//
   // Description
   //    Perform substitution on the template.  We do not really recurse
   //    downward in the sense that we do not do subsitutions on inferior
   //    templates.  For each inferior template which is a part of this
   //    template, we insert the current value of their results.
   //
   // Notes
   //    Do I want to make this return a reference?
   function subst ($handle, $tag, $autoload = true) {
      $append = false;
      $debug = $this->DEBUGALL || $this->DEBUG['subst'];
      $this->LAST = $handle;

      if ($debug)
         $this->logwrite ("subst (handle=$handle, tag=$tag, autoload=$autoload)");

      // For compatibility with FastTemplate, the results need to overwrite
      // for an array.  This really only seems to be useful in the case of
      // something like
      //     $t->parse ('MAIN', array ('array', 'main'));
      // Where the 'main' template has a variable named MAIN which will be
      // set on the first pass (i.e., when parasing 'array') and used on the
      // second pass (i.e., when parsing 'main').
      if (gettype($tag) == 'array') {
         foreach (array_values($tag) as $t) {
            if ($debug)
               $this->logwrite ("subst: calling subst($handle,$t,$autoload)");
            $this->subst ($handle, $t, $autoload);
         }
         return $this->HANDLE[$handle];
      }

      // Period prefix means append result to pre-existing value.
      if (substr($tag,0,1) == '.') {
         $append = true;
         $tag = substr ($tag, 1);
         if ($debug)
            $this->logwrite ("subst (handle=$handle, tag=$tag, autoload=$autoload) in append mode");
      }
      // $this->TEMPLATE[$tag] will only be set if it was explicitly
      // declared via define(); i.e., inferior templates will not have an
      // entry.
      if (isset($this->TEMPLATE[$tag])) {
         if (!isset($this->TEMPLATE[$tag]['parsed'])
             || !$this->TEMPLATE[$tag]['parsed'])
            $this->parse_internal ($tag);
      } else {
         if (!$this->DYNAMIC) {
            $this->error ("subst (handle=$handle, tag=$tag, autoload=$autoload): " .
                          'no such tag and dynamic templates are turned off', true);
         }
         if ($autoload) {
            if ($debug)
               $this->logwrite ("subst: TEMPLATE[tag=$tag] not found, trying autoload");
            foreach (array_keys($this->TEMPLATE) as $t) {
               if ($debug)
                  $this->logwrite ("subst: calling parse_internal (tag=$t)");
               if (!isset($this->TEMPLATE[$tag]['parsed'])
                   || !$this->TEMPLATE[$tag]['parsed'])
                  $this->parse_internal ($t);
            }
            if ($debug)
               $this->logwrite ('subst: retrying with autoload = false');
            $this->subst ($handle, $tag, false);
            if ($debug)
               $this->logwrite ('subst: completed with autoload = false');
            return;
         } else {
            $this->error ("subst (handle=$handle, tag=$tag, autoload=$autoload):  no such tag", true);
         }
      }
      if (!$append) {
         $this->TEMPLATE[$tag]['result'] = '';
         if ($debug)
            $this->logwrite ("subst (handle=$handle, tag=$tag, autoload=$autoload) in overwrite mode");
      }
      if ($debug)
         $this->logwrite ('subst: type(this->TEMPLATE[$tag][\'part\']) => ' .
                          gettype($this->TEMPLATE[$tag]['part']));
      // Hmmm, clear() called before subst() seems to result in this not
      // being defined which leaves me a bit confused....
      $result = '';
      if (isset($this->TEMPLATE[$tag]['part'])) {
         reset ($this->TEMPLATE[$tag]['part']);
         foreach (array_keys($this->TEMPLATE[$tag]['part']) as $p) {
            if ($debug)
               $this->logwrite ("subst: looking at TEMPLATE[$tag]['part'][$p]");
            $tmp = $this->TEMPLATE[$tag]['part'][$p];
            // Don't try if ($p == 'parent')....
            if (strcmp ($p, 'parent') == 0) {
               if ($debug)
                  $this->logwrite ("subst: skipping part $p");
               $tmp = '';
            } else if (gettype($this->TEMPLATE[$tag]['part'][$p]) == 'string') {
               if ($debug)
                  $this->logwrite ("subst: using part $p");
               reset ($this->VAR);
               // Because we treat VAR and HANDLE separately (unlike
               // class.FastTemplate.php3), we have to iterate over both or we
               // miss some substitutions and are not 100% compatible.
               while (list($key,$val) = each ($this->VAR)) {
                  if ($debug)
                     $this->logwrite ("subst: substituting VAR $key = $val in $tag");
                  $key = '{'.$key.'}';
                  $tmp = str_replace ($key, $val, $tmp);
               }
               reset ($this->HANDLE);
               while (list($key,$val) = each ($this->HANDLE)) {
                  if ($debug)
                     $this->logwrite ("subst: substituting HANDLE $key = $val in $tag");
                  $key = '{'.$key.'}';
                  $tmp = str_replace ($key, $val, $tmp);
               }
               $result .= $tmp;
            } else {
               $xtag = $this->TEMPLATE[$tag]['part'][$p]['tag'];
               if ($debug) {
                  $this->logwrite ("subst: substituting other tag $xtag result in $tag");
               }
               // The assignment is a no-op if the result is not set, but when
               // E_ALL is in effect, a warning is generated without the
               // isset() test.
               if (isset ($this->TEMPLATE[$xtag]['result']))
                  $result .= $this->TEMPLATE[$xtag]['result'];
            }
         }
      }
      if ($this->STRICT) {
     // If quiet-mode is turned on, skip the check since we're not going
     // to do anything anyway.
     if (!$this->QUIET) {
        if (preg_match ($this->REGEX_VAR, $result)) {
           $this->error ("<B>unmatched tags still present in $tag</B><BR />");
        }
     }
      } else {
         $result = preg_replace ($this->REGEX_VAR, '', $result);
      }
      if ($append) {
         if ($debug) {
            $this->logwrite ("subst: appending TEMPLATE[$tag]['result'] = $result");
            $this->logwrite ("subst: old HANDLE[$handle] = {$this->HANDLE[$handle]}");
            $this->logwrite ("subst: old TEMPLATE[$tag]['result'] = {$this->TEMPLATE[$tag]['result']}");
         }
         // The isset() tests are to suppresss warning when E_ALL is in effect
         // and the variables have not actually been set yet (even though the
         // user specified append-mode).
         if (isset ($this->HANDLE[$handle]))
            $this->HANDLE[$handle] .= $result;
         else
            $this->HANDLE[$handle] = $result;
         if (isset ($this->TEMPLATE[$tag]['result']))
            $this->TEMPLATE[$tag]['result'] .= $result;
         else
            $this->TEMPLATE[$tag]['result'] = $result;
         if ($debug) {
            $this->logwrite ("subst: new HANDLE[$handle] = {$this->HANDLE[$handle]}");
            $this->logwrite ("subst: new TEMPLATE[$tag]['result'] = {$this->TEMPLATE[$tag]['result']}");
         }

      } else {
         if ($debug)
            $this->logwrite ("subst: setting TEMPLATE[$tag]['result'] = $result");
         $this->HANDLE[$handle]  = $result;
         $this->TEMPLATE[$tag]['result'] = $result;
      }
      return $this->HANDLE[$handle];
   }

   //
   // Description
   //    Clear a block from a template.  The intent is to remove an inferior
   //    template from a parent.  This works even if the template has already
   //    been parsed since we go straight to the specified template and clear
   //    the results element.  If the given template has not yet been
   //    loaded, the load is forced by calling parse_internal().
   //
   function clear_dynamic ($tag = NULL) {
      $debug = $this->DEBUGALL || $this->DEBUG['clear_dynamic'];
      if (is_null ($tag)) {
         // Clear all result elements.  Uhm, needs to be tested.
         if ($debug)
            $this->logwrite ("clear_dynamic (NULL)");
         foreach (array_values ($this->TEMPLATE) as $t) {
            $this->clear_dynamic ($t);
         }
         return;
      } else if (gettype($tag) == 'array') {
         if ($debug)
            $this->logwrite ("clear_dynamic ($tag)");
         foreach (array_values($tag) as $t) {
            $this->clear_dynamic ($t);
         }
         return;
      }
      else if (!isset($this->TEMPLATE[$tag])) {
         if ($debug)
            $this->logwrite ("clear_dynamic ($tag) --> $tag not set, calling parse_internal");
         $this->parse_internal ($tag);
         // $this->TEMPLATE[$tag] = array ();
      }
      if ($debug)
         $this->logwrite ("clear_dynamic ($tag)");
      // $this->TEMPLATE[$tag]['loaded']  = true;
      // $this->TEMPLATE[$tag]['string']  = '';
      $this->TEMPLATE[$tag]['result'] = '';
      // $this->TEMPLATE[$tag]['clear']   = true;
   }

   //
   // Description
   //    Clear the results of a handle set by parse().  The input handle can
   //    be a single value, an array, or the PHP constant NULL.  For the
   //    last case, all handles cleared.
   //
   function clear ($handle = NULL) {
      $debug = $this->DEBUGALL || $this->DEBUG['clear'];
      if (is_null ($handle)) {
         // Don't bother unsetting them, just set the whole thing to a new,
         // empty array.
         if ($debug)
            $this->logwrite ("clear (NULL)");
         $this->HANDLE = array ();
      } else if (gettype ($handle) == 'array') {
         if ($debug)
            $this->logwrite ("clear ($handle)");
         foreach (array_values ($handle) as $h) {
            $this->clear ($h);
         }
      } else if (isset ($this->HANDLE[$handle])) {
         if ($debug)
            $this->logwrite ("clear ($handle)");
         unset ($this->HANDLE[$handle]);
      }
   }

   //
   // Description
   //   Clears all information associated with the specified tag as well as
   //   any information associated with embedded templates.  This will force
   //   the templates to be reloaded on the next call to subst().
   //   Additionally, any results of previous calls to subst() will also be
   //   cleared.
   //
   // Notes
   //   This leaves dangling references in $this->HANDLE.  Or does PHP do
   //   reference counting so they are still valid?
   //
   function unload ($tag) {
      if (!isset($this->TEMPLATE[$tag]))
         return;
      if (isset ($this->TEMPLATE[$tag]['parent'])) {
         $ptag = $this->TEMPLATE[$tag]['parent'];
         foreach (array_keys($this->TEMPLATE) as $t) {
            if ($this->TEMPLATE[$t]['parent'] == $ptag) {
               unset ($this->TEMPLATE[$t]);
            }
         }
      }
      unset ($this->TEMPLATE[$tag]);
      return;
   }

   //
   // Description
   //    class.FastTemplate.php3 compatible interface.
   //
   function assign ($tplkey, $rest = '') {
      $this->setkey ($tplkey, $rest);
   }

   //
   // Description
   //    Set a (key,value) in our internal variable array.  These will be
   //    used during the substitution phase to replace template variables.
   //
   function setkey ($tplkey, $rest = '') {
      if (gettype ($tplkey) == 'array') {
         reset ($tplkey);
         while (list($key,$val) = each ($tplkey)) {
            if (!empty($key)) {
               $this->VAR[$key] = $val;
            }
         }
      } else {
         if (!empty($tplkey)) {
            $this->VAR[$tplkey] = $rest;
         }
      }
   }

   //
   // Description
   //    class.FastTemplate.php3 compatible interface
   //
   function get_assigned ($key = '') {
      return $this->getkey ($key);
   }

   //
   // Description
   //    Retrieve a value from our internal variable array given the key name.
   //
   function getkey ($key = '') {
      if (empty($key)) {
         return false;
      } else if (isset ($this->VAR[$key])) {
         return $this->VAR[$key];
      } else {
         return false;
      }
   }

   function fetch ($handle = '') {
      if (empty($handle)) {
         $handle = $this->LAST;
      }
      return $this->HANDLE[$handle];
   }

   function xprint ($handle = '') {
      if (empty($handle)) {
         $handle = $this->LAST;
      }
      print ($this->HANDLE[$handle]);
   }

   function FastPrint ($handle = '') {
      $this->xprint ($handle);
   }

   function clear_href ($key = '') {
      $this->unsetkey ($key);
   }

   function unsetkey ($key = '') {
      if (empty($key)) {
         unset ($this->VAR);
         $this->VAR = array ();
      } else if (gettype($key) == 'array') {
         reset ($key);
         foreach (array_values($key) as $k) {
            unset ($this->VAR[$k]);
         }
      } else {
         unset ($this->VAR[$key]);
      }
   }

   function define_nofile ($stringList, $dynamic = 0) {
      $this->define_raw ($stringList, $dynamic);
   }
   //
   // Description
   //    Member function to control explicit error messages.  We don't do
   //    real PHP error handling.
   //
   function error ($errorMsg, $die = 0) {
      $this->ERROR = $errorMsg;
      echo "ERROR: {$this->ERROR} <br /> \n";
      if ($die) {
         exit;
      }
      return;
   }
}

//全部结束