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

Generated by: LCOV version 1.10

Generated at Sat, 27 Jun 2015 09:41:22 +0000 (7 days ago)

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