TokenReader::readBlockString() - Code Metrics - Inspection of "WIP: Lexer unit tests" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#184)

by Christoffer

created 2018-04-07 20:35 UTC

TokenReader::readBlockString() C

↳ Parent: TokenReader

Complexity

Conditions	7
Paths	5

Size

Total Lines	40
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	40
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	27
nc	5
nop	6

<?php

namespace Digia\GraphQL\Language;

use Digia\GraphQL\Error\SyntaxErrorException;

class TokenReader implements TokenReaderInterface
{

    /**
     * The lexer owning this token reader.
     *
     * @var LexerInterface
     */
    protected $lexer;

    /**
     * @inheritdoc
     */
    public function setLexer(LexerInterface $lexer)
    {
        $this->lexer = $lexer;
        return $this;
    }

    /**
     * @inheritdoc
     */
    public function getLexer(): LexerInterface
    {
        return $this->lexer;
    }

    /**
     * @inheritdoc
     * @throws SyntaxErrorException
     */
    public function read(string $body, int $bodyLength, int $code, int $pos, int $line, int $col, Token $prev): ?Token
    {
        switch ($code) {
            case 33: // !
                return $this->readBang($pos, $line, $col, $prev);
            case 35: // #
                return $this->readComment($pos, $line, $col, $prev);
            case 36: // $
                return $this->readDollar($pos, $line, $col, $prev);
            case 38: // &
                return $this->readAmp($pos, $line, $col, $prev);
            case 58: // :
                return $this->readColon($pos, $line, $col, $prev);
            case 61: // =
                return $this->readEquals($pos, $line, $col, $prev);
            case 64: // @
                return $this->readAt($pos, $line, $col, $prev);
            case 124: // |
                return $this->readPipe($pos, $line, $col, $prev);
            case 40:
            case 41: // ( or )~
                return $this->readParenthesis($code, $pos, $line, $col, $prev);
            case 91:
            case 93: // [ or ]
                return $this->readBracket($code, $pos, $line, $col, $prev);
            case 123:
            case 125: // { or }
                return $this->readBrace($code, $pos, $line, $col, $prev);
        }

        // Int:   -?(0|[1-9][0-9]*)
        // Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
        if ($code === 45 || isNumber($code)) {
            return $this->readNumber($code, $pos, $line, $col, $prev);
        }

        // Name: [_A-Za-z][_0-9A-Za-z]*
        if (isAlphaNumeric($code)) {
            return $this->readName($body, $bodyLength, $pos, $line, $col, $prev);
        }

        // Spread: ...
        if ($bodyLength >= 3 && isSpread($body, $code, $pos)) {
            return $this->readSpread($pos, $line, $col, $prev);
        }

        // String: "([^"\\\u000A\u000D]|(\\(u[0-9a-fA-F]{4}|["\\/bfnrt])))*"
        if (isString($body, $code, $pos)) {
            return $this->readString($body, $bodyLength, $pos, $line, $col, $prev);
        }

        // Block String: """("?"?(\\"""|\\(?!=""")|[^"\\]))*"""
        if ($bodyLength >= 3 && isTripleQuote($body, $code, $pos)) {
            return $this->readBlockString($body, $bodyLength, $pos, $line, $col, $prev);
        }

        return null;
    }

    /**
     * @param string $body
     * @param int    $bodyLength
     * @param int    $pos
     * @param int    $line
     * @param int    $col
     * @param Token  $prev
     * @return Token
     */
    protected function readName(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
    {
        $start = $pos;
        $pos   = $start + 1;

        while ($pos !== $bodyLength && ($code = charCodeAt($body, $pos)) !== null && isAlphaNumeric($code)) {
            ++$pos;
        }

        return new Token(TokenKindEnum::NAME, $start, $pos, $line, $col, $prev, sliceString($body, $start, $pos));
    }

    /**
     * @param string $body
     * @param int    $bodyLength
     * @param int    $pos
     * @param int    $line
     * @param int    $col
     * @param Token  $prev
     * @return Token
     * @throws SyntaxErrorException
     */
    protected function readBlockString(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
    {
        $start      = $pos;
        $pos        = $start + 3;
        $chunkStart = $pos;
        $rawValue   = '';

        while ($pos < $bodyLength && ($code = charCodeAt($body, $pos)) !== null) {
            // Closing Triple-Quote (""")
            if (isTripleQuote($body, $code, $pos)) {
                $rawValue .= sliceString($body, $chunkStart, $pos);
                return new Token(
                    TokenKindEnum::BLOCK_STRING,
                    $start,
                    $pos + 3,
                    $line,
                    $col,
                    $prev,
                    blockStringValue($rawValue)
                );
            }

            if (isSourceCharacter($code) && !isLineTerminator($code)) {
                throw new SyntaxErrorException(
                    $this->lexer->getSource(),
                    $pos,
                    \sprintf('Invalid character within String: %s.', printCharCode($code))
                );
            }

            if (isEscapedTripleQuote($body, $code, $pos)) {
                $rawValue   .= sliceString($body, $chunkStart, $pos) . '"""';
                $pos        += 4;
                $chunkStart = $pos;
            } else {
                ++$pos;
            }
        }

        throw new SyntaxErrorException($this->lexer->getSource(), $pos, 'Unterminated string.');
    }

    /**
     * @param int   $code
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     * @throws SyntaxErrorException
     */
    protected function readNumber(int $code, int $pos, int $line, int $col, Token $prev): Token
    {
        $body    = $this->lexer->getBody();
        $start   = $pos;
        $isFloat = false;

        if ($code === 45) {
            // -
            $code = charCodeAt($body, ++$pos);
        }

        if ($code === 48) {
            // 0
            $code = charCodeAt($body, ++$pos);
            if (isNumber($code)) {
                throw new SyntaxErrorException(
                    $this->lexer->getSource(),
                    $pos,
                    \sprintf('Invalid number, unexpected digit after 0: %s.', printCharCode($code))
                );
            }
        } else {
            $pos  = $this->readDigits($code, $pos);
            $code = charCodeAt($body, $pos);
        }

        if ($code === 46) {
            // .
            $isFloat = true;
            $code    = charCodeAt($body, ++$pos);
            $pos     = $this->readDigits($code, $pos);
            $code    = charCodeAt($body, $pos);
        }

        if ($code === 69 || $code === 101) {
            // e or E
            $isFloat = true;
            $code    = charCodeAt($body, ++$pos);

            if ($code === 43 || $code === 45) {
                // + or -
                $code = charCodeAt($body, ++$pos);
            }

            $pos = $this->readDigits($code, $pos);
        }

        return new Token(
            $isFloat ? TokenKindEnum::FLOAT : TokenKindEnum::INT,
            $start,
            $pos,
            $line,
            $col,
            $prev,
            sliceString($body, $start, $pos)
        );
    }

    /**
     * @param string $body
     * @param int    $bodyLength
     * @param int    $pos
     * @param int    $line
     * @param int    $col
     * @param Token  $prev
     * @return Token
     * @throws SyntaxErrorException
     */
    protected function readString(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
    {
        $start      = $pos;
        $pos        = $start + 1;
        $chunkStart = $pos;
        $value      = '';
        while ($pos < $bodyLength && ($code = charCodeAt($body, $pos)) !== null && !isLineTerminator($code)) {
            // Closing Quote (")
            if ($code === 34) {
                $value .= sliceString($body, $chunkStart, $pos);
                return new Token(TokenKindEnum::STRING, $start, $pos + 1, $line, $col, $prev, $value);
            }

            if (isSourceCharacter($code)) {
                throw new SyntaxErrorException(
                    $this->lexer->getSource(),
                    $pos,
                    \sprintf('Invalid character within String: %s', printCharCode($code))
                );
            }

            ++$pos;

            if ($code === 92) {
                // \
                $value .= sliceString($body, $chunkStart, $pos - 1);
                $code  = charCodeAt($body, $pos);

                switch ($code) {
                    case 34:
                        $value .= '"';
                        break;
                    case 47:
                        $value .= '/';
                        break;
                    case 92:
                        $value .= '\\';
                        break;
                    case 98:
                        $value .= '\b';
                        break;
                    case 102:
                        $value .= '\f';
                        break;
                    case 110:
                        $value .= '\n';
                        break;
                    case 114:
                        $value .= '\r';
                        break;
                    case 116:
                        $value .= '\t';
                        break;
                    case 117:
                        // u
                        $unicodeString = sliceString($body, $pos - 1, $pos + 5);
                        $charCode      = uniCharCode(
                            charCodeAt($body, $pos + 1),
                            charCodeAt($body, $pos + 2),
                            charCodeAt($body, $pos + 3),
                            charCodeAt($body, $pos + 4)
                        );
                        if ($charCode < 0) {
                            throw new SyntaxErrorException(
                                $this->lexer->getSource(),
                                $pos,
                                \sprintf('Invalid character escape sequence: %s.', $unicodeString)
                            );
                        }
                        $value .= $unicodeString;
                        $pos   += 4;
                        break;
                    default:
                        throw new SyntaxErrorException(
                            $this->lexer->getSource(),
                            $pos,
                            \sprintf('Invalid character escape sequence: \\%s.', \chr($code))
                        );
                }

                ++$pos;

                $chunkStart = $pos;
            }
        }

        throw new SyntaxErrorException($this->lexer->getSource(), $pos, 'Unterminated string.');
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readSpread(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::SPREAD, $pos, $pos + 3, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readDollar(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::DOLLAR, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readPipe(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::PIPE, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $code
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readParenthesis(int $code, int $pos, int $line, int $col, Token $prev): Token
    {
        return $code === 40
            ? new Token(TokenKindEnum::PAREN_L, $pos, $pos + 1, $line, $col, $prev)
            : new Token(TokenKindEnum::PAREN_R, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readEquals(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::EQUALS, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readAt(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::AT, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readComment(int $pos, int $line, int $col, Token $prev): Token
    {
        $body  = $this->lexer->getBody();
        $start = $pos;

        do {
            $code = charCodeAt($body, ++$pos);
        } while ($code !== null && ($code > 0x001f || $code === 0x0009)); // SourceCharacter but not LineTerminator

        return new Token(
            TokenKindEnum::COMMENT,
            $start,
            $pos,
            $line,
            $col,
            $prev,
            sliceString($body, $start + 1, $pos)
        );
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readColon(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::COLON, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readAmp(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::AMP, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readBang(int $pos, int $line, int $col, Token $prev): Token
    {
        return new Token(TokenKindEnum::BANG, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $code
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readBrace(int $code, int $pos, int $line, int $col, Token $prev): Token
    {
        return $code === 123
            ? new Token(TokenKindEnum::BRACE_L, $pos, $pos + 1, $line, $col, $prev)
            : new Token(TokenKindEnum::BRACE_R, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int   $code
     * @param int   $pos
     * @param int   $line
     * @param int   $col
     * @param Token $prev
     * @return Token
     */
    protected function readBracket(int $code, int $pos, int $line, int $col, Token $prev): Token
    {
        return $code === 91
            ? new Token(TokenKindEnum::BRACKET_L, $pos, $pos + 1, $line, $col, $prev)
            : new Token(TokenKindEnum::BRACKET_R, $pos, $pos + 1, $line, $col, $prev);
    }

    /**
     * @param int $code
     * @param int $pos
     * @return int
     * @throws SyntaxErrorException
     */
    protected function readDigits(int $code, int $pos): int
    {
        $body = $this->lexer->getBody();

        if (isNumber($code)) {
            do {
                $code = charCodeAt($body, ++$pos);
            } while (isNumber($code));

            return $pos;
        }

        throw new SyntaxErrorException(
            $this->lexer->getSource(),
            $pos,
            sprintf('Invalid number, expected digit but got: %s.', printCharCode($code))
        );
    }
}


1			<?php
2
3			namespace Digia\GraphQL\Language;
4
5			use Digia\GraphQL\Error\SyntaxErrorException;
6
7			class TokenReader implements TokenReaderInterface
8			{
9
10			/**
11			* The lexer owning this token reader.
12			*
13			* @var LexerInterface
14			*/
15			protected $lexer;
16
17			/**
18			* @inheritdoc
19			*/
20			public function setLexer(LexerInterface $lexer)
21			{
22			$this->lexer = $lexer;
23			return $this;
24			}
25
26			/**
27			* @inheritdoc
28			*/
29			public function getLexer(): LexerInterface
30			{
31			return $this->lexer;
32			}
33
34			/**
35			* @inheritdoc
36			* @throws SyntaxErrorException
37			*/
38			public function read(string $body, int $bodyLength, int $code, int $pos, int $line, int $col, Token $prev): ?Token
39			{
40			switch ($code) {
41			case 33: // !
42			return $this->readBang($pos, $line, $col, $prev);
43			case 35: // #
44			return $this->readComment($pos, $line, $col, $prev);
45			case 36: // $
46			return $this->readDollar($pos, $line, $col, $prev);
47			case 38: // &
48			return $this->readAmp($pos, $line, $col, $prev);
49			case 58: // :
50			return $this->readColon($pos, $line, $col, $prev);
51			case 61: // =
52			return $this->readEquals($pos, $line, $col, $prev);
53			case 64: // @
54			return $this->readAt($pos, $line, $col, $prev);
55			case 124: // \|
56			return $this->readPipe($pos, $line, $col, $prev);
57			case 40:
58			case 41: // ( or )~
59			return $this->readParenthesis($code, $pos, $line, $col, $prev);
60			case 91:
61			case 93: // [ or ]
62			return $this->readBracket($code, $pos, $line, $col, $prev);
63			case 123:
64			case 125: // { or }
65			return $this->readBrace($code, $pos, $line, $col, $prev);
66			}
67
68			// Int: -?(0\|[1-9][0-9]*)
69			// Float: -?(0\|[1-9][0-9]*)(\.[0-9]+)?((E\|e)(+\|-)?[0-9]+)?
70			if ($code === 45 \|\| isNumber($code)) {
71			return $this->readNumber($code, $pos, $line, $col, $prev);
72			}
73
74			// Name: [_A-Za-z][_0-9A-Za-z]*
75			if (isAlphaNumeric($code)) {
76			return $this->readName($body, $bodyLength, $pos, $line, $col, $prev);
77			}
78
79			// Spread: ...
80			if ($bodyLength >= 3 && isSpread($body, $code, $pos)) {
81			return $this->readSpread($pos, $line, $col, $prev);
82			}
83
84			// String: "([^"\\\u000A\u000D]\|(\\(u[0-9a-fA-F]{4}\|["\\/bfnrt])))*"
85			if (isString($body, $code, $pos)) {
86			return $this->readString($body, $bodyLength, $pos, $line, $col, $prev);
87			}
88
89			// Block String: """("?"?(\\"""\|\\(?!=""")\|[^"\\]))*"""
90			if ($bodyLength >= 3 && isTripleQuote($body, $code, $pos)) {
91			return $this->readBlockString($body, $bodyLength, $pos, $line, $col, $prev);
92			}
93
94			return null;
95			}
96
97			/**
98			* @param string $body
99			* @param int $bodyLength
100			* @param int $pos
101			* @param int $line
102			* @param int $col
103			* @param Token $prev
104			* @return Token
105			*/
106			protected function readName(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
107			{
108			$start = $pos;
109			$pos = $start + 1;
110
111			while ($pos !== $bodyLength && ($code = charCodeAt($body, $pos)) !== null && isAlphaNumeric($code)) {
112			++$pos;
113			}
114
115			return new Token(TokenKindEnum::NAME, $start, $pos, $line, $col, $prev, sliceString($body, $start, $pos));
116			}
117
118			/**
119			* @param string $body
120			* @param int $bodyLength
121			* @param int $pos
122			* @param int $line
123			* @param int $col
124			* @param Token $prev
125			* @return Token
126			* @throws SyntaxErrorException
127			*/
128			protected function readBlockString(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
129			{
130			$start = $pos;
131			$pos = $start + 3;
132			$chunkStart = $pos;
133			$rawValue = '';
134
135			while ($pos < $bodyLength && ($code = charCodeAt($body, $pos)) !== null) {
136			// Closing Triple-Quote (""")
137			if (isTripleQuote($body, $code, $pos)) {
138			$rawValue .= sliceString($body, $chunkStart, $pos);
139			return new Token(
140			TokenKindEnum::BLOCK_STRING,
141			$start,
142			$pos + 3,
143			$line,
144			$col,
145			$prev,
146			blockStringValue($rawValue)
147			);
148			}
149
150			if (isSourceCharacter($code) && !isLineTerminator($code)) {
151			throw new SyntaxErrorException(
152			$this->lexer->getSource(),
153			$pos,
154			\sprintf('Invalid character within String: %s.', printCharCode($code))
155			);
156			}
157
158			if (isEscapedTripleQuote($body, $code, $pos)) {
159			$rawValue .= sliceString($body, $chunkStart, $pos) . '"""';
160			$pos += 4;
161			$chunkStart = $pos;
162			} else {
163			++$pos;
164			}
165			}
166
167			throw new SyntaxErrorException($this->lexer->getSource(), $pos, 'Unterminated string.');
168			}
169
170			/**
171			* @param int $code
172			* @param int $pos
173			* @param int $line
174			* @param int $col
175			* @param Token $prev
176			* @return Token
177			* @throws SyntaxErrorException
178			*/
179			protected function readNumber(int $code, int $pos, int $line, int $col, Token $prev): Token
180			{
181			$body = $this->lexer->getBody();
182			$start = $pos;
183			$isFloat = false;
184
185			if ($code === 45) {
186			// -
187			$code = charCodeAt($body, ++$pos);
188			}
189
190			if ($code === 48) {
191			// 0
192			$code = charCodeAt($body, ++$pos);
193			if (isNumber($code)) {
194			throw new SyntaxErrorException(
195			$this->lexer->getSource(),
196			$pos,
197			\sprintf('Invalid number, unexpected digit after 0: %s.', printCharCode($code))
198			);
199			}
200			} else {
201			$pos = $this->readDigits($code, $pos);
202			$code = charCodeAt($body, $pos);
203			}
204
205			if ($code === 46) {
206			// .
207			$isFloat = true;
208			$code = charCodeAt($body, ++$pos);
209			$pos = $this->readDigits($code, $pos);
210			$code = charCodeAt($body, $pos);
211			}
212
213			if ($code === 69 \|\| $code === 101) {
214			// e or E
215			$isFloat = true;
216			$code = charCodeAt($body, ++$pos);
217
218			if ($code === 43 \|\| $code === 45) {
219			// + or -
220			$code = charCodeAt($body, ++$pos);
221			}
222
223			$pos = $this->readDigits($code, $pos);
224			}
225
226			return new Token(
227			$isFloat ? TokenKindEnum::FLOAT : TokenKindEnum::INT,
228			$start,
229			$pos,
230			$line,
231			$col,
232			$prev,
233			sliceString($body, $start, $pos)
234			);
235			}
236
237			/**
238			* @param string $body
239			* @param int $bodyLength
240			* @param int $pos
241			* @param int $line
242			* @param int $col
243			* @param Token $prev
244			* @return Token
245			* @throws SyntaxErrorException
246			*/
247			protected function readString(string $body, int $bodyLength, int $pos, int $line, int $col, Token $prev): Token
248			{
249			$start = $pos;
250			$pos = $start + 1;
251			$chunkStart = $pos;
252			$value = '';
253			while ($pos < $bodyLength && ($code = charCodeAt($body, $pos)) !== null && !isLineTerminator($code)) {
254			// Closing Quote (")
255			if ($code === 34) {
256			$value .= sliceString($body, $chunkStart, $pos);
257			return new Token(TokenKindEnum::STRING, $start, $pos + 1, $line, $col, $prev, $value);
258			}
259
260			if (isSourceCharacter($code)) {
261			throw new SyntaxErrorException(
262			$this->lexer->getSource(),
263			$pos,
264			\sprintf('Invalid character within String: %s', printCharCode($code))
265			);
266			}
267
268			++$pos;
269
270			if ($code === 92) {
271			// \
272			$value .= sliceString($body, $chunkStart, $pos - 1);
273			$code = charCodeAt($body, $pos);
274
275			switch ($code) {
276			case 34:
277			$value .= '"';
278			break;
279			case 47:
280			$value .= '/';
281			break;
282			case 92:
283			$value .= '\\';
284			break;
285			case 98:
286			$value .= '\b';
287			break;
288			case 102:
289			$value .= '\f';
290			break;
291			case 110:
292			$value .= '\n';
293			break;
294			case 114:
295			$value .= '\r';
296			break;
297			case 116:
298			$value .= '\t';
299			break;
300			case 117:
301			// u
302			$unicodeString = sliceString($body, $pos - 1, $pos + 5);
303			$charCode = uniCharCode(
304			charCodeAt($body, $pos + 1),
305			charCodeAt($body, $pos + 2),
306			charCodeAt($body, $pos + 3),
307			charCodeAt($body, $pos + 4)
308			);
309			if ($charCode < 0) {
310			throw new SyntaxErrorException(
311			$this->lexer->getSource(),
312			$pos,
313			\sprintf('Invalid character escape sequence: %s.', $unicodeString)
314			);
315			}
316			$value .= $unicodeString;
317			$pos += 4;
318			break;
319			default:
320			throw new SyntaxErrorException(
321			$this->lexer->getSource(),
322			$pos,
323			\sprintf('Invalid character escape sequence: \\%s.', \chr($code))
324			);
325			}
326
327			++$pos;
328
329			$chunkStart = $pos;
330			}
331			}
332
333			throw new SyntaxErrorException($this->lexer->getSource(), $pos, 'Unterminated string.');
334			}
335
336			/**
337			* @param int $pos
338			* @param int $line
339			* @param int $col
340			* @param Token $prev
341			* @return Token
342			*/
343			protected function readSpread(int $pos, int $line, int $col, Token $prev): Token
344			{
345			return new Token(TokenKindEnum::SPREAD, $pos, $pos + 3, $line, $col, $prev);
346			}
347
348			/**
349			* @param int $pos
350			* @param int $line
351			* @param int $col
352			* @param Token $prev
353			* @return Token
354			*/
355			protected function readDollar(int $pos, int $line, int $col, Token $prev): Token
356			{
357			return new Token(TokenKindEnum::DOLLAR, $pos, $pos + 1, $line, $col, $prev);
358			}
359
360			/**
361			* @param int $pos
362			* @param int $line
363			* @param int $col
364			* @param Token $prev
365			* @return Token
366			*/
367			protected function readPipe(int $pos, int $line, int $col, Token $prev): Token
368			{
369			return new Token(TokenKindEnum::PIPE, $pos, $pos + 1, $line, $col, $prev);
370			}
371
372			/**
373			* @param int $code
374			* @param int $pos
375			* @param int $line
376			* @param int $col
377			* @param Token $prev
378			* @return Token
379			*/
380			protected function readParenthesis(int $code, int $pos, int $line, int $col, Token $prev): Token
381			{
382			return $code === 40
383			? new Token(TokenKindEnum::PAREN_L, $pos, $pos + 1, $line, $col, $prev)
384			: new Token(TokenKindEnum::PAREN_R, $pos, $pos + 1, $line, $col, $prev);
385			}
386
387			/**
388			* @param int $pos
389			* @param int $line
390			* @param int $col
391			* @param Token $prev
392			* @return Token
393			*/
394			protected function readEquals(int $pos, int $line, int $col, Token $prev): Token
395			{
396			return new Token(TokenKindEnum::EQUALS, $pos, $pos + 1, $line, $col, $prev);
397			}
398
399			/**
400			* @param int $pos
401			* @param int $line
402			* @param int $col
403			* @param Token $prev
404			* @return Token
405			*/
406			protected function readAt(int $pos, int $line, int $col, Token $prev): Token
407			{
408			return new Token(TokenKindEnum::AT, $pos, $pos + 1, $line, $col, $prev);
409			}
410
411			/**
412			* @param int $pos
413			* @param int $line
414			* @param int $col
415			* @param Token $prev
416			* @return Token
417			*/
418			protected function readComment(int $pos, int $line, int $col, Token $prev): Token
419			{
420			$body = $this->lexer->getBody();
421			$start = $pos;
422
423			do {
424			$code = charCodeAt($body, ++$pos);
425			} while ($code !== null && ($code > 0x001f \|\| $code === 0x0009)); // SourceCharacter but not LineTerminator
426
427			return new Token(
428			TokenKindEnum::COMMENT,
429			$start,
430			$pos,
431			$line,
432			$col,
433			$prev,
434			sliceString($body, $start + 1, $pos)
435			);
436			}
437
438			/**
439			* @param int $pos
440			* @param int $line
441			* @param int $col
442			* @param Token $prev
443			* @return Token
444			*/
445			protected function readColon(int $pos, int $line, int $col, Token $prev): Token
446			{
447			return new Token(TokenKindEnum::COLON, $pos, $pos + 1, $line, $col, $prev);
448			}
449
450			/**
451			* @param int $pos
452			* @param int $line
453			* @param int $col
454			* @param Token $prev
455			* @return Token
456			*/
457			protected function readAmp(int $pos, int $line, int $col, Token $prev): Token
458			{
459			return new Token(TokenKindEnum::AMP, $pos, $pos + 1, $line, $col, $prev);
460			}
461
462			/**
463			* @param int $pos
464			* @param int $line
465			* @param int $col
466			* @param Token $prev
467			* @return Token
468			*/
469			protected function readBang(int $pos, int $line, int $col, Token $prev): Token
470			{
471			return new Token(TokenKindEnum::BANG, $pos, $pos + 1, $line, $col, $prev);
472			}
473
474			/**
475			* @param int $code
476			* @param int $pos
477			* @param int $line
478			* @param int $col
479			* @param Token $prev
480			* @return Token
481			*/
482			protected function readBrace(int $code, int $pos, int $line, int $col, Token $prev): Token
483			{
484			return $code === 123
485			? new Token(TokenKindEnum::BRACE_L, $pos, $pos + 1, $line, $col, $prev)
486			: new Token(TokenKindEnum::BRACE_R, $pos, $pos + 1, $line, $col, $prev);
487			}
488
489			/**
490			* @param int $code
491			* @param int $pos
492			* @param int $line
493			* @param int $col
494			* @param Token $prev
495			* @return Token
496			*/
497			protected function readBracket(int $code, int $pos, int $line, int $col, Token $prev): Token
498			{
499			return $code === 91
500			? new Token(TokenKindEnum::BRACKET_L, $pos, $pos + 1, $line, $col, $prev)
501			: new Token(TokenKindEnum::BRACKET_R, $pos, $pos + 1, $line, $col, $prev);
502			}
503
504			/**
505			* @param int $code
506			* @param int $pos
507			* @return int
508			* @throws SyntaxErrorException
509			*/
510			protected function readDigits(int $code, int $pos): int
511			{
512			$body = $this->lexer->getBody();
513
514			if (isNumber($code)) {
515			do {
516			$code = charCodeAt($body, ++$pos);
517			} while (isNumber($code));
518
519			return $pos;
520			}
521
522			throw new SyntaxErrorException(
523			$this->lexer->getSource(),
524			$pos,
525			sprintf('Invalid number, expected digit but got: %s.', printCharCode($code))
526			);
527			}
528			}
529

digiaonline / graphql-php

Pull Request — master (#184)

TokenReader::readBlockString() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like