home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / language / sozobon2 / pre.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  14.9 KB  |  974 lines
  1. /* Copyright (c) 1988 by Sozobon, Limited.  Author: Johann Ruegg
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    pre.c
  12.  *
  13.  *    preprocessor for the compiler
  14.  *
  15.  *    Handles all preprocessor (#) commands and
  16.  *      looks up keywords
  17.  *
  18.  *    Interface:
  19.  *        getnode()    returns next "token node"
  20.  */
  21.  
  22. #include <stdio.h>
  23. #include "param.h"
  24. #include "tok.h"
  25. #include "nodes.h"
  26.  
  27. #if CC68
  28. FILE *fopenb();
  29. #define fopen fopenb
  30. #endif
  31.  
  32. extern struct tok curtok;
  33. extern char curstr[];
  34.  
  35. #define TK_SEENL    1    /* want to see NL token */
  36. #define TK_SEEWS    2    /* want to see WS token */
  37. #define TK_ONLY1    4    /* only want 1st token on line */
  38. #define TK_LTSTR    8    /* '<' starts a string */
  39. #define TK_NOESC    16    /* dont do '\' escapes in string */
  40.  
  41. extern int tk_flags, sawnl;
  42.  
  43. #ifndef ACK_HOST
  44. NODE *deflist[NHASH];
  45. NODE *holdtok;
  46. int iflevel, iftruth, ifnest, in_if_x, skip_id;
  47. #else
  48. #if PART_1
  49. NODE *deflist[NHASH];
  50. NODE *holdtok;
  51. extern int iflevel, iftruth, ifnest, in_if_x, skip_id;
  52. #else
  53. extern NODE *deflist[NHASH];
  54. extern NODE *holdtok;
  55. int iflevel, iftruth, ifnest, in_if_x, skip_id;
  56. #endif
  57. #endif
  58.  
  59. extern lineno;
  60. extern char *inname;
  61. extern FILE *input;
  62.  
  63. NODE *hlook(), *llook();
  64. NODEP tok_to_node();
  65. NODE *copylist();
  66.  
  67. #ifdef DEBUG
  68. extern int oflags[];
  69. #define debugd    oflags['d'-'a']
  70. #define debugt    oflags['t'-'a']
  71. #endif
  72.  
  73. #ifndef ACK_HOST
  74. #define PART_1    1
  75. #define PART_2    1
  76. #endif
  77.  
  78. #if PART_1
  79.  
  80. NODEP
  81. hi_node()
  82. {
  83.     register NODEP rv;
  84.  
  85.     /* node from hold queue ? */
  86.     if (holdtok) {
  87. #ifdef DEBUG
  88.         if (debugd > 2) {
  89.             printf("Holdqueue");
  90.             printnode(holdtok);
  91.         }
  92. #endif
  93.         rv = holdtok;
  94.         holdtok = rv->n_next;
  95.         rv->n_next = NULL;
  96.         return rv;
  97.     }
  98.     /* node from input */
  99. again:
  100.     while (iflevel && !iftruth)
  101.         skiplines();
  102.     if (nxttok()==0)
  103.         return NULL;
  104.     if (curtok.tnum == '#') {
  105.         dopound(0);
  106.         goto again;
  107.     }
  108.     rv = tok_to_node();
  109.     return rv;
  110. }
  111.  
  112. NODEP
  113. getnode()
  114. {
  115.     register NODEP rv;
  116.     NODEP dp;
  117.  
  118. again:
  119.     rv = hi_node();
  120.     if (rv == NULL) {
  121.         rv = allocnode();
  122.         rv->e_token = EOFTOK;
  123.         strcpy(rv->n_name, "*EOF*");
  124.     } else
  125.     if (rv->e_token == ID) {
  126.         if (in_if_x && strcmp(rv->n_name, "defined") == 0) {
  127.             skip_id = 1;
  128.             goto out;
  129.         }
  130.         if (skip_id) {
  131.             skip_id = 0;
  132.             goto out;
  133.         }
  134.         if ((dp = hlook(deflist, rv)) != NULL) {
  135.             expand(dp);
  136.             freenode(rv);
  137.             goto again;
  138.         } else if (rv->n_name[0] == '_' && builtin(rv))
  139.             return rv;
  140.         else
  141.             kw_tok(rv);
  142.     }
  143. out:
  144. #ifdef DEBUG
  145.     if (debugt) {
  146.         putchar('[');
  147.         put_nnm(rv);
  148.         printf("] ");
  149.     }
  150. #endif
  151.     return rv;
  152. }
  153.  
  154. builtin(np)
  155. register NODEP np;
  156. {
  157.     int rv;
  158.  
  159.     if (strcmp(np->n_name, "__LINE__") == 0) {
  160.         np->e_token = ICON;
  161.         np->e_ival = lineno;
  162.         return 1;
  163.     }
  164.     else if (strcmp(np->n_name, "__FILE__") == 0) {
  165.         np->e_token = SCON;
  166.         nscpy(np, inname);
  167.         return 1;
  168.     }
  169.     return 0;
  170. }
  171.  
  172. skiplines()
  173. {
  174.     for (;;) {
  175.         if (nxttok()== 0)
  176.             return;
  177.         if (curtok.tnum == '#') {
  178.             dopound(1);
  179.             return;
  180.         }
  181.         tk_flags |= TK_ONLY1;
  182.     }
  183. }
  184.  
  185. static defnargs;
  186.  
  187. p_def()
  188. {
  189.     NODE *args;
  190.     NODE *val;
  191.     NODE *def;
  192.     NODE *def_rgs(), *def_val();
  193.  
  194.     defnargs = -1;
  195.     args = NULL;
  196.     val = NULL;
  197.     nxttok();
  198.     if (curtok.tnum != ID) {
  199.         error("bad #define");
  200.         goto flush;
  201.     }
  202.     def = tok_to_node();
  203.  
  204.     tk_flags |= TK_SEEWS;
  205.     nxttok();
  206.     switch (curtok.tnum) {
  207.     case '(':
  208.         defnargs = 0;
  209.         args = def_rgs();
  210.     case WS:
  211.         goto getval;
  212.     case NL:
  213.         goto dodef;
  214.     default:
  215.         error("bad #define");
  216.         goto flush;
  217.     }
  218. getval:
  219.     val = def_val();
  220. dodef:
  221.     def->e_ival = defnargs;
  222.     define(def, val, args);
  223. flush:
  224.     ;
  225. }
  226.  
  227. optdef(s,as)
  228. char *s, *as;
  229. {
  230.     NODEP val;
  231.     NODEP def;
  232.     NODEP id_tok(), def_val();
  233.  
  234.     defnargs = -1;
  235.     val = NULL;
  236.  
  237.     def = id_tok(s);
  238.     chr_push(as);
  239.  
  240.     tk_flags |= TK_SEENL;
  241.  
  242.     val = def_val();
  243.  
  244.     tk_flags = 0;
  245.  
  246.     def->e_ival = defnargs;
  247.     define(def, val, NULL);
  248. }
  249.  
  250. /*
  251. optundef(s)
  252. char *s;
  253. {
  254.     NODEP np, tp, id_tok();
  255.  
  256.     np = id_tok(s);
  257.     tp = hlook(deflist, np);
  258.     if (tp != NULL)
  259.         tp->n_name[0] = '#';
  260.     freenode(np);
  261. }
  262. */
  263.  
  264. samedef(p1, p2)
  265. NODEP p1, p2;
  266. {
  267.     if (p1->e_ival != p2->e_ival)
  268.         return 0;
  269.     return same_list(p1->n_right, p2->n_right);
  270. }
  271.  
  272. same_list(p1, p2)
  273. NODEP p1, p2;
  274. {
  275.     if (p1 == NULL)
  276.         return p2 == NULL;
  277.     if (p2 == NULL)
  278.         return 0;
  279.     if (l_cmp(p1, p2, sizeof(*p1)/sizeof(long)) != 0)
  280.         return 0;
  281.     return same_list(p1->n_left, p2->n_left);
  282. }
  283.  
  284. l_cmp(p1, p2, n)
  285. NODE *p1, *p2;
  286. {
  287.     if (xstrcmp(p1,p2) != 0)
  288.         return 1;
  289.     if (p1->e_token != p2->e_token ||
  290.         p1->e_ival != p2->e_ival)
  291.         return 1;
  292.     return 0;
  293. }
  294.  
  295. define(def, val, args)
  296. NODEP def, val, args;
  297. {
  298.     NODEP oldp;
  299.  
  300.     if (args != NULL) {
  301.         argsmod(val, args);
  302.         freenode(args);
  303.     }
  304.     def->n_right = val;
  305.     if ((oldp = hlook(deflist, def)) != NULL) {
  306.         if (!samedef(oldp, def))
  307.             warnn("redefined", def);
  308.     }
  309. #ifdef DEBUG
  310.     if (debugd) {
  311.         printf("define (%d args)", (int)def->e_ival);
  312.         printnode(def);
  313.     }
  314. #endif
  315.     puthlist(deflist, def);
  316. }
  317.  
  318. argsmod(toks, args)
  319. NODEP toks, args;
  320. {
  321.     register NODE *np, *vp;
  322.  
  323.     for (np=toks; np != NULL; np = np->n_next)
  324.         if (np->e_token == ID) {
  325.             vp = llook(args,np);
  326.             if (vp != NULL) {
  327.                 np->e_token = DPARAM;
  328.                 np->e_ival = vp->e_ival;
  329.                 sprintf(np->n_name, "\\%d", (int)np->e_ival);
  330.             }
  331.         }
  332. }
  333.  
  334. NODE *
  335. def_rgs()
  336. {
  337.     NODE *rv;
  338.     NODE *tail;
  339.     NODE *np;
  340.  
  341.     rv = NULL;
  342.     tail = NULL;
  343.     nxttok();
  344.     if (curtok.tnum == ')') {
  345.         goto out;
  346.     }
  347. more:
  348.     if (curtok.tnum != ID) {
  349.         error("expect ID");
  350.         goto bad;
  351.     }
  352.     np = tok_to_node();
  353.     np->e_ival = defnargs;    /* hold sequence number */
  354.     defnargs++;
  355.     if (tail == NULL) {    /* first one */
  356.         rv = np;
  357.         tail = np;
  358.     } else {            /* more */
  359.         tail->n_next = np;
  360.         tail = np;
  361.     }
  362.     nxttok();
  363.     if (curtok.tnum == ',') {
  364.         nxttok();
  365.         goto more;
  366.     }
  367.     if (curtok.tnum == ')')
  368.         goto out;
  369.     error("define arg syntax");
  370. bad:
  371.     freenode(rv);
  372.     rv = NULL;
  373.     defnargs = 0;
  374. out:
  375.     return rv;
  376. }
  377.  
  378. NODE *
  379. def_val()
  380. {
  381.     NODE *rv;
  382.     NODE *tail;
  383.     NODE *np;
  384.  
  385.     rv = NULL;
  386.     tail = NULL;
  387. more:
  388.     nxttok();
  389.     if (curtok.tnum == NL) {
  390.         goto out;
  391. /*
  392.     } else if (curtok.tnum == '\\') {
  393.         nxttok();
  394.         if (curtok.tnum != NL)
  395.             goto bad;
  396.         goto more;
  397. */
  398.     }
  399.     np = tok_to_node();
  400.     if (tail == NULL) {    /* first one */
  401.         rv = np;
  402.         tail = np;
  403.     } else {            /* more */
  404.         tail->n_next = np;
  405.         tail = np;
  406.     }
  407.     goto more;
  408.  
  409. bad:
  410.     freenode(rv);
  411.     rv = NULL;
  412. out:
  413.     return rv;
  414. }
  415.  
  416. NODE *
  417. gath1(sep)
  418. int *sep;
  419. {
  420.     NODE *np, *rv, *tail;
  421.     int inparen;
  422.  
  423.     inparen = 0;
  424.     rv = NULL;
  425.     tail = NULL;
  426. more:
  427.     np = hi_node();
  428.     if (np == NULL) {
  429.         goto bad;
  430.     }
  431.     switch (np->e_token) {
  432.     case ')':
  433.     case ',':
  434.         if (inparen) {    /* dont end, part of subexpr */
  435.             if (np->e_token == ')')
  436.                 inparen--;
  437.             break;
  438.         }
  439.         *sep = np->e_token;
  440.         freenode(np);
  441.         goto out;
  442.     case '(':
  443.         inparen++;
  444.         break;
  445.     }
  446.     if (tail == NULL) {    /* first one */
  447.         rv = np;
  448.         tail = np;
  449.     } else {            /* more */
  450.         tail->n_next = np;
  451.         tail = np;
  452.     }
  453.     goto more;
  454. bad:
  455.     freenode(rv);
  456.     rv = NULL;
  457.     *sep = 0;
  458. out:
  459.     return rv;
  460. }
  461.  
  462. NODE *
  463. gath_args(n)
  464. {
  465.     NODE *rv;
  466.     NODE *tail;
  467.     NODE *np;
  468.     int sep;
  469.     int getn;
  470.  
  471.     getn = 0;
  472.     rv = NULL;
  473.     tail = NULL;
  474.     np = hi_node();
  475.     if (np->e_token != '(') {
  476.         error("expect (");
  477.         goto bad;
  478.     }
  479.     freenode(np);
  480.     if (n == 0) {
  481.         np = hi_node();
  482.         if (np->e_token != ')') {
  483.             error("expect )");
  484.             goto bad;
  485.         }
  486.         freenode(np);
  487.         return NULL;
  488.     }
  489. more:
  490.     np = gath1(&sep);
  491.     if (np == NULL) {
  492.         error("expect arg");
  493.         goto bad;
  494.     }
  495.     getn++;
  496.     if (tail == NULL) {    /* first one */
  497.         rv = np;
  498.         tail = np;
  499.     } else {            /* more */
  500.         tail->n_right = np;
  501.         tail = np;
  502.     }
  503.     if (sep) switch (sep) {
  504.     case ',':
  505.         goto more;
  506.     case ')':
  507.         if (getn != n) {
  508.             error("arg num mismatch");
  509.             goto bad;
  510.         }
  511.         goto out;
  512.     }
  513.     error("expand arg syntax");
  514. bad:
  515.     freenode(rv);
  516.     rv = NULL;
  517. out:
  518.     return rv;
  519. }
  520.  
  521. NODE *
  522. argfix(val, args, rt)
  523. NODE *val, *args;
  524. NODE **rt;
  525. {
  526.     register NODE *scan, *sub;
  527.     NODE *head;
  528.     NODE *tail, *back;
  529.     NODE *rthnode();
  530.     NODE *copylist();
  531.  
  532.     head = val;
  533.     back = NULL;
  534.     for (scan = val; scan != NULL; back=scan, scan=scan->n_next)
  535.         if (scan->e_token == DPARAM) {
  536.             sub = rthnode(args, (int)scan->e_ival);
  537.             sub = copylist(sub,&tail);
  538.             if (back) {
  539.                 back->n_next = sub;
  540.                 tail->n_next = scan->n_next;
  541.             } else {
  542.                 head = sub;
  543.                 tail->n_next = scan->n_next;
  544.             }
  545.             scan->n_next = NULL;
  546.             freenode(scan);
  547.             scan = tail;
  548.         }
  549.     *rt = back;
  550.     return head;
  551. }
  552.  
  553. expand(dp)
  554. NODEP dp;
  555. {
  556.     int nargs;
  557.     NODEP args;
  558.     register NODEP val;
  559.     NODEP tail;
  560.  
  561.     val = dp->n_right;
  562.     if (val)
  563.         val = copylist(val, &tail);
  564.     nargs = dp->e_ival;
  565.     if (nargs >= 0) {
  566.         args = gath_args(nargs);
  567.         if (args) {
  568.             if (val)
  569.                 val = argfix(val,args,&tail);
  570.             freenode(args);
  571.         }
  572.     }
  573.     if (val == NULL)
  574.         return;
  575. #ifdef DEBUG
  576.     if (debugd > 1) {
  577.         printf("Expand");
  578.         printnode(val);
  579.     }
  580. #endif
  581.     tail->n_next = holdtok;
  582.     holdtok = val;
  583. }
  584.  
  585. p_undef()
  586. {
  587.     NODEP np, tp;
  588.  
  589.     nxttok();
  590.     if (curtok.tnum != ID) {
  591.         error("bad #undef");
  592.         goto out;
  593.     }
  594.     tp = tok_to_node();
  595.     if ((np = hlook(deflist, tp)) != NULL)
  596.         /* quick and dirty */
  597.         np->n_name[0] = '#';
  598.     freenode(tp);
  599. out:
  600.     ;
  601. }
  602.  
  603. #endif
  604. #if PART_2
  605.  
  606. p_inc()
  607. {
  608.     int chkhere;
  609.     FILE *newf, *srch_open();
  610.     char *scopy(), *newnm;
  611.  
  612.     tk_flags |= TK_NOESC|TK_LTSTR;
  613.     nxttok();
  614.     switch (curtok.tnum) {
  615.     case SCON:
  616.         chkhere = 1;
  617.         break;
  618.     case SCON2:
  619.         chkhere = 0;
  620.         break;
  621.     case NL:
  622.     case EOF:
  623.         error("bad #include");
  624.         return;
  625.     }
  626.     newf = srch_open(curstr, chkhere);
  627.     if (newf == NULL) {
  628.         fatals("Cant open ", curstr);
  629.         return;
  630.     }
  631.     newnm = scopy(curstr);
  632.     do 
  633.         nxttok();
  634.     while (curtok.tnum != NL);
  635.     newfile(newf,newnm);
  636. }
  637.  
  638. int inclvl;
  639. struct svinc {
  640.     int lineno;
  641.     FILE *fd;
  642.     char *filenm;
  643. } svincs[MAXINCL];
  644.  
  645. #if NEEDBUF
  646. char p_buf[MAXINCL][BUFSIZ];
  647. #endif
  648.  
  649. static char obuf[MAXSTR];
  650.  
  651. newfile(fd,s)
  652. FILE *fd;
  653. char *s;
  654. {
  655.     register struct svinc *p;
  656.  
  657.     inclvl++;
  658.     if (inclvl > MAXINCL) {
  659.         inclvl--;
  660.         fclose(fd);
  661.         error("too many includes");
  662.         return;
  663.     }
  664.     p = &svincs[inclvl-1];
  665.     p->lineno = lineno;
  666.     p->fd = input;
  667.     p->filenm = inname;
  668.     input = fd;
  669.     lineno = 1;
  670.     inname = s;
  671. #if NEEDBUF
  672.     setbuf(input, p_buf[inclvl-1]);
  673. #endif
  674. }
  675.  
  676. endfile()
  677. {
  678.     register struct svinc *p;
  679.  
  680.     if (inclvl == 0)
  681.         return 0;
  682.     fclose(input);
  683.     inclvl--;
  684.     p = &svincs[inclvl];
  685.     sfree(inname);
  686.     input = p->fd;
  687.     lineno = p->lineno;
  688.     inname = p->filenm;
  689.     return 1;
  690. }
  691.  
  692. #define MAXIDIR    10
  693.  
  694. #ifndef FOR_AMIGA
  695. #ifndef MINIX
  696. char *srchlist[MAXIDIR] = {
  697.     "",
  698.     "\\include\\",
  699.     "\\sozobon\\include\\",
  700.     "",
  701.     0
  702. };
  703. static int idir_n = 4;        /* number of entries in above table */
  704. #else
  705. char *srchlist[MAXIDIR] = {
  706.     "",
  707.     "/usr/include/",
  708.     0
  709. };
  710. static int idir_n = 2;
  711. #endif
  712. #else
  713. char *srchlist[MAXIDIR] = {
  714.     "",
  715.     "include:",
  716.     0
  717. };
  718. static int idir_n = 2;        /* number of entries in above table */
  719. #endif
  720.  
  721. static int idir_put = 1;    /* where to put -I dirs */
  722.  
  723. optincl(s)
  724. char *s;
  725. {
  726.     register char **pp;
  727.  
  728.     if (idir_n >= MAXIDIR-1) {
  729.         warn("too many -I dirs");
  730.         return;
  731.     }
  732.     for (pp = &srchlist[idir_n]; pp > &srchlist[idir_put]; ) {
  733.         pp--;
  734.         pp[1] = pp[0];
  735.     }
  736.     *pp = s;
  737.     idir_put++;
  738.     idir_n++;
  739. }
  740.  
  741. FILE *
  742. srch_open(s, chkhere)
  743. char *s;
  744. {
  745.     char **dir;
  746.     FILE *fd;
  747.  
  748.     dir = srchlist;
  749.     if (chkhere == 0) dir++;
  750.     while (*dir) {
  751.         strcpy(obuf, *dir);
  752.         strcat(obuf, s);
  753.         fd = fopen(obuf, ROPEN);
  754.         if (fd != NULL) {
  755.             return fd;
  756.         }
  757.         dir++;
  758.     }
  759.     return NULL;
  760. }
  761.  
  762. p_if(kind,skipping)
  763. {
  764.     int truth;
  765.     NODEP tp;
  766.  
  767.     if (skipping) {
  768.         ifnest++;
  769.         return;
  770.     }
  771.     switch (kind) {
  772.     case 0:
  773.         truth = if_expr();
  774.         break;
  775.     case 1:
  776.     case 2:
  777.         nxttok();
  778.         if (curtok.tnum != ID) {
  779.             error("bad #if(n)def");
  780.             goto flush;
  781.         }
  782.         tp = tok_to_node();
  783.         truth = (hlook(deflist, tp) != NULL);
  784.         freenode(tp);
  785.         if (kind == 2)
  786.             truth = !truth;
  787.     }
  788.     iflevel++;
  789.     iftruth = truth;
  790. flush:
  791.     ;
  792. }
  793.  
  794. if_expr()
  795. {
  796.     NODE *tp, *questx();
  797.     extern NODE *cur;
  798.     int rv;
  799.  
  800.     in_if_x = 1;
  801.     skip_id = 0;
  802.     advnode();
  803.     tp = questx();
  804.     in_if_x = 0;
  805.     skip_id = 0;
  806.     if (tp) {
  807.         pnames(tp);
  808.         rv = conxval(tp);
  809.     } else
  810.         rv = 0;
  811.     if (cur->e_token != NL) {
  812.         error("bad #if");
  813.     } else
  814.         freenode(cur);
  815.     return rv;
  816. }
  817.  
  818. pnames(np)
  819. register NODEP np;
  820. {
  821. again:
  822.     if (np->e_token == ID) {
  823.         np->e_token = ICON;
  824.         np->e_ival = 0;
  825.     } else if (np->e_token == '(') {
  826.         NODEP rp, lp;
  827.         int truth;
  828.  
  829.         rp = np->n_right;
  830.         lp = np->n_left;
  831.         if (lp->e_token == ID && strcmp(lp->n_name, "defined") == 0
  832.             && rp && rp->e_token == ID) {
  833.             truth = (hlook(deflist, rp) != NULL);
  834.             freenode(rp);
  835.             freenode(lp);
  836.             np->n_left = NULL;
  837.             np->n_right = NULL;
  838.             np->e_token = ICON;
  839.             np->e_ival = truth;
  840.         }
  841.     }
  842.     if (np->n_right)
  843.         pnames(np->n_right);
  844.     np = np->n_left;
  845.     if (np)
  846.         goto again;
  847. }
  848.  
  849. p_swit(kind,skipping)
  850. {
  851.     if (skipping && ifnest) {
  852.         if (kind == 1)
  853.             ifnest--;
  854.         return;
  855.     }
  856.     if (iflevel == 0) {
  857.         error("not in #if");
  858.         goto out;
  859.     }
  860.     switch (kind) {
  861.     case 0:        /* else */
  862.         iftruth = !iftruth;
  863.         break;
  864.     case 1:        /* endif */
  865.         iflevel--;
  866.         iftruth = 1;
  867.         break;
  868.     }
  869. out:
  870.     ;
  871. }
  872.  
  873. p_line()
  874. {
  875.     char *scopy();
  876.  
  877.     nxttok();
  878.     if (curtok.tnum != ICON) {
  879.         error("bad #line");
  880.         goto flush;
  881.     }
  882.     tk_flags |= TK_NOESC;
  883.     nxttok();
  884.     if (curtok.tnum == SCON) {
  885.         sfree(inname);
  886.         inname = scopy(curtok.name);
  887.     }
  888.     lineno = curtok.ival;
  889. flush:
  890.     ;
  891. }
  892.  
  893. struct cmds {
  894.     char *name;
  895.     int (*fun)();
  896.     int arg;
  897.     int skip;
  898. } pcmds[] = {
  899.     {"define", p_def, 0, 1},
  900.     {"undef", p_undef, 0, 1},
  901.     {"include", p_inc, 0, 1},
  902.     {"if", p_if, 0, 0},
  903.     {"ifdef", p_if, 1, 0},
  904.     {"ifndef", p_if, 2, 0},
  905.     {"else", p_swit, 0, 0},
  906.     {"endif", p_swit, 1, 0},
  907.     {"line", p_line, 0, 1},
  908.     {0}
  909. };
  910.  
  911. dopound(skipping)
  912. {
  913.     register struct cmds *p;
  914.     register char *cname;
  915.  
  916.     tk_flags |= TK_SEENL;
  917.     sawnl = 0;
  918.     nxttok();
  919.     if (curtok.tnum != ID) {
  920.         error("expect name");
  921.         return;
  922.     }
  923.     cname = curtok.name;
  924.     for (p=pcmds; p->name; p++)
  925.         if (strcmp(p->name, cname) == 0) {
  926.             if (!skipping || !p->skip)
  927.                 (*p->fun)(p->arg, skipping);
  928.             tk_flags = 0;
  929.             if (sawnl == 0)
  930.                 tk_flags |= TK_ONLY1;
  931.             return;
  932.         }
  933.     error("bad # command");
  934. }
  935.  
  936. NODEP
  937. tok_to_node()
  938. {
  939.     register struct tok *tp;
  940.     register NODEP np;
  941.  
  942.     tp = &curtok;
  943.     np = allocnode();
  944.     np->e_token = tp->tnum;
  945.     np->e_flags = tp->flags;
  946.     if (tp->prec)    /* binary op */
  947.         np->e_prec = tp->prec;
  948.     else
  949.     switch (np->e_token) {
  950.     case ICON:
  951.         np->e_ival = tp->ival;
  952.         break;
  953.     case FCON:
  954.         np->e_fval = tp->fval;
  955.         break;
  956.     }
  957.     nscpy(np, tp->name);
  958.     return np;
  959. }
  960.  
  961. NODEP
  962. id_tok(s)
  963. char *s;
  964. {
  965.     NODEP np;
  966.  
  967.     np = allocnode();
  968.     np->e_token = ID;
  969.     nscpy(np, s);
  970.     return np;
  971. }
  972.  
  973. #endif
  974.