![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm|
Return to misc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm |
1.1 root 1: /*
2: * $Source: /orpheus/u1/X11/clients/xterm/RCS/misc.c,v $
3: * $Header: misc.c,v 1.29 87/09/10 18:09:03 swick Exp $
4: */
5:
6:
7: #include <X11/copyright.h>
8:
9: /*
10: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
11: *
12: * All Rights Reserved
13: *
14: * Permission to use, copy, modify, and distribute this software and its
15: * documentation for any purpose and without fee is hereby granted,
16: * provided that the above copyright notice appear in all copies and that
17: * both that copyright notice and this permission notice appear in
18: * supporting documentation, and that the name of Digital Equipment
19: * Corporation not be used in advertising or publicity pertaining to
20: * distribution of the software without specific, written prior permission.
21: *
22: *
23: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
29: * SOFTWARE.
30: */
31:
32: #include <stdio.h>
33: #include <setjmp.h>
34: #include <signal.h>
35: #include <ctype.h>
36: #include <pwd.h>
37: #include <strings.h>
38: #include <X11/Xlib.h>
39: #include <X11/Xutil.h>
40: #include <X11/Xatom.h>
41: #include <X11/Xtlib.h>
42: #include "ptyx.h"
43: #include "data.h"
44: #include "error.h"
45: #include <X11/cursorfont.h>
46: #include "gray.ic"
47: #include "hilite.ic"
48: #include "wait.ic"
49: #include "waitmask.ic"
50:
51: extern char *malloc();
52: extern char *mktemp();
53: extern void exit();
54: extern void perror();
55: extern void abort();
56:
57: #ifndef lint
58: static char rcs_id[] = "$Header: misc.c,v 1.29 87/09/10 18:09:03 swick Exp $";
59: #endif lint
60:
61: xevents()
62: {
63: XEvent event;
64: register TScreen *screen = &term.screen;
65: XtEventReturnCode returnCode;
66:
67: if(screen->scroll_amt)
68: FlushScroll(screen);
69: XPending (screen->display);
70: do {
71: if (waitingForTrackInfo)
72: return;
73: XNextEvent (screen->display, &event);
74: returnCode = XtDispatchEvent(&event);
75: switch (returnCode) {
76: case XteventHandled :
77: break;
78: case XteventNotHandled :
79: /* |||
80: fprintf(stderr, "Event %d not handled for window %d (subwindow %d)\n",
81: (int)event.type, (int)event.window, (int)event.subwindow);
82: */
83: break;
84: case XteventNoHandler :
85: /* |||
86: fprintf(stderr, "Event %d no entry for window %d (subwindow %d)\n",
87: (int)event.type, (int)event.window, (int)event.subwindow);
88: */
89: break;
90: }
91: } while (QLength(screen->display) > 0);
92: }
93:
94: /*ARGSUSED*/
95: XtEventReturnCode EventDoNothing(event, eventdata)
96: XEvent *event;
97: caddr_t eventdata;
98: {
99: return (XteventHandled);
100: }
101:
102: /*ARGSUSED*/
103: XtEventReturnCode HandleKeyPressed(event, eventdata)
104: XEvent *event;
105: caddr_t eventdata;
106: {
107: Input (&term.keyboard, &term.screen, (XKeyPressedEvent *)event);
108: return (XteventHandled);
109: }
110: /*ARGSUSED*/
111: XtEventReturnCode HandleEnterWindow(event, eventdata)
112: register XEnterWindowEvent *event;
113: caddr_t eventdata;
114: {
115: register TScreen *screen = &term.screen;
116:
117: if (((event->detail) != NotifyInferior)
118: && event->mode == NotifyNormal
119: && event->focus) {
120: #ifdef DEBUG
121: if(debug)
122: fprintf(stderr, "EnterWindow %s\n", window ==
123: VWindow(screen) ? "VT" : "Tek");
124: #endif DEBUG
125: selectwindow(screen, INWINDOW);
126: }
127: return (XteventHandled);
128: }
129:
130: /*ARGSUSED*/
131: XtEventReturnCode HandleLeaveWindow(event, eventdata)
132: register XEnterWindowEvent *event;
133: caddr_t eventdata;
134: {
135: register TScreen *screen = &term.screen;
136:
137: if (((event->detail) != NotifyInferior)
138: && event->mode == NotifyNormal
139: && event->focus) {
140: #ifdef DEBUG
141: if(debug)
142: fprintf(stderr, "LeaveWindow %s\n", window ==
143: VWindow(screen) ? "VT" : "Tek");
144: #endif DEBUG
145: unselectwindow(screen, INWINDOW);
146: }
147: return (XteventHandled);
148: }
149:
150:
151: /*ARGSUSED*/
152: XtEventReturnCode HandleFocusChange(event, eventdata)
153: register XFocusChangeEvent *event;
154: caddr_t eventdata;
155: {
156: register TScreen *screen = &term.screen;
157:
158: if(event->type == FocusIn)
159: selectwindow(screen, FOCUS);
160: else
161: unselectwindow(screen, FOCUS);
162: return (XteventHandled);
163: }
164:
165:
166:
167: selectwindow(screen, flag)
168: register TScreen *screen;
169: register int flag;
170: {
171: if(screen->TekEmu) {
172: TekSelect();
173: if(!Ttoggled)
174: TCursorToggle(TOGGLE);
175: if(screen->cellsused) {
176: screen->colorcells[2].pixel =
177: screen->Tcursorcolor;
178: XStoreColor(screen->display,
179: DefaultColormap(screen->display,
180: DefaultScreen(screen->display)),
181: &screen->colorcells[2]);
182: }
183: screen->select |= flag;
184: if(!Ttoggled)
185: TCursorToggle(TOGGLE);
186: return;
187: } else {
188: VTSelect();
189: if(screen->cursor_state &&
190: (screen->cursor_col != screen->cur_col ||
191: screen->cursor_row != screen->cur_row))
192: HideCursor();
193: screen->select |= flag;
194: if(screen->cursor_state)
195: ShowCursor();
196: return;
197: }
198: }
199:
200: unselectwindow(screen, flag)
201: register TScreen *screen;
202: register int flag;
203: {
204: register int i;
205:
206: screen->select &= ~flag;
207: if(!(screen->select)) {
208: if(screen->TekEmu) {
209: TekUnselect();
210: if(!Ttoggled)
211: TCursorToggle(TOGGLE);
212: if(screen->cellsused) {
213: i = (term.flags & REVERSE_VIDEO) == 0;
214: screen->colorcells[i].pixel =
215: screen->Tcursorcolor;
216: XStoreColor(screen->display,
217: DefaultColormap(screen->display,
218: DefaultScreen(screen->display)),
219: &screen->colorcells[i]);
220: }
221: if(!Ttoggled)
222: TCursorToggle(TOGGLE);
223: } else {
224: VTUnselect();
225: if(screen->cursor_state &&
226: (screen->cursor_col != screen->cur_col ||
227: screen->cursor_row != screen->cur_row))
228: HideCursor();
229: if(screen->cursor_state)
230: ShowCursor();
231: }
232: }
233: }
234:
235: reselectwindow(screen)
236: register TScreen *screen;
237: {
238: Window root, win;
239: int rootx, rooty, x, y;
240: unsigned int mask;
241:
242: if(XQueryPointer(
243: screen->display,
244: DefaultRootWindow(screen->display),
245: &root, &win,
246: &rootx, &rooty,
247: &x, &y,
248: &mask)) {
249: if(win && (win == VWindow(screen) || win == TWindow(screen)))
250: selectwindow(screen, INWINDOW);
251: else unselectwindow(screen, INWINDOW);
252: }
253: }
254:
255: Pixmap Make_tile(width, height, bits, foreground, background, depth)
256: unsigned int width, height, depth;
257: Pixel foreground, background;
258: char *bits;
259: {
260: register GC gc;
261: register Pixmap pix;
262: register TScreen *screen = &term.screen;
263: XGCValues gcVals;
264: XImage tileimage;
265: GC XtGetGC();
266:
267: pix = (Pixmap)XCreatePixmap(screen->display,
268: DefaultRootWindow(screen->display), width, height, depth);
269: gcVals.foreground = foreground;
270: gcVals.background = background;
271: gc = XCreateGC(screen->display, (Drawable) pix,
272: GCForeground+GCBackground, &gcVals);
273: tileimage.height = height;
274: tileimage.width = width;
275: tileimage.xoffset = 0;
276: tileimage.format = XYBitmap;
277: tileimage.data = bits;
278: tileimage.byte_order = LSBFirst;
279: tileimage.bitmap_unit = 8;
280: tileimage.bitmap_bit_order = LSBFirst;
281: tileimage.bitmap_pad = 8;
282: tileimage.bytes_per_line = (width+7)>>3;
283: tileimage.depth = 1;
284: XPutImage(screen->display, pix, gc, &tileimage, 0, 0, 0, 0, width, height);
285: /* done with gc */
286: return(pix);
287: }
288:
289:
290: Pixmap make_gray(fg, bg, depth)
291: Pixel fg, bg;
292: {
293: return(Make_tile(gray_width, gray_height, gray_bits, fg, bg, depth));
294: }
295:
296: /* ARGSUSED */
297: Cursor make_tcross(fg, bg)
298: Pixel fg, bg;
299: {
300: register TScreen *screen = &term.screen;
301: Cursor c;
302:
303: c = XCreateFontCursor(screen->display, XC_tcross);
304: /*
305: XRecolorCursor(screen->display, c, PixelToColor(fg), PixelToColor(bg));
306: */
307: return(c);
308: }
309:
310: /* ARGSUSED */
311: Cursor make_xterm(fg, bg)
312: unsigned long fg, bg;
313: {
314: register TScreen *screen = &term.screen;
315: Cursor c;
316:
317: c = XCreateFontCursor(screen->display, XC_xterm);
318: /*
319: XRecolorCursor(screen->display, c, PixelToColor(fg), PixelToColor(bg));
320: */
321: return(c);
322: }
323:
324: static XColor foreground = { 0L, 65535, 65535, 65535 };
325: static XColor background = { 0L, 0, 0, 0 };
326:
327: Cursor make_wait(fg, bg)
328: Pixel fg, bg;
329: {
330: register TScreen *screen = &term.screen;
331: Pixmap source, mask;
332:
333: source = Make_tile(wait_width, wait_height, wait_bits, fg, bg, 1);
334: mask = Make_tile(waitmask_width, waitmask_height, waitmask_bits,
335: fg, bg, 1);
336: /*
337: return(XCreatePixmapCursor(screen->display, source, mask, PixelToColor(fg),
338: PixelToColor(bg), wait_x_hot, wait_y_hot));
339: */
340: return(XCreatePixmapCursor(screen->display, source, mask,
341: &foreground, &background, wait_x_hot, wait_y_hot));
342: }
343:
344: /* ARGSUSED */
345: Cursor make_arrow(fg, bg)
346: unsigned long fg, bg;
347:
348: {
349: register TScreen *screen = &term.screen;
350: Cursor c;
351:
352: c = XCreateFontCursor(screen->display, XC_left_ptr);
353: /*
354: XRecolorCursor(screen->display, c, PixelToColor(fg), PixelToColor(bg));
355: */
356: return(c);
357: }
358:
359: char *uniquesuffix(name)
360: char *name;
361: {
362: register int *np, *fp, i;
363: register Window *cp;
364: register int temp, j, k, exact, *number;
365: char *wname;
366: Window *children, parent, root;
367: unsigned int nchildren;
368: static char *suffix, sufbuf[10];
369: TScreen *screen = &term.screen;
370: char *malloc();
371:
372: if(suffix)
373: return(suffix);
374: suffix = sufbuf;
375: if(!XQueryTree(
376: screen->display,
377: DefaultRootWindow(screen->display),
378: &root, &parent,
379: &children, &nchildren) ||
380: nchildren < 1 || (number = (int *)malloc((unsigned)nchildren * sizeof(int)))
381: == NULL)
382: return(suffix);
383: exact = FALSE;
384: i = strlen(name);
385: for(np = number, cp = children, j = nchildren ; j > 0 ; cp++, j--) {
386: if(!XFetchName(screen->display, *cp, &wname) || wname == NULL)
387: continue;
388: if(strncmp(name, wname, i) == 0) {
389: if(wname[i] == 0 || XStrCmp(&wname[i], " (Tek)") == 0)
390: exact = TRUE;
391: else if(strncmp(&wname[i], " #", 2) == 0)
392: *np++ = atoi(&wname[i + 2]);
393: }
394: free(wname);
395: }
396: free((char *)children);
397: if(exact) {
398: if(np <= number)
399: strcpy(suffix, " #2");
400: else {
401: exact = np - number;
402: np = number;
403: /* shell sort */
404: for(i = exact / 2 ; i > 0 ; i /= 2)
405: for(k = i ; k < exact ; k++)
406: for(j = k - i ; j >= 0 &&
407: np[j] > np[j + i] ; j -= i) {
408: temp = np[j];
409: np[j] = np[j + i];
410: np[j + i] = temp;
411: }
412: /* make numbers unique */
413: for(fp = np + 1, i = exact - 1 ; i > 0 ; fp++, i--)
414: if(*fp != *np)
415: *++np = *fp;
416: /* find least unique number */
417: for(i = 2, fp = number ; fp <= np ; fp++) {
418: if(i < *fp)
419: break;
420: if(i == *fp)
421: i++;
422: }
423: sprintf(suffix, " #%d", i);
424: }
425: }
426: free((char *)number);
427: return(suffix);
428: }
429:
430: Bell()
431: {
432: extern Terminal term;
433: register TScreen *screen = &term.screen;
434: register Pixel xorPixel = screen->foreground ^ screen->background;
435: XGCValues gcval;
436: GC visualGC;
437:
438: if(screen->visualbell) {
439: gcval.function = GXxor;
440: gcval.foreground = xorPixel;
441: visualGC = XtGetGC(screen->display, (XContext)NULL,
442: DefaultRootWindow(screen->display),
443: GCFunction+GCForeground, &gcval);
444: if(screen->TekEmu) {
445: XFillRectangle(
446: screen->display,
447: TWindow(screen),
448: visualGC,
449: 0, 0,
450: (unsigned) TFullWidth(screen),
451: (unsigned) TFullHeight(screen));
452: XFlush(screen->display);
453: XFillRectangle(
454: screen->display,
455: TWindow(screen),
456: visualGC,
457: 0, 0,
458: (unsigned) TFullWidth(screen),
459: (unsigned) TFullHeight(screen));
460: } else {
461: XFillRectangle(
462: screen->display,
463: VWindow(screen),
464: visualGC,
465: 0, 0,
466: (unsigned) FullWidth(screen),
467: (unsigned) FullHeight(screen));
468: XFlush(screen->display);
469: XFillRectangle(
470: screen->display,
471: VWindow(screen),
472: visualGC,
473: 0, 0,
474: (unsigned) FullWidth(screen),
475: (unsigned) FullHeight(screen));
476: }
477: } else
478: XBell(screen->display, 0);
479: }
480:
481: Redraw()
482: {
483: extern Terminal term;
484: register TScreen *screen = &term.screen;
485: XExposeEvent event;
486:
487: event.type = Expose;
488: event.display = screen->display;
489: event.x = 0;
490: event.y = 0;
491: event.width = DisplayWidth(
492: screen->display, DefaultScreen(screen->display));
493: event.height =DisplayHeight(
494: screen->display, DefaultScreen(screen->display));
495: event.count = 0;
496:
497: if(VWindow(screen)) {
498: extern XtEventReturnCode VTExpose();
499:
500: event.window = VWindow(screen);
501: (void) VTExpose(&event, (caddr_t)NULL);
502: if(screen->scrollbar) {
503: RedrawScrollBar(screen->scrollWindow);
504: }
505: }
506: if(TWindow(screen) && screen->Tshow) {
507: event.window = TWindow(screen);
508: TekExpose(&event);
509: }
510: }
511:
512: SyncUnmap(win, mask)
513: register Window win;
514: register long int mask;
515: {
516: XEvent ev;
517: register XEvent *rep = &ev;
518: register TScreen *screen = &term.screen;
519:
520: do { /* ignore events through unmap */
521: XWindowEvent(screen->display, win, mask, rep);
522: } while(rep->type != UnmapNotify);
523: }
524:
525: StartLog(screen)
526: register TScreen *screen;
527: {
528: register char *cp;
529: register int i;
530: static char *log_default;
531: char *malloc(), *rindex();
532: extern logpipe();
533:
534: if(screen->logging || (screen->inhibit & I_LOG))
535: return;
536: if(screen->logfile == NULL || *screen->logfile == 0) {
537: if(screen->logfile)
538: free(screen->logfile);
539: if(log_default == NULL)
540: mktemp(log_default = log_def_name);
541: if((screen->logfile = malloc((unsigned)strlen(log_default) + 1)) == NULL)
542: return;
543: strcpy(screen->logfile, log_default);
544: }
545: if(*screen->logfile == '|') { /* exec command */
546: int p[2];
547: static char *shell;
548:
549: if(pipe(p) < 0 || (i = fork()) < 0)
550: return;
551: if(i == 0) { /* child */
552: close(p[1]);
553: dup2(p[0], 0);
554: close(p[0]);
555: dup2(fileno(stderr), 1);
556: dup2(fileno(stderr), 2);
557: close(fileno(stderr));
558: fileno(stderr) = 2;
559: close(screen->display->fd);
560: close(screen->respond);
561: if(!shell) {
562: register struct passwd *pw;
563: char *getenv(), *malloc();
564: struct passwd *getpwuid();
565:
566: if(((cp = getenv("SHELL")) == NULL || *cp == 0)
567: && ((pw = getpwuid(screen->uid)) == NULL ||
568: *(cp = pw->pw_shell) == 0) ||
569: (shell = malloc((unsigned) strlen(cp) + 1)) == NULL)
570: shell = "/bin/sh";
571: else
572: strcpy(shell, cp);
573: }
574: signal(SIGHUP, SIG_DFL);
575: signal(SIGCHLD, SIG_DFL);
576: setgid(screen->gid);
577: setuid(screen->uid);
578: execl(shell, shell, "-c", &screen->logfile[1], 0);
579: fprintf(stderr, "%s: Can't exec `%s'\n", xterm_name,
580: &screen->logfile[1]);
581: exit(ERROR_LOGEXEC);
582: }
583: close(p[0]);
584: screen->logfd = p[1];
585: signal(SIGPIPE, logpipe);
586: } else {
1.1.1.2 ! root 587: if(access(screen->logfile, 0) == 0) {
! 588: if(access(screen->logfile, 2) < 0)
1.1 root 589: return;
590: } else if(cp = rindex(screen->logfile, '/')) {
591: *cp = 0;
1.1.1.2 ! root 592: i = access(screen->logfile, 2);
1.1 root 593: *cp = '/';
594: if(i < 0)
595: return;
1.1.1.2 ! root 596: } else if(access(".", 2) < 0)
1.1 root 597: return;
1.1.1.2 ! root 598: if (access(screen->logfile, 0) == 0) {
! 599: if ((screen->logfd = open(screen->logfile, 1)) < 0)
! 600: return;
! 601: lseek(screen->logfd, 0, 2);
! 602: }
! 603: else if((screen->logfd = creat(screen->logfile, 0644)) < 0)
1.1 root 604: return;
605: chown(screen->logfile, screen->uid, screen->gid);
606:
607: }
608: screen->logstart = screen->TekEmu ? Tbptr : bptr;
609: screen->logging = TRUE;
610: }
611:
612: CloseLog(screen)
613: register TScreen *screen;
614: {
615: if(!screen->logging || (screen->inhibit & I_LOG))
616: return;
617: FlushLog(screen);
618: close(screen->logfd);
619: screen->logging = FALSE;
620: }
621:
622: FlushLog(screen)
623: register TScreen *screen;
624: {
625: register char *cp;
626: register int i;
627:
628: cp = screen->TekEmu ? Tbptr : bptr;
629: if((i = cp - screen->logstart) > 0)
630: write(screen->logfd, screen->logstart, i);
631: screen->logstart = screen->TekEmu ? Tbuffer : buffer;
632: }
633:
634: logpipe()
635: {
636: register TScreen *screen = &term.screen;
637:
638: if(screen->logging)
639: CloseLog(screen);
640: }
641:
642:
643: do_osc(func)
644: int (*func)();
645: {
646: register TScreen *screen = &term.screen;
647: register int mode, c;
648: register char *cp;
649: char buf[512];
650: extern char *malloc();
651:
652: mode = 0;
653: while(isdigit(c = (*func)()))
654: mode = 10 * mode + (c - '0');
655: cp = buf;
656: while(isprint(c = (*func)()))
657: *cp++ = c;
658: *cp = 0;
659: switch(mode) {
660: case 0: /* new icon name and title*/
661: Changename(buf);
662: Changetitle(buf);
663: break;
664:
665: case 1: /* new icon name only */
666: Changename(buf);
667: break;
668:
669: case 2: /* new title only */
670: Changetitle(buf);
671: break;
672:
673:
674: case 46: /* new log file */
675: if((cp = malloc((unsigned)strlen(buf) + 1)) == NULL)
676: break;
677: strcpy(cp, buf);
678: if(screen->logfile)
679: free(screen->logfile);
680: screen->logfile = cp;
681: break;
682: }
683: }
684:
685: Changename(name)
686: register char *name;
687: {
688: register TScreen *screen = &term.screen;
689:
690: free(screen->iconname);
691: if((screen->iconname =
692: malloc((unsigned)(screen->iconnamelen = strlen(name)) + 1)) == NULL)
693: Error(ERROR_CNMALLOC1);
694: strcpy(screen->iconname, name);
695: if(screen->fullVwin.window) {
696: XChangeProperty(
697: screen->display,
698: VWindow(screen),
699: XA_WM_ICON_NAME, XA_STRING,
700: 8, PropModeReplace,
701: (unsigned char *)name, screen->iconnamelen);
702: }
703: if(screen->fullTwin.window) {
704: free(screen->Ticonname);
705: if((screen->Ticonname = malloc((unsigned)(screen->Ticonnamelen =
706: screen->iconnamelen + 6) + 1)) == NULL)
707: Error(ERROR_CNMALLOC2);
708: strcpy(screen->Ticonname, name);
709: strcat(screen->Ticonname, " (Tek)");
710: XChangeProperty(
711: screen->display,
712: VWindow(screen),
713: XA_WM_ICON_NAME, XA_STRING, 8, PropModeReplace,
714: (unsigned char *)screen->Ticonname, screen->Ticonnamelen);
715: }
716: }
717:
718: Changetitle(name)
719: register char *name;
720: {
721: register TScreen *screen = &term.screen;
722:
723: free(screen->titlename);
724: if((screen->titlename =
725: malloc((unsigned)(screen->titlenamelen = strlen(name)) + 1)) == NULL)
726: Error(ERROR_CNMALLOC1);
727: strcpy(screen->titlename, name);
728: if(screen->fullVwin.window) {
729: XStoreName(screen->display, VWindow(screen), name);
730: }
731: if(screen->fullTwin.window) {
732: free(screen->Ttitlename);
733: if((screen->Ttitlename = malloc((unsigned)(screen->Ttitlenamelen =
734: screen->titlenamelen + 6) + 1)) == NULL)
735: Error(ERROR_CNMALLOC2);
736: strcpy(screen->Ttitlename, name);
737: strcat(screen->Ttitlename, " (Tek)");
738: XStoreName(screen->display, TWindow(screen), screen->Ttitlename);
739: }
740: }
741:
742: #ifndef DEBUG
743: /* ARGSUSED */
744: #endif
745: Panic(s, a)
746: char *s;
747: int a;
748: {
749: #ifdef DEBUG
750: if(debug) {
751: fprintf(stderr, "%s: PANIC! ", xterm_name);
752: fprintf(stderr, s, a);
753: fputs("\r\n", stderr);
754: fflush(stderr);
755: }
756: #endif DEBUG
757: }
758:
759: SysError (i)
760: int i;
761: {
762: fprintf (stderr, "%s: Error %d, errno %d:\n", xterm_name, i, errno);
763: perror ("");
764: Cleanup(i);
765: }
766:
767: Error (i)
768: int i;
769: {
770: fprintf (stderr, "%s: Error %d\n", xterm_name, i);
771: Cleanup(i);
772: }
773:
774: /*
775: * cleanup by sending SIGHUP to client processes
776: */
777: Cleanup (code)
778: int code;
779: {
780: #ifdef notdef
781: extern Terminal term;
782: register TScreen *screen;
783:
784: screen = &term.screen;
785: if (screen->pid > 1)
1.1.1.2 ! root 786: kill(-getpgrp(screen->pid), SIGHUP);
1.1 root 787: #endif
788: Exit (code);
789: }
790:
791: /*
792: * sets the value of var to be arg in the Unix 4.2 BSD environment env.
793: * Var should end with '=' (bindings are of the form "var=value").
794: * This procedure assumes the memory for the first level of environ
795: * was allocated using calloc, with enough extra room at the end so not
796: * to have to do a realloc().
797: */
798: Setenv (var, value)
799: register char *var, *value;
800: {
801: extern char **environ;
802: register int index = 0;
803: register int len = strlen(var);
804:
805: while (environ [index] != NULL) {
806: if (strncmp (environ [index], var, len) == 0) {
807: /* found it */
808: environ[index] = (char *)malloc ((unsigned)len + strlen (value) + 1);
809: strcpy (environ [index], var);
810: strcat (environ [index], value);
811: return;
812: }
813: index ++;
814: }
815:
816: #ifdef DEBUG
817: if (debug) fputs ("expanding env\n", stderr);
818: #endif DEBUG
819:
820: environ [index] = (char *) malloc ((unsigned)len + strlen (value) + 1);
821: (void) strcpy (environ [index], var);
822: strcat (environ [index], value);
823: environ [++index] = NULL;
824: }
825:
826: /*
827: * returns a pointer to the first occurrence of s2 in s1,
828: * or NULL if there are none.
829: */
830: char *strindex (s1, s2)
831: register char *s1, *s2;
832: {
833: register char *s3;
834: char *index();
835:
836: while ((s3=index(s1, *s2)) != NULL) {
837: if (strncmp(s3, s2, strlen(s2)) == 0)
838: return (s3);
839: s1 = ++s3;
840: }
841: return (NULL);
842: }
843:
844: /*ARGSUSED*/
845: xerror(d, ev)
846: Display *d;
847: register XErrorEvent *ev;
848: {
849: char buffer[BUFSIZ];
850: XGetErrorText(d, ev->error_code, buffer, BUFSIZ);
851: fprintf(stderr, "%s: %s\n", xterm_name, buffer);
852: fprintf(stderr, "Request code %d, minor code %d, serial #%ld, resource id %ld\n",
853: ev->request_code, ev->minor_code, ev->serial, (long)ev->resourceid);
854: _cleanup();
855: abort();
856: /* Exit(ERROR_XERROR); */
857: }
858:
859: /*ARGSUSED*/
860: xioerror(d)
861: Display *d;
862: {
863: perror(xterm_name);
864: Exit(ERROR_XIOERROR);
865: }
866:
867: XStrCmp(s1, s2)
868: char *s1, *s2;
869: {
870: if (s1 && s2) return(strcmp(s1, s2));
871: if (s1 && *s1) return(1);
872: if (s2 && *s2) return(-1);
873: return(0);
874: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.