<?PHP
/*
Jotti's template engine version 4

JTPL is distributed under specific license,
see LICENSE for details.

If your copy of JTPL did not include a LICENSE
file, please visit:
http://jotti.org/openlibs/jtpl/LICENSE

Latest version is located at:
http://jotti.org/openlibs/jtpl

Some rudimentary documentation is available at:
http://jotti.org/openlibs/jtpl/USAGE

Copyright (C) 2002-2009 Jordi Bosveld <jotti@jotti.org>

This is free software. Go insane.
*/

// this will probably be added to PHP eventually, let's provide it
// ourselves while they don't
if (!function_exists("mb_ucfirst") && function_exists("mb_substr"))
{
	function mb_ucfirst($string)
	{
		$string = mb_strtoupper(mb_substr($string, 0, 1)).mb_substr($string, 1);
		
		return $string;
	}
}

class jtpl
{
	// debugging disabled by default
	public $debug = false;
	
	// where to read e.g. included template files from
	public $templateroot = "./";
	
	// Normally we emulate trigger_error to obtain the correct line numbers etc.,
	// but in projects where custom error handlers are used, this is a pain
	// so this feature can be disabled at runtime
	public $honor_errorhandler = false;
	
	// character set of the template
	public $charset = "UTF-8";
	
	// default variable escaper, empty by default (no escaping)
	public $defaultvarescape = "";
					
	// ignore preserves?
	public $ignorepreserves = false;
	
	// by default {file.tpl:INCLUDE} tokens cannot include files from an upper
	// directory (e.g. paths containing two consecutive dots "../")
	public $allowupperdirectoryincludes = false;
	
	// by default {file.tpl:INCLUDE} tokens cannot include files using an
	// absolute path (e.g. /etc/passwd)
	public $allowabsolutepathincludes = false;

	// main template
	private $_template = "";
	
	// current tree depth
	private $_depth = "/";
	
	// current iteration
	private $_currentiteration = 0;
	
	// storage for variables, case blocks, if blocks
	private $_vars = array();
	private $_ifblocks = array();
	private $_caseblocks = array();
	
	// cache for variable validation (only once per occasion)
	private $_vars_namecheckcache = array();
	
	// timer for performance tracking
	private $_timer = false;
	
	// template variable escapers
	private $_escapers = array("HTML" => "_escape_html",
								   "XML" => "_escape_xml",
								   "JS" => "_escape_js",
								   "NL2BR" => "_escape_nl2br",
								   "OOO" => "_escape_ooo",
								   "URL" => "_escape_url",
								   "TPL" => "_escape_tpl",
								   "UCASE" => "_escape_ucase",
								   "LCASE" => "_escape_lcase",
								   "UCFIRST" => "_escape_ucfirst",
								   "INT" => "_escape_int",
								   "MONEY" => "_escape_money",
								   "PERCENTAGE" => "_escape_percentage",
								   "NOESCAPE" => "_escape_void");
	
	// read a template from a file and use as root template
	// expects a template file name on the local filesystem
	public function readtemplate($file)
	{
		$this->_settemplateroot($file);
		
		$data = $this->_readfile($file);
		
		$this->_template = $data;
	}
	
	// read template data from string and use as root template
	public function assigntemplate($data)
	{
		$this->_template = $data;
	}
	
	// include a template as a variable
	// expects a template file name on the local filesystem
	public function includetemplate($file, $variable)
	{
		$data = $this->_readfile($file);
		
		$this->assignvar($variable, $data);
	}
	
	// read a file from disk into a string
	private function _readfile($file)
	{
		if (!is_file($file))
		{
			$this->_trigger_jtplerror("Unable to open ".$file." as a template: file not found", E_USER_ERROR);
		}
		
		if (!is_readable($file))
		{
			$this->_trigger_jtplerror("Unable to open ".$file." as a template: permission denied", E_USER_ERROR);
		}
		
		$data = file_get_contents($file);
		
		return $data;
	}

	// derive template path from assigned template file
	// used in dynamic includes to determine the right template directory, no matter
	// where the script itself is
	private function _settemplateroot($filename)
	{
		if (preg_match("/(.*\/).*?/", $filename, $matches))
		{
			$this->templateroot = $matches[1];
		} else
		{
			$this->templateroot = "./";
		}
	}
	
	// this function is used to display/handle errors
	// it will default to emulating trigger_error so correct line numbers
	// will be stated.
	private function _trigger_jtplerror($errormessage, $errortype = E_USER_WARNING)
	{
		// let's honour the local PHP configuration when we 'emulate'
		// trigger_error()
		$htmlerrors = ini_get("html_errors");
		if ($htmlerrors)
		{
			$boldprepend = "<b>";
			$boldappend = "</b>";
			$linebreak = "<br />\n";
		} else
		{
			$boldprepend = "";
			$boldappend = "";
			$linebreak = "\n";
		}
		
		switch ($errortype)
		{
			case E_USER_WARNING:
					$fatal = false;
					$messagetext = "Warning";
				break;
			case E_USER_ERROR:
					$fatal = true;
					$messagetext = "Fatal error";
				break;
			case E_USER_NOTICE:
					$fatal = false;
					$messagetext = "Notice";
				break;
			default:
					// we should never arrive here, but let's put it in anyway...
					$fatal = true;
					$messagetext = "Unknown error";
				break;
		}
		
		// get a backtrace
		$backtrace = debug_backtrace();
		// reverse the array so the first item becomes the last, which
		// holds the entry important to us
		$backtrace = array_reverse($backtrace);
		$actualerror = $backtrace[0];
		
		// these will not be too helpful when complaining about dynamic includes
		// or variable modifiers, but this way at least we're not blaming ourselves
		$file = $actualerror['file'];
		$linenumber = $actualerror['line'];
		
		if ($this->honor_errorhandler)
		{
			trigger_error($errormessage, $errortype);
		} else
		{
			echo $linebreak.$boldprepend.$messagetext.$boldappend.": ".$errormessage." in ".$boldprepend.$file.$boldappend." on line ".$boldprepend.$linenumber.$boldappend.$linebreak;
		}
		
		// if the error is fatal, we should consider our trek ended
		if ($fatal)
		{
			die;
		}
	}
	
	// this will parse the whole template on the fly
	private function _buildtree($processdata, $depth = "/", $scope = array())
	{
		$processeddata = "";
		$text = "";
		
		// iterate until there is nothing left
		while ($processdata != "")
		{
			$token = "";
			
			// find the first occurence of {
			$firstcurl = strpos($processdata, "{");
			
			if ($firstcurl > 0)
			{
				// first we have some text, then something
				// that may very well be a token
				$text .= substr($processdata, 0, $firstcurl);
				$processdata = substr($processdata, $firstcurl);
			} elseif ($firstcurl === false)
			{
				// only text left
				$text .= $processdata;
				$processdata = "";
			} else
			{
				if (preg_match("/^{([a-z0-9_\-\.:;\|&\/]+)}([\n\r]{0,2})/is", $processdata, $match))
				{
					// possible real token
					$token = $match[1];

					// let's not catch these last newline characters,
					// otherwise output will contain lots of them.
					$tmp = $match[2];
					
					// unless it is a variable, then we keep them intact (otherwise lines
					// ending with a variable suddenly glue to the next line)
					if (strpos($token, ":") === false)
					{
						$tmp = "";
					}
					
					$processdata = substr($processdata, strlen($token) + strlen($tmp) + 2);
				} elseif (preg_match("/^{!--.*?--}/s", $processdata, $match))
				{
					// template comment, ignore the whole thing
					$processdata = substr($processdata, strlen($match[0]));
				} else
				{
					// probably something else... treat as text
					$text .= substr($processdata, 0, 1);
					$processdata = substr($processdata, 1);
				}
			}
			
			// let's see what kind of token we have here
			$tokentype = $this->_get_tokentype($token);
			
			// handle tokens appropriately
			if ($tokentype['type'] == "REPEAT" && $tokentype['starter'])
			{
				// we have a repeater! please iterate...
				
				$this->enterblock($tokentype['name']);
				
				$olddepth = $depth;

				if ($depth == "/")
				{
					$depth = $tokentype['name'];
				} else
				{
					$depth = $depth.":".$tokentype['name'];
				}
				
				if (!isset($this->_iterations[$depth]))
				{
					if ($this->debug)
					{
						$this->_trigger_jtplerror("REPEAT block '".$tokentype['name']."' never iterates at level ".$olddepth, E_USER_NOTICE);
					}
					
					$iterations = 0;
				} else
				{
					$iterations = $this->_iterations[$depth];
				}
				
				// find out where this block ends
				if (!$tempdata = $this->_find_block_end($processdata, $tokentype['name'].":END"))
				{
					$this->_trigger_jtplerror("Encountered REPEAT block '".$tokentype['name']."' START token without accompanying END", E_USER_ERROR);
				}
				
				// we have to treat this repeat block as a 'separate' template in this subroutine
				$processdata = $tempdata['processdata'];
				$blockdata = $tempdata['blockdata'];
				
				for ($i = 1; $i <= $iterations; $i++)
				{
					// we need a different variable/if/case/etc. scope to parse this part
					// of the document. we pass on our current scope too, as 'parent'
					// variables etc., when not set in the repeat block itself, should be
					// inherited.
					$tempscope = $this->_createscope($depth."|".$i, $scope);
					$text .= $this->_buildtree($blockdata, $depth."|".$i, $tempscope);
				}
				
				$this->leaveblock();
				
				$depth = $olddepth;
			} elseif ($tokentype['type'] == "IF" && $tokentype['starter'])
			{
				// IF block found
				$blockname = $tokentype['name'];
				
				if (!$tempdata = $this->_find_block_end($processdata, $blockname.":ENDIF"))
				{
					$this->_trigger_jtplerror("Encountered IF block '".$blockname."' IF token without accompanying ENDIF", E_USER_ERROR);
				}
				
				$processdata = $tempdata['processdata'];
				$ifdata = $this->_split_ifblock($tempdata['blockdata'], $blockname);
				
				// do we have AND/OR inside the IF block?
				if (strpos($blockname, "|") > 0 || strpos($blockname, "&") > 0)
				{
					// grab IF block names and & | AND/OR separators
					$matches = preg_split("/(&|\|)/", $blockname, -1, PREG_SPLIT_DELIM_CAPTURE);
					
					$operator = "";
					
					$parttrue = false;
					
					foreach ($matches as $match)
					{
						if ($match == "|" || $match == "&")
						{
							$operator = $match;
						} else
						{
							$previousparttrue = $parttrue;
							
							// is this part supposed to be true?
							if (isset($scope['ifblocks'][$match]))
							{
								$parttrue = $scope['ifblocks'][$match];
							} else
							{
								if ($this->debug)
								{
									$this->_trigger_jtplerror("IF block portion '".$match."' of IF block '".$blockname."' not set, reverting to FALSE", E_USER_NOTICE);
								}
								
								$parttrue = false;
							}
							
							if (($previousparttrue || $parttrue) && $operator == "|")
							{
								// we've found an OR that is true, no need
								// to continue
								$iftrue = true;
								break;
							} elseif (!$parttrue && $operator == "&")
							{
								// we've found an AND that is false,
								// no need to continue
								$iftrue = false;
								break;
							}
						}
						
						if ($operator == "&")
						{
							// if we survived our last AND operator without stumbling
							// upon something false, it must be true
							$iftrue = true;
						} else
						{
							// if we survived our last OR operator without stumbling
							// upon something true, it must be false
							$iftrue = false;
						}
					}
				} elseif (isset($scope['ifblocks'][$blockname]))
				{
					$iftrue = $scope['ifblocks'][$blockname];
				} else
				{
					if ($this->debug)
					{
						$this->_trigger_jtplerror("IF block '".$blockname."' not set, reverting to FALSE", E_USER_NOTICE);
					}
					
					$iftrue = false;
				}
				
				if ($iftrue)
				{
					$blockdata = $ifdata['if'];
				} else
				{
					$blockdata = $ifdata['else'];
				}
				
				$text .= $this->_buildtree($blockdata, $depth, $scope);
				
			} elseif ($tokentype['type'] == "PRESERVE" && $tokentype['starter'])
			{
				// PRESERVE block found, don't parse anything inside it

				if (!$tempdata = $this->_find_block_end($processdata, "PRESERVE-END"))
				{
					$this->_trigger_jtplerror("Encountered PRESERVE-START token without accompanying PRESERVE-END", E_USER_ERROR);
				}
				
				if ($this->ignorepreserves)
				{
					$processdata = $tempdata['blockdata'].$tempdata['processdata'];
				} else
				{
					$processdata = $tempdata['processdata'];
					$text .= $tempdata['blockdata'];
				}
			} elseif ($tokentype['type'] == "CASE" && $tokentype['starter'])
			{
				// CASE block found
				
				$blockname = $tokentype['name'];
				
				// see where this block ends
				if (!$tempdata = $this->_find_block_end($processdata, $blockname.":CASE-END"))
				{
					$this->_trigger_jtplerror("Encountered CASE token without accompanying CASE-END", E_USER_ERROR);
				}
				
				$processdata = $tempdata['processdata'];
				$casedata = $this->_split_caseblock("{".$blockname.":".$tokentype['params'].":CASE}".$tempdata['blockdata'], $blockname);
				
				if (isset($scope['caseblocks'][$blockname]))
				{
					$case = $scope['caseblocks'][$blockname];
				} else
				{
					if ($this->debug)
					{
						$this->_trigger_jtplerror("CASE block '".$blockname."' not set, reverting to DEFAULT", E_USER_NOTICE);
					}
					$case = "DEFAULT";
				}
				
				if (!isset($casedata[$case]))
				{
					if (!isset($casedata['DEFAULT']))
					{
						if ($this->debug)
						{
							$this->_trigger_jtplerror("CASE block '".$blockname."' has no CASE called '".$case."', leaving empty (no DEFAULT to fall back to)", E_USER_NOTICE);
						}
							
						$blockdata = "";
					} else
					{
						if ($this->debug)
						{
							$this->_trigger_jtplerror("CASE block '".$blockname."' has no CASE called '".$case."', reverting to DEFAULT", E_USER_NOTICE);
						}
						
						$blockdata = $casedata['DEFAULT'];
					}
				} else
				{
					$blockdata = $casedata[$case];
				}
				
				$text .= $this->_buildtree($blockdata, $depth, $scope);
			} elseif ($tokentype['type'] == "INCLUDE")
			{
				// this is an INCLUDE token, let's include the file specified
				// if it is allowed (presumably safe) to do so
				if (!$this->allowupperdirectoryincludes && strpos($tokentype['name'], "..") !== false)
				{
					$this->_trigger_jtplerror("Dynamically including ".$tokentype['name']." not allowed (parent directory restriction in effect)", E_USER_ERROR);
				}
				
				if (!$this->allowabsolutepathincludes && $tokentype['name'][0] == "/")
				{
					$this->_trigger_jtplerror("Dynamically including ".$tokentype['name']." not allowed (absolute path restriction in effect)", E_USER_ERROR);
				}
				
				// is the include file included using an absolute path?
				if ($tokentype['name'][0] == "/")
				{
					// yes, don't use current template dir when including
					$blockdata = $this->_readfile($tokentype['name']);
				} else
				{
					// no, relative... let's use the current template dir as a base path
					$blockdata = $this->_readfile($this->templateroot.$tokentype['name']);
				}
				
				if ($tokentype['params'] != "")
				{
					$processdata = $this->modify_content($blockdata, $tokentype['params']).$processdata;
				} else
				{
					$processdata = $blockdata.$processdata;
				}
			} elseif ($tokentype['type'] == "ESCAPE" && $tokentype['starter'])
			{
				// ESCAPE block found, escape using the correct escaper(s)
				
				if (!$tempdata = $this->_find_block_end($processdata, $tokentype['params'].":ESCAPE-END"))
				{
					$this->_trigger_jtplerror("Encountered ESCAPE-START token without accompanying ESCAPE-END", E_USER_ERROR);
				}
				
				$processdata = $this->modify_content($tempdata['blockdata'], $tokentype['params']).$tempdata['processdata'];
			} elseif ($tokentype['ender'])
			{
				// we're never supposed to find these...
				switch ($tokentype['type'])
				{
					case "REPEAT":
							$this->_trigger_jtplerror("Encountered REPEAT block '".$tokentype['name']."' closing token without accompanying '{".$tokentype['name'].":START}'", E_USER_ERROR);
						break;
					case "IF":
							$this->_trigger_jtplerror("Encountered IF block '".$tokentype['name']."' closing token without accompanying '{".$tokentype['name'].":IF}", E_USER_ERROR);
						break;
					case "CASE":
							$this->_trigger_jtplerror("Encountered CASE block '".$tokentype['name']."' closing token without accompanying '{".$tokentype['name'].":...:CASE}'", E_USER_ERROR);
						break;
					case "PRESERVE":
							$this->_trigger_jtplerror("Encountered PRESERVE block closing token without accompanying '{PRESERVE-START}'", E_USER_ERROR);
						break;
					case "ESCAPE":
							$this->_trigger_jtplerror("Encountered ESCAPE block closing token without accompanying {...;ESCAPE-END}", E_USER_ERROR);
						break;
				}
				$this->_trigger_jtplerror("Encountered ".$tokentype['type']." block '".$tokentype['name']."' closing token without accompanying starting token", E_USER_ERROR);
			}
			
			// variables are a special case... we don't delegate these to ourselves since
			// variables aren't "blocks".
			if ($tokentype['type'] == "VARIABLE")
			{
				$var = $tokentype['name'];
				
				if (isset($scope['vars'][$var]))
				{
					// if no modifiers are present in template, use the default one,
					// if set
					if ($this->defaultvarescape != "" && $tokentype['params'] == "")
					{
						$tokentype['params'] = $this->defaultvarescape;
					}
					
					if ($tokentype['params'] != "")
					{
						$processdata = $this->modify_content($scope['vars'][$var], $tokentype['params']).$processdata;
					} else
					{
						$processdata = $scope['vars'][$var].$processdata;
					}
				} else
				{
					if ($this->debug)
					{
						$this->_trigger_jtplerror("VARIABLE '".$var."' not set", E_USER_NOTICE);
					}
				}
			}
		}
		
		return $text;
	}
	
	private function _get_tokentype($token)
	{
		$tokentype = array("name" => "",
						   "type" => "",
						   "starter" => false,
						   "ender" => false,
						   "params" => "");
						   
		// what kind of token do we have...
		if ($token == "")
		{
			// not a token at all
		} elseif ($token == "PRESERVE-START")
		{
			// PRESERVE start token
			$tokentype['type'] = "PRESERVE";
			$tokentype['starter'] = true;
		} elseif ($token == "PRESERVE-END")
		{
			// PRESERVE end token (shouldn't find these, but oh well...)
			$tokentype['type'] = "PRESERVE";
			$tokentype['ender'] = true;
		} elseif (strpos($token, ":") === false)
		{
			// a plain old variable... 9 out of 10 tokens are plain old variables, match first
			$tokentype['type'] = "VARIABLE";
			$tokentype['name'] = $token;
			
			// are there any modifiers?
			if (strpos($token, ";") !== false)
			{
				// apparently...
				// check which modifiers are there...
				$matches = explode(";", $token, 2);
				
				$tokentype['name'] = $matches[0];
				
				if (isset($matches[1]))
				{
					$tokentype['params'] = $matches[1];
				}
			}
		} else
		{
			// alright... some more difficult tag
			
			preg_match("/^(.*):(.*?)$/", $token, $matches);
			
			$data = $matches[1];
			$type = $matches[2];
			
			if ($type == "START")
			{
				$tokentype['type'] = "REPEAT";
				$tokentype['starter'] = true;
				$tokentype['name'] = $data;
			} elseif ($type == "END")
			{
				$tokentype['type'] = "REPEAT";
				$tokentype['ender'] = true;
				$tokentype['name'] = $data;
			} elseif ($type == "IF")
			{
				$tokentype['type'] = "IF";
				$tokentype['starter'] = true;
				$tokentype['name'] = $data;
			} elseif ($type == "ENDIF")
			{
				$tokentype['type'] = "IF";
				$tokentype['ender'] = true;
				$tokentype['name'] = $data;
			} elseif ($type == "CASE")
			{
				// we need to find the CASE name and options...
				if (!preg_match("/^(.*?):(.*)$/", $data, $match))
				{
					$this->_trigger_jtplerror("Malformed CASE token: {".$matches[0]."}", E_USER_ERROR);
				}
				
				$tokentype['type'] = "CASE";
				$tokentype['starter'] = true;
				$tokentype['name'] = $match[1];
				$tokentype['params'] = $match[2];
			} elseif ($type == "CASE-END")
			{
				$tokentype['type'] = "CASE";
				$tokentype['ender'] = true;
				$tokentype['name'] = $data;
			} elseif ($type == "ESCAPE-START")
			{
				$tokentype['type'] = "ESCAPE";
				$tokentype['starter'] = true;
				$tokentype['params'] = $data;
			} elseif ($type == "ESCAPE-END")
			{
				$tokentype['type'] = "ESCAPE";
				$tokentype['ender'] = true;
				$tokentype['params'] = $data;
			} elseif (substr($type, 0, 7) == "INCLUDE")
			{
				$tokentype['type'] = "INCLUDE";
				$tokentype['name'] = $data;
				
				// see if we have any escapers for this dynamic INCLUDE
				if (strlen($type) > 7 && preg_match("/^INCLUDE;([\w;]+)$/", $type, $matches))
				{
					$tokentype['params'] = $matches[1];
				}
			} else
			{
				$didyoumean = "";
				// something else after the colon... may be a misspelling
				if (isset($this->_escapers[$type]))
				{
					$didyoumean = " (did you mean {".$data.";".$type."} ?)";
				}
				$this->_trigger_jtplerror("Unknown token type: {".$data.":".$type."}".$didyoumean, E_USER_ERROR);
			}
		}
		
		return $tokentype;
	}
	
	// this function will search for the end of some block
	private function _find_block_end($processdata, $blockend)
	{
		if (!preg_match("/(.*?){".preg_quote($blockend, "/")."}(.*)$/s", $processdata, $matches))
		{
			return false;
		}
		
		$data = array("processdata" => $matches[2],
					  "blockdata" => $matches[1]);
		
		return $data;
	}
	
	// determine the IF and ELSE (if any) portions of the IF block
	private function _split_ifblock($blockdata, $blockname)
	{
		if (!preg_match("/^(.*?){".preg_quote($blockname, "/").":ELSE}(.*?)$/s", $blockdata, $matches))
		{
			// there is no ELSE...
			$if = $blockdata;
			$else = "";
		} else
		{
			$if = $matches[1];
			$else = $matches[2];
		}
		
		$ifdata = array("if" => $if,
						"else" => $else);
		
		return $ifdata;
	}
	
	// determine the specific cases for this CASE block
	private function _split_caseblock($blockdata, $blockname)
	{
		$blockname_preg = preg_quote($blockname, "/");
		
		preg_match_all("/{".$blockname_preg.":(.*?):CASE}(.*?)(?={".$blockname_preg.":|$)/s", $blockdata, $matches);
		
		$cases = array();
		
		foreach ($matches[1] as $key => $value)
		{
			$casedata = explode(":", $value);
			
			foreach ($casedata as $casetarget)
			{
				$cases[$casetarget] = $matches[2][$key];
			}
		}
		
		return $cases;
	}
	
	// will modify content based on used escapers
	public function modify_content($content, $modifiers)
	{
		$modifiers = preg_split("/;/", $modifiers);
		
		foreach ($modifiers as $modifier)
		{
			if (!isset($this->_escapers[$modifier]))
			{
				$this->_trigger_jtplerror("Unsupported variable modifier '".$modifier."' detected in template", E_USER_WARNING);
				continue;
			}
			
			$function = $this->_escapers[$modifier];
			
			if (method_exists($this, $function))
			{
				$content = $this->$function($content);
			} elseif (function_exists($function))
			{
				$content = $function($content);
			} else
			{
				$this->_trigger_jtplerror("Unknown function '".$function."' for escaper '".$modifier."' ", E_USER_ERROR);
			}
		}
		
		return $content;
	}
	
	// this way you can add custom template escapers
	public function add_custom_escaper($escapetag, $function)
	{
		$this->_escapers[$escapetag] = $function;
	}
	
	private function _escape_html($content)
	{
		return htmlentities($content, ENT_QUOTES, $this->charset);
	}
	
	private function _escape_js($content)
	{
		$content = preg_replace("/('|\"|\\\)/s", "\\\\$1", $content);
		$content = preg_replace("/(\r\n|\r|\n)/s", "\\n", $content);
		
		return $content;
	}
	
	private function _escape_nl2br($content)
	{
		return nl2br($content);
	}
	
	private function _escape_xml($content)
	{
		static $trans;

		$content = str_replace("&", "&#38;" , $content);

		if(!isset($trans))
		{
			$trans = get_html_translation_table(HTML_ENTITIES, ENT_QUOTES);
			
			foreach($trans as $key => $value)
			{
				$ord = ord($key);
				$trans[$key] = "&#".$ord.";";
			}
			
			// dont translate the '&' in case it is part of &xxx;
			$trans[chr(38)] = '&';
		}

		return strtr($content, $trans);
	}

	// "escapes" a string to OpenOffice.org encoding
	private function _escape_ooo($string)
	{
		return iconv("WINDOWS-1252", "UTF-8", $this->_escape_xml($string));
	}
	
	private function _escape_url($content)
	{
		return rawurlencode($content);
	}

	function _escape_percentage($content)
	{
		return sprintf("%.2f%%", $content * 100);
	}
	
	private function _escape_tpl($content)
	{
		$content = str_replace("{", "&#0123;", $content);
		$content = str_replace("}", "&#0125;", $content);
		
		return $content;
	}
	
	private function _escape_ucase($content)
	{
		if (function_exists("mb_strtoupper"))
		{
			return mb_strtoupper($content);
		} else
		{
			return strtoupper($content);
		}
	}
	
	private function _escape_lcase($content)
	{
		if (function_exists("mb_strtolower"))
		{
			return mb_strtolower($content);
		} else
		{
			return strtolower($content);
		}
	}
	
	private function _escape_ucfirst($content)
	{
		if (function_exists("mb_ucfirst"))
		{
			return mb_ucfirst($content);
		} else
		{
			return ucfirst($content);
		}
	}
	
	private function _escape_int($content)
	{
		return intval($content);
	}
	
	private function _escape_money($content)
	{
		return sprintf("%.2f", $content);
	}
	
	private function _escape_void($content)
	{
		return $content;
	}
	
	// assign a variable for use in a template (block)
	public function assignvar($var, $content)
	{
		$depth = $this->_depth;
		$iteration = $this->_currentiteration;
		
 		// iteration cannot be 0 when assigning variables
		if ($iteration == 0 && $depth != "/")
		{
			$this->_trigger_jtplerror("Called assignvar() without prior startiteration()", E_USER_ERROR);
		}
		
		// no funky variable names please
		if (!isset($this->_vars_namecheckcache[$var]))
		{
			if (!preg_match("/^[a-z0-9_\.\-]+$/i", $var))
			{
				$this->_trigger_jtplerror("' ".$var."' is not a valid variable name", E_USER_WARNING);
			} else
			{
				// only validate a variable name once
				$this->_vars_namecheckcache[$var] = true;
			}
		}
		
		$this->_vars[$depth][$var] = $content;
	}
	
	// function to assign an entire array as vars (key => value)
	// by default array keys (vars) are capitalised
	public function assignvarsfromarray($vars, $touppercase = true)
	{
		if (is_array($vars))
		{
			foreach ($vars as $var => $val)
			{
				if ($touppercase)
				{
					$var = strtoupper($var);
				}
				
				$this->assignvar($var, $val);
			}
		} else
		{
			$this->_trigger_jtplerror("First argument supplied to assignvarsfromarray() is not an array", E_USER_WARNING);
		}
	}
	
	// assign an if block to the current iteration depth
	public function ifblock($blockname, $condition)
	{
		$depth = $this->_depth;
		$iteration = $this->_currentiteration;
		if ($iteration == 0 && $depth != "/")
		{
			$this->_trigger_jtplerror("Called ifblock() without prior startiteration()", E_USER_ERROR);
		}
		
		if (isset($this->_ifblocks[$depth]) && is_array($this->_ifblocks[$depth])&& array_key_exists($blockname, $this->_ifblocks[$depth]) && $this->debug)
		{
			$this->_trigger_jtplerror("IF block '".$blockname."' already declared", E_USER_WARNING);
		}
		
		$this->_ifblocks[$depth][strtoupper($blockname)] = $condition;
	}
	
	// assign a case block to the current iteration depth
	public function caseblock($blockname, $condition)
	{
		$depth = $this->_depth;
		$iteration = $this->_currentiteration;
		if ($iteration == 0 && $depth != "/")
		{
			$this->_trigger_jtplerror("Called caseblock() without prior startiteration()", E_USER_ERROR);
		}
		
		if (isset($this->_caseblocks[$depth]) && is_array($this->_caseblocks[$depth]) && array_key_exists($blockname, $this->_caseblocks[$depth]) && $this->debug)
		{
			$this->_trigger_jtplerror("CASE block '".$blockname."' already declared", E_USER_WARNING);
		}
		
		$this->_caseblocks[$depth][$blockname] = $condition;
	}
	
	// enter a template block "level"
	public function enterblock($depth)
	{
		$currentdepth = $this->_depth;
		
		if ($currentdepth == "/")
		{
			if (isset($this->_iterations[$depth]))
			{
				$newdepth = $depth."|".intval($this->_iterations[$depth]);
			} else
			{
				$newdepth = $depth."|0";
			}
		} else
		{
			if (isset($this->_iterations[$currentdepth.":".$depth]))
			{
				$newdepth = $currentdepth.":".$depth."|".intval($this->_iterations[$currentdepth.":".$depth]);
			} else
			{
				$newdepth = $currentdepth.":".$depth."|0";
			}
		}
		
		$this->_depth = $newdepth;
		$this->_currentiteration = $this->_getcurrentiteration();
		
		return true;
	}
	
	// leave a block "level"
	public function leaveblock()
	{
		$currentdepth = $this->_depth;
		
		// we cannot go higher than the root level!
		if ($currentdepth == "/")
		{
			$this->_trigger_jtplerror("leaveblock(): already at root level", E_USER_ERROR);
		}
		
		$newdepth = preg_replace("/^(.*):.*?$/", "$1", $currentdepth);
		
		// the only time this regex will not replace anything, is when
		// we're about to ascend to the root level
		if ($newdepth == $currentdepth)
		{
			$newdepth = "/";
		}
		
		$this->_depth = $newdepth;
		$this->_currentiteration = $this->_getcurrentiteration();
	}
	
	// go back to root template (escape all repeat blocks)
	public function torootblock()
	{
		$this->_depth = "/";
		$this->_currentiteration = $this->_getcurrentiteration();
	}
	
	// start an iteration for a repeat block
	public function startiteration()
	{
		$depth = $this->_depth;
		
		// iterations on the root template do not make sense...
		if ($depth == "/")
		{
			$this->_trigger_jtplerror("Attempted to start an iteration for the root template", E_USER_ERROR);
		}
		
		$currentdepth = $this->_getcurrentdepth();
		if (!isset($this->_iterations[$currentdepth]))
		{
			$this->_iterations[$currentdepth] = 0;
		}
		
		$this->_iterations[$currentdepth]++;
		$this->_increasedepthiteration();
		$this->_currentiteration++;		
	}
	
	private function _getcurrentiteration()
	{
		return $this->_getiteration($this->_depth);
	}
	
	private function _getiteration($depth)
	{
		if (preg_match("/^.*\|(\d+)$/", $depth, $matches))
		{
			return $matches[1];
		} else
		{
			return 0;
		}
		
	}
	
	private function _getcurrentdepth()
	{
		return $this->_getdepth($this->_depth);
	}
	
	private function _getdepth($depth)
	{
		if (preg_match("/^(.*)\|\d+$/", $depth, $matches))
		{
			return $matches[1];
		} else
		{
			return "/";
		}
	}
	
	private function _increasedepthiteration()
	{
		$depth = $this->_getcurrentdepth();
		
		if ($depth == "/")
		{
			return false;
		}
		
		$iteration = $this->_currentiteration;
		$iteration++;
		
		$newdepth = $depth."|".$iteration;
		
		$this->_depth = $newdepth;
	}
	
	// create a var/if/case scope for parsing content
	private function _createscope($depth, $parentscope = false)
	{
		if (!$parentscope)
		{
			$parentscope = array("vars" => array(),
								 "ifblocks" => array(),
								 "caseblocks" => array());
		}
		
		if (isset($this->_vars[$depth]))
		{
			$vars = array_merge($parentscope['vars'], $this->_vars[$depth]);
		} else
		{
			$vars = $parentscope['vars'];
		}
		
		if (isset($this->_ifblocks[$depth]))
		{
			$ifblocks = array_merge($parentscope['ifblocks'], $this->_ifblocks[$depth]);
		} else
		{
			$ifblocks = $parentscope['ifblocks'];
		}
		
		if (isset($this->_caseblocks[$depth]))
		{
			$caseblocks = array_merge($parentscope['caseblocks'], $this->_caseblocks[$depth]);
		} else
		{
			$caseblocks = $parentscope['caseblocks'];
		}
		
		$scope = array("vars" => $vars,
					   "ifblocks" => $ifblocks,
					   "caseblocks" => $caseblocks);
					   
		return $scope;
	}

	// simple function to get current time
	private function _gettime()
	{
		return microtime(1);
	}
	
	// this will render the template
	private function _process()
	{
		$timer = $this->_gettime();
		
		// reset template iterator before processing
		$this->_depth = "";
		
		$data = $this->_template;
		
		// we need a variable/if/case/etc. scope to parse the document
		$scope = $this->_createscope("/");
		
		$document = $this->_buildtree($data, "/", $scope);
		
		$timer = $this->_gettime() - $timer;
		
		$this->_timer = $timer;
		
		return $document;
	}

	// return the time taken to parse the document (returns false is no
	// processing has been done yet)
	public function getparsetime()
	{
		return $this->_timer;
	}
	
	// return the generated document
	public function getdocument()
	{
		$document = $this->_process($this->_template);
		
		return $document;
	}
	
	// display the generated document
	public function display()
	{
		$document = $this->_process($this->_template);
		
		echo $document;
	}
}

?>