EdkCompatibilityPkg/Other/Maintained/Tools/Pccts/h/AToken.h

   1 /* ANTLRToken.h
   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  * Terence Parr
  25  * Parr Research Corporation
  26  * with Purdue University and AHPCRC, University of Minnesota
  27  * 1989-1998
  28  */
  29
  30 #ifndef ATOKEN_H_GATE
  31 #define ATOKEN_H_GATE
  32
  33 #include "pcctscfg.h"
  34
  35 #include "pccts_string.h"
  36 #include "pccts_stdio.h"
  37 #include "pccts_stdlib.h"
  38
  39 PCCTS_NAMESPACE_STD
  40
  41 // MR9      RJV (JVincent@novell.com) Not needed for variable length strings
  42
  43 //// MR9 #ifndef ANTLRCommonTokenTEXTSIZE
  44 //// MR9 #define ANTLRCommonTokenTEXTSIZE          100
  45 //// MR9 #endif
  46
  47
  48 /* must define what a char looks like; can make this a class too */
  49 typedef char ANTLRChar;
  50
  51 /* D E F I N E  S M A R T  P O I N T E R S */
  52
  53 //#include ATOKPTR_H   not tested yet, leave out
  54 class ANTLRAbstractToken;
  55 typedef ANTLRAbstractToken *_ANTLRTokenPtr;
  56
  57 class ANTLRAbstractToken {
  58 public:
  59     virtual ~ANTLRAbstractToken() {;}
  60     virtual ANTLRTokenType getType() const = 0;
  61     virtual void setType(ANTLRTokenType t) = 0;
  62     virtual int getLine() const = 0;
  63     virtual void setLine(int line) = 0;
  64     virtual ANTLRChar *getText() const = 0;
  65     virtual void setText(const ANTLRChar *) = 0;
  66
  67     /* This function will disappear when I can use templates */
  68   virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
  69                       ANTLRChar *text,
  70                       int line) = 0;
  71
  72   /* define to satisfy ANTLRTokenBuffer's need to determine whether or
  73      not a token object can be destroyed.  If nref()==0, no one has
  74      a reference, and the object may be destroyed.  This function defaults
  75      to 1, hence, if you use deleteTokens() message with a token object
  76      not derived from ANTLRCommonRefCountToken, the parser will compile
  77      but will not delete objects after they leave the token buffer.
  78     */
  79
  80   virtual unsigned nref() const { return 1; }     // MR11
  81   virtual void ref() {;}
  82   virtual void deref() {;}
  83
  84   virtual void panic(const char *msg)             // MR20 const
  85     {
  86       fprintf(stderr, "ANTLRAbstractToken panic: %s\n", msg);
  87       exit(PCCTS_EXIT_FAILURE);
  88     }
  89 };
  90
  91 /* This class should be subclassed.  It cannot store token type or text */
  92
  93 class ANTLRRefCountToken : public ANTLRAbstractToken {
  94 public:
  95 #ifdef DBG_REFCOUNTTOKEN
  96   static int ctor;
  97   static int dtor;
  98 #endif
  99 protected:
 100     unsigned refcnt_;
 101 #ifdef DBG_REFCOUNTTOKEN
 102   char object[200];
 103 #endif
 104
 105 public:
 106   ANTLRRefCountToken(ANTLRTokenType t, const ANTLRChar *s)
 107 #ifndef DBG_REFCOUNTTOKEN
 108     {
 109       refcnt_ = 0;
 110     }
 111 #else
 112   {
 113     ctor++;
 114     refcnt_ = 0;
 115     if ( t==1 ) sprintf(object,"tok_EOF");
 116     else sprintf(object,"tok_%s",s);
 117     fprintf(stderr, "ctor %s #%d\n",object,ctor);
 118   }
 119 #endif
 120   ANTLRRefCountToken()
 121 #ifndef DBG_REFCOUNTTOKEN
 122     { refcnt_ = 0; }
 123 #else
 124     {
 125       ctor++;
 126       refcnt_ = 0;
 127       sprintf(object,"tok_blank");
 128       fprintf(stderr, "ctor %s #%d\n",object,ctor);
 129     }
 130   virtual ~ANTLRRefCountToken()
 131     {
 132       dtor++;
 133       if ( dtor>ctor ) fprintf(stderr, "WARNING: dtor>ctor\n");
 134       fprintf(stderr, "dtor %s #%d\n", object, dtor);
 135       object[0]='\0';
 136     }
 137 #endif
 138
 139   // reference counting stuff needed by ANTLRTokenPtr.
 140   // User should not access these; for C++ language reasons, we had
 141   // to make these public.  Yuck.
 142
 143   void ref()          { refcnt_++; }
 144   void deref()        { refcnt_--; }
 145   unsigned nref()  const { return refcnt_; }   // MR11
 146
 147   virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
 148                       ANTLRChar *txt,
 149                       int line)
 150   {
 151     panic("call to ANTLRRefCountToken::makeToken()\n");
 152     return NULL;
 153   }
 154 };
 155
 156 class ANTLRCommonNoRefCountToken : public ANTLRAbstractToken {
 157 protected:
 158   ANTLRTokenType _type;
 159   int _line;
 160   ANTLRChar *_text;               // MR9 RJV
 161
 162 public:
 163   ANTLRCommonNoRefCountToken(ANTLRTokenType t, const ANTLRChar *s)
 164   { setType(t); _line = 0; _text = NULL; setText(s); }
 165   ANTLRCommonNoRefCountToken()
 166   { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); }
 167
 168   ~ANTLRCommonNoRefCountToken() { if (_text) delete [] _text; }  // MR9 RJV: Added Destructor to remove string
 169
 170   ANTLRTokenType getType() const   { return _type; }
 171   void setType(ANTLRTokenType t)  { _type = t; }
 172   virtual int getLine() const    { return _line; }
 173   void setLine(int line)        { _line = line; }
 174   ANTLRChar *getText() const     { return _text; }
 175     int getLength() const           { return strlen(getText()); }       // MR11
 176
 177 // MR9 RJV: Added code for variable length strings to setText()
 178
 179   void setText(const ANTLRChar *s)
 180   {  if (s != _text) {
 181           if (_text) delete [] _text;
 182           if (s != NULL) {
 183            _text = new ANTLRChar[strlen(s)+1];
 184             if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
 185             strcpy(_text,s);
 186         } else {
 187             _text = new ANTLRChar[1];
 188             if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
 189             strcpy(_text,"");
 190           };
 191         };
 192   }
 193
 194   virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
 195                       ANTLRChar *txt,
 196                       int line)
 197     {
 198       ANTLRAbstractToken *t = new ANTLRCommonNoRefCountToken;
 199       t->setType(tt); t->setText(txt); t->setLine(line);
 200       return t;
 201     }
 202
 203 // MR9 THM Copy constructor required when heap allocated string is used with copy semantics
 204
 205    ANTLRCommonNoRefCountToken (const ANTLRCommonNoRefCountToken& from) :
 206          ANTLRAbstractToken(from) {
 207     setType(from._type);
 208    setLine(from._line);
 209      _text=NULL;
 210      setText(from._text);
 211   };
 212
 213 // MR9 THM operator =() required when heap allocated string is used with copy semantics
 214
 215    virtual ANTLRCommonNoRefCountToken& operator =(const ANTLRCommonNoRefCountToken& rhs) {
 216
 217 //////  MR15 WatCom can't hack use of operator =()
 218 //////  Use this:  *( (ANTRLAbstractToken *) this)=rhs;
 219
 220      *( (ANTLRAbstractToken *) this ) = rhs;
 221
 222      setType(rhs._type);
 223     setLine(rhs._line);
 224      setText(rhs._text);
 225      return *this;
 226    };
 227 };
 228
 229 class ANTLRCommonToken : public ANTLRRefCountToken {
 230 protected:
 231   ANTLRTokenType       _type;
 232   int                  _line;
 233   ANTLRChar           *_text;               // MR9 RJV:Added
 234
 235 public:
 236   ANTLRCommonToken(ANTLRTokenType t, const ANTLRChar *s) : ANTLRRefCountToken(t,s)
 237     { setType(t); _line = 0; _text = NULL; setText(s); }                    // MR9
 238   ANTLRCommonToken()
 239     { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); }   // MR9
 240
 241   virtual ~ANTLRCommonToken() { if (_text) delete [] _text; } // MR9 RJV: Added Destructor to remove string
 242
 243   ANTLRTokenType getType() const   { return _type; }
 244   void setType(ANTLRTokenType t)  { _type = t; }
 245   virtual int getLine() const    { return _line; }
 246   void setLine(int line)        { _line = line; }
 247   ANTLRChar *getText() const    { return _text; }
 248     int getLength() const           { return strlen(getText()); }       // MR11
 249
 250 // MR9 RJV: Added code for variable length strings to setText()
 251
 252   void setText(const ANTLRChar *s)
 253   {  if (s != _text) {
 254           if (_text) delete [] _text;
 255           if (s != NULL) {
 256            _text = new ANTLRChar[strlen(s)+1];
 257             if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
 258             strcpy(_text,s);
 259         } else {
 260             _text = new ANTLRChar[1];
 261             if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
 262             strcpy(_text,"");
 263           };
 264         };
 265   }
 266
 267   virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
 268                       ANTLRChar *txt,
 269                       int line)
 270   {
 271     ANTLRAbstractToken *t = new ANTLRCommonToken(tt,txt);
 272     t->setLine(line);
 273     return t;
 274   }
 275
 276 // MR9 THM Copy constructor required when heap allocated string is used with copy semantics
 277
 278    ANTLRCommonToken (const ANTLRCommonToken& from) :
 279          ANTLRRefCountToken(from) {
 280     setType(from._type);
 281    setLine(from._line);
 282      _text=NULL;
 283      setText(from._text);
 284   };
 285
 286 // MR9 THM operator =() required when heap allocated string is used with copy semantics
 287
 288    virtual ANTLRCommonToken& operator =(const ANTLRCommonToken& rhs) {
 289
 290 //////  MR15 WatCom can't hack use of operator =()
 291 //////  Use this instead:   *( (ANTRLRRefCountToken *) this)=rhs;
 292
 293      *( (ANTLRRefCountToken *) this) = rhs;
 294
 295      setType(rhs._type);
 296     setLine(rhs._line);
 297      setText(rhs._text);
 298      return *this;
 299    };
 300 };
 301
 302 // used for backward compatibility
 303 typedef ANTLRCommonToken ANTLRCommonBacktrackingToken;
 304
 305 #endif