// THIS FILE IS GENERATED
// WARNING! All changes made in this file will be lost!

#include "phpdefaultvisitor.h"

namespace Php
{

void DefaultVisitor::visitAdditiveExpression(AdditiveExpressionAst *node)
{
    visitNode(node->expression);
    if (node->additionalExpressionSequence)
    {
        const KDevPG::ListNode<AdditiveExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitAdditiveExpressionRest(AdditiveExpressionRestAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitArrayIndexSpecifier(ArrayIndexSpecifierAst *node)
{
    visitNode(node->expr);
}

void DefaultVisitor::visitArrayPairValue(ArrayPairValueAst *node)
{
    visitNode(node->expr);
    visitNode(node->exprValue);
    visitNode(node->varValue);
    visitNode(node->variable);
}

void DefaultVisitor::visitAssignmentExpression(AssignmentExpressionAst *node)
{
    visitNode(node->expression);
    visitNode(node->assignmentExpressionEqual);
    visitNode(node->assignmentExpression);
}

void DefaultVisitor::visitAssignmentExpressionCheckIfVariable(AssignmentExpressionCheckIfVariableAst *)
{
}

void DefaultVisitor::visitAssignmentExpressionEqual(AssignmentExpressionEqualAst *node)
{
    visitNode(node->assignmentExpression);
}

void DefaultVisitor::visitAssignmentList(AssignmentListAst *node)
{
    if (node->elementSequence)
    {
        const KDevPG::ListNode<AssignmentListElementAst*> *__it = node->elementSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitAssignmentListElement(AssignmentListElementAst *node)
{
    visitNode(node->variable);
    visitNode(node->assignmentList);
}

void DefaultVisitor::visitBaseVariable(BaseVariableAst *node)
{
    visitNode(node->var);
    if (node->offsetItemsSequence)
    {
        const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->staticMember);
}

void DefaultVisitor::visitBaseVariableWithFunctionCalls(BaseVariableWithFunctionCallsAst *node)
{
    visitNode(node->functionCall);
    visitNode(node->arrayIndex);
    visitNode(node->baseVariable);
}

void DefaultVisitor::visitBitAndExpression(BitAndExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<EqualityExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitBitOrExpression(BitOrExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<BitXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitBitXorExpression(BitXorExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<BitAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitBooleanAndExpression(BooleanAndExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<BitOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitBooleanOrExpression(BooleanOrExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<BooleanAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitCaseList(CaseListAst *node)
{
    if (node->caseItemsSequence)
    {
        const KDevPG::ListNode<Case_itemAst*> *__it = node->caseItemsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitCase_item(Case_itemAst *node)
{
    visitNode(node->expr);
    visitNode(node->statements);
}

void DefaultVisitor::visitCatchItem(CatchItemAst *node)
{
    if (node->catchClassSequence)
    {
        const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->catchClassSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->var);
    visitNode(node->statements);
}

void DefaultVisitor::visitClassBody(ClassBodyAst *node)
{
    if (node->classStatementsSequence)
    {
        const KDevPG::ListNode<ClassStatementAst*> *__it = node->classStatementsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitClassConstant(ClassConstantAst *)
{
}

void DefaultVisitor::visitClassConstantDeclaration(ClassConstantDeclarationAst *node)
{
    visitNode(node->identifier);
    visitNode(node->scalar);
}

void DefaultVisitor::visitClassDeclarationStatement(ClassDeclarationStatementAst *node)
{
    visitNode(node->modifier);
    visitNode(node->className);
    visitNode(node->extends);
    visitNode(node->implements);
    visitNode(node->body);
}

void DefaultVisitor::visitClassExtends(ClassExtendsAst *node)
{
    visitNode(node->identifier);
}

void DefaultVisitor::visitClassImplements(ClassImplementsAst *node)
{
    if (node->implementsSequence)
    {
        const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitClassName(ClassNameAst *node)
{
    visitNode(node->identifier);
}

void DefaultVisitor::visitClassNameReference(ClassNameReferenceAst *node)
{
    visitNode(node->className);
    visitNode(node->staticProperty);
    if (node->propertiesSequence)
    {
        const KDevPG::ListNode<ClassPropertyAst*> *__it = node->propertiesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->baseVariable);
}

void DefaultVisitor::visitClassProperty(ClassPropertyAst *node)
{
    visitNode(node->staticProperty);
    visitNode(node->property);
}

void DefaultVisitor::visitClassStatement(ClassStatementAst *node)
{
    visitNode(node->variable);
    visitNode(node->modifiers);
    visitNode(node->propertyType);
    visitNode(node->methodName);
    visitNode(node->parameters);
    visitNode(node->returnType);
    visitNode(node->methodBody);
    if (node->constsSequence)
    {
        const KDevPG::ListNode<ClassConstantDeclarationAst*> *__it = node->constsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    if (node->traitsSequence)
    {
        const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->traitsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->imports);
}

void DefaultVisitor::visitClassVariable(ClassVariableAst *node)
{
    visitNode(node->variable);
    visitNode(node->value);
}

void DefaultVisitor::visitClassVariableDeclaration(ClassVariableDeclarationAst *node)
{
    if (node->varsSequence)
    {
        const KDevPG::ListNode<ClassVariableAst*> *__it = node->varsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitClosure(ClosureAst *node)
{
    visitNode(node->parameters);
    visitNode(node->lexicalVars);
    visitNode(node->returnType);
    visitNode(node->functionBody);
}

void DefaultVisitor::visitCommonScalar(CommonScalarAst *node)
{
    visitNode(node->stringIndex);
}

void DefaultVisitor::visitCompoundVariable(CompoundVariableAst *node)
{
    visitNode(node->variable);
    visitNode(node->expr);
}

void DefaultVisitor::visitCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst *node)
{
    visitNode(node->indirectVariable);
    visitNode(node->expr);
    visitNode(node->variable);
}

void DefaultVisitor::visitConditionalExpression(ConditionalExpressionAst *node)
{
    visitNode(node->expression);
    visitNode(node->ifExpression);
    visitNode(node->elseExpression);
}

void DefaultVisitor::visitConstantDeclaration(ConstantDeclarationAst *node)
{
    visitNode(node->identifier);
    visitNode(node->scalar);
}

void DefaultVisitor::visitConstantOrClassConst(ConstantOrClassConstAst *node)
{
    visitNode(node->constant);
    visitNode(node->classConstant);
}

void DefaultVisitor::visitCtorArguments(CtorArgumentsAst *node)
{
    visitNode(node->parameterList);
}

void DefaultVisitor::visitDeclareItem(DeclareItemAst *node)
{
    visitNode(node->scalar);
}

void DefaultVisitor::visitDeclareStatement(DeclareStatementAst *node)
{
    visitNode(node->statement);
    visitNode(node->statements);
}

void DefaultVisitor::visitDimListItem(DimListItemAst *node)
{
    visitNode(node->arrayIndex);
    visitNode(node->expr);
}

void DefaultVisitor::visitElseSingle(ElseSingleAst *node)
{
    visitNode(node->statement);
}

void DefaultVisitor::visitElseifList(ElseifListAst *node)
{
    if (node->elseifListItemSequence)
    {
        const KDevPG::ListNode<ElseifListItemAst*> *__it = node->elseifListItemSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitElseifListItem(ElseifListItemAst *node)
{
    visitNode(node->expr);
    visitNode(node->statement);
}

void DefaultVisitor::visitEncaps(EncapsAst *node)
{
    visitNode(node->var);
}

void DefaultVisitor::visitEncapsList(EncapsListAst *node)
{
    if (node->encapsSequence)
    {
        const KDevPG::ListNode<EncapsAst*> *__it = node->encapsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitEncapsVar(EncapsVarAst *node)
{
    visitNode(node->arrayIndex);
    visitNode(node->expr);
    visitNode(node->variable);
    visitNode(node->propertyIdentifier);
    visitNode(node->offset);
}

void DefaultVisitor::visitEncapsVarOffset(EncapsVarOffsetAst *)
{
}

void DefaultVisitor::visitEqualityExpression(EqualityExpressionAst *node)
{
    visitNode(node->expression);
    visitNode(node->additionalExpression);
}

void DefaultVisitor::visitEqualityExpressionRest(EqualityExpressionRestAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitExpr(ExprAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitForExpr(ForExprAst *node)
{
    if (node->exprsSequence)
    {
        const KDevPG::ListNode<ExprAst*> *__it = node->exprsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitForStatement(ForStatementAst *node)
{
    visitNode(node->statement);
    visitNode(node->statements);
}

void DefaultVisitor::visitForeachStatement(ForeachStatementAst *node)
{
    visitNode(node->statement);
    visitNode(node->statements);
}

void DefaultVisitor::visitForeachVariable(ForeachVariableAst *node)
{
    visitNode(node->variable);
}

void DefaultVisitor::visitFunctionCall(FunctionCallAst *node)
{
    visitNode(node->stringFunctionNameOrClass);
    visitNode(node->stringParameterList);
    visitNode(node->stringFunctionName);
    visitNode(node->varFunctionName);
    visitNode(node->expr);
    visitNode(node->varParameterList);
}

void DefaultVisitor::visitFunctionCallParameterList(FunctionCallParameterListAst *node)
{
    if (node->parametersSequence)
    {
        const KDevPG::ListNode<FunctionCallParameterListElementAst*> *__it = node->parametersSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitFunctionCallParameterListElement(FunctionCallParameterListElementAst *node)
{
    visitNode(node->variable);
    visitNode(node->expr);
}

void DefaultVisitor::visitFunctionDeclarationStatement(FunctionDeclarationStatementAst *node)
{
    visitNode(node->functionName);
    visitNode(node->parameters);
    visitNode(node->returnType);
    visitNode(node->functionBody);
}

void DefaultVisitor::visitGenericTypeHint(GenericTypeHintAst *node)
{
    visitNode(node->genericType);
}

void DefaultVisitor::visitGlobalVar(GlobalVarAst *node)
{
    visitNode(node->var);
    visitNode(node->dollarVar);
    visitNode(node->expr);
}

void DefaultVisitor::visitIdentifier(IdentifierAst *)
{
}

void DefaultVisitor::visitIifeSyntax(IifeSyntaxAst *node)
{
    visitNode(node->closure);
    visitNode(node->parameterList);
    visitNode(node->expression);
}

void DefaultVisitor::visitInnerStatementList(InnerStatementListAst *node)
{
    if (node->statementsSequence)
    {
        const KDevPG::ListNode<TopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitInstantiationAccess(InstantiationAccessAst *node)
{
    visitNode(node->variableProperty);
}

void DefaultVisitor::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node)
{
    visitNode(node->interfaceName);
    visitNode(node->extends);
    visitNode(node->body);
}

void DefaultVisitor::visitLexicalVar(LexicalVarAst *node)
{
    visitNode(node->variable);
}

void DefaultVisitor::visitLexicalVarList(LexicalVarListAst *node)
{
    if (node->lexicalVarsSequence)
    {
        const KDevPG::ListNode<LexicalVarAst*> *__it = node->lexicalVarsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitLogicalAndExpression(LogicalAndExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<PrintExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitLogicalOrExpression(LogicalOrExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<LogicalXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitLogicalXorExpression(LogicalXorExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<LogicalAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitMethodBody(MethodBodyAst *node)
{
    visitNode(node->statements);
}

void DefaultVisitor::visitMultiplicativeExpression(MultiplicativeExpressionAst *node)
{
    visitNode(node->expression);
    if (node->additionalExpressionSequence)
    {
        const KDevPG::ListNode<MultiplicativeExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitMultiplicativeExpressionRest(MultiplicativeExpressionRestAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitNamespaceDeclarationStatement(NamespaceDeclarationStatementAst *node)
{
    if (node->namespaceNameSequence)
    {
        const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->body);
}

void DefaultVisitor::visitNamespacedIdentifier(NamespacedIdentifierAst *node)
{
    if (node->namespaceNameSequence)
    {
        const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitNewElseSingle(NewElseSingleAst *node)
{
    visitNode(node->statements);
}

void DefaultVisitor::visitNewElseifList(NewElseifListAst *node)
{
    if (node->newElseifListItemSequence)
    {
        const KDevPG::ListNode<NewelseifListItemAst*> *__it = node->newElseifListItemSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitNewelseifListItem(NewelseifListItemAst *node)
{
    visitNode(node->expr);
    visitNode(node->statements);
}

void DefaultVisitor::visitNullCoalesceExpression(NullCoalesceExpressionAst *node)
{
    if (node->expressionSequence)
    {
        const KDevPG::ListNode<BooleanOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitObjectDimList(ObjectDimListAst *node)
{
    visitNode(node->variableName);
    if (node->offsetItemsSequence)
    {
        const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitObjectOperator(ObjectOperatorAst *)
{
}

void DefaultVisitor::visitObjectProperty(ObjectPropertyAst *node)
{
    visitNode(node->objectDimList);
    visitNode(node->variableWithoutObjects);
}

void DefaultVisitor::visitOptionalClassModifier(OptionalClassModifierAst *)
{
}

void DefaultVisitor::visitOptionalModifiers(OptionalModifiersAst *)
{
}

void DefaultVisitor::visitOuterTopStatement(OuterTopStatementAst *node)
{
    visitNode(node->namespaceDeclaration);
    visitNode(node->statement);
}

void DefaultVisitor::visitParameter(ParameterAst *node)
{
    visitNode(node->parameterType);
    visitNode(node->variable);
    visitNode(node->defaultValue);
}

void DefaultVisitor::visitParameterList(ParameterListAst *node)
{
    if (node->parametersSequence)
    {
        const KDevPG::ListNode<ParameterAst*> *__it = node->parametersSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitParameterType(ParameterTypeAst *node)
{
    visitNode(node->typehint);
}

void DefaultVisitor::visitPostprefixOperator(PostprefixOperatorAst *)
{
}

void DefaultVisitor::visitPrintExpression(PrintExpressionAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitPropertyType(PropertyTypeAst *node)
{
    visitNode(node->typehint);
}

void DefaultVisitor::visitPropertyTypeHint(PropertyTypeHintAst *node)
{
    visitNode(node->genericType);
}

void DefaultVisitor::visitRelationalExpression(RelationalExpressionAst *node)
{
    visitNode(node->expression);
    visitNode(node->additionalExpression);
    visitNode(node->instanceofType);
}

void DefaultVisitor::visitRelationalExpressionRest(RelationalExpressionRestAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitReservedNonModifierIdentifier(ReservedNonModifierIdentifierAst *)
{
}

void DefaultVisitor::visitReservedNonModifiers(ReservedNonModifiersAst *)
{
}

void DefaultVisitor::visitReturnType(ReturnTypeAst *node)
{
    visitNode(node->typehint);
}

void DefaultVisitor::visitScalar(ScalarAst *node)
{
    visitNode(node->commonScalar);
    visitNode(node->constantOrClassConst);
    if (node->offsetItemSequence)
    {
        const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->encapsList);
    visitNode(node->stringIndex);
}

void DefaultVisitor::visitSemiReserved(SemiReservedAst *)
{
}

void DefaultVisitor::visitSemiReservedIdentifier(SemiReservedIdentifierAst *)
{
}

void DefaultVisitor::visitSemicolonOrCloseTag(SemicolonOrCloseTagAst *)
{
}

void DefaultVisitor::visitShiftExpression(ShiftExpressionAst *node)
{
    visitNode(node->expression);
    if (node->additionalExpressionSequence)
    {
        const KDevPG::ListNode<ShiftExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitShiftExpressionRest(ShiftExpressionRestAst *node)
{
    visitNode(node->expression);
}

void DefaultVisitor::visitStart(StartAst *node)
{
    if (node->statementsSequence)
    {
        const KDevPG::ListNode<OuterTopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitStatement(StatementAst *node)
{
    visitNode(node->statements);
    visitNode(node->ifExpr);
    visitNode(node->ifStatement);
    visitNode(node->elseifList);
    visitNode(node->elseSingle);
    visitNode(node->whileExpr);
    visitNode(node->whileStatement);
    visitNode(node->forExpr1);
    visitNode(node->forExpr2);
    visitNode(node->forExpr3);
    visitNode(node->forStatement);
    visitNode(node->swtichExpr);
    visitNode(node->switchCaseList);
    visitNode(node->foreachVar);
    visitNode(node->foreachVarAsVar);
    visitNode(node->foreachExpr);
    visitNode(node->foreachExprAsVar);
    visitNode(node->foreachVariable);
    visitNode(node->foreachStatement);
    visitNode(node->declareItem);
    if (node->catchesSequence)
    {
        const KDevPG::ListNode<CatchItemAst*> *__it = node->catchesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->finallyBody);
    if (node->unsetVariablesSequence)
    {
        const KDevPG::ListNode<VariableAst*> *__it = node->unsetVariablesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->expr);
    visitNode(node->doStatement);
    visitNode(node->breakExpr);
    visitNode(node->continueExpr);
    visitNode(node->returnExpr);
    if (node->globalVarsSequence)
    {
        const KDevPG::ListNode<GlobalVarAst*> *__it = node->globalVarsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    if (node->staticVarsSequence)
    {
        const KDevPG::ListNode<StaticVarAst*> *__it = node->staticVarsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    if (node->echoExprsSequence)
    {
        const KDevPG::ListNode<ExprAst*> *__it = node->echoExprsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->throwExpr);
    if (node->constsSequence)
    {
        const KDevPG::ListNode<ConstantDeclarationAst*> *__it = node->constsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->useStatement);
}

void DefaultVisitor::visitStaticArrayPairValue(StaticArrayPairValueAst *node)
{
    if (node->val1Sequence)
    {
        const KDevPG::ListNode<StaticScalarAst*> *__it = node->val1Sequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    if (node->val2Sequence)
    {
        const KDevPG::ListNode<StaticScalarAst*> *__it = node->val2Sequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitStaticMember(StaticMemberAst *node)
{
    visitNode(node->className);
    visitNode(node->staticProperty);
}

void DefaultVisitor::visitStaticProperty(StaticPropertyAst *node)
{
    visitNode(node->staticProperty);
    if (node->offsetItemsSequence)
    {
        const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitStaticScalar(StaticScalarAst *node)
{
    visitNode(node->value);
    visitNode(node->constantOrClassConst);
    visitNode(node->plusValue);
    visitNode(node->minusValue);
    if (node->arrayValuesSequence)
    {
        const KDevPG::ListNode<StaticArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitStaticVar(StaticVarAst *node)
{
    visitNode(node->var);
    visitNode(node->value);
}

void DefaultVisitor::visitStringIndexSpecifier(StringIndexSpecifierAst *node)
{
    visitNode(node->expr);
}

void DefaultVisitor::visitSwitchCaseList(SwitchCaseListAst *node)
{
    visitNode(node->caseList);
}

void DefaultVisitor::visitTopStatement(TopStatementAst *node)
{
    visitNode(node->statement);
    visitNode(node->functionDeclaration);
    visitNode(node->classDeclaration);
    visitNode(node->traitDeclaration);
    visitNode(node->interfaceDeclaration);
}

void DefaultVisitor::visitTraitAliasDeclaration(TraitAliasDeclarationAst *node)
{
    if (node->statementsSequence)
    {
        const KDevPG::ListNode<TraitAliasStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitTraitAliasIdentifier(TraitAliasIdentifierAst *node)
{
    visitNode(node->identifier);
    visitNode(node->methodIdentifier);
}

void DefaultVisitor::visitTraitAliasStatement(TraitAliasStatementAst *node)
{
    visitNode(node->importIdentifier);
    visitNode(node->modifiers);
    visitNode(node->aliasNonModifierIdentifier);
    visitNode(node->aliasIdentifier);
    if (node->conflictIdentifierSequence)
    {
        const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->conflictIdentifierSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitTraitDeclarationStatement(TraitDeclarationStatementAst *node)
{
    visitNode(node->traitName);
    visitNode(node->body);
}

void DefaultVisitor::visitTraitVisibilityModifiers(TraitVisibilityModifiersAst *)
{
}

void DefaultVisitor::visitUnaryExpression(UnaryExpressionAst *node)
{
    visitNode(node->unaryExpression);
    visitNode(node->assignmentList);
    visitNode(node->expression);
    visitNode(node->includeExpression);
    visitNode(node->unaryExpressionNotPlusminus);
}

void DefaultVisitor::visitUnaryExpressionNotPlusminus(UnaryExpressionNotPlusminusAst *node)
{
    if (node->prefixOperatorSequence)
    {
        const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->prefixOperatorSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->varExpression);
    if (node->postfixOperatorSequence)
    {
        const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->postfixOperatorSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitUseNamespace(UseNamespaceAst *node)
{
    visitNode(node->identifier);
    visitNode(node->aliasIdentifier);
}

void DefaultVisitor::visitUseStatement(UseStatementAst *node)
{
    if (node->useNamespaceSequence)
    {
        const KDevPG::ListNode<UseNamespaceAst*> *__it = node->useNamespaceSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitVarExpression(VarExpressionAst *node)
{
    visitNode(node->printExpression);
    visitNode(node->generatorExpression);
    visitNode(node->generatorValueExpr);
    visitNode(node->variable);
    visitNode(node->newObject);
    visitNode(node->varExpressionNormal);
    visitNode(node->varExpressionArray);
    visitNode(node->arrayIndex);
}

void DefaultVisitor::visitVarExpressionArray(VarExpressionArrayAst *node)
{
    if (node->arrayValuesSequence)
    {
        const KDevPG::ListNode<ArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitVarExpressionNewObject(VarExpressionNewObjectAst *node)
{
    visitNode(node->classNameReference);
    visitNode(node->ctor);
}

void DefaultVisitor::visitVarExpressionNormal(VarExpressionNormalAst *node)
{
    visitNode(node->iife);
    visitNode(node->newObject);
    if (node->variablePropertiesSequence)
    {
        const KDevPG::ListNode<InstantiationAccessAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->expression);
    visitNode(node->encapsList);
    visitNode(node->variable);
    visitNode(node->scalar);
    if (node->issetVariableSequence)
    {
        const KDevPG::ListNode<VariableAst*> *__it = node->issetVariableSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
    visitNode(node->emptyExpression);
    visitNode(node->cloneCar);
    visitNode(node->closure);
}

void DefaultVisitor::visitVariable(VariableAst *node)
{
    visitNode(node->var);
    if (node->variablePropertiesSequence)
    {
        const KDevPG::ListNode<VariableObjectPropertyAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitVariableIdentifier(VariableIdentifierAst *)
{
}

void DefaultVisitor::visitVariableName(VariableNameAst *node)
{
    visitNode(node->name);
    visitNode(node->expr);
}

void DefaultVisitor::visitVariableObjectProperty(VariableObjectPropertyAst *node)
{
    visitNode(node->variableProperty);
}

void DefaultVisitor::visitVariableProperty(VariablePropertyAst *node)
{
    visitNode(node->variable);
    visitNode(node->objectProperty);
    visitNode(node->parameterList);
    visitNode(node->arrayIndex);
}

void DefaultVisitor::visitVariableWithoutObjects(VariableWithoutObjectsAst *node)
{
    visitNode(node->variable);
    if (node->offsetItemsSequence)
    {
        const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
        do
        {
            visitNode(__it->element);
            __it = __it->next;
        }
        while (__it != __end);
    }
}

void DefaultVisitor::visitWhileStatement(WhileStatementAst *node)
{
    visitNode(node->statement);
    visitNode(node->statements);
}


} // end of namespace Php

