Lexer::escape() - Code Metrics - Inspection of "start of refactoring the config plugin" - splitbrain/dokuwiki - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — psr2-config ( c6639e )

by Andreas

created 2018-05-11 16:49 UTC

Lexer::escape() B

↳ Parent: Lexer

Complexity

Conditions	1
Paths	1

Size

Total Lines	43
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	38
nc	1
nop	1
dl	0
loc	43
rs	8.8571
c	0
b	0
f	0

<?php
/**
 * Lexer adapted from Simple Test: http://sourceforge.net/projects/simpletest/
 * For an intro to the Lexer see:
 * https://web.archive.org/web/20120125041816/http://www.phppatterns.com/docs/develop/simple_test_lexer_notes
 *
 * @author Marcus Baker http://www.lastcraft.com
 */

namespace dokuwiki\Parsing\Lexer;

// FIXME move elsewhere

define("DOKU_LEXER_ENTER", 1);
define("DOKU_LEXER_MATCHED", 2);
define("DOKU_LEXER_UNMATCHED", 3);
define("DOKU_LEXER_EXIT", 4);
define("DOKU_LEXER_SPECIAL", 5);

/**
 * Accepts text and breaks it into tokens.
 *
 * Some optimisation to make the sure the content is only scanned by the PHP regex
 * parser once. Lexer modes must not start with leading underscores.
 */
class Lexer
{
    /** @var ParallelRegex[] */
    protected $regexes;
    /** @var \Doku_Handler */
    protected $handler;
    /** @var StateStack */
    protected $mode;
    /** @var array mode "rewrites" */
    protected $mode_handlers;
    /** @var bool case sensitive? */
    protected $case;

    /**
     * Sets up the lexer in case insensitive matching by default.
     *
     * @param \Doku_Handler $handler  Handling strategy by reference.
     * @param string $start            Starting handler.
     * @param boolean $case            True for case sensitive.
     */
    public function __construct($handler, $start = "accept", $case = false)
    {
        $this->case = $case;
        $this->regexes = array();
        $this->handler = $handler;
        $this->mode = new StateStack($start);
        $this->mode_handlers = array();
    }

    /**
     * Adds a token search pattern for a particular parsing mode.
     *
     * The pattern does not change the current mode.
     *
     * @param string $pattern      Perl style regex, but ( and )
     *                             lose the usual meaning.
     * @param string $mode         Should only apply this
     *                             pattern when dealing with
     *                             this type of input.
     */
    public function addPattern($pattern, $mode = "accept")
    {
        if (! isset($this->regexes[$mode])) {
            $this->regexes[$mode] = new ParallelRegex($this->case);
        }
        $this->regexes[$mode]->addPattern($pattern);
    }

    /**
     * Adds a pattern that will enter a new parsing mode.
     *
     * Useful for entering parenthesis, strings, tags, etc.
     *
     * @param string $pattern      Perl style regex, but ( and ) lose the usual meaning.
     * @param string $mode         Should only apply this pattern when dealing with this type of input.
     * @param string $new_mode     Change parsing to this new nested mode.
     */
    public function addEntryPattern($pattern, $mode, $new_mode)
    {
        if (! isset($this->regexes[$mode])) {
            $this->regexes[$mode] = new ParallelRegex($this->case);
        }
        $this->regexes[$mode]->addPattern($pattern, $new_mode);
    }

    /**
     * Adds a pattern that will exit the current mode and re-enter the previous one.
     *
     * @param string $pattern      Perl style regex, but ( and ) lose the usual meaning.
     * @param string $mode         Mode to leave.
     */
    public function addExitPattern($pattern, $mode)
    {
        if (! isset($this->regexes[$mode])) {
            $this->regexes[$mode] = new ParallelRegex($this->case);
        }
        $this->regexes[$mode]->addPattern($pattern, "__exit");
    }

    /**
     * Adds a pattern that has a special mode.
     *
     * Acts as an entry and exit pattern in one go, effectively calling a special
     * parser handler for this token only.
     *
     * @param string $pattern      Perl style regex, but ( and ) lose the usual meaning.
     * @param string $mode         Should only apply this pattern when dealing with this type of input.
     * @param string $special      Use this mode for this one token.
     */
    public function addSpecialPattern($pattern, $mode, $special)
    {
        if (! isset($this->regexes[$mode])) {
            $this->regexes[$mode] = new ParallelRegex($this->case);
        }
        $this->regexes[$mode]->addPattern($pattern, "_$special");
    }

    /**
     * Adds a mapping from a mode to another handler.
     *
     * @param string $mode        Mode to be remapped.
     * @param string $handler     New target handler.
     */
    public function mapHandler($mode, $handler)
    {
        $this->mode_handlers[$mode] = $handler;
    }

    /**
     * Splits the page text into tokens.
     *
     * Will fail if the handlers report an error or if no content is consumed. If successful then each
     * unparsed and parsed token invokes a call to the held listener.
     *
     * @param string $raw        Raw HTML text.
     * @return boolean           True on success, else false.
     */
    public function parse($raw)
    {
        if (! isset($this->handler)) {
            return false;
        }
        $initialLength = strlen($raw);
        $length = $initialLength;
        $pos = 0;
        while (is_array($parsed = $this->reduce($raw))) {
            list($unmatched, $matched, $mode) = $parsed;
            $currentLength = strlen($raw);
            $matchPos = $initialLength - $currentLength - strlen($matched);
            if (! $this->dispatchTokens($unmatched, $matched, $mode, $pos, $matchPos)) {
                return false;
            }
            if ($currentLength == $length) {
                return false;
            }
            $length = $currentLength;
            $pos = $initialLength - $currentLength;
        }
        if (!$parsed) {
            return false;
        }
        return $this->invokeHandler($raw, DOKU_LEXER_UNMATCHED, $pos);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Sends the matched token and any leading unmatched
     * text to the parser changing the lexer to a new
     * mode if one is listed.
     *
     * @param string $unmatched Unmatched leading portion.
     * @param string $matched Actual token match.
     * @param bool|string $mode Mode after match. A boolean false mode causes no change.
     * @param int $initialPos
     * @param int $matchPos Current byte index location in raw doc thats being parsed
     * @return boolean             False if there was any error from the parser.
     */
    protected function dispatchTokens($unmatched, $matched, $mode = false, $initialPos, $matchPos)
    {
        if (! $this->invokeHandler($unmatched, DOKU_LEXER_UNMATCHED, $initialPos)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return false;
        }
        if ($this->isModeEnd($mode)) {

            if (! $this->invokeHandler($matched, DOKU_LEXER_EXIT, $matchPos)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return false;
            }
            return $this->mode->leave();
        }
        if ($this->isSpecialMode($mode)) {

            $this->mode->enter($this->decodeSpecial($mode));

            if (! $this->invokeHandler($matched, DOKU_LEXER_SPECIAL, $matchPos)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return false;
            }
            return $this->mode->leave();
        }
        if (is_string($mode)) {
            $this->mode->enter($mode);
            return $this->invokeHandler($matched, DOKU_LEXER_ENTER, $matchPos);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        return $this->invokeHandler($matched, DOKU_LEXER_MATCHED, $matchPos);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Tests to see if the new mode is actually to leave the current mode and pop an item from the matching
     * mode stack.
     *
     * @param string $mode    Mode to test.
     * @return boolean        True if this is the exit mode.
     */
    protected function isModeEnd($mode)
    {
        return ($mode === "__exit");
    }

    /**
     * Test to see if the mode is one where this mode is entered for this token only and automatically
     * leaves immediately afterwoods.
     *
     * @param string $mode    Mode to test.
     * @return boolean        True if this is the exit mode.
     */
    protected function isSpecialMode($mode)
    {
        return (strncmp($mode, "_", 1) == 0);
    }

    /**
     * Strips the magic underscore marking single token modes.
     *
     * @param string $mode    Mode to decode.
     * @return string         Underlying mode name.
     */
    protected function decodeSpecial($mode)
    {
        return substr($mode, 1);
    }

    /**
     * Calls the parser method named after the current mode.
     *
     * Empty content will be ignored. The lexer has a parser handler for each mode in the lexer.
     *
     * @param string $content Text parsed.
     * @param boolean $is_match Token is recognised rather
     *                               than unparsed data.
     * @param int $pos Current byte index location in raw doc
     *                             thats being parsed
     * @return bool
     */
    protected function invokeHandler($content, $is_match, $pos)
    {
        if (($content === "") || ($content === false)) {
            return true;
        }
        $handler = $this->mode->getCurrent();
        if (isset($this->mode_handlers[$handler])) {
            $handler = $this->mode_handlers[$handler];
        }

        // modes starting with plugin_ are all handled by the same
        // handler but with an additional parameter
        if (substr($handler, 0, 7)=='plugin_') {
            list($handler,$plugin) = explode('_', $handler, 2);
            return $this->handler->$handler($content, $is_match, $pos, $plugin);
        }

        return $this->handler->$handler($content, $is_match, $pos);
    }

    /**
     * Tries to match a chunk of text and if successful removes the recognised chunk and any leading
     * unparsed data. Empty strings will not be matched.
     *
     * @param string $raw         The subject to parse. This is the content that will be eaten.
     * @return array|bool         Three item list of unparsed content followed by the
     *                            recognised token and finally the action the parser is to take.
     *                            True if no match, false if there is a parsing error.
     */
    protected function reduce(&$raw)
    {
        if (! isset($this->regexes[$this->mode->getCurrent()])) {
            return false;
        }
        if ($raw === "") {
            return true;
        }
        if ($action = $this->regexes[$this->mode->getCurrent()]->split($raw, $split)) {
            list($unparsed, $match, $raw) = $split;
            return array($unparsed, $match, $action);
        }
        return true;
    }

    /**
     * Escapes regex characters other than (, ) and /
     *
     * @param string $str
     * @return string
     */
    public static function escape($str)
    {
        $chars = array(
            '/\\\\/',
            '/\./',
            '/\+/',
            '/\*/',
            '/\?/',
            '/\[/',
            '/\^/',
            '/\]/',
            '/\$/',
            '/\{/',
            '/\}/',
            '/\=/',
            '/\!/',
            '/\</',
            '/\>/',
            '/\|/',
            '/\:/'
        );

        $escaped = array(
            '\\\\\\\\',
            '\.',
            '\+',
            '\*',
            '\?',
            '\[',
            '\^',
            '\]',
            '\$',
            '\{',
            '\}',
            '\=',
            '\!',
            '\<',
            '\>',
            '\|',
            '\:'
        );
        return preg_replace($chars, $escaped, $str);
    }
}


1			<?php
2			/**
3			* Lexer adapted from Simple Test: http://sourceforge.net/projects/simpletest/
4			* For an intro to the Lexer see:
5			* https://web.archive.org/web/20120125041816/http://www.phppatterns.com/docs/develop/simple_test_lexer_notes
6			*
7			* @author Marcus Baker http://www.lastcraft.com
8			*/
9
10			namespace dokuwiki\Parsing\Lexer;
11
12			// FIXME move elsewhere
13
14			define("DOKU_LEXER_ENTER", 1);
15			define("DOKU_LEXER_MATCHED", 2);
16			define("DOKU_LEXER_UNMATCHED", 3);
17			define("DOKU_LEXER_EXIT", 4);
18			define("DOKU_LEXER_SPECIAL", 5);
19
20			/**
21			* Accepts text and breaks it into tokens.
22			*
23			* Some optimisation to make the sure the content is only scanned by the PHP regex
24			* parser once. Lexer modes must not start with leading underscores.
25			*/
26			class Lexer
27			{
28			/** @var ParallelRegex[] */
29			protected $regexes;
30			/** @var \Doku_Handler */
31			protected $handler;
32			/** @var StateStack */
33			protected $mode;
34			/** @var array mode "rewrites" */
35			protected $mode_handlers;
36			/** @var bool case sensitive? */
37			protected $case;
38
39			/**
40			* Sets up the lexer in case insensitive matching by default.
41			*
42			* @param \Doku_Handler $handler Handling strategy by reference.
43			* @param string $start Starting handler.
44			* @param boolean $case True for case sensitive.
45			*/
46			public function __construct($handler, $start = "accept", $case = false)
47			{
48			$this->case = $case;
49			$this->regexes = array();
50			$this->handler = $handler;
51			$this->mode = new StateStack($start);
52			$this->mode_handlers = array();
53			}
54
55			/**
56			* Adds a token search pattern for a particular parsing mode.
57			*
58			* The pattern does not change the current mode.
59			*
60			* @param string $pattern Perl style regex, but ( and )
61			* lose the usual meaning.
62			* @param string $mode Should only apply this
63			* pattern when dealing with
64			* this type of input.
65			*/
66			public function addPattern($pattern, $mode = "accept")
67			{
68			if (! isset($this->regexes[$mode])) {
69			$this->regexes[$mode] = new ParallelRegex($this->case);
70			}
71			$this->regexes[$mode]->addPattern($pattern);
72			}
73
74			/**
75			* Adds a pattern that will enter a new parsing mode.
76			*
77			* Useful for entering parenthesis, strings, tags, etc.
78			*
79			* @param string $pattern Perl style regex, but ( and ) lose the usual meaning.
80			* @param string $mode Should only apply this pattern when dealing with this type of input.
81			* @param string $new_mode Change parsing to this new nested mode.
82			*/
83			public function addEntryPattern($pattern, $mode, $new_mode)
84			{
85			if (! isset($this->regexes[$mode])) {
86			$this->regexes[$mode] = new ParallelRegex($this->case);
87			}
88			$this->regexes[$mode]->addPattern($pattern, $new_mode);
89			}
90
91			/**
92			* Adds a pattern that will exit the current mode and re-enter the previous one.
93			*
94			* @param string $pattern Perl style regex, but ( and ) lose the usual meaning.
95			* @param string $mode Mode to leave.
96			*/
97			public function addExitPattern($pattern, $mode)
98			{
99			if (! isset($this->regexes[$mode])) {
100			$this->regexes[$mode] = new ParallelRegex($this->case);
101			}
102			$this->regexes[$mode]->addPattern($pattern, "__exit");
103			}
104
105			/**
106			* Adds a pattern that has a special mode.
107			*
108			* Acts as an entry and exit pattern in one go, effectively calling a special
109			* parser handler for this token only.
110			*
111			* @param string $pattern Perl style regex, but ( and ) lose the usual meaning.
112			* @param string $mode Should only apply this pattern when dealing with this type of input.
113			* @param string $special Use this mode for this one token.
114			*/
115			public function addSpecialPattern($pattern, $mode, $special)
116			{
117			if (! isset($this->regexes[$mode])) {
118			$this->regexes[$mode] = new ParallelRegex($this->case);
119			}
120			$this->regexes[$mode]->addPattern($pattern, "_$special");
121			}
122
123			/**
124			* Adds a mapping from a mode to another handler.
125			*
126			* @param string $mode Mode to be remapped.
127			* @param string $handler New target handler.
128			*/
129			public function mapHandler($mode, $handler)
130			{
131			$this->mode_handlers[$mode] = $handler;
132			}
133
134			/**
135			* Splits the page text into tokens.
136			*
137			* Will fail if the handlers report an error or if no content is consumed. If successful then each
138			* unparsed and parsed token invokes a call to the held listener.
139			*
140			* @param string $raw Raw HTML text.
141			* @return boolean True on success, else false.
142			*/
143			public function parse($raw)
144			{
145			if (! isset($this->handler)) {
146			return false;
147			}
148			$initialLength = strlen($raw);
149			$length = $initialLength;
150			$pos = 0;
151			while (is_array($parsed = $this->reduce($raw))) {
152			list($unmatched, $matched, $mode) = $parsed;
153			$currentLength = strlen($raw);
154			$matchPos = $initialLength - $currentLength - strlen($matched);
155			if (! $this->dispatchTokens($unmatched, $matched, $mode, $pos, $matchPos)) {
156			return false;
157			}
158			if ($currentLength == $length) {
159			return false;
160			}
161			$length = $currentLength;
162			$pos = $initialLength - $currentLength;
163			}
164			if (!$parsed) {
165			return false;
166			}
167			return $this->invokeHandler($raw, DOKU_LEXER_UNMATCHED, $pos);
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_UNMATCHED` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
168			}
169
170			/**
171			* Sends the matched token and any leading unmatched
172			* text to the parser changing the lexer to a new
173			* mode if one is listed.
174			*
175			* @param string $unmatched Unmatched leading portion.
176			* @param string $matched Actual token match.
177			* @param bool\|string $mode Mode after match. A boolean false mode causes no change.
178			* @param int $initialPos
179			* @param int $matchPos Current byte index location in raw doc thats being parsed
180			* @return boolean False if there was any error from the parser.
181			*/
182			protected function dispatchTokens($unmatched, $matched, $mode = false, $initialPos, $matchPos)
183			{
184			if (! $this->invokeHandler($unmatched, DOKU_LEXER_UNMATCHED, $initialPos)) {
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_UNMATCHED` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
185			return false;
186			}
187			if ($this->isModeEnd($mode)) {
			0 ignored issues – show Bug introduced 2018-05-04 13:12 UTC by Report Bug Copy Issue Report It seems like `$mode` defined by parameter `$mode` on line 182 can also be of type `boolean`; however, `dokuwiki\Parsing\Lexer\Lexer::isModeEnd()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
188			if (! $this->invokeHandler($matched, DOKU_LEXER_EXIT, $matchPos)) {
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_EXIT` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
189			return false;
190			}
191			return $this->mode->leave();
192			}
193			if ($this->isSpecialMode($mode)) {
			0 ignored issues – show Bug introduced 2018-05-04 13:12 UTC by Report Bug Copy Issue Report It seems like `$mode` defined by parameter `$mode` on line 182 can also be of type `boolean`; however, `dokuwiki\Parsing\Lexer\Lexer::isSpecialMode()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
194			$this->mode->enter($this->decodeSpecial($mode));
			0 ignored issues – show Bug introduced 2018-05-04 13:12 UTC by Report Bug Copy Issue Report It seems like `$mode` defined by parameter `$mode` on line 182 can also be of type `boolean`; however, `dokuwiki\Parsing\Lexer\Lexer::decodeSpecial()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
195			if (! $this->invokeHandler($matched, DOKU_LEXER_SPECIAL, $matchPos)) {
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_SPECIAL` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
196			return false;
197			}
198			return $this->mode->leave();
199			}
200			if (is_string($mode)) {
201			$this->mode->enter($mode);
202			return $this->invokeHandler($matched, DOKU_LEXER_ENTER, $matchPos);
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_ENTER` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
203			}
204			return $this->invokeHandler($matched, DOKU_LEXER_MATCHED, $matchPos);
			0 ignored issues – show Documentation introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report `DOKU_LEXER_MATCHED` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
205			}
206
207			/**
208			* Tests to see if the new mode is actually to leave the current mode and pop an item from the matching
209			* mode stack.
210			*
211			* @param string $mode Mode to test.
212			* @return boolean True if this is the exit mode.
213			*/
214			protected function isModeEnd($mode)
215			{
216			return ($mode === "__exit");
217			}
218
219			/**
220			* Test to see if the mode is one where this mode is entered for this token only and automatically
221			* leaves immediately afterwoods.
222			*
223			* @param string $mode Mode to test.
224			* @return boolean True if this is the exit mode.
225			*/
226			protected function isSpecialMode($mode)
227			{
228			return (strncmp($mode, "_", 1) == 0);
229			}
230
231			/**
232			* Strips the magic underscore marking single token modes.
233			*
234			* @param string $mode Mode to decode.
235			* @return string Underlying mode name.
236			*/
237			protected function decodeSpecial($mode)
238			{
239			return substr($mode, 1);
240			}
241
242			/**
243			* Calls the parser method named after the current mode.
244			*
245			* Empty content will be ignored. The lexer has a parser handler for each mode in the lexer.
246			*
247			* @param string $content Text parsed.
248			* @param boolean $is_match Token is recognised rather
249			* than unparsed data.
250			* @param int $pos Current byte index location in raw doc
251			* thats being parsed
252			* @return bool
253			*/
254			protected function invokeHandler($content, $is_match, $pos)
255			{
256			if (($content === "") \|\| ($content === false)) {
257			return true;
258			}
259			$handler = $this->mode->getCurrent();
260			if (isset($this->mode_handlers[$handler])) {
261			$handler = $this->mode_handlers[$handler];
262			}
263
264			// modes starting with plugin_ are all handled by the same
265			// handler but with an additional parameter
266			if (substr($handler, 0, 7)=='plugin_') {
267			list($handler,$plugin) = explode('_', $handler, 2);
268			return $this->handler->$handler($content, $is_match, $pos, $plugin);
269			}
270
271			return $this->handler->$handler($content, $is_match, $pos);
272			}
273
274			/**
275			* Tries to match a chunk of text and if successful removes the recognised chunk and any leading
276			* unparsed data. Empty strings will not be matched.
277			*
278			* @param string $raw The subject to parse. This is the content that will be eaten.
279			* @return array\|bool Three item list of unparsed content followed by the
280			* recognised token and finally the action the parser is to take.
281			* True if no match, false if there is a parsing error.
282			*/
283			protected function reduce(&$raw)
284			{
285			if (! isset($this->regexes[$this->mode->getCurrent()])) {
286			return false;
287			}
288			if ($raw === "") {
289			return true;
290			}
291			if ($action = $this->regexes[$this->mode->getCurrent()]->split($raw, $split)) {
292			list($unparsed, $match, $raw) = $split;
293			return array($unparsed, $match, $action);
294			}
295			return true;
296			}
297
298			/**
299			* Escapes regex characters other than (, ) and /
300			*
301			* @param string $str
302			* @return string
303			*/
304			public static function escape($str)
305			{
306			$chars = array(
307			'/\\\\/',
308			'/\./',
309			'/\+/',
310			'/\*/',
311			'/\?/',
312			'/\[/',
313			'/\^/',
314			'/\]/',
315			'/\$/',
316			'/\{/',
317			'/\}/',
318			'/\=/',
319			'/\!/',
320			'/\</',
321			'/\>/',
322			'/\\|/',
323			'/\:/'
324			);
325
326			$escaped = array(
327			'\\\\\\\\',
328			'\.',
329			'\+',
330			'\*',
331			'\?',
332			'\[',
333			'\^',
334			'\]',
335			'\$',
336			'\{',
337			'\}',
338			'\=',
339			'\!',
340			'\<',
341			'\>',
342			'\\|',
343			'\:'
344			);
345			return preg_replace($chars, $escaped, $str);
346			}
347			}
348

splitbrain / dokuwiki

Push — psr2-config ( c6639e )

Lexer::escape() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like