INTERFACE:

#include <cassert>
#include <algorithm>

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

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

class Source;

/** Base class for visitors of a PTree hierarchy.  This class template
    serves as an adapter to OpenC++'s Walker hierarchy, which is
    already supported by PTree and friends.  Currently, this class
    recursively traverses a parse tree.  Users can overload the
    visit() functions to add their own node-specific code, and call
    this class' visit() to do the recursion. */

template <typename Returntype>
class Ptree_visitor : private Opencxx::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; }
};

IMPLEMENTATION:

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

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

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

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

  Returntype saved = _saved;

  Super::Translate (p);

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

/** Recursively visit nested nodes.  
    (You should not overload this function.  If you want to change the
    default action, overload default() instead.)
    @param p parse subtree
    @returns result of visitation of last subtree of p
 */
PROTECTED
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;
}

/** Default action taken when a visit_*() function has not been
    overloaded.  Overload this function to change the default action.
    The standard default action is to call recurse() on the argument.
    @param p parse subtree
    @returns result of default action
 */
PROTECTED
template <typename Returntype>
virtual Returntype
Ptree_visitor<Returntype>::default_action (Ptree* p)
{
  if (p)
    return recurse (p);

  return Returntype (0);
}

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


// 
// Type switch
// 

/** Visit a parse-tree leaf: Leaf, LeafReserved, and all subclasses of
    LeafReserved: LeafNAMESPACE etc.
 */
PUBLIC
template <typename Returntype>
virtual Returntype 
Ptree_visitor<Returntype>::visit_leaf (Leaf *p) 
{
  return default_action(p);
}

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

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

/**
    @param p ["typedef", Ptree(type), Ptree(newtypename)]
 */
PUBLIC
template <typename Returntype>
virtual Returntype 
Ptree_visitor<Returntype>::visit_typedef (PtreeTypedef *p) 
{
  return default_action(p);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PUBLIC
template <typename Returntype>
virtual Returntype 
Ptree_visitor<Returntype>::visit_typeid (PtreeTypeidExpr *p) 
{
  return default_action(p);
}

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

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

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

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

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

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

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

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

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

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



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

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

/** @param p Can be PtreeName or LeafName
 */
PUBLIC
template <typename Returntype>
virtual Returntype 
Ptree_visitor<Returntype>::visit_name (Ptree *p) 
{
  return default_action(p);
}

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


PROTECTED
template <typename Returntype>
virtual 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>
virtual 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>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTypedef (Ptree *p) 
{
  _saved = visit_typedef (downcast<PtreeTypedef*>(p));
  return 0;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTypeid (Ptree *p) 
{
  _saved = visit_typeid (downcast<PtreeTypeidExpr*>(p));
  return 0;
}

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

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

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

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

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

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

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

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

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

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

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

template <typename Returntype>
virtual 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>
virtual 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>
virtual bool Ptree_visitor<Returntype>::IsClassWalker () { runtime_error(); return 0; }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofPtree (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTemplateInstantiation (Ptree *, Ptree *, Ptree *, Opencxx::Class *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTemplateClass (Ptree *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTemplateFunction (Ptree *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateStorageSpecifiers (Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateDeclarators (Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateDeclarator (bool, PtreeDeclarator *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateArgDeclList (bool, Ptree *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateInitializeArgs (PtreeDeclarator *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateAssignInitializer (PtreeDeclarator *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateFunctionImplementation (Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::RecordArgsAndTranslateFbody (Opencxx::Class *, Ptree *args, Ptree *body) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateFunctionBody (Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateClassSpec (Ptree *, Ptree *, Ptree *, Opencxx::Class *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateTypespecifier (Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateNew2 (Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; }
template <typename Returntype>
virtual Ptree* Ptree_visitor<Returntype>::TranslateNew3 (Ptree *type) { runtime_error(); return 0; }

// Metaclass stuff 
template <typename Returntype>
virtual Opencxx::Class* Ptree_visitor<Returntype>::MakeTemplateInstantiationMetaobject (Ptree *full_class_spec, Ptree *userkey, Ptree *class_spec) { runtime_error(); return 0; }
template <typename Returntype>
virtual Opencxx::Class* Ptree_visitor<Returntype>::MakeTemplateClassMetaobject (Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; } 
template <typename Returntype>
virtual Opencxx::Class* Ptree_visitor<Returntype>::MakeClassMetaobject (Ptree *, Ptree *, Ptree *) { runtime_error(); return 0; }

// Typeof stuff
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofComma (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofAssign (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofCond (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofInfix (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofPm (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofCast (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofUnary (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofThrow (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofSizeof (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofTypeid (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofNew (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofDelete (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofThis (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofVariable (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofFstyleCast (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofArray (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofFuncall (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofPostfix (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofUserStatement (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofDotMember (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofArrowMember (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofParen (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }
template <typename Returntype>
virtual void Ptree_visitor<Returntype>::TypeofStaticUserStatement (Ptree *, Opencxx::TypeInfo &) { runtime_error(); }