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

Generated by: LCOV version 1.10

Generated at Sat, 22 Nov 2014 23:01:28 +0000 (47 hours ago)

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