Variable handling in template engine rewritten
[core.git] / inc / classes / main / template / class_BaseTemplateEngine.php
index 4b121a4febe93ae70082126205ccab4ecd254001..ecc71c22a7de080950dc59ca6e3fd2527d37c3ee 100644 (file)
@@ -4,7 +4,7 @@
  *
  * @author             Roland Haeder <webmaster@ship-simu.org>
  * @version            0.0.0
- * @copyright  Copyright (c) 2007 - 2009 Roland Haeder, this is free software
+ * @copyright  Copyright (c) 2007, 2008 Roland Haeder, 2009, 2010 Core Developer Team
  * @license            GNU GPL 3.0 or any newer version
  * @link               http://www.ship-simu.org
  *
@@ -27,27 +27,32 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * templates are stored. We will internally determine the language plus
         * "html" for web templates or "emails" for email templates
         */
-       private $basePath = '';
+       private $templateBasePath = '';
 
        /**
         * Template type
         */
-       private $templateType = "html";
+       private $templateType = 'html';
 
        /**
         * The extension for web and email templates (not compiled templates)
         */
-       private $templateExtension = ".tpl";
+       private $templateExtension = '.tpl';
 
        /**
         * The extension for code templates (not compiled templates)
         */
-       private $codeExtension = ".ctp";
+       private $codeExtension = '.ctp';
 
        /**
-        * Path relative to $basePath and language code for compiled code-templates
+        * Path relative to $templateBasePath and language code for compiled code-templates
         */
-       private $compileOutputPath = "templates/_compiled";
+       private $compileOutputPath = 'templates/_compiled/';
+
+       /**
+        * The path name for all templates
+        */
+       private $genericBasePath = 'templates/';
 
        /**
         * The raw (maybe uncompiled) template
@@ -116,10 +121,31 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        private $varGroups = array();
 
+       /**
+        * Code begin
+        */
+       private $codeBegin = '<?php';
+
+       /**
+        * Code end
+        */
+       private $codeEnd = '?>';
+
+       /**
+        * Language support is enabled by default
+        */
+       private $languageSupport = true;
+
+       /**
+        * XML compacting is disabled by default
+        */
+       private $xmlCompacting = false;
+
        // 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;
+       const EXCEPTION_VARIABLE_IS_MISSING           = 0x113;
 
        /**
         * Protected constructor
@@ -130,32 +156,32 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
        protected function __construct ($className) {
                // Call parent constructor
                parent::__construct($className);
-
-               // Clean up a little
-               $this->removeNumberFormaters();
-               $this->removeSystemArray();
        }
 
        /**
         * Search for a variable in the stack
         *
         * @param       $var    The variable we are looking for
-        * @return      $idx    FALSE means not found, >=0 means found on a specific index
+        * @param       $stack  Optional variable stack to look in
+        * @return      $index  FALSE means not found, >=0 means found on a specific index
         */
-       private function isVariableAlreadySet ($var) {
+       private function getVariableIndex ($var, $stack = null) {
                // First everything is not found
                $found = false;
 
+               // If the stack is null, use the current group
+               if (is_null($stack)) $stack = $this->currGroup;
+
                // Is the group there?
-               if (isset($this->varStack[$this->currGroup])) {
+               if ($this->isVarStackSet($stack)) {
                        // 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";
+                       foreach ($this->getVarStack($stack) as $index => $currEntry) {
+                               //* DEBUG: */ echo __METHOD__.":currGroup={$stack},idx={$index},currEntry={$currEntry['name']},var={$var}<br />\n";
                                // Is the entry found?
                                if ($currEntry['name'] == $var) {
                                        // Found!
                                        //* DEBUG: */ echo __METHOD__.":FOUND!<br />\n";
-                                       $found = $idx;
+                                       $found = $index;
                                        break;
                                } // END - if
                        } // END - foreach
@@ -165,29 +191,67 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                return $found;
        }
 
+       /**
+        * Checks wether the given variable stack is set
+        *
+        * @param       $stack  Variable stack to check
+        * @return      $isSet  Wether the given variable stack is set
+        */
+       protected final function isVarStackSet ($stack) {
+               // Check it
+               $isSet = isset($this->varStack[$stack]);
+
+               // Return result
+               return $isSet;
+       }
+
+       /**
+        * Getter for given variable stack
+        *
+        * @param       $stack          Variable stack to check
+        * @return      $varStack       Found variable stack
+        */
+       public final function getVarStack ($stack) {
+               return $this->varStack[$stack];
+       }
+
+       /**
+        * Setter for given variable stack
+        *
+        * @param       $stack          Variable stack to check
+        * @param       $varStack       Variable stack to check
+        * @return      void
+        */
+       protected final function setVarStack ($stack, array $varStack) {
+               $this->varStack[$stack]  = $varStack;
+       }
+
        /**
         * Return a content of a variable or null if not found
         *
         * @param       $var            The variable we are looking for
+        * @param       $stack          Optional variable stack to look in
         * @return      $content        Content of the variable or null if not found
         */
-       protected function readVariable ($var) {
+       protected function readVariable ($var, $stack = null) {
                // First everything is not found
                $content = null;
 
+               // If the stack is null, use the current group
+               if (is_null($stack)) $stack = $this->currGroup;
+
                // Get variable index
-               $found = $this->isVariableAlreadySet($var);
+               $found = $this->getVariableIndex($var, $stack);
 
                // Is the variable found?
                if ($found !== false) {
                        // Read it
-                       $found = $this->varStack[$this->currGroup][$found]['value'];
+                       $content = $this->getVariableValue($stack, $found);
                } // END - if
 
-               //* DEBUG: */ echo __METHOD__.": group=".$this->currGroup.",var=".$var.", found=".$found."<br />\n";
-
                // Return the current position
-               return $found;
+               //* DEBUG: */ echo __METHOD__.": group=".$stack.",var=".$var.", content[".gettype($content)."]=".$content."<br />\n";
+               return $content;
        }
 
        /**
@@ -215,9 +279,9 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                $result = array();
 
                // Is the group there?
-               if (isset($this->varStack[$this->currGroup])) {
+               if ($this->isVarStackSet($this->currGroup)) {
                        // Then use it
-                       $result = $this->varStack[$this->currGroup];
+                       $result = $this->getVarStack($this->currGroup);
                } // END - if
 
                // Return result
@@ -229,7 +293,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         *
         * @param       $groupName      Name of variable group
         * @param       $add            Wether add this group
-        * @retur4n     void
+        * @retur     void
         */
        public function setVariableGroup ($groupName, $add = true) {
                // Set group name
@@ -257,13 +321,22 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                $currVars = $this->readCurrentGroup();
 
                // Append our variable
-               $currVars[] = array(
-                       'name'  => $var,
-                       'value' => $value
-               );
+               $currVars[] = $this->generateVariableArray($var, $value);
 
                // Add it to the stack
-               $this->varStack[$this->currGroup] = $currVars;
+               $this->setVarStack($this->currGroup, $currVars);
+       }
+
+       /**
+        * Getter for variable value, throws a NoVariableException if the variable is not found
+        *
+        * @param       $varGroup       Variable group to use
+        * @param       $index          Index in variable array
+        * @return      $value          Value to set
+        */
+       private function getVariableValue ($varGroup, $index) {
+               // Return it
+               return $this->varStack[$varGroup][$index]['value'];
        }
 
        /**
@@ -272,26 +345,85 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * @param       $var    The variable we are looking for
         * @param       $value  The value we want to store in the variable
         * @return      void
+        * @throws      NoVariableException     If the given variable is not found
         */
        private function modifyVariable ($var, $value) {
                // Get index for variable
-               $idx = $this->isVariableAlreadySet($var);
+               $index = $this->getVariableIndex($var);
 
                // Is the variable set?
-               if ($idx !== false) {
-                       // Then modify it
-                       $this->varStack[$this->currGroup][$idx]['value'] = $value;
+               if ($index === false) {
+                       // Unset variables cannot be modified
+                       throw new NoVariableException(array($this, $var, $value), self::EXCEPTION_VARIABLE_IS_MISSING);
                } // END - if
+
+               // Then modify it
+               $this->setVariableValue($this->currGroup, $index, $value);
        }
 
        /**
-        * Setter for template type. Only "html", "emails" and "compiled" should
+        * Sets a variable value for given variable group and index
+        *
+        * @param       $varGroup       Variable group to use
+        * @param       $index          Index in variable array
+        * @param       $value          Value to set
+        * @return      void
+        */
+       private function setVariableValue ($varGroup, $index, $value) {
+               $this->varStack[$varGroup][$index]['value'] = $value;
+       }
+
+       /**
+        * Sets a variable within given group. This method does detect if the
+        * variable is already set. If so, the variable got modified, otherwise
+        * added.
+        *
+        * @param       $varGroup       Variable group to use
+        * @param       $var            Variable to set
+        * @param       $value          Value to set
+        * @return      void
+        */
+       protected function setVariable ($varGroup, $var, $value) {
+               // Get index for variable
+               $index = $this->getVariableIndex($var);
+
+               // Is the variable set?
+               if ($index === false) {
+                       // Not found, add it
+                       $this->varStack[$varGroup][] = $this->generateVariableArray($var, $value);
+               } else {
+                       // Then modify it
+                       $this->setVariableValue($this->currGroup, $index, $value);
+               }
+       }
+
+       /**
+        * "Generates" (better returns) an array for all variables for given
+        * variable/value pay.
+        *
+        * @param       $var            Variable to set
+        * @param       $value          Value to set
+        * @return      $varData        Variable data array
+        */
+       private function generateVariableArray ($var, $value) {
+               // Generate the temporary array
+               $varData = array(
+                       'name'  => $var,
+                       'value' => $value
+               );
+
+               // And return it
+               return $varData;
+       }
+
+       /**
+        * Setter for template type. Only 'html', 'emails' and 'compiled' should
         * be sent here
         *
         * @param       $templateType   The current template's type
         * @return      void
         */
-       private final function setTemplateType ($templateType) {
+       protected final function setTemplateType ($templateType) {
                $this->templateType = (string) $templateType;
        }
 
@@ -317,22 +449,32 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
        /**
         * Setter for base path
         *
-        * @param               $basePath               The local base path for all templates
+        * @param               $templateBasePath               The relative base path for all templates
         * @return      void
         */
-       public final function setBasePath ($basePath) {
+       public final function setTemplateBasePath ($templateBasePath) {
                // And set it
-               $this->basePath = (string) $basePath;
+               $this->templateBasePath = (string) $templateBasePath;
        }
 
        /**
         * Getter for base path
         *
-        * @return      $basePath               The local base path for all templates
+        * @return      $templateBasePath               The relative base path for all templates
+        */
+       public final function getTemplateBasePath () {
+               // And set it
+               return $this->templateBasePath;
+       }
+
+       /**
+        * Getter for generic base path
+        *
+        * @return      $templateBasePath               The relative base path for all templates
         */
-       public final function getBasePath () {
+       public final function getGenericBasePath () {
                // And set it
-               return $this->basePath;
+               return $this->genericBasePath;
        }
 
        /**
@@ -421,10 +563,10 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                } // END - if
 
                // First search for the variable if it was already added
-               $idx = $this->isVariableAlreadySet($var);
+               $index = $this->getVariableIndex($var);
 
                // Was it found?
-               if ($idx === false) {
+               if ($index === false) {
                        // Add it to the stack
                        //* DEBUG: */ echo "ADD: ".$var."<br />\n";
                        $this->addVariable($var, $value);
@@ -443,13 +585,13 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        public final function removeVariable ($var) {
                // First search for the variable if it was already added
-               $idx = $this->isVariableAlreadySet($var);
+               $index = $this->getVariableIndex($var);
 
                // Was it found?
-               if ($idx !== false) {
+               if ($index !== false) {
                        // Remove this variable
-                       $this->varStack->offsetUnset($idx);
-               }
+                       $this->varStack->offsetUnset($index);
+               } // END - if
        }
 
        /**
@@ -460,8 +602,8 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        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";
+               //* DEBUG: */ echo __METHOD__.':'.$this->getUniqueId().': '.strlen($rawTemplateData).' Bytes set.<br />\n';
+               //* DEBUG: */ echo $this->currGroup.' variables: '.count($this->getVarStack($this->currGroup)).', groups='.count($this->varStack).'<br />\n';
                $this->rawTemplateData = (string) $rawTemplateData;
        }
 
@@ -471,7 +613,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * @return      $rawTemplateData        The raw data from the template
         */
        public final function getRawTemplateData () {
-               //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($this->rawTemplateData)." Bytes read.<br />\n";
+               //* DEBUG: */ echo __METHOD__.':'.$this->getUniqueId().': '.strlen($this->rawTemplateData).' Bytes read.<br />\n';
                return $this->rawTemplateData;
        }
 
@@ -482,7 +624,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        private final function setCompiledData ($compiledData) {
                // And store it in this class
-               //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($compiledData)." Bytes set.<br />\n";
+               //* DEBUG: */ echo __METHOD__.':'.$this->getUniqueId().': '.strlen($compiledData).' Bytes set.<br />\n';
                $this->compiledData = (string) $compiledData;
        }
 
@@ -492,7 +634,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * @return      $compiledData   Compiled template data
         */
        public final function getCompiledData () {
-               //* DEBUG: */ echo __METHOD__.":".$this->getUniqueId().": ".strlen($this->compiledData)." Bytes read.<br />\n";
+               //* DEBUG: */ echo __METHOD__.':'.$this->getUniqueId().': '.strlen($this->compiledData).' Bytes read.<br />\n';
                return $this->compiledData;
        }
 
@@ -500,29 +642,62 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * Private loader for all template types
         *
         * @param       $template       The template we shall load
+        * @param       $extOther       An other extension to use
         * @return      void
+        * @throws      FileIoException If the template was not found
         */
-       private function loadTemplate ($template) {
-               // Get extension for the template
-               $ext = $this->getRawTemplateExtension();
+       protected function loadTemplate ($template, $extOther = '') {
+               // Get extension for the template if empty
+               if (empty($extOther)) {
+                       // None provided, so get the raw one
+                       $ext = $this->getRawTemplateExtension();
+               } else {
+                       // Then use it!
+                       $ext = (string) $extOther;
+               }
 
-               // 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
+               // Is language support enabled?
+               if ($this->isLanguageSupportEnabled()) {
+                       // Construct the FQFN for the template by honoring the current language
+                       $fqfn = sprintf("%s%s%s%s/%s/%s%s",
+                               $this->getConfigInstance()->getConfigEntry('base_path'),
+                               $this->getTemplateBasePath(),
+                               $this->getGenericBasePath(),
+                               $this->getLanguageInstance()->getLanguageCode(),
+                               $this->getTemplateType(),
+                               (string) $template,
+                               $ext
+                       );
+               } else {
+                       // Construct the FQFN for the template without language
+                       $fqfn = sprintf("%s%s%s%s/%s%s",
+                               $this->getConfigInstance()->getConfigEntry('base_path'),
+                               $this->getTemplateBasePath(),
+                               $this->getGenericBasePath(),
+                               $this->getTemplateType(),
+                               (string) $template,
+                               $ext
+                       );
+               }
 
-               // 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
-               );
+               // First try this
+               try {
+                       // Load the raw template data
+                       $this->loadRawTemplateData($fqfn);
+               } catch (FileIoException $e) {
+                       // If we shall load a code-template we need to switch the file extension
+                       if (($this->getTemplateType() != $this->getConfigInstance()->getConfigEntry('web_template_type')) && (empty($extOther))) {
+                               // Switch over to the code-template extension and try it again
+                               $ext = $this->getCodeTemplateExtension();
+
+                               // Try it again...
+                               $this->loadTemplate($template, $ext);
+                       } else {
+                               // Throw it again
+                               throw new FileIoException($fqfn, FrameworkFileInputPointer::EXCEPTION_FILE_NOT_FOUND);
+                       }
+               }
 
-               // Load the raw template data
-               $this->loadRawTemplateData($fqfn);
        }
 
        /**
@@ -606,9 +781,9 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * Structure of $templateMatches:
         *---------------------------------
         * [0] => Array - An array with all full matches
-        * [1] => Array - An array with left part (before the ":") of a match
-        * [2] => Array - An array with right part of a match including ":"
-        * [3] => Array - An array with right part of a match excluding ":"
+        * [1] => Array - An array with left part (before the ':') of a match
+        * [2] => Array - An array with right part of a match including ':'
+        * [3] => Array - An array with right part of a match excluding ':'
         */
        private function analyzeTemplate (array $templateMatches) {
                // Backup raw template data
@@ -626,15 +801,15 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
 
                                // Template not found, but maybe variable assigned?
                                //* DEBUG: */ echo __METHOD__.":template={$template}<br />\n";
-                               if ($this->isVariableAlreadySet($template) !== false) {
+                               if ($this->getVariableIndex($template) !== false) {
                                        // Use that content here
                                        $this->loadedRawData[$template] = $this->readVariable($template);
 
                                        // Recursive protection:
                                        $this->loadedTemplates[] = $template;
-                               } elseif (isset($this->varStack['config'][$template])) {
+                               } elseif ($this->getVariableIndex($template, 'config')) {
                                        // Use that content here
-                                       $this->loadedRawData[$template] = $this->varStack['config'][$template];
+                                       $this->loadedRawData[$template] = $this->readVariable($template, 'config');
 
                                        // Recursive protection:
                                        $this->loadedTemplates[] = $template;
@@ -648,10 +823,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                                                // 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) {
+                                       } catch (FileIoException $e) {
                                                // Even this is not done... :/
                                                $this->rawTemplates[] = $template;
                                        }
@@ -750,10 +922,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                                        // 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) {
+                               } catch (FileIoException $e) {
                                        // This template was never found. We silently ignore it
                                        unset($this->rawTemplates[$key]);
                                }
@@ -773,18 +942,18 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                foreach ($varMatches[1] as $key => $var) {
 
                        // Detect leading equals
-                       if (substr($varMatches[2][$key], 0, 1) == "=") {
+                       if (substr($varMatches[2][$key], 0, 1) == '=') {
                                // Remove and cast it
                                $varMatches[2][$key] = (string) substr($varMatches[2][$key], 1);
-                       }
+                       } // END - if
 
                        // 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) == "\'')) {
+                       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!");
+                               // @TODO Non-string found so we need some deeper analysis...
+                               ApplicationEntryPoint::app_die('Deeper analysis not yet implemented!');
                        }
 
                } // for ($varMatches ...
@@ -792,7 +961,7 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
        /**
         * Compiles all loaded raw templates
         *
-        * @param               $templateMatches        See method analyzeTemplate() for details
+        * @param       $templateMatches        See method analyzeTemplate() for details
         * @return      void
         */
        private function compileRawTemplateData (array $templateMatches) {
@@ -854,23 +1023,30 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
        private function finalizeVariableCompilation () {
                // Get the content
                $content = $this->getRawTemplateData();
-               //* DEBUG: */ echo __METHOD__.": content before=".strlen($content)." (".md5($content).")<br />\n";
+               //* DEBUG: */ echo __METHOD__.': content before='.strlen($content).' ('.md5($content).')<br />\n';
+
+               // Do we have the stack?
+               if (!$this->isVarStackSet('general')) {
+                       // Abort here silently
+                       // @TODO This silent abort should be logged, maybe.
+                       return;
+               } // END - if
 
                // Walk through all variables
-               foreach ($this->varStack['general'] as $currEntry) {
-                       //* DEBUG: */ echo __METHOD__.": name=".$currEntry['name'].", value=<pre>".htmlentities($currEntry['value'])."</pre>\n";
+               foreach ($this->getVarStack('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);
+                       // @TODO 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);
+                       // @TODO Yet another old way
+                       $content = str_replace('[' . $currEntry['name'] . ']', $currEntry['value'], $content);
 
                        // The new behaviour
-                       $content = str_replace("{?".$currEntry['name']."?}", $currEntry['value'], $content);
+                       $content = str_replace('{?' . $currEntry['name'] . '?}', $currEntry['value'], $content);
                } // END - for
 
-               //* DEBUG: */ echo __METHOD__.": content after=".strlen($content)." (".md5($content).")<br />\n";
+               //* DEBUG: */ echo __METHOD__.': content after='.strlen($content).' ('.md5($content).')<br />\n';
 
                // Set the content back
                $this->setRawTemplateData($content);
@@ -880,12 +1056,12 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * Load a specified web template into the engine
         *
         * @param       $template       The web template we shall load which is located in
-        *                                              "html" by default
+        *                                              'html' by default
         * @return      void
         */
        public function loadWebTemplate ($template) {
                // Set template type
-               $this->setTemplateType($this->getConfigInstance()->readConfig('web_template_type'));
+               $this->setTemplateType($this->getConfigInstance()->getConfigEntry('web_template_type'));
 
                // Load the special template
                $this->loadTemplate($template);
@@ -899,38 +1075,51 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        public function assignConfigVariable ($var) {
                // Sweet and simple...
-               //* DEBUG: */ echo __METHOD__.":var={$var}<br />\n";
-               $this->varStack['config'][$var] = $this->getConfigInstance()->readConfig($var);
+               //* DEBUG: */ echo __METHOD__.':var={$var}<br />\n';
+               $this->setVariable('config', $var, $this->getConfigInstance()->getConfigEntry($var));
        }
 
        /**
-        * Load a specified email template into the engine
+        * Load a specified code template into the engine
         *
-        * @param       $template       The email template we shall load which is located in
-        *                                              "emails" by default
+        * @param       $template       The code template we shall load which is
+        *                                              located in 'code' by default
         * @return      void
         */
-       public function loadEmailTemplate ($template) {
+       public function loadCodeTemplate ($template) {
                // Set template type
-               $this->setTemplateType($this->getConfigInstance()->readConfig('email_template_type'));
+               $this->setTemplateType($this->getConfigInstance()->getConfigEntry('code_template_type'));
 
                // Load the special template
                $this->loadTemplate($template);
        }
 
        /**
-        * Load a specified code template into the engine
+        * Compiles configuration place-holders in all variables. This 'walks'
+        * through the variable stack 'general'. It interprets all values from that
+        * variables as configuration entries after compiling them.
         *
-        * @param       $template       The code template we shall load which is
-        *                                              located in "code" by default
         * @return      void
         */
-       public function loadCodeTemplate ($template) {
-               // Set template type
-               $this->setTemplateType($this->getConfigInstance()->readConfig('code_template_type'));
+       public final function compileConfigInVariables () {
+               // Do we have the stack?
+               if (!$this->isVarStackSet('general')) {
+                       // Abort here silently
+                       // @TODO This silent abort should be logged, maybe.
+                       return;
+               } // END - if
 
-               // Load the special template
-               $this->loadTemplate($template);
+               // Iterate through all general variables
+               foreach ($this->getVarStack('general') as $index=>$currVariable) {
+                       // Compile the value
+                       $value = $this->compileRawCode($this->readVariable($currVariable['name']), true);
+
+                       // Remove it from stack
+                       $this->removeVariable($index, 'general');
+
+                       // Re-assign the variable
+                       $this->assignConfigVariable($value);
+               } // END - foreach
        }
 
        /**
@@ -941,13 +1130,13 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        public final function compileVariables () {
                // Initialize the $content array
-               $validVar = $this->getConfigInstance()->readConfig('tpl_valid_var');
+               $validVar = $this->getConfigInstance()->getConfigEntry('tpl_valid_var');
                $dummy = array();
 
                // Iterate through all general variables
-               foreach ($this->varStack['general'] as $currVariable) {
+               foreach ($this->getVarStack('general') as $currVariable) {
                        // Transfer it's name/value combination to the $content array
-                       //* DEBUG: */ echo $currVariable['name']."=<pre>".htmlentities($currVariable['value'])."</pre>\n";
+                       //* DEBUG: */ echo $currVariable['name'].'=<pre>'.htmlentities($currVariable['value']).'</pre>\n';
                        $dummy[$currVariable['name']] = $currVariable['value'];
                }// END - if
 
@@ -956,15 +1145,15 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
 
                // Prepare all configuration variables
                $config = null;
-               if (isset($this->varStack['config'])) {
-                       $config = $this->varStack['config'];
+               if ($this->isVarStackSet('config')) {
+                       $config = $this->getVarStack('config');
                } // END - if
 
                // Remove some variables
-               unset($idx);
+               unset($index);
                unset($currVariable);
 
-               // Run the compilation twice to get content from helper classes in
+               // Run the compilation three times to get content from helper classes in
                $cnt = 0;
                while ($cnt < 3) {
                        // Finalize the compilation of template variables
@@ -976,19 +1165,19 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                        );
 
                        // This loop does remove the backslashes (\) in PHP parameters
-                       while (strpos($eval, "<?php") !== false) {
+                       while (strpos($eval, $this->codeBegin) !== false) {
                                // Get left part before "<?"
-                               $evalLeft = substr($eval, 0, strpos($eval, "<?php"));
+                               $evalLeft = substr($eval, 0, strpos($eval, $this->codeBegin));
 
                                // Get all from right of "<?"
-                               $evalRight = substr($eval, (strpos($eval, "<?php") + 5));
+                               $evalRight = substr($eval, (strpos($eval, $this->codeBegin) + 5));
 
                                // Cut middle part out and remove escapes
-                               $evalMiddle = trim(substr($evalRight, 0, strpos($evalRight, "?>")));
+                               $evalMiddle = trim(substr($evalRight, 0, strpos($evalRight, $this->codeEnd)));
                                $evalMiddle = stripslashes($evalMiddle);
 
                                // Remove the middle part from right one
-                               $evalRight = substr($evalRight, (strpos($evalRight, "?>") + 2));
+                               $evalRight = substr($evalRight, (strpos($evalRight, $this->codeEnd) + 2));
 
                                // And put all together
                                $eval = sprintf("%s<%%php %s %%>%s", $evalLeft, $evalMiddle, $evalRight);
@@ -998,15 +1187,17 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                        $eval = str_replace(
                                "<%php", "\";",
                                str_replace(
-                                       "%>", "\n\$result .= \'', $eval
+                                       "%>",
+                                       "\n\$result .= \"",
+                                       $eval
                                )
                        );
 
                        // Run the constructed command. This will "compile" all variables in
-                       @eval($eval);
+                       eval($eval);
 
                        // Goes something wrong?
-                       if (!isset($result)) {
+                       if ((!isset($result)) || (empty($result))) {
                                // Output eval command
                                $this->debugOutput(sprintf("Failed eval() code: <pre>%s</pre>", $this->markupCode($eval, true)), true);
 
@@ -1037,16 +1228,16 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         */
        public function compileTemplate () {
                // We will only work with template type "code" from configuration
-               if ($this->getTemplateType() != $this->getConfigInstance()->readConfig('code_template_type')) {
+               if ($this->getTemplateType() != $this->getConfigInstance()->getConfigEntry('code_template_type')) {
                        // Abort here
-                       throw new UnexpectedTemplateTypeException(array($this, $this->getTemplateType(), $this->getConfigInstance()->readConfig('code_template_type')), self::EXCEPTION_TEMPLATE_TYPE_IS_UNEXPECTED);
+                       throw new UnexpectedTemplateTypeException(array($this, $this->getTemplateType(), $this->getConfigInstance()->getConfigEntry('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));
+               $rawData = trim(str_replace('  ', ' ', $rawData));
 
                // Search for raw variables
                $this->extractVariablesFromRawData($rawData);
@@ -1081,41 +1272,11 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                } // END - if($templateMatches ...
        }
 
-       /**
-        * A old deprecated method
-        *
-        * @return      void
-        * @deprecated
-        * @see         BaseTemplateEngine::transferToResponse
-        */
-       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;
-               }
-       }
-
        /**
         * Loads a given view helper (by name)
         *
         * @param       $helperName             The helper's name
         * @return      void
-        * @throws      ViewHelperNotFoundException     If the given view helper was not found
         */
        protected function loadViewHelper ($helperName) {
                // Make first character upper case, rest low
@@ -1126,21 +1287,8 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
                        // 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);
+                       $this->helpers[$helperName] = ObjectFactory::createObjectByName($className);
                } // END - if
 
                // Return the requested instance
@@ -1199,29 +1347,38 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
        /**
         * "Compiles" a variable by replacing {?var?} with it's content
         *
-        * @param       $rawCode        Raw code to compile
+        * @param       $rawCode                        Raw code to compile
+        * @param       $setMatchAsCode         Sets $match if readVariable() returns empty result
         * @return      $rawCode        Compile code with inserted variable value
         */
-       public function compileRawCode ($rawCode) {
+       public function compileRawCode ($rawCode, $setMatchAsCode=false) {
                // Find the variables
-               //* DEBUG: */ echo "rawCode=<pre>".htmlentities($rawCode)."</pre>\n";
+               //* DEBUG: */ echo __METHOD__.":rawCode=<pre>".htmlentities($rawCode)."</pre>\n";
                preg_match_all($this->regExpVarValue, $rawCode, $varMatches);
 
                // Compile all variables
-               //* DEBUG: */ echo "<pre>".print_r($varMatches, true)."</pre>";
+               //* DEBUG: */ echo __METHOD__.":<pre>".print_r($varMatches, true)."</pre>\n";
                foreach ($varMatches[0] as $match) {
                        // Add variable tags around it
-                       $varCode = "{?".$match."?}";
+                       $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);
+                               $value = $this->readVariable($match);
+                               //* DEBUG: */ echo __METHOD__.": match=".$match.",value[".gettype($value)."]=".$value."<br />\n";
+                               if (($setMatchAsCode === true) && (is_null($value))) {
+                                       // Insert match
+                                       $rawCode = str_replace($varCode, $match, $rawCode);
+                               } else {
+                                       // Insert value
+                                       $rawCode = str_replace($varCode, $value, $rawCode);
+                               }
                        } // END - if
                } // END - foreach
 
                // Return the compiled data
+               //* DEBUG: */ echo __METHOD__.":rawCode=<pre>".htmlentities($rawCode)."</pre>\n";
                return $rawCode;
        }
 
@@ -1260,42 +1417,62 @@ class BaseTemplateEngine extends BaseFrameworkSystem {
         * @return      void
         * @throws      XmlParserException      If an XML error was found
         */
-       public final function renderXmlContent ($content = null) {
+       public function renderXmlContent ($content = null) {
                // Is the content set?
                if (is_null($content)) {
                        // Get current content
                        $content = $this->getRawTemplateData();
                } // END - if
 
-               // Convert all to UTF8
-               if (function_exists('recode')) {
-                       $content = recode("html..utf8", $content);
-               } else {
-                       // @TODO We need to find a fallback solution here
-               } // END - if
+               // Get a XmlParser instance
+               $parserInstance = ObjectFactory::createObjectByConfiguredName('xml_parser_class', array($this));
 
-               // Get an XML parser
-               $xmlParser = xml_parser_create();
+               // Check if we have XML compacting enabled
+               if ($this->isXmlCompactingEnabled()) {
+                       // Yes, so get a decorator class for transparent compacting
+                       $parserInstance = ObjectFactory::createObjectByConfiguredName('deco_compacting_xml_parser_class', array($parserInstance));
+               } // END - if
 
-               // Force case-folding to on
-               xml_parser_set_option($xmlParser, XML_OPTION_CASE_FOLDING, true);
+               // Parse the XML document
+               $parserInstance->parseXmlContent($content);
+       }
 
-               // Set object
-               xml_set_object($xmlParser, $this);
+       /**
+        * Enables or disables language support
+        *
+        * @param       $languageSupport        New language support setting
+        * @return      void
+        */
+       public final function enableLanguageSupport ($languageSupport = true) {
+               $this->languageSupport = (bool) $languageSupport;
+       }
 
-               // Set handler call-backs
-               xml_set_element_handler($xmlParser, 'startElement', 'endElement');
-               xml_set_character_data_handler($xmlParser, 'characterHandler');
+       /**
+        * Checks wether language support is enabled
+        *
+        * @return      $languageSupport        Wether language support is enabled or disabled
+        */
+       public final function isLanguageSupportEnabled () {
+               return $this->languageSupport;
+       }
 
-               // 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
+       /**
+        * Enables or disables XML compacting
+        *
+        * @param       $xmlCompacting  New XML compacting setting
+        * @return      void
+        */
+       public final function enableXmlCompacting ($xmlCompacting = true) {
+               $this->xmlCompacting = (bool) $xmlCompacting;
+       }
 
-               // Free the parser
-               xml_parser_free($xmlParser);
+       /**
+        * Checks wether XML compacting is enabled
+        *
+        * @return      $xmlCompacting  Wether XML compacting is enabled or disabled
+        */
+       public final function isXmlCompactingEnabled () {
+               return $this->xmlCompacting;
        }
 }