lsys/antlr/AToken.h

/* ANTLRToken.h
 *
 * SOFTWARE RIGHTS
 *
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
 * company may do whatever they wish with source code distributed with
 * PCCTS or the code generated by PCCTS, including the incorporation of
 * PCCTS, or its output, into commerical software.
 *
 * We encourage users to develop software with PCCTS.  However, we do ask
 * that credit is given to us for developing PCCTS.  By "credit",
 * we mean that if you incorporate our source code into one of your
 * programs (commercial product, research project, or otherwise) that you
 * acknowledge this fact somewhere in the documentation, research report,
 * etc...  If you like PCCTS and have developed a nice tool with the
 * output, please mention that you developed it using PCCTS.  In
 * addition, we ask that this header remain intact in our source code.
 * As long as these guidelines are kept, we expect to continue enhancing
 * this system and expect to make other tools available as they are
 * completed.
 *
 * ANTLR 1.33
 * Terence Parr
 * Parr Research Corporation
 * with Purdue University and AHPCRC, University of Minnesota
 * 1989-2000
 */

#ifndef ATOKEN_H_GATE
#define ATOKEN_H_GATE

#include "pcctscfg.h"

#include "pccts_string.h"
#include "pccts_stdio.h"
#include "pccts_stdlib.h"
#include "pccts_stdarg.h" // MR23

PCCTS_NAMESPACE_STD

// MR9      RJV (JVincent@novell.com) Not needed for variable length strings

//// MR9 #ifndef ANTLRCommonTokenTEXTSIZE
//// MR9 #define ANTLRCommonTokenTEXTSIZE               100
//// MR9 #endif


/* must define what a char looks like; can make this a class too */
typedef char ANTLRChar;

/* D E F I N E  S M A R T  P O I N T E R S */

//#include ATOKPTR_H   not tested yet, leave out
class ANTLRAbstractToken;
typedef ANTLRAbstractToken *_ANTLRTokenPtr;

class ANTLRAbstractToken {
public:
    virtual ~ANTLRAbstractToken() {;}
    virtual ANTLRTokenType getType() const = 0;
    virtual void setType(ANTLRTokenType t) = 0;
    virtual int getLine() const = 0;
    virtual void setLine(int line) = 0;
    virtual ANTLRChar *getText() const = 0;
    virtual void setText(const ANTLRChar *) = 0;

    /* This function will disappear when I can use templates */
        virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
                                                                                  ANTLRChar *text,
                                                                                  int line) = 0;

        /* define to satisfy ANTLRTokenBuffer's need to determine whether or
           not a token object can be destroyed.  If nref()==0, no one has
           a reference, and the object may be destroyed.  This function defaults
           to 1, hence, if you use deleteTokens() message with a token object
           not derived from ANTLRCommonRefCountToken, the parser will compile
           but will not delete objects after they leave the token buffer.
    */

        virtual unsigned nref() const { return 1; }     // MR11
        virtual void ref() {;}
        virtual void deref() {;}

        virtual void panic(const char *msg)             // MR20 const
                {
                        /* MR23 */ printMessage(stderr, "ANTLRAbstractToken panic: %s\n", msg);
                        exit(PCCTS_EXIT_FAILURE);
                }

        virtual int printMessage(FILE* pFile, const char* pFormat, ...) // MR23
                {
                        va_list marker;
                        va_start( marker, pFormat );
                        int iRet = vfprintf(pFile, pFormat, marker);
                        va_end( marker );
                        return iRet;
                }
};

/* This class should be subclassed.  It cannot store token type or text */

class ANTLRRefCountToken : public ANTLRAbstractToken {
public:
#ifdef DBG_REFCOUNTTOKEN
        static int ctor;
        static int dtor;
#endif
protected:
    unsigned refcnt_;
#ifdef DBG_REFCOUNTTOKEN
        char object[200];
#endif

public:

        // MR23 - No matter what you do, you're hammered.
        //        Don't give names to formals something breaks.
        //                Give names to formals and don't use them it breaks.

#ifndef DBG_REFCOUNTTOKEN
        ANTLRRefCountToken(ANTLRTokenType /* t MR23 */, const ANTLRChar * /* s MR23 */)
#else
        ANTLRRefCountToken(ANTLRTokenType t, const ANTLRChar * s)
#endif

#ifndef DBG_REFCOUNTTOKEN
                {
                        refcnt_ = 0;
                }
#else
        {
                ctor++;
                refcnt_ = 0;
                if ( t==1 ) sprintf(object,"tok_EOF");
                else sprintf(object,"tok_%s",s);
                /* MR23 */ printMessage(stderr, "ctor %s #%d\n",object,ctor);
        }
#endif
        ANTLRRefCountToken()
#ifndef DBG_REFCOUNTTOKEN
                { refcnt_ = 0; }
#else
                {
                        ctor++;
                        refcnt_ = 0;
                        sprintf(object,"tok_blank");
                        /* MR23 */ printMessage(stderr, "ctor %s #%d\n",object,ctor);
                }
        virtual ~ANTLRRefCountToken()
                {
                        dtor++;
                        if ( dtor>ctor ) /* MR23 */ printMessage(stderr, "WARNING: dtor>ctor\n");
                        /* MR23 */ printMessage(stderr, "dtor %s #%d\n", object, dtor);
                        object[0]='\0';
                }
#endif

        // reference counting stuff needed by ANTLRTokenPtr.
        // User should not access these; for C++ language reasons, we had
        // to make these public.  Yuck.

        void ref()                    { refcnt_++; }
        void deref()          { refcnt_--; }
        unsigned nref() const { return refcnt_; }   // MR11

        virtual ANTLRAbstractToken *makeToken(ANTLRTokenType /*tt MR23*/,
                                                                                  ANTLRChar * /*txt MR23*/,
                                                                                  int /*line MR23*/)
        {
                panic("call to ANTLRRefCountToken::makeToken()\n");
                return NULL;
        }
};

class ANTLRCommonNoRefCountToken : public ANTLRAbstractToken {
protected:
        ANTLRTokenType _type;
        int _line;
        ANTLRChar *_text;               // MR9 RJV

public:
        ANTLRCommonNoRefCountToken(ANTLRTokenType t, const ANTLRChar *s)
        { setType(t); _line = 0; _text = NULL; setText(s); }
        ANTLRCommonNoRefCountToken()
        { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); }

        ~ANTLRCommonNoRefCountToken() { if (_text) delete [] _text; }  // MR9 RJV: Added Destructor to remove string

        ANTLRTokenType getType() const  { return _type; }
        void setType(ANTLRTokenType t)  { _type = t; }
        virtual int getLine() const             { return _line; }
        void setLine(int line)          { _line = line; }
        ANTLRChar *getText() const      { return _text; }
    int getLength() const           { return strlen(getText()); }       // MR11

// MR9 RJV: Added code for variable length strings to setText()

        void setText(const ANTLRChar *s)
        {       if (s != _text) {
          if (_text) delete [] _text;
          if (s != NULL) {
                _text = new ANTLRChar[strlen(s)+1];
            if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
            strcpy(_text,s);
          } else {
            _text = new ANTLRChar[1];
            if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
            strcpy(_text,"");
          };
        };
        }

        virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
                                                                                  ANTLRChar *txt,
                                                                                  int line)
                {
                        ANTLRAbstractToken *t = new ANTLRCommonNoRefCountToken;
                        t->setType(tt); t->setText(txt); t->setLine(line);
                        return t;
                }

// MR9 THM Copy constructor required when heap allocated string is used with copy semantics

   ANTLRCommonNoRefCountToken (const ANTLRCommonNoRefCountToken& from) :
         ANTLRAbstractToken(from) {
         setType(from._type);
         setLine(from._line);
     _text=NULL;
     setText(from._text);
  };

// MR9 THM operator =() required when heap allocated string is used with copy semantics

   virtual ANTLRCommonNoRefCountToken& operator =(const ANTLRCommonNoRefCountToken& rhs) {

//////  MR15 WatCom can't hack use of operator =()
//////  Use this:  *( (ANTRLAbstractToken *) this)=rhs;

     *( (ANTLRAbstractToken *) this ) = rhs;

         setType(rhs._type);
         setLine(rhs._line);
     setText(rhs._text);
     return *this;
   };
};

class ANTLRCommonToken : public ANTLRRefCountToken {
protected:
        ANTLRTokenType       _type;
        int                  _line;
        ANTLRChar           *_text;               // MR9 RJV:Added

public:
        ANTLRCommonToken(ANTLRTokenType t, const ANTLRChar *s) : ANTLRRefCountToken(t,s)
                { setType(t); _line = 0; _text = NULL; setText(s); }                    // MR9
        ANTLRCommonToken()
                { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); }   // MR9

        virtual ~ANTLRCommonToken() { if (_text) delete [] _text; } // MR9 RJV: Added Destructor to remove string

        ANTLRTokenType getType() const  { return _type; }
        void setType(ANTLRTokenType t)  { _type = t; }
        virtual int getLine() const             { return _line; }
        void setLine(int line)          { _line = line; }
        ANTLRChar *getText() const              { return _text; }
    int getLength() const           { return strlen(getText()); }       // MR11

// MR9 RJV: Added code for variable length strings to setText()

        void setText(const ANTLRChar *s)
        {       if (s != _text) {
          if (_text) delete [] _text;
          if (s != NULL) {
                _text = new ANTLRChar[strlen(s)+1];
            if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
            strcpy(_text,s);
          } else {
            _text = new ANTLRChar[1];
            if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
            strcpy(_text,"");
          };
        };
        }

        virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
                                                                                  ANTLRChar *txt,
                                                                                  int line)
        {
                ANTLRAbstractToken *t = new ANTLRCommonToken(tt,txt);
                t->setLine(line);
                return t;
        }

// MR9 THM Copy constructor required when heap allocated string is used with copy semantics

   ANTLRCommonToken (const ANTLRCommonToken& from) :
         ANTLRRefCountToken(from) {
         setType(from._type);
         setLine(from._line);
     _text=NULL;
     setText(from._text);
  };

// MR9 THM operator =() required when heap allocated string is used with copy semantics

   virtual ANTLRCommonToken& operator =(const ANTLRCommonToken& rhs) {

//////  MR15 WatCom can't hack use of operator =()
//////  Use this instead:   *( (ANTRLRRefCountToken *) this)=rhs;

     *( (ANTLRRefCountToken *) this) = rhs;

         setType(rhs._type);
         setLine(rhs._line);
     setText(rhs._text);
     return *this;
   };
};

// used for backward compatibility
typedef ANTLRCommonToken ANTLRCommonBacktrackingToken;

#endif
Revision:	1.1
Committed:	Thu Nov 6 14:31:25 2008 UTC (15 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.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@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