home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 6 / FreshFish_September1994.bin / bbs / gnu / emacs-18.59-src.lha / GNU / src / amiga / emacs-18.59 / cpp / cccp.c next >
Encoding:
C/C++ Source or Header  |  1993-06-05  |  64.8 KB  |  2,553 lines
  1. /* C Compatible Compiler Preprocessor (CCCP)
  2. Copyright (C) 1986, Free Software Foundation, Inc.
  3.                     Written by Paul Rubin, June 1986
  4.  
  5.                NO WARRANTY
  6.  
  7.   BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
  8. NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
  9. WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
  10. RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
  11. WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  12. BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  13. FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
  14. AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
  15. DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
  16. CORRECTION.
  17.  
  18.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
  19. STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
  20. WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
  21. LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
  22. OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
  23. USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
  24. DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
  25. A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
  26. PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
  27. DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
  28.  
  29.         GENERAL PUBLIC LICENSE TO COPY
  30.  
  31.   1. You may copy and distribute verbatim copies of this source file
  32. as you receive it, in any medium, provided that you conspicuously
  33. and appropriately publish on each copy a valid copyright notice
  34. "Copyright (C) 1986 Free Software Foundation"; and include
  35. following the copyright notice a verbatim copy of the above disclaimer
  36. of warranty and of this License.
  37.  
  38.   2. You may modify your copy or copies of this source file or
  39. any portion of it, and copy and distribute such modifications under
  40. the terms of Paragraph 1 above, provided that you also do the following:
  41.  
  42.     a) cause the modified files to carry prominent notices stating
  43.     that you changed the files and the date of any change; and
  44.  
  45.     b) cause the whole of any work that you distribute or publish,
  46.     that in whole or in part contains or is a derivative of this
  47.     program or any part thereof, to be licensed at no charge to all
  48.     third parties on terms identical to those contained in this
  49.     License Agreement (except that you may choose to grant more extensive
  50.     warranty protection to some or all third parties, at your option).
  51.  
  52.     c) You may charge a distribution fee for the physical act of
  53.     transferring a copy, and you may at your option offer warranty
  54.     protection in exchange for a fee.
  55.  
  56. Mere aggregation of another unrelated program with this program (or its
  57. derivative) on a volume of a storage or distribution medium does not bring
  58. the other program under the scope of these terms.
  59.  
  60.   3. You may copy and distribute this program (or a portion or derivative
  61. of it, under Paragraph 2) in object code or executable form under the terms
  62. of Paragraphs 1 and 2 above provided that you also do one of the following:
  63.  
  64.     a) accompany it with the complete corresponding machine-readable
  65.     source code, which must be distributed under the terms of
  66.     Paragraphs 1 and 2 above; or,
  67.  
  68.     b) accompany it with a written offer, valid for at least three
  69.     years, to give any third party free (except for a nominal
  70.     shipping charge) a complete machine-readable copy of the
  71.     corresponding source code, to be distributed under the terms of
  72.     Paragraphs 1 and 2 above; or,
  73.  
  74.     c) accompany it with the information you received as to where the
  75.     corresponding source code may be obtained.  (This alternative is
  76.     allowed only for noncommercial distribution and only if you
  77.     received the program in object code or executable form alone.)
  78.  
  79. For an executable file, complete source code means all the source code for
  80. all modules it contains; but, as a special exception, it need not include
  81. source code for modules which are standard libraries that accompany the
  82. operating system on which the executable file runs.
  83.  
  84.   4. You may not copy, sublicense, distribute or transfer this program
  85. except as expressly provided under this License Agreement.  Any attempt
  86. otherwise to copy, sublicense, distribute or transfer this program is void and
  87. your rights to use the program under this License agreement shall be
  88. automatically terminated.  However, parties who have received computer
  89. software programs from you with this License Agreement will not have
  90. their licenses terminated so long as such parties remain in full compliance.
  91.  
  92.  In other words, you are welcome to use, share and improve this program.
  93.  You are forbidden to forbid anyone else to use, share and improve
  94.  what you give them.   Help stamp out software-hoarding!  */
  95.  
  96. typedef unsigned char U_CHAR;
  97.  
  98. #ifdef EMACS
  99. #define NO_SHORTNAMES
  100. #ifdef AMIGA
  101. #include "/src/config.h"
  102. #undef fflush
  103. #undef fwrite
  104. #undef main
  105. #undef putchar
  106. #undef AMIGA_DUMP
  107. #include <string.h>
  108. #else
  109. #include "../src/config.h"
  110. #endif
  111. #ifdef static
  112. #undef static
  113. #endif
  114. #ifdef open
  115. #undef open
  116. #undef close
  117. #undef read
  118. #undef write
  119. #endif /* open */
  120. #endif /* EMACS */
  121.  
  122. #include <sys/types.h>
  123. #include <sys/stat.h>
  124. #include <sys/file.h>
  125. #include <ctype.h>
  126. #include <stdio.h>
  127. #ifndef USG
  128. #ifdef AMIGA
  129. #include <time.h>
  130. #else
  131. #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  132. #endif
  133. #else
  134. #define index strchr
  135. #define rindex strrchr
  136. #include <time.h>
  137. #include <fcntl.h>
  138. #endif /* USG */
  139.  
  140. #ifndef AMIGA
  141. void bcopy (), bzero ();
  142. int bcmp ();
  143. #endif
  144.  
  145. char *xmalloc (), *xrealloc (), *xcalloc ();
  146. void fatal (), pfatal_with_name (), perror_with_name ();
  147.  
  148. char *progname;
  149.  
  150. #define FATAL_EXIT_CODE 33    /* gnu cc command understands this */
  151.  
  152. struct directory_stack
  153.   {
  154.     struct directory_stack *next;
  155.     char *fname;
  156.   };
  157.  
  158. /* #include "file" starts with the first entry in the stack */
  159. /* #include <file> starts with the second. */
  160. /* -I directories are added after the first */
  161. #ifdef AMIGA
  162. struct directory_stack default_includes[2] =
  163.   {
  164.     { &default_includes[1], "" },
  165.     { 0, "include:" }
  166.   };
  167. #else
  168. struct directory_stack default_includes[2] =
  169.   {
  170.     { &default_includes[1], "." },
  171.     { 0, "/usr/include" }
  172.   };
  173. #endif
  174.  
  175. struct directory_stack *include = &default_includes[0];
  176.  
  177. #ifdef AMIGA
  178. int max_include_len = 14;    /* strlen (default_include) + 2
  179.                             (for / and null) */
  180. #else
  181. int max_include_len = 9;    /* strlen (default_include) + 1
  182.                             (for null) */
  183. #endif
  184.  
  185. char STDIN_FILE[] = "";        /* Empty, like real cpp */
  186. int put_out_comments = 0;    /* JF non-zero means leave comments in the
  187.                    output file.  Used by lint */
  188.  
  189. /* table to tell if char can be part of a C identifier. */
  190. U_CHAR is_idchar[256];
  191. /* table to tell if char can be first char of a c identifier. */
  192. U_CHAR is_idstart[256];
  193. /* table to tell if c is horizontal space.  isspace() thinks that
  194.    newline is space; this is not a good idea for this program. */
  195. U_CHAR is_hor_space[256];
  196.  
  197. /* I/O buffer structure.  Ought to be used for the output file too.
  198.    These are also used when there is no file present, for example,
  199.    when rescanning a definition.  Then, the fname field is null. */
  200. #define INPUT_STACK_MAX 100
  201. struct file_buf {
  202.   struct infile *next;    /* for making stacks of file ptrs */
  203.   char *fname;
  204.   int lineno;
  205.   int length;
  206.   U_CHAR *buf;
  207.   U_CHAR *bufp;
  208. } instack[INPUT_STACK_MAX];
  209. int indepth = 0;
  210.  
  211. typedef struct file_buf FILE_BUF;
  212.  
  213. /* The output buffer.  Its LENGTH field is the amount of room allocated
  214.    for the buffer, not the number of chars actually present.  To get
  215.    that, subtract outbuf.buf from outbuf.bufp. */
  216.  
  217. #define OUTBUF_SIZE 10    /* initial size of output buffer */
  218. FILE_BUF outbuf;
  219.  
  220. /* Structure allocated for every #define.  For a simple replacement
  221.    such as
  222.        #define foo bar ,
  223.    nargs = -1, the `pattern' list is null, and the expansion is just
  224.    the replacement text.  Nargs = 0 means a real macro with no args,
  225.    e.g.,
  226.        #define getchar() getc(stdin) .
  227.    When there are args, the expansion is the replacement text with the
  228.    args squashed out, and the reflist is a list describing how to
  229.    build the output from the input: e.g., "3 chars, then the 1st arg,
  230.    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
  231.    The chars here come from the expansion.  Thus, for any definition
  232.    d , strlen(d->expansion) should equal the sum of all the
  233.    d->pattern->nchars.  Note that the list can be arbitrarily long---
  234.    its length depends on the number of times the arguements appear in
  235.    the replacement text, not how many args there are.  Example:
  236.    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
  237.    pattern list
  238.      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
  239.    where (x, y) means (nchars, argno). */
  240.  
  241. typedef struct definition DEFINITION;
  242. struct definition {
  243.   int nargs;
  244.   int length;            /* length of expansion string */
  245.   U_CHAR *expansion;
  246.   struct reflist {
  247.     struct reflist *next;
  248.     int nchars;
  249.     int argno;
  250.   } *pattern;
  251. };
  252.  
  253. /* different kinds of things that can appear in the value field
  254.    of a hash node.  Actually, this may be useless now. */
  255. union hashval {
  256.   int ival;
  257.   char *cpval;
  258.   DEFINITION *defn;
  259. };
  260.  
  261.  
  262. /* The structure of a node in the hash table.  The hash table
  263.    has entries for all tokens defined by #define commands (type T_MACRO),
  264.    plus some special tokens like __LINE__ (these each have their own
  265.    type, and the appropriate code is run when that type of node is seen.
  266.    It does not contain control words like "#define", which are recognized
  267.    by a separate piece of code. */
  268. typedef struct hashnode HASHNODE;
  269. struct hashnode {
  270.   HASHNODE *next;        /* double links for easy deletion */
  271.   HASHNODE *prev;
  272.   HASHNODE **bucket_hdr;    /* also, a back pointer to this node's hash
  273.                    chain is kept, in case the node is the head
  274.                    of the chain and gets deleted. */
  275.   int type;            /* type of special token */
  276.   int length;            /* length of token, for quick comparison */
  277.   U_CHAR *name;            /* the actual name */
  278.   union hashval value;        /* pointer to expansion, or whatever */
  279. };
  280.  
  281.  
  282. HASHNODE *install();
  283. /* different flavors of hash nodes --- also used in keyword table */
  284. #define T_DEFINE    1    /* the "#define" keyword */
  285. #define T_INCLUDE    2    /* the "#include" keyword */
  286. #define T_IFDEF        3    /* the "#ifdef" keyword */
  287. #define T_IF        4    /* the "#if" keyword */
  288. #define T_EXPAND    5    /* argument to be expanded (now unused) */
  289. #define T_MACRO        6    /* macro defined by "#define" */
  290. #define T_ELSE        7    /* "#else" */
  291. #define T_PRAGMA    8    /* "#pragma" */
  292. #define T_ELIF        9    /* "#else" */
  293. #define T_UNDEF        10    /* "#undef" */
  294. #define T_LINE        11    /* "#line" */
  295. #define T_ERROR        12    /* "#error" */
  296. #define T_IFNDEF    13    /* "#ifndef"; forgot this earlier */
  297. #define T_ENDIF        14    /* "#endif" */
  298. #define T_SPECLINE    15    /* special symbol "__LINE__" */
  299. #define T_DATE        16    /* "__DATE__" */
  300. #define T_FILE        17    /* "__FILE__" */
  301. #define T_TIME        18    /* "__TIME__" */
  302.  
  303. #define T_SPEC_DEFINED    19    /* special macro for use in #if statements */
  304.  
  305.  
  306.  
  307. /* some more different types will be needed --- no longer bloody likely */
  308.  
  309.  
  310. int do_define(), do_line(), do_include(), do_undef(), do_error(),
  311.   do_pragma(), do_if(), do_xifdef(), do_else(),
  312.   do_elif(), do_endif();
  313.  
  314.  
  315. /* table of control words, along with code to execute when the keyword
  316.    is seen.  For now, it is searched linearly, so put the most frequently
  317.    found keywords at the beginning of the list. */
  318.  
  319. struct keyword_table {
  320.   int length;
  321.   int (*func)();
  322.   char *name;
  323.   int type;
  324. } keyword_table[] = {
  325.   {  6, do_define, "define", T_DEFINE},
  326.   {  4, do_line, "line", T_LINE},
  327.   {  7, do_include, "include", T_INCLUDE},
  328.   {  5, do_undef, "undef", T_UNDEF},
  329.   {  5, do_error, "error", T_ERROR},
  330.   {  2, do_if, "if", T_IF},
  331.   {  5, do_xifdef, "ifdef", T_IFDEF},
  332.   {  6, do_xifdef, "ifndef", T_IFNDEF},
  333.   {  4, do_else, "else", T_ELSE},
  334.   {  4, do_elif, "elif", T_ELIF},
  335.   {  5, do_endif, "endif", T_ENDIF},
  336.   {  6, do_pragma, "pragma", T_PRAGMA},
  337.   {  -1, 0, "", -1},
  338. };
  339.  
  340. /* Some definitions for the hash table.  The hash function MUST be
  341.    computed as shown in hashf() below.  That is because the rescan
  342.    loop computes the hash value `on the fly' for most tokens,
  343.    in order to avoid the overhead of a lot of procedure calls to
  344.    the hashf() function.  Hashf() only exists for the sake of
  345.    politeness, for use when speed isn't so important. */
  346.  
  347. #define HASHSIZE 1009
  348. HASHNODE *hashtab[HASHSIZE];
  349. #define HASHSTEP(old, c) ((old << 1) + c)
  350. #define MAKE_POS(v) (v & ~0x80000000) /* make number positive */
  351.  
  352. #define SKIP_WHITE_SPACE(p) { while (is_hor_space[*p]) p++; }
  353.  
  354.  
  355.  
  356. main (argc, argv)
  357.      int argc;
  358.      char **argv;
  359. {
  360.   struct stat sbuf;
  361.   char *in_fname, *out_fname;
  362.   int out_fd = 1;    /* default to stdout */
  363.   int f, i;
  364.   FILE_BUF *fp;
  365.  
  366.   progname = argv[0];
  367.   in_fname = NULL;
  368.   out_fname = NULL;
  369.   initialize_random_junk ();
  370.  
  371.   fp = &instack[indepth++];
  372.  
  373. /*  if (argc < 2)        JF no args means work as filter
  374.     return FATAL_EXIT_CODE; */
  375.  
  376.   for (i = 1; i < argc; i++) {
  377.     if (argv[i][0] != '-') {
  378.       if (out_fname != NULL)
  379.     fatal ("Usage: %s [switches] input output\n", argv[0]);
  380.       else if (in_fname != NULL) {
  381.     out_fname = argv[i];
  382.     if ((out_fd = creat (out_fname, 0666)) < 0)
  383.       pfatal_with_name (out_fname);
  384.       } else
  385.     in_fname = argv[i];
  386.     } else {
  387.       switch (argv[i][1]) {
  388.     U_CHAR *p;
  389.     struct directory_stack *dirtmp;
  390.       case 'D':
  391.     if ((p = (U_CHAR *) index(argv[i]+2, '=')) != NULL)
  392.       *p = ' ';
  393.     make_definition (argv[i] + 2);
  394.     break;
  395.       case 'U':        /* JF #undef something */
  396.     make_undef(argv[i] + 2);
  397.     break;
  398.       case 'C':        /* JF do later -C means leave comments alone! */
  399.     put_out_comments++;
  400.     break;
  401.       case 'E':            /* -E comes from cc -E; ignore it.  */
  402.     break;
  403.       case 'M':            /* Makefile dependencies or something like
  404.                    that.  Not implimented yet */
  405.     break;
  406.       case 'I':            /* JF handle directory path right */
  407.         dirtmp = (struct directory_stack *)
  408.             xmalloc (sizeof (struct directory_stack));
  409.     dirtmp->next = include->next;
  410.     include->next = dirtmp;
  411.     dirtmp->fname = argv[i]+2;
  412.     if (strlen (argv[i]) > max_include_len)
  413.       max_include_len = strlen (argv[i]);
  414.     break;
  415.  
  416.       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
  417.     if (in_fname == NULL) {
  418.       in_fname = STDIN_FILE;
  419.       break;
  420.     } else if (out_fname == NULL) {
  421.       out_fname = "stdout";
  422.       break;
  423.     }    /* else fall through into error */
  424.  
  425.       default:
  426.     fatal ("Illegal option %s\n", argv[i]);
  427.       }
  428.     }
  429.   }
  430.  
  431.   /* JF check for stdin */
  432.   if (in_fname == STDIN_FILE || in_fname == NULL)
  433.     f = 0;
  434.   else if ((f = open (in_fname, O_RDONLY)) < 0)
  435.     goto perror;
  436.  
  437.   if (f) fstat (f, &sbuf);
  438.   fp->fname = in_fname;
  439.   fp->lineno = 1;
  440.   /* JF all this is mine about reading pipes and ttys */
  441.   if (!f || (sbuf.st_mode & S_IFMT) != S_IFREG) {
  442.     int size;
  443.     int bsize;
  444.     int cnt;
  445.     U_CHAR *bufp;
  446.  
  447.     bsize = 2000;
  448.     size = 0;
  449.     fp->buf = (U_CHAR *) xmalloc (bsize + 1);
  450.     bufp = fp->buf;
  451.     for (;;) {
  452.       cnt = read (f, bufp, bsize - size);
  453.       if (cnt < 0) goto perror;    /* error! */
  454.       if (cnt == 0) break;    /* End of file */
  455.       size += cnt;
  456.       bufp += cnt;
  457.       if (bsize-size == 0) {    /* Buffer is full! */
  458.         bsize *= 2;
  459.         fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 1);
  460.     bufp = fp->buf + size;    /* May have moved */
  461.       }
  462.     }
  463.     fp->buf[size] = '\0';
  464.     fp->length = size;
  465.   } else {
  466.     fp->length = sbuf.st_size;
  467.     fp->buf = (U_CHAR *) alloca (sbuf.st_size + 1);
  468.  
  469.     if (read (f, fp->buf, sbuf.st_size) != sbuf.st_size)
  470.       goto perror;
  471.  
  472.     fp->buf[sbuf.st_size] = '\0';
  473.   }
  474.  
  475.   /* initialize output buffer */
  476.   outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
  477.   outbuf.bufp = outbuf.buf;
  478.   outbuf.length = OUTBUF_SIZE;
  479.  
  480.   output_line_command (fp, &outbuf);
  481.   rescan (fp, &outbuf);
  482.  
  483.   /* do something different than this later */
  484.   fflush (stdout);
  485.   write (out_fd, outbuf.buf, outbuf.bufp - outbuf.buf);
  486.   exit (0);
  487.  
  488.  perror:
  489.   pfatal_with_name (argv[1]);
  490. }
  491.  
  492. /*
  493.  * The main loop of the program.  Try to examine and move past most
  494.  * ordinary input chars as fast as possible.  Call appropriate routines
  495.  * when something special (such as a macro expansion) has to happen.
  496.  
  497. IP is the source of input to scan.
  498. OP is the place to put input. */
  499.  
  500. rescan (ip, op)
  501.      FILE_BUF *ip, *op;
  502. {
  503.   register int c;
  504.   register int ident_length = 0, hash = 0;
  505.   register U_CHAR *limit;
  506.   U_CHAR *check_expand ();
  507.   struct keyword_table *handle_directive ();
  508.   int excess_newlines = 0;
  509.   int escaped = 0;
  510.  
  511.   U_CHAR *bp;
  512.  
  513.   check_expand(op, ip->length);
  514.  
  515.   ip->bufp = ip->buf;
  516.   limit = ip->buf + ip->length;
  517.   while (1) {
  518.     if (ip->bufp < limit) {
  519.       c = *ip->bufp++;
  520.       *op->bufp++ = c;
  521.     } else {
  522.       c = -1;
  523.     }
  524.  
  525.     --escaped;
  526.     /* Now ESCAPED is 0 if and only if this character is escaped.  */
  527.  
  528.     switch (c) {
  529.     case '\\':
  530.       if (escaped == 0)
  531.     goto randomchar;
  532.       if (*ip->bufp != '\n')
  533.     {
  534.       escaped = 1;
  535.       goto randomchar;
  536.     }
  537.       /* always merge lines ending with backslash-newline */
  538.       ++ip->bufp;
  539.       ++ip->lineno;
  540.       ++excess_newlines;
  541.       --op->bufp;        /* remove backslash from obuf */
  542.       continue;            /* back to top of while loop */
  543.  
  544.     case '#':
  545.       /* # keyword: a # must be first nonblank char on the line */
  546.       for (bp = ip->bufp - 1; bp >= ip->buf; bp--)
  547.     if (*bp == '\n')
  548.       break;
  549.       bp++;            /* skip nl or move back into buffer */
  550.       SKIP_WHITE_SPACE (bp);
  551.       if (*bp != '#')
  552.     goto randomchar;
  553.       ident_length = hash = 0;
  554.       --op->bufp;        /* don't copy the '#' */
  555.  
  556.       if (handle_directive (ip, op, &excess_newlines) == NULL) {
  557.     ++op->bufp;        /* copy the '#' after all */
  558.     goto randomchar;
  559.       }
  560.       break;
  561.  
  562.     case '\"':            /* skip quoted string */
  563.     case '\'':
  564.       /* a single quoted string is treated like a double -- some
  565.      programs (e.g., troff) are perverse this way */
  566.  
  567.       if (escaped == 0)
  568.     goto randomchar;    /* false alarm-- it's escaped. */
  569.  
  570.       /* skip ahead to a matching quote.  */
  571.  
  572.       bp = ip->bufp;
  573.       while (bp < limit) {
  574.     *op->bufp++ = *bp;
  575.     switch (*bp++) {
  576.     case '\n':
  577.       ++ip->lineno;
  578.       break;
  579.     case '\\':
  580.       if (bp >= limit)
  581.         break;
  582.       if (*bp == '\n')
  583.         {
  584.           /* backslash newline is replaced by nothing at all,
  585.          but remember that the source line count is out of synch.  */
  586.           --op->bufp;
  587.           ++bp;
  588.           ++excess_newlines;
  589.           ++ip->lineno;
  590.         }
  591.       else
  592.         *op->bufp++ = *bp++;
  593.       break;
  594.     case '\"':
  595.     case '\'':
  596.       if (bp[-1] == c)
  597.         goto while2end;
  598.       break;
  599.     }
  600.       }
  601.     while2end:
  602.       ip->bufp = bp;
  603.       break;
  604.  
  605.     case '/':            /* possible comment */
  606.       if (*ip->bufp != '*')
  607.     goto randomchar;
  608.       if (put_out_comments) {
  609.         bp = ip->bufp;
  610.     *op->bufp++ = *bp++;
  611.       } else {
  612.     bp = ip->bufp + 1;
  613.     --op->bufp;        /* don't leave initial slash in buffer */
  614.       }
  615.  
  616.       for (;;) {
  617.     while (bp < limit) {
  618.       if (put_out_comments)
  619.         *op->bufp++ = *bp;
  620.       switch (*bp++) {
  621.       case '*':
  622.         goto whileend;
  623.       case '\n':
  624.         /* copy the newline into the output buffer, in order to
  625.            avoid the pain of a #line every time a multiline comment
  626.            is seen.  This means keywords with embedded comments
  627.            that contain newlines (blucch!) will lose.  By making
  628.            sure that excess_newlines is not just a flag, but really
  629.            an accurate count, it might be possible to get around this. */
  630.         if (!put_out_comments)
  631.           *op->bufp++ = '\n';
  632.         ++ip->lineno;
  633.       }
  634.     }
  635.       whileend:
  636.     if (bp >= limit) {
  637.       error ("unterminated comment");
  638.       break;        /* causes eof condition */
  639.     }
  640.     if (*bp == '/')
  641.       break;
  642.       }
  643.       if (put_out_comments)
  644.         *op->bufp++ = '/';
  645.       ip->bufp = bp + 1;
  646.       break;
  647.  
  648.     case '0': case '1': case '2': case '3': case '4':
  649.     case '5': case '6': case '7': case '8': case '9':
  650.       /* if digit is not part of identifier, it is random */
  651.       if (ident_length == 0)
  652.     goto randomchar;
  653.       /* fall through */
  654.  
  655.     case '_':
  656.     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  657.     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
  658.     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
  659.     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
  660.     case 'y': case 'z':
  661.     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  662.     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
  663.     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
  664.     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
  665.     case 'Y': case 'Z':
  666.       ident_length++;
  667.       /* compute step of hash function, to avoid a proc call on every token */
  668.       hash = HASHSTEP(hash, c);
  669.       break;
  670.  
  671.     default:
  672. randomchar:
  673.       if (ident_length > 0) {
  674.     register HASHNODE *hp;
  675.     for (hp = hashtab[MAKE_POS(hash) % HASHSIZE]; hp != NULL;
  676.          hp = hp->next) {
  677.           U_CHAR *save_ibufp;    /* kludge, see below */
  678.  
  679.           if (hp->length == ident_length) {
  680.         register int i = ident_length;
  681.         register U_CHAR *p = hp->name;
  682.         register U_CHAR *q = op->bufp - i;
  683.  
  684.         if (c != -1)
  685.           q--;
  686.  
  687.         do {        /* all this to avoid a strncmp() */
  688.           if (*p++ != *q++)
  689.         goto hashcollision;
  690.         } while (--i);
  691.  
  692.         save_ibufp = ip->bufp;
  693.         /* back up over identifier, then expand token */
  694.         op->bufp -= ident_length;
  695.         if (c != -1) op->bufp--;
  696.         macroexpand (hp, ip, op, &excess_newlines);
  697.  
  698.         check_expand(op, ip->length - (ip->bufp - ip->buf));
  699.  
  700.         /* If we just processed an identifier at end of input,
  701.            return right away.  */
  702.         if (c == -1)
  703.           return;
  704.  
  705.         /* if the expansion routine has not moved the input
  706.            pointer, put back the char that ended the token.
  707.            This is a kludge because there might be a different
  708.            reason to put it back or not put it back. */
  709.         if (ip->bufp == save_ibufp)
  710.           *op->bufp++ = c;
  711.  
  712.         break;        /* out of for loop */
  713.       }
  714. hashcollision:
  715.            ;
  716.     }            /* end for loop */
  717.     ident_length = hash = 0; /* stop collecting identifier */
  718.       }
  719.  
  720.       /* If we just processed an identifier at end of input,
  721.      return right away.  */
  722.       if (c == -1)
  723.     return;
  724.  
  725.       /* count the newline, if it was one.  The reason this is
  726.      done down here instead of as a case in the switch is
  727.      that some expansions might want to look at the line
  728.      number, and if they happen right before the newline,
  729.      we don't want them to get the wrong one.  So the newline
  730.      must be counted AFTER any expansions happen. */
  731.       if (c == '\n') {
  732.     ++ip->lineno;
  733.     if (excess_newlines > 0) {
  734.       output_line_command (ip, op);
  735.       check_expand(op, ip->length - (ip->bufp - ip->buf));
  736.  
  737.       excess_newlines = 0;
  738.     }
  739.       }
  740.       break;            /* from switch */
  741.     }
  742.   }
  743. }
  744.  
  745. /*
  746.  * Process a # directive.  Expects ip->bufp to point to the '#', as in
  747.  * "#define foo bar".  Bumps *excess_newlines counter as necessary if
  748.  * the command is several lines long (and also updates ip->lineno).
  749.  * The main reason for this is that the comments could contain
  750.  * newlines, which would be confusing.  Passes to the command handler
  751.  * (do_define, do_include, etc.): the addresses of the 1st and
  752.  * last chars of the command (starting immediately after the #
  753.  * keyword), plus op and the keyword table pointer.  If the line
  754.  * contains comments the command is copied into a temporary buffer
  755.  * (sans comments) and the temporary buffer is passed to the command
  756.  * handler instead.
  757.  */
  758.  
  759. struct keyword_table *
  760. handle_directive (ip, op, excess_newlines)
  761.      FILE_BUF *ip, *op;
  762.      int *excess_newlines;
  763. {
  764.   register U_CHAR *bp, *cp;
  765.   register struct keyword_table *kt;
  766.   register int ident_length;
  767.  
  768.   /* Nonzero means we must copy the entire command
  769.      to get rid of comments or backslash-newlines.  */
  770.   int copy_command = 0;
  771.  
  772.   bp = ip->bufp;
  773.   SKIP_WHITE_SPACE(bp);
  774.   cp = bp;
  775.   while (is_idchar[*cp])
  776.     cp++;
  777.   ident_length = cp - bp;
  778.  
  779.   /*
  780.    * Decode the keyword and call the appropriate expansion
  781.    * routine, after moving the input pointer up to the next line.
  782.    * If the keyword is not a legitimate control word, return NULL.
  783.    * Otherwise, return ptr to the keyword structure matched.
  784.    */
  785.   for (kt = keyword_table; kt->length > 0; kt++) {
  786.     if (kt->length == ident_length && !strncmp(kt->name, bp, ident_length)) {
  787.       register U_CHAR *buf;
  788.       register U_CHAR *limit = ip->buf + ip->length;
  789.       U_CHAR *skip_to_end_of_comment();
  790.  
  791.       buf = bp = bp + ident_length;
  792.       while (bp < limit) {
  793.     if (*bp == '\'' || *bp == '\"') {        /* JF handle quotes right  */
  794.       U_CHAR quotec;
  795.  
  796.       for (quotec = *bp++; bp < limit; bp++) {
  797.         if (*bp == quotec)
  798.           {
  799.         bp++;
  800.         break;
  801.           }
  802.         if (*bp == '\\') bp++;
  803.         if (*bp == '\n') {
  804.           if (bp[-1] == '\\')
  805.         copy_command++;
  806.           else {
  807.         /* --bp; */
  808.         break;    /* JF ugly, but might work */
  809.           }
  810.         }
  811.       }
  812.       continue;
  813.     }
  814.     if (*bp == '/' && bp[1] == '*') {
  815.       copy_command++;
  816.       ip->bufp = bp + 2;
  817.       skip_to_end_of_comment (ip, NULL);
  818.       bp = ip->bufp;
  819.       continue;
  820.     }
  821.  
  822.     if (*bp++ == '\n') {
  823.       if (*(bp-2) == '\\')
  824.         copy_command++;
  825.       else {
  826.         --bp;        /* point to the newline */
  827.         break;
  828.       }
  829.     }
  830.       }
  831.       if (copy_command) {
  832.     /* need to copy entire command into temp buffer before dispatching */
  833.  
  834.     cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
  835.                           some slop */
  836.     bp = buf;
  837.     buf = cp;
  838.  
  839.     while (bp < limit) {
  840.       if (*bp == '\'' || *bp == '\"') {    /* JF handle quotes right  */
  841.         U_CHAR quotec;
  842.  
  843.         *cp++ = *bp;
  844.         for (quotec = *bp++; bp < limit; *cp++ = *bp++) {
  845.           if (*bp == quotec)
  846.         {
  847.           *cp++ = *bp++;
  848.           break;
  849.         }
  850.           if (*bp == '\\')
  851.         *cp++ = *bp++;
  852.           if (*bp == '\n') {
  853.         if (bp[-1] == '\\') {
  854.           ++ip->lineno;
  855.           ++*excess_newlines;
  856.         } else break;    /* JF ugly, but might work */
  857.           }
  858.         }
  859.         continue;
  860.       }
  861.       if (*bp == '/' && bp[1] == '*') {
  862.         int newlines_found = 0;
  863.         ip->bufp = bp + 2;
  864.         skip_to_end_of_comment (ip, &newlines_found);
  865.         *excess_newlines += newlines_found;
  866.         ip->lineno += newlines_found;
  867.         bp = ip->bufp;
  868.         continue;
  869.       }
  870.  
  871.       if (*bp == '\n') {
  872.         if (bp[-1] == '\\') {
  873.           ++ip->lineno;
  874.           ++*excess_newlines;
  875.         } else
  876.           break;
  877.       }
  878.       *cp++ = *bp++;
  879.     }
  880.       }
  881.       else
  882.     cp = bp;
  883.  
  884.       ip->bufp = bp;        /* skip to the end of the command */
  885.  
  886.       /* call the appropriate command handler.  Buf now points to
  887.      either the appropriate place in the input buffer, or to
  888.      the temp buffer if it was necessary to make one.  Cp
  889.      points to the first char after the contents of the (possibly
  890.      copied) command, in either case. */
  891.       (*kt->func) (buf, cp, op, kt);
  892.       check_expand (op, ip->length - (ip->bufp - ip->buf));
  893.  
  894.       break;
  895.     }
  896.   }
  897.   if (kt->length <= 0)
  898.     kt = NULL;
  899.  
  900.   return kt;
  901. }
  902.  
  903. static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  904.                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
  905.                 };
  906.  
  907. /*
  908.  * expand things like __FILE__.  Place the expansion into the output
  909.  * buffer *without* rescanning.
  910.  */
  911. expand_special_symbol (hp, ip, op)
  912.      HASHNODE *hp;
  913.      FILE_BUF *ip, *op;
  914. {
  915.   char *buf;
  916.   int i, len;
  917.   FILE_BUF *last_ip = NULL;
  918.   static struct tm *timebuf = NULL;
  919.   struct tm *localtime();
  920.  
  921.   int paren = 0;        /* for special `defined' keyword */
  922.   HASHNODE *lookup();
  923.  
  924.   for (i = indepth - 1; i >= 0; i--)
  925.     if (instack[i].fname != NULL) {
  926.       last_ip = &instack[i];
  927.       break;
  928.     }
  929.   if (last_ip == NULL) {
  930.     error("CCCP error: not in any file?!");
  931.     return;            /* the show must go on */
  932.   }
  933.  
  934.   switch (hp->type) {
  935.   case T_FILE:
  936.     buf = (char *) alloca (3 + strlen(last_ip->fname));
  937.     sprintf (buf, "\"%s\"", last_ip->fname);
  938.     break;
  939.   case T_SPECLINE:
  940.     buf = (char *) alloca (10);
  941.     sprintf (buf, "%d", last_ip->lineno);
  942.     break;
  943.   case T_DATE:
  944.   case T_TIME:
  945.     if (timebuf == NULL) {
  946.       i = time(0);
  947.       timebuf = localtime(&i);
  948.     }
  949.     buf = (char *) alloca (20);
  950.     if (hp->type == T_DATE)
  951.       sprintf(buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon - 1],
  952.           timebuf->tm_mday, timebuf->tm_year + 1900);
  953.     else
  954.       sprintf(buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
  955.           timebuf->tm_sec);
  956.     break;
  957.   case T_SPEC_DEFINED:
  958.     buf = " 0 ";        /* assume symbol is not defined */
  959.     if (is_hor_space[*(ip->bufp-1)]) {
  960.       SKIP_WHITE_SPACE(ip->bufp);
  961.       if (*ip->bufp == '(') {
  962.     paren++;
  963.     ip->bufp++;            /* skip over the paren */
  964.       }
  965.     } else if (*(ip->bufp-1) == '(')
  966.       paren++;
  967.  
  968.     if (!is_idstart[*ip->bufp])
  969.       goto oops;
  970.     if (lookup(ip->bufp))
  971.       buf = " 1 ";
  972.     while (is_idchar[*ip->bufp])
  973.       ++ip->bufp;
  974.     SKIP_WHITE_SPACE (ip->bufp);
  975.     if (paren) {
  976.       if (*ip->bufp != ')')
  977.     goto oops;
  978.       ++ip->bufp;
  979.     }
  980.     break;
  981.  
  982. oops:
  983.  
  984.     error ("`defined' must be followed by IDENT or (IDENT)");
  985.     break;
  986.  
  987.   default:
  988.     error("CCCP error: illegal special hash type"); /* time for gdb */
  989.     abort ();
  990.   }
  991.   len = strlen(buf);
  992.   check_expand(op, len);
  993.   bcopy (buf, op->bufp, len);
  994.   op->bufp += len;
  995.  
  996.   return;
  997. }
  998.  
  999.  
  1000. /* routines to handle #directives */
  1001.  
  1002. /*
  1003.  * process include file by reading it in and calling rescan.
  1004.  * expects to see "fname" or <fname> on the input.
  1005.  * add error checking and -I option later.
  1006.  */
  1007.  
  1008. do_include (buf, limit, op, keyword)
  1009.      U_CHAR *buf, *limit;
  1010.      FILE_BUF *op;
  1011.      struct keyword_table *keyword;
  1012. {
  1013.   char *fname;        /* dynamically allocated fname buffer */
  1014.   U_CHAR *fbeg, *fend;        /* beginning and end of fname */
  1015.   U_CHAR term;            /* terminator for fname */
  1016.   int err = 0;            /* some error has happened */
  1017.   struct stat sbuf;        /* to stat the include file */
  1018.   FILE_BUF *fp;    /* for input stack frame */
  1019.   struct directory_stack *stackp;
  1020.   int flen, maxlen;
  1021.  
  1022.   int save_indepth = indepth;
  1023.                 /* in case of errors */
  1024.  
  1025.   int f;            /* file number */
  1026.   char *other_dir;        /* JF */
  1027.  
  1028.   f= -1;    /* JF we iz PARANOID! */
  1029.   fbeg = buf;
  1030.   SKIP_WHITE_SPACE(fbeg);
  1031.  
  1032.   switch (*fbeg++) {
  1033.   case '\"':
  1034.     term = '\"';
  1035.     stackp = include;
  1036.     break;
  1037.   case '<':
  1038.     term = '>';
  1039.     stackp = include->next;
  1040.     break;
  1041.   default:
  1042.     error ("#include expects \"fname\" or <fname>");
  1043.     fbeg--;            /* so person can see whole fname */
  1044.     err++;
  1045.     term = '\n';
  1046.     break;
  1047.   }
  1048.   for (fend = fbeg; *fend != term; fend++)
  1049.     {
  1050.       if (fend >= limit)
  1051.     {
  1052.       error ("illegal or unterminated include file name");
  1053.       goto nope;
  1054.     }
  1055.     }
  1056.  
  1057.   flen = fend - fbeg;
  1058.   if (err)
  1059.     goto nope;
  1060.  
  1061.   /* DG: This doesn't handle includes of aa:... on the Amiga */
  1062.   /* It doesn't seem worth it. */
  1063.   other_dir = NULL;
  1064.   maxlen = max_include_len;
  1065. #if 0
  1066.   if (stackp == include)
  1067.     {
  1068.       fp = &instack[indepth];
  1069.       while(--fp >= &instack[0])
  1070.     {
  1071.       int n;
  1072.       char *ep,*nam;
  1073.       extern char *rindex ();
  1074.  
  1075.       if ((nam = fp->fname) != NULL)
  1076.         {
  1077.           if ((ep = rindex (nam, '/')) != NULL)
  1078.         {
  1079.           n = ep - nam;
  1080.           other_dir = (char *) alloca (n + 1);
  1081.           strncpy (other_dir, nam, n);
  1082.           other_dir[n] = '\0';
  1083.                   if (n + 4 > maxlen) maxlen = n + 4;
  1084.         }
  1085.           break;
  1086.         }
  1087.     }
  1088.     }
  1089. #endif
  1090.               /* JF search directory path */
  1091.   fname = (char *) alloca (maxlen + flen);
  1092.   for (; stackp; stackp = stackp->next)
  1093.     {
  1094.       if (other_dir)
  1095.     {
  1096.       strcpy (fname, other_dir);
  1097.       other_dir = 0;
  1098.     }
  1099.       else
  1100.     strcpy (fname, stackp->fname);
  1101. #ifdef AMIGA
  1102.       if (fname[0] != 0 && fname[strlen(fname) - 1] != ':')
  1103.       /* Don't add / after : or empty strings */
  1104. #endif
  1105.       strcat (fname, "/");
  1106.       strncat (fname, fbeg, flen);
  1107.       if ((f = open (fname, O_RDONLY)) >= 0)
  1108.     break;
  1109.     }
  1110.   if (f < 0)
  1111.     {
  1112.       err++;
  1113.       goto nope;
  1114.     }
  1115.  
  1116. #ifdef AMIGA
  1117.   if (stat(fname, &sbuf) < 0)
  1118. #else
  1119.   if (fstat(f, &sbuf) < 0)
  1120. #endif
  1121.     {
  1122.       perror_with_name (fname);
  1123.       goto nope;        /* impossible? */
  1124.     }
  1125.  
  1126.   fp = &instack[indepth++];
  1127.   fp->buf = (U_CHAR *) alloca (sbuf.st_size + 1);
  1128.   fp->fname = fname;
  1129.   fp->length = sbuf.st_size;
  1130.   fp->lineno = 1;
  1131.  
  1132.   if (read(f, fp->buf, sbuf.st_size) != sbuf.st_size)
  1133.     goto nope;
  1134.  
  1135.   fp->buf[sbuf.st_size] = '\0';
  1136.  
  1137.   output_line_command (fp, op);
  1138.   rescan(fp, op);
  1139.  
  1140. nope:
  1141.  
  1142.   if (f > 0)
  1143.     close (f);
  1144.   indepth = save_indepth;
  1145.   output_line_command (&instack[indepth-1], op);
  1146.   if (err) {
  1147.     strncpy (fname, fbeg, flen);
  1148.     fname[flen] = '\0';
  1149.     perror_with_name (fname);
  1150.   }
  1151.   return err;
  1152. }
  1153.  
  1154. /* the arglist structure is built by do_define to tell
  1155.    collect_definition where the argument names begin.  That
  1156.    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
  1157.    would contain pointers to the strings x, y, and z.
  1158.    Collect_definition would then build a DEFINITION node,
  1159.    with reflist nodes pointing to the places x, y, and z had
  1160.    appeared.  So the arglist is just convenience data passed
  1161.    between these two routines.  It is not kept around after
  1162.    the current #define has been processed and entered into the
  1163.    hash table. */
  1164.  
  1165. struct arglist {
  1166.   struct arglist *next;
  1167.   U_CHAR *name;
  1168.   int length;
  1169.   int argno;
  1170. };
  1171.  
  1172. /* Process a #define command.
  1173. BUF points to the contents of the #define command, as a continguous string.
  1174. LIMIT points to the first character past the end of the definition.
  1175. KEYWORD is the keyword-table entry for #define.  */
  1176.  
  1177. do_define (buf, limit, op, keyword)
  1178.      U_CHAR *buf, *limit;
  1179.      FILE_BUF *op;
  1180.      struct keyword_table *keyword;
  1181. {
  1182.   U_CHAR *bp;            /* temp ptr into input buffer */
  1183.   U_CHAR *symname;        /* remember where symbol name starts */
  1184.   int sym_length;        /* and how long it is */
  1185.   U_CHAR *def;            /* beginning of expansion */
  1186.  
  1187.   DEFINITION *defn, *collect_expansion();
  1188.  
  1189.   bp = buf;
  1190.  
  1191.   while (is_hor_space[*bp])
  1192.     bp++;
  1193.   if (!is_idstart[*bp]) {
  1194.     error("illegal macro name: must start with an alphabetic or '_'");
  1195.     goto nope;
  1196.   }
  1197.   symname = bp;            /* remember where it starts */
  1198.   while (is_idchar[*bp] && bp < limit)
  1199.     bp++;
  1200.   sym_length = bp - symname;
  1201.  
  1202.   /* lossage will occur if identifiers or control keywords are broken
  1203.      across lines using backslash.  This is not the right place to take
  1204.      care of that. */
  1205.  
  1206.   if (is_hor_space[*bp] || *bp == '\n' || bp >= limit) {
  1207.     /* simple expansion or empty definition; gobble it */
  1208.     if (is_hor_space[*bp])
  1209.       def = ++bp;        /* skip exactly one blank/tab char */
  1210.     else
  1211.       def = bp;            /* empty definition */
  1212.  
  1213.     defn = (DEFINITION *) xmalloc (sizeof (DEFINITION) + limit - def);
  1214.     defn->nargs = -1;
  1215.     defn->pattern = NULL;
  1216.     defn->expansion = ((U_CHAR *) defn) + sizeof (DEFINITION);
  1217.     defn->length = limit - def;
  1218.     if (defn->length > 0)
  1219.       bcopy (def, defn->expansion, defn->length);
  1220.   }
  1221.   else if (*bp == '(') {
  1222.     struct arglist *arg_ptrs = NULL;
  1223.     int argno = 0;
  1224.  
  1225.     bp++;            /* skip '(' */
  1226.     SKIP_WHITE_SPACE(bp);
  1227.  
  1228.     while (*bp != ')') {
  1229.       struct arglist *temp;
  1230.  
  1231.       temp = (struct arglist *) alloca (sizeof (struct arglist));
  1232.       temp->name = bp;
  1233.       temp->next = arg_ptrs;
  1234.       temp->argno = ++argno;
  1235.       arg_ptrs = temp;
  1236.       while (is_idchar[*bp])
  1237.     bp++;
  1238.       temp->length = bp - temp->name;
  1239.       SKIP_WHITE_SPACE (bp);    /* there should not be spaces here,
  1240.                    but let it slide if there are. */
  1241.       if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
  1242.     error ("illegal parameter to macro");
  1243.     goto nope;
  1244.       }
  1245.       if (*bp == ',') {
  1246.     bp++;
  1247.     SKIP_WHITE_SPACE(bp);
  1248.       }
  1249.       if (bp >= limit) {
  1250.     error ("unterminated format parameter list in #define");
  1251.     goto nope;
  1252.       }
  1253.     }
  1254.  
  1255.     ++bp;            /* skip paren */
  1256.     /* Skip exactly one space or tab if any.  */
  1257.     if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp;
  1258.  
  1259.     /* now everything from bp before limit is the definition. */
  1260.     defn = collect_expansion(bp, limit - bp, arg_ptrs);
  1261.   } else {
  1262.     error("#define symbol name not followed by SPC, TAB, or '('");
  1263.     goto nope;
  1264.   }
  1265.  
  1266.   {
  1267.     HASHNODE *hp, *lookup();
  1268.     DEFINITION *old_def;
  1269.     if ((hp = lookup(symname)) != NULL) {
  1270.       old_def = hp->value.defn;
  1271.       if (compare_defs(defn, old_def)) {
  1272.     U_CHAR *msg;            /* what pain... */
  1273.     msg = (U_CHAR *) alloca (sym_length + 20);
  1274.     bcopy (symname, msg, sym_length);
  1275.     strcpy (msg + sym_length, " redefined");
  1276.     error (msg);
  1277.     /* flush the most recent old definition */
  1278.     delete (hp);
  1279.       }
  1280.     }
  1281.   }
  1282.  
  1283.   install (symname, T_MACRO, defn);
  1284.   return 0;
  1285.  
  1286. nope:
  1287.  
  1288.   return 1;
  1289. }
  1290.  
  1291. /*
  1292.  * return zero if two DEFINITIONs are isomorphic
  1293.  */
  1294. static
  1295. compare_defs(d1, d2)
  1296.      DEFINITION *d1, *d2;
  1297. {
  1298.   struct reflist *a1, *a2;
  1299.  
  1300.   if (d1->nargs != d2->nargs || d1->length != d2->length)
  1301.     return 1;
  1302.   if (strncmp(d1->expansion, d2->expansion, d1->length) != 0)
  1303.     return 1;
  1304.   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
  1305.        a1 = a1->next, a2 = a2->next)
  1306.     if (a1->nchars != a2->nchars || a1->argno != a2->argno)
  1307.       return 1;
  1308.    return 0;
  1309. }
  1310.  
  1311. /* Read a macro definition for a macro with parameters.
  1312.    Build the DEFINITION structure.
  1313.    Reads SIZE characters of text starting at BUF.
  1314.    ARGLIST specifies the formal parameters to look for
  1315.    in the text of the definition.  */
  1316.  
  1317. static DEFINITION *
  1318. collect_expansion(buf, size, arglist)
  1319.      U_CHAR *buf;
  1320.      int size;
  1321.      struct arglist *arglist;
  1322. {
  1323.   DEFINITION *defn;
  1324.   U_CHAR *p, *lastp, *exp_p;
  1325.   int id_len;
  1326.   struct arglist *arg;
  1327.   struct reflist *endpat = NULL;
  1328.  
  1329.   /* scan thru the macro definition, ignoring comments and quoted
  1330.    strings, picking up on the macro calls.  It does a linear search
  1331.    thru the arg list on every potential symbol.  Profiling might say
  1332.    that something smarter should happen. */
  1333.  
  1334.  
  1335.   if (size < 0)
  1336.     abort ();
  1337.  
  1338.   defn = (DEFINITION *) xcalloc (1, sizeof (DEFINITION));
  1339.  
  1340.   /* watch out!  the arg count here depends on the order in which
  1341.      arglist was built.  you might have to count the args if
  1342.      you change something. */
  1343.   if (arglist != NULL)
  1344.     defn->nargs = arglist->argno;
  1345.   else
  1346.     defn->nargs = 0;
  1347.   exp_p = defn->expansion = (U_CHAR *) xmalloc (size + 1);
  1348.  
  1349.   /* write comment and quote handling
  1350.      and speed this loop up later; this is a stripped version */
  1351.  
  1352.   /* On the other hand, is it really worth doing that here?
  1353.      comments will get taken care of on rescan.  The sun /lib/cpp doc
  1354.      says that arg substitution happens even inside quoted strings,
  1355.      which would mean DON'T do anything with them here.  Check the
  1356.      standard on this. */
  1357.  
  1358.   lastp = p = buf;
  1359.   while (p < buf+size) {
  1360.     int skipped_arg = 0;
  1361.  
  1362.     if (is_idstart[*p] && (p==buf || !is_idchar[*(p-1)])) {
  1363.  
  1364.       for (id_len = 0; p+id_len < buf+size && is_idchar[p[id_len]]; id_len++)
  1365.     ;
  1366.       for (arg = arglist; arg != NULL; arg = arg->next) {
  1367.     struct reflist *tpat;
  1368.  
  1369.     if (arg->length == id_len && strncmp(arg->name, p, id_len) == 0) {
  1370.       /* make a pat node for this arg and append it to the end of
  1371.          the pat list */
  1372.       tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
  1373.       tpat->next = NULL;
  1374.       if (endpat == NULL)
  1375.         defn->pattern = tpat;
  1376.       else
  1377.         endpat->next = tpat;
  1378.       endpat = tpat;
  1379.  
  1380.       tpat->argno = arg->argno;
  1381.       tpat->nchars = p - lastp;
  1382.       p += id_len;
  1383.       lastp = p;        /* place to start copying from next time */
  1384.       skipped_arg++;
  1385.       break;
  1386.     }
  1387.       }
  1388.     }
  1389.  
  1390.     if (skipped_arg == 0)
  1391.       *exp_p++ = *p++;
  1392.   }
  1393.  
  1394.   *exp_p++ = '\0';
  1395.  
  1396.   defn->length = exp_p - defn->expansion - 1;
  1397.  
  1398.   /* give back excess storage */
  1399.   defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
  1400.  
  1401.   return defn;
  1402. }
  1403.  
  1404. #ifdef DEBUG
  1405. /*
  1406.  * debugging routine ---- return a ptr to a string containing
  1407.  *   first n chars of s.  Returns a ptr to a static object
  1408.  *   since I happen to know it will fit.
  1409.  */
  1410. static U_CHAR *
  1411. prefix (s, n)
  1412.      U_CHAR *s;
  1413.      int n;
  1414. {
  1415.   static U_CHAR buf[1000];
  1416.   bcopy (s, buf, n);
  1417.   buf[n] = '\0';        /* this should not be necessary! */
  1418.   return buf;
  1419. }
  1420. #endif
  1421.  
  1422. /*
  1423.  * interpret #line command.  Remembers previously seen fnames
  1424.  * in its very own hash table.
  1425.  */
  1426. #define FNAME_HASHSIZE 37
  1427.  
  1428. do_line(buf, limit, op, keyword)
  1429.      U_CHAR *buf, *limit;
  1430.      FILE_BUF *op;
  1431.      struct keyword_table *keyword;
  1432. {
  1433.   register U_CHAR *bp;
  1434.   FILE_BUF *ip = &instack[indepth - 1];
  1435.  
  1436.   bp = buf;
  1437.   ip->lineno = atoi(bp);
  1438.   /* this time, skip to the end of the line WITHOUT
  1439.      bumping lineno.  If line counting is consolidated,
  1440.      this will have to be hacked, perhaps horribly. */
  1441.  
  1442.   /* skip over blanks, optional sign, digits, blanks. */
  1443.   SKIP_WHITE_SPACE (bp);
  1444.   if (*bp == '-' || *bp == '+')
  1445.     bp++;
  1446.   while (isdigit(*bp))
  1447.     bp++;
  1448.   SKIP_WHITE_SPACE (bp);
  1449.  
  1450.   if (*bp != '\n') {        /* if eol, then don't hack fname */
  1451.     static HASHNODE *fname_table[FNAME_HASHSIZE];
  1452.     HASHNODE *hp, **hash_bucket;
  1453.     U_CHAR *fname;
  1454.     int fname_length;
  1455.  
  1456.     if (*bp != '"') {
  1457.       error ("#line directive must be #line NNN [\"fname\"]");
  1458.       goto done;
  1459.     }
  1460.     fname = ++bp;
  1461.  
  1462.     while (*bp != '"' && bp < limit)
  1463.       bp++;
  1464.     if (*bp != '"') {
  1465.       error ("Unterminated fname in #line command");
  1466.       goto done;
  1467.     }
  1468.     fname_length = bp - fname;
  1469.     hash_bucket =
  1470.       &fname_table[hashf(fname, fname_length, FNAME_HASHSIZE)];
  1471.     for (hp = *hash_bucket; hp != NULL; hp = hp->next)
  1472.       if (hp->length == fname_length &&
  1473.       strncmp(hp->value.cpval, fname, fname_length) == 0) {
  1474.     ip->fname = hp->value.cpval;
  1475.     goto done;
  1476.       }
  1477.     /* didn't find it, cons up a new one */
  1478.     hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
  1479.     hp->next = *hash_bucket;
  1480.     *hash_bucket = hp;
  1481.  
  1482.     hp->length = fname_length;
  1483.     ip->fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
  1484.     bcopy (fname, hp->value.cpval, fname_length);
  1485.   }
  1486.  
  1487. done:
  1488.  
  1489.   output_line_command (ip, op);
  1490.   check_expand (op, ip->length - (ip->bufp - ip->buf));
  1491. }
  1492.  
  1493. /*
  1494.  * remove all definitions of symbol from symbol table.
  1495.  * according to un*x /lib/cpp, it is not an error to undef
  1496.  * something that has no definitions, so it isn't one here either.
  1497.  */
  1498. do_undef(buf, limit, op, keyword)
  1499.      U_CHAR *buf, *limit;
  1500.      FILE_BUF *op;
  1501.      struct keyword_table *keyword;
  1502. {
  1503.   register U_CHAR *bp;
  1504.   HASHNODE *hp, *lookup();
  1505.  
  1506.   SKIP_WHITE_SPACE (buf);
  1507.  
  1508.   while ((hp = lookup(buf)) != NULL)
  1509.     delete (hp);
  1510. }
  1511.  
  1512. /* handle #error command later */
  1513. do_error()
  1514. {
  1515. }
  1516.  
  1517. /*
  1518.  * the behavior of the #pragma directive is implementation defined.
  1519.  * this implementation defines it as follows.
  1520.  */
  1521. #ifdef AMIGA
  1522. do_pragma(buf, limit, op, keyword)
  1523.      U_CHAR *buf, *limit;
  1524.      FILE_BUF *op;
  1525.      struct keyword_table *keyword;
  1526. {
  1527.     /* Just copy the pragma directibe back out */
  1528.     int len2 = limit - buf, len1 = sizeof("#pragma") - 1;
  1529.  
  1530.     check_expand(op, len1 + len2);
  1531.     bcopy("#pragma", op->bufp, len1);
  1532.     bcopy(buf, op->bufp + len1, len2);
  1533.     op->bufp += len1 + len2;
  1534. }
  1535. #else
  1536. do_pragma()
  1537. {
  1538.   close (0);
  1539.   if (open ("/dev/tty", O_RDONLY) != 0)
  1540.     goto nope;
  1541.   close (1);
  1542.   if (open("/dev/tty", O_WRONLY) != 1)
  1543.     goto nope;
  1544.   execl("/usr/games/rogue", "#pragma", 0);
  1545.   execl("/usr/games/hack", "#pragma", 0);
  1546.   execl("/usr/new/emacs -f hanoi 9 -kill", "#pragma", 0);
  1547. nope:
  1548.   fatal ("You are in a maze of twisty compiler features, all different");
  1549. }
  1550. #endif
  1551.  
  1552. typedef struct if_stack {
  1553.   struct if_stack *next;    /* for chaining to the next stack frame */
  1554.   char *fname;        /* copied from input when frame is made */
  1555.   int lineno;            /* similarly */
  1556.   int if_succeeded;        /* true if a leg of this if-group
  1557.                     has been passed through rescan */
  1558.   int type;            /* type of last directive seen in this group */
  1559. };
  1560. typedef struct if_stack IF_STACK_FRAME ;
  1561. IF_STACK_FRAME *if_stack = NULL;
  1562.  
  1563. /*
  1564.  * handle #if command by
  1565.  *   1) inserting special `defined' keyword into the hash table
  1566.  *    that gets turned into 0 or 1 by expand_special_symbol (thus,
  1567.  *    if the luser has a symbol called `defined' already, it won't
  1568.  *      work inside the #if command)
  1569.  *   2) rescan the input into a temporary output buffer
  1570.  *   3) pass the output buffer to the yacc parser and collect a value
  1571.  *   4) clean up the mess left from steps 1 and 2.
  1572.  *   5) call conditional_skip to skip til the next #endif (etc.),
  1573.  *      or not, depending on the value from step 3.
  1574.  */
  1575. do_if (buf, limit, op, keyword)
  1576.      U_CHAR *buf, *limit;
  1577.      FILE_BUF *op;
  1578.      struct keyword_table *keyword;
  1579. {
  1580.   int value;
  1581.   FILE_BUF *ip = &instack[indepth - 1];
  1582.  
  1583.   value = eval_if_expression (buf, limit - buf);
  1584.   conditional_skip (ip, value == 0, T_IF);
  1585. }
  1586.  
  1587. /*
  1588.  * handle a #elif directive by not changing  if_stack  either.
  1589.  * see the comment above do_else.
  1590.  */
  1591.  
  1592. do_elif (buf, limit, op, keyword)
  1593.      U_CHAR *buf, *limit;
  1594.      FILE_BUF *op;
  1595.      struct keyword_table *keyword;
  1596. {
  1597.   int value;
  1598.   FILE_BUF *ip = &instack[indepth - 1];
  1599.  
  1600.   if (if_stack == NULL)
  1601.     error ("if-less #elif");
  1602.   else {
  1603.     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
  1604.       error ("#elif after #else");
  1605.       fprintf (stderr, " (matches line %d", if_stack->lineno);
  1606.       if (if_stack->fname != NULL && ip->fname != NULL &&
  1607.       strcmp(if_stack->fname, ip->fname) != 0)
  1608.     fprintf (stderr, ", file %s", if_stack->fname);
  1609.       fprintf(stderr, ")\n");
  1610.     }
  1611.     if_stack->type = T_ELIF;
  1612.   }
  1613.  
  1614.   value = eval_if_expression (buf, limit - buf);
  1615.   conditional_skip (ip, value == 0, T_ELIF);
  1616. }
  1617.  
  1618. /*
  1619.  * evaluate a #if expression in BUF, of length LENGTH,
  1620.  * making careful arrangements to handle `defined' and
  1621.  * prepare for calling the yacc parser.
  1622.  */
  1623. static int
  1624. eval_if_expression (buf, length)
  1625.      U_CHAR *buf;
  1626.      int length;
  1627. {
  1628.   FILE_BUF temp_ibuf, temp_obuf;
  1629.   HASHNODE *save_defined;
  1630.   int value;
  1631.  
  1632.   bzero (&temp_ibuf, sizeof temp_ibuf);    /* paranoia */
  1633.   temp_ibuf.length = length;
  1634.   temp_ibuf.buf = temp_ibuf.bufp = buf;
  1635.  
  1636.   temp_obuf.length = length;
  1637.   temp_obuf.bufp = temp_obuf.buf = (U_CHAR *) xmalloc (length);
  1638.  
  1639.   save_defined = install("defined", T_SPEC_DEFINED, 0);
  1640.   rescan (&temp_ibuf, &temp_obuf);
  1641.   *temp_obuf.bufp = '\0';
  1642.   value = parse_c_expression(temp_obuf.buf);
  1643.  
  1644.   delete (save_defined);    /* clean up special symbol */
  1645.   free (temp_obuf.buf);
  1646.  
  1647.   return value;
  1648. }
  1649.  
  1650. /*
  1651.  * routine to handle ifdef/ifndef.  Try to look up the symbol,
  1652.  * then do or don't skip to the #endif/#else/#elif depending
  1653.  * on what directive is actually being processed.
  1654.  */
  1655. do_xifdef (buf, limit, op, keyword)
  1656.      U_CHAR *buf, *limit;
  1657.      FILE_BUF *op;
  1658.      struct keyword_table *keyword;
  1659. {
  1660.   HASHNODE *lookup();
  1661.   int skip;
  1662.   FILE_BUF *ip = &instack[indepth - 1];
  1663.  
  1664.   SKIP_WHITE_SPACE (buf);
  1665.   skip = (lookup(buf) == NULL) ^ (keyword->type == T_IFNDEF);
  1666.   conditional_skip (ip, skip, T_IF);
  1667. }
  1668.  
  1669. /*
  1670.  * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
  1671.  */
  1672. static
  1673. conditional_skip (ip, skip, type)
  1674.      FILE_BUF *ip;
  1675.      int skip, type;
  1676. {
  1677.   IF_STACK_FRAME *temp;
  1678.  
  1679.   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
  1680.   temp->fname = ip->fname;
  1681.   temp->lineno = ip->lineno;
  1682.   temp->next = if_stack;
  1683.   if_stack = temp;
  1684.  
  1685.   if_stack->type = type;
  1686.  
  1687.   if (skip != 0) {
  1688.     skip_if_group(ip);
  1689.     return;
  1690.   } else {
  1691.     ++if_stack->if_succeeded;
  1692.     output_line_command(ip, &outbuf);    /* JF */
  1693.   }
  1694. }
  1695.  
  1696. /*
  1697.  * skip to #endif, #else, or #elif.  adjust line numbers, etc.
  1698.  * leaves input ptr at the sharp sign found.
  1699.  */
  1700. static
  1701. skip_if_group(ip)
  1702.      FILE_BUF *ip;
  1703. {
  1704.   register U_CHAR *bp = ip->bufp, *cp;
  1705.   register U_CHAR *endb = ip->buf + ip->length;
  1706.   struct keyword_table *kt;
  1707.   U_CHAR *save_sharp, *skip_to_end_of_comment (), *skip_quoted_string ();
  1708.   IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
  1709.  
  1710.   while (bp <= endb) {
  1711.     switch (*bp++) {
  1712.     case '/':            /* possible comment */
  1713.       if (*bp == '*') {
  1714.     ip->bufp = ++bp;
  1715.     bp = skip_to_end_of_comment (ip, &ip->lineno);
  1716.       }
  1717.       break;
  1718.     case '\"':
  1719.     case '\'':
  1720.       ip->bufp = bp - 1;
  1721.       bp = skip_quoted_string (ip, NULL);    /* JF was (ip) */
  1722.       break;
  1723.     case '\n':
  1724.       ++ip->lineno;
  1725.       break;
  1726.     case '#':
  1727.       /* # keyword: the # must be first nonblank char on the line */
  1728.       for (cp = bp - 1; cp >= ip->buf; cp--)
  1729.     if (*cp == '\n')
  1730.       break;
  1731.       cp++;            /* skip nl or move back into buffer */
  1732.       SKIP_WHITE_SPACE (cp);
  1733.       if (cp != bp - 1)    /* ????? */
  1734.     break;
  1735.  
  1736.       save_sharp = cp;        /* point at '#' */
  1737.       SKIP_WHITE_SPACE (bp);
  1738.       for (kt = keyword_table; kt->length >= 0; kt++) {
  1739.     IF_STACK_FRAME *temp;
  1740.     if (strncmp(bp, kt->name, kt->length) == 0
  1741.         && !is_idchar[bp[kt->length]]) {
  1742.       switch (kt->type) {
  1743.       case T_IF:
  1744.       case T_IFDEF:
  1745.       case T_IFNDEF:
  1746.         temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
  1747.         temp->next = if_stack;
  1748.         if_stack = temp;
  1749.         temp->lineno = ip->lineno;
  1750.         temp->fname = ip->fname;
  1751.         temp->type = kt->type;
  1752.         break;
  1753.       case T_ELSE:
  1754.       case T_ELIF:
  1755.       case T_ENDIF:
  1756.         ip->bufp = save_sharp;
  1757.         if (if_stack == NULL) {
  1758.           U_CHAR msg[50];
  1759.           sprintf (msg, "if-less #%s", kt->name);
  1760.           error (msg);
  1761.           break;
  1762.         }
  1763.         else if (if_stack == save_if_stack)
  1764.           return;        /* found what we came for */
  1765.  
  1766.         if (kt->type != T_ENDIF) {
  1767.           if (if_stack->type == T_ELSE)
  1768.         error ("#else or #elif after #else");
  1769.           if_stack->type = kt->type;
  1770.           break;
  1771.         }
  1772.  
  1773.         temp = if_stack;
  1774.         if_stack = if_stack->next;
  1775.         free (temp);
  1776.         break;
  1777.       }
  1778.     }
  1779.       }
  1780.     }
  1781.   }
  1782.   ip->bufp = bp;
  1783.   ip->lineno = instack->lineno; /* bufp won't be right, though */
  1784.   error ("unterminated #if/#ifdef/#ifndef conditional");
  1785.   /* after this returns, the main loop will exit because ip->bufp
  1786.      now points to the end of the buffer.  I am not sure whether
  1787.      this is dirty or not. */
  1788.   return;
  1789. }
  1790.  
  1791. /*
  1792.  * handle a #else directive.  Do this by just continuing processing
  1793.  * without changing  if_stack ;  this is so that the error message
  1794.  * for missing #endif's etc. will point to the original #if.  It
  1795.  * is possible that something different would be better.
  1796.  */
  1797. do_else(buf, limit, op, keyword)
  1798.      U_CHAR *buf, *limit;
  1799.      FILE_BUF *op;
  1800.      struct keyword_table *keyword;
  1801. {
  1802.   register U_CHAR *bp;
  1803.   FILE_BUF *ip = &instack[indepth - 1];
  1804.  
  1805.   if (if_stack == NULL) {
  1806.     error ("if-less #else");
  1807.     return;
  1808.   } else {
  1809.     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
  1810.       error ("#else after #else");
  1811.       fprintf (stderr, " (matches line %d", if_stack->lineno);
  1812.       if (strcmp(if_stack->fname, ip->fname) != 0)
  1813.     fprintf (stderr, ", file %s", if_stack->fname);
  1814.       fprintf(stderr, ")\n");
  1815.     }
  1816.     if_stack->type = T_ELSE;
  1817.   }
  1818.  
  1819.   if (if_stack->if_succeeded)
  1820.     skip_if_group (ip);
  1821.   else {
  1822.     ++if_stack->if_succeeded;    /* continue processing input */
  1823.     output_line_command(ip, op);    /* JF try to keep line #s right? */
  1824.   }
  1825. }
  1826.  
  1827. /*
  1828.  * unstack after #endif command
  1829.  */
  1830. do_endif(buf, limit, op, keyword)
  1831.      U_CHAR *buf, *limit;
  1832.      FILE_BUF *op;
  1833.      struct keyword_table *keyword;
  1834. {
  1835.   register U_CHAR *bp;
  1836.  
  1837.   if (if_stack == NULL)
  1838.     error ("if-less #endif");
  1839.   else {
  1840.     IF_STACK_FRAME *temp = if_stack;
  1841.     if_stack = if_stack->next;
  1842.     free (temp);
  1843.     /* JF try to keep line #s right? */
  1844.     output_line_command (&instack[indepth - 1], op);
  1845.   }
  1846. }
  1847.  
  1848. /*
  1849.  * Skip a comment, assuming the input ptr immediately follows the
  1850.  * initial slash-star.  Bump line counter as necessary.
  1851.  * (The canonical line counter is &ip->lineno).
  1852.  * Don't use this routine (or the next one) if bumping the line
  1853.  * counter is not sufficient to deal with newlines in the string.
  1854.  */
  1855. U_CHAR *
  1856. skip_to_end_of_comment (ip, line_counter)
  1857.      register FILE_BUF *ip;
  1858.      int *line_counter;        /* place to remember newlines, or NULL */
  1859. {
  1860.   register U_CHAR *limit = ip->buf + ip->length;
  1861.   register U_CHAR *bp = ip->bufp;
  1862.   FILE_BUF *op = &outbuf;    /* JF */
  1863.  
  1864.     /* JF this line_counter stuff is a crock to make sure the
  1865.        comment is only put out once, no matter how many times
  1866.        the comment is skipped.  It almost works */
  1867.   if (put_out_comments && !line_counter) {
  1868.     *op->bufp++ = '/';
  1869.     *op->bufp++ = '*';
  1870.   }
  1871.   while (bp < limit) {
  1872.     if (put_out_comments && !line_counter)
  1873.       *op->bufp++ = *bp;
  1874.     switch (*bp++) {
  1875.     case '\n':
  1876.       if (line_counter != NULL)
  1877.     ++*line_counter;
  1878.       break;
  1879.     case '*':
  1880.       if (*bp == '/') {
  1881.         if (put_out_comments && !line_counter)
  1882.       *op->bufp++ = '/';
  1883.     ip->bufp = ++bp;
  1884.     return bp;
  1885.       }
  1886.       break;
  1887.     }
  1888.   }
  1889.   ip->bufp = bp;
  1890.   return bp;
  1891. }
  1892. /*
  1893.  * skip over a quoted string.  Unlike skip_to_end_of_comment, this
  1894.  * wants ip->bufp at the beginning quote, not after it.  this is so we
  1895.  * can tell what kind of quote to match.  return if unescaped eol is
  1896.  * encountered --- it is probably some sort of error in the input.
  1897.  */
  1898. U_CHAR *
  1899. skip_quoted_string (ip, count_newlines)
  1900.      register FILE_BUF *ip;
  1901.      int count_newlines;
  1902. {
  1903.   register U_CHAR *limit = ip->buf + ip->length;
  1904.   register U_CHAR *bp = ip->bufp;
  1905.   register U_CHAR c, match;
  1906.  
  1907.   match = *bp++;
  1908.   while (bp < limit) {
  1909.     c = *bp++;
  1910.     if (c == '\\') {
  1911.       if (*bp++ == '\n' && count_newlines)
  1912.     ++ip->lineno;
  1913.     } else if (c == '\n') {
  1914.       bp -= 2;            /* whoa!  back up to eol and punt. */
  1915.       break;
  1916.     } else if (c == match)
  1917.       break;
  1918.   }
  1919.   ip->bufp = bp;
  1920.   return bp;
  1921. }
  1922.  
  1923. /*
  1924.  * write out a #line command, for instance, after an #include file.
  1925.  */
  1926. static
  1927. output_line_command (ip, op)
  1928.      FILE_BUF *ip, *op;
  1929. {
  1930.   int len, line_cmd_buf[500];
  1931.  
  1932.   if (ip->fname == NULL)
  1933.     return;
  1934.  
  1935. #ifdef OUTPUT_LINE_COMMANDS
  1936.   sprintf(line_cmd_buf, "#line %d \"%s\"\n", ip->lineno, ip->fname);
  1937. #else
  1938.   sprintf(line_cmd_buf, "# %d \"%s\"\n", ip->lineno, ip->fname);
  1939. #endif
  1940.   len = strlen(line_cmd_buf);
  1941.   check_expand (op, len);
  1942.   if (op->bufp > op->buf && op->bufp[-1] != '\n')    /* JF make sure */
  1943.       *op->bufp++ = '\n';
  1944.   bcopy (line_cmd_buf, op->bufp, len);
  1945.   op->bufp += len;
  1946. }
  1947.  
  1948.  
  1949. /* Expand a macro call.
  1950.    HP points to the symbol that is the macro being called.
  1951.    IP is the input source for reading the arguments of the macro.
  1952.    Send the result of the expansion to OP.
  1953.    EXCESS_NEWLINES_PTR points to an integer;
  1954.    we increment that integer once for each newline swallowed
  1955.    in the process of reading this macro call.  */
  1956.  
  1957. macroexpand (hp, ip, op, excess_newlines_ptr)
  1958.      HASHNODE *hp;
  1959.      FILE_BUF *ip, *op;
  1960.      int *excess_newlines_ptr;
  1961. {
  1962.   FILE_BUF *ip2;
  1963.   int nargs;
  1964.   DEFINITION *defn = hp->value.defn;
  1965.   int newlines_found = 0;
  1966.  
  1967.   /* it might not actually be a macro.  */
  1968.   if (hp->type != T_MACRO)
  1969.     return expand_special_symbol (hp, ip, op);
  1970.  
  1971.   ip2 = &instack[indepth++];
  1972.   bzero (ip2, sizeof (FILE_BUF)); /* paranoia */
  1973.  
  1974.   nargs = defn->nargs;
  1975.  
  1976.   if (nargs >= 0)
  1977.     {
  1978.       register U_CHAR *bp, *xbuf;
  1979.       U_CHAR *skip_macro_argument ();
  1980.       register int i;
  1981.       int xbuf_len;
  1982.       int offset;        /* offset in expansion,
  1983.                    copied a piece at a time */
  1984.       int totlen;        /* total amount of exp buffer filled so far */
  1985.  
  1986.       register struct reflist *ap;
  1987.       struct argptrs {
  1988.                U_CHAR *argstart;
  1989.                int length;
  1990.              } *args;
  1991.  
  1992.       args = (struct argptrs *) alloca ((nargs + 1) * sizeof (struct argptrs));
  1993.       if (ip->bufp >= ip->buf+ip->length)
  1994.     {            /* JF evil magic to make things work! */
  1995.       ip = &instack[indepth-3];
  1996.     }
  1997.       bp = ip->bufp;
  1998.  
  1999.       /* make sure it really was a macro call. */
  2000.       if (isspace(bp[-1])) {
  2001.     while (isspace (*bp)) {
  2002.       if (*bp == '\n')
  2003.         ++newlines_found;
  2004.       bp++;
  2005.     }
  2006.     if (*bp != '(')
  2007.       goto nope;
  2008.     bp++;            /* skip over the paren */
  2009.       }
  2010.       else if (*(bp-1) != '(')
  2011.     goto nope;
  2012.  
  2013.       for (i = 0; i < nargs; i++) {
  2014.     args[i].argstart = bp;
  2015.     bp = skip_macro_argument(bp, ip, &newlines_found);
  2016.     args[i].length = bp - args[i].argstart;
  2017.     if (*bp == ',')
  2018.       bp++;
  2019.       }
  2020.       args[nargs].argstart = bp;
  2021.       if (*bp++ != ')')
  2022.     goto nope;
  2023.  
  2024.       /* make a rescan buffer with enough room for the pattern plus
  2025.      all the arg strings. */
  2026.       xbuf_len = defn->length + 1;
  2027.       for (ap = defn->pattern; ap != NULL; ap = ap->next)
  2028.     xbuf_len += args[ap->argno - 1].length;
  2029.       xbuf = (U_CHAR *) alloca (xbuf_len);
  2030.  
  2031.       offset = totlen = 0;
  2032.       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
  2033.     bcopy (defn->expansion + offset, xbuf + totlen, ap->nchars);
  2034.     totlen += ap->nchars;
  2035.     offset += ap->nchars;
  2036.  
  2037.     if (ap->argno > 0) {
  2038.       bcopy (args[ap->argno - 1].argstart, xbuf + totlen,
  2039.          args[ap->argno - 1].length);
  2040.       totlen += args[ap->argno - 1].length;
  2041.     }
  2042.  
  2043.     if (totlen > xbuf_len)
  2044.       {
  2045.         /* impossible */
  2046.         error ("cpp impossible internal error: expansion too large");
  2047.         goto nope;        /* this can't happen??? */
  2048.       }
  2049.       }
  2050.  
  2051.       /* if there is anything left after handling the arg list,
  2052.      copy that in too. */
  2053.       if (offset < defn->length) {
  2054.     bcopy (defn->expansion + offset, xbuf + totlen,
  2055.            defn->length - offset);
  2056.     totlen += defn->length - offset;
  2057.       }
  2058.  
  2059.       ip2->buf = xbuf;
  2060.       ip2->length = totlen;
  2061.  
  2062.       /* skip the input over the whole macro call. */
  2063.       ip->bufp = bp;
  2064.  
  2065.     }
  2066.   else
  2067.     {
  2068.       ip2->buf = ip2->bufp = defn->expansion;
  2069.       ip2->length = defn->length;
  2070.     }
  2071.  
  2072.   rescan (ip2, op);
  2073.   --indepth;
  2074.   *excess_newlines_ptr += newlines_found;
  2075.   ip->lineno += newlines_found;
  2076.  
  2077.   return 0;
  2078.  
  2079.  nope:
  2080.   error ("argument mismatch");
  2081.   --indepth;
  2082.   return 1;
  2083. }
  2084.  
  2085. /*
  2086.  * skip a balanced paren string up to the next comma.
  2087.  */
  2088. U_CHAR *
  2089. skip_macro_argument(bp, ip, newlines)
  2090.      U_CHAR *bp;
  2091.      FILE_BUF *ip;
  2092.      int *newlines;
  2093. {
  2094.   int paren = 0;
  2095.   int quotec = 0;
  2096.  
  2097.   while (bp < ip->buf + ip->length) {
  2098.     switch (*bp) {
  2099.     case '(':
  2100.       paren++;
  2101.       break;
  2102.     case ')':
  2103.       if (--paren < 0)
  2104.     return bp;
  2105.       break;
  2106.     case '\n':
  2107.       ++*newlines;
  2108.       break;
  2109.     case '/':
  2110.       if (bp[1] != '*' || bp + 1 >= ip->buf + ip->length)
  2111.     break;
  2112.       bp += 2;
  2113.       while ((bp[0] != '*' || bp[1] != '/')
  2114.          && bp + 1 < ip->buf + ip->length)
  2115.     {
  2116.       if (*bp == '\n') ++*newlines;
  2117.       bp++;
  2118.     }
  2119.       break;
  2120.     case '\'':        /* JF handle quotes right  */
  2121.     case '\"':
  2122.       for (quotec = *bp++; bp < ip->buf + ip->length && *bp != quotec; bp++)
  2123.     {
  2124.       if (*bp == '\\') bp++;
  2125.       if (*bp == '\n')
  2126.         ++*newlines;
  2127.     }
  2128.       break;
  2129.     case ',':
  2130.       if (paren == 0)
  2131.     return bp;
  2132.       break;
  2133.     }
  2134.     bp++;
  2135.   }
  2136.   return bp;
  2137. }
  2138.  
  2139. /*
  2140.  * error - print out message.  also make print on stderr.  Uses stdout
  2141.  * now for debugging convenience.
  2142.  */
  2143. error (msg)
  2144.      U_CHAR *msg;
  2145. {
  2146.   int i;
  2147.   FILE_BUF *ip = NULL;
  2148.  
  2149.   for (i = indepth - 1; i >= 0; i--)
  2150.     if (instack[i].fname != NULL) {
  2151.       ip = &instack[i];
  2152.       break;
  2153.     }
  2154.  
  2155.   if (ip != NULL)
  2156.     fprintf(stderr, "file %s, offset %d (line %d): ",
  2157.         ip->fname, ip->bufp - ip->buf, ip->lineno);
  2158.   fprintf(stderr, "%s\n", msg);
  2159.   return 0;
  2160. }
  2161.  
  2162. /*
  2163.  * if OBUF doesn't have NEEDED bytes after OPTR, make it bigger
  2164.  *    this should be a macro, for speed.
  2165.  * The "expand" in the name of this routine means buffer expansion,
  2166.  * not macro expansion.  It may become necessary to have some hacky
  2167.  * mechanism for flushing out the output buffer if it gets too big.
  2168.  *
  2169.  * As things stand, nothing is ever placed in the output buffer to be
  2170.  * removed again except when it's KNOWN to be part of an identifier,
  2171.  * so flushing and moving down everything left, instead of expanding,
  2172.  * should work ok.
  2173.  */
  2174. U_CHAR *
  2175. check_expand(obuf, needed)
  2176.      register FILE_BUF *obuf;
  2177.      register int needed;
  2178. {
  2179.   register int i;
  2180.   register U_CHAR *p;
  2181.  
  2182.   if (obuf->length - (obuf->bufp - obuf->buf) > needed)
  2183.     return obuf->buf;
  2184.  
  2185.   i = 2 * obuf->length;
  2186.   if (needed >= i)
  2187.     i += (3 * needed) / 2;
  2188.  
  2189.   if ((p = (U_CHAR *) xrealloc (obuf->buf, i)) == NULL)
  2190.     return NULL;
  2191.   obuf->bufp = p + (obuf->bufp - obuf->buf);
  2192.   obuf->buf = p;
  2193.   obuf->length = i;
  2194.  
  2195.   return p;
  2196. }
  2197.  
  2198. /*
  2199.  * install a name in the main hash table, even if it is already there.
  2200.  *   name stops with first non alphanumeric, except leading '#'.
  2201.  * caller must check against redefinition if that is desired.
  2202.  * delete() removes things installed by install() in fifo order.
  2203.  * this is important because of the `defined' special symbol used
  2204.  * in #if, and also if pushdef/popdef directives are ever implemented.
  2205.  */
  2206. HASHNODE *
  2207. install (name, type, value)
  2208.      U_CHAR *name;
  2209.      int type;
  2210.      int value;
  2211.         /* watch out here if sizeof(U_CHAR *) != sizeof (int) */
  2212. {
  2213.   HASHNODE *hp;
  2214.   int i, len = 0, bucket;
  2215.   register U_CHAR *p;
  2216.  
  2217.   p = name;
  2218.   while (is_idchar[*p])
  2219.     p++;
  2220.   len = p - name;
  2221.  
  2222.   i = sizeof (HASHNODE) + len + 1;
  2223.   hp = (HASHNODE *) xmalloc (i);
  2224.   bucket = hashf(name, len, HASHSIZE);
  2225.   hp->bucket_hdr = &hashtab[bucket];
  2226.   hp->next = hashtab[bucket];
  2227.   hashtab[bucket] = hp;
  2228.   hp->prev = NULL;
  2229.   if (hp->next != NULL)
  2230.     hp->next->prev = hp;
  2231.   hp->type = type;
  2232.   hp->length = len;
  2233.   hp->value.ival = value;
  2234.   hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
  2235.   bcopy (name, hp->name, len);
  2236.   return hp;
  2237. }
  2238. /*
  2239.  * find the most recent hash node for name name (ending with first
  2240.  * non-identifier char) installed by install
  2241.  */
  2242. HASHNODE *
  2243. lookup (name)
  2244.      U_CHAR *name;
  2245. {
  2246.   register U_CHAR *bp;
  2247.   register HASHNODE *bucket;
  2248.   int len;
  2249.  
  2250.   for (bp = name; is_idchar[*bp]; bp++)
  2251.     ;
  2252.   len = bp - name;
  2253.   bucket = hashtab[hashf(name, len, HASHSIZE)];
  2254.   while (bucket) {
  2255.     if (bucket->length == len && strncmp(bucket->name, name, len) == 0)
  2256.       return bucket;
  2257.     bucket = bucket->next;
  2258.   }
  2259.   return NULL;
  2260. }
  2261.  
  2262. /*
  2263.  * Delete a hash node.  Some weirdness to free junk from macros.
  2264.  * More such weirdness will have to be added if you define more hash
  2265.  * types that need it.
  2266.  */
  2267. delete(hp)
  2268.      HASHNODE *hp;
  2269. {
  2270.  
  2271.   if (hp->prev != NULL)
  2272.     hp->prev->next = hp->next;
  2273.   if (hp->next != NULL)
  2274.     hp->next->prev = hp->prev;
  2275.  
  2276.   /* make sure that the bucket chain header that
  2277.      the deleted guy was on points to the right thing afterwards. */
  2278.   if (hp == *hp->bucket_hdr)
  2279.     *hp->bucket_hdr = hp->next;
  2280.  
  2281.   if (hp->type == T_MACRO) {
  2282.     DEFINITION *d = hp->value.defn;
  2283.     struct reflist *ap, *nextap;
  2284.  
  2285.     for (ap = d->pattern; ap != NULL; ap = nextap) {
  2286.       nextap = ap->next;
  2287.       free (ap);
  2288.     }
  2289.     free (d);
  2290.   }
  2291. }
  2292.  
  2293. /*
  2294.  * return hash function on name.  must be compatible with the one
  2295.  * computed a step at a time, elsewhere
  2296.  */
  2297. int
  2298. hashf(name, len, hashsize)
  2299.      register U_CHAR *name;
  2300.      register int len;
  2301.      int hashsize;
  2302. {
  2303.   register int r = 0;
  2304.  
  2305.   while (len--)
  2306.     r = HASHSTEP(r, *name++);
  2307.  
  2308.   return MAKE_POS(r) % hashsize;
  2309. }
  2310.  
  2311.  
  2312. /*
  2313.  * initialize random junk in the hash table and maybe other places
  2314.  */
  2315. initialize_random_junk()
  2316. {
  2317.   register int i;
  2318.  
  2319.   /*
  2320.    * Set up is_idchar and is_idstart tables.  These should be
  2321.    * faster than saying (is_alpha(c) || c == '_'), etc.
  2322.    * Must do set up these things before calling any routines tthat
  2323.    * refer to them.
  2324.    */
  2325.   for (i = 'a'; i <= 'z'; i++) {
  2326.     ++is_idchar[i - 'a' + 'A'];
  2327.     ++is_idchar[i];
  2328.     ++is_idstart[i - 'a' + 'A'];
  2329.     ++is_idstart[i];
  2330.   }
  2331.   for (i = '0'; i <= '9'; i++)
  2332.     ++is_idchar[i];
  2333.   ++is_idchar['_'];
  2334.   ++is_idstart['_'];
  2335.  
  2336.   /* horizontal space table */
  2337.   ++is_hor_space[' '];
  2338.   ++is_hor_space['\t'];
  2339.  
  2340.   install("__LINE__", T_SPECLINE, 0);
  2341.   install("__DATE__", T_DATE, 0);
  2342.   install("__FILE__", T_FILE, 0);
  2343.   install("__TIME__", T_TIME, 0);
  2344.  
  2345. #ifdef vax
  2346.   make_definition("vax 1");
  2347. #endif
  2348.  
  2349. #ifdef unix
  2350.   make_definition("unix 1");
  2351. #endif
  2352.  
  2353.   /* is there more? */
  2354.  
  2355. }
  2356.  
  2357. /*
  2358.  * process a given definition string, for initialization
  2359.  */
  2360. make_definition(str)
  2361.      U_CHAR *str;
  2362. {
  2363.   FILE_BUF *ip;
  2364.   struct keyword_table *kt;
  2365.  
  2366.   ip = &instack[indepth++];
  2367.   ip->fname = "*Initialization*";
  2368.  
  2369.   ip->buf = ip->bufp = str;
  2370.   ip->length = strlen(str);
  2371.   ip->lineno = 1;
  2372.  
  2373.   for (kt = keyword_table; kt->type != T_DEFINE; kt++)
  2374.     ;
  2375.  
  2376.   /* pass NULL as output ptr to do_define since we KNOW it never
  2377.      does any output.... */
  2378.   do_define (str, str + strlen(str) /* - 1 JF */ , NULL, kt);
  2379.   --indepth;
  2380. }
  2381.  
  2382. /* JF, this does the work for the -U option */
  2383. make_undef(str)
  2384.      U_CHAR *str;
  2385. {
  2386.   FILE_BUF *ip;
  2387.   struct keyword_table *kt;
  2388.  
  2389.   ip = &instack[indepth++];
  2390.   ip->fname = "*undef*";
  2391.  
  2392.   ip->buf = ip->bufp = str;
  2393.   ip->length = strlen(str);
  2394.   ip->lineno = 1;
  2395.  
  2396.   for(kt = keyword_table; kt->type != T_UNDEF; kt++)
  2397.     ;
  2398.  
  2399.   do_undef(str,str + strlen(str) - 1, NULL, kt);
  2400.   --indepth;
  2401. }
  2402.  
  2403.  
  2404. #ifndef BSD
  2405. #ifndef BSTRING
  2406.  
  2407. void
  2408. bzero (b, length)
  2409.      register char *b;
  2410.      register int length;
  2411. {
  2412. #ifdef VMS
  2413.   short zero = 0;
  2414.   long max_str = 65535;
  2415.  
  2416.   while (length > max_str)
  2417.     {
  2418.       (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
  2419.       length -= max_str;
  2420.       b += max_str;
  2421.     }
  2422.   (void) LIB$MOVC5 (&zero, &zero, &zero, &length, b);
  2423. #else
  2424.   while (length-- > 0)
  2425.     *b++ = 0;
  2426. #endif /* not VMS */
  2427. }
  2428.  
  2429. void
  2430. bcopy (b1, b2, length)
  2431.      register char *b1;
  2432.      register char *b2;
  2433.      register int length;
  2434. {
  2435. #ifdef VMS
  2436.   long max_str = 65535;
  2437.  
  2438.   while (length > max_str)
  2439.     {
  2440.       (void) LIB$MOVC3 (&max_str, b1, b2);
  2441.       length -= max_str;
  2442.       b1 += max_str;
  2443.       b2 += max_str;
  2444.     }
  2445.   (void) LIB$MOVC3 (&length, b1, b2);
  2446. #else
  2447.   while (length-- > 0)
  2448.     *b2++ = *b1++;
  2449. #endif /* not VMS */
  2450. }
  2451.  
  2452. int
  2453. bcmp (b1, b2, length)    /* This could be a macro! */
  2454.      register char *b1;
  2455.      register char *b2;
  2456.       register int length;
  2457.  {
  2458. #ifdef VMS
  2459.    struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
  2460.    struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
  2461.  
  2462.    return STR$COMPARE (&src1, &src2);
  2463. #else
  2464.    while (length-- > 0)
  2465.      if (*b1++ != *b2++)
  2466.        return 1;
  2467.  
  2468.    return 0;
  2469. #endif /* not VMS */
  2470. }
  2471. #endif /* not BSTRING */
  2472. #endif /* not BSD */
  2473.  
  2474.  
  2475. void
  2476. fatal (str, arg)
  2477.      char *str, *arg;
  2478. {
  2479.   fprintf (stderr, "%s: ", progname);
  2480.   fprintf (stderr, str, arg);
  2481.   fprintf (stderr, "\n");
  2482.   exit (FATAL_EXIT_CODE);
  2483. }
  2484.  
  2485. void
  2486. perror_with_name (name)
  2487.      char *name;
  2488. {
  2489.   extern int errno, sys_nerr;
  2490.   extern char *sys_errlist[];
  2491.  
  2492.   fprintf (stderr, "%s: ", progname);
  2493.   if (errno < sys_nerr)
  2494.     fprintf (stderr, "%s for %s\n", sys_errlist[errno], name);
  2495.   else
  2496.     fprintf (stderr, "cannot open %s\n", sys_errlist[errno], name);
  2497. }
  2498.  
  2499. void
  2500. pfatal_with_name (name)
  2501.      char *name;
  2502. {
  2503.   perror_with_name (name);
  2504.   exit (FATAL_EXIT_CODE);
  2505. }
  2506.  
  2507.  
  2508. static void
  2509. memory_full ()
  2510. {
  2511.   fatal ("Memory exhausted.");
  2512. }
  2513.  
  2514.  
  2515. char *
  2516. xmalloc (size)
  2517.      int size;
  2518. {
  2519.   extern char *malloc ();
  2520.   register char *ptr = malloc (size);
  2521.   if (ptr != 0) return (ptr);
  2522.   memory_full ();
  2523.   /*NOTREACHED*/
  2524. }
  2525.  
  2526. char *
  2527. xrealloc (old, size)
  2528.      char *old;
  2529.      int size;
  2530. {
  2531.   extern char *realloc ();
  2532.   register char *ptr = realloc (old, size);
  2533.   if (ptr != 0) return (ptr);
  2534.   memory_full ();
  2535.   /*NOTREACHED*/
  2536. }
  2537.  
  2538. char *
  2539. xcalloc (number, size)
  2540.      int number, size;
  2541. {
  2542.   extern char *malloc ();
  2543.   register int total = number * size;
  2544.   register char *ptr = malloc (total);
  2545.   if (ptr != 0)
  2546.     {
  2547.       bzero (ptr, total);
  2548.       return (ptr);
  2549.     }
  2550.   memory_full ();
  2551.   /*NOTREACHED*/
  2552. }
  2553.