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

Generated by: LCOV version 1.10

Generated at Thu, 21 May 2015 19:59:07 +0000 (4 days ago)

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