bfw: comparison library/log4php/helpers/LoggerPatternParser.php

equal deleted inserted replaced

--1:000000000000
+:4869aea77e21
+<?php
+/**
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License. You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* @package log4php
+*/
+/**
+* Most of the work of the {@link LoggerPatternLayout} class
+* is delegated to the {@link LoggerPatternParser} class.
+*
+* <p>It is this class that parses conversion patterns and creates
+* a chained list of {@link LoggerPatternConverter} converters.</p>
+*
+* @version $Revision: 1395467 $
+* @package log4php
+* @subpackage helpers
+*
+* @since 0.3
+*/
+class LoggerPatternParser {
+/** Escape character for conversion words in the conversion pattern. */
+const ESCAPE_CHAR = '%';
+/** Maps conversion words to relevant converters. */
+private $converterMap;
+/** Conversion pattern used in layout. */
+private $pattern;
+/** Regex pattern used for parsing the conversion pattern. */
+private $regex;
+/**
+* First converter in the chain.
+* @var LoggerPatternConverter
+*/
+private $head;
+/** Last converter in the chain. */
+private $tail;
+public function __construct($pattern, $converterMap) {
+$this->pattern = $pattern;
+$this->converterMap = $converterMap;
+// Construct the regex pattern
+$this->regex =
+'/' .                       // Starting regex pattern delimiter
+self::ESCAPE_CHAR .         // Character which marks the start of the conversion pattern
+'(?P<modifiers>[0-9.-]*)' . // Format modifiers (optional)
+'(?P<word>[a-zA-Z]+)' .     // The conversion word
+'(?P<option>{[^}]*})?' .    // Conversion option in braces (optional)
+'/';                        // Ending regex pattern delimiter
+}
+/**
+* Parses the conversion pattern string, converts it to a chain of pattern
+* converters and returns the first converter in the chain.
+*
+* @return LoggerPatternConverter
+*/
+public function parse() {
+// Skip parsing if the pattern is empty
+if (empty($this->pattern)) {
+$this->addLiteral('');
+return $this->head;
+}
+// Find all conversion words in the conversion pattern
+$count = preg_match_all($this->regex, $this->pattern, $matches, PREG_OFFSET_CAPTURE);
+if ($count === false) {
+$error = error_get_last();
+throw new LoggerException("Failed parsing layotut pattern: {$error['message']}");
+}
+$prevEnd = 0;
+foreach ($matches[0] as $key => $item) {
+// Locate where the conversion command starts and ends
+$length = strlen($item[0]);
+$start = $item[1];
+$end = $item[1] + $length;
+// Find any literal expressions between matched commands
+if ($start > $prevEnd) {
+$literal = substr($this->pattern, $prevEnd, $start - $prevEnd);
+$this->addLiteral($literal);
+}
+// Extract the data from the matched command
+$word = !empty($matches['word'][$key]) ? $matches['word'][$key][0] : null;
+$modifiers = !empty($matches['modifiers'][$key]) ? $matches['modifiers'][$key][0] : null;
+$option = !empty($matches['option'][$key]) ? $matches['option'][$key][0] : null;
+// Create a converter and add it to the chain
+$this->addConverter($word, $modifiers, $option);
+$prevEnd = $end;
+}
+// Add any trailing literals
+if ($end < strlen($this->pattern)) {
+$literal = substr($this->pattern, $end);
+$this->addLiteral($literal);
+}
+return $this->head;
+}
+/**
+* Adds a literal converter to the converter chain.
+* @param string $string The string for the literal converter.
+*/
+private function addLiteral($string) {
+$converter = new LoggerPatternConverterLiteral($string);
+$this->addToChain($converter);
+}
+/**
+* Adds a non-literal converter to the converter chain.
+*
+* @param string $word The conversion word, used to determine which
+*  converter will be used.
+* @param string $modifiers Formatting modifiers.
+* @param string $option Option to pass to the converter.
+*/
+private function addConverter($word, $modifiers, $option) {
+$formattingInfo = $this->parseModifiers($modifiers);
+$option = trim($option, "{} ");
+if (isset($this->converterMap[$word])) {
+$converter = $this->getConverter($word, $formattingInfo, $option);
+$this->addToChain($converter);
+} else {
+trigger_error("log4php: Invalid keyword '%$word' in converison pattern. Ignoring keyword.", E_USER_WARNING);
+}
+}
+/**
+* Determines which converter to use based on the conversion word. Creates
+* an instance of the converter using the provided formatting info and
+* option and returns it.
+*
+* @param string $word The conversion word.
+* @param LoggerFormattingInfo $info Formatting info.
+* @param string $option Converter option.
+*
+* @throws LoggerException
+*
+* @return LoggerPatternConverter
+*/
+private function getConverter($word, $info, $option) {
+if (!isset($this->converterMap[$word])) {
+throw new LoggerException("Invalid keyword '%$word' in converison pattern. Ignoring keyword.");
+}
+$converterClass = $this->converterMap[$word];
+if (!class_exists($converterClass)) {
+throw new LoggerException("Class '$converterClass' does not exist.");
+}
+$converter = new $converterClass($info, $option);
+if (!($converter instanceof LoggerPatternConverter)) {
+throw new LoggerException("Class '$converterClass' is not an instance of LoggerPatternConverter.");
+}
+return $converter;
+}
+/** Adds a converter to the chain and updates $head and $tail pointers. */
+private function addToChain(LoggerPatternConverter $converter) {
+if (!isset($this->head)) {
+$this->head = $converter;
+$this->tail = $this->head;
+} else {
+$this->tail->next = $converter;
+$this->tail = $this->tail->next;
+}
+}
+/**
+* Parses the formatting modifiers and produces the corresponding
+* LoggerFormattingInfo object.
+*
+* @param string $modifier
+* @return LoggerFormattingInfo
+* @throws LoggerException
+*/
+private function parseModifiers($modifiers) {
+$info = new LoggerFormattingInfo();
+// If no modifiers are given, return default values
+if (empty($modifiers)) {
+return $info;
+}
+// Validate
+$pattern = '/^(-?[0-9]+)?\.?-?[0-9]+$/';
+if (!preg_match($pattern, $modifiers)) {
+trigger_error("log4php: Invalid modifier in conversion pattern: [$modifiers]. Ignoring modifier.", E_USER_WARNING);
+return $info;
+}
+$parts = explode('.', $modifiers);
+if (!empty($parts[0])) {
+$minPart = (integer)$parts[0];
+$info->min = abs($minPart);
+$info->padLeft = ($minPart > 0);
+}
+if (!empty($parts[1])) {
+$maxPart = (integer)$parts[1];
+$info->max = abs($maxPart);
+$info->trimLeft = ($maxPart < 0);
+}
+return $info;
+}
+}