OSX/libsecurity_codesigning/antlr2/antlr/AST.hpp

   1 #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: //depot/code/org.antlr/release/antlr-2.7.7/lib/cpp/antlr/AST.hpp#2 $
   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__