Utils::characterValue() - Code Metrics - Inspection of "Improve the code" - stenin-nikita/PHP-Yacc - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 77aa03...453f7d )

by Nikita

created 2018-02-04 20:22 UTC

Utils::characterValue() C

↳ Parent: Utils

Complexity

Conditions	14
Paths	12

Size

Total Lines	44
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	31
nc	12
nop	1
dl	0
loc	44
rs	5.0864
c	0
b	0
f	0

How to fix Complexity

<?php
/**
 * This file is part of Yacc package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace PhpYacc\Support;
use PhpYacc\Compress\Compress;
use PhpYacc\Grammar\Context;
use PhpYacc\Lalr\BitSet;
use PhpYacc\Lalr\Lr1;

/**
 * Class Utils.
 */
final class Utils
{
    /**
     * @param string $char
     *
     * @return bool
     */
    public static function isWhite(string $char): bool
    {
        return $char === ' ' || $char === "\t" || $char === "\r" || $char === "\x0b" || $char === "\x0c";
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    public static function isSymChar(string $char): bool
    {
        return ctype_alnum($char) || $char === '_';
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    public static function isOctal(string $char): bool
    {
        $n = \ord($char);

        return $n >= 48 && $n <= 55;
    }

    /**
     * @param string $string
     *
     * @return int
     */
    public static function characterValue(string $string): int
    {
        $n = 0;
        $length = \mb_strlen($string);

        if ($length === 0) {
            return 0;
        }

        $c = $string[$n++];

        if ($c !== '\\') {
            return \ord($c);
        }

        $c = $string[$n++];
        if (self::isOctal($c)) {
            $value = (int) $c;
            for ($i = 0; $n < $length && self::isOctal($string[$n]) && $i < 3; $i++) {
                $value = $value * 8 + $string[$n++];
            }

            return $value;
        }

        switch ($c) {
            case 'n':
                return \ord("\n");
            case 't':
                return \ord("\t");
            case 'b':
                return \ord("\x08");
            case 'r':
                return \ord("\r");
            case 'f':
                return \ord("\x0C");
            case 'v':
                return \ord("\x0B");
            case 'a':
                return \ord("\x07");
            default:
                return \ord($c);
        }
    }

    /**
     * @param array    $array
     * @param callable $cmp
     */
    public static function stableSort(array &$array, callable $cmp)
    {
        $indexedArray = [];
        $i = 0;
        foreach ($array as $item) {
            $indexedArray[] = [$item, $i++];
        }

        \usort($indexedArray, function (array $a, array $b) use ($cmp) {
            $result = $cmp($a[0], $b[0]);
            if ($result !== 0) {
                return $result;
            }

            return $a[1] - $b[1];
        });

        $array = [];
        foreach ($indexedArray as $item) {
            $array[] = $item[0];
        }
    }

    /**
     * @param array $array
     * @param int $length
     * @return bool
     */
    public static function vacantRow(array $array, int $length): bool
    {
        for ($i = 0; $i < $length; $i++) {
            if ($array[$i] !== Compress::VACANT) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param array $a
     * @param array $b
     * @param int $length
     * @return bool
     */
    public static function eqRow(array $a, array $b, int $length): bool
    {
        for ($i = 0; $i < $length; $i++) {
            if ($a[$i] !== $b[$i]) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param int $action
     * @return string
     */
    public static function printAction(int $action): string
    {
        if ($action === Compress::VACANT) {
            return '  . ';
        }

        return \sprintf('%4d', $action);
    }

    /**
     * @param Lr1|null $left
     * @param Lr1|null $right
     * @return bool
     */
    public static function isSameSet(Lr1 $left = null, Lr1 $right = null): bool
    {
        $p = $left;
        $t = $right;
        while ($t !== null) {
            // Not using !== here intentionally
            if ($p === null || $p->item != $t->item) {
                return false;
            }
            $p = $p->next;
            $t = $t->next;
        }
        return $p === null || $p->isHeadItem();
    }

    /**
     * @param Context $ctx
     * @param BitSet $set
     * @return string
     */
    public static function dumpSet(Context $ctx, BitSet $set): string
    {
        $result = '';
        foreach ($set as $code) {
            $symbol = $ctx->symbols[$code];
            $result .= "{$symbol->name} ";
        }

        return $result;
    }
}


1			<?php
2			/**
3			* This file is part of Yacc package.
4			*
5			* For the full copyright and license information, please view the LICENSE
6			* file that was distributed with this source code.
7			*/
8			declare(strict_types=1);
9
10			namespace PhpYacc\Support;
11			use PhpYacc\Compress\Compress;
12			use PhpYacc\Grammar\Context;
13			use PhpYacc\Lalr\BitSet;
14			use PhpYacc\Lalr\Lr1;
15
16			/**
17			* Class Utils.
18			*/
19			final class Utils
20			{
21			/**
22			* @param string $char
23			*
24			* @return bool
25			*/
26			public static function isWhite(string $char): bool
27			{
28			return $char === ' ' \|\| $char === "\t" \|\| $char === "\r" \|\| $char === "\x0b" \|\| $char === "\x0c";
29			}
30
31			/**
32			* @param string $char
33			*
34			* @return bool
35			*/
36			public static function isSymChar(string $char): bool
37			{
38			return ctype_alnum($char) \|\| $char === '_';
39			}
40
41			/**
42			* @param string $char
43			*
44			* @return bool
45			*/
46			public static function isOctal(string $char): bool
47			{
48			$n = \ord($char);
49
50			return $n >= 48 && $n <= 55;
51			}
52
53			/**
54			* @param string $string
55			*
56			* @return int
57			*/
58			public static function characterValue(string $string): int
59			{
60			$n = 0;
61			$length = \mb_strlen($string);
62
63			if ($length === 0) {
64			return 0;
65			}
66
67			$c = $string[$n++];
68
69			if ($c !== '\\') {
70			return \ord($c);
71			}
72
73			$c = $string[$n++];
74			if (self::isOctal($c)) {
75			$value = (int) $c;
76			for ($i = 0; $n < $length && self::isOctal($string[$n]) && $i < 3; $i++) {
77			$value = $value * 8 + $string[$n++];
78			}
79
80			return $value;
81			}
82
83			switch ($c) {
84			case 'n':
85			return \ord("\n");
86			case 't':
87			return \ord("\t");
88			case 'b':
89			return \ord("\x08");
90			case 'r':
91			return \ord("\r");
92			case 'f':
93			return \ord("\x0C");
94			case 'v':
95			return \ord("\x0B");
96			case 'a':
97			return \ord("\x07");
98			default:
99			return \ord($c);
100			}
101			}
102
103			/**
104			* @param array $array
105			* @param callable $cmp
106			*/
107			public static function stableSort(array &$array, callable $cmp)
108			{
109			$indexedArray = [];
110			$i = 0;
111			foreach ($array as $item) {
112			$indexedArray[] = [$item, $i++];
113			}
114
115			\usort($indexedArray, function (array $a, array $b) use ($cmp) {
116			$result = $cmp($a[0], $b[0]);
117			if ($result !== 0) {
118			return $result;
119			}
120
121			return $a[1] - $b[1];
122			});
123
124			$array = [];
125			foreach ($indexedArray as $item) {
126			$array[] = $item[0];
127			}
128			}
129
130			/**
131			* @param array $array
132			* @param int $length
133			* @return bool
134			*/
135			public static function vacantRow(array $array, int $length): bool
136			{
137			for ($i = 0; $i < $length; $i++) {
138			if ($array[$i] !== Compress::VACANT) {
139			return false;
140			}
141			}
142
143			return true;
144			}
145
146			/**
147			* @param array $a
148			* @param array $b
149			* @param int $length
150			* @return bool
151			*/
152			public static function eqRow(array $a, array $b, int $length): bool
153			{
154			for ($i = 0; $i < $length; $i++) {
155			if ($a[$i] !== $b[$i]) {
156			return false;
157			}
158			}
159
160			return true;
161			}
162
163			/**
164			* @param int $action
165			* @return string
166			*/
167			public static function printAction(int $action): string
168			{
169			if ($action === Compress::VACANT) {
170			return ' . ';
171			}
172
173			return \sprintf('%4d', $action);
174			}
175
176			/**
177			* @param Lr1\|null $left
178			* @param Lr1\|null $right
179			* @return bool
180			*/
181			public static function isSameSet(Lr1 $left = null, Lr1 $right = null): bool
182			{
183			$p = $left;
184			$t = $right;
185			while ($t !== null) {
186			// Not using !== here intentionally
187			if ($p === null \|\| $p->item != $t->item) {
188			return false;
189			}
190			$p = $p->next;
191			$t = $t->next;
192			}
193			return $p === null \|\| $p->isHeadItem();
194			}
195
196			/**
197			* @param Context $ctx
198			* @param BitSet $set
199			* @return string
200			*/
201			public static function dumpSet(Context $ctx, BitSet $set): string
202			{
203			$result = '';
204			foreach ($set as $code) {
205			$symbol = $ctx->symbols[$code];
206			$result .= "{$symbol->name} ";
207			}
208
209			return $result;
210			}
211			}
212

stenin-nikita / PHP-Yacc

Push — master ( 77aa03...453f7d )

Utils::characterValue() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like