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.l (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 800 860 93.0 %
Date: 2014-04-18 Functions: 18 18 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 2.00 of the Zend license,     |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.zend.com/license/2_00.txt.                                |
      11             :    | If you did not receive a copy of the Zend license and are unable to  |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@zend.com so we can mail you a copy immediately.              |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Marcus Boerger <helly@php.net>                              |
      16             :    |          Nuno Lopes <nlopess@php.net>                                |
      17             :    |          Scott MacVicar <scottmac@php.net>                           |
      18             :    | Flex version authors:                                                |
      19             :    |          Andi Gutmans <andi@zend.com>                                |
      20             :    |          Zeev Suraski <zeev@zend.com>                                |
      21             :    +----------------------------------------------------------------------+
      22             : */
      23             : 
      24             : /* $Id$ */
      25             : 
      26             : #if 0
      27             : # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
      28             : #else
      29             : # define YYDEBUG(s, c)
      30             : #endif
      31             : 
      32             : #include "zend_language_scanner_defs.h"
      33             : 
      34             : #include <errno.h>
      35             : #include "zend.h"
      36             : #include "zend_alloc.h"
      37             : #include <zend_language_parser.h>
      38             : #include "zend_compile.h"
      39             : #include "zend_language_scanner.h"
      40             : #include "zend_highlight.h"
      41             : #include "zend_constants.h"
      42             : #include "zend_variables.h"
      43             : #include "zend_operators.h"
      44             : #include "zend_API.h"
      45             : #include "zend_strtod.h"
      46             : #include "zend_exceptions.h"
      47             : #include "tsrm_virtual_cwd.h"
      48             : #include "tsrm_config_common.h"
      49             : 
      50             : #define YYCTYPE   unsigned char
      51             : #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
      52             : #define YYCURSOR  SCNG(yy_cursor)
      53             : #define YYLIMIT   SCNG(yy_limit)
      54             : #define YYMARKER  SCNG(yy_marker)
      55             : 
      56             : #define YYGETCONDITION()  SCNG(yy_state)
      57             : #define YYSETCONDITION(s) SCNG(yy_state) = s
      58             : 
      59             : #define STATE(name)  yyc##name
      60             : 
      61             : /* emulate flex constructs */
      62             : #define BEGIN(state) YYSETCONDITION(STATE(state))
      63             : #define YYSTATE      YYGETCONDITION()
      64             : #define yytext       ((char*)SCNG(yy_text))
      65             : #define yyleng       SCNG(yy_leng)
      66             : #define yyless(x)    do { YYCURSOR = (unsigned char*)yytext + x; \
      67             :                           yyleng   = (unsigned int)x; } while(0)
      68             : #define yymore()     goto yymore_restart
      69             : 
      70             : /* perform sanity check. If this message is triggered you should
      71             :    increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
      72             : /*!max:re2c */
      73             : #if ZEND_MMAP_AHEAD < YYMAXFILL
      74             : # error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
      75             : #endif
      76             : 
      77             : #ifdef HAVE_STDARG_H
      78             : # include <stdarg.h>
      79             : #endif
      80             : 
      81             : #ifdef HAVE_UNISTD_H
      82             : # include <unistd.h>
      83             : #endif
      84             : 
      85             : /* Globals Macros */
      86             : #define SCNG    LANG_SCNG
      87             : #ifdef ZTS
      88             : ZEND_API ts_rsrc_id language_scanner_globals_id;
      89             : #else
      90             : ZEND_API zend_php_scanner_globals language_scanner_globals;
      91             : #endif
      92             : 
      93             : #define HANDLE_NEWLINES(s, l)                                                                                                   \
      94             : do {                                                                                                                                                    \
      95             :         char *p = (s), *boundary = p+(l);                                                                                       \
      96             :                                                                                                                                                                 \
      97             :         while (p<boundary) {                                                                                                         \
      98             :                 if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {                                   \
      99             :                         CG(zend_lineno)++;                                                                                                      \
     100             :                 }                                                                                                                                               \
     101             :                 p++;                                                                                                                                    \
     102             :         }                                                                                                                                                       \
     103             : } while (0)
     104             : 
     105             : #define HANDLE_NEWLINE(c) \
     106             : { \
     107             :         if (c == '\n' || c == '\r') { \
     108             :                 CG(zend_lineno)++; \
     109             :         } \
     110             : }
     111             : 
     112             : /* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
     113             : #define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
     114             : #define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    CG(doc_comment_len)
     115             : 
     116             : #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
     117             : 
     118             : #define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')
     119             : #define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
     120             : 
     121             : BEGIN_EXTERN_C()
     122             : 
     123      178055 : static void _yy_push_state(int new_state TSRMLS_DC)
     124             : {
     125      178055 :         zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));
     126      178055 :         YYSETCONDITION(new_state);
     127      178055 : }
     128             : 
     129             : #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
     130             : 
     131      177978 : static void yy_pop_state(TSRMLS_D)
     132             : {
     133             :         int *stack_state;
     134      177978 :         zend_stack_top(&SCNG(state_stack), (void **) &stack_state);
     135      177978 :         YYSETCONDITION(*stack_state);
     136      177978 :         zend_stack_del_top(&SCNG(state_stack));
     137      177978 : }
     138             : 
     139       29672 : static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
     140             : {
     141       29672 :         YYCURSOR       = (YYCTYPE*)str;
     142       29672 :         YYLIMIT        = YYCURSOR + len;
     143       29672 :         if (!SCNG(yy_start)) {
     144        1104 :                 SCNG(yy_start) = YYCURSOR;
     145             :         }
     146       29672 : }
     147             : 
     148       19327 : void startup_scanner(TSRMLS_D)
     149             : {
     150       19327 :         CG(heredoc) = NULL;
     151       19327 :         CG(heredoc_len) = 0;
     152       19327 :         CG(doc_comment) = NULL;
     153       19327 :         CG(doc_comment_len) = 0;
     154       19327 :         zend_stack_init(&SCNG(state_stack));
     155       19327 : }
     156             : 
     157       19362 : void shutdown_scanner(TSRMLS_D)
     158             : {
     159       19362 :         if (CG(heredoc)) {
     160           2 :                 efree(CG(heredoc));
     161           2 :                 CG(heredoc_len)=0;
     162             :         }
     163       19362 :         zend_stack_destroy(&SCNG(state_stack));
     164       19362 :         RESET_DOC_COMMENT();
     165       19362 : }
     166             : 
     167       29698 : ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
     168             : {
     169       29698 :         lex_state->yy_leng   = SCNG(yy_leng);
     170       29698 :         lex_state->yy_start  = SCNG(yy_start);
     171       29698 :         lex_state->yy_text   = SCNG(yy_text);
     172       29698 :         lex_state->yy_cursor = SCNG(yy_cursor);
     173       29698 :         lex_state->yy_marker = SCNG(yy_marker);
     174       29698 :         lex_state->yy_limit  = SCNG(yy_limit);
     175             : 
     176       29698 :         lex_state->state_stack = SCNG(state_stack);
     177       29698 :         zend_stack_init(&SCNG(state_stack));
     178             : 
     179       29698 :         lex_state->in = SCNG(yy_in);
     180       29698 :         lex_state->yy_state = YYSTATE;
     181       29698 :         lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
     182       29698 :         lex_state->lineno = CG(zend_lineno);
     183             : 
     184             : #ifdef ZEND_MULTIBYTE
     185             :         lex_state->script_org = SCNG(script_org);
     186             :         lex_state->script_org_size = SCNG(script_org_size);
     187             :         lex_state->script_filtered = SCNG(script_filtered);
     188             :         lex_state->script_filtered_size = SCNG(script_filtered_size);
     189             :         lex_state->input_filter = SCNG(input_filter);
     190             :         lex_state->output_filter = SCNG(output_filter);
     191             :         lex_state->script_encoding = SCNG(script_encoding);
     192             :         lex_state->internal_encoding = SCNG(internal_encoding);
     193             : #endif /* ZEND_MULTIBYTE */
     194       29698 : }
     195             : 
     196       29530 : ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
     197             : {
     198       29530 :         SCNG(yy_leng)   = lex_state->yy_leng;
     199       29530 :         SCNG(yy_start)  = lex_state->yy_start;
     200       29530 :         SCNG(yy_text)   = lex_state->yy_text;
     201       29530 :         SCNG(yy_cursor) = lex_state->yy_cursor;
     202       29530 :         SCNG(yy_marker) = lex_state->yy_marker;
     203       29530 :         SCNG(yy_limit)  = lex_state->yy_limit;
     204             : 
     205       29530 :         zend_stack_destroy(&SCNG(state_stack));
     206       29530 :         SCNG(state_stack) = lex_state->state_stack;
     207             : 
     208       29530 :         SCNG(yy_in) = lex_state->in;
     209       29530 :         YYSETCONDITION(lex_state->yy_state);
     210       29530 :         CG(zend_lineno) = lex_state->lineno;
     211       29530 :         zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);
     212             : #ifdef ZEND_MULTIBYTE
     213             :         if (SCNG(script_org)) {
     214             :                 efree(SCNG(script_org));
     215             :                 SCNG(script_org) = NULL;
     216             :         }
     217             :         if (SCNG(script_filtered)) {
     218             :                 efree(SCNG(script_filtered));
     219             :                 SCNG(script_filtered) = NULL;
     220             :         }
     221             :         SCNG(script_org) = lex_state->script_org;
     222             :         SCNG(script_org_size) = lex_state->script_org_size;
     223             :         SCNG(script_filtered) = lex_state->script_filtered;
     224             :         SCNG(script_filtered_size) = lex_state->script_filtered_size;
     225             :         SCNG(input_filter) = lex_state->input_filter;
     226             :         SCNG(output_filter) = lex_state->output_filter;
     227             :         SCNG(script_encoding) = lex_state->script_encoding;
     228             :         SCNG(internal_encoding) = lex_state->internal_encoding;
     229             : #endif /* ZEND_MULTIBYTE */
     230             : 
     231       29530 :         if (CG(heredoc)) {
     232           1 :                 efree(CG(heredoc));
     233           1 :                 CG(heredoc) = NULL;
     234           1 :                 CG(heredoc_len) = 0;
     235             :         }
     236       29530 : }
     237             : 
     238       28424 : ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
     239             : {
     240       28424 :         zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
     241             :         /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
     242       28424 :         file_handle->opened_path = NULL;
     243       28424 :         if (file_handle->free_filename) {
     244           0 :                 file_handle->filename = NULL;
     245             :         }
     246       28424 : }
     247             : 
     248             : 
     249       28600 : ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
     250             : {
     251       28600 :         char *file_path = NULL, *buf;
     252       28600 :         size_t size, offset = 0;
     253             :         
     254             :         /* The shebang line was read, get the current position to obtain the buffer start */
     255       28600 :         if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {
     256           4 :                 if ((offset = ftell(file_handle->handle.fp)) == -1) {
     257           0 :                         offset = 0;
     258             :                 }
     259             :         }
     260             : 
     261       28600 :         if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {
     262          32 :                 return FAILURE;
     263             :         }
     264             : 
     265       28568 :         zend_llist_add_element(&CG(open_files), file_handle);
     266       28568 :         if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
     267       19498 :                 zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
     268       19498 :                 size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
     269       19498 :                 fh->handle.stream.handle = (void*)(((char*)fh) + diff);
     270       19498 :                 file_handle->handle.stream.handle = fh->handle.stream.handle;
     271             :         }
     272             : 
     273             :         /* Reset the scanner for scanning the new file */
     274       28568 :         SCNG(yy_in) = file_handle;
     275       28568 :         SCNG(yy_start) = NULL;
     276             : 
     277       28568 :         if (size != -1) {
     278             : #ifdef ZEND_MULTIBYTE
     279             :                 if (zend_multibyte_read_script((unsigned char *)buf, size TSRMLS_CC) != 0) {
     280             :                         return FAILURE;
     281             :                 }
     282             : 
     283             :                 SCNG(yy_in) = NULL;
     284             : 
     285             :                 zend_multibyte_set_filter(NULL TSRMLS_CC);
     286             : 
     287             :                 if (!SCNG(input_filter)) {
     288             :                         SCNG(script_filtered) = (unsigned char*)emalloc(SCNG(script_org_size)+2);
     289             :                         memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
     290             :                         SCNG(script_filtered_size) = SCNG(script_org_size);
     291             :                 } else {
     292             :                         SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
     293             :                         if (SCNG(script_filtered) == NULL) {
     294             :                                 zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
     295             :                                                 "encoding \"%s\" to a compatible encoding", LANG_SCNG(script_encoding)->name);
     296             :                         }
     297             :                 }
     298             :                 SCNG(yy_start) = SCNG(script_filtered) - offset;
     299             :                 yy_scan_buffer((char *)SCNG(script_filtered), SCNG(script_filtered_size) TSRMLS_CC);
     300             : #else /* !ZEND_MULTIBYTE */
     301       28568 :                 SCNG(yy_start) = buf - offset;
     302       28568 :                 yy_scan_buffer(buf, size TSRMLS_CC);
     303             : #endif /* ZEND_MULTIBYTE */
     304             :         } else {
     305           0 :                 zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
     306             :         }
     307             : 
     308       28568 :         BEGIN(INITIAL);
     309             : 
     310       28568 :         if (file_handle->opened_path) {
     311       28538 :                 file_path = file_handle->opened_path;
     312             :         } else {
     313          30 :                 file_path = file_handle->filename;
     314             :         }
     315             : 
     316       28568 :         zend_set_compiled_filename(file_path TSRMLS_CC);
     317             : 
     318       28568 :         if (CG(start_lineno)) {
     319       18918 :                 CG(zend_lineno) = CG(start_lineno);
     320       18918 :                 CG(start_lineno) = 0;
     321             :         } else {
     322        9650 :                 CG(zend_lineno) = 1;
     323             :         }
     324             : 
     325       28568 :         CG(increment_lineno) = 0;
     326       28568 :         return SUCCESS;
     327             : }
     328             : END_EXTERN_C()
     329             : 
     330             : 
     331       28569 : ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
     332             : {
     333             :         zend_lex_state original_lex_state;
     334       28569 :         zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
     335       28569 :         zend_op_array *original_active_op_array = CG(active_op_array);
     336       28569 :         zend_op_array *retval=NULL;
     337             :         int compiler_result;
     338       28569 :         zend_bool compilation_successful=0;
     339             :         znode retval_znode;
     340       28569 :         zend_bool original_in_compilation = CG(in_compilation);
     341             : 
     342       28569 :         retval_znode.op_type = IS_CONST;
     343       28569 :         retval_znode.u.constant.type = IS_LONG;
     344       28569 :         retval_znode.u.constant.value.lval = 1;
     345             :         Z_UNSET_ISREF(retval_znode.u.constant);
     346             :         Z_SET_REFCOUNT(retval_znode.u.constant, 1);
     347             : 
     348       28569 :         zend_save_lexical_state(&original_lex_state TSRMLS_CC);
     349             : 
     350       28569 :         retval = op_array; /* success oriented */
     351             : 
     352       28569 :         if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
     353          28 :                 if (type==ZEND_REQUIRE) {
     354           1 :                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename TSRMLS_CC);
     355           0 :                         zend_bailout();
     356             :                 } else {
     357          27 :                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename TSRMLS_CC);
     358             :                 }
     359          27 :                 compilation_successful=0;
     360             :         } else {
     361       28541 :                 init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
     362       28541 :                 CG(in_compilation) = 1;
     363       28541 :                 CG(active_op_array) = op_array;
     364       28541 :                 compiler_result = zendparse(TSRMLS_C);
     365       28405 :                 zend_do_return(&retval_znode, 0 TSRMLS_CC);
     366       28405 :                 CG(in_compilation) = original_in_compilation;
     367       28405 :                 if (compiler_result==1) { /* parser error */
     368          26 :                         zend_bailout();
     369             :                 }
     370       28379 :                 compilation_successful=1;
     371             :         }
     372             : 
     373       28406 :         if (retval) {
     374       28406 :                 CG(active_op_array) = original_active_op_array;
     375       28406 :                 if (compilation_successful) {
     376       28379 :                         pass_two(op_array TSRMLS_CC);
     377       28376 :                         zend_release_labels(TSRMLS_C);
     378             :                 } else {
     379          27 :                         efree(op_array);
     380          27 :                         retval = NULL;
     381             :                 }
     382             :         }
     383       28403 :         zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     384       28403 :         return retval;
     385             : }
     386             : 
     387             : 
     388        3798 : zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
     389             : {
     390             :         zend_file_handle file_handle;
     391             :         zval tmp;
     392             :         zend_op_array *retval;
     393        3798 :         char *opened_path = NULL;
     394             : 
     395        3798 :         if (filename->type != IS_STRING) {
     396           0 :                 tmp = *filename;
     397           0 :                 zval_copy_ctor(&tmp);
     398           0 :                 convert_to_string(&tmp);
     399           0 :                 filename = &tmp;
     400             :         }
     401        3798 :         file_handle.filename = filename->value.str.val;
     402        3798 :         file_handle.free_filename = 0;
     403        3798 :         file_handle.type = ZEND_HANDLE_FILENAME;
     404        3798 :         file_handle.opened_path = NULL;
     405        3798 :         file_handle.handle.fp = NULL;
     406             : 
     407        3798 :         retval = zend_compile_file(&file_handle, type TSRMLS_CC);
     408        3793 :         if (retval && file_handle.handle.stream.handle) {
     409        3766 :                 int dummy = 1;
     410             : 
     411        3766 :                 if (!file_handle.opened_path) {
     412          17 :                         file_handle.opened_path = opened_path = estrndup(filename->value.str.val, filename->value.str.len);
     413             :                 }
     414             : 
     415        3766 :                 zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
     416             : 
     417        3766 :                 if (opened_path) {
     418          17 :                         efree(opened_path);
     419             :                 }
     420             :         }
     421        3793 :         zend_destroy_file_handle(&file_handle TSRMLS_CC);
     422             : 
     423        3793 :         if (filename==&tmp) {
     424           0 :                 zval_dtor(&tmp);
     425             :         }
     426        3793 :         return retval;
     427             : }
     428             : 
     429        1104 : ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
     430             : {
     431             :         /* enforce two trailing NULLs for flex... */
     432        1104 :         str->value.str.val = safe_erealloc(str->value.str.val, 1, str->value.str.len, ZEND_MMAP_AHEAD);
     433             : 
     434        1104 :         memset(str->value.str.val + str->value.str.len, 0, ZEND_MMAP_AHEAD);
     435             : 
     436        1104 :         SCNG(yy_in)=NULL;
     437        1104 :         SCNG(yy_start) = NULL;
     438             : 
     439             : #ifdef ZEND_MULTIBYTE
     440             :         SCNG(script_org) = (unsigned char *)estrdup(str->value.str.val);
     441             :         SCNG(script_org_size) = str->value.str.len;
     442             : 
     443             :         zend_multibyte_set_filter(CG(internal_encoding) TSRMLS_CC);
     444             : 
     445             :         if (!SCNG(input_filter)) {
     446             :                 SCNG(script_filtered) = (unsigned char*)emalloc(SCNG(script_org_size)+2);
     447             :                 memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
     448             :                 SCNG(script_filtered_size) = SCNG(script_org_size);
     449             :         } else {
     450             :                 SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
     451             :         }
     452             : 
     453             :         yy_scan_buffer((char *)SCNG(script_filtered), SCNG(script_filtered_size) TSRMLS_CC);    
     454             : #else /* !ZEND_MULTIBYTE */
     455        1104 :         yy_scan_buffer(str->value.str.val, str->value.str.len TSRMLS_CC);
     456             : #endif /* ZEND_MULTIBYTE */
     457             : 
     458        1104 :         zend_set_compiled_filename(filename TSRMLS_CC);
     459        1104 :         CG(zend_lineno) = 1;
     460        1104 :         CG(increment_lineno) = 0;
     461        1104 :         return SUCCESS;
     462             : }
     463             : 
     464             : 
     465         273 : ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D)
     466             : {
     467         273 :         size_t offset = SCNG(yy_cursor) - SCNG(yy_start);
     468             : #ifdef ZEND_MULTIBYTE
     469             :         if (SCNG(input_filter)) {
     470             :                 size_t original_offset = offset, length = 0; do {
     471             :                         unsigned char *p = NULL;
     472             :                         SCNG(input_filter)(&p, &length, SCNG(script_org), offset TSRMLS_CC);
     473             :                         if (!p) {
     474             :                                 break;
     475             :                         }
     476             :                         efree(p);
     477             :                         if (length > original_offset) {
     478             :                                 offset--;
     479             :                         } else if (length < original_offset) {
     480             :                                 offset++;
     481             :                         }
     482             :                 } while (original_offset != length);
     483             :         }
     484             : #endif
     485         273 :         return offset;
     486             : }
     487             : 
     488             : 
     489        1022 : zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
     490             : {
     491             :         zend_lex_state original_lex_state;
     492        1022 :         zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
     493        1022 :         zend_op_array *original_active_op_array = CG(active_op_array);
     494             :         zend_op_array *retval;
     495             :         zval tmp;
     496             :         int compiler_result;
     497        1022 :         zend_bool original_in_compilation = CG(in_compilation);
     498             : 
     499        1022 :         if (source_string->value.str.len==0) {
     500           0 :                 efree(op_array);
     501           0 :                 return NULL;
     502             :         }
     503             : 
     504        1022 :         CG(in_compilation) = 1;
     505             : 
     506        1022 :         tmp = *source_string;
     507        1022 :         zval_copy_ctor(&tmp);
     508        1022 :         convert_to_string(&tmp);
     509        1022 :         source_string = &tmp;
     510             : 
     511        1022 :         zend_save_lexical_state(&original_lex_state TSRMLS_CC);
     512        1022 :         if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
     513           0 :                 efree(op_array);
     514           0 :                 retval = NULL;
     515             :         } else {
     516        1022 :                 zend_bool orig_interactive = CG(interactive);
     517             : 
     518        1022 :                 CG(interactive) = 0;
     519        1022 :                 init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
     520        1022 :                 CG(interactive) = orig_interactive;
     521        1022 :                 CG(active_op_array) = op_array;
     522        1022 :                 BEGIN(ST_IN_SCRIPTING);
     523        1022 :                 compiler_result = zendparse(TSRMLS_C);
     524             : 
     525             : #ifdef ZEND_MULTIBYTE
     526             :                 if (SCNG(script_org)) {
     527             :                         efree(SCNG(script_org));
     528             :                         SCNG(script_org) = NULL;
     529             :                 }
     530             :                 if (SCNG(script_filtered)) {
     531             :                         efree(SCNG(script_filtered));
     532             :                         SCNG(script_filtered) = NULL;
     533             :                 }
     534             : #endif /* ZEND_MULTIBYTE */
     535             : 
     536        1020 :                 if (compiler_result==1) {
     537           8 :                         CG(active_op_array) = original_active_op_array;
     538           8 :                         CG(unclean_shutdown)=1;
     539           8 :                         destroy_op_array(op_array TSRMLS_CC);
     540           8 :                         efree(op_array);
     541           8 :                         retval = NULL;
     542             :                 } else {
     543        1012 :                         zend_do_return(NULL, 0 TSRMLS_CC);
     544        1012 :                         CG(active_op_array) = original_active_op_array;
     545        1012 :                         pass_two(op_array TSRMLS_CC);
     546        1012 :                         zend_release_labels(TSRMLS_C);
     547        1012 :                         retval = op_array;
     548             :                 }
     549             :         }
     550        1020 :         zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     551        1020 :         zval_dtor(&tmp);
     552        1020 :         CG(in_compilation) = original_in_compilation;
     553        1020 :         return retval;
     554             : }
     555             : 
     556             : 
     557             : BEGIN_EXTERN_C()
     558          20 : int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
     559             : {
     560             :         zend_lex_state original_lex_state;
     561             :         zend_file_handle file_handle;
     562             : 
     563          20 :         file_handle.type = ZEND_HANDLE_FILENAME;
     564          20 :         file_handle.filename = filename;
     565          20 :         file_handle.free_filename = 0;
     566          20 :         file_handle.opened_path = NULL;
     567          20 :         zend_save_lexical_state(&original_lex_state TSRMLS_CC);
     568          20 :         if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
     569           2 :                 zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename TSRMLS_CC);
     570           2 :                 zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     571           2 :                 return FAILURE;
     572             :         }
     573          18 :         zend_highlight(syntax_highlighter_ini TSRMLS_CC);
     574             : #ifdef ZEND_MULTIBYTE
     575             :         if (SCNG(script_org)) {
     576             :                 efree(SCNG(script_org));
     577             :                 SCNG(script_org) = NULL;
     578             :         }
     579             :         if (SCNG(script_filtered)) {
     580             :                 efree(SCNG(script_filtered));
     581             :                 SCNG(script_filtered) = NULL;
     582             :         }
     583             : #endif /* ZEND_MULTIBYTE */
     584          18 :         zend_destroy_file_handle(&file_handle TSRMLS_CC);
     585          18 :         zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     586          18 :         return SUCCESS;
     587             : }
     588             : 
     589          14 : int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)
     590             : {
     591             :         zend_lex_state original_lex_state;
     592          14 :         zval tmp = *str;
     593             : 
     594          14 :         str = &tmp;
     595          14 :         zval_copy_ctor(str);
     596          14 :         zend_save_lexical_state(&original_lex_state TSRMLS_CC);
     597          14 :         if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
     598           0 :                 zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     599           0 :                 return FAILURE;
     600             :         }
     601          14 :         BEGIN(INITIAL);
     602          14 :         zend_highlight(syntax_highlighter_ini TSRMLS_CC);
     603             : #ifdef ZEND_MULTIBYTE
     604             :         if (SCNG(script_org)) {
     605             :                 efree(SCNG(script_org));
     606             :                 SCNG(script_org) = NULL;
     607             :         }
     608             :         if (SCNG(script_filtered)) {
     609             :                 efree(SCNG(script_filtered));
     610             :                 SCNG(script_filtered) = NULL;
     611             :         }
     612             : #endif /* ZEND_MULTIBYTE */
     613          14 :         zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
     614          14 :         zval_dtor(str);
     615          14 :         return SUCCESS;
     616             : }
     617             : END_EXTERN_C()
     618             : 
     619             : #ifdef ZEND_MULTIBYTE
     620             : 
     621             : BEGIN_EXTERN_C()
     622             : ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, zend_encoding *old_encoding TSRMLS_DC)
     623             : {
     624             :         size_t original_offset, offset, free_flag, new_len, length;
     625             :         unsigned char *p;
     626             : 
     627             :         /* calculate current position */
     628             :         offset = original_offset = YYCURSOR - SCNG(yy_start);
     629             :         if (old_input_filter && offset > 0) {
     630             :                 zend_encoding *new_encoding = SCNG(script_encoding);
     631             :                 zend_encoding_filter new_filter = SCNG(input_filter);
     632             :                 SCNG(script_encoding) = old_encoding;
     633             :                 SCNG(input_filter) = old_input_filter;
     634             :                 offset = zend_get_scanned_file_offset(TSRMLS_C);
     635             :                 SCNG(script_encoding) = new_encoding;
     636             :                 SCNG(input_filter) = new_filter;
     637             :         }
     638             : 
     639             :         /* convert and set */
     640             :         if (!SCNG(input_filter)) {
     641             :                 length = SCNG(script_org_size) - offset;
     642             :                 p = SCNG(script_org) + offset;
     643             :                 free_flag = 0;
     644             :         } else {
     645             :                 SCNG(input_filter)(&p, &length, SCNG(script_org) + offset, SCNG(script_org_size) - offset TSRMLS_CC);
     646             :                 free_flag = 1;
     647             :         }
     648             : 
     649             :         new_len = original_offset + length;
     650             : 
     651             :         if (new_len > YYLIMIT - SCNG(yy_start)) {
     652             :                 unsigned char *new_yy_start = erealloc(SCNG(yy_start), new_len);
     653             :                 SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));
     654             :                 SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));
     655             :                 SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));
     656             :                 SCNG(yy_start) = new_yy_start;
     657             :                 SCNG(script_filtered) = new_yy_start;
     658             :                 SCNG(script_filtered_size) = new_len;
     659             :         }
     660             : 
     661             :         SCNG(yy_limit) = SCNG(yy_start) + new_len;
     662             :         memmove(SCNG(yy_start) + original_offset, p, length);
     663             : 
     664             :         if (free_flag) {
     665             :                 efree(p);
     666             :         }
     667             : }
     668             : 
     669             : 
     670             : ZEND_API int zend_multibyte_yyinput(zend_file_handle *file_handle, char *buf, size_t len TSRMLS_DC)
     671             : {
     672             :         size_t n;
     673             : 
     674             :         if (CG(interactive) == 0) {
     675             :                 if (zend_stream_fixup(file_handle, &buf, &len TSRMLS_CC) == FAILURE) {
     676             :                         return FAILURE;
     677             :                 }
     678             :                 n = len;
     679             :                 return n;
     680             :         }
     681             : 
     682             :         /* interactive */
     683             :         if (SCNG(script_org)) {
     684             :                 efree(SCNG(script_org));
     685             :         }
     686             :         if (SCNG(script_filtered)) {
     687             :                 efree(SCNG(script_filtered));
     688             :         }
     689             :         SCNG(script_org) = NULL;
     690             :         SCNG(script_org_size) = 0;
     691             : 
     692             :         /* TODO: support widechars */
     693             :         if (zend_stream_fixup(file_handle, &buf, &len TSRMLS_CC) == FAILURE) {
     694             :                 return FAILURE;
     695             :         }
     696             :         n = len;
     697             : 
     698             :         SCNG(script_org_size) = n;
     699             :         SCNG(script_org) = (unsigned char*)emalloc(SCNG(script_org_size) + 1);
     700             :         memcpy(SCNG(script_org), buf, n);
     701             : 
     702             :         return n;
     703             : }
     704             : 
     705             : 
     706             : ZEND_API int zend_multibyte_read_script(unsigned char *buf, size_t n TSRMLS_DC)
     707             : {
     708             :         if (SCNG(script_org)) {
     709             :                 efree(SCNG(script_org));
     710             :                 SCNG(script_org) = NULL;
     711             :         }
     712             :         SCNG(script_org_size) = n;      
     713             :         
     714             :         SCNG(script_org) = (unsigned char*)emalloc(SCNG(script_org_size) + 1);
     715             :         memcpy(SCNG(script_org), buf, n);
     716             :         *(SCNG(script_org)+SCNG(script_org_size)) = '\0';
     717             : 
     718             :         return 0;
     719             : }
     720             : 
     721             : 
     722             : # define zend_copy_value(zendlval, yytext, yyleng) \
     723             :         if (SCNG(output_filter)) { \
     724             :                 size_t sz = 0; \
     725             :                 SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \
     726             :                 zendlval->value.str.len = sz; \
     727             :         } else { \
     728             :                 zendlval->value.str.val = (char *) estrndup(yytext, yyleng); \
     729             :                 zendlval->value.str.len = yyleng; \
     730             :         }
     731             : #else /* ZEND_MULTIBYTE */
     732             : # define zend_copy_value(zendlval, yytext, yyleng) \
     733             :         zendlval->value.str.val = (char *)estrndup(yytext, yyleng); \
     734             :         zendlval->value.str.len = yyleng;
     735             : #endif /* ZEND_MULTIBYTE */
     736             : 
     737      213391 : static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
     738             : {
     739             :         register char *s, *t;
     740             :         char *end;
     741             : 
     742      213391 :         ZVAL_STRINGL(zendlval, str, len, 1);
     743             : 
     744             :         /* convert escape sequences */
     745      213391 :         s = t = zendlval->value.str.val;
     746      213391 :         end = s+zendlval->value.str.len;
     747     4116504 :         while (s<end) {
     748     3689726 :                 if (*s=='\\') {
     749       64489 :                         s++;
     750       64489 :                         if (s >= end) {
     751           4 :                                 *t++ = '\\';
     752           4 :                                 break;
     753             :                         }
     754             : 
     755       64485 :                         switch(*s) {
     756             :                                 case 'n':
     757       53942 :                                         *t++ = '\n';
     758       53942 :                                         zendlval->value.str.len--;
     759       53942 :                                         break;
     760             :                                 case 'r':
     761        3663 :                                         *t++ = '\r';
     762        3663 :                                         zendlval->value.str.len--;
     763        3663 :                                         break;
     764             :                                 case 't':
     765         935 :                                         *t++ = '\t';
     766         935 :                                         zendlval->value.str.len--;
     767         935 :                                         break;
     768             :                                 case 'f':
     769          72 :                                         *t++ = '\f';
     770          72 :                                         zendlval->value.str.len--;
     771          72 :                                         break;
     772             :                                 case 'v':
     773         106 :                                         *t++ = '\v';
     774         106 :                                         zendlval->value.str.len--;
     775         106 :                                         break;
     776             :                                 case '"':
     777             :                                 case '`':
     778        1122 :                                         if (*s != quote_type) {
     779           4 :                                                 *t++ = '\\';
     780           4 :                                                 *t++ = *s;
     781           4 :                                                 break;
     782             :                                         }
     783             :                                 case '\\':
     784             :                                 case '$':
     785        2260 :                                         *t++ = *s;
     786        2260 :                                         zendlval->value.str.len--;
     787        2260 :                                         break;
     788             :                                 case 'x':
     789             :                                 case 'X':
     790        4161 :                                         if (ZEND_IS_HEX(*(s+1))) {
     791        2070 :                                                 char hex_buf[3] = { 0, 0, 0 };
     792             : 
     793        2070 :                                                 zendlval->value.str.len--; /* for the 'x' */
     794             : 
     795        2070 :                                                 hex_buf[0] = *(++s);
     796        2070 :                                                 zendlval->value.str.len--;
     797        2070 :                                                 if (ZEND_IS_HEX(*(s+1))) {
     798        2042 :                                                         hex_buf[1] = *(++s);
     799        2042 :                                                         zendlval->value.str.len--;
     800             :                                                 }
     801        2070 :                                                 *t++ = (char) strtol(hex_buf, NULL, 16);
     802             :                                         } else {
     803          21 :                                                 *t++ = '\\';
     804          21 :                                                 *t++ = *s;
     805             :                                         }
     806        2091 :                                         break;
     807             :                                 default:
     808             :                                         /* check for an octal */
     809        2150 :                                         if (ZEND_IS_OCT(*s)) {
     810         738 :                                                 char octal_buf[4] = { 0, 0, 0, 0 };
     811             : 
     812         738 :                                                 octal_buf[0] = *s;
     813         738 :                                                 zendlval->value.str.len--;
     814         738 :                                                 if (ZEND_IS_OCT(*(s+1))) {
     815         197 :                                                         octal_buf[1] = *(++s);
     816         197 :                                                         zendlval->value.str.len--;
     817         197 :                                                         if (ZEND_IS_OCT(*(s+1))) {
     818         173 :                                                                 octal_buf[2] = *(++s);
     819         173 :                                                                 zendlval->value.str.len--;
     820             :                                                         }
     821             :                                                 }
     822         738 :                                                 *t++ = (char) strtol(octal_buf, NULL, 8);
     823             :                                         } else {
     824         674 :                                                 *t++ = '\\';
     825         674 :                                                 *t++ = *s;
     826             :                                         }
     827             :                                         break;
     828             :                         }
     829             :                 } else {
     830     3625237 :                         *t++ = *s;
     831             :                 }
     832             : 
     833     3689722 :                 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
     834       10489 :                         CG(zend_lineno)++;
     835             :                 }
     836     3689722 :                 s++;
     837             :         }
     838      213391 :         *t = 0;
     839             : #ifdef ZEND_MULTIBYTE
     840             :         if (SCNG(output_filter)) {
     841             :                 size_t sz = 0;
     842             :                 s = zendlval->value.str.val;
     843             :                 SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
     844             :                 zendlval->value.str.len = sz;
     845             :                 efree(s);
     846             :         }
     847             : #endif /* ZEND_MULTIBYTE */
     848      213391 : }
     849             : 
     850             : 
     851     8297458 : int lex_scan(zval *zendlval TSRMLS_DC)
     852             : {
     853             : restart:
     854     8297458 :         SCNG(yy_text) = YYCURSOR;
     855             : 
     856             : yymore_restart:
     857             : 
     858             : /*!re2c
     859             : re2c:yyfill:check = 0;
     860             : LNUM    [0-9]+
     861             : DNUM    ([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)
     862             : EXPONENT_DNUM   (({LNUM}|{DNUM})[eE][+-]?{LNUM})
     863             : HNUM    "0x"[0-9a-fA-F]+
     864             : LABEL   [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
     865             : WHITESPACE [ \n\r\t]+
     866             : TABS_AND_SPACES [ \t]*
     867             : TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@]
     868             : ANY_CHAR [^]
     869             : NEWLINE ("\r"|"\n"|"\r\n")
     870             : 
     871             : /* compute yyleng before each rule */
     872             : <!*> := yyleng = YYCURSOR - SCNG(yy_text);
     873             : 
     874             : 
     875             : <ST_IN_SCRIPTING>"exit" {
     876        1431 :         return T_EXIT;
     877             : }
     878             : 
     879             : <ST_IN_SCRIPTING>"die" {
     880       13177 :         return T_EXIT;
     881             : }
     882             : 
     883             : <ST_IN_SCRIPTING>"function" {
     884       36259 :         return T_FUNCTION;
     885             : }
     886             : 
     887             : <ST_IN_SCRIPTING>"const" {
     888         244 :         return T_CONST;
     889             : }
     890             : 
     891             : <ST_IN_SCRIPTING>"return" {
     892       50953 :         return T_RETURN;
     893             : }
     894             : 
     895             : <ST_IN_SCRIPTING>"try" {
     896        2056 :         return T_TRY;
     897             : }
     898             : 
     899             : <ST_IN_SCRIPTING>"catch" {
     900        2063 :         return T_CATCH;
     901             : }
     902             : 
     903             : <ST_IN_SCRIPTING>"throw" {
     904         263 :         return T_THROW;
     905             : }
     906             : 
     907             : <ST_IN_SCRIPTING>"if" {
     908       80903 :         return T_IF;
     909             : }
     910             : 
     911             : <ST_IN_SCRIPTING>"elseif" {
     912        1811 :         return T_ELSEIF;
     913             : }
     914             : 
     915             : <ST_IN_SCRIPTING>"endif" {
     916           4 :         return T_ENDIF;
     917             : }
     918             : 
     919             : <ST_IN_SCRIPTING>"else" {
     920       19826 :         return T_ELSE;
     921             : }
     922             : 
     923             : <ST_IN_SCRIPTING>"while" {
     924        3094 :         return T_WHILE;
     925             : }
     926             : 
     927             : <ST_IN_SCRIPTING>"endwhile" {
     928           1 :         return T_ENDWHILE;
     929             : }
     930             : 
     931             : <ST_IN_SCRIPTING>"do" {
     932         273 :         return T_DO;
     933             : }
     934             : 
     935             : <ST_IN_SCRIPTING>"for" {
     936        1998 :         return T_FOR;
     937             : }
     938             : 
     939             : <ST_IN_SCRIPTING>"endfor" {
     940           3 :         return T_ENDFOR;
     941             : }
     942             : 
     943             : <ST_IN_SCRIPTING>"foreach" {
     944       11164 :         return T_FOREACH;
     945             : }
     946             : 
     947             : <ST_IN_SCRIPTING>"endforeach" {
     948           0 :         return T_ENDFOREACH;
     949             : }
     950             : 
     951             : <ST_IN_SCRIPTING>"declare" {
     952          12 :         return T_DECLARE;
     953             : }
     954             : 
     955             : <ST_IN_SCRIPTING>"enddeclare" {
     956           0 :         return T_ENDDECLARE;
     957             : }
     958             : 
     959             : <ST_IN_SCRIPTING>"instanceof" {
     960          64 :         return T_INSTANCEOF;
     961             : }
     962             : 
     963             : <ST_IN_SCRIPTING>"as" {
     964       11193 :         return T_AS;
     965             : }
     966             : 
     967             : <ST_IN_SCRIPTING>"switch" {
     968         446 :         return T_SWITCH;
     969             : }
     970             : 
     971             : <ST_IN_SCRIPTING>"endswitch" {
     972           1 :         return T_ENDSWITCH;
     973             : }
     974             : 
     975             : <ST_IN_SCRIPTING>"case" {
     976        1488 :         return T_CASE;
     977             : }
     978             : 
     979             : <ST_IN_SCRIPTING>"default" {
     980         269 :         return T_DEFAULT;
     981             : }
     982             : 
     983             : <ST_IN_SCRIPTING>"break" {
     984        1666 :         return T_BREAK;
     985             : }
     986             : 
     987             : <ST_IN_SCRIPTING>"continue" {
     988         238 :         return T_CONTINUE;
     989             : }
     990             : 
     991             : <ST_IN_SCRIPTING>"goto" {
     992          25 :         return T_GOTO;
     993             : }
     994             : 
     995             : <ST_IN_SCRIPTING>"echo" {
     996       30824 :         return T_ECHO;
     997             : }
     998             : 
     999             : <ST_IN_SCRIPTING>"print" {
    1000        3293 :         return T_PRINT;
    1001             : }
    1002             : 
    1003             : <ST_IN_SCRIPTING>"class" {
    1004        6541 :         return T_CLASS;
    1005             : }
    1006             : 
    1007             : <ST_IN_SCRIPTING>"interface" {
    1008         166 :         return T_INTERFACE;
    1009             : }
    1010             : 
    1011             : <ST_IN_SCRIPTING>"extends" {
    1012        2199 :         return T_EXTENDS;
    1013             : }
    1014             : 
    1015             : <ST_IN_SCRIPTING>"implements" {
    1016         263 :         return T_IMPLEMENTS;
    1017             : }
    1018             : 
    1019             : <ST_IN_SCRIPTING>"->" {
    1020       43948 :         yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
    1021       43948 :         return T_OBJECT_OPERATOR;
    1022             : }
    1023             : 
    1024             : <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ {
    1025     2392321 :         zendlval->value.str.val = yytext; /* no copying - intentional */
    1026     2392321 :         zendlval->value.str.len = yyleng;
    1027     2392321 :         zendlval->type = IS_STRING;
    1028     2392321 :         HANDLE_NEWLINES(yytext, yyleng);
    1029     2392321 :         return T_WHITESPACE;
    1030             : }
    1031             : 
    1032             : <ST_LOOKING_FOR_PROPERTY>"->" {
    1033          81 :         return T_OBJECT_OPERATOR;
    1034             : }
    1035             : 
    1036             : <ST_LOOKING_FOR_PROPERTY>{LABEL} {
    1037       43829 :         yy_pop_state(TSRMLS_C);
    1038       43829 :         zend_copy_value(zendlval, yytext, yyleng);
    1039       43829 :         zendlval->type = IS_STRING;
    1040       43829 :         return T_STRING;
    1041             : }
    1042             : 
    1043             : <ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} {
    1044         200 :         yyless(0);
    1045         200 :         yy_pop_state(TSRMLS_C);
    1046         200 :         goto restart;
    1047             : }
    1048             : 
    1049             : <ST_IN_SCRIPTING>"::" {
    1050       21170 :         return T_PAAMAYIM_NEKUDOTAYIM;
    1051             : }
    1052             : 
    1053             : <ST_IN_SCRIPTING>"\\" {
    1054         515 :         return T_NS_SEPARATOR;
    1055             : }
    1056             : 
    1057             : <ST_IN_SCRIPTING>"new" {
    1058       13468 :         return T_NEW;
    1059             : }
    1060             : 
    1061             : <ST_IN_SCRIPTING>"clone" {
    1062          89 :         return T_CLONE;
    1063             : }
    1064             : 
    1065             : <ST_IN_SCRIPTING>"var" {
    1066         108 :         return T_VAR;
    1067             : }
    1068             : 
    1069             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" {
    1070        4817 :         return T_INT_CAST;
    1071             : }
    1072             : 
    1073             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("real"|"double"|"float"){TABS_AND_SPACES}")" {
    1074          65 :         return T_DOUBLE_CAST;
    1075             : }
    1076             : 
    1077             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"string"{TABS_AND_SPACES}")" {
    1078         402 :         return T_STRING_CAST;
    1079             : }
    1080             : 
    1081             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"binary"{TABS_AND_SPACES}")" {
    1082         912 :         return T_STRING_CAST;
    1083             : }
    1084             : 
    1085             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" {
    1086          15 :         return T_ARRAY_CAST;
    1087             : }
    1088             : 
    1089             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"object"{TABS_AND_SPACES}")" {
    1090         148 :         return T_OBJECT_CAST;
    1091             : }
    1092             : 
    1093             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("bool"|"boolean"){TABS_AND_SPACES}")" {
    1094         256 :         return T_BOOL_CAST;
    1095             : }
    1096             : 
    1097             : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("unset"){TABS_AND_SPACES}")" {
    1098           1 :         return T_UNSET_CAST;
    1099             : }
    1100             : 
    1101             : <ST_IN_SCRIPTING>"eval" {
    1102        2210 :         return T_EVAL;
    1103             : }
    1104             : 
    1105             : <ST_IN_SCRIPTING>"include" {
    1106        2100 :         return T_INCLUDE;
    1107             : }
    1108             : 
    1109             : <ST_IN_SCRIPTING>"include_once" {
    1110         549 :         return T_INCLUDE_ONCE;
    1111             : }
    1112             : 
    1113             : <ST_IN_SCRIPTING>"require" {
    1114        2145 :         return T_REQUIRE;
    1115             : }
    1116             : 
    1117             : <ST_IN_SCRIPTING>"require_once" {
    1118        5742 :         return T_REQUIRE_ONCE;
    1119             : }
    1120             : 
    1121             : <ST_IN_SCRIPTING>"namespace" {
    1122         191 :         return T_NAMESPACE;
    1123             : }
    1124             : 
    1125             : <ST_IN_SCRIPTING>"use" {
    1126          90 :         return T_USE;
    1127             : }
    1128             : 
    1129             : <ST_IN_SCRIPTING>"global" {
    1130        4349 :         return T_GLOBAL;
    1131             : }
    1132             : 
    1133             : <ST_IN_SCRIPTING>"isset" {
    1134        5112 :         return T_ISSET;
    1135             : }
    1136             : 
    1137             : <ST_IN_SCRIPTING>"empty" {
    1138        7979 :         return T_EMPTY;
    1139             : }
    1140             : 
    1141             : <ST_IN_SCRIPTING>"__halt_compiler" {
    1142         277 :         return T_HALT_COMPILER;
    1143             : }
    1144             : 
    1145             : <ST_IN_SCRIPTING>"static" {
    1146        9616 :         return T_STATIC;
    1147             : }
    1148             : 
    1149             : <ST_IN_SCRIPTING>"abstract" {
    1150         121 :         return T_ABSTRACT;
    1151             : }
    1152             : 
    1153             : <ST_IN_SCRIPTING>"final" {
    1154          36 :         return T_FINAL;
    1155             : }
    1156             : 
    1157             : <ST_IN_SCRIPTING>"private" {
    1158         649 :         return T_PRIVATE;
    1159             : }
    1160             : 
    1161             : <ST_IN_SCRIPTING>"protected" {
    1162         558 :         return T_PROTECTED;
    1163             : }
    1164             : 
    1165             : <ST_IN_SCRIPTING>"public" {
    1166        3553 :         return T_PUBLIC;
    1167             : }
    1168             : 
    1169             : <ST_IN_SCRIPTING>"unset" {
    1170        1476 :         return T_UNSET;
    1171             : }
    1172             : 
    1173             : <ST_IN_SCRIPTING>"=>" {
    1174       46315 :         return T_DOUBLE_ARROW;
    1175             : }
    1176             : 
    1177             : <ST_IN_SCRIPTING>"list" {
    1178         118 :         return T_LIST;
    1179             : }
    1180             : 
    1181             : <ST_IN_SCRIPTING>"array" {
    1182       29244 :         return T_ARRAY;
    1183             : }
    1184             : 
    1185             : <ST_IN_SCRIPTING>"++" {
    1186        5829 :         return T_INC;
    1187             : }
    1188             : 
    1189             : <ST_IN_SCRIPTING>"--" {
    1190         156 :         return T_DEC;
    1191             : }
    1192             : 
    1193             : <ST_IN_SCRIPTING>"===" {
    1194        5998 :         return T_IS_IDENTICAL;
    1195             : }
    1196             : 
    1197             : <ST_IN_SCRIPTING>"!==" {
    1198        7933 :         return T_IS_NOT_IDENTICAL;
    1199             : }
    1200             : 
    1201             : <ST_IN_SCRIPTING>"==" {
    1202       16622 :         return T_IS_EQUAL;
    1203             : }
    1204             : 
    1205             : <ST_IN_SCRIPTING>"!="|"<>" {
    1206        2697 :         return T_IS_NOT_EQUAL;
    1207             : }
    1208             : 
    1209             : <ST_IN_SCRIPTING>"<=" {
    1210        1744 :         return T_IS_SMALLER_OR_EQUAL;
    1211             : }
    1212             : 
    1213             : <ST_IN_SCRIPTING>">=" {
    1214         364 :         return T_IS_GREATER_OR_EQUAL;
    1215             : }
    1216             : 
    1217             : <ST_IN_SCRIPTING>"+=" {
    1218         654 :         return T_PLUS_EQUAL;
    1219             : }
    1220             : 
    1221             : <ST_IN_SCRIPTING>"-=" {
    1222         139 :         return T_MINUS_EQUAL;
    1223             : }
    1224             : 
    1225             : <ST_IN_SCRIPTING>"*=" {
    1226          13 :         return T_MUL_EQUAL;
    1227             : }
    1228             : 
    1229             : <ST_IN_SCRIPTING>"/=" {
    1230           4 :         return T_DIV_EQUAL;
    1231             : }
    1232             : 
    1233             : <ST_IN_SCRIPTING>".=" {
    1234        2848 :         return T_CONCAT_EQUAL;
    1235             : }
    1236             : 
    1237             : <ST_IN_SCRIPTING>"%=" {
    1238           1 :         return T_MOD_EQUAL;
    1239             : }
    1240             : 
    1241             : <ST_IN_SCRIPTING>"<<=" {
    1242           4 :         return T_SL_EQUAL;
    1243             : }
    1244             : 
    1245             : <ST_IN_SCRIPTING>">>=" {
    1246           5 :         return T_SR_EQUAL;
    1247             : }
    1248             : 
    1249             : <ST_IN_SCRIPTING>"&=" {
    1250           3 :         return T_AND_EQUAL;
    1251             : }
    1252             : 
    1253             : <ST_IN_SCRIPTING>"|=" {
    1254          96 :         return T_OR_EQUAL;
    1255             : }
    1256             : 
    1257             : <ST_IN_SCRIPTING>"^=" {
    1258           2 :         return T_XOR_EQUAL;
    1259             : }
    1260             : 
    1261             : <ST_IN_SCRIPTING>"||" {
    1262        9632 :         return T_BOOLEAN_OR;
    1263             : }
    1264             : 
    1265             : <ST_IN_SCRIPTING>"&&" {
    1266        6770 :         return T_BOOLEAN_AND;
    1267             : }
    1268             : 
    1269             : <ST_IN_SCRIPTING>"OR" {
    1270         755 :         return T_LOGICAL_OR;
    1271             : }
    1272             : 
    1273             : <ST_IN_SCRIPTING>"AND" {
    1274          14 :         return T_LOGICAL_AND;
    1275             : }
    1276             : 
    1277             : <ST_IN_SCRIPTING>"XOR" {
    1278           1 :         return T_LOGICAL_XOR;
    1279             : }
    1280             : 
    1281             : <ST_IN_SCRIPTING>"<<" {
    1282         114 :         return T_SL;
    1283             : }
    1284             : 
    1285             : <ST_IN_SCRIPTING>">>" {
    1286          52 :         return T_SR;
    1287             : }
    1288             : 
    1289             : <ST_IN_SCRIPTING>{TOKENS} {
    1290     2799240 :         return yytext[0];
    1291             : }
    1292             : 
    1293             : 
    1294             : <ST_IN_SCRIPTING>"{" {
    1295      132271 :         yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
    1296      132271 :         return '{';
    1297             : }
    1298             : 
    1299             : 
    1300             : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" {
    1301          87 :         yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
    1302          87 :         return T_DOLLAR_OPEN_CURLY_BRACES;
    1303             : }
    1304             : 
    1305             : 
    1306             : <ST_IN_SCRIPTING>"}" {
    1307      132913 :         RESET_DOC_COMMENT();
    1308      132913 :         if (!zend_stack_is_empty(&SCNG(state_stack))) {
    1309      132912 :                 yy_pop_state(TSRMLS_C);
    1310             :         }
    1311      132913 :         return '}';
    1312             : }
    1313             : 
    1314             : 
    1315             : <ST_LOOKING_FOR_VARNAME>{LABEL} {
    1316          87 :         zend_copy_value(zendlval, yytext, yyleng);
    1317          87 :         zendlval->type = IS_STRING;
    1318          87 :         yy_pop_state(TSRMLS_C);
    1319          87 :         yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
    1320          87 :         return T_STRING_VARNAME;
    1321             : }
    1322             : 
    1323             : 
    1324             : <ST_LOOKING_FOR_VARNAME>{ANY_CHAR} {
    1325           0 :         yyless(0);
    1326           0 :         yy_pop_state(TSRMLS_C);
    1327           0 :         yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
    1328           0 :         goto restart;
    1329             : }
    1330             : 
    1331             : 
    1332             : <ST_IN_SCRIPTING>{LNUM} {
    1333      159052 :         if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
    1334      158875 :                 zendlval->value.lval = strtol(yytext, NULL, 0);
    1335             :         } else {
    1336         177 :                 errno = 0;
    1337         177 :                 zendlval->value.lval = strtol(yytext, NULL, 0);
    1338         177 :                 if (errno == ERANGE) { /* Overflow */
    1339          43 :                         if (yytext[0] == '0') { /* octal overflow */
    1340           1 :                                 zendlval->value.dval = zend_oct_strtod(yytext, NULL);
    1341             :                         } else {
    1342          42 :                                 zendlval->value.dval = zend_strtod(yytext, NULL);
    1343             :                         }
    1344          43 :                         zendlval->type = IS_DOUBLE;
    1345          43 :                         return T_DNUMBER;
    1346             :                 }
    1347             :         }
    1348             : 
    1349      159009 :         zendlval->type = IS_LONG;
    1350      159009 :         return T_LNUMBER;
    1351             : }
    1352             : 
    1353             : <ST_IN_SCRIPTING>{HNUM} {
    1354        1457 :         char *hex = yytext + 2; /* Skip "0x" */
    1355        1457 :         int len = yyleng - 2;
    1356             : 
    1357             :         /* Skip any leading 0s */
    1358        3624 :         while (*hex == '0') {
    1359         710 :                 hex++;
    1360         710 :                 len--;
    1361             :         }
    1362             : 
    1363        1457 :         if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
    1364        1457 :                 if (len == 0) {
    1365          56 :                         zendlval->value.lval = 0;
    1366             :                 } else {
    1367        1401 :                         zendlval->value.lval = strtol(hex, NULL, 16);
    1368             :                 }
    1369        1457 :                 zendlval->type = IS_LONG;
    1370        1457 :                 return T_LNUMBER;
    1371             :         } else {
    1372           0 :                 zendlval->value.dval = zend_hex_strtod(hex, NULL);
    1373           0 :                 zendlval->type = IS_DOUBLE;
    1374           0 :                 return T_DNUMBER;
    1375             :         }
    1376             : }
    1377             : 
    1378             : <ST_VAR_OFFSET>[0]|([1-9][0-9]*) { /* Offset could be treated as a long */
    1379         732 :         if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
    1380         366 :                 zendlval->value.lval = strtol(yytext, NULL, 10);
    1381         366 :                 zendlval->type = IS_LONG;
    1382             :         } else {
    1383           0 :                 zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
    1384           0 :                 zendlval->value.str.len = yyleng;
    1385           0 :                 zendlval->type = IS_STRING;
    1386             :         }
    1387         366 :         return T_NUM_STRING;
    1388             : }
    1389             : 
    1390             : <ST_VAR_OFFSET>{LNUM}|{HNUM} { /* Offset must be treated as a string */
    1391           0 :         zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
    1392           0 :         zendlval->value.str.len = yyleng;
    1393           0 :         zendlval->type = IS_STRING;
    1394           0 :         return T_NUM_STRING;
    1395             : }
    1396             : 
    1397             : <ST_IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} {
    1398        6795 :         zendlval->value.dval = zend_strtod(yytext, NULL);
    1399        6795 :         zendlval->type = IS_DOUBLE;
    1400        6795 :         return T_DNUMBER;
    1401             : }
    1402             : 
    1403             : <ST_IN_SCRIPTING>"__CLASS__" {
    1404          77 :         char *class_name = NULL;
    1405             : 
    1406          77 :         if (CG(active_class_entry)) {
    1407          76 :                 class_name = CG(active_class_entry)->name;
    1408             :         }
    1409             : 
    1410          77 :         if (!class_name) {
    1411           1 :                 class_name = "";
    1412             :         }
    1413          77 :         zendlval->value.str.len = strlen(class_name);
    1414          77 :         zendlval->value.str.val = estrndup(class_name, zendlval->value.str.len);
    1415          77 :         zendlval->type = IS_STRING;
    1416          77 :         return T_CLASS_C;
    1417             : }
    1418             : 
    1419             : <ST_IN_SCRIPTING>"__FUNCTION__" {
    1420          99 :         char *func_name = NULL;
    1421             : 
    1422          99 :         if (CG(active_op_array)) {
    1423          98 :                 func_name = CG(active_op_array)->function_name;
    1424             :         }
    1425             : 
    1426          99 :         if (!func_name) {
    1427           2 :                 func_name = "";
    1428             :         }
    1429          99 :         zendlval->value.str.len = strlen(func_name);
    1430          99 :         zendlval->value.str.val = estrndup(func_name, zendlval->value.str.len);
    1431          99 :         zendlval->type = IS_STRING;
    1432          99 :         return T_FUNC_C;
    1433             : }
    1434             : 
    1435             : <ST_IN_SCRIPTING>"__METHOD__" {
    1436         812 :         char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;
    1437         812 :         char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;
    1438         812 :         size_t len = 0;
    1439             : 
    1440         812 :         if (class_name) {
    1441         788 :                 len += strlen(class_name) + 2;
    1442             :         }
    1443         812 :         if (func_name) {
    1444         810 :                 len += strlen(func_name);
    1445             :         }
    1446             : 
    1447         812 :         zendlval->value.str.len = zend_spprintf(&zendlval->value.str.val, 0, "%s%s%s", 
    1448             :                 class_name ? class_name : "",
    1449             :                 class_name && func_name ? "::" : "",
    1450             :                 func_name ? func_name : ""
    1451             :                 );
    1452         812 :         zendlval->type = IS_STRING;
    1453         812 :         return T_METHOD_C;
    1454             : }
    1455             : 
    1456             : <ST_IN_SCRIPTING>"__LINE__" {
    1457          15 :         zendlval->value.lval = CG(zend_lineno);
    1458          15 :         zendlval->type = IS_LONG;
    1459          15 :         return T_LINE;
    1460             : }
    1461             : 
    1462             : <ST_IN_SCRIPTING>"__FILE__" {
    1463        8886 :         char *filename = zend_get_compiled_filename(TSRMLS_C);
    1464             : 
    1465        8886 :         if (!filename) {
    1466           0 :                 filename = "";
    1467             :         }
    1468        8886 :         zendlval->value.str.len = strlen(filename);
    1469        8886 :         zendlval->value.str.val = estrndup(filename, zendlval->value.str.len);
    1470        8886 :         zendlval->type = IS_STRING;
    1471        8886 :         return T_FILE;
    1472             : }
    1473             : 
    1474             : <ST_IN_SCRIPTING>"__DIR__" {
    1475         176 :         char *filename = zend_get_compiled_filename(TSRMLS_C);
    1476         176 :         const size_t filename_len = strlen(filename);
    1477             :         char *dirname;
    1478             : 
    1479         176 :         if (!filename) {
    1480           0 :                 filename = "";
    1481             :         }
    1482             : 
    1483         176 :         dirname = estrndup(filename, filename_len);
    1484         176 :         zend_dirname(dirname, filename_len);
    1485             : 
    1486         176 :         if (strcmp(dirname, ".") == 0) {
    1487           0 :                 dirname = erealloc(dirname, MAXPATHLEN);
    1488             : #if HAVE_GETCWD
    1489           0 :                 VCWD_GETCWD(dirname, MAXPATHLEN);
    1490             : #elif HAVE_GETWD
    1491             :                 VCWD_GETWD(dirname);
    1492             : #endif
    1493             :         }
    1494             : 
    1495         176 :         zendlval->value.str.len = strlen(dirname);
    1496         176 :         zendlval->value.str.val = dirname;
    1497         176 :         zendlval->type = IS_STRING;
    1498         176 :         return T_DIR;
    1499             : }
    1500             : 
    1501             : <ST_IN_SCRIPTING>"__NAMESPACE__" {
    1502          33 :         if (CG(current_namespace)) {
    1503          25 :                 *zendlval = *CG(current_namespace);
    1504          25 :                 zval_copy_ctor(zendlval);
    1505             :         } else {
    1506           8 :                 ZVAL_EMPTY_STRING(zendlval);
    1507             :         }
    1508          33 :         return T_NS_C;
    1509             : }
    1510             : 
    1511             : <INITIAL>"<script"{WHITESPACE}+"language"{WHITESPACE}*"="{WHITESPACE}*("php"|"\"php\""|"'php'"){WHITESPACE}*">" {
    1512           5 :         YYCTYPE *bracket = zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
    1513             : 
    1514           5 :         if (bracket != SCNG(yy_text)) {
    1515             :                 /* Handle previously scanned HTML, as possible <script> tags found are assumed to not be PHP's */
    1516           1 :                 YYCURSOR = bracket;
    1517           1 :                 goto inline_html;
    1518             :         }
    1519             : 
    1520           4 :         HANDLE_NEWLINES(yytext, yyleng);
    1521           4 :         zendlval->value.str.val = yytext; /* no copying - intentional */
    1522           4 :         zendlval->value.str.len = yyleng;
    1523           4 :         zendlval->type = IS_STRING;
    1524           4 :         BEGIN(ST_IN_SCRIPTING);
    1525           4 :         return T_OPEN_TAG;
    1526             : }
    1527             : 
    1528             : 
    1529             : <INITIAL>"<%=" {
    1530           2 :         if (CG(asp_tags)) {
    1531           2 :                 zendlval->value.str.val = yytext; /* no copying - intentional */
    1532           2 :                 zendlval->value.str.len = yyleng;
    1533           2 :                 zendlval->type = IS_STRING;
    1534           2 :                 BEGIN(ST_IN_SCRIPTING);
    1535           2 :                 return T_OPEN_TAG_WITH_ECHO;
    1536             :         } else {
    1537           0 :                 goto inline_char_handler;
    1538             :         }
    1539             : }
    1540             : 
    1541             : 
    1542             : <INITIAL>"<?=" {
    1543           4 :         if (CG(short_tags)) {
    1544           3 :                 zendlval->value.str.val = yytext; /* no copying - intentional */
    1545           3 :                 zendlval->value.str.len = yyleng;
    1546           3 :                 zendlval->type = IS_STRING;
    1547           3 :                 BEGIN(ST_IN_SCRIPTING);
    1548           3 :                 return T_OPEN_TAG_WITH_ECHO;
    1549             :         } else {
    1550           1 :                 goto inline_char_handler;
    1551             :         }
    1552             : }
    1553             : 
    1554             : 
    1555             : <INITIAL>"<%" {
    1556           0 :         if (CG(asp_tags)) {
    1557           0 :                 zendlval->value.str.val = yytext; /* no copying - intentional */
    1558           0 :                 zendlval->value.str.len = yyleng;
    1559           0 :                 zendlval->type = IS_STRING;
    1560           0 :                 BEGIN(ST_IN_SCRIPTING);
    1561           0 :                 return T_OPEN_TAG;
    1562             :         } else {
    1563           0 :                 goto inline_char_handler;
    1564             :         }
    1565             : }
    1566             : 
    1567             : 
    1568             : <INITIAL>"<?php"([ \t]|{NEWLINE}) {
    1569       29003 :         zendlval->value.str.val = yytext; /* no copying - intentional */
    1570       29003 :         zendlval->value.str.len = yyleng;
    1571       29003 :         zendlval->type = IS_STRING;
    1572       29003 :         HANDLE_NEWLINE(yytext[yyleng-1]);
    1573       29003 :         BEGIN(ST_IN_SCRIPTING);
    1574       29003 :         return T_OPEN_TAG;
    1575             : }
    1576             : 
    1577             : 
    1578             : <INITIAL>"<?" {
    1579           5 :         if (CG(short_tags)) {
    1580           4 :                 zendlval->value.str.val = yytext; /* no copying - intentional */
    1581           4 :                 zendlval->value.str.len = yyleng;
    1582           4 :                 zendlval->type = IS_STRING;
    1583           4 :                 BEGIN(ST_IN_SCRIPTING);
    1584           4 :                 return T_OPEN_TAG;
    1585             :         } else {
    1586           1 :                 goto inline_char_handler;
    1587             :         }
    1588             : }
    1589             : 
    1590             : <INITIAL>{ANY_CHAR} {
    1591       30841 :         if (YYCURSOR > YYLIMIT) {
    1592       27276 :                 return 0;
    1593             :         }
    1594             : 
    1595             : inline_char_handler:
    1596             : 
    1597             :         while (1) {
    1598        3676 :                 YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
    1599             : 
    1600        3676 :                 YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
    1601             : 
    1602        3676 :                 if (YYCURSOR < YYLIMIT) {
    1603         335 :                         switch (*YYCURSOR) {
    1604             :                                 case '?':
    1605         220 :                                         if (CG(short_tags) || !strncasecmp(YYCURSOR + 1, "php", 3)) { /* Assume [ \t\n\r] follows "php" */
    1606             :                                                 break;
    1607             :                                         }
    1608           2 :                                         continue;
    1609             :                                 case '%':
    1610           4 :                                         if (CG(asp_tags)) {
    1611           2 :                                                 break;
    1612             :                                         }
    1613           2 :                                         continue;
    1614             :                                 case 's':
    1615             :                                 case 'S':
    1616             :                                         /* Probably NOT an opening PHP <script> tag, so don't end the HTML chunk yet
    1617             :                                          * If it is, the PHP <script> tag rule checks for any HTML scanned before it */
    1618           6 :                                         YYCURSOR--;
    1619           6 :                                         yymore();
    1620             :                                 default:
    1621         105 :                                         continue;
    1622             :                         }
    1623             : 
    1624         220 :                         YYCURSOR--;
    1625             :                 }
    1626             : 
    1627        3561 :                 break;
    1628         109 :         }
    1629             : 
    1630             : inline_html:
    1631        3562 :         yyleng = YYCURSOR - SCNG(yy_text);
    1632             : 
    1633             : #ifdef ZEND_MULTIBYTE
    1634             :         if (SCNG(output_filter)) {
    1635             :                 int readsize;
    1636             :                 size_t sz = 0;
    1637             :                 readsize = SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);
    1638             :                 zendlval->value.str.len = sz;
    1639             :                 if (readsize < yyleng) {
    1640             :                         yyless(readsize);
    1641             :                 }
    1642             :         } else {
    1643             :           zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
    1644             :           zendlval->value.str.len = yyleng;
    1645             :         }
    1646             : #else /* !ZEND_MULTIBYTE */
    1647        3562 :         zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
    1648        3562 :         zendlval->value.str.len = yyleng;
    1649             : #endif
    1650        3562 :         zendlval->type = IS_STRING;
    1651        3562 :         HANDLE_NEWLINES(yytext, yyleng);
    1652        3562 :         return T_INLINE_HTML;
    1653             : }
    1654             : 
    1655             : 
    1656             : /* Make sure a label character follows "->", otherwise there is no property
    1657             :  * and "->" will be taken literally
    1658             :  */
    1659             : <ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL}"->"[a-zA-Z_\x7f-\xff] {
    1660          81 :         yyless(yyleng - 3);
    1661          81 :         yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
    1662          81 :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1663          81 :         zendlval->type = IS_STRING;
    1664          81 :         return T_VARIABLE;
    1665             : }
    1666             : 
    1667             : /* A [ always designates a variable offset, regardless of what follows
    1668             :  */
    1669             : <ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL}"[" {
    1670         950 :         yyless(yyleng - 1);
    1671         950 :         yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
    1672         950 :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1673         950 :         zendlval->type = IS_STRING;
    1674         950 :         return T_VARIABLE;
    1675             : }
    1676             : 
    1677             : <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
    1678      870729 :         zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    1679      870729 :         zendlval->type = IS_STRING;
    1680      870729 :         return T_VARIABLE;
    1681             : }
    1682             : 
    1683             : <ST_VAR_OFFSET>"]" {
    1684         948 :         yy_pop_state(TSRMLS_C);
    1685         948 :         return ']';
    1686             : }
    1687             : 
    1688             : <ST_VAR_OFFSET>{TOKENS}|[{}"`] {
    1689             :         /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
    1690         950 :         return yytext[0];
    1691             : }
    1692             : 
    1693             : <ST_VAR_OFFSET>[ \n\r\t\\'#] {
    1694             :         /* Invalid rule to return a more explicit parse error with proper line number */
    1695           2 :         yyless(0);
    1696           2 :         yy_pop_state(TSRMLS_C);
    1697           2 :         return T_ENCAPSED_AND_WHITESPACE;
    1698             : }
    1699             : 
    1700             : <ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} {
    1701      500499 :         zend_copy_value(zendlval, yytext, yyleng);
    1702      500499 :         zendlval->type = IS_STRING;
    1703      500499 :         return T_STRING;
    1704             : }
    1705             : 
    1706             : 
    1707             : <ST_IN_SCRIPTING>"#"|"//" {
    1708     1626208 :         while (YYCURSOR < YYLIMIT) {
    1709     1575591 :                 switch (*YYCURSOR++) {
    1710             :                         case '\r':
    1711         138 :                                 if (*YYCURSOR == '\n') {
    1712         138 :                                         YYCURSOR++;
    1713             :                                 }
    1714             :                                 /* fall through */
    1715             :                         case '\n':
    1716       50605 :                                 CG(zend_lineno)++;
    1717       50605 :                                 break;
    1718             :                         case '%':
    1719          28 :                                 if (!CG(asp_tags)) {
    1720          28 :                                         continue;
    1721             :                                 }
    1722             :                                 /* fall through */
    1723             :                         case '?':
    1724         547 :                                 if (*YYCURSOR == '>') {
    1725           2 :                                         YYCURSOR--;
    1726           2 :                                         break;
    1727             :                                 }
    1728             :                                 /* fall through */
    1729             :                         default:
    1730     1524956 :                                 continue;
    1731             :                 }
    1732             : 
    1733       50607 :                 break;
    1734             :         }
    1735             : 
    1736       50612 :         yyleng = YYCURSOR - SCNG(yy_text);
    1737             : 
    1738       50612 :         return T_COMMENT;
    1739             : }
    1740             : 
    1741             : <ST_IN_SCRIPTING>"/*"|"/**"{WHITESPACE} {
    1742             :         int doc_com;
    1743             : 
    1744       27082 :         if (yyleng > 2) {
    1745        2449 :                 doc_com = 1;
    1746        2449 :                 RESET_DOC_COMMENT();
    1747             :         } else {
    1748       24633 :                 doc_com = 0;
    1749             :         }
    1750             : 
    1751     4012838 :         while (YYCURSOR < YYLIMIT) {
    1752     3985755 :                 if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
    1753       27081 :                         break;
    1754             :                 }
    1755             :         }
    1756             : 
    1757       27082 :         if (YYCURSOR < YYLIMIT) {
    1758       27081 :                 YYCURSOR++;
    1759             :         } else {
    1760           1 :                 zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
    1761             :         }
    1762             : 
    1763       27082 :         yyleng = YYCURSOR - SCNG(yy_text);
    1764       27082 :         HANDLE_NEWLINES(yytext, yyleng);
    1765             : 
    1766       27082 :         if (doc_com) {
    1767        2449 :                 CG(doc_comment) = estrndup(yytext, yyleng);
    1768        2449 :                 CG(doc_comment_len) = yyleng;
    1769        2449 :                 return T_DOC_COMMENT;
    1770             :         }
    1771             : 
    1772       24633 :         return T_COMMENT;
    1773             : }
    1774             : 
    1775             : <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
    1776       27640 :         zendlval->value.str.val = yytext; /* no copying - intentional */
    1777       27640 :         zendlval->value.str.len = yyleng;
    1778       27640 :         zendlval->type = IS_STRING;
    1779       27640 :         BEGIN(INITIAL);
    1780       27640 :         return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
    1781             : }
    1782             : 
    1783             : 
    1784             : <ST_IN_SCRIPTING>"%>"{NEWLINE}? {
    1785           2 :         if (CG(asp_tags)) {
    1786           2 :                 BEGIN(INITIAL);
    1787           2 :                 zendlval->value.str.len = yyleng;
    1788           2 :                 zendlval->type = IS_STRING;
    1789           2 :                 zendlval->value.str.val = yytext; /* no copying - intentional */
    1790           2 :                 return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
    1791             :         } else {
    1792           0 :                 yyless(1);
    1793           0 :                 return yytext[0];
    1794             :         }
    1795             : }
    1796             : 
    1797             : 
    1798             : <ST_IN_SCRIPTING>b?['] {
    1799             :         register char *s, *t;
    1800             :         char *end;
    1801      276945 :         int bprefix = (yytext[0] != '\'') ? 1 : 0;
    1802             : 
    1803             :         while (1) {
    1804     2775985 :                 if (YYCURSOR < YYLIMIT) {
    1805     2775985 :                         if (*YYCURSOR == '\'') {
    1806      276945 :                                 YYCURSOR++;
    1807      276945 :                                 yyleng = YYCURSOR - SCNG(yy_text);
    1808             : 
    1809      276945 :                                 break;
    1810     2499040 :                         } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
    1811       12503 :                                 YYCURSOR++;
    1812             :                         }
    1813             :                 } else {
    1814           0 :                         yyleng = YYLIMIT - SCNG(yy_text);
    1815             : 
    1816             :                         /* Unclosed single quotes; treat similar to double quotes, but without a separate token
    1817             :                          * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
    1818             :                          * rule, which continued in ST_IN_SCRIPTING state after the quote */
    1819           0 :                         return T_ENCAPSED_AND_WHITESPACE;
    1820             :                 }
    1821     2499040 :         }
    1822             : 
    1823      276945 :         zendlval->value.str.val = estrndup(yytext+bprefix+1, yyleng-bprefix-2);
    1824      276945 :         zendlval->value.str.len = yyleng-bprefix-2;
    1825      276945 :         zendlval->type = IS_STRING;
    1826             : 
    1827             :         /* convert escape sequences */
    1828      276945 :         s = t = zendlval->value.str.val;
    1829      276945 :         end = s+zendlval->value.str.len;
    1830     3052930 :         while (s<end) {
    1831     2499040 :                 if (*s=='\\') {
    1832       12503 :                         s++;
    1833             : 
    1834       12503 :                         switch(*s) {
    1835             :                                 case '\\':
    1836             :                                 case '\'':
    1837        1410 :                                         *t++ = *s;
    1838        1410 :                                         zendlval->value.str.len--;
    1839        1410 :                                         break;
    1840             :                                 default:
    1841       11093 :                                         *t++ = '\\';
    1842       11093 :                                         *t++ = *s;
    1843             :                                         break;
    1844             :                         }
    1845             :                 } else {
    1846     2486537 :                         *t++ = *s;
    1847             :                 }
    1848             : 
    1849     2499040 :                 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
    1850        1251 :                         CG(zend_lineno)++;
    1851             :                 }
    1852     2499040 :                 s++;
    1853             :         }
    1854      276945 :         *t = 0;
    1855             : 
    1856             : #ifdef ZEND_MULTIBYTE
    1857             :         if (SCNG(output_filter)) {
    1858             :                 size_t sz = 0;
    1859             :                 s = zendlval->value.str.val;
    1860             :                 SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
    1861             :                 zendlval->value.str.len = sz;
    1862             :                 efree(s);
    1863             :         }
    1864             : #endif /* ZEND_MULTIBYTE */
    1865      276945 :         return T_CONSTANT_ENCAPSED_STRING;
    1866             : }
    1867             : 
    1868             : 
    1869             : <ST_IN_SCRIPTING>b?["] {
    1870      199942 :         int bprefix = (yytext[0] != '"') ? 1 : 0;
    1871             : 
    1872     3691136 :         while (YYCURSOR < YYLIMIT) {
    1873     3491193 :                 switch (*YYCURSOR++) {
    1874             :                         case '"':
    1875      185796 :                                 yyleng = YYCURSOR - SCNG(yy_text);
    1876      185796 :                                 zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"' TSRMLS_CC);
    1877      185796 :                                 return T_CONSTANT_ENCAPSED_STRING;
    1878             :                         case '$':
    1879       14150 :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    1880             :                                         break;
    1881             :                                 }
    1882         382 :                                 continue;
    1883             :                         case '{':
    1884         539 :                                 if (*YYCURSOR == '$') {
    1885         377 :                                         break;
    1886             :                                 }
    1887         162 :                                 continue;
    1888             :                         case '\\':
    1889       56180 :                                 if (YYCURSOR < YYLIMIT) {
    1890       56180 :                                         YYCURSOR++;
    1891             :                                 }
    1892             :                                 /* fall through */
    1893             :                         default:
    1894     3290708 :                                 continue;
    1895             :                 }
    1896             : 
    1897       14145 :                 YYCURSOR--;
    1898       14145 :                 break;
    1899             :         }
    1900             : 
    1901             :         /* Remember how much was scanned to save rescanning */
    1902       14146 :         SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
    1903             : 
    1904       14146 :         YYCURSOR = SCNG(yy_text) + yyleng;
    1905             : 
    1906       14146 :         BEGIN(ST_DOUBLE_QUOTES);
    1907       14146 :         return '"';
    1908             : }
    1909             : 
    1910             : 
    1911             : <ST_IN_SCRIPTING>b?"<<<"{TABS_AND_SPACES}({LABEL}|([']{LABEL}['])|(["]{LABEL}["])){NEWLINE} {
    1912             :         char *s;
    1913        1425 :         int bprefix = (yytext[0] != '<') ? 1 : 0;
    1914             : 
    1915             :         /* save old heredoc label */
    1916        1425 :         Z_STRVAL_P(zendlval) = CG(heredoc);
    1917        1425 :         Z_STRLEN_P(zendlval) = CG(heredoc_len);
    1918             : 
    1919        1425 :         CG(zend_lineno)++;
    1920        1425 :         CG(heredoc_len) = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
    1921        1425 :         s = yytext+bprefix+3;
    1922        2885 :         while ((*s == ' ') || (*s == '\t')) {
    1923          35 :                 s++;
    1924          35 :                 CG(heredoc_len)--;
    1925             :         }
    1926             : 
    1927        1425 :         if (*s == '\'') {
    1928          42 :                 s++;
    1929          42 :                 CG(heredoc_len) -= 2;
    1930             : 
    1931          42 :                 BEGIN(ST_NOWDOC);
    1932             :         } else {
    1933        1383 :                 if (*s == '"') {
    1934           7 :                         s++;
    1935           7 :                         CG(heredoc_len) -= 2;
    1936             :                 }
    1937             : 
    1938        1383 :                 BEGIN(ST_HEREDOC);
    1939             :         }
    1940             : 
    1941        1425 :         CG(heredoc) = estrndup(s, CG(heredoc_len));
    1942             : 
    1943             :         /* Check for ending label on the next line */
    1944        1425 :         if (CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, CG(heredoc_len))) {
    1945          66 :                 YYCTYPE *end = YYCURSOR + CG(heredoc_len);
    1946             : 
    1947          66 :                 if (*end == ';') {
    1948          61 :                         end++;
    1949             :                 }
    1950             : 
    1951          66 :                 if (*end == '\n' || *end == '\r') {
    1952          62 :                         BEGIN(ST_END_HEREDOC);
    1953             :                 }
    1954             :         }
    1955             : 
    1956        1425 :         return T_START_HEREDOC;
    1957             : }
    1958             : 
    1959             : 
    1960             : <ST_IN_SCRIPTING>[`] {
    1961         108 :         BEGIN(ST_BACKQUOTE);
    1962         108 :         return '`';
    1963             : }
    1964             : 
    1965             : 
    1966             : <ST_END_HEREDOC>{ANY_CHAR} {
    1967        1422 :         YYCURSOR += CG(heredoc_len) - 1;
    1968        1422 :         yyleng = CG(heredoc_len);
    1969             : 
    1970        1422 :         Z_STRVAL_P(zendlval) = CG(heredoc);
    1971        1422 :         Z_STRLEN_P(zendlval) = CG(heredoc_len);
    1972        1422 :         CG(heredoc) = NULL;
    1973        1422 :         CG(heredoc_len) = 0;
    1974        1422 :         BEGIN(ST_IN_SCRIPTING);
    1975        1422 :         return T_END_HEREDOC;
    1976             : }
    1977             : 
    1978             : 
    1979             : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
    1980         631 :         zendlval->value.lval = (long) '{';
    1981         631 :         yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
    1982         631 :         yyless(1);
    1983         631 :         return T_CURLY_OPEN;
    1984             : }
    1985             : 
    1986             : 
    1987             : <ST_DOUBLE_QUOTES>["] {
    1988       14143 :         BEGIN(ST_IN_SCRIPTING);
    1989       14143 :         return '"';
    1990             : }
    1991             : 
    1992             : <ST_BACKQUOTE>[`] {
    1993         108 :         BEGIN(ST_IN_SCRIPTING);
    1994         108 :         return '`';
    1995             : }
    1996             : 
    1997             : 
    1998             : <ST_DOUBLE_QUOTES>{ANY_CHAR} {
    1999       25637 :         if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
    2000        9719 :                 YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
    2001        9719 :                 SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
    2002             : 
    2003        9719 :                 goto double_quotes_scan_done;
    2004             :         }
    2005             : 
    2006       15918 :         if (YYCURSOR > YYLIMIT) {
    2007           1 :                 return 0;
    2008             :         }
    2009       15917 :         if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
    2010        2160 :                 YYCURSOR++;
    2011             :         }
    2012             : 
    2013       98064 :         while (YYCURSOR < YYLIMIT) {
    2014       82147 :                 switch (*YYCURSOR++) {
    2015             :                         case '"':
    2016        9283 :                                 break;
    2017             :                         case '$':
    2018        6420 :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    2019             :                                         break;
    2020             :                                 }
    2021           1 :                                 continue;
    2022             :                         case '{':
    2023         229 :                                 if (*YYCURSOR == '$') {
    2024         215 :                                         break;
    2025             :                                 }
    2026          14 :                                 continue;
    2027             :                         case '\\':
    2028        5532 :                                 if (YYCURSOR < YYLIMIT) {
    2029        5532 :                                         YYCURSOR++;
    2030             :                                 }
    2031             :                                 /* fall through */
    2032             :                         default:
    2033       66215 :                                 continue;
    2034             :                 }
    2035             : 
    2036       15917 :                 YYCURSOR--;
    2037       15917 :                 break;
    2038             :         }
    2039             : 
    2040             : double_quotes_scan_done:
    2041       25636 :         yyleng = YYCURSOR - SCNG(yy_text);
    2042             : 
    2043       25636 :         zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
    2044       25636 :         return T_ENCAPSED_AND_WHITESPACE;
    2045             : }
    2046             : 
    2047             : 
    2048             : <ST_BACKQUOTE>{ANY_CHAR} {
    2049         171 :         if (YYCURSOR > YYLIMIT) {
    2050           0 :                 return 0;
    2051             :         }
    2052         171 :         if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
    2053           0 :                 YYCURSOR++;
    2054             :         }
    2055             : 
    2056        2593 :         while (YYCURSOR < YYLIMIT) {
    2057        2422 :                 switch (*YYCURSOR++) {
    2058             :                         case '`':
    2059          95 :                                 break;
    2060             :                         case '$':
    2061          76 :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    2062             :                                         break;
    2063             :                                 }
    2064           0 :                                 continue;
    2065             :                         case '{':
    2066           4 :                                 if (*YYCURSOR == '$') {
    2067           0 :                                         break;
    2068             :                                 }
    2069           4 :                                 continue;
    2070             :                         case '\\':
    2071           6 :                                 if (YYCURSOR < YYLIMIT) {
    2072           6 :                                         YYCURSOR++;
    2073             :                                 }
    2074             :                                 /* fall through */
    2075             :                         default:
    2076        2247 :                                 continue;
    2077             :                 }
    2078             : 
    2079         171 :                 YYCURSOR--;
    2080         171 :                 break;
    2081             :         }
    2082             : 
    2083         171 :         yyleng = YYCURSOR - SCNG(yy_text);
    2084             : 
    2085         171 :         zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
    2086         171 :         return T_ENCAPSED_AND_WHITESPACE;
    2087             : }
    2088             : 
    2089             : 
    2090             : <ST_HEREDOC>{ANY_CHAR} {
    2091        1789 :         int newline = 0;
    2092             : 
    2093        1789 :         if (YYCURSOR > YYLIMIT) {
    2094           1 :                 return 0;
    2095             :         }
    2096             : 
    2097        1788 :         YYCURSOR--;
    2098             : 
    2099      321967 :         while (YYCURSOR < YYLIMIT) {
    2100      320178 :                 switch (*YYCURSOR++) {
    2101             :                         case '\r':
    2102           0 :                                 if (*YYCURSOR == '\n') {
    2103           0 :                                         YYCURSOR++;
    2104             :                                 }
    2105             :                                 /* fall through */
    2106             :                         case '\n':
    2107             :                                 /* Check for ending label on the next line */
    2108        9551 :                                 if (IS_LABEL_START(*YYCURSOR) && CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, CG(heredoc), CG(heredoc_len))) {
    2109        1327 :                                         YYCTYPE *end = YYCURSOR + CG(heredoc_len);
    2110             : 
    2111        1327 :                                         if (*end == ';') {
    2112        1304 :                                                 end++;
    2113             :                                         }
    2114             : 
    2115        1327 :                                         if (*end == '\n' || *end == '\r') {
    2116             :                                                 /* newline before label will be subtracted from returned text, but
    2117             :                                                  * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
    2118        1323 :                                                 if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
    2119           0 :                                                         newline = 2; /* Windows newline */
    2120             :                                                 } else {
    2121        1323 :                                                         newline = 1;
    2122             :                                                 }
    2123             : 
    2124        1323 :                                                 CG(increment_lineno) = 1; /* For newline before label */
    2125        1323 :                                                 BEGIN(ST_END_HEREDOC);
    2126             : 
    2127        1323 :                                                 goto heredoc_scan_done;
    2128             :                                         }
    2129             :                                 }
    2130        8228 :                                 continue;
    2131             :                         case '$':
    2132         520 :                                 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
    2133             :                                         break;
    2134             :                                 }
    2135          79 :                                 continue;
    2136             :                         case '{':
    2137          48 :                                 if (*YYCURSOR == '$') {
    2138          23 :                                         break;
    2139             :                                 }
    2140          25 :                                 continue;
    2141             :                         case '\\':
    2142         611 :                                 if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
    2143         603 :                                         YYCURSOR++;
    2144             :                                 }
    2145             :                                 /* fall through */
    2146             :                         default:
    2147      310059 :                                 continue;
    2148             :                 }
    2149             : 
    2150         464 :                 YYCURSOR--;
    2151         464 :                 break;
    2152             :         }
    2153             : 
    2154             : heredoc_scan_done:
    2155        1788 :         yyleng = YYCURSOR - SCNG(yy_text);
    2156             : 
    2157        1788 :         zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
    2158        1788 :         return T_ENCAPSED_AND_WHITESPACE;
    2159             : }
    2160             : 
    2161             : 
    2162             : <ST_NOWDOC>{ANY_CHAR} {
    2163          37 :         int newline = 0;
    2164             : 
    2165          37 :         if (YYCURSOR > YYLIMIT) {
    2166           0 :                 return 0;
    2167             :         }
    2168             : 
    2169          37 :         YYCURSOR--;
    2170             : 
    2171        1540 :         while (YYCURSOR < YYLIMIT) {
    2172        1503 :                 switch (*YYCURSOR++) {
    2173             :                         case '\r':
    2174           0 :                                 if (*YYCURSOR == '\n') {
    2175           0 :                                         YYCURSOR++;
    2176             :                                 }
    2177             :                                 /* fall through */
    2178             :                         case '\n':
    2179             :                                 /* Check for ending label on the next line */
    2180         106 :                                 if (IS_LABEL_START(*YYCURSOR) && CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, CG(heredoc), CG(heredoc_len))) {
    2181          42 :                                         YYCTYPE *end = YYCURSOR + CG(heredoc_len);
    2182             : 
    2183          42 :                                         if (*end == ';') {
    2184          33 :                                                 end++;
    2185             :                                         }
    2186             : 
    2187          42 :                                         if (*end == '\n' || *end == '\r') {
    2188             :                                                 /* newline before label will be subtracted from returned text, but
    2189             :                                                  * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
    2190          37 :                                                 if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
    2191           0 :                                                         newline = 2; /* Windows newline */
    2192             :                                                 } else {
    2193          37 :                                                         newline = 1;
    2194             :                                                 }
    2195             : 
    2196          37 :                                                 CG(increment_lineno) = 1; /* For newline before label */
    2197          37 :                                                 BEGIN(ST_END_HEREDOC);
    2198             : 
    2199          37 :                                                 goto nowdoc_scan_done;
    2200             :                                         }
    2201             :                                 }
    2202             :                                 /* fall through */
    2203             :                         default:
    2204        1466 :                                 continue;
    2205             :                 }
    2206             :         }
    2207             : 
    2208             : nowdoc_scan_done:
    2209          37 :         yyleng = YYCURSOR - SCNG(yy_text);
    2210             : 
    2211          37 :         zend_copy_value(zendlval, yytext, yyleng - newline);
    2212          37 :         zendlval->type = IS_STRING;
    2213          37 :         HANDLE_NEWLINES(yytext, yyleng - newline);
    2214          37 :         return T_ENCAPSED_AND_WHITESPACE;
    2215             : }
    2216             : 
    2217             : 
    2218             : <ST_IN_SCRIPTING,ST_VAR_OFFSET>{ANY_CHAR} {
    2219        1949 :         if (YYCURSOR > YYLIMIT) {
    2220        1949 :                 return 0;
    2221             :         }
    2222             : 
    2223           0 :         zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
    2224           0 :         goto restart;
    2225             : }
    2226             : 
    2227             : */
    2228             : }

Generated by: LCOV version 1.10

Generated at Fri, 18 Apr 2014 07:01:39 +0000 (6 days ago)

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