in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Nov 11, 10:23 PM

in-portal
View Options

	Index: branches/unlabeled/unlabeled-1.24.2/core/kernel/parser/template_parser.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.24.2/core/kernel/parser/template_parser.php (revision 5892)
	+++ branches/unlabeled/unlabeled-1.24.2/core/kernel/parser/template_parser.php (revision 5893)
	@@ -1,673 +1,673 @@
	<?php

	k4_include_once(KERNEL_PATH.'/parser/tags.php');
	k4_include_once(KERNEL_PATH.'/parser/construct_tags.php');

	class TemplateParser extends kBase {
	var $Template;
	var $Output = '';
	var $Position = 0;
	var $LastPosition = 0;

	var $Ses;
	var $Recursion = Array();
	var $RecursionIndex = 0;
	var $SkipMode = 0;
	var $Params = Array();
	var $Pattern = Array();
	var $ForSort = Array();
	var $Values = Array();
	var $Buffers = Array();
	var $Args;

	var $ParamsRecursionIndex = 0;
	var $ParamsStack = Array();

	var $CompiledBuffer;

	var $DataExists = false;

	function TemplateParser()
	{
	parent::kBase();
	$this->Ses =& $this->Application->recallObject('Session');
	}

	function AddParam($pattern, $value, $dont_sort=0)
	{
	$this->ForSort[] = Array($pattern, $value);
	if (!$dont_sort) //used when mass-adding params, to escape sorting after every new param
	$this->SortParams(); //but do sort by default!
	}

	//We need to sort params by its name length desc, so that params starting with same word get parsed correctly
	function SortParams()
	{
	uasort($this->ForSort, array ("TemplateParser", "CmpParams"));

	// commented out by Kostja, otherwise when rednerElement is done into var (result_to_var) the other params are reset
	// $this->Pattern = Array();
	// $this->Values = Array();
	foreach($this->ForSort as $pair)
	{
	$this->Pattern[] = $pair[0];
	$this->Values[] = $pair[1];
	}
	}

	function CmpParams($a, $b)
	{
	$a_len = strlen($a[0]);
	$b_len = strlen($b[0]);
	if ($a_len == $b_len) return 0;
	return $a_len > $b_len ? -1 : 1;
	}

	function SetParams($params, $for_parsing=true)
	{
	if (!is_array($params)) $params = Array();

	$this->ForSort = array();
	$this->Params = $params;
	$this->ParamsStack[$this->ParamsRecursionIndex] = $params;

	if (!$for_parsing) return ;

	foreach ($params as $key => $val) {
	$this->AddParam('/[{]{0,1}\$'.$key.'[}]{0,1}/i', $val, 1); //Do not sort every time
	}
	$this->SortParams(); //Sort once after adding is done
	}

	/**
	* Returns parser parameter value at specified deep level
	*
	* @param string $name
	* @param int $deep_level if greather then 0 then use from ParamsStack
	* @return mixed
	*/
	function GetParam($name, $deep_level = 0)
	{
	if ($deep_level > 0) {
	return isset($this->ParamsStack[$deep_level][$name]) ? $this->ParamsStack[$deep_level][$name] : false;
	}

	return isset($this->Params[$name]) ? $this->Params[$name] : false;
	}

	/**
	* Set's template parser parameter, that could be retrieved from template
	*
	* @param string $name
	* @param mixed $value
	*/
	function SetParam($name, $value)
	{
	$this->Params[strtolower($name)] = $value;
	$this->AddParam('/[{]{0,1}\$'.$name.'[}]{0,1}/i', $value, $this->FromPreParseCache);
	}

	function SetBuffer($body)
	{
	$this->Buffers[$this->RecursionIndex] = $body;
	}

	function GetBuffer()
	{
	return $this->Buffers[$this->RecursionIndex];
	}

	function GetCode()
	{
	return $this->Code[$this->RecursionIndex];
	}

	function AppendBuffer($append)
	{
	$this->Buffers[$this->RecursionIndex] .= $append;
	$this->AppendCode( $this->ConvertToCode($append) );
	}

	function AppendOutput($append, $append_code=false)
	{
	if ($this->SkipMode == parse) {
	$this->Output .= $append; //append to Ouput only if we are parsing
	if ($append_code) $this->AppendCompiledHTML($append);
	}
	elseif ($this->SkipMode == skip) {
	if ($append_code) $this->AppendCompiledHTML($append);
	}
	elseif ($this->SkipMode == skip_tags) {
	$this->AppendBuffer($append); //append to buffer if we are skipping tags
	}
	}

	function ConvertToCode($data)
	{
	$code = '$o .= \''. str_replace("'", "\'", $data) .'\';';
	$code = explode("\n", $code);
	return $code;
	}

	function AppendCode($code)
	{
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	if (!isset($this->Code[$this->RecursionIndex])) {
	$this->Code[$this->RecursionIndex] = Array();
	}
	if (is_array($code)) {
	foreach ($code as $line) {
	$this->Code[$this->RecursionIndex][] = rtrim($line, "\n")."\n";
	}
	}
	else {
	$this->Code[$this->RecursionIndex][] .= rtrim($code, "\n")."\n";
	}
	}
	}

	function AppendCompiledFunction($f_name, $f_body)
	{
	$real_name = 'f_'.abs(crc32($this->TemplateName)).'_'.$f_name;
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	// if such function already compiled
	if ( isset($this->Application->CompiledFunctions[$f_name]) \|\|
	function_exists($real_name)
	)
	{
	if (!isset($this->Application->CompiledFunctions[$f_name])) {
	$real_name = $real_name.'_';
	}
	else {
	$real_name = $this->Application->CompiledFunctions[$f_name].'_';
	}
	}

	$this->CompiledBuffer .= "\t".'$application->PreParsedBlocks[\''.$f_name.'\'] = \''.$real_name.'\';'."\n";
	$this->CompiledBuffer .= 'if (!function_exists(\''.$real_name.'\')) {'."\n";
	$this->CompiledBuffer .= "\t".'function '.$real_name.'($params)'."\n\t{\n";
	$this->CompiledBuffer .= $f_body;
	$this->CompiledBuffer .= "\t}\n\n";
	$this->CompiledBuffer .= '}'."\n";

	$this->Application->CompiledFunctions[$f_name] = $real_name;

	}
	}

	function AppendCompiledCode($code)
	{
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	if (is_array($code)) {
	foreach ($code as $line) {
	$this->CompiledBuffer .= "\t".rtrim($line, "\n")."\n";
	}
	}
	else {
	$this->CompiledBuffer .= $code;
	}
	$this->CompiledBuffer .= "\t".'echo $o;'."\n\t".'$o = \'\';'."\n";
	}
	}

	function AppendCompiledHTML($append)
	{
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	$this->CompiledBuffer .= '?'.'>'."\n";
	$this->CompiledBuffer .= rtrim($append, "\t");
	$this->CompiledBuffer .= '<'.'?php'."\n";
	}
	}

	function ResetCode()
	{
	$this->Code[$this->RecursionIndex] = Array();
	}

	function FindTag2()
	{
	$openings = Array('<%' => '%>', '<inp2:' => Array('>', '/>'), '</inp2:' => '>', '</inp2>' => '', '<!--' => '-->');

	$tag_open_pos = false;
	foreach ($openings as $an_opening => $closings) {
	$pos = strpos($this->Template, $an_opening, $this->Position);
	if ($pos !== false && ($tag_open_pos === false \|\| (int) $pos <= (int) $tag_open_pos)) {
	$tag_open_pos = $pos;
	$open_len = strlen($an_opening);
	$opening_tag = $an_opening;
	$tag_closings = $closings;
	}
	}

	if ($tag_open_pos === false) { //If no tags left - adding all other data
	$this->AppendOutput(substr($this->Template, $this->Position), true);
	return false;
	}

	//Adding all data before tag open
	$this->AppendOutput(substr($this->Template, $this->Position, $tag_open_pos - $this->Position), true);

	if (is_array($tag_closings)) {
	$tag_close_pos = false;
	foreach ($tag_closings as $a_closing) {
	$pos = strpos($this->Template, $a_closing, $tag_open_pos);
	if ($pos !== false && ($tag_close_pos === false \|\| (int) $pos <= (int) $tag_close_pos)) {
	$tag_close_pos = $pos;
	$closing_tag = $a_closing;
	}
	}
	}
	elseif ($opening_tag == '</inp2>') {
	$closing_tag = '';
	$tag_close_pos = $tag_open_pos + $open_len;
	}
	else {
	$closing_tag = $tag_closings;
	$tag_close_pos = strpos($this->Template, $closing_tag, $tag_open_pos);
	}
	$close_len = strlen($closing_tag);

	//Cutting out the tag itself
	$tag = substr($this->Template, $tag_open_pos + $open_len, $tag_close_pos - $tag_open_pos - $open_len);


	if ($opening_tag == '<inp2:') {
	//getting prefix_tag upto first space, tab or line break into regs[1]
	preg_match("/^([^ \t\n])(.)/", $tag, $regs);
	$tag_part = $regs[1];

	if (strpos($tag_part, '_') !== false) {
	list($prefix, $the_tag) = explode('_', $tag, 2);
	/preg_match('/(.)_(.*)/', $tag_part, $rets);
	$prefix = $rets[1];
	$the_tag = $rets[2].$regs[2];*/

	$tag = $prefix.':'.$the_tag;
	}
	else {
	$the_tag = $tag;
	$tag = ':'.$tag;
	}
	}

	if ($opening_tag == '</inp2>') { //empty closing means old style in-portal if <inp2:tag>....</inp2>
	$tag = 'm:endif';
	}

	if ($opening_tag == '</inp2:') {
	preg_match("/^([^ \t\n])(.)/", $tag, $regs);
	$tag_part = $regs[1];
	if (strpos($tag_part, '_') !== false) {
	list($prefix, $the_tag) = explode('_', $tag, 2);
	$tag = $prefix.':'.$the_tag;
	}
	$tag .= ' _closing_tag_="1"';
	}

	// if there is no prefix for the tag
	if (strpos($tag, ':') === 0) {
	$prefix = getArrayValue($this->Params, 'PrefixSpecial');
	- $tag = $prefix.$tag;
	+ $tag = $prefix.$tag.' _auto_prefix_="1"';
	}

	// temporary - for backward compatability with in-portal style if
	if ($opening_tag == '<inp2:' && $closing_tag == '>' && $tag_part != 'm_if' && $tag_part != 'm_DefineElement') {
	if (strpos($the_tag, ' ') !== false) {
	list($function, $params) = explode(' ', $the_tag, 2);
	}
	else {
	$function = $the_tag;
	$params = '';
	}
	$tag = 'm:if prefix="'.$prefix.'" function="'.$function.'" '.$params;
	}

	if ($opening_tag == '<!--') {
	$this->AppendOutput('<!-- '.$tag. '-->');
	$tag = '__COMMENT__';
	}

	$this->Position = $tag_close_pos + $close_len;
	return $tag;
	}

	function CurrentLineNumber()
	{
	return substr_count(substr($this->Template, 0, $this->Position), "\n")+1;
	}

	function SkipModeName()
	{
	switch ($this->SkipMode) {
	case skip: return 'skip';
	case skip_tags: return 'skip_tags';
	case parse: return 'parse';
	}
	}

	/**
	* Recursive mkdir
	*
	* @param string $dir
	* @param string $base_path base path to directory where folders should be created in
	*/
	function CheckDir($dir, $base_path = '')
	{
	if (file_exists($dir)) {
	return;
	}
	else {
	// remove $base_path from beggining because it is already created during install
	$dir = preg_replace('/^'.preg_quote($base_path.'/', '/').'/', '', $dir, 1);
	$segments = explode('/', $dir);
	$cur_path = $base_path;

	foreach ($segments as $segment) {
	// do not add leading / for windows paths (c:\...)
	$cur_path .= preg_match('/^[a-zA-Z]{1}:/', $segment) ? $segment : '/'.$segment;
	if (!file_exists($cur_path)) {
	mkdir($cur_path);
	}
	}
	}
	}

	function ParseTemplate($name, $pre_parse = 1, $params=array(), $silent=0)
	{
	$this->FromPreParseCache = false;
	if ($this->GetParam('from_inportal')) $pre_parse = 0;
	if ($pre_parse) {
	$pre_parsed = $this->Application->TemplatesCache->GetPreParsed($name);
	if ($pre_parsed && $pre_parsed['active']) { // active means good (not expired) pre-parsed cache
	$this->FromPreParseCache = true;
	$this->SetParams($params, 0); // 0 to disable params sorting and regexp generation - not needed when processing pre-parsed
	ob_start();
	if ($pre_parsed['mode'] == 'file') {
	include($pre_parsed['fname']);
	}
	else {
	eval('?'.'>'.$pre_parsed['content']);
	}
	$output = ob_get_contents();
	ob_end_clean();
	}
	else {
	$this->SetParams($params);

	$this->CompiledBuffer .= '<'.'?php'."\n";
	$this->CompiledBuffer .= 'global $application;'."\n";

	$this->CompiledBuffer .= '$params =& $application->Parser->Params;'."\n";
	$this->CompiledBuffer .= 'extract($params);'."\n";

	$this->CompiledBuffer .= '$o = \'\';'."\n";

	$output = $this->NewParse($this->Application->TemplatesCache->GetTemplateBody($name, $silent), $name);

	$this->CompiledBuffer .= '?'.'>'."\n";

	if (defined('SAFE_MODE') && SAFE_MODE) {
	if (!isset($conn)) $conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE INTO '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ('.$conn->qstr($pre_parsed['fname']).','.$conn->qstr($this->CompiledBuffer).','.adodb_mktime().')');
	}
	else {
	$compiled = fopen($pre_parsed['fname'], 'w');
	fwrite($compiled, $this->CompiledBuffer);
	fclose($compiled);
	}

	}
	if ( !$this->GetParam('from_inportal') && strpos($output, '<inp:') !== false) {
	$inp1_parser =& $this->Application->recallObject('Inp1Parser');
	$output = $inp1_parser->NewParse($name, $output);
	}
	return $output;
	}

	// pre-parse is OFF
	$this->SetParams($params);
	return $this->NewParse($this->Application->TemplatesCache->GetTemplateBody($name), $name, $pre_parse);
	}

	function NewParse($template, $name='unknown', $pre_parse = 1)
	{
	$this->Template = $template;
	$this->TemplateName = $name;
	$this->Position = 0;
	$this->Output = '';
	$this->TagHolder = new MyTagHolder();

	$has_inp_tags = false;

	if (!getArrayValue($this->Params, 'PrefixSpecial')) {
	$this->Params['PrefixSpecial'] = '$PrefixSpecial';
	}

	//While we have more tags
	while ($tag_data = $this->FindTag2())
	{
	if ($tag_data == '__COMMENT__') continue;
	//Create tag object from passed tag data
	if( $this->Application->isDebugMode() && constOn('DBG_SHOW_TAGS') )
	{
	global $debugger;
	$debugger->appendHTML('mode: '.$this->SkipModeName().' tag '.$debugger->highlightString($tag_data).' in '.$debugger->getFileLink($debugger->getLocalFile(FULL_PATH.THEMES_PATH.'/'.$this->TemplateName).'.tpl', $this->CurrentLineNumber(), '', true));
	}
	$tag =& $this->TagHolder->GetTag($tag_data, $this);

	if (!$this->CheckRecursion($tag)) //we do NOT process closing tags
	{
	$tag->Process();
	}
	}
	return $this->Output;
	}

	function Parse($template, $name='unknown', $pre_parse = 1)
	{
	$this->Template = $template;
	$this->TemplateName = $name;
	$this->Position = 0;
	$this->Output = '';
	$this->TagHolder = new MyTagHolder();

	$has_inp_tags = false;

	if ($this->GetParam('from_inportal')) $pre_parse = 0;

	if (defined('EXPERIMENTAL_PRE_PARSE') && $pre_parse) {
	$fname = $this->Application->TemplatesCache->GetRealFilename($this->TemplateName).'.php';

	$fname = str_replace(FULL_PATH, FULL_PATH.'/kernel/cache', $fname);

	if (!defined('SAFE_MODE') \|\| !SAFE_MODE) {
	$this->CheckDir(dirname($fname), FULL_PATH.'/kernel/cache');
	}

	$tname = $this->Application->TemplatesCache->GetRealFilename($this->TemplateName).'.tpl';
	$output = '';
	$is_cached = false;
	ob_start();
	if (defined('SAFE_MODE') && SAFE_MODE) {
	$conn =& $this->Application->GetADODBConnection();
	$cached = $conn->GetRow('SELECT * FROM '.TABLE_PREFIX.'Cache WHERE VarName = "'.$fname.'"');
	if ($cached !== false && $cached['Cached'] > filemtime($tname)) {
	eval('?'.'>'.$cached['Data']);
	$is_cached = true;
	}
	}
	else {
	if (file_exists($fname) && file_exists($tname) && filemtime($fname) > filemtime($tname)) {
	include($fname);
	$is_cached = true;
	}
	}
	$output = ob_get_contents();
	ob_end_clean();

	if ( $is_cached && !$this->GetParam('from_inportal') ) {
	if ( strpos($output, '<inp:') !== false) {
	$inp1_parser =& $this->Application->recallObject('Inp1Parser');
	$output = $inp1_parser->Parse($name, $output);
	}
	return $output;
	}

	$this->CompiledBuffer .= '<'.'?php'."\n";
	$this->CompiledBuffer .= 'global $application;'."\n";

	$this->CompiledBuffer .= '$params =& $application->Parser->Params;'."\n";
	$this->CompiledBuffer .= 'extract($params);'."\n";

	$this->CompiledBuffer .= '$o = \'\';'."\n";
	}

	if (!getArrayValue($this->Params, 'PrefixSpecial')) {
	$this->Params['PrefixSpecial'] = '$PrefixSpecial';
	}

	//While we have more tags
	while ($tag_data = $this->FindTag2())
	{
	if ($tag_data == '__COMMENT__') continue;
	//Create tag object from passed tag data
	if( $this->Application->isDebugMode() && constOn('DBG_SHOW_TAGS') )
	{
	global $debugger;
	$debugger->appendHTML('mode: '.$this->SkipModeName().' tag '.$debugger->highlightString($tag_data).' in '.$debugger->getFileLink($debugger->getLocalFile(FULL_PATH.THEMES_PATH.'/'.$this->TemplateName).'.tpl', $this->CurrentLineNumber(), '', true));
	}
	// $tag =& new MyTag($tag_data, $this);
	$tag =& $this->TagHolder->GetTag($tag_data, $this);

	if (!$this->CheckRecursion($tag)) //we do NOT process closing tags
	{
	$tag->Process();
	}
	}

	if ( !$this->GetParam('from_inportal') ) {
	if ( strpos($this->Output, '<inp:') !== false) {
	$inp1_parser =& $this->Application->recallObject('Inp1Parser');
	$this->Output = $inp1_parser->Parse($name, $this->Output);
	$has_inp_tags = true;
	}
	}


	if (defined('EXPERIMENTAL_PRE_PARSE') && $pre_parse && !$has_inp_tags) {
	// $this->CompiledBuffer .= 'echo $o;'."\n";
	$this->CompiledBuffer .= '?'.'>'."\n";

	if (defined('SAFE_MODE') && SAFE_MODE) {
	if (!isset($conn)) $conn =& $this->Application->GetADODBConnection();
	$conn->Query('REPLACE INTO '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ('.$conn->qstr($fname).','.$conn->qstr($this->CompiledBuffer).','.adodb_mktime().')');
	}
	else {
	$compiled = fopen($fname, 'w');
	fwrite($compiled, $this->CompiledBuffer);
	fclose($compiled);
	}
	}

	return $this->Output;
	}

	function ParseBlock($params, $force_pass_params=0, $as_template=false)
	{
	if( $this->Application->isDebugMode() && constOn('DBG_SHOW_TAGS') )
	{
	global $debugger;
	$debugger->appendHTML('ParseBlock '.$params['name'].' pass_params is '.$params['pass_params'].' force is '.$force_pass_params.' in '.$debugger->getFileLink($debugger->getLocalFile(FULL_PATH.THEMES_PATH.'/'.$this->TemplateName).'.tpl', $this->CurrentLineNumber(), '', true));

	}
	/*if ( $this->Application->isDebugMode() && constOn('DBG_PRE_PARSE') ) {
	global $debugger;
	$debugger->CurrentPreParsedBlock = $params['name'];
	}*/
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	$this->MainParser = false;
	if (isset($this->Application->PreParsedBlocks[$params['name']]) ) {

	if ($this->ParamsRecursionIndex == 0) {
	$this->ParamsStack[$this->ParamsRecursionIndex] = $this->Params;
	}

	if (isset($params['pass_params']) \|\| $force_pass_params) {
	$pass_params = array_merge($this->ParamsStack[$this->ParamsRecursionIndex], $params);
	}
	else {
	$pass_params = $params;
	}

	$this->ParamsStack[++$this->ParamsRecursionIndex] = $pass_params;
	$this->Params = $pass_params;

	$f = $this->Application->PreParsedBlocks[$params['name']];

	// $this->ParamsRecursionIndex--;

	//$this->SetParams($params);
	if( !isset($pass_params['PrefixSpecial']) && isset($pass_params['prefix']) ) $pass_params['PrefixSpecial'] = $pass_params['prefix'];

	$ret = $f($pass_params);

	unset($this->ParamsStack[$this->ParamsRecursionIndex--]);
	$this->Params = $this->ParamsStack[$this->ParamsRecursionIndex];
	$this->MainParser = true;
	return $ret;
	}
	}

	$BlockParser =& $this->Application->makeClass('TemplateParser');
	if (isset($params['pass_params']) \|\| $force_pass_params) {
	$BlockParser->SetParams(array_merge($this->Params, $params));
	}
	else
	$BlockParser->SetParams($params);
	$this->Application->Parser =& $BlockParser;
	if (!isset($params['name'])) trigger_error('<b>***Error: Block name not passed to ParseBlock</b>', E_USER_ERROR);
	$templates_cache =& $this->Application->recallObject('TemplatesCache');

	$template_name = $as_template ? $params['name'] : $templates_cache->GetTemplateFileName($params['name']) . '-block:'.$params['name'];

	$silent = getArrayValue($params, 'from_inportal') && !defined('DBG_TEMPLATE_FAILURE');

	$o = $BlockParser->Parse(
	$templates_cache->GetTemplateBody($params['name'], $silent),
	$template_name
	);
	if (getArrayValue($params, 'BlockNoData') && !$BlockParser->DataExists) {
	$template_name = $as_template ? $params['BlockNoData'] : $templates_cache->GetTemplateFileName($params['BlockNoData']) . '-block:'.$params['BlockNoData'];
	$o = $BlockParser->Parse(
	$templates_cache->GetTemplateBody($params['BlockNoData'], $silent),
	$template_name
	);
	}
	$this->Application->Parser =& $this;
	$this->Application->Parser->DataExists = $this->Application->Parser->DataExists \|\| $BlockParser->DataExists;
	return $o;
	}

	function Recurve(&$tag)
	{
	$this->Recursion[++$this->RecursionIndex] =& $tag;
	}

	function CheckRecursion(&$tag)
	{
	if ($this->RecursionIndex > 0) { //If we are inside the recursion
	if ($this->Recursion[$this->RecursionIndex]->CheckRecursion($tag)) { //If we can close this recursion
	unset($this->Recursion[$this->RecursionIndex--]); //unsetting current recursion level and decreasing it at the same time
	return true; //we should inform not to process closing tag
	}
	}
	return false;
	}

	function SetSkipMode($mode)
	{
	$this->SkipMode = $mode;
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.24.2/core/kernel/parser/template_parser.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.24.2.7
	\ No newline at end of property
	+1.24.2.8
	\ No newline at end of property
	Index: branches/unlabeled/unlabeled-1.12.2/core/kernel/parser/tags.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.12.2/core/kernel/parser/tags.php (revision 5892)
	+++ branches/unlabeled/unlabeled-1.12.2/core/kernel/parser/tags.php (revision 5893)
	@@ -1,420 +1,434 @@
	<?php

	define ('parse', 0);
	define ('skip', 1);
	define ('skip_tags', 2);

	class MyTagHolder extends kBase {

	var $_Tag;

	function MyTagHolder()
	{

	}

	function &GetTag($tag_data, &$parser, $inp_tag = 0)
	{
	if (!isset($this->_Tag)) {
	$this->_Tag =& new Tag($tag_data, $parser, $inp_tag);
	}
	else {
	// $this->_Tag->Parser =& $parser;
	$this->_Tag->TagData = $tag_data;
	if ($tag_data != '') $this->_Tag->ParseTagData($tag_data);
	$this->_Tag->NP =& $this->_Tag->NamedParams;
	}
	return $this->_Tag;
	}

	}

	class Tag extends kBase {
	var $Processor;
	var $Tag;
	var $Params = Array();
	var $NamedParams = Array();
	var $NP;
	/**
	* Enter description here...
	*
	* @var TemplateParser
	*/
	var $Parser;
	var $TagData = '';

	function Tag($tag_data, &$parser, $inp_tag=0)
	{
	parent::kBase();
	$this->Parser =& $parser;
	$this->TagData = $tag_data;
	if ($tag_data != '') $this->ParseTagData($tag_data);
	$this->NP =& $this->NamedParams;
	}

	function CopyFrom(&$tag)
	{
	$this->Processor = $tag->Processor;
	$this->Tag = $tag->Tag;
	$this->TagData = $tag->TagData;
	$this->Params = $tag->Params;
	$this->NamedParams = $tag->NamedParams;
	$this->Parser =& $tag->Parser;
	}

	function GetFullTag()
	{
	return '<%'.$this->TagData.'%>';
	}

	function RebuildTagData()
	{
	$res = $this->Processor.':'.$this->Tag.' ';
	foreach ($this->NamedParams as $name => $value) {
	$res .= "$name='$value' ";
	}
	return $res;
	}

	/**
	* Escape chars in phrase translation, that could harm parser to process tag
	*
	* @param string $text
	* @return string
	* @access private
	*/
	function EscapeReservedChars($text)
	{
	$reserved = Array('"',"'"); // =
	$replacement = Array('\"',"\'"); // \=
	return str_replace($reserved,$replacement,$text);
	}


	function ReplaceParams($tag_data)
	{
	//print_pre($this->Parser->Pattern, $tag_data);
	$values = $this->Parser->Values;
	foreach($values as $param_name => $param_value)
	{
	$values[$param_name] = $this->EscapeReservedChars($param_value);
	}

	if (is_array($this->Parser->Params)) {
	$tag_data = preg_replace($this->Parser->Pattern, $values, $tag_data);
	}
	//echo "got: $tag_data<br>";
	return $tag_data;
	}

	function PreParseReplaceParams($tag_data)
	{
	//print_pre($this->Parser->Pattern, $tag_data);
	$values = $this->Parser->Values;
	foreach($values as $param_name => $param_value)
	{
	$values[$param_name] = $this->EscapeReservedChars($param_value);
	}

	/*$patterns = Array();
	if ( is_array($this->Parser->Args) ) {
	foreach ($this->Parser->Args as $arg) {

	}
	}*/

	if ($this->Parser->SkipMode == parse) {
	if (is_array($this->Parser->Params)) {
	$tag_data = preg_replace($this->Parser->Pattern, $values, $tag_data);
	}
	}
	//echo "got: $tag_data<br>";
	return $tag_data;
	}

	function CmpParams($a, $b)
	{
	$a_len = strlen($a);
	$b_len = strlen($b);
	if ($a_len == $b_len) return 0;
	return $a_len > $b_len ? -1 : 1;
	}

	/**
	* Set's Prefix and Special for Tag object
	* based on ones from tagname
	*
	* @param string $tag_data
	* @access protected
	*/
	function ParseTagData($tag_data)
	{
	if (defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->OriginalTagData = $tag_data;
	$tag_data = $this->PreParseReplaceParams($tag_data) . ' ';
	}
	else {
	$tag_data = $this->ReplaceParams($tag_data) . ' ';
	// $tag_data = $this->Application->ReplaceLanguageTags($tag_data);
	}

	list ($key_data, $params) = split("[ \t\n]{1}", $tag_data, 2);
	$key_data = trim($key_data);

	$tmp=explode(':',$key_data);
	$this->Tag=$tmp[1];

	$tmp=$this->Application->processPrefix($tmp[0]);
	$this->Prefix=$tmp['prefix'];
	$this->Special=$tmp['special'];
	$this->Processor=$this->Prefix;

	if ($params != '') {
	$this->ParseNamedParams($params);
	}
	else {
	$this->NamedParams = array();
	}
	}

	function ParseNamedParams($params_str)
	{
	$params =& new Params($params_str);
	$this->NamedParams = $params->_Params;
	}

	function GetParam($param)
	{
	if (isset($this->NP[$param]))
	return $this->NP[$param];
	else
	return false;
	}

	/**
	* Process IF tags in specific way
	*
	*/
	function Process()
	{
	if ($this->Processor == 'm' \|\| $this->Processor == 'm_TagProcessor') { //if we are procssing Main tags
	if ($this->Tag == 'block' \|\| $this->Tag == 'DefineElement') {
	$tag =& new BlockTag('', $this->Parser);
	$tag->CopyFrom($this);
	$tag->Process();
	}
	elseif ($this->Parser->SkipMode == skip_tags) {
	return;
	}
	elseif (
	$this->Tag == 'if' \|\|
	$this->Tag == 'ifnot' \|\|
	$this->Tag == 'else' \|\|
	$this->Tag == 'elseif'
	)
	{
	if ( defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->Parser->AppendCompiledCode( $this->GetCode() );
	}
	$tag =& new ConstructTag('', $this->Parser);
	$tag->CopyFrom($this);
	$tag->Process();
	}
	else {
	if ($this->Parser->SkipMode == skip) {
	if ( defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->Parser->AppendCompiledCode( $this->GetCode() );
	}
	return;
	}
	$this->ProcessTag();
	if ( defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->Parser->AppendCompiledCode( $this->GetCode() );
	}
	}
	}
	else { //normal tags - processors other than main
	if ($this->Parser->SkipMode == skip) { // inside if - add statements inside if to compiled code
	if ( defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->Parser->AppendCompiledCode( $this->GetCode() );
	}
	return;
	}
	elseif ($this->Parser->SkipMode == skip_tags) return; //do not parse if we skipping tags
	$this->ProcessTag();
	if ( defined('EXPERIMENTAL_PRE_PARSE') ) {
	$this->Parser->AppendCompiledCode( $this->GetCode() );
	}
	}
	}

	/**
	* Set's Prefix and Special for TagProcessor
	* based on tag beeing processed
	*
	* @return string
	* @access protected
	*/
	function DoProcessTag()
	{
	// $tag->Prefix - l_TagProcessor
	$tmp = $this->Application->processPrefix($this->Processor);

	$processor =& $this->Application->recallObject($tmp['prefix'].'_TagProcessor'); // $this->Processor

	$tmp=explode('_',$tmp['prefix'],2);
	$processor->Prefix=$tmp[0];
	$processor->Special=$this->Special;

	// pass_params for non ParseBlock tags :)
	$parser_params = $this->Application->Parser->Params;
	if( getArrayValue($this->NamedParams,'pass_params') )
	{
	unset( $this->NamedParams['pass_params'] );
	$this->NamedParams = array_merge_recursive2($parser_params, $this->NamedParams);
	}

	return $processor->ProcessTag($this);
	}

	function ProcessTag()
	{
	$o = $this->DoProcessTag();
	if ($o !== false)
	{
	$this->Parser->AppendOutput($o);
	}
	else
	{
	trigger_error('can\'t process tag '.$this->Tag,E_USER_WARNING);
	}
	}

	function GetCode($echo=false)
	{
	$tmp_params = $this->NamedParams;
	$splited = split("[ \t\n]{1}", $this->OriginalTagData, 2);
	if (isset($splited[1]) && $splited[1]) {
	$this->ParseNamedParams($splited[1]);
	}
	$pass_params = $this->NamedParams;
	$this->NamedParams = $tmp_params;

	$code = Array();

	$to_pass = 'Array(';
	foreach ($pass_params as $name => $val) {
	$to_pass .= '"'.$name.'" => "'.str_replace('"', '\"', $val).'",';
	}
	$to_pass .= ')';

	if ($echo) $code[] = '$o = '."'';\n";

	switch ( $this->Tag ) {
	case 'DefaultParam':
	foreach ($this->NP as $key => $val) {
	$code[] = 'if (!isset($'.$key.')) $application->Parser->SetParam(\''.$key.'\', \''.$val.'\');';
	$code[] = '$'.$key.' = isset($'.$key.') ? $'.$key.' : \''.$val.'\';';
	}
	return $code;
	case 'param':
	$code[] = '$o .= $params["'.$this->NP['name'].'"];';
	return $code;
	case 'if':
	if (isset($this->NP['_closing_tag_'])) {
	$code[] = ' }';
	}
	else {

	$check = $this->GetParam('check');
	if ($check) {
	if (strpos($check, '_') !== false) {
	list($prefix, $function) = explode('_', $check, 2);
	}
	else {
	$function = $check;
	- $prefix = $this->Parser->GetParam('PrefixSpecial');
	+
	+ if (isset($this->NamedParams['_auto_prefix_'])) {
	+ $prefix = '$PrefixSpecial';
	+ }
	+ else {
	+ $prefix = $this->getPrefixSpecial();
	+ }
	+
	+// $prefix = $this->Parser->GetParam('PrefixSpecial');
	}
	}
	else {
	$prefix = $this->GetParam('prefix');
	$function = $this->GetParam('function');
	}

	$code[] = '$tmp = $application->processPrefix("'.$prefix.'");'."\n";
	$code[] = '$__tp = $tmp[\'prefix\'].\'_TagProcessor\';'."\n";
	$code[] = '$p =& $application->recallObject($__tp);'."\n";
	$code[] = '$p->Prefix = $tmp[\'prefix\'];'."\n";
	$code[] = '$p->Special = $tmp[\'special\'];'."\n";
	$code[] = '$if_result = $p->ProcessParsedTag(\''.$function.'\', '.$to_pass.', "'.$prefix.'");'."\n";
	if (isset($pass_params['inverse'])) {
	$code[] = 'if (!$if_result) {';
	}
	else {
	$code[] = 'if ($if_result) {';
	}
	}
	return $code;

	case 'endif':
	$code[] = ' }';
	return $code;

	case 'else':
	$code[] = ' }';
	$code[] = ' else {';
	return $code;
	}

	/* $tmp_pref = $this->getPrefixSpecial();
	$tmp = $this->Application->processPrefix($tmp_pref);
	$tmp_processor = $tmp['prefix'].'_TagProcessor';
	if (strpos($tmp['prefix'], '$') !== false) {
	$processor_to_check = '{'.$tmp['prefix'].'}_TagProcessor';
	}
	else {
	$processor_to_check = $tmp_processor;
	} */

	- $code[] = '$tmp = $application->processPrefix("'.$this->getPrefixSpecial().'");'."\n";
	+ if (isset($this->NamedParams['_auto_prefix_'])) {
	+ $prefix = '$PrefixSpecial';
	+ }
	+ else {
	+ $prefix = $this->getPrefixSpecial();
	+ }
	+ $code[] = '$tmp = $application->processPrefix("'.$prefix.'");'."\n";

	/*if (!isset($this->Application->CompilationCache[$this->getPrefixSpecial()])) {
	$code[] = '$tmp = $application->processPrefix("'.$this->getPrefixSpecial().'");'."\n";
	$code[] = '$__tp = $tmp[\'prefix\'].\'_TagProcessor\';'."\n";
	$code[] = '$application->CachedProcessors["'.$this->getPrefixSpecial().'"] =& $application->recallObject($__tp);'."\n";
	$this->Application->CompilationCache[$this->getPrefixSpecial()] = true;

	if (strpos($tmp_pref, '$') === false) {
	$this->Application->CachedProcessors[$this->getPrefixSpecial()] =& $this->Application->recallObject($tmp_processor);
	}
	}

	$this->Parser->UsedProcessors[] = $tmp['prefix'];*/
	$code[] = '$__tp = $tmp[\'prefix\'].\'_TagProcessor\';'."\n";
	$code[] = '$p =& $application->recallObject($__tp);'."\n";
	$code[] = '$p->Prefix = $tmp[\'prefix\'];'."\n";
	$code[] = '$p->Special = $tmp[\'special\'];'."\n";

	$tag_func = $this->Tag;
	if ($tag_func == 'include') $tag_func = 'MyInclude';

	// $code[] = '$o .= $application->CachedProcessors["'.$this->getPrefixSpecial().'"]->ProcessParsedTag(\''.$tag_func.'\', '.$to_pass.', "'.$this->Processor.'");'."\n";

	$code[] = '$o .= $p->ProcessParsedTag(\''.$tag_func.'\', '.$to_pass.', "'.$this->Processor.'");'."\n";

	/*$code = ' $processor =& $application->recallObject(\''.$this->Processor.'_TagProcessor\');
	$o .= $processor->ProcessParsedTag(\''.$this->Tag.'\', unserialize(\''.serialize($this->NP).'\'));';*/

	if (isset($pass_params['result_to_var'])) {
	$code[] = '$'.$pass_params['result_to_var'].' = $application->Parser->GetParam(\''.$pass_params['result_to_var'].'\');';
	$echo = false;
	}

	if ($echo) $code[] = ' echo $o;'."\n";

	return $code;
	//return '$o .= \'tag:'. $this->Tag .'\'';
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.12.2/core/kernel/parser/tags.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.12.2.3
	\ No newline at end of property
	+1.12.2.4
	\ No newline at end of property

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options