1 /* Generated by re2c 0.13.5 */
2 /*
3 +----------------------------------------------------------------------+
4 | Zend Engine |
5 +----------------------------------------------------------------------+
6 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
7 +----------------------------------------------------------------------+
8 | This source file is subject to version 2.00 of the Zend license, |
9 | that is bundled with this package in the file LICENSE, and is |
10 | available through the world-wide-web at the following url: |
11 | http://www.zend.com/license/2_00.txt. |
12 | If you did not receive a copy of the Zend license and are unable to |
13 | obtain it through the world-wide-web, please send a note to |
14 | license@zend.com so we can mail you a copy immediately. |
15 +----------------------------------------------------------------------+
16 | Authors: Marcus Boerger <helly@php.net> |
17 | Nuno Lopes <nlopess@php.net> |
18 | Scott MacVicar <scottmac@php.net> |
19 | Flex version authors: |
20 | Andi Gutmans <andi@php.net> |
21 | Zeev Suraski <zeev@php.net> |
22 +----------------------------------------------------------------------+
23 */
24
25 #if 0
26 # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
27 #else
28 # define YYDEBUG(s, c)
29 #endif
30
31 #include "zend_language_scanner_defs.h"
32
33 #include <errno.h>
34 #include "zend.h"
35 #ifdef ZEND_WIN32
36 # include <Winuser.h>
37 #endif
38 #include "zend_alloc.h"
39 #include <zend_language_parser.h>
40 #include "zend_compile.h"
41 #include "zend_language_scanner.h"
42 #include "zend_highlight.h"
43 #include "zend_constants.h"
44 #include "zend_variables.h"
45 #include "zend_operators.h"
46 #include "zend_API.h"
47 #include "zend_strtod.h"
48 #include "zend_exceptions.h"
49 #include "zend_virtual_cwd.h"
50
51 #define YYCTYPE unsigned char
52 #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
53 #define YYCURSOR SCNG(yy_cursor)
54 #define YYLIMIT SCNG(yy_limit)
55 #define YYMARKER SCNG(yy_marker)
56
57 #define YYGETCONDITION() SCNG(yy_state)
58 #define YYSETCONDITION(s) SCNG(yy_state) = s
59
60 #define STATE(name) yyc##name
61
62 /* emulate flex constructs */
63 #define BEGIN(state) YYSETCONDITION(STATE(state))
64 #define YYSTATE YYGETCONDITION()
65 #define yytext ((char*)SCNG(yy_text))
66 #define yyleng SCNG(yy_leng)
67 #define yyless(x) do { YYCURSOR = (unsigned char*)yytext + x; \
68 yyleng = (unsigned int)x; } while(0)
69 #define yymore() goto yymore_restart
70
71 /* perform sanity check. If this message is triggered you should
72 increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
73 #define YYMAXFILL 16
74 #if ZEND_MMAP_AHEAD < YYMAXFILL
75 # error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
76 #endif
77
78 #include <stdarg.h>
79
80 #ifdef HAVE_UNISTD_H
81 # include <unistd.h>
82 #endif
83
84 /* Globals Macros */
85 #define SCNG LANG_SCNG
86 #ifdef ZTS
87 ZEND_API ts_rsrc_id language_scanner_globals_id;
88 ZEND_API size_t language_scanner_globals_offset;
89 #else
90 ZEND_API zend_php_scanner_globals language_scanner_globals;
91 #endif
92
93 #define HANDLE_NEWLINES(s, l) \
94 do { \
95 char *p = (s), *boundary = p+(l); \
96 \
97 while (p<boundary) { \
98 if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) { \
99 CG(zend_lineno)++; \
100 } \
101 p++; \
102 } \
103 } while (0)
104
105 #define HANDLE_NEWLINE(c) \
106 { \
107 if (c == '\n' || c == '\r') { \
108 CG(zend_lineno)++; \
109 } \
110 }
111
112 /* To save initial string length after scanning to first variable */
113 #define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(scanned_string_len) = (len)
114 #define GET_DOUBLE_QUOTES_SCANNED_LENGTH() SCNG(scanned_string_len)
115
116 #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x80)
117 #define IS_LABEL_SUCCESSOR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || ((c) >= '0' && (c) <= '9') || (c) == '_' || (c) >= 0x80)
118
119 #define ZEND_IS_OCT(c) ((c)>='0' && (c)<='7')
120 #define ZEND_IS_HEX(c) (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
121
BEGIN_EXTERN_C()122 BEGIN_EXTERN_C()
123
124 static void strip_underscores(char *str, size_t *len)
125 {
126 char *src = str, *dest = str;
127 while (*src != '\0') {
128 if (*src != '_') {
129 *dest = *src;
130 dest++;
131 } else {
132 --(*len);
133 }
134 src++;
135 }
136 *dest = '\0';
137 }
138
encoding_filter_script_to_internal(unsigned char ** to,size_t * to_length,const unsigned char * from,size_t from_length)139 static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
140 {
141 const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
142 ZEND_ASSERT(internal_encoding);
143 return zend_multibyte_encoding_converter(to, to_length, from, from_length, internal_encoding, LANG_SCNG(script_encoding));
144 }
145
encoding_filter_script_to_intermediate(unsigned char ** to,size_t * to_length,const unsigned char * from,size_t from_length)146 static size_t encoding_filter_script_to_intermediate(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
147 {
148 return zend_multibyte_encoding_converter(to, to_length, from, from_length, zend_multibyte_encoding_utf8, LANG_SCNG(script_encoding));
149 }
150
encoding_filter_intermediate_to_script(unsigned char ** to,size_t * to_length,const unsigned char * from,size_t from_length)151 static size_t encoding_filter_intermediate_to_script(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
152 {
153 return zend_multibyte_encoding_converter(to, to_length, from, from_length,
154 LANG_SCNG(script_encoding), zend_multibyte_encoding_utf8);
155 }
156
encoding_filter_intermediate_to_internal(unsigned char ** to,size_t * to_length,const unsigned char * from,size_t from_length)157 static size_t encoding_filter_intermediate_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)
158 {
159 const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
160 ZEND_ASSERT(internal_encoding);
161 return zend_multibyte_encoding_converter(to, to_length, from, from_length,
162 internal_encoding, zend_multibyte_encoding_utf8);
163 }
164
165
_yy_push_state(int new_state)166 static void _yy_push_state(int new_state)
167 {
168 zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION());
169 YYSETCONDITION(new_state);
170 }
171
172 #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
173
yy_pop_state(void)174 static void yy_pop_state(void)
175 {
176 int *stack_state = zend_stack_top(&SCNG(state_stack));
177 YYSETCONDITION(*stack_state);
178 zend_stack_del_top(&SCNG(state_stack));
179 }
180
yy_scan_buffer(char * str,size_t len)181 static void yy_scan_buffer(char *str, size_t len)
182 {
183 YYCURSOR = (YYCTYPE*)str;
184 YYLIMIT = YYCURSOR + len;
185 if (!SCNG(yy_start)) {
186 SCNG(yy_start) = YYCURSOR;
187 }
188 }
189
startup_scanner(void)190 void startup_scanner(void)
191 {
192 CG(parse_error) = 0;
193 CG(doc_comment) = NULL;
194 CG(extra_fn_flags) = 0;
195 zend_stack_init(&SCNG(state_stack), sizeof(int));
196 zend_ptr_stack_init(&SCNG(heredoc_label_stack));
197 SCNG(heredoc_scan_ahead) = 0;
198 }
199
heredoc_label_dtor(zend_heredoc_label * heredoc_label)200 static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {
201 efree(heredoc_label->label);
202 }
203
shutdown_scanner(void)204 void shutdown_scanner(void)
205 {
206 CG(parse_error) = 0;
207 RESET_DOC_COMMENT();
208 zend_stack_destroy(&SCNG(state_stack));
209 zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
210 zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
211 SCNG(heredoc_scan_ahead) = 0;
212 SCNG(on_event) = NULL;
213 }
214
zend_save_lexical_state(zend_lex_state * lex_state)215 ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state)
216 {
217 lex_state->yy_leng = SCNG(yy_leng);
218 lex_state->yy_start = SCNG(yy_start);
219 lex_state->yy_text = SCNG(yy_text);
220 lex_state->yy_cursor = SCNG(yy_cursor);
221 lex_state->yy_marker = SCNG(yy_marker);
222 lex_state->yy_limit = SCNG(yy_limit);
223
224 lex_state->state_stack = SCNG(state_stack);
225 zend_stack_init(&SCNG(state_stack), sizeof(int));
226
227 lex_state->heredoc_label_stack = SCNG(heredoc_label_stack);
228 zend_ptr_stack_init(&SCNG(heredoc_label_stack));
229
230 lex_state->in = SCNG(yy_in);
231 lex_state->yy_state = YYSTATE;
232 lex_state->filename = zend_get_compiled_filename();
233 lex_state->lineno = CG(zend_lineno);
234
235 lex_state->script_org = SCNG(script_org);
236 lex_state->script_org_size = SCNG(script_org_size);
237 lex_state->script_filtered = SCNG(script_filtered);
238 lex_state->script_filtered_size = SCNG(script_filtered_size);
239 lex_state->input_filter = SCNG(input_filter);
240 lex_state->output_filter = SCNG(output_filter);
241 lex_state->script_encoding = SCNG(script_encoding);
242
243 lex_state->on_event = SCNG(on_event);
244 lex_state->on_event_context = SCNG(on_event_context);
245
246 lex_state->ast = CG(ast);
247 lex_state->ast_arena = CG(ast_arena);
248 }
249
zend_restore_lexical_state(zend_lex_state * lex_state)250 ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state)
251 {
252 SCNG(yy_leng) = lex_state->yy_leng;
253 SCNG(yy_start) = lex_state->yy_start;
254 SCNG(yy_text) = lex_state->yy_text;
255 SCNG(yy_cursor) = lex_state->yy_cursor;
256 SCNG(yy_marker) = lex_state->yy_marker;
257 SCNG(yy_limit) = lex_state->yy_limit;
258
259 zend_stack_destroy(&SCNG(state_stack));
260 SCNG(state_stack) = lex_state->state_stack;
261
262 zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
263 zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
264 SCNG(heredoc_label_stack) = lex_state->heredoc_label_stack;
265
266 SCNG(yy_in) = lex_state->in;
267 YYSETCONDITION(lex_state->yy_state);
268 CG(zend_lineno) = lex_state->lineno;
269 zend_restore_compiled_filename(lex_state->filename);
270
271 if (SCNG(script_filtered)) {
272 efree(SCNG(script_filtered));
273 SCNG(script_filtered) = NULL;
274 }
275 SCNG(script_org) = lex_state->script_org;
276 SCNG(script_org_size) = lex_state->script_org_size;
277 SCNG(script_filtered) = lex_state->script_filtered;
278 SCNG(script_filtered_size) = lex_state->script_filtered_size;
279 SCNG(input_filter) = lex_state->input_filter;
280 SCNG(output_filter) = lex_state->output_filter;
281 SCNG(script_encoding) = lex_state->script_encoding;
282
283 SCNG(on_event) = lex_state->on_event;
284 SCNG(on_event_context) = lex_state->on_event_context;
285
286 CG(ast) = lex_state->ast;
287 CG(ast_arena) = lex_state->ast_arena;
288
289 RESET_DOC_COMMENT();
290 }
291
zend_destroy_file_handle(zend_file_handle * file_handle)292 ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle)
293 {
294 zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
295 /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
296 file_handle->opened_path = NULL;
297 if (file_handle->free_filename) {
298 file_handle->filename = NULL;
299 }
300 }
301
zend_lex_tstring(zval * zv)302 ZEND_API void zend_lex_tstring(zval *zv)
303 {
304 if (SCNG(on_event)) {
305 SCNG(on_event)(ON_FEEDBACK, T_STRING, 0, SCNG(on_event_context));
306 }
307
308 ZVAL_STRINGL(zv, (char*)SCNG(yy_text), SCNG(yy_leng));
309 }
310
311 #define BOM_UTF32_BE "\x00\x00\xfe\xff"
312 #define BOM_UTF32_LE "\xff\xfe\x00\x00"
313 #define BOM_UTF16_BE "\xfe\xff"
314 #define BOM_UTF16_LE "\xff\xfe"
315 #define BOM_UTF8 "\xef\xbb\xbf"
316
zend_multibyte_detect_utf_encoding(const unsigned char * script,size_t script_size)317 static const zend_encoding *zend_multibyte_detect_utf_encoding(const unsigned char *script, size_t script_size)
318 {
319 const unsigned char *p;
320 int wchar_size = 2;
321 int le = 0;
322
323 /* utf-16 or utf-32? */
324 p = script;
325 assert(p >= script);
326 while ((size_t)(p-script) < script_size) {
327 p = memchr(p, 0, script_size-(p-script)-2);
328 if (!p) {
329 break;
330 }
331 if (*(p+1) == '\0' && *(p+2) == '\0') {
332 wchar_size = 4;
333 break;
334 }
335
336 /* searching for UTF-32 specific byte orders, so this will do */
337 p += 4;
338 }
339
340 /* BE or LE? */
341 p = script;
342 assert(p >= script);
343 while ((size_t)(p-script) < script_size) {
344 if (*p == '\0' && *(p+wchar_size-1) != '\0') {
345 /* BE */
346 le = 0;
347 break;
348 } else if (*p != '\0' && *(p+wchar_size-1) == '\0') {
349 /* LE* */
350 le = 1;
351 break;
352 }
353 p += wchar_size;
354 }
355
356 if (wchar_size == 2) {
357 return le ? zend_multibyte_encoding_utf16le : zend_multibyte_encoding_utf16be;
358 } else {
359 return le ? zend_multibyte_encoding_utf32le : zend_multibyte_encoding_utf32be;
360 }
361
362 return NULL;
363 }
364
zend_multibyte_detect_unicode(void)365 static const zend_encoding* zend_multibyte_detect_unicode(void)
366 {
367 const zend_encoding *script_encoding = NULL;
368 int bom_size;
369 unsigned char *pos1, *pos2;
370
371 if (LANG_SCNG(script_org_size) < sizeof(BOM_UTF32_LE)-1) {
372 return NULL;
373 }
374
375 /* check out BOM */
376 if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_BE, sizeof(BOM_UTF32_BE)-1)) {
377 script_encoding = zend_multibyte_encoding_utf32be;
378 bom_size = sizeof(BOM_UTF32_BE)-1;
379 } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_LE, sizeof(BOM_UTF32_LE)-1)) {
380 script_encoding = zend_multibyte_encoding_utf32le;
381 bom_size = sizeof(BOM_UTF32_LE)-1;
382 } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_BE, sizeof(BOM_UTF16_BE)-1)) {
383 script_encoding = zend_multibyte_encoding_utf16be;
384 bom_size = sizeof(BOM_UTF16_BE)-1;
385 } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_LE, sizeof(BOM_UTF16_LE)-1)) {
386 script_encoding = zend_multibyte_encoding_utf16le;
387 bom_size = sizeof(BOM_UTF16_LE)-1;
388 } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF8, sizeof(BOM_UTF8)-1)) {
389 script_encoding = zend_multibyte_encoding_utf8;
390 bom_size = sizeof(BOM_UTF8)-1;
391 }
392
393 if (script_encoding) {
394 /* remove BOM */
395 LANG_SCNG(script_org) += bom_size;
396 LANG_SCNG(script_org_size) -= bom_size;
397
398 return script_encoding;
399 }
400
401 /* script contains NULL bytes -> auto-detection */
402 if ((pos1 = memchr(LANG_SCNG(script_org), 0, LANG_SCNG(script_org_size)))) {
403 /* check if the NULL byte is after the __HALT_COMPILER(); */
404 pos2 = LANG_SCNG(script_org);
405
406 while ((size_t)(pos1 - pos2) >= sizeof("__HALT_COMPILER();")-1) {
407 pos2 = memchr(pos2, '_', pos1 - pos2);
408 if (!pos2) break;
409 pos2++;
410 if (strncasecmp((char*)pos2, "_HALT_COMPILER", sizeof("_HALT_COMPILER")-1) == 0) {
411 pos2 += sizeof("_HALT_COMPILER")-1;
412 while (*pos2 == ' ' ||
413 *pos2 == '\t' ||
414 *pos2 == '\r' ||
415 *pos2 == '\n') {
416 pos2++;
417 }
418 if (*pos2 == '(') {
419 pos2++;
420 while (*pos2 == ' ' ||
421 *pos2 == '\t' ||
422 *pos2 == '\r' ||
423 *pos2 == '\n') {
424 pos2++;
425 }
426 if (*pos2 == ')') {
427 pos2++;
428 while (*pos2 == ' ' ||
429 *pos2 == '\t' ||
430 *pos2 == '\r' ||
431 *pos2 == '\n') {
432 pos2++;
433 }
434 if (*pos2 == ';') {
435 return NULL;
436 }
437 }
438 }
439 }
440 }
441 /* make best effort if BOM is missing */
442 return zend_multibyte_detect_utf_encoding(LANG_SCNG(script_org), LANG_SCNG(script_org_size));
443 }
444
445 return NULL;
446 }
447
zend_multibyte_find_script_encoding(void)448 static const zend_encoding* zend_multibyte_find_script_encoding(void)
449 {
450 const zend_encoding *script_encoding;
451
452 if (CG(detect_unicode)) {
453 /* check out bom(byte order mark) and see if containing wchars */
454 script_encoding = zend_multibyte_detect_unicode();
455 if (script_encoding != NULL) {
456 /* bom or wchar detection is prior to 'script_encoding' option */
457 return script_encoding;
458 }
459 }
460
461 /* if no script_encoding specified, just leave alone */
462 if (!CG(script_encoding_list) || !CG(script_encoding_list_size)) {
463 return NULL;
464 }
465
466 /* if multiple encodings specified, detect automagically */
467 if (CG(script_encoding_list_size) > 1) {
468 return zend_multibyte_encoding_detector(LANG_SCNG(script_org), LANG_SCNG(script_org_size), CG(script_encoding_list), CG(script_encoding_list_size));
469 }
470
471 return CG(script_encoding_list)[0];
472 }
473
zend_multibyte_set_filter(const zend_encoding * onetime_encoding)474 ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding)
475 {
476 const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();
477 const zend_encoding *script_encoding = onetime_encoding ? onetime_encoding: zend_multibyte_find_script_encoding();
478
479 if (!script_encoding) {
480 return FAILURE;
481 }
482
483 /* judge input/output filter */
484 LANG_SCNG(script_encoding) = script_encoding;
485 LANG_SCNG(input_filter) = NULL;
486 LANG_SCNG(output_filter) = NULL;
487
488 if (!internal_encoding || LANG_SCNG(script_encoding) == internal_encoding) {
489 if (!zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
490 /* and if not, work around w/ script_encoding -> utf-8 -> script_encoding conversion */
491 LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
492 LANG_SCNG(output_filter) = encoding_filter_intermediate_to_script;
493 } else {
494 LANG_SCNG(input_filter) = NULL;
495 LANG_SCNG(output_filter) = NULL;
496 }
497 return SUCCESS;
498 }
499
500 if (zend_multibyte_check_lexer_compatibility(internal_encoding)) {
501 LANG_SCNG(input_filter) = encoding_filter_script_to_internal;
502 LANG_SCNG(output_filter) = NULL;
503 } else if (zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
504 LANG_SCNG(input_filter) = NULL;
505 LANG_SCNG(output_filter) = encoding_filter_script_to_internal;
506 } else {
507 /* both script and internal encodings are incompatible w/ flex */
508 LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
509 LANG_SCNG(output_filter) = encoding_filter_intermediate_to_internal;
510 }
511
512 return 0;
513 }
514
open_file_for_scanning(zend_file_handle * file_handle)515 ZEND_API int open_file_for_scanning(zend_file_handle *file_handle)
516 {
517 char *buf;
518 size_t size;
519 zend_string *compiled_filename;
520
521 if (zend_stream_fixup(file_handle, &buf, &size) == FAILURE) {
522 /* Still add it to open_files to make destroy_file_handle work */
523 zend_llist_add_element(&CG(open_files), file_handle);
524 return FAILURE;
525 }
526
527 ZEND_ASSERT(!EG(exception) && "stream_fixup() should have failed");
528 zend_llist_add_element(&CG(open_files), file_handle);
529 if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
530 zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
531 size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
532 fh->handle.stream.handle = (void*)(((char*)fh) + diff);
533 file_handle->handle.stream.handle = fh->handle.stream.handle;
534 }
535
536 /* Reset the scanner for scanning the new file */
537 SCNG(yy_in) = file_handle;
538 SCNG(yy_start) = NULL;
539
540 if (size != (size_t)-1) {
541 if (CG(multibyte)) {
542 SCNG(script_org) = (unsigned char*)buf;
543 SCNG(script_org_size) = size;
544 SCNG(script_filtered) = NULL;
545
546 zend_multibyte_set_filter(NULL);
547
548 if (SCNG(input_filter)) {
549 if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {
550 zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
551 "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
552 }
553 buf = (char*)SCNG(script_filtered);
554 size = SCNG(script_filtered_size);
555 }
556 }
557 SCNG(yy_start) = (unsigned char *)buf;
558 yy_scan_buffer(buf, size);
559 } else {
560 zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
561 }
562
563 if (CG(skip_shebang)) {
564 CG(skip_shebang) = 0;
565 BEGIN(SHEBANG);
566 } else {
567 BEGIN(INITIAL);
568 }
569
570 if (file_handle->opened_path) {
571 compiled_filename = zend_string_copy(file_handle->opened_path);
572 } else {
573 compiled_filename = zend_string_init(file_handle->filename, strlen(file_handle->filename), 0);
574 }
575
576 zend_set_compiled_filename(compiled_filename);
577 zend_string_release_ex(compiled_filename, 0);
578
579 RESET_DOC_COMMENT();
580 CG(zend_lineno) = 1;
581 CG(increment_lineno) = 0;
582 return SUCCESS;
583 }
END_EXTERN_C()584 END_EXTERN_C()
585
586 static zend_op_array *zend_compile(int type)
587 {
588 zend_op_array *op_array = NULL;
589 zend_bool original_in_compilation = CG(in_compilation);
590
591 CG(in_compilation) = 1;
592 CG(ast) = NULL;
593 CG(ast_arena) = zend_arena_create(1024 * 32);
594
595 if (!zendparse()) {
596 int last_lineno = CG(zend_lineno);
597 zend_file_context original_file_context;
598 zend_oparray_context original_oparray_context;
599 zend_op_array *original_active_op_array = CG(active_op_array);
600
601 op_array = emalloc(sizeof(zend_op_array));
602 init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);
603 CG(active_op_array) = op_array;
604
605 /* Use heap to not waste arena memory */
606 op_array->fn_flags |= ZEND_ACC_HEAP_RT_CACHE;
607
608 if (zend_ast_process) {
609 zend_ast_process(CG(ast));
610 }
611
612 zend_file_context_begin(&original_file_context);
613 zend_oparray_context_begin(&original_oparray_context);
614 zend_compile_top_stmt(CG(ast));
615 CG(zend_lineno) = last_lineno;
616 zend_emit_final_return(type == ZEND_USER_FUNCTION);
617 op_array->line_start = 1;
618 op_array->line_end = last_lineno;
619 pass_two(op_array);
620 zend_oparray_context_end(&original_oparray_context);
621 zend_file_context_end(&original_file_context);
622
623 CG(active_op_array) = original_active_op_array;
624 }
625
626 zend_ast_destroy(CG(ast));
627 zend_arena_destroy(CG(ast_arena));
628
629 CG(in_compilation) = original_in_compilation;
630
631 return op_array;
632 }
633
compile_file(zend_file_handle * file_handle,int type)634 ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)
635 {
636 zend_lex_state original_lex_state;
637 zend_op_array *op_array = NULL;
638 zend_save_lexical_state(&original_lex_state);
639
640 if (open_file_for_scanning(file_handle)==FAILURE) {
641 if (!EG(exception)) {
642 if (type==ZEND_REQUIRE) {
643 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
644 zend_bailout();
645 } else {
646 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename);
647 }
648 }
649 } else {
650 op_array = zend_compile(ZEND_USER_FUNCTION);
651 }
652
653 zend_restore_lexical_state(&original_lex_state);
654 return op_array;
655 }
656
657
compile_filename(int type,zval * filename)658 zend_op_array *compile_filename(int type, zval *filename)
659 {
660 zend_file_handle file_handle;
661 zval tmp;
662 zend_op_array *retval;
663 zend_string *opened_path = NULL;
664
665 if (Z_TYPE_P(filename) != IS_STRING) {
666 ZVAL_STR(&tmp, zval_get_string(filename));
667 filename = &tmp;
668 }
669 zend_stream_init_filename(&file_handle, Z_STRVAL_P(filename));
670
671 retval = zend_compile_file(&file_handle, type);
672 if (retval && file_handle.handle.stream.handle) {
673 if (!file_handle.opened_path) {
674 file_handle.opened_path = opened_path = zend_string_copy(Z_STR_P(filename));
675 }
676
677 zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);
678
679 if (opened_path) {
680 zend_string_release_ex(opened_path, 0);
681 }
682 }
683 zend_destroy_file_handle(&file_handle);
684
685 if (UNEXPECTED(filename == &tmp)) {
686 zval_ptr_dtor(&tmp);
687 }
688 return retval;
689 }
690
zend_prepare_string_for_scanning(zval * str,char * filename)691 ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename)
692 {
693 char *buf;
694 size_t size, old_len;
695 zend_string *new_compiled_filename;
696
697 /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
698 old_len = Z_STRLEN_P(str);
699 Z_STR_P(str) = zend_string_extend(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
700 Z_TYPE_INFO_P(str) = IS_STRING_EX;
701 memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
702
703 SCNG(yy_in) = NULL;
704 SCNG(yy_start) = NULL;
705
706 buf = Z_STRVAL_P(str);
707 size = old_len;
708
709 if (CG(multibyte)) {
710 SCNG(script_org) = (unsigned char*)buf;
711 SCNG(script_org_size) = size;
712 SCNG(script_filtered) = NULL;
713
714 zend_multibyte_set_filter(zend_multibyte_get_internal_encoding());
715
716 if (SCNG(input_filter)) {
717 if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {
718 zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
719 "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
720 }
721 buf = (char*)SCNG(script_filtered);
722 size = SCNG(script_filtered_size);
723 }
724 }
725
726 yy_scan_buffer(buf, size);
727
728 new_compiled_filename = zend_string_init(filename, strlen(filename), 0);
729 zend_set_compiled_filename(new_compiled_filename);
730 zend_string_release_ex(new_compiled_filename, 0);
731 CG(zend_lineno) = 1;
732 CG(increment_lineno) = 0;
733 RESET_DOC_COMMENT();
734 return SUCCESS;
735 }
736
737
zend_get_scanned_file_offset(void)738 ZEND_API size_t zend_get_scanned_file_offset(void)
739 {
740 size_t offset = SCNG(yy_cursor) - SCNG(yy_start);
741 if (SCNG(input_filter)) {
742 size_t original_offset = offset, length = 0;
743 do {
744 unsigned char *p = NULL;
745 if ((size_t)-1 == SCNG(input_filter)(&p, &length, SCNG(script_org), offset)) {
746 return (size_t)-1;
747 }
748 efree(p);
749 if (length > original_offset) {
750 offset--;
751 } else if (length < original_offset) {
752 offset++;
753 }
754 } while (original_offset != length);
755 }
756 return offset;
757 }
758
compile_string(zval * source_string,char * filename)759 zend_op_array *compile_string(zval *source_string, char *filename)
760 {
761 zend_lex_state original_lex_state;
762 zend_op_array *op_array = NULL;
763 zval tmp;
764
765 if (UNEXPECTED(Z_TYPE_P(source_string) != IS_STRING)) {
766 ZVAL_STR(&tmp, zval_get_string_func(source_string));
767 } else {
768 ZVAL_COPY(&tmp, source_string);
769 }
770
771 if (Z_STRLEN(tmp)==0) {
772 zval_ptr_dtor(&tmp);
773 return NULL;
774 }
775
776 zend_save_lexical_state(&original_lex_state);
777 if (zend_prepare_string_for_scanning(&tmp, filename) == SUCCESS) {
778 BEGIN(ST_IN_SCRIPTING);
779 op_array = zend_compile(ZEND_EVAL_CODE);
780 }
781
782 zend_restore_lexical_state(&original_lex_state);
783 zval_ptr_dtor(&tmp);
784
785 return op_array;
786 }
787
788
BEGIN_EXTERN_C()789 BEGIN_EXTERN_C()
790 int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini)
791 {
792 zend_lex_state original_lex_state;
793 zend_file_handle file_handle;
794
795 zend_stream_init_filename(&file_handle, filename);
796 zend_save_lexical_state(&original_lex_state);
797 if (open_file_for_scanning(&file_handle)==FAILURE) {
798 zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
799 zend_restore_lexical_state(&original_lex_state);
800 return FAILURE;
801 }
802 zend_highlight(syntax_highlighter_ini);
803 if (SCNG(script_filtered)) {
804 efree(SCNG(script_filtered));
805 SCNG(script_filtered) = NULL;
806 }
807 zend_destroy_file_handle(&file_handle);
808 zend_restore_lexical_state(&original_lex_state);
809 return SUCCESS;
810 }
811
highlight_string(zval * str,zend_syntax_highlighter_ini * syntax_highlighter_ini,char * str_name)812 int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name)
813 {
814 zend_lex_state original_lex_state;
815 zval tmp;
816
817 if (UNEXPECTED(Z_TYPE_P(str) != IS_STRING)) {
818 ZVAL_STR(&tmp, zval_get_string_func(str));
819 str = &tmp;
820 }
821 zend_save_lexical_state(&original_lex_state);
822 if (zend_prepare_string_for_scanning(str, str_name)==FAILURE) {
823 zend_restore_lexical_state(&original_lex_state);
824 if (UNEXPECTED(str == &tmp)) {
825 zval_ptr_dtor(&tmp);
826 }
827 return FAILURE;
828 }
829 BEGIN(INITIAL);
830 zend_highlight(syntax_highlighter_ini);
831 if (SCNG(script_filtered)) {
832 efree(SCNG(script_filtered));
833 SCNG(script_filtered) = NULL;
834 }
835 zend_restore_lexical_state(&original_lex_state);
836 if (UNEXPECTED(str == &tmp)) {
837 zval_ptr_dtor(&tmp);
838 }
839 return SUCCESS;
840 }
841
zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter,const zend_encoding * old_encoding)842 ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding)
843 {
844 size_t length;
845 unsigned char *new_yy_start;
846
847 /* convert and set */
848 if (!SCNG(input_filter)) {
849 if (SCNG(script_filtered)) {
850 efree(SCNG(script_filtered));
851 SCNG(script_filtered) = NULL;
852 }
853 SCNG(script_filtered_size) = 0;
854 length = SCNG(script_org_size);
855 new_yy_start = SCNG(script_org);
856 } else {
857 if ((size_t)-1 == SCNG(input_filter)(&new_yy_start, &length, SCNG(script_org), SCNG(script_org_size))) {
858 zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
859 "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
860 }
861 if (SCNG(script_filtered)) {
862 efree(SCNG(script_filtered));
863 }
864 SCNG(script_filtered) = new_yy_start;
865 SCNG(script_filtered_size) = length;
866 }
867
868 SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));
869 SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));
870 SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));
871 SCNG(yy_limit) = new_yy_start + length;
872
873 SCNG(yy_start) = new_yy_start;
874 }
875
876
877 // TODO: avoid reallocation ???
878 # define zend_copy_value(zendlval, yytext, yyleng) \
879 if (SCNG(output_filter)) { \
880 size_t sz = 0; \
881 char *s = NULL; \
882 SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng); \
883 ZVAL_STRINGL(zendlval, s, sz); \
884 efree(s); \
885 } else if (yyleng == 1) { \
886 ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR((zend_uchar)*(yytext))); \
887 } else { \
888 ZVAL_STRINGL(zendlval, yytext, yyleng); \
889 }
890
zend_scan_escape_string(zval * zendlval,char * str,int len,char quote_type)891 static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type)
892 {
893 register char *s, *t;
894 char *end;
895
896 if (len <= 1) {
897 if (len < 1) {
898 ZVAL_EMPTY_STRING(zendlval);
899 } else {
900 zend_uchar c = (zend_uchar)*str;
901 if (c == '\n' || c == '\r') {
902 CG(zend_lineno)++;
903 }
904 ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR(c));
905 }
906 goto skip_escape_conversion;
907 }
908
909 ZVAL_STRINGL(zendlval, str, len);
910
911 /* convert escape sequences */
912 s = Z_STRVAL_P(zendlval);
913 end = s+Z_STRLEN_P(zendlval);
914 while (1) {
915 if (UNEXPECTED(*s=='\\')) {
916 break;
917 }
918 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
919 CG(zend_lineno)++;
920 }
921 s++;
922 if (s == end) {
923 goto skip_escape_conversion;
924 }
925 }
926
927 t = s;
928 while (s<end) {
929 if (*s=='\\') {
930 s++;
931 if (s >= end) {
932 *t++ = '\\';
933 break;
934 }
935
936 switch(*s) {
937 case 'n':
938 *t++ = '\n';
939 break;
940 case 'r':
941 *t++ = '\r';
942 break;
943 case 't':
944 *t++ = '\t';
945 break;
946 case 'f':
947 *t++ = '\f';
948 break;
949 case 'v':
950 *t++ = '\v';
951 break;
952 case 'e':
953 #ifdef ZEND_WIN32
954 *t++ = VK_ESCAPE;
955 #else
956 *t++ = '\e';
957 #endif
958 break;
959 case '"':
960 case '`':
961 if (*s != quote_type) {
962 *t++ = '\\';
963 *t++ = *s;
964 break;
965 }
966 case '\\':
967 case '$':
968 *t++ = *s;
969 break;
970 case 'x':
971 case 'X':
972 if (ZEND_IS_HEX(*(s+1))) {
973 char hex_buf[3] = { 0, 0, 0 };
974
975 hex_buf[0] = *(++s);
976 if (ZEND_IS_HEX(*(s+1))) {
977 hex_buf[1] = *(++s);
978 }
979 *t++ = (char) ZEND_STRTOL(hex_buf, NULL, 16);
980 } else {
981 *t++ = '\\';
982 *t++ = *s;
983 }
984 break;
985 /* UTF-8 codepoint escape, format: /\\u\{\x+\}/ */
986 case 'u':
987 {
988 /* cache where we started so we can parse after validating */
989 char *start = s + 1;
990 size_t len = 0;
991 zend_bool valid = 1;
992 unsigned long codepoint;
993
994 if (*start != '{') {
995 /* we silently let this pass to avoid breaking code
996 * with JSON in string literals (e.g. "\"\u202e\""
997 */
998 *t++ = '\\';
999 *t++ = 'u';
1000 break;
1001 } else {
1002 /* on the other hand, invalid \u{blah} errors */
1003 s++;
1004 len++;
1005 s++;
1006 while (*s != '}') {
1007 if (!ZEND_IS_HEX(*s)) {
1008 valid = 0;
1009 break;
1010 } else {
1011 len++;
1012 }
1013 s++;
1014 }
1015 if (*s == '}') {
1016 valid = 1;
1017 len++;
1018 }
1019 }
1020
1021 /* \u{} is invalid */
1022 if (len <= 2) {
1023 valid = 0;
1024 }
1025
1026 if (!valid) {
1027 zend_throw_exception(zend_ce_parse_error,
1028 "Invalid UTF-8 codepoint escape sequence", 0);
1029 zval_ptr_dtor(zendlval);
1030 ZVAL_UNDEF(zendlval);
1031 return FAILURE;
1032 }
1033
1034 errno = 0;
1035 codepoint = strtoul(start + 1, NULL, 16);
1036
1037 /* per RFC 3629, UTF-8 can only represent 21 bits */
1038 if (codepoint > 0x10FFFF || errno) {
1039 zend_throw_exception(zend_ce_parse_error,
1040 "Invalid UTF-8 codepoint escape sequence: Codepoint too large", 0);
1041 zval_ptr_dtor(zendlval);
1042 ZVAL_UNDEF(zendlval);
1043 return FAILURE;
1044 }
1045
1046 /* based on https://en.wikipedia.org/wiki/UTF-8#Sample_code */
1047 if (codepoint < 0x80) {
1048 *t++ = codepoint;
1049 } else if (codepoint <= 0x7FF) {
1050 *t++ = (codepoint >> 6) + 0xC0;
1051 *t++ = (codepoint & 0x3F) + 0x80;
1052 } else if (codepoint <= 0xFFFF) {
1053 *t++ = (codepoint >> 12) + 0xE0;
1054 *t++ = ((codepoint >> 6) & 0x3F) + 0x80;
1055 *t++ = (codepoint & 0x3F) + 0x80;
1056 } else if (codepoint <= 0x10FFFF) {
1057 *t++ = (codepoint >> 18) + 0xF0;
1058 *t++ = ((codepoint >> 12) & 0x3F) + 0x80;
1059 *t++ = ((codepoint >> 6) & 0x3F) + 0x80;
1060 *t++ = (codepoint & 0x3F) + 0x80;
1061 }
1062 }
1063 break;
1064 default:
1065 /* check for an octal */
1066 if (ZEND_IS_OCT(*s)) {
1067 char octal_buf[4] = { 0, 0, 0, 0 };
1068
1069 octal_buf[0] = *s;
1070 if (ZEND_IS_OCT(*(s+1))) {
1071 octal_buf[1] = *(++s);
1072 if (ZEND_IS_OCT(*(s+1))) {
1073 octal_buf[2] = *(++s);
1074 }
1075 }
1076 if (octal_buf[2] && (octal_buf[0] > '3') && !SCNG(heredoc_scan_ahead)) {
1077 /* 3 octit values must not overflow 0xFF (\377) */
1078 zend_error(E_COMPILE_WARNING, "Octal escape sequence overflow \\%s is greater than \\377", octal_buf);
1079 }
1080
1081 *t++ = (char) ZEND_STRTOL(octal_buf, NULL, 8);
1082 } else {
1083 *t++ = '\\';
1084 *t++ = *s;
1085 }
1086 break;
1087 }
1088 } else {
1089 *t++ = *s;
1090 }
1091
1092 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
1093 CG(zend_lineno)++;
1094 }
1095 s++;
1096 }
1097 *t = 0;
1098 Z_STRLEN_P(zendlval) = t - Z_STRVAL_P(zendlval);
1099
1100 skip_escape_conversion:
1101 if (SCNG(output_filter)) {
1102 size_t sz = 0;
1103 unsigned char *str;
1104 // TODO: avoid realocation ???
1105 s = Z_STRVAL_P(zendlval);
1106 SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval));
1107 zval_ptr_dtor(zendlval);
1108 ZVAL_STRINGL(zendlval, (char *) str, sz);
1109 efree(str);
1110 }
1111 return SUCCESS;
1112 }
1113
1114 #define HEREDOC_USING_SPACES 1
1115 #define HEREDOC_USING_TABS 2
1116
next_newline(const char * str,const char * end,size_t * newline_len)1117 static const char *next_newline(const char *str, const char *end, size_t *newline_len) {
1118 for (; str < end; str++) {
1119 if (*str == '\r') {
1120 *newline_len = str + 1 < end && *(str + 1) == '\n' ? 2 : 1;
1121 return str;
1122 } else if (*str == '\n') {
1123 *newline_len = 1;
1124 return str;
1125 }
1126 }
1127 *newline_len = 0;
1128 return NULL;
1129 }
1130
strip_multiline_string_indentation(zval * zendlval,int indentation,zend_bool using_spaces,zend_bool newline_at_start,zend_bool newline_at_end)1131 static zend_bool strip_multiline_string_indentation(
1132 zval *zendlval, int indentation, zend_bool using_spaces,
1133 zend_bool newline_at_start, zend_bool newline_at_end)
1134 {
1135 const char *str = Z_STRVAL_P(zendlval), *end = str + Z_STRLEN_P(zendlval);
1136 char *copy = Z_STRVAL_P(zendlval);
1137
1138 int newline_count = 0;
1139 size_t newline_len;
1140 const char *nl;
1141
1142 if (!newline_at_start) {
1143 nl = next_newline(str, end, &newline_len);
1144 if (!nl) {
1145 return 1;
1146 }
1147
1148 str = nl + newline_len;
1149 copy = (char *) nl + newline_len;
1150 newline_count++;
1151 } else {
1152 nl = str;
1153 }
1154
1155 /* <= intentional */
1156 while (str <= end && nl) {
1157 size_t skip;
1158 nl = next_newline(str, end, &newline_len);
1159 if (!nl && newline_at_end) {
1160 nl = end;
1161 }
1162
1163 /* Try to skip indentation */
1164 for (skip = 0; skip < indentation; skip++, str++) {
1165 if (str == nl) {
1166 /* Don't require full indentation on whitespace-only lines */
1167 break;
1168 }
1169
1170 if (str == end || (*str != ' ' && *str != '\t')) {
1171 CG(zend_lineno) += newline_count;
1172 zend_throw_exception_ex(zend_ce_parse_error, 0,
1173 "Invalid body indentation level (expecting an indentation level of at least %d)", indentation);
1174 goto error;
1175 }
1176
1177 if ((!using_spaces && *str == ' ') || (using_spaces && *str == '\t')) {
1178 CG(zend_lineno) += newline_count;
1179 zend_throw_exception(zend_ce_parse_error,
1180 "Invalid indentation - tabs and spaces cannot be mixed", 0);
1181 goto error;
1182 }
1183 }
1184
1185 if (str == end) {
1186 break;
1187 }
1188
1189 size_t len = nl ? (nl - str + newline_len) : (end - str);
1190 memmove(copy, str, len);
1191 str += len;
1192 copy += len;
1193 newline_count++;
1194 }
1195
1196 *copy = '\0';
1197 Z_STRLEN_P(zendlval) = copy - Z_STRVAL_P(zendlval);
1198 return 1;
1199
1200 error:
1201 zval_ptr_dtor_str(zendlval);
1202 ZVAL_UNDEF(zendlval);
1203
1204 return 0;
1205 }
1206
copy_heredoc_label_stack(void * void_heredoc_label)1207 static void copy_heredoc_label_stack(void *void_heredoc_label)
1208 {
1209 zend_heredoc_label *heredoc_label = void_heredoc_label;
1210 zend_heredoc_label *new_heredoc_label = emalloc(sizeof(zend_heredoc_label));
1211
1212 *new_heredoc_label = *heredoc_label;
1213 new_heredoc_label->label = estrndup(heredoc_label->label, heredoc_label->length);
1214
1215 zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) new_heredoc_label);
1216 }
1217
1218 #define PARSER_MODE() \
1219 EXPECTED(elem != NULL)
1220
1221 #define RETURN_TOKEN(_token) do { \
1222 token = _token; \
1223 goto emit_token; \
1224 } while (0)
1225
1226 #define RETURN_TOKEN_WITH_VAL(_token) do { \
1227 token = _token; \
1228 goto emit_token_with_val; \
1229 } while (0)
1230
1231 #define RETURN_TOKEN_WITH_STR(_token, _offset) do { \
1232 token = _token; \
1233 offset = _offset; \
1234 goto emit_token_with_str; \
1235 } while (0)
1236
1237 #define RETURN_OR_SKIP_TOKEN(_token) do { \
1238 token = _token; \
1239 if (PARSER_MODE()) { \
1240 goto skip_token; \
1241 } \
1242 goto emit_token; \
1243 } while (0)
1244
lex_scan(zval * zendlval,zend_parser_stack_elem * elem)1245 int ZEND_FASTCALL lex_scan(zval *zendlval, zend_parser_stack_elem *elem)
1246 {
1247 int token;
1248 int offset;
1249 int start_line = CG(zend_lineno);
1250
1251 ZVAL_UNDEF(zendlval);
1252 restart:
1253 SCNG(yy_text) = YYCURSOR;
1254
1255
1256 {
1257 YYCTYPE yych;
1258 unsigned int yyaccept = 0;
1259 if (YYGETCONDITION() < 5) {
1260 if (YYGETCONDITION() < 2) {
1261 if (YYGETCONDITION() < 1) {
1262 goto yyc_ST_IN_SCRIPTING;
1263 } else {
1264 goto yyc_ST_LOOKING_FOR_PROPERTY;
1265 }
1266 } else {
1267 if (YYGETCONDITION() < 3) {
1268 goto yyc_ST_BACKQUOTE;
1269 } else {
1270 if (YYGETCONDITION() < 4) {
1271 goto yyc_ST_DOUBLE_QUOTES;
1272 } else {
1273 goto yyc_ST_HEREDOC;
1274 }
1275 }
1276 }
1277 } else {
1278 if (YYGETCONDITION() < 8) {
1279 if (YYGETCONDITION() < 6) {
1280 goto yyc_ST_LOOKING_FOR_VARNAME;
1281 } else {
1282 if (YYGETCONDITION() < 7) {
1283 goto yyc_ST_VAR_OFFSET;
1284 } else {
1285 goto yyc_SHEBANG;
1286 }
1287 }
1288 } else {
1289 if (YYGETCONDITION() < 9) {
1290 goto yyc_INITIAL;
1291 } else {
1292 if (YYGETCONDITION() < 10) {
1293 goto yyc_ST_END_HEREDOC;
1294 } else {
1295 goto yyc_ST_NOWDOC;
1296 }
1297 }
1298 }
1299 }
1300 /* *********************************** */
1301 yyc_INITIAL:
1302
1303 YYDEBUG(0, *YYCURSOR);
1304 YYFILL(7);
1305 yych = *YYCURSOR;
1306 if (yych != '<') goto yy4;
1307 YYDEBUG(2, *YYCURSOR);
1308 ++YYCURSOR;
1309 if ((yych = *YYCURSOR) == '?') goto yy5;
1310 yy3:
1311 YYDEBUG(3, *YYCURSOR);
1312 yyleng = YYCURSOR - SCNG(yy_text);
1313 {
1314 if (YYCURSOR > YYLIMIT) {
1315 RETURN_TOKEN(END);
1316 }
1317
1318 inline_char_handler:
1319
1320 while (1) {
1321 YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
1322
1323 YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
1324
1325 if (YYCURSOR >= YYLIMIT) {
1326 break;
1327 }
1328
1329 if (*YYCURSOR == '?') {
1330 if (CG(short_tags) /* <? */
1331 || (*(YYCURSOR + 1) == '=') /* <?= */
1332 || (!strncasecmp((char*)YYCURSOR + 1, "php", 3) && /* <?php[ \t\r\n] */
1333 (YYCURSOR + 4 == YYLIMIT ||
1334 YYCURSOR[4] == ' ' || YYCURSOR[4] == '\t' ||
1335 YYCURSOR[4] == '\n' || YYCURSOR[4] == '\r'))
1336 ) {
1337 YYCURSOR--;
1338 break;
1339 }
1340 }
1341 }
1342
1343 yyleng = YYCURSOR - SCNG(yy_text);
1344
1345 if (SCNG(output_filter)) {
1346 size_t readsize;
1347 char *s = NULL;
1348 size_t sz = 0;
1349 // TODO: avoid reallocation ???
1350 readsize = SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng);
1351 ZVAL_STRINGL(zendlval, s, sz);
1352 efree(s);
1353 if (readsize < yyleng) {
1354 yyless(readsize);
1355 }
1356 } else if (yyleng == 1) {
1357 ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR((zend_uchar)*yytext));
1358 } else {
1359 ZVAL_STRINGL(zendlval, yytext, yyleng);
1360 }
1361 HANDLE_NEWLINES(yytext, yyleng);
1362 RETURN_TOKEN_WITH_VAL(T_INLINE_HTML);
1363 }
1364 yy4:
1365 YYDEBUG(4, *YYCURSOR);
1366 yych = *++YYCURSOR;
1367 goto yy3;
1368 yy5:
1369 YYDEBUG(5, *YYCURSOR);
1370 yyaccept = 0;
1371 yych = *(YYMARKER = ++YYCURSOR);
1372 if (yych <= 'O') {
1373 if (yych == '=') goto yy7;
1374 } else {
1375 if (yych <= 'P') goto yy9;
1376 if (yych == 'p') goto yy9;
1377 }
1378 yy6:
1379 YYDEBUG(6, *YYCURSOR);
1380 yyleng = YYCURSOR - SCNG(yy_text);
1381 {
1382 if (CG(short_tags)) {
1383 BEGIN(ST_IN_SCRIPTING);
1384 RETURN_OR_SKIP_TOKEN(T_OPEN_TAG);
1385 } else {
1386 goto inline_char_handler;
1387 }
1388 }
1389 yy7:
1390 YYDEBUG(7, *YYCURSOR);
1391 ++YYCURSOR;
1392 YYDEBUG(8, *YYCURSOR);
1393 yyleng = YYCURSOR - SCNG(yy_text);
1394 {
1395 BEGIN(ST_IN_SCRIPTING);
1396 if (PARSER_MODE()) {
1397 RETURN_TOKEN(T_ECHO);
1398 }
1399 RETURN_TOKEN(T_OPEN_TAG_WITH_ECHO);
1400 }
1401 yy9:
1402 YYDEBUG(9, *YYCURSOR);
1403 yych = *++YYCURSOR;
1404 if (yych == 'H') goto yy11;
1405 if (yych == 'h') goto yy11;
1406 yy10:
1407 YYDEBUG(10, *YYCURSOR);
1408 YYCURSOR = YYMARKER;
1409 goto yy6;
1410 yy11:
1411 YYDEBUG(11, *YYCURSOR);
1412 yych = *++YYCURSOR;
1413 if (yych == 'P') goto yy12;
1414 if (yych != 'p') goto yy10;
1415 yy12:
1416 YYDEBUG(12, *YYCURSOR);
1417 ++YYCURSOR;
1418 if ((yych = *YYCURSOR) <= '\f') {
1419 if (yych <= 0x08) goto yy13;
1420 if (yych <= '\n') goto yy14;
1421 } else {
1422 if (yych <= '\r') goto yy16;
1423 if (yych == ' ') goto yy14;
1424 }
1425 yy13:
1426 YYDEBUG(13, *YYCURSOR);
1427 yyleng = YYCURSOR - SCNG(yy_text);
1428 {
1429 /* Allow <?php followed by end of file. */
1430 if (YYCURSOR == YYLIMIT) {
1431 BEGIN(ST_IN_SCRIPTING);
1432 RETURN_OR_SKIP_TOKEN(T_OPEN_TAG);
1433 }
1434 /* Degenerate case: <?phpX is interpreted as <? phpX with short tags. */
1435 if (CG(short_tags)) {
1436 yyless(2);
1437 BEGIN(ST_IN_SCRIPTING);
1438 RETURN_OR_SKIP_TOKEN(T_OPEN_TAG);
1439 }
1440 goto inline_char_handler;
1441 }
1442 yy14:
1443 YYDEBUG(14, *YYCURSOR);
1444 ++YYCURSOR;
1445 yy15:
1446 YYDEBUG(15, *YYCURSOR);
1447 yyleng = YYCURSOR - SCNG(yy_text);
1448 {
1449 HANDLE_NEWLINE(yytext[yyleng-1]);
1450 BEGIN(ST_IN_SCRIPTING);
1451 RETURN_OR_SKIP_TOKEN(T_OPEN_TAG);
1452 }
1453 yy16:
1454 YYDEBUG(16, *YYCURSOR);
1455 ++YYCURSOR;
1456 if ((yych = *YYCURSOR) == '\n') goto yy14;
1457 goto yy15;
1458 /* *********************************** */
1459 yyc_SHEBANG:
1460 {
1461 static const unsigned char yybm[] = {
1462 64, 64, 64, 64, 64, 64, 64, 64,
1463 64, 64, 0, 64, 64, 128, 64, 64,
1464 64, 64, 64, 64, 64, 64, 64, 64,
1465 64, 64, 64, 64, 64, 64, 64, 64,
1466 64, 64, 64, 64, 64, 64, 64, 64,
1467 64, 64, 64, 64, 64, 64, 64, 64,
1468 64, 64, 64, 64, 64, 64, 64, 64,
1469 64, 64, 64, 64, 64, 64, 64, 64,
1470 64, 64, 64, 64, 64, 64, 64, 64,
1471 64, 64, 64, 64, 64, 64, 64, 64,
1472 64, 64, 64, 64, 64, 64, 64, 64,
1473 64, 64, 64, 64, 64, 64, 64, 64,
1474 64, 64, 64, 64, 64, 64, 64, 64,
1475 64, 64, 64, 64, 64, 64, 64, 64,
1476 64, 64, 64, 64, 64, 64, 64, 64,
1477 64, 64, 64, 64, 64, 64, 64, 64,
1478 64, 64, 64, 64, 64, 64, 64, 64,
1479 64, 64, 64, 64, 64, 64, 64, 64,
1480 64, 64, 64, 64, 64, 64, 64, 64,
1481 64, 64, 64, 64, 64, 64, 64, 64,
1482 64, 64, 64, 64, 64, 64, 64, 64,
1483 64, 64, 64, 64, 64, 64, 64, 64,
1484 64, 64, 64, 64, 64, 64, 64, 64,
1485 64, 64, 64, 64, 64, 64, 64, 64,
1486 64, 64, 64, 64, 64, 64, 64, 64,
1487 64, 64, 64, 64, 64, 64, 64, 64,
1488 64, 64, 64, 64, 64, 64, 64, 64,
1489 64, 64, 64, 64, 64, 64, 64, 64,
1490 64, 64, 64, 64, 64, 64, 64, 64,
1491 64, 64, 64, 64, 64, 64, 64, 64,
1492 64, 64, 64, 64, 64, 64, 64, 64,
1493 64, 64, 64, 64, 64, 64, 64, 64,
1494 };
1495 YYDEBUG(17, *YYCURSOR);
1496 YYFILL(2);
1497 yych = *YYCURSOR;
1498 if (yych != '#') goto yy21;
1499 YYDEBUG(19, *YYCURSOR);
1500 yyaccept = 0;
1501 yych = *(YYMARKER = ++YYCURSOR);
1502 if (yych == '!') goto yy22;
1503 yy20:
1504 YYDEBUG(20, *YYCURSOR);
1505 yyleng = YYCURSOR - SCNG(yy_text);
1506 {
1507 yyless(0);
1508 BEGIN(INITIAL);
1509 goto restart;
1510 }
1511 yy21:
1512 YYDEBUG(21, *YYCURSOR);
1513 yych = *++YYCURSOR;
1514 goto yy20;
1515 yy22:
1516 YYDEBUG(22, *YYCURSOR);
1517 ++YYCURSOR;
1518 YYFILL(1);
1519 yych = *YYCURSOR;
1520 YYDEBUG(23, *YYCURSOR);
1521 if (yybm[0+yych] & 64) {
1522 goto yy22;
1523 }
1524 if (yych <= '\f') goto yy27;
1525 yy24:
1526 YYDEBUG(24, *YYCURSOR);
1527 yyaccept = 1;
1528 YYMARKER = ++YYCURSOR;
1529 YYFILL(1);
1530 yych = *YYCURSOR;
1531 YYDEBUG(25, *YYCURSOR);
1532 if (yybm[0+yych] & 64) {
1533 goto yy22;
1534 }
1535 if (yych <= '\f') goto yy27;
1536 goto yy24;
1537 yy26:
1538 YYDEBUG(26, *YYCURSOR);
1539 yyleng = YYCURSOR - SCNG(yy_text);
1540 {
1541 CG(zend_lineno)++;
1542 BEGIN(INITIAL);
1543 goto restart;
1544 }
1545 yy27:
1546 YYDEBUG(27, *YYCURSOR);
1547 ++YYCURSOR;
1548 yych = *YYCURSOR;
1549 goto yy26;
1550 }
1551 /* *********************************** */
1552 yyc_ST_BACKQUOTE:
1553 {
1554 static const unsigned char yybm[] = {
1555 0, 0, 0, 0, 0, 0, 0, 0,
1556 0, 0, 0, 0, 0, 0, 0, 0,
1557 0, 0, 0, 0, 0, 0, 0, 0,
1558 0, 0, 0, 0, 0, 0, 0, 0,
1559 0, 0, 0, 0, 0, 0, 0, 0,
1560 0, 0, 0, 0, 0, 0, 0, 0,
1561 128, 128, 128, 128, 128, 128, 128, 128,
1562 128, 128, 0, 0, 0, 0, 0, 0,
1563 0, 128, 128, 128, 128, 128, 128, 128,
1564 128, 128, 128, 128, 128, 128, 128, 128,
1565 128, 128, 128, 128, 128, 128, 128, 128,
1566 128, 128, 128, 0, 0, 0, 0, 128,
1567 0, 128, 128, 128, 128, 128, 128, 128,
1568 128, 128, 128, 128, 128, 128, 128, 128,
1569 128, 128, 128, 128, 128, 128, 128, 128,
1570 128, 128, 128, 0, 0, 0, 0, 0,
1571 128, 128, 128, 128, 128, 128, 128, 128,
1572 128, 128, 128, 128, 128, 128, 128, 128,
1573 128, 128, 128, 128, 128, 128, 128, 128,
1574 128, 128, 128, 128, 128, 128, 128, 128,
1575 128, 128, 128, 128, 128, 128, 128, 128,
1576 128, 128, 128, 128, 128, 128, 128, 128,
1577 128, 128, 128, 128, 128, 128, 128, 128,
1578 128, 128, 128, 128, 128, 128, 128, 128,
1579 128, 128, 128, 128, 128, 128, 128, 128,
1580 128, 128, 128, 128, 128, 128, 128, 128,
1581 128, 128, 128, 128, 128, 128, 128, 128,
1582 128, 128, 128, 128, 128, 128, 128, 128,
1583 128, 128, 128, 128, 128, 128, 128, 128,
1584 128, 128, 128, 128, 128, 128, 128, 128,
1585 128, 128, 128, 128, 128, 128, 128, 128,
1586 128, 128, 128, 128, 128, 128, 128, 128,
1587 };
1588 YYDEBUG(28, *YYCURSOR);
1589 YYFILL(2);
1590 yych = *YYCURSOR;
1591 if (yych <= '_') {
1592 if (yych != '$') goto yy35;
1593 } else {
1594 if (yych <= '`') goto yy33;
1595 if (yych == '{') goto yy32;
1596 goto yy35;
1597 }
1598 YYDEBUG(30, *YYCURSOR);
1599 ++YYCURSOR;
1600 if ((yych = *YYCURSOR) <= '_') {
1601 if (yych <= '@') goto yy31;
1602 if (yych <= 'Z') goto yy38;
1603 if (yych >= '_') goto yy38;
1604 } else {
1605 if (yych <= 'z') {
1606 if (yych >= 'a') goto yy38;
1607 } else {
1608 if (yych <= '{') goto yy41;
1609 if (yych >= 0x80) goto yy38;
1610 }
1611 }
1612 yy31:
1613 YYDEBUG(31, *YYCURSOR);
1614 yyleng = YYCURSOR - SCNG(yy_text);
1615 {
1616 if (YYCURSOR > YYLIMIT) {
1617 RETURN_TOKEN(END);
1618 }
1619 if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
1620 YYCURSOR++;
1621 }
1622
1623 while (YYCURSOR < YYLIMIT) {
1624 switch (*YYCURSOR++) {
1625 case '`':
1626 break;
1627 case '$':
1628 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
1629 break;
1630 }
1631 continue;
1632 case '{':
1633 if (*YYCURSOR == '$') {
1634 break;
1635 }
1636 continue;
1637 case '\\':
1638 if (YYCURSOR < YYLIMIT) {
1639 YYCURSOR++;
1640 }
1641 /* fall through */
1642 default:
1643 continue;
1644 }
1645
1646 YYCURSOR--;
1647 break;
1648 }
1649
1650 yyleng = YYCURSOR - SCNG(yy_text);
1651
1652 if (EXPECTED(zend_scan_escape_string(zendlval, yytext, yyleng, '`') == SUCCESS)
1653 || !PARSER_MODE()) {
1654 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
1655 } else {
1656 RETURN_TOKEN(T_ERROR);
1657 }
1658 }
1659 yy32:
1660 YYDEBUG(32, *YYCURSOR);
1661 yych = *++YYCURSOR;
1662 if (yych == '$') goto yy36;
1663 goto yy31;
1664 yy33:
1665 YYDEBUG(33, *YYCURSOR);
1666 ++YYCURSOR;
1667 YYDEBUG(34, *YYCURSOR);
1668 yyleng = YYCURSOR - SCNG(yy_text);
1669 {
1670 BEGIN(ST_IN_SCRIPTING);
1671 RETURN_TOKEN('`');
1672 }
1673 yy35:
1674 YYDEBUG(35, *YYCURSOR);
1675 yych = *++YYCURSOR;
1676 goto yy31;
1677 yy36:
1678 YYDEBUG(36, *YYCURSOR);
1679 ++YYCURSOR;
1680 YYDEBUG(37, *YYCURSOR);
1681 yyleng = YYCURSOR - SCNG(yy_text);
1682 {
1683 yy_push_state(ST_IN_SCRIPTING);
1684 yyless(1);
1685 RETURN_TOKEN(T_CURLY_OPEN);
1686 }
1687 yy38:
1688 YYDEBUG(38, *YYCURSOR);
1689 yyaccept = 0;
1690 YYMARKER = ++YYCURSOR;
1691 YYFILL(3);
1692 yych = *YYCURSOR;
1693 YYDEBUG(39, *YYCURSOR);
1694 if (yybm[0+yych] & 128) {
1695 goto yy38;
1696 }
1697 if (yych == '-') goto yy43;
1698 if (yych == '[') goto yy45;
1699 yy40:
1700 YYDEBUG(40, *YYCURSOR);
1701 yyleng = YYCURSOR - SCNG(yy_text);
1702 {
1703 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1704 }
1705 yy41:
1706 YYDEBUG(41, *YYCURSOR);
1707 ++YYCURSOR;
1708 YYDEBUG(42, *YYCURSOR);
1709 yyleng = YYCURSOR - SCNG(yy_text);
1710 {
1711 yy_push_state(ST_LOOKING_FOR_VARNAME);
1712 RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
1713 }
1714 yy43:
1715 YYDEBUG(43, *YYCURSOR);
1716 yych = *++YYCURSOR;
1717 if (yych == '>') goto yy47;
1718 yy44:
1719 YYDEBUG(44, *YYCURSOR);
1720 YYCURSOR = YYMARKER;
1721 goto yy40;
1722 yy45:
1723 YYDEBUG(45, *YYCURSOR);
1724 ++YYCURSOR;
1725 YYDEBUG(46, *YYCURSOR);
1726 yyleng = YYCURSOR - SCNG(yy_text);
1727 {
1728 yyless(yyleng - 1);
1729 yy_push_state(ST_VAR_OFFSET);
1730 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1731 }
1732 yy47:
1733 YYDEBUG(47, *YYCURSOR);
1734 yych = *++YYCURSOR;
1735 if (yych <= '_') {
1736 if (yych <= '@') goto yy44;
1737 if (yych <= 'Z') goto yy48;
1738 if (yych <= '^') goto yy44;
1739 } else {
1740 if (yych <= '`') goto yy44;
1741 if (yych <= 'z') goto yy48;
1742 if (yych <= 0x7F) goto yy44;
1743 }
1744 yy48:
1745 YYDEBUG(48, *YYCURSOR);
1746 ++YYCURSOR;
1747 YYDEBUG(49, *YYCURSOR);
1748 yyleng = YYCURSOR - SCNG(yy_text);
1749 {
1750 yyless(yyleng - 3);
1751 yy_push_state(ST_LOOKING_FOR_PROPERTY);
1752 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1753 }
1754 }
1755 /* *********************************** */
1756 yyc_ST_DOUBLE_QUOTES:
1757 {
1758 static const unsigned char yybm[] = {
1759 0, 0, 0, 0, 0, 0, 0, 0,
1760 0, 0, 0, 0, 0, 0, 0, 0,
1761 0, 0, 0, 0, 0, 0, 0, 0,
1762 0, 0, 0, 0, 0, 0, 0, 0,
1763 0, 0, 0, 0, 0, 0, 0, 0,
1764 0, 0, 0, 0, 0, 0, 0, 0,
1765 128, 128, 128, 128, 128, 128, 128, 128,
1766 128, 128, 0, 0, 0, 0, 0, 0,
1767 0, 128, 128, 128, 128, 128, 128, 128,
1768 128, 128, 128, 128, 128, 128, 128, 128,
1769 128, 128, 128, 128, 128, 128, 128, 128,
1770 128, 128, 128, 0, 0, 0, 0, 128,
1771 0, 128, 128, 128, 128, 128, 128, 128,
1772 128, 128, 128, 128, 128, 128, 128, 128,
1773 128, 128, 128, 128, 128, 128, 128, 128,
1774 128, 128, 128, 0, 0, 0, 0, 0,
1775 128, 128, 128, 128, 128, 128, 128, 128,
1776 128, 128, 128, 128, 128, 128, 128, 128,
1777 128, 128, 128, 128, 128, 128, 128, 128,
1778 128, 128, 128, 128, 128, 128, 128, 128,
1779 128, 128, 128, 128, 128, 128, 128, 128,
1780 128, 128, 128, 128, 128, 128, 128, 128,
1781 128, 128, 128, 128, 128, 128, 128, 128,
1782 128, 128, 128, 128, 128, 128, 128, 128,
1783 128, 128, 128, 128, 128, 128, 128, 128,
1784 128, 128, 128, 128, 128, 128, 128, 128,
1785 128, 128, 128, 128, 128, 128, 128, 128,
1786 128, 128, 128, 128, 128, 128, 128, 128,
1787 128, 128, 128, 128, 128, 128, 128, 128,
1788 128, 128, 128, 128, 128, 128, 128, 128,
1789 128, 128, 128, 128, 128, 128, 128, 128,
1790 128, 128, 128, 128, 128, 128, 128, 128,
1791 };
1792 YYDEBUG(50, *YYCURSOR);
1793 YYFILL(2);
1794 yych = *YYCURSOR;
1795 if (yych <= '#') {
1796 if (yych == '"') goto yy55;
1797 goto yy57;
1798 } else {
1799 if (yych <= '$') goto yy52;
1800 if (yych == '{') goto yy54;
1801 goto yy57;
1802 }
1803 yy52:
1804 YYDEBUG(52, *YYCURSOR);
1805 ++YYCURSOR;
1806 if ((yych = *YYCURSOR) <= '_') {
1807 if (yych <= '@') goto yy53;
1808 if (yych <= 'Z') goto yy60;
1809 if (yych >= '_') goto yy60;
1810 } else {
1811 if (yych <= 'z') {
1812 if (yych >= 'a') goto yy60;
1813 } else {
1814 if (yych <= '{') goto yy63;
1815 if (yych >= 0x80) goto yy60;
1816 }
1817 }
1818 yy53:
1819 YYDEBUG(53, *YYCURSOR);
1820 yyleng = YYCURSOR - SCNG(yy_text);
1821 {
1822 if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
1823 YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
1824 SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
1825
1826 goto double_quotes_scan_done;
1827 }
1828
1829 if (YYCURSOR > YYLIMIT) {
1830 RETURN_TOKEN(END);
1831 }
1832 if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
1833 YYCURSOR++;
1834 }
1835
1836 while (YYCURSOR < YYLIMIT) {
1837 switch (*YYCURSOR++) {
1838 case '"':
1839 break;
1840 case '$':
1841 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
1842 break;
1843 }
1844 continue;
1845 case '{':
1846 if (*YYCURSOR == '$') {
1847 break;
1848 }
1849 continue;
1850 case '\\':
1851 if (YYCURSOR < YYLIMIT) {
1852 YYCURSOR++;
1853 }
1854 /* fall through */
1855 default:
1856 continue;
1857 }
1858
1859 YYCURSOR--;
1860 break;
1861 }
1862
1863 double_quotes_scan_done:
1864 yyleng = YYCURSOR - SCNG(yy_text);
1865
1866 if (EXPECTED(zend_scan_escape_string(zendlval, yytext, yyleng, '"') == SUCCESS)
1867 || !PARSER_MODE()) {
1868 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
1869 } else {
1870 RETURN_TOKEN(T_ERROR);
1871 }
1872 }
1873 yy54:
1874 YYDEBUG(54, *YYCURSOR);
1875 yych = *++YYCURSOR;
1876 if (yych == '$') goto yy58;
1877 goto yy53;
1878 yy55:
1879 YYDEBUG(55, *YYCURSOR);
1880 ++YYCURSOR;
1881 YYDEBUG(56, *YYCURSOR);
1882 yyleng = YYCURSOR - SCNG(yy_text);
1883 {
1884 BEGIN(ST_IN_SCRIPTING);
1885 RETURN_TOKEN('"');
1886 }
1887 yy57:
1888 YYDEBUG(57, *YYCURSOR);
1889 yych = *++YYCURSOR;
1890 goto yy53;
1891 yy58:
1892 YYDEBUG(58, *YYCURSOR);
1893 ++YYCURSOR;
1894 YYDEBUG(59, *YYCURSOR);
1895 yyleng = YYCURSOR - SCNG(yy_text);
1896 {
1897 yy_push_state(ST_IN_SCRIPTING);
1898 yyless(1);
1899 RETURN_TOKEN(T_CURLY_OPEN);
1900 }
1901 yy60:
1902 YYDEBUG(60, *YYCURSOR);
1903 yyaccept = 0;
1904 YYMARKER = ++YYCURSOR;
1905 YYFILL(3);
1906 yych = *YYCURSOR;
1907 YYDEBUG(61, *YYCURSOR);
1908 if (yybm[0+yych] & 128) {
1909 goto yy60;
1910 }
1911 if (yych == '-') goto yy65;
1912 if (yych == '[') goto yy67;
1913 yy62:
1914 YYDEBUG(62, *YYCURSOR);
1915 yyleng = YYCURSOR - SCNG(yy_text);
1916 {
1917 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1918 }
1919 yy63:
1920 YYDEBUG(63, *YYCURSOR);
1921 ++YYCURSOR;
1922 YYDEBUG(64, *YYCURSOR);
1923 yyleng = YYCURSOR - SCNG(yy_text);
1924 {
1925 yy_push_state(ST_LOOKING_FOR_VARNAME);
1926 RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
1927 }
1928 yy65:
1929 YYDEBUG(65, *YYCURSOR);
1930 yych = *++YYCURSOR;
1931 if (yych == '>') goto yy69;
1932 yy66:
1933 YYDEBUG(66, *YYCURSOR);
1934 YYCURSOR = YYMARKER;
1935 goto yy62;
1936 yy67:
1937 YYDEBUG(67, *YYCURSOR);
1938 ++YYCURSOR;
1939 YYDEBUG(68, *YYCURSOR);
1940 yyleng = YYCURSOR - SCNG(yy_text);
1941 {
1942 yyless(yyleng - 1);
1943 yy_push_state(ST_VAR_OFFSET);
1944 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1945 }
1946 yy69:
1947 YYDEBUG(69, *YYCURSOR);
1948 yych = *++YYCURSOR;
1949 if (yych <= '_') {
1950 if (yych <= '@') goto yy66;
1951 if (yych <= 'Z') goto yy70;
1952 if (yych <= '^') goto yy66;
1953 } else {
1954 if (yych <= '`') goto yy66;
1955 if (yych <= 'z') goto yy70;
1956 if (yych <= 0x7F) goto yy66;
1957 }
1958 yy70:
1959 YYDEBUG(70, *YYCURSOR);
1960 ++YYCURSOR;
1961 YYDEBUG(71, *YYCURSOR);
1962 yyleng = YYCURSOR - SCNG(yy_text);
1963 {
1964 yyless(yyleng - 3);
1965 yy_push_state(ST_LOOKING_FOR_PROPERTY);
1966 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
1967 }
1968 }
1969 /* *********************************** */
1970 yyc_ST_END_HEREDOC:
1971 YYDEBUG(72, *YYCURSOR);
1972 YYFILL(1);
1973 yych = *YYCURSOR;
1974 YYDEBUG(74, *YYCURSOR);
1975 ++YYCURSOR;
1976 YYDEBUG(75, *YYCURSOR);
1977 yyleng = YYCURSOR - SCNG(yy_text);
1978 {
1979 zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
1980
1981 yyleng = heredoc_label->indentation + heredoc_label->length;
1982 YYCURSOR += yyleng - 1;
1983
1984 heredoc_label_dtor(heredoc_label);
1985 efree(heredoc_label);
1986
1987 BEGIN(ST_IN_SCRIPTING);
1988 RETURN_TOKEN(T_END_HEREDOC);
1989 }
1990 /* *********************************** */
1991 yyc_ST_HEREDOC:
1992 {
1993 static const unsigned char yybm[] = {
1994 0, 0, 0, 0, 0, 0, 0, 0,
1995 0, 0, 0, 0, 0, 0, 0, 0,
1996 0, 0, 0, 0, 0, 0, 0, 0,
1997 0, 0, 0, 0, 0, 0, 0, 0,
1998 0, 0, 0, 0, 0, 0, 0, 0,
1999 0, 0, 0, 0, 0, 0, 0, 0,
2000 128, 128, 128, 128, 128, 128, 128, 128,
2001 128, 128, 0, 0, 0, 0, 0, 0,
2002 0, 128, 128, 128, 128, 128, 128, 128,
2003 128, 128, 128, 128, 128, 128, 128, 128,
2004 128, 128, 128, 128, 128, 128, 128, 128,
2005 128, 128, 128, 0, 0, 0, 0, 128,
2006 0, 128, 128, 128, 128, 128, 128, 128,
2007 128, 128, 128, 128, 128, 128, 128, 128,
2008 128, 128, 128, 128, 128, 128, 128, 128,
2009 128, 128, 128, 0, 0, 0, 0, 0,
2010 128, 128, 128, 128, 128, 128, 128, 128,
2011 128, 128, 128, 128, 128, 128, 128, 128,
2012 128, 128, 128, 128, 128, 128, 128, 128,
2013 128, 128, 128, 128, 128, 128, 128, 128,
2014 128, 128, 128, 128, 128, 128, 128, 128,
2015 128, 128, 128, 128, 128, 128, 128, 128,
2016 128, 128, 128, 128, 128, 128, 128, 128,
2017 128, 128, 128, 128, 128, 128, 128, 128,
2018 128, 128, 128, 128, 128, 128, 128, 128,
2019 128, 128, 128, 128, 128, 128, 128, 128,
2020 128, 128, 128, 128, 128, 128, 128, 128,
2021 128, 128, 128, 128, 128, 128, 128, 128,
2022 128, 128, 128, 128, 128, 128, 128, 128,
2023 128, 128, 128, 128, 128, 128, 128, 128,
2024 128, 128, 128, 128, 128, 128, 128, 128,
2025 128, 128, 128, 128, 128, 128, 128, 128,
2026 };
2027 YYDEBUG(76, *YYCURSOR);
2028 YYFILL(2);
2029 yych = *YYCURSOR;
2030 if (yych == '$') goto yy78;
2031 if (yych == '{') goto yy80;
2032 goto yy81;
2033 yy78:
2034 YYDEBUG(78, *YYCURSOR);
2035 ++YYCURSOR;
2036 if ((yych = *YYCURSOR) <= '_') {
2037 if (yych <= '@') goto yy79;
2038 if (yych <= 'Z') goto yy84;
2039 if (yych >= '_') goto yy84;
2040 } else {
2041 if (yych <= 'z') {
2042 if (yych >= 'a') goto yy84;
2043 } else {
2044 if (yych <= '{') goto yy87;
2045 if (yych >= 0x80) goto yy84;
2046 }
2047 }
2048 yy79:
2049 YYDEBUG(79, *YYCURSOR);
2050 yyleng = YYCURSOR - SCNG(yy_text);
2051 {
2052 zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
2053 int newline = 0, indentation = 0, spacing = 0;
2054
2055 if (YYCURSOR > YYLIMIT) {
2056 RETURN_TOKEN(END);
2057 }
2058
2059 YYCURSOR--;
2060
2061 while (YYCURSOR < YYLIMIT) {
2062 switch (*YYCURSOR++) {
2063 case '\r':
2064 if (*YYCURSOR == '\n') {
2065 YYCURSOR++;
2066 }
2067 /* fall through */
2068 case '\n':
2069 indentation = spacing = 0;
2070
2071 while (YYCURSOR < YYLIMIT && (*YYCURSOR == ' ' || *YYCURSOR == '\t')) {
2072 if (*YYCURSOR == '\t') {
2073 spacing |= HEREDOC_USING_TABS;
2074 } else {
2075 spacing |= HEREDOC_USING_SPACES;
2076 }
2077 ++YYCURSOR;
2078 ++indentation;
2079 }
2080
2081 if (YYCURSOR == YYLIMIT) {
2082 yyleng = YYCURSOR - SCNG(yy_text);
2083 HANDLE_NEWLINES(yytext, yyleng);
2084 ZVAL_NULL(zendlval);
2085 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
2086 }
2087
2088 /* Check for ending label on the next line */
2089 if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
2090 if (IS_LABEL_SUCCESSOR(YYCURSOR[heredoc_label->length])) {
2091 continue;
2092 }
2093
2094 if (spacing == (HEREDOC_USING_SPACES | HEREDOC_USING_TABS)) {
2095 zend_throw_exception(zend_ce_parse_error, "Invalid indentation - tabs and spaces cannot be mixed", 0);
2096 if (PARSER_MODE()) {
2097 RETURN_TOKEN(T_ERROR);
2098 }
2099 }
2100
2101 /* newline before label will be subtracted from returned text, but
2102 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
2103 if (YYCURSOR[-indentation - 2] == '\r' && YYCURSOR[-indentation - 1] == '\n') {
2104 newline = 2; /* Windows newline */
2105 } else {
2106 newline = 1;
2107 }
2108
2109 CG(increment_lineno) = 1; /* For newline before label */
2110
2111 if (SCNG(heredoc_scan_ahead)) {
2112 SCNG(heredoc_indentation) = indentation;
2113 SCNG(heredoc_indentation_uses_spaces) = (spacing == HEREDOC_USING_SPACES);
2114 } else {
2115 YYCURSOR -= indentation;
2116 }
2117
2118 BEGIN(ST_END_HEREDOC);
2119
2120 goto heredoc_scan_done;
2121 }
2122 continue;
2123 case '$':
2124 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
2125 break;
2126 }
2127 continue;
2128 case '{':
2129 if (*YYCURSOR == '$') {
2130 break;
2131 }
2132 continue;
2133 case '\\':
2134 if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
2135 YYCURSOR++;
2136 }
2137 /* fall through */
2138 default:
2139 continue;
2140 }
2141
2142 YYCURSOR--;
2143 break;
2144 }
2145
2146 heredoc_scan_done:
2147
2148 yyleng = YYCURSOR - SCNG(yy_text);
2149 ZVAL_STRINGL(zendlval, yytext, yyleng - newline);
2150
2151 if (!SCNG(heredoc_scan_ahead) && !EG(exception) && PARSER_MODE()) {
2152 zend_bool newline_at_start = *(yytext - 1) == '\n' || *(yytext - 1) == '\r';
2153 zend_string *copy = Z_STR_P(zendlval);
2154
2155 if (!strip_multiline_string_indentation(
2156 zendlval, heredoc_label->indentation, heredoc_label->indentation_uses_spaces,
2157 newline_at_start, newline != 0)) {
2158 RETURN_TOKEN(T_ERROR);
2159 }
2160
2161 if (UNEXPECTED(zend_scan_escape_string(zendlval, ZSTR_VAL(copy), ZSTR_LEN(copy), 0) != SUCCESS)) {
2162 zend_string_efree(copy);
2163 RETURN_TOKEN(T_ERROR);
2164 }
2165
2166 zend_string_efree(copy);
2167 } else {
2168 HANDLE_NEWLINES(yytext, yyleng - newline);
2169 }
2170
2171 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
2172 }
2173 yy80:
2174 YYDEBUG(80, *YYCURSOR);
2175 yych = *++YYCURSOR;
2176 if (yych == '$') goto yy82;
2177 goto yy79;
2178 yy81:
2179 YYDEBUG(81, *YYCURSOR);
2180 yych = *++YYCURSOR;
2181 goto yy79;
2182 yy82:
2183 YYDEBUG(82, *YYCURSOR);
2184 ++YYCURSOR;
2185 YYDEBUG(83, *YYCURSOR);
2186 yyleng = YYCURSOR - SCNG(yy_text);
2187 {
2188 yy_push_state(ST_IN_SCRIPTING);
2189 yyless(1);
2190 RETURN_TOKEN(T_CURLY_OPEN);
2191 }
2192 yy84:
2193 YYDEBUG(84, *YYCURSOR);
2194 yyaccept = 0;
2195 YYMARKER = ++YYCURSOR;
2196 YYFILL(3);
2197 yych = *YYCURSOR;
2198 YYDEBUG(85, *YYCURSOR);
2199 if (yybm[0+yych] & 128) {
2200 goto yy84;
2201 }
2202 if (yych == '-') goto yy89;
2203 if (yych == '[') goto yy91;
2204 yy86:
2205 YYDEBUG(86, *YYCURSOR);
2206 yyleng = YYCURSOR - SCNG(yy_text);
2207 {
2208 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
2209 }
2210 yy87:
2211 YYDEBUG(87, *YYCURSOR);
2212 ++YYCURSOR;
2213 YYDEBUG(88, *YYCURSOR);
2214 yyleng = YYCURSOR - SCNG(yy_text);
2215 {
2216 yy_push_state(ST_LOOKING_FOR_VARNAME);
2217 RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES);
2218 }
2219 yy89:
2220 YYDEBUG(89, *YYCURSOR);
2221 yych = *++YYCURSOR;
2222 if (yych == '>') goto yy93;
2223 yy90:
2224 YYDEBUG(90, *YYCURSOR);
2225 YYCURSOR = YYMARKER;
2226 goto yy86;
2227 yy91:
2228 YYDEBUG(91, *YYCURSOR);
2229 ++YYCURSOR;
2230 YYDEBUG(92, *YYCURSOR);
2231 yyleng = YYCURSOR - SCNG(yy_text);
2232 {
2233 yyless(yyleng - 1);
2234 yy_push_state(ST_VAR_OFFSET);
2235 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
2236 }
2237 yy93:
2238 YYDEBUG(93, *YYCURSOR);
2239 yych = *++YYCURSOR;
2240 if (yych <= '_') {
2241 if (yych <= '@') goto yy90;
2242 if (yych <= 'Z') goto yy94;
2243 if (yych <= '^') goto yy90;
2244 } else {
2245 if (yych <= '`') goto yy90;
2246 if (yych <= 'z') goto yy94;
2247 if (yych <= 0x7F) goto yy90;
2248 }
2249 yy94:
2250 YYDEBUG(94, *YYCURSOR);
2251 ++YYCURSOR;
2252 YYDEBUG(95, *YYCURSOR);
2253 yyleng = YYCURSOR - SCNG(yy_text);
2254 {
2255 yyless(yyleng - 3);
2256 yy_push_state(ST_LOOKING_FOR_PROPERTY);
2257 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
2258 }
2259 }
2260 /* *********************************** */
2261 yyc_ST_IN_SCRIPTING:
2262 {
2263 static const unsigned char yybm[] = {
2264 0, 0, 0, 0, 0, 0, 0, 0,
2265 0, 192, 64, 0, 0, 64, 0, 0,
2266 0, 0, 0, 0, 0, 0, 0, 0,
2267 0, 0, 0, 0, 0, 0, 0, 0,
2268 192, 0, 0, 0, 0, 0, 0, 0,
2269 0, 0, 0, 0, 0, 0, 0, 0,
2270 60, 60, 44, 44, 44, 44, 44, 44,
2271 44, 44, 0, 0, 0, 0, 0, 0,
2272 0, 36, 36, 36, 36, 36, 36, 4,
2273 4, 4, 4, 4, 4, 4, 4, 4,
2274 4, 4, 4, 4, 4, 4, 4, 4,
2275 4, 4, 4, 0, 0, 0, 0, 4,
2276 0, 36, 36, 36, 36, 36, 36, 4,
2277 4, 4, 4, 4, 4, 4, 4, 4,
2278 4, 4, 4, 4, 4, 4, 4, 4,
2279 4, 4, 4, 0, 0, 0, 0, 0,
2280 4, 4, 4, 4, 4, 4, 4, 4,
2281 4, 4, 4, 4, 4, 4, 4, 4,
2282 4, 4, 4, 4, 4, 4, 4, 4,
2283 4, 4, 4, 4, 4, 4, 4, 4,
2284 4, 4, 4, 4, 4, 4, 4, 4,
2285 4, 4, 4, 4, 4, 4, 4, 4,
2286 4, 4, 4, 4, 4, 4, 4, 4,
2287 4, 4, 4, 4, 4, 4, 4, 4,
2288 4, 4, 4, 4, 4, 4, 4, 4,
2289 4, 4, 4, 4, 4, 4, 4, 4,
2290 4, 4, 4, 4, 4, 4, 4, 4,
2291 4, 4, 4, 4, 4, 4, 4, 4,
2292 4, 4, 4, 4, 4, 4, 4, 4,
2293 4, 4, 4, 4, 4, 4, 4, 4,
2294 4, 4, 4, 4, 4, 4, 4, 4,
2295 4, 4, 4, 4, 4, 4, 4, 4,
2296 };
2297 YYDEBUG(96, *YYCURSOR);
2298 YYFILL(16);
2299 yych = *YYCURSOR;
2300 YYDEBUG(-1, yych);
2301 switch (yych) {
2302 case 0x00:
2303 case 0x01:
2304 case 0x02:
2305 case 0x03:
2306 case 0x04:
2307 case 0x05:
2308 case 0x06:
2309 case 0x07:
2310 case 0x08:
2311 case '\v':
2312 case '\f':
2313 case 0x0E:
2314 case 0x0F:
2315 case 0x10:
2316 case 0x11:
2317 case 0x12:
2318 case 0x13:
2319 case 0x14:
2320 case 0x15:
2321 case 0x16:
2322 case 0x17:
2323 case 0x18:
2324 case 0x19:
2325 case 0x1A:
2326 case 0x1B:
2327 case 0x1C:
2328 case 0x1D:
2329 case 0x1E:
2330 case 0x1F:
2331 case 0x7F: goto yy159;
2332 case '\t':
2333 case '\n':
2334 case '\r':
2335 case ' ': goto yy115;
2336 case '!': goto yy130;
2337 case '"': goto yy155;
2338 case '#': goto yy151;
2339 case '$': goto yy141;
2340 case '%': goto yy135;
2341 case '&': goto yy136;
2342 case '\'': goto yy153;
2343 case '(': goto yy124;
2344 case ')':
2345 case ',':
2346 case ';':
2347 case '@':
2348 case '[':
2349 case ']':
2350 case '~': goto yy142;
2351 case '*': goto yy133;
2352 case '+': goto yy129;
2353 case '-': goto yy113;
2354 case '.': goto yy120;
2355 case '/': goto yy134;
2356 case '0': goto yy147;
2357 case '1':
2358 case '2':
2359 case '3':
2360 case '4':
2361 case '5':
2362 case '6':
2363 case '7':
2364 case '8':
2365 case '9': goto yy149;
2366 case ':': goto yy117;
2367 case '<': goto yy131;
2368 case '=': goto yy127;
2369 case '>': goto yy132;
2370 case '?': goto yy121;
2371 case 'A':
2372 case 'a': goto yy108;
2373 case 'B':
2374 case 'b': goto yy110;
2375 case 'C':
2376 case 'c': goto yy102;
2377 case 'D':
2378 case 'd': goto yy100;
2379 case 'E':
2380 case 'e': goto yy98;
2381 case 'F':
2382 case 'f': goto yy101;
2383 case 'G':
2384 case 'g': goto yy111;
2385 case 'I':
2386 case 'i': goto yy106;
2387 case 'L':
2388 case 'l': goto yy128;
2389 case 'N':
2390 case 'n': goto yy122;
2391 case 'O':
2392 case 'o': goto yy139;
2393 case 'P':
2394 case 'p': goto yy112;
2395 case 'R':
2396 case 'r': goto yy103;
2397 case 'S':
2398 case 's': goto yy109;
2399 case 'T':
2400 case 't': goto yy105;
2401 case 'U':
2402 case 'u': goto yy125;
2403 case 'V':
2404 case 'v': goto yy123;
2405 case 'W':
2406 case 'w': goto yy107;
2407 case 'X':
2408 case 'x': goto yy140;
2409 case 'Y':
2410 case 'y': goto yy104;
2411 case '\\': goto yy118;
2412 case '^': goto yy138;
2413 case '_': goto yy126;
2414 case '`': goto yy157;
2415 case '{': goto yy143;
2416 case '|': goto yy137;
2417 case '}': goto yy145;
2418 default: goto yy150;
2419 }
2420 yy98:
2421 YYDEBUG(98, *YYCURSOR);
2422 ++YYCURSOR;
2423 YYDEBUG(-1, yych);
2424 switch ((yych = *YYCURSOR)) {
2425 case 'C':
2426 case 'c': goto yy744;
2427 case 'L':
2428 case 'l': goto yy745;
2429 case 'M':
2430 case 'm': goto yy746;
2431 case 'N':
2432 case 'n': goto yy747;
2433 case 'V':
2434 case 'v': goto yy748;
2435 case 'X':
2436 case 'x': goto yy749;
2437 default: goto yy162;
2438 }
2439 yy99:
2440 YYDEBUG(99, *YYCURSOR);
2441 yyleng = YYCURSOR - SCNG(yy_text);
2442 {
2443 RETURN_TOKEN_WITH_STR(T_STRING, 0);
2444 }
2445 yy100:
2446 YYDEBUG(100, *YYCURSOR);
2447 yych = *++YYCURSOR;
2448 if (yych <= 'O') {
2449 if (yych <= 'H') {
2450 if (yych == 'E') goto yy726;
2451 goto yy162;
2452 } else {
2453 if (yych <= 'I') goto yy727;
2454 if (yych <= 'N') goto yy162;
2455 goto yy728;
2456 }
2457 } else {
2458 if (yych <= 'h') {
2459 if (yych == 'e') goto yy726;
2460 goto yy162;
2461 } else {
2462 if (yych <= 'i') goto yy727;
2463 if (yych == 'o') goto yy728;
2464 goto yy162;
2465 }
2466 }
2467 yy101:
2468 YYDEBUG(101, *YYCURSOR);
2469 yych = *++YYCURSOR;
2470 if (yych <= 'U') {
2471 if (yych <= 'M') {
2472 if (yych == 'I') goto yy700;
2473 goto yy162;
2474 } else {
2475 if (yych <= 'N') goto yy701;
2476 if (yych <= 'O') goto yy703;
2477 if (yych <= 'T') goto yy162;
2478 goto yy704;
2479 }
2480 } else {
2481 if (yych <= 'n') {
2482 if (yych == 'i') goto yy700;
2483 if (yych <= 'm') goto yy162;
2484 goto yy701;
2485 } else {
2486 if (yych <= 'o') goto yy703;
2487 if (yych == 'u') goto yy704;
2488 goto yy162;
2489 }
2490 }
2491 yy102:
2492 YYDEBUG(102, *YYCURSOR);
2493 yych = *++YYCURSOR;
2494 if (yych <= 'O') {
2495 if (yych <= 'K') {
2496 if (yych == 'A') goto yy665;
2497 goto yy162;
2498 } else {
2499 if (yych <= 'L') goto yy666;
2500 if (yych <= 'N') goto yy162;
2501 goto yy667;
2502 }
2503 } else {
2504 if (yych <= 'k') {
2505 if (yych == 'a') goto yy665;
2506 goto yy162;
2507 } else {
2508 if (yych <= 'l') goto yy666;
2509 if (yych == 'o') goto yy667;
2510 goto yy162;
2511 }
2512 }
2513 yy103:
2514 YYDEBUG(103, *YYCURSOR);
2515 yych = *++YYCURSOR;
2516 if (yych == 'E') goto yy647;
2517 if (yych == 'e') goto yy647;
2518 goto yy162;
2519 yy104:
2520 YYDEBUG(104, *YYCURSOR);
2521 yych = *++YYCURSOR;
2522 if (yych == 'I') goto yy634;
2523 if (yych == 'i') goto yy634;
2524 goto yy162;
2525 yy105:
2526 YYDEBUG(105, *YYCURSOR);
2527 yych = *++YYCURSOR;
2528 if (yych <= 'R') {
2529 if (yych == 'H') goto yy622;
2530 if (yych <= 'Q') goto yy162;
2531 goto yy623;
2532 } else {
2533 if (yych <= 'h') {
2534 if (yych <= 'g') goto yy162;
2535 goto yy622;
2536 } else {
2537 if (yych == 'r') goto yy623;
2538 goto yy162;
2539 }
2540 }
2541 yy106:
2542 YYDEBUG(106, *YYCURSOR);
2543 yych = *++YYCURSOR;
2544 if (yych <= 'S') {
2545 if (yych <= 'L') {
2546 if (yych == 'F') goto yy569;
2547 goto yy162;
2548 } else {
2549 if (yych <= 'M') goto yy571;
2550 if (yych <= 'N') goto yy572;
2551 if (yych <= 'R') goto yy162;
2552 goto yy573;
2553 }
2554 } else {
2555 if (yych <= 'm') {
2556 if (yych == 'f') goto yy569;
2557 if (yych <= 'l') goto yy162;
2558 goto yy571;
2559 } else {
2560 if (yych <= 'n') goto yy572;
2561 if (yych == 's') goto yy573;
2562 goto yy162;
2563 }
2564 }
2565 yy107:
2566 YYDEBUG(107, *YYCURSOR);
2567 yych = *++YYCURSOR;
2568 if (yych == 'H') goto yy564;
2569 if (yych == 'h') goto yy564;
2570 goto yy162;
2571 yy108:
2572 YYDEBUG(108, *YYCURSOR);
2573 yych = *++YYCURSOR;
2574 if (yych <= 'S') {
2575 if (yych <= 'M') {
2576 if (yych == 'B') goto yy546;
2577 goto yy162;
2578 } else {
2579 if (yych <= 'N') goto yy547;
2580 if (yych <= 'Q') goto yy162;
2581 if (yych <= 'R') goto yy548;
2582 goto yy549;
2583 }
2584 } else {
2585 if (yych <= 'n') {
2586 if (yych == 'b') goto yy546;
2587 if (yych <= 'm') goto yy162;
2588 goto yy547;
2589 } else {
2590 if (yych <= 'q') goto yy162;
2591 if (yych <= 'r') goto yy548;
2592 if (yych <= 's') goto yy549;
2593 goto yy162;
2594 }
2595 }
2596 yy109:
2597 YYDEBUG(109, *YYCURSOR);
2598 yych = *++YYCURSOR;
2599 if (yych <= 'W') {
2600 if (yych == 'T') goto yy534;
2601 if (yych <= 'V') goto yy162;
2602 goto yy535;
2603 } else {
2604 if (yych <= 't') {
2605 if (yych <= 's') goto yy162;
2606 goto yy534;
2607 } else {
2608 if (yych == 'w') goto yy535;
2609 goto yy162;
2610 }
2611 }
2612 yy110:
2613 YYDEBUG(110, *YYCURSOR);
2614 yyaccept = 0;
2615 yych = *(YYMARKER = ++YYCURSOR);
2616 if (yych <= ';') {
2617 if (yych <= '"') {
2618 if (yych <= '!') goto yy162;
2619 goto yy526;
2620 } else {
2621 if (yych == '\'') goto yy527;
2622 goto yy162;
2623 }
2624 } else {
2625 if (yych <= 'R') {
2626 if (yych <= '<') goto yy525;
2627 if (yych <= 'Q') goto yy162;
2628 goto yy528;
2629 } else {
2630 if (yych == 'r') goto yy528;
2631 goto yy162;
2632 }
2633 }
2634 yy111:
2635 YYDEBUG(111, *YYCURSOR);
2636 yych = *++YYCURSOR;
2637 if (yych <= 'O') {
2638 if (yych == 'L') goto yy515;
2639 if (yych <= 'N') goto yy162;
2640 goto yy516;
2641 } else {
2642 if (yych <= 'l') {
2643 if (yych <= 'k') goto yy162;
2644 goto yy515;
2645 } else {
2646 if (yych == 'o') goto yy516;
2647 goto yy162;
2648 }
2649 }
2650 yy112:
2651 YYDEBUG(112, *YYCURSOR);
2652 yych = *++YYCURSOR;
2653 if (yych <= 'U') {
2654 if (yych == 'R') goto yy491;
2655 if (yych <= 'T') goto yy162;
2656 goto yy492;
2657 } else {
2658 if (yych <= 'r') {
2659 if (yych <= 'q') goto yy162;
2660 goto yy491;
2661 } else {
2662 if (yych == 'u') goto yy492;
2663 goto yy162;
2664 }
2665 }
2666 yy113:
2667 YYDEBUG(113, *YYCURSOR);
2668 ++YYCURSOR;
2669 if ((yych = *YYCURSOR) <= '<') {
2670 if (yych == '-') goto yy487;
2671 } else {
2672 if (yych <= '=') goto yy485;
2673 if (yych <= '>') goto yy489;
2674 }
2675 yy114:
2676 YYDEBUG(114, *YYCURSOR);
2677 yyleng = YYCURSOR - SCNG(yy_text);
2678 {
2679 RETURN_TOKEN(yytext[0]);
2680 }
2681 yy115:
2682 YYDEBUG(115, *YYCURSOR);
2683 ++YYCURSOR;
2684 yych = *YYCURSOR;
2685 goto yy484;
2686 yy116:
2687 YYDEBUG(116, *YYCURSOR);
2688 yyleng = YYCURSOR - SCNG(yy_text);
2689 {
2690 goto return_whitespace;
2691 }
2692 yy117:
2693 YYDEBUG(117, *YYCURSOR);
2694 yych = *++YYCURSOR;
2695 if (yych == ':') goto yy481;
2696 goto yy114;
2697 yy118:
2698 YYDEBUG(118, *YYCURSOR);
2699 ++YYCURSOR;
2700 YYDEBUG(119, *YYCURSOR);
2701 yyleng = YYCURSOR - SCNG(yy_text);
2702 {
2703 RETURN_TOKEN(T_NS_SEPARATOR);
2704 }
2705 yy120:
2706 YYDEBUG(120, *YYCURSOR);
2707 yyaccept = 1;
2708 yych = *(YYMARKER = ++YYCURSOR);
2709 if (yych <= '/') {
2710 if (yych == '.') goto yy475;
2711 goto yy114;
2712 } else {
2713 if (yych <= '9') goto yy471;
2714 if (yych == '=') goto yy473;
2715 goto yy114;
2716 }
2717 yy121:
2718 YYDEBUG(121, *YYCURSOR);
2719 yych = *++YYCURSOR;
2720 if (yych <= '=') goto yy114;
2721 if (yych <= '>') goto yy463;
2722 if (yych <= '?') goto yy465;
2723 goto yy114;
2724 yy122:
2725 YYDEBUG(122, *YYCURSOR);
2726 yych = *++YYCURSOR;
2727 if (yych <= 'E') {
2728 if (yych == 'A') goto yy451;
2729 if (yych <= 'D') goto yy162;
2730 goto yy452;
2731 } else {
2732 if (yych <= 'a') {
2733 if (yych <= '`') goto yy162;
2734 goto yy451;
2735 } else {
2736 if (yych == 'e') goto yy452;
2737 goto yy162;
2738 }
2739 }
2740 yy123:
2741 YYDEBUG(123, *YYCURSOR);
2742 yych = *++YYCURSOR;
2743 if (yych == 'A') goto yy448;
2744 if (yych == 'a') goto yy448;
2745 goto yy162;
2746 yy124:
2747 YYDEBUG(124, *YYCURSOR);
2748 yyaccept = 1;
2749 yych = *(YYMARKER = ++YYCURSOR);
2750 if (yych <= 'S') {
2751 if (yych <= 'D') {
2752 if (yych <= ' ') {
2753 if (yych == '\t') goto yy369;
2754 if (yych <= 0x1F) goto yy114;
2755 goto yy369;
2756 } else {
2757 if (yych <= '@') goto yy114;
2758 if (yych == 'C') goto yy114;
2759 goto yy369;
2760 }
2761 } else {
2762 if (yych <= 'I') {
2763 if (yych == 'F') goto yy369;
2764 if (yych <= 'H') goto yy114;
2765 goto yy369;
2766 } else {
2767 if (yych == 'O') goto yy369;
2768 if (yych <= 'Q') goto yy114;
2769 goto yy369;
2770 }
2771 }
2772 } else {
2773 if (yych <= 'f') {
2774 if (yych <= 'b') {
2775 if (yych == 'U') goto yy369;
2776 if (yych <= '`') goto yy114;
2777 goto yy369;
2778 } else {
2779 if (yych == 'd') goto yy369;
2780 if (yych <= 'e') goto yy114;
2781 goto yy369;
2782 }
2783 } else {
2784 if (yych <= 'o') {
2785 if (yych == 'i') goto yy369;
2786 if (yych <= 'n') goto yy114;
2787 goto yy369;
2788 } else {
2789 if (yych <= 's') {
2790 if (yych <= 'q') goto yy114;
2791 goto yy369;
2792 } else {
2793 if (yych == 'u') goto yy369;
2794 goto yy114;
2795 }
2796 }
2797 }
2798 }
2799 yy125:
2800 YYDEBUG(125, *YYCURSOR);
2801 yych = *++YYCURSOR;
2802 if (yych <= 'S') {
2803 if (yych == 'N') goto yy360;
2804 if (yych <= 'R') goto yy162;
2805 goto yy361;
2806 } else {
2807 if (yych <= 'n') {
2808 if (yych <= 'm') goto yy162;
2809 goto yy360;
2810 } else {
2811 if (yych == 's') goto yy361;
2812 goto yy162;
2813 }
2814 }
2815 yy126:
2816 YYDEBUG(126, *YYCURSOR);
2817 yych = *++YYCURSOR;
2818 if (yych == '_') goto yy278;
2819 goto yy162;
2820 yy127:
2821 YYDEBUG(127, *YYCURSOR);
2822 yych = *++YYCURSOR;
2823 if (yych <= '<') goto yy114;
2824 if (yych <= '=') goto yy272;
2825 if (yych <= '>') goto yy274;
2826 goto yy114;
2827 yy128:
2828 YYDEBUG(128, *YYCURSOR);
2829 yych = *++YYCURSOR;
2830 if (yych == 'I') goto yy268;
2831 if (yych == 'i') goto yy268;
2832 goto yy162;
2833 yy129:
2834 YYDEBUG(129, *YYCURSOR);
2835 yych = *++YYCURSOR;
2836 if (yych == '+') goto yy266;
2837 if (yych == '=') goto yy264;
2838 goto yy114;
2839 yy130:
2840 YYDEBUG(130, *YYCURSOR);
2841 yych = *++YYCURSOR;
2842 if (yych == '=') goto yy261;
2843 goto yy114;
2844 yy131:
2845 YYDEBUG(131, *YYCURSOR);
2846 yych = *++YYCURSOR;
2847 if (yych <= ';') goto yy114;
2848 if (yych <= '<') goto yy237;
2849 if (yych <= '=') goto yy239;
2850 if (yych <= '>') goto yy241;
2851 goto yy114;
2852 yy132:
2853 YYDEBUG(132, *YYCURSOR);
2854 yych = *++YYCURSOR;
2855 if (yych <= '<') goto yy114;
2856 if (yych <= '=') goto yy233;
2857 if (yych <= '>') goto yy231;
2858 goto yy114;
2859 yy133:
2860 YYDEBUG(133, *YYCURSOR);
2861 yych = *++YYCURSOR;
2862 if (yych == '*') goto yy225;
2863 if (yych == '=') goto yy227;
2864 goto yy114;
2865 yy134:
2866 YYDEBUG(134, *YYCURSOR);
2867 yych = *++YYCURSOR;
2868 if (yych <= '.') {
2869 if (yych == '*') goto yy217;
2870 goto yy114;
2871 } else {
2872 if (yych <= '/') goto yy219;
2873 if (yych == '=') goto yy220;
2874 goto yy114;
2875 }
2876 yy135:
2877 YYDEBUG(135, *YYCURSOR);
2878 yych = *++YYCURSOR;
2879 if (yych == '=') goto yy215;
2880 goto yy114;
2881 yy136:
2882 YYDEBUG(136, *YYCURSOR);
2883 yych = *++YYCURSOR;
2884 if (yych == '&') goto yy211;
2885 if (yych == '=') goto yy213;
2886 goto yy114;
2887 yy137:
2888 YYDEBUG(137, *YYCURSOR);
2889 yych = *++YYCURSOR;
2890 if (yych == '=') goto yy209;
2891 if (yych == '|') goto yy207;
2892 goto yy114;
2893 yy138:
2894 YYDEBUG(138, *YYCURSOR);
2895 yych = *++YYCURSOR;
2896 if (yych == '=') goto yy205;
2897 goto yy114;
2898 yy139:
2899 YYDEBUG(139, *YYCURSOR);
2900 yych = *++YYCURSOR;
2901 if (yych == 'R') goto yy203;
2902 if (yych == 'r') goto yy203;
2903 goto yy162;
2904 yy140:
2905 YYDEBUG(140, *YYCURSOR);
2906 yych = *++YYCURSOR;
2907 if (yych == 'O') goto yy200;
2908 if (yych == 'o') goto yy200;
2909 goto yy162;
2910 yy141:
2911 YYDEBUG(141, *YYCURSOR);
2912 yych = *++YYCURSOR;
2913 if (yych <= '_') {
2914 if (yych <= '@') goto yy114;
2915 if (yych <= 'Z') goto yy197;
2916 if (yych <= '^') goto yy114;
2917 goto yy197;
2918 } else {
2919 if (yych <= '`') goto yy114;
2920 if (yych <= 'z') goto yy197;
2921 if (yych <= 0x7F) goto yy114;
2922 goto yy197;
2923 }
2924 yy142:
2925 YYDEBUG(142, *YYCURSOR);
2926 yych = *++YYCURSOR;
2927 goto yy114;
2928 yy143:
2929 YYDEBUG(143, *YYCURSOR);
2930 ++YYCURSOR;
2931 YYDEBUG(144, *YYCURSOR);
2932 yyleng = YYCURSOR - SCNG(yy_text);
2933 {
2934 yy_push_state(ST_IN_SCRIPTING);
2935 RETURN_TOKEN('{');
2936 }
2937 yy145:
2938 YYDEBUG(145, *YYCURSOR);
2939 ++YYCURSOR;
2940 YYDEBUG(146, *YYCURSOR);
2941 yyleng = YYCURSOR - SCNG(yy_text);
2942 {
2943 RESET_DOC_COMMENT();
2944 if (!zend_stack_is_empty(&SCNG(state_stack))) {
2945 yy_pop_state();
2946 }
2947 RETURN_TOKEN('}');
2948 }
2949 yy147:
2950 YYDEBUG(147, *YYCURSOR);
2951 yyaccept = 2;
2952 yych = *(YYMARKER = ++YYCURSOR);
2953 if (yych <= 'X') {
2954 if (yych == 'B') goto yy184;
2955 if (yych <= 'W') goto yy168;
2956 goto yy183;
2957 } else {
2958 if (yych <= 'b') {
2959 if (yych <= 'a') goto yy168;
2960 goto yy184;
2961 } else {
2962 if (yych == 'x') goto yy183;
2963 goto yy168;
2964 }
2965 }
2966 yy148:
2967 YYDEBUG(148, *YYCURSOR);
2968 yyleng = YYCURSOR - SCNG(yy_text);
2969 {
2970 size_t len = yyleng;
2971 char *end, *lnum = yytext;
2972 zend_bool is_octal = lnum[0] == '0';
2973 zend_bool contains_underscores = (memchr(lnum, '_', len) != NULL);
2974
2975 if (contains_underscores) {
2976 lnum = estrndup(lnum, len);
2977 strip_underscores(lnum, &len);
2978 }
2979
2980 /* Digits 8 and 9 are illegal in octal literals. */
2981 if (is_octal) {
2982 size_t i;
2983 for (i = 0; i < len; i++) {
2984 if (lnum[i] == '8' || lnum[i] == '9') {
2985 zend_throw_exception(zend_ce_parse_error, "Invalid numeric literal", 0);
2986 if (PARSER_MODE()) {
2987 if (contains_underscores) {
2988 efree(lnum);
2989 }
2990 ZVAL_UNDEF(zendlval);
2991 RETURN_TOKEN(T_ERROR);
2992 }
2993
2994 /* Continue in order to determine if this is T_LNUMBER or T_DNUMBER. */
2995 len = i;
2996 break;
2997 }
2998 }
2999 }
3000
3001
3002 if (len < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
3003 errno = 0;
3004 /* base must be passed explicitly for correct parse error on Windows */
3005 ZVAL_LONG(zendlval, ZEND_STRTOL(lnum, &end, is_octal ? 8 : 10));
3006 ZEND_ASSERT(end == lnum + len);
3007 } else {
3008 errno = 0;
3009 ZVAL_LONG(zendlval, ZEND_STRTOL(lnum, &end, 0));
3010 if (errno == ERANGE) { /* Overflow */
3011 errno = 0;
3012 if (is_octal) { /* octal overflow */
3013 ZVAL_DOUBLE(zendlval, zend_oct_strtod(lnum, (const char **)&end));
3014 } else {
3015 ZVAL_DOUBLE(zendlval, zend_strtod(lnum, (const char **)&end));
3016 }
3017 ZEND_ASSERT(end == lnum + len);
3018 if (contains_underscores) {
3019 efree(lnum);
3020 }
3021 RETURN_TOKEN_WITH_VAL(T_DNUMBER);
3022 }
3023 ZEND_ASSERT(end == lnum + len);
3024 }
3025 ZEND_ASSERT(!errno);
3026 if (contains_underscores) {
3027 efree(lnum);
3028 }
3029 RETURN_TOKEN_WITH_VAL(T_LNUMBER);
3030 }
3031 yy149:
3032 YYDEBUG(149, *YYCURSOR);
3033 yyaccept = 2;
3034 yych = *(YYMARKER = ++YYCURSOR);
3035 goto yy168;
3036 yy150:
3037 YYDEBUG(150, *YYCURSOR);
3038 yych = *++YYCURSOR;
3039 goto yy162;
3040 yy151:
3041 YYDEBUG(151, *YYCURSOR);
3042 ++YYCURSOR;
3043 yy152:
3044 YYDEBUG(152, *YYCURSOR);
3045 yyleng = YYCURSOR - SCNG(yy_text);
3046 {
3047 while (YYCURSOR < YYLIMIT) {
3048 switch (*YYCURSOR++) {
3049 case '\r':
3050 if (*YYCURSOR == '\n') {
3051 YYCURSOR++;
3052 }
3053 /* fall through */
3054 case '\n':
3055 CG(zend_lineno)++;
3056 break;
3057 case '?':
3058 if (*YYCURSOR == '>') {
3059 YYCURSOR--;
3060 break;
3061 }
3062 /* fall through */
3063 default:
3064 continue;
3065 }
3066
3067 break;
3068 }
3069
3070 yyleng = YYCURSOR - SCNG(yy_text);
3071 RETURN_OR_SKIP_TOKEN(T_COMMENT);
3072 }
3073 yy153:
3074 YYDEBUG(153, *YYCURSOR);
3075 ++YYCURSOR;
3076 yy154:
3077 YYDEBUG(154, *YYCURSOR);
3078 yyleng = YYCURSOR - SCNG(yy_text);
3079 {
3080 register char *s, *t;
3081 char *end;
3082 int bprefix = (yytext[0] != '\'') ? 1 : 0;
3083
3084 while (1) {
3085 if (YYCURSOR < YYLIMIT) {
3086 if (*YYCURSOR == '\'') {
3087 YYCURSOR++;
3088 yyleng = YYCURSOR - SCNG(yy_text);
3089
3090 break;
3091 } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
3092 YYCURSOR++;
3093 }
3094 } else {
3095 yyleng = YYLIMIT - SCNG(yy_text);
3096
3097 /* Unclosed single quotes; treat similar to double quotes, but without a separate token
3098 * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
3099 * rule, which continued in ST_IN_SCRIPTING state after the quote */
3100 ZVAL_NULL(zendlval);
3101 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
3102 }
3103 }
3104
3105 if (yyleng-bprefix-2 <= 1) {
3106 if (yyleng-bprefix-2 < 1) {
3107 ZVAL_EMPTY_STRING(zendlval);
3108 } else {
3109 zend_uchar c = (zend_uchar)*(yytext+bprefix+1);
3110 if (c == '\n' || c == '\r') {
3111 CG(zend_lineno)++;
3112 }
3113 ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR(c));
3114 }
3115 goto skip_escape_conversion;
3116 }
3117 ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2);
3118
3119 /* convert escape sequences */
3120 s = Z_STRVAL_P(zendlval);
3121 end = s+Z_STRLEN_P(zendlval);
3122 while (1) {
3123 if (UNEXPECTED(*s=='\\')) {
3124 break;
3125 }
3126 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
3127 CG(zend_lineno)++;
3128 }
3129 s++;
3130 if (s == end) {
3131 goto skip_escape_conversion;
3132 }
3133 }
3134
3135 t = s;
3136 while (s<end) {
3137 if (*s=='\\') {
3138 s++;
3139 if (*s == '\\' || *s == '\'') {
3140 *t++ = *s;
3141 } else {
3142 *t++ = '\\';
3143 *t++ = *s;
3144 }
3145 } else {
3146 *t++ = *s;
3147 }
3148 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
3149 CG(zend_lineno)++;
3150 }
3151 s++;
3152 }
3153 *t = 0;
3154 Z_STRLEN_P(zendlval) = t - Z_STRVAL_P(zendlval);
3155
3156 skip_escape_conversion:
3157 if (SCNG(output_filter)) {
3158 size_t sz = 0;
3159 char *str = NULL;
3160 zend_string *new_str;
3161 s = Z_STRVAL_P(zendlval);
3162 // TODO: avoid reallocation ???
3163 SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval));
3164 new_str = zend_string_init(str, sz, 0);
3165 if (str != s) {
3166 efree(str);
3167 }
3168 zend_string_release_ex(Z_STR_P(zendlval), 0);
3169 ZVAL_STR(zendlval, new_str);
3170 }
3171 RETURN_TOKEN_WITH_VAL(T_CONSTANT_ENCAPSED_STRING);
3172 }
3173 yy155:
3174 YYDEBUG(155, *YYCURSOR);
3175 ++YYCURSOR;
3176 yy156:
3177 YYDEBUG(156, *YYCURSOR);
3178 yyleng = YYCURSOR - SCNG(yy_text);
3179 {
3180 int bprefix = (yytext[0] != '"') ? 1 : 0;
3181
3182 while (YYCURSOR < YYLIMIT) {
3183 switch (*YYCURSOR++) {
3184 case '"':
3185 yyleng = YYCURSOR - SCNG(yy_text);
3186 if (EXPECTED(zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"') == SUCCESS)
3187 || !PARSER_MODE()) {
3188 RETURN_TOKEN_WITH_VAL(T_CONSTANT_ENCAPSED_STRING);
3189 } else {
3190 RETURN_TOKEN(T_ERROR);
3191 }
3192 case '$':
3193 if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
3194 break;
3195 }
3196 continue;
3197 case '{':
3198 if (*YYCURSOR == '$') {
3199 break;
3200 }
3201 continue;
3202 case '\\':
3203 if (YYCURSOR < YYLIMIT) {
3204 YYCURSOR++;
3205 }
3206 /* fall through */
3207 default:
3208 continue;
3209 }
3210
3211 YYCURSOR--;
3212 break;
3213 }
3214
3215 /* Remember how much was scanned to save rescanning */
3216 SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
3217
3218 YYCURSOR = SCNG(yy_text) + yyleng;
3219
3220 BEGIN(ST_DOUBLE_QUOTES);
3221 RETURN_TOKEN('"');
3222 }
3223 yy157:
3224 YYDEBUG(157, *YYCURSOR);
3225 ++YYCURSOR;
3226 YYDEBUG(158, *YYCURSOR);
3227 yyleng = YYCURSOR - SCNG(yy_text);
3228 {
3229 BEGIN(ST_BACKQUOTE);
3230 RETURN_TOKEN('`');
3231 }
3232 yy159:
3233 YYDEBUG(159, *YYCURSOR);
3234 ++YYCURSOR;
3235 YYDEBUG(160, *YYCURSOR);
3236 yyleng = YYCURSOR - SCNG(yy_text);
3237 {
3238 if (YYCURSOR > YYLIMIT) {
3239 RETURN_TOKEN(END);
3240 }
3241
3242 if (!SCNG(heredoc_scan_ahead)) {
3243 zend_error(E_COMPILE_WARNING, "Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
3244 }
3245 if (PARSER_MODE()) {
3246 goto restart;
3247 } else {
3248 RETURN_TOKEN(T_BAD_CHARACTER);
3249 }
3250 }
3251 yy161:
3252 YYDEBUG(161, *YYCURSOR);
3253 ++YYCURSOR;
3254 YYFILL(1);
3255 yych = *YYCURSOR;
3256 yy162:
3257 YYDEBUG(162, *YYCURSOR);
3258 if (yybm[0+yych] & 4) {
3259 goto yy161;
3260 }
3261 goto yy99;
3262 yy163:
3263 YYDEBUG(163, *YYCURSOR);
3264 ++YYCURSOR;
3265 YYFILL(1);
3266 yych = *YYCURSOR;
3267 if (yych <= '/') goto yy164;
3268 if (yych <= '9') goto yy181;
3269 yy164:
3270 YYDEBUG(164, *YYCURSOR);
3271 YYCURSOR = YYMARKER;
3272 if (yyaccept <= 4) {
3273 if (yyaccept <= 2) {
3274 if (yyaccept <= 1) {
3275 if (yyaccept <= 0) {
3276 goto yy99;
3277 } else {
3278 goto yy114;
3279 }
3280 } else {
3281 goto yy148;
3282 }
3283 } else {
3284 if (yyaccept <= 3) {
3285 goto yy166;
3286 } else {
3287 goto yy187;
3288 }
3289 }
3290 } else {
3291 if (yyaccept <= 6) {
3292 if (yyaccept <= 5) {
3293 goto yy193;
3294 } else {
3295 goto yy218;
3296 }
3297 } else {
3298 if (yyaccept <= 7) {
3299 goto yy238;
3300 } else {
3301 goto yy638;
3302 }
3303 }
3304 }
3305 yy165:
3306 YYDEBUG(165, *YYCURSOR);
3307 yyaccept = 3;
3308 yych = *(YYMARKER = ++YYCURSOR);
3309 if (yych != '_') goto yy177;
3310 yy166:
3311 YYDEBUG(166, *YYCURSOR);
3312 yyleng = YYCURSOR - SCNG(yy_text);
3313 {
3314 const char *end;
3315 size_t len = yyleng;
3316 char *dnum = yytext;
3317 zend_bool contains_underscores = (memchr(dnum, '_', len) != NULL);
3318
3319 if (contains_underscores) {
3320 dnum = estrndup(dnum, len);
3321 strip_underscores(dnum, &len);
3322 }
3323
3324 ZVAL_DOUBLE(zendlval, zend_strtod(dnum, &end));
3325 /* errno isn't checked since we allow HUGE_VAL/INF overflow */
3326 ZEND_ASSERT(end == dnum + len);
3327 if (contains_underscores) {
3328 efree(dnum);
3329 }
3330 RETURN_TOKEN_WITH_VAL(T_DNUMBER);
3331 }
3332 yy167:
3333 YYDEBUG(167, *YYCURSOR);
3334 yyaccept = 2;
3335 YYMARKER = ++YYCURSOR;
3336 YYFILL(4);
3337 yych = *YYCURSOR;
3338 yy168:
3339 YYDEBUG(168, *YYCURSOR);
3340 if (yybm[0+yych] & 8) {
3341 goto yy167;
3342 }
3343 if (yych <= 'E') {
3344 if (yych == '.') goto yy165;
3345 if (yych <= 'D') goto yy148;
3346 } else {
3347 if (yych <= '_') {
3348 if (yych <= '^') goto yy148;
3349 goto yy163;
3350 } else {
3351 if (yych != 'e') goto yy148;
3352 }
3353 }
3354 yy169:
3355 YYDEBUG(169, *YYCURSOR);
3356 yych = *++YYCURSOR;
3357 if (yych <= ',') {
3358 if (yych != '+') goto yy164;
3359 } else {
3360 if (yych <= '-') goto yy170;
3361 if (yych <= '/') goto yy164;
3362 if (yych <= '9') goto yy171;
3363 goto yy164;
3364 }
3365 yy170:
3366 YYDEBUG(170, *YYCURSOR);
3367 yych = *++YYCURSOR;
3368 if (yych <= '/') goto yy164;
3369 if (yych >= ':') goto yy164;
3370 yy171:
3371 YYDEBUG(171, *YYCURSOR);
3372 yyaccept = 3;
3373 YYMARKER = ++YYCURSOR;
3374 YYFILL(1);
3375 yych = *YYCURSOR;
3376 YYDEBUG(172, *YYCURSOR);
3377 if (yych <= '/') goto yy166;
3378 if (yych <= '9') goto yy171;
3379 if (yych != '_') goto yy166;
3380 yy173:
3381 YYDEBUG(173, *YYCURSOR);
3382 ++YYCURSOR;
3383 YYFILL(1);
3384 yych = *YYCURSOR;
3385 if (yych <= '/') goto yy164;
3386 if (yych >= ':') goto yy164;
3387 yy174:
3388 YYDEBUG(174, *YYCURSOR);
3389 yyaccept = 3;
3390 YYMARKER = ++YYCURSOR;
3391 YYFILL(1);
3392 yych = *YYCURSOR;
3393 YYDEBUG(175, *YYCURSOR);
3394 if (yych <= '/') goto yy166;
3395 if (yych <= '9') goto yy174;
3396 if (yych == '_') goto yy173;
3397 goto yy166;
3398 yy176:
3399 YYDEBUG(176, *YYCURSOR);
3400 yyaccept = 3;
3401 YYMARKER = ++YYCURSOR;
3402 YYFILL(3);
3403 yych = *YYCURSOR;
3404 yy177:
3405 YYDEBUG(177, *YYCURSOR);
3406 if (yych <= 'E') {
3407 if (yych <= '/') goto yy166;
3408 if (yych <= '9') goto yy176;
3409 if (yych <= 'D') goto yy166;
3410 goto yy169;
3411 } else {
3412 if (yych <= '_') {
3413 if (yych <= '^') goto yy166;
3414 } else {
3415 if (yych == 'e') goto yy169;
3416 goto yy166;
3417 }
3418 }
3419 yy178:
3420 YYDEBUG(178, *YYCURSOR);
3421 ++YYCURSOR;
3422 YYFILL(1);
3423 yych = *YYCURSOR;
3424 if (yych <= '/') goto yy164;
3425 if (yych >= ':') goto yy164;
3426 yy179:
3427 YYDEBUG(179, *YYCURSOR);
3428 yyaccept = 3;
3429 YYMARKER = ++YYCURSOR;
3430 YYFILL(3);
3431 yych = *YYCURSOR;
3432 YYDEBUG(180, *YYCURSOR);
3433 if (yych <= 'E') {
3434 if (yych <= '/') goto yy166;
3435 if (yych <= '9') goto yy179;
3436 if (yych <= 'D') goto yy166;
3437 goto yy169;
3438 } else {
3439 if (yych <= '_') {
3440 if (yych <= '^') goto yy166;
3441 goto yy178;
3442 } else {
3443 if (yych == 'e') goto yy169;
3444 goto yy166;
3445 }
3446 }
3447 yy181:
3448 YYDEBUG(181, *YYCURSOR);
3449 yyaccept = 2;
3450 YYMARKER = ++YYCURSOR;
3451 YYFILL(4);
3452 yych = *YYCURSOR;
3453 YYDEBUG(182, *YYCURSOR);
3454 if (yych <= 'D') {
3455 if (yych <= '.') {
3456 if (yych <= '-') goto yy148;
3457 goto yy165;
3458 } else {
3459 if (yych <= '/') goto yy148;
3460 if (yych <= '9') goto yy181;
3461 goto yy148;
3462 }
3463 } else {
3464 if (yych <= '_') {
3465 if (yych <= 'E') goto yy169;
3466 if (yych <= '^') goto yy148;
3467 goto yy163;
3468 } else {
3469 if (yych == 'e') goto yy169;
3470 goto yy148;
3471 }
3472 }
3473 yy183:
3474 YYDEBUG(183, *YYCURSOR);
3475 yych = *++YYCURSOR;
3476 if (yybm[0+yych] & 32) {
3477 goto yy191;
3478 }
3479 goto yy164;
3480 yy184:
3481 YYDEBUG(184, *YYCURSOR);
3482 yych = *++YYCURSOR;
3483 if (yybm[0+yych] & 16) {
3484 goto yy185;
3485 }
3486 goto yy164;
3487 yy185:
3488 YYDEBUG(185, *YYCURSOR);
3489 yyaccept = 4;
3490 YYMARKER = ++YYCURSOR;
3491 YYFILL(1);
3492 yych = *YYCURSOR;
3493 YYDEBUG(186, *YYCURSOR);
3494 if (yybm[0+yych] & 16) {
3495 goto yy185;
3496 }
3497 if (yych == '_') goto yy188;
3498 yy187:
3499 YYDEBUG(187, *YYCURSOR);
3500 yyleng = YYCURSOR - SCNG(yy_text);
3501 {
3502 /* The +/- 2 skips "0b" */
3503 size_t len = yyleng - 2;
3504 char *end, *bin = yytext + 2;
3505 zend_bool contains_underscores;
3506
3507 /* Skip any leading 0s */
3508 while (len > 0 && (*bin == '0' || *bin == '_')) {
3509 ++bin;
3510 --len;
3511 }
3512
3513 contains_underscores = (memchr(bin, '_', len) != NULL);
3514
3515 if (contains_underscores) {
3516 bin = estrndup(bin, len);
3517 strip_underscores(bin, &len);
3518 }
3519
3520 if (len < SIZEOF_ZEND_LONG * 8) {
3521 if (len == 0) {
3522 ZVAL_LONG(zendlval, 0);
3523 } else {
3524 errno = 0;
3525 ZVAL_LONG(zendlval, ZEND_STRTOL(bin, &end, 2));
3526 ZEND_ASSERT(!errno && end == bin + len);
3527 }
3528 if (contains_underscores) {
3529 efree(bin);
3530 }
3531 RETURN_TOKEN_WITH_VAL(T_LNUMBER);
3532 } else {
3533 ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, (const char **)&end));
3534 /* errno isn't checked since we allow HUGE_VAL/INF overflow */
3535 ZEND_ASSERT(end == bin + len);
3536 if (contains_underscores) {
3537 efree(bin);
3538 }
3539 RETURN_TOKEN_WITH_VAL(T_DNUMBER);
3540 }
3541 }
3542 yy188:
3543 YYDEBUG(188, *YYCURSOR);
3544 ++YYCURSOR;
3545 YYFILL(1);
3546 yych = *YYCURSOR;
3547 if (yych <= '/') goto yy164;
3548 if (yych >= '2') goto yy164;
3549 yy189:
3550 YYDEBUG(189, *YYCURSOR);
3551 yyaccept = 4;
3552 YYMARKER = ++YYCURSOR;
3553 YYFILL(1);
3554 yych = *YYCURSOR;
3555 YYDEBUG(190, *YYCURSOR);
3556 if (yych <= '/') goto yy187;
3557 if (yych <= '1') goto yy189;
3558 if (yych == '_') goto yy188;
3559 goto yy187;
3560 yy191:
3561 YYDEBUG(191, *YYCURSOR);
3562 yyaccept = 5;
3563 YYMARKER = ++YYCURSOR;
3564 YYFILL(1);
3565 yych = *YYCURSOR;
3566 YYDEBUG(192, *YYCURSOR);
3567 if (yybm[0+yych] & 32) {
3568 goto yy191;
3569 }
3570 if (yych == '_') goto yy194;
3571 yy193:
3572 YYDEBUG(193, *YYCURSOR);
3573 yyleng = YYCURSOR - SCNG(yy_text);
3574 {
3575 /* The +/- 2 skips "0x" */
3576 size_t len = yyleng - 2;
3577 char *end, *hex = yytext + 2;
3578 zend_bool contains_underscores;
3579
3580 /* Skip any leading 0s */
3581 while (len > 0 && (*hex == '0' || *hex == '_')) {
3582 ++hex;
3583 --len;
3584 }
3585
3586 contains_underscores = (memchr(hex, '_', len) != NULL);
3587
3588 if (contains_underscores) {
3589 hex = estrndup(hex, len);
3590 strip_underscores(hex, &len);
3591 }
3592
3593 if (len < SIZEOF_ZEND_LONG * 2 || (len == SIZEOF_ZEND_LONG * 2 && *hex <= '7')) {
3594 if (len == 0) {
3595 ZVAL_LONG(zendlval, 0);
3596 } else {
3597 errno = 0;
3598 ZVAL_LONG(zendlval, ZEND_STRTOL(hex, &end, 16));
3599 ZEND_ASSERT(!errno && end == hex + len);
3600 }
3601 if (contains_underscores) {
3602 efree(hex);
3603 }
3604 RETURN_TOKEN_WITH_VAL(T_LNUMBER);
3605 } else {
3606 ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, (const char **)&end));
3607 /* errno isn't checked since we allow HUGE_VAL/INF overflow */
3608 ZEND_ASSERT(end == hex + len);
3609 if (contains_underscores) {
3610 efree(hex);
3611 }
3612 RETURN_TOKEN_WITH_VAL(T_DNUMBER);
3613 }
3614 }
3615 yy194:
3616 YYDEBUG(194, *YYCURSOR);
3617 ++YYCURSOR;
3618 YYFILL(1);
3619 yych = *YYCURSOR;
3620 if (yych <= '@') {
3621 if (yych <= '/') goto yy164;
3622 if (yych >= ':') goto yy164;
3623 } else {
3624 if (yych <= 'F') goto yy195;
3625 if (yych <= '`') goto yy164;
3626 if (yych >= 'g') goto yy164;
3627 }
3628 yy195:
3629 YYDEBUG(195, *YYCURSOR);
3630 yyaccept = 5;
3631 YYMARKER = ++YYCURSOR;
3632 YYFILL(1);
3633 yych = *YYCURSOR;
3634 YYDEBUG(196, *YYCURSOR);
3635 if (yych <= 'F') {
3636 if (yych <= '/') goto yy193;
3637 if (yych <= '9') goto yy195;
3638 if (yych <= '@') goto yy193;
3639 goto yy195;
3640 } else {
3641 if (yych <= '_') {
3642 if (yych <= '^') goto yy193;
3643 goto yy194;
3644 } else {
3645 if (yych <= '`') goto yy193;
3646 if (yych <= 'f') goto yy195;
3647 goto yy193;
3648 }
3649 }
3650 yy197:
3651 YYDEBUG(197, *YYCURSOR);
3652 ++YYCURSOR;
3653 YYFILL(1);
3654 yych = *YYCURSOR;
3655 YYDEBUG(198, *YYCURSOR);
3656 if (yych <= '^') {
3657 if (yych <= '9') {
3658 if (yych >= '0') goto yy197;
3659 } else {
3660 if (yych <= '@') goto yy199;
3661 if (yych <= 'Z') goto yy197;
3662 }
3663 } else {
3664 if (yych <= '`') {
3665 if (yych <= '_') goto yy197;
3666 } else {
3667 if (yych <= 'z') goto yy197;
3668 if (yych >= 0x80) goto yy197;
3669 }
3670 }
3671 yy199:
3672 YYDEBUG(199, *YYCURSOR);
3673 yyleng = YYCURSOR - SCNG(yy_text);
3674 {
3675 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
3676 }
3677 yy200:
3678 YYDEBUG(200, *YYCURSOR);
3679 yych = *++YYCURSOR;
3680 if (yych == 'R') goto yy201;
3681 if (yych != 'r') goto yy162;
3682 yy201:
3683 YYDEBUG(201, *YYCURSOR);
3684 ++YYCURSOR;
3685 if (yybm[0+(yych = *YYCURSOR)] & 4) {
3686 goto yy161;
3687 }
3688 YYDEBUG(202, *YYCURSOR);
3689 yyleng = YYCURSOR - SCNG(yy_text);
3690 {
3691 RETURN_TOKEN(T_LOGICAL_XOR);
3692 }
3693 yy203:
3694 YYDEBUG(203, *YYCURSOR);
3695 ++YYCURSOR;
3696 if (yybm[0+(yych = *YYCURSOR)] & 4) {
3697 goto yy161;
3698 }
3699 YYDEBUG(204, *YYCURSOR);
3700 yyleng = YYCURSOR - SCNG(yy_text);
3701 {
3702 RETURN_TOKEN(T_LOGICAL_OR);
3703 }
3704 yy205:
3705 YYDEBUG(205, *YYCURSOR);
3706 ++YYCURSOR;
3707 YYDEBUG(206, *YYCURSOR);
3708 yyleng = YYCURSOR - SCNG(yy_text);
3709 {
3710 RETURN_TOKEN(T_XOR_EQUAL);
3711 }
3712 yy207:
3713 YYDEBUG(207, *YYCURSOR);
3714 ++YYCURSOR;
3715 YYDEBUG(208, *YYCURSOR);
3716 yyleng = YYCURSOR - SCNG(yy_text);
3717 {
3718 RETURN_TOKEN(T_BOOLEAN_OR);
3719 }
3720 yy209:
3721 YYDEBUG(209, *YYCURSOR);
3722 ++YYCURSOR;
3723 YYDEBUG(210, *YYCURSOR);
3724 yyleng = YYCURSOR - SCNG(yy_text);
3725 {
3726 RETURN_TOKEN(T_OR_EQUAL);
3727 }
3728 yy211:
3729 YYDEBUG(211, *YYCURSOR);
3730 ++YYCURSOR;
3731 YYDEBUG(212, *YYCURSOR);
3732 yyleng = YYCURSOR - SCNG(yy_text);
3733 {
3734 RETURN_TOKEN(T_BOOLEAN_AND);
3735 }
3736 yy213:
3737 YYDEBUG(213, *YYCURSOR);
3738 ++YYCURSOR;
3739 YYDEBUG(214, *YYCURSOR);
3740 yyleng = YYCURSOR - SCNG(yy_text);
3741 {
3742 RETURN_TOKEN(T_AND_EQUAL);
3743 }
3744 yy215:
3745 YYDEBUG(215, *YYCURSOR);
3746 ++YYCURSOR;
3747 YYDEBUG(216, *YYCURSOR);
3748 yyleng = YYCURSOR - SCNG(yy_text);
3749 {
3750 RETURN_TOKEN(T_MOD_EQUAL);
3751 }
3752 yy217:
3753 YYDEBUG(217, *YYCURSOR);
3754 yyaccept = 6;
3755 yych = *(YYMARKER = ++YYCURSOR);
3756 if (yych == '*') goto yy222;
3757 yy218:
3758 YYDEBUG(218, *YYCURSOR);
3759 yyleng = YYCURSOR - SCNG(yy_text);
3760 {
3761 int doc_com;
3762
3763 if (yyleng > 2) {
3764 doc_com = 1;
3765 RESET_DOC_COMMENT();
3766 } else {
3767 doc_com = 0;
3768 }
3769
3770 while (YYCURSOR < YYLIMIT) {
3771 if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
3772 break;
3773 }
3774 }
3775
3776 if (YYCURSOR < YYLIMIT) {
3777 YYCURSOR++;
3778 } else if (!SCNG(heredoc_scan_ahead)) {
3779 zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
3780 }
3781
3782 yyleng = YYCURSOR - SCNG(yy_text);
3783 HANDLE_NEWLINES(yytext, yyleng);
3784
3785 if (doc_com) {
3786 CG(doc_comment) = zend_string_init(yytext, yyleng, 0);
3787 RETURN_OR_SKIP_TOKEN(T_DOC_COMMENT);
3788 }
3789
3790 RETURN_OR_SKIP_TOKEN(T_COMMENT);
3791 }
3792 yy219:
3793 YYDEBUG(219, *YYCURSOR);
3794 yych = *++YYCURSOR;
3795 goto yy152;
3796 yy220:
3797 YYDEBUG(220, *YYCURSOR);
3798 ++YYCURSOR;
3799 YYDEBUG(221, *YYCURSOR);
3800 yyleng = YYCURSOR - SCNG(yy_text);
3801 {
3802 RETURN_TOKEN(T_DIV_EQUAL);
3803 }
3804 yy222:
3805 YYDEBUG(222, *YYCURSOR);
3806 yych = *++YYCURSOR;
3807 if (yybm[0+yych] & 64) {
3808 goto yy223;
3809 }
3810 goto yy164;
3811 yy223:
3812 YYDEBUG(223, *YYCURSOR);
3813 ++YYCURSOR;
3814 YYFILL(1);
3815 yych = *YYCURSOR;
3816 YYDEBUG(224, *YYCURSOR);
3817 if (yybm[0+yych] & 64) {
3818 goto yy223;
3819 }
3820 goto yy218;
3821 yy225:
3822 YYDEBUG(225, *YYCURSOR);
3823 ++YYCURSOR;
3824 if ((yych = *YYCURSOR) == '=') goto yy229;
3825 YYDEBUG(226, *YYCURSOR);
3826 yyleng = YYCURSOR - SCNG(yy_text);
3827 {
3828 RETURN_TOKEN(T_POW);
3829 }
3830 yy227:
3831 YYDEBUG(227, *YYCURSOR);
3832 ++YYCURSOR;
3833 YYDEBUG(228, *YYCURSOR);
3834 yyleng = YYCURSOR - SCNG(yy_text);
3835 {
3836 RETURN_TOKEN(T_MUL_EQUAL);
3837 }
3838 yy229:
3839 YYDEBUG(229, *YYCURSOR);
3840 ++YYCURSOR;
3841 YYDEBUG(230, *YYCURSOR);
3842 yyleng = YYCURSOR - SCNG(yy_text);
3843 {
3844 RETURN_TOKEN(T_POW_EQUAL);
3845 }
3846 yy231:
3847 YYDEBUG(231, *YYCURSOR);
3848 ++YYCURSOR;
3849 if ((yych = *YYCURSOR) == '=') goto yy235;
3850 YYDEBUG(232, *YYCURSOR);
3851 yyleng = YYCURSOR - SCNG(yy_text);
3852 {
3853 RETURN_TOKEN(T_SR);
3854 }
3855 yy233:
3856 YYDEBUG(233, *YYCURSOR);
3857 ++YYCURSOR;
3858 YYDEBUG(234, *YYCURSOR);
3859 yyleng = YYCURSOR - SCNG(yy_text);
3860 {
3861 RETURN_TOKEN(T_IS_GREATER_OR_EQUAL);
3862 }
3863 yy235:
3864 YYDEBUG(235, *YYCURSOR);
3865 ++YYCURSOR;
3866 YYDEBUG(236, *YYCURSOR);
3867 yyleng = YYCURSOR - SCNG(yy_text);
3868 {
3869 RETURN_TOKEN(T_SR_EQUAL);
3870 }
3871 yy237:
3872 YYDEBUG(237, *YYCURSOR);
3873 yyaccept = 7;
3874 yych = *(YYMARKER = ++YYCURSOR);
3875 if (yych <= ';') goto yy238;
3876 if (yych <= '<') goto yy247;
3877 if (yych <= '=') goto yy245;
3878 yy238:
3879 YYDEBUG(238, *YYCURSOR);
3880 yyleng = YYCURSOR - SCNG(yy_text);
3881 {
3882 RETURN_TOKEN(T_SL);
3883 }
3884 yy239:
3885 YYDEBUG(239, *YYCURSOR);
3886 ++YYCURSOR;
3887 if ((yych = *YYCURSOR) == '>') goto yy243;
3888 YYDEBUG(240, *YYCURSOR);
3889 yyleng = YYCURSOR - SCNG(yy_text);
3890 {
3891 RETURN_TOKEN(T_IS_SMALLER_OR_EQUAL);
3892 }
3893 yy241:
3894 YYDEBUG(241, *YYCURSOR);
3895 ++YYCURSOR;
3896 yy242:
3897 YYDEBUG(242, *YYCURSOR);
3898 yyleng = YYCURSOR - SCNG(yy_text);
3899 {
3900 RETURN_TOKEN(T_IS_NOT_EQUAL);
3901 }
3902 yy243:
3903 YYDEBUG(243, *YYCURSOR);
3904 ++YYCURSOR;
3905 YYDEBUG(244, *YYCURSOR);
3906 yyleng = YYCURSOR - SCNG(yy_text);
3907 {
3908 RETURN_TOKEN(T_SPACESHIP);
3909 }
3910 yy245:
3911 YYDEBUG(245, *YYCURSOR);
3912 ++YYCURSOR;
3913 YYDEBUG(246, *YYCURSOR);
3914 yyleng = YYCURSOR - SCNG(yy_text);
3915 {
3916 RETURN_TOKEN(T_SL_EQUAL);
3917 }
3918 yy247:
3919 YYDEBUG(247, *YYCURSOR);
3920 ++YYCURSOR;
3921 YYFILL(2);
3922 yych = *YYCURSOR;
3923 YYDEBUG(248, *YYCURSOR);
3924 if (yybm[0+yych] & 128) {
3925 goto yy247;
3926 }
3927 if (yych <= 'Z') {
3928 if (yych <= '&') {
3929 if (yych == '"') goto yy252;
3930 goto yy164;
3931 } else {
3932 if (yych <= '\'') goto yy251;
3933 if (yych <= '@') goto yy164;
3934 }
3935 } else {
3936 if (yych <= '`') {
3937 if (yych != '_') goto yy164;
3938 } else {
3939 if (yych <= 'z') goto yy249;
3940 if (yych <= 0x7F) goto yy164;
3941 }
3942 }
3943 yy249:
3944 YYDEBUG(249, *YYCURSOR);
3945 ++YYCURSOR;
3946 YYFILL(2);
3947 yych = *YYCURSOR;
3948 YYDEBUG(250, *YYCURSOR);
3949 if (yych <= '@') {
3950 if (yych <= '\f') {
3951 if (yych == '\n') goto yy256;
3952 goto yy164;
3953 } else {
3954 if (yych <= '\r') goto yy258;
3955 if (yych <= '/') goto yy164;
3956 if (yych <= '9') goto yy249;
3957 goto yy164;
3958 }
3959 } else {
3960 if (yych <= '_') {
3961 if (yych <= 'Z') goto yy249;
3962 if (yych <= '^') goto yy164;
3963 goto yy249;
3964 } else {
3965 if (yych <= '`') goto yy164;
3966 if (yych <= 'z') goto yy249;
3967 if (yych <= 0x7F) goto yy164;
3968 goto yy249;
3969 }
3970 }
3971 yy251:
3972 YYDEBUG(251, *YYCURSOR);
3973 yych = *++YYCURSOR;
3974 if (yych == '\'') goto yy164;
3975 if (yych <= '/') goto yy260;
3976 if (yych <= '9') goto yy164;
3977 goto yy260;
3978 yy252:
3979 YYDEBUG(252, *YYCURSOR);
3980 yych = *++YYCURSOR;
3981 if (yych == '"') goto yy164;
3982 if (yych <= '/') goto yy254;
3983 if (yych <= '9') goto yy164;
3984 goto yy254;
3985 yy253:
3986 YYDEBUG(253, *YYCURSOR);
3987 ++YYCURSOR;
3988 YYFILL(3);
3989 yych = *YYCURSOR;
3990 yy254:
3991 YYDEBUG(254, *YYCURSOR);
3992 if (yych <= 'Z') {
3993 if (yych <= '/') {
3994 if (yych != '"') goto yy164;
3995 } else {
3996 if (yych <= '9') goto yy253;
3997 if (yych <= '@') goto yy164;
3998 goto yy253;
3999 }
4000 } else {
4001 if (yych <= '`') {
4002 if (yych == '_') goto yy253;
4003 goto yy164;
4004 } else {
4005 if (yych <= 'z') goto yy253;
4006 if (yych <= 0x7F) goto yy164;
4007 goto yy253;
4008 }
4009 }
4010 yy255:
4011 YYDEBUG(255, *YYCURSOR);
4012 yych = *++YYCURSOR;
4013 if (yych == '\n') goto yy256;
4014 if (yych == '\r') goto yy258;
4015 goto yy164;
4016 yy256:
4017 YYDEBUG(256, *YYCURSOR);
4018 ++YYCURSOR;
4019 yy257:
4020 YYDEBUG(257, *YYCURSOR);
4021 yyleng = YYCURSOR - SCNG(yy_text);
4022 {
4023 char *s;
4024 unsigned char *saved_cursor;
4025 int bprefix = (yytext[0] != '<') ? 1 : 0, spacing = 0, indentation = 0;
4026 zend_heredoc_label *heredoc_label = emalloc(sizeof(zend_heredoc_label));
4027 zend_bool is_heredoc = 1;
4028
4029 CG(zend_lineno)++;
4030 heredoc_label->length = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
4031 s = yytext+bprefix+3;
4032 while ((*s == ' ') || (*s == '\t')) {
4033 s++;
4034 heredoc_label->length--;
4035 }
4036
4037 if (*s == '\'') {
4038 s++;
4039 heredoc_label->length -= 2;
4040 is_heredoc = 0;
4041
4042 BEGIN(ST_NOWDOC);
4043 } else {
4044 if (*s == '"') {
4045 s++;
4046 heredoc_label->length -= 2;
4047 }
4048
4049 BEGIN(ST_HEREDOC);
4050 }
4051
4052 heredoc_label->label = estrndup(s, heredoc_label->length);
4053 heredoc_label->indentation = 0;
4054 saved_cursor = YYCURSOR;
4055
4056 zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label);
4057
4058 while (YYCURSOR < YYLIMIT && (*YYCURSOR == ' ' || *YYCURSOR == '\t')) {
4059 if (*YYCURSOR == '\t') {
4060 spacing |= HEREDOC_USING_TABS;
4061 } else {
4062 spacing |= HEREDOC_USING_SPACES;
4063 }
4064 ++YYCURSOR;
4065 ++indentation;
4066 }
4067
4068 if (YYCURSOR == YYLIMIT) {
4069 YYCURSOR = saved_cursor;
4070 RETURN_TOKEN(T_START_HEREDOC);
4071 }
4072
4073 /* Check for ending label on the next line */
4074 if (heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, heredoc_label->length)) {
4075 if (!IS_LABEL_SUCCESSOR(YYCURSOR[heredoc_label->length])) {
4076 if (spacing == (HEREDOC_USING_SPACES | HEREDOC_USING_TABS)) {
4077 zend_throw_exception(zend_ce_parse_error, "Invalid indentation - tabs and spaces cannot be mixed", 0);
4078 if (PARSER_MODE()) {
4079 RETURN_TOKEN(T_ERROR);
4080 }
4081 }
4082
4083 YYCURSOR = saved_cursor;
4084 heredoc_label->indentation = indentation;
4085
4086 BEGIN(ST_END_HEREDOC);
4087 RETURN_TOKEN(T_START_HEREDOC);
4088 }
4089 }
4090
4091 YYCURSOR = saved_cursor;
4092
4093 if (is_heredoc && !SCNG(heredoc_scan_ahead)) {
4094 zend_lex_state current_state;
4095 zend_string *saved_doc_comment = CG(doc_comment);
4096 int heredoc_nesting_level = 1;
4097 int first_token = 0;
4098 int error = 0;
4099
4100 zend_save_lexical_state(¤t_state);
4101
4102 SCNG(heredoc_scan_ahead) = 1;
4103 SCNG(heredoc_indentation) = 0;
4104 SCNG(heredoc_indentation_uses_spaces) = 0;
4105 LANG_SCNG(on_event) = NULL;
4106 CG(doc_comment) = NULL;
4107
4108 zend_ptr_stack_reverse_apply(¤t_state.heredoc_label_stack, copy_heredoc_label_stack);
4109
4110 zend_exception_save();
4111 while (heredoc_nesting_level) {
4112 zval zv;
4113 int retval;
4114
4115 ZVAL_UNDEF(&zv);
4116 retval = lex_scan(&zv, NULL);
4117 zval_ptr_dtor_nogc(&zv);
4118
4119 if (EG(exception)) {
4120 zend_clear_exception();
4121 break;
4122 }
4123
4124 if (!first_token) {
4125 first_token = retval;
4126 }
4127
4128 switch (retval) {
4129 case T_START_HEREDOC:
4130 ++heredoc_nesting_level;
4131 break;
4132 case T_END_HEREDOC:
4133 --heredoc_nesting_level;
4134 break;
4135 case END:
4136 heredoc_nesting_level = 0;
4137 }
4138 }
4139 zend_exception_restore();
4140
4141 if (
4142 (first_token == T_VARIABLE
4143 || first_token == T_DOLLAR_OPEN_CURLY_BRACES
4144 || first_token == T_CURLY_OPEN
4145 ) && SCNG(heredoc_indentation)) {
4146 zend_throw_exception_ex(zend_ce_parse_error, 0, "Invalid body indentation level (expecting an indentation level of at least %d)", SCNG(heredoc_indentation));
4147 error = 1;
4148 }
4149
4150 heredoc_label->indentation = SCNG(heredoc_indentation);
4151 heredoc_label->indentation_uses_spaces = SCNG(heredoc_indentation_uses_spaces);
4152
4153 zend_restore_lexical_state(¤t_state);
4154 SCNG(heredoc_scan_ahead) = 0;
4155 CG(increment_lineno) = 0;
4156 CG(doc_comment) = saved_doc_comment;
4157
4158 if (PARSER_MODE() && error) {
4159 RETURN_TOKEN(T_ERROR);
4160 }
4161 }
4162
4163 RETURN_TOKEN(T_START_HEREDOC);
4164 }
4165 yy258:
4166 YYDEBUG(258, *YYCURSOR);
4167 yych = *++YYCURSOR;
4168 if (yych == '\n') goto yy256;
4169 goto yy257;
4170 yy259:
4171 YYDEBUG(259, *YYCURSOR);
4172 ++YYCURSOR;
4173 YYFILL(3);
4174 yych = *YYCURSOR;
4175 yy260:
4176 YYDEBUG(260, *YYCURSOR);
4177 if (yych <= 'Z') {
4178 if (yych <= '/') {
4179 if (yych == '\'') goto yy255;
4180 goto yy164;
4181 } else {
4182 if (yych <= '9') goto yy259;
4183 if (yych <= '@') goto yy164;
4184 goto yy259;
4185 }
4186 } else {
4187 if (yych <= '`') {
4188 if (yych == '_') goto yy259;
4189 goto yy164;
4190 } else {
4191 if (yych <= 'z') goto yy259;
4192 if (yych <= 0x7F) goto yy164;
4193 goto yy259;
4194 }
4195 }
4196 yy261:
4197 YYDEBUG(261, *YYCURSOR);
4198 yych = *++YYCURSOR;
4199 if (yych != '=') goto yy242;
4200 YYDEBUG(262, *YYCURSOR);
4201 ++YYCURSOR;
4202 YYDEBUG(263, *YYCURSOR);
4203 yyleng = YYCURSOR - SCNG(yy_text);
4204 {
4205 RETURN_TOKEN(T_IS_NOT_IDENTICAL);
4206 }
4207 yy264:
4208 YYDEBUG(264, *YYCURSOR);
4209 ++YYCURSOR;
4210 YYDEBUG(265, *YYCURSOR);
4211 yyleng = YYCURSOR - SCNG(yy_text);
4212 {
4213 RETURN_TOKEN(T_PLUS_EQUAL);
4214 }
4215 yy266:
4216 YYDEBUG(266, *YYCURSOR);
4217 ++YYCURSOR;
4218 YYDEBUG(267, *YYCURSOR);
4219 yyleng = YYCURSOR - SCNG(yy_text);
4220 {
4221 RETURN_TOKEN(T_INC);
4222 }
4223 yy268:
4224 YYDEBUG(268, *YYCURSOR);
4225 yych = *++YYCURSOR;
4226 if (yych == 'S') goto yy269;
4227 if (yych != 's') goto yy162;
4228 yy269:
4229 YYDEBUG(269, *YYCURSOR);
4230 yych = *++YYCURSOR;
4231 if (yych == 'T') goto yy270;
4232 if (yych != 't') goto yy162;
4233 yy270:
4234 YYDEBUG(270, *YYCURSOR);
4235 ++YYCURSOR;
4236 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4237 goto yy161;
4238 }
4239 YYDEBUG(271, *YYCURSOR);
4240 yyleng = YYCURSOR - SCNG(yy_text);
4241 {
4242 RETURN_TOKEN(T_LIST);
4243 }
4244 yy272:
4245 YYDEBUG(272, *YYCURSOR);
4246 ++YYCURSOR;
4247 if ((yych = *YYCURSOR) == '=') goto yy276;
4248 YYDEBUG(273, *YYCURSOR);
4249 yyleng = YYCURSOR - SCNG(yy_text);
4250 {
4251 RETURN_TOKEN(T_IS_EQUAL);
4252 }
4253 yy274:
4254 YYDEBUG(274, *YYCURSOR);
4255 ++YYCURSOR;
4256 YYDEBUG(275, *YYCURSOR);
4257 yyleng = YYCURSOR - SCNG(yy_text);
4258 {
4259 RETURN_TOKEN(T_DOUBLE_ARROW);
4260 }
4261 yy276:
4262 YYDEBUG(276, *YYCURSOR);
4263 ++YYCURSOR;
4264 YYDEBUG(277, *YYCURSOR);
4265 yyleng = YYCURSOR - SCNG(yy_text);
4266 {
4267 RETURN_TOKEN(T_IS_IDENTICAL);
4268 }
4269 yy278:
4270 YYDEBUG(278, *YYCURSOR);
4271 yych = *++YYCURSOR;
4272 YYDEBUG(-1, yych);
4273 switch (yych) {
4274 case 'C':
4275 case 'c': goto yy280;
4276 case 'D':
4277 case 'd': goto yy285;
4278 case 'F':
4279 case 'f': goto yy282;
4280 case 'H':
4281 case 'h': goto yy279;
4282 case 'L':
4283 case 'l': goto yy284;
4284 case 'M':
4285 case 'm': goto yy283;
4286 case 'N':
4287 case 'n': goto yy286;
4288 case 'T':
4289 case 't': goto yy281;
4290 default: goto yy162;
4291 }
4292 yy279:
4293 YYDEBUG(279, *YYCURSOR);
4294 yych = *++YYCURSOR;
4295 if (yych == 'A') goto yy347;
4296 if (yych == 'a') goto yy347;
4297 goto yy162;
4298 yy280:
4299 YYDEBUG(280, *YYCURSOR);
4300 yych = *++YYCURSOR;
4301 if (yych == 'L') goto yy340;
4302 if (yych == 'l') goto yy340;
4303 goto yy162;
4304 yy281:
4305 YYDEBUG(281, *YYCURSOR);
4306 yych = *++YYCURSOR;
4307 if (yych == 'R') goto yy333;
4308 if (yych == 'r') goto yy333;
4309 goto yy162;
4310 yy282:
4311 YYDEBUG(282, *YYCURSOR);
4312 yych = *++YYCURSOR;
4313 if (yych <= 'U') {
4314 if (yych == 'I') goto yy317;
4315 if (yych <= 'T') goto yy162;
4316 goto yy318;
4317 } else {
4318 if (yych <= 'i') {
4319 if (yych <= 'h') goto yy162;
4320 goto yy317;
4321 } else {
4322 if (yych == 'u') goto yy318;
4323 goto yy162;
4324 }
4325 }
4326 yy283:
4327 YYDEBUG(283, *YYCURSOR);
4328 yych = *++YYCURSOR;
4329 if (yych == 'E') goto yy309;
4330 if (yych == 'e') goto yy309;
4331 goto yy162;
4332 yy284:
4333 YYDEBUG(284, *YYCURSOR);
4334 yych = *++YYCURSOR;
4335 if (yych == 'I') goto yy303;
4336 if (yych == 'i') goto yy303;
4337 goto yy162;
4338 yy285:
4339 YYDEBUG(285, *YYCURSOR);
4340 yych = *++YYCURSOR;
4341 if (yych == 'I') goto yy298;
4342 if (yych == 'i') goto yy298;
4343 goto yy162;
4344 yy286:
4345 YYDEBUG(286, *YYCURSOR);
4346 yych = *++YYCURSOR;
4347 if (yych == 'A') goto yy287;
4348 if (yych != 'a') goto yy162;
4349 yy287:
4350 YYDEBUG(287, *YYCURSOR);
4351 yych = *++YYCURSOR;
4352 if (yych == 'M') goto yy288;
4353 if (yych != 'm') goto yy162;
4354 yy288:
4355 YYDEBUG(288, *YYCURSOR);
4356 yych = *++YYCURSOR;
4357 if (yych == 'E') goto yy289;
4358 if (yych != 'e') goto yy162;
4359 yy289:
4360 YYDEBUG(289, *YYCURSOR);
4361 yych = *++YYCURSOR;
4362 if (yych == 'S') goto yy290;
4363 if (yych != 's') goto yy162;
4364 yy290:
4365 YYDEBUG(290, *YYCURSOR);
4366 yych = *++YYCURSOR;
4367 if (yych == 'P') goto yy291;
4368 if (yych != 'p') goto yy162;
4369 yy291:
4370 YYDEBUG(291, *YYCURSOR);
4371 yych = *++YYCURSOR;
4372 if (yych == 'A') goto yy292;
4373 if (yych != 'a') goto yy162;
4374 yy292:
4375 YYDEBUG(292, *YYCURSOR);
4376 yych = *++YYCURSOR;
4377 if (yych == 'C') goto yy293;
4378 if (yych != 'c') goto yy162;
4379 yy293:
4380 YYDEBUG(293, *YYCURSOR);
4381 yych = *++YYCURSOR;
4382 if (yych == 'E') goto yy294;
4383 if (yych != 'e') goto yy162;
4384 yy294:
4385 YYDEBUG(294, *YYCURSOR);
4386 yych = *++YYCURSOR;
4387 if (yych != '_') goto yy162;
4388 YYDEBUG(295, *YYCURSOR);
4389 yych = *++YYCURSOR;
4390 if (yych != '_') goto yy162;
4391 YYDEBUG(296, *YYCURSOR);
4392 ++YYCURSOR;
4393 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4394 goto yy161;
4395 }
4396 YYDEBUG(297, *YYCURSOR);
4397 yyleng = YYCURSOR - SCNG(yy_text);
4398 {
4399 RETURN_TOKEN(T_NS_C);
4400 }
4401 yy298:
4402 YYDEBUG(298, *YYCURSOR);
4403 yych = *++YYCURSOR;
4404 if (yych == 'R') goto yy299;
4405 if (yych != 'r') goto yy162;
4406 yy299:
4407 YYDEBUG(299, *YYCURSOR);
4408 yych = *++YYCURSOR;
4409 if (yych != '_') goto yy162;
4410 YYDEBUG(300, *YYCURSOR);
4411 yych = *++YYCURSOR;
4412 if (yych != '_') goto yy162;
4413 YYDEBUG(301, *YYCURSOR);
4414 ++YYCURSOR;
4415 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4416 goto yy161;
4417 }
4418 YYDEBUG(302, *YYCURSOR);
4419 yyleng = YYCURSOR - SCNG(yy_text);
4420 {
4421 RETURN_TOKEN(T_DIR);
4422 }
4423 yy303:
4424 YYDEBUG(303, *YYCURSOR);
4425 yych = *++YYCURSOR;
4426 if (yych == 'N') goto yy304;
4427 if (yych != 'n') goto yy162;
4428 yy304:
4429 YYDEBUG(304, *YYCURSOR);
4430 yych = *++YYCURSOR;
4431 if (yych == 'E') goto yy305;
4432 if (yych != 'e') goto yy162;
4433 yy305:
4434 YYDEBUG(305, *YYCURSOR);
4435 yych = *++YYCURSOR;
4436 if (yych != '_') goto yy162;
4437 YYDEBUG(306, *YYCURSOR);
4438 yych = *++YYCURSOR;
4439 if (yych != '_') goto yy162;
4440 YYDEBUG(307, *YYCURSOR);
4441 ++YYCURSOR;
4442 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4443 goto yy161;
4444 }
4445 YYDEBUG(308, *YYCURSOR);
4446 yyleng = YYCURSOR - SCNG(yy_text);
4447 {
4448 RETURN_TOKEN(T_LINE);
4449 }
4450 yy309:
4451 YYDEBUG(309, *YYCURSOR);
4452 yych = *++YYCURSOR;
4453 if (yych == 'T') goto yy310;
4454 if (yych != 't') goto yy162;
4455 yy310:
4456 YYDEBUG(310, *YYCURSOR);
4457 yych = *++YYCURSOR;
4458 if (yych == 'H') goto yy311;
4459 if (yych != 'h') goto yy162;
4460 yy311:
4461 YYDEBUG(311, *YYCURSOR);
4462 yych = *++YYCURSOR;
4463 if (yych == 'O') goto yy312;
4464 if (yych != 'o') goto yy162;
4465 yy312:
4466 YYDEBUG(312, *YYCURSOR);
4467 yych = *++YYCURSOR;
4468 if (yych == 'D') goto yy313;
4469 if (yych != 'd') goto yy162;
4470 yy313:
4471 YYDEBUG(313, *YYCURSOR);
4472 yych = *++YYCURSOR;
4473 if (yych != '_') goto yy162;
4474 YYDEBUG(314, *YYCURSOR);
4475 yych = *++YYCURSOR;
4476 if (yych != '_') goto yy162;
4477 YYDEBUG(315, *YYCURSOR);
4478 ++YYCURSOR;
4479 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4480 goto yy161;
4481 }
4482 YYDEBUG(316, *YYCURSOR);
4483 yyleng = YYCURSOR - SCNG(yy_text);
4484 {
4485 RETURN_TOKEN(T_METHOD_C);
4486 }
4487 yy317:
4488 YYDEBUG(317, *YYCURSOR);
4489 yych = *++YYCURSOR;
4490 if (yych == 'L') goto yy328;
4491 if (yych == 'l') goto yy328;
4492 goto yy162;
4493 yy318:
4494 YYDEBUG(318, *YYCURSOR);
4495 yych = *++YYCURSOR;
4496 if (yych == 'N') goto yy319;
4497 if (yych != 'n') goto yy162;
4498 yy319:
4499 YYDEBUG(319, *YYCURSOR);
4500 yych = *++YYCURSOR;
4501 if (yych == 'C') goto yy320;
4502 if (yych != 'c') goto yy162;
4503 yy320:
4504 YYDEBUG(320, *YYCURSOR);
4505 yych = *++YYCURSOR;
4506 if (yych == 'T') goto yy321;
4507 if (yych != 't') goto yy162;
4508 yy321:
4509 YYDEBUG(321, *YYCURSOR);
4510 yych = *++YYCURSOR;
4511 if (yych == 'I') goto yy322;
4512 if (yych != 'i') goto yy162;
4513 yy322:
4514 YYDEBUG(322, *YYCURSOR);
4515 yych = *++YYCURSOR;
4516 if (yych == 'O') goto yy323;
4517 if (yych != 'o') goto yy162;
4518 yy323:
4519 YYDEBUG(323, *YYCURSOR);
4520 yych = *++YYCURSOR;
4521 if (yych == 'N') goto yy324;
4522 if (yych != 'n') goto yy162;
4523 yy324:
4524 YYDEBUG(324, *YYCURSOR);
4525 yych = *++YYCURSOR;
4526 if (yych != '_') goto yy162;
4527 YYDEBUG(325, *YYCURSOR);
4528 yych = *++YYCURSOR;
4529 if (yych != '_') goto yy162;
4530 YYDEBUG(326, *YYCURSOR);
4531 ++YYCURSOR;
4532 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4533 goto yy161;
4534 }
4535 YYDEBUG(327, *YYCURSOR);
4536 yyleng = YYCURSOR - SCNG(yy_text);
4537 {
4538 RETURN_TOKEN(T_FUNC_C);
4539 }
4540 yy328:
4541 YYDEBUG(328, *YYCURSOR);
4542 yych = *++YYCURSOR;
4543 if (yych == 'E') goto yy329;
4544 if (yych != 'e') goto yy162;
4545 yy329:
4546 YYDEBUG(329, *YYCURSOR);
4547 yych = *++YYCURSOR;
4548 if (yych != '_') goto yy162;
4549 YYDEBUG(330, *YYCURSOR);
4550 yych = *++YYCURSOR;
4551 if (yych != '_') goto yy162;
4552 YYDEBUG(331, *YYCURSOR);
4553 ++YYCURSOR;
4554 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4555 goto yy161;
4556 }
4557 YYDEBUG(332, *YYCURSOR);
4558 yyleng = YYCURSOR - SCNG(yy_text);
4559 {
4560 RETURN_TOKEN(T_FILE);
4561 }
4562 yy333:
4563 YYDEBUG(333, *YYCURSOR);
4564 yych = *++YYCURSOR;
4565 if (yych == 'A') goto yy334;
4566 if (yych != 'a') goto yy162;
4567 yy334:
4568 YYDEBUG(334, *YYCURSOR);
4569 yych = *++YYCURSOR;
4570 if (yych == 'I') goto yy335;
4571 if (yych != 'i') goto yy162;
4572 yy335:
4573 YYDEBUG(335, *YYCURSOR);
4574 yych = *++YYCURSOR;
4575 if (yych == 'T') goto yy336;
4576 if (yych != 't') goto yy162;
4577 yy336:
4578 YYDEBUG(336, *YYCURSOR);
4579 yych = *++YYCURSOR;
4580 if (yych != '_') goto yy162;
4581 YYDEBUG(337, *YYCURSOR);
4582 yych = *++YYCURSOR;
4583 if (yych != '_') goto yy162;
4584 YYDEBUG(338, *YYCURSOR);
4585 ++YYCURSOR;
4586 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4587 goto yy161;
4588 }
4589 YYDEBUG(339, *YYCURSOR);
4590 yyleng = YYCURSOR - SCNG(yy_text);
4591 {
4592 RETURN_TOKEN(T_TRAIT_C);
4593 }
4594 yy340:
4595 YYDEBUG(340, *YYCURSOR);
4596 yych = *++YYCURSOR;
4597 if (yych == 'A') goto yy341;
4598 if (yych != 'a') goto yy162;
4599 yy341:
4600 YYDEBUG(341, *YYCURSOR);
4601 yych = *++YYCURSOR;
4602 if (yych == 'S') goto yy342;
4603 if (yych != 's') goto yy162;
4604 yy342:
4605 YYDEBUG(342, *YYCURSOR);
4606 yych = *++YYCURSOR;
4607 if (yych == 'S') goto yy343;
4608 if (yych != 's') goto yy162;
4609 yy343:
4610 YYDEBUG(343, *YYCURSOR);
4611 yych = *++YYCURSOR;
4612 if (yych != '_') goto yy162;
4613 YYDEBUG(344, *YYCURSOR);
4614 yych = *++YYCURSOR;
4615 if (yych != '_') goto yy162;
4616 YYDEBUG(345, *YYCURSOR);
4617 ++YYCURSOR;
4618 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4619 goto yy161;
4620 }
4621 YYDEBUG(346, *YYCURSOR);
4622 yyleng = YYCURSOR - SCNG(yy_text);
4623 {
4624 RETURN_TOKEN(T_CLASS_C);
4625 }
4626 yy347:
4627 YYDEBUG(347, *YYCURSOR);
4628 yych = *++YYCURSOR;
4629 if (yych == 'L') goto yy348;
4630 if (yych != 'l') goto yy162;
4631 yy348:
4632 YYDEBUG(348, *YYCURSOR);
4633 yych = *++YYCURSOR;
4634 if (yych == 'T') goto yy349;
4635 if (yych != 't') goto yy162;
4636 yy349:
4637 YYDEBUG(349, *YYCURSOR);
4638 yych = *++YYCURSOR;
4639 if (yych != '_') goto yy162;
4640 YYDEBUG(350, *YYCURSOR);
4641 yych = *++YYCURSOR;
4642 if (yych == 'C') goto yy351;
4643 if (yych != 'c') goto yy162;
4644 yy351:
4645 YYDEBUG(351, *YYCURSOR);
4646 yych = *++YYCURSOR;
4647 if (yych == 'O') goto yy352;
4648 if (yych != 'o') goto yy162;
4649 yy352:
4650 YYDEBUG(352, *YYCURSOR);
4651 yych = *++YYCURSOR;
4652 if (yych == 'M') goto yy353;
4653 if (yych != 'm') goto yy162;
4654 yy353:
4655 YYDEBUG(353, *YYCURSOR);
4656 yych = *++YYCURSOR;
4657 if (yych == 'P') goto yy354;
4658 if (yych != 'p') goto yy162;
4659 yy354:
4660 YYDEBUG(354, *YYCURSOR);
4661 yych = *++YYCURSOR;
4662 if (yych == 'I') goto yy355;
4663 if (yych != 'i') goto yy162;
4664 yy355:
4665 YYDEBUG(355, *YYCURSOR);
4666 yych = *++YYCURSOR;
4667 if (yych == 'L') goto yy356;
4668 if (yych != 'l') goto yy162;
4669 yy356:
4670 YYDEBUG(356, *YYCURSOR);
4671 yych = *++YYCURSOR;
4672 if (yych == 'E') goto yy357;
4673 if (yych != 'e') goto yy162;
4674 yy357:
4675 YYDEBUG(357, *YYCURSOR);
4676 yych = *++YYCURSOR;
4677 if (yych == 'R') goto yy358;
4678 if (yych != 'r') goto yy162;
4679 yy358:
4680 YYDEBUG(358, *YYCURSOR);
4681 ++YYCURSOR;
4682 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4683 goto yy161;
4684 }
4685 YYDEBUG(359, *YYCURSOR);
4686 yyleng = YYCURSOR - SCNG(yy_text);
4687 {
4688 RETURN_TOKEN(T_HALT_COMPILER);
4689 }
4690 yy360:
4691 YYDEBUG(360, *YYCURSOR);
4692 yych = *++YYCURSOR;
4693 if (yych == 'S') goto yy364;
4694 if (yych == 's') goto yy364;
4695 goto yy162;
4696 yy361:
4697 YYDEBUG(361, *YYCURSOR);
4698 yych = *++YYCURSOR;
4699 if (yych == 'E') goto yy362;
4700 if (yych != 'e') goto yy162;
4701 yy362:
4702 YYDEBUG(362, *YYCURSOR);
4703 ++YYCURSOR;
4704 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4705 goto yy161;
4706 }
4707 YYDEBUG(363, *YYCURSOR);
4708 yyleng = YYCURSOR - SCNG(yy_text);
4709 {
4710 RETURN_TOKEN(T_USE);
4711 }
4712 yy364:
4713 YYDEBUG(364, *YYCURSOR);
4714 yych = *++YYCURSOR;
4715 if (yych == 'E') goto yy365;
4716 if (yych != 'e') goto yy162;
4717 yy365:
4718 YYDEBUG(365, *YYCURSOR);
4719 yych = *++YYCURSOR;
4720 if (yych == 'T') goto yy366;
4721 if (yych != 't') goto yy162;
4722 yy366:
4723 YYDEBUG(366, *YYCURSOR);
4724 ++YYCURSOR;
4725 if (yybm[0+(yych = *YYCURSOR)] & 4) {
4726 goto yy161;
4727 }
4728 YYDEBUG(367, *YYCURSOR);
4729 yyleng = YYCURSOR - SCNG(yy_text);
4730 {
4731 RETURN_TOKEN(T_UNSET);
4732 }
4733 yy368:
4734 YYDEBUG(368, *YYCURSOR);
4735 ++YYCURSOR;
4736 YYFILL(7);
4737 yych = *YYCURSOR;
4738 yy369:
4739 YYDEBUG(369, *YYCURSOR);
4740 if (yych <= 'S') {
4741 if (yych <= 'D') {
4742 if (yych <= ' ') {
4743 if (yych == '\t') goto yy368;
4744 if (yych <= 0x1F) goto yy164;
4745 goto yy368;
4746 } else {
4747 if (yych <= 'A') {
4748 if (yych <= '@') goto yy164;
4749 goto yy373;
4750 } else {
4751 if (yych <= 'B') goto yy371;
4752 if (yych <= 'C') goto yy164;
4753 goto yy376;
4754 }
4755 }
4756 } else {
4757 if (yych <= 'I') {
4758 if (yych == 'F') goto yy377;
4759 if (yych <= 'H') goto yy164;
4760 goto yy378;
4761 } else {
4762 if (yych <= 'O') {
4763 if (yych <= 'N') goto yy164;
4764 goto yy372;
4765 } else {
4766 if (yych <= 'Q') goto yy164;
4767 if (yych <= 'R') goto yy375;
4768 goto yy374;
4769 }
4770 }
4771 }
4772 } else {
4773 if (yych <= 'f') {
4774 if (yych <= 'a') {
4775 if (yych == 'U') goto yy370;
4776 if (yych <= '`') goto yy164;
4777 goto yy373;
4778 } else {
4779 if (yych <= 'c') {
4780 if (yych <= 'b') goto yy371;
4781 goto yy164;
4782 } else {
4783 if (yych <= 'd') goto yy376;
4784 if (yych <= 'e') goto yy164;
4785 goto yy377;
4786 }
4787 }
4788 } else {
4789 if (yych <= 'q') {
4790 if (yych <= 'i') {
4791 if (yych <= 'h') goto yy164;
4792 goto yy378;
4793 } else {
4794 if (yych == 'o') goto yy372;
4795 goto yy164;
4796 }
4797 } else {
4798 if (yych <= 's') {
4799 if (yych <= 'r') goto yy375;
4800 goto yy374;
4801 } else {
4802 if (yych != 'u') goto yy164;
4803 }
4804 }
4805 }
4806 }
4807 yy370:
4808 YYDEBUG(370, *YYCURSOR);
4809 yych = *++YYCURSOR;
4810 if (yych == 'N') goto yy441;
4811 if (yych == 'n') goto yy441;
4812 goto yy164;
4813 yy371:
4814 YYDEBUG(371, *YYCURSOR);
4815 yych = *++YYCURSOR;
4816 if (yych <= 'O') {
4817 if (yych == 'I') goto yy428;
4818 if (yych <= 'N') goto yy164;
4819 goto yy429;
4820 } else {
4821 if (yych <= 'i') {
4822 if (yych <= 'h') goto yy164;
4823 goto yy428;
4824 } else {
4825 if (yych == 'o') goto yy429;
4826 goto yy164;
4827 }
4828 }
4829 yy372:
4830 YYDEBUG(372, *YYCURSOR);
4831 yych = *++YYCURSOR;
4832 if (yych == 'B') goto yy420;
4833 if (yych == 'b') goto yy420;
4834 goto yy164;
4835 yy373:
4836 YYDEBUG(373, *YYCURSOR);
4837 yych = *++YYCURSOR;
4838 if (yych == 'R') goto yy413;
4839 if (yych == 'r') goto yy413;
4840 goto yy164;
4841 yy374:
4842 YYDEBUG(374, *YYCURSOR);
4843 yych = *++YYCURSOR;
4844 if (yych == 'T') goto yy405;
4845 if (yych == 't') goto yy405;
4846 goto yy164;
4847 yy375:
4848 YYDEBUG(375, *YYCURSOR);
4849 yych = *++YYCURSOR;
4850 if (yych == 'E') goto yy399;
4851 if (yych == 'e') goto yy399;
4852 goto yy164;
4853 yy376:
4854 YYDEBUG(376, *YYCURSOR);
4855 yych = *++YYCURSOR;
4856 if (yych == 'O') goto yy395;
4857 if (yych == 'o') goto yy395;
4858 goto yy164;
4859 yy377:
4860 YYDEBUG(377, *YYCURSOR);
4861 yych = *++YYCURSOR;
4862 if (yych == 'L') goto yy388;
4863 if (yych == 'l') goto yy388;
4864 goto yy164;
4865 yy378:
4866 YYDEBUG(378, *YYCURSOR);
4867 yych = *++YYCURSOR;
4868 if (yych == 'N') goto yy379;
4869 if (yych != 'n') goto yy164;
4870 yy379:
4871 YYDEBUG(379, *YYCURSOR);
4872 yych = *++YYCURSOR;
4873 if (yych == 'T') goto yy380;
4874 if (yych != 't') goto yy164;
4875 yy380:
4876 YYDEBUG(380, *YYCURSOR);
4877 yych = *++YYCURSOR;
4878 if (yych == 'E') goto yy381;
4879 if (yych != 'e') goto yy383;
4880 yy381:
4881 YYDEBUG(381, *YYCURSOR);
4882 yych = *++YYCURSOR;
4883 if (yych == 'G') goto yy386;
4884 if (yych == 'g') goto yy386;
4885 goto yy164;
4886 yy382:
4887 YYDEBUG(382, *YYCURSOR);
4888 ++YYCURSOR;
4889 YYFILL(1);
4890 yych = *YYCURSOR;
4891 yy383:
4892 YYDEBUG(383, *YYCURSOR);
4893 if (yych <= 0x1F) {
4894 if (yych == '\t') goto yy382;
4895 goto yy164;
4896 } else {
4897 if (yych <= ' ') goto yy382;
4898 if (yych != ')') goto yy164;
4899 }
4900 YYDEBUG(384, *YYCURSOR);
4901 ++YYCURSOR;
4902 YYDEBUG(385, *YYCURSOR);
4903 yyleng = YYCURSOR - SCNG(yy_text);
4904 {
4905 RETURN_TOKEN(T_INT_CAST);
4906 }
4907 yy386:
4908 YYDEBUG(386, *YYCURSOR);
4909 yych = *++YYCURSOR;
4910 if (yych == 'E') goto yy387;
4911 if (yych != 'e') goto yy164;
4912 yy387:
4913 YYDEBUG(387, *YYCURSOR);
4914 yych = *++YYCURSOR;
4915 if (yych == 'R') goto yy382;
4916 if (yych == 'r') goto yy382;
4917 goto yy164;
4918 yy388:
4919 YYDEBUG(388, *YYCURSOR);
4920 yych = *++YYCURSOR;
4921 if (yych == 'O') goto yy389;
4922 if (yych != 'o') goto yy164;
4923 yy389:
4924 YYDEBUG(389, *YYCURSOR);
4925 yych = *++YYCURSOR;
4926 if (yych == 'A') goto yy390;
4927 if (yych != 'a') goto yy164;
4928 yy390:
4929 YYDEBUG(390, *YYCURSOR);
4930 yych = *++YYCURSOR;
4931 if (yych == 'T') goto yy391;
4932 if (yych != 't') goto yy164;
4933 yy391:
4934 YYDEBUG(391, *YYCURSOR);
4935 ++YYCURSOR;
4936 YYFILL(1);
4937 yych = *YYCURSOR;
4938 YYDEBUG(392, *YYCURSOR);
4939 if (yych <= 0x1F) {
4940 if (yych == '\t') goto yy391;
4941 goto yy164;
4942 } else {
4943 if (yych <= ' ') goto yy391;
4944 if (yych != ')') goto yy164;
4945 }
4946 YYDEBUG(393, *YYCURSOR);
4947 ++YYCURSOR;
4948 YYDEBUG(394, *YYCURSOR);
4949 yyleng = YYCURSOR - SCNG(yy_text);
4950 {
4951 RETURN_TOKEN(T_DOUBLE_CAST);
4952 }
4953 yy395:
4954 YYDEBUG(395, *YYCURSOR);
4955 yych = *++YYCURSOR;
4956 if (yych == 'U') goto yy396;
4957 if (yych != 'u') goto yy164;
4958 yy396:
4959 YYDEBUG(396, *YYCURSOR);
4960 yych = *++YYCURSOR;
4961 if (yych == 'B') goto yy397;
4962 if (yych != 'b') goto yy164;
4963 yy397:
4964 YYDEBUG(397, *YYCURSOR);
4965 yych = *++YYCURSOR;
4966 if (yych == 'L') goto yy398;
4967 if (yych != 'l') goto yy164;
4968 yy398:
4969 YYDEBUG(398, *YYCURSOR);
4970 yych = *++YYCURSOR;
4971 if (yych == 'E') goto yy391;
4972 if (yych == 'e') goto yy391;
4973 goto yy164;
4974 yy399:
4975 YYDEBUG(399, *YYCURSOR);
4976 yych = *++YYCURSOR;
4977 if (yych == 'A') goto yy400;
4978 if (yych != 'a') goto yy164;
4979 yy400:
4980 YYDEBUG(400, *YYCURSOR);
4981 yych = *++YYCURSOR;
4982 if (yych == 'L') goto yy401;
4983 if (yych != 'l') goto yy164;
4984 yy401:
4985 YYDEBUG(401, *YYCURSOR);
4986 ++YYCURSOR;
4987 YYFILL(1);
4988 yych = *YYCURSOR;
4989 YYDEBUG(402, *YYCURSOR);
4990 if (yych <= 0x1F) {
4991 if (yych == '\t') goto yy401;
4992 goto yy164;
4993 } else {
4994 if (yych <= ' ') goto yy401;
4995 if (yych != ')') goto yy164;
4996 }
4997 YYDEBUG(403, *YYCURSOR);
4998 ++YYCURSOR;
4999 YYDEBUG(404, *YYCURSOR);
5000 yyleng = YYCURSOR - SCNG(yy_text);
5001 {
5002 if (PARSER_MODE()) {
5003 zend_error(E_DEPRECATED, "The (real) cast is deprecated, use (float) instead");
5004 }
5005 RETURN_TOKEN(T_DOUBLE_CAST);
5006 }
5007 yy405:
5008 YYDEBUG(405, *YYCURSOR);
5009 yych = *++YYCURSOR;
5010 if (yych == 'R') goto yy406;
5011 if (yych != 'r') goto yy164;
5012 yy406:
5013 YYDEBUG(406, *YYCURSOR);
5014 yych = *++YYCURSOR;
5015 if (yych == 'I') goto yy407;
5016 if (yych != 'i') goto yy164;
5017 yy407:
5018 YYDEBUG(407, *YYCURSOR);
5019 yych = *++YYCURSOR;
5020 if (yych == 'N') goto yy408;
5021 if (yych != 'n') goto yy164;
5022 yy408:
5023 YYDEBUG(408, *YYCURSOR);
5024 yych = *++YYCURSOR;
5025 if (yych == 'G') goto yy409;
5026 if (yych != 'g') goto yy164;
5027 yy409:
5028 YYDEBUG(409, *YYCURSOR);
5029 ++YYCURSOR;
5030 YYFILL(1);
5031 yych = *YYCURSOR;
5032 YYDEBUG(410, *YYCURSOR);
5033 if (yych <= 0x1F) {
5034 if (yych == '\t') goto yy409;
5035 goto yy164;
5036 } else {
5037 if (yych <= ' ') goto yy409;
5038 if (yych != ')') goto yy164;
5039 }
5040 YYDEBUG(411, *YYCURSOR);
5041 ++YYCURSOR;
5042 YYDEBUG(412, *YYCURSOR);
5043 yyleng = YYCURSOR - SCNG(yy_text);
5044 {
5045 RETURN_TOKEN(T_STRING_CAST);
5046 }
5047 yy413:
5048 YYDEBUG(413, *YYCURSOR);
5049 yych = *++YYCURSOR;
5050 if (yych == 'R') goto yy414;
5051 if (yych != 'r') goto yy164;
5052 yy414:
5053 YYDEBUG(414, *YYCURSOR);
5054 yych = *++YYCURSOR;
5055 if (yych == 'A') goto yy415;
5056 if (yych != 'a') goto yy164;
5057 yy415:
5058 YYDEBUG(415, *YYCURSOR);
5059 yych = *++YYCURSOR;
5060 if (yych == 'Y') goto yy416;
5061 if (yych != 'y') goto yy164;
5062 yy416:
5063 YYDEBUG(416, *YYCURSOR);
5064 ++YYCURSOR;
5065 YYFILL(1);
5066 yych = *YYCURSOR;
5067 YYDEBUG(417, *YYCURSOR);
5068 if (yych <= 0x1F) {
5069 if (yych == '\t') goto yy416;
5070 goto yy164;
5071 } else {
5072 if (yych <= ' ') goto yy416;
5073 if (yych != ')') goto yy164;
5074 }
5075 YYDEBUG(418, *YYCURSOR);
5076 ++YYCURSOR;
5077 YYDEBUG(419, *YYCURSOR);
5078 yyleng = YYCURSOR - SCNG(yy_text);
5079 {
5080 RETURN_TOKEN(T_ARRAY_CAST);
5081 }
5082 yy420:
5083 YYDEBUG(420, *YYCURSOR);
5084 yych = *++YYCURSOR;
5085 if (yych == 'J') goto yy421;
5086 if (yych != 'j') goto yy164;
5087 yy421:
5088 YYDEBUG(421, *YYCURSOR);
5089 yych = *++YYCURSOR;
5090 if (yych == 'E') goto yy422;
5091 if (yych != 'e') goto yy164;
5092 yy422:
5093 YYDEBUG(422, *YYCURSOR);
5094 yych = *++YYCURSOR;
5095 if (yych == 'C') goto yy423;
5096 if (yych != 'c') goto yy164;
5097 yy423:
5098 YYDEBUG(423, *YYCURSOR);
5099 yych = *++YYCURSOR;
5100 if (yych == 'T') goto yy424;
5101 if (yych != 't') goto yy164;
5102 yy424:
5103 YYDEBUG(424, *YYCURSOR);
5104 ++YYCURSOR;
5105 YYFILL(1);
5106 yych = *YYCURSOR;
5107 YYDEBUG(425, *YYCURSOR);
5108 if (yych <= 0x1F) {
5109 if (yych == '\t') goto yy424;
5110 goto yy164;
5111 } else {
5112 if (yych <= ' ') goto yy424;
5113 if (yych != ')') goto yy164;
5114 }
5115 YYDEBUG(426, *YYCURSOR);
5116 ++YYCURSOR;
5117 YYDEBUG(427, *YYCURSOR);
5118 yyleng = YYCURSOR - SCNG(yy_text);
5119 {
5120 RETURN_TOKEN(T_OBJECT_CAST);
5121 }
5122 yy428:
5123 YYDEBUG(428, *YYCURSOR);
5124 yych = *++YYCURSOR;
5125 if (yych == 'N') goto yy438;
5126 if (yych == 'n') goto yy438;
5127 goto yy164;
5128 yy429:
5129 YYDEBUG(429, *YYCURSOR);
5130 yych = *++YYCURSOR;
5131 if (yych == 'O') goto yy430;
5132 if (yych != 'o') goto yy164;
5133 yy430:
5134 YYDEBUG(430, *YYCURSOR);
5135 yych = *++YYCURSOR;
5136 if (yych == 'L') goto yy431;
5137 if (yych != 'l') goto yy164;
5138 yy431:
5139 YYDEBUG(431, *YYCURSOR);
5140 yych = *++YYCURSOR;
5141 if (yych == 'E') goto yy436;
5142 if (yych == 'e') goto yy436;
5143 goto yy433;
5144 yy432:
5145 YYDEBUG(432, *YYCURSOR);
5146 ++YYCURSOR;
5147 YYFILL(1);
5148 yych = *YYCURSOR;
5149 yy433:
5150 YYDEBUG(433, *YYCURSOR);
5151 if (yych <= 0x1F) {
5152 if (yych == '\t') goto yy432;
5153 goto yy164;
5154 } else {
5155 if (yych <= ' ') goto yy432;
5156 if (yych != ')') goto yy164;
5157 }
5158 YYDEBUG(434, *YYCURSOR);
5159 ++YYCURSOR;
5160 YYDEBUG(435, *YYCURSOR);
5161 yyleng = YYCURSOR - SCNG(yy_text);
5162 {
5163 RETURN_TOKEN(T_BOOL_CAST);
5164 }
5165 yy436:
5166 YYDEBUG(436, *YYCURSOR);
5167 yych = *++YYCURSOR;
5168 if (yych == 'A') goto yy437;
5169 if (yych != 'a') goto yy164;
5170 yy437:
5171 YYDEBUG(437, *YYCURSOR);
5172 yych = *++YYCURSOR;
5173 if (yych == 'N') goto yy432;
5174 if (yych == 'n') goto yy432;
5175 goto yy164;
5176 yy438:
5177 YYDEBUG(438, *YYCURSOR);
5178 yych = *++YYCURSOR;
5179 if (yych == 'A') goto yy439;
5180 if (yych != 'a') goto yy164;
5181 yy439:
5182 YYDEBUG(439, *YYCURSOR);
5183 yych = *++YYCURSOR;
5184 if (yych == 'R') goto yy440;
5185 if (yych != 'r') goto yy164;
5186 yy440:
5187 YYDEBUG(440, *YYCURSOR);
5188 yych = *++YYCURSOR;
5189 if (yych == 'Y') goto yy409;
5190 if (yych == 'y') goto yy409;
5191 goto yy164;
5192 yy441:
5193 YYDEBUG(441, *YYCURSOR);
5194 yych = *++YYCURSOR;
5195 if (yych == 'S') goto yy442;
5196 if (yych != 's') goto yy164;
5197 yy442:
5198 YYDEBUG(442, *YYCURSOR);
5199 yych = *++YYCURSOR;
5200 if (yych == 'E') goto yy443;
5201 if (yych != 'e') goto yy164;
5202 yy443:
5203 YYDEBUG(443, *YYCURSOR);
5204 yych = *++YYCURSOR;
5205 if (yych == 'T') goto yy444;
5206 if (yych != 't') goto yy164;
5207 yy444:
5208 YYDEBUG(444, *YYCURSOR);
5209 ++YYCURSOR;
5210 YYFILL(1);
5211 yych = *YYCURSOR;
5212 YYDEBUG(445, *YYCURSOR);
5213 if (yych <= 0x1F) {
5214 if (yych == '\t') goto yy444;
5215 goto yy164;
5216 } else {
5217 if (yych <= ' ') goto yy444;
5218 if (yych != ')') goto yy164;
5219 }
5220 YYDEBUG(446, *YYCURSOR);
5221 ++YYCURSOR;
5222 YYDEBUG(447, *YYCURSOR);
5223 yyleng = YYCURSOR - SCNG(yy_text);
5224 {
5225 RETURN_TOKEN(T_UNSET_CAST);
5226 }
5227 yy448:
5228 YYDEBUG(448, *YYCURSOR);
5229 yych = *++YYCURSOR;
5230 if (yych == 'R') goto yy449;
5231 if (yych != 'r') goto yy162;
5232 yy449:
5233 YYDEBUG(449, *YYCURSOR);
5234 ++YYCURSOR;
5235 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5236 goto yy161;
5237 }
5238 YYDEBUG(450, *YYCURSOR);
5239 yyleng = YYCURSOR - SCNG(yy_text);
5240 {
5241 RETURN_TOKEN(T_VAR);
5242 }
5243 yy451:
5244 YYDEBUG(451, *YYCURSOR);
5245 yych = *++YYCURSOR;
5246 if (yych == 'M') goto yy455;
5247 if (yych == 'm') goto yy455;
5248 goto yy162;
5249 yy452:
5250 YYDEBUG(452, *YYCURSOR);
5251 yych = *++YYCURSOR;
5252 if (yych == 'W') goto yy453;
5253 if (yych != 'w') goto yy162;
5254 yy453:
5255 YYDEBUG(453, *YYCURSOR);
5256 ++YYCURSOR;
5257 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5258 goto yy161;
5259 }
5260 YYDEBUG(454, *YYCURSOR);
5261 yyleng = YYCURSOR - SCNG(yy_text);
5262 {
5263 RETURN_TOKEN(T_NEW);
5264 }
5265 yy455:
5266 YYDEBUG(455, *YYCURSOR);
5267 yych = *++YYCURSOR;
5268 if (yych == 'E') goto yy456;
5269 if (yych != 'e') goto yy162;
5270 yy456:
5271 YYDEBUG(456, *YYCURSOR);
5272 yych = *++YYCURSOR;
5273 if (yych == 'S') goto yy457;
5274 if (yych != 's') goto yy162;
5275 yy457:
5276 YYDEBUG(457, *YYCURSOR);
5277 yych = *++YYCURSOR;
5278 if (yych == 'P') goto yy458;
5279 if (yych != 'p') goto yy162;
5280 yy458:
5281 YYDEBUG(458, *YYCURSOR);
5282 yych = *++YYCURSOR;
5283 if (yych == 'A') goto yy459;
5284 if (yych != 'a') goto yy162;
5285 yy459:
5286 YYDEBUG(459, *YYCURSOR);
5287 yych = *++YYCURSOR;
5288 if (yych == 'C') goto yy460;
5289 if (yych != 'c') goto yy162;
5290 yy460:
5291 YYDEBUG(460, *YYCURSOR);
5292 yych = *++YYCURSOR;
5293 if (yych == 'E') goto yy461;
5294 if (yych != 'e') goto yy162;
5295 yy461:
5296 YYDEBUG(461, *YYCURSOR);
5297 ++YYCURSOR;
5298 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5299 goto yy161;
5300 }
5301 YYDEBUG(462, *YYCURSOR);
5302 yyleng = YYCURSOR - SCNG(yy_text);
5303 {
5304 RETURN_TOKEN(T_NAMESPACE);
5305 }
5306 yy463:
5307 YYDEBUG(463, *YYCURSOR);
5308 ++YYCURSOR;
5309 if ((yych = *YYCURSOR) == '\n') goto yy469;
5310 if (yych == '\r') goto yy470;
5311 yy464:
5312 YYDEBUG(464, *YYCURSOR);
5313 yyleng = YYCURSOR - SCNG(yy_text);
5314 {
5315 BEGIN(INITIAL);
5316 if (yytext[yyleng-1] != '>') {
5317 CG(increment_lineno) = 1;
5318 }
5319 if (PARSER_MODE()) {
5320 RETURN_TOKEN(';'); /* implicit ';' at php-end tag */
5321 }
5322 RETURN_TOKEN(T_CLOSE_TAG);
5323 }
5324 yy465:
5325 YYDEBUG(465, *YYCURSOR);
5326 ++YYCURSOR;
5327 if ((yych = *YYCURSOR) == '=') goto yy467;
5328 YYDEBUG(466, *YYCURSOR);
5329 yyleng = YYCURSOR - SCNG(yy_text);
5330 {
5331 RETURN_TOKEN(T_COALESCE);
5332 }
5333 yy467:
5334 YYDEBUG(467, *YYCURSOR);
5335 ++YYCURSOR;
5336 YYDEBUG(468, *YYCURSOR);
5337 yyleng = YYCURSOR - SCNG(yy_text);
5338 {
5339 RETURN_TOKEN(T_COALESCE_EQUAL);
5340 }
5341 yy469:
5342 YYDEBUG(469, *YYCURSOR);
5343 yych = *++YYCURSOR;
5344 goto yy464;
5345 yy470:
5346 YYDEBUG(470, *YYCURSOR);
5347 yych = *++YYCURSOR;
5348 if (yych == '\n') goto yy469;
5349 goto yy464;
5350 yy471:
5351 YYDEBUG(471, *YYCURSOR);
5352 yyaccept = 3;
5353 YYMARKER = ++YYCURSOR;
5354 YYFILL(3);
5355 yych = *YYCURSOR;
5356 YYDEBUG(472, *YYCURSOR);
5357 if (yych <= 'E') {
5358 if (yych <= '/') goto yy166;
5359 if (yych <= '9') goto yy471;
5360 if (yych <= 'D') goto yy166;
5361 goto yy169;
5362 } else {
5363 if (yych <= '_') {
5364 if (yych <= '^') goto yy166;
5365 goto yy478;
5366 } else {
5367 if (yych == 'e') goto yy169;
5368 goto yy166;
5369 }
5370 }
5371 yy473:
5372 YYDEBUG(473, *YYCURSOR);
5373 ++YYCURSOR;
5374 YYDEBUG(474, *YYCURSOR);
5375 yyleng = YYCURSOR - SCNG(yy_text);
5376 {
5377 RETURN_TOKEN(T_CONCAT_EQUAL);
5378 }
5379 yy475:
5380 YYDEBUG(475, *YYCURSOR);
5381 yych = *++YYCURSOR;
5382 if (yych != '.') goto yy164;
5383 YYDEBUG(476, *YYCURSOR);
5384 ++YYCURSOR;
5385 YYDEBUG(477, *YYCURSOR);
5386 yyleng = YYCURSOR - SCNG(yy_text);
5387 {
5388 RETURN_TOKEN(T_ELLIPSIS);
5389 }
5390 yy478:
5391 YYDEBUG(478, *YYCURSOR);
5392 ++YYCURSOR;
5393 YYFILL(1);
5394 yych = *YYCURSOR;
5395 if (yych <= '/') goto yy164;
5396 if (yych >= ':') goto yy164;
5397 yy479:
5398 YYDEBUG(479, *YYCURSOR);
5399 yyaccept = 3;
5400 YYMARKER = ++YYCURSOR;
5401 YYFILL(3);
5402 yych = *YYCURSOR;
5403 YYDEBUG(480, *YYCURSOR);
5404 if (yych <= 'E') {
5405 if (yych <= '/') goto yy166;
5406 if (yych <= '9') goto yy479;
5407 if (yych <= 'D') goto yy166;
5408 goto yy169;
5409 } else {
5410 if (yych <= '_') {
5411 if (yych <= '^') goto yy166;
5412 goto yy478;
5413 } else {
5414 if (yych == 'e') goto yy169;
5415 goto yy166;
5416 }
5417 }
5418 yy481:
5419 YYDEBUG(481, *YYCURSOR);
5420 ++YYCURSOR;
5421 YYDEBUG(482, *YYCURSOR);
5422 yyleng = YYCURSOR - SCNG(yy_text);
5423 {
5424 RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM);
5425 }
5426 yy483:
5427 YYDEBUG(483, *YYCURSOR);
5428 ++YYCURSOR;
5429 YYFILL(1);
5430 yych = *YYCURSOR;
5431 yy484:
5432 YYDEBUG(484, *YYCURSOR);
5433 if (yych <= '\f') {
5434 if (yych <= 0x08) goto yy116;
5435 if (yych <= '\n') goto yy483;
5436 goto yy116;
5437 } else {
5438 if (yych <= '\r') goto yy483;
5439 if (yych == ' ') goto yy483;
5440 goto yy116;
5441 }
5442 yy485:
5443 YYDEBUG(485, *YYCURSOR);
5444 ++YYCURSOR;
5445 YYDEBUG(486, *YYCURSOR);
5446 yyleng = YYCURSOR - SCNG(yy_text);
5447 {
5448 RETURN_TOKEN(T_MINUS_EQUAL);
5449 }
5450 yy487:
5451 YYDEBUG(487, *YYCURSOR);
5452 ++YYCURSOR;
5453 YYDEBUG(488, *YYCURSOR);
5454 yyleng = YYCURSOR - SCNG(yy_text);
5455 {
5456 RETURN_TOKEN(T_DEC);
5457 }
5458 yy489:
5459 YYDEBUG(489, *YYCURSOR);
5460 ++YYCURSOR;
5461 YYDEBUG(490, *YYCURSOR);
5462 yyleng = YYCURSOR - SCNG(yy_text);
5463 {
5464 yy_push_state(ST_LOOKING_FOR_PROPERTY);
5465 RETURN_TOKEN(T_OBJECT_OPERATOR);
5466 }
5467 yy491:
5468 YYDEBUG(491, *YYCURSOR);
5469 yych = *++YYCURSOR;
5470 if (yych <= 'O') {
5471 if (yych == 'I') goto yy498;
5472 if (yych <= 'N') goto yy162;
5473 goto yy499;
5474 } else {
5475 if (yych <= 'i') {
5476 if (yych <= 'h') goto yy162;
5477 goto yy498;
5478 } else {
5479 if (yych == 'o') goto yy499;
5480 goto yy162;
5481 }
5482 }
5483 yy492:
5484 YYDEBUG(492, *YYCURSOR);
5485 yych = *++YYCURSOR;
5486 if (yych == 'B') goto yy493;
5487 if (yych != 'b') goto yy162;
5488 yy493:
5489 YYDEBUG(493, *YYCURSOR);
5490 yych = *++YYCURSOR;
5491 if (yych == 'L') goto yy494;
5492 if (yych != 'l') goto yy162;
5493 yy494:
5494 YYDEBUG(494, *YYCURSOR);
5495 yych = *++YYCURSOR;
5496 if (yych == 'I') goto yy495;
5497 if (yych != 'i') goto yy162;
5498 yy495:
5499 YYDEBUG(495, *YYCURSOR);
5500 yych = *++YYCURSOR;
5501 if (yych == 'C') goto yy496;
5502 if (yych != 'c') goto yy162;
5503 yy496:
5504 YYDEBUG(496, *YYCURSOR);
5505 ++YYCURSOR;
5506 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5507 goto yy161;
5508 }
5509 YYDEBUG(497, *YYCURSOR);
5510 yyleng = YYCURSOR - SCNG(yy_text);
5511 {
5512 RETURN_TOKEN(T_PUBLIC);
5513 }
5514 yy498:
5515 YYDEBUG(498, *YYCURSOR);
5516 yych = *++YYCURSOR;
5517 if (yych <= 'V') {
5518 if (yych == 'N') goto yy507;
5519 if (yych <= 'U') goto yy162;
5520 goto yy508;
5521 } else {
5522 if (yych <= 'n') {
5523 if (yych <= 'm') goto yy162;
5524 goto yy507;
5525 } else {
5526 if (yych == 'v') goto yy508;
5527 goto yy162;
5528 }
5529 }
5530 yy499:
5531 YYDEBUG(499, *YYCURSOR);
5532 yych = *++YYCURSOR;
5533 if (yych == 'T') goto yy500;
5534 if (yych != 't') goto yy162;
5535 yy500:
5536 YYDEBUG(500, *YYCURSOR);
5537 yych = *++YYCURSOR;
5538 if (yych == 'E') goto yy501;
5539 if (yych != 'e') goto yy162;
5540 yy501:
5541 YYDEBUG(501, *YYCURSOR);
5542 yych = *++YYCURSOR;
5543 if (yych == 'C') goto yy502;
5544 if (yych != 'c') goto yy162;
5545 yy502:
5546 YYDEBUG(502, *YYCURSOR);
5547 yych = *++YYCURSOR;
5548 if (yych == 'T') goto yy503;
5549 if (yych != 't') goto yy162;
5550 yy503:
5551 YYDEBUG(503, *YYCURSOR);
5552 yych = *++YYCURSOR;
5553 if (yych == 'E') goto yy504;
5554 if (yych != 'e') goto yy162;
5555 yy504:
5556 YYDEBUG(504, *YYCURSOR);
5557 yych = *++YYCURSOR;
5558 if (yych == 'D') goto yy505;
5559 if (yych != 'd') goto yy162;
5560 yy505:
5561 YYDEBUG(505, *YYCURSOR);
5562 ++YYCURSOR;
5563 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5564 goto yy161;
5565 }
5566 YYDEBUG(506, *YYCURSOR);
5567 yyleng = YYCURSOR - SCNG(yy_text);
5568 {
5569 RETURN_TOKEN(T_PROTECTED);
5570 }
5571 yy507:
5572 YYDEBUG(507, *YYCURSOR);
5573 yych = *++YYCURSOR;
5574 if (yych == 'T') goto yy513;
5575 if (yych == 't') goto yy513;
5576 goto yy162;
5577 yy508:
5578 YYDEBUG(508, *YYCURSOR);
5579 yych = *++YYCURSOR;
5580 if (yych == 'A') goto yy509;
5581 if (yych != 'a') goto yy162;
5582 yy509:
5583 YYDEBUG(509, *YYCURSOR);
5584 yych = *++YYCURSOR;
5585 if (yych == 'T') goto yy510;
5586 if (yych != 't') goto yy162;
5587 yy510:
5588 YYDEBUG(510, *YYCURSOR);
5589 yych = *++YYCURSOR;
5590 if (yych == 'E') goto yy511;
5591 if (yych != 'e') goto yy162;
5592 yy511:
5593 YYDEBUG(511, *YYCURSOR);
5594 ++YYCURSOR;
5595 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5596 goto yy161;
5597 }
5598 YYDEBUG(512, *YYCURSOR);
5599 yyleng = YYCURSOR - SCNG(yy_text);
5600 {
5601 RETURN_TOKEN(T_PRIVATE);
5602 }
5603 yy513:
5604 YYDEBUG(513, *YYCURSOR);
5605 ++YYCURSOR;
5606 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5607 goto yy161;
5608 }
5609 YYDEBUG(514, *YYCURSOR);
5610 yyleng = YYCURSOR - SCNG(yy_text);
5611 {
5612 RETURN_TOKEN(T_PRINT);
5613 }
5614 yy515:
5615 YYDEBUG(515, *YYCURSOR);
5616 yych = *++YYCURSOR;
5617 if (yych == 'O') goto yy520;
5618 if (yych == 'o') goto yy520;
5619 goto yy162;
5620 yy516:
5621 YYDEBUG(516, *YYCURSOR);
5622 yych = *++YYCURSOR;
5623 if (yych == 'T') goto yy517;
5624 if (yych != 't') goto yy162;
5625 yy517:
5626 YYDEBUG(517, *YYCURSOR);
5627 yych = *++YYCURSOR;
5628 if (yych == 'O') goto yy518;
5629 if (yych != 'o') goto yy162;
5630 yy518:
5631 YYDEBUG(518, *YYCURSOR);
5632 ++YYCURSOR;
5633 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5634 goto yy161;
5635 }
5636 YYDEBUG(519, *YYCURSOR);
5637 yyleng = YYCURSOR - SCNG(yy_text);
5638 {
5639 RETURN_TOKEN(T_GOTO);
5640 }
5641 yy520:
5642 YYDEBUG(520, *YYCURSOR);
5643 yych = *++YYCURSOR;
5644 if (yych == 'B') goto yy521;
5645 if (yych != 'b') goto yy162;
5646 yy521:
5647 YYDEBUG(521, *YYCURSOR);
5648 yych = *++YYCURSOR;
5649 if (yych == 'A') goto yy522;
5650 if (yych != 'a') goto yy162;
5651 yy522:
5652 YYDEBUG(522, *YYCURSOR);
5653 yych = *++YYCURSOR;
5654 if (yych == 'L') goto yy523;
5655 if (yych != 'l') goto yy162;
5656 yy523:
5657 YYDEBUG(523, *YYCURSOR);
5658 ++YYCURSOR;
5659 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5660 goto yy161;
5661 }
5662 YYDEBUG(524, *YYCURSOR);
5663 yyleng = YYCURSOR - SCNG(yy_text);
5664 {
5665 RETURN_TOKEN(T_GLOBAL);
5666 }
5667 yy525:
5668 YYDEBUG(525, *YYCURSOR);
5669 yych = *++YYCURSOR;
5670 if (yych == '<') goto yy533;
5671 goto yy164;
5672 yy526:
5673 YYDEBUG(526, *YYCURSOR);
5674 yych = *++YYCURSOR;
5675 goto yy156;
5676 yy527:
5677 YYDEBUG(527, *YYCURSOR);
5678 yych = *++YYCURSOR;
5679 goto yy154;
5680 yy528:
5681 YYDEBUG(528, *YYCURSOR);
5682 yych = *++YYCURSOR;
5683 if (yych == 'E') goto yy529;
5684 if (yych != 'e') goto yy162;
5685 yy529:
5686 YYDEBUG(529, *YYCURSOR);
5687 yych = *++YYCURSOR;
5688 if (yych == 'A') goto yy530;
5689 if (yych != 'a') goto yy162;
5690 yy530:
5691 YYDEBUG(530, *YYCURSOR);
5692 yych = *++YYCURSOR;
5693 if (yych == 'K') goto yy531;
5694 if (yych != 'k') goto yy162;
5695 yy531:
5696 YYDEBUG(531, *YYCURSOR);
5697 ++YYCURSOR;
5698 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5699 goto yy161;
5700 }
5701 YYDEBUG(532, *YYCURSOR);
5702 yyleng = YYCURSOR - SCNG(yy_text);
5703 {
5704 RETURN_TOKEN(T_BREAK);
5705 }
5706 yy533:
5707 YYDEBUG(533, *YYCURSOR);
5708 yych = *++YYCURSOR;
5709 if (yych == '<') goto yy247;
5710 goto yy164;
5711 yy534:
5712 YYDEBUG(534, *YYCURSOR);
5713 yych = *++YYCURSOR;
5714 if (yych == 'A') goto yy541;
5715 if (yych == 'a') goto yy541;
5716 goto yy162;
5717 yy535:
5718 YYDEBUG(535, *YYCURSOR);
5719 yych = *++YYCURSOR;
5720 if (yych == 'I') goto yy536;
5721 if (yych != 'i') goto yy162;
5722 yy536:
5723 YYDEBUG(536, *YYCURSOR);
5724 yych = *++YYCURSOR;
5725 if (yych == 'T') goto yy537;
5726 if (yych != 't') goto yy162;
5727 yy537:
5728 YYDEBUG(537, *YYCURSOR);
5729 yych = *++YYCURSOR;
5730 if (yych == 'C') goto yy538;
5731 if (yych != 'c') goto yy162;
5732 yy538:
5733 YYDEBUG(538, *YYCURSOR);
5734 yych = *++YYCURSOR;
5735 if (yych == 'H') goto yy539;
5736 if (yych != 'h') goto yy162;
5737 yy539:
5738 YYDEBUG(539, *YYCURSOR);
5739 ++YYCURSOR;
5740 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5741 goto yy161;
5742 }
5743 YYDEBUG(540, *YYCURSOR);
5744 yyleng = YYCURSOR - SCNG(yy_text);
5745 {
5746 RETURN_TOKEN(T_SWITCH);
5747 }
5748 yy541:
5749 YYDEBUG(541, *YYCURSOR);
5750 yych = *++YYCURSOR;
5751 if (yych == 'T') goto yy542;
5752 if (yych != 't') goto yy162;
5753 yy542:
5754 YYDEBUG(542, *YYCURSOR);
5755 yych = *++YYCURSOR;
5756 if (yych == 'I') goto yy543;
5757 if (yych != 'i') goto yy162;
5758 yy543:
5759 YYDEBUG(543, *YYCURSOR);
5760 yych = *++YYCURSOR;
5761 if (yych == 'C') goto yy544;
5762 if (yych != 'c') goto yy162;
5763 yy544:
5764 YYDEBUG(544, *YYCURSOR);
5765 ++YYCURSOR;
5766 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5767 goto yy161;
5768 }
5769 YYDEBUG(545, *YYCURSOR);
5770 yyleng = YYCURSOR - SCNG(yy_text);
5771 {
5772 RETURN_TOKEN(T_STATIC);
5773 }
5774 yy546:
5775 YYDEBUG(546, *YYCURSOR);
5776 yych = *++YYCURSOR;
5777 if (yych == 'S') goto yy557;
5778 if (yych == 's') goto yy557;
5779 goto yy162;
5780 yy547:
5781 YYDEBUG(547, *YYCURSOR);
5782 yych = *++YYCURSOR;
5783 if (yych == 'D') goto yy555;
5784 if (yych == 'd') goto yy555;
5785 goto yy162;
5786 yy548:
5787 YYDEBUG(548, *YYCURSOR);
5788 yych = *++YYCURSOR;
5789 if (yych == 'R') goto yy551;
5790 if (yych == 'r') goto yy551;
5791 goto yy162;
5792 yy549:
5793 YYDEBUG(549, *YYCURSOR);
5794 ++YYCURSOR;
5795 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5796 goto yy161;
5797 }
5798 YYDEBUG(550, *YYCURSOR);
5799 yyleng = YYCURSOR - SCNG(yy_text);
5800 {
5801 RETURN_TOKEN(T_AS);
5802 }
5803 yy551:
5804 YYDEBUG(551, *YYCURSOR);
5805 yych = *++YYCURSOR;
5806 if (yych == 'A') goto yy552;
5807 if (yych != 'a') goto yy162;
5808 yy552:
5809 YYDEBUG(552, *YYCURSOR);
5810 yych = *++YYCURSOR;
5811 if (yych == 'Y') goto yy553;
5812 if (yych != 'y') goto yy162;
5813 yy553:
5814 YYDEBUG(553, *YYCURSOR);
5815 ++YYCURSOR;
5816 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5817 goto yy161;
5818 }
5819 YYDEBUG(554, *YYCURSOR);
5820 yyleng = YYCURSOR - SCNG(yy_text);
5821 {
5822 RETURN_TOKEN(T_ARRAY);
5823 }
5824 yy555:
5825 YYDEBUG(555, *YYCURSOR);
5826 ++YYCURSOR;
5827 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5828 goto yy161;
5829 }
5830 YYDEBUG(556, *YYCURSOR);
5831 yyleng = YYCURSOR - SCNG(yy_text);
5832 {
5833 RETURN_TOKEN(T_LOGICAL_AND);
5834 }
5835 yy557:
5836 YYDEBUG(557, *YYCURSOR);
5837 yych = *++YYCURSOR;
5838 if (yych == 'T') goto yy558;
5839 if (yych != 't') goto yy162;
5840 yy558:
5841 YYDEBUG(558, *YYCURSOR);
5842 yych = *++YYCURSOR;
5843 if (yych == 'R') goto yy559;
5844 if (yych != 'r') goto yy162;
5845 yy559:
5846 YYDEBUG(559, *YYCURSOR);
5847 yych = *++YYCURSOR;
5848 if (yych == 'A') goto yy560;
5849 if (yych != 'a') goto yy162;
5850 yy560:
5851 YYDEBUG(560, *YYCURSOR);
5852 yych = *++YYCURSOR;
5853 if (yych == 'C') goto yy561;
5854 if (yych != 'c') goto yy162;
5855 yy561:
5856 YYDEBUG(561, *YYCURSOR);
5857 yych = *++YYCURSOR;
5858 if (yych == 'T') goto yy562;
5859 if (yych != 't') goto yy162;
5860 yy562:
5861 YYDEBUG(562, *YYCURSOR);
5862 ++YYCURSOR;
5863 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5864 goto yy161;
5865 }
5866 YYDEBUG(563, *YYCURSOR);
5867 yyleng = YYCURSOR - SCNG(yy_text);
5868 {
5869 RETURN_TOKEN(T_ABSTRACT);
5870 }
5871 yy564:
5872 YYDEBUG(564, *YYCURSOR);
5873 yych = *++YYCURSOR;
5874 if (yych == 'I') goto yy565;
5875 if (yych != 'i') goto yy162;
5876 yy565:
5877 YYDEBUG(565, *YYCURSOR);
5878 yych = *++YYCURSOR;
5879 if (yych == 'L') goto yy566;
5880 if (yych != 'l') goto yy162;
5881 yy566:
5882 YYDEBUG(566, *YYCURSOR);
5883 yych = *++YYCURSOR;
5884 if (yych == 'E') goto yy567;
5885 if (yych != 'e') goto yy162;
5886 yy567:
5887 YYDEBUG(567, *YYCURSOR);
5888 ++YYCURSOR;
5889 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5890 goto yy161;
5891 }
5892 YYDEBUG(568, *YYCURSOR);
5893 yyleng = YYCURSOR - SCNG(yy_text);
5894 {
5895 RETURN_TOKEN(T_WHILE);
5896 }
5897 yy569:
5898 YYDEBUG(569, *YYCURSOR);
5899 ++YYCURSOR;
5900 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5901 goto yy161;
5902 }
5903 YYDEBUG(570, *YYCURSOR);
5904 yyleng = YYCURSOR - SCNG(yy_text);
5905 {
5906 RETURN_TOKEN(T_IF);
5907 }
5908 yy571:
5909 YYDEBUG(571, *YYCURSOR);
5910 yych = *++YYCURSOR;
5911 if (yych == 'P') goto yy613;
5912 if (yych == 'p') goto yy613;
5913 goto yy162;
5914 yy572:
5915 YYDEBUG(572, *YYCURSOR);
5916 yych = *++YYCURSOR;
5917 if (yych <= 'T') {
5918 if (yych <= 'C') {
5919 if (yych <= 'B') goto yy162;
5920 goto yy580;
5921 } else {
5922 if (yych <= 'R') goto yy162;
5923 if (yych <= 'S') goto yy578;
5924 goto yy579;
5925 }
5926 } else {
5927 if (yych <= 'r') {
5928 if (yych == 'c') goto yy580;
5929 goto yy162;
5930 } else {
5931 if (yych <= 's') goto yy578;
5932 if (yych <= 't') goto yy579;
5933 goto yy162;
5934 }
5935 }
5936 yy573:
5937 YYDEBUG(573, *YYCURSOR);
5938 yych = *++YYCURSOR;
5939 if (yych == 'S') goto yy574;
5940 if (yych != 's') goto yy162;
5941 yy574:
5942 YYDEBUG(574, *YYCURSOR);
5943 yych = *++YYCURSOR;
5944 if (yych == 'E') goto yy575;
5945 if (yych != 'e') goto yy162;
5946 yy575:
5947 YYDEBUG(575, *YYCURSOR);
5948 yych = *++YYCURSOR;
5949 if (yych == 'T') goto yy576;
5950 if (yych != 't') goto yy162;
5951 yy576:
5952 YYDEBUG(576, *YYCURSOR);
5953 ++YYCURSOR;
5954 if (yybm[0+(yych = *YYCURSOR)] & 4) {
5955 goto yy161;
5956 }
5957 YYDEBUG(577, *YYCURSOR);
5958 yyleng = YYCURSOR - SCNG(yy_text);
5959 {
5960 RETURN_TOKEN(T_ISSET);
5961 }
5962 yy578:
5963 YYDEBUG(578, *YYCURSOR);
5964 yych = *++YYCURSOR;
5965 if (yych == 'T') goto yy599;
5966 if (yych == 't') goto yy599;
5967 goto yy162;
5968 yy579:
5969 YYDEBUG(579, *YYCURSOR);
5970 yych = *++YYCURSOR;
5971 if (yych == 'E') goto yy592;
5972 if (yych == 'e') goto yy592;
5973 goto yy162;
5974 yy580:
5975 YYDEBUG(580, *YYCURSOR);
5976 yych = *++YYCURSOR;
5977 if (yych == 'L') goto yy581;
5978 if (yych != 'l') goto yy162;
5979 yy581:
5980 YYDEBUG(581, *YYCURSOR);
5981 yych = *++YYCURSOR;
5982 if (yych == 'U') goto yy582;
5983 if (yych != 'u') goto yy162;
5984 yy582:
5985 YYDEBUG(582, *YYCURSOR);
5986 yych = *++YYCURSOR;
5987 if (yych == 'D') goto yy583;
5988 if (yych != 'd') goto yy162;
5989 yy583:
5990 YYDEBUG(583, *YYCURSOR);
5991 yych = *++YYCURSOR;
5992 if (yych == 'E') goto yy584;
5993 if (yych != 'e') goto yy162;
5994 yy584:
5995 YYDEBUG(584, *YYCURSOR);
5996 ++YYCURSOR;
5997 if ((yych = *YYCURSOR) <= '^') {
5998 if (yych <= '9') {
5999 if (yych >= '0') goto yy161;
6000 } else {
6001 if (yych <= '@') goto yy585;
6002 if (yych <= 'Z') goto yy161;
6003 }
6004 } else {
6005 if (yych <= '`') {
6006 if (yych <= '_') goto yy586;
6007 } else {
6008 if (yych <= 'z') goto yy161;
6009 if (yych >= 0x80) goto yy161;
6010 }
6011 }
6012 yy585:
6013 YYDEBUG(585, *YYCURSOR);
6014 yyleng = YYCURSOR - SCNG(yy_text);
6015 {
6016 RETURN_TOKEN(T_INCLUDE);
6017 }
6018 yy586:
6019 YYDEBUG(586, *YYCURSOR);
6020 yych = *++YYCURSOR;
6021 if (yych == 'O') goto yy587;
6022 if (yych != 'o') goto yy162;
6023 yy587:
6024 YYDEBUG(587, *YYCURSOR);
6025 yych = *++YYCURSOR;
6026 if (yych == 'N') goto yy588;
6027 if (yych != 'n') goto yy162;
6028 yy588:
6029 YYDEBUG(588, *YYCURSOR);
6030 yych = *++YYCURSOR;
6031 if (yych == 'C') goto yy589;
6032 if (yych != 'c') goto yy162;
6033 yy589:
6034 YYDEBUG(589, *YYCURSOR);
6035 yych = *++YYCURSOR;
6036 if (yych == 'E') goto yy590;
6037 if (yych != 'e') goto yy162;
6038 yy590:
6039 YYDEBUG(590, *YYCURSOR);
6040 ++YYCURSOR;
6041 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6042 goto yy161;
6043 }
6044 YYDEBUG(591, *YYCURSOR);
6045 yyleng = YYCURSOR - SCNG(yy_text);
6046 {
6047 RETURN_TOKEN(T_INCLUDE_ONCE);
6048 }
6049 yy592:
6050 YYDEBUG(592, *YYCURSOR);
6051 yych = *++YYCURSOR;
6052 if (yych == 'R') goto yy593;
6053 if (yych != 'r') goto yy162;
6054 yy593:
6055 YYDEBUG(593, *YYCURSOR);
6056 yych = *++YYCURSOR;
6057 if (yych == 'F') goto yy594;
6058 if (yych != 'f') goto yy162;
6059 yy594:
6060 YYDEBUG(594, *YYCURSOR);
6061 yych = *++YYCURSOR;
6062 if (yych == 'A') goto yy595;
6063 if (yych != 'a') goto yy162;
6064 yy595:
6065 YYDEBUG(595, *YYCURSOR);
6066 yych = *++YYCURSOR;
6067 if (yych == 'C') goto yy596;
6068 if (yych != 'c') goto yy162;
6069 yy596:
6070 YYDEBUG(596, *YYCURSOR);
6071 yych = *++YYCURSOR;
6072 if (yych == 'E') goto yy597;
6073 if (yych != 'e') goto yy162;
6074 yy597:
6075 YYDEBUG(597, *YYCURSOR);
6076 ++YYCURSOR;
6077 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6078 goto yy161;
6079 }
6080 YYDEBUG(598, *YYCURSOR);
6081 yyleng = YYCURSOR - SCNG(yy_text);
6082 {
6083 RETURN_TOKEN(T_INTERFACE);
6084 }
6085 yy599:
6086 YYDEBUG(599, *YYCURSOR);
6087 yych = *++YYCURSOR;
6088 if (yych <= 'E') {
6089 if (yych == 'A') goto yy600;
6090 if (yych <= 'D') goto yy162;
6091 goto yy601;
6092 } else {
6093 if (yych <= 'a') {
6094 if (yych <= '`') goto yy162;
6095 } else {
6096 if (yych == 'e') goto yy601;
6097 goto yy162;
6098 }
6099 }
6100 yy600:
6101 YYDEBUG(600, *YYCURSOR);
6102 yych = *++YYCURSOR;
6103 if (yych == 'N') goto yy607;
6104 if (yych == 'n') goto yy607;
6105 goto yy162;
6106 yy601:
6107 YYDEBUG(601, *YYCURSOR);
6108 yych = *++YYCURSOR;
6109 if (yych == 'A') goto yy602;
6110 if (yych != 'a') goto yy162;
6111 yy602:
6112 YYDEBUG(602, *YYCURSOR);
6113 yych = *++YYCURSOR;
6114 if (yych == 'D') goto yy603;
6115 if (yych != 'd') goto yy162;
6116 yy603:
6117 YYDEBUG(603, *YYCURSOR);
6118 yych = *++YYCURSOR;
6119 if (yych == 'O') goto yy604;
6120 if (yych != 'o') goto yy162;
6121 yy604:
6122 YYDEBUG(604, *YYCURSOR);
6123 yych = *++YYCURSOR;
6124 if (yych == 'F') goto yy605;
6125 if (yych != 'f') goto yy162;
6126 yy605:
6127 YYDEBUG(605, *YYCURSOR);
6128 ++YYCURSOR;
6129 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6130 goto yy161;
6131 }
6132 YYDEBUG(606, *YYCURSOR);
6133 yyleng = YYCURSOR - SCNG(yy_text);
6134 {
6135 RETURN_TOKEN(T_INSTEADOF);
6136 }
6137 yy607:
6138 YYDEBUG(607, *YYCURSOR);
6139 yych = *++YYCURSOR;
6140 if (yych == 'C') goto yy608;
6141 if (yych != 'c') goto yy162;
6142 yy608:
6143 YYDEBUG(608, *YYCURSOR);
6144 yych = *++YYCURSOR;
6145 if (yych == 'E') goto yy609;
6146 if (yych != 'e') goto yy162;
6147 yy609:
6148 YYDEBUG(609, *YYCURSOR);
6149 yych = *++YYCURSOR;
6150 if (yych == 'O') goto yy610;
6151 if (yych != 'o') goto yy162;
6152 yy610:
6153 YYDEBUG(610, *YYCURSOR);
6154 yych = *++YYCURSOR;
6155 if (yych == 'F') goto yy611;
6156 if (yych != 'f') goto yy162;
6157 yy611:
6158 YYDEBUG(611, *YYCURSOR);
6159 ++YYCURSOR;
6160 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6161 goto yy161;
6162 }
6163 YYDEBUG(612, *YYCURSOR);
6164 yyleng = YYCURSOR - SCNG(yy_text);
6165 {
6166 RETURN_TOKEN(T_INSTANCEOF);
6167 }
6168 yy613:
6169 YYDEBUG(613, *YYCURSOR);
6170 yych = *++YYCURSOR;
6171 if (yych == 'L') goto yy614;
6172 if (yych != 'l') goto yy162;
6173 yy614:
6174 YYDEBUG(614, *YYCURSOR);
6175 yych = *++YYCURSOR;
6176 if (yych == 'E') goto yy615;
6177 if (yych != 'e') goto yy162;
6178 yy615:
6179 YYDEBUG(615, *YYCURSOR);
6180 yych = *++YYCURSOR;
6181 if (yych == 'M') goto yy616;
6182 if (yych != 'm') goto yy162;
6183 yy616:
6184 YYDEBUG(616, *YYCURSOR);
6185 yych = *++YYCURSOR;
6186 if (yych == 'E') goto yy617;
6187 if (yych != 'e') goto yy162;
6188 yy617:
6189 YYDEBUG(617, *YYCURSOR);
6190 yych = *++YYCURSOR;
6191 if (yych == 'N') goto yy618;
6192 if (yych != 'n') goto yy162;
6193 yy618:
6194 YYDEBUG(618, *YYCURSOR);
6195 yych = *++YYCURSOR;
6196 if (yych == 'T') goto yy619;
6197 if (yych != 't') goto yy162;
6198 yy619:
6199 YYDEBUG(619, *YYCURSOR);
6200 yych = *++YYCURSOR;
6201 if (yych == 'S') goto yy620;
6202 if (yych != 's') goto yy162;
6203 yy620:
6204 YYDEBUG(620, *YYCURSOR);
6205 ++YYCURSOR;
6206 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6207 goto yy161;
6208 }
6209 YYDEBUG(621, *YYCURSOR);
6210 yyleng = YYCURSOR - SCNG(yy_text);
6211 {
6212 RETURN_TOKEN(T_IMPLEMENTS);
6213 }
6214 yy622:
6215 YYDEBUG(622, *YYCURSOR);
6216 yych = *++YYCURSOR;
6217 if (yych == 'R') goto yy630;
6218 if (yych == 'r') goto yy630;
6219 goto yy162;
6220 yy623:
6221 YYDEBUG(623, *YYCURSOR);
6222 yych = *++YYCURSOR;
6223 if (yych <= 'Y') {
6224 if (yych == 'A') goto yy626;
6225 if (yych <= 'X') goto yy162;
6226 } else {
6227 if (yych <= 'a') {
6228 if (yych <= '`') goto yy162;
6229 goto yy626;
6230 } else {
6231 if (yych != 'y') goto yy162;
6232 }
6233 }
6234 YYDEBUG(624, *YYCURSOR);
6235 ++YYCURSOR;
6236 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6237 goto yy161;
6238 }
6239 YYDEBUG(625, *YYCURSOR);
6240 yyleng = YYCURSOR - SCNG(yy_text);
6241 {
6242 RETURN_TOKEN(T_TRY);
6243 }
6244 yy626:
6245 YYDEBUG(626, *YYCURSOR);
6246 yych = *++YYCURSOR;
6247 if (yych == 'I') goto yy627;
6248 if (yych != 'i') goto yy162;
6249 yy627:
6250 YYDEBUG(627, *YYCURSOR);
6251 yych = *++YYCURSOR;
6252 if (yych == 'T') goto yy628;
6253 if (yych != 't') goto yy162;
6254 yy628:
6255 YYDEBUG(628, *YYCURSOR);
6256 ++YYCURSOR;
6257 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6258 goto yy161;
6259 }
6260 YYDEBUG(629, *YYCURSOR);
6261 yyleng = YYCURSOR - SCNG(yy_text);
6262 {
6263 RETURN_TOKEN(T_TRAIT);
6264 }
6265 yy630:
6266 YYDEBUG(630, *YYCURSOR);
6267 yych = *++YYCURSOR;
6268 if (yych == 'O') goto yy631;
6269 if (yych != 'o') goto yy162;
6270 yy631:
6271 YYDEBUG(631, *YYCURSOR);
6272 yych = *++YYCURSOR;
6273 if (yych == 'W') goto yy632;
6274 if (yych != 'w') goto yy162;
6275 yy632:
6276 YYDEBUG(632, *YYCURSOR);
6277 ++YYCURSOR;
6278 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6279 goto yy161;
6280 }
6281 YYDEBUG(633, *YYCURSOR);
6282 yyleng = YYCURSOR - SCNG(yy_text);
6283 {
6284 RETURN_TOKEN(T_THROW);
6285 }
6286 yy634:
6287 YYDEBUG(634, *YYCURSOR);
6288 yych = *++YYCURSOR;
6289 if (yych == 'E') goto yy635;
6290 if (yych != 'e') goto yy162;
6291 yy635:
6292 YYDEBUG(635, *YYCURSOR);
6293 yych = *++YYCURSOR;
6294 if (yych == 'L') goto yy636;
6295 if (yych != 'l') goto yy162;
6296 yy636:
6297 YYDEBUG(636, *YYCURSOR);
6298 yych = *++YYCURSOR;
6299 if (yych == 'D') goto yy637;
6300 if (yych != 'd') goto yy162;
6301 yy637:
6302 YYDEBUG(637, *YYCURSOR);
6303 yyaccept = 8;
6304 yych = *(YYMARKER = ++YYCURSOR);
6305 if (yybm[0+yych] & 4) {
6306 goto yy161;
6307 }
6308 if (yych <= '\f') {
6309 if (yych <= 0x08) goto yy638;
6310 if (yych <= '\n') goto yy639;
6311 } else {
6312 if (yych <= '\r') goto yy639;
6313 if (yych == ' ') goto yy639;
6314 }
6315 yy638:
6316 YYDEBUG(638, *YYCURSOR);
6317 yyleng = YYCURSOR - SCNG(yy_text);
6318 {
6319 RETURN_TOKEN(T_YIELD);
6320 }
6321 yy639:
6322 YYDEBUG(639, *YYCURSOR);
6323 ++YYCURSOR;
6324 YYFILL(5);
6325 yych = *YYCURSOR;
6326 YYDEBUG(640, *YYCURSOR);
6327 if (yych <= 0x1F) {
6328 if (yych <= '\n') {
6329 if (yych <= 0x08) goto yy164;
6330 goto yy639;
6331 } else {
6332 if (yych == '\r') goto yy639;
6333 goto yy164;
6334 }
6335 } else {
6336 if (yych <= 'F') {
6337 if (yych <= ' ') goto yy639;
6338 if (yych <= 'E') goto yy164;
6339 } else {
6340 if (yych != 'f') goto yy164;
6341 }
6342 }
6343 YYDEBUG(641, *YYCURSOR);
6344 yych = *++YYCURSOR;
6345 if (yych == 'R') goto yy642;
6346 if (yych != 'r') goto yy164;
6347 yy642:
6348 YYDEBUG(642, *YYCURSOR);
6349 yych = *++YYCURSOR;
6350 if (yych == 'O') goto yy643;
6351 if (yych != 'o') goto yy164;
6352 yy643:
6353 YYDEBUG(643, *YYCURSOR);
6354 yych = *++YYCURSOR;
6355 if (yych == 'M') goto yy644;
6356 if (yych != 'm') goto yy164;
6357 yy644:
6358 YYDEBUG(644, *YYCURSOR);
6359 yych = *++YYCURSOR;
6360 if (yych <= '^') {
6361 if (yych <= '9') {
6362 if (yych >= '0') goto yy164;
6363 } else {
6364 if (yych <= '@') goto yy645;
6365 if (yych <= 'Z') goto yy164;
6366 }
6367 } else {
6368 if (yych <= '`') {
6369 if (yych <= '_') goto yy164;
6370 } else {
6371 if (yych <= 'z') goto yy164;
6372 if (yych >= 0x80) goto yy164;
6373 }
6374 }
6375 yy645:
6376 YYDEBUG(645, *YYCURSOR);
6377 ++YYCURSOR;
6378 YYDEBUG(646, *YYCURSOR);
6379 yyleng = YYCURSOR - SCNG(yy_text);
6380 {
6381 yyless(yyleng - 1);
6382 HANDLE_NEWLINES(yytext, yyleng);
6383 RETURN_TOKEN(T_YIELD_FROM);
6384 }
6385 yy647:
6386 YYDEBUG(647, *YYCURSOR);
6387 yych = *++YYCURSOR;
6388 if (yych <= 'T') {
6389 if (yych == 'Q') goto yy649;
6390 if (yych <= 'S') goto yy162;
6391 } else {
6392 if (yych <= 'q') {
6393 if (yych <= 'p') goto yy162;
6394 goto yy649;
6395 } else {
6396 if (yych != 't') goto yy162;
6397 }
6398 }
6399 YYDEBUG(648, *YYCURSOR);
6400 yych = *++YYCURSOR;
6401 if (yych == 'U') goto yy661;
6402 if (yych == 'u') goto yy661;
6403 goto yy162;
6404 yy649:
6405 YYDEBUG(649, *YYCURSOR);
6406 yych = *++YYCURSOR;
6407 if (yych == 'U') goto yy650;
6408 if (yych != 'u') goto yy162;
6409 yy650:
6410 YYDEBUG(650, *YYCURSOR);
6411 yych = *++YYCURSOR;
6412 if (yych == 'I') goto yy651;
6413 if (yych != 'i') goto yy162;
6414 yy651:
6415 YYDEBUG(651, *YYCURSOR);
6416 yych = *++YYCURSOR;
6417 if (yych == 'R') goto yy652;
6418 if (yych != 'r') goto yy162;
6419 yy652:
6420 YYDEBUG(652, *YYCURSOR);
6421 yych = *++YYCURSOR;
6422 if (yych == 'E') goto yy653;
6423 if (yych != 'e') goto yy162;
6424 yy653:
6425 YYDEBUG(653, *YYCURSOR);
6426 ++YYCURSOR;
6427 if ((yych = *YYCURSOR) <= '^') {
6428 if (yych <= '9') {
6429 if (yych >= '0') goto yy161;
6430 } else {
6431 if (yych <= '@') goto yy654;
6432 if (yych <= 'Z') goto yy161;
6433 }
6434 } else {
6435 if (yych <= '`') {
6436 if (yych <= '_') goto yy655;
6437 } else {
6438 if (yych <= 'z') goto yy161;
6439 if (yych >= 0x80) goto yy161;
6440 }
6441 }
6442 yy654:
6443 YYDEBUG(654, *YYCURSOR);
6444 yyleng = YYCURSOR - SCNG(yy_text);
6445 {
6446 RETURN_TOKEN(T_REQUIRE);
6447 }
6448 yy655:
6449 YYDEBUG(655, *YYCURSOR);
6450 yych = *++YYCURSOR;
6451 if (yych == 'O') goto yy656;
6452 if (yych != 'o') goto yy162;
6453 yy656:
6454 YYDEBUG(656, *YYCURSOR);
6455 yych = *++YYCURSOR;
6456 if (yych == 'N') goto yy657;
6457 if (yych != 'n') goto yy162;
6458 yy657:
6459 YYDEBUG(657, *YYCURSOR);
6460 yych = *++YYCURSOR;
6461 if (yych == 'C') goto yy658;
6462 if (yych != 'c') goto yy162;
6463 yy658:
6464 YYDEBUG(658, *YYCURSOR);
6465 yych = *++YYCURSOR;
6466 if (yych == 'E') goto yy659;
6467 if (yych != 'e') goto yy162;
6468 yy659:
6469 YYDEBUG(659, *YYCURSOR);
6470 ++YYCURSOR;
6471 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6472 goto yy161;
6473 }
6474 YYDEBUG(660, *YYCURSOR);
6475 yyleng = YYCURSOR - SCNG(yy_text);
6476 {
6477 RETURN_TOKEN(T_REQUIRE_ONCE);
6478 }
6479 yy661:
6480 YYDEBUG(661, *YYCURSOR);
6481 yych = *++YYCURSOR;
6482 if (yych == 'R') goto yy662;
6483 if (yych != 'r') goto yy162;
6484 yy662:
6485 YYDEBUG(662, *YYCURSOR);
6486 yych = *++YYCURSOR;
6487 if (yych == 'N') goto yy663;
6488 if (yych != 'n') goto yy162;
6489 yy663:
6490 YYDEBUG(663, *YYCURSOR);
6491 ++YYCURSOR;
6492 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6493 goto yy161;
6494 }
6495 YYDEBUG(664, *YYCURSOR);
6496 yyleng = YYCURSOR - SCNG(yy_text);
6497 {
6498 RETURN_TOKEN(T_RETURN);
6499 }
6500 yy665:
6501 YYDEBUG(665, *YYCURSOR);
6502 yych = *++YYCURSOR;
6503 if (yych <= 'T') {
6504 if (yych <= 'L') {
6505 if (yych <= 'K') goto yy162;
6506 goto yy688;
6507 } else {
6508 if (yych <= 'R') goto yy162;
6509 if (yych <= 'S') goto yy687;
6510 goto yy686;
6511 }
6512 } else {
6513 if (yych <= 'r') {
6514 if (yych == 'l') goto yy688;
6515 goto yy162;
6516 } else {
6517 if (yych <= 's') goto yy687;
6518 if (yych <= 't') goto yy686;
6519 goto yy162;
6520 }
6521 }
6522 yy666:
6523 YYDEBUG(666, *YYCURSOR);
6524 yych = *++YYCURSOR;
6525 if (yych <= 'O') {
6526 if (yych == 'A') goto yy678;
6527 if (yych <= 'N') goto yy162;
6528 goto yy679;
6529 } else {
6530 if (yych <= 'a') {
6531 if (yych <= '`') goto yy162;
6532 goto yy678;
6533 } else {
6534 if (yych == 'o') goto yy679;
6535 goto yy162;
6536 }
6537 }
6538 yy667:
6539 YYDEBUG(667, *YYCURSOR);
6540 yych = *++YYCURSOR;
6541 if (yych == 'N') goto yy668;
6542 if (yych != 'n') goto yy162;
6543 yy668:
6544 YYDEBUG(668, *YYCURSOR);
6545 yych = *++YYCURSOR;
6546 if (yych <= 'T') {
6547 if (yych <= 'R') goto yy162;
6548 if (yych >= 'T') goto yy670;
6549 } else {
6550 if (yych <= 'r') goto yy162;
6551 if (yych <= 's') goto yy669;
6552 if (yych <= 't') goto yy670;
6553 goto yy162;
6554 }
6555 yy669:
6556 YYDEBUG(669, *YYCURSOR);
6557 yych = *++YYCURSOR;
6558 if (yych == 'T') goto yy676;
6559 if (yych == 't') goto yy676;
6560 goto yy162;
6561 yy670:
6562 YYDEBUG(670, *YYCURSOR);
6563 yych = *++YYCURSOR;
6564 if (yych == 'I') goto yy671;
6565 if (yych != 'i') goto yy162;
6566 yy671:
6567 YYDEBUG(671, *YYCURSOR);
6568 yych = *++YYCURSOR;
6569 if (yych == 'N') goto yy672;
6570 if (yych != 'n') goto yy162;
6571 yy672:
6572 YYDEBUG(672, *YYCURSOR);
6573 yych = *++YYCURSOR;
6574 if (yych == 'U') goto yy673;
6575 if (yych != 'u') goto yy162;
6576 yy673:
6577 YYDEBUG(673, *YYCURSOR);
6578 yych = *++YYCURSOR;
6579 if (yych == 'E') goto yy674;
6580 if (yych != 'e') goto yy162;
6581 yy674:
6582 YYDEBUG(674, *YYCURSOR);
6583 ++YYCURSOR;
6584 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6585 goto yy161;
6586 }
6587 YYDEBUG(675, *YYCURSOR);
6588 yyleng = YYCURSOR - SCNG(yy_text);
6589 {
6590 RETURN_TOKEN(T_CONTINUE);
6591 }
6592 yy676:
6593 YYDEBUG(676, *YYCURSOR);
6594 ++YYCURSOR;
6595 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6596 goto yy161;
6597 }
6598 YYDEBUG(677, *YYCURSOR);
6599 yyleng = YYCURSOR - SCNG(yy_text);
6600 {
6601 RETURN_TOKEN(T_CONST);
6602 }
6603 yy678:
6604 YYDEBUG(678, *YYCURSOR);
6605 yych = *++YYCURSOR;
6606 if (yych == 'S') goto yy683;
6607 if (yych == 's') goto yy683;
6608 goto yy162;
6609 yy679:
6610 YYDEBUG(679, *YYCURSOR);
6611 yych = *++YYCURSOR;
6612 if (yych == 'N') goto yy680;
6613 if (yych != 'n') goto yy162;
6614 yy680:
6615 YYDEBUG(680, *YYCURSOR);
6616 yych = *++YYCURSOR;
6617 if (yych == 'E') goto yy681;
6618 if (yych != 'e') goto yy162;
6619 yy681:
6620 YYDEBUG(681, *YYCURSOR);
6621 ++YYCURSOR;
6622 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6623 goto yy161;
6624 }
6625 YYDEBUG(682, *YYCURSOR);
6626 yyleng = YYCURSOR - SCNG(yy_text);
6627 {
6628 RETURN_TOKEN(T_CLONE);
6629 }
6630 yy683:
6631 YYDEBUG(683, *YYCURSOR);
6632 yych = *++YYCURSOR;
6633 if (yych == 'S') goto yy684;
6634 if (yych != 's') goto yy162;
6635 yy684:
6636 YYDEBUG(684, *YYCURSOR);
6637 ++YYCURSOR;
6638 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6639 goto yy161;
6640 }
6641 YYDEBUG(685, *YYCURSOR);
6642 yyleng = YYCURSOR - SCNG(yy_text);
6643 {
6644 RETURN_TOKEN(T_CLASS);
6645 }
6646 yy686:
6647 YYDEBUG(686, *YYCURSOR);
6648 yych = *++YYCURSOR;
6649 if (yych == 'C') goto yy697;
6650 if (yych == 'c') goto yy697;
6651 goto yy162;
6652 yy687:
6653 YYDEBUG(687, *YYCURSOR);
6654 yych = *++YYCURSOR;
6655 if (yych == 'E') goto yy695;
6656 if (yych == 'e') goto yy695;
6657 goto yy162;
6658 yy688:
6659 YYDEBUG(688, *YYCURSOR);
6660 yych = *++YYCURSOR;
6661 if (yych == 'L') goto yy689;
6662 if (yych != 'l') goto yy162;
6663 yy689:
6664 YYDEBUG(689, *YYCURSOR);
6665 yych = *++YYCURSOR;
6666 if (yych == 'A') goto yy690;
6667 if (yych != 'a') goto yy162;
6668 yy690:
6669 YYDEBUG(690, *YYCURSOR);
6670 yych = *++YYCURSOR;
6671 if (yych == 'B') goto yy691;
6672 if (yych != 'b') goto yy162;
6673 yy691:
6674 YYDEBUG(691, *YYCURSOR);
6675 yych = *++YYCURSOR;
6676 if (yych == 'L') goto yy692;
6677 if (yych != 'l') goto yy162;
6678 yy692:
6679 YYDEBUG(692, *YYCURSOR);
6680 yych = *++YYCURSOR;
6681 if (yych == 'E') goto yy693;
6682 if (yych != 'e') goto yy162;
6683 yy693:
6684 YYDEBUG(693, *YYCURSOR);
6685 ++YYCURSOR;
6686 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6687 goto yy161;
6688 }
6689 YYDEBUG(694, *YYCURSOR);
6690 yyleng = YYCURSOR - SCNG(yy_text);
6691 {
6692 RETURN_TOKEN(T_CALLABLE);
6693 }
6694 yy695:
6695 YYDEBUG(695, *YYCURSOR);
6696 ++YYCURSOR;
6697 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6698 goto yy161;
6699 }
6700 YYDEBUG(696, *YYCURSOR);
6701 yyleng = YYCURSOR - SCNG(yy_text);
6702 {
6703 RETURN_TOKEN(T_CASE);
6704 }
6705 yy697:
6706 YYDEBUG(697, *YYCURSOR);
6707 yych = *++YYCURSOR;
6708 if (yych == 'H') goto yy698;
6709 if (yych != 'h') goto yy162;
6710 yy698:
6711 YYDEBUG(698, *YYCURSOR);
6712 ++YYCURSOR;
6713 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6714 goto yy161;
6715 }
6716 YYDEBUG(699, *YYCURSOR);
6717 yyleng = YYCURSOR - SCNG(yy_text);
6718 {
6719 RETURN_TOKEN(T_CATCH);
6720 }
6721 yy700:
6722 YYDEBUG(700, *YYCURSOR);
6723 yych = *++YYCURSOR;
6724 if (yych == 'N') goto yy719;
6725 if (yych == 'n') goto yy719;
6726 goto yy162;
6727 yy701:
6728 YYDEBUG(701, *YYCURSOR);
6729 ++YYCURSOR;
6730 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6731 goto yy161;
6732 }
6733 YYDEBUG(702, *YYCURSOR);
6734 yyleng = YYCURSOR - SCNG(yy_text);
6735 {
6736 RETURN_TOKEN(T_FN);
6737 }
6738 yy703:
6739 YYDEBUG(703, *YYCURSOR);
6740 yych = *++YYCURSOR;
6741 if (yych == 'R') goto yy712;
6742 if (yych == 'r') goto yy712;
6743 goto yy162;
6744 yy704:
6745 YYDEBUG(704, *YYCURSOR);
6746 yych = *++YYCURSOR;
6747 if (yych == 'N') goto yy705;
6748 if (yych != 'n') goto yy162;
6749 yy705:
6750 YYDEBUG(705, *YYCURSOR);
6751 yych = *++YYCURSOR;
6752 if (yych == 'C') goto yy706;
6753 if (yych != 'c') goto yy162;
6754 yy706:
6755 YYDEBUG(706, *YYCURSOR);
6756 yych = *++YYCURSOR;
6757 if (yych == 'T') goto yy707;
6758 if (yych != 't') goto yy162;
6759 yy707:
6760 YYDEBUG(707, *YYCURSOR);
6761 yych = *++YYCURSOR;
6762 if (yych == 'I') goto yy708;
6763 if (yych != 'i') goto yy162;
6764 yy708:
6765 YYDEBUG(708, *YYCURSOR);
6766 yych = *++YYCURSOR;
6767 if (yych == 'O') goto yy709;
6768 if (yych != 'o') goto yy162;
6769 yy709:
6770 YYDEBUG(709, *YYCURSOR);
6771 yych = *++YYCURSOR;
6772 if (yych == 'N') goto yy710;
6773 if (yych != 'n') goto yy162;
6774 yy710:
6775 YYDEBUG(710, *YYCURSOR);
6776 ++YYCURSOR;
6777 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6778 goto yy161;
6779 }
6780 YYDEBUG(711, *YYCURSOR);
6781 yyleng = YYCURSOR - SCNG(yy_text);
6782 {
6783 RETURN_TOKEN(T_FUNCTION);
6784 }
6785 yy712:
6786 YYDEBUG(712, *YYCURSOR);
6787 ++YYCURSOR;
6788 if ((yych = *YYCURSOR) <= '^') {
6789 if (yych <= '@') {
6790 if (yych <= '/') goto yy713;
6791 if (yych <= '9') goto yy161;
6792 } else {
6793 if (yych == 'E') goto yy714;
6794 if (yych <= 'Z') goto yy161;
6795 }
6796 } else {
6797 if (yych <= 'd') {
6798 if (yych != '`') goto yy161;
6799 } else {
6800 if (yych <= 'e') goto yy714;
6801 if (yych <= 'z') goto yy161;
6802 if (yych >= 0x80) goto yy161;
6803 }
6804 }
6805 yy713:
6806 YYDEBUG(713, *YYCURSOR);
6807 yyleng = YYCURSOR - SCNG(yy_text);
6808 {
6809 RETURN_TOKEN(T_FOR);
6810 }
6811 yy714:
6812 YYDEBUG(714, *YYCURSOR);
6813 yych = *++YYCURSOR;
6814 if (yych == 'A') goto yy715;
6815 if (yych != 'a') goto yy162;
6816 yy715:
6817 YYDEBUG(715, *YYCURSOR);
6818 yych = *++YYCURSOR;
6819 if (yych == 'C') goto yy716;
6820 if (yych != 'c') goto yy162;
6821 yy716:
6822 YYDEBUG(716, *YYCURSOR);
6823 yych = *++YYCURSOR;
6824 if (yych == 'H') goto yy717;
6825 if (yych != 'h') goto yy162;
6826 yy717:
6827 YYDEBUG(717, *YYCURSOR);
6828 ++YYCURSOR;
6829 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6830 goto yy161;
6831 }
6832 YYDEBUG(718, *YYCURSOR);
6833 yyleng = YYCURSOR - SCNG(yy_text);
6834 {
6835 RETURN_TOKEN(T_FOREACH);
6836 }
6837 yy719:
6838 YYDEBUG(719, *YYCURSOR);
6839 yych = *++YYCURSOR;
6840 if (yych == 'A') goto yy720;
6841 if (yych != 'a') goto yy162;
6842 yy720:
6843 YYDEBUG(720, *YYCURSOR);
6844 yych = *++YYCURSOR;
6845 if (yych == 'L') goto yy721;
6846 if (yych != 'l') goto yy162;
6847 yy721:
6848 YYDEBUG(721, *YYCURSOR);
6849 ++YYCURSOR;
6850 if ((yych = *YYCURSOR) <= '^') {
6851 if (yych <= '@') {
6852 if (yych <= '/') goto yy722;
6853 if (yych <= '9') goto yy161;
6854 } else {
6855 if (yych == 'L') goto yy723;
6856 if (yych <= 'Z') goto yy161;
6857 }
6858 } else {
6859 if (yych <= 'k') {
6860 if (yych != '`') goto yy161;
6861 } else {
6862 if (yych <= 'l') goto yy723;
6863 if (yych <= 'z') goto yy161;
6864 if (yych >= 0x80) goto yy161;
6865 }
6866 }
6867 yy722:
6868 YYDEBUG(722, *YYCURSOR);
6869 yyleng = YYCURSOR - SCNG(yy_text);
6870 {
6871 RETURN_TOKEN(T_FINAL);
6872 }
6873 yy723:
6874 YYDEBUG(723, *YYCURSOR);
6875 yych = *++YYCURSOR;
6876 if (yych == 'Y') goto yy724;
6877 if (yych != 'y') goto yy162;
6878 yy724:
6879 YYDEBUG(724, *YYCURSOR);
6880 ++YYCURSOR;
6881 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6882 goto yy161;
6883 }
6884 YYDEBUG(725, *YYCURSOR);
6885 yyleng = YYCURSOR - SCNG(yy_text);
6886 {
6887 RETURN_TOKEN(T_FINALLY);
6888 }
6889 yy726:
6890 YYDEBUG(726, *YYCURSOR);
6891 yych = *++YYCURSOR;
6892 if (yych <= 'F') {
6893 if (yych == 'C') goto yy732;
6894 if (yych <= 'E') goto yy162;
6895 goto yy733;
6896 } else {
6897 if (yych <= 'c') {
6898 if (yych <= 'b') goto yy162;
6899 goto yy732;
6900 } else {
6901 if (yych == 'f') goto yy733;
6902 goto yy162;
6903 }
6904 }
6905 yy727:
6906 YYDEBUG(727, *YYCURSOR);
6907 yych = *++YYCURSOR;
6908 if (yych == 'E') goto yy730;
6909 if (yych == 'e') goto yy730;
6910 goto yy162;
6911 yy728:
6912 YYDEBUG(728, *YYCURSOR);
6913 ++YYCURSOR;
6914 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6915 goto yy161;
6916 }
6917 YYDEBUG(729, *YYCURSOR);
6918 yyleng = YYCURSOR - SCNG(yy_text);
6919 {
6920 RETURN_TOKEN(T_DO);
6921 }
6922 yy730:
6923 YYDEBUG(730, *YYCURSOR);
6924 ++YYCURSOR;
6925 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6926 goto yy161;
6927 }
6928 YYDEBUG(731, *YYCURSOR);
6929 yyleng = YYCURSOR - SCNG(yy_text);
6930 {
6931 RETURN_TOKEN(T_EXIT);
6932 }
6933 yy732:
6934 YYDEBUG(732, *YYCURSOR);
6935 yych = *++YYCURSOR;
6936 if (yych == 'L') goto yy739;
6937 if (yych == 'l') goto yy739;
6938 goto yy162;
6939 yy733:
6940 YYDEBUG(733, *YYCURSOR);
6941 yych = *++YYCURSOR;
6942 if (yych == 'A') goto yy734;
6943 if (yych != 'a') goto yy162;
6944 yy734:
6945 YYDEBUG(734, *YYCURSOR);
6946 yych = *++YYCURSOR;
6947 if (yych == 'U') goto yy735;
6948 if (yych != 'u') goto yy162;
6949 yy735:
6950 YYDEBUG(735, *YYCURSOR);
6951 yych = *++YYCURSOR;
6952 if (yych == 'L') goto yy736;
6953 if (yych != 'l') goto yy162;
6954 yy736:
6955 YYDEBUG(736, *YYCURSOR);
6956 yych = *++YYCURSOR;
6957 if (yych == 'T') goto yy737;
6958 if (yych != 't') goto yy162;
6959 yy737:
6960 YYDEBUG(737, *YYCURSOR);
6961 ++YYCURSOR;
6962 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6963 goto yy161;
6964 }
6965 YYDEBUG(738, *YYCURSOR);
6966 yyleng = YYCURSOR - SCNG(yy_text);
6967 {
6968 RETURN_TOKEN(T_DEFAULT);
6969 }
6970 yy739:
6971 YYDEBUG(739, *YYCURSOR);
6972 yych = *++YYCURSOR;
6973 if (yych == 'A') goto yy740;
6974 if (yych != 'a') goto yy162;
6975 yy740:
6976 YYDEBUG(740, *YYCURSOR);
6977 yych = *++YYCURSOR;
6978 if (yych == 'R') goto yy741;
6979 if (yych != 'r') goto yy162;
6980 yy741:
6981 YYDEBUG(741, *YYCURSOR);
6982 yych = *++YYCURSOR;
6983 if (yych == 'E') goto yy742;
6984 if (yych != 'e') goto yy162;
6985 yy742:
6986 YYDEBUG(742, *YYCURSOR);
6987 ++YYCURSOR;
6988 if (yybm[0+(yych = *YYCURSOR)] & 4) {
6989 goto yy161;
6990 }
6991 YYDEBUG(743, *YYCURSOR);
6992 yyleng = YYCURSOR - SCNG(yy_text);
6993 {
6994 RETURN_TOKEN(T_DECLARE);
6995 }
6996 yy744:
6997 YYDEBUG(744, *YYCURSOR);
6998 yych = *++YYCURSOR;
6999 if (yych == 'H') goto yy806;
7000 if (yych == 'h') goto yy806;
7001 goto yy162;
7002 yy745:
7003 YYDEBUG(745, *YYCURSOR);
7004 yych = *++YYCURSOR;
7005 if (yych == 'S') goto yy800;
7006 if (yych == 's') goto yy800;
7007 goto yy162;
7008 yy746:
7009 YYDEBUG(746, *YYCURSOR);
7010 yych = *++YYCURSOR;
7011 if (yych == 'P') goto yy796;
7012 if (yych == 'p') goto yy796;
7013 goto yy162;
7014 yy747:
7015 YYDEBUG(747, *YYCURSOR);
7016 yych = *++YYCURSOR;
7017 if (yych == 'D') goto yy762;
7018 if (yych == 'd') goto yy762;
7019 goto yy162;
7020 yy748:
7021 YYDEBUG(748, *YYCURSOR);
7022 yych = *++YYCURSOR;
7023 if (yych == 'A') goto yy759;
7024 if (yych == 'a') goto yy759;
7025 goto yy162;
7026 yy749:
7027 YYDEBUG(749, *YYCURSOR);
7028 yych = *++YYCURSOR;
7029 if (yych <= 'T') {
7030 if (yych == 'I') goto yy750;
7031 if (yych <= 'S') goto yy162;
7032 goto yy751;
7033 } else {
7034 if (yych <= 'i') {
7035 if (yych <= 'h') goto yy162;
7036 } else {
7037 if (yych == 't') goto yy751;
7038 goto yy162;
7039 }
7040 }
7041 yy750:
7042 YYDEBUG(750, *YYCURSOR);
7043 yych = *++YYCURSOR;
7044 if (yych == 'T') goto yy757;
7045 if (yych == 't') goto yy757;
7046 goto yy162;
7047 yy751:
7048 YYDEBUG(751, *YYCURSOR);
7049 yych = *++YYCURSOR;
7050 if (yych == 'E') goto yy752;
7051 if (yych != 'e') goto yy162;
7052 yy752:
7053 YYDEBUG(752, *YYCURSOR);
7054 yych = *++YYCURSOR;
7055 if (yych == 'N') goto yy753;
7056 if (yych != 'n') goto yy162;
7057 yy753:
7058 YYDEBUG(753, *YYCURSOR);
7059 yych = *++YYCURSOR;
7060 if (yych == 'D') goto yy754;
7061 if (yych != 'd') goto yy162;
7062 yy754:
7063 YYDEBUG(754, *YYCURSOR);
7064 yych = *++YYCURSOR;
7065 if (yych == 'S') goto yy755;
7066 if (yych != 's') goto yy162;
7067 yy755:
7068 YYDEBUG(755, *YYCURSOR);
7069 ++YYCURSOR;
7070 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7071 goto yy161;
7072 }
7073 YYDEBUG(756, *YYCURSOR);
7074 yyleng = YYCURSOR - SCNG(yy_text);
7075 {
7076 RETURN_TOKEN(T_EXTENDS);
7077 }
7078 yy757:
7079 YYDEBUG(757, *YYCURSOR);
7080 ++YYCURSOR;
7081 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7082 goto yy161;
7083 }
7084 YYDEBUG(758, *YYCURSOR);
7085 yyleng = YYCURSOR - SCNG(yy_text);
7086 {
7087 RETURN_TOKEN(T_EXIT);
7088 }
7089 yy759:
7090 YYDEBUG(759, *YYCURSOR);
7091 yych = *++YYCURSOR;
7092 if (yych == 'L') goto yy760;
7093 if (yych != 'l') goto yy162;
7094 yy760:
7095 YYDEBUG(760, *YYCURSOR);
7096 ++YYCURSOR;
7097 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7098 goto yy161;
7099 }
7100 YYDEBUG(761, *YYCURSOR);
7101 yyleng = YYCURSOR - SCNG(yy_text);
7102 {
7103 RETURN_TOKEN(T_EVAL);
7104 }
7105 yy762:
7106 YYDEBUG(762, *YYCURSOR);
7107 yych = *++YYCURSOR;
7108 YYDEBUG(-1, yych);
7109 switch (yych) {
7110 case 'D':
7111 case 'd': goto yy763;
7112 case 'F':
7113 case 'f': goto yy764;
7114 case 'I':
7115 case 'i': goto yy765;
7116 case 'S':
7117 case 's': goto yy766;
7118 case 'W':
7119 case 'w': goto yy767;
7120 default: goto yy162;
7121 }
7122 yy763:
7123 YYDEBUG(763, *YYCURSOR);
7124 yych = *++YYCURSOR;
7125 if (yych == 'E') goto yy789;
7126 if (yych == 'e') goto yy789;
7127 goto yy162;
7128 yy764:
7129 YYDEBUG(764, *YYCURSOR);
7130 yych = *++YYCURSOR;
7131 if (yych == 'O') goto yy781;
7132 if (yych == 'o') goto yy781;
7133 goto yy162;
7134 yy765:
7135 YYDEBUG(765, *YYCURSOR);
7136 yych = *++YYCURSOR;
7137 if (yych == 'F') goto yy779;
7138 if (yych == 'f') goto yy779;
7139 goto yy162;
7140 yy766:
7141 YYDEBUG(766, *YYCURSOR);
7142 yych = *++YYCURSOR;
7143 if (yych == 'W') goto yy773;
7144 if (yych == 'w') goto yy773;
7145 goto yy162;
7146 yy767:
7147 YYDEBUG(767, *YYCURSOR);
7148 yych = *++YYCURSOR;
7149 if (yych == 'H') goto yy768;
7150 if (yych != 'h') goto yy162;
7151 yy768:
7152 YYDEBUG(768, *YYCURSOR);
7153 yych = *++YYCURSOR;
7154 if (yych == 'I') goto yy769;
7155 if (yych != 'i') goto yy162;
7156 yy769:
7157 YYDEBUG(769, *YYCURSOR);
7158 yych = *++YYCURSOR;
7159 if (yych == 'L') goto yy770;
7160 if (yych != 'l') goto yy162;
7161 yy770:
7162 YYDEBUG(770, *YYCURSOR);
7163 yych = *++YYCURSOR;
7164 if (yych == 'E') goto yy771;
7165 if (yych != 'e') goto yy162;
7166 yy771:
7167 YYDEBUG(771, *YYCURSOR);
7168 ++YYCURSOR;
7169 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7170 goto yy161;
7171 }
7172 YYDEBUG(772, *YYCURSOR);
7173 yyleng = YYCURSOR - SCNG(yy_text);
7174 {
7175 RETURN_TOKEN(T_ENDWHILE);
7176 }
7177 yy773:
7178 YYDEBUG(773, *YYCURSOR);
7179 yych = *++YYCURSOR;
7180 if (yych == 'I') goto yy774;
7181 if (yych != 'i') goto yy162;
7182 yy774:
7183 YYDEBUG(774, *YYCURSOR);
7184 yych = *++YYCURSOR;
7185 if (yych == 'T') goto yy775;
7186 if (yych != 't') goto yy162;
7187 yy775:
7188 YYDEBUG(775, *YYCURSOR);
7189 yych = *++YYCURSOR;
7190 if (yych == 'C') goto yy776;
7191 if (yych != 'c') goto yy162;
7192 yy776:
7193 YYDEBUG(776, *YYCURSOR);
7194 yych = *++YYCURSOR;
7195 if (yych == 'H') goto yy777;
7196 if (yych != 'h') goto yy162;
7197 yy777:
7198 YYDEBUG(777, *YYCURSOR);
7199 ++YYCURSOR;
7200 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7201 goto yy161;
7202 }
7203 YYDEBUG(778, *YYCURSOR);
7204 yyleng = YYCURSOR - SCNG(yy_text);
7205 {
7206 RETURN_TOKEN(T_ENDSWITCH);
7207 }
7208 yy779:
7209 YYDEBUG(779, *YYCURSOR);
7210 ++YYCURSOR;
7211 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7212 goto yy161;
7213 }
7214 YYDEBUG(780, *YYCURSOR);
7215 yyleng = YYCURSOR - SCNG(yy_text);
7216 {
7217 RETURN_TOKEN(T_ENDIF);
7218 }
7219 yy781:
7220 YYDEBUG(781, *YYCURSOR);
7221 yych = *++YYCURSOR;
7222 if (yych == 'R') goto yy782;
7223 if (yych != 'r') goto yy162;
7224 yy782:
7225 YYDEBUG(782, *YYCURSOR);
7226 ++YYCURSOR;
7227 if ((yych = *YYCURSOR) <= '^') {
7228 if (yych <= '@') {
7229 if (yych <= '/') goto yy783;
7230 if (yych <= '9') goto yy161;
7231 } else {
7232 if (yych == 'E') goto yy784;
7233 if (yych <= 'Z') goto yy161;
7234 }
7235 } else {
7236 if (yych <= 'd') {
7237 if (yych != '`') goto yy161;
7238 } else {
7239 if (yych <= 'e') goto yy784;
7240 if (yych <= 'z') goto yy161;
7241 if (yych >= 0x80) goto yy161;
7242 }
7243 }
7244 yy783:
7245 YYDEBUG(783, *YYCURSOR);
7246 yyleng = YYCURSOR - SCNG(yy_text);
7247 {
7248 RETURN_TOKEN(T_ENDFOR);
7249 }
7250 yy784:
7251 YYDEBUG(784, *YYCURSOR);
7252 yych = *++YYCURSOR;
7253 if (yych == 'A') goto yy785;
7254 if (yych != 'a') goto yy162;
7255 yy785:
7256 YYDEBUG(785, *YYCURSOR);
7257 yych = *++YYCURSOR;
7258 if (yych == 'C') goto yy786;
7259 if (yych != 'c') goto yy162;
7260 yy786:
7261 YYDEBUG(786, *YYCURSOR);
7262 yych = *++YYCURSOR;
7263 if (yych == 'H') goto yy787;
7264 if (yych != 'h') goto yy162;
7265 yy787:
7266 YYDEBUG(787, *YYCURSOR);
7267 ++YYCURSOR;
7268 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7269 goto yy161;
7270 }
7271 YYDEBUG(788, *YYCURSOR);
7272 yyleng = YYCURSOR - SCNG(yy_text);
7273 {
7274 RETURN_TOKEN(T_ENDFOREACH);
7275 }
7276 yy789:
7277 YYDEBUG(789, *YYCURSOR);
7278 yych = *++YYCURSOR;
7279 if (yych == 'C') goto yy790;
7280 if (yych != 'c') goto yy162;
7281 yy790:
7282 YYDEBUG(790, *YYCURSOR);
7283 yych = *++YYCURSOR;
7284 if (yych == 'L') goto yy791;
7285 if (yych != 'l') goto yy162;
7286 yy791:
7287 YYDEBUG(791, *YYCURSOR);
7288 yych = *++YYCURSOR;
7289 if (yych == 'A') goto yy792;
7290 if (yych != 'a') goto yy162;
7291 yy792:
7292 YYDEBUG(792, *YYCURSOR);
7293 yych = *++YYCURSOR;
7294 if (yych == 'R') goto yy793;
7295 if (yych != 'r') goto yy162;
7296 yy793:
7297 YYDEBUG(793, *YYCURSOR);
7298 yych = *++YYCURSOR;
7299 if (yych == 'E') goto yy794;
7300 if (yych != 'e') goto yy162;
7301 yy794:
7302 YYDEBUG(794, *YYCURSOR);
7303 ++YYCURSOR;
7304 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7305 goto yy161;
7306 }
7307 YYDEBUG(795, *YYCURSOR);
7308 yyleng = YYCURSOR - SCNG(yy_text);
7309 {
7310 RETURN_TOKEN(T_ENDDECLARE);
7311 }
7312 yy796:
7313 YYDEBUG(796, *YYCURSOR);
7314 yych = *++YYCURSOR;
7315 if (yych == 'T') goto yy797;
7316 if (yych != 't') goto yy162;
7317 yy797:
7318 YYDEBUG(797, *YYCURSOR);
7319 yych = *++YYCURSOR;
7320 if (yych == 'Y') goto yy798;
7321 if (yych != 'y') goto yy162;
7322 yy798:
7323 YYDEBUG(798, *YYCURSOR);
7324 ++YYCURSOR;
7325 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7326 goto yy161;
7327 }
7328 YYDEBUG(799, *YYCURSOR);
7329 yyleng = YYCURSOR - SCNG(yy_text);
7330 {
7331 RETURN_TOKEN(T_EMPTY);
7332 }
7333 yy800:
7334 YYDEBUG(800, *YYCURSOR);
7335 yych = *++YYCURSOR;
7336 if (yych == 'E') goto yy801;
7337 if (yych != 'e') goto yy162;
7338 yy801:
7339 YYDEBUG(801, *YYCURSOR);
7340 ++YYCURSOR;
7341 if ((yych = *YYCURSOR) <= '^') {
7342 if (yych <= '@') {
7343 if (yych <= '/') goto yy802;
7344 if (yych <= '9') goto yy161;
7345 } else {
7346 if (yych == 'I') goto yy803;
7347 if (yych <= 'Z') goto yy161;
7348 }
7349 } else {
7350 if (yych <= 'h') {
7351 if (yych != '`') goto yy161;
7352 } else {
7353 if (yych <= 'i') goto yy803;
7354 if (yych <= 'z') goto yy161;
7355 if (yych >= 0x80) goto yy161;
7356 }
7357 }
7358 yy802:
7359 YYDEBUG(802, *YYCURSOR);
7360 yyleng = YYCURSOR - SCNG(yy_text);
7361 {
7362 RETURN_TOKEN(T_ELSE);
7363 }
7364 yy803:
7365 YYDEBUG(803, *YYCURSOR);
7366 yych = *++YYCURSOR;
7367 if (yych == 'F') goto yy804;
7368 if (yych != 'f') goto yy162;
7369 yy804:
7370 YYDEBUG(804, *YYCURSOR);
7371 ++YYCURSOR;
7372 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7373 goto yy161;
7374 }
7375 YYDEBUG(805, *YYCURSOR);
7376 yyleng = YYCURSOR - SCNG(yy_text);
7377 {
7378 RETURN_TOKEN(T_ELSEIF);
7379 }
7380 yy806:
7381 YYDEBUG(806, *YYCURSOR);
7382 yych = *++YYCURSOR;
7383 if (yych == 'O') goto yy807;
7384 if (yych != 'o') goto yy162;
7385 yy807:
7386 YYDEBUG(807, *YYCURSOR);
7387 ++YYCURSOR;
7388 if (yybm[0+(yych = *YYCURSOR)] & 4) {
7389 goto yy161;
7390 }
7391 YYDEBUG(808, *YYCURSOR);
7392 yyleng = YYCURSOR - SCNG(yy_text);
7393 {
7394 RETURN_TOKEN(T_ECHO);
7395 }
7396 }
7397 /* *********************************** */
7398 yyc_ST_LOOKING_FOR_PROPERTY:
7399 {
7400 static const unsigned char yybm[] = {
7401 0, 0, 0, 0, 0, 0, 0, 0,
7402 0, 128, 128, 0, 0, 128, 0, 0,
7403 0, 0, 0, 0, 0, 0, 0, 0,
7404 0, 0, 0, 0, 0, 0, 0, 0,
7405 128, 0, 0, 0, 0, 0, 0, 0,
7406 0, 0, 0, 0, 0, 0, 0, 0,
7407 64, 64, 64, 64, 64, 64, 64, 64,
7408 64, 64, 0, 0, 0, 0, 0, 0,
7409 0, 64, 64, 64, 64, 64, 64, 64,
7410 64, 64, 64, 64, 64, 64, 64, 64,
7411 64, 64, 64, 64, 64, 64, 64, 64,
7412 64, 64, 64, 0, 0, 0, 0, 64,
7413 0, 64, 64, 64, 64, 64, 64, 64,
7414 64, 64, 64, 64, 64, 64, 64, 64,
7415 64, 64, 64, 64, 64, 64, 64, 64,
7416 64, 64, 64, 0, 0, 0, 0, 0,
7417 64, 64, 64, 64, 64, 64, 64, 64,
7418 64, 64, 64, 64, 64, 64, 64, 64,
7419 64, 64, 64, 64, 64, 64, 64, 64,
7420 64, 64, 64, 64, 64, 64, 64, 64,
7421 64, 64, 64, 64, 64, 64, 64, 64,
7422 64, 64, 64, 64, 64, 64, 64, 64,
7423 64, 64, 64, 64, 64, 64, 64, 64,
7424 64, 64, 64, 64, 64, 64, 64, 64,
7425 64, 64, 64, 64, 64, 64, 64, 64,
7426 64, 64, 64, 64, 64, 64, 64, 64,
7427 64, 64, 64, 64, 64, 64, 64, 64,
7428 64, 64, 64, 64, 64, 64, 64, 64,
7429 64, 64, 64, 64, 64, 64, 64, 64,
7430 64, 64, 64, 64, 64, 64, 64, 64,
7431 64, 64, 64, 64, 64, 64, 64, 64,
7432 64, 64, 64, 64, 64, 64, 64, 64,
7433 };
7434 YYDEBUG(809, *YYCURSOR);
7435 YYFILL(2);
7436 yych = *YYCURSOR;
7437 if (yych <= '-') {
7438 if (yych <= '\r') {
7439 if (yych <= 0x08) goto yy817;
7440 if (yych <= '\n') goto yy811;
7441 if (yych <= '\f') goto yy817;
7442 } else {
7443 if (yych == ' ') goto yy811;
7444 if (yych <= ',') goto yy817;
7445 goto yy813;
7446 }
7447 } else {
7448 if (yych <= '_') {
7449 if (yych <= '@') goto yy817;
7450 if (yych <= 'Z') goto yy815;
7451 if (yych <= '^') goto yy817;
7452 goto yy815;
7453 } else {
7454 if (yych <= '`') goto yy817;
7455 if (yych <= 'z') goto yy815;
7456 if (yych <= 0x7F) goto yy817;
7457 goto yy815;
7458 }
7459 }
7460 yy811:
7461 YYDEBUG(811, *YYCURSOR);
7462 ++YYCURSOR;
7463 yych = *YYCURSOR;
7464 goto yy823;
7465 yy812:
7466 YYDEBUG(812, *YYCURSOR);
7467 yyleng = YYCURSOR - SCNG(yy_text);
7468 {
7469 goto return_whitespace;
7470 }
7471 yy813:
7472 YYDEBUG(813, *YYCURSOR);
7473 ++YYCURSOR;
7474 if ((yych = *YYCURSOR) == '>') goto yy820;
7475 yy814:
7476 YYDEBUG(814, *YYCURSOR);
7477 yyleng = YYCURSOR - SCNG(yy_text);
7478 {
7479 yyless(0);
7480 yy_pop_state();
7481 goto restart;
7482 }
7483 yy815:
7484 YYDEBUG(815, *YYCURSOR);
7485 ++YYCURSOR;
7486 yych = *YYCURSOR;
7487 goto yy819;
7488 yy816:
7489 YYDEBUG(816, *YYCURSOR);
7490 yyleng = YYCURSOR - SCNG(yy_text);
7491 {
7492 yy_pop_state();
7493 RETURN_TOKEN_WITH_STR(T_STRING, 0);
7494 }
7495 yy817:
7496 YYDEBUG(817, *YYCURSOR);
7497 yych = *++YYCURSOR;
7498 goto yy814;
7499 yy818:
7500 YYDEBUG(818, *YYCURSOR);
7501 ++YYCURSOR;
7502 YYFILL(1);
7503 yych = *YYCURSOR;
7504 yy819:
7505 YYDEBUG(819, *YYCURSOR);
7506 if (yybm[0+yych] & 64) {
7507 goto yy818;
7508 }
7509 goto yy816;
7510 yy820:
7511 YYDEBUG(820, *YYCURSOR);
7512 ++YYCURSOR;
7513 YYDEBUG(821, *YYCURSOR);
7514 yyleng = YYCURSOR - SCNG(yy_text);
7515 {
7516 RETURN_TOKEN(T_OBJECT_OPERATOR);
7517 }
7518 yy822:
7519 YYDEBUG(822, *YYCURSOR);
7520 ++YYCURSOR;
7521 YYFILL(1);
7522 yych = *YYCURSOR;
7523 yy823:
7524 YYDEBUG(823, *YYCURSOR);
7525 if (yybm[0+yych] & 128) {
7526 goto yy822;
7527 }
7528 goto yy812;
7529 }
7530 /* *********************************** */
7531 yyc_ST_LOOKING_FOR_VARNAME:
7532 {
7533 static const unsigned char yybm[] = {
7534 0, 0, 0, 0, 0, 0, 0, 0,
7535 0, 0, 0, 0, 0, 0, 0, 0,
7536 0, 0, 0, 0, 0, 0, 0, 0,
7537 0, 0, 0, 0, 0, 0, 0, 0,
7538 0, 0, 0, 0, 0, 0, 0, 0,
7539 0, 0, 0, 0, 0, 0, 0, 0,
7540 128, 128, 128, 128, 128, 128, 128, 128,
7541 128, 128, 0, 0, 0, 0, 0, 0,
7542 0, 128, 128, 128, 128, 128, 128, 128,
7543 128, 128, 128, 128, 128, 128, 128, 128,
7544 128, 128, 128, 128, 128, 128, 128, 128,
7545 128, 128, 128, 0, 0, 0, 0, 128,
7546 0, 128, 128, 128, 128, 128, 128, 128,
7547 128, 128, 128, 128, 128, 128, 128, 128,
7548 128, 128, 128, 128, 128, 128, 128, 128,
7549 128, 128, 128, 0, 0, 0, 0, 0,
7550 128, 128, 128, 128, 128, 128, 128, 128,
7551 128, 128, 128, 128, 128, 128, 128, 128,
7552 128, 128, 128, 128, 128, 128, 128, 128,
7553 128, 128, 128, 128, 128, 128, 128, 128,
7554 128, 128, 128, 128, 128, 128, 128, 128,
7555 128, 128, 128, 128, 128, 128, 128, 128,
7556 128, 128, 128, 128, 128, 128, 128, 128,
7557 128, 128, 128, 128, 128, 128, 128, 128,
7558 128, 128, 128, 128, 128, 128, 128, 128,
7559 128, 128, 128, 128, 128, 128, 128, 128,
7560 128, 128, 128, 128, 128, 128, 128, 128,
7561 128, 128, 128, 128, 128, 128, 128, 128,
7562 128, 128, 128, 128, 128, 128, 128, 128,
7563 128, 128, 128, 128, 128, 128, 128, 128,
7564 128, 128, 128, 128, 128, 128, 128, 128,
7565 128, 128, 128, 128, 128, 128, 128, 128,
7566 };
7567 YYDEBUG(824, *YYCURSOR);
7568 YYFILL(2);
7569 yych = *YYCURSOR;
7570 if (yych <= '_') {
7571 if (yych <= '@') goto yy828;
7572 if (yych <= 'Z') goto yy826;
7573 if (yych <= '^') goto yy828;
7574 } else {
7575 if (yych <= '`') goto yy828;
7576 if (yych <= 'z') goto yy826;
7577 if (yych <= 0x7F) goto yy828;
7578 }
7579 yy826:
7580 YYDEBUG(826, *YYCURSOR);
7581 yyaccept = 0;
7582 yych = *(YYMARKER = ++YYCURSOR);
7583 if (yych <= '_') {
7584 if (yych <= '@') {
7585 if (yych <= '/') goto yy827;
7586 if (yych <= '9') goto yy830;
7587 } else {
7588 if (yych <= '[') goto yy830;
7589 if (yych >= '_') goto yy830;
7590 }
7591 } else {
7592 if (yych <= '|') {
7593 if (yych <= '`') goto yy827;
7594 if (yych <= 'z') goto yy830;
7595 } else {
7596 if (yych <= '}') goto yy830;
7597 if (yych >= 0x80) goto yy830;
7598 }
7599 }
7600 yy827:
7601 YYDEBUG(827, *YYCURSOR);
7602 yyleng = YYCURSOR - SCNG(yy_text);
7603 {
7604 yyless(0);
7605 yy_pop_state();
7606 yy_push_state(ST_IN_SCRIPTING);
7607 goto restart;
7608 }
7609 yy828:
7610 YYDEBUG(828, *YYCURSOR);
7611 yych = *++YYCURSOR;
7612 goto yy827;
7613 yy829:
7614 YYDEBUG(829, *YYCURSOR);
7615 ++YYCURSOR;
7616 YYFILL(1);
7617 yych = *YYCURSOR;
7618 yy830:
7619 YYDEBUG(830, *YYCURSOR);
7620 if (yybm[0+yych] & 128) {
7621 goto yy829;
7622 }
7623 if (yych == '[') goto yy832;
7624 if (yych == '}') goto yy832;
7625 YYDEBUG(831, *YYCURSOR);
7626 YYCURSOR = YYMARKER;
7627 goto yy827;
7628 yy832:
7629 YYDEBUG(832, *YYCURSOR);
7630 ++YYCURSOR;
7631 YYDEBUG(833, *YYCURSOR);
7632 yyleng = YYCURSOR - SCNG(yy_text);
7633 {
7634 yyless(yyleng - 1);
7635 yy_pop_state();
7636 yy_push_state(ST_IN_SCRIPTING);
7637 RETURN_TOKEN_WITH_STR(T_STRING_VARNAME, 0);
7638 }
7639 }
7640 /* *********************************** */
7641 yyc_ST_NOWDOC:
7642 YYDEBUG(834, *YYCURSOR);
7643 YYFILL(1);
7644 yych = *YYCURSOR;
7645 YYDEBUG(836, *YYCURSOR);
7646 ++YYCURSOR;
7647 YYDEBUG(837, *YYCURSOR);
7648 yyleng = YYCURSOR - SCNG(yy_text);
7649 {
7650 zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
7651 int newline = 0, indentation = 0, spacing = -1;
7652
7653 if (YYCURSOR > YYLIMIT) {
7654 RETURN_TOKEN(END);
7655 }
7656
7657 YYCURSOR--;
7658
7659 while (YYCURSOR < YYLIMIT) {
7660 switch (*YYCURSOR++) {
7661 case '\r':
7662 if (*YYCURSOR == '\n') {
7663 YYCURSOR++;
7664 }
7665 /* fall through */
7666 case '\n':
7667 indentation = spacing = 0;
7668
7669 while (YYCURSOR < YYLIMIT && (*YYCURSOR == ' ' || *YYCURSOR == '\t')) {
7670 if (*YYCURSOR == '\t') {
7671 spacing |= HEREDOC_USING_TABS;
7672 } else {
7673 spacing |= HEREDOC_USING_SPACES;
7674 }
7675 ++YYCURSOR;
7676 ++indentation;
7677 }
7678
7679 if (YYCURSOR == YYLIMIT) {
7680 yyleng = YYCURSOR - SCNG(yy_text);
7681 HANDLE_NEWLINES(yytext, yyleng);
7682 ZVAL_NULL(zendlval);
7683 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
7684 }
7685
7686 /* Check for ending label on the next line */
7687 if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
7688 if (IS_LABEL_SUCCESSOR(YYCURSOR[heredoc_label->length])) {
7689 continue;
7690 }
7691
7692 if (spacing == (HEREDOC_USING_SPACES | HEREDOC_USING_TABS)) {
7693 zend_throw_exception(zend_ce_parse_error, "Invalid indentation - tabs and spaces cannot be mixed", 0);
7694 if (PARSER_MODE()) {
7695 RETURN_TOKEN(T_ERROR);
7696 }
7697 }
7698
7699 /* newline before label will be subtracted from returned text, but
7700 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
7701 if (YYCURSOR[-indentation - 2] == '\r' && YYCURSOR[-indentation - 1] == '\n') {
7702 newline = 2; /* Windows newline */
7703 } else {
7704 newline = 1;
7705 }
7706
7707 CG(increment_lineno) = 1; /* For newline before label */
7708
7709 YYCURSOR -= indentation;
7710 heredoc_label->indentation = indentation;
7711
7712 BEGIN(ST_END_HEREDOC);
7713
7714 goto nowdoc_scan_done;
7715 }
7716 /* fall through */
7717 default:
7718 continue;
7719 }
7720 }
7721
7722 nowdoc_scan_done:
7723 yyleng = YYCURSOR - SCNG(yy_text);
7724 ZVAL_STRINGL(zendlval, yytext, yyleng - newline);
7725
7726 if (!EG(exception) && spacing != -1 && PARSER_MODE()) {
7727 zend_bool newline_at_start = *(yytext - 1) == '\n' || *(yytext - 1) == '\r';
7728 if (!strip_multiline_string_indentation(
7729 zendlval, indentation, spacing == HEREDOC_USING_SPACES,
7730 newline_at_start, newline != 0)) {
7731 RETURN_TOKEN(T_ERROR);
7732 }
7733 }
7734
7735 HANDLE_NEWLINES(yytext, yyleng - newline);
7736 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
7737 }
7738 /* *********************************** */
7739 yyc_ST_VAR_OFFSET:
7740 {
7741 static const unsigned char yybm[] = {
7742 0, 0, 0, 0, 0, 0, 0, 0,
7743 0, 0, 0, 0, 0, 0, 0, 0,
7744 0, 0, 0, 0, 0, 0, 0, 0,
7745 0, 0, 0, 0, 0, 0, 0, 0,
7746 0, 0, 0, 0, 0, 0, 0, 0,
7747 0, 0, 0, 0, 0, 0, 0, 0,
7748 240, 240, 112, 112, 112, 112, 112, 112,
7749 112, 112, 0, 0, 0, 0, 0, 0,
7750 0, 80, 80, 80, 80, 80, 80, 16,
7751 16, 16, 16, 16, 16, 16, 16, 16,
7752 16, 16, 16, 16, 16, 16, 16, 16,
7753 16, 16, 16, 0, 0, 0, 0, 16,
7754 0, 80, 80, 80, 80, 80, 80, 16,
7755 16, 16, 16, 16, 16, 16, 16, 16,
7756 16, 16, 16, 16, 16, 16, 16, 16,
7757 16, 16, 16, 0, 0, 0, 0, 0,
7758 16, 16, 16, 16, 16, 16, 16, 16,
7759 16, 16, 16, 16, 16, 16, 16, 16,
7760 16, 16, 16, 16, 16, 16, 16, 16,
7761 16, 16, 16, 16, 16, 16, 16, 16,
7762 16, 16, 16, 16, 16, 16, 16, 16,
7763 16, 16, 16, 16, 16, 16, 16, 16,
7764 16, 16, 16, 16, 16, 16, 16, 16,
7765 16, 16, 16, 16, 16, 16, 16, 16,
7766 16, 16, 16, 16, 16, 16, 16, 16,
7767 16, 16, 16, 16, 16, 16, 16, 16,
7768 16, 16, 16, 16, 16, 16, 16, 16,
7769 16, 16, 16, 16, 16, 16, 16, 16,
7770 16, 16, 16, 16, 16, 16, 16, 16,
7771 16, 16, 16, 16, 16, 16, 16, 16,
7772 16, 16, 16, 16, 16, 16, 16, 16,
7773 16, 16, 16, 16, 16, 16, 16, 16,
7774 };
7775 YYDEBUG(838, *YYCURSOR);
7776 YYFILL(3);
7777 yych = *YYCURSOR;
7778 if (yych <= '0') {
7779 if (yych <= ' ') {
7780 if (yych <= '\f') {
7781 if (yych <= 0x08) goto yy852;
7782 if (yych <= '\n') goto yy848;
7783 goto yy852;
7784 } else {
7785 if (yych <= '\r') goto yy848;
7786 if (yych <= 0x1F) goto yy852;
7787 goto yy848;
7788 }
7789 } else {
7790 if (yych <= '$') {
7791 if (yych <= '"') goto yy847;
7792 if (yych <= '#') goto yy848;
7793 goto yy843;
7794 } else {
7795 if (yych == '\'') goto yy848;
7796 if (yych <= '/') goto yy847;
7797 }
7798 }
7799 } else {
7800 if (yych <= ']') {
7801 if (yych <= 'Z') {
7802 if (yych <= '9') goto yy842;
7803 if (yych <= '@') goto yy847;
7804 goto yy850;
7805 } else {
7806 if (yych <= '[') goto yy847;
7807 if (yych <= '\\') goto yy848;
7808 goto yy845;
7809 }
7810 } else {
7811 if (yych <= '`') {
7812 if (yych == '_') goto yy850;
7813 goto yy847;
7814 } else {
7815 if (yych <= 'z') goto yy850;
7816 if (yych <= '~') goto yy847;
7817 if (yych <= 0x7F) goto yy852;
7818 goto yy850;
7819 }
7820 }
7821 }
7822 YYDEBUG(840, *YYCURSOR);
7823 yyaccept = 0;
7824 yych = *(YYMARKER = ++YYCURSOR);
7825 if (yych <= 'X') {
7826 if (yych <= 'A') {
7827 if (yych <= '/') goto yy841;
7828 if (yych <= '9') goto yy868;
7829 } else {
7830 if (yych <= 'B') goto yy866;
7831 if (yych >= 'X') goto yy867;
7832 }
7833 } else {
7834 if (yych <= 'a') {
7835 if (yych == '_') goto yy859;
7836 } else {
7837 if (yych <= 'b') goto yy866;
7838 if (yych == 'x') goto yy867;
7839 }
7840 }
7841 yy841:
7842 YYDEBUG(841, *YYCURSOR);
7843 yyleng = YYCURSOR - SCNG(yy_text);
7844 { /* Offset could be treated as a long */
7845 if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
7846 char *end;
7847 errno = 0;
7848 ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, &end, 10));
7849 if (errno == ERANGE) {
7850 goto string;
7851 }
7852 ZEND_ASSERT(end == yytext + yyleng);
7853 } else {
7854 string:
7855 ZVAL_STRINGL(zendlval, yytext, yyleng);
7856 }
7857 RETURN_TOKEN_WITH_VAL(T_NUM_STRING);
7858 }
7859 yy842:
7860 YYDEBUG(842, *YYCURSOR);
7861 yyaccept = 0;
7862 yych = *(YYMARKER = ++YYCURSOR);
7863 goto yy862;
7864 yy843:
7865 YYDEBUG(843, *YYCURSOR);
7866 ++YYCURSOR;
7867 if ((yych = *YYCURSOR) <= '_') {
7868 if (yych <= '@') goto yy844;
7869 if (yych <= 'Z') goto yy856;
7870 if (yych >= '_') goto yy856;
7871 } else {
7872 if (yych <= '`') goto yy844;
7873 if (yych <= 'z') goto yy856;
7874 if (yych >= 0x80) goto yy856;
7875 }
7876 yy844:
7877 YYDEBUG(844, *YYCURSOR);
7878 yyleng = YYCURSOR - SCNG(yy_text);
7879 {
7880 /* Only '[' or '-' can be valid, but returning other tokens will allow a more explicit parse error */
7881 RETURN_TOKEN(yytext[0]);
7882 }
7883 yy845:
7884 YYDEBUG(845, *YYCURSOR);
7885 ++YYCURSOR;
7886 YYDEBUG(846, *YYCURSOR);
7887 yyleng = YYCURSOR - SCNG(yy_text);
7888 {
7889 yy_pop_state();
7890 RETURN_TOKEN(']');
7891 }
7892 yy847:
7893 YYDEBUG(847, *YYCURSOR);
7894 yych = *++YYCURSOR;
7895 goto yy844;
7896 yy848:
7897 YYDEBUG(848, *YYCURSOR);
7898 ++YYCURSOR;
7899 YYDEBUG(849, *YYCURSOR);
7900 yyleng = YYCURSOR - SCNG(yy_text);
7901 {
7902 /* Invalid rule to return a more explicit parse error with proper line number */
7903 yyless(0);
7904 yy_pop_state();
7905 ZVAL_NULL(zendlval);
7906 RETURN_TOKEN_WITH_VAL(T_ENCAPSED_AND_WHITESPACE);
7907 }
7908 yy850:
7909 YYDEBUG(850, *YYCURSOR);
7910 ++YYCURSOR;
7911 yych = *YYCURSOR;
7912 goto yy855;
7913 yy851:
7914 YYDEBUG(851, *YYCURSOR);
7915 yyleng = YYCURSOR - SCNG(yy_text);
7916 {
7917 RETURN_TOKEN_WITH_STR(T_STRING, 0);
7918 }
7919 yy852:
7920 YYDEBUG(852, *YYCURSOR);
7921 ++YYCURSOR;
7922 YYDEBUG(853, *YYCURSOR);
7923 yyleng = YYCURSOR - SCNG(yy_text);
7924 {
7925 if (YYCURSOR > YYLIMIT) {
7926 RETURN_TOKEN(END);
7927 }
7928
7929 if (!SCNG(heredoc_scan_ahead)) {
7930 zend_error(E_COMPILE_WARNING, "Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
7931 }
7932 if (PARSER_MODE()) {
7933 goto restart;
7934 } else {
7935 RETURN_TOKEN(T_BAD_CHARACTER);
7936 }
7937 }
7938 yy854:
7939 YYDEBUG(854, *YYCURSOR);
7940 ++YYCURSOR;
7941 YYFILL(1);
7942 yych = *YYCURSOR;
7943 yy855:
7944 YYDEBUG(855, *YYCURSOR);
7945 if (yybm[0+yych] & 16) {
7946 goto yy854;
7947 }
7948 goto yy851;
7949 yy856:
7950 YYDEBUG(856, *YYCURSOR);
7951 ++YYCURSOR;
7952 YYFILL(1);
7953 yych = *YYCURSOR;
7954 YYDEBUG(857, *YYCURSOR);
7955 if (yych <= '^') {
7956 if (yych <= '9') {
7957 if (yych >= '0') goto yy856;
7958 } else {
7959 if (yych <= '@') goto yy858;
7960 if (yych <= 'Z') goto yy856;
7961 }
7962 } else {
7963 if (yych <= '`') {
7964 if (yych <= '_') goto yy856;
7965 } else {
7966 if (yych <= 'z') goto yy856;
7967 if (yych >= 0x80) goto yy856;
7968 }
7969 }
7970 yy858:
7971 YYDEBUG(858, *YYCURSOR);
7972 yyleng = YYCURSOR - SCNG(yy_text);
7973 {
7974 RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
7975 }
7976 yy859:
7977 YYDEBUG(859, *YYCURSOR);
7978 ++YYCURSOR;
7979 YYFILL(1);
7980 yych = *YYCURSOR;
7981 if (yych <= '/') goto yy860;
7982 if (yych <= '9') goto yy863;
7983 yy860:
7984 YYDEBUG(860, *YYCURSOR);
7985 YYCURSOR = YYMARKER;
7986 if (yyaccept <= 0) {
7987 goto yy841;
7988 } else {
7989 goto yy865;
7990 }
7991 yy861:
7992 YYDEBUG(861, *YYCURSOR);
7993 yyaccept = 0;
7994 YYMARKER = ++YYCURSOR;
7995 YYFILL(1);
7996 yych = *YYCURSOR;
7997 yy862:
7998 YYDEBUG(862, *YYCURSOR);
7999 if (yybm[0+yych] & 32) {
8000 goto yy861;
8001 }
8002 if (yych == '_') goto yy859;
8003 goto yy841;
8004 yy863:
8005 YYDEBUG(863, *YYCURSOR);
8006 yyaccept = 1;
8007 YYMARKER = ++YYCURSOR;
8008 YYFILL(1);
8009 yych = *YYCURSOR;
8010 YYDEBUG(864, *YYCURSOR);
8011 if (yych <= '/') goto yy865;
8012 if (yych <= '9') goto yy863;
8013 if (yych == '_') goto yy859;
8014 yy865:
8015 YYDEBUG(865, *YYCURSOR);
8016 yyleng = YYCURSOR - SCNG(yy_text);
8017 { /* Offset must be treated as a string */
8018 if (yyleng == 1) {
8019 ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR((zend_uchar)*(yytext)));
8020 } else {
8021 ZVAL_STRINGL(zendlval, yytext, yyleng);
8022 }
8023 RETURN_TOKEN_WITH_VAL(T_NUM_STRING);
8024 }
8025 yy866:
8026 YYDEBUG(866, *YYCURSOR);
8027 yych = *++YYCURSOR;
8028 if (yybm[0+yych] & 128) {
8029 goto yy875;
8030 }
8031 goto yy860;
8032 yy867:
8033 YYDEBUG(867, *YYCURSOR);
8034 yych = *++YYCURSOR;
8035 if (yybm[0+yych] & 64) {
8036 goto yy870;
8037 }
8038 goto yy860;
8039 yy868:
8040 YYDEBUG(868, *YYCURSOR);
8041 yyaccept = 1;
8042 YYMARKER = ++YYCURSOR;
8043 YYFILL(1);
8044 yych = *YYCURSOR;
8045 YYDEBUG(869, *YYCURSOR);
8046 if (yych <= '/') goto yy865;
8047 if (yych <= '9') goto yy868;
8048 if (yych == '_') goto yy859;
8049 goto yy865;
8050 yy870:
8051 YYDEBUG(870, *YYCURSOR);
8052 yyaccept = 1;
8053 YYMARKER = ++YYCURSOR;
8054 YYFILL(1);
8055 yych = *YYCURSOR;
8056 YYDEBUG(871, *YYCURSOR);
8057 if (yybm[0+yych] & 64) {
8058 goto yy870;
8059 }
8060 if (yych != '_') goto yy865;
8061 yy872:
8062 YYDEBUG(872, *YYCURSOR);
8063 ++YYCURSOR;
8064 YYFILL(1);
8065 yych = *YYCURSOR;
8066 if (yych <= '@') {
8067 if (yych <= '/') goto yy860;
8068 if (yych >= ':') goto yy860;
8069 } else {
8070 if (yych <= 'F') goto yy873;
8071 if (yych <= '`') goto yy860;
8072 if (yych >= 'g') goto yy860;
8073 }
8074 yy873:
8075 YYDEBUG(873, *YYCURSOR);
8076 yyaccept = 1;
8077 YYMARKER = ++YYCURSOR;
8078 YYFILL(1);
8079 yych = *YYCURSOR;
8080 YYDEBUG(874, *YYCURSOR);
8081 if (yych <= 'F') {
8082 if (yych <= '/') goto yy865;
8083 if (yych <= '9') goto yy873;
8084 if (yych <= '@') goto yy865;
8085 goto yy873;
8086 } else {
8087 if (yych <= '_') {
8088 if (yych <= '^') goto yy865;
8089 goto yy872;
8090 } else {
8091 if (yych <= '`') goto yy865;
8092 if (yych <= 'f') goto yy873;
8093 goto yy865;
8094 }
8095 }
8096 yy875:
8097 YYDEBUG(875, *YYCURSOR);
8098 yyaccept = 1;
8099 YYMARKER = ++YYCURSOR;
8100 YYFILL(1);
8101 yych = *YYCURSOR;
8102 YYDEBUG(876, *YYCURSOR);
8103 if (yybm[0+yych] & 128) {
8104 goto yy875;
8105 }
8106 if (yych != '_') goto yy865;
8107 yy877:
8108 YYDEBUG(877, *YYCURSOR);
8109 ++YYCURSOR;
8110 YYFILL(1);
8111 yych = *YYCURSOR;
8112 if (yych <= '/') goto yy860;
8113 if (yych >= '2') goto yy860;
8114 yy878:
8115 YYDEBUG(878, *YYCURSOR);
8116 yyaccept = 1;
8117 YYMARKER = ++YYCURSOR;
8118 YYFILL(1);
8119 yych = *YYCURSOR;
8120 YYDEBUG(879, *YYCURSOR);
8121 if (yych <= '/') goto yy865;
8122 if (yych <= '1') goto yy878;
8123 if (yych == '_') goto yy877;
8124 goto yy865;
8125 }
8126 }
8127
8128
8129 emit_token_with_str:
8130 zend_copy_value(zendlval, (yytext + offset), (yyleng - offset));
8131
8132 emit_token_with_val:
8133 if (PARSER_MODE()) {
8134 ZEND_ASSERT(Z_TYPE_P(zendlval) != IS_UNDEF);
8135 elem->ast = zend_ast_create_zval_with_lineno(zendlval, start_line);
8136 }
8137
8138 emit_token:
8139 if (SCNG(on_event)) {
8140 SCNG(on_event)(ON_TOKEN, token, start_line, SCNG(on_event_context));
8141 }
8142 return token;
8143
8144 return_whitespace:
8145 HANDLE_NEWLINES(yytext, yyleng);
8146 if (SCNG(on_event)) {
8147 SCNG(on_event)(ON_TOKEN, T_WHITESPACE, start_line, SCNG(on_event_context));
8148 }
8149 if (PARSER_MODE()) {
8150 start_line = CG(zend_lineno);
8151 goto restart;
8152 } else {
8153 return T_WHITESPACE;
8154 }
8155
8156 skip_token:
8157 if (SCNG(on_event)) {
8158 SCNG(on_event)(ON_TOKEN, token, start_line, SCNG(on_event_context));
8159 }
8160 start_line = CG(zend_lineno);
8161 goto restart;
8162 }
8163