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