1 : %{
2 :
3 : /*
4 : +----------------------------------------------------------------------+
5 : | Zend Engine |
6 : +----------------------------------------------------------------------+
7 : | Copyright (c) 1998-2006 Zend Technologies Ltd. (http://www.zend.com) |
8 : +----------------------------------------------------------------------+
9 : | This source file is subject to version 2.00 of the Zend license, |
10 : | that is bundled with this package in the file LICENSE, and is |
11 : | available through the world-wide-web at the following url: |
12 : | http://www.zend.com/license/2_00.txt. |
13 : | If you did not receive a copy of the Zend license and are unable to |
14 : | obtain it through the world-wide-web, please send a note to |
15 : | license@zend.com so we can mail you a copy immediately. |
16 : +----------------------------------------------------------------------+
17 : | Authors: Andi Gutmans <andi@zend.com> |
18 : | Zeev Suraski <zeev@zend.com> |
19 : +----------------------------------------------------------------------+
20 : */
21 :
22 : /* $Id: zend_language_scanner.l,v 1.131.2.11.2.9 2007/02/24 02:17:23 helly Exp $ */
23 :
24 : #define yyleng SCNG(yy_leng)
25 : #define yytext SCNG(yy_text)
26 : #define yytext_ptr SCNG(yy_text)
27 : #define yyin SCNG(yy_in)
28 : #define yyout SCNG(yy_out)
29 : #define yy_last_accepting_state SCNG(_yy_last_accepting_state)
30 : #define yy_last_accepting_cpos SCNG(_yy_last_accepting_cpos)
31 : #define yy_more_flag SCNG(_yy_more_flag)
32 : #define yy_more_len SCNG(_yy_more_len)
33 :
34 : %}
35 :
36 : %x ST_IN_SCRIPTING
37 : %x ST_DOUBLE_QUOTES
38 : %x ST_SINGLE_QUOTE
39 : %x ST_BACKQUOTE
40 : %x ST_HEREDOC
41 : %x ST_LOOKING_FOR_PROPERTY
42 : %x ST_LOOKING_FOR_VARNAME
43 : %x ST_COMMENT
44 : %x ST_DOC_COMMENT
45 : %x ST_ONE_LINE_COMMENT
46 : %option stack
47 :
48 : %{
49 :
50 : #include <errno.h>
51 : #include "zend.h"
52 : #include "zend_alloc.h"
53 : #include <zend_language_parser.h>
54 : #include "zend_compile.h"
55 : #include "zend_language_scanner.h"
56 : #include "zend_highlight.h"
57 : #include "zend_constants.h"
58 : #include "zend_variables.h"
59 : #include "zend_operators.h"
60 : #include "zend_API.h"
61 : #include "zend_strtod.h"
62 : #include "zend_exceptions.h"
63 :
64 : #ifdef HAVE_STDARG_H
65 : # include <stdarg.h>
66 : #endif
67 :
68 : #ifdef HAVE_UNISTD_H
69 : # include <unistd.h>
70 : #endif
71 :
72 : #define YY_DECL int lex_scan(zval *zendlval TSRMLS_DC)
73 :
74 : #define ECHO { ZEND_WRITE( yytext, yyleng ); }
75 :
76 : #ifdef ZTS
77 : # define MY_INPUT yyinput
78 : #else
79 : # define MY_INPUT input
80 : #endif
81 :
82 :
83 : /* Globals Macros */
84 : #define SCNG LANG_SCNG
85 : #ifdef ZTS
86 : ZEND_API ts_rsrc_id language_scanner_globals_id;
87 : #else
88 : ZEND_API zend_scanner_globals language_scanner_globals;
89 : #endif
90 :
91 :
92 : #define YY_FATAL_ERROR zend_fatal_scanner_error
93 :
94 : #define HANDLE_NEWLINES(s, l) \
95 : do { \
96 : char *p = (s), *boundary = p+(l); \
97 : \
98 : while (p<boundary) { \
99 : if (*p == '\n') { \
100 : CG(zend_lineno)++; \
101 : } else if ((*p == '\r') && (p+1 < boundary) && (*(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 :
116 : #define ZEND_IS_OCT(c) ((c)>='0' && (c)<='7')
117 : #define ZEND_IS_HEX(c) (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
118 :
119 :
120 : void zend_fatal_scanner_error(char *message)
121 0 : {
122 0 : zend_error(E_COMPILE_ERROR, "%s", message);
123 0 : }
124 :
125 : BEGIN_EXTERN_C()
126 : void startup_scanner(TSRMLS_D)
127 219 : {
128 219 : CG(heredoc) = NULL;
129 219 : CG(heredoc_len) = 0;
130 219 : CG(doc_comment) = NULL;
131 219 : CG(doc_comment_len) = 0;
132 219 : SCNG(yy_start_stack_ptr) = 0;
133 219 : SCNG(yy_start_stack_depth) = 0;
134 219 : SCNG(current_buffer) = NULL;
135 : #ifdef ZEND_MULTIBYTE
136 : SCNG(script_org) = NULL;
137 : SCNG(script_org_size) = 0;
138 : SCNG(script_filtered) = NULL;
139 : SCNG(script_filtered_size) = 0;
140 : SCNG(input_filter) = NULL;
141 : SCNG(output_filter) = NULL;
142 : SCNG(script_encoding) = NULL;
143 : SCNG(internal_encoding) = NULL;
144 : #endif /* ZEND_MULTIBYTE */
145 219 : }
146 :
147 :
148 : void shutdown_scanner(TSRMLS_D)
149 219 : {
150 219 : if (CG(heredoc)) {
151 0 : efree(CG(heredoc));
152 0 : CG(heredoc_len)=0;
153 : }
154 219 : if (SCNG(yy_start_stack)) {
155 157 : yy_flex_free(SCNG(yy_start_stack));
156 157 : SCNG(yy_start_stack) = NULL;
157 : }
158 219 : RESET_DOC_COMMENT();
159 :
160 : #ifdef ZEND_MULTIBYTE
161 : if (SCNG(script_org)) {
162 : efree(SCNG(script_org));
163 : SCNG(script_org) = NULL;
164 : }
165 : if (SCNG(script_filtered)) {
166 : efree(SCNG(script_filtered));
167 : SCNG(script_filtered) = NULL;
168 : }
169 : SCNG(script_org_size) = 0;
170 : SCNG(script_filtered_size) = 0;
171 : SCNG(input_filter) = NULL;
172 : SCNG(output_filter) = NULL;
173 : SCNG(script_encoding) = NULL;
174 : SCNG(internal_encoding) = NULL;
175 : #endif /* ZEND_MULTIBYTE */
176 219 : }
177 : END_EXTERN_C()
178 :
179 :
180 : ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
181 335 : {
182 335 : memcpy(&lex_state->buffer_state, &YY_CURRENT_BUFFER, sizeof(YY_BUFFER_STATE));
183 335 : lex_state->in = SCNG(yy_in);
184 335 : lex_state->state = YYSTATE;
185 335 : lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
186 335 : lex_state->lineno = CG(zend_lineno);
187 :
188 : #ifdef ZEND_MULTIBYTE
189 : lex_state->script_org = SCNG(script_org);
190 : lex_state->script_org_size = SCNG(script_org_size);
191 : lex_state->script_filtered = SCNG(script_filtered);
192 : lex_state->script_filtered_size = SCNG(script_filtered_size);
193 : lex_state->input_filter = SCNG(input_filter);
194 : lex_state->output_filter = SCNG(output_filter);
195 : lex_state->script_encoding = SCNG(script_encoding);
196 : lex_state->internal_encoding = SCNG(internal_encoding);
197 : #endif /* ZEND_MULTIBYTE */
198 335 : }
199 :
200 : ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
201 335 : {
202 335 : YY_BUFFER_STATE original_buffer_state = YY_CURRENT_BUFFER;
203 :
204 335 : if (lex_state->buffer_state) {
205 0 : yy_switch_to_buffer(lex_state->buffer_state TSRMLS_CC);
206 : } else {
207 335 : YY_CURRENT_BUFFER = NULL;
208 : }
209 :
210 335 : yy_delete_buffer(original_buffer_state TSRMLS_CC);
211 335 : SCNG(yy_in) = lex_state->in;
212 335 : BEGIN(lex_state->state);
213 335 : CG(zend_lineno) = lex_state->lineno;
214 335 : zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);
215 :
216 : #ifdef ZEND_MULTIBYTE
217 : if (SCNG(script_org)) {
218 : efree(SCNG(script_org));
219 : SCNG(script_org) = NULL;
220 : }
221 : if (SCNG(script_filtered)) {
222 : efree(SCNG(script_filtered));
223 : SCNG(script_filtered) = NULL;
224 : }
225 : SCNG(script_org) = lex_state->script_org;
226 : SCNG(script_org_size) = lex_state->script_org_size;
227 : SCNG(script_filtered) = lex_state->script_filtered;
228 : SCNG(script_filtered_size) = lex_state->script_filtered_size;
229 : SCNG(input_filter) = lex_state->input_filter;
230 : SCNG(output_filter) = lex_state->output_filter;
231 : SCNG(script_encoding) = lex_state->script_encoding;
232 : SCNG(internal_encoding) = lex_state->internal_encoding;
233 : #endif /* ZEND_MULTIBYTE */
234 335 : }
235 :
236 :
237 : BEGIN_EXTERN_C()
238 :
239 :
240 : ZEND_API void zend_file_handle_dtor(zend_file_handle *fh)
241 335 : {
242 : TSRMLS_FETCH();
243 :
244 335 : switch (fh->type) {
245 : case ZEND_HANDLE_FP:
246 219 : fclose(fh->handle.fp);
247 219 : break;
248 : case ZEND_HANDLE_STREAM:
249 116 : if (fh->handle.stream.closer) {
250 116 : fh->handle.stream.closer(fh->handle.stream.handle TSRMLS_CC);
251 : }
252 : break;
253 : case ZEND_HANDLE_FILENAME:
254 : /* We're only supposed to get here when destructing the used_files hash,
255 : * which doesn't really contain open files, but references to their names/paths
256 : */
257 : break;
258 : }
259 335 : if (fh->opened_path) {
260 335 : efree(fh->opened_path);
261 335 : fh->opened_path = NULL;
262 : }
263 335 : if (fh->free_filename && fh->filename) {
264 0 : efree(fh->filename);
265 0 : fh->filename = NULL;
266 : }
267 335 : }
268 :
269 :
270 : int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2)
271 335 : {
272 335 : if (fh1->type != fh2->type) {
273 0 : return 0;
274 : }
275 335 : switch (fh1->type) {
276 : case ZEND_HANDLE_FP:
277 219 : return fh1->handle.fp==fh2->handle.fp;
278 : break;
279 : case ZEND_HANDLE_STREAM:
280 116 : return fh1->handle.stream.handle == fh2->handle.stream.handle;
281 : break;
282 : }
283 0 : return 0;
284 : }
285 :
286 :
287 : ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
288 335 : {
289 335 : zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
290 : /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
291 335 : file_handle->opened_path = NULL;
292 335 : if (file_handle->free_filename) {
293 0 : file_handle->filename = NULL;
294 : }
295 335 : }
296 :
297 :
298 : ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
299 335 : {
300 335 : char *file_path=NULL;
301 :
302 335 : if (FAILURE == zend_stream_fixup(file_handle TSRMLS_CC)) {
303 0 : return FAILURE;
304 : }
305 :
306 335 : zend_llist_add_element(&CG(open_files), file_handle);
307 :
308 : /* Reset the scanner for scanning the new file */
309 335 : SCNG(yy_in) = file_handle;
310 :
311 : #ifdef ZEND_MULTIBYTE
312 : if (file_handle->handle.stream.interactive == 0) {
313 : if (zend_multibyte_read_script(TSRMLS_C) != 0) {
314 : return FAILURE;
315 : }
316 :
317 : /* force flex to use buffer only */
318 : SCNG(yy_in) = NULL;
319 : SCNG(init) = 0;
320 : SCNG(start) = 1;
321 :
322 : zend_multibyte_set_filter(NULL TSRMLS_CC);
323 :
324 : if (!SCNG(input_filter)) {
325 : SCNG(script_filtered) = (char*)emalloc(SCNG(script_org_size)+1);
326 : memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
327 : SCNG(script_filtered_size) = SCNG(script_org_size);
328 : } else {
329 : SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
330 : }
331 :
332 : /* flex requires doubled null */
333 : SCNG(script_filtered) = (char*)erealloc(SCNG(script_filtered), SCNG(script_filtered_size)+2);
334 : *(SCNG(script_filtered)+SCNG(script_filtered_size)) = (char)NULL;
335 : *(SCNG(script_filtered)+SCNG(script_filtered_size)+1) = (char)NULL;
336 : yy_scan_buffer(SCNG(script_filtered), SCNG(script_filtered_size)+2 TSRMLS_CC);
337 : } else {
338 : yy_switch_to_buffer(yy_create_buffer(SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC) TSRMLS_CC);
339 : }
340 : #else /* !ZEND_MULTIBYTE */
341 335 : yy_switch_to_buffer(yy_create_buffer(SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC) TSRMLS_CC);
342 : #endif /* ZEND_MULTIBYTE */
343 :
344 335 : BEGIN(INITIAL);
345 :
346 335 : if (file_handle->opened_path) {
347 335 : file_path = file_handle->opened_path;
348 : } else {
349 0 : file_path = file_handle->filename;
350 : }
351 :
352 335 : zend_set_compiled_filename(file_path TSRMLS_CC);
353 :
354 335 : if (CG(start_lineno)) {
355 1 : CG(zend_lineno) = CG(start_lineno);
356 1 : CG(start_lineno) = 0;
357 : } else {
358 334 : CG(zend_lineno) = 1;
359 : }
360 :
361 335 : CG(increment_lineno) = 0;
362 335 : return SUCCESS;
363 : }
364 : END_EXTERN_C()
365 :
366 :
367 : ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
368 335 : {
369 : zend_lex_state original_lex_state;
370 335 : zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
371 335 : zend_op_array *original_active_op_array = CG(active_op_array);
372 335 : zend_op_array *retval=NULL;
373 : int compiler_result;
374 335 : zend_bool compilation_successful=0;
375 : znode retval_znode;
376 335 : zend_bool original_in_compilation = CG(in_compilation);
377 :
378 335 : retval_znode.op_type = IS_CONST;
379 335 : retval_znode.u.constant.type = IS_LONG;
380 335 : retval_znode.u.constant.value.lval = 1;
381 335 : retval_znode.u.constant.is_ref = 0;
382 335 : retval_znode.u.constant.refcount = 1;
383 :
384 335 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
385 :
386 335 : retval = op_array; /* success oriented */
387 :
388 335 : if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
389 0 : if (type==ZEND_REQUIRE) {
390 0 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
391 0 : zend_bailout();
392 : } else {
393 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename);
394 : }
395 0 : compilation_successful=0;
396 : } else {
397 335 : init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
398 335 : CG(in_compilation) = 1;
399 335 : CG(active_op_array) = op_array;
400 335 : compiler_result = zendparse(TSRMLS_C);
401 335 : zend_do_return(&retval_znode, 0 TSRMLS_CC);
402 335 : zend_do_handle_exception(TSRMLS_C);
403 335 : CG(in_compilation) = original_in_compilation;
404 335 : if (compiler_result==1) { /* parser error */
405 0 : zend_bailout();
406 : }
407 335 : compilation_successful=1;
408 : }
409 :
410 335 : if (retval) {
411 335 : CG(active_op_array) = original_active_op_array;
412 335 : if (compilation_successful) {
413 335 : pass_two(op_array TSRMLS_CC);
414 : } else {
415 0 : efree(op_array);
416 0 : retval = NULL;
417 : }
418 : }
419 335 : if (compilation_successful) {
420 335 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
421 : }
422 335 : return retval;
423 : }
424 :
425 :
426 : zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
427 116 : {
428 : zend_file_handle file_handle;
429 : zval tmp;
430 : zend_op_array *retval;
431 116 : char *opened_path = NULL;
432 :
433 116 : if (filename->type != IS_STRING) {
434 0 : tmp = *filename;
435 0 : zval_copy_ctor(&tmp);
436 0 : convert_to_string(&tmp);
437 0 : filename = &tmp;
438 : }
439 116 : file_handle.filename = filename->value.str.val;
440 116 : file_handle.free_filename = 0;
441 116 : file_handle.type = ZEND_HANDLE_FILENAME;
442 116 : file_handle.opened_path = NULL;
443 116 : file_handle.handle.fp = NULL;
444 :
445 116 : retval = zend_compile_file(&file_handle, type TSRMLS_CC);
446 116 : if (retval && file_handle.handle.stream.handle) {
447 116 : int dummy = 1;
448 :
449 116 : if (!file_handle.opened_path) {
450 0 : file_handle.opened_path = opened_path = estrndup(filename->value.str.val, filename->value.str.len);
451 : }
452 :
453 116 : zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
454 :
455 116 : if (opened_path) {
456 0 : efree(opened_path);
457 : }
458 : }
459 116 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
460 :
461 116 : if (filename==&tmp) {
462 0 : zval_dtor(&tmp);
463 : }
464 116 : return retval;
465 : }
466 :
467 : ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
468 0 : {
469 : /* enforce two trailing NULLs for flex... */
470 0 : STR_REALLOC(str->value.str.val, str->value.str.len+2);
471 :
472 0 : str->value.str.val[str->value.str.len+1]=0;
473 :
474 0 : SCNG(yy_in)=NULL;
475 :
476 : #ifdef ZEND_MULTIBYTE
477 : SCNG(script_org) = estrdup(str->value.str.val);
478 : SCNG(script_org_size) = str->value.str.len;
479 :
480 : zend_multibyte_set_filter(CG(internal_encoding) TSRMLS_CC);
481 :
482 : if (!SCNG(input_filter)) {
483 : SCNG(script_filtered) = (char*)emalloc(SCNG(script_org_size)+1);
484 : memcpy(SCNG(script_filtered), SCNG(script_org), SCNG(script_org_size)+1);
485 : SCNG(script_filtered_size) = SCNG(script_org_size);
486 : } else {
487 : SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC);
488 : }
489 :
490 : /* flex requires doubled null */
491 : SCNG(script_filtered) = (char*)erealloc(SCNG(script_filtered), SCNG(script_filtered_size)+2);
492 : *(SCNG(script_filtered)+SCNG(script_filtered_size)) = (char)NULL;
493 : *(SCNG(script_filtered)+SCNG(script_filtered_size)+1) = (char)NULL;
494 : yy_scan_buffer(SCNG(script_filtered), SCNG(script_filtered_size)+2 TSRMLS_CC);
495 : #else /* !ZEND_MULTIBYTE */
496 0 : yy_scan_buffer(str->value.str.val, str->value.str.len+2 TSRMLS_CC);
497 : #endif /* ZEND_MULTIBYTE */
498 :
499 0 : zend_set_compiled_filename(filename TSRMLS_CC);
500 0 : CG(zend_lineno) = 1;
501 0 : CG(increment_lineno) = 0;
502 0 : return SUCCESS;
503 : }
504 :
505 :
506 : ZEND_API int zend_get_scanned_file_offset(TSRMLS_D)
507 0 : {
508 0 : if (yyin) {
509 0 : int offset_in_buffer = (yy_c_buf_p - (YY_CURRENT_BUFFER)->yy_ch_buf);
510 0 : int read_bytes = SCNG(yy_n_chars);
511 0 : int offset_from_the_end = read_bytes - offset_in_buffer;
512 :
513 0 : return zend_stream_ftell(yyin TSRMLS_CC) - offset_from_the_end;
514 : } else {
515 : /* The entire file is in the buffer; probably zend multibyte
516 : is enabled */
517 0 : return (yy_c_buf_p - (YY_CURRENT_BUFFER)->yy_ch_buf);
518 : }
519 : }
520 :
521 :
522 : zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
523 0 : {
524 : zend_lex_state original_lex_state;
525 0 : zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
526 0 : zend_op_array *original_active_op_array = CG(active_op_array);
527 : zend_op_array *retval;
528 : zval tmp;
529 : int compiler_result;
530 0 : zend_bool original_in_compilation = CG(in_compilation);
531 :
532 0 : if (source_string->value.str.len==0) {
533 0 : efree(op_array);
534 0 : return NULL;
535 : }
536 :
537 0 : CG(in_compilation) = 1;
538 :
539 0 : tmp = *source_string;
540 0 : zval_copy_ctor(&tmp);
541 0 : convert_to_string(&tmp);
542 0 : source_string = &tmp;
543 :
544 0 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
545 0 : if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
546 0 : efree(op_array);
547 0 : retval = NULL;
548 : } else {
549 0 : zend_bool orig_interactive = CG(interactive);
550 :
551 0 : CG(interactive) = 0;
552 0 : init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
553 0 : CG(interactive) = orig_interactive;
554 0 : CG(active_op_array) = op_array;
555 0 : BEGIN(ST_IN_SCRIPTING);
556 0 : compiler_result = zendparse(TSRMLS_C);
557 :
558 : #ifdef ZEND_MULTIBYTE
559 : if (SCNG(script_org)) {
560 : efree(SCNG(script_org));
561 : SCNG(script_org) = NULL;
562 : }
563 : if (SCNG(script_filtered)) {
564 : efree(SCNG(script_filtered));
565 : SCNG(script_filtered) = NULL;
566 : }
567 : #endif /* ZEND_MULTIBYTE */
568 :
569 0 : if (compiler_result==1) {
570 0 : CG(active_op_array) = original_active_op_array;
571 0 : CG(unclean_shutdown)=1;
572 0 : retval = NULL;
573 : } else {
574 0 : zend_do_return(NULL, 0 TSRMLS_CC);
575 0 : zend_do_handle_exception(TSRMLS_C);
576 0 : CG(active_op_array) = original_active_op_array;
577 0 : pass_two(op_array TSRMLS_CC);
578 0 : retval = op_array;
579 : }
580 0 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
581 : }
582 0 : zval_dtor(&tmp);
583 0 : CG(in_compilation) = original_in_compilation;
584 0 : return retval;
585 : }
586 :
587 :
588 : BEGIN_EXTERN_C()
589 : int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
590 0 : {
591 : zend_lex_state original_lex_state;
592 : zend_file_handle file_handle;
593 :
594 0 : file_handle.type = ZEND_HANDLE_FILENAME;
595 0 : file_handle.filename = filename;
596 0 : file_handle.free_filename = 0;
597 0 : file_handle.opened_path = NULL;
598 0 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
599 0 : if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
600 0 : zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
601 0 : return FAILURE;
602 : }
603 0 : zend_highlight(syntax_highlighter_ini TSRMLS_CC);
604 : #ifdef ZEND_MULTIBYTE
605 : if (SCNG(script_org)) {
606 : efree(SCNG(script_org));
607 : SCNG(script_org) = NULL;
608 : }
609 : if (SCNG(script_filtered)) {
610 : efree(SCNG(script_filtered));
611 : SCNG(script_filtered) = NULL;
612 : }
613 : #endif /* ZEND_MULTIBYTE */
614 0 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
615 0 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
616 0 : return SUCCESS;
617 : }
618 :
619 : int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)
620 0 : {
621 : zend_lex_state original_lex_state;
622 0 : zval tmp = *str;
623 :
624 0 : str = &tmp;
625 0 : zval_copy_ctor(str);
626 0 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
627 0 : if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
628 0 : return FAILURE;
629 : }
630 0 : BEGIN(INITIAL);
631 0 : zend_highlight(syntax_highlighter_ini TSRMLS_CC);
632 : #ifdef ZEND_MULTIBYTE
633 : if (SCNG(script_org)) {
634 : efree(SCNG(script_org));
635 : SCNG(script_org) = NULL;
636 : }
637 : if (SCNG(script_filtered)) {
638 : efree(SCNG(script_filtered));
639 : SCNG(script_filtered) = NULL;
640 : }
641 : #endif /* ZEND_MULTIBYTE */
642 0 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
643 0 : zval_dtor(str);
644 0 : return SUCCESS;
645 : }
646 : END_EXTERN_C()
647 :
648 : #ifdef ZEND_MULTIBYTE
649 : BEGIN_EXTERN_C()
650 : ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, zend_encoding *old_encoding TSRMLS_DC)
651 : {
652 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
653 : int offset, original_offset, length, free_flag;
654 : char *p;
655 : zend_encoding *new_encoding;
656 :
657 : /* calculate current position */
658 : offset = original_offset = yy_c_buf_p - b->yy_ch_buf;
659 : if (old_input_filter && original_offset > 0) {
660 : new_encoding = SCNG(script_encoding);
661 : SCNG(script_encoding) = old_encoding;
662 : do {
663 : (old_input_filter)(&p, &length, SCNG(script_org), offset TSRMLS_CC);
664 : if (!p) {
665 : SCNG(script_encoding) = new_encoding;
666 : return;
667 : }
668 : efree(p);
669 : if (length > original_offset) {
670 : offset--;
671 : } else if (length < original_offset) {
672 : offset++;
673 : }
674 : } while (original_offset != length);
675 : SCNG(script_encoding) = new_encoding;
676 : }
677 :
678 : /* convert and set */
679 : if (!SCNG(input_filter)) {
680 : length = SCNG(script_org_size)-offset-1;
681 : p = SCNG(script_org)+offset+1;
682 : free_flag = 0;
683 : } else {
684 : SCNG(input_filter)(&p, &length, SCNG(script_org)+offset+1, SCNG(script_org_size)-offset-1 TSRMLS_CC);
685 : free_flag = 1;
686 : }
687 : if (original_offset+length+1 > (int)b->yy_buf_size) {
688 : b->yy_buf_size = original_offset+length+1;
689 : b->yy_ch_buf = (char*)erealloc(b->yy_ch_buf, b->yy_buf_size+2);
690 : SCNG(script_filtered) = b->yy_ch_buf;
691 : SCNG(script_filtered_size) = b->yy_buf_size;
692 : }
693 : yy_c_buf_p = b->yy_ch_buf + original_offset;
694 : strncpy(yy_c_buf_p+1, p, length);
695 : b->yy_n_chars = original_offset + length + 1;
696 : SCNG(yy_n_chars) = b->yy_n_chars;
697 : b->yy_ch_buf[SCNG(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
698 : b->yy_ch_buf[SCNG(yy_n_chars)+1] = YY_END_OF_BUFFER_CHAR;
699 :
700 : if (free_flag) {
701 : efree(p);
702 : }
703 : }
704 :
705 :
706 : ZEND_API int zend_multibyte_yyinput(zend_file_handle *file_handle, char *buf, size_t len TSRMLS_DC)
707 : {
708 : int c = '*', n;
709 :
710 : if (file_handle->handle.stream.interactive == 0) {
711 : return zend_stream_read(file_handle, buf, len TSRMLS_CC);
712 : }
713 :
714 : /* interactive */
715 : if (SCNG(script_org)) {
716 : efree(SCNG(script_org));
717 : }
718 : if (SCNG(script_filtered)) {
719 : efree(SCNG(script_filtered));
720 : }
721 : SCNG(script_org) = NULL;
722 : SCNG(script_org_size) = 0;
723 :
724 : /* TODO: support widechars */
725 :
726 : for (n = 0; n < sizeof(buf) && (c = zend_stream_getc(yyin TSRMLS_CC)) != EOF && c != '\n'; ++n) {
727 : buf[n] = (char)c;
728 : }
729 : if (c == '\n') {
730 : buf[n++] = (char) c;
731 : }
732 :
733 : SCNG(script_org_size) = n;
734 : SCNG(script_org) = (char*)emalloc(SCNG(script_org_size)+1);
735 : memcpy(SCNG(script_org)+SCNG(script_org_size)-n, buf, n);
736 :
737 : return n;
738 : }
739 :
740 :
741 : ZEND_API int zend_multibyte_read_script(TSRMLS_D)
742 : {
743 : char buf[8192];
744 : int n;
745 :
746 : if (SCNG(script_org)) {
747 : efree(SCNG(script_org));
748 : }
749 : SCNG(script_org) = NULL;
750 : SCNG(script_org_size) = 0;
751 :
752 : for (;;) {
753 : n = zend_stream_read(yyin, buf, sizeof(buf) TSRMLS_CC);
754 : if (n <= 0) {
755 : break;
756 : }
757 :
758 : SCNG(script_org_size) += n;
759 : if (SCNG(script_org)) {
760 : SCNG(script_org) = (char*)erealloc(SCNG(script_org), SCNG(script_org_size)+1);
761 : } else {
762 : SCNG(script_org) = (char*)emalloc(SCNG(script_org_size)+1);
763 : }
764 : memcpy(SCNG(script_org)+SCNG(script_org_size)-n, buf, n);
765 : }
766 :
767 : if (n < 0) {
768 : return -1;
769 : }
770 :
771 : if (!SCNG(script_org)) {
772 : SCNG(script_org) = emalloc(SCNG(script_org_size)+1);
773 : }
774 : *(SCNG(script_org)+SCNG(script_org_size)) = (char)NULL;
775 :
776 : return 0;
777 : }
778 :
779 :
780 : # define zend_copy_value(zendlval, yytext, yyleng) \
781 : if (SCNG(output_filter)) { \
782 : SCNG(output_filter)(&(zendlval->value.str.val), &(zendlval->value.str.len), yytext, yyleng TSRMLS_CC); \
783 : } else { \
784 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng); \
785 : zendlval->value.str.len = yyleng; \
786 : }
787 : #else /* ZEND_MULTIBYTE */
788 : # define zend_copy_value(zendlval, yytext, yyleng) \
789 : zendlval->value.str.val = (char *)estrndup(yytext, yyleng); \
790 : zendlval->value.str.len = yyleng;
791 : #endif /* ZEND_MULTIBYTE */
792 : %}
793 :
794 : LNUM [0-9]+
795 : DNUM ([0-9]*[\.][0-9]+)|([0-9]+[\.][0-9]*)
796 : EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
797 : HNUM "0x"[0-9a-fA-F]+
798 : LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
799 : WHITESPACE [ \n\r\t]+
800 : TABS_AND_SPACES [ \t]*
801 : TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@]
802 : ENCAPSED_TOKENS [\[\]{}$]
803 : ESCAPED_AND_WHITESPACE [\n\t\r #'.:;,()|^&+-/*=%!~<>?@]+
804 : ANY_CHAR (.|[\n])
805 : NEWLINE ("\r"|"\n"|"\r\n")
806 :
807 : %option noyylineno
808 : %option noyywrap
809 : %%
810 :
811 : <ST_IN_SCRIPTING>"exit" {
812 117 : return T_EXIT;
813 : }
814 :
815 : <ST_IN_SCRIPTING>"die" {
816 1 : return T_EXIT;
817 : }
818 :
819 : <ST_IN_SCRIPTING>"function" {
820 916 : return T_FUNCTION;
821 : }
822 :
823 : <ST_IN_SCRIPTING>"const" {
824 0 : return T_CONST;
825 : }
826 :
827 : <ST_IN_SCRIPTING>"return" {
828 27 : return T_RETURN;
829 : }
830 :
831 : <ST_IN_SCRIPTING>"try" {
832 8 : return T_TRY;
833 : }
834 :
835 : <ST_IN_SCRIPTING>"catch" {
836 8 : return T_CATCH;
837 : }
838 :
839 : <ST_IN_SCRIPTING>"throw" {
840 3 : return T_THROW;
841 : }
842 :
843 : <ST_IN_SCRIPTING>"if" {
844 330 : return T_IF;
845 : }
846 :
847 : <ST_IN_SCRIPTING>"elseif" {
848 3 : return T_ELSEIF;
849 : }
850 :
851 : <ST_IN_SCRIPTING>"endif" {
852 0 : return T_ENDIF;
853 : }
854 :
855 : <ST_IN_SCRIPTING>"else" {
856 45 : return T_ELSE;
857 : }
858 :
859 : <ST_IN_SCRIPTING>"while" {
860 14 : return T_WHILE;
861 : }
862 :
863 : <ST_IN_SCRIPTING>"endwhile" {
864 0 : return T_ENDWHILE;
865 : }
866 :
867 : <ST_IN_SCRIPTING>"do" {
868 1 : return T_DO;
869 : }
870 :
871 : <ST_IN_SCRIPTING>"for" {
872 9 : return T_FOR;
873 : }
874 :
875 : <ST_IN_SCRIPTING>"endfor" {
876 0 : return T_ENDFOR;
877 : }
878 :
879 : <ST_IN_SCRIPTING>"foreach" {
880 42 : return T_FOREACH;
881 : }
882 :
883 : <ST_IN_SCRIPTING>"endforeach" {
884 0 : return T_ENDFOREACH;
885 : }
886 :
887 : <ST_IN_SCRIPTING>"declare" {
888 0 : return T_DECLARE;
889 : }
890 :
891 : <ST_IN_SCRIPTING>"enddeclare" {
892 0 : return T_ENDDECLARE;
893 : }
894 :
895 : <ST_IN_SCRIPTING>"instanceof" {
896 0 : return T_INSTANCEOF;
897 : }
898 :
899 : <ST_IN_SCRIPTING>"as" {
900 42 : return T_AS;
901 : }
902 :
903 : <ST_IN_SCRIPTING>"switch" {
904 10 : return T_SWITCH;
905 : }
906 :
907 : <ST_IN_SCRIPTING>"endswitch" {
908 0 : return T_ENDSWITCH;
909 : }
910 :
911 : <ST_IN_SCRIPTING>"case" {
912 65 : return T_CASE;
913 : }
914 :
915 : <ST_IN_SCRIPTING>"default" {
916 1 : return T_DEFAULT;
917 : }
918 :
919 : <ST_IN_SCRIPTING>"break" {
920 62 : return T_BREAK;
921 : }
922 :
923 : <ST_IN_SCRIPTING>"continue" {
924 4 : return T_CONTINUE;
925 : }
926 :
927 : <ST_IN_SCRIPTING>"echo" {
928 227 : return T_ECHO;
929 : }
930 :
931 : <ST_IN_SCRIPTING>"print" {
932 9 : return T_PRINT;
933 : }
934 :
935 : <ST_IN_SCRIPTING>"class" {
936 5 : return T_CLASS;
937 : }
938 :
939 : <ST_IN_SCRIPTING>"interface" {
940 0 : return T_INTERFACE;
941 : }
942 :
943 : <ST_IN_SCRIPTING>"extends" {
944 5 : return T_EXTENDS;
945 : }
946 :
947 : <ST_IN_SCRIPTING>"implements" {
948 0 : return T_IMPLEMENTS;
949 : }
950 :
951 : <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"->" {
952 278 : yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
953 278 : return T_OBJECT_OPERATOR;
954 : }
955 :
956 : <ST_LOOKING_FOR_PROPERTY>{LABEL} {
957 277 : yy_pop_state(TSRMLS_C);
958 277 : zend_copy_value(zendlval, yytext, yyleng);
959 277 : zendlval->type = IS_STRING;
960 277 : return T_STRING;
961 : }
962 :
963 : <ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} {
964 1 : yyless(0);
965 1 : yy_pop_state(TSRMLS_C);
966 : }
967 1 :
968 : <ST_IN_SCRIPTING>"::" {
969 62 : return T_PAAMAYIM_NEKUDOTAYIM;
970 : }
971 :
972 : <ST_IN_SCRIPTING>"new" {
973 58 : return T_NEW;
974 : }
975 :
976 : <ST_IN_SCRIPTING>"clone" {
977 1 : return T_CLONE;
978 : }
979 :
980 : <ST_IN_SCRIPTING>"var" {
981 0 : return T_VAR;
982 : }
983 :
984 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" {
985 0 : return T_INT_CAST;
986 : }
987 :
988 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("real"|"double"|"float"){TABS_AND_SPACES}")" {
989 216 : return T_DOUBLE_CAST;
990 : }
991 :
992 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"string"{TABS_AND_SPACES}")" {
993 0 : return T_STRING_CAST;
994 : }
995 :
996 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"binary"{TABS_AND_SPACES}")" {
997 0 : return T_STRING_CAST;
998 : }
999 :
1000 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" {
1001 1 : return T_ARRAY_CAST;
1002 : }
1003 :
1004 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"object"{TABS_AND_SPACES}")" {
1005 2 : return T_OBJECT_CAST;
1006 : }
1007 :
1008 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("bool"|"boolean"){TABS_AND_SPACES}")" {
1009 0 : return T_BOOL_CAST;
1010 : }
1011 :
1012 : <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("unset"){TABS_AND_SPACES}")" {
1013 0 : return T_UNSET_CAST;
1014 : }
1015 :
1016 : <ST_IN_SCRIPTING>"eval" {
1017 1 : return T_EVAL;
1018 : }
1019 :
1020 : <ST_IN_SCRIPTING>"include" {
1021 116 : return T_INCLUDE;
1022 : }
1023 :
1024 : <ST_IN_SCRIPTING>"include_once" {
1025 0 : return T_INCLUDE_ONCE;
1026 : }
1027 :
1028 : <ST_IN_SCRIPTING>"require" {
1029 0 : return T_REQUIRE;
1030 : }
1031 :
1032 : <ST_IN_SCRIPTING>"require_once" {
1033 0 : return T_REQUIRE_ONCE;
1034 : }
1035 :
1036 : <ST_IN_SCRIPTING>"use" {
1037 0 : return T_USE;
1038 : }
1039 :
1040 : <ST_IN_SCRIPTING>"global" {
1041 19 : return T_GLOBAL;
1042 : }
1043 :
1044 : <ST_IN_SCRIPTING>"isset" {
1045 28 : return T_ISSET;
1046 : }
1047 :
1048 : <ST_IN_SCRIPTING>"empty" {
1049 18 : return T_EMPTY;
1050 : }
1051 :
1052 : <ST_IN_SCRIPTING>"__halt_compiler" {
1053 0 : return T_HALT_COMPILER;
1054 : }
1055 :
1056 : <ST_IN_SCRIPTING>"static" {
1057 1 : return T_STATIC;
1058 : }
1059 :
1060 : <ST_IN_SCRIPTING>"abstract" {
1061 0 : return T_ABSTRACT;
1062 : }
1063 :
1064 : <ST_IN_SCRIPTING>"final" {
1065 4 : return T_FINAL;
1066 : }
1067 :
1068 : <ST_IN_SCRIPTING>"private" {
1069 3 : return T_PRIVATE;
1070 : }
1071 :
1072 : <ST_IN_SCRIPTING>"protected" {
1073 2 : return T_PROTECTED;
1074 : }
1075 :
1076 : <ST_IN_SCRIPTING>"public" {
1077 4 : return T_PUBLIC;
1078 : }
1079 :
1080 : <ST_IN_SCRIPTING>"unset" {
1081 2 : return T_UNSET;
1082 : }
1083 :
1084 : <ST_IN_SCRIPTING>"=>" {
1085 140 : return T_DOUBLE_ARROW;
1086 : }
1087 :
1088 : <ST_IN_SCRIPTING>"list" {
1089 2 : return T_LIST;
1090 : }
1091 :
1092 : <ST_IN_SCRIPTING>"array" {
1093 109 : return T_ARRAY;
1094 : }
1095 :
1096 : <ST_IN_SCRIPTING>"++" {
1097 34 : return T_INC;
1098 : }
1099 :
1100 : <ST_IN_SCRIPTING>"--" {
1101 6 : return T_DEC;
1102 : }
1103 :
1104 : <ST_IN_SCRIPTING>"===" {
1105 17 : return T_IS_IDENTICAL;
1106 : }
1107 :
1108 : <ST_IN_SCRIPTING>"!==" {
1109 15 : return T_IS_NOT_IDENTICAL;
1110 : }
1111 :
1112 : <ST_IN_SCRIPTING>"==" {
1113 51 : return T_IS_EQUAL;
1114 : }
1115 :
1116 : <ST_IN_SCRIPTING>"!="|"<>" {
1117 12 : return T_IS_NOT_EQUAL;
1118 : }
1119 :
1120 : <ST_IN_SCRIPTING>"<=" {
1121 1 : return T_IS_SMALLER_OR_EQUAL;
1122 : }
1123 :
1124 : <ST_IN_SCRIPTING>">=" {
1125 0 : return T_IS_GREATER_OR_EQUAL;
1126 : }
1127 :
1128 : <ST_IN_SCRIPTING>"+=" {
1129 5 : return T_PLUS_EQUAL;
1130 : }
1131 :
1132 : <ST_IN_SCRIPTING>"-=" {
1133 0 : return T_MINUS_EQUAL;
1134 : }
1135 :
1136 : <ST_IN_SCRIPTING>"*=" {
1137 0 : return T_MUL_EQUAL;
1138 : }
1139 :
1140 : <ST_IN_SCRIPTING>"/=" {
1141 0 : return T_DIV_EQUAL;
1142 : }
1143 :
1144 : <ST_IN_SCRIPTING>".=" {
1145 52 : return T_CONCAT_EQUAL;
1146 : }
1147 :
1148 : <ST_IN_SCRIPTING>"%=" {
1149 0 : return T_MOD_EQUAL;
1150 : }
1151 :
1152 : <ST_IN_SCRIPTING>"<<=" {
1153 0 : return T_SL_EQUAL;
1154 : }
1155 :
1156 : <ST_IN_SCRIPTING>">>=" {
1157 0 : return T_SR_EQUAL;
1158 : }
1159 :
1160 : <ST_IN_SCRIPTING>"&=" {
1161 0 : return T_AND_EQUAL;
1162 : }
1163 :
1164 : <ST_IN_SCRIPTING>"|=" {
1165 0 : return T_OR_EQUAL;
1166 : }
1167 :
1168 : <ST_IN_SCRIPTING>"^=" {
1169 0 : return T_XOR_EQUAL;
1170 : }
1171 :
1172 : <ST_IN_SCRIPTING>"||" {
1173 25 : return T_BOOLEAN_OR;
1174 : }
1175 :
1176 : <ST_IN_SCRIPTING>"&&" {
1177 37 : return T_BOOLEAN_AND;
1178 : }
1179 :
1180 : <ST_IN_SCRIPTING>"OR" {
1181 117 : return T_LOGICAL_OR;
1182 : }
1183 :
1184 : <ST_IN_SCRIPTING>"AND" {
1185 10 : return T_LOGICAL_AND;
1186 : }
1187 :
1188 : <ST_IN_SCRIPTING>"XOR" {
1189 0 : return T_LOGICAL_XOR;
1190 : }
1191 :
1192 : <ST_IN_SCRIPTING>"<<" {
1193 0 : return T_SL;
1194 : }
1195 :
1196 : <ST_IN_SCRIPTING>">>" {
1197 0 : return T_SR;
1198 : }
1199 :
1200 : <ST_IN_SCRIPTING>{TOKENS} {
1201 20005 : return yytext[0];
1202 : }
1203 :
1204 :
1205 1369 : <ST_IN_SCRIPTING>"{" {
1206 1369 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
1207 1369 : return '{';
1208 : }
1209 :
1210 :
1211 0 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" {
1212 0 : yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
1213 0 : return T_DOLLAR_OPEN_CURLY_BRACES;
1214 : }
1215 :
1216 :
1217 1386 : <ST_IN_SCRIPTING>"}" {
1218 1386 : RESET_DOC_COMMENT();
1219 : /* This is a temporary fix which is dependant on flex and it's implementation */
1220 1386 : if (yy_start_stack_ptr) {
1221 1386 : yy_pop_state(TSRMLS_C);
1222 : }
1223 1386 : return '}';
1224 : }
1225 :
1226 :
1227 0 : <ST_LOOKING_FOR_VARNAME>{LABEL} {
1228 0 : zend_copy_value(zendlval, yytext, yyleng);
1229 0 : zendlval->type = IS_STRING;
1230 0 : yy_pop_state(TSRMLS_C);
1231 0 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
1232 0 : return T_STRING_VARNAME;
1233 : }
1234 :
1235 :
1236 0 : <ST_LOOKING_FOR_VARNAME>{ANY_CHAR} {
1237 0 : yyless(0);
1238 0 : yy_pop_state(TSRMLS_C);
1239 0 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
1240 : }
1241 0 :
1242 :
1243 945 : <ST_IN_SCRIPTING>{LNUM} {
1244 945 : if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
1245 944 : zendlval->value.lval = strtol(yytext, NULL, 0);
1246 : } else {
1247 1 : errno = 0;
1248 1 : zendlval->value.lval = strtol(yytext, NULL, 0);
1249 1 : if (errno == ERANGE) { /* Overflow */
1250 0 : zendlval->value.dval = zend_strtod(yytext, NULL);
1251 0 : zendlval->type = IS_DOUBLE;
1252 0 : return T_DNUMBER;
1253 : }
1254 : }
1255 :
1256 945 : zendlval->type = IS_LONG;
1257 945 : return T_LNUMBER;
1258 : }
1259 :
1260 : <ST_IN_SCRIPTING>{HNUM} {
1261 0 : char *hex = yytext + 2; /* Skip "0x" */
1262 0 : int len = yyleng - 2;
1263 :
1264 : /* Skip any leading 0s */
1265 0 : while (*hex == '0') {
1266 0 : hex++;
1267 0 : len--;
1268 : }
1269 :
1270 0 : if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
1271 0 : zendlval->value.lval = strtol(hex, NULL, 16);
1272 0 : zendlval->type = IS_LONG;
1273 0 : return T_LNUMBER;
1274 : } else {
1275 0 : zendlval->value.dval = zend_hex_strtod(hex, NULL);
1276 0 : zendlval->type = IS_DOUBLE;
1277 0 : return T_DNUMBER;
1278 : }
1279 : }
1280 :
1281 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{LNUM}|{HNUM} { /* treat numbers (almost) as strings inside encapsulated strings */
1282 25 : zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
1283 25 : zendlval->value.str.len = yyleng;
1284 25 : zendlval->type = IS_STRING;
1285 25 : return T_NUM_STRING;
1286 : }
1287 :
1288 : <ST_IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} {
1289 34 : zendlval->value.dval = zend_strtod(yytext, NULL);
1290 34 : zendlval->type = IS_DOUBLE;
1291 34 : return T_DNUMBER;
1292 : }
1293 :
1294 : <ST_IN_SCRIPTING>"__CLASS__" {
1295 0 : char *class_name = NULL;
1296 :
1297 0 : if (CG(active_class_entry)) {
1298 0 : class_name = CG(active_class_entry)->name;
1299 : }
1300 :
1301 0 : if (!class_name) {
1302 0 : class_name = "";
1303 : }
1304 0 : zendlval->value.str.len = strlen(class_name);
1305 0 : zendlval->value.str.val = estrndup(class_name, zendlval->value.str.len);
1306 0 : zendlval->type = IS_STRING;
1307 0 : return T_CLASS_C;
1308 : }
1309 :
1310 : <ST_IN_SCRIPTING>"__FUNCTION__" {
1311 0 : char *func_name = NULL;
1312 :
1313 0 : if (CG(active_op_array)) {
1314 0 : func_name = CG(active_op_array)->function_name;
1315 : }
1316 :
1317 0 : if (!func_name) {
1318 0 : func_name = "";
1319 : }
1320 0 : zendlval->value.str.len = strlen(func_name);
1321 0 : zendlval->value.str.val = estrndup(func_name, zendlval->value.str.len);
1322 0 : zendlval->type = IS_STRING;
1323 0 : return T_FUNC_C;
1324 : }
1325 :
1326 : <ST_IN_SCRIPTING>"__METHOD__" {
1327 0 : char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;
1328 0 : char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;
1329 0 : size_t len = 0;
1330 :
1331 0 : if (class_name) {
1332 0 : len += strlen(class_name) + 2;
1333 : }
1334 0 : if (func_name) {
1335 0 : len += strlen(func_name);
1336 : }
1337 :
1338 0 : zendlval->value.str.len = zend_spprintf(&zendlval->value.str.val, 0, "%s%s%s",
1339 : class_name ? class_name : "",
1340 : class_name && func_name ? "::" : "",
1341 : func_name ? func_name : ""
1342 : );
1343 0 : zendlval->type = IS_STRING;
1344 0 : return T_METHOD_C;
1345 : }
1346 :
1347 : <ST_IN_SCRIPTING>"__LINE__" {
1348 0 : zendlval->value.lval = CG(zend_lineno);
1349 0 : zendlval->type = IS_LONG;
1350 0 : return T_LINE;
1351 : }
1352 :
1353 : <ST_IN_SCRIPTING>"__FILE__" {
1354 16 : char *filename = zend_get_compiled_filename(TSRMLS_C);
1355 :
1356 16 : if (!filename) {
1357 0 : filename = "";
1358 : }
1359 16 : zendlval->value.str.len = strlen(filename);
1360 16 : zendlval->value.str.val = estrndup(filename, zendlval->value.str.len);
1361 16 : zendlval->type = IS_STRING;
1362 16 : return T_FILE;
1363 : }
1364 :
1365 : <INITIAL>(([^<]|"<"[^?%s<]){1,400})|"<s"|"<" {
1366 1 : #ifdef ZEND_MULTIBYTE
1367 : if (SCNG(output_filter)) {
1368 : int readsize;
1369 : readsize = SCNG(output_filter)(&(zendlval->value.str.val), &(zendlval->value.str.len), yytext, yyleng TSRMLS_CC);
1370 : if (readsize < yyleng) {
1371 : yyless(readsize);
1372 : }
1373 : } else {
1374 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1375 : zendlval->value.str.len = yyleng;
1376 : }
1377 : #else /* !ZEND_MULTIBYTE */
1378 1 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1379 1 : zendlval->value.str.len = yyleng;
1380 : #endif /* ZEND_MULTIBYTE */
1381 1 : zendlval->type = IS_STRING;
1382 1 : HANDLE_NEWLINES(yytext, yyleng);
1383 1 : return T_INLINE_HTML;
1384 : }
1385 :
1386 : <INITIAL>"<?"|"<script"{WHITESPACE}+"language"{WHITESPACE}*"="{WHITESPACE}*("php"|"\"php\""|"\'php\'"){WHITESPACE}*">" {
1387 0 : HANDLE_NEWLINES(yytext, yyleng);
1388 0 : if (CG(short_tags) || yyleng>2) { /* yyleng>2 means it's not <? but <script> */
1389 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1390 0 : zendlval->value.str.len = yyleng;
1391 0 : zendlval->type = IS_STRING;
1392 0 : BEGIN(ST_IN_SCRIPTING);
1393 0 : return T_OPEN_TAG;
1394 : } else {
1395 0 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1396 0 : zendlval->value.str.len = yyleng;
1397 0 : zendlval->type = IS_STRING;
1398 0 : return T_INLINE_HTML;
1399 : }
1400 : }
1401 :
1402 :
1403 0 : <INITIAL>"<%="|"<?=" {
1404 0 : if ((yytext[1]=='%' && CG(asp_tags)) || (yytext[1]=='?' && CG(short_tags))) {
1405 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1406 0 : zendlval->value.str.len = yyleng;
1407 0 : zendlval->type = IS_STRING;
1408 0 : BEGIN(ST_IN_SCRIPTING);
1409 0 : return T_OPEN_TAG_WITH_ECHO;
1410 : } else {
1411 0 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1412 0 : zendlval->value.str.len = yyleng;
1413 0 : zendlval->type = IS_STRING;
1414 0 : return T_INLINE_HTML;
1415 : }
1416 : }
1417 :
1418 :
1419 0 : <INITIAL>"<%" {
1420 0 : if (CG(asp_tags)) {
1421 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1422 0 : zendlval->value.str.len = yyleng;
1423 0 : zendlval->type = IS_STRING;
1424 0 : BEGIN(ST_IN_SCRIPTING);
1425 0 : return T_OPEN_TAG;
1426 : } else {
1427 0 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1428 0 : zendlval->value.str.len = yyleng;
1429 0 : zendlval->type = IS_STRING;
1430 0 : return T_INLINE_HTML;
1431 : }
1432 : }
1433 :
1434 :
1435 335 : <INITIAL>"<?php"([ \t]|{NEWLINE}) {
1436 335 : zendlval->value.str.val = yytext; /* no copying - intentional */
1437 335 : zendlval->value.str.len = yyleng;
1438 335 : zendlval->type = IS_STRING;
1439 335 : HANDLE_NEWLINE(yytext[yyleng-1]);
1440 335 : BEGIN(ST_IN_SCRIPTING);
1441 335 : return T_OPEN_TAG;
1442 : }
1443 :
1444 : <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL} {
1445 4709 : zend_copy_value(zendlval, (yytext+1), (yyleng-1));
1446 4709 : zendlval->type = IS_STRING;
1447 4709 : return T_VARIABLE;
1448 : }
1449 :
1450 : <ST_IN_SCRIPTING>{LABEL} {
1451 5545 : zend_copy_value(zendlval, yytext, yyleng);
1452 5545 : zendlval->type = IS_STRING;
1453 5545 : return T_STRING;
1454 : }
1455 :
1456 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{LABEL} {
1457 1313 : zend_copy_value(zendlval, yytext, yyleng);
1458 1313 : zendlval->type = IS_STRING;
1459 1313 : return T_STRING;
1460 : }
1461 :
1462 :
1463 14733 : <ST_IN_SCRIPTING>{WHITESPACE} {
1464 14733 : zendlval->value.str.val = yytext; /* no copying - intentional */
1465 14733 : zendlval->value.str.len = yyleng;
1466 14733 : zendlval->type = IS_STRING;
1467 14733 : HANDLE_NEWLINES(yytext, yyleng);
1468 14733 : return T_WHITESPACE;
1469 : }
1470 :
1471 :
1472 74 : <ST_IN_SCRIPTING>"#"|"//" {
1473 74 : BEGIN(ST_ONE_LINE_COMMENT);
1474 74 : yymore();
1475 : }
1476 74 :
1477 : <ST_ONE_LINE_COMMENT>"?"|"%"|">" {
1478 4 : yymore();
1479 : }
1480 4 :
1481 : <ST_ONE_LINE_COMMENT>[^\n\r?%>]*{ANY_CHAR} {
1482 78 : switch (yytext[yyleng-1]) {
1483 : case '?': case '%': case '>':
1484 4 : yyless(yyleng-1);
1485 4 : yymore();
1486 : break;
1487 : case '\n':
1488 74 : CG(zend_lineno)++;
1489 : /* intentional fall through */
1490 : default:
1491 74 : zendlval->value.str.val = yytext; /* no copying - intentional */
1492 74 : zendlval->value.str.len = yyleng;
1493 74 : zendlval->type = IS_STRING;
1494 74 : BEGIN(ST_IN_SCRIPTING);
1495 74 : return T_COMMENT;
1496 : }
1497 : }
1498 4 :
1499 : <ST_ONE_LINE_COMMENT>{NEWLINE} {
1500 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1501 0 : zendlval->value.str.len = yyleng;
1502 0 : zendlval->type = IS_STRING;
1503 0 : BEGIN(ST_IN_SCRIPTING);
1504 0 : CG(zend_lineno)++;
1505 0 : return T_COMMENT;
1506 : }
1507 :
1508 : <ST_ONE_LINE_COMMENT>"?>"|"%>" {
1509 0 : if (CG(asp_tags) || yytext[yyleng-2] != '%') { /* asp comment? */
1510 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1511 0 : zendlval->value.str.len = yyleng-2;
1512 0 : zendlval->type = IS_STRING;
1513 0 : yyless(yyleng-2);
1514 0 : BEGIN(ST_IN_SCRIPTING);
1515 0 : return T_COMMENT;
1516 : } else {
1517 0 : yymore();
1518 : }
1519 : }
1520 0 :
1521 : <ST_IN_SCRIPTING>"/**"{WHITESPACE} {
1522 0 : CG(comment_start_line) = CG(zend_lineno);
1523 0 : RESET_DOC_COMMENT();
1524 0 : BEGIN(ST_DOC_COMMENT);
1525 0 : yymore();
1526 : }
1527 0 :
1528 : <ST_IN_SCRIPTING>"/*" {
1529 19 : CG(comment_start_line) = CG(zend_lineno);
1530 19 : BEGIN(ST_COMMENT);
1531 19 : yymore();
1532 : }
1533 19 :
1534 :
1535 30 : <ST_COMMENT,ST_DOC_COMMENT>[^*]+ {
1536 30 : yymore();
1537 : }
1538 30 :
1539 : <ST_DOC_COMMENT>"*/" {
1540 0 : CG(doc_comment) = estrndup(yytext, yyleng);
1541 0 : CG(doc_comment_len) = yyleng;
1542 0 : HANDLE_NEWLINES(yytext, yyleng);
1543 0 : BEGIN(ST_IN_SCRIPTING);
1544 0 : return T_DOC_COMMENT;
1545 : }
1546 :
1547 : <ST_COMMENT>"*/" {
1548 19 : HANDLE_NEWLINES(yytext, yyleng);
1549 19 : BEGIN(ST_IN_SCRIPTING);
1550 19 : return T_COMMENT;
1551 : }
1552 :
1553 : <ST_COMMENT,ST_DOC_COMMENT>"*" {
1554 11 : yymore();
1555 : }
1556 11 :
1557 : <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
1558 327 : zendlval->value.str.val = yytext; /* no copying - intentional */
1559 327 : zendlval->value.str.len = yyleng;
1560 327 : zendlval->type = IS_STRING;
1561 327 : BEGIN(INITIAL);
1562 327 : return T_CLOSE_TAG; /* implicit ';' at php-end tag */
1563 : }
1564 :
1565 :
1566 0 : <ST_IN_SCRIPTING>"%>"{NEWLINE}? {
1567 0 : if (CG(asp_tags)) {
1568 0 : BEGIN(INITIAL);
1569 0 : zendlval->value.str.len = yyleng;
1570 0 : zendlval->type = IS_STRING;
1571 0 : zendlval->value.str.val = yytext; /* no copying - intentional */
1572 0 : return T_CLOSE_TAG; /* implicit ';' at php-end tag */
1573 : } else {
1574 0 : yyless(1);
1575 0 : return yytext[0];
1576 : }
1577 : }
1578 :
1579 :
1580 831 : <ST_IN_SCRIPTING>("b"?["]([^$"\\]|("\\".))*["]) {
1581 : register char *s, *t;
1582 : char *end;
1583 831 : int bprefix = (*yytext == 'b') ? 1 : 0;
1584 :
1585 831 : zendlval->value.str.val = estrndup(yytext+bprefix+1, yyleng-bprefix-2);
1586 831 : zendlval->value.str.len = yyleng-bprefix-2;
1587 831 : zendlval->type = IS_STRING;
1588 831 : HANDLE_NEWLINES(yytext, yyleng);
1589 :
1590 : /* convert escape sequences */
1591 831 : s = t = zendlval->value.str.val;
1592 831 : end = s+zendlval->value.str.len;
1593 14162 : while (s<end) {
1594 12500 : if (*s=='\\') {
1595 453 : s++;
1596 453 : if (s>=end) {
1597 0 : continue;
1598 : }
1599 453 : switch(*s) {
1600 : case 'n':
1601 373 : *t++ = '\n';
1602 373 : zendlval->value.str.len--;
1603 373 : break;
1604 : case 'r':
1605 67 : *t++ = '\r';
1606 67 : zendlval->value.str.len--;
1607 67 : break;
1608 : case 't':
1609 3 : *t++ = '\t';
1610 3 : zendlval->value.str.len--;
1611 3 : break;
1612 : case '\\':
1613 : case '$':
1614 : case '"':
1615 2 : *t++ = *s;
1616 2 : zendlval->value.str.len--;
1617 2 : break;
1618 : default:
1619 : /* check for an octal */
1620 11 : if (ZEND_IS_OCT(*s)) {
1621 3 : char octal_buf[4] = { 0, 0, 0, 0 };
1622 :
1623 3 : octal_buf[0] = *s;
1624 3 : zendlval->value.str.len--;
1625 3 : if ((s+1)<end && ZEND_IS_OCT(*(s+1))) {
1626 1 : octal_buf[1] = *(++s);
1627 1 : zendlval->value.str.len--;
1628 1 : if ((s+1)<end && ZEND_IS_OCT(*(s+1))) {
1629 0 : octal_buf[2] = *(++s);
1630 0 : zendlval->value.str.len--;
1631 : }
1632 : }
1633 3 : *t++ = (char) strtol(octal_buf, NULL, 8);
1634 5 : } else if (*s=='x' && (s+1)<end && ZEND_IS_HEX(*(s+1))) {
1635 0 : char hex_buf[3] = { 0, 0, 0};
1636 :
1637 0 : zendlval->value.str.len--; /* for the 'x' */
1638 :
1639 0 : hex_buf[0] = *(++s);
1640 0 : zendlval->value.str.len--;
1641 0 : if ((s+1)<end && ZEND_IS_HEX(*(s+1))) {
1642 0 : hex_buf[1] = *(++s);
1643 0 : zendlval->value.str.len--;
1644 : }
1645 0 : *t++ = (char) strtol(hex_buf, NULL, 16);
1646 : } else {
1647 5 : *t++ = '\\';
1648 5 : *t++ = *s;
1649 : }
1650 : break;
1651 : }
1652 453 : s++;
1653 : } else {
1654 12047 : *t++ = *s++;
1655 : }
1656 : }
1657 831 : *t = 0;
1658 :
1659 : #ifdef ZEND_MULTIBYTE
1660 : if (SCNG(output_filter)) {
1661 : s = zendlval->value.str.val;
1662 : SCNG(output_filter)(&(zendlval->value.str.val), &(zendlval->value.str.len), s, zendlval->value.str.len TSRMLS_CC);
1663 : efree(s);
1664 : }
1665 : #endif /* ZEND_MULTIBYTE */
1666 :
1667 831 : return T_CONSTANT_ENCAPSED_STRING;
1668 : }
1669 :
1670 :
1671 1917 : <ST_IN_SCRIPTING>("b"?[']([^'\\]|("\\".))*[']) {
1672 : register char *s, *t;
1673 : char *end;
1674 1917 : int bprefix = (*yytext == 'b') ? 1 : 0;
1675 :
1676 1917 : zendlval->value.str.val = estrndup(yytext+bprefix+1, yyleng-bprefix-2);
1677 1917 : zendlval->value.str.len = yyleng-bprefix-2;
1678 1917 : zendlval->type = IS_STRING;
1679 1917 : HANDLE_NEWLINES(yytext, yyleng);
1680 :
1681 : /* convert escape sequences */
1682 1917 : s = t = zendlval->value.str.val;
1683 1917 : end = s+zendlval->value.str.len;
1684 18311 : while (s<end) {
1685 14477 : if (*s=='\\') {
1686 23 : s++;
1687 23 : if (s>=end) {
1688 0 : continue;
1689 : }
1690 23 : switch(*s) {
1691 : case '\\':
1692 : case '\'':
1693 3 : *t++ = *s;
1694 3 : zendlval->value.str.len--;
1695 3 : break;
1696 : default:
1697 20 : *t++ = '\\';
1698 20 : *t++ = *s;
1699 : break;
1700 : }
1701 23 : s++;
1702 : } else {
1703 14454 : *t++ = *s++;
1704 : }
1705 : }
1706 1917 : *t = 0;
1707 :
1708 : #ifdef ZEND_MULTIBYTE
1709 : if (SCNG(output_filter)) {
1710 : s = zendlval->value.str.val;
1711 : SCNG(output_filter)(&(zendlval->value.str.val), &(zendlval->value.str.len), s, zendlval->value.str.len TSRMLS_CC);
1712 : efree(s);
1713 : }
1714 : #endif /* ZEND_MULTIBYTE */
1715 :
1716 1917 : return T_CONSTANT_ENCAPSED_STRING;
1717 : }
1718 :
1719 :
1720 518 : <ST_IN_SCRIPTING>b?["] {
1721 518 : BEGIN(ST_DOUBLE_QUOTES);
1722 518 : return '\"';
1723 : }
1724 :
1725 :
1726 5 : <ST_IN_SCRIPTING>"b"?"<<<"{TABS_AND_SPACES}{LABEL}{NEWLINE} {
1727 : char *s;
1728 5 : int bprefix = (*yytext == 'b') ? 1 : 0;
1729 :
1730 5 : CG(zend_lineno)++;
1731 5 : CG(heredoc_len) = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
1732 5 : s = yytext+bprefix+3;
1733 11 : while ((*s == ' ') || (*s == '\t')) {
1734 1 : s++;
1735 1 : CG(heredoc_len)--;
1736 : }
1737 5 : CG(heredoc) = estrndup(s, CG(heredoc_len));
1738 5 : BEGIN(ST_HEREDOC);
1739 5 : return T_START_HEREDOC;
1740 : }
1741 :
1742 :
1743 3 : <ST_IN_SCRIPTING>[`] {
1744 3 : BEGIN(ST_BACKQUOTE);
1745 3 : return '`';
1746 : }
1747 :
1748 :
1749 0 : <ST_IN_SCRIPTING>b?['] {
1750 0 : BEGIN(ST_SINGLE_QUOTE);
1751 0 : return '\'';
1752 : }
1753 :
1754 :
1755 5 : <ST_HEREDOC>^{LABEL}(";")?{NEWLINE} {
1756 : int label_len;
1757 :
1758 5 : if (yytext[yyleng-2]=='\r') {
1759 0 : label_len = yyleng-2;
1760 : } else {
1761 5 : label_len = yyleng-1;
1762 : }
1763 :
1764 5 : if (yytext[label_len-1]==';') {
1765 5 : label_len--;
1766 : }
1767 :
1768 5 : if (label_len==CG(heredoc_len) && !memcmp(yytext, CG(heredoc), label_len)) {
1769 5 : zendlval->value.str.val = estrndup(yytext, label_len); /* unput destroys yytext */
1770 5 : zendlval->value.str.len = label_len;
1771 5 : yyless(yyleng - (yyleng - label_len));
1772 5 : efree(CG(heredoc));
1773 5 : CG(heredoc)=NULL;
1774 5 : CG(heredoc_len)=0;
1775 5 : BEGIN(ST_IN_SCRIPTING);
1776 5 : return T_END_HEREDOC;
1777 : } else {
1778 0 : CG(zend_lineno)++;
1779 0 : zend_copy_value(zendlval, yytext, yyleng);
1780 0 : zendlval->type = IS_STRING;
1781 0 : return T_STRING;
1782 : }
1783 : }
1784 :
1785 :
1786 1446 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{ESCAPED_AND_WHITESPACE} {
1787 1446 : HANDLE_NEWLINES(yytext, yyleng);
1788 1446 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1789 1446 : zendlval->value.str.len = yyleng;
1790 1446 : zendlval->type = IS_STRING;
1791 1446 : return T_ENCAPSED_AND_WHITESPACE;
1792 : }
1793 :
1794 : <ST_SINGLE_QUOTE>([^'\\]|\\[^'\\])+ {
1795 0 : HANDLE_NEWLINES(yytext, yyleng);
1796 0 : zend_copy_value(zendlval, yytext, yyleng);
1797 0 : zendlval->type = IS_STRING;
1798 0 : return T_ENCAPSED_AND_WHITESPACE;
1799 : }
1800 :
1801 :
1802 0 : <ST_DOUBLE_QUOTES>[`]+ {
1803 0 : zend_copy_value(zendlval, yytext, yyleng);
1804 0 : zendlval->type = IS_STRING;
1805 0 : return T_ENCAPSED_AND_WHITESPACE;
1806 : }
1807 :
1808 :
1809 6 : <ST_BACKQUOTE>["]+ {
1810 6 : zend_copy_value(zendlval, yytext, yyleng);
1811 6 : zendlval->type = IS_STRING;
1812 6 : return T_ENCAPSED_AND_WHITESPACE;
1813 : }
1814 :
1815 :
1816 2 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"$"[^a-zA-Z_\x7f-\xff{] {
1817 2 : zendlval->value.lval = (long) yytext[0];
1818 2 : if (yyleng == 2) {
1819 2 : yyless(1);
1820 : }
1821 2 : return T_CHARACTER;
1822 : }
1823 :
1824 :
1825 56 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{ENCAPSED_TOKENS} {
1826 56 : zendlval->value.lval = (long) yytext[0];
1827 56 : return yytext[0];
1828 : }
1829 :
1830 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\{" {
1831 0 : zendlval->value.str.val = estrndup("\\{", sizeof("\\{") - 1);
1832 0 : zendlval->value.str.len = sizeof("\\{") - 1;
1833 0 : zendlval->type = IS_STRING;
1834 0 : return T_STRING;
1835 : }
1836 :
1837 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
1838 17 : zendlval->value.lval = (long) yytext[0];
1839 17 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
1840 17 : yyless(1);
1841 17 : return T_CURLY_OPEN;
1842 : }
1843 :
1844 :
1845 0 : <ST_SINGLE_QUOTE>"\\'" {
1846 0 : zendlval->value.lval = (long) '\'';
1847 0 : return T_CHARACTER;
1848 : }
1849 :
1850 : <ST_SINGLE_QUOTE>"\\\\" {
1851 0 : zendlval->value.lval = (long)'\\';
1852 0 : return T_CHARACTER;
1853 : }
1854 :
1855 : <ST_DOUBLE_QUOTES>"\\\"" {
1856 10 : zendlval->value.lval = (long) '"';
1857 10 : return T_CHARACTER;
1858 : }
1859 :
1860 : <ST_BACKQUOTE>"\\`" {
1861 0 : zendlval->value.lval = (long) '`';
1862 0 : return T_CHARACTER;
1863 : }
1864 :
1865 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\"[0-7]{1,3} {
1866 0 : zendlval->value.lval = strtol(yytext+1, NULL, 8);
1867 0 : return T_CHARACTER;
1868 : }
1869 :
1870 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\x"[0-9A-Fa-f]{1,2} {
1871 0 : zendlval->value.lval = strtol (yytext+2, NULL, 16);
1872 0 : return T_CHARACTER;
1873 : }
1874 :
1875 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\"{ANY_CHAR} {
1876 38 : switch (yytext[1]) {
1877 : case 'n':
1878 32 : zendlval->value.lval = (long) '\n';
1879 32 : break;
1880 : case 't':
1881 1 : zendlval->value.lval = (long) '\t';
1882 1 : break;
1883 : case 'r':
1884 3 : zendlval->value.lval = (long) '\r';
1885 3 : break;
1886 : case '\\':
1887 0 : zendlval->value.lval = (long) '\\';
1888 0 : break;
1889 : case '$':
1890 1 : zendlval->value.lval = (long) yytext[1];
1891 1 : break;
1892 : default:
1893 1 : zendlval->value.str.val = estrndup(yytext, yyleng);
1894 1 : zendlval->value.str.len = yyleng;
1895 1 : zendlval->type = IS_STRING;
1896 1 : return T_BAD_CHARACTER;
1897 : break;
1898 : }
1899 37 : return T_CHARACTER;
1900 : }
1901 :
1902 :
1903 4 : <ST_HEREDOC>["'`]+ {
1904 4 : zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
1905 4 : zendlval->value.str.len = yyleng;
1906 4 : zendlval->type = IS_STRING;
1907 4 : return T_ENCAPSED_AND_WHITESPACE;
1908 : }
1909 :
1910 :
1911 518 : <ST_DOUBLE_QUOTES>["] {
1912 518 : BEGIN(ST_IN_SCRIPTING);
1913 518 : return '\"';
1914 : }
1915 :
1916 :
1917 3 : <ST_BACKQUOTE>[`] {
1918 3 : BEGIN(ST_IN_SCRIPTING);
1919 3 : return '`';
1920 : }
1921 :
1922 :
1923 0 : <ST_SINGLE_QUOTE>['] {
1924 0 : BEGIN(ST_IN_SCRIPTING);
1925 0 : return '\'';
1926 : }
1927 :
1928 :
1929 : <ST_DOUBLE_QUOTES,ST_BACKQUOTE,INITIAL,ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY><<EOF>> {
1930 335 : return 0;
1931 : }
1932 :
1933 : <ST_COMMENT,ST_DOC_COMMENT><<EOF>> {
1934 0 : zend_error(E_COMPILE_WARNING,"Unterminated comment starting line %d", CG(comment_start_line));
1935 0 : return 0;
1936 : }
1937 :
1938 :
1939 0 :
1940 : <ST_IN_SCRIPTING,INITIAL,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_SINGLE_QUOTE,ST_HEREDOC>{ANY_CHAR} {
1941 0 : zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
1942 : }
|
