in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Aug 17, 2:48 PM

in-portal
View Options

	Index: trunk/core/kernel/parser/template.php
	===================================================================
	--- trunk/core/kernel/parser/template.php (revision 3529)
	+++ trunk/core/kernel/parser/template.php (revision 3530)
	@@ -1,197 +1,197 @@
	<?php

	class Template {
	var $Body = '';
	var $BasePath = '';
	var $Filename = '';

	function Template($base_path=null, $filename=null, $silent=0)
	{
	if ($this->SetBasePath($base_path)) {
	if (isset($filename)) {
	$this->Filename = $filename;
	$this->LoadTemplate($silent);
	}
	}
	}

	function SetBasePath($base_path=null)
	{
	if (isset($base_path)) {
	$base_path = eregi_replace("/$", '', $base_path); //Cutting possible last slash
	$this->BasePath = $base_path;
	return true;
	}
	return false;
	}

	function GetFullPath()
	{
	return $this->BasePath.'/'.ltrim($this->Filename, '/').'.tpl';
	}

	function LoadTemplate($silent=0)
	{
	$filename = $this->GetFullPath();
	if(file_exists($filename)) {
	if (filesize ($filename) == 0) {
	trigger_error("Template file size is 0: <b>$filename</b>", ($silent ? E_USER_NOTICE : E_USER_ERROR) );
	}

	$handle = fopen ($filename, "r");
	$contents = fread ($handle, filesize ($filename));
	$this->SetBody($contents);
	fclose ($handle);
	return true;
	}
	else {
	/*global $debugger;
	if($debugger) $debugger->appendTrace();*/
	trigger_error("File or block not found: <b>$filename</b>", ($silent ? E_USER_NOTICE : E_USER_ERROR) );
	return false;
	}
	}

	function SetBody($body)
	{
	$this->Body = $body;
	}

	function GetBody()
	{
	return $this->Body;
	}
	}

	class TemplatesCache extends kBase {
	var $Templates = Array();
	var $BasePath;
	var $FileNames = Array();

	var $ModulesCache = Array();

	function TemplatesCache()
	{
	parent::kBase();
	$this->SetThemePath();
	$this->BasePath = FULL_PATH.THEMES_PATH;

	$conn =& $this->Application->GetADODBConnection();
	$this->ModulesCache = $conn->GetCol('SELECT LOWER(Name) FROM '.TABLE_PREFIX.'Modules');
	}

	function SetThemePath()
	{
	if ( defined('SPECIAL_TEMPLATES_FOLDER') )
	{
	$sub_folder = SPECIAL_TEMPLATES_FOLDER;
	}
	elseif( $this->Application->IsAdmin() )
	{
	$sub_folder = '/admin/templates';
	}
	else
	{
	$current_theme = $this->Application->GetVar('m_theme');
	$theme_folder = $this->Application->DB->GetOne('SELECT Name FROM '.TABLE_PREFIX.'Theme WHERE ThemeId = '.$current_theme);
	$sub_folder = '/themes/'.$theme_folder;
	}
	safeDefine('THEMES_PATH', $sub_folder);
	}

	function LoadTemplate($filename, $title=NULL, $silent=0)
	{
	if (preg_match('#^[\/]{0,1}([^\/])\/(.)#', $filename, $regs)) {
	$module_filename = $regs[2];
	$first_dir = $regs[1];
	}
	else {
	$first_dir = '';
	$module_filename = $filename;
	}

	if ( $this->Application->IsAdmin() && in_array(strtolower($first_dir), $this->ModulesCache)) {
	$path = MODULES_PATH.'/'.strtolower($first_dir).'/admin_templates';
	}
	else {
	$path = $this->BasePath;
	$module_filename = $first_dir.'/'.$module_filename;
	}

	$template =& new Template($path, $module_filename, $silent);
	if (!isset($title)) $title = $filename;
	$this->SetTemplate($title, $template);
	}

	function GetRealFilename($filename, $base=null) {
	if (preg_match('#^[\/]{0,1}([^\/])\/(.)#', $filename, $regs)) {
	$module_filename = $regs[2];
	$first_dir = $regs[1];
	}
	else {
	$first_dir = '';
	$module_filename = $filename;
	}

	if ( $this->Application->IsAdmin() && in_array(strtolower($first_dir), $this->ModulesCache)) {
	$path = MODULES_PATH.'/'.strtolower($first_dir).'/admin_templates';
	}
	else {
	$path = isset($base) ? $base : $this->BasePath;
	$module_filename = $first_dir.'/'.$module_filename;
	}
	return $path.'/'.$module_filename;
	}

	function SetTemplate($title, &$template, $filename=null)
	{
	if (!isset($filename)) $filename=$title;
	$this->Templates[$title] = $template;
	$this->FileNames[$title] = $filename;
	}

	function &GetTemplate($title, $silent=0)
	{
	if (!isset($this->Templates[$title])) {
	$this->LoadTemplate($title, null, $silent);
	}
	return $this->Templates[$title];
	}

	function GetTemplateBody($title, $silent=0)
	{
	$template =& $this->GetTemplate($title, $silent);
	if ( !is_object($template) ) {
	return '';
	}
	return $template->GetBody();
	}

	function GetTemplateFileName($title)
	{
	- return $this->FileNames[$title];
	+ return getArrayValue($this->FileNames, $title);
	}

	function SetTemplateBody($title, $body)
	{
	$template =& new Template();
	$template->SetBody($body);
	$this->SetTemplate($title, $template);
	}

	function ParseTemplate($template_name)
	{
	$Parser =& new TemplateParser($this->Application);
	return $Parser->Parse( $this->GetTemplateBody($template_name) );
	}

	function TemplateExists($filename)
	{
	if (!preg_match("/\.tpl$/", $filename)) $filename .= '.tpl';
	$real_file = $this->GetRealFilename($filename);
	return file_exists($real_file);
	}
	}


	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/parser/template.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.9
	\ No newline at end of property
	+1.10
	\ No newline at end of property
	Index: trunk/core/kernel/parser/construct_tags.php
	===================================================================
	--- trunk/core/kernel/parser/construct_tags.php (revision 3529)
	+++ trunk/core/kernel/parser/construct_tags.php (revision 3530)
	@@ -1,269 +1,269 @@
	<?php

	//Template language contruct tags (if, block...) which has opening and ending
	class ConstructTag extends Tag {
	var $StopTag = '';
	var $SkipMode = 0;
	var $Logic = 0;


	function SetStopTag($tag)
	{
	$this->StopTag = $tag;
	}

	function StoreSkipMode()
	{
	$this->SkipMode = $this->Parser->SkipMode;
	}

	function RestoreSkipMode()
	{
	$this->Parser->SetSkipMode($this->SkipMode);
	}

	function RestoreThisLevelSkipMode()
	{
	$this->SkipMode = $this->Parser->Recursion[$this->Parser->RecursionIndex]->SkipMode;
	}

	function SuggestSkipMode($mode)
	{
	if ($mode >= 1) //if we need to skip - always forcing it
	$this->Parser->SetSkipMode($mode);
	else { //if we need to turn of skipping
	if ($this->SkipMode == parse) //check if initially skipping was off
	$this->Parser->SetSkipMode(parse); //set it to off only then
	}
	}

	function GetLogic()
	{
	$check = $this->GetParam('check');
	if ($check) {
	if (strpos($check, '_') !== false) {
	list($prefix, $function) = explode('_', $check, 2);
	}
	else {
	$function = $check;
	$prefix = $this->Parser->GetParam('PrefixSpecial');
	}
	}
	else {
	$prefix = $this->GetParam('prefix');
	$function = $this->GetParam('function');
	}
	$this->NP['prefix'] = $prefix;
	$this->NP['function'] = $function;

	$inverse = $this->GetParam('inverse');

	if ($prefix !== false) {
	$tag =& new Tag('', $this->Parser);
	$tag->Tag = $function;

	$tmp = $this->Application->processPrefix($prefix);
	$tag->Processor = $tmp['prefix'];

	$tag->Prefix=$tmp['prefix'];
	$tag->Special=$tmp['special'];
	$tag->NamedParams = $this->NP;
	$this->Logic = $tag->DoProcessTag();
	// echo " this->Logic : ".$this->Logic."<br>";
	}
	else
	{
	$this->Logic = $function;
	}
	if($inverse) $this->Logic = !$this->Logic;
	}

	function Process()
	{
	switch ($this->Tag) {
	case 'if':
	case 'ifnot':
	$this->GetLogic();

	$this->SetStopTag('endif'); //This recursion level should end when 'endif' is found
	$this->Parser->Recurve($this); //Saving current tag in parser recursion array
	$this->StoreSkipMode(); //Storing initial SkipMode

	if ($this->Logic) {
	$this->SuggestSkipMode(parse); //suggest we parse it
	}
	else {
	$this->SuggestSkipMode(skip); //suggest we don't parse it
	}
	break;
	case 'elseif':
	$if_logic = $this->Parser->Recursion[$this->Parser->RecursionIndex]->Logic;
	if (!$if_logic) { //if IF or ELSEIF above have not worked
	$this->GetLogic();

	if ($this->Logic) { //ELSEIF should run
	$this->Parser->Recursion[$this->Parser->RecursionIndex]->Logic = $this->Logic; //To escape running ELSE or ELSEIF below
	$this->SuggestSkipMode(parse);
	}
	else { //ELSEIF should NOT run
	$this->SuggestSkipMode(skip);
	}
	}
	else //IF or ELSEIF above HAVE worked - this ELSEIF should NOT run
	$this->SuggestSkipMode(skip);
	break;
	case 'else':
	$if_logic = $this->Parser->Recursion[$this->Parser->RecursionIndex]->Logic;
	$this->RestoreThisLevelSkipMode();
	if (!$if_logic) { //IF was false - ELSE should run
	$this->SuggestSkipMode(parse);
	}
	else { //IF was true - ELSE should not run
	$this->SuggestSkipMode(skip);
	}
	break;
	}
	}

	function CheckRecursion(&$tag)
	{
	if ($this->CheckEndRecursion($tag)) {
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	if ($tag->Tag == 'if' \|\| $tag->Tag == 'endif') {
	$this->Parser->AppendCompiledCode('}');
	$this->Parser->ResetCode();
	}
	}
	$this->RestoreSkipMode(); //Restoring original SkipMode
	return true;
	}
	else {
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	if ($tag->Tag != 'block' && $tag->Tag != 'DefineElement') {
	$this->Parser->AppendCode($tag->GetCode());
	}
	// $this->Parser->AppendCompiledCode( $tag->GetCode() );
	}
	}
	return false;
	}

	function CheckEndRecursion(&$tag)
	{
	if ($tag->GetParam('_closing_tag_') == 1 && $tag->Tag == $this->Tag) {
	return true;
	}
	return ($tag->Tag == $this->StopTag); //Tag matches StopTag we are waiting for to close current recursion
	}
	}

	class BlockTag extends ConstructTag {
	var $BlockName = '';
	var $InsideBlock = 0;

	function Process()
	{
	switch ($this->Tag) {
	case 'block':
	case 'DefineElement':
	if ($this->Tag == 'DefineElement') {
	$this->SetStopTag('end_define'); //This recursion level should end when 'blockend' is found
	}
	else {
	$this->SetStopTag('blockend'); //This recursion level should end when 'blockend' is found
	}
	$this->Parser->Recurve($this); //Saving current tag in parser recursion array
	$this->Parser->SetBuffer('');
	$this->BlockName = $this->NP['name']; //Stroing BlockName
	if (isset($this->NP['args']) ) {
	$this->Parser->Args = explode(',', $this->NP['args']);
	}
	$this->StoreSkipMode();
	$this->SuggestSkipMode(skip_tags); //We need to skip tags from now
	break;
	}
	}

	function CheckRecursion(&$tag)
	{
	if (parent::CheckRecursion($tag)) { //if endtag matches (SkipMode would be restored then)
	//Creating template from buffer

	//if (defined('EXPERIMENTAL_PRE_PARSE') && isset($this->Application->PreParsedBlocks[$this->BlockName])) return true;

	$template = new Template();
	$template->SetBody($this->Parser->GetBuffer());

	$templates_cache =& $this->Application->recallObject('TemplatesCache');

	//Adding template to application' cache
	$templates_cache->SetTemplate($this->BlockName, $template, $this->Parser->TemplateName);

	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	$code = $this->Parser->GetCode();
	array_unshift($code, '$o = \'\';');
	- array_unshift($code, '$application->Parser->Params = $params;');
	+ array_unshift($code, '$application->Parser->SetParams($params);');
	array_unshift($code, '$application =& kApplication::Instance();');
	array_unshift($code, 'extract($params);');

	$defaults = '$defaults = Array(';
	foreach ($this->NP as $name => $val) {
	if ($name == 'name') continue;
	$defaults .= '"'.$name.'" => "'.str_replace('"', '\"', $val).'",';
	}
	$defaults .= ');';
	array_unshift($code, '$params = array_merge_recursive2($defaults, $params);');
	array_unshift($code, $defaults);

	$code[] = 'return $o;';

	global $debugger;

	$dbg_functions = $this->Application->isDebugMode() && dbg_ConstOn('DBG_PRINT_PREPARSED');

	$f_body = '';
	//echo "<pre>";
	$l = 0;
	if ($dbg_functions) echo "<b>function ".$this->BlockName." {</b><br>";
	foreach ($code as $line) {
	$l++;
	if ($dbg_functions) {
	echo $l.' '.$debugger->highlightString(trim($line)."\n", true);
	}
	$f_body .= "\t\t".rtrim($line, "\n")."\n";
	}
	if ($dbg_functions) echo "<b>} // function ".$this->BlockName." end</b><br><br>";
	//echo "</pre>";

	//caching func body
	$this->Application->PreParsedCache[$this->BlockName] = $f_body;

	$func = create_function('$params', $f_body);
	$this->Application->PreParsedBlocks[$this->BlockName] = $func;
	$this->Parser->Args = null;
	$this->Parser->ResetCode();

	$this->Parser->AppendCompiledFunction($this->BlockName, $f_body);
	}
	return true;
	}
	else {
	// append the tag itself to the block - while in block, we check every tag to be 'blockend'
	// if it is not - we need to append the tag to the buffer, which we'll parse later in 'parse_block'
	//if ($tag->Tag != 'block') {
	if (defined('EXPERIMENTAL_PRE_PARSE') && isset($this->Application->PreParsedBlocks[$this->BlockName])) {
	return;
	}
	if (defined('EXPERIMENTAL_PRE_PARSE')) {
	// $this->Parser->AppendCode($tag->GetCode());
	}
	else {
	$this->Parser->AppendOutput($tag->GetFullTag());
	}
	//}
	return false;
	}
	}
	}

	?>
	\ No newline at end of file

	Property changes on: trunk/core/kernel/parser/construct_tags.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.7
	\ No newline at end of property
	+1.8
	\ No newline at end of property
	Index: trunk/core/kernel/parser/template_parser.php
	===================================================================
	--- trunk/core/kernel/parser/template_parser.php (revision 3529)
	+++ trunk/core/kernel/parser/template_parser.php (revision 3530)
	@@ -1,546 +1,549 @@
	<?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"));
	$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)
	{
	if (!is_array($params)) $params = Array();
	+
	$this->Params = $params;
	+ $this->ParamsStack[$this->ParamsRecursionIndex] = $params;
	+
	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
	}

	function GetParam($name)
	{
	//return isset($this->Params[strtolower($name)]) ? $this->Params[strtolower($name)] : false;
	return isset($this->Params[$name]) ? $this->Params[$name] : false;
	}

	function SetParam($name, $value)
	{
	$this->Params[strtolower($name)] = $value;
	}

	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 .= 'if (!function_exists(\''.$real_name.'\')) {'."\n";


	$this->CompiledBuffer .= "\t".'$application->PreParsedBlocks[\''.$f_name.'\'] = \''.$real_name.'\';';
	$this->CompiledBuffer .= "\n\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);
	$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;
	}

	// 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';
	}
	}

	function CheckDir($dir)
	{
	if (file_exists($dir)) {
	return;
	}
	else {
	$segments = explode('/', $dir);
	$cur_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 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) {
	$template_cache =& $this->Application->recallObject('TemplatesCache');
	$fname = $template_cache->GetRealFilename($this->TemplateName).'.php';

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

	if (!defined('SAFE_MODE') \|\| !SAFE_MODE) {
	$this->CheckDir(dirname($fname));
	}

	$tname = $template_cache->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) && filemtime($fname) > filemtime($tname)) {
	+ 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 .= '$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() && dbg_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() && dbg_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() && dbg_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: trunk/core/kernel/parser/template_parser.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.19
	\ No newline at end of property
	+1.20
	\ 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