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

Generated by: LCOV version 1.10

Generated at Mon, 04 Aug 2014 15:49:17 +0000 (41 days ago)

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