YetiForceCompany / YetiForceCRM

admin/include/Viewer.php

Braces +8 added lines, -6 removed lines

@@ -28,8 +28,9 @@ 
 	protected function log($message, $delimiter = "\n")
 	{
 		static $file = null;
-		if ($file === null)
-			$file = dirname(__FILE__) . '/../../cache/logs/viewer-debug.log';
+		if ($file === null) {
+					$file = dirname(__FILE__) . '/../../cache/logs/viewer-debug.log';
+		}
 		if (self::$debugViewer) {
 			file_put_contents($file, $message . $delimiter, FILE_APPEND);
 		}
@@ -173,10 +174,11 @@ 
 			foreach ($this->tpl_vars as $key => $smarty_variable) {
 				// Determine type of value being pased.
 				$valueType = 'literal';
-				if (is_object($smarty_variable->value))
-					$valueType = get_class($smarty_variable->value);
-				else if (is_array($smarty_variable->value))
-					$valueType = 'array';
+				if (is_object($smarty_variable->value)) {
+									$valueType = get_class($smarty_variable->value);
+				} else if (is_array($smarty_variable->value)) {
+									$valueType = 'array';
+				}
 				$this->log(sprintf("DATA: %s, TYPE: %s", $key, $valueType));
 			}
 		}

libraries/Smarty/libs/sysplugins/smarty_security.php

Indentation +705 added lines, -705 removed lines

@@ -13,710 +13,710 @@
  */
 class Smarty_Security
 {
-    /**
-     * This determines how Smarty handles "<?php ... ?>" tags in templates.
-     * possible values:
-     * <ul>
-     *   <li>Smarty::PHP_PASSTHRU -> echo PHP tags as they are</li>
-     *   <li>Smarty::PHP_QUOTE    -> escape tags as entities</li>
-     *   <li>Smarty::PHP_REMOVE   -> remove php tags</li>
-     *   <li>Smarty::PHP_ALLOW    -> execute php tags</li>
-     * </ul>
-     *
-     * @var integer
-     */
-    public $php_handling = Smarty::PHP_PASSTHRU;
-
-    /**
-     * This is the list of template directories that are considered secure.
-     * $template_dir is in this list implicitly.
-     *
-     * @var array
-     */
-    public $secure_dir = array();
-
-    /**
-     * This is an array of directories where trusted php scripts reside.
-     * {@link $security} is disabled during their inclusion/execution.
-     *
-     * @var array
-     */
-    public $trusted_dir = array();
-
-    /**
-     * List of regular expressions (PCRE) that include trusted URIs
-     *
-     * @var array
-     */
-    public $trusted_uri = array();
-
-    /**
-     * List of trusted constants names
-     *
-     * @var array
-     */
-    public $trusted_constants = array();
-
-    /**
-     * This is an array of trusted static classes.
-     * If empty access to all static classes is allowed.
-     * If set to 'none' none is allowed.
-     *
-     * @var array
-     */
-    public $static_classes = array();
-
-    /**
-     * This is an nested array of trusted classes and static methods.
-     * If empty access to all static classes and methods is allowed.
-     * Format:
-     * array (
-     *         'class_1' => array('method_1', 'method_2'), // allowed methods listed
-     *         'class_2' => array(),                       // all methods of class allowed
-     *       )
-     * If set to null none is allowed.
-     *
-     * @var array
-     */
-    public $trusted_static_methods = array();
-
-    /**
-     * This is an array of trusted static properties.
-     * If empty access to all static classes and properties is allowed.
-     * Format:
-     * array (
-     *         'class_1' => array('prop_1', 'prop_2'), // allowed properties listed
-     *         'class_2' => array(),                   // all properties of class allowed
-     *       )
-     * If set to null none is allowed.
-     *
-     * @var array
-     */
-    public $trusted_static_properties = array();
-
-    /**
-     * This is an array of trusted PHP functions.
-     * If empty all functions are allowed.
-     * To disable all PHP functions set $php_functions = null.
-     *
-     * @var array
-     */
-    public $php_functions = array('isset', 'empty', 'count', 'sizeof', 'in_array', 'is_array', 'time',);
-
-    /**
-     * This is an array of trusted PHP modifiers.
-     * If empty all modifiers are allowed.
-     * To disable all modifier set $php_modifiers = null.
-     *
-     * @var array
-     */
-    public $php_modifiers = array('escape', 'count', 'nl2br',);
-
-    /**
-     * This is an array of allowed tags.
-     * If empty no restriction by allowed_tags.
-     *
-     * @var array
-     */
-    public $allowed_tags = array();
-
-    /**
-     * This is an array of disabled tags.
-     * If empty no restriction by disabled_tags.
-     *
-     * @var array
-     */
-    public $disabled_tags = array();
-
-    /**
-     * This is an array of allowed modifier plugins.
-     * If empty no restriction by allowed_modifiers.
-     *
-     * @var array
-     */
-    public $allowed_modifiers = array();
-
-    /**
-     * This is an array of disabled modifier plugins.
-     * If empty no restriction by disabled_modifiers.
-     *
-     * @var array
-     */
-    public $disabled_modifiers = array();
-
-    /**
-     * This is an array of disabled special $smarty variables.
-     *
-     * @var array
-     */
-    public $disabled_special_smarty_vars = array();
-
-    /**
-     * This is an array of trusted streams.
-     * If empty all streams are allowed.
-     * To disable all streams set $streams = null.
-     *
-     * @var array
-     */
-    public $streams = array('file');
-
-    /**
-     * + flag if constants can be accessed from template
-     *
-     * @var boolean
-     */
-    public $allow_constants = true;
-
-    /**
-     * + flag if super globals can be accessed from template
-     *
-     * @var boolean
-     */
-    public $allow_super_globals = true;
-
-    /**
-     * max template nesting level
-     *
-     * @var int
-     */
-    public $max_template_nesting = 0;
-
-    /**
-     * current template nesting level
-     *
-     * @var int
-     */
-    private $_current_template_nesting = 0;
-
-    /**
-     * Cache for $resource_dir lookup
-     *
-     * @var array
-     */
-    protected $_resource_dir = array();
-
-    /**
-     * Cache for $template_dir lookup
-     *
-     * @var array
-     */
-    protected $_template_dir = array();
-
-    /**
-     * Cache for $config_dir lookup
-     *
-     * @var array
-     */
-    protected $_config_dir = array();
-
-    /**
-     * Cache for $secure_dir lookup
-     *
-     * @var array
-     */
-    protected $_secure_dir = array();
-
-    /**
-     * Cache for $php_resource_dir lookup
-     *
-     * @var array
-     */
-    protected $_php_resource_dir = null;
-
-    /**
-     * Cache for $trusted_dir lookup
-     *
-     * @var array
-     */
-    protected $_trusted_dir = null;
-
-    /**
-     * Cache for include path status
-     *
-     * @var bool
-     */
-    protected $_include_path_status = false;
-
-    /**
-     * Cache for $_include_array lookup
-     *
-     * @var array
-     */
-    protected $_include_dir = array();
-
-    /**
-     * @param Smarty $smarty
-     */
-    public function __construct($smarty)
-    {
-        $this->smarty = $smarty;
-        $this->smarty->_cache[ 'template_dir_new' ] = true;
-        $this->smarty->_cache[ 'config_dir_new' ] = true;
-    }
-
-    /**
-     * Check if PHP function is trusted.
-     *
-     * @param  string $function_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if function is trusted
-     * @throws SmartyCompilerException if php function is not trusted
-     */
-    public function isTrustedPhpFunction($function_name, $compiler)
-    {
-        if (isset($this->php_functions) &&
-            (empty($this->php_functions) || in_array($function_name, $this->php_functions))
-        ) {
-            return true;
-        }
-
-        $compiler->trigger_template_error("PHP function '{$function_name}' not allowed by security setting");
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if static class is trusted.
-     *
-     * @param  string $class_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if class is trusted
-     * @throws SmartyCompilerException if static class is not trusted
-     */
-    public function isTrustedStaticClass($class_name, $compiler)
-    {
-        if (isset($this->static_classes) &&
-            (empty($this->static_classes) || in_array($class_name, $this->static_classes))
-        ) {
-            return true;
-        }
-
-        $compiler->trigger_template_error("access to static class '{$class_name}' not allowed by security setting");
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if static class method/property is trusted.
-     *
-     * @param  string $class_name
-     * @param  string $params
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if class method is trusted
-     * @throws SmartyCompilerException if static class method is not trusted
-     */
-    public function isTrustedStaticClassAccess($class_name, $params, $compiler)
-    {
-        if (!isset($params[ 2 ])) {
-            // fall back
-            return $this->isTrustedStaticClass($class_name, $compiler);
-        }
-        if ($params[ 2 ] == 'method') {
-            $allowed = $this->trusted_static_methods;
-            $name = substr($params[ 0 ], 0, strpos($params[ 0 ], '('));
-        } else {
-            $allowed = $this->trusted_static_properties;
-            // strip '$'
-            $name = substr($params[ 0 ], 1);
-        }
-        if (isset($allowed)) {
-            if (empty($allowed)) {
-                // fall back
-                return $this->isTrustedStaticClass($class_name, $compiler);
-            }
-            if (isset($allowed[ $class_name ]) &&
-                (empty($allowed[ $class_name ]) || in_array($name, $allowed[ $class_name ]))
-            ) {
-                return true;
-            }
-        }
-        $compiler->trigger_template_error("access to static class '{$class_name}' {$params[2]} '{$name}' not allowed by security setting");
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if PHP modifier is trusted.
-     *
-     * @param  string $modifier_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if modifier is trusted
-     * @throws SmartyCompilerException if modifier is not trusted
-     */
-    public function isTrustedPhpModifier($modifier_name, $compiler)
-    {
-        if (isset($this->php_modifiers) &&
-            (empty($this->php_modifiers) || in_array($modifier_name, $this->php_modifiers))
-        ) {
-            return true;
-        }
-
-        $compiler->trigger_template_error("modifier '{$modifier_name}' not allowed by security setting");
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if tag is trusted.
-     *
-     * @param  string $tag_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if tag is trusted
-     * @throws SmartyCompilerException if modifier is not trusted
-     */
-    public function isTrustedTag($tag_name, $compiler)
-    {
-        // check for internal always required tags
-        if (in_array($tag_name,
-                     array('assign', 'call', 'private_filter', 'private_block_plugin', 'private_function_plugin',
-                           'private_object_block_function', 'private_object_function', 'private_registered_function',
-                           'private_registered_block', 'private_special_variable', 'private_print_expression',
-                           'private_modifier'))) {
-            return true;
-        }
-        // check security settings
-        if (empty($this->allowed_tags)) {
-            if (empty($this->disabled_tags) || !in_array($tag_name, $this->disabled_tags)) {
-                return true;
-            } else {
-                $compiler->trigger_template_error("tag '{$tag_name}' disabled by security setting", null, true);
-            }
-        } elseif (in_array($tag_name, $this->allowed_tags) && !in_array($tag_name, $this->disabled_tags)) {
-            return true;
-        } else {
-            $compiler->trigger_template_error("tag '{$tag_name}' not allowed by security setting", null, true);
-        }
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if special $smarty variable is trusted.
-     *
-     * @param  string $var_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if tag is trusted
-     * @throws SmartyCompilerException if modifier is not trusted
-     */
-    public function isTrustedSpecialSmartyVar($var_name, $compiler)
-    {
-        if (!in_array($var_name, $this->disabled_special_smarty_vars)) {
-            return true;
-        } else {
-            $compiler->trigger_template_error("special variable '\$smarty.{$var_name}' not allowed by security setting",
-                                              null, true);
-        }
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if modifier plugin is trusted.
-     *
-     * @param  string $modifier_name
-     * @param  object $compiler compiler object
-     *
-     * @return boolean                 true if tag is trusted
-     * @throws SmartyCompilerException if modifier is not trusted
-     */
-    public function isTrustedModifier($modifier_name, $compiler)
-    {
-        // check for internal always allowed modifier
-        if (in_array($modifier_name, array('default'))) {
-            return true;
-        }
-        // check security settings
-        if (empty($this->allowed_modifiers)) {
-            if (empty($this->disabled_modifiers) || !in_array($modifier_name, $this->disabled_modifiers)) {
-                return true;
-            } else {
-                $compiler->trigger_template_error("modifier '{$modifier_name}' disabled by security setting", null,
-                                                  true);
-            }
-        } elseif (in_array($modifier_name, $this->allowed_modifiers) &&
-                  !in_array($modifier_name, $this->disabled_modifiers)
-        ) {
-            return true;
-        } else {
-            $compiler->trigger_template_error("modifier '{$modifier_name}' not allowed by security setting", null,
-                                              true);
-        }
-
-        return false; // should not, but who knows what happens to the compiler in the future?
-    }
-
-    /**
-     * Check if constants are enabled or trusted
-     *
-     * @param  string $const    constant name
-     * @param  object $compiler compiler object
-     *
-     * @return bool
-     */
-    public function isTrustedConstant($const, $compiler)
-    {
-        if (in_array($const, array('true', 'false', 'null'))) {
-            return true;
-        }
-        if (!empty($this->trusted_constants)) {
-            if (!in_array($const, $this->trusted_constants)) {
-                $compiler->trigger_template_error("Security: access to constant '{$const}' not permitted");
-                return false;
-            }
-            return true;
-        }
-        if ($this->allow_constants) {
-            return true;
-        }
-        $compiler->trigger_template_error("Security: access to constants not permitted");
-        return false;
-    }
-
-    /**
-     * Check if stream is trusted.
-     *
-     * @param  string $stream_name
-     *
-     * @return boolean         true if stream is trusted
-     * @throws SmartyException if stream is not trusted
-     */
-    public function isTrustedStream($stream_name)
-    {
-        if (isset($this->streams) && (empty($this->streams) || in_array($stream_name, $this->streams))) {
-            return true;
-        }
-
-        throw new SmartyException("stream '{$stream_name}' not allowed by security setting");
-    }
-
-    /**
-     * Check if directory of file resource is trusted.
-     *
-     * @param  string   $filepath
-     * @param null|bool $isConfig
-     *
-     * @return bool true if directory is trusted
-     * @throws \SmartyException if directory is not trusted
-     */
-    public function isTrustedResourceDir($filepath, $isConfig = null)
-    {
-        if ($this->_include_path_status !== $this->smarty->use_include_path) {
-            foreach ($this->_include_dir as $directory) {
-                unset($this->_resource_dir[ $directory ]);
-            }
-            if ($this->smarty->use_include_path) {
-                $this->_include_dir = array();
-                $_dirs = $this->smarty->ext->_getIncludePath->getIncludePathDirs($this->smarty);
-                foreach ($_dirs as $directory) {
-                    $this->_include_dir[] = $directory;
-                    $this->_resource_dir[ $directory ] = true;
-                }
-            }
-            $this->_include_path_status = $this->smarty->use_include_path;
-        }
-        if ($isConfig !== true &&
-            (!isset($this->smarty->_cache[ 'template_dir_new' ]) || $this->smarty->_cache[ 'template_dir_new' ])
-        ) {
-            $_dir = $this->smarty->getTemplateDir();
-            if ($this->_template_dir !== $_dir) {
-                foreach ($this->_template_dir as $directory) {
-                    unset($this->_resource_dir[ $directory ]);
-                }
-                foreach ($_dir as $directory) {
-                    $this->_resource_dir[ $directory ] = true;
-                }
-                $this->_template_dir = $_dir;
-            }
-            $this->smarty->_cache[ 'template_dir_new' ] = false;
-        }
-        if ($isConfig !== false &&
-            (!isset($this->smarty->_cache[ 'config_dir_new' ]) || $this->smarty->_cache[ 'config_dir_new' ])
-        ) {
-            $_dir = $this->smarty->getConfigDir();
-            if ($this->_config_dir !== $_dir) {
-                foreach ($this->_config_dir as $directory) {
-                    unset($this->_resource_dir[ $directory ]);
-                }
-                foreach ($_dir as $directory) {
-                    $this->_resource_dir[ $directory ] = true;
-                }
-                $this->_config_dir = $_dir;
-            }
-            $this->smarty->_cache[ 'config_dir_new' ] = false;
-        }
-        if ($this->_secure_dir !== (array) $this->secure_dir) {
-            foreach ($this->_secure_dir as $directory) {
-                unset($this->_resource_dir[ $directory ]);
-            }
-            foreach ((array) $this->secure_dir as $directory) {
-                $directory = $this->smarty->_realpath($directory . DS, true);
-                $this->_resource_dir[ $directory ] = true;
-            }
-            $this->_secure_dir = (array) $this->secure_dir;
-        }
-        $this->_resource_dir = $this->_checkDir($filepath, $this->_resource_dir);
-        return true;
-    }
-
-    /**
-     * Check if URI (e.g. {fetch} or {html_image}) is trusted
-     * To simplify things, isTrustedUri() resolves all input to "{$PROTOCOL}://{$HOSTNAME}".
-     * So "http://username:password@hello.world.example.org:8080/some-path?some=query-string"
-     * is reduced to "http://hello.world.example.org" prior to applying the patters from {@link $trusted_uri}.
-     *
-     * @param  string $uri
-     *
-     * @return boolean         true if URI is trusted
-     * @throws SmartyException if URI is not trusted
-     * @uses $trusted_uri for list of patterns to match against $uri
-     */
-    public function isTrustedUri($uri)
-    {
-        $_uri = parse_url($uri);
-        if (!empty($_uri[ 'scheme' ]) && !empty($_uri[ 'host' ])) {
-            $_uri = $_uri[ 'scheme' ] . '://' . $_uri[ 'host' ];
-            foreach ($this->trusted_uri as $pattern) {
-                if (preg_match($pattern, $_uri)) {
-                    return true;
-                }
-            }
-        }
-
-        throw new SmartyException("URI '{$uri}' not allowed by security setting");
-    }
-
-    /**
-     * Check if directory of file resource is trusted.
-     *
-     * @param  string $filepath
-     *
-     * @return boolean         true if directory is trusted
-     * @throws SmartyException if PHP directory is not trusted
-     */
-    public function isTrustedPHPDir($filepath)
-    {
-        if (empty($this->trusted_dir)) {
-            throw new SmartyException("directory '{$filepath}' not allowed by security setting (no trusted_dir specified)");
-        }
-
-        // check if index is outdated
-        if (!$this->_trusted_dir || $this->_trusted_dir !== $this->trusted_dir) {
-            $this->_php_resource_dir = array();
-
-            $this->_trusted_dir = $this->trusted_dir;
-            foreach ((array) $this->trusted_dir as $directory) {
-                $directory = $this->smarty->_realpath($directory . DS, true);
-                $this->_php_resource_dir[ $directory ] = true;
-            }
-        }
-
-        $this->_php_resource_dir =
-            $this->_checkDir($this->smarty->_realpath($filepath, true), $this->_php_resource_dir);
-        return true;
-    }
+	/**
+	 * This determines how Smarty handles "<?php ... ?>" tags in templates.
+	 * possible values:
+	 * <ul>
+	 *   <li>Smarty::PHP_PASSTHRU -> echo PHP tags as they are</li>
+	 *   <li>Smarty::PHP_QUOTE    -> escape tags as entities</li>
+	 *   <li>Smarty::PHP_REMOVE   -> remove php tags</li>
+	 *   <li>Smarty::PHP_ALLOW    -> execute php tags</li>
+	 * </ul>
+	 *
+	 * @var integer
+	 */
+	public $php_handling = Smarty::PHP_PASSTHRU;
+
+	/**
+	 * This is the list of template directories that are considered secure.
+	 * $template_dir is in this list implicitly.
+	 *
+	 * @var array
+	 */
+	public $secure_dir = array();
+
+	/**
+	 * This is an array of directories where trusted php scripts reside.
+	 * {@link $security} is disabled during their inclusion/execution.
+	 *
+	 * @var array
+	 */
+	public $trusted_dir = array();
+
+	/**
+	 * List of regular expressions (PCRE) that include trusted URIs
+	 *
+	 * @var array
+	 */
+	public $trusted_uri = array();
+
+	/**
+	 * List of trusted constants names
+	 *
+	 * @var array
+	 */
+	public $trusted_constants = array();
+
+	/**
+	 * This is an array of trusted static classes.
+	 * If empty access to all static classes is allowed.
+	 * If set to 'none' none is allowed.
+	 *
+	 * @var array
+	 */
+	public $static_classes = array();
+
+	/**
+	 * This is an nested array of trusted classes and static methods.
+	 * If empty access to all static classes and methods is allowed.
+	 * Format:
+	 * array (
+	 *         'class_1' => array('method_1', 'method_2'), // allowed methods listed
+	 *         'class_2' => array(),                       // all methods of class allowed
+	 *       )
+	 * If set to null none is allowed.
+	 *
+	 * @var array
+	 */
+	public $trusted_static_methods = array();
+
+	/**
+	 * This is an array of trusted static properties.
+	 * If empty access to all static classes and properties is allowed.
+	 * Format:
+	 * array (
+	 *         'class_1' => array('prop_1', 'prop_2'), // allowed properties listed
+	 *         'class_2' => array(),                   // all properties of class allowed
+	 *       )
+	 * If set to null none is allowed.
+	 *
+	 * @var array
+	 */
+	public $trusted_static_properties = array();
+
+	/**
+	 * This is an array of trusted PHP functions.
+	 * If empty all functions are allowed.
+	 * To disable all PHP functions set $php_functions = null.
+	 *
+	 * @var array
+	 */
+	public $php_functions = array('isset', 'empty', 'count', 'sizeof', 'in_array', 'is_array', 'time',);
+
+	/**
+	 * This is an array of trusted PHP modifiers.
+	 * If empty all modifiers are allowed.
+	 * To disable all modifier set $php_modifiers = null.
+	 *
+	 * @var array
+	 */
+	public $php_modifiers = array('escape', 'count', 'nl2br',);
+
+	/**
+	 * This is an array of allowed tags.
+	 * If empty no restriction by allowed_tags.
+	 *
+	 * @var array
+	 */
+	public $allowed_tags = array();
+
+	/**
+	 * This is an array of disabled tags.
+	 * If empty no restriction by disabled_tags.
+	 *
+	 * @var array
+	 */
+	public $disabled_tags = array();
+
+	/**
+	 * This is an array of allowed modifier plugins.
+	 * If empty no restriction by allowed_modifiers.
+	 *
+	 * @var array
+	 */
+	public $allowed_modifiers = array();
+
+	/**
+	 * This is an array of disabled modifier plugins.
+	 * If empty no restriction by disabled_modifiers.
+	 *
+	 * @var array
+	 */
+	public $disabled_modifiers = array();
+
+	/**
+	 * This is an array of disabled special $smarty variables.
+	 *
+	 * @var array
+	 */
+	public $disabled_special_smarty_vars = array();
+
+	/**
+	 * This is an array of trusted streams.
+	 * If empty all streams are allowed.
+	 * To disable all streams set $streams = null.
+	 *
+	 * @var array
+	 */
+	public $streams = array('file');
+
+	/**
+	 * + flag if constants can be accessed from template
+	 *
+	 * @var boolean
+	 */
+	public $allow_constants = true;
+
+	/**
+	 * + flag if super globals can be accessed from template
+	 *
+	 * @var boolean
+	 */
+	public $allow_super_globals = true;
+
+	/**
+	 * max template nesting level
+	 *
+	 * @var int
+	 */
+	public $max_template_nesting = 0;
+
+	/**
+	 * current template nesting level
+	 *
+	 * @var int
+	 */
+	private $_current_template_nesting = 0;
+
+	/**
+	 * Cache for $resource_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_resource_dir = array();
+
+	/**
+	 * Cache for $template_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_template_dir = array();
+
+	/**
+	 * Cache for $config_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_config_dir = array();
+
+	/**
+	 * Cache for $secure_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_secure_dir = array();
+
+	/**
+	 * Cache for $php_resource_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_php_resource_dir = null;
+
+	/**
+	 * Cache for $trusted_dir lookup
+	 *
+	 * @var array
+	 */
+	protected $_trusted_dir = null;
+
+	/**
+	 * Cache for include path status
+	 *
+	 * @var bool
+	 */
+	protected $_include_path_status = false;
+
+	/**
+	 * Cache for $_include_array lookup
+	 *
+	 * @var array
+	 */
+	protected $_include_dir = array();
+
+	/**
+	 * @param Smarty $smarty
+	 */
+	public function __construct($smarty)
+	{
+		$this->smarty = $smarty;
+		$this->smarty->_cache[ 'template_dir_new' ] = true;
+		$this->smarty->_cache[ 'config_dir_new' ] = true;
+	}
+
+	/**
+	 * Check if PHP function is trusted.
+	 *
+	 * @param  string $function_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if function is trusted
+	 * @throws SmartyCompilerException if php function is not trusted
+	 */
+	public function isTrustedPhpFunction($function_name, $compiler)
+	{
+		if (isset($this->php_functions) &&
+			(empty($this->php_functions) || in_array($function_name, $this->php_functions))
+		) {
+			return true;
+		}
+
+		$compiler->trigger_template_error("PHP function '{$function_name}' not allowed by security setting");
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if static class is trusted.
+	 *
+	 * @param  string $class_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if class is trusted
+	 * @throws SmartyCompilerException if static class is not trusted
+	 */
+	public function isTrustedStaticClass($class_name, $compiler)
+	{
+		if (isset($this->static_classes) &&
+			(empty($this->static_classes) || in_array($class_name, $this->static_classes))
+		) {
+			return true;
+		}
+
+		$compiler->trigger_template_error("access to static class '{$class_name}' not allowed by security setting");
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if static class method/property is trusted.
+	 *
+	 * @param  string $class_name
+	 * @param  string $params
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if class method is trusted
+	 * @throws SmartyCompilerException if static class method is not trusted
+	 */
+	public function isTrustedStaticClassAccess($class_name, $params, $compiler)
+	{
+		if (!isset($params[ 2 ])) {
+			// fall back
+			return $this->isTrustedStaticClass($class_name, $compiler);
+		}
+		if ($params[ 2 ] == 'method') {
+			$allowed = $this->trusted_static_methods;
+			$name = substr($params[ 0 ], 0, strpos($params[ 0 ], '('));
+		} else {
+			$allowed = $this->trusted_static_properties;
+			// strip '$'
+			$name = substr($params[ 0 ], 1);
+		}
+		if (isset($allowed)) {
+			if (empty($allowed)) {
+				// fall back
+				return $this->isTrustedStaticClass($class_name, $compiler);
+			}
+			if (isset($allowed[ $class_name ]) &&
+				(empty($allowed[ $class_name ]) || in_array($name, $allowed[ $class_name ]))
+			) {
+				return true;
+			}
+		}
+		$compiler->trigger_template_error("access to static class '{$class_name}' {$params[2]} '{$name}' not allowed by security setting");
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if PHP modifier is trusted.
+	 *
+	 * @param  string $modifier_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if modifier is trusted
+	 * @throws SmartyCompilerException if modifier is not trusted
+	 */
+	public function isTrustedPhpModifier($modifier_name, $compiler)
+	{
+		if (isset($this->php_modifiers) &&
+			(empty($this->php_modifiers) || in_array($modifier_name, $this->php_modifiers))
+		) {
+			return true;
+		}
+
+		$compiler->trigger_template_error("modifier '{$modifier_name}' not allowed by security setting");
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if tag is trusted.
+	 *
+	 * @param  string $tag_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if tag is trusted
+	 * @throws SmartyCompilerException if modifier is not trusted
+	 */
+	public function isTrustedTag($tag_name, $compiler)
+	{
+		// check for internal always required tags
+		if (in_array($tag_name,
+					 array('assign', 'call', 'private_filter', 'private_block_plugin', 'private_function_plugin',
+						   'private_object_block_function', 'private_object_function', 'private_registered_function',
+						   'private_registered_block', 'private_special_variable', 'private_print_expression',
+						   'private_modifier'))) {
+			return true;
+		}
+		// check security settings
+		if (empty($this->allowed_tags)) {
+			if (empty($this->disabled_tags) || !in_array($tag_name, $this->disabled_tags)) {
+				return true;
+			} else {
+				$compiler->trigger_template_error("tag '{$tag_name}' disabled by security setting", null, true);
+			}
+		} elseif (in_array($tag_name, $this->allowed_tags) && !in_array($tag_name, $this->disabled_tags)) {
+			return true;
+		} else {
+			$compiler->trigger_template_error("tag '{$tag_name}' not allowed by security setting", null, true);
+		}
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if special $smarty variable is trusted.
+	 *
+	 * @param  string $var_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if tag is trusted
+	 * @throws SmartyCompilerException if modifier is not trusted
+	 */
+	public function isTrustedSpecialSmartyVar($var_name, $compiler)
+	{
+		if (!in_array($var_name, $this->disabled_special_smarty_vars)) {
+			return true;
+		} else {
+			$compiler->trigger_template_error("special variable '\$smarty.{$var_name}' not allowed by security setting",
+											  null, true);
+		}
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if modifier plugin is trusted.
+	 *
+	 * @param  string $modifier_name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return boolean                 true if tag is trusted
+	 * @throws SmartyCompilerException if modifier is not trusted
+	 */
+	public function isTrustedModifier($modifier_name, $compiler)
+	{
+		// check for internal always allowed modifier
+		if (in_array($modifier_name, array('default'))) {
+			return true;
+		}
+		// check security settings
+		if (empty($this->allowed_modifiers)) {
+			if (empty($this->disabled_modifiers) || !in_array($modifier_name, $this->disabled_modifiers)) {
+				return true;
+			} else {
+				$compiler->trigger_template_error("modifier '{$modifier_name}' disabled by security setting", null,
+												  true);
+			}
+		} elseif (in_array($modifier_name, $this->allowed_modifiers) &&
+				  !in_array($modifier_name, $this->disabled_modifiers)
+		) {
+			return true;
+		} else {
+			$compiler->trigger_template_error("modifier '{$modifier_name}' not allowed by security setting", null,
+											  true);
+		}
+
+		return false; // should not, but who knows what happens to the compiler in the future?
+	}
+
+	/**
+	 * Check if constants are enabled or trusted
+	 *
+	 * @param  string $const    constant name
+	 * @param  object $compiler compiler object
+	 *
+	 * @return bool
+	 */
+	public function isTrustedConstant($const, $compiler)
+	{
+		if (in_array($const, array('true', 'false', 'null'))) {
+			return true;
+		}
+		if (!empty($this->trusted_constants)) {
+			if (!in_array($const, $this->trusted_constants)) {
+				$compiler->trigger_template_error("Security: access to constant '{$const}' not permitted");
+				return false;
+			}
+			return true;
+		}
+		if ($this->allow_constants) {
+			return true;
+		}
+		$compiler->trigger_template_error("Security: access to constants not permitted");
+		return false;
+	}
+
+	/**
+	 * Check if stream is trusted.
+	 *
+	 * @param  string $stream_name
+	 *
+	 * @return boolean         true if stream is trusted
+	 * @throws SmartyException if stream is not trusted
+	 */
+	public function isTrustedStream($stream_name)
+	{
+		if (isset($this->streams) && (empty($this->streams) || in_array($stream_name, $this->streams))) {
+			return true;
+		}
+
+		throw new SmartyException("stream '{$stream_name}' not allowed by security setting");
+	}
+
+	/**
+	 * Check if directory of file resource is trusted.
+	 *
+	 * @param  string   $filepath
+	 * @param null|bool $isConfig
+	 *
+	 * @return bool true if directory is trusted
+	 * @throws \SmartyException if directory is not trusted
+	 */
+	public function isTrustedResourceDir($filepath, $isConfig = null)
+	{
+		if ($this->_include_path_status !== $this->smarty->use_include_path) {
+			foreach ($this->_include_dir as $directory) {
+				unset($this->_resource_dir[ $directory ]);
+			}
+			if ($this->smarty->use_include_path) {
+				$this->_include_dir = array();
+				$_dirs = $this->smarty->ext->_getIncludePath->getIncludePathDirs($this->smarty);
+				foreach ($_dirs as $directory) {
+					$this->_include_dir[] = $directory;
+					$this->_resource_dir[ $directory ] = true;
+				}
+			}
+			$this->_include_path_status = $this->smarty->use_include_path;
+		}
+		if ($isConfig !== true &&
+			(!isset($this->smarty->_cache[ 'template_dir_new' ]) || $this->smarty->_cache[ 'template_dir_new' ])
+		) {
+			$_dir = $this->smarty->getTemplateDir();
+			if ($this->_template_dir !== $_dir) {
+				foreach ($this->_template_dir as $directory) {
+					unset($this->_resource_dir[ $directory ]);
+				}
+				foreach ($_dir as $directory) {
+					$this->_resource_dir[ $directory ] = true;
+				}
+				$this->_template_dir = $_dir;
+			}
+			$this->smarty->_cache[ 'template_dir_new' ] = false;
+		}
+		if ($isConfig !== false &&
+			(!isset($this->smarty->_cache[ 'config_dir_new' ]) || $this->smarty->_cache[ 'config_dir_new' ])
+		) {
+			$_dir = $this->smarty->getConfigDir();
+			if ($this->_config_dir !== $_dir) {
+				foreach ($this->_config_dir as $directory) {
+					unset($this->_resource_dir[ $directory ]);
+				}
+				foreach ($_dir as $directory) {
+					$this->_resource_dir[ $directory ] = true;
+				}
+				$this->_config_dir = $_dir;
+			}
+			$this->smarty->_cache[ 'config_dir_new' ] = false;
+		}
+		if ($this->_secure_dir !== (array) $this->secure_dir) {
+			foreach ($this->_secure_dir as $directory) {
+				unset($this->_resource_dir[ $directory ]);
+			}
+			foreach ((array) $this->secure_dir as $directory) {
+				$directory = $this->smarty->_realpath($directory . DS, true);
+				$this->_resource_dir[ $directory ] = true;
+			}
+			$this->_secure_dir = (array) $this->secure_dir;
+		}
+		$this->_resource_dir = $this->_checkDir($filepath, $this->_resource_dir);
+		return true;
+	}
+
+	/**
+	 * Check if URI (e.g. {fetch} or {html_image}) is trusted
+	 * To simplify things, isTrustedUri() resolves all input to "{$PROTOCOL}://{$HOSTNAME}".
+	 * So "http://username:password@hello.world.example.org:8080/some-path?some=query-string"
+	 * is reduced to "http://hello.world.example.org" prior to applying the patters from {@link $trusted_uri}.
+	 *
+	 * @param  string $uri
+	 *
+	 * @return boolean         true if URI is trusted
+	 * @throws SmartyException if URI is not trusted
+	 * @uses $trusted_uri for list of patterns to match against $uri
+	 */
+	public function isTrustedUri($uri)
+	{
+		$_uri = parse_url($uri);
+		if (!empty($_uri[ 'scheme' ]) && !empty($_uri[ 'host' ])) {
+			$_uri = $_uri[ 'scheme' ] . '://' . $_uri[ 'host' ];
+			foreach ($this->trusted_uri as $pattern) {
+				if (preg_match($pattern, $_uri)) {
+					return true;
+				}
+			}
+		}
+
+		throw new SmartyException("URI '{$uri}' not allowed by security setting");
+	}
+
+	/**
+	 * Check if directory of file resource is trusted.
+	 *
+	 * @param  string $filepath
+	 *
+	 * @return boolean         true if directory is trusted
+	 * @throws SmartyException if PHP directory is not trusted
+	 */
+	public function isTrustedPHPDir($filepath)
+	{
+		if (empty($this->trusted_dir)) {
+			throw new SmartyException("directory '{$filepath}' not allowed by security setting (no trusted_dir specified)");
+		}
+
+		// check if index is outdated
+		if (!$this->_trusted_dir || $this->_trusted_dir !== $this->trusted_dir) {
+			$this->_php_resource_dir = array();
+
+			$this->_trusted_dir = $this->trusted_dir;
+			foreach ((array) $this->trusted_dir as $directory) {
+				$directory = $this->smarty->_realpath($directory . DS, true);
+				$this->_php_resource_dir[ $directory ] = true;
+			}
+		}
+
+		$this->_php_resource_dir =
+			$this->_checkDir($this->smarty->_realpath($filepath, true), $this->_php_resource_dir);
+		return true;
+	}
     
-    /**
-     * Check if file is inside a valid directory
-     *
-     * @param string $filepath
-     * @param array  $dirs valid directories
-     *
-     * @return array
-     * @throws \SmartyException
-     */
-    private function _checkDir($filepath, $dirs)
-    {
-        $directory = dirname($filepath) . DS;
-        $_directory = array();
-        while (true) {
-            // remember the directory to add it to _resource_dir in case we're successful
-            $_directory[ $directory ] = true;
-            // test if the directory is trusted
-            if (isset($dirs[ $directory ])) {
-                // merge sub directories of current $directory into _resource_dir to speed up subsequent lookup
-                $dirs = array_merge($dirs, $_directory);
-
-                return $dirs;
-            }
-            // abort if we've reached root
-            if (!preg_match('#[\\\/][^\\\/]+[\\\/]$#', $directory)) {
-                break;
-            }
-            // bubble up one level
-            $directory = preg_replace('#[\\\/][^\\\/]+[\\\/]$#', DS, $directory);
-        }
-
-        // give up
-        throw new SmartyException("directory '{$filepath}' not allowed by security setting");
-    }
-
-    /**
-     * Loads security class and enables security
-     *
-     * @param \Smarty                 $smarty
-     * @param  string|Smarty_Security $security_class if a string is used, it must be class-name
-     *
-     * @return \Smarty current Smarty instance for chaining
-     * @throws \SmartyException when an invalid class name is provided
-     */
-    public static function enableSecurity(Smarty $smarty, $security_class)
-    {
-        if ($security_class instanceof Smarty_Security) {
-            $smarty->security_policy = $security_class;
-            return;
-        } elseif (is_object($security_class)) {
-            throw new SmartyException("Class '" . get_class($security_class) . "' must extend Smarty_Security.");
-        }
-        if ($security_class === null) {
-            $security_class = $smarty->security_class;
-        }
-        if (!class_exists($security_class)) {
-            throw new SmartyException("Security class '$security_class' is not defined");
-        } elseif ($security_class !== 'Smarty_Security' && !is_subclass_of($security_class, 'Smarty_Security')) {
-            throw new SmartyException("Class '$security_class' must extend Smarty_Security.");
-        } else {
-            $smarty->security_policy = new $security_class($smarty);
-        }
-        return;
-    }
-    /**
-     * Start template processing
-     *
-     * @param $template
-     *
-     * @throws SmartyException
-     */
-    public function startTemplate($template)
-    {
-        if ($this->max_template_nesting > 0 && $this->_current_template_nesting ++ >= $this->max_template_nesting) {
-            throw new SmartyException("maximum template nesting level of '{$this->max_template_nesting}' exceeded when calling '{$template->template_resource}'");
-        }
-    }
-
-    /**
-     * Exit template processing
-     *
-     */
-    public function endTemplate()
-    {
-        if ($this->max_template_nesting > 0) {
-            $this->_current_template_nesting --;
-        }
-    }
-
-    /**
-     * Register callback functions call at start/end of template rendering
-     *
-     * @param \Smarty_Internal_Template $template
-     */
-    public function registerCallBacks(Smarty_Internal_Template $template)
-    {
-        $template->startRenderCallbacks[] = array($this, 'startTemplate');
-        $template->endRenderCallbacks[] = array($this, 'endTemplate');
-    }
+	/**
+	 * Check if file is inside a valid directory
+	 *
+	 * @param string $filepath
+	 * @param array  $dirs valid directories
+	 *
+	 * @return array
+	 * @throws \SmartyException
+	 */
+	private function _checkDir($filepath, $dirs)
+	{
+		$directory = dirname($filepath) . DS;
+		$_directory = array();
+		while (true) {
+			// remember the directory to add it to _resource_dir in case we're successful
+			$_directory[ $directory ] = true;
+			// test if the directory is trusted
+			if (isset($dirs[ $directory ])) {
+				// merge sub directories of current $directory into _resource_dir to speed up subsequent lookup
+				$dirs = array_merge($dirs, $_directory);
+
+				return $dirs;
+			}
+			// abort if we've reached root
+			if (!preg_match('#[\\\/][^\\\/]+[\\\/]$#', $directory)) {
+				break;
+			}
+			// bubble up one level
+			$directory = preg_replace('#[\\\/][^\\\/]+[\\\/]$#', DS, $directory);
+		}
+
+		// give up
+		throw new SmartyException("directory '{$filepath}' not allowed by security setting");
+	}
+
+	/**
+	 * Loads security class and enables security
+	 *
+	 * @param \Smarty                 $smarty
+	 * @param  string|Smarty_Security $security_class if a string is used, it must be class-name
+	 *
+	 * @return \Smarty current Smarty instance for chaining
+	 * @throws \SmartyException when an invalid class name is provided
+	 */
+	public static function enableSecurity(Smarty $smarty, $security_class)
+	{
+		if ($security_class instanceof Smarty_Security) {
+			$smarty->security_policy = $security_class;
+			return;
+		} elseif (is_object($security_class)) {
+			throw new SmartyException("Class '" . get_class($security_class) . "' must extend Smarty_Security.");
+		}
+		if ($security_class === null) {
+			$security_class = $smarty->security_class;
+		}
+		if (!class_exists($security_class)) {
+			throw new SmartyException("Security class '$security_class' is not defined");
+		} elseif ($security_class !== 'Smarty_Security' && !is_subclass_of($security_class, 'Smarty_Security')) {
+			throw new SmartyException("Class '$security_class' must extend Smarty_Security.");
+		} else {
+			$smarty->security_policy = new $security_class($smarty);
+		}
+		return;
+	}
+	/**
+	 * Start template processing
+	 *
+	 * @param $template
+	 *
+	 * @throws SmartyException
+	 */
+	public function startTemplate($template)
+	{
+		if ($this->max_template_nesting > 0 && $this->_current_template_nesting ++ >= $this->max_template_nesting) {
+			throw new SmartyException("maximum template nesting level of '{$this->max_template_nesting}' exceeded when calling '{$template->template_resource}'");
+		}
+	}
+
+	/**
+	 * Exit template processing
+	 *
+	 */
+	public function endTemplate()
+	{
+		if ($this->max_template_nesting > 0) {
+			$this->_current_template_nesting --;
+		}
+	}
+
+	/**
+	 * Register callback functions call at start/end of template rendering
+	 *
+	 * @param \Smarty_Internal_Template $template
+	 */
+	public function registerCallBacks(Smarty_Internal_Template $template)
+	{
+		$template->startRenderCallbacks[] = array($this, 'startTemplate');
+		$template->endRenderCallbacks[] = array($this, 'endTemplate');
+	}
 }

libraries/log4php.debug/LoggerAppenderSkeleton.php

Indentation +268 added lines, -268 removed lines

@@ -41,315 +41,315 @@
  */
 class LoggerAppenderSkeleton extends LoggerAppender {
 
-    /**
-     * @var boolean closed appender flag
-     */
-    public $closed;
+	/**
+	 * @var boolean closed appender flag
+	 */
+	public $closed;
     
-    /**
-     * @var object unused
-     */
-    public $errorHandler;
+	/**
+	 * @var object unused
+	 */
+	public $errorHandler;
            
-    /**
-     * The first filter in the filter chain
-     * @var LoggerFilter
-     */
-    public $headFilter = null;
+	/**
+	 * The first filter in the filter chain
+	 * @var LoggerFilter
+	 */
+	public $headFilter = null;
             
-    /**
-     * LoggerLayout for this appender. It can be null if appender has its own layout
-     * @var LoggerLayout
-     */
-    public $layout = null; 
+	/**
+	 * LoggerLayout for this appender. It can be null if appender has its own layout
+	 * @var LoggerLayout
+	 */
+	public $layout = null; 
            
-    /**
-     * @var string Appender name
-     */
-    public $name;
+	/**
+	 * @var string Appender name
+	 */
+	public $name;
            
-    /**
-     * The last filter in the filter chain
-     * @var LoggerFilter
-     */
-    public $tailFilter = null; 
+	/**
+	 * The last filter in the filter chain
+	 * @var LoggerFilter
+	 */
+	public $tailFilter = null; 
            
-    /**
-     * @var LoggerLevel There is no level threshold filtering by default.
-     */
-    public $threshold = null;
+	/**
+	 * @var LoggerLevel There is no level threshold filtering by default.
+	 */
+	public $threshold = null;
     
-    /**
-     * @var boolean needs a layout formatting ?
-     */
-    public $requiresLayout = false;
+	/**
+	 * @var boolean needs a layout formatting ?
+	 */
+	public $requiresLayout = false;
     
 /* --------------------------------------------------------------------------*/
 /* --------------------------------------------------------------------------*/
 /* --------------------------------------------------------------------------*/
     
-    /**
-     * Constructor
-     *
-     * @param string $name appender name
-     */
-    public function LoggerAppenderSkeleton($name)
-    {
-        $this->name = $name;
-        $this->clearFilters();
-    }
+	/**
+	 * Constructor
+	 *
+	 * @param string $name appender name
+	 */
+	public function LoggerAppenderSkeleton($name)
+	{
+		$this->name = $name;
+		$this->clearFilters();
+	}
 
-    /**
-     * @param LoggerFilter $newFilter add a new LoggerFilter
-     * @see LoggerAppender::addFilter()
-     */
-    public function addFilter($newFilter)
-    {
-        if($this->headFilter === null) {
-            $this->headFilter = $newFilter;
-            $this->tailFilter =& $this->headFilter;
-        } else {
-            $this->tailFilter->next = $newFilter;
-            $this->tailFilter =& $this->tailFilter->next;
-        }
-    }
+	/**
+	 * @param LoggerFilter $newFilter add a new LoggerFilter
+	 * @see LoggerAppender::addFilter()
+	 */
+	public function addFilter($newFilter)
+	{
+		if($this->headFilter === null) {
+			$this->headFilter = $newFilter;
+			$this->tailFilter =& $this->headFilter;
+		} else {
+			$this->tailFilter->next = $newFilter;
+			$this->tailFilter =& $this->tailFilter->next;
+		}
+	}
     
-    /**
-     * Derived appenders should override this method if option structure
-     * requires it.
-     */
-    public function activateOptions() 
-    { 
+	/**
+	 * Derived appenders should override this method if option structure
+	 * requires it.
+	 */
+	public function activateOptions() 
+	{ 
 
-    }
+	}
     
-    /**
-     * Subclasses of {@link LoggerAppenderSkeleton} should implement 
-     * this method to perform actual logging.
-     *
-     * @param LoggerLoggingEvent $event
-     * @see doAppend()
-     * @abstract
-     */
-    public function append($event)
-    { 
-        // override me
-    }
+	/**
+	 * Subclasses of {@link LoggerAppenderSkeleton} should implement 
+	 * this method to perform actual logging.
+	 *
+	 * @param LoggerLoggingEvent $event
+	 * @see doAppend()
+	 * @abstract
+	 */
+	public function append($event)
+	{ 
+		// override me
+	}
  
-    /**
-     * @see LoggerAppender::clearFilters()
-     */
-    public function clearFilters()
-    {
-        unset($this->headFilter);
-        unset($this->tailFilter);
-        $this->headFilter = null;
-        $this->tailFilter = null;
-    }
+	/**
+	 * @see LoggerAppender::clearFilters()
+	 */
+	public function clearFilters()
+	{
+		unset($this->headFilter);
+		unset($this->tailFilter);
+		$this->headFilter = null;
+		$this->tailFilter = null;
+	}
            
-    /**
-     * @see LoggerAppender::close()
-     */
-    public function close()
-    {
-        //override me
-    }
+	/**
+	 * @see LoggerAppender::close()
+	 */
+	public function close()
+	{
+		//override me
+	}
             
-    /**
-     * Finalize this appender by calling the derived class' <i>close()</i> method.
-     */
-    public function finalize() 
-    {
-        // An appender might be closed then garbage collected. There is no
-        // point in closing twice.
-        if ($this->closed) return;
+	/**
+	 * Finalize this appender by calling the derived class' <i>close()</i> method.
+	 */
+	public function finalize() 
+	{
+		// An appender might be closed then garbage collected. There is no
+		// point in closing twice.
+		if ($this->closed) return;
         
-        LoggerLog::debug("LoggerAppenderSkeleton::finalize():name=[{$this->name}].");
+		LoggerLog::debug("LoggerAppenderSkeleton::finalize():name=[{$this->name}].");
         
-        $this->close();
-    }
+		$this->close();
+	}
     
-    /**
-     * Do not use this method.
-     * @see LoggerAppender::getErrorHandler()
-     * @return object
-     */
-    public function &getErrorHandler()
-    {
-        return $this->errorHandler;
-    } 
+	/**
+	 * Do not use this method.
+	 * @see LoggerAppender::getErrorHandler()
+	 * @return object
+	 */
+	public function &getErrorHandler()
+	{
+		return $this->errorHandler;
+	} 
            
-    /**
-     * @see LoggerAppender::getFilter()
-     * @return Filter
-     */
-    public function &getFilter()
-    {
-        return $this->headFilter;
-    } 
+	/**
+	 * @see LoggerAppender::getFilter()
+	 * @return Filter
+	 */
+	public function &getFilter()
+	{
+		return $this->headFilter;
+	} 
 
-    /** 
-     * 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 &getFirstFilter()
-    {
-        return $this->headFilter;
-    }
+	/** 
+	 * 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 &getFirstFilter()
+	{
+		return $this->headFilter;
+	}
             
-    /**
-     * @see LoggerAppender::getLayout()
-     * @return LoggerLayout
-     */
-    public function &getLayout()
-    {
-        return $this->layout;
-    }
+	/**
+	 * @see LoggerAppender::getLayout()
+	 * @return LoggerLayout
+	 */
+	public function &getLayout()
+	{
+		return $this->layout;
+	}
            
-    /**
-     * @see LoggerAppender::getName()
-     * @return string
-     */
-    public function getName()
-    {
-        return $this->name;
-    }
+	/**
+	 * @see LoggerAppender::getName()
+	 * @return string
+	 */
+	public function getName()
+	{
+		return $this->name;
+	}
     
-    /**
-     * Returns this appenders threshold level. 
-     * See the {@link setThreshold()} method for the meaning of this option.
-     * @return LoggerLevel
-     */
-    public function &getThreshold()
-    { 
-        return $this->threshold;
-    }
+	/**
+	 * Returns this appenders threshold level. 
+	 * See the {@link setThreshold()} method for the meaning of this option.
+	 * @return LoggerLevel
+	 */
+	public function &getThreshold()
+	{ 
+		return $this->threshold;
+	}
     
-    /**
-     * Check whether the message level is below the appender's threshold. 
-     *
-     *
-     * If there is no threshold set, then the return value is always <i>true</i>.
-     * @param LoggerLevel $priority
-     * @return boolean true if priority is greater or equal than threshold  
-     */
-    public function isAsSevereAsThreshold($priority)
-    {
-        if ($this->threshold === null)
-            return true;
+	/**
+	 * Check whether the message level is below the appender's threshold. 
+	 *
+	 *
+	 * If there is no threshold set, then the return value is always <i>true</i>.
+	 * @param LoggerLevel $priority
+	 * @return boolean true if priority is greater or equal than threshold  
+	 */
+	public function isAsSevereAsThreshold($priority)
+	{
+		if ($this->threshold === null)
+			return true;
             
-        return $priority->isGreaterOrEqual($this->getThreshold());
-    }
+		return $priority->isGreaterOrEqual($this->getThreshold());
+	}
     
-    /**
-     * @see LoggerAppender::doAppend()
-     * @param LoggerLoggingEvent $event
-     */
-    public function doAppend($event)
-    {
-        LoggerLog::debug("LoggerAppenderSkeleton::doAppend()"); 
+	/**
+	 * @see LoggerAppender::doAppend()
+	 * @param LoggerLoggingEvent $event
+	 */
+	public function doAppend($event)
+	{
+		LoggerLog::debug("LoggerAppenderSkeleton::doAppend()"); 
 
-        if ($this->closed) {
-            LoggerLog::debug("LoggerAppenderSkeleton::doAppend() Attempted to append to closed appender named [{$this->name}].");
-            return;
-        }
-        if(!$this->isAsSevereAsThreshold($event->getLevel())) {
-            LoggerLog::debug("LoggerAppenderSkeleton::doAppend() event level is less severe than threshold.");
-            return;
-        }
+		if ($this->closed) {
+			LoggerLog::debug("LoggerAppenderSkeleton::doAppend() Attempted to append to closed appender named [{$this->name}].");
+			return;
+		}
+		if(!$this->isAsSevereAsThreshold($event->getLevel())) {
+			LoggerLog::debug("LoggerAppenderSkeleton::doAppend() event level is less severe than threshold.");
+			return;
+		}
 
-        $f = $this->getFirstFilter();
+		$f = $this->getFirstFilter();
     
-        while($f !== null) {
-            switch ($f->decide($event)) {
-                case LOG4PHP_LOGGER_FILTER_DENY: return;
-                case LOG4PHP_LOGGER_FILTER_ACCEPT: return $this->append($event);
-                case LOG4PHP_LOGGER_FILTER_NEUTRAL: $f = $f->next;
-            }
-        }
-        $this->append($event);    
-    }    
+		while($f !== null) {
+			switch ($f->decide($event)) {
+				case LOG4PHP_LOGGER_FILTER_DENY: return;
+				case LOG4PHP_LOGGER_FILTER_ACCEPT: return $this->append($event);
+				case LOG4PHP_LOGGER_FILTER_NEUTRAL: $f = $f->next;
+			}
+		}
+		$this->append($event);    
+	}    
         
             
-    /**
-     * @see LoggerAppender::requiresLayout()
-     * @return boolean
-     */
-    public function requiresLayout()
-    {
-        return $this->requiresLayout;
-    }
+	/**
+	 * @see LoggerAppender::requiresLayout()
+	 * @return boolean
+	 */
+	public function requiresLayout()
+	{
+		return $this->requiresLayout;
+	}
             
-    /**
-     * @see LoggerAppender::setErrorHandler()
-     * @param object
-     */
-    public function setErrorHandler($errorHandler)
-    {
-        if($errorHandler === null) {
-          // We do not throw exception here since the cause is probably a
-          // bad config file.
-            LoggerLog::warn("You have tried to set a null error-handler.");
-        } else {
-            $this->errorHandler = $errorHandler;
-        }
-    } 
+	/**
+	 * @see LoggerAppender::setErrorHandler()
+	 * @param object
+	 */
+	public function setErrorHandler($errorHandler)
+	{
+		if($errorHandler === null) {
+		  // We do not throw exception here since the cause is probably a
+		  // bad config file.
+			LoggerLog::warn("You have tried to set a null error-handler.");
+		} else {
+			$this->errorHandler = $errorHandler;
+		}
+	} 
            
-    /**
-     * @see LoggerAppender::setLayout()
-     * @param LoggerLayout $layout
-     */
-    public function setLayout($layout)
-    {
-        if ($this->requiresLayout())
-            $this->layout = $layout;
-    } 
+	/**
+	 * @see LoggerAppender::setLayout()
+	 * @param LoggerLayout $layout
+	 */
+	public function setLayout($layout)
+	{
+		if ($this->requiresLayout())
+			$this->layout = $layout;
+	} 
  
-    /**
-     * @see LoggerAppender::setName()
-     * @param string $name
-     */
-    public function setName($name) 
-    {
-        $this->name = $name;    
-    }
+	/**
+	 * @see LoggerAppender::setName()
+	 * @param string $name
+	 */
+	public function setName($name) 
+	{
+		$this->name = $name;    
+	}
     
-    /**
-     * Set the threshold level of this appender.
-     *
-     * @param mixed $threshold can be a {@link LoggerLevel} object or a string.
-     * @see LoggerOptionConverter::toLevel()
-     */
-    public function setThreshold($threshold)
-    {
-        if (is_string($threshold)) {
-           $this->threshold = LoggerOptionConverter::toLevel($threshold, null);
-        }elseif (is_a($threshold, 'loggerlevel')) {
-           $this->threshold = $threshold;
-        }
-    }
+	/**
+	 * Set the threshold level of this appender.
+	 *
+	 * @param mixed $threshold can be a {@link LoggerLevel} object or a string.
+	 * @see LoggerOptionConverter::toLevel()
+	 */
+	public function setThreshold($threshold)
+	{
+		if (is_string($threshold)) {
+		   $this->threshold = LoggerOptionConverter::toLevel($threshold, null);
+		}elseif (is_a($threshold, 'loggerlevel')) {
+		   $this->threshold = $threshold;
+		}
+	}
     
-    /**
-     * Perform actions before object serialization.
-     *
-     * Call {@link finalize()} to properly close the appender.
-     */
-    public function __sleep()
-    {
-        $this->finalize();
-        return array_keys(get_object_vars($this)); 
-    }
+	/**
+	 * Perform actions before object serialization.
+	 *
+	 * Call {@link finalize()} to properly close the appender.
+	 */
+	public function __sleep()
+	{
+		$this->finalize();
+		return array_keys(get_object_vars($this)); 
+	}
     
-    /**
-     * Perform actions after object deserialization.
-     *
-     * Call {@link activateOptions()} to properly setup the appender.
-     */
-    public function __wakeup()
-    {
-        $this->activateOptions();
-    }
+	/**
+	 * Perform actions after object deserialization.
+	 *
+	 * Call {@link activateOptions()} to properly setup the appender.
+	 */
+	public function __wakeup()
+	{
+		$this->activateOptions();
+	}
     
 }
 ?>
\ No newline at end of file

Spacing +6 added lines, -6 removed lines

@@ -105,12 +105,12 @@ 
      */
     public function addFilter($newFilter)
     {
-        if($this->headFilter === null) {
+        if ($this->headFilter === null) {
             $this->headFilter = $newFilter;
-            $this->tailFilter =& $this->headFilter;
+            $this->tailFilter = & $this->headFilter;
         } else {
             $this->tailFilter->next = $newFilter;
-            $this->tailFilter =& $this->tailFilter->next;
+            $this->tailFilter = & $this->tailFilter->next;
         }
     }
     
@@ -254,14 +254,14 @@ 
             LoggerLog::debug("LoggerAppenderSkeleton::doAppend() Attempted to append to closed appender named [{$this->name}].");
             return;
         }
-        if(!$this->isAsSevereAsThreshold($event->getLevel())) {
+        if (!$this->isAsSevereAsThreshold($event->getLevel())) {
             LoggerLog::debug("LoggerAppenderSkeleton::doAppend() event level is less severe than threshold.");
             return;
         }
 
         $f = $this->getFirstFilter();
     
-        while($f !== null) {
+        while ($f !== null) {
             switch ($f->decide($event)) {
                 case LOG4PHP_LOGGER_FILTER_DENY: return;
                 case LOG4PHP_LOGGER_FILTER_ACCEPT: return $this->append($event);
@@ -287,7 +287,7 @@ 
      */
     public function setErrorHandler($errorHandler)
     {
-        if($errorHandler === null) {
+        if ($errorHandler === null) {
           // We do not throw exception here since the cause is probably a
           // bad config file.
             LoggerLog::warn("You have tried to set a null error-handler.");

libraries/log4php.debug/LoggerHierarchy.php

Indentation +289 added lines, -289 removed lines

@@ -52,196 +52,196 @@ 
  */
 class LoggerHierarchy {
 
-    /**
-     * @var object currently unused
-     */
-    public $defaultFactory;
+	/**
+	 * @var object currently unused
+	 */
+	public $defaultFactory;
     
-    /**
-     * @var boolean activate internal logging
-     * @see LoggerLog
-     */
-    public $debug = false;
+	/**
+	 * @var boolean activate internal logging
+	 * @see LoggerLog
+	 */
+	public $debug = false;
 
-    /**
-     * @var array hierarchy tree. saves here all loggers
-     */
-    public $ht = array();
+	/**
+	 * @var array hierarchy tree. saves here all loggers
+	 */
+	public $ht = array();
     
-    /**
-     * @var LoggerRoot
-     */
-    public $root = null;
+	/**
+	 * @var LoggerRoot
+	 */
+	public $root = null;
     
-    /**
-     * @var LoggerRendererMap
-     */
-    public $rendererMap;
+	/**
+	 * @var LoggerRendererMap
+	 */
+	public $rendererMap;
 
-    /**
-     * @var LoggerLevel main level threshold
-     */
-    public $threshold;
+	/**
+	 * @var LoggerLevel main level threshold
+	 */
+	public $threshold;
     
-    /**
-     * @var boolean currently unused
-     */
-    public $emittedNoAppenderWarning       = false;
+	/**
+	 * @var boolean currently unused
+	 */
+	public $emittedNoAppenderWarning       = false;
 
-    /**
-     * @var boolean currently unused
-     */
-    public $emittedNoResourceBundleWarning = false;
+	/**
+	 * @var boolean currently unused
+	 */
+	public $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

Braces +12 added lines, -7 removed lines

@@ -19,7 +19,9 @@ 
 /**
  * @ignore 
  */
-if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__)); 
+if (!defined('LOG4PHP_DIR')) {
+	define('LOG4PHP_DIR', dirname(__FILE__));
+}
 
 /**
  */
@@ -102,8 +104,9 @@ 
     {
         static $instance;
         
-        if (!isset($instance))
-            $instance = new LoggerHierarchy(new LoggerRoot());
+        if (!isset($instance)) {
+                    $instance = new LoggerHierarchy(new LoggerRoot());
+        }
         return $instance;
     }
     
@@ -266,8 +269,9 @@ 
      */ 
     public function &getRootLogger()
     {
-        if (!isset($this->root) || $this->root === null)
-            $this->root = new LoggerRoot();
+        if (!isset($this->root) || $this->root === null) {
+                    $this->root = new LoggerRoot();
+        }
         return $this->root;
     }
      
@@ -355,8 +359,9 @@ 
      */
     public function setThreshold($l)
     {
-        if ($l !== null)
-            $this->threshold = $l;
+        if ($l !== null) {
+                    $this->threshold = $l;
+        }
     }
     
     /**

libraries/log4php.debug/helpers/LoggerPatternConverter.php

Indentation +347 added lines, -347 removed lines

@@ -31,8 +31,8 @@ 
  * Used by {@link LoggerPatternConverter::spacePad()}.  
  */
 $GLOBALS['log4php.LoggerPatternConverter.spaces'] = array(" ", "  ", "    ", "        ", //1,2,4,8 spaces
-			    "                ", // 16 spaces
-			    "                                " ); // 32 spaces
+				"                ", // 16 spaces
+				"                                " ); // 32 spaces
 
 /**
  * LoggerPatternConverter is an abstract class that provides the formatting 
@@ -51,101 +51,101 @@ 
  */
 class LoggerPatternConverter {
 
-    /**
-     * @var LoggerPatternConverter next converter in converter chain
-     */
-    public $next = null;
+	/**
+	 * @var LoggerPatternConverter next converter in converter chain
+	 */
+	public $next = null;
     
-    public $min = -1;
-    public $max = 0x7FFFFFFF;
-    public $leftAlign = false;
-
-    /**
-     * Constructor 
-     *
-     * @param LoggerFormattingInfo $fi
-     */
-    public function LoggerPatternConverter($fi = null) 
-    {  
-        if ($fi !== null) {
-            $this->min = $fi->min;
-            $this->max = $fi->max;
-            $this->leftAlign = $fi->leftAlign;
-        }
-    }
+	public $min = -1;
+	public $max = 0x7FFFFFFF;
+	public $leftAlign = false;
+
+	/**
+	 * Constructor 
+	 *
+	 * @param LoggerFormattingInfo $fi
+	 */
+	public function LoggerPatternConverter($fi = null) 
+	{  
+		if ($fi !== null) {
+			$this->min = $fi->min;
+			$this->max = $fi->max;
+			$this->leftAlign = $fi->leftAlign;
+		}
+	}
   
-    /**
-     * Derived pattern converters must override this method in order to
-     * convert conversion specifiers in the correct way.
-     *
-     * @param LoggerLoggingEvent $event
-     */
-    public function convert($event) {}
-
-    /**
-     * A template method for formatting in a converter specific way.
-     *
-     * @param string &$sbuf string buffer
-     * @param LoggerLoggingEvent $e
-     */
-    public function format(&$sbuf, $e)
-    {
-        LoggerLog::debug("LoggerPatternConverter::format() sbuf='$sbuf'");    
+	/**
+	 * Derived pattern converters must override this method in order to
+	 * convert conversion specifiers in the correct way.
+	 *
+	 * @param LoggerLoggingEvent $event
+	 */
+	public function convert($event) {}
+
+	/**
+	 * A template method for formatting in a converter specific way.
+	 *
+	 * @param string &$sbuf string buffer
+	 * @param LoggerLoggingEvent $e
+	 */
+	public function format(&$sbuf, $e)
+	{
+		LoggerLog::debug("LoggerPatternConverter::format() sbuf='$sbuf'");    
     
-        $s = $this->convert($e);
+		$s = $this->convert($e);
         
-        LoggerLog::debug("LoggerPatternConverter::format() converted event is '$s'");    
+		LoggerLog::debug("LoggerPatternConverter::format() converted event is '$s'");    
         
     
-        if($s === null || empty($s)) {
-            if(0 < $this->min)
-                $this->spacePad($sbuf, $this->min);
-            return;
-        }
+		if($s === null || empty($s)) {
+			if(0 < $this->min)
+				$this->spacePad($sbuf, $this->min);
+			return;
+		}
         
-        $len = strlen($s);
+		$len = strlen($s);
     
-        if($len > $this->max) {
-            $sbuf .= substr($s , 0, ($len - $this->max));
-        } elseif($len < $this->min) {
-            if($this->leftAlign) {	
-                $sbuf .= $s;
-                $this->spacePad($sbuf, ($this->min - $len));
-            } else {
-                $this->spacePad($sbuf, ($this->min - $len));
-                $sbuf .= $s;
-            }
-        } else {
-            $sbuf .= $s;
-        }
-    }	
-
-
-    /**
-     * Fast space padding method.
-     *
-     * @param string    &$sbuf     string buffer
-     * @param integer   $length    pad length
-     *
-     * @todo reimplement using PHP string functions
-     */
-    public function spacePad(&$sbuf, $length)
-    {
-        LoggerLog::debug("LoggerPatternConverter::spacePad() sbuf='$sbuf' len='$length'");        
+		if($len > $this->max) {
+			$sbuf .= substr($s , 0, ($len - $this->max));
+		} elseif($len < $this->min) {
+			if($this->leftAlign) {	
+				$sbuf .= $s;
+				$this->spacePad($sbuf, ($this->min - $len));
+			} else {
+				$this->spacePad($sbuf, ($this->min - $len));
+				$sbuf .= $s;
+			}
+		} else {
+			$sbuf .= $s;
+		}
+	}	
+
+
+	/**
+	 * Fast space padding method.
+	 *
+	 * @param string    &$sbuf     string buffer
+	 * @param integer   $length    pad length
+	 *
+	 * @todo reimplement using PHP string functions
+	 */
+	public function spacePad(&$sbuf, $length)
+	{
+		LoggerLog::debug("LoggerPatternConverter::spacePad() sbuf='$sbuf' len='$length'");        
     
-        while($length >= 32) {
-          $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][5];
-          $length -= 32;
-        }
+		while($length >= 32) {
+		  $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][5];
+		  $length -= 32;
+		}
         
-        for($i = 4; $i >= 0; $i--) {	
-            if(($length & (1<<$i)) != 0) {
-    	        $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][$i];
-            }
-        }
-
-        // $sbuf = str_pad($sbuf, $length);
-    }
+		for($i = 4; $i >= 0; $i--) {	
+			if(($length & (1<<$i)) != 0) {
+				$sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][$i];
+			}
+		}
+
+		// $sbuf = str_pad($sbuf, $length);
+	}
 }
 
 // ---------------------------------------------------------------------
@@ -159,54 +159,54 @@ 
  */
 class LoggerBasicPatternConverter extends LoggerPatternConverter {
 
-    /**
-     * @var integer
-     */
-    public $type;
-
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param integer $type
-     */
-    public function LoggerBasicPatternConverter($formattingInfo, $type)
-    {
-      LoggerLog::debug("LoggerBasicPatternConverter::LoggerBasicPatternConverter() type='$type'");    
+	/**
+	 * @var integer
+	 */
+	public $type;
+
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param integer $type
+	 */
+	public function LoggerBasicPatternConverter($formattingInfo, $type)
+	{
+	  LoggerLog::debug("LoggerBasicPatternConverter::LoggerBasicPatternConverter() type='$type'");    
     
-      $this->LoggerPatternConverter($formattingInfo);
-      $this->type = $type;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-        switch($this->type) {
-            case LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER:
-                $timeStamp = $event->getTimeStamp();
-                $startTime = LoggerLoggingEvent::getStartTime();
-	            return (string)(int)($timeStamp * 1000 - $startTime * 1000);
+	  $this->LoggerPatternConverter($formattingInfo);
+	  $this->type = $type;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+		switch($this->type) {
+			case LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER:
+				$timeStamp = $event->getTimeStamp();
+				$startTime = LoggerLoggingEvent::getStartTime();
+				return (string)(int)($timeStamp * 1000 - $startTime * 1000);
                 
-            case LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER:
-	            return $event->getThreadName();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER:
+				return $event->getThreadName();
 
-            case LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER:
-                $level = $event->getLevel();
-	            return $level->toString();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER:
+				$level = $event->getLevel();
+				return $level->toString();
 
-            case LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER:
-	            return $event->getNDC();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER:
+				return $event->getNDC();
 
-            case LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER:
-	            return $event->getRenderedMessage();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER:
+				return $event->getRenderedMessage();
                 
-            default: 
-                return '';
-        }
-    }
+			default: 
+				return '';
+		}
+	}
 }
 
 /**
@@ -216,40 +216,40 @@ 
  */
 class LoggerLiteralPatternConverter extends LoggerPatternConverter {
     
-    /**
-     * @var string
-     */
-    public $literal;
-
-    /**
-     * Constructor
-     *
-     * @param string $value
-     */
-    public function LoggerLiteralPatternConverter($value)
-    {
-        LoggerLog::debug("LoggerLiteralPatternConverter::LoggerLiteralPatternConverter() value='$value'");    
+	/**
+	 * @var string
+	 */
+	public $literal;
+
+	/**
+	 * Constructor
+	 *
+	 * @param string $value
+	 */
+	public function LoggerLiteralPatternConverter($value)
+	{
+		LoggerLog::debug("LoggerLiteralPatternConverter::LoggerLiteralPatternConverter() value='$value'");    
     
-        $this->literal = $value;
-    }
-
-    /**
-     * @param string &$sbuf
-     * @param LoggerLoggingEvent $event
-     */
-    public function format(&$sbuf, $event)
-    {
-        $sbuf .= $this->literal;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-      return $this->literal;
-    }
+		$this->literal = $value;
+	}
+
+	/**
+	 * @param string &$sbuf
+	 * @param LoggerLoggingEvent $event
+	 */
+	public function format(&$sbuf, $event)
+	{
+		$sbuf .= $this->literal;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+	  return $this->literal;
+	}
 }
 
 /**
@@ -259,38 +259,38 @@ 
  */
 class LoggerDatePatternConverter extends LoggerPatternConverter {
 
-    /**
-     * @var string
-     */
-    public $df;
+	/**
+	 * @var string
+	 */
+	public $df;
     
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param string $df
-     */
-    public function LoggerDatePatternConverter($formattingInfo, $df)
-    {
-        LoggerLog::debug("LoggerDatePatternConverter::LoggerDatePatternConverter() dateFormat='$df'");    
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param string $df
+	 */
+	public function LoggerDatePatternConverter($formattingInfo, $df)
+	{
+		LoggerLog::debug("LoggerDatePatternConverter::LoggerDatePatternConverter() dateFormat='$df'");    
     
-        $this->LoggerPatternConverter($formattingInfo);
-        $this->df = $df;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-        $timeStamp = $event->getTimeStamp();
-        $usecs = round(($timeStamp - (int)$timeStamp) * 1000);
-        $this->df = str_replace("\u", "u", ereg_replace("[^\\]u", sprintf(',%03d', $usecs), $this->df));
+		$this->LoggerPatternConverter($formattingInfo);
+		$this->df = $df;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+		$timeStamp = $event->getTimeStamp();
+		$usecs = round(($timeStamp - (int)$timeStamp) * 1000);
+		$this->df = str_replace("\u", "u", ereg_replace("[^\\]u", sprintf(',%03d', $usecs), $this->df));
          
-        return date($this->df, $event->getTimeStamp());
+		return date($this->df, $event->getTimeStamp());
         
-    }
+	}
 }
 
 /**
@@ -300,33 +300,33 @@ 
  */
 class LoggerMDCPatternConverter extends LoggerPatternConverter {
 
-    /**
-     * @var string
-     */
-    public $key;
-
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param string $key
-     */
-    public function LoggerMDCPatternConverter($formattingInfo, $key)
-    {
-      LoggerLog::debug("LoggerMDCPatternConverter::LoggerMDCPatternConverter() key='$key'");    
-
-      $this->LoggerPatternConverter($formattingInfo);
-      $this->key = $key;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-        return $event->getMDC($this->key);
-    }
+	/**
+	 * @var string
+	 */
+	public $key;
+
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param string $key
+	 */
+	public function LoggerMDCPatternConverter($formattingInfo, $key)
+	{
+	  LoggerLog::debug("LoggerMDCPatternConverter::LoggerMDCPatternConverter() key='$key'");    
+
+	  $this->LoggerPatternConverter($formattingInfo);
+	  $this->key = $key;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+		return $event->getMDC($this->key);
+	}
 }
 
 /**
@@ -336,45 +336,45 @@ 
  */
 class LoggerLocationPatternConverter extends LoggerPatternConverter {
     
-    /**
-     * @var integer
-     */
-    public $type;
-
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param integer $type
-     */
-    public function LoggerLocationPatternConverter($formattingInfo, $type)
-    {
-      LoggerLog::debug("LoggerLocationPatternConverter::LoggerLocationPatternConverter() type='$type'");    
+	/**
+	 * @var integer
+	 */
+	public $type;
+
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param integer $type
+	 */
+	public function LoggerLocationPatternConverter($formattingInfo, $type)
+	{
+	  LoggerLog::debug("LoggerLocationPatternConverter::LoggerLocationPatternConverter() type='$type'");    
     
-      $this->LoggerPatternConverter($formattingInfo);
-      $this->type = $type;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-        $locationInfo = $event->getLocationInformation();
-        switch($this->type) {
-            case LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER:
-	            return $locationInfo->fullInfo;
-            case LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER:
-	            return $locationInfo->getMethodName();
-            case LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER:
-	            return $locationInfo->getLineNumber();
-            case LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER:
-	            return $locationInfo->getFileName();
-            default: 
-                return '';
-        }
-    }
+	  $this->LoggerPatternConverter($formattingInfo);
+	  $this->type = $type;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+		$locationInfo = $event->getLocationInformation();
+		switch($this->type) {
+			case LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER:
+				return $locationInfo->fullInfo;
+			case LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER:
+				return $locationInfo->getMethodName();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER:
+				return $locationInfo->getLineNumber();
+			case LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER:
+				return $locationInfo->getFileName();
+			default: 
+				return '';
+		}
+	}
 }
 
 /**
@@ -385,60 +385,60 @@ 
  */
 class LoggerNamedPatternConverter extends LoggerPatternConverter {
 
-    /**
-     * @var integer
-     */
-    public $precision;
-
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param integer $precision
-     */
-    public function LoggerNamedPatternConverter($formattingInfo, $precision)
-    {
-      LoggerLog::debug("LoggerNamedPatternConverter::LoggerNamedPatternConverter() precision='$precision'");    
+	/**
+	 * @var integer
+	 */
+	public $precision;
+
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param integer $precision
+	 */
+	public function LoggerNamedPatternConverter($formattingInfo, $precision)
+	{
+	  LoggerLog::debug("LoggerNamedPatternConverter::LoggerNamedPatternConverter() precision='$precision'");    
     
-      $this->LoggerPatternConverter($formattingInfo);
-      $this->precision =  $precision;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     * @abstract
-     */
-    public function getFullyQualifiedName($event)
-    { 
-        // abstract
-        return;
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function convert($event)
-    {
-        $n = $this->getFullyQualifiedName($event);
-        if ($this->precision <= 0) {
-	        return $n;
-        } else {
-	        $len = strlen($n);
+	  $this->LoggerPatternConverter($formattingInfo);
+	  $this->precision =  $precision;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 * @abstract
+	 */
+	public function getFullyQualifiedName($event)
+	{ 
+		// abstract
+		return;
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function convert($event)
+	{
+		$n = $this->getFullyQualifiedName($event);
+		if ($this->precision <= 0) {
+			return $n;
+		} else {
+			$len = strlen($n);
             
-        	// We substract 1 from 'len' when assigning to 'end' to avoid out of
-        	// bounds exception in return r.substring(end+1, len). This can happen if
-        	// precision is 1 and the category name ends with a dot.
-        	$end = $len -1 ;
-        	for($i = $this->precision; $i > 0; $i--) {
-        	    $end = strrpos(substr($n, 0, ($end - 1)), '.');
-        	    if ($end === false)
-        	        return $n;
-        	}
-        	return substr($n, ($end + 1), $len);
-        }
-    }
+			// We substract 1 from 'len' when assigning to 'end' to avoid out of
+			// bounds exception in return r.substring(end+1, len). This can happen if
+			// precision is 1 and the category name ends with a dot.
+			$end = $len -1 ;
+			for($i = $this->precision; $i > 0; $i--) {
+				$end = strrpos(substr($n, 0, ($end - 1)), '.');
+				if ($end === false)
+					return $n;
+			}
+			return substr($n, ($end + 1), $len);
+		}
+	}
 }
 
 /**
@@ -448,27 +448,27 @@ 
  */
 class LoggerClassNamePatternConverter extends LoggerNamedPatternConverter {
 
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param integer $precision
-     */
-    public function LoggerClassNamePatternConverter($formattingInfo, $precision)
-    {
-        LoggerLog::debug("LoggerClassNamePatternConverter::LoggerClassNamePatternConverter() precision='$precision'");    
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param integer $precision
+	 */
+	public function LoggerClassNamePatternConverter($formattingInfo, $precision)
+	{
+		LoggerLog::debug("LoggerClassNamePatternConverter::LoggerClassNamePatternConverter() precision='$precision'");    
     
-        $this->LoggerNamedPatternConverter($formattingInfo, $precision);
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function getFullyQualifiedName($event)
-    {
-        return $event->fqcn;
-    }
+		$this->LoggerNamedPatternConverter($formattingInfo, $precision);
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function getFullyQualifiedName($event)
+	{
+		return $event->fqcn;
+	}
 }
 
 /**
@@ -478,27 +478,27 @@ 
  */
 class LoggerCategoryPatternConverter extends LoggerNamedPatternConverter {
 
-    /**
-     * Constructor
-     *
-     * @param string $formattingInfo
-     * @param integer $precision
-     */
-    public function LoggerCategoryPatternConverter($formattingInfo, $precision)
-    {
-        LoggerLog::debug("LoggerCategoryPatternConverter::LoggerCategoryPatternConverter() precision='$precision'");    
+	/**
+	 * Constructor
+	 *
+	 * @param string $formattingInfo
+	 * @param integer $precision
+	 */
+	public function LoggerCategoryPatternConverter($formattingInfo, $precision)
+	{
+		LoggerLog::debug("LoggerCategoryPatternConverter::LoggerCategoryPatternConverter() precision='$precision'");    
     
-        $this->LoggerNamedPatternConverter($formattingInfo, $precision);
-    }
-
-    /**
-     * @param LoggerLoggingEvent $event
-     * @return string
-     */
-    public function getFullyQualifiedName($event)
-    {
-      return $event->getLoggerName();
-    }
+		$this->LoggerNamedPatternConverter($formattingInfo, $precision);
+	}
+
+	/**
+	 * @param LoggerLoggingEvent $event
+	 * @return string
+	 */
+	public function getFullyQualifiedName($event)
+	{
+	  return $event->getLoggerName();
+	}
 }
 
 ?>
\ No newline at end of file

Spacing +17 added lines, -17 removed lines

@@ -32,7 +32,7 @@ 
  */
 $GLOBALS['log4php.LoggerPatternConverter.spaces'] = array(" ", "  ", "    ", "        ", //1,2,4,8 spaces
 			    "                ", // 16 spaces
-			    "                                " ); // 32 spaces
+			    "                                "); // 32 spaces
 
 /**
  * LoggerPatternConverter is an abstract class that provides the formatting 
@@ -97,18 +97,18 @@ 
         LoggerLog::debug("LoggerPatternConverter::format() converted event is '$s'");    
         
     
-        if($s === null || empty($s)) {
-            if(0 < $this->min)
+        if ($s === null || empty($s)) {
+            if (0 < $this->min)
                 $this->spacePad($sbuf, $this->min);
             return;
         }
         
         $len = strlen($s);
     
-        if($len > $this->max) {
-            $sbuf .= substr($s , 0, ($len - $this->max));
-        } elseif($len < $this->min) {
-            if($this->leftAlign) {	
+        if ($len > $this->max) {
+            $sbuf .= substr($s, 0, ($len - $this->max));
+        } elseif ($len < $this->min) {
+            if ($this->leftAlign) {	
                 $sbuf .= $s;
                 $this->spacePad($sbuf, ($this->min - $len));
             } else {
@@ -133,13 +133,13 @@ 
     {
         LoggerLog::debug("LoggerPatternConverter::spacePad() sbuf='$sbuf' len='$length'");        
     
-        while($length >= 32) {
+        while ($length >= 32) {
           $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][5];
           $length -= 32;
         }
         
-        for($i = 4; $i >= 0; $i--) {	
-            if(($length & (1<<$i)) != 0) {
+        for ($i = 4; $i >= 0; $i--) {	
+            if (($length & (1 << $i)) != 0) {
     	        $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][$i];
             }
         }
@@ -184,11 +184,11 @@ 
      */
     public function convert($event)
     {
-        switch($this->type) {
+        switch ($this->type) {
             case LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER:
                 $timeStamp = $event->getTimeStamp();
                 $startTime = LoggerLoggingEvent::getStartTime();
-	            return (string)(int)($timeStamp * 1000 - $startTime * 1000);
+	            return (string) (int) ($timeStamp * 1000 - $startTime * 1000);
                 
             case LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER:
 	            return $event->getThreadName();
@@ -285,7 +285,7 @@ 
     public function convert($event)
     {
         $timeStamp = $event->getTimeStamp();
-        $usecs = round(($timeStamp - (int)$timeStamp) * 1000);
+        $usecs = round(($timeStamp - (int) $timeStamp) * 1000);
         $this->df = str_replace("\u", "u", ereg_replace("[^\\]u", sprintf(',%03d', $usecs), $this->df));
          
         return date($this->df, $event->getTimeStamp());
@@ -362,7 +362,7 @@ 
     public function convert($event)
     {
         $locationInfo = $event->getLocationInformation();
-        switch($this->type) {
+        switch ($this->type) {
             case LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER:
 	            return $locationInfo->fullInfo;
             case LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER:
@@ -401,7 +401,7 @@ 
       LoggerLog::debug("LoggerNamedPatternConverter::LoggerNamedPatternConverter() precision='$precision'");    
     
       $this->LoggerPatternConverter($formattingInfo);
-      $this->precision =  $precision;
+      $this->precision = $precision;
     }
 
     /**
@@ -430,8 +430,8 @@ 
         	// We substract 1 from 'len' when assigning to 'end' to avoid out of
         	// bounds exception in return r.substring(end+1, len). This can happen if
         	// precision is 1 and the category name ends with a dot.
-        	$end = $len -1 ;
-        	for($i = $this->precision; $i > 0; $i--) {
+        	$end = $len - 1;
+        	for ($i = $this->precision; $i > 0; $i--) {
         	    $end = strrpos(substr($n, 0, ($end - 1)), '.');
         	    if ($end === false)
         	        return $n;

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

Spacing +22 added lines, -22 removed lines

@@ -24,10 +24,10 @@ 
 
 require_once(LOG4PHP_DIR . '/LoggerLevel.php');
 
-define('LOG4PHP_OPTION_CONVERTER_DELIM_START',      '${');
-define('LOG4PHP_OPTION_CONVERTER_DELIM_STOP',       '}');
-define('LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN',  2);
-define('LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN',   1);
+define('LOG4PHP_OPTION_CONVERTER_DELIM_START', '${');
+define('LOG4PHP_OPTION_CONVERTER_DELIM_STOP', '}');
+define('LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN', 2);
+define('LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN', 1);
 
 /**
  * A convenience class to convert property values to specific types.
@@ -81,9 +81,9 @@ 
         LoggerLog::debug("LoggerOptionConverter::getSystemProperty():key=[{$key}]:def=[{$def}].");
 
         if (defined($key)) {
-            return (string)constant($key);
+            return (string) constant($key);
         } elseif (isset($_ENV[$key])) {
-            return (string)$_ENV[$key];
+            return (string) $_ENV[$key];
         } else {
             return $def;
         }
@@ -105,7 +105,7 @@ 
      */
     public function toBoolean($value, $default)
     {
-        if($value === null)
+        if ($value === null)
             return $default;
         if ($value == 1)
             return true;
@@ -127,7 +127,7 @@ 
     {
         $value = trim($value);
         if (is_numeric($value)) {
-            return (int)$value;
+            return (int) $value;
         } else {
             return $default;
         }
@@ -162,12 +162,12 @@ 
      */
     public function toLevel($value, $defaultValue)
     {
-        if($value === null)
+        if ($value === null)
             return $defaultValue;
 
         $hashIndex = strpos($value, '#');
         if ($hashIndex === false) {
-            if("NULL" == strtoupper($value)) {
+            if ("NULL" == strtoupper($value)) {
 	            return null;
             } else {
 	            // no class name specified : use standard Level class
@@ -181,7 +181,7 @@ 
         $levelName = substr($value, 0, $hashIndex);
 
         // This is degenerate case but you never know.
-        if("NULL" == strtoupper($levelName)) {
+        if ("NULL" == strtoupper($levelName)) {
         	return null;
         }
 
@@ -217,19 +217,19 @@ 
             return $default;
 
         $s = strtoupper(trim($value));
-        $multiplier = (float)1;
-        if(($index = strpos($s, 'KB')) !== false) {
+        $multiplier = (float) 1;
+        if (($index = strpos($s, 'KB')) !== false) {
             $multiplier = 1024;
             $s = substr($s, 0, $index);
-        } elseif(($index = strpos($s, 'MB')) !== false) {
+        } elseif (($index = strpos($s, 'MB')) !== false) {
             $multiplier = 1024 * 1024;
             $s = substr($s, 0, $index);
-        } elseif(($index = strpos($s, 'GB')) !== false) {
+        } elseif (($index = strpos($s, 'GB')) !== false) {
             $multiplier = 1024 * 1024 * 1024;
             $s = substr($s, 0, $index);
         }
-        if(is_numeric($s)) {
-            return (float)$s * $multiplier;
+        if (is_numeric($s)) {
+            return (float) $s * $multiplier;
         } else {
             LoggerLog::warn("LoggerOptionConverter::toFileSize() [{$s}] is not in proper form.");
         }
@@ -250,7 +250,7 @@ 
     public function findAndSubst($key, $props)
     {
         $value = @$props[$key];
-        if(empty($value)) {
+        if (empty($value)) {
             return null;
         }
         return LoggerOptionConverter::substVars($value, $props);
@@ -297,7 +297,7 @@ 
         
         $sbuf = '';
         $i = 0;
-        while(true) {
+        while (true) {
             $j = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_START, $i);
             if ($j === false) {
                 LoggerLog::debug("LoggerOptionConverter::substVars() no more variables");
@@ -312,7 +312,7 @@ 
 	            }
             } else {
             
-	            $sbuf .= substr($val, $i, $j-$i);
+	            $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) {
@@ -327,11 +327,11 @@ 
                     // first try in System properties
 	                $replacement = LoggerOptionConverter::getSystemProperty($key, null);
 	                // then try props parameter
-	                if($replacement === null && $props !== null) {
+	                if ($replacement === null && $props !== null) {
             	        $replacement = @$props[$key];
 	                }
 
-                    if(!empty($replacement)) {
+                    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

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 {
 
-    public $state;
-    public $currentLiteral;
-    public $patternLength;
-    public $i;
+	public $state;
+	public $currentLiteral;
+	public $patternLength;
+	public $i;
     
-    /**
-     * @var LoggerPatternConverter
-     */
-    public $head = null;
+	/**
+	 * @var LoggerPatternConverter
+	 */
+	public $head = null;
      
-    /**
-     * @var LoggerPatternConverter
-     */
-    public $tail = null;
+	/**
+	 * @var LoggerPatternConverter
+	 */
+	public $tail = null;
     
-    /**
-     * @var LoggerFormattingInfo
-     */
-    public $formattingInfo;
+	/**
+	 * @var LoggerFormattingInfo
+	 */
+	public $formattingInfo;
     
-    /**
-     * @var string pattern to parse
-     */
-    public $pattern;
+	/**
+	 * @var string pattern to parse
+	 */
+	public $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

Spacing +47 added lines, -47 removed lines

@@ -42,30 +42,30 @@ 
 require_once(LOG4PHP_DIR . '/helpers/LoggerPatternConverter.php');
 require_once(LOG4PHP_DIR . '/LoggerLog.php');
 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR',         '%');
+define('LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR', '%');
 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE',       0);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE',     1);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_MINUS_STATE',         2);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE',           3);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE',           4);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE',           5);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE', 0);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE', 1);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_MINUS_STATE', 2);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE', 3);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_MIN_STATE', 4);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_MAX_STATE', 5);
 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER',         1000);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER',       1001);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_CLASS_LOCATION_CONVERTER',        1002);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER',         1003);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER',         1004);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER', 1000);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER', 1001);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_CLASS_LOCATION_CONVERTER', 1002);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER', 1003);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER', 1004);
 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER',         2000);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER',                2001);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER',                 2002);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER',                   2003);
-define('LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER',               2004);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER', 2000);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER', 2001);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER', 2002);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER', 2003);
+define('LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER', 2004);
 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601',    'Y-m-d H:i:s,u'); 
-define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE',   'H:i:s');
-define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE',       'd M Y H:i:s,u');
+define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601', 'Y-m-d H:i:s,u'); 
+define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE', 'H:i:s');
+define('LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE', 'd M Y H:i:s,u');
 
 /**
  * Most of the work of the {@link LoggerPatternLayout} class 
@@ -118,7 +118,7 @@ 
         LoggerLog::debug("LoggerPatternParser::LoggerPatternParser() pattern='$pattern'");
     
         $this->pattern = $pattern;
-        $this->patternLength =  strlen($pattern);
+        $this->patternLength = strlen($pattern);
         $this->formattingInfo = new LoggerFormattingInfo();
         $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_LITERAL_STATE;
     }
@@ -130,12 +130,12 @@ 
     {
         // LoggerLog::debug("LoggerPatternParser::addToList()");
     
-        if($this->head === null) {
+        if ($this->head === null) {
             $this->head = $pc;
-            $this->tail =& $this->head;
+            $this->tail = & $this->head;
         } else {
             $this->tail->next = $pc;
-            $this->tail =& $this->tail->next;
+            $this->tail = & $this->tail->next;
         }
     }
 
@@ -144,11 +144,11 @@ 
      */
     public function extractOption()
     {
-        if(($this->i < $this->patternLength) && ($this->pattern{$this->i} == '{')) {
-            $end = strpos($this->pattern, '}' , $this->i);
+        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;
+	            $this->i = $end + 1;
         	    return $r;
             }
         }
@@ -165,8 +165,8 @@ 
         $r = 0;
         if ($opt !== null) {
             if (is_numeric($opt)) {
-    	        $r = (int)$opt;
-            	if($r <= 0) {
+    	        $r = (int) $opt;
+            	if ($r <= 0) {
             	    LoggerLog::warn("Precision option ({$opt}) isn't a positive integer.");
             	    $r = 0;
             	}
@@ -187,18 +187,18 @@ 
         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) {
+            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) {
+                    if ($this->i == $this->patternLength) {
                         $this->currentLiteral .= $c;
                         continue;
                     }
-                    if($c == LOG4PHP_LOGGER_PATTERN_PARSER_ESCAPE_CHAR) {
+                    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}) {
+                        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;
@@ -210,7 +210,7 @@ 
                                 $this->i++; // move pointer
                                 break;
                             default:
-                                if(strlen($this->currentLiteral) != 0) {
+                                if (strlen($this->currentLiteral) != 0) {
                                     $this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
                                     LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
                                 }
@@ -225,7 +225,7 @@ 
               case LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE:
                     // LoggerLog::debug("LoggerPatternParser::parse() state is 'LOG4PHP_LOGGER_PATTERN_PARSER_CONVERTER_STATE'");              
                 	$this->currentLiteral .= $c;
-                	switch($c) {
+                	switch ($c) {
                     	case '-':
                             $this->formattingInfo->leftAlign = true;
                             break;
@@ -233,7 +233,7 @@ 
                             $this->state = LOG4PHP_LOGGER_PATTERN_PARSER_DOT_STATE;
 	                        break;
                     	default:
-                            if(ord($c) >= ord('0') && ord($c) <= ord('9')) {
+                            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 {
@@ -244,7 +244,7 @@ 
               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')) {
+                    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;
@@ -255,7 +255,7 @@ 
               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')) {
+                    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 {
@@ -266,7 +266,7 @@ 
               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')) {
+                    if (ord($c) >= ord('0') && ord($c) <= ord('9')) {
                         $this->formattingInfo->max = ($this->formattingInfo->max * 10) + (ord($c) - ord('0'));
 	                } else {
                 	  $this->finalizeConverter($c);
@@ -275,7 +275,7 @@ 
                 	break;
             } // switch
         } // while
-        if(strlen($this->currentLiteral) != 0) {
+        if (strlen($this->currentLiteral) != 0) {
             $this->addToList(new LoggerLiteralPatternConverter($this->currentLiteral));
             // LoggerLog::debug("LoggerPatternParser::parse() Parsed LITERAL converter: \"{$this->currentLiteral}\".");
         }
@@ -287,7 +287,7 @@ 
         LoggerLog::debug("LoggerPatternParser::finalizeConverter() with char '$c'");    
 
         $pc = null;
-        switch($c) {
+        switch ($c) {
             case 'c':
                 $pc = new LoggerCategoryPatternConverter($this->formattingInfo, $this->extractPrecisionOption());
                 LoggerLog::debug("LoggerPatternParser::finalizeConverter() CATEGORY converter.");
@@ -302,14 +302,14 @@ 
                 $dateFormatStr = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601; // ISO8601_DATE_FORMAT;
                 $dOpt = $this->extractOption();
 
-                if($dOpt !== null)
+                if ($dOpt !== null)
 	                $dateFormatStr = $dOpt;
                     
                 if ($dateFormatStr == 'ISO8601') {
                     $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
-                } elseif($dateFormatStr == 'ABSOLUTE') {
+                } elseif ($dateFormatStr == 'ABSOLUTE') {
                     $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE;
-                } elseif($dateFormatStr == 'DATE') {
+                } elseif ($dateFormatStr == 'DATE') {
                     $df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE;
                 } else {
                     $df = $dateFormatStr;
@@ -369,10 +369,10 @@ 
                 $this->currentLiteral = '';
                 break;
             case 'u':
-                if($this->i < $this->patternLength) {
+                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')));
+                    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 = '';

libraries/log4php.debug/LoggerRoot.php

Indentation +54 added lines, -54 removed lines

@@ -36,66 +36,66 @@
  */
 class LoggerRoot extends Logger {
 
-    /**
-     * @var string name of logger 
-     */
-    public $name   = 'root';
+	/**
+	 * @var string name of logger 
+	 */
+	public $name   = 'root';
 
-    /**
-     * @var object must be null for LoggerRoot
-     */
-    public $parent = null;
+	/**
+	 * @var object must be null for LoggerRoot
+	 */
+	public $parent = null;
     
 
-    /**
-     * Constructor
-     *
-     * @param integer $level initial log level
-     */
-    public function LoggerRoot($level = null)
-    {
-        $this->Logger($this->name);
-        if ($level === null)
-            $level = LoggerLevel::getLevelAll();
-        $this->setLevel($level);
-    } 
+	/**
+	 * Constructor
+	 *
+	 * @param integer $level initial log level
+	 */
+	public function LoggerRoot($level = null)
+	{
+		$this->Logger($this->name);
+		if ($level === null)
+			$level = LoggerLevel::getLevelAll();
+		$this->setLevel($level);
+	} 
     
-    /**
-     * @return integer the level
-     */
-    public function getChainedLevel()
-    {
-        return $this->level;
-    } 
+	/**
+	 * @return integer the level
+	 */
+	public function getChainedLevel()
+	{
+		return $this->level;
+	} 
     
-    /**
-     * Setting a null value to the level of the root category may have catastrophic results.
-     * @param LoggerLevel $level
-     */
-    public function setLevel($level)
-    {
-        $this->level = $level;
-    }    
+	/**
+	 * Setting a null value to the level of the root category may have catastrophic results.
+	 * @param LoggerLevel $level
+	 */
+	public function setLevel($level)
+	{
+		$this->level = $level;
+	}    
  
-    /**
-     * Please use setLevel() instead.
-     * @param LoggerLevel $level
-     * @deprecated
-     */
-    public function setPriority($level)
-    {
-        $this->setLevel($level); 
-    }
+	/**
+	 * Please use setLevel() instead.
+	 * @param LoggerLevel $level
+	 * @deprecated
+	 */
+	public function setPriority($level)
+	{
+		$this->setLevel($level); 
+	}
     
-    /**
-     * Always returns false.
-     * Because LoggerRoot has no parents, it returns false.
-     * @param Logger $parent
-     * @return boolean
-     */
-    public function setParent($parent)
-    {
-        return false;
-    }  
+	/**
+	 * Always returns false.
+	 * Because LoggerRoot has no parents, it returns false.
+	 * @param Logger $parent
+	 * @return boolean
+	 */
+	public function setParent($parent)
+	{
+		return false;
+	}  
 }
 ?>
\ No newline at end of file

Braces +6 added lines, -3 removed lines

@@ -19,7 +19,9 @@ 
 /**
  * @ignore 
  */
-if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__));
+if (!defined('LOG4PHP_DIR')) {
+	define('LOG4PHP_DIR', dirname(__FILE__));
+}
  
 /**
  */
@@ -55,8 +57,9 @@ 
     public function LoggerRoot($level = null)
     {
         $this->Logger($this->name);
-        if ($level === null)
-            $level = LoggerLevel::getLevelAll();
+        if ($level === null) {
+                    $level = LoggerLevel::getLevelAll();
+        }
         $this->setLevel($level);
     } 
     

libraries/log4php.debug/or/LoggerRendererMap.php

Indentation +128 added lines, -128 removed lines

@@ -39,146 +39,146 @@
  */
 class LoggerRendererMap {
 
-    /**
-     * @var array
-     */
-    public $map;
+	/**
+	 * @var array
+	 */
+	public $map;
 
-    /**
-     * @var LoggerDefaultRenderer
-     */
-    public $defaultRenderer;
+	/**
+	 * @var LoggerDefaultRenderer
+	 */
+	public $defaultRenderer;
 
-    /**
-     * Constructor
-     */
-    public function LoggerRendererMap()
-    {
-        $this->map = array();
-        $this->defaultRenderer = new LoggerDefaultRenderer();
-    }
+	/**
+	 * Constructor
+	 */
+	public function LoggerRendererMap()
+	{
+		$this->map = array();
+		$this->defaultRenderer = new LoggerDefaultRenderer();
+	}
 
-    /**
-     * Add a renderer to a hierarchy passed as parameter.
-     * Note that hierarchy must implement getRendererMap() and setRenderer() methods.
-     *
-     * @param LoggerHierarchy &$repository a logger repository.
-     * @param string &$renderedClassName
-     * @param string &$renderingClassName
-     * @static
-     */
-    public function addRenderer(&$repository, $renderedClassName, $renderingClassName)
-    {
-        LoggerLog::debug("LoggerRendererMap::addRenderer() Rendering class: [{$renderingClassName}], Rendered class: [{$renderedClassName}].");
-        $renderer = LoggerObjectRenderer::factory($renderingClassName);
-        if($renderer === null) {
-            LoggerLog::warn("LoggerRendererMap::addRenderer() Could not instantiate renderer [{$renderingClassName}].");
-            return;
-        } else {
-            $repository->setRenderer($renderedClassName, $renderer);
-        }
-    }
+	/**
+	 * Add a renderer to a hierarchy passed as parameter.
+	 * Note that hierarchy must implement getRendererMap() and setRenderer() methods.
+	 *
+	 * @param LoggerHierarchy &$repository a logger repository.
+	 * @param string &$renderedClassName
+	 * @param string &$renderingClassName
+	 * @static
+	 */
+	public function addRenderer(&$repository, $renderedClassName, $renderingClassName)
+	{
+		LoggerLog::debug("LoggerRendererMap::addRenderer() Rendering class: [{$renderingClassName}], Rendered class: [{$renderedClassName}].");
+		$renderer = LoggerObjectRenderer::factory($renderingClassName);
+		if($renderer === null) {
+			LoggerLog::warn("LoggerRendererMap::addRenderer() Could not instantiate renderer [{$renderingClassName}].");
+			return;
+		} else {
+			$repository->setRenderer($renderedClassName, $renderer);
+		}
+	}
 
 
-    /**
-     * Find the appropriate renderer for the class type of the
-     * <var>o</var> parameter. 
-     *
-     * This is accomplished by calling the {@link getByObject()} 
-     * method if <var>o</var> is object or using {@link LoggerDefaultRenderer}. 
-     * Once a renderer is found, it is applied on the object <var>o</var> and 
-     * the result is returned as a string.
-     *
-     * @param mixed $o
-     * @return string 
-     */
-    public function findAndRender($o)
-    {
-        if($o === null) {
-            return null;
-        } else {
-            if (is_object($o)) {
-                $renderer = $this->getByObject($o);
-                if ($renderer !== null) {
-                    return $renderer->doRender($o);
-                } else {
-                    return null;
-                }
-            } else {
-                $renderer = $this->defaultRenderer;
-                return $renderer->doRender($o);
-            }
-        }
-    }
+	/**
+	 * Find the appropriate renderer for the class type of the
+	 * <var>o</var> parameter. 
+	 *
+	 * This is accomplished by calling the {@link getByObject()} 
+	 * method if <var>o</var> is object or using {@link LoggerDefaultRenderer}. 
+	 * Once a renderer is found, it is applied on the object <var>o</var> and 
+	 * the result is returned as a string.
+	 *
+	 * @param mixed $o
+	 * @return string 
+	 */
+	public function findAndRender($o)
+	{
+		if($o === null) {
+			return null;
+		} else {
+			if (is_object($o)) {
+				$renderer = $this->getByObject($o);
+				if ($renderer !== null) {
+					return $renderer->doRender($o);
+				} else {
+					return null;
+				}
+			} else {
+				$renderer = $this->defaultRenderer;
+				return $renderer->doRender($o);
+			}
+		}
+	}
 
-    /**
-     * Syntactic sugar method that calls {@link PHP_MANUAL#get_class} with the
-     * class of the object parameter.
-     * 
-     * @param mixed $o
-     * @return string
-     */
-    public function &getByObject($o)
-    {
-        return ($o === null) ? null : $this->getByClassName(get_class($o));
-    }
+	/**
+	 * Syntactic sugar method that calls {@link PHP_MANUAL#get_class} with the
+	 * class of the object parameter.
+	 * 
+	 * @param mixed $o
+	 * @return string
+	 */
+	public function &getByObject($o)
+	{
+		return ($o === null) ? null : $this->getByClassName(get_class($o));
+	}
 
 
-    /**
-     * Search the parents of <var>clazz</var> for a renderer. 
-     *
-     * The renderer closest in the hierarchy will be returned. If no
-     * renderers could be found, then the default renderer is returned.
-     *
-     * @param string $class
-     * @return LoggerObjectRenderer
-     */
-    public function &getByClassName($class)
-    {
-        $r = null;
-        for($c = strtolower($class); !empty($c); $c = get_parent_class($c)) {
-            if (isset($this->map[$c])) {
-                return  $this->map[$c];
-            }
-        }
-        return $this->defaultRenderer;
-    }
+	/**
+	 * Search the parents of <var>clazz</var> for a renderer. 
+	 *
+	 * The renderer closest in the hierarchy will be returned. If no
+	 * renderers could be found, then the default renderer is returned.
+	 *
+	 * @param string $class
+	 * @return LoggerObjectRenderer
+	 */
+	public function &getByClassName($class)
+	{
+		$r = null;
+		for($c = strtolower($class); !empty($c); $c = get_parent_class($c)) {
+			if (isset($this->map[$c])) {
+				return  $this->map[$c];
+			}
+		}
+		return $this->defaultRenderer;
+	}
 
-    /**
-     * @return LoggerDefaultRenderer
-     */
-    public function &getDefaultRenderer()
-    {
-        return $this->defaultRenderer;
-    }
+	/**
+	 * @return LoggerDefaultRenderer
+	 */
+	public function &getDefaultRenderer()
+	{
+		return $this->defaultRenderer;
+	}
 
 
-    public function clear()
-    {
-        $this->map = array();
-    }
+	public function clear()
+	{
+		$this->map = array();
+	}
 
-    /**
-     * Register a {@link LoggerObjectRenderer} for <var>clazz</var>.
-     * @param string $class
-     * @param LoggerObjectRenderer $or
-     */
-    public function put($class, $or)
-    {
-        $this->map[strtolower($class)] = $or;
-    }
+	/**
+	 * Register a {@link LoggerObjectRenderer} for <var>clazz</var>.
+	 * @param string $class
+	 * @param LoggerObjectRenderer $or
+	 */
+	public function put($class, $or)
+	{
+		$this->map[strtolower($class)] = $or;
+	}
     
-    /**
-     * @param string $class
-     * @return boolean
-     */
-    public function rendererExists($class)
-    {
-        $class = basename($class);
-        if (!class_exists($class)) {
-            @include_once(LOG4PHP_DIR ."/or/{$class}.php");
-        }
-        return class_exists($class);
-    }
+	/**
+	 * @param string $class
+	 * @return boolean
+	 */
+	public function rendererExists($class)
+	{
+		$class = basename($class);
+		if (!class_exists($class)) {
+			@include_once(LOG4PHP_DIR ."/or/{$class}.php");
+		}
+		return class_exists($class);
+	}
 }
 ?>
\ No newline at end of file

Spacing +4 added lines, -4 removed lines

@@ -71,7 +71,7 @@ 
     {
         LoggerLog::debug("LoggerRendererMap::addRenderer() Rendering class: [{$renderingClassName}], Rendered class: [{$renderedClassName}].");
         $renderer = LoggerObjectRenderer::factory($renderingClassName);
-        if($renderer === null) {
+        if ($renderer === null) {
             LoggerLog::warn("LoggerRendererMap::addRenderer() Could not instantiate renderer [{$renderingClassName}].");
             return;
         } else {
@@ -94,7 +94,7 @@ 
      */
     public function findAndRender($o)
     {
-        if($o === null) {
+        if ($o === null) {
             return null;
         } else {
             if (is_object($o)) {
@@ -136,7 +136,7 @@ 
     public function &getByClassName($class)
     {
         $r = null;
-        for($c = strtolower($class); !empty($c); $c = get_parent_class($c)) {
+        for ($c = strtolower($class); !empty($c); $c = get_parent_class($c)) {
             if (isset($this->map[$c])) {
                 return  $this->map[$c];
             }
@@ -176,7 +176,7 @@ 
     {
         $class = basename($class);
         if (!class_exists($class)) {
-            @include_once(LOG4PHP_DIR ."/or/{$class}.php");
+            @include_once(LOG4PHP_DIR . "/or/{$class}.php");
         }
         return class_exists($class);
     }