YetiForceCompany / YetiForceCRM

libraries/log4php.debug/helpers/LoggerOptionConverter.php

Indentation +283 added lines, -283 removed lines

@@ -41,310 +41,310 @@
  */
 class LoggerOptionConverter {
 
-    /** 
-     * OptionConverter is a static class. 
-     */
-    public function OptionConverter() 
-    {
-        return;
-    }
+	/** 
+	 * OptionConverter is a static class. 
+	 */
+	public function OptionConverter() 
+	{
+		return;
+	}
 
-    /**
-     * @param array $l
-     * @param array $r
-     * @return array
-     *
-     * @static
-     */
-    public function concatanateArrays($l, $r)
-    {
-        return array_merge($l, $r);
-    }
+	/**
+	 * @param array $l
+	 * @param array $r
+	 * @return array
+	 *
+	 * @static
+	 */
+	public function concatanateArrays($l, $r)
+	{
+		return array_merge($l, $r);
+	}
 
-    /**
-    * Read a predefined var.
-    *
-    * It returns a value referenced by <var>$key</var> using this search criteria:
-    * - if <var>$key</var> is a constant then return it. Else
-    * - if <var>$key</var> is set in <var>$_ENV</var> then return it. Else
-    * - return <var>$def</var>. 
-    *
-    * @param string $key The key to search for.
-    * @param string $def The default value to return.
-    * @return string    the string value of the system property, or the default
-    *                   value if there is no property with that key.
-    *
-    * @static
-    */
-    public function getSystemProperty($key, $def)
-    {
-        LoggerLog::debug("LoggerOptionConverter::getSystemProperty():key=[{$key}]:def=[{$def}].");
+	/**
+	 * Read a predefined var.
+	 *
+	 * It returns a value referenced by <var>$key</var> using this search criteria:
+	 * - if <var>$key</var> is a constant then return it. Else
+	 * - if <var>$key</var> is set in <var>$_ENV</var> then return it. Else
+	 * - return <var>$def</var>. 
+	 *
+	 * @param string $key The key to search for.
+	 * @param string $def The default value to return.
+	 * @return string    the string value of the system property, or the default
+	 *                   value if there is no property with that key.
+	 *
+	 * @static
+	 */
+	public function getSystemProperty($key, $def)
+	{
+		LoggerLog::debug("LoggerOptionConverter::getSystemProperty():key=[{$key}]:def=[{$def}].");
 
-        if (defined($key)) {
-            return (string)constant($key);
-        } elseif (isset($_ENV[$key])) {
-            return (string)$_ENV[$key];
-        } else {
-            return $def;
-        }
-    }
+		if (defined($key)) {
+			return (string)constant($key);
+		} elseif (isset($_ENV[$key])) {
+			return (string)$_ENV[$key];
+		} else {
+			return $def;
+		}
+	}
 
-    /**
-     * If <var>$value</var> is <i>true</i>, then <i>true</i> is
-     * returned. If <var>$value</var> is <i>false</i>, then
-     * <i>true</i> is returned. Otherwise, <var>$default</var> is
-     * returned.
-     *
-     * <p>Case of value is unimportant.</p>
-     *
-     * @param string $value
-     * @param boolean $default
-     * @return boolean
-     *
-     * @static
-     */
-    public function toBoolean($value, $default)
-    {
-        if($value === null)
-            return $default;
-        if ($value == 1)
-            return true;
-        $trimmedVal = strtolower(trim($value));
-        if ("true" == $trimmedVal || "yes" == $trimmedVal)
-            return true;
-        if ("false" == $trimmedVal)
-            return false;
-        return $default;
-    }
+	/**
+	 * If <var>$value</var> is <i>true</i>, then <i>true</i> is
+	 * returned. If <var>$value</var> is <i>false</i>, then
+	 * <i>true</i> is returned. Otherwise, <var>$default</var> is
+	 * returned.
+	 *
+	 * <p>Case of value is unimportant.</p>
+	 *
+	 * @param string $value
+	 * @param boolean $default
+	 * @return boolean
+	 *
+	 * @static
+	 */
+	public function toBoolean($value, $default)
+	{
+		if($value === null)
+			return $default;
+		if ($value == 1)
+			return true;
+		$trimmedVal = strtolower(trim($value));
+		if ("true" == $trimmedVal || "yes" == $trimmedVal)
+			return true;
+		if ("false" == $trimmedVal)
+			return false;
+		return $default;
+	}
 
-    /**
-     * @param string $value
-     * @param integer $default
-     * @return integer
-     * @static
-     */
-    public function toInt($value, $default)
-    {
-        $value = trim($value);
-        if (is_numeric($value)) {
-            return (int)$value;
-        } else {
-            return $default;
-        }
-    }
+	/**
+	 * @param string $value
+	 * @param integer $default
+	 * @return integer
+	 * @static
+	 */
+	public function toInt($value, $default)
+	{
+		$value = trim($value);
+		if (is_numeric($value)) {
+			return (int)$value;
+		} else {
+			return $default;
+		}
+	}
 
-    /**
-     * Converts a standard or custom priority level to a Level
-     * object.
-     *
-     * <p> If <var>$value</var> is of form "<b>level#full_file_classname</b>",
-     * where <i>full_file_classname</i> means the class filename with path
-     * but without php extension, then the specified class' <i>toLevel()</i> method
-     * is called to process the specified level string; if no '#'
-     * character is present, then the default {@link LoggerLevel}
-     * class is used to process the level value.</p>
-     *
-     * <p>As a special case, if the <var>$value</var> parameter is
-     * equal to the string "NULL", then the value <i>null</i> will
-     * be returned.</p>
-     *
-     * <p>If any error occurs while converting the value to a level,
-     * the <var>$defaultValue</var> parameter, which may be
-     * <i>null</i>, is returned.</p>
-     *
-     * <p>Case of <var>$value</var> is insignificant for the level level, but is
-     * significant for the class name part, if present.</p>
-     *
-     * @param string $value
-     * @param LoggerLevel $defaultValue
-     * @return LoggerLevel a {@link LoggerLevel} or null
-     * @static
-     */
-    public function toLevel($value, $defaultValue)
-    {
-        if($value === null)
-            return $defaultValue;
+	/**
+	 * Converts a standard or custom priority level to a Level
+	 * object.
+	 *
+	 * <p> If <var>$value</var> is of form "<b>level#full_file_classname</b>",
+	 * where <i>full_file_classname</i> means the class filename with path
+	 * but without php extension, then the specified class' <i>toLevel()</i> method
+	 * is called to process the specified level string; if no '#'
+	 * character is present, then the default {@link LoggerLevel}
+	 * class is used to process the level value.</p>
+	 *
+	 * <p>As a special case, if the <var>$value</var> parameter is
+	 * equal to the string "NULL", then the value <i>null</i> will
+	 * be returned.</p>
+	 *
+	 * <p>If any error occurs while converting the value to a level,
+	 * the <var>$defaultValue</var> parameter, which may be
+	 * <i>null</i>, is returned.</p>
+	 *
+	 * <p>Case of <var>$value</var> is insignificant for the level level, but is
+	 * significant for the class name part, if present.</p>
+	 *
+	 * @param string $value
+	 * @param LoggerLevel $defaultValue
+	 * @return LoggerLevel a {@link LoggerLevel} or null
+	 * @static
+	 */
+	public function toLevel($value, $defaultValue)
+	{
+		if($value === null)
+			return $defaultValue;
 
-        $hashIndex = strpos($value, '#');
-        if ($hashIndex === false) {
-            if("NULL" == strtoupper($value)) {
-	            return null;
-            } else {
-	            // no class name specified : use standard Level class
-	            return LoggerLevel::toLevel($value, $defaultValue);
-            }
-        }
+		$hashIndex = strpos($value, '#');
+		if ($hashIndex === false) {
+			if("NULL" == strtoupper($value)) {
+				return null;
+			} else {
+				// no class name specified : use standard Level class
+				return LoggerLevel::toLevel($value, $defaultValue);
+			}
+		}
 
-        $result = $defaultValue;
+		$result = $defaultValue;
 
-        $clazz = substr($value, ($hashIndex + 1));
-        $levelName = substr($value, 0, $hashIndex);
+		$clazz = substr($value, ($hashIndex + 1));
+		$levelName = substr($value, 0, $hashIndex);
 
-        // This is degenerate case but you never know.
-        if("NULL" == strtoupper($levelName)) {
-        	return null;
-        }
+		// This is degenerate case but you never know.
+		if("NULL" == strtoupper($levelName)) {
+			return null;
+		}
 
-        LoggerLog::debug("LoggerOptionConverter::toLevel():class=[{$clazz}]:pri=[{$levelName}]");
+		LoggerLog::debug("LoggerOptionConverter::toLevel():class=[{$clazz}]:pri=[{$levelName}]");
 
-        if (!class_exists($clazz))
-            @include_once("{$clazz}.php");
+		if (!class_exists($clazz))
+			@include_once("{$clazz}.php");
 
-        $clazz = basename($clazz);
+		$clazz = basename($clazz);
 
-        if (class_exists($clazz)) {
-            $result = @call_user_func(array($clazz, 'toLevel'), $value, $defaultValue);
-            if (!is_a($result, 'loggerlevel')) {
-                LoggerLog::debug("LoggerOptionConverter::toLevel():class=[{$clazz}] cannot call toLevel(). Returning default.");            
-                $result = $defaultValue;
-            }
-        } else {
-            LoggerLog::warn("LoggerOptionConverter::toLevel() class '{$clazz}' doesnt exists.");
-        }
-        return $result;
-    }
+		if (class_exists($clazz)) {
+			$result = @call_user_func(array($clazz, 'toLevel'), $value, $defaultValue);
+			if (!is_a($result, 'loggerlevel')) {
+				LoggerLog::debug("LoggerOptionConverter::toLevel():class=[{$clazz}] cannot call toLevel(). Returning default.");            
+				$result = $defaultValue;
+			}
+		} else {
+			LoggerLog::warn("LoggerOptionConverter::toLevel() class '{$clazz}' doesnt exists.");
+		}
+		return $result;
+	}
 
-    /**
-     * @param string $value
-     * @param float $default
-     * @return float
-     *
-     * @static
-     */
-    public function toFileSize($value, $default)
-    {
-        if ($value === null)
-            return $default;
+	/**
+	 * @param string $value
+	 * @param float $default
+	 * @return float
+	 *
+	 * @static
+	 */
+	public function toFileSize($value, $default)
+	{
+		if ($value === null)
+			return $default;
 
-        $s = strtoupper(trim($value));
-        $multiplier = (float)1;
-        if(($index = strpos($s, 'KB')) !== false) {
-            $multiplier = 1024;
-            $s = substr($s, 0, $index);
-        } elseif(($index = strpos($s, 'MB')) !== false) {
-            $multiplier = 1024 * 1024;
-            $s = substr($s, 0, $index);
-        } elseif(($index = strpos($s, 'GB')) !== false) {
-            $multiplier = 1024 * 1024 * 1024;
-            $s = substr($s, 0, $index);
-        }
-        if(is_numeric($s)) {
-            return (float)$s * $multiplier;
-        } else {
-            LoggerLog::warn("LoggerOptionConverter::toFileSize() [{$s}] is not in proper form.");
-        }
-        return $default;
-    }
+		$s = strtoupper(trim($value));
+		$multiplier = (float)1;
+		if(($index = strpos($s, 'KB')) !== false) {
+			$multiplier = 1024;
+			$s = substr($s, 0, $index);
+		} elseif(($index = strpos($s, 'MB')) !== false) {
+			$multiplier = 1024 * 1024;
+			$s = substr($s, 0, $index);
+		} elseif(($index = strpos($s, 'GB')) !== false) {
+			$multiplier = 1024 * 1024 * 1024;
+			$s = substr($s, 0, $index);
+		}
+		if(is_numeric($s)) {
+			return (float)$s * $multiplier;
+		} else {
+			LoggerLog::warn("LoggerOptionConverter::toFileSize() [{$s}] is not in proper form.");
+		}
+		return $default;
+	}
 
-    /**
-     * Find the value corresponding to <var>$key</var> in
-     * <var>$props</var>. Then perform variable substitution on the
-     * found value.
-     *
-     * @param string $key
-     * @param array $props
-     * @return string
-     *
-     * @static
-     */
-    public function findAndSubst($key, $props)
-    {
-        $value = @$props[$key];
-        if(empty($value)) {
-            return null;
-        }
-        return LoggerOptionConverter::substVars($value, $props);
-    }
+	/**
+	 * Find the value corresponding to <var>$key</var> in
+	 * <var>$props</var>. Then perform variable substitution on the
+	 * found value.
+	 *
+	 * @param string $key
+	 * @param array $props
+	 * @return string
+	 *
+	 * @static
+	 */
+	public function findAndSubst($key, $props)
+	{
+		$value = @$props[$key];
+		if(empty($value)) {
+			return null;
+		}
+		return LoggerOptionConverter::substVars($value, $props);
+	}
 
-    /**
-     * Perform variable substitution in string <var>$val</var> from the
-     * values of keys found with the {@link getSystemProperty()} method.
-     * 
-     * <p>The variable substitution delimeters are <b>${</b> and <b>}</b>.
-     * 
-     * <p>For example, if the "MY_CONSTANT" contains "value", then
-     * the call
-     * <code>
-     * $s = LoggerOptionConverter::substituteVars("Value of key is ${MY_CONSTANT}.");
-     * </code>
-     * will set the variable <i>$s</i> to "Value of key is value.".</p>
-     * 
-     * <p>If no value could be found for the specified key, then the
-     * <var>$props</var> parameter is searched, if the value could not
-     * be found there, then substitution defaults to the empty string.</p>
-     * 
-     * <p>For example, if {@link getSystemProperty()} cannot find any value for the key
-     * "inexistentKey", then the call
-     * <code>
-     * $s = LoggerOptionConverter::substVars("Value of inexistentKey is [${inexistentKey}]");
-     * </code>
-     * will set <var>$s</var> to "Value of inexistentKey is []".</p>
-     * 
-     * <p>A warn is thrown if <var>$val</var> contains a start delimeter "${" 
-     * which is not balanced by a stop delimeter "}" and an empty string is returned.</p>
-     * 
-     * @log4j-author Avy Sharell
-     * 
-     * @param string $val The string on which variable substitution is performed.
-     * @param array $props
-     * @return string
-     *
-     * @static
-     */
-    public function substVars($val, $props = null)
-    {
-        LoggerLog::debug("LoggerOptionConverter::substVars():val=[{$val}]");
+	/**
+	 * Perform variable substitution in string <var>$val</var> from the
+	 * values of keys found with the {@link getSystemProperty()} method.
+	 * 
+	 * <p>The variable substitution delimeters are <b>${</b> and <b>}</b>.
+	 * 
+	 * <p>For example, if the "MY_CONSTANT" contains "value", then
+	 * the call
+	 * <code>
+	 * $s = LoggerOptionConverter::substituteVars("Value of key is ${MY_CONSTANT}.");
+	 * </code>
+	 * will set the variable <i>$s</i> to "Value of key is value.".</p>
+	 * 
+	 * <p>If no value could be found for the specified key, then the
+	 * <var>$props</var> parameter is searched, if the value could not
+	 * be found there, then substitution defaults to the empty string.</p>
+	 * 
+	 * <p>For example, if {@link getSystemProperty()} cannot find any value for the key
+	 * "inexistentKey", then the call
+	 * <code>
+	 * $s = LoggerOptionConverter::substVars("Value of inexistentKey is [${inexistentKey}]");
+	 * </code>
+	 * will set <var>$s</var> to "Value of inexistentKey is []".</p>
+	 * 
+	 * <p>A warn is thrown if <var>$val</var> contains a start delimeter "${" 
+	 * which is not balanced by a stop delimeter "}" and an empty string is returned.</p>
+	 * 
+	 * @log4j-author Avy Sharell
+	 * 
+	 * @param string $val The string on which variable substitution is performed.
+	 * @param array $props
+	 * @return string
+	 *
+	 * @static
+	 */
+	public function substVars($val, $props = null)
+	{
+		LoggerLog::debug("LoggerOptionConverter::substVars():val=[{$val}]");
         
-        $sbuf = '';
-        $i = 0;
-        while(true) {
-            $j = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_START, $i);
-            if ($j === false) {
-                LoggerLog::debug("LoggerOptionConverter::substVars() no more variables");
-	            // no more variables
-	            if ($i == 0) { // this is a simple string
-                    LoggerLog::debug("LoggerOptionConverter::substVars() simple string");
-	                return $val;
-            	} else { // add the tail string which contails no variables and return the result.
-                    $sbuf .= substr($val, $i);
-                    LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]. Returning sbuf");                    
-                    return $sbuf;
-	            }
-            } else {
+		$sbuf = '';
+		$i = 0;
+		while(true) {
+			$j = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_START, $i);
+			if ($j === false) {
+				LoggerLog::debug("LoggerOptionConverter::substVars() no more variables");
+				// no more variables
+				if ($i == 0) { // this is a simple string
+					LoggerLog::debug("LoggerOptionConverter::substVars() simple string");
+					return $val;
+				} else { // add the tail string which contails no variables and return the result.
+					$sbuf .= substr($val, $i);
+					LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]. Returning sbuf");                    
+					return $sbuf;
+				}
+			} else {
             
-	            $sbuf .= substr($val, $i, $j-$i);
-                LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]:i={$i}:j={$j}.");
-            	$k = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_STOP, $j);
-            	if ($k === false) {
-                    LoggerLog::warn(
-                        "LoggerOptionConverter::substVars() " .
-                        "'{$val}' has no closing brace. Opening brace at position {$j}."
-                    );
-                    return '';
-	            } else {
-	                $j += LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN;
-	                $key = substr($val, $j, $k - $j);
-                    // first try in System properties
-	                $replacement = LoggerOptionConverter::getSystemProperty($key, null);
-	                // then try props parameter
-	                if($replacement == null && $props !== null) {
-            	        $replacement = @$props[$key];
-	                }
+				$sbuf .= substr($val, $i, $j-$i);
+				LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]:i={$i}:j={$j}.");
+				$k = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_STOP, $j);
+				if ($k === false) {
+					LoggerLog::warn(
+						"LoggerOptionConverter::substVars() " .
+						"'{$val}' has no closing brace. Opening brace at position {$j}."
+					);
+					return '';
+				} else {
+					$j += LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN;
+					$key = substr($val, $j, $k - $j);
+					// first try in System properties
+					$replacement = LoggerOptionConverter::getSystemProperty($key, null);
+					// then try props parameter
+					if($replacement == null && $props !== null) {
+						$replacement = @$props[$key];
+					}
 
-                    if(!empty($replacement)) {
-	                    // Do variable substitution on the replacement string
-                	    // such that we can solve "Hello ${x2}" as "Hello p1" 
-                        // the where the properties are
-                	    // x1=p1
-                        // x2=${x1}
-	                    $recursiveReplacement = LoggerOptionConverter::substVars($replacement, $props);
-                	    $sbuf .= $recursiveReplacement;
-	                }
-	                $i = $k + LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN;
-	            }
-            }
-        }
-    }
+					if(!empty($replacement)) {
+						// Do variable substitution on the replacement string
+						// such that we can solve "Hello ${x2}" as "Hello p1" 
+						// the where the properties are
+						// x1=p1
+						// x2=${x1}
+						$recursiveReplacement = LoggerOptionConverter::substVars($replacement, $props);
+						$sbuf .= $recursiveReplacement;
+					}
+					$i = $k + LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN;
+				}
+			}
+		}
+	}
 
 }
 ?>
\ No newline at end of file

libraries/log4php.debug/helpers/LoggerTransform.php

Indentation +46 added lines, -46 removed lines

@@ -26,9 +26,9 @@ 
 define('LOG4PHP_LOGGER_TRANSFORM_CDATA_END',            ']]>');
 define('LOG4PHP_LOGGER_TRANSFORM_CDATA_PSEUDO_END',     ']]>');
 define('LOG4PHP_LOGGER_TRANSFORM_CDATA_EMBEDDED_END',   
-    LOG4PHP_LOGGER_TRANSFORM_CDATA_END .
-    LOG4PHP_LOGGER_TRANSFORM_CDATA_PSEUDO_END .
-    LOG4PHP_LOGGER_TRANSFORM_CDATA_START 
+	LOG4PHP_LOGGER_TRANSFORM_CDATA_END .
+	LOG4PHP_LOGGER_TRANSFORM_CDATA_PSEUDO_END .
+	LOG4PHP_LOGGER_TRANSFORM_CDATA_START 
 );
 
 /**
@@ -43,53 +43,53 @@ 
  */
 class LoggerTransform {
 
-    /**
-    * This method takes a string which may contain HTML tags (ie,
-    * <b>, <table>, etc) and replaces any '<' and '>'
-    * characters with respective predefined entity references.
-    *
-    * @param string $input The text to be converted.
-    * @return string The input string with the characters '<' and '>' replaced with
-    *                < and > respectively.
-    * @static  
-    */
-    public function escapeTags($input)
-    {
-        //Check if the string is null or zero length -- if so, return
-        //what was sent in.
+	/**
+	 * This method takes a string which may contain HTML tags (ie,
+	 * <b>, <table>, etc) and replaces any '<' and '>'
+	 * characters with respective predefined entity references.
+	 *
+	 * @param string $input The text to be converted.
+	 * @return string The input string with the characters '<' and '>' replaced with
+	 *                < and > respectively.
+	 * @static  
+	 */
+	public function escapeTags($input)
+	{
+		//Check if the string is null or zero length -- if so, return
+		//what was sent in.
 
-        if(empty($input))
-            return $input;
+		if(empty($input))
+			return $input;
 
-        //Use a StringBuffer in lieu of String concatenation -- it is
-        //much more efficient this way.
+		//Use a StringBuffer in lieu of String concatenation -- it is
+		//much more efficient this way.
 
-        return htmlspecialchars($input, ENT_NOQUOTES);
-    }
+		return htmlspecialchars($input, ENT_NOQUOTES);
+	}
 
-    /**
-    * Ensures that embeded CDEnd strings (]]>) are handled properly
-    * within message, NDC and throwable tag text.
-    *
-    * @param string $buf    String holding the XML data to this point.  The
-    *                       initial CDStart (<![CDATA[) and final CDEnd (]]>) 
-    *                       of the CDATA section are the responsibility of 
-    *                       the calling method.
-    * @param string &str    The String that is inserted into an existing 
-    *                       CDATA Section within buf.
-    * @static  
-    */
-    public function appendEscapingCDATA(&$buf, $str)
-    {
-        if(empty($str))
-            return;
+	/**
+	 * Ensures that embeded CDEnd strings (]]&gt;) are handled properly
+	 * within message, NDC and throwable tag text.
+	 *
+	 * @param string $buf    String holding the XML data to this point.  The
+	 *                       initial CDStart (<![CDATA[) and final CDEnd (]]>) 
+	 *                       of the CDATA section are the responsibility of 
+	 *                       the calling method.
+	 * @param string &str    The String that is inserted into an existing 
+	 *                       CDATA Section within buf.
+	 * @static  
+	 */
+	public function appendEscapingCDATA(&$buf, $str)
+	{
+		if(empty($str))
+			return;
     
-        $rStr = str_replace(
-            LOG4PHP_LOGGER_TRANSFORM_CDATA_END,
-            LOG4PHP_LOGGER_TRANSFORM_CDATA_EMBEDDED_END,
-            $str
-        );
-        $buf .= $rStr;
-    }
+		$rStr = str_replace(
+			LOG4PHP_LOGGER_TRANSFORM_CDATA_END,
+			LOG4PHP_LOGGER_TRANSFORM_CDATA_EMBEDDED_END,
+			$str
+		);
+		$buf .= $rStr;
+	}
 }
 ?>
\ No newline at end of file

libraries/log4php.debug/helpers/LoggerFormattingInfo.php

Indentation +17 added lines, -17 removed lines

@@ -37,25 +37,25 @@
  */
 class LoggerFormattingInfo {
 
-    var $min        = -1;
-    var $max        = 0x7FFFFFFF;
-    var $leftAlign  = false;
+	var $min        = -1;
+	var $max        = 0x7FFFFFFF;
+	var $leftAlign  = false;
 
-    /**
-     * Constructor
-     */
-    public function LoggerFormattingInfo() {}
+	/**
+	 * Constructor
+	 */
+	public function LoggerFormattingInfo() {}
     
-    public function reset()
-    {
-        $this->min          = -1;
-        $this->max          = 0x7FFFFFFF;
-        $this->leftAlign    = false;      
-    }
+	public function reset()
+	{
+		$this->min          = -1;
+		$this->max          = 0x7FFFFFFF;
+		$this->leftAlign    = false;      
+	}
 
-    public function dump()
-    {
-        LoggerLog::debug("LoggerFormattingInfo::dump() min={$this->min}, max={$this->max}, leftAlign={$this->leftAlign}");
-    }
+	public function dump()
+	{
+		LoggerLog::debug("LoggerFormattingInfo::dump() min={$this->min}, max={$this->max}, leftAlign={$this->leftAlign}");
+	}
 } 
 ?>
\ No newline at end of file

libraries/log4php.debug/helpers/LoggerPatternParser.php

Indentation +321 added lines, -321 removed lines

@@ -23,17 +23,17 @@ 
 if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__) . '/..');
 
 if (!defined('LOG4PHP_LINE_SEP')) {
-    if (substr(php_uname(), 0, 7) == "Windows") {
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_LINE_SEP', "\r\n");
-    } else {
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_LINE_SEP', "\n");
-    }
+	if (substr(php_uname(), 0, 7) == "Windows") {
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_LINE_SEP', "\r\n");
+	} else {
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_LINE_SEP', "\n");
+	}
 }
  
 /**
@@ -83,335 +83,335 @@ 
  */
 class LoggerPatternParser {
 
-    var $state;
-    var $currentLiteral;
-    var $patternLength;
-    var $i;
+	var $state;
+	var $currentLiteral;
+	var $patternLength;
+	var $i;
     
-    /**
-     * @var LoggerPatternConverter
-     */
-    var $head = null;
+	/**
+	 * @var LoggerPatternConverter
+	 */
+	var $head = null;
      
-    /**
-     * @var LoggerPatternConverter
-     */
-    var $tail = null;
+	/**
+	 * @var LoggerPatternConverter
+	 */
+	var $tail = null;
     
-    /**
-     * @var LoggerFormattingInfo
-     */
-    var $formattingInfo;
+	/**
+	 * @var LoggerFormattingInfo
+	 */
+	var $formattingInfo;
     
-    /**
-     * @var string pattern to parse
-     */
-    var $pattern;
+	/**
+	 * @var string pattern to parse
+	 */
+	var $pattern;
 
-    /**
-     * Constructor 
-     *
-     * @param string $pattern
-     */
-    public function LoggerPatternParser($pattern)
-    {
-        LoggerLog::debug("LoggerPatternParser::LoggerPatternParser() pattern='$pattern'");
+	/**
+	 * Constructor 
+	 *
+	 * @param string $pattern
+	 */
+	public function LoggerPatternParser($pattern)
+	{
+		LoggerLog::debug("LoggerPatternParser::LoggerPatternParser() pattern='$pattern'");
     
-        $this->pattern = $pattern;
-        $this->patternLength =  strlen($pattern);
-        $this->formattingInfo = new LoggerFormattingInfo();
-        $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
-    }
+		$this->pattern = $pattern;
+		$this->patternLength =  strlen($pattern);
+		$this->formattingInfo = new LoggerFormattingInfo();
+		$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
+	}
 
-    /**
-     * @param LoggerPatternConverter $pc
-     */
-    public function addToList($pc)
-    {
-        // LoggerLog::debug("LoggerPatternParser::addToList()");
+	/**
+	 * @param LoggerPatternConverter $pc
+	 */
+	public function addToList($pc)
+	{
+		// LoggerLog::debug("LoggerPatternParser::addToList()");
     
-        if($this->head == null) {
-            $this->head = $pc;
-            $this->tail =& $this->head;
-        } else {
-            $this->tail->next = $pc;
-            $this->tail =& $this->tail->next;
-        }
-    }
+		if($this->head == null) {
+			$this->head = $pc;
+			$this->tail =& $this->head;
+		} else {
+			$this->tail->next = $pc;
+			$this->tail =& $this->tail->next;
+		}
+	}
 
-    /**
-     * @return string
-     */
-    public function extractOption()
-    {
-        if(($this->i < $this->patternLength) && ($this->pattern{$this->i} == '{')) {
-            $end = strpos($this->pattern, '}' , $this->i);
-            if ($end !== false) {
-                $r = substr($this->pattern, ($this->i + 1), ($end - $this->i - 1));
-	            $this->i= $end + 1;
-        	    return $r;
-            }
-        }
-        return null;
-    }
+	/**
+	 * @return string
+	 */
+	public function extractOption()
+	{
+		if(($this->i < $this->patternLength) && ($this->pattern{$this->i} == '{')) {
+			$end = strpos($this->pattern, '}' , $this->i);
+			if ($end !== false) {
+				$r = substr($this->pattern, ($this->i + 1), ($end - $this->i - 1));
+				$this->i= $end + 1;
+				return $r;
+			}
+		}
+		return null;
+	}
 
-    /**
-     * The option is expected to be in decimal and positive. In case of
-     * error, zero is returned.  
-     */
-    public function extractPrecisionOption()
-    {
-        $opt = $this->extractOption();
-        $r = 0;
-        if ($opt !== null) {
-            if (is_numeric($opt)) {
-    	        $r = (int)$opt;
-            	if($r <= 0) {
-            	    LoggerLog::warn("Precision option ({$opt}) isn't a positive integer.");
-            	    $r = 0;
-            	}
-            } else {
-                LoggerLog::warn("Category option \"{$opt}\" not a decimal integer.");
-            }
-        }
-        return $r;
-    }
+	/**
+	 * The option is expected to be in decimal and positive. In case of
+	 * error, zero is returned.  
+	 */
+	public function extractPrecisionOption()
+	{
+		$opt = $this->extractOption();
+		$r = 0;
+		if ($opt !== null) {
+			if (is_numeric($opt)) {
+				$r = (int)$opt;
+				if($r <= 0) {
+					LoggerLog::warn("Precision option ({$opt}) isn't a positive integer.");
+					$r = 0;
+				}
+			} else {
+				LoggerLog::warn("Category option \"{$opt}\" not a decimal integer.");
+			}
+		}
+		return $r;
+	}
 
-    public function parse()
-    {
-        LoggerLog::debug("LoggerPatternParser::parse()");
+	public function parse()
+	{
+		LoggerLog::debug("LoggerPatternParser::parse()");
     
-        $c = '';
-        $this->i = 0;
-        $this->currentLiteral = '';
-        while ($this->i < $this->patternLength) {
-            $c = $this->pattern{$this->i++};
+		$c = '';
+		$this->i = 0;
+		$this->currentLiteral = '';
+		while ($this->i < $this->patternLength) {
+			$c = $this->pattern{$this->i++};
 //            LoggerLog::debug("LoggerPatternParser::parse() char is now '$c' and currentLiteral is '{$this->currentLiteral}'");            
-            switch($this->state) {
-                case LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE:
-                    // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE'");
-                    // In literal state, the last char is always a literal.
-                    if($this->i == $this->patternLength) {
-                        $this->currentLiteral .= $c;
-                        continue;
-                    }
-                    if($c == LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR) {
-                        // LoggerLog::debug("LoggerPatternParser::parse() char is an escape char");                    
-                        // peek at the next char.
-                        switch($this->pattern{$this->i}) {
-                            case LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR:
-                                // LoggerLog::debug("LoggerPatternParser::parse() next char is an escape char");                    
-                                $this->currentLiteral .= $c;
-                                $this->i++; // move pointer
-                                break;
-                            case 'n':
-                                // LoggerLog::debug("LoggerPatternParser::parse() next char is 'n'");                            
-                                $this->currentLiteral .= LOG4PHP_LINE_SEP;
-                                $this->i++; // move pointer
-                                break;
-                            default:
-                                if(strlen($this->currentLiteral) != 0) {
-                                    $this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
-                                    LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
-                                }
-                                $this->currentLiteral = $c;
-                                $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE;
-                                $this->formattingInfo->reset();
-                        }
-                    } else {
-                        $this->currentLiteral .= $c;
-                    }
-                    break;
-              case LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE:
-                    // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE'");              
-                	$this->currentLiteral .= $c;
-                	switch($c) {
-                    	case '-':
-                            $this->formattingInfo->leftAlign = true;
-                            break;
-                    	case '.':
-                            $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE;
-	                        break;
-                    	default:
-                            if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
-                        	    $this->formattingInfo->min = ord($c) - ord('0');
-                        	    $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE;
-                            } else {
-                                $this->finalizeConverter($c);
-                            }
-                  	} // switch
-                    break;
-              case LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE:
-                    // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE'");              
-	                $this->currentLiteral .= $c;
-                    if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
-                        $this->formattingInfo->min = ($this->formattingInfo->min * 10) + (ord(c) - ord('0'));
-                	} elseif ($c == '.') {
-                        $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE;
-                    } else {
-                    	$this->finalizeConverter($c);
-                	}
-                	break;
-              case LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE:
-                    // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE'");              
-                	$this->currentLiteral .= $c;
-                    if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
-                        $this->formattingInfo->max = ord($c) - ord('0');
-	                    $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE;
-                    } else {
-                	  LoggerLog::warn("LoggerPatternParser::parse() Error occured in position {$this->i}. Was expecting digit, instead got char \"{$c}\".");
-	                  $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
-                    }
-                	break;
-              case LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE:
-                    // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE'");              
-                	$this->currentLiteral .= $c;
-                    if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
-                        $this->formattingInfo->max = ($this->formattingInfo->max * 10) + (ord($c) - ord('0'));
-	                } else {
-                	  $this->finalizeConverter($c);
-                      $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
-	                }
-                	break;
-            } // switch
-        } // while
-        if(strlen($this->currentLiteral) != 0) {
-            $this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
-            // LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
-        }
-        return $this->head;
-    }
+			switch($this->state) {
+				case LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE:
+					// LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE'");
+					// In literal state, the last char is always a literal.
+					if($this->i == $this->patternLength) {
+						$this->currentLiteral .= $c;
+						continue;
+					}
+					if($c == LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR) {
+						// LoggerLog::debug("LoggerPatternParser::parse() char is an escape char");                    
+						// peek at the next char.
+						switch($this->pattern{$this->i}) {
+							case LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR:
+								// LoggerLog::debug("LoggerPatternParser::parse() next char is an escape char");                    
+								$this->currentLiteral .= $c;
+								$this->i++; // move pointer
+								break;
+							case 'n':
+								// LoggerLog::debug("LoggerPatternParser::parse() next char is 'n'");                            
+								$this->currentLiteral .= LOG4PHP_LINE_SEP;
+								$this->i++; // move pointer
+								break;
+							default:
+								if(strlen($this->currentLiteral) != 0) {
+									$this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
+									LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
+								}
+								$this->currentLiteral = $c;
+								$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE;
+								$this->formattingInfo->reset();
+						}
+					} else {
+						$this->currentLiteral .= $c;
+					}
+					break;
+			  case LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE:
+					// LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE'");              
+					$this->currentLiteral .= $c;
+					switch($c) {
+						case '-':
+							$this->formattingInfo->leftAlign = true;
+							break;
+						case '.':
+							$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE;
+							break;
+						default:
+							if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
+								$this->formattingInfo->min = ord($c) - ord('0');
+								$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE;
+							} else {
+								$this->finalizeConverter($c);
+							}
+				  	} // switch
+					break;
+			  case LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE:
+					// LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE'");              
+					$this->currentLiteral .= $c;
+					if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
+						$this->formattingInfo->min = ($this->formattingInfo->min * 10) + (ord(c) - ord('0'));
+					} elseif ($c == '.') {
+						$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE;
+					} else {
+						$this->finalizeConverter($c);
+					}
+					break;
+			  case LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE:
+					// LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE'");              
+					$this->currentLiteral .= $c;
+					if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
+						$this->formattingInfo->max = ord($c) - ord('0');
+						$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE;
+					} else {
+					  LoggerLog::warn("LoggerPatternParser::parse() Error occured in position {$this->i}. Was expecting digit, instead got char \"{$c}\".");
+					  $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
+					}
+					break;
+			  case LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE:
+					// LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE'");              
+					$this->currentLiteral .= $c;
+					if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
+						$this->formattingInfo->max = ($this->formattingInfo->max * 10) + (ord($c) - ord('0'));
+					} else {
+					  $this->finalizeConverter($c);
+					  $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
+					}
+					break;
+			} // switch
+		} // while
+		if(strlen($this->currentLiteral) != 0) {
+			$this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
+			// LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
+		}
+		return $this->head;
+	}
 
-    public function finalizeConverter($c)
-    {
-        LoggerLog::debug("LoggerPatternParser::finalizeConverter() with char '$c'");    
+	public function finalizeConverter($c)
+	{
+		LoggerLog::debug("LoggerPatternParser::finalizeConverter() with char '$c'");    
 
-        $pc = null;
-        switch($c) {
-            case 'c':
-                $pc = new LoggerCategoryPatternConverter($this->formattingInfo, $this->extractPrecisionOption());
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() CATEGORY converter.");
-                $this->currentLiteral = '';
-                break;
-            case 'C':
-                $pc = new LoggerClassNamePatternConverter($this->formattingInfo, $this->extractPrecisionOption());
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() CLASSNAME converter.");
-                $this->currentLiteral = '';
-                break;
-            case 'd':
-                $dateFormatStr = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601; // ISO8601_DATE_FORMAT;
-                $dOpt = $this->extractOption();
+		$pc = null;
+		switch($c) {
+			case 'c':
+				$pc = new LoggerCategoryPatternConverter($this->formattingInfo, $this->extractPrecisionOption());
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() CATEGORY converter.");
+				$this->currentLiteral = '';
+				break;
+			case 'C':
+				$pc = new LoggerClassNamePatternConverter($this->formattingInfo, $this->extractPrecisionOption());
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() CLASSNAME converter.");
+				$this->currentLiteral = '';
+				break;
+			case 'd':
+				$dateFormatStr = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601; // ISO8601_DATE_FORMAT;
+				$dOpt = $this->extractOption();
 
-                if($dOpt !== null)
-	                $dateFormatStr = $dOpt;
+				if($dOpt !== null)
+					$dateFormatStr = $dOpt;
                     
-                if ($dateFormatStr == 'ISO8601') {
-                    $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
-                } elseif($dateFormatStr == 'ABSOLUTE') {
-                    $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE;
-                } elseif($dateFormatStr == 'DATE') {
-                    $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE;
-                } else {
-                    $df = $dateFormatStr;
-                    if ($df == null) {
-                        $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
-                    }
-	            }
-                $pc = new LoggerDatePatternConverter($this->formattingInfo, $df);
-                $this->currentLiteral = '';
-                break;
-            case 'F':
-                $pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() File name converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'l':
-                $pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() Location converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'L':
-                $pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() LINE NUMBER converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'm':
-                $pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() MESSAGE converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'M':
-                $pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER);
-                //LogLog.debug("METHOD converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'p':
-                $pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER);
-                //LogLog.debug("LEVEL converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'r':
-                $pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() RELATIVE TIME converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 't':
-                $pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() THREAD converter.");
-                //formattingInfo.dump();
-                $this->currentLiteral = '';
-                break;
-            case 'u':
-                if($this->i < $this->patternLength) {
-	                $cNext = $this->pattern{$this->i};
-                    if(ord($cNext) >= ord('0') && ord($cNext) <= ord('9')) {
-	                    $pc = new LoggerUserFieldPatternConverter($this->formattingInfo, (string)(ord($cNext) - ord('0')));
-                        LoggerLog::debug("LoggerPatternParser::finalizeConverter() USER converter [{$cNext}].");
-	                    // formattingInfo.dump();
-                        $this->currentLiteral = '';
-	                    $this->i++;
-	                } else {
-                        LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char '{$cNext}' at position {$this->i}.");
-                    }
-                }
-                break;
-            case 'x':
-                $pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() NDC converter.");
-                $this->currentLiteral = '';
-                break;
+				if ($dateFormatStr == 'ISO8601') {
+					$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
+				} elseif($dateFormatStr == 'ABSOLUTE') {
+					$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE;
+				} elseif($dateFormatStr == 'DATE') {
+					$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE;
+				} else {
+					$df = $dateFormatStr;
+					if ($df == null) {
+						$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
+					}
+				}
+				$pc = new LoggerDatePatternConverter($this->formattingInfo, $df);
+				$this->currentLiteral = '';
+				break;
+			case 'F':
+				$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() File name converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'l':
+				$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() Location converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'L':
+				$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() LINE NUMBER converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'm':
+				$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() MESSAGE converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'M':
+				$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER);
+				//LogLog.debug("METHOD converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'p':
+				$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER);
+				//LogLog.debug("LEVEL converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'r':
+				$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() RELATIVE TIME converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 't':
+				$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() THREAD converter.");
+				//formattingInfo.dump();
+				$this->currentLiteral = '';
+				break;
+			case 'u':
+				if($this->i < $this->patternLength) {
+					$cNext = $this->pattern{$this->i};
+					if(ord($cNext) >= ord('0') && ord($cNext) <= ord('9')) {
+						$pc = new LoggerUserFieldPatternConverter($this->formattingInfo, (string)(ord($cNext) - ord('0')));
+						LoggerLog::debug("LoggerPatternParser::finalizeConverter() USER converter [{$cNext}].");
+						// formattingInfo.dump();
+						$this->currentLiteral = '';
+						$this->i++;
+					} else {
+						LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char '{$cNext}' at position {$this->i}.");
+					}
+				}
+				break;
+			case 'x':
+				$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() NDC converter.");
+				$this->currentLiteral = '';
+				break;
 
-            case 'X':
-                $xOpt = $this->extractOption();
-                $pc = new LoggerMDCPatternConverter($this->formattingInfo, $xOpt);
-                LoggerLog::debug("LoggerPatternParser::finalizeConverter() MDC converter.");
-                $this->currentLiteral = '';
-                break;
-            default:
-                LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char [$c] at position {$this->i} in conversion pattern.");
-                $pc = new LoggerLiteralPatternConverter($this->currentLiteral);
-                $this->currentLiteral = '';
-        }
-        $this->addConverter($pc);
-    }
+			case 'X':
+				$xOpt = $this->extractOption();
+				$pc = new LoggerMDCPatternConverter($this->formattingInfo, $xOpt);
+				LoggerLog::debug("LoggerPatternParser::finalizeConverter() MDC converter.");
+				$this->currentLiteral = '';
+				break;
+			default:
+				LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char [$c] at position {$this->i} in conversion pattern.");
+				$pc = new LoggerLiteralPatternConverter($this->currentLiteral);
+				$this->currentLiteral = '';
+		}
+		$this->addConverter($pc);
+	}
 
-    public function addConverter($pc)
-    {
-        $this->currentLiteral = '';
-        // Add the pattern converter to the list.
-        $this->addToList($pc);
-        // Next pattern is assumed to be a literal.
-        $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
-        // Reset formatting info
-        $this->formattingInfo->reset();
-    }
+	public function addConverter($pc)
+	{
+		$this->currentLiteral = '';
+		// Add the pattern converter to the list.
+		$this->addToList($pc);
+		// Next pattern is assumed to be a literal.
+		$this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
+		// Reset formatting info
+		$this->formattingInfo->reset();
+	}
 }
 
 ?>
\ No newline at end of file

libraries/log4php.debug/LoggerManager.php

Indentation +176 added lines, -176 removed lines

@@ -47,101 +47,101 @@ 
 		}
 		return self::$loggerCache;
 	}
-    /**
-     * check if a given logger exists.
-     * 
-     * @param string $name logger name 
-     * @static
-     * @return boolean
-     */
-    public function exists($name)
-    {
-        $repository =& LoggerManager::getLoggerRepository();
-        return $repository->exists($name);
-    }
+	/**
+	 * check if a given logger exists.
+	 * 
+	 * @param string $name logger name 
+	 * @static
+	 * @return boolean
+	 */
+	public function exists($name)
+	{
+		$repository =& LoggerManager::getLoggerRepository();
+		return $repository->exists($name);
+	}
 
-    /**
-     * Returns an array this whole Logger instances.
-     * 
-     * @static
-     * @see Logger
-     * @return array
-     */
-    public function getCurrentLoggers()
-    {
-        $repository =& LoggerManager::getLoggerRepository();
-        return $repository->getCurrentLoggers();
-    }
+	/**
+	 * Returns an array this whole Logger instances.
+	 * 
+	 * @static
+	 * @see Logger
+	 * @return array
+	 */
+	public function getCurrentLoggers()
+	{
+		$repository =& LoggerManager::getLoggerRepository();
+		return $repository->getCurrentLoggers();
+	}
     
-    /**
-     * Returns the root logger.
-     * 
-     * @static
-     * @return object
-     * @see LoggerRoot
-     */
-    public function &getRootLogger()
-    {
-        $repository =& LoggerManager::getLoggerRepository();
-        return $repository->getRootLogger();
-    }
+	/**
+	 * Returns the root logger.
+	 * 
+	 * @static
+	 * @return object
+	 * @see LoggerRoot
+	 */
+	public function &getRootLogger()
+	{
+		$repository =& LoggerManager::getLoggerRepository();
+		return $repository->getRootLogger();
+	}
     
-    /**
-     * Returns the specified Logger.
-     * 
-     * @param string $name logger name
-     * @param LoggerFactory $factory a {@link LoggerFactory} instance or null
-     * @static
-     * @return Logger
-     */
-    public function &getLogger($name, $factory = null)
-    {
-        $repository =& LoggerManager::getLoggerRepository();
-        return $repository->getLogger($name, $factory);
-    }
+	/**
+	 * Returns the specified Logger.
+	 * 
+	 * @param string $name logger name
+	 * @param LoggerFactory $factory a {@link LoggerFactory} instance or null
+	 * @static
+	 * @return Logger
+	 */
+	public function &getLogger($name, $factory = null)
+	{
+		$repository =& LoggerManager::getLoggerRepository();
+		return $repository->getLogger($name, $factory);
+	}
     
-    /**
-     * Returns the LoggerHierarchy.
-     * 
-     * @static
-     * @return LoggerHierarchy
-     */
-    public function &getLoggerRepository()
-    {
-        return LoggerHierarchy::singleton();    
-    }
+	/**
+	 * Returns the LoggerHierarchy.
+	 * 
+	 * @static
+	 * @return LoggerHierarchy
+	 */
+	public function &getLoggerRepository()
+	{
+		return LoggerHierarchy::singleton();    
+	}
     
 
-    /**
-     * Destroy loggers object tree.
-     * 
-     * @static
-     * @return boolean 
-     */
-    public function resetConfiguration()
-    {
-        $repository =& LoggerManager::getLoggerRepository();    
-        return $repository->resetConfiguration();    
-    }
+	/**
+	 * Destroy loggers object tree.
+	 * 
+	 * @static
+	 * @return boolean 
+	 */
+	public function resetConfiguration()
+	{
+		$repository =& LoggerManager::getLoggerRepository();    
+		return $repository->resetConfiguration();    
+	}
     
-    /**
-     * Does nothing.
-     * @static
-     */
-    public function setRepositorySelector($selector, $guard)
-    {
-        return;
-    }
+	/**
+	 * Does nothing.
+	 * @static
+	 */
+	public function setRepositorySelector($selector, $guard)
+	{
+		return;
+	}
     
-    /**
-     * Safely close all appenders.
-     * @static
-     */
-    public function shutdown()
-    {
-        $repository =& LoggerManager::getLoggerRepository();    
-        return $repository->shutdown();    
-    }
+	/**
+	 * Safely close all appenders.
+	 * @static
+	 */
+	public function shutdown()
+	{
+		$repository =& LoggerManager::getLoggerRepository();    
+		return $repository->shutdown();    
+	}
 }
 
 // ---------------------------------------------------------------------------
@@ -149,94 +149,94 @@ 
 // ---------------------------------------------------------------------------
 
 if (!defined('LOG4PHP_DEFAULT_INIT_OVERRIDE')) {
-    if (isset($_ENV['log4php.defaultInitOverride'])) {
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_DEFAULT_INIT_OVERRIDE', 
-            LoggerOptionConverter::toBoolean($_ENV['log4php.defaultInitOverride'], false)
-        );
-    } elseif (isset($GLOBALS['log4php.defaultInitOverride'])) {
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_DEFAULT_INIT_OVERRIDE', 
-            LoggerOptionConverter::toBoolean($GLOBALS['log4php.defaultInitOverride'], false)
-        );
-    } else {
-        /**
-         * Controls init execution
-         *
-         * With this constant users can skip the default init procedure that is
-         * called when this file is included.
-         *
-         * <p>If it is not user defined, log4php tries to autoconfigure using (in order):</p>
-         *
-         * - the <code>$_ENV['log4php.defaultInitOverride']</code> variable.
-         * - the <code>$GLOBALS['log4php.defaultInitOverride']</code> global variable.
-         * - defaults to <i>false</i>
-         *
-         * @var boolean
-         */
-        define('LOG4PHP_DEFAULT_INIT_OVERRIDE', false);
-    }
+	if (isset($_ENV['log4php.defaultInitOverride'])) {
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_DEFAULT_INIT_OVERRIDE', 
+			LoggerOptionConverter::toBoolean($_ENV['log4php.defaultInitOverride'], false)
+		);
+	} elseif (isset($GLOBALS['log4php.defaultInitOverride'])) {
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_DEFAULT_INIT_OVERRIDE', 
+			LoggerOptionConverter::toBoolean($GLOBALS['log4php.defaultInitOverride'], false)
+		);
+	} else {
+		/**
+		 * Controls init execution
+		 *
+		 * With this constant users can skip the default init procedure that is
+		 * called when this file is included.
+		 *
+		 * <p>If it is not user defined, log4php tries to autoconfigure using (in order):</p>
+		 *
+		 * - the <code>$_ENV['log4php.defaultInitOverride']</code> variable.
+		 * - the <code>$GLOBALS['log4php.defaultInitOverride']</code> global variable.
+		 * - defaults to <i>false</i>
+		 *
+		 * @var boolean
+		 */
+		define('LOG4PHP_DEFAULT_INIT_OVERRIDE', false);
+	}
 }
 
 if (!defined('LOG4PHP_CONFIGURATION')) {
-    if (isset($_ENV['log4php.configuration'])) {
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_CONFIGURATION', trim($_ENV['log4php.configuration']));
-    } else {
-        /**
-         * Configuration file.
-         *
-         * <p>This constant tells configurator classes where the configuration
-         * file is located.</p>
-         * <p>If not set by user, log4php tries to set it automatically using 
-         * (in order):</p>
-         *
-         * - the <code>$_ENV['log4php.configuration']</code> enviroment variable.
-         * - defaults to 'log4php.properties'.
-         *
-         * @var string
-         */
-        define('LOG4PHP_CONFIGURATION', 'config/log4php.properties');
-    }
+	if (isset($_ENV['log4php.configuration'])) {
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_CONFIGURATION', trim($_ENV['log4php.configuration']));
+	} else {
+		/**
+		 * Configuration file.
+		 *
+		 * <p>This constant tells configurator classes where the configuration
+		 * file is located.</p>
+		 * <p>If not set by user, log4php tries to set it automatically using 
+		 * (in order):</p>
+		 *
+		 * - the <code>$_ENV['log4php.configuration']</code> enviroment variable.
+		 * - defaults to 'log4php.properties'.
+		 *
+		 * @var string
+		 */
+		define('LOG4PHP_CONFIGURATION', 'config/log4php.properties');
+	}
 }
 
 if (!defined('LOG4PHP_CONFIGURATOR_CLASS')) {
-    if ( strtolower(substr( LOG4PHP_CONFIGURATION, -4 )) == '.xml') { 
-        /**
-         * @ignore
-         */
-        define('LOG4PHP_CONFIGURATOR_CLASS', LOG4PHP_DIR . '/xml/LoggerDOMConfigurator');
-    } else {
-        /**
-         * Holds the configurator class name.
-         *
-         * <p>This constant is set with the fullname (path included but non the 
-         * .php extension) of the configurator class that init procedure will use.</p>
-         * <p>If not set by user, log4php tries to set it automatically.</p>
-         * <p>If {@link LOG4PHP_CONFIGURATION} has '.xml' extension set the 
-         * constants to '{@link LOG4PHP_DIR}/xml/{@link LoggerDOMConfigurator}'.</p>
-         * <p>Otherwise set the constants to 
-         * '{@link LOG4PHP_DIR}/{@link LoggerPropertyConfigurator}'.</p>
-         *
-         * <p><b>Security Note</b>: classfile pointed by this constant will be brutally
-         * included with a:
-         * <code>@include_once(LOG4PHP_CONFIGURATOR_CLASS . ".php");</code></p>
-         *
-         * @var string
-         */
-        define('LOG4PHP_CONFIGURATOR_CLASS', LOG4PHP_DIR . '/LoggerPropertyConfigurator');
-    }
+	if ( strtolower(substr( LOG4PHP_CONFIGURATION, -4 )) == '.xml') { 
+		/**
+		 * @ignore
+		 */
+		define('LOG4PHP_CONFIGURATOR_CLASS', LOG4PHP_DIR . '/xml/LoggerDOMConfigurator');
+	} else {
+		/**
+		 * Holds the configurator class name.
+		 *
+		 * <p>This constant is set with the fullname (path included but non the 
+		 * .php extension) of the configurator class that init procedure will use.</p>
+		 * <p>If not set by user, log4php tries to set it automatically.</p>
+		 * <p>If {@link LOG4PHP_CONFIGURATION} has '.xml' extension set the 
+		 * constants to '{@link LOG4PHP_DIR}/xml/{@link LoggerDOMConfigurator}'.</p>
+		 * <p>Otherwise set the constants to 
+		 * '{@link LOG4PHP_DIR}/{@link LoggerPropertyConfigurator}'.</p>
+		 *
+		 * <p><b>Security Note</b>: classfile pointed by this constant will be brutally
+		 * included with a:
+		 * <code>@include_once(LOG4PHP_CONFIGURATOR_CLASS . ".php");</code></p>
+		 *
+		 * @var string
+		 */
+		define('LOG4PHP_CONFIGURATOR_CLASS', LOG4PHP_DIR . '/LoggerPropertyConfigurator');
+	}
 }
 
 if (!LOG4PHP_DEFAULT_INIT_OVERRIDE) {
-    if (!LoggerManagerDefaultInit())
-        LoggerLog::warn("LOG4PHP main() Default Init failed.");
+	if (!LoggerManagerDefaultInit())
+		LoggerLog::warn("LOG4PHP main() Default Init failed.");
 }
 
 /**
@@ -253,16 +253,16 @@ 
  */
 function LoggerManagerDefaultInit()
 {
-    $configuratorClass = basename(LOG4PHP_CONFIGURATOR_CLASS);
-    if (!class_exists($configuratorClass)) {
-        @include_once(LOG4PHP_CONFIGURATOR_CLASS . ".php");
-    }
-    if (class_exists($configuratorClass)) {
+	$configuratorClass = basename(LOG4PHP_CONFIGURATOR_CLASS);
+	if (!class_exists($configuratorClass)) {
+		@include_once(LOG4PHP_CONFIGURATOR_CLASS . ".php");
+	}
+	if (class_exists($configuratorClass)) {
         
-        return call_user_func(array($configuratorClass, 'configure'), LOG4PHP_CONFIGURATION);         
+		return call_user_func(array($configuratorClass, 'configure'), LOG4PHP_CONFIGURATION);         
 
-    } else {
-        LoggerLog::warn("LoggerManagerDefaultInit() Configurator '{$configuratorClass}' doesnt exists");
-        return false;
-    }
+	} else {
+		LoggerLog::warn("LoggerManagerDefaultInit() Configurator '{$configuratorClass}' doesnt exists");
+		return false;
+	}
 }

libraries/log4php.debug/LoggerPropertyConfigurator.php

Indentation +521 added lines, -521 removed lines

@@ -91,560 +91,560 @@
  */
 class LoggerPropertyConfigurator extends LoggerConfigurator {
 
-    /**
-     * @var LoggerFactory
-     */
-    var $loggerFactory = null;
+	/**
+	 * @var LoggerFactory
+	 */
+	var $loggerFactory = null;
     
-    /**
-     * Constructor
-     */
-    public function LoggerPropertyConfigurator()
-    {
-        $this->loggerFactory = new LoggerDefaultCategoryFactory();
-    }
+	/**
+	 * Constructor
+	 */
+	public function LoggerPropertyConfigurator()
+	{
+		$this->loggerFactory = new LoggerDefaultCategoryFactory();
+	}
     
-    /**
-     * Configure the default repository using the resource pointed by <b>url</b>.
-     * <b>Url</b> is any valid resurce as defined in {@link PHP_MANUAL#file} function.
-     * Note that the resource will be search with <i>use_include_path</i> parameter 
-     * set to "1".
-     *
-     * @param string $url
-     * @return boolean configuration result
-     * @static
-     */
-    public function configure($url = '')
-    {
-        $configurator = new LoggerPropertyConfigurator();
-        $repository =& LoggerManager::getLoggerRepository();
-        return $configurator->doConfigure($url, $repository);
-    }
+	/**
+	 * Configure the default repository using the resource pointed by <b>url</b>.
+	 * <b>Url</b> is any valid resurce as defined in {@link PHP_MANUAL#file} function.
+	 * Note that the resource will be search with <i>use_include_path</i> parameter 
+	 * set to "1".
+	 *
+	 * @param string $url
+	 * @return boolean configuration result
+	 * @static
+	 */
+	public function configure($url = '')
+	{
+		$configurator = new LoggerPropertyConfigurator();
+		$repository =& LoggerManager::getLoggerRepository();
+		return $configurator->doConfigure($url, $repository);
+	}
 
-    /**
-     * Read configuration from a file.
-     *
-     * <p>The function {@link PHP_MANUAL#parse_ini_file} is used to read the
-     * file.</p>
-     *
-     * <b>The existing configuration is not cleared nor reset.</b> 
-     * If you require a different behavior, then call 
-     * {@link  LoggerManager::resetConfiguration()} 
-     * method before calling {@link doConfigure()}.
-     * 
-     * <p>The configuration file consists of statements in the format
-     * <b>key=value</b>. The syntax of different configuration
-     * elements are discussed below.
-     * 
-     * <p><b>Repository-wide threshold</b></p>
-     * 
-     * <p>The repository-wide threshold filters logging requests by level
-     * regardless of logger. The syntax is:
-     * 
-     * <pre>
-     * log4php.threshold=[level]
-     * </pre>
-     * 
-     * <p>The level value can consist of the string values OFF, FATAL,
-     * ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
-     * custom level value can be specified in the form
-     * <samp>level#classname</samp>. By default the repository-wide threshold is set
-     * to the lowest possible value, namely the level <b>ALL</b>.
-     * </p>
-     * 
-     * 
-     * <p><b>Appender configuration</b></p>
-     * 
-     * <p>Appender configuration syntax is:</p>
-     * <pre>
-     * ; For appender named <i>appenderName</i>, set its class.
-     * ; Note: The appender name can contain dots.
-     * log4php.appender.appenderName=name_of_appender_class
-     * 
-     * ; Set appender specific options.
-     * 
-     * log4php.appender.appenderName.option1=value1
-     * log4php.appender.appenderName.optionN=valueN
-     * </pre>
-     * 
-     * For each named appender you can configure its {@link LoggerLayout}. The
-     * syntax for configuring an appender's layout is:
-     * <pre>
-     * log4php.appender.appenderName.layout=name_of_layout_class
-     * log4php.appender.appenderName.layout.option1=value1
-     *  ....
-     * log4php.appender.appenderName.layout.optionN=valueN
-     * </pre>
-     * 
-     * <p><b>Configuring loggers</b></p>
-     * 
-     * <p>The syntax for configuring the root logger is:
-     * <pre>
-     * log4php.rootLogger=[level], appenderName, appenderName, ...
-     * </pre>
-     * 
-     * <p>This syntax means that an optional <i>level</i> can be
-     * supplied followed by appender names separated by commas.
-     * 
-     * <p>The level value can consist of the string values OFF, FATAL,
-     * ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
-     * custom level value can be specified in the form</p>
-     *
-     * <pre>level#classname</pre>
-     * 
-     * <p>If a level value is specified, then the root level is set
-     * to the corresponding level.  If no level value is specified,
-     * then the root level remains untouched.
-     * 
-     * <p>The root logger can be assigned multiple appenders.
-     * 
-     * <p>Each <i>appenderName</i> (separated by commas) will be added to
-     * the root logger. The named appender is defined using the
-     * appender syntax defined above.
-     * 
-     * <p>For non-root categories the syntax is almost the same:
-     * <pre>
-     * log4php.logger.logger_name=[level|INHERITED|NULL], appenderName, appenderName, ...
-     * </pre>
-     * 
-     * <p>The meaning of the optional level value is discussed above
-     * in relation to the root logger. In addition however, the value
-     * INHERITED can be specified meaning that the named logger should
-     * inherit its level from the logger hierarchy.</p>
-     * 
-     * <p>If no level value is supplied, then the level of the
-     * named logger remains untouched.</p>
-     * 
-     * <p>By default categories inherit their level from the
-     * hierarchy. However, if you set the level of a logger and later
-     * decide that that logger should inherit its level, then you should
-     * specify INHERITED as the value for the level value. NULL is a
-     * synonym for INHERITED.</p>
-     * 
-     * <p>Similar to the root logger syntax, each <i>appenderName</i>
-     * (separated by commas) will be attached to the named logger.</p>
-     * 
-     * <p>See the <i>appender additivity rule</i> in the user manual for 
-     * the meaning of the <b>additivity</b> flag.
-     * 
-     * <p><b>ObjectRenderers</b></p>
-     * 
-     * <p>You can customize the way message objects of a given type are
-     * converted to String before being logged. This is done by
-     * specifying a {@link LoggerObjectRenderer}
-     * for the object type would like to customize.</p>
-     * 
-     * <p>The syntax is:
-     * 
-     * <pre>
-     * log4php.renderer.name_of_rendered_class=name_of_rendering.class
-     * </pre>
-     * 
-     * As in,
-     * <pre>
-     * log4php.renderer.myFruit=myFruitRenderer
-     * </pre>
-     * 
-     * <p><b>Logger Factories</b></p>
-     * 
-     * The usage of custom logger factories is discouraged and no longer
-     * documented.
-     * 
-     * <p><b>Example</b></p>
-     * 
-     * <p>An example configuration is given below. Other configuration
-     * file examples are given in the <b>tests</b> folder.
-     * 
-     * <pre>
-     * ; Set options for appender named "A1".
-     * ; Appender "A1" will be a SyslogAppender
-     * log4php.appender.A1=SyslogAppender
-     * 
-     * ; The syslog daemon resides on www.abc.net
-     * log4php.appender.A1.SyslogHost=www.abc.net
-     * 
-     * ; A1's layout is a LoggerPatternLayout, using the conversion pattern
-     * ; <b>%r %-5p %c{2} %M.%L %x - %m%n</b>. Thus, the log output will
-     * ; include the relative time since the start of the application in
-     * ; milliseconds, followed by the level of the log request,
-     * ; followed by the two rightmost components of the logger name,
-     * ; followed by the callers method name, followed by the line number,
-     * ; the nested disgnostic context and finally the message itself.
-     * ; Refer to the documentation of LoggerPatternLayout} for further information
-     * ; on the syntax of the ConversionPattern key.
-     * log4php.appender.A1.layout=LoggerPatternLayout
-     * log4php.appender.A1.layout.ConversionPattern="%-4r %-5p %c{2} %M.%L %x - %m%n"
-     * 
-     * ; Set options for appender named "A2"
-     * ; A2 should be a LoggerAppenderRollingFile, with maximum file size of 10 MB
-     * ; using at most one backup file. A2's layout is TTCC, using the
-     * ; ISO8061 date format with context printing enabled.
-     * log4php.appender.A2=LoggerAppenderRollingFile
-     * log4php.appender.A2.MaxFileSize=10MB
-     * log4php.appender.A2.MaxBackupIndex=1
-     * log4php.appender.A2.layout=LoggerLayoutTTCC
-     * log4php.appender.A2.layout.ContextPrinting="true"
-     * log4php.appender.A2.layout.DateFormat="%c"
-     * 
-     * ; Root logger set to DEBUG using the A2 appender defined above.
-     * log4php.rootLogger=DEBUG, A2
-     * 
-     * ; Logger definitions:
-     * ; The SECURITY logger inherits is level from root. However, it's output
-     * ; will go to A1 appender defined above. It's additivity is non-cumulative.
-     * log4php.logger.SECURITY=INHERIT, A1
-     * log4php.additivity.SECURITY=false
-     * 
-     * ; Only warnings or above will be logged for the logger "SECURITY.access".
-     * ; Output will go to A1.
-     * log4php.logger.SECURITY.access=WARN
-     * 
-     * 
-     * ; The logger "class.of.the.day" inherits its level from the
-     * ; logger hierarchy.  Output will go to the appender's of the root
-     * ; logger, A2 in this case.
-     * log4php.logger.class.of.the.day=INHERIT
-     * </pre>
-     * 
-     * <p>Refer to the <b>setOption</b> method in each Appender and
-     * Layout for class specific options.</p>
-     * 
-     * <p>Use the <b>&quot;;&quot;</b> character at the
-     * beginning of a line for comments.</p>
-     * 
-     * @param string $url The name of the configuration file where the
-     *                    configuration information is stored.
-     * @param LoggerHierarchy &$repository the repository to apply the configuration
-     */
-    public function doConfigure($url, &$repository)
-    {
-        $properties = @parse_ini_file($url);
-        if ($properties === false) {
-            LoggerLog::warn("LoggerPropertyConfigurator::doConfigure() cannot load '$url' configuration.");
-            return false; 
-        }
-        return $this->doConfigureProperties($properties, $repository);
-    }
+	/**
+	 * Read configuration from a file.
+	 *
+	 * <p>The function {@link PHP_MANUAL#parse_ini_file} is used to read the
+	 * file.</p>
+	 *
+	 * <b>The existing configuration is not cleared nor reset.</b> 
+	 * If you require a different behavior, then call 
+	 * {@link  LoggerManager::resetConfiguration()} 
+	 * method before calling {@link doConfigure()}.
+	 * 
+	 * <p>The configuration file consists of statements in the format
+	 * <b>key=value</b>. The syntax of different configuration
+	 * elements are discussed below.
+	 * 
+	 * <p><b>Repository-wide threshold</b></p>
+	 * 
+	 * <p>The repository-wide threshold filters logging requests by level
+	 * regardless of logger. The syntax is:
+	 * 
+	 * <pre>
+	 * log4php.threshold=[level]
+	 * </pre>
+	 * 
+	 * <p>The level value can consist of the string values OFF, FATAL,
+	 * ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
+	 * custom level value can be specified in the form
+	 * <samp>level#classname</samp>. By default the repository-wide threshold is set
+	 * to the lowest possible value, namely the level <b>ALL</b>.
+	 * </p>
+	 * 
+	 * 
+	 * <p><b>Appender configuration</b></p>
+	 * 
+	 * <p>Appender configuration syntax is:</p>
+	 * <pre>
+	 * ; For appender named <i>appenderName</i>, set its class.
+	 * ; Note: The appender name can contain dots.
+	 * log4php.appender.appenderName=name_of_appender_class
+	 * 
+	 * ; Set appender specific options.
+	 * 
+	 * log4php.appender.appenderName.option1=value1
+	 * log4php.appender.appenderName.optionN=valueN
+	 * </pre>
+	 * 
+	 * For each named appender you can configure its {@link LoggerLayout}. The
+	 * syntax for configuring an appender's layout is:
+	 * <pre>
+	 * log4php.appender.appenderName.layout=name_of_layout_class
+	 * log4php.appender.appenderName.layout.option1=value1
+	 *  ....
+	 * log4php.appender.appenderName.layout.optionN=valueN
+	 * </pre>
+	 * 
+	 * <p><b>Configuring loggers</b></p>
+	 * 
+	 * <p>The syntax for configuring the root logger is:
+	 * <pre>
+	 * log4php.rootLogger=[level], appenderName, appenderName, ...
+	 * </pre>
+	 * 
+	 * <p>This syntax means that an optional <i>level</i> can be
+	 * supplied followed by appender names separated by commas.
+	 * 
+	 * <p>The level value can consist of the string values OFF, FATAL,
+	 * ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
+	 * custom level value can be specified in the form</p>
+	 *
+	 * <pre>level#classname</pre>
+	 * 
+	 * <p>If a level value is specified, then the root level is set
+	 * to the corresponding level.  If no level value is specified,
+	 * then the root level remains untouched.
+	 * 
+	 * <p>The root logger can be assigned multiple appenders.
+	 * 
+	 * <p>Each <i>appenderName</i> (separated by commas) will be added to
+	 * the root logger. The named appender is defined using the
+	 * appender syntax defined above.
+	 * 
+	 * <p>For non-root categories the syntax is almost the same:
+	 * <pre>
+	 * log4php.logger.logger_name=[level|INHERITED|NULL], appenderName, appenderName, ...
+	 * </pre>
+	 * 
+	 * <p>The meaning of the optional level value is discussed above
+	 * in relation to the root logger. In addition however, the value
+	 * INHERITED can be specified meaning that the named logger should
+	 * inherit its level from the logger hierarchy.</p>
+	 * 
+	 * <p>If no level value is supplied, then the level of the
+	 * named logger remains untouched.</p>
+	 * 
+	 * <p>By default categories inherit their level from the
+	 * hierarchy. However, if you set the level of a logger and later
+	 * decide that that logger should inherit its level, then you should
+	 * specify INHERITED as the value for the level value. NULL is a
+	 * synonym for INHERITED.</p>
+	 * 
+	 * <p>Similar to the root logger syntax, each <i>appenderName</i>
+	 * (separated by commas) will be attached to the named logger.</p>
+	 * 
+	 * <p>See the <i>appender additivity rule</i> in the user manual for 
+	 * the meaning of the <b>additivity</b> flag.
+	 * 
+	 * <p><b>ObjectRenderers</b></p>
+	 * 
+	 * <p>You can customize the way message objects of a given type are
+	 * converted to String before being logged. This is done by
+	 * specifying a {@link LoggerObjectRenderer}
+	 * for the object type would like to customize.</p>
+	 * 
+	 * <p>The syntax is:
+	 * 
+	 * <pre>
+	 * log4php.renderer.name_of_rendered_class=name_of_rendering.class
+	 * </pre>
+	 * 
+	 * As in,
+	 * <pre>
+	 * log4php.renderer.myFruit=myFruitRenderer
+	 * </pre>
+	 * 
+	 * <p><b>Logger Factories</b></p>
+	 * 
+	 * The usage of custom logger factories is discouraged and no longer
+	 * documented.
+	 * 
+	 * <p><b>Example</b></p>
+	 * 
+	 * <p>An example configuration is given below. Other configuration
+	 * file examples are given in the <b>tests</b> folder.
+	 * 
+	 * <pre>
+	 * ; Set options for appender named "A1".
+	 * ; Appender "A1" will be a SyslogAppender
+	 * log4php.appender.A1=SyslogAppender
+	 * 
+	 * ; The syslog daemon resides on www.abc.net
+	 * log4php.appender.A1.SyslogHost=www.abc.net
+	 * 
+	 * ; A1's layout is a LoggerPatternLayout, using the conversion pattern
+	 * ; <b>%r %-5p %c{2} %M.%L %x - %m%n</b>. Thus, the log output will
+	 * ; include the relative time since the start of the application in
+	 * ; milliseconds, followed by the level of the log request,
+	 * ; followed by the two rightmost components of the logger name,
+	 * ; followed by the callers method name, followed by the line number,
+	 * ; the nested disgnostic context and finally the message itself.
+	 * ; Refer to the documentation of LoggerPatternLayout} for further information
+	 * ; on the syntax of the ConversionPattern key.
+	 * log4php.appender.A1.layout=LoggerPatternLayout
+	 * log4php.appender.A1.layout.ConversionPattern="%-4r %-5p %c{2} %M.%L %x - %m%n"
+	 * 
+	 * ; Set options for appender named "A2"
+	 * ; A2 should be a LoggerAppenderRollingFile, with maximum file size of 10 MB
+	 * ; using at most one backup file. A2's layout is TTCC, using the
+	 * ; ISO8061 date format with context printing enabled.
+	 * log4php.appender.A2=LoggerAppenderRollingFile
+	 * log4php.appender.A2.MaxFileSize=10MB
+	 * log4php.appender.A2.MaxBackupIndex=1
+	 * log4php.appender.A2.layout=LoggerLayoutTTCC
+	 * log4php.appender.A2.layout.ContextPrinting="true"
+	 * log4php.appender.A2.layout.DateFormat="%c"
+	 * 
+	 * ; Root logger set to DEBUG using the A2 appender defined above.
+	 * log4php.rootLogger=DEBUG, A2
+	 * 
+	 * ; Logger definitions:
+	 * ; The SECURITY logger inherits is level from root. However, it's output
+	 * ; will go to A1 appender defined above. It's additivity is non-cumulative.
+	 * log4php.logger.SECURITY=INHERIT, A1
+	 * log4php.additivity.SECURITY=false
+	 * 
+	 * ; Only warnings or above will be logged for the logger "SECURITY.access".
+	 * ; Output will go to A1.
+	 * log4php.logger.SECURITY.access=WARN
+	 * 
+	 * 
+	 * ; The logger "class.of.the.day" inherits its level from the
+	 * ; logger hierarchy.  Output will go to the appender's of the root
+	 * ; logger, A2 in this case.
+	 * log4php.logger.class.of.the.day=INHERIT
+	 * </pre>
+	 * 
+	 * <p>Refer to the <b>setOption</b> method in each Appender and
+	 * Layout for class specific options.</p>
+	 * 
+	 * <p>Use the <b>&quot;;&quot;</b> character at the
+	 * beginning of a line for comments.</p>
+	 * 
+	 * @param string $url The name of the configuration file where the
+	 *                    configuration information is stored.
+	 * @param LoggerHierarchy &$repository the repository to apply the configuration
+	 */
+	public function doConfigure($url, &$repository)
+	{
+		$properties = @parse_ini_file($url);
+		if ($properties === false) {
+			LoggerLog::warn("LoggerPropertyConfigurator::doConfigure() cannot load '$url' configuration.");
+			return false; 
+		}
+		return $this->doConfigureProperties($properties, $repository);
+	}
 
 
-    /**
-     * Read configuration options from <b>properties</b>.
-     *
-     * @see doConfigure().
-     * @param array $properties
-     * @param LoggerHierarchy &$hierarchy
-     */
-    public function doConfigureProperties($properties, &$hierarchy)
-    {
-        $value = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_DEBUG_KEY];
+	/**
+	 * Read configuration options from <b>properties</b>.
+	 *
+	 * @see doConfigure().
+	 * @param array $properties
+	 * @param LoggerHierarchy &$hierarchy
+	 */
+	public function doConfigureProperties($properties, &$hierarchy)
+	{
+		$value = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_DEBUG_KEY];
         
-        if (!empty($value)) {
-            LoggerLog::internalDebugging(LoggerOptionConverter::toBoolean($value, LoggerLog::internalDebugging()));
-        }
+		if (!empty($value)) {
+			LoggerLog::internalDebugging(LoggerOptionConverter::toBoolean($value, LoggerLog::internalDebugging()));
+		}
 
-        $thresholdStr = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_THRESHOLD_PREFIX];
-        $hierarchy->setThreshold(LoggerOptionConverter::toLevel($thresholdStr, LoggerLevel::getLevelAll()));
+		$thresholdStr = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_THRESHOLD_PREFIX];
+		$hierarchy->setThreshold(LoggerOptionConverter::toLevel($thresholdStr, LoggerLevel::getLevelAll()));
         
-        $this->configureRootCategory($properties, $hierarchy);
-        $this->configureLoggerFactory($properties);
-        $this->parseCatsAndRenderers($properties, $hierarchy);
+		$this->configureRootCategory($properties, $hierarchy);
+		$this->configureLoggerFactory($properties);
+		$this->parseCatsAndRenderers($properties, $hierarchy);
 
-        LoggerLog::debug("LoggerPropertyConfigurator::doConfigureProperties() Finished configuring.");
+		LoggerLog::debug("LoggerPropertyConfigurator::doConfigureProperties() Finished configuring.");
         
-        return true;
-    }
+		return true;
+	}
 
-    // --------------------------------------------------------------------------
-    // Internal stuff
-    // --------------------------------------------------------------------------
+	// --------------------------------------------------------------------------
+	// Internal stuff
+	// --------------------------------------------------------------------------
 
-    /**
-     * Check the provided <b>Properties</b> object for a
-     * {@link LoggerFactory} entry specified by 
-     * {@link LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY}.
-     *  
-     * If such an entry exists, an attempt is made to create an instance using 
-     * the default constructor.  
-     * This instance is used for subsequent Category creations
-     * within this configurator.
-     *
-     * @see parseCatsAndRenderers()
-     * @param array $props array of properties
-     */
-    public function configureLoggerFactory($props)
-    {
-        $factoryFqcn = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY];
-        if(!empty($factoryFqcn)) {
-            $factoryClassName = basename($factoryFqcn);
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::configureLoggerFactory() Trying to load factory [" .
-                $factoryClassName . 
-                "]."
-            );
+	/**
+	 * Check the provided <b>Properties</b> object for a
+	 * {@link LoggerFactory} entry specified by 
+	 * {@link LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY}.
+	 *  
+	 * If such an entry exists, an attempt is made to create an instance using 
+	 * the default constructor.  
+	 * This instance is used for subsequent Category creations
+	 * within this configurator.
+	 *
+	 * @see parseCatsAndRenderers()
+	 * @param array $props array of properties
+	 */
+	public function configureLoggerFactory($props)
+	{
+		$factoryFqcn = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY];
+		if(!empty($factoryFqcn)) {
+			$factoryClassName = basename($factoryFqcn);
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::configureLoggerFactory() Trying to load factory [" .
+				$factoryClassName . 
+				"]."
+			);
             
-            if (!class_exists($factoryClassName))
-                @include_once("{$factoryFqcn}.php");
-            if (class_exists($factoryClassName)) {
-                $loggerFactory = new $factoryClassName();
-            } else {
-                LoggerLog::debug(
-                    "LoggerPropertyConfigurator::configureLoggerFactory() Unable to load factory [" .
-                    $factoryClassName . 
-                    "]. Using default."
-                );
-                $loggerFactory = $this->loggerFactory;
-            }
+			if (!class_exists($factoryClassName))
+				@include_once("{$factoryFqcn}.php");
+			if (class_exists($factoryClassName)) {
+				$loggerFactory = new $factoryClassName();
+			} else {
+				LoggerLog::debug(
+					"LoggerPropertyConfigurator::configureLoggerFactory() Unable to load factory [" .
+					$factoryClassName . 
+					"]. Using default."
+				);
+				$loggerFactory = $this->loggerFactory;
+			}
 
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::configureLoggerFactory() ".
-                "Setting properties for category factory [" . get_class($loggerFactory) . "]."
-            );
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::configureLoggerFactory() ".
+				"Setting properties for category factory [" . get_class($loggerFactory) . "]."
+			);
             
-            LoggerPropertySetter::setPropertiesByObject($loggerFactory, $props, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_FACTORY_PREFIX . ".");
-        }
-    }
+			LoggerPropertySetter::setPropertiesByObject($loggerFactory, $props, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_FACTORY_PREFIX . ".");
+		}
+	}
     
-    /**
-     * @param array $props array of properties
-     * @param LoggerHierarchy &$hierarchy
-     */
-    public function configureRootCategory($props, &$hierarchy)
-    {
-        $effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX;
-        $value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX];
+	/**
+	 * @param array $props array of properties
+	 * @param LoggerHierarchy &$hierarchy
+	 */
+	public function configureRootCategory($props, &$hierarchy)
+	{
+		$effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX;
+		$value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX];
 
-        if(empty($value)) {
-            $value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX];
-            $effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX;
-        }
+		if(empty($value)) {
+			$value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX];
+			$effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX;
+		}
 
-        if (empty($value)) {
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::configureRootCategory() ".
-                "Could not find root logger information. Is this OK?"
-            );
-        } else {
-            $root =& $hierarchy->getRootLogger();
-            // synchronized(root) {
-        	$this->parseCategory(
-                $props, 
-                $root, 
-                $effectivePrefix, 
-                LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME, 
-                $value
-            );
-            // }
-        }
-    }
+		if (empty($value)) {
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::configureRootCategory() ".
+				"Could not find root logger information. Is this OK?"
+			);
+		} else {
+			$root =& $hierarchy->getRootLogger();
+			// synchronized(root) {
+			$this->parseCategory(
+				$props, 
+				$root, 
+				$effectivePrefix, 
+				LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME, 
+				$value
+			);
+			// }
+		}
+	}
 
-    /**
-     * Parse non-root elements, such non-root categories and renderers.
-     *
-     * @param array $props array of properties
-     * @param LoggerHierarchy &$hierarchy
-     */
-    public function parseCatsAndRenderers($props, &$hierarchy)
-    {
-        while(list($key,$value) = each($props)) {
-            if( strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0 || 
-                strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
-	            if(strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0) {
-                    $loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX));
-	            } elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
-                    $loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX));
-                }
-                $logger =& $hierarchy->getLogger($loggerName, $this->loggerFactory);
-	            // synchronized(logger) {
-	            $this->parseCategory($props, $logger, $key, $loggerName, $value);
-        	    $this->parseAdditivityForLogger($props, $logger, $loggerName);
-	            // }
-            } elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX) === 0) {
-                $renderedClass = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX));
-	            $renderingClass = $value;
-            	if (method_exists($hierarchy, 'addrenderer')) {
-	                LoggerRendererMap::addRenderer($hierarchy, $renderedClass, $renderingClass);
-                }
-	        }
-        }
-    }
+	/**
+	 * Parse non-root elements, such non-root categories and renderers.
+	 *
+	 * @param array $props array of properties
+	 * @param LoggerHierarchy &$hierarchy
+	 */
+	public function parseCatsAndRenderers($props, &$hierarchy)
+	{
+		while(list($key,$value) = each($props)) {
+			if( strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0 || 
+				strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
+				if(strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0) {
+					$loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX));
+				} elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
+					$loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX));
+				}
+				$logger =& $hierarchy->getLogger($loggerName, $this->loggerFactory);
+				// synchronized(logger) {
+				$this->parseCategory($props, $logger, $key, $loggerName, $value);
+				$this->parseAdditivityForLogger($props, $logger, $loggerName);
+				// }
+			} elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX) === 0) {
+				$renderedClass = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX));
+				$renderingClass = $value;
+				if (method_exists($hierarchy, 'addrenderer')) {
+					LoggerRendererMap::addRenderer($hierarchy, $renderedClass, $renderingClass);
+				}
+			}
+		}
+	}
 
-    /**
-     * Parse the additivity option for a non-root category.
-     *
-     * @param array $props array of properties
-     * @param Logger &$cat
-     * @param string $loggerName
-     */
-    public function parseAdditivityForLogger($props, &$cat, $loggerName)
-    {
-        $value = LoggerOptionConverter::findAndSubst(
-                    LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName,
+	/**
+	 * Parse the additivity option for a non-root category.
+	 *
+	 * @param array $props array of properties
+	 * @param Logger &$cat
+	 * @param string $loggerName
+	 */
+	public function parseAdditivityForLogger($props, &$cat, $loggerName)
+	{
+		$value = LoggerOptionConverter::findAndSubst(
+					LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName,
 					$props
-                 );
-        LoggerLog::debug(
-            "LoggerPropertyConfigurator::parseAdditivityForLogger() ".
-            "Handling " . LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName . "=[{$value}]"
-        );
-        // touch additivity only if necessary
-        if(!empty($value)) {
-            $additivity = LoggerOptionConverter::toBoolean($value, true);
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseAdditivityForLogger() ".
-                "Setting additivity for [{$loggerName}] to [{$additivity}]"
-            );
-            $cat->setAdditivity($additivity);
-        }
-    }
+				 );
+		LoggerLog::debug(
+			"LoggerPropertyConfigurator::parseAdditivityForLogger() ".
+			"Handling " . LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName . "=[{$value}]"
+		);
+		// touch additivity only if necessary
+		if(!empty($value)) {
+			$additivity = LoggerOptionConverter::toBoolean($value, true);
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseAdditivityForLogger() ".
+				"Setting additivity for [{$loggerName}] to [{$additivity}]"
+			);
+			$cat->setAdditivity($additivity);
+		}
+	}
 
-    /**
-     * This method must work for the root category as well.
-     *
-     * @param array $props array of properties
-     * @param Logger &$logger
-     * @param string $optionKey
-     * @param string $loggerName
-     * @param string $value
-     * @return Logger
-     */
-    public function &parseCategory($props, &$logger, $optionKey, $loggerName, $value)
-    {
-        LoggerLog::debug(
-            "LoggerPropertyConfigurator::parseCategory() ".
-            "Parsing for [{$loggerName}] with value=[{$value}]."
-        );
+	/**
+	 * This method must work for the root category as well.
+	 *
+	 * @param array $props array of properties
+	 * @param Logger &$logger
+	 * @param string $optionKey
+	 * @param string $loggerName
+	 * @param string $value
+	 * @return Logger
+	 */
+	public function &parseCategory($props, &$logger, $optionKey, $loggerName, $value)
+	{
+		LoggerLog::debug(
+			"LoggerPropertyConfigurator::parseCategory() ".
+			"Parsing for [{$loggerName}] with value=[{$value}]."
+		);
         
-        // We must skip over ',' but not white space
-        $st = explode(',', $value);
+		// We must skip over ',' but not white space
+		$st = explode(',', $value);
 
-        // If value is not in the form ", appender.." or "", then we should set
-        // the level of the loggeregory.
+		// If value is not in the form ", appender.." or "", then we should set
+		// the level of the loggeregory.
 
-        if(!(@$value{0} == ',' || empty($value))) {
-            // just to be on the safe side...
-            if(sizeof($st) == 0)
-	            return;
+		if(!(@$value{0} == ',' || empty($value))) {
+			// just to be on the safe side...
+			if(sizeof($st) == 0)
+				return;
                 
-            $levelStr = current($st);
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseCategory() ".
-                "Level token is [$levelStr]."
-            );
+			$levelStr = current($st);
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseCategory() ".
+				"Level token is [$levelStr]."
+			);
 
-            // If the level value is inherited, set category level value to
-            // null. We also check that the user has not specified inherited for the
-            // root category.
-            if('INHERITED' == strtoupper($levelStr) || 'NULL' == strtoupper($levelStr)) {
-        	    if ($loggerName == LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME) {
-                    LoggerLog::warn(
-                        "LoggerPropertyConfigurator::parseCategory() ".
-                        "The root logger cannot be set to null."
-                    );
-	            } else {
-	                $logger->setLevel(null);
-	            }
-            } else {
-	            $logger->setLevel(LoggerOptionConverter::toLevel($levelStr, LoggerLevel::getLevelDebug()));
-            }
-        }
+			// If the level value is inherited, set category level value to
+			// null. We also check that the user has not specified inherited for the
+			// root category.
+			if('INHERITED' == strtoupper($levelStr) || 'NULL' == strtoupper($levelStr)) {
+				if ($loggerName == LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME) {
+					LoggerLog::warn(
+						"LoggerPropertyConfigurator::parseCategory() ".
+						"The root logger cannot be set to null."
+					);
+				} else {
+					$logger->setLevel(null);
+				}
+			} else {
+				$logger->setLevel(LoggerOptionConverter::toLevel($levelStr, LoggerLevel::getLevelDebug()));
+			}
+		}
 
-        // Begin by removing all existing appenders.
-        $logger->removeAllAppenders();
-        while($appenderName = next($st)) {
-            $appenderName = trim($appenderName);
-            if(empty($appenderName))
-                continue;
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseCategory() ".
-                "Parsing appender named [{$appenderName}]."
-            );
-            $appender =& $this->parseAppender($props, $appenderName);
-            if($appender !== null) {
-	            $logger->addAppender($appender);
-            }
-        }
-    }
+		// Begin by removing all existing appenders.
+		$logger->removeAllAppenders();
+		while($appenderName = next($st)) {
+			$appenderName = trim($appenderName);
+			if(empty($appenderName))
+				continue;
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseCategory() ".
+				"Parsing appender named [{$appenderName}]."
+			);
+			$appender =& $this->parseAppender($props, $appenderName);
+			if($appender !== null) {
+				$logger->addAppender($appender);
+			}
+		}
+	}
 
-    /**
-     * @param array $props array of properties
-     * @param string $appenderName
-     * @return LoggerAppender
-     */
-    public function &parseAppender($props, $appenderName)
-    {
-        $appender =& LoggerAppender::singleton($appenderName);
-        if($appender !== null) {
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseAppender() ".
-                "Appender [{$appenderName}] was already parsed."
-            );
-            return $appender;
-        }
-        // Appender was not previously initialized.
-        $prefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_APPENDER_PREFIX . $appenderName;
-        $layoutPrefix = $prefix . ".layout";
-        $appenderClass = @$props[$prefix];
-        if (!empty($appenderClass)) {
-            $appender =& LoggerAppender::singleton($appenderName, $appenderClass);
-            if($appender === null) {
-                LoggerLog::warn(
-                    "LoggerPropertyConfigurator::parseAppender() ".
-                    "Could not instantiate appender named [$appenderName]."
-                );
-                return null;
-            }
-        } else {
-            LoggerLog::warn(
-                "LoggerPropertyConfigurator::parseAppender() ".
-                "Could not instantiate appender named [$appenderName] with null className."
-            );
-            return null;
-        }
+	/**
+	 * @param array $props array of properties
+	 * @param string $appenderName
+	 * @return LoggerAppender
+	 */
+	public function &parseAppender($props, $appenderName)
+	{
+		$appender =& LoggerAppender::singleton($appenderName);
+		if($appender !== null) {
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseAppender() ".
+				"Appender [{$appenderName}] was already parsed."
+			);
+			return $appender;
+		}
+		// Appender was not previously initialized.
+		$prefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_APPENDER_PREFIX . $appenderName;
+		$layoutPrefix = $prefix . ".layout";
+		$appenderClass = @$props[$prefix];
+		if (!empty($appenderClass)) {
+			$appender =& LoggerAppender::singleton($appenderName, $appenderClass);
+			if($appender === null) {
+				LoggerLog::warn(
+					"LoggerPropertyConfigurator::parseAppender() ".
+					"Could not instantiate appender named [$appenderName]."
+				);
+				return null;
+			}
+		} else {
+			LoggerLog::warn(
+				"LoggerPropertyConfigurator::parseAppender() ".
+				"Could not instantiate appender named [$appenderName] with null className."
+			);
+			return null;
+		}
         
-        $appender->setName($appenderName);
-        if( $appender->requiresLayout() ) {
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseAppender() ".
-                "Parsing layout section for [$appenderName]."
-            );
-            $layoutClass = @$props[$layoutPrefix];
-            $layoutClass = LoggerOptionConverter::substVars($layoutClass, $props);
-            if (empty($layoutClass)) {
-                LoggerLog::warn(
-                    "LoggerPropertyConfigurator::parseAppender() ".
-                    "layout class is empty in '$layoutPrefix'. Using Simple layout"
-                );
-                $layout = LoggerLayout::factory('LoggerLayoutSimple');
-            } else {
-        	    $layout = LoggerLayout::factory($layoutClass);
+		$appender->setName($appenderName);
+		if( $appender->requiresLayout() ) {
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseAppender() ".
+				"Parsing layout section for [$appenderName]."
+			);
+			$layoutClass = @$props[$layoutPrefix];
+			$layoutClass = LoggerOptionConverter::substVars($layoutClass, $props);
+			if (empty($layoutClass)) {
+				LoggerLog::warn(
+					"LoggerPropertyConfigurator::parseAppender() ".
+					"layout class is empty in '$layoutPrefix'. Using Simple layout"
+				);
+				$layout = LoggerLayout::factory('LoggerLayoutSimple');
+			} else {
+				$layout = LoggerLayout::factory($layoutClass);
                 
-	            if($layout === null) {
-	                LoggerLog::warn(
-                        "LoggerPropertyConfigurator::parseAppender() ".
-                        "cannot create layout '$layoutClass'. Using Simple layout"
-                    );
-                    $layout = LoggerLayout::factory('LoggerLayoutSimple');
-                }
-            }
+				if($layout === null) {
+					LoggerLog::warn(
+						"LoggerPropertyConfigurator::parseAppender() ".
+						"cannot create layout '$layoutClass'. Using Simple layout"
+					);
+					$layout = LoggerLayout::factory('LoggerLayoutSimple');
+				}
+			}
             
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseAppender() ".
-                "Parsing layout options for [$appenderName]."
-            );
-            LoggerPropertySetter::setPropertiesByObject($layout, $props, $layoutPrefix . ".");                
-            LoggerLog::debug(
-                "LoggerPropertyConfigurator::parseAppender() ".
-                "End Parsing layout options for [$appenderName]."
-            );
-            $appender->setLayout($layout);
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseAppender() ".
+				"Parsing layout options for [$appenderName]."
+			);
+			LoggerPropertySetter::setPropertiesByObject($layout, $props, $layoutPrefix . ".");                
+			LoggerLog::debug(
+				"LoggerPropertyConfigurator::parseAppender() ".
+				"End Parsing layout options for [$appenderName]."
+			);
+			$appender->setLayout($layout);
             
-        }
-        LoggerPropertySetter::setPropertiesByObject($appender, $props, $prefix . ".");
-        LoggerLog::debug(
-            "LoggerPropertyConfigurator::parseAppender() ".        
-            "Parsed [{$appenderName}] options."
-        );
-        return $appender;        
-    }
+		}
+		LoggerPropertySetter::setPropertiesByObject($appender, $props, $prefix . ".");
+		LoggerLog::debug(
+			"LoggerPropertyConfigurator::parseAppender() ".        
+			"Parsed [{$appenderName}] options."
+		);
+		return $appender;        
+	}
 
 }
 ?>
\ No newline at end of file

libraries/log4php.debug/LoggerNDC.php

Indentation +123 added lines, -123 removed lines

@@ -97,144 +97,144 @@
  */
 class LoggerNDC {
 
-    /**
-     * Clear any nested diagnostic information if any. This method is
-     * useful in cases where the same thread can be potentially used
-     * over and over in different unrelated contexts.
-     *
-     * <p>This method is equivalent to calling the {@link setMaxDepth()}
-     * method with a zero <var>maxDepth</var> argument.
-     *
-     * @static  
-     */
-    public function clear()
-    {
-        LoggerLog::debug("LoggerNDC::clear()");
+	/**
+	 * Clear any nested diagnostic information if any. This method is
+	 * useful in cases where the same thread can be potentially used
+	 * over and over in different unrelated contexts.
+	 *
+	 * <p>This method is equivalent to calling the {@link setMaxDepth()}
+	 * method with a zero <var>maxDepth</var> argument.
+	 *
+	 * @static  
+	 */
+	public function clear()
+	{
+		LoggerLog::debug("LoggerNDC::clear()");
         
-        $GLOBALS['log4php.LoggerNDC.ht'] = array();
-    }
+		$GLOBALS['log4php.LoggerNDC.ht'] = array();
+	}
 
-    /**
-     * Never use this method directly, use the {@link LoggerLoggingEvent::getNDC()} method instead.
-     * @static
-     * @return array
-     */
-    public function get()
-    {
-        LoggerLog::debug("LoggerNDC::get()");
+	/**
+	 * Never use this method directly, use the {@link LoggerLoggingEvent::getNDC()} method instead.
+	 * @static
+	 * @return array
+	 */
+	public function get()
+	{
+		LoggerLog::debug("LoggerNDC::get()");
     
-        return $GLOBALS['log4php.LoggerNDC.ht'];
-    }
+		return $GLOBALS['log4php.LoggerNDC.ht'];
+	}
   
-    /**
-     * Get the current nesting depth of this diagnostic context.
-     *
-     * @see setMaxDepth()
-     * @return integer
-     * @static
-     */
-    public function getDepth()
-    {
-        LoggerLog::debug("LoggerNDC::getDepth()");
+	/**
+	 * Get the current nesting depth of this diagnostic context.
+	 *
+	 * @see setMaxDepth()
+	 * @return integer
+	 * @static
+	 */
+	public function getDepth()
+	{
+		LoggerLog::debug("LoggerNDC::getDepth()");
     
-        return sizeof($GLOBALS['log4php.LoggerNDC.ht']);      
-    }
+		return sizeof($GLOBALS['log4php.LoggerNDC.ht']);      
+	}
 
-    /**
-     * Clients should call this method before leaving a diagnostic
-     * context.
-     *
-     * <p>The returned value is the value that was pushed last. If no
-     * context is available, then the empty string "" is returned.</p>
-     *
-     * @return string The innermost diagnostic context.
-     * @static
-     */
-    public function pop()
-    {
-        LoggerLog::debug("LoggerNDC::pop()");
+	/**
+	 * Clients should call this method before leaving a diagnostic
+	 * context.
+	 *
+	 * <p>The returned value is the value that was pushed last. If no
+	 * context is available, then the empty string "" is returned.</p>
+	 *
+	 * @return string The innermost diagnostic context.
+	 * @static
+	 */
+	public function pop()
+	{
+		LoggerLog::debug("LoggerNDC::pop()");
     
-        if (sizeof($GLOBALS['log4php.LoggerNDC.ht']) > 0) {
-            return array_pop($GLOBALS['log4php.LoggerNDC.ht']);
-        } else {
-            return '';
-        }
-    }
+		if (sizeof($GLOBALS['log4php.LoggerNDC.ht']) > 0) {
+			return array_pop($GLOBALS['log4php.LoggerNDC.ht']);
+		} else {
+			return '';
+		}
+	}
 
-    /**
-     * Looks at the last diagnostic context at the top of this NDC
-     * without removing it.
-     *
-     * <p>The returned value is the value that was pushed last. If no
-     * context is available, then the empty string "" is returned.</p>
-     * @return string The innermost diagnostic context.
-     * @static
-     */
-    public function peek()
-    {
-        LoggerLog::debug("LoggerNDC::peek()");
+	/**
+	 * Looks at the last diagnostic context at the top of this NDC
+	 * without removing it.
+	 *
+	 * <p>The returned value is the value that was pushed last. If no
+	 * context is available, then the empty string "" is returned.</p>
+	 * @return string The innermost diagnostic context.
+	 * @static
+	 */
+	public function peek()
+	{
+		LoggerLog::debug("LoggerNDC::peek()");
     
-        if (sizeof($GLOBALS['log4php.LoggerNDC.ht']) > 0) {
-            return end($GLOBALS['log4php.LoggerNDC.ht']);
-        } else {
-            return '';
-        }
-    }
+		if (sizeof($GLOBALS['log4php.LoggerNDC.ht']) > 0) {
+			return end($GLOBALS['log4php.LoggerNDC.ht']);
+		} else {
+			return '';
+		}
+	}
   
-    /**
-     * Push new diagnostic context information for the current thread.
-     *
-     * <p>The contents of the <var>message</var> parameter is
-     * determined solely by the client.
-     *  
-     * @param string $message The new diagnostic context information.
-     * @static  
-     */
-    public function push($message)
-    {
-        LoggerLog::debug("LoggerNDC::push()");
+	/**
+	 * Push new diagnostic context information for the current thread.
+	 *
+	 * <p>The contents of the <var>message</var> parameter is
+	 * determined solely by the client.
+	 *  
+	 * @param string $message The new diagnostic context information.
+	 * @static  
+	 */
+	public function push($message)
+	{
+		LoggerLog::debug("LoggerNDC::push()");
     
-        array_push($GLOBALS['log4php.LoggerNDC.ht'], (string)$message);
-    }
+		array_push($GLOBALS['log4php.LoggerNDC.ht'], (string)$message);
+	}
 
-    /**
-     * Remove the diagnostic context for this thread.
-     * @static
-     */
-    public function remove()
-    {
-        LoggerLog::debug("LoggerNDC::remove()");
+	/**
+	 * Remove the diagnostic context for this thread.
+	 * @static
+	 */
+	public function remove()
+	{
+		LoggerLog::debug("LoggerNDC::remove()");
     
-        LoggerNDC::clear();
-    }
+		LoggerNDC::clear();
+	}
 
-    /**
-     * Set maximum depth of this diagnostic context. If the current
-     * depth is smaller or equal to <var>maxDepth</var>, then no
-     * action is taken.
-     *
-     * <p>This method is a convenient alternative to multiple 
-     * {@link pop()} calls. Moreover, it is often the case that at 
-     * the end of complex call sequences, the depth of the NDC is
-     * unpredictable. The {@link setMaxDepth()} method circumvents
-     * this problem.
-     *
-     * @param integer $maxDepth
-     * @see getDepth()
-     * @static
-     */
-    public function setMaxDepth($maxDepth)
-    {
-        LoggerLog::debug("LoggerNDC::setMaxDepth() maxDepth='$maxDepth'");
+	/**
+	 * Set maximum depth of this diagnostic context. If the current
+	 * depth is smaller or equal to <var>maxDepth</var>, then no
+	 * action is taken.
+	 *
+	 * <p>This method is a convenient alternative to multiple 
+	 * {@link pop()} calls. Moreover, it is often the case that at 
+	 * the end of complex call sequences, the depth of the NDC is
+	 * unpredictable. The {@link setMaxDepth()} method circumvents
+	 * this problem.
+	 *
+	 * @param integer $maxDepth
+	 * @see getDepth()
+	 * @static
+	 */
+	public function setMaxDepth($maxDepth)
+	{
+		LoggerLog::debug("LoggerNDC::setMaxDepth() maxDepth='$maxDepth'");
     
-        $maxDepth = (int)$maxDepth;
-        if ($maxDepth <= LOGGER_NDC_HT_SIZE) {
-            if (LoggerNDC::getDepth() > $maxDepth) {
-                $GLOBALS['log4php.LoggerNDC.ht'] = array_slice($GLOBALS['log4php.LoggerNDC.ht'], $maxDepth);
-            }
-            $GLOBALS['log4php.LoggerNDC.maxDepth'] = $maxDepth;            
-        }
-    }
+		$maxDepth = (int)$maxDepth;
+		if ($maxDepth <= LOGGER_NDC_HT_SIZE) {
+			if (LoggerNDC::getDepth() > $maxDepth) {
+				$GLOBALS['log4php.LoggerNDC.ht'] = array_slice($GLOBALS['log4php.LoggerNDC.ht'], $maxDepth);
+			}
+			$GLOBALS['log4php.LoggerNDC.maxDepth'] = $maxDepth;            
+		}
+	}
   
 }
 ?>
\ No newline at end of file

libraries/log4php.debug/LoggerAppender.php

Indentation +167 added lines, -167 removed lines

@@ -31,188 +31,188 @@
  */
 class LoggerAppender {
 
-    /**
-     * Factory
-     *
-     * @param string $name appender name
-     * @param string $class create an instance of this appender class
-     * @return LoggerAppender
-     */
-    public function factory($name, $class)
-    {
-        $class = basename($class);
-        if (!empty($class)) {
-            if (!class_exists($class)) 
-                @include_once(LOG4PHP_DIR . "/appenders/{$class}.php");
-            if (class_exists($class))
-                return new $class($name);
-        }
-        return null;
-    }
+	/**
+	 * Factory
+	 *
+	 * @param string $name appender name
+	 * @param string $class create an instance of this appender class
+	 * @return LoggerAppender
+	 */
+	public function factory($name, $class)
+	{
+		$class = basename($class);
+		if (!empty($class)) {
+			if (!class_exists($class)) 
+				@include_once(LOG4PHP_DIR . "/appenders/{$class}.php");
+			if (class_exists($class))
+				return new $class($name);
+		}
+		return null;
+	}
     
-    /**
-     * Singleton
-     *
-     * @param string $name appender name
-     * @param string $class create or get a reference instance of this class
-     * @return LoggerAppender 
-     */
-    public function &singleton($name, $class = '')
-    {
-        static $instances;
+	/**
+	 * Singleton
+	 *
+	 * @param string $name appender name
+	 * @param string $class create or get a reference instance of this class
+	 * @return LoggerAppender 
+	 */
+	public function &singleton($name, $class = '')
+	{
+		static $instances;
         
-        if (!empty($name)) {
-            if (!isset($instances[$name])) {
-                if (!empty($class)) {
-                    $appender = LoggerAppender::factory($name, $class);
-                    if ($appender !== null) { 
-                        $instances[$name] = $appender;
-                        return $instances[$name];
-                    }
-                }
-                return null;
-            }
-            return $instances[$name];                
-        }        
-        return null;        
-    }
+		if (!empty($name)) {
+			if (!isset($instances[$name])) {
+				if (!empty($class)) {
+					$appender = LoggerAppender::factory($name, $class);
+					if ($appender !== null) { 
+						$instances[$name] = $appender;
+						return $instances[$name];
+					}
+				}
+				return null;
+			}
+			return $instances[$name];                
+		}        
+		return null;        
+	}
     
-    /* --------------------------------------------------------------------------*/
-    /* --------------------------------------------------------------------------*/
-    /* --------------------------------------------------------------------------*/
+	/* --------------------------------------------------------------------------*/
+	/* --------------------------------------------------------------------------*/
+	/* --------------------------------------------------------------------------*/
     
-    /**
-     * Add a filter to the end of the filter list.
-     *
-     * @param LoggerFilter $newFilter add a new LoggerFilter
-     * @abstract
-     */
-    public function addFilter($newFilter)
-    {
-        // override 
-    }
+	/**
+	 * Add a filter to the end of the filter list.
+	 *
+	 * @param LoggerFilter $newFilter add a new LoggerFilter
+	 * @abstract
+	 */
+	public function addFilter($newFilter)
+	{
+		// override 
+	}
     
-    /**
-     * Clear the list of filters by removing all the filters in it.
-     * @abstract
-     */
-    public function clearFilters()
-    {
-        // override    
-    }
+	/**
+	 * Clear the list of filters by removing all the filters in it.
+	 * @abstract
+	 */
+	public function clearFilters()
+	{
+		// override    
+	}
 
-    /**
-     * Return the first filter in the filter chain for this Appender. 
-     * The return value may be <i>null</i> if no is filter is set.
-     * @return Filter
-     */
-    public function &getFilter()
-    {
-        // override    
-    } 
+	/**
+	 * Return the first filter in the filter chain for this Appender. 
+	 * The return value may be <i>null</i> if no is filter is set.
+	 * @return Filter
+	 */
+	public function &getFilter()
+	{
+		// override    
+	} 
     
-    /**
-     * Release any resources allocated.
-     * Subclasses of {@link LoggerAppender} should implement 
-     * this method to perform proper closing procedures.
-     * @abstract
-     */
-    public function close()
-    {
-        //override me
-    }
+	/**
+	 * Release any resources allocated.
+	 * Subclasses of {@link LoggerAppender} should implement 
+	 * this method to perform proper closing procedures.
+	 * @abstract
+	 */
+	public function close()
+	{
+		//override me
+	}
 
-    /**
-     * This method performs threshold checks and invokes filters before
-     * delegating actual logging to the subclasses specific <i>append()</i> method.
-     * @param LoggerLoggingEvent $event
-     * @abstract
-     */
-    public function doAppend($event)
-    {
-        //override me    
-    }
+	/**
+	 * This method performs threshold checks and invokes filters before
+	 * delegating actual logging to the subclasses specific <i>append()</i> method.
+	 * @param LoggerLoggingEvent $event
+	 * @abstract
+	 */
+	public function doAppend($event)
+	{
+		//override me    
+	}
 
-    /**
-     * Get the name of this appender.
-     * @return string
-     */
-    public function getName()
-    {
-        //override me    
-    }
+	/**
+	 * Get the name of this appender.
+	 * @return string
+	 */
+	public function getName()
+	{
+		//override me    
+	}
 
-    /**
-     * Do not use this method.
-     *
-     * @param object $errorHandler
-     */
-    public function setErrorHandler($errorHandler)
-    {
-        // override me
-    }
+	/**
+	 * Do not use this method.
+	 *
+	 * @param object $errorHandler
+	 */
+	public function setErrorHandler($errorHandler)
+	{
+		// override me
+	}
     
-    /**
-     * Do not use this method.
-     * @return object Returns the ErrorHandler for this appender.
-     */
-    public function &getErrorHandler()
-    {
-        return $this->errorHandler;
-    } 
+	/**
+	 * Do not use this method.
+	 * @return object Returns the ErrorHandler for this appender.
+	 */
+	public function &getErrorHandler()
+	{
+		return $this->errorHandler;
+	} 
 
-    /**
-     * Set the Layout for this appender.
-     *
-     * @param LoggerLayout $layout
-     */
-    public function setLayout($layout)
-    {
-        // override me
-    }
+	/**
+	 * Set the Layout for this appender.
+	 *
+	 * @param LoggerLayout $layout
+	 */
+	public function setLayout($layout)
+	{
+		// override me
+	}
     
-    /**
-     * Returns this appender layout.
-     * @return LoggerLayout
-     */
-    public function &getLayout()
-    {
-        // override me
-    }
+	/**
+	 * Returns this appender layout.
+	 * @return LoggerLayout
+	 */
+	public function &getLayout()
+	{
+		// override me
+	}
 
-    /**
-     * Set the name of this appender.
-     *
-     * The name is used by other components to identify this appender.
-     *
-     * @param string $name
-     */
-    public function setName($name) 
-    {
-        // override me    
-    }
+	/**
+	 * Set the name of this appender.
+	 *
+	 * The name is used by other components to identify this appender.
+	 *
+	 * @param string $name
+	 */
+	public function setName($name) 
+	{
+		// override me    
+	}
 
-    /**
-     * Configurators call this method to determine if the appender
-     * requires a layout. 
-     *
-     * <p>If this method returns <i>true</i>, meaning that layout is required, 
-     * then the configurator will configure a layout using the configuration 
-     * information at its disposal.  If this method returns <i>false</i>, 
-     * meaning that a layout is not required, then layout configuration will be
-     * skipped even if there is available layout configuration
-     * information at the disposal of the configurator.</p>
-     *
-     * <p>In the rather exceptional case, where the appender
-     * implementation admits a layout but can also work without it, then
-     * the appender should return <i>true</i>.</p>
-     *
-     * @return boolean
-     */
-    public function requiresLayout()
-    {
-        // override me
-    }
+	/**
+	 * Configurators call this method to determine if the appender
+	 * requires a layout. 
+	 *
+	 * <p>If this method returns <i>true</i>, meaning that layout is required, 
+	 * then the configurator will configure a layout using the configuration 
+	 * information at its disposal.  If this method returns <i>false</i>, 
+	 * meaning that a layout is not required, then layout configuration will be
+	 * skipped even if there is available layout configuration
+	 * information at the disposal of the configurator.</p>
+	 *
+	 * <p>In the rather exceptional case, where the appender
+	 * implementation admits a layout but can also work without it, then
+	 * the appender should return <i>true</i>.</p>
+	 *
+	 * @return boolean
+	 */
+	public function requiresLayout()
+	{
+		// override me
+	}
 
 }
 ?>
\ No newline at end of file

libraries/log4php.debug/LoggerHierarchy.php

Indentation +289 added lines, -289 removed lines

@@ -52,196 +52,196 @@ 
  */
 class LoggerHierarchy {
 
-    /**
-     * @var object currently unused
-     */
-    var $defaultFactory;
+	/**
+	 * @var object currently unused
+	 */
+	var $defaultFactory;
     
-    /**
-     * @var boolean activate internal logging
-     * @see LoggerLog
-     */
-    var $debug = false;
+	/**
+	 * @var boolean activate internal logging
+	 * @see LoggerLog
+	 */
+	var $debug = false;
 
-    /**
-     * @var array hierarchy tree. saves here all loggers
-     */
-    var $ht = array();
+	/**
+	 * @var array hierarchy tree. saves here all loggers
+	 */
+	var $ht = array();
     
-    /**
-     * @var LoggerRoot
-     */
-    var $root = null;
+	/**
+	 * @var LoggerRoot
+	 */
+	var $root = null;
     
-    /**
-     * @var LoggerRendererMap
-     */
-    var $rendererMap;
+	/**
+	 * @var LoggerRendererMap
+	 */
+	var $rendererMap;
 
-    /**
-     * @var LoggerLevel main level threshold
-     */
-    var $threshold;
+	/**
+	 * @var LoggerLevel main level threshold
+	 */
+	var $threshold;
     
-    /**
-     * @var boolean currently unused
-     */
-    var $emittedNoAppenderWarning       = false;
+	/**
+	 * @var boolean currently unused
+	 */
+	var $emittedNoAppenderWarning       = false;
 
-    /**
-     * @var boolean currently unused
-     */
-    var $emittedNoResourceBundleWarning = false;
+	/**
+	 * @var boolean currently unused
+	 */
+	var $emittedNoResourceBundleWarning = false;
     
     
 /* --------------------------------------------------------------------------*/
 /* --------------------------------------------------------------------------*/
 /* --------------------------------------------------------------------------*/
 
-    public function &singleton()
-    {
-        static $instance;
+	public function &singleton()
+	{
+		static $instance;
         
-        if (!isset($instance))
-            $instance = new LoggerHierarchy(new LoggerRoot());
-        return $instance;
-    }
+		if (!isset($instance))
+			$instance = new LoggerHierarchy(new LoggerRoot());
+		return $instance;
+	}
     
-    /**
-     * Create a new logger hierarchy.
-     * @param object $root the root logger
-     */
-    public function LoggerHierarchy($root)
-    {
-        $this->root    =& $root;
-        // Enable all level levels by default.
-        $this->setThreshold(LoggerLevel::getLevelAll());
-        $this->root->setHierarchy($this);
-        $this->rendererMap = new LoggerRendererMap();
-        $this->defaultFactory = new LoggerDefaultCategoryFactory();        
-    }
+	/**
+	 * Create a new logger hierarchy.
+	 * @param object $root the root logger
+	 */
+	public function LoggerHierarchy($root)
+	{
+		$this->root    =& $root;
+		// Enable all level levels by default.
+		$this->setThreshold(LoggerLevel::getLevelAll());
+		$this->root->setHierarchy($this);
+		$this->rendererMap = new LoggerRendererMap();
+		$this->defaultFactory = new LoggerDefaultCategoryFactory();        
+	}
      
-    /**
-     * Add a HierarchyEventListener event to the repository. 
-     * Not Yet Impl.
-     */
-    public function addHierarchyEventListener($listener)
-    {
-        return;
-    }
+	/**
+	 * Add a HierarchyEventListener event to the repository. 
+	 * Not Yet Impl.
+	 */
+	public function addHierarchyEventListener($listener)
+	{
+		return;
+	}
      
-    /**
-     * Add an object renderer for a specific class.
-     * Not Yet Impl.
-     */
-    public function addRenderer($classToRender, $or)
-    {
-        $this->rendererMap->put($classToRender, $or);
-    } 
+	/**
+	 * Add an object renderer for a specific class.
+	 * Not Yet Impl.
+	 */
+	public function addRenderer($classToRender, $or)
+	{
+		$this->rendererMap->put($classToRender, $or);
+	} 
     
-    /**
-     * This call will clear all logger definitions from the internal hashtable.
-     */
-    public function clear()
-    {
-        $this->ht = array();
-    }
+	/**
+	 * This call will clear all logger definitions from the internal hashtable.
+	 */
+	public function clear()
+	{
+		$this->ht = array();
+	}
       
-    public function emitNoAppenderWarning($cat)
-    {
-        return;
-    }
+	public function emitNoAppenderWarning($cat)
+	{
+		return;
+	}
     
-    /**
-     * Check if the named logger exists in the hierarchy.
-     * @param string $name
-     * @return boolean
-     */
-    public function exists($name)
-    {
-        return in_array($name, array_keys($this->ht));
-    }
+	/**
+	 * Check if the named logger exists in the hierarchy.
+	 * @param string $name
+	 * @return boolean
+	 */
+	public function exists($name)
+	{
+		return in_array($name, array_keys($this->ht));
+	}
 
-    public function fireAddAppenderEvent($logger, $appender)
-    {
-        return;
-    }
+	public function fireAddAppenderEvent($logger, $appender)
+	{
+		return;
+	}
     
-    /**
-     * @deprecated Please use {@link getCurrentLoggers()} instead.
-     */
-    public function &getCurrentCategories()
-    {
-        return $this->getCurrentLoggers();
-    }
+	/**
+	 * @deprecated Please use {@link getCurrentLoggers()} instead.
+	 */
+	public function &getCurrentCategories()
+	{
+		return $this->getCurrentLoggers();
+	}
     
-    /**
-     * Returns all the currently defined categories in this hierarchy as an array.
-     * @return array
-     */  
-    public function &getCurrentLoggers()
-    {
-        $loggers = array();
-        $loggerNames = array_keys($this->ht);
-        $enumLoggers = sizeof($loggerNames);
-        for ($i = 0; $i < $enumLoggers; $i++) {
-            $loggerName = $loggerNames[$i];
-            $loggers[] =& $this->ht[$loggerName];
-        }
-        return $loggers; 
-    }
+	/**
+	 * Returns all the currently defined categories in this hierarchy as an array.
+	 * @return array
+	 */  
+	public function &getCurrentLoggers()
+	{
+		$loggers = array();
+		$loggerNames = array_keys($this->ht);
+		$enumLoggers = sizeof($loggerNames);
+		for ($i = 0; $i < $enumLoggers; $i++) {
+			$loggerName = $loggerNames[$i];
+			$loggers[] =& $this->ht[$loggerName];
+		}
+		return $loggers; 
+	}
     
-    /**
-     * Return a new logger instance named as the first parameter using the default factory.
-     * 
-     * @param string $name logger name
-     * @param LoggerFactory $factory a {@link LoggerFactory} instance or null     
-     * @return Logger
-     */
-    public function &getLogger($name, $factory = null)
-    {
-        if ($factory === null) {
-            return $this->getLoggerByFactory($name, $this->defaultFactory);
-        } else {
-            return $this->getLoggerByFactory($name, $factory);
-        }
-    } 
+	/**
+	 * Return a new logger instance named as the first parameter using the default factory.
+	 * 
+	 * @param string $name logger name
+	 * @param LoggerFactory $factory a {@link LoggerFactory} instance or null     
+	 * @return Logger
+	 */
+	public function &getLogger($name, $factory = null)
+	{
+		if ($factory === null) {
+			return $this->getLoggerByFactory($name, $this->defaultFactory);
+		} else {
+			return $this->getLoggerByFactory($name, $factory);
+		}
+	} 
     
-    /**
-     * Return a new logger instance named as the first parameter using the default factory.
-     * 
-     * @param string $name logger name
-     * @return Logger
-     * @todo merge with {@link getLogger()}
-     */
-    public function &getLoggerByFactory($name, $factory)
-    {
-        if (!isset($this->ht[$name])) {
-            LoggerLog::debug("LoggerHierarchy::getLoggerByFactory():name=[$name]:factory=[".get_class($factory)."] creating a new logger...");
-            $this->ht[$name] = $factory->makeNewLoggerInstance($name);
-            $this->ht[$name]->setHierarchy($this);
-            $nodes = explode('.', $name);
-            $firstNode = array_shift($nodes);
-            if ( $firstNode != $name && isset($this->ht[$firstNode])) {
-                LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$firstNode]");            
-                $this->ht[$name]->parent =& $this->ht[$firstNode];
-            } else {
-                LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [root]");            
-                $this->ht[$name]->parent =& $this->root;
-            } 
-            if (sizeof($nodes) > 0) {
-                // find parent node
-                foreach ($nodes as $node) {
-                    $parentNode = "$firstNode.$node";
-                    if (isset($this->ht[$parentNode]) && $parentNode != $name) {
-                        LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$parentNode]");                    
-                        $this->ht[$name]->parent =& $this->ht[$parentNode];
-                    }
-                    $firstNode .= ".$node";
-                }
-            }
-            // update children
-            /*
+	/**
+	 * Return a new logger instance named as the first parameter using the default factory.
+	 * 
+	 * @param string $name logger name
+	 * @return Logger
+	 * @todo merge with {@link getLogger()}
+	 */
+	public function &getLoggerByFactory($name, $factory)
+	{
+		if (!isset($this->ht[$name])) {
+			LoggerLog::debug("LoggerHierarchy::getLoggerByFactory():name=[$name]:factory=[".get_class($factory)."] creating a new logger...");
+			$this->ht[$name] = $factory->makeNewLoggerInstance($name);
+			$this->ht[$name]->setHierarchy($this);
+			$nodes = explode('.', $name);
+			$firstNode = array_shift($nodes);
+			if ( $firstNode != $name && isset($this->ht[$firstNode])) {
+				LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$firstNode]");            
+				$this->ht[$name]->parent =& $this->ht[$firstNode];
+			} else {
+				LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [root]");            
+				$this->ht[$name]->parent =& $this->root;
+			} 
+			if (sizeof($nodes) > 0) {
+				// find parent node
+				foreach ($nodes as $node) {
+					$parentNode = "$firstNode.$node";
+					if (isset($this->ht[$parentNode]) && $parentNode != $name) {
+						LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$parentNode]");                    
+						$this->ht[$name]->parent =& $this->ht[$parentNode];
+					}
+					$firstNode .= ".$node";
+				}
+			}
+			// update children
+			/*
             $children = array();
             foreach (array_keys($this->ht) as $nodeName) {
                 if ($nodeName != $name && substr($nodeName, 0, strlen($name)) == $name) {
@@ -249,140 +249,140 @@ 
                 }
             }
             */
-        }            
-        return $this->ht[$name];
-    }
+		}            
+		return $this->ht[$name];
+	}
     
-    /**
-     * @return LoggerRendererMap Get the renderer map for this hierarchy.
-     */
-    public function &getRendererMap()
-    {
-        return $this->rendererMap;
-    }
+	/**
+	 * @return LoggerRendererMap Get the renderer map for this hierarchy.
+	 */
+	public function &getRendererMap()
+	{
+		return $this->rendererMap;
+	}
     
-    /**
-     * @return LoggerRoot Get the root of this hierarchy.
-     */ 
-    public function &getRootLogger()
-    {
-        if (!isset($this->root) || $this->root == null)
-            $this->root = new LoggerRoot();
-        return $this->root;
-    }
+	/**
+	 * @return LoggerRoot Get the root of this hierarchy.
+	 */ 
+	public function &getRootLogger()
+	{
+		if (!isset($this->root) || $this->root == null)
+			$this->root = new LoggerRoot();
+		return $this->root;
+	}
      
-    /**
-     * @return LoggerLevel Returns the threshold Level.
-     */
-    public function getThreshold()
-    {
-        return $this->threshold;
-    } 
+	/**
+	 * @return LoggerLevel Returns the threshold Level.
+	 */
+	public function getThreshold()
+	{
+		return $this->threshold;
+	} 
 
-    /**
-     * This method will return true if this repository is disabled 
-     * for level object passed as parameter and false otherwise.
-     * @return boolean
-     */
-    public function isDisabled($level)
-    {
-        return ($this->threshold->level > $level->level);
-    }
+	/**
+	 * This method will return true if this repository is disabled 
+	 * for level object passed as parameter and false otherwise.
+	 * @return boolean
+	 */
+	public function isDisabled($level)
+	{
+		return ($this->threshold->level > $level->level);
+	}
     
-    /**
-     * @deprecated Deprecated with no replacement.
-     */
-    public function overrideAsNeeded($override)
-    {
-        return;
-    } 
+	/**
+	 * @deprecated Deprecated with no replacement.
+	 */
+	public function overrideAsNeeded($override)
+	{
+		return;
+	} 
     
-    /**
-     * Reset all values contained in this hierarchy instance to their
-     * default. 
-     *
-     * This removes all appenders from all categories, sets
-     * the level of all non-root categories to <i>null</i>,
-     * sets their additivity flag to <i>true</i> and sets the level
-     * of the root logger to {@link LOGGER_LEVEL_DEBUG}.  Moreover,
-     * message disabling is set its default "off" value.
-     * 
-     * <p>Existing categories are not removed. They are just reset.
-     *
-     * <p>This method should be used sparingly and with care as it will
-     * block all logging until it is completed.</p>
-     */
-    public function resetConfiguration()
-    {
-        $root =& $this->getRootLogger();
+	/**
+	 * Reset all values contained in this hierarchy instance to their
+	 * default. 
+	 *
+	 * This removes all appenders from all categories, sets
+	 * the level of all non-root categories to <i>null</i>,
+	 * sets their additivity flag to <i>true</i> and sets the level
+	 * of the root logger to {@link LOGGER_LEVEL_DEBUG}.  Moreover,
+	 * message disabling is set its default "off" value.
+	 * 
+	 * <p>Existing categories are not removed. They are just reset.
+	 *
+	 * <p>This method should be used sparingly and with care as it will
+	 * block all logging until it is completed.</p>
+	 */
+	public function resetConfiguration()
+	{
+		$root =& $this->getRootLogger();
         
-        $root->setLevel(LoggerLevel::getLevelDebug());
-        $this->setThreshold(LoggerLevel::getLevelAll());
-        $this->shutDown();
-        $loggers =& $this->getCurrentLoggers();
-        $enumLoggers = sizeof($loggers);
-        for ($i = 0; $i < $enumLoggers; $i++) {
-            $loggers[$i]->setLevel(null);
-        	$loggers[$i]->setAdditivity(true);
-        	$loggers[$i]->setResourceBundle(null);
-        }
-        $this->rendererMap->clear();
-    }
+		$root->setLevel(LoggerLevel::getLevelDebug());
+		$this->setThreshold(LoggerLevel::getLevelAll());
+		$this->shutDown();
+		$loggers =& $this->getCurrentLoggers();
+		$enumLoggers = sizeof($loggers);
+		for ($i = 0; $i < $enumLoggers; $i++) {
+			$loggers[$i]->setLevel(null);
+			$loggers[$i]->setAdditivity(true);
+			$loggers[$i]->setResourceBundle(null);
+		}
+		$this->rendererMap->clear();
+	}
       
-    /**
-     * @deprecated Deprecated with no replacement.
-     */
-    public function setDisableOverride($override)
-    {
-        return;
-    }
+	/**
+	 * @deprecated Deprecated with no replacement.
+	 */
+	public function setDisableOverride($override)
+	{
+		return;
+	}
     
-    /**
-     * Used by subclasses to add a renderer to the hierarchy passed as parameter.
-     * @param string $renderedClass a LoggerRenderer class name
-     * @param LoggerRenderer $renderer
-     *
-     */
-    public function setRenderer($renderedClass, $renderer)
-    {
-        $this->rendererMap->put($renderedClass, $renderer);
-    }
+	/**
+	 * Used by subclasses to add a renderer to the hierarchy passed as parameter.
+	 * @param string $renderedClass a LoggerRenderer class name
+	 * @param LoggerRenderer $renderer
+	 *
+	 */
+	public function setRenderer($renderedClass, $renderer)
+	{
+		$this->rendererMap->put($renderedClass, $renderer);
+	}
     
-    /**
-     * set a new threshold level
-     *
-     * @param LoggerLevel $l
-     */
-    public function setThreshold($l)
-    {
-        if ($l !== null)
-            $this->threshold = $l;
-    }
+	/**
+	 * set a new threshold level
+	 *
+	 * @param LoggerLevel $l
+	 */
+	public function setThreshold($l)
+	{
+		if ($l !== null)
+			$this->threshold = $l;
+	}
     
-    /**
-     * Shutting down a hierarchy will <i>safely</i> close and remove
-     * all appenders in all categories including the root logger.
-     * 
-     * <p>Some appenders such as {@link LoggerSocketAppender}
-     * need to be closed before the
-     * application exists. Otherwise, pending logging events might be
-     * lost.
-     * 
-     * <p>The shutdown method is careful to close nested
-     * appenders before closing regular appenders. This is allows
-     * configurations where a regular appender is attached to a logger
-     * and again to a nested appender.
-     */
-    public function shutdown()
-    {
-        $this->root->removeAllAppenders();
-        $cats =& $this->getCurrentLoggers();
-        $enumCats = sizeof($cats);        
-        if ($enumCats > 0) {
-            for ($i = 0; $i < $enumCats; $i++) {
-                $cats[$i]->removeAllAppenders();
-            }
-        }
-    }  
+	/**
+	 * Shutting down a hierarchy will <i>safely</i> close and remove
+	 * all appenders in all categories including the root logger.
+	 * 
+	 * <p>Some appenders such as {@link LoggerSocketAppender}
+	 * need to be closed before the
+	 * application exists. Otherwise, pending logging events might be
+	 * lost.
+	 * 
+	 * <p>The shutdown method is careful to close nested
+	 * appenders before closing regular appenders. This is allows
+	 * configurations where a regular appender is attached to a logger
+	 * and again to a nested appender.
+	 */
+	public function shutdown()
+	{
+		$this->root->removeAllAppenders();
+		$cats =& $this->getCurrentLoggers();
+		$enumCats = sizeof($cats);        
+		if ($enumCats > 0) {
+			for ($i = 0; $i < $enumCats; $i++) {
+				$cats[$i]->removeAllAppenders();
+			}
+		}
+	}  
 } 
 ?>
\ No newline at end of file