php-src/Zend/zend-scanner.l

1213 lines
24 KiB
Plaintext

%{
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski |
+----------------------------------------------------------------------+
| This source file is subject to the Zend license, that is bundled |
| with this package in the file LICENSE. If you did not receive a |
| copy of the Zend license, please mail us at zend@zend.com so we can |
| send you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@zend.com> |
| Zeev Suraski <zeev@zend.com> |
+----------------------------------------------------------------------+
*/
%}
%x IN_SCRIPTING
%x DOUBLE_QUOTES
%x SINGLE_QUOTE
%x BACKQUOTE
%x HEREDOC
%x LOOKING_FOR_PROPERTY
%option stack
%{
#if WIN32|WINNT
#include <winsock.h>
#endif
#include <errno.h>
#include "zend.h"
#include "zend_alloc.h"
#include "zend_compile.h"
#include "zend-scanner.h"
#include "zend_highlight.h"
#include "zend_constants.h"
#include "zend_variables.h"
#include "zend_operators.h"
#if HAVE_STDARG_H
#include <stdarg.h>
#endif
#define YY_DECL int lex_scan(zval *zendlval CLS_DC)
#define ECHO { ZEND_WRITE( yytext, yyleng ); }
#ifdef __cplusplus
# define MY_INPUT yyinput
#else
# define MY_INPUT input
#endif
#ifndef YY_TLS_VARS
/* NOTE, YY_TLS_VARS CANNOT have a semicolon after in
in the code or it will break compilation in msvc5 */
#define YY_TLS_VARS
#endif
#ifndef TLS_VARS /* just to make sure ;) */
#define TLS_VARS
#endif
#define HANDLE_NEWLINES(s,l) \
do { \
char *p = (s),*boundary = p+(l); \
\
while(p<boundary) { \
if (*p++=='\n') { \
CG(zend_lineno)++; \
} \
} \
} while(0)
#define HANDLE_NEWLINE(c) \
{ \
if (c=='\n') { \
CG(zend_lineno)++; \
} \
}
void startup_scanner(CLS_D)
{
CG(heredoc) = NULL;
CG(heredoc_len)=0;
}
void shutdown_scanner(CLS_D)
{
if (CG(heredoc)) {
efree(CG(heredoc));
CG(heredoc_len)=0;
}
}
void reset_scanner(CLS_D)
{
YY_TLS_VARS
BEGIN(INITIAL);
CG(zend_lineno)=1;
}
static inline void save_lexical_state(zend_lex_state *lex_state CLS_DC)
{
memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
lex_state->in = yyin;
lex_state->lineno = CG(zend_lineno);
lex_state->state = YYSTATE;
lex_state->filename = zend_get_compiled_filename();
}
static inline void restore_lexical_state(zend_lex_state *lex_state CLS_DC)
{
YY_BUFFER_STATE original_buffer_state = YY_CURRENT_BUFFER;
if (lex_state->buffer_state) {
yy_switch_to_buffer(lex_state->buffer_state);
} else {
YY_CURRENT_BUFFER = NULL;
}
yy_delete_buffer(original_buffer_state);
yyin = lex_state->in;
CG(zend_lineno) = lex_state->lineno;
BEGIN(lex_state->state);
zend_restore_compiled_filename(lex_state->filename);
}
inline int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
{
FILE *tmp;
YY_BUFFER_STATE buffer_state = YY_CURRENT_BUFFER;
switch (file_handle->type) {
case ZEND_HANDLE_FILENAME:
tmp = zend_fopen(file_handle->filename);
break;
case ZEND_HANDLE_FD:
tmp = fdopen(file_handle->handle.fd, "r");
break;
case ZEND_HANDLE_FP:
tmp = file_handle->handle.fp;
break;
}
if (!tmp) {
return FAILURE;
}
/* Reset the scanner for scanning the new file */
yyin = tmp;
yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
CG(zend_lineno) = 1;
BEGIN(INITIAL);
zend_set_compiled_filename(file_handle->filename);
return SUCCESS;
}
zend_op_array *compile_files(int mark_as_ref CLS_DC, int file_count, ...)
{
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;
zend_file_handle *file_handle;
va_list files;
int i;
va_start(files, file_count);
init_op_array(op_array, INITIAL_OP_ARRAY_SIZE);
save_lexical_state(&original_lex_state CLS_CC);
for (i=0; i<file_count; i++) {
file_handle = va_arg(files, zend_file_handle *);
if (!file_handle) {
continue;
}
if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename);
destroy_op_array(op_array);
efree(op_array);
retval = NULL;
break;
} else {
CG(active_op_array) = op_array;
if (zendparse(CLS_C)==1) {
retval = NULL;
break;
} else {
fclose(yyin);
restore_lexical_state(&original_lex_state CLS_CC);
CG(active_op_array) = original_active_op_array;
retval = op_array;
}
}
}
if (retval) {
pass_two(op_array);
if (mark_as_ref) {
pass_include_eval(op_array);
}
}
va_end(files);
return retval;
}
zend_op_array *compile_filename(zval *filename CLS_DC)
{
zend_file_handle file_handle;
zval tmp;
zend_op_array *retval;
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.type = ZEND_HANDLE_FILENAME;
retval = compile_files(0 CLS_CC, 1, &file_handle);
if (filename==&tmp) {
zval_dtor(&tmp);
}
return retval;
}
static inline int prepare_string_for_scanning(zval *str)
{
/* enforce two trailing NULLs for flex... */
str->value.str.val = (char *) erealloc(str->value.str.val,str->value.str.len+2);
str->value.str.val[str->value.str.len+1]=0;
yyin=NULL;
yy_scan_buffer(str->value.str.val, str->value.str.len+2);
return SUCCESS;
}
zend_op_array *compile_string(zval *source_string CLS_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;
tmp = *source_string;
zval_copy_ctor(&tmp);
convert_to_string(&tmp);
source_string = &tmp;
init_op_array(op_array, INITIAL_OP_ARRAY_SIZE);
save_lexical_state(&original_lex_state CLS_CC);
if (prepare_string_for_scanning(source_string)==FAILURE) {
destroy_op_array(op_array);
efree(op_array);
retval = NULL;
} else {
CG(active_op_array) = op_array;
BEGIN(IN_SCRIPTING);
if (zendparse(CLS_C)==1) {
retval = NULL;
} else {
pass_two(op_array);
pass_include_eval(op_array);
restore_lexical_state(&original_lex_state CLS_CC);
CG(active_op_array) = original_active_op_array;
retval = op_array;
}
}
zval_dtor(&tmp);
return retval;
}
int require_filename(char *filename CLS_DC)
{
zend_file_handle file_handle;
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = filename;
return require_file(&file_handle CLS_CC);
}
int require_file(zend_file_handle *file_handle CLS_DC)
{
zend_lex_state original_lex_state;
save_lexical_state(&original_lex_state CLS_CC);
if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
return FAILURE;
}
zendparse(CLS_C);
fclose(yyin);
restore_lexical_state(&original_lex_state CLS_CC);
return SUCCESS;
}
int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini)
{
zend_lex_state original_lex_state;
zend_file_handle file_handle;
CLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = filename;
save_lexical_state(&original_lex_state CLS_CC);
if (open_file_for_scanning(&file_handle CLS_CC)==FAILURE) {
zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
return FAILURE;
}
zend_highlight(syntax_highlighter_ini);
fclose(yyin);
restore_lexical_state(&original_lex_state CLS_CC);
return SUCCESS;
}
int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini)
{
zend_lex_state original_lex_state;
zval tmp = *str;
CLS_FETCH();
str = &tmp;
zval_copy_ctor(str);
save_lexical_state(&original_lex_state CLS_CC);
if (prepare_string_for_scanning(str)==FAILURE) {
return FAILURE;
}
zend_highlight(syntax_highlighter_ini);
restore_lexical_state(&original_lex_state CLS_CC);
zval_dtor(str);
return SUCCESS;
}
/* redefine YY_INPUT to handle urls for win32*/
#if 0 /*WIN32|WINNT*/
#define YY_INPUT(buf,result,max_size) \
if ( yyin->_tmpfname != "url" ){ \
if ( yy_current_buffer->yy_is_interactive ) \
{ \
int c = '*', n; \
for ( n = 0; n < max_size && \
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
if ( c == '\n' ) \
buf[n++] = (char) c; \
if ( c == EOF && ferror( yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
result = n; \
} \
else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
&& ferror( yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
}else{ /* this is a url */ \
int recv_char=0,socketd=0; \
/*memset(buf,0,max_size);*/ \
socketd=yyin->_file; \
if ( yy_current_buffer->yy_is_interactive ) \
{ \
int c = '*', n; \
for ( n = 0; n < max_size && \
( (recv_char=recv( socketd,(char *)&c,1,0 ))) >0 && c != '\n'; ++n ) \
buf[n] = (char) c; \
if ( c == '\n' ) \
buf[n++] = (char) c; \
if ( recv_char == SOCKET_ERROR ) \
YY_FATAL_ERROR( "input from url in flex scanner failed" ); \
result = n; \
} \
else if ((result = recv( socketd, (char *)buf, max_size, 0)) == SOCKET_ERROR) \
YY_FATAL_ERROR( "input from url read in flex scanner failed" ); \
}
#endif
%}
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 [;:,.\[\]()|^&+-/*=%!~$<>?@]
ENCAPSED_TOKENS [\[\]{}$]
ESCAPED_AND_WHITESPACE [\n\t\r #'.:;,()|^&+-/*=%!~<>?@]+
%option noyylineno
%option noyywrap
%%
%{
TLS_VARS;
%}
<IN_SCRIPTING>"exit" {
return T_EXIT;
}
<IN_SCRIPTING>"die" {
return T_EXIT;
}
<IN_SCRIPTING>"old_function" {
return OLD_FUNCTION;
}
<IN_SCRIPTING>"function"|"cfunction" {
return FUNCTION;
}
<IN_SCRIPTING>"const" {
return ZEND_CONST;
}
<IN_SCRIPTING>"return" {
return RETURN;
}
<IN_SCRIPTING>"if" {
return IF;
}
<IN_SCRIPTING>"elseif" {
return ELSEIF;
}
<IN_SCRIPTING>"endif" {
return ENDIF;
}
<IN_SCRIPTING>"else" {
return ELSE;
}
<IN_SCRIPTING>"while" {
return WHILE;
}
<IN_SCRIPTING>"endwhile" {
return ENDWHILE;
}
<IN_SCRIPTING>"do" {
return DO;
}
<IN_SCRIPTING>"for" {
return FOR;
}
<IN_SCRIPTING>"endfor" {
return ENDFOR;
}
<IN_SCRIPTING>"foreach" {
return ZEND_FOREACH;
}
<IN_SCRIPTING>"endforeach" {
return T_ENDFOREACH;
}
<IN_SCRIPTING>"as" {
return ZEND_AS;
}
<IN_SCRIPTING>"switch" {
return SWITCH;
}
<IN_SCRIPTING>"endswitch" {
return ENDSWITCH;
}
<IN_SCRIPTING>"case" {
return CASE;
}
<IN_SCRIPTING>"default" {
return DEFAULT;
}
<IN_SCRIPTING>"break" {
return BREAK;
}
<IN_SCRIPTING>"continue" {
return CONTINUE;
}
<IN_SCRIPTING>"echo" {
return ZEND_ECHO;
}
<IN_SCRIPTING>"print" {
return ZEND_PRINT;
}
<IN_SCRIPTING>"class" {
return CLASS;
}
<IN_SCRIPTING>"extends" {
return EXTENDS;
}
<IN_SCRIPTING,DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"->" {
yy_push_state(LOOKING_FOR_PROPERTY);
return ZEND_OBJECT_OPERATOR;
}
<LOOKING_FOR_PROPERTY>{LABEL} {
yy_pop_state();
zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return STRING;
}
<LOOKING_FOR_PROPERTY>. {
unput(yytext[0]);
yy_pop_state();
}
<IN_SCRIPTING>"::" {
return T_PAAMAYIM_NEKUDOTAYIM;
}
<IN_SCRIPTING>"new" {
return NEW;
}
<IN_SCRIPTING>"var" {
return VAR;
}
<IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" {
return INT_CAST;
}
<IN_SCRIPTING>"("{TABS_AND_SPACES}("real"|"double"|"float"){TABS_AND_SPACES}")" {
return DOUBLE_CAST;
}
<IN_SCRIPTING>"("{TABS_AND_SPACES}"string"{TABS_AND_SPACES}")" {
return STRING_CAST;
}
<IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" {
return ARRAY_CAST;
}
<IN_SCRIPTING>"("{TABS_AND_SPACES}"object"{TABS_AND_SPACES}")" {
return OBJECT_CAST;
}
<IN_SCRIPTING>"eval" {
return EVAL;
}
<IN_SCRIPTING>"include" {
return INCLUDE;
}
<IN_SCRIPTING>"require" {
return REQUIRE;
}
<IN_SCRIPTING>"global" {
return ZEND_GLOBAL;
}
<IN_SCRIPTING>"isset" {
return T_ISSET;
}
<IN_SCRIPTING>"empty" {
return T_EMPTY;
}
<IN_SCRIPTING>"static" {
return ZEND_STATIC;
}
<IN_SCRIPTING>"unset" {
return ZEND_UNSET;
}
<IN_SCRIPTING>"=>" {
return ZEND_DOUBLE_ARROW;
}
<IN_SCRIPTING>"list" {
return ZEND_LIST;
}
<IN_SCRIPTING>"array" {
return ZEND_ARRAY;
}
<IN_SCRIPTING>"++" {
return INCREMENT;
}
<IN_SCRIPTING>"--" {
return DECREMENT;
}
<IN_SCRIPTING>"==" {
return IS_EQUAL;
}
<IN_SCRIPTING>"!="|"<>" {
return IS_NOT_EQUAL;
}
<IN_SCRIPTING>"<=" {
return IS_SMALLER_OR_EQUAL;
}
<IN_SCRIPTING>">=" {
return IS_GREATER_OR_EQUAL;
}
<IN_SCRIPTING>"+=" {
return PLUS_EQUAL;
}
<IN_SCRIPTING>"-=" {
return MINUS_EQUAL;
}
<IN_SCRIPTING>"*=" {
return MUL_EQUAL;
}
<IN_SCRIPTING>"/=" {
return DIV_EQUAL;
}
<IN_SCRIPTING>".=" {
return CONCAT_EQUAL;
}
<IN_SCRIPTING>"%=" {
return MOD_EQUAL;
}
<IN_SCRIPTING>"<<=" {
return SHIFT_LEFT_EQUAL;
}
<IN_SCRIPTING>">>=" {
return SHIFT_RIGHT_EQUAL;
}
<IN_SCRIPTING>"&=" {
return AND_EQUAL;
}
<IN_SCRIPTING>"|=" {
return OR_EQUAL;
}
<IN_SCRIPTING>"^=" {
return XOR_EQUAL;
}
<IN_SCRIPTING>"||" {
return BOOLEAN_OR;
}
<IN_SCRIPTING>"&&" {
return BOOLEAN_AND;
}
<IN_SCRIPTING>"OR" {
return LOGICAL_OR;
}
<IN_SCRIPTING>"AND" {
return LOGICAL_AND;
}
<IN_SCRIPTING>"XOR" {
return LOGICAL_XOR;
}
<IN_SCRIPTING>"<<" {
return SHIFT_LEFT;
}
<IN_SCRIPTING>">>" {
return SHIFT_RIGHT;
}
<IN_SCRIPTING>{TOKENS} {
return yytext[0];
}
<IN_SCRIPTING>"{" {
yy_push_state(IN_SCRIPTING);
return '{';
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"${" {
yy_push_state(IN_SCRIPTING);
return DOLLAR_OPEN_CURLY_BRACES;
}
<IN_SCRIPTING>"}" {
yy_pop_state();
return '}';
}
<IN_SCRIPTING>{LNUM}|{HNUM} {
errno = 0;
zendlval->value.lval = strtol(yytext, NULL, 0);
if (errno == ERANGE) { /* overflow */
zendlval->value.dval = strtod(yytext,NULL);
zendlval->type = IS_DOUBLE;
return DNUMBER;
} else {
zendlval->type = IS_LONG;
return LNUMBER;
}
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>{LNUM}|{HNUM} { /* treat numbers (almost) as strings inside encapsulated strings */
zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return NUM_STRING;
}
<IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} {
zendlval->value.dval = strtod(yytext,NULL);
zendlval->type = IS_DOUBLE;
return DNUMBER;
}
<IN_SCRIPTING>"__LINE__" {
zendlval->value.lval = CG(zend_lineno);
zendlval->type = IS_LONG;
return ZEND_LINE;
}
<IN_SCRIPTING>"__FILE__" {
char *filename = zend_get_compiled_filename();
zendlval->value.str.len = strlen(filename);
zendlval->value.str.val = estrndup(filename,zendlval->value.str.len);
zendlval->type = IS_STRING;
return ZEND_FILE;
}
<INITIAL>(([^<]|"<"[^?%s<]){1,400})|"<s"|"<" {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
return INLINE_HTML;
}
<INITIAL>"<?"|"<script"{WHITESPACE}+"language"{WHITESPACE}*"="{WHITESPACE}*("php"|"\"php\""|"\'php\'"){WHITESPACE}*">" {
HANDLE_NEWLINES(yytext,yyleng);
if (CG(short_tags) || yyleng>2) { /* yyleng>2 means it's not <? but <script> */
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
BEGIN(IN_SCRIPTING);
return PHP_OPEN_TAG;
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return INLINE_HTML;
}
}
<INITIAL>"<%=" {
HANDLE_NEWLINES(yytext,yyleng);
if (CG(asp_tags)) {
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
BEGIN(IN_SCRIPTING);
return PHP_OPEN_TAG_WITH_ECHO;
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return INLINE_HTML;
}
}
<INITIAL>"<%" {
HANDLE_NEWLINES(yytext,yyleng);
if (CG(asp_tags)) {
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
BEGIN(IN_SCRIPTING);
} else {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return INLINE_HTML;
}
}
<INITIAL>"<?php"[ \n\r\t] {
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
HANDLE_NEWLINE(yytext[yyleng-1]);
BEGIN(IN_SCRIPTING);
return PHP_OPEN_TAG;
}
<INITIAL>"<?php_track_vars?>"([\n]|"\r\n")? {
zend_message_dispatcher(ZMSG_ENABLE_TRACK_VARS, NULL);
HANDLE_NEWLINE(yytext[yyleng-1]);
return T_PHP_TRACK_VARS;
}
<IN_SCRIPTING,DOUBLE_QUOTES,HEREDOC>"$"{LABEL} {
zendlval->value.str.val = (char *)estrndup(yytext+1, yyleng-1);
zendlval->value.str.len = yyleng-1;
zendlval->type = IS_STRING;
return VARIABLE;
}
<IN_SCRIPTING>{LABEL} {
zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return STRING;
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>{LABEL} {
zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return STRING;
}
<IN_SCRIPTING>{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;
}
<IN_SCRIPTING>([#]|"//")([^\n\r?]|"?"[^>\n\r])*("?\n"|"?\r\n")? { /* eat one line comments */
HANDLE_NEWLINE(yytext[yyleng-1]);
return ZEND_COMMENT;
}
<IN_SCRIPTING>"/*"([^*]|"*"[^/])*(("*/")?) {
HANDLE_NEWLINES(yytext, yyleng);
return ZEND_COMMENT;
}
<IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">")([\n]|"\r\n")? {
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext, yyleng);
BEGIN(INITIAL);
return PHP_CLOSE_TAG; /* implicit ';' at php-end tag */
}
<IN_SCRIPTING>"%>"([\n]|"\r\n")? {
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
if (CG(asp_tags)) {
BEGIN(INITIAL);
return PHP_CLOSE_TAG; /* implicit ';' at php-end tag */
} else {
return INLINE_HTML;
}
}
<IN_SCRIPTING>(["]([^"$\\]|([\\]+[^\\$]))*["])|([']([^'\\]|([\\]+['\\]))*[']) {
register char *s, *t;
char *end;
zendlval->value.str.val = estrndup(yytext+1, yyleng-2);
zendlval->value.str.len = yyleng-2;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
/* convert escape sequences */
s = t = zendlval->value.str.val;
end = s+zendlval->value.str.len;
while (s<end) {
if (*s=='\\') {
s++;
if (s>=end) {
continue;
}
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 '\\':
*t++ = '\\';
zendlval->value.str.len--;
break;
case '$':
case '"':
*t++ = *s;
zendlval->value.str.len--;
break;
default:
*t++ = '\\';
*t++ = *s;
break;
}
s++;
} else {
*t++ = *s++;
}
}
*t = 0;
return CONSTANT_ENCAPSED_STRING;
}
<IN_SCRIPTING>["] {
BEGIN(DOUBLE_QUOTES);
return '\"';
}
<IN_SCRIPTING>"<<<"{TABS_AND_SPACES}{LABEL}("\r")?"\n" {
char *s;
CG(heredoc_len) = yyleng-3-1-(yytext[yyleng-2]=='\r'?1:0);
s = yytext+3;
while ((*s == ' ') || (*s == '\t')) {
s++;
CG(heredoc_len)--;
}
CG(heredoc) = estrndup(s, CG(heredoc_len));
BEGIN(HEREDOC);
return ZEND_HEREDOC;
}
<IN_SCRIPTING>[`] {
BEGIN(BACKQUOTE);
return '`';
}
<IN_SCRIPTING>['] {
BEGIN(SINGLE_QUOTE);
return '\'';
}
<HEREDOC>^{LABEL}(";")?("\r")?"\n" {
int label_len;
unsigned char unput_semicolon;
if (yytext[yyleng-2]=='\r') {
label_len = yyleng-2;
} else {
label_len = yyleng-1;
}
if (yytext[label_len-1]==';') {
label_len--;
unput_semicolon=1;
} else{
unput_semicolon=0;
}
if (label_len==CG(heredoc_len) && !memcmp(yytext, CG(heredoc), label_len)) {
if (unput_semicolon) {
unput(';');
}
efree(CG(heredoc));
CG(heredoc)=NULL;
CG(heredoc_len)=0;
BEGIN(IN_SCRIPTING);
return ZEND_HEREDOC;
} else {
zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return STRING;
}
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>{ESCAPED_AND_WHITESPACE} {
HANDLE_NEWLINES(yytext,yyleng);
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return ENCAPSED_AND_WHITESPACE;
}
<SINGLE_QUOTE>([^'\\]|\\[^'\\])+ {
HANDLE_NEWLINES(yytext,yyleng);
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return ENCAPSED_AND_WHITESPACE;
}
<DOUBLE_QUOTES>[`]+ {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return ENCAPSED_AND_WHITESPACE;
}
<BACKQUOTE>["]+ {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return ENCAPSED_AND_WHITESPACE;
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"$"[^a-zA-Z_\x7f-\xff{] {
zendlval->value.chval = yytext[0];
if (yyleng == 2) {
unput(yytext[1]);
yytext[1] = 0;
yyleng--;
}
return CHARACTER;
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>{ENCAPSED_TOKENS} {
zendlval->value.chval = yytext[0];
return yytext[0];
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"{$" {
zendlval->value.chval = yytext[0];
yy_push_state(IN_SCRIPTING);
unput('$');
return T_CURLY_OPEN;
}
<SINGLE_QUOTE>"\\'" {
zendlval->value.chval='\'';
return CHARACTER;
}
<SINGLE_QUOTE>"\\\\" {
zendlval->value.chval='\\';
return CHARACTER;
}
<DOUBLE_QUOTES>"\\\"" {
zendlval->value.chval='"';
return CHARACTER;
}
<BACKQUOTE>"\\`" {
zendlval->value.chval='`';
return CHARACTER;
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"\\"[0-7]{1,3} {
zendlval->value.chval = (char) strtol (yytext+1, NULL, 8);
return CHARACTER;
}
<DOUBLE_QUOTES,BACKQUOTE,HEREDOC>"\\x"[0-9A-Fa-f]{1,2} {
zendlval->value.chval = (char) strtol (yytext+2, NULL, 16);
return CHARACTER;
}
<DOUBLE_QUOTES,BACKQUOTE>"\\". {
switch (yytext[1]) {
case 'n':
zendlval->value.chval='\n';
break;
case 't':
zendlval->value.chval='\t';
break;
case 'r':
zendlval->value.chval='\r';
break;
case '\\':
zendlval->value.chval='\\';
break;
case '$':
zendlval->value.chval=yytext[1];
break;
case '{':
zendlval->value.chval=yytext[1];
break;
default:
zendlval->value.str.val = estrndup(yytext,yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return BAD_CHARACTER;
break;
}
return CHARACTER;
}
<HEREDOC>"\\$"|"\\{" {
zendlval->value.chval = yytext[1];
return CHARACTER;
}
<HEREDOC>["'`]+ {
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return ENCAPSED_AND_WHITESPACE;
}
<DOUBLE_QUOTES>["] {
BEGIN(IN_SCRIPTING);
return '\"';
}
<BACKQUOTE>[`] {
BEGIN(IN_SCRIPTING);
return '`';
}
<SINGLE_QUOTE>['] {
BEGIN(IN_SCRIPTING);
return '\'';
}
<DOUBLE_QUOTES,BACKQUOTE,INITIAL,IN_SCRIPTING,LOOKING_FOR_PROPERTY><<EOF>> {
return 0;
}
<IN_SCRIPTING,INITIAL,DOUBLE_QUOTES,BACKQUOTE,SINGLE_QUOTE>. {
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d",yytext[0],yytext[0],YYSTATE);
}