Ë@,öK¦é¶ðlƒŸL/ÒŽ©.‰™`„o²ø–»Iô¤¯kÁ%_´;–áž|G{õèµ‰ÏÐoÿ…D@HŽƒÑVsÁJHjL{q]Û‡“FvâÇ»9o¼ÓNº’à9ñ‚¬[Ä‘œÚË0Fã¡ýZNNñ¡%üÞAÑ¢OÔaÙ‡R9/Â$M 13iþHëGK_«3e*×'å¹òCA\šý¬»3uüDJÔ†kXK:|²RO‰‹ZSBë#='O »ˆ§›ôƒ?Áû´–—à'Å)¢š:Ù[k×ôþ—¤/=ËÏ„Xøº¼;ÓÑ9¤ï—æÂaÊ¸8)•5À

•¾óò¥—ÅDTyº8-xå(\8n`èQ=™ô+3îeÅ1î3ÃµâK•{q¥6Õ¶ö»™Üü*î[oóÏ”®X]ˆ´ ÎôØÌÁ–S®_ §¿1òÜÕ™x–í‘b?AÛŠòú!>þ¡ï]½EžK9'¡Ÿ}éG1¸ç`]!RÛ:ƒêm®ÆäŠpWk3sd-À-	‹/œ¹þßÎDð°îáX;co%ª":»a¶ëÎàžü€`7µ"âŽöûÔ2>ˆ—¿‘1wÆ>ÑFµ-Añ%B¾xÖgg/å…†ÛÍ‡Š*Õ3òÀÜÈO(%^ß,n/!FýQÿãPTÍöæƒÄÅ>³¡dsÿ9Ñ¹åsÚD¶%w"¥ãvœî3‹ÂêST6øÓÚ\Š¹:&ßŒÖ:0ú¬ÝÈëy%œï{´‚MüX¼õ‹ëŒé„‹è…­j³9.A'óÅ<Ó}@ëãÖ<(u˜}I÷Ð.éfÊ0ø4f‰ƒ-Jåˆ1‚@úÃ’þˆ‰5R’…¾<Ñžƒa'4yBÅ~ÁÖ/§»æz `aÚxHVƒF=õ÷0MŽª36k˜W yem/×ÂŒ€¹}ó£.¢ºåQ86]êá¥Qšäe”ò°}.ÓKÓCºˆ`wœïÌÀwm6«ø#²Ë7::QuoàY˜b¶À<: [¦AzéˆHÃ—¿NV˜:?h%Þð†þ‰FMíÆ¶P ®ó]Õ2èà11!N6¥<^2~
r§5dœ=–_¹—jb™Œ†¶dñÎóž‘SPõÈ³1Ò!
…¬  ZdWš“¥Î,àcŸÿÄ¿Ýö›ÑGd}EaÒuâš_¥ŒcàÖ±Ë#¡h8¢Ä;FÃˆ„Q¶ðo;€CH¸)~ì+QA)GK‹™>‰©,D³$¯0nUñØæ0 L@áÆb´4”™¾àüÃ¶#‘T!×åH˜öþuë£Ó¶O²vÇUÇ»ÑÒU–>úwí­x³{eYjö§!trÛö}$·¼ŽîÂô¯â·=ØìÚú»K2ÔJwÇTSBÔÑiÍ‚Ez­¾f«@gåù‡Á@AÁ?DßÆ9<p}Nò
‹ïl;•ö(k6
 É5õ¬ñ…ÑxíëËÊßÙ«4íúOŸ?Â’€ùÆíÊ#Âæ7.»Ø„êð÷j>p\ÆH–G
Ðº˜C½1ôLKÜ÷¶¨kÇÛØÑ7>ŸËxTiAa&´ê[é)Ô½9ÝÝ"¨‚—Øa¡”õV'Ä§Í¦Þþ:ÊK•›~²‡LëÀ¯üÇ±ÂhÂ^ñÛƒß•Å–‡f ÝØXÀ]¢#ÌmN­Ä•1º”ûº‹"‹ç¿çnŽÞRX‹»01Léü¡VJ&}6†ÀGwÛÃž8sXç^†µö!µVK$î÷Â0Ë=^ÐtÚ€|5’W°3K~A†øßÀ6^s†¶Æ¹Â`MÝ}yuÕdØr¾t{öö0–”ë­Ë3*Ú\¹QæTäxÖÜ$Þ¬úvÛt‰dp.òýº?±‘P7QþUùày]¥+m#¿‚yà„£êÒÎWç—þŸÁ»Òzdú§)7¬ÎôkùuP'j³‡¥ùâÛ±{F‹Š›ÓZ—·yÎÇZêqñ‹ã´kÝ9Ú3EáI5z‘làB¬»K<ÿå_É„ª;°yKî—º":¡›
ôD-ƒmB¦·7Ä>»Úž²k‚K«J·*H’S¹c£¼d¹r~ŸznNqs_ÃV <6(†ž+Ë(:^$s°pAyÈÎVÀåŒõ’‰ìfG!"|2@`8sóÕÐå&7Z¥ÙºV†³V•Æ¿»|YV©ŒW]eÉf»ð—6¤"9ŸÝþk•_½U~RÝòãž8sXç^†µö!µVK$îçEîóÝ´È«~tŠö±í*•þpÍ5œVåxªÄ£0îvò
Ó“ªá™QvÆ9ÅÙÞLLTl€>¡ |3±ñ¤Øî1Y¨ú’6™§Æ@x{1$zñUÏîüà¢ØR[ò¨ùžÖ“ôèØUÀ›}ÙWé%ñ‰o€¨øØäÌJB›ÿ²ƒJ2í<Í#ÙáGQv¹Ÿ5’%–lüÌkXÎjîø0Õ;n–.Ôê@[2‚€LTl€>¡ |3±ñ¤Øçß«åŽ3µÎ]^ãšTîÈ?»íùö-˜¼å±r)¹Î¢¡ÁëüÚæ7ubÌ Ì×1é|C•‚Ä¶k†šÍ5ªS,.¤(íüƒº}!Ã™—÷æ$ªOÅV<{¦×[ÿH¢ýƒ¿-¼d?!ÕœÊåº¢]SjÞ…§u¶d‡y6§6ª-åVJì“·ù„? P¤ç"ö
O¦îH/>
ì¦@²HéjY)›Íd7Æwì5DBòvà†‘qÒO–]µÌ«/eÜVŠpNn¶ˆº0!5QY!_èU“ý’˜‘ùµì=ºÇú½7¾Ù|1ùñg´V‘7XHLú›?P+Ú}rY™ž×Îœ7aÔ„ÈÃ’Ftô¨5lå—ÈqÐµl2²­Pó¿f‰#ÂXÃÏÔËsËö½Ê€Ý×Qbâ4ù³Ð€<`“õ«Ù•œÇÌ3Ð[`|?‹Šƒö	ˆ°"Í™Ôë±ó2;o"J_Y>Œtºõ™¥pqˆÚ	²æ¬C,/&‚2˜Ð"Vó÷ Û8C	d#-lêy{ˆUP„cËº &†öŽg#úyqKð	jZO‹.(z•&!Â…«tû7ðò+Xå÷L—ÃýSé™ÄçÂ+‡é±ŠS	§uËS®»xÝ²Ë?žŠ7™8’7wšYL[^gˆ~—8ÚSCfT•V â<öjŠ¦þ@ñÛá¸ høŠ€õ/ú+€Ì”§-¢ÖnógÔÿçö›¦Ñþ8 ®™ùÕ05ÕQuÊ¡’;Bã’5ÏÎ–Ndr—[ž|É-Ô±˜&Ã£QUŸ¹P1½4CÇNÍæ.Þí•¾Q÷ÕB¬È5Û<¹`LžâÍÿŸFƒ&@¦
ñØC{›g—ÝR•©î¡Â%"Rû©âÔºâÓºO}vr©€>#w\€SëÝ_pÙ¡ÃI~A	ši‘b¾gƒÒlf¿Ö=/Žqô¬Ô!ÿÌ3}™“ G°5´QÝ‚l
LŠ±ð±È˜¾¦åB&¤ƒv¦™B‚°KAÁýÁ¢rñË¨ÑjáÜwÔIdRŒ•‹üþQ§aˆ]8óš.aÑ þ’È‰¯¤i §~m8ÇFO¢!
Vø×ÀÚ0©·ž—!ßk<òÄvE›)qÛ„es£4©î¦e£¿æU#•.{ÊZÖà„•ÊíøxnOê5IÓô‘ÑlÁ-îTf¿Ánju[ÎŠeÝŒ†žÑCbáÉ8Eè‘ÚÓâÃAr“<ÞäRD–­Ó>sÏÆpØ²=Ü°`Œ™‡üáÈÕ«2Ý³ÈêtÕðj¨zéèå>wïI	Ð nUXÖö7(^p„5òŠƒ€M­œ©W´]ôh©ðSÚåSoÑË¿«¼8ô(ÔS^îe&YN¨^BÜ}(_‚ïrðeŠI¿û7ŽcŽXç"9³œVÿ«yRq£¢Ùì6¶ñ*Äob¾#r K¸D6ìÛJn&9MŽøÒÉKêë'Œ‚mQŠõQ<¸F+økÐ¦¨ùÉ$Ûh<åº'M»‰%â³Yò÷¤mÙ5»|¢Ý>^Ò:Û/ž ×1÷>ïŸõœÁ}ÿõB×ÔâF ¾²†éœÞŠÒ¤½ðÌ7f4ÑÏ«`ZS?Š6ÙÇð9±1^ïTÒª×ð, Vc(rÒØmw$u°‹Æê{±ñ&béZ÷ƒ×núÕ·zM«î˜ì–cQN¤ââG-Jåˆ1‚@úÃ’þˆ‰@¸4wù®”ŒâÏXÆ¢pŠÄº¬OjeÚbR9®ëã@&2æ#‚¼N»¾CTyNMŠ‘e¹‹…˜r=äÍ?Ø‚°É~YJî‹¥ÚqASnÀ³»ºl^Ó—wSÆ©;ýÍEõIuÆ!Ö*F2˜WŒTówQfÔRUS1x<‰$«i†Ðð§ƒ17£†[QR\sR)ÎÊ+„Ã6ÿûP<Ñ¢ÍðPÓý’êmÞ$ÌšÄvÍ²7¯”š„EÜ=P«ÞÃ•ë”Q²bêl‹”bîpy2d¿˜þýA3_K¤ßÚÇ`Cb5ó”ýìZ°4Ñ%3…5“”åBÄpB†;³^^…#Àg-1BƒðE@hs³v-ë†’ ˆ½@œ%¶ ²á)ÓsSOöú°T(ÆOJÜP ”C{›g—ÝR•©î¡Â%F‹&Vd¦óÉÖ íÜA€˜–ÔÝ‹¥#šEb# ôa…ío’w5ÅnÖF÷®€&xrÎsUXfOþa>Ï+8ÍðeêoóI¬ýw‹ŸÁÞ,?lßh¦DÀ·R(‚x	å$…ÛA×Ìò ¡4ØZš¾§¾	G'æâ‰zuýòÝSZ`%cì†½òè®q_:ñ?Î6¸:‘ª×-ŽäøQ1Õj^üPìšË_ü	/øíj‰P”CWÖ8ÙõAiz*¾‘ 8õ+Z•D3ÙÈÈÁÏXø\àÊ€è)n<QOcÑÄ=ˆ0‹Ä˜qS»²ß?˜v¯‘ÚÊ€ˆé[àÑ&	¨_ƒ’3Îª-¶r’ÜX¶è÷íÛDÚÒÝÃ¡/ýPon¥ü¾|F4 pæ¶@xÃ´µÊV‰$ê«‚f¡a&bþ¼J6µ˜B‘gn#²8søå¢	®Äs›Q®S\·1s ;í¤@PÓþµ8Œ5À¦bá¾”‚nÜ€úàDõ>üŠöQjÙù+NÑ–§…w®HŒ+£úê®¥«5½Þ¼Þ»$‰xãq¸?nr œhU×Kò=ñúÝÌÇÜ"Ë
sÿ#ûCª‚hÄUéâd?³ÌWH‚He™
     * @param bool             $strict    whether strict mode should be
     *                                    enabled or not
     * @param string           $delimiter the delimiter to be used
     *
     * @return TokensList
     */
    public static function getTokens($str, $strict = false, $delimiter = null)
    {
        $lexer = new self($str, $strict, $delimiter);

        return $lexer->list;
    }

    /**
     * Constructor.
     *
     * @param string|UtfString $str       the query to be lexed
     * @param bool             $strict    whether strict mode should be
     *                                    enabled or not
     * @param string           $delimiter the delimiter to be used
     */
    public function __construct($str, $strict = false, $delimiter = null)
    {
        // `strlen` is used instead of `mb_strlen` because the lexer needs to
        // parse each byte of the input.
        $len = $str instanceof UtfString ? $str->length() : strlen($str);

        // For multi-byte strings, a new instance of `UtfString` is
        // initialized (only if `UtfString` usage is forced.
        if (!$str instanceof UtfString && USE_UTF_STRINGS && $len !== mb_strlen($str, 'UTF-8')) {
            $str = new UtfString($str);
        }

        $this->str = $str;
        $this->len = $str instanceof UtfString ? $str->length() : $len;

        $this->strict = $strict;

        // Setting the delimiter.
        $this->setDelimiter(
            !empty($delimiter) ? $delimiter : static::$DEFAULT_DELIMITER
        );

        $this->lex();
    }

    /**
     * Sets the delimiter.
     *
     * @param string $delimiter the new delimiter
     */
    public function setDelimiter($delimiter)
    {
        $this->delimiter = $delimiter;
        $this->delimiterLen = strlen($delimiter);
    }

    /**
     * Parses the string and extracts lexemes.
     */
    public function lex()
    {
        // TODO: Sometimes, static::parse* functions make unnecessary calls to
        // is* functions. For a better performance, some rules can be deduced
        // from context.
        // For example, in `parseBool` there is no need to compare the token
        // every time with `true` and `false`. The first step would be to
        // compare with 'true' only and just after that add another letter from
        // context and compare again with `false`.
        // Another example is `parseComment`.

        $list = new TokensList();

        /**
         * Last processed token.
         *
         * @var Token
         */
        $lastToken = null;

        for ($this->last = 0, $lastIdx = 0; $this->last < $this->len; $lastIdx = ++$this->last) {
            /**
             * The new token.
             *
             * @var Token
             */
            $token = null;

            foreach (static::$PARSER_METHODS as $method) {
                if ($token = $this->$method()) {
                    break;
                }
            }

            if ($token === null) {
                // @assert($this->last === $lastIdx);
                $token = new Token($this->str[$this->last]);
                $this->error(
                    __('Unexpected character.'),
                    $this->str[$this->last],
                    $this->last
                );
            } elseif ($lastToken !== null
                && $token->type === Token::TYPE_SYMBOL
                && $token->flags & Token::FLAG_SYMBOL_VARIABLE
                && (
                    $lastToken->type === Token::TYPE_STRING
                    || (
                        $lastToken->type === Token::TYPE_SYMBOL
                        && $lastToken->flags & Token::FLAG_SYMBOL_BACKTICK
                    )
                )
            ) {
                // Handles ```... FROM 'user'@'%' ...```.
                $lastToken->token .= $token->token;
                $lastToken->type = Token::TYPE_SYMBOL;
                $lastToken->flags = Token::FLAG_SYMBOL_USER;
                $lastToken->value .= '@' . $token->value;
                continue;
            } elseif ($lastToken !== null
                && $token->type === Token::TYPE_KEYWORD
                && $lastToken->type === Token::TYPE_OPERATOR
                && $lastToken->value === '.'
            ) {
                // Handles ```... tbl.FROM ...```. In this case, FROM is not
                // a reserved word.
                $token->type = Token::TYPE_NONE;
                $token->flags = 0;
                $token->value = $token->token;
            }

            $token->position = $lastIdx;

            $list->tokens[$list->count++] = $token;

            // Handling delimiters.
            if ($token->type === Token::TYPE_NONE && $token->value === 'DELIMITER') {
                if ($this->last + 1 >= $this->len) {
                    $this->error(
                        __('Expected whitespace(s) before delimiter.'),
                        '',
                        $this->last + 1
                    );
                    continue;
                }

                // Skipping last R (from `delimiteR`) and whitespaces between
                // the keyword `DELIMITER` and the actual delimiter.
                $pos = ++$this->last;
                if (($token = $this->parseWhitespace()) !== null) {
                    $token->position = $pos;
                    $list->tokens[$list->count++] = $token;
                }

                // Preparing the token that holds the new delimiter.
                if ($this->last + 1 >= $this->len) {
                    $this->error(
                        __('Expected delimiter.'),
                        '',
                        $this->last + 1
                    );
                    continue;
                }
                $pos = $this->last + 1;

                // Parsing the delimiter.
                $this->delimiter = null;
                while (++$this->last < $this->len && !Context::isWhitespace($this->str[$this->last])) {
                    $this->delimiter .= $this->str[$this->last];
                }

                if (empty($this->delimiter)) {
                    $this->error(
                        __('Expected delimiter.'),
                        '',
                        $this->last
                    );
                    $this->delimiter = ';';
                }

                --$this->last;

                // Saving the delimiter and its token.
                $this->delimiterLen = strlen($this->delimiter);
                $token = new Token($this->delimiter, Token::TYPE_DELIMITER);
                $token->position = $pos;
                $list->tokens[$list->count++] = $token;
            }

            $lastToken = $token;
        }

        // Adding a final delimiter to mark the ending.
        $list->tokens[$list->count++] = new Token(null, Token::TYPE_DELIMITER);

        // Saving the tokens list.
        $this->list = $list;
    }

    /**
     * Creates a new error log.
     *
     * @param string $msg  the error message
     * @param string $str  the character that produced the error
     * @param int    $pos  the position of the character
     * @param int    $code the code of the error
     *
     * @throws LexerException throws the exception, if strict mode is enabled
     */
    public function error($msg = '', $str = '', $pos = 0, $code = 0)
    {
        $error = new LexerException($msg, $str, $pos, $code);
        if ($this->strict) {
            throw $error;
        }
        $this->errors[] = $error;
    }

    /**
     * Parses a keyword.
     *
     * @return Token
     */
    public function parseKeyword()
    {
        $token = '';

        /**
         * Value to be returned.
         *
         * @var Token
         */
        $ret = null;

        /**
         * The value of `$this->last` where `$token` ends in `$this->str`.
         *
         * @var int
         */
        $iEnd = $this->last;

        /**
         * Whether last parsed character is a whitespace.
         *
         * @var bool
         */
        $lastSpace = false;

        for ($j = 1; $j < Context::KEYWORD_MAX_LENGTH && $this->last < $this->len; ++$j, ++$this->last) {
            // Composed keywords shouldn't have more than one whitespace between
            // keywords.
            if (Context::isWhitespace($this->str[$this->last])) {
                if ($lastSpace) {
                    --$j; // The size of the keyword didn't increase.
                    continue;
                } else {
                    $lastSpace = true;
                }
            } else {
                $lastSpace = false;
            }

            $token .= $this->str[$this->last];
            if (($this->last + 1 === $this->len || Context::isSeparator($this->str[$this->last + 1]))
                && $flags = Context::isKeyword($token)
            ) {
                $ret = new Token($token, Token::TYPE_KEYWORD, $flags);
                $iEnd = $this->last;

                // We don't break so we find longest keyword.
                // For example, `OR` and `ORDER` have a common prefix `OR`.
                // If we stopped at `OR`, the parsing would be invalid.
            }
        }

        $this->last = $iEnd;

        return $ret;
    }

    /**
     * Parses a label.
     *
     * @return Token
     */
    public function parseLabel()
    {
        $token = '';

        /**
         * Value to be returned.
         *
         * @var Token
         */
        $ret = null;

        /**
         * The value of `$this->last` where `$token` ends in `$this->str`.
         *
         * @var int
         */
        $iEnd = $this->last;

        /**
         * Whether last parsed character is a whitespace.
         *
         * @var bool
         */
        $lastSpace = false;

        for ($j = 1; $j < Context::LABEL_MAX_LENGTH && $this->last < $this->len; ++$j, ++$this->last) {
            // Composed keywords shouldn't have more than one whitespace between
            // keywords.
            if (Context::isWhitespace($this->str[$this->last])) {
                if ($lastSpace) {
                    --$j; // The size of the keyword didn't increase.
                    continue;
                } else {
                    $lastSpace = true;
                }
            } elseif ($this->str[$this->last] === ':') {
                $token .= $this->str[$this->last];
                $ret = new Token($token, Token::TYPE_LABEL);
                $iEnd = $this->last;
                break;
            } else {
                $lastSpace = false;
            }
            $token .= $this->str[$this->last];
        }

        $this->last = $iEnd;

        return $ret;
    }

    /**
     * Parses an operator.
     *
     * @return Token
     */
    public function parseOperator()
    {
        $token = '';

        /**
         * Value to be returned.
         *
         * @var Token
         */
        $ret = null;

        /**
         * The value of `$this->last` where `$token` ends in `$this->str`.
         *
         * @var int
         */
        $iEnd = $this->last;

        for ($j = 1; $j < Context::OPERATOR_MAX_LENGTH && $this->last < $this->len; ++$j, ++$this->last) {
            $token .= $this->str[$this->last];
            if ($flags = Context::isOperator($token)) {
                $ret = new Token($token, Token::TYPE_OPERATOR, $flags);
                $iEnd = $this->last;
            }
        }

        $this->last = $iEnd;

        return $ret;
    }

    /**
     * Parses a whitespace.
     *
     * @return Token
     */
    public function parseWhitespace()
    {
        $token = $this->str[$this->last];

        if (!Context::isWhitespace($token)) {
            return null;
        }

        while (++$this->last < $this->len && Context::isWhitespace($this->str[$this->last])) {
            $token .= $this->str[$this->last];
        }

        --$this->last;

        return new Token($token, Token::TYPE_WHITESPACE);
    }

    /**
     * Parses a comment.
     *
     * @return Token
     */
    public function parseComment()
    {
        $iBak = $this->last;
        $token = $this->str[$this->last];

        // Bash style comments. (#comment\n)
        if (Context::isComment($token)) {
            while (
                ++$this->last < $this->len
                && $this->str[$this->last] !== "\n"
            ) {
                $token .= $this->str[$this->last];
            }
            return new Token($token, Token::TYPE_COMMENT, Token::FLAG_COMMENT_BASH);
        }

        // C style comments. (/*comment*\/)
        if (++$this->last < $this->len) {
            $token .= $this->str[$this->last];
            if (Context::isComment($token)) {
                $flags = Token::FLAG_COMMENT_C;

                // This comment already ended. It may be a part of a
                // previous MySQL specific command.
                if ($token === '*/') {
                    return new Token($token, Token::TYPE_COMMENT, $flags);
                }

                // Checking if this is a MySQL-specific command.
                if ($this->last + 1 < $this->len
                    && $this->str[$this->last + 1] === '!'
                ) {
                    $flags |= Token::FLAG_COMMENT_MYSQL_CMD;
                    $token .= $this->str[++$this->last];

                    while (
                        ++$this->last < $this->len
                        && '0' <= $this->str[$this->last]
                        && $this->str[$this->last] <= '9'
                    ) {
                        $token .= $this->str[$this->last];
                    }
                    --$this->last;

                    // We split this comment and parse only its beginning
                    // here.
                    return new Token($token, Token::TYPE_COMMENT, $flags);
                }

                // Parsing the comment.
                while (
                    ++$this->last < $this->len
                    && (
                        $this->str[$this->last - 1] !== '*'
                        || $this->str[$this->last] !== '/'
                    )
                ) {
                    $token .= $this->str[$this->last];
                }

                // Adding the ending.
                if ($this->last < $this->len) {
                    $token .= $this->str[$this->last];
                }

                return new Token($token, Token::TYPE_COMMENT, $flags);
            }
        }

        // SQL style comments. (-- comment\n)
        if (++$this->last < $this->len) {
            $token .= $this->str[$this->last];
            if (Context::isComment($token)) {
                // Checking if this comment did not end already (```--\n```).
                if ($this->str[$this->last] !== "\n") {
                    while (
                        ++$this->last < $this->len
                        && $this->str[$this->last] !== "\n"
                    ) {
                        $token .= $this->str[$this->last];
                    }
                }

                return new Token($token, Token::TYPE_COMMENT, Token::FLAG_COMMENT_SQL);
            }
        }

        $this->last = $iBak;

        return null;
    }

    /**
     * Parses a boolean.
     *
     * @return Token
     */
    public function parseBool()
    {
        if ($this->last + 3 >= $this->len) {
            // At least `min(strlen('TRUE'), strlen('FALSE'))` characters are
            // required.
            return null;
        }

        $iBak = $this->last;
        $token = $this->str[$this->last] . $this->str[++$this->last]
        . $this->str[++$this->last] . $this->str[++$this->last]; // _TRUE_ or _FALS_e

        if (Context::isBool($token)) {
            return new Token($token, Token::TYPE_BOOL);
        } elseif (++$this->last < $this->len) {
            $token .= $this->str[$this->last]; // fals_E_
            if (Context::isBool($token)) {
                return new Token($token, Token::TYPE_BOOL, 1);
            }
        }

        $this->last = $iBak;

        return null;
    }

    /**
     * Parses a number.
     *
     * @return Token
     */
    public function parseNumber()
    {
        // A rudimentary state machine is being used to parse numbers due to
        // the various forms of their notation.
        //
        // Below are the states of the machines and the conditions to change
        // the state.
        //
        //      1 --------------------[ + or - ]-------------------> 1
        //      1 -------------------[ 0x or 0X ]------------------> 2
        //      1 --------------------[ 0 to 9 ]-------------------> 3
        //      1 -----------------------[ . ]---------------------> 4
        //      1 -----------------------[ b ]---------------------> 7
        //
        //      2 --------------------[ 0 to F ]-------------------> 2
        //
        //      3 --------------------[ 0 to 9 ]-------------------> 3
        //      3 -----------------------[ . ]---------------------> 4
        //      3 --------------------[ e or E ]-------------------> 5
        //
        //      4 --------------------[ 0 to 9 ]-------------------> 4
        //      4 --------------------[ e or E ]-------------------> 5
        //
        //      5 ---------------[ + or - or 0 to 9 ]--------------> 6
        //
        //      7 -----------------------[ ' ]---------------------> 8
        //
        //      8 --------------------[ 0 or 1 ]-------------------> 8
        //      8 -----------------------[ ' ]---------------------> 9
        //
        // State 1 may be reached by negative numbers.
        // State 2 is reached only by hex numbers.
        // State 4 is reached only by float numbers.
        // State 5 is reached only by numbers in approximate form.
        // State 7 is reached only by numbers in bit representation.
        //
        // Valid final states are: 2, 3, 4 and 6. Any parsing that finished in a
        // state other than these is invalid.
        $iBak = $this->last;
        $token = '';
        $flags = 0;
        $state = 1;
        for (; $this->last < $this->len; ++$this->last) {
            if ($state === 1) {
                if ($this->str[$this->last] === '-') {
                    $flags |= Token::FLAG_NUMBER_NEGATIVE;
                } elseif ($this->last + 1 < $this->len
                    && $this->str[$this->last] === '0'
                    && (
                        $this->str[$this->last + 1] === 'x'
                        || $this->str[$this->last + 1] === 'X'
                    )
                ) {
                    $token .= $this->str[$this->last++];
                    $state = 2;
                } elseif ($this->str[$this->last] >= '0' && $this->str[$this->last] <= '9') {
                    $state = 3;
                } elseif ($this->str[$this->last] === '.') {
                    $state = 4;
                } elseif ($this->str[$this->last] === 'b') {
                    $state = 7;
                } elseif ($this->str[$this->last] !== '+') {
                    // `+` is a valid character in a number.
                    break;
                }
            } elseif ($state === 2) {
                $flags |= Token::FLAG_NUMBER_HEX;
                if (
                    !(
                        ($this->str[$this->last] >= '0' && $this->str[$this->last] <= '9')
                        || ($this->str[$this->last] >= 'A' && $this->str[$this->last] <= 'F')
                        || ($this->str[$this->last] >= 'a' && $this->str[$this->last] <= 'f')
                    )
                ) {
                    break;
                }
            } elseif ($state === 3) {
                if ($this->str[$this->last] === '.') {
                    $state = 4;
                } elseif ($this->str[$this->last] === 'e' || $this->str[$this->last] === 'E') {
                    $state = 5;
                } elseif ($this->str[$this->last] < '0' || $this->str[$this->last] > '9') {
                    // Just digits and `.`, `e` and `E` are valid characters.
                    break;
                }
            } elseif ($state === 4) {
                $flags |= Token::FLAG_NUMBER_FLOAT;
                if ($this->str[$this->last] === 'e' || $this->str[$this->last] === 'E') {
                    $state = 5;
                } elseif ($this->str[$this->last] < '0' || $this->str[$this->last] > '9') {
                    // Just digits, `e` and `E` are valid characters.
                    break;
                }
            } elseif ($state === 5) {
                $flags |= Token::FLAG_NUMBER_APPROXIMATE;
                if ($this->str[$this->last] === '+' || $this->str[$this->last] === '-'
                    || ($this->str[$this->last] >= '0' && $this->str[$this->last] <= '9')
                ) {
                    $state = 6;
                } else {
                    break;
                }
            } elseif ($state === 6) {
                if ($this->str[$this->last] < '0' || $this->str[$this->last] > '9') {
                    // Just digits are valid characters.
                    break;
                }
            } elseif ($state === 7) {
                $flags |= Token::FLAG_NUMBER_BINARY;
                if ($this->str[$this->last] === '\'') {
                    $state = 8;
                } else {
                    break;
                }
            } elseif ($state === 8) {
                if ($this->str[$this->last] === '\'') {
                    $state = 9;
                } elseif ($this->str[$this->last] !== '0'
                    && $this->str[$this->last] !== '1'
                ) {
                    break;
                }
            } elseif ($state === 9) {
                break;
            }
            $token .= $this->str[$this->last];
        }
        if ($state === 2 || $state === 3
            || ($token !== '.' && $state === 4)
            || $state === 6 || $state === 9
        ) {
            --$this->last;

            return new Token($token, Token::TYPE_NUMBER, $flags);
        }
        $this->last = $iBak;

        return null;
    }

    /**
     * Parses a string.
     *
     * @param string $quote additional starting symbol
     *
     * @return Token
     */
    public function parseString($quote = '')
    {
        $token = $this->str[$this->last];
        if (!($flags = Context::isString($token)) && $token !== $quote) {
            return null;
        }
        $quote = $token;

        while (++$this->last < $this->len) {
            if ($this->last + 1 < $this->len
                && (
                    ($this->str[$this->last] === $quote && $this->str[$this->last + 1] === $quote)
                    || ($this->str[$this->last] === '\\' && $quote !== '`')
                )
            ) {
                $token .= $this->str[$this->last] . $this->str[++$this->last];
            } else {
                if ($this->str[$this->last] === $quote) {
                    break;
                }
                $token .= $this->str[$this->last];
            }
        }

        if ($this->last >= $this->len || $this->str[$this->last] !== $quote) {
            $this->error(
                sprintf(
                    __('Ending quote %1$s was expected.'),
                    $quote
                ),
                '',
                $this->last
            );
        } else {
            $token .= $this->str[$this->last];
        }

        return new Token($token, Token::TYPE_STRING, $flags);
    }

    /**
     * Parses a symbol.
     *
     * @return Token
     */
    public function parseSymbol()
    {
        $token = $this->str[$this->last];
        if (!($flags = Context::isSymbol($token))) {
            return null;
        }

        if ($flags & Token::FLAG_SYMBOL_VARIABLE) {
            if ($this->last + 1 < $this->len && $this->str[++$this->last] === '@') {
                // This is a system variable (e.g. `@@hostname`).
                $token .= $this->str[$this->last++];
                $flags |= Token::FLAG_SYMBOL_SYSTEM;
            }
        } else {
            $token = '';
        }

        $str = null;

        if ($this->last < $this->len) {
            if (($str = $this->parseString('`')) === null) {
                if (($str = static::parseUnknown()) === null) {
                    $this->error(
                        __('Variable name was expected.'),
                        $this->str[$this->last],
                        $this->last
                    );
                }
            }
        }

        if ($str !== null) {
            $token .= $str->token;
        }

        return new Token($token, Token::TYPE_SYMBOL, $flags);
    }

    /**
     * Parses unknown parts of the query.
     *
     * @return Token
     */
    public function parseUnknown()
    {
        $token = $this->str[$this->last];
        if (Context::isSeparator($token)) {
            return null;
        }

        while (++$this->last < $this->len && !Context::isSeparator($this->str[$this->last])) {
            $token .= $this->str[$this->last];
        }
        --$this->last;

        return new Token($token);
    }

    /**
     * Parses the delimiter of the query.
     *
     * @return Token
     */
    public function parseDelimiter()
    {
        $idx = 0;

        while ($idx < $this->delimiterLen && $this->last + $idx < $this->len) {
            if ($this->delimiter[$idx] !== $this->str[$this->last + $idx]) {
                return null;
            }
            ++$idx;
        }

        $this->last += $this->delimiterLen - 1;

        return new Token($this->delimiter, Token::TYPE_DELIMITER);
    }
}