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