![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cpp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / parse|
Return to cpp.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / parse |
1.1 noro 1: /* $OpenXM: OpenXM/src/asir99/parse/cpp.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */
2: #if defined(__MWERKS__)
3: #define THINK_C
4: #endif
5:
6: #include <stdio.h>
7: #include <ctype.h>
8: #include <setjmp.h>
9: jmp_buf cpp_env;
10:
11: #if 0
12: #include "accum.h"
13: #include "expr.h"
14: #include "if.h"
15: #include "io.h"
16: #include "is.h"
17: #include "malloc.h"
18: #include "stats.h"
19: #include "symtbl.h"
20: #include "unctrl.h"
21: #endif
22:
23: #if defined(THINK_C)
24: #include <string.h>
25:
26: int define(char *,int,unsigned char *,int);
27: void Bcopy(char *,char *,int);
28: #endif
29:
30:
31: #include "cpp.h"
32:
33: char *init_accum(void)
34: {
35: ACCUM *a;
36:
37: a = NEW(ACCUM);
38: check_malloc(a);
39: a->used = 0;
40: a->have = 8;
41: a->buf = malloc(8);
42: check_malloc(a->buf);
43: return((char *)a);
44: }
45:
46: void accum_char(char *A, char c)
47:
48: #define a ((ACCUM *)A)
49:
50: {
51: while (a->used >= a->have)
52: { a->buf = realloc(a->buf,a->have+=8);
53: check_malloc(a->buf);
54: }
55: a->buf[a->used++] = c;
56: }
57: #undef a
58:
59: char accum_regret(char *A)
60:
61: #define a ((ACCUM *)A)
62: {
63: if (a->used > 0)
64: { return(a->buf[--a->used]);
65: }
66: else
67: { return(0);
68: }
69: }
70: #undef a
71:
72: char *accum_result(char *A)
73:
74: #define a ((ACCUM *)A)
75: {
76: char *cp;
77:
78: cp = realloc(a->buf,a->used+1);
79: check_malloc(cp);
80: cp[a->used] = '\0';
81: OLD(a);
82: return(cp);
83: }
84: #undef a
85:
86: char *accum_sofar(char *A)
87:
88: #define a ((ACCUM *)A)
89: {
90: char *cp;
91:
92: cp = malloc(a->used+1);
93: check_malloc(cp);
94: Bcopy(a->buf,cp,a->used);
95: cp[a->used] = '\0';
96: return(cp);
97: }
98: #undef a
99:
100: char *accum_buf(char *A)
101:
102: #define a ((ACCUM *)A)
103: {
104: return(a->buf);
105: }
106: #undef a
107:
108: int accum_howfar(char *A)
109:
110: #define a ((ACCUM *)A)
111: {
112: return(a->used);
113: }
114: #undef a
115:
116: void do_at(void)
117: {
118: char *w;
119:
120: w = read_ctrl();
121: if (strcmp(w,"include") == 0)
122: { do_include(0);
123: }
124: else if (strcmp(w,"define") == 0)
125: { do_define(0,0);
126: }
127: else if (strcmp(w,"undef") == 0)
128: { do_undef(0);
129: }
130: else if (strcmp(w,"redefine") == 0)
131: { do_define(0,1);
132: }
133: else if (strcmp(w,"ifdef") == 0)
134: { do_ifdef(0);
135: }
136: else if (strcmp(w,"ifndef") == 0)
137: { do_ifndef(0);
138: }
139: else if (strcmp(w,"if") == 0)
140: { do_if(0);
141: }
142: else if (strcmp(w,"else") == 0)
143: { do_else(0);
144: }
145: else if (strcmp(w,"elif") == 0)
146: { do_elif(0);
147: }
148: else if (strcmp(w,"endif") == 0)
149: { do_endif(0);
150: }
151: else if (strcmp(w,"set") == 0)
152: { do_set();
153: }
154: else if (strcmp(w,"while") == 0)
155: { do_while();
156: }
157: else if (strcmp(w,"endwhile") == 0)
158: { do_endwhile();
159: }
160: else if (strcmp(w,"dump") == 0)
161: { do_dump();
162: }
163: else if (strcmp(w,"debug") == 0)
164: { do_debug();
165: }
166: else if (strcmp(w,"eval") == 0)
167: { do_eval();
168: }
169: else
170: { if (! in_false_if())
171: { err_head();
172: fprintf(stderr,"unknown control `%s'\n",w);
173: }
174: }
175: free(w);
176: }
177:
178: static char *temp;
179:
180: void autodef_file(char *f)
181: {
182: int i;
183:
184: i = strlen(f);
185: temp = malloc(i+2+1);
186: check_malloc(temp);
187: sprintf(temp,"\"%s\"",f);
188: undef("__FILE__");
189: define("__FILE__",-1,(unsigned char *)temp,0);
190: }
191:
192: void autodef_line(int l)
193: {
194: defd("__LINE__",l);
195: }
196:
197: char *copyofstr(char *str)
198: {
199: char *cp;
200:
201: if (str == 0)
202: { return(0);
203: }
204: cp = malloc(strlen(str)+1);
205: if (cp == 0)
206: { return(0);
207: }
208: strcpy(cp,str);
209: return(cp);
210: }
211:
212: char *copyofblk(char *blk, int len)
213: {
214: char *cp;
215:
216: if (blk == 0)
217: { return(0);
218: }
219: cp = malloc(len);
220: if (cp == 0)
221: { return(0);
222: }
223: Bcopy(blk,cp,len);
224: return(cp);
225: }
226:
227: /* these really don't beint here; they should be in their own file */
228:
229: #if 0
230: char *malloc(nb)
231: #undef malloc
232: int nb;
233: {
234: extern char *malloc();
235:
236: return(malloc(nb?nb:1));
237: }
238:
239: char *realloc(old,nb)
240: #undef realloc
241: char *old;
242: int nb;
243: {
244: extern char *realloc();
245:
246: return(realloc(old,(nb?nb:1)));
247: }
248: #endif
249:
250: static char buf[BUFSIZ];
251:
252: int debugging = 0;
253:
254: void do_debug(void)
255: {
256: char c;
257:
258: fflush(outfile);
259: c = getnonspace();
260: switch (c)
261: { case '1':
262: case 'y':
263: case 'Y':
264: debugging = 1;
265: break;
266: default:
267: debugging = 0;
268: break;
269: }
270: setbuf(outfile,debugging?NULL:buf);
271: }
272:
273: static int nargs;
274: static int nfound;
275: static char **argnames;
276:
277: void read_formals(void)
278: {
279: char *arg;
280: char c;
281:
282: nargs = 0;
283: argnames = (char **) malloc(1);
284: check_malloc(argnames);
285: while (1)
286: { arg = read_ident();
287: if (arg)
288: { argnames = (char **) realloc((char *)argnames,(nargs+1)*sizeof(char *));
289: check_malloc(argnames);
290: argnames[nargs] = arg;
291: nargs ++;
292: c = getnonspace();
293: if (c == ')')
294: { return;
295: }
296: else if (c != ',')
297: { err_head();
298: fprintf(stderr,"invalid macro parameter delimiter\n");
299: }
300: }
301: else
302: { c = Get();
303: if ((c == ')') && (nargs == 0))
304: { return;
305: }
306: else
307: { Push(c);
308: }
309: err_head();
310: fprintf(stderr,"missing/illegal macro parameter\n");
311: while (1)
312: { c = Get();
313: if (c == ')')
314: { return;
315: }
316: if (isbsymchar(c))
317: { Push(c);
318: break;
319: }
320: }
321: }
322: }
323: }
324:
325: void do_define(int sharp, int redef)
326: {
327: char *mac;
328: char c;
329: char *acc;
330: unsigned char *repl;
331: int quoted;
332: int incomment;
333: unsigned char *f;
334: unsigned char *t;
335: unsigned char *g;
336: int i;
337:
338: if (in_false_if())
339: { char e = '\0';
340: if (sharp)
341: { while (1)
342: { c = e;
343: e = Get();
344: if (e == '\n')
345: { if (c == '\\')
346: { maybe_print('\n');
347: }
348: else
349: { break;
350: }
351: }
352: }
353: }
354: else
355: { do
356: { c = e;
357: e = Get();
358: } while ((c != '@') || (e == '@'));
359: Push(e);
360: }
361: return;
362: }
363: mac = read_ident();
364: if (! mac)
365: { err_head();
366: fprintf(stderr,"missing/illegal macro name\n");
367: flush_sharp_line();
368: return;
369: }
370: c = Get();
371: if (c == '(')
372: { read_formals();
373: nfound = nargs;
374: if (nargs > 128)
375: { err_head();
376: fprintf(stderr,"too many macro formals, more than 128 ignored\n");
377: nargs = 128;
378: }
379: }
380: else
381: { argnames = 0;
382: nargs = -1;
383: nfound = -1;
384: if ((c != ' ') && (c != '\t'))
385: { Push(c);
386: }
387: }
388: quoted = 0;
389: incomment = 0;
390: acc = init_accum();
391: if (sharp)
392: { while (1)
393: { c = Get();
394: if (quoted && (c == '\n'))
395: { quoted = 0;
396: maybe_print('\n');
397: }
398: else if (quoted)
399: { accum_char(acc,'\\');
400: accum_char(acc,c);
401: quoted = 0;
402: }
403: else if (c == '/')
404: { char d = Get();
405: accum_char(acc,'/');
406: if (d == '*')
407: { accum_char(acc,'*');
408: incomment = 1;
409: }
410: else
411: { Push(d);
412: }
413: }
414: else if (incomment)
415: { accum_char(acc,c);
416: if (c == '*')
417: { char d = Get();
418: if (d == '/')
419: { accum_char(acc,'/');
420: incomment = 0;
421: }
422: else
423: { Push(d);
424: }
425: }
426: else if (c == '\n')
427: { maybe_print('\n');
428: }
429: }
430: else if (c == '\\')
431: { quoted = 1;
432: }
433: else if (c == '\n')
434: { break;
435: }
436: else
437: { accum_char(acc,c);
438: }
439: }
440: }
441: else
442: { while (1)
443: { c = Get();
444: if (quoted && (c == '@'))
445: { accum_char(acc,'@');
446: quoted = 0;
447: }
448: else if (quoted)
449: { Push(c);
450: break;
451: }
452: else if (c == '/')
453: { char d = Get();
454: accum_char(acc,'/');
455: if (d == '*')
456: { accum_char(acc,'*');
457: incomment = 1;
458: }
459: else
460: { Push(d);
461: }
462: }
463: else if (incomment)
464: { accum_char(acc,c);
465: if (c == '*')
466: { char d = Get();
467: if (d == '/')
468: { accum_char(acc,'/');
469: incomment = 0;
470: }
471: else
472: { Push(d);
473: }
474: }
475: else if (c == '\n')
476: { maybe_print('\n');
477: }
478: }
479: else if (c == '@')
480: { quoted = 1;
481: }
482: else
483: { if (c == '\n')
484: { maybe_print('\n');
485: }
486: accum_char(acc,c);
487: }
488: }
489: }
490: repl = (unsigned char *) accum_result(acc);
491: f = repl;
492: t = repl;
493: while (*f)
494: { if (isbsymchar(*f) && !incomment)
495: { for (g=f;issymchar(*g);g++) ;
496: c = *g;
497: *g = '\0';
498: for (i=0;i<nargs;i++)
499: { if (strcmp((char *)f,argnames[i]) == 0)
500: { break;
501: }
502: }
503: if (i < nargs)
504: { *t++ = 0x80 | i;
505: f = g;
506: }
507: else
508: { while (*t++ = *f++) ;
509: f --;
510: t --;
511: }
512: *g = c;
513: }
514: else if ((f[0] == '/') && (f[1] == '*'))
515: { f += 2;
516: *t++ = '/';
517: *t++ = '*';
518: incomment = 1;
519: }
520: else if (incomment && (f[0] == '*') && (f[1] == '/'))
521: { f += 2;
522: *t++ = '*';
523: *t++ = '/';
524: incomment = 0;
525: }
526: else
527: { *t++ = *f++;
528: }
529: }
530: *t++ = '\0';
531: repl = (unsigned char *) realloc((char *)repl,t-repl);
532: check_malloc(repl);
533: if (redef)
534: { undef(mac);
535: }
536: n_defines ++;
537: define(mac,nargs,repl,DEF_DEFINE);
538: if (argnames)
539: { for (i=0;i<nfound;i++)
540: { free(argnames[i]);
541: }
542: free((char *)argnames);
543: }
544: free(mac);
545: }
546:
547: void do_dump(void)
548: {
549: int i;
550: DEF *d;
551: extern char *cur_incldir;
552: extern char *incldir[];
553: extern int fstackdepth;
554:
555: fprintf(stderr,
556: "\n\n\tDump of definition table (%d entries in %d buckets):\n\n",
557: n_in_table,symtbl_size);
558: for (i=0;i<symtbl_size;i++)
559: { fprintf(stderr,"Bucket %d:\n",i);
560: for (d=symtbl[i];d;d=d->link)
561: { dump_single(d);
562: putc('\n',stderr);
563: }
564: }
565: fprintf(stderr,"\n\tInclude directory stack:\n\n");
566: for (i=0;i<fstackdepth;i++)
567: { fprintf(stderr,"\t\t%s\n",incldir[i]);
568: }
569: fprintf(stderr,"\t\t%s\n",cur_incldir);
570: }
571:
572: void dump_single(DEF *d)
573: {
574: unsigned char *cp;
575:
576: fprintf(stderr,"\t%s",d->name);
577: if (d->nargs == 0)
578: { fprintf(stderr,"()");
579: }
580: else if (d->nargs > 0)
581: { int i;
582: for (i=0;i<d->nargs;i++)
583: { fprintf(stderr,"%c#%d",i?',':'(',i);
584: }
585: putc(')',stderr);
586: }
587: putc(' ',stderr);
588: for (cp=d->repl;*cp;cp++)
589: { if (*cp & 0x80)
590: { fprintf(stderr,"#%d",(*cp)&~0x80);
591: }
592: else
593: { putc(*cp,stderr);
594: }
595: }
596: }
597:
598: void err_head(void)
599: {
600: fprintf(stderr,"\"%s\", line %d: ",curfile(),curline());
601: }
602:
603: void Check_malloc(char *ptr)
604: {
605: if (ptr == 0)
606: { fprintf(stderr,"out of memory!\n");
607: abort();
608: }
609: }
610:
611: void do_eval(void)
612: {
613: char c;
614: char temp[64];
615: int i;
616:
617: if (! in_false_if())
618: { c = getnonspace();
619: if (c != '(')
620: { err_head();
621: fprintf(stderr,"@eval must have ()s\n");
622: Push(c);
623: return;
624: }
625: sprintf(temp,"%d",eval_expr(0,1));
626: for (i=strlen(temp)-1;i>=0;i--)
627: { Push(temp[i]);
628: }
629: }
630: }
631:
632: #define DEBUG_EXPAND/**/
633:
634: #ifdef DEBUG_EXPAND
635: extern int debugging;
636: #endif
637:
638: extern int keep_comments;
639:
640: static char **actuals;
641: static int *actlens;
642:
643: void read_actuals(DEF *d)
644: {
645: int n;
646: int i;
647: int pc;
648: char c;
649: char last;
650: char quote;
651: int backslash;
652: int comment;
653: char *acc;
654:
655: n = d->nargs;
656: actuals = (char **) malloc(n*sizeof(char *));
657: check_malloc(actuals);
658: actlens = (int *) malloc(n*sizeof(int));
659: check_malloc(actlens);
660: c = getnonspace();
661: if (c != '(')
662: { err_head();
663: if (n == 0)
664: { fprintf(stderr,"missing () on %s\n",d->name);
665: }
666: else
667: { fprintf(stderr,"missing argument%s to %s\n",(n==1)?"":"s",d->name);
668: }
669: for (i=0;i<n;i++)
670: { actuals[i] = copyofstr("");
671: check_malloc(actuals[i]);
672: actlens[i] = 0;
673: }
674: Push(c);
675: return;
676: }
677: if (n == 0)
678: { c = getnonspace();
679: if (c != ')')
680: { err_head();
681: fprintf(stderr,"unwanted argument to %s\n",d->name);
682: Push(c);
683: }
684: return;
685: }
686: i = 0;
687: while (1)
688: { pc = 0;
689: quote = 0;
690: backslash = 0;
691: comment = 0;
692: c = 0;
693: acc = init_accum();
694: while (1)
695: { last = c;
696: c = Get();
697: accum_char(acc,c);
698: if (comment)
699: { if ((last == '*') && (c == '/'))
700: { comment = 0;
701: }
702: }
703: else
704: { if (backslash)
705: { backslash = 0;
706: }
707: else if (quote && (c == quote))
708: { quote = 0;
709: }
710: else if (c == '\\')
711: { backslash = 1;
712: }
713: else if (quote)
714: {
715: }
716: else if ((last == '/') && (c == '*'))
717: { comment = 1;
718: }
719: else if ((c == '\'') || (c == '"'))
720: { quote = c;
721: }
722: else if (c == '(')
723: { pc ++;
724: }
725: else if (c == ')')
726: { if (pc > 0)
727: { pc --;
728: }
729: else
730: { accum_regret(acc);
731: break;
732: }
733: }
734: else if ((c == ',') && (pc == 0))
735: { accum_regret(acc);
736: break;
737: }
738: }
739: }
740: if (i < n)
741: { actuals[i] = accum_result(acc);
742: actlens[i] = strlen(actuals[i]);
743: i ++;
744: }
745: else if (i == n)
746: { err_head();
747: fprintf(stderr,"too many arguments to %s\n",d->name);
748: i ++;
749: }
750: if (c == ')')
751: { break;
752: }
753: }
754: if (i < n)
755: { err_head();
756: fprintf(stderr,"too few arguments to %s\n",d->name);
757: for (;i<n;i++)
758: { actuals[i] = copyofstr("");
759: check_malloc(actuals[i]);
760: actlens[i] = 0;
761: }
762: }
763: }
764:
765: void expand_def(DEF *d)
766: {
767: unsigned char *cp;
768: char *dp;
769: char *ep;
770: char *result;
771: int ok;
772: int incomm;
773: char last;
774:
775: if (d->nargs >= 0)
776: { read_actuals(d);
777: }
778: #ifdef DEBUG_EXPAND
779: if (debugging)
780: { char *cp;
781: outputs("~EXPAND:");
782: outputs(d->name);
783: if (d->nargs == 0)
784: { outputs("()");
785: }
786: else if (d->nargs > 0)
787: { int i;
788: for (i=0;i<d->nargs;i++)
789: { outputc((char)(i?',':'('));
790: outputs(actuals[i]);
791: }
792: outputc(')');
793: }
794: outputs("-->");
795: for (cp=(char *)d->repl;*cp;cp++)
796: { outputs(unctrl(*cp));
797: }
798: outputc('~');
799: }
800: #endif
801: result = init_accum();
802: for (cp=d->repl;*cp;cp++)
803: { if (*cp & 0x80)
804: { char *dp;
805: int i;
806: i = *cp & ~0x80;
807: for (dp=actuals[i];*dp;dp++)
808: { accum_char(result,*dp);
809: }
810: }
811: else
812: { accum_char(result,*cp);
813: }
814: }
815: dp = accum_result(result);
816: #ifdef DEBUG_EXPAND
817: if (debugging)
818: { outputs("first:");
819: for (ep=dp;*ep;ep++)
820: { outputs(unctrl(*ep));
821: }
822: outputc('~');
823: }
824: #endif
825: result = init_accum();
826: last = '\0';
827: ok = 1;
828: incomm = 0;
829: for (ep=dp;*ep;ep++)
830: { if (!incomm && (last == '/') && (*ep == '*'))
831: { incomm = 1;
832: if (!keep_comments || (strncmp(ep,"**/",3) == 0))
833: { accum_regret(result);
834: ok = 0;
835: }
836: }
837: if (ok)
838: { accum_char(result,*ep);
839: }
840: if ((last == '*') && (*ep == '/'))
841: { incomm = 0;
842: ok = 1;
843: }
844: last = *ep;
845: }
846: free(dp);
847: result = accum_result(result);
848: #ifdef DEBUG_EXPAND
849: if (debugging)
850: { outputs("/**/strip:");
851: outputs(result);
852: outputc('~');
853: }
854: #endif
855: for (dp=result+strlen(result)-1;dp>=result;dp--)
856: { Push(*dp);
857: }
858: free(result);
859: if (d->nargs >= 0)
860: { int i;
861: for (i=0;i<d->nargs;i++)
862: { free(actuals[i]);
863: }
864: free((char *)actuals);
865: }
866: }
867:
868: #define DEBUG_EXPR/**/
869:
870: #define TWOCHAR(c1,c2) (((c1)<<8)|(c2))
871: #define LSH TWOCHAR('<','<')
872: #define RSH TWOCHAR('>','>')
873: #define LEQ TWOCHAR('<','=')
874: #define GEQ TWOCHAR('>','=')
875: #define EQL TWOCHAR('=','=')
876: #define NEQ TWOCHAR('!','=')
877: #define AND TWOCHAR('&','&')
878: #define OR TWOCHAR('|','|')
879:
880: #define ALLBINS \
881: BIN('*',*) \
882: BIN('/',/) \
883: BIN('%',%) \
884: BIN('+',+) \
885: BIN(LSH,<<) \
886: BIN(RSH,>>) \
887: BIN('<',<) \
888: BIN('>',>) \
889: BIN(LEQ,<=) \
890: BIN(GEQ,>=) \
891: BIN(EQL,==) \
892: BIN(NEQ,!=) \
893: BIN('&',&) \
894: BIN('^',^) \
895: BIN('|',|) \
896: BIN(AND,&&) \
897: BIN(OR ,||)
898:
899: char *Index(char *s, int c);
900:
901: static NODE *expr;
902: int expr_sharp;
903: #define sharp expr_sharp
904: static int complain;
905:
906: #ifdef DEBUG_EXPR
907: extern int debugging;
908: #endif
909:
910: void free_expr(NODE *n)
911: {
912: switch (n->op)
913: { case 0:
914: break;
915: case '-':
916: if (n->left)
917: { free_expr(n->left);
918: }
919: free_expr(n->right);
920: break;
921: case '!':
922: case '~':
923: free_expr(n->right);
924: break;
925: case 'd':
926: free(n->name);
927: break;
928: default:
929: free_expr(n->left);
930: free_expr(n->right);
931: break;
932: }
933: OLD(n);
934: }
935:
936: int exec_free(NODE *n)
937: {
938: int rv;
939: int l;
940: int r;
941:
942: switch (n->op)
943: { case 0:
944: rv = n->leaf;
945: break;
946: case '-':
947: if (n->left)
948: { rv = exec_free(n->left);
949: }
950: else
951: { rv = 0;
952: }
953: rv -= exec_free(n->right);
954: break;
955: case '!':
956: rv = ! exec_free(n->right);
957: break;
958: case '~':
959: rv = ~ exec_free(n->right);
960: break;
961: case 'd':
962: rv = !! find_def(n->name);
963: free(n->name);
964: break;
965: #define BIN(key,op) case key:l=exec_free(n->left);r=exec_free(n->right);rv=l op r;break;
966: ALLBINS
967: #undef BIN
968: }
969: OLD(n);
970: return(rv);
971: }
972:
973: int exec_nofree(NODE *n)
974: {
975: int rv;
976:
977: switch (n->op)
978: { case 0:
979: rv = n->leaf;
980: break;
981: case '-':
982: if (n->left)
983: { rv = exec_nofree(n->left);
984: }
985: else
986: { rv = 0;
987: }
988: rv -= exec_nofree(n->right);
989: break;
990: case '!':
991: rv = ! exec_nofree(n->right);
992: break;
993: case '~':
994: rv = ~ exec_nofree(n->right);
995: break;
996: case 'd':
997: rv = !! find_def(n->name);
998: free(n->name);
999: break;
1000: #define BIN(key,op) case key:rv=(exec_nofree(n->left)op exec_nofree(n->right));break;
1001: ALLBINS
1002: #undef BIN
1003: }
1004: return(rv);
1005: }
1006:
1007: NODE *newnode(NODE *l, int c, NODE *r)
1008: {
1009: NODE *n;
1010:
1011: n = NEW(NODE);
1012: check_malloc(n);
1013: n->left = l;
1014: n->right = r;
1015: n->op = c;
1016: return(n);
1017: }
1018:
1019: NODE *newleaf(int v)
1020: {
1021: NODE *n;
1022:
1023: n = NEW(NODE);
1024: check_malloc(n);
1025: n->op = 0;
1026: n->left = 0;
1027: n->right = 0;
1028: n->leaf = v;
1029: return(n);
1030: }
1031:
1032: NODE *newname(char *name)
1033: {
1034: NODE *n;
1035:
1036: n = NEW(NODE);
1037: check_malloc(n);
1038: n->op = 'd';
1039: n->name = copyofstr(name);
1040: check_malloc(n->name);
1041: return(n);
1042: }
1043:
1044: int get_quote_char(void)
1045: {
1046: char c;
1047: char d;
1048:
1049: c = Get();
1050: if (c == '\'')
1051: { return(-1);
1052: }
1053: if (c == '\n')
1054: { err_head();
1055: fprintf(stderr,"newline in character constant\n");
1056: return(-1);
1057: }
1058: if (c != '\\')
1059: { return(0xff&(int)c);
1060: }
1061: c = Get();
1062: if ((c >= '0') && (c <= '7'))
1063: { d = c - '0';
1064: c = Get();
1065: if ((c >= '0') && (c <= '7'))
1066: { d = (d << 3) + c - '0';
1067: c = Get();
1068: if ((c >= '0') && (c <= '7'))
1069: { d = (d << 3) + c - '0';
1070: }
1071: else
1072: { Push(c);
1073: }
1074: }
1075: else
1076: { Push(c);
1077: }
1078: return(0xff&(int)d);
1079: }
1080: switch (c)
1081: { case 'n':
1082: return('\n');
1083: break;
1084: case 'r':
1085: return('\r');
1086: break;
1087: case 'e':
1088: return('\033');
1089: break;
1090: case 'f':
1091: return('\f');
1092: break;
1093: case 't':
1094: return('\t');
1095: break;
1096: case 'b':
1097: return('\b');
1098: break;
1099: case 'v':
1100: return('\v');
1101: break;
1102: default:
1103: return(0xff&(int)c);
1104: break;
1105: }
1106: }
1107:
1108: NODE *read_expr_11(void)
1109: {
1110: char c;
1111:
1112: #ifdef DEBUG_EXPR
1113: if (debugging)
1114: { outputs("~E11:");
1115: }
1116: #endif
1117: while (1)
1118: { c = getnhsexpand();
1119: if (c == '(')
1120: { NODE *n;
1121: NODE *read_expr_(void);
1122: #ifdef DEBUG_EXPR
1123: if (debugging)
1124: { outputs("()");
1125: }
1126: #endif
1127: n = read_expr_();
1128: c = getnhsexpand();
1129: if (c != ')')
1130: { err_head();
1131: fprintf(stderr,"expression syntax error -- missing ) supplied\n");
1132: Push(c);
1133: }
1134: #ifdef DEBUG_EXPR
1135: if (debugging)
1136: { outputs("~");
1137: }
1138: #endif
1139: return(n);
1140: }
1141: else if (isdigit(c))
1142: { int base;
1143: static char digits[] = "0123456789abcdefABCDEF";
1144: static char values[] =
1145: "\0\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\12\13\14\15\16\17";
1146: char *d;
1147: int v;
1148: #ifdef DEBUG_EXPR
1149: if (debugging)
1150: { outputs("N");
1151: }
1152: #endif
1153: base = 10;
1154: if (c == '0')
1155: { base = 8;
1156: c = Get();
1157: if ((c == 'x') || (c == 'X'))
1158: { base = 16;
1159: c = Get();
1160: }
1161: }
1162: v = 0;
1163: while (1)
1164: { d = Index(digits,c);
1165: if (d == 0)
1166: { Push(c);
1167: #ifdef DEBUG_EXPR
1168: if (debugging)
1169: { outputd(v);
1170: outputs("~");
1171: }
1172: #endif
1173: return(newleaf(v));
1174: }
1175: else if (values[d-digits] >= base)
1176: { err_head();
1177: fprintf(stderr,"warning: illegal %sdigit `%c'\n",
1178: (base==16)?"hex ":(base==8)?"octal ":"",c);
1179: }
1180: v = (v * base) + values[d-digits];
1181: c = Get();
1182: }
1183: }
1184: else if (c == '\'')
1185: { int i;
1186: int j;
1187: int n;
1188: i = 0;
1189: n = 0;
1190: while (1)
1191: { j = get_quote_char();
1192: if (j < 0)
1193: { break;
1194: }
1195: i = (i << 8) | j;
1196: n ++;
1197: }
1198: if (n > 4)
1199: { err_head();
1200: fprintf(stderr,"warning: too many characters in character constant\n");
1201: }
1202: return(newleaf(i));
1203: }
1204: else if ((c == '\n') && !sharp)
1205: {
1206: }
1207: else
1208: { char *id;
1209: if (complain)
1210: { err_head();
1211: fprintf(stderr,"expression syntax error -- number expected\n");
1212: }
1213: if (isbsymchar(c))
1214: { Push(c);
1215: id = read_ident();
1216: }
1217: else
1218: { id = 0;
1219: }
1220: #ifdef DEBUG_EXPR
1221: if (debugging)
1222: { outputs("0(");
1223: outputc(c);
1224: outputs(":");
1225: outputs(id?id:"(none)");
1226: outputs(")~");
1227: }
1228: #endif
1229: if (id)
1230: { free(id);
1231: }
1232: return(newleaf(0));
1233: }
1234: }
1235: }
1236:
1237: NODE *read_expr_10(void)
1238: {
1239: char c;
1240: char *w;
1241: NODE *n;
1242:
1243: #ifdef DEBUG_EXPR
1244: if (debugging)
1245: { outputs("~E10:");
1246: }
1247: #endif
1248: while (1)
1249: { c = getnhsexpand();
1250: switch (c)
1251: { case '-':
1252: case '~':
1253: case '!':
1254: #ifdef DEBUG_EXPR
1255: if (debugging)
1256: { outputc(c);
1257: }
1258: #endif
1259: n = read_expr_10();
1260: #ifdef DEBUG_EXPR
1261: if (debugging)
1262: { outputs("~");
1263: }
1264: #endif
1265: return(newnode(0,c,n));
1266: break;
1267: case 'd':
1268: Push(c);
1269: input_mark();
1270: w = read_ident();
1271: if (strcmp(w,"defined") == 0)
1272: { c = getnonspace();
1273: if (c == '(')
1274: { char *id;
1275: id = read_ident();
1276: if (id)
1277: { c = getnonspace();
1278: if (c == ')')
1279: { input_unmark();
1280: #ifdef DEBUG_EXPR
1281: if (debugging)
1282: { outputs("ifdef");
1283: }
1284: #endif
1285: return(newname(id));
1286: }
1287: }
1288: }
1289: else if (isbsymchar(c))
1290: { char *id;
1291: Push(c);
1292: id = read_ident();
1293: if (id)
1294: { input_unmark();
1295: #ifdef DEBUG_EXPR
1296: if (debugging)
1297: { outputs("ifdef");
1298: }
1299: #endif
1300: return(newname(id));
1301: }
1302: }
1303: }
1304: input_recover();
1305: n = read_expr_11();
1306: #ifdef DEBUG_EXPR
1307: if (debugging)
1308: { outputs("~");
1309: }
1310: #endif
1311: return(n);
1312: break;
1313: default:
1314: Push(c);
1315: n = read_expr_11();
1316: #ifdef DEBUG_EXPR
1317: if (debugging)
1318: { outputs("~");
1319: }
1320: #endif
1321: return(n);
1322: break;
1323: }
1324: }
1325: }
1326:
1327: NODE *read_expr_9(void)
1328: {
1329: NODE *l;
1330: NODE *r;
1331: char c;
1332:
1333: #ifdef DEBUG_EXPR
1334: if (debugging)
1335: { outputs("~E9:");
1336: }
1337: #endif
1338: l = read_expr_10();
1339: while (1)
1340: { c = getnhsexpand();
1341: switch (c)
1342: { case '*':
1343: case '/':
1344: case '%':
1345: #ifdef DEBUG_EXPR
1346: if (debugging)
1347: { outputc(c);
1348: }
1349: #endif
1350: r = read_expr_10();
1351: l = newnode(l,c,r);
1352: break;
1353: default:
1354: #ifdef DEBUG_EXPR
1355: if (debugging)
1356: { outputs("~");
1357: }
1358: #endif
1359: Push(c);
1360: return(l);
1361: break;
1362: }
1363: }
1364: }
1365:
1366: NODE *read_expr_8(void)
1367: {
1368: NODE *l;
1369: NODE *r;
1370: char c;
1371:
1372: #ifdef DEBUG_EXPR
1373: if (debugging)
1374: { outputs("~E8:");
1375: }
1376: #endif
1377: l = read_expr_9();
1378: while (1)
1379: { c = getnhsexpand();
1380: switch (c)
1381: { case '+':
1382: case '-':
1383: #ifdef DEBUG_EXPR
1384: if (debugging)
1385: { outputc(c);
1386: }
1387: #endif
1388: r = read_expr_9();
1389: l = newnode(l,c,r);
1390: break;
1391: default:
1392: #ifdef DEBUG_EXPR
1393: if (debugging)
1394: { outputs("~");
1395: }
1396: #endif
1397: Push(c);
1398: return(l);
1399: break;
1400: }
1401: }
1402: }
1403:
1404: NODE *read_expr_7(void)
1405: {
1406: NODE *l;
1407: NODE *r;
1408: char c;
1409: char d;
1410:
1411: #ifdef DEBUG_EXPR
1412: if (debugging)
1413: { outputs("~E7:");
1414: }
1415: #endif
1416: l = read_expr_8();
1417: while (1)
1418: { c = getnhsexpand();
1419: switch (c)
1420: { case '<':
1421: case '>':
1422: d = Get();
1423: if (d == c)
1424: {
1425: #ifdef DEBUG_EXPR
1426: if (debugging)
1427: { outputc(c);
1428: outputc(d);
1429: }
1430: #endif
1431: r = read_expr_8();
1432: l = newnode(l,(c=='<')?LSH:RSH,r);
1433: break;
1434: }
1435: Push(d);
1436: /* fall through ... */
1437: default:
1438: #ifdef DEBUG_EXPR
1439: if (debugging)
1440: { outputs("~");
1441: }
1442: #endif
1443: Push(c);
1444: return(l);
1445: break;
1446: }
1447: }
1448: }
1449:
1450: NODE *read_expr_6(void)
1451: {
1452: NODE *l;
1453: NODE *r;
1454: char c;
1455: char d;
1456:
1457: #ifdef DEBUG_EXPR
1458: if (debugging)
1459: { outputs("~E6:");
1460: }
1461: #endif
1462: l = read_expr_7();
1463: while (1)
1464: { c = getnhsexpand();
1465: switch (c)
1466: { case '<':
1467: case '>':
1468: d = Get();
1469: if (d == '=')
1470: {
1471: #ifdef DEBUG_EXPR
1472: if (debugging)
1473: { outputc(c);
1474: outputc(d);
1475: }
1476: #endif
1477: r = read_expr_7();
1478: l = newnode(l,(c=='<')?LEQ:GEQ,r);
1479: }
1480: else
1481: {
1482: #ifdef DEBUG_EXPR
1483: if (debugging)
1484: { outputc(c);
1485: }
1486: #endif
1487: Push(d);
1488: r = read_expr_7();
1489: l = newnode(l,c,r);
1490: }
1491: break;
1492: default:
1493: #ifdef DEBUG_EXPR
1494: if (debugging)
1495: { outputs("~");
1496: }
1497: #endif
1498: Push(c);
1499: return(l);
1500: break;
1501: }
1502: }
1503: }
1504:
1505: NODE *read_expr_5(void)
1506: {
1507: NODE *l;
1508: NODE *r;
1509: char c;
1510: char d;
1511:
1512: #ifdef DEBUG_EXPR
1513: if (debugging)
1514: { outputs("~E5:");
1515: }
1516: #endif
1517: l = read_expr_6();
1518: while (1)
1519: { c = getnhsexpand();
1520: switch (c)
1521: { case '=':
1522: case '!':
1523: d = Get();
1524: if (d == '=')
1525: {
1526: #ifdef DEBUG_EXPR
1527: if (debugging)
1528: { outputc(c);
1529: outputc(d);
1530: }
1531: #endif
1532: r = read_expr_6();
1533: l = newnode(l,(c=='=')?EQL:NEQ,r);
1534: break;
1535: }
1536: Push(d);
1537: /* fall through ... */
1538: default:
1539: #ifdef DEBUG_EXPR
1540: if (debugging)
1541: { outputs("~");
1542: }
1543: #endif
1544: Push(c);
1545: return(l);
1546: break;
1547: }
1548: }
1549: }
1550:
1551: NODE *read_expr_4(void)
1552: {
1553: NODE *l;
1554: NODE *r;
1555: char c;
1556: char d;
1557:
1558: #ifdef DEBUG_EXPR
1559: if (debugging)
1560: { outputs("~E4:");
1561: }
1562: #endif
1563: l = read_expr_5();
1564: while (1)
1565: { c = getnhsexpand();
1566: switch (c)
1567: { case '&':
1568: d = Get();
1569: if (d != '&')
1570: {
1571: #ifdef DEBUG_EXPR
1572: if (debugging)
1573: { outputc(c);
1574: outputc(d);
1575: }
1576: #endif
1577: r = read_expr_5();
1578: l = newnode(l,c,r);
1579: break;
1580: }
1581: Push(d);
1582: /* fall through ... */
1583: default:
1584: #ifdef DEBUG_EXPR
1585: if (debugging)
1586: { outputs("~");
1587: }
1588: #endif
1589: Push(c);
1590: return(l);
1591: break;
1592: }
1593: }
1594: }
1595:
1596: NODE *read_expr_3(void)
1597: {
1598: NODE *l;
1599: NODE *r;
1600: char c;
1601:
1602: #ifdef DEBUG_EXPR
1603: if (debugging)
1604: { outputs("~E3:");
1605: }
1606: #endif
1607: l = read_expr_4();
1608: while (1)
1609: { c = getnhsexpand();
1610: switch (c)
1611: { case '^':
1612: #ifdef DEBUG_EXPR
1613: if (debugging)
1614: { outputc(c);
1615: }
1616: #endif
1617: r = read_expr_4();
1618: l = newnode(l,c,r);
1619: break;
1620: default:
1621: #ifdef DEBUG_EXPR
1622: if (debugging)
1623: { outputs("~");
1624: }
1625: #endif
1626: Push(c);
1627: return(l);
1628: break;
1629: }
1630: }
1631: }
1632:
1633: NODE *read_expr_2(void)
1634: {
1635: NODE *l;
1636: NODE *r;
1637: char c;
1638: char d;
1639:
1640: #ifdef DEBUG_EXPR
1641: if (debugging)
1642: { outputs("~E2:");
1643: }
1644: #endif
1645: l = read_expr_3();
1646: while (1)
1647: { c = getnhsexpand();
1648: switch (c)
1649: { case '|':
1650: d = Get();
1651: if (d != '|')
1652: { Push(d);
1653: #ifdef DEBUG_EXPR
1654: if (debugging)
1655: { outputc(c);
1656: }
1657: #endif
1658: r = read_expr_3();
1659: l = newnode(l,c,r);
1660: break;
1661: }
1662: Push(d);
1663: /* fall through ... */
1664: default:
1665: #ifdef DEBUG_EXPR
1666: if (debugging)
1667: { outputs("~");
1668: }
1669: #endif
1670: Push(c);
1671: return(l);
1672: break;
1673: }
1674: }
1675: }
1676:
1677: NODE *read_expr_1(void)
1678: {
1679: NODE *l;
1680: NODE *r;
1681: char c;
1682: char d;
1683:
1684: #ifdef DEBUG_EXPR
1685: if (debugging)
1686: { outputs("~E1:");
1687: }
1688: #endif
1689: l = read_expr_2();
1690: while (1)
1691: { c = getnhsexpand();
1692: switch (c)
1693: { case '&':
1694: d = Get();
1695: if (d == c)
1696: {
1697: #ifdef DEBUG_EXPR
1698: if (debugging)
1699: { outputc(c);
1700: outputc(d);
1701: }
1702: #endif
1703: r = read_expr_2();
1704: l = newnode(l,AND,r);
1705: break;
1706: }
1707: Push(d);
1708: /* fall through ... */
1709: default:
1710: #ifdef DEBUG_EXPR
1711: if (debugging)
1712: { outputs("~");
1713: }
1714: #endif
1715: Push(c);
1716: return(l);
1717: break;
1718: }
1719: }
1720: }
1721:
1722: NODE *read_expr_0(void)
1723: {
1724: NODE *l;
1725: NODE *r;
1726: char c;
1727: char d;
1728:
1729: #ifdef DEBUG_EXPR
1730: if (debugging)
1731: { outputs("~E0:");
1732: }
1733: #endif
1734: l = read_expr_1();
1735: while (1)
1736: { c = getnhsexpand();
1737: switch (c)
1738: { case '|':
1739: d = Get();
1740: if (d == c)
1741: {
1742: #ifdef DEBUG_EXPR
1743: if (debugging)
1744: { outputc(c);
1745: outputc(d);
1746: }
1747: #endif
1748: r = read_expr_1();
1749: l = newnode(l,OR,r);
1750: break;
1751: }
1752: Push(d);
1753: /* fall through ... */
1754: default:
1755: #ifdef DEBUG_EXPR
1756: if (debugging)
1757: { outputs("~");
1758: }
1759: #endif
1760: Push(c);
1761: return(l);
1762: break;
1763: }
1764: }
1765: }
1766:
1767: NODE *read_expr_(void)
1768: {
1769: NODE *l;
1770: NODE *r;
1771: char c;
1772:
1773: #ifdef DEBUG_EXPR
1774: if (debugging)
1775: { outputs("~E");
1776: }
1777: #endif
1778: l = read_expr_0();
1779: while (1)
1780: { c = getnhsexpand();
1781: switch (c)
1782: { case '\n':
1783: case ')':
1784: Push(c);
1785: return(l);
1786: break;
1787: case ',':
1788: r = read_expr_0();
1789: l = newnode(l,c,r);
1790: break;
1791: default:
1792: err_head();
1793: fprintf(stderr,"expression syntax error -- bad operator `%c'\n",c);
1794: return(l);
1795: break;
1796: }
1797: }
1798: }
1799:
1800: NODE *read_expr_p(void)
1801: {
1802: char c;
1803: NODE *rv;
1804:
1805: sharp = 0;
1806: complain = 1;
1807: c = getnonspace();
1808: if (c != '(')
1809: { Push(c);
1810: return(0);
1811: }
1812: rv = read_expr_();
1813: c = getnonspace();
1814: if (c != ')')
1815: { err_head();
1816: fprintf(stderr,"junk after expression\n");
1817: }
1818: return(rv);
1819: }
1820:
1821: int eval_expr(int Sharp, int Complain)
1822: {
1823: char c;
1824: char d;
1825: int rv;
1826:
1827: sharp = Sharp;
1828: complain = Complain;
1829: expr = read_expr_();
1830: if (sharp)
1831: { c = getnonhspace();
1832: d = '\n';
1833: }
1834: else
1835: { c = getnonspace();
1836: d = ')';
1837: }
1838: if (c != d)
1839: { if (complain)
1840: { err_head();
1841: fprintf(stderr,"expression syntax error -- junk after expression\n");
1842: }
1843: while (Get() != d) ;
1844: }
1845: #ifdef DEBUG_EXPR
1846: if (debugging)
1847: { outputc('<');
1848: dump_expr(expr);
1849: outputc('=');
1850: rv = exec_free(expr);
1851: outputd(rv);
1852: outputc('>');
1853: }
1854: else
1855: { rv = exec_free(expr);
1856: }
1857: return(rv);
1858: #else
1859: return(exec_free(expr));
1860: #endif
1861: }
1862:
1863: #ifdef DEBUG_EXPR
1864: void dump_expr(NODE *n)
1865: {
1866: switch (n->op)
1867: { case 0:
1868: outputd(n->leaf);
1869: break;
1870: case '-':
1871: if (n->left)
1872: { dump_expr(n->left);
1873: }
1874: outputc('-');
1875: dump_expr(n->right);
1876: break;
1877: case '!':
1878: outputc('!');
1879: dump_expr(n->right);
1880: break;
1881: case '~':
1882: outputc('~');
1883: dump_expr(n->right);
1884: break;
1885: case 'd':
1886: outputs("defined(");
1887: outputs(n->name);
1888: outputc(')');
1889: break;
1890: #define BIN(key,op) case key:dump_expr(n->left);\
1891: putx(key);\
1892: dump_expr(n->right);\
1893: break;
1894: ALLBINS
1895: #undef BIN
1896: }
1897: }
1898:
1899: void putx(int i)
1900: {
1901: if (i > 0xff) outputc((char)(i>>8));
1902: outputc((char)(i&0xff));
1903: }
1904: #endif
1905:
1906: /*#define DEBUG_IF/**/
1907:
1908: #ifdef DEBUG_IF
1909: extern int debugging;
1910: #endif
1911:
1912: void do_if(int expr_sharp)
1913: {
1914: char c;
1915: char d;
1916:
1917: #ifdef DEBUG_IF
1918: if (debugging)
1919: { outputc('<');
1920: outputc(sharp?'#':'@');
1921: outputs("if: ");
1922: fflush(outfile);
1923: }
1924: #endif
1925: if (in_false_if())
1926: { n_skipped_ifs ++;
1927: #ifdef DEBUG_IF
1928: if (debugging)
1929: { outputs("in-false, skipped>");
1930: fflush(outfile);
1931: }
1932: #endif
1933: if (sharp)
1934: { d = '\0';
1935: do
1936: { c = d;
1937: d = Get();
1938: } while ((c == '\\') || (d != '\n'));
1939: }
1940: return;
1941: }
1942: if (! sharp)
1943: { c = getnonspace();
1944: if (c != '(')
1945: { err_head();
1946: fprintf(stderr,"@if must have ()s\n");
1947: Push(c);
1948: iffalse();
1949: #ifdef DEBUG_IF
1950: if (debugging)
1951: { outputc('>');
1952: fflush(outfile);
1953: }
1954: #endif
1955: return;
1956: }
1957: }
1958: if (eval_expr(sharp,0))
1959: { iftrue();
1960: }
1961: else
1962: { iffalse();
1963: }
1964: #ifdef DEBUG_IF
1965: if (debugging)
1966: { outputc('>');
1967: fflush(outfile);
1968: }
1969: #endif
1970: }
1971:
1972: void do_ifdef(int expr_sharp)
1973: {
1974: char *w;
1975:
1976: #ifdef DEBUG_IF
1977: if (debugging)
1978: { outputc('<');
1979: outputc(sharp?'#':'@');
1980: outputs("ifdef: ");
1981: fflush(outfile);
1982: }
1983: #endif
1984: if (in_false_if())
1985: { n_skipped_ifs ++;
1986: #ifdef DEBUG_IF
1987: if (debugging)
1988: { outputs("in-false, skipped>");
1989: fflush(outfile);
1990: }
1991: #endif
1992: }
1993: else
1994: { w = read_ident();
1995: if (! w)
1996: {
1997: #ifdef DEBUG_IF
1998: if (debugging)
1999: { outputs("no ident ");
2000: fflush(outfile);
2001: }
2002: #endif
2003: iffalse();
2004: }
2005: else
2006: {
2007: #ifdef DEBUG_IF
2008: if (debugging)
2009: { outputs(w);
2010: outputc(' ');
2011: fflush(outfile);
2012: }
2013: #endif
2014: if (find_def(w))
2015: { iftrue();
2016: }
2017: else
2018: { iffalse();
2019: }
2020: free(w);
2021: }
2022: #ifdef DEBUG_IF
2023: if (debugging)
2024: { outputc('>');
2025: fflush(outfile);
2026: }
2027: #endif
2028: }
2029: if (sharp)
2030: { flush_sharp_line();
2031: }
2032: }
2033:
2034: void do_ifndef(int expr_sharp)
2035: {
2036: char *w;
2037:
2038: #ifdef DEBUG_IF
2039: if (debugging)
2040: { outputc('<');
2041: outputc(sharp?'#':'@');
2042: outputs("ifndef: ");
2043: fflush(outfile);
2044: }
2045: #endif
2046: if (in_false_if())
2047: { n_skipped_ifs ++;
2048: #ifdef DEBUG_IF
2049: if (debugging)
2050: { outputs("in-false, skipped>");
2051: fflush(outfile);
2052: }
2053: #endif
2054: }
2055: else
2056: { w = read_ident();
2057: if (! w)
2058: {
2059: #ifdef DEBUG_IF
2060: if (debugging)
2061: { outputs("no ident ");
2062: fflush(outfile);
2063: }
2064: #endif
2065: iftrue();
2066: }
2067: else
2068: {
2069: #ifdef DEBUG_IF
2070: if (debugging)
2071: { outputs(w);
2072: outputc(' ');
2073: fflush(outfile);
2074: }
2075: #endif
2076: if (find_def(w))
2077: { iffalse();
2078: }
2079: else
2080: { iftrue();
2081: }
2082: free(w);
2083: }
2084: #ifdef DEBUG_IF
2085: if (debugging)
2086: { outputc('>');
2087: fflush(outfile);
2088: }
2089: #endif
2090: }
2091: if (sharp)
2092: { flush_sharp_line();
2093: }
2094: }
2095:
2096: void do_else(int expr_sharp)
2097: {
2098: #ifdef DEBUG_IF
2099: if (debugging)
2100: { outputc('<');
2101: outputc(sharp?'#':'@');
2102: outputs("else: ");
2103: fflush(outfile);
2104: }
2105: #endif
2106: if (n_skipped_ifs == 0)
2107: { if (ifstack)
2108: {
2109: #ifdef DEBUG_IF
2110: if (debugging)
2111: { outputs("top ");
2112: output_ifstate(ifstack->condstate);
2113: fflush(outfile);
2114: }
2115: #endif
2116: switch (ifstack->condstate)
2117: { case IFSTATE_TRUE:
2118: ifstack->condstate = IFSTATE_STAYFALSE;
2119: break;
2120: case IFSTATE_FALSE:
2121: ifstack->condstate = IFSTATE_TRUE;
2122: break;
2123: }
2124: #ifdef DEBUG_IF
2125: if (debugging)
2126: { outputs(" now ");
2127: output_ifstate(ifstack->condstate);
2128: outputc('>');
2129: fflush(outfile);
2130: }
2131: #endif
2132: }
2133: else
2134: {
2135: #ifdef DEBUG_IF
2136: if (debugging)
2137: { outputs(" no if>");
2138: fflush(outfile);
2139: }
2140: #endif
2141: err_head();
2142: fprintf(stderr,"if-less else\n");
2143: }
2144: }
2145: else
2146: {
2147: #ifdef DEBUG_IF
2148: if (debugging)
2149: { outputs("in-false, forgetting>");
2150: fflush(outfile);
2151: }
2152: #endif
2153: }
2154: if (sharp)
2155: { flush_sharp_line();
2156: }
2157: }
2158:
2159: #ifdef DEBUG_IF
2160: void output_ifstate(state)
2161: int state;
2162: {
2163: switch (state)
2164: { case IFSTATE_TRUE:
2165: outputs("TRUE");
2166: break;
2167: case IFSTATE_FALSE:
2168: outputs("FALSE");
2169: break;
2170: case IFSTATE_STAYFALSE:
2171: outputs("STAYFALSE");
2172: break;
2173: default:
2174: outputs("BAD");
2175: outputd(state);
2176: break;
2177: }
2178: }
2179: #endif
2180:
2181: void do_elif(int expr_sharp)
2182: {
2183: char c;
2184: char d;
2185: int e;
2186:
2187: #ifdef DEBUG_IF
2188: if (debugging)
2189: { outputc('<');
2190: outputc(sharp?'#':'@');
2191: outputs("elif: ");
2192: fflush(outfile);
2193: }
2194: #endif
2195: if (ifstack == 0)
2196: { err_head();
2197: fprintf(stderr,"if-less elif converted to normal if\n");
2198: iffalse();
2199: }
2200: if (n_skipped_ifs > 0)
2201: {
2202: #ifdef DEBUG_IF
2203: if (debugging)
2204: { outputs("being skipped, ignoring>");
2205: fflush(outfile);
2206: }
2207: #endif
2208: if (sharp)
2209: { d = '\0';
2210: do
2211: { c = d;
2212: d = Get();
2213: } while ((c == '\\') || (d != '\n'));
2214: }
2215: return;
2216: }
2217: if (! sharp)
2218: { c = getnonspace();
2219: if (c != '(')
2220: { err_head();
2221: fprintf(stderr,"@elif must have ()s\n");
2222: Push(c);
2223: ifstack->condstate = IFSTATE_STAYFALSE;
2224: #ifdef DEBUG_IF
2225: if (debugging)
2226: { outputs("forcing STAYFALSE>");
2227: fflush(outfile);
2228: }
2229: #endif
2230: return;
2231: }
2232: }
2233: e = eval_expr(sharp,0);
2234: #ifdef DEBUG_IF
2235: if (debugging)
2236: { outputs("expr ");
2237: outputd(e);
2238: outputc(' ');
2239: fflush(outfile);
2240: }
2241: #endif
2242: #ifdef DEBUG_IF
2243: if (debugging)
2244: { outputs(" top ");
2245: output_ifstate(ifstack->condstate);
2246: fflush(outfile);
2247: }
2248: #endif
2249: switch (ifstack->condstate)
2250: { case IFSTATE_TRUE:
2251: ifstack->condstate = IFSTATE_STAYFALSE;
2252: break;
2253: case IFSTATE_FALSE:
2254: if (e)
2255: { ifstack->condstate = IFSTATE_TRUE;
2256: }
2257: break;
2258: }
2259: #ifdef DEBUG_IF
2260: if (debugging)
2261: { outputs(" now ");
2262: output_ifstate(ifstack->condstate);
2263: outputc('>');
2264: fflush(outfile);
2265: }
2266: #endif
2267: }
2268:
2269: void do_endif(int expr_sharp)
2270: {
2271: IF *i;
2272:
2273: #ifdef DEBUG_IF
2274: if (debugging)
2275: { outputc('<');
2276: outputc(sharp?'#':'@');
2277: outputs("endif: ");
2278: fflush(outfile);
2279: }
2280: #endif
2281: if (n_skipped_ifs > 0)
2282: { n_skipped_ifs --;
2283: #ifdef DEBUG_IF
2284: if (debugging)
2285: { outputs("n_skipped -->");
2286: fflush(outfile);
2287: }
2288: #endif
2289: }
2290: else if (ifstack)
2291: { i = ifstack->next;
2292: OLD(ifstack);
2293: ifstack = i;
2294: #ifdef DEBUG_IF
2295: if (debugging)
2296: { outputs("popping stack>");
2297: fflush(outfile);
2298: }
2299: #endif
2300: }
2301: else
2302: { err_head();
2303: fprintf(stderr,"if-less endif\n");
2304: #ifdef DEBUG_IF
2305: if (debugging)
2306: { outputc('>');
2307: fflush(outfile);
2308: }
2309: #endif
2310: }
2311: if (sharp)
2312: { flush_sharp_line();
2313: }
2314: }
2315:
2316: void iftrue(void)
2317: {
2318: IF *i;
2319:
2320: i = NEW(IF);
2321: check_malloc(i);
2322: i->next = ifstack;
2323: ifstack = i;
2324: i->condstate = IFSTATE_TRUE;
2325: #ifdef DEBUG_IF
2326: if (debugging)
2327: { outputs("IFTRUE");
2328: fflush(outfile);
2329: }
2330: #endif
2331: }
2332:
2333: void iffalse(void)
2334: {
2335: IF *i;
2336:
2337: i = NEW(IF);
2338: check_malloc(i);
2339: i->next = ifstack;
2340: ifstack = i;
2341: i->condstate = IFSTATE_FALSE;
2342: #ifdef DEBUG_IF
2343: if (debugging)
2344: { outputs("IFFALSE");
2345: fflush(outfile);
2346: }
2347: #endif
2348: }
2349:
2350: int in_false_if(void)
2351: {
2352: return(ifstack && (ifstack->condstate != IFSTATE_TRUE));
2353: }
2354:
2355: void maybe_print(char c)
2356: {
2357: extern int incldep;
2358:
2359: if (incldep)
2360: { return;
2361: }
2362: if ((c == '\n') || !in_false_if())
2363: { outputc(c);
2364: }
2365: }
2366:
2367: char *Rindex(char *s, int c);
2368:
2369: int nIfiles;
2370: char **Ifiles;
2371:
2372: void init_include(void)
2373: {
2374: nIfiles = 0;
2375: Ifiles = (char **) malloc(1);
2376: check_malloc(Ifiles);
2377: }
2378:
2379: void Ifile(char *f)
2380: {
2381: Ifiles = (char **) realloc((char *)Ifiles,(nIfiles+1)*sizeof(char *));
2382: check_malloc(Ifiles);
2383: Ifiles[nIfiles] = copyofstr(f);
2384: check_malloc(Ifiles[nIfiles]);
2385: nIfiles ++;
2386: }
2387:
2388: void do_include(int expr_sharp)
2389: {
2390: char c;
2391: char *acc;
2392:
2393: if (in_false_if())
2394: { if (sharp)
2395: { flush_sharp_line();
2396: }
2397: return;
2398: }
2399: while (1)
2400: { c = getnonspace();
2401: if (isbsymchar(c))
2402: { char *cp;
2403: DEF *d;
2404: cp = init_accum();
2405: while (issymchar(c))
2406: { accum_char(cp,c);
2407: c = Get();
2408: }
2409: Push(c);
2410: cp = accum_result(cp);
2411: d = find_def(cp);
2412: if (d)
2413: { expand_def(d);
2414: n_hits ++;
2415: }
2416: else
2417: { char *dp;
2418: for (dp=cp+strlen(cp);dp>cp;dp--) Push(*dp);
2419: n_misses ++;
2420: }
2421: }
2422: else
2423: { break;
2424: }
2425: }
2426: acc = init_accum();
2427: if (c == '"')
2428: { while (1)
2429: { c = Get();
2430: if (c == '\n')
2431: { Push('\n');
2432: c = '"';
2433: err_head();
2434: fprintf(stderr,"warning: unterminated %cinclude filename\n",
2435: sharp?'#':'@');
2436: }
2437: if (c == '"')
2438: { break;
2439: }
2440: accum_char(acc,c);
2441: }
2442: if (sharp)
2443: { flush_sharp_line();
2444: }
2445: read_include_file(accum_result(acc),1,sharp);
2446: }
2447: else if (c == '<')
2448: { while (1)
2449: { c = Get();
2450: if (c == '\n')
2451: { Push('\n');
2452: c = '>';
2453: err_head();
2454: fprintf(stderr,"warning: unterminated %cinclude filename\n",
2455: sharp?'#':'@');
2456: }
2457: if (c == '>')
2458: { break;
2459: }
2460: accum_char(acc,c);
2461: }
2462: if (sharp)
2463: { flush_sharp_line();
2464: }
2465: read_include_file(accum_result(acc),0,sharp);
2466: }
2467: else
2468: { free(accum_result(acc));
2469: err_head();
2470: fprintf(stderr,"illegal %cinclude filename delimiter\n",sharp?'#':'@');
2471: }
2472: }
2473:
2474: #if defined(THINK_C)
2475: #if defined(DELIM)
2476: #undef DELIM
2477: #endif
2478: #define DELIM ':'
2479: #endif
2480:
2481: #if defined(SYSV)
2482: #else
2483: #if defined(DELIM)
2484: #undef DELIM
2485: #endif
2486: #define DELIM '/'
2487: #endif
2488:
2489: #if defined(VISUAL)
2490: #if defined(DELIM)
2491: #undef DELIM
2492: #endif
2493: #define DELIM '\\'
2494: #endif
2495:
2496: void read_include_file(char *name, int dohere, int expr_sharp)
2497: {
2498: FILE *f;
2499: char *n;
2500: char temp[1024];
2501: char *cp;
2502: extern int incldep;
2503: extern char *incldep_o;
2504:
2505: f = NULL;
2506: if (dohere)
2507: { if ((strcmp(curdir(),".") != 0) && (name[0] != DELIM))
2508: { sprintf(temp,"%s%c%s",curdir(),DELIM,name);
2509: n = temp;
2510: }
2511: else
2512: { n = name;
2513: }
2514: f = fopen(n,"r");
2515: }
2516: if (f == NULL)
2517: { if (name[0] == DELIM)
2518: { f = fopen(name,"r");
2519: n = name;
2520: }
2521: else
2522: { int i;
2523: n = temp;
2524: for (i=0;i<nIfiles;i++)
2525: { sprintf(temp,"%s%c%s",Ifiles[i],DELIM,name);
2526: f = fopen(temp,"r");
2527: if (f != NULL)
2528: { break;
2529: }
2530: }
2531: }
2532: }
2533: if (f == NULL)
2534: { err_head();
2535: fprintf(stderr,"can't find include file %s\n",name);
2536: free(name);
2537: return;
2538: }
2539: if (incldep)
2540: { printf("%s: %s\n",incldep_o,n);
2541: }
2542: out_at(!sharp,n);
2543: autodef_file(n);
2544: autodef_line(1);
2545: Push('\n');
2546: Get();
2547: push_new_file(n,f);
2548: cp = Rindex(n,DELIM);
2549: if (cp)
2550: { *cp = '\0';
2551: cp = copyofstr(n);
2552: }
2553: else
2554: { cp = copyofstr(".");
2555: }
2556: check_malloc(cp);
2557: *Curdir() = cp;
2558: free(name);
2559: return;
2560: }
2561:
2562: /*#define DEBUG_IO/**/
2563: /*#define DEBUG_INCL/**/
2564:
2565: #if defined(DEBUG_IO) || defined(DEBUG_INCL)
2566: extern int debugging;
2567: #endif
2568:
2569: extern int no_line_lines;
2570:
2571: int linefirst;
2572: int willbefirst;
2573: int lineno[MAXFILES];
2574: FILE *fstack[MAXFILES];
2575: int fstackdepth;
2576: char *fn[MAXFILES];
2577: int npushed[MAXFILES];
2578: char pushback[MAXFILES][MAX_PUSHBACK];
2579: char *incldir[MAXFILES];
2580: FILE *outfile;
2581:
2582: char *cur_pushback;
2583: int cur_npushed;
2584: FILE *cur_fstack;
2585: char *cur_fn;
2586: char *cur_incldir;
2587: int cur_lineno;
2588:
2589: typedef struct _mark {
2590: struct _mark *link;
2591: char *acc;
2592: int startdepth;
2593: int incs[MAXFILES];
2594: int nincs;
2595: int nignore; } MARK;
2596:
2597: static MARK *marks;
2598: static int atline;
2599: static char *atfile;
2600: static int done_line;
2601: static int nnls;
2602:
2603: /* XXX these definitions assume no input chars are 81, 82, 83 */
2604: #define NOEXPAND ((char)0x81)
2605: #define MARKLINE ((char)0x82)
2606: #define MARKLEND ((char)0x83)
2607:
2608: void init_io(FILE *f, char *fnname)
2609: {
2610: register int i;
2611:
2612: fstackdepth = 0;
2613: cur_pushback = pushback[0];
2614: cur_npushed = 0;
2615: cur_fstack = f;
2616: cur_fn = copyofstr(fnname);
2617: check_malloc(cur_fn);
2618: cur_lineno = 1;
2619: nnls = 0;
2620: atfile = copyofstr("");
2621: check_malloc(atfile);
2622: for (i=0;i<MAXFILES;i++)
2623: { npushed[i] = 0;
2624: }
2625: marks = 0;
2626: }
2627:
2628: void init_incldir(char *d)
2629: {
2630: cur_incldir = copyofstr(d);
2631: check_malloc(cur_incldir);
2632: }
2633:
2634: void change_fstackdepth(int delta)
2635: {
2636: npushed[fstackdepth] = cur_npushed;
2637: fstack[fstackdepth] = cur_fstack;
2638: fn[fstackdepth] = cur_fn;
2639: incldir[fstackdepth] = cur_incldir;
2640: lineno[fstackdepth] = cur_lineno;
2641: fstackdepth += delta;
2642: cur_pushback = pushback[fstackdepth];
2643: cur_npushed = npushed[fstackdepth];
2644: cur_fstack = fstack[fstackdepth];
2645: cur_fn = fn[fstackdepth];
2646: cur_incldir = incldir[fstackdepth];
2647: cur_lineno = lineno[fstackdepth];
2648: }
2649:
2650: #define GET() (cur_pushback[--cur_npushed])
2651: #define PUSH() (cur_pushback[cur_npushed++])
2652:
2653: char Get(void)
2654: {
2655: char c;
2656:
2657: linefirst = willbefirst;
2658: willbefirst = 0;
2659: while (1)
2660: { if (cur_npushed > 0)
2661: { do
2662: { c = GET();
2663: } while (c == NOEXPAND);
2664: if (c == MARKLINE)
2665: { mark_get_line();
2666: continue;
2667: }
2668: mark_got_from_pushback(c);
2669: #ifdef DEBUG_IO
2670: if (debugging)
2671: { outputc('(');
2672: outputs(unctrl(c));
2673: outputc(')');
2674: fflush(outfile);
2675: }
2676: #endif
2677: break;
2678: }
2679: else
2680: { c = getc(cur_fstack);
2681: if (feof(cur_fstack))
2682: { if (fstackdepth > 0)
2683: {
2684: #ifdef DEBUG_INCL
2685: if (debugging)
2686: { outputs("--eof:");
2687: outputs(cur_fn);
2688: outputs("--");
2689: }
2690: #endif
2691: fclose(cur_fstack);
2692: free(cur_fn);
2693: free(cur_incldir);
2694: change_fstackdepth(-1);
2695: mark_file_ending();
2696: out_at(cur_lineno,cur_fn);
2697: autodef_file(curfile());
2698: autodef_line(curline());
2699: continue;
2700: }
2701: else
2702: { flush_final_nl();
2703: save_stats();
2704: #if 0
2705: exit(0);
2706: #endif
2707: longjmp(cpp_env,1);
2708: }
2709: }
2710: mark_got_from_file(c);
2711: #ifdef DEBUG_IO
2712: if (debugging)
2713: { outputc('<');
2714: outputs(unctrl(c));
2715: outputc('>');
2716: fflush(outfile);
2717: }
2718: #endif
2719: break;
2720: }
2721: }
2722: if (c == '\n')
2723: { cur_lineno ++;
2724: autodef_line(curline());
2725: willbefirst = 1;
2726: }
2727: return(c);
2728: }
2729:
2730: void push_new_file(char *name, FILE *f)
2731: {
2732: change_fstackdepth(1);
2733: cur_fn = copyofstr(name);
2734: check_malloc(cur_fn);
2735: cur_lineno = 1;
2736: cur_fstack = f;
2737: cur_npushed = 0;
2738: #ifdef DEBUG_INCL
2739: if (debugging)
2740: { outputs("--newfile:");
2741: outputs(name);
2742: outputs("--");
2743: }
2744: #endif
2745: mark_file_beginning();
2746: }
2747:
2748: void Push(char c)
2749: {
2750: if (cur_npushed > MAX_PUSHBACK)
2751: { fprintf(stderr,"too much pushback\n");
2752: cur_npushed = 0;
2753: }
2754: PUSH() = c;
2755: mark_charpushed();
2756: willbefirst = 0;
2757: if (c == '\n')
2758: { cur_lineno --;
2759: autodef_line(curline());
2760: }
2761: #ifdef DEBUG_IO
2762: if (debugging)
2763: { outputc('[');
2764: outputs(unctrl(c));
2765: outputc(']');
2766: fflush(outfile);
2767: }
2768: #endif
2769: }
2770:
2771: char *curfile(void)
2772: {
2773: return(cur_fn);
2774: }
2775:
2776: char **Curfile(void)
2777: {
2778: return(&cur_fn);
2779: }
2780:
2781: int curline(void)
2782: {
2783: return(cur_lineno);
2784: }
2785:
2786: int *Curline(void)
2787: {
2788: return(&cur_lineno);
2789: }
2790:
2791: char *curdir(void)
2792: {
2793: return(cur_incldir);
2794: }
2795:
2796: char **Curdir(void)
2797: {
2798: return(&cur_incldir);
2799: }
2800:
2801: char getnonspace(void)
2802: {
2803: char c;
2804:
2805: while (isspace(c=Get())) ;
2806: return(c);
2807: }
2808:
2809: char getnonhspace(void)
2810: {
2811: char c;
2812:
2813: while (ishspace(c=Get())) ;
2814: return(c);
2815: }
2816:
2817: char getnhsexpand(void)
2818: {
2819: char c;
2820:
2821: while (1)
2822: { c = getexpand();
2823: if (ishspace(c))
2824: { continue;
2825: }
2826: if (expr_sharp && (c == '\\'))
2827: { c = Get();
2828: if (c == '\n')
2829: { continue;
2830: }
2831: else
2832: { Push(c);
2833: c = '\\';
2834: }
2835: }
2836: break;
2837: }
2838: return(c);
2839: }
2840:
2841: char getexpand(void)
2842: {
2843: char c;
2844: char *str;
2845: DEF *d;
2846:
2847: while (1)
2848: { c = Get();
2849: if (c == '/')
2850: { char d;
2851: d = Get();
2852: if (d == '*')
2853: { d = '\0';
2854: do
2855: { c = d;
2856: d = Get();
2857: } while ((c != '*') || (d != '/'));
2858: continue;
2859: }
2860: else
2861: { Push(d);
2862: return('/');
2863: }
2864: }
2865: else if (c == NOEXPAND)
2866: { c = Get();
2867: if (issymchar(c))
2868: { Push(NOEXPAND);
2869: }
2870: return(c);
2871: }
2872: else if (! isbsymchar(c))
2873: {
2874: return(c);
2875: }
2876: str = init_accum();
2877: do
2878: { accum_char(str,c);
2879: } while (issymchar(c=Get()));
2880: Push(c);
2881: str = accum_result(str);
2882: if (d = find_def(str))
2883: { expand_def(d);
2884: free(str);
2885: }
2886: else
2887: { int i;
2888: for (i=strlen(str)-1;i>0;i--)
2889: { Push(str[i]);
2890: }
2891: Push(NOEXPAND);
2892: c = str[0];
2893: free(str);
2894: return(c);
2895: }
2896: }
2897: }
2898:
2899: char *read_ctrl(void)
2900: {
2901: char c;
2902: char *acc;
2903:
2904: acc = init_accum();
2905: while (ishspace(c=Get())) ;
2906: Push(c);
2907: while (1)
2908: { c = Get();
2909: if (islower(c))
2910: { accum_char(acc,c);
2911: }
2912: else
2913: { Push(c);
2914: return(accum_result(acc));
2915: }
2916: }
2917: }
2918:
2919: char *read_ident(void)
2920: {
2921: char *acc;
2922: char c;
2923:
2924: c = getnonspace();
2925: if (! isbsymchar(c))
2926: { Push(c);
2927: return(0);
2928: }
2929: acc = init_accum();
2930: do
2931: { accum_char(acc,c);
2932: } while (issymchar(c=Get()));
2933: Push(c);
2934: return(accum_result(acc));
2935: }
2936:
2937: void out_at(int line, char *file)
2938: {
2939: if ((line-nnls != atline) || strcmp(file,atfile))
2940: { free(atfile);
2941: atline = line - nnls;
2942: atfile = copyofstr(file);
2943: check_malloc(atfile);
2944: done_line = 0;
2945: }
2946: }
2947:
2948: void outputc(char c)
2949: {
2950: extern int incldep;
2951: static char *white = 0;
2952:
2953: if (incldep)
2954: { return;
2955: }
2956: if (c == '\n')
2957: { nnls ++;
2958: if (white)
2959: { free(accum_result(white));
2960: white = 0;
2961: }
2962: }
2963: else if ((nnls > 0) && ((c == ' ') || (c == '\t')))
2964: { if (! white)
2965: { white = init_accum();
2966: }
2967: accum_char(white,c);
2968: }
2969: else
2970: { if ((nnls > 2) || !done_line)
2971: { atline += nnls;
2972: nnls = 0;
2973: if (no_line_lines)
2974: { fprintf(outfile,"\n");
2975: }
2976: else
2977: { fprintf(outfile,"\n# %d \"%s\"\n",atline,atfile);
2978: }
2979: done_line = 1;
2980: }
2981: for (;nnls;nnls--)
2982: { atline ++;
2983: putc('\n',outfile);
2984: }
2985: if (white)
2986: { white = accum_result(white);
2987: fputs(white,outfile);
2988: free(white);
2989: white = 0;
2990: }
2991: putc(c,outfile);
2992: }
2993: }
2994:
2995: void flush_final_nl(void)
2996: {
2997: if (nnls > 0)
2998: { putc('\n',outfile);
2999: }
3000: }
3001:
3002: void outputs(char *s)
3003: {
3004: for (;*s;s++)
3005: { outputc(*s);
3006: }
3007: }
3008:
3009: void outputd(int n)
3010: {
3011: char temp[64];
3012:
3013: sprintf(temp,"%d",n);
3014: outputs(temp);
3015: }
3016:
3017: void mark_push_here(MARK *,int,char *);
3018:
3019: void input_mark(void)
3020: {
3021: MARK *m;
3022:
3023: m = NEW(MARK);
3024: check_malloc(m);
3025: m->link = marks;
3026: marks = m;
3027: m->startdepth = fstackdepth;
3028: m->acc = init_accum();
3029: m->nignore = 0;
3030: m->nincs = 0;
3031: mark_push_here(m,curline(),curfile());
3032: #ifdef DEBUG_IO
3033: if (debugging)
3034: { outputs("~MARK~");
3035: }
3036: #endif
3037: }
3038:
3039: void input_unmark(void)
3040: {
3041: MARK *m;
3042:
3043: if (marks)
3044: { m = marks;
3045: marks = m->link;
3046: free(accum_result(m->acc));
3047: OLD(m);
3048: #ifdef DEBUG_IO
3049: if (debugging)
3050: { outputs("~UNMARK~");
3051: }
3052: #endif
3053: }
3054: }
3055:
3056: void input_recover(void)
3057: {
3058: register MARK *m;
3059: register char *txt;
3060: register int i;
3061: register int l;
3062: char c;
3063:
3064: if (marks)
3065: { m = marks;
3066: marks = m->link;
3067: #ifdef DEBUG_IO
3068: if (debugging)
3069: { outputs("~RECOVER~");
3070: }
3071: #endif
3072: for (;m->nignore>0;m->nignore--)
3073: { accum_regret(m->acc);
3074: }
3075: txt = accum_result(m->acc);
3076: i = strlen(txt) - 1;
3077: while (m->nincs > 0)
3078: { l = m->incs[--m->nincs];
3079: for (;i>=l;i--)
3080: { Push(txt[i]);
3081: }
3082: Push(MARKLEND);
3083: c = txt[i];
3084: for (i--;txt[i]!=c;i--)
3085: { Push(txt[i]);
3086: }
3087: Push('A');
3088: Push('@');
3089: Push('@');
3090: Push('@');
3091: Push('@');
3092: Push('@');
3093: Push('@');
3094: Push('@');
3095: for (;(txt[i]!='#')&&(txt[i]!='@');i--) ;
3096: Push(MARKLINE);
3097: i --;
3098: }
3099: for (;i>=0;i--)
3100: { Push(txt[i]);
3101: }
3102: free(txt);
3103: OLD(m);
3104: }
3105: }
3106:
3107: void mark_file_beginning(void)
3108: {
3109: register MARK *m;
3110:
3111: for (m=marks;m;m=m->link)
3112: { m->incs[m->nincs++] = accum_howfar(m->acc);
3113: }
3114: }
3115:
3116: void mark_file_ending(void)
3117: {
3118: register MARK *m;
3119: register int i;
3120: register int to;
3121: register char *acc;
3122:
3123: for (m=marks;m;m=m->link)
3124: { if (m->startdepth > fstackdepth)
3125: { m->startdepth = fstackdepth;
3126: mark_push_here(m,curline(),curfile());
3127: }
3128: else if (m->nincs <= 0)
3129: { fprintf(stderr,"INTERNAL BUG: nincs<0 in mark_file_ending\n");
3130: abort();
3131: }
3132: else
3133: { to = m->incs[--m->nincs];
3134: acc = m->acc;
3135: for (i=accum_howfar(acc);i>to;i--)
3136: { accum_regret(acc);
3137: }
3138: }
3139: }
3140: }
3141:
3142: void mark_charpushed(void)
3143: {
3144: register MARK *m;
3145:
3146: for (m=marks;m;m=m->link)
3147: { m->nignore ++;
3148: }
3149: }
3150:
3151: void mark_got_from_pushback(char c)
3152: {
3153: mark_got(c);
3154: }
3155:
3156: void mark_got_from_file(char c)
3157: {
3158: mark_got(c);
3159: }
3160:
3161: void mark_got(char c)
3162: {
3163: register MARK *m;
3164:
3165: for (m=marks;m;m=m->link)
3166: { if (m->nignore > 0)
3167: { m->nignore --;
3168: }
3169: else
3170: { accum_char(m->acc,c);
3171: }
3172: }
3173: }
3174:
3175: void mark_push_here(MARK *m, int l, char *f)
3176: {
3177: int i;
3178: char c;
3179:
3180: switch (c=accum_regret(m->acc))
3181: { case 0:
3182: break;
3183: case MARKLEND:
3184: while (accum_regret(m->acc) != MARKLINE) ;
3185: break;
3186: default:
3187: accum_char(m->acc,c);
3188: break;
3189: }
3190: accum_char(m->acc,MARKLINE);
3191: for (i=28;i>=0;i-=4)
3192: { accum_char(m->acc,(char)('@'+((l>>i)&0xf)));
3193: }
3194: for (;*f;f++)
3195: { accum_char(m->acc,*f);
3196: }
3197: accum_char(m->acc,MARKLEND);
3198: }
3199:
3200: void mark_get_line(void)
3201: {
3202: int l;
3203: char *f;
3204: int i;
3205: char c;
3206: MARK *m;
3207:
3208: l = 0;
3209: for (i=0;i<8;i++)
3210: { l = (l << 4) + (GET() & 0xf);
3211: }
3212: f = init_accum();
3213: while ((c=GET()) != MARKLEND)
3214: { accum_char(f,c);
3215: }
3216: f = accum_result(f);
3217: out_at(l,f);
3218: for (m=marks;m;m=m->link)
3219: { mark_push_here(m,l,f);
3220: }
3221: free(f);
3222: }
3223:
3224: int ishspace(char c)
3225: {
3226: return((c == ' ') || (c == '\t'));
3227: }
3228:
3229: int isbsymchar(char c)
3230: {
3231: return(isalpha(c) || (c == '_'));
3232: }
3233:
3234: int issymchar(char c)
3235: {
3236: return(isalnum(c) || (c == '_') || (c == '$'));
3237: }
3238:
3239: void do_line(void)
3240: {
3241: char c;
3242:
3243: outputc('#');
3244: while ((c=Get()) != '\n')
3245: { outputc(c);
3246: }
3247: }
3248:
3249: #define DEBUG_MAIN/**/
3250:
3251: extern char **argvec;
3252:
3253: char *Index(char *s, int c);
3254: char *Rindex(char *s, int c);
3255:
3256: #ifdef DEBUG_MAIN
3257: extern int debugging;
3258: #endif
3259:
3260: static char quote;
3261:
3262: IF *ifstack;
3263: int n_skipped_ifs;
3264:
3265: int keep_comments;
3266: int no_line_lines;
3267: int incldep;
3268: char *incldep_o;
3269: int do_at_ctrls;
3270: extern char *predefs[];
3271:
3272: #if defined(SYSV)
3273: void main(ac,av)
3274: #else
3275: void cpp_main(int ac, char **av)
3276: #endif
3277: {
3278: int argno;
3279: int rest;
3280: char *cp;
3281: static FILE *inf;
3282: static FILE *outf;
3283: char *inname;
3284: int backslash;
3285: int i;
3286:
3287: if ( setjmp(cpp_env) ) {
3288: if ( inf != stdin )
3289: fclose(inf);
3290: if ( outf == stdout )
3291: fflush(outf);
3292: else
3293: fclose(outf);
3294: return;
3295: }
3296:
3297: init_symtbl();
3298: #define predef(str) ( (cp=copyofstr("1")), \
3299: check_malloc(cp), \
3300: define((str),-1,(unsigned char *)cp,DEF_PREDEF) )
3301: for (i=0;predefs[i];i++)
3302: { predef(predefs[i]);
3303: }
3304: init_include();
3305: inf = stdin;
3306: outf = stdout;
3307: inname = "";
3308: keep_comments = 0;
3309: no_line_lines = 0;
3310: do_at_ctrls = 0;
3311: incldep = 0;
3312: argno = 0;
3313: for (ac--,av++;ac;ac--,av++)
3314: { if (**av == '-')
3315: { rest = 0;
3316: if (!strcmp(*av,"-undef"))
3317: { undef_predefs();
3318: }
3319: else
3320: { for (++*av;(**av)&&!rest;++*av)
3321: { switch (**av)
3322: { case 'C':
3323: keep_comments = 1;
3324: break;
3325: case 'D':
3326: rest = 1;
3327: ++*av;
3328: if (strcmp(*av,"@") == 0)
3329: { do_at_ctrls = 1;
3330: }
3331: else
3332: { cp = Index(*av,'=');
3333: if (cp)
3334: { if (cp != *av)
3335: { char *dp;
3336: *cp++ = '\0';
3337: dp = copyofstr(cp);
3338: check_malloc(dp);
3339: define(*av,-1,(unsigned char *)dp,DEF_CMDLINE);
3340: }
3341: else
3342: { fprintf(stderr,"Must give a name for -D\n");
3343: }
3344: }
3345: else
3346: { char *dp;
3347: dp = copyofstr("1");
3348: check_malloc(dp);
3349: define(*av,-1,(unsigned char *)dp,DEF_CMDLINE);
3350: }
3351: }
3352: break;
3353: case 'E':
3354: break;
3355: case 'I':
3356: rest = 1;
3357: ++*av;
3358: if (**av)
3359: { Ifile(*av);
3360: }
3361: else
3362: { fprintf(stderr,"Must give a directory name for -I\n");
3363: }
3364: break;
3365: case 'M':
3366: incldep = 1;
3367: break;
3368: case 'P':
3369: no_line_lines = 1;
3370: break;
3371: case 'R':
3372: break;
3373: case 'U':
3374: rest = 1;
3375: ++*av;
3376: if (**av)
3377: { undef(*av);
3378: }
3379: else
3380: { fprintf(stderr,"Must give a name for -U\n");
3381: }
3382: break;
3383: default:
3384: fprintf(stderr,"Unknown flag -%c\n",**av);
3385: break;
3386: }
3387: }
3388: }
3389: }
3390: else
3391: { switch (argno++)
3392: { case 0:
3393: if (strcmp(*av,"-") != 0)
3394: { FILE *f;
3395: f = fopen(*av,"r");
3396: if (f == NULL)
3397: { fprintf(stderr,"Cannot open source file %s\n",*av);
3398: }
3399: else
3400: { inf = f;
3401: inname = *av;
3402: }
3403: }
3404: break;
3405: case 1:
3406: if (strcmp(*av,"-") != 0)
3407: { FILE *f;
3408: f = fopen(*av,"w");
3409: if (f == NULL)
3410: { fprintf(stderr,"Can't create %s\n",*av);
3411: }
3412: else
3413: { outf = f;
3414: }
3415: }
3416: break;
3417: default:
3418: fprintf(stderr,"Extra name %s ignored\n",*av);
3419: break;
3420: }
3421: }
3422: }
3423: if (incldep && !inname[0])
3424: { fprintf(stderr,"No input file for -M flag\n");
3425: #if 0
3426: exit(1);
3427: #endif
3428: longjmp(cpp_env,1);
3429: }
3430: if (do_at_ctrls)
3431: { predef("at_sign_ctrls");
3432: }
3433: Ifile("/local/include");
3434: Ifile("/usr/include");
3435: willbefirst = 1;
3436: quote = 0;
3437: backslash = 0;
3438: init_io(inf,inname);
3439: outfile = outf;
3440: ifstack = 0;
3441: n_skipped_ifs = 0;
3442: cp = Rindex(inname,'/');
3443: if (cp)
3444: { *cp = '\0';
3445: init_incldir(inname);
3446: *cp = '/';
3447: }
3448: else
3449: { init_incldir(".");
3450: }
3451: autodef_file(inname);
3452: autodef_line(1);
3453: out_at(1,inname);
3454: if (incldep)
3455: { char *dp;
3456: cp = Rindex(inname,'/');
3457: if (cp)
3458: { cp ++;
3459: }
3460: else
3461: { cp = inname;
3462: }
3463: dp = cp + strlen(cp) - 2;
3464: if ((dp < cp) || strcmp(dp,".c"))
3465: { fprintf(stderr,"Missing .c in %s\n",inname);
3466: #if 0
3467: exit(1);
3468: #endif
3469: longjmp(cpp_env,1);
3470: }
3471: incldep_o = copyofstr(cp);
3472: incldep_o[dp+1-cp] = 'o';
3473: fprintf(outfile,"%s: ",incldep_o);
3474: fprintf(outfile,"%s\n",inname);
3475: }
3476: init_stats();
3477: while (1)
3478: { char c;
3479: int haddigit;
3480: c = Get();
3481: if (backslash)
3482: { maybe_print(c);
3483: backslash = 0;
3484: continue;
3485: }
3486: if (!incldep && (isdigit(c) || (c == '.')))
3487: { haddigit = 0;
3488: while (isdigit(c) || (c == '.'))
3489: { haddigit |= isdigit(c);
3490: maybe_print(c);
3491: c = Get();
3492: }
3493: if (haddigit && ((c == 'e') || (c == 'E')))
3494: { maybe_print(c);
3495: c = Get();
3496: while (isdigit(c))
3497: { maybe_print(c);
3498: c = Get();
3499: }
3500: }
3501: Push(c);
3502: continue;
3503: }
3504: if (quote)
3505: { if (c == '\\')
3506: { maybe_print(c);
3507: backslash = 1;
3508: continue;
3509: }
3510: else if ((c == quote) || (c == '\n'))
3511: { maybe_print(c);
3512: quote = 0;
3513: continue;
3514: }
3515: else
3516: { maybe_print(c);
3517: continue;
3518: }
3519: }
3520: if (c == '\\') /* this weirdness is Reiser semantics.... */
3521: { backslash = 1;
3522: maybe_print(c);
3523: continue;
3524: }
3525: if ((c == '\'') || (c == '"'))
3526: { quote = c;
3527: maybe_print(c);
3528: }
3529: else if (linefirst && (c == '#'))
3530: { do_sharp();
3531: }
3532: else if (do_at_ctrls && (c == '@'))
3533: { do_at();
3534: }
3535: else if (! incldep)
3536: { if (isbsymchar(c) && !in_false_if())
3537: { char *cp;
3538: DEF *d;
3539: cp = init_accum();
3540: while (issymchar(c))
3541: { accum_char(cp,c);
3542: c = Get();
3543: }
3544: Push(c);
3545: cp = accum_result(cp);
3546: #ifdef DEBUG_MAIN
3547: if (debugging)
3548: { outputs("<word:");
3549: outputs(cp);
3550: outputs(">");
3551: }
3552: #endif
3553: d = find_def(cp);
3554: if (d)
3555: { expand_def(d);
3556: n_hits ++;
3557: }
3558: else
3559: { for (;*cp;cp++)
3560: { maybe_print(*cp);
3561: }
3562: n_misses ++;
3563: }
3564: }
3565: else if (c == '/')
3566: { char d;
3567: d = Get();
3568: if (d == '*')
3569: { d = '\0';
3570: if (keep_comments)
3571: { maybe_print('/');
3572: maybe_print('*');
3573: }
3574: do
3575: { c = d;
3576: d = Get();
3577: if ((d == '\n') || keep_comments)
3578: { maybe_print(d);
3579: }
3580: } while ((c != '*') || (d != '/'));
3581: }
3582: else
3583: { Push(d);
3584: maybe_print(c);
3585: }
3586: }
3587: else
3588: { maybe_print(c);
3589: }
3590: }
3591: }
3592: }
3593:
3594: void do_pragma(void)
3595: {
3596: char c;
3597:
3598: if (in_false_if())
3599: { while ((c=Get()) != '\n') ;
3600: }
3601: else
3602: { outputc('#');
3603: outputc('p');
3604: outputc('r');
3605: outputc('a');
3606: outputc('g');
3607: outputc('m');
3608: outputc('a');
3609: outputc(' ');
3610: while ((c=Get()) != '\n')
3611: { outputc(c);
3612: }
3613: }
3614: }
3615:
3616: char *predefs[] = {
3617: "mc68000",
3618: "unix",
3619: "NeXT",
3620: "__MACH__",
3621: 0
3622: };
3623:
3624: void do_set(void)
3625: {
3626: char *mac;
3627: char c;
3628: char temp[64];
3629:
3630: mac = read_ident();
3631: if (! mac)
3632: { err_head();
3633: fprintf(stderr,"@set: missing/illegal macro name\n");
3634: return;
3635: }
3636: if (! in_false_if())
3637: { char *cp;
3638: c = getnonspace();
3639: if (c != '(')
3640: { err_head();
3641: fprintf(stderr,"@set must have ()s\n");
3642: Push(c);
3643: return;
3644: }
3645: sprintf(temp,"%d",eval_expr(0,1));
3646: undef(mac);
3647: cp = copyofstr(temp);
3648: check_malloc(cp);
3649: define(mac,-1,(unsigned char *)cp,DEF_DEFINE);
3650: }
3651: free(mac);
3652: }
3653:
3654: void do_sharp(void)
3655: {
3656: char *w;
3657: char c;
3658:
3659: w = read_ctrl();
3660: if (strcmp(w,"ifdef") == 0)
3661: { do_ifdef(1);
3662: }
3663: else if (strcmp(w,"ifndef") == 0)
3664: { do_ifndef(1);
3665: }
3666: else if (strcmp(w,"if") == 0)
3667: { do_if(1);
3668: }
3669: else if (strcmp(w,"else") == 0)
3670: { do_else(1);
3671: }
3672: else if (strcmp(w,"elif") == 0)
3673: { do_elif(1);
3674: }
3675: else if (strcmp(w,"endif") == 0)
3676: { do_endif(1);
3677: }
3678: else if (strcmp(w,"include") == 0)
3679: { do_include(1);
3680: }
3681: else if (strcmp(w,"define") == 0)
3682: { do_define(1,0);
3683: }
3684: else if (strcmp(w,"undef") == 0)
3685: { do_undef(1);
3686: }
3687: else if (strcmp(w,"line") == 0)
3688: { do_line();
3689: }
3690: else if (strcmp(w,"pragma") == 0)
3691: { do_pragma();
3692: }
3693: else if (strcmp(w,"") == 0)
3694: {
3695: }
3696: else
3697: { int isnull;
3698: isnull = 0;
3699: if (strcmp(w,"") == 0)
3700: { c = Get();
3701: if (c != '\n')
3702: { Push(c);
3703: }
3704: else
3705: { isnull = 1;
3706: }
3707: }
3708: if (!isnull && !in_false_if())
3709: { err_head();
3710: fprintf(stderr,"unknown control `%s'\n",w);
3711: flush_sharp_line();
3712: }
3713: }
3714: maybe_print('\n');
3715: free(w);
3716: }
3717:
3718: void flush_sharp_line(void)
3719: {
3720: int quote;
3721: int backslash;
3722: int comment;
3723: int lastc;
3724: int c;
3725:
3726: quote = 0;
3727: backslash = 0;
3728: comment = 0;
3729: c = 'x';
3730: while (1)
3731: { lastc = c;
3732: c = Get();
3733: if (backslash)
3734: { backslash = 0;
3735: continue;
3736: }
3737: if (comment)
3738: { if (c == '\\')
3739: { backslash = 1;
3740: }
3741: else if ((c == '/') && (lastc == '*'))
3742: { comment = 0;
3743: }
3744: continue;
3745: }
3746: if (quote)
3747: { if (c == '\\')
3748: { backslash = 1;
3749: }
3750: else if (c == quote)
3751: { quote = 0;
3752: }
3753: }
3754: switch (c)
3755: { case '\\':
3756: backslash = 1;
3757: continue;
3758: break;
3759: case '"': case '\'':
3760: quote = c;
3761: continue;
3762: break;
3763: case '*':
3764: comment = (lastc == '/');
3765: continue;
3766: break;
3767: default:
3768: continue;
3769: break;
3770: case '\n':
3771: break;
3772: }
3773: break;
3774: }
3775: }
3776:
3777:
3778: int n_defines;
3779: int n_undefines;
3780: int n_hits;
3781: int n_misses;
3782:
3783: void init_stats(void)
3784: {
3785: n_defines = 0;
3786: n_undefines = 0;
3787: n_hits = 0;
3788: n_misses = 0;
3789: }
3790:
3791: void save_stats(void)
3792: {
3793: FILE *f;
3794:
3795: f = fopen("/@larry/u1/mouse/Mouse-C/cpp.stats","a");
3796: if (f)
3797: { fprintf(f,"%d def, %d undef, %d hits, %d misses\n",
3798: n_defines,n_undefines,n_hits,n_misses);
3799: fclose(f);
3800: }
3801: }
3802:
3803: DEF **symtbl;
3804: int symtbl_size;
3805: int n_in_table;
3806:
3807: static int size_index;
3808: static int sizes[] = { 7, 37, 179, 719, 2003, 8009, 30011, 120011, 0 };
3809:
3810: static int hash(unsigned char *s)
3811: {
3812: register unsigned int i;
3813:
3814: for (i=0;*s;s++)
3815: { i = (i >> 8) + (i << 3) + *s;
3816: }
3817: i &= ~0x80000000;
3818: return(i%symtbl_size);
3819: }
3820:
3821: void init_symtbl(void)
3822: {
3823: int i;
3824:
3825: symtbl_size = sizes[size_index=0];
3826: symtbl = (DEF **) malloc(symtbl_size*sizeof(DEF *));
3827: check_malloc(symtbl);
3828: for (i=0;i<symtbl_size;i++)
3829: { symtbl[i] = 0;
3830: }
3831: n_in_table = 0;
3832: }
3833:
3834: static void rehash_up(void)
3835: {
3836: int osize;
3837: DEF **otbl;
3838: int i;
3839: DEF *d;
3840: DEF *n;
3841: int h;
3842:
3843: if ((sizes[size_index] == 0) || (sizes[++size_index] == 0))
3844: { return;
3845: }
3846: osize = symtbl_size;
3847: otbl = symtbl;
3848: symtbl_size = sizes[size_index];
3849: symtbl = (DEF **) malloc(symtbl_size*sizeof(DEF *));
3850: check_malloc(symtbl);
3851: for (i=0;i<symtbl_size;i++)
3852: { symtbl[i] = 0;
3853: }
3854: for (i=0;i<osize;i++)
3855: { for (d=otbl[i];d;d=n)
3856: { n = d->link;
3857: h = hash((unsigned char *)d->name);
3858: d->link = symtbl[h];
3859: symtbl[h] = d;
3860: }
3861: }
3862: free((char *)otbl);
3863: }
3864:
3865: void define(char *name, int nargs, unsigned char *repl, int how)
3866: {
3867: int h;
3868: DEF *d;
3869: char *n;
3870:
3871: n = copyofstr(name);
3872: h = hash((unsigned char *)n);
3873: for (d=symtbl[h];d;d=d->link)
3874: { if (strcmp(d->name,n) == 0)
3875: { break;
3876: }
3877: }
3878: if (d)
3879: { if ( (nargs != d->nargs) || strcmp((char *)repl,(char *)d->repl) )
3880: { err_head();
3881: fprintf(stderr,"%s redefined\n",n);
3882: }
3883: free((char *)d->repl);
3884: free(d->name);
3885: d->name = n;
3886: d->nargs = nargs;
3887: d->repl = repl;
3888: d->how = how;
3889: }
3890: else
3891: { d = NEW(DEF);
3892: check_malloc(d);
3893: d->name = n;
3894: d->nargs = nargs;
3895: d->repl = repl;
3896: d->how = how;
3897: d->link = symtbl[h];
3898: symtbl[h] = d;
3899: n_in_table ++;
3900: if (n_in_table > 2*symtbl_size)
3901: { rehash_up();
3902: }
3903: }
3904: if (strcmp(n,"at_sign_ctrls") == 0)
3905: { extern int do_at_ctrls;
3906: do_at_ctrls = 1;
3907: }
3908: }
3909:
3910: int undef(char *name)
3911: {
3912: int h;
3913: DEF **D;
3914: DEF *d;
3915: int rv;
3916:
3917: h = hash((unsigned char *)name);
3918: for (D=symtbl+h;*D;D= &(*D)->link)
3919: { if (strcmp((*D)->name,name) == 0)
3920: { break;
3921: }
3922: }
3923: rv = 0;
3924: if (d = *D)
3925: { *D = d->link;
3926: free(d->name);
3927: free((char *)d->repl);
3928: OLD(d);
3929: n_in_table --;
3930: rv = 1;
3931: }
3932: if (strcmp(name,"at_sign_ctrls") == 0)
3933: { extern int do_at_ctrls;
3934: do_at_ctrls = 0;
3935: }
3936: return rv;
3937: }
3938:
3939: DEF *find_def(char *name)
3940: {
3941: int h;
3942: DEF *d;
3943:
3944: h = hash((unsigned char *)name);
3945: for (d=symtbl[h];d;d=d->link)
3946: { if (strcmp(d->name,name) == 0)
3947: { break;
3948: }
3949: }
3950: return(d);
3951: }
3952:
3953: void defd(char *name, int value)
3954: {
3955: char temp[64];
3956: char *cp;
3957:
3958: sprintf(temp,"%d",value);
3959: undef(name);
3960: cp = copyofstr(temp);
3961: check_malloc(cp);
3962: define(name,-1,(unsigned char *)cp,DEF_DEFINE);
3963: }
3964:
3965: void undef_predefs(void)
3966: {
3967: int h;
3968: DEF **D;
3969: DEF *d;
3970:
3971: for (h=symtbl_size-1;h>=0;h--)
3972: { D = symtbl + h;
3973: while (*D)
3974: { d = *D;
3975: if (d->how == DEF_PREDEF)
3976: { free(d->name);
3977: free((char *)d->repl);
3978: *D = d->link;
3979: OLD(d);
3980: n_in_table --;
3981: }
3982: else
3983: { D = &d->link;
3984: }
3985: }
3986: }
3987: }
3988:
3989: char *_unctrl[0400] = { "^@",
3990: "^A",
3991: "^B",
3992: "^C",
3993: "^D",
3994: "^E",
3995: "^F",
3996: "^G",
3997: "^H",
3998: "^I",
3999: "^J",
4000: "^K",
4001: "^L",
4002: "^M",
4003: "^N",
4004: "^O",
4005: "^P",
4006: "^Q",
4007: "^R",
4008: "^S",
4009: "^T",
4010: "^U",
4011: "^V",
4012: "^W",
4013: "^X",
4014: "^Y",
4015: "^Z",
4016: "^[",
4017: "^\\",
4018: "^]",
4019: "^^",
4020: "^_",
4021: " ",
4022: "!",
4023: "\"",
4024: "#",
4025: "$",
4026: "%",
4027: "&",
4028: "'",
4029: "(",
4030: ")",
4031: "*",
4032: "+",
4033: ",",
4034: "-",
4035: ".",
4036: "/",
4037: "0",
4038: "1",
4039: "2",
4040: "3",
4041: "4",
4042: "5",
4043: "6",
4044: "7",
4045: "8",
4046: "9",
4047: ":",
4048: ";",
4049: "<",
4050: "=",
4051: ">",
4052: "?",
4053: "@",
4054: "A",
4055: "B",
4056: "C",
4057: "D",
4058: "E",
4059: "F",
4060: "G",
4061: "H",
4062: "I",
4063: "J",
4064: "K",
4065: "L",
4066: "M",
4067: "N",
4068: "O",
4069: "P",
4070: "Q",
4071: "R",
4072: "S",
4073: "T",
4074: "U",
4075: "V",
4076: "W",
4077: "X",
4078: "Y",
4079: "Z",
4080: "[",
4081: "\\",
4082: "]",
4083: "^",
4084: "_",
4085: "`",
4086: "a",
4087: "b",
4088: "c",
4089: "d",
4090: "e",
4091: "f",
4092: "g",
4093: "h",
4094: "i",
4095: "j",
4096: "k",
4097: "l",
4098: "m",
4099: "n",
4100: "o",
4101: "p",
4102: "q",
4103: "r",
4104: "s",
4105: "t",
4106: "u",
4107: "v",
4108: "w",
4109: "x",
4110: "y",
4111: "z",
4112: "{"/*}*/,
4113: "|",
4114: /*{*/"}",
4115: "~",
4116: "^?",
4117: "|^@",
4118: "|^A",
4119: "|^B",
4120: "|^C",
4121: "|^D",
4122: "|^E",
4123: "|^F",
4124: "|^G",
4125: "|^H",
4126: "|^I",
4127: "|^J",
4128: "|^K",
4129: "|^L",
4130: "|^M",
4131: "|^N",
4132: "|^O",
4133: "|^P",
4134: "|^Q",
4135: "|^R",
4136: "|^S",
4137: "|^T",
4138: "|^U",
4139: "|^V",
4140: "|^W",
4141: "|^X",
4142: "|^Y",
4143: "|^Z",
4144: "|^[",
4145: "|^\\",
4146: "|^]",
4147: "|^^",
4148: "|^_",
4149: "| ",
4150: "|!",
4151: "|\"",
4152: "|#",
4153: "|$",
4154: "|%",
4155: "|&",
4156: "|'",
4157: "|(",
4158: "|)",
4159: "|*",
4160: "|+",
4161: "|,",
4162: "|-",
4163: "|.",
4164: "|/",
4165: "|0",
4166: "|1",
4167: "|2",
4168: "|3",
4169: "|4",
4170: "|5",
4171: "|6",
4172: "|7",
4173: "|8",
4174: "|9",
4175: "|:",
4176: "|;",
4177: "|<",
4178: "|=",
4179: "|>",
4180: "|?",
4181: "|@",
4182: "|A",
4183: "|B",
4184: "|C",
4185: "|D",
4186: "|E",
4187: "|F",
4188: "|G",
4189: "|H",
4190: "|I",
4191: "|J",
4192: "|K",
4193: "|L",
4194: "|M",
4195: "|N",
4196: "|O",
4197: "|P",
4198: "|Q",
4199: "|R",
4200: "|S",
4201: "|T",
4202: "|U",
4203: "|V",
4204: "|W",
4205: "|X",
4206: "|Y",
4207: "|Z",
4208: "|[",
4209: "|\\",
4210: "|]",
4211: "|^",
4212: "|_",
4213: "|`",
4214: "|a",
4215: "|b",
4216: "|c",
4217: "|d",
4218: "|e",
4219: "|f",
4220: "|g",
4221: "|h",
4222: "|i",
4223: "|j",
4224: "|k",
4225: "|l",
4226: "|m",
4227: "|n",
4228: "|o",
4229: "|p",
4230: "|q",
4231: "|r",
4232: "|s",
4233: "|t",
4234: "|u",
4235: "|v",
4236: "|w",
4237: "|x",
4238: "|y",
4239: "|z",
4240: "|{"/*}*/,
4241: "||",
4242: /*{*/"|}",
4243: "|~",
4244: "|^?" };
4245:
4246: char *_Unctrl[0400] = { "^@",
4247: "^A",
4248: "^B",
4249: "^C",
4250: "^D",
4251: "^E",
4252: "^F",
4253: "^G",
4254: "^H",
4255: "^I",
4256: "^J",
4257: "^K",
4258: "^L",
4259: "^M",
4260: "^N",
4261: "^O",
4262: "^P",
4263: "^Q",
4264: "^R",
4265: "^S",
4266: "^T",
4267: "^U",
4268: "^V",
4269: "^W",
4270: "^X",
4271: "^Y",
4272: "^Z",
4273: "^[",
4274: "^\\",
4275: "^]",
4276: "^^",
4277: "^_",
4278: "sp",
4279: "!",
4280: "\"",
4281: "#",
4282: "$",
4283: "%",
4284: "&",
4285: "'",
4286: "(",
4287: ")",
4288: "*",
4289: "+",
4290: ",",
4291: "-",
4292: ".",
4293: "/",
4294: "0",
4295: "1",
4296: "2",
4297: "3",
4298: "4",
4299: "5",
4300: "6",
4301: "7",
4302: "8",
4303: "9",
4304: ":",
4305: ";",
4306: "<",
4307: "=",
4308: ">",
4309: "?",
4310: "@",
4311: "A",
4312: "B",
4313: "C",
4314: "D",
4315: "E",
4316: "F",
4317: "G",
4318: "H",
4319: "I",
4320: "J",
4321: "K",
4322: "L",
4323: "M",
4324: "N",
4325: "O",
4326: "P",
4327: "Q",
4328: "R",
4329: "S",
4330: "T",
4331: "U",
4332: "V",
4333: "W",
4334: "X",
4335: "Y",
4336: "Z",
4337: "[",
4338: "\\",
4339: "]",
4340: "^",
4341: "_",
4342: "`",
4343: "a",
4344: "b",
4345: "c",
4346: "d",
4347: "e",
4348: "f",
4349: "g",
4350: "h",
4351: "i",
4352: "j",
4353: "k",
4354: "l",
4355: "m",
4356: "n",
4357: "o",
4358: "p",
4359: "q",
4360: "r",
4361: "s",
4362: "t",
4363: "u",
4364: "v",
4365: "w",
4366: "x",
4367: "y",
4368: "z",
4369: "{"/*}*/,
4370: "|",
4371: /*{*/"}",
4372: "~",
4373: "^?",
4374: "|^@",
4375: "|^A",
4376: "|^B",
4377: "|^C",
4378: "|^D",
4379: "|^E",
4380: "|^F",
4381: "|^G",
4382: "|^H",
4383: "|^I",
4384: "|^J",
4385: "|^K",
4386: "|^L",
4387: "|^M",
4388: "|^N",
4389: "|^O",
4390: "|^P",
4391: "|^Q",
4392: "|^R",
4393: "|^S",
4394: "|^T",
4395: "|^U",
4396: "|^V",
4397: "|^W",
4398: "|^X",
4399: "|^Y",
4400: "|^Z",
4401: "|^[",
4402: "|^\\",
4403: "|^]",
4404: "|^^",
4405: "|^_",
4406: "|sp",
4407: "|!",
4408: "|\"",
4409: "|#",
4410: "|$",
4411: "|%",
4412: "|&",
4413: "|'",
4414: "|(",
4415: "|)",
4416: "|*",
4417: "|+",
4418: "|,",
4419: "|-",
4420: "|.",
4421: "|/",
4422: "|0",
4423: "|1",
4424: "|2",
4425: "|3",
4426: "|4",
4427: "|5",
4428: "|6",
4429: "|7",
4430: "|8",
4431: "|9",
4432: "|:",
4433: "|;",
4434: "|<",
4435: "|=",
4436: "|>",
4437: "|?",
4438: "|@",
4439: "|A",
4440: "|B",
4441: "|C",
4442: "|D",
4443: "|E",
4444: "|F",
4445: "|G",
4446: "|H",
4447: "|I",
4448: "|J",
4449: "|K",
4450: "|L",
4451: "|M",
4452: "|N",
4453: "|O",
4454: "|P",
4455: "|Q",
4456: "|R",
4457: "|S",
4458: "|T",
4459: "|U",
4460: "|V",
4461: "|W",
4462: "|X",
4463: "|Y",
4464: "|Z",
4465: "|[",
4466: "|\\",
4467: "|]",
4468: "|^",
4469: "|_",
4470: "|`",
4471: "|a",
4472: "|b",
4473: "|c",
4474: "|d",
4475: "|e",
4476: "|f",
4477: "|g",
4478: "|h",
4479: "|i",
4480: "|j",
4481: "|k",
4482: "|l",
4483: "|m",
4484: "|n",
4485: "|o",
4486: "|p",
4487: "|q",
4488: "|r",
4489: "|s",
4490: "|t",
4491: "|u",
4492: "|v",
4493: "|w",
4494: "|x",
4495: "|y",
4496: "|z",
4497: "|{"/*}*/,
4498: "||",
4499: /*{*/"|}",
4500: "|~",
4501: "|^?" };
4502:
4503: void do_undef(int expr_sharp)
4504: {
4505: char *mac;
4506:
4507: if (! in_false_if())
4508: { mac = read_ident();
4509: if (! mac)
4510: { err_head();
4511: fprintf(stderr,"missing/illegal macro name\n");
4512: }
4513: else
4514: { if (undef(mac))
4515: { n_undefines ++;
4516: }
4517: }
4518: }
4519: if (sharp)
4520: { flush_sharp_line();
4521: }
4522: }
4523: /*#define DEBUG_WHILE/**/
4524:
4525: #ifdef DEBUG_WHILE
4526: extern int debugging;
4527: #endif
4528:
4529: void do_while(void)
4530: {
4531: input_mark();
4532: do_if(0);
4533: }
4534:
4535: void do_endwhile(void)
4536: {
4537: if (in_false_if())
4538: { do_endif(0);
4539: input_unmark();
4540: #ifdef DEBUG_WHILE
4541: if (debugging)
4542: { outputs("//endwhile:");
4543: outputd(curline());
4544: outputs(",");
4545: outputs(curfile());
4546: outputs("\\\\");
4547: }
4548: #endif
4549: out_at(curline(),curfile());
4550: }
4551: else
4552: { do_endif(0);
4553: input_recover();
4554: input_mark();
4555: do_if(0);
4556: }
4557: }
4558:
4559: char *Index(char *s, int c)
4560: {
4561: return strchr(s,c);
4562: }
4563:
4564: char *Rindex(char *s, int c)
4565: {
4566: return strrchr(s,c);
4567: }
4568:
4569: void Bcopy(char *from, char *to, int len)
4570: {
4571: #if defined(GO32)
4572: bcopy(from,to,len);
4573: #else
4574: memmove((void *)from,(void *)to,(int)len);
4575: #endif
4576: }