PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - lcov_data/Zend - zend_language_scanner.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 2451 2710 90.4 %
Date: 2016-06-25 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Generated by re2c 0.13.5 */
       2             : #line 1 "Zend/zend_language_scanner.l"
       3             : /*
       4             :    +----------------------------------------------------------------------+
       5             :    | Zend Engine                                                          |
       6             :    +----------------------------------------------------------------------+
       7             :    | Copyright (c) 1998-2016 Zend Technologies Ltd. (http://www.zend.com) |
       8             :    +----------------------------------------------------------------------+
       9             :    | This source file is subject to version 2.00 of the Zend license,     |
      10             :    | that is bundled with this package in the file LICENSE, and is        |
      11             :    | available through the world-wide-web at the following url:           |
      12             :    | http://www.zend.com/license/2_00.txt.                                |
      13             :    | If you did not receive a copy of the Zend license and are unable to  |
      14             :    | obtain it through the world-wide-web, please send a note to          |
      15             :    | license@zend.com so we can mail you a copy immediately.              |
      16             :    +----------------------------------------------------------------------+
      17             :    | Authors: Marcus Boerger <helly@php.net>                              |
      18             :    |          Nuno Lopes <nlopess@php.net>                                |
      19             :    |          Scott MacVicar <scottmac@php.net>                           |
      20             :    | Flex version authors:                                                |
      21             :    |          Andi Gutmans <andi@zend.com>                                |
      22             :    |          Zeev Suraski <zeev@zend.com>                                |
      23             :    +----------------------------------------------------------------------+
      24             : */
      25             : 
      26             : /* $Id$ */
      27             : 
      28             : #if 0
      29             : # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
      30             : #else
      31             : # define YYDEBUG(s, c)
      32             : #endif
      33             : 
      34             : #include "zend_language_scanner_defs.h"
      35             : 
      36             : #include <errno.h>
      37             : #include "zend.h"
      38             : #ifdef ZEND_WIN32
      39             : # include <Winuser.h>
      40             : #endif
      41             : #include "zend_alloc.h"
      42             : #include <zend_language_parser.h>
      43             : #include "zend_compile.h"
      44             : #include "zend_language_scanner.h"
      45             : #include "zend_highlight.h"
      46             : #include "zend_constants.h"
      47             : #include "zend_variables.h"
      48             : #include "zend_operators.h"
      49             : #include "zend_API.h"
      50             : #include "zend_strtod.h"
      51             : #include "zend_exceptions.h"
      52             : #include "zend_virtual_cwd.h"
      53             : #include "tsrm_config_common.h"
      54             : 
      55             : #define YYCTYPE   unsigned char
      56             : #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
      57             : #define YYCURSOR  SCNG(yy_cursor)
      58             : #define YYLIMIT   SCNG(yy_limit)
      59             : #define YYMARKER  SCNG(yy_marker)
      60             : 
      61             : #define YYGETCONDITION()  SCNG(yy_state)
      62             : #define YYSETCONDITION(s) SCNG(yy_state) = s
      63             : 
      64             : #define STATE(name)  yyc##name
      65             : 
      66             : /* emulate flex constructs */
      67             : #define BEGIN(state) YYSETCONDITION(STATE(state))
      68             : #define YYSTATE      YYGETCONDITION()
      69             : #define yytext       ((char*)SCNG(yy_text))
      70             : #define yyleng       SCNG(yy_leng)
      71             : #define yyless(x)    do { YYCURSOR = (unsigned char*)yytext + x; \
      72             :                           yyleng   = (unsigned int)x; } while(0)
      73             : #define yymore()     goto yymore_restart
      74             : 
      75             : /* perform sanity check. If this message is triggered you should
      76             :    increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
      77             : #define YYMAXFILL 16
      78             : #if ZEND_MMAP_AHEAD < YYMAXFILL
      79             : # error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
      80             : #endif
      81             : 
      82             : #ifdef HAVE_STDARG_H
      83             : # include <stdarg.h>
      84             : #endif
      85             : 
      86             : #ifdef HAVE_UNISTD_H
      87             : # include <unistd.h>
      88             : #endif
      89             : 
      90             : /* Globals Macros */
      91             : #define SCNG    LANG_SCNG
      92             : #ifdef ZTS
      93             : ZEND_API ts_rsrc_id language_scanner_globals_id;
      94             : #else
      95             : ZEND_API zend_php_scanner_globals language_scanner_globals;
      96             : #endif
      97             : 
      98             : #define HANDLE_NEWLINES(s, l)                                                                                                   \
      99             : do {                                                                                                                                                    \
     100             :         char *p = (s), *boundary = p+(l);                                                                                       \
     101             :                                                                                                                                                                 \
     102             :         while (p<boundary) {                                                                                                         \
     103             :                 if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {                                   \
     104             :                         CG(zend_lineno)++;                                                                                                      \
     105             :                 }                                                                                                                                               \
     106             :                 p++;                                                                                                                                    \
     107             :         }                                                                                                                                                       \
     108             : } while (0)
     109             : 
     110             : #define HANDLE_NEWLINE(c) \
     111             : { \
     112             :         if (c == '\n' || c == '\r') { \
     113             :                 CG(zend_lineno)++; \
     114             :         } \
     115             : }
     116             : 
     117             : /* To save initial string length after scanning to first variable */
     118             : #define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(scanned_string_len) = (len)
     119             : #define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(scanned_string_len)
     120             : 
     121             : #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
     122             : 
     123             : #define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')
     124             : #define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
     125             : 
     126             : BEGIN_EXTERN_C()
     127             : 
     128             : static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
     129             : {
     130             :         const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
     131             :         ZEND_ASSERT(internal_encoding);
     132             :         return zend_multibyte_encoding_converter(to, to_length, from, from_length, internal_encoding, LANG_SCNG(script_encoding));
     133             : }
     134             : 
     135             : static size_t encoding_filter_script_to_intermediate(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
     136             : {
     137             :         return zend_multibyte_encoding_converter(to, to_length, from, from_length, zend_multibyte_encoding_utf8, LANG_SCNG(script_encoding));
     138             : }
     139             : 
     140             : static size_t encoding_filter_intermediate_to_script(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
     141             : {
     142             :         return zend_multibyte_encoding_converter(to, to_length, from, from_length,
     143             : LANG_SCNG(script_encoding), zend_multibyte_encoding_utf8);
     144             : }
     145             : 
     146             : static size_t encoding_filter_intermediate_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
     147             : {
     148             :         const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
     149             :         ZEND_ASSERT(internal_encoding);
     150             :         return zend_multibyte_encoding_converter(to, to_length, from, from_length,
     151             : internal_encoding, zend_multibyte_encoding_utf8);
     152             : }
     153             : 
     154             : 
     155             : static void _yy_push_state(int new_state)
     156             : {
     157             :         zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION());
     158             :         YYSETCONDITION(new_state);
     159             : }
     160             : 
     161             : #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
     162             : 
     163             : static void yy_pop_state(void)
     164             : {
     165             :         int *stack_state = zend_stack_top(&SCNG(state_stack));
     166             :         YYSETCONDITION(*stack_state);
     167             :         zend_stack_del_top(&SCNG(state_stack));
     168             : }
     169             : 
     170             : static void yy_scan_buffer(char *str, unsigned int len)
     171             : {
     172             :         YYCURSOR       = (YYCTYPE*)str;
     173             :         YYLIMIT        = YYCURSOR + len;
     174             :         if (!SCNG(yy_start)) {
     175             :                 SCNG(yy_start) = YYCURSOR;
     176             :         }
     177             : }
     178             : 
     179             : void startup_scanner(void)
     180             : {
     181             :         CG(parse_error) = 0;
     182             :         CG(doc_comment) = NULL;
     183             :         zend_stack_init(&SCNG(state_stack), sizeof(int));
     184             :         zend_ptr_stack_init(&SCNG(heredoc_label_stack));
     185             : }
     186             : 
     187             : static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {
     188             :     efree(heredoc_label->label);
     189             : }
     190             : 
     191             : void shutdown_scanner(void)
     192             : {
     193             :         CG(parse_error) = 0;
     194             :         RESET_DOC_COMMENT();
     195             :         zend_stack_destroy(&SCNG(state_stack));
     196             :         zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
     197             :         zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
     198             :         SCNG(on_event) = NULL;
     199             : }
     200             : 
     201             : ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state)
     202             : {
     203             :         lex_state->yy_leng   = SCNG(yy_leng);
     204             :         lex_state->yy_start  = SCNG(yy_start);
     205             :         lex_state->yy_text   = SCNG(yy_text);
     206             :         lex_state->yy_cursor = SCNG(yy_cursor);
     207             :         lex_state->yy_marker = SCNG(yy_marker);
     208             :         lex_state->yy_limit  = SCNG(yy_limit);
     209             : 
     210             :         lex_state->state_stack = SCNG(state_stack);
     211             :         zend_stack_init(&SCNG(state_stack), sizeof(int));
     212             : 
     213             :         lex_state->heredoc_label_stack = SCNG(heredoc_label_stack);
     214             :         zend_ptr_stack_init(&SCNG(heredoc_label_stack));
     215             : 
     216             :         lex_state->in = SCNG(yy_in);
     217             :         lex_state->yy_state = YYSTATE;
     218             :         lex_state->filename = zend_get_compiled_filename();
     219             :         lex_state->lineno = CG(zend_lineno);
     220             : 
     221             :         lex_state->script_org = SCNG(script_org);
     222             :         lex_state->script_org_size = SCNG(script_org_size);
     223             :         lex_state->script_filtered = SCNG(script_filtered);
     224             :         lex_state->script_filtered_size = SCNG(script_filtered_size);
     225             :         lex_state->input_filter = SCNG(input_filter);
     226             :         lex_state->output_filter = SCNG(output_filter);
     227             :         lex_state->script_encoding = SCNG(script_encoding);
     228             : 
     229             :         lex_state->on_event = SCNG(on_event);
     230             : 
     231             :         lex_state->ast = CG(ast);
     232             :         lex_state->ast_arena = CG(ast_arena);
     233             : }
     234             : 
     235             : ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state)
     236             : {
     237             :         SCNG(yy_leng)   = lex_state->yy_leng;
     238             :         SCNG(yy_start)  = lex_state->yy_start;
     239             :         SCNG(yy_text)   = lex_state->yy_text;
     240             :         SCNG(yy_cursor) = lex_state->yy_cursor;
     241             :         SCNG(yy_marker) = lex_state->yy_marker;
     242             :         SCNG(yy_limit)  = lex_state->yy_limit;
     243             : 
     244             :         zend_stack_destroy(&SCNG(state_stack));
     245             :         SCNG(state_stack) = lex_state->state_stack;
     246             : 
     247             :         zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
     248             :         zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
     249             :         SCNG(heredoc_label_stack) = lex_state->heredoc_label_stack;
     250             : 
     251             :         SCNG(yy_in) = lex_state->in;
     252             :         YYSETCONDITION(lex_state->yy_state);
     253             :         CG(zend_lineno) = lex_state->lineno;
     254             :         zend_restore_compiled_filename(lex_state->filename);
     255             : 
     256             :         if (SCNG(script_filtered)) {
     257             :                 efree(SCNG(script_filtered));
     258             :                 SCNG(script_filtered) = NULL;
     259             :         }
     260             :         SCNG(script_org) = lex_state->script_org;
     261             :         SCNG(script_org_size) = lex_state->script_org_size;
     262             :         SCNG(script_filtered) = lex_state->script_filtered;
     263             :         SCNG(script_filtered_size) = lex_state->script_filtered_size;
     264             :         SCNG(input_filter) = lex_state->input_filter;
     265             :         SCNG(output_filter) = lex_state->output_filter;
     266             :         SCNG(script_encoding) = lex_state->script_encoding;
     267             : 
     268             :         SCNG(on_event) = lex_state->on_event;
     269             : 
     270             :         CG(ast) = lex_state->ast;
     271             :         CG(ast_arena) = lex_state->ast_arena;
     272             : 
     273             :         RESET_DOC_COMMENT();
     274             : }
     275             : 
     276             : ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle)
     277             : {
     278             :         zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
     279             :         /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
     280             :         file_handle->opened_path = NULL;
     281             :         if (file_handle->free_filename) {
     282             :                 file_handle->filename = NULL;
     283             :         }
     284             : }
     285             : 
     286             : ZEND_API void zend_lex_tstring(zval *zv)
     287             : {
     288             :         if (SCNG(on_event)) SCNG(on_event)(ON_FEEDBACK, T_STRING, 0);
     289             : 
     290             :         ZVAL_STRINGL(zv, (char*)SCNG(yy_text), SCNG(yy_leng));
     291             : }
     292             : 
     293             : #define BOM_UTF32_BE    "\x00\x00\xfe\xff"
     294             : #define BOM_UTF32_LE    "\xff\xfe\x00\x00"
     295             : #define BOM_UTF16_BE    "\xfe\xff"
     296             : #define BOM_UTF16_LE    "\xff\xfe"
     297             : #define BOM_UTF8                "\xef\xbb\xbf"
     298             : 
     299             : static const zend_encoding *zend_multibyte_detect_utf_encoding(const unsigned char *script, size_t script_size)
     300             : {
     301             :         const unsigned char *p;
     302             :         int wchar_size = 2;
     303             :         int le = 0;
     304             : 
     305             :         /* utf-16 or utf-32? */
     306             :         p = script;
     307             :         assert(p >= script);
     308             :         while ((size_t)(p-script) < script_size) {
     309             :                 p = memchr(p, 0, script_size-(p-script)-2);
     310             :                 if (!p) {
     311             :                         break;
     312             :                 }
     313             :                 if (*(p+1) == '\0' && *(p+2) == '\0') {
     314             :                         wchar_size = 4;
     315             :                         break;
     316             :                 }
     317             : 
     318             :                 /* searching for UTF-32 specific byte orders, so this will do */
     319             :                 p += 4;
     320             :         }
     321             : 
     322             :         /* BE or LE? */
     323             :         p = script;
     324             :         assert(p >= script);
     325             :         while ((size_t)(p-script) < script_size) {
     326             :                 if (*p == '\0' && *(p+wchar_size-1) != '\0') {
     327             :                         /* BE */
     328             :                         le = 0;
     329             :                         break;
     330             :                 } else if (*p != '\0' && *(p+wchar_size-1) == '\0') {
     331             :                         /* LE* */
     332             :                         le = 1;
     333             :                         break;
     334             :                 }
     335             :                 p += wchar_size;
     336             :         }
     337             : 
     338             :         if (wchar_size == 2) {
     339             :                 return le ? zend_multibyte_encoding_utf16le : zend_multibyte_encoding_utf16be;
     340             :         } else {
     341             :                 return le ? zend_multibyte_encoding_utf32le : zend_multibyte_encoding_utf32be;
     342             :         }
     343             : 
     344             :         return NULL;
     345             : }
     346             : 
     347             : static const zend_encoding* zend_multibyte_detect_unicode(void)
     348             : {
     349             :         const zend_encoding *script_encoding = NULL;
     350             :         int bom_size;
     351             :         unsigned char *pos1, *pos2;
     352             : 
     353             :         if (LANG_SCNG(script_org_size) < sizeof(BOM_UTF32_LE)-1) {
     354             :                 return NULL;
     355             :         }
     356             : 
     357             :         /* check out BOM */
     358             :         if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_BE, sizeof(BOM_UTF32_BE)-1)) {
     359             :                 script_encoding = zend_multibyte_encoding_utf32be;
     360             :                 bom_size = sizeof(BOM_UTF32_BE)-1;
     361             :         } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_LE, sizeof(BOM_UTF32_LE)-1)) {
     362             :                 script_encoding = zend_multibyte_encoding_utf32le;
     363             :                 bom_size = sizeof(BOM_UTF32_LE)-1;
     364             :         } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_BE, sizeof(BOM_UTF16_BE)-1)) {
     365             :                 script_encoding = zend_multibyte_encoding_utf16be;
     366             :                 bom_size = sizeof(BOM_UTF16_BE)-1;
     367             :         } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_LE, sizeof(BOM_UTF16_LE)-1)) {
     368             :                 script_encoding = zend_multibyte_encoding_utf16le;
     369             :                 bom_size = sizeof(BOM_UTF16_LE)-1;
     370             :         } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF8, sizeof(BOM_UTF8)-1)) {
     371             :                 script_encoding = zend_multibyte_encoding_utf8;
     372             :                 bom_size = sizeof(BOM_UTF8)-1;
     373             :         }
     374             : 
     375             :         if (script_encoding) {
     376             :                 /* remove BOM */
     377             :                 LANG_SCNG(script_org) += bom_size;
     378             :                 LANG_SCNG(script_org_size) -= bom_size;
     379             : 
     380             :                 return script_encoding;
     381             :         }
     382             : 
     383             :         /* script contains NULL bytes -> auto-detection */
     384             :         if ((pos1 = memchr(LANG_SCNG(script_org), 0, LANG_SCNG(script_org_size)))) {
     385             :                 /* check if the NULL byte is after the __HALT_COMPILER(); */
     386             :                 pos2 = LANG_SCNG(script_org);
     387             : 
     388             :                 while (pos1 - pos2 >= sizeof("__HALT_COMPILER();")-1) {
     389             :                         pos2 = memchr(pos2, '_', pos1 - pos2);
     390             :                         if (!pos2) break;
     391             :                         pos2++;
     392             :                         if (strncasecmp((char*)pos2, "_HALT_COMPILER", sizeof("_HALT_COMPILER")-1) == 0) {
     393             :                                 pos2 += sizeof("_HALT_COMPILER")-1;
     394             :                                 while (*pos2 == ' '  ||
     395             :                                            *pos2 == '\t' ||
     396             :                                            *pos2 == '\r' ||
     397             :                                            *pos2 == '\n') {
     398             :                                         pos2++;
     399             :                                 }
     400             :                                 if (*pos2 == '(') {
     401             :                                         pos2++;
     402             :                                         while (*pos2 == ' '  ||
     403             :                                                    *pos2 == '\t' ||
     404             :                                                    *pos2 == '\r' ||
     405             :                                                    *pos2 == '\n') {
     406             :                                                 pos2++;
     407             :                                         }
     408             :                                         if (*pos2 == ')') {
     409             :                                                 pos2++;
     410             :                                                 while (*pos2 == ' '  ||
     411             :                                                            *pos2 == '\t' ||
     412             :                                                            *pos2 == '\r' ||
     413             :                                                            *pos2 == '\n') {
     414             :                                                         pos2++;
     415             :                                                 }
     416             :                                                 if (*pos2 == ';') {
     417             :                                                         return NULL;
     418             :                                                 }
     419             :                                         }
     420             :                                 }
     421             :                         }
     422             :                 }
     423             :                 /* make best effort if BOM is missing */
     424             :                 return zend_multibyte_detect_utf_encoding(LANG_SCNG(script_org), LANG_SCNG(script_org_size));
     425             :         }
     426             : 
     427             :         return NULL;
     428             : }
     429             : 
     430             : static const zend_encoding* zend_multibyte_find_script_encoding(void)
     431             : {
     432             :         const zend_encoding *script_encoding;
     433             : 
     434             :         if (CG(detect_unicode)) {
     435             :                 /* check out bom(byte order mark) and see if containing wchars */
     436             :                 script_encoding = zend_multibyte_detect_unicode();
     437             :                 if (script_encoding != NULL) {
     438             :                         /* bom or wchar detection is prior to 'script_encoding' option */
     439             :                         return script_encoding;
     440             :                 }
     441             :         }
     442             : 
     443             :         /* if no script_encoding specified, just leave alone */
     444             :         if (!CG(script_encoding_list) || !CG(script_encoding_list_size)) {
     445             :                 return NULL;
     446             :         }
     447             : 
     448             :         /* if multiple encodings specified, detect automagically */
     449             :         if (CG(script_encoding_list_size) > 1) {
     450             :                 return zend_multibyte_encoding_detector(LANG_SCNG(script_org), LANG_SCNG(script_org_size), CG(script_encoding_list), CG(script_encoding_list_size));
     451             :         }
     452             : 
     453             :         return CG(script_encoding_list)[0];
     454             : }
     455             : 
     456             : ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding)
     457             : {
     458             :         const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
     459             :         const zend_encoding *script_encoding = onetime_encoding ? onetime_encoding: zend_multibyte_find_script_encoding();
     460             : 
     461             :         if (!script_encoding) {
     462             :                 return FAILURE;
     463             :         }
     464             : 
     465             :         /* judge input/output filter */
     466             :         LANG_SCNG(script_encoding) = script_encoding;
     467             :         LANG_SCNG(input_filter) = NULL;
     468             :         LANG_SCNG(output_filter) = NULL;
     469             : 
     470             :         if (!internal_encoding || LANG_SCNG(script_encoding) == internal_encoding) {
     471             :                 if (!zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
     472             :                         /* and if not, work around w/ script_encoding -> utf-8 -> script_encoding conversion */
     473             :                         LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
     474             :                         LANG_SCNG(output_filter) = encoding_filter_intermediate_to_script;
     475             :                 } else {
     476             :                         LANG_SCNG(input_filter) = NULL;
     477             :                         LANG_SCNG(output_filter) = NULL;
     478             :                 }
     479             :                 return SUCCESS;
     480             :         }
     481             : 
     482             :         if (zend_multibyte_check_lexer_compatibility(internal_encoding)) {
     483             :                 LANG_SCNG(input_filter) = encoding_filter_script_to_internal;
     484             :                 LANG_SCNG(output_filter) = NULL;
     485             :         } else if (zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
     486             :                 LANG_SCNG(input_filter) = NULL;
     487             :                 LANG_SCNG(output_filter) = encoding_filter_script_to_internal;
     488             :         } else {
     489             :                 /* both script and internal encodings are incompatible w/ flex */
     490             :                 LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
     491             :                 LANG_SCNG(output_filter) = encoding_filter_intermediate_to_internal;
     492             :         }
     493             : 
     494             :         return 0;
     495             : }
     496             : 
     497             : ZEND_API int open_file_for_scanning(zend_file_handle *file_handle)
     498             : {
     499             :         char *buf;
     500             :         size_t size, offset = 0;
     501             :         zend_string *compiled_filename;
     502             : 
     503             :         /* The shebang line was read, get the current position to obtain the buffer start */
     504             :         if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {
     505             :                 if ((offset = ftell(file_handle->handle.fp)) == -1) {
     506             :                         offset = 0;
     507             :                 }
     508             :         }
     509             : 
     510             :         if (zend_stream_fixup(file_handle, &buf, &size) == FAILURE) {
     511             :                 return FAILURE;
     512             :         }
     513             : 
     514             :         zend_llist_add_element(&CG(open_files), file_handle);
     515             :         if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
     516             :                 zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
     517             :                 size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
     518             :                 fh->handle.stream.handle = (void*)(((char*)fh) + diff);
     519             :                 file_handle->handle.stream.handle = fh->handle.stream.handle;
     520             :         }
     521             : 
     522             :         /* Reset the scanner for scanning the new file */
     523             :         SCNG(yy_in) = file_handle;
     524             :         SCNG(yy_start) = NULL;
     525             : 
     526             :         if (size != -1) {
     527             :                 if (CG(multibyte)) {
     528             :                         SCNG(script_org) = (unsigned char*)buf;
     529             :                         SCNG(script_org_size) = size;
     530             :                         SCNG(script_filtered) = NULL;
     531             : 
     532             :                         zend_multibyte_set_filter(NULL);
     533             : 
     534             :                         if (SCNG(input_filter)) {
     535             :                                 if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {
     536             :                                         zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
     537             :                                                         "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
     538             :                                 }
     539             :                                 buf = (char*)SCNG(script_filtered);
     540             :                                 size = SCNG(script_filtered_size);
     541             :                         }
     542             :                 }
     543             :                 SCNG(yy_start) = (unsigned char *)buf - offset;
     544             :                 yy_scan_buffer(buf, (unsigned int)size);
     545             :         } else {
     546             :                 zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
     547             :         }
     548             : 
     549             :         BEGIN(INITIAL);
     550             : 
     551             :         if (file_handle->opened_path) {
     552             :                 compiled_filename = zend_string_copy(file_handle->opened_path);
     553             :         } else {
     554             :                 compiled_filename = zend_string_init(file_handle->filename, strlen(file_handle->filename), 0);
     555             :         }
     556             : 
     557             :         zend_set_compiled_filename(compiled_filename);
     558             :         zend_string_release(compiled_filename);
     559             : 
     560             :         if (CG(start_lineno)) {
     561             :                 CG(zend_lineno) = CG(start_lineno);
     562             :                 CG(start_lineno) = 0;
     563             :         } else {
     564             :                 CG(zend_lineno) = 1;
     565             :         }
     566             : 
     567             :         RESET_DOC_COMMENT();
     568             :         CG(increment_lineno) = 0;
     569             :         return SUCCESS;
     570             : }
     571             : END_EXTERN_C()
     572             : 
     573             : static zend_op_array *zend_compile(int type)
     574             : {
     575             :         zend_op_array *op_array = NULL;
     576             :         zend_bool original_in_compilation = CG(in_compilation);
     577             : 
     578             :         CG(in_compilation) = 1;
     579             :         CG(ast) = NULL;
     580             :         CG(ast_arena) = zend_arena_create(1024 * 32);
     581             : 
     582             :         if (!zendparse()) {
     583             :                 zend_file_context original_file_context;
     584             :                 zend_oparray_context original_oparray_context;
     585             :                 zend_op_array *original_active_op_array = CG(active_op_array);
     586             : 
     587             :                 op_array = emalloc(sizeof(zend_op_array));
     588             :                 init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);
     589             :                 CG(active_op_array) = op_array;
     590             : 
     591             :                 if (zend_ast_process) {
     592             :                         zend_ast_process(CG(ast));
     593             :                 }
     594             : 
     595             :                 zend_file_context_begin(&original_file_context);
     596             :                 zend_oparray_context_begin(&original_oparray_context);
     597             :                 zend_compile_top_stmt(CG(ast));
     598             :                 zend_emit_final_return(type == ZEND_USER_FUNCTION);
     599             :                 op_array->line_start = 1;
     600             :                 op_array->line_end = CG(zend_lineno);
     601             :                 pass_two(op_array);
     602             :                 zend_oparray_context_end(&original_oparray_context);
     603             :                 zend_file_context_end(&original_file_context);
     604             : 
     605             :                 CG(active_op_array) = original_active_op_array;
     606             :         }
     607             : 
     608             :         zend_ast_destroy(CG(ast));
     609             :         zend_arena_destroy(CG(ast_arena));
     610             : 
     611             :         CG(in_compilation) = original_in_compilation;
     612             : 
     613             :         return op_array;
     614             : }
     615             : 
     616             : ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)
     617             : {
     618             :         zend_lex_state original_lex_state;
     619             :         zend_op_array *op_array = NULL;
     620             :         zend_save_lexical_state(&original_lex_state);
     621             : 
     622             :         if (open_file_for_scanning(file_handle)==FAILURE) {
     623             :                 if (type==ZEND_REQUIRE) {
     624             :                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
     625             :                         zend_bailout();
     626             :                 } else {
     627             :                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename);
     628             :                 }
     629             :         } else {
     630             :                 op_array = zend_compile(ZEND_USER_FUNCTION);
     631             :         }
     632             : 
     633             :         zend_restore_lexical_state(&original_lex_state);
     634             :         return op_array;
     635             : }
     636             : 
     637             : 
     638             : zend_op_array *compile_filename(int type, zval *filename)
     639             : {
     640             :         zend_file_handle file_handle;
     641             :         zval tmp;
     642             :         zend_op_array *retval;
     643             :         zend_string *opened_path = NULL;
     644             : 
     645             :         if (Z_TYPE_P(filename) != IS_STRING) {
     646             :                 tmp = *filename;
     647             :                 zval_copy_ctor(&tmp);
     648             :                 convert_to_string(&tmp);
     649             :                 filename = &tmp;
     650             :         }
     651             :         file_handle.filename = Z_STRVAL_P(filename);
     652             :         file_handle.free_filename = 0;
     653             :         file_handle.type = ZEND_HANDLE_FILENAME;
     654             :         file_handle.opened_path = NULL;
     655             :         file_handle.handle.fp = NULL;
     656             : 
     657             :         retval = zend_compile_file(&file_handle, type);
     658             :         if (retval && file_handle.handle.stream.handle) {
     659             :                 if (!file_handle.opened_path) {
     660             :                         file_handle.opened_path = opened_path = zend_string_copy(Z_STR_P(filename));
     661             :                 }
     662             : 
     663             :                 zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);
     664             : 
     665             :                 if (opened_path) {
     666             :                         zend_string_release(opened_path);
     667             :                 }
     668             :         }
     669             :         zend_destroy_file_handle(&file_handle);
     670             : 
     671             :         if (filename==&tmp) {
     672             :                 zval_dtor(&tmp);
     673             :         }
     674             :         return retval;
     675             : }
     676             : 
     677             : ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename)
     678             : {
     679             :         char *buf;
     680             :         size_t size, old_len;
     681             :         zend_string *new_compiled_filename;
     682             : 
     683             :         /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
     684             :         old_len = Z_STRLEN_P(str);
     685             :         Z_STR_P(str) = zend_string_extend(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
     686             :         Z_TYPE_INFO_P(str) = IS_STRING_EX;
     687             :         memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
     688             : 
     689             :         SCNG(yy_in) = NULL;
     690             :         SCNG(yy_start) = NULL;
     691             : 
     692             :         buf = Z_STRVAL_P(str);
     693             :         size = old_len;
     694             : 
     695             :         if (CG(multibyte)) {
     696             :                 SCNG(script_org) = (unsigned char*)buf;
     697             :                 SCNG(script_org_size) = size;
     698             :                 SCNG(script_filtered) = NULL;
     699             : 
     700             :                 zend_multibyte_set_filter(zend_multibyte_get_internal_encoding());
     701             : 
     702             :                 if (SCNG(input_filter)) {
     703             :                         if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {
     704             :                                 zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
     705             :                                                 "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
     706             :                         }
     707             :                         buf = (char*)SCNG(script_filtered);
     708             :                         size = SCNG(script_filtered_size);
     709             :                 }
     710             :         }
     711             : 
     712             :         yy_scan_buffer(buf, (unsigned int)size);
     713             : 
     714             :         new_compiled_filename = zend_string_init(filename, strlen(filename), 0);
     715             :         zend_set_compiled_filename(new_compiled_filename);
     716             :         zend_string_release(new_compiled_filename);
     717             :         CG(zend_lineno) = 1;
     718             :         CG(increment_lineno) = 0;
     719             :         RESET_DOC_COMMENT();
     720             :         return SUCCESS;
     721             : }
     722             : 
     723             : 
     724             : ZEND_API size_t zend_get_scanned_file_offset(void)
     725             : {
     726             :         size_t offset = SCNG(yy_cursor) - SCNG(yy_start);
     727             :         if (SCNG(input_filter)) {
     728             :                 size_t original_offset = offset, length = 0;
     729             :                 do {
     730             :                         unsigned char *p = NULL;
     731             :                         if ((size_t)-1 == SCNG(input_filter)(&p, &length, SCNG(script_org), offset)) {
     732             :                                 return (size_t)-1;
     733             :                         }
     734             :                         efree(p);
     735             :                         if (length > original_offset) {
     736             :                                 offset--;
     737             :                         } else if (length < original_offset) {
     738             :                                 offset++;
     739             :                         }
     740             :                 } while (original_offset != length);
     741             :         }
     742             :         return offset;
     743             : }
     744             : 
     745             : zend_op_array *compile_string(zval *source_string, char *filename)
     746             : {
     747             :         zend_lex_state original_lex_state;
     748             :         zend_op_array *op_array = NULL;
     749             :         zval tmp;
     750             : 
     751             :         if (Z_STRLEN_P(source_string)==0) {
     752             :                 return NULL;
     753             :         }
     754             : 
     755             :         ZVAL_DUP(&tmp, source_string);
     756             :         convert_to_string(&tmp);
     757             :         source_string = &tmp;
     758             : 
     759             :         zend_save_lexical_state(&original_lex_state);
     760             :         if (zend_prepare_string_for_scanning(source_string, filename) == SUCCESS) {
     761             :                 BEGIN(ST_IN_SCRIPTING);
     762             :                 op_array = zend_compile(ZEND_EVAL_CODE);
     763             :         }
     764             : 
     765             :         zend_restore_lexical_state(&original_lex_state);
     766             :         zval_dtor(&tmp);
     767             : 
     768             :         return op_array;
     769             : }
     770             : 
     771             : 
     772             : BEGIN_EXTERN_C()
     773             : int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini)
     774             : {
     775             :         zend_lex_state original_lex_state;
     776             :         zend_file_handle file_handle;
     777             : 
     778             :         file_handle.type = ZEND_HANDLE_FILENAME;
     779             :         file_handle.filename = filename;
     780             :         file_handle.free_filename = 0;
     781             :         file_handle.opened_path = NULL;
     782             :         zend_save_lexical_state(&original_lex_state);
     783             :         if (open_file_for_scanning(&file_handle)==FAILURE) {
     784             :                 zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
     785             :                 zend_restore_lexical_state(&original_lex_state);
     786             :                 return FAILURE;
     787             :         }
     788             :         zend_highlight(syntax_highlighter_ini);
     789             :         if (SCNG(script_filtered)) {
     790             :                 efree(SCNG(script_filtered));
     791             :                 SCNG(script_filtered) = NULL;
     792             :         }
     793             :         zend_destroy_file_handle(&file_handle);
     794             :         zend_restore_lexical_state(&original_lex_state);
     795             :         return SUCCESS;
     796             : }
     797             : 
     798             : int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name)
     799             : {
     800             :         zend_lex_state original_lex_state;
     801             :         zval tmp = *str;
     802             : 
     803             :         str = &tmp;
     804             :         zval_copy_ctor(str);
     805             :         zend_save_lexical_state(&original_lex_state);
     806             :         if (zend_prepare_string_for_scanning(str, str_name)==FAILURE) {
     807             :                 zend_restore_lexical_state(&original_lex_state);
     808             :                 return FAILURE;
     809             :         }
     810             :         BEGIN(INITIAL);
     811             :         zend_highlight(syntax_highlighter_ini);
     812             :         if (SCNG(script_filtered)) {
     813             :                 efree(SCNG(script_filtered));
     814             :                 SCNG(script_filtered) = NULL;
     815             :         }
     816             :         zend_restore_lexical_state(&original_lex_state);
     817             :         zval_dtor(str);
     818             :         return SUCCESS;
     819             : }
     820             : 
     821             : ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding)
     822             : {
     823             :         size_t length;
     824             :         unsigned char *new_yy_start;
     825             : 
     826             :         /* convert and set */
     827             :         if (!SCNG(input_filter)) {
     828             :                 if (SCNG(script_filtered)) {
     829             :                         efree(SCNG(script_filtered));
     830             :                         SCNG(script_filtered) = NULL;
     831             :                 }
     832             :                 SCNG(script_filtered_size) = 0;
     833             :                 length = SCNG(script_org_size);
     834             :                 new_yy_start = SCNG(script_org);
     835             :         } else {
     836             :                 if ((size_t)-1 == SCNG(input_filter)(&new_yy_start, &length, SCNG(script_org), SCNG(script_org_size))) {
     837             :                         zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
     838             :                                         "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
     839             :                 }
     840             :                 if (SCNG(script_filtered)) {
     841             :                         efree(SCNG(script_filtered));
     842             :                 }
     843             :                 SCNG(script_filtered) = new_yy_start;
     844             :                 SCNG(script_filtered_size) = length;
     845             :         }
     846             : 
     847             :         SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));
     848             :         SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));
     849             :         SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));
     850             :         SCNG(yy_limit) = new_yy_start + length;
     851             : 
     852             :         SCNG(yy_start) = new_yy_start;
     853             : }
     854             : 
     855             : 
     856             : // TODO: avoid reallocation ???
     857             : # define zend_copy_value(zendlval, yytext, yyleng) \
     858             :         if (SCNG(output_filter)) { \
     859             :                 size_t sz = 0; \
     860             :                 char *s = NULL; \
     861             :                 SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng); \
     862             :                 ZVAL_STRINGL(zendlval, s, sz); \
     863             :                 efree(s); \
     864             :         } else { \
     865             :                 ZVAL_STRINGL(zendlval, yytext, yyleng); \
     866             :         }
     867             : 
     868             : static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type)
     869             : {
     870             :         register char *s, *t;
     871             :         char *end;
     872             : 
     873             :         ZVAL_STRINGL(zendlval, str, len);
     874             : 
     875             :         /* convert escape sequences */
     876             :         s = t = Z_STRVAL_P(zendlval);
     877             :         end = s+Z_STRLEN_P(zendlval);
     878             :         while (s<end) {
     879             :                 if (*s=='\\') {
     880             :                         s++;
     881             :                         if (s >= end) {
     882             :                                 *t++ = '\\';
     883             :                                 break;
     884             :                         }
     885             : 
     886             :                         switch(*s) {
     887             :                                 case 'n':
     888             :                                         *t++ = '\n';
     889             :                                         Z_STRLEN_P(zendlval)--;
     890             :                                         break;
     891             :                                 case 'r':
     892             :                                         *t++ = '\r';
     893             :                                         Z_STRLEN_P(zendlval)--;
     894             :                                         break;
     895             :                                 case 't':
     896             :                                         *t++ = '\t';
     897             :                                         Z_STRLEN_P(zendlval)--;
     898             :                                         break;
     899             :                                 case 'f':
     900             :                                         *t++ = '\f';
     901             :                                         Z_STRLEN_P(zendlval)--;
     902             :                                         break;
     903             :                                 case 'v':
     904             :                                         *t++ = '\v';
     905             :                                         Z_STRLEN_P(zendlval)--;
     906             :                                         break;
     907             :                                 case 'e':
     908             : #ifdef ZEND_WIN32
     909             :                                         *t++ = VK_ESCAPE;
     910             : #else
     911             :                                         *t++ = '\e';
     912             : #endif
     913             :                                         Z_STRLEN_P(zendlval)--;
     914             :                                         break;
     915             :                                 case '"':
     916             :                                 case '`':
     917             :                                         if (*s != quote_type) {
     918             :                                                 *t++ = '\\';
     919             :                                                 *t++ = *s;
     920             :                                                 break;
     921             :                                         }
     922             :                                 case '\\':
     923             :                                 case '$':
     924             :                                         *t++ = *s;
     925             :                                         Z_STRLEN_P(zendlval)--;
     926             :                                         break;
     927             :                                 case 'x':
     928             :                                 case 'X':
     929             :                                         if (ZEND_IS_HEX(*(s+1))) {
     930             :                                                 char hex_buf[3] = { 0, 0, 0 };
     931             : 
     932             :                                                 Z_STRLEN_P(zendlval)--; /* for the 'x' */
     933             : 
     934             :                                                 hex_buf[0] = *(++s);
     935             :                                                 Z_STRLEN_P(zendlval)--;
     936             :                                                 if (ZEND_IS_HEX(*(s+1))) {
     937             :                                                         hex_buf[1] = *(++s);
     938             :                                                         Z_STRLEN_P(zendlval)--;
     939             :                                                 }
     940             :                                                 *t++ = (char) ZEND_STRTOL(hex_buf, NULL, 16);
     941             :                                         } else {
     942             :                                                 *t++ = '\\';
     943             :                                                 *t++ = *s;
     944             :                                         }
     945             :                                         break;
     946             :                                 /* UTF-8 codepoint escape, format: /\\u\{\x+\}/ */
     947             :                                 case 'u':
     948             :                                         {
     949             :                                                 /* cache where we started so we can parse after validating */
     950             :                                                 char *start = s + 1;
     951             :                                                 size_t len = 0;
     952             :                                                 zend_bool valid = 1;
     953             :                                                 unsigned long codepoint;
     954             :                                                 size_t byte_len = 0;
     955             : 
     956             :                                                 if (*start != '{') {
     957             :                                                         /* we silently let this pass to avoid breaking code
     958             :                                                          * with JSON in string literals (e.g. "\"\u202e\""
     959             :                                                          */
     960             :                                                         *t++ = '\\';
     961             :                                                         *t++ = 'u';
     962             :                                                         break;
     963             :                                                 } else {
     964             :                                                         /* on the other hand, invalid \u{blah} errors */
     965             :                                                         s++;
     966             :                                                         len++;
     967             :                                                         s++;
     968             :                                                         while (*s != '}') {
     969             :                                                                 if (!ZEND_IS_HEX(*s)) {
     970             :                                                                         valid = 0;
     971             :                                                                         break;
     972             :                                                                 } else {
     973             :                                                                         len++;
     974             :                                                                 }
     975             :                                                                 s++;
     976             :                                                         }
     977             :                                                         if (*s == '}') {
     978             :                                                                 valid = 1;
     979             :                                                                 len++;
     980             :                                                         }
     981             :                                                 }
     982             : 
     983             :                                                 /* \u{} is invalid */
     984             :                                                 if (len <= 2) {
     985             :                                                         valid = 0;
     986             :                                                 }
     987             : 
     988             :                                                 if (!valid) {
     989             :                                                         zend_throw_exception(zend_ce_parse_error,
     990             :                                                                 "Invalid UTF-8 codepoint escape sequence", 0);
     991             :                                                         zval_ptr_dtor(zendlval);
     992             :                                                         ZVAL_UNDEF(zendlval);
     993             :                                                         return FAILURE;
     994             :                                                 }
     995             : 
     996             :                                                 errno = 0;
     997             :                                                 codepoint = strtoul(start + 1, NULL, 16);
     998             : 
     999             :                                                 /* per RFC 3629, UTF-8 can only represent 21 bits */
    1000             :                                                 if (codepoint > 0x10FFFF || errno) {
    1001             :                                                         zend_throw_exception(zend_ce_parse_error,
    1002             :                                                                 "Invalid UTF-8 codepoint escape sequence: Codepoint too large", 0);
    1003             :                                                         zval_ptr_dtor(zendlval);
    1004             :                                                         ZVAL_UNDEF(zendlval);
    1005             :                                                         return FAILURE;
    1006             :                                                 }
    1007             : 
    1008             :                                                 /* based on https://en.wikipedia.org/wiki/UTF-8#Sample_code */
    1009             :                                                 if (codepoint < 0x80) {
    1010             :                                                         byte_len = 1;
    1011             :                                                         *t++ = codepoint;
    1012             :                                                 } else if (codepoint <= 0x7FF) {
    1013             :                                                         byte_len = 2;
    1014             :                                                         *t++ = (codepoint >> 6) + 0xC0;
    1015             :                                                         *t++ = (codepoint & 0x3F) + 0x80;
    1016             :                                                 } else if (codepoint <= 0xFFFF) {
    1017             :                                                         byte_len = 3;
    1018             :                                                         *t++ = (codepoint >> 12) + 0xE0;
    1019             :                                                         *t++ = ((codepoint >> 6) & 0x3F) + 0x80;
    1020             :                                                         *t++ = (codepoint & 0x3F) + 0x80;
    1021             :                                                 } else if (codepoint <= 0x10FFFF) {
    1022             :                                                         byte_len = 4;
    1023             :                                                         *t++ = (codepoint >> 18) + 0xF0;
    1024             :                                                         *t++ = ((codepoint >> 12) & 0x3F) + 0x80;
    1025             :                                                         *t++ = ((codepoint >> 6) & 0x3F) + 0x80;
    1026             :                                                         *t++ = (codepoint & 0x3F) + 0x80;
    1027             :                                                 }
    1028             : 
    1029             :                                                 Z_STRLEN_P(zendlval) -= 2; /* \u */
    1030             :                                                 Z_STRLEN_P(zendlval) -= (len - byte_len);
    1031             :                                         }
    1032             :                                         break;
    1033             :                                 default:
    1034             :                                         /* check for an octal */
    1035             :                                         if (ZEND_IS_OCT(*s)) {
    1036             :                                                 char octal_buf[4] = { 0, 0, 0, 0 };
    1037             : 
    1038             :                                                 octal_buf[0] = *s;
    1039             :                                                 Z_STRLEN_P(zendlval)--;
    1040             :                                                 if (ZEND_IS_OCT(*(s+1))) {
    1041             :                                                         octal_buf[1] = *(++s);
    1042             :                                                         Z_STRLEN_P(zendlval)--;
    1043             :                                                         if (ZEND_IS_OCT(*(s+1))) {
    1044             :                                                                 octal_buf[2] = *(++s);
    1045             :                                                                 Z_STRLEN_P(zendlval)--;
    1046             :                                                         }
    1047             :                                                 }
    1048             :                                                 *t++ = (char) ZEND_STRTOL(octal_buf, NULL, 8);
    1049             :                                         } else {
    1050             :                                                 *t++ = '\\';
    1051             :                                                 *t++ = *s;
    1052             :                                         }
    1053             :                                         break;
    1054             :                         }
    1055             :                 } else {
    1056             :                         *t++ = *s;
    1057             :                 }
    1058             : 
    1059             :                 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
    1060             :                         CG(zend_lineno)++;
    1061             :                 }
    1062             :                 s++;
    1063             :         }
    1064             :         *t = 0;
    1065             :         if (SCNG(output_filter)) {
    1066             :                 size_t sz = 0;
    1067             :                 unsigned char *str;
    1068             :                 // TODO: avoid realocation ???
    1069             :                 s = Z_STRVAL_P(zendlval);
    1070             :                 SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval));
    1071             :                 zval_ptr_dtor(zendlval);
    1072             :                 ZVAL_STRINGL(zendlval, (char *) str, sz);
    1073             :                 efree(str);
    1074             :         }
    1075             :         return SUCCESS;
    1076             : }
    1077             : 
    1078             : static zend_always_inline int emit_token(int token, int token_line)
    1079             : {
    1080             :         if(SCNG(on_event)) SCNG(on_event)(ON_TOKEN, token, token_line);
    1081             : 
    1082             :         return token;
    1083             : }
    1084             : 
    1085             : #define RETURN_TOKEN(token) return emit_token(token, start_line);
    1086             : 
    1087             : int lex_scan(zval *zendlval)
    1088             : {
    1089             : 
    1090             : int start_line = CG(zend_lineno);
    1091             : 
    1092             : restart:
    1093             :         SCNG(yy_text) = YYCURSOR;
    1094             : 
    1095             : 
    1096             : #line 1097 "Zend/zend_language_scanner.c"
    1097             : {
    1098             :         YYCTYPE yych;
    1099     7821024 :         unsigned int yyaccept = 0;
    1100     7821024 :         if (YYGETCONDITION() < 5) {
    1101     7749584 :                 if (YYGETCONDITION() < 2) {
    1102     7674561 :                         if (YYGETCONDITION() < 1) {
    1103     7625381 :                                 goto yyc_ST_IN_SCRIPTING;
    1104             :                         } else {
    1105       49180 :                                 goto yyc_ST_LOOKING_FOR_PROPERTY;
    1106             :                         }
    1107             :                 } else {
    1108       75023 :                         if (YYGETCONDITION() < 3) {
    1109         470 :                                 goto yyc_ST_BACKQUOTE;
    1110             :                         } else {
    1111       74553 :                                 if (YYGETCONDITION() < 4) {
    1112       72104 :                                         goto yyc_ST_DOUBLE_QUOTES;
    1113             :                                 } else {
    1114        2449 :                                         goto yyc_ST_HEREDOC;
    1115             :                                 }
    1116             :                         }
    1117             :                 }
    1118             :         } else {
    1119       71440 :                 if (YYGETCONDITION() < 7) {
    1120        3345 :                         if (YYGETCONDITION() < 6) {
    1121         380 :                                 goto yyc_ST_LOOKING_FOR_VARNAME;
    1122             :                         } else {
    1123        2965 :                                 goto yyc_ST_VAR_OFFSET;
    1124             :                         }
    1125             :                 } else {
    1126       68095 :                         if (YYGETCONDITION() < 8) {
    1127       66389 :                                 goto yyc_INITIAL;
    1128             :                         } else {
    1129        1706 :                                 if (YYGETCONDITION() < 9) {
    1130        1593 :                                         goto yyc_ST_END_HEREDOC;
    1131             :                                 } else {
    1132         113 :                                         goto yyc_ST_NOWDOC;
    1133             :                                 }
    1134             :                         }
    1135             :                 }
    1136             :         }
    1137             : /* *********************************** */
    1138             : yyc_INITIAL:
    1139             : 
    1140             :         YYDEBUG(0, *YYCURSOR);
    1141       66389 :         YYFILL(7);
    1142       66389 :         yych = *YYCURSOR;
    1143       66389 :         if (yych != '<') goto yy4;
    1144             :         YYDEBUG(2, *YYCURSOR);
    1145       32829 :         ++YYCURSOR;
    1146       32829 :         if ((yych = *YYCURSOR) == '?') goto yy5;
    1147             : yy3:
    1148             :         YYDEBUG(3, *YYCURSOR);
    1149       33654 :         yyleng = YYCURSOR - SCNG(yy_text);
    1150             : #line 1788 "Zend/zend_language_scanner.l"
    1151             :         {
    1152             :         if (YYCURSOR > YYLIMIT) {
    1153             :                 RETURN_TOKEN(END);
    1154             :         }
    1155             : 
    1156             : inline_char_handler:
    1157             : 
    1158             :         while (1) {
    1159             :                 YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
    1160             : 
    1161             :                 YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
    1162             : 
    1163             :                 if (YYCURSOR >= YYLIMIT) {
    1164             :                         break;
    1165             :                 }
    1166             : 
    1167             :                 if (*YYCURSOR == '?') {
    1168             :                         if (CG(short_tags) || !strncasecmp((char*)YYCURSOR + 1, "php", 3) || (*(YYCURSOR + 1) == '=')) { /* Assume [ \t\n\r] follows "php" */
    1169             : 
    1170             :                                 YYCURSOR--;
    1171             :                                 break;
    1172             :                         }
    1173             :                 }
    1174             :         }
    1175             : 
    1176             :         yyleng = YYCURSOR - SCNG(yy_text);
    1177             : 
    1178             :         if (SCNG(output_filter)) {
    1179             :                 size_t readsize;
    1180             :                 char *s = NULL;
    1181             :                 size_t sz = 0;
    1182             :                 // TODO: avoid reallocation ???
    1183             :                 readsize = SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng);
    1184             :                 ZVAL_STRINGL(zendlval, s, sz);
    1185             :                 efree(s);
    1186             :                 if (readsize < yyleng) {
    1187             :                         yyless(readsize);
    1188             :                 }
    1189             :         } else {
    1190             :           ZVAL_STRINGL(zendlval, yytext, yyleng);
    1191             :         }
    1192             :         HANDLE_NEWLINES(yytext, yyleng);
    1193             :         RETURN_TOKEN(T_INLINE_HTML);
    1194             : }
    1195             : #line 1196 "Zend/zend_language_scanner.c"
    1196             : yy4:
    1197             :         YYDEBUG(4, *YYCURSOR);
    1198       33560 :         yych = *++YYCURSOR;
    1199       33560 :         goto yy3;
    1200             : yy5:
    1201             :         YYDEBUG(5, *YYCURSOR);
    1202       32735 :         yyaccept = 0;
    1203       32735 :         yych = *(YYMARKER = ++YYCURSOR);
    1204       32735 :         if (yych <= 'O') {
    1205           8 :                 if (yych == '=') goto yy7;
    1206             :         } else {
    1207       32727 :                 if (yych <= 'P') goto yy9;
    1208       32412 :                 if (yych == 'p') goto yy9;
    1209             :         }
    1210             : yy6:
    1211             :         YYDEBUG(6, *YYCURSOR);
    1212           4 :         yyleng = YYCURSOR - SCNG(yy_text);
    1213             : #line 1779 "Zend/zend_language_scanner.l"
    1214             :         {
    1215             :         if (CG(short_tags)) {
    1216             :                 BEGIN(ST_IN_SCRIPTING);
    1217             :                 RETURN_TOKEN(T_OPEN_TAG);
    1218             :         } else {
    1219             :                 goto inline_char_handler;
    1220             :         }
    1221             : }
    1222             : #line 1223 "Zend/zend_language_scanner.c"
    1223             : yy7:
    1224             :         YYDEBUG(7, *YYCURSOR);
    1225           4 :         ++YYCURSOR;
    1226             :         YYDEBUG(8, *YYCURSOR);
    1227           4 :         yyleng = YYCURSOR - SCNG(yy_text);
    1228             : #line 1766 "Zend/zend_language_scanner.l"
    1229             :         {
    1230             :         BEGIN(ST_IN_SCRIPTING);
    1231             :         RETURN_TOKEN(T_OPEN_TAG_WITH_ECHO);
    1232             : }
    1233             : #line 1234 "Zend/zend_language_scanner.c"
    1234             : yy9:
    1235             :         YYDEBUG(9, *YYCURSOR);
    1236       32727 :         yych = *++YYCURSOR;
    1237       32727 :         if (yych == 'H') goto yy11;
    1238       32412 :         if (yych == 'h') goto yy11;
    1239             : yy10:
    1240             :         YYDEBUG(10, *YYCURSOR);
    1241           0 :         YYCURSOR = YYMARKER;
    1242           0 :         goto yy6;
    1243             : yy11:
    1244             :         YYDEBUG(11, *YYCURSOR);
    1245       32727 :         yych = *++YYCURSOR;
    1246       32727 :         if (yych == 'P') goto yy12;
    1247       32412 :         if (yych != 'p') goto yy10;
    1248             : yy12:
    1249             :         YYDEBUG(12, *YYCURSOR);
    1250       32727 :         yych = *++YYCURSOR;
    1251       32727 :         if (yych <= '\f') {
    1252       26525 :                 if (yych <= 0x08) goto yy10;
    1253       26525 :                 if (yych >= '\v') goto yy10;
    1254             :         } else {
    1255        6202 :                 if (yych <= '\r') goto yy15;
    1256        5974 :                 if (yych != ' ') goto yy10;
    1257             :         }
    1258             : yy13:
    1259             :         YYDEBUG(13, *YYCURSOR);
    1260       32727 :         ++YYCURSOR;
    1261             : yy14:
    1262             :         YYDEBUG(14, *YYCURSOR);
    1263       32727 :         yyleng = YYCURSOR - SCNG(yy_text);
    1264             : #line 1772 "Zend/zend_language_scanner.l"
    1265             :         {
    1266             :         HANDLE_NEWLINE(yytext[yyleng-1]);
    1267             :         BEGIN(ST_IN_SCRIPTING);
    1268             :         RETURN_TOKEN(T_OPEN_TAG);
    1269             : }
    1270             : #line 1271 "Zend/zend_language_scanner.c"
    1271             : yy15:
    1272             :         YYDEBUG(15, *YYCURSOR);
    1273         228 :         ++YYCURSOR;
    1274         228 :         if ((yych = *YYCURSOR) == '\n') goto yy13;
    1275           0 :         goto yy14;
    1276             : /* *********************************** */
    1277             : yyc_ST_BACKQUOTE:
    1278             :         {
    1279             :                 static const unsigned char yybm[] = {
    1280             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1281             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1282             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1283             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1284             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1285             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1286             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1287             :                         128, 128,   0,   0,   0,   0,   0,   0, 
    1288             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1289             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1290             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1291             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1292             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1293             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1294             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1295             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1296             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1297             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1298             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1299             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1300             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1301             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1302             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1303             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1304             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1305             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1306             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1307             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1308             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1309             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1310             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1311             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1312             :                 };
    1313             :                 YYDEBUG(16, *YYCURSOR);
    1314         470 :                 YYFILL(2);
    1315         470 :                 yych = *YYCURSOR;
    1316         470 :                 if (yych <= '_') {
    1317         333 :                         if (yych != '$') goto yy23;
    1318             :                 } else {
    1319         137 :                         if (yych <= '`') goto yy21;
    1320          17 :                         if (yych == '{') goto yy20;
    1321          17 :                         goto yy23;
    1322             :                 }
    1323             :                 YYDEBUG(18, *YYCURSOR);
    1324         157 :                 ++YYCURSOR;
    1325         157 :                 if ((yych = *YYCURSOR) <= '_') {
    1326           0 :                         if (yych <= '@') goto yy19;
    1327           0 :                         if (yych <= 'Z') goto yy26;
    1328           0 :                         if (yych >= '_') goto yy26;
    1329             :                 } else {
    1330         157 :                         if (yych <= 'z') {
    1331         157 :                                 if (yych >= 'a') goto yy26;
    1332             :                         } else {
    1333           0 :                                 if (yych <= '{') goto yy29;
    1334           0 :                                 if (yych >= 0x7F) goto yy26;
    1335             :                         }
    1336             :                 }
    1337             : yy19:
    1338             :                 YYDEBUG(19, *YYCURSOR);
    1339         193 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1340             : #line 2198 "Zend/zend_language_scanner.l"
    1341             :                 {
    1342             :         if (YYCURSOR > YYLIMIT) {
    1343             :                 RETURN_TOKEN(END);
    1344             :         }
    1345             :         if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
    1346             :                 YYCURSOR++;
    1347             :         }
    1348             : 
    1349             :         while (YYCURSOR < YYLIMIT) {
    1350             :                 switch (*YYCURSOR++) {
    1351             :                         case '`':
    1352             :                                 break;
    1353             :                         case '$':
    1354             :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    1355             :                                         break;
    1356             :                                 }
    1357             :                                 continue;
    1358             :                         case '{':
    1359             :                                 if (*YYCURSOR == '$') {
    1360             :                                         break;
    1361             :                                 }
    1362             :                                 continue;
    1363             :                         case '\\':
    1364             :                                 if (YYCURSOR < YYLIMIT) {
    1365             :                                         YYCURSOR++;
    1366             :                                 }
    1367             :                                 /* fall through */
    1368             :                         default:
    1369             :                                 continue;
    1370             :                 }
    1371             : 
    1372             :                 YYCURSOR--;
    1373             :                 break;
    1374             :         }
    1375             : 
    1376             :         yyleng = YYCURSOR - SCNG(yy_text);
    1377             : 
    1378             :         zend_scan_escape_string(zendlval, yytext, yyleng, '`');
    1379             :         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    1380             : }
    1381             : #line 1382 "Zend/zend_language_scanner.c"
    1382             : yy20:
    1383             :                 YYDEBUG(20, *YYCURSOR);
    1384           0 :                 yych = *++YYCURSOR;
    1385           0 :                 if (yych == '$') goto yy24;
    1386           0 :                 goto yy19;
    1387             : yy21:
    1388             :                 YYDEBUG(21, *YYCURSOR);
    1389         120 :                 ++YYCURSOR;
    1390             :                 YYDEBUG(22, *YYCURSOR);
    1391         120 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1392             : #line 2142 "Zend/zend_language_scanner.l"
    1393             :                 {
    1394             :         BEGIN(ST_IN_SCRIPTING);
    1395             :         RETURN_TOKEN('`');
    1396             : }
    1397             : #line 1398 "Zend/zend_language_scanner.c"
    1398             : yy23:
    1399             :                 YYDEBUG(23, *YYCURSOR);
    1400         193 :                 yych = *++YYCURSOR;
    1401         193 :                 goto yy19;
    1402             : yy24:
    1403             :                 YYDEBUG(24, *YYCURSOR);
    1404           0 :                 ++YYCURSOR;
    1405             :                 YYDEBUG(25, *YYCURSOR);
    1406           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1407             : #line 2129 "Zend/zend_language_scanner.l"
    1408             :                 {
    1409             :         Z_LVAL_P(zendlval) = (zend_long) '{';
    1410             :         yy_push_state(ST_IN_SCRIPTING);
    1411             :         yyless(1);
    1412             :         RETURN_TOKEN(T_CURLY_OPEN);
    1413             : }
    1414             : #line 1415 "Zend/zend_language_scanner.c"
    1415             : yy26:
    1416             :                 YYDEBUG(26, *YYCURSOR);
    1417         725 :                 yyaccept = 0;
    1418         725 :                 YYMARKER = ++YYCURSOR;
    1419         725 :                 YYFILL(3);
    1420         725 :                 yych = *YYCURSOR;
    1421             :                 YYDEBUG(27, *YYCURSOR);
    1422         725 :                 if (yybm[0+yych] & 128) {
    1423         568 :                         goto yy26;
    1424             :                 }
    1425         157 :                 if (yych == '-') goto yy31;
    1426         157 :                 if (yych == '[') goto yy33;
    1427             : yy28:
    1428             :                 YYDEBUG(28, *YYCURSOR);
    1429         157 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1430             : #line 1853 "Zend/zend_language_scanner.l"
    1431             :                 {
    1432             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1433             :         RETURN_TOKEN(T_VARIABLE);
    1434             : }
    1435             : #line 1436 "Zend/zend_language_scanner.c"
    1436             : yy29:
    1437             :                 YYDEBUG(29, *YYCURSOR);
    1438           0 :                 ++YYCURSOR;
    1439             :                 YYDEBUG(30, *YYCURSOR);
    1440           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1441             : #line 1571 "Zend/zend_language_scanner.l"
    1442             :                 {
    1443             :         yy_push_state(ST_LOOKING_FOR_VARNAME);
    1444             :         RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
    1445             : }
    1446             : #line 1447 "Zend/zend_language_scanner.c"
    1447             : yy31:
    1448             :                 YYDEBUG(31, *YYCURSOR);
    1449           0 :                 yych = *++YYCURSOR;
    1450           0 :                 if (yych == '>') goto yy35;
    1451             : yy32:
    1452             :                 YYDEBUG(32, *YYCURSOR);
    1453           0 :                 YYCURSOR = YYMARKER;
    1454           0 :                 goto yy28;
    1455             : yy33:
    1456             :                 YYDEBUG(33, *YYCURSOR);
    1457           0 :                 ++YYCURSOR;
    1458             :                 YYDEBUG(34, *YYCURSOR);
    1459           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1460             : #line 1846 "Zend/zend_language_scanner.l"
    1461             :                 {
    1462             :         yyless(yyleng - 1);
    1463             :         yy_push_state(ST_VAR_OFFSET);
    1464             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1465             :         RETURN_TOKEN(T_VARIABLE);
    1466             : }
    1467             : #line 1468 "Zend/zend_language_scanner.c"
    1468             : yy35:
    1469             :                 YYDEBUG(35, *YYCURSOR);
    1470           0 :                 yych = *++YYCURSOR;
    1471           0 :                 if (yych <= '_') {
    1472           0 :                         if (yych <= '@') goto yy32;
    1473           0 :                         if (yych <= 'Z') goto yy36;
    1474           0 :                         if (yych <= '^') goto yy32;
    1475             :                 } else {
    1476           0 :                         if (yych <= '`') goto yy32;
    1477           0 :                         if (yych <= 'z') goto yy36;
    1478           0 :                         if (yych <= '~') goto yy32;
    1479             :                 }
    1480             : yy36:
    1481             :                 YYDEBUG(36, *YYCURSOR);
    1482           0 :                 ++YYCURSOR;
    1483             :                 YYDEBUG(37, *YYCURSOR);
    1484           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1485             : #line 1837 "Zend/zend_language_scanner.l"
    1486             :                 {
    1487             :         yyless(yyleng - 3);
    1488             :         yy_push_state(ST_LOOKING_FOR_PROPERTY);
    1489             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1490             :         RETURN_TOKEN(T_VARIABLE);
    1491             : }
    1492             : #line 1493 "Zend/zend_language_scanner.c"
    1493             :         }
    1494             : /* *********************************** */
    1495             : yyc_ST_DOUBLE_QUOTES:
    1496             :         {
    1497             :                 static const unsigned char yybm[] = {
    1498             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1499             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1500             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1501             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1502             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1503             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1504             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1505             :                         128, 128,   0,   0,   0,   0,   0,   0, 
    1506             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1507             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1508             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1509             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1510             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1511             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1512             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1513             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1514             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1515             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1516             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1517             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1518             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1519             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1520             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1521             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1522             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1523             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1524             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1525             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1526             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1527             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1528             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1529             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1530             :                 };
    1531             :                 YYDEBUG(38, *YYCURSOR);
    1532       72104 :                 YYFILL(2);
    1533       72104 :                 yych = *YYCURSOR;
    1534       72104 :                 if (yych <= '#') {
    1535       21882 :                         if (yych == '"') goto yy43;
    1536        4287 :                         goto yy45;
    1537             :                 } else {
    1538       50222 :                         if (yych <= '$') goto yy40;
    1539       26781 :                         if (yych == '{') goto yy42;
    1540       25428 :                         goto yy45;
    1541             :                 }
    1542             : yy40:
    1543             :                 YYDEBUG(40, *YYCURSOR);
    1544       23441 :                 ++YYCURSOR;
    1545       23441 :                 if ((yych = *YYCURSOR) <= '_') {
    1546         168 :                         if (yych <= '@') goto yy41;
    1547         168 :                         if (yych <= 'Z') goto yy48;
    1548           0 :                         if (yych >= '_') goto yy48;
    1549             :                 } else {
    1550       23273 :                         if (yych <= 'z') {
    1551       22893 :                                 if (yych >= 'a') goto yy48;
    1552             :                         } else {
    1553         380 :                                 if (yych <= '{') goto yy51;
    1554           0 :                                 if (yych >= 0x7F) goto yy48;
    1555             :                         }
    1556             :                 }
    1557             : yy41:
    1558             :                 YYDEBUG(41, *YYCURSOR);
    1559       29715 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1560             : #line 2148 "Zend/zend_language_scanner.l"
    1561             :                 {
    1562             :         if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
    1563             :                 YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
    1564             :                 SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
    1565             : 
    1566             :                 goto double_quotes_scan_done;
    1567             :         }
    1568             : 
    1569             :         if (YYCURSOR > YYLIMIT) {
    1570             :                 RETURN_TOKEN(END);
    1571             :         }
    1572             :         if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
    1573             :                 YYCURSOR++;
    1574             :         }
    1575             : 
    1576             :         while (YYCURSOR < YYLIMIT) {
    1577             :                 switch (*YYCURSOR++) {
    1578             :                         case '"':
    1579             :                                 break;
    1580             :                         case '$':
    1581             :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    1582             :                                         break;
    1583             :                                 }
    1584             :                                 continue;
    1585             :                         case '{':
    1586             :                                 if (*YYCURSOR == '$') {
    1587             :                                         break;
    1588             :                                 }
    1589             :                                 continue;
    1590             :                         case '\\':
    1591             :                                 if (YYCURSOR < YYLIMIT) {
    1592             :                                         YYCURSOR++;
    1593             :                                 }
    1594             :                                 /* fall through */
    1595             :                         default:
    1596             :                                 continue;
    1597             :                 }
    1598             : 
    1599             :                 YYCURSOR--;
    1600             :                 break;
    1601             :         }
    1602             : 
    1603             : double_quotes_scan_done:
    1604             :         yyleng = YYCURSOR - SCNG(yy_text);
    1605             : 
    1606             :         zend_scan_escape_string(zendlval, yytext, yyleng, '"');
    1607             :         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    1608             : }
    1609             : #line 1610 "Zend/zend_language_scanner.c"
    1610             : yy42:
    1611             :                 YYDEBUG(42, *YYCURSOR);
    1612        1353 :                 yych = *++YYCURSOR;
    1613        1353 :                 if (yych == '$') goto yy46;
    1614           0 :                 goto yy41;
    1615             : yy43:
    1616             :                 YYDEBUG(43, *YYCURSOR);
    1617       17595 :                 ++YYCURSOR;
    1618             :                 YYDEBUG(44, *YYCURSOR);
    1619       17595 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1620             : #line 2137 "Zend/zend_language_scanner.l"
    1621             :                 {
    1622             :         BEGIN(ST_IN_SCRIPTING);
    1623             :         RETURN_TOKEN('"');
    1624             : }
    1625             : #line 1626 "Zend/zend_language_scanner.c"
    1626             : yy45:
    1627             :                 YYDEBUG(45, *YYCURSOR);
    1628       29715 :                 yych = *++YYCURSOR;
    1629       29715 :                 goto yy41;
    1630             : yy46:
    1631             :                 YYDEBUG(46, *YYCURSOR);
    1632        1353 :                 ++YYCURSOR;
    1633             :                 YYDEBUG(47, *YYCURSOR);
    1634        1353 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1635             : #line 2129 "Zend/zend_language_scanner.l"
    1636             :                 {
    1637             :         Z_LVAL_P(zendlval) = (zend_long) '{';
    1638             :         yy_push_state(ST_IN_SCRIPTING);
    1639             :         yyless(1);
    1640             :         RETURN_TOKEN(T_CURLY_OPEN);
    1641             : }
    1642             : #line 1643 "Zend/zend_language_scanner.c"
    1643             : yy48:
    1644             :                 YYDEBUG(48, *YYCURSOR);
    1645       98718 :                 yyaccept = 0;
    1646       98718 :                 YYMARKER = ++YYCURSOR;
    1647       98718 :                 YYFILL(3);
    1648       98718 :                 yych = *YYCURSOR;
    1649             :                 YYDEBUG(49, *YYCURSOR);
    1650       98718 :                 if (yybm[0+yych] & 128) {
    1651       75657 :                         goto yy48;
    1652             :                 }
    1653       23061 :                 if (yych == '-') goto yy53;
    1654       22726 :                 if (yych == '[') goto yy55;
    1655             : yy50:
    1656             :                 YYDEBUG(50, *YYCURSOR);
    1657       21985 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1658             : #line 1853 "Zend/zend_language_scanner.l"
    1659             :                 {
    1660             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1661             :         RETURN_TOKEN(T_VARIABLE);
    1662             : }
    1663             : #line 1664 "Zend/zend_language_scanner.c"
    1664             : yy51:
    1665             :                 YYDEBUG(51, *YYCURSOR);
    1666         380 :                 ++YYCURSOR;
    1667             :                 YYDEBUG(52, *YYCURSOR);
    1668         380 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1669             : #line 1571 "Zend/zend_language_scanner.l"
    1670             :                 {
    1671             :         yy_push_state(ST_LOOKING_FOR_VARNAME);
    1672             :         RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
    1673             : }
    1674             : #line 1675 "Zend/zend_language_scanner.c"
    1675             : yy53:
    1676             :                 YYDEBUG(53, *YYCURSOR);
    1677         335 :                 yych = *++YYCURSOR;
    1678         335 :                 if (yych == '>') goto yy57;
    1679             : yy54:
    1680             :                 YYDEBUG(54, *YYCURSOR);
    1681         247 :                 YYCURSOR = YYMARKER;
    1682         247 :                 goto yy50;
    1683             : yy55:
    1684             :                 YYDEBUG(55, *YYCURSOR);
    1685         988 :                 ++YYCURSOR;
    1686             :                 YYDEBUG(56, *YYCURSOR);
    1687         988 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1688             : #line 1846 "Zend/zend_language_scanner.l"
    1689             :                 {
    1690             :         yyless(yyleng - 1);
    1691             :         yy_push_state(ST_VAR_OFFSET);
    1692             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1693             :         RETURN_TOKEN(T_VARIABLE);
    1694             : }
    1695             : #line 1696 "Zend/zend_language_scanner.c"
    1696             : yy57:
    1697             :                 YYDEBUG(57, *YYCURSOR);
    1698          88 :                 yych = *++YYCURSOR;
    1699          88 :                 if (yych <= '_') {
    1700           0 :                         if (yych <= '@') goto yy54;
    1701           0 :                         if (yych <= 'Z') goto yy58;
    1702           0 :                         if (yych <= '^') goto yy54;
    1703             :                 } else {
    1704          88 :                         if (yych <= '`') goto yy54;
    1705          88 :                         if (yych <= 'z') goto yy58;
    1706           0 :                         if (yych <= '~') goto yy54;
    1707             :                 }
    1708             : yy58:
    1709             :                 YYDEBUG(58, *YYCURSOR);
    1710          88 :                 ++YYCURSOR;
    1711             :                 YYDEBUG(59, *YYCURSOR);
    1712          88 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1713             : #line 1837 "Zend/zend_language_scanner.l"
    1714             :                 {
    1715             :         yyless(yyleng - 3);
    1716             :         yy_push_state(ST_LOOKING_FOR_PROPERTY);
    1717             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1718             :         RETURN_TOKEN(T_VARIABLE);
    1719             : }
    1720             : #line 1721 "Zend/zend_language_scanner.c"
    1721             :         }
    1722             : /* *********************************** */
    1723             : yyc_ST_END_HEREDOC:
    1724             :         YYDEBUG(60, *YYCURSOR);
    1725        1593 :         YYFILL(1);
    1726        1593 :         yych = *YYCURSOR;
    1727             :         YYDEBUG(62, *YYCURSOR);
    1728        1593 :         ++YYCURSOR;
    1729             :         YYDEBUG(63, *YYCURSOR);
    1730        1593 :         yyleng = YYCURSOR - SCNG(yy_text);
    1731             : #line 2115 "Zend/zend_language_scanner.l"
    1732             :         {
    1733             :         zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
    1734             : 
    1735             :         YYCURSOR += heredoc_label->length - 1;
    1736             :         yyleng = heredoc_label->length;
    1737             : 
    1738             :         heredoc_label_dtor(heredoc_label);
    1739             :         efree(heredoc_label);
    1740             : 
    1741             :         BEGIN(ST_IN_SCRIPTING);
    1742             :         RETURN_TOKEN(T_END_HEREDOC);
    1743             : }
    1744             : #line 1745 "Zend/zend_language_scanner.c"
    1745             : /* *********************************** */
    1746             : yyc_ST_HEREDOC:
    1747             :         {
    1748             :                 static const unsigned char yybm[] = {
    1749             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1750             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1751             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1752             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1753             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1754             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1755             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1756             :                         128, 128,   0,   0,   0,   0,   0,   0, 
    1757             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1758             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1759             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1760             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1761             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    1762             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1763             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1764             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    1765             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1766             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1767             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1768             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1769             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1770             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1771             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1772             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1773             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1774             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1775             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1776             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1777             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1778             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1779             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1780             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    1781             :                 };
    1782             :                 YYDEBUG(64, *YYCURSOR);
    1783        2449 :                 YYFILL(2);
    1784        2449 :                 yych = *YYCURSOR;
    1785        2449 :                 if (yych == '$') goto yy66;
    1786        1997 :                 if (yych == '{') goto yy68;
    1787        1929 :                 goto yy69;
    1788             : yy66:
    1789             :                 YYDEBUG(66, *YYCURSOR);
    1790         452 :                 ++YYCURSOR;
    1791         452 :                 if ((yych = *YYCURSOR) <= '_') {
    1792           2 :                         if (yych <= '@') goto yy67;
    1793           2 :                         if (yych <= 'Z') goto yy72;
    1794           0 :                         if (yych >= '_') goto yy72;
    1795             :                 } else {
    1796         450 :                         if (yych <= 'z') {
    1797         450 :                                 if (yych >= 'a') goto yy72;
    1798             :                         } else {
    1799           0 :                                 if (yych <= '{') goto yy75;
    1800           0 :                                 if (yych >= 0x7F) goto yy72;
    1801             :                         }
    1802             :                 }
    1803             : yy67:
    1804             :                 YYDEBUG(67, *YYCURSOR);
    1805        1931 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1806             : #line 2240 "Zend/zend_language_scanner.l"
    1807             :                 {
    1808             :         int newline = 0;
    1809             : 
    1810             :         zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
    1811             : 
    1812             :         if (YYCURSOR > YYLIMIT) {
    1813             :                 RETURN_TOKEN(END);
    1814             :         }
    1815             : 
    1816             :         YYCURSOR--;
    1817             : 
    1818             :         while (YYCURSOR < YYLIMIT) {
    1819             :                 switch (*YYCURSOR++) {
    1820             :                         case '\r':
    1821             :                                 if (*YYCURSOR == '\n') {
    1822             :                                         YYCURSOR++;
    1823             :                                 }
    1824             :                                 /* fall through */
    1825             :                         case '\n':
    1826             :                                 /* Check for ending label on the next line */
    1827             :                                 if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
    1828             :                                         YYCTYPE *end = YYCURSOR + heredoc_label->length;
    1829             : 
    1830             :                                         if (*end == ';') {
    1831             :                                                 end++;
    1832             :                                         }
    1833             : 
    1834             :                                         if (*end == '\n' || *end == '\r') {
    1835             :                                                 /* newline before label will be subtracted from returned text, but
    1836             :                                                  * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
    1837             :                                                 if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
    1838             :                                                         newline = 2; /* Windows newline */
    1839             :                                                 } else {
    1840             :                                                         newline = 1;
    1841             :                                                 }
    1842             : 
    1843             :                                                 CG(increment_lineno) = 1; /* For newline before label */
    1844             :                                                 BEGIN(ST_END_HEREDOC);
    1845             : 
    1846             :                                                 goto heredoc_scan_done;
    1847             :                                         }
    1848             :                                 }
    1849             :                                 continue;
    1850             :                         case '$':
    1851             :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    1852             :                                         break;
    1853             :                                 }
    1854             :                                 continue;
    1855             :                         case '{':
    1856             :                                 if (*YYCURSOR == '$') {
    1857             :                                         break;
    1858             :                                 }
    1859             :                                 continue;
    1860             :                         case '\\':
    1861             :                                 if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
    1862             :                                         YYCURSOR++;
    1863             :                                 }
    1864             :                                 /* fall through */
    1865             :                         default:
    1866             :                                 continue;
    1867             :                 }
    1868             : 
    1869             :                 YYCURSOR--;
    1870             :                 break;
    1871             :         }
    1872             : 
    1873             : heredoc_scan_done:
    1874             :         yyleng = YYCURSOR - SCNG(yy_text);
    1875             : 
    1876             :         zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0);
    1877             :         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    1878             : }
    1879             : #line 1880 "Zend/zend_language_scanner.c"
    1880             : yy68:
    1881             :                 YYDEBUG(68, *YYCURSOR);
    1882          68 :                 yych = *++YYCURSOR;
    1883          68 :                 if (yych == '$') goto yy70;
    1884           2 :                 goto yy67;
    1885             : yy69:
    1886             :                 YYDEBUG(69, *YYCURSOR);
    1887        1929 :                 yych = *++YYCURSOR;
    1888        1929 :                 goto yy67;
    1889             : yy70:
    1890             :                 YYDEBUG(70, *YYCURSOR);
    1891          66 :                 ++YYCURSOR;
    1892             :                 YYDEBUG(71, *YYCURSOR);
    1893          66 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1894             : #line 2129 "Zend/zend_language_scanner.l"
    1895             :                 {
    1896             :         Z_LVAL_P(zendlval) = (zend_long) '{';
    1897             :         yy_push_state(ST_IN_SCRIPTING);
    1898             :         yyless(1);
    1899             :         RETURN_TOKEN(T_CURLY_OPEN);
    1900             : }
    1901             : #line 1902 "Zend/zend_language_scanner.c"
    1902             : yy72:
    1903             :                 YYDEBUG(72, *YYCURSOR);
    1904        3343 :                 yyaccept = 0;
    1905        3343 :                 YYMARKER = ++YYCURSOR;
    1906        3343 :                 YYFILL(3);
    1907        3343 :                 yych = *YYCURSOR;
    1908             :                 YYDEBUG(73, *YYCURSOR);
    1909        3343 :                 if (yybm[0+yych] & 128) {
    1910        2891 :                         goto yy72;
    1911             :                 }
    1912         452 :                 if (yych == '-') goto yy77;
    1913         452 :                 if (yych == '[') goto yy79;
    1914             : yy74:
    1915             :                 YYDEBUG(74, *YYCURSOR);
    1916         451 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1917             : #line 1853 "Zend/zend_language_scanner.l"
    1918             :                 {
    1919             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1920             :         RETURN_TOKEN(T_VARIABLE);
    1921             : }
    1922             : #line 1923 "Zend/zend_language_scanner.c"
    1923             : yy75:
    1924             :                 YYDEBUG(75, *YYCURSOR);
    1925           0 :                 ++YYCURSOR;
    1926             :                 YYDEBUG(76, *YYCURSOR);
    1927           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1928             : #line 1571 "Zend/zend_language_scanner.l"
    1929             :                 {
    1930             :         yy_push_state(ST_LOOKING_FOR_VARNAME);
    1931             :         RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
    1932             : }
    1933             : #line 1934 "Zend/zend_language_scanner.c"
    1934             : yy77:
    1935             :                 YYDEBUG(77, *YYCURSOR);
    1936           0 :                 yych = *++YYCURSOR;
    1937           0 :                 if (yych == '>') goto yy81;
    1938             : yy78:
    1939             :                 YYDEBUG(78, *YYCURSOR);
    1940           0 :                 YYCURSOR = YYMARKER;
    1941           0 :                 goto yy74;
    1942             : yy79:
    1943             :                 YYDEBUG(79, *YYCURSOR);
    1944           1 :                 ++YYCURSOR;
    1945             :                 YYDEBUG(80, *YYCURSOR);
    1946           1 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1947             : #line 1846 "Zend/zend_language_scanner.l"
    1948             :                 {
    1949             :         yyless(yyleng - 1);
    1950             :         yy_push_state(ST_VAR_OFFSET);
    1951             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1952             :         RETURN_TOKEN(T_VARIABLE);
    1953             : }
    1954             : #line 1955 "Zend/zend_language_scanner.c"
    1955             : yy81:
    1956             :                 YYDEBUG(81, *YYCURSOR);
    1957           0 :                 yych = *++YYCURSOR;
    1958           0 :                 if (yych <= '_') {
    1959           0 :                         if (yych <= '@') goto yy78;
    1960           0 :                         if (yych <= 'Z') goto yy82;
    1961           0 :                         if (yych <= '^') goto yy78;
    1962             :                 } else {
    1963           0 :                         if (yych <= '`') goto yy78;
    1964           0 :                         if (yych <= 'z') goto yy82;
    1965           0 :                         if (yych <= '~') goto yy78;
    1966             :                 }
    1967             : yy82:
    1968             :                 YYDEBUG(82, *YYCURSOR);
    1969           0 :                 ++YYCURSOR;
    1970             :                 YYDEBUG(83, *YYCURSOR);
    1971           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    1972             : #line 1837 "Zend/zend_language_scanner.l"
    1973             :                 {
    1974             :         yyless(yyleng - 3);
    1975             :         yy_push_state(ST_LOOKING_FOR_PROPERTY);
    1976             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1977             :         RETURN_TOKEN(T_VARIABLE);
    1978             : }
    1979             : #line 1980 "Zend/zend_language_scanner.c"
    1980             :         }
    1981             : /* *********************************** */
    1982             : yyc_ST_IN_SCRIPTING:
    1983             :         {
    1984             :                 static const unsigned char yybm[] = {
    1985             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1986             :                           0, 192,  64,   0,   0,  64,   0,   0, 
    1987             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1988             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1989             :                         192,   0,   0,   0,   0,   0,   0,   0, 
    1990             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    1991             :                          60,  60,  44,  44,  44,  44,  44,  44, 
    1992             :                          44,  44,   0,   0,   0,   0,   0,   0, 
    1993             :                           0,  36,  36,  36,  36,  36,  36,   4, 
    1994             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    1995             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    1996             :                           4,   4,   4,   0,   0,   0,   0,   4, 
    1997             :                           0,  36,  36,  36,  36,  36,  36,   4, 
    1998             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    1999             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2000             :                           4,   4,   4,   0,   0,   0,   0,   4, 
    2001             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2002             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2003             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2004             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2005             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2006             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2007             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2008             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2009             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2010             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2011             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2012             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2013             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2014             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2015             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2016             :                           4,   4,   4,   4,   4,   4,   4,   4, 
    2017             :                 };
    2018             :                 YYDEBUG(84, *YYCURSOR);
    2019     7625381 :                 YYFILL(16);
    2020     7625381 :                 yych = *YYCURSOR;
    2021             :                 YYDEBUG(-1, yych);
    2022     7625381 :                 switch (yych) {
    2023             :                 case 0x00:
    2024             :                 case 0x01:
    2025             :                 case 0x02:
    2026             :                 case 0x03:
    2027             :                 case 0x04:
    2028             :                 case 0x05:
    2029             :                 case 0x06:
    2030             :                 case 0x07:
    2031             :                 case 0x08:
    2032             :                 case '\v':
    2033             :                 case '\f':
    2034             :                 case 0x0E:
    2035             :                 case 0x0F:
    2036             :                 case 0x10:
    2037             :                 case 0x11:
    2038             :                 case 0x12:
    2039             :                 case 0x13:
    2040             :                 case 0x14:
    2041             :                 case 0x15:
    2042             :                 case 0x16:
    2043             :                 case 0x17:
    2044             :                 case 0x18:
    2045             :                 case 0x19:
    2046             :                 case 0x1A:
    2047             :                 case 0x1B:
    2048             :                 case 0x1C:
    2049             :                 case 0x1D:
    2050             :                 case 0x1E:
    2051        3606 :                 case 0x1F:      goto yy147;
    2052             :                 case '\t':
    2053             :                 case '\n':
    2054             :                 case '\r':
    2055     2328294 :                 case ' ':       goto yy103;
    2056       44049 :                 case '!':       goto yy118;
    2057      198994 :                 case '"':  goto yy143;
    2058        2213 :                 case '#':       goto yy139;
    2059      748299 :                 case '$':       goto yy129;
    2060         137 :                 case '%':       goto yy123;
    2061       10085 :                 case '&':   goto yy124;
    2062      196168 :                 case '\'':      goto yy141;
    2063      573075 :                 case '(':       goto yy112;
    2064             :                 case ')':
    2065             :                 case ',':
    2066             :                 case ';':
    2067             :                 case '@':
    2068             :                 case '[':
    2069             :                 case ']':
    2070     1651303 :                 case '~':       goto yy130;
    2071        2913 :                 case '*':       goto yy121;
    2072       13028 :                 case '+':       goto yy117;
    2073       56998 :                 case '-':       goto yy101;
    2074       49034 :                 case '.':       goto yy108;
    2075       76968 :                 case '/':       goto yy122;
    2076       31462 :                 case '0':       goto yy135;
    2077             :                 case '1':
    2078             :                 case '2':
    2079             :                 case '3':
    2080             :                 case '4':
    2081             :                 case '5':
    2082             :                 case '6':
    2083             :                 case '7':
    2084             :                 case '8':
    2085      149468 :                 case '9':       goto yy137;
    2086       50634 :                 case ':':       goto yy105;
    2087        5742 :                 case '<':    goto yy119;
    2088      228700 :                 case '=':       goto yy115;
    2089        1608 :                 case '>':    goto yy120;
    2090       55811 :                 case '?':       goto yy109;
    2091             :                 case 'A':
    2092       50552 :                 case 'a':       goto yy96;
    2093             :                 case 'B':
    2094        7265 :                 case 'b':       goto yy98;
    2095             :                 case 'C':
    2096       28851 :                 case 'c':       goto yy90;
    2097             :                 case 'D':
    2098       41040 :                 case 'd':       goto yy88;
    2099             :                 case 'E':
    2100       90474 :                 case 'e':       goto yy86;
    2101             :                 case 'F':
    2102      114977 :                 case 'f':       goto yy89;
    2103             :                 case 'G':
    2104       56871 :                 case 'g':       goto yy99;
    2105             :                 case 'I':
    2106      103034 :                 case 'i':       goto yy94;
    2107             :                 case 'L':
    2108        8385 :                 case 'l':       goto yy116;
    2109             :                 case 'N':
    2110       33283 :                 case 'n':       goto yy110;
    2111             :                 case 'O':
    2112       13608 :                 case 'o':       goto yy127;
    2113             :                 case 'P':
    2114       59806 :                 case 'p':       goto yy100;
    2115             :                 case 'R':
    2116       65238 :                 case 'r':       goto yy91;
    2117             :                 case 'S':
    2118       50985 :                 case 's':       goto yy97;
    2119             :                 case 'T':
    2120       34956 :                 case 't':       goto yy93;
    2121             :                 case 'U':
    2122       16490 :                 case 'u':       goto yy113;
    2123             :                 case 'V':
    2124       35090 :                 case 'v':       goto yy111;
    2125             :                 case 'W':
    2126        3003 :                 case 'w':       goto yy95;
    2127             :                 case 'X':
    2128        1111 :                 case 'x':       goto yy128;
    2129             :                 case 'Y':
    2130         339 :                 case 'y':       goto yy92;
    2131         828 :                 case '\\':      goto yy106;
    2132          31 :                 case '^':       goto yy126;
    2133       16585 :                 case '_':       goto yy114;
    2134         120 :                 case '`':       goto yy145;
    2135      133863 :                 case '{':       goto yy131;
    2136        6364 :                 case '|':       goto yy125;
    2137      135632 :                 case '}':       goto yy133;
    2138       38011 :                 default:        goto yy138;
    2139             :                 }
    2140             : yy86:
    2141             :                 YYDEBUG(86, *YYCURSOR);
    2142       90474 :                 ++YYCURSOR;
    2143             :                 YYDEBUG(-1, yych);
    2144       90474 :                 switch ((yych = *YYCURSOR)) {
    2145             :                 case 'C':
    2146       37448 :                 case 'c':       goto yy704;
    2147             :                 case 'L':
    2148       22373 :                 case 'l':       goto yy705;
    2149             :                 case 'M':
    2150        8027 :                 case 'm':       goto yy706;
    2151             :                 case 'N':
    2152         710 :                 case 'n':       goto yy707;
    2153             :                 case 'V':
    2154        2326 :                 case 'v':       goto yy708;
    2155             :                 case 'X':
    2156       16100 :                 case 'x':       goto yy709;
    2157        3490 :                 default:        goto yy150;
    2158             :                 }
    2159             : yy87:
    2160             :                 YYDEBUG(87, *YYCURSOR);
    2161      475639 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2162             : #line 1876 "Zend/zend_language_scanner.l"
    2163             :                 {
    2164             :         zend_copy_value(zendlval, yytext, yyleng);
    2165             :         RETURN_TOKEN(T_STRING);
    2166             : }
    2167             : #line 2168 "Zend/zend_language_scanner.c"
    2168             : yy88:
    2169             :                 YYDEBUG(88, *YYCURSOR);
    2170       41040 :                 yych = *++YYCURSOR;
    2171       41040 :                 if (yych <= 'O') {
    2172        1497 :                         if (yych <= 'H') {
    2173         421 :                                 if (yych == 'E') goto yy686;
    2174         361 :                                 goto yy150;
    2175             :                         } else {
    2176        1076 :                                 if (yych <= 'I') goto yy687;
    2177         328 :                                 if (yych <= 'N') goto yy150;
    2178         319 :                                 goto yy688;
    2179             :                         }
    2180             :                 } else {
    2181       39543 :                         if (yych <= 'h') {
    2182       12166 :                                 if (yych == 'e') goto yy686;
    2183        6451 :                                 goto yy150;
    2184             :                         } else {
    2185       27377 :                                 if (yych <= 'i') goto yy687;
    2186        1806 :                                 if (yych == 'o') goto yy688;
    2187        1063 :                                 goto yy150;
    2188             :                         }
    2189             :                 }
    2190             : yy89:
    2191             :                 YYDEBUG(89, *YYCURSOR);
    2192      114977 :                 yych = *++YYCURSOR;
    2193      114977 :                 if (yych <= 'U') {
    2194        6747 :                         if (yych <= 'N') {
    2195        6564 :                                 if (yych == 'I') goto yy662;
    2196        5832 :                                 goto yy150;
    2197             :                         } else {
    2198         183 :                                 if (yych <= 'O') goto yy663;
    2199          95 :                                 if (yych <= 'T') goto yy150;
    2200          55 :                                 goto yy664;
    2201             :                         }
    2202             :                 } else {
    2203      108230 :                         if (yych <= 'n') {
    2204       41042 :                                 if (yych == 'i') goto yy662;
    2205       34140 :                                 goto yy150;
    2206             :                         } else {
    2207       67188 :                                 if (yych <= 'o') goto yy663;
    2208       48676 :                                 if (yych == 'u') goto yy664;
    2209        5724 :                                 goto yy150;
    2210             :                         }
    2211             :                 }
    2212             : yy90:
    2213             :                 YYDEBUG(90, *YYCURSOR);
    2214       28851 :                 yych = *++YYCURSOR;
    2215       28851 :                 if (yych <= 'O') {
    2216        2447 :                         if (yych <= 'K') {
    2217        2268 :                                 if (yych == 'A') goto yy627;
    2218         854 :                                 goto yy150;
    2219             :                         } else {
    2220         179 :                                 if (yych <= 'L') goto yy628;
    2221         122 :                                 if (yych <= 'N') goto yy150;
    2222          92 :                                 goto yy629;
    2223             :                         }
    2224             :                 } else {
    2225       26404 :                         if (yych <= 'k') {
    2226        7724 :                                 if (yych == 'a') goto yy627;
    2227        2888 :                                 goto yy150;
    2228             :                         } else {
    2229       18680 :                                 if (yych <= 'l') goto yy628;
    2230        8633 :                                 if (yych == 'o') goto yy629;
    2231        3109 :                                 goto yy150;
    2232             :                         }
    2233             :                 }
    2234             : yy91:
    2235             :                 YYDEBUG(91, *YYCURSOR);
    2236       65238 :                 yych = *++YYCURSOR;
    2237       65238 :                 if (yych == 'E') goto yy609;
    2238       65193 :                 if (yych == 'e') goto yy609;
    2239        2840 :                 goto yy150;
    2240             : yy92:
    2241             :                 YYDEBUG(92, *YYCURSOR);
    2242         339 :                 yych = *++YYCURSOR;
    2243         339 :                 if (yych == 'I') goto yy597;
    2244         337 :                 if (yych == 'i') goto yy597;
    2245          56 :                 goto yy150;
    2246             : yy93:
    2247             :                 YYDEBUG(93, *YYCURSOR);
    2248       34956 :                 yych = *++YYCURSOR;
    2249       34956 :                 if (yych <= 'R') {
    2250        4093 :                         if (yych == 'H') goto yy585;
    2251        4011 :                         if (yych <= 'Q') goto yy150;
    2252        3641 :                         goto yy586;
    2253             :                 } else {
    2254       30863 :                         if (yych <= 'h') {
    2255        8254 :                                 if (yych <= 'g') goto yy150;
    2256         472 :                                 goto yy585;
    2257             :                         } else {
    2258       22609 :                                 if (yych == 'r') goto yy586;
    2259        1021 :                                 goto yy150;
    2260             :                         }
    2261             :                 }
    2262             : yy94:
    2263             :                 YYDEBUG(94, *YYCURSOR);
    2264      103034 :                 yych = *++YYCURSOR;
    2265      103034 :                 if (yych <= 'S') {
    2266         780 :                         if (yych <= 'L') {
    2267         216 :                                 if (yych == 'F') goto yy532;
    2268         204 :                                 goto yy150;
    2269             :                         } else {
    2270         564 :                                 if (yych <= 'M') goto yy534;
    2271         457 :                                 if (yych <= 'N') goto yy535;
    2272         115 :                                 if (yych <= 'R') goto yy150;
    2273          36 :                                 goto yy536;
    2274             :                         }
    2275             :                 } else {
    2276      102254 :                         if (yych <= 'm') {
    2277       80181 :                                 if (yych == 'f') goto yy532;
    2278        3622 :                                 if (yych <= 'l') goto yy150;
    2279        3354 :                                 goto yy534;
    2280             :                         } else {
    2281       22073 :                                 if (yych <= 'n') goto yy535;
    2282       12088 :                                 if (yych == 's') goto yy536;
    2283         246 :                                 goto yy150;
    2284             :                         }
    2285             :                 }
    2286             : yy95:
    2287             :                 YYDEBUG(95, *YYCURSOR);
    2288        3003 :                 yych = *++YYCURSOR;
    2289        3003 :                 if (yych == 'H') goto yy527;
    2290        2997 :                 if (yych == 'h') goto yy527;
    2291         641 :                 goto yy150;
    2292             : yy96:
    2293             :                 YYDEBUG(96, *YYCURSOR);
    2294       50552 :                 yych = *++YYCURSOR;
    2295       50552 :                 if (yych <= 'S') {
    2296        1489 :                         if (yych <= 'M') {
    2297        1391 :                                 if (yych == 'B') goto yy509;
    2298        1377 :                                 goto yy150;
    2299             :                         } else {
    2300          98 :                                 if (yych <= 'N') goto yy510;
    2301          96 :                                 if (yych <= 'Q') goto yy150;
    2302          84 :                                 if (yych <= 'R') goto yy511;
    2303          61 :                                 goto yy512;
    2304             :                         }
    2305             :                 } else {
    2306       49063 :                         if (yych <= 'n') {
    2307        5546 :                                 if (yych == 'b') goto yy509;
    2308        5270 :                                 if (yych <= 'm') goto yy150;
    2309          99 :                                 goto yy510;
    2310             :                         } else {
    2311       43517 :                                 if (yych <= 'q') goto yy150;
    2312       43492 :                                 if (yych <= 'r') goto yy511;
    2313       12197 :                                 if (yych <= 's') goto yy512;
    2314         115 :                                 goto yy150;
    2315             :                         }
    2316             :                 }
    2317             : yy97:
    2318             :                 YYDEBUG(97, *YYCURSOR);
    2319       50985 :                 yych = *++YYCURSOR;
    2320       50985 :                 if (yych <= 'W') {
    2321        2842 :                         if (yych == 'T') goto yy497;
    2322        1983 :                         if (yych <= 'V') goto yy150;
    2323           3 :                         goto yy498;
    2324             :                 } else {
    2325       48143 :                         if (yych <= 't') {
    2326       41337 :                                 if (yych <= 's') goto yy150;
    2327       26072 :                                 goto yy497;
    2328             :                         } else {
    2329        6806 :                                 if (yych == 'w') goto yy498;
    2330        6325 :                                 goto yy150;
    2331             :                         }
    2332             :                 }
    2333             : yy98:
    2334             :                 YYDEBUG(98, *YYCURSOR);
    2335        7265 :                 yyaccept = 0;
    2336        7265 :                 yych = *(YYMARKER = ++YYCURSOR);
    2337        7265 :                 if (yych <= ';') {
    2338        1729 :                         if (yych <= '"') {
    2339         767 :                                 if (yych <= '!') goto yy150;
    2340         442 :                                 goto yy489;
    2341             :                         } else {
    2342         962 :                                 if (yych == '\'') goto yy490;
    2343         338 :                                 goto yy150;
    2344             :                         }
    2345             :                 } else {
    2346        5536 :                         if (yych <= 'R') {
    2347          96 :                                 if (yych <= '<') goto yy488;
    2348          64 :                                 if (yych <= 'Q') goto yy150;
    2349           2 :                                 goto yy491;
    2350             :                         } else {
    2351        5440 :                                 if (yych == 'r') goto yy491;
    2352        3502 :                                 goto yy150;
    2353             :                         }
    2354             :                 }
    2355             : yy99:
    2356             :                 YYDEBUG(99, *YYCURSOR);
    2357       56871 :                 yych = *++YYCURSOR;
    2358       56871 :                 if (yych <= 'O') {
    2359         155 :                         if (yych == 'L') goto yy478;
    2360         142 :                         if (yych <= 'N') goto yy150;
    2361           2 :                         goto yy479;
    2362             :                 } else {
    2363       56716 :                         if (yych <= 'l') {
    2364       54694 :                                 if (yych <= 'k') goto yy150;
    2365        4292 :                                 goto yy478;
    2366             :                         } else {
    2367        2022 :                                 if (yych == 'o') goto yy479;
    2368        1953 :                                 goto yy150;
    2369             :                         }
    2370             :                 }
    2371             : yy100:
    2372             :                 YYDEBUG(100, *YYCURSOR);
    2373       59806 :                 yych = *++YYCURSOR;
    2374       59806 :                 if (yych <= 'U') {
    2375       23202 :                         if (yych == 'R') goto yy454;
    2376       23089 :                         if (yych <= 'T') goto yy150;
    2377           3 :                         goto yy455;
    2378             :                 } else {
    2379       36604 :                         if (yych <= 'r') {
    2380       28549 :                                 if (yych <= 'q') goto yy150;
    2381       20133 :                                 goto yy454;
    2382             :                         } else {
    2383        8055 :                                 if (yych == 'u') goto yy455;
    2384          71 :                                 goto yy150;
    2385             :                         }
    2386             :                 }
    2387             : yy101:
    2388             :                 YYDEBUG(101, *YYCURSOR);
    2389       56998 :                 ++YYCURSOR;
    2390       56998 :                 if ((yych = *YYCURSOR) <= '<') {
    2391        7789 :                         if (yych == '-') goto yy450;
    2392             :                 } else {
    2393       49209 :                         if (yych <= '=') goto yy448;
    2394       49068 :                         if (yych <= '>') goto yy452;
    2395             :                 }
    2396             : yy102:
    2397             :                 YYDEBUG(102, *YYCURSOR);
    2398     2545158 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2399             : #line 1560 "Zend/zend_language_scanner.l"
    2400             :                 {
    2401             :         RETURN_TOKEN(yytext[0]);
    2402             : }
    2403             : #line 2404 "Zend/zend_language_scanner.c"
    2404             : yy103:
    2405             :                 YYDEBUG(103, *YYCURSOR);
    2406     2328294 :                 ++YYCURSOR;
    2407     2328294 :                 yych = *YYCURSOR;
    2408     2328294 :                 goto yy447;
    2409             : yy104:
    2410             :                 YYDEBUG(104, *YYCURSOR);
    2411     2328294 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2412             : #line 1275 "Zend/zend_language_scanner.l"
    2413             :                 {
    2414             :         HANDLE_NEWLINES(yytext, yyleng);
    2415             :         RETURN_TOKEN(T_WHITESPACE);
    2416             : }
    2417             : #line 2418 "Zend/zend_language_scanner.c"
    2418             : yy105:
    2419             :                 YYDEBUG(105, *YYCURSOR);
    2420       50634 :                 yych = *++YYCURSOR;
    2421       50634 :                 if (yych == ':') goto yy444;
    2422       27629 :                 goto yy102;
    2423             : yy106:
    2424             :                 YYDEBUG(106, *YYCURSOR);
    2425         828 :                 ++YYCURSOR;
    2426             :                 YYDEBUG(107, *YYCURSOR);
    2427         828 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2428             : #line 1300 "Zend/zend_language_scanner.l"
    2429             :                 {
    2430             :         RETURN_TOKEN(T_NS_SEPARATOR);
    2431             : }
    2432             : #line 2433 "Zend/zend_language_scanner.c"
    2433             : yy108:
    2434             :                 YYDEBUG(108, *YYCURSOR);
    2435       49034 :                 yyaccept = 1;
    2436       49034 :                 yych = *(YYMARKER = ++YYCURSOR);
    2437       49034 :                 if (yych <= '/') {
    2438       42711 :                         if (yych == '.') goto yy441;
    2439       42600 :                         goto yy102;
    2440             :                 } else {
    2441        6323 :                         if (yych <= '9') goto yy437;
    2442        5567 :                         if (yych == '=') goto yy439;
    2443        2548 :                         goto yy102;
    2444             :                 }
    2445             : yy109:
    2446             :                 YYDEBUG(109, *YYCURSOR);
    2447       55811 :                 yych = *++YYCURSOR;
    2448       55811 :                 if (yych <= '=') goto yy102;
    2449       30252 :                 if (yych <= '>') goto yy431;
    2450          25 :                 if (yych <= '?') goto yy433;
    2451           5 :                 goto yy102;
    2452             : yy110:
    2453             :                 YYDEBUG(110, *YYCURSOR);
    2454       33283 :                 yych = *++YYCURSOR;
    2455       33283 :                 if (yych <= 'E') {
    2456          45 :                         if (yych == 'A') goto yy419;
    2457           8 :                         if (yych <= 'D') goto yy150;
    2458           4 :                         goto yy420;
    2459             :                 } else {
    2460       33238 :                         if (yych <= 'a') {
    2461        8663 :                                 if (yych <= '`') goto yy150;
    2462         367 :                                 goto yy419;
    2463             :                         } else {
    2464       24575 :                                 if (yych == 'e') goto yy420;
    2465        9224 :                                 goto yy150;
    2466             :                         }
    2467             :                 }
    2468             : yy111:
    2469             :                 YYDEBUG(111, *YYCURSOR);
    2470       35090 :                 yych = *++YYCURSOR;
    2471       35090 :                 if (yych == 'A') goto yy416;
    2472       35068 :                 if (yych == 'a') goto yy416;
    2473         919 :                 goto yy150;
    2474             : yy112:
    2475             :                 YYDEBUG(112, *YYCURSOR);
    2476      573075 :                 yyaccept = 1;
    2477      573075 :                 yych = *(YYMARKER = ++YYCURSOR);
    2478      573075 :                 if (yych <= 'S') {
    2479      493289 :                         if (yych <= 'D') {
    2480      479607 :                                 if (yych <= ' ') {
    2481       44396 :                                         if (yych == '\t') goto yy341;
    2482       44391 :                                         if (yych <= 0x1F) goto yy102;
    2483       37891 :                                         goto yy341;
    2484             :                                 } else {
    2485      435211 :                                         if (yych <= '@') goto yy102;
    2486        1557 :                                         if (yych == 'C') goto yy102;
    2487        1440 :                                         goto yy341;
    2488             :                                 }
    2489             :                         } else {
    2490       13682 :                                 if (yych <= 'I') {
    2491        2153 :                                         if (yych == 'F') goto yy341;
    2492        1916 :                                         if (yych <= 'H') goto yy102;
    2493         461 :                                         goto yy341;
    2494             :                                 } else {
    2495       11529 :                                         if (yych == 'O') goto yy341;
    2496       11486 :                                         if (yych <= 'Q') goto yy102;
    2497         393 :                                         goto yy341;
    2498             :                                 }
    2499             :                         }
    2500             :                 } else {
    2501       79786 :                         if (yych <= 'f') {
    2502       35034 :                                 if (yych <= 'b') {
    2503       14941 :                                         if (yych == 'U') goto yy341;
    2504       14915 :                                         if (yych <= '`') goto yy102;
    2505        4404 :                                         goto yy341;
    2506             :                                 } else {
    2507       20093 :                                         if (yych == 'd') goto yy341;
    2508       12257 :                                         if (yych <= 'e') goto yy102;
    2509        8685 :                                         goto yy341;
    2510             :                                 }
    2511             :                         } else {
    2512       44752 :                                 if (yych <= 'o') {
    2513       25549 :                                         if (yych == 'i') goto yy341;
    2514       12253 :                                         if (yych <= 'n') goto yy102;
    2515        1164 :                                         goto yy341;
    2516             :                                 } else {
    2517       19203 :                                         if (yych <= 's') {
    2518       14714 :                                                 if (yych <= 'q') goto yy102;
    2519        9701 :                                                 goto yy341;
    2520             :                                         } else {
    2521        4489 :                                                 if (yych == 'u') goto yy341;
    2522        2862 :                                                 goto yy102;
    2523             :                                         }
    2524             :                                 }
    2525             :                         }
    2526             :                 }
    2527             : yy113:
    2528             :                 YYDEBUG(113, *YYCURSOR);
    2529       16490 :                 yych = *++YYCURSOR;
    2530       16490 :                 if (yych <= 'S') {
    2531         119 :                         if (yych == 'N') goto yy332;
    2532         114 :                         if (yych <= 'R') goto yy150;
    2533          20 :                         goto yy333;
    2534             :                 } else {
    2535       16371 :                         if (yych <= 'n') {
    2536        8755 :                                 if (yych <= 'm') goto yy150;
    2537        8635 :                                 goto yy332;
    2538             :                         } else {
    2539        7616 :                                 if (yych == 's') goto yy333;
    2540        6789 :                                 goto yy150;
    2541             :                         }
    2542             :                 }
    2543             : yy114:
    2544             :                 YYDEBUG(114, *YYCURSOR);
    2545       16585 :                 yych = *++YYCURSOR;
    2546       16585 :                 if (yych == '_') goto yy250;
    2547         339 :                 goto yy150;
    2548             : yy115:
    2549             :                 YYDEBUG(115, *YYCURSOR);
    2550      228700 :                 yych = *++YYCURSOR;
    2551      228700 :                 if (yych <= '<') goto yy102;
    2552       57479 :                 if (yych <= '=') goto yy244;
    2553       33994 :                 if (yych <= '>') goto yy246;
    2554         615 :                 goto yy102;
    2555             : yy116:
    2556             :                 YYDEBUG(116, *YYCURSOR);
    2557        8385 :                 yych = *++YYCURSOR;
    2558        8385 :                 if (yych == 'I') goto yy240;
    2559        8351 :                 if (yych == 'i') goto yy240;
    2560        7845 :                 goto yy150;
    2561             : yy117:
    2562             :                 YYDEBUG(117, *YYCURSOR);
    2563       13028 :                 yych = *++YYCURSOR;
    2564       13028 :                 if (yych == '+') goto yy238;
    2565        6737 :                 if (yych == '=') goto yy236;
    2566        6019 :                 goto yy102;
    2567             : yy118:
    2568             :                 YYDEBUG(118, *YYCURSOR);
    2569       44049 :                 yych = *++YYCURSOR;
    2570       44049 :                 if (yych == '=') goto yy233;
    2571       32512 :                 goto yy102;
    2572             : yy119:
    2573             :                 YYDEBUG(119, *YYCURSOR);
    2574        5742 :                 yych = *++YYCURSOR;
    2575        5742 :                 if (yych <= ';') goto yy102;
    2576        3533 :                 if (yych <= '<') goto yy209;
    2577        1817 :                 if (yych <= '=') goto yy211;
    2578          42 :                 if (yych <= '>') goto yy213;
    2579          37 :                 goto yy102;
    2580             : yy120:
    2581             :                 YYDEBUG(120, *YYCURSOR);
    2582        1608 :                 yych = *++YYCURSOR;
    2583        1608 :                 if (yych <= '<') goto yy102;
    2584         699 :                 if (yych <= '=') goto yy205;
    2585          90 :                 if (yych <= '>') goto yy203;
    2586           4 :                 goto yy102;
    2587             : yy121:
    2588             :                 YYDEBUG(121, *YYCURSOR);
    2589        2913 :                 yych = *++YYCURSOR;
    2590        2913 :                 if (yych == '*') goto yy197;
    2591        2896 :                 if (yych == '=') goto yy199;
    2592        2879 :                 goto yy102;
    2593             : yy122:
    2594             :                 YYDEBUG(122, *YYCURSOR);
    2595       76968 :                 yych = *++YYCURSOR;
    2596       76968 :                 if (yych <= '.') {
    2597       26865 :                         if (yych == '*') goto yy189;
    2598         510 :                         goto yy102;
    2599             :                 } else {
    2600       50103 :                         if (yych <= '/') goto yy191;
    2601          35 :                         if (yych == '=') goto yy192;
    2602          29 :                         goto yy102;
    2603             :                 }
    2604             : yy123:
    2605             :                 YYDEBUG(123, *YYCURSOR);
    2606         137 :                 yych = *++YYCURSOR;
    2607         137 :                 if (yych == '=') goto yy187;
    2608         131 :                 goto yy102;
    2609             : yy124:
    2610             :                 YYDEBUG(124, *YYCURSOR);
    2611       10085 :                 yych = *++YYCURSOR;
    2612       10085 :                 if (yych == '&') goto yy183;
    2613        2252 :                 if (yych == '=') goto yy185;
    2614        2246 :                 goto yy102;
    2615             : yy125:
    2616             :                 YYDEBUG(125, *YYCURSOR);
    2617        6364 :                 yych = *++YYCURSOR;
    2618        6364 :                 if (yych == '=') goto yy181;
    2619        6265 :                 if (yych == '|') goto yy179;
    2620        1653 :                 goto yy102;
    2621             : yy126:
    2622             :                 YYDEBUG(126, *YYCURSOR);
    2623          31 :                 yych = *++YYCURSOR;
    2624          31 :                 if (yych == '=') goto yy177;
    2625          25 :                 goto yy102;
    2626             : yy127:
    2627             :                 YYDEBUG(127, *YYCURSOR);
    2628       13608 :                 yych = *++YYCURSOR;
    2629       13608 :                 if (yych == 'R') goto yy175;
    2630       13604 :                 if (yych == 'r') goto yy175;
    2631       12615 :                 goto yy150;
    2632             : yy128:
    2633             :                 YYDEBUG(128, *YYCURSOR);
    2634        1111 :                 yych = *++YYCURSOR;
    2635        1111 :                 if (yych == 'O') goto yy172;
    2636        1109 :                 if (yych == 'o') goto yy172;
    2637        1103 :                 goto yy150;
    2638             : yy129:
    2639             :                 YYDEBUG(129, *YYCURSOR);
    2640      748299 :                 yych = *++YYCURSOR;
    2641      748299 :                 if (yych <= '_') {
    2642       26574 :                         if (yych <= '@') goto yy102;
    2643       26401 :                         if (yych <= 'Z') goto yy169;
    2644       10491 :                         if (yych <= '^') goto yy102;
    2645       10491 :                         goto yy169;
    2646             :                 } else {
    2647      721725 :                         if (yych <= '`') goto yy102;
    2648      721725 :                         if (yych <= 'z') goto yy169;
    2649          69 :                         if (yych <= '~') goto yy102;
    2650          13 :                         goto yy169;
    2651             :                 }
    2652             : yy130:
    2653             :                 YYDEBUG(130, *YYCURSOR);
    2654     1651303 :                 yych = *++YYCURSOR;
    2655     1651303 :                 goto yy102;
    2656             : yy131:
    2657             :                 YYDEBUG(131, *YYCURSOR);
    2658      133863 :                 ++YYCURSOR;
    2659             :                 YYDEBUG(132, *YYCURSOR);
    2660      133863 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2661             : #line 1565 "Zend/zend_language_scanner.l"
    2662             :                 {
    2663             :         yy_push_state(ST_IN_SCRIPTING);
    2664             :         RETURN_TOKEN('{');
    2665             : }
    2666             : #line 2667 "Zend/zend_language_scanner.c"
    2667             : yy133:
    2668             :                 YYDEBUG(133, *YYCURSOR);
    2669      135632 :                 ++YYCURSOR;
    2670             :                 YYDEBUG(134, *YYCURSOR);
    2671      135632 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2672             : #line 1577 "Zend/zend_language_scanner.l"
    2673             :                 {
    2674             :         RESET_DOC_COMMENT();
    2675             :         if (!zend_stack_is_empty(&SCNG(state_stack))) {
    2676             :                 yy_pop_state();
    2677             :         }
    2678             :         RETURN_TOKEN('}');
    2679             : }
    2680             : #line 2681 "Zend/zend_language_scanner.c"
    2681             : yy135:
    2682             :                 YYDEBUG(135, *YYCURSOR);
    2683       31462 :                 yyaccept = 2;
    2684       31462 :                 yych = *(YYMARKER = ++YYCURSOR);
    2685       31462 :                 if (yych <= 'E') {
    2686       24929 :                         if (yych <= '9') {
    2687       19218 :                                 if (yych == '.') goto yy151;
    2688       18774 :                                 if (yych >= '0') goto yy154;
    2689             :                         } else {
    2690        5711 :                                 if (yych == 'B') goto yy162;
    2691        5711 :                                 if (yych >= 'E') goto yy156;
    2692             :                         }
    2693             :                 } else {
    2694        6533 :                         if (yych <= 'b') {
    2695        3308 :                                 if (yych == 'X') goto yy161;
    2696        3257 :                                 if (yych >= 'b') goto yy162;
    2697             :                         } else {
    2698        3225 :                                 if (yych <= 'e') {
    2699           4 :                                         if (yych >= 'e') goto yy156;
    2700             :                                 } else {
    2701        3221 :                                         if (yych == 'x') goto yy161;
    2702             :                                 }
    2703             :                         }
    2704             :                 }
    2705             : yy136:
    2706             :                 YYDEBUG(136, *YYCURSOR);
    2707      171686 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2708             : #line 1630 "Zend/zend_language_scanner.l"
    2709             :                 {
    2710             :         char *end;
    2711             :         if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
    2712             :                 errno = 0;
    2713             :                 ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, &end, 0));
    2714             :                 /* This isn't an assert, we need to ensure 019 isn't valid octal
    2715             :                  * Because the lexing itself doesn't do that for us
    2716             :                  */
    2717             :                 if (end != yytext + yyleng) {
    2718             :                         zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", 0);
    2719             :                         ZVAL_UNDEF(zendlval);
    2720             :                         RETURN_TOKEN(T_LNUMBER);
    2721             :                 }
    2722             :         } else {
    2723             :                 errno = 0;
    2724             :                 ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, &end, 0));
    2725             :                 if (errno == ERANGE) { /* Overflow */
    2726             :                         errno = 0;
    2727             :                         if (yytext[0] == '0') { /* octal overflow */
    2728             :                                 errno = 0;
    2729             :                                 ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, (const char **)&end));
    2730             :                         } else {
    2731             :                                 ZVAL_DOUBLE(zendlval, zend_strtod(yytext, (const char **)&end));
    2732             :                         }
    2733             :                         /* Also not an assert for the same reason */
    2734             :                         if (end != yytext + yyleng) {
    2735             :                                 zend_throw_exception(zend_ce_parse_error,
    2736             :                                         "Invalid numeric literal", 0);
    2737             :                                 ZVAL_UNDEF(zendlval);
    2738             :                                 RETURN_TOKEN(T_DNUMBER);
    2739             :                         }
    2740             :                         ZEND_ASSERT(!errno);
    2741             :                         RETURN_TOKEN(T_DNUMBER);
    2742             :                 }
    2743             :                 /* Also not an assert for the same reason */
    2744             :                 if (end != yytext + yyleng) {
    2745             :                         zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", 0);
    2746             :                         ZVAL_UNDEF(zendlval);
    2747             :                         RETURN_TOKEN(T_DNUMBER);
    2748             :                 }
    2749             :         }
    2750             :         ZEND_ASSERT(!errno);
    2751             :         RETURN_TOKEN(T_LNUMBER);
    2752             : }
    2753             : #line 2754 "Zend/zend_language_scanner.c"
    2754             : yy137:
    2755             :                 YYDEBUG(137, *YYCURSOR);
    2756      149468 :                 yyaccept = 2;
    2757      149468 :                 yych = *(YYMARKER = ++YYCURSOR);
    2758      149468 :                 if (yych <= '9') {
    2759      131178 :                         if (yych == '.') goto yy151;
    2760      129504 :                         if (yych <= '/') goto yy136;
    2761       95016 :                         goto yy154;
    2762             :                 } else {
    2763       18290 :                         if (yych <= 'E') {
    2764        7162 :                                 if (yych <= 'D') goto yy136;
    2765          77 :                                 goto yy156;
    2766             :                         } else {
    2767       11128 :                                 if (yych == 'e') goto yy156;
    2768       10892 :                                 goto yy136;
    2769             :                         }
    2770             :                 }
    2771             : yy138:
    2772             :                 YYDEBUG(138, *YYCURSOR);
    2773       38011 :                 yych = *++YYCURSOR;
    2774       38011 :                 goto yy150;
    2775             : yy139:
    2776             :                 YYDEBUG(139, *YYCURSOR);
    2777        2213 :                 ++YYCURSOR;
    2778             : yy140:
    2779             :                 YYDEBUG(140, *YYCURSOR);
    2780       52281 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2781             : #line 1882 "Zend/zend_language_scanner.l"
    2782             :                 {
    2783             :         while (YYCURSOR < YYLIMIT) {
    2784             :                 switch (*YYCURSOR++) {
    2785             :                         case '\r':
    2786             :                                 if (*YYCURSOR == '\n') {
    2787             :                                         YYCURSOR++;
    2788             :                                 }
    2789             :                                 /* fall through */
    2790             :                         case '\n':
    2791             :                                 CG(zend_lineno)++;
    2792             :                                 break;
    2793             :                         case '?':
    2794             :                                 if (*YYCURSOR == '>') {
    2795             :                                         YYCURSOR--;
    2796             :                                         break;
    2797             :                                 }
    2798             :                                 /* fall through */
    2799             :                         default:
    2800             :                                 continue;
    2801             :                 }
    2802             : 
    2803             :                 break;
    2804             :         }
    2805             : 
    2806             :         yyleng = YYCURSOR - SCNG(yy_text);
    2807             : 
    2808             :         RETURN_TOKEN(T_COMMENT);
    2809             : }
    2810             : #line 2811 "Zend/zend_language_scanner.c"
    2811             : yy141:
    2812             :                 YYDEBUG(141, *YYCURSOR);
    2813      196168 :                 ++YYCURSOR;
    2814             : yy142:
    2815             :                 YYDEBUG(142, *YYCURSOR);
    2816      196792 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2817             : #line 1950 "Zend/zend_language_scanner.l"
    2818             :                 {
    2819             :         register char *s, *t;
    2820             :         char *end;
    2821             :         int bprefix = (yytext[0] != '\'') ? 1 : 0;
    2822             : 
    2823             :         while (1) {
    2824             :                 if (YYCURSOR < YYLIMIT) {
    2825             :                         if (*YYCURSOR == '\'') {
    2826             :                                 YYCURSOR++;
    2827             :                                 yyleng = YYCURSOR - SCNG(yy_text);
    2828             : 
    2829             :                                 break;
    2830             :                         } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
    2831             :                                 YYCURSOR++;
    2832             :                         }
    2833             :                 } else {
    2834             :                         yyleng = YYLIMIT - SCNG(yy_text);
    2835             : 
    2836             :                         /* Unclosed single quotes; treat similar to double quotes, but without a separate token
    2837             :                          * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
    2838             :                          * rule, which continued in ST_IN_SCRIPTING state after the quote */
    2839             :                         ZVAL_NULL(zendlval);
    2840             :                         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    2841             :                 }
    2842             :         }
    2843             : 
    2844             :         ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2);
    2845             : 
    2846             :         /* convert escape sequences */
    2847             :         s = t = Z_STRVAL_P(zendlval);
    2848             :         end = s+Z_STRLEN_P(zendlval);
    2849             :         while (s<end) {
    2850             :                 if (*s=='\\') {
    2851             :                         s++;
    2852             : 
    2853             :                         switch(*s) {
    2854             :                                 case '\\':
    2855             :                                 case '\'':
    2856             :                                         *t++ = *s;
    2857             :                                         Z_STRLEN_P(zendlval)--;
    2858             :                                         break;
    2859             :                                 default:
    2860             :                                         *t++ = '\\';
    2861             :                                         *t++ = *s;
    2862             :                                         break;
    2863             :                         }
    2864             :                 } else {
    2865             :                         *t++ = *s;
    2866             :                 }
    2867             : 
    2868             :                 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
    2869             :                         CG(zend_lineno)++;
    2870             :                 }
    2871             :                 s++;
    2872             :         }
    2873             :         *t = 0;
    2874             : 
    2875             :         if (SCNG(output_filter)) {
    2876             :                 size_t sz = 0;
    2877             :                 char *str = NULL;
    2878             :                 s = Z_STRVAL_P(zendlval);
    2879             :                 // TODO: avoid reallocation ???
    2880             :                 SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval));
    2881             :                 ZVAL_STRINGL(zendlval, str, sz);
    2882             :         }
    2883             :         RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING);
    2884             : }
    2885             : #line 2886 "Zend/zend_language_scanner.c"
    2886             : yy143:
    2887             :                 YYDEBUG(143, *YYCURSOR);
    2888      198994 :                 ++YYCURSOR;
    2889             : yy144:
    2890             :                 YYDEBUG(144, *YYCURSOR);
    2891      199436 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2892             : #line 2019 "Zend/zend_language_scanner.l"
    2893             :                 {
    2894             :         int bprefix = (yytext[0] != '"') ? 1 : 0;
    2895             : 
    2896             :         while (YYCURSOR < YYLIMIT) {
    2897             :                 switch (*YYCURSOR++) {
    2898             :                         case '"':
    2899             :                                 yyleng = YYCURSOR - SCNG(yy_text);
    2900             :                                 zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"');
    2901             :                                 RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING);
    2902             :                         case '$':
    2903             :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    2904             :                                         break;
    2905             :                                 }
    2906             :                                 continue;
    2907             :                         case '{':
    2908             :                                 if (*YYCURSOR == '$') {
    2909             :                                         break;
    2910             :                                 }
    2911             :                                 continue;
    2912             :                         case '\\':
    2913             :                                 if (YYCURSOR < YYLIMIT) {
    2914             :                                         YYCURSOR++;
    2915             :                                 }
    2916             :                                 /* fall through */
    2917             :                         default:
    2918             :                                 continue;
    2919             :                 }
    2920             : 
    2921             :                 YYCURSOR--;
    2922             :                 break;
    2923             :         }
    2924             : 
    2925             :         /* Remember how much was scanned to save rescanning */
    2926             :         SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
    2927             : 
    2928             :         YYCURSOR = SCNG(yy_text) + yyleng;
    2929             : 
    2930             :         BEGIN(ST_DOUBLE_QUOTES);
    2931             :         RETURN_TOKEN('"');
    2932             : }
    2933             : #line 2934 "Zend/zend_language_scanner.c"
    2934             : yy145:
    2935             :                 YYDEBUG(145, *YYCURSOR);
    2936         120 :                 ++YYCURSOR;
    2937             :                 YYDEBUG(146, *YYCURSOR);
    2938         120 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2939             : #line 2109 "Zend/zend_language_scanner.l"
    2940             :                 {
    2941             :         BEGIN(ST_BACKQUOTE);
    2942             :         RETURN_TOKEN('`');
    2943             : }
    2944             : #line 2945 "Zend/zend_language_scanner.c"
    2945             : yy147:
    2946             :                 YYDEBUG(147, *YYCURSOR);
    2947        3606 :                 ++YYCURSOR;
    2948             :                 YYDEBUG(148, *YYCURSOR);
    2949        3606 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2950             : #line 2371 "Zend/zend_language_scanner.l"
    2951             :                 {
    2952             :         if (YYCURSOR > YYLIMIT) {
    2953             :                 RETURN_TOKEN(END);
    2954             :         }
    2955             : 
    2956             :         zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
    2957             :         goto restart;
    2958             : }
    2959             : #line 2960 "Zend/zend_language_scanner.c"
    2960             : yy149:
    2961             :                 YYDEBUG(149, *YYCURSOR);
    2962    13978334 :                 ++YYCURSOR;
    2963    13978334 :                 YYFILL(1);
    2964    13978334 :                 yych = *YYCURSOR;
    2965             : yy150:
    2966             :                 YYDEBUG(150, *YYCURSOR);
    2967    14395479 :                 if (yybm[0+yych] & 4) {
    2968    13919840 :                         goto yy149;
    2969             :                 }
    2970      475639 :                 goto yy87;
    2971             : yy151:
    2972             :                 YYDEBUG(151, *YYCURSOR);
    2973       24954 :                 yyaccept = 3;
    2974       24954 :                 YYMARKER = ++YYCURSOR;
    2975       24954 :                 YYFILL(3);
    2976       24954 :                 yych = *YYCURSOR;
    2977             :                 YYDEBUG(152, *YYCURSOR);
    2978       24954 :                 if (yybm[0+yych] & 8) {
    2979       19397 :                         goto yy151;
    2980             :                 }
    2981        5557 :                 if (yych == 'E') goto yy156;
    2982        5061 :                 if (yych == 'e') goto yy156;
    2983             : yy153:
    2984             :                 YYDEBUG(153, *YYCURSOR);
    2985        6675 :                 yyleng = YYCURSOR - SCNG(yy_text);
    2986             : #line 1724 "Zend/zend_language_scanner.l"
    2987             :                 {
    2988             :         const char *end;
    2989             : 
    2990             :         ZVAL_DOUBLE(zendlval, zend_strtod(yytext, &end));
    2991             :         /* errno isn't checked since we allow HUGE_VAL/INF overflow */
    2992             :         ZEND_ASSERT(end == yytext + yyleng);
    2993             :         RETURN_TOKEN(T_DNUMBER);
    2994             : }
    2995             : #line 2996 "Zend/zend_language_scanner.c"
    2996             : yy154:
    2997             :                 YYDEBUG(154, *YYCURSOR);
    2998      189442 :                 yyaccept = 2;
    2999      189442 :                 YYMARKER = ++YYCURSOR;
    3000      189442 :                 YYFILL(3);
    3001      189442 :                 yych = *YYCURSOR;
    3002             :                 YYDEBUG(155, *YYCURSOR);
    3003      189442 :                 if (yych <= '9') {
    3004      118130 :                         if (yych == '.') goto yy151;
    3005      114691 :                         if (yych <= '/') goto yy136;
    3006       92812 :                         goto yy154;
    3007             :                 } else {
    3008       71312 :                         if (yych <= 'E') {
    3009        6104 :                                 if (yych <= 'D') goto yy136;
    3010             :                         } else {
    3011       65208 :                                 if (yych != 'e') goto yy136;
    3012             :                         }
    3013             :                 }
    3014             : yy156:
    3015             :                 YYDEBUG(156, *YYCURSOR);
    3016        1893 :                 yych = *++YYCURSOR;
    3017        1893 :                 if (yych <= ',') {
    3018         144 :                         if (yych == '+') goto yy158;
    3019             :                 } else {
    3020        1749 :                         if (yych <= '-') goto yy158;
    3021        1195 :                         if (yych <= '/') goto yy157;
    3022        1195 :                         if (yych <= '9') goto yy159;
    3023             :                 }
    3024             : yy157:
    3025             :                 YYDEBUG(157, *YYCURSOR);
    3026       81010 :                 YYCURSOR = YYMARKER;
    3027       81010 :                 if (yyaccept <= 3) {
    3028       80670 :                         if (yyaccept <= 1) {
    3029       80670 :                                 if (yyaccept <= 0) {
    3030           0 :                                         goto yy87;
    3031             :                                 } else {
    3032       80670 :                                         goto yy102;
    3033             :                                 }
    3034             :                         } else {
    3035           0 :                                 if (yyaccept <= 2) {
    3036           0 :                                         goto yy136;
    3037             :                                 } else {
    3038           0 :                                         goto yy153;
    3039             :                                 }
    3040             :                         }
    3041             :                 } else {
    3042         340 :                         if (yyaccept <= 5) {
    3043         174 :                                 if (yyaccept <= 4) {
    3044         173 :                                         goto yy190;
    3045             :                                 } else {
    3046           1 :                                         goto yy210;
    3047             :                                 }
    3048             :                         } else {
    3049         166 :                                 goto yy601;
    3050             :                         }
    3051             :                 }
    3052             : yy158:
    3053             :                 YYDEBUG(158, *YYCURSOR);
    3054         698 :                 yych = *++YYCURSOR;
    3055         698 :                 if (yych <= '/') goto yy157;
    3056         698 :                 if (yych >= ':') goto yy157;
    3057             : yy159:
    3058             :                 YYDEBUG(159, *YYCURSOR);
    3059        3105 :                 ++YYCURSOR;
    3060        3105 :                 YYFILL(1);
    3061        3105 :                 yych = *YYCURSOR;
    3062             :                 YYDEBUG(160, *YYCURSOR);
    3063        3105 :                 if (yych <= '/') goto yy153;
    3064        1243 :                 if (yych <= '9') goto yy159;
    3065          31 :                 goto yy153;
    3066             : yy161:
    3067             :                 YYDEBUG(161, *YYCURSOR);
    3068        3252 :                 yych = *++YYCURSOR;
    3069        3252 :                 if (yybm[0+yych] & 32) {
    3070        3252 :                         goto yy166;
    3071             :                 }
    3072           0 :                 goto yy157;
    3073             : yy162:
    3074             :                 YYDEBUG(162, *YYCURSOR);
    3075          73 :                 yych = *++YYCURSOR;
    3076          73 :                 if (yybm[0+yych] & 16) {
    3077          73 :                         goto yy163;
    3078             :                 }
    3079           0 :                 goto yy157;
    3080             : yy163:
    3081             :                 YYDEBUG(163, *YYCURSOR);
    3082        2529 :                 ++YYCURSOR;
    3083        2529 :                 YYFILL(1);
    3084        2529 :                 yych = *YYCURSOR;
    3085             :                 YYDEBUG(164, *YYCURSOR);
    3086        2529 :                 if (yybm[0+yych] & 16) {
    3087        2456 :                         goto yy163;
    3088             :                 }
    3089             :                 YYDEBUG(165, *YYCURSOR);
    3090          73 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3091             : #line 1602 "Zend/zend_language_scanner.l"
    3092             :                 {
    3093             :         char *bin = yytext + 2; /* Skip "0b" */
    3094             :         int len = yyleng - 2;
    3095             :         char *end;
    3096             : 
    3097             :         /* Skip any leading 0s */
    3098             :         while (*bin == '0') {
    3099             :                 ++bin;
    3100             :                 --len;
    3101             :         }
    3102             : 
    3103             :         if (len < SIZEOF_ZEND_LONG * 8) {
    3104             :                 if (len == 0) {
    3105             :                         ZVAL_LONG(zendlval, 0);
    3106             :                 } else {
    3107             :                         errno = 0;
    3108             :                         ZVAL_LONG(zendlval, ZEND_STRTOL(bin, &end, 2));
    3109             :                         ZEND_ASSERT(!errno && end == yytext + yyleng);
    3110             :                 }
    3111             :                 RETURN_TOKEN(T_LNUMBER);
    3112             :         } else {
    3113             :                 ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, (const char **)&end));
    3114             :                 /* errno isn't checked since we allow HUGE_VAL/INF overflow */
    3115             :                 ZEND_ASSERT(end == yytext + yyleng);
    3116             :                 RETURN_TOKEN(T_DNUMBER);
    3117             :         }
    3118             : }
    3119             : #line 3120 "Zend/zend_language_scanner.c"
    3120             : yy166:
    3121             :                 YYDEBUG(166, *YYCURSOR);
    3122       11365 :                 ++YYCURSOR;
    3123       11365 :                 YYFILL(1);
    3124       11365 :                 yych = *YYCURSOR;
    3125             :                 YYDEBUG(167, *YYCURSOR);
    3126       11365 :                 if (yybm[0+yych] & 32) {
    3127        8113 :                         goto yy166;
    3128             :                 }
    3129             :                 YYDEBUG(168, *YYCURSOR);
    3130        3252 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3131             : #line 1675 "Zend/zend_language_scanner.l"
    3132             :                 {
    3133             :         char *hex = yytext + 2; /* Skip "0x" */
    3134             :         int len = yyleng - 2;
    3135             :         char *end;
    3136             : 
    3137             :         /* Skip any leading 0s */
    3138             :         while (*hex == '0') {
    3139             :                 hex++;
    3140             :                 len--;
    3141             :         }
    3142             : 
    3143             :         if (len < SIZEOF_ZEND_LONG * 2 || (len == SIZEOF_ZEND_LONG * 2 && *hex <= '7')) {
    3144             :                 if (len == 0) {
    3145             :                         ZVAL_LONG(zendlval, 0);
    3146             :                 } else {
    3147             :                         errno = 0;
    3148             :                         ZVAL_LONG(zendlval, ZEND_STRTOL(hex, &end, 16));
    3149             :                         ZEND_ASSERT(!errno && end == hex + len);
    3150             :                 }
    3151             :                 RETURN_TOKEN(T_LNUMBER);
    3152             :         } else {
    3153             :                 ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, (const char **)&end));
    3154             :                 /* errno isn't checked since we allow HUGE_VAL/INF overflow */
    3155             :                 ZEND_ASSERT(end == hex + len);
    3156             :                 RETURN_TOKEN(T_DNUMBER);
    3157             :         }
    3158             : }
    3159             : #line 3160 "Zend/zend_language_scanner.c"
    3160             : yy169:
    3161             :                 YYDEBUG(169, *YYCURSOR);
    3162     4301334 :                 ++YYCURSOR;
    3163     4301334 :                 YYFILL(1);
    3164     4301334 :                 yych = *YYCURSOR;
    3165             :                 YYDEBUG(170, *YYCURSOR);
    3166     4301334 :                 if (yych <= '^') {
    3167     1008289 :                         if (yych <= '9') {
    3168      643745 :                                 if (yych >= '0') goto yy169;
    3169             :                         } else {
    3170      364544 :                                 if (yych <= '@') goto yy171;
    3171      328071 :                                 if (yych <= 'Z') goto yy169;
    3172             :                         }
    3173             :                 } else {
    3174     3293045 :                         if (yych <= '`') {
    3175      143783 :                                 if (yych <= '_') goto yy169;
    3176             :                         } else {
    3177     3149262 :                                 if (yych <= 'z') goto yy169;
    3178        1402 :                                 if (yych >= 0x7F) goto yy169;
    3179             :                         }
    3180             :                 }
    3181             : yy171:
    3182             :                 YYDEBUG(171, *YYCURSOR);
    3183      748070 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3184             : #line 1853 "Zend/zend_language_scanner.l"
    3185             :                 {
    3186             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    3187             :         RETURN_TOKEN(T_VARIABLE);
    3188             : }
    3189             : #line 3190 "Zend/zend_language_scanner.c"
    3190             : yy172:
    3191             :                 YYDEBUG(172, *YYCURSOR);
    3192           8 :                 yych = *++YYCURSOR;
    3193           8 :                 if (yych == 'R') goto yy173;
    3194           6 :                 if (yych != 'r') goto yy150;
    3195             : yy173:
    3196             :                 YYDEBUG(173, *YYCURSOR);
    3197           8 :                 ++YYCURSOR;
    3198           8 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3199           0 :                         goto yy149;
    3200             :                 }
    3201             :                 YYDEBUG(174, *YYCURSOR);
    3202           8 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3203             : #line 1548 "Zend/zend_language_scanner.l"
    3204             :                 {
    3205             :         RETURN_TOKEN(T_LOGICAL_XOR);
    3206             : }
    3207             : #line 3208 "Zend/zend_language_scanner.c"
    3208             : yy175:
    3209             :                 YYDEBUG(175, *YYCURSOR);
    3210         993 :                 ++YYCURSOR;
    3211         993 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3212          70 :                         goto yy149;
    3213             :                 }
    3214             :                 YYDEBUG(176, *YYCURSOR);
    3215         923 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3216             : #line 1540 "Zend/zend_language_scanner.l"
    3217             :                 {
    3218             :         RETURN_TOKEN(T_LOGICAL_OR);
    3219             : }
    3220             : #line 3221 "Zend/zend_language_scanner.c"
    3221             : yy177:
    3222             :                 YYDEBUG(177, *YYCURSOR);
    3223           6 :                 ++YYCURSOR;
    3224             :                 YYDEBUG(178, *YYCURSOR);
    3225           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3226             : #line 1528 "Zend/zend_language_scanner.l"
    3227             :                 {
    3228             :         RETURN_TOKEN(T_XOR_EQUAL);
    3229             : }
    3230             : #line 3231 "Zend/zend_language_scanner.c"
    3231             : yy179:
    3232             :                 YYDEBUG(179, *YYCURSOR);
    3233        4612 :                 ++YYCURSOR;
    3234             :                 YYDEBUG(180, *YYCURSOR);
    3235        4612 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3236             : #line 1532 "Zend/zend_language_scanner.l"
    3237             :                 {
    3238             :         RETURN_TOKEN(T_BOOLEAN_OR);
    3239             : }
    3240             : #line 3241 "Zend/zend_language_scanner.c"
    3241             : yy181:
    3242             :                 YYDEBUG(181, *YYCURSOR);
    3243          99 :                 ++YYCURSOR;
    3244             :                 YYDEBUG(182, *YYCURSOR);
    3245          99 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3246             : #line 1524 "Zend/zend_language_scanner.l"
    3247             :                 {
    3248             :         RETURN_TOKEN(T_OR_EQUAL);
    3249             : }
    3250             : #line 3251 "Zend/zend_language_scanner.c"
    3251             : yy183:
    3252             :                 YYDEBUG(183, *YYCURSOR);
    3253        7833 :                 ++YYCURSOR;
    3254             :                 YYDEBUG(184, *YYCURSOR);
    3255        7833 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3256             : #line 1536 "Zend/zend_language_scanner.l"
    3257             :                 {
    3258             :         RETURN_TOKEN(T_BOOLEAN_AND);
    3259             : }
    3260             : #line 3261 "Zend/zend_language_scanner.c"
    3261             : yy185:
    3262             :                 YYDEBUG(185, *YYCURSOR);
    3263           6 :                 ++YYCURSOR;
    3264             :                 YYDEBUG(186, *YYCURSOR);
    3265           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3266             : #line 1520 "Zend/zend_language_scanner.l"
    3267             :                 {
    3268             :         RETURN_TOKEN(T_AND_EQUAL);
    3269             : }
    3270             : #line 3271 "Zend/zend_language_scanner.c"
    3271             : yy187:
    3272             :                 YYDEBUG(187, *YYCURSOR);
    3273           6 :                 ++YYCURSOR;
    3274             :                 YYDEBUG(188, *YYCURSOR);
    3275           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3276             : #line 1508 "Zend/zend_language_scanner.l"
    3277             :                 {
    3278             :         RETURN_TOKEN(T_MOD_EQUAL);
    3279             : }
    3280             : #line 3281 "Zend/zend_language_scanner.c"
    3281             : yy189:
    3282             :                 YYDEBUG(189, *YYCURSOR);
    3283       26355 :                 yyaccept = 4;
    3284       26355 :                 yych = *(YYMARKER = ++YYCURSOR);
    3285       26355 :                 if (yych == '*') goto yy194;
    3286             : yy190:
    3287             :                 YYDEBUG(190, *YYCURSOR);
    3288       26355 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3289             : #line 1911 "Zend/zend_language_scanner.l"
    3290             :                 {
    3291             :         int doc_com;
    3292             : 
    3293             :         if (yyleng > 2) {
    3294             :                 doc_com = 1;
    3295             :                 RESET_DOC_COMMENT();
    3296             :         } else {
    3297             :                 doc_com = 0;
    3298             :         }
    3299             : 
    3300             :         while (YYCURSOR < YYLIMIT) {
    3301             :                 if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
    3302             :                         break;
    3303             :                 }
    3304             :         }
    3305             : 
    3306             :         if (YYCURSOR < YYLIMIT) {
    3307             :                 YYCURSOR++;
    3308             :         } else {
    3309             :                 zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
    3310             :         }
    3311             : 
    3312             :         yyleng = YYCURSOR - SCNG(yy_text);
    3313             :         HANDLE_NEWLINES(yytext, yyleng);
    3314             : 
    3315             :         if (doc_com) {
    3316             :                 CG(doc_comment) = zend_string_init(yytext, yyleng, 0);
    3317             :                 RETURN_TOKEN(T_DOC_COMMENT);
    3318             :         }
    3319             : 
    3320             :         RETURN_TOKEN(T_COMMENT);
    3321             : }
    3322             : #line 3323 "Zend/zend_language_scanner.c"
    3323             : yy191:
    3324             :                 YYDEBUG(191, *YYCURSOR);
    3325       50068 :                 yych = *++YYCURSOR;
    3326       50068 :                 goto yy140;
    3327             : yy192:
    3328             :                 YYDEBUG(192, *YYCURSOR);
    3329           6 :                 ++YYCURSOR;
    3330             :                 YYDEBUG(193, *YYCURSOR);
    3331           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3332             : #line 1500 "Zend/zend_language_scanner.l"
    3333             :                 {
    3334             :         RETURN_TOKEN(T_DIV_EQUAL);
    3335             : }
    3336             : #line 3337 "Zend/zend_language_scanner.c"
    3337             : yy194:
    3338             :                 YYDEBUG(194, *YYCURSOR);
    3339        2789 :                 yych = *++YYCURSOR;
    3340        2789 :                 if (yybm[0+yych] & 64) {
    3341        2616 :                         goto yy195;
    3342             :                 }
    3343         173 :                 goto yy157;
    3344             : yy195:
    3345             :                 YYDEBUG(195, *YYCURSOR);
    3346        7551 :                 ++YYCURSOR;
    3347        7551 :                 YYFILL(1);
    3348        7551 :                 yych = *YYCURSOR;
    3349             :                 YYDEBUG(196, *YYCURSOR);
    3350        7551 :                 if (yybm[0+yych] & 64) {
    3351        4935 :                         goto yy195;
    3352             :                 }
    3353        2616 :                 goto yy190;
    3354             : yy197:
    3355             :                 YYDEBUG(197, *YYCURSOR);
    3356          17 :                 ++YYCURSOR;
    3357          17 :                 if ((yych = *YYCURSOR) == '=') goto yy201;
    3358             :                 YYDEBUG(198, *YYCURSOR);
    3359          13 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3360             : #line 1492 "Zend/zend_language_scanner.l"
    3361             :                 {
    3362             :         RETURN_TOKEN(T_POW);
    3363             : }
    3364             : #line 3365 "Zend/zend_language_scanner.c"
    3365             : yy199:
    3366             :                 YYDEBUG(199, *YYCURSOR);
    3367          17 :                 ++YYCURSOR;
    3368             :                 YYDEBUG(200, *YYCURSOR);
    3369          17 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3370             : #line 1488 "Zend/zend_language_scanner.l"
    3371             :                 {
    3372             :         RETURN_TOKEN(T_MUL_EQUAL);
    3373             : }
    3374             : #line 3375 "Zend/zend_language_scanner.c"
    3375             : yy201:
    3376             :                 YYDEBUG(201, *YYCURSOR);
    3377           4 :                 ++YYCURSOR;
    3378             :                 YYDEBUG(202, *YYCURSOR);
    3379           4 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3380             : #line 1496 "Zend/zend_language_scanner.l"
    3381             :                 {
    3382             :         RETURN_TOKEN(T_POW_EQUAL);
    3383             : }
    3384             : #line 3385 "Zend/zend_language_scanner.c"
    3385             : yy203:
    3386             :                 YYDEBUG(203, *YYCURSOR);
    3387          86 :                 ++YYCURSOR;
    3388          86 :                 if ((yych = *YYCURSOR) == '=') goto yy207;
    3389             :                 YYDEBUG(204, *YYCURSOR);
    3390          72 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3391             : #line 1556 "Zend/zend_language_scanner.l"
    3392             :                 {
    3393             :         RETURN_TOKEN(T_SR);
    3394             : }
    3395             : #line 3396 "Zend/zend_language_scanner.c"
    3396             : yy205:
    3397             :                 YYDEBUG(205, *YYCURSOR);
    3398         609 :                 ++YYCURSOR;
    3399             :                 YYDEBUG(206, *YYCURSOR);
    3400         609 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3401             : #line 1476 "Zend/zend_language_scanner.l"
    3402             :                 {
    3403             :         RETURN_TOKEN(T_IS_GREATER_OR_EQUAL);
    3404             : }
    3405             : #line 3406 "Zend/zend_language_scanner.c"
    3406             : yy207:
    3407             :                 YYDEBUG(207, *YYCURSOR);
    3408          14 :                 ++YYCURSOR;
    3409             :                 YYDEBUG(208, *YYCURSOR);
    3410          14 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3411             : #line 1516 "Zend/zend_language_scanner.l"
    3412             :                 {
    3413             :         RETURN_TOKEN(T_SR_EQUAL);
    3414             : }
    3415             : #line 3416 "Zend/zend_language_scanner.c"
    3416             : yy209:
    3417             :                 YYDEBUG(209, *YYCURSOR);
    3418        1716 :                 yyaccept = 5;
    3419        1716 :                 yych = *(YYMARKER = ++YYCURSOR);
    3420        1716 :                 if (yych <= ';') goto yy210;
    3421        1573 :                 if (yych <= '<') goto yy219;
    3422           8 :                 if (yych <= '=') goto yy217;
    3423             : yy210:
    3424             :                 YYDEBUG(210, *YYCURSOR);
    3425         144 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3426             : #line 1552 "Zend/zend_language_scanner.l"
    3427             :                 {
    3428             :         RETURN_TOKEN(T_SL);
    3429             : }
    3430             : #line 3431 "Zend/zend_language_scanner.c"
    3431             : yy211:
    3432             :                 YYDEBUG(211, *YYCURSOR);
    3433        1775 :                 ++YYCURSOR;
    3434        1775 :                 if ((yych = *YYCURSOR) == '>') goto yy215;
    3435             :                 YYDEBUG(212, *YYCURSOR);
    3436        1765 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3437             : #line 1472 "Zend/zend_language_scanner.l"
    3438             :                 {
    3439             :         RETURN_TOKEN(T_IS_SMALLER_OR_EQUAL);
    3440             : }
    3441             : #line 3442 "Zend/zend_language_scanner.c"
    3442             : yy213:
    3443             :                 YYDEBUG(213, *YYCURSOR);
    3444           5 :                 ++YYCURSOR;
    3445             : yy214:
    3446             :                 YYDEBUG(214, *YYCURSOR);
    3447        2911 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3448             : #line 1464 "Zend/zend_language_scanner.l"
    3449             :                 {
    3450             :         RETURN_TOKEN(T_IS_NOT_EQUAL);
    3451             : }
    3452             : #line 3453 "Zend/zend_language_scanner.c"
    3453             : yy215:
    3454             :                 YYDEBUG(215, *YYCURSOR);
    3455          10 :                 ++YYCURSOR;
    3456             :                 YYDEBUG(216, *YYCURSOR);
    3457          10 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3458             : #line 1468 "Zend/zend_language_scanner.l"
    3459             :                 {
    3460             :         RETURN_TOKEN(T_SPACESHIP);
    3461             : }
    3462             : #line 3463 "Zend/zend_language_scanner.c"
    3463             : yy217:
    3464             :                 YYDEBUG(217, *YYCURSOR);
    3465           8 :                 ++YYCURSOR;
    3466             :                 YYDEBUG(218, *YYCURSOR);
    3467           8 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3468             : #line 1512 "Zend/zend_language_scanner.l"
    3469             :                 {
    3470             :         RETURN_TOKEN(T_SL_EQUAL);
    3471             : }
    3472             : #line 3473 "Zend/zend_language_scanner.c"
    3473             : yy219:
    3474             :                 YYDEBUG(219, *YYCURSOR);
    3475        1631 :                 ++YYCURSOR;
    3476        1631 :                 YYFILL(2);
    3477        1631 :                 yych = *YYCURSOR;
    3478             :                 YYDEBUG(220, *YYCURSOR);
    3479        1631 :                 if (yybm[0+yych] & 128) {
    3480          34 :                         goto yy219;
    3481             :                 }
    3482        1597 :                 if (yych <= 'Z') {
    3483        1590 :                         if (yych <= '&') {
    3484           8 :                                 if (yych == '"') goto yy224;
    3485           0 :                                 goto yy157;
    3486             :                         } else {
    3487        1582 :                                 if (yych <= '\'') goto yy223;
    3488        1464 :                                 if (yych <= '@') goto yy157;
    3489             :                         }
    3490             :                 } else {
    3491           7 :                         if (yych <= '`') {
    3492           2 :                                 if (yych != '_') goto yy157;
    3493             :                         } else {
    3494           5 :                                 if (yych <= 'z') goto yy221;
    3495           0 :                                 if (yych <= '~') goto yy157;
    3496             :                         }
    3497             :                 }
    3498             : yy221:
    3499             :                 YYDEBUG(221, *YYCURSOR);
    3500        5008 :                 ++YYCURSOR;
    3501        5008 :                 YYFILL(2);
    3502        5008 :                 yych = *YYCURSOR;
    3503             :                 YYDEBUG(222, *YYCURSOR);
    3504        5008 :                 if (yych <= '@') {
    3505        1513 :                         if (yych <= '\f') {
    3506        1471 :                                 if (yych == '\n') goto yy228;
    3507           0 :                                 goto yy157;
    3508             :                         } else {
    3509          42 :                                 if (yych <= '\r') goto yy230;
    3510          42 :                                 if (yych <= '/') goto yy157;
    3511          42 :                                 if (yych <= '9') goto yy221;
    3512           0 :                                 goto yy157;
    3513             :                         }
    3514             :                 } else {
    3515        3495 :                         if (yych <= '_') {
    3516        3411 :                                 if (yych <= 'Z') goto yy221;
    3517          16 :                                 if (yych <= '^') goto yy157;
    3518          16 :                                 goto yy221;
    3519             :                         } else {
    3520          84 :                                 if (yych <= '`') goto yy157;
    3521          84 :                                 if (yych <= 'z') goto yy221;
    3522           0 :                                 if (yych <= '~') goto yy157;
    3523           0 :                                 goto yy221;
    3524             :                         }
    3525             :                 }
    3526             : yy223:
    3527             :                 YYDEBUG(223, *YYCURSOR);
    3528         118 :                 yych = *++YYCURSOR;
    3529         118 :                 if (yych == '\'') goto yy157;
    3530         118 :                 if (yych <= '/') goto yy232;
    3531         118 :                 if (yych <= '9') goto yy157;
    3532         118 :                 goto yy232;
    3533             : yy224:
    3534             :                 YYDEBUG(224, *YYCURSOR);
    3535           8 :                 yych = *++YYCURSOR;
    3536           8 :                 if (yych == '"') goto yy157;
    3537           8 :                 if (yych <= '/') goto yy226;
    3538           8 :                 if (yych <= '9') goto yy157;
    3539           8 :                 goto yy226;
    3540             : yy225:
    3541             :                 YYDEBUG(225, *YYCURSOR);
    3542          41 :                 ++YYCURSOR;
    3543          41 :                 YYFILL(3);
    3544          41 :                 yych = *YYCURSOR;
    3545             : yy226:
    3546             :                 YYDEBUG(226, *YYCURSOR);
    3547          49 :                 if (yych <= 'Z') {
    3548          49 :                         if (yych <= '/') {
    3549           8 :                                 if (yych != '"') goto yy157;
    3550             :                         } else {
    3551          41 :                                 if (yych <= '9') goto yy225;
    3552          41 :                                 if (yych <= '@') goto yy157;
    3553          41 :                                 goto yy225;
    3554             :                         }
    3555             :                 } else {
    3556           0 :                         if (yych <= '`') {
    3557           0 :                                 if (yych == '_') goto yy225;
    3558           0 :                                 goto yy157;
    3559             :                         } else {
    3560           0 :                                 if (yych <= 'z') goto yy225;
    3561           0 :                                 if (yych <= '~') goto yy157;
    3562           0 :                                 goto yy225;
    3563             :                         }
    3564             :                 }
    3565             : yy227:
    3566             :                 YYDEBUG(227, *YYCURSOR);
    3567         125 :                 yych = *++YYCURSOR;
    3568         125 :                 if (yych == '\n') goto yy228;
    3569           0 :                 if (yych == '\r') goto yy230;
    3570           0 :                 goto yy157;
    3571             : yy228:
    3572             :                 YYDEBUG(228, *YYCURSOR);
    3573        1596 :                 ++YYCURSOR;
    3574             : yy229:
    3575             :                 YYDEBUG(229, *YYCURSOR);
    3576        1596 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3577             : #line 2061 "Zend/zend_language_scanner.l"
    3578             :                 {
    3579             :         char *s;
    3580             :         int bprefix = (yytext[0] != '<') ? 1 : 0;
    3581             :         zend_heredoc_label *heredoc_label = emalloc(sizeof(zend_heredoc_label));
    3582             : 
    3583             :         CG(zend_lineno)++;
    3584             :         heredoc_label->length = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
    3585             :         s = yytext+bprefix+3;
    3586             :         while ((*s == ' ') || (*s == '\t')) {
    3587             :                 s++;
    3588             :                 heredoc_label->length--;
    3589             :         }
    3590             : 
    3591             :         if (*s == '\'') {
    3592             :                 s++;
    3593             :                 heredoc_label->length -= 2;
    3594             : 
    3595             :                 BEGIN(ST_NOWDOC);
    3596             :         } else {
    3597             :                 if (*s == '"') {
    3598             :                         s++;
    3599             :                         heredoc_label->length -= 2;
    3600             :                 }
    3601             : 
    3602             :                 BEGIN(ST_HEREDOC);
    3603             :         }
    3604             : 
    3605             :         heredoc_label->label = estrndup(s, heredoc_label->length);
    3606             : 
    3607             :         /* Check for ending label on the next line */
    3608             :         if (heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, heredoc_label->length)) {
    3609             :                 YYCTYPE *end = YYCURSOR + heredoc_label->length;
    3610             : 
    3611             :                 if (*end == ';') {
    3612             :                         end++;
    3613             :                 }
    3614             : 
    3615             :                 if (*end == '\n' || *end == '\r') {
    3616             :                         BEGIN(ST_END_HEREDOC);
    3617             :                 }
    3618             :         }
    3619             : 
    3620             :         zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label);
    3621             : 
    3622             :         RETURN_TOKEN(T_START_HEREDOC);
    3623             : }
    3624             : #line 3625 "Zend/zend_language_scanner.c"
    3625             : yy230:
    3626             :                 YYDEBUG(230, *YYCURSOR);
    3627           0 :                 yych = *++YYCURSOR;
    3628           0 :                 if (yych == '\n') goto yy228;
    3629           0 :                 goto yy229;
    3630             : yy231:
    3631             :                 YYDEBUG(231, *YYCURSOR);
    3632         600 :                 ++YYCURSOR;
    3633         600 :                 YYFILL(3);
    3634         600 :                 yych = *YYCURSOR;
    3635             : yy232:
    3636             :                 YYDEBUG(232, *YYCURSOR);
    3637         718 :                 if (yych <= 'Z') {
    3638         712 :                         if (yych <= '/') {
    3639         118 :                                 if (yych == '\'') goto yy227;
    3640           0 :                                 goto yy157;
    3641             :                         } else {
    3642         594 :                                 if (yych <= '9') goto yy231;
    3643         594 :                                 if (yych <= '@') goto yy157;
    3644         594 :                                 goto yy231;
    3645             :                         }
    3646             :                 } else {
    3647           6 :                         if (yych <= '`') {
    3648           0 :                                 if (yych == '_') goto yy231;
    3649           0 :                                 goto yy157;
    3650             :                         } else {
    3651           6 :                                 if (yych <= 'z') goto yy231;
    3652           0 :                                 if (yych <= '~') goto yy157;
    3653           0 :                                 goto yy231;
    3654             :                         }
    3655             :                 }
    3656             : yy233:
    3657             :                 YYDEBUG(233, *YYCURSOR);
    3658       11537 :                 yych = *++YYCURSOR;
    3659       11537 :                 if (yych != '=') goto yy214;
    3660             :                 YYDEBUG(234, *YYCURSOR);
    3661        8631 :                 ++YYCURSOR;
    3662             :                 YYDEBUG(235, *YYCURSOR);
    3663        8631 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3664             : #line 1456 "Zend/zend_language_scanner.l"
    3665             :                 {
    3666             :         RETURN_TOKEN(T_IS_NOT_IDENTICAL);
    3667             : }
    3668             : #line 3669 "Zend/zend_language_scanner.c"
    3669             : yy236:
    3670             :                 YYDEBUG(236, *YYCURSOR);
    3671         718 :                 ++YYCURSOR;
    3672             :                 YYDEBUG(237, *YYCURSOR);
    3673         718 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3674             : #line 1480 "Zend/zend_language_scanner.l"
    3675             :                 {
    3676             :         RETURN_TOKEN(T_PLUS_EQUAL);
    3677             : }
    3678             : #line 3679 "Zend/zend_language_scanner.c"
    3679             : yy238:
    3680             :                 YYDEBUG(238, *YYCURSOR);
    3681        6291 :                 ++YYCURSOR;
    3682             :                 YYDEBUG(239, *YYCURSOR);
    3683        6291 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3684             : #line 1444 "Zend/zend_language_scanner.l"
    3685             :                 {
    3686             :         RETURN_TOKEN(T_INC);
    3687             : }
    3688             : #line 3689 "Zend/zend_language_scanner.c"
    3689             : yy240:
    3690             :                 YYDEBUG(240, *YYCURSOR);
    3691         540 :                 yych = *++YYCURSOR;
    3692         540 :                 if (yych == 'S') goto yy241;
    3693         538 :                 if (yych != 's') goto yy150;
    3694             : yy241:
    3695             :                 YYDEBUG(241, *YYCURSOR);
    3696         210 :                 yych = *++YYCURSOR;
    3697         210 :                 if (yych == 'T') goto yy242;
    3698         208 :                 if (yych != 't') goto yy150;
    3699             : yy242:
    3700             :                 YYDEBUG(242, *YYCURSOR);
    3701         210 :                 ++YYCURSOR;
    3702         210 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3703          14 :                         goto yy149;
    3704             :                 }
    3705             :                 YYDEBUG(243, *YYCURSOR);
    3706         196 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3707             : #line 1432 "Zend/zend_language_scanner.l"
    3708             :                 {
    3709             :         RETURN_TOKEN(T_LIST);
    3710             : }
    3711             : #line 3712 "Zend/zend_language_scanner.c"
    3712             : yy244:
    3713             :                 YYDEBUG(244, *YYCURSOR);
    3714       23485 :                 ++YYCURSOR;
    3715       23485 :                 if ((yych = *YYCURSOR) == '=') goto yy248;
    3716             :                 YYDEBUG(245, *YYCURSOR);
    3717       17052 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3718             : #line 1460 "Zend/zend_language_scanner.l"
    3719             :                 {
    3720             :         RETURN_TOKEN(T_IS_EQUAL);
    3721             : }
    3722             : #line 3723 "Zend/zend_language_scanner.c"
    3723             : yy246:
    3724             :                 YYDEBUG(246, *YYCURSOR);
    3725       33379 :                 ++YYCURSOR;
    3726             :                 YYDEBUG(247, *YYCURSOR);
    3727       33379 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3728             : #line 1428 "Zend/zend_language_scanner.l"
    3729             :                 {
    3730             :         RETURN_TOKEN(T_DOUBLE_ARROW);
    3731             : }
    3732             : #line 3733 "Zend/zend_language_scanner.c"
    3733             : yy248:
    3734             :                 YYDEBUG(248, *YYCURSOR);
    3735        6433 :                 ++YYCURSOR;
    3736             :                 YYDEBUG(249, *YYCURSOR);
    3737        6433 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3738             : #line 1452 "Zend/zend_language_scanner.l"
    3739             :                 {
    3740             :         RETURN_TOKEN(T_IS_IDENTICAL);
    3741             : }
    3742             : #line 3743 "Zend/zend_language_scanner.c"
    3743             : yy250:
    3744             :                 YYDEBUG(250, *YYCURSOR);
    3745       16246 :                 yych = *++YYCURSOR;
    3746             :                 YYDEBUG(-1, yych);
    3747       16246 :                 switch (yych) {
    3748             :                 case 'C':
    3749        3240 :                 case 'c':       goto yy252;
    3750             :                 case 'D':
    3751         841 :                 case 'd':       goto yy257;
    3752             :                 case 'F':
    3753        9731 :                 case 'f':       goto yy254;
    3754             :                 case 'H':
    3755         289 :                 case 'h':       goto yy251;
    3756             :                 case 'L':
    3757          89 :                 case 'l':       goto yy256;
    3758             :                 case 'M':
    3759         993 :                 case 'm':       goto yy255;
    3760             :                 case 'N':
    3761          41 :                 case 'n':       goto yy258;
    3762             :                 case 'T':
    3763         715 :                 case 't':       goto yy253;
    3764         307 :                 default:        goto yy150;
    3765             :                 }
    3766             : yy251:
    3767             :                 YYDEBUG(251, *YYCURSOR);
    3768         289 :                 yych = *++YYCURSOR;
    3769         289 :                 if (yych == 'A') goto yy319;
    3770          36 :                 if (yych == 'a') goto yy319;
    3771           0 :                 goto yy150;
    3772             : yy252:
    3773             :                 YYDEBUG(252, *YYCURSOR);
    3774        3240 :                 yych = *++YYCURSOR;
    3775        3240 :                 if (yych == 'L') goto yy312;
    3776        3139 :                 if (yych == 'l') goto yy312;
    3777        3108 :                 goto yy150;
    3778             : yy253:
    3779             :                 YYDEBUG(253, *YYCURSOR);
    3780         715 :                 yych = *++YYCURSOR;
    3781         715 :                 if (yych == 'R') goto yy305;
    3782         704 :                 if (yych == 'r') goto yy305;
    3783         704 :                 goto yy150;
    3784             : yy254:
    3785             :                 YYDEBUG(254, *YYCURSOR);
    3786        9731 :                 yych = *++YYCURSOR;
    3787        9731 :                 if (yych <= 'U') {
    3788        9729 :                         if (yych == 'I') goto yy289;
    3789         137 :                         if (yych <= 'T') goto yy150;
    3790         137 :                         goto yy290;
    3791             :                 } else {
    3792           2 :                         if (yych <= 'i') {
    3793           1 :                                 if (yych <= 'h') goto yy150;
    3794           1 :                                 goto yy289;
    3795             :                         } else {
    3796           1 :                                 if (yych == 'u') goto yy290;
    3797           0 :                                 goto yy150;
    3798             :                         }
    3799             :                 }
    3800             : yy255:
    3801             :                 YYDEBUG(255, *YYCURSOR);
    3802         993 :                 yych = *++YYCURSOR;
    3803         993 :                 if (yych == 'E') goto yy281;
    3804           1 :                 if (yych == 'e') goto yy281;
    3805           0 :                 goto yy150;
    3806             : yy256:
    3807             :                 YYDEBUG(256, *YYCURSOR);
    3808          89 :                 yych = *++YYCURSOR;
    3809          89 :                 if (yych == 'I') goto yy275;
    3810          62 :                 if (yych == 'i') goto yy275;
    3811          61 :                 goto yy150;
    3812             : yy257:
    3813             :                 YYDEBUG(257, *YYCURSOR);
    3814         841 :                 yych = *++YYCURSOR;
    3815         841 :                 if (yych == 'I') goto yy270;
    3816         233 :                 if (yych == 'i') goto yy270;
    3817         232 :                 goto yy150;
    3818             : yy258:
    3819             :                 YYDEBUG(258, *YYCURSOR);
    3820          41 :                 yych = *++YYCURSOR;
    3821          41 :                 if (yych == 'A') goto yy259;
    3822           1 :                 if (yych != 'a') goto yy150;
    3823             : yy259:
    3824             :                 YYDEBUG(259, *YYCURSOR);
    3825          41 :                 yych = *++YYCURSOR;
    3826          41 :                 if (yych == 'M') goto yy260;
    3827           1 :                 if (yych != 'm') goto yy150;
    3828             : yy260:
    3829             :                 YYDEBUG(260, *YYCURSOR);
    3830          41 :                 yych = *++YYCURSOR;
    3831          41 :                 if (yych == 'E') goto yy261;
    3832           1 :                 if (yych != 'e') goto yy150;
    3833             : yy261:
    3834             :                 YYDEBUG(261, *YYCURSOR);
    3835          41 :                 yych = *++YYCURSOR;
    3836          41 :                 if (yych == 'S') goto yy262;
    3837           1 :                 if (yych != 's') goto yy150;
    3838             : yy262:
    3839             :                 YYDEBUG(262, *YYCURSOR);
    3840          41 :                 yych = *++YYCURSOR;
    3841          41 :                 if (yych == 'P') goto yy263;
    3842           1 :                 if (yych != 'p') goto yy150;
    3843             : yy263:
    3844             :                 YYDEBUG(263, *YYCURSOR);
    3845          41 :                 yych = *++YYCURSOR;
    3846          41 :                 if (yych == 'A') goto yy264;
    3847           1 :                 if (yych != 'a') goto yy150;
    3848             : yy264:
    3849             :                 YYDEBUG(264, *YYCURSOR);
    3850          41 :                 yych = *++YYCURSOR;
    3851          41 :                 if (yych == 'C') goto yy265;
    3852           1 :                 if (yych != 'c') goto yy150;
    3853             : yy265:
    3854             :                 YYDEBUG(265, *YYCURSOR);
    3855          41 :                 yych = *++YYCURSOR;
    3856          41 :                 if (yych == 'E') goto yy266;
    3857           1 :                 if (yych != 'e') goto yy150;
    3858             : yy266:
    3859             :                 YYDEBUG(266, *YYCURSOR);
    3860          41 :                 yych = *++YYCURSOR;
    3861          41 :                 if (yych != '_') goto yy150;
    3862             :                 YYDEBUG(267, *YYCURSOR);
    3863          41 :                 yych = *++YYCURSOR;
    3864          41 :                 if (yych != '_') goto yy150;
    3865             :                 YYDEBUG(268, *YYCURSOR);
    3866          41 :                 ++YYCURSOR;
    3867          41 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3868           0 :                         goto yy149;
    3869             :                 }
    3870             :                 YYDEBUG(269, *YYCURSOR);
    3871          41 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3872             : #line 1761 "Zend/zend_language_scanner.l"
    3873             :                 {
    3874             :         RETURN_TOKEN(T_NS_C);
    3875             : }
    3876             : #line 3877 "Zend/zend_language_scanner.c"
    3877             : yy270:
    3878             :                 YYDEBUG(270, *YYCURSOR);
    3879         609 :                 yych = *++YYCURSOR;
    3880         609 :                 if (yych == 'R') goto yy271;
    3881           1 :                 if (yych != 'r') goto yy150;
    3882             : yy271:
    3883             :                 YYDEBUG(271, *YYCURSOR);
    3884         609 :                 yych = *++YYCURSOR;
    3885         609 :                 if (yych != '_') goto yy150;
    3886             :                 YYDEBUG(272, *YYCURSOR);
    3887         609 :                 yych = *++YYCURSOR;
    3888         609 :                 if (yych != '_') goto yy150;
    3889             :                 YYDEBUG(273, *YYCURSOR);
    3890         609 :                 ++YYCURSOR;
    3891         609 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3892           0 :                         goto yy149;
    3893             :                 }
    3894             :                 YYDEBUG(274, *YYCURSOR);
    3895         609 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3896             : #line 1757 "Zend/zend_language_scanner.l"
    3897             :                 {
    3898             :         RETURN_TOKEN(T_DIR);
    3899             : }
    3900             : #line 3901 "Zend/zend_language_scanner.c"
    3901             : yy275:
    3902             :                 YYDEBUG(275, *YYCURSOR);
    3903          28 :                 yych = *++YYCURSOR;
    3904          28 :                 if (yych == 'N') goto yy276;
    3905           1 :                 if (yych != 'n') goto yy150;
    3906             : yy276:
    3907             :                 YYDEBUG(276, *YYCURSOR);
    3908          28 :                 yych = *++YYCURSOR;
    3909          28 :                 if (yych == 'E') goto yy277;
    3910           1 :                 if (yych != 'e') goto yy150;
    3911             : yy277:
    3912             :                 YYDEBUG(277, *YYCURSOR);
    3913          28 :                 yych = *++YYCURSOR;
    3914          28 :                 if (yych != '_') goto yy150;
    3915             :                 YYDEBUG(278, *YYCURSOR);
    3916          28 :                 yych = *++YYCURSOR;
    3917          28 :                 if (yych != '_') goto yy150;
    3918             :                 YYDEBUG(279, *YYCURSOR);
    3919          28 :                 ++YYCURSOR;
    3920          28 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3921           0 :                         goto yy149;
    3922             :                 }
    3923             :                 YYDEBUG(280, *YYCURSOR);
    3924          28 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3925             : #line 1749 "Zend/zend_language_scanner.l"
    3926             :                 {
    3927             :         RETURN_TOKEN(T_LINE);
    3928             : }
    3929             : #line 3930 "Zend/zend_language_scanner.c"
    3930             : yy281:
    3931             :                 YYDEBUG(281, *YYCURSOR);
    3932         993 :                 yych = *++YYCURSOR;
    3933         993 :                 if (yych == 'T') goto yy282;
    3934           1 :                 if (yych != 't') goto yy150;
    3935             : yy282:
    3936             :                 YYDEBUG(282, *YYCURSOR);
    3937         993 :                 yych = *++YYCURSOR;
    3938         993 :                 if (yych == 'H') goto yy283;
    3939           1 :                 if (yych != 'h') goto yy150;
    3940             : yy283:
    3941             :                 YYDEBUG(283, *YYCURSOR);
    3942         993 :                 yych = *++YYCURSOR;
    3943         993 :                 if (yych == 'O') goto yy284;
    3944           1 :                 if (yych != 'o') goto yy150;
    3945             : yy284:
    3946             :                 YYDEBUG(284, *YYCURSOR);
    3947         993 :                 yych = *++YYCURSOR;
    3948         993 :                 if (yych == 'D') goto yy285;
    3949           1 :                 if (yych != 'd') goto yy150;
    3950             : yy285:
    3951             :                 YYDEBUG(285, *YYCURSOR);
    3952         993 :                 yych = *++YYCURSOR;
    3953         993 :                 if (yych != '_') goto yy150;
    3954             :                 YYDEBUG(286, *YYCURSOR);
    3955         993 :                 yych = *++YYCURSOR;
    3956         993 :                 if (yych != '_') goto yy150;
    3957             :                 YYDEBUG(287, *YYCURSOR);
    3958         993 :                 ++YYCURSOR;
    3959         993 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    3960           0 :                         goto yy149;
    3961             :                 }
    3962             :                 YYDEBUG(288, *YYCURSOR);
    3963         993 :                 yyleng = YYCURSOR - SCNG(yy_text);
    3964             : #line 1745 "Zend/zend_language_scanner.l"
    3965             :                 {
    3966             :         RETURN_TOKEN(T_METHOD_C);
    3967             : }
    3968             : #line 3969 "Zend/zend_language_scanner.c"
    3969             : yy289:
    3970             :                 YYDEBUG(289, *YYCURSOR);
    3971        9593 :                 yych = *++YYCURSOR;
    3972        9593 :                 if (yych == 'L') goto yy300;
    3973           1 :                 if (yych == 'l') goto yy300;
    3974           0 :                 goto yy150;
    3975             : yy290:
    3976             :                 YYDEBUG(290, *YYCURSOR);
    3977         138 :                 yych = *++YYCURSOR;
    3978         138 :                 if (yych == 'N') goto yy291;
    3979           1 :                 if (yych != 'n') goto yy150;
    3980             : yy291:
    3981             :                 YYDEBUG(291, *YYCURSOR);
    3982         138 :                 yych = *++YYCURSOR;
    3983         138 :                 if (yych == 'C') goto yy292;
    3984           1 :                 if (yych != 'c') goto yy150;
    3985             : yy292:
    3986             :                 YYDEBUG(292, *YYCURSOR);
    3987         138 :                 yych = *++YYCURSOR;
    3988         138 :                 if (yych == 'T') goto yy293;
    3989           1 :                 if (yych != 't') goto yy150;
    3990             : yy293:
    3991             :                 YYDEBUG(293, *YYCURSOR);
    3992         138 :                 yych = *++YYCURSOR;
    3993         138 :                 if (yych == 'I') goto yy294;
    3994           1 :                 if (yych != 'i') goto yy150;
    3995             : yy294:
    3996             :                 YYDEBUG(294, *YYCURSOR);
    3997         138 :                 yych = *++YYCURSOR;
    3998         138 :                 if (yych == 'O') goto yy295;
    3999           1 :                 if (yych != 'o') goto yy150;
    4000             : yy295:
    4001             :                 YYDEBUG(295, *YYCURSOR);
    4002         138 :                 yych = *++YYCURSOR;
    4003         138 :                 if (yych == 'N') goto yy296;
    4004           1 :                 if (yych != 'n') goto yy150;
    4005             : yy296:
    4006             :                 YYDEBUG(296, *YYCURSOR);
    4007         138 :                 yych = *++YYCURSOR;
    4008         138 :                 if (yych != '_') goto yy150;
    4009             :                 YYDEBUG(297, *YYCURSOR);
    4010         138 :                 yych = *++YYCURSOR;
    4011         138 :                 if (yych != '_') goto yy150;
    4012             :                 YYDEBUG(298, *YYCURSOR);
    4013         138 :                 ++YYCURSOR;
    4014         138 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4015           0 :                         goto yy149;
    4016             :                 }
    4017             :                 YYDEBUG(299, *YYCURSOR);
    4018         138 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4019             : #line 1741 "Zend/zend_language_scanner.l"
    4020             :                 {
    4021             :         RETURN_TOKEN(T_FUNC_C);
    4022             : }
    4023             : #line 4024 "Zend/zend_language_scanner.c"
    4024             : yy300:
    4025             :                 YYDEBUG(300, *YYCURSOR);
    4026        9593 :                 yych = *++YYCURSOR;
    4027        9593 :                 if (yych == 'E') goto yy301;
    4028           1 :                 if (yych != 'e') goto yy150;
    4029             : yy301:
    4030             :                 YYDEBUG(301, *YYCURSOR);
    4031        9593 :                 yych = *++YYCURSOR;
    4032        9593 :                 if (yych != '_') goto yy150;
    4033             :                 YYDEBUG(302, *YYCURSOR);
    4034        9593 :                 yych = *++YYCURSOR;
    4035        9593 :                 if (yych != '_') goto yy150;
    4036             :                 YYDEBUG(303, *YYCURSOR);
    4037        9593 :                 ++YYCURSOR;
    4038        9593 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4039           0 :                         goto yy149;
    4040             :                 }
    4041             :                 YYDEBUG(304, *YYCURSOR);
    4042        9593 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4043             : #line 1753 "Zend/zend_language_scanner.l"
    4044             :                 {
    4045             :         RETURN_TOKEN(T_FILE);
    4046             : }
    4047             : #line 4048 "Zend/zend_language_scanner.c"
    4048             : yy305:
    4049             :                 YYDEBUG(305, *YYCURSOR);
    4050          11 :                 yych = *++YYCURSOR;
    4051          11 :                 if (yych == 'A') goto yy306;
    4052           0 :                 if (yych != 'a') goto yy150;
    4053             : yy306:
    4054             :                 YYDEBUG(306, *YYCURSOR);
    4055          11 :                 yych = *++YYCURSOR;
    4056          11 :                 if (yych == 'I') goto yy307;
    4057           0 :                 if (yych != 'i') goto yy150;
    4058             : yy307:
    4059             :                 YYDEBUG(307, *YYCURSOR);
    4060          11 :                 yych = *++YYCURSOR;
    4061          11 :                 if (yych == 'T') goto yy308;
    4062           0 :                 if (yych != 't') goto yy150;
    4063             : yy308:
    4064             :                 YYDEBUG(308, *YYCURSOR);
    4065          11 :                 yych = *++YYCURSOR;
    4066          11 :                 if (yych != '_') goto yy150;
    4067             :                 YYDEBUG(309, *YYCURSOR);
    4068          11 :                 yych = *++YYCURSOR;
    4069          11 :                 if (yych != '_') goto yy150;
    4070             :                 YYDEBUG(310, *YYCURSOR);
    4071          11 :                 ++YYCURSOR;
    4072          11 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4073           0 :                         goto yy149;
    4074             :                 }
    4075             :                 YYDEBUG(311, *YYCURSOR);
    4076          11 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4077             : #line 1737 "Zend/zend_language_scanner.l"
    4078             :                 {
    4079             :         RETURN_TOKEN(T_TRAIT_C);
    4080             : }
    4081             : #line 4082 "Zend/zend_language_scanner.c"
    4082             : yy312:
    4083             :                 YYDEBUG(312, *YYCURSOR);
    4084         132 :                 yych = *++YYCURSOR;
    4085         132 :                 if (yych == 'A') goto yy313;
    4086          31 :                 if (yych != 'a') goto yy150;
    4087             : yy313:
    4088             :                 YYDEBUG(313, *YYCURSOR);
    4089         102 :                 yych = *++YYCURSOR;
    4090         102 :                 if (yych == 'S') goto yy314;
    4091           1 :                 if (yych != 's') goto yy150;
    4092             : yy314:
    4093             :                 YYDEBUG(314, *YYCURSOR);
    4094         102 :                 yych = *++YYCURSOR;
    4095         102 :                 if (yych == 'S') goto yy315;
    4096           1 :                 if (yych != 's') goto yy150;
    4097             : yy315:
    4098             :                 YYDEBUG(315, *YYCURSOR);
    4099         102 :                 yych = *++YYCURSOR;
    4100         102 :                 if (yych != '_') goto yy150;
    4101             :                 YYDEBUG(316, *YYCURSOR);
    4102         102 :                 yych = *++YYCURSOR;
    4103         102 :                 if (yych != '_') goto yy150;
    4104             :                 YYDEBUG(317, *YYCURSOR);
    4105         102 :                 ++YYCURSOR;
    4106         102 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4107           0 :                         goto yy149;
    4108             :                 }
    4109             :                 YYDEBUG(318, *YYCURSOR);
    4110         102 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4111             : #line 1733 "Zend/zend_language_scanner.l"
    4112             :                 {
    4113             :         RETURN_TOKEN(T_CLASS_C);
    4114             : }
    4115             : #line 4116 "Zend/zend_language_scanner.c"
    4116             : yy319:
    4117             :                 YYDEBUG(319, *YYCURSOR);
    4118         289 :                 yych = *++YYCURSOR;
    4119         289 :                 if (yych == 'L') goto yy320;
    4120          36 :                 if (yych != 'l') goto yy150;
    4121             : yy320:
    4122             :                 YYDEBUG(320, *YYCURSOR);
    4123         289 :                 yych = *++YYCURSOR;
    4124         289 :                 if (yych == 'T') goto yy321;
    4125          36 :                 if (yych != 't') goto yy150;
    4126             : yy321:
    4127             :                 YYDEBUG(321, *YYCURSOR);
    4128         289 :                 yych = *++YYCURSOR;
    4129         289 :                 if (yych != '_') goto yy150;
    4130             :                 YYDEBUG(322, *YYCURSOR);
    4131         289 :                 yych = *++YYCURSOR;
    4132         289 :                 if (yych == 'C') goto yy323;
    4133          36 :                 if (yych != 'c') goto yy150;
    4134             : yy323:
    4135             :                 YYDEBUG(323, *YYCURSOR);
    4136         289 :                 yych = *++YYCURSOR;
    4137         289 :                 if (yych == 'O') goto yy324;
    4138          36 :                 if (yych != 'o') goto yy150;
    4139             : yy324:
    4140             :                 YYDEBUG(324, *YYCURSOR);
    4141         289 :                 yych = *++YYCURSOR;
    4142         289 :                 if (yych == 'M') goto yy325;
    4143          36 :                 if (yych != 'm') goto yy150;
    4144             : yy325:
    4145             :                 YYDEBUG(325, *YYCURSOR);
    4146         289 :                 yych = *++YYCURSOR;
    4147         289 :                 if (yych == 'P') goto yy326;
    4148          36 :                 if (yych != 'p') goto yy150;
    4149             : yy326:
    4150             :                 YYDEBUG(326, *YYCURSOR);
    4151         289 :                 yych = *++YYCURSOR;
    4152         289 :                 if (yych == 'I') goto yy327;
    4153          36 :                 if (yych != 'i') goto yy150;
    4154             : yy327:
    4155             :                 YYDEBUG(327, *YYCURSOR);
    4156         289 :                 yych = *++YYCURSOR;
    4157         289 :                 if (yych == 'L') goto yy328;
    4158          36 :                 if (yych != 'l') goto yy150;
    4159             : yy328:
    4160             :                 YYDEBUG(328, *YYCURSOR);
    4161         289 :                 yych = *++YYCURSOR;
    4162         289 :                 if (yych == 'E') goto yy329;
    4163          36 :                 if (yych != 'e') goto yy150;
    4164             : yy329:
    4165             :                 YYDEBUG(329, *YYCURSOR);
    4166         289 :                 yych = *++YYCURSOR;
    4167         289 :                 if (yych == 'R') goto yy330;
    4168          36 :                 if (yych != 'r') goto yy150;
    4169             : yy330:
    4170             :                 YYDEBUG(330, *YYCURSOR);
    4171         289 :                 ++YYCURSOR;
    4172         289 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4173           0 :                         goto yy149;
    4174             :                 }
    4175             :                 YYDEBUG(331, *YYCURSOR);
    4176         289 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4177             : #line 1396 "Zend/zend_language_scanner.l"
    4178             :                 {
    4179             :         RETURN_TOKEN(T_HALT_COMPILER);
    4180             : }
    4181             : #line 4182 "Zend/zend_language_scanner.c"
    4182             : yy332:
    4183             :                 YYDEBUG(332, *YYCURSOR);
    4184        8640 :                 yych = *++YYCURSOR;
    4185        8640 :                 if (yych == 'S') goto yy336;
    4186        8638 :                 if (yych == 's') goto yy336;
    4187        5504 :                 goto yy150;
    4188             : yy333:
    4189             :                 YYDEBUG(333, *YYCURSOR);
    4190         847 :                 yych = *++YYCURSOR;
    4191         847 :                 if (yych == 'E') goto yy334;
    4192         827 :                 if (yych != 'e') goto yy150;
    4193             : yy334:
    4194             :                 YYDEBUG(334, *YYCURSOR);
    4195         677 :                 ++YYCURSOR;
    4196         677 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4197         149 :                         goto yy149;
    4198             :                 }
    4199             :                 YYDEBUG(335, *YYCURSOR);
    4200         528 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4201             : #line 1376 "Zend/zend_language_scanner.l"
    4202             :                 {
    4203             :         RETURN_TOKEN(T_USE);
    4204             : }
    4205             : #line 4206 "Zend/zend_language_scanner.c"
    4206             : yy336:
    4207             :                 YYDEBUG(336, *YYCURSOR);
    4208        3136 :                 yych = *++YYCURSOR;
    4209        3136 :                 if (yych == 'E') goto yy337;
    4210        3134 :                 if (yych != 'e') goto yy150;
    4211             : yy337:
    4212             :                 YYDEBUG(337, *YYCURSOR);
    4213        3136 :                 yych = *++YYCURSOR;
    4214        3136 :                 if (yych == 'T') goto yy338;
    4215        3134 :                 if (yych != 't') goto yy150;
    4216             : yy338:
    4217             :                 YYDEBUG(338, *YYCURSOR);
    4218        1550 :                 ++YYCURSOR;
    4219        1550 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4220          17 :                         goto yy149;
    4221             :                 }
    4222             :                 YYDEBUG(339, *YYCURSOR);
    4223        1533 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4224             : #line 1424 "Zend/zend_language_scanner.l"
    4225             :                 {
    4226             :         RETURN_TOKEN(T_UNSET);
    4227             : }
    4228             : #line 4229 "Zend/zend_language_scanner.c"
    4229             : yy340:
    4230             :                 YYDEBUG(340, *YYCURSOR);
    4231       39355 :                 ++YYCURSOR;
    4232       39355 :                 YYFILL(7);
    4233       39355 :                 yych = *YYCURSOR;
    4234             : yy341:
    4235             :                 YYDEBUG(341, *YYCURSOR);
    4236      126564 :                 if (yych <= 'S') {
    4237       72429 :                         if (yych <= 'D') {
    4238       71148 :                                 if (yych <= ' ') {
    4239       39450 :                                         if (yych == '\t') goto yy340;
    4240       39444 :                                         if (yych <= 0x1F) goto yy157;
    4241       39349 :                                         goto yy340;
    4242             :                                 } else {
    4243       31698 :                                         if (yych <= 'A') {
    4244       31460 :                                                 if (yych <= '@') goto yy157;
    4245        1249 :                                                 goto yy345;
    4246             :                                         } else {
    4247         238 :                                                 if (yych <= 'B') goto yy343;
    4248         185 :                                                 if (yych <= 'C') goto yy157;
    4249         184 :                                                 goto yy348;
    4250             :                                         }
    4251             :                                 }
    4252             :                         } else {
    4253        1281 :                                 if (yych <= 'I') {
    4254         737 :                                         if (yych == 'F') goto yy349;
    4255         474 :                                         if (yych <= 'H') goto yy157;
    4256         463 :                                         goto yy350;
    4257             :                                 } else {
    4258         544 :                                         if (yych <= 'O') {
    4259          99 :                                                 if (yych <= 'N') goto yy157;
    4260          43 :                                                 goto yy344;
    4261             :                                         } else {
    4262         445 :                                                 if (yych <= 'Q') goto yy157;
    4263         444 :                                                 if (yych <= 'R') goto yy347;
    4264         288 :                                                 goto yy346;
    4265             :                                         }
    4266             :                                 }
    4267             :                         }
    4268             :                 } else {
    4269       54135 :                         if (yych <= 'f') {
    4270       24738 :                                 if (yych <= 'a') {
    4271        3787 :                                         if (yych == 'U') goto yy342;
    4272        3755 :                                         if (yych <= '`') goto yy157;
    4273        3713 :                                         goto yy345;
    4274             :                                 } else {
    4275       20951 :                                         if (yych <= 'c') {
    4276        2379 :                                                 if (yych <= 'b') goto yy343;
    4277         477 :                                                 goto yy157;
    4278             :                                         } else {
    4279       18572 :                                                 if (yych <= 'd') goto yy348;
    4280       10422 :                                                 if (yych <= 'e') goto yy157;
    4281       10269 :                                                 goto yy349;
    4282             :                                         }
    4283             :                                 }
    4284             :                         } else {
    4285       29397 :                                 if (yych <= 'q') {
    4286       15940 :                                         if (yych <= 'i') {
    4287       14076 :                                                 if (yych <= 'h') goto yy157;
    4288       13715 :                                                 goto yy350;
    4289             :                                         } else {
    4290        1864 :                                                 if (yych == 'o') goto yy344;
    4291         671 :                                                 goto yy157;
    4292             :                                         }
    4293             :                                 } else {
    4294       13457 :                                         if (yych <= 's') {
    4295       11188 :                                                 if (yych <= 'r') goto yy347;
    4296        9237 :                                                 goto yy346;
    4297             :                                         } else {
    4298        2269 :                                                 if (yych != 'u') goto yy157;
    4299             :                                         }
    4300             :                                 }
    4301             :                         }
    4302             :                 }
    4303             : yy342:
    4304             :                 YYDEBUG(342, *YYCURSOR);
    4305        1927 :                 yych = *++YYCURSOR;
    4306        1927 :                 if (yych == 'N') goto yy409;
    4307        1927 :                 if (yych == 'n') goto yy409;
    4308         174 :                 goto yy157;
    4309             : yy343:
    4310             :                 YYDEBUG(343, *YYCURSOR);
    4311        1955 :                 yych = *++YYCURSOR;
    4312        1955 :                 if (yych <= 'O') {
    4313         178 :                         if (yych == 'I') goto yy396;
    4314         178 :                         if (yych <= 'N') goto yy157;
    4315           3 :                         goto yy397;
    4316             :                 } else {
    4317        1777 :                         if (yych <= 'i') {
    4318        1600 :                                 if (yych <= 'h') goto yy157;
    4319        1351 :                                 goto yy396;
    4320             :                         } else {
    4321         177 :                                 if (yych == 'o') goto yy397;
    4322          81 :                                 goto yy157;
    4323             :                         }
    4324             :                 }
    4325             : yy344:
    4326             :                 YYDEBUG(344, *YYCURSOR);
    4327        1236 :                 yych = *++YYCURSOR;
    4328        1236 :                 if (yych == 'B') goto yy388;
    4329        1236 :                 if (yych == 'b') goto yy388;
    4330         944 :                 goto yy157;
    4331             : yy345:
    4332             :                 YYDEBUG(345, *YYCURSOR);
    4333        4962 :                 yych = *++YYCURSOR;
    4334        4962 :                 if (yych == 'R') goto yy381;
    4335        4962 :                 if (yych == 'r') goto yy381;
    4336         485 :                 goto yy157;
    4337             : yy346:
    4338             :                 YYDEBUG(346, *YYCURSOR);
    4339        9525 :                 yych = *++YYCURSOR;
    4340        9525 :                 if (yych == 'T') goto yy373;
    4341        9449 :                 if (yych == 't') goto yy373;
    4342        4969 :                 goto yy157;
    4343             : yy347:
    4344             :                 YYDEBUG(347, *YYCURSOR);
    4345        2107 :                 yych = *++YYCURSOR;
    4346        2107 :                 if (yych == 'E') goto yy371;
    4347        2097 :                 if (yych == 'e') goto yy371;
    4348        1772 :                 goto yy157;
    4349             : yy348:
    4350             :                 YYDEBUG(348, *YYCURSOR);
    4351        8334 :                 yych = *++YYCURSOR;
    4352        8334 :                 if (yych == 'O') goto yy367;
    4353        8314 :                 if (yych == 'o') goto yy367;
    4354        8290 :                 goto yy157;
    4355             : yy349:
    4356             :                 YYDEBUG(349, *YYCURSOR);
    4357       10532 :                 yych = *++YYCURSOR;
    4358       10532 :                 if (yych == 'L') goto yy360;
    4359       10532 :                 if (yych == 'l') goto yy360;
    4360       10426 :                 goto yy157;
    4361             : yy350:
    4362             :                 YYDEBUG(350, *YYCURSOR);
    4363       14178 :                 yych = *++YYCURSOR;
    4364       14178 :                 if (yych == 'N') goto yy351;
    4365       13892 :                 if (yych != 'n') goto yy157;
    4366             : yy351:
    4367             :                 YYDEBUG(351, *YYCURSOR);
    4368        6917 :                 yych = *++YYCURSOR;
    4369        6917 :                 if (yych == 'T') goto yy352;
    4370        6705 :                 if (yych != 't') goto yy157;
    4371             : yy352:
    4372             :                 YYDEBUG(352, *YYCURSOR);
    4373        5433 :                 yych = *++YYCURSOR;
    4374        5433 :                 if (yych == 'E') goto yy353;
    4375        5433 :                 if (yych != 'e') goto yy355;
    4376             : yy353:
    4377             :                 YYDEBUG(353, *YYCURSOR);
    4378          32 :                 yych = *++YYCURSOR;
    4379          32 :                 if (yych == 'G') goto yy358;
    4380          32 :                 if (yych == 'g') goto yy358;
    4381          28 :                 goto yy157;
    4382             : yy354:
    4383             :                 YYDEBUG(354, *YYCURSOR);
    4384          35 :                 ++YYCURSOR;
    4385          35 :                 YYFILL(1);
    4386          35 :                 yych = *YYCURSOR;
    4387             : yy355:
    4388             :                 YYDEBUG(355, *YYCURSOR);
    4389        5436 :                 if (yych <= 0x1F) {
    4390           0 :                         if (yych == '\t') goto yy354;
    4391           0 :                         goto yy157;
    4392             :                 } else {
    4393        5436 :                         if (yych <= ' ') goto yy354;
    4394        5405 :                         if (yych != ')') goto yy157;
    4395             :                 }
    4396             :                 YYDEBUG(356, *YYCURSOR);
    4397        4878 :                 ++YYCURSOR;
    4398             :                 YYDEBUG(357, *YYCURSOR);
    4399        4878 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4400             : #line 1324 "Zend/zend_language_scanner.l"
    4401             :                 {
    4402             :         RETURN_TOKEN(T_INT_CAST);
    4403             : }
    4404             : #line 4405 "Zend/zend_language_scanner.c"
    4405             : yy358:
    4406             :                 YYDEBUG(358, *YYCURSOR);
    4407           4 :                 yych = *++YYCURSOR;
    4408           4 :                 if (yych == 'E') goto yy359;
    4409           4 :                 if (yych != 'e') goto yy157;
    4410             : yy359:
    4411             :                 YYDEBUG(359, *YYCURSOR);
    4412           4 :                 yych = *++YYCURSOR;
    4413           4 :                 if (yych == 'R') goto yy354;
    4414           4 :                 if (yych == 'r') goto yy354;
    4415           0 :                 goto yy157;
    4416             : yy360:
    4417             :                 YYDEBUG(360, *YYCURSOR);
    4418         106 :                 yych = *++YYCURSOR;
    4419         106 :                 if (yych == 'O') goto yy361;
    4420         106 :                 if (yych != 'o') goto yy157;
    4421             : yy361:
    4422             :                 YYDEBUG(361, *YYCURSOR);
    4423         103 :                 yych = *++YYCURSOR;
    4424         103 :                 if (yych == 'A') goto yy362;
    4425         103 :                 if (yych != 'a') goto yy157;
    4426             : yy362:
    4427             :                 YYDEBUG(362, *YYCURSOR);
    4428          58 :                 yych = *++YYCURSOR;
    4429          58 :                 if (yych == 'T') goto yy363;
    4430          58 :                 if (yych != 't') goto yy157;
    4431             : yy363:
    4432             :                 YYDEBUG(363, *YYCURSOR);
    4433         130 :                 ++YYCURSOR;
    4434         130 :                 YYFILL(1);
    4435         130 :                 yych = *YYCURSOR;
    4436             :                 YYDEBUG(364, *YYCURSOR);
    4437         130 :                 if (yych <= 0x1F) {
    4438           0 :                         if (yych == '\t') goto yy363;
    4439           0 :                         goto yy157;
    4440             :                 } else {
    4441         130 :                         if (yych <= ' ') goto yy363;
    4442         117 :                         if (yych != ')') goto yy157;
    4443             :                 }
    4444             :                 YYDEBUG(365, *YYCURSOR);
    4445          42 :                 ++YYCURSOR;
    4446             :                 YYDEBUG(366, *YYCURSOR);
    4447          42 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4448             : #line 1328 "Zend/zend_language_scanner.l"
    4449             :                 {
    4450             :         RETURN_TOKEN(T_DOUBLE_CAST);
    4451             : }
    4452             : #line 4453 "Zend/zend_language_scanner.c"
    4453             : yy367:
    4454             :                 YYDEBUG(367, *YYCURSOR);
    4455          44 :                 yych = *++YYCURSOR;
    4456          44 :                 if (yych == 'U') goto yy368;
    4457          44 :                 if (yych != 'u') goto yy157;
    4458             : yy368:
    4459             :                 YYDEBUG(368, *YYCURSOR);
    4460          14 :                 yych = *++YYCURSOR;
    4461          14 :                 if (yych == 'B') goto yy369;
    4462          14 :                 if (yych != 'b') goto yy157;
    4463             : yy369:
    4464             :                 YYDEBUG(369, *YYCURSOR);
    4465          14 :                 yych = *++YYCURSOR;
    4466          14 :                 if (yych == 'L') goto yy370;
    4467          14 :                 if (yych != 'l') goto yy157;
    4468             : yy370:
    4469             :                 YYDEBUG(370, *YYCURSOR);
    4470          14 :                 yych = *++YYCURSOR;
    4471          14 :                 if (yych == 'E') goto yy363;
    4472          14 :                 if (yych == 'e') goto yy363;
    4473           0 :                 goto yy157;
    4474             : yy371:
    4475             :                 YYDEBUG(371, *YYCURSOR);
    4476         335 :                 yych = *++YYCURSOR;
    4477         335 :                 if (yych == 'A') goto yy372;
    4478         325 :                 if (yych != 'a') goto yy157;
    4479             : yy372:
    4480             :                 YYDEBUG(372, *YYCURSOR);
    4481         161 :                 yych = *++YYCURSOR;
    4482         161 :                 if (yych == 'L') goto yy363;
    4483         161 :                 if (yych == 'l') goto yy363;
    4484         116 :                 goto yy157;
    4485             : yy373:
    4486             :                 YYDEBUG(373, *YYCURSOR);
    4487        4556 :                 yych = *++YYCURSOR;
    4488        4556 :                 if (yych == 'R') goto yy374;
    4489        4551 :                 if (yych != 'r') goto yy157;
    4490             : yy374:
    4491             :                 YYDEBUG(374, *YYCURSOR);
    4492        4441 :                 yych = *++YYCURSOR;
    4493        4441 :                 if (yych == 'I') goto yy375;
    4494        4441 :                 if (yych != 'i') goto yy157;
    4495             : yy375:
    4496             :                 YYDEBUG(375, *YYCURSOR);
    4497         753 :                 yych = *++YYCURSOR;
    4498         753 :                 if (yych == 'N') goto yy376;
    4499         753 :                 if (yych != 'n') goto yy157;
    4500             : yy376:
    4501             :                 YYDEBUG(376, *YYCURSOR);
    4502         453 :                 yych = *++YYCURSOR;
    4503         453 :                 if (yych == 'G') goto yy377;
    4504         453 :                 if (yych != 'g') goto yy157;
    4505             : yy377:
    4506             :                 YYDEBUG(377, *YYCURSOR);
    4507        1364 :                 ++YYCURSOR;
    4508        1364 :                 YYFILL(1);
    4509        1364 :                 yych = *YYCURSOR;
    4510             :                 YYDEBUG(378, *YYCURSOR);
    4511        1364 :                 if (yych <= 0x1F) {
    4512           0 :                         if (yych == '\t') goto yy377;
    4513           0 :                         goto yy157;
    4514             :                 } else {
    4515        1364 :                         if (yych <= ' ') goto yy377;
    4516        1353 :                         if (yych != ')') goto yy157;
    4517             :                 }
    4518             :                 YYDEBUG(379, *YYCURSOR);
    4519        1340 :                 ++YYCURSOR;
    4520             :                 YYDEBUG(380, *YYCURSOR);
    4521        1340 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4522             : #line 1332 "Zend/zend_language_scanner.l"
    4523             :                 {
    4524             :         RETURN_TOKEN(T_STRING_CAST);
    4525             : }
    4526             : #line 4527 "Zend/zend_language_scanner.c"
    4527             : yy381:
    4528             :                 YYDEBUG(381, *YYCURSOR);
    4529        4477 :                 yych = *++YYCURSOR;
    4530        4477 :                 if (yych == 'R') goto yy382;
    4531        4477 :                 if (yych != 'r') goto yy157;
    4532             : yy382:
    4533             :                 YYDEBUG(382, *YYCURSOR);
    4534        4422 :                 yych = *++YYCURSOR;
    4535        4422 :                 if (yych == 'A') goto yy383;
    4536        4422 :                 if (yych != 'a') goto yy157;
    4537             : yy383:
    4538             :                 YYDEBUG(383, *YYCURSOR);
    4539        4422 :                 yych = *++YYCURSOR;
    4540        4422 :                 if (yych == 'Y') goto yy384;
    4541        4422 :                 if (yych != 'y') goto yy157;
    4542             : yy384:
    4543             :                 YYDEBUG(384, *YYCURSOR);
    4544        4632 :                 ++YYCURSOR;
    4545        4632 :                 YYFILL(1);
    4546        4632 :                 yych = *YYCURSOR;
    4547             :                 YYDEBUG(385, *YYCURSOR);
    4548        4632 :                 if (yych <= 0x1F) {
    4549           0 :                         if (yych == '\t') goto yy384;
    4550           0 :                         goto yy157;
    4551             :                 } else {
    4552        4632 :                         if (yych <= ' ') goto yy384;
    4553        4422 :                         if (yych != ')') goto yy157;
    4554             :                 }
    4555             :                 YYDEBUG(386, *YYCURSOR);
    4556          30 :                 ++YYCURSOR;
    4557             :                 YYDEBUG(387, *YYCURSOR);
    4558          30 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4559             : #line 1336 "Zend/zend_language_scanner.l"
    4560             :                 {
    4561             :         RETURN_TOKEN(T_ARRAY_CAST);
    4562             : }
    4563             : #line 4564 "Zend/zend_language_scanner.c"
    4564             : yy388:
    4565             :                 YYDEBUG(388, *YYCURSOR);
    4566         292 :                 yych = *++YYCURSOR;
    4567         292 :                 if (yych == 'J') goto yy389;
    4568         292 :                 if (yych != 'j') goto yy157;
    4569             : yy389:
    4570             :                 YYDEBUG(389, *YYCURSOR);
    4571         177 :                 yych = *++YYCURSOR;
    4572         177 :                 if (yych == 'E') goto yy390;
    4573         177 :                 if (yych != 'e') goto yy157;
    4574             : yy390:
    4575             :                 YYDEBUG(390, *YYCURSOR);
    4576         177 :                 yych = *++YYCURSOR;
    4577         177 :                 if (yych == 'C') goto yy391;
    4578         177 :                 if (yych != 'c') goto yy157;
    4579             : yy391:
    4580             :                 YYDEBUG(391, *YYCURSOR);
    4581         177 :                 yych = *++YYCURSOR;
    4582         177 :                 if (yych == 'T') goto yy392;
    4583         177 :                 if (yych != 't') goto yy157;
    4584             : yy392:
    4585             :                 YYDEBUG(392, *YYCURSOR);
    4586         177 :                 ++YYCURSOR;
    4587         177 :                 YYFILL(1);
    4588         177 :                 yych = *YYCURSOR;
    4589             :                 YYDEBUG(393, *YYCURSOR);
    4590         177 :                 if (yych <= 0x1F) {
    4591           0 :                         if (yych == '\t') goto yy392;
    4592           0 :                         goto yy157;
    4593             :                 } else {
    4594         177 :                         if (yych <= ' ') goto yy392;
    4595         177 :                         if (yych != ')') goto yy157;
    4596             :                 }
    4597             :                 YYDEBUG(394, *YYCURSOR);
    4598         174 :                 ++YYCURSOR;
    4599             :                 YYDEBUG(395, *YYCURSOR);
    4600         174 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4601             : #line 1340 "Zend/zend_language_scanner.l"
    4602             :                 {
    4603             :         RETURN_TOKEN(T_OBJECT_CAST);
    4604             : }
    4605             : #line 4606 "Zend/zend_language_scanner.c"
    4606             : yy396:
    4607             :                 YYDEBUG(396, *YYCURSOR);
    4608        1351 :                 yych = *++YYCURSOR;
    4609        1351 :                 if (yych == 'N') goto yy406;
    4610        1351 :                 if (yych == 'n') goto yy406;
    4611           0 :                 goto yy157;
    4612             : yy397:
    4613             :                 YYDEBUG(397, *YYCURSOR);
    4614          99 :                 yych = *++YYCURSOR;
    4615          99 :                 if (yych == 'O') goto yy398;
    4616          99 :                 if (yych != 'o') goto yy157;
    4617             : yy398:
    4618             :                 YYDEBUG(398, *YYCURSOR);
    4619          96 :                 yych = *++YYCURSOR;
    4620          96 :                 if (yych == 'L') goto yy399;
    4621          96 :                 if (yych != 'l') goto yy157;
    4622             : yy399:
    4623             :                 YYDEBUG(399, *YYCURSOR);
    4624          94 :                 yych = *++YYCURSOR;
    4625          94 :                 if (yych == 'E') goto yy404;
    4626          94 :                 if (yych == 'e') goto yy404;
    4627          93 :                 goto yy401;
    4628             : yy400:
    4629             :                 YYDEBUG(400, *YYCURSOR);
    4630          10 :                 ++YYCURSOR;
    4631          10 :                 YYFILL(1);
    4632          10 :                 yych = *YYCURSOR;
    4633             : yy401:
    4634             :                 YYDEBUG(401, *YYCURSOR);
    4635         103 :                 if (yych <= 0x1F) {
    4636           0 :                         if (yych == '\t') goto yy400;
    4637           0 :                         goto yy157;
    4638             :                 } else {
    4639         103 :                         if (yych <= ' ') goto yy400;
    4640          94 :                         if (yych != ')') goto yy157;
    4641             :                 }
    4642             :                 YYDEBUG(402, *YYCURSOR);
    4643          74 :                 ++YYCURSOR;
    4644             :                 YYDEBUG(403, *YYCURSOR);
    4645          74 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4646             : #line 1344 "Zend/zend_language_scanner.l"
    4647             :                 {
    4648             :         RETURN_TOKEN(T_BOOL_CAST);
    4649             : }
    4650             : #line 4651 "Zend/zend_language_scanner.c"
    4651             : yy404:
    4652             :                 YYDEBUG(404, *YYCURSOR);
    4653           1 :                 yych = *++YYCURSOR;
    4654           1 :                 if (yych == 'A') goto yy405;
    4655           1 :                 if (yych != 'a') goto yy157;
    4656             : yy405:
    4657             :                 YYDEBUG(405, *YYCURSOR);
    4658           1 :                 yych = *++YYCURSOR;
    4659           1 :                 if (yych == 'N') goto yy400;
    4660           1 :                 if (yych == 'n') goto yy400;
    4661           0 :                 goto yy157;
    4662             : yy406:
    4663             :                 YYDEBUG(406, *YYCURSOR);
    4664        1351 :                 yych = *++YYCURSOR;
    4665        1351 :                 if (yych == 'A') goto yy407;
    4666        1351 :                 if (yych != 'a') goto yy157;
    4667             : yy407:
    4668             :                 YYDEBUG(407, *YYCURSOR);
    4669         900 :                 yych = *++YYCURSOR;
    4670         900 :                 if (yych == 'R') goto yy408;
    4671         900 :                 if (yych != 'r') goto yy157;
    4672             : yy408:
    4673             :                 YYDEBUG(408, *YYCURSOR);
    4674         900 :                 yych = *++YYCURSOR;
    4675         900 :                 if (yych == 'Y') goto yy377;
    4676         900 :                 if (yych == 'y') goto yy377;
    4677           0 :                 goto yy157;
    4678             : yy409:
    4679             :                 YYDEBUG(409, *YYCURSOR);
    4680        1753 :                 yych = *++YYCURSOR;
    4681        1753 :                 if (yych == 'S') goto yy410;
    4682        1753 :                 if (yych != 's') goto yy157;
    4683             : yy410:
    4684             :                 YYDEBUG(410, *YYCURSOR);
    4685          95 :                 yych = *++YYCURSOR;
    4686          95 :                 if (yych == 'E') goto yy411;
    4687          95 :                 if (yych != 'e') goto yy157;
    4688             : yy411:
    4689             :                 YYDEBUG(411, *YYCURSOR);
    4690          95 :                 yych = *++YYCURSOR;
    4691          95 :                 if (yych == 'T') goto yy412;
    4692          95 :                 if (yych != 't') goto yy157;
    4693             : yy412:
    4694             :                 YYDEBUG(412, *YYCURSOR);
    4695           1 :                 ++YYCURSOR;
    4696           1 :                 YYFILL(1);
    4697           1 :                 yych = *YYCURSOR;
    4698             :                 YYDEBUG(413, *YYCURSOR);
    4699           1 :                 if (yych <= 0x1F) {
    4700           0 :                         if (yych == '\t') goto yy412;
    4701           0 :                         goto yy157;
    4702             :                 } else {
    4703           1 :                         if (yych <= ' ') goto yy412;
    4704           1 :                         if (yych != ')') goto yy157;
    4705             :                 }
    4706             :                 YYDEBUG(414, *YYCURSOR);
    4707           1 :                 ++YYCURSOR;
    4708             :                 YYDEBUG(415, *YYCURSOR);
    4709           1 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4710             : #line 1348 "Zend/zend_language_scanner.l"
    4711             :                 {
    4712             :         RETURN_TOKEN(T_UNSET_CAST);
    4713             : }
    4714             : #line 4715 "Zend/zend_language_scanner.c"
    4715             : yy416:
    4716             :                 YYDEBUG(416, *YYCURSOR);
    4717       34171 :                 yych = *++YYCURSOR;
    4718       34171 :                 if (yych == 'R') goto yy417;
    4719       34165 :                 if (yych != 'r') goto yy150;
    4720             : yy417:
    4721             :                 YYDEBUG(417, *YYCURSOR);
    4722       33922 :                 ++YYCURSOR;
    4723       33922 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4724       33718 :                         goto yy149;
    4725             :                 }
    4726             :                 YYDEBUG(418, *YYCURSOR);
    4727         204 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4728             : #line 1320 "Zend/zend_language_scanner.l"
    4729             :                 {
    4730             :         RETURN_TOKEN(T_VAR);
    4731             : }
    4732             : #line 4733 "Zend/zend_language_scanner.c"
    4733             : yy419:
    4734             :                 YYDEBUG(419, *YYCURSOR);
    4735         404 :                 yych = *++YYCURSOR;
    4736         404 :                 if (yych == 'M') goto yy423;
    4737         382 :                 if (yych == 'm') goto yy423;
    4738          37 :                 goto yy150;
    4739             : yy420:
    4740             :                 YYDEBUG(420, *YYCURSOR);
    4741       15355 :                 yych = *++YYCURSOR;
    4742       15355 :                 if (yych == 'W') goto yy421;
    4743       15353 :                 if (yych != 'w') goto yy150;
    4744             : yy421:
    4745             :                 YYDEBUG(421, *YYCURSOR);
    4746       15181 :                 ++YYCURSOR;
    4747       15181 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4748          28 :                         goto yy149;
    4749             :                 }
    4750             :                 YYDEBUG(422, *YYCURSOR);
    4751       15153 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4752             : #line 1312 "Zend/zend_language_scanner.l"
    4753             :                 {
    4754             :         RETURN_TOKEN(T_NEW);
    4755             : }
    4756             : #line 4757 "Zend/zend_language_scanner.c"
    4757             : yy423:
    4758             :                 YYDEBUG(423, *YYCURSOR);
    4759         367 :                 yych = *++YYCURSOR;
    4760         367 :                 if (yych == 'E') goto yy424;
    4761         345 :                 if (yych != 'e') goto yy150;
    4762             : yy424:
    4763             :                 YYDEBUG(424, *YYCURSOR);
    4764         367 :                 yych = *++YYCURSOR;
    4765         367 :                 if (yych == 'S') goto yy425;
    4766         365 :                 if (yych != 's') goto yy150;
    4767             : yy425:
    4768             :                 YYDEBUG(425, *YYCURSOR);
    4769         333 :                 yych = *++YYCURSOR;
    4770         333 :                 if (yych == 'P') goto yy426;
    4771         331 :                 if (yych != 'p') goto yy150;
    4772             : yy426:
    4773             :                 YYDEBUG(426, *YYCURSOR);
    4774         328 :                 yych = *++YYCURSOR;
    4775         328 :                 if (yych == 'A') goto yy427;
    4776         326 :                 if (yych != 'a') goto yy150;
    4777             : yy427:
    4778             :                 YYDEBUG(427, *YYCURSOR);
    4779         328 :                 yych = *++YYCURSOR;
    4780         328 :                 if (yych == 'C') goto yy428;
    4781         326 :                 if (yych != 'c') goto yy150;
    4782             : yy428:
    4783             :                 YYDEBUG(428, *YYCURSOR);
    4784         328 :                 yych = *++YYCURSOR;
    4785         328 :                 if (yych == 'E') goto yy429;
    4786         326 :                 if (yych != 'e') goto yy150;
    4787             : yy429:
    4788             :                 YYDEBUG(429, *YYCURSOR);
    4789         328 :                 ++YYCURSOR;
    4790         328 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4791           2 :                         goto yy149;
    4792             :                 }
    4793             :                 YYDEBUG(430, *YYCURSOR);
    4794         326 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4795             : #line 1372 "Zend/zend_language_scanner.l"
    4796             :                 {
    4797             :         RETURN_TOKEN(T_NAMESPACE);
    4798             : }
    4799             : #line 4800 "Zend/zend_language_scanner.c"
    4800             : yy431:
    4801             :                 YYDEBUG(431, *YYCURSOR);
    4802       30227 :                 ++YYCURSOR;
    4803       30227 :                 if ((yych = *YYCURSOR) == '\n') goto yy435;
    4804        3072 :                 if (yych == '\r') goto yy436;
    4805             : yy432:
    4806             :                 YYDEBUG(432, *YYCURSOR);
    4807       30227 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4808             : #line 1944 "Zend/zend_language_scanner.l"
    4809             :                 {
    4810             :         BEGIN(INITIAL);
    4811             :         RETURN_TOKEN(T_CLOSE_TAG);  /* implicit ';' at php-end tag */
    4812             : }
    4813             : #line 4814 "Zend/zend_language_scanner.c"
    4814             : yy433:
    4815             :                 YYDEBUG(433, *YYCURSOR);
    4816          20 :                 ++YYCURSOR;
    4817             :                 YYDEBUG(434, *YYCURSOR);
    4818          20 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4819             : #line 1308 "Zend/zend_language_scanner.l"
    4820             :                 {
    4821             :         RETURN_TOKEN(T_COALESCE);
    4822             : }
    4823             : #line 4824 "Zend/zend_language_scanner.c"
    4824             : yy435:
    4825             :                 YYDEBUG(435, *YYCURSOR);
    4826       27352 :                 yych = *++YYCURSOR;
    4827       27352 :                 goto yy432;
    4828             : yy436:
    4829             :                 YYDEBUG(436, *YYCURSOR);
    4830         197 :                 yych = *++YYCURSOR;
    4831         197 :                 if (yych == '\n') goto yy435;
    4832           0 :                 goto yy432;
    4833             : yy437:
    4834             :                 YYDEBUG(437, *YYCURSOR);
    4835         942 :                 yyaccept = 3;
    4836         942 :                 YYMARKER = ++YYCURSOR;
    4837         942 :                 YYFILL(3);
    4838         942 :                 yych = *YYCURSOR;
    4839             :                 YYDEBUG(438, *YYCURSOR);
    4840         942 :                 if (yych <= 'D') {
    4841         868 :                         if (yych <= '/') goto yy153;
    4842         186 :                         if (yych <= '9') goto yy437;
    4843           0 :                         goto yy153;
    4844             :                 } else {
    4845          74 :                         if (yych <= 'E') goto yy156;
    4846          39 :                         if (yych == 'e') goto yy156;
    4847           0 :                         goto yy153;
    4848             :                 }
    4849             : yy439:
    4850             :                 YYDEBUG(439, *YYCURSOR);
    4851        3019 :                 ++YYCURSOR;
    4852             :                 YYDEBUG(440, *YYCURSOR);
    4853        3019 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4854             : #line 1504 "Zend/zend_language_scanner.l"
    4855             :                 {
    4856             :         RETURN_TOKEN(T_CONCAT_EQUAL);
    4857             : }
    4858             : #line 4859 "Zend/zend_language_scanner.c"
    4859             : yy441:
    4860             :                 YYDEBUG(441, *YYCURSOR);
    4861         111 :                 yych = *++YYCURSOR;
    4862         111 :                 if (yych != '.') goto yy157;
    4863             :                 YYDEBUG(442, *YYCURSOR);
    4864         111 :                 ++YYCURSOR;
    4865             :                 YYDEBUG(443, *YYCURSOR);
    4866         111 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4867             : #line 1304 "Zend/zend_language_scanner.l"
    4868             :                 {
    4869             :         RETURN_TOKEN(T_ELLIPSIS);
    4870             : }
    4871             : #line 4872 "Zend/zend_language_scanner.c"
    4872             : yy444:
    4873             :                 YYDEBUG(444, *YYCURSOR);
    4874       23005 :                 ++YYCURSOR;
    4875             :                 YYDEBUG(445, *YYCURSOR);
    4876       23005 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4877             : #line 1296 "Zend/zend_language_scanner.l"
    4878             :                 {
    4879             :         RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM);
    4880             : }
    4881             : #line 4882 "Zend/zend_language_scanner.c"
    4882             : yy446:
    4883             :                 YYDEBUG(446, *YYCURSOR);
    4884     2304349 :                 ++YYCURSOR;
    4885     2304349 :                 YYFILL(1);
    4886     2304349 :                 yych = *YYCURSOR;
    4887             : yy447:
    4888             :                 YYDEBUG(447, *YYCURSOR);
    4889     4632643 :                 if (yych <= '\f') {
    4890     1003670 :                         if (yych <= 0x08) goto yy104;
    4891     1001411 :                         if (yych <= '\n') goto yy446;
    4892           0 :                         goto yy104;
    4893             :                 } else {
    4894     3628973 :                         if (yych <= '\r') goto yy446;
    4895     3628107 :                         if (yych == ' ') goto yy446;
    4896     2326035 :                         goto yy104;
    4897             :                 }
    4898             : yy448:
    4899             :                 YYDEBUG(448, *YYCURSOR);
    4900         141 :                 ++YYCURSOR;
    4901             :                 YYDEBUG(449, *YYCURSOR);
    4902         141 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4903             : #line 1484 "Zend/zend_language_scanner.l"
    4904             :                 {
    4905             :         RETURN_TOKEN(T_MINUS_EQUAL);
    4906             : }
    4907             : #line 4908 "Zend/zend_language_scanner.c"
    4908             : yy450:
    4909             :                 YYDEBUG(450, *YYCURSOR);
    4910         109 :                 ++YYCURSOR;
    4911             :                 YYDEBUG(451, *YYCURSOR);
    4912         109 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4913             : #line 1448 "Zend/zend_language_scanner.l"
    4914             :                 {
    4915             :         RETURN_TOKEN(T_DEC);
    4916             : }
    4917             : #line 4918 "Zend/zend_language_scanner.c"
    4918             : yy452:
    4919             :                 YYDEBUG(452, *YYCURSOR);
    4920       48998 :                 ++YYCURSOR;
    4921             :                 YYDEBUG(453, *YYCURSOR);
    4922       48998 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4923             : #line 1270 "Zend/zend_language_scanner.l"
    4924             :                 {
    4925             :         yy_push_state(ST_LOOKING_FOR_PROPERTY);
    4926             :         RETURN_TOKEN(T_OBJECT_OPERATOR);
    4927             : }
    4928             : #line 4929 "Zend/zend_language_scanner.c"
    4929             : yy454:
    4930             :                 YYDEBUG(454, *YYCURSOR);
    4931       20246 :                 yych = *++YYCURSOR;
    4932       20246 :                 if (yych <= 'O') {
    4933         113 :                         if (yych == 'I') goto yy461;
    4934         106 :                         if (yych <= 'N') goto yy150;
    4935           4 :                         goto yy462;
    4936             :                 } else {
    4937       20133 :                         if (yych <= 'i') {
    4938       18853 :                                 if (yych <= 'h') goto yy150;
    4939       12897 :                                 goto yy461;
    4940             :                         } else {
    4941        1280 :                                 if (yych == 'o') goto yy462;
    4942           0 :                                 goto yy150;
    4943             :                         }
    4944             :                 }
    4945             : yy455:
    4946             :                 YYDEBUG(455, *YYCURSOR);
    4947        7987 :                 yych = *++YYCURSOR;
    4948        7987 :                 if (yych == 'B') goto yy456;
    4949        7984 :                 if (yych != 'b') goto yy150;
    4950             : yy456:
    4951             :                 YYDEBUG(456, *YYCURSOR);
    4952        4947 :                 yych = *++YYCURSOR;
    4953        4947 :                 if (yych == 'L') goto yy457;
    4954        4945 :                 if (yych != 'l') goto yy150;
    4955             : yy457:
    4956             :                 YYDEBUG(457, *YYCURSOR);
    4957        4919 :                 yych = *++YYCURSOR;
    4958        4919 :                 if (yych == 'I') goto yy458;
    4959        4917 :                 if (yych != 'i') goto yy150;
    4960             : yy458:
    4961             :                 YYDEBUG(458, *YYCURSOR);
    4962        4919 :                 yych = *++YYCURSOR;
    4963        4919 :                 if (yych == 'C') goto yy459;
    4964        4917 :                 if (yych != 'c') goto yy150;
    4965             : yy459:
    4966             :                 YYDEBUG(459, *YYCURSOR);
    4967        4918 :                 ++YYCURSOR;
    4968        4918 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    4969          15 :                         goto yy149;
    4970             :                 }
    4971             :                 YYDEBUG(460, *YYCURSOR);
    4972        4903 :                 yyleng = YYCURSOR - SCNG(yy_text);
    4973             : #line 1420 "Zend/zend_language_scanner.l"
    4974             :                 {
    4975             :         RETURN_TOKEN(T_PUBLIC);
    4976             : }
    4977             : #line 4978 "Zend/zend_language_scanner.c"
    4978             : yy461:
    4979             :                 YYDEBUG(461, *YYCURSOR);
    4980       12904 :                 yych = *++YYCURSOR;
    4981       12904 :                 if (yych <= 'V') {
    4982           7 :                         if (yych == 'N') goto yy470;
    4983           5 :                         if (yych <= 'U') goto yy150;
    4984           4 :                         goto yy471;
    4985             :                 } else {
    4986       12897 :                         if (yych <= 'n') {
    4987       11631 :                                 if (yych <= 'm') goto yy150;
    4988       11631 :                                 goto yy470;
    4989             :                         } else {
    4990        1266 :                                 if (yych == 'v') goto yy471;
    4991           0 :                                 goto yy150;
    4992             :                         }
    4993             :                 }
    4994             : yy462:
    4995             :                 YYDEBUG(462, *YYCURSOR);
    4996        1284 :                 yych = *++YYCURSOR;
    4997        1284 :                 if (yych == 'T') goto yy463;
    4998        1281 :                 if (yych != 't') goto yy150;
    4999             : yy463:
    5000             :                 YYDEBUG(463, *YYCURSOR);
    5001         662 :                 yych = *++YYCURSOR;
    5002         662 :                 if (yych == 'E') goto yy464;
    5003         660 :                 if (yych != 'e') goto yy150;
    5004             : yy464:
    5005             :                 YYDEBUG(464, *YYCURSOR);
    5006         631 :                 yych = *++YYCURSOR;
    5007         631 :                 if (yych == 'C') goto yy465;
    5008         629 :                 if (yych != 'c') goto yy150;
    5009             : yy465:
    5010             :                 YYDEBUG(465, *YYCURSOR);
    5011         631 :                 yych = *++YYCURSOR;
    5012         631 :                 if (yych == 'T') goto yy466;
    5013         629 :                 if (yych != 't') goto yy150;
    5014             : yy466:
    5015             :                 YYDEBUG(466, *YYCURSOR);
    5016         631 :                 yych = *++YYCURSOR;
    5017         631 :                 if (yych == 'E') goto yy467;
    5018         629 :                 if (yych != 'e') goto yy150;
    5019             : yy467:
    5020             :                 YYDEBUG(467, *YYCURSOR);
    5021         631 :                 yych = *++YYCURSOR;
    5022         631 :                 if (yych == 'D') goto yy468;
    5023         629 :                 if (yych != 'd') goto yy150;
    5024             : yy468:
    5025             :                 YYDEBUG(468, *YYCURSOR);
    5026         631 :                 ++YYCURSOR;
    5027         631 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5028          16 :                         goto yy149;
    5029             :                 }
    5030             :                 YYDEBUG(469, *YYCURSOR);
    5031         615 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5032             : #line 1416 "Zend/zend_language_scanner.l"
    5033             :                 {
    5034             :         RETURN_TOKEN(T_PROTECTED);
    5035             : }
    5036             : #line 5037 "Zend/zend_language_scanner.c"
    5037             : yy470:
    5038             :                 YYDEBUG(470, *YYCURSOR);
    5039       11633 :                 yych = *++YYCURSOR;
    5040       11633 :                 if (yych == 'T') goto yy476;
    5041       11631 :                 if (yych == 't') goto yy476;
    5042           0 :                 goto yy150;
    5043             : yy471:
    5044             :                 YYDEBUG(471, *YYCURSOR);
    5045        1270 :                 yych = *++YYCURSOR;
    5046        1270 :                 if (yych == 'A') goto yy472;
    5047        1267 :                 if (yych != 'a') goto yy150;
    5048             : yy472:
    5049             :                 YYDEBUG(472, *YYCURSOR);
    5050        1232 :                 yych = *++YYCURSOR;
    5051        1232 :                 if (yych == 'T') goto yy473;
    5052        1229 :                 if (yych != 't') goto yy150;
    5053             : yy473:
    5054             :                 YYDEBUG(473, *YYCURSOR);
    5055        1232 :                 yych = *++YYCURSOR;
    5056        1232 :                 if (yych == 'E') goto yy474;
    5057        1229 :                 if (yych != 'e') goto yy150;
    5058             : yy474:
    5059             :                 YYDEBUG(474, *YYCURSOR);
    5060        1232 :                 ++YYCURSOR;
    5061        1232 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5062          23 :                         goto yy149;
    5063             :                 }
    5064             :                 YYDEBUG(475, *YYCURSOR);
    5065        1209 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5066             : #line 1412 "Zend/zend_language_scanner.l"
    5067             :                 {
    5068             :         RETURN_TOKEN(T_PRIVATE);
    5069             : }
    5070             : #line 5071 "Zend/zend_language_scanner.c"
    5071             : yy476:
    5072             :                 YYDEBUG(476, *YYCURSOR);
    5073       11633 :                 ++YYCURSOR;
    5074       11633 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5075        8189 :                         goto yy149;
    5076             :                 }
    5077             :                 YYDEBUG(477, *YYCURSOR);
    5078        3444 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5079             : #line 1246 "Zend/zend_language_scanner.l"
    5080             :                 {
    5081             :         RETURN_TOKEN(T_PRINT);
    5082             : }
    5083             : #line 5084 "Zend/zend_language_scanner.c"
    5084             : yy478:
    5085             :                 YYDEBUG(478, *YYCURSOR);
    5086        4305 :                 yych = *++YYCURSOR;
    5087        4305 :                 if (yych == 'O') goto yy483;
    5088        4292 :                 if (yych == 'o') goto yy483;
    5089           0 :                 goto yy150;
    5090             : yy479:
    5091             :                 YYDEBUG(479, *YYCURSOR);
    5092          71 :                 yych = *++YYCURSOR;
    5093          71 :                 if (yych == 'T') goto yy480;
    5094          69 :                 if (yych != 't') goto yy150;
    5095             : yy480:
    5096             :                 YYDEBUG(480, *YYCURSOR);
    5097          50 :                 yych = *++YYCURSOR;
    5098          50 :                 if (yych == 'O') goto yy481;
    5099          48 :                 if (yych != 'o') goto yy150;
    5100             : yy481:
    5101             :                 YYDEBUG(481, *YYCURSOR);
    5102          50 :                 ++YYCURSOR;
    5103          50 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5104           0 :                         goto yy149;
    5105             :                 }
    5106             :                 YYDEBUG(482, *YYCURSOR);
    5107          50 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5108             : #line 1238 "Zend/zend_language_scanner.l"
    5109             :                 {
    5110             :         RETURN_TOKEN(T_GOTO);
    5111             : }
    5112             : #line 5113 "Zend/zend_language_scanner.c"
    5113             : yy483:
    5114             :                 YYDEBUG(483, *YYCURSOR);
    5115        4305 :                 yych = *++YYCURSOR;
    5116        4305 :                 if (yych == 'B') goto yy484;
    5117        4292 :                 if (yych != 'b') goto yy150;
    5118             : yy484:
    5119             :                 YYDEBUG(484, *YYCURSOR);
    5120        4305 :                 yych = *++YYCURSOR;
    5121        4305 :                 if (yych == 'A') goto yy485;
    5122        4303 :                 if (yych != 'a') goto yy150;
    5123             : yy485:
    5124             :                 YYDEBUG(485, *YYCURSOR);
    5125        4222 :                 yych = *++YYCURSOR;
    5126        4222 :                 if (yych == 'L') goto yy486;
    5127        4220 :                 if (yych != 'l') goto yy150;
    5128             : yy486:
    5129             :                 YYDEBUG(486, *YYCURSOR);
    5130        4222 :                 ++YYCURSOR;
    5131        4222 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5132           1 :                         goto yy149;
    5133             :                 }
    5134             :                 YYDEBUG(487, *YYCURSOR);
    5135        4221 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5136             : #line 1384 "Zend/zend_language_scanner.l"
    5137             :                 {
    5138             :         RETURN_TOKEN(T_GLOBAL);
    5139             : }
    5140             : #line 5141 "Zend/zend_language_scanner.c"
    5141             : yy488:
    5142             :                 YYDEBUG(488, *YYCURSOR);
    5143          32 :                 yych = *++YYCURSOR;
    5144          32 :                 if (yych == '<') goto yy496;
    5145           0 :                 goto yy157;
    5146             : yy489:
    5147             :                 YYDEBUG(489, *YYCURSOR);
    5148         442 :                 yych = *++YYCURSOR;
    5149         442 :                 goto yy144;
    5150             : yy490:
    5151             :                 YYDEBUG(490, *YYCURSOR);
    5152         624 :                 yych = *++YYCURSOR;
    5153         624 :                 goto yy142;
    5154             : yy491:
    5155             :                 YYDEBUG(491, *YYCURSOR);
    5156        1940 :                 yych = *++YYCURSOR;
    5157        1940 :                 if (yych == 'E') goto yy492;
    5158        1938 :                 if (yych != 'e') goto yy150;
    5159             : yy492:
    5160             :                 YYDEBUG(492, *YYCURSOR);
    5161        1938 :                 yych = *++YYCURSOR;
    5162        1938 :                 if (yych == 'A') goto yy493;
    5163        1936 :                 if (yych != 'a') goto yy150;
    5164             : yy493:
    5165             :                 YYDEBUG(493, *YYCURSOR);
    5166        1938 :                 yych = *++YYCURSOR;
    5167        1938 :                 if (yych == 'K') goto yy494;
    5168        1936 :                 if (yych != 'k') goto yy150;
    5169             : yy494:
    5170             :                 YYDEBUG(494, *YYCURSOR);
    5171        1938 :                 ++YYCURSOR;
    5172        1938 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5173           0 :                         goto yy149;
    5174             :                 }
    5175             :                 YYDEBUG(495, *YYCURSOR);
    5176        1938 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5177             : #line 1230 "Zend/zend_language_scanner.l"
    5178             :                 {
    5179             :         RETURN_TOKEN(T_BREAK);
    5180             : }
    5181             : #line 5182 "Zend/zend_language_scanner.c"
    5182             : yy496:
    5183             :                 YYDEBUG(496, *YYCURSOR);
    5184          32 :                 yych = *++YYCURSOR;
    5185          32 :                 if (yych == '<') goto yy219;
    5186           0 :                 goto yy157;
    5187             : yy497:
    5188             :                 YYDEBUG(497, *YYCURSOR);
    5189       26931 :                 yych = *++YYCURSOR;
    5190       26931 :                 if (yych == 'A') goto yy504;
    5191       26922 :                 if (yych == 'a') goto yy504;
    5192       16450 :                 goto yy150;
    5193             : yy498:
    5194             :                 YYDEBUG(498, *YYCURSOR);
    5195         484 :                 yych = *++YYCURSOR;
    5196         484 :                 if (yych == 'I') goto yy499;
    5197         482 :                 if (yych != 'i') goto yy150;
    5198             : yy499:
    5199             :                 YYDEBUG(499, *YYCURSOR);
    5200         482 :                 yych = *++YYCURSOR;
    5201         482 :                 if (yych == 'T') goto yy500;
    5202         480 :                 if (yych != 't') goto yy150;
    5203             : yy500:
    5204             :                 YYDEBUG(500, *YYCURSOR);
    5205         482 :                 yych = *++YYCURSOR;
    5206         482 :                 if (yych == 'C') goto yy501;
    5207         480 :                 if (yych != 'c') goto yy150;
    5208             : yy501:
    5209             :                 YYDEBUG(501, *YYCURSOR);
    5210         482 :                 yych = *++YYCURSOR;
    5211         482 :                 if (yych == 'H') goto yy502;
    5212         480 :                 if (yych != 'h') goto yy150;
    5213             : yy502:
    5214             :                 YYDEBUG(502, *YYCURSOR);
    5215         482 :                 ++YYCURSOR;
    5216         482 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5217           2 :                         goto yy149;
    5218             :                 }
    5219             :                 YYDEBUG(503, *YYCURSOR);
    5220         480 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5221             : #line 1214 "Zend/zend_language_scanner.l"
    5222             :                 {
    5223             :         RETURN_TOKEN(T_SWITCH);
    5224             : }
    5225             : #line 5226 "Zend/zend_language_scanner.c"
    5226             : yy504:
    5227             :                 YYDEBUG(504, *YYCURSOR);
    5228       10481 :                 yych = *++YYCURSOR;
    5229       10481 :                 if (yych == 'T') goto yy505;
    5230       10478 :                 if (yych != 't') goto yy150;
    5231             : yy505:
    5232             :                 YYDEBUG(505, *YYCURSOR);
    5233       10462 :                 yych = *++YYCURSOR;
    5234       10462 :                 if (yych == 'I') goto yy506;
    5235       10459 :                 if (yych != 'i') goto yy150;
    5236             : yy506:
    5237             :                 YYDEBUG(506, *YYCURSOR);
    5238       10339 :                 yych = *++YYCURSOR;
    5239       10339 :                 if (yych == 'C') goto yy507;
    5240       10336 :                 if (yych != 'c') goto yy150;
    5241             : yy507:
    5242             :                 YYDEBUG(507, *YYCURSOR);
    5243       10339 :                 ++YYCURSOR;
    5244       10339 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5245          75 :                         goto yy149;
    5246             :                 }
    5247             :                 YYDEBUG(508, *YYCURSOR);
    5248       10264 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5249             : #line 1400 "Zend/zend_language_scanner.l"
    5250             :                 {
    5251             :         RETURN_TOKEN(T_STATIC);
    5252             : }
    5253             : #line 5254 "Zend/zend_language_scanner.c"
    5254             : yy509:
    5255             :                 YYDEBUG(509, *YYCURSOR);
    5256         290 :                 yych = *++YYCURSOR;
    5257         290 :                 if (yych == 'S') goto yy520;
    5258         288 :                 if (yych == 's') goto yy520;
    5259          39 :                 goto yy150;
    5260             : yy510:
    5261             :                 YYDEBUG(510, *YYCURSOR);
    5262         101 :                 yych = *++YYCURSOR;
    5263         101 :                 if (yych == 'D') goto yy518;
    5264          99 :                 if (yych == 'd') goto yy518;
    5265          79 :                 goto yy150;
    5266             : yy511:
    5267             :                 YYDEBUG(511, *YYCURSOR);
    5268       31318 :                 yych = *++YYCURSOR;
    5269       31318 :                 if (yych == 'R') goto yy514;
    5270       31295 :                 if (yych == 'r') goto yy514;
    5271          63 :                 goto yy150;
    5272             : yy512:
    5273             :                 YYDEBUG(512, *YYCURSOR);
    5274       12143 :                 ++YYCURSOR;
    5275       12143 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5276         438 :                         goto yy149;
    5277             :                 }
    5278             :                 YYDEBUG(513, *YYCURSOR);
    5279       11705 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5280             : #line 1210 "Zend/zend_language_scanner.l"
    5281             :                 {
    5282             :         RETURN_TOKEN(T_AS);
    5283             : }
    5284             : #line 5285 "Zend/zend_language_scanner.c"
    5285             : yy514:
    5286             :                 YYDEBUG(514, *YYCURSOR);
    5287       31255 :                 yych = *++YYCURSOR;
    5288       31255 :                 if (yych == 'A') goto yy515;
    5289       31232 :                 if (yych != 'a') goto yy150;
    5290             : yy515:
    5291             :                 YYDEBUG(515, *YYCURSOR);
    5292       31253 :                 yych = *++YYCURSOR;
    5293       31253 :                 if (yych == 'Y') goto yy516;
    5294       31230 :                 if (yych != 'y') goto yy150;
    5295             : yy516:
    5296             :                 YYDEBUG(516, *YYCURSOR);
    5297       31253 :                 ++YYCURSOR;
    5298       31253 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5299        3004 :                         goto yy149;
    5300             :                 }
    5301             :                 YYDEBUG(517, *YYCURSOR);
    5302       28249 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5303             : #line 1436 "Zend/zend_language_scanner.l"
    5304             :                 {
    5305             :         RETURN_TOKEN(T_ARRAY);
    5306             : }
    5307             : #line 5308 "Zend/zend_language_scanner.c"
    5308             : yy518:
    5309             :                 YYDEBUG(518, *YYCURSOR);
    5310          22 :                 ++YYCURSOR;
    5311          22 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5312           2 :                         goto yy149;
    5313             :                 }
    5314             :                 YYDEBUG(519, *YYCURSOR);
    5315          20 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5316             : #line 1544 "Zend/zend_language_scanner.l"
    5317             :                 {
    5318             :         RETURN_TOKEN(T_LOGICAL_AND);
    5319             : }
    5320             : #line 5321 "Zend/zend_language_scanner.c"
    5321             : yy520:
    5322             :                 YYDEBUG(520, *YYCURSOR);
    5323         251 :                 yych = *++YYCURSOR;
    5324         251 :                 if (yych == 'T') goto yy521;
    5325         249 :                 if (yych != 't') goto yy150;
    5326             : yy521:
    5327             :                 YYDEBUG(521, *YYCURSOR);
    5328         221 :                 yych = *++YYCURSOR;
    5329         221 :                 if (yych == 'R') goto yy522;
    5330         219 :                 if (yych != 'r') goto yy150;
    5331             : yy522:
    5332             :                 YYDEBUG(522, *YYCURSOR);
    5333         221 :                 yych = *++YYCURSOR;
    5334         221 :                 if (yych == 'A') goto yy523;
    5335         219 :                 if (yych != 'a') goto yy150;
    5336             : yy523:
    5337             :                 YYDEBUG(523, *YYCURSOR);
    5338         221 :                 yych = *++YYCURSOR;
    5339         221 :                 if (yych == 'C') goto yy524;
    5340         219 :                 if (yych != 'c') goto yy150;
    5341             : yy524:
    5342             :                 YYDEBUG(524, *YYCURSOR);
    5343         221 :                 yych = *++YYCURSOR;
    5344         221 :                 if (yych == 'T') goto yy525;
    5345         219 :                 if (yych != 't') goto yy150;
    5346             : yy525:
    5347             :                 YYDEBUG(525, *YYCURSOR);
    5348         221 :                 ++YYCURSOR;
    5349         221 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5350          34 :                         goto yy149;
    5351             :                 }
    5352             :                 YYDEBUG(526, *YYCURSOR);
    5353         187 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5354             : #line 1404 "Zend/zend_language_scanner.l"
    5355             :                 {
    5356             :         RETURN_TOKEN(T_ABSTRACT);
    5357             : }
    5358             : #line 5359 "Zend/zend_language_scanner.c"
    5359             : yy527:
    5360             :                 YYDEBUG(527, *YYCURSOR);
    5361        2362 :                 yych = *++YYCURSOR;
    5362        2362 :                 if (yych == 'I') goto yy528;
    5363        2360 :                 if (yych != 'i') goto yy150;
    5364             : yy528:
    5365             :                 YYDEBUG(528, *YYCURSOR);
    5366        2329 :                 yych = *++YYCURSOR;
    5367        2329 :                 if (yych == 'L') goto yy529;
    5368        2327 :                 if (yych != 'l') goto yy150;
    5369             : yy529:
    5370             :                 YYDEBUG(529, *YYCURSOR);
    5371        2329 :                 yych = *++YYCURSOR;
    5372        2329 :                 if (yych == 'E') goto yy530;
    5373        2327 :                 if (yych != 'e') goto yy150;
    5374             : yy530:
    5375             :                 YYDEBUG(530, *YYCURSOR);
    5376        2329 :                 ++YYCURSOR;
    5377        2329 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5378           0 :                         goto yy149;
    5379             :                 }
    5380             :                 YYDEBUG(531, *YYCURSOR);
    5381        2329 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5382             : #line 1170 "Zend/zend_language_scanner.l"
    5383             :                 {
    5384             :         RETURN_TOKEN(T_WHILE);
    5385             : }
    5386             : #line 5387 "Zend/zend_language_scanner.c"
    5387             : yy532:
    5388             :                 YYDEBUG(532, *YYCURSOR);
    5389       76571 :                 ++YYCURSOR;
    5390       76571 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5391          73 :                         goto yy149;
    5392             :                 }
    5393             :                 YYDEBUG(533, *YYCURSOR);
    5394       76498 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5395             : #line 1154 "Zend/zend_language_scanner.l"
    5396             :                 {
    5397             :         RETURN_TOKEN(T_IF);
    5398             : }
    5399             : #line 5400 "Zend/zend_language_scanner.c"
    5400             : yy534:
    5401             :                 YYDEBUG(534, *YYCURSOR);
    5402        3461 :                 yych = *++YYCURSOR;
    5403        3461 :                 if (yych == 'P') goto yy576;
    5404        3459 :                 if (yych == 'p') goto yy576;
    5405        2910 :                 goto yy150;
    5406             : yy535:
    5407             :                 YYDEBUG(535, *YYCURSOR);
    5408       10327 :                 yych = *++YYCURSOR;
    5409       10327 :                 if (yych <= 'T') {
    5410         340 :                         if (yych <= 'C') {
    5411           4 :                                 if (yych <= 'B') goto yy150;
    5412           4 :                                 goto yy543;
    5413             :                         } else {
    5414         336 :                                 if (yych <= 'R') goto yy150;
    5415         224 :                                 if (yych <= 'S') goto yy541;
    5416         220 :                                 goto yy542;
    5417             :                         }
    5418             :                 } else {
    5419        9987 :                         if (yych <= 'r') {
    5420        8412 :                                 if (yych == 'c') goto yy543;
    5421        5385 :                                 goto yy150;
    5422             :                         } else {
    5423        1575 :                                 if (yych <= 's') goto yy541;
    5424        1164 :                                 if (yych <= 't') goto yy542;
    5425          17 :                                 goto yy150;
    5426             :                         }
    5427             :                 }
    5428             : yy536:
    5429             :                 YYDEBUG(536, *YYCURSOR);
    5430       11878 :                 yych = *++YYCURSOR;
    5431       11878 :                 if (yych == 'S') goto yy537;
    5432       11873 :                 if (yych != 's') goto yy150;
    5433             : yy537:
    5434             :                 YYDEBUG(537, *YYCURSOR);
    5435        5713 :                 yych = *++YYCURSOR;
    5436        5713 :                 if (yych == 'E') goto yy538;
    5437        5711 :                 if (yych != 'e') goto yy150;
    5438             : yy538:
    5439             :                 YYDEBUG(538, *YYCURSOR);
    5440        5713 :                 yych = *++YYCURSOR;
    5441        5713 :                 if (yych == 'T') goto yy539;
    5442        5711 :                 if (yych != 't') goto yy150;
    5443             : yy539:
    5444             :                 YYDEBUG(539, *YYCURSOR);
    5445        5710 :                 ++YYCURSOR;
    5446        5710 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5447           0 :                         goto yy149;
    5448             :                 }
    5449             :                 YYDEBUG(540, *YYCURSOR);
    5450        5710 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5451             : #line 1388 "Zend/zend_language_scanner.l"
    5452             :                 {
    5453             :         RETURN_TOKEN(T_ISSET);
    5454             : }
    5455             : #line 5456 "Zend/zend_language_scanner.c"
    5456             : yy541:
    5457             :                 YYDEBUG(541, *YYCURSOR);
    5458         415 :                 yych = *++YYCURSOR;
    5459         415 :                 if (yych == 'T') goto yy562;
    5460         411 :                 if (yych == 't') goto yy562;
    5461         296 :                 goto yy150;
    5462             : yy542:
    5463             :                 YYDEBUG(542, *YYCURSOR);
    5464        1367 :                 yych = *++YYCURSOR;
    5465        1367 :                 if (yych == 'E') goto yy555;
    5466        1364 :                 if (yych == 'e') goto yy555;
    5467        1077 :                 goto yy150;
    5468             : yy543:
    5469             :                 YYDEBUG(543, *YYCURSOR);
    5470        3031 :                 yych = *++YYCURSOR;
    5471        3031 :                 if (yych == 'L') goto yy544;
    5472        3027 :                 if (yych != 'l') goto yy150;
    5473             : yy544:
    5474             :                 YYDEBUG(544, *YYCURSOR);
    5475        3015 :                 yych = *++YYCURSOR;
    5476        3015 :                 if (yych == 'U') goto yy545;
    5477        3011 :                 if (yych != 'u') goto yy150;
    5478             : yy545:
    5479             :                 YYDEBUG(545, *YYCURSOR);
    5480        3015 :                 yych = *++YYCURSOR;
    5481        3015 :                 if (yych == 'D') goto yy546;
    5482        3011 :                 if (yych != 'd') goto yy150;
    5483             : yy546:
    5484             :                 YYDEBUG(546, *YYCURSOR);
    5485        3015 :                 yych = *++YYCURSOR;
    5486        3015 :                 if (yych == 'E') goto yy547;
    5487        3011 :                 if (yych != 'e') goto yy150;
    5488             : yy547:
    5489             :                 YYDEBUG(547, *YYCURSOR);
    5490        3015 :                 ++YYCURSOR;
    5491        3015 :                 if ((yych = *YYCURSOR) <= '^') {
    5492        2498 :                         if (yych <= '9') {
    5493        2498 :                                 if (yych >= '0') goto yy149;
    5494             :                         } else {
    5495           0 :                                 if (yych <= '@') goto yy548;
    5496           0 :                                 if (yych <= 'Z') goto yy149;
    5497             :                         }
    5498             :                 } else {
    5499         517 :                         if (yych <= '`') {
    5500         517 :                                 if (yych <= '_') goto yy549;
    5501             :                         } else {
    5502           0 :                                 if (yych <= 'z') goto yy149;
    5503           0 :                                 if (yych >= 0x7F) goto yy149;
    5504             :                         }
    5505             :                 }
    5506             : yy548:
    5507             :                 YYDEBUG(548, *YYCURSOR);
    5508        2498 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5509             : #line 1356 "Zend/zend_language_scanner.l"
    5510             :                 {
    5511             :         RETURN_TOKEN(T_INCLUDE);
    5512             : }
    5513             : #line 5514 "Zend/zend_language_scanner.c"
    5514             : yy549:
    5515             :                 YYDEBUG(549, *YYCURSOR);
    5516         517 :                 yych = *++YYCURSOR;
    5517         517 :                 if (yych == 'O') goto yy550;
    5518         515 :                 if (yych != 'o') goto yy150;
    5519             : yy550:
    5520             :                 YYDEBUG(550, *YYCURSOR);
    5521         517 :                 yych = *++YYCURSOR;
    5522         517 :                 if (yych == 'N') goto yy551;
    5523         515 :                 if (yych != 'n') goto yy150;
    5524             : yy551:
    5525             :                 YYDEBUG(551, *YYCURSOR);
    5526         517 :                 yych = *++YYCURSOR;
    5527         517 :                 if (yych == 'C') goto yy552;
    5528         515 :                 if (yych != 'c') goto yy150;
    5529             : yy552:
    5530             :                 YYDEBUG(552, *YYCURSOR);
    5531         517 :                 yych = *++YYCURSOR;
    5532         517 :                 if (yych == 'E') goto yy553;
    5533         515 :                 if (yych != 'e') goto yy150;
    5534             : yy553:
    5535             :                 YYDEBUG(553, *YYCURSOR);
    5536         517 :                 ++YYCURSOR;
    5537         517 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5538           0 :                         goto yy149;
    5539             :                 }
    5540             :                 YYDEBUG(554, *YYCURSOR);
    5541         517 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5542             : #line 1360 "Zend/zend_language_scanner.l"
    5543             :                 {
    5544             :         RETURN_TOKEN(T_INCLUDE_ONCE);
    5545             : }
    5546             : #line 5547 "Zend/zend_language_scanner.c"
    5547             : yy555:
    5548             :                 YYDEBUG(555, *YYCURSOR);
    5549         290 :                 yych = *++YYCURSOR;
    5550         290 :                 if (yych == 'R') goto yy556;
    5551         288 :                 if (yych != 'r') goto yy150;
    5552             : yy556:
    5553             :                 YYDEBUG(556, *YYCURSOR);
    5554         272 :                 yych = *++YYCURSOR;
    5555         272 :                 if (yych == 'F') goto yy557;
    5556         270 :                 if (yych != 'f') goto yy150;
    5557             : yy557:
    5558             :                 YYDEBUG(557, *YYCURSOR);
    5559         253 :                 yych = *++YYCURSOR;
    5560         253 :                 if (yych == 'A') goto yy558;
    5561         251 :                 if (yych != 'a') goto yy150;
    5562             : yy558:
    5563             :                 YYDEBUG(558, *YYCURSOR);
    5564         253 :                 yych = *++YYCURSOR;
    5565         253 :                 if (yych == 'C') goto yy559;
    5566         251 :                 if (yych != 'c') goto yy150;
    5567             : yy559:
    5568             :                 YYDEBUG(559, *YYCURSOR);
    5569         253 :                 yych = *++YYCURSOR;
    5570         253 :                 if (yych == 'E') goto yy560;
    5571         251 :                 if (yych != 'e') goto yy150;
    5572             : yy560:
    5573             :                 YYDEBUG(560, *YYCURSOR);
    5574         253 :                 ++YYCURSOR;
    5575         253 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5576          38 :                         goto yy149;
    5577             :                 }
    5578             :                 YYDEBUG(561, *YYCURSOR);
    5579         215 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5580             : #line 1254 "Zend/zend_language_scanner.l"
    5581             :                 {
    5582             :         RETURN_TOKEN(T_INTERFACE);
    5583             : }
    5584             : #line 5585 "Zend/zend_language_scanner.c"
    5585             : yy562:
    5586             :                 YYDEBUG(562, *YYCURSOR);
    5587         119 :                 yych = *++YYCURSOR;
    5588         119 :                 if (yych <= 'E') {
    5589           4 :                         if (yych == 'A') goto yy563;
    5590           2 :                         if (yych <= 'D') goto yy150;
    5591           2 :                         goto yy564;
    5592             :                 } else {
    5593         115 :                         if (yych <= 'a') {
    5594          85 :                                 if (yych <= '`') goto yy150;
    5595             :                         } else {
    5596          30 :                                 if (yych == 'e') goto yy564;
    5597           0 :                                 goto yy150;
    5598             :                         }
    5599             :                 }
    5600             : yy563:
    5601             :                 YYDEBUG(563, *YYCURSOR);
    5602          87 :                 yych = *++YYCURSOR;
    5603          87 :                 if (yych == 'N') goto yy570;
    5604          85 :                 if (yych == 'n') goto yy570;
    5605           0 :                 goto yy150;
    5606             : yy564:
    5607             :                 YYDEBUG(564, *YYCURSOR);
    5608          32 :                 yych = *++YYCURSOR;
    5609          32 :                 if (yych == 'A') goto yy565;
    5610          30 :                 if (yych != 'a') goto yy150;
    5611             : yy565:
    5612             :                 YYDEBUG(565, *YYCURSOR);
    5613          32 :                 yych = *++YYCURSOR;
    5614          32 :                 if (yych == 'D') goto yy566;
    5615          30 :                 if (yych != 'd') goto yy150;
    5616             : yy566:
    5617             :                 YYDEBUG(566, *YYCURSOR);
    5618          32 :                 yych = *++YYCURSOR;
    5619          32 :                 if (yych == 'O') goto yy567;
    5620          30 :                 if (yych != 'o') goto yy150;
    5621             : yy567:
    5622             :                 YYDEBUG(567, *YYCURSOR);
    5623          32 :                 yych = *++YYCURSOR;
    5624          32 :                 if (yych == 'F') goto yy568;
    5625          30 :                 if (yych != 'f') goto yy150;
    5626             : yy568:
    5627             :                 YYDEBUG(568, *YYCURSOR);
    5628          32 :                 ++YYCURSOR;
    5629          32 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5630           0 :                         goto yy149;
    5631             :                 }
    5632             :                 YYDEBUG(569, *YYCURSOR);
    5633          32 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5634             : #line 1380 "Zend/zend_language_scanner.l"
    5635             :                 {
    5636             :     RETURN_TOKEN(T_INSTEADOF);
    5637             : }
    5638             : #line 5639 "Zend/zend_language_scanner.c"
    5639             : yy570:
    5640             :                 YYDEBUG(570, *YYCURSOR);
    5641          87 :                 yych = *++YYCURSOR;
    5642          87 :                 if (yych == 'C') goto yy571;
    5643          85 :                 if (yych != 'c') goto yy150;
    5644             : yy571:
    5645             :                 YYDEBUG(571, *YYCURSOR);
    5646          87 :                 yych = *++YYCURSOR;
    5647          87 :                 if (yych == 'E') goto yy572;
    5648          85 :                 if (yych != 'e') goto yy150;
    5649             : yy572:
    5650             :                 YYDEBUG(572, *YYCURSOR);
    5651          87 :                 yych = *++YYCURSOR;
    5652          87 :                 if (yych == 'O') goto yy573;
    5653          84 :                 if (yych != 'o') goto yy150;
    5654             : yy573:
    5655             :                 YYDEBUG(573, *YYCURSOR);
    5656          80 :                 yych = *++YYCURSOR;
    5657          80 :                 if (yych == 'F') goto yy574;
    5658          78 :                 if (yych != 'f') goto yy150;
    5659             : yy574:
    5660             :                 YYDEBUG(574, *YYCURSOR);
    5661          80 :                 ++YYCURSOR;
    5662          80 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5663           0 :                         goto yy149;
    5664             :                 }
    5665             :                 YYDEBUG(575, *YYCURSOR);
    5666          80 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5667             : #line 1206 "Zend/zend_language_scanner.l"
    5668             :                 {
    5669             :         RETURN_TOKEN(T_INSTANCEOF);
    5670             : }
    5671             : #line 5672 "Zend/zend_language_scanner.c"
    5672             : yy576:
    5673             :                 YYDEBUG(576, *YYCURSOR);
    5674         551 :                 yych = *++YYCURSOR;
    5675         551 :                 if (yych == 'L') goto yy577;
    5676         549 :                 if (yych != 'l') goto yy150;
    5677             : yy577:
    5678             :                 YYDEBUG(577, *YYCURSOR);
    5679         551 :                 yych = *++YYCURSOR;
    5680         551 :                 if (yych == 'E') goto yy578;
    5681         549 :                 if (yych != 'e') goto yy150;
    5682             : yy578:
    5683             :                 YYDEBUG(578, *YYCURSOR);
    5684         338 :                 yych = *++YYCURSOR;
    5685         338 :                 if (yych == 'M') goto yy579;
    5686         336 :                 if (yych != 'm') goto yy150;
    5687             : yy579:
    5688             :                 YYDEBUG(579, *YYCURSOR);
    5689         338 :                 yych = *++YYCURSOR;
    5690         338 :                 if (yych == 'E') goto yy580;
    5691         336 :                 if (yych != 'e') goto yy150;
    5692             : yy580:
    5693             :                 YYDEBUG(580, *YYCURSOR);
    5694         331 :                 yych = *++YYCURSOR;
    5695         331 :                 if (yych == 'N') goto yy581;
    5696         329 :                 if (yych != 'n') goto yy150;
    5697             : yy581:
    5698             :                 YYDEBUG(581, *YYCURSOR);
    5699         331 :                 yych = *++YYCURSOR;
    5700         331 :                 if (yych == 'T') goto yy582;
    5701         329 :                 if (yych != 't') goto yy150;
    5702             : yy582:
    5703             :                 YYDEBUG(582, *YYCURSOR);
    5704         331 :                 yych = *++YYCURSOR;
    5705         331 :                 if (yych == 'S') goto yy583;
    5706         329 :                 if (yych != 's') goto yy150;
    5707             : yy583:
    5708             :                 YYDEBUG(583, *YYCURSOR);
    5709         330 :                 ++YYCURSOR;
    5710         330 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5711           0 :                         goto yy149;
    5712             :                 }
    5713             :                 YYDEBUG(584, *YYCURSOR);
    5714         330 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5715             : #line 1266 "Zend/zend_language_scanner.l"
    5716             :                 {
    5717             :         RETURN_TOKEN(T_IMPLEMENTS);
    5718             : }
    5719             : #line 5720 "Zend/zend_language_scanner.c"
    5720             : yy585:
    5721             :                 YYDEBUG(585, *YYCURSOR);
    5722         554 :                 yych = *++YYCURSOR;
    5723         554 :                 if (yych == 'R') goto yy593;
    5724         552 :                 if (yych == 'r') goto yy593;
    5725          99 :                 goto yy150;
    5726             : yy586:
    5727             :                 YYDEBUG(586, *YYCURSOR);
    5728       25229 :                 yych = *++YYCURSOR;
    5729       25229 :                 if (yych <= 'Y') {
    5730        3645 :                         if (yych == 'A') goto yy589;
    5731        3632 :                         if (yych <= 'X') goto yy150;
    5732             :                 } else {
    5733       21584 :                         if (yych <= 'a') {
    5734         422 :                                 if (yych <= '`') goto yy150;
    5735         422 :                                 goto yy589;
    5736             :                         } else {
    5737       21162 :                                 if (yych != 'y') goto yy150;
    5738             :                         }
    5739             :                 }
    5740             :                 YYDEBUG(587, *YYCURSOR);
    5741        2755 :                 ++YYCURSOR;
    5742        2755 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5743          19 :                         goto yy149;
    5744             :                 }
    5745             :                 YYDEBUG(588, *YYCURSOR);
    5746        2736 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5747             : #line 1138 "Zend/zend_language_scanner.l"
    5748             :                 {
    5749             :         RETURN_TOKEN(T_TRY);
    5750             : }
    5751             : #line 5752 "Zend/zend_language_scanner.c"
    5752             : yy589:
    5753             :                 YYDEBUG(589, *YYCURSOR);
    5754         435 :                 yych = *++YYCURSOR;
    5755         435 :                 if (yych == 'I') goto yy590;
    5756         433 :                 if (yych != 'i') goto yy150;
    5757             : yy590:
    5758             :                 YYDEBUG(590, *YYCURSOR);
    5759         345 :                 yych = *++YYCURSOR;
    5760         345 :                 if (yych == 'T') goto yy591;
    5761         343 :                 if (yych != 't') goto yy150;
    5762             : yy591:
    5763             :                 YYDEBUG(591, *YYCURSOR);
    5764         345 :                 ++YYCURSOR;
    5765         345 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5766         102 :                         goto yy149;
    5767             :                 }
    5768             :                 YYDEBUG(592, *YYCURSOR);
    5769         243 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5770             : #line 1258 "Zend/zend_language_scanner.l"
    5771             :                 {
    5772             :         RETURN_TOKEN(T_TRAIT);
    5773             : }
    5774             : #line 5775 "Zend/zend_language_scanner.c"
    5775             : yy593:
    5776             :                 YYDEBUG(593, *YYCURSOR);
    5777         455 :                 yych = *++YYCURSOR;
    5778         455 :                 if (yych == 'O') goto yy594;
    5779         453 :                 if (yych != 'o') goto yy150;
    5780             : yy594:
    5781             :                 YYDEBUG(594, *YYCURSOR);
    5782         448 :                 yych = *++YYCURSOR;
    5783         448 :                 if (yych == 'W') goto yy595;
    5784         446 :                 if (yych != 'w') goto yy150;
    5785             : yy595:
    5786             :                 YYDEBUG(595, *YYCURSOR);
    5787         448 :                 ++YYCURSOR;
    5788         448 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5789          47 :                         goto yy149;
    5790             :                 }
    5791             :                 YYDEBUG(596, *YYCURSOR);
    5792         401 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5793             : #line 1150 "Zend/zend_language_scanner.l"
    5794             :                 {
    5795             :         RETURN_TOKEN(T_THROW);
    5796             : }
    5797             : #line 5798 "Zend/zend_language_scanner.c"
    5798             : yy597:
    5799             :                 YYDEBUG(597, *YYCURSOR);
    5800         283 :                 yych = *++YYCURSOR;
    5801         283 :                 if (yych == 'E') goto yy598;
    5802         281 :                 if (yych != 'e') goto yy150;
    5803             : yy598:
    5804             :                 YYDEBUG(598, *YYCURSOR);
    5805         283 :                 yych = *++YYCURSOR;
    5806         283 :                 if (yych == 'L') goto yy599;
    5807         281 :                 if (yych != 'l') goto yy150;
    5808             : yy599:
    5809             :                 YYDEBUG(599, *YYCURSOR);
    5810         283 :                 yych = *++YYCURSOR;
    5811         283 :                 if (yych == 'D') goto yy600;
    5812         281 :                 if (yych != 'd') goto yy150;
    5813             : yy600:
    5814             :                 YYDEBUG(600, *YYCURSOR);
    5815         283 :                 yyaccept = 6;
    5816         283 :                 yych = *(YYMARKER = ++YYCURSOR);
    5817         283 :                 if (yybm[0+yych] & 4) {
    5818           3 :                         goto yy149;
    5819             :                 }
    5820         280 :                 if (yych <= '\f') {
    5821           0 :                         if (yych <= 0x08) goto yy601;
    5822           0 :                         if (yych <= '\n') goto yy602;
    5823             :                 } else {
    5824         280 :                         if (yych <= '\r') goto yy602;
    5825         280 :                         if (yych == ' ') goto yy602;
    5826             :                 }
    5827             : yy601:
    5828             :                 YYDEBUG(601, *YYCURSOR);
    5829         244 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5830             : #line 1134 "Zend/zend_language_scanner.l"
    5831             :                 {
    5832             :         RETURN_TOKEN(T_YIELD);
    5833             : }
    5834             : #line 5835 "Zend/zend_language_scanner.c"
    5835             : yy602:
    5836             :                 YYDEBUG(602, *YYCURSOR);
    5837         202 :                 ++YYCURSOR;
    5838         202 :                 YYFILL(4);
    5839         202 :                 yych = *YYCURSOR;
    5840             :                 YYDEBUG(603, *YYCURSOR);
    5841         202 :                 if (yych <= 0x1F) {
    5842           0 :                         if (yych <= '\n') {
    5843           0 :                                 if (yych <= 0x08) goto yy157;
    5844           0 :                                 goto yy602;
    5845             :                         } else {
    5846           0 :                                 if (yych == '\r') goto yy602;
    5847           0 :                                 goto yy157;
    5848             :                         }
    5849             :                 } else {
    5850         202 :                         if (yych <= 'F') {
    5851         150 :                                 if (yych <= ' ') goto yy602;
    5852         150 :                                 if (yych <= 'E') goto yy157;
    5853             :                         } else {
    5854          52 :                                 if (yych != 'f') goto yy157;
    5855             :                         }
    5856             :                 }
    5857             :                 YYDEBUG(604, *YYCURSOR);
    5858          39 :                 yych = *++YYCURSOR;
    5859          39 :                 if (yych == 'R') goto yy605;
    5860          39 :                 if (yych != 'r') goto yy157;
    5861             : yy605:
    5862             :                 YYDEBUG(605, *YYCURSOR);
    5863          36 :                 yych = *++YYCURSOR;
    5864          36 :                 if (yych == 'O') goto yy606;
    5865          36 :                 if (yych != 'o') goto yy157;
    5866             : yy606:
    5867             :                 YYDEBUG(606, *YYCURSOR);
    5868          36 :                 yych = *++YYCURSOR;
    5869          36 :                 if (yych == 'M') goto yy607;
    5870          36 :                 if (yych != 'm') goto yy157;
    5871             : yy607:
    5872             :                 YYDEBUG(607, *YYCURSOR);
    5873          36 :                 ++YYCURSOR;
    5874             :                 YYDEBUG(608, *YYCURSOR);
    5875          36 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5876             : #line 1130 "Zend/zend_language_scanner.l"
    5877             :                 {
    5878             :         RETURN_TOKEN(T_YIELD_FROM);
    5879             : }
    5880             : #line 5881 "Zend/zend_language_scanner.c"
    5881             : yy609:
    5882             :                 YYDEBUG(609, *YYCURSOR);
    5883       62398 :                 yych = *++YYCURSOR;
    5884       62398 :                 if (yych <= 'T') {
    5885          50 :                         if (yych == 'Q') goto yy611;
    5886          46 :                         if (yych <= 'S') goto yy150;
    5887             :                 } else {
    5888       62348 :                         if (yych <= 'q') {
    5889       16347 :                                 if (yych <= 'p') goto yy150;
    5890        7878 :                                 goto yy611;
    5891             :                         } else {
    5892       46001 :                                 if (yych != 't') goto yy150;
    5893             :                         }
    5894             :                 }
    5895             :                 YYDEBUG(610, *YYCURSOR);
    5896       44988 :                 yych = *++YYCURSOR;
    5897       44988 :                 if (yych == 'U') goto yy623;
    5898       44984 :                 if (yych == 'u') goto yy623;
    5899          10 :                 goto yy150;
    5900             : yy611:
    5901             :                 YYDEBUG(611, *YYCURSOR);
    5902        7882 :                 yych = *++YYCURSOR;
    5903        7882 :                 if (yych == 'U') goto yy612;
    5904        7878 :                 if (yych != 'u') goto yy150;
    5905             : yy612:
    5906             :                 YYDEBUG(612, *YYCURSOR);
    5907        7882 :                 yych = *++YYCURSOR;
    5908        7882 :                 if (yych == 'I') goto yy613;
    5909        7878 :                 if (yych != 'i') goto yy150;
    5910             : yy613:
    5911             :                 YYDEBUG(613, *YYCURSOR);
    5912        7882 :                 yych = *++YYCURSOR;
    5913        7882 :                 if (yych == 'R') goto yy614;
    5914        7878 :                 if (yych != 'r') goto yy150;
    5915             : yy614:
    5916             :                 YYDEBUG(614, *YYCURSOR);
    5917        7882 :                 yych = *++YYCURSOR;
    5918        7882 :                 if (yych == 'E') goto yy615;
    5919        7878 :                 if (yych != 'e') goto yy150;
    5920             : yy615:
    5921             :                 YYDEBUG(615, *YYCURSOR);
    5922        7882 :                 ++YYCURSOR;
    5923        7882 :                 if ((yych = *YYCURSOR) <= '^') {
    5924        2242 :                         if (yych <= '9') {
    5925        2242 :                                 if (yych >= '0') goto yy149;
    5926             :                         } else {
    5927           0 :                                 if (yych <= '@') goto yy616;
    5928           0 :                                 if (yych <= 'Z') goto yy149;
    5929             :                         }
    5930             :                 } else {
    5931        5640 :                         if (yych <= '`') {
    5932        5567 :                                 if (yych <= '_') goto yy617;
    5933             :                         } else {
    5934          73 :                                 if (yych <= 'z') goto yy149;
    5935           0 :                                 if (yych >= 0x7F) goto yy149;
    5936             :                         }
    5937             :                 }
    5938             : yy616:
    5939             :                 YYDEBUG(616, *YYCURSOR);
    5940        2242 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5941             : #line 1364 "Zend/zend_language_scanner.l"
    5942             :                 {
    5943             :         RETURN_TOKEN(T_REQUIRE);
    5944             : }
    5945             : #line 5946 "Zend/zend_language_scanner.c"
    5946             : yy617:
    5947             :                 YYDEBUG(617, *YYCURSOR);
    5948        5567 :                 yych = *++YYCURSOR;
    5949        5567 :                 if (yych == 'O') goto yy618;
    5950        5565 :                 if (yych != 'o') goto yy150;
    5951             : yy618:
    5952             :                 YYDEBUG(618, *YYCURSOR);
    5953        5567 :                 yych = *++YYCURSOR;
    5954        5567 :                 if (yych == 'N') goto yy619;
    5955        5565 :                 if (yych != 'n') goto yy150;
    5956             : yy619:
    5957             :                 YYDEBUG(619, *YYCURSOR);
    5958        5567 :                 yych = *++YYCURSOR;
    5959        5567 :                 if (yych == 'C') goto yy620;
    5960        5565 :                 if (yych != 'c') goto yy150;
    5961             : yy620:
    5962             :                 YYDEBUG(620, *YYCURSOR);
    5963        5567 :                 yych = *++YYCURSOR;
    5964        5567 :                 if (yych == 'E') goto yy621;
    5965        5565 :                 if (yych != 'e') goto yy150;
    5966             : yy621:
    5967             :                 YYDEBUG(621, *YYCURSOR);
    5968        5567 :                 ++YYCURSOR;
    5969        5567 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5970           0 :                         goto yy149;
    5971             :                 }
    5972             :                 YYDEBUG(622, *YYCURSOR);
    5973        5567 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5974             : #line 1368 "Zend/zend_language_scanner.l"
    5975             :                 {
    5976             :         RETURN_TOKEN(T_REQUIRE_ONCE);
    5977             : }
    5978             : #line 5979 "Zend/zend_language_scanner.c"
    5979             : yy623:
    5980             :                 YYDEBUG(623, *YYCURSOR);
    5981       44978 :                 yych = *++YYCURSOR;
    5982       44978 :                 if (yych == 'R') goto yy624;
    5983       44974 :                 if (yych != 'r') goto yy150;
    5984             : yy624:
    5985             :                 YYDEBUG(624, *YYCURSOR);
    5986       44978 :                 yych = *++YYCURSOR;
    5987       44978 :                 if (yych == 'N') goto yy625;
    5988       44974 :                 if (yych != 'n') goto yy150;
    5989             : yy625:
    5990             :                 YYDEBUG(625, *YYCURSOR);
    5991       44978 :                 ++YYCURSOR;
    5992       44978 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    5993         140 :                         goto yy149;
    5994             :                 }
    5995             :                 YYDEBUG(626, *YYCURSOR);
    5996       44838 :                 yyleng = YYCURSOR - SCNG(yy_text);
    5997             : #line 1126 "Zend/zend_language_scanner.l"
    5998             :                 {
    5999             :         RETURN_TOKEN(T_RETURN);
    6000             : }
    6001             : #line 6002 "Zend/zend_language_scanner.c"
    6002             : yy627:
    6003             :                 YYDEBUG(627, *YYCURSOR);
    6004        6250 :                 yych = *++YYCURSOR;
    6005        6250 :                 if (yych <= 'T') {
    6006        1416 :                         if (yych <= 'L') {
    6007          77 :                                 if (yych <= 'K') goto yy150;
    6008          66 :                                 goto yy650;
    6009             :                         } else {
    6010        1339 :                                 if (yych <= 'R') goto yy150;
    6011        1339 :                                 if (yych <= 'S') goto yy649;
    6012           9 :                                 goto yy648;
    6013             :                         }
    6014             :                 } else {
    6015        4834 :                         if (yych <= 'r') {
    6016         515 :                                 if (yych == 'l') goto yy650;
    6017         128 :                                 goto yy150;
    6018             :                         } else {
    6019        4319 :                                 if (yych <= 's') goto yy649;
    6020        2681 :                                 if (yych <= 't') goto yy648;
    6021           1 :                                 goto yy150;
    6022             :                         }
    6023             :                 }
    6024             : yy628:
    6025             :                 YYDEBUG(628, *YYCURSOR);
    6026       10104 :                 yych = *++YYCURSOR;
    6027       10104 :                 if (yych <= 'O') {
    6028          17 :                         if (yych == 'A') goto yy640;
    6029           6 :                         if (yych <= 'N') goto yy150;
    6030           2 :                         goto yy641;
    6031             :                 } else {
    6032       10087 :                         if (yych <= 'a') {
    6033        9295 :                                 if (yych <= '`') goto yy150;
    6034        9255 :                                 goto yy640;
    6035             :                         } else {
    6036         792 :                                 if (yych == 'o') goto yy641;
    6037         386 :                                 goto yy150;
    6038             :                         }
    6039             :                 }
    6040             : yy629:
    6041             :                 YYDEBUG(629, *YYCURSOR);
    6042        5616 :                 yych = *++YYCURSOR;
    6043        5616 :                 if (yych == 'N') goto yy630;
    6044        5579 :                 if (yych != 'n') goto yy150;
    6045             : yy630:
    6046             :                 YYDEBUG(630, *YYCURSOR);
    6047        1085 :                 yych = *++YYCURSOR;
    6048        1085 :                 if (yych <= 'T') {
    6049          37 :                         if (yych <= 'R') goto yy150;
    6050          36 :                         if (yych >= 'T') goto yy632;
    6051             :                 } else {
    6052        1048 :                         if (yych <= 'r') goto yy150;
    6053        1023 :                         if (yych <= 's') goto yy631;
    6054         342 :                         if (yych <= 't') goto yy632;
    6055          42 :                         goto yy150;
    6056             :                 }
    6057             : yy631:
    6058             :                 YYDEBUG(631, *YYCURSOR);
    6059         711 :                 yych = *++YYCURSOR;
    6060         711 :                 if (yych == 'T') goto yy638;
    6061         688 :                 if (yych == 't') goto yy638;
    6062           3 :                 goto yy150;
    6063             : yy632:
    6064             :                 YYDEBUG(632, *YYCURSOR);
    6065         306 :                 yych = *++YYCURSOR;
    6066         306 :                 if (yych == 'I') goto yy633;
    6067         300 :                 if (yych != 'i') goto yy150;
    6068             : yy633:
    6069             :                 YYDEBUG(633, *YYCURSOR);
    6070         287 :                 yych = *++YYCURSOR;
    6071         287 :                 if (yych == 'N') goto yy634;
    6072         281 :                 if (yych != 'n') goto yy150;
    6073             : yy634:
    6074             :                 YYDEBUG(634, *YYCURSOR);
    6075         287 :                 yych = *++YYCURSOR;
    6076         287 :                 if (yych == 'U') goto yy635;
    6077         281 :                 if (yych != 'u') goto yy150;
    6078             : yy635:
    6079             :                 YYDEBUG(635, *YYCURSOR);
    6080         287 :                 yych = *++YYCURSOR;
    6081         287 :                 if (yych == 'E') goto yy636;
    6082         281 :                 if (yych != 'e') goto yy150;
    6083             : yy636:
    6084             :                 YYDEBUG(636, *YYCURSOR);
    6085         287 :                 ++YYCURSOR;
    6086         287 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6087           0 :                         goto yy149;
    6088             :                 }
    6089             :                 YYDEBUG(637, *YYCURSOR);
    6090         287 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6091             : #line 1234 "Zend/zend_language_scanner.l"
    6092             :                 {
    6093             :         RETURN_TOKEN(T_CONTINUE);
    6094             : }
    6095             : #line 6096 "Zend/zend_language_scanner.c"
    6096             : yy638:
    6097             :                 YYDEBUG(638, *YYCURSOR);
    6098         708 :                 ++YYCURSOR;
    6099         708 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6100         106 :                         goto yy149;
    6101             :                 }
    6102             :                 YYDEBUG(639, *YYCURSOR);
    6103         602 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6104             : #line 1122 "Zend/zend_language_scanner.l"
    6105             :                 {
    6106             :         RETURN_TOKEN(T_CONST);
    6107             : }
    6108             : #line 6109 "Zend/zend_language_scanner.c"
    6109             : yy640:
    6110             :                 YYDEBUG(640, *YYCURSOR);
    6111        9266 :                 yych = *++YYCURSOR;
    6112        9266 :                 if (yych == 'S') goto yy645;
    6113        9255 :                 if (yych == 's') goto yy645;
    6114           0 :                 goto yy150;
    6115             : yy641:
    6116             :                 YYDEBUG(641, *YYCURSOR);
    6117         408 :                 yych = *++YYCURSOR;
    6118         408 :                 if (yych == 'N') goto yy642;
    6119         406 :                 if (yych != 'n') goto yy150;
    6120             : yy642:
    6121             :                 YYDEBUG(642, *YYCURSOR);
    6122         126 :                 yych = *++YYCURSOR;
    6123         126 :                 if (yych == 'E') goto yy643;
    6124         124 :                 if (yych != 'e') goto yy150;
    6125             : yy643:
    6126             :                 YYDEBUG(643, *YYCURSOR);
    6127         126 :                 ++YYCURSOR;
    6128         126 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6129           0 :                         goto yy149;
    6130             :                 }
    6131             :                 YYDEBUG(644, *YYCURSOR);
    6132         126 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6133             : #line 1316 "Zend/zend_language_scanner.l"
    6134             :                 {
    6135             :         RETURN_TOKEN(T_CLONE);
    6136             : }
    6137             : #line 6138 "Zend/zend_language_scanner.c"
    6138             : yy645:
    6139             :                 YYDEBUG(645, *YYCURSOR);
    6140        9266 :                 yych = *++YYCURSOR;
    6141        9266 :                 if (yych == 'S') goto yy646;
    6142        9255 :                 if (yych != 's') goto yy150;
    6143             : yy646:
    6144             :                 YYDEBUG(646, *YYCURSOR);
    6145        9266 :                 ++YYCURSOR;
    6146        9266 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6147        1695 :                         goto yy149;
    6148             :                 }
    6149             :                 YYDEBUG(647, *YYCURSOR);
    6150        7571 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6151             : #line 1250 "Zend/zend_language_scanner.l"
    6152             :                 {
    6153             :         RETURN_TOKEN(T_CLASS);
    6154             : }
    6155             : #line 6156 "Zend/zend_language_scanner.c"
    6156             : yy648:
    6157             :                 YYDEBUG(648, *YYCURSOR);
    6158        2689 :                 yych = *++YYCURSOR;
    6159        2689 :                 if (yych == 'C') goto yy659;
    6160        2680 :                 if (yych == 'c') goto yy659;
    6161           2 :                 goto yy150;
    6162             : yy649:
    6163             :                 YYDEBUG(649, *YYCURSOR);
    6164        2968 :                 yych = *++YYCURSOR;
    6165        2968 :                 if (yych == 'E') goto yy657;
    6166        1638 :                 if (yych == 'e') goto yy657;
    6167           2 :                 goto yy150;
    6168             : yy650:
    6169             :                 YYDEBUG(650, *YYCURSOR);
    6170         453 :                 yych = *++YYCURSOR;
    6171         453 :                 if (yych == 'L') goto yy651;
    6172         446 :                 if (yych != 'l') goto yy150;
    6173             : yy651:
    6174             :                 YYDEBUG(651, *YYCURSOR);
    6175         347 :                 yych = *++YYCURSOR;
    6176         347 :                 if (yych == 'A') goto yy652;
    6177         345 :                 if (yych != 'a') goto yy150;
    6178             : yy652:
    6179             :                 YYDEBUG(652, *YYCURSOR);
    6180          21 :                 yych = *++YYCURSOR;
    6181          21 :                 if (yych == 'B') goto yy653;
    6182          19 :                 if (yych != 'b') goto yy150;
    6183             : yy653:
    6184             :                 YYDEBUG(653, *YYCURSOR);
    6185          21 :                 yych = *++YYCURSOR;
    6186          21 :                 if (yych == 'L') goto yy654;
    6187          19 :                 if (yych != 'l') goto yy150;
    6188             : yy654:
    6189             :                 YYDEBUG(654, *YYCURSOR);
    6190          21 :                 yych = *++YYCURSOR;
    6191          21 :                 if (yych == 'E') goto yy655;
    6192          19 :                 if (yych != 'e') goto yy150;
    6193             : yy655:
    6194             :                 YYDEBUG(655, *YYCURSOR);
    6195          21 :                 ++YYCURSOR;
    6196          21 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6197           0 :                         goto yy149;
    6198             :                 }
    6199             :                 YYDEBUG(656, *YYCURSOR);
    6200          21 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6201             : #line 1440 "Zend/zend_language_scanner.l"
    6202             :                 {
    6203             :         RETURN_TOKEN(T_CALLABLE);
    6204             : }
    6205             : #line 6206 "Zend/zend_language_scanner.c"
    6206             : yy657:
    6207             :                 YYDEBUG(657, *YYCURSOR);
    6208        2966 :                 ++YYCURSOR;
    6209        2966 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6210        1352 :                         goto yy149;
    6211             :                 }
    6212             :                 YYDEBUG(658, *YYCURSOR);
    6213        1614 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6214             : #line 1222 "Zend/zend_language_scanner.l"
    6215             :                 {
    6216             :         RETURN_TOKEN(T_CASE);
    6217             : }
    6218             : #line 6219 "Zend/zend_language_scanner.c"
    6219             : yy659:
    6220             :                 YYDEBUG(659, *YYCURSOR);
    6221        2687 :                 yych = *++YYCURSOR;
    6222        2687 :                 if (yych == 'H') goto yy660;
    6223        2678 :                 if (yych != 'h') goto yy150;
    6224             : yy660:
    6225             :                 YYDEBUG(660, *YYCURSOR);
    6226        2687 :                 ++YYCURSOR;
    6227        2687 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6228          10 :                         goto yy149;
    6229             :                 }
    6230             :                 YYDEBUG(661, *YYCURSOR);
    6231        2677 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6232             : #line 1142 "Zend/zend_language_scanner.l"
    6233             :                 {
    6234             :         RETURN_TOKEN(T_CATCH);
    6235             : }
    6236             : #line 6237 "Zend/zend_language_scanner.c"
    6237             : yy662:
    6238             :                 YYDEBUG(662, *YYCURSOR);
    6239        7634 :                 yych = *++YYCURSOR;
    6240        7634 :                 if (yych == 'N') goto yy679;
    6241        7630 :                 if (yych == 'n') goto yy679;
    6242        7333 :                 goto yy150;
    6243             : yy663:
    6244             :                 YYDEBUG(663, *YYCURSOR);
    6245       18600 :                 yych = *++YYCURSOR;
    6246       18600 :                 if (yych == 'R') goto yy672;
    6247       18575 :                 if (yych == 'r') goto yy672;
    6248        4606 :                 goto yy150;
    6249             : yy664:
    6250             :                 YYDEBUG(664, *YYCURSOR);
    6251       43007 :                 yych = *++YYCURSOR;
    6252       43007 :                 if (yych == 'N') goto yy665;
    6253       43003 :                 if (yych != 'n') goto yy150;
    6254             : yy665:
    6255             :                 YYDEBUG(665, *YYCURSOR);
    6256       42954 :                 yych = *++YYCURSOR;
    6257       42954 :                 if (yych == 'C') goto yy666;
    6258       42950 :                 if (yych != 'c') goto yy150;
    6259             : yy666:
    6260             :                 YYDEBUG(666, *YYCURSOR);
    6261       42953 :                 yych = *++YYCURSOR;
    6262       42953 :                 if (yych == 'T') goto yy667;
    6263       42949 :                 if (yych != 't') goto yy150;
    6264             : yy667:
    6265             :                 YYDEBUG(667, *YYCURSOR);
    6266       42028 :                 yych = *++YYCURSOR;
    6267       42028 :                 if (yych == 'I') goto yy668;
    6268       42024 :                 if (yych != 'i') goto yy150;
    6269             : yy668:
    6270             :                 YYDEBUG(668, *YYCURSOR);
    6271       42028 :                 yych = *++YYCURSOR;
    6272       42028 :                 if (yych == 'O') goto yy669;
    6273       42024 :                 if (yych != 'o') goto yy150;
    6274             : yy669:
    6275             :                 YYDEBUG(669, *YYCURSOR);
    6276       42028 :                 yych = *++YYCURSOR;
    6277       42028 :                 if (yych == 'N') goto yy670;
    6278       42024 :                 if (yych != 'n') goto yy150;
    6279             : yy670:
    6280             :                 YYDEBUG(670, *YYCURSOR);
    6281       42028 :                 ++YYCURSOR;
    6282       42028 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6283        3898 :                         goto yy149;
    6284             :                 }
    6285             :                 YYDEBUG(671, *YYCURSOR);
    6286       38130 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6287             : #line 1118 "Zend/zend_language_scanner.l"
    6288             :                 {
    6289             :         RETURN_TOKEN(T_FUNCTION);
    6290             : }
    6291             : #line 6292 "Zend/zend_language_scanner.c"
    6292             : yy672:
    6293             :                 YYDEBUG(672, *YYCURSOR);
    6294       13994 :                 ++YYCURSOR;
    6295       13994 :                 if ((yych = *YYCURSOR) <= '^') {
    6296        2200 :                         if (yych <= '@') {
    6297        2172 :                                 if (yych <= '/') goto yy673;
    6298           0 :                                 if (yych <= '9') goto yy149;
    6299             :                         } else {
    6300          28 :                                 if (yych == 'E') goto yy674;
    6301          25 :                                 if (yych <= 'Z') goto yy149;
    6302             :                         }
    6303             :                 } else {
    6304       11794 :                         if (yych <= 'd') {
    6305         124 :                                 if (yych != '`') goto yy149;
    6306             :                         } else {
    6307       11670 :                                 if (yych <= 'e') goto yy674;
    6308         108 :                                 if (yych <= 'z') goto yy149;
    6309           0 :                                 if (yych >= 0x7F) goto yy149;
    6310             :                         }
    6311             :                 }
    6312             : yy673:
    6313             :                 YYDEBUG(673, *YYCURSOR);
    6314        2172 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6315             : #line 1182 "Zend/zend_language_scanner.l"
    6316             :                 {
    6317             :         RETURN_TOKEN(T_FOR);
    6318             : }
    6319             : #line 6320 "Zend/zend_language_scanner.c"
    6320             : yy674:
    6321             :                 YYDEBUG(674, *YYCURSOR);
    6322       11565 :                 yych = *++YYCURSOR;
    6323       11565 :                 if (yych == 'A') goto yy675;
    6324       11562 :                 if (yych != 'a') goto yy150;
    6325             : yy675:
    6326             :                 YYDEBUG(675, *YYCURSOR);
    6327       11565 :                 yych = *++YYCURSOR;
    6328       11565 :                 if (yych == 'C') goto yy676;
    6329       11562 :                 if (yych != 'c') goto yy150;
    6330             : yy676:
    6331             :                 YYDEBUG(676, *YYCURSOR);
    6332       11565 :                 yych = *++YYCURSOR;
    6333       11565 :                 if (yych == 'H') goto yy677;
    6334       11562 :                 if (yych != 'h') goto yy150;
    6335             : yy677:
    6336             :                 YYDEBUG(677, *YYCURSOR);
    6337       11565 :                 ++YYCURSOR;
    6338       11565 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6339           0 :                         goto yy149;
    6340             :                 }
    6341             :                 YYDEBUG(678, *YYCURSOR);
    6342       11565 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6343             : #line 1190 "Zend/zend_language_scanner.l"
    6344             :                 {
    6345             :         RETURN_TOKEN(T_FOREACH);
    6346             : }
    6347             : #line 6348 "Zend/zend_language_scanner.c"
    6348             : yy679:
    6349             :                 YYDEBUG(679, *YYCURSOR);
    6350         301 :                 yych = *++YYCURSOR;
    6351         301 :                 if (yych == 'A') goto yy680;
    6352         297 :                 if (yych != 'a') goto yy150;
    6353             : yy680:
    6354             :                 YYDEBUG(680, *YYCURSOR);
    6355         177 :                 yych = *++YYCURSOR;
    6356         177 :                 if (yych == 'L') goto yy681;
    6357         173 :                 if (yych != 'l') goto yy150;
    6358             : yy681:
    6359             :                 YYDEBUG(681, *YYCURSOR);
    6360         177 :                 ++YYCURSOR;
    6361         177 :                 if ((yych = *YYCURSOR) <= '^') {
    6362          64 :                         if (yych <= '@') {
    6363          53 :                                 if (yych <= '/') goto yy682;
    6364           1 :                                 if (yych <= '9') goto yy149;
    6365             :                         } else {
    6366          11 :                                 if (yych == 'L') goto yy683;
    6367           9 :                                 if (yych <= 'Z') goto yy149;
    6368             :                         }
    6369             :                 } else {
    6370         113 :                         if (yych <= 'k') {
    6371           1 :                                 if (yych != '`') goto yy149;
    6372             :                         } else {
    6373         112 :                                 if (yych <= 'l') goto yy683;
    6374           0 :                                 if (yych <= 'z') goto yy149;
    6375           0 :                                 if (yych >= 0x7F) goto yy149;
    6376             :                         }
    6377             :                 }
    6378             : yy682:
    6379             :                 YYDEBUG(682, *YYCURSOR);
    6380          53 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6381             : #line 1408 "Zend/zend_language_scanner.l"
    6382             :                 {
    6383             :         RETURN_TOKEN(T_FINAL);
    6384             : }
    6385             : #line 6386 "Zend/zend_language_scanner.c"
    6386             : yy683:
    6387             :                 YYDEBUG(683, *YYCURSOR);
    6388         114 :                 yych = *++YYCURSOR;
    6389         114 :                 if (yych == 'Y') goto yy684;
    6390         112 :                 if (yych != 'y') goto yy150;
    6391             : yy684:
    6392             :                 YYDEBUG(684, *YYCURSOR);
    6393         114 :                 ++YYCURSOR;
    6394         114 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6395           0 :                         goto yy149;
    6396             :                 }
    6397             :                 YYDEBUG(685, *YYCURSOR);
    6398         114 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6399             : #line 1146 "Zend/zend_language_scanner.l"
    6400             :                 {
    6401             :         RETURN_TOKEN(T_FINALLY);
    6402             : }
    6403             : #line 6404 "Zend/zend_language_scanner.c"
    6404             : yy686:
    6405             :                 YYDEBUG(686, *YYCURSOR);
    6406        5775 :                 yych = *++YYCURSOR;
    6407        5775 :                 if (yych <= 'F') {
    6408          56 :                         if (yych == 'C') goto yy692;
    6409          26 :                         if (yych <= 'E') goto yy150;
    6410          16 :                         goto yy693;
    6411             :                 } else {
    6412        5719 :                         if (yych <= 'c') {
    6413         407 :                                 if (yych <= 'b') goto yy150;
    6414         264 :                                 goto yy692;
    6415             :                         } else {
    6416        5312 :                                 if (yych == 'f') goto yy693;
    6417        1342 :                                 goto yy150;
    6418             :                         }
    6419             :                 }
    6420             : yy687:
    6421             :                 YYDEBUG(687, *YYCURSOR);
    6422       26319 :                 yych = *++YYCURSOR;
    6423       26319 :                 if (yych == 'E') goto yy690;
    6424       26317 :                 if (yych == 'e') goto yy690;
    6425       11323 :                 goto yy150;
    6426             : yy688:
    6427             :                 YYDEBUG(688, *YYCURSOR);
    6428        1062 :                 ++YYCURSOR;
    6429        1062 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6430         757 :                         goto yy149;
    6431             :                 }
    6432             :                 YYDEBUG(689, *YYCURSOR);
    6433         305 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6434             : #line 1178 "Zend/zend_language_scanner.l"
    6435             :                 {
    6436             :         RETURN_TOKEN(T_DO);
    6437             : }
    6438             : #line 6439 "Zend/zend_language_scanner.c"
    6439             : yy690:
    6440             :                 YYDEBUG(690, *YYCURSOR);
    6441       14996 :                 ++YYCURSOR;
    6442       14996 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6443           0 :                         goto yy149;
    6444             :                 }
    6445             :                 YYDEBUG(691, *YYCURSOR);
    6446       14996 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6447             : #line 1114 "Zend/zend_language_scanner.l"
    6448             :                 {
    6449             :         RETURN_TOKEN(T_EXIT);
    6450             : }
    6451             : #line 6452 "Zend/zend_language_scanner.c"
    6452             : yy692:
    6453             :                 YYDEBUG(692, *YYCURSOR);
    6454         294 :                 yych = *++YYCURSOR;
    6455         294 :                 if (yych == 'L') goto yy699;
    6456         290 :                 if (yych == 'l') goto yy699;
    6457         218 :                 goto yy150;
    6458             : yy693:
    6459             :                 YYDEBUG(693, *YYCURSOR);
    6460        3986 :                 yych = *++YYCURSOR;
    6461        3986 :                 if (yych == 'A') goto yy694;
    6462        3981 :                 if (yych != 'a') goto yy150;
    6463             : yy694:
    6464             :                 YYDEBUG(694, *YYCURSOR);
    6465         292 :                 yych = *++YYCURSOR;
    6466         292 :                 if (yych == 'U') goto yy695;
    6467         287 :                 if (yych != 'u') goto yy150;
    6468             : yy695:
    6469             :                 YYDEBUG(695, *YYCURSOR);
    6470         292 :                 yych = *++YYCURSOR;
    6471         292 :                 if (yych == 'L') goto yy696;
    6472         287 :                 if (yych != 'l') goto yy150;
    6473             : yy696:
    6474             :                 YYDEBUG(696, *YYCURSOR);
    6475         292 :                 yych = *++YYCURSOR;
    6476         292 :                 if (yych == 'T') goto yy697;
    6477         287 :                 if (yych != 't') goto yy150;
    6478             : yy697:
    6479             :                 YYDEBUG(697, *YYCURSOR);
    6480         292 :                 ++YYCURSOR;
    6481         292 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6482           5 :                         goto yy149;
    6483             :                 }
    6484             :                 YYDEBUG(698, *YYCURSOR);
    6485         287 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6486             : #line 1226 "Zend/zend_language_scanner.l"
    6487             :                 {
    6488             :         RETURN_TOKEN(T_DEFAULT);
    6489             : }
    6490             : #line 6491 "Zend/zend_language_scanner.c"
    6491             : yy699:
    6492             :                 YYDEBUG(699, *YYCURSOR);
    6493          76 :                 yych = *++YYCURSOR;
    6494          76 :                 if (yych == 'A') goto yy700;
    6495          72 :                 if (yych != 'a') goto yy150;
    6496             : yy700:
    6497             :                 YYDEBUG(700, *YYCURSOR);
    6498          76 :                 yych = *++YYCURSOR;
    6499          76 :                 if (yych == 'R') goto yy701;
    6500          72 :                 if (yych != 'r') goto yy150;
    6501             : yy701:
    6502             :                 YYDEBUG(701, *YYCURSOR);
    6503          76 :                 yych = *++YYCURSOR;
    6504          76 :                 if (yych == 'E') goto yy702;
    6505          72 :                 if (yych != 'e') goto yy150;
    6506             : yy702:
    6507             :                 YYDEBUG(702, *YYCURSOR);
    6508          76 :                 ++YYCURSOR;
    6509          76 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6510           0 :                         goto yy149;
    6511             :                 }
    6512             :                 YYDEBUG(703, *YYCURSOR);
    6513          76 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6514             : #line 1198 "Zend/zend_language_scanner.l"
    6515             :                 {
    6516             :         RETURN_TOKEN(T_DECLARE);
    6517             : }
    6518             : #line 6519 "Zend/zend_language_scanner.c"
    6519             : yy704:
    6520             :                 YYDEBUG(704, *YYCURSOR);
    6521       37448 :                 yych = *++YYCURSOR;
    6522       37448 :                 if (yych == 'H') goto yy766;
    6523       37446 :                 if (yych == 'h') goto yy766;
    6524           0 :                 goto yy150;
    6525             : yy705:
    6526             :                 YYDEBUG(705, *YYCURSOR);
    6527       22373 :                 yych = *++YYCURSOR;
    6528       22373 :                 if (yych == 'S') goto yy760;
    6529       22369 :                 if (yych == 's') goto yy760;
    6530          13 :                 goto yy150;
    6531             : yy706:
    6532             :                 YYDEBUG(706, *YYCURSOR);
    6533        8027 :                 yych = *++YYCURSOR;
    6534        8027 :                 if (yych == 'P') goto yy756;
    6535        8025 :                 if (yych == 'p') goto yy756;
    6536           0 :                 goto yy150;
    6537             : yy707:
    6538             :                 YYDEBUG(707, *YYCURSOR);
    6539         710 :                 yych = *++YYCURSOR;
    6540         710 :                 if (yych == 'D') goto yy722;
    6541         695 :                 if (yych == 'd') goto yy722;
    6542         606 :                 goto yy150;
    6543             : yy708:
    6544             :                 YYDEBUG(708, *YYCURSOR);
    6545        2326 :                 yych = *++YYCURSOR;
    6546        2326 :                 if (yych == 'A') goto yy719;
    6547        2326 :                 if (yych == 'a') goto yy719;
    6548           4 :                 goto yy150;
    6549             : yy709:
    6550             :                 YYDEBUG(709, *YYCURSOR);
    6551       16100 :                 yych = *++YYCURSOR;
    6552       16100 :                 if (yych <= 'T') {
    6553          78 :                         if (yych == 'I') goto yy710;
    6554          74 :                         if (yych <= 'S') goto yy150;
    6555          70 :                         goto yy711;
    6556             :                 } else {
    6557       16022 :                         if (yych <= 'i') {
    6558        4468 :                                 if (yych <= 'h') goto yy150;
    6559             :                         } else {
    6560       11554 :                                 if (yych == 't') goto yy711;
    6561        1084 :                                 goto yy150;
    6562             :                         }
    6563             :                 }
    6564             : yy710:
    6565             :                 YYDEBUG(710, *YYCURSOR);
    6566        1623 :                 yych = *++YYCURSOR;
    6567        1623 :                 if (yych == 'T') goto yy717;
    6568        1621 :                 if (yych == 't') goto yy717;
    6569          50 :                 goto yy150;
    6570             : yy711:
    6571             :                 YYDEBUG(711, *YYCURSOR);
    6572       10540 :                 yych = *++YYCURSOR;
    6573       10540 :                 if (yych == 'E') goto yy712;
    6574       10538 :                 if (yych != 'e') goto yy150;
    6575             : yy712:
    6576             :                 YYDEBUG(712, *YYCURSOR);
    6577        9645 :                 yych = *++YYCURSOR;
    6578        9645 :                 if (yych == 'N') goto yy713;
    6579        9643 :                 if (yych != 'n') goto yy150;
    6580             : yy713:
    6581             :                 YYDEBUG(713, *YYCURSOR);
    6582        9645 :                 yych = *++YYCURSOR;
    6583        9645 :                 if (yych == 'D') goto yy714;
    6584        9643 :                 if (yych != 'd') goto yy150;
    6585             : yy714:
    6586             :                 YYDEBUG(714, *YYCURSOR);
    6587        2527 :                 yych = *++YYCURSOR;
    6588        2527 :                 if (yych == 'S') goto yy715;
    6589        2525 :                 if (yych != 's') goto yy150;
    6590             : yy715:
    6591             :                 YYDEBUG(715, *YYCURSOR);
    6592        2489 :                 ++YYCURSOR;
    6593        2489 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6594          10 :                         goto yy149;
    6595             :                 }
    6596             :                 YYDEBUG(716, *YYCURSOR);
    6597        2479 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6598             : #line 1262 "Zend/zend_language_scanner.l"
    6599             :                 {
    6600             :         RETURN_TOKEN(T_EXTENDS);
    6601             : }
    6602             : #line 6603 "Zend/zend_language_scanner.c"
    6603             : yy717:
    6604             :                 YYDEBUG(717, *YYCURSOR);
    6605        1573 :                 ++YYCURSOR;
    6606        1573 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6607           0 :                         goto yy149;
    6608             :                 }
    6609             :                 YYDEBUG(718, *YYCURSOR);
    6610        1573 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6611             : #line 1110 "Zend/zend_language_scanner.l"
    6612             :                 {
    6613             :         RETURN_TOKEN(T_EXIT);
    6614             : }
    6615             : #line 6616 "Zend/zend_language_scanner.c"
    6616             : yy719:
    6617             :                 YYDEBUG(719, *YYCURSOR);
    6618        2322 :                 yych = *++YYCURSOR;
    6619        2322 :                 if (yych == 'L') goto yy720;
    6620        2322 :                 if (yych != 'l') goto yy150;
    6621             : yy720:
    6622             :                 YYDEBUG(720, *YYCURSOR);
    6623        2322 :                 ++YYCURSOR;
    6624        2322 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6625           2 :                         goto yy149;
    6626             :                 }
    6627             :                 YYDEBUG(721, *YYCURSOR);
    6628        2320 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6629             : #line 1352 "Zend/zend_language_scanner.l"
    6630             :                 {
    6631             :         RETURN_TOKEN(T_EVAL);
    6632             : }
    6633             : #line 6634 "Zend/zend_language_scanner.c"
    6634             : yy722:
    6635             :                 YYDEBUG(722, *YYCURSOR);
    6636         104 :                 yych = *++YYCURSOR;
    6637             :                 YYDEBUG(-1, yych);
    6638         104 :                 switch (yych) {
    6639             :                 case 'D':
    6640           5 :                 case 'd':       goto yy723;
    6641             :                 case 'F':
    6642          13 :                 case 'f':       goto yy724;
    6643             :                 case 'I':
    6644          14 :                 case 'i':       goto yy725;
    6645             :                 case 'S':
    6646           6 :                 case 's':       goto yy726;
    6647             :                 case 'W':
    6648           6 :                 case 'w':       goto yy727;
    6649          60 :                 default:        goto yy150;
    6650             :                 }
    6651             : yy723:
    6652             :                 YYDEBUG(723, *YYCURSOR);
    6653           5 :                 yych = *++YYCURSOR;
    6654           5 :                 if (yych == 'E') goto yy749;
    6655           3 :                 if (yych == 'e') goto yy749;
    6656           0 :                 goto yy150;
    6657             : yy724:
    6658             :                 YYDEBUG(724, *YYCURSOR);
    6659          13 :                 yych = *++YYCURSOR;
    6660          13 :                 if (yych == 'O') goto yy741;
    6661           9 :                 if (yych == 'o') goto yy741;
    6662           0 :                 goto yy150;
    6663             : yy725:
    6664             :                 YYDEBUG(725, *YYCURSOR);
    6665          14 :                 yych = *++YYCURSOR;
    6666          14 :                 if (yych == 'F') goto yy739;
    6667          12 :                 if (yych == 'f') goto yy739;
    6668           4 :                 goto yy150;
    6669             : yy726:
    6670             :                 YYDEBUG(726, *YYCURSOR);
    6671           6 :                 yych = *++YYCURSOR;
    6672           6 :                 if (yych == 'W') goto yy733;
    6673           4 :                 if (yych == 'w') goto yy733;
    6674           0 :                 goto yy150;
    6675             : yy727:
    6676             :                 YYDEBUG(727, *YYCURSOR);
    6677           6 :                 yych = *++YYCURSOR;
    6678           6 :                 if (yych == 'H') goto yy728;
    6679           4 :                 if (yych != 'h') goto yy150;
    6680             : yy728:
    6681             :                 YYDEBUG(728, *YYCURSOR);
    6682           6 :                 yych = *++YYCURSOR;
    6683           6 :                 if (yych == 'I') goto yy729;
    6684           4 :                 if (yych != 'i') goto yy150;
    6685             : yy729:
    6686             :                 YYDEBUG(729, *YYCURSOR);
    6687           6 :                 yych = *++YYCURSOR;
    6688           6 :                 if (yych == 'L') goto yy730;
    6689           4 :                 if (yych != 'l') goto yy150;
    6690             : yy730:
    6691             :                 YYDEBUG(730, *YYCURSOR);
    6692           6 :                 yych = *++YYCURSOR;
    6693           6 :                 if (yych == 'E') goto yy731;
    6694           4 :                 if (yych != 'e') goto yy150;
    6695             : yy731:
    6696             :                 YYDEBUG(731, *YYCURSOR);
    6697           6 :                 ++YYCURSOR;
    6698           6 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6699           0 :                         goto yy149;
    6700             :                 }
    6701             :                 YYDEBUG(732, *YYCURSOR);
    6702           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6703             : #line 1174 "Zend/zend_language_scanner.l"
    6704             :                 {
    6705             :         RETURN_TOKEN(T_ENDWHILE);
    6706             : }
    6707             : #line 6708 "Zend/zend_language_scanner.c"
    6708             : yy733:
    6709             :                 YYDEBUG(733, *YYCURSOR);
    6710           6 :                 yych = *++YYCURSOR;
    6711           6 :                 if (yych == 'I') goto yy734;
    6712           4 :                 if (yych != 'i') goto yy150;
    6713             : yy734:
    6714             :                 YYDEBUG(734, *YYCURSOR);
    6715           6 :                 yych = *++YYCURSOR;
    6716           6 :                 if (yych == 'T') goto yy735;
    6717           4 :                 if (yych != 't') goto yy150;
    6718             : yy735:
    6719             :                 YYDEBUG(735, *YYCURSOR);
    6720           6 :                 yych = *++YYCURSOR;
    6721           6 :                 if (yych == 'C') goto yy736;
    6722           4 :                 if (yych != 'c') goto yy150;
    6723             : yy736:
    6724             :                 YYDEBUG(736, *YYCURSOR);
    6725           6 :                 yych = *++YYCURSOR;
    6726           6 :                 if (yych == 'H') goto yy737;
    6727           4 :                 if (yych != 'h') goto yy150;
    6728             : yy737:
    6729             :                 YYDEBUG(737, *YYCURSOR);
    6730           6 :                 ++YYCURSOR;
    6731           6 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6732           0 :                         goto yy149;
    6733             :                 }
    6734             :                 YYDEBUG(738, *YYCURSOR);
    6735           6 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6736             : #line 1218 "Zend/zend_language_scanner.l"
    6737             :                 {
    6738             :         RETURN_TOKEN(T_ENDSWITCH);
    6739             : }
    6740             : #line 6741 "Zend/zend_language_scanner.c"
    6741             : yy739:
    6742             :                 YYDEBUG(739, *YYCURSOR);
    6743          10 :                 ++YYCURSOR;
    6744          10 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6745           0 :                         goto yy149;
    6746             :                 }
    6747             :                 YYDEBUG(740, *YYCURSOR);
    6748          10 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6749             : #line 1162 "Zend/zend_language_scanner.l"
    6750             :                 {
    6751             :         RETURN_TOKEN(T_ENDIF);
    6752             : }
    6753             : #line 6754 "Zend/zend_language_scanner.c"
    6754             : yy741:
    6755             :                 YYDEBUG(741, *YYCURSOR);
    6756          13 :                 yych = *++YYCURSOR;
    6757          13 :                 if (yych == 'R') goto yy742;
    6758           9 :                 if (yych != 'r') goto yy150;
    6759             : yy742:
    6760             :                 YYDEBUG(742, *YYCURSOR);
    6761          13 :                 ++YYCURSOR;
    6762          13 :                 if ((yych = *YYCURSOR) <= '^') {
    6763          10 :                         if (yych <= '@') {
    6764           8 :                                 if (yych <= '/') goto yy743;
    6765           3 :                                 if (yych <= '9') goto yy149;
    6766             :                         } else {
    6767           2 :                                 if (yych == 'E') goto yy744;
    6768           0 :                                 if (yych <= 'Z') goto yy149;
    6769             :                         }
    6770             :                 } else {
    6771           3 :                         if (yych <= 'd') {
    6772           0 :                                 if (yych != '`') goto yy149;
    6773             :                         } else {
    6774           3 :                                 if (yych <= 'e') goto yy744;
    6775           0 :                                 if (yych <= 'z') goto yy149;
    6776           0 :                                 if (yych >= 0x7F) goto yy149;
    6777             :                         }
    6778             :                 }
    6779             : yy743:
    6780             :                 YYDEBUG(743, *YYCURSOR);
    6781           8 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6782             : #line 1186 "Zend/zend_language_scanner.l"
    6783             :                 {
    6784             :         RETURN_TOKEN(T_ENDFOR);
    6785             : }
    6786             : #line 6787 "Zend/zend_language_scanner.c"
    6787             : yy744:
    6788             :                 YYDEBUG(744, *YYCURSOR);
    6789           5 :                 yych = *++YYCURSOR;
    6790           5 :                 if (yych == 'A') goto yy745;
    6791           3 :                 if (yych != 'a') goto yy150;
    6792             : yy745:
    6793             :                 YYDEBUG(745, *YYCURSOR);
    6794           5 :                 yych = *++YYCURSOR;
    6795           5 :                 if (yych == 'C') goto yy746;
    6796           3 :                 if (yych != 'c') goto yy150;
    6797             : yy746:
    6798             :                 YYDEBUG(746, *YYCURSOR);
    6799           5 :                 yych = *++YYCURSOR;
    6800           5 :                 if (yych == 'H') goto yy747;
    6801           3 :                 if (yych != 'h') goto yy150;
    6802             : yy747:
    6803             :                 YYDEBUG(747, *YYCURSOR);
    6804           5 :                 ++YYCURSOR;
    6805           5 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6806           0 :                         goto yy149;
    6807             :                 }
    6808             :                 YYDEBUG(748, *YYCURSOR);
    6809           5 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6810             : #line 1194 "Zend/zend_language_scanner.l"
    6811             :                 {
    6812             :         RETURN_TOKEN(T_ENDFOREACH);
    6813             : }
    6814             : #line 6815 "Zend/zend_language_scanner.c"
    6815             : yy749:
    6816             :                 YYDEBUG(749, *YYCURSOR);
    6817           5 :                 yych = *++YYCURSOR;
    6818           5 :                 if (yych == 'C') goto yy750;
    6819           3 :                 if (yych != 'c') goto yy150;
    6820             : yy750:
    6821             :                 YYDEBUG(750, *YYCURSOR);
    6822           5 :                 yych = *++YYCURSOR;
    6823           5 :                 if (yych == 'L') goto yy751;
    6824           3 :                 if (yych != 'l') goto yy150;
    6825             : yy751:
    6826             :                 YYDEBUG(751, *YYCURSOR);
    6827           5 :                 yych = *++YYCURSOR;
    6828           5 :                 if (yych == 'A') goto yy752;
    6829           3 :                 if (yych != 'a') goto yy150;
    6830             : yy752:
    6831             :                 YYDEBUG(752, *YYCURSOR);
    6832           5 :                 yych = *++YYCURSOR;
    6833           5 :                 if (yych == 'R') goto yy753;
    6834           3 :                 if (yych != 'r') goto yy150;
    6835             : yy753:
    6836             :                 YYDEBUG(753, *YYCURSOR);
    6837           5 :                 yych = *++YYCURSOR;
    6838           5 :                 if (yych == 'E') goto yy754;
    6839           3 :                 if (yych != 'e') goto yy150;
    6840             : yy754:
    6841             :                 YYDEBUG(754, *YYCURSOR);
    6842           5 :                 ++YYCURSOR;
    6843           5 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6844           0 :                         goto yy149;
    6845             :                 }
    6846             :                 YYDEBUG(755, *YYCURSOR);
    6847           5 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6848             : #line 1202 "Zend/zend_language_scanner.l"
    6849             :                 {
    6850             :         RETURN_TOKEN(T_ENDDECLARE);
    6851             : }
    6852             : #line 6853 "Zend/zend_language_scanner.c"
    6853             : yy756:
    6854             :                 YYDEBUG(756, *YYCURSOR);
    6855        8027 :                 yych = *++YYCURSOR;
    6856        8027 :                 if (yych == 'T') goto yy757;
    6857        8025 :                 if (yych != 't') goto yy150;
    6858             : yy757:
    6859             :                 YYDEBUG(757, *YYCURSOR);
    6860        8025 :                 yych = *++YYCURSOR;
    6861        8025 :                 if (yych == 'Y') goto yy758;
    6862        8023 :                 if (yych != 'y') goto yy150;
    6863             : yy758:
    6864             :                 YYDEBUG(758, *YYCURSOR);
    6865        8025 :                 ++YYCURSOR;
    6866        8025 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6867         106 :                         goto yy149;
    6868             :                 }
    6869             :                 YYDEBUG(759, *YYCURSOR);
    6870        7919 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6871             : #line 1392 "Zend/zend_language_scanner.l"
    6872             :                 {
    6873             :         RETURN_TOKEN(T_EMPTY);
    6874             : }
    6875             : #line 6876 "Zend/zend_language_scanner.c"
    6876             : yy760:
    6877             :                 YYDEBUG(760, *YYCURSOR);
    6878       22360 :                 yych = *++YYCURSOR;
    6879       22360 :                 if (yych == 'E') goto yy761;
    6880       22356 :                 if (yych != 'e') goto yy150;
    6881             : yy761:
    6882             :                 YYDEBUG(761, *YYCURSOR);
    6883       22360 :                 ++YYCURSOR;
    6884       22360 :                 if ((yych = *YYCURSOR) <= '^') {
    6885       20364 :                         if (yych <= '@') {
    6886       20362 :                                 if (yych <= '/') goto yy762;
    6887           2 :                                 if (yych <= '9') goto yy149;
    6888             :                         } else {
    6889           2 :                                 if (yych == 'I') goto yy763;
    6890           0 :                                 if (yych <= 'Z') goto yy149;
    6891             :                         }
    6892             :                 } else {
    6893        1996 :                         if (yych <= 'h') {
    6894           0 :                                 if (yych != '`') goto yy149;
    6895             :                         } else {
    6896        1996 :                                 if (yych <= 'i') goto yy763;
    6897          61 :                                 if (yych <= 'z') goto yy149;
    6898          61 :                                 if (yych >= 0x7F) goto yy149;
    6899             :                         }
    6900             :                 }
    6901             : yy762:
    6902             :                 YYDEBUG(762, *YYCURSOR);
    6903       20423 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6904             : #line 1166 "Zend/zend_language_scanner.l"
    6905             :                 {
    6906             :         RETURN_TOKEN(T_ELSE);
    6907             : }
    6908             : #line 6909 "Zend/zend_language_scanner.c"
    6909             : yy763:
    6910             :                 YYDEBUG(763, *YYCURSOR);
    6911        1937 :                 yych = *++YYCURSOR;
    6912        1937 :                 if (yych == 'F') goto yy764;
    6913        1935 :                 if (yych != 'f') goto yy150;
    6914             : yy764:
    6915             :                 YYDEBUG(764, *YYCURSOR);
    6916        1937 :                 ++YYCURSOR;
    6917        1937 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6918           0 :                         goto yy149;
    6919             :                 }
    6920             :                 YYDEBUG(765, *YYCURSOR);
    6921        1937 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6922             : #line 1158 "Zend/zend_language_scanner.l"
    6923             :                 {
    6924             :         RETURN_TOKEN(T_ELSEIF);
    6925             : }
    6926             : #line 6927 "Zend/zend_language_scanner.c"
    6927             : yy766:
    6928             :                 YYDEBUG(766, *YYCURSOR);
    6929       37448 :                 yych = *++YYCURSOR;
    6930       37448 :                 if (yych == 'O') goto yy767;
    6931       37446 :                 if (yych != 'o') goto yy150;
    6932             : yy767:
    6933             :                 YYDEBUG(767, *YYCURSOR);
    6934       37448 :                 ++YYCURSOR;
    6935       37448 :                 if (yybm[0+(yych = *YYCURSOR)] & 4) {
    6936        3994 :                         goto yy149;
    6937             :                 }
    6938             :                 YYDEBUG(768, *YYCURSOR);
    6939       33454 :                 yyleng = YYCURSOR - SCNG(yy_text);
    6940             : #line 1242 "Zend/zend_language_scanner.l"
    6941             :                 {
    6942             :         RETURN_TOKEN(T_ECHO);
    6943             : }
    6944             : #line 6945 "Zend/zend_language_scanner.c"
    6945             :         }
    6946             : /* *********************************** */
    6947             : yyc_ST_LOOKING_FOR_PROPERTY:
    6948             :         {
    6949             :                 static const unsigned char yybm[] = {
    6950             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    6951             :                           0, 128, 128,   0,   0, 128,   0,   0, 
    6952             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    6953             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    6954             :                         128,   0,   0,   0,   0,   0,   0,   0, 
    6955             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    6956             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6957             :                          64,  64,   0,   0,   0,   0,   0,   0, 
    6958             :                           0,  64,  64,  64,  64,  64,  64,  64, 
    6959             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6960             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6961             :                          64,  64,  64,   0,   0,   0,   0,  64, 
    6962             :                           0,  64,  64,  64,  64,  64,  64,  64, 
    6963             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6964             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6965             :                          64,  64,  64,   0,   0,   0,   0,  64, 
    6966             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6967             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6968             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6969             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6970             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6971             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6972             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6973             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6974             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6975             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6976             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6977             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6978             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6979             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6980             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6981             :                          64,  64,  64,  64,  64,  64,  64,  64, 
    6982             :                 };
    6983             :                 YYDEBUG(769, *YYCURSOR);
    6984       49180 :                 YYFILL(2);
    6985       49180 :                 yych = *YYCURSOR;
    6986       49180 :                 if (yych <= '-') {
    6987         272 :                         if (yych <= '\r') {
    6988           0 :                                 if (yych <= 0x08) goto yy777;
    6989           0 :                                 if (yych <= '\n') goto yy771;
    6990           0 :                                 if (yych <= '\f') goto yy777;
    6991             :                         } else {
    6992         272 :                                 if (yych == ' ') goto yy771;
    6993         265 :                                 if (yych <= ',') goto yy777;
    6994          88 :                                 goto yy773;
    6995             :                         }
    6996             :                 } else {
    6997       48908 :                         if (yych <= '_') {
    6998        1240 :                                 if (yych <= '@') goto yy777;
    6999        1240 :                                 if (yych <= 'Z') goto yy775;
    7000         767 :                                 if (yych <= '^') goto yy777;
    7001         767 :                                 goto yy775;
    7002             :                         } else {
    7003       47668 :                                 if (yych <= '`') goto yy777;
    7004       47668 :                                 if (yych <= 'z') goto yy775;
    7005          69 :                                 if (yych <= '~') goto yy777;
    7006           0 :                                 goto yy775;
    7007             :                         }
    7008             :                 }
    7009             : yy771:
    7010             :                 YYDEBUG(771, *YYCURSOR);
    7011           7 :                 ++YYCURSOR;
    7012           7 :                 yych = *YYCURSOR;
    7013           7 :                 goto yy783;
    7014             : yy772:
    7015             :                 YYDEBUG(772, *YYCURSOR);
    7016           7 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7017             : #line 1275 "Zend/zend_language_scanner.l"
    7018             :                 {
    7019             :         HANDLE_NEWLINES(yytext, yyleng);
    7020             :         RETURN_TOKEN(T_WHITESPACE);
    7021             : }
    7022             : #line 7023 "Zend/zend_language_scanner.c"
    7023             : yy773:
    7024             :                 YYDEBUG(773, *YYCURSOR);
    7025          88 :                 ++YYCURSOR;
    7026          88 :                 if ((yych = *YYCURSOR) == '>') goto yy780;
    7027             : yy774:
    7028             :                 YYDEBUG(774, *YYCURSOR);
    7029         246 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7030             : #line 1290 "Zend/zend_language_scanner.l"
    7031             :                 {
    7032             :         yyless(0);
    7033             :         yy_pop_state();
    7034             :         goto restart;
    7035             : }
    7036             : #line 7037 "Zend/zend_language_scanner.c"
    7037             : yy775:
    7038             :                 YYDEBUG(775, *YYCURSOR);
    7039       48839 :                 ++YYCURSOR;
    7040       48839 :                 yych = *YYCURSOR;
    7041       48839 :                 goto yy779;
    7042             : yy776:
    7043             :                 YYDEBUG(776, *YYCURSOR);
    7044       48839 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7045             : #line 1284 "Zend/zend_language_scanner.l"
    7046             :                 {
    7047             :         yy_pop_state();
    7048             :         zend_copy_value(zendlval, yytext, yyleng);
    7049             :         RETURN_TOKEN(T_STRING);
    7050             : }
    7051             : #line 7052 "Zend/zend_language_scanner.c"
    7052             : yy777:
    7053             :                 YYDEBUG(777, *YYCURSOR);
    7054         246 :                 yych = *++YYCURSOR;
    7055         246 :                 goto yy774;
    7056             : yy778:
    7057             :                 YYDEBUG(778, *YYCURSOR);
    7058      367946 :                 ++YYCURSOR;
    7059      367946 :                 YYFILL(1);
    7060      367946 :                 yych = *YYCURSOR;
    7061             : yy779:
    7062             :                 YYDEBUG(779, *YYCURSOR);
    7063      416785 :                 if (yybm[0+yych] & 64) {
    7064      367946 :                         goto yy778;
    7065             :                 }
    7066       48839 :                 goto yy776;
    7067             : yy780:
    7068             :                 YYDEBUG(780, *YYCURSOR);
    7069          88 :                 ++YYCURSOR;
    7070             :                 YYDEBUG(781, *YYCURSOR);
    7071          88 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7072             : #line 1280 "Zend/zend_language_scanner.l"
    7073             :                 {
    7074             :         RETURN_TOKEN(T_OBJECT_OPERATOR);
    7075             : }
    7076             : #line 7077 "Zend/zend_language_scanner.c"
    7077             : yy782:
    7078             :                 YYDEBUG(782, *YYCURSOR);
    7079           0 :                 ++YYCURSOR;
    7080           0 :                 YYFILL(1);
    7081           0 :                 yych = *YYCURSOR;
    7082             : yy783:
    7083             :                 YYDEBUG(783, *YYCURSOR);
    7084           7 :                 if (yybm[0+yych] & 128) {
    7085           0 :                         goto yy782;
    7086             :                 }
    7087           7 :                 goto yy772;
    7088             :         }
    7089             : /* *********************************** */
    7090             : yyc_ST_LOOKING_FOR_VARNAME:
    7091             :         {
    7092             :                 static const unsigned char yybm[] = {
    7093             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7094             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7095             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7096             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7097             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7098             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7099             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7100             :                         128, 128,   0,   0,   0,   0,   0,   0, 
    7101             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    7102             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7103             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7104             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    7105             :                           0, 128, 128, 128, 128, 128, 128, 128, 
    7106             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7107             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7108             :                         128, 128, 128,   0,   0,   0,   0, 128, 
    7109             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7110             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7111             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7112             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7113             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7114             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7115             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7116             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7117             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7118             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7119             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7120             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7121             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7122             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7123             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7124             :                         128, 128, 128, 128, 128, 128, 128, 128, 
    7125             :                 };
    7126             :                 YYDEBUG(784, *YYCURSOR);
    7127         380 :                 YYFILL(2);
    7128         380 :                 yych = *YYCURSOR;
    7129         380 :                 if (yych <= '_') {
    7130           3 :                         if (yych <= '@') goto yy788;
    7131           0 :                         if (yych <= 'Z') goto yy786;
    7132           0 :                         if (yych <= '^') goto yy788;
    7133             :                 } else {
    7134         377 :                         if (yych <= '`') goto yy788;
    7135         377 :                         if (yych <= 'z') goto yy786;
    7136           0 :                         if (yych <= '~') goto yy788;
    7137             :                 }
    7138             : yy786:
    7139             :                 YYDEBUG(786, *YYCURSOR);
    7140         377 :                 yyaccept = 0;
    7141         377 :                 yych = *(YYMARKER = ++YYCURSOR);
    7142         377 :                 if (yych <= '_') {
    7143           0 :                         if (yych <= '@') {
    7144           0 :                                 if (yych <= '/') goto yy787;
    7145           0 :                                 if (yych <= '9') goto yy790;
    7146             :                         } else {
    7147           0 :                                 if (yych <= '[') goto yy790;
    7148           0 :                                 if (yych >= '_') goto yy790;
    7149             :                         }
    7150             :                 } else {
    7151         377 :                         if (yych <= '|') {
    7152         376 :                                 if (yych <= '`') goto yy787;
    7153         376 :                                 if (yych <= 'z') goto yy790;
    7154             :                         } else {
    7155           1 :                                 if (yych != '~') goto yy790;
    7156             :                         }
    7157             :                 }
    7158             : yy787:
    7159             :                 YYDEBUG(787, *YYCURSOR);
    7160           4 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7161             : #line 1595 "Zend/zend_language_scanner.l"
    7162             :                 {
    7163             :         yyless(0);
    7164             :         yy_pop_state();
    7165             :         yy_push_state(ST_IN_SCRIPTING);
    7166             :         goto restart;
    7167             : }
    7168             : #line 7169 "Zend/zend_language_scanner.c"
    7169             : yy788:
    7170             :                 YYDEBUG(788, *YYCURSOR);
    7171           3 :                 yych = *++YYCURSOR;
    7172           3 :                 goto yy787;
    7173             : yy789:
    7174             :                 YYDEBUG(789, *YYCURSOR);
    7175        3662 :                 ++YYCURSOR;
    7176        3662 :                 YYFILL(1);
    7177        3662 :                 yych = *YYCURSOR;
    7178             : yy790:
    7179             :                 YYDEBUG(790, *YYCURSOR);
    7180        4039 :                 if (yybm[0+yych] & 128) {
    7181        3662 :                         goto yy789;
    7182             :                 }
    7183         377 :                 if (yych == '[') goto yy792;
    7184         377 :                 if (yych == '}') goto yy792;
    7185             :                 YYDEBUG(791, *YYCURSOR);
    7186           1 :                 YYCURSOR = YYMARKER;
    7187           1 :                 goto yy787;
    7188             : yy792:
    7189             :                 YYDEBUG(792, *YYCURSOR);
    7190         376 :                 ++YYCURSOR;
    7191             :                 YYDEBUG(793, *YYCURSOR);
    7192         376 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7193             : #line 1586 "Zend/zend_language_scanner.l"
    7194             :                 {
    7195             :         yyless(yyleng - 1);
    7196             :         zend_copy_value(zendlval, yytext, yyleng);
    7197             :         yy_pop_state();
    7198             :         yy_push_state(ST_IN_SCRIPTING);
    7199             :         RETURN_TOKEN(T_STRING_VARNAME);
    7200             : }
    7201             : #line 7202 "Zend/zend_language_scanner.c"
    7202             :         }
    7203             : /* *********************************** */
    7204             : yyc_ST_NOWDOC:
    7205             :         YYDEBUG(794, *YYCURSOR);
    7206         113 :         YYFILL(1);
    7207         113 :         yych = *YYCURSOR;
    7208             :         YYDEBUG(796, *YYCURSOR);
    7209         113 :         ++YYCURSOR;
    7210             :         YYDEBUG(797, *YYCURSOR);
    7211         113 :         yyleng = YYCURSOR - SCNG(yy_text);
    7212             : #line 2314 "Zend/zend_language_scanner.l"
    7213             :         {
    7214             :         int newline = 0;
    7215             : 
    7216             :         zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
    7217             : 
    7218             :         if (YYCURSOR > YYLIMIT) {
    7219             :                 RETURN_TOKEN(END);
    7220             :         }
    7221             : 
    7222             :         YYCURSOR--;
    7223             : 
    7224             :         while (YYCURSOR < YYLIMIT) {
    7225             :                 switch (*YYCURSOR++) {
    7226             :                         case '\r':
    7227             :                                 if (*YYCURSOR == '\n') {
    7228             :                                         YYCURSOR++;
    7229             :                                 }
    7230             :                                 /* fall through */
    7231             :                         case '\n':
    7232             :                                 /* Check for ending label on the next line */
    7233             :                                 if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
    7234             :                                         YYCTYPE *end = YYCURSOR + heredoc_label->length;
    7235             : 
    7236             :                                         if (*end == ';') {
    7237             :                                                 end++;
    7238             :                                         }
    7239             : 
    7240             :                                         if (*end == '\n' || *end == '\r') {
    7241             :                                                 /* newline before label will be subtracted from returned text, but
    7242             :                                                  * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
    7243             :                                                 if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
    7244             :                                                         newline = 2; /* Windows newline */
    7245             :                                                 } else {
    7246             :                                                         newline = 1;
    7247             :                                                 }
    7248             : 
    7249             :                                                 CG(increment_lineno) = 1; /* For newline before label */
    7250             :                                                 BEGIN(ST_END_HEREDOC);
    7251             : 
    7252             :                                                 goto nowdoc_scan_done;
    7253             :                                         }
    7254             :                                 }
    7255             :                                 /* fall through */
    7256             :                         default:
    7257             :                                 continue;
    7258             :                 }
    7259             :         }
    7260             : 
    7261             : nowdoc_scan_done:
    7262             :         yyleng = YYCURSOR - SCNG(yy_text);
    7263             : 
    7264             :         zend_copy_value(zendlval, yytext, yyleng - newline);
    7265             :         HANDLE_NEWLINES(yytext, yyleng - newline);
    7266             :         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    7267             : }
    7268             : #line 7269 "Zend/zend_language_scanner.c"
    7269             : /* *********************************** */
    7270             : yyc_ST_VAR_OFFSET:
    7271             :         {
    7272             :                 static const unsigned char yybm[] = {
    7273             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7274             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7275             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7276             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7277             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7278             :                           0,   0,   0,   0,   0,   0,   0,   0, 
    7279             :                         240, 240, 112, 112, 112, 112, 112, 112, 
    7280             :                         112, 112,   0,   0,   0,   0,   0,   0, 
    7281             :                           0,  80,  80,  80,  80,  80,  80,  16, 
    7282             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7283             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7284             :                          16,  16,  16,   0,   0,   0,   0,  16, 
    7285             :                           0,  80,  80,  80,  80,  80,  80,  16, 
    7286             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7287             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7288             :                          16,  16,  16,   0,   0,   0,   0,  16, 
    7289             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7290             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7291             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7292             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7293             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7294             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7295             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7296             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7297             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7298             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7299             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7300             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7301             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7302             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7303             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7304             :                          16,  16,  16,  16,  16,  16,  16,  16, 
    7305             :                 };
    7306             :                 YYDEBUG(798, *YYCURSOR);
    7307        2965 :                 YYFILL(3);
    7308        2965 :                 yych = *YYCURSOR;
    7309        2965 :                 if (yych <= '/') {
    7310         596 :                         if (yych <= ' ') {
    7311           0 :                                 if (yych <= '\f') {
    7312           0 :                                         if (yych <= 0x08) goto yy812;
    7313           0 :                                         if (yych <= '\n') goto yy808;
    7314           0 :                                         goto yy812;
    7315             :                                 } else {
    7316           0 :                                         if (yych <= '\r') goto yy808;
    7317           0 :                                         if (yych <= 0x1F) goto yy812;
    7318           0 :                                         goto yy808;
    7319             :                                 }
    7320             :                         } else {
    7321         596 :                                 if (yych <= '$') {
    7322         594 :                                         if (yych <= '"') goto yy807;
    7323         594 :                                         if (yych <= '#') goto yy808;
    7324         594 :                                         goto yy803;
    7325             :                                 } else {
    7326           2 :                                         if (yych == '\'') goto yy808;
    7327           0 :                                         goto yy807;
    7328             :                                 }
    7329             :                         }
    7330             :                 } else {
    7331        2369 :                         if (yych <= '\\') {
    7332        1378 :                                 if (yych <= '@') {
    7333         389 :                                         if (yych <= '0') goto yy800;
    7334         219 :                                         if (yych <= '9') goto yy802;
    7335           0 :                                         goto yy807;
    7336             :                                 } else {
    7337         989 :                                         if (yych <= 'Z') goto yy810;
    7338         989 :                                         if (yych <= '[') goto yy807;
    7339           0 :                                         goto yy808;
    7340             :                                 }
    7341             :                         } else {
    7342         991 :                                 if (yych <= '_') {
    7343         987 :                                         if (yych <= ']') goto yy805;
    7344           0 :                                         if (yych <= '^') goto yy807;
    7345           0 :                                         goto yy810;
    7346             :                                 } else {
    7347           4 :                                         if (yych <= '`') goto yy807;
    7348           4 :                                         if (yych <= 'z') goto yy810;
    7349           0 :                                         if (yych <= '~') goto yy807;
    7350           0 :                                         goto yy810;
    7351             :                                 }
    7352             :                         }
    7353             :                 }
    7354             : yy800:
    7355             :                 YYDEBUG(800, *YYCURSOR);
    7356         170 :                 yyaccept = 0;
    7357         170 :                 yych = *(YYMARKER = ++YYCURSOR);
    7358         170 :                 if (yych <= 'W') {
    7359           0 :                         if (yych <= '9') {
    7360           0 :                                 if (yych >= '0') goto yy824;
    7361             :                         } else {
    7362           0 :                                 if (yych == 'B') goto yy821;
    7363             :                         }
    7364             :                 } else {
    7365         170 :                         if (yych <= 'b') {
    7366         170 :                                 if (yych <= 'X') goto yy823;
    7367         170 :                                 if (yych >= 'b') goto yy821;
    7368             :                         } else {
    7369           0 :                                 if (yych == 'x') goto yy823;
    7370             :                         }
    7371             :                 }
    7372             : yy801:
    7373             :                 YYDEBUG(801, *YYCURSOR);
    7374         389 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7375             : #line 1703 "Zend/zend_language_scanner.l"
    7376             :                 { /* Offset could be treated as a long */
    7377             :         if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
    7378             :                 char *end;
    7379             :                 errno = 0;
    7380             :                 ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, &end, 10));
    7381             :                 if (errno == ERANGE) {
    7382             :                         goto string;
    7383             :                 }
    7384             :                 ZEND_ASSERT(end == yytext + yyleng);
    7385             :         } else {
    7386             : string:
    7387             :                 ZVAL_STRINGL(zendlval, yytext, yyleng);
    7388             :         }
    7389             :         RETURN_TOKEN(T_NUM_STRING);
    7390             : }
    7391             : #line 7392 "Zend/zend_language_scanner.c"
    7392             : yy802:
    7393             :                 YYDEBUG(802, *YYCURSOR);
    7394         219 :                 yych = *++YYCURSOR;
    7395         219 :                 goto yy820;
    7396             : yy803:
    7397             :                 YYDEBUG(803, *YYCURSOR);
    7398         594 :                 ++YYCURSOR;
    7399         594 :                 if ((yych = *YYCURSOR) <= '_') {
    7400           0 :                         if (yych <= '@') goto yy804;
    7401           0 :                         if (yych <= 'Z') goto yy816;
    7402           0 :                         if (yych >= '_') goto yy816;
    7403             :                 } else {
    7404         594 :                         if (yych <= '`') goto yy804;
    7405         594 :                         if (yych <= 'z') goto yy816;
    7406           0 :                         if (yych >= 0x7F) goto yy816;
    7407             :                 }
    7408             : yy804:
    7409             :                 YYDEBUG(804, *YYCURSOR);
    7410         989 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7411             : #line 1863 "Zend/zend_language_scanner.l"
    7412             :                 {
    7413             :         /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
    7414             :         RETURN_TOKEN(yytext[0]);
    7415             : }
    7416             : #line 7417 "Zend/zend_language_scanner.c"
    7417             : yy805:
    7418             :                 YYDEBUG(805, *YYCURSOR);
    7419         987 :                 ++YYCURSOR;
    7420             :                 YYDEBUG(806, *YYCURSOR);
    7421         987 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7422             : #line 1858 "Zend/zend_language_scanner.l"
    7423             :                 {
    7424             :         yy_pop_state();
    7425             :         RETURN_TOKEN(']');
    7426             : }
    7427             : #line 7428 "Zend/zend_language_scanner.c"
    7428             : yy807:
    7429             :                 YYDEBUG(807, *YYCURSOR);
    7430         989 :                 yych = *++YYCURSOR;
    7431         989 :                 goto yy804;
    7432             : yy808:
    7433             :                 YYDEBUG(808, *YYCURSOR);
    7434           2 :                 ++YYCURSOR;
    7435             :                 YYDEBUG(809, *YYCURSOR);
    7436           2 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7437             : #line 1868 "Zend/zend_language_scanner.l"
    7438             :                 {
    7439             :         /* Invalid rule to return a more explicit parse error with proper line number */
    7440             :         yyless(0);
    7441             :         yy_pop_state();
    7442             :         ZVAL_NULL(zendlval);
    7443             :         RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE);
    7444             : }
    7445             : #line 7446 "Zend/zend_language_scanner.c"
    7446             : yy810:
    7447             :                 YYDEBUG(810, *YYCURSOR);
    7448           4 :                 ++YYCURSOR;
    7449           4 :                 yych = *YYCURSOR;
    7450           4 :                 goto yy815;
    7451             : yy811:
    7452             :                 YYDEBUG(811, *YYCURSOR);
    7453           4 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7454             : #line 1876 "Zend/zend_language_scanner.l"
    7455             :                 {
    7456             :         zend_copy_value(zendlval, yytext, yyleng);
    7457             :         RETURN_TOKEN(T_STRING);
    7458             : }
    7459             : #line 7460 "Zend/zend_language_scanner.c"
    7460             : yy812:
    7461             :                 YYDEBUG(812, *YYCURSOR);
    7462           0 :                 ++YYCURSOR;
    7463             :                 YYDEBUG(813, *YYCURSOR);
    7464           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7465             : #line 2371 "Zend/zend_language_scanner.l"
    7466             :                 {
    7467             :         if (YYCURSOR > YYLIMIT) {
    7468             :                 RETURN_TOKEN(END);
    7469             :         }
    7470             : 
    7471             :         zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
    7472             :         goto restart;
    7473             : }
    7474             : #line 7475 "Zend/zend_language_scanner.c"
    7475             : yy814:
    7476             :                 YYDEBUG(814, *YYCURSOR);
    7477          10 :                 ++YYCURSOR;
    7478          10 :                 YYFILL(1);
    7479          10 :                 yych = *YYCURSOR;
    7480             : yy815:
    7481             :                 YYDEBUG(815, *YYCURSOR);
    7482          14 :                 if (yybm[0+yych] & 16) {
    7483          10 :                         goto yy814;
    7484             :                 }
    7485           4 :                 goto yy811;
    7486             : yy816:
    7487             :                 YYDEBUG(816, *YYCURSOR);
    7488        3367 :                 ++YYCURSOR;
    7489        3367 :                 YYFILL(1);
    7490        3367 :                 yych = *YYCURSOR;
    7491             :                 YYDEBUG(817, *YYCURSOR);
    7492        3367 :                 if (yych <= '^') {
    7493         594 :                         if (yych <= '9') {
    7494           0 :                                 if (yych >= '0') goto yy816;
    7495             :                         } else {
    7496         594 :                                 if (yych <= '@') goto yy818;
    7497         594 :                                 if (yych <= 'Z') goto yy816;
    7498             :                         }
    7499             :                 } else {
    7500        2773 :                         if (yych <= '`') {
    7501          68 :                                 if (yych <= '_') goto yy816;
    7502             :                         } else {
    7503        2705 :                                 if (yych <= 'z') goto yy816;
    7504           0 :                                 if (yych >= 0x7F) goto yy816;
    7505             :                         }
    7506             :                 }
    7507             : yy818:
    7508             :                 YYDEBUG(818, *YYCURSOR);
    7509         594 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7510             : #line 1853 "Zend/zend_language_scanner.l"
    7511             :                 {
    7512             :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    7513             :         RETURN_TOKEN(T_VARIABLE);
    7514             : }
    7515             : #line 7516 "Zend/zend_language_scanner.c"
    7516             : yy819:
    7517             :                 YYDEBUG(819, *YYCURSOR);
    7518           0 :                 ++YYCURSOR;
    7519           0 :                 YYFILL(1);
    7520           0 :                 yych = *YYCURSOR;
    7521             : yy820:
    7522             :                 YYDEBUG(820, *YYCURSOR);
    7523         219 :                 if (yybm[0+yych] & 32) {
    7524           0 :                         goto yy819;
    7525             :                 }
    7526         219 :                 goto yy801;
    7527             : yy821:
    7528             :                 YYDEBUG(821, *YYCURSOR);
    7529           0 :                 yych = *++YYCURSOR;
    7530           0 :                 if (yybm[0+yych] & 128) {
    7531           0 :                         goto yy829;
    7532             :                 }
    7533             : yy822:
    7534             :                 YYDEBUG(822, *YYCURSOR);
    7535           0 :                 YYCURSOR = YYMARKER;
    7536           0 :                 goto yy801;
    7537             : yy823:
    7538             :                 YYDEBUG(823, *YYCURSOR);
    7539           0 :                 yych = *++YYCURSOR;
    7540           0 :                 if (yybm[0+yych] & 64) {
    7541           0 :                         goto yy827;
    7542             :                 }
    7543           0 :                 goto yy822;
    7544             : yy824:
    7545             :                 YYDEBUG(824, *YYCURSOR);
    7546           0 :                 ++YYCURSOR;
    7547           0 :                 YYFILL(1);
    7548           0 :                 yych = *YYCURSOR;
    7549             :                 YYDEBUG(825, *YYCURSOR);
    7550           0 :                 if (yych <= '/') goto yy826;
    7551           0 :                 if (yych <= '9') goto yy824;
    7552             : yy826:
    7553             :                 YYDEBUG(826, *YYCURSOR);
    7554           0 :                 yyleng = YYCURSOR - SCNG(yy_text);
    7555             : #line 1719 "Zend/zend_language_scanner.l"
    7556             :                 { /* Offset must be treated as a string */
    7557             :         ZVAL_STRINGL(zendlval, yytext, yyleng);
    7558             :         RETURN_TOKEN(T_NUM_STRING);
    7559             : }
    7560             : #line 7561 "Zend/zend_language_scanner.c"
    7561             : yy827:
    7562             :                 YYDEBUG(827, *YYCURSOR);
    7563           0 :                 ++YYCURSOR;
    7564           0 :                 YYFILL(1);
    7565           0 :                 yych = *YYCURSOR;
    7566             :                 YYDEBUG(828, *YYCURSOR);
    7567           0 :                 if (yybm[0+yych] & 64) {
    7568           0 :                         goto yy827;
    7569             :                 }
    7570           0 :                 goto yy826;
    7571             : yy829:
    7572             :                 YYDEBUG(829, *YYCURSOR);
    7573           0 :                 ++YYCURSOR;
    7574           0 :                 YYFILL(1);
    7575           0 :                 yych = *YYCURSOR;
    7576             :                 YYDEBUG(830, *YYCURSOR);
    7577           0 :                 if (yybm[0+yych] & 128) {
    7578           0 :                         goto yy829;
    7579             :                 }
    7580           0 :                 goto yy826;
    7581             :         }
    7582             : }
    7583             : #line 2380 "Zend/zend_language_scanner.l"
    7584             : 
    7585             : }

Generated by: LCOV version 1.10

Generated at Sat, 25 Jun 2016 07:09:09 +0000 (3 days ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.