YetiForceCompany / YetiForceCRM

libraries/log4php.debug/LoggerAppenderSkeleton.php

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/helpers/LoggerPatternConverter.php

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

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

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/or/LoggerRendererMap.php

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);
     }

libraries/antlr/ANTLRStringStream.php

Spacing +20 added lines, -20 removed lines

@@ -5,13 +5,13 @@ 
 
 		/** Copy data in string to a local char array */
 		public function __construct($input) {
-			$this->p=0;
+			$this->p = 0;
 			$this->line = 1;
 			$this->charPositionInLine = 0;
 			$this->markDepth = 0;
 			$this->markers = null;
-			$this->lastMarker=0;
-			$this->name=null;
+			$this->lastMarker = 0;
+			$this->name = null;
 			
 			$this->data = strToIntArray($input);
 			$this->n = strlen($input);
@@ -29,34 +29,34 @@ 
 		}
 
 	    public function consume() {
-	        if ( $this->p < $this->n ) {
+	        if ($this->p < $this->n) {
 				$this->charPositionInLine++;
-				if ( $this->data[$this->p]==ord("\n") ) {
+				if ($this->data[$this->p] == ord("\n")) {
 					$this->line++;
-					$this->charPositionInLine=0;
+					$this->charPositionInLine = 0;
 				}
 	            $this->p++;
 	        }
 	    }
 
 	    public function LA($i) {
-			if ( $i==0 ) {
+			if ($i == 0) {
 				return 0; // undefined
 			}
-			if ( $i<0 ) {
+			if ($i < 0) {
 				$i++; // e.g., translate LA(-1) to use offset i=0; then data[p+0-1]
-				if ( ($this->p+$i-1) < 0 ) {
+				if (($this->p + $i - 1) < 0) {
 					return CharStreamConst::$EOF; // invalid; no char before first char
 				}
 			}
 
-			if ( ($this->p+$i-1) >= $this->n ) {
+			if (($this->p + $i - 1) >= $this->n) {
 	            //System.out.println("char LA("+i+")=EOF; p="+p);
 	            return CharStreamConst::$EOF;
 	        }
 	        //System.out.println("char LA("+i+")="+(char)data[p+i-1]+"; p="+p);
 			//System.out.println("LA("+i+"); p="+p+" n="+n+" data.length="+data.length);
-			return $this->data[$this->p+$i-1];
+			return $this->data[$this->p + $i - 1];
 	    }
 
 		public function LT($i) {
@@ -76,13 +76,13 @@ 
 		}
 
 		public function mark() {
-	        if ( $this->markers === null) {
+	        if ($this->markers === null) {
 	            $this->markers = array();
 	            $this->markers[] = null; // depth 0 means no backtracking, leave blank
 	        }
 	        $this->markDepth++;
 			$state = null;
-			if ($this->markDepth>=sizeof($this->markers)) {
+			if ($this->markDepth >= sizeof($this->markers)) {
 				$state = new CharStreamState();
 				$this->markers[] = $state;
 			}
@@ -96,10 +96,10 @@ 
 			return $this->markDepth;
 	    }
 
-	    public function rewind($m=null) {
-			if($m===null){
-				$this->rewind((int)$this->lastMarker);
-			}else{
+	    public function rewind($m = null) {
+			if ($m === null) {
+				$this->rewind((int) $this->lastMarker);
+			} else {
 				$state = $this->markers[$m];
 				// restore stream state
 				$this->seek($state->p);
@@ -120,18 +120,18 @@ 
 		 *  update line and charPositionInLine.
 		 */
 		public function seek($index) {
-			if ( $index<=$this->p ) {
+			if ($index <= $this->p) {
 				$this->p = $index; // just jump; don't update stream state (line, ...)
 				return;
 			}
 			// seek forward, consume until p hits index
-			while ( $this->p<$index ) {
+			while ($this->p < $index) {
 				$this->consume();
 			}
 		}
 
 		public function substring($start, $stop) {
-			return implode(array_map('chr', array_slice($this->data, $start, $stop-$start+1)));
+			return implode(array_map('chr', array_slice($this->data, $start, $stop - $start + 1)));
 		}
 
 		public function getLine() {