Parser - Code Metrics - Inspection of "EventLoopContainer" - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — EventLoopContainer ( c9a84d...6e77fa )

by Vasily

created 2016-06-06 02:46 UTC

Parser F

↳ Parent: Project

Complexity

Total Complexity

101

Size/Duplication

Total Lines	541
Duplicated Lines	4.07 %

Coupling/Cohesion

Components	5
Dependencies	9

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	22
loc	541
rs	1.5789
wmc	101
lcom	5
cbo	9

10 Methods

Rating	Name	Duplication	Size	Complexity
A	isErroneous()	0	4	1
A	parse()	0	11	2
D	__construct()	22	294	77
B	purgeScope()	0	20	11
A	getCurrentScope()	0	6	1
A	raiseError()	0	14	4
A	token()	0	4	1
A	getCurrentChar()	0	13	2
A	getNextChar()	0	4	1
A	rewind()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Parser often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Parser, and based on these observations, apply Extract Interface, too.

<?php
namespace PHPDaemon\Config;

use PHPDaemon\Config\Entry\Generic;
use PHPDaemon\Core\Daemon;
use PHPDaemon\Core\Debug;
use PHPDaemon\Exceptions\InfiniteRecursion;

/**
 * Config parser
 *
 * @package    Core
 * @subpackage Config
 *
 * @author     Vasily Zorin <[email protected]>
 */
class Parser
{
    use \PHPDaemon\Traits\ClassWatchdog;
    use \PHPDaemon\Traits\StaticObjectWatchdog;

    /**
     * State: standby
     */
    const T_ALL = 1;
    /**
     * State: comment
     */
    const T_COMMENT = 2;
    /**
     * State: variable definition block
     */
    const T_VAR = 3;
    /**
     * Single-quoted string
     */
    const T_STRING = 4;

    /**
     * Double-quoted
     */
    const T_STRING_DOUBLE = 5;

    /**
     * Block
     */
    const T_BLOCK = 6;

    /**
     * Value defined by constant (keyword) or number
     */
    const T_CVALUE = 7;

    /**
     * Config file path
     * @var string
     */
    protected $file;

    /**
     * Current line number
     * @var number
     */
    protected $line = 1;

    /**
     * Current column number
     * @var number
     */
    protected $col = 1;

    /**
     * Pointer (current offset)
     * @var integer
     */
    protected $p = 0;

    /**
     * State stack
     * @var array
     */
    protected $state = [];

    /**
     * Target object
     * @var object
     */
    protected $target;

    /**
     * Erroneous?
     * @var boolean
     */
    protected $erroneous = false;

    /**
     * Callbacks
     * @var array
     */
    protected $tokens;

    /**
     * File length
     * @var integer
     */
    protected $length;

    /**
     * Revision
     * @var integer
     */
    protected $revision;

    /**
     * Contents of config file
     * @var string
     */
    protected $data;

    /**
     * Parse stack
     * @var array
     */
    protected static $stack = [];

    /**
     * Erroneous?
     * @return boolean
     */
    public function isErroneous()
    {
        return $this->erroneous;
    }

    /**
     * Parse config file
     * @param string  File path
     * @param object  Target
     * @param boolean Included? Default is false
     * @return \PHPDaemon\Config\Parser
     */
    public static function parse($file, $target, $included = false)
    {
        if (in_array($file, static::$stack)) {
            throw new InfiniteRecursion;
        }

        static::$stack[] = $file;
        $parser = new static($file, $target, $included);
        array_pop(static::$stack);
        return $parser;
    }

    /**
     * Constructor
     * @return void

     */
    protected function __construct($file, $target, $included = false)
    {
        $this->file = $file;
        $this->target = $target;
        $this->revision = ++Object::$lastRevision;
        $this->data = file_get_contents($file);

        if (substr($this->data, 0, 2) === '#!') {
            if (!is_executable($file)) {
                $this->raiseError('Shebang (#!) detected in the first line, but file hasn\'t +x mode.');
                return;
            }
            $this->data = shell_exec($file);
        }

        $this->data = str_replace("\r", '', $this->data);
        $this->length = mb_orig_strlen($this->data);
        $this->state[] = [static::T_ALL, $this->target];
        $this->tokens = [
            static::T_COMMENT => function ($c) {
                if ($c === "\n") {
                    array_pop($this->state);
                }
            },
            static::T_STRING_DOUBLE => function ($q) {
                $str = '';
                ++$this->p;

                for (; $this->p < $this->length; ++$this->p) {

                    $c = $this->getCurrentChar();

                    if ($c === $q) {
                        ++$this->p;
                        break;
                    } elseif ($c === '\\') {
                        next:
                        $n = $this->getNextChar();
                        if ($n === $q) {
                            $str .= $q;
                            ++$this->p;
                        } elseif (ctype_digit($n)) {
                            $def = $n;
                            ++$this->p;
                            for (; $this->p < min($this->length, $this->p + 2); ++$this->p) {

                                $n = $this->getNextChar();
                                if (!ctype_digit($n)) {
                                    break;
                                }
                                $def .= $n;
                            }
                            $str .= chr((int)$def);
                        } elseif (($n === 'x') || ($n === 'X')) {
                            $def = $n;
                            ++$this->p;
                            for (; $this->p < min($this->length, $this->p + 2); ++$this->p) {

                                $n = $this->getNextChar();
                                if (!ctype_xdigit($n)) {
                                    break;
                                }
                                $def .= $n;
                            }
                            $str .= chr((int)hexdec($def));
                        } else {
                            $str .= $c;
                        }
                    } else {
                        $str .= $c;
                    }
                }

                if ($this->p >= $this->length) {
                    $this->raiseError('Unexpected End-Of-File.');
                }
                return $str;
            },
            static::T_STRING => function ($q) {
                $str = '';
                ++$this->p;

                for (; $this->p < $this->length; ++$this->p) {
                    $c = $this->getCurrentChar();

                    if ($c === $q) {
                        ++$this->p;
                        break;
                    } elseif ($c === '\\') {
                        if ($this->getNextChar() === $q) {
                            $str .= $q;
                            ++$this->p;
                        } else {
                            $str .= $c;
                        }
                    } else {
                        $str .= $c;
                    }
                }

                if ($this->p >= $this->length) {
                    $this->raiseError('Unexpected End-Of-File.');
                }
                return $str;
            },
            static::T_ALL => function ($c) {
                if (ctype_space($c)) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                } elseif ($c === '#') {
                    $this->state[] = [static::T_COMMENT];
                } elseif ($c === '}') {
                    if (sizeof($this->state) > 1) {
                        $this->purgeScope($this->getCurrentScope());
                        array_pop($this->state);
                    } else {
                        $this->raiseError('Unexpected \'}\'');
                    }
                } elseif (ctype_alnum($c) || $c === '\\') {
                    $elements = [''];
                    $elTypes = [null];
                    $i = 0;
                    $tokenType = 0;
                    $newLineDetected = null;

                    for (; $this->p < $this->length; ++$this->p) {
                        $prePoint = [$this->line, $this->col - 1];
                        $c = $this->getCurrentChar();

                        if (ctype_space($c) || $c === '=' || $c === ',') {
                            if ($c === "\n") {
                                $newLineDetected = $prePoint;
                            }
                            if ($elTypes[$i] !== null) {
                                ++$i;
                                $elTypes[$i] = null;
                            }
                        } elseif ($c === '\'') {
                            if ($elTypes[$i] !== null) {
                                $this->raiseError('Unexpected T_STRING.');
                            }

                            $string = $this->token(static::T_STRING, $c);
                            --$this->p;

                            if ($elTypes[$i] === null) {

                                $elements[$i] = $string;
                                $elTypes[$i] = static::T_STRING;
                            }
                        } elseif ($c === '"') {
                            if ($elTypes[$i] !== null) {
                                $this->raiseError('Unexpected T_STRING_DOUBLE.');
                            }

                            $string = $this->token(static::T_STRING_DOUBLE, $c);
                            --$this->p;

                            if ($elTypes[$i] === null) {

                                $elements[$i] = $string;
                                $elTypes[$i] = static::T_STRING_DOUBLE;
                            }
                        } elseif ($c === '}') {
                            $this->raiseError('Unexpected \'}\' instead of \';\' or \'{\'');
                        } elseif ($c === ';') {
                            if ($newLineDetected) {
                                $this->raiseError('Unexpected new-line instead of \';\'', 'notice', $newLineDetected[0],
                                    $newLineDetected[1]);
                            }
                            $tokenType = static::T_VAR;
                            break;
                        } elseif ($c === '{') {
                            $tokenType = static::T_BLOCK;
                            break;
                        } else {
                            if ($elTypes[$i] === static::T_STRING) {
                                $this->raiseError('Unexpected T_CVALUE.');
                            } else {
                                if (!isset($elements[$i])) {
                                    $elements[$i] = '';
                                }

                                $elements[$i] .= $c;
                                $elTypes[$i] = static::T_CVALUE;
                            }
                        }
                    }
                    foreach ($elTypes as $k => $v) {
                        if (static::T_CVALUE === $v) {
                            if (ctype_digit($elements[$k])) {
                                $elements[$k] = (int)$elements[$k];
                            } elseif (is_numeric($elements[$k])) {
                                $elements[$k] = (float)$elements[$k];
                            } else {
                                $l = strtolower($elements[$k]);

                                if (($l === 'true') || ($l === 'on')) {
                                    $elements[$k] = true;
                                } elseif (($l === 'false') || ($l === 'off')) {
                                    $elements[$k] = false;
                                } elseif ($l === 'null') {
                                    $elements[$k] = null;
                                }
                            }
                        }
                    }
                    if ($tokenType === 0) {
                        $this->raiseError('Expected \';\' or \'{\'');
                    } elseif ($tokenType === static::T_VAR) {
                        $name = str_replace('-', '', strtolower($elements[0]));
                        if (sizeof($elements) > 2) {
                            $value = array_slice($elements, 1);
                        } else {
                            $value = isset($elements[1]) ? $elements[1] : null;
                        }
                        $scope = $this->getCurrentScope();

                        if ($name === 'include') {
                            if (!is_array($value)) {
                                $value = [$value];
                            }
                            foreach ($value as $path) {
                                if (substr($path, 0, 1) !== '/') {
                                    $path = 'conf/' . $path;
                                }
                                $files = glob($path);
                                if ($files) {

                                    foreach ($files as $fn) {
                                        try {
                                            static::parse($fn, $scope, true);
                                        } catch (InfiniteRecursion $e) {
                                            $this->raiseError('Cannot include \'' . $fn . '\' as a part of itself, it may cause an infinite recursion.');

                                        }
                                    }
                                }
                            }
                        } else {
                            if (sizeof($elements) === 1) {
                                $value = true;
                                $elements[1] = true;
                                $elTypes[1] = static::T_CVALUE;
                            } elseif ($value === null) {
                                $value = null;
                                $elements[1] = null;
                                $elTypes[1] = static::T_CVALUE;
                            }

                            if (isset($scope->{$name})) {
                                if ($scope->{$name}->source !== 'cmdline') {
                                    if (($elTypes[1] === static::T_CVALUE) && is_string($value)) {
                                        $scope->{$name}->pushHumanValue($value);
                                    } else {
                                        $scope->{$name}->pushValue($value);
                                    }
                                    $scope->{$name}->source = 'config';
                                    $scope->{$name}->revision = $this->revision;
                                }
                            } elseif ($scope instanceof Section) {
                                $scope->{$name} = new Generic();
                                $scope->{$name}->source = 'config';
                                $scope->{$name}->revision = $this->revision;
                                $scope->{$name}->pushValue($value);
                                $scope->{$name}->setValueType($value);
                            } else {
                                $this->raiseError('Unrecognized parameter \'' . $name . '\'');
                            }
                        }
                    } elseif ($tokenType === static::T_BLOCK) {
                        $scope = $this->getCurrentScope();
                        $sectionName = implode('-', $elements);
                        $sectionName = strtr($sectionName, '-. ', ':::');
                        if (!isset($scope->{$sectionName})) {
                            $scope->{$sectionName} = new Section;
                        }
                        $scope->{$sectionName}->source = 'config';
                        $scope->{$sectionName}->revision = $this->revision;
                        $this->state[] = [
                            static::T_ALL,
                            $scope->{$sectionName},
                        ];
                    }
                } else {
                    $this->raiseError('Unexpected char \'' . Debug::exportBytes($c) . '\'');
                }
            }
        ];

        for (; $this->p < $this->length; ++$this->p) {
            $c = $this->getCurrentChar();
            $e = end($this->state);
            $this->token($e[0], $c);
        }
        if (!$included) {
            $this->purgeScope($this->target);
        }

        if (Daemon::$config->verbosetty->value) {
            Daemon::log('Loaded config file: ' . escapeshellarg($file));
        }
    }

    /**
     * Removes old config parts after updating.
     * @return void
     */
    protected function purgeScope($scope)
    {
        foreach ($scope as $name => $obj) {
            if ($obj instanceof Generic) {
                if ($obj->source === 'config' && ($obj->revision < $this->revision)) {
                    if (!$obj->resetToDefault()) {
                        unset($scope->{$name});
                    }
                }
            } elseif ($obj instanceof Section) {
                if ($obj->source === 'config' && ($obj->revision < $this->revision)) {
                    if ($obj->count() === 0) {
                        unset($scope->{$name});
                    } elseif (isset($obj->enable)) {
                        $obj->enable->setValue(false);
                    }
                }
            }
        }
    }

    /**
     * Returns current variable scope
     * @return object Scope.
     */
    public function getCurrentScope()
    {
        $e = end($this->state);

        return $e[1];
    }

    /**
     * Raises error message.
     * @param string Message.
     * @param string Level.
     * @param string $msg
     * @return void
     */
    public function raiseError($msg, $level = 'emerg', $line = null, $col = null)
    {
        if ($level === 'emerg') {
            $this->erroneous = true;
        }
        if ($line === null) {
            $line = $this->line;
        }
        if ($col === null) {
            $col = $this->col - 1;
        }

        Daemon::log('[conf#' . $level . '][' . $this->file . ' L:' . $line . ' C: ' . $col . ']   ' . $msg);
    }

    /**
     * Executes token server.
     * @param string $c
     * @return mixed|void
     */
    protected function token($token, $c)
    {
        return $this->tokens[$token]($c);
    }

    /**
     * Current character.
     * @return string Character.
     */
    protected function getCurrentChar()
    {
        $c = substr($this->data, $this->p, 1);

        if ($c === "\n") {
            ++$this->line;
            $this->col = 1;
        } else {
            ++$this->col;
        }

        return $c;
    }

    /**
     * Returns next character.
     * @return string Character.
     */
    protected function getNextChar()
    {
        return substr($this->data, $this->p + 1, 1);
    }

    /**
     * Rewinds the pointer back.
     * @param integer Number of characters to rewind back.
     * @return void
     */
    protected function rewind($n)
    {
        $this->p -= $n;
    }
}


1		<?php
2		namespace PHPDaemon\Config;
3
4		use PHPDaemon\Config\Entry\Generic;
5		use PHPDaemon\Core\Daemon;
6		use PHPDaemon\Core\Debug;
7		use PHPDaemon\Exceptions\InfiniteRecursion;
8
9		/**
10		* Config parser
11		*
12		* @package Core
13		* @subpackage Config
14		*
15		* @author Vasily Zorin <[email protected]>
16		*/
17		class Parser
18		{
19		use \PHPDaemon\Traits\ClassWatchdog;
20		use \PHPDaemon\Traits\StaticObjectWatchdog;
21
22		/**
23		* State: standby
24		*/
25		const T_ALL = 1;
26		/**
27		* State: comment
28		*/
29		const T_COMMENT = 2;
30		/**
31		* State: variable definition block
32		*/
33		const T_VAR = 3;
34		/**
35		* Single-quoted string
36		*/
37		const T_STRING = 4;
38
39		/**
40		* Double-quoted
41		*/
42		const T_STRING_DOUBLE = 5;
43
44		/**
45		* Block
46		*/
47		const T_BLOCK = 6;
48
49		/**
50		* Value defined by constant (keyword) or number
51		*/
52		const T_CVALUE = 7;
53
54		/**
55		* Config file path
56		* @var string
57		*/
58		protected $file;
59
60		/**
61		* Current line number
62		* @var number
63		*/
64		protected $line = 1;
65
66		/**
67		* Current column number
68		* @var number
69		*/
70		protected $col = 1;
71
72		/**
73		* Pointer (current offset)
74		* @var integer
75		*/
76		protected $p = 0;
77
78		/**
79		* State stack
80		* @var array
81		*/
82		protected $state = [];
83
84		/**
85		* Target object
86		* @var object
87		*/
88		protected $target;
89
90		/**
91		* Erroneous?
92		* @var boolean
93		*/
94		protected $erroneous = false;
95
96		/**
97		* Callbacks
98		* @var array
99		*/
100		protected $tokens;
101
102		/**
103		* File length
104		* @var integer
105		*/
106		protected $length;
107
108		/**
109		* Revision
110		* @var integer
111		*/
112		protected $revision;
113
114		/**
115		* Contents of config file
116		* @var string
117		*/
118		protected $data;
119
120		/**
121		* Parse stack
122		* @var array
123		*/
124		protected static $stack = [];
125
126		/**
127		* Erroneous?
128		* @return boolean
129		*/
130		public function isErroneous()
131		{
132		return $this->erroneous;
133		}
134
135		/**
136		* Parse config file
137		* @param string File path
138		* @param object Target
139		* @param boolean Included? Default is false
140		* @return \PHPDaemon\Config\Parser
141		*/
142		public static function parse($file, $target, $included = false)
143		{
144		if (in_array($file, static::$stack)) {
145		throw new InfiniteRecursion;
146		}
147
148		static::$stack[] = $file;
149		$parser = new static($file, $target, $included);
150		array_pop(static::$stack);
151		return $parser;
152		}
153
154		/**
155		* Constructor
156		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
157		*/
158		protected function __construct($file, $target, $included = false)
159		{
160		$this->file = $file;
161		$this->target = $target;
162		$this->revision = ++Object::$lastRevision;
163		$this->data = file_get_contents($file);
164
165		if (substr($this->data, 0, 2) === '#!') {
166		if (!is_executable($file)) {
167		$this->raiseError('Shebang (#!) detected in the first line, but file hasn\'t +x mode.');
168		return;
169		}
170		$this->data = shell_exec($file);
171		}
172
173		$this->data = str_replace("\r", '', $this->data);
174		$this->length = mb_orig_strlen($this->data);
175		$this->state[] = [static::T_ALL, $this->target];
176		$this->tokens = [
177		static::T_COMMENT => function ($c) {
178		if ($c === "\n") {
179		array_pop($this->state);
180		}
181		},
182		static::T_STRING_DOUBLE => function ($q) {
183		$str = '';
184		++$this->p;
185
186		for (; $this->p < $this->length; ++$this->p) {
		0 ignored issues – show Comprehensibility Bug introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Loop incrementor ($this) jumbling with inner loop Loading history...
187		$c = $this->getCurrentChar();
188
189		if ($c === $q) {
190		++$this->p;
191		break;
192		} elseif ($c === '\\') {
193		next:
194		$n = $this->getNextChar();
195		if ($n === $q) {
196		$str .= $q;
197		++$this->p;
198		} elseif (ctype_digit($n)) {
199		$def = $n;
200		++$this->p;
201	View Code Duplication	for (; $this->p < min($this->length, $this->p + 2); ++$this->p) {
		0 ignored issues – show Duplication introduced 2016-05-18 23:08 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
202		$n = $this->getNextChar();
203		if (!ctype_digit($n)) {
204		break;
205		}
206		$def .= $n;
207		}
208		$str .= chr((int)$def);
209		} elseif (($n === 'x') \|\| ($n === 'X')) {
210		$def = $n;
211		++$this->p;
212	View Code Duplication	for (; $this->p < min($this->length, $this->p + 2); ++$this->p) {
		0 ignored issues – show Duplication introduced 2016-05-18 23:08 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
213		$n = $this->getNextChar();
214		if (!ctype_xdigit($n)) {
215		break;
216		}
217		$def .= $n;
218		}
219		$str .= chr((int)hexdec($def));
220		} else {
221		$str .= $c;
222		}
223		} else {
224		$str .= $c;
225		}
226		}
227
228		if ($this->p >= $this->length) {
229		$this->raiseError('Unexpected End-Of-File.');
230		}
231		return $str;
232		},
233		static::T_STRING => function ($q) {
234		$str = '';
235		++$this->p;
236
237		for (; $this->p < $this->length; ++$this->p) {
238		$c = $this->getCurrentChar();
239
240		if ($c === $q) {
241		++$this->p;
242		break;
243		} elseif ($c === '\\') {
244		if ($this->getNextChar() === $q) {
245		$str .= $q;
246		++$this->p;
247		} else {
248		$str .= $c;
249		}
250		} else {
251		$str .= $c;
252		}
253		}
254
255		if ($this->p >= $this->length) {
256		$this->raiseError('Unexpected End-Of-File.');
257		}
258		return $str;
259		},
260		static::T_ALL => function ($c) {
261		if (ctype_space($c)) {
		0 ignored issues – show Unused Code introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
262		} elseif ($c === '#') {
263		$this->state[] = [static::T_COMMENT];
264		} elseif ($c === '}') {
265		if (sizeof($this->state) > 1) {
266		$this->purgeScope($this->getCurrentScope());
267		array_pop($this->state);
268		} else {
269		$this->raiseError('Unexpected \'}\'');
270		}
271		} elseif (ctype_alnum($c) \|\| $c === '\\') {
272		$elements = [''];
273		$elTypes = [null];
274		$i = 0;
275		$tokenType = 0;
276		$newLineDetected = null;
277
278		for (; $this->p < $this->length; ++$this->p) {
279		$prePoint = [$this->line, $this->col - 1];
280		$c = $this->getCurrentChar();
281
282		if (ctype_space($c) \|\| $c === '=' \|\| $c === ',') {
283		if ($c === "\n") {
284		$newLineDetected = $prePoint;
285		}
286		if ($elTypes[$i] !== null) {
287		++$i;
288		$elTypes[$i] = null;
289		}
290		} elseif ($c === '\'') {
291		if ($elTypes[$i] !== null) {
292		$this->raiseError('Unexpected T_STRING.');
293		}
294
295		$string = $this->token(static::T_STRING, $c);
296		--$this->p;
297
298	View Code Duplication	if ($elTypes[$i] === null) {
		0 ignored issues – show Duplication introduced 2016-05-14 17:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
299		$elements[$i] = $string;
300		$elTypes[$i] = static::T_STRING;
301		}
302		} elseif ($c === '"') {
303		if ($elTypes[$i] !== null) {
304		$this->raiseError('Unexpected T_STRING_DOUBLE.');
305		}
306
307		$string = $this->token(static::T_STRING_DOUBLE, $c);
308		--$this->p;
309
310	View Code Duplication	if ($elTypes[$i] === null) {
		0 ignored issues – show Duplication introduced 2016-05-14 17:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
311		$elements[$i] = $string;
312		$elTypes[$i] = static::T_STRING_DOUBLE;
313		}
314		} elseif ($c === '}') {
315		$this->raiseError('Unexpected \'}\' instead of \';\' or \'{\'');
316		} elseif ($c === ';') {
317		if ($newLineDetected) {
318		$this->raiseError('Unexpected new-line instead of \';\'', 'notice', $newLineDetected[0],
319		$newLineDetected[1]);
320		}
321		$tokenType = static::T_VAR;
322		break;
323		} elseif ($c === '{') {
324		$tokenType = static::T_BLOCK;
325		break;
326		} else {
327		if ($elTypes[$i] === static::T_STRING) {
328		$this->raiseError('Unexpected T_CVALUE.');
329		} else {
330		if (!isset($elements[$i])) {
331		$elements[$i] = '';
332		}
333
334		$elements[$i] .= $c;
335		$elTypes[$i] = static::T_CVALUE;
336		}
337		}
338		}
339		foreach ($elTypes as $k => $v) {
340		if (static::T_CVALUE === $v) {
341		if (ctype_digit($elements[$k])) {
342		$elements[$k] = (int)$elements[$k];
343		} elseif (is_numeric($elements[$k])) {
344		$elements[$k] = (float)$elements[$k];
345		} else {
346		$l = strtolower($elements[$k]);
347
348		if (($l === 'true') \|\| ($l === 'on')) {
349		$elements[$k] = true;
350		} elseif (($l === 'false') \|\| ($l === 'off')) {
351		$elements[$k] = false;
352		} elseif ($l === 'null') {
353		$elements[$k] = null;
354		}
355		}
356		}
357		}
358		if ($tokenType === 0) {
359		$this->raiseError('Expected \';\' or \'{\'');
360		} elseif ($tokenType === static::T_VAR) {
361		$name = str_replace('-', '', strtolower($elements[0]));
362		if (sizeof($elements) > 2) {
363		$value = array_slice($elements, 1);
364		} else {
365		$value = isset($elements[1]) ? $elements[1] : null;
366		}
367		$scope = $this->getCurrentScope();
368
369		if ($name === 'include') {
370		if (!is_array($value)) {
371		$value = [$value];
372		}
373		foreach ($value as $path) {
374		if (substr($path, 0, 1) !== '/') {
375		$path = 'conf/' . $path;
376		}
377		$files = glob($path);
378		if ($files) {
		0 ignored issues – show Bug Best Practice introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report The expression `$files` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
379		foreach ($files as $fn) {
380		try {
381		static::parse($fn, $scope, true);
382		} catch (InfiniteRecursion $e) {
383		$this->raiseError('Cannot include \'' . $fn . '\' as a part of itself, it may cause an infinite recursion.');
		0 ignored issues – show Coding Style introduced 2016-05-10 20:52 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 153 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
384		}
385		}
386		}
387		}
388		} else {
389		if (sizeof($elements) === 1) {
390		$value = true;
391		$elements[1] = true;
392		$elTypes[1] = static::T_CVALUE;
393		} elseif ($value === null) {
394		$value = null;
395		$elements[1] = null;
396		$elTypes[1] = static::T_CVALUE;
397		}
398
399		if (isset($scope->{$name})) {
400		if ($scope->{$name}->source !== 'cmdline') {
401		if (($elTypes[1] === static::T_CVALUE) && is_string($value)) {
402		$scope->{$name}->pushHumanValue($value);
403		} else {
404		$scope->{$name}->pushValue($value);
405		}
406		$scope->{$name}->source = 'config';
407		$scope->{$name}->revision = $this->revision;
408		}
409		} elseif ($scope instanceof Section) {
410		$scope->{$name} = new Generic();
411		$scope->{$name}->source = 'config';
412		$scope->{$name}->revision = $this->revision;
413		$scope->{$name}->pushValue($value);
414		$scope->{$name}->setValueType($value);
415		} else {
416		$this->raiseError('Unrecognized parameter \'' . $name . '\'');
417		}
418		}
419		} elseif ($tokenType === static::T_BLOCK) {
420		$scope = $this->getCurrentScope();
421		$sectionName = implode('-', $elements);
422		$sectionName = strtr($sectionName, '-. ', ':::');
423		if (!isset($scope->{$sectionName})) {
424		$scope->{$sectionName} = new Section;
425		}
426		$scope->{$sectionName}->source = 'config';
427		$scope->{$sectionName}->revision = $this->revision;
428		$this->state[] = [
429		static::T_ALL,
430		$scope->{$sectionName},
431		];
432		}
433		} else {
434		$this->raiseError('Unexpected char \'' . Debug::exportBytes($c) . '\'');
435		}
436		}
437		];
438
439		for (; $this->p < $this->length; ++$this->p) {
440		$c = $this->getCurrentChar();
441		$e = end($this->state);
442		$this->token($e[0], $c);
443		}
444		if (!$included) {
445		$this->purgeScope($this->target);
446		}
447
448		if (Daemon::$config->verbosetty->value) {
449		Daemon::log('Loaded config file: ' . escapeshellarg($file));
450		}
451		}
452
453		/**
454		* Removes old config parts after updating.
455		* @return void
456		*/
457		protected function purgeScope($scope)
458		{
459		foreach ($scope as $name => $obj) {
460		if ($obj instanceof Generic) {
461		if ($obj->source === 'config' && ($obj->revision < $this->revision)) {
462		if (!$obj->resetToDefault()) {
463		unset($scope->{$name});
464		}
465		}
466		} elseif ($obj instanceof Section) {
467		if ($obj->source === 'config' && ($obj->revision < $this->revision)) {
468		if ($obj->count() === 0) {
469		unset($scope->{$name});
470		} elseif (isset($obj->enable)) {
471		$obj->enable->setValue(false);
472		}
473		}
474		}
475		}
476		}
477
478		/**
479		* Returns current variable scope
480		* @return object Scope.
481		*/
482		public function getCurrentScope()
483		{
484		$e = end($this->state);
485
486		return $e[1];
487		}
488
489		/**
490		* Raises error message.
491		* @param string Message.
492		* @param string Level.
493		* @param string $msg
494		* @return void
495		*/
496		public function raiseError($msg, $level = 'emerg', $line = null, $col = null)
497		{
498		if ($level === 'emerg') {
499		$this->erroneous = true;
500		}
501		if ($line === null) {
502		$line = $this->line;
503		}
504		if ($col === null) {
505		$col = $this->col - 1;
506		}
507
508		Daemon::log('[conf#' . $level . '][' . $this->file . ' L:' . $line . ' C: ' . $col . '] ' . $msg);
509		}
510
511		/**
512		* Executes token server.
513		* @param string $c
514		* @return mixed\|void
515		*/
516		protected function token($token, $c)
517		{
518		return $this->tokens[$token]($c);
519		}
520
521		/**
522		* Current character.
523		* @return string Character.
524		*/
525		protected function getCurrentChar()
526		{
527		$c = substr($this->data, $this->p, 1);
528
529		if ($c === "\n") {
530		++$this->line;
531		$this->col = 1;
532		} else {
533		++$this->col;
534		}
535
536		return $c;
537		}
538
539		/**
540		* Returns next character.
541		* @return string Character.
542		*/
543		protected function getNextChar()
544		{
545		return substr($this->data, $this->p + 1, 1);
546		}
547
548		/**
549		* Rewinds the pointer back.
550		* @param integer Number of characters to rewind back.
551		* @return void
552		*/
553		protected function rewind($n)
554		{
555		$this->p -= $n;
556		}
557		}
558

kakserpom / phpdaemon