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