![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to library.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx|
Return to library.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)library.c 5.2 (Berkeley) 1/12/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: library.c,v 1.2 87/03/25 20:50:14 donn Exp $";
12:
13: /*
14: * General purpose routines.
15: */
16:
17: #include <stdio.h>
18: #include <errno.h>
19: #include <signal.h>
20:
21: #define public
22: #define private static
23: #define and &&
24: #define or ||
25: #define not !
26: #define ord(enumcon) ((int) enumcon)
27: #define nil(type) ((type) 0)
28:
29: typedef int integer;
30: typedef enum { FALSE, TRUE } boolean;
31: typedef char *String;
32: typedef FILE *File;
33: typedef String Filename;
34:
35: #undef FILE
36:
37: String cmdname; /* name of command for error messages */
38: Filename errfilename; /* current file associated with error */
39: short errlineno; /* line number associated with error */
40:
41: /*
42: * Definitions for doing memory allocation.
43: */
44:
45: extern char *malloc();
46:
47: #define alloc(n, type) ((type *) malloc((unsigned) (n) * sizeof(type)))
48: #define dispose(p) { free((char *) p); p = 0; }
49:
50: /*
51: * Macros for doing freads + fwrites.
52: */
53:
54: #define get(fp, var) fread((char *) &(var), sizeof(var), 1, fp)
55: #define put(fp, var) fwrite((char *) &(var), sizeof(var), 1, fp)
56:
57: /*
58: * String definitions.
59: */
60:
61: extern String strcpy(), index(), rindex();
62: extern int strlen();
63:
64: #define strdup(s) strcpy(malloc((unsigned) strlen(s) + 1), s)
65: #define streq(s1, s2) (strcmp(s1, s2) == 0)
66:
67: typedef int IntFunc();
68:
69: IntFunc *onsyserr();
70:
71: typedef struct {
72: IntFunc *func;
73: } ErrInfo;
74:
75: #define ERR_IGNORE ((IntFunc *) 0)
76: #define ERR_CATCH ((IntFunc *) 1)
77:
78: /*
79: * Call a program.
80: *
81: * Four entries:
82: *
83: * call, callv - call a program and wait for it, returning status
84: * back, backv - call a program and don't wait, returning process id
85: *
86: * The command's standard input and output are passed as FILE's.
87: */
88:
89:
90: #define MAXNARGS 1000 /* unchecked upper limit on max num of arguments */
91: #define BADEXEC 127 /* exec fails */
92:
93: #define ischild(pid) ((pid) == 0)
94:
95: /* VARARGS3 */
96: public int call(name, in, out, args)
97: String name;
98: File in;
99: File out;
100: String args;
101: {
102: String *ap, *argp;
103: String argv[MAXNARGS];
104:
105: argp = &argv[0];
106: *argp++ = name;
107: ap = &args;
108: while (*ap != nil(String)) {
109: *argp++ = *ap++;
110: }
111: *argp = nil(String);
112: return callv(name, in, out, argv);
113: }
114:
115: /* VARARGS3 */
116: public int back(name, in, out, args)
117: String name;
118: File in;
119: File out;
120: String args;
121: {
122: String *ap, *argp;
123: String argv[MAXNARGS];
124:
125: argp = &argv[0];
126: *argp++ = name;
127: ap = &args;
128: while (*ap != nil(String)) {
129: *argp++ = *ap++;
130: }
131: *argp = nil(String);
132: return backv(name, in, out, argv);
133: }
134:
135: public int callv(name, in, out, argv)
136: String name;
137: File in;
138: File out;
139: String *argv;
140: {
141: int pid, status;
142:
143: pid = backv(name, in, out, argv);
144: pwait(pid, &status);
145: return status;
146: }
147:
148: public int backv(name, in, out, argv)
149: String name;
150: File in;
151: File out;
152: String *argv;
153: {
154: int pid;
155:
156: fflush(stdout);
157: if (ischild(pid = fork())) {
158: fswap(0, fileno(in));
159: fswap(1, fileno(out));
160: onsyserr(EACCES, ERR_IGNORE);
161: execvp(name, argv);
162: _exit(BADEXEC);
163: }
164: return pid;
165: }
166:
167: /*
168: * Swap file numbers so as to redirect standard input and output.
169: */
170:
171: private fswap(oldfd, newfd)
172: int oldfd;
173: int newfd;
174: {
175: if (oldfd != newfd) {
176: close(oldfd);
177: dup(newfd);
178: close(newfd);
179: }
180: }
181:
182: /*
183: * Invoke a shell on a command line.
184: */
185:
186: #define DEF_SHELL "csh"
187:
188: public shell(s)
189: String s;
190: {
191: extern String getenv();
192: String sh;
193:
194: if ((sh = getenv("SHELL")) == nil(String)) {
195: sh = DEF_SHELL;
196: }
197: if (s != nil(String) and *s != '\0') {
198: call(sh, stdin, stdout, "-c", s, 0);
199: } else {
200: call(sh, stdin, stdout, 0);
201: }
202: }
203:
204: /*
205: * Wait for a process the right way. We wait for a particular
206: * process and if any others come along in between, we remember them
207: * in case they are eventually waited for.
208: *
209: * This routine is not very efficient when the number of processes
210: * to be remembered is large.
211: *
212: * To deal with a kernel idiosyncrasy, we keep a list on the side
213: * of "traced" processes, and do not notice them when waiting for
214: * another process.
215: */
216:
217: typedef struct pidlist {
218: int pid;
219: int status;
220: struct pidlist *next;
221: } Pidlist;
222:
223: private Pidlist *pidlist, *ptrclist, *pfind();
224:
225: public ptraced(pid)
226: int pid;
227: {
228: Pidlist *p;
229:
230: p = alloc(1, Pidlist);
231: p->pid = pid;
232: p->next = ptrclist;
233: ptrclist = p;
234: }
235:
236: public unptraced(pid)
237: int pid;
238: {
239: register Pidlist *p, *prev;
240:
241: prev = nil(Pidlist *);
242: p = ptrclist;
243: while (p != nil(Pidlist *) and p->pid != pid) {
244: prev = p;
245: p = p->next;
246: }
247: if (p != nil(Pidlist *)) {
248: if (prev == nil(Pidlist *)) {
249: ptrclist = p->next;
250: } else {
251: prev->next = p->next;
252: }
253: dispose(p);
254: }
255: }
256:
257: private boolean isptraced(pid)
258: int pid;
259: {
260: register Pidlist *p;
261:
262: p = ptrclist;
263: while (p != nil(Pidlist *) and p->pid != pid) {
264: p = p->next;
265: }
266: return (boolean) (p != nil(Pidlist *));
267: }
268:
269: public pwait(pid, statusp)
270: int pid, *statusp;
271: {
272: Pidlist *p;
273: int pnum, status;
274:
275: p = pfind(pid);
276: if (p != nil(Pidlist *)) {
277: *statusp = p->status;
278: dispose(p);
279: } else {
280: pnum = wait(&status);
281: while (pnum != pid and pnum >= 0) {
282: if (not isptraced(pnum)) {
283: p = alloc(1, Pidlist);
284: p->pid = pnum;
285: p->status = status;
286: p->next = pidlist;
287: pidlist = p;
288: }
289: pnum = wait(&status);
290: }
291: if (pnum < 0) {
292: p = pfind(pid);
293: if (p == nil(Pidlist *)) {
294: panic("pwait: pid %d not found", pid);
295: }
296: *statusp = p->status;
297: dispose(p);
298: } else {
299: *statusp = status;
300: }
301: }
302: }
303:
304: /*
305: * Look for the given process id on the pidlist.
306: *
307: * Unlink it from list if found.
308: */
309:
310: private Pidlist *pfind(pid)
311: int pid;
312: {
313: register Pidlist *p, *prev;
314:
315: prev = nil(Pidlist *);
316: for (p = pidlist; p != nil(Pidlist *); p = p->next) {
317: if (p->pid == pid) {
318: break;
319: }
320: prev = p;
321: }
322: if (p != nil(Pidlist *)) {
323: if (prev == nil(Pidlist *)) {
324: pidlist = p->next;
325: } else {
326: prev->next = p->next;
327: }
328: }
329: return p;
330: }
331:
332: /*
333: * System call error handler.
334: *
335: * The syserr routine is called when a system call is about to
336: * set the c-bit to report an error. Certain errors are caught
337: * and cause the process to print a message and immediately exit.
338: */
339:
340: extern int sys_nerr;
341: extern char *sys_errlist[];
342:
343: /*
344: * Before calling syserr, the integer errno is set to contain the
345: * number of the error. The routine "_mycerror" is a dummy which
346: * is used to force the loader to get my version of cerror rather
347: * than the usual one.
348: */
349:
350: extern int errno;
351: extern _mycerror();
352:
353: /*
354: * Initialize error information, setting defaults for handling errors.
355: */
356:
357: private ErrInfo *errinfo;
358:
359: private initErrInfo ()
360: {
361: integer i;
362:
363: errinfo = alloc(sys_nerr, ErrInfo);
364: for (i = 0; i < sys_nerr; i++) {
365: errinfo[i].func = ERR_CATCH;
366: }
367: errinfo[0].func = ERR_IGNORE;
368: errinfo[EPERM].func = ERR_IGNORE;
369: errinfo[ENOENT].func = ERR_IGNORE;
370: errinfo[ESRCH].func = ERR_IGNORE;
371: errinfo[EBADF].func = ERR_IGNORE;
372: errinfo[ENOTTY].func = ERR_IGNORE;
373: errinfo[EOPNOTSUPP].func = ERR_IGNORE;
374: }
375:
376: public syserr()
377: {
378: register ErrInfo *e;
379:
380: if (errno < 0 or errno > sys_nerr) {
381: fatal("errno %d", errno);
382: } else {
383: if (errinfo == nil(ErrInfo *)) {
384: initErrInfo();
385: }
386: e = &(errinfo[errno]);
387: if (e->func == ERR_CATCH) {
388: fatal(sys_errlist[errno]);
389: } else if (e->func != ERR_IGNORE) {
390: (*e->func)();
391: }
392: }
393: }
394:
395: /*
396: * Catcherrs' purpose is to initialize the errinfo table, get this module
397: * loaded, and make sure my cerror is loaded (only applicable when this is
398: * in a library).
399: */
400:
401: public catcherrs()
402: {
403: _mycerror();
404: initErrInfo();
405: }
406:
407: /*
408: * Turn off the error catching mechanism completely by having all errors
409: * ignored. This is most useful between a fork and an exec.
410: */
411:
412: public nocatcherrs()
413: {
414: integer i;
415:
416: for (i = 0; i < sys_nerr; i++) {
417: errinfo[i].func = ERR_IGNORE;
418: }
419: }
420:
421: /*
422: * Change the action on receipt of an error, returning the previous action.
423: */
424:
425: public IntFunc *onsyserr(n, f)
426: int n;
427: IntFunc *f;
428: {
429: IntFunc *oldf;
430:
431: if (errinfo == nil(ErrInfo *)) {
432: initErrInfo();
433: }
434: oldf = errinfo[n].func;
435: errinfo[n].func = f;
436: return oldf;
437: }
438:
439: /*
440: * Print the message associated with the given signal.
441: * Like a "perror" for signals.
442: */
443:
444: #ifdef SIGWINCH
445: public int sys_nsig = NSIG;
446: #else not 4.3 BSD
447: /*
448: * This table is correct for 4.2-like systems but will
449: * be inadequate for System V (which is the sort of
450: * Unix that needs it!).
451: */
452: public String sys_siglist[] = {
453: "no signal",
454: "hangup",
455: "interrupt",
456: "quit",
457: "illegal instruction",
458: "trace trap",
459: "IOT instruction",
460: "EMT instruction",
461: "floating point exception",
462: "kill",
463: "bus error",
464: "segmentation violation",
465: "bad argument to system call",
466: "broken pipe",
467: "alarm clock",
468: "soft kill",
469: "urgent I/O condition",
470: "stop signal not from tty",
471: "stop signal from tty",
472: "continue",
473: "child termination",
474: "stop (tty input)",
475: "stop (tty output)",
476: "possible input/output",
477: "exceeded CPU time limit",
478: "exceeded file size limit"
479: };
480: public int sys_nsig = sizeof sys_siglist / sizeof sys_siglist[0];
481: #endif
482:
483: public psignal(s, n)
484: String s;
485: integer n;
486: {
487: String msg;
488: integer len;
489: extern String sys_siglist[];
490:
491: if (n >= 0 and n < sys_nsig) {
492: msg = sys_siglist[n];
493: } else {
494: msg = "Unknown signal";
495: }
496: len = strlen(s);
497: if (len > 0) {
498: write(2, s, len);
499: write(2, ": ", 2);
500: }
501: write(2, msg, strlen(msg));
502: write(2, "\n", 1);
503: }
504:
505: /*
506: * Standard error handling routines.
507: */
508:
509: private short nerrs;
510: private short nwarnings;
511:
512: /*
513: * Main driver of error message reporting.
514: */
515:
516: /* VARARGS2 */
517: private errmsg(errname, shouldquit, s, a, b, c, d, e, f, g, h, i, j, k, l, m)
518: String errname;
519: boolean shouldquit;
520: String s;
521: {
522: fflush(stdout);
523: if (shouldquit and cmdname != nil(String)) {
524: fprintf(stderr, "%s: ", cmdname);
525: }
526: if (errfilename != nil(Filename)) {
527: fprintf(stderr, "%s: ", errfilename);
528: }
529: if (errlineno > 0) {
530: fprintf(stderr, "%d: ", errlineno);
531: }
532: if (errname != nil(String)) {
533: fprintf(stderr, "%s: ", errname);
534: }
535: fprintf(stderr, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
536: putc('\n', stderr);
537: fflush(stderr);
538: if (shouldquit) {
539: quit(1);
540: }
541: }
542:
543: /*
544: * For when printf isn't sufficient for printing the error message ...
545: */
546:
547: public beginerrmsg()
548: {
549: fflush(stdout);
550: if (errfilename != nil(String)) {
551: fprintf(stderr, "%s: ", errfilename);
552: }
553: if (errlineno > 0) {
554: fprintf(stderr, "%d: ", errlineno);
555: }
556: }
557:
558: public enderrmsg()
559: {
560: putc('\n', stderr);
561: fflush(stderr);
562: erecover();
563: }
564:
565: /*
566: * The messages are listed in increasing order of seriousness.
567: *
568: * First are warnings.
569: */
570:
571: /* VARARGS1 */
572: public warning(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
573: String s;
574: {
575: nwarnings++;
576: errmsg("warning", FALSE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
577: }
578:
579: /*
580: * Errors are a little worse, they mean something is wrong,
581: * but not so bad that processing can't continue.
582: *
583: * The routine "erecover" is called to recover from the error,
584: * a default routine is provided that does nothing.
585: */
586:
587: /* VARARGS1 */
588: public error(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
589: String s;
590: {
591: extern erecover();
592:
593: nerrs++;
594: errmsg(nil(String), FALSE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
595: erecover();
596: }
597:
598: /*
599: * Non-recoverable user error.
600: */
601:
602: /* VARARGS1 */
603: public fatal(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
604: String s;
605: {
606: errmsg("fatal error", TRUE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
607: }
608:
609: /*
610: * Panics indicate an internal program error.
611: */
612:
613: /* VARARGS1 */
614: public panic(s, a, b, c, d, e, f, g, h, i, j, k, l, m)
615: String s;
616: {
617: errmsg("internal error", TRUE, s, a, b, c, d, e, f, g, h, i, j, k, l, m);
618: }
619:
620: short numerrors()
621: {
622: short r;
623:
624: r = nerrs;
625: nerrs = 0;
626: return r;
627: }
628:
629: short numwarnings()
630: {
631: short r;
632:
633: r = nwarnings;
634: nwarnings = 0;
635: return r;
636: }
637:
638: /*
639: * Recover from an error.
640: *
641: * This is the default routine which we aren't using since we have our own.
642: *
643: public erecover()
644: {
645: }
646: *
647: */
648:
649: /*
650: * Default way to quit from a program is just to exit.
651: *
652: public quit(r)
653: int r;
654: {
655: exit(r);
656: }
657: *
658: */
659:
660: /*
661: * Compare n-byte areas pointed to by s1 and s2
662: * if n is 0 then compare up until one has a null byte.
663: */
664:
665: public int cmp(s1, s2, n)
666: register char *s1, *s2;
667: register unsigned int n;
668: {
669: if (s1 == nil(char *) || s2 == nil(char *)) {
670: panic("cmp: nil pointer");
671: }
672: if (n == 0) {
673: while (*s1 == *s2++) {
674: if (*s1++ == '\0') {
675: return(0);
676: }
677: }
678: return(*s1 - *(s2-1));
679: } else {
680: for (; n != 0; n--) {
681: if (*s1++ != *s2++) {
682: return(*(s1-1) - *(s2-1));
683: }
684: }
685: return(0);
686: }
687: }
688:
689: /*
690: * Move n bytes from src to dest.
691: * If n is 0 move until a null is found.
692: */
693:
694: public mov(src, dest, n)
695: register char *src, *dest;
696: register unsigned int n;
697: {
698: if (src == nil(char *))
699: panic("mov: nil source");
700: if (dest == nil(char *))
701: panic("mov: nil destination");
702: if (n != 0) {
703: for (; n != 0; n--) {
704: *dest++ = *src++;
705: }
706: } else {
707: while ((*dest++ = *src++) != '\0');
708: }
709: }
710:
711: #ifdef IRIS /* or in general for 4.2 - System V C library interface */
712:
713: public bcopy (fromaddr, toaddr, n)
714: char *fromaddr, *toaddr;
715: int n;
716: {
717: blt(toaddr, fromaddr, n);
718: }
719:
720: public bzero (addr, n)
721: char *addr;
722: int n;
723: {
724: register char *p, *q;
725:
726: p = addr;
727: q = p + n;
728: while (p < q) {
729: *p++ = '\0';
730: }
731: }
732:
733: #include <string.h>
734:
735: public char *index (s, c)
736: char *s, c;
737: {
738: return strchr(s, c);
739: }
740:
741: public char *rindex (s, c)
742: char *s, c;
743: {
744: return strrchr(s, c);
745: }
746:
747: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.