lsys/antlr/DLexerBase.h

/* DLGLexerBase.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 DLGX_H
#define DLGX_H

#include "pcctscfg.h"
#include "pccts_stdio.h"

PCCTS_NAMESPACE_STD

#include ATOKEN_H
#include ATOKENSTREAM_H

class ANTLRParser;                                                      // MR1

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

/*  Can have it as a class too: (ack this looks weird; is it right?)
class DllExportPCCTS DLGChar {
private:
        int c;
public:
        DLGChar(int ch) { c = ch; }
        int atom() { return c; }
};
*/

/* user must subclass this */
class DllExportPCCTS DLGInputStream {
public:
        virtual int nextChar() = 0;
};

/* Predefined char stream: Input from FILE */
class DllExportPCCTS DLGFileInput : public DLGInputStream {
private:
        int found_eof;
        FILE *input;
public:
        DLGFileInput(FILE *f) { input = f; found_eof = 0; }
        int nextChar() {
                        int c;
                        if ( found_eof ) return EOF;
                        else {
                                c=getc(input);
                                if ( c==EOF ) found_eof = 1;
                                return c;
                        }
        }
    void DLGFileReset(FILE *f) {input=f; found_eof = 0; };              // MR11
};

// MR9  Suggested by Bruce Guenter (bruceg@qcc.sk.ca)
// MR9  Make DLGStringInput const correct

/* Predefined char stream: Input from string */
class DllExportPCCTS DLGStringInput : public DLGInputStream {
private:
        const DLGChar *input;                                           // MR9
        const DLGChar *p;                                               // MR9
public:
        DLGStringInput(const DLGChar *s) { input = s; p = &input[0];}   // MR9
        int nextChar()
                {
                        if (*p) return (int) (unsigned char) *p++;              // MR14
                        else return EOF;
                }

    void DLGStringReset(const DLGChar *s) {input=s; p= &input[0]; }; // MR11 // MR16
};

class DllExportPCCTS DLGState {
public:
        DLGInputStream *input;
        int interactive;
        int track_columns;
        int auto_num;
        int add_erase;
        int lookc;
        int char_full;
        int begcol, endcol;
        int line;
        DLGChar *lextext, *begexpr, *endexpr;
        int bufsize;
        int bufovf;
        DLGChar *nextpos;
        int     class_num;
        int     debugLexerFlag;                                         // MR1
        ANTLRParser *parser;                                            // MR1
};

/* user must subclass this */
class DllExportPCCTS DLGLexerBase : public ANTLRTokenStream {
public:
        virtual ANTLRTokenType erraction();

protected:
        DLGInputStream *input;
        int interactive;
        int track_columns;
        DLGChar *_lextext;      /* text of most recently matched token */
        DLGChar *_begexpr;      /* beginning of last reg expr recogn. */
        DLGChar *_endexpr;      /* beginning of last reg expr recogn. */
        int     _bufsize;               /* number of characters in lextext */
        int     _begcol;                /* column that first character of token is in*/
        int     _endcol;                /* column that last character of token is in */
        int     _line;                  /* line current token is on */
        int     ch;                             /* character to determine next state */
        int     bufovf;                 /* indicates that buffer too small for text */
        int     charfull;
        DLGChar *nextpos;       /* points to next available position in lextext*/
        int     cl;
        int automaton;
        int     add_erase;
        DLGChar ebuf[70];
        _ANTLRTokenPtr token_to_fill;

        int     debugLexerFlag;                                         // MR1
        ANTLRParser     *parser;                                        // MR1
public:
        virtual _ANTLRTokenPtr getToken();      // MR12 public
        virtual void advance(void) = 0;
        void    skip(void);             /* erase lextext, look for antoher token */
        void    more(void);             /* keep lextext, look for another token */
        void    mode(int k);    /* switch to automaton 'k' */
        void    saveState(DLGState *);
        void    restoreState(DLGState *);
        virtual ANTLRTokenType nextTokenType(void)=0;/* get next token */
        void    replchar(DLGChar c);    /* replace last recognized reg. expr. with
                                                                         a character */
        void    replstr(const DLGChar *s);      /* replace last recognized reg. expr. with
                                                                         a string */ /* MR20 const */
        virtual int err_in();                                           // MR1
        virtual void errstd(const char *);                              // MR1  MR20 const
        int             line()          { return _line; }
        void    set_line(int newValue)  { _line=newValue; };            // MR1
        virtual void newline()  { _line++; }
        DLGChar *lextext()      { return _lextext; }

        int             begcol()        { return _begcol; }
        int             endcol()        { return _endcol; }
        void    set_begcol(int a)       { _begcol=a; }
        void    set_endcol(int a)       { _endcol=a; }
        DLGChar *begexpr()      { return _begexpr; }
        DLGChar *endexpr()      { return _endexpr; }
        int             bufsize()       { return _bufsize; }

        void    setToken(ANTLRAbstractToken *t) { token_to_fill = t; }

        void    setInputStream(DLGInputStream *);
        DLGLexerBase(DLGInputStream *in,
                                 unsigned bufsize=2000,
                                 int interactive=0,
                                 int track_columns=0);
        void reset();                                                                   // MR19
        virtual ~DLGLexerBase() { delete [] _lextext; }
        virtual void panic(const char *msg);                    // MR1  MR20 const
        void    trackColumns() {
                                track_columns = 1;
                                this->_begcol = 0;
                                this->_endcol = 0;
                        };
        virtual ANTLRParser *setParser(ANTLRParser *p);                 // MR1
        virtual ANTLRParser *getParser();                               // MR1
        virtual int debugLexer(int value);                              // MR1
    int     lexErrCount;                            // MR12
        virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
};

#endif
Revision:	1.1
Committed:	Thu Nov 6 14:31:25 2008 UTC (17 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	Content
1	/* DLGLexerBase.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 DLGX_H
31	#define DLGX_H
32
33	#include "pcctscfg.h"
34	#include "pccts_stdio.h"
35
36	PCCTS_NAMESPACE_STD
37
38	#include ATOKEN_H
39	#include ATOKENSTREAM_H
40
41	class ANTLRParser; // MR1
42
43	/* must define what a char looks like; can make this a class too */
44	typedef char DLGChar;
45
46	/* Can have it as a class too: (ack this looks weird; is it right?)
47	class DllExportPCCTS DLGChar {
48	private:
49	int c;
50	public:
51	DLGChar(int ch) { c = ch; }
52	int atom() { return c; }
53	};
54	*/
55
56	/* user must subclass this */
57	class DllExportPCCTS DLGInputStream {
58	public:
59	virtual int nextChar() = 0;
60	};
61
62	/* Predefined char stream: Input from FILE */
63	class DllExportPCCTS DLGFileInput : public DLGInputStream {
64	private:
65	int found_eof;
66	FILE *input;
67	public:
68	DLGFileInput(FILE *f) { input = f; found_eof = 0; }
69	int nextChar() {
70	int c;
71	if ( found_eof ) return EOF;
72	else {
73	c=getc(input);
74	if ( c==EOF ) found_eof = 1;
75	return c;
76	}
77	}
78	void DLGFileReset(FILE *f) {input=f; found_eof = 0; }; // MR11
79	};
80
81	// MR9 Suggested by Bruce Guenter (bruceg@qcc.sk.ca)
82	// MR9 Make DLGStringInput const correct
83
84	/* Predefined char stream: Input from string */
85	class DllExportPCCTS DLGStringInput : public DLGInputStream {
86	private:
87	const DLGChar *input; // MR9
88	const DLGChar *p; // MR9
89	public:
90	DLGStringInput(const DLGChar *s) { input = s; p = &input[0];} // MR9
91	int nextChar()
92	{
93	if (p) return (int) (unsigned char) p++; // MR14
94	else return EOF;
95	}
96
97	void DLGStringReset(const DLGChar *s) {input=s; p= &input[0]; }; // MR11 // MR16
98	};
99
100	class DllExportPCCTS DLGState {
101	public:
102	DLGInputStream *input;
103	int interactive;
104	int track_columns;
105	int auto_num;
106	int add_erase;
107	int lookc;
108	int char_full;
109	int begcol, endcol;
110	int line;
111	DLGChar lextext, begexpr, *endexpr;
112	int bufsize;
113	int bufovf;
114	DLGChar *nextpos;
115	int class_num;
116	int debugLexerFlag; // MR1
117	ANTLRParser *parser; // MR1
118	};
119
120	/* user must subclass this */
121	class DllExportPCCTS DLGLexerBase : public ANTLRTokenStream {
122	public:
123	virtual ANTLRTokenType erraction();
124
125	protected:
126	DLGInputStream *input;
127	int interactive;
128	int track_columns;
129	DLGChar _lextext; / text of most recently matched token */
130	DLGChar _begexpr; / beginning of last reg expr recogn. */
131	DLGChar _endexpr; / beginning of last reg expr recogn. */
132	int _bufsize; /* number of characters in lextext */
133	int _begcol; /* column that first character of token is in*/
134	int _endcol; /* column that last character of token is in */
135	int _line; /* line current token is on */
136	int ch; /* character to determine next state */
137	int bufovf; /* indicates that buffer too small for text */
138	int charfull;
139	DLGChar nextpos; / points to next available position in lextext*/
140	int cl;
141	int automaton;
142	int add_erase;
143	DLGChar ebuf[70];
144	_ANTLRTokenPtr token_to_fill;
145
146	int debugLexerFlag; // MR1
147	ANTLRParser *parser; // MR1
148	public:
149	virtual _ANTLRTokenPtr getToken(); // MR12 public
150	virtual void advance(void) = 0;
151	void skip(void); /* erase lextext, look for antoher token */
152	void more(void); /* keep lextext, look for another token */
153	void mode(int k); /* switch to automaton 'k' */
154	void saveState(DLGState *);
155	void restoreState(DLGState *);
156	virtual ANTLRTokenType nextTokenType(void)=0;/* get next token */
157	void replchar(DLGChar c); /* replace last recognized reg. expr. with
158	a character */
159	void replstr(const DLGChar s); / replace last recognized reg. expr. with
160	a string / / MR20 const */
161	virtual int err_in(); // MR1
162	virtual void errstd(const char *); // MR1 MR20 const
163	int line() { return _line; }
164	void set_line(int newValue) { _line=newValue; }; // MR1
165	virtual void newline() { _line++; }
166	DLGChar *lextext() { return _lextext; }
167
168	int begcol() { return _begcol; }
169	int endcol() { return _endcol; }
170	void set_begcol(int a) { _begcol=a; }
171	void set_endcol(int a) { _endcol=a; }
172	DLGChar *begexpr() { return _begexpr; }
173	DLGChar *endexpr() { return _endexpr; }
174	int bufsize() { return _bufsize; }
175
176	void setToken(ANTLRAbstractToken *t) { token_to_fill = t; }
177
178	void setInputStream(DLGInputStream *);
179	DLGLexerBase(DLGInputStream *in,
180	unsigned bufsize=2000,
181	int interactive=0,
182	int track_columns=0);
183	void reset(); // MR19
184	virtual ~DLGLexerBase() { delete [] _lextext; }
185	virtual void panic(const char *msg); // MR1 MR20 const
186	void trackColumns() {
187	track_columns = 1;
188	this->_begcol = 0;
189	this->_endcol = 0;
190	};
191	virtual ANTLRParser setParser(ANTLRParser p); // MR1
192	virtual ANTLRParser *getParser(); // MR1
193	virtual int debugLexer(int value); // MR1
194	int lexErrCount; // MR12
195	virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
196	};
197
198	#endif