src/antlr/AST.hpp

#ifndef INC_AST_hpp__
#define INC_AST_hpp__

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

#include <antlr/config.hpp>
#include <antlr/ASTRefCount.hpp>
#include <antlr/Token.hpp>
#include <vector>
#include <string>

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

struct ASTRef;

class ANTLR_API AST {
public:
        AST() : ref(0) {}
        AST(const AST&) : ref(0) {}
        virtual ~AST() {}

        /// Return the type name for this AST node. (for XML output)
        virtual const char* typeName( void ) const = 0;
        /// Clone this AST node.
        virtual RefAST clone( void ) const = 0;
   /// Is node t equal to this in terms of token type and text?
        virtual bool equals(RefAST t) const = 0;
   /** Is t an exact structural and equals() match of this tree. The
         * 'this' reference is considered the start of a sibling list.
         */
        virtual bool equalsList(RefAST t) const = 0;

        /** Is 't' a subtree of this list? The siblings of the root are NOT ignored.
    */
        virtual bool equalsListPartial(RefAST t) const = 0;
        /** Is tree rooted at 'this' equal to 't'?  The siblings of 'this' are
         * ignored.
         */
        virtual bool equalsTree(RefAST t) const = 0;
        /** Is 't' a subtree of the tree rooted at 'this'? The siblings of
         * 'this' are ignored.
         */
        virtual bool equalsTreePartial(RefAST t) const = 0;

        /** Walk the tree looking for all exact subtree matches.  Return
         *  a vector of RefAST that lets the caller walk the list
         *  of subtree roots found herein.
         */
        virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAll(RefAST t) = 0;

   /** Walk the tree looking for all subtrees.  Return
    *  a vector of RefAST that lets the caller walk the list
    *  of subtree roots found herein.
    */
        virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAllPartial(RefAST t) = 0;

   /// Add a node to the end of the child list for this node
        virtual void addChild(RefAST c) = 0;
        /// Get the number of children. Returns 0 if the node is a leaf
        virtual size_t getNumberOfChildren() const = 0;

        /// Get the first child of this node; null if no children
        virtual RefAST getFirstChild() const = 0;
        /// Get  the next sibling in line after this one
        virtual RefAST getNextSibling() const = 0;

        /// Get the token text for this node
        virtual ANTLR_USE_NAMESPACE(std)string getText() const = 0;
        /// Get the token type for this node
        virtual int getType() const = 0;

        /** Various initialization routines. Used by several factories to initialize
         * an AST element.
         */
        virtual void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt) = 0;
        virtual void initialize(RefAST t) = 0;
        virtual void initialize(RefToken t) = 0;

#ifdef ANTLR_SUPPORT_XML
        /** initialize this node from the contents of a stream.
         * @param in the stream to read the AST attributes from.
         */
        virtual void initialize( ANTLR_USE_NAMESPACE(std)istream& in ) = 0;
#endif

        /// Set the first child of a node.
        virtual void setFirstChild(RefAST c) = 0;
        /// Set the next sibling after this one.
        virtual void setNextSibling(RefAST n) = 0;

        /// Set the token text for this node
        virtual void setText(const ANTLR_USE_NAMESPACE(std)string& txt) = 0;
        /// Set the token type for this node
        virtual void setType(int type) = 0;

        /// Return this AST node as a string
        virtual ANTLR_USE_NAMESPACE(std)string toString() const = 0;

        /// Print out a child-sibling tree in LISP notation
        virtual ANTLR_USE_NAMESPACE(std)string toStringList() const = 0;
        virtual ANTLR_USE_NAMESPACE(std)string toStringTree() const = 0;

#ifdef ANTLR_SUPPORT_XML
        /** get attributes of this node to 'out'. Override to customize XML
         * output.
         * @param out the stream to write the AST attributes to.
         * @returns if a explicit closetag should be written
         */
        virtual bool attributesToStream( ANTLR_USE_NAMESPACE(std)ostream& out ) const = 0;

        /** Print a symbol over ostream. Overload this one to customize the XML
         * output for AST derived AST-types
         * @param output stream
         */
        virtual void toStream( ANTLR_USE_NAMESPACE(std)ostream &out ) const = 0;

        /** Dump AST contents in XML format to output stream.
         * Works in conjunction with to_stream method. Overload that one is
         * derived classes to customize behaviour.
         * @param output stream to write to string to put the stuff in.
         * @param ast RefAST object to write.
         */
        friend ANTLR_USE_NAMESPACE(std)ostream& operator<<( ANTLR_USE_NAMESPACE(std)ostream& output, const RefAST& ast );
#endif

private:
        friend struct ASTRef;
        ASTRef* ref;

        AST(RefAST other);
        AST& operator=(const AST& other);
        AST& operator=(RefAST other);
};

#ifdef ANTLR_SUPPORT_XML
inline ANTLR_USE_NAMESPACE(std)ostream& operator<<( ANTLR_USE_NAMESPACE(std)ostream& output, const RefAST& ast )
{
        ast->toStream(output);
        return output;
}
#endif

extern ANTLR_API RefAST nullAST;
extern ANTLR_API AST* const nullASTptr;

#ifdef NEEDS_OPERATOR_LESS_THAN
// RK: apparently needed by MSVC and a SUN CC, up to and including
// 2.7.2 this was undefined ?
inline bool operator<( RefAST l, RefAST r )
{
        return nullAST == l ? ( nullAST == r ? false : true ) : l->getType() < r->getType();
}
#endif

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif

#endif //INC_AST_hpp__
Revision:	770
Committed:	Fri Dec 2 15:38:03 2005 UTC (19 years, 11 months ago) by tim
Original Path:	*trunk/src/antlr/AST.hpp*
File size:	5289 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_AST_hpp__
2			#define INC_AST_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: AST.hpp,v 1.1 2005-12-02 15:38:02 tim Exp $
9			*/
10
11			#include <antlr/config.hpp>
12			#include <antlr/ASTRefCount.hpp>
13			#include <antlr/Token.hpp>
14			#include <vector>
15			#include <string>
16
17			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
18			namespace antlr {
19			#endif
20
21			struct ASTRef;
22
23			class ANTLR_API AST {
24			public:
25			AST() : ref(0) {}
26			AST(const AST&) : ref(0) {}
27			virtual ~AST() {}
28
29			/// Return the type name for this AST node. (for XML output)
30			virtual const char* typeName( void ) const = 0;
31			/// Clone this AST node.
32			virtual RefAST clone( void ) const = 0;
33			/// Is node t equal to this in terms of token type and text?
34			virtual bool equals(RefAST t) const = 0;
35			/** Is t an exact structural and equals() match of this tree. The
36			* 'this' reference is considered the start of a sibling list.
37			*/
38			virtual bool equalsList(RefAST t) const = 0;
39
40			/** Is 't' a subtree of this list? The siblings of the root are NOT ignored.
41			*/
42			virtual bool equalsListPartial(RefAST t) const = 0;
43			/** Is tree rooted at 'this' equal to 't'? The siblings of 'this' are
44			* ignored.
45			*/
46			virtual bool equalsTree(RefAST t) const = 0;
47			/** Is 't' a subtree of the tree rooted at 'this'? The siblings of
48			* 'this' are ignored.
49			*/
50			virtual bool equalsTreePartial(RefAST t) const = 0;
51
52			/** Walk the tree looking for all exact subtree matches. Return
53			* a vector of RefAST that lets the caller walk the list
54			* of subtree roots found herein.
55			*/
56			virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAll(RefAST t) = 0;
57
58			/** Walk the tree looking for all subtrees. Return
59			* a vector of RefAST that lets the caller walk the list
60			* of subtree roots found herein.
61			*/
62			virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAllPartial(RefAST t) = 0;
63
64			/// Add a node to the end of the child list for this node
65			virtual void addChild(RefAST c) = 0;
66			/// Get the number of children. Returns 0 if the node is a leaf
67			virtual size_t getNumberOfChildren() const = 0;
68
69			/// Get the first child of this node; null if no children
70			virtual RefAST getFirstChild() const = 0;
71			/// Get the next sibling in line after this one
72			virtual RefAST getNextSibling() const = 0;
73
74			/// Get the token text for this node
75			virtual ANTLR_USE_NAMESPACE(std)string getText() const = 0;
76			/// Get the token type for this node
77			virtual int getType() const = 0;
78
79			/** Various initialization routines. Used by several factories to initialize
80			* an AST element.
81			*/
82			virtual void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt) = 0;
83			virtual void initialize(RefAST t) = 0;
84			virtual void initialize(RefToken t) = 0;
85
86			#ifdef ANTLR_SUPPORT_XML
87			/** initialize this node from the contents of a stream.
88			* @param in the stream to read the AST attributes from.
89			*/
90			virtual void initialize( ANTLR_USE_NAMESPACE(std)istream& in ) = 0;
91			#endif
92
93			/// Set the first child of a node.
94			virtual void setFirstChild(RefAST c) = 0;
95			/// Set the next sibling after this one.
96			virtual void setNextSibling(RefAST n) = 0;
97
98			/// Set the token text for this node
99			virtual void setText(const ANTLR_USE_NAMESPACE(std)string& txt) = 0;
100			/// Set the token type for this node
101			virtual void setType(int type) = 0;
102
103			/// Return this AST node as a string
104			virtual ANTLR_USE_NAMESPACE(std)string toString() const = 0;
105
106			/// Print out a child-sibling tree in LISP notation
107			virtual ANTLR_USE_NAMESPACE(std)string toStringList() const = 0;
108			virtual ANTLR_USE_NAMESPACE(std)string toStringTree() const = 0;
109
110			#ifdef ANTLR_SUPPORT_XML
111			/** get attributes of this node to 'out'. Override to customize XML
112			* output.
113			* @param out the stream to write the AST attributes to.
114			* @returns if a explicit closetag should be written
115			*/
116			virtual bool attributesToStream( ANTLR_USE_NAMESPACE(std)ostream& out ) const = 0;
117
118			/** Print a symbol over ostream. Overload this one to customize the XML
119			* output for AST derived AST-types
120			* @param output stream
121			*/
122			virtual void toStream( ANTLR_USE_NAMESPACE(std)ostream &out ) const = 0;
123
124			/** Dump AST contents in XML format to output stream.
125			* Works in conjunction with to_stream method. Overload that one is
126			* derived classes to customize behaviour.
127			* @param output stream to write to string to put the stuff in.
128			* @param ast RefAST object to write.
129			*/
130			friend ANTLR_USE_NAMESPACE(std)ostream& operator<<( ANTLR_USE_NAMESPACE(std)ostream& output, const RefAST& ast );
131			#endif
132
133			private:
134			friend struct ASTRef;
135			ASTRef* ref;
136
137			AST(RefAST other);
138			AST& operator=(const AST& other);
139			AST& operator=(RefAST other);
140			};
141
142			#ifdef ANTLR_SUPPORT_XML
143			inline ANTLR_USE_NAMESPACE(std)ostream& operator<<( ANTLR_USE_NAMESPACE(std)ostream& output, const RefAST& ast )
144			{
145			ast->toStream(output);
146			return output;
147			}
148			#endif
149
150			extern ANTLR_API RefAST nullAST;
151			extern ANTLR_API AST* const nullASTptr;
152
153			#ifdef NEEDS_OPERATOR_LESS_THAN
154			// RK: apparently needed by MSVC and a SUN CC, up to and including
155			// 2.7.2 this was undefined ?
156			inline bool operator<( RefAST l, RefAST r )
157			{
158			return nullAST == l ? ( nullAST == r ? false : true ) : l->getType() < r->getType();
159			}
160			#endif
161
162			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
163			}
164			#endif
165
166			#endif //INC_AST_hpp__