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: 2382 2689 88.6 %
Date: 2014-07-27 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Sun, 27 Jul 2014 12:58:40 +0000 (41 hours ago)

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