---

ptree_visitor.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef ptree_visitor_h
#define ptree_visitor_h

#include <cassert>
#include <algorithm>

#include "source.h"
#include "downcast.h"

// OpenC++ interfaces
#include <ptree.h>
#include <walker.h>

//
// INTERFACE definition follows 
//


class Source;

template <typename Returntype>
class Ptree_visitor : private Walker
{
  // TYPES
  typedef Walker Super;

  // DATA
  Source* _s;
  Returntype _saved;

public:
  using Super::operator delete;
  using Super::operator new;

  Source* get_source() const { return _s; }

public:  
  explicit Ptree_visitor(Source* s);
  
  virtual ~Ptree_visitor();
  
  Returntype visit();
  
  virtual Returntype visit(Ptree *p);
  
  virtual Returntype visit_null();
  
  // 
  // Type switch
  // 
  
  virtual Returntype visit_leaf(Leaf *p);
  
  virtual Returntype visit_nonleaf(NonLeaf *p);
  
  virtual Returntype visit_declarator(PtreeDeclarator *p);
  
  virtual Returntype visit_typedef(PtreeTypedef *p);
  
  virtual Returntype visit_templatedecl(PtreeTemplateDecl *p);
  
  virtual Returntype visit_templateinstantiation(PtreeTemplateInstantiation *p);
  
  virtual Returntype visit_externtemplate(PtreeExternTemplate *p);
  
  virtual Returntype visit_linkagespec(PtreeLinkageSpec *p);
  
  virtual Returntype visit_namespacespec(PtreeNamespaceSpec *p);
  
  virtual Returntype visit_using(PtreeUsing *p);
  
  virtual Returntype visit_declaration(PtreeDeclaration *p);
  
  virtual Returntype visit_brace(PtreeBrace *p);
  
  virtual Returntype visit_block(PtreeBlock *p);
  
  virtual Returntype visit_classbody(PtreeClassBody *p);
  
  virtual Returntype visit_classspec(PtreeClassSpec *p);
  
  virtual Returntype visit_enumspec(PtreeEnumSpec *p);
  
  virtual Returntype visit_accessspec(PtreeAccessSpec *p);
  
  virtual Returntype visit_accessdecl(PtreeAccessDecl *p);
  
  virtual Returntype visit_useraccessspec(PtreeUserAccessSpec *p);
  
  virtual Returntype visit_if(PtreeIfStatement *p);
  
  virtual Returntype visit_switch(PtreeSwitchStatement *p);
  
  virtual Returntype visit_while(PtreeWhileStatement *p);
  
  virtual Returntype visit_do(PtreeDoStatement *p);
  
  virtual Returntype visit_for(PtreeForStatement *p);
  
  virtual Returntype visit_try(PtreeTryStatement *p);
  
  virtual Returntype visit_break(PtreeBreakStatement *p);
  
  virtual Returntype visit_continue(PtreeContinueStatement *p);
  
  virtual Returntype visit_return(PtreeReturnStatement *p);
  
  virtual Returntype visit_goto(PtreeGotoStatement *p);
  
  virtual Returntype visit_case(PtreeCaseStatement *p);
  
  virtual Returntype visit_default(PtreeDefaultStatement *p);
  
  virtual Returntype visit_label(PtreeLabelStatement *p);
  
  virtual Returntype visit_expr(PtreeExprStatement *p);
  
  virtual Returntype visit_comma(PtreeCommaExpr *p);
  
  virtual Returntype visit_assign(PtreeAssignExpr *p);
  
  virtual Returntype visit_cond(PtreeCondExpr *p);
  
  virtual Returntype visit_infix(PtreeInfixExpr *p);
  
  virtual Returntype visit_pm(PtreePmExpr *p);
  
  virtual Returntype visit_cast(PtreeCastExpr *p);
  
  virtual Returntype visit_unary(PtreeUnaryExpr *p);
  
  virtual Returntype visit_throw(PtreeThrowExpr *p);
  
  virtual Returntype visit_sizeof(PtreeSizeofExpr *p);
  
  virtual Returntype visit_new(PtreeNewExpr *p);
  
  virtual Returntype visit_delete(PtreeDeleteExpr *p);
  
  virtual Returntype visit_array(PtreeArrayExpr *p);
  
  virtual Returntype visit_funcall(PtreeFuncallExpr *p);
  
  virtual Returntype visit_postfix(PtreePostfixExpr *p);
  
  virtual Returntype visit_userstatement(PtreeUserStatementExpr *p);
  
  virtual Returntype visit_dotmember(PtreeDotMemberExpr *p);
  
  virtual Returntype visit_arrowmember(PtreeArrowMemberExpr *p);
  
  virtual Returntype visit_paren(PtreeParenExpr *p);
  
  virtual Returntype visit_staticuserstatement(PtreeStaticUserStatementExpr *p);
  
  virtual Returntype visit_exprstatement(PtreeExprStatement *p);
  
  virtual Returntype visit_fstylecastexpr(PtreeFstyleCastExpr *p);
  
  virtual Returntype visit_name(Ptree *p);
  
  virtual Returntype visit_this(LeafThis *p);

protected:  
  Returntype recurse(Ptree* p);
  
  virtual Returntype default_action(Ptree* p);
  
  virtual void runtime_error();

private:  
  // 
  // Override OpenC++'s Walker functions
  // 
  
  // Define those functions called by subclass implementations of
  // Ptree::Translate().
  virtual Ptree* TranslatePtree(Ptree *p);
  
  virtual Ptree* TranslateTypedef(Ptree *p);
  
  virtual Ptree* TranslateTemplateDecl(Ptree *p);
  
  virtual Ptree* TranslateTemplateInstantiation(Ptree *p);
  
  virtual Ptree* TranslateExternTemplate(Ptree *p);
  
  virtual Ptree* TranslateLinkageSpec(Ptree *p);
  
  virtual Ptree* TranslateNamespaceSpec(Ptree *p);
  
  virtual Ptree* TranslateUsing(Ptree *p);
  
  virtual Ptree* TranslateDeclaration(Ptree *p);
  
  virtual Ptree* TranslateBrace(Ptree *p);
  
  virtual Ptree* TranslateBlock(Ptree *p);
  
  virtual Ptree* TranslateClassBody(Ptree *p, Ptree *, Class *);
  
  virtual Ptree* TranslateClassSpec(Ptree *p);
  
  virtual Ptree* TranslateEnumSpec(Ptree *p);
  
  virtual Ptree* TranslateAccessSpec(Ptree *p);
  
  virtual Ptree* TranslateAccessDecl(Ptree *p);
  
  virtual Ptree* TranslateUserAccessSpec(Ptree *p);
  
  virtual Ptree* TranslateIf(Ptree *p);
  
  virtual Ptree* TranslateSwitch(Ptree *p);
  
  virtual Ptree* TranslateWhile(Ptree *p);
  
  virtual Ptree* TranslateDo(Ptree *p);
  
  virtual Ptree* TranslateFor(Ptree *p);
  
  virtual Ptree* TranslateTry(Ptree *p);
  
  virtual Ptree* TranslateBreak(Ptree *p);
  
  virtual Ptree* TranslateContinue(Ptree *p);
  
  virtual Ptree* TranslateReturn(Ptree *p);
  
  virtual Ptree* TranslateGoto(Ptree *p);
  
  virtual Ptree* TranslateCase(Ptree *p);
  
  virtual Ptree* TranslateDefault(Ptree *p);
  
  virtual Ptree* TranslateLabel(Ptree *p);
  
  virtual Ptree* TranslateExprStatement(Ptree *p);
  
  virtual Ptree* TranslateComma(Ptree *p);
  
  virtual Ptree* TranslateAssign(Ptree *p);
  
  virtual Ptree* TranslateCond(Ptree *p);
  
  virtual Ptree* TranslateInfix(Ptree *p);
  
  virtual Ptree* TranslatePm(Ptree *p);
  
  virtual Ptree* TranslateCast(Ptree *p);
  
  virtual Ptree* TranslateUnary(Ptree *p);
  
  virtual Ptree* TranslateThrow(Ptree *p);
  
  virtual Ptree* TranslateSizeof(Ptree *p);
  
  virtual Ptree* TranslateNew(Ptree *p);
  
  virtual Ptree* TranslateDelete(Ptree *p);
  
  virtual Ptree* TranslateArray(Ptree *p);
  
  virtual Ptree* TranslateFuncall(Ptree *p);
  
  virtual Ptree* TranslatePostfix(Ptree *p);
  
  virtual Ptree* TranslateUserStatement(Ptree *p);
  
  virtual Ptree* TranslateDotMember(Ptree *p);
  
  virtual Ptree* TranslateArrowMember(Ptree *p);
  
  virtual Ptree* TranslateParen(Ptree *p);
  
  virtual Ptree* TranslateStaticUserStatement(Ptree *p);
  
  virtual Ptree* TranslateFstyleCast(Ptree *p);
  
  virtual Ptree* TranslateVariable(Ptree *p);
  
  virtual Ptree* TranslateThis(Ptree *p);
  
  // Wire all other virtual functions of Walker to runtime errors.  They
  // should never be called.
  virtual bool IsClassWalker();
  
  virtual void TypeofPtree(Ptree *, TypeInfo &);
  
  virtual Ptree* TranslateTemplateInstantiation(Ptree *, Ptree *, Ptree *, Class *);
  
  virtual Ptree* TranslateTemplateClass(Ptree *, Ptree *);
  
  virtual Ptree* TranslateTemplateFunction(Ptree *, Ptree *);
  
  virtual Ptree* TranslateStorageSpecifiers(Ptree *);
  
  virtual Ptree* TranslateDeclarators(Ptree *);
  
  virtual Ptree* TranslateDeclarator(bool, PtreeDeclarator *);
  
  virtual Ptree* TranslateArgDeclList(bool, Ptree *, Ptree *);
  
  virtual Ptree* TranslateInitializeArgs(PtreeDeclarator *, Ptree *);
  
  virtual Ptree* TranslateAssignInitializer(PtreeDeclarator *, Ptree *);
  
  virtual Ptree* TranslateFunctionImplementation(Ptree *);
  
  virtual Ptree* RecordArgsAndTranslateFbody(Class *, Ptree *args, Ptree *body);
  
  virtual Ptree* TranslateFunctionBody(Ptree *);
  
  virtual Ptree* TranslateClassSpec(Ptree *, Ptree *, Ptree *, Class *);
  
  virtual Ptree* TranslateTypespecifier(Ptree *);
  
  virtual Ptree* TranslateNew2(Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *);
  
  virtual Ptree* TranslateNew3(Ptree *type);
  
  // Metaclass stuff 
  virtual Class* MakeTemplateInstantiationMetaobject(Ptree *full_class_spec, Ptree *userkey, Ptree *class_spec);
  
  virtual Class* MakeTemplateClassMetaobject(Ptree *, Ptree *, Ptree *);
  
  virtual Class* MakeClassMetaobject(Ptree *, Ptree *, Ptree *);
  
  // Typeof stuff
  virtual void TypeofComma(Ptree *, TypeInfo &);
  
  virtual void TypeofAssign(Ptree *, TypeInfo &);
  
  virtual void TypeofCond(Ptree *, TypeInfo &);
  
  virtual void TypeofInfix(Ptree *, TypeInfo &);
  
  virtual void TypeofPm(Ptree *, TypeInfo &);
  
  virtual void TypeofCast(Ptree *, TypeInfo &);
  
  virtual void TypeofUnary(Ptree *, TypeInfo &);
  
  virtual void TypeofThrow(Ptree *, TypeInfo &);
  
  virtual void TypeofSizeof(Ptree *, TypeInfo &);
  
  virtual void TypeofNew(Ptree *, TypeInfo &);
  
  virtual void TypeofDelete(Ptree *, TypeInfo &);
  
  virtual void TypeofThis(Ptree *, TypeInfo &);
  
  virtual void TypeofVariable(Ptree *, TypeInfo &);
  
  virtual void TypeofFstyleCast(Ptree *, TypeInfo &);
  
  virtual void TypeofArray(Ptree *, TypeInfo &);
  
  virtual void TypeofFuncall(Ptree *, TypeInfo &);
  
  virtual void TypeofPostfix(Ptree *, TypeInfo &);
  
  virtual void TypeofUserStatement(Ptree *, TypeInfo &);
  
  virtual void TypeofDotMember(Ptree *, TypeInfo &);
  
  virtual void TypeofArrowMember(Ptree *, TypeInfo &);
  
  virtual void TypeofParen(Ptree *, TypeInfo &);
  
  virtual void TypeofStaticUserStatement(Ptree *, TypeInfo &);
};

//
// IMPLEMENTATION of function templates
//




template <typename Returntype> Ptree_visitor<Returntype>::Ptree_visitor(Source* s)
  : Walker (s->parser()),
    _s (s)
{
}



template <typename Returntype> Ptree_visitor<Returntype>::~Ptree_visitor()
{
}



template <typename Returntype> Returntype
Ptree_visitor<Returntype>::visit()
{
  _s->translate(this);          // XXX Source::translate returns Ptree -- why?
  return _saved;
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit(Ptree *p) 
{
  if (! p)
    return visit_null ();

  Returntype saved = _saved;

  Super::Translate (p);

  std::swap (_saved, saved);
  return saved;
}


template <typename Returntype> Returntype
Ptree_visitor<Returntype>::recurse(Ptree* p)
{
  assert (p);

  if (p->IsLeaf())
    return Returntype(0);

  Returntype r(0);

  do 
    {
      r = visit (p->Car());
      p = p->Cdr();

      if (p && p->IsLeaf())
        {
          r = visit (p);
          break;
        }
    }
  while (p);

  return r;
}


template <typename Returntype> Returntype
Ptree_visitor<Returntype>::default_action(Ptree* p)
{
  if (p)
    return recurse (p);

  return Returntype (0);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_null() 
{
  return default_action (0);
}



// 
// Type switch
// 

template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_leaf(Leaf *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_nonleaf(NonLeaf *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_declarator(PtreeDeclarator *p) 
{
  return default_action(p);
}


template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_typedef(PtreeTypedef *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_templatedecl(PtreeTemplateDecl *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_templateinstantiation(PtreeTemplateInstantiation *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_externtemplate(PtreeExternTemplate *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_linkagespec(PtreeLinkageSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_namespacespec(PtreeNamespaceSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_using(PtreeUsing *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_declaration(PtreeDeclaration *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_brace(PtreeBrace *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_block(PtreeBlock *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_classbody(PtreeClassBody *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_classspec(PtreeClassSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_enumspec(PtreeEnumSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_accessspec(PtreeAccessSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_accessdecl(PtreeAccessDecl *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_useraccessspec(PtreeUserAccessSpec *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_if(PtreeIfStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_switch(PtreeSwitchStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_while(PtreeWhileStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_do(PtreeDoStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_for(PtreeForStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_try(PtreeTryStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_break(PtreeBreakStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_continue(PtreeContinueStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_return(PtreeReturnStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_goto(PtreeGotoStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_case(PtreeCaseStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_default(PtreeDefaultStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_label(PtreeLabelStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_expr(PtreeExprStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_comma(PtreeCommaExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_assign(PtreeAssignExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_cond(PtreeCondExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_infix(PtreeInfixExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_pm(PtreePmExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_cast(PtreeCastExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_unary(PtreeUnaryExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_throw(PtreeThrowExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_sizeof(PtreeSizeofExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_new(PtreeNewExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_delete(PtreeDeleteExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_array(PtreeArrayExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_funcall(PtreeFuncallExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_postfix(PtreePostfixExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_userstatement(PtreeUserStatementExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_dotmember(PtreeDotMemberExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_arrowmember(PtreeArrowMemberExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_paren(PtreeParenExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_staticuserstatement(PtreeStaticUserStatementExpr *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_exprstatement(PtreeExprStatement *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_fstylecastexpr(PtreeFstyleCastExpr *p) 
{
  return default_action(p);
}


template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_name(Ptree *p) 
{
  return default_action(p);
}



template <typename Returntype> Returntype 
Ptree_visitor<Returntype>::visit_this(LeafThis *p) 
{
  return default_action(p);
}



template <typename Returntype> void 
Ptree_visitor<Returntype>::runtime_error()
{ 
  assert (!"This should never be called.");
}



// 
// Override OpenC++'s Walker functions
// 

// Define those functions called by subclass implementations of
// Ptree::Translate().

template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslatePtree(Ptree *p) 
{
  // Hack: Do some type deduction for types that do not support
  // visitation

  if (p->IsLeaf())
    _saved = visit_leaf (downcast<Leaf*>(p));
  else if (PtreeDeclarator* d = dynamic_cast<PtreeDeclarator*>(p))
    _saved = visit_declarator (d);
  else
    _saved = visit_nonleaf (downcast<NonLeaf*>(p));
    // This barfs if p is not a nonleaf, which is what we want.

  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTypedef(Ptree *p) 
{
  _saved = visit_typedef (downcast<PtreeTypedef*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTemplateDecl(Ptree *p)
{
  _saved = visit_templatedecl (downcast<PtreeTemplateDecl*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTemplateInstantiation(Ptree *p) 
{
  _saved = visit_templateinstantiation 
    (downcast<PtreeTemplateInstantiation*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateExternTemplate(Ptree *p) 
{
  _saved = visit_externtemplate (downcast<PtreeExternTemplate*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateLinkageSpec(Ptree *p) 
{
  _saved = visit_linkagespec (downcast<PtreeLinkageSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateNamespaceSpec(Ptree *p) 
{
  _saved = visit_namespacespec (downcast<PtreeNamespaceSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateUsing(Ptree *p) 
{
  _saved = visit_using (downcast<PtreeUsing*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDeclaration(Ptree *p) 
{
  _saved = visit_declaration (downcast<PtreeDeclaration*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateBrace(Ptree *p) 
{
  _saved = visit_brace (downcast<PtreeBrace*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateBlock(Ptree *p) 
{
  _saved = visit_block (downcast<PtreeBlock*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateClassBody(Ptree *p, Ptree *, Class *) 
{ 
  _saved = visit_classbody (downcast<PtreeClassBody*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateClassSpec(Ptree *p) 
{
  _saved = visit_classspec (downcast<PtreeClassSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateEnumSpec(Ptree *p) 
{
  _saved = visit_enumspec (downcast<PtreeEnumSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateAccessSpec(Ptree *p) 
{
  _saved = visit_accessspec (downcast<PtreeAccessSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateAccessDecl(Ptree *p) 
{
  _saved = visit_accessdecl (downcast<PtreeAccessDecl*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateUserAccessSpec(Ptree *p) 
{
  _saved = visit_useraccessspec (downcast<PtreeUserAccessSpec*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateIf(Ptree *p) 
{
  _saved = visit_if (downcast<PtreeIfStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateSwitch(Ptree *p) 
{
  _saved = visit_switch (downcast<PtreeSwitchStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateWhile(Ptree *p) 
{
  _saved = visit_while (downcast<PtreeWhileStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDo(Ptree *p) 
{
  _saved = visit_do (downcast<PtreeDoStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateFor(Ptree *p) 
{
  _saved = visit_for (downcast<PtreeForStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTry(Ptree *p) 
{
  _saved = visit_try (downcast<PtreeTryStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateBreak(Ptree *p) 
{
  _saved = visit_break (downcast<PtreeBreakStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateContinue(Ptree *p) 
{
  _saved = visit_continue (downcast<PtreeContinueStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateReturn(Ptree *p) 
{
  _saved = visit_return (downcast<PtreeReturnStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateGoto(Ptree *p) 
{
  _saved = visit_goto (downcast<PtreeGotoStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateCase(Ptree *p) 
{
  _saved = visit_case (downcast<PtreeCaseStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDefault(Ptree *p) 
{
  _saved = visit_default (downcast<PtreeDefaultStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateLabel(Ptree *p) 
{
  _saved = visit_label (downcast<PtreeLabelStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateExprStatement(Ptree *p) 
{ 
  _saved = visit_exprstatement (downcast<PtreeExprStatement*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateComma(Ptree *p) 
{
  _saved = visit_comma (downcast<PtreeCommaExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateAssign(Ptree *p) 
{
  _saved = visit_assign (downcast<PtreeAssignExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateCond(Ptree *p) 
{
  _saved = visit_cond (downcast<PtreeCondExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateInfix(Ptree *p) 
{
  _saved = visit_infix (downcast<PtreeInfixExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslatePm(Ptree *p) 
{
  _saved = visit_pm (downcast<PtreePmExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateCast(Ptree *p) 
{
  _saved = visit_cast (downcast<PtreeCastExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateUnary(Ptree *p) 
{
  _saved = visit_unary (downcast<PtreeUnaryExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateThrow(Ptree *p) 
{
  _saved = visit_throw (downcast<PtreeThrowExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateSizeof(Ptree *p) 
{
  _saved = visit_sizeof (downcast<PtreeSizeofExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateNew(Ptree *p) 
{
  _saved = visit_new (downcast<PtreeNewExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDelete(Ptree *p) 
{
  _saved = visit_delete (downcast<PtreeDeleteExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateArray(Ptree *p) 
{
  _saved = visit_array (downcast<PtreeArrayExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateFuncall(Ptree *p) 
{
  _saved = visit_funcall (downcast<PtreeFuncallExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslatePostfix(Ptree *p) 
{
  _saved = visit_postfix (downcast<PtreePostfixExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateUserStatement(Ptree *p) 
{
  _saved = visit_userstatement (downcast<PtreeUserStatementExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDotMember(Ptree *p) 
{
  _saved = visit_dotmember (downcast<PtreeDotMemberExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateArrowMember(Ptree *p) 
{
  _saved = visit_arrowmember (downcast<PtreeArrowMemberExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateParen(Ptree *p) 
{
  _saved = visit_paren (downcast<PtreeParenExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateStaticUserStatement(Ptree *p) 
{
  _saved = visit_staticuserstatement (downcast<PtreeStaticUserStatementExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateFstyleCast(Ptree *p) 
{
  _saved = visit_fstylecastexpr (downcast<PtreeFstyleCastExpr*>(p));
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateVariable(Ptree *p) 
{
  // no downcast here -- p can be LeafName or PtreeName
  _saved = visit_name (p);
  return 0;
}



template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateThis(Ptree *p) 
{
  _saved = visit_this (downcast<LeafThis*>(p));
  return 0;
}


// Wire all other virtual functions of Walker to runtime errors.  They
// should never be called.

template <typename Returntype> bool Ptree_visitor<Returntype>::IsClassWalker() { runtime_error(); return 0; }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofPtree(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTemplateInstantiation(Ptree *, Ptree *, Ptree *, Class *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTemplateClass(Ptree *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTemplateFunction(Ptree *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateStorageSpecifiers(Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDeclarators(Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateDeclarator(bool, PtreeDeclarator *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateArgDeclList(bool, Ptree *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateInitializeArgs(PtreeDeclarator *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateAssignInitializer(PtreeDeclarator *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateFunctionImplementation(Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::RecordArgsAndTranslateFbody(Class *, Ptree *args, Ptree *body) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateFunctionBody(Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateClassSpec(Ptree *, Ptree *, Ptree *, Class *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateTypespecifier(Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateNew2(Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; }


template <typename Returntype> Ptree* Ptree_visitor<Returntype>::TranslateNew3(Ptree *type) { runtime_error(); return 0; }


// Metaclass stuff 

template <typename Returntype> Class* Ptree_visitor<Returntype>::MakeTemplateInstantiationMetaobject(Ptree *full_class_spec, Ptree *userkey, Ptree *class_spec) { runtime_error(); return 0; }


template <typename Returntype> Class* Ptree_visitor<Returntype>::MakeTemplateClassMetaobject(Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; } 


template <typename Returntype> Class* Ptree_visitor<Returntype>::MakeClassMetaobject(Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; }


// Typeof stuff

template <typename Returntype> void Ptree_visitor<Returntype>::TypeofComma(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofAssign(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofCond(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofInfix(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofPm(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofCast(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofUnary(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofThrow(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofSizeof(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofNew(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofDelete(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofThis(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofVariable(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofFstyleCast(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofArray(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofFuncall(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofPostfix(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofUserStatement(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofDotMember(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofArrowMember(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofParen(Ptree *, TypeInfo &) { runtime_error(); }


template <typename Returntype> void Ptree_visitor<Returntype>::TypeofStaticUserStatement(Ptree *, TypeInfo &) { runtime_error(); }

#endif // ptree_visitor_h

---