class_BaseTemplateEngine.php

Go to the documentation of this file.

<?php
class BaseTemplateEngine extends BaseFrameworkSystem {
        private $basePath = "";

        private $templateType = "html";

        private $templateExtension = ".tpl";

        private $codeExtension = ".ctp";

        private $compileOutputPath = "templates/_compiled";

        private $rawTemplateData = "";

        private $compiledData = "";

        private $lastTemplate = "";

        private $varStack = array();

        private $loadedTemplates = array();

        private $compiledTemplates = array();

        private $loadedRawData = null;

        private $rawTemplates = null;

        private $regExpVarValue = '/([\w_]+)(="([^"]*)"|=([\w_]+))?/';

        private $regExpCodeTags = '/\{\?([a-z_]+)(:("[^"]+"|[^?}]+)+)?\?\}/';

        private $helpers = array();

        private $currGroup = 'general';

        private $varGroups = array();

        // Exception codes for the template engine
        const EXCEPTION_TEMPLATE_TYPE_IS_UNEXPECTED   = 0x110;
        const EXCEPTION_TEMPLATE_CONTAINS_INVALID_VAR = 0x111;
        const EXCEPTION_INVALID_VIEW_HELPER           = 0x112;

        protected function __construct ($className) {
                // Call parent constructor
                parent::__construct($className);

                // Clean up a little
                $this->removeNumberFormaters();
                $this->removeSystemArray();
        }

        private function isVariableAlreadySet ($var) {
                // First everything is not found
                $found = false;

                // Is the group there?
                if (isset($this->varStack[$this->currGroup])) {
                        // Now search for it
                        foreach ($this->varStack[$this->currGroup] as $idx => $currEntry) {
                                //* DEBUG: */ echo __METHOD__.":currGroup={$this->currGroup},idx={$idx},currEntry={$currEntry['name']},var={$var}<br />\n";
                                // Is the entry found?
                                if ($currEntry['name'] == $var) {
                                        // Found!
                                        //* DEBUG: */ echo __METHOD__.":FOUND!<br />\n";
                                        $found = $idx;
                                        break;
                                } // END - if
                        } // END - foreach
                } // END - if

                // Return the current position
                return $found;
        }

        protected function readVariable ($var) {
                // First everything is not found
                $content = null;

                // Get variable index
                $found = $this->isVariableAlreadySet($var);

                // Is the variable found?
                if ($found !== false) {
                        // Read it
                        $found = $this->varStack[$this->currGroup][$found]['value'];
                } // END - if

                //* DEBUG: */ echo __METHOD__.": group=".$this->currGroup.",var=".$var.", found=".$found."<br />\n";

                // Return the current position
                return $found;
        }

        private function addVariable ($var, $value) {
                // Set general variable group
                $this->setVariableGroup('general');

                // Add it to the stack
                $this->addGroupVariable($var, $value);
        }

        private function readCurrentGroup () {
                // Default is not found
                $result = array();

                // Is the group there?
                if (isset($this->varStack[$this->currGroup])) {
                        // Then use it
                        $result = $this->varStack[$this->currGroup];
                } // END - if

                // Return result
                return $result;
        }

        public function setVariableGroup ($groupName, $add = true) {
                // Set group name
                //* DEBIG: */ echo __METHOD__.": currGroup=".$groupName."<br />\n";
                $this->currGroup = $groupName;

                // Skip group 'general'
                if (($groupName != 'general') && ($add === true)) {
                        $this->varGroups[$groupName] = 'OK';
                } // END - if
        }


        public function addGroupVariable ($var, $value) {
                //* DEBUG: */ echo __METHOD__.": group=".$this->currGroup.", var=".$var.", value=".$value."<br />\n";

                // Get current variables in group
                $currVars = $this->readCurrentGroup();

                // Append our variable
                $currVars[] = array(
                        'name'  => $var,
                        'value' => $value
                );

                // Add it to the stack
                $this->varStack[$this->currGroup] = $currVars;
        }

        private function modifyVariable ($var, $value) {
                // Get index for variable
                $idx = $this->isVariableAlreadySet($var);

                // Is the variable set?
                if ($idx !== false) {
                        // Then modify it
                        $this->varStack[$this->currGroup][$idx]['value'] = $value;
                } // END - if
        }

        private final function setTemplateType ($templateType) {
                $this->templateType = (string) $templateType;
        }

        private final function setLastTemplate ($template) {
                $this->lastTemplate = (string) $template;
        }

        private final function getLastTemplate () {
                return $this->lastTemplate;
        }

        public final function setBasePath ($basePath) {
                // And set it
                $this->basePath = (string) $basePath;
        }

        public final function getBasePath () {
                // And set it
                return $this->basePath;
        }

        public final function setRawTemplateExtension ($templateExtension) {
                // And set it
                $this->templateExtension = (string) $templateExtension;
        }

        public final function setCodeTemplateExtension ($codeExtension) {
                // And set it
                $this->codeExtension = (string) $codeExtension;
        }

        public final function getRawTemplateExtension () {
                // And set it
                return $this->templateExtension;
        }

        public final function getCodeTemplateExtension () {
                // And set it
                return $this->codeExtension;
        }

        public final function setCompileOutputPath ($compileOutputPath) {
                // And set it
                $this->compileOutputPath = (string) $compileOutputPath;
        }

        public final function getTemplateType () {
                return $this->templateType;
        }

        public final function assignVariable ($var, $value) {
                // Trim spaces of variable name
                $var = trim($var);

                // Empty variable found?
                if (empty($var)) {
                        // Throw an exception
                        throw new EmptyVariableException(array($this, 'var'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
                } // END - if

                // First search for the variable if it was already added
                $idx = $this->isVariableAlreadySet($var);

                // Was it found?
                if ($idx === false) {
                        // Add it to the stack
                        //* DEBUG: */ echo "ADD: ".$var."<br />\n";
                        $this->addVariable($var, $value);
                } elseif (!empty($value)) {
                        // Modify the stack entry
                        //* DEBUG: */ echo "MOD: ".$var."<br />\n";
                        $this->modifyVariable($var, $value);
                }
        }

        public final function removeVariable ($var) {
                // First search for the variable if it was already added
                $idx = $this->isVariableAlreadySet($var);

                // Was it found?
                if ($idx !== false) {
                        // Remove this variable
                        $this->varStack->offsetUnset($idx);
                }
        }

        protected final function setRawTemplateData ($rawTemplateData) {
                // And store it in this class
                //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($rawTemplateData)." Bytes set.<br />\n";
                //* DEBUG: */ echo $this->currGroup." variables: ".count($this->varStack[$this->currGroup]).", groups=".count($this->varStack)."<br />\n";
                $this->rawTemplateData = (string) $rawTemplateData;
        }

        public final function getRawTemplateData () {
                //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($this->rawTemplateData)." Bytes read.<br />\n";
                return $this->rawTemplateData;
        }

        private final function setCompiledData ($compiledData) {
                // And store it in this class
                //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($compiledData)." Bytes set.<br />\n";
                $this->compiledData = (string) $compiledData;
        }

        public final function getCompiledData () {
                //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($this->compiledData)." Bytes read.<br />\n";
                return $this->compiledData;
        }

        private function loadTemplate ($template) {
                // Get extension for the template
                $ext = $this->getRawTemplateExtension();

                // If we shall load a code-template we need to switch the file extension
                if ($this->getTemplateType() == $this->getConfigInstance()->readConfig('code_template_type')) {
                        // Switch over to the code-template extension
                        $ext = $this->getCodeTemplateExtension();
                } // END - if

                // Construct the FQFN for the template by honoring the current language
                $fqfn = sprintf("%s%s/%s/%s%s",
                        $this->getBasePath(),
                        $this->getLanguageInstance()->getLanguageCode(),
                        $this->getTemplateType(),
                        (string) $template,
                        $ext
                );

                // Load the raw template data
                $this->loadRawTemplateData($fqfn);
        }

        private function loadRawTemplateData ($fqfn) {
                // Get a input/output instance from the middleware
                $ioInstance = $this->getFileIoInstance();

                // Some debug code to look on the file which is being loaded
                //* DEBUG: */ echo __METHOD__.": FQFN=".$fqfn."<br />\n";

                // Load the raw template
                $rawTemplateData = $ioInstance->loadFileContents($fqfn);

                // Store the template's contents into this class
                $this->setRawTemplateData($rawTemplateData);

                // Remember the template's FQFN
                $this->setLastTemplate($fqfn);
        }

        private function assignTemplateVariable ($varName, $var) {
                // Is it not a config variable?
                if ($varName != 'config') {
                        // Regular template variables
                        $this->assignVariable($var, "");
                } else {
                        // Configuration variables
                        $this->assignConfigVariable($var);
                }
        }

        private function extractVariablesFromRawData ($rawData) {
                // Cast to string
                $rawData = (string) $rawData;

                // Search for variables
                @preg_match_all('/\$(\w+)(\[(\w+)\])?/', $rawData, $variableMatches);

                // Did we find some variables?
                if ((is_array($variableMatches)) && (count($variableMatches) == 4) && (count($variableMatches[0]) > 0)) {
                        // Initialize all missing variables
                        foreach ($variableMatches[3] as $key => $var) {
                                // Variable name
                                $varName = $variableMatches[1][$key];

                                // Workarround: Do not assign empty variables
                                if (!empty($var)) {
                                        // Try to assign it, empty strings are being ignored
                                        $this->assignTemplateVariable($varName, $var);
                                } // END - if
                        } // END - foreach
                } // END - if
        }

        private function analyzeTemplate (array $templateMatches) {
                // Backup raw template data
                $backup = $this->getRawTemplateData();

                // Initialize some arrays
                if (is_null($this->loadedRawData)) { $this->loadedRawData = array(); $this->rawTemplates = array(); }

                // Load all requested templates
                foreach ($templateMatches[1] as $template) {

                        // Load and compile only templates which we have not yet loaded
                        // RECURSIVE PROTECTION! BE CAREFUL HERE!
                        if ((!isset($this->loadedRawData[$template])) && (!in_array($template, $this->loadedTemplates))) {

                                // Template not found, but maybe variable assigned?
                                //* DEBUG: */ echo __METHOD__.":template={$template}<br />\n";
                                if ($this->isVariableAlreadySet($template) !== false) {
                                        // Use that content here
                                        $this->loadedRawData[$template] = $this->readVariable($template);

                                        // Recursive protection:
                                        $this->loadedTemplates[] = $template;
                                } elseif (isset($this->varStack['config'][$template])) {
                                        // Use that content here
                                        $this->loadedRawData[$template] = $this->varStack['config'][$template];

                                        // Recursive protection:
                                        $this->loadedTemplates[] = $template;
                                } else {
                                        // Then try to search for code-templates
                                        try {
                                                // Load the code template and remember it's contents
                                                $this->loadCodeTemplate($template);
                                                $this->loadedRawData[$template] = $this->getRawTemplateData();

                                                // Remember this template for recursion detection
                                                // RECURSIVE PROTECTION!
                                                $this->loadedTemplates[] = $template;
                                        } catch (FileNotFoundException $e) {
                                                // Even this is not done... :/
                                                $this->rawTemplates[] = $template;
                                        } catch (FilePointerNotOpenedException $e) {
                                                // Even this is not done... :/
                                                $this->rawTemplates[] = $template;
                                        }
                                }
                        } // END - if
                } // END - foreach

                // Restore the raw template data
                $this->setRawTemplateData($backup);
        }

        private function compileCode ($code, $template) {
                // Is this template already compiled?
                if (in_array($template, $this->compiledTemplates)) {
                        // Abort here...
                        return;
                } // END - if

                // Remember this template being compiled
                $this->compiledTemplates[] = $template;

                // Compile the loaded code in five steps:
                //
                // 1. Backup current template data
                $backup = $this->getRawTemplateData();

                // 2. Set the current template's raw data as the new content
                $this->setRawTemplateData($code);

                // 3. Compile the template data
                $this->compileTemplate();

                // 4. Remember it's contents
                $this->loadedRawData[$template] = $this->getRawTemplateData();

                // 5. Restore the previous raw content from backup variable
                $this->setRawTemplateData($backup);
        }

        private function insertAllTemplates (array $templateMatches) {
                // Run through all loaded codes
                foreach ($this->loadedRawData as $template => $code) {

                        // Search for the template
                        $foundIndex = array_search($template, $templateMatches[1]);

                        // Lookup the matching template replacement
                        if (($foundIndex !== false) && (isset($templateMatches[0][$foundIndex]))) {

                                // Get the current raw template
                                $rawData = $this->getRawTemplateData();

                                // Replace the space holder with the template code
                                $rawData = str_replace($templateMatches[0][$foundIndex], $code, $rawData);

                                // Set the new raw data
                                $this->setRawTemplateData($rawData);
                        } // END - if
                } // END - foreach
        }

        private function loadExtraRawTemplates () {
                // Are there some raw templates we need to load?
                if (count($this->rawTemplates) > 0) {
                        // Try to load all raw templates
                        foreach ($this->rawTemplates as $key => $template) {
                                try {
                                        // Load the template
                                        $this->loadWebTemplate($template);

                                        // Remember it's contents
                                        $this->rawTemplates[$template] = $this->getRawTemplateData();

                                        // Remove it from the loader list
                                        unset($this->rawTemplates[$key]);

                                        // Remember this template for recursion detection
                                        // RECURSIVE PROTECTION!
                                        $this->loadedTemplates[] = $template;
                                } catch (FileNotFoundException $e) {
                                        // This template was never found. We silently ignore it
                                        unset($this->rawTemplates[$key]);
                                } catch (FilePointerNotOpenedException $e) {
                                        // This template was never found. We silently ignore it
                                        unset($this->rawTemplates[$key]);
                                }
                        } // END - foreach
                } // END - if
        }

        private function assignAllVariables (array $varMatches) {
                // Search for all variables
                foreach ($varMatches[1] as $key => $var) {

                        // Detect leading equals
                        if (substr($varMatches[2][$key], 0, 1) == "=") {
                                // Remove and cast it
                                $varMatches[2][$key] = (string) substr($varMatches[2][$key], 1);
                        }

                        // Do we have some quotes left and right side? Then it is free text
                        if ((substr($varMatches[2][$key], 0, 1) == "\"") && (substr($varMatches[2][$key], -1, 1) == "\"")) {
                                // Free string detected! Which we can assign directly
                                $this->assignVariable($var, $varMatches[3][$key]);
                        } elseif (!empty($varMatches[2][$key])) {
                                // Non-string found so we need some deeper analysis...
                                die("Deeper analysis not yet implemented!");
                        }

                } // for ($varMatches ...
        }
        private function compileRawTemplateData (array $templateMatches) {
                // Are some code-templates found which we need to compile?
                if (count($this->loadedRawData) > 0) {

                        // Then compile all!
                        foreach ($this->loadedRawData as $template => $code) {

                                // Is this template already compiled?
                                if (in_array($template, $this->compiledTemplates)) {
                                        // Then skip it
                                        continue;
                                }

                                // Search for the template
                                $foundIndex = array_search($template, $templateMatches[1]);

                                // Lookup the matching variable data
                                if (($foundIndex !== false) && (isset($templateMatches[3][$foundIndex]))) {

                                        // Split it up with another reg. exp. into variable=value pairs
                                        preg_match_all($this->regExpVarValue, $templateMatches[3][$foundIndex], $varMatches);

                                        // Assign all variables
                                        $this->assignAllVariables($varMatches);

                                } // END - if (isset($templateMatches ...

                                // Compile the loaded template
                                $this->compileCode($code, $template);

                        } // END - foreach ($this->loadedRawData ...

                        // Insert all templates
                        $this->insertAllTemplates($templateMatches);

                } // END - if (count($this->loadedRawData) ...
        }

        private function insertRawTemplates () {
                // Load all templates
                foreach ($this->rawTemplates as $template => $content) {
                        // Set the template as a variable with the content
                        $this->assignVariable($template, $content);
                }
        }

        private function finalizeVariableCompilation () {
                // Get the content
                $content = $this->getRawTemplateData();
                //* DEBUG: */ echo __METHOD__.": content before=".strlen($content)." (".md5($content).")<br />\n";

                // Walk through all variables
                foreach ($this->varStack['general'] as $currEntry) {
                        //* DEBUG: */ echo __METHOD__.": name=".$currEntry['name'].", value=<pre>".htmlentities($currEntry['value'])."</pre>\n";
                        // Replace all [$var] or {?$var?} with the content
                        // Old behaviour, will become obsolete!
                        $content = str_replace("\$content[".$currEntry['name']."]", $currEntry['value'], $content);

                        // Yet another old way
                        $content = str_replace("[".$currEntry['name']."]", $currEntry['value'], $content);

                        // The new behaviour
                        $content = str_replace("{?".$currEntry['name']."?}", $currEntry['value'], $content);
                } // END - for

                //* DEBUG: */ echo __METHOD__.": content after=".strlen($content)." (".md5($content).")<br />\n";

                // Set the content back
                $this->setRawTemplateData($content);
        }

        public function loadWebTemplate ($template) {
                // Set template type
                $this->setTemplateType($this->getConfigInstance()->readConfig('web_template_type'));

                // Load the special template
                $this->loadTemplate($template);
        }

        public function assignConfigVariable ($var) {
                // Sweet and simple...
                //* DEBUG: */ echo __METHOD__.":var={$var}<br />\n";
                $this->varStack['config'][$var] = $this->getConfigInstance()->readConfig($var);
        }

        public function loadEmailTemplate ($template) {
                // Set template type
                $this->setTemplateType($this->getConfigInstance()->readConfig('email_template_type'));

                // Load the special template
                $this->loadTemplate($template);
        }

        public function loadCodeTemplate ($template) {
                // Set template type
                $this->setTemplateType($this->getConfigInstance()->readConfig('code_template_type'));

                // Load the special template
                $this->loadTemplate($template);
        }

        public final function compileVariables () {
                // Initialize the $content array
                $validVar = $this->getConfigInstance()->readConfig('tpl_valid_var');
                $dummy = array();

                // Iterate through all general variables
                foreach ($this->varStack['general'] as $currVariable) {
                        // Transfer it's name/value combination to the $content array
                        //* DEBUG: */ echo $currVariable['name']."=<pre>".htmlentities($currVariable['value'])."</pre>\n";
                        $dummy[$currVariable['name']] = $currVariable['value'];
                }// END - if

                // Set the new variable (don't remove the second dollar!)
                $$validVar = $dummy;

                // Prepare all configuration variables
                $config = null;
                if (isset($this->varStack['config'])) {
                        $config = $this->varStack['config'];
                } // END - if

                // Remove some variables
                unset($idx);
                unset($currVariable);

                // Run the compilation twice to get content from helper classes in
                $cnt = 0;
                while ($cnt < 3) {
                        // Finalize the compilation of template variables
                        $this->finalizeVariableCompilation();

                        // Prepare the eval() command for comiling the template
                        $eval = sprintf("\$result = \"%s\";",
                                addslashes($this->getRawTemplateData())
                        );

                        // This loop does remove the backslashes (\) in PHP parameters
                        while (strpos($eval, "<?php") !== false) {
                                // Get left part before "<?"
                                $evalLeft = substr($eval, 0, strpos($eval, "<?php"));

                                // Get all from right of "<?"
                                $evalRight = substr($eval, (strpos($eval, "<?php") + 5));

                                // Cut middle part out and remove escapes
                                $evalMiddle = trim(substr($evalRight, 0, strpos($evalRight, "?>")));
                                $evalMiddle = stripslashes($evalMiddle);

                                // Remove the middle part from right one
                                $evalRight = substr($evalRight, (strpos($evalRight, "?>") + 2));

                                // And put all together
                                $eval = sprintf("%s<%%php %s %%>%s", $evalLeft, $evalMiddle, $evalRight);
                        } // END - while

                        // Prepare PHP code for eval() command
                        $eval = str_replace(
                                "<%php", "\";",
                                str_replace(
                                        "%>", "\n\$result .= \"", $eval
                                )
                        );

                        // Run the constructed command. This will "compile" all variables in
                        @eval($eval);

                        // Goes something wrong?
                        if (!isset($result)) {
                                // Output eval command
                                $this->debugOutput(sprintf("Failed eval() code: <pre>%s</pre>", $this->markupCode($eval, true)), true);

                                // Output backtrace here
                                $this->debugBackTrace();
                        } // END - if

                        // Set raw template data
                        $this->setRawTemplateData($result);
                        $cnt++;
                } // END - while

                // Final variable assignment
                $this->finalizeVariableCompilation();

                // Set the new content
                $this->setCompiledData($this->getRawTemplateData());
        }

        public function compileTemplate () {
                // We will only work with template type "code" from configuration
                if ($this->getTemplateType() != $this->getConfigInstance()->readConfig('code_template_type')) {
                        // Abort here
                        throw new UnexpectedTemplateTypeException(array($this, $this->getTemplateType(), $this->getConfigInstance()->readConfig('code_template_type')), self::EXCEPTION_TEMPLATE_TYPE_IS_UNEXPECTED);
                } // END - if

                // Get the raw data.
                $rawData = $this->getRawTemplateData();

                // Remove double spaces and trim leading/trailing spaces
                $rawData = trim(str_replace("  ", " ", $rawData));

                // Search for raw variables
                $this->extractVariablesFromRawData($rawData);

                // Search for code-tags which are {? ?}
                preg_match_all($this->regExpCodeTags, $rawData, $templateMatches);

                // Analyze the matches array
                if ((is_array($templateMatches)) && (count($templateMatches) == 4) && (count($templateMatches[0]) > 0)) {
                        // Entries are found:
                        //
                        // The main analysis
                        $this->analyzeTemplate($templateMatches);

                        // Compile raw template data
                        $this->compileRawTemplateData($templateMatches);

                        // Are there some raw templates left for loading?
                        $this->loadExtraRawTemplates();

                        // Are some raw templates found and loaded?
                        if (count($this->rawTemplates) > 0) {

                                // Insert all raw templates
                                $this->insertRawTemplates();

                                // Remove the raw template content as well
                                $this->setRawTemplateData("");

                        } // END - if

                } // END - if($templateMatches ...
        }

        public function output () {
                // Check which type of template we have
                switch ($this->getTemplateType()) {
                case "html": // Raw HTML templates can be send to the output buffer
                        // Quick-N-Dirty:
                        $this->getWebOutputInstance()->output($this->getCompiledData());
                        break;

                default: // Unknown type found
                        // Construct message
                        $msg = sprintf("[%s-&gt;%s] Unknown/unsupported template type <span class=\"data\">%s</span> detected.",
                                $this->__toString(),
                                __FUNCTION__,
                                $this->getTemplateType()
                        );

                        // Write the problem to the world...
                        $this->debugOutput($msg);
                        break;
                }
        }

        protected function loadViewHelper ($helperName) {
                // Make first character upper case, rest low
                $helperName = ucfirst($helperName);

                // Is this view helper loaded?
                if (!isset($this->helpers[$helperName])) {
                        // Create a class name
                        $className = "{$helperName}ViewHelper";

                        // Does this class exists?
                        if (!class_exists($className)) {
                                // Abort here!
                                throw new ViewHelperNotFoundException(array($this, $helperName), self::EXCEPTION_INVALID_VIEW_HELPER);
                        } // END - if

                        // Generate new instance
                        $eval = sprintf("\$this->helpers[%s] = %s::create%s();",
                                $helperName,
                                $className,
                                $className
                        );

                        // Run the code
                        eval($eval);
                } // END - if

                // Return the requested instance
                return $this->helpers[$helperName];
        }

        public function assignTemplateWithVariable ($templateName, $variableName) {
                // Get the content from last loaded raw template
                $content = $this->getRawTemplateData();

                // Assign the variable
                $this->assignVariable($variableName, $content);

                // Purge raw content
                $this->setRawTemplateData("");
        }

        public function transferToResponse (Responseable $responseInstance) {
                // Get the content and set it in response class
                $responseInstance->writeToBody($this->getCompiledData());
        }

        public function assignApplicationData (ManageableApplication $appInstance) {
                // Get long name and assign it
                $this->assignVariable('app_full_name' , $appInstance->getAppName());

                // Get short name and assign it
                $this->assignVariable('app_short_name', $appInstance->getAppShortName());

                // Get version number and assign it
                $this->assignVariable('app_version'   , $appInstance->getAppVersion());

                // Assign extra application-depending data
                $appInstance->assignExtraTemplateData($this);
        }

        public function compileRawCode ($rawCode) {
                // Find the variables
                //* DEBUG: */ echo "rawCode=<pre>".htmlentities($rawCode)."</pre>\n";
                preg_match_all($this->regExpVarValue, $rawCode, $varMatches);

                // Compile all variables
                //* DEBUG: */ echo "<pre>".print_r($varMatches, true)."</pre>";
                foreach ($varMatches[0] as $match) {
                        // Add variable tags around it
                        $varCode = "{?".$match."?}";

                        // Is the variable found in code? (safes some calls)
                        if (strpos($rawCode, $varCode) !== false) {
                                // Replace the variable with it's value, if found
                                //* DEBUG: */ echo __METHOD__.": match=".$match."<br />\n";
                                $rawCode = str_replace($varCode, $this->readVariable($match), $rawCode);
                        } // END - if
                } // END - foreach

                // Return the compiled data
                return $rawCode;
        }

        public final function getVariableGroups () {
                return $this->varGroups;
        }

        public function renameVariable ($oldName, $newName) {
                //* DEBUG: */ echo __METHOD__.": oldName={$oldName}, newName={$newName}<br />\n";
                // Get raw template code
                $rawData = $this->getRawTemplateData();

                // Replace it
                $rawData = str_replace($oldName, $newName, $rawData);

                // Set the code back
                $this->setRawTemplateData($rawData);
        }

        public final function renderXmlContent ($content = null) {
                // Is the content set?
                if (is_null($content)) {
                        // Get current content
                        $content = $this->getRawTemplateData();
                } // END - if

                // Convert all to UTF8
                $content = recode("html..utf8", $content);

                // Get an XML parser
                $xmlParser = xml_parser_create();

                // Force case-folding to on
                xml_parser_set_option($xmlParser, XML_OPTION_CASE_FOLDING, true);

                // Set object
                xml_set_object($xmlParser, $this);

                // Set handler call-backs
                xml_set_element_handler($xmlParser, 'startElement', 'endElement');
                xml_set_character_data_handler($xmlParser, 'characterHandler');

                // Now parse the XML tree
                if (!xml_parse($xmlParser, $content)) {
                        // Error found in XML!
                        //die("<pre>".htmlentities($content)."</pre>");
                        throw new XmlParserException(array($this, $xmlParser), BaseHelper::EXCEPTION_XML_PARSER_ERROR);
                } // END - if

                // Free the parser
                xml_parser_free($xmlParser);
        }
}

// [EOF]
?>