// 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;
}
}
//全部结束
文章来源于领测软件测试网 https://www.ltesting.net/
