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: 2459 2791 88.1 %
Date: 2014-12-20 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Sun, 21 Dec 2014 04:59:02 +0000 (4 days ago)

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