/Template/src/parsers/ast_to_ast/implementations/ast_walker.php

<?php
/**
 * File containing the ezcTemplateAstWalker
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * @package Template
 * @version //autogen//
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 * @access private
 */
/**
 * The entire AST tree, doing nothing.
 * 
 * @package Template
 * @version //autogen//
 * @access private
 */
class ezcTemplateAstWalker implements ezcTemplateAstNodeVisitor
{

    /**
     * A stack that keeps the path of nodes to the current position.  The first element (0) contains the last 
     * executed node. The second element, the second last node, etc.
     *
     * @var array(ezcTemplateAstNode)
     */
    public $nodePath = array(); 


    /**
     * The amount of statements in the last, second last, etc. position / level.
     *
     * @var array(int)
     */
    public $statements = array();

    /**
     * The offset of the statements. Default it's 0. When a statement is inserted, the offset should also increase.
     *
     * @var array(int)
     */
    public $offset = array();

    /**
     * Constructs a new ezcTemplateAstWalker
     */
    public function __construct( )
    {
    }

    /**
     * Destructor
     */
    public function __destruct()
    {
    }

    /**
     * visitLiteralAstNode
     *
     * @param ezcTemplateLiteralAstNode  $type
     * @return void
     */
    public function visitLiteralAstNode( ezcTemplateLiteralAstNode $type )
    {
    }

    /**
     * visitLiteralArrayAstNode
     *
     * @param ezcTemplateLiteralArrayAstNode  $type
     * @return void
     */
    public function visitLiteralArrayAstNode( ezcTemplateLiteralArrayAstNode $type )
    {
    }


    /**
     * visitOutputAstNode
     *
     * @param ezcTemplateOutputAstNode  $type
     * @return void
     */
    public function visitOutputAstNode( ezcTemplateOutputAstNode $type )
    {
        array_unshift( $this->nodePath, $type );

        $this->acceptAndUpdate( $type->expression );

        array_shift( $this->nodePath );
    }

    /**
     * visitTypeCastAstNode
     *
     * @param ezcTemplateTypeCastAstNode  $node
     * @return void
     */
    public function visitTypeCastAstNode( ezcTemplateTypeCastAstNode $node )
    {
        array_unshift( $this->nodePath, $node );
        $this->acceptAndUpdate( $node->value );
        array_shift( $this->nodePath );
    }

    /**
     * visitConstantAstNode
     *
     * @param ezcTemplateConstantAstNode  $type
     * @return void
     */
    public function visitConstantAstNode( ezcTemplateConstantAstNode $type )
    {
    }

    /**
     * visitEolCommentAstNode
     *
     * @param ezcTemplateEolCommentAstNode  $comment
     * @return void
     */
    public function visitEolCommentAstNode( ezcTemplateEolCommentAstNode $comment )
    {
    }

    /**
     * visitBlockCommentAstNode
     *
     * @param ezcTemplateBlockCommentAstNode  $comment
     * @return void
     */
    public function visitBlockCommentAstNode( ezcTemplateBlockCommentAstNode $comment )
    {
    }

    /**
     * visitVariableAstNode
     *
     * @param ezcTemplateVariableAstNode  $var
     * @return void
     */
    public function visitVariableAstNode( ezcTemplateVariableAstNode $var )
    {
    }

    /**
     * visitDynamicVariableAstNode
     *
     * @param ezcTemplateDynamicVariableAstNode  $var
     * @return void
     */
    public function visitDynamicVariableAstNode( ezcTemplateDynamicVariableAstNode $var )
    {
        array_unshift( $this->nodePath, $var );
        $this->acceptAndUpdate( $var->nameExpression );
        array_shift( $this->nodePath );
    }

    /**
     * visitDynamicStringAstNode
     *
     * @param ezcTemplateDynamicStringAstNode  $dynamic
     * @return void
     */
    public function visitDynamicStringAstNode( ezcTemplateDynamicStringAstNode $dynamic )
    {
        throw new ezcTemplateInternalException( "TODO: dynamicstring Ast node , tree walker" );

        array_unshift( $this->nodePath, $dynamic );
        foreach ( $parameters as $parameter )
        {
            if ( !$parameter instanceof ezcTemplateLiteralAstNode )
            {
                $this->acceptAndUpdate( $parameter );
            }
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitArrayFetchOperatorAstNode
     *
     * @param ezcTemplateArrayFetchOperatorAstNode  $operator
     * @return void
     */
    public function visitArrayFetchOperatorAstNode( ezcTemplateArrayFetchOperatorAstNode $operator )
    {
        array_unshift( $this->nodePath, $operator );
        $parameters = $operator->getParameters();
        $count = count( $parameters );
        for ( $i = 0; $i < $count; ++$i )
        {
            $this->acceptAndUpdate( $operator->parameters[$i] );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitUnaryOperatorAstNode
     *
     * @param ezcTemplateOperatorAstNode  $operator
     * @return void
     */
    public function visitUnaryOperatorAstNode( ezcTemplateOperatorAstNode $operator )
    {
        $parameters = $operator->getParameters();
        if ( count( $parameters ) < $operator->minParameterCount )
        {
            throw new ezcTemplateInternalException( "The operator <" . get_class( $operator ) . " contains only " . count( $parameters ) . " parameters but should at least have {$operator->minParameterCount} parameters." );
        }

        array_unshift( $this->nodePath, $operator );

        $this->acceptAndUpdate( $operator->parameters[0] );
       
        array_shift( $this->nodePath );

    }

    /**
     * visitBinaryOperatorAstNode
     *
     * @param ezcTemplateOperatorAstNode  $operator
     * @return void
     */
    public function visitBinaryOperatorAstNode( ezcTemplateOperatorAstNode $operator )
    {
        $parameters = $operator->getParameters();
        if ( count( $parameters ) < $operator->minParameterCount )
        {
            throw new ezcTemplateInternalException( "The operator <" . get_class( $operator ) . " contains only " . count( $parameters ) . " parameters but should at least have {$operator->minParameterCount} parameters." );
        }

        array_unshift( $this->nodePath, $operator );
        $this->acceptAndUpdate( $operator->parameters[0] );
        $this->acceptAndUpdate( $operator->parameters[1] );
        array_shift( $this->nodePath );
    }

    /**
     * visitFunctionCallAstNode
     *
     * @param ezcTemplateFunctionCallAstNode  $fcall
     * @return void
     */
    public function visitFunctionCallAstNode( ezcTemplateFunctionCallAstNode $fcall )
    {
        array_unshift( $this->nodePath, $fcall );
        foreach ( $fcall->getParameters() as $i => $parameter )
        {
            $this->acceptAndUpdate( $fcall->parameters[$i] );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitBodyAstNode
     *
     * @param ezcTemplateBodyAstNode  $body
     * @return void
     */
    public function visitBodyAstNode( ezcTemplateBodyAstNode $body )
    {
        array_unshift( $this->nodePath, $body );
        array_unshift( $this->statements, 0);
        array_unshift( $this->offset, 0);

        $b = clone( $body );

        for( $i = 0; $i < sizeof( $b->statements ); $i++)
        {
            $this->statements[0] = $i;
            $this->acceptAndUpdate( $b->statements[$i]  );
        }

        $body = $b;

        array_shift( $this->offset );
        array_shift( $this->statements );
        array_shift( $this->nodePath );
    }

    /**
     * visitRootAstNode
     *
     * @param ezcTemplateRootAstNode $body
     * @return void
     */
    public function visitRootAstNode( ezcTemplateRootAstNode &$body )
    {
        array_unshift( $this->nodePath, $body );
        array_unshift( $this->statements, 0);
        array_unshift( $this->offset, 0);

        $b = clone( $body );

        for( $i = 0; $i < sizeof( $b->statements ); $i++)
        {
            $this->statements[0] = $i;
            $this->acceptAndUpdate( $b->statements[$i] );
        }

        // XXX Test this, this may be wrong.
        // $body = $b;

        array_shift( $this->offset );
        array_shift( $this->statements );
        array_shift( $this->nodePath );
    }


    /**
     * visitGenericStatementAstNode
     *
     * @param ezcTemplateGenericStatementAstNode  $statement
     * @return void
     */
    public function visitGenericStatementAstNode( ezcTemplateGenericStatementAstNode $statement )
    {
        array_unshift( $this->nodePath, $statement );

        $this->acceptAndUpdate( $statement->expression );

        array_shift( $this->nodePath );
    }

    /**
     * visitIfAstNode
     *
     * @param ezcTemplateIfAstNode  $if
     * @return void
     */
    public function visitIfAstNode( ezcTemplateIfAstNode $if )
    {
        array_unshift( $this->nodePath, $if );

        foreach ( $if->conditions as $i => $conditionBody )
        {
            $condition = $conditionBody->condition;
            if ( $condition !== null )
            {
                $this->acceptAndUpdate( $if->conditions[$i]->condition );
            }

            $this->acceptAndUpdate( $conditionBody->body );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitDynamicBlockAstNode
     *
     * @param ezcTemplateDynamicBlockAstNode  $statement
     * @return void
     */
    public function visitDynamicBlockAstNode( ezcTemplateDynamicBlockAstNode $statement )
    {
        array_unshift( $this->nodePath, $statement );

        $this->acceptAndUpdate( $statement->body );

        array_shift( $this->nodePath );
    }


    /**
     * Visits a code element containing while control structures.
     *
     * @param ezcTemplateWhileAstNode $while The code element containing the while control structure.
     * @return void
     */
    public function visitWhileAstNode( ezcTemplateWhileAstNode $while )
    {
        array_unshift( $this->nodePath, $while );
        $conditionBody = $while->conditionBody;

        $this->acceptAndUpdate( $conditionBody->condition );
        $this->acceptAndUpdate( $conditionBody->body );

        array_shift( $this->nodePath );
    }

    /**
     * visitForeachAstNode
     *
     * @param ezcTemplateForeachAstNode  $foreach
     * @return void
     */
    public function visitForeachAstNode( ezcTemplateForeachAstNode $foreach )
    {
        array_unshift( $this->nodePath, $foreach );

        $this->acceptAndUpdate( $foreach->arrayExpression );

        if ( $foreach->keyVariable !== null )
        {
            $this->acceptAndUpdate( $foreach->keyVariable );
        }

        $this->acceptAndUpdate( $foreach->valueVariable );
        $this->acceptAndUpdate( $foreach->body );

        array_shift( $this->nodePath );
    }

    /**
     * visitBreakAstNode
     *
     * @param ezcTemplateBreakAstNode  $break
     * @return void
     */
    public function visitBreakAstNode( ezcTemplateBreakAstNode $break )
    {
    }

    /**
     * visitContinueAstNode
     *
     * @param ezcTemplateContinueAstNode  $continue
     * @return void
     */
    public function visitContinueAstNode( ezcTemplateContinueAstNode $continue )
    {
    }

    /**
     * visitReturnAstNode
     *
     * @param ezcTemplateReturnAstNode  $return
     * @return void
     */
    public function visitReturnAstNode( ezcTemplateReturnAstNode $return )
    {
    }

    /**
     * visitRequireAstNode
     *
     * @param ezcTemplateRequireAstNode  $require
     * @return void
     */
    public function visitRequireAstNode( ezcTemplateRequireAstNode $require )
    {
    }

    /**
     * visitRequireOnceAstNode
     *
     * @param ezcTemplateRequireOnceAstNode  $require
     * @return void
     */
    public function visitRequireOnceAstNode( ezcTemplateRequireOnceAstNode $require )
    {
    }

    /**
     * visitIncludeAstNode
     *
     * @param ezcTemplateIncludeAstNode  $include
     * @return void
     */
    public function visitIncludeAstNode( ezcTemplateIncludeAstNode $include )
    {
    }

    /**
     * visitIncludeOnceAstNode
     *
     * @param ezcTemplateIncludeOnceAstNode  $include
     * @return void
     */
    public function visitIncludeOnceAstNode( ezcTemplateIncludeOnceAstNode $include )
    {
    }

    /**
     * visitSwitchAstNode
     *
     * @param ezcTemplateSwitchAstNode  $switch
     * @return void
     */
    public function visitSwitchAstNode( ezcTemplateSwitchAstNode $switch )
    {
        array_unshift( $this->nodePath, $switch );

        $this->acceptAndUpdate( $switch->expression );

        foreach ( $switch->cases as $key => $case )
        {
            $this->acceptAndUpdate( $case );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitCaseAstNode
     *
     * @param ezcTemplateCaseAstNode  $case
     * @return void
     */
    public function visitCaseAstNode( ezcTemplateCaseAstNode $case )
    {
        array_unshift( $this->nodePath, $case );
        $this->acceptAndUpdate( $case->match );
        $this->acceptAndUpdate( $case->body );
        array_shift( $this->nodePath );
    }

    /**
     * visitDefaultAstNode
     *
     * @param ezcTemplateDefaultAstNode  $default
     * @return void
     */
    public function visitDefaultAstNode( ezcTemplateDefaultAstNode $default )
    {
        array_unshift( $this->nodePath, $default );
        $this->acceptAndUpdate( $default->body );
        array_shift( $this->nodePath );
    }

    /**
     * visitConditionBodyAstNode
     *
     * @param ezcTemplateConditionBodyAstNode  $cond
     * @return void
     */
    public function visitConditionBodyAstNode( ezcTemplateConditionBodyAstNode $cond )
    {
    }

    /**
     * visitTryAstNode
     *
     * @param ezcTemplateTryAstNode  $try
     * @return void
     */
    public function visitTryAstNode( ezcTemplateTryAstNode $try )
    {
        array_unshift( $this->nodePath, $try );
        $try->body->accept( $this );
        $this->acceptAndUpdate( $try->body );

        foreach ( $try->catches as $key => $catch )
        {
            $this->acceptAndUpdate( $try->catches[$key] );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitCatchAstNode
     *
     * @param ezcTemplateCatchAstNode  $catch
     * @return void
     */
    public function visitCatchAstNode( ezcTemplateCatchAstNode $catch )
    {
        array_unshift( $this->nodePath, $catch );

        $this->acceptAndUpdate( $catch->variableExpression );
        $this->acceptAndUpdate( $catch->body );

        array_shift( $this->nodePath );
    }

    /**
     * visitEchoAstNode
     *
     * @param ezcTemplateEchoAstNode  $echo
     * @return void
     */
    public function visitEchoAstNode( ezcTemplateEchoAstNode $echo )
    {
        array_unshift( $this->nodePath, $echo );
        $outputList = $echo->getOutputList();
        foreach ( $outputList as $i => $output )
        {
            $this->acceptAndUpdate( $echo->outputList[$i] );
        }
        array_shift( $this->nodePath );
    }

    /**
     * visitPrintAstNode
     *
     * @param ezcTemplatePrintAstNode  $print
     * @return void
     */
    public function visitPrintAstNode( ezcTemplatePrintAstNode $print )
    {
        array_unshift( $this->nodePath, $print );
        $this->acceptAndUpdate( $print->expression );
        array_shift( $this->nodePath );
    }

    /**
     * visitIssetAstNode
     *
     * @param ezcTemplateIssetAstNode  $isset
     * @return void
     */
    public function visitIssetAstNode( ezcTemplateIssetAstNode $isset )
    {
    }

    /**
     * visitUnsetAstNode
     *
     * @param ezcTemplateUnsetAstNode  $unset
     * @return void
     */
    public function visitUnsetAstNode( ezcTemplateUnsetAstNode $unset )
    {
    }

    /**
     * visitEmptyAstNode
     *
     * @param ezcTemplateEmptyAstNode  $empty
     * @return void
     */
    public function visitEmptyAstNode( ezcTemplateEmptyAstNode $empty )
    {
        array_unshift( $this->nodePath, $empty );
        $this->acceptAndUpdate( $empty->expression );
        array_shift( $this->nodePath );
    }

    /**
     * visitParenthesisAstNode
     *
     * @param ezcTemplateParenthesisAstNode  $parenthesis
     * @return void
     */
    public function visitParenthesisAstNode( ezcTemplateParenthesisAstNode $parenthesis )
    {
        array_unshift( $this->nodePath, $parenthesis );
        $this->acceptAndUpdate( $parenthesis->expression );
        array_shift( $this->nodePath );
    }

    /**
     * visitCurlyBracesAstNode
     *
     * @param ezcTemplateCurlyBracesAstNode  $curly
     * @return void
     */
    public function visitCurlyBracesAstNode( ezcTemplateCurlyBracesAstNode $curly )
    {
        array_unshift( $this->nodePath, $curly );
        $this->acceptAndUpdate( $parenthesis->expression );
        array_shift( $this->nodePath );
    }

    /**
     * visitIdentifierAstNode
     *
     * @param ezcTemplateIdentifierAstNode  $node
     * @return void
     */
    public function visitIdentifierAstNode( ezcTemplateIdentifierAstNode $node )
    {
    }

    /**
     * visitNewAstNode
     *
     * @param ezcTemplateNewAstNode  $node
     * @return void
     */
    public function visitNewAstNode( ezcTemplateNewAstNode $node )
    {
    }

    /**
     * visitCloneAstNode
     *
     * @param ezcTemplateCloneAstNode  $node
     * @return void
     */
    public function visitCloneAstNode( ezcTemplateCloneAstNode $node )
    {
    }

    /**
     * visitPhpCodeAstNode
     *
     * @param ezcTemplatePhpCodeAstNode  $node
     * @return void
     */
    public function visitPhpCodeAstNode( ezcTemplatePhpCodeAstNode $node )
    {
    }

    /**
     * visitThrowExceptionAstNode
     *
     * @param ezcTemplateThrowExceptionAstNode  $node
     * @return void
     */
    public function visitThrowExceptionAstNode( ezcTemplateThrowExceptionAstNode $node )
    {
        array_unshift( $this->nodePath, $node );
        $this->acceptAndUpdate( $node->message );
        array_shift( $this->nodePath );
    }


    /**
     * visitNopAstNode
     *
     * @param ezcTemplateNopAstNode  $node
     * @return void
     */
    public function visitNopAstNode( ezcTemplateNopAstNode $node )
    {
    }

    /**
     * Internal function called to  call the accept function and change the given node.
     *
     * @param ezcTemplateAstNode $node  Notice that the parameter will be changed.
     * @return void
     */
    protected function acceptAndUpdate( ezcTemplateAstNode &$node )
    {
        $ret = $node->accept( $this );
        if ( $ret !== null ) $node = $ret;
    }
}
?>