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

Generated by: LCOV version 1.10

Generated at Tue, 14 Oct 2014 07:25:53 +0000 (6 days ago)

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