<?

/*
 Class FastTemplate w/ caching extensions
 
 PHP extension for managing templates and performing variable interpolation with cached results. 
 
 This program is free software; you can redistribute it and/or modify it under 
 the GNU Library General Public License, with the following stipulations; 
 
 Changes or modifications must retain these Copyright statements. 
 Changes or modifications must be submitted to both AUTHORS. 
 
 This program is released under the GNU Library General Public License. 
 ( http://www.gnu.org/copyleft/lgpl.html )
 
 This program is distributed in the hope that it will be useful, 
 but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE. See the Artistic License for more details. 
 This software is distributed AS-IS. 
 
 Some caching functions by Benjamin Kahn <xkahn@cybersites.com>
 http://www.zoned.net/~xkahn/php/fasttemplate
 Portions written by Benjamin Kahn Copyright (c) 2000 CyberSites, Inc; xkahn@cybersites.com, All Rights Reserved
 
 originally by: "JP" <jprins@dds.nl>
 http://www.phpbuilder.com/columns/jprins20000201.php3 
 
 with code by: Spencer D. Mindlin <smindlin@beaconeast.com>
 http://www.phpbuilder.com/columns/spencer20000208.php3
 
 PHP3 port by CDI cdi@thewebmasters.net 
 PHP3 Version Copyright (c) 1999 CDI, cdi@thewebmasters.net, All Rights Reserved. 
 Perl Version Copyright (c) 1998 Jason Moore jmoore@sober.com. All Rights Reserved. 
 Original Perl module CGI::FastTemplate by Jason Moore jmoore@sober.com 
 
*/

class FastTemplate {

  var $FILELIST	        =	array();	//	Holds the array of filehandles
                                                //	FILELIST[HANDLE] == "fileName"

  var $DYNAMIC	        =	array();	//	Holds the array of dynamic
                                                //	blocks, and the fileHandles they
		          			//	live in.

  var $PARSEVARS	=	array();	//	Holds the array of Variable
						//	handles.
						//	PARSEVARS[HANDLE] == "value"

  var $LOADED		=	array();	//	We only want to load a template
						//	once - when it's used.
						//	LOADED[FILEHANDLE] == 1 if loaded
						//	undefined if not loaded yet.

  var $HANDLE		=	array();	//	Holds the handle names assigned
						//	by a call to parse()

  var $ROOT		=	"";		//	Holds path-to-templates

  var $WIN32		=	false;		//	Set to true if this is a WIN32 server

  var $ERROR		=	"";		//	Holds the last error message

  var $LAST		=	"";		//	Holds the HANDLE to the last
						//	template parsed by parse()

  var $STRICT		=	true;		//	Strict template checking.
						//	Unresolved vars in templates will
						//	generate a warning when found.

//	************************************************************

 function FastTemplate ($pathToTemplates = "") {
 global $php_errormsg;
 
 if(!empty($pathToTemplates)) {
 $this->set_root($pathToTemplates);
 }
 
 }	// end (new) FastTemplate ()
 

 // New call: cache_expire (HANDLE, number of seconds); which allows you to cache a template
 // New call: cache_refresh (HANDLE, how often); which allows you to cache a template
 // New call: is_cached(RETURN, FileHandle); true if a valid cache file is available
 // New call: write_cache(HANDLE, FileHandle); call when a handle is done.

 // *********************
 // Function: is_cached
 // Input: RETURN, FileHandle (FIXME: Plural FileHandles are not supported.)
 // Return: true or false depending on whether a cache file is available. 
 // Side Effects: assigns variables as if a parse call had been made
 // 
 // Notes: 
 // Find the cache name, and see if the file exists
 // If it doesn't, return FALSE
 // If it does, check is the file is current (see ~/src/php-cache.php)
 // If is isn't, return FALSE
 // check if the section is dynamic. If so, use clear_dynamic to insert contents of file
 // If not, assign file contents to ReturnVar
 // return TRUE
 function is_cached ( $ReturnVar, $FileTags ) {

 // Fixme: We should do something smart if $FileTags is an array
 
 $str_cache_file = $this->cache_file_name( $ReturnVar, $FileTags );

 // This function will wait until a cache has been created. (Lock file cleared.)
 clearstatcache($str_cache_file); 
 // Here we perform some error correction. If a lock file 
 // is left over from a previous request, this ensures that 
 // it is deleted. 
 // FIXME: If this takes too long, we should turn caching off for this file, and return FALSE;
 while (file_exists($str_cache_file . '.lock')) { 
 sleep(2); 
 clearstatcache(); 
 continue; 
 }
 clearstatcache(); 
 
 // If the cache file doesn't exist, it isn't cached. QED.
 if (!file_exists($str_cache_file)) {
 return FALSE;
 }

 // Now we need to find out if we are caching.
 $refresh = $this->CACHE[$FileTags]["refresh"];
 $expires = $this->CACHE[$FileTags]["expire"];
 $cache_read = 0; // Default to no read
 if (!refresh && !expires) // Do we have any set time?
 $expires = 600;

    if (isset ($expires)) {
      if ((filectime ($str_cache_file) + $expires) > date (  "U")) {
	$cache_read = 1;
      }
    }

    if (isset ($refresh)) {
      switch (strtoupper($refresh)) { 
      case  'MINUTE': 
	if (checkRefreshMinute(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'QUARTERHOUR': 
	if (checkRefreshQuarterHour(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'HALFHOUR': 
	if (checkRefreshHalfHour(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'HOUR': 
	if (checkRefreshHour(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'HALFDAY': 
	if (checkExpiredHalfDay(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'DAY': 
	if (checkRefreshDay(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
	break; 
      case  'MONTH': 
	if (checkRefreshMonth(mktime(), filemtime($str_cache_file))) { 
	  $cache_read = 1;
	} 
 }
 }
 
 if ($cache_read == 1) {

 // We have a cache file and we should read from it!
 if ($f = fopen ($str_cache_file, "r")) { 
	$buf = "";
	while ($str = fgets ($f, 4096)) { 
	 $buf .= $str; 
	} 
	fclose ($f);
	
	$this->LAST = $ReturnVar;

	// This is the part that actually does all the work.
	// The template and the parsed version are the same when caching
	$this->assign( array( $ReturnVar => $buf ) );
	$this->$ReturnVar = $buf;
	$this->$FileTags = $buf; 
	$this->LOADED[$FileTags] = "1"; // Make sure the template doesn't get loaded.
	
	// If we were supposed to be appending, maybe we should assume a dynamic block
	if ( (substr ($FileTags, 0, 1)) == '.' ) {
	 $this->add_cache_dynamic ($ReturnVar, $buf);
	}
	
	return TRUE;
 }
 }
 
 
 return FALSE;
 }
 
 // *********************
 // Function: write_cache
 // Input: RETURN, FileHandle (FIXME: Plural FileHandles are not supported.)
 // Return: true or false depending on whether a cache file could be created
 // Side Effects: None
 // 
 // Notes: 
 // Find the cache name.
 // Write out the ReturnVar contents to the file
 // Return
 function write_cache ( $ReturnVar, $FileTags ) {

 // FIXME: I should do something clever if $FileTags is an array. 

 $str_cache_file = $this->cache_file_name ( $ReturnVar, $FileTags );

 $new = $this->parse_template_messy ($this->$FileTags, $this->PARSEVARS);
 
 // Time to write the cache -- but we need to look out for lock files
 // FIXME: I'm SURE there is a race condition here.
 while (file_exists($str_cache_file . '.lock')) { 
 sleep(2); 
 clearstatcache(); 
 continue; 
 }
 clearstatcache(); 

 // We pray that nothing bad happens after this point.
 touch ($str_cache_file . '.lock');
 
 $f = fopen ($str_cache_file, "w");
 if (!$f)
 return FALSE;

 fputs ($f, $new);
 fclose ($f);

 // And remove the lock file.
 $this->remove_cache_lock ($str_cache_file); 

 return TRUE;

 }

 // *********************
 // Function: cache_expire
 // Input: RETURN, number_of_seconds
 // Return: None
 // Side Effects: Stores time to expire
 // 
 // Notes: 
 // tells in how many seconds the cached data will expire

 function cache_expire ( $ReturnVar, $seconds = 3000) {
 $this->CACHE[$ReturnVar]["expire"] = $seconds;
 }

 // *********************
 // Function: cache_refresh
 // Input: RETURN, frequency
 // Return: None
 // Side Effects: Stores time to refresh
 // 
 // Notes: 
 // sets an event (turn of day) at which cache will expire
 function cache_refresh ( $ReturnVar, $freq = 'HOUR') {
 $this->CACHE[$ReturnVar]["refresh"] = $freq;
 }

 //	************************************************************
 //	All templates will be loaded from this "root" directory
 //	Can be changed in mid-process by re-calling with a new
 //	value.
 
 function set_root ($root) {
   
 $trailer = substr($root,-1);
 
 if(!$this->WIN32) {
 
 if( (ord($trailer)) != 47 ) {
	$root = "$root". chr(47);
      }
      
      if(is_dir($root)) {
	$this->ROOT = $root;
      } else {
	$this->ROOT = "";
	$this->error("Specified ROOT dir [$root] is not a directory");
      }
    } else {
      // WIN32 box - no testing
      if( (ord($trailer)) != 92 ) {
	$root = "$root" . chr(92);
      }
      $this->ROOT = $root;
    }
    
  }	// End set_root()
  

  //  **************************************************************
  //  Calculates current microtime
  //	I throw this into all my classes for benchmarking purposes
  //	It's not used by anything in this class and can be removed
  //	if you don't need it.
  

  function utime () {
    $time = explode( " ", microtime());
    $usec = (double)$time[0];
    $sec = (double)$time[1];
    return $sec + $usec;
  }
  
  //  **************************************************************
  //	Strict template checking, if true sends warnings to STDOUT when
  //	parsing a template with undefined variable references
  //	Used for tracking down bugs-n-such. Use no_strict() to disable.
  
  function strict () {
    $this->STRICT = true;
  }
  
  //	************************************************************
  //	Silently discards (removes) undefined variable references
  //	found in templates
  
  function no_strict () {
    $this->STRICT = false;
  }

  //	************************************************************
  //	A quick check of the template file before reading it.
  //	This is -not- a reliable check, mostly due to inconsistencies
  //	in the way PHP determines if a file is readable.
  
  function is_safe ($filename) {
    if(!file_exists($filename)) {
      $this->error("[$filename] does not exist",0);
      return false;
    }
    return true;
  }
  
  //	************************************************************
  //	Grabs a template from the root dir and 
  //	reads it into a (potentially REALLY) big string
  
  function get_template ($template) {
    if(empty($this->ROOT)) {
      $this->error("Cannot open template. Root not valid.",1);
      return false;
    }
    
    $filename	=	"$this->ROOT"."$template";
    
    $contents = implode("",(@file($filename)));
    if( (!$contents) or (empty($contents)) ) {
      $this->error("get_template() failure: [$filename] $php_errormsg",1);
    }
    
    return $contents;
    
  } // end get_template
  
  //	************************************************************
  //	Prints the warnings for unresolved variable references
  //	in template files. Used if STRICT is true
  
  function show_unknowns ($Line) {
    $unknown = array();
    if (ereg("({[A-Z0-9_]+})",$Line,$unknown)) {
      $UnkVar = $unknown[1];
      if(!(empty($UnkVar))) {
	@error_log("[FastTemplate] Warning: no value found for variable: $UnkVar ",0);
      }
    }
  }	// end show_unknowns()
  
  //	************************************************************
  //	This routine get's called by parse() and does the actual
  //	{VAR} to VALUE conversion within the template.
  
  function parse_template ($template, $tpl_array) {
    $a = strtok($template,"{");
    $oldtemp = $template;
    while($a || $t) {
      $t = strtok("}");
      
      if($t){
	settype($tpl_array[$t],"string");
	//if(empty($tpl_array[$t])){
	//  print($t . '<BR>');
	//}
	$toprint = $toprint . $a . $tpl_array[$t];
      } else {
	$toprint = $toprint . $a;
      }
      //print('T-' . $t . '<BR>');
      //print('value' . htmlentities($tpl_array[$t]) . '<BR>');
      //print('A-' . htmlentities($a) . '<BR>');
      $a = strtok("{");
      
    }
    
    $template = $toprint;
    
    return $template;
    
  }	// end parse_template();

  function parse_template_messy ($template, $tpl_array) {
    $a = strtok($template,"{");
    $oldtemp = $template;
    while($a || $t) {
      $t = strtok("}");
      
      if($t){
	settype($tpl_array[$t],"string");

	if(empty($tpl_array[$t])){
	  $toprint = $toprint . $a . "{". $t . "}"; // Recreate the substitution. 
	} else {
	  $toprint = $toprint . $a . $tpl_array[$t];
	}

      } else {
	$toprint = $toprint . $a;
      }
      //print('T-' . $t . '<BR>');
      //print('value' . htmlentities($tpl_array[$t]) . '<BR>');
      //print('A-' . htmlentities($a) . '<BR>');
      $a = strtok("{");
      
    }
    
    $template = $toprint;
    
    return $template;
    
  }	// end parse_template();
  
  //	************************************************************
  //	The meat of the whole class. The magic happens here.
  
  function parse ( $ReturnVar, $FileTags ) {
    $append = false;
    $this->LAST = $ReturnVar;
    $this->HANDLE[$ReturnVar] = 1;
    
    if (gettype($FileTags) == "array") {
      
      unset($this->$ReturnVar);	// Clear any previous data
      
      while ( list ( $key , $val ) = each ( $FileTags ) ) {
	if ( (!isset($this->$val)) || (empty($this->$val)) ) {
	  $this->LOADED["$val"] = 1;
	  if(isset($this->DYNAMIC["$val"])) {
	    $this->parse_dynamic($val,$ReturnVar);
	  } else {
	    $fileName = $this->FILELIST["$val"];
	    $this->$val = $this->get_template($fileName);
	    
	  }
	}
	
        //	Array context implies overwrite
	
	$this->$ReturnVar = $this->parse_template($this->$val,$this->PARSEVARS);
	
	//	For recursive calls.
	
	$this->assign( array( $ReturnVar => $this->$ReturnVar ) );
	
      }
    } else {	// end if FileTags is array()
      // FileTags is not an array
      
      $val = $FileTags;
      
      
      if( (substr($val,0,1)) == '.' ) {
				// Append this template to a previous ReturnVar
	
	$append = true;
	$val = substr($val,1);
      }

      if ( (!isset($this->$val)) || (empty($this->$val)) ) {
	$this->LOADED["$val"] = 1;
	if(isset($this->DYNAMIC["$val"])) {
	  $this->parse_dynamic($val,$ReturnVar);
	} else {
	  $fileName = $this->FILELIST["$val"];
	  $this->$val = $this->get_template($fileName);
	}
      }
      
      if($append) {
	$this->$ReturnVar .= $this->parse_template($this->$val,$this->PARSEVARS);
      } else {
	$this->$ReturnVar = $this->parse_template($this->$val,$this->PARSEVARS);
      }
      
      //	For recursive calls.
      
      $this->assign(array( $ReturnVar => $this->$ReturnVar) );
      
    }
    return;
  }	//	End parse()
  
  
  //	************************************************************
  
  function FastPrint ( $template = "" ) {
    if(empty($template)) {
      $template = $this->LAST;
    }
    
    if( (!(isset($this->$template))) || (empty($this->$template)) ) {
      $this->error("Nothing parsed, nothing printed",0);
      return;
    } else {
      print $this->$template;
    }
    return;
  }
  
  //	************************************************************
  
  
  function fetch ( $template = "" ) {
    if(empty($template)) {
      $template = $this->LAST;
    }
    if( (!(isset($this->$template))) || (empty($this->$template)) ) {
      $this->error("Nothing parsed, nothing printed",0);
      return "";
    }
    
    return($this->$template);
  }
  
  
  //	************************************************************
  
  function define_dynamic ($Macro, $ParentName) {
    //	A dynamic block lives inside another template file.
    //	It will be stripped from the template when parsed
    //	and replaced with the {$Tag}.
    
    $this->DYNAMIC["$Macro"] = $ParentName;
    return true;
  }
  
  //	************************************************************
  
  function parse_dynamic ($Macro,$MacroName) {
      // The file must already be in memory.
      
      $ParentTag = $this->DYNAMIC["$Macro"];
      if( (!$this->$ParentTag) or (empty($this->$ParentTag)) ) {
	$fileName = $this->FILELIST[$ParentTag];
	$this->$ParentTag = $this->get_template($fileName);
	$this->LOADED[$ParentTag] = 1;
      }
      if($this->$ParentTag) {
	$template = $this->$ParentTag;
	$DataArray = split("\n",$template);
	$newMacro = "";
	$newParent = "";
	$outside = true;
	$start = false;
	$end = false;
	while ( list ($lineNum,$lineData) = each ($DataArray) ) {
	  $lineTest = trim($lineData);
	  if("<!-- BEGIN DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = true;
	    $end = false;
	    $outside = false;
	  }
	  if("<!-- END DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = false;
	    $end = true;
	    $outside = true;
	  }
	  if( (!$outside) and (!$start) and (!$end) ) {
	    $newMacro .= "$lineData\n"; // Restore linebreaks
	  }
	  if( ($outside) and (!$start) and (!$end) ) {
	    $newParent .= "$lineData\n"; // Restore linebreaks
	  }
	  if($end) {
	    //	$newParent .= "{$MacroName}\n";
	    $newParent .= '{'."$MacroName}\n";
	  }
	  // Next line please
	  if($end) { $end = false; }
	  if($start) { $start = false; }
	}	// end While

	$this->$Macro = $newMacro;
	$this->$ParentTag = $newParent;
	return true;
	
      }	else {// $ParentTag NOT loaded - MAJOR oopsie
	@error_log("ParentTag: [$ParentTag] not loaded!",0);
	$this->error("ParentTag: [$ParentTag] not loaded!",0);
      }
      return false;
    }

    //	************************************************************
    //	Strips a DYNAMIC BLOCK from a template.
    
    function clear_dynamic ($Macro="") {
      if(empty($Macro)) { return false; }
      
      // The file must already be in memory.
      
      $ParentTag = $this->DYNAMIC["$Macro"];
      
      if( (!$this->$ParentTag) or (empty($this->$ParentTag)) ) {
	$fileName = $this->FILELIST[$ParentTag];
	$this->$ParentTag = $this->get_template($fileName);
	$this->LOADED[$ParentTag] = 1;
      }

      if($this->$ParentTag) {
	$template = $this->$ParentTag;
	$DataArray = split("\n",$template);
	$newParent = "";
	$outside = true;
	$start = false;
	$end = false;
	while ( list ($lineNum,$lineData) = each ($DataArray) ) {
	  $lineTest = trim($lineData);
	  if("<!-- BEGIN DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = true;
	    $end = false;
	    $outside = false;
	  }
	  if("<!-- END DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = false;
	    $end = true;
	    $outside = true;
	  }
	  if( ($outside) and (!$start) and (!$end) ) {
	    $newParent .= "$lineData\n"; // Restore linebreaks
	  }
	  // Next line please
	  if($end) { $end = false; }
	  if($start) { $start = false; }
	}	// end While
	
	$this->$ParentTag = $newParent;
	return true;
	
      }	else {// $ParentTag NOT loaded - MAJOR oopsie
	@error_log("ParentTag: [$ParentTag] not loaded!",0);
	$this->error("ParentTag: [$ParentTag] not loaded!",0);
      }
      return false;
    }
    
    //	************************************************************
    //	Adds cached data to a DYNAMIC BLOCK from a template.
    
    function add_cache_dynamic ($Macro="", $cache_data="" ) {
      if(empty($Macro)) { return false; }

      // The file must already be in memory.
      
      $ParentTag = $this->DYNAMIC["$Macro"];
      
      if( (!$this->$ParentTag) or (empty($this->$ParentTag)) ) {
	$fileName = $this->FILELIST[$ParentTag];
	$this->$ParentTag = $this->get_template($fileName);
	$this->LOADED[$ParentTag] = 1;
      }

      if($this->$ParentTag) {
	$template = $this->$ParentTag;
	$DataArray = split("\n",$template);
	$newParent = "";
	$outside = true;
	$start = false;
	$end = false;
	while ( list ($lineNum,$lineData) = each ($DataArray) ) {
	  $lineTest = trim($lineData);
	  if("<!-- BEGIN DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = true;
	    $end = false;
	    $outside = false;
	  }
	  if("<!-- END DYNAMIC BLOCK: $Macro -->" == "$lineTest" ) {
	    $start = false;
	    $end = true;
	    $outside = true;
	  }
	  if( ($outside) and (!$start) and (!$end) ) {
	    $newParent .= "$lineData\n"; // Restore linebreaks
	  }
	  if ($end) {
	    $newParent .= $cache_data;
	  }
	  // Next line please
	  if($end) { $end = false; }
	  if($start) { $start = false; }
	}	// end While
	
	$this->$ParentTag = $newParent;
	return true;
	
      }	else {// $ParentTag NOT loaded - MAJOR oopsie
	@error_log("ParentTag: [$ParentTag] not loaded!",0);
	$this->error("ParentTag: [$ParentTag] not loaded!",0);
      }
      return false;
    }
    
    
    //	************************************************************
    
    function define ($fileList) {
      while ( list ($FileTag,$FileName) = each ($fileList) ) {
	$this->FILELIST["$FileTag"] = $FileName;
      }
      return true;
    }
    
    //	************************************************************
    
    function clear_parse ( $ReturnVar = "") {
      $this->clear($ReturnVar);
    }
    
    //	************************************************************
    
    function clear ( $ReturnVar = "" ) {
      // Clears out hash created by call to parse()
      
      if(!empty($ReturnVar)) {
	if( (gettype($ReturnVar)) != "array") {
	  unset($this->$ReturnVar);
	  return;
	} else {
	  while ( list ($key,$val) = each ($ReturnVar) ) {
	    unset($this->$val);
	  }
	  return;
	}
      }
      
      // Empty - clear all of them
      
      while ( list ( $key,$val) = each ($this->HANDLE) ) {
	$KEY = $key;
	unset($this->$KEY);
      }
      return;
      
    }	//	end clear()
    
    //	************************************************************
    
    function clear_all () {
      $this->clear();
      $this->clear_assign();
      $this->clear_define();
      $this->clear_tpl();
      
      return;
      
    }	//	end clear_all
    
    //	************************************************************

    function clear_tpl ($fileHandle = "") {
      if(empty($this->LOADED)) {
	// Nothing loaded, nothing to clear
	
	return true;
      }
      if(empty($fileHandle)) {
	// Clear ALL fileHandles
	
	while ( list ($key, $val) = each ($this->LOADED) ) {
	  unset($this->$key);
	}
	unset($this->LOADED);
	
	return true;
      } else {
	if( (gettype($fileHandle)) != "array") {
	  if( (isset($this->$fileHandle)) || (!empty($this->$fileHandle)) ) {
	    unset($this->LOADED[$fileHandle]);
	    unset($this->$fileHandle);
	    return true;
	  }
	} else {
	  while ( list ($Key, $Val) = each ($fileHandle) ) {
	    unset($this->LOADED[$Key]);
	    unset($this->$Key);
	  }
	  return true;
	}
      }
      
      return false;
      
    }	// end clear_tpl
    
    //	************************************************************
    
    function clear_define ( $FileTag = "" ){
      if(empty($FileTag)) {
	unset($this->FILELIST);
	return;
      }
      
      if( (gettype($Files)) != "array") { 
	unset($this->FILELIST[$FileTag]);
	return;
      } else {
	while ( list ( $Tag, $Val) = each ($FileTag) ) {
	  unset($this->FILELIST[$Tag]);
	}
	return;
      }
    }
    
    //	************************************************************
    //	Aliased function - used for compatibility with CGI::FastTemplate
    function clear_parse () {
      $this->clear_assign();
    }
    
    //	************************************************************
    //	Clears all variables set by assign()

    function clear_assign () {
      if(!(empty($this->PARSEVARS))) {
	while(list($Ref,$Val) = each ($this->PARSEVARS) ) {
	  unset($this->PARSEVARS["$Ref"]);
	}
      }
    }
    
    //	************************************************************
    
    function clear_href ($href) {
      if(!empty($href)) {
	if( (gettype($href)) != "array") {
	  unset($this->PARSEVARS[$href]);
	  return;
	} else {
	  while (list ($Ref,$val) = each ($href) ) {
	    unset($this->PARSEVARS[$Ref]);
	  }
	  return;
	}
      } else {
	// Empty - clear them all
	
	$this->clear_assign();
      }
      return;
    }
    
    //	************************************************************
    
    function assign ($tpl_array, $trailer="") {
      if(gettype($tpl_array) == "array") {
	while ( list ($key,$val) = each ($tpl_array) ) {
	  if (!(empty($key))) {
	    //	Empty values are allowed
	    //	Empty Keys are NOT
	    
	    $this->PARSEVARS["$key"] = $val;
	  }
	}
	
	
	//if(empty($this->PARSEVARS)){
	//$this->PARSEVARS = $tpl_array;
	//}else{
	//$this->PARSEVARS = $this->PARSEVARS + $tpl_array;
	//}
	
      } else {
	// Empty values are allowed in non-array context now.
	if (!empty($tpl_array)) {
	  $this->PARSEVARS["$tpl_array"] = $trailer;
	}
      }
    }
    
    //	************************************************************
    //	Return the value of an assigned variable.
    //	Christian Brandel cbrandel@gmx.de
    
    function get_assigned($tpl_name = "") {
      if(empty($tpl_name)) { return false; }
      if(isset($this->PARSEVARS["$tpl_name"])) {
	return ($this->PARSEVARS["$tpl_name"]);
      } else {
	return false;
      }
    }

    //	************************************************************

  function error ($errorMsg, $die = 0) {
    $this->ERROR = $errorMsg;
    echo "ERROR: $this->ERROR <BR> \n";
    if ($die == 1) {
      exit;
    }
    
    return;
    
  } // end error()
  
  
  //	************************************************************
  
  
  
  //	************************************************************
  // Caching system
  
  //*********************************/ 
  // Some other functions 
  function remove_cache_lock($str_cache_file) { 
    clearstatcache(); 
    if (file_exists($str_cache_file .  '.lock')) { 
      @unlink($str_cache_file .  '.lock'); 
    } 
  } 
  
  // Create the cache file name
  function cache_file_name ( $ReturnVar, $FileTags ) {
    
    // What are we going to do?
    $str_cache_root = "/tmp/";
    $str_cache_dir = strtolower(getenv ("HTTP_HOST")) . getenv ("SCRIPT_URL");
    if ( (substr ($FileTags, 0, 1)) == '.' ) {
      $str_cache_file = "/" . substr($FileTags,1);
    } else {
      $str_cache_file = "/" . $FileTags;
    }
    
    // First we need to make the directory the cache file is in if it doesn't already exist.
    if ($this->rmkdir ($str_cache_root . $str_cache_dir)) 
      return $str_cache_root . $str_cache_dir . $str_cache_file;

    return;
  }

  // Create a directory tree
  function rmkdir ( $directory ) {
    
    // If we encounter this as a file, we can't make it a directory
    $type = filetype ( $directory );
    if ($type != 'dir' && $type != 'FALSE' && !empty($type)) {
      return FALSE;
    }
    if ($type == 'dir')
      return TRUE;

    $pieces = explode ("/", $directory);
    
    for ($num = 0; $num < count($pieces); $num += 1) {
      $so_far = $so_far . "/" . $pieces[$num];
      
      $type = filetype ( $so_far );
      if ($type != 'dir' && $type != 'FALSE' && !empty($type)) {
	return FALSE;
      }
      
      if ($type == 'dir') {
	continue;
      }
      
      if (!mkdir ($so_far, 0700)) {
	return FALSE;
      }
    }

 return TRUE;

 }
 
 //*********************************/ 
 // CACHE REFRESH CHECKING FUNCTIONS 
 // Each function checks the next interval higher for verification 
 
 function checkRefreshYear($systime, $filetime) { 
 $sysYear = date( "y", $systime); 
 $fileYear = date( "y", $filetime); 
 if ($sysYear != $fileYear) { return false; } 
 return true; 
 } 
 
 function checkRefreshMonth($systime, $filetime) { 
 $sysMonth = date( "M", $systime); 
 $fileMonth = date( "M", $filetime); 
 if ($sysMonth != $fileMonth) { return false; } 
 if (!(checkRefreshYear($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshDay($systime, $filetime) { 
 $sysDay = date( "j", $systime); 
 $fileDay = date( "j", $filetime); 
 if ($sysDay != $fileDay) { return false; } 
 if (!(checkRefreshMonth($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshDayHalf($systime, $filetime) { 
 $sysHour = date( "H", $systime); 
 $fileHour = date( "H", $filetime); 
 if (($sysHour % 12) < ($fileHour % 12)) { return false; } 
 if (!(checkRefreshDay($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshHour($systime, $filetime) { 
 $sysHour = date( "H", $systime); 
 $fileHour = date( "H", $filetime); 
 if ($sysHour != $fileHour) { return false; } 
 if (!(checkRefreshDayHalf($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshHalfHour($systime, $filetime) { 
 $sysMin = date( "i", $systime); 
 $fileMin = date( "i", $filetime); 
 if (($sysMin % 30) < ($fileMin % 30)) { return false; } 
 if (!(checkRefreshHour($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshQuarterHour($systime, $filetime) { 
 $sysMin = date( "i", $systime); 
 $fileMin = date( "i", $filetime); 
 if (($sysMin % 15) < ($fileMin % 15)) { return false; } 
 if (!(checkRefreshHalfHour($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 function checkRefreshMinute($systime, $filetime) { 
 $sysMin = date( "i", $systime); 
 $fileMin = date( "i", $filetime); 
 if ($sysMin != $fileMin) { return false; } 
 if (!(checkRefreshQuarterHour($systime, $filetime))) { return false; } 
 return true; 
 } 
 
 
 
} // End class.FastTemplate

?>