![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / m4|
Return to m4.c CVS log | Up to [Research Unix] / researchv10dc / cmd / m4 |
1.1 root 1: #include <stdio.h>
2: #include <signal.h>
3: #include "m4.h"
4:
5: #define match(c,s) (c==*s && (!s[1] || inpmatch(s+1)))
6:
7: char *xcalloc();
8:
9:
10: main(argc,argv)
11: char **argv;
12: {
13: register t;
14:
15: {
16: static sigs[] = {SIGHUP, SIGINT, SIGPIPE, 0};
17: for (t=0; sigs[t]; ++t)
18: if (signal(sigs[t], SIG_IGN) != SIG_IGN)
19: signal(sigs[t],catchsig);
20: }
21:
22: tempname = mktemp("/tmp/m4aXXXXXX");
23: close(creat(tempname,0));
24:
25: procnam = argv[0];
26: getflags(&argc,&argv);
27: initalloc();
28:
29: setfname("-");
30: if (argc>1) {
31: --argc;
32: ++argv;
33: if (strcmp(argv[0],"-")) {
34: ifile[ifx] = xfopen(argv[0],"r");
35: setfname(argv[0]);
36: }
37: }
38:
39: for (;;) {
40: token[0] = t = getchr();
41: token[1] = EOS;
42:
43: if (t==EOF) {
44: if (ifx > 0) {
45: fclose(ifile[ifx]);
46: ipflr = ipstk[--ifx];
47: continue;
48: }
49:
50: getflags(&argc,&argv);
51:
52: if (argc<=1)
53: if (Wrapstr) {
54: pbstr(Wrapstr);
55: Wrapstr = NULL;
56: continue;
57: } else
58: break;
59:
60: --argc;
61: ++argv;
62:
63: if (ifile[ifx]!=stdin)
64: fclose(ifile[ifx]);
65:
66: if (*argv[0]=='-')
67: ifile[ifx] = stdin;
68: else
69: ifile[ifx] = xfopen(argv[0],"r");
70:
71: setfname(argv[0]);
72: continue;
73: }
74:
75: if (isalpha(t)) {
76: register char *tp = token+1;
77: register tlim = toksize;
78:
79: while (alphanum(*tp++=getchr()))
80: if (--tlim<=0)
81: error2("more than %d chars in word",
82: toksize);
83:
84: putbak(*--tp);
85: *tp = EOS;
86:
87: if (((struct nlist *)(*((struct nlist **)Ap)=lookup(token)))->def) {
88: if (++Ap >= astklm) {
89: --Ap;
90: error2(astkof,stksize);
91: }
92:
93: if (Cp++==NULL)
94: Cp = callst;
95:
96: Cp->argp = Ap;
97: *Ap++ = op;
98: puttok(token);
99: stkchr(EOS);
100: t = getchr();
101: putbak(t);
102:
103: if (t!='(')
104: pbstr("()");
105: else /* try to fix arg count */
106: *Ap++ = op;
107:
108: Cp->plev = 0;
109: } else {
110: puttok(token);
111: }
112: } else if (match(t,lquote)) {
113: register qlev = 1;
114:
115: for (;;) {
116: token[0] = t = getchr();
117: token[1] = EOS;
118:
119: if (match(t,rquote)) {
120: if (--qlev > 0)
121: puttok(token);
122: else
123: break;
124: } else if (match(t,lquote)) {
125: ++qlev;
126: puttok(token);
127: } else {
128: if (t==EOF)
129: error("EOF in quote");
130:
131: putchr(t);
132: }
133: }
134: } else if (match(t,lcom)) {
135: puttok(token);
136:
137: for (;;) {
138: token[0] = t = getchr();
139: token[1] = EOS;
140:
141: if (match(t,rcom)) {
142: puttok(token);
143: break;
144: } else {
145: if (t==EOF)
146: error("EOF in comment");
147: putchr(t);
148: }
149: }
150: } else if (Cp==NULL) {
151: putchr(t);
152: } else if (t=='(') {
153: if (Cp->plev)
154: stkchr(t);
155: else {
156: /* skip white before arg */
157: while (isspace(t=getchr()))
158: ;
159:
160: putbak(t);
161: }
162:
163: ++Cp->plev;
164: } else if (t==')') {
165: --Cp->plev;
166:
167: if (Cp->plev==0) {
168: stkchr(EOS);
169: expand(Cp->argp,Ap-Cp->argp-1);
170: op = *Cp->argp;
171: Ap = Cp->argp-1;
172:
173: if (--Cp < callst)
174: Cp = NULL;
175: } else
176: stkchr(t);
177: } else if (t==',' && Cp->plev<=1) {
178: stkchr(EOS);
179: *Ap = op;
180:
181: if (++Ap >= astklm) {
182: --Ap;
183: error2(astkof,stksize);
184: }
185:
186: while (isspace(t=getchr()))
187: ;
188:
189: putbak(t);
190: } else
191: stkchr(t);
192: }
193:
194: if (Cp!=NULL)
195: error("EOF in argument list");
196:
197: delexit(OK);
198: }
199:
200: char *
201: inpmatch(s)
202: register char *s;
203: {
204: register char *tp = token+1;
205:
206: while (*s) {
207: *tp = getchr();
208:
209: if (*tp++ != *s++) {
210: *tp = EOS;
211: pbstr(token+1);
212: return 0;
213: }
214: }
215:
216: *tp = EOS;
217: return token;
218: }
219:
220: getflags(xargc,xargv)
221: register int *xargc;
222: register char ***xargv;
223: {
224: while (*xargc > 1) {
225: register char *arg = (*xargv)[1];
226:
227: if (arg[0]!='-' || arg[1]==EOS)
228: break;
229:
230: switch (arg[1]) {
231: case 'B':
232: bufsize = atoi(&arg[2]);
233: break;
234: case 'D':
235: {
236: register char *t;
237: char *s[2];
238:
239: initalloc();
240:
241: for (t = s[0] = &arg[2]; *t; t++)
242: if (*t=='=') {
243: *t++ = EOS;
244: break;
245: }
246:
247: s[1] = t;
248: dodef(&s[-1],2);
249: break;
250: }
251: case 'H':
252: hshsize = atoi(&arg[2]);
253: break;
254: case 'S':
255: stksize = atoi(&arg[2]);
256: break;
257: case 'T':
258: toksize = atoi(&arg[2]);
259: break;
260: case 'U':
261: {
262: char *s[1];
263:
264: initalloc();
265: s[0] = &arg[2];
266: doundef(&s[-1],1);
267: break;
268: }
269: case 'e':
270: setbuf(stdout,NULL);
271: signal(SIGINT,SIG_IGN);
272: break;
273: case 's':
274: /* turn on line sync */
275: sflag = 1;
276: break;
277: default:
278: fprintf(stderr,"%s: bad option: %s\n",
279: procnam,arg);
280: delexit(NOT_OK);
281: }
282:
283: (*xargv)++;
284: --(*xargc);
285: }
286:
287: return;
288: }
289:
290: initalloc()
291: {
292: static done = 0;
293: register t;
294:
295: if (done++)
296: return;
297:
298: hshtab = (struct nlist **)xcalloc(hshsize,sizeof(struct nlist *));
299: callst = (struct call *)xcalloc(stksize/3+1,sizeof(struct call));
300: Ap = argstk = (char **)xcalloc(stksize+3,sizeof(char *));
301: ipstk[0] = ipflr = ip = ibuf = xcalloc(bufsize+1,sizeof(char));
302: op = obuf = xcalloc(bufsize+1,sizeof(char));
303: token = xcalloc(toksize+1,sizeof(char));
304:
305: astklm = &argstk[stksize];
306: ibuflm = &ibuf[bufsize];
307: obuflm = &obuf[bufsize];
308: toklm = &token[toksize];
309:
310: for (t=0; barray[t].bname; ++t) {
311: static char p[2] = {0, EOS};
312:
313: p[0] = t|~LOW7;
314: install(barray[t].bname,p,NOPUSH);
315: }
316:
317: install("unix",nullstr,NOPUSH);
318: }
319:
320: /*struct nlist * */
321: install(nam,val,mode)
322: char *nam;
323: register char *val;
324: {
325: register struct nlist *np;
326: register char *cp;
327: int l;
328:
329: if (mode==PUSH)
330: lookup(nam); /* lookup sets hshval */
331: else
332: while (undef(nam)) /* undef calls lookup */
333: ;
334:
335: np = (struct nlist *)xcalloc(1,sizeof(*np));
336: np->name = copy(nam);
337: np->next = hshtab[hshval];
338: hshtab[hshval] = np;
339:
340: cp = xcalloc((l=strlen(val))+1,sizeof(*val));
341: np->def = cp;
342: cp = &cp[l];
343:
344: while (*val)
345: *--cp = *val++;
346: }
347:
348: struct nlist *
349: lookup(str)
350: char *str;
351: {
352: register char *s1, *s2;
353: register struct nlist *np;
354: static struct nlist nodef;
355:
356: s1 = str;
357:
358: for (hshval = 0; *s1; )
359: hshval += *s1++;
360:
361: hshval %= hshsize;
362:
363: for (np = hshtab[hshval]; np!=NULL; np = np->next) {
364: s1 = str;
365: s2 = np->name;
366: while (*s1++==*s2)
367: if (*s2++==EOS)
368: return(np);
369: }
370:
371: return(&nodef);
372: }
373:
374: expand(a1,c)
375: char **a1;
376: {
377: register char *dp;
378: register struct nlist *sp;
379:
380: sp = (struct nlist *)a1[-1];
381:
382: if (sp->tflag || trace) {
383: int i;
384:
385: fprintf(stderr,"Trace(%d): %s",Cp-callst,a1[0]);
386:
387: if (c > 0) {
388: fprintf(stderr,"(%s",chkbltin(a1[1]));
389: for (i=2; i<=c; ++i)
390: fprintf(stderr,",%s",chkbltin(a1[i]));
391: fprintf(stderr,")");
392: }
393:
394: fprintf(stderr,"\n");
395: }
396:
397: dp = sp->def;
398:
399: for (; *dp; ++dp) {
400: if (*dp&~LOW7) {
401: (*barray[*dp&LOW7].bfunc)(a1,c);
402: } else if (dp[1]=='$') {
403: if (isdigit(*dp)) {
404: register n;
405: if ((n = *dp-'0') <= c)
406: pbstr(a1[n]);
407: ++dp;
408: } else if (*dp=='#') {
409: pbnum((long) c);
410: ++dp;
411: } else if (*dp=='*' || *dp=='@') {
412: register i = c;
413: char **a = a1;
414:
415: if (i > 0)
416: for (;;) {
417: if (*dp=='@')
418: pbstr(rquote);
419:
420: pbstr(a[i--]);
421:
422: if (*dp=='@')
423: pbstr(lquote);
424:
425: if (i <= 0)
426: break;
427:
428: pbstr(",");
429: }
430: ++dp;
431: } else
432: putbak(*dp);
433: } else
434: putbak(*dp);
435: }
436: }
437:
438: setfname(s)
439: register char *s;
440: {
441: strcpy(fname[ifx],s);
442: fname[ifx+1] = fname[ifx]+strlen(s)+1;
443: fline[ifx] = 1;
444: nflag = 1;
445: lnsync(stdout);
446: }
447:
448: lnsync(iop)
449: register FILE *iop;
450: {
451: static int cline = 0;
452: static int cfile = 0;
453:
454: if (!sflag || iop!=stdout)
455: return;
456:
457: if (nflag || ifx!=cfile) {
458: nflag = 0;
459: cfile = ifx;
460: fprintf(iop,"#line %d \"",cline = fline[ifx]);
461: fpath(iop);
462: fprintf(iop,"\"\n");
463: } else if (++cline != fline[ifx])
464: fprintf(iop,"#line %d\n",cline = fline[ifx]);
465: }
466:
467: fpath(iop)
468: register FILE *iop;
469: {
470: register i;
471:
472: fprintf(iop,"%s",fname[0]);
473:
474: for (i=1; i<=ifx; ++i)
475: fprintf(iop,":%s",fname[i]);
476: }
477:
478: catchsig()
479: {
480: signal(SIGHUP,SIG_IGN);
481: signal(SIGINT,SIG_IGN);
482:
483: delexit(NOT_OK);
484: }
485:
486: delexit(code)
487: {
488: register i;
489:
490: cf = stdout;
491:
492: /* if (ofx != 0) { /* quitting in middle of diversion */
493: /* ofx = 0;
494: /* code = NOT_OK;
495: /* }
496: */
497: ofx = 0; /* ensure that everything comes out */
498: for (i=1; i<10; i++)
499: undiv(i,code);
500:
501: tempname[7] = 'a';
502: unlink(tempname);
503:
504: if (code==OK)
505: exit(code);
506:
507: _exit(code);
508: }
509:
510: puttok(tp)
511: register char *tp;
512: {
513: if (Cp) {
514: while (*tp)
515: stkchr(*tp++);
516: } else if (cf)
517: while (*tp)
518: sputchr(*tp++,cf);
519: }
520:
521: pbstr(str)
522: register char *str;
523: {
524: register char *p;
525:
526: p = str;
527:
528: while (*p++)
529: ;
530:
531: --p;
532:
533: while (p > str)
534: putbak(*--p);
535: }
536:
537: undiv(i,code)
538: register i;
539: {
540: register FILE *fp;
541: register c;
542:
543: if (i<1 || i>9 || i==ofx || !ofile[i])
544: return;
545:
546: fclose(ofile[i]);
547: tempname[7] = 'a'+i;
548:
549: if (code==OK && cf) {
550: fp = xfopen(tempname,"r");
551:
552: while ((c=getc(fp)) != EOF)
553: sputchr(c,cf);
554:
555: fclose(fp);
556: }
557:
558: unlink(tempname);
559: ofile[i] = NULL;
560: }
561:
562: char *copy(s)
563: register char *s;
564: {
565: register char *p, *s1;
566:
567: p = s1 = xcalloc(strlen(s)+1,1);
568:
569: while (*s1++ = *s++)
570: ;
571:
572: return(p);
573: }
574:
575: pbnum(num)
576: long num;
577: {
578: pbnbr(num,10,1);
579: }
580:
581: pbnbr(nbr,base,len)
582: long nbr;
583: register base, len;
584: {
585: register neg = 0;
586:
587: if (base<=0)
588: return;
589:
590: if (nbr<0) {
591: neg = 1;
592: nbr = -nbr;
593: }
594:
595: while (nbr>0) {
596: int i;
597: if (base>1) {
598: i = nbr%base;
599: nbr /= base;
600: } else {
601: i = 1;
602: --nbr;
603: }
604: putbak(itochr(i));
605: --len;
606: }
607:
608: while (--len >= 0)
609: putbak('0');
610:
611: if (neg)
612: putbak('-');
613: }
614:
615: itochr(i)
616: register i;
617: {
618: if (i>9)
619: return i-10+'A';
620: else
621: return i+'0';
622: }
623:
624: long ctol(str)
625: register char *str;
626: {
627: register sign;
628: long num;
629:
630: while (isspace(*str))
631: ++str;
632: num = 0;
633: if (*str=='-') {
634: sign = -1;
635: ++str;
636: }
637: else
638: sign = 1;
639: while (isdigit(*str))
640: num = num*10 + *str++ - '0';
641: return(sign * num);
642: }
643:
644: min(a,b)
645: {
646: if (a>b)
647: return(b);
648: return(a);
649: }
650:
651: FILE *
652: xfopen(name,mode)
653: char *name,
654: *mode;
655: {
656: FILE *fp;
657:
658: if ((fp=fopen(name,mode))==NULL)
659: error(badfile);
660:
661: return fp;
662: }
663:
664: char *
665: xcalloc(nbr,size)
666: {
667: register char *ptr;
668:
669: if ((ptr=calloc(nbr,size)) == NULL)
670: error(nocore);
671:
672: return ptr;
673: }
674:
675: error(str)
676: char *str;
677: {
678: fprintf(stderr,"\n%s:",procnam);
679: fpath(stderr);
680: fprintf(stderr,":%d %s\n",fline[ifx],str);
681: if (Cp) {
682: register struct call *mptr;
683:
684: /* fix limit */
685: *op = EOS;
686: (Cp+1)->argp = Ap+1;
687:
688: for (mptr=callst; mptr<=Cp; ++mptr) {
689: register char **aptr, **lim;
690:
691: aptr = mptr->argp;
692: lim = (mptr+1)->argp-1;
693: if (mptr==callst)
694: fputs(*aptr,stderr);
695: ++aptr;
696: fputs("(",stderr);
697: if (aptr < lim)
698: for (;;) {
699: fputs(*aptr++,stderr);
700: if (aptr >= lim)
701: break;
702: fputs(",",stderr);
703: }
704: }
705: while (--mptr >= callst)
706: fputs(")",stderr);
707:
708: fputs("\n",stderr);
709: }
710: delexit(NOT_OK);
711: }
712:
713: error2(str,num)
714: char *str;
715: int num;
716: {
717: char buf[500];
718:
719: fprintf(buf,str,num);
720: error(buf);
721: }
722:
723: char *
724: chkbltin(s)
725: char *s;
726: {
727: static char buf[24];
728:
729: if (*s&~LOW7) {
730: sprintf(buf,"<%s>",barray[*s&LOW7].bname);
731: return buf;
732: }
733: return s;
734: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.