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