/docs/official-grammars/php/5.3.0/zend_language_scanner.l
LEX | 2200 lines | 1702 code | 377 blank | 121 comment | 0 complexity | 8617beea79988cac77f69fc670e09b54 MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0, LGPL-2.0, Apache-2.0
Large files files are truncated, but you can click here to view the full file
- /*
- +----------------------------------------------------------------------+
- | Zend Engine |
- +----------------------------------------------------------------------+
- | Copyright (c) 1998-2009 Zend Technologies Ltd. (http://www.zend.com) |
- +----------------------------------------------------------------------+
- | This source file is subject to version 2.00 of the Zend license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.zend.com/license/2_00.txt. |
- | If you did not receive a copy of the Zend license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@zend.com so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Authors: Marcus Boerger <helly@php.net> |
- | Nuno Lopes <nlopess@php.net> |
- | Scott MacVicar <scottmac@php.net> |
- | Flex version authors: |
- | Andi Gutmans <andi@zend.com> |
- | Zeev Suraski <zeev@zend.com> |
- +----------------------------------------------------------------------+
- */
- /* $Id: zend_language_scanner.l,v 1.131.2.11.2.13.2.40 2009/05/05 01:35:44 mattwil Exp $ */
- #if 0
- # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
- #else
- # define YYDEBUG(s, c)
- #endif
- #include "zend_language_scanner_defs.h"
- #include <errno.h>
- #include "zend.h"
- #include "zend_alloc.h"
- #include <zend_language_parser.h>
- #include "zend_compile.h"
- #include "zend_language_scanner.h"
- #include "zend_highlight.h"
- #include "zend_constants.h"
- #include "zend_variables.h"
- #include "zend_operators.h"
- #include "zend_API.h"
- #include "zend_strtod.h"
- #include "zend_exceptions.h"
- #include "tsrm_virtual_cwd.h"
- #include "tsrm_config_common.h"
- #define YYCTYPE unsigned char
- #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
- #define YYCURSOR SCNG(yy_cursor)
- #define YYLIMIT SCNG(yy_limit)
- #define YYMARKER SCNG(yy_marker)
- #define YYGETCONDITION() SCNG(yy_state)
- #define YYSETCONDITION(s) SCNG(yy_state) = s
- #define STATE(name) yyc##name
- /* emulate flex constructs */
- #define BEGIN(state) YYSETCONDITION(STATE(state))
- #define YYSTATE YYGETCONDITION()
- #define yytext ((char*)SCNG(yy_text))
- #define yyleng SCNG(yy_leng)
- #define yyless(x) do { YYCURSOR = (unsigned char*)yytext + x; \
- yyleng = (unsigned int)x; } while(0)
- #define yymore() goto yymore_restart
- /* perform sanity check. If this message is triggered you should
- increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
- /*!max:re2c */
- #if ZEND_MMAP_AHEAD < YYMAXFILL
- # error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
- #endif
- #ifdef HAVE_STDARG_H
- # include <stdarg.h>
- #endif
- #ifdef HAVE_UNISTD_H
- # include <unistd.h>
- #endif
- /* Globals Macros */
- #define SCNG LANG_SCNG
- #ifdef ZTS
- ZEND_API ts_rsrc_id language_scanner_globals_id;
- #else
- ZEND_API zend_php_scanner_globals language_scanner_globals;
- #endif
- #define HANDLE_NEWLINES(s, l) \
- do { \
- char *p = (s), *boundary = p+(l); \
- \
- while (p<boundary) { \
- if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) { \
- CG(zend_lineno)++; \
- } \
- p++; \
- } \
- } while (0)
- #define HANDLE_NEWLINE(c) \
- { \
- if (c == '\n' || c == '\r') { \
- CG(zend_lineno)++; \
- } \
- }
- /* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
- #define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
- #define GET_DOUBLE_QUOTES_SCANNED_LENGTH() CG(doc_comment_len)
- #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
- #define ZEND_IS_OCT(c) ((c)>='0' && (c)<='7')
- #define ZEND_IS_HEX(c) (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
- BEGIN_EXTERN_C()
- static void _yy_push_state(int new_state TSRMLS_DC)
- {
- zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));
- YYSETCONDITION(new_state);
- }
- #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
- static void yy_pop_state(TSRMLS_D)
- {
- int *stack_state;
- zend_stack_top(&SCNG(state_stack), (void **) &stack_state);
- YYSETCONDITION(*stack_state);
- zend_stack_del_top(&SCNG(state_stack));
- }
- static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
- {
- YYCURSOR = (YYCTYPE*)str;
- SCNG(yy_start) = YYCURSOR;
- YYLIMIT = YYCURSOR + len;
- }
- void startup_scanner(TSRMLS_D)
- {
- CG(heredoc) = NULL;
- CG(heredoc_len) = 0;
- CG(doc_comment) = NULL;
- CG(doc_comment_len) = 0;
- zend_stack_init(&SCNG(state_stack));
- }
- void shutdown_scanner(TSRMLS_D)
- {
- if (CG(heredoc)) {
- efree(CG(heredoc));
- CG(heredoc_len)=0;
- }
- zend_stack_destroy(&SCNG(state_stack));
- RESET_DOC_COMMENT();
- }
- ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
- {
- lex_state->yy_leng = SCNG(yy_leng);
- lex_state->yy_start = SCNG(yy_start);
- lex_state->yy_text = SCNG(yy_text);
- lex_state->yy_cursor = SCNG(yy_cursor);
- lex_state->yy_marker = SCNG(yy_marker);
- lex_state->yy_limit = SCNG(yy_limit);
- lex_state->state_stack = SCNG(state_stack);
- zend_stack_init(&SCNG(state_stack));
- lex_state->in = SCNG(yy_in);
- lex_state->yy_state = YYSTATE;
- lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
- lex_state->lineno = CG(zend_lineno);
- #ifdef ZEND_MULTIBYTE
- lex_state->script_org = SCNG(script_org);
- lex_state->script_org_size = SCNG(script_org_size);
- lex_state->script_filtered = SCNG(script_filtered);
- lex_state->script_filtered_size = SCNG(script_filtered_size);
- lex_state->input_filter = SCNG(input_filter);
- lex_state->output_filter = SCNG(output_filter);
- lex_state->script_encoding = SCNG(script_encoding);
- lex_state->internal_encoding = SCNG(internal_encoding);
- #endif /* ZEND_MULTIBYTE */
- }
- ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
- {
- SCNG(yy_leng) = lex_state->yy_leng;
- SCNG(yy_start) = lex_state->yy_start;
- SCNG(yy_text) = lex_state->yy_text;
- SCNG(yy_cursor) = lex_state->yy_cursor;
- SCNG(yy_marker) = lex_state->yy_marker;
- SCNG(yy_limit) = lex_state->yy_limit;
- zend_stack_destroy(&SCNG(state_stack));
- SCNG(state_stack) = lex_state->state_stack;
- SCNG(yy_in) = lex_state->in;
- YYSETCONDITION(lex_state->yy_state);
- CG(zend_lineno) = lex_state->lineno;
- zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- SCNG(script_org) = NULL;
- }
- if (SCNG(script_filtered)) {
- efree(SCNG(script_filtered));
- SCNG(script_filtered) = NULL;
- }
- SCNG(script_org) = lex_state->script_org;
- SCNG(script_org_size) = lex_state->script_org_size;
- SCNG(script_filtered) = lex_state->script_filtered;
- SCNG(script_filtered_size) = lex_state->script_filtered_size;
- SCNG(input_filter) = lex_state->input_filter;
- SCNG(output_filter) = lex_state->output_filter;
- SCNG(script_encoding) = lex_state->script_encoding;
- SCNG(internal_encoding) = lex_state->internal_encoding;
- #endif /* ZEND_MULTIBYTE */
- }
- ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
- {
- zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
- /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
- file_handle->opened_path = NULL;
- if (file_handle->free_filename) {
- file_handle->filename = NULL;
- }
- }
- ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
- {
- char *file_path = NULL, *buf;
- size_t size;
- if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {
- return FAILURE;
- }
- zend_llist_add_element(&CG(open_files), file_handle);
- if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
- zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
- size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
- fh->handle.stream.handle = (void*)(((char*)fh) + diff);
- file_handle->handle.stream.handle = fh->handle.stream.handle;
- }
- /* Reset the scanner for scanning the new file */
- SCNG(yy_in) = file_handle;
- if (size != -1) {
- #ifdef ZEND_MULTIBYTE
- if (zend_multibyte_read_script((unsigned char *)buf, size TSRMLS_CC) != 0) {
- return FAILURE;
- }
- SCNG(yy_in) = NULL;
- zend_multibyte_set_filter(NULL TSRMLS_CC);
- if (!SCNG(input_filter)) {
- SCNG(script_filtered) = (unsigned char*)emalloc(SCNG(script_org_size)+1);
- memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
- SCNG(script_filtered_size) = SCNG(script_org_size);
- } else {
- SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
- }
- yy_scan_buffer((char *)SCNG(script_filtered), SCNG(script_filtered_size) TSRMLS_CC);
- #else /* !ZEND_MULTIBYTE */
- yy_scan_buffer(buf, size TSRMLS_CC);
- #endif /* ZEND_MULTIBYTE */
- } else {
- zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
- }
- BEGIN(INITIAL);
- if (file_handle->opened_path) {
- file_path = file_handle->opened_path;
- } else {
- file_path = file_handle->filename;
- }
- zend_set_compiled_filename(file_path TSRMLS_CC);
- if (CG(start_lineno)) {
- CG(zend_lineno) = CG(start_lineno);
- CG(start_lineno) = 0;
- } else {
- CG(zend_lineno) = 1;
- }
- CG(increment_lineno) = 0;
- return SUCCESS;
- }
- END_EXTERN_C()
- ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
- {
- zend_lex_state original_lex_state;
- zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
- zend_op_array *original_active_op_array = CG(active_op_array);
- zend_op_array *retval=NULL;
- int compiler_result;
- zend_bool compilation_successful=0;
- znode retval_znode;
- zend_bool original_in_compilation = CG(in_compilation);
- retval_znode.op_type = IS_CONST;
- retval_znode.u.constant.type = IS_LONG;
- retval_znode.u.constant.value.lval = 1;
- Z_UNSET_ISREF(retval_znode.u.constant);
- Z_SET_REFCOUNT(retval_znode.u.constant, 1);
- zend_save_lexical_state(&original_lex_state TSRMLS_CC);
- retval = op_array; /* success oriented */
- if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
- if (type==ZEND_REQUIRE) {
- zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename TSRMLS_CC);
- zend_bailout();
- } else {
- zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename TSRMLS_CC);
- }
- compilation_successful=0;
- } else {
- init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
- CG(in_compilation) = 1;
- CG(active_op_array) = op_array;
- compiler_result = zendparse(TSRMLS_C);
- zend_do_return(&retval_znode, 0 TSRMLS_CC);
- CG(in_compilation) = original_in_compilation;
- if (compiler_result==1) { /* parser error */
- zend_bailout();
- }
- compilation_successful=1;
- }
- if (retval) {
- CG(active_op_array) = original_active_op_array;
- if (compilation_successful) {
- pass_two(op_array TSRMLS_CC);
- zend_release_labels(TSRMLS_C);
- } else {
- efree(op_array);
- retval = NULL;
- }
- }
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- return retval;
- }
- zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
- {
- zend_file_handle file_handle;
- zval tmp;
- zend_op_array *retval;
- char *opened_path = NULL;
- if (filename->type != IS_STRING) {
- tmp = *filename;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- filename = &tmp;
- }
- file_handle.filename = filename->value.str.val;
- file_handle.free_filename = 0;
- file_handle.type = ZEND_HANDLE_FILENAME;
- file_handle.opened_path = NULL;
- file_handle.handle.fp = NULL;
- retval = zend_compile_file(&file_handle, type TSRMLS_CC);
- if (retval && file_handle.handle.stream.handle) {
- int dummy = 1;
- if (!file_handle.opened_path) {
- file_handle.opened_path = opened_path = estrndup(filename->value.str.val, filename->value.str.len);
- }
- zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
- if (opened_path) {
- efree(opened_path);
- }
- }
- zend_destroy_file_handle(&file_handle TSRMLS_CC);
- if (filename==&tmp) {
- zval_dtor(&tmp);
- }
- return retval;
- }
- ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
- {
- /* enforce two trailing NULLs for flex... */
- str->value.str.val = safe_erealloc(str->value.str.val, 1, str->value.str.len, ZEND_MMAP_AHEAD);
- memset(str->value.str.val + str->value.str.len, 0, ZEND_MMAP_AHEAD);
- SCNG(yy_in)=NULL;
- #ifdef ZEND_MULTIBYTE
- SCNG(script_org) = (unsigned char *)estrdup(str->value.str.val);
- SCNG(script_org_size) = str->value.str.len;
- zend_multibyte_set_filter(CG(internal_encoding) TSRMLS_CC);
- if (!SCNG(input_filter)) {
- SCNG(script_filtered) = (unsigned char*)emalloc(SCNG(script_org_size)+1);
- memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
- SCNG(script_filtered_size) = SCNG(script_org_size);
- } else {
- SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
- }
- yy_scan_buffer((char *)SCNG(script_filtered), SCNG(script_filtered_size) TSRMLS_CC);
- #else /* !ZEND_MULTIBYTE */
- yy_scan_buffer(str->value.str.val, str->value.str.len TSRMLS_CC);
- #endif /* ZEND_MULTIBYTE */
- zend_set_compiled_filename(filename TSRMLS_CC);
- CG(zend_lineno) = 1;
- CG(increment_lineno) = 0;
- return SUCCESS;
- }
- ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D)
- {
- size_t offset = SCNG(yy_cursor) - SCNG(yy_start);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(input_filter)) {
- size_t original_offset = offset, length = 0; do {
- unsigned char *p = NULL;
- SCNG(input_filter)(&p, &length, SCNG(script_org), offset TSRMLS_CC);
- if (!p) {
- break;
- }
- efree(p);
- if (length > original_offset) {
- offset--;
- } else if (length < original_offset) {
- offset++;
- }
- } while (original_offset != length);
- }
- #endif
- return offset;
- }
- zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
- {
- zend_lex_state original_lex_state;
- zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
- zend_op_array *original_active_op_array = CG(active_op_array);
- zend_op_array *retval;
- zval tmp;
- int compiler_result;
- zend_bool original_in_compilation = CG(in_compilation);
- if (source_string->value.str.len==0) {
- efree(op_array);
- return NULL;
- }
- CG(in_compilation) = 1;
- tmp = *source_string;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- source_string = &tmp;
- zend_save_lexical_state(&original_lex_state TSRMLS_CC);
- if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
- efree(op_array);
- retval = NULL;
- } else {
- zend_bool orig_interactive = CG(interactive);
- CG(interactive) = 0;
- init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
- CG(interactive) = orig_interactive;
- CG(active_op_array) = op_array;
- BEGIN(ST_IN_SCRIPTING);
- compiler_result = zendparse(TSRMLS_C);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- SCNG(script_org) = NULL;
- }
- if (SCNG(script_filtered)) {
- efree(SCNG(script_filtered));
- SCNG(script_filtered) = NULL;
- }
- #endif /* ZEND_MULTIBYTE */
- if (compiler_result==1) {
- CG(active_op_array) = original_active_op_array;
- CG(unclean_shutdown)=1;
- retval = NULL;
- } else {
- zend_do_return(NULL, 0 TSRMLS_CC);
- CG(active_op_array) = original_active_op_array;
- pass_two(op_array TSRMLS_CC);
- zend_release_labels(TSRMLS_C);
- retval = op_array;
- }
- }
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- zval_dtor(&tmp);
- CG(in_compilation) = original_in_compilation;
- return retval;
- }
- BEGIN_EXTERN_C()
- int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
- {
- zend_lex_state original_lex_state;
- zend_file_handle file_handle;
- file_handle.type = ZEND_HANDLE_FILENAME;
- file_handle.filename = filename;
- file_handle.free_filename = 0;
- file_handle.opened_path = NULL;
- zend_save_lexical_state(&original_lex_state TSRMLS_CC);
- if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
- zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename TSRMLS_CC);
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- return FAILURE;
- }
- zend_highlight(syntax_highlighter_ini TSRMLS_CC);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- SCNG(script_org) = NULL;
- }
- if (SCNG(script_filtered)) {
- efree(SCNG(script_filtered));
- SCNG(script_filtered) = NULL;
- }
- #endif /* ZEND_MULTIBYTE */
- zend_destroy_file_handle(&file_handle TSRMLS_CC);
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- return SUCCESS;
- }
- int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)
- {
- zend_lex_state original_lex_state;
- zval tmp = *str;
- str = &tmp;
- zval_copy_ctor(str);
- zend_save_lexical_state(&original_lex_state TSRMLS_CC);
- if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- return FAILURE;
- }
- BEGIN(INITIAL);
- zend_highlight(syntax_highlighter_ini TSRMLS_CC);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- SCNG(script_org) = NULL;
- }
- if (SCNG(script_filtered)) {
- efree(SCNG(script_filtered));
- SCNG(script_filtered) = NULL;
- }
- #endif /* ZEND_MULTIBYTE */
- zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
- zval_dtor(str);
- return SUCCESS;
- }
- END_EXTERN_C()
- #ifdef ZEND_MULTIBYTE
- BEGIN_EXTERN_C()
- ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, zend_encoding *old_encoding TSRMLS_DC)
- {
- size_t original_offset, offset, free_flag, new_len, length;
- unsigned char *p;
- /* calculate current position */
- offset = original_offset = YYCURSOR - SCNG(yy_start);
- if (old_input_filter && offset > 0) {
- zend_encoding *new_encoding = SCNG(script_encoding);
- zend_encoding_filter new_filter = SCNG(input_filter);
- SCNG(script_encoding) = old_encoding;
- SCNG(input_filter) = old_input_filter;
- offset = zend_get_scanned_file_offset(TSRMLS_C);
- SCNG(script_encoding) = new_encoding;
- SCNG(input_filter) = new_filter;
- }
- /* convert and set */
- if (!SCNG(input_filter)) {
- length = SCNG(script_org_size) - offset;
- p = SCNG(script_org) + offset;
- free_flag = 0;
- } else {
- SCNG(input_filter)(&p, &length, SCNG(script_org) + offset, SCNG(script_org_size) - offset TSRMLS_CC);
- free_flag = 1;
- }
- new_len = original_offset + length;
- if (new_len > YYLIMIT - SCNG(yy_start)) {
- unsigned char *new_yy_start = erealloc(SCNG(yy_start), new_len);
- SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));
- SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));
- SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));
- SCNG(yy_start) = new_yy_start;
- SCNG(script_filtered) = new_yy_start;
- SCNG(script_filtered_size) = new_len;
- }
- SCNG(yy_limit) = SCNG(yy_start) + new_len;
- memmove(SCNG(yy_start) + original_offset, p, length);
- if (free_flag) {
- efree(p);
- }
- }
- ZEND_API int zend_multibyte_yyinput(zend_file_handle *file_handle, char *buf, size_t len TSRMLS_DC)
- {
- size_t n;
- if (CG(interactive) == 0) {
- if (zend_stream_fixup(file_handle, &buf, &len TSRMLS_CC) == FAILURE) {
- return FAILURE;
- }
- n = len;
- return n;
- }
- /* interactive */
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- }
- if (SCNG(script_filtered)) {
- efree(SCNG(script_filtered));
- }
- SCNG(script_org) = NULL;
- SCNG(script_org_size) = 0;
- /* TODO: support widechars */
- if (zend_stream_fixup(file_handle, &buf, &len TSRMLS_CC) == FAILURE) {
- return FAILURE;
- }
- n = len;
- SCNG(script_org_size) = n;
- SCNG(script_org) = (unsigned char*)emalloc(SCNG(script_org_size) + 1);
- memcpy(SCNG(script_org), buf, n);
- return n;
- }
- ZEND_API int zend_multibyte_read_script(unsigned char *buf, size_t n TSRMLS_DC)
- {
- if (SCNG(script_org)) {
- efree(SCNG(script_org));
- }
- SCNG(script_org_size) = n;
- SCNG(script_org) = (unsigned char*)erealloc(SCNG(script_org), SCNG(script_org_size));
- memcpy(SCNG(script_org) + SCNG(script_org_size) - n, buf, n);
-
- SCNG(script_org) = (unsigned char*)erealloc(SCNG(script_org), SCNG(script_org_size) + 1);
- *(SCNG(script_org)+SCNG(script_org_size)) = '\0';
- return 0;
- }
- # define zend_copy_value(zendlval, yytext, yyleng) \
- if (SCNG(output_filter)) { \
- size_t sz = 0; \
- SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \
- zendlval->value.str.len = sz; \
- } else { \
- zendlval->value.str.val = (char *) estrndup(yytext, yyleng); \
- zendlval->value.str.len = yyleng; \
- }
- #else /* ZEND_MULTIBYTE */
- # define zend_copy_value(zendlval, yytext, yyleng) \
- zendlval->value.str.val = (char *)estrndup(yytext, yyleng); \
- zendlval->value.str.len = yyleng;
- #endif /* ZEND_MULTIBYTE */
- static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
- {
- register char *s, *t;
- char *end;
- ZVAL_STRINGL(zendlval, str, len, 1);
- /* convert escape sequences */
- s = t = zendlval->value.str.val;
- end = s+zendlval->value.str.len;
- while (s<end) {
- if (*s=='\\') {
- s++;
- if (s >= end) {
- *t++ = '\\';
- break;
- }
- switch(*s) {
- case 'n':
- *t++ = '\n';
- zendlval->value.str.len--;
- break;
- case 'r':
- *t++ = '\r';
- zendlval->value.str.len--;
- break;
- case 't':
- *t++ = '\t';
- zendlval->value.str.len--;
- break;
- case 'f':
- *t++ = '\f';
- zendlval->value.str.len--;
- break;
- case 'v':
- *t++ = '\v';
- zendlval->value.str.len--;
- break;
- case '"':
- case '`':
- if (*s != quote_type) {
- *t++ = '\\';
- *t++ = *s;
- break;
- }
- case '\\':
- case '$':
- *t++ = *s;
- zendlval->value.str.len--;
- break;
- case 'x':
- case 'X':
- if (ZEND_IS_HEX(*(s+1))) {
- char hex_buf[3] = { 0, 0, 0 };
- zendlval->value.str.len--; /* for the 'x' */
- hex_buf[0] = *(++s);
- zendlval->value.str.len--;
- if (ZEND_IS_HEX(*(s+1))) {
- hex_buf[1] = *(++s);
- zendlval->value.str.len--;
- }
- *t++ = (char) strtol(hex_buf, NULL, 16);
- } else {
- *t++ = '\\';
- *t++ = *s;
- }
- break;
- default:
- /* check for an octal */
- if (ZEND_IS_OCT(*s)) {
- char octal_buf[4] = { 0, 0, 0, 0 };
- octal_buf[0] = *s;
- zendlval->value.str.len--;
- if (ZEND_IS_OCT(*(s+1))) {
- octal_buf[1] = *(++s);
- zendlval->value.str.len--;
- if (ZEND_IS_OCT(*(s+1))) {
- octal_buf[2] = *(++s);
- zendlval->value.str.len--;
- }
- }
- *t++ = (char) strtol(octal_buf, NULL, 8);
- } else {
- *t++ = '\\';
- *t++ = *s;
- }
- break;
- }
- } else {
- *t++ = *s;
- }
- if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
- CG(zend_lineno)++;
- }
- s++;
- }
- *t = 0;
- #ifdef ZEND_MULTIBYTE
- if (SCNG(output_filter)) {
- size_t sz = 0;
- s = zendlval->value.str.val;
- SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
- zendlval->value.str.len = sz;
- efree(s);
- }
- #endif /* ZEND_MULTIBYTE */
- }
- int lex_scan(zval *zendlval TSRMLS_DC)
- {
- restart:
- SCNG(yy_text) = YYCURSOR;
- yymore_restart:
- /*!re2c
- re2c:yyfill:check = 0;
- LNUM [0-9]+
- DNUM ([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)
- EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
- HNUM "0x"[0-9a-fA-F]+
- LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
- WHITESPACE [ \n\r\t]+
- TABS_AND_SPACES [ \t]*
- TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@]
- ANY_CHAR [^]
- NEWLINE ("\r"|"\n"|"\r\n")
- /* compute yyleng before each rule */
- <!*> := yyleng = YYCURSOR - SCNG(yy_text);
- <ST_IN_SCRIPTING>"exit" {
- return T_EXIT;
- }
- <ST_IN_SCRIPTING>"die" {
- return T_EXIT;
- }
- <ST_IN_SCRIPTING>"function" {
- return T_FUNCTION;
- }
- <ST_IN_SCRIPTING>"const" {
- return T_CONST;
- }
- <ST_IN_SCRIPTING>"return" {
- return T_RETURN;
- }
- <ST_IN_SCRIPTING>"try" {
- return T_TRY;
- }
- <ST_IN_SCRIPTING>"catch" {
- return T_CATCH;
- }
- <ST_IN_SCRIPTING>"throw" {
- return T_THROW;
- }
- <ST_IN_SCRIPTING>"if" {
- return T_IF;
- }
- <ST_IN_SCRIPTING>"elseif" {
- return T_ELSEIF;
- }
- <ST_IN_SCRIPTING>"endif" {
- return T_ENDIF;
- }
- <ST_IN_SCRIPTING>"else" {
- return T_ELSE;
- }
- <ST_IN_SCRIPTING>"while" {
- return T_WHILE;
- }
- <ST_IN_SCRIPTING>"endwhile" {
- return T_ENDWHILE;
- }
- <ST_IN_SCRIPTING>"do" {
- return T_DO;
- }
- <ST_IN_SCRIPTING>"for" {
- return T_FOR;
- }
- <ST_IN_SCRIPTING>"endfor" {
- return T_ENDFOR;
- }
- <ST_IN_SCRIPTING>"foreach" {
- return T_FOREACH;
- }
- <ST_IN_SCRIPTING>"endforeach" {
- return T_ENDFOREACH;
- }
- <ST_IN_SCRIPTING>"declare" {
- return T_DECLARE;
- }
- <ST_IN_SCRIPTING>"enddeclare" {
- return T_ENDDECLARE;
- }
- <ST_IN_SCRIPTING>"instanceof" {
- return T_INSTANCEOF;
- }
- <ST_IN_SCRIPTING>"as" {
- return T_AS;
- }
- <ST_IN_SCRIPTING>"switch" {
- return T_SWITCH;
- }
- <ST_IN_SCRIPTING>"endswitch" {
- return T_ENDSWITCH;
- }
- <ST_IN_SCRIPTING>"case" {
- return T_CASE;
- }
- <ST_IN_SCRIPTING>"default" {
- return T_DEFAULT;
- }
- <ST_IN_SCRIPTING>"break" {
- return T_BREAK;
- }
- <ST_IN_SCRIPTING>"continue" {
- return T_CONTINUE;
- }
- <ST_IN_SCRIPTING>"goto" {
- return T_GOTO;
- }
- <ST_IN_SCRIPTING>"echo" {
- return T_ECHO;
- }
- <ST_IN_SCRIPTING>"print" {
- return T_PRINT;
- }
- <ST_IN_SCRIPTING>"class" {
- return T_CLASS;
- }
- <ST_IN_SCRIPTING>"interface" {
- return T_INTERFACE;
- }
- <ST_IN_SCRIPTING>"extends" {
- return T_EXTENDS;
- }
- <ST_IN_SCRIPTING>"implements" {
- return T_IMPLEMENTS;
- }
- <ST_IN_SCRIPTING>"->" {
- yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
- return T_OBJECT_OPERATOR;
- }
- <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- HANDLE_NEWLINES(yytext, yyleng);
- return T_WHITESPACE;
- }
- <ST_LOOKING_FOR_PROPERTY>"->" {
- return T_OBJECT_OPERATOR;
- }
- <ST_LOOKING_FOR_PROPERTY>{LABEL} {
- yy_pop_state(TSRMLS_C);
- zend_copy_value(zendlval, yytext, yyleng);
- zendlval->type = IS_STRING;
- return T_STRING;
- }
- <ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} {
- yyless(0);
- yy_pop_state(TSRMLS_C);
- goto restart;
- }
- <ST_IN_SCRIPTING>"::" {
- return T_PAAMAYIM_NEKUDOTAYIM;
- }
- <ST_IN_SCRIPTING>"\\" {
- return T_NS_SEPARATOR;
- }
- <ST_IN_SCRIPTING>"new" {
- return T_NEW;
- }
- <ST_IN_SCRIPTING>"clone" {
- return T_CLONE;
- }
- <ST_IN_SCRIPTING>"var" {
- return T_VAR;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" {
- return T_INT_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("real"|"double"|"float"){TABS_AND_SPACES}")" {
- return T_DOUBLE_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"string"{TABS_AND_SPACES}")" {
- return T_STRING_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"binary"{TABS_AND_SPACES}")" {
- return T_STRING_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" {
- return T_ARRAY_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"object"{TABS_AND_SPACES}")" {
- return T_OBJECT_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("bool"|"boolean"){TABS_AND_SPACES}")" {
- return T_BOOL_CAST;
- }
- <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("unset"){TABS_AND_SPACES}")" {
- return T_UNSET_CAST;
- }
- <ST_IN_SCRIPTING>"eval" {
- return T_EVAL;
- }
- <ST_IN_SCRIPTING>"include" {
- return T_INCLUDE;
- }
- <ST_IN_SCRIPTING>"include_once" {
- return T_INCLUDE_ONCE;
- }
- <ST_IN_SCRIPTING>"require" {
- return T_REQUIRE;
- }
- <ST_IN_SCRIPTING>"require_once" {
- return T_REQUIRE_ONCE;
- }
- <ST_IN_SCRIPTING>"namespace" {
- return T_NAMESPACE;
- }
- <ST_IN_SCRIPTING>"use" {
- return T_USE;
- }
- <ST_IN_SCRIPTING>"global" {
- return T_GLOBAL;
- }
- <ST_IN_SCRIPTING>"isset" {
- return T_ISSET;
- }
- <ST_IN_SCRIPTING>"empty" {
- return T_EMPTY;
- }
- <ST_IN_SCRIPTING>"__halt_compiler" {
- return T_HALT_COMPILER;
- }
- <ST_IN_SCRIPTING>"static" {
- return T_STATIC;
- }
- <ST_IN_SCRIPTING>"abstract" {
- return T_ABSTRACT;
- }
- <ST_IN_SCRIPTING>"final" {
- return T_FINAL;
- }
- <ST_IN_SCRIPTING>"private" {
- return T_PRIVATE;
- }
- <ST_IN_SCRIPTING>"protected" {
- return T_PROTECTED;
- }
- <ST_IN_SCRIPTING>"public" {
- return T_PUBLIC;
- }
- <ST_IN_SCRIPTING>"unset" {
- return T_UNSET;
- }
- <ST_IN_SCRIPTING>"=>" {
- return T_DOUBLE_ARROW;
- }
- <ST_IN_SCRIPTING>"list" {
- return T_LIST;
- }
- <ST_IN_SCRIPTING>"array" {
- return T_ARRAY;
- }
- <ST_IN_SCRIPTING>"++" {
- return T_INC;
- }
- <ST_IN_SCRIPTING>"--" {
- return T_DEC;
- }
- <ST_IN_SCRIPTING>"===" {
- return T_IS_IDENTICAL;
- }
- <ST_IN_SCRIPTING>"!==" {
- return T_IS_NOT_IDENTICAL;
- }
- <ST_IN_SCRIPTING>"==" {
- return T_IS_EQUAL;
- }
- <ST_IN_SCRIPTING>"!="|"<>" {
- return T_IS_NOT_EQUAL;
- }
- <ST_IN_SCRIPTING>"<=" {
- return T_IS_SMALLER_OR_EQUAL;
- }
- <ST_IN_SCRIPTING>">=" {
- return T_IS_GREATER_OR_EQUAL;
- }
- <ST_IN_SCRIPTING>"+=" {
- return T_PLUS_EQUAL;
- }
- <ST_IN_SCRIPTING>"-=" {
- return T_MINUS_EQUAL;
- }
- <ST_IN_SCRIPTING>"*=" {
- return T_MUL_EQUAL;
- }
- <ST_IN_SCRIPTING>"/=" {
- return T_DIV_EQUAL;
- }
- <ST_IN_SCRIPTING>".=" {
- return T_CONCAT_EQUAL;
- }
- <ST_IN_SCRIPTING>"%=" {
- return T_MOD_EQUAL;
- }
- <ST_IN_SCRIPTING>"<<=" {
- return T_SL_EQUAL;
- }
- <ST_IN_SCRIPTING>">>=" {
- return T_SR_EQUAL;
- }
- <ST_IN_SCRIPTING>"&=" {
- return T_AND_EQUAL;
- }
- <ST_IN_SCRIPTING>"|=" {
- return T_OR_EQUAL;
- }
- <ST_IN_SCRIPTING>"^=" {
- return T_XOR_EQUAL;
- }
- <ST_IN_SCRIPTING>"||" {
- return T_BOOLEAN_OR;
- }
- <ST_IN_SCRIPTING>"&&" {
- return T_BOOLEAN_AND;
- }
- <ST_IN_SCRIPTING>"OR" {
- return T_LOGICAL_OR;
- }
- <ST_IN_SCRIPTING>"AND" {
- return T_LOGICAL_AND;
- }
- <ST_IN_SCRIPTING>"XOR" {
- return T_LOGICAL_XOR;
- }
- <ST_IN_SCRIPTING>"<<" {
- return T_SL;
- }
- <ST_IN_SCRIPTING>">>" {
- return T_SR;
- }
- <ST_IN_SCRIPTING>{TOKENS} {
- return yytext[0];
- }
- <ST_IN_SCRIPTING>"{" {
- yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
- return '{';
- }
- <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" {
- yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
- return T_DOLLAR_OPEN_CURLY_BRACES;
- }
- <ST_IN_SCRIPTING>"}" {
- RESET_DOC_COMMENT();
- if (!zend_stack_is_empty(&SCNG(state_stack))) {
- yy_pop_state(TSRMLS_C);
- }
- return '}';
- }
- <ST_LOOKING_FOR_VARNAME>{LABEL} {
- zend_copy_value(zendlval, yytext, yyleng);
- zendlval->type = IS_STRING;
- yy_pop_state(TSRMLS_C);
- yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
- return T_STRING_VARNAME;
- }
- <ST_LOOKING_FOR_VARNAME>{ANY_CHAR} {
- yyless(0);
- yy_pop_state(TSRMLS_C);
- yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
- goto restart;
- }
- <ST_IN_SCRIPTING>{LNUM} {
- if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
- zendlval->value.lval = strtol(yytext, NULL, 0);
- } else {
- errno = 0;
- zendlval->value.lval = strtol(yytext, NULL, 0);
- if (errno == ERANGE) { /* Overflow */
- if (yytext[0] == '0') { /* octal overflow */
- zendlval->value.dval = zend_oct_strtod(yytext, NULL);
- } else {
- zendlval->value.dval = zend_strtod(yytext, NULL);
- }
- zendlval->type = IS_DOUBLE;
- return T_DNUMBER;
- }
- }
- zendlval->type = IS_LONG;
- return T_LNUMBER;
- }
- <ST_IN_SCRIPTING>{HNUM} {
- char *hex = yytext + 2; /* Skip "0x" */
- int len = yyleng - 2;
- /* Skip any leading 0s */
- while (*hex == '0') {
- hex++;
- len--;
- }
- if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
- zendlval->value.lval = strtol(hex, NULL, 16);
- zendlval->type = IS_LONG;
- return T_LNUMBER;
- } else {
- zendlval->value.dval = zend_hex_strtod(hex, NULL);
- zendlval->type = IS_DOUBLE;
- return T_DNUMBER;
- }
- }
- <ST_VAR_OFFSET>[0]|([1-9][0-9]*) { /* Offset could be treated as a long */
- if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
- zendlval->value.lval = strtol(yytext, NULL, 10);
- zendlval->type = IS_LONG;
- } else {
- zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- }
- return T_NUM_STRING;
- }
- <ST_VAR_OFFSET>{LNUM}|{HNUM} { /* Offset must be treated as a string */
- zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- return T_NUM_STRING;
- }
- <ST_IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} {
- zendlval->value.dval = zend_strtod(yytext, NULL);
- zendlval->type = IS_DOUBLE;
- return T_DNUMBER;
- }
- <ST_IN_SCRIPTING>"__CLASS__" {
- char *class_name = NULL;
- if (CG(active_class_entry)) {
- class_name = CG(active_class_entry)->name;
- }
- if (!class_name) {
- class_name = "";
- }
- zendlval->value.str.len = strlen(class_name);
- zendlval->value.str.val = estrndup(class_name, zendlval->value.str.len);
- zendlval->type = IS_STRING;
- return T_CLASS_C;
- }
- <ST_IN_SCRIPTING>"__FUNCTION__" {
- char *func_name = NULL;
- if (CG(active_op_array)) {
- func_name = CG(active_op_array)->function_name;
- }
- if (!func_name) {
- func_name = "";
- }
- zendlval->value.str.len = strlen(func_name);
- zendlval->value.str.val = estrndup(func_name, zendlval->value.str.len);
- zendlval->type = IS_STRING;
- return T_FUNC_C;
- }
- <ST_IN_SCRIPTING>"__METHOD__" {
- char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;
- char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;
- size_t len = 0;
- if (class_name) {
- len += strlen(class_name) + 2;
- }
- if (func_name) {
- len += strlen(func_name);
- }
- zendlval->value.str.len = zend_spprintf(&zendlval->value.str.val, 0, "%s%s%s",
- class_name ? class_name : "",
- class_name && func_name ? "::" : "",
- func_name ? func_name : ""
- );
- zendlval->type = IS_STRING;
- return T_METHOD_C;
- }
- <ST_IN_SCRIPTING>"__LINE__" {
- zendlval->value.lval = CG(zend_lineno);
- zendlval->type = IS_LONG;
- return T_LINE;
- }
- <ST_IN_SCRIPTING>"__FILE__" {
- char *filename = zend_get_compiled_filename(TSRMLS_C);
- if (!filename) {
- filename = "";
- }
- zendlval->value.str.len = strlen(filename);
- zendlval->value.str.val = estrndup(filename, zendlval->value.str.len);
- zendlval->type = IS_STRING;
- return T_FILE;
- }
- <ST_IN_SCRIPTING>"__DIR__" {
- char *filename = zend_get_compiled_filename(TSRMLS_C);
- const size_t filename_len = strlen(filename);
- char *dirname;
- if (!filename) {
- filename = "";
- }
- dirname = estrndup(filename, filename_len);
- zend_dirname(dirname, filename_len);
- if (strcmp(dirname, ".") == 0) {
- dirname = erealloc(dirname, MAXPATHLEN);
- #if HAVE_GETCWD
- VCWD_GETCWD(dirname, MAXPATHLEN);
- #elif HAVE_GETWD
- VCWD_GETWD(dirname);
- #endif
- }
- zendlval->value.str.len = strlen(dirname);
- zendlval->value.str.val = dirname;
- zendlval->type = IS_STRING;
- return T_DIR;
- }
- <ST_IN_SCRIPTING>"__NAMESPACE__" {
- if (CG(current_namespace)) {
- *zendlval = *CG(current_namespace);
- zval_copy_ctor(zendlval);
- } else {
- ZVAL_EMPTY_STRING(zendlval);
- }
- return T_NS_C;
- }
- <INITIAL>"<script"{WHITESPACE}+"language"{WHITESPACE}*"="{WHITESPACE}*("php"|"\"php\""|"'php'"){WHITESPACE}*">" {
- YYCTYPE *bracket = zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
- if (bracket != SCNG(yy_text)) {
- /* Handle previously scanned HTML, as possible <script> tags found are assumed to not be PHP's */
- YYCURSOR = bracket;
- goto inline_html;
- }
- HANDLE_NEWLINES(yytext, yyleng);
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG;
- }
- <INITIAL>"<%=" {
- if (CG(asp_tags)) {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG_WITH_ECHO;
- } else {
- goto inline_char_handler;
- }
- }
- <INITIAL>"<?=" {
- if (CG(short_tags)) {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG_WITH_ECHO;
- } else {
- goto inline_char_handler;
- }
- }
- <INITIAL>"<%" {
- if (CG(asp_tags)) {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG;
- } else {
- goto inline_char_handler;
- }
- }
- <INITIAL>"<?php"([ \t]|{NEWLINE}) {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- HANDLE_NEWLINE(yytext[yyleng-1]);
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG;
- }
- <INITIAL>"<?" {
- if (CG(short_tags)) {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(ST_IN_SCRIPTING);
- return T_OPEN_TAG;
- } else {
- goto inline_char_handler;
- }
- }
- <INITIAL>{ANY_CHAR} {
- if (YYCURSOR > YYLIMIT) {
- return 0;
- }
- inline_char_handler:
- while (1) {
- YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
- YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
- if (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR) {
- case '?':
- if (CG(short_tags) || !strncasecmp(YYCURSOR + 1, "php", 3)) { /* Assume [ \t\n\r] follows "php" */
- break;
- }
- continue;
- case '%':
- if (CG(asp_tags)) {
- break;
- }
- continue;
- case 's':
- case 'S':
- /* Probably NOT an opening PHP <script> tag, so don't end the HTML chunk yet
- * If it is, the PHP <script> tag rule checks for any HTML scanned before it */
- YYCURSOR--;
- yymore();
- default:
- continue;
- }
- YYCURSOR--;
- }
- break;
- }
- inline_html:
- yyleng = YYCURSOR - SCNG(yy_text);
- #ifdef ZEND_MULTIBYTE
- if (SCNG(output_filter)) {
- int readsize;
- size_t sz = 0;
- readsize = SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);
- zendlval->value.str.len = sz;
- if (readsize < yyleng) {
- yyless(readsize);
- }
- } else {
- zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
- zendlval->value.str.len = yyleng;
- }
- #else /* !ZEND_MULTIBYTE */
- zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
- zendlval->value.str.len = yyleng;
- #endif
- zendlval->type = IS_STRING;
- HANDLE_NEWLINES(yytext, yyleng);
- return T_INLINE_HTML;
- }
- /* Make sure a label character follows "->", otherwise there is no property
- * and "->" will be taken literally
- */
- <ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL}"->"[a-zA-Z_\x7f-\xff] {
- yyless(yyleng - 3);
- yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
- zend_copy_value(zendlval, (yytext+1), (yyleng-1));
- zendlval->type = IS_STRING;
- return T_VARIABLE;
- }
- /* A [ always designates a variable offset, regardless of what follows
- */
- <ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL}"[" {
- yyless(yyleng - 1);
- yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
- zend_copy_value(zendlval, (yytext+1), (yyleng-1));
- zendlval->type = IS_STRING;
- return T_VARIABLE;
- }
- <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
- zend_copy_value(zendlval, (yytext+1), (yyleng-1));
- zendlval->type = IS_STRING;
- return T_VARIABLE;
- }
- <ST_VAR_OFFSET>"]" {
- yy_pop_state(TSRMLS_C);
- return ']';
- }
- <ST_VAR_OFFSET>{TOKENS}|[{}"`] {
- /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
- return yytext[0];
- }
- <ST_VAR_OFFSET>[ \n\r\t\\'#] {
- /* Invalid rule to return a more explicit parse error with proper line number */
- yyless(0);
- yy_pop_state(TSRMLS_C);
- return T_ENCAPSED_AND_WHITESPACE;
- }
- <ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} {
- zend_copy_value(zendlval, yytext, yyleng);
- zendlval->type = IS_STRING;
- return T_STRING;
- }
- <ST_IN_SCRIPTING>"#"|"//" {
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '\r':
- if (*YYCURSOR == '\n') {
- YYCURSOR++;
- }
- /* fall through */
- case '\n':
- CG(zend_lineno)++;
- break;
- case '%':
- if (!CG(asp_tags)) {
- continue;
- }
- /* fall through */
- case '?':
- if (*YYCURSOR == '>') {
- YYCURSOR--;
- break;
- }
- /* fall through */
- default:
- continue;
- }
- break;
- }
- yyleng = YYCURSOR - SCNG(yy_text);
- return T_COMMENT;
- }
- <ST_IN_SCRIPTING>"/*"|"/**"{WHITESPACE} {
- int doc_com;
- if (yyleng > 2) {
- doc_com = 1;
- RESET_DOC_COMMENT();
- } else {
- doc_com = 0;
- }
- while (YYCURSOR < YYLIMIT) {
- if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
- break;
- }
- }
- if (YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- } else {
- zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
- }
- yyleng = YYCURSOR - SCNG(yy_text);
- HANDLE_NEWLINES(yytext, yyleng);
- if (doc_com) {
- CG(doc_comment) = estrndup(yytext, yyleng);
- CG(doc_comment_len) = yyleng;
- return T_DOC_COMMENT;
- }
- return T_COMMENT;
- }
- <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
- zendlval->value.str.val = yytext; /* no copying - intentional */
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- BEGIN(INITIAL);
- return T_CLOSE_TAG; /* implicit ';' at php-end tag */
- }
- <ST_IN_SCRIPTING>"%>"{NEWLINE}? {
- if (CG(asp_tags)) {
- BEGIN(INITIAL);
- zendlval->value.str.len = yyleng;
- zendlval->type = IS_STRING;
- zendlval->value.str.val = yytext; /* no copying - intentional */
- return T_CLOSE_TAG; /* implicit ';' at php-end tag */
- } else {
- yyless(1);
- return yytext[0];
- }
- }
- <ST_IN_SCRIPTING>b?['] {
- register char *s, *t;
- char *end;
- int bprefix = (yytext[0] != '\'') ? 1 : 0;
- while (1) {
- if (YYCURSOR < YYLIMIT) {
- if (*YYCURSOR == '\'') {
- YYCURSOR++;
- yyleng = YYCURSOR - SCNG(yy_text);
- break;
- } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- } else {
- yyleng = YYLIMIT - SCNG(yy_text);
- /* Unclosed single quotes; treat similar to double quotes, but without a separate token
- * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
- * rule, which continued in ST_IN_SCRIPTING state after the quote */
- return T_ENCAPSED_AND_WHITESPACE;
- }
- }
- zendlval->value.str.val = estrndup(yytext+bprefix+1, yyleng-bprefix-2);
- zendlval->value.str.len = yyleng-bprefix-2;
- zendlval->type = IS_STRING;
- /* convert escape sequences */
- s = t = zendlval->value.str.val;
- end = s+zendlval->value.str.len;
- while (s<end) {
- if (*s=='\\') {
- s++;
- switch(*s) {
- case '\\':
- case '\'':
- *t++ = *s;
- zendlval->value.str.len--;
- break;
- default:
- *t++ = '\\';
- *t++ = *s;
- break;
- }
- } else {
- *t++ = *s;
- }
- if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
- CG(zend_lineno)++;
- }
- s++;
- }
- *t = 0;
- #ifdef ZEND_MULTIBYTE
- if (SCNG(output_filter)) {
- size_t sz = 0;
- s = zendlval->value.str.val;
- SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
- zendlval->value.str.len = sz;
- efree(s);
- }
- #endif /* ZEND_MULTIBYTE */
- return T_CONSTANT_ENCAPSED_STRING;
- }
- <ST_IN_SCRIPTING>b?["] {
- int bprefix = (yytext[0] != '"') ? 1 : 0;
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '"':
- yyleng = YYCURSOR - SCNG(yy_text);
- zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"' TSRMLS_CC);
- return T_CONSTANT_ENCAPSED_STRING;
- case '$':
- if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
- break;
- }
- continue;
- case '{':
- if (*YYCURSOR == '$') {
- break;
- }
- continue;
- case '\\':
- if (YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- /* fall through */
- default:
- continue;
- }
- YYCURSOR--;
- break;
- }
- /* Remember how much was scanned to save rescanning */
- SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
- YYCURSOR = SCNG(yy_text) + yyleng;
- BEGIN(ST_DOUBLE_QUOTES);
- return '"';
- }
- <ST_IN_SCRIPTING>b?"<<<"{TABS_AND_SPACES}({LABEL}|([']{LABEL}['])|(["]{LABEL}["])){NEWLINE} {
- char *s;
- int bprefix = (yytext[0] != '<') ? 1 : 0;
- /* save old heredoc label */
- Z_STRVAL_P(zendlval) = CG(heredoc);
- Z_STRLEN_P(zendlval) = CG(heredoc_len);
- CG(zend_lineno)++;
- CG(heredoc_len) = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
- s = yytext+bprefix+3;
- while ((*s == ' ') || (*s == '\t')) {
- s++;
- CG(heredoc_len)--;
- }
- if (*s == '\'') {
- s++;
- CG(heredoc_len) -= 2;
- BEGIN(ST_NOWDOC);
- } else {
- if (*s == '"') {
- s++;
- CG(heredoc_len) -= 2;
- }
- BEGIN(ST_HEREDOC);
- }
- CG(heredoc) = estrndup(s, CG(heredoc_len));
- /* Check for ending label on the next line */
- if (CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, CG(heredoc_len))) {
- YYCTYPE *end = YYCURSOR + CG(heredoc_len);
- if (*end == ';') {
- end++;
- }
- if (*end == '\n' || *end == '\r') {
- BEGIN(ST_END_HEREDOC);
- }
- }
- return T_START_HEREDOC;
- }
- <ST_IN_SCRIPTING>[`] {
- BEGIN(ST_BACKQUOTE);
- return '`';
- }
- <ST_END_HEREDOC>{ANY_CHAR} {
- YYCURSOR += CG(heredoc_len) - 1;
- yyleng = CG(heredoc_len);
- Z_STRVAL_P(zendlval) = CG(heredoc);
- Z_STRLEN_P(zendlval) = CG(heredoc_len);
- CG(heredoc) = NULL;
- CG(heredoc_len) = 0;
- BEGIN(ST_IN_SCRIPTING);
- return T_END_HEREDOC;
- }
- <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
- zendlval->value.lval = (long) '{';
- yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
- yyless(1);
- return T_CURLY_OPEN;
- }
- <ST_DOUBLE_QUOTES>["] {
- BEGIN(ST_IN_SCRIPTING);
- return '"';
- }
- <ST_BACKQUOTE>[`] {
- BEGIN(ST_IN_SCRIPTING);
- return '`';
- }
- <ST_DOUBLE_QUOTES>{ANY_CHAR} {
- if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
- YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
- SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
- goto double_quotes_scan_done;
- }
- if (YYCURSOR > YYLIMIT) {
- return 0;
- }
- if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '"':
- break;
- case '$':
- if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
- break;
- }
- continue;
- case '{':
- if (*YYCURSOR == '$') {
- break;
- }
- continue;
- case '\\':
- if (YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- /* fall through */
- default:
- continue;
- }
- YYCURSOR--;
- break;
- }
- double_quotes_scan_done:
- yyleng = YYCURSOR - SCNG(yy_text);
- zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
- return T_ENCAPSED_AND_WHITESPACE;
- }
- <ST_BACKQUOTE>{ANY_CHAR} {
- if (YYCURSOR > YYLIMIT) {
- return 0;
- }
- if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '`':
- break;
- case '$':
- if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
- break;
- }
- continue;
- case '{':
- if (*YYCURSOR == '$') {
- break;
- }
- continue;
- case '\\':
- if (YYCURSOR < YYLIMIT) {
- YYCURSOR++;
- }
- /* fall through */
- default:
- continue;
- }
- YYCURSOR--;
- break;
- }
- yyleng = YYCURSOR - SCNG(yy_text);
- zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
- return T_ENCAPSED_AND_WHITESPACE;
- }
- <ST_HEREDOC>{ANY_CHAR} {
- int newline = 0;
- if (YYCURSOR > YYLIMIT) {
- return 0;
- }
- YYCURSOR--;
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '\r':
- if (*YYCURSOR == '\n') {
- YYCURSOR++;
- }
- /* fall through */
- case '\n':
- /* Check for ending label on the next line */
- if (IS_LABEL_START(*YYCURSOR) && CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, CG(heredoc), CG(heredoc_len))) {
- YYCTYPE *end = YYCURSOR + CG(heredoc_len);
- if (*end == ';') {
- end++;
- }
- if (*end == '\n' || *end == '\r') {
- /* newline before label will be subtracted from returned text, but
- * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
- if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
- newline = 2; /* Windows newline */
- } else {
- newline = 1;
- }
- CG(increment_lineno) = 1; /* For newline before label */
- BEGIN(ST_END_HEREDOC);
- goto heredoc_scan_done;
- }
- }
- continue;
- case '$':
- if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
- break;
- }
- continue;
- case '{':
- if (*YYCURSOR == '$') {
- break;
- }
- continue;
- case '\\':
- if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
- YYCURSOR++;
- }
- /* fall through */
- default:
- continue;
- }
- YYCURSOR--;
- break;
- }
- heredoc_scan_done:
- yyleng = YYCURSOR - SCNG(yy_text);
- zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
- return T_ENCAPSED_AND_WHITESPACE;
- }
- <ST_NOWDOC>{ANY_CHAR} {
- int newline = 0;
- if (YYCURSOR > YYLIMIT) {
- return 0;
- }
- YYCURSOR--;
- while (YYCURSOR < YYLIMIT) {
- switch (*YYCURSOR++) {
- case '\r':
- if (*YYCURSOR == '\n') {
- YYCURSOR++;
- }
- /* fall through */
- case '\n':
- /* Check for ending label on the next line */
- if (IS_LABEL_START(*YYCURSOR) && CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, CG(heredoc), CG(heredoc_len))) {
- YYCTYPE *end = YYCURSOR + CG(heredoc_len);
- if (*end == ';') {
- end++;
- }
- if (*end == '\n' || *end == '\r') {
- /* newline before label will be subtracted from returned text, but
- * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
- if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
- newline = 2; /* Windows newline */
- } else {
- newline = 1;
- }
- CG(increment_lineno) = 1; /* For newline before label */
- BEGIN(ST_END_HEREDOC);
- goto nowdoc_scan_done;
- }
- }
- /* fall through */
- default:
- continue;
- }
- }
- nowdoc_scan_done:
- yyleng = YYCURSOR - SCNG(yy_text);
- zend_copy_value(zendlval, yytext, yyleng - newline);
- zendlval->type = IS_STRING;
- HANDLE_NEWLINES(yytext,…
Large files files are truncated, but you can click here to view the full file