From: Roland Häder <roland@mxchange.org>
Date: Sat, 25 Feb 2023 23:58:45 +0000 (+0100)
Subject: Continued:
X-Git-Url: https://git.mxchange.org/?a=commitdiff_plain;h=53f5e597b72bedb2995dca43e04d88f37eaa5e88;p=core.git

Continued:
- added way (!) more thrown exceptions
- added more debug lines
- configuration variable 'html_template_type' is now statically "cached"
---

diff --git a/framework/main/classes/template/class_BaseTemplateEngine.php b/framework/main/classes/template/class_BaseTemplateEngine.php
index 3594bb7b..b49f8d7d 100644
--- a/framework/main/classes/template/class_BaseTemplateEngine.php
+++ b/framework/main/classes/template/class_BaseTemplateEngine.php
@@ -17,6 +17,7 @@ use Org\Mxchange\CoreFramework\Traits\Handler\Io\IoHandlerTrait;
 use Org\Mxchange\CoreFramework\Utils\Strings\StringUtils;
 
 // Import SPL stuff
+use \BadMethodCallException;
 use \InvalidArgumentException;
 use \SplFileInfo;
 
@@ -52,6 +53,11 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	const EXCEPTION_INVALID_VIEW_HELPER           = 0x112;
 	const EXCEPTION_VARIABLE_IS_MISSING           = 0x113;
 
+	/**
+	 * HTML template type
+	 */
+	private static $htmlTemplateType = 'invalid';
+
 	/**
 	 * The local path name where all templates and sub folders for special
 	 * templates are stored. We will internally determine the language plus
@@ -179,13 +185,21 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	protected function __construct (string $className) {
 		// Call parent constructor
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: className=%s - CONSTRUCTED!', $className));
 		parent::__construct($className);
 
 		// Init file I/O instance
 		$ioInstance = ObjectFactory::createObjectByConfiguredName('file_io_class');
 
 		// Set it
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: ioInstance=%s', $ioInstance->__toString()));
 		$this->setFileIoInstance($ioInstance);
+
+		// "Cache" config entry
+		self::$htmlTemplateType = FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('html_template_type');
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: self::htmlTemplateType=%s - EXIT!', self::$htmlTemplateType));
 	}
 
 	/**
@@ -197,27 +211,30 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function getVariableIndex (string $variableName, string $variableGroup = NULL) {
 		// Replace all dashes to underscores to match variables with configuration entries
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,variableGroup[%s]=%s - CALLED!', $variableName, gettype($variableGroup), $variableGroup));
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// First everything is not found
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableName=%s', $variableName));
 		$found = false;
 
 		// If the stack is NULL, use the current group
 		if (is_null($variableGroup)) {
 			// Use current group
-			//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.' currGroup=' . $this->currGroup . ' set as stack!');
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->currGroup=%s set as stack!', $this->currGroup));
 			$variableGroup = $this->currGroup;
 		}
 
 		// Is the group there?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableGroup=%s', $variableGroup));
 		if ($this->isVarStackSet($variableGroup)) {
 			// Now search for it
 			foreach ($this->getVarStack($variableGroup) as $index => $currEntry) {
-				//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.':currGroup=' . $variableGroup . ',idx=' . $index . ',currEntry=' . $currEntry['name'] . ',variableName=' . $variableName);
 				// Is the entry found?
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: index=%d,currGroup=%s,currEntry[name]=%s,variableName=%s', $index, $variableGroup, $currEntry['name'], $variableName));
 				if ($currEntry['name'] == $variableName) {
 					// Found!
-					//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.':FOUND!');
+					/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: index=%d - BREAK!', $index));
 					$found = $index;
 					break;
 				}
@@ -225,6 +242,7 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		}
 
 		// Return the current position
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: found=%d - EXIT!', $found));
 		return $found;
 	}
 
@@ -233,13 +251,22 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 *
 	 * @param	$variableGroup	Variable group to check
 	 * @return	$isSet			Whether the given variable group is set
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	protected final function isVarStackSet (string $variableGroup) {
+		// Validate parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s - CALLED!', $variableName));
+		if (empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Check it
-		$isSet = isset($this->varStack[$variableGroup]);
+		$isset = isset($this->varStack[$variableGroup]);
 
 		// Return result
-		return $isSet;
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: isset=%d - EXIT!', intval($isset)));
+		return $isset;
 	}
 
 	/**
@@ -247,8 +274,18 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 *
 	 * @param	$variableGroup	Variable group to check
 	 * @return	$varStack		Found variable group
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public final function getVarStack (string $variableGroup) {
+		// Validate parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s - CALLED!', $variableName));
+		if (empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
+		// Return value
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: this->varStack[%s]()=%d - EXIT!', $variableName, count($this->varStack[$variableGroup])));
 		return $this->varStack[$variableGroup];
 	}
 
@@ -258,9 +295,21 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableGroup	Variable group to check
 	 * @param	$varStack		Variable stack to check
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	protected final function setVarStack (string $variableGroup, array $varStack) {
+		// Validate parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,varStack()=%d - CALLED!', $variableName, count($varStack)));
+		if (empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
+		// Set var stack
 		$this->varStack[$variableGroup]  = $varStack;
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -269,18 +318,30 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableName	The variable we are looking for
 	 * @param	$variableGroup	Optional variable group to look in
 	 * @return	$content		Content of the variable or null if not found
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	protected function readVariable (string $variableName, string $variableGroup = NULL) {
+		// Check parameters
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,variableGroup[%s]=%s - CALLED!', $variableName, gettype($variableGroup), $variableGroup));
+		if (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (!is_null($variableGroup) && empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Replace all dashes to underscores to match variables with configuration entries
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// First everything is not found
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableName=%s', $variableName));
 		$content = NULL;
 
 		// If the stack is NULL, use the current group
 		if (is_null($variableGroup)) {
 			// Use current group
-			//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.' currGroup=' . $this->currGroup . ' set as stack!');
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->currGroup=%s set as stack!', $this->currGroup));
 			$variableGroup = $this->currGroup;
 		}
 
@@ -288,13 +349,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		$found = $this->getVariableIndex($variableName, $variableGroup);
 
 		// Is the variable found?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: found[]=%s', gettype($found)));
 		if ($found !== false) {
 			// Read it
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->getVariableValue(%s,%s) ...', $variableGroup, $found));
 			$content = $this->getVariableValue($variableGroup, $found);
 		}
 
 		// Return the current position
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.': variableGroup=' . $variableGroup . ',variableName=' . $variableName . ', content[' . gettype($content) . ']=' . $content);
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: content()=%d - EXIT!', strlen($content)));
 		return $content;
 	}
 
@@ -307,10 +370,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function addVariable (string $variableName, $value) {
 		// Set general variable group
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,value[]=%s - CALLED!', $variableName, gettype($value)));
 		$this->setVariableGroup('general');
 
 		// Add it to the stack
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->addVariableGroup(%s,value[]=%s) ...', $variableName, gettype($value)));
 		$this->addGroupVariable($variableName, $value);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -320,15 +388,19 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function readCurrentGroup () {
 		// Default is not found
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: CALLED!');
 		$result = [];
 
 		// Is the group there?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->currGroup=%s', $this->currGroup));
 		if ($this->isVarStackSet($this->currGroup)) {
 			// Then use it
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->getVarStack(%s) ...', $this->currGroup));
 			$result = $this->getVarStack($this->currGroup);
 		}
 
 		// Return result
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: result()=%d - EXIT!', count($result)));
 		return $result;
 	}
 
@@ -338,18 +410,29 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$groupName	Name of variable group
 	 * @param	$add		Whether add this group
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function setVariableGroup (string $groupName, bool $add = true) {
+		// Check parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: groupName=%s,add=%d - CALLED!', $groupName, intval($add)));
+		if (empty($groupName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "groupName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Set group name
-		//* DEBIG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.': currGroup=' . $groupName);
 		$this->currGroup = $groupName;
 
 		// Skip group 'general'
 		if (($groupName != 'general') && ($add === true)) {
+			// Mark as 'OK'
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Marking groupName=%s as OK ...', $groupdName));
 			$this->variableGroups[$groupName] = 'OK';
 		}
-	}
 
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
+	}
 
 	/**
 	 * Adds a variable to current group
@@ -357,34 +440,54 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableName	Variable to set
 	 * @param	$value			Value to store in variable
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function addGroupVariable (string $variableName, $value) {
+		// Check parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,value[]=%s - CALLED!', $variableName, gettype($value)));
+		if (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (is_object($value) || is_resource($value)) {
+			// Throw an exception
+			throw new InvalidArgumentException(sprintf('value[]=%s is not supported', gettype($value)), FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Replace all dashes to underscores to match variables with configuration entries
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking StringUtils::convertDashesToUnderscores(%s) ...', $variableName));
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
-		// Debug message
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.': group=' . $this->currGroup . ', variableName=' . $variableName . ', value=' . $value);
-
 		// Get current variables in group
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->currGroup=%s,variableName=%s,value[]=%s', $this->currGroup, $variableName, gettype($value)));
 		$currVars = $this->readCurrentGroup();
 
 		// Append our variable
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: currVars()=%d - BEFORE!', count($currVars)));
 		array_push($currVars, $this->generateVariableArray($variableName, $value));
 
 		// Add it to the stack
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setVarStack(%s,currVars()=%d) - AFTER!', $this->currGroup, count($currVars)));
 		$this->setVarStack($this->currGroup, $currVars);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
 	 * Getter for variable value, throws a NoVariableException if the variable is not found
 	 *
 	 * @param	$variableGroup	Variable group to use
-	 * @param	$index		Index in variable array
-	 * @return	$value		Value to set
+	 * @param	$index	Index in variable array
+	 * @return	$value	Value to set
 	 */
 	private function getVariableValue (string $variableGroup, int $index) {
 		// Return it
-		return $this->varStack[$variableGroup][$index]['value'];
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableGroup=%s,index[]=%d - CALLED!', $variableGroup, $index));
+		$value = $this->varStack[$variableGroup][$index]['value'];
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: value[]=%s - EXIT!', gettype($value)));
+		return $value;
 	}
 
 	/**
@@ -393,23 +496,22 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableName	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 (string $variableName, $value) {
 		// Replace all dashes to underscores to match variables with configuration entries
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,value[]=%s - CALLED!', $variableName, gettype($value)));
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// Get index for variable
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: this->getVariableIndex(%s) ...', $variableName));
 		$index = $this->getVariableIndex($variableName);
 
-		// Is the variable set?
-		if ($index === false) {
-			// Unset variables cannot be modified
-			throw new NoVariableException(array($this, $variableName, $value), self::EXCEPTION_VARIABLE_IS_MISSING);
-		}
-
 		// Then modify it
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: this->setVariableValue(%s,%d,value[]=%s) ...', $this->currGroup, $index, gettype($value)));
 		$this->setVariableValue($this->currGroup, $index, $value);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -421,7 +523,12 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @return	void
 	 */
 	private function setVariableValue (string $variableGroup, int $index, $value) {
+		// Set variable
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableGroup=%s,index[]=%d,value[]=%s - CALLED!', $variableGroup, $index, gettype($value)));
 		$this->varStack[$variableGroup][$index]['value'] = $value;
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -433,28 +540,47 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableName	Variable to set
 	 * @param	$value			Value to set
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	protected function setVariable (string $variableGroup, string $variableName, $value) {
+		// Check parameters
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableGroup=%s,variableName=%s,value[]=%s - CALLED!', $variableGroup, $variableName, gettype($value)));
+		if (empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Replace all dashes to underscores to match variables with configuration entries
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// Get index for variable
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: this->getVariableIndex(%s) ...', $variableName));
 		$index = $this->getVariableIndex($variableName);
 
 		// Is the variable set?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: index[]=%s', gettype($index)));
 		if ($index === false) {
 			// Is the stack there?
 			if (!isset($this->varStack[$variableGroup])) {
 				// Then initialize it here
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Initializing this->varStack[%s] ...', $variableGroup));
 				$this->varStack[$variableGroup] = [];
 			}
 
 			// Not found, add it
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Pushing variableGroup=%s,variableName=%s,value[]=%s ...', $variableGroup, $variableName, gettype($value)));
 			array_push($this->varStack[$variableGroup], $this->generateVariableArray($variableName, $value));
 		} else {
 			// Then modify it
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setVariableValue(%s,%d,value[]=%s) ...', $this->currGroup, $index, gettype($value)));
 			$this->setVariableValue($this->currGroup, $index, $value);
 		}
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -467,15 +593,17 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function generateVariableArray (string $variableName, $value) {
 		// Replace all dashes to underscores to match variables with configuration entries
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,value[]=%s - CALLED!', $variableName, gettype($value)));
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// Generate the temporary array
-		$varData = array(
+		$varData = [
 			'name'  => $variableName,
 			'value' => $value
-		);
+		];
 
 		// And return it
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: varData()=%d - EXIT!', count($varData)));
 		return $varData;
 	}
 
@@ -613,22 +741,40 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$index			Index to unset
 	 * @param	$variableGroup	Variable group (default: currGroup)
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
+	 * @throws	BadMethodCallException	If this method was called but combination of variableGroup/index isn't found
 	 */
 	protected final function unsetVariableStackOffset (int $index, string $variableGroup = NULL) {
+		// Check variables
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: index=%d,variableGroup[%s]=%s - CALLED!', $index, gettype($variableGroup), $variableGroup));
+		if ($index < 0) {
+			// Invalid index
+			throw new InvalidArgumentException(sprintf('index=%d is below zero', $index), FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (!is_null($variableGroup) && empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Is the variable group not set?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableGroup[]=%s', gettype($variableGroup)));
 		if (is_null($variableGroup)) {
 			// Then set it to current
 			$variableGroup = $this->currGroup;
 		}
 
 		// Is the entry there?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Checking variableGroup=%s,index=%d ...', $variableGroup, $index));
 		if (!isset($this->varStack[$variableGroup][$index])) {
 			// Abort here, we need fixing!
-			$this->debugInstance();
+			throw new BadMethodCallException(sprintf('variableGroup=%s,index=%d does not exist, but method was invoked', $variableGroup, $index), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
 		}
 
 		// Remove it
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Unsetting variableGroup=%s,index=%d ...', $variableGroup, $index));
 		unset($this->varStack[$variableGroup][$index]);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -639,8 +785,6 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	protected final function setRawTemplateData (string $rawTemplateData) {
 		// And store it in this class
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.': ' . strlen($rawTemplateData) . ' Bytes set.');
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(__METHOD__.': ' . $this->currGroup . ' variables: ' . count($this->getVarStack($this->currGroup)) . ', groups=' . count($this->varStack));
 		$this->rawTemplateData = $rawTemplateData;
 	}
 
@@ -650,7 +794,6 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @return	$rawTemplateData	The raw data from the template
 	 */
 	public final function getRawTemplateData () {
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: ' . strlen($this->rawTemplateData) . ' Bytes read.');
 		return $this->rawTemplateData;
 	}
 
@@ -662,7 +805,6 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private final function setCompiledData (string $compiledData) {
 		// And store it in this class
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: ' . strlen($compiledData) . ' Bytes set.');
 		$this->compiledData = $compiledData;
 	}
 
@@ -672,7 +814,6 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @return	$compiledData	Compiled template data
 	 */
 	public final function getCompiledData () {
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: ' . strlen($this->compiledData) . ' Bytes read.');
 		return $this->compiledData;
 	}
 
@@ -682,9 +823,17 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$templateName	The template we shall load
 	 * @param	$extOther	An other extension to use
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 * @throws	FileNotFoundException	If the template was not found
 	 */
 	protected function loadTemplate (string $templateName, string $extOther = '') {
+		// Check parameter
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: templateName=%s,extOther=%s - CALLED!', $templateName, $extOther));
+		if (empty($templateName)) {
+			// Throw IAE
+			throw new InvalidArgumentException('Parameter "templateName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Get extension for the template if empty
 		if (empty($extOther)) {
 			// None provided, so get the raw one
@@ -699,6 +848,7 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		 * now entirely done by php_intl. These old thing with language-based
 		 * template paths comes from an older time.
 		 */
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: ext=%s', $ext));
 		$fileInstance = new SplFileInfo(sprintf('%s%s%s%s%s%s',
 			$this->getTemplateBasePath(),
 			$this->getGenericBasePath(),
@@ -709,16 +859,20 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		));
 
 		// First try this
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: fileInstance=%s', $fileInstance->__toString()));
 		try {
 			// Load the raw template data
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->loadRawTemplateData(%s) ...', $fileInstance->__toString()));
 			$this->loadRawTemplateData($fileInstance);
 		} catch (FileNotFoundException $e) {
 			// If we shall load a code-template we need to switch the file extension
-			if (($this->getTemplateType() != FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('html_template_type')) && (empty($extOther))) {
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->templateType=%s,self::htmlTemplateType=%s,extOther=%s', $this->getTemplateType(), self::$htmlTemplateType, $extOther));
+			if (($this->getTemplateType() != self::$htmlTemplateType) && (empty($extOther))) {
 				// Switch over to the code-template extension and try it again
 				$ext = $this->getCodeTemplateExtension();
 
 				// Try it again...
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->loadTemplate(%s,%s) ...', $templateName, $ex));
 				$this->loadTemplate($templateName, $ext);
 			} else {
 				// Throw it again
@@ -726,6 +880,8 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 			}
 		}
 
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -736,14 +892,19 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function loadRawTemplateData (SplFileInfo $fileInstance) {
 		// Load the raw template
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: fileInstance=' . $fileInstance);
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: fileInstance=%s - CALLED!', $fileInstance->__toString()));
 		$rawTemplateData = $this->getFileIoInstance()->loadFileContents($fileInstance);
 
 		// Store the template's contents into this class
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setRawTemplateData(%d) ...', strlen($rrawTemplateData)));
 		$this->setRawTemplateData($rawTemplateData);
 
 		// Remember the template's file instance
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setLastTemplate(%s) ...', $fileInstance->__toString()));
 		$this->setLastTemplate($fileInstance);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -752,22 +913,28 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 *
 	 * @param	$variableName	The variable's name (shall be content or config)
 	 *							by default
-	 * @param	$variableName	The variable we want to assign
+	 * @param	$configKey	Possible configuration key
 	 * @return	void
 	 */
-	private function assignTemplateVariable (string $variableName, $var) {
+	private function assignTemplateVariable (string $variableName, string $configKey = '') {
 		// Replace all dashes to underscores to match variables with configuration entries
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: variableName=' . $variableName . ',var=' . $var);
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: variableName=%s,configKey=%s - CALLED!', $variableName, $configKey));
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
 		// Is it not a config variable?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableName=%s', $variableName));
 		if ($variableName != 'config') {
 			// Regular template variables
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->assignVariable(%s,"") ...', $variableName));
 			$this->assignVariable($variableName, '');
 		} else {
 			// Configuration variables
-			$this->assignConfigVariable($var);
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->assignConfigVariable(%s,"") ...', $configKey));
+			$this->assignConfigVariable($configKey);
 		}
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -778,23 +945,31 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function extractVariablesFromRawData (string $rawData) {
 		// Search for variables
-		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:rawData(' . strlen($rawData) . ')=' . $rawData . ',variableMatches=' . print_r($variableMatches, true));
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: rawData(%d)=%s - CALLED!', strlen($rawData), $rawData));
 		preg_match_all('/\$(\w+)(\[(\w+)\])?/', $rawData, $variableMatches);
 
 		// Did we find some variables?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableMatches[]=%s', gettype($variableMatches)));
 		if ((is_array($variableMatches)) && (count($variableMatches) == 4) && (count($variableMatches[0]) > 0)) {
 			// Initialize all missing variables
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableMatches()=%d', count($variableMatches)));
 			foreach ($variableMatches[3] as $key => $var) {
 				// Variable name
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: key=%s,var=%s', $key, $var));
 				$variableName = $variableMatches[1][$key];
 
 				// Workarround: Do not assign empty variables
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: variableName=%s', $variableName));
 				if (!empty($var)) {
 					// Try to assign it, empty strings are being ignored
+					/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->assignTemplateVariable(%s,%s) ...', $variableName, $var));
 					$this->assignTemplateVariable($variableName, $var);
 				}
 			}
 		}
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -813,9 +988,11 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function analyzeTemplate (array $templateMatches) {
 		// Backup raw template data
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: templateMatches()=%d', count($templateMatches)));
 		$backup = $this->getRawTemplateData();
 
 		// Initialize some arrays
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: backup[%s]()=%d,this->loadedRawData[]=%s', gettype($backup), strlen($backup), gettype($this->loadedRawData)));
 		if (is_null($this->loadedRawData)) {
 			// Initialize both
 			$this->loadedRawData = [];
@@ -823,32 +1000,41 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		}
 
 		// Load all requested templates
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: templateMatches[1]()=%d', count($templateMatches[1])));
 		foreach ($templateMatches[1] as $template) {
 			// Load and compile only templates which we have not yet loaded
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: template=%s', $template));
 			// RECURSIVE PROTECTION! BE CAREFUL HERE!
 			if ((!isset($this->loadedRawData[$template])) && (!in_array($template, $this->loadedTemplates))) {
-				// Debug message
-				//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:template=' . $template);
-
 				// Template not found, but maybe variable assigned?
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: template=%s not loaded yet', $template));
 				if ($this->getVariableIndex($template) !== false) {
 					// Use that content here
+					/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Assigning this->loadedTemplateData[%s] from variable template=%s ...', $template, $template));
 					$this->loadedRawData[$template] = $this->readVariable($template);
 
 					// Recursive protection:
+					/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Marking template=%s as loaded ...', $template));
 					array_push($this->loadedTemplates, $template);
 				} else {
 					// Then try to search for code-templates
+					/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: template=%s is maybe name of code template?', $template));
 					try {
-						// Load the code template and remember it's contents
+						// Load the code template ...
+						/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->loadCodeTemplate(%s) ...', $template));
 						$this->loadCodeTemplate($template);
+
+						// ... and remember it's contents
+						/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Setting this->loadedRawData[%s] from this->rawTemplateData ...', $template));
 						$this->loadedRawData[$template] = $this->getRawTemplateData();
 
 						// Remember this template for recursion detection
 						// RECURSIVE PROTECTION!
+						/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Marking template=%s as loaded ...', $template));
 						array_push($this->loadedTemplates, $template);
 					} catch (FileNotFoundException $e) {
 						// Even this is not done... :/
+						/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Marking template=%s as loaded ...', $template));
 						array_push($this->rawTemplates, $template);
 					}
 				}
@@ -856,7 +1042,11 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		}
 
 		// Restore the raw template data
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setRawTemplateData(backup()=%d) ...', strlen($backup)));
 		$this->setRawTemplateData($backup);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -868,30 +1058,41 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function compileCode (string $code, string $template) {
 		// Is this template already compiled?
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: code=%s,template=%s - CALLED!', $code, $template));
 		if (in_array($template, $this->compiledTemplates)) {
 			// Abort here...
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Found template=%s in this->compiledTemplates - EXIT!', $template));
 			return;
 		}
 
 		// Remember this template being compiled
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: Adding template=%s to this->compiledTemplates ...', $template));
 		array_push($this->compiledTemplates, $template);
 
 		// Compile the loaded code in five steps:
 		//
 		// 1. Backup current template data
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: this->compiledTemplates()=%d', count($this->compiledTemplates)));
 		$backup = $this->getRawTemplateData();
 
 		// 2. Set the current template's raw data as the new content
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setRawTemplateData(code()=%d) ... - backup[%s]()=%d', strlen($code), gettype($backup), strlen($backup)));
 		$this->setRawTemplateData($code);
 
 		// 3. Compile the template data
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: Invoking this->compileTemplate() ...');
 		$this->compileTemplate();
 
 		// 4. Remember it's contents
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput(sprintf('BASE-TEMPLATE: Setting this->loadedRawData[%s] from this->rawTemplateData ...', $template));
 		$this->loadedRawData[$template] = $this->getRawTemplateData();
 
 		// 5. Restore the previous raw content from backup variable
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: Invoking this->setRawTemplateData(backup()=%d) ...', strlen($backup)));
 		$this->setRawTemplateData($backup);
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -903,24 +1104,30 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 */
 	private function insertAllTemplates (array $templateMatches) {
 		// Run through all loaded codes
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-TEMPLATE: templateMatches()=%d', count($templateMatches)));
 		foreach ($this->loadedRawData as $template => $code) {
-
 			// Search for the template
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: template=%s,code()=%d', $template, strlen($code)));
 			$foundIndex = array_search($template, $templateMatches[1]);
 
 			// Lookup the matching template replacement
+			/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: foundIndex[%s]=d', gettype($foundIndex), $foundIndex));
 			if (($foundIndex !== false) && (isset($templateMatches[0][$foundIndex]))) {
-
 				// Get the current raw template
 				$rawData = $this->getRawTemplateData();
 
 				// Replace the space holder with the template code
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: rawData()=%s - BEFORE!', strlen($rawData)));
 				$rawData = str_replace($templateMatches[0][$foundIndex], $code, $rawData);
 
 				// Set the new raw data
+				/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-TEMPLATE: rawData()=%s - AFTER!', strlen($rawData)));
 				$this->setRawTemplateData($rawData);
 			}
 		}
+
+		// Trace message
+		/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-TEMPLATE: EXIT!');
 	}
 
 	/**
@@ -962,10 +1169,8 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @todo	Unfinished work or don't die here.
 	 */
 	private function assignAllVariables (array $varMatches) {
-		// Debug message
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:varMatches()=' . count($varMatches));
-
 		// Search for all variables
+		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:varMatches()=' . count($varMatches));
 		foreach ($varMatches[1] as $key => $var) {
 			// Replace all dashes to underscores to match variables with configuration entries
 			$var = trim(StringUtils::convertDashesToUnderscores($var));
@@ -997,10 +1202,8 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @return	void
 	 */
 	private function compileRawTemplateData (array $templateMatches) {
-		// Debug message
-		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:loadedRawData()= ' .count($this->loadedRawData));
-
 		// Are some code-templates found which we need to compile?
+		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:loadedRawData()= ' .count($this->loadedRawData));
 		if (count($this->loadedRawData) > 0) {
 			// Then compile all!
 			foreach ($this->loadedRawData as $template => $code) {
@@ -1059,13 +1262,6 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 		$content = $this->getRawTemplateData();
 		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: content before=' . strlen($content) . ' (' . md5($content) . ')');
 
-		// Do we have the stack?
-		if (!$this->isVarStackSet('general')) {
-			// Abort here silently
-			// @TODO This silent abort should be logged, maybe.
-			return;
-		}
-
 		// Walk through all variables
 		foreach ($this->getVarStack('general') as $currEntry) {
 			//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: name=' . $currEntry['name'] . ', value=<pre>' . htmlentities($currEntry['value']) . '</pre>');
@@ -1091,10 +1287,17 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$template	The web template we shall load which is located in
 	 *						'html' by default
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function loadHtmlTemplate (string $template) {
+		// Validate parameter
+		if (empty($template)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "template" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Set template type
-		$this->setTemplateType(FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('html_template_type'));
+		$this->setTemplateType(self::$htmlTemplateType);
 
 		// Load the special template
 		$this->loadTemplate($template);
@@ -1139,8 +1342,18 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$variableName	The variable we are looking for
 	 * @param	$variableGroup	Name of variable group (default: 'general')
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public final function removeVariable (string $variableName, string $variableGroup = 'general') {
+		// Validate parameter
+		if (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (empty($variableGroup)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// First search for the variable if it was already added
 		$index = $this->getVariableIndex($variableName, $variableGroup);
 
@@ -1158,8 +1371,18 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$templateName	Name of the template we want to assign
 	 * @param	$variableName	Name of the variable we want to assign
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function assignTemplateWithVariable (string $templateName, string $variableName) {
+		// Validate parameter
+		if (empty($templateName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "templateName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Get the content from last loaded raw template
 		$content = $this->getRawTemplateData();
 
@@ -1175,8 +1398,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 *
 	 * @param	$variableName	The configuration variable we want to assign
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function assignConfigVariable (string $variableName) {
+		// Validate parameter
+		if (empty($variableName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "variableName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Replace all dashes to underscores to match variables with configuration entries
 		$variableName = trim(StringUtils::convertDashesToUnderscores($variableName));
 
@@ -1231,8 +1461,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$template	The code template we shall load which is
 	 *						located in 'code' by default
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function loadCodeTemplate (string $template) {
+		// Validate parameter
+		if (empty($template)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "template" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Set template type
 		$this->setTemplateType(FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('code_' . FrameworkBootstrap::getRequestTypeFromSystem() . '_template_type'));
 
@@ -1246,8 +1483,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$template	The email template we shall load which is
 	 *						located in 'emails' by default
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function loadEmailTemplate (string $template) {
+		// Validate parameter
+		if (empty($template)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "template" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Set template type
 		$this->setTemplateType(FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('email_template_type'));
 
@@ -1445,8 +1689,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 *
 	 * @param	$helperName		The helper's name
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	protected function loadViewHelper (string $helperName) {
+		// Validate parameter
+		if (empty($helperName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "helperName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Is this view helper loaded?
 		if (!isset($this->helpers[$helperName])) {
 			// Create a class name
@@ -1477,8 +1728,15 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$rawCode			Raw code to compile
 	 * @param	$setMatchAsCode		Sets $match if readVariable() returns empty result
 	 * @return	$rawCode	Compile code with inserted variable value
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function compileRawCode (string $rawCode, bool $setMatchAsCode = false) {
+		// Validate parameter
+		if (empty($rawCode)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "rawCode" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Find the variables
 		//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE:rawCode=<pre>' . htmlentities($rawCode) . '</pre>');
 		preg_match_all($this->regExpVarValue, $rawCode, $varMatches);
@@ -1531,9 +1789,19 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @param	$oldName	Old name of variable
 	 * @param	$newName	New name of variable
 	 * @return	void
+	 * @throws	InvalidArgumentException	If the variable name is left empty
 	 */
 	public function renameVariable (string $oldName, string $newName) {
+		// Validate parameter
 		//* DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('BASE-TEMPLATE: oldName=' . $oldName . ', newName=' . $newName);
+		if (empty($oldName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "oldName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		} elseif (empty($newName)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "newName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// Get raw template code
 		$rawData = $this->getRawTemplateData();
 
@@ -1570,6 +1838,12 @@ abstract class BaseTemplateEngine extends BaseFrameworkSystem {
 	 * @return	$compactedContent		The compacted content
 	 */
 	public function compactContent (string $uncompactedContent) {
+		// Validate parameter
+		if (empty($uncompactedContent)) {
+			// Throw an exception
+			throw new InvalidArgumentException('Parameter "uncompactedContent" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
+		}
+
 		// First, remove all tab/new-line/revert characters
 		$compactedContent = str_replace(chr(9), '', str_replace(chr(10), '', str_replace(chr(13), '', $uncompactedContent)));