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