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