PHP Professional

{for $i = 0; $i < 5; $i++}
	<p>{$i} is an {if $i % 2 == 0}even{else}odd{/if} number</p>
{/for}
 
The Result:
--
<p>0 is an even number</p> 
 
<p>1 is an odd number</p> 
 
<p>2 is an even number</p> 
 
<p>3 is an odd number</p> 
 
<p>4 is an even number</p> 
 
<p>5 is an odd number</p>

{foreach array('Name'=>'PHP Professional', 'Occupation'=>'PHP Software Engineer', 'Hobby'=>'Blogging') as $key => $value}
	<p>{$key} = {$value}</p>
{/foreach}
 
The Result:
--
<p>Name = PHP Professional</p> 
 
<p>Occupation = PHP Software Engineer</p> 
 
<p>Hobby = Blogging</p>

{for $i = 0; $i < 10; $i++}
	{if $i == 2}
		<p>continue on 2</p>
		{continue}
	{/if}
	<p>the current iteration is {$i}</p>
	{if $i == 5}
		<p>it is time to break!</p>
		{break}
	{/if}
{/for}
 
The Result:
--
<p>the current iteration is 0</p> 
 
<p>the current iteration is 1</p> 
 
<p>continue on 2</p> 
 
<p>the current iteration is 3</p> 
 
<p>the current iteration is 4</p> 
 
<p>the current iteration is 5</p> 
 
<p>it is time to break!</p

public function Compile( $str )
{
	// replace assigned variables first
	$search = array();
	$replace = array();
	foreach ( $this->variables as $key => $value )
	{
		$search[] = '{$'. $key .'}';
		$replace[] = '<?php echo $this->GetVar("'. addslashes($key) .'");?>';
	}
	$str = str_replace($search, $replace, $str);
 
	// if we're not parsing control structures, there's no need to continue, return the parsed str
	if ( !$this->parse_control_structures )
		return $str;
 
	// replace control-structures, predefined blocks and tags (break, continue), other variables that were not assigned before-hand, and other misc. functions
	$replaced = preg_replace(
		array(
			// find PHP blocks
			'/\{php\}(.*?)\{\/php\}/s' ,
 
			// find loops and loop-controls like continue and break
			'/\{(for|foreach|while)\s([^\}]+)\}(.*?)\{\/(for|foreach|while)\s*\}/s' ,
			'/\{dowhile\s([^\}]+)\}(.*?)\{\/dowhile\s*\}/s' ,
			'/\{break\s*\}/' ,
			'/\{continue\s*\}/' ,
 
			// find if-elseif-else and endif statements
			'/\{if\s([^\}]+)\}(.*?)(\{\/if\s*\}|\{elseif[^\}]+\}|\{else\s*\})/s' ,
			'/\{elseif\s([^\}]+)\}(.*?)(\{\/if\s*\}|\{else\s*\})/s' ,
			'/\{else\s*\}(.*?)(\{\/if\s*\})/s' ,
			'/\{\/if\s*\}/' ,
 
			// find variables
			'/\{\$([^\}|\:]+)\}/' ,
 
			// find php functions {func_name arg, list} - {var_dump array(1,2,3)}
			'/\{([^\s\}$]+)\s?(.*?)\}/'
		) ,
		array(
			// put PHP code inside php tags
			'<?php \1 ?>' ,
 
			// replace loop template syntax with PHP template syntax
			'<?php \1(\2):?> \3 <?php end\1;?>' ,
			'<?php do{?> \2 <?php }while(\1);?>' ,
 
			// replace break and continue
			'<?php break;?>' ,
			'<?php continue;?>' ,
 
			// replace if statements
			'<?php if (\1):?>\2\3' ,
			'<?php elseif (\1):?>\2\3' ,
			'<?php else:?>\1\2' ,
			'<?php endif;?>' ,
 
			// replace variables, but allow vars that have not been assigned via AssignVar() so we use isset() to check
			'<?php echo (isset($\1)?$\1:$this->GetVar("\1"));?>' ,
 
			// replace PHP functions - {var_dump array(1,2,3)} becomes <?php var_dump(array(1,2,3));?>
			'<?php \1(\2);?>'
		) ,
		$str
	);
 
	// if the regular expression succeeded, use the replaced content, otherwise, use $str which has our pre-assigned variables replaced
	return $replaced : $replaced : $str;
}

<?php
 
class Template
{
	/**
	* TEMPLATE_DIR is a constant which holds the path to the directory where the original template files are stored
	*
	* @var string path to template directory
	**/
	const TEMPLATE_DIR = 'TemplateEngine/templates';
 
	/**
	* COMPILE_DIR is a constant which holds the path to the directory where the compiled template files are stored
	*
	* @var string path to compiled directory
	**/
	const COMPILE_DIR = 'TemplateEngine/templates_compiled';
 
	/**
	* CACHE_DIR is a constant which holds the path to the directory where the cached template files are stored
	*
	* @var string path to cached directory
	**/
	const CACHE_DIR = 'TemplateEngine/templates_cached';
 
	/**
	* RESOURCE_DIR is a constant which holds the path to the directory where resource types may be declared in files
	* 
	* @var string path to the directory where pre-defined template resource types are stored
	*/
	const RESOURCE_DIR = 'TemplateEngine/template_resource_types';
 
	/**
	* This stores the resource types that have been loaded from files in the pre-determined location (self::RESOURCE_DIR). 
	* This is here so we don't have to look for them on each instantiation, only the first of each page request
	* 
	* @var array
	*/
	private static $LoadedResourceTypes = array();
 
	/**
	* This is an associative array which holds the variable names (keys) and the values to parse in the template file
	*
	* @var array - associative array
	**/
	private $variables = array();
 
	/**
	* Associative array of resource-types that have been registered with this class
	* 
	* @var array - array('type_name'=>array('content_callback_function','datestamp_callback_function'))
	*/
	private $resource_types = array();
 
	/**
	* This is a boolean indicating whether or not this class should cache templates or use cached templates when fetched - false by default
	*
	* @var boolean false by default
	**/
	public $caching = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-compile the template if it is already compiled, regardless of its datestamps
	*
	* @var boolean
	**/
	public $recompile = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-cache the template if it is already cached, regardless of its datestamps
	* 
	* @var boolean
	*/
	public $recache = false;
 
	/**
	* This controls whether or not the template class should look for and replace template control structure syntax into php syntax - true by default
	* If you know you're not going to use control-structures, turn this off to save processing time
	* 
	* @var boolean true to parse control structures, false otherwise - true by default
	*/
	public $parse_control_structures = true;
 
	/**
	* Our constructor method - this will load resource types from files and handle any other procedures we may need 
	* 
	*/
	public function __construct()
	{
		// load pre-defined resource types from files
		$this->LoadResourceTypes();
 
		// register our default 'file' resource type
		$this->AddResourceType('file', array($this, 'FetchFileContent'), array($this, 'FetchFileDatetime'));
	}
 
	/**
	* This loads resource types from files in self::RESOURCE_DIR
	* 
	* @return boolean
	*/
	private function LoadResourceTypes()
	{
		// only read the directory once per request
		if ( !empty(self::$LoadedResourceTypes) )
		{
			$this->resource_types = self::$LoadedResourceTypes;
			return true;
		}
 
		// make sure we have a valid directory
		if ( !is_dir(self::RESOURCE_DIR) )
			return false;
 
		// read all files in the directory
		if ( $dir = opendir(self::RESOURCE_DIR) )
		{
			while ( false !== ($file = readdir($dir)) )
			{
				if ( !is_dir(self::RESOURCE_DIR .'/'. $file) )
				{
					// use pathinfo to retrieve the filename without the extension - introduced in PHP 5.2.0
					$filename = pathinfo($file, PATHINFO_FILENAME);
 
					/**
					* execute the file to retrieve the callback functions
					* the function names must follow a specific naming convention
					* 
					* content functions - function filename_template_content( $template_name ) { } - should return the template content or (bool)false
					* datetime functions - function filename_template_datetime( $template_name ) { } - should return the last-modified time as a unix-timestamp or (bool)false
					*/
 
					// use output buffering so nothing outputs to the browser
					ob_start();
					include self::RESOURCE_DIR .'/'. $file;
					ob_end_clean();
 
					// make sure the callback functions exist
					if ( !is_callable($filename .'_template_content') )
					{
						throw new Exception($file .' does not have a valid callback function for fetching content.');
						continue;
					}
 
					if ( !is_callable($filename .'_template_datetime') )
					{
						throw new Exception($file .' does not have a valid callback function for fetching a last-modified date.');
						continue;
					}
 
					// save the resource type
					$this->resource_types[ $filename ] = self::$LoadedResourceTypes[ $filename ] = array($filename .'_template_content', $filename .'_template_datetime');
				}
			}
			closedir($dir);
		}
 
		return true;
	}
 
	/**
	* Display a fetched template - uses 'print'
	* 
	* @param string $name the name of the template to display
	* @param string $type the resource type we are using to fetch the template - defaults to 'file'
	*/
	public function Display( $name , $type='file' )
	{
		$contents = $this->Fetch($name, $type);
		print $contents;
	}
 
	/**
	* Fetch a template
	* 
	* @param string $name the filename of the template to fetch
	* @param string $type the resource type - defaults to 'file'
	* @return mixed (bool)false or string contents of the parsed file
	*/
	public function Fetch( $name , $type='file' )
	{
		// fetch the last-modified time of the template here, so it's not done multiple times
		$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $this->caching && !$this->recache && $this->IsCached($name, $type, $template_mtime) )
			return file_get_contents(self::CACHE_DIR .'/'. $type .'_'. $name .'.php');
 
		if ( $this->recompile || !$this->IsCompiled($name, $type, $template_mtime) )
		{
			$contents = $this->FetchContent($name, $type);
			if ( !$contents )
			{
				throw new Exception('Contents for '. $name .' could not be fetched.');
				return false;
			}
			// we always compile the template if it's not compiled already
			$compiled = $this->Compile($contents);
			$this->SaveCompiledTemplate($name, $compiled, $type);
			unset($compiled);
			unset($contents);
		}
 
		// make sure the template doesn't overwrite our $type and $name variables - since it's executed within this scope
		$__template_name__ = $name;
		$__template_type__ = $type;
		unset($name);
		unset($type);
 
		// our 'parsed' version of the template is the result of the executed 'compiled' file
		ob_start();
		include self::COMPILE_DIR .'/'. $__template_type__ .'_'. $__template_name__ .'.php';
		$parsed = ob_get_clean();
 
		if ( $this->caching )
			$this->SaveCachedTemplate($__template_name__, $parsed, $__template_type__);
 
		return $parsed;
	}
 
	/**
	* Retrieve the content for a registered resource type
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @return mixed the file contents or (bool)false
	*/
	public function FetchContent( &$name , $type )
	{
		if ( !isset($this->resource_types[$type]) )
			return false;
 
		$content = call_user_func($this->resource_types[$type][0], $name);
		return $content ? $content : false;
	}
 
	/**
	* Retrieve the last-modified unix-timestamp for a registered resource type
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @return mixed (int)last-modified as a unix-timestamp or (bool)false
	*/
	public function FetchDatetime( &$name , $type )
	{
		if ( !isset($this->resource_types[$type]) )
			return false;
 
		$datetime = call_user_func($this->resource_types[$type][1], $name);
		return $datetime ? $datetime : false;
	}
 
	/**
	* Retrieve the content for a 'file' template type - this is for our default resource type
	* 
	* @param string $name the template name or file-name - this is by reference, because we may change the file name with a default file extension
	* @return mixed the file contents or (bool)false
	*/
	public function FetchFileContent( &$name )
	{
		$name = trim($name, '/');
		if ( !file_exists(self::TEMPLATE_DIR .'/'. $name) )
		{
			$ext = pathinfo($name, PATHINFO_EXTENSION);
			if ( empty($ext) )
			{
				if ( !file_exists(self::TEMPLATE_DIR .'/'. $name .'.tpl') )
					return false;
 
				$name = $name .'.tpl';
			}
		}
		return file_get_contents(self::TEMPLATE_DIR .'/'. $name);
	}
 
	/**
	* Retrieve the last-modified date for a 'file' template type - this is for our default resource type
	* 
	* @param string $name the template name or file-name - this is by reference, because we may change the file name with a default file extension
	* @return mixed the last-modified date as a unix-timestamp or (bool)false
	*/
	public function FetchFileDatetime( &$name )
	{
		$name = trim($name, '/');
		if ( !file_exists(self::TEMPLATE_DIR .'/'. $name) )
		{
			$ext = pathinfo($name, PATHINFO_EXTENSION);
			if ( empty($ext) )
			{
				if ( !file_exists(self::TEMPLATE_DIR .'/'. $name .'.tpl') )
					return false;
 
				$name = $name .'.tpl';
			}
		}
		return filemtime(self::TEMPLATE_DIR .'/'. $name);
	}
 
	/**
	* See if a template-file is compiled already
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $type the resource type - defaults to 'file'
	* @param mixed $template_mtime should be an integer unix-timestamp of the last-modified time or null - if null, it will be fetched in this function
	* @return boolean
	*/
	public function IsCompiled( &$name , $type='file' , $template_mtime=null )
	{
		if ( is_null($template_mtime) )
			$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $template_mtime === false )
			return false;
 
		if ( !file_exists(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php') )
			return false;
 
		if ( false === ($compiled_mtime = filemtime(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php')) )
			return false;
 
		return ($compiled_mtime >= $template_mtime);
	}
 
	/**
	* See if a template is cached already
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $type the resource type - defaults to 'file'
	* @param mixed $template_mtime should be an integer unix-timestamp of the last-modified time or null - if null, it will be fetched in this function
	* @return boolean
	*/
	public function IsCached( &$name , $type='file' , $template_mtime=null )
	{
		if ( is_null($template_mtime) )
			$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $template_mtime === false )
			return false;
 
		if ( !file_exists(self::CACHE_DIR .'/'. $type .'_'. $name .'.php') )
			return false;
 
		if ( false === ($cached_mtime = filemtime(self::CACHE_DIR .'/'. $type .'_'. $name .'.php')) )
			return false;
 
		return ($cached_mtime >= $template_mtime);
	}
 
	/**
	* Compile a template
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $contents should contain the compiled contents of the file
	* @param string $type the resource type - defaults to 'file'
	* @param boolean $is_compiled if true, $contents need to contain the compiled contents, if false, $contents should contain the raw-contents (uncompiled)
	* @return boolean
	*/
	protected function SaveCompiledTemplate( &$name , $contents , $type='file' , $is_compiled=true )
	{
		if ( !is_dir(self::COMPILE_DIR) )
			return false;
 
		$compiled = $is_compiled ? $contents : $this->Compile($contents);
		return (bool)file_put_contents(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php', $compiled);
	}
 
	/**
	* Cache a template
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $contents should contain the parsed contents of the file
	* @param string $type the resource type - defaults to 'file'
	* @return boolean
	*/
	protected function SaveCachedTemplate( &$name , $contents , $type='file' )
	{
		if ( !is_dir(self::CACHE_DIR) )
			return false;
 
		return (bool)file_put_contents(self::CACHE_DIR .'/'. $type .'_'. $name .'.php', $contents);
	}
 
	/**
	* Add / Register a resource type with this Template instance
	* 
	* @param string $name the name of the resource type
	* @param callback $content_callback the function used to fetch the content
	* @param callback $datetime_callback the function used to fetch the last-modified time
	* @return boolean
	*/
	public function AddResourceType( $name , $content_callback , $datetime_callback )
	{
		if ( !is_callable($content_callback) )
		{
			throw new Exception('Your content callback function does not appear to be valid for "'. $name .'".');
			return false;
		}
		if ( !is_callable($datetime_callback) )
		{
			throw new Exception('Your last-modified callback function does not appear to be valid for "'. $name .'".');
			return false;
		}
		$this->resource_types[ $name ] = array($content_callback, $datetime_callback);
		return true;
	}
 
	/**
	* Remove a registered resource type by name
	* 
	* @param string $name the resource type name you wish to remove
	*/
	public function RemoveResourceType( $name )
	{
		if ( isset($this->resource_types[$name]) )
			unset($this->resource_types[$name]);
	}
 
	/**
	* Retrieve a registered resource type
	* 
	* @param mixed $name if null or not provided, all resource types are returned
	* @return mixed array or (bool)false
	*/
	public function GetResourceType( $name=null )
	{
		if ( is_null($name) )
			return $this->resource_types;
		elseif ( isset($this->resource_types[$name]) )
			return $this->resource_types[$name];
		else
			return false;
	}
 
 	/**
 	* Assign a variable to the template engine so it can be parsed
 	* 
 	* @param string $name the variable name
 	* @param mixed $value
 	*/
	public function AssignVar( $name , $value )
	{
		$this->variables[$name] = $value;
	}
 
 	/**
 	* Retrieve the value of an assigned variable
 	* 
 	* @param mixed $name the variable name - if this is not provided or is null, all the variables are returned as an associative array
 	* @return mixed
 	*/
	public function GetVar( $name=null )
	{
		if ( is_null($name) )
			return $this->variables;
		elseif ( isset($this->variables[$name]) )
			return $this->variables[$name];
		else
			return false;
	}
 
 	/**
 	* Remove an assigned variable
 	* 
 	* @param string $name the variable name
 	*/
	public function RemoveVar( $name )
	{
		if ( isset($this->variables[$name]) )
			unset($this->variables[$name]);
	}
 
 	/**
 	* Takes template-contents and returns contents with the necessary PHP code to execute everything, if-statements and variables
 	* 
 	* @param string $str the raw template contents
 	* @return string
 	*/
	public function Compile( $str )
	{
		// replace assigned variables first
		$search = array();
		$replace = array();
		foreach ( $this->variables as $key => $value )
		{
			$search[] = '{$'. $key .'}';
			$replace[] = '<?php echo $this->GetVar("'. addslashes($key) .'");?>';
		}
		$str = str_replace($search, $replace, $str);
 
		// if we're not parsing control structures, there's no need to continue, return the parsed str
		if ( !$this->parse_control_structures )
			return $str;
 
		// replace control-structures, predefined blocks and tags (break, continue), other variables that were not assigned before-hand, and other misc. functions
		$replaced = preg_replace(
			array(
				// find PHP blocks
				'/\{php\}(.*?)\{\/php\}/s' ,
 
				// find loops and loop-controls like continue and break
				'/\{(for|foreach|while)\s([^\}]+)\}(.*?)\{\/(for|foreach|while)\s*\}/s' ,
				'/\{dowhile\s([^\}]+)\}(.*?)\{\/dowhile\s*\}/s' ,
				'/\{break\s*\}/' ,
				'/\{continue\s*\}/' ,
 
				// find if-elseif-else and endif statements
				'/\{if\s([^\}]+)\}(.*?)(\{\/if\s*\}|\{elseif[^\}]+\}|\{else\s*\})/s' ,
				'/\{elseif\s([^\}]+)\}(.*?)(\{\/if\s*\}|\{else\s*\})/s' ,
				'/\{else\s*\}(.*?)(\{\/if\s*\})/s' ,
				'/\{\/if\s*\}/' ,
 
				// find variables
				'/\{\$([^\}|\:]+)\}/' ,
 
				// find php functions {func_name arg, list} - {var_dump array(1,2,3)}
				'/\{([^\s\}$]+)\s?(.*?)\}/'
			) ,
			array(
				// put PHP code inside PHP tags
				'<?php \1 ?>' ,
 
				// replace loop template syntax with PHP template syntax
				'<?php \1(\2):?> \3 <?php end\1;?>' ,
				'<?php do{?> \2 <?php }while(\1);?>' ,
 
				// replace break and continue
				'<?php break;?>' ,
				'<?php continue;?>' ,
 
				// replace if statments
				'<?php if (\1):?>\2\3' ,
				'<?php elseif (\1):?>\2\3' ,
				'<?php else:?>\1\2' ,
				'<?php endif;?>' ,
 
				// replace variables, but allow vars that have not been assigned via AssignVar() so we use isset() to check
				'<?php echo (isset($\1)?$\1:$this->GetVar("\1"));?>' ,
 
				// replace PHP functions - {var_dump array(1,2,3)} becomes var_dump(array(1,2,3));
				'<?php \1(\2);?>'
			) ,
			$str
		);
 
		// return the compiled data
		return $replaced ? $replaced : $str;
	}
}

<?php
 
class Template
{
	/**
	* TEMPLATE_DIR is a constant which holds the path to the directory where the original template files are stored
	*
	* @var string path to template directory
	**/
	const TEMPLATE_DIR = 'TemplateEngine/templates';
 
	/**
	* COMPILE_DIR is a constant which holds the path to the directory where the compiled template files are stored
	*
	* @var string path to compiled directory
	**/
	const COMPILE_DIR = 'TemplateEngine/templates_compiled';
 
	/**
	* CACHE_DIR is a constant which holds the path to the directory where the cached template files are stored
	*
	* @var string path to cached directory
	**/
	const CACHE_DIR = 'TemplateEngine/templates_cached';
 
	/**
	* RESOURCE_DIR is a constant which holds the path to the directory where resource types may be declared in files
	* 
	* @var string path to the directory where pre-defined template resource types are stored
	*/
	const RESOURCE_DIR = 'TemplateEngine/template_resource_types';
 
	/**
	* This stores the resource types that have been loaded from files in the pre-determined location (self::RESOURCE_DIR). 
	* This is here so we don't have to look for them on each instantiation, only the first of each page request
	* 
	* @var array
	*/
	private static $LoadedResourceTypes = array();
 
	/**
	* This is an associative array which holds the variable names (keys) and the values to parse in the template file
	*
	* @var array - associative array
	**/
	private $variables = array();
 
	/**
	* Associative array of resource-types that have been registered with this class
	* 
	* @var array - array('type_name'=>array('content_callback_function','datestamp_callback_function'))
	*/
	private $resource_types = array();
 
	/**
	* This is a boolean indicating whether or not this class should compile templates or use compiled templates when fetched - true by default
	*
	* @var boolean true by default
	**/
	public $compiling = true;
 
	/**
	* This is a boolean indicating whether or not this class should cache templates or use cached templates when fetched - false by default
	*
	* @var boolean false by default
	**/
	public $caching = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-compile the template if it is already compiled, regardless of its datestamps
	*
	* @var boolean
	**/
	public $recompile = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-cache the template if it is already cached, regardless of its datestamps
	* 
	* @var boolean
	*/
	public $recache = false;
 
	/**
	* Our constructor method - this will load resource types from files and handle any other procedures we may need 
	* 
	*/
	public function __construct()
	{
		// load pre-defined resource types from files
		$this->LoadResourceTypes();
 
		// register our default 'file' resource type
		$this->AddResourceType('file', array($this, 'FetchFileContent'), array($this, 'FetchFileDatetime'));
	}
 
	/**
	* This loads resource types from files in self::RESOURCE_DIR
	* 
	* @return boolean
	*/
	private function LoadResourceTypes()
	{
		// only read the directory once per request
		if ( !empty(self::$LoadedResourceTypes) )
		{
			$this->resource_types = self::$LoadedResourceTypes;
			return true;
		}
 
		// make sure we have a valid directory
		if ( !is_dir(self::RESOURCE_DIR) )
			return false;
 
		// read all files in the directory
		if ( $dir = opendir(self::RESOURCE_DIR) )
		{
			while ( false !== ($file = readdir($dir)) )
			{
				if ( !is_dir(self::RESOURCE_DIR .'/'. $file) )
				{
					// use pathinfo to retrieve the filename without the extension - introduced in PHP 5.2.0
					$filename = pathinfo($file, PATHINFO_FILENAME);
 
					/**
					* execute the file to retrieve the callback functions
					* the function names must follow a specific naming convention
					* 
					* content functions - function filename_template_content( $template_name ) { } - should return the template content or (bool)false
					* datetime functions - function filename_template_datetime( $template_name ) { } - should return the last-modified time as a unix-timestamp or (bool)false
					*/
 
					// use output buffering so nothing outputs to the browser
					ob_start();
					include self::RESOURCE_DIR .'/'. $file;
					ob_end_clean();
 
					// make sure the callback functions exist
					if ( !is_callable($filename .'_template_content') )
					{
						throw new Exception($file .' does not have a valid callback function for fetching content.');
						continue;
					}
 
					if ( !is_callable($filename .'_template_datetime') )
					{
						throw new Exception($file .' does not have a valid callback function for fetching a last-modified date.');
						continue;
					}
 
					// save the resource type
					$this->resource_types[ $filename ] = self::$LoadedResourceTypes[ $filename ] = array($filename .'_template_content', $filename .'_template_datetime');
				}
			}
			closedir($dir);
		}
 
		return true;
	}
 
	/**
	* Display a fetched template - uses 'print'
	* 
	* @param string $name the name of the template to display
	* @param string $type the resource type we are using to fetch the template - defaults to 'file'
	*/
	public function Display( $name , $type='file' )
	{
		$contents = $this->Fetch($name, $type);
		print $contents;
	}
 
	/**
	* Fetch a template
	* 
	* @param string $name the filename of the template to fetch
	* @param string $type the resource type - defaults to 'file'
	* @return mixed (bool)false or string contents of the parsed file
	*/
	public function Fetch( $name , $type='file' )
	{
		// fetch the last-modified time of the template here so it's not done multiple times
		$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $this->caching && !$this->recache && $this->IsCached($name, $type, $template_mtime) )
			return file_get_contents(self::CACHE_DIR .'/'. $type .'_'. $name .'.php');
 
		if ( $this->compiling && !$this->recompile && $this->IsCompiled($name, $type, $template_mtime) )
		{
			ob_start();
			include self::COMPILE_DIR .'/'. $type .'_'. $name .'.php';
			return ob_get_clean();
		}
 
		$contents = $this->FetchContent($name, $type);
		if ( !$contents )
		{
			throw new Exception('Contents for '. $name .' could not be fetched.');
			return false;
		}
 
		$parsed = $this->Parse($contents);
 
		if ( $this->compiling )
			$this->CompileTemplate($name, $contents, $type);
 
		if ( $this->caching )
			$this->CacheTemplate($name, $parsed, $type, true);
 
		return $parsed;
	}
 
	/**
	* Retrieve the content for a registered resource type
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @return mixed the file contents or (bool)false
	*/
	public function FetchContent( &$name , $type )
	{
		if ( !isset($this->resource_types[$type]) )
			return false;
 
		$content = call_user_func($this->resource_types[$type][0], $name);
		return $content ? $content : false;
	}
 
	/**
	* Retrieve the last-modified unix-timestamp for a registered resource type
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @return mixed (int)last-modified as a unix-timestamp or (bool)false
	*/
	public function FetchDatetime( &$name , $type )
	{
		if ( !isset($this->resource_types[$type]) )
			return false;
 
		$datetime = call_user_func($this->resource_types[$type][1], $name);
		return $datetime ? $datetime : false;
	}
 
	/**
	* Retrieve the content for a 'file' template type - this is for our default resource type
	* 
	* @param string $name the template name or file-name - this is by reference, because we may change the file name with a default file extension
	* @return mixed the file contents or (bool)false
	*/
	public function FetchFileContent( &$name )
	{
		$name = trim($name, '/');
		if ( !file_exists(self::TEMPLATE_DIR .'/'. $name) )
		{
			$ext = pathinfo($name, PATHINFO_EXTENSION);
			if ( empty($ext) )
			{
				if ( !file_exists(self::TEMPLATE_DIR .'/'. $name .'.tpl') )
					return false;
 
				$name = $name .'.tpl';
			}
		}
		return file_get_contents(self::TEMPLATE_DIR .'/'. $name);
	}
 
	/**
	* Retrieve the last-modified date for a 'file' template type - this is for our default resource type
	* 
	* @param string $name the template name or file-name - this is by reference, because we may change the file name with a default file extension
	* @return mixed the last-modified date as a unix-timestamp or (bool)false
	*/
	public function FetchFileDatetime( &$name )
	{
		$name = trim($name, '/');
		if ( !file_exists(self::TEMPLATE_DIR .'/'. $name) )
		{
			$ext = pathinfo($name, PATHINFO_EXTENSION);
			if ( empty($ext) )
			{
				if ( !file_exists(self::TEMPLATE_DIR .'/'. $name .'.tpl') )
					return false;
 
				$name = $name .'.tpl';
			}
		}
		return filemtime(self::TEMPLATE_DIR .'/'. $name);
	}
 
	/**
	* See if a template-file is compiled already
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $type the resource type - defaults to 'file'
	* @param mixed $template_mtime should be an integer unix-timestamp of the last-modified time or null - if null, it will be fetched in this function
	* @return boolean
	*/
	public function IsCompiled( &$name , $type='file' , $template_mtime=null )
	{
		if ( is_null($template_mtime) )
			$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $template_mtime === false )
			return false;
 
		if ( !file_exists(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php') )
			return false;
 
		if ( false === ($compiled_mtime = filemtime(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php')) )
			return false;
 
		return ($compiled_mtime >= $template_mtime);
	}
 
	/**
	* See if a template is cached already
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $type the resource type - defaults to 'file'
	* @param mixed $template_mtime should be an integer unix-timestamp of the last-modified time or null - if null, it will be fetched in this function
	* @return boolean
	*/
	public function IsCached( &$name , $type='file' , $template_mtime=null )
	{
		if ( is_null($template_mtime) )
			$template_mtime = $this->FetchDatetime($name, $type);
 
		if ( $template_mtime === false )
			return false;
 
		if ( !file_exists(self::CACHE_DIR .'/'. $type .'_'. $name .'.php') )
			return false;
 
		if ( false === ($cached_mtime = filemtime(self::CACHE_DIR .'/'. $type .'_'. $name .'.php')) )
			return false;
 
		return ($cached_mtime >= $template_mtime);
	}
 
	/**
	* Compile a template
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $contents should contain the raw contents of the file
	* @param string $type the resource type - defaults to 'file'
	* @return boolean
	*/
	protected function CompileTemplate( &$name , $contents , $type='file' )
	{
		if ( !is_dir(self::COMPILE_DIR) )
			return false;
 
		$compiled = $this->Parse($contents, true);
		return (bool)file_put_contents(self::COMPILE_DIR .'/'. $type .'_'. $name .'.php', $compiled);
	}
 
	/**
	* Cache a template
	* 
	* @param string $name the template name - this is by reference, because the callback may alter it slightly
	* @param string $contents should contain the cached contents of the file
	* @param string $type the resource type - defaults to 'file'
	* @param boolean $is_parsed true if the contents has already been parsed, false otherwise
	* @return boolean
	*/
	protected function CacheTemplate( &$name , $contents , $type='file' , $is_parsed=false )
	{
		if ( !is_dir(self::CACHE_DIR) )
			return false;
 
		$cached = $is_parsed ? $contents : $this->Parse($contents);
		return (bool)file_put_contents(self::CACHE_DIR .'/'. $type .'_'. $name .'.php', $cached);
	}
 
	/**
	* Add / Register a resource type with this Template instance
	* 
	* @param string $name the name of the resource type
	* @param callback $content_callback the function used to fetch the content
	* @param callback $datetime_callback the function used to fetch the last-modified time
	* @return boolean
	*/
	public function AddResourceType( $name , $content_callback , $datetime_callback )
	{
		if ( !is_callable($content_callback) )
		{
			throw new Exception('Your content callback function does not appear to be valid for "'. $name .'".');
			return false;
		}
		if ( !is_callable($datetime_callback) )
		{
			throw new Exception('Your last-modified callback function does not appear to be valid for "'. $name .'".');
			return false;
		}
		$this->resource_types[ $name ] = array($content_callback, $datetime_callback);
		return true;
	}
 
	/**
	* Remove a registered resource type by name
	* 
	* @param string $name the resource type name you wish to remove
	*/
	public function RemoveResourceType( $name )
	{
		if ( isset($this->resource_types[$name]) )
			unset($this->resource_types[$name]);
	}
 
	/**
	* Retrieve a registered resource type
	* 
	* @param mixed $name if null or not provided, all resource types are returned
	* @return mixed array or (bool)false
	*/
	public function GetResourceType( $name=null )
	{
		if ( is_null($name) )
			return $this->resource_types;
		elseif ( isset($this->resource_types[$name]) )
			return $this->resource_types[$name];
		else
			return false;
	}
 
 	/**
 	* Assign a variable to the template engine so it can be parsed
 	* 
 	* @param string $name the variable name
 	* @param mixed $value
 	*/
	public function AssignVar( $name , $value )
	{
		$this->variables[$name] = $value;
	}
 
 	/**
 	* Retrieve the value of an assigned variable
 	* 
 	* @param mixed $name the variable name - if this is not provided or is null, all the variables are returned as an associative array
 	* @return mixed
 	*/
	public function GetVar( $name=null )
	{
		if ( is_null($name) )
			return $this->variables;
		elseif ( isset($this->variables[$name]) )
			return $this->variables[$name];
		else
			return false;
	}
 
 	/**
 	* Remove an assigned variable
 	* 
 	* @param string $name the variable name
 	*/
	public function RemoveVar( $name )
	{
		if ( isset($this->variables[$name]) )
			unset($this->variables[$name]);
	}
 
 	/**
 	* Takes template-contents and returns those contents with variables replaced with values
 	* 
 	* @param string $str
 	* @param boolean $compile true if you wish to return 'compiled code' instead of parsed code - compiled code has template syntax changed into php syntax
 	* @return string
 	*/
	public function Parse( $str , $compile=false )
	{
		$search = array();
		$replace = array();
		foreach ( $this->variables as $name => $value )
		{
			$search[] = '{$'. $name .'}';
 
			if ( $compile )
				$replace[] = '<?php echo $this->GetVar("'. addslashes($name) .'");?>';
			else
				$replace[] = $value;
		}
		return str_replace($search, $replace, $str);
	}
}

<?php
 
function cms_template_content( $name )
{
	$rs = mysql_query('select content from templates where name = "'. mysql_real_escape_string($name) .'"');
	if ( !$rs || !mysql_num_rows($rs) )
		return false;
 
	list($content) = mysql_fetch_array($rs, MYSQL_NUM);
	return $content;	
}
 
function cms_template_datetime( $name )
{
	$rs = mysql_query('select last_modified from templates where name = "'. mysql_real_escape_string($name) .'"');
 
	if ( !$rs || !mysql_num_rows($rs) )
		return false;
 
	list($last_modified) = mysql_fetch_array($rs, MYSQL_NUM);
	return $last_modified;
}

<?php
 
class CMSTemplate extends Template
{
	public function __construct()
	{
		parent::__construct();
 
		$this->AddResourceType(
			'cms',
			function($name)
			{
				$rs = mysql_query('select content from templates where name = "'. mysql_real_escape_string($name) .'"');
 
				if ( !$rs || !mysql_num_rows($rs) )
					return false;
 
				list($content) = mysql_fetch_array($rs, MYSQL_NUM);
				return $content;
			},
			function($name)
			{
				$rs = mysql_query('select last_modified from templates where name = "'. mysql_real_escape_string($name) .'"');
 
				if ( !$rs || !mysql_num_rows($rs) )
					return false;
 
				list($last_modified) = mysql_fetch_array($rs, MYSQL_NUM);
				return $last_modified;
			}
		);
	}
}

<?php
 
// include and instantiate the template class
require_once 'Template.php';
$template = new Template;
 
// get contact info from database
require_once 'db.php';
$rs = mysql_query('select address, phone, email from company', $dblink);
if ( !$rs || mysql_errno($rs) > 0 || mysql_num_rows($rs) <= 0 )
{
	// if we cannot find data, display a message and assign empty values
	echo 'Error while retrieving company contact information';
	$template->AssignVar('address', 'N/A');
	$template->AssignVar('phone', 'N/A');
	$template->AssignVar('email', 'N/A');
} else {
	// if we have data, assign it
	$row = mysql_fetch_array($rs, MYSQL_ASSOC);
	$template->AssignVar('address', $row['address']);
	$template->AssignVar('phone', $row['phone']);
	$template->AssignVar('email', $row['email']);
}
 
// Tell the object to display a 'cms' template resource
$template->Display('contact', 'cms');
 
?>

<?php
 
class Template
{
	/**
	* TEMPLATE_DIR is a constant which holds the relative path to the directory where the original template files are stored
	*
	* @var string relative path to template directory
	**/
	const TEMPLATE_DIR = 'TemplateEngine/templates';
 
	/**
	* COMPILE_DIR is a constant which holds the relative path to the directory where the compiled template files are stored
	*
	* @var string relative path to compiled directory
	**/
	const COMPILE_DIR = 'TemplateEngine/templates_compiled';
 
	/**
	* CACHE_DIR is a constant which holds the relative path to the directory where the cached template files are stored
	*
	* @var string relative path to cached directory
	**/
	const CACHE_DIR = 'TemplateEngine/templates_cached';
 
	/**
	* This is an associative array which holds the variable names (keys) and the values to parse in the template file
	*
	* @var array - associative array
	**/
	private $variables = array();
 
	/**
	* This is a boolean indicating whether or not this class should compile templates or use compiled templates when fetched - true by default
	*
	* @var boolean true by default
	**/
	public $compiling = true;
 
	/**
	* This is a boolean indicating whether or not this class should cache templates or use cached templates when fetched - false by default
	*
	* @var boolean false by default
	**/
	public $caching = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-compile the template if it is already compiled, regardless of its datestamps
	*
	* @var boolean
	**/
	public $recompile = false;
 
	/**
	* This is a boolean indicating whether or not this class should re-cache the template if it is already cached, regardless of its datestamps
	* 
	* @var boolean
	*/
	public $recache = false;
 
	/**
	* Display a fetched template - uses 'print'
	* 
	* @param string $filename the filename of the template to display
	*/
	public function Display( $filename )
	{
		$contents = $this->Fetch($filename);
		print $contents;
	}
 
	/**
	* Fetch a template
	* 
	* @param string $filename the filename of the template to fetch
	* @return mixed (bool)false or string contents of the parsed file
	*/
	public function Fetch( $filename )
	{
		$filename = trim($filename, '/');
 
		if ( $this->caching && !$this->recache && $this->IsCached($filename) )
			return file_get_contents(self::CACHE_DIR .'/'. $filename .'.php');
 
		if ( $this->compiling && !$this->recompile && $this->IsCompiled($filename) )
		{
			ob_start();
			include self::COMPILE_DIR .'/'. $filename .'.php';
			return ob_get_clean();
		}
 
		if ( file_exists(self::TEMPLATE_DIR .'/'. $filename) )
		{
			$contents = file_get_contents(self::TEMPLATE_DIR .'/'. $filename);
			$parsed = $this->Parse($contents);
 
			if ( $this->compiling )
				$this->CompileTemplate($filename, $contents);
 
			if ( $this->caching )
				$this->CacheTemplate($filename, $parsed, true);
 
			return $parsed;
		}
 
		return null;
	}
 
	/**
	* See if a template-file is compiled already
	* 
	* @param string $filename
	* @return boolean
	*/
	public function IsCompiled( $filename )
	{
		$filename = trim($filename, '/');
 
		if ( !file_exists(self::COMPILE_DIR .'/'. $filename .'.php') )
			return false;
 
		if ( false === ($template_mtime = filemtime(self::TEMPLATE_DIR .'/'. $filename)) )
			return false;
 
		if ( false === ($compiled_mtime = filemtime(self::COMPILE_DIR .'/'. $filename .'.php')) )
			return false;
 
		return ($compiled_mtime >= $template_mtime);
	}
 
	/**
	* See if a template-file is cached already
	* 
	* @param string $filename
	* @return boolean
	*/
	public function IsCached( $filename )
	{
		$filename = trim($filename, '/');
 
		if ( !file_exists(self::CACHE_DIR .'/'. $filename .'.php') )
			return false;
 
		if ( false === ($template_mtime = filemtime(self::TEMPLATE_DIR .'/'. $filename)) )
			return false;
 
		if ( false === ($cached_mtime = filemtime(self::CACHE_DIR .'/'. $filename .'.php')) )
			return false;
 
		return ($cached_mtime >= $template_mtime);
	}
 
	/**
	* Compile a template
	* 
	* @param string $filename
	* @param string $contents should contain the un-parsed contents of the file
	* @return boolean
	*/
	protected function CompileTemplate( $filename , $contents )
	{
		if ( !is_dir(self::COMPILE_DIR) )
			return false;
 
		$compiled = $this->Parse($contents, true);
		return (bool)file_put_contents(self::COMPILE_DIR .'/'. trim($filename, '/') .'.php', $compiled);
	}
 
	/**
	* Cache a template
	* 
	* @param string $filename
	* @param string $contents should contain the contents of the file (parsed or not, see $is_parsed)
	* @param boolean $is_parsed true if the contents have already been parsed, false otherwise
	* @return boolean
	*/
	protected function CacheTemplate( $filename , $contents , $is_parsed=false )
	{
		if ( !is_dir(self::CACHE_DIR) )
			return false;
 
		$cached = $is_parsed ? $contents : $this->Parse($contents);
		return (bool)file_put_contents(self::CACHE_DIR .'/'. trim($filename, '/') .'.php', $cached);
	}
 
 	/**
 	* Assign a variable to the template engine so it can be parsed
 	* 
 	* @param string $name the variable name
 	* @param mixed $value
 	*/
	public function AssignVar( $name , $value )
	{
		$this->variables[$name] = $value;
	}
 
 	/**
 	* Retrieve the value of an assigned variable
 	* 
 	* @param mixed $name the variable name - if this is not provided or is null, all the variables are returned as an associative array
 	* @return mixed
 	*/
	public function GetVar( $name=null )
	{
		if ( is_null($name) )
			return $this->variables;
		elseif ( isset($this->variables[$name]) )
			return $this->variables[$name];
		else
			return false;
	}
 
 	/**
 	* Remove an assigned variable
 	* 
 	* @param string $name the variable name
 	*/
	public function RemoveVar( $name )
	{
		if ( isset($this->variables[$name]) )
			unset($this->variables[$name]);
	}
 
 	/**
 	* Takes template-contents and returns those contents with variables replaced with values
 	* 
 	* @param string $str
 	* @param boolean $compile true if you wish to return 'compiled code' instead of parsed code - compiled code has template syntax changed into php syntax
 	* @return string
 	*/
	public function Parse( $str , $compile=false )
	{
		$search = array();
		$replace = array();
		foreach ( $this->variables as $name => $value )
		{
			$search[] = '{$'. $name .'}';
 
			if ( $compile )
				$replace[] = '<?php echo $this->GetVar("'. addslashes($name) .'");?>';
			else
				$replace[] = $value;
		}
		return str_replace($search, $replace, $str);
	}
}

<html>
<head>
	<title>Contact Us</title>
</head>
 
<body>
 
<h1>Contact Us</h1>
 
<p>By Phone: <span>{$phone}</span></p>
<p>By Email: <span>{$email}</span></p>
<p>By Mail: <span>{$address}</span></p>
 
</body>
</html>

<?php
 
// include and instantiate the template class
require_once 'Template.php';
$template = new Template;
 
// get contact info from database
require_once 'db.php';
$rs = mysql_query('select address, phone, email from company', $dblink);
if ( !$rs || mysql_errno($rs) > 0 || mysql_num_rows($rs) <= 0 )
{
	// if we cannot find data, display a message and assign empty values
	echo 'Error while retrieving company contact information';
	$template->AssignVar('address', 'N/A');
	$template->AssignVar('phone', 'N/A');
	$template->AssignVar('email', 'N/A');
} else {
	// if we have data, assign it
	$row = mysql_fetch_array($rs, MYSQL_ASSOC);
	$template->AssignVar('address', $row['address']);
	$template->AssignVar('phone', $row['phone']);
	$template->AssignVar('email', $row['email']);
}
 
// The new Template class has an option to Display the data, which basically calls Fetch and then prints the data which is returned, for lazy folks like myself :)
$template->Display('contact.tpl');
 
?>

<?php
 
/* http://www.smarty.net/manual/en/plugins.block.functions.php */
 
abstract class SmartyBlock
{
	private static $nest = array(null);						// array of SmartyBlock objects at their relative nested-depth
	private static $current_depth = 0; 						// the current depth of this operation - index starts at 1, if the depth is 0, there is no depth
 
	protected $assign_data; 							// data that will be assigned to the template before the next output
	protected $tplvar = 'data'; 							// the template variable name that the assign_data will be assigned under - this is the default, extending classes may change it
 
	public $args;  									// the attributes associated to this tag {tagnname attribute="list"}
	public $content; 								// the content; null on the opening tag call otherwise it's the content nested inside the block after being evaluated by Smarty
	public $template;  								// Smarty template resource
	public $repeat;  								// ::Run will continue to execute while this is true
 
	abstract public function Run(); 						// this executes the block
 
	/**
	* Retrieve the current tag-stack depth
	*
	* @returns int the current depth
	**/
	public static function CurrentDepth()
	{
		return self::$current_depth;
	}
 
	/**
	* Retrieve a SmartyBlock instance at the given depth
	*
	* @param int $idx the depth you wish to retrieve a SmartyBlock object at
	* @returns mixed (bool)false or the SmartyBlock instance at the specified depth
	*/
	public static function GetNest( $idx )
	{
		return self::$nest[$idx]?:false;
	}
 
	/**
	* See if we are on the opening tag call
	*
	* @returns bool
	*/
	public function OpeningTag()
	{
		return $this->repeat && !$this->content;
	}
 
	/**
	* See if we are on the closing tag call
	*
	* @returns bool
	*/
	public function ClosingTag()
	{
		return !$this->OpeningTag();
	}
 
	/**
	* See if an argument was specified in the opening tag
	*
	* @param string $name the name of an argument
	* @returns bool
	*/
	public function HasArg( $name )
	{
		return isset($this->args[$name]);
	}
 
	/**
	* Get an argument that was specified in the opening tag
	*
	* @param string $name the name of an argument
	* @returns mixed (bool)false or the value of the argument, most likely as a string
	*/
	public function GetArg( $name )
	{
		return $this->args[$name]?:false;
	}
 
	/**
	* Invoke the block
	*
	* @param array $args the block arguments as an associative array
	* @param mixed $content the processed block content or null
	* @param Smarty a Smarty template instance (theoretically, the instance that executed the template file, but I've have cases where Smarty creates clones or passes a copy of the object - be warned)
	* @returns string the processed block contents
	*/
	public function __invoke( array $args , $content , &$template , &$repeat )
	{
		// if the content is not set, it means this is the opening-tag function call - set a new depth
		if ( !isset($content) )
			self::$current_depth += 1;
 
		$idx = self::$current_depth;
 
		// if we have a new depth, instantiate
		if ( !is_object(self::$nest[$idx]) )
			self::$nest[$idx] = $this;
 
		// initialize the block data
		self::$nest[$idx]->args = $args;
		self::$nest[$idx]->content = $content;
		self::$nest[$idx]->template = &$template;
		self::$nest[$idx]->repeat = &$repeat;
 
		// run the block
		$ret = self::$nest[$idx]->Run();
 
		// assign data for the next iteration in the block (or the next time smarty calls this function)
		if ( self::$nest[$idx]->assign_data )
			$template->assign(self::$nest[$idx]->tplvar, self::$nest[$idx]->assign_data);
 
		// clear the data after it's assigned
		self::$nest[$idx]->assign_data = null;
 
		// if we are not repeating, remove this instance from the nest and decrement the depth - we are done
		if ( !$repeat )
		{
			array_pop( self::$nest );
			self::$current_depth -= 1;
		}
 
		// assign the output or return the data - whatever Run() gave us should be the evaluated content or void
		if ( isset($args['tplvar']) )
		{
			$template->assign($args['tplvar'], $ret);
			return '';
		} else
			return $ret; 
	}
}

<?php
 
abstract class SmartyBlockList extends SmartyBlock
{
	protected $loaded = false;
	protected $index = 0;
	protected $length = 0;
	protected $data = array();
 
	abstract public function GetData();
 
	public function Run()
	{
		$this->tplvar = 'item';
 
		if ( !$this->loaded )
		{
			// opening-tag call - returns void
			$this->data = $this->GetData();
			$this->loaded = true;
			if ( !is_array($this->data) )
			{
				$this->template->trigger_error(get_class($this).'::GetData() did not return an array - SmartyBlockList fails.', E_USER_WARNING);
				$this->repeat = false;
				return;
			}
			$this->index = 0;
			$this->length = count($this->data);
		} else
			$this->index++;
 
		if ( $this->index > $this->length )
		{
			$this->repeat = false;
			return false;
		}
 
		$this->repeat = true;
		$this->assign_data = $this->data[ $this->index ];
 
		if ( $this->index == 0 )
			$this->assign_data['first'] = 'first';
		elseif ( $this->index == $this->length )
			$this->assign_data['last'] = 'last';
 
		/*
		  if the extending class provides it, $this->Iterate() is called on each Iteration
		*/
 
		if ( is_callable(array($this, 'Iterate')) )
			$this->Iterate();
 
		if ( $this->content )
			return $this->content;
	}
}

 
require_once '/path/to/SmartyBlock.php';
require_once '/path/to/SmartyBlockList.php';
 
class CategoryProducts extends SmartyBlockList
{
	public function GetData()
	{
		// make sure we know which category to display products for
		if ( !$this->HasArg('category') )
		{
			$this->template->trigger_error('{CategoryProducts} requires a category argument be supplied as an id or category name.');
			return array();
		}
 
		// using PDO with mysql, assuming you have a proper singleton-interface set up.
		// you can change this to mysql_* if you must or view my other post for an example
		// example of a custom PDO Singleton class: http://www.phpprofessional.us/memcache-session-handler/#dbclass
		$pdo = CustomPDO::GetPDO();
 
		// make sure the category provided exists		
		// allow the html dev to list products by category name or by category id
		$category = $this->GetArg('category');
		if ( is_numeric($category) )
		{
			// by category id
			$category_id = (int)$category;
			$st = $pdo->prepare('select name from categories where id = ?');
			$st->execute( array($category_id) );
			if ( !$st || $st->rowCount() <= 0 )
			{
				$this->template->trigger_error('Category id '. $category .' seems to be invalid. {CategoryProducts} fails.');
				return array();
			}
			list($category_name) = $st->fetch();
		} elseif ( is_scalar($category) ) {
			// by category name
			$st = $pdo->prepare('select id from categories where name = ?');
			$st->execute( array($category) );
			if ( !$st || $st->rowCount() <= 0 )
			{
				$this->template->trigger_error('Category '. $category .' seems to be invalid. {CategoryProducts} fails.');
				return array();
			}
			list($category_id) = $st->fetch();
			$category_name = $category;
		}
 
		$data = array('category_name'=>$category_name, 'category_id'=>$category_id);		
 
		/* From this point down is all the code we really need.  All the code above is sanitation and validation. */
 
		// get the products
		$st = $pdo->prepare('select id , name , description , image , price from products where id in ( select idProduct from product_categories where idCategory = ? )');
		$st->execute( array($category_id) );
		if ( $st && $st->rowCount() > 0 )
			return array_merge($data, $st->fetchAll( PDO::FETCH_ASSOC ));
		else
			return $data;
	}
}
 
// now this is how Smarty likes us to interact with our plugin
// we must make a function
function smarty_block_CategoryProducts( $params , $content , &$template , $repeat )
{
	// our SmartyBlock class takes advantage of PHP 5.3's invoke
 
	$block = new CategoryProducts;
	return $block($params, $content, $template, $repeat);
}

<h1>Viewing Products In: {$category|ucwords}</h1>
<table class="product_list">
	<tr class="header">
		<td />
		<th>Name</th>
		<th>Price</th>
		<th>Description</th>
		<th>Buy Now</th>
	</tr>
	{CategoryProducts category=$category}
		<tr class="product">
			<td><img src="http://www.blah.com/products/{$item.image}" alt="{$item.name|htmlentities}" /></td>
			<td>{$item.name|htmlentities}</td>
			<td>${$item.price|round:2}</td>
			<td>{$item.description|htmlentities}</td>
			<td>
				<button onclick="location.href = 'addcart.php?idProduct={$item.id|rawurlencode}'; return false;">Add To Cart</button>
			</td>
		</tr>
	{/CategoryProducts}
</table>

<html>
<head>
	<title>Products</title>
	...
</head>
<body>
	...
 
	<div id="products">
		{assign var="category" value="clothes"}
		{include file="category_products.tpl"}
	</div>
 
	...
</body>
</html>

 
// validate the posted data
$validated = filter_var($_POST['email_address'], FILTER_VALIDATE_EMAIL);
 
// print validate status message
if ( $validated === false )
	echo 'Sorry, but that email address is not in a valid format.';
else
	echo 'Thank you, that email address is in a valid format as '. $validated;

 
function ValidateEmail( $email_address )
{
	// validate the posted data
	$validated = filter_var($_POST['email_address'], FILTER_VALIDATE_EMAIL);
	if ( ($ret = (bool)$validated) )
	{
		// get the username and host
		list($user, $mailhost) = explode('@', $validated);
 
		// find mx records for host
		$mx = getmxrr($mailhost, $hosts);
 
		if ( empty($hosts) )
		{
			// try to get the A record
			foreach ( (array)dns_get_record($host, DNS_A) as $address )
				$hosts[] = $address['ip'];
		}
 
		if ( !empty($hosts) )
		{
			// if we have one or most host, loop through the array and try to connect to them
			foreach ( $hosts as $host )
			{
				// try to establish a connection to the host on port 25 with a 15 second timeout
				if ( false !== ($smtp = @fsockopen($host, 25, $errno, $errstr, 15)) )
				{
					// set a maximum wait time of 15 seconds for all responses from the server
					stream_set_timeout($smtp, 15);
 
					// get responses from the server after connecting
					$smtp_response = fgets($smtp);
 
					// send the HELO command and get the response
					fputs($smtp, "HELO hi\n");
					$smtp_response = fgets($smtp);
 
					// send MAIL FROM command and get the response
					fputs($smtp, "MAIL FROM: <somebody@example.com>\r\n");
					$smtp_response = fgets($smtp);
 
					// tell the server who this email is for - since this is the server the email account belongs to, it can verify if the user is valid
					// if the user is not valid, the server will respond with response codes 550, 551, or 553; see, http://www.ietf.org/rfc/rfc2821.txt
					fputs($smtp, "RCPT TO: <$user@$mailhost>\r\n");
					$smtp_response = fgets($smtp);
 
					// if we have an invalid response code, return false
					$ret = !in_array((int)$smtp_response, array(550,551,553));
 
					// tell the server we are don e
					fputs($smtp, "QUIT\r\n");
 
					// close the connection
					fclose($smtp);
 
					// break the loop as soon as we find 1 connectable host
					break;
				}
			}
		} else
			$ret = false;
	}
	return $ret?$validated:false;
}
 
$validated = ValidateEmail( $_POST['email_address'] );
 
if ( $validated === false )
	echo 'Sorry, but the email address you provided does not appear to be valid.';
else
	echo 'Yes, '. $validated .' appears to be a valid email address.';

<?php
 
// open mp3 and read it
if ( $f = fopen($mp3, 'rb') )
{
	// read mp3
	$data = '';
	while ( !feof($f) )
		$data .= fread($f, 8192);
 
	// close mp3 and remove it, we are done with it
	fclose($f);
	unlink($mp3);
 
	// send some http request headers
	header('content-type: audio/mpeg');
	header('content-length: '. strlen($data));
 
	// print the data, flush, and exit the script, we are done
	echo $data;
	flush();
	exit;
}

<?php
 
// if there is no data to parse, exit
if ( !isset($_REQUEST['txt']) || !is_scalar($_REQUEST['txt']) || strlen(trim($_REQUEST['txt'])) == 0 )
	exit;
 
// create some temporary files
$dir = sys_get_temp_dir();
$txt = tempnam($dir, 'TXT');
$wav = tempnam($dir, 'WAV');
$mp3 = tempnam($dir, 'MP3');
 
// put the content inside the txt file - strip_tags so HTML applications can use it
$txtdata = strip_tags($_REQUEST['txt']);
file_put_contents($txt, $txtdata);
 
// create the wav
exec('text2wave '. $txt .' -o '. $wav);
 
// create the mp3
exec('lame '. $wav .' '. $mp3);
 
// remove txt and wav, we are done with them
unlink($txt);
unlink($wav);
 
// open mp3 and read it
if ( $f = fopen($mp3, 'rb') )
{
	// read mp3
	$data = '';
	while ( !feof($f) )
		$data .= fread($f, 8192);
 
	// close mp3 and remove it, we are done with it
	fclose($f);
	unlink($mp3);
 
	// send some http request headers
	header('content-type: audio/mpeg');
	header('content-length: '. strlen($data));
 
	// print the data, flush, and exit the script, we are done
	echo $data;
	flush();
	exit;
}

<?php
 
 
class TTS
{
	public static $mp3;
 
	// convert
	public static function Convert( $txtdata )
	{
		if ( strlen(trim($txtdata)) == 0 )
			return false;
 
		// create some temporary files
		$dir = sys_get_temp_dir();
		$txt = tempnam($dir, 'TXT');
		$wav = tempnam($dir, 'WAV');
		$mp3 = tempnam($dir, 'MP3');
 
		// put the content inside the txt file - strip_tags so HTML applications can use it
		file_put_contents($txt, trim(strip_tags($txtdata)));
 
		// create the wav
		exec('text2wave '. $txt .' -o '. $wav);
 
		// create the mp3
		exec('lame '. $wav .' '. $mp3);
 
		// remove txt and wav, we are done with them
		unlink($txt);
		unlink($wav);
 
		// hold on to the mp3 location
		self::$mp3 = $mp3;
 
		return true;
	}
 
	// read
	public static function ReadBinary( $txt=null )
	{
		if ( !self::$mp3 )
		{
			if ( is_null($txt) )
			{
				trigger_error('TTS::GetBinary has no file to read binary data from.  Use TTS::GetBinary("the text to convert")', E_USER_ERROR);
				return null;
			}
			self::Convert($txt);
		}
		// open mp3 and read it
		if ( $f = fopen(self::$mp3, 'rb') )
		{
			// read mp3
			$data = '';
			while ( !feof($f) )
				$data .= fread($f, 8192);
 
			// close mp3 and remove it, we are done with it
			fclose($f);
 
			// clean up - if we created the mp3, remove it
			if ( !is_null($txt) )
				self::DeleteMP3();
 
			// return binary data
			return $data;
		}
		// could not open file - either no permissions or file dosn't exist
		trigger_error('Could not open file: '. self::$mp3, E_USER_ERROR);
		return null;
	}
 
	// stream
	public static function Stream( $txt=null )
	{
		if ( !self::$mp3 )
		{
			if ( is_null($txt) )
			{
				trigger_error('TTS::Stream has nothing to stream.  Use TTS::Stream("the text to stream")', E_USER_ERROR);
				return null;
			}
			self::Convert($txt);
		}
 
		// read binary data, flush and exit
		if ( $data = self::ReadBinary() )
		{
			if ( !is_null($txt) )
				self::DeleteMP3();
 
			// send some http request headers
			header('content-type: audio/mpeg');
			header('content-length: '. strlen($data));
 
			// flush data
			echo $data;
			flush();
			exit;
		} elseif ( !is_null($txt) )
			self::DeleteMP3();
	}
 
	// download
	public static function Download( $txt=null )
	{
		if ( !self::$mp3 )
		{
			if ( is_null($txt) )
			{
				trigger_error('TTS::Download has nothing to stream.  Use TTS::Download("the text to download")', E_USER_ERROR);
				return null;
			}
			self::Convert($txt);
		}
 
		// read binary data, flush and exit
		if ( $data = self::ReadBinary() )
		{
			if ( !is_null($txt) )
				self::DeleteMP3();
 
			// send some http request headers
			header('content-type: audio/mpeg');
			header('content-disposition: attachment; filename="PHPProfessional_TextToSpeech.mp3"');
			header('content-length: '. strlen($data));
 
			// flush data
			echo $data;
			flush();
			exit;
		} elseif ( !is_null($txt) )
			self::DeleteMP3();
	}
 
	// delete the mp3 file
	public static function DeleteMP3()
	{
		if ( !self::$mp3 )
			return;
 
		if ( file_exists(self::$mp3) )
			unlink( self::$mp3 );
 
		self::$mp3 = null;
	}
}

if ( is_null(self::$key) )
{
	$key = '';
	$file = PATH_TO_KEY_FILE .'.key';
	if ( file_exists($file) )
	{
		if ( $f = fopen($file, 'rb') )
		{
			while ( !feof($f) ) $key .= fread($f, 8192);
			fclose($f);
			self::$key = $key;
		} else
			die('Data Encryption Failed'); 
	} else
		self::GenerateKey();
}

if ( $f = fopen(PATH_TO_KEY_FILE .'.key', 'w') )
{
	$key = '';
	for ($i = 0; $i < 250; $i++) $key .= chr( rand(0, 255) );
	fwrite($f, $key);
	fclose($f);
	self::$key = $key;
} else
	die('Data Encryption Failed');