mirror of
https://github.com/retailcrm/graphql-php.git
synced 2025-02-14 19:43:13 +03:00
348 lines
11 KiB
PHP
348 lines
11 KiB
PHP
<?php
|
|
namespace GraphQL\Language;
|
|
|
|
use GraphQL\SyntaxError;
|
|
use GraphQL\Utils;
|
|
|
|
// language/lexer.js
|
|
|
|
class Lexer
|
|
{
|
|
/**
|
|
* @var int
|
|
*/
|
|
private $prevPosition;
|
|
|
|
/**
|
|
* @var Source
|
|
*/
|
|
private $source;
|
|
|
|
public function __construct(Source $source)
|
|
{
|
|
$this->prevPosition = 0;
|
|
$this->source = $source;
|
|
}
|
|
|
|
/**
|
|
* @param int|null $resetPosition
|
|
* @return Token
|
|
*/
|
|
public function nextToken($resetPosition = null)
|
|
{
|
|
$token = $this->readToken($resetPosition === null ? $this->prevPosition : $resetPosition);
|
|
$this->prevPosition = $token->end;
|
|
return $token;
|
|
}
|
|
|
|
/**
|
|
* @param int $fromPosition
|
|
* @return Token
|
|
* @throws SyntaxError
|
|
*/
|
|
private function readToken($fromPosition)
|
|
{
|
|
$body = $this->source->body;
|
|
$bodyLength = $this->source->length;
|
|
|
|
$position = $this->positionAfterWhitespace($body, $fromPosition);
|
|
|
|
if ($position >= $bodyLength) {
|
|
return new Token(Token::EOF, $position, $position);
|
|
}
|
|
|
|
$code = Utils::charCodeAt($body, $position);
|
|
|
|
// SourceCharacter
|
|
if ($code < 0x0020 && $code !== 0x0009 && $code !== 0x000A && $code !== 0x000D) {
|
|
throw new SyntaxError($this->source, $position, 'Invalid character ' . Utils::printCharCode($code));
|
|
}
|
|
|
|
switch ($code) {
|
|
// !
|
|
case 33: return new Token(Token::BANG, $position, $position + 1);
|
|
// $
|
|
case 36: return new Token(Token::DOLLAR, $position, $position + 1);
|
|
// (
|
|
case 40: return new Token(Token::PAREN_L, $position, $position + 1);
|
|
// )
|
|
case 41: return new Token(Token::PAREN_R, $position, $position + 1);
|
|
// .
|
|
case 46:
|
|
if (Utils::charCodeAt($body, $position+1) === 46 &&
|
|
Utils::charCodeAt($body, $position+2) === 46) {
|
|
return new Token(Token::SPREAD, $position, $position + 3);
|
|
}
|
|
break;
|
|
// :
|
|
case 58: return new Token(Token::COLON, $position, $position + 1);
|
|
// =
|
|
case 61: return new Token(Token::EQUALS, $position, $position + 1);
|
|
// @
|
|
case 64: return new Token(Token::AT, $position, $position + 1);
|
|
// [
|
|
case 91: return new Token(Token::BRACKET_L, $position, $position + 1);
|
|
// ]
|
|
case 93: return new Token(Token::BRACKET_R, $position, $position + 1);
|
|
// {
|
|
case 123: return new Token(Token::BRACE_L, $position, $position + 1);
|
|
// |
|
|
case 124: return new Token(Token::PIPE, $position, $position + 1);
|
|
// }
|
|
case 125: return new Token(Token::BRACE_R, $position, $position + 1);
|
|
// A-Z
|
|
case 65: case 66: case 67: case 68: case 69: case 70: case 71: case 72:
|
|
case 73: case 74: case 75: case 76: case 77: case 78: case 79: case 80:
|
|
case 81: case 82: case 83: case 84: case 85: case 86: case 87: case 88:
|
|
case 89: case 90:
|
|
// _
|
|
case 95:
|
|
// a-z
|
|
case 97: case 98: case 99: case 100: case 101: case 102: case 103: case 104:
|
|
case 105: case 106: case 107: case 108: case 109: case 110: case 111:
|
|
case 112: case 113: case 114: case 115: case 116: case 117: case 118:
|
|
case 119: case 120: case 121: case 122:
|
|
return $this->readName($position);
|
|
// -
|
|
case 45:
|
|
// 0-9
|
|
case 48: case 49: case 50: case 51: case 52:
|
|
case 53: case 54: case 55: case 56: case 57:
|
|
return $this->readNumber($position, $code);
|
|
// "
|
|
case 34: return $this->readString($position);
|
|
}
|
|
|
|
throw new SyntaxError($this->source, $position, 'Unexpected character ' . Utils::printCharCode($code));
|
|
}
|
|
|
|
/**
|
|
* Reads an alphanumeric + underscore name from the source.
|
|
*
|
|
* [_A-Za-z][_0-9A-Za-z]*
|
|
* @param int $position
|
|
* @return Token
|
|
*/
|
|
private function readName($position)
|
|
{
|
|
$body = $this->source->body;
|
|
$bodyLength = $this->source->length;
|
|
$end = $position + 1;
|
|
|
|
while (
|
|
$end !== $bodyLength &&
|
|
($code = Utils::charCodeAt($body, $end)) &&
|
|
(
|
|
$code === 95 || // _
|
|
$code >= 48 && $code <= 57 || // 0-9
|
|
$code >= 65 && $code <= 90 || // A-Z
|
|
$code >= 97 && $code <= 122 // a-z
|
|
)
|
|
) {
|
|
++$end;
|
|
}
|
|
return new Token(Token::NAME, $position, $end, mb_substr($body, $position, $end - $position, 'UTF-8'));
|
|
}
|
|
|
|
/**
|
|
* Reads a number token from the source file, either a float
|
|
* or an int depending on whether a decimal point appears.
|
|
*
|
|
* Int: -?(0|[1-9][0-9]*)
|
|
* Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
|
|
*
|
|
* @param $start
|
|
* @param $firstCode
|
|
* @return Token
|
|
* @throws SyntaxError
|
|
*/
|
|
private function readNumber($start, $firstCode)
|
|
{
|
|
$code = $firstCode;
|
|
$body = $this->source->body;
|
|
$position = $start;
|
|
$isFloat = false;
|
|
|
|
if ($code === 45) { // -
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
}
|
|
|
|
if ($code === 48) { // 0
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
|
|
if ($code >= 48 && $code <= 57) {
|
|
throw new SyntaxError($this->source, $position, "Invalid number, unexpected digit after 0: " . Utils::printCharCode($code));
|
|
}
|
|
} else {
|
|
$position = $this->readDigits($position, $code);
|
|
$code = Utils::charCodeAt($body, $position);
|
|
}
|
|
|
|
if ($code === 46) { // .
|
|
$isFloat = true;
|
|
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
$position = $this->readDigits($position, $code);
|
|
$code = Utils::charCodeAt($body, $position);
|
|
}
|
|
|
|
if ($code === 69 || $code === 101) { // E e
|
|
$isFloat = true;
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
|
|
if ($code === 43 || $code === 45) { // + -
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
}
|
|
$position = $this->readDigits($position, $code);
|
|
}
|
|
return new Token(
|
|
$isFloat ? Token::FLOAT : Token::INT,
|
|
$start,
|
|
$position,
|
|
mb_substr($body, $start, $position - $start, 'UTF-8')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns the new position in the source after reading digits.
|
|
*/
|
|
private function readDigits($start, $firstCode)
|
|
{
|
|
$body = $this->source->body;
|
|
$position = $start;
|
|
$code = $firstCode;
|
|
if ($code >= 48 && $code <= 57) { // 0 - 9
|
|
do {
|
|
$code = Utils::charCodeAt($body, ++$position);
|
|
} while ($code >= 48 && $code <= 57); // 0 - 9
|
|
|
|
return $position;
|
|
}
|
|
if ($position > $this->source->length - 1) {
|
|
$code = null;
|
|
}
|
|
throw new SyntaxError($this->source, $position, "Invalid number, expected digit but got: " . Utils::printCharCode($code));
|
|
}
|
|
|
|
/**
|
|
* @param $start
|
|
* @return Token
|
|
* @throws SyntaxError
|
|
*/
|
|
private function readString($start)
|
|
{
|
|
$body = $this->source->body;
|
|
$bodyLength = $this->source->length;
|
|
|
|
$position = $start + 1;
|
|
$chunkStart = $position;
|
|
$code = null;
|
|
$value = '';
|
|
|
|
while (
|
|
$position < $bodyLength &&
|
|
($code = Utils::charCodeAt($body, $position)) &&
|
|
// not LineTerminator
|
|
$code !== 0x000A && $code !== 0x000D &&
|
|
// not Quote (")
|
|
$code !== 34
|
|
) {
|
|
$this->assertValidStringCharacterCode($code, $position);
|
|
|
|
++$position;
|
|
if ($code === 92) { // \
|
|
$value .= mb_substr($body, $chunkStart, $position - 1 - $chunkStart, 'UTF-8');
|
|
$code = Utils::charCodeAt($body, $position);
|
|
switch ($code) {
|
|
case 34: $value .= '"'; break;
|
|
case 47: $value .= '/'; break;
|
|
case 92: $value .= '\\'; break;
|
|
case 98: $value .= chr(8); break; // \b (backspace)
|
|
case 102: $value .= "\f"; break;
|
|
case 110: $value .= "\n"; break;
|
|
case 114: $value .= "\r"; break;
|
|
case 116: $value .= "\t"; break;
|
|
case 117:
|
|
$hex = mb_substr($body, $position + 1, 4);
|
|
if (!preg_match('/[0-9a-fA-F]{4}/', $hex)) {
|
|
throw new SyntaxError($this->source, $position, 'Invalid character escape sequence: \\u' . $hex);
|
|
}
|
|
$code = hexdec($hex);
|
|
$this->assertValidStringCharacterCode($code, $position - 1);
|
|
$value .= Utils::chr($code);
|
|
$position += 4;
|
|
break;
|
|
default:
|
|
throw new SyntaxError($this->source, $position, 'Invalid character escape sequence: \\' . Utils::chr($code));
|
|
}
|
|
++$position;
|
|
$chunkStart = $position;
|
|
}
|
|
}
|
|
|
|
if ($code !== 34) {
|
|
throw new SyntaxError($this->source, $position, 'Unterminated string');
|
|
}
|
|
|
|
$value .= mb_substr($body, $chunkStart, $position - $chunkStart, 'UTF-8');
|
|
return new Token(Token::STRING, $start, $position + 1, $value);
|
|
}
|
|
|
|
private function assertValidStringCharacterCode($code, $position)
|
|
{
|
|
// SourceCharacter
|
|
if ($code < 0x0020 && $code !== 0x0009) {
|
|
throw new SyntaxError(
|
|
$this->source,
|
|
$position,
|
|
"Invalid character within String: " . Utils::printCharCode($code)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads from body starting at startPosition until it finds a non-whitespace
|
|
* or commented character, then returns the position of that character for
|
|
* lexing.
|
|
*
|
|
* @param $body
|
|
* @param $startPosition
|
|
* @return int
|
|
*/
|
|
private function positionAfterWhitespace($body, $startPosition)
|
|
{
|
|
$bodyLength = mb_strlen($body, 'UTF-8');
|
|
$position = $startPosition;
|
|
|
|
while ($position < $bodyLength) {
|
|
$code = Utils::charCodeAt($body, $position);
|
|
|
|
// Skip whitespace
|
|
if (
|
|
$code === 0xFEFF || // BOM
|
|
$code === 0x0009 || // tab
|
|
$code === 0x0020 || // space
|
|
$code === 0x000A || // new line
|
|
$code === 0x000D || // carriage return
|
|
$code === 0x002C
|
|
) {
|
|
++$position;
|
|
// Skip comments
|
|
} else if ($code === 35) { // #
|
|
++$position;
|
|
while (
|
|
$position < $bodyLength &&
|
|
($code = Utils::charCodeAt($body, $position)) &&
|
|
// SourceCharacter but not LineTerminator
|
|
($code > 0x001F || $code === 0x0009) && $code !== 0x000A && $code !== 0x000D
|
|
) {
|
|
++$position;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return $position;
|
|
}
|
|
}
|