Nuglif\Nacl\Lexer::getRules()

Complexity

Conditions	15
Paths	1

Size

Total Lines	117
Code Lines	85

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	94
CRAP Score	15.002

Importance

Changes	2
Bugs	0	Features	0

<?php
    protected function getRules(): array
    {
        return [
            self::STATE_INITIAL => [
                self::REGEX_SPACE      => false,
                self::REGEX_COMMENT    => false,
                self::REGEX_COMMENT_ML => function () {
                    $pos = strpos($this->content, '*/', $this->count);
                    if (false === $pos) {
                        $this->line += substr_count(substr($this->content, $this->count), "\n");
                        $this->error('Unterminated multiline comment');
                    }
                    $this->line += substr_count(substr($this->content, $this->count, (int) $pos - $this->count + 2), "\n");
                    $this->count = (int) $pos + 2;
                },
                self::REGEX_DQUOTE => function (): void {
                    $this->begin(self::STATE_INSTRING);
                    $this->textBuffer = '';
                },
                self::REGEX_BOOL => function (mixed &$yylval): int {
                    $yylval = TypeCaster::toBool($yylval);

                    return Token::T_BOOL;
                },
                self::REGEX_NULL => function (mixed &$yylval): int {
                    $yylval = null;

                    return Token::T_NULL;
                },
                self::REGEX_NUM => function (mixed &$yylval): int {
                    $yylval = TypeCaster::toNum($yylval);

                    return Token::T_NUM;
                },
                self::REGEX_NAME => fn() => Token::T_NAME,
                self::REGEX_HEREDOC => function (mixed &$yylval): int {
                    $needle = "\n" . $yylval;
                    $pos = strpos($this->content, $needle, $this->count);
                    if (false === $pos) {
                        $this->line += substr_count(substr($this->content, $this->count), "\n");
                        $this->error('Unterminated HEREDOC');
                    }

                    $yylval = substr($this->content, $this->count, (int) $pos - $this->count);
                    $this->line += substr_count($yylval, "\n") + 1;
                    $this->count += strlen($yylval) + strlen($needle);

                    return Token::T_END_STR;
                },
                self::REGEX_TOKEN => fn(mixed $yylval): string => $yylval,
                self::REGEX_VAR => fn(): int => Token::T_VAR,
                self::REGEX_ANY => function (mixed $yylval): void {
                    $this->error('Unexpected char \'' . $yylval . '\'');
                },
                self::EOF => fn(): int => Token::T_EOF,
            ],
            self::STATE_INSTRING => [
                '[^\\\"$]+' => function (mixed &$yylval) {
                    $this->textBuffer .= $yylval;
                    if ('$' == substr($this->content, $this->count, 1)) {
                        $yylval = $this->textBuffer;
                        $this->textBuffer = '';

                        return Token::T_STRING;
                    }
                },
                '?:\\\(.)' => function (mixed $yylval) {
                    switch ($yylval) {
                        case 'n':
                            $this->textBuffer .= "\n";
                            break;
                        case 't':
                            $this->textBuffer .= "\t";
                            break;
                        case '\\':
                        case '/':
                        case '"':
                            $this->textBuffer .= $yylval;
                            break;
                        case 'u':
                            $utfCode = substr($this->content, $this->count, 4);
                            if (preg_match('/[A-Fa-f0-9]{4,4}/', $utfCode)) {
                                $utf = hexdec($utfCode);
                                $this->count += 4;
                                // UTF-32 ?
                                if ($utf >= 0xD800 && $utf <= 0xDBFF && preg_match('/^\\\\u[dD][c-fC-F][0-9a-fA-F][0-9a-fA-F]/', substr($this->content, $this->count, 6), $matches)) {
                                    $utf_hi = hexdec(substr($matches[0], -4));
                                    $utf = (($utf & 0x3FF) << 10) + ($utf_hi & 0x3FF) + 0x10000;
                                    $this->count += 6;
                                }
                                $this->textBuffer .= $this->fromCharCode($utf);

It seems like $utf can also be of type double; however, parameter $bytes of Nuglif\Nacl\Lexer::fromCharCode() does only seem to accept integer, maybe add an additional type check?

                                break;
                            }
                            /* no break */
                        default:
                            $this->textBuffer .= '\\' . $yylval;
                            break;
                    }
                },
                '\$' => function (mixed &$yylval) {
                    if (preg_match('/^{([A-Za-z0-9_]+)}/', substr($this->content, $this->count), $matches)) {
                        $this->count += strlen($matches[0]);
                        $yylval = $matches[1];

                        return Token::T_ENCAPSED_VAR;
                    }

                    $this->textBuffer .= $yylval;
                },
                self::REGEX_DQUOTE => function (mixed &$yylval) {
                    $yylval = $this->textBuffer;
                    $this->begin(self::STATE_INITIAL);

                    return Token::T_END_STR;
                },
                self::EOF => function () {
                    $this->error('Unterminated string');
                },