home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pccts.zip / pccts / h / antlrx.h < prev    next >
C/C++ Source or Header  |  1994-03-31  |  7KB  |  218 lines
  1. /* antlrx.h
  2.  *
  3.  * Define the generic ANTLRParser superclass, which is subclassed to
  4.  * define an actual parser.
  5.  *
  6.  * Before entry into this file: TokenType must be set.
  7.  *
  8.  * ast stuff has not been converted to c++ and will not even compile
  9.  * due to stuff in this file.
  10.  *
  11.  * SOFTWARE RIGHTS
  12.  *
  13.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  14.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  15.  * company may do whatever they wish with source code distributed with
  16.  * PCCTS or the code generated by PCCTS, including the incorporation of
  17.  * PCCTS, or its output, into commerical software.
  18.  * 
  19.  * We encourage users to develop software with PCCTS.  However, we do ask
  20.  * that credit is given to us for developing PCCTS.  By "credit",
  21.  * we mean that if you incorporate our source code into one of your
  22.  * programs (commercial product, research project, or otherwise) that you
  23.  * acknowledge this fact somewhere in the documentation, research report,
  24.  * etc...  If you like PCCTS and have developed a nice tool with the
  25.  * output, please mention that you developed it using PCCTS.  In
  26.  * addition, we ask that this header remain intact in our source code.
  27.  * As long as these guidelines are kept, we expect to continue enhancing
  28.  * this system and expect to make other tools available as they are
  29.  * completed.
  30.  *
  31.  * ANTLR 1.20
  32.  * Terence Parr
  33.  * Purdue University
  34.  * With AHPCRC, University of Minnesota
  35.  * 1989-1994
  36.  */
  37.  
  38. #ifndef ANTLRX_H
  39. #define ANTLRX_H
  40.  
  41. #include <stdio.h>
  42. #include <setjmp.h>
  43. #include "AToken.h"
  44. #include "ATokenStream.h"
  45.  
  46. #ifdef ZZCAN_GUESS
  47. #ifndef ZZINF_LOOK
  48. #define ZZINF_LOOK
  49. #endif
  50. #endif
  51.  
  52.  
  53. /* define usable bits SetWordType */
  54.  
  55. typedef unsigned char SetWordType;
  56.  
  57. #define WORDSIZE    (sizeof(SetWordType)*8)
  58. #define LOGWORDSIZE    3
  59.  
  60.  
  61.            /* s y n t a c t i c  p r e d i c a t e  s t u f f */
  62.  
  63. typedef struct _zzjmp_buf {
  64.             jmp_buf state;
  65.         } zzjmp_buf;
  66.  
  67. /* these need to be macros not member functions */
  68. #define zzGUESS_BLOCK        ANTLRParserState zzst; int zzrv;
  69. #define zzNON_GUESS_MODE    if ( !guessing )
  70. #define zzGUESS_FAIL        guess_fail()
  71. #define zzGUESS_DONE        guess_done(&zzst);
  72. #define zzGUESS                saveState(&zzst); \
  73.                             guessing = 1; \
  74.                             zzrv = setjmp(guess_start.state);
  75.  
  76.                   /* a n t l r  p a r s e r  d e f */
  77.  
  78. struct ANTLRParserState {
  79.     /* class variables */
  80.     ANTLRTokenStream *lexer;        //place to get tokens
  81.     zzjmp_buf guess_start;
  82.     int guessing;
  83.  
  84.     int inf_lap;
  85.     int inf_labase;
  86.     int inf_last;
  87.  
  88.     int dirty;
  89.  
  90.     TokenType *token_type;        // fast reference cache of token.type()
  91.     ANTLRTokenBase **token;        // the token with all its attributes
  92.     int lap;
  93.     int labase;
  94. };
  95.  
  96. /* notes:
  97.  *
  98.  * multiple inheritance is a cool way to include what stuff is needed
  99.  * in this structure (like guess stuff).  however, i'm not convinced that
  100.  * multiple inheritance works correctly on all platforms.  not that
  101.  * much space is used--just include all possibly useful members.
  102.  *
  103.  * the class should also be a template with arguments for the lookahead
  104.  * depth and so on.  that way, more than one parser can be defined (as
  105.  * each will probably have different lookahead requirements).  however,
  106.  * am i sure that templates work?  no, i'm not sure.
  107.  *
  108.  * no attributes are maintained and, hence, the 'asp' variable is not
  109.  * needed.  $i can still be referenced, but it refers to the token
  110.  * associated with that rule element.  question: where are the token's
  111.  * stored if not on the software stack?  in local variables created
  112.  * and assigned to by antlr.  they are pointers actually to the tokens
  113.  * sitting in parser.token[i].
  114.  */
  115. class ANTLRParser {
  116. protected:
  117.     /* class variables */
  118.     static SetWordType bitmask[sizeof(SetWordType)*8];
  119.  
  120. protected:
  121.     int LLk;                    // number of lookahead symbols (old LL_K)
  122.     int demand_look;
  123.     TokenType eofToken;            // when do I stop during resynch()s
  124.     int bsetsize;                // size of bitsets created by ANTLR in
  125.                                 // units of SetWordType
  126.  
  127.     ANTLRTokenStream *lexer;    //place to get input tokens
  128.  
  129.     zzjmp_buf guess_start;        // where to jump back to upon failure
  130.     int guessing;                // if guessing (using (...)? predicate)
  131.  
  132.     // infinite lookahead stuff
  133.     int can_use_inf_look;        // set by subclass (generated by ANTLR)
  134.     int inf_lap;
  135.     int inf_labase;
  136.     int inf_last;
  137.     ANTLRTokenBase **inf_token;
  138.     int *_inf_line;
  139.  
  140.     ANTLRChar **token_tbl;        // pointer to table of token type strings
  141.  
  142.     int dirty;                    // used during demand lookahead
  143.  
  144.     TokenType *token_type;        // fast reference cache of token.getType()
  145.     ANTLRTokenBase **token;        // the token with all its attributes
  146.     int lap;
  147.     int labase;
  148.  
  149. private:
  150.     void fill_inf_look();
  151.  
  152. protected:
  153.     int inf_LA_valid(unsigned i)    { return (((inf_labase+i-1)-LLk+1) <= inf_last); }
  154.     int inf_LA(unsigned i)            { return inf_token[(inf_labase+i-1)-LLk+1]->getType(); }
  155.     inline inf_line(unsigned i)        { return _inf_line[(inf_labase+i-1)-LLk+1]; }
  156.     void guess_fail()                { longjmp(guess_start.state, 1); }
  157.     void guess_done(ANTLRParserState *st){ restoreState(st); }
  158.     int guess(ANTLRParserState *);
  159.     void look(int);
  160.     ANTLRTokenBase *inf_gettok();
  161.     int _match(TokenType, ANTLRChar **, TokenType *, ANTLRTokenBase **, SetWordType **);
  162.     virtual void consume();
  163.     void resynch(SetWordType *wd,SetWordType mask);
  164.     void prime_lookahead();
  165.     virtual void tracein(ANTLRChar *r)
  166.             {
  167.                 fprintf(stderr, "enter rule \"%s\"\n", r);
  168.             }
  169.     virtual void traceout(ANTLRChar *r)
  170.             {
  171.                 fprintf(stderr, "exit rule \"%s\"\n", r);
  172.             }
  173.     unsigned MODWORD(unsigned x) {return x & (WORDSIZE-1);}    // x % WORDSIZE
  174.     unsigned DIVWORD(unsigned x) {return x >> LOGWORDSIZE;}    // x / WORDSIZE
  175.     int set_deg(SetWordType *);
  176.     int set_el(TokenType, SetWordType *);
  177.     void edecode(SetWordType *);
  178.     void FAIL(int k, ...);
  179.  
  180. public:
  181.     ANTLRParser(ANTLRTokenStream *,
  182.                 int k=1,
  183.                 int use_inf_look=0,
  184.                 int demand_look=0,
  185.                 int bsetsize=1);
  186.     virtual ~ANTLRParser();
  187.     inline TokenType LA(int);
  188.     inline ANTLRTokenBase *LT(int);
  189.  
  190.     void setEofToken(TokenType t) { eofToken = t; }
  191.  
  192.     void syn(ANTLRTokenBase *tok, ANTLRChar *egroup,
  193.              SetWordType *eset, TokenType etok, int k);
  194.     void saveState(ANTLRParserState *);
  195.     void restoreState(ANTLRParserState *);
  196.  
  197.     void ANTLRPanic(ANTLRChar *msg);
  198.     static ANTLRChar *eMsgd(ANTLRChar *,int);
  199.     static ANTLRChar *eMsg(ANTLRChar *,ANTLRChar *);
  200.     static ANTLRChar *eMsg2(ANTLRChar *,ANTLRChar *,ANTLRChar *);
  201. };
  202.  
  203.  
  204. #define zzmatch(_t)                            \
  205.     if ( !_match((TokenType)_t, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet) ) goto fail;
  206.  
  207. #ifndef zzfailed_pred
  208. #define zzfailed_pred(_p)       \
  209.         zzNON_GUESS_MODE { fprintf(stderr, "semantic error; failed predicate: '%s'\n",_p) }
  210. #endif
  211.  
  212. #define zzRULE        SetWordType *zzMissSet=NULL; TokenType zzMissTok=(TokenType)0;    \
  213.                     ANTLRTokenBase *zzBadTok; ANTLRChar *zzBadText="";        \
  214.                     int zzErrk=1;                                    \
  215.                     ANTLRChar *zzMissText="";
  216.  
  217. #endif
  218.