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: 2510 2852 88.0 %
Date: 2014-09-27 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Sat, 27 Sep 2014 16:43:21 +0000 (3 days ago)

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