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: 928 1060 87.5 %
Date: 2015-05-21 Functions: 26 28 92.9 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Thu, 21 May 2015 19:59:08 +0000 (36 hours ago)

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