1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Zeev Suraski <zeev@php.net> |
16 | Jani Taskinen <jani@php.net> |
17 | Marcus Boerger <helly@php.net> |
18 | Nuno Lopes <nlopess@php.net> |
19 | Scott MacVicar <scottmac@php.net> |
20 +----------------------------------------------------------------------+
21 */
22
23 #include <errno.h>
24 #include "zend.h"
25 #include "zend_API.h"
26 #include "zend_globals.h"
27 #include <zend_ini_parser.h>
28 #include "zend_ini_scanner.h"
29
30 #ifdef YYDEBUG
31 #undef YYDEBUG
32 #endif
33
34 #if 0
35 # define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
36 #else
37 # define YYDEBUG(s, c)
38 #endif
39
40 #include "zend_ini_scanner_defs.h"
41
42 #define YYCTYPE unsigned char
43 /* allow the scanner to read one null byte after the end of the string (from ZEND_MMAP_AHEAD)
44 * so that if will be able to terminate to match the current token (e.g. non-enclosed string) */
45 #define YYFILL(n) { if (YYCURSOR > YYLIMIT) return 0; }
46 #define YYCURSOR SCNG(yy_cursor)
47 #define YYLIMIT SCNG(yy_limit)
48 #define YYMARKER SCNG(yy_marker)
49
50 #define YYGETCONDITION() SCNG(yy_state)
51 #define YYSETCONDITION(s) SCNG(yy_state) = s
52
53 #define STATE(name) yyc##name
54
55 /* emulate flex constructs */
56 #define BEGIN(state) YYSETCONDITION(STATE(state))
57 #define YYSTATE YYGETCONDITION()
58 #define yytext ((const char*)SCNG(yy_text))
59 #define yyleng SCNG(yy_leng)
60 #define yyless(x) do { YYCURSOR = (const unsigned char*)yytext + x; \
61 yyleng = (unsigned int)x; } while(0)
62
63 /* #define yymore() goto yymore_restart */
64
65 /* perform sanity check. If this message is triggered you should
66 increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
67 /*!max:re2c */
68 #if ZEND_MMAP_AHEAD < (YYMAXFILL + 1)
69 # error ZEND_MMAP_AHEAD should be greater than YYMAXFILL
70 #endif
71
72
73 /* How it works (for the core ini directives):
74 * ===========================================
75 *
76 * 1. Scanner scans file for tokens and passes them to parser.
77 * 2. Parser parses the tokens and passes the name/value pairs to the callback
78 * function which stores them in the configuration hash table.
79 * 3. Later REGISTER_INI_ENTRIES() is called which triggers the actual
80 * registering of ini entries and uses zend_get_configuration_directive()
81 * to fetch the previously stored name/value pair from configuration hash table
82 * and registers the static ini entries which match the name to the value
83 * into EG(ini_directives) hash table.
84 * 4. PATH section entries are used per-request from down to top, each overriding
85 * previous if one exists. zend_alter_ini_entry() is called for each entry.
86 * Settings in PATH section are ZEND_INI_SYSTEM accessible and thus mimics the
87 * php_admin_* directives used within Apache httpd.conf when PHP is compiled as
88 * module for Apache.
89 * 5. User defined ini files (like .htaccess for apache) are parsed for each request and
90 * stored in separate hash defined by SAPI.
91 */
92
93 /* TODO: (ordered by importance :-)
94 * ===============================================================================
95 *
96 * - Separate constant lookup totally from plain strings (using CONSTANT pattern)
97 * - Add #if .. #else .. #endif and ==, !=, <, > , <=, >= operators
98 * - Add #include "some.ini"
99 * - Allow variables to refer to options also when using parse_ini_file()
100 *
101 */
102
103 /* Globals Macros */
104 #define SCNG INI_SCNG
105 #ifdef ZTS
106 ZEND_API ts_rsrc_id ini_scanner_globals_id;
107 ZEND_API size_t ini_scanner_globals_offset;
108 #else
109 ZEND_API zend_ini_scanner_globals ini_scanner_globals;
110 #endif
111
112 #define ZEND_SYSTEM_INI CG(ini_parser_unbuffered_errors)
113
114 /* Eat leading whitespace */
115 #define EAT_LEADING_WHITESPACE() \
116 while (yyleng) { \
117 if (yytext[0] == ' ' || yytext[0] == '\t') { \
118 SCNG(yy_text)++; \
119 yyleng--; \
120 } else { \
121 break; \
122 } \
123 }
124
125 /* Eat trailing whitespace + extra char */
126 #define EAT_TRAILING_WHITESPACE_EX(ch) \
127 while (yyleng && ( \
128 (ch != 'X' && yytext[yyleng - 1] == ch) || \
129 yytext[yyleng - 1] == '\n' || \
130 yytext[yyleng - 1] == '\r' || \
131 yytext[yyleng - 1] == '\t' || \
132 yytext[yyleng - 1] == ' ') \
133 ) { \
134 yyleng--; \
135 }
136
137 /* Eat trailing whitespace */
138 #define EAT_TRAILING_WHITESPACE() EAT_TRAILING_WHITESPACE_EX('X')
139
140 #define zend_ini_copy_value(retval, str, len) \
141 ZVAL_NEW_STR(retval, zend_string_init(str, len, ZEND_SYSTEM_INI))
142
143
144 #define RETURN_TOKEN(type, str, len) { \
145 if (SCNG(scanner_mode) == ZEND_INI_SCANNER_TYPED && \
146 (YYSTATE == STATE(ST_VALUE) || YYSTATE == STATE(ST_RAW))) {\
147 zend_ini_copy_typed_value(ini_lval, type, str, len); \
148 Z_EXTRA_P(ini_lval) = 0; \
149 } else { \
150 zend_ini_copy_value(ini_lval, str, len); \
151 } \
152 return type; \
153 }
154
zend_ini_copy_typed_value(zval * retval,const int type,const char * str,int len)155 static void zend_ini_copy_typed_value(zval *retval, const int type, const char *str, int len)
156 {
157 switch (type) {
158 case BOOL_FALSE:
159 case BOOL_TRUE:
160 ZVAL_BOOL(retval, type == BOOL_TRUE);
161 break;
162
163 case NULL_NULL:
164 ZVAL_NULL(retval);
165 break;
166
167 default:
168 zend_ini_copy_value(retval, str, len);
169 }
170 }
171
_yy_push_state(int new_state)172 static void _yy_push_state(int new_state)
173 {
174 zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION());
175 YYSETCONDITION(new_state);
176 }
177
178 #define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
179
yy_pop_state(void)180 static void yy_pop_state(void)
181 {
182 int *stack_state = zend_stack_top(&SCNG(state_stack));
183 YYSETCONDITION(*stack_state);
184 zend_stack_del_top(&SCNG(state_stack));
185 }
186
yy_scan_buffer(const char * str,unsigned int len)187 static void yy_scan_buffer(const char *str, unsigned int len)
188 {
189 YYCURSOR = (const YYCTYPE*)str;
190 SCNG(yy_start) = YYCURSOR;
191 YYLIMIT = YYCURSOR + len;
192 }
193
194 #define ini_filename SCNG(filename)
195
196 /* {{{ init_ini_scanner() */
init_ini_scanner(int scanner_mode,zend_file_handle * fh)197 static zend_result init_ini_scanner(int scanner_mode, zend_file_handle *fh)
198 {
199 /* Sanity check */
200 if (scanner_mode != ZEND_INI_SCANNER_NORMAL && scanner_mode != ZEND_INI_SCANNER_RAW && scanner_mode != ZEND_INI_SCANNER_TYPED) {
201 zend_error(E_WARNING, "Invalid scanner mode");
202 return FAILURE;
203 }
204
205 SCNG(lineno) = 1;
206 SCNG(scanner_mode) = scanner_mode;
207 SCNG(yy_in) = fh;
208
209 if (fh != NULL) {
210 ini_filename = zend_string_copy(fh->filename);
211 } else {
212 ini_filename = NULL;
213 }
214
215 zend_stack_init(&SCNG(state_stack), sizeof(int));
216 BEGIN(INITIAL);
217
218 return SUCCESS;
219 }
220 /* }}} */
221
222 /* {{{ shutdown_ini_scanner() */
shutdown_ini_scanner(void)223 void shutdown_ini_scanner(void)
224 {
225 zend_stack_destroy(&SCNG(state_stack));
226 if (ini_filename) {
227 zend_string_release(ini_filename);
228 }
229 }
230 /* }}} */
231
232 /* {{{ zend_ini_scanner_get_lineno() */
zend_ini_scanner_get_lineno(void)233 ZEND_COLD int zend_ini_scanner_get_lineno(void)
234 {
235 return SCNG(lineno);
236 }
237 /* }}} */
238
239 /* {{{ zend_ini_scanner_get_filename() */
zend_ini_scanner_get_filename(void)240 ZEND_COLD const char *zend_ini_scanner_get_filename(void)
241 {
242 return ini_filename ? ZSTR_VAL(ini_filename) : "Unknown";
243 }
244 /* }}} */
245
246 /* {{{ zend_ini_open_file_for_scanning() */
zend_ini_open_file_for_scanning(zend_file_handle * fh,int scanner_mode)247 zend_result zend_ini_open_file_for_scanning(zend_file_handle *fh, int scanner_mode)
248 {
249 char *buf;
250 size_t size;
251
252 if (zend_stream_fixup(fh, &buf, &size) == FAILURE) {
253 return FAILURE;
254 }
255
256 if (init_ini_scanner(scanner_mode, fh) == FAILURE) {
257 return FAILURE;
258 }
259
260 yy_scan_buffer(buf, (unsigned int)size);
261
262 return SUCCESS;
263 }
264 /* }}} */
265
266 /* {{{ zend_ini_prepare_string_for_scanning() */
zend_ini_prepare_string_for_scanning(const char * str,int scanner_mode)267 zend_result zend_ini_prepare_string_for_scanning(const char *str, int scanner_mode)
268 {
269 int len = (int)strlen(str);
270
271 if (init_ini_scanner(scanner_mode, NULL) == FAILURE) {
272 return FAILURE;
273 }
274
275 yy_scan_buffer(str, len);
276
277 return SUCCESS;
278 }
279 /* }}} */
280
281 /* {{{ zend_ini_escape_string() */
zend_ini_escape_string(zval * lval,const char * str,int len,char quote_type)282 static void zend_ini_escape_string(zval *lval, const char *str, int len, char quote_type)
283 {
284 char *s, *t;
285 char *end;
286
287 zend_ini_copy_value(lval, str, len);
288
289 /* convert escape sequences */
290 s = t = Z_STRVAL_P(lval);
291 end = s + Z_STRLEN_P(lval);
292
293 while (s < end) {
294 if (*s == '\\') {
295 s++;
296 if (s >= end) {
297 *t++ = '\\';
298 continue;
299 }
300 switch (*s) {
301 case '"':
302 if (*s != quote_type) {
303 *t++ = '\\';
304 *t++ = *s;
305 break;
306 }
307 ZEND_FALLTHROUGH;
308 case '\\':
309 case '$':
310 *t++ = *s;
311 Z_STRLEN_P(lval)--;
312 break;
313 default:
314 *t++ = '\\';
315 *t++ = *s;
316 break;
317 }
318 } else {
319 *t++ = *s;
320 }
321 if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
322 SCNG(lineno)++;
323 }
324 s++;
325 }
326 *t = 0;
327 }
328 /* }}} */
329
ini_lex(zval * ini_lval)330 int ini_lex(zval *ini_lval)
331 {
332 restart:
333 SCNG(yy_text) = YYCURSOR;
334
335 /* yymore_restart: */
336 /* detect EOF */
337 if (YYCURSOR >= YYLIMIT) {
338 if (YYSTATE == STATE(ST_VALUE) || YYSTATE == STATE(ST_RAW)) {
339 BEGIN(INITIAL);
340 return END_OF_LINE;
341 }
342 return 0;
343 }
344
345 /* Eat any UTF-8 BOM we find in the first 3 bytes */
346 if (YYCURSOR == SCNG(yy_start) && YYCURSOR + 3 < YYLIMIT) {
347 if (memcmp(YYCURSOR, "\xef\xbb\xbf", 3) == 0) {
348 YYCURSOR += 3;
349 goto restart;
350 }
351 }
352 /*!re2c
353 re2c:yyfill:check = 0;
354 LNUM [0-9]+
355 DNUM ([0-9]*[\.][0-9]+)|([0-9]+[\.][0-9]*)
356 NUMBER [-]?{LNUM}|{DNUM}
357 ANY_CHAR (.|[\n\t])
358 NEWLINE ("\r"|"\n"|"\r\n")
359 TABS_AND_SPACES [ \t]
360 WHITESPACE [ \t]+
361 CONSTANT [a-zA-Z_][a-zA-Z0-9_]*
362 LABEL_CHAR [^=\n\r\t;&|^$~(){}!"\[\]\x00]
363 LABEL ({LABEL_CHAR}+)
364 TOKENS [:,.\[\]"'()&|^+-/*=%$!~<>?@{}]
365 OPERATORS [&|^~()!]
366 DOLLAR_CURLY "${"
367
368 SECTION_RAW_CHARS [^\]\n\r]
369 SINGLE_QUOTED_CHARS [^']
370 RAW_VALUE_CHARS [^\n\r;\000]
371
372 LITERAL_DOLLAR ("$"([^{\000]|("\\"{ANY_CHAR})))
373 VALUE_CHARS ([^$= \t\n\r;&|^~()!"'\000]|{LITERAL_DOLLAR})
374 FALLBACK_CHARS ([^$\n\r;"'}\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
375 SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
376
377 <!*> := yyleng = YYCURSOR - SCNG(yy_text);
378
379 <INITIAL>"[" { /* Section start */
380 /* Enter section data lookup state */
381 if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {
382 BEGIN(ST_SECTION_RAW);
383 } else {
384 BEGIN(ST_SECTION_VALUE);
385 }
386 return TC_SECTION;
387 }
388
389 <ST_VALUE,ST_SECTION_VALUE,ST_OFFSET>"'"{SINGLE_QUOTED_CHARS}+"'" { /* Raw string */
390 /* Eat leading and trailing single quotes */
391 if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {
392 SCNG(yy_text)++;
393 yyleng = yyleng - 2;
394 }
395 RETURN_TOKEN(TC_RAW, yytext, yyleng);
396 }
397
398 <ST_SECTION_RAW,ST_SECTION_VALUE>"]"{TABS_AND_SPACES}*{NEWLINE}? { /* End of section */
399 BEGIN(INITIAL);
400 SCNG(lineno)++;
401 return ']';
402 }
403
404 <INITIAL>{LABEL}"["{TABS_AND_SPACES}* { /* Start of option with offset */
405 /* Eat leading whitespace */
406 EAT_LEADING_WHITESPACE();
407
408 /* Eat trailing whitespace and [ */
409 EAT_TRAILING_WHITESPACE_EX('[');
410
411 /* Enter offset lookup state */
412 BEGIN(ST_OFFSET);
413
414 RETURN_TOKEN(TC_OFFSET, yytext, yyleng);
415 }
416
417 <ST_OFFSET>{TABS_AND_SPACES}*"]" { /* End of section or an option offset */
418 BEGIN(INITIAL);
419 return ']';
420 }
421
422 <ST_DOUBLE_QUOTES,ST_SECTION_VALUE,ST_VALUE,ST_OFFSET,ST_VAR_FALLBACK>{DOLLAR_CURLY} { /* Variable start */
423 yy_push_state(ST_VARNAME);
424 return TC_DOLLAR_CURLY;
425 }
426
427 <ST_VARNAME>":-" { /* End Variable name, fallback start */
428 fallback_lexing:
429 yy_pop_state();
430 yy_push_state(ST_VAR_FALLBACK);
431 return TC_FALLBACK;
432 }
433
434 <ST_VARNAME>{LABEL_CHAR} { /* Variable name */
435 if (YYCURSOR[0] == ':' && YYCURSOR[1] == '-') {
436 YYCURSOR++;
437 goto fallback_lexing;
438 }
439
440 while (YYCURSOR < YYLIMIT) {
441 switch (*YYCURSOR++) {
442 case '=':
443 case '\n':
444 case '\r':
445 case '\t':
446 case ';':
447 case '&':
448 case '|':
449 case '^':
450 case '$':
451 case '~':
452 case '(':
453 case ')':
454 case '{':
455 case '}':
456 case '!':
457 case '"':
458 case '[':
459 case ']':
460 break;
461 /* ':' is only allowed if it isn't followed by '-'. */
462 case ':':
463 if (YYCURSOR[0] == '-') {
464 break;
465 } else {
466 continue;
467 }
468 default:
469 continue;
470 }
471
472 YYCURSOR--;
473 yyleng = YYCURSOR - SCNG(yy_text);
474 break;
475 }
476
477 /* Eat leading whitespace */
478 EAT_LEADING_WHITESPACE();
479
480 /* Eat trailing whitespace */
481 EAT_TRAILING_WHITESPACE();
482
483 RETURN_TOKEN(TC_VARNAME, yytext, yyleng);
484 }
485
486 <ST_VARNAME,ST_VAR_FALLBACK>"}" { /* Variable/fallback end */
487 yy_pop_state();
488 return '}';
489 }
490
491 <INITIAL,ST_VALUE>("true"|"on"|"yes"){TABS_AND_SPACES}* { /* TRUE value (when used outside option value/offset this causes parse error!) */
492 RETURN_TOKEN(BOOL_TRUE, "1", 1);
493 }
494
495 <INITIAL,ST_VALUE>("false"|"off"|"no"|"none"){TABS_AND_SPACES}* { /* FALSE value (when used outside option value/offset this causes parse error!)*/
496 RETURN_TOKEN(BOOL_FALSE, "", 0);
497 }
498
499 <INITIAL,ST_VALUE>("null"){TABS_AND_SPACES}* {
500 RETURN_TOKEN(NULL_NULL, "", 0);
501 }
502
503 <INITIAL>{LABEL} { /* Get option name */
504 /* Eat leading whitespace */
505 EAT_LEADING_WHITESPACE();
506
507 /* Eat trailing whitespace */
508 EAT_TRAILING_WHITESPACE();
509
510 RETURN_TOKEN(TC_LABEL, yytext, yyleng);
511 }
512
513 <INITIAL>{TABS_AND_SPACES}*[=]{TABS_AND_SPACES}* { /* Start option value */
514 if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {
515 BEGIN(ST_RAW);
516 } else {
517 BEGIN(ST_VALUE);
518 }
519 return '=';
520 }
521
522 <ST_RAW>{RAW_VALUE_CHARS} { /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */
523 const unsigned char *sc = NULL;
524 EAT_LEADING_WHITESPACE();
525 while (YYCURSOR < YYLIMIT) {
526 switch (*YYCURSOR) {
527 case '\n':
528 case '\r':
529 goto end_raw_value_chars;
530 break;
531 case ';':
532 if (sc == NULL) {
533 sc = YYCURSOR;
534 }
535 YYCURSOR++;
536 break;
537 case '"':
538 if (yytext[0] == '"') {
539 sc = NULL;
540 }
541 YYCURSOR++;
542 break;
543 default:
544 YYCURSOR++;
545 break;
546 }
547 }
548 end_raw_value_chars:
549 if (sc) {
550 yyleng = sc - SCNG(yy_text);
551 } else {
552 yyleng = YYCURSOR - SCNG(yy_text);
553 }
554
555 EAT_TRAILING_WHITESPACE();
556
557 /* Eat leading and trailing double quotes */
558 if (yyleng > 1 && yytext[0] == '"' && yytext[yyleng - 1] == '"') {
559 SCNG(yy_text)++;
560 yyleng = yyleng - 2;
561 }
562
563 RETURN_TOKEN(TC_RAW, yytext, yyleng);
564 }
565
566 <ST_SECTION_RAW>{SECTION_RAW_CHARS}+ { /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */
567 RETURN_TOKEN(TC_RAW, yytext, yyleng);
568 }
569
570 <ST_VALUE,ST_RAW>{TABS_AND_SPACES}*{NEWLINE} { /* End of option value */
571 BEGIN(INITIAL);
572 SCNG(lineno)++;
573 return END_OF_LINE;
574 }
575
576 <ST_SECTION_VALUE,ST_VALUE,ST_VAR_FALLBACK,ST_OFFSET>{CONSTANT} { /* Get constant option value */
577 RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);
578 }
579
580 <ST_SECTION_VALUE,ST_VALUE,ST_VAR_FALLBACK,ST_OFFSET>{NUMBER} { /* Get number option value as string */
581 RETURN_TOKEN(TC_NUMBER, yytext, yyleng);
582 }
583
584 <INITIAL>{TOKENS} { /* Disallow these chars outside option values */
585 return yytext[0];
586 }
587
588 <ST_VALUE>{OPERATORS}{TABS_AND_SPACES}* { /* Boolean operators */
589 return yytext[0];
590 }
591
592 <ST_VALUE>[=] { /* Make = used in option value to trigger error */
593 yyless(0);
594 BEGIN(INITIAL);
595 return END_OF_LINE;
596 }
597
598 <ST_VALUE>{VALUE_CHARS}+ { /* Get everything else as option/offset value */
599 RETURN_TOKEN(TC_STRING, yytext, yyleng);
600 }
601
602 <ST_VAR_FALLBACK>{FALLBACK_CHARS}+ { /* Same as below, but excluding '}' */
603 RETURN_TOKEN(TC_STRING, yytext, yyleng);
604 }
605
606 <ST_SECTION_VALUE,ST_OFFSET>{SECTION_VALUE_CHARS}+ { /* Get rest as section/offset value */
607 RETURN_TOKEN(TC_STRING, yytext, yyleng);
608 }
609
610 <ST_SECTION_VALUE,ST_VALUE,ST_VAR_FALLBACK,ST_OFFSET>{TABS_AND_SPACES}*["] { /* Double quoted '"' string start */
611 yy_push_state(ST_DOUBLE_QUOTES);
612 return '"';
613 }
614
615 <ST_DOUBLE_QUOTES>["]{TABS_AND_SPACES}* { /* Double quoted '"' string ends */
616 yy_pop_state();
617 return '"';
618 }
619
620 <ST_DOUBLE_QUOTES>[^] { /* Escape double quoted string contents */
621 if (YYCURSOR > YYLIMIT) {
622 return 0;
623 }
624
625 const unsigned char *s = SCNG(yy_text);
626
627 while (s < YYLIMIT) {
628 switch (*s++) {
629 case '"':
630 break;
631 case '$':
632 if (s < YYLIMIT && *s == '{') {
633 break;
634 }
635 continue;
636 case '\\':
637 if (s < YYLIMIT) {
638 unsigned char escaped = *s++;
639 /* A special case for Windows paths, e.g. key="C:\path\" */
640 if (escaped == '"' && (s >= YYLIMIT || *s == '\n' || *s == '\r')) {
641 break;
642 }
643 }
644 ZEND_FALLTHROUGH;
645 default:
646 continue;
647 }
648
649 s--;
650 break;
651 }
652
653 YYCURSOR = s;
654 yyleng = YYCURSOR - SCNG(yy_text);
655
656 zend_ini_escape_string(ini_lval, yytext, yyleng, '"');
657 Z_EXTRA_P(ini_lval) = 0;
658 return TC_QUOTED_STRING;
659 }
660
661 <ST_SECTION_VALUE,ST_VALUE,ST_OFFSET,ST_VAR_FALLBACK>{WHITESPACE} {
662 RETURN_TOKEN(TC_WHITESPACE, yytext, yyleng);
663 }
664
665 <INITIAL,ST_RAW>{TABS_AND_SPACES}+ {
666 /* eat whitespace */
667 goto restart;
668 }
669
670 <INITIAL>{TABS_AND_SPACES}*{NEWLINE} {
671 SCNG(lineno)++;
672 return END_OF_LINE;
673 }
674
675 <INITIAL,ST_VALUE,ST_RAW>{TABS_AND_SPACES}*[;][^\r\n]*{NEWLINE} { /* Comment */
676 BEGIN(INITIAL);
677 SCNG(lineno)++;
678 return END_OF_LINE;
679 }
680
681 <ST_VALUE,ST_RAW>[^] { /* End of option value (if EOF is reached before EOL */
682 BEGIN(INITIAL);
683 return END_OF_LINE;
684 }
685
686 <*>[^] {
687 return 0;
688 }
689
690 */
691 }
692
