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

Generated by: LCOV version 1.10

Generated at Sun, 18 Sep 2016 08:20:20 +0000 (7 days ago)

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