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