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