BaseAST.hpp

Go to the documentation of this file.

#ifndef INC_BaseAST_hpp__
#define INC_BaseAST_hpp__
 
/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: //depot/code/org.antlr/release/antlr-2.7.7/lib/cpp/antlr/BaseAST.hpp#2 $
 */
 
#include <antlr/config.hpp>
#include <antlr/AST.hpp>
 
#include <iostream>
 
#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif
 
class ANTLR_API BaseAST;
typedef ASTRefCount<BaseAST> RefBaseAST;
 
class ANTLR_API BaseAST : public AST {
public:
   BaseAST() : AST()
   {
   }
   BaseAST(const BaseAST& other)
   : AST(other)
   {
   }
   virtual ~BaseAST()
   {
   }

   virtual const char* typeName( void ) const = 0;

   virtual RefAST clone( void ) const = 0;

   virtual bool equals(RefAST t) const;

   virtual bool equalsList(RefAST t) const;

   virtual bool equalsListPartial(RefAST t) const;

   virtual bool equalsTree(RefAST t) const;

   virtual bool equalsTreePartial(RefAST t) const;

   virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAll(RefAST t);

   virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAllPartial(RefAST t);

   virtual void addChild(RefAST c)
   {
      if( !c )
         return;
 
      RefBaseAST tmp = down;
 
      if (tmp)
      {
         while (tmp->right)
            tmp = tmp->right;
         tmp->right = c;
      }
      else
         down = c;
   }

   virtual size_t getNumberOfChildren() const;

   virtual RefAST getFirstChild() const
   {
      return RefAST(down);
   }

   virtual RefAST getNextSibling() const
   {
      return RefAST(right);
   }

   virtual ANTLR_USE_NAMESPACE(std)string getText() const
   {
      return "";
   }

   virtual int getType() const
   {
      return 0;
   }

   virtual void removeChildren()
   {
      down = static_cast<BaseAST*>(static_cast<AST*>(nullAST));
   }

   virtual void setFirstChild(RefAST c)
   {
      down = static_cast<BaseAST*>(static_cast<AST*>(c));
   }

   virtual void setNextSibling(RefAST n)
   {
      right = static_cast<BaseAST*>(static_cast<AST*>(n));
   }

   virtual void setText(const ANTLR_USE_NAMESPACE(std)string& txt)
   {
   }

   virtual void setType(int type)
   {
   }
 
#ifdef ANTLR_SUPPORT_XML
   virtual bool attributesToStream( ANTLR_USE_NAMESPACE(std)ostream& out ) const;
   virtual void toStream( ANTLR_USE_NAMESPACE(std)ostream &out ) const;
#endif

   virtual ANTLR_USE_NAMESPACE(std)string toString() const
   {
      return getText();
   }

   virtual ANTLR_USE_NAMESPACE(std)string toStringList() const;
   virtual ANTLR_USE_NAMESPACE(std)string toStringTree() const;
protected:
   RefBaseAST down;
   RefBaseAST right;
private:
   void doWorkForFindAll(ANTLR_USE_NAMESPACE(std)vector<RefAST>& v,
                         RefAST target,
                         bool partialMatch);
};

inline bool BaseAST::equals(RefAST t) const
{
   if (!t)
      return false;
   return ((getType() == t->getType()) && (getText() == t->getText()));
}
 
#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif
 
#endif //INC_BaseAST_hpp__