home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckwart.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  17KB  |  747 lines
  1. #include "ckcsym.h"
  2. char *wartv = "Wart Version 2.14, 10 Nov 1999";
  3.  
  4. #define CKWART_C
  5.  
  6. #ifdef MDEBUG
  7. /* Use the real ones in this module only */
  8. #ifdef malloc
  9. #undef malloc
  10. #endif /* malloc */
  11. #ifdef calloc
  12. #undef calloc
  13. #endif /* calloc */
  14. #ifdef realloc
  15. #undef realloc
  16. #endif /* realloc */
  17. #ifdef free
  18. #undef free
  19. #endif /* free */
  20. #endif /* MDEBUG */
  21.  
  22. #ifdef MAC
  23. #define VOID void
  24. #endif /* MAC */
  25.  
  26. /* W A R T */
  27.  
  28. /*
  29.   A small subset of "lex".
  30.  
  31.   Authors: Jeff Damens, Frank da Cruz
  32.   Columbia University Center for Computing Activites.
  33.   First released November 1984.
  34.   Copyright (C) 1984, 2009,
  35.     Trustees of Columbia University in the City of New York.
  36.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  37.     copyright text in the ckcmai.c module for disclaimer and permissions.
  38. */
  39.  
  40. /*
  41.  * input format is:
  42.  *  lines to be copied | %state <state names...>
  43.  *  %%
  44.  * <state> | <state,state,...> CHAR  { actions }
  45.  * ...
  46.  *  %%
  47.  *  more lines to be copied
  48.  */
  49.  
  50. #include "ckcdeb.h"            /* Includes */
  51.  
  52. #ifdef STRATUS
  53. /* Actually call printf, not our printf-catcher for Kermit */
  54. #ifdef printf
  55. #undef printf
  56. #endif /* printf */
  57. #ifdef fprintf
  58. #undef fprintf
  59. #endif /* fprintf */
  60. #endif /* STRATUS */
  61.  
  62. #ifdef MAC
  63. /* Same deal for Macintosh */
  64. #ifdef printf
  65. #undef printf
  66. #endif /* printf */
  67. #ifdef fprintf
  68. #undef fprintf
  69. #endif /* fprintf */
  70. #endif /* MAC */
  71.  
  72. #ifdef UNIX
  73. /* And UNIX */
  74. #ifdef printf
  75. #undef printf
  76. #endif /* printf */
  77. #ifdef fprintf
  78. #undef fprintf
  79. #endif /* fprintf */
  80. #endif /* UNIX */
  81. /*
  82.   The following "char" should be changed to "short", "int", or "long" if your
  83.   wart program will generate more than 127 states.  Since wart is used mainly
  84.   with C-Kermit, which has about 80 states, "char" is adequate.  This keeps
  85.   the program about 3K-4K smaller, which can be critical on 16-bit
  86.   architectures.
  87. */
  88. #ifdef IRIX60
  89. /*
  90.   Also use short or int if your compiler complains inordinately about
  91.   "integer conversion resulted in a change of sign"...
  92. */
  93. #define TBL_TYPE "short"        /* C data type of state table */
  94. #else
  95. #define TBL_TYPE "char"            /* C data type of state table */
  96. #endif /* IRIX60 */
  97.  
  98. #define C_L 014                /* Formfeed */
  99.  
  100. #define SEP 1                /* Token types */
  101. #define LBRACK 2
  102. #define RBRACK 3
  103. #define WORD 4
  104. #define COMMA 5
  105.  
  106. /* Storage sizes */
  107.  
  108. #define MAXSTATES 50            /* max number of states */
  109. #define MAXWORD 50            /* max # of chars/word */
  110. #define SBYTES ((MAXSTATES+6)/8)    /* # of bytes for state bitmask */
  111.  
  112. /* Name of wart function in generated program */
  113.  
  114. #ifndef FNAME
  115. #define FNAME "wart"
  116. #endif /* FNAME */
  117.  
  118. /* Structure for state information */
  119.  
  120. struct transx {
  121.     CHAR states[SBYTES];        /* included states */
  122.     int anyst;                /* true if this good from any state */
  123.     CHAR inchr;                /* input character */
  124.     int actno;                /* associated action */
  125.     struct transx *nxt;
  126. };                    /* next transition */
  127. typedef struct transx *trans;
  128.  
  129. /* Function prototypes */
  130.  
  131. _PROTOTYP( VOID setwstate, (int, trans) );
  132. _PROTOTYP( int teststate, (int, trans) );
  133. _PROTOTYP( trans rdinput, (FILE *, FILE *) );
  134. _PROTOTYP( VOID initial, (FILE *, FILE *) );
  135. _PROTOTYP( int isin, (char *, int) );
  136. _PROTOTYP( int isword, (int) );
  137. _PROTOTYP( VOID rdword, (FILE *, char *) );
  138. _PROTOTYP( VOID rdstates, (FILE *, FILE *) );
  139. _PROTOTYP( trans newtrans, (void) );
  140. _PROTOTYP( trans rdrules, (FILE *, FILE *) );
  141. _PROTOTYP( VOID statelist, (FILE *, trans) );
  142. _PROTOTYP( VOID copyact, (FILE *, FILE *, int) );
  143. _PROTOTYP( int faction, (trans, int, int) );
  144. _PROTOTYP( VOID emptytbl, (void) );
  145. _PROTOTYP( VOID addaction, (int, int, int) );
  146. _PROTOTYP( VOID writetbl, (FILE *) );
  147. _PROTOTYP( VOID warray, (FILE *, char *, int [], int, char *) );
  148. _PROTOTYP( VOID prolog, (FILE *) );
  149. _PROTOTYP( VOID epilogue, (FILE *) );
  150. _PROTOTYP( VOID copyrest, (FILE *, FILE *) );
  151. _PROTOTYP( int gettoken, (FILE *) );
  152. _PROTOTYP( VOID rdcmnt, (FILE *) );
  153. _PROTOTYP( VOID clrhash, (void) );
  154. _PROTOTYP( int hash, (char *) );
  155. _PROTOTYP( VOID enter, (char *, int) );
  156. _PROTOTYP( int lkup, (char *) );
  157. _PROTOTYP( static char* copy, (char *s) );
  158.  
  159. /* Variables and tables */
  160.  
  161. /* lt 1992-10-08 Begin
  162.  * provide definition for deblog variable
  163.  * ckcdeb.h declares as extern. DECC AXP is strict about ref/def model
  164.  * Variable is unused herein, to the best of my knowledge.
  165.  */
  166. #ifdef VMS
  167. int deblog;
  168. #endif /* VMS */
  169. /* lt 1992-10-08 End
  170.  */
  171.  
  172. static int lines, nstates, nacts;
  173.  
  174. static char tokval[MAXWORD];
  175.  
  176. static int tbl[MAXSTATES*96];
  177.  
  178. char *tbl_type = TBL_TYPE;
  179.  
  180. char *txt1 = "\n#define BEGIN state =\n\nint state = 0;\n\nint\n";
  181.  
  182. char *fname = FNAME;            /* Generated function name goes here */
  183.  
  184. /* rest of program... */
  185.  
  186. char *txt2 = "()\n\
  187. {\n\
  188.     int c,actno;\n\
  189.     extern ";
  190.  
  191. /* Data type of state table is inserted here (short or int) */
  192.  
  193. char *txt2a =
  194. " tbl[];\n\
  195.     while (1) {\n\
  196.     c = input() - 32;\n\
  197.     debug(F000,\"PROTO input\",ckitoa(state),c+32);\n\
  198.     if (c < 0 || c > 95) c = 0;\n";
  199.  
  200. char *txt2b = "    if ((actno = tbl[c + state*96]) != -1)\n\
  201.         switch(actno) {\n";
  202.  
  203. /* this program's output goes here, followed by final text... */
  204.  
  205. char *txt3 = "\n        }\n    }\n}\n\n";
  206.  
  207.  
  208. /*
  209.  * turn on the bit associated with the given state
  210.  *
  211.  */
  212. VOID
  213. setwstate(state,t) int state; trans t; {
  214.     int idx,msk;
  215.     idx = state/8;            /* byte associated with state */
  216.     msk = 0x80 >> (state % 8);        /* bit mask for state */
  217.     t->states[idx] |= msk;
  218. }
  219.  
  220. /*
  221.  * see if the state is involved in the transition
  222.  *
  223.  */
  224. int
  225. teststate(state,t) int state; trans t; {
  226.     int idx,msk;
  227.     idx = state/8;
  228.     msk = 0x80 >> (state % 8);
  229.     return(t->states[idx] & msk);
  230. }
  231.  
  232.  
  233. /*
  234.  * read input from here...
  235.  *
  236.  */
  237.  
  238. trans
  239. rdinput(infp,outfp) FILE *infp,*outfp; {
  240.     trans x;
  241.     lines = 1;                /* line counter */
  242.     nstates = 0;            /* no states */
  243.     nacts = 0;                /* no actions yet */
  244.     fprintf(outfp,"\n%c* WARNING -- This C source program generated by ",'/');
  245.     fprintf(outfp,"Wart preprocessor. */\n");
  246.     fprintf(outfp,"%c* Do not edit this file; edit the Wart-format ",'/');
  247.     fprintf(outfp,"source file instead, */\n");
  248.     fprintf(outfp,"%c* and then run it through Wart to produce a new ",'/');
  249.     fprintf(outfp,"C source file.     */\n\n");
  250.     fprintf(outfp,"%c* Wart Version Info: */\n",'/');
  251.     fprintf(outfp,"char *wartv = \"%s\";\n\n",wartv);
  252.  
  253.     initial(infp,outfp);        /* read state names, initial defs */
  254.     prolog(outfp);            /* write out our initial code */
  255.     x = rdrules(infp,outfp);        /* read rules */
  256.     epilogue(outfp);            /* write out epilogue code */
  257.     return(x);
  258. }
  259.  
  260.  
  261. /*
  262.  * initial - read initial definitions and state names.  Returns
  263.  * on EOF or %%.
  264.  *
  265.  */
  266. VOID
  267. initial(infp,outfp) FILE *infp, *outfp; {
  268.     int c;
  269.     char wordbuf[MAXWORD];
  270.     while ((c = getc(infp)) != EOF) {
  271.     if (c == '%') {
  272.         rdword(infp,wordbuf);
  273.         if (strcmp(wordbuf,"states") == 0)
  274.           rdstates(infp,outfp);
  275.         else if (strcmp(wordbuf,"%") == 0) return;
  276.         else fprintf(outfp,"%%%s",wordbuf);
  277.     }
  278.     else putc(c,outfp);
  279.     if (c == '\n') lines++;
  280.     }
  281. }
  282.  
  283. /*
  284.  * boolean function to tell if the given character can be part of
  285.  * a word.
  286.  *
  287.  */
  288. int
  289. isin(s,c) char *s; int c; {
  290.     for (; *s != '\0'; s++)
  291.       if (*s == (char) c) return(1);
  292.     return(0);
  293. }
  294. int
  295. isword(c) int c; {
  296.     static char special[] = ".%_-$@";    /* these are allowable */
  297.     return(isalnum(c) || isin(special,c));
  298. }
  299.  
  300. /*
  301.  * read the next word into the given buffer.
  302.  *
  303.  */
  304. VOID
  305. rdword(fp,buf) FILE *fp; char *buf; {
  306.     int len = 0,c;
  307.     while (isword(c = getc(fp)) && ++len < MAXWORD) *buf++ = (char) c;
  308.     *buf++ = '\0';            /* tie off word */
  309.     ungetc(c,fp);            /* put break char back */
  310. }
  311.  
  312. /*
  313.  * read state names, up to a newline.
  314.  *
  315.  */
  316. VOID
  317. rdstates(fp,ofp) FILE *fp,*ofp; {
  318.     int c;
  319.     char wordbuf[MAXWORD];
  320.     while ((c = getc(fp)) != EOF && c != '\n') {
  321.     if (isspace(c) || c == C_L) continue;    /* skip whitespace */
  322.     ungetc(c,fp);            /* put char back */
  323.     rdword(fp,wordbuf);        /* read the whole word */
  324.     enter(wordbuf,++nstates);    /* put into symbol tbl */
  325.     fprintf(ofp,"#define %s %d\n",wordbuf,nstates);
  326.     }
  327.     lines++;
  328. }
  329.  
  330. /*
  331.  * allocate a new, empty transition node
  332.  *
  333.  */
  334. trans
  335. newtrans() {
  336.     trans new;
  337.     int i;
  338.     new = (trans) malloc(sizeof (struct transx));
  339.     for (i=0; i<SBYTES; i++) new->states[i] = 0;
  340.     new->anyst = 0;
  341.     new->nxt = NULL;
  342.     return(new);
  343. }
  344.  
  345.  
  346. /*
  347.  * read all the rules.
  348.  *
  349.  */
  350.  
  351. trans
  352. rdrules(fp,out) FILE *fp,*out; {
  353.     trans head,cur,prev;
  354.     int curtok;
  355.     head = cur = prev = NULL;
  356.     while ((curtok = gettoken(fp)) != SEP)
  357.  
  358.       switch(curtok) {
  359.     case LBRACK:
  360.       if (cur == NULL)
  361.         cur = newtrans();
  362.       else
  363.         fatal("duplicate state list");
  364.       statelist(fp,cur);        /* set states */
  365.       continue;            /* prepare to read char */
  366.  
  367.     case WORD:
  368.       if ((int)strlen(tokval) != 1)
  369.         fatal("multiple chars in state");
  370.       if (cur == NULL) {
  371.           cur = newtrans();
  372.           cur->anyst = 1;
  373.       }
  374.       cur->actno = ++nacts;
  375.       cur->inchr = (char) (tokval[0] - 32);
  376.       if (head == NULL)
  377.         head = cur;
  378.       else
  379.         prev->nxt = cur;
  380.       prev = cur;
  381.       cur = NULL;
  382.       copyact(fp,out,nacts);
  383.       break;
  384.     default: fatal("bad input format");
  385.       }
  386.     return(head);
  387. }
  388.  
  389. /*
  390.  * read a list of (comma-separated) states, set them in the
  391.  * given transition.
  392.  *
  393.  */
  394. VOID
  395. statelist(fp,t) FILE *fp; trans t; {
  396.     int curtok,sval;
  397.     curtok = COMMA;
  398.     while (curtok != RBRACK) {
  399.     if (curtok != COMMA) fatal("missing comma");
  400.     if ((curtok = gettoken(fp)) != WORD) fatal("missing state name");
  401.     if ((sval = lkup(tokval)) == -1) {
  402.         fprintf(stderr,"state %s undefined\n",tokval);
  403.         fatal("undefined state");
  404.     }
  405.     setwstate(sval,t);
  406.     curtok = gettoken(fp);
  407.     }
  408. }
  409.  
  410. /*
  411.  * copy an action from the input to the output file
  412.  *
  413.  */
  414. VOID
  415. copyact(inp,outp,actno) FILE *inp,*outp; int actno; {
  416.     int c,bcnt;
  417.     fprintf(outp,"case %d:\n",actno);
  418.     while (c = getc(inp), (isspace(c) || c == C_L))
  419.       if (c == '\n') lines++;
  420.     if (c == '{') {
  421.     bcnt = 1;
  422.     fputs("    {",outp);
  423.     while (bcnt > 0 && (c = getc(inp)) != EOF) {
  424.         if (c == '{') bcnt++;
  425.         else if (c == '}') bcnt--;
  426.         else if (c == '\n') lines++;
  427.         putc(c,outp);
  428.     }
  429.     if (bcnt > 0) fatal("action doesn't end");
  430.     } else {
  431.     while (c != '\n' && c != EOF) {
  432.         putc(c,outp);
  433.         c = getc(inp);
  434.     }
  435.     lines++;
  436.     }
  437.     fprintf(outp,"\n    break;\n");
  438. }
  439.  
  440. /*
  441.  * find the action associated with a given character and state.
  442.  * returns -1 if one can't be found.
  443.  *
  444.  */
  445. int
  446. faction(hd,state,chr) trans hd; int state,chr; {
  447.     while (hd != NULL) {
  448.     if (hd->anyst || teststate(state,hd))
  449.       if (hd->inchr == ('.' - 32) || hd->inchr == (char) chr)
  450.         return(hd->actno);
  451.     hd = hd->nxt;
  452.     }
  453.     return(-1);
  454. }
  455.  
  456. /*
  457.  * empty the table...
  458.  *
  459.  */
  460. VOID
  461. emptytbl() {
  462.     int i;
  463.     for (i=0; i<nstates*96; i++) tbl[i] = -1;
  464. }
  465.  
  466. /*
  467.  * add the specified action to the output for the given state and chr.
  468.  *
  469.  */
  470. VOID
  471. addaction(act,state,chr) int act,state,chr; {
  472.     tbl[state*96 + chr] = act;
  473. }
  474.  
  475. VOID
  476. writetbl(fp) FILE *fp; {
  477.     warray(fp,"tbl",tbl,96*(nstates+1),TBL_TYPE);
  478. }
  479.  
  480.  
  481. /*
  482.  * write an array to the output file, given its name and size.
  483.  *
  484.  */
  485. VOID
  486. warray(fp,nam,cont,siz,typ) FILE *fp; char *nam; int cont[],siz; char *typ; {
  487.     int i;
  488.     fprintf(fp,"%s %s[] = {\n",typ,nam);
  489.     for (i = 0; i < siz - 1; ) {
  490.     fprintf(fp," %2d,",cont[i]);
  491.     if ((++i % 16) == 0) putc('\n',fp);
  492.     }
  493.     fprintf(fp,"%2d\n};\n",cont[siz-1]);
  494. }
  495.  
  496. #ifndef STRATUS
  497. #ifdef MAINTYPE
  498. /*
  499.   If you get complaints about "main: return type is not blah",
  500.   define MAINTYPE on the CC command line, e.g. "CFLAGS=-DMAINTYPE=int".
  501. */
  502. MAINTYPE
  503. #else
  504. #ifdef CK_SCOV5
  505. int
  506. #else
  507. #ifdef __DECC
  508. #ifdef __ALPHA
  509. int
  510. #else
  511. VOID
  512. #endif /* __ALPHA */
  513. #else
  514. #ifdef STRATUS
  515. int
  516. #ifdef __GNUC__
  517. int
  518. #else
  519. /*
  520.   The default case should be int, not VOID, but it's been this way for
  521.   years (no doubt for a reason) and who knows how many builds would break
  522.   if I changed it.
  523. */
  524. VOID
  525. #endif /* __GNUC__ */
  526. #endif /* STRATUS */
  527. #endif /* __DECC */
  528. #endif /* CK_SCOV5 */
  529. #endif /* MAINTYPE */
  530. #endif /* STRATUS */
  531. main(argc,argv) int argc; char **argv; {
  532.     trans head;
  533.     int state,c;
  534.     FILE *infile,*outfile;
  535.  
  536.     if (argc > 1) {
  537.     if ((infile = fopen(argv[1],"r")) == NULL) {
  538.         fprintf(stderr,"Can't open %s\n",argv[1]);
  539.         fatal("unreadable input file");
  540.     }
  541.     } else infile = stdin;
  542.  
  543.     if (argc > 2) {
  544.     if ((outfile = fopen(argv[2],"w")) == NULL) {
  545.         fprintf(stderr,"Can't write to %s\n",argv[2]);
  546.         fatal("bad output file");
  547.     }
  548.     } else outfile = stdout;
  549.  
  550.     clrhash();                /* empty hash table */
  551.     head = rdinput(infile,outfile);    /* read input file */
  552.     emptytbl();                /* empty our tables */
  553.     for (state = 0; state <= nstates; state++)
  554.       for (c = 1; c < 96; c++)        /* find actions, */
  555.     addaction(faction(head,state,c),state,c); /* add to tbl */
  556.     writetbl(outfile);
  557.     copyrest(infile,outfile);
  558.     printf("%d states, %d actions\n",nstates,nacts);
  559.     exit(GOOD_EXIT);
  560. }
  561.  
  562.  
  563. /*
  564.  * fatal error handler
  565.  *
  566.  */
  567.  
  568. VOID
  569. fatal(msg) char *msg; {
  570.     fprintf(stderr,"error in line %d: %s\n",lines,msg);
  571.     exit(BAD_EXIT);
  572. }
  573.  
  574. VOID
  575. prolog(outfp) FILE *outfp; {
  576.     int c;
  577.     while ((c = *txt1++)     != '\0') putc(c,outfp);
  578.     while ((c = *fname++)    != '\0') putc(c,outfp);
  579.     while ((c = *txt2++)     != '\0') putc(c,outfp);
  580.     while ((c = *tbl_type++) != '\0') putc(c,outfp);
  581.     while ((c = *txt2a++)    != '\0') putc(c,outfp);
  582.     while ((c = *txt2b++)    != '\0') putc(c,outfp);
  583. }
  584.  
  585. VOID
  586. epilogue(outfp) FILE *outfp; {
  587.     int c;
  588.     while ((c = *txt3++) != '\0') putc(c,outfp);
  589. }
  590.  
  591. VOID
  592. copyrest(in,out) FILE *in,*out; {
  593.     int c;
  594.     while ((c = getc(in)) != EOF) putc(c,out);
  595. }
  596.  
  597. /*
  598.  * gettoken - returns token type of next token, sets tokval
  599.  * to the string value of the token if appropriate.
  600.  *
  601.  */
  602.  
  603. int
  604. gettoken(fp) FILE *fp; {
  605.     int c;
  606.     while (1) {                /* loop if reading comments... */
  607.     do {
  608.         c = getc(fp);
  609.         if (c == '\n') lines++;
  610.     } while ((isspace(c) || c == C_L)); /* skip whitespace */
  611.     switch(c) {
  612.       case EOF:
  613.         return(SEP);
  614.       case '%':
  615.         if ((c = getc(fp)) == '%') return(SEP);
  616.         tokval[0] = '%';
  617.         tokval[1] = (char) c;
  618.         rdword(fp,tokval+2);
  619.         return(WORD);
  620.       case '<':
  621.         return(LBRACK);
  622.       case '>':
  623.         return(RBRACK);
  624.       case ',':
  625.         return(COMMA);
  626.       case '/':
  627.         if ((c = getc(fp)) == '*') {
  628.         rdcmnt(fp);        /* skip over the comment */
  629.         continue;
  630.         } else {            /* and keep looping */
  631.         ungetc(c,fp);        /* put this back into input */
  632.         c = '/';        /* put character back, fall thru */
  633.         }
  634.  
  635.       default:
  636.         if (isword(c)) {
  637.         ungetc(c,fp);
  638.         rdword(fp,tokval);
  639.         return(WORD);
  640.         } else fatal("Invalid character in input");
  641.     }
  642.     }
  643. }
  644.  
  645. /*
  646.  * skip over a comment
  647.  *
  648.  */
  649.  
  650. VOID
  651. rdcmnt(fp) FILE *fp; {
  652.     int c,star,prcnt;
  653.     prcnt = star = 0;            /* no star seen yet */
  654.     while (!((c = getc(fp)) == '/' && star)) {
  655.     if (c == EOF || (prcnt && c == '%')) fatal("Unterminated comment");
  656.     prcnt = (c == '%');
  657.     star = (c == '*');
  658.     if (c == '\n') lines++;
  659.     }
  660. }
  661.  
  662. /*
  663.  * symbol table management for wart
  664.  *
  665.  * entry points:
  666.  *   clrhash - empty hash table.
  667.  *   enter - enter a name into the symbol table
  668.  *   lkup - find a name's value in the symbol table.
  669.  *
  670.  */
  671.  
  672. #define HASHSIZE 101            /* # of entries in hash table */
  673.  
  674. struct sym {
  675.     char *name;                /* symbol name */
  676.     int val;                /* value */
  677.     struct sym *hnxt;            /* next on collision chain */
  678. } *htab[HASHSIZE];            /* the hash table */
  679.  
  680. /*
  681.  * empty the hash table before using it...
  682.  *
  683.  */
  684. VOID
  685. clrhash() {
  686.     int i;
  687.     for (i=0; i<HASHSIZE; i++) htab[i] = NULL;
  688. }
  689.  
  690. /*
  691.  * compute the value of the hash for a symbol
  692.  *
  693.  */
  694. int
  695. hash(name) char *name; {
  696.     int sum;
  697.     for (sum = 0; *name != '\0'; name++) sum += (sum + *name);
  698.     sum %= HASHSIZE;            /* take sum mod hashsize */
  699.     if (sum < 0) sum += HASHSIZE;    /* disallow negative hash value */
  700.     return(sum);
  701. }
  702.  
  703. /*
  704.  * make a private copy of a string...
  705.  *
  706.  */
  707. static char*
  708. copy(s) char *s; {
  709.     char *new;
  710.     new = (char *) malloc((int)strlen(s) + 1);
  711.     strcpy(new,s);
  712.     return(new);
  713. }
  714.  
  715. /*
  716.  * enter state name into the hash table
  717.  *
  718.  */
  719. VOID
  720. enter(name,svalue) char *name; int svalue; {
  721.     int h;
  722.     struct sym *cur;
  723.     if (lkup(name) != -1) {
  724.     fprintf(stderr,"state \"%s\" appears twice...\n", name);
  725.     exit(BAD_EXIT);
  726.     }
  727.     h = hash(name);
  728.     cur = (struct sym *)malloc(sizeof (struct sym));
  729.     cur->name = copy(name);
  730.     cur->val = svalue;
  731.     cur->hnxt = htab[h];
  732.     htab[h] = cur;
  733. }
  734.  
  735. /*
  736.  * find name in the symbol table, return its value.  Returns -1
  737.  * if not found.
  738.  *
  739.  */
  740. int
  741. lkup(name) char *name; {
  742.     struct sym *cur;
  743.     for (cur = htab[hash(name)]; cur != NULL; cur = cur->hnxt)
  744.       if (strcmp(cur->name,name) == 0) return(cur->val);
  745.     return(-1);
  746. }
  747.