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

Generated by: LCOV version 1.10

Generated at Thu, 30 Apr 2015 23:10:15 +0000 (4 days ago)

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