function templateNodeTransformation($functionName, &$node, $tpl, $parameters, $privateData)
{
if ($functionName != $this->BlockName) {
return false;
}
$parameters = eZTemplateNodeTool::extractFunctionNodeParameters($node);
if (!isset($parameters['name'])) {
return false;
}
$namespaceValue = false;
$newNodes = array();
if (isset($parameters["name"])) {
$menuIni = eZINI::instance("menu.ini");
$nameData = $parameters["name"];
if (!eZTemplateNodeTool::isConstantElement($nameData)) {
return false;
}
$menuName = eZTemplateNodeTool::elementConstantValue($nameData);
if ($menuIni->hasVariable('SelectedMenu', $menuName)) {
$menuTemplate = $menuIni->variable("SelectedMenu", $menuName);
if ($menuTemplate != null) {
$uriString = "design:menu/{$menuTemplate}.tpl";
$resourceName = "";
$templateName = "";
$resource = $tpl->resourceFor($uriString, $resourceName, $templateName);
$resourceData = $tpl->resourceData($resource, $uriString, $resourceName, $templateName);
$resourceData['use-comments'] = eZTemplateCompiler::isCommentsEnabled();
$includeNodes = $resource->templateNodeTransformation($functionName, $node, $tpl, $resourceData, $parameters, $namespaceValue);
if ($includeNodes === false) {
return false;
}
$variableList = array();
foreach (array_keys($parameters) as $parameterName) {
if ($parameterName == 'name') {
continue;
}
$parameterData =& $parameters[$parameterName];
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameterData, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $parameterName));
$variableList[] = $parameterName;
}
$newNodes = array_merge($newNodes, $includeNodes);
foreach ($variableList as $variableName) {
$newNodes[] = eZTemplateNodeTool::createVariableUnsetNode(array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $variableName));
}
} else {
// to do: not use this function to generate empty code.
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("");
}
} else {
// to do: not use this function to generate empty code.
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("");
}
}
return $newNodes;
}
function templateNodeTransformation($functionName, &$node, $tpl, $parameters, $privateData)
{
if ($functionName != $this->IncludeName) {
return false;
}
$parameters = eZTemplateNodeTool::extractFunctionNodeParameters($node);
if (!isset($parameters['uri'])) {
return false;
}
$uriData = $parameters['uri'];
if (!eZTemplateNodeTool::isConstantElement($uriData)) {
return false;
}
$namespaceValue = false;
$namespaceName = '$currentNamespace';
if (isset($parameters['name'])) {
$nameData = $parameters['name'];
if (!eZTemplateNodeTool::isConstantElement($nameData)) {
return false;
}
$namespaceValue = eZTemplateNodeTool::elementConstantValue($nameData);
$namespaceName = '$namespace';
}
$uriString = eZTemplateNodeTool::elementConstantValue($uriData);
$resourceName = "";
$templateName = "";
$resource = $tpl->resourceFor($uriString, $resourceName, $templateName);
$resourceData = $tpl->resourceData($resource, $uriString, $resourceName, $templateName);
$resourceData['use-comments'] = eZTemplateCompiler::isCommentsEnabled();
$includeNodes = $resource->templateNodeTransformation($functionName, $node, $tpl, $resourceData, $parameters, $namespaceValue);
if ($includeNodes === false) {
return false;
}
$newNodes = array();
$variableList = array();
$uniqID = md5(uniqid('inc'));
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("\$oldRestoreIncludeArray" . "_{$uniqID} = isset( \$restoreIncludeArray ) ? \$restoreIncludeArray : array();\n" . "\$restoreIncludeArray = array();\n");
foreach (array_keys($parameters) as $parameterName) {
if ($parameterName == 'uri' or $parameterName == 'name') {
continue;
}
$parameterData =& $parameters[$parameterName];
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( isset( {$namespaceName} ) and isset( \$vars[{$namespaceName}]['{$parameterName}'] ) )\n" . " \$restoreIncludeArray[] = array( {$namespaceName}, '{$parameterName}', \$vars[{$namespaceName}]['{$parameterName}'] );\n" . "elseif ( !isset( \$vars[( isset( {$namespaceName} ) ? {$namespaceName} : '' )]['{$parameterName}'] ) ) \n" . " \$restoreIncludeArray[] = array( ( isset( {$namespaceName} ) ? {$namespaceName} : '' ), '{$parameterName}', 'unset' );\n");
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameterData, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $parameterName));
$variableList[] = $parameterName;
}
$newNodes = array_merge($newNodes, $includeNodes);
// Restore previous variables, before including
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("foreach ( \$restoreIncludeArray as \$element )\n" . "{\n" . " if ( \$element[2] === 'unset' )\n" . " {\n" . " unset( \$vars[\$element[0]][\$element[1]] );\n" . " continue;\n" . " }\n" . " \$vars[\$element[0]][\$element[1]] = \$element[2];\n" . "}\n" . "\$restoreIncludeArray = \$oldRestoreIncludeArray" . "_{$uniqID};\n");
return $newNodes;
}
function templateNodeTransformation( $functionName, &$node,
$tpl, $parameters, $privateData )
{
if ( !isset( $this->Rules[$functionName] ) )
return false;
$rule = $this->Rules[$functionName];
$resourceData = $privateData['resource-data'];
$parameters = eZTemplateNodeTool::extractFunctionNodeParameters( $node );
$inputName = $rule['input_name'];
if ( !isset( $parameters[$inputName] ) )
{
return false;
}
$inputData = $parameters[$inputName];
$outputName = $rule['output_name'];
$newNodes = array();
$viewDir = '';
$renderMode = false;
if ( isset( $rule["render_mode"] ) )
{
$renderMode = $rule["render_mode"];
}
if ( isset( $parameters['render-mode'] ) )
{
$renderData = $parameters['render-mode'];
if ( !eZTemplateNodeTool::isConstantElement( $renderData ) )
{
return false;
}
$renderMode = eZTemplateNodeTool::elementConstantValue( $renderData );
}
if ( $renderMode )
$view_dir .= "/render-$renderMode";
$viewValue = false;
$viewName = false;
if ( $rule['use_views'] )
{
$viewName = $rule['use_views'];
if ( isset( $parameters[$viewName] ) )
{
$viewData = $parameters[$viewName];
if ( !eZTemplateNodeTool::isConstantElement( $viewData ) )
{
return false;
}
$viewValue = eZTemplateNodeTool::elementConstantValue( $viewData );
$viewDir .= '/' . $viewValue;
}
else
{
if ( !( isset( $rule['optional_views'] ) && $rule['optional_views'] ) )
{
return false;
}
}
}
$namespaceValue = false;
if ( isset( $rule['namespace'] ) )
{
$namespaceValue = $rule['namespace'];
}
$variableList = array();
$newNodes[] = eZTemplateNodeTool::createVariableNode( false, $inputData, false, array(),
array( $namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $outputName ) );
$variableList[] = $outputName;
foreach ( array_keys( $parameters ) as $parameterName )
{
if ( $parameterName == $inputName or
$parameterName == $outputName or
$parameterName == $viewName )
continue;
$newNodes[] = eZTemplateNodeTool::createVariableNode( false, $parameters[$parameterName], false, array(),
array( $namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $parameterName ) );
$variableList[] = $parameterName;
}
$templateRoot = $rule["template_root"];
$matchFileArray = eZTemplateDesignResource::overrideArray();
if ( is_string( $templateRoot ) )
{
$resourceNodes = $this->resourceAcquisitionTransformation( $functionName, $node, $rule, $inputData,
$outputName, $namespaceValue,
$templateRoot, $viewDir, $viewValue,
$matchFileArray, 0, $resourceData );
// If the transformation failed we return false to invoke interpreted mode
if ( $resourceNodes === false )
return false;
$newNodes = array_merge( $newNodes, $resourceNodes );
}
else
{
if ( isset( $templateRoot['type'] ) and
$templateRoot['type'] == 'multi_match' and
isset( $templateRoot['attributes'] ) and
isset( $templateRoot['matches'] ) )
{
$attributeAccessData = array();
$attributeAccessData[] = eZTemplateNodeTool::createVariableElement( $outputName, $namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE );
foreach ( $templateRoot['attributes'] as $rootAttributeName )
{
$attributeAccessData[] = eZTemplateNodeTool::createAttributeLookupElement( $rootAttributeName );
}
$newNodes[] = eZTemplateNodeTool::createVariableNode( false, $attributeAccessData, false,
array( 'spacing' => 0 ), 'templateRootMatch' );
$rootMatchCounter = 0;
foreach ( $templateRoot['matches'] as $rootMatch )
{
$templateRoot = $rootMatch[1];
if ( is_array( $templateRoot ) )
{
$templateRoot = $templateRoot[0];
}
$resourceNodes = $this->resourceAcquisitionTransformation( $functionName, $node, $rule, $inputData,
$outputName, $namespaceValue,
$templateRoot, $viewDir, $viewValue,
$matchFileArray, 4, $resourceData );
// If this transformation failed we continue to the next root match
if ( $resourceNodes === false )
continue;
$rootMatchValueText = eZPHPCreator::variableText( $rootMatch[0], 0, 0, false );
$code = '';
if ( $rootMatchCounter > 0 )
{
$code .= "else " . ( $resourceData['use-comments'] ? ( "/*OF:" . __LINE__ . "*/" ) : "" ) . "";
}
$code .= "if " . ( $resourceData['use-comments'] ? ( "/*OF:" . __LINE__ . "*/" ) : "" ) . "( \$templateRootMatch == $rootMatchValueText )\n{";
$newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code );
$newNodes = array_merge( $newNodes, $resourceNodes );
$newNodes[] = eZTemplateNodeTool::createCodePieceNode( "}" );
++$rootMatchCounter;
}
// If the transformation failed we invoke interpreted mode
if ( $rootMatchCounter == 0 )
{
return false;
}
$newNodes[] = eZTemplateNodeTool::createVariableUnsetNode( 'templateRootMatch' );
}
}
foreach ( $variableList as $variableName )
{
$newNodes[] = eZTemplateNodeTool::createVariableUnsetNode( array( $namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $variableName ) );
}
return $newNodes;
}
function templateNodeTransformation( $functionName, &$node,
$tpl, $parameters, $privateData )
{
switch( $functionName )
{
case $this->SetName:
case $this->DefaultName:
case $this->LetName:
{
$scope = eZTemplate::NAMESPACE_SCOPE_RELATIVE;
if ( isset( $parameters['-scope'] ) )
{
if ( !eZTemplateNodeTool::isConstantElement( $parameters['-scope'] ) )
return false;
$scopeText = eZTemplateNodeTool::elementConstantValue( $parameters['-scope'] );
if ( $scopeText == 'relative' )
$scope = eZTemplate::NAMESPACE_SCOPE_RELATIVE;
else if ( $scopeText == 'root' )
$scope = eZTemplate::NAMESPACE_SCOPE_LOCAL;
else if ( $scopeText == 'global' )
$scope = eZTemplate::NAMESPACE_SCOPE_GLOBAL;
}
$parameters = eZTemplateNodeTool::extractFunctionNodeParameters( $node );
$namespaceValue = false;
if ( isset( $parameters['-name'] ) )
{
if ( !eZTemplateNodeTool::isConstantElement( $parameters['-name'] ) )
{
return false;
}
$namespaceValue = eZTemplateNodeTool::elementConstantValue( $parameters['-name'] );
}
$variableList = array();
$setVarNodes = array();
foreach ( array_keys( $parameters ) as $parameterName )
{
if ( $parameterName == '-name' or $parameterName == '-scope' )
{
continue;
}
$parameterData =& $parameters[$parameterName];
$setVarNodes[] = eZTemplateNodeTool::createVariableNode(
false, $parameterData, eZTemplateNodeTool::extractFunctionNodePlacement( $node ),
array(), array( $namespaceValue, $scope, $parameterName ),
( $functionName == $this->SetName ), ( $functionName != $this->DefaultName ),
false, ( $functionName == $this->DefaultName ) );
if ( $functionName == $this->LetName or $functionName == $this->DefaultName )
{
$variableList[] = $parameterName;
}
}
if ( ( $functionName == $this->LetName or $functionName == $this->DefaultName ) and
$namespaceValue )
{
$setVarNodes[] = eZTemplateNodeTool::createNamespaceChangeNode( $namespaceValue );
}
if ( $functionName == $this->LetName or $functionName == $this->DefaultName )
{
$childNodes = eZTemplateNodeTool::extractFunctionNodeChildren( $node );
if ( !is_array( $childNodes ) )
{
$childNodes = array();
}
}
else
{
$childNodes = array();
}
$unsetVarNodes = array();
if ( ( $functionName == $this->LetName or $functionName == $this->DefaultName ) and
$namespaceValue )
{
$unsetVarNodes[] = eZTemplateNodeTool::createNamespaceRestoreNode();
}
if ( $functionName == $this->LetName or $functionName == $this->DefaultName )
{
foreach( $variableList as $parameterName )
{
$unsetVarNodes[] = eZTemplateNodeTool::createVariableUnsetNode( array( $namespaceValue,
eZTemplate::NAMESPACE_SCOPE_RELATIVE,
$parameterName ),
array( 'remember_set' => $functionName == $this->DefaultName ) );
}
}
return array_merge( $setVarNodes, $childNodes, $unsetVarNodes );
} break;
}
}
function templateNodeTransformation($functionName, &$node, $tpl, $parameters, $privateData)
{
if ($functionName != $this->BlockName) {
return false;
}
$parameters = eZTemplateNodeTool::extractFunctionNodeParameters($node);
if (!isset($parameters['name'])) {
return false;
}
// Read ini file
$toolbarIni = eZINI::instance("toolbar.ini");
if (isset($parameters["view"])) {
$viewData = $parameters["view"];
$viewMode = eZTemplateNodeTool::elementConstantValue($viewData);
} else {
$viewMode = "full";
}
$params = $parameters;
$namespaceValue = false;
if (isset($parameters["name"])) {
$nameData = $parameters["name"];
if (!eZTemplateNodeTool::isConstantElement($nameData)) {
return false;
}
$nameValue = eZTemplateNodeTool::elementConstantValue($nameData);
$toolbarPosition = $nameValue;
$toolbarName = "Toolbar_" . $toolbarPosition;
$toolArray = $toolbarIni->variable($toolbarName, 'Tool');
if (!is_array($toolArray)) {
$toolArray = array();
}
$newNodes = array();
foreach (array_keys($toolArray) as $toolKey) {
$tool = $toolArray[$toolKey];
$placement = $toolKey + 1;
$uriString = "design:toolbar/{$viewMode}/{$tool}.tpl";
$placementValue = "";
$firstValue = false;
$lastValue = false;
if ($placement == 1) {
if ($placement == count($toolArray)) {
$firstValue = true;
$lastValue = true;
$placementValue = "last";
} else {
$firstValue = true;
$placementValue = "first";
}
} else {
if ($placement == count($toolArray)) {
$lastValue = true;
$placementValue = "last";
}
}
$resourceName = "";
$templateName = "";
$resource = $tpl->resourceFor($uriString, $resourceName, $templateName);
$resourceData = $tpl->resourceData($resource, $uriString, $resourceName, $templateName);
$resourceData['use-comments'] = eZTemplateCompiler::isCommentsEnabled();
$includeNodes = $resource->templateNodeTransformation($functionName, $node, $tpl, $resourceData, $parameters, $namespaceValue);
if ($includeNodes === false) {
return false;
}
$uniqID = md5(uniqid('inc'));
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("\$oldRestoreIncludeArray" . "_{$uniqID} = isset( \$restoreIncludeArray ) ? \$restoreIncludeArray : array();\n" . "\$restoreIncludeArray = array();\n");
$variableList = array();
foreach (array_keys($parameters) as $parameterName) {
if ($parameterName == 'name' or $parameterName == 'view') {
continue;
}
$parameterData =& $parameters[$parameterName];
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( isset( \$vars['']['{$parameterName}'] ) )\n" . " \$restoreIncludeArray[] = array( '', '{$parameterName}', \$vars['']['{$parameterName}'] );\n" . "elseif ( !isset( \$vars['']['{$parameterName}'] ) ) \n" . " \$restoreIncludeArray[] = array( '', '{$parameterName}', 'unset' );\n");
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameterData, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $parameterName));
$variableList[] = $parameterName;
}
$actionParameters = array();
if ($toolbarIni->hasGroup("Tool_" . $tool)) {
$actionParameters = $toolbarIni->group("Tool_" . $tool);
}
if ($toolbarIni->hasGroup("Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement)) {
$actionParameters = array_merge($actionParameters, $toolbarIni->group("Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement));
}
foreach (array_keys($actionParameters) as $key) {
$itemValue = $actionParameters[$key];
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $itemValue, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, $key));
$variableList[] = $key;
}
// Add parameter tool_id and offset
$toolIDValue = "Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement;
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $toolIDValue, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, "tool_id"));
$variableList[] = "tool_id";
$toolOffset = $placement;
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $toolOffset, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, "offset"));
$variableList[] = "offset";
// Add parameter first, last and placement
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $firstValue, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, "first"));
$variableList[] = "first";
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $lastValue, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, "last"));
$variableList[] = "last";
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $placementValue, false, array(), array($namespaceValue, eZTemplate::NAMESPACE_SCOPE_RELATIVE, "placement"));
$variableList[] = "placement";
$newNodes = array_merge($newNodes, $includeNodes);
// Restore previous variables, before including
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("foreach ( \$restoreIncludeArray as \$element )\n" . "{\n" . " if ( \$element[2] === 'unset' )\n" . " {\n" . " unset( \$vars[\$element[0]][\$element[1]] );\n" . " continue;\n" . " }\n" . " \$vars[\$element[0]][\$element[1]] = \$element[2];\n" . "}\n" . "\$restoreIncludeArray = \$oldRestoreIncludeArray" . "_{$uniqID};\n");
}
}
return $newNodes;
}
function templateNodeTransformation($functionName, &$node, $tpl, $parameters, $privateData)
{
$useLastValue = false;
if (isset($parameters['last-value']) and !eZTemplateNodeTool::isConstantElement($parameters['last-value'])) {
return false;
}
if (isset($parameters['name']) and !eZTemplateNodeTool::isConstantElement($parameters['name'])) {
return false;
}
if (isset($parameters['var']) and !eZTemplateNodeTool::isConstantElement($parameters['var'])) {
return false;
}
if (isset($parameters['reverse']) and !eZTemplateNodeTool::isConstantElement($parameters['reverse'])) {
return false;
}
$varName = false;
if (isset($parameters['var'])) {
$varName = eZTemplateNodeTool::elementConstantValue($parameters['var']);
}
if (isset($parameters['last-value'])) {
$useLastValue = (bool) eZTemplateNodeTool::elementConstantValue($parameters['last-value']);
}
if (!$varName) {
$useLastValue = false;
}
$reverseLoop = false;
if (isset($parameters['reverse'])) {
$reverseLoop = eZTemplateNodeTool::elementConstantValue($parameters['reverse']);
}
$useLoop = isset($parameters['loop']);
$allowLoop = true;
$newNodes = array();
$maxText = "false";
$useMax = false;
$maxPopText = false;
if (isset($parameters['max'])) {
if (eZTemplateNodeTool::isConstantElement($parameters['max'])) {
$maxValue = eZTemplateNodeTool::elementConstantValue($parameters['max']);
if ($maxValue > 0) {
$maxText = eZPHPCreator::variableText($maxValue);
$useMax = true;
} else {
return array(eZTemplateNodeTool::createTextNode(''));
}
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameters['max'], eZTemplateNodeTool::extractFunctionNodePlacement($node), array(), 'max');
$maxText = "\$max";
$maxPopText = ", \$max";
$useMax = true;
}
}
// Controls whether the 'if' statement with brackets is added
$useShow = false;
// Controls whether main nodes are handled, also controls delimiter and filters
$useMain = true;
// Controls wether else nodes are handled
$useElse = false;
$spacing = 0;
if (isset($parameters['show'])) {
if (eZTemplateNodeTool::isConstantElement($parameters['show'])) {
$showValue = eZTemplateNodeTool::elementConstantValue($parameters['show']);
if ($showValue) {
$useMain = true;
$useElse = false;
$useShow = false;
} else {
$useMain = false;
$useElse = true;
$useShow = false;
}
$newNodes[] = eZTemplateNodeTool::createTextNode('');
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameters['show'], eZTemplateNodeTool::extractFunctionNodePlacement($node), array(), 'show');
$spacing = 4;
$useElse = true;
$useShow = true;
}
}
$children = eZTemplateNodeTool::extractFunctionNodeChildren($node);
if ($useShow) {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( \$show )\n{\n");
$newNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode($spacing);
$newNodes[] = eZTemplateNodeTool::createVariableUnsetNode('show');
}
if (isset($parameters['name']) and !$useLoop) {
$newNodes[] = eZTemplateNodeTool::createNamespaceChangeNode($parameters['name']);
}
$mainNodes = eZTemplateNodeTool::extractNodes($children, array('match' => array('type' => 'before', 'matches' => array(array('match-keys' => array(0), 'match-with' => eZTemplate::NODE_FUNCTION), array('match-keys' => array(2), 'match-with' => 'section-else')), 'filter' => array(array(array('match-keys' => array(0), 'match-with' => eZTemplate::NODE_FUNCTION), array('match-keys' => array(2), 'match-with' => array('delimiter', 'section-exclude', 'section-include')))))));
$delimiterNodes = eZTemplateNodeTool::extractNodes($children, array('match' => array('type' => 'equal', 'matches' => array(array('match-keys' => array(0), 'match-with' => eZTemplate::NODE_FUNCTION), array('match-keys' => array(2), 'match-with' => 'delimiter')))));
$filterNodes = eZTemplateNodeTool::extractNodes($children, array('match' => array('type' => 'equal', 'matches' => array(array('match-keys' => array(0), 'match-with' => eZTemplate::NODE_FUNCTION), array('match-keys' => array(2), 'match-with' => array('section-exclude', 'section-include'))))));
$delimiterNode = false;
if (count($delimiterNodes) > 0) {
$delimiterNode = $delimiterNodes[0];
}
if ($useMain) {
// Avoid transformation if the nodes will not be used, saves time
$mainNodes = eZTemplateCompiler::processNodeTransformationNodes($tpl, $node, $mainNodes, $privateData);
}
if ($useLoop and $useMain) {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $parameters['loop'], eZTemplateNodeTool::extractFunctionNodePlacement($node), array(), 'loopItem');
$hasSequence = false;
if (isset($parameters['sequence'])) {
$sequenceParameter = $parameters['sequence'];
$hasSequence = true;
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $sequenceParameter, eZTemplateNodeTool::extractFunctionNodePlacement($node), array(), 'sequence');
}
if (isset($parameters['name'])) {
$newNodes[] = eZTemplateNodeTool::createNamespaceChangeNode($parameters['name']);
}
$code = "if ( !isset( \$sectionStack ) )\n" . " \$sectionStack = array();\n";
$variableValuePushText = '';
$variableValuePopText = '';
if ($varName) {
$code .= "\$variableValue = new eZTemplateSectionIterator();\n" . "\$lastVariableValue = false;\n";
$variableValuePushText = "&\$variableValue, ";
$variableValuePopText = "\$variableValue, ";
}
$code .= "\$index = 0;\n" . "\$currentIndex = 1;\n";
$arrayCode = '';
$numericCode = '';
$stringCode = '';
$offsetText = '0';
if (isset($parameters['offset'])) {
$offsetParameter = $parameters['offset'];
if (eZTemplateNodeTool::isConstantElement($offsetParameter)) {
$iterationValue = (int) eZTemplateNodeTool::elementConstantValue($offsetParameter);
if ($iterationValue > 0) {
$arrayCode = " \$loopKeys = array_splice( \$loopKeys, {$iterationValue} );\n";
}
$offsetText = $iterationValue;
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $offsetParameter, eZTemplateNodeTool::extractFunctionNodePlacement($node), array(), 'offset');
$arrayCode = " if ( \$offset > 0 )\n" . " \$loopKeys = array_splice( \$loopKeys, \$offset );\n";
$offsetText = "\$offset";
}
}
// Initialization for array
$code .= "if ( is_array( \$loopItem ) )\n{\n" . " \$loopKeys = array_keys( \$loopItem );\n";
if ($reverseLoop) {
$code .= " \$loopKeys = array_reverse( \$loopKeys );\n";
}
$code .= $arrayCode;
$code .= " \$loopCount = count( \$loopKeys );\n";
$code .= "}\n";
// Initialization for numeric
$code .= "else if ( is_numeric( \$loopItem ) )\n{\n" . " \$loopKeys = false;\n" . $numericCode . " if ( \$loopItem < 0 )\n" . " \$loopCountValue = -\$loopItem;\n" . " else\n" . " \$loopCountValue = \$loopItem;\n" . " \$loopCount = \$loopCountValue - {$offsetText};\n" . "}\n";
// Initialization for string
$code .= "else if ( is_string( \$loopItem ) )\n{\n" . " \$loopKeys = false;\n" . $stringCode . " \$loopCount = strlen( \$loopItem ) - {$offsetText};\n" . "}\n";
// Fallback for no item
$code .= "else\n{\n" . " \$loopKeys = false;\n" . " \$loopCount = 0;\n" . "}";
// Initialization end
$newNodes[] = eZTemplateNodeTool::createCodePieceNode($code);
$code = "while ( \$index < \$loopCount )\n" . "{\n";
if ($useMax) {
$code .= " if ( \$currentIndex > {$maxText} )\n" . " break;\n" . " unset( \$item );\n";
}
// Iterator check for array
$code .= " if ( is_array( \$loopItem ) )\n" . " {\n" . " \$loopKey = \$loopKeys[\$index];\n" . " unset( \$item );\n" . " \$item = \$loopItem[\$loopKey];\n" . " }\n";
// Iterator check for numeric
$code .= " else if ( is_numeric( \$loopItem ) )\n" . " {\n" . " unset( \$item );\n";
if ($reverseLoop) {
$code .= " \$item = \$loopCountValue - \$index - {$offsetText};\n";
} else {
$code .= " \$item = \$index + {$offsetText} + 1;\n";
}
$code .= " if ( \$loopItem < 0 )\n" . " \$item = -\$item;\n";
if ($reverseLoop) {
$code .= " \$loopKey = \$loopCountValue - \$index - {$offsetText} - 1;\n";
} else {
$code .= " \$loopKey = \$index + {$offsetText};\n";
}
$code .= " }\n";
// Iterator check for string
$code .= " else if ( is_string( \$loopItem ) )\n" . " {\n" . " unset( \$item );\n";
if ($reverseLoop) {
$code .= " \$loopKey = \$loopCount - \$index - {$offsetText} + 1;\n";
} else {
$code .= " \$loopKey = \$index + {$offsetText};\n";
}
$code .= " \$item = \$loopItem[\$loopKey];\n" . " }\n";
// Iterator check end
$code .= " unset( \$last );\n" . " \$last = false;\n";
$newNodes[] = eZTemplateNodeTool::createCodePieceNode($code);
$code = '';
if ($useLastValue) {
$code .= " if ( \$currentIndex > 1 )\n" . " {\n" . " \$last = \$lastVariableValue;\n" . " \$variableValue = new eZTemplateSectionIterator();\n" . " }\n";
}
if ($varName) {
$code .= " \$variableValue->setIteratorValues( \$item, \$loopKey, \$currentIndex - 1, \$currentIndex, false, \$last );";
$newNodes[] = eZTemplateNodeTool::createCodePieceNode($code);
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'variableValue', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, $varName), false, true, true);
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'loopKey', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, 'key'), false, true, true);
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'item', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, 'item'), false, true, true);
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("\$currentIndexInc = \$currentIndex - 1;\n");
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'currentIndexInc', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, 'index'), false, true, true);
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'currentIndex', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, 'number'), false, true, true);
}
$mainSpacing = 0;
$hasFilter = false;
if (count($filterNodes) > 0) {
$newFilterNodes = array();
$matchValue = true;
$hasDynamicFilter = false;
foreach ($filterNodes as $filterNode) {
$filterParameters = eZTemplateNodeTool::extractFunctionNodeParameters($filterNode);
if (!isset($filterParameters['match'])) {
continue;
}
$hasFilter = true;
$filterParameterMatch = $filterParameters['match'];
$filterParameterMatch = eZTemplateCompiler::processElementTransformationList($tpl, $filterNode, $filterParameterMatch, $privateData);
if (eZTemplateNodeTool::isConstantElement($filterParameterMatch)) {
$matchValue = eZTemplateNodeTool::elementConstantValue($filterParameterMatch);
if (eZTemplateNodeTool::extractFunctionNodeName($filterNode) == 'section-exclude') {
if ($matchValue) {
$matchValue = false;
}
} else {
if ($matchValue) {
$matchValue = true;
}
}
$newFilterNodes = array();
$hasDynamicFilter = false;
} else {
$newFilterNodes[] = eZTemplateNodeTool::createVariableNode(false, $filterParameterMatch, eZTemplateNodeTool::extractFunctionNodePlacement($filterNode), array('spacing' => 4), 'tmpMatchValue');
if (eZTemplateNodeTool::extractFunctionNodeName($filterNode) == 'section-exclude') {
$newFilterNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( \$tmpMatchValue )\n \$matchValue = false;", array('spacing' => 4));
} else {
$newFilterNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( \$tmpMatchValue )\n \$matchValue = true;", array('spacing' => 4));
}
$hasDynamicFilter = true;
}
}
if ($hasFilter) {
$mainSpacing += 4;
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $matchValue, eZTemplateNodeTool::extractFunctionNodePlacement($filterNode), array('spacing' => 4), 'matchValue');
if ($hasDynamicFilter) {
$newNodes = array_merge($newNodes, $newFilterNodes);
}
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( \$matchValue )\n{\n", array('spacing' => 4));
}
}
$sequencePopText = '';
if ($hasSequence) {
$sequencePopText = ", \$sequence";
if ($varName) {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( is_array( \$sequence ) )\n" . "{\n" . " \$sequenceValue = array_shift( \$sequence );\n" . " \$variableValue->setSequence( \$sequenceValue );\n" . " \$sequence[] = \$sequenceValue;\n" . " unset( \$sequenceValue );\n" . "}", array('spacing' => $mainSpacing + 4));
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'variableValue', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, $varName), false, true, true);
} else {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( is_array( \$sequence ) )\n" . "{\n" . " \$sequenceValue = array_shift( \$sequence );\n", array('spacing' => $mainSpacing + 4));
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, 'sequenceValue', eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => $mainSpacing + 4), array('', eZTemplate::NAMESPACE_SCOPE_RELATIVE, 'sequence'), false, true, true);
$newNodes[] = eZTemplateNodeTool::createCodePieceNode(" \$sequence[] = \$sequenceValue;\n" . " unset( \$sequenceValue );\n" . "}", array('spacing' => $mainSpacing + 4));
}
}
$code = "\$sectionStack[] = array( " . $variableValuePushText . "&\$loopItem, \$loopKeys, \$loopCount, \$currentIndex, \$index" . $sequencePopText . $maxPopText . " );\n" . "unset( \$loopItem, \$loopKeys );\n";
$newNodes[] = eZTemplateNodeTool::createCodePieceNode($code, array('spacing' => $mainSpacing + 4));
$newNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode($mainSpacing + 4);
if ($delimiterNode) {
$delimiterChildren = eZTemplateNodeTool::extractFunctionNodeChildren($delimiterNode);
$delimiterParameters = eZTemplateNodeTool::extractFunctionNodeParameters($delimiterNode);
$delimiterChildren = eZTemplateCompiler::processNodeTransformationNodes($tpl, $node, $delimiterChildren, $privateData);
$delimiterModulo = false;
$matchCode = false;
$useModulo = true;
if (isset($delimiterParameters['match'])) {
$delimiterMatch = $delimiterParameters['match'];
$delimiterMatch = eZTemplateCompiler::processElementTransformationList($tpl, $delimiterNode, $delimiterMatch, $privateData);
if (eZTemplateNodeTool::isConstantElement($delimiterMatch)) {
$moduloValue = eZTemplateNodeTool::elementConstantValue($delimiterMatch);
$useModulo = false;
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $delimiterMatch, eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 0), 'matchValue');
$matchCode = " and \$matchValue";
}
} else {
if (isset($delimiterParameters['modulo'])) {
$delimiterModulo = $delimiterParameters['modulo'];
$delimiterModulo = eZTemplateCompiler::processElementTransformationList($tpl, $delimiterModulo, $delimiterModulo, $privateData);
if (eZTemplateNodeTool::isConstantElement($delimiterModulo)) {
$moduloValue = (int) eZTemplateNodeTool::elementConstantValue($delimiterModulo);
$matchCode = " and ( ( \$currentIndex - 1 ) % {$moduloValue} ) == 0";
} else {
$newNodes[] = eZTemplateNodeTool::createVariableNode(false, $delimiterModulo, eZTemplateNodeTool::extractFunctionNodePlacement($node), array('spacing' => 0), 'moduloValue');
$matchCode = " and ( ( \$currentIndex - 1 ) % \$moduloValue ) == 0";
}
}
}
if ($useModulo) {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("if ( \$currentIndex > 1{$matchCode} )\n{");
$newNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode(4);
$newNodes = array_merge($newNodes, $delimiterChildren);
$newNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode(4);
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("}\n");
}
}
$newNodes = array_merge($newNodes, $mainNodes);
$newNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode($mainSpacing + 4);
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("list( " . $variableValuePopText . "\$loopItem, \$loopKeys, \$loopCount, \$currentIndex, \$index" . $sequencePopText . $maxPopText . " ) = array_pop( \$sectionStack );", array('spacing' => $mainSpacing + 4));
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("++\$currentIndex;\n", array('spacing' => $mainSpacing + 4));
if ($varName) {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("\$lastVariableValue = \$variableValue;", array('spacing' => $mainSpacing + 4));
}
if ($hasFilter) {
$newNodes[] = eZTemplateNodeTool::createCodePieceNode(" }");
$mainSpacing -= 4;
}
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("++\$index;\n", array('spacing' => $mainSpacing + 4));
$code = "}\n" . "unset( \$loopKeys, \$loopCount, \$index, \$last, \$loopIndex, \$loopItem";
if ($hasSequence) {
$code .= ", \$sequence";
}
$code .= " );";
$newNodes[] = eZTemplateNodeTool::createCodePieceNode($code);
} else {
if ($useMain) {
$newNodes = array_merge($newNodes, $mainNodes);
}
}
if (isset($parameters['name'])) {
$newNodes[] = eZTemplateNodeTool::createNamespaceRestoreNode();
}
if ($useShow) {
$newNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode($spacing);
}
if ($useElse) {
$elseNodes = eZTemplateNodeTool::extractNodes($children, array('match' => array('type' => 'after', 'matches' => array(array('match-keys' => array(0), 'match-with' => eZTemplate::NODE_FUNCTION), array('match-keys' => array(2), 'match-with' => 'section-else')))));
$elseNodes = eZTemplateCompiler::processNodeTransformationNodes($tpl, $node, $elseNodes, $privateData);
if (count($elseNodes) > 0) {
if ($useShow) {
// This is needed if a 'if ( $show )' was used earlier
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("}\nelse\n{\n");
$newNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode($spacing);
$newNodes[] = eZTemplateNodeTool::createVariableUnsetNode('show');
}
if (isset($parameters['name'])) {
$newNodes[] = eZTemplateNodeTool::createNamespaceChangeNode($parameters['name']);
}
$newNodes = array_merge($newNodes, $elseNodes);
if (isset($parameters['name'])) {
$newNodes[] = eZTemplateNodeTool::createNamespaceRestoreNode();
}
if ($useShow) {
// This is needed if a 'if ( $show )' was used earlier
$newNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode($spacing);
}
}
if ($useShow) {
// This is needed if a 'if ( $show )' was used earlier
$newNodes[] = eZTemplateNodeTool::createCodePieceNode("}\n");
}
}
return $newNodes;
}
function processChildren()
{
// process the loop body
$children = eZTemplateNodeTool::extractFunctionNodeChildren( $this->Node );
$transformedChildren = eZTemplateCompiler::processNodeTransformationNodes( $this->Tpl, $this->Node, $children, $this->PrivateData );
$childrenNodes = array();
$delimiter = null;
if ( is_array( $transformedChildren ) )
{
foreach ( $transformedChildren as $child )
{
if ( $child[0] == eZTemplate::NODE_FUNCTION ) // check child type
{
$childFunctionName = $child[2];
if ( $childFunctionName == 'delimiter' )
{
// save delimiter for it to be processed below
$delimiter = $child;
continue;
}
elseif ( $childFunctionName == 'break' )
{
$childrenNodes[] = eZTemplateNodeTool::createCodePieceNode( "break;\n" );
continue;
}
elseif ( $childFunctionName == 'continue' )
{
$childrenNodes[] = eZTemplateNodeTool::createCodePieceNode( "continue;\n" );
continue;
}
elseif ( $childFunctionName == 'skip' )
{
$childrenNodes[] = eZTemplateNodeTool::createCodePieceNode( "\$skipDelimiter = true;\ncontinue;\n" );
continue;
}
}
$childrenNodes[] = $child;
}
}
if ( $delimiter ) // if delimiter is specified
{
$delimiterNodes = eZTemplateNodeTool::extractNodes( $children,
array( 'match' => array( 'type' => 'equal',
'matches' => array( array( 'match-keys' => array( 0 ),
'match-with' => eZTemplate::NODE_FUNCTION ),
array( 'match-keys' => array( 2 ),
'match-with' => 'delimiter' ) ) ) ) );
$delimiterNode = false;
if ( count( $delimiterNodes ) > 0 )
$delimiterNode = $delimiterNodes[0];
$delimiterChildren = eZTemplateNodeTool::extractFunctionNodeChildren( $delimiterNode );
$delimiterParameters = eZTemplateNodeTool::extractFunctionNodeParameters( $delimiterNode );
$checkModulo = array();
$checkModuloEnd = array();
$delemiterModuloValue = array();
if ( isset( $delimiterParameters['modulo'] ) )
{
switch ( $this->Name )
{
case 'foreach':
{
$delimiterModulo = $delimiterParameters['modulo'];
$delimiterModulo = eZTemplateCompiler::processElementTransformationList( $this->Tpl, $delimiterModulo, $delimiterModulo, $this->PrivateData );
// Get unique index
$currentIndex = "\$fe_i_$this->UniqID";
if ( eZTemplateNodeTool::isConstantElement( $delimiterModulo ) )
{
$moduloValue = (int)eZTemplateNodeTool::elementConstantValue( $delimiterModulo );
$matchCode = "( ( $currentIndex ) % $moduloValue ) == 0";
}
else
{
$delemiterModuloValue[] = eZTemplateNodeTool::createVariableNode( false, $delimiterModulo, eZTemplateNodeTool::extractFunctionNodePlacement( $this->Node ),
array( 'spacing' => 0 ), 'moduloValue' );
$matchCode = "( ( $currentIndex ) % \$moduloValue ) == 0";
}
$checkModulo[] = eZTemplateNodeTool::createCodePieceNode( "if ( $matchCode ) // Check modulo\n{" );
$checkModulo[] = eZTemplateNodeTool::createSpacingIncreaseNode( 4 );
$checkModuloEnd[] = eZTemplateNodeTool::createSpacingDecreaseNode( 4 );
$checkModuloEnd[] = eZTemplateNodeTool::createCodePieceNode( "}\n" );
}
}
}
$delimiterNodes = array();
$delimiterNodes[] = eZTemplateNodeTool::createCodePieceNode( "if ( \$skipDelimiter )\n" .
" \$skipDelimiter = false;\n" .
"else\n" .
"{ // delimiter begins" );
$delimiterNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode();
if ( is_array( $delimiter[1] ) ) // if delimiter has children
{
// If modulo is specified
$delimiterNodes = array_merge( $delimiterNodes, $checkModulo );
foreach ( $delimiter[1] as $delimiterChild )
$delimiterNodes[] = $delimiterChild;
// Set end of checking for modulo
$delimiterNodes = array_merge( $delimiterNodes, $checkModuloEnd );
}
$delimiterNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode();
$delimiterNodes[] = eZTemplateNodeTool::createCodePieceNode( "} // delimiter ends\n" );
// we place its code right before other loop children,
// if delemiter and modulo are specified and value of modulo is not static
// $delemiterModuloValue is initialization of variable
// we should place initialization of moduloValue before checking for delimiter
$childrenNodes = array_merge( $delemiterModuloValue, $delimiterNodes, $childrenNodes );
}
$this->NewNodes = array_merge( $this->NewNodes, $childrenNodes );
}
