src/antlr/LexerSharedInputState.hpp

#ifndef INC_LexerSharedInputState_hpp__
#define INC_LexerSharedInputState_hpp__

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: LexerSharedInputState.hpp,v 1.1 2005-12-02 15:38:02 tim Exp $
 */

#include <antlr/config.hpp>
#include <antlr/InputBuffer.hpp>
#include <antlr/RefCount.hpp>
#include <antlr/CharBuffer.hpp>
#include <string>

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

/** This object contains the data associated with an
 *  input stream of characters.  Multiple lexers
 *  share a single LexerSharedInputState to lex
 *  the same input stream.
 */
class ANTLR_API LexerInputState {
public:
        /** Construct a new LexerInputState
         * @param inbuf the InputBuffer to read from. The object is deleted together
         * with the LexerInputState object.
         */
        LexerInputState(InputBuffer* inbuf)
        : column(1)
        , line(1)
        , tokenStartColumn(1)
        , tokenStartLine(1)
        , guessing(0)
        , filename("")
        , input(inbuf)
        , inputResponsible(true)
        {
        }

        /** Construct a new LexerInputState
         * @param inbuf the InputBuffer to read from.
         */
        LexerInputState(InputBuffer& inbuf)
        : column(1)
        , line(1)
        , tokenStartColumn(1)
        , tokenStartLine(1)
        , guessing(0)
        , filename("")
        , input(&inbuf)
        , inputResponsible(false)
        {
        }

        /** Construct a new LexerInputState
         * @param in an istream to read from.
         * @see antlr.CharBuffer
         */
        LexerInputState(ANTLR_USE_NAMESPACE(std)istream& in)
        : column(1)
        , line(1)
        , tokenStartColumn(1)
        , tokenStartLine(1)
        , guessing(0)
        , filename("")
        , input(new CharBuffer(in))
        , inputResponsible(true)
        {
        }

        /** Reset the LexerInputState with a specified stream and filename.
         * This method is a hack, dunno what I was thinking when I added it.
         * This should actually be done in a subclass.
         * @deprecated
         */
        virtual void initialize( ANTLR_USE_NAMESPACE(std)istream& in, const char* file = "" )
        {
                column = 1;
                line = 1;
                tokenStartColumn = 1;
                tokenStartLine = 1;
                guessing = 0;
                filename = file;

                if( input && inputResponsible )
                        delete input;

                input = new CharBuffer(in);
                inputResponsible = true;
        }

        /** Reset the LexerInputState to initial state.
         * The underlying InputBuffer is also reset.
         */
        virtual void reset( void )
        {
                column = 1;
                line = 1;
                tokenStartColumn = 1;
                tokenStartLine = 1;
                guessing = 0;
                input->reset();
        }

        /** Set the file position of the SharedLexerInputState.
         * @param line_ line number to be set
         * @param column_ column number to be set
         */
        void setPosition( int line_, int column_ )
        {
                line = line_;
                column = column_;
        }

        virtual ~LexerInputState()
        {
                if (inputResponsible)
                        delete input;
        }

        int column;
        int line;
        int tokenStartColumn;
        int tokenStartLine;
        int guessing;
        /** What file (if known) caused the problem? */
        ANTLR_USE_NAMESPACE(std)string filename;
        InputBuffer& getInput();
private:
        /// Input buffer we use
        InputBuffer* input;
        /// Who is responsible for cleaning up the InputBuffer?
        bool inputResponsible;

        // we don't want these:
        LexerInputState(const LexerInputState&);
        LexerInputState& operator=(const LexerInputState&);
};

inline InputBuffer& LexerInputState::getInput()
{
        return *input;
}

/// A reference counted LexerInputState object
typedef RefCount<LexerInputState> LexerSharedInputState;

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif

#endif //INC_LexerSharedInputState_hpp__
Revision:	770
Committed:	Fri Dec 2 15:38:03 2005 UTC (19 years, 11 months ago) by tim
Original Path:	*trunk/src/antlr/LexerSharedInputState.hpp*
File size:	3454 byte(s)
Log Message:	End of the Link --> List Return of the Oject-Oriented replace yacc/lex parser with antlr parser
#	User	Rev	Content
1	tim	770	#ifndef INC_LexerSharedInputState_hpp__
2			#define INC_LexerSharedInputState_hpp__
3
4			/* ANTLR Translator Generator
5			* Project led by Terence Parr at http://www.jGuru.com
6			* Software rights: http://www.antlr.org/license.html
7			*
8			* $Id: LexerSharedInputState.hpp,v 1.1 2005-12-02 15:38:02 tim Exp $
9			*/
10
11			#include <antlr/config.hpp>
12			#include <antlr/InputBuffer.hpp>
13			#include <antlr/RefCount.hpp>
14			#include <antlr/CharBuffer.hpp>
15			#include <string>
16
17			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
18			namespace antlr {
19			#endif
20
21			/** This object contains the data associated with an
22			* input stream of characters. Multiple lexers
23			* share a single LexerSharedInputState to lex
24			* the same input stream.
25			*/
26			class ANTLR_API LexerInputState {
27			public:
28			/** Construct a new LexerInputState
29			* @param inbuf the InputBuffer to read from. The object is deleted together
30			* with the LexerInputState object.
31			*/
32			LexerInputState(InputBuffer* inbuf)
33			: column(1)
34			, line(1)
35			, tokenStartColumn(1)
36			, tokenStartLine(1)
37			, guessing(0)
38			, filename("")
39			, input(inbuf)
40			, inputResponsible(true)
41			{
42			}
43
44			/** Construct a new LexerInputState
45			* @param inbuf the InputBuffer to read from.
46			*/
47			LexerInputState(InputBuffer& inbuf)
48			: column(1)
49			, line(1)
50			, tokenStartColumn(1)
51			, tokenStartLine(1)
52			, guessing(0)
53			, filename("")
54			, input(&inbuf)
55			, inputResponsible(false)
56			{
57			}
58
59			/** Construct a new LexerInputState
60			* @param in an istream to read from.
61			* @see antlr.CharBuffer
62			*/
63			LexerInputState(ANTLR_USE_NAMESPACE(std)istream& in)
64			: column(1)
65			, line(1)
66			, tokenStartColumn(1)
67			, tokenStartLine(1)
68			, guessing(0)
69			, filename("")
70			, input(new CharBuffer(in))
71			, inputResponsible(true)
72			{
73			}
74
75			/** Reset the LexerInputState with a specified stream and filename.
76			* This method is a hack, dunno what I was thinking when I added it.
77			* This should actually be done in a subclass.
78			* @deprecated
79			*/
80			virtual void initialize( ANTLR_USE_NAMESPACE(std)istream& in, const char* file = "" )
81			{
82			column = 1;
83			line = 1;
84			tokenStartColumn = 1;
85			tokenStartLine = 1;
86			guessing = 0;
87			filename = file;
88
89			if( input && inputResponsible )
90			delete input;
91
92			input = new CharBuffer(in);
93			inputResponsible = true;
94			}
95
96			/** Reset the LexerInputState to initial state.
97			* The underlying InputBuffer is also reset.
98			*/
99			virtual void reset( void )
100			{
101			column = 1;
102			line = 1;
103			tokenStartColumn = 1;
104			tokenStartLine = 1;
105			guessing = 0;
106			input->reset();
107			}
108
109			/** Set the file position of the SharedLexerInputState.
110			* @param line_ line number to be set
111			* @param column_ column number to be set
112			*/
113			void setPosition( int line_, int column_ )
114			{
115			line = line_;
116			column = column_;
117			}
118
119			virtual ~LexerInputState()
120			{
121			if (inputResponsible)
122			delete input;
123			}
124
125			int column;
126			int line;
127			int tokenStartColumn;
128			int tokenStartLine;
129			int guessing;
130			/** What file (if known) caused the problem? */
131			ANTLR_USE_NAMESPACE(std)string filename;
132			InputBuffer& getInput();
133			private:
134			/// Input buffer we use
135			InputBuffer* input;
136			/// Who is responsible for cleaning up the InputBuffer?
137			bool inputResponsible;
138
139			// we don't want these:
140			LexerInputState(const LexerInputState&);
141			LexerInputState& operator=(const LexerInputState&);
142			};
143
144			inline InputBuffer& LexerInputState::getInput()
145			{
146			return *input;
147			}
148
149			/// A reference counted LexerInputState object
150			typedef RefCount<LexerInputState> LexerSharedInputState;
151
152			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
153			}
154			#endif
155
156			#endif //INC_LexerSharedInputState_hpp__