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: 922 1069 86.2 %
Date: 2014-08-04 Functions: 26 28 92.9 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

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

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