ASTFactory.hpp

Go to the documentation of this file.

#ifndef INC_ASTFactory_hpp__
#define INC_ASTFactory_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/ASTFactory.hpp#2 $
 */
 
#include <antlr/config.hpp>
#include <antlr/AST.hpp>
#include <antlr/ASTArray.hpp>
#include <antlr/ASTPair.hpp>
 
#include <istream>
#include <utility>
 
#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif
 
// Using these extra types to appease MSVC
typedef RefAST (*factory_type_)();
typedef ANTLR_USE_NAMESPACE(std)pair< const char*, factory_type_ >  factory_descriptor_;
typedef ANTLR_USE_NAMESPACE(std)vector< factory_descriptor_* >      factory_descriptor_list_;

class ANTLR_API ASTFactory {
public:
   typedef factory_type_             factory_type;
   typedef factory_descriptor_       factory_descriptor;
   typedef factory_descriptor_list_  factory_descriptor_list;
protected:
   /* The mapping of AST node type to factory..
    */
   factory_descriptor default_factory_descriptor;
   factory_descriptor_list nodeFactories;
public:
   ASTFactory();
   ASTFactory( const char* factory_node_name, factory_type factory );
   virtual ~ASTFactory();

   void registerFactory( int type, const char* ast_name, factory_type factory );
   void setMaxNodeType( int type );

   void addASTChild(ASTPair& currentAST, RefAST child);
   virtual RefAST create();
   RefAST create(int type);
   RefAST create(int type, const ANTLR_USE_NAMESPACE(std)string& txt);
   RefAST create(RefAST tr);
   RefAST create(RefToken tok);
   RefAST create(const ANTLR_USE_NAMESPACE(std)string& txt, ANTLR_USE_NAMESPACE(std)istream& infile );
   RefAST dup(RefAST t);
   RefAST dupList(RefAST t);
   RefAST dupTree(RefAST t);
   RefAST make(ANTLR_USE_NAMESPACE(std)vector<RefAST>& nodes);
   RefAST make(ASTArray* nodes);
   void makeASTRoot(ASTPair& currentAST, RefAST root);

   void setASTNodeFactory( const char* factory_node_name, factory_type factory );
 
#ifdef ANTLR_SUPPORT_XML
   RefAST LoadAST( ANTLR_USE_NAMESPACE(std)istream& infile );
#endif
protected:
   void loadChildren( ANTLR_USE_NAMESPACE(std)istream& infile, RefAST current );
   void loadSiblings( ANTLR_USE_NAMESPACE(std)istream& infile, RefAST current );
   bool checkCloseTag( ANTLR_USE_NAMESPACE(std)istream& infile );
 
#ifdef ANTLR_VECTOR_HAS_AT
   inline RefAST getNodeOfType( unsigned int type )
   {
      return RefAST(nodeFactories.at(type)->second());
   }
   const char* getASTNodeType( unsigned int type )
   {
      return nodeFactories.at(type)->first;
   }
   factory_type getASTNodeFactory( unsigned int type )
   {
      return nodeFactories.at(type)->second;
   }
#else
   inline RefAST getNodeOfType( unsigned int type )
   {
      return RefAST(nodeFactories[type]->second());
   }

   const char* getASTNodeType( unsigned int type )
   {
      return nodeFactories[type]->first;
   }
   factory_type getASTNodeFactory( unsigned int type )
   {
      return nodeFactories[type]->second;
   }
#endif
 
private:
   // no copying and such..
   ASTFactory( const ASTFactory& );
   ASTFactory& operator=( const ASTFactory& );
};
 
#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif
 
#endif //INC_ASTFactory_hpp__