/includes/Opl/Opt/Compiler/Class.php

<?php

/*

 *  OPEN POWER LIBS <http://www.invenzzia.org>

 *

 * This file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE. It is also available through

 * WWW at this URL: <http://www.invenzzia.org/license/new-bsd>

 *

 * Copyright (c) Invenzzia Group <http://www.invenzzia.org>

 * and other contributors. See website for details.

 *

 * $Id: Class.php 274 2009-12-29 10:17:48Z zyxist $

 */



	class Opt_Compiler_Class

	{

		// Opcodes

		const OP_VARIABLE = 1;

		const OP_LANGUAGE_VAR = 2;

		const OP_STRING = 4;

		const OP_NUMBER = 8;

		const OP_ARRAY = 16;

		const OP_OBJECT = 32;

		const OP_IDENTIFIER = 64;

		const OP_OPERATOR = 128;

		const OP_POST_OPERATOR = 256;

		const OP_PRE_OPERATOR = 512;

		const OP_ASSIGN = 1024;

		const OP_NULL = 2048;

		const OP_SQ_BRACKET = 4096;

		const OP_SQ_BRACKET_E = 8192;

		const OP_FUNCTION = 16384;

		const OP_METHOD = 32768;

		const OP_BRACKET = 65536;

		const OP_CLASS = 131072;

		const OP_CALL = 262144;

		const OP_FIELD = 524288;

		const OP_EXPRESSION = 1048576;

		const OP_OBJMAN = 2097152;

		const OP_BRACKET_E = 4194304;

		const OP_TU = 8388608;

		const OP_CURLY_BRACKET = 16777216;

		

		const ESCAPE_ON = true;

		const ESCAPE_OFF = false;

		const ESCAPE_BOTH = 2;

	

	

		// Current compilation

		protected $_template = NULL;

		protected $_attr = array();

		protected $_stack = NULL;

		protected $_node = NULL;

		

		static protected $_recursionDetector = NULL;

		

		// Compiler info

		protected $_tags = array();

		protected $_attributes = array();

		protected $_conversions = array();

		protected $_processors = array();

		protected $_dependencies = array();

		

		// OPT parser info

		protected $_tpl;

		protected $_instructions;

		protected $_namespaces;

		protected $_functions;

		protected $_classes;

		protected $_blocks;

		protected $_components;

		protected $_tf;

		protected $_entities;

		protected $_formnatInfo;

		protected $_formats = array();

		protected $_formatObj = array();

		protected $_inheritance;

		

		// Regular expressions

		private $_rCDataExpression = '/(\<\!\[CDATA\[|\]\]\>)/msi';

		private $_rCommentExpression = '/(\<\!\-\-|\-\-\>)/si';

		private $_rCommentSplitExpression = '/(\<\!\-\-(.*?)\-\-\>)/si';

		private $_rOpeningChar = '[a-zA-Z\:\_]';

		private $_rNameChar = '[a-zA-Z0-9\:\.\_\-]';

		private $_rNameExpression;

		private $_rXmlTagExpression;

		private $_rTagExpandExpression;

		private $_rQuirksTagExpression = '';

		private $_rExpressionTag = '/(\{([^\}]*)\})/msi';

		private $_rAttributeTokens = '/(?:[^\=\"\'\s]+|\=|\"|\'|\s)/x';

		private $_rPrologTokens = '/(?:[^\=\"\'\s]+|\=|\'|\"|\s)/x';

		private $_rModifiers = 'si';

		private $_rXmlHeader = '/(\<\?xml.+\?\>)/msi';

		private $_rProlog = '/\<\?xml(.+)\?\>|/msi';

		private $_rEncodingName = '/[A-Za-z]([A-Za-z0-9.\_]|\-)*/si';

		

		private $_rBacktickString = '`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`';

		private $_rSingleQuoteString = '\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'';

		private $_rHexadecimalNumber = '\-?0[xX][0-9a-fA-F]+';

		private $_rDecimalNumber = '[0-9]+\.?[0-9]*';

		private $_rLanguageVar = '\$[a-zA-Z0-9\_]+@[a-zA-Z0-9\_]+';

		private $_rVariable = '(\$|@)[a-zA-Z0-9\_\.]*';

		private $_rOperators = '\-\>|!==|===|==|!=|\=\>|<>|<<|>>|<=|>=|\&\&|\|\||\(|\)|,|\!|\^|=|\&|\~|<|>|\||\%|\+\+|\-\-|\+|\-|\*|\/|\[|\]|\.|\:\:|\{|\}|\'|\"|';

		private $_rIdentifier = '[a-zA-Z\_]{1}[a-zA-Z0-9\_\.]*';

		private $_rLanguageVarExtract = '\$([a-zA-Z0-9\_]+)@([a-zA-Z0-9\_]+)';



		// Help fields

		private $_charset = null;

		private $_translationConversion = null;

		private $_initialMemory = null;

		private $_comments = 0;

		private $_standalone = false;

		private $_dynamicBlocks = null;

		

		static private $_templates = array();



		/**

		 * Creates a new instance of the template compiler. The compiler can

		 * be created, using the settings from the main OPT class or another

		 * compiler.

		 *

		 * @param Opt_Class|Opt_Compiler_Class $tpl The initial object.

		 */

		public function __construct($tpl)

		{

			if($tpl instanceof Opt_Class)

			{

				$this->_tpl = $tpl;

				$this->_namespaces = $tpl->_getList('_namespaces');

				$this->_classes = $tpl->_getList('_classes');

				$this->_functions = $tpl->_getList('_functions');

				$this->_components = $tpl->_getList('_components');

				$this->_blocks = $tpl->_getList('_blocks');

				$this->_phpFunctions = $tpl->_getList('_phpFunctions');

				$this->_formats = $tpl->_getList('_formats');

				$this->_tf = $tpl->_getList('_tf');

				$this->_entities = $tpl->_getList('_entities');

				$this->_charset = strtoupper($tpl->charset);

				

				// Create the processors and call their configuration method in the constructors.

				$instructions = $tpl->_getList('_instructions');

				foreach($instructions as $instructionClass)

				{

					$obj = new $instructionClass($this, $tpl);

					$this->_processors[$obj->getName()] = $obj;

					

					// Add the tags and attributes registered by this processor.

					foreach($obj->getInstructions() as $item)

					{

						$this->_instructions[$item] = $obj;

					}

					foreach($obj->getAttributes() as $item)

					{

						$this->_attributes[$item] = $obj;

					}

				}

			}

			elseif($tpl instanceof Opt_Compiler_Class)

			{

				// Simply import the data structures from that compiler.

				$this->_tpl = $tpl->_tpl;

				$this->_namespaces = $tpl->_namespaces;

				$this->_classes = $tpl->_classes;

				$this->_functions = $tpl->_functions;

				$this->_components = $tpl->_components;

				$this->_blocks = $tpl->_blocks;

				$this->_inheritance = $tpl->_inheritance;

				$this->_formatInfo = $tpl->_formatInfo;

				$this->_formats = $tpl->_formats;

				$this->_tf = $tpl->_tf;

				$this->_processor = $tpl->_processors;

				$this->_instructions = $tpl->_instructions;

				$this->_attributes = $tpl->_attributes;

				$this->_charset = $tpl->_charset;

				$this->_entities = $tpl->_entities;

				$tpl = $this->_tpl;

			}

			

			if($tpl->unicodeNames)

			{

				// Register unicode name regular expressions

				$this->_rOpeningChar = '(\p{Lu}|\p{Ll}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Nl}|\_|\:)';

				$this->_rNameChar = '(\p{Lu}|\p{Ll}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Nl}|\p{Mc}|\p{Me}|\p{Mn}|\p{Lm}|\p{Nd}|\_|\:|\.|\-)';

				$this->_rModifiers = 'msiu';

			}

			

			// Register the rest of the expressions

			$this->_rNameExpression = '/('.$this->_rOpeningChar.'?'.$this->_rNameChar.'*)/'.$this->_rModifiers;

			$this->_rXmlTagExpression = '/(\<((\/)?('.$this->_rOpeningChar.'?'.$this->_rNameChar.'*)( [^\<\>]*)?(\/)?)\>)/'.$this->_rModifiers;

			$this->_rTagExpandExpression = '/^(\/)?('.$this->_rOpeningChar.'?'.$this->_rNameChar.'*)( [^\<\>]*)?(\/)?$/'.$this->_rModifiers;

			

			

			$this->_rQuirksTagExpression = '/(\<((\/)?(('.implode('|', $this->_namespaces).')\:'.$this->_rNameChar.'*)( [^\<\>]+)?(\/)?)\>)/'.$this->_rModifiers;

			// We've just thrown the performance away by loading the compiler, so this won't make things worse

			// but the user may be happy :). However, don't show this message, if we are in the performance mode.

			if(!is_writable($tpl->compileDir) && $tpl->_compileMode != Opt_Class::CM_PERFORMANCE)

			{

				throw new Opt_FilesystemAccess_Exception('compilation', 'writeable');

			}



			// If the debug console is active, preload the XML tree classes.

			// Without it, the debug console would show crazy things about the memory usage.

			if($this->_tpl->debugConsole && !class_exists('Opt_Xml_Root'))

			{

				Opl_Loader::load('Opt_Xml_Root');

				Opl_Loader::load('Opt_Xml_Text');

				Opl_Loader::load('Opt_Xml_Cdata');

				Opl_Loader::load('Opt_Xml_Element');

				Opl_Loader::load('Opt_Xml_Attribute');

				Opl_Loader::load('Opt_Xml_Expression');

				Opl_Loader::load('Opt_Xml_Prolog');

				Opl_Loader::load('Opt_Xml_Dtd');

				Opl_Loader::load('Opt_Format_Array');

			}

		} // end __construct();



		/**

		 * Allows to clone the original compiler, creating new instruction

		 * processors for the new instance.

		 */

		public function __clone()

		{

			$this->_processors = array();

			$this->_tags = array();

			$this->_attributes = array();

			$this->_conversions = array();

			$instructions = $this->_tpl->_getList('_instructions');

			$cnt = sizeof($instructions);

			for($i = 0; $i < $cnt; $i++)

			{

				$obj = new $instructions[$i]($this, $tpl);	

				$this->_processors[$obj->getName()] = $obj;

			}

		} // end __clone();

	

		/*

		 * General purpose tools and utilities

		 */



		/**

		 * Returns the currently processed template file name.

		 *

		 * @static

		 * @return String The currently processed template name

		 */

		static public function getCurrentTemplate()

		{

			return end(self::$_templates);

		} // end getCurrentTemplate();



		/**

		 * Cleans the compiler state after the template compilation.

		 * It is necessary in the exception processing - if the exception

		 * is thrown in the middle of the compilation, the compiler becomes

		 * useless, because it is locked. The compilation algorithm automatically

		 * filters the exceptions, cleans the compiler state and throws the captured

		 * exceptions again, to the script.

		 *

		 * @static

		 */

		static public function cleanCompiler()

		{

			self::$_recursionDetector = null;

			self::$_templates = array();

		} // end cleanCompiler();



		/**

		 * Returns the value of the compiler state variable or

		 * NULL if the variable is not set.

		 *

		 * @param String $name Compiler variable name

		 * @return Mixed The compiler variable value.

		 */

		public function get($name)

		{

			if(!isset($this->_attr[$name]))

			{

				return NULL;

			}

			return $this->_attr[$name];

		} // end get();



		/**

		 * Creates or modifies the compiler state variable.

		 *

		 * @param String $name The name

		 * @param Mixed $value The value

		 */

		public function set($name, $value)

		{

			$this->_attr[$name] = $value;

		} // end set();



		/**

		 * Adds the escaping formula to the specified expression using the current escaping

		 * rules:

		 *

		 * 1. The $status variable.

		 * 2. The current template settings.

		 * 3. The OPT settings.

		 *

		 * @param String $expression The PHP expression to be escaped.

		 * @param Boolean $status The status of escaping for this expression or NULL, if not set.

		 * @return String The expression with the escaping formula added, if necessary.

		 */

		public function escape($expression, $status = null)

		{

			// OPT Configuration

			$escape = $this->_tpl->escape;

			

			// Template configuration

			if(!is_null($this->get('escaping')))

			{

				$escape = ($this->get('escaping') == true ? true : false);

			}

			

			// Expression settings

			if(!is_null($status))

			{

				$escape = ($status == true ? true : false);

			}

			

			if($escape)

			{

				// The user may define a custom escaping function

				if($this->isFunction('escape'))

				{

					if(strpos($this->_functions['escape'], '#', 0) !== false)

					{

						throw new Opt_InvalidArgumentFormat_Exception('escape', 'escape');

					}

					return $this->_functions['escape'].'('.$expression.')';

				}

				return 'htmlspecialchars('.$expression.')';

			}

			return $expression;

		} // end escape();



		/**

		 * Returns the format object for the specified variable.

		 *

		 * @param String $variable The variable identifier.

		 * @param Boolean $restore optional Whether to load a previously created format object (false) or to create a new one.

		 * @return Opt_Compiler_Format The format object.

		 */

		public function getFormat($variable, $restore = false)

		{

			$hc = $this->_tpl->defaultFormat;

			if(isset($this->_formatInfo[$variable]))

			{

				$hc = $this->_formatInfo[$variable];

			}

			if($restore && isset($this->_formatObj[$hc]))

			{

				return $this->_formatObj[$hc];

			}

			

			$top = $this->createFormat($variable, $hc);

			if($restore)

			{

				$this->_formatObj[$hc] = $top;

			}

			return $top;

		} // end getFormat();



		/**

		 * Creates a format object for the specified description string.

		 *

		 * @param String $variable The variable name (for debug purposes)

		 * @param String $hc The description string.

		 * @return Opt_Compiler_Format The newly created format object.

		 */

		public function createFormat($variable, $hc)

		{

			// Decorate the objects, if necessary

			$expanded = explode('/', $hc);

			$obj = null;

			foreach($expanded as $class)

			{

				if(!isset($this->_formats[$class]))

				{

					throw new Opt_FormatNotFound_Exception($variable, $class);

				}

				$hcName = $this->_formats[$class];

				if(!is_null($obj))

				{

					$obj->decorate($obj2 = new $hcName($this->_tpl, $this));

					$obj = $obj2;

				}

				else

				{

					$top = $obj = new $hcName($this->_tpl, $this, $hc);

				}

			}

			return $top;

		} // end createFormat();



		/**

		 * Allows to export the list of variables and their data formats to

		 * the template compiler.

		 *

		 * @param Array $list An associative array of pairs "variable => format description"

		 */

		public function setFormatList(Array $list)

		{

			$this->_formatInfo = $list;

		} // end setFormatList();



		/**

		 * Converts the specified item into another string using one of the

		 * registered patterns. If the pattern is not found, the method returns

		 * the original item unmodified.

		 *

		 * @param String $item The item to be converted.

		 * @return String

		 */

		public function convert($item)

		{

			// the converter allows to convert one name into another and keep it, if there is no

			// conversion pattern. Used in connection with sections + snippets.

			if(isset($this->_conversions[$item]))

			{

				return $this->_conversions[$item];

			}

			return $item;

		} // end convert();



		/**

		 * Creates a new conversion pattern. The string $from will be converted

		 * into $to.

		 *

		 * @param String $from The original string

		 * @param String $to The new string

		 */

		public function setConversion($from, $to)

		{

			$this->_conversions[$from] = $to;

		} // end setConversion();



		/**

		 * Removes the conversion pattern from the compiler memory.

		 *

		 * @param String $from The original string.

		 * @return Boolean

		 */

		public function unsetConversion($from)

		{

			if(isset($this->_conversions[$from]))

			{

				unset($this->_conversions[$from]);

				return true;

			}

			return false;

		} // end unsetConversion();



		/**

		 * Registers the dynamic inheritance rules for the templates. The

		 * array taken as a parameter must be an associative array of pairs

		 * 'extending' => 'extended' file names.

		 *

		 * @param Array $inheritance The list of inheritance rules.

		 */

		public function setInheritance(Array $inheritance)

		{

			$this->_inheritance = $inheritance;

		} // end setInheritance();



		/**

		 * Parses the entities in the specified text.

		 *

		 * @param String $text The original text

		 * @return String

		 */

		public function parseEntities($text)

		{

			return preg_replace_callback('/\&(([a-zA-Z\_\:]{1}[a-zA-Z0-9\_\:\-\.]*)|(\#((x[a-fA-F0-9]+)|([0-9]+))))\;/', array($this, '_decodeEntity'), $text);

		//	return htmlspecialchars_decode(str_replace(array_keys($this->_entities), array_values($this->_entities), $text));

		} // end parseEntities();



		/**

		 * Replaces only OPT-specific entities &lb; and &rb; to the corresponding

		 * characters.

		 *

		 * @param String $text Input text

		 * @return String output text

		 */

		public function parseShortEntities($text)

		{

			return str_replace(array('&lb;', '&rb;'), array('{', '}'), $text);

		} // end parseShortEntities();



		/**

		 * Replaces the XML special characters back to entities with smart ommiting of &

		 * that already creates an entity.

		 *

		 * @param String $text Input text.

		 * @return String Output text.

		 */

		public function parseSpecialChars($text)

		{

			return htmlspecialchars($text);

			return preg_replace_callback('/(\&\#?[a-zA-Z0-9]*\;)|\<|\>|\"|\&/', array($this, '_entitize'), $text);

		} // end parseSpecialChars();



		/**

		 * Returns 'true', if the argument is a valid identifier. An identifier

		 * must begin with a letter or underscore, and later, the numbers are also

		 * allowed.

		 *

		 * @param String $id The tested string

		 * @return Boolean

		 */

		public function isIdentifier($id)

		{

			return preg_match($this->_rEncodingName, $id);

		} // end isIdentifier();



		/**

		 * Checks whether the specified tag name is registered as an instruction.

		 * Returns its processor in case of success or NULL.

		 *

		 * @param String $tag The tag name (with the namespace)

		 * @return Opt_Compiler_Processor|NULL The processor that registered this tag.

		 */

		public function isInstruction($tag)

		{

			if(isset($this->_instructions[$tag]))

			{

				return $this->_instructions[$tag];

			}

			return NULL;

		} // end isInstruction();



		/**

		 * Returns true, if the argument is the name of an OPT attribute.

		 *

		 * @param String $tag The attribute name

		 * @return Boolean

		 */

		public function isOptAttribute($tag)

		{

			if(isset($this->_attributes[$tag]))

			{

				return $this->_attributes[$tag];

			}

			return NULL;

		} // end isOptAttribute();



		/**

		 * Returns true, if the argument is the OPT function name.

		 *

		 * @param String $name The function name

		 * @return Boolean

		 */

		public function isFunction($name)

		{

			if(isset($this->_functions[$name]))

			{

				return $this->_functions[$name];

			}

			return NULL;

		} // end isFunction();



		/**

		 * Returns true, if the argument is the name of the class

		 * accepted by OPT.

		 *

		 * @param String $id The class name.

		 * @return Boolean

		 */

		public function isClass($id)

		{

			if(isset($this->_classes[$id]))

			{

				return $this->_classes[$id];

			}

			return NULL;

		} // end isClass();



		/**

		 * Returns true, if the argument is the name of the namespace

		 * processed by OPT.

		 *

		 * @param String $ns The namespace name

		 * @return Boolean

		 */

		public function isNamespace($ns)

		{

			return in_array($ns, $this->_namespaces);

		} // end isNamespace();



		/**

		 * Returns true, if the argument is the name of the component tag.

		 * @param String $component The component tag name

		 * @return Boolean

		 */

		public function isComponent($component)

		{

			return isset($this->_components[$component]);

		} // end isComponent();



		/**

		 * Returns true, if the argument is the name of the block tag.

		 * @param String $block The block tag name.

		 * @return Boolean

		 */

		public function isBlock($block)

		{

			return isset($this->_blocks[$block]);

		} // end isComponent();



		/**

		 * Returns true, if the argument is the processor name.

		 *

		 * @param String $name The instruction processor name

		 * @return Boolean

		 */

		public function isProcessor($name)

		{

			if(!isset($this->_processors[$name]))

			{

				return NULL;

			}

			return $this->_processors[$name];

		} // end isProcessor();



		/**

		 * Returns the processor object with the specified name. If

		 * the processor does not exist, it generates an exception.

		 *

		 * @param String $name The processor name

		 * @return Opt_Compiler_Processor

		 */

		public function processor($name)

		{

			if(!isset($this->_processors[$name]))

			{

				throw new Opt_ObjectNotExists_Exception('processor', $name);

			}

			return $this->_processors[$name];

		} // end processor();



		/**

		 * Returns the component class name assigned to the specified

		 * XML tag. If the component class is not registered, it throws

		 * an exception.

		 *

		 * @param String $name The component XML tag name.

		 * @return Opt_Component_Interface

		 */

		public function component($name)

		{

			if(!isset($this->_components[$name]))

			{

				throw new Opt_ObjectNotExists_Exception('component', $name);

			}

			return $this->_components[$name];

		} // end component();



		/**

		 * Returns the block class name assigned to the specified

		 * XML tag. If the block class is not registered, it throws

		 * an exception.

		 *

		 * @param String $name The block XML tag name.

		 * @return Opt_Block_Interface

		 */

		public function block($name)

		{

			if(!isset($this->_blocks[$name]))

			{

				throw new Opt_ObjectNotExists_Exception('block', $name);

			}

			return $this->_blocks[$name];

		} // end block();



		/**

		 * Returns the template name that is inherited by the template '$name'

		 *

		 * @param String $name The "current" template file name

		 * @return String

		 */

		public function inherits($name)

		{

			if(isset($this->_inheritance[$name]))

			{

				return $this->_inheritance[$name];

			}

			return NULL;

		} // end inherits();



		/**

		 * Adds the template file name to the dependency list of the currently

		 * compiled file, so that it could be checked for modifications during

		 * the execution.

		 *

		 * @param String $template The template file name.

		 */

		public function addDependantTemplate($template)

		{

			if(in_array($template, $this->_dependencies))

			{

				$exception = new Opt_InheritanceRecursion_Exception($template);

				$exception->setData($this->_dependencies);

				throw $exception;

			}

			

			$this->_dependencies[] = $template;

		} // end addDependantTemplate();



		/**

		 * Imports the dependencies from another compiler object and adds them

		 * to the actual dependency list.

		 *

		 * @param Opt_Compiler_Class $compiler Another compiler object.

		 */

		public function importDependencies(Opt_Compiler_Class $compiler)

		{

			$this->_dependencies = array_merge($this->_dependencies, $compiler->_dependencies);

		} // end importDependencies();



		/*

		 * Internal tools and utilities

		 */



		/**

		 * Compiles the attribute part of the opening tag and extracts the tag

		 * attributes to an array. Moreover, it performs the entity conversion

		 * to the corresponding characters.

		 *

		 * @internal

		 * @param String $attrList The attribute list string

		 * @param string $tagName The tag name for debug purposes

		 * @return Array The list of attributes with the values.

		 */

		protected function _compileAttributes($attrList, $tagName = '')

		{

			// Tokenize the list

			preg_match_all($this->_rAttributeTokens, $attrList, $match, PREG_SET_ORDER);

			

			$size = sizeof($match);

			$result = array();

			for($i = 0; $i < $size; $i++)

			{

				/**

				 * The algorithm scans the tokens on the list and determines, where

				 * the beginning and the end of the attribute is. We do not use the

				 * regular expressions, because they are not able to capture the

				 * invalid content between the expressions.

				 *

				 * The sub-loops can modify the iteration variable to skip the found

				 * elements, white characters etc. This means that the main loop

				 * does only a few iteration number, equal approximately the number

				 * of attributes.

				 */

				if(!ctype_space($match[$i][0]))

				{

					

					if(!preg_match($this->_rNameExpression, $match[$i][0]))

					{

						return false;

					}

					

					$vret = false;

					$name = $match[$i][0];



					if(substr_count($name, ':') > 1)

					{

						throw new Opt_InvalidNamespace_Exception($name);

					}



					$value = null;

					for($i++; ctype_space($match[$i][0]) && $i < $size; $i++){}

					

					if($match[$i][0] != '=')

					{

						if($this->_tpl->htmlAttributes)

						{

							$result[$name] = $name;

							continue;

						}

						else

						{

							return false;

						}

					}

					// Look for the attribute value start

					for($i++; ctype_space($match[$i][0]) && $i < $size; $i++){}

				

					if($match[$i][0] != '"' && $match[$i][0] != '\'')

					{

						return false;

					}



					// Save the delimiter, because we will use it to make the error checking

					$delimiter = $match[$i][0];



					$value = '';

					for($i++; $i < $size; $i++)

					{

						if($match[$i][0] == $delimiter)

						{

							break;

						}

						$value .= $match[$i][0];

					}

					if(!isset($match[$i][0]))

					{

						return false;

					}

					if($match[$i][0] != $delimiter)

					{

						return false;

					}

					// We return the decoded attribute values, because they are

					// stored without the entities.

					if(isset($result[$name]))

					{

						throw new Opt_XmlDuplicatedAttribute_Exception($name, $tagName);

					}

					$result[$name] = htmlspecialchars_decode($value);

				}

			}

			return $result;

		} // end _compileAttributes();



		/**

		 * Parses the XML prolog and returns its attributes as an array. The parsing

		 * algorith is the same, as in _compileAttributes().

		 *

		 * @internal

		 * @param String $prolog The prolog string.

		 * @return Array

		 */

		protected function _compileProlog($prolog)

		{

			// Tokenize the list

			preg_match_all($this->_rPrologTokens, $prolog, $match, PREG_SET_ORDER);

				

			$size = sizeof($match);

			$result = array();

			for($i = 0; $i < $size; $i++)

			{

				if(!ctype_space($match[$i][0]))

				{

					// Traverse through a single attribute

					if(!preg_match($this->_rNameExpression, $match[$i][0]))

					{

						throw new Opt_XmlInvalidProlog_Exception('invalid attribute format');

					}

						

					$vret = false;

					$name = $match[$i][0];

					$value = null;

					for($i++; $i < $size && ctype_space($match[$i][0]); $i++){}

						

					if($i >= $size || $match[$i][0] != '=')

					{

						throw new Opt_XmlInvalidProlog_Exception('invalid attribute format');

					}

					for($i++; ctype_space($match[$i][0]) && $i < $size; $i++){}

					

					if($match[$i][0] != '"' && $match[$i][0] != '\'')

					{

						throw new Opt_XmlInvalidProlog_Exception('invalid attribute format');

					}

					$opening = $match[$i][0];

					$value = '';

					for($i++; $i < $size; $i++)

					{

						if($match[$i][0] == $opening)

						{

							break;

						}

						$value .= $match[$i][0];

					}

					if(!isset($match[$i][0]) || $match[$i][0] != $opening)

					{

						throw new Opt_XmlInvalidProlog_Exception('invalid attribute format');

					}

					// If we are here, the attribute is correct. No shit on the way detected.

					$result[$name] = $value;

				}

			}

			$returnedResult = $result;

			// Check, whether the arguments are correct.

			if(isset($result['version']))

			{

				// There is no other version so far, so report a warning. For 99,9% this is a mistake.

				if($result['version'] != '1.0')

				{

					$this->_tpl->debugConsole and Opt_Support::warning('OPT', 'XML prolog warning: strange XML version: '.$result['version']);

				}

				unset($result['version']);

			}

			if(isset($result['encoding']))

			{

				if(!preg_match($this->_rEncodingName, $result['encoding']))

				{

					throw new Opt_XmlInvalidProlog_Exception('invalid encoding name format');

				}

				// The encoding should match the value we mentioned in the OPT configuration and sent to the browser.

				$result['encoding'] = strtolower($result['encoding']);

				$charset = is_null($this->_tpl->charset) ? null : strtolower($this->_tpl->charset);

				if($result['encoding'] != $charset && !is_null($charset))

				{

					$this->_tpl->debugConsole and Opt_Support::warning('OPT', 'XML prolog warning: the declared encoding: "'.$result['encoding'].'" differs from setContentType() setting: "'.$charset.'"');

				}

				unset($result['encoding']);

			}

			else

			{

				$this->_tpl->debugConsole and Opt_Support::warning('XML prolog warning: no encoding information. Remember your content must be pure UTF-8 or UTF-16 then.');

			}

			if(isset($result['standalone']))

			{

				if($result['standalone'] != 'yes' && $result['standalone'] != 'no')

				{

					throw new Opt_XmlInvalidProlog_Exception('invalid value for "standalone" attribute: "'.$result['standalone'].'"; expected: "yes", "no".');

				}

				unset($result['standalone']);

			}

			if(sizeof($result) > 0)

			{

				throw new Opt_XmlInvalidProlog_Exception('invalid attributes in prolog.');

			}

			return $returnedResult;

		} // end _compileProlog();



		/**

		 * Adds the PHP code with dependencies to the code buffers in the tree

		 * root node.

		 *

		 * @internal

		 * @param Opt_Xml_Node $tree The tree root node.

		 */

		protected function _addDependencies($tree)

		{

			// OK, there is really some info to include!

			$list = '';

			foreach($this->_dependencies as $a)

			{

				$list .= '\''.$a.'\',';

			}

			

			$tree->addBefore(Opt_Xml_Buffer::TAG_BEFORE, 'if(!$this->_massPreprocess($compileTime, array('.$list.'))){ ');

			$tree->addAfter(Opt_Xml_Buffer::TAG_AFTER, ' }else{ $compileTime = $this->_compile($this->_template); require(__FILE__); } ');

		} // end _addDependencies();



		/**

		 * Compiles the current text block between two XML tags, creating a

		 * complete Opt_Xml_Text node. It looks for the expressions in the

		 * curly brackets, extracts them and packs as separate nodes.

		 *

		 * Moreover, it replaces the entities with the corresponding characters.

		 *

		 * @internal

		 * @param Opt_Xml_Node $current The current XML node.

		 * @param String $text The text block between two tags.

		 * @param Boolean $noExpressions=false If true, do not look for the expressions.

		 * @return Opt_Xml_Node The current XML node.

		 */

		protected function _treeTextCompile($current, $text, $noExpressions = false)

		{

			// Yes, we parse entities, but the text itself should not contain

			// any special characters.

			if(strcspn($text, '<>') != strlen($text))

			{

				throw new Opt_XmlInvalidCharacter_Exception(htmlspecialchars($text));

			}



			if($noExpressions)

			{

				$current = $this->_treeTextAppend($current, $this->parseEntities($text));

			}

			

			preg_match_all($this->_rExpressionTag, $text, $result, PREG_SET_ORDER);

			

			$resultSize = sizeof($result);

			$offset = 0;

			for($i = 0; $i < $resultSize; $i++)

			{

				$id = strpos($text, $result[$i][0], $offset);

				if($id > $offset)

				{

					$current = $this->_treeTextAppend($current, $this->parseEntities(substr($text, $offset, $id - $offset)));						

				}

				$offset = $id + strlen($result[$i][0]);

				

				$current = $this->_treeTextAppend($current, new Opt_Xml_Expression($this->parseEntities($result[$i][2])));

			}

			

			$i--;

			// Now the remaining content of the file

			if(strlen($text) > $offset)

			{

				$current = $this->_treeTextAppend($current, $this->parseEntities(substr($text, $offset, strlen($text) - $offset)));

			}

			return $current;

		} // end _treeTextCompile();



		/**

		 * An utility method that simplifies inserting the text to the XML

		 * tree. Depending on the last child type, it can create a new text

		 * node or add the text to the existing one.

		 *

		 * @internal

		 * @param Opt_Xml_Node $current The currently built XML node.

		 * @param String|Opt_Xml_Node $text The text or the expression node.

		 * @return Opt_Xml_Node The current XML node.

		 */

		protected function _treeTextAppend($current, $text)

		{

			$last = $current->getLastChild();

			if(!is_object($last) || !($last instanceof Opt_Xml_Text))

			{

				if(!is_object($text))

				{

					$node = new Opt_Xml_Text($text);

				}

				else

				{

					$node = new Opt_Xml_Text();

					$node->appendChild($text);

				}

				$current->appendChild($node);

			}

			else

			{

				if(!is_object($text))

				{

					$last->appendData($text);

				}

				else

				{

					$last->appendChild($text);

				}

			}

			return $current;

		} // end _treeTextAppend();



		/**

		 * A helper method for building the XML tree. It appends the

		 * node to the current node and returns the new node that should

		 * become the new current node.

		 *

		 * @internal

		 * @param Opt_Xml_Node $current The current node.

		 * @param Opt_Xml_Node $node The newly created node.

		 * @param Boolean $goInto Whether we visit the new node.

		 * @return Opt_Xml_Node

		 */

		protected function _treeNodeAppend($current, $node, $goInto)

		{

			$current->appendChild($node);

			if($goInto)

			{

				return $node;

			}

			return $current;

		} // end _treeNodeAppend();



		/**

		 * A helper method for building the XML tree. It jumps out of the

		 * current node to the parent and switches to it.

		 *

		 * @internal

		 * @param Opt_Xml_Node $current The current node.

		 * @return Opt_Xml_Node

		 */

		protected function _treeJumpOut($current)

		{

			$parent = $current->getParent();

			

			if(!is_null($parent))

			{

				return $parent;

			}

			return $current;

		} // end _treeJumpOut();



		/**

		 * Looks for special OPT attributes in the element attribute list and

		 * processes them. Returns the list of nodes that need to be postprocessed.

		 *

		 * @internal

		 * @param Opt_Xml_Element $node The scanned element.

		 * @param Boolean $specialNs Do we recognize "parse" and "str" namespaces?

		 * @return Array

		 */

		protected function _processXml(Opt_Xml_Element $node, $specialNs = true)

		{

			if(!$node->hasAttributes())

			{

				return array();

			}

			$attributes = $node->getAttributes();

			$pp = array();



			// Look for special OPT attributes

			foreach($attributes as $attr)

			{

				if($this->isNamespace($attr->getNamespace()))

				{

					$xml = $attr->getXmlName();

					// Check the namespace we found

					switch($attr->getNamespace())

					{

						case 'parse':

							if($specialNs)

							{

								$result = $this->compileExpression((string)$attr, false, Opt_Compiler_Class::ESCAPE_BOTH);

								$attr->addAfter(Opt_Xml_Buffer::ATTRIBUTE_VALUE, ' echo '.$result[0].'; ');

								$attr->setNamespace(null);

							}

							break;

						case 'str':

							if($specialNs)

							{

								$attr->setNamespace(null);

							}

							break;

						default:

							if(isset($this->_attributes[$xml]))

							{

								$this->_attributes[$xml]->processAttribute($node, $attr);

								if($attr->get('postprocess'))

								{

									$pp[] = array($this->_attributes[$xml], $attr);

								}

							}

							$node->removeAttribute($xml);

					}

				}

			}

			return $pp;

		} // end _processXml();



		/**

		 * Runs the postprocessors for the specified attributes.

		 *

		 * @internal

		 * @param Opt_Xml_Node $node The scanned node.

		 * @param Array $list The list of XML attribute processors that need to be postprocessed.

		 */

		protected function _postprocessXml(Opt_Xml_Node $node, Array $list)

		{

			$cnt = sizeof($list);

			for($i = 0; $i < $cnt; $i++)

			{

				$list[$i][0]->postprocessAttribute($node, $list[$i][1]);

			}

		} // end _postprocessXml();



		/**

		 * An utility method for the stage 2 and 3 of the compilation. It is

		 * used to create a non-recursive depth-first search algorithm. The

		 * current queue is sent to a stack, and the new queue if initialized,

		 * if $item contains children.

		 *

		 * @internal

		 * @param SplStack $stack The processing stack.

		 * @param SplQueue $queue The processing queue.

		 * @param Opt_Xml_Scannable $item The item, where to import the nodes from.

		 * @param Boolean $pp The postprocess flag.

		 * @return SplQueue The new queue (or the old one, if none has been created).

		 */

		protected function _pushQueue($stack, $queue, $item, $pp)

		{		

			if($item->hasChildren())

			{

				$stack->push(array($item, $queue, $pp));

				$pp = NULL;

				$queue = new SplQueue;

				foreach($item as $child)

				{

					$queue->enqueue($child);

				}

			}

			

			return $queue;

		} // end _pushQueue();



		/**

		 * Does the postprocessing in the second stage of compilation.

		 *

		 * @internal

		 * @param Opt_Xml_Node|Null $item The postprocessed node.

		 * @param Array $pp The list of postprocessed attributes.

		 */

		protected function _doPostprocess($item, $pp)

		{

			// Postprocess code for the compilation stage 2

			// Packed into a method, because it is used twice.

			if(is_null($item))

			{

				return;

			}

			if(sizeof($pp) > 0)

			{

				$this->_postprocessXml($item, $pp);

			}

			if($item->get('postprocess'))

			{

				if(!is_null($processor = $this->isInstruction($item->getXmlName())))

				{

					$processor->postprocessNode($item);

				}

				elseif($this->isComponent($item->getXmlName()))

				{

					$processor = $this->processor('component');

					$processor->postprocessComponent($item);

				}

				elseif($this->isBlock($item->getXmlName()))

				{

					$processor = $this->processor('block');

					$processor->postprocessBlock($item);

				}

				else

				{

					throw new Opt_UnknownProcessor_Exception($item->getXmlName());

				}

			}

		} // end _doPostprocess();



		/**

		 * Does the post-linking for the third stage of the compilation and returns

		 * the linked code.

		 *

		 * @internal

		 * @param Opt_Xml_Node $item The linked item.

		 * @return String

		 */

		protected function _doPostlinking($item)

		{

			// Post code

			if(is_null($item))

			{

				return '';

			}



			// This prevents from displaying </> if the HTML node was hidden.

			if($item->get('hidden') !== false)

			{

				return '';

			}

			if($item->get('_skip_postlinking') == true)

			{

				return '';

			}



			$output = '';

			switch($item->getType())

			{

				case 'Opt_Xml_Text':

					$output .= $item->buildCode(Opt_Xml_Buffer::TAG_AFTER);

					break;

				case 'Opt_Xml_Element':

					if($this->isNamespace($item->getNamespace()))

					{

						if($item->get('single'))

						{

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_SINGLE_AFTER, Opt_Xml_Buffer::TAG_AFTER);

						}

						else

						{

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_CONTENT_AFTER, Opt_Xml_Buffer::TAG_CLOSING_BEFORE,

								Opt_Xml_Buffer::TAG_CLOSING_AFTER, Opt_Xml_Buffer::TAG_AFTER);

						}

					}

					else

					{

						$output .= $item->buildCode(Opt_Xml_Buffer::TAG_CONTENT_AFTER, Opt_Xml_Buffer::TAG_CLOSING_BEFORE).'</'.$item->get('_name').'>'.$item->buildCode(Opt_Xml_Buffer::TAG_CLOSING_AFTER, Opt_Xml_Buffer::TAG_AFTER);

						$item->set('_name', NULL);

					}

					break;

				case 'Opt_Xml_Root':

					$output .= $item->buildCode(Opt_Xml_Buffer::TAG_AFTER);

					break;

			}

			$this->_closeComments($item, $output);

			return $output;

		} // end _doPostlinking();



		/**

		 * Closes the XML comment for the commented item.

		 *

		 * @internal

		 * @param Opt_Xml_Node $item The commented item.

		 * @param String &$output The reference to the output buffer.

		 */

		protected function _closeComments($item, &$output)

		{

			if($item->get('commented'))

			{

				$this->_comments--;

				if($this->_comments == 0)

				{

					// According to the XML grammar, the construct "--->" is not allowed.

					if(strlen($output) > 0 && $output[strlen($output)-1] == '-')

					{

						throw new Opt_XmlComment_Exception('--->');

					}



					$output .= '-->';

				}

			}

		} // end _closeComments();



		/**

		 * Links the element attributes into a valid XML code and returns

		 * the output code.

		 *

		 * @internal

		 * @param Opt_Xml_Element $subitem The XML element.

		 * @return String

		 */

		protected function _linkAttributes($subitem)

		{

			// Links the attributes into the PHP code

			if($subitem->hasAttributes() || $subitem->bufferSize(Opt_Xml_Buffer::TAG_BEGINNING_ATTRIBUTES) > 0 || $subitem->bufferSize(Opt_Xml_Buffer::TAG_ENDING_ATTRIBUTES) > 0)

			{

			

				$code = $subitem->buildCode(Opt_Xml_Buffer::TAG_ATTRIBUTES_BEFORE, Opt_Xml_Buffer::TAG_BEGINNING_ATTRIBUTES);

				$attrList = $subitem->getAttributes();

				// Link attributes into a string

				foreach($attrList as $attribute)

				{

					$s = $attribute->bufferSize(Opt_Xml_Buffer::ATTRIBUTE_NAME);

					switch($s)

					{

						case 0:

							$code .= $attribute->buildCode(Opt_Xml_Buffer::ATTRIBUTE_BEGIN).' '.$attribute->getXmlName();

							break;

						case 1:

							$code .= ($attribute->bufferSize(Opt_Xml_Buffer::ATTRIBUTE_BEGIN) == 0 ? ' ' : '').$attribute->buildCode(Opt_Xml_Buffer::ATTRIBUTE_BEGIN, ' ', Opt_Xml_Buffer::ATTRIBUTE_NAME);

							break;

						default:

							throw new Opt_CompilerCodeBufferConflict_Exception(1, 'ATTRIBUTE_NAME', $subitem->getXmlName());

					}



					if($attribute->bufferSize(Opt_Xml_Buffer::ATTRIBUTE_VALUE) == 0)

					{

						// Static value

						if(!($this->_tpl->htmlAttributes && $attribute->getValue() == $attribute->getName()))

						{

							$code .= '="'.htmlspecialchars($attribute->getValue()).'"';

						}

					}

					else

					{

						$code .= '="'.$attribute->buildCode(Opt_Xml_Buffer::ATTRIBUTE_VALUE).'"';

					}

					$code .= $attribute->buildCode(Opt_Xml_Buffer::ATTRIBUTE_END);

				}

				return $code.$subitem->buildCode(Opt_Xml_Buffer::TAG_ENDING_ATTRIBUTES, Opt_Xml_Buffer::TAG_ATTRIBUTES_AFTER);				

			}

			return '';

		} // end _linkAttributes();

		

		/*

		 * Main compilation methods

		 */



		/**

		 * The compilation launcher. It executes the proper compilation steps

		 * according to the inheritance rules etc.

		 *

		 * @param String $code The source code to be compiled.

		 * @param String $filename The source template filename.

		 * @param String $compiledFilename The output template filename.

		 * @param Int $mode The compilation mode.

		 */

		public function compile($code, $filename, $compiledFilename, $mode)

		{

			try

			{

				// We cannot compile two templates at the same time

				if(!is_null($this->_template))

				{

					throw new Opt_CompilerLocked_Exception($filename, $this->_template);

				}



				// Detecting recursive inclusion

				if(is_null(self::$_recursionDetector))

				{

					self::$_recursionDetector = array(0 => $filename);

					$weFree = true;

				}

				else

				{

					if(in_array($filename, self::$_recursionDetector))

					{

						$exception = new Opt_CompilerRecursion_Exception($filename);

						$exception->setData(self::$_recursionDetector);

						throw $exception;

					}

					self::$_recursionDetector[] = $filename;

					$weFree = false;

				}

				// Cleaning up the processors

				foreach($this->_processors as $proc)

				{

					$proc->reset();

				}

				// Initializing the template launcher

				$this->set('template', $this->_template = $filename);

				$this->set('mode', $mode);

				$this->set('currentTemplate', $this->_template);

				array_push(self::$_templates, $filename);

				$this->_stack = new SplStack;

				$i = 0;

				$extend = $filename;



				$memory = 0;



				// The inheritance loop

				do

				{

					// Stage 1 - code compilation

					if($this->_tpl->debugConsole)

					{

						$initial = memory_get_usage();

						$tree = $this->_stage1($code, $extend, $mode);

						// Stage 2 - PHP tree processing

						$this->_stack = array();

						$this->_stage2($tree);

						$this->set('escape', NULL);

						unset($this->_stack);

						$memory += (memory_get_usage() - $initial);

						unset($code);

					}

					else

					{

						$tree = $this->_stage1($code, $extend, $mode);

						unset($code);

						// Stage 2 - PHP tree processing

						$this->_stack = array();

						$this->_stage2($tree);

						$this->set('escape', NULL);

						unset($this->_stack);

					}





					// if the template extends something, load it and also process

					if(isset($extend) && $extend != $filename)

					{

						$this->addDependantTemplate($extend);

					}



					if(!is_null($snippet = $tree->get('snippet')))

					{

						$tree->dispose();

						unset($tree);



						// Change the specified snippet into a root node.

						$tree = new Opt_Xml_Root;

						$attribute = new Opt_Xml_Attribute('opt:use', $snippet);

						$this->processor('snippet')->processAttribute($tree, $attribute);

						$this->processor('snippet')->postprocessAttribute($tree, $attribute);



						$this->_stage2($tree, true);

						break;

					}

					if(!is_null($extend = $tree->get('extend')))

					{

						$tree->dispose();

						unset($tree);



						$this->set('currentTemplate', $extend);

						array_pop(self::$_templates);

						array_push(self::$_templates, $extend);

						$code = $this->_tpl->_getSource($extend);

					}

					$i++;

				}

				while(!is_null($extend));

				// There are some dependant templates. We must add a suitable PHP code

				// to the output.



				if(sizeof($this->_dependencies) > 0)

				{

					$this->_addDependencies($tree);

				}



				if($this->_tpl->debugConsole)

				{

					Opt_Support::addCompiledTemplate($this->_template, $memory);

				}



				// Stage 3 - linking the last tree

				if(!is_null($compiledFilename))

				{

					$output = '';

					$this->_dynamicBlocks = array();



					$this->_stage3($output, $tree);

					$tree->dispose();

					unset($tree);



					$output = str_replace('?><'.'?php', '', $output);



					// Build the directories, if needed.

					if(($pos = strrpos($compiledFilename, '/')) !== false)

					{

						$path = $this->_tpl->compileDir.substr($compiledFilename, 0, $pos);

						if(!is_dir($path))

						{

							mkdir($path, 0750, true);

						}

					}



					// Save the file

					if(sizeof($this->_dynamicBlocks) > 0)

					{

						file_put_contents($this->_tpl->compileDir.$compiledFilename.'.dyn', serialize($this->_dynamicBlocks));

					}

					file_put_contents($this->_tpl->compileDir.$compiledFilename, $output);

				}

				else

				{

					$tree->dispose();

				}

				array_pop(self::$_templates);

				$this->_inheritance = array();

				if($weFree)

				{

					// Do the cleanup.

					$this->_dependencies = array();

					self::$_recursionDetector = NULL;

					foreach($this->_processors as $processor)

					{

						$processor->reset();

					}

				}

				$this->_template = NULL;



				// Run the new garbage collector, if it is available.

			/*	if(version_compare(PHP_VERSION, '5.3.0', '>='))

				{

					gc_collect_cycles();

				}*/

			}

			catch(Exception $e)

			{

				// Free the memory

				if(isset($tree))

				{

					$tree->dispose();

				}

				// Clean the compiler state in case of exception

				$this->_template = NULL;

				$this->_dependencies = array();

				self::$_recursionDetector = NULL;

				foreach($this->_processors as $processor)

				{

					$processor->reset();

				}

				// Run the new garbage collector, if it is available.

			/*	if(version_compare(PHP_VERSION, '5.3.0', '>='))

				{					

					gc_collect_cycles();

				}*/

				// And throw it forward.

				throw $e;

			}

		} // end compile();



		/**

		 * Compilation - stage 1 - parsing the input template and

		 * building an XML tree.

		 *

		 * @internal

		 * @param String &$code The code to be parsed

		 * @param String $filename Currently unused.

		 * @param Int $mode The compilation mode.

		 * @return Opt_Xml_Root The root node of the new tree.

		 */

		protected function _stage1(&$code, $filename, $mode)

		{

			$current = $tree = new Opt_Xml_Root;

			$codeSize = strlen($code);

			$encoding = $this->_tpl->charset;

			

			// First we have to find the prolog and DTD. Then we will be able to parse tags.			

			if($mode != Opt_Class::QUIRKS_MODE)

			{

				// Find and parse XML prolog

				$endProlog = 0;

				$endDoctype = 0;

				if(substr($code, 0, 5) == '<?xml')

				{

					$endProlog = strpos($code, '?>', 5);



					if($endProlog === false)

					{

						throw new Opt_XmlInvalidProlog_Exception('prolog ending is missing');

					}

					$values = $this->_compileProlog(substr($code, 5, $endProlog - 5));

					$endProlog += 2;

					if(!$this->_tpl->prologRequired)

					{

						// The prolog must be displayed

						$tree->setProlog(new Opt_Xml_Prolog($values));

					}

				}

				// Skip white spaces

				for($i = $endProlog; $i < $codeSize; $i++)

				{

					if($code[$i] != ' ' && $code[$i] != '	' && $code[$i] != "\r" && $code[$i] != "\n")

					{

						break;

					}

				}

				// Try to find doctype at the new position.

				$possibleDoctype = substr($code, $i, 9);

				

				if($possibleDoctype == '<!doctype' || $possibleDoctype == '<!DOCTYPE')

				{

					// OK, we've found it, now determine the doctype end.

					$bracketCounter = 0;

					$doctypeStart = $i;

					for($i += 9; $i < $codeSize; $i++)

					{

						if($code[$i] == '<')

						{

							$bracketCounter++;

						}

						else if($code[$i] == '>')

						{

							if($bracketCounter == 0)

							{

								$endDoctype = $i;

								break;

							}

							$bracketCounter--;

						}

					}

					if($endDoctype == 0)

					{

						throw new Opt_XmlInvalidDoctype_Exception('doctype ending is missing');

					}



					if(!$this->_tpl->prologRequired)

					{

						$tree->setDtd(new Opt_Xml_Dtd(substr($code, $doctypeStart, $i - $doctypeStart + 1)));

					}

					$endDoctype++;

				}

				else

				{

					$endDoctype = $endProlog;

				}

				// OK, now skip that part.

				$code = substr($code, $endDoctype, $codeSize);

				// In the quirks mode, some results from the regular expression parser are

				// moved by one position, so we must add some dynamics here.

				$attributeCell = 5;

				$endingSlashCell = 6;

				$tagExpression = $this->_rXmlTagExpression;

			}

			else

			{

				$tagExpression = $this->_rQuirksTagExpression;

				$attributeCell = 6;

				$endingSlashCell = 7;

			}



			// Split through the general groups (cdata-content)

			$groups = preg_split($this->_rCDataExpression, $code, 0, PREG_SPLIT_DELIM_CAPTURE);

			$groupCnt = sizeof($groups);

			$groupState = 0;

			Opt_Xml_Cdata::$mode = $mode;

			for($k = 0; $k < $groupCnt; $k++)

			{

				// Process CDATA

				if($groupState == 0 && $groups[$k] == '<![CDATA[')

				{

					$cdata = new Opt_Xml_Cdata('');

					$cdata->set('cdata', true);

					$groupState = 1;

					continue;

				}

				if($groupState == 1)

				{

					if($groups[$k] == ']]>')

					{

						$current = $this->_treeTextAppend($current, $cdata);

						$groupState = 0;

					}

					else

					{

						$cdata->appendData($groups[$k]);

					}

					continue;

				}

				$subgroups = preg_split($this->_rCommentExpression, $groups[$k], 0, PREG_SPLIT_DELIM_CAPTURE);

				$subgroupCnt = sizeof($subgroups);

				$subgroupState = 0;

				for($i = 0; $i < $subgroupCnt; $i++)

				{

					// Process comments

					if($subgroupState == 0 && $subgroups[$i] == '<!--')

					{

						$commentNode = new Opt_Xml_Comment();

						$subgroupState = 1;

						continue;

					}

					if($subgroupState == 1)

					{

						if($subgroups[$i] == '-->')

						{

							$current->appendChild($commentNode);

							$subgroupState = 0;

						}

						else

						{

							$commentNode->appendData($subgroups[$i]);

						}

						continue;

					}

					elseif($subgroups[$i] == '-->')

					{

						throw new Opt_XmlInvalidCharacter_Exception('--&gt;');

					}

					// Find XML tags

					preg_match_all($tagExpression, $subgroups[$i], $result, PREG_SET_ORDER);

					/*

					 * Output field description for $result array:

					 *  0 - original content

					 *  1 - tag content (without delimiters)

					 *  2 - /, if enclosing tag

					 *  3 - name

					 *  4 - arguments (5 in quirks mode)

					 *  5 - /, if enclosing tag without subcontent (6 in quirks mode)

					 */

					

					$resultSize = sizeof($result);

					$offset = 0;

					for($j = 0; $j < $resultSize; $j++)

					{

						// Copy the remaining text to the text node

						$id = strpos($subgroups[$i], $result[$j][0], $offset);

						if($id > $offset)

						{

							$current = $this->_treeTextCompile($current, substr($subgroups[$i], $offset, $id - $offset));

						}

						$offset = $id + strlen($result[$j][0]);

						if(!isset($result[$j][$endingSlashCell]))

						{

							$result[$j][$endingSlashCell] = '';

						}					

						// Process the argument list

						$attributes = array();

						if(!empty($result[$j][$attributeCell]))

						{

							// Just for sure...

							$result[$j][$attributeCell] = trim($result[$j][$attributeCell]);

							$oldLength = strlen($result[$j][$attributeCell]);

							$result[$j][$attributeCell] = rtrim($result[$j][$attributeCell], '/');

							if(strlen($result[$j][$attributeCell]) != $oldLength)

							{

								$result[$j][$endingSlashCell] = '/';

							}

							$attributes = $this->_compileAttributes($result[$j][$attributeCell], $result[$j][4]);

							if(!is_array($attributes))

							{

								throw new Opt_XmlInvalidAttribute_Exception($result[$j][0]);

							}

						}

						// Recognize the tag type

						if(substr_count($result[$j][4], ':') > 1)

						{

							throw new Opt_InvalidNamespace_Exception($result[$j][4]);

						}

						if($result[$j][3] != '/')

						{

							// Opening tag

							$node = new Opt_Xml_Element($result[$j][4]);

							$node->set('single', $result[$j][$endingSlashCell] == '/');

							foreach($attributes as $name => $value)

							{

								$node->addAttribute($anode = new Opt_Xml_Attribute($name, $value));

							}

							$current = $this->_treeNodeAppend($current, $node, $result[$j][$endingSlashCell] != '/');

						}

						elseif($result[$j][3] == '/')

						{

							if(sizeof($attributes) > 0)

							{

								throw new Opt_XmlInvalidTagStructure_Exception($result[$j][0]);

							}

							if($current instanceof Opt_Xml_Element)

							{

								if($current->getXmlName() != $result[$j][4])

								{

									throw new Opt_XmlInvalidOrder_Exception($result[$j][4], $current->getXmlName());

								}

							}

							else

							{

								throw new Opt_XmlInvalidOrder_Exception($result[$j][4], 'NULL');	

							}

							$current = $this->_treeJumpOut($current);

						}

						else

						{

							throw new Opt_XmlInvalidTagStructure_Exception($result[$j][0]);

						}

					}

					if(strlen($subgroups[$i]) > $offset)

					{

						$current = $this->_treeTextCompile($current, substr($subgroups[$i], $offset, strlen($subgroups[$i]) - $offset));

					}

				}

			}

			// Testing if everything was closed.

			if($current !== $tree)

			{

				// Error handling - determine the name of the unclosed tag.

				while(! $current instanceof Opt_Xml_Element)

				{

					$current = $current->getParent();

				}



				throw new Opt_UnclosedTag_Exception($current->getXmlName());

			}



			// Testing the single root node.

			if($mode == Opt_Class::XML_MODE && $this->_tpl->singleRootNode)

			{

				// TODO: The current code does not check the contents of Opt_Text_Nodes and other root elements

				// that may contain invalid and valid XML syntax at the same time.

				// For now, this code is frozen, we'll think a bit about it in the future. Maybe nobody

				// will notice this :)

				$elementFound = false;

				foreach($tree as $item)

				{

					if($item instanceof Opt_Xml_Element)

					{

						if($elementFound)

						{

							// Oops, there is already another root node!

							throw new Opt_XmlRootElement_Exception($item->getXmlName());

						}

						$elementFound = true;

					}

				}

			}

			return $tree;

		} // end _stage1();



		/**

		 * Compilation - stage 2. Traversing through the tree and doing something

		 * with the tree and the nodes. The method is recursion-safe.

		 *

		 * @internal

		 * @param Opt_Xml_Node $node The initial node.

		 */

		protected function _stage2(Opt_Xml_Node $node)

		{

			$queue = new SplQueue;

			$stack = new SplStack;

			$queue->enqueue($node);

			

			while(true)

			{

				$item = NULL;

				if($queue->count() > 0)

				{

					$item = $queue->dequeue();

				}

				$pp = array();



				// We set the "hidden" state unless it is set.

				

				try

				{

					if(is_null($item))

					{

						throw new Opl_Goto_Exception;

					}

					

					$stateSet = false;

					if(is_null($item->get('hidden')))

					{ 

						$item->set('hidden', true);

						$stateSet = true;

					}

	

					// Proper processing

					switch($item->getType())

					{

						case 'Opt_Xml_Cdata':

							$stateSet and $item->set('hidden', false);

							break;

						case 'Opt_Xml_Text':

							$stateSet and $item->set('hidden', false);

							if($item->hasChildren())

							{

								$stack->push(array($item, $queue, $pp));

								$pp = NULL;

								$queue = new SplQueue;

								foreach($item as $child)

								{

									$queue->enqueue($child);

								}

								continue 2;

							}

							break;

						case 'Opt_Xml_Element':

							if($this->isNamespace($item->getNamespace()))

							{

								$name = $item->getXmlName();

								$pp = $this->_processXml($item, false);



								// Look for the processor

								if(!is_null($processor = $this->isInstruction($name)))

								{

									$processor->processNode($item);

								}

								elseif($this->isComponent($name))

								{

									$processor = $this->processor('component');

									$processor->processComponent($item);

								}

								elseif($this->isBlock($name))

								{

									$processor = $this->processor('block');

									$processor->processBlock($item);

								}

								

								if(is_object($processor))

								{									

									$stateSet and $item->set('hidden', false);

									$result = $processor->getQueue();

									if(!is_null($result))

									{

										$stack->push(array($item, $queue, $pp));

										$queue = $result;

										continue 2;

									}

								}

								elseif($item->get('processAll'))

								{

									$stateSet and $item->set('hidden', false);

									$stack->push(array($item, $queue, $pp));

									$pp = NULL;

									$queue = new SplQueue;

									foreach($item as $child)

									{

										$queue->enqueue($child);

									}

									continue 2;

								}

								unset($processor);

							}

							else

							{

								$pp = $this->_processXml($item, true);

								$stateSet and $item->set('hidden', false);

								if($item->hasChildren())

								{

									$stack->push(array($item, $queue, $pp));

									$pp = NULL;

									$queue = new SplQueue;

									foreach($item as $child)

									{

										$queue->enqueue($child);

									}

									continue 2;

								}

							}

							break;

						case 'Opt_Xml_Expression':

							$stateSet and $item->set('hidden', false);

							// Empty expressions will be caught by the try... catch.

							try

							{

								$result = $this->compileExpression((string)$item, true);

								if(!$result[1])

								{

									$item->addAfter(Opt_Xml_Buffer::TAG_BEFORE, 'echo '.$result[0].'; ');

								}

								else

								{

									$item->addAfter(Opt_Xml_Buffer::TAG_BEFORE, $result[0].';');

								}

							}

							catch(Opt_EmptyExpression_Exception $e){}

							break;

						case 'Opt_Xml_Root':

							$stateSet and $item->set('hidden', false);

							$queue = $this->_pushQueue($stack, $queue, $item, array());

							break;

						case 'Opt_Xml_Comment':

							if($this->_tpl->printComments)

							{

								$stateSet and $item->set('hidden', false);

							}

							break;

					}

				

				}

				catch(Opl_Goto_Exception $e){}

				$this->_doPostprocess($item, $pp);

				if($queue->count() == 0)

				{

					unset($queue);

					if($stack->count() == 0)

					{

						break;

					}

					list($item, $queue, $pp) = $stack->pop();

					$this->_doPostprocess($item, $pp);

				}

			}

		} // end _stage2();



		/**

		 * Links the tree into a valid XML file with embedded PHP commands

		 * from the tag buffers. The method is recursion-free.

		 *

		 * @internal

		 * @param String &$output Where to store the output.

		 * @param Opt_Xml_Node $node The initial node.

		 */

		protected function _stage3(&$output, Opt_Xml_Node $node)

		{

			// To avoid the recursion, we need a queue and a stack.

			$queue = new SplQueue;

			$stack = new SplStack;

			$queue->enqueue($node);

			

			// Reset the output

			$realOutput = &$output;

			$output = '';

			$wasElement = false;



			// We will be processing the tags in a "infinite" loop

			// In fact, the stop condition can be found within the loop.

			while(true)

			{

				// Obtain the new item to process from the queue.

				$item = NULL;

				if($queue->count() > 0)

				{

					$item = $queue->dequeue();

				}



				// Note that this code uses Opl_Goto_Exception to simulate

				// "goto" instruction.

				try

				{

					// Should we display this node?

					if(is_null($item) || $item->get('hidden') !== false)

					{

						throw new Opl_Goto_Exception;	// Goto postprocess;

					}

					// If the tag has the "commented" flag, we comment it

					// and its content.

					if($item->get('commented'))

					{

						$this->_comments++;

						if($this->_comments == 1)

						{

							$output .= '<!--';

						}

					}

					// If the block is dynamic, then replace the output with some other variable.

					if($item->get('dynamic'))

					{

						$i = sizeof($this->_dynamicBlocks);

						$this->_dynamicBlocks[$i] = '';

						$output = &$this->_dynamicBlocks[$i];

					}



					/* Note that some of the node types must execute some code both before

					 * processing their children and after them. This method processes only

					 * the code executed BEFORE the children are parsed. The latter situation

					 * is implemented in the _doPostlinking() method.

					 */

					$doPostlinking = false;

					switch($item->getType())

					{

						case 'Opt_Xml_Cdata':

							if($item->get('cdata'))

							{

								$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE).'<![CDATA['.$item.']]>'.$item->buildCode(Opt_Xml_Buffer::TAG_AFTER);

								break;

							}

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE);



							// We strip the white spaces at the linking level.

							if($this->_tpl->stripWhitespaces)

							{

								// The CDATA composed of white characters only is reduced to a single space.

								if(ctype_space((string)$item))

								{

									if($wasElement)

									{

										$output .= ' ';

									}

								}

								else

								{

									// In the opposite case reduce all the groups of the white characters

									// to single spaces in the text.

									if($item->get('noEntitize') === true)

									{

										$output .= preg_replace('/\s\s+/', ' ', (string)$item);

									}

									else

									{

										$output .= $this->parseSpecialChars(preg_replace('/(\s){1,}/', ' ', (string)$item));

									}

								}

							}

							else

							{

								$output .= ($item->get('noEntitize') ? (string)$item : $this->parseSpecialChars($item));

							}

							

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_AFTER);

							$this->_closeComments($item, $output);

							break;

						case 'Opt_Xml_Text':

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE);

							$queue = $this->_pushQueue($stack, $queue, $item, NULL);

							// Next part in the post-process section

							break;

						case 'Opt_Xml_Element':

							if($this->isNamespace($item->getNamespace()))

							{

								// This code handles the XML elements that represent the

								// OPT instructions. They have shorter code, because

								// we do not need to display their tags.

								if(!$item->hasChildren() && $item->get('single'))

								{

									$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE, Opt_Xml_Buffer::TAG_SINGLE_BEFORE);

									$doPostlinking = true;

								}

								elseif($item->hasChildren())

								{

									$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE, Opt_Xml_Buffer::TAG_OPENING_BEFORE,

										Opt_Xml_Buffer::TAG_OPENING_AFTER, Opt_Xml_Buffer::TAG_CONTENT_BEFORE);

									

									$queue = $this->_pushQueue($stack, $queue, $item, NULL);

									// Next part in the post-process section

								}

								else

								{

									$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE, Opt_Xml_Buffer::TAG_OPENING_BEFORE,

										Opt_Xml_Buffer::TAG_OPENING_AFTER, Opt_Xml_Buffer::TAG_CONTENT_BEFORE);

									$doPostlinking = true;

								}

							}

							else

							{

								$wasElement = true;

								$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE, Opt_Xml_Buffer::TAG_OPENING_BEFORE);

								if($item->bufferSize(Opt_Xml_Buffer::TAG_NAME) == 0)

								{

									$name = $item->getXmlName();

								}

								elseif($item->bufferSize(Opt_Xml_Buffer::TAG_NAME) == 1)

								{

									$name = $item->buildCode(Opt_Xml_Buffer::TAG_NAME);

								}

								else

								{

									throw new Opt_CompilerCodeBufferConflict_Exception(1, 'TAG_NAME', $item->getXmlName());

								}

								if(!$item->hasChildren() && $item->bufferSize(Opt_Xml_Buffer::TAG_CONTENT) == 0 && $item->get('single'))

								{

									$output .= '<'.$name.$this->_linkAttributes($item).' />'.$item->buildCode(Opt_Xml_Buffer::TAG_SINGLE_AFTER,Opt_Xml_Buffer::TAG_AFTER);

									$item = null;

								}

								else

								{

									$output .= '<'.$name.$this->_linkAttributes($item).'>'.$item->buildCode(Opt_Xml_Buffer::TAG_OPENING_AFTER);

									$item->set('_name', $name);

									if($item->bufferSize(Opt_Xml_Buffer::TAG_CONTENT) > 0)

									{

										$output .= $item->buildCode(Opt_Xml_Buffer::TAG_CONTENT_BEFORE, Opt_Xml_Buffer::TAG_CONTENT, Opt_Xml_Buffer::TAG_CONTENT_AFTER);

									}

									elseif($item->hasChildren())

									{

										$output .= $item->buildCode(Opt_Xml_Buffer::TAG_CONTENT_BEFORE);

										$queue = $this->_pushQueue($stack, $queue, $item, NULL);

										// Next part in the post-process section

										break;

									}

									else

									{

										// The postlinking is already done here, so skip this part

										// in the linker

										$item->set('_skip_postlinking', true);

										$output .= $item->buildCode(Opt_Xml_Buffer::TAG_CLOSING_BEFORE).'</'.$name.'>'.$item->buildCode(Opt_Xml_Buffer::TAG_CLOSING_AFTER, Opt_Xml_Buffer::TAG_AFTER);

									}

								}

							}

							break;

						case 'Opt_Xml_Expression':

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE);

							$this->_closeComments($item, $output);

							break;

						case 'Opt_Xml_Root':

							$output .= $item->buildCode(Opt_Xml_Buffer::TAG_BEFORE);



							// Display the prolog and DTD, if it was set in the node.

							// Such construct ensures us that they will appear in the

							// valid place in the output document.

							if($item->hasProlog())

							{

								$output .= str_replace('<?xml', '<<?php echo \'?\'; ?>xml', $item->getProlog()->getProlog())."\r\n";

							}

							if($item->hasDtd())

							{

								$output .= $item->getDtd()->getDoctype()."\r\n";

							}



							// And go to their children.

							$queue = $this->_pushQueue($stack, $queue, $item, NULL);

							break;

						case 'Opt_Xml_Comment':

							// The comment tags are added automatically.

							$output .= (string)$item;

							$this->_closeComments($item, $output);

							break;

					}

				}

				catch(Opl_Goto_Exception $goto){}	// postprocess:

				if($doPostlinking)

				{

					$output .= $this->_doPostlinking($item);

					if(is_object($item) && $item->get('dynamic'))

					{

						$realOutput .= $output;

						$output = &$realOutput;

					}

				}



				if($queue->count() == 0)

				{

					if($stack->count() == 0)

					{

						break;

					}

					/**

					 * !!!!!!!!!!!!THIS IS WRONG!!!!!!!!!!!!!!!!

					 *

					 * Some items get this called only if they are

					 * the last in the queue.

					 */

					if(!$doPostlinking)

					{

						$output .= $this->_doPostlinking($item);

						if(is_object($item) && $item->get('dynamic'))

						{

							$realOutput .= $output;

							$output = &$realOutput;

						}

					}

					

					list($item, $queue, $pp) = $stack->pop();

					$output .= $this->_doPostlinking($item);

					if($item->get('dynamic'))

					{

						$realOutput .= $output;

						$output = &$realOutput;

					}

				}

			}



			if($this->_tpl->stripWhitespaces)

			{

				$output = rtrim($output);

			}

		} // end _stage3();

		

		/*

		 * Expression compiler

		 */



		/**

		 * Compiles the template expression to the PHP code and checks the syntax

		 * errors. The method is recursion-free.

		 *

		 * @param String $expr The expression

		 * @param Boolean $allowAssignment=false True, if the assignments are allowed.

		 * @param Int $escape=self::ESCAPE_ON The HTML escaping policy for this expression.

		 * @return Array An array consisting of four elements: the compiled expression,

		 *   the assignment status and the variable status (if the expression is in fact

		 *   a single variable). If the escaping is controlled by the template or the

		 *   script, the fourth element contains also an unescaped PHP expression.

		 */

		public function compileExpression($expr, $allowAssignment = false, $escape = self::ESCAPE_ON)

		{

			// The expression modifier must not be tokenized, so we

			// capture it before doing anything with the expression.

			$modifier = '';

			if(preg_match('/^([^\'])\:[^\:]/', $expr, $found))

			{

				$modifier = $found[1];



				if($modifier != 'e' && $modifier != 'u')

				{

					throw new Opt_InvalidExpressionModifier_Exception($modifier, $expr);

				}



				$expr = substr($expr, 2, strlen($expr) - 2);

			}



			// cat $expr > /dev/oracle > $result > happy programmer :)

			preg_match_all('/(?:'.

		   			$this->_rSingleQuoteString.'|'.

		   			$this->_rBacktickString.'|'.

					$this->_rHexadecimalNumber.'|'.

					$this->_rDecimalNumber.'|'.

					$this->_rLanguageVar.'|'.

					$this->_rVariable.'|'.

					$this->_rOperators.'|'.

					$this->_rIdentifier.')/x', $expr, $match);

					

			// Skip the whitespaces and create the translation units

			$cnt = sizeof($match[0]);

			$stack = new SplStack;

			$tu = array(0 => array());

			$tuid = 0;

			$maxTuid = 0;

			$prev = '';

			$chr = chr(18);

			$assignments = array();



			/* The translation units allow to avoid recursive compilation of the

			 * expression. Each sub-expression within parentheses and that is a

			 * function call parameter, becomes a separate translation unit. The

			 * loop below scans the array of tokens, looking for translation

			 * unit separators and builds suitable arrays of tokens for each

			 * TU.

			 */

			for($i = 0; $i < $cnt; $i++)

			{

				if(ctype_space($match[0][$i]) || $match[0][$i] == '')

				{

					continue;

				}

				switch($match[0][$i])

				{

					case ',':

						if($prev == '(' || $prev == ',')

						{

							throw new Opt_Expression_Exception('OP_COMMA', $match[0][$i], $expr);

						}

						$tuid = $stack->pop();

						if(in_array($tuid, $assignments))

						{

							$tuid = $stack->pop();

						}

					case '[':

					case '(':

					case 'is':

					case '=':

						if($match[0][$i] == '=' || $match[0][$i] == 'is')

						{

							$assignments[] = $tuid;

						}

						$tu[$tuid][] = $match[0][$i];

						++$maxTuid;

						$tu[$tuid][] = $chr.$maxTuid;	// A fake token that marks the translation unit which goes here.

						$stack->push($tuid);

						$tuid = $maxTuid;

						$tu[$tuid] = array();

						break;

					case ']':

					case ')':

						// If we have a situation like (), we can remove the TU we've just created,

						// because it's empty and will confuse the expression compiler later.

						if($prev == '(')

						{

							unset($tu[$tuid]);

							--$maxTuid;

						}

						if($stack->count() > 0)

						{

							$tuid = $stack->pop();

							if(in_array($tuid, $assignments))

							{

								$tuid = $stack->pop();

							}

						}

						if($prev == '(')

						{

							array_pop($tu[$tuid]);

						}

						if($prev == ',')

						{

							throw new Opt_Expression_Exception('OP_BRACKET', $match[0][$i], $expr);

						}

						$tu[$tuid][] = $match[0][$i];

						break;

					default:

						$tu[$tuid][] = $match[0][$i];

				}

				$prev = $match[0][$i];

			}

			if(sizeof($tu[0]) == 0)

			{

				throw new Opt_EmptyExpression_Exception();

			}

			/*

			 * Now we have an array of translation units and their tokens and

			 * we can process it linearly, thus avoiding recursive calls.

			 */

			foreach($tu as $id => &$tuItem)

			{

				$tuItem = $this->_compileExpression($expr, $allowAssignment, $tuItem, $id);

			}			

			$assign = $tu[0][1];

			$variable = $tu[0][2];

			

			/*

			 * Finally, we have to link all the subexpressions into an output

			 * expression. We use SPL stack to achieve this, because we need

			 * to store the current subexpression status while finding a new one.

			 */

			$tuid = 0;

			$i = -1;

			$cnt = sizeof($tu[0][0]);

			$stack = new SplStack;

			$prev = null;

			$expression = '';

			

			while(true)

			{

				$i++;

				$token = &$tu[$tuid][0][$i];

				

				// If we've found a translation unit, we must stop for a while the current one

				// and link the new.

				if(strlen($token) > 0 && $token[0] == $chr)

				{

					$wasAssignment = in_array($tuid, $assignments);

					$stack->push(Array($tuid, $i, $cnt));

					$tuid = (int)ltrim($token, $chr);

					$i = -1;

					$cnt = sizeof($tu[$tuid][0]);

					if($cnt == 0 && $wasAssignment)

					{

						throw new Opt_Expression_Exception('OP_NULL', '', $expr);

					}

					continue;				

				}

				else

				{

					$expression .= $token;

				}

			

				if($i >= $cnt)

				{

					if($stack->count() == 0)

					{

						break;

					}

					// OK, current TU is ready. Check, whether there are unfinished upper-level TUs

					// on the stack

					unset($tu[$tuid]);

					list($tuid, $i, $cnt) = $stack->pop();

				}

				$prev = $token;

			}

			

			/*

			 * Now it's time to apply the escaping policy to this expression. We check

			 * the expression for the "e:" and "u:" modifiers and redirect the task to

			 * the escape() method.

			 */

			$result = $expression;

			if($escape != self::ESCAPE_OFF && !$assign)

			{

				if($modifier != '')

				{

					$result = $this->escape($result, $modifier == 'e');

				}

				else

				{

					$result = $this->escape($result);

				}

			}

			// Pack everything

			if($escape != self::ESCAPE_BOTH)

			{

				return array(0 => $result, $assign, $variable, NULL);

			}

			else

			{

				return array(0 => $result, $assign, $variable, $expression);

			}

		} // end compileExpression();



		/**

		 * Compiles a single translation unit in the expression.

		 *

		 * @internal

		 * @param String &$expr A reference to the compiled expressions for debug purposes.

		 * @param Boolean $allowAssignment True, if the assignments are allowed in this unit.

		 * @param Array &$tokens A reference to the array of tokens for this translation unit.

		 * @param String $tu The number of the current translation unit.

		 * @return Array An array build of three items: the compiled expression, the assignment status

		 *    and the variable status (whether the expression is in fact a single variable).

		 */

		protected function _compileExpression(&$expr, $allowAssignment, Array &$tokens, $tu)

		{

			/* The method processes a single translation unit (TU). For example, in the expression

			 *		$a is ($b + $c) * $d

			 * we have the following translation units:

			 * 1. $a is #TU2 * $d

			 * 2. $b + $c

			 * 

			 * They are compiled separately and automatically, so you do not have to do this on

			 * your own. This has been done to remove the recursion from the source code, and moreover

			 * it allows, for example, to manage the argument order in the functions.

			 */



			// Operator mappings

			$wordOperators = array(

				'eq' => '==',

				'eqt' => '===',

				'ne' => '!=',

				'net' => '!==',

				'neq' => '!=',

				'neqt' => '!==',

				'lt' => '<',

				'le' => '<=',

				'lte' => '<=',

				'gt' => '>',

				'ge' => '>=',

				'gte' => '>=',

				'and' => '&&',

				'or' => '||',

				'xor' => 'xor',

				'not' => '!',

				'mod' => '%',

				'div' => '/',

				'add' => '+',

				'sub' => '-',

				'mul' => '*',

				'shl' => '<<',

				'shr' => '>>'

			);

			

			// Previous token information

			$previous = array(

				'token' => null,

				'source' => null,

				'result' => null

			);

			// Some standard "next token sets"

			$valueSet = self::OP_VARIABLE | self::OP_LANGUAGE_VAR | self::OP_STRING | self::OP_NUMBER |

				self::OP_IDENTIFIER | self::OP_PRE_OPERATOR | self::OP_OBJMAN | self::OP_BRACKET;

			$operatorSet = self::OP_OPERATOR | self::OP_POST_OPERATOR | self::OP_NULL;

			// Initial state

			$state = array(

				'next' => $valueSet | self::OP_NULL,	// What token must occur next.

				'step' => 0,		// This flag helps processing brackets by saving some extra token information.

				'func' => 0,		// The function call type: 0 - OPT function (with "$this" as the first argument); 1 - ordinary function

				'oper' => false,	// The assignment flag. The value must be assigned to a variable, so on the left side there must not be any operator (false).

				'clone' => 0,		// We've already used "clone"

				'preop' => false,	// Prefix operators ++ and -- found. This flag is cancelled by any other operator.

				'rev' => NULL,		// Changing the argument order options

				'assign_func' => false,	// Informing the bracket parser that the first argument must be a language block, which must be processed separately.

				'tu'	=> 0,		// What has opened a translation unit? The field contains the token type.

				'variable' => NULL,	// To detect if the expression is a single variable or not.

				'function' => NULL	// Function name for the argument checker errors

			);

			$chr = chr(18);		// Which ASCII code marks the translation unit

			$result = array();	// Here we put the compilation result

			$void = false;		// This is a fake variable for a recursive call, as a last argument (reference)

			$assign = false;

			$to = sizeof($tokens);



			// Loop through the token list.

			for($i = 0; $i < $to; $i++)

			{

				// Some initializing stuff.

				$token = &$tokens[$i];

				$parsefunc = false;

				$current = array(

					'token' => null,		// Symbolic token type. Look at the file header to find the token definitions.

					'source' => $token,		// Original form of the token is also remembered.

					'result' => null,		// Here we have to put the result PHP code generated from the token.

				);

				// Find out, what it is and process it.

				switch($token)

				{

					case '[':

						// This code checks, whether the token is properly used. We have to assign it to one of the token groups.

						if(!($state['next'] & self::OP_SQ_BRACKET))

						{

							throw new Opt_Expression_Exception('OP_SQ_BRACKET', $token, $expr);

						}

						$result[] = '[';

						$state['tu'] = self::OP_SQ_BRACKET_E;

						$state['next'] = self::OP_TU;

						$state['step'] = self::OP_VARIABLE;

						continue;

					case ']':

						if(!($state['next'] & self::OP_SQ_BRACKET_E))

						{

							throw new Opt_Expression_Exception('OP_SQ_BRACKET_E', $token, $expr);

						}

						$current['token'] = $state['step'];

						$current['result'] = ']';

						$state['step'] = 0;

						// This is the way we mark, what tokens can occur next.

						$state['next'] = self::OP_OPERATOR | self::OP_NULL | self::OP_SQ_BRACKET;

						if($state['clone'] == 1)

						{

							$state['next'] = self::OP_NULL | self::OP_SQ_BRACKET;

						}

						break;

					// These tokens are invalid and must produce an error

					case '\'':

					case '"':

					case '{':

					case '}':

						throw new Opt_Expression_Exception('OP_CURLY_BRACKET', $token, $expr);

						break;

					// Text operators.

					case 'add':

					case 'sub':

					case 'mul':

					case 'div':

					case 'mod':

					case 'shl':

					case 'shr':

					case 'eq':

					case 'neq':

					case 'eqt':

					case 'neqt':

					case 'ne':

					case 'net':

					case 'lt':

					case 'le':

					case 'lte':

					case 'gt':

					case 'gte':

					case 'ge':

						// These guys can be also method names, if in proper context

						if($previous['token'] == self::OP_CALL)

						{

							$this->_compileIdentifier($token, $previous['token'], $previous['result'], 

								isset($tokens[$i+1]) ? $tokens[$i+1] : null, $operatorSet, $expr, $current, $state);

							break;

						}

					case 'and':

					case 'or':

					case 'xor':

						$this->_testPreOperators($previous['token'], $state['preop'], $token, $expr);



						// And these three ones - only strings.		

						if($state['next'] & self::OP_STRING)

						{

							$current['result'] = '\''.$token.'\'';

							$current['token'] = self::OP_STRING;

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E;

						}

						else

						{

							if(!($state['next'] & self::OP_OPERATOR))

							{

								throw new Opt_Expression_Exception('OP_OPERATOR', $token, $expr);

							}

							$current['result'] = $wordOperators[$token];

							$current['token'] = self::OP_OPERATOR;

							$state['next'] = $valueSet;

							$state['preop'] = false;

						}

						$state['variable'] = false;

						break;

					case 'not':

						if(!($state['next'] & self::OP_PRE_OPERATOR))

						{

							throw new Opt_Expression_Exception('OP_PRE_OPERATOR', $token, $expr);

						}

						$current['token'] = self::OP_PRE_OPERATOR;

						$current['result'] = $wordOperators[$token];

						$state['next'] = $valueSet;

						$state['variable'] = false;					

						break;

					case 'new':

					case 'clone':

						// These operators are active only if the directive advancedOOP is true.

						if(!$this->_tpl->advancedOOP)

						{

							throw new Opt_ExpressionOptionDisabled_Exception($token, 'security reasons');

						}

						if(!($state['next'] & self::OP_OBJMAN))

						{

							throw new Opt_Expression_Exception('OP_OBJMAN', $token, $expr);

						}

						$current['result'] = $token.' ';

						$current['token'] = self::OP_OBJMAN;

						$state['next'] = ($token == 'new' ? self::OP_IDENTIFIER : self::OP_BLOCK);

						$state['clone'] = 1;

						$state['variable'] = false;

						break;

					case 'is':

						if($state['next'] & self::OP_STRING)

						{

							$current['result'] = '\''.$token.'\'';

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E | self::OP_TU;

							break;

						}

					case '=':

						if(!$allowAssignment)

						{

							throw new Opt_ExpressionOptionDisabled_Exception('Assignments', 'compiler requirements');

						}

						// We have to assign the data to the variable or object field.

						if(($previous['token'] == self::OP_VARIABLE || $previous['token'] == self::OP_FIELD) && !$state['oper'] && $previous['token'] != self::OP_LANGUAGE_VAR)

						{

							$current['result'] = '';

							$current['token'] = self::OP_ASSIGN;

							$state['variable'] = false;

							$state['next'] = self::OP_TU;

							$state['tu'] = self::OP_NULL;

							$assign = true;

						}

						else

						{

							throw new Opt_Expression_Exception('OP_ASSIGN', $token, $expr);

						}

						break;

					case '!==':

					case '==':

					case '===':

					case '!=':

					case '+':

					case '*':

					case '/':

					case '%':						

						if(!($state['next'] & self::OP_OPERATOR))

						{

							throw new Opt_Expression_Exception('OP_OPERATOR', $token, $expr);

						}

						$this->_testPreOperators($previous['token'], $state['preop'], $token, $expr);

						

						$current['result'] = $token;

						$state['next'] = $valueSet;

						$state['oper'] = true;

						$state['preop'] = false;

						$state['variable'] = false;

						break;

					case '-':

						if($state['next'] & self::OP_OPERATOR)

						{

							$this->_testPreOperators($previous['token'], $state['preop'], $token, $expr);

							

							$current['result'] = $token;

							$state['oper'] = true;

							$state['next'] = $valueSet;

							$state['preop'] = false;

						}

						elseif($state['next'] & self::OP_NUMBER | self::OP_VARIABLE | self::OP_IDENTIFIER)

						{

							$current['result'] = $token;

							$state['next'] = self::OP_NUMBER | self::OP_VARIABLE | self::OP_IDENTIFIER;

						}

						else

						{

							throw new Opt_Expression_Exception('OP_OPERATOR', $token, $expr);

						}

						$state['variable'] = false;

						break;

					case '~':

						if(!($state['next'] & self::OP_OPERATOR))

						{

							throw new Opt_Expression_Exception('OP_OPERATOR', $token, $expr);

						}

						$current['result'] = '.';

						$state['next'] = $valueSet;

						$state['oper'] = true;

						$state['preop'] = false;

						$state['variable'] = false;

						break;

					case '++':

					case '--':

						$current['token'] = self::OP_PRE_OPERATOR;

						if(!($state['next'] & self::OP_PRE_OPERATOR))

						{

							$current['token'] = self::OP_POST_OPERATOR;

							if(!($state['next'] & self::OP_POST_OPERATOR))

							{							

								throw new Opt_Expression_Exception('OP_POST_OPERATOR', $token, $expr);

							}

							else

							{

								$state['next'] = self::OP_OPERATOR | self::OP_NULL;

							}

						}

						else

						{

							$state['next'] = self::OP_VARIABLE | self::OP_LANGUAGE_VAR | self::OP_NUMBER;

							$state['preop'] = true;

						}

						$state['oper'] = true;

						$state['variable'] = false;

						$current['result'] = $token;

						break;

					case '!':

						if(!($state['next'] & self::OP_PRE_OPERATOR))

						{

							throw new Opt_Expression_Exception('OP_PRE_OPERATOR', $token, $expr);

						}

						$current['result'] = $token;

						$current['token'] = self::OP_PRE_OPERATOR;

						$state['variable'] = false;

						break;

					case 'null':

					case 'false':

					case 'true':

						// These special values are treated as numbers by the compiler.

						if(!($state['next'] & self::OP_NUMBER))

						{

							throw new Opt_Expression_Exception('OP_NUMBER', $token, $expr);

						}

						$current['token'] = self::OP_NUMBER;

						$current['result'] = $token;

						$state['next'] = $operatorSet;

						break;

					case '.':

						throw new Opt_Expression_Exception('.', $token, $expr);

						break;

					case '::':

						if(!($state['next'] & self::OP_CALL))

						{

							throw new Opt_Expression_Exception('OP_CALL', $token, $expr);

						}

						if(!$this->_tpl->basicOOP)

						{

							throw new Opt_NotSupported_Exception('object-oriented programming', 'disabled');

						}

						// OPT decides from the context, whether "::" means a static

						// or dynamic call.

						if($previous['token'] == self::OP_CLASS)

						{

							$current['result'] = '::';

							$state['call'] = 0;

						}

						else

						{

							$current['result'] = '->';

						}

						$current['token'] = self::OP_CALL;

						$state['next'] = self::OP_IDENTIFIER;

						break;

					case '(':

						// Check, if the parenhesis begins a function/method argument list

						if($previous['token'] == self::OP_METHOD || $previous['token'] == self::OP_FUNCTION || $previous['token'] == self::OP_CLASS)

						{

							// Yes, this is a function call, so we need to find its arguments.

							$args = array();

							for($j = $i + 1; $j < $to && $tokens[$j] != ')'; $j++)

							{								

								if($tokens[$j][0] == $chr)

								{

									$args[] = $tokens[$j];

								}

								elseif($tokens[$j] != ',')

								{

									throw new Opt_Expression_Exception('OP_UNKNOWN', $tokens[$j], $expr);	

								}

							}

							$argNum = sizeof($args);

							

							// Optionally, change the argument order

							if(!is_null($state['rev']))

							{

								$this->_reverseArgs($args, $state['rev'], $state['function']);

								$state['rev'] = null;

								$argNum = sizeof($args);

							}



							// Put the parenthesis to the compiled token list.

							$result[] = '(';



							// If we have a call of the assign() function, we need to store the

							// number of the translation unit in the _translationConversion field.

							// This will allow the language variable compiler to notice that here

							// we should have a language call that must be treated in a bit different

							// way.

							if($argNum > 0 && $state['assign_func'])

							{

								$this->_translationConversion = (int)trim($args[0], $chr);

							}

							// Build the argument list.

							for($k = 0; $k < $argNum; $k++)

							{

								$result[] = $args[$k];

								if($k < $argNum - 1)

								{

									$result[] = ',';

								}

							}

							$i = $j-1;

							$state['next'] = self::OP_BRACKET_E;

							$state['step'] = $previous['token'];

							continue;

						}

						else

						{

							if(!($state['next'] & self::OP_BRACKET))

							{

								throw new Opt_Expression_Exception('OP_BRACKET', $token, $expr);

							}

							$result[] = '(';

							$state['tu'] = self::OP_BRACKET_E;

							$state['next'] = self::OP_TU;

							$state['step'] = self::OP_VARIABLE;

						}

						break;

					case ')':

						if($state['step'] == 0)

						{

							throw new Opt_Expression_Exception('OP_BRACKET', $token, $expr);

						}

						else

						{

							if(!($state['next'] & self::OP_BRACKET_E))

							{

								throw new Opt_Expression_Exception('OP_BRACKET_E', $token, $expr);

							}

							$current['token'] = $state['step'];

							$current['result'] = ')';

							$state['step'] = 0;

							$state['next'] = self::OP_OPERATOR | self::OP_NULL | self::OP_CALL;

							if($state['clone'] == 1)

							{

								$state['next'] = self::OP_NULL | self::OP_CALL;

							}

						}

						break;

					default:	

						if($token[0] == $chr)

						{

							// We've found another translation unit.

							if(!($state['next'] & self::OP_TU))

							{

								throw new Opt_Expression_Exception('OP_TU', 'Translation unit #'.ltrim($token, $chr), $expr);

							}

							if($previous['token'] != self::OP_ASSIGN)

							{

								$result[] = $token;

							}

							$state['next'] = $state['tu'];

						}

						elseif(preg_match('/^'.$this->_rVariable.'$/', $token))

						{

							// Variable call.

							if(!($state['next'] & self::OP_VARIABLE))

							{

								throw new Opt_Expression_Exception('OP_VARIABLE', $token, $expr);

							}

							// We do the first character test manually, because

							// in regular expression the parser would receive too much rubbish.

							if(!ctype_alpha($token[1]) && $token[1] != '_')

							{

								throw new Opt_Expression_Exception('OP_VARIABLE', $token, $expr);

							}

							// Moreover, we need to know the future (assignments)

							$assignment = null;

							if(isset($tokens[$i+1]) && ($tokens[$i+1] == '=' || $tokens[$i+1] == 'is'))

							{

								$assignment = $tokens[$i+2];

							}



							$out = $this->_compileVariable($token, $assignment);

							if(is_array($out))

							{

								foreach($out as $t)

								{

									$result[] = $t;

								}

								$current['result'] = '';

								$current['token'] = self::OP_VARIABLE;

							}

							else

							{

								$current['result'] = $out;

								$current['token'] = self::OP_VARIABLE;

							}

							if(is_null($state['variable']))

							{

								$state['variable'] = true;

							}

							// Hmmm... and what is the purpose of this IF? Seriously, I forgot.

							// So better do not touch it; it must have been very important.

							if($state['clone'] == 1)

							{

								$state['next'] = self::OP_SQ_BRACKET | self::OP_CALL | self::OP_NULL;

							}

							else

							{

								$state['next'] = $operatorSet | self::OP_SQ_BRACKET | self::OP_CALL;

							}

						}

						elseif(preg_match('/^'.$this->_rLanguageVarExtract.'$/', $token, $found))

						{

							// Extracting the language var.

							if(!($state['next'] & self::OP_LANGUAGE_VAR))

							{

								throw new Opt_Expression_Exception('OP_LANGUAGE_VAR', $token, $expr);

							}

							$current['result'] = $this->_compileLanguageVar($found[1], $found[2], $tu);

							$current['token'] = self::OP_LANGUAGE_VAR;

							$state['next'] = $operatorSet;

						}

						elseif(preg_match('/^'.$this->_rDecimalNumber.'$/', $token))

						{

							// Handling the decimal numbers.

							if(!($state['next'] & self::OP_NUMBER))

							{

								throw new Opt_Expression_Exception('OP_NUMBER', $token, $expr);

							}

							$current['result'] = $token;

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E;

						}

						elseif(preg_match('/^'.$this->_rHexadecimalNumber.'$/', $token))

						{

							// Hexadecimal, too.

							if(!($state['next'] & self::OP_NUMBER))

							{

								throw new Opt_Expression_Exception('OP_NUMBER', $token, $expr);

							}

							$current['result'] = $token;

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E;

						}

						elseif(preg_match('/^'.$this->_rSingleQuoteString.'$/', $token))

						{

							if(!($state['next'] & self::OP_STRING))

							{

								throw new Opt_Expression_Exception('OP_STRING', $token, $expr);

							}

							$current['result'] = $this->_compileString($token);

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E;

						}

						elseif(preg_match('/^'.$this->_rBacktickString.'$/', $token))

						{

							if(!($state['next'] & self::OP_STRING))

							{

								throw new Opt_Expression_Exception('OP_STRING', $token, $expr);

							}

							$current['result'] = $this->_compileString($token);

							$state['next'] = $operatorSet | self::OP_SQ_BRACKET_E;

						}

						elseif(preg_match('/^'.$this->_rIdentifier.'$/', $token))

						{

							$this->_compileIdentifier($token, $previous['token'], $previous['result'], 

								isset($tokens[$i+1]) ? $tokens[$i+1] : null, $operatorSet, $expr, $current, $state);

						}

				}

				$previous = $current;

				if($current['result'] != '')

				{

					$result[] = $current['result'];

				}

			}

			// Finally, test if the pre- operators have been used properly.

			$this->_testPreOperators($previous['token'], $state['preop'], $token, $expr);



			// And if we are allowed to finish here...

			if(!($state['next'] & self::OP_NULL))

			{

				throw new Opt_Expression_Exception('OP_NULL', $token, $expr);

			}

			// TODO: For variable detection: check also class/object fields!

			return array($result, $assign, $state['variable']);

		} // end _compileExpression();



		/**

		 * An utility function that allows to test the preincrementation

		 * operators, if they are used in the right place. In case of

		 * problems, it generates an exception.

		 *

		 * @internal

		 * @param Int $previous The previous token type.

		 * @param Boolean $state The state of the "preop" expression parser flag.

		 * @param String $token The current token provided for debug purposes.

		 * @param String &$expr The reference to the parsed expression for debug purposes.

		 */

		protected function _testPreOperators($previous, $state, &$token, &$expr)

		{

			if(($previous == self::OP_METHOD || $previous == self::OP_FUNCTION || $previous == self::OP_EXPRESSION) && $state)

			{

				// Invalid use of prefix operators!

				throw new Opt_Expression_Exception('OP_PRE_OPERATOR', $token, $expr);

			}

		} // end _testPreOperators();



		/**

		 * Compiles the template variable into the PHP code. It can be

		 * generated in two contexts: read and save. The method supports

		 * all the special variables, local template variables and

		 * chooses the correct data formats. Moreover, it provides a

		 * build-in support for sections.

		 *

		 * @internal

		 * @param String $name Variable call

		 * @param String $newValue Null or the new value to assign

		 * @return String The output PHP code.

		 */

		protected function _compileVariable($name, $saveContext = null)

		{

			$value = substr($name, 1, strlen($name) - 1);

			$result = '';

			if(strpos($value, '.') !== FALSE)

			{

				$ns = explode('.', $value);

			}

			else

			{

				$ns = array(0 => $value);

			}

			

			if($name[0] == '@')

			{

				// The instruction may wish to handle this variable somehow differently.

				if(($to = $this->convert('##var_'.$ns[0])) == '##var_'.$ns[0])

				{

					$result = 'self::$_vars';	// Standard handler

				}

				else

				{

					$result = $to;		// Programmer-defined handler

					unset($ns[0]);		// We assume that the variable name is already included into the handler.

				}

				

				// Link the rest of the array call.

				foreach($ns as $item)

				{

					if(ctype_digit($item))

					{

						$result .= '['.$item.']';

					}

					else

					{

						$result .= '[\''.$item.'\']';

					}

				}

				if($saveContext !== null)

				{

					return array($result.'=', $saveContext);

				}

				return $result;

			}

			else

			{

				/*

				 * This is the variable scanner that parses things like "$var.foo.bar.joe".

				 * Each segment of the name can be parsed in different format, depending on

				 * the programmer settings. Moreover, it recognizes the special calls, like "opt"/"system"

				 * or section element calls.

				 */

			

				$path = '';

				$previous = null;

				$code = '';

				$count = sizeof($ns);

				$state = array(

					'access' => $this->_tpl->variableAccess,

					'section' => null,

					'first' => false	

				);



				// Check the first element for special keywords.

				switch($ns[0])

				{

					case 'opt':

					case 'sys':

					case 'system':

						if($saveContext !== null)

						{

							throw new Opt_AssignNotSupported_Exception($name);

						}

						return $this->_compileSys($ns);

					case 'this':

						$state['access'] = Opt_Class::ACCESS_LOCAL;

						unset($ns[0]);

						break;

					case 'global':

						$state['access'] = Opt_Class::ACCESS_GLOBAL;

						unset($ns[0]);

						break;

				}

				// Scan the rest of the name

				$final = sizeof($ns) - 1;

				foreach($ns as $id => $item)

				{

					$previous = $path;

					if($path == '')

					{

						// Parsing the first element. First, check the conversions.

						if(($to = $this->convert('##simplevar_'.$item)) != '##simplevar_'.$item)

						{

							$item = $to;

						}

						$path = $item;

						$state['first'] = true;

					}

					else

					{

						// Parsing one of the later elements

						$path .= '.'.$item;

						$state['first'] = false;

					}

					

					// Processing sections

					if(!is_null($this->isProcessor('section')))

					{

						if(is_null($state['section']))

						{

							// Check if any section with the specified name exists.

							$proc = $this->processor('section');

							$sectionName = $this->convert($item);

							if(!is_null($section = $proc->getSection($sectionName)))

							{

								$path = $sectionName;

								$state['section'] = $section;



								if($id == $count - 1)

								{

									// This is the last name element.

									if($saveContext !== null)

									{

										if(!$section['format']->property('section:itemAssign'))

										{

											throw new Opt_AssignNotSupported_Exception($name);

										}

										$format->assign('value', $saveContext);

										return $section['format']->get('section:itemAssign');

									}



									return $section['format']->get('section:item');

								}

								continue;

							}

						}

						else

						{

							// The section has been found, we need to process the item.

							$state['section']['format']->assign('item', $item);



							if($saveContext !== null && $id == $final)

							{

								if(!$state['section']['format']->property('section:variableAssign'))

								{

									throw new Opt_AssignNotSupported_Exception($name);

								}

								$state['section']['format']->assign('value', $saveContext);

								$code = $state['section']['format']->get('section:variableAssign');

							}

							else

							{

								$code = $state['section']['format']->get('section:variable');

							}

							$state['section'] = null;

							continue;

						}

					}

					

					// Now, the normal variables

					if($state['first'])

					{

						if($state['access'] == Opt_Class::ACCESS_GLOBAL)

						{

							$format = $this->getFormat('global.'.$path, true);

						}

						else

						{

							$format = $this->getFormat($path, true);

						}

						if(!$format->supports('variable'))

						{

							throw new Opt_FormatNotSupported_Exception($format->getName(), 'variable');

						}



						$format->assign('access', $state['access']);

						if($format->property('variable:captureAll'))

						{

							// With this property, the data format may capture

							// the whole namespace and process it in a more complex

							// way

							$format->assign('items', $ns);

							if($saveContext !== null)

							{

								if(!$format->property('variable:assign'))

								{

									throw new Opt_AssignNotSupported_Exception($name);

								}

								$format->assign('value', $saveContext);

								$code = $format->get('variable:captureAssign');

							}

							else

							{								

								$code = $format->get('variable:capture');

							}

							break;

						}

						else

						{

							// An ordinary call - the format captures only

							// the first item, the others are processed

							// by different "item" formats.

							$format->assign('item', $item);

							if($final == $id && $saveContext !== null)

							{

								if(!$format->property('variable:assign'))

								{

									throw new Opt_AssignNotSupported_Exception($name);

								}								

								$format->assign('value', $saveContext);

								$code = $format->get('variable:assign');

							}

							else

							{

								$code = $format->get('variable:main');

							}

						}

					}

					else

					{

						// The subitems are processed with the upper-item format

						if($state['access'] == Opt_Class::ACCESS_GLOBAL)

						{

							$format = $this->getFormat('global.'.$previous, true);

						}

						else

						{

							$format = $this->getFormat($previous, true);

						}

						if(!$format->supports('item'))

						{

							throw new Opt_FormatNotSupported_Exception($format->getName(), 'item');

						}

						if($final == $id && $saveContext !== null)

						{

							if(!$format->property('item:assign'))

							{

								throw new Opt_AssignNotSupported_Exception($name);

							}

							$format->assign('item', $item);

							$format->assign('value', $saveContext);

							$code .= $format->get('item:assign');

						}

						else

						{

							$format->assign('item', $item);

							$code .= $format->get('item:item');

						}

					}

				}

				if($saveContext !== null)

				{

					$out = explode($saveContext, $code);

					if(sizeof($out) != 2)

					{

						return $code;

					}

					return array(0 => $out[0], $saveContext, $out[1]);

				}

				return $code;

			}

		} // end _compileVariable();



		/**

		 * Compiles the call to the language variable into the PHP code.

		 *

		 * @param String $group Group name

		 * @param String $id Message identifier name within a group

		 * @param String $tu The ID of the current translation unit for handling the assign() function properly.

		 * @return String The output PHP code.

		 */

		protected function _compileLanguageVar($group, $id, $tu)

		{

			if(is_null($this->_tf))

			{

				throw new Opl_NoTranslationInterface_Exception('OPT template compiler');

			}

			if($tu === $this->_translationConversion)

			{

				$this->_translationConversion = null;

				return '\''.$group.'\',\''.$id.'\'';

			}

			return '$this->_tf->_(\''.$group.'\',\''.$id.'\')';

		} // end _compileLanguageVar();



		/**

		 * Compiles the special $sys variable to PHP code.

		 *

		 * @param Array $ns The $sys call splitted into array.

		 * @return String The output PHP code.

		 */

		protected function _compileSys(Array $ns)

		{

			switch($ns[1])

			{

				case 'version':

					return '\''.Opt_Class::VERSION.'\'';

				case 'const':

					return 'constant(\''.$ns[2].'\')';				

				default:

					if(!is_null($this->isProcessor($ns[1])))

					{

						return $this->processor($ns[1])->processSystemVar($ns);

					}

					

					throw new Opt_SysVariableUnknown_Exception('$'.implode('.', $ns));

			}

		} // end _compileSys();



		/**

		 * Compiles the string call in the expression to a suitable PHP source code.

		 *

		 * @internal

		 * @param String $str The "string" string (with the delimiting characters)

		 * @return String The output PHP code.

		 */

		protected function _compileString($str)

		{

			// TODO: Fix

			// COMMENT: Fix what?

			switch($str[0])

			{

				case '\'':

					return $str;

				case '`':

					if(is_null($this->_tpl->backticks))

					{

						throw new Opt_NotSupported_Exception('backticks', 'not configured');

					}

					elseif(is_string($this->_tpl->backticks))

					{

						// A redirect to a function		

						return $this->_tpl->backticks.'(\''.str_replace('\'', '\\\'', stripslashes(substr($str, 1, strlen($str) - 2))).'\')';

					}

					elseif(is_array($this->_tpl->backticks) && is_object($this->_tpl->backticks[0]))

					{

						// A redirect to an object method

			

						return '$this->_tpl->backticks[0]->'.$this->_tpl->backticks[1].'(\''.str_replace('\'', '\\\'', stripslashes(substr($str, 1, strlen($str) - 2))).'\')';

					}

					else

					{

						throw new Opt_InvalidCallback_Exception('backticks');

					}

				default:

					return '\''.$str.'\'';

			}

		} // end _compileString();



		/**

		 * Compiles the specified identifier encountered in the expression

		 * to the PHP code.

		 *

		 * @internal

		 * @param String $token The encountered token.

		 * @param Int $previous Previous token

		 * @param String $pt Used for OOP parsing to determine whether we have a static call.

		 * @param String $next The next token in the list

		 * @param Int $operatorSet The flag of allowed opcodes at this position.

		 * @param String &$expr The current expression (for debug purposes)

		 * @param Array &$current Reference to the current token information

		 * @param Array &$state Reference to the parser state flags.

		 */

		protected function _compileIdentifier($token, $previous, $pt, $next, $operatorSet, &$expr, &$current, &$state)

		{

			if($previous == self::OP_OBJMAN)

			{

				// Class constructor call

				if(isset($this->_classes[$token]) && $this->_tpl->basicOOP)

				{

					$current['result'] = $this->_classes[$token];

					$current['token'] = self::OP_CLASS;

					$state['next'] = self::OP_BRACKET | self::OP_NULL;

					if($next == '(')

					{

						$state['func'] = 1;

					}

				}

				else

				{

					throw new Opt_ItemNotAllowed_Exception('Class', $token);

				}

			}

			elseif($next == '(')

			{

				// Function/method call

				if($previous == self::OP_CALL)

				{

					$current['result'] = $token;

					$current['token'] = self::OP_METHOD;

					$state['next'] = self::OP_BRACKET;

					$state['func'] = 1;

				}

				elseif(isset($this->_functions[$token]))

				{

					$name = $this->_functions[$token];

					if($name[0] == '#')

					{

						$pos = strpos($name, '#', 1);

						if($pos === false)

						{

							throw new Opt_InvalidArgumentFormat_Exception($name, $token);

						}

						$state['rev'] = substr($name, 1, $pos - 1);

						$name = substr($name, $pos+1, strlen($name));

					}

					$current['result'] = $name;

					$current['token'] = self::OP_FUNCTION;

					$state['next'] = self::OP_BRACKET;

					$state['function'] = $token;

				}

				elseif($token == 'assign')

				{

					$current['result'] = '$this->_tf->assign';

					$current['token'] = self::OP_FUNCTION;

					$state['next'] = self::OP_BRACKET;

					$state['assign_func'] = true;

					$state['function'] = $token;

				}

				else

				{

					throw new Opt_ItemNotAllowed_Exception('Function', $token);

				}

			}

			elseif($previous == self::OP_CALL)

			{

				// Class/object field call, check whether static or not.

				$current['result'] = ($pt == '::' ? '$'.$token : $token);

				$current['token'] = self::OP_FIELD;

				$state['next'] = $operatorSet | self::OP_SQ_BRACKET | self::OP_CALL;

				if($state['clone'] == 1)

				{

					$state['next'] = self::OP_SQ_BRACKET | self::OP_CALL | self::OP_NULL;

				}

			}

			elseif($next == '::')

			{

				// Static class call

				if(isset($this->_classes[$token]))

				{

					$current['result'] = $this->_classes[$token];

					$current['token'] = self::OP_CLASS;

					$state['next'] = self::OP_CALL;

				}

				else

				{

					throw new Opt_ItemNotAllowed_Exception('Class', $token);

				}

			}

			else

			{

				// An ending string.

				if(!($state['next'] & self::OP_STRING))

				{

					throw new Opt_Expression_Exception('OP_STRING', $token, $expr);

				}

				$state['next'] = self::OP_NULL;

				$current['token'] = self::OP_STRING;

				$current['result'] = '\''.$token.'\'';

			}

		} // end _compileIdentifier();



		/**

		 * Processes the argument order change functionality for function

		 * parsing in expressions.

		 *

		 * @internal

		 * @param Array &$args Reference to a list of function arguments.

		 * @param String $format The new order format code.

		 * @param String $function The function name provided for debugging purposes.

		 */

		protected function _reverseArgs(&$args, $format, $function)

		{

			$codes = explode(',', $format);

			$newArgs = array();

			$i = 0;

			foreach($codes as $code)

			{

				$data = explode(':', $code);

				if(!isset($args[$i]))

				{

					if(!isset($data[1]))

					{

						throw new Opt_FunctionArgument_Exception($i, $function);

					}

					$newArgs[(int)$data[0]-1] = $data[1];

				}

				else

				{

					$newArgs[(int)$data[0]-1] = $args[$i];

				}

				$i++;

			}

			$args = $newArgs;

		} // end _reverseArgs();



		/**

		 * Smart special character replacement that leaves entities

		 * unmodified. Used by parseSpecialChars().

		 *

		 * @internal

		 * @param Array $text Matching string

		 * @return String Modified text

		 */

		protected function _entitize($text)

		{

			switch($text[0])

			{

				case '&':	return '&amp;';

				case '>':	return '&gt;';

				case '<':	return '&lt;';

				case '"':	return '&quot;';

				default:	return $text[0];

			}

		} // end _entitize();



		/**

		 * Smart entity replacement that makes use of

		 *

		 * @internal

		 * @param Array $text Matching string

		 * @return String Modified text

		 */

		protected function _decodeEntity($text)

		{

			switch($text[1])

			{

				case 'amp':	return '&';

				case 'quot':	return '"';

				case 'lt':	return '<';

				case 'gt':	return '>';

				case 'apos': return "'";

				default:

					

					if(isset($this->_entities[$text[1]]))

					{

						return $this->_entities[$text[1]];

					}

					if($text[1][0] == '#')

					{

						return html_entity_decode($text[0], ENT_COMPAT, $this->_tpl->charset);

					}

					elseif($this->_tpl->htmlEntities && $text[0] != ($result = html_entity_decode($text[0], ENT_COMPAT, $this->_tpl->charset)))

					{

						return $result;

					}

					throw new Opt_UnknownEntity_Exception(htmlspecialchars($text[0]));

			}

		} // end _entitize();

	} // end Opt_Compiler_Class;