1 : #define yy_create_buffer ini__create_buffer
2 : #define yy_delete_buffer ini__delete_buffer
3 : #define yy_scan_buffer ini__scan_buffer
4 : #define yy_scan_string ini__scan_string
5 : #define yy_scan_bytes ini__scan_bytes
6 : #define yy_flex_debug ini__flex_debug
7 : #define yy_init_buffer ini__init_buffer
8 : #define yy_flush_buffer ini__flush_buffer
9 : #define yy_load_buffer_state ini__load_buffer_state
10 : #define yy_switch_to_buffer ini__switch_to_buffer
11 : #define yyin ini_in
12 : #define yyleng ini_leng
13 : #define yylex ini_lex
14 : #define yyout ini_out
15 : #define yyrestart ini_restart
16 : #define yytext ini_text
17 :
18 : #line 19 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.c"
19 : /* A Lexical scanner generated by flex */
20 :
21 : /* Scanner skeleton version:
22 : * $Header$
23 : * vim:ft=lex:
24 : */
25 :
26 : #define FLEX_SCANNER
27 : #define YY_FLEX_MAJOR_VERSION 2
28 : #define YY_FLEX_MINOR_VERSION 5
29 :
30 : #include <stdio.h>
31 :
32 :
33 : /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
34 : #ifdef c_plusplus
35 : #ifndef __cplusplus
36 : #define __cplusplus
37 : #endif
38 : #endif
39 :
40 :
41 : #ifdef __cplusplus
42 :
43 : #include <stdlib.h>
44 : #if HAVE_UNISTD_H
45 : #include <unistd.h>
46 : #endif
47 :
48 : /* Use prototypes in function declarations. */
49 : #define YY_USE_PROTOS
50 :
51 : /* The "const" storage-class-modifier is valid. */
52 : #define YY_USE_CONST
53 :
54 : #else /* ! __cplusplus */
55 :
56 : #if __STDC__
57 :
58 : #define YY_USE_PROTOS
59 : #define YY_USE_CONST
60 :
61 : #endif /* __STDC__ */
62 : #endif /* ! __cplusplus */
63 :
64 : #ifdef __TURBOC__
65 : #pragma warn -rch
66 : #pragma warn -use
67 : #include <io.h>
68 : #include <stdlib.h>
69 : #define YY_USE_CONST
70 : #define YY_USE_PROTOS
71 : #endif
72 :
73 : #ifdef YY_USE_CONST
74 : #define yyconst const
75 : #else
76 : #define yyconst
77 : #endif
78 :
79 : #undef YY_USE_PROTOS
80 : #define YY_USE_PROTOS
81 :
82 : #ifdef YY_USE_PROTOS
83 : #define YY_PROTO(proto) proto
84 : #else
85 : #define YY_PROTO(proto) ()
86 : #endif
87 :
88 : /* Returned upon end-of-file. */
89 : #define YY_NULL 0
90 :
91 : /* Promotes a possibly negative, possibly signed char to an unsigned
92 : * integer for use as an array index. If the signed char is negative,
93 : * we want to instead treat it as an 8-bit unsigned char, hence the
94 : * double cast.
95 : */
96 : #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
97 :
98 : /* Enter a start condition. This macro really ought to take a parameter,
99 : * but we do it the disgusting crufty way forced on us by the ()-less
100 : * definition of BEGIN.
101 : */
102 : #define BEGIN yy_start = 1 + 2 *
103 :
104 : /* Translate the current start state into a value that can be later handed
105 : * to BEGIN to return to the state. The YYSTATE alias is for lex
106 : * compatibility.
107 : */
108 : #define YY_START ((yy_start - 1) / 2)
109 : #define YYSTATE YY_START
110 :
111 : /* Action number for EOF rule of a given start state. */
112 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
113 :
114 : /* Special action meaning "start processing a new file". */
115 : #define YY_NEW_FILE yyrestart( SCNG(yy_in) TSRMLS_CC )
116 :
117 : #define YY_END_OF_BUFFER_CHAR 0
118 :
119 : /* Size of default input buffer. */
120 : #define YY_BUF_SIZE 16384
121 :
122 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
123 :
124 : extern int yyleng;
125 :
126 :
127 : #define EOB_ACT_CONTINUE_SCAN 0
128 : #define EOB_ACT_END_OF_FILE 1
129 : #define EOB_ACT_LAST_MATCH 2
130 :
131 : /* The funky do-while in the following #define is used to turn the definition
132 : * int a single C statement (which needs a semi-colon terminator). This
133 : * avoids problems with code like:
134 : *
135 : * if ( condition_holds )
136 : * yyless( 5 );
137 : * else
138 : * do_something_else();
139 : *
140 : * Prior to using the do-while the compiler would get upset at the
141 : * "else" because it interpreted the "if" statement as being all
142 : * done when it reached the ';' after the yyless() call.
143 : */
144 :
145 : /* Return all but the first 'n' matched characters back to the input stream. */
146 :
147 : #define yyless(n) \
148 : do \
149 : { \
150 : /* Undo effects of setting up yytext. */ \
151 : *yy_cp = yy_hold_char; \
152 : yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
153 : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
154 : } \
155 : while ( 0 )
156 :
157 : #define unput(c) yyunput( c, yytext_ptr TSRMLS_CC )
158 :
159 : /* The following is because we cannot portably get our hands on size_t
160 : * (without autoconf's help, which isn't available because we want
161 : * flex-generated scanners to compile on their own).
162 : */
163 : typedef unsigned int yy_size_t;
164 :
165 :
166 : struct yy_buffer_state
167 : {
168 : struct _zend_file_handle *yy_input_file;
169 :
170 : char *yy_ch_buf; /* input buffer */
171 : char *yy_buf_pos; /* current position in input buffer */
172 :
173 : /* Size of input buffer in bytes, not including room for EOB
174 : * characters.
175 : */
176 : yy_size_t yy_buf_size;
177 :
178 : /* Number of characters read into yy_ch_buf, not including EOB
179 : * characters.
180 : */
181 : int yy_n_chars;
182 :
183 : /* Whether we "own" the buffer - i.e., we know we created it,
184 : * and can realloc() it to grow it, and should free() it to
185 : * delete it.
186 : */
187 : int yy_is_our_buffer;
188 :
189 : /* Whether this is an "interactive" input source; if so, and
190 : * if we're using stdio for input, then we want to use getc()
191 : * instead of fread(), to make sure we stop fetching input after
192 : * each newline.
193 : */
194 : int yy_is_interactive;
195 :
196 : /* Whether we're considered to be at the beginning of a line.
197 : * If so, '^' rules will be active on the next match, otherwise
198 : * not.
199 : */
200 : int yy_at_bol;
201 :
202 : /* Whether to try to fill the input buffer when we reach the
203 : * end of it.
204 : */
205 : int yy_fill_buffer;
206 :
207 : int yy_buffer_status;
208 : #define YY_BUFFER_NEW 0
209 : #define YY_BUFFER_NORMAL 1
210 : /* When an EOF's been seen but there's still some text to process
211 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
212 : * shouldn't try reading from the input source any more. We might
213 : * still have a bunch of tokens to match, though, because of
214 : * possible backing-up.
215 : *
216 : * When we actually see the EOF, we change the status to "new"
217 : * (via yyrestart()), so that the user can continue scanning by
218 : * just pointing yyin at a new input file.
219 : */
220 : #define YY_BUFFER_EOF_PENDING 2
221 : };
222 :
223 : #define yy_current_buffer SCNG(current_buffer)
224 : #define yy_hold_char SCNG(_yy_hold_char)
225 :
226 : /* We provide macros for accessing buffer states in case in the
227 : * future we want to put the buffer states in a more general
228 : * "scanner state".
229 : */
230 : #define YY_CURRENT_BUFFER yy_current_buffer
231 :
232 :
233 : /* yy_hold_char holds the character lost when yytext is formed. */
234 :
235 : #if 0
236 : static char yy_hold_char;
237 :
238 : static int yy_n_chars; /* number of characters read into yy_ch_buf */
239 : #endif
240 :
241 : /* Points to current character in buffer. */
242 : #define yy_c_buf_p SCNG(c_buf_p)
243 : #define yy_init SCNG(init)
244 : #define yy_start SCNG(start)
245 :
246 : #ifdef ZTS
247 : #define TSRMLS_D void ***tsrm_ls
248 : #define TSRMLS_DC , TSRMLS_D
249 : #define TSRMLS_C tsrm_ls
250 : #define TSRMLS_CC , TSRMLS_C
251 : #else
252 : #define TSRMLS_D
253 : #define TSRMLS_DC
254 : #define TSRMLS_C
255 : #define TSRMLS_CC
256 : #endif
257 :
258 : /* Flag which is used to allow yywrap()'s to do buffer switches
259 : * instead of setting up a fresh yyin. A bit of a hack ...
260 : */
261 : /* static int yy_did_buffer_switch_on_eof; */
262 : #define yy_did_buffer_switch_on_eof SCNG(_yy_did_buffer_switch_on_eof)
263 :
264 : void yyrestart YY_PROTO(( struct _zend_file_handle *input_file TSRMLS_DC ));
265 :
266 : void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer TSRMLS_DC ));
267 : void yy_load_buffer_state YY_PROTO(( TSRMLS_D ));
268 : YY_BUFFER_STATE yy_create_buffer YY_PROTO(( struct _zend_file_handle *file, int size TSRMLS_DC ));
269 : void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
270 : void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, struct _zend_file_handle *file TSRMLS_DC ));
271 : void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
272 : #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer TSRMLS_CC )
273 :
274 : YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size TSRMLS_DC ));
275 : YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str TSRMLS_DC ));
276 : YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len TSRMLS_DC ));
277 :
278 :
279 : static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
280 : static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
281 : static void yy_flex_free YY_PROTO(( void * ));
282 :
283 : #define yy_new_buffer yy_create_buffer
284 :
285 : #define yy_set_interactive(is_interactive) \
286 : { \
287 : if ( ! yy_current_buffer ) \
288 : yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC ); \
289 : yy_current_buffer->yy_is_interactive = is_interactive; \
290 : }
291 :
292 : #define yy_set_bol(at_bol) \
293 : { \
294 : if ( ! yy_current_buffer ) \
295 : yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC ); \
296 : yy_current_buffer->yy_at_bol = at_bol; \
297 : }
298 :
299 : #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
300 :
301 :
302 : #define yywrap() 1
303 : #define YY_SKIP_YYWRAP
304 : typedef unsigned char YY_CHAR;
305 : FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
306 : typedef int yy_state_type;
307 : extern char *yytext;
308 : #define yytext_ptr yytext
309 : #undef yyleng
310 : #define yyleng SCNG(yy_leng)
311 : #undef yytext
312 : #define yytext SCNG(yy_text)
313 : #undef yytext_ptr
314 : #define yytext_ptr SCNG(yy_text)
315 : #undef yyin
316 : #define yyin SCNG(yy_in)
317 : #undef yyout
318 : #define yyout SCNG(yy_out)
319 : #undef yy_last_accepting_state
320 : #define yy_last_accepting_state SCNG(_yy_last_accepting_state)
321 : #undef yy_last_accepting_cpos
322 : #define yy_last_accepting_cpos SCNG(_yy_last_accepting_cpos)
323 : #undef yy_more_flag
324 : #define yy_more_flag SCNG(_yy_more_flag)
325 : #undef yy_more_len
326 : #define yy_more_len SCNG(_yy_more_len)
327 :
328 :
329 : static yy_state_type yy_get_previous_state YY_PROTO(( TSRMLS_D ));
330 : static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state TSRMLS_DC ));
331 : static int yy_get_next_buffer YY_PROTO(( TSRMLS_D ));
332 : static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
333 :
334 : #undef TSRMLS_D
335 : #undef TSRMLS_DC
336 : #undef TSRMLS_C
337 : #undef TSRMLS_CC
338 :
339 : /* Done after the current pattern has been matched and before the
340 : * corresponding action - sets up yytext.
341 : */
342 : #define YY_DO_BEFORE_ACTION \
343 : yytext_ptr = yy_bp; \
344 : yyleng = (int) (yy_cp - yy_bp); \
345 : yy_hold_char = *yy_cp; \
346 : *yy_cp = '\0'; \
347 : yy_c_buf_p = yy_cp;
348 :
349 : #undef yyleng
350 : #undef yytext
351 : #undef yytext_ptr
352 : #undef yyin
353 : #undef yyout
354 : #undef yy_last_accepting_state
355 : #undef yy_last_accepting_cpos
356 : #undef yy_more_flag
357 : #undef yy_more_len
358 :
359 :
360 : #define YY_NUM_RULES 15
361 : #define YY_END_OF_BUFFER 16
362 : static yyconst short int yy_accept[63] =
363 : { 0,
364 : 0, 0, 16, 9, 13, 10, 11, 9, 8, 14,
365 : 8, 12, 10, 14, 9, 9, 9, 9, 9, 7,
366 : 9, 11, 9, 0, 9, 9, 9, 9, 9, 0,
367 : 5, 6, 12, 12, 12, 0, 0, 1, 9, 3,
368 : 9, 9, 2, 9, 9, 0, 4, 1, 1, 9,
369 : 3, 9, 9, 3, 2, 9, 4, 4, 4, 1,
370 : 9, 0
371 : } ;
372 :
373 : static yyconst int yy_ec[256] =
374 : { 0,
375 : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
376 : 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
377 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
378 : 1, 5, 6, 7, 1, 8, 1, 6, 1, 6,
379 : 6, 1, 1, 1, 1, 1, 1, 1, 1, 1,
380 : 1, 1, 1, 1, 1, 1, 1, 1, 9, 1,
381 : 10, 1, 1, 1, 13, 1, 1, 1, 14, 15,
382 : 1, 1, 1, 1, 1, 16, 1, 17, 18, 1,
383 : 1, 19, 20, 21, 22, 1, 1, 1, 23, 1,
384 : 11, 1, 12, 1, 1, 1, 13, 1, 1, 1,
385 :
386 : 14, 15, 1, 1, 1, 1, 1, 16, 1, 17,
387 : 18, 1, 1, 19, 20, 21, 22, 1, 1, 1,
388 : 23, 1, 24, 6, 25, 6, 1, 1, 1, 1,
389 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
391 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 :
397 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 : 1, 1, 1, 1, 1
403 : } ;
404 :
405 : static yyconst int yy_meta[26] =
406 : { 0,
407 : 1, 2, 3, 2, 1, 2, 2, 2, 2, 2,
408 : 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 : 1, 1, 1, 2, 2
410 : } ;
411 :
412 : static yyconst short int yy_base[67] =
413 : { 0,
414 : 0, 0, 105, 0, 106, 106, 101, 21, 106, 96,
415 : 78, 24, 106, 25, 88, 11, 26, 81, 85, 106,
416 : 0, 106, 0, 35, 85, 13, 31, 78, 82, 88,
417 : 106, 106, 46, 106, 91, 81, 40, 87, 75, 46,
418 : 74, 74, 83, 65, 66, 48, 51, 54, 80, 64,
419 : 78, 68, 65, 75, 74, 64, 106, 59, 61, 64,
420 : 47, 106, 33, 69, 72, 75
421 : } ;
422 :
423 : static yyconst short int yy_def[67] =
424 : { 0,
425 : 62, 1, 62, 63, 62, 62, 62, 63, 62, 64,
426 : 62, 65, 62, 66, 63, 63, 63, 63, 63, 62,
427 : 63, 62, 8, 62, 63, 63, 63, 63, 63, 64,
428 : 62, 62, 65, 62, 62, 66, 66, 62, 63, 63,
429 : 63, 63, 63, 63, 63, 62, 62, 62, 62, 63,
430 : 63, 63, 63, 63, 63, 63, 62, 62, 62, 62,
431 : 63, 0, 62, 62, 62, 62
432 : } ;
433 :
434 : static yyconst short int yy_nxt[132] =
435 : { 0,
436 : 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
437 : 14, 4, 4, 4, 15, 4, 16, 17, 4, 4,
438 : 18, 4, 19, 9, 20, 23, 34, 35, 40, 37,
439 : 40, 24, 41, 21, 41, 25, 38, 26, 27, 46,
440 : 42, 28, 43, 29, 37, 42, 38, 43, 34, 35,
441 : 51, 48, 46, 57, 58, 59, 57, 58, 60, 38,
442 : 54, 57, 52, 57, 58, 59, 57, 58, 60, 30,
443 : 30, 30, 33, 33, 33, 36, 36, 43, 55, 51,
444 : 54, 54, 51, 61, 49, 43, 56, 55, 54, 53,
445 : 50, 49, 47, 34, 31, 45, 44, 39, 45, 44,
446 :
447 : 39, 32, 31, 22, 62, 3, 62, 62, 62, 62,
448 : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
449 : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
450 : 62
451 : } ;
452 :
453 : static yyconst short int yy_chk[132] =
454 : { 0,
455 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
456 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 : 1, 1, 1, 1, 1, 8, 12, 12, 16, 14,
458 : 26, 8, 16, 63, 26, 8, 14, 8, 8, 24,
459 : 17, 8, 17, 8, 37, 27, 24, 27, 33, 33,
460 : 40, 37, 46, 47, 47, 47, 48, 48, 48, 46,
461 : 61, 58, 40, 59, 59, 59, 60, 60, 60, 64,
462 : 64, 64, 65, 65, 65, 66, 66, 56, 55, 54,
463 : 53, 52, 51, 50, 49, 45, 44, 43, 42, 41,
464 : 39, 38, 36, 35, 30, 29, 28, 25, 19, 18,
465 :
466 : 15, 11, 10, 7, 3, 62, 62, 62, 62, 62,
467 : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
468 : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
469 : 62
470 : } ;
471 :
472 : static yy_state_type yy_last_accepting_state;
473 : static char *yy_last_accepting_cpos;
474 :
475 : /* The intent behind this definition is that it'll catch
476 : * any uses of REJECT which flex missed.
477 : */
478 : #define REJECT reject_used_but_not_detected
479 : #define yymore() yymore_used_but_not_detected
480 : #define YY_MORE_ADJ 0
481 : #define YY_RESTORE_YY_MORE_OFFSET
482 : char *yytext;
483 : #line 1 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
484 : #define INITIAL 0
485 : #line 2 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
486 : /*
487 : +----------------------------------------------------------------------+
488 : | Zend Engine |
489 : +----------------------------------------------------------------------+
490 : | Copyright (c) 1998-2006 Zend Technologies Ltd. (http://www.zend.com) |
491 : +----------------------------------------------------------------------+
492 : | This source file is subject to version 2.00 of the Zend license, |
493 : | that is bundled with this package in the file LICENSE, and is |
494 : | available through the world-wide-web at the following url: |
495 : | http://www.zend.com/license/2_00.txt. |
496 : | If you did not receive a copy of the Zend license and are unable to |
497 : | obtain it through the world-wide-web, please send a note to |
498 : | license@zend.com so we can mail you a copy immediately. |
499 : +----------------------------------------------------------------------+
500 : | Author: Zeev Suraski <zeev@zend.com> |
501 : +----------------------------------------------------------------------+
502 : */
503 :
504 : /* $Id: zend_ini_scanner.l 240224 2007-07-23 16:17:10Z jani $ */
505 :
506 : #define yyleng SCNG(yy_leng)
507 : #define yytext SCNG(yy_text)
508 : #define yytext_ptr SCNG(yy_text)
509 : #define yyin SCNG(yy_in)
510 : #define yyout SCNG(yy_out)
511 : #define yy_last_accepting_state SCNG(_yy_last_accepting_state)
512 : #define yy_last_accepting_cpos SCNG(_yy_last_accepting_cpos)
513 : #define yy_more_flag SCNG(_yy_more_flag)
514 : #define yy_more_len SCNG(_yy_more_len)
515 :
516 : #include <errno.h>
517 : #include "zend.h"
518 : #include "zend_globals.h"
519 : #include <zend_ini_parser.h>
520 : #include "zend_ini_scanner.h"
521 :
522 : #undef YYSTYPE
523 : #define YYSTYPE zval
524 :
525 : #define YY_DECL int ini_lex(zval *ini_lval TSRMLS_DC)
526 :
527 : /* Globals Macros */
528 : #define SCNG INI_SCNG
529 : #ifdef ZTS
530 : ZEND_API ts_rsrc_id ini_scanner_globals_id;
531 : #else
532 : ZEND_API zend_scanner_globals ini_scanner_globals;
533 : #endif
534 :
535 : # define YY_INPUT(buf, result, max_size) \
536 : if ( ((result = zend_stream_read(yyin, buf, max_size TSRMLS_CC)) == 0) \
537 : && zend_stream_ferror( yyin TSRMLS_CC) ) \
538 : YY_FATAL_ERROR( "input in flex scanner failed" );
539 :
540 : static char *ini_filename;
541 :
542 : void init_ini_scanner(TSRMLS_D)
543 : {
544 : SCNG(lineno)=1;
545 : }
546 :
547 : int zend_ini_scanner_get_lineno(TSRMLS_D)
548 : {
549 : return SCNG(lineno);
550 : }
551 :
552 : char *zend_ini_scanner_get_filename(TSRMLS_D)
553 : {
554 : return ini_filename;
555 : }
556 :
557 : int zend_ini_open_file_for_scanning(zend_file_handle *fh TSRMLS_DC)
558 : {
559 : if (FAILURE == zend_stream_fixup(fh TSRMLS_CC)) {
560 : return FAILURE;
561 : }
562 :
563 : init_ini_scanner(TSRMLS_C);
564 : yyin = fh;
565 : yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE TSRMLS_CC) TSRMLS_CC);
566 : ini_filename = fh->filename;
567 : return SUCCESS;
568 : }
569 :
570 : int zend_ini_prepare_string_for_scanning(char *str TSRMLS_DC)
571 : {
572 : int len = strlen(str);
573 :
574 : yyin = NULL;
575 : yy_scan_buffer(str, len + 2 TSRMLS_CC);
576 : ini_filename = NULL;
577 : return SUCCESS;
578 : }
579 :
580 : void zend_ini_close_file(zend_file_handle *fh TSRMLS_DC)
581 : {
582 : zend_stream_close(fh);
583 : }
584 :
585 : #define YY_NEVER_INTERACTIVE 1
586 : #line 587 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.c"
587 :
588 : /* Macros after this point can all be overridden by user definitions in
589 : * section 1.
590 : */
591 :
592 : #ifndef YY_SKIP_YYWRAP
593 : #ifdef __cplusplus
594 : extern "C" int yywrap YY_PROTO(( void ));
595 : #else
596 : extern int yywrap YY_PROTO(( void ));
597 : #endif
598 : #endif
599 :
600 : #ifndef YY_NO_UNPUT
601 : static void yyunput YY_PROTO(( int c, char *buf_ptr TSRMLS_DC ));
602 : #endif
603 :
604 : #ifndef yytext_ptr
605 : static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
606 : #endif
607 :
608 : #ifdef YY_NEED_STRLEN
609 : static int yy_flex_strlen YY_PROTO(( yyconst char * ));
610 : #endif
611 :
612 : #ifndef YY_NO_INPUT
613 : #ifdef __cplusplus
614 : static int 3 YY_PROTO(( TSRMLS_D ));
615 : #else
616 : static int input YY_PROTO(( TSRMLS_D ));
617 : #endif
618 : #endif
619 :
620 : #if YY_STACK_USED
621 : #define yy_start_stack_ptr SCNG(yy_start_stack_ptr)
622 : #define yy_start_stack_depth SCNG(yy_start_stack_depth)
623 : #define yy_start_stack SCNG(yy_start_stack)
624 : /*
625 : static int yy_start_stack_ptr = 0;
626 : static int yy_start_stack_depth = 0;
627 : static int *yy_start_stack = 0;
628 : */
629 : #ifndef YY_NO_PUSH_STATE
630 : static void yy_push_state YY_PROTO(( int new_state TSRMLS_DC ));
631 : #endif
632 : #ifndef YY_NO_POP_STATE
633 : static void yy_pop_state YY_PROTO(( TSRMLS_D ));
634 : #endif
635 : #ifndef YY_NO_TOP_STATE
636 : static int yy_top_state YY_PROTO(( TSRMLS_D ));
637 : #endif
638 :
639 : #else
640 : #define YY_NO_PUSH_STATE 1
641 : #define YY_NO_POP_STATE 1
642 : #define YY_NO_TOP_STATE 1
643 : #endif
644 :
645 : #ifdef YY_MALLOC_DECL
646 : YY_MALLOC_DECL
647 : #else
648 : #if __STDC__
649 : #ifndef __cplusplus
650 : #include <stdlib.h>
651 : #endif
652 : #else
653 : /* Just try to get by without declaring the routines. This will fail
654 : * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
655 : * or sizeof(void*) != sizeof(int).
656 : */
657 : #endif
658 : #endif
659 :
660 : /* Amount of stuff to slurp up with each read. */
661 : #ifndef YY_READ_BUF_SIZE
662 : #define YY_READ_BUF_SIZE 8192
663 : #endif
664 :
665 : /* Copy whatever the last rule matched to the standard output. */
666 :
667 : /* Zend file handle reading */
668 : #ifndef ECHO
669 : #define ECHO /* There is no output */
670 : #endif
671 :
672 : #ifdef ZEND_MULTIBYTE
673 : # define YY_INPUT(buf, result, max_size) \
674 : if ( ((result = zend_multibyte_yyinput(yyin, buf, max_size TSRMLS_CC)) == 0) \
675 : && zend_stream_ferror( yyin TSRMLS_CC) ) \
676 : YY_FATAL_ERROR( "input in flex scanner failed" );
677 : #else
678 : # define YY_INPUT(buf, result, max_size) \
679 : if ( ((result = zend_stream_read(yyin, buf, max_size TSRMLS_CC)) == 0) \
680 : && zend_stream_ferror( yyin TSRMLS_CC) ) \
681 : YY_FATAL_ERROR( "input in flex scanner failed" );
682 : #endif
683 :
684 : #ifndef ECHO
685 : /* This used to be an fputs(), but since the string might contain NUL's,
686 : * we now use fwrite().
687 : */
688 : #define ECHO (void) fwrite( yytext, yyleng, 1, SCNG(yy_out) )
689 : #endif
690 :
691 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
692 : * is returned in "result".
693 : */
694 : #ifndef YY_INPUT
695 : #define YY_INPUT(buf,result,max_size) \
696 : if ( yy_current_buffer->yy_is_interactive ) \
697 : { \
698 : int c = '*', n; \
699 : for ( n = 0; n < max_size && \
700 : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
701 : buf[n] = (char) c; \
702 : if ( c == '\n' ) \
703 : buf[n++] = (char) c; \
704 : if ( c == EOF && ferror( yyin ) ) \
705 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
706 : result = n; \
707 : } \
708 : else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
709 : && ferror( yyin ) ) \
710 : YY_FATAL_ERROR( "input in flex scanner failed" );
711 : #endif
712 :
713 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
714 : * we don't want an extra ';' after the "return" because that will cause
715 : * some compilers to complain about unreachable statements.
716 : */
717 : #ifndef yyterminate
718 : #define yyterminate() return YY_NULL
719 : #endif
720 :
721 : /* Number of entries by which start-condition stack grows. */
722 : #ifndef YY_START_STACK_INCR
723 : #define YY_START_STACK_INCR 25
724 : #endif
725 :
726 : /* Report a fatal error. */
727 : #ifndef YY_FATAL_ERROR
728 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
729 : #endif
730 :
731 :
732 : /* Default declaration of generated scanner - a define so the user can
733 : * easily add parameters.
734 : */
735 : #ifndef YY_DECL
736 : #define YY_DECL int yylex YY_PROTO(( void ))
737 : #endif
738 :
739 : /* Code executed at the beginning of each rule, after yytext and yyleng
740 : * have been set up.
741 : */
742 : #ifndef YY_USER_ACTION
743 : #define YY_USER_ACTION
744 : #endif
745 :
746 : /* Code executed at the end of each rule. */
747 : #ifndef YY_BREAK
748 : #define YY_BREAK break;
749 : #endif
750 :
751 : #define YY_RULE_SETUP \
752 : YY_USER_ACTION
753 :
754 : YY_DECL
755 1974210 : {
756 : register yy_state_type yy_current_state;
757 : register char *yy_cp, *yy_bp;
758 : register int yy_act;
759 :
760 : #line 108 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
761 :
762 :
763 : #line 764 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.c"
764 :
765 1974210 : if ( yy_init )
766 : {
767 13546 : yy_init = 0;
768 :
769 : #ifdef YY_USER_INIT
770 : YY_USER_INIT;
771 : #endif
772 :
773 13546 : if ( ! yy_start )
774 13546 : yy_start = 1; /* first start state */
775 :
776 : #if 0
777 : if ( ! SCNG(yy_in) )
778 : SCNG(yy_in) = stdin;
779 :
780 : if ( ! SCNG(yy_out) )
781 : SCNG(yy_out) = stdout;
782 : #endif
783 :
784 13546 : if ( ! yy_current_buffer )
785 0 : yy_current_buffer =
786 : yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC );
787 :
788 13546 : yy_load_buffer_state(TSRMLS_C);
789 : }
790 :
791 : while ( 1 ) /* loops until end-of-file is reached */
792 : {
793 1974332 : yy_cp = yy_c_buf_p;
794 :
795 : /* Support of yytext. */
796 1974332 : *yy_cp = yy_hold_char;
797 :
798 : /* yy_bp points to the position in yy_ch_buf of the start of
799 : * the current run.
800 : */
801 1974332 : yy_bp = yy_cp;
802 :
803 1974332 : yy_current_state = yy_start;
804 11528499 : yy_match:
805 : do
806 : {
807 11528499 : register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
808 11528499 : if ( yy_accept[yy_current_state] )
809 : {
810 9470859 : yy_last_accepting_state = yy_current_state;
811 9470859 : yy_last_accepting_cpos = yy_cp;
812 : }
813 33421824 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
814 : {
815 10364826 : yy_current_state = (int) yy_def[yy_current_state];
816 10364826 : if ( yy_current_state >= 63 )
817 9418263 : yy_c = yy_meta[(unsigned int) yy_c];
818 : }
819 11528499 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
820 11528499 : ++yy_cp;
821 : }
822 11528499 : while ( yy_base[yy_current_state] != 106 );
823 :
824 1987907 : yy_find_action:
825 1987907 : yy_act = yy_accept[yy_current_state];
826 1987907 : if ( yy_act == 0 )
827 : { /* have to back up */
828 946558 : yy_cp = yy_last_accepting_cpos;
829 946558 : yy_current_state = yy_last_accepting_state;
830 946558 : yy_act = yy_accept[yy_current_state];
831 : }
832 :
833 1987907 : YY_DO_BEFORE_ACTION;
834 :
835 :
836 2014980 : do_action: /* This label is used only to access EOF actions. */
837 :
838 :
839 2014980 : switch ( yy_act )
840 : { /* beginning of action switch */
841 : case 0: /* must back up */
842 : /* undo the effects of YY_DO_BEFORE_ACTION */
843 0 : *yy_cp = yy_hold_char;
844 0 : yy_cp = yy_last_accepting_cpos;
845 0 : yy_current_state = yy_last_accepting_state;
846 0 : goto yy_find_action;
847 :
848 : case 1:
849 : YY_RULE_SETUP
850 : #line 110 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
851 : {
852 : return BRACK;
853 : }
854 : YY_BREAK
855 : case 2:
856 : YY_RULE_SETUP
857 : #line 114 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
858 : {
859 : Z_STRVAL_P(ini_lval) = zend_strndup("1", 1);
860 : Z_STRLEN_P(ini_lval) = 1;
861 : Z_TYPE_P(ini_lval) = IS_STRING;
862 : return CFG_TRUE;
863 : }
864 : YY_BREAK
865 : case 3:
866 : YY_RULE_SETUP
867 : #line 122 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
868 : {
869 : Z_STRVAL_P(ini_lval) = zend_strndup("", 0);
870 : Z_STRLEN_P(ini_lval) = 0;
871 : Z_TYPE_P(ini_lval) = IS_STRING;
872 : return CFG_FALSE;
873 : }
874 : YY_BREAK
875 : case 4:
876 : YY_RULE_SETUP
877 : #line 129 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
878 : {
879 : /* SECTION */
880 :
881 : /* eat trailing ] and spaces */
882 : while (yyleng>0 && (yytext[yyleng-1]=='\n' || yytext[yyleng-1]=='\r' || yytext[yyleng-1]==']' || yytext[yyleng-1]==' ')) {
883 : yyleng--;
884 : yytext[yyleng]=0;
885 : }
886 :
887 : SCNG(lineno)++;
888 :
889 : /* eat leading [ */
890 : yytext++;
891 : yyleng--;
892 :
893 : Z_STRVAL_P(ini_lval) = zend_strndup(yytext, yyleng);
894 : Z_STRLEN_P(ini_lval) = yyleng;
895 : Z_TYPE_P(ini_lval) = IS_STRING;
896 : return SECTION;
897 : }
898 : YY_BREAK
899 : case 5:
900 : YY_RULE_SETUP
901 : #line 150 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
902 : {
903 : char *p = yytext;
904 :
905 : /* ENCAPSULATED TC_STRING */
906 :
907 : while ((p = strpbrk(p, "\r\n"))) {
908 : if (*p == '\r' && *(p + 1) == '\n') {
909 : p++;
910 : }
911 : SCNG(lineno)++;
912 : p++;
913 : }
914 :
915 : /* eat trailing " */
916 : yytext[yyleng-1]=0;
917 :
918 : /* eat leading " */
919 : yytext++;
920 :
921 : Z_STRVAL_P(ini_lval) = zend_strndup(yytext, yyleng - 2);
922 : Z_STRLEN_P(ini_lval) = yyleng - 2;
923 : Z_TYPE_P(ini_lval) = IS_STRING;
924 : return TC_ENCAPSULATED_STRING;
925 : }
926 : YY_BREAK
927 : case 6:
928 : YY_RULE_SETUP
929 : #line 175 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
930 : {
931 : return TC_DOLLAR_CURLY;
932 : }
933 : YY_BREAK
934 : case 7:
935 : YY_RULE_SETUP
936 : #line 179 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
937 : {
938 : Z_LVAL_P(ini_lval) = (long) yytext[0];
939 : return yytext[0];
940 : }
941 : YY_BREAK
942 : case 8:
943 : YY_RULE_SETUP
944 : #line 184 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
945 : {
946 : return yytext[0];
947 : }
948 : YY_BREAK
949 : case 9:
950 : YY_RULE_SETUP
951 : #line 188 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
952 : {
953 : /* STRING */
954 : register int i;
955 :
956 : /* eat trailing whitespace */
957 : for (i=yyleng-1; i>=0; i--) {
958 : if (yytext[i]==' ' || yytext[i]=='\t') {
959 : yytext[i]=0;
960 : yyleng--;
961 : } else {
962 : break;
963 : }
964 : }
965 : /* eat leading whitespace */
966 : while (yytext[0]) {
967 : if (yytext[0]==' ' || yytext[0]=='\t') {
968 : yytext++;
969 : yyleng--;
970 : } else {
971 : break;
972 : }
973 : }
974 : if (yyleng!=0) {
975 : Z_STRVAL_P(ini_lval) = zend_strndup(yytext, yyleng);
976 : Z_STRLEN_P(ini_lval) = yyleng;
977 : Z_TYPE_P(ini_lval) = IS_STRING;
978 : return TC_STRING;
979 : } else {
980 : /* whitespace */
981 : }
982 : }
983 : YY_BREAK
984 : case 10:
985 : YY_RULE_SETUP
986 : #line 220 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
987 : {
988 : if (yytext[0] == '\n') {
989 : SCNG(lineno)++;
990 : }
991 : return yytext[0];
992 : }
993 : YY_BREAK
994 : case 11:
995 : YY_RULE_SETUP
996 : #line 227 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
997 : {
998 : SCNG(lineno)++;
999 : return '\n';
1000 : }
1001 : YY_BREAK
1002 : case 12:
1003 : YY_RULE_SETUP
1004 : #line 232 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
1005 : {
1006 : /* comment */
1007 : SCNG(lineno)++;
1008 : return '\n';
1009 : }
1010 : YY_BREAK
1011 : case 13:
1012 : YY_RULE_SETUP
1013 : #line 238 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
1014 : {
1015 : /* eat whitespace */
1016 : }
1017 : YY_BREAK
1018 : case 14:
1019 : YY_RULE_SETUP
1020 : #line 242 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
1021 : {
1022 : #if DEBUG
1023 : php_error(E_NOTICE,"Unexpected character on line %d: '%s' (ASCII %d)\n", yylineno, yytext, yytext[0]);
1024 : #endif
1025 : }
1026 : YY_BREAK
1027 : case YY_STATE_EOF(INITIAL):
1028 : #line 248 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
1029 : {
1030 : yy_delete_buffer(YY_CURRENT_BUFFER TSRMLS_CC);
1031 : yyterminate();
1032 : }
1033 : YY_BREAK
1034 : case 15:
1035 : YY_RULE_SETUP
1036 : #line 252 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
1037 : ECHO;
1038 : YY_BREAK
1039 : #line 1040 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.c"
1040 :
1041 : case YY_END_OF_BUFFER:
1042 : {
1043 : /* Amount of text matched not including the EOB char. */
1044 40648 : int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1045 :
1046 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1047 40648 : *yy_cp = yy_hold_char;
1048 :
1049 40648 : if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1050 : {
1051 : /* We're scanning a new file or input source. It's
1052 : * possible that this happened because the user
1053 : * just pointed yyin at a new source and called
1054 : * yylex(). If so, then we have to assure
1055 : * consistency between yy_current_buffer and our
1056 : * globals. Here is the right place to do so, because
1057 : * this is the first action (other than possibly a
1058 : * back-up) that will match for the new input source.
1059 : */
1060 27075 : SCNG(yy_n_chars) = yy_current_buffer->yy_n_chars;
1061 27075 : yy_current_buffer->yy_input_file = SCNG(yy_in);
1062 27075 : yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1063 : }
1064 :
1065 : /* Note that here we test for yy_c_buf_p "<=" to the position
1066 : * of the first EOB in the buffer, since yy_c_buf_p will
1067 : * already have been incremented past the NUL character
1068 : * (since all states make transitions on EOB to the
1069 : * end-of-buffer state). Contrast this with the test
1070 : * in input().
1071 : */
1072 40648 : if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] )
1073 : { /* This was really a NUL. */
1074 : yy_state_type yy_next_state;
1075 :
1076 4 : yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1077 :
1078 4 : yy_current_state = yy_get_previous_state(TSRMLS_C);
1079 :
1080 : /* Okay, we're now positioned to make the NUL
1081 : * transition. We couldn't have
1082 : * yy_get_previous_state() go ahead and do it
1083 : * for us because it doesn't know how to deal
1084 : * with the possibility of jamming (and we don't
1085 : * want to build jamming into it because then it
1086 : * will run more slowly).
1087 : */
1088 :
1089 4 : yy_next_state = yy_try_NUL_trans( yy_current_state TSRMLS_CC );
1090 :
1091 4 : yy_bp = yytext_ptr + YY_MORE_ADJ;
1092 :
1093 4 : if ( yy_next_state )
1094 : {
1095 : /* Consume the NUL. */
1096 4 : yy_cp = ++yy_c_buf_p;
1097 4 : yy_current_state = yy_next_state;
1098 4 : goto yy_match;
1099 : }
1100 :
1101 : else
1102 : {
1103 0 : yy_cp = yy_c_buf_p;
1104 0 : goto yy_find_action;
1105 : }
1106 : }
1107 :
1108 40644 : else switch ( yy_get_next_buffer(TSRMLS_C) )
1109 : {
1110 : case EOB_ACT_END_OF_FILE:
1111 : {
1112 27073 : yy_did_buffer_switch_on_eof = 0;
1113 :
1114 : if ( yywrap() )
1115 : {
1116 : /* Note: because we've taken care in
1117 : * yy_get_next_buffer() to have set up
1118 : * yytext, we can now set up
1119 : * yy_c_buf_p so that if some total
1120 : * hoser (like flex itself) wants to
1121 : * call the scanner after we return the
1122 : * YY_NULL, it'll still work - another
1123 : * YY_NULL will get returned.
1124 : */
1125 27073 : yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1126 :
1127 27073 : yy_act = YY_STATE_EOF(YY_START);
1128 27073 : goto do_action;
1129 : }
1130 :
1131 : else
1132 : {
1133 : if ( ! yy_did_buffer_switch_on_eof )
1134 : YY_NEW_FILE;
1135 : }
1136 : break;
1137 : }
1138 :
1139 : case EOB_ACT_CONTINUE_SCAN:
1140 13529 : yy_c_buf_p =
1141 : yytext_ptr + yy_amount_of_matched_text;
1142 :
1143 13529 : yy_current_state = yy_get_previous_state(TSRMLS_C);
1144 :
1145 13529 : yy_cp = yy_c_buf_p;
1146 13529 : yy_bp = yytext_ptr + YY_MORE_ADJ;
1147 13529 : goto yy_match;
1148 :
1149 : case EOB_ACT_LAST_MATCH:
1150 42 : yy_c_buf_p =
1151 : &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)];
1152 :
1153 42 : yy_current_state = yy_get_previous_state(TSRMLS_C);
1154 :
1155 42 : yy_cp = yy_c_buf_p;
1156 42 : yy_bp = yytext_ptr + YY_MORE_ADJ;
1157 42 : goto yy_find_action;
1158 : }
1159 0 : break;
1160 : }
1161 :
1162 : default:
1163 0 : YY_FATAL_ERROR(
1164 : "fatal flex scanner internal error--no action found" );
1165 : } /* end of action switch */
1166 122 : } /* end of scanning one token */
1167 : } /* end of yylex */
1168 :
1169 :
1170 : /* yy_get_next_buffer - try to read in a new buffer
1171 : *
1172 : * Returns a code representing an action:
1173 : * EOB_ACT_LAST_MATCH -
1174 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1175 : * EOB_ACT_END_OF_FILE - end of file
1176 : */
1177 :
1178 : static int yy_get_next_buffer(TSRMLS_D)
1179 40644 : {
1180 40644 : register char *dest = yy_current_buffer->yy_ch_buf;
1181 40644 : register char *source = yytext_ptr;
1182 : register int number_to_move, i;
1183 : int ret_val;
1184 :
1185 40644 : if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars) + 1] )
1186 0 : YY_FATAL_ERROR(
1187 : "fatal flex scanner internal error--end of buffer missed" );
1188 :
1189 40644 : if ( yy_current_buffer->yy_fill_buffer == 0 )
1190 : { /* Don't try to fill the buffer, so this is an EOF. */
1191 13546 : if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1192 : {
1193 : /* We matched a single character, the EOB, so
1194 : * treat this as a final EOF.
1195 : */
1196 13546 : return EOB_ACT_END_OF_FILE;
1197 : }
1198 :
1199 : else
1200 : {
1201 : /* We matched some text prior to the EOB, first
1202 : * process it.
1203 : */
1204 0 : return EOB_ACT_LAST_MATCH;
1205 : }
1206 : }
1207 :
1208 : /* Try to read more data. */
1209 :
1210 : /* First move last chars to start of buffer. */
1211 27098 : number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1212 :
1213 27297 : for ( i = 0; i < number_to_move; ++i )
1214 199 : *(dest++) = *(source++);
1215 :
1216 27098 : if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1217 : /* don't do the read, it's not guaranteed to return an EOF,
1218 : * just force an EOF
1219 : */
1220 42 : yy_current_buffer->yy_n_chars = SCNG(yy_n_chars) = 0;
1221 :
1222 : else
1223 : {
1224 : int num_to_read =
1225 27056 : yy_current_buffer->yy_buf_size - number_to_move - 1;
1226 :
1227 54112 : while ( num_to_read <= 0 )
1228 : { /* Not enough room in the buffer - grow it. */
1229 : #ifdef YY_USES_REJECT
1230 : YY_FATAL_ERROR(
1231 : "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1232 : #else
1233 :
1234 : /* just a shorter name for the current buffer */
1235 0 : YY_BUFFER_STATE b = yy_current_buffer;
1236 :
1237 : int yy_c_buf_p_offset =
1238 0 : (int) (yy_c_buf_p - b->yy_ch_buf);
1239 :
1240 0 : if ( b->yy_is_our_buffer )
1241 : {
1242 0 : int new_size = b->yy_buf_size * 2;
1243 :
1244 0 : if ( new_size <= 0 )
1245 0 : b->yy_buf_size += b->yy_buf_size / 8;
1246 : else
1247 0 : b->yy_buf_size *= 2;
1248 :
1249 0 : b->yy_ch_buf = (char *)
1250 : /* Include room in for 2 EOB chars. */
1251 : yy_flex_realloc( (void *) b->yy_ch_buf,
1252 : b->yy_buf_size + 2 );
1253 : }
1254 : else
1255 : /* Can't grow it, we don't own it. */
1256 0 : b->yy_ch_buf = 0;
1257 :
1258 0 : if ( ! b->yy_ch_buf )
1259 0 : YY_FATAL_ERROR(
1260 : "fatal error - scanner input buffer overflow" );
1261 :
1262 0 : yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1263 :
1264 0 : num_to_read = yy_current_buffer->yy_buf_size -
1265 : number_to_move - 1;
1266 : #endif
1267 : }
1268 :
1269 27056 : if ( num_to_read > YY_READ_BUF_SIZE )
1270 27056 : num_to_read = YY_READ_BUF_SIZE;
1271 :
1272 : /* Read in more data. */
1273 27056 : YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1274 : SCNG(yy_n_chars), num_to_read );
1275 :
1276 27056 : yy_current_buffer->yy_n_chars = SCNG(yy_n_chars);
1277 : }
1278 :
1279 27098 : if ( SCNG(yy_n_chars) == 0 )
1280 : {
1281 13569 : if ( number_to_move == YY_MORE_ADJ )
1282 : {
1283 13527 : ret_val = EOB_ACT_END_OF_FILE;
1284 13527 : yyrestart( SCNG(yy_in) TSRMLS_CC );
1285 : }
1286 :
1287 : else
1288 : {
1289 42 : ret_val = EOB_ACT_LAST_MATCH;
1290 42 : yy_current_buffer->yy_buffer_status =
1291 : YY_BUFFER_EOF_PENDING;
1292 : }
1293 : }
1294 :
1295 : else
1296 13529 : ret_val = EOB_ACT_CONTINUE_SCAN;
1297 :
1298 27098 : SCNG(yy_n_chars) += number_to_move;
1299 27098 : yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1300 27098 : yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1301 :
1302 27098 : yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1303 :
1304 27098 : return ret_val;
1305 : }
1306 :
1307 :
1308 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1309 :
1310 : static yy_state_type yy_get_previous_state(TSRMLS_D)
1311 13575 : {
1312 : register yy_state_type yy_current_state;
1313 : register char *yy_cp;
1314 :
1315 13575 : yy_current_state = yy_start;
1316 :
1317 13806 : for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1318 : {
1319 231 : register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1320 231 : if ( yy_accept[yy_current_state] )
1321 : {
1322 185 : yy_last_accepting_state = yy_current_state;
1323 185 : yy_last_accepting_cpos = yy_cp;
1324 : }
1325 629 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1326 : {
1327 167 : yy_current_state = (int) yy_def[yy_current_state];
1328 167 : if ( yy_current_state >= 63 )
1329 167 : yy_c = yy_meta[(unsigned int) yy_c];
1330 : }
1331 231 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1332 : }
1333 :
1334 13575 : return yy_current_state;
1335 : }
1336 :
1337 :
1338 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1339 : *
1340 : * synopsis
1341 : * next_state = yy_try_NUL_trans( current_state );
1342 : */
1343 :
1344 : #ifdef YY_USE_PROTOS
1345 : static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state TSRMLS_DC )
1346 : #else
1347 : static yy_state_type yy_try_NUL_trans( yy_current_state TSRMLS_CC )
1348 : yy_state_type yy_current_state;
1349 : #ifdef ZTS
1350 : void ***tsrm_ls;
1351 : #endif
1352 : #endif
1353 4 : {
1354 : register int yy_is_jam;
1355 4 : register char *yy_cp = yy_c_buf_p;
1356 :
1357 4 : register YY_CHAR yy_c = 1;
1358 4 : if ( yy_accept[yy_current_state] )
1359 : {
1360 4 : yy_last_accepting_state = yy_current_state;
1361 4 : yy_last_accepting_cpos = yy_cp;
1362 : }
1363 12 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1364 : {
1365 4 : yy_current_state = (int) yy_def[yy_current_state];
1366 4 : if ( yy_current_state >= 63 )
1367 4 : yy_c = yy_meta[(unsigned int) yy_c];
1368 : }
1369 4 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1370 4 : yy_is_jam = (yy_current_state == 62);
1371 :
1372 4 : return yy_is_jam ? 0 : yy_current_state;
1373 : }
1374 :
1375 :
1376 : #ifndef YY_NO_UNPUT
1377 : #ifdef YY_USE_PROTOS
1378 : static void yyunput( int c, register char *yy_bp TSRMLS_DC )
1379 : #else
1380 : static void yyunput( c, yy_bp TSRMLS_CC )
1381 : int c;
1382 : register char *yy_bp;
1383 : #ifdef ZTS
1384 : void ***tsrm_ls;
1385 : #endif
1386 : #endif
1387 0 : {
1388 0 : register char *yy_cp = yy_c_buf_p;
1389 :
1390 : /* undo effects of setting up yytext */
1391 0 : *yy_cp = yy_hold_char;
1392 :
1393 0 : if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1394 : { /* need to shift things up to make room */
1395 : /* +2 for EOB chars. */
1396 0 : register int number_to_move = SCNG(yy_n_chars) + 2;
1397 : register char *dest = &yy_current_buffer->yy_ch_buf[
1398 0 : yy_current_buffer->yy_buf_size + 2];
1399 : register char *source =
1400 0 : &yy_current_buffer->yy_ch_buf[number_to_move];
1401 :
1402 0 : while ( source > yy_current_buffer->yy_ch_buf )
1403 0 : *--dest = *--source;
1404 :
1405 0 : yy_cp += (int) (dest - source);
1406 0 : yy_bp += (int) (dest - source);
1407 0 : yy_current_buffer->yy_n_chars =
1408 : SCNG(yy_n_chars) = yy_current_buffer->yy_buf_size;
1409 :
1410 0 : if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1411 0 : YY_FATAL_ERROR( "flex scanner push-back overflow" );
1412 : }
1413 :
1414 0 : *--yy_cp = (char) c;
1415 :
1416 :
1417 0 : yytext_ptr = yy_bp;
1418 0 : yy_hold_char = *yy_cp;
1419 0 : yy_c_buf_p = yy_cp;
1420 0 : }
1421 : #endif /* ifndef YY_NO_UNPUT */
1422 :
1423 :
1424 : #ifdef __cplusplus
1425 : static int yyinput(TSRMLS_D)
1426 : #else
1427 : static int input(TSRMLS_C)
1428 : #ifdef ZTS
1429 : void ***tsrm_ls;
1430 : #endif
1431 : #endif
1432 0 : {
1433 : int c;
1434 :
1435 0 : *yy_c_buf_p = yy_hold_char;
1436 :
1437 0 : if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1438 : {
1439 : /* yy_c_buf_p now points to the character we want to return.
1440 : * If this occurs *before* the EOB characters, then it's a
1441 : * valid NUL; if not, then we've hit the end of the buffer.
1442 : */
1443 0 : if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] )
1444 : /* This was really a NUL. */
1445 0 : *yy_c_buf_p = '\0';
1446 :
1447 : else
1448 : { /* need more input */
1449 0 : int offset = yy_c_buf_p - yytext_ptr;
1450 0 : ++yy_c_buf_p;
1451 :
1452 0 : switch ( yy_get_next_buffer(TSRMLS_C) )
1453 : {
1454 : case EOB_ACT_LAST_MATCH:
1455 : /* This happens because yy_g_n_b()
1456 : * sees that we've accumulated a
1457 : * token and flags that we need to
1458 : * try matching the token before
1459 : * proceeding. But for input(),
1460 : * there's no matching to consider.
1461 : * So convert the EOB_ACT_LAST_MATCH
1462 : * to EOB_ACT_END_OF_FILE.
1463 : */
1464 :
1465 : /* Reset buffer status. */
1466 0 : yyrestart( SCNG(yy_in) TSRMLS_CC );
1467 :
1468 : /* fall through */
1469 :
1470 : case EOB_ACT_END_OF_FILE:
1471 : {
1472 : if ( yywrap() )
1473 0 : return EOF;
1474 :
1475 : if ( ! yy_did_buffer_switch_on_eof )
1476 : YY_NEW_FILE;
1477 : #ifdef __cplusplus
1478 : return yyinput(TSRMLS_C);
1479 : #else
1480 : return input(TSRMLS_C);
1481 : #endif
1482 : }
1483 :
1484 : case EOB_ACT_CONTINUE_SCAN:
1485 0 : yy_c_buf_p = yytext_ptr + offset;
1486 : break;
1487 : }
1488 : }
1489 : }
1490 :
1491 0 : c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1492 0 : *yy_c_buf_p = '\0'; /* preserve yytext */
1493 0 : yy_hold_char = *++yy_c_buf_p;
1494 :
1495 :
1496 0 : return c;
1497 : }
1498 :
1499 :
1500 : #ifdef YY_USE_PROTOS
1501 : void yyrestart( struct _zend_file_handle *input_file TSRMLS_DC )
1502 : #else
1503 : void yyrestart( input_file TSRMLS_CC )
1504 : struct _zend_file_handle *input_file;
1505 : #endif
1506 13527 : {
1507 13527 : if ( ! yy_current_buffer )
1508 0 : yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC );
1509 :
1510 13527 : yy_init_buffer( yy_current_buffer, input_file TSRMLS_CC );
1511 13527 : yy_load_buffer_state(TSRMLS_C);
1512 13527 : }
1513 :
1514 :
1515 : #ifdef YY_USE_PROTOS
1516 : void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC)
1517 : #else
1518 : void yy_switch_to_buffer( new_buffer TSRMLS_CC)
1519 : YY_BUFFER_STATE new_buffer;
1520 : #ifdef ZTS
1521 : void ***tsrm_ls;
1522 : #endif
1523 : #endif
1524 27075 : {
1525 27075 : if ( yy_current_buffer == new_buffer )
1526 0 : return;
1527 :
1528 27075 : if ( yy_current_buffer )
1529 : {
1530 : /* Flush out information for old buffer. */
1531 2 : *yy_c_buf_p = yy_hold_char;
1532 2 : yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1533 2 : yy_current_buffer->yy_n_chars = SCNG(yy_n_chars);
1534 : }
1535 :
1536 27075 : yy_current_buffer = new_buffer;
1537 27075 : yy_load_buffer_state(TSRMLS_C);
1538 :
1539 : /* We don't actually know whether we did this switch during
1540 : * EOF (yywrap()) processing, but the only time this flag
1541 : * is looked at is after yywrap() is called, so it's safe
1542 : * to go ahead and always set it.
1543 : */
1544 27075 : yy_did_buffer_switch_on_eof = 1;
1545 : }
1546 :
1547 :
1548 : #ifdef YY_USE_PROTOS
1549 : void yy_load_buffer_state( TSRMLS_D )
1550 : #else
1551 : void yy_load_buffer_state(TSRMLS_C)
1552 : #ifdef ZTS
1553 : void ***tsrm_ls;
1554 : #endif
1555 : #endif
1556 67675 : {
1557 67675 : SCNG(yy_n_chars) = yy_current_buffer->yy_n_chars;
1558 67675 : yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1559 67675 : SCNG(yy_in) = yy_current_buffer->yy_input_file;
1560 67675 : yy_hold_char = *yy_c_buf_p;
1561 67675 : }
1562 :
1563 :
1564 : #ifdef YY_USE_PROTOS
1565 : YY_BUFFER_STATE yy_create_buffer( struct _zend_file_handle *file, int size TSRMLS_DC )
1566 : #else
1567 : YY_BUFFER_STATE yy_create_buffer( file, size TSRMLS_CC )
1568 : struct _zend_file_handle *file;
1569 : int size;
1570 : #ifdef ZTS
1571 : void ***tsrm_ls;
1572 : #endif
1573 : #endif
1574 13529 : {
1575 : YY_BUFFER_STATE b;
1576 :
1577 13529 : b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1578 13529 : if ( ! b )
1579 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1580 :
1581 13529 : b->yy_buf_size = size;
1582 :
1583 : /* yy_ch_buf has to be 2 characters longer than the size given because
1584 : * we need to put in 2 end-of-buffer characters.
1585 : */
1586 13529 : b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1587 13529 : if ( ! b->yy_ch_buf )
1588 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1589 :
1590 13529 : b->yy_is_our_buffer = 1;
1591 :
1592 13529 : yy_init_buffer( b, file TSRMLS_CC );
1593 :
1594 13529 : return b;
1595 : }
1596 :
1597 :
1598 : #ifdef YY_USE_PROTOS
1599 : void yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
1600 : #else
1601 : void yy_delete_buffer( b TSRMLS_CC )
1602 : YY_BUFFER_STATE b;
1603 : #ifdef ZTS
1604 : void ***tsrm_ls;
1605 : #endif
1606 : #endif
1607 27073 : {
1608 27073 : if ( ! b )
1609 0 : return;
1610 :
1611 27073 : if ( b == yy_current_buffer )
1612 27073 : yy_current_buffer = (YY_BUFFER_STATE) 0;
1613 :
1614 27073 : if ( b->yy_is_our_buffer )
1615 13527 : yy_flex_free( (void *) b->yy_ch_buf );
1616 :
1617 27073 : yy_flex_free( (void *) b );
1618 : }
1619 :
1620 :
1621 :
1622 : #ifdef YY_USE_PROTOS
1623 : void yy_init_buffer( YY_BUFFER_STATE b, struct _zend_file_handle *file TSRMLS_DC )
1624 : #else
1625 : void yy_init_buffer( b, file TSRMLS_CC )
1626 : YY_BUFFER_STATE b;
1627 : struct _zend_file_handle *file;
1628 : #ifdef ZTS
1629 : void ***tsrm_ls;
1630 : #endif
1631 : #endif
1632 :
1633 :
1634 27056 : {
1635 27056 : yy_flush_buffer( b TSRMLS_CC );
1636 :
1637 27056 : b->yy_input_file = file;
1638 27056 : b->yy_fill_buffer = 1;
1639 :
1640 : #if YY_ALWAYS_INTERACTIVE
1641 : b->yy_is_interactive = 1;
1642 : #else
1643 : #if YY_NEVER_INTERACTIVE
1644 27056 : b->yy_is_interactive = 0;
1645 : #else
1646 : b->yy_is_interactive = file->handle.stream.interactive;
1647 : #endif
1648 : #endif
1649 27056 : }
1650 :
1651 :
1652 : #ifdef YY_USE_PROTOS
1653 : void yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
1654 : #else
1655 : void yy_flush_buffer( b TSRMLS_CC )
1656 : YY_BUFFER_STATE b;
1657 : #ifdef ZTS
1658 : void ***tsrm_ls;
1659 : #endif
1660 : #endif
1661 :
1662 27056 : {
1663 27056 : if ( ! b )
1664 0 : return;
1665 :
1666 27056 : b->yy_n_chars = 0;
1667 :
1668 : /* We always need two end-of-buffer characters. The first causes
1669 : * a transition to the end-of-buffer state. The second causes
1670 : * a jam in that state.
1671 : */
1672 27056 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1673 27056 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1674 :
1675 27056 : b->yy_buf_pos = &b->yy_ch_buf[0];
1676 :
1677 27056 : b->yy_at_bol = 1;
1678 27056 : b->yy_buffer_status = YY_BUFFER_NEW;
1679 :
1680 27056 : if ( b == yy_current_buffer )
1681 13527 : yy_load_buffer_state(TSRMLS_C);
1682 : }
1683 :
1684 :
1685 : #ifndef YY_NO_SCAN_BUFFER
1686 : #ifdef YY_USE_PROTOS
1687 : YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size TSRMLS_DC )
1688 : #else
1689 : YY_BUFFER_STATE yy_scan_buffer( base, size TSRMLS_CC )
1690 : char *base;
1691 : yy_size_t size;
1692 : #ifdef ZTS
1693 : void ***tsrm_ls;
1694 : #endif
1695 : #endif
1696 13546 : {
1697 : YY_BUFFER_STATE b;
1698 :
1699 13546 : if ( size < 2 ||
1700 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
1701 : base[size-1] != YY_END_OF_BUFFER_CHAR )
1702 : /* They forgot to leave room for the EOB's. */
1703 0 : return 0;
1704 :
1705 13546 : b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1706 13546 : if ( ! b )
1707 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1708 :
1709 13546 : b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1710 13546 : b->yy_buf_pos = b->yy_ch_buf = base;
1711 13546 : b->yy_is_our_buffer = 0;
1712 13546 : b->yy_input_file = 0;
1713 13546 : b->yy_n_chars = b->yy_buf_size;
1714 13546 : b->yy_is_interactive = 0;
1715 13546 : b->yy_at_bol = 1;
1716 13546 : b->yy_fill_buffer = 0;
1717 13546 : b->yy_buffer_status = YY_BUFFER_NEW;
1718 :
1719 13546 : yy_switch_to_buffer( b TSRMLS_CC );
1720 :
1721 13546 : return b;
1722 : }
1723 : #endif
1724 :
1725 :
1726 : #ifndef YY_NO_SCAN_STRING
1727 : #ifdef YY_USE_PROTOS
1728 : YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str TSRMLS_DC )
1729 : #else
1730 : YY_BUFFER_STATE yy_scan_string( yy_str TSRMLS_CC )
1731 : yyconst char *yy_str;
1732 : #ifdef ZTS
1733 : void ***tsrm_ls;
1734 : #endif
1735 : #endif
1736 0 : {
1737 : int len;
1738 0 : for ( len = 0; yy_str[len]; ++len )
1739 : ;
1740 :
1741 0 : return yy_scan_bytes( yy_str, len TSRMLS_CC );
1742 : }
1743 : #endif
1744 :
1745 :
1746 : #ifndef YY_NO_SCAN_BYTES
1747 : #ifdef YY_USE_PROTOS
1748 : YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len TSRMLS_DC )
1749 : #else
1750 : YY_BUFFER_STATE yy_scan_bytes( bytes, len TSRMLS_CC )
1751 : yyconst char *bytes;
1752 : int len;
1753 : #ifdef ZTS
1754 : void ***tsrm_ls;
1755 : #endif
1756 : #endif
1757 0 : {
1758 : YY_BUFFER_STATE b;
1759 : char *buf;
1760 : yy_size_t n;
1761 : int i;
1762 :
1763 : /* Get memory for full buffer, including space for trailing EOB's. */
1764 0 : n = len + 2;
1765 0 : buf = (char *) yy_flex_alloc( n );
1766 0 : if ( ! buf )
1767 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1768 :
1769 0 : for ( i = 0; i < len; ++i )
1770 0 : buf[i] = bytes[i];
1771 :
1772 0 : buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1773 :
1774 0 : b = yy_scan_buffer( buf, n TSRMLS_CC);
1775 0 : if ( ! b )
1776 0 : YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1777 :
1778 : /* It's okay to grow etc. this buffer, and we should throw it
1779 : * away when we're done.
1780 : */
1781 0 : b->yy_is_our_buffer = 1;
1782 :
1783 0 : return b;
1784 : }
1785 : #endif
1786 :
1787 :
1788 : #ifndef YY_NO_PUSH_STATE
1789 : #ifdef YY_USE_PROTOS
1790 : static void yy_push_state( int new_state TSRMLS_DC )
1791 : #else
1792 : static void yy_push_state( new_state TSRMLS_CC )
1793 : int new_state;
1794 : #ifdef ZTS
1795 : void ***tsrm_ls;
1796 : #endif
1797 : #endif
1798 : {
1799 : if ( yy_start_stack_ptr >= yy_start_stack_depth )
1800 : {
1801 : yy_size_t new_size;
1802 :
1803 : yy_start_stack_depth += YY_START_STACK_INCR;
1804 : new_size = yy_start_stack_depth * sizeof( int );
1805 :
1806 : if ( ! yy_start_stack )
1807 : yy_start_stack = (int *) yy_flex_alloc( new_size );
1808 :
1809 : else
1810 : yy_start_stack = (int *) yy_flex_realloc(
1811 : (void *) yy_start_stack, new_size );
1812 :
1813 : if ( ! yy_start_stack )
1814 : YY_FATAL_ERROR(
1815 : "out of memory expanding start-condition stack" );
1816 : }
1817 :
1818 : yy_start_stack[yy_start_stack_ptr++] = YY_START;
1819 :
1820 : BEGIN(new_state);
1821 : }
1822 : #endif
1823 :
1824 :
1825 : #ifndef YY_NO_POP_STATE
1826 : static void yy_pop_state(TSRMLS_D)
1827 : {
1828 : if ( --yy_start_stack_ptr < 0 )
1829 : YY_FATAL_ERROR( "start-condition stack underflow" );
1830 :
1831 : BEGIN(yy_start_stack[yy_start_stack_ptr]);
1832 : }
1833 : #endif
1834 :
1835 :
1836 : #ifndef YY_NO_TOP_STATE
1837 : static int yy_top_state(TSRMLS_D)
1838 : {
1839 : return yy_start_stack[yy_start_stack_ptr - 1];
1840 : }
1841 : #endif
1842 :
1843 : #ifndef YY_EXIT_FAILURE
1844 : #define YY_EXIT_FAILURE 2
1845 : #endif
1846 :
1847 : #ifdef YY_USE_PROTOS
1848 : static void yy_fatal_error( yyconst char msg[] )
1849 : #else
1850 : static void yy_fatal_error( msg )
1851 : char msg[];
1852 : #endif
1853 0 : {
1854 0 : (void) fprintf( stderr, "%s\n", msg );
1855 0 : exit( YY_EXIT_FAILURE );
1856 : }
1857 :
1858 :
1859 :
1860 : /* Redefine yyless() so it works in section 3 code. */
1861 :
1862 : #undef yyless
1863 : #define yyless(n) \
1864 : do \
1865 : { \
1866 : /* Undo effects of setting up yytext. */ \
1867 : yytext[yyleng] = yy_hold_char; \
1868 : yy_c_buf_p = yytext + n; \
1869 : yy_hold_char = *yy_c_buf_p; \
1870 : *yy_c_buf_p = '\0'; \
1871 : yyleng = n; \
1872 : } \
1873 : while ( 0 )
1874 :
1875 :
1876 : /* Internal utility routines. */
1877 :
1878 : #ifndef yytext_ptr
1879 : #ifdef YY_USE_PROTOS
1880 : static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1881 : #else
1882 : static void yy_flex_strncpy( s1, s2, n )
1883 : char *s1;
1884 : yyconst char *s2;
1885 : int n;
1886 : #endif
1887 : {
1888 : register int i;
1889 : for ( i = 0; i < n; ++i )
1890 : s1[i] = s2[i];
1891 : }
1892 : #endif
1893 :
1894 : #ifdef YY_NEED_STRLEN
1895 : #ifdef YY_USE_PROTOS
1896 : static int yy_flex_strlen( yyconst char *s )
1897 : #else
1898 : static int yy_flex_strlen( s )
1899 : yyconst char *s;
1900 : #endif
1901 : {
1902 : register int n;
1903 : for ( n = 0; s[n]; ++n )
1904 : ;
1905 :
1906 : return n;
1907 : }
1908 : #endif
1909 :
1910 :
1911 : #ifdef YY_USE_PROTOS
1912 : static void *yy_flex_alloc( yy_size_t size )
1913 : #else
1914 : static void *yy_flex_alloc( size )
1915 : yy_size_t size;
1916 : #endif
1917 40604 : {
1918 40604 : return (void *) malloc( size );
1919 : }
1920 :
1921 : #ifdef YY_USE_PROTOS
1922 : static void *yy_flex_realloc( void *ptr, yy_size_t size )
1923 : #else
1924 : static void *yy_flex_realloc( ptr, size )
1925 : void *ptr;
1926 : yy_size_t size;
1927 : #endif
1928 0 : {
1929 : /* The cast to (char *) in the following accommodates both
1930 : * implementations that use char* generic pointers, and those
1931 : * that use void* generic pointers. It works with the latter
1932 : * because both ANSI C and C++ allow castless assignment from
1933 : * any pointer type to void*, and deal with argument conversions
1934 : * as though doing an assignment.
1935 : */
1936 0 : return (void *) realloc( (char *) ptr, size );
1937 : }
1938 :
1939 : #ifdef YY_USE_PROTOS
1940 : static void yy_flex_free( void *ptr )
1941 : #else
1942 : static void yy_flex_free( ptr )
1943 : void *ptr;
1944 : #endif
1945 40600 : {
1946 40600 : free( ptr );
1947 40600 : }
1948 :
1949 : #if YY_MAIN
1950 : int main()
1951 : {
1952 : yylex();
1953 : return 0;
1954 : }
1955 : #endif
1956 : #line 252 "/var/php_gcov/PHP_5_2/Zend/zend_ini_scanner.l"
|
