/**
* Compile saved child block source
*
* @param object $compiler compiler object
* @param string $_name optional name of child block
*
* @return string compiled code of child block
*/
static function compileChildBlock($compiler, $_name = null)
{
if ($compiler->inheritance_child) {
$name1 = Smurty_Internal_Compile_Block::$nested_block_names[0];
if (isset($compiler->template->block_data[$name1])) {
// replace inner block name with generic
Smurty_Internal_Compile_Block::$block_data[$name1]['source'] .= $compiler->template->block_data[$name1]['source'];
Smurty_Internal_Compile_Block::$block_data[$name1]['child'] = true;
}
$compiler->lex->yypushstate(Smurty_Internal_Templatelexer::CHILDBLOCK);
$compiler->has_code = false;
return;
}
// if called by {$smurty.block.child} we must search the name of enclosing {block}
if ($_name == null) {
$stack_count = count($compiler->_tag_stack);
while (--$stack_count >= 0) {
if ($compiler->_tag_stack[$stack_count][0] == 'block') {
$_name = trim($compiler->_tag_stack[$stack_count][1][0]['name'], "\"'");
break;
}
}
}
if ($_name == null) {
$compiler->trigger_template_error(' tag {$smurty.block.child} used outside {block} tags ', $compiler->lex->taglineno);
}
// undefined child?
if (!isset($compiler->template->block_data[$_name]['source'])) {
$compiler->popTrace();
return '';
}
// flag that child is already compile by {$smurty.block.child} inclusion
$compiler->template->block_data[$_name]['compiled'] = true;
$_tpl = new Smurty_Internal_template('string:' . $compiler->template->block_data[$_name]['source'], $compiler->smurty, $compiler->template, $compiler->template->cache_id, $compiler->template->compile_id, $compiler->template->caching, $compiler->template->cache_lifetime);
if ($compiler->smurty->debugging) {
Smurty_Internal_Debug::ignore($_tpl);
}
$_tpl->tpl_vars = $compiler->template->tpl_vars;
$_tpl->variable_filters = $compiler->template->variable_filters;
$_tpl->properties['nocache_hash'] = $compiler->template->properties['nocache_hash'];
$_tpl->allow_relative_path = true;
$_tpl->compiler->inheritance = true;
$_tpl->compiler->suppressHeader = true;
$_tpl->compiler->suppressFilter = true;
$_tpl->compiler->suppressTemplatePropertyHeader = true;
$_tpl->compiler->suppressMergedTemplates = true;
$nocache = $compiler->nocache || $compiler->tag_nocache;
if (strpos($compiler->template->block_data[$_name]['source'], self::parent) !== false) {
$_output = str_replace(self::parent, $compiler->parser->current_buffer->to_smurty_php(), $_tpl->compiler->compileTemplate($_tpl, $nocache));
} elseif ($compiler->template->block_data[$_name]['mode'] == 'prepend') {
$_output = $_tpl->compiler->compileTemplate($_tpl, $nocache) . $compiler->parser->current_buffer->to_smurty_php();
} elseif ($compiler->template->block_data[$_name]['mode'] == 'append') {
$_output = $compiler->parser->current_buffer->to_smurty_php() . $_tpl->compiler->compileTemplate($_tpl, $nocache);
} elseif (!empty($compiler->template->block_data[$_name])) {
$_output = $_tpl->compiler->compileTemplate($_tpl, $nocache);
}
$compiler->template->properties['file_dependency'] = array_merge($compiler->template->properties['file_dependency'], $_tpl->properties['file_dependency']);
$compiler->template->properties['function'] = array_merge($compiler->template->properties['function'], $_tpl->properties['function']);
$compiler->merged_templates = array_merge($compiler->merged_templates, $_tpl->compiler->merged_templates);
$compiler->template->variable_filters = $_tpl->variable_filters;
if ($_tpl->has_nocache_code) {
$compiler->template->has_nocache_code = true;
}
foreach ($_tpl->required_plugins as $key => $tmp1) {
if ($compiler->nocache && $compiler->template->caching) {
$code = 'nocache';
} else {
$code = $key;
}
foreach ($tmp1 as $name => $tmp) {
foreach ($tmp as $type => $data) {
$compiler->template->required_plugins[$code][$name][$type] = $data;
}
}
}
unset($_tpl);
$compiler->has_code = true;
return $_output;
}
/**
* fetches a rendered hiweb_tpl template
*
* @param string $template the resource handle of the template file or template object
* @param mixed $cache_id cache id to be used with this template
* @param mixed $compile_id compile id to be used with this template
* @param object $parent next higher level of hiweb_tpl variables
* @param bool $display true: display, false: fetch
* @param bool $merge_tpl_vars if true parent template variables merged in to local scope
* @param bool $no_output_filter if true do not run output filter
*
* @throws Exception
* @throws SmurtyException
* @return string rendered template output
*/
public function fetch($template = null, $cache_id = null, $compile_id = null, $parent = null, $display = false, $merge_tpl_vars = true, $no_output_filter = false)
{
if ($template === null && $this instanceof $this->template_class) {
$template = $this;
}
if ($cache_id !== null && is_object($cache_id)) {
$parent = $cache_id;
$cache_id = null;
}
if ($parent === null && ($this instanceof hiweb_tpl || is_string($template))) {
$parent = $this;
}
// create template object if necessary
$_template = $template instanceof $this->template_class ? $template : $this->smurty->createTemplate($template, $cache_id, $compile_id, $parent, false);
// if called by hiweb_tpl object make sure we use current caching status
if ($this instanceof hiweb_tpl) {
$_template->caching = $this->caching;
}
// merge all variable scopes into template
if ($merge_tpl_vars) {
// save local variables
$save_tpl_vars = $_template->tpl_vars;
$save_config_vars = $_template->config_vars;
$ptr_array = array($_template);
$ptr = $_template;
while (isset($ptr->parent)) {
$ptr_array[] = $ptr = $ptr->parent;
}
$ptr_array = array_reverse($ptr_array);
$parent_ptr = reset($ptr_array);
$tpl_vars = $parent_ptr->tpl_vars;
$config_vars = $parent_ptr->config_vars;
while ($parent_ptr = next($ptr_array)) {
if (!empty($parent_ptr->tpl_vars)) {
$tpl_vars = array_merge($tpl_vars, $parent_ptr->tpl_vars);
}
if (!empty($parent_ptr->config_vars)) {
$config_vars = array_merge($config_vars, $parent_ptr->config_vars);
}
}
if (!empty(hiweb_tpl::$global_tpl_vars)) {
$tpl_vars = array_merge(hiweb_tpl::$global_tpl_vars, $tpl_vars);
}
$_template->tpl_vars = $tpl_vars;
$_template->config_vars = $config_vars;
}
// dummy local smurty variable
if (!isset($_template->tpl_vars['smurty'])) {
$_template->tpl_vars['smurty'] = new Smurty_Variable();
}
if (isset($this->smurty->error_reporting)) {
$_smurty_old_error_level = error_reporting($this->smurty->error_reporting);
}
// check URL debugging control
if (!$this->smurty->debugging && $this->smurty->debugging_ctrl == 'URL') {
if (isset($_SERVER['QUERY_STRING'])) {
$_query_string = $_SERVER['QUERY_STRING'];
} else {
$_query_string = '';
}
if (false !== strpos($_query_string, $this->smurty->smurty_debug_id)) {
if (false !== strpos($_query_string, $this->smurty->smurty_debug_id . '=on')) {
// enable debugging for this browser session
setcookie('SMURTY_DEBUG', true);
$this->smurty->debugging = true;
} elseif (false !== strpos($_query_string, $this->smurty->smurty_debug_id . '=off')) {
// disable debugging for this browser session
setcookie('SMURTY_DEBUG', false);
$this->smurty->debugging = false;
} else {
// enable debugging for this page
$this->smurty->debugging = true;
}
} else {
if (isset($_COOKIE['SMURTY_DEBUG'])) {
$this->smurty->debugging = true;
}
}
}
// must reset merge template date
$_template->smurty->merged_templates_func = array();
// get rendered template
// disable caching for evaluated code
if ($_template->source->recompiled) {
$_template->caching = false;
}
// checks if template exists
if (!$_template->source->exists) {
if ($_template->parent instanceof Smurty_Internal_Template) {
$parent_resource = " in '{$_template->parent->template_resource}'";
} else {
$parent_resource = '';
}
throw new SmurtyException("Unable to load template {$_template->source->type} '{$_template->source->name}'{$parent_resource}");
}
// read from cache or render
if (!($_template->caching == hiweb_tpl::CACHING_LIFETIME_CURRENT || $_template->caching == hiweb_tpl::CACHING_LIFETIME_SAVED) || !$_template->cached->valid) {
// render template (not loaded and not in cache)
if (!$_template->source->uncompiled) {
/** @var Smurty_Internal_Template $_smurty_tpl
* used in evaluated code
*/
$_smurty_tpl = $_template;
if ($_template->source->recompiled) {
$code = $_template->compiler->compileTemplate($_template);
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_render($_template);
}
try {
ob_start();
eval("?>" . $code);
unset($code);
} catch (Exception $e) {
ob_get_clean();
throw $e;
}
} else {
if (!$_template->compiled->exists || $_template->smurty->force_compile && !$_template->compiled->isCompiled) {
$_template->compileTemplateSource();
$code = file_get_contents($_template->compiled->filepath);
eval("?>" . $code);
unset($code);
$_template->compiled->loaded = true;
$_template->compiled->isCompiled = true;
}
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_render($_template);
}
if (!$_template->compiled->loaded) {
include $_template->compiled->filepath;
if ($_template->mustCompile) {
// recompile and load again
$_template->compileTemplateSource();
$code = file_get_contents($_template->compiled->filepath);
eval("?>" . $code);
unset($code);
$_template->compiled->isCompiled = true;
}
$_template->compiled->loaded = true;
} else {
$_template->decodeProperties($_template->compiled->_properties, false);
}
try {
ob_start();
if (empty($_template->properties['unifunc']) || !is_callable($_template->properties['unifunc'])) {
throw new SmurtyException("Invalid compiled template for '{$_template->template_resource}'");
}
array_unshift($_template->_capture_stack, array());
//
// render compiled template
//
$_template->properties['unifunc']($_template);
// any unclosed {capture} tags ?
if (isset($_template->_capture_stack[0][0])) {
$_template->capture_error();
}
array_shift($_template->_capture_stack);
} catch (Exception $e) {
ob_get_clean();
throw $e;
}
}
} else {
if ($_template->source->uncompiled) {
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_render($_template);
}
try {
ob_start();
$_template->source->renderUncompiled($_template);
} catch (Exception $e) {
ob_get_clean();
throw $e;
}
} else {
throw new SmurtyException("Resource '{$_template->source}->type' must have 'renderUncompiled' method");
}
}
$_output = ob_get_clean();
if (!$_template->source->recompiled && empty($_template->properties['file_dependency'][$_template->source->uid])) {
$_template->properties['file_dependency'][$_template->source->uid] = array($_template->source->filepath, $_template->source->timestamp, $_template->source->type);
}
if ($_template->parent instanceof Smurty_Internal_Template) {
$_template->parent->properties['file_dependency'] = array_merge($_template->parent->properties['file_dependency'], $_template->properties['file_dependency']);
foreach ($_template->required_plugins as $code => $tmp1) {
foreach ($tmp1 as $name => $tmp) {
foreach ($tmp as $type => $data) {
$_template->parent->required_plugins[$code][$name][$type] = $data;
}
}
}
}
if ($this->smurty->debugging) {
Smurty_Internal_Debug::end_render($_template);
}
// write to cache when nessecary
if (!$_template->source->recompiled && ($_template->caching == hiweb_tpl::CACHING_LIFETIME_SAVED || $_template->caching == hiweb_tpl::CACHING_LIFETIME_CURRENT)) {
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_cache($_template);
}
$_template->properties['has_nocache_code'] = false;
// get text between non-cached items
$cache_split = preg_split("!/\\*%%SmurtyNocache:{$_template->properties['nocache_hash']}%%\\*\\/(.+?)/\\*/%%SmurtyNocache:{$_template->properties['nocache_hash']}%%\\*/!s", $_output);
// get non-cached items
preg_match_all("!/\\*%%SmurtyNocache:{$_template->properties['nocache_hash']}%%\\*\\/(.+?)/\\*/%%SmurtyNocache:{$_template->properties['nocache_hash']}%%\\*/!s", $_output, $cache_parts);
$output = '';
// loop over items, stitch back together
foreach ($cache_split as $curr_idx => $curr_split) {
// escape PHP tags in template content
$output .= preg_replace('/(<%|%>|<\\?php|<\\?|\\?>)/', "<?php echo '\$1'; ?>\n", $curr_split);
if (isset($cache_parts[0][$curr_idx])) {
$_template->properties['has_nocache_code'] = true;
// remove nocache tags from cache output
$output .= preg_replace("!/\\*/?%%SmurtyNocache:{$_template->properties['nocache_hash']}%%\\*/!", '', $cache_parts[0][$curr_idx]);
}
}
if (!$no_output_filter && !$_template->has_nocache_code && (isset($this->smurty->autoload_filters['output']) || isset($this->smurty->registered_filters['output']))) {
$output = Smurty_Internal_Filter_Handler::runFilter('output', $output, $_template);
}
// rendering (must be done before writing cache file because of {function} nocache handling)
/** @var Smurty_Internal_Template $_smurty_tpl
* used in evaluated code
*/
$_smurty_tpl = $_template;
try {
ob_start();
eval("?>" . $output);
$_output = ob_get_clean();
} catch (Exception $e) {
ob_get_clean();
throw $e;
}
// write cache file content
$_template->writeCachedContent($output);
if ($this->smurty->debugging) {
Smurty_Internal_Debug::end_cache($_template);
}
} else {
// var_dump('renderTemplate', $_template->has_nocache_code, $_template->template_resource, $_template->properties['nocache_hash'], $_template->parent->properties['nocache_hash'], $_output);
if (!empty($_template->properties['nocache_hash']) && !empty($_template->parent->properties['nocache_hash'])) {
// replace nocache_hash
$_output = str_replace("{$_template->properties['nocache_hash']}", $_template->parent->properties['nocache_hash'], $_output);
$_template->parent->has_nocache_code = $_template->parent->has_nocache_code || $_template->has_nocache_code;
}
}
} else {
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_cache($_template);
}
try {
ob_start();
array_unshift($_template->_capture_stack, array());
//
// render cached template
//
$_template->properties['unifunc']($_template);
// any unclosed {capture} tags ?
if (isset($_template->_capture_stack[0][0])) {
$_template->capture_error();
}
array_shift($_template->_capture_stack);
$_output = ob_get_clean();
} catch (Exception $e) {
ob_get_clean();
throw $e;
}
if ($this->smurty->debugging) {
Smurty_Internal_Debug::end_cache($_template);
}
}
if ((!$this->caching || $_template->has_nocache_code || $_template->source->recompiled) && !$no_output_filter && (isset($this->smurty->autoload_filters['output']) || isset($this->smurty->registered_filters['output']))) {
$_output = Smurty_Internal_Filter_Handler::runFilter('output', $_output, $_template);
}
if (isset($this->error_reporting)) {
error_reporting($_smurty_old_error_level);
}
// display or fetch
if ($display) {
if ($this->caching && $this->cache_modified_check) {
$_isCached = $_template->isCached() && !$_template->has_nocache_code;
$_last_modified_date = @substr($_SERVER['HTTP_IF_MODIFIED_SINCE'], 0, strpos($_SERVER['HTTP_IF_MODIFIED_SINCE'], 'GMT') + 3);
if ($_isCached && $_template->cached->timestamp <= strtotime($_last_modified_date)) {
switch (PHP_SAPI) {
case 'cgi':
// php-cgi < 5.3
// php-cgi < 5.3
case 'cgi-fcgi':
// php-cgi >= 5.3
// php-cgi >= 5.3
case 'fpm-fcgi':
// php-fpm >= 5.3.3
header('Status: 304 Not Modified');
break;
case 'cli':
if (!empty($_SERVER['SMURTY_PHPUNIT_DISABLE_HEADERS'])) {
$_SERVER['SMURTY_PHPUNIT_HEADERS'][] = '304 Not Modified';
}
break;
default:
header($_SERVER['SERVER_PROTOCOL'] . ' 304 Not Modified');
break;
}
} else {
switch (PHP_SAPI) {
case 'cli':
if (!empty($_SERVER['SMURTY_PHPUNIT_DISABLE_HEADERS'])) {
$_SERVER['SMURTY_PHPUNIT_HEADERS'][] = 'Last-Modified: ' . gmdate('D, d M Y H:i:s', $_template->cached->timestamp) . ' GMT';
}
break;
default:
header('Last-Modified: ' . gmdate('D, d M Y H:i:s', $_template->cached->timestamp) . ' GMT');
break;
}
echo $_output;
}
} else {
echo $_output;
}
// debug output
if ($this->smurty->debugging) {
Smurty_Internal_Debug::display_debug($_template);
}
if ($merge_tpl_vars) {
// restore local variables
$_template->tpl_vars = $save_tpl_vars;
$_template->config_vars = $save_config_vars;
}
return;
} else {
if ($merge_tpl_vars) {
// restore local variables
$_template->tpl_vars = $save_tpl_vars;
$_template->config_vars = $save_config_vars;
}
// return fetched content
return $_output;
}
}
/**
* create Cached Object container
*
* @param Smurty_Internal_Template $_template template object
*/
public function __construct(Smurty_Internal_Template $_template)
{
$this->compile_id = $_template->compile_id;
$this->cache_id = $_template->cache_id;
$this->source = $_template->source;
$_template->cached = $this;
$smurty = $_template->smurty;
//
// load resource handler
//
$this->handler = $handler = Smurty_CacheResource::load($smurty);
// Note: prone to circular references
//
// check if cache is valid
//
if (!($_template->caching == hiweb_tpl::CACHING_LIFETIME_CURRENT || $_template->caching == hiweb_tpl::CACHING_LIFETIME_SAVED) || $_template->source->recompiled) {
$handler->populate($this, $_template);
return;
}
while (true) {
while (true) {
$handler->populate($this, $_template);
if ($this->timestamp === false || $smurty->force_compile || $smurty->force_cache) {
$this->valid = false;
} else {
$this->valid = true;
}
if ($this->valid && $_template->caching == hiweb_tpl::CACHING_LIFETIME_CURRENT && $_template->cache_lifetime >= 0 && time() > $this->timestamp + $_template->cache_lifetime) {
// lifetime expired
$this->valid = false;
}
if ($this->valid || !$_template->smurty->cache_locking) {
break;
}
if (!$this->handler->locked($_template->smurty, $this)) {
$this->handler->acquireLock($_template->smurty, $this);
break 2;
}
}
if ($this->valid) {
if (!$_template->smurty->cache_locking || $this->handler->locked($_template->smurty, $this) === null) {
// load cache file for the following checks
if ($smurty->debugging) {
Smurty_Internal_Debug::start_cache($_template);
}
if ($handler->process($_template, $this) === false) {
$this->valid = false;
} else {
$this->processed = true;
}
if ($smurty->debugging) {
Smurty_Internal_Debug::end_cache($_template);
}
} else {
continue;
}
} else {
return;
}
if ($this->valid && $_template->caching === hiweb_tpl::CACHING_LIFETIME_SAVED && $_template->properties['cache_lifetime'] >= 0 && time() > $_template->cached->timestamp + $_template->properties['cache_lifetime']) {
$this->valid = false;
}
if (!$this->valid && $_template->smurty->cache_locking) {
$this->handler->acquireLock($_template->smurty, $this);
return;
} else {
return;
}
}
}
/**
* restore file and line offset
*/
public function popTrace()
{
if ($this->smurty->debugging) {
Smurty_Internal_Debug::end_compile($this->template);
}
$r = array_pop($this->trace_stack);
$this->smurty->_current_file = $r[0];
$this->trace_filepath = $r[1];
$this->trace_uid = $r[2];
$this->trace_line_offset = $r[3];
if ($this->smurty->debugging) {
Smurty_Internal_Debug::start_compile($this->template);
}
}
