1 : /* Generated by re2c 0.13.5 on Wed Jun 03 09:59:17 2009 */
2 : #line 1 "Zend/zend_language_scanner.l"
3 : /*
4 : +----------------------------------------------------------------------+
5 : | Zend Engine |
6 : +----------------------------------------------------------------------+
7 : | Copyright (c) 1998-2009 Zend Technologies Ltd. (http://www.zend.com) |
8 : +----------------------------------------------------------------------+
9 : | This source file is subject to version 2.00 of the Zend license, |
10 : | that is bundled with this package in the file LICENSE, and is |
11 : | available through the world-wide-web at the following url: |
12 : | http://www.zend.com/license/2_00.txt. |
13 : | If you did not receive a copy of the Zend license and are unable to |
14 : | obtain it through the world-wide-web, please send a note to |
15 : | license@zend.com so we can mail you a copy immediately. |
16 : +----------------------------------------------------------------------+
17 : | Authors: Marcus Boerger <helly@php.net> |
18 : | Nuno Lopes <nlopess@php.net> |
19 : | Scott MacVicar <scottmac@php.net> |
20 : | Flex version authors: |
21 : | Andi Gutmans <andi@zend.com> |
22 : | Zeev Suraski <zeev@zend.com> |
23 : +----------------------------------------------------------------------+
24 : */
25 :
26 : /* $Id: zend_language_scanner.c 282162 2009-06-15 14:06:30Z pajoye $ */
27 :
28 : #if 0
29 : # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
30 : #else
31 : # define YYDEBUG(s, c)
32 : #endif
33 :
34 : #include "zend_language_scanner_defs.h"
35 :
36 : #include <errno.h>
37 : #include "zend.h"
38 : #include "zend_alloc.h"
39 : #include <zend_language_parser.h>
40 : #include "zend_compile.h"
41 : #include "zend_language_scanner.h"
42 : #include "zend_highlight.h"
43 : #include "zend_constants.h"
44 : #include "zend_variables.h"
45 : #include "zend_operators.h"
46 : #include "zend_API.h"
47 : #include "zend_strtod.h"
48 : #include "zend_unicode.h"
49 : #include "tsrm_virtual_cwd.h"
50 : #include "tsrm_config_common.h"
51 :
52 : #define YYCTYPE unsigned char
53 : #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
54 : #define YYCURSOR SCNG(yy_cursor)
55 : #define YYLIMIT SCNG(yy_limit)
56 : #define YYMARKER SCNG(yy_marker)
57 :
58 : #define YYGETCONDITION() SCNG(yy_state)
59 : #define YYSETCONDITION(s) SCNG(yy_state) = s
60 :
61 : #define STATE(name) yyc##name
62 :
63 : /* emulate flex constructs */
64 : #define BEGIN(state) YYSETCONDITION(STATE(state))
65 : #define YYSTATE YYGETCONDITION()
66 : #define yytext ((char*)SCNG(yy_text))
67 : #define yyleng SCNG(yy_leng)
68 : #define yyless(x) do { YYCURSOR = (unsigned char*)yytext + (x); \
69 : yyleng = (unsigned int)(x); } while(0)
70 : #define yymore() goto yymore_restart
71 :
72 : /* perform sanity check. If this message is triggered you should
73 : increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
74 : #define YYMAXFILL 16
75 : #if ZEND_MMAP_AHEAD < YYMAXFILL
76 : # error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
77 : #endif
78 :
79 : #ifdef HAVE_STDARG_H
80 : # include <stdarg.h>
81 : #endif
82 :
83 : #ifdef HAVE_UNISTD_H
84 : # include <unistd.h>
85 : #endif
86 :
87 : /* Globals Macros */
88 : #define SCNG LANG_SCNG
89 : #ifdef ZTS
90 : ZEND_API ts_rsrc_id language_scanner_globals_id;
91 : #else
92 : ZEND_API zend_php_scanner_globals language_scanner_globals;
93 : #endif
94 :
95 : /*
96 : #define YY_INPUT(buf, result, max_size) \
97 : if ( ((result = zend_unicode_yyinput(yyin, buf, max_size TSRMLS_CC)) == 0)) \
98 : YY_FATAL_ERROR( "input in flex scanner failed" );
99 : */
100 :
101 : #define HANDLE_NEWLINES(s, l) \
102 : do { \
103 : char *p = (s), *boundary = p+(l); \
104 : \
105 : while (p<boundary) { \
106 : if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) { \
107 : CG(zend_lineno)++; \
108 : } \
109 : p++; \
110 : } \
111 : } while (0)
112 :
113 : #define HANDLE_NEWLINE(c) \
114 : { \
115 : if (c == '\n' || c == '\r') { \
116 : CG(zend_lineno)++; \
117 : } \
118 : }
119 :
120 : /* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
121 : #define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
122 : #define GET_DOUBLE_QUOTES_SCANNED_LENGTH() CG(doc_comment_len)
123 :
124 : #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
125 :
126 : #define ZEND_IS_OCT(c) ((c)>='0' && (c)<='7')
127 : #define ZEND_IS_HEX(c) (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
128 :
129 : BEGIN_EXTERN_C()
130 :
131 : static void _yy_push_state(int new_state TSRMLS_DC)
132 : {
133 : zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));
134 : YYSETCONDITION(new_state);
135 : }
136 :
137 : #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
138 :
139 : static void yy_pop_state(TSRMLS_D)
140 : {
141 : int *stack_state;
142 : zend_stack_top(&SCNG(state_stack), (void **) &stack_state);
143 : YYSETCONDITION(*stack_state);
144 : zend_stack_del_top(&SCNG(state_stack));
145 : }
146 :
147 : static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
148 : {
149 : YYCURSOR = (YYCTYPE*)str;
150 : SCNG(yy_start) = YYCURSOR;
151 : YYLIMIT = YYCURSOR + len;
152 : }
153 :
154 : void startup_scanner(TSRMLS_D)
155 : {
156 : CG(heredoc) = NULL;
157 : CG(heredoc_len) = 0;
158 : CG(doc_comment) = NULL_ZSTR;
159 : CG(doc_comment_len) = 0;
160 :
161 : SCNG(input_conv) = NULL;
162 : SCNG(output_conv) = NULL;
163 : SCNG(encoding_checked) = 0;
164 : SCNG(rest_str) = NULL;
165 : SCNG(rest_len) = 0;
166 :
167 : zend_stack_init(&SCNG(state_stack));
168 : }
169 :
170 :
171 : void shutdown_scanner(TSRMLS_D)
172 : {
173 : if (CG(heredoc)) {
174 : efree(CG(heredoc));
175 : CG(heredoc_len)=0;
176 : }
177 : zend_stack_destroy(&SCNG(state_stack));
178 : RESET_DOC_COMMENT();
179 :
180 : if (SCNG(input_conv)) {
181 : ucnv_close(SCNG(input_conv));
182 : SCNG(input_conv) = NULL;
183 : }
184 : if (SCNG(output_conv)) {
185 : ucnv_close(SCNG(output_conv));
186 : SCNG(output_conv) = NULL;
187 : }
188 : SCNG(encoding_checked) = 0;
189 : if (SCNG(rest_str)) {
190 : efree(SCNG(rest_str));
191 : SCNG(rest_str) = NULL;
192 : }
193 : SCNG(rest_len) = 0;
194 : }
195 :
196 : ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
197 : {
198 : lex_state->yy_leng = SCNG(yy_leng);
199 : lex_state->yy_start = SCNG(yy_start);
200 : lex_state->yy_text = SCNG(yy_text);
201 : lex_state->yy_cursor = SCNG(yy_cursor);
202 : lex_state->yy_marker = SCNG(yy_marker);
203 : lex_state->yy_limit = SCNG(yy_limit);
204 :
205 : lex_state->state_stack = SCNG(state_stack);
206 : zend_stack_init(&SCNG(state_stack));
207 :
208 : lex_state->in = SCNG(yy_in);
209 : lex_state->yy_state = YYSTATE;
210 : lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
211 : lex_state->lineno = CG(zend_lineno);
212 :
213 : lex_state->input_conv = SCNG(input_conv);
214 : lex_state->output_conv = SCNG(output_conv);
215 : lex_state->encoding_checked = SCNG(encoding_checked);
216 : lex_state->rest_str = SCNG(rest_str);
217 : lex_state->rest_len = SCNG(rest_len);
218 : SCNG(input_conv) = NULL;
219 : SCNG(output_conv) = NULL;
220 : SCNG(encoding_checked) = 0;
221 : SCNG(rest_str) = NULL;
222 : SCNG(rest_len) = 0;
223 : }
224 :
225 : ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
226 : {
227 : SCNG(yy_leng) = lex_state->yy_leng;
228 : SCNG(yy_start) = lex_state->yy_start;
229 : SCNG(yy_text) = lex_state->yy_text;
230 : SCNG(yy_cursor) = lex_state->yy_cursor;
231 : SCNG(yy_marker) = lex_state->yy_marker;
232 : SCNG(yy_limit) = lex_state->yy_limit;
233 :
234 : zend_stack_destroy(&SCNG(state_stack));
235 : SCNG(state_stack) = lex_state->state_stack;
236 :
237 : SCNG(yy_in) = lex_state->in;
238 : YYSETCONDITION(lex_state->yy_state);
239 : CG(zend_lineno) = lex_state->lineno;
240 : zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);
241 : zend_restore_compiled_script_encoding(lex_state->script_encoding TSRMLS_CC);
242 :
243 : if (SCNG(input_conv)) {
244 : ucnv_close(SCNG(input_conv));
245 : }
246 : SCNG(input_conv) = lex_state->input_conv;
247 : if (SCNG(output_conv)) {
248 : ucnv_close(SCNG(output_conv));
249 : }
250 : SCNG(output_conv) = lex_state->output_conv;
251 : SCNG(encoding_checked) = lex_state->encoding_checked;
252 : if (SCNG(rest_str)) {
253 : efree(SCNG(rest_str));
254 : }
255 : SCNG(rest_str) = lex_state->rest_str;
256 : SCNG(rest_len) = lex_state->rest_len;
257 : }
258 :
259 : ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
260 : {
261 : zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
262 : /* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
263 : file_handle->opened_path = NULL;
264 : if (file_handle->free_filename) {
265 : file_handle->filename = NULL;
266 : }
267 : }
268 :
269 : /* Convert one octal digit to a numeric value 0..7, or -1 on failure */
270 : static inline int8_t zend_get_octal_digit(UChar c) {
271 : if (c >= 0x0030 && c <= 0x0037) {
272 : return (int8_t)(c - 0x0030);
273 : }
274 : return -1;
275 : }
276 :
277 : /*
278 : * Convert one hex digit to a numeric value 0..F, or -1 on failure.
279 : * Borrowed from ICU.
280 : */
281 : static inline int8_t zend_get_hex_digit(UChar c) {
282 : if (c >= 0x0030 && c <= 0x0039) {
283 : return (int8_t)(c - 0x0030);
284 : }
285 : if (c >= 0x0041 && c <= 0x0046) {
286 : return (int8_t)(c - (0x0041 - 10));
287 : }
288 : if (c >= 0x0061 && c <= 0x0066) {
289 : return (int8_t)(c - (0x0061 - 10));
290 : }
291 : return -1;
292 : }
293 :
294 : static inline zend_bool zend_udigits_to_codepoint(UChar *s, UChar *end, UChar32 *c, int8_t digits)
295 : {
296 : int8_t n = 0;
297 : int8_t digit = 0;
298 : UChar32 codepoint = 0;
299 :
300 : while (s < end && n < digits) {
301 : digit = zend_get_hex_digit(*s);
302 : if (digit < 0) {
303 : break;
304 : }
305 : codepoint = (codepoint << 4) | digit;
306 : ++s;
307 : ++n;
308 : }
309 :
310 : if (n < digits) {
311 : return 0;
312 : }
313 :
314 : *c = codepoint;
315 : return 1;
316 : }
317 :
318 : static inline int zend_uchar_from_uname(UChar *name, int name_len, UChar32 *c TSRMLS_DC)
319 : {
320 : UChar32 codepoint = 0;
321 : UErrorCode status = U_ZERO_ERROR;
322 : char *buf;
323 :
324 : buf = zend_unicode_to_ascii(name, name_len TSRMLS_CC);
325 : if (!buf) return 0;
326 : codepoint = u_charFromName(U_UNICODE_CHAR_NAME, buf, &status);
327 : efree(buf);
328 : if (U_SUCCESS(status)) {
329 : *c = codepoint;
330 : return 1;
331 : } else {
332 : return 0;
333 : }
334 : }
335 :
336 : static inline int zend_parse_charname_sequence(UChar **s, UChar *end, UChar32 *c TSRMLS_DC)
337 : {
338 : UChar *start;
339 :
340 : if (**s == '{') {
341 : start = ++(*s);
342 : while ((*s)++ != end) {
343 : if (**s == '}') {
344 : if (zend_uchar_from_uname(start, *s - start, c TSRMLS_CC)) {
345 : return 1;
346 : } else {
347 : /* safe, since *s points to '}' */
348 : **s = 0;
349 : zend_error(E_COMPILE_WARNING, "Invalid Unicode character name: '%r'", start);
350 : break;
351 : }
352 : }
353 : }
354 : }
355 :
356 : return 0;
357 : }
358 :
359 : ZEND_API int zend_copy_scanner_string(zval *zendlval, char *str, zend_uint str_len, zend_uchar type, UConverter *conv TSRMLS_DC)
360 : {
361 : UErrorCode status = U_ZERO_ERROR;
362 : int consumed = 0;
363 :
364 : if (type == IS_UNICODE) {
365 : consumed = zend_convert_scanner_output(conv, &Z_USTRVAL_P(zendlval), &Z_USTRLEN_P(zendlval), str, str_len, &status TSRMLS_CC);
366 :
367 : if (U_FAILURE(status)) {
368 : zend_error(E_COMPILE_WARNING,"Illegal or truncated character in input: offset %d, state=%d", consumed, YYSTATE);
369 : efree(Z_USTRVAL_P(zendlval));
370 : return 0;
371 : }
372 : Z_TYPE_P(zendlval) = IS_UNICODE;
373 : } else {
374 : Z_STRVAL_P(zendlval) = (char *)estrndup(str, str_len);
375 : Z_STRLEN_P(zendlval) = str_len;
376 : Z_TYPE_P(zendlval) = IS_STRING;
377 : }
378 :
379 : return 1;
380 : }
381 :
382 : static inline int zend_check_and_normalize_identifier(zval *zendlval)
383 : {
384 : UChar *norm;
385 : int norm_len;
386 :
387 : if (!zend_is_valid_identifier(Z_USTRVAL_P(zendlval), Z_USTRLEN_P(zendlval))) {
388 : zend_error(E_COMPILE_WARNING, "Invalid identifier syntax: %r", Z_USTRVAL_P(zendlval));
389 : efree(Z_USTRVAL_P(zendlval));
390 : return 0;
391 : }
392 : if (zend_normalize_identifier(&norm, &norm_len, Z_USTRVAL_P(zendlval), Z_USTRLEN_P(zendlval), 0) == FAILURE) {
393 : zend_error(E_COMPILE_WARNING, "Could not normalize identifier: %r", Z_USTRVAL_P(zendlval));
394 : efree(Z_USTRVAL_P(zendlval));
395 : return 0;
396 : }
397 : if (norm != Z_USTRVAL_P(zendlval)) {
398 : efree(Z_USTRVAL_P(zendlval));
399 : ZVAL_UNICODEL(zendlval, norm, norm_len, 0);
400 : }
401 : return 1;
402 : }
403 :
404 : static void zend_scanner_output_callback(
405 : const void *context,
406 : UConverterToUnicodeArgs *toUArgs,
407 : const char *codeUnits,
408 : int32_t length,
409 : UConverterCallbackReason reason,
410 : UErrorCode *err
411 : )
412 : {
413 : if (*err == U_TRUNCATED_CHAR_FOUND ||
414 : *err == U_ILLEGAL_CHAR_FOUND ||
415 : *err == U_INVALID_CHAR_FOUND) {
416 : *(const char **)context = toUArgs->source - length;
417 : }
418 :
419 : return;
420 : }
421 :
422 : static int is_encoding_flex_compatible(const char *enc TSRMLS_DC)
423 : {
424 : int key_len = strlen(enc)+1;
425 : unsigned char ret;
426 : unsigned char *ret_ptr;
427 :
428 : if (zend_hash_find(&UG(flex_compatible), (char*)enc, key_len, (void**)&ret_ptr) == SUCCESS) {
429 : return *ret_ptr;
430 : } else {
431 : UErrorCode status = U_ZERO_ERROR;
432 : UConverter *conv = ucnv_open(enc, &status);
433 :
434 : if (U_FAILURE(status)) {
435 : return 0;
436 : }
437 :
438 : switch (ucnv_getType(conv)) {
439 : case UCNV_DBCS:
440 : case UCNV_UTF16_BigEndian:
441 : case UCNV_UTF16_LittleEndian:
442 : case UCNV_UTF32_BigEndian:
443 : case UCNV_UTF32_LittleEndian:
444 : case UCNV_EBCDIC_STATEFUL:
445 : case UCNV_ISO_2022:
446 : case UCNV_LMBCS_1:
447 : case UCNV_LMBCS_2:
448 : case UCNV_LMBCS_3:
449 : case UCNV_LMBCS_4:
450 : case UCNV_LMBCS_5:
451 : case UCNV_LMBCS_6:
452 : case UCNV_LMBCS_8:
453 : case UCNV_LMBCS_11:
454 : case UCNV_LMBCS_16:
455 : case UCNV_LMBCS_17:
456 : case UCNV_LMBCS_18:
457 : case UCNV_LMBCS_19:
458 : case UCNV_HZ:
459 : case UCNV_SCSU:
460 : case UCNV_UTF7:
461 : case UCNV_BOCU1:
462 : case UCNV_UTF16:
463 : case UCNV_UTF32:
464 : case UCNV_IMAP_MAILBOX:
465 : ret = 0;
466 : break;
467 : case UCNV_LATIN_1:
468 : case UCNV_UTF8:
469 : case UCNV_ISCII:
470 : case UCNV_US_ASCII:
471 : case UCNV_CESU8:
472 : ret = 1;
473 : break;
474 : default: {
475 : static const UChar ascii[] = {
476 : 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
477 : 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
478 : 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
479 : 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
480 : 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
481 : 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
482 : 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
483 : 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E
484 : };
485 : static const char expected[] =
486 : "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
487 : "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"
488 : "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2A\x2B\x2C\x2D\x2E\x2F"
489 : "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x3E\x3F"
490 : "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F"
491 : "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x5B\x5C\x5D\x5E\x5F"
492 : "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F"
493 : "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7A\x7B\x7C\x7D\x7E";
494 : char output[sizeof(expected)];
495 :
496 : if (ucnv_fromUChars(conv,
497 : output, sizeof(output),
498 : ascii, sizeof(expected),
499 : &status) != sizeof(expected) ||
500 : U_FAILURE(status)) {
501 : ret = 0;
502 : } else {
503 : ret = (memcmp(expected, output, sizeof(expected)) == 0);
504 : }
505 : }
506 : }
507 : ucnv_close(conv);
508 :
509 : zend_hash_add(&UG(flex_compatible), (char*)enc, key_len, (void**)&ret, sizeof(ret), NULL);
510 :
511 : return ret;
512 : }
513 : }
514 :
515 : ZEND_API int zend_prepare_scanner_converters(const char *onetime_encoding, int run_time TSRMLS_DC)
516 : {
517 : const char *encoding = NULL;
518 :
519 : if (SCNG(input_conv)) {
520 : /* Script is already converted to UTF-8 */
521 : return zend_set_converter_encoding(&SCNG(output_conv), "UTF-8");
522 : } else {
523 : encoding = onetime_encoding;
524 : }
525 :
526 : /* We need to convert the input stream only if script_encoding is not ASCII compatible */
527 : if (!is_encoding_flex_compatible(encoding TSRMLS_CC)) {
528 : if (zend_set_converter_encoding(&SCNG(input_conv), encoding) == FAILURE) {
529 : return FAILURE;
530 : }
531 : #ifdef scottmac_0
532 : if (run_time) {
533 : /* Convert rest of the buffer to unicode.runtime_encoding. */
534 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
535 : int offset, length, size;
536 : const char *src, *old_src;
537 : char rt_buf[8192];
538 : char *target = rt_buf;
539 : UErrorCode status = U_ZERO_ERROR;
540 :
541 : old_src = src = yy_c_buf_p;
542 : offset = yy_c_buf_p - b->yy_ch_buf;
543 : length = b->yy_n_chars - offset;
544 : size = b->yy_buf_size - offset;
545 :
546 : ucnv_convertEx(UG(utf8_conv),
547 : SCNG(input_conv),
548 : &target, rt_buf+size-2,
549 : &src, src+length,
550 : NULL, NULL, NULL, NULL,
551 : TRUE, TRUE,
552 : &status);
553 :
554 : if (src - old_src < length) {
555 : /* Cannot fit into buffer. Schedule for next read. */
556 : SCNG(rest_len) = length - (src - old_src);
557 : SCNG(rest_str) = emalloc(SCNG(rest_len));
558 : memcpy(SCNG(rest_str), src, SCNG(rest_len));
559 : }
560 : length = target - rt_buf;
561 : memcpy(yy_c_buf_p, rt_buf, length);
562 : SCNG(yy_n_chars) = b->yy_n_chars = length + offset;
563 : b->yy_ch_buf[b->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
564 : b->yy_ch_buf[b->yy_n_chars+1] = YY_END_OF_BUFFER_CHAR;
565 : }
566 : #endif
567 : encoding = "UTF-8";
568 : }
569 : return zend_set_converter_encoding(&SCNG(output_conv), encoding);
570 : }
571 :
572 : ZEND_API int zend_convert_scanner_output(UConverter *conv, UChar **target, int *target_len, const char *source, int source_len, UErrorCode *status TSRMLS_DC)
573 : {
574 : const char *source_consumed = NULL;
575 :
576 : /* set our custom callback with context */
577 : ucnv_setToUCallBack(conv, zend_scanner_output_callback, &source_consumed, NULL, NULL, status);
578 :
579 : /* reset the error and perform conversion */
580 : *status = U_ZERO_ERROR;
581 : zend_string_to_unicode_ex(conv, target, target_len, source, source_len, status);
582 :
583 : /* figure out how many source bytes were consumed */
584 : if (U_SUCCESS(*status)) {
585 : return source_len;
586 : } else if (source_consumed) {
587 : return source_consumed - source;
588 : } else {
589 : return 0;
590 : }
591 : }
592 :
593 : int zend_unicode_yyinput(zend_file_handle *file_handle, char *buf, size_t len TSRMLS_DC)
594 : {
595 : size_t n = len;
596 : const char *src = buf;
597 :
598 : #ifdef scottmac_0
599 : /* Look of we have rest from previous call */
600 : if (SCNG(rest_str)) {
601 : if (len >= SCNG(rest_len)) {
602 : memcpy(buf, SCNG(rest_str), SCNG(rest_len));
603 : efree(SCNG(rest_str));
604 : SCNG(rest_str) = NULL;
605 : n = SCNG(rest_len);
606 : SCNG(rest_len) = 0;
607 : } else {
608 : memcpy(buf, SCNG(rest_str), len);
609 : memcpy(SCNG(rest_str), SCNG(rest_str)+len, SCNG(rest_len)-len);
610 : n = len;
611 : SCNG(rest_len) -= len;
612 : }
613 : } else {
614 : n = zend_stream_read(file_handle, buf, len TSRMLS_CC);
615 : }
616 : #endif
617 : /* Autodetect encoding */
618 : if (!SCNG(encoding_checked)) {
619 : int32_t signatureLength;
620 : UErrorCode status = U_ZERO_ERROR;
621 : const char *encoding;
622 :
623 : encoding = ucnv_detectUnicodeSignature(buf, n, &signatureLength, &status);
624 : if (encoding && U_SUCCESS(status)) {
625 : src += signatureLength;
626 : n -= signatureLength;
627 : if (is_encoding_flex_compatible(encoding TSRMLS_CC)) {
628 : if (SCNG(input_conv)) {
629 : ucnv_close(SCNG(input_conv));
630 : SCNG(input_conv) = NULL;
631 : }
632 : zend_set_converter_encoding(&SCNG(output_conv), encoding);
633 : if (signatureLength > 0) {
634 : memcpy(buf, src, n);
635 : }
636 : } else {
637 : zend_set_converter_encoding(&SCNG(input_conv), encoding);
638 : zend_set_converter_encoding(&SCNG(output_conv), "UTF-8");
639 : }
640 : }
641 : status = U_ZERO_ERROR;
642 : SCNG(encoding_checked) = 1;
643 : }
644 :
645 : if (SCNG(input_conv) && n >= 0) {
646 : UErrorCode status = U_ZERO_ERROR;
647 : char rt_buf[8192];
648 : char *target = rt_buf;
649 : const char *old_src = src;
650 :
651 : ucnv_convertEx(UG(utf8_conv),
652 : SCNG(input_conv),
653 : &target, rt_buf+len,
654 : &src, src+n,
655 : NULL, NULL, NULL, NULL,
656 : TRUE, TRUE,
657 : &status);
658 : if (src - old_src < n) {
659 : /* Cannot fit into buffer. Schedule for next read. */
660 : SCNG(rest_len) = n - (src - old_src);
661 : SCNG(rest_str) = emalloc(SCNG(rest_len));
662 : memcpy(SCNG(rest_str), src, SCNG(rest_len));
663 : }
664 : n = target - rt_buf;
665 : memcpy(buf, rt_buf, n);
666 : }
667 : return n;
668 : }
669 :
670 : ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
671 : {
672 : char *file_path=NULL, *buf;
673 : UErrorCode status = U_ZERO_ERROR;
674 : size_t size;
675 :
676 : if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {
677 : return FAILURE;
678 : }
679 :
680 : zend_llist_add_element(&CG(open_files), file_handle);
681 :
682 : if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
683 : zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
684 : size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
685 : fh->handle.stream.handle = (void*)(((char*)fh) + diff);
686 : file_handle->handle.stream.handle = fh->handle.stream.handle;
687 : }
688 :
689 : /* Reset the scanner for scanning the new file */
690 : SCNG(yy_in) = file_handle;
691 :
692 : zend_prepare_scanner_converters(ucnv_getName(ZEND_U_CONVERTER(UG(script_encoding_conv)), &status), 0 TSRMLS_CC);
693 :
694 : if (size != -1) {
695 : /* Re-encode for Unicode if needed */
696 : yy_scan_buffer(buf, size TSRMLS_CC);
697 : } else {
698 : zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
699 : }
700 :
701 : BEGIN(INITIAL);
702 :
703 : if (file_handle->opened_path) {
704 : file_path = file_handle->opened_path;
705 : } else {
706 : file_path = file_handle->filename;
707 : }
708 :
709 : zend_set_compiled_filename(file_path TSRMLS_CC);
710 : zend_set_compiled_script_encoding((char*)ucnv_getName(SCNG(output_conv), &status) TSRMLS_CC);
711 :
712 : if (CG(start_lineno)) {
713 : CG(zend_lineno) = CG(start_lineno);
714 : CG(start_lineno) = 0;
715 : } else {
716 : CG(zend_lineno) = 1;
717 : }
718 :
719 : CG(increment_lineno) = 0;
720 : return SUCCESS;
721 : }
722 : END_EXTERN_C()
723 :
724 :
725 : ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
726 : {
727 : zend_lex_state original_lex_state;
728 : zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
729 : zend_op_array *original_active_op_array = CG(active_op_array);
730 : zend_op_array *retval=NULL;
731 : int compiler_result;
732 : zend_bool compilation_successful=0;
733 : znode retval_znode;
734 : zend_bool original_in_compilation = CG(in_compilation);
735 :
736 : retval_znode.op_type = IS_CONST;
737 : Z_TYPE(retval_znode.u.constant) = IS_LONG;
738 : Z_LVAL(retval_znode.u.constant) = 1;
739 : Z_UNSET_ISREF(retval_znode.u.constant);
740 : Z_SET_REFCOUNT(retval_znode.u.constant, 1);
741 :
742 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
743 :
744 : retval = op_array; /* success oriented */
745 :
746 : if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
747 : if (type==ZEND_REQUIRE) {
748 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename TSRMLS_CC);
749 : zend_bailout();
750 : } else {
751 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename TSRMLS_CC);
752 : }
753 : compilation_successful=0;
754 : } else {
755 : init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
756 : CG(in_compilation) = 1;
757 : CG(active_op_array) = op_array;
758 : compiler_result = zendparse(TSRMLS_C);
759 : zend_do_return(&retval_znode, 0 TSRMLS_CC);
760 : CG(in_compilation) = original_in_compilation;
761 : if (compiler_result==1) { /* parser error */
762 : zend_bailout();
763 : }
764 : compilation_successful=1;
765 : }
766 :
767 : if (retval) {
768 : CG(active_op_array) = original_active_op_array;
769 : if (compilation_successful) {
770 : pass_two(op_array TSRMLS_CC);
771 : zend_release_labels(TSRMLS_C);
772 : } else {
773 : efree(op_array);
774 : retval = NULL;
775 : }
776 : }
777 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
778 : return retval;
779 : }
780 :
781 :
782 : zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
783 : {
784 : zend_file_handle file_handle;
785 : zval tmp;
786 : zend_op_array *retval;
787 : char *opened_path = NULL;
788 :
789 : if (Z_TYPE_P(filename) != IS_STRING) {
790 : tmp = *filename;
791 : zval_copy_ctor(&tmp);
792 : convert_to_string(&tmp);
793 : filename = &tmp;
794 : }
795 : file_handle.filename = Z_STRVAL_P(filename);
796 : file_handle.free_filename = 0;
797 : file_handle.type = ZEND_HANDLE_FILENAME;
798 : file_handle.opened_path = NULL;
799 : file_handle.handle.fp = NULL;
800 :
801 : retval = zend_compile_file(&file_handle, type TSRMLS_CC);
802 : if (retval && file_handle.handle.stream.handle) {
803 : int dummy = 1;
804 :
805 : if (!file_handle.opened_path) {
806 : file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename));
807 : }
808 :
809 : zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
810 :
811 : if (opened_path) {
812 : efree(opened_path);
813 : }
814 : }
815 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
816 :
817 : if (filename==&tmp) {
818 : zval_dtor(&tmp);
819 : }
820 : return retval;
821 : }
822 :
823 : ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
824 : {
825 : const char *encoding;
826 : UErrorCode status = U_ZERO_ERROR;
827 :
828 : if (Z_TYPE_P(str) == IS_UNICODE) {
829 : convert_to_string_with_converter(str, UG(utf8_conv));
830 : encoding = "UTF-8";
831 : } else {
832 : UErrorCode status = U_ZERO_ERROR;
833 : encoding = ucnv_getName(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &status);
834 : }
835 :
836 : str->value.str.val = safe_erealloc(str->value.str.val, 1, str->value.str.len, ZEND_MMAP_AHEAD);
837 : memset(str->value.str.val + str->value.str.len, 0, ZEND_MMAP_AHEAD);
838 :
839 : SCNG(yy_in)=NULL;
840 :
841 : zend_prepare_scanner_converters(encoding, 0 TSRMLS_CC);
842 : /* Re-encode for Unicode if needed */
843 : yy_scan_buffer(Z_STRVAL_P(str), Z_STRLEN_P(str) TSRMLS_CC);
844 :
845 : zend_set_compiled_filename(filename TSRMLS_CC);
846 : zend_set_compiled_script_encoding((char*)ucnv_getName(SCNG(output_conv), &status) TSRMLS_CC);
847 : CG(zend_lineno) = 1;
848 : CG(increment_lineno) = 0;
849 : return SUCCESS;
850 : }
851 :
852 :
853 : ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D)
854 : {
855 : return SCNG(yy_cursor) - SCNG(yy_start);
856 : }
857 :
858 :
859 : zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
860 : {
861 : zend_lex_state original_lex_state;
862 : zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
863 : zend_op_array *original_active_op_array = CG(active_op_array);
864 : zend_op_array *retval;
865 : zval tmp;
866 : int compiler_result;
867 : zend_bool original_in_compilation = CG(in_compilation);
868 :
869 : tmp = *source_string;
870 : zval_copy_ctor(&tmp);
871 : if (Z_TYPE(tmp) != IS_STRING && Z_TYPE(tmp) != IS_UNICODE) {
872 : convert_to_unicode(&tmp);
873 : }
874 : source_string = &tmp;
875 :
876 : if (Z_UNILEN_P(source_string)==0) {
877 : efree(op_array);
878 : zval_dtor(&tmp);
879 : return NULL;
880 : }
881 :
882 : CG(in_compilation) = 1;
883 :
884 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
885 : if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
886 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
887 : efree(op_array);
888 : retval = NULL;
889 : } else {
890 : zend_bool orig_interactive = CG(interactive);
891 :
892 : CG(interactive) = 0;
893 : init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
894 : CG(interactive) = orig_interactive;
895 : CG(active_op_array) = op_array;
896 : BEGIN(ST_IN_SCRIPTING);
897 : compiler_result = zendparse(TSRMLS_C);
898 :
899 : if (compiler_result==1) {
900 : CG(active_op_array) = original_active_op_array;
901 : CG(unclean_shutdown)=1;
902 : retval = NULL;
903 : } else {
904 : zend_do_return(NULL, 0 TSRMLS_CC);
905 : CG(active_op_array) = original_active_op_array;
906 : pass_two(op_array TSRMLS_CC);
907 : zend_release_labels(TSRMLS_C);
908 : retval = op_array;
909 : }
910 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
911 : }
912 : zval_dtor(&tmp);
913 : CG(in_compilation) = original_in_compilation;
914 : return retval;
915 : }
916 :
917 :
918 : BEGIN_EXTERN_C()
919 : int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
920 : {
921 : zend_lex_state original_lex_state;
922 : zend_file_handle file_handle;
923 :
924 : file_handle.type = ZEND_HANDLE_FILENAME;
925 : file_handle.filename = filename;
926 : file_handle.free_filename = 0;
927 : file_handle.opened_path = NULL;
928 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
929 : if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
930 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
931 : zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename TSRMLS_CC);
932 : return FAILURE;
933 : }
934 : zend_highlight(syntax_highlighter_ini TSRMLS_CC);
935 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
936 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
937 : return SUCCESS;
938 : }
939 :
940 : int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)
941 : {
942 : zend_lex_state original_lex_state;
943 : zval tmp = *str;
944 :
945 : str = &tmp;
946 : zval_copy_ctor(str);
947 : zend_save_lexical_state(&original_lex_state TSRMLS_CC);
948 : if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
949 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
950 : return FAILURE;
951 : }
952 : BEGIN(INITIAL);
953 : zend_highlight(syntax_highlighter_ini TSRMLS_CC);
954 : zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
955 : zval_dtor(str);
956 : return SUCCESS;
957 : }
958 : END_EXTERN_C()
959 :
960 : #define zend_copy_value(zendlval, yytext, yyleng) \
961 : Z_STRVAL_P(zendlval) = (char *)estrndup(yytext, yyleng); \
962 : Z_STRLEN_P(zendlval) = yyleng;
963 :
964 : static int zend_scan_unicode_escape_string(zval *zendlval, char *str, int len, UChar quote_type, int type TSRMLS_DC)
965 : {
966 : register UChar *s, *t, c;
967 : UChar *end;
968 : UChar32 codepoint = 0;
969 : int8_t digit;
970 : int8_t min_digits = 0, max_digits = 0;
971 : int8_t bits;
972 : int8_t n;
973 :
974 : if (!zend_copy_scanner_string(zendlval, str, len, IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
975 : return 0;
976 : }
977 :
978 : /* convert escape sequences */
979 : s = t = Z_USTRVAL_P(zendlval);
980 : end = s+Z_USTRLEN_P(zendlval);
981 : while (s<end) {
982 : if (*s==0x5C /*'\\'*/) {
983 : s++;
984 : c = *s;
985 : if (s >= end) {
986 : *t++ = 0x5C; /*'\\'*/
987 : break;
988 : }
989 :
990 : min_digits = 0;
991 : codepoint = 0;
992 : bits = 4;
993 : n = 0;
994 :
995 : switch(c) {
996 : case 0x6E: /*'n'*/
997 : *t++ = (UChar) 0x0A; /*'\n'*/
998 : Z_USTRLEN_P(zendlval)--;
999 : break;
1000 : case 0x72: /*'r'*/
1001 : *t++ = (UChar) 0x0D; /*'\r'*/
1002 : Z_USTRLEN_P(zendlval)--;
1003 : break;
1004 : case 0x74: /*'t'*/
1005 : *t++ = (UChar) 0x09; /*'\t'*/
1006 : Z_USTRLEN_P(zendlval)--;
1007 : break;
1008 : case 0x66: /*'f'*/
1009 : *t++ = (UChar) 0x0C; /*'\f'*/
1010 : Z_USTRLEN_P(zendlval)--;
1011 : break;
1012 : case 0x76: /*'v'*/
1013 : *t++ = (UChar) 0x0B; /*'\v'*/
1014 : Z_USTRLEN_P(zendlval)--;
1015 : break;
1016 : case 0x22: /*'"'*/
1017 : case 0x60: /*'`'*/
1018 : if (c != quote_type) {
1019 : *t++ = 0x5C; /*'\\'*/
1020 : *t++ = *s;
1021 : break;
1022 : }
1023 : case 0x5C: /*'\\'*/
1024 : case 0x24: /*'$'*/
1025 : *t++ = *s;
1026 : Z_USTRLEN_P(zendlval)--;
1027 : break;
1028 : case 0x43: /*'C'*/
1029 : {
1030 : UChar *p = s+1;
1031 : if (p < end && zend_parse_charname_sequence(&p, end, &codepoint TSRMLS_CC)) {
1032 : Z_USTRLEN_P(zendlval) -= p - s + 1;
1033 : s = p;
1034 : if (U_IS_BMP(codepoint)) {
1035 : *t++ = (UChar) codepoint;
1036 : } else {
1037 : *t++ = (UChar) U16_LEAD(codepoint);
1038 : *t++ = (UChar) U16_TRAIL(codepoint);
1039 : Z_USTRLEN_P(zendlval)++;
1040 : }
1041 : } else {
1042 : zend_error(E_COMPILE_WARNING, "Invalid \\C{..} sequence");
1043 : efree(Z_USTRVAL_P(zendlval));
1044 : return 0;
1045 : }
1046 : break;
1047 : }
1048 : case 0x75: /*'u'*/
1049 : min_digits = 4;
1050 : max_digits = 4;
1051 : Z_USTRLEN_P(zendlval)--;
1052 : break;
1053 : case 0x55: /*'U'*/
1054 : min_digits = 6;
1055 : max_digits = 6;
1056 : Z_USTRLEN_P(zendlval)--;
1057 : break;
1058 : case 0x78: /*'x'*/
1059 : case 0x58: /*'X'*/
1060 : if ((digit = zend_get_hex_digit(*(s+1))) >= 0) {
1061 : min_digits = 1;
1062 : max_digits = 2;
1063 : Z_USTRLEN_P(zendlval)--;
1064 : s++;
1065 : n = 1; /* already have one digit */
1066 : codepoint = digit;
1067 : } else {
1068 : *t++ = 0x5C; /*'\\'*/
1069 : *t++ = *s;
1070 : }
1071 : break;
1072 : default:
1073 : digit = zend_get_octal_digit(*s);
1074 : if (digit >= 0) {
1075 : min_digits = 1;
1076 : max_digits = 3;
1077 : bits = 3;
1078 : n = 1; /* already have one digit */
1079 : codepoint = digit;
1080 : } else {
1081 : *t++ = 0x5C; /*'\\'*/
1082 : *t++ = *s;
1083 : }
1084 : break;
1085 : }
1086 :
1087 : /* need to parse a number for one of the escape sequences */
1088 : if (min_digits != 0) {
1089 : while (s++ < end && n < max_digits) {
1090 : digit = (bits == 4) ? zend_get_hex_digit(*s) : zend_get_octal_digit(*s);
1091 : if (digit < 0) {
1092 : break;
1093 : }
1094 : codepoint = (codepoint << bits) | digit;
1095 : n++;
1096 : }
1097 :
1098 : if (n < min_digits) {
1099 : /* can only happen for \u and \U sequences */
1100 : zend_error(E_COMPILE_WARNING,"\\%c escape sequence requires exactly %d hexadecimal digits", (char) c, min_digits);
1101 : efree(Z_USTRVAL_P(zendlval));
1102 : return 0;
1103 : }
1104 :
1105 : if (U_IS_BMP(codepoint)) {
1106 : *t++ = (UChar) codepoint;
1107 : Z_USTRLEN_P(zendlval) -= n;
1108 : } else if (codepoint <= 0x10FFFF) {
1109 : *t++ = (UChar) U16_LEAD(codepoint);
1110 : *t++ = (UChar) U16_TRAIL(codepoint);
1111 : Z_USTRLEN_P(zendlval) -= n-1;
1112 : } else {
1113 : zend_error(E_COMPILE_WARNING,"\\U%06x is above the highest valid codepoint 0x10FFFF", codepoint);
1114 : efree(Z_USTRVAL_P(zendlval));
1115 : return 0;
1116 : }
1117 :
1118 : /* s is already incremented and not past a newline */
1119 : continue;
1120 : }
1121 : } else {
1122 : *t++ = *s;
1123 : }
1124 :
1125 : if (*s == 0x0A /*'\n'*/ || (*s == 0x0D /*'\r'*/ && (*(s+1) != 0x0A /*'\n'*/))) {
1126 : CG(zend_lineno)++;
1127 : }
1128 : s++;
1129 : }
1130 : *t = 0;
1131 :
1132 : return type;
1133 : }
1134 :
1135 : static int zend_scan_unicode_single_string(zval *zendlval TSRMLS_DC)
1136 : {
1137 : register UChar *s, *t;
1138 : UChar *end;
1139 :
1140 : if (!zend_copy_scanner_string(zendlval, yytext+1, yyleng-2, IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
1141 : return 0;
1142 : }
1143 :
1144 : /* convert escape sequences */
1145 : s = t = Z_USTRVAL_P(zendlval);
1146 : end = s+Z_USTRLEN_P(zendlval);
1147 : while (s<end) {
1148 : if (*s==0x5C /*'\\'*/) {
1149 : s++;
1150 :
1151 : switch(*s) {
1152 : case 0x5C: /*'\\'*/
1153 : case 0x27: /*'\''*/
1154 : *t++ = *s;
1155 : Z_USTRLEN_P(zendlval)--;
1156 : break;
1157 : default:
1158 : *t++ = 0x5C; /*'\\'*/
1159 : *t++ = *s;
1160 : break;
1161 : }
1162 : } else {
1163 : *t++ = *s;
1164 : }
1165 :
1166 : if (*s == 0x0A /*'\n'*/ || (*s == 0x0D /*'\r'*/ && (*(s+1) != 0x0A /*'\n'*/))) {
1167 : CG(zend_lineno)++;
1168 : }
1169 : s++;
1170 : }
1171 : *t = 0;
1172 :
1173 : return T_CONSTANT_ENCAPSED_STRING;
1174 : }
1175 :
1176 : static void zend_scan_binary_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
1177 : {
1178 : register char *s, *t;
1179 : char *end;
1180 :
1181 : ZVAL_STRINGL(zendlval, str, len, 1);
1182 :
1183 : /* convert escape sequences */
1184 : s = t = Z_STRVAL_P(zendlval);
1185 : end = s+Z_STRLEN_P(zendlval);
1186 : while (s<end) {
1187 : if (*s=='\\') {
1188 : s++;
1189 : if (s >= end) {
1190 : *t++ = '\\';
1191 : break;
1192 : }
1193 :
1194 : switch(*s) {
1195 : case 'n':
1196 : *t++ = '\n';
1197 : Z_STRLEN_P(zendlval)--;
1198 : break;
1199 : case 'r':
1200 : *t++ = '\r';
1201 : Z_STRLEN_P(zendlval)--;
1202 : break;
1203 : case 't':
1204 : *t++ = '\t';
1205 : Z_STRLEN_P(zendlval)--;
1206 : break;
1207 : case 'f':
1208 : *t++ = '\f';
1209 : zendlval->value.str.len--;
1210 : break;
1211 : case 'v':
1212 : *t++ = '\v';
1213 : zendlval->value.str.len--;
1214 : break;
1215 : case '"':
1216 : case '`':
1217 : if (*s != quote_type) {
1218 : *t++ = '\\';
1219 : *t++ = *s;
1220 : break;
1221 : }
1222 : case '\\':
1223 : case '$':
1224 : *t++ = *s;
1225 : Z_STRLEN_P(zendlval)--;
1226 : break;
1227 : case 'x':
1228 : case 'X':
1229 : if (ZEND_IS_HEX(*(s+1))) {
1230 : char hex_buf[3] = { 0, 0, 0 };
1231 :
1232 : Z_STRLEN_P(zendlval)--; /* for the 'x' */
1233 :
1234 : hex_buf[0] = *(++s);
1235 : Z_STRLEN_P(zendlval)--;
1236 : if (ZEND_IS_HEX(*(s+1))) {
1237 : hex_buf[1] = *(++s);
1238 : Z_STRLEN_P(zendlval)--;
1239 : }
1240 : *t++ = (char) strtol(hex_buf, NULL, 16);
1241 : } else {
1242 : *t++ = '\\';
1243 : *t++ = *s;
1244 : }
1245 : break;
1246 : default:
1247 : /* check for an octal */
1248 : if (ZEND_IS_OCT(*s)) {
1249 : char octal_buf[4] = { 0, 0, 0, 0 };
1250 :
1251 : octal_buf[0] = *s;
1252 : Z_STRLEN_P(zendlval)--;
1253 : if (ZEND_IS_OCT(*(s+1))) {
1254 : octal_buf[1] = *(++s);
1255 : Z_STRLEN_P(zendlval)--;
1256 : if (ZEND_IS_OCT(*(s+1))) {
1257 : octal_buf[2] = *(++s);
1258 : Z_STRLEN_P(zendlval)--;
1259 : }
1260 : }
1261 : *t++ = (char) strtol(octal_buf, NULL, 8);
1262 : } else {
1263 : *t++ = '\\';
1264 : *t++ = *s;
1265 : }
1266 : break;
1267 : }
1268 : } else {
1269 : *t++ = *s;
1270 : }
1271 :
1272 : if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
1273 : CG(zend_lineno)++;
1274 : }
1275 : s++;
1276 : }
1277 : *t = 0;
1278 : }
1279 :
1280 : static void zend_scan_binary_single_string(zval *zendlval, char *str, int len TSRMLS_DC)
1281 : {
1282 : register char *s, *t;
1283 : char *end;
1284 :
1285 : ZVAL_STRINGL(zendlval, str, len, 1);
1286 :
1287 : /* convert escape sequences */
1288 : s = t = Z_STRVAL_P(zendlval);
1289 : end = s+Z_STRLEN_P(zendlval);
1290 : while (s<end) {
1291 : if (*s=='\\') {
1292 : s++;
1293 :
1294 : switch(*s) {
1295 : case '\\':
1296 : case '\'':
1297 : *t++ = *s;
1298 : Z_STRLEN_P(zendlval)--;
1299 : break;
1300 : default:
1301 : *t++ = '\\';
1302 : *t++ = *s;
1303 : break;
1304 : }
1305 : } else {
1306 : *t++ = *s;
1307 : }
1308 :
1309 : if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
1310 : CG(zend_lineno)++;
1311 : }
1312 : s++;
1313 : }
1314 : *t = 0;
1315 : }
1316 :
1317 :
1318 : int lex_scan(zval *zendlval TSRMLS_DC)
1319 : {
1320 : restart:
1321 : SCNG(yy_text) = YYCURSOR;
1322 :
1323 : yymore_restart:
1324 :
1325 :
1326 : #line 1327 "Zend/zend_language_scanner.c"
1327 : {
1328 : YYCTYPE yych;
1329 5521540 : unsigned int yyaccept = 0;
1330 5521540 : if (YYGETCONDITION() < 5) {
1331 5466085 : if (YYGETCONDITION() < 2) {
1332 5419168 : if (YYGETCONDITION() < 1) {
1333 5387722 : goto yyc_ST_IN_SCRIPTING;
1334 : } else {
1335 31446 : goto yyc_ST_LOOKING_FOR_PROPERTY;
1336 : }
1337 : } else {
1338 46917 : if (YYGETCONDITION() < 3) {
1339 422 : goto yyc_ST_BACKQUOTE;
1340 : } else {
1341 46495 : if (YYGETCONDITION() < 4) {
1342 44281 : goto yyc_ST_DOUBLE_QUOTES;
1343 : } else {
1344 2214 : goto yyc_ST_HEREDOC;
1345 : }
1346 : }
1347 : }
1348 : } else {
1349 55455 : if (YYGETCONDITION() < 7) {
1350 2663 : if (YYGETCONDITION() < 6) {
1351 85 : goto yyc_ST_LOOKING_FOR_VARNAME;
1352 : } else {
1353 2578 : goto yyc_ST_VAR_OFFSET;
1354 : }
1355 : } else {
1356 52792 : if (YYGETCONDITION() < 8) {
1357 51375 : goto yyc_INITIAL;
1358 : } else {
1359 1417 : if (YYGETCONDITION() < 9) {
1360 1380 : goto yyc_ST_END_HEREDOC;
1361 : } else {
1362 37 : goto yyc_ST_NOWDOC;
1363 : }
1364 : }
1365 : }
1366 : }
1367 : /* *********************************** */
1368 51375 : yyc_INITIAL:
1369 : {
1370 : static const unsigned char yybm[] = {
1371 : 0, 0, 0, 0, 0, 0, 0, 0,
1372 : 0, 128, 128, 0, 0, 128, 0, 0,
1373 : 0, 0, 0, 0, 0, 0, 0, 0,
1374 : 0, 0, 0, 0, 0, 0, 0, 0,
1375 : 128, 0, 0, 0, 0, 0, 0, 0,
1376 : 0, 0, 0, 0, 0, 0, 0, 0,
1377 : 0, 0, 0, 0, 0, 0, 0, 0,
1378 : 0, 0, 0, 0, 0, 0, 0, 0,
1379 : 0, 0, 0, 0, 0, 0, 0, 0,
1380 : 0, 0, 0, 0, 0, 0, 0, 0,
1381 : 0, 0, 0, 0, 0, 0, 0, 0,
1382 : 0, 0, 0, 0, 0, 0, 0, 0,
1383 : 0, 0, 0, 0, 0, 0, 0, 0,
1384 : 0, 0, 0, 0, 0, 0, 0, 0,
1385 : 0, 0, 0, 0, 0, 0, 0, 0,
1386 : 0, 0, 0, 0, 0, 0, 0, 0,
1387 : 0, 0, 0, 0, 0, 0, 0, 0,
1388 : 0, 0, 0, 0, 0, 0, 0, 0,
1389 : 0, 0, 0, 0, 0, 0, 0, 0,
1390 : 0, 0, 0, 0, 0, 0, 0, 0,
1391 : 0, 0, 0, 0, 0, 0, 0, 0,
1392 : 0, 0, 0, 0, 0, 0, 0, 0,
1393 : 0, 0, 0, 0, 0, 0, 0, 0,
1394 : 0, 0, 0, 0, 0, 0, 0, 0,
1395 : 0, 0, 0, 0, 0, 0, 0, 0,
1396 : 0, 0, 0, 0, 0, 0, 0, 0,
1397 : 0, 0, 0, 0, 0, 0, 0, 0,
1398 : 0, 0, 0, 0, 0, 0, 0, 0,
1399 : 0, 0, 0, 0, 0, 0, 0, 0,
1400 : 0, 0, 0, 0, 0, 0, 0, 0,
1401 : 0, 0, 0, 0, 0, 0, 0, 0,
1402 : 0, 0, 0, 0, 0, 0, 0, 0,
1403 : };
1404 :
1405 : YYDEBUG(0, *YYCURSOR);
1406 51375 : YYFILL(8);
1407 51375 : yych = *YYCURSOR;
1408 51375 : if (yych != '<') goto yy4;
1409 : YYDEBUG(2, *YYCURSOR);
1410 24832 : yyaccept = 0;
1411 24832 : yych = *(YYMARKER = ++YYCURSOR);
1412 24832 : if (yych <= '?') {
1413 24732 : if (yych == '%') goto yy7;
1414 24730 : if (yych >= '?') goto yy5;
1415 : } else {
1416 100 : if (yych <= 'S') {
1417 3 : if (yych >= 'S') goto yy9;
1418 : } else {
1419 97 : if (yych == 's') goto yy9;
1420 : }
1421 : }
1422 26639 : yy3:
1423 : YYDEBUG(3, *YYCURSOR);
1424 26639 : yyleng = YYCURSOR - SCNG(yy_text);
1425 : #line 2068 "Zend/zend_language_scanner.l"
1426 : {
1427 : if (YYCURSOR > YYLIMIT) {
1428 : return 0;
1429 : }
1430 :
1431 : inline_char_handler:
1432 :
1433 : while (1) {
1434 : YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
1435 :
1436 : YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
1437 :
1438 : if (YYCURSOR < YYLIMIT) {
1439 : switch (*YYCURSOR) {
1440 : case '?':
1441 : if (CG(short_tags) || !strncasecmp(YYCURSOR + 1, "php", 3)) { /* Assume [ \t\n\r] follows "php" */
1442 : break;
1443 : }
1444 : continue;
1445 : case '%':
1446 : if (CG(asp_tags)) {
1447 : break;
1448 : }
1449 : continue;
1450 : case 's':
1451 : case 'S':
1452 : /* Probably NOT an opening PHP <script> tag, so don't end the HTML chunk yet
1453 : * If it is, the PHP <script> tag rule checks for any HTML scanned before it */
1454 : YYCURSOR--;
1455 : yymore();
1456 : default:
1457 : continue;
1458 : }
1459 :
1460 : YYCURSOR--;
1461 : }
1462 :
1463 : break;
1464 : }
1465 :
1466 : inline_html:
1467 : yyleng = YYCURSOR - SCNG(yy_text);
1468 :
1469 : Z_STRVAL_P(zendlval) = (char *) estrndup(yytext, yyleng);
1470 : Z_STRLEN_P(zendlval) = yyleng;
1471 : Z_TYPE_P(zendlval) = IS_STRING;
1472 : HANDLE_NEWLINES(yytext, yyleng);
1473 : return T_INLINE_HTML;
1474 : }
1475 : #line 1476 "Zend/zend_language_scanner.c"
1476 26543 : yy4:
1477 : YYDEBUG(4, *YYCURSOR);
1478 26543 : yych = *++YYCURSOR;
1479 26543 : goto yy3;
1480 24729 : yy5:
1481 : YYDEBUG(5, *YYCURSOR);
1482 24729 : yyaccept = 1;
1483 24729 : yych = *(YYMARKER = ++YYCURSOR);
1484 24729 : if (yych <= 'O') {
1485 10 : if (yych == '=') goto yy45;
1486 : } else {
1487 24719 : if (yych <= 'P') goto yy47;
1488 24353 : if (yych == 'p') goto yy47;
1489 : }
1490 6 : yy6:
1491 : YYDEBUG(6, *YYCURSOR);
1492 6 : yyleng = YYCURSOR - SCNG(yy_text);
1493 : #line 2056 "Zend/zend_language_scanner.l"
1494 : {
1495 : if (CG(short_tags)) {
1496 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1497 : Z_STRLEN_P(zendlval) = yyleng;
1498 : Z_TYPE_P(zendlval) = IS_STRING;
1499 : BEGIN(ST_IN_SCRIPTING);
1500 : return T_OPEN_TAG;
1501 : } else {
1502 : goto inline_char_handler;
1503 : }
1504 : }
1505 : #line 1506 "Zend/zend_language_scanner.c"
1506 2 : yy7:
1507 : YYDEBUG(7, *YYCURSOR);
1508 2 : ++YYCURSOR;
1509 2 : if ((yych = *YYCURSOR) == '=') goto yy43;
1510 : YYDEBUG(8, *YYCURSOR);
1511 0 : yyleng = YYCURSOR - SCNG(yy_text);
1512 : #line 2033 "Zend/zend_language_scanner.l"
1513 : {
1514 : if (CG(asp_tags)) {
1515 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1516 : Z_STRLEN_P(zendlval) = yyleng;
1517 : Z_TYPE_P(zendlval) = IS_STRING;
1518 : BEGIN(ST_IN_SCRIPTING);
1519 : return T_OPEN_TAG;
1520 : } else {
1521 : goto inline_char_handler;
1522 : }
1523 : }
1524 : #line 1525 "Zend/zend_language_scanner.c"
1525 10 : yy9:
1526 : YYDEBUG(9, *YYCURSOR);
1527 10 : yych = *++YYCURSOR;
1528 10 : if (yych == 'C') goto yy11;
1529 10 : if (yych == 'c') goto yy11;
1530 5 : yy10:
1531 : YYDEBUG(10, *YYCURSOR);
1532 5 : YYCURSOR = YYMARKER;
1533 5 : if (yyaccept <= 0) {
1534 5 : goto yy3;
1535 : } else {
1536 0 : goto yy6;
1537 : }
1538 9 : yy11:
1539 : YYDEBUG(11, *YYCURSOR);
1540 9 : yych = *++YYCURSOR;
1541 9 : if (yych == 'R') goto yy12;
1542 9 : if (yych != 'r') goto yy10;
1543 8 : yy12:
1544 : YYDEBUG(12, *YYCURSOR);
1545 8 : yych = *++YYCURSOR;
1546 8 : if (yych == 'I') goto yy13;
1547 8 : if (yych != 'i') goto yy10;
1548 8 : yy13:
1549 : YYDEBUG(13, *YYCURSOR);
1550 8 : yych = *++YYCURSOR;
1551 8 : if (yych == 'P') goto yy14;
1552 8 : if (yych != 'p') goto yy10;
1553 8 : yy14:
1554 : YYDEBUG(14, *YYCURSOR);
1555 8 : yych = *++YYCURSOR;
1556 8 : if (yych == 'T') goto yy15;
1557 8 : if (yych != 't') goto yy10;
1558 8 : yy15:
1559 : YYDEBUG(15, *YYCURSOR);
1560 8 : yych = *++YYCURSOR;
1561 8 : if (yych == 'L') goto yy10;
1562 8 : if (yych == 'l') goto yy10;
1563 8 : goto yy17;
1564 7 : yy16:
1565 : YYDEBUG(16, *YYCURSOR);
1566 7 : ++YYCURSOR;
1567 7 : YYFILL(8);
1568 7 : yych = *YYCURSOR;
1569 15 : yy17:
1570 : YYDEBUG(17, *YYCURSOR);
1571 15 : if (yybm[0+yych] & 128) {
1572 7 : goto yy16;
1573 : }
1574 8 : if (yych == 'L') goto yy18;
1575 8 : if (yych != 'l') goto yy10;
1576 7 : yy18:
1577 : YYDEBUG(18, *YYCURSOR);
1578 7 : yych = *++YYCURSOR;
1579 7 : if (yych == 'A') goto yy19;
1580 7 : if (yych != 'a') goto yy10;
1581 7 : yy19:
1582 : YYDEBUG(19, *YYCURSOR);
1583 7 : yych = *++YYCURSOR;
1584 7 : if (yych == 'N') goto yy20;
1585 7 : if (yych != 'n') goto yy10;
1586 7 : yy20:
1587 : YYDEBUG(20, *YYCURSOR);
1588 7 : yych = *++YYCURSOR;
1589 7 : if (yych == 'G') goto yy21;
1590 7 : if (yych != 'g') goto yy10;
1591 7 : yy21:
1592 : YYDEBUG(21, *YYCURSOR);
1593 7 : yych = *++YYCURSOR;
1594 7 : if (yych == 'U') goto yy22;
1595 7 : if (yych != 'u') goto yy10;
1596 7 : yy22:
1597 : YYDEBUG(22, *YYCURSOR);
1598 7 : yych = *++YYCURSOR;
1599 7 : if (yych == 'A') goto yy23;
1600 7 : if (yych != 'a') goto yy10;
1601 7 : yy23:
1602 : YYDEBUG(23, *YYCURSOR);
1603 7 : yych = *++YYCURSOR;
1604 7 : if (yych == 'G') goto yy24;
1605 7 : if (yych != 'g') goto yy10;
1606 7 : yy24:
1607 : YYDEBUG(24, *YYCURSOR);
1608 7 : yych = *++YYCURSOR;
1609 7 : if (yych == 'E') goto yy25;
1610 7 : if (yych != 'e') goto yy10;
1611 7 : yy25:
1612 : YYDEBUG(25, *YYCURSOR);
1613 7 : ++YYCURSOR;
1614 7 : YYFILL(1);
1615 7 : yych = *YYCURSOR;
1616 : YYDEBUG(26, *YYCURSOR);
1617 7 : if (yych <= '\r') {
1618 0 : if (yych <= 0x08) goto yy10;
1619 0 : if (yych <= '\n') goto yy25;
1620 0 : if (yych <= '\f') goto yy10;
1621 0 : goto yy25;
1622 : } else {
1623 7 : if (yych <= ' ') {
1624 0 : if (yych <= 0x1F) goto yy10;
1625 0 : goto yy25;
1626 : } else {
1627 7 : if (yych != '=') goto yy10;
1628 : }
1629 : }
1630 6 : yy27:
1631 : YYDEBUG(27, *YYCURSOR);
1632 6 : ++YYCURSOR;
1633 6 : YYFILL(5);
1634 6 : yych = *YYCURSOR;
1635 : YYDEBUG(28, *YYCURSOR);
1636 6 : if (yych <= '!') {
1637 0 : if (yych <= '\f') {
1638 0 : if (yych <= 0x08) goto yy10;
1639 0 : if (yych <= '\n') goto yy27;
1640 0 : goto yy10;
1641 : } else {
1642 0 : if (yych <= '\r') goto yy27;
1643 0 : if (yych == ' ') goto yy27;
1644 0 : goto yy10;
1645 : }
1646 : } else {
1647 6 : if (yych <= 'O') {
1648 3 : if (yych <= '"') goto yy30;
1649 2 : if (yych == '\'') goto yy31;
1650 1 : goto yy10;
1651 : } else {
1652 3 : if (yych <= 'P') goto yy29;
1653 3 : if (yych != 'p') goto yy10;
1654 : }
1655 : }
1656 3 : yy29:
1657 : YYDEBUG(29, *YYCURSOR);
1658 3 : yych = *++YYCURSOR;
1659 3 : if (yych == 'H') goto yy42;
1660 3 : if (yych == 'h') goto yy42;
1661 0 : goto yy10;
1662 1 : yy30:
1663 : YYDEBUG(30, *YYCURSOR);
1664 1 : yych = *++YYCURSOR;
1665 1 : if (yych == 'P') goto yy39;
1666 1 : if (yych == 'p') goto yy39;
1667 0 : goto yy10;
1668 1 : yy31:
1669 : YYDEBUG(31, *YYCURSOR);
1670 1 : yych = *++YYCURSOR;
1671 1 : if (yych == 'P') goto yy32;
1672 1 : if (yych != 'p') goto yy10;
1673 1 : yy32:
1674 : YYDEBUG(32, *YYCURSOR);
1675 1 : yych = *++YYCURSOR;
1676 1 : if (yych == 'H') goto yy33;
1677 1 : if (yych != 'h') goto yy10;
1678 1 : yy33:
1679 : YYDEBUG(33, *YYCURSOR);
1680 1 : yych = *++YYCURSOR;
1681 1 : if (yych == 'P') goto yy34;
1682 1 : if (yych != 'p') goto yy10;
1683 1 : yy34:
1684 : YYDEBUG(34, *YYCURSOR);
1685 1 : yych = *++YYCURSOR;
1686 1 : if (yych != '\'') goto yy10;
1687 5 : yy35:
1688 : YYDEBUG(35, *YYCURSOR);
1689 5 : ++YYCURSOR;
1690 5 : YYFILL(1);
1691 5 : yych = *YYCURSOR;
1692 : YYDEBUG(36, *YYCURSOR);
1693 5 : if (yych <= '\r') {
1694 0 : if (yych <= 0x08) goto yy10;
1695 0 : if (yych <= '\n') goto yy35;
1696 0 : if (yych <= '\f') goto yy10;
1697 0 : goto yy35;
1698 : } else {
1699 5 : if (yych <= ' ') {
1700 0 : if (yych <= 0x1F) goto yy10;
1701 0 : goto yy35;
1702 : } else {
1703 5 : if (yych != '>') goto yy10;
1704 : }
1705 : }
1706 : YYDEBUG(37, *YYCURSOR);
1707 5 : ++YYCURSOR;
1708 : YYDEBUG(38, *YYCURSOR);
1709 5 : yyleng = YYCURSOR - SCNG(yy_text);
1710 : #line 1990 "Zend/zend_language_scanner.l"
1711 : {
1712 : YYCTYPE *bracket = zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
1713 :
1714 : if (bracket != SCNG(yy_text)) {
1715 : /* Handle previously scanned HTML, as possible <script> tags found are assumed to not be PHP's */
1716 : YYCURSOR = bracket;
1717 : goto inline_html;
1718 : }
1719 :
1720 : HANDLE_NEWLINES(yytext, yyleng);
1721 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1722 : Z_STRLEN_P(zendlval) = yyleng;
1723 : Z_TYPE_P(zendlval) = IS_STRING;
1724 : BEGIN(ST_IN_SCRIPTING);
1725 : return T_OPEN_TAG;
1726 : }
1727 : #line 1728 "Zend/zend_language_scanner.c"
1728 1 : yy39:
1729 : YYDEBUG(39, *YYCURSOR);
1730 1 : yych = *++YYCURSOR;
1731 1 : if (yych == 'H') goto yy40;
1732 1 : if (yych != 'h') goto yy10;
1733 1 : yy40:
1734 : YYDEBUG(40, *YYCURSOR);
1735 1 : yych = *++YYCURSOR;
1736 1 : if (yych == 'P') goto yy41;
1737 1 : if (yych != 'p') goto yy10;
1738 1 : yy41:
1739 : YYDEBUG(41, *YYCURSOR);
1740 1 : yych = *++YYCURSOR;
1741 1 : if (yych == '"') goto yy35;
1742 0 : goto yy10;
1743 3 : yy42:
1744 : YYDEBUG(42, *YYCURSOR);
1745 3 : yych = *++YYCURSOR;
1746 3 : if (yych == 'P') goto yy35;
1747 3 : if (yych == 'p') goto yy35;
1748 0 : goto yy10;
1749 2 : yy43:
1750 : YYDEBUG(43, *YYCURSOR);
1751 2 : ++YYCURSOR;
1752 : YYDEBUG(44, *YYCURSOR);
1753 2 : yyleng = YYCURSOR - SCNG(yy_text);
1754 : #line 2007 "Zend/zend_language_scanner.l"
1755 : {
1756 : if (CG(asp_tags)) {
1757 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1758 : Z_STRLEN_P(zendlval) = yyleng;
1759 : Z_TYPE_P(zendlval) = IS_STRING;
1760 : BEGIN(ST_IN_SCRIPTING);
1761 : return T_OPEN_TAG_WITH_ECHO;
1762 : } else {
1763 : goto inline_char_handler;
1764 : }
1765 : }
1766 : #line 1767 "Zend/zend_language_scanner.c"
1767 4 : yy45:
1768 : YYDEBUG(45, *YYCURSOR);
1769 4 : ++YYCURSOR;
1770 : YYDEBUG(46, *YYCURSOR);
1771 4 : yyleng = YYCURSOR - SCNG(yy_text);
1772 : #line 2020 "Zend/zend_language_scanner.l"
1773 : {
1774 : if (CG(short_tags)) {
1775 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1776 : Z_STRLEN_P(zendlval) = yyleng;
1777 : Z_TYPE_P(zendlval) = IS_STRING;
1778 : BEGIN(ST_IN_SCRIPTING);
1779 : return T_OPEN_TAG_WITH_ECHO;
1780 : } else {
1781 : goto inline_char_handler;
1782 : }
1783 : }
1784 : #line 1785 "Zend/zend_language_scanner.c"
1785 24719 : yy47:
1786 : YYDEBUG(47, *YYCURSOR);
1787 24719 : yych = *++YYCURSOR;
1788 24719 : if (yych == 'H') goto yy48;
1789 24353 : if (yych != 'h') goto yy10;
1790 24719 : yy48:
1791 : YYDEBUG(48, *YYCURSOR);
1792 24719 : yych = *++YYCURSOR;
1793 24719 : if (yych == 'P') goto yy49;
1794 24353 : if (yych != 'p') goto yy10;
1795 24719 : yy49:
1796 : YYDEBUG(49, *YYCURSOR);
1797 24719 : yych = *++YYCURSOR;
1798 24719 : if (yych <= '\f') {
1799 19740 : if (yych <= 0x08) goto yy10;
1800 19740 : if (yych >= '\v') goto yy10;
1801 : } else {
1802 4979 : if (yych <= '\r') goto yy52;
1803 4832 : if (yych != ' ') goto yy10;
1804 : }
1805 24719 : yy50:
1806 : YYDEBUG(50, *YYCURSOR);
1807 24719 : ++YYCURSOR;
1808 24719 : yy51:
1809 : YYDEBUG(51, *YYCURSOR);
1810 24719 : yyleng = YYCURSOR - SCNG(yy_text);
1811 : #line 2046 "Zend/zend_language_scanner.l"
1812 : {
1813 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
1814 : Z_STRLEN_P(zendlval) = yyleng;
1815 : Z_TYPE_P(zendlval) = IS_STRING;
1816 : HANDLE_NEWLINE(yytext[yyleng-1]);
1817 : BEGIN(ST_IN_SCRIPTING);
1818 : return T_OPEN_TAG;
1819 : }
1820 : #line 1821 "Zend/zend_language_scanner.c"
1821 147 : yy52:
1822 : YYDEBUG(52, *YYCURSOR);
1823 147 : ++YYCURSOR;
1824 147 : if ((yych = *YYCURSOR) == '\n') goto yy50;
1825 0 : goto yy51;
1826 : }
1827 : /* *********************************** */
1828 422 : yyc_ST_BACKQUOTE:
1829 : {
1830 : static const unsigned char yybm[] = {
1831 : 0, 0, 0, 0, 0, 0, 0, 0,
1832 : 0, 0, 0, 0, 0, 0, 0, 0,
1833 : 0, 0, 0, 0, 0, 0, 0, 0,
1834 : 0, 0, 0, 0, 0, 0, 0, 0,
1835 : 0, 0, 0, 0, 0, 0, 0, 0,
1836 : 0, 0, 0, 0, 0, 0, 0, 0,
1837 : 128, 128, 128, 128, 128, 128, 128, 128,
1838 : 128, 128, 0, 0, 0, 0, 0, 0,
1839 : 0, 128, 128, 128, 128, 128, 128, 128,
1840 : 128, 128, 128, 128, 128, 128, 128, 128,
1841 : 128, 128, 128, 128, 128, 128, 128, 128,
1842 : 128, 128, 128, 0, 0, 0, 0, 128,
1843 : 0, 128, 128, 128, 128, 128, 128, 128,
1844 : 128, 128, 128, 128, 128, 128, 128, 128,
1845 : 128, 128, 128, 128, 128, 128, 128, 128,
1846 : 128, 128, 128, 0, 0, 0, 0, 128,
1847 : 128, 128, 128, 128, 128, 128, 128, 128,
1848 : 128, 128, 128, 128, 128, 128, 128, 128,
1849 : 128, 128, 128, 128, 128, 128, 128, 128,
1850 : 128, 128, 128, 128, 128, 128, 128, 128,
1851 : 128, 128, 128, 128, 128, 128, 128, 128,
1852 : 128, 128, 128, 128, 128, 128, 128, 128,
1853 : 128, 128, 128, 128, 128, 128, 128, 128,
1854 : 128, 128, 128, 128, 128, 128, 128, 128,
1855 : 128, 128, 128, 128, 128, 128, 128, 128,
1856 : 128, 128, 128, 128, 128, 128, 128, 128,
1857 : 128, 128, 128, 128, 128, 128, 128, 128,
1858 : 128, 128, 128, 128, 128, 128, 128, 128,
1859 : 128, 128, 128, 128, 128, 128, 128, 128,
1860 : 128, 128, 128, 128, 128, 128, 128, 128,
1861 : 128, 128, 128, 128, 128, 128, 128, 128,
1862 : 128, 128, 128, 128, 128, 128, 128, 128,
1863 : };
1864 : YYDEBUG(53, *YYCURSOR);
1865 422 : YYFILL(2);
1866 422 : yych = *YYCURSOR;
1867 422 : if (yych <= '_') {
1868 305 : if (yych != '$') goto yy60;
1869 : } else {
1870 117 : if (yych <= '`') goto yy58;
1871 12 : if (yych == '{') goto yy57;
1872 12 : goto yy60;
1873 : }
1874 : YYDEBUG(55, *YYCURSOR);
1875 137 : ++YYCURSOR;
1876 137 : if ((yych = *YYCURSOR) <= '_') {
1877 0 : if (yych <= '@') goto yy56;
1878 0 : if (yych <= 'Z') goto yy63;
1879 0 : if (yych >= '_') goto yy63;
1880 : } else {
1881 137 : if (yych <= 'z') {
1882 137 : if (yych >= 'a') goto yy63;
1883 : } else {
1884 0 : if (yych <= '{') goto yy66;
1885 0 : if (yych >= 0x7F) goto yy63;
1886 : }
1887 : }
1888 180 : yy56:
1889 : YYDEBUG(56, *YYCURSOR);
1890 180 : yyleng = YYCURSOR - SCNG(yy_text);
1891 : #line 2510 "Zend/zend_language_scanner.l"
1892 : {
1893 : if (YYCURSOR > YYLIMIT) {
1894 : return 0;
1895 : }
1896 : if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
1897 : YYCURSOR++;
1898 : }
1899 :
1900 : while (YYCURSOR < YYLIMIT) {
1901 : switch (*YYCURSOR++) {
1902 : case '`':
1903 : break;
1904 : case '$':
1905 : if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
1906 : break;
1907 : }
1908 : continue;
1909 : case '{':
1910 : if (*YYCURSOR == '$') {
1911 : break;
1912 : }
1913 : continue;
1914 : case '\\':
1915 : if (YYCURSOR < YYLIMIT) {
1916 : YYCURSOR++;
1917 : }
1918 : /* fall through */
1919 : default:
1920 : continue;
1921 : }
1922 :
1923 : YYCURSOR--;
1924 : break;
1925 : }
1926 :
1927 : yyleng = YYCURSOR - SCNG(yy_text);
1928 :
1929 : if (CG(literal_type) == IS_UNICODE) {
1930 : return zend_scan_unicode_escape_string(zendlval, yytext, yyleng, 0x60 /*'`'*/, T_ENCAPSED_AND_WHITESPACE TSRMLS_CC);
1931 : } else {
1932 : zend_scan_binary_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
1933 : return T_ENCAPSED_AND_WHITESPACE;
1934 : }
1935 : }
1936 : #line 1937 "Zend/zend_language_scanner.c"
1937 0 : yy57:
1938 : YYDEBUG(57, *YYCURSOR);
1939 0 : yych = *++YYCURSOR;
1940 0 : if (yych == '$') goto yy61;
1941 0 : goto yy56;
1942 105 : yy58:
1943 : YYDEBUG(58, *YYCURSOR);
1944 105 : ++YYCURSOR;
1945 : YYDEBUG(59, *YYCURSOR);
1946 105 : yyleng = YYCURSOR - SCNG(yy_text);
1947 : #line 2450 "Zend/zend_language_scanner.l"
1948 : {
1949 : BEGIN(ST_IN_SCRIPTING);
1950 : return '`';
1951 : }
1952 : #line 1953 "Zend/zend_language_scanner.c"
1953 180 : yy60:
1954 : YYDEBUG(60, *YYCURSOR);
1955 180 : yych = *++YYCURSOR;
1956 180 : goto yy56;
1957 0 : yy61:
1958 : YYDEBUG(61, *YYCURSOR);
1959 0 : ++YYCURSOR;
1960 : YYDEBUG(62, *YYCURSOR);
1961 0 : yyleng = YYCURSOR - SCNG(yy_text);
1962 : #line 2437 "Zend/zend_language_scanner.l"
1963 : {
1964 : Z_LVAL_P(zendlval) = (long) '{';
1965 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
1966 : yyless(1);
1967 : return T_CURLY_OPEN;
1968 : }
1969 : #line 1970 "Zend/zend_language_scanner.c"
1970 590 : yy63:
1971 : YYDEBUG(63, *YYCURSOR);
1972 590 : yyaccept = 0;
1973 590 : YYMARKER = ++YYCURSOR;
1974 590 : YYFILL(3);
1975 590 : yych = *YYCURSOR;
1976 : YYDEBUG(64, *YYCURSOR);
1977 590 : if (yybm[0+yych] & 128) {
1978 453 : goto yy63;
1979 : }
1980 137 : if (yych == '-') goto yy68;
1981 137 : if (yych == '[') goto yy70;
1982 137 : yy65:
1983 : YYDEBUG(65, *YYCURSOR);
1984 137 : yyleng = YYCURSOR - SCNG(yy_text);
1985 : #line 2149 "Zend/zend_language_scanner.l"
1986 : {
1987 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
1988 : return 0;
1989 : }
1990 : if (!zend_check_and_normalize_identifier(zendlval)) {
1991 : return 0;
1992 : }
1993 : return T_VARIABLE;
1994 : }
1995 : #line 1996 "Zend/zend_language_scanner.c"
1996 0 : yy66:
1997 : YYDEBUG(66, *YYCURSOR);
1998 0 : ++YYCURSOR;
1999 : YYDEBUG(67, *YYCURSOR);
2000 0 : yyleng = YYCURSOR - SCNG(yy_text);
2001 : #line 1773 "Zend/zend_language_scanner.l"
2002 : {
2003 : yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
2004 : return T_DOLLAR_OPEN_CURLY_BRACES;
2005 : }
2006 : #line 2007 "Zend/zend_language_scanner.c"
2007 0 : yy68:
2008 : YYDEBUG(68, *YYCURSOR);
2009 0 : yych = *++YYCURSOR;
2010 0 : if (yych == '>') goto yy72;
2011 0 : yy69:
2012 : YYDEBUG(69, *YYCURSOR);
2013 0 : YYCURSOR = YYMARKER;
2014 0 : goto yy65;
2015 0 : yy70:
2016 : YYDEBUG(70, *YYCURSOR);
2017 0 : ++YYCURSOR;
2018 : YYDEBUG(71, *YYCURSOR);
2019 0 : yyleng = YYCURSOR - SCNG(yy_text);
2020 : #line 2136 "Zend/zend_language_scanner.l"
2021 : {
2022 : yyless(yyleng - 1);
2023 : yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
2024 :
2025 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2026 : return 0;
2027 : }
2028 : if (!zend_check_and_normalize_identifier(zendlval)) {
2029 : return 0;
2030 : }
2031 : return T_VARIABLE;
2032 : }
2033 : #line 2034 "Zend/zend_language_scanner.c"
2034 0 : yy72:
2035 : YYDEBUG(72, *YYCURSOR);
2036 0 : yych = *++YYCURSOR;
2037 0 : if (yych <= '_') {
2038 0 : if (yych <= '@') goto yy69;
2039 0 : if (yych <= 'Z') goto yy73;
2040 0 : if (yych <= '^') goto yy69;
2041 : } else {
2042 0 : if (yych <= '`') goto yy69;
2043 0 : if (yych <= 'z') goto yy73;
2044 0 : if (yych <= '~') goto yy69;
2045 : }
2046 0 : yy73:
2047 : YYDEBUG(73, *YYCURSOR);
2048 0 : ++YYCURSOR;
2049 : YYDEBUG(74, *YYCURSOR);
2050 0 : yyleng = YYCURSOR - SCNG(yy_text);
2051 : #line 2121 "Zend/zend_language_scanner.l"
2052 : {
2053 : yyless(yyleng - 3);
2054 : yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
2055 :
2056 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2057 : return 0;
2058 : }
2059 : if (!zend_check_and_normalize_identifier(zendlval)) {
2060 : return 0;
2061 : }
2062 : return T_VARIABLE;
2063 : }
2064 : #line 2065 "Zend/zend_language_scanner.c"
2065 : }
2066 : /* *********************************** */
2067 44281 : yyc_ST_DOUBLE_QUOTES:
2068 : {
2069 : static const unsigned char yybm[] = {
2070 : 0, 0, 0, 0, 0, 0, 0, 0,
2071 : 0, 0, 0, 0, 0, 0, 0, 0,
2072 : 0, 0, 0, 0, 0, 0, 0, 0,
2073 : 0, 0, 0, 0, 0, 0, 0, 0,
2074 : 0, 0, 0, 0, 0, 0, 0, 0,
2075 : 0, 0, 0, 0, 0, 0, 0, 0,
2076 : 128, 128, 128, 128, 128, 128, 128, 128,
2077 : 128, 128, 0, 0, 0, 0, 0, 0,
2078 : 0, 128, 128, 128, 128, 128, 128, 128,
2079 : 128, 128, 128, 128, 128, 128, 128, 128,
2080 : 128, 128, 128, 128, 128, 128, 128, 128,
2081 : 128, 128, 128, 0, 0, 0, 0, 128,
2082 : 0, 128, 128, 128, 128, 128, 128, 128,
2083 : 128, 128, 128, 128, 128, 128, 128, 128,
2084 : 128, 128, 128, 128, 128, 128, 128, 128,
2085 : 128, 128, 128, 0, 0, 0, 0, 128,
2086 : 128, 128, 128, 128, 128, 128, 128, 128,
2087 : 128, 128, 128, 128, 128, 128, 128, 128,
2088 : 128, 128, 128, 128, 128, 128, 128, 128,
2089 : 128, 128, 128, 128, 128, 128, 128, 128,
2090 : 128, 128, 128, 128, 128, 128, 128, 128,
2091 : 128, 128, 128, 128, 128, 128, 128, 128,
2092 : 128, 128, 128, 128, 128, 128, 128, 128,
2093 : 128, 128, 128, 128, 128, 128, 128, 128,
2094 : 128, 128, 128, 128, 128, 128, 128, 128,
2095 : 128, 128, 128, 128, 128, 128, 128, 128,
2096 : 128, 128, 128, 128, 128, 128, 128, 128,
2097 : 128, 128, 128, 128, 128, 128, 128, 128,
2098 : 128, 128, 128, 128, 128, 128, 128, 128,
2099 : 128, 128, 128, 128, 128, 128, 128, 128,
2100 : 128, 128, 128, 128, 128, 128, 128, 128,
2101 : 128, 128, 128, 128, 128, 128, 128, 128,
2102 : };
2103 : YYDEBUG(75, *YYCURSOR);
2104 44281 : YYFILL(2);
2105 44281 : yych = *YYCURSOR;
2106 44281 : if (yych <= '#') {
2107 12503 : if (yych == '"') goto yy80;
2108 2002 : goto yy82;
2109 : } else {
2110 31778 : if (yych <= '$') goto yy77;
2111 16661 : if (yych == '{') goto yy79;
2112 16427 : goto yy82;
2113 : }
2114 15117 : yy77:
2115 : YYDEBUG(77, *YYCURSOR);
2116 15117 : ++YYCURSOR;
2117 15117 : if ((yych = *YYCURSOR) <= '_') {
2118 55 : if (yych <= '@') goto yy78;
2119 54 : if (yych <= 'Z') goto yy85;
2120 0 : if (yych >= '_') goto yy85;
2121 : } else {
2122 15062 : if (yych <= 'z') {
2123 14977 : if (yych >= 'a') goto yy85;
2124 : } else {
2125 85 : if (yych <= '{') goto yy88;
2126 0 : if (yych >= 0x7F) goto yy85;
2127 : }
2128 : }
2129 18430 : yy78:
2130 : YYDEBUG(78, *YYCURSOR);
2131 18430 : yyleng = YYCURSOR - SCNG(yy_text);
2132 : #line 2456 "Zend/zend_language_scanner.l"
2133 : {
2134 : if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
2135 : YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
2136 : SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
2137 :
2138 : goto double_quotes_scan_done;
2139 : }
2140 :
2141 : if (YYCURSOR > YYLIMIT) {
2142 : return 0;
2143 : }
2144 : if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
2145 : YYCURSOR++;
2146 : }
2147 :
2148 : while (YYCURSOR < YYLIMIT) {
2149 : switch (*YYCURSOR++) {
2150 : case '"':
2151 : break;
2152 : case '$':
2153 : if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
2154 : break;
2155 : }
2156 : continue;
2157 : case '{':
2158 : if (*YYCURSOR == '$') {
2159 : break;
2160 : }
2161 : continue;
2162 : case '\\':
2163 : if (YYCURSOR < YYLIMIT) {
2164 : YYCURSOR++;
2165 : }
2166 : /* fall through */
2167 : default:
2168 : continue;
2169 : }
2170 :
2171 : YYCURSOR--;
2172 : break;
2173 : }
2174 :
2175 : double_quotes_scan_done:
2176 : yyleng = YYCURSOR - SCNG(yy_text);
2177 :
2178 : if (CG(literal_type) == IS_UNICODE) {
2179 : return zend_scan_unicode_escape_string(zendlval, yytext, yyleng, 0x22 /*'"'*/, T_ENCAPSED_AND_WHITESPACE TSRMLS_CC);
2180 : } else {
2181 : zend_scan_binary_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
2182 : return T_ENCAPSED_AND_WHITESPACE;
2183 : }
2184 : }
2185 : #line 2186 "Zend/zend_language_scanner.c"
2186 234 : yy79:
2187 : YYDEBUG(79, *YYCURSOR);
2188 234 : yych = *++YYCURSOR;
2189 234 : if (yych == '$') goto yy83;
2190 0 : goto yy78;
2191 10501 : yy80:
2192 : YYDEBUG(80, *YYCURSOR);
2193 10501 : ++YYCURSOR;
2194 : YYDEBUG(81, *YYCURSOR);
2195 10501 : yyleng = YYCURSOR - SCNG(yy_text);
2196 : #line 2445 "Zend/zend_language_scanner.l"
2197 : {
2198 : BEGIN(ST_IN_SCRIPTING);
2199 : return '"';
2200 : }
2201 : #line 2202 "Zend/zend_language_scanner.c"
2202 18429 : yy82:
2203 : YYDEBUG(82, *YYCURSOR);
2204 18429 : yych = *++YYCURSOR;
2205 18429 : goto yy78;
2206 234 : yy83:
2207 : YYDEBUG(83, *YYCURSOR);
2208 234 : ++YYCURSOR;
2209 : YYDEBUG(84, *YYCURSOR);
2210 234 : yyleng = YYCURSOR - SCNG(yy_text);
2211 : #line 2437 "Zend/zend_language_scanner.l"
2212 : {
2213 : Z_LVAL_P(zendlval) = (long) '{';
2214 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
2215 : yyless(1);
2216 : return T_CURLY_OPEN;
2217 : }
2218 : #line 2219 "Zend/zend_language_scanner.c"
2219 63099 : yy85:
2220 : YYDEBUG(85, *YYCURSOR);
2221 63099 : yyaccept = 0;
2222 63099 : YYMARKER = ++YYCURSOR;
2223 63099 : YYFILL(3);
2224 63099 : yych = *YYCURSOR;
2225 : YYDEBUG(86, *YYCURSOR);
2226 63099 : if (yybm[0+yych] & 128) {
2227 48068 : goto yy85;
2228 : }
2229 15031 : if (yych == '-') goto yy90;
2230 14716 : if (yych == '[') goto yy92;
2231 14113 : yy87:
2232 : YYDEBUG(87, *YYCURSOR);
2233 14113 : yyleng = YYCURSOR - SCNG(yy_text);
2234 : #line 2149 "Zend/zend_language_scanner.l"
2235 : {
2236 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2237 : return 0;
2238 : }
2239 : if (!zend_check_and_normalize_identifier(zendlval)) {
2240 : return 0;
2241 : }
2242 : return T_VARIABLE;
2243 : }
2244 : #line 2245 "Zend/zend_language_scanner.c"
2245 85 : yy88:
2246 : YYDEBUG(88, *YYCURSOR);
2247 85 : ++YYCURSOR;
2248 : YYDEBUG(89, *YYCURSOR);
2249 85 : yyleng = YYCURSOR - SCNG(yy_text);
2250 : #line 1773 "Zend/zend_language_scanner.l"
2251 : {
2252 : yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
2253 : return T_DOLLAR_OPEN_CURLY_BRACES;
2254 : }
2255 : #line 2256 "Zend/zend_language_scanner.c"
2256 315 : yy90:
2257 : YYDEBUG(90, *YYCURSOR);
2258 315 : yych = *++YYCURSOR;
2259 315 : if (yych == '>') goto yy94;
2260 256 : yy91:
2261 : YYDEBUG(91, *YYCURSOR);
2262 256 : YYCURSOR = YYMARKER;
2263 256 : goto yy87;
2264 859 : yy92:
2265 : YYDEBUG(92, *YYCURSOR);
2266 859 : ++YYCURSOR;
2267 : YYDEBUG(93, *YYCURSOR);
2268 859 : yyleng = YYCURSOR - SCNG(yy_text);
2269 : #line 2136 "Zend/zend_language_scanner.l"
2270 : {
2271 : yyless(yyleng - 1);
2272 : yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
2273 :
2274 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2275 : return 0;
2276 : }
2277 : if (!zend_check_and_normalize_identifier(zendlval)) {
2278 : return 0;
2279 : }
2280 : return T_VARIABLE;
2281 : }
2282 : #line 2283 "Zend/zend_language_scanner.c"
2283 59 : yy94:
2284 : YYDEBUG(94, *YYCURSOR);
2285 59 : yych = *++YYCURSOR;
2286 59 : if (yych <= '_') {
2287 0 : if (yych <= '@') goto yy91;
2288 0 : if (yych <= 'Z') goto yy95;
2289 0 : if (yych <= '^') goto yy91;
2290 : } else {
2291 59 : if (yych <= '`') goto yy91;
2292 59 : if (yych <= 'z') goto yy95;
2293 0 : if (yych <= '~') goto yy91;
2294 : }
2295 59 : yy95:
2296 : YYDEBUG(95, *YYCURSOR);
2297 59 : ++YYCURSOR;
2298 : YYDEBUG(96, *YYCURSOR);
2299 59 : yyleng = YYCURSOR - SCNG(yy_text);
2300 : #line 2121 "Zend/zend_language_scanner.l"
2301 : {
2302 : yyless(yyleng - 3);
2303 : yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
2304 :
2305 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2306 : return 0;
2307 : }
2308 : if (!zend_check_and_normalize_identifier(zendlval)) {
2309 : return 0;
2310 : }
2311 : return T_VARIABLE;
2312 : }
2313 : #line 2314 "Zend/zend_language_scanner.c"
2314 : }
2315 : /* *********************************** */
2316 1380 : yyc_ST_END_HEREDOC:
2317 : YYDEBUG(97, *YYCURSOR);
2318 1380 : YYFILL(1);
2319 1380 : yych = *YYCURSOR;
2320 : YYDEBUG(99, *YYCURSOR);
2321 1380 : ++YYCURSOR;
2322 : YYDEBUG(100, *YYCURSOR);
2323 1380 : yyleng = YYCURSOR - SCNG(yy_text);
2324 : #line 2424 "Zend/zend_language_scanner.l"
2325 : {
2326 : YYCURSOR += CG(heredoc_len) - 1;
2327 : yyleng = CG(heredoc_len);
2328 :
2329 : Z_STRVAL_P(zendlval) = CG(heredoc);
2330 : Z_STRLEN_P(zendlval) = CG(heredoc_len);
2331 : CG(heredoc) = NULL;
2332 : CG(heredoc_len) = 0;
2333 : BEGIN(ST_IN_SCRIPTING);
2334 : return T_END_HEREDOC;
2335 : }
2336 : #line 2337 "Zend/zend_language_scanner.c"
2337 : /* *********************************** */
2338 2214 : yyc_ST_HEREDOC:
2339 : {
2340 : static const unsigned char yybm[] = {
2341 : 0, 0, 0, 0, 0, 0, 0, 0,
2342 : 0, 0, 0, 0, 0, 0, 0, 0,
2343 : 0, 0, 0, 0, 0, 0, 0, 0,
2344 : 0, 0, 0, 0, 0, 0, 0, 0,
2345 : 0, 0, 0, 0, 0, 0, 0, 0,
2346 : 0, 0, 0, 0, 0, 0, 0, 0,
2347 : 128, 128, 128, 128, 128, 128, 128, 128,
2348 : 128, 128, 0, 0, 0, 0, 0, 0,
2349 : 0, 128, 128, 128, 128, 128, 128, 128,
2350 : 128, 128, 128, 128, 128, 128, 128, 128,
2351 : 128, 128, 128, 128, 128, 128, 128, 128,
2352 : 128, 128, 128, 0, 0, 0, 0, 128,
2353 : 0, 128, 128, 128, 128, 128, 128, 128,
2354 : 128, 128, 128, 128, 128, 128, 128, 128,
2355 : 128, 128, 128, 128, 128, 128, 128, 128,
2356 : 128, 128, 128, 0, 0, 0, 0, 128,
2357 : 128, 128, 128, 128, 128, 128, 128, 128,
2358 : 128, 128, 128, 128, 128, 128, 128, 128,
2359 : 128, 128, 128, 128, 128, 128, 128, 128,
2360 : 128, 128, 128, 128, 128, 128, 128, 128,
2361 : 128, 128, 128, 128, 128, 128, 128, 128,
2362 : 128, 128, 128, 128, 128, 128, 128, 128,
2363 : 128, 128, 128, 128, 128, 128, 128, 128,
2364 : 128, 128, 128, 128, 128, 128, 128, 128,
2365 : 128, 128, 128, 128, 128, 128, 128, 128,
2366 : 128, 128, 128, 128, 128, 128, 128, 128,
2367 : 128, 128, 128, 128, 128, 128, 128, 128,
2368 : 128, 128, 128, 128, 128, 128, 128, 128,
2369 : 128, 128, 128, 128, 128, 128, 128, 128,
2370 : 128, 128, 128, 128, 128, 128, 128, 128,
2371 : 128, 128, 128, 128, 128, 128, 128, 128,
2372 : 128, 128, 128, 128, 128, 128, 128, 128,
2373 : };
2374 : YYDEBUG(101, *YYCURSOR);
2375 2214 : YYFILL(2);
2376 2214 : yych = *YYCURSOR;
2377 2214 : if (yych == '$') goto yy103;
2378 1772 : if (yych == '{') goto yy105;
2379 1745 : goto yy106;
2380 442 : yy103:
2381 : YYDEBUG(103, *YYCURSOR);
2382 442 : ++YYCURSOR;
2383 442 : if ((yych = *YYCURSOR) <= '_') {
2384 2 : if (yych <= '@') goto yy104;
2385 2 : if (yych <= 'Z') goto yy109;
2386 0 : if (yych >= '_') goto yy109;
2387 : } else {
2388 440 : if (yych <= 'z') {
2389 440 : if (yych >= 'a') goto yy109;
2390 : } else {
2391 0 : if (yych <= '{') goto yy112;
2392 0 : if (yych >= 0x7F) goto yy109;
2393 : }
2394 : }
2395 1745 : yy104:
2396 : YYDEBUG(104, *YYCURSOR);
2397 1745 : yyleng = YYCURSOR - SCNG(yy_text);
2398 : #line 2556 "Zend/zend_language_scanner.l"
2399 : {
2400 : int newline = 0;
2401 :
2402 : if (YYCURSOR > YYLIMIT) {
2403 : return 0;
2404 : }
2405 :
2406 : YYCURSOR--;
2407 :
2408 : while (YYCURSOR < YYLIMIT) {
2409 : switch (*YYCURSOR++) {
2410 : case '\r':
2411 : if (*YYCURSOR == '\n') {
2412 : YYCURSOR++;
2413 : }
2414 : /* fall through */
2415 : case '\n':
2416 : /* Check for ending label on the next line */
2417 : if (IS_LABEL_START(*YYCURSOR) && CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, CG(heredoc), CG(heredoc_len))) {
2418 : YYCTYPE *end = YYCURSOR + CG(heredoc_len);
2419 :
2420 : if (*end == ';') {
2421 : end++;
2422 : }
2423 :
2424 : if (*end == '\n' || *end == '\r') {
2425 : /* newline before label will be subtracted from returned text, but
2426 : * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
2427 : if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
2428 : newline = 2; /* Windows newline */
2429 : } else {
2430 : newline = 1;
2431 : }
2432 :
2433 : CG(increment_lineno) = 1; /* For newline before label */
2434 : BEGIN(ST_END_HEREDOC);
2435 :
2436 : goto heredoc_scan_done;
2437 : }
2438 : }
2439 : continue;
2440 : case '$':
2441 : if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
2442 : break;
2443 : }
2444 : continue;
2445 : case '{':
2446 : if (*YYCURSOR == '$') {
2447 : break;
2448 : }
2449 : continue;
2450 : case '\\':
2451 : if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
2452 : YYCURSOR++;
2453 : }
2454 : /* fall through */
2455 : default:
2456 : continue;
2457 : }
2458 :
2459 : YYCURSOR--;
2460 : break;
2461 : }
2462 :
2463 : heredoc_scan_done:
2464 : yyleng = YYCURSOR - SCNG(yy_text);
2465 :
2466 : if (CG(literal_type) == IS_UNICODE) {
2467 : return zend_scan_unicode_escape_string(zendlval, yytext, yyleng - newline, 0, T_ENCAPSED_AND_WHITESPACE TSRMLS_CC);
2468 : } else {
2469 : zend_scan_binary_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
2470 : return T_ENCAPSED_AND_WHITESPACE;
2471 : }
2472 : }
2473 : #line 2474 "Zend/zend_language_scanner.c"
2474 27 : yy105:
2475 : YYDEBUG(105, *YYCURSOR);
2476 27 : yych = *++YYCURSOR;
2477 27 : if (yych == '$') goto yy107;
2478 0 : goto yy104;
2479 1745 : yy106:
2480 : YYDEBUG(106, *YYCURSOR);
2481 1745 : yych = *++YYCURSOR;
2482 1745 : goto yy104;
2483 27 : yy107:
2484 : YYDEBUG(107, *YYCURSOR);
2485 27 : ++YYCURSOR;
2486 : YYDEBUG(108, *YYCURSOR);
2487 27 : yyleng = YYCURSOR - SCNG(yy_text);
2488 : #line 2437 "Zend/zend_language_scanner.l"
2489 : {
2490 : Z_LVAL_P(zendlval) = (long) '{';
2491 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
2492 : yyless(1);
2493 : return T_CURLY_OPEN;
2494 : }
2495 : #line 2496 "Zend/zend_language_scanner.c"
2496 3293 : yy109:
2497 : YYDEBUG(109, *YYCURSOR);
2498 3293 : yyaccept = 0;
2499 3293 : YYMARKER = ++YYCURSOR;
2500 3293 : YYFILL(3);
2501 3293 : yych = *YYCURSOR;
2502 : YYDEBUG(110, *YYCURSOR);
2503 3293 : if (yybm[0+yych] & 128) {
2504 2851 : goto yy109;
2505 : }
2506 442 : if (yych == '-') goto yy114;
2507 442 : if (yych == '[') goto yy116;
2508 441 : yy111:
2509 : YYDEBUG(111, *YYCURSOR);
2510 441 : yyleng = YYCURSOR - SCNG(yy_text);
2511 : #line 2149 "Zend/zend_language_scanner.l"
2512 : {
2513 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2514 : return 0;
2515 : }
2516 : if (!zend_check_and_normalize_identifier(zendlval)) {
2517 : return 0;
2518 : }
2519 : return T_VARIABLE;
2520 : }
2521 : #line 2522 "Zend/zend_language_scanner.c"
2522 0 : yy112:
2523 : YYDEBUG(112, *YYCURSOR);
2524 0 : ++YYCURSOR;
2525 : YYDEBUG(113, *YYCURSOR);
2526 0 : yyleng = YYCURSOR - SCNG(yy_text);
2527 : #line 1773 "Zend/zend_language_scanner.l"
2528 : {
2529 : yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
2530 : return T_DOLLAR_OPEN_CURLY_BRACES;
2531 : }
2532 : #line 2533 "Zend/zend_language_scanner.c"
2533 0 : yy114:
2534 : YYDEBUG(114, *YYCURSOR);
2535 0 : yych = *++YYCURSOR;
2536 0 : if (yych == '>') goto yy118;
2537 0 : yy115:
2538 : YYDEBUG(115, *YYCURSOR);
2539 0 : YYCURSOR = YYMARKER;
2540 0 : goto yy111;
2541 1 : yy116:
2542 : YYDEBUG(116, *YYCURSOR);
2543 1 : ++YYCURSOR;
2544 : YYDEBUG(117, *YYCURSOR);
2545 1 : yyleng = YYCURSOR - SCNG(yy_text);
2546 : #line 2136 "Zend/zend_language_scanner.l"
2547 : {
2548 : yyless(yyleng - 1);
2549 : yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
2550 :
2551 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2552 : return 0;
2553 : }
2554 : if (!zend_check_and_normalize_identifier(zendlval)) {
2555 : return 0;
2556 : }
2557 : return T_VARIABLE;
2558 : }
2559 : #line 2560 "Zend/zend_language_scanner.c"
2560 0 : yy118:
2561 : YYDEBUG(118, *YYCURSOR);
2562 0 : yych = *++YYCURSOR;
2563 0 : if (yych <= '_') {
2564 0 : if (yych <= '@') goto yy115;
2565 0 : if (yych <= 'Z') goto yy119;
2566 0 : if (yych <= '^') goto yy115;
2567 : } else {
2568 0 : if (yych <= '`') goto yy115;
2569 0 : if (yych <= 'z') goto yy119;
2570 0 : if (yych <= '~') goto yy115;
2571 : }
2572 0 : yy119:
2573 : YYDEBUG(119, *YYCURSOR);
2574 0 : ++YYCURSOR;
2575 : YYDEBUG(120, *YYCURSOR);
2576 0 : yyleng = YYCURSOR - SCNG(yy_text);
2577 : #line 2121 "Zend/zend_language_scanner.l"
2578 : {
2579 : yyless(yyleng - 3);
2580 : yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
2581 :
2582 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2583 : return 0;
2584 : }
2585 : if (!zend_check_and_normalize_identifier(zendlval)) {
2586 : return 0;
2587 : }
2588 : return T_VARIABLE;
2589 : }
2590 : #line 2591 "Zend/zend_language_scanner.c"
2591 : }
2592 : /* *********************************** */
2593 5387722 : yyc_ST_IN_SCRIPTING:
2594 : {
2595 : static const unsigned char yybm[] = {
2596 : 0, 0, 0, 0, 0, 0, 0, 0,
2597 : 0, 192, 64, 0, 0, 64, 0, 0,
2598 : 0, 0, 0, 0, 0, 0, 0, 0,
2599 : 0, 0, 0, 0, 0, 0, 0, 0,
2600 : 192, 0, 0, 0, 0, 0, 0, 0,
2601 : 0, 0, 0, 0, 0, 0, 0, 0,
2602 : 56, 56, 56, 56, 56, 56, 56, 56,
2603 : 56, 56, 0, 0, 0, 0, 0, 0,
2604 : 0, 40, 40, 40, 40, 40, 40, 8,
2605 : 8, 8, 8, 8, 8, 8, 8, 8,
2606 : 8, 8, 8, 8, 8, 8, 8, 8,
2607 : 8, 8, 8, 0, 0, 0, 0, 8,
2608 : 0, 40, 40, 40, 40, 40, 40, 8,
2609 : 8, 8, 8, 8, 8, 8, 8, 8,
2610 : 8, 8, 8, 8, 8, 8, 8, 8,
2611 : 8, 8, 8, 0, 0, 0, 0, 8,
2612 : 8, 8, 8, 8, 8, 8, 8, 8,
2613 : 8, 8, 8, 8, 8, 8, 8, 8,
2614 : 8, 8, 8, 8, 8, 8, 8, 8,
2615 : 8, 8, 8, 8, 8, 8, 8, 8,
2616 : 8, 8, 8, 8, 8, 8, 8, 8,
2617 : 8, 8, 8, 8, 8, 8, 8, 8,
2618 : 8, 8, 8, 8, 8, 8, 8, 8,
2619 : 8, 8, 8, 8, 8, 8, 8, 8,
2620 : 8, 8, 8, 8, 8, 8, 8, 8,
2621 : 8, 8, 8, 8, 8, 8, 8, 8,
2622 : 8, 8, 8, 8, 8, 8, 8, 8,
2623 : 8, 8, 8, 8, 8, 8, 8, 8,
2624 : 8, 8, 8, 8, 8, 8, 8, 8,
2625 : 8, 8, 8, 8, 8, 8, 8, 8,
2626 : 8, 8, 8, 8, 8, 8, 8, 8,
2627 : 8, 8, 8, 8, 8, 8, 8, 8,
2628 : };
2629 : YYDEBUG(121, *YYCURSOR);
2630 5387722 : YYFILL(16);
2631 5387722 : yych = *YYCURSOR;
2632 : YYDEBUG(-1, yych);
2633 5387722 : switch (yych) {
2634 : case 0x00:
2635 : case 0x01:
2636 : case 0x02:
2637 : case 0x03:
2638 : case 0x04:
2639 : case 0x05:
2640 : case 0x06:
2641 : case 0x07:
2642 : case 0x08:
2643 : case '\v':
2644 : case '\f':
2645 : case 0x0E:
2646 : case 0x0F:
2647 : case 0x10:
2648 : case 0x11:
2649 : case 0x12:
2650 : case 0x13:
2651 : case 0x14:
2652 : case 0x15:
2653 : case 0x16:
2654 : case 0x17:
2655 : case 0x18:
2656 : case 0x19:
2657 : case 0x1A:
2658 : case 0x1B:
2659 : case 0x1C:
2660 : case 0x1D:
2661 : case 0x1E:
2662 1445 : case 0x1F: goto yy183;
2663 : case '\t':
2664 : case '\n':
2665 : case '\r':
2666 1600074 : case ' ': goto yy139;
2667 31579 : case '!': goto yy152;
2668 158809 : case '"': goto yy179;
2669 1642 : case '#': goto yy175;
2670 538447 : case '$': goto yy164;
2671 118 : case '%': goto yy158;
2672 5778 : case '&': goto yy159;
2673 185672 : case '\'': goto yy177;
2674 417824 : case '(': goto yy146;
2675 : case ')':
2676 : case ',':
2677 : case ';':
2678 : case '@':
2679 : case '[':
2680 : case ']':
2681 1157513 : case '~': goto yy165;
2682 2364 : case '*': goto yy155;
2683 9581 : case '+': goto yy151;
2684 38119 : case '-': goto yy137;
2685 32190 : case '.': goto yy157;
2686 59028 : case '/': goto yy156;
2687 23472 : case '0': goto yy171;
2688 : case '1':
2689 : case '2':
2690 : case '3':
2691 : case '4':
2692 : case '5':
2693 : case '6':
2694 : case '7':
2695 : case '8':
2696 63294 : case '9': goto yy173;
2697 33576 : case ':': goto yy141;
2698 4400 : case '<': goto yy153;
2699 171566 : case '=': goto yy149;
2700 1060 : case '>': goto yy154;
2701 40824 : case '?': goto yy166;
2702 : case 'A':
2703 37332 : case 'a': goto yy132;
2704 : case 'B':
2705 6858 : case 'b': goto yy134;
2706 : case 'C':
2707 20806 : case 'c': goto yy127;
2708 : case 'D':
2709 28045 : case 'd': goto yy125;
2710 : case 'E':
2711 66189 : case 'e': goto yy123;
2712 : case 'F':
2713 85182 : case 'f': goto yy126;
2714 : case 'G':
2715 44554 : case 'g': goto yy135;
2716 : case 'I':
2717 69925 : case 'i': goto yy130;
2718 : case 'L':
2719 4320 : case 'l': goto yy150;
2720 : case 'N':
2721 23469 : case 'n': goto yy144;
2722 : case 'O':
2723 7745 : case 'o': goto yy162;
2724 : case 'P':
2725 42587 : case 'p': goto yy136;
2726 : case 'R':
2727 45210 : case 'r': goto yy128;
2728 : case 'S':
2729 36930 : case 's': goto yy133;
2730 : case 'T':
2731 24863 : case 't': goto yy129;
2732 : case 'U':
2733 7976 : case 'u': goto yy147;
2734 : case 'V':
2735 28626 : case 'v': goto yy145;
2736 : case 'W':
2737 1367 : case 'w': goto yy131;
2738 : case 'X':
2739 826 : case 'x': goto yy163;
2740 466 : case '\\': goto yy142;
2741 21 : case '^': goto yy161;
2742 12459 : case '_': goto yy148;
2743 105 : case '`': goto yy181;
2744 88992 : case '{': goto yy167;
2745 2545 : case '|': goto yy160;
2746 89253 : case '}': goto yy169;
2747 32696 : default: goto yy174;
2748 : }
2749 66189 : yy123:
2750 : YYDEBUG(123, *YYCURSOR);
2751 66189 : ++YYCURSOR;
2752 : YYDEBUG(-1, yych);
2753 66189 : switch ((yych = *YYCURSOR)) {
2754 : case 'C':
2755 29047 : case 'c': goto yy709;
2756 : case 'L':
2757 16185 : case 'l': goto yy710;
2758 : case 'M':
2759 5481 : case 'm': goto yy711;
2760 : case 'N':
2761 346 : case 'n': goto yy712;
2762 : case 'V':
2763 1704 : case 'v': goto yy713;
2764 : case 'X':
2765 11282 : case 'x': goto yy714;
2766 2144 : default: goto yy186;
2767 : }
2768 352199 : yy124:
2769 : YYDEBUG(124, *YYCURSOR);
2770 352199 : yyleng = YYCURSOR - SCNG(yy_text);
2771 : #line 2176 "Zend/zend_language_scanner.l"
2772 : {
2773 : if (!zend_copy_scanner_string(zendlval, yytext, yyleng, IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
2774 : return 0;
2775 : }
2776 : if (!zend_check_and_normalize_identifier(zendlval)) {
2777 : return 0;
2778 : }
2779 : return T_STRING;
2780 : }
2781 : #line 2782 "Zend/zend_language_scanner.c"
2782 28045 : yy125:
2783 : YYDEBUG(125, *YYCURSOR);
2784 28045 : yych = *++YYCURSOR;
2785 28045 : if (yych <= 'O') {
2786 1049 : if (yych <= 'H') {
2787 318 : if (yych == 'E') goto yy691;
2788 302 : goto yy186;
2789 : } else {
2790 731 : if (yych <= 'I') goto yy692;
2791 190 : if (yych <= 'N') goto yy186;
2792 190 : goto yy693;
2793 : }
2794 : } else {
2795 26996 : if (yych <= 'h') {
2796 7167 : if (yych == 'e') goto yy691;
2797 2042 : goto yy186;
2798 : } else {
2799 19829 : if (yych <= 'i') goto yy692;
2800 1314 : if (yych == 'o') goto yy693;
2801 778 : goto yy186;
2802 : }
2803 : }
2804 85182 : yy126:
2805 : YYDEBUG(126, *YYCURSOR);
2806 85182 : yych = *++YYCURSOR;
2807 85182 : if (yych <= 'U') {
2808 5834 : if (yych <= 'N') {
2809 5756 : if (yych == 'I') goto yy670;
2810 5249 : goto yy186;
2811 : } else {
2812 78 : if (yych <= 'O') goto yy671;
2813 40 : if (yych <= 'T') goto yy186;
2814 4 : goto yy672;
2815 : }
2816 : } else {
2817 79348 : if (yych <= 'n') {
2818 32545 : if (yych == 'i') goto yy670;
2819 27323 : goto yy186;
2820 : } else {
2821 46803 : if (yych <= 'o') goto yy671;
2822 32431 : if (yych == 'u') goto yy672;
2823 4734 : goto yy186;
2824 : }
2825 : }
2826 20806 : yy127:
2827 : YYDEBUG(127, *YYCURSOR);
2828 20806 : yych = *++YYCURSOR;
2829 20806 : if (yych <= 'O') {
2830 1841 : if (yych <= 'K') {
2831 1750 : if (yych == 'A') goto yy642;
2832 657 : goto yy186;
2833 : } else {
2834 91 : if (yych <= 'L') goto yy643;
2835 55 : if (yych <= 'N') goto yy186;
2836 54 : goto yy644;
2837 : }
2838 : } else {
2839 18965 : if (yych <= 'k') {
2840 5946 : if (yych == 'a') goto yy642;
2841 2357 : goto yy186;
2842 : } else {
2843 13019 : if (yych <= 'l') goto yy643;
2844 4858 : if (yych == 'o') goto yy644;
2845 2141 : goto yy186;
2846 : }
2847 : }
2848 45210 : yy128:
2849 : YYDEBUG(128, *YYCURSOR);
2850 45210 : yych = *++YYCURSOR;
2851 45210 : if (yych == 'E') goto yy624;
2852 45209 : if (yych == 'e') goto yy624;
2853 2442 : goto yy186;
2854 24863 : yy129:
2855 : YYDEBUG(129, *YYCURSOR);
2856 24863 : yych = *++YYCURSOR;
2857 24863 : if (yych <= 'R') {
2858 3939 : if (yych == 'H') goto yy616;
2859 3935 : if (yych <= 'Q') goto yy186;
2860 3777 : goto yy617;
2861 : } else {
2862 20924 : if (yych <= 'h') {
2863 6739 : if (yych <= 'g') goto yy186;
2864 266 : goto yy616;
2865 : } else {
2866 14185 : if (yych == 'r') goto yy617;
2867 636 : goto yy186;
2868 : }
2869 : }
2870 69925 : yy130:
2871 : YYDEBUG(130, *YYCURSOR);
2872 69925 : yych = *++YYCURSOR;
2873 69925 : if (yych <= 'S') {
2874 407 : if (yych <= 'L') {
2875 199 : if (yych == 'F') goto yy569;
2876 192 : goto yy186;
2877 : } else {
2878 208 : if (yych <= 'M') goto yy571;
2879 124 : if (yych <= 'N') goto yy572;
2880 28 : if (yych <= 'R') goto yy186;
2881 28 : goto yy573;
2882 : }
2883 : } else {
2884 69518 : if (yych <= 'm') {
2885 57026 : if (yych == 'f') goto yy569;
2886 2770 : if (yych <= 'l') goto yy186;
2887 2575 : goto yy571;
2888 : } else {
2889 12492 : if (yych <= 'n') goto yy572;
2890 6871 : if (yych == 's') goto yy573;
2891 179 : goto yy186;
2892 : }
2893 : }
2894 1367 : yy131:
2895 : YYDEBUG(131, *YYCURSOR);
2896 1367 : yych = *++YYCURSOR;
2897 1367 : if (yych == 'H') goto yy564;
2898 1367 : if (yych == 'h') goto yy564;
2899 337 : goto yy186;
2900 37332 : yy132:
2901 : YYDEBUG(132, *YYCURSOR);
2902 37332 : yych = *++YYCURSOR;
2903 37332 : if (yych <= 'S') {
2904 842 : if (yych <= 'M') {
2905 763 : if (yych == 'B') goto yy546;
2906 751 : goto yy186;
2907 : } else {
2908 79 : if (yych <= 'N') goto yy547;
2909 79 : if (yych <= 'Q') goto yy186;
2910 67 : if (yych <= 'R') goto yy548;
2911 52 : goto yy549;
2912 : }
2913 : } else {
2914 36490 : if (yych <= 'n') {
2915 4163 : if (yych == 'b') goto yy546;
2916 4001 : if (yych <= 'm') goto yy186;
2917 82 : goto yy547;
2918 : } else {
2919 32327 : if (yych <= 'q') goto yy186;
2920 32309 : if (yych <= 'r') goto yy548;
2921 9245 : if (yych <= 's') goto yy549;
2922 86 : goto yy186;
2923 : }
2924 : }
2925 36930 : yy133:
2926 : YYDEBUG(133, *YYCURSOR);
2927 36930 : yych = *++YYCURSOR;
2928 36930 : if (yych <= 'W') {
2929 1614 : if (yych == 'T') goto yy534;
2930 1402 : if (yych <= 'V') goto yy186;
2931 0 : goto yy535;
2932 : } else {
2933 35316 : if (yych <= 't') {
2934 30731 : if (yych <= 's') goto yy186;
2935 19920 : goto yy534;
2936 : } else {
2937 4585 : if (yych == 'w') goto yy535;
2938 4145 : goto yy186;
2939 : }
2940 : }
2941 6858 : yy134:
2942 : YYDEBUG(134, *YYCURSOR);
2943 6858 : yyaccept = 0;
2944 6858 : yych = *(YYMARKER = ++YYCURSOR);
2945 6858 : if (yych <= ';') {
2946 2459 : if (yych <= '"') {
2947 1332 : if (yych <= '!') goto yy186;
2948 1134 : goto yy526;
2949 : } else {
2950 1127 : if (yych == '\'') goto yy527;
2951 191 : goto yy186;
2952 : }
2953 : } else {
2954 4399 : if (yych <= 'R') {
2955 127 : if (yych <= '<') goto yy525;
2956 24 : if (yych <= 'Q') goto yy186;
2957 0 : goto yy528;
2958 : } else {
2959 4272 : if (yych == 'r') goto yy528;
2960 2640 : goto yy186;
2961 : }
2962 : }
2963 44554 : yy135:
2964 : YYDEBUG(135, *YYCURSOR);
2965 44554 : yych = *++YYCURSOR;
2966 44554 : if (yych <= 'O') {
2967 66 : if (yych == 'L') goto yy515;
2968 57 : if (yych <= 'N') goto yy186;
2969 0 : goto yy516;
2970 : } else {
2971 44488 : if (yych <= 'l') {
2972 42803 : if (yych <= 'k') goto yy186;
2973 3753 : goto yy515;
2974 : } else {
2975 1685 : if (yych == 'o') goto yy516;
2976 1644 : goto yy186;
2977 : }
2978 : }
2979 42587 : yy136:
2980 : YYDEBUG(136, *YYCURSOR);
2981 42587 : yych = *++YYCURSOR;
2982 42587 : if (yych <= 'U') {
2983 14642 : if (yych == 'R') goto yy491;
2984 14560 : if (yych <= 'T') goto yy186;
2985 0 : goto yy492;
2986 : } else {
2987 27945 : if (yych <= 'r') {
2988 22202 : if (yych <= 'q') goto yy186;
2989 16017 : goto yy491;
2990 : } else {
2991 5743 : if (yych == 'u') goto yy492;
2992 48 : goto yy186;
2993 : }
2994 : }
2995 38119 : yy137:
2996 : YYDEBUG(137, *YYCURSOR);
2997 38119 : ++YYCURSOR;
2998 38119 : if ((yych = *YYCURSOR) <= '<') {
2999 6597 : if (yych == '-') goto yy487;
3000 : } else {
3001 31522 : if (yych <= '=') goto yy485;
3002 31383 : if (yych <= '>') goto yy489;
3003 : }
3004 1802233 : yy138:
3005 : YYDEBUG(138, *YYCURSOR);
3006 1802233 : yyleng = YYCURSOR - SCNG(yy_text);
3007 : #line 1762 "Zend/zend_language_scanner.l"
3008 : {
3009 : return yytext[0];
3010 : }
3011 : #line 3012 "Zend/zend_language_scanner.c"
3012 1600074 : yy139:
3013 : YYDEBUG(139, *YYCURSOR);
3014 1600074 : ++YYCURSOR;
3015 1600074 : yych = *YYCURSOR;
3016 1600074 : goto yy484;
3017 1600074 : yy140:
3018 : YYDEBUG(140, *YYCURSOR);
3019 1600074 : yyleng = YYCURSOR - SCNG(yy_text);
3020 : #line 1489 "Zend/zend_language_scanner.l"
3021 : {
3022 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
3023 : Z_STRLEN_P(zendlval) = yyleng;
3024 : Z_TYPE_P(zendlval) = IS_STRING;
3025 : HANDLE_NEWLINES(yytext, yyleng);
3026 : return T_WHITESPACE;
3027 : }
3028 : #line 3029 "Zend/zend_language_scanner.c"
3029 33576 : yy141:
3030 : YYDEBUG(141, *YYCURSOR);
3031 33576 : yych = *++YYCURSOR;
3032 33576 : if (yych == ':') goto yy481;
3033 18829 : goto yy138;
3034 466 : yy142:
3035 : YYDEBUG(142, *YYCURSOR);
3036 466 : ++YYCURSOR;
3037 : YYDEBUG(143, *YYCURSOR);
3038 466 : yyleng = YYCURSOR - SCNG(yy_text);
3039 : #line 1522 "Zend/zend_language_scanner.l"
3040 : {
3041 : return T_NS_SEPARATOR;
3042 : }
3043 : #line 3044 "Zend/zend_language_scanner.c"
3044 23469 : yy144:
3045 : YYDEBUG(144, *YYCURSOR);
3046 23469 : yych = *++YYCURSOR;
3047 23469 : if (yych <= 'E') {
3048 23 : if (yych == 'A') goto yy469;
3049 0 : if (yych <= 'D') goto yy186;
3050 0 : goto yy470;
3051 : } else {
3052 23446 : if (yych <= 'a') {
3053 7773 : if (yych <= '`') goto yy186;
3054 223 : goto yy469;
3055 : } else {
3056 15673 : if (yych == 'e') goto yy470;
3057 5537 : goto yy186;
3058 : }
3059 : }
3060 28626 : yy145:
3061 : YYDEBUG(145, *YYCURSOR);
3062 28626 : yych = *++YYCURSOR;
3063 28626 : if (yych == 'A') goto yy466;
3064 28613 : if (yych == 'a') goto yy466;
3065 577 : goto yy186;
3066 417824 : yy146:
3067 : YYDEBUG(146, *YYCURSOR);
3068 417824 : yyaccept = 1;
3069 417824 : yych = *(YYMARKER = ++YYCURSOR);
3070 417824 : if (yych <= 'S') {
3071 356823 : if (yych <= 'D') {
3072 347001 : if (yych <= ' ') {
3073 23068 : if (yych == '\t') goto yy379;
3074 23064 : if (yych <= 0x1F) goto yy138;
3075 18477 : goto yy379;
3076 : } else {
3077 323933 : if (yych <= '@') goto yy138;
3078 826 : if (yych == 'C') goto yy138;
3079 760 : goto yy379;
3080 : }
3081 : } else {
3082 9822 : if (yych <= 'I') {
3083 1132 : if (yych == 'F') goto yy379;
3084 953 : if (yych <= 'H') goto yy138;
3085 112 : goto yy379;
3086 : } else {
3087 8690 : if (yych == 'O') goto yy379;
3088 8668 : if (yych <= 'Q') goto yy138;
3089 208 : goto yy379;
3090 : }
3091 : }
3092 : } else {
3093 61001 : if (yych <= 'f') {
3094 27175 : if (yych <= 'b') {
3095 12707 : if (yych == 'U') goto yy379;
3096 12695 : if (yych <= '`') goto yy138;
3097 4885 : goto yy379;
3098 : } else {
3099 14468 : if (yych == 'd') goto yy379;
3100 8706 : if (yych <= 'e') goto yy138;
3101 6589 : goto yy379;
3102 : }
3103 : } else {
3104 33826 : if (yych <= 'o') {
3105 20095 : if (yych == 'i') goto yy379;
3106 10034 : if (yych <= 'n') goto yy138;
3107 947 : goto yy379;
3108 : } else {
3109 13731 : if (yych <= 's') {
3110 10105 : if (yych <= 'q') goto yy138;
3111 6269 : goto yy379;
3112 : } else {
3113 3626 : if (yych == 'u') goto yy379;
3114 2005 : goto yy138;
3115 : }
3116 : }
3117 : }
3118 : }
3119 7976 : yy147:
3120 : YYDEBUG(147, *YYCURSOR);
3121 7976 : yych = *++YYCURSOR;
3122 7976 : if (yych <= 'S') {
3123 14 : if (yych == 'N') goto yy370;
3124 13 : if (yych <= 'R') goto yy186;
3125 13 : goto yy371;
3126 : } else {
3127 7962 : if (yych <= 'n') {
3128 7671 : if (yych <= 'm') goto yy186;
3129 7576 : goto yy370;
3130 : } else {
3131 291 : if (yych == 's') goto yy371;
3132 58 : goto yy186;
3133 : }
3134 : }
3135 12459 : yy148:
3136 : YYDEBUG(148, *YYCURSOR);
3137 12459 : yych = *++YYCURSOR;
3138 12459 : if (yych == '_') goto yy296;
3139 129 : goto yy186;
3140 171566 : yy149:
3141 : YYDEBUG(149, *YYCURSOR);
3142 171566 : yych = *++YYCURSOR;
3143 171566 : if (yych <= '<') goto yy138;
3144 44335 : if (yych <= '=') goto yy290;
3145 27867 : if (yych <= '>') goto yy292;
3146 389 : goto yy138;
3147 4320 : yy150:
3148 : YYDEBUG(150, *YYCURSOR);
3149 4320 : yych = *++YYCURSOR;
3150 4320 : if (yych == 'I') goto yy286;
3151 4307 : if (yych == 'i') goto yy286;
3152 3943 : goto yy186;
3153 9581 : yy151:
3154 : YYDEBUG(151, *YYCURSOR);
3155 9581 : yych = *++YYCURSOR;
3156 9581 : if (yych == '+') goto yy284;
3157 4021 : if (yych == '=') goto yy282;
3158 3398 : goto yy138;
3159 31579 : yy152:
3160 : YYDEBUG(152, *YYCURSOR);
3161 31579 : yych = *++YYCURSOR;
3162 31579 : if (yych == '=') goto yy279;
3163 22694 : goto yy138;
3164 4400 : yy153:
3165 : YYDEBUG(153, *YYCURSOR);
3166 4400 : yyaccept = 1;
3167 4400 : yych = *(YYMARKER = ++YYCURSOR);
3168 4400 : if (yych <= ';') {
3169 1372 : if (yych == '/') goto yy251;
3170 1369 : goto yy138;
3171 : } else {
3172 3028 : if (yych <= '<') goto yy249;
3173 1641 : if (yych <= '=') goto yy252;
3174 32 : if (yych <= '>') goto yy254;
3175 29 : goto yy138;
3176 : }
3177 1060 : yy154:
3178 : YYDEBUG(154, *YYCURSOR);
3179 1060 : yych = *++YYCURSOR;
3180 1060 : if (yych <= '<') goto yy138;
3181 301 : if (yych <= '=') goto yy245;
3182 43 : if (yych <= '>') goto yy243;
3183 4 : goto yy138;
3184 2364 : yy155:
3185 : YYDEBUG(155, *YYCURSOR);
3186 2364 : yych = *++YYCURSOR;
3187 2364 : if (yych == '=') goto yy241;
3188 2351 : goto yy138;
3189 59028 : yy156:
3190 : YYDEBUG(156, *YYCURSOR);
3191 59028 : yych = *++YYCURSOR;
3192 59028 : if (yych <= '.') {
3193 21824 : if (yych == '*') goto yy233;
3194 476 : goto yy138;
3195 : } else {
3196 37204 : if (yych <= '/') goto yy235;
3197 21 : if (yych == '=') goto yy236;
3198 17 : goto yy138;
3199 : }
3200 32190 : yy157:
3201 : YYDEBUG(157, *YYCURSOR);
3202 32190 : yych = *++YYCURSOR;
3203 32190 : if (yych <= '/') goto yy138;
3204 4405 : if (yych <= '9') goto yy229;
3205 3507 : if (yych == '=') goto yy231;
3206 1573 : goto yy138;
3207 118 : yy158:
3208 : YYDEBUG(158, *YYCURSOR);
3209 118 : yych = *++YYCURSOR;
3210 118 : if (yych <= '<') goto yy138;
3211 3 : if (yych <= '=') goto yy225;
3212 2 : if (yych <= '>') goto yy223;
3213 0 : goto yy138;
3214 5778 : yy159:
3215 : YYDEBUG(159, *YYCURSOR);
3216 5778 : yych = *++YYCURSOR;
3217 5778 : if (yych == '&') goto yy219;
3218 2115 : if (yych == '=') goto yy221;
3219 2112 : goto yy138;
3220 2545 : yy160:
3221 : YYDEBUG(160, *YYCURSOR);
3222 2545 : yych = *++YYCURSOR;
3223 2545 : if (yych == '=') goto yy217;
3224 2449 : if (yych == '|') goto yy215;
3225 487 : goto yy138;
3226 21 : yy161:
3227 : YYDEBUG(161, *YYCURSOR);
3228 21 : yych = *++YYCURSOR;
3229 21 : if (yych == '=') goto yy213;
3230 19 : goto yy138;
3231 7745 : yy162:
3232 : YYDEBUG(162, *YYCURSOR);
3233 7745 : yych = *++YYCURSOR;
3234 7745 : if (yych == 'R') goto yy211;
3235 7745 : if (yych == 'r') goto yy211;
3236 7070 : goto yy186;
3237 826 : yy163:
3238 : YYDEBUG(163, *YYCURSOR);
3239 826 : yych = *++YYCURSOR;
3240 826 : if (yych == 'O') goto yy208;
3241 826 : if (yych == 'o') goto yy208;
3242 825 : goto yy186;
3243 538447 : yy164:
3244 : YYDEBUG(164, *YYCURSOR);
3245 538447 : yych = *++YYCURSOR;
3246 538447 : if (yych <= '_') {
3247 18321 : if (yych <= '@') goto yy138;
3248 18171 : if (yych <= 'Z') goto yy205;
3249 9960 : if (yych <= '^') goto yy138;
3250 9960 : goto yy205;
3251 : } else {
3252 520126 : if (yych <= '`') goto yy138;
3253 520126 : if (yych <= 'z') goto yy205;
3254 33 : if (yych <= '~') goto yy138;
3255 3 : goto yy205;
3256 : }
3257 1157513 : yy165:
3258 : YYDEBUG(165, *YYCURSOR);
3259 1157513 : yych = *++YYCURSOR;
3260 1157513 : goto yy138;
3261 40824 : yy166:
3262 : YYDEBUG(166, *YYCURSOR);
3263 40824 : yych = *++YYCURSOR;
3264 40824 : if (yych == '>') goto yy201;
3265 17068 : goto yy138;
3266 88992 : yy167:
3267 : YYDEBUG(167, *YYCURSOR);
3268 88992 : ++YYCURSOR;
3269 : YYDEBUG(168, *YYCURSOR);
3270 88992 : yyleng = YYCURSOR - SCNG(yy_text);
3271 : #line 1767 "Zend/zend_language_scanner.l"
3272 : {
3273 : yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
3274 : return '{';
3275 : }
3276 : #line 3277 "Zend/zend_language_scanner.c"
3277 89253 : yy169:
3278 : YYDEBUG(169, *YYCURSOR);
3279 89253 : ++YYCURSOR;
3280 : YYDEBUG(170, *YYCURSOR);
3281 89253 : yyleng = YYCURSOR - SCNG(yy_text);
3282 : #line 1779 "Zend/zend_language_scanner.l"
3283 : {
3284 : RESET_DOC_COMMENT();
3285 : if (!zend_stack_is_empty(&SCNG(state_stack))) {
3286 : yy_pop_state(TSRMLS_C);
3287 : }
3288 : return '}';
3289 : }
3290 : #line 3291 "Zend/zend_language_scanner.c"
3291 23472 : yy171:
3292 : YYDEBUG(171, *YYCURSOR);
3293 23472 : yyaccept = 2;
3294 23472 : yych = *(YYMARKER = ++YYCURSOR);
3295 23472 : if (yych <= 'E') {
3296 17567 : if (yych <= '/') {
3297 12634 : if (yych == '.') goto yy187;
3298 : } else {
3299 4933 : if (yych <= '9') goto yy190;
3300 3365 : if (yych >= 'E') goto yy192;
3301 : }
3302 : } else {
3303 5905 : if (yych <= 'd') {
3304 4603 : if (yych == 'X') goto yy197;
3305 : } else {
3306 1302 : if (yych <= 'e') goto yy192;
3307 1298 : if (yych == 'x') goto yy197;
3308 : }
3309 : }
3310 79493 : yy172:
3311 : YYDEBUG(172, *YYCURSOR);
3312 79493 : yyleng = YYCURSOR - SCNG(yy_text);
3313 : #line 1809 "Zend/zend_language_scanner.l"
3314 : {
3315 : if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
3316 : Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
3317 : } else {
3318 : errno = 0;
3319 : Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
3320 : if (errno == ERANGE) { /* Overflow */
3321 : if (yytext[0] == '0') { /* octal overflow */
3322 : Z_DVAL_P(zendlval) = zend_oct_strtod(yytext, NULL);
3323 : } else {
3324 : Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);
3325 : }
3326 : Z_TYPE_P(zendlval) = IS_DOUBLE;
3327 : return T_DNUMBER;
3328 : }
3329 : }
3330 :
3331 : Z_TYPE_P(zendlval) = IS_LONG;
3332 : return T_LNUMBER;
3333 : }
3334 : #line 3335 "Zend/zend_language_scanner.c"
3335 63294 : yy173:
3336 : YYDEBUG(173, *YYCURSOR);
3337 63294 : yyaccept = 2;
3338 63294 : yych = *(YYMARKER = ++YYCURSOR);
3339 63294 : if (yych <= '9') {
3340 50780 : if (yych == '.') goto yy187;
3341 49165 : if (yych <= '/') goto yy172;
3342 23129 : goto yy190;
3343 : } else {
3344 12514 : if (yych <= 'E') {
3345 6226 : if (yych <= 'D') goto yy172;
3346 101 : goto yy192;
3347 : } else {
3348 6288 : if (yych == 'e') goto yy192;
3349 6030 : goto yy172;
3350 : }
3351 : }
3352 32696 : yy174:
3353 : YYDEBUG(174, *YYCURSOR);
3354 32696 : yych = *++YYCURSOR;
3355 32696 : goto yy186;
3356 1642 : yy175:
3357 : YYDEBUG(175, *YYCURSOR);
3358 1642 : ++YYCURSOR;
3359 38825 : yy176:
3360 : YYDEBUG(176, *YYCURSOR);
3361 38825 : yyleng = YYCURSOR - SCNG(yy_text);
3362 : #line 2194 "Zend/zend_language_scanner.l"
3363 : {
3364 : while (YYCURSOR < YYLIMIT) {
3365 : switch (*YYCURSOR++) {
3366 : case '\r':
3367 : if (*YYCURSOR == '\n') {
3368 : YYCURSOR++;
3369 : }
3370 : /* fall through */
3371 : case '\n':
3372 : CG(zend_lineno)++;
3373 : break;
3374 : case '%':
3375 : if (!CG(asp_tags)) {
3376 : continue;
3377 : }
3378 : /* fall through */
3379 : case '?':
3380 : if (*YYCURSOR == '>') {
3381 : YYCURSOR--;
3382 : break;
3383 : }
3384 : /* fall through */
3385 : default:
3386 : continue;
3387 : }
3388 :
3389 : break;
3390 : }
3391 :
3392 : yyleng = YYCURSOR - SCNG(yy_text);
3393 :
3394 : return T_COMMENT;
3395 : }
3396 : #line 3397 "Zend/zend_language_scanner.c"
3397 185672 : yy177:
3398 : YYDEBUG(177, *YYCURSOR);
3399 185672 : ++YYCURSOR;
3400 186608 : yy178:
3401 : YYDEBUG(178, *YYCURSOR);
3402 186608 : yyleng = YYCURSOR - SCNG(yy_text);
3403 : #line 2290 "Zend/zend_language_scanner.l"
3404 : {
3405 : int bprefix = (yytext[0] != '\'') ? 1 : 0;
3406 :
3407 : while (1) {
3408 : if (YYCURSOR < YYLIMIT) {
3409 : if (*YYCURSOR == '\'') {
3410 : YYCURSOR++;
3411 : yyleng = YYCURSOR - SCNG(yy_text);
3412 :
3413 : break;
3414 : } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
3415 : YYCURSOR++;
3416 : }
3417 : } else {
3418 : yyleng = YYLIMIT - SCNG(yy_text);
3419 :
3420 : /* Unclosed single quotes; treat similar to double quotes, but without a separate token
3421 : * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
3422 : * rule, which continued in ST_IN_SCRIPTING state after the quote */
3423 : return T_ENCAPSED_AND_WHITESPACE;
3424 : }
3425 : }
3426 :
3427 : if (bprefix) {
3428 : zend_scan_binary_single_string(zendlval, yytext+2, yyleng-3 TSRMLS_CC);
3429 : return T_CONSTANT_ENCAPSED_STRING;
3430 : } else {
3431 : return zend_scan_unicode_single_string(zendlval TSRMLS_CC);
3432 : }
3433 : }
3434 : #line 3435 "Zend/zend_language_scanner.c"
3435 158809 : yy179:
3436 : YYDEBUG(179, *YYCURSOR);
3437 158809 : ++YYCURSOR;
3438 159943 : yy180:
3439 : YYDEBUG(180, *YYCURSOR);
3440 159943 : yyleng = YYCURSOR - SCNG(yy_text);
3441 : #line 2322 "Zend/zend_language_scanner.l"
3442 : {
3443 : int bprefix = (yytext[0] != '"') ? 1 : 0;
3444 :
3445 : while (YYCURSOR < YYLIMIT) {
3446 : switch (*YYCURSOR++) {
3447 : case '"':
3448 : yyleng = YYCURSOR - SCNG(yy_text);
3449 :
3450 : if (bprefix) {
3451 : zend_scan_binary_escape_string(zendlval, yytext+2, yyleng-3, '"' TSRMLS_CC);
3452 : return T_CONSTANT_ENCAPSED_STRING;
3453 : } else {
3454 : return zend_scan_unicode_escape_string(zendlval, yytext+1, yyleng-2, 0x22 /*'"'*/, T_CONSTANT_ENCAPSED_STRING TSRMLS_CC);
3455 : }
3456 : case '$':
3457 : if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
3458 : break;
3459 : }
3460 : continue;
3461 : case '{':
3462 : if (*YYCURSOR == '$') {
3463 : break;
3464 : }
3465 : continue;
3466 : case '\\':
3467 : if (YYCURSOR < YYLIMIT) {
3468 : YYCURSOR++;
3469 : }
3470 : /* fall through */
3471 : default:
3472 : continue;
3473 : }
3474 :
3475 : YYCURSOR--;
3476 : break;
3477 : }
3478 :
3479 : /* Remember how much was scanned to save rescanning */
3480 : SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
3481 :
3482 : YYCURSOR = SCNG(yy_text) + yyleng;
3483 :
3484 : BEGIN(ST_DOUBLE_QUOTES);
3485 : return bprefix ? T_BINARY_DOUBLE : '"';
3486 : }
3487 : #line 3488 "Zend/zend_language_scanner.c"
3488 105 : yy181:
3489 : YYDEBUG(181, *YYCURSOR);
3490 105 : ++YYCURSOR;
3491 : YYDEBUG(182, *YYCURSOR);
3492 105 : yyleng = YYCURSOR - SCNG(yy_text);
3493 : #line 2418 "Zend/zend_language_scanner.l"
3494 : {
3495 : BEGIN(ST_BACKQUOTE);
3496 : return '`';
3497 : }
3498 : #line 3499 "Zend/zend_language_scanner.c"
3499 1445 : yy183:
3500 : YYDEBUG(183, *YYCURSOR);
3501 1445 : ++YYCURSOR;
3502 : YYDEBUG(184, *YYCURSOR);
3503 1445 : yyleng = YYCURSOR - SCNG(yy_text);
3504 : #line 2689 "Zend/zend_language_scanner.l"
3505 : {
3506 : if (YYCURSOR > YYLIMIT) {
3507 : return 0;
3508 : }
3509 :
3510 : zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
3511 : goto restart;
3512 : }
3513 : #line 3514 "Zend/zend_language_scanner.c"
3514 12924581 : yy185:
3515 : YYDEBUG(185, *YYCURSOR);
3516 12924581 : ++YYCURSOR;
3517 12924581 : YYFILL(1);
3518 12924581 : yych = *YYCURSOR;
3519 13227752 : yy186:
3520 : YYDEBUG(186, *YYCURSOR);
3521 13227752 : if (yybm[0+yych] & 8) {
3522 12875553 : goto yy185;
3523 : }
3524 352199 : goto yy124;
3525 24695 : yy187:
3526 : YYDEBUG(187, *YYCURSOR);
3527 24695 : yyaccept = 3;
3528 24695 : YYMARKER = ++YYCURSOR;
3529 24695 : YYFILL(3);
3530 24695 : yych = *YYCURSOR;
3531 : YYDEBUG(188, *YYCURSOR);
3532 24695 : if (yybm[0+yych] & 16) {
3533 19186 : goto yy187;
3534 : }
3535 5509 : if (yych == 'E') goto yy192;
3536 5004 : if (yych == 'e') goto yy192;
3537 6817 : yy189:
3538 : YYDEBUG(189, *YYCURSOR);
3539 6817 : yyleng = YYCURSOR - SCNG(yy_text);
3540 : #line 1870 "Zend/zend_language_scanner.l"
3541 : {
3542 : Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);
3543 : Z_TYPE_P(zendlval) = IS_DOUBLE;
3544 : return T_DNUMBER;
3545 : }
3546 : #line 3547 "Zend/zend_language_scanner.c"
3547 61048 : yy190:
3548 : YYDEBUG(190, *YYCURSOR);
3549 61048 : yyaccept = 2;
3550 61048 : YYMARKER = ++YYCURSOR;
3551 61048 : YYFILL(3);
3552 61048 : yych = *YYCURSOR;
3553 : YYDEBUG(191, *YYCURSOR);
3554 61048 : if (yych <= '9') {
3555 55471 : if (yych == '.') goto yy187;
3556 51966 : if (yych <= '/') goto yy172;
3557 36351 : goto yy190;
3558 : } else {
3559 5577 : if (yych <= 'E') {
3560 5520 : if (yych <= 'D') goto yy172;
3561 : } else {
3562 57 : if (yych != 'e') goto yy172;
3563 : }
3564 : }
3565 2105 : yy192:
3566 : YYDEBUG(192, *YYCURSOR);
3567 2105 : yych = *++YYCURSOR;
3568 2105 : if (yych <= ',') {
3569 178 : if (yych == '+') goto yy194;
3570 : } else {
3571 1927 : if (yych <= '-') goto yy194;
3572 1332 : if (yych <= '/') goto yy193;
3573 1332 : if (yych <= '9') goto yy195;
3574 : }
3575 49408 : yy193:
3576 : YYDEBUG(193, *YYCURSOR);
3577 49408 : YYCURSOR = YYMARKER;
3578 49408 : if (yyaccept <= 2) {
3579 49325 : if (yyaccept <= 1) {
3580 49325 : if (yyaccept <= 0) {
3581 0 : goto yy124;
3582 : } else {
3583 49325 : goto yy138;
3584 : }
3585 : } else {
3586 0 : goto yy172;
3587 : }
3588 : } else {
3589 83 : if (yyaccept <= 4) {
3590 82 : if (yyaccept <= 3) {
3591 0 : goto yy189;
3592 : } else {
3593 82 : goto yy234;
3594 : }
3595 : } else {
3596 1 : goto yy250;
3597 : }
3598 : }
3599 773 : yy194:
3600 : YYDEBUG(194, *YYCURSOR);
3601 773 : yych = *++YYCURSOR;
3602 773 : if (yych <= '/') goto yy193;
3603 773 : if (yych >= ':') goto yy193;
3604 3376 : yy195:
3605 : YYDEBUG(195, *YYCURSOR);
3606 3376 : ++YYCURSOR;
3607 3376 : YYFILL(1);
3608 3376 : yych = *YYCURSOR;
3609 : YYDEBUG(196, *YYCURSOR);
3610 3376 : if (yych <= '/') goto yy189;
3611 1314 : if (yych <= '9') goto yy195;
3612 43 : goto yy189;
3613 1354 : yy197:
3614 : YYDEBUG(197, *YYCURSOR);
3615 1354 : yych = *++YYCURSOR;
3616 1354 : if (yybm[0+yych] & 32) {
3617 1354 : goto yy198;
3618 : }
3619 0 : goto yy193;
3620 5579 : yy198:
3621 : YYDEBUG(198, *YYCURSOR);
3622 5579 : ++YYCURSOR;
3623 5579 : YYFILL(1);
3624 5579 : yych = *YYCURSOR;
3625 : YYDEBUG(199, *YYCURSOR);
3626 5579 : if (yybm[0+yych] & 32) {
3627 4225 : goto yy198;
3628 : }
3629 : YYDEBUG(200, *YYCURSOR);
3630 1354 : yyleng = YYCURSOR - SCNG(yy_text);
3631 : #line 1830 "Zend/zend_language_scanner.l"
3632 : {
3633 : char *hex = yytext + 2; /* Skip "0x" */
3634 : int len = yyleng - 2;
3635 :
3636 : /* Skip any leading 0s */
3637 : while (*hex == '0') {
3638 : hex++;
3639 : len--;
3640 : }
3641 :
3642 : if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
3643 : Z_LVAL_P(zendlval) = strtol(hex, NULL, 16);
3644 : Z_TYPE_P(zendlval) = IS_LONG;
3645 : return T_LNUMBER;
3646 : } else {
3647 : Z_DVAL_P(zendlval) = zend_hex_strtod(hex, NULL);
3648 : Z_TYPE_P(zendlval) = IS_DOUBLE;
3649 : return T_DNUMBER;
3650 : }
3651 : }
3652 : #line 3653 "Zend/zend_language_scanner.c"
3653 23759 : yy201:
3654 : YYDEBUG(201, *YYCURSOR);
3655 23759 : ++YYCURSOR;
3656 23759 : if ((yych = *YYCURSOR) == '\n') goto yy203;
3657 4512 : if (yych == '\r') goto yy204;
3658 23759 : yy202:
3659 : YYDEBUG(202, *YYCURSOR);
3660 23759 : yyleng = YYCURSOR - SCNG(yy_text);
3661 : #line 2267 "Zend/zend_language_scanner.l"
3662 : {
3663 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
3664 : Z_STRLEN_P(zendlval) = yyleng;
3665 : Z_TYPE_P(zendlval) = IS_STRING;
3666 : BEGIN(INITIAL);
3667 : return T_CLOSE_TAG; /* implicit ';' at php-end tag */
3668 : }
3669 : #line 3670 "Zend/zend_language_scanner.c"
3670 19369 : yy203:
3671 : YYDEBUG(203, *YYCURSOR);
3672 19369 : yych = *++YYCURSOR;
3673 19369 : goto yy202;
3674 122 : yy204:
3675 : YYDEBUG(204, *YYCURSOR);
3676 122 : yych = *++YYCURSOR;
3677 122 : if (yych == '\n') goto yy203;
3678 0 : goto yy202;
3679 3131890 : yy205:
3680 : YYDEBUG(205, *YYCURSOR);
3681 3131890 : ++YYCURSOR;
3682 3131890 : YYFILL(1);
3683 3131890 : yych = *YYCURSOR;
3684 : YYDEBUG(206, *YYCURSOR);
3685 3131890 : if (yych <= '^') {
3686 849792 : if (yych <= '9') {
3687 647690 : if (yych >= '0') goto yy205;
3688 : } else {
3689 202102 : if (yych <= '@') goto yy207;
3690 174168 : if (yych <= 'Z') goto yy205;
3691 : }
3692 : } else {
3693 2282098 : if (yych <= '`') {
3694 118252 : if (yych <= '_') goto yy205;
3695 : } else {
3696 2163846 : if (yych <= 'z') goto yy205;
3697 325 : if (yych >= 0x7F) goto yy205;
3698 : }
3699 : }
3700 538267 : yy207:
3701 : YYDEBUG(207, *YYCURSOR);
3702 538267 : yyleng = YYCURSOR - SCNG(yy_text);
3703 : #line 2149 "Zend/zend_language_scanner.l"
3704 : {
3705 : if (!zend_copy_scanner_string(zendlval, (yytext+1), (yyleng-1), IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
3706 : return 0;
3707 : }
3708 : if (!zend_check_and_normalize_identifier(zendlval)) {
3709 : return 0;
3710 : }
3711 : return T_VARIABLE;
3712 : }
3713 : #line 3714 "Zend/zend_language_scanner.c"
3714 1 : yy208:
3715 : YYDEBUG(208, *YYCURSOR);
3716 1 : yych = *++YYCURSOR;
3717 1 : if (yych == 'R') goto yy209;
3718 1 : if (yych != 'r') goto yy186;
3719 1 : yy209:
3720 : YYDEBUG(209, *YYCURSOR);
3721 1 : ++YYCURSOR;
3722 1 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
3723 0 : goto yy185;
3724 : }
3725 : YYDEBUG(210, *YYCURSOR);
3726 1 : yyleng = YYCURSOR - SCNG(yy_text);
3727 : #line 1750 "Zend/zend_language_scanner.l"
3728 : {
3729 : return T_LOGICAL_XOR;
3730 : }
3731 : #line 3732 "Zend/zend_language_scanner.c"
3732 675 : yy211:
3733 : YYDEBUG(211, *YYCURSOR);
3734 675 : ++YYCURSOR;
3735 675 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
3736 36 : goto yy185;
3737 : }
3738 : YYDEBUG(212, *YYCURSOR);
3739 639 : yyleng = YYCURSOR - SCNG(yy_text);
3740 : #line 1742 "Zend/zend_language_scanner.l"
3741 : {
3742 : return T_LOGICAL_OR;
3743 : }
3744 : #line 3745 "Zend/zend_language_scanner.c"
3745 2 : yy213:
3746 : YYDEBUG(213, *YYCURSOR);
3747 2 : ++YYCURSOR;
3748 : YYDEBUG(214, *YYCURSOR);
3749 2 : yyleng = YYCURSOR - SCNG(yy_text);
3750 : #line 1730 "Zend/zend_language_scanner.l"
3751 : {
3752 : return T_XOR_EQUAL;
3753 : }
3754 : #line 3755 "Zend/zend_language_scanner.c"
3755 1962 : yy215:
3756 : YYDEBUG(215, *YYCURSOR);
3757 1962 : ++YYCURSOR;
3758 : YYDEBUG(216, *YYCURSOR);
3759 1962 : yyleng = YYCURSOR - SCNG(yy_text);
3760 : #line 1734 "Zend/zend_language_scanner.l"
3761 : {
3762 : return T_BOOLEAN_OR;
3763 : }
3764 : #line 3765 "Zend/zend_language_scanner.c"
3765 96 : yy217:
3766 : YYDEBUG(217, *YYCURSOR);
3767 96 : ++YYCURSOR;
3768 : YYDEBUG(218, *YYCURSOR);
3769 96 : yyleng = YYCURSOR - SCNG(yy_text);
3770 : #line 1726 "Zend/zend_language_scanner.l"
3771 : {
3772 : return T_OR_EQUAL;
3773 : }
3774 : #line 3775 "Zend/zend_language_scanner.c"
3775 3663 : yy219:
3776 : YYDEBUG(219, *YYCURSOR);
3777 3663 : ++YYCURSOR;
3778 : YYDEBUG(220, *YYCURSOR);
3779 3663 : yyleng = YYCURSOR - SCNG(yy_text);
3780 : #line 1738 "Zend/zend_language_scanner.l"
3781 : {
3782 : return T_BOOLEAN_AND;
3783 : }
3784 : #line 3785 "Zend/zend_language_scanner.c"
3785 3 : yy221:
3786 : YYDEBUG(221, *YYCURSOR);
3787 3 : ++YYCURSOR;
3788 : YYDEBUG(222, *YYCURSOR);
3789 3 : yyleng = YYCURSOR - SCNG(yy_text);
3790 : #line 1722 "Zend/zend_language_scanner.l"
3791 : {
3792 : return T_AND_EQUAL;
3793 : }
3794 : #line 3795 "Zend/zend_language_scanner.c"
3795 2 : yy223:
3796 : YYDEBUG(223, *YYCURSOR);
3797 2 : ++YYCURSOR;
3798 2 : if ((yych = *YYCURSOR) == '\n') goto yy227;
3799 0 : if (yych == '\r') goto yy228;
3800 2 : yy224:
3801 : YYDEBUG(224, *YYCURSOR);
3802 2 : yyleng = YYCURSOR - SCNG(yy_text);
3803 : #line 2276 "Zend/zend_language_scanner.l"
3804 : {
3805 : if (CG(asp_tags)) {
3806 : BEGIN(INITIAL);
3807 : Z_STRLEN_P(zendlval) = yyleng;
3808 : Z_TYPE_P(zendlval) = IS_STRING;
3809 : Z_STRVAL_P(zendlval) = yytext; /* no copying - intentional */
3810 : return T_CLOSE_TAG; /* implicit ';' at php-end tag */
3811 : } else {
3812 : yyless(1);
3813 : return yytext[0];
3814 : }
3815 : }
3816 : #line 3817 "Zend/zend_language_scanner.c"
3817 1 : yy225:
3818 : YYDEBUG(225, *YYCURSOR);
3819 1 : ++YYCURSOR;
3820 : YYDEBUG(226, *YYCURSOR);
3821 1 : yyleng = YYCURSOR - SCNG(yy_text);
3822 : #line 1710 "Zend/zend_language_scanner.l"
3823 : {
3824 : return T_MOD_EQUAL;
3825 : }
3826 : #line 3827 "Zend/zend_language_scanner.c"
3827 2 : yy227:
3828 : YYDEBUG(227, *YYCURSOR);
3829 2 : yych = *++YYCURSOR;
3830 2 : goto yy224;
3831 0 : yy228:
3832 : YYDEBUG(228, *YYCURSOR);
3833 0 : yych = *++YYCURSOR;
3834 0 : if (yych == '\n') goto yy227;
3835 0 : goto yy224;
3836 1194 : yy229:
3837 : YYDEBUG(229, *YYCURSOR);
3838 1194 : yyaccept = 3;
3839 1194 : YYMARKER = ++YYCURSOR;
3840 1194 : YYFILL(3);
3841 1194 : yych = *YYCURSOR;
3842 : YYDEBUG(230, *YYCURSOR);
3843 1194 : if (yych <= 'D') {
3844 1032 : if (yych <= '/') goto yy189;
3845 296 : if (yych <= '9') goto yy229;
3846 0 : goto yy189;
3847 : } else {
3848 162 : if (yych <= 'E') goto yy192;
3849 79 : if (yych == 'e') goto yy192;
3850 0 : goto yy189;
3851 : }
3852 1934 : yy231:
3853 : YYDEBUG(231, *YYCURSOR);
3854 1934 : ++YYCURSOR;
3855 : YYDEBUG(232, *YYCURSOR);
3856 1934 : yyleng = YYCURSOR - SCNG(yy_text);
3857 : #line 1706 "Zend/zend_language_scanner.l"
3858 : {
3859 : return T_CONCAT_EQUAL;
3860 : }
3861 : #line 3862 "Zend/zend_language_scanner.c"
3862 21348 : yy233:
3863 : YYDEBUG(233, *YYCURSOR);
3864 21348 : yyaccept = 4;
3865 21348 : yych = *(YYMARKER = ++YYCURSOR);
3866 21348 : if (yych == '*') goto yy238;
3867 21348 : yy234:
3868 : YYDEBUG(234, *YYCURSOR);
3869 21348 : yyleng = YYCURSOR - SCNG(yy_text);
3870 : #line 2228 "Zend/zend_language_scanner.l"
3871 : {
3872 : int doc_com;
3873 :
3874 : if (yyleng > 2) {
3875 : doc_com = 1;
3876 : RESET_DOC_COMMENT();
3877 : } else {
3878 : doc_com = 0;
3879 : }
3880 :
3881 : while (YYCURSOR < YYLIMIT) {
3882 : if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
3883 : break;
3884 : }
3885 : }
3886 :
3887 : if (YYCURSOR < YYLIMIT) {
3888 : YYCURSOR++;
3889 : } else {
3890 : zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
3891 : }
3892 :
3893 : yyleng = YYCURSOR - SCNG(yy_text);
3894 : HANDLE_NEWLINES(yytext, yyleng);
3895 :
3896 : if (doc_com) {
3897 : zval tmp;
3898 :
3899 : if (!zend_copy_scanner_string(&tmp, yytext, yyleng, IS_UNICODE, SCNG(output_conv) TSRMLS_CC)) {
3900 : return 0;
3901 : }
3902 : CG(doc_comment) = tmp.value.uni.val;
3903 : CG(doc_comment_len) = tmp.value.uni.len;
3904 : return T_DOC_COMMENT;
3905 : }
3906 :
3907 : return T_COMMENT;
3908 : }
3909 : #line 3910 "Zend/zend_language_scanner.c"
3910 37183 : yy235:
3911 : YYDEBUG(235, *YYCURSOR);
3912 37183 : yych = *++YYCURSOR;
3913 37183 : goto yy176;
3914 4 : yy236:
3915 : YYDEBUG(236, *YYCURSOR);
3916 4 : ++YYCURSOR;
3917 : YYDEBUG(237, *YYCURSOR);
3918 4 : yyleng = YYCURSOR - SCNG(yy_text);
3919 : #line 1702 "Zend/zend_language_scanner.l"
3920 : {
3921 : return T_DIV_EQUAL;
3922 : }
3923 : #line 3924 "Zend/zend_language_scanner.c"
3924 2087 : yy238:
3925 : YYDEBUG(238, *YYCURSOR);
3926 2087 : yych = *++YYCURSOR;
3927 2087 : if (yybm[0+yych] & 64) {
3928 2005 : goto yy239;
3929 : }
3930 82 : goto yy193;
3931 6000 : yy239:
3932 : YYDEBUG(239, *YYCURSOR);
3933 6000 : ++YYCURSOR;
3934 6000 : YYFILL(1);
3935 6000 : yych = *YYCURSOR;
3936 : YYDEBUG(240, *YYCURSOR);
3937 6000 : if (yybm[0+yych] & 64) {
3938 3995 : goto yy239;
3939 : }
3940 2005 : goto yy234;
3941 13 : yy241:
3942 : YYDEBUG(241, *YYCURSOR);
3943 13 : ++YYCURSOR;
3944 : YYDEBUG(242, *YYCURSOR);
3945 13 : yyleng = YYCURSOR - SCNG(yy_text);
3946 : #line 1698 "Zend/zend_language_scanner.l"
3947 : {
3948 : return T_MUL_EQUAL;
3949 : }
3950 : #line 3951 "Zend/zend_language_scanner.c"
3951 39 : yy243:
3952 : YYDEBUG(243, *YYCURSOR);
3953 39 : ++YYCURSOR;
3954 39 : if ((yych = *YYCURSOR) == '=') goto yy247;
3955 : YYDEBUG(244, *YYCURSOR);
3956 34 : yyleng = YYCURSOR - SCNG(yy_text);
3957 : #line 1758 "Zend/zend_language_scanner.l"
3958 : {
3959 : return T_SR;
3960 : }
3961 : #line 3962 "Zend/zend_language_scanner.c"
3962 258 : yy245:
3963 : YYDEBUG(245, *YYCURSOR);
3964 258 : ++YYCURSOR;
3965 : YYDEBUG(246, *YYCURSOR);
3966 258 : yyleng = YYCURSOR - SCNG(yy_text);
3967 : #line 1686 "Zend/zend_language_scanner.l"
3968 : {
3969 : return T_IS_GREATER_OR_EQUAL;
3970 : }
3971 : #line 3972 "Zend/zend_language_scanner.c"
3972 5 : yy247:
3973 : YYDEBUG(247, *YYCURSOR);
3974 5 : ++YYCURSOR;
3975 : YYDEBUG(248, *YYCURSOR);
3976 5 : yyleng = YYCURSOR - SCNG(yy_text);
3977 : #line 1718 "Zend/zend_language_scanner.l"
3978 : {
3979 : return T_SR_EQUAL;
3980 : }
3981 : #line 3982 "Zend/zend_language_scanner.c"
3982 1387 : yy249:
3983 : YYDEBUG(249, *YYCURSOR);
3984 1387 : yyaccept = 5;
3985 1387 : yych = *(YYMARKER = ++YYCURSOR);
3986 1387 : if (yych <= ';') goto yy250;
3987 1284 : if (yych <= '<') goto yy265;
3988 4 : if (yych <= '=') goto yy263;
3989 104 : yy250:
3990 : YYDEBUG(250, *YYCURSOR);
3991 104 : yyleng = YYCURSOR - SCNG(yy_text);
3992 : #line 1754 "Zend/zend_language_scanner.l"
3993 : {
3994 : return T_SL;
3995 : }
3996 : #line 3997 "Zend/zend_language_scanner.c"
3997 3 : yy251:
3998 : YYDEBUG(251, *YYCURSOR);
3999 3 : yych = *++YYCURSOR;
4000 3 : if (yych == 'S') goto yy256;
4001 3 : if (yych == 's') goto yy256;
4002 0 : goto yy193;
4003 1609 : yy252:
4004 : YYDEBUG(252, *YYCURSOR);
4005 1609 : ++YYCURSOR;
4006 : YYDEBUG(253, *YYCURSOR);
4007 1609 : yyleng = YYCURSOR - SCNG(yy_text);
4008 : #line 1682 "Zend/zend_language_scanner.l"
4009 : {
4010 : return T_IS_SMALLER_OR_EQUAL;
4011 : }
4012 : #line 4013 "Zend/zend_language_scanner.c"
4013 3 : yy254:
4014 : YYDEBUG(254, *YYCURSOR);
4015 3 : ++YYCURSOR;
4016 2412 : yy255:
4017 : YYDEBUG(255, *YYCURSOR);
4018 2412 : yyleng = YYCURSOR - SCNG(yy_text);
4019 : #line 1678 "Zend/zend_language_scanner.l"
4020 : {
4021 : return T_IS_NOT_EQUAL;
4022 : }
4023 : #line 4024 "Zend/zend_language_scanner.c"
4024 3 : yy256:
4025 : YYDEBUG(256, *YYCURSOR);
4026 3 : yych = *++YYCURSOR;
4027 3 : if (yych == 'C') goto yy257;
4028 3 : if (yych != 'c') goto yy193;
4029 3 : yy257:
4030 : YYDEBUG(257, *YYCURSOR);
4031 3 : yych = *++YYCURSOR;
4032 3 : if (yych == 'R') goto yy258;
4033 3 : if (yych != 'r') goto yy193;
4034 3 : yy258:
4035 : YYDEBUG(258, *YYCURSOR);
4036 3 : yych = *++YYCURSOR;
4037 3 : if (yych == 'I') goto yy259;
4038 3 : if (yych != 'i') goto yy193;
4039 3 : yy259:
4040 : YYDEBUG(259, *YYCURSOR);
4041 3 : yych = *++YYCURSOR;
4042 3 : if (yych == 'P') goto yy260;
4043 3 : if (yych != 'p') goto yy193;
4044 3 : yy260:
4045 : YYDEBUG(260, *YYCURSOR);
4046 3 : yych = *++YYCURSOR;
4047 3 : if (yych == 'T') goto yy261;
4048 3 : if (yych != 't') goto yy193;
4049 3 : yy261:
4050 : YYDEBUG(261, *YYCURSOR);
4051 3 : ++YYCURSOR;
4052 3 : YYFILL(3);
4053 3 : yych = *YYCURSOR;
4054 : YYDEBUG(262, *YYCURSOR);
4055 3 : if (yych <= '\r') {
4056 0 : if (yych <= 0x08) goto yy193;
4057 0 : if (yych <= '\n') goto yy261;
4058 0 : if (yych <= '\f') goto yy193;
4059 0 : goto yy261;
4060 : } else {
4061 3 : if (yych <= ' ') {
4062 0 : if (yych <= 0x1F) goto yy193;
4063 0 : goto yy261;
4064 : } else {
4065 3 : if (yych == '>') goto yy201;
4066 0 : goto yy193;
4067 : }
4068 : }
4069 4 : yy263:
4070 : YYDEBUG(263, *YYCURSOR);
4071 4 : ++YYCURSOR;
4072 : YYDEBUG(264, *YYCURSOR);
4073 4 : yyleng = YYCURSOR - SCNG(yy_text);
4074 : #line 1714 "Zend/zend_language_scanner.l"
4075 : {
4076 : return T_SL_EQUAL;
4077 : }
4078 : #line 4079 "Zend/zend_language_scanner.c"
4079 1410 : yy265:
4080 : YYDEBUG(265, *YYCURSOR);
4081 1410 : ++YYCURSOR;
4082 1410 : YYFILL(2);
4083 1410 : yych = *YYCURSOR;
4084 : YYDEBUG(266, *YYCURSOR);
4085 1410 : if (yybm[0+yych] & 128) {
4086 27 : goto yy265;
4087 : }
4088 1383 : if (yych <= 'Z') {
4089 1376 : if (yych <= '&') {
4090 10 : if (yych == '"') goto yy270;
4091 0 : goto yy193;
4092 : } else {
4093 1366 : if (yych <= '\'') goto yy269;
4094 1324 : if (yych <= '@') goto yy193;
4095 : }
4096 : } else {
4097 7 : if (yych <= '`') {
4098 2 : if (yych != '_') goto yy193;
4099 : } else {
4100 5 : if (yych <= 'z') goto yy267;
4101 0 : if (yych <= '~') goto yy193;
4102 : }
4103 : }
4104 4457 : yy267:
4105 : YYDEBUG(267, *YYCURSOR);
4106 4457 : ++YYCURSOR;
4107 4457 : YYFILL(2);
4108 4457 : yych = *YYCURSOR;
4109 : YYDEBUG(268, *YYCURSOR);
4110 4457 : if (yych <= '@') {
4111 1371 : if (yych <= '\f') {
4112 1331 : if (yych == '\n') goto yy274;
4113 0 : goto yy193;
4114 : } else {
4115 40 : if (yych <= '\r') goto yy276;
4116 40 : if (yych <= '/') goto yy193;
4117 40 : if (yych <= '9') goto yy267;
4118 0 : goto yy193;
4119 : }
4120 : } else {
4121 3086 : if (yych <= '_') {
4122 3002 : if (yych <= 'Z') goto yy267;
4123 16 : if (yych <= '^') goto yy193;
4124 16 : goto yy267;
4125 : } else {
4126 84 : if (yych <= '`') goto yy193;
4127 84 : if (yych <= 'z') goto yy267;
4128 0 : if (yych <= '~') goto yy193;
4129 0 : goto yy267;
4130 : }
4131 : }
4132 42 : yy269:
4133 : YYDEBUG(269, *YYCURSOR);
4134 42 : yych = *++YYCURSOR;
4135 42 : if (yych == '\'') goto yy193;
4136 42 : if (yych <= '/') goto yy278;
4137 42 : if (yych <= '9') goto yy193;
4138 42 : goto yy278;
4139 10 : yy270:
4140 : YYDEBUG(270, *YYCURSOR);
4141 10 : yych = *++YYCURSOR;
4142 10 : if (yych == '"') goto yy193;
4143 10 : if (yych <= '/') goto yy272;
4144 10 : if (yych <= '9') goto yy193;
4145 10 : goto yy272;
4146 47 : yy271:
4147 : YYDEBUG(271, *YYCURSOR);
4148 47 : ++YYCURSOR;
4149 47 : YYFILL(3);
4150 47 : yych = *YYCURSOR;
4151 57 : yy272:
4152 : YYDEBUG(272, *YYCURSOR);
4153 57 : if (yych <= 'Z') {
4154 57 : if (yych <= '/') {
4155 10 : if (yych != '"') goto yy193;
4156 : } else {
4157 47 : if (yych <= '9') goto yy271;
4158 47 : if (yych <= '@') goto yy193;
4159 47 : goto yy271;
4160 : }
4161 : } else {
4162 0 : if (yych <= '`') {
4163 0 : if (yych == '_') goto yy271;
4164 0 : goto yy193;
4165 : } else {
4166 0 : if (yych <= 'z') goto yy271;
4167 0 : if (yych <= '~') goto yy193;
4168 0 : goto yy271;
4169 : }
4170 : }
4171 51 : yy273:
4172 : YYDEBUG(273, *YYCURSOR);
4173 51 : yych = *++YYCURSOR;
4174 51 : if (yych == '\n') goto yy274;
4175 0 : if (yych == '\r') goto yy276;
4176 0 : goto yy193;
4177 1382 : yy274:
4178 : YYDEBUG(274, *YYCURSOR);
4179 1382 : ++YYCURSOR;
4180 1382 : yy275:
4181 : YYDEBUG(275, *YYCURSOR);
4182 1382 : yyleng = YYCURSOR - SCNG(yy_text);
4183 : #line 2369 "Zend/zend_language_scanner.l"
4184 : {
4185 : char *s;
4186 : int bprefix = (yytext[0] != '<') ? 1 : 0;
4187 :
4188 : /* save old heredoc label */
4189 : Z_STRVAL_P(zendlval) = CG(heredoc);
4190 : Z_STRLEN_P(zendlval) = CG(heredoc_len);
4191 :
4192 : CG(zend_lineno)++;
4193 : CG(heredoc_len) = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
4194 : s = yytext+bprefix+3;
4195 : while ((*s == ' ') || (*s == '\t')) {
4196 : s++;
4197 : CG(heredoc_len)--;
4198 : }
4199 :
4200 : if (*s == '\'') {
4201 : s++;
4202 : CG(heredoc_len) -= 2;
4203 :
4204 : BEGIN(ST_NOWDOC);
4205 : } else {
4206 : if (*s == '"') {
4207 : s++;
4208 : CG(heredoc_len) -= 2;
4209 : }
4210 :
4211 : BEGIN(ST_HEREDOC);
4212 : }
4213 :
4214 : CG(heredoc) = estrndup(s, CG(heredoc_len));
4215 :
4216 : /* Check for ending label on the next line */
4217 : if (CG(heredoc_len) < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, CG(heredoc_len))) {
4218 : YYCTYPE *end = YYCURSOR + CG(heredoc_len);
4219 :
4220 : if (*end == ';') {
4221 : end++;
4222 : }
4223 :
4224 : if (*end == '\n' || *end == '\r') {
4225 : BEGIN(ST_END_HEREDOC);
4226 : }
4227 : }
4228 :
4229 : return bprefix ? T_BINARY_HEREDOC : T_START_HEREDOC;
4230 : }
4231 : #line 4232 "Zend/zend_language_scanner.c"
4232 0 : yy276:
4233 : YYDEBUG(276, *YYCURSOR);
4234 0 : yych = *++YYCURSOR;
4235 0 : if (yych == '\n') goto yy274;
4236 0 : goto yy275;
4237 312 : yy277:
4238 : YYDEBUG(277, *YYCURSOR);
4239 312 : ++YYCURSOR;
4240 312 : YYFILL(3);
4241 312 : yych = *YYCURSOR;
4242 354 : yy278:
4243 : YYDEBUG(278, *YYCURSOR);
4244 354 : if (yych <= 'Z') {
4245 348 : if (yych <= '/') {
4246 42 : if (yych == '\'') goto yy273;
4247 0 : goto yy193;
4248 : } else {
4249 306 : if (yych <= '9') goto yy277;
4250 306 : if (yych <= '@') goto yy193;
4251 306 : goto yy277;
4252 : }
4253 : } else {
4254 6 : if (yych <= '`') {
4255 0 : if (yych == '_') goto yy277;
4256 0 : goto yy193;
4257 : } else {
4258 6 : if (yych <= 'z') goto yy277;
4259 0 : if (yych <= '~') goto yy193;
4260 0 : goto yy277;
4261 : }
4262 : }
4263 8885 : yy279:
4264 : YYDEBUG(279, *YYCURSOR);
4265 8885 : yych = *++YYCURSOR;
4266 8885 : if (yych != '=') goto yy255;
4267 : YYDEBUG(280, *YYCURSOR);
4268 6476 : ++YYCURSOR;
4269 : YYDEBUG(281, *YYCURSOR);
4270 6476 : yyleng = YYCURSOR - SCNG(yy_text);
4271 : #line 1670 "Zend/zend_language_scanner.l"
4272 : {
4273 : return T_IS_NOT_IDENTICAL;
4274 : }
4275 : #line 4276 "Zend/zend_language_scanner.c"
4276 623 : yy282:
4277 : YYDEBUG(282, *YYCURSOR);
4278 623 : ++YYCURSOR;
4279 : YYDEBUG(283, *YYCURSOR);
4280 623 : yyleng = YYCURSOR - SCNG(yy_text);
4281 : #line 1690 "Zend/zend_language_scanner.l"
4282 : {
4283 : return T_PLUS_EQUAL;
4284 : }
4285 : #line 4286 "Zend/zend_language_scanner.c"
4286 5560 : yy284:
4287 : YYDEBUG(284, *YYCURSOR);
4288 5560 : ++YYCURSOR;
4289 : YYDEBUG(285, *YYCURSOR);
4290 5560 : yyleng = YYCURSOR - SCNG(yy_text);
4291 : #line 1658 "Zend/zend_language_scanner.l"
4292 : {
4293 : return T_INC;
4294 : }
4295 : #line 4296 "Zend/zend_language_scanner.c"
4296 377 : yy286:
4297 : YYDEBUG(286, *YYCURSOR);
4298 377 : yych = *++YYCURSOR;
4299 377 : if (yych == 'S') goto yy287;
4300 377 : if (yych != 's') goto yy186;
4301 113 : yy287:
4302 : YYDEBUG(287, *YYCURSOR);
4303 113 : yych = *++YYCURSOR;
4304 113 : if (yych == 'T') goto yy288;
4305 113 : if (yych != 't') goto yy186;
4306 113 : yy288:
4307 : YYDEBUG(288, *YYCURSOR);
4308 113 : ++YYCURSOR;
4309 113 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4310 2 : goto yy185;
4311 : }
4312 : YYDEBUG(289, *YYCURSOR);
4313 111 : yyleng = YYCURSOR - SCNG(yy_text);
4314 : #line 1650 "Zend/zend_language_scanner.l"
4315 : {
4316 : return T_LIST;
4317 : }
4318 : #line 4319 "Zend/zend_language_scanner.c"
4319 16468 : yy290:
4320 : YYDEBUG(290, *YYCURSOR);
4321 16468 : ++YYCURSOR;
4322 16468 : if ((yych = *YYCURSOR) == '=') goto yy294;
4323 : YYDEBUG(291, *YYCURSOR);
4324 11695 : yyleng = YYCURSOR - SCNG(yy_text);
4325 : #line 1674 "Zend/zend_language_scanner.l"
4326 : {
4327 : return T_IS_EQUAL;
4328 : }
4329 : #line 4330 "Zend/zend_language_scanner.c"
4330 27478 : yy292:
4331 : YYDEBUG(292, *YYCURSOR);
4332 27478 : ++YYCURSOR;
4333 : YYDEBUG(293, *YYCURSOR);
4334 27478 : yyleng = YYCURSOR - SCNG(yy_text);
4335 : #line 1646 "Zend/zend_language_scanner.l"
4336 : {
4337 : return T_DOUBLE_ARROW;
4338 : }
4339 : #line 4340 "Zend/zend_language_scanner.c"
4340 4773 : yy294:
4341 : YYDEBUG(294, *YYCURSOR);
4342 4773 : ++YYCURSOR;
4343 : YYDEBUG(295, *YYCURSOR);
4344 4773 : yyleng = YYCURSOR - SCNG(yy_text);
4345 : #line 1666 "Zend/zend_language_scanner.l"
4346 : {
4347 : return T_IS_IDENTICAL;
4348 : }
4349 : #line 4350 "Zend/zend_language_scanner.c"
4350 12330 : yy296:
4351 : YYDEBUG(296, *YYCURSOR);
4352 12330 : yych = *++YYCURSOR;
4353 : YYDEBUG(-1, yych);
4354 12330 : switch (yych) {
4355 : case 'C':
4356 2499 : case 'c': goto yy298;
4357 : case 'D':
4358 267 : case 'd': goto yy302;
4359 : case 'F':
4360 7526 : case 'f': goto yy299;
4361 : case 'H':
4362 272 : case 'h': goto yy297;
4363 : case 'L':
4364 73 : case 'l': goto yy301;
4365 : case 'M':
4366 746 : case 'm': goto yy300;
4367 : case 'N':
4368 33 : case 'n': goto yy303;
4369 914 : default: goto yy186;
4370 : }
4371 272 : yy297:
4372 : YYDEBUG(297, *YYCURSOR);
4373 272 : yych = *++YYCURSOR;
4374 272 : if (yych == 'A') goto yy357;
4375 23 : if (yych == 'a') goto yy357;
4376 0 : goto yy186;
4377 2499 : yy298:
4378 : YYDEBUG(298, *YYCURSOR);
4379 2499 : yych = *++YYCURSOR;
4380 2499 : if (yych == 'L') goto yy350;
4381 2424 : if (yych == 'l') goto yy350;
4382 2402 : goto yy186;
4383 7526 : yy299:
4384 : YYDEBUG(299, *YYCURSOR);
4385 7526 : yych = *++YYCURSOR;
4386 7526 : if (yych <= 'U') {
4387 7524 : if (yych == 'I') goto yy334;
4388 97 : if (yych <= 'T') goto yy186;
4389 97 : goto yy335;
4390 : } else {
4391 2 : if (yych <= 'i') {
4392 1 : if (yych <= 'h') goto yy186;
4393 1 : goto yy334;
4394 : } else {
4395 1 : if (yych == 'u') goto yy335;
4396 0 : goto yy186;
4397 : }
4398 : }
4399 746 : yy300:
4400 : YYDEBUG(300, *YYCURSOR);
4401 746 : yych = *++YYCURSOR;
4402 746 : if (yych == 'E') goto yy326;
4403 1 : if (yych == 'e') goto yy326;
4404 0 : goto yy186;
4405 73 : yy301:
4406 : YYDEBUG(301, *YYCURSOR);
4407 73 : yych = *++YYCURSOR;
4408 73 : if (yych == 'I') goto yy320;
4409 58 : if (yych == 'i') goto yy320;
4410 57 : goto yy186;
4411 267 : yy302:
4412 : YYDEBUG(302, *YYCURSOR);
4413 267 : yych = *++YYCURSOR;
4414 267 : if (yych == 'I') goto yy315;
4415 171 : if (yych == 'i') goto yy315;
4416 170 : goto yy186;
4417 33 : yy303:
4418 : YYDEBUG(303, *YYCURSOR);
4419 33 : yych = *++YYCURSOR;
4420 33 : if (yych == 'A') goto yy304;
4421 1 : if (yych != 'a') goto yy186;
4422 33 : yy304:
4423 : YYDEBUG(304, *YYCURSOR);
4424 33 : yych = *++YYCURSOR;
4425 33 : if (yych == 'M') goto yy305;
4426 1 : if (yych != 'm') goto yy186;
4427 33 : yy305:
4428 : YYDEBUG(305, *YYCURSOR);
4429 33 : yych = *++YYCURSOR;
4430 33 : if (yych == 'E') goto yy306;
4431 1 : if (yych != 'e') goto yy186;
4432 33 : yy306:
4433 : YYDEBUG(306, *YYCURSOR);
4434 33 : yych = *++YYCURSOR;
4435 33 : if (yych == 'S') goto yy307;
4436 1 : if (yych != 's') goto yy186;
4437 33 : yy307:
4438 : YYDEBUG(307, *YYCURSOR);
4439 33 : yych = *++YYCURSOR;
4440 33 : if (yych == 'P') goto yy308;
4441 1 : if (yych != 'p') goto yy186;
4442 33 : yy308:
4443 : YYDEBUG(308, *YYCURSOR);
4444 33 : yych = *++YYCURSOR;
4445 33 : if (yych == 'A') goto yy309;
4446 1 : if (yych != 'a') goto yy186;
4447 33 : yy309:
4448 : YYDEBUG(309, *YYCURSOR);
4449 33 : yych = *++YYCURSOR;
4450 33 : if (yych == 'C') goto yy310;
4451 1 : if (yych != 'c') goto yy186;
4452 33 : yy310:
4453 : YYDEBUG(310, *YYCURSOR);
4454 33 : yych = *++YYCURSOR;
4455 33 : if (yych == 'E') goto yy311;
4456 1 : if (yych != 'e') goto yy186;
4457 33 : yy311:
4458 : YYDEBUG(311, *YYCURSOR);
4459 33 : yych = *++YYCURSOR;
4460 33 : if (yych != '_') goto yy186;
4461 : YYDEBUG(312, *YYCURSOR);
4462 33 : yych = *++YYCURSOR;
4463 33 : if (yych != '_') goto yy186;
4464 : YYDEBUG(313, *YYCURSOR);
4465 33 : ++YYCURSOR;
4466 33 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4467 0 : goto yy185;
4468 : }
4469 : YYDEBUG(314, *YYCURSOR);
4470 33 : yyleng = YYCURSOR - SCNG(yy_text);
4471 : #line 1980 "Zend/zend_language_scanner.l"
4472 : {
4473 : if (CG(current_namespace)) {
4474 : *zendlval = *CG(current_namespace);
4475 : zval_copy_ctor(zendlval);
4476 : } else {
4477 : ZVAL_EMPTY_UNICODE(zendlval);
4478 : }
4479 : return T_NS_C;
4480 : }
4481 : #line 4482 "Zend/zend_language_scanner.c"
4482 97 : yy315:
4483 : YYDEBUG(315, *YYCURSOR);
4484 97 : yych = *++YYCURSOR;
4485 97 : if (yych == 'R') goto yy316;
4486 1 : if (yych != 'r') goto yy186;
4487 97 : yy316:
4488 : YYDEBUG(316, *YYCURSOR);
4489 97 : yych = *++YYCURSOR;
4490 97 : if (yych != '_') goto yy186;
4491 : YYDEBUG(317, *YYCURSOR);
4492 97 : yych = *++YYCURSOR;
4493 97 : if (yych != '_') goto yy186;
4494 : YYDEBUG(318, *YYCURSOR);
4495 97 : ++YYCURSOR;
4496 97 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4497 0 : goto yy185;
4498 : }
4499 : YYDEBUG(319, *YYCURSOR);
4500 97 : yyleng = YYCURSOR - SCNG(yy_text);
4501 : #line 1953 "Zend/zend_language_scanner.l"
4502 : {
4503 : char *filename = zend_get_compiled_filename(TSRMLS_C);
4504 : const size_t filename_len = strlen(filename);
4505 : char *dirname;
4506 :
4507 : if (!filename) {
4508 : filename = "";
4509 : }
4510 :
4511 : dirname = estrndup(filename, filename_len);
4512 : zend_dirname(dirname, filename_len);
4513 :
4514 : if (strcmp(dirname, ".") == 0) {
4515 : dirname = erealloc(dirname, MAXPATHLEN);
4516 : #if HAVE_GETCWD
4517 : VCWD_GETCWD(dirname, MAXPATHLEN);
4518 : #elif HAVE_GETWD
4519 : VCWD_GETWD(dirname);
4520 : #endif
4521 : }
4522 :
4523 : zendlval->value.str.len = strlen(dirname);
4524 : zendlval->value.str.val = dirname;
4525 : zendlval->type = IS_STRING;
4526 : return T_DIR;
4527 : }
4528 : #line 4529 "Zend/zend_language_scanner.c"
4529 16 : yy320:
4530 : YYDEBUG(320, *YYCURSOR);
4531 16 : yych = *++YYCURSOR;
4532 16 : if (yych == 'N') goto yy321;
4533 1 : if (yych != 'n') goto yy186;
4534 16 : yy321:
4535 : YYDEBUG(321, *YYCURSOR);
4536 16 : yych = *++YYCURSOR;
4537 16 : if (yych == 'E') goto yy322;
4538 1 : if (yych != 'e') goto yy186;
4539 16 : yy322:
4540 : YYDEBUG(322, *YYCURSOR);
4541 16 : yych = *++YYCURSOR;
4542 16 : if (yych != '_') goto yy186;
4543 : YYDEBUG(323, *YYCURSOR);
4544 16 : yych = *++YYCURSOR;
4545 16 : if (yych != '_') goto yy186;
4546 : YYDEBUG(324, *YYCURSOR);
4547 16 : ++YYCURSOR;
4548 16 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4549 0 : goto yy185;
4550 : }
4551 : YYDEBUG(325, *YYCURSOR);
4552 16 : yyleng = YYCURSOR - SCNG(yy_text);
4553 : #line 1937 "Zend/zend_language_scanner.l"
4554 : {
4555 : Z_LVAL_P(zendlval) = CG(zend_lineno);
4556 : Z_TYPE_P(zendlval) = IS_LONG;
4557 : return T_LINE;
4558 : }
4559 : #line 4560 "Zend/zend_language_scanner.c"
4560 746 : yy326:
4561 : YYDEBUG(326, *YYCURSOR);
4562 746 : yych = *++YYCURSOR;
4563 746 : if (yych == 'T') goto yy327;
4564 1 : if (yych != 't') goto yy186;
4565 746 : yy327:
4566 : YYDEBUG(327, *YYCURSOR);
4567 746 : yych = *++YYCURSOR;
4568 746 : if (yych == 'H') goto yy328;
4569 1 : if (yych != 'h') goto yy186;
4570 746 : yy328:
4571 : YYDEBUG(328, *YYCURSOR);
4572 746 : yych = *++YYCURSOR;
4573 746 : if (yych == 'O') goto yy329;
4574 1 : if (yych != 'o') goto yy186;
4575 746 : yy329:
4576 : YYDEBUG(329, *YYCURSOR);
4577 746 : yych = *++YYCURSOR;
4578 746 : if (yych == 'D') goto yy330;
4579 1 : if (yych != 'd') goto yy186;
4580 746 : yy330:
4581 : YYDEBUG(330, *YYCURSOR);
4582 746 : yych = *++YYCURSOR;
4583 746 : if (yych != '_') goto yy186;
4584 : YYDEBUG(331, *YYCURSOR);
4585 746 : yych = *++YYCURSOR;
4586 746 : if (yych != '_') goto yy186;
4587 : YYDEBUG(332, *YYCURSOR);
4588 746 : ++YYCURSOR;
4589 746 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4590 0 : goto yy185;
4591 : }
4592 : YYDEBUG(333, *YYCURSOR);
4593 746 : yyleng = YYCURSOR - SCNG(yy_text);
4594 : #line 1906 "Zend/zend_language_scanner.l"
4595 : {
4596 : zstr class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL_ZSTR;
4597 : zstr func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL_ZSTR;
4598 : size_t len = 0;
4599 : size_t len1;
4600 :
4601 : if (class_name.u) {
4602 : len += len1 = u_strlen(class_name.u);
4603 : len += 2;
4604 : }
4605 : if (func_name.u) {
4606 : len += u_strlen(func_name.u);
4607 : } else {
4608 : func_name.u = EMPTY_STR;
4609 : }
4610 : Z_USTRLEN_P(zendlval) = len;
4611 : Z_USTRVAL_P(zendlval) = eumalloc(len+1);
4612 : if (class_name.u) {
4613 : u_strcpy(Z_USTRVAL_P(zendlval), class_name.u);
4614 : Z_USTRVAL_P(zendlval)[len1] = 0x3a; /* ':' */
4615 : Z_USTRVAL_P(zendlval)[len1+1] = 0x3a; /* ':' */
4616 : Z_USTRVAL_P(zendlval)[len1+2] = 0;
4617 : } else {
4618 : Z_USTRVAL_P(zendlval)[0] = 0;
4619 : }
4620 : u_strcat(Z_USTRVAL_P(zendlval), func_name.u);
4621 : Z_TYPE_P(zendlval) = IS_UNICODE;
4622 :
4623 : return T_METHOD_C;
4624 : }
4625 : #line 4626 "Zend/zend_language_scanner.c"
4626 7428 : yy334:
4627 : YYDEBUG(334, *YYCURSOR);
4628 7428 : yych = *++YYCURSOR;
4629 7428 : if (yych == 'L') goto yy345;
4630 1 : if (yych == 'l') goto yy345;
4631 0 : goto yy186;
4632 98 : yy335:
4633 : YYDEBUG(335, *YYCURSOR);
4634 98 : yych = *++YYCURSOR;
4635 98 : if (yych == 'N') goto yy336;
4636 1 : if (yych != 'n') goto yy186;
4637 98 : yy336:
4638 : YYDEBUG(336, *YYCURSOR);
4639 98 : yych = *++YYCURSOR;
4640 98 : if (yych == 'C') goto yy337;
4641 1 : if (yych != 'c') goto yy186;
4642 98 : yy337:
4643 : YYDEBUG(337, *YYCURSOR);
4644 98 : yych = *++YYCURSOR;
4645 98 : if (yych == 'T') goto yy338;
4646 1 : if (yych != 't') goto yy186;
4647 98 : yy338:
4648 : YYDEBUG(338, *YYCURSOR);
4649 98 : yych = *++YYCURSOR;
4650 98 : if (yych == 'I') goto yy339;
4651 1 : if (yych != 'i') goto yy186;
4652 98 : yy339:
4653 : YYDEBUG(339, *YYCURSOR);
4654 98 : yych = *++YYCURSOR;
4655 98 : if (yych == 'O') goto yy340;
4656 1 : if (yych != 'o') goto yy186;
4657 98 : yy340:
4658 : YYDEBUG(340, *YYCURSOR);
4659 98 : yych = *++YYCURSOR;
4660 98 : if (yych == 'N') goto yy341;
4661 1 : if (yych != 'n') goto yy186;
4662 98 : yy341:
4663 : YYDEBUG(341, *YYCURSOR);
4664 98 : yych = *++YYCURSOR;
4665 98 : if (yych != '_') goto yy186;
4666 : YYDEBUG(342, *YYCURSOR);
4667 98 : yych = *++YYCURSOR;
4668 98 : if (yych != '_') goto yy186;
4669 : YYDEBUG(343, *YYCURSOR);
4670 98 : ++YYCURSOR;
4671 98 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4672 0 : goto yy185;
4673 : }
4674 : YYDEBUG(344, *YYCURSOR);
4675 98 : yyleng = YYCURSOR - SCNG(yy_text);
4676 : #line 1891 "Zend/zend_language_scanner.l"
4677 : {
4678 : zstr func_name = NULL_ZSTR;
4679 :
4680 : if (CG(active_op_array)) {
4681 : func_name = CG(active_op_array)->function_name;
4682 : }
4683 :
4684 : if (!func_name.v) {
4685 : ZVAL_EMPTY_UNICODE(zendlval);
4686 : } else {
4687 : ZVAL_UNICODE(zendlval, func_name.u, 1);
4688 : }
4689 : return T_FUNC_C;
4690 : }
4691 : #line 4692 "Zend/zend_language_scanner.c"
4692 7428 : yy345:
4693 : YYDEBUG(345, *YYCURSOR);
4694 7428 : yych = *++YYCURSOR;
4695 7428 : if (yych == 'E') goto yy346;
4696 1 : if (yych != 'e') goto yy186;
4697 7428 : yy346:
4698 : YYDEBUG(346, *YYCURSOR);
4699 7428 : yych = *++YYCURSOR;
4700 7428 : if (yych != '_') goto yy186;
4701 : YYDEBUG(347, *YYCURSOR);
4702 7428 : yych = *++YYCURSOR;
4703 7428 : if (yych != '_') goto yy186;
4704 : YYDEBUG(348, *YYCURSOR);
4705 7428 : ++YYCURSOR;
4706 7428 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4707 0 : goto yy185;
4708 : }
4709 : YYDEBUG(349, *YYCURSOR);
4710 7428 : yyleng = YYCURSOR - SCNG(yy_text);
4711 : #line 1943 "Zend/zend_language_scanner.l"
4712 : {
4713 : char *filename = zend_get_compiled_filename(TSRMLS_C);
4714 :
4715 : if (!filename) {
4716 : filename = "";
4717 : }
4718 : ZVAL_RT_STRING(zendlval, filename, 1);
4719 : return T_FILE;
4720 : }
4721 : #line 4722 "Zend/zend_language_scanner.c"
4722 97 : yy350:
4723 : YYDEBUG(350, *YYCURSOR);
4724 97 : yych = *++YYCURSOR;
4725 97 : if (yych == 'A') goto yy351;
4726 22 : if (yych != 'a') goto yy186;
4727 76 : yy351:
4728 : YYDEBUG(351, *YYCURSOR);
4729 76 : yych = *++YYCURSOR;
4730 76 : if (yych == 'S') goto yy352;
4731 1 : if (yych != 's') goto yy186;
4732 76 : yy352:
4733 : YYDEBUG(352, *YYCURSOR);
4734 76 : yych = *++YYCURSOR;
4735 76 : if (yych == 'S') goto yy353;
4736 1 : if (yych != 's') goto yy186;
4737 76 : yy353:
4738 : YYDEBUG(353, *YYCURSOR);
4739 76 : yych = *++YYCURSOR;
4740 76 : if (yych != '_') goto yy186;
4741 : YYDEBUG(354, *YYCURSOR);
4742 76 : yych = *++YYCURSOR;
4743 76 : if (yych != '_') goto yy186;
4744 : YYDEBUG(355, *YYCURSOR);
4745 76 : ++YYCURSOR;
4746 76 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4747 0 : goto yy185;
4748 : }
4749 : YYDEBUG(356, *YYCURSOR);
4750 76 : yyleng = YYCURSOR - SCNG(yy_text);
4751 : #line 1876 "Zend/zend_language_scanner.l"
4752 : {
4753 : zstr class_name = NULL_ZSTR;
4754 :
4755 : if (CG(active_class_entry)) {
4756 : class_name = CG(active_class_entry)->name;
4757 : }
4758 :
4759 : if (!class_name.v) {
4760 : ZVAL_EMPTY_UNICODE(zendlval);
4761 : } else {
4762 : ZVAL_UNICODE(zendlval, class_name.u, 1);
4763 : }
4764 : return T_CLASS_C;
4765 : }
4766 : #line 4767 "Zend/zend_language_scanner.c"
4767 272 : yy357:
4768 : YYDEBUG(357, *YYCURSOR);
4769 272 : yych = *++YYCURSOR;
4770 272 : if (yych == 'L') goto yy358;
4771 23 : if (yych != 'l') goto yy186;
4772 272 : yy358:
4773 : YYDEBUG(358, *YYCURSOR);
4774 272 : yych = *++YYCURSOR;
4775 272 : if (yych == 'T') goto yy359;
4776 23 : if (yych != 't') goto yy186;
4777 272 : yy359:
4778 : YYDEBUG(359, *YYCURSOR);
4779 272 : yych = *++YYCURSOR;
4780 272 : if (yych != '_') goto yy186;
4781 : YYDEBUG(360, *YYCURSOR);
4782 272 : yych = *++YYCURSOR;
4783 272 : if (yych == 'C') goto yy361;
4784 23 : if (yych != 'c') goto yy186;
4785 272 : yy361:
4786 : YYDEBUG(361, *YYCURSOR);
4787 272 : yych = *++YYCURSOR;
4788 272 : if (yych == 'O') goto yy362;
4789 23 : if (yych != 'o') goto yy186;
4790 272 : yy362:
4791 : YYDEBUG(362, *YYCURSOR);
4792 272 : yych = *++YYCURSOR;
4793 272 : if (yych == 'M') goto yy363;
4794 23 : if (yych != 'm') goto yy186;
4795 272 : yy363:
4796 : YYDEBUG(363, *YYCURSOR);
4797 272 : yych = *++YYCURSOR;
4798 272 : if (yych == 'P') goto yy364;
4799 23 : if (yych != 'p') goto yy186;
4800 272 : yy364:
4801 : YYDEBUG(364, *YYCURSOR);
4802 272 : yych = *++YYCURSOR;
4803 272 : if (yych == 'I') goto yy365;
4804 23 : if (yych != 'i') goto yy186;
4805 272 : yy365:
4806 : YYDEBUG(365, *YYCURSOR);
4807 272 : yych = *++YYCURSOR;
4808 272 : if (yych == 'L') goto yy366;
4809 23 : if (yych != 'l') goto yy186;
4810 272 : yy366:
4811 : YYDEBUG(366, *YYCURSOR);
4812 272 : yych = *++YYCURSOR;
4813 272 : if (yych == 'E') goto yy367;
4814 23 : if (yych != 'e') goto yy186;
4815 272 : yy367:
4816 : YYDEBUG(367, *YYCURSOR);
4817 272 : yych = *++YYCURSOR;
4818 272 : if (yych == 'R') goto yy368;
4819 23 : if (yych != 'r') goto yy186;
4820 272 : yy368:
4821 : YYDEBUG(368, *YYCURSOR);
4822 272 : ++YYCURSOR;
4823 272 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4824 0 : goto yy185;
4825 : }
4826 : YYDEBUG(369, *YYCURSOR);
4827 272 : yyleng = YYCURSOR - SCNG(yy_text);
4828 : #line 1614 "Zend/zend_language_scanner.l"
4829 : {
4830 : return T_HALT_COMPILER;
4831 : }
4832 : #line 4833 "Zend/zend_language_scanner.c"
4833 7577 : yy370:
4834 : YYDEBUG(370, *YYCURSOR);
4835 7577 : yych = *++YYCURSOR;
4836 7577 : if (yych == 'S') goto yy374;
4837 7577 : if (yych == 's') goto yy374;
4838 5022 : goto yy186;
4839 246 : yy371:
4840 : YYDEBUG(371, *YYCURSOR);
4841 246 : yych = *++YYCURSOR;
4842 246 : if (yych == 'E') goto yy372;
4843 233 : if (yych != 'e') goto yy186;
4844 195 : yy372:
4845 : YYDEBUG(372, *YYCURSOR);
4846 195 : ++YYCURSOR;
4847 195 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4848 124 : goto yy185;
4849 : }
4850 : YYDEBUG(373, *YYCURSOR);
4851 71 : yyleng = YYCURSOR - SCNG(yy_text);
4852 : #line 1598 "Zend/zend_language_scanner.l"
4853 : {
4854 : return T_USE;
4855 : }
4856 : #line 4857 "Zend/zend_language_scanner.c"
4857 2555 : yy374:
4858 : YYDEBUG(374, *YYCURSOR);
4859 2555 : yych = *++YYCURSOR;
4860 2555 : if (yych == 'E') goto yy375;
4861 2555 : if (yych != 'e') goto yy186;
4862 2555 : yy375:
4863 : YYDEBUG(375, *YYCURSOR);
4864 2555 : yych = *++YYCURSOR;
4865 2555 : if (yych == 'T') goto yy376;
4866 2555 : if (yych != 't') goto yy186;
4867 1370 : yy376:
4868 : YYDEBUG(376, *YYCURSOR);
4869 1370 : ++YYCURSOR;
4870 1370 : if (yybm[0+(yych = *YYCURSOR)] & 8) {
4871 15 : goto yy185;
4872 : }
4873 : YYDEBUG(377, *YYCURSOR);
4874 1355 : yyleng = YYCURSOR - SCNG(yy_text);
4875 : #line 1642 "Zend/zend_language_scanner.l"
4876 : {
4877 : return T_UNSET;
4878 : }
4879 : #line 4880 "Zend/zend_language_scanner.c"
4880 18644 : yy378:
4881 : YYDEBUG(378, *YYCURSOR);
4882 18644 : ++YYCURSOR;
4883 18644 : YYFILL(7);
4884 18644 : yych = *YYCURSOR;
4885 74552 : yy379:
4886 : YYDEBUG(379, *YYCURSOR);
4887 74552 : if (yych <= 'S') {
4888 31073 : if (yych <= 'D') {
4889 30492 : if (yych <= ' ') {
4890 18736 : if (yych == '\t') goto yy378;
4891 18730 : if (yych <= 0x1F) goto yy193;
4892 18638 : goto yy378;
4893 : } else {
4894 11756 : if (yych <= 'A') {
4895 11587 : if (yych <= '@') goto yy193;
4896 631 : goto yy383;
4897 : } else {
4898 169 : if (yych <= 'B') goto yy381;
4899 136 : if (yych <= 'C') goto yy193;
4900 135 : goto yy386;
4901 : }
4902 : }
4903 : } else {
4904 581 : if (yych <= 'I') {
4905 319 : if (yych == 'F') goto yy387;
4906 115 : if (yych <= 'H') goto yy193;
4907 112 : goto yy388;
4908 : } else {
4909 262 : if (yych <= 'O') {
4910 52 : if (yych <= 'N') goto yy193;
4911 22 : goto yy382;
4912 : } else {
4913 210 : if (yych <= 'Q') goto yy193;
4914 209 : if (yych <= 'R') goto yy385;
4915 128 : goto yy384;
4916 : }
4917 : }
4918 : }
4919 : } else {
4920 43479 : if (yych <= 'f') {
4921 20935 : if (yych <= 'a') {
4922 3213 : if (yych == 'U') goto yy380;
4923 3201 : if (yych <= '`') goto yy193;
4924 3166 : goto yy383;
4925 : } else {
4926 17722 : if (yych <= 'c') {
4927 3326 : if (yych <= 'b') goto yy381;
4928 408 : goto yy193;
4929 : } else {
4930 14396 : if (yych <= 'd') goto yy386;
4931 8327 : if (yych <= 'e') goto yy193;
4932 8156 : goto yy387;
4933 : }
4934 : }
4935 : } else {
4936 22544 : if (yych <= 'q') {
4937 12485 : if (yych <= 'i') {
4938 10863 : if (yych <= 'h') goto yy193;
4939 10484 : goto yy388;
4940 : } else {
4941 1622 : if (yych == 'o') goto yy382;
4942 649 : goto yy193;
4943 : }
4944 : } else {
4945 10059 : if (yych <= 's') {
4946 7819 : if (yych <= 'r') goto yy385;
4947 5910 : goto yy384;
4948 : } else {
4949 2240 : if (yych != 'u') goto yy193;
4950 : }
4951 : }
4952 : }
4953 : }
4954 1891 : yy380:
4955 : YYDEBUG(380, *YYCURSOR);
4956 1891 : yych = *++YYCURSOR;
4957 1891 : if (yych == 'N') goto yy451;
4958 1891 : if (yych == 'n') goto yy451;
4959 140 : goto yy193;
4960 2951 : yy381:
4961 : YYDEBUG(381, *YYCURSOR);
4962 2951 : yych = *++YYCURSOR;
4963 2951 : if (yych <= 'O') {
4964 |
