Template/src/parsers/source_to_tst/implementations/expression.php - zetacomponents - Git at Google

 <?php
 /**
  * File containing the ezcTemplateExpressionExpressionParser class
  *
  * 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
  */
 /**
  * Parser for expressions.
  *
  * Parses as until it reaches the end of the expression. The expression is
  * parsed using type parsers and operator parsers. The end of the expression
  * is determined by calling atEnd() on the parent element parser.
  *
  * @package Template
  * @version //autogen//
  * @access private
  */
 class ezcTemplateExpressionSourceToTstParser extends ezcTemplateSourceToTstParser
 {
     /**
      * The current operator element if any.
      *
      * If you are interested in the result of the expression see $rootOperator
      * instead.
      *
      * @var ezcTemplateOperatorTstNode
      */
     public $currentOperator;

     /**
      * The root of the operator/operand tree which is the result of the expression parsing.
      * This will only be set after the parsing is succesful.
      *
      * @var ezcTemplateOperatorTstNode
      */
     public $rootOperator;


     /**
      * @var bool
      */
     public $foundArrayAppend = false;

     /**
      * Passes control to parent.
      *
      * @param ezcTemplateParser $parser
      * @param ezcTemplateSourceToTstParser $parentParser
      * @param ezcTemplateCursor $startCursor
      */
     function __construct( ezcTemplateParser $parser, /*ezcTemplateSourceToTstParser*/ $parentParser, /*ezcTemplateCursor*/ $startCursor )
     {
         parent::__construct( $parser, $parentParser, $startCursor );
         $this->currentOperator = null;
         $this->rootOperator = null;
         $this->minPrecedence = false;
     }

     /**
      * Parses the expression by using the various type and operator parsers.
      * The parsers has two states 'operand' and 'operator' which is switched
      * (often alternating) to correctly parse the next element. Each operation
      * also has a call to atEnd() on the parent element parser to figure out
      * if the end has been reached.
      *
      * When an operator is found it will call ezcTemplateParser::handleOperatorPrecedence()
      * to get proper order of operators in the tree.
      *
      * Look ahead: Operand
      *
      * @param ezcTemplateCursor $cursor
      * @return bool
      */
     protected function parseCurrent( ezcTemplateCursor $cursor )
     {
         $this->expressionStartCursor = clone $this->currentCursor;

         $this->findNextElement();

         $canDoAssignment = true;
         $this->foundArrayAppend = false;

         // If it has a preOperator, it must have an operand.
         $match = "";
         $type = "";
         if ( $this->parsePreModifyingOperator( $cursor, $match ) ) // Parse: --, ++
         {
             $canDoAssignment = false;
             if ( !$this->parseOperand( $cursor, array( "Variable" ), false ) )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_VARIABLE );
             }

             return true;
         }
         elseif ( $this->parsePreOperator( $cursor, $match ) ) // Parse: -, +, !
         {
             $canDoAssignment = false;
             if ( !$this->parseOperand( $cursor, array(), false ) )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_OPERAND );
             }
         }
         elseif ( $type = $this->parseOperand( $cursor, array(), true, true) ) // Only an operand?
         {
             if ( $type == "Variable" )
             {
                 // The expression stops after a post operator.
                 if ( $this->parsePostOperator( $cursor ) ) return true;
             }
         }
         else
         {
             // No, then it's not an expression.
             return false;
         }

         while ( true )
         {
             //  Operator check.
             $this->findNextElement();

             if ( $this->foundArrayAppend )
             {
                 // After an array append follows an assignment.
                 if ( !$this->parseAssignmentOperator( $cursor ) )
                 {
                     throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                        ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_ARRAY_APPEND_ASSIGNMENT );
                 }
             }
             else
             {
                 $operator = $this->parseOperator( $cursor, true /*$canDoAssignment*/ );
                 if ( !$operator )
                 {
                     return true;
                 }

                 if ( $type != "Variable" || $operator != "AssignmentOperator" )
                 {
                     $canDoAssignment = false;
                 }
             }

             // An operand is mandantory.
             $failedCursor = clone $cursor;
             $this->findNextElement();

             $this->foundArrayAppend = false;

             // Modifying operators are not allowed anymore.
             $this->parsePreOperator( $cursor, $match );

             $type = $this->parseOperand( $cursor, array(), false );
             if ( !$type )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_NON_MODIFYING_OPERAND );
             }
         }
     }

     /**
      * Makes sure the element list contains the root operator/operand from the
      * expression.
      *
      * @param ezcTemplateCursor $lastCursor
      * @param ezcTemplateCursor $cursor
      * @return void
      */
     protected function handleSuccessfulResult( ezcTemplateCursor $lastCursor, ezcTemplateCursor $cursor )
     {
         $rootOperator = $this->currentOperator;
         if ( $rootOperator instanceof ezcTemplateOperatorTstNode )
         {
             $rootOperator = $rootOperator->getRoot();
         }
         $this->rootOperator = $rootOperator;

         // Make sure element list contains the root
         $this->children = array( $this->rootOperator );
     }

     /**
      * Returns true if the type $name can be parsed. If the $allowedTypes array is not empty, the array should also have the element $name.
      *
      * @param string $name
      * @param array(string) $allowedTypes
      * @return bool
      */
     protected function canParseType( $name, $allowedTypes )
     {
         return $this->parseOptionalType( $name ) && ( sizeof( $allowedTypes ) == 0  || in_array( $name, $allowedTypes )  );
     }

     /**
      * Parse an operand.
      *
      * @param ezcTemplateCursor $cursor
      * @param array(string) $allowedTypes
      * @param bool $allowPostModification
      * @param bool $allowArrayAppend
      * @return string The type that is parsed.
      */
     protected function parseOperand( $cursor, $allowedTypes = array(), $allowPostModification = true, $allowArrayAppend = false )
     {
         $parsedType = false;
         if ( $this->canParseType( 'Literal', $allowedTypes ) )
         {
             $this->operatorRhsCheck( $this->currentOperator, $this->lastParser->element, $cursor );
             $this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );
             $parsedType = "Literal";
         }
         elseif ( $this->canParseType( 'Variable', $allowedTypes ) )
         {
             $type = $this->parser->symbolTable->retrieve( $this->lastParser->element->name );
             if ( $type === false )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $this->startCursor, $this->startCursor, $this->parser->symbolTable->getErrorMessage() );
             }

             $this->operatorRhsCheck( $this->currentOperator, $this->lastParser->element, $cursor );
             $this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );

             $this->findNextElement();

             while ( (($res = $this->parseArrayFetch( $cursor, $allowArrayAppend )) && $res[0]) || $this->parsePropertyFetch( $cursor) )
             {
                 $this->findNextElement();

                 if ( !$res[1] ) break;
             }

             $parsedType = "Variable";
         }
         elseif ( $this->canParseType( 'FunctionCall', $allowedTypes ) )
         {
             $this->operatorRhsCheck( $this->currentOperator, $this->lastParser->functionCall, $cursor );

             $this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->functionCall );
             $parsedType = "FunctionCall";
         }
         elseif ( $cursor->match( '(' ) && sizeof( $allowedTypes ) == 0 )
         {
             $expressionCursor = clone $cursor;
             $expressionParser = new ezcTemplateExpressionBlockSourceToTstParser( $this->parser, $this, null );
             $expressionParser->setAllCursors( $expressionCursor );
             $expressionParser->startCursor = clone $cursor;
             $expressionParser->startBracket = '(';
             $expressionParser->endBracket = ')';

             if ( !$this->parseRequiredType( $expressionParser ) )
             {
                 return false;
             }

             if ( !$cursor->match( ')' ) )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_ROUND_BRACKET_CLOSE );
             }

             $this->operatorRhsCheck( $this->currentOperator, $this->lastParser->block, $cursor );
             $this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->block );
             $parsedType = "Parenthesis";
         }

         return $parsedType;
     }

     /**
      * Parse a pre operator
      *
      * @param ezcTemplateCursor $cursor
      * @return bool
      */
     protected function parsePreOperator( $cursor )
     {
         // Check if we have -, ! operators
         $operator = null;
         // This will contain the name of the operator if it is found.
         $operatorName = false;

         $operatorSymbols = array( array( 1,
                                          array( '-', '!', '+' ) ) );
         foreach ( $operatorSymbols as $symbolEntry )
         {
             $chars = $cursor->current( $symbolEntry[0] );
             if ( in_array( $chars, $symbolEntry[1] ) )
             {
                 $operatorName = $chars;
                 break;
             }
         }

         if ( $operatorName !== false )
         {
             // Ignore the unary + operator.
             if ( $operatorName == "+" )
             {
                 $this->findNextElement();
                 $cursor->advance();
                 return true;
             }

             $operatorStartCursor = clone $cursor;
             $cursor->advance( strlen( $operatorName ) );
             $this->findNextElement();

             $operatorMap = array( '-' => 'NegateOperator',
                                   '!' => 'LogicalNegateOperator' );
             $operatorName = $operatorMap[$operatorName];

             $function = "ezcTemplate". $operatorName . "TstNode";
             $operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

             // If the min precedence has been reached we immediately stop parsing
             // and return a successful parse result
             if ( $this->minPrecedence !== false &&
                  $operator->precedence < $this->minPrecedence )
             {
                 $cursor->copy( $operatorStartCursor );
                 return true;
             }

             if ( $this->currentOperator === null )
             {
                 $this->currentOperator = $operator;
             }
             else
             {
                 // All pre operators should not sort precedence at this
                 // moment so just append it to the current operator.
                 $this->currentOperator->appendParameter( $operator );
                 $operator->parentOperator = $this->currentOperator;
                 $this->currentOperator = $operator;
             }

             $this->lastCursor->copy( $cursor );
             return true;
         }
         return false;
     }

     /**
      * Parse a pre operator
      *
      * @param ezcTemplateCursor $cursor
      * @return bool
      */
     protected function parsePostOperator( $cursor )
     {
         if ( $cursor->match( '++' ) )
         {
             $operatorStartCursor = clone $cursor;
             $operator = new ezcTemplatePostIncrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
         }
         elseif ( $cursor->match( '--' ) )
         {
             $operatorStartCursor = clone $cursor;
             $operator = new ezcTemplatePostDecrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
         }
         else
         {
             return false;
         }

         $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

         $this->lastCursor->copy( $cursor );

         return true;
     }

     /**
      * Parse a pre modifying operator
      *
      * @param ezcTemplateCursor $cursor
      * @return bool
      */
     protected function parsePreModifyingOperator( $cursor )
     {
         if ( $cursor->match( '++' ) )
         {
             $operatorStartCursor = clone $cursor;
             $operator = new ezcTemplatePreIncrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
         }
         elseif ( $cursor->match( '--' ) )
         {
             $operatorStartCursor = clone $cursor;
             $operator = new ezcTemplatePreDecrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
         }
         else
         {
             return false;
         }

         if ( $this->currentOperator === null )
         {
             $this->currentOperator = $operator;
         }
         else
         {
             // All pre operators should not sort precedence at this
             // moment so just append it to the current operator.
             $this->currentOperator->appendParameter( $operator );
             $operator->parentOperator = $this->currentOperator;
             $this->currentOperator = $operator;
         }

         $this->lastCursor->copy( $cursor );

         return true;
     }


     /**
      * Parse the array fetch
      *
      * @param ezcTemplateCursor $cursor
      * @param bool $allowArrayAppend
      * @return array(bool,bool) = Continue, repeat.
      */
     protected function parseArrayFetch( $cursor, $allowArrayAppend = false )
     {
         // Try the special array fetch operator
         $operator = null;
         while ( $cursor->match( '[' ) )
         {
             $this->findNextElement();

             if ( $allowArrayAppend && $cursor->match( "]" ) )
             {
                 $operator = new ezcTemplateArrayAppendOperatorTstNode( $this->parser->source, $this->startCursor, $cursor );
                 $this->foundArrayAppend = true;

                 $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );
                 $this->lastCursor = clone $cursor;

                 return array(true, false);
             }
             else
             {
                 $operatorStartCursor = clone $cursor;
                 if ( !$this->parseRequiredType( 'ArrayFetch' ) )
                 {
                     return array(false, true);
                 }

                 $this->findNextElement();
                 if ( !$cursor->match( "]" ) )
                 {
                     throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_SQUARE_BRACKET_CLOSE );
                 }

                 $operator = $this->lastParser->fetch;
             }

             // If the min precedence has been reached we immediately stop parsing
             // and return a successful parse result
             if ( $this->minPrecedence !== false &&
             $operator->precedence < $this->minPrecedence )
             {
                 $cursor->copy( $operatorStartCursor );
                 return array(true, true);
             }

             $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );
             $this->lastCursor = clone $cursor;

             $this->findNextElement();
         }

         return array(($operator !== null), true);
     }

     protected function parsePropertyFetch($cursor)
     {
         $operator = null;
         while ( $cursor->match( '->' ) )
         {
             $this->findNextElement();

             $operator = new ezcTemplatePropertyFetchOperatorTstNode( $this->parser->source, $this->startCursor, $cursor );

             if ( $this->canParseType( 'Variable' , array() ) )
             {
                 $type = $this->parser->symbolTable->retrieve( $this->lastParser->element->name );
                 if ( $type === false )
                 {
                     throw new ezcTemplateParserException( $this->parser->source, $this->lastParser->startCursor, $this->lastParser->startCursor, $this->parser->symbolTable->getErrorMessage() );
                 }
             }
             else if ( !$this->parseRequiredType( 'Identifier' ) )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                         ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_IDENTIFIER_OR_VARIABLE );
             }


             $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );


             $this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );

             $this->findNextElement();

             // $operator = $this->lastParser->value;
         }
         return $operator !== null;
     }

     /**
      * Parse assignment operator
      *
      * @param ezcTemplateCursor $cursor
      * @return bool
      */
     protected function parseAssignmentOperator( $cursor )
     {
         if ( $cursor->match( "=" ) )
         {
             $function = "ezcTemplateAssignmentOperatorTstNode";
             $operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

             $this->checkForValidOperator( $this->currentOperator, $operator, $cursor );

             $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

             return true;
         }

         return false;
     }

     /**
      * Parse operator
      *
      * @param ezcTemplateCursor $cursor
      * @param bool $canDoAssignment
      * @return bool
      */
     protected function parseOperator( $cursor, $canDoAssignment = true )
     {
         // Try som generic operators
         $operator = null;
         // This will contain the name of the operator if it is found.
         $operatorName = false;

         $operatorSymbols = array(
         array( 3,
         array( '===', '!==' ) ),
         array( 2,
         array(
         '==', '!=',
         '<=', '>=',
         '&&', '||',
         '+=', '-=', '*=', '/=', '.=', '%=',
         '..',
         '=>' /* To make sure that the expression ends when this token is found */,) ),
         array( 1,
         array( '+', '-', '.',
         '*', '/', '%',
         '<', '>', '=' ) ) );
         foreach ( $operatorSymbols as $symbolEntry )
         {
             $chars = $cursor->current( $symbolEntry[0] );
             if ( in_array( $chars, $symbolEntry[1] ) )
             {
                 $operatorName = $chars;
                 break;
             }
         }

         if ( $operatorName !== false && $operatorName == "=>" )
         {
             return false;
         }

         // Cannot do an assignment right now.
         if ( $operatorName == "=" && !$canDoAssignment)
         {
             return false;
         }


         if ( $operatorName !== false )
         {
             $operatorStartCursor = clone $cursor;
             $cursor->advance( strlen( $operatorName ) );

             $operatorMap = array( '+' => 'PlusOperator',
             '-' => 'MinusOperator',
             '.' => 'ConcatOperator',

             '*' => 'MultiplicationOperator',
             '/' => 'DivisionOperator',
             '%' => 'ModuloOperator',

             '==' => 'EqualOperator',
             '!=' => 'NotEqualOperator',

             '===' => 'IdenticalOperator',
             '!==' => 'NotIdenticalOperator',

             '<' => 'LessThanOperator',
             '>' => 'GreaterThanOperator',

             '<=' => 'LessEqualOperator',
             '>=' => 'GreaterEqualOperator',

             '&&' => 'LogicalAndOperator',
             '||' => 'LogicalOrOperator',

             '=' => 'AssignmentOperator',
             '+=' => 'PlusAssignmentOperator',
             '-=' => 'MinusAssignmentOperator',
             '*=' => 'MultiplicationAssignmentOperator',
             '/=' => 'DivisionAssignmentOperator',
             '.=' => 'ConcatAssignmentOperator',
             '%=' => 'ModuloAssignmentOperator',

             '..' => 'ArrayRangeOperator', );

             $requestedName = $operatorName;
             $operatorName = $operatorMap[$operatorName];

             $function = "ezcTemplate". $operatorName . "TstNode";
             $operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

             // If the min precedence has been reached we immediately stop parsing
             // and return a successful parse result
             if ( $this->minPrecedence !== false &&
             $operator->precedence < $this->minPrecedence )
             {
                 $cursor->copy( $operatorStartCursor );
                 return $operatorName;
             }

             $this->checkForValidOperator( $this->currentOperator, $operator, $operatorStartCursor );

             $this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

             $this->lastCursor->copy( $cursor );

             return $operatorName;
         }

         return false;
     }

     /**
      * Check whether the given operand can be the left hand side of the $operator.
      * For example: 4 = 5; is not allowed. But $a = 5 , and $a[0][0]->bla  is.
      *
      * @param ezcTemplateTstNode $lhs
      * @param ezcTemplateTstNode $op
      * @param ezcTemplateCursor $cursor
      * @throws ezcTemplateParserException if the check fails.
      * @return void
      */
     private function checkForValidOperator( $lhs, $op, $cursor )
     {
         if ( $op instanceof ezcTemplateModifyingOperatorTstNode)
         {
             if ( !( $lhs instanceof ezcTemplateVariableTstNode ||
                 $lhs instanceof ezcTemplateArrayAppendOperatorTstNode ||
                 $lhs instanceof ezcTemplateArrayFetchOperatorTstNode ||
                 $lhs instanceof ezcTemplatePropertyFetchOperatorTstNode ||
                 $lhs instanceof ezcTemplateModifyingOperatorTstNode ) )
             {
                 if ( $op instanceof ezcTemplateOperatorTstNode )
                 {
                     throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                         sprintf( ezcTemplateSourceToTstErrorMessages::MSG_LHS_IS_NOT_VARIABLE, $op->symbol ));
                 }
                 else
                 {
                     throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                         ezcTemplateSourceToTstErrorMessages::MSG_LHS_IS_NOT_VARIABLE_NO_SYMBOL );
                 }
             }

             if ( $lhs instanceof ezcTemplateModifyingOperatorTstNode )
             {
                 $this->checkForValidOperator( $lhs->parameters[1], $op, $cursor);
             }

             return;
         }

         if ( $lhs instanceof ezcTemplateModifyingBlockTstNode )
         {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                       ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_LHS_IS_MODIFYING_BLOCK );
         }

         return;
     }


     /**
      * @param ezcTemplateTstNode $op
      * @param ezcTemplateTstNode $rhs
      * @param ezcTemplateCursor $cursor
      *
      * @throws ezcTemplateParserException if the check fails.
      * @return void
      */
     private function operatorRhsCheck( $op, $rhs, $cursor )
     {
         if ( $rhs instanceof ezcTemplateModifyingBlockTstNode )
         {
             if ( $op instanceof ezcTemplateOperatorTstNode )
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                     sprintf( ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_RHS_IS_MODIFYING_BLOCK, $op->symbol ));
             }
             else
             {
                 throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
                     ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_IS_MODIFYING_BLOCK );
             }
         }
     }
 }

 ?>
	<?php
	/**
	* File containing the ezcTemplateExpressionExpressionParser class
	*
	* 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
	*/
	/**
	* Parser for expressions.
	*
	* Parses as until it reaches the end of the expression. The expression is
	* parsed using type parsers and operator parsers. The end of the expression
	* is determined by calling atEnd() on the parent element parser.
	*
	* @package Template
	* @version //autogen//
	* @access private
	*/
	class ezcTemplateExpressionSourceToTstParser extends ezcTemplateSourceToTstParser
	{
	/**
	* The current operator element if any.
	*
	* If you are interested in the result of the expression see $rootOperator
	* instead.
	*
	* @var ezcTemplateOperatorTstNode
	*/
	public $currentOperator;

	/**
	* The root of the operator/operand tree which is the result of the expression parsing.
	* This will only be set after the parsing is succesful.
	*
	* @var ezcTemplateOperatorTstNode
	*/
	public $rootOperator;


	/**
	* @var bool
	*/
	public $foundArrayAppend = false;

	/**
	* Passes control to parent.
	*
	* @param ezcTemplateParser $parser
	* @param ezcTemplateSourceToTstParser $parentParser
	* @param ezcTemplateCursor $startCursor
	*/
	function __construct( ezcTemplateParser $parser, /ezcTemplateSourceToTstParser/ $parentParser, /ezcTemplateCursor/ $startCursor )
	{
	parent::__construct( $parser, $parentParser, $startCursor );
	$this->currentOperator = null;
	$this->rootOperator = null;
	$this->minPrecedence = false;
	}

	/**
	* Parses the expression by using the various type and operator parsers.
	* The parsers has two states 'operand' and 'operator' which is switched
	* (often alternating) to correctly parse the next element. Each operation
	* also has a call to atEnd() on the parent element parser to figure out
	* if the end has been reached.
	*
	* When an operator is found it will call ezcTemplateParser::handleOperatorPrecedence()
	* to get proper order of operators in the tree.
	*
	* Look ahead: Operand
	*
	* @param ezcTemplateCursor $cursor
	* @return bool
	*/
	protected function parseCurrent( ezcTemplateCursor $cursor )
	{
	$this->expressionStartCursor = clone $this->currentCursor;

	$this->findNextElement();

	$canDoAssignment = true;
	$this->foundArrayAppend = false;

	// If it has a preOperator, it must have an operand.
	$match = "";
	$type = "";
	if ( $this->parsePreModifyingOperator( $cursor, $match ) ) // Parse: --, ++
	{
	$canDoAssignment = false;
	if ( !$this->parseOperand( $cursor, array( "Variable" ), false ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_VARIABLE );
	}

	return true;
	}
	elseif ( $this->parsePreOperator( $cursor, $match ) ) // Parse: -, +, !
	{
	$canDoAssignment = false;
	if ( !$this->parseOperand( $cursor, array(), false ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_OPERAND );
	}
	}
	elseif ( $type = $this->parseOperand( $cursor, array(), true, true) ) // Only an operand?
	{
	if ( $type == "Variable" )
	{
	// The expression stops after a post operator.
	if ( $this->parsePostOperator( $cursor ) ) return true;
	}
	}
	else
	{
	// No, then it's not an expression.
	return false;
	}

	while ( true )
	{
	// Operator check.
	$this->findNextElement();

	if ( $this->foundArrayAppend )
	{
	// After an array append follows an assignment.
	if ( !$this->parseAssignmentOperator( $cursor ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_ARRAY_APPEND_ASSIGNMENT );
	}
	}
	else
	{
	$operator = $this->parseOperator( $cursor, true /$canDoAssignment/ );
	if ( !$operator )
	{
	return true;
	}

	if ( $type != "Variable" \|\| $operator != "AssignmentOperator" )
	{
	$canDoAssignment = false;
	}
	}

	// An operand is mandantory.
	$failedCursor = clone $cursor;
	$this->findNextElement();

	$this->foundArrayAppend = false;

	// Modifying operators are not allowed anymore.
	$this->parsePreOperator( $cursor, $match );

	$type = $this->parseOperand( $cursor, array(), false );
	if ( !$type )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_NON_MODIFYING_OPERAND );
	}
	}
	}

	/**
	* Makes sure the element list contains the root operator/operand from the
	* expression.
	*
	* @param ezcTemplateCursor $lastCursor
	* @param ezcTemplateCursor $cursor
	* @return void
	*/
	protected function handleSuccessfulResult( ezcTemplateCursor $lastCursor, ezcTemplateCursor $cursor )
	{
	$rootOperator = $this->currentOperator;
	if ( $rootOperator instanceof ezcTemplateOperatorTstNode )
	{
	$rootOperator = $rootOperator->getRoot();
	}
	$this->rootOperator = $rootOperator;

	// Make sure element list contains the root
	$this->children = array( $this->rootOperator );
	}

	/**
	* Returns true if the type $name can be parsed. If the $allowedTypes array is not empty, the array should also have the element $name.
	*
	* @param string $name
	* @param array(string) $allowedTypes
	* @return bool
	*/
	protected function canParseType( $name, $allowedTypes )
	{
	return $this->parseOptionalType( $name ) && ( sizeof( $allowedTypes ) == 0 \|\| in_array( $name, $allowedTypes ) );
	}

	/**
	* Parse an operand.
	*
	* @param ezcTemplateCursor $cursor
	* @param array(string) $allowedTypes
	* @param bool $allowPostModification
	* @param bool $allowArrayAppend
	* @return string The type that is parsed.
	*/
	protected function parseOperand( $cursor, $allowedTypes = array(), $allowPostModification = true, $allowArrayAppend = false )
	{
	$parsedType = false;
	if ( $this->canParseType( 'Literal', $allowedTypes ) )
	{
	$this->operatorRhsCheck( $this->currentOperator, $this->lastParser->element, $cursor );
	$this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );
	$parsedType = "Literal";
	}
	elseif ( $this->canParseType( 'Variable', $allowedTypes ) )
	{
	$type = $this->parser->symbolTable->retrieve( $this->lastParser->element->name );
	if ( $type === false )
	{
	throw new ezcTemplateParserException( $this->parser->source, $this->startCursor, $this->startCursor, $this->parser->symbolTable->getErrorMessage() );
	}

	$this->operatorRhsCheck( $this->currentOperator, $this->lastParser->element, $cursor );
	$this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );

	$this->findNextElement();

	while ( (($res = $this->parseArrayFetch( $cursor, $allowArrayAppend )) && $res[0]) \|\| $this->parsePropertyFetch( $cursor) )
	{
	$this->findNextElement();

	if ( !$res[1] ) break;
	}

	$parsedType = "Variable";
	}
	elseif ( $this->canParseType( 'FunctionCall', $allowedTypes ) )
	{
	$this->operatorRhsCheck( $this->currentOperator, $this->lastParser->functionCall, $cursor );

	$this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->functionCall );
	$parsedType = "FunctionCall";
	}
	elseif ( $cursor->match( '(' ) && sizeof( $allowedTypes ) == 0 )
	{
	$expressionCursor = clone $cursor;
	$expressionParser = new ezcTemplateExpressionBlockSourceToTstParser( $this->parser, $this, null );
	$expressionParser->setAllCursors( $expressionCursor );
	$expressionParser->startCursor = clone $cursor;
	$expressionParser->startBracket = '(';
	$expressionParser->endBracket = ')';

	if ( !$this->parseRequiredType( $expressionParser ) )
	{
	return false;
	}

	if ( !$cursor->match( ')' ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_ROUND_BRACKET_CLOSE );
	}

	$this->operatorRhsCheck( $this->currentOperator, $this->lastParser->block, $cursor );
	$this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->block );
	$parsedType = "Parenthesis";
	}

	return $parsedType;
	}

	/**
	* Parse a pre operator
	*
	* @param ezcTemplateCursor $cursor
	* @return bool
	*/
	protected function parsePreOperator( $cursor )
	{
	// Check if we have -, ! operators
	$operator = null;
	// This will contain the name of the operator if it is found.
	$operatorName = false;

	$operatorSymbols = array( array( 1,
	array( '-', '!', '+' ) ) );
	foreach ( $operatorSymbols as $symbolEntry )
	{
	$chars = $cursor->current( $symbolEntry[0] );
	if ( in_array( $chars, $symbolEntry[1] ) )
	{
	$operatorName = $chars;
	break;
	}
	}

	if ( $operatorName !== false )
	{
	// Ignore the unary + operator.
	if ( $operatorName == "+" )
	{
	$this->findNextElement();
	$cursor->advance();
	return true;
	}

	$operatorStartCursor = clone $cursor;
	$cursor->advance( strlen( $operatorName ) );
	$this->findNextElement();

	$operatorMap = array( '-' => 'NegateOperator',
	'!' => 'LogicalNegateOperator' );
	$operatorName = $operatorMap[$operatorName];

	$function = "ezcTemplate". $operatorName . "TstNode";
	$operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

	// If the min precedence has been reached we immediately stop parsing
	// and return a successful parse result
	if ( $this->minPrecedence !== false &&
	$operator->precedence < $this->minPrecedence )
	{
	$cursor->copy( $operatorStartCursor );
	return true;
	}

	if ( $this->currentOperator === null )
	{
	$this->currentOperator = $operator;
	}
	else
	{
	// All pre operators should not sort precedence at this
	// moment so just append it to the current operator.
	$this->currentOperator->appendParameter( $operator );
	$operator->parentOperator = $this->currentOperator;
	$this->currentOperator = $operator;
	}

	$this->lastCursor->copy( $cursor );
	return true;
	}
	return false;
	}

	/**
	* Parse a pre operator
	*
	* @param ezcTemplateCursor $cursor
	* @return bool
	*/
	protected function parsePostOperator( $cursor )
	{
	if ( $cursor->match( '++' ) )
	{
	$operatorStartCursor = clone $cursor;
	$operator = new ezcTemplatePostIncrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
	}
	elseif ( $cursor->match( '--' ) )
	{
	$operatorStartCursor = clone $cursor;
	$operator = new ezcTemplatePostDecrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
	}
	else
	{
	return false;
	}

	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

	$this->lastCursor->copy( $cursor );

	return true;
	}

	/**
	* Parse a pre modifying operator
	*
	* @param ezcTemplateCursor $cursor
	* @return bool
	*/
	protected function parsePreModifyingOperator( $cursor )
	{
	if ( $cursor->match( '++' ) )
	{
	$operatorStartCursor = clone $cursor;
	$operator = new ezcTemplatePreIncrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
	}
	elseif ( $cursor->match( '--' ) )
	{
	$operatorStartCursor = clone $cursor;
	$operator = new ezcTemplatePreDecrementOperatorTstNode( $this->parser->source, clone $this->lastCursor, $cursor );
	}
	else
	{
	return false;
	}

	if ( $this->currentOperator === null )
	{
	$this->currentOperator = $operator;
	}
	else
	{
	// All pre operators should not sort precedence at this
	// moment so just append it to the current operator.
	$this->currentOperator->appendParameter( $operator );
	$operator->parentOperator = $this->currentOperator;
	$this->currentOperator = $operator;
	}

	$this->lastCursor->copy( $cursor );

	return true;
	}


	/**
	* Parse the array fetch
	*
	* @param ezcTemplateCursor $cursor
	* @param bool $allowArrayAppend
	* @return array(bool,bool) = Continue, repeat.
	*/
	protected function parseArrayFetch( $cursor, $allowArrayAppend = false )
	{
	// Try the special array fetch operator
	$operator = null;
	while ( $cursor->match( '[' ) )
	{
	$this->findNextElement();

	if ( $allowArrayAppend && $cursor->match( "]" ) )
	{
	$operator = new ezcTemplateArrayAppendOperatorTstNode( $this->parser->source, $this->startCursor, $cursor );
	$this->foundArrayAppend = true;

	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );
	$this->lastCursor = clone $cursor;

	return array(true, false);
	}
	else
	{
	$operatorStartCursor = clone $cursor;
	if ( !$this->parseRequiredType( 'ArrayFetch' ) )
	{
	return array(false, true);
	}

	$this->findNextElement();
	if ( !$cursor->match( "]" ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor, ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_SQUARE_BRACKET_CLOSE );
	}

	$operator = $this->lastParser->fetch;
	}

	// If the min precedence has been reached we immediately stop parsing
	// and return a successful parse result
	if ( $this->minPrecedence !== false &&
	$operator->precedence < $this->minPrecedence )
	{
	$cursor->copy( $operatorStartCursor );
	return array(true, true);
	}

	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );
	$this->lastCursor = clone $cursor;

	$this->findNextElement();
	}

	return array(($operator !== null), true);
	}

	protected function parsePropertyFetch($cursor)
	{
	$operator = null;
	while ( $cursor->match( '->' ) )
	{
	$this->findNextElement();

	$operator = new ezcTemplatePropertyFetchOperatorTstNode( $this->parser->source, $this->startCursor, $cursor );

	if ( $this->canParseType( 'Variable' , array() ) )
	{
	$type = $this->parser->symbolTable->retrieve( $this->lastParser->element->name );
	if ( $type === false )
	{
	throw new ezcTemplateParserException( $this->parser->source, $this->lastParser->startCursor, $this->lastParser->startCursor, $this->parser->symbolTable->getErrorMessage() );
	}
	}
	else if ( !$this->parseRequiredType( 'Identifier' ) )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	ezcTemplateSourceToTstErrorMessages::MSG_EXPECT_IDENTIFIER_OR_VARIABLE );
	}


	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );


	$this->currentOperator = $this->parser->handleOperand( $this->currentOperator, $this->lastParser->element );

	$this->findNextElement();

	// $operator = $this->lastParser->value;
	}
	return $operator !== null;
	}

	/**
	* Parse assignment operator
	*
	* @param ezcTemplateCursor $cursor
	* @return bool
	*/
	protected function parseAssignmentOperator( $cursor )
	{
	if ( $cursor->match( "=" ) )
	{
	$function = "ezcTemplateAssignmentOperatorTstNode";
	$operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

	$this->checkForValidOperator( $this->currentOperator, $operator, $cursor );

	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

	return true;
	}

	return false;
	}

	/**
	* Parse operator
	*
	* @param ezcTemplateCursor $cursor
	* @param bool $canDoAssignment
	* @return bool
	*/
	protected function parseOperator( $cursor, $canDoAssignment = true )
	{
	// Try som generic operators
	$operator = null;
	// This will contain the name of the operator if it is found.
	$operatorName = false;

	$operatorSymbols = array(
	array( 3,
	array( '===', '!==' ) ),
	array( 2,
	array(
	'==', '!=',
	'<=', '>=',
	'&&', '\|\|',
	'+=', '-=', '*=', '/=', '.=', '%=',
	'..',
	'=>' /* To make sure that the expression ends when this token is found */,) ),
	array( 1,
	array( '+', '-', '.',
	'*', '/', '%',
	'<', '>', '=' ) ) );
	foreach ( $operatorSymbols as $symbolEntry )
	{
	$chars = $cursor->current( $symbolEntry[0] );
	if ( in_array( $chars, $symbolEntry[1] ) )
	{
	$operatorName = $chars;
	break;
	}
	}

	if ( $operatorName !== false && $operatorName == "=>" )
	{
	return false;
	}

	// Cannot do an assignment right now.
	if ( $operatorName == "=" && !$canDoAssignment)
	{
	return false;
	}


	if ( $operatorName !== false )
	{
	$operatorStartCursor = clone $cursor;
	$cursor->advance( strlen( $operatorName ) );

	$operatorMap = array( '+' => 'PlusOperator',
	'-' => 'MinusOperator',
	'.' => 'ConcatOperator',

	'*' => 'MultiplicationOperator',
	'/' => 'DivisionOperator',
	'%' => 'ModuloOperator',

	'==' => 'EqualOperator',
	'!=' => 'NotEqualOperator',

	'===' => 'IdenticalOperator',
	'!==' => 'NotIdenticalOperator',

	'<' => 'LessThanOperator',
	'>' => 'GreaterThanOperator',

	'<=' => 'LessEqualOperator',
	'>=' => 'GreaterEqualOperator',

	'&&' => 'LogicalAndOperator',
	'\|\|' => 'LogicalOrOperator',

	'=' => 'AssignmentOperator',
	'+=' => 'PlusAssignmentOperator',
	'-=' => 'MinusAssignmentOperator',
	'*=' => 'MultiplicationAssignmentOperator',
	'/=' => 'DivisionAssignmentOperator',
	'.=' => 'ConcatAssignmentOperator',
	'%=' => 'ModuloAssignmentOperator',

	'..' => 'ArrayRangeOperator', );

	$requestedName = $operatorName;
	$operatorName = $operatorMap[$operatorName];

	$function = "ezcTemplate". $operatorName . "TstNode";
	$operator = new $function( $this->parser->source, clone $this->lastCursor, $cursor );

	// If the min precedence has been reached we immediately stop parsing
	// and return a successful parse result
	if ( $this->minPrecedence !== false &&
	$operator->precedence < $this->minPrecedence )
	{
	$cursor->copy( $operatorStartCursor );
	return $operatorName;
	}

	$this->checkForValidOperator( $this->currentOperator, $operator, $operatorStartCursor );

	$this->currentOperator = $this->parser->handleOperatorPrecedence( $this->currentOperator, $operator );

	$this->lastCursor->copy( $cursor );

	return $operatorName;
	}

	return false;
	}

	/**
	* Check whether the given operand can be the left hand side of the $operator.
	* For example: 4 = 5; is not allowed. But $a = 5 , and $a[0][0]->bla is.
	*
	* @param ezcTemplateTstNode $lhs
	* @param ezcTemplateTstNode $op
	* @param ezcTemplateCursor $cursor
	* @throws ezcTemplateParserException if the check fails.
	* @return void
	*/
	private function checkForValidOperator( $lhs, $op, $cursor )
	{
	if ( $op instanceof ezcTemplateModifyingOperatorTstNode)
	{
	if ( !( $lhs instanceof ezcTemplateVariableTstNode \|\|
	$lhs instanceof ezcTemplateArrayAppendOperatorTstNode \|\|
	$lhs instanceof ezcTemplateArrayFetchOperatorTstNode \|\|
	$lhs instanceof ezcTemplatePropertyFetchOperatorTstNode \|\|
	$lhs instanceof ezcTemplateModifyingOperatorTstNode ) )
	{
	if ( $op instanceof ezcTemplateOperatorTstNode )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	sprintf( ezcTemplateSourceToTstErrorMessages::MSG_LHS_IS_NOT_VARIABLE, $op->symbol ));
	}
	else
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	ezcTemplateSourceToTstErrorMessages::MSG_LHS_IS_NOT_VARIABLE_NO_SYMBOL );
	}
	}

	if ( $lhs instanceof ezcTemplateModifyingOperatorTstNode )
	{
	$this->checkForValidOperator( $lhs->parameters[1], $op, $cursor);
	}

	return;
	}

	if ( $lhs instanceof ezcTemplateModifyingBlockTstNode )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_LHS_IS_MODIFYING_BLOCK );
	}

	return;
	}


	/**
	* @param ezcTemplateTstNode $op
	* @param ezcTemplateTstNode $rhs
	* @param ezcTemplateCursor $cursor
	*
	* @throws ezcTemplateParserException if the check fails.
	* @return void
	*/
	private function operatorRhsCheck( $op, $rhs, $cursor )
	{
	if ( $rhs instanceof ezcTemplateModifyingBlockTstNode )
	{
	if ( $op instanceof ezcTemplateOperatorTstNode )
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	sprintf( ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_RHS_IS_MODIFYING_BLOCK, $op->symbol ));
	}
	else
	{
	throw new ezcTemplateParserException( $this->parser->source, $cursor, $cursor,
	ezcTemplateSourceToTstErrorMessages::MSG_OPERATOR_IS_MODIFYING_BLOCK );
	}
	}
	}
	}

	?>