home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts.zip / pccts / h / dlgauto.h < prev    next >
C/C++ Source or Header  |  1994-03-31  |  10KB  |  469 lines
  1. /* dlgauto.h automaton
  2.  *
  3.  * SOFTWARE RIGHTS
  4.  *
  5.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  6.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  7.  * company may do whatever they wish with source code distributed with
  8.  * PCCTS or the code generated by PCCTS, including the incorporation of
  9.  * PCCTS, or its output, into commerical software.
  10.  * 
  11.  * We encourage users to develop software with PCCTS.  However, we do ask
  12.  * that credit is given to us for developing PCCTS.  By "credit",
  13.  * we mean that if you incorporate our source code into one of your
  14.  * programs (commercial product, research project, or otherwise) that you
  15.  * acknowledge this fact somewhere in the documentation, research report,
  16.  * etc...  If you like PCCTS and have developed a nice tool with the
  17.  * output, please mention that you developed it using PCCTS.  In
  18.  * addition, we ask that this header remain intact in our source code.
  19.  * As long as these guidelines are kept, we expect to continue enhancing
  20.  * this system and expect to make other tools available as they are
  21.  * completed.
  22.  *
  23.  * ANTLR 1.20
  24.  * Terence Parr
  25.  * Purdue University
  26.  * With AHPCRC, University of Minnesota
  27.  * 1989-1994
  28.  */
  29.  
  30. #ifndef ZZDEFAUTO_H
  31. #define ZZDEFAUTO_H
  32.  
  33. zzchar_t    *zzlextext;    /* text of most recently matched token */
  34. zzchar_t    *zzbegexpr;    /* beginning of last reg expr recogn. */
  35. zzchar_t    *zzendexpr;    /* beginning of last reg expr recogn. */
  36. int    zzbufsize;    /* number of characters in zzlextext */
  37. int    zzbegcol = 0;    /* column that first character of token is in*/
  38. int    zzendcol = 0;    /* column that last character of token is in */
  39. int    zzline = 1;    /* line current token is on */
  40. int    zzchar;        /* character to determine next state */
  41. int    zzbufovf;    /* indicates that buffer too small for text */
  42. int    zzcharfull = 0;
  43. static zzchar_t    *zznextpos;/* points to next available position in zzlextext*/
  44. static int     zzclass;
  45.  
  46. #ifdef __STDC__
  47. void    zzerrstd(char *);
  48. void    (*zzerr)(char *)=zzerrstd;/* pointer to error reporting function */
  49. extern int    zzerr_in(void);
  50. #else
  51. void    zzerrstd();
  52. void    (*zzerr)()=zzerrstd;    /* pointer to error reporting function */
  53. extern int    zzerr_in();
  54. #endif
  55.  
  56. static FILE    *zzstream_in=0;
  57. static int    (*zzfunc_in)() = zzerr_in;
  58. static zzchar_t    *zzstr_in=0;
  59.  
  60. static int     zzauto = 0;
  61. static int    zzadd_erase;
  62. static char     zzebuf[70];
  63.  
  64. #ifdef ZZCOL
  65. #define ZZINC (++zzendcol)
  66. #else
  67. #define ZZINC
  68. #endif
  69.  
  70.  
  71. #define ZZGETC_STREAM {zzchar = getc(zzstream_in); zzclass = ZZSHIFT(zzchar);}
  72. #define ZZGETC_FUNC {zzchar = (*zzfunc_in)(); zzclass = ZZSHIFT(zzchar);}
  73. #define ZZGETC_STR {             \
  74.     if (*zzstr_in){                \
  75.         zzchar = *zzstr_in;        \
  76.         ++zzstr_in;                \
  77.     }else{                        \
  78.         zzchar = EOF;            \
  79.     }                            \
  80.     zzclass = ZZSHIFT(zzchar);    \
  81. }
  82.  
  83. #define ZZNEWSTATE    (newstate = dfa[state][zzclass])
  84.  
  85. #ifndef ZZCOPY
  86. #define ZZCOPY    \
  87.     /* Truncate matching buffer to size (not an error) */    \
  88.     if (zznextpos < lastpos){                \
  89.         *(zznextpos++) = zzchar;            \
  90.     }else{                            \
  91.         zzbufovf = 1;                    \
  92.     }
  93. #endif
  94.  
  95. void
  96. #ifdef __STDC__
  97. zzrdstream( FILE *f )
  98. #else
  99. zzrdstream( f )
  100. FILE *f;
  101. #endif
  102. {
  103.     /* make sure that it is really set to something, otherwise just 
  104.        leave it be.
  105.     */
  106.     if (f){
  107.         /* make sure that there is always someplace to get input
  108.            before closing zzstream_in
  109.         */
  110. #if 0
  111.         if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
  112. #endif
  113.         zzline = 1;
  114.         zzstream_in = f;
  115.         zzfunc_in = NULL;
  116.         zzstr_in = 0;
  117.         zzcharfull = 0;
  118.     }
  119. }
  120.  
  121. void
  122. #ifdef __STDC__
  123. zzrdfunc( int (*f)() )
  124. #else
  125. zzrdfunc( f )
  126. int (*f)();
  127. #endif
  128. {
  129.     /* make sure that it is really set to something, otherwise just 
  130.        leave it be.
  131.     */
  132.     if (f){
  133.         /* make sure that there is always someplace to get input
  134.            before closing zzstream_in
  135.         */
  136. #if 0
  137.         if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
  138. #endif
  139.         zzline = 1;
  140.         zzstream_in = NULL;
  141.         zzfunc_in = f;
  142.         zzstr_in = 0;
  143.         zzcharfull = 0;
  144.     }
  145. }
  146.  
  147.  
  148. void
  149. #ifdef __STDC__
  150. zzrdstr( zzchar_t *s )
  151. #else
  152. zzrdstr( s )
  153. zzchar_t *s;
  154. #endif
  155. {
  156.     /* make sure that it is really set to something, otherwise just 
  157.        leave it be.
  158.     */
  159.     if (s){
  160.         /* make sure that there is always someplace to get input
  161.            before closing zzstream_in
  162.         */
  163. #if 0
  164.         if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
  165. #endif
  166.         zzline = 1;
  167.         zzstream_in = NULL;
  168.         zzfunc_in = 0;
  169.         zzstr_in = s;
  170.         zzcharfull = 0;
  171.     }
  172. }
  173.  
  174.  
  175. void
  176. zzclose_stream()
  177. {
  178. #if 0
  179.     fclose( zzstream_in );
  180.     zzstream_in = NULL;
  181.     zzfunc_in = NULL;
  182. #endif
  183. }
  184.  
  185. /* saves dlg state, but not what feeds dlg (such as file position) */
  186. void
  187. #ifdef __STDC__
  188. zzsave_dlg_state(struct zzdlg_state *state)
  189. #else
  190. zzsave_dlg_state(state)
  191. struct zzdlg_state *state;
  192. #endif
  193. {
  194.     state->stream = zzstream_in;
  195.     state->func_ptr = zzfunc_in;
  196.     state->str = zzstr_in;
  197.     state->auto_num = zzauto;
  198.     state->add_erase = zzadd_erase;
  199.     state->lookc = zzchar;
  200.     state->char_full = zzcharfull;
  201.     state->begcol = zzbegcol;
  202.     state->endcol = zzendcol;
  203.     state->line = zzline;
  204.     state->lextext = zzlextext;
  205.     state->begexpr = zzbegexpr;
  206.     state->endexpr = zzendexpr;
  207.     state->bufsize = zzbufsize;
  208.     state->bufovf = zzbufovf;
  209.     state->nextpos = zznextpos;
  210.     state->class_num = zzclass;
  211. }
  212.  
  213. void
  214. #ifdef __STDC__
  215. zzrestore_dlg_state(struct zzdlg_state *state)
  216. #else
  217. zzrestore_dlg_state(state)
  218. struct zzdlg_state *state;
  219. #endif
  220. {
  221.     zzstream_in = state->stream;
  222.     zzfunc_in = state->func_ptr;
  223.     zzstr_in = state->str;
  224.     zzauto = state->auto_num;
  225.     zzadd_erase = state->add_erase;
  226.     zzchar = state->lookc;
  227.     zzcharfull = state->char_full;
  228.     zzbegcol = state->begcol;
  229.     zzendcol = state->endcol;
  230.     zzline = state->line;
  231.     zzlextext = state->lextext;
  232.     zzbegexpr = state->begexpr;
  233.     zzendexpr = state->endexpr;
  234.     zzbufsize = state->bufsize;
  235.     zzbufovf = state->bufovf;
  236.     zznextpos = state->nextpos;
  237.     zzclass = state->class_num;
  238. }
  239.  
  240. void
  241. #ifdef __STDC__
  242. zzmode( int m )
  243. #else
  244. zzmode( m )
  245. int m;
  246. #endif
  247. {
  248.     /* points to base of dfa table */
  249.     if (m<MAX_MODE){
  250.         zzauto = m;
  251.         /* have to redo class since using different compression */
  252.         zzclass = ZZSHIFT(zzchar);
  253.     }else{
  254.         sprintf(zzebuf,"Invalid automaton mode = %d ",m);
  255.         zzerr(zzebuf);
  256.     }
  257. }
  258.  
  259. /* erase what is currently in the buffer, and get a new reg. expr */
  260. void
  261. zzskip()
  262. {
  263.     zzadd_erase = 1;
  264. }
  265.  
  266. /* don't erase what is in the zzlextext buffer, add on to it */
  267. void
  268. zzmore()
  269. {
  270.     zzadd_erase = 2;
  271. }
  272.  
  273. /* substitute c for the reg. expr last matched and is in the buffer */
  274. #ifdef __STDC__
  275. void
  276. zzreplchar(zzchar_t c)
  277. #else
  278. void
  279. zzreplchar(c)
  280. zzchar_t c;
  281. #endif
  282. {
  283.     /* can't allow overwriting null at end of string */
  284.     if (zzbegexpr < &zzlextext[zzbufsize-1]){
  285.         *zzbegexpr = c;
  286.         *(zzbegexpr+1) = '\0';
  287.     }
  288.     zzendexpr = zzbegexpr;
  289.     zznextpos = zzbegexpr + 1;
  290. }
  291.  
  292. /* replace the string s for the reg. expr last matched and in the buffer */
  293. void
  294. #ifdef __STDC__
  295. zzreplstr(register zzchar_t *s)
  296. #else
  297. zzreplstr(s)
  298. register zzchar_t *s;
  299. #endif
  300. {
  301.     register zzchar_t *l= &zzlextext[zzbufsize -1];
  302.  
  303.     zznextpos = zzbegexpr;
  304.     if (s){
  305.          while ((zznextpos <= l) && (*(zznextpos++) = *(s++))){
  306.             /* empty */
  307.         }
  308.         /* correct for NULL at end of string */
  309.         zznextpos--;
  310.     }
  311.     if ((zznextpos <= l) && (*(--s) == 0)){
  312.         zzbufovf = 0;
  313.     }else{
  314.         zzbufovf = 1;
  315.     }
  316.     *(zznextpos) = '\0';
  317.     zzendexpr = zznextpos - 1;
  318. }
  319.  
  320. void
  321. zzgettok()
  322. {
  323.     register int state, newstate;
  324.     /* last space reserved for the null char */
  325.     register zzchar_t *lastpos;
  326.  
  327. skip:
  328.     zzbufovf = 0;
  329.     lastpos = &zzlextext[zzbufsize-1];
  330.     zznextpos = zzlextext;
  331.     zzbegcol = zzendcol+1;
  332. more:
  333.     zzbegexpr = zznextpos;
  334. #ifdef ZZINTERACTIVE
  335.     /* interactive version of automaton */
  336.     /* if there is something in zzchar, process it */
  337.     state = newstate = dfa_base[zzauto];
  338.     if (zzcharfull){
  339.         ZZINC;
  340.         ZZCOPY;
  341.         ZZNEWSTATE;
  342.     }
  343.     if (zzstr_in)
  344.         while (zzalternatives[newstate]){
  345.             state = newstate;
  346.             ZZGETC_STR;
  347.             ZZINC;
  348.             ZZCOPY;
  349.             ZZNEWSTATE;
  350.         }
  351.     else if (zzstream_in)
  352.         while (zzalternatives[newstate]){
  353.             state = newstate;
  354.             ZZGETC_STREAM;
  355.             ZZINC;
  356.             ZZCOPY;
  357.             ZZNEWSTATE;
  358.         }
  359.     else if (zzfunc_in)
  360.         while (zzalternatives[newstate]){
  361.             state = newstate;
  362.             ZZGETC_FUNC;
  363.             ZZINC;
  364.             ZZCOPY;
  365.             ZZNEWSTATE;
  366.         }
  367.     /* figure out if last character really part of token */
  368.     if ((state != dfa_base[zzauto]) && (newstate == DfaStates)){
  369.         zzcharfull = 1;
  370.         --zznextpos;
  371.     }else{
  372.         zzcharfull = 0;
  373.         state = newstate;
  374.     }
  375.     *(zznextpos) = '\0';
  376.     /* Able to transition out of start state to some non err state?*/
  377.     if ( state == dfa_base[zzauto] ){
  378.         /* make sure doesn't get stuck */
  379.         zzadvance();
  380.     }
  381. #else
  382.     /* non-interactive version of automaton */
  383.     if (!zzcharfull)
  384.         zzadvance();
  385.     else
  386.         ZZINC;
  387.     state = dfa_base[zzauto];
  388.     if (zzstr_in)
  389.         while (ZZNEWSTATE != DfaStates){
  390.             state = newstate;
  391.             ZZCOPY;
  392.             ZZGETC_STR;
  393.             ZZINC;
  394.         }
  395.     else if (zzstream_in)
  396.         while (ZZNEWSTATE != DfaStates){
  397.             state = newstate;
  398.             ZZCOPY;
  399.             ZZGETC_STREAM;
  400.             ZZINC;
  401.         }
  402.     else if (zzfunc_in)
  403.         while (ZZNEWSTATE != DfaStates){
  404.             state = newstate;
  405.             ZZCOPY;
  406.             ZZGETC_FUNC;
  407.             ZZINC;
  408.         }
  409.     zzcharfull = 1;
  410.     if ( state == dfa_base[zzauto] ){
  411.         if (zznextpos < lastpos){
  412.             *(zznextpos++) = zzchar;
  413.         }else{
  414.             zzbufovf = 1;
  415.         }
  416.         *zznextpos = '\0';
  417.         /* make sure doesn't get stuck */
  418.         zzadvance();
  419.     }else{
  420.         *zznextpos = '\0';
  421.     }
  422. #endif
  423. #ifdef ZZCOL
  424.     zzendcol -= zzcharfull;
  425. #endif
  426.     zzendexpr = zznextpos -1;
  427.     zzadd_erase = 0;
  428.     (*actions[accepts[state]])();
  429.     switch (zzadd_erase) {
  430.         case 1: goto skip;
  431.         case 2: goto more;
  432.     }
  433. }
  434.  
  435. void
  436. zzadvance()
  437. {
  438.     if (zzstream_in) { ZZGETC_STREAM; zzcharfull = 1; ZZINC;}
  439.     if (zzfunc_in) { ZZGETC_FUNC; zzcharfull = 1; ZZINC;}
  440.     if (zzstr_in) { ZZGETC_STR; zzcharfull = 1; ZZINC;}
  441.     if (!(zzstream_in || zzfunc_in || zzstr_in)){
  442.         zzerr_in();
  443.     }
  444. }
  445.  
  446. void
  447. #ifdef __STDC__
  448. zzerrstd(char *s)
  449. #else
  450. zzerrstd(s)
  451. char *s;
  452. #endif
  453. {
  454.         fprintf(stderr,
  455.                 "%s near line %d (text was '%s')\n",
  456.                 ((s == NULL) ? "Lexical error" : s),
  457.                 zzline,zzlextext);
  458. }
  459.  
  460. int
  461. zzerr_in()
  462. {
  463.     fprintf(stderr,"No input stream, function, or string\n");
  464.     /* return eof to get out gracefully */
  465.     return EOF;
  466. }
  467.  
  468. #endif
  469.