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