]> git.saurik.com Git - bison.git/blame - src/scan-gram.l
Fix bug that mistakes braced code in a declaration in the rules section
[bison.git] / src / scan-gram.l
CommitLineData
e9955c83 1/* Bison Grammar Scanner -*- C -*-
3b1e470c 2
073f9288 3 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
e9955c83
AD
4
5 This file is part of Bison, the GNU Compiler Compiler.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
0fb669f9
PE
19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301 USA
e9955c83
AD
21*/
22
aa418041 23%option debug nodefault nounput noyywrap never-interactive
e9955c83
AD
24%option prefix="gram_" outfile="lex.yy.c"
25
26%{
9e668899
JD
27#include <config.h>
28#include "system.h"
29
4f6e011e
PE
30/* Work around a bug in flex 2.5.31. See Debian bug 333231
31 <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>. */
32#undef gram_wrap
33#define gram_wrap() 1
34
e9071366
AD
35#define FLEX_PREFIX(Id) gram_ ## Id
36#include "flex-scanner.h"
223ff46e 37
e9955c83 38#include "complain.h"
3f2d73f1 39#include "files.h"
e9071366 40#include "getargs.h" /* yacc_flag */
e9955c83 41#include "gram.h"
ca407bdf 42#include "quotearg.h"
e9955c83 43#include "reader.h"
223ff46e 44#include "uniqstr.h"
e9955c83 45
e9071366
AD
46#include <mbswidth.h>
47#include <quote.h>
48
49#include "scan-gram.h"
50
51#define YY_DECL GRAM_LEX_DECL
2346344a 52
3f2d73f1 53#define YY_USER_INIT \
e9071366 54 code_start = scanner_cursor = loc->start; \
dc9701e8 55
3f2d73f1
PE
56/* Location of scanner cursor. */
57boundary scanner_cursor;
41141c56 58
e9071366 59#define YY_USER_ACTION location_compute (loc, &scanner_cursor, yytext, yyleng);
d8d3f94a 60
6c30d641 61static size_t no_cr_read (FILE *, char *, size_t);
d8d3f94a
PE
62#define YY_INPUT(buf, result, size) ((result) = no_cr_read (yyin, buf, size))
63
7ec2d4cd 64/* A string representing the most recently saved token. */
6b702268 65char *last_string;
7ec2d4cd 66
7ec2d4cd 67void
e9071366 68gram_scanner_last_string_free (void)
7ec2d4cd 69{
41141c56 70 STRING_FREE;
7ec2d4cd 71}
e9955c83 72
e9071366
AD
73/* The location of the most recently saved token, if it was a
74 BRACED_CODE token; otherwise, this has an unspecified value. */
75location gram_last_braced_code_loc;
4517da37 76
4517da37 77static void handle_syncline (char *, location);
1452af69 78static unsigned long int scan_integer (char const *p, int base, location loc);
d8d3f94a 79static int convert_ucn_to_byte (char const *hex_text);
aa418041 80static void unexpected_eof (boundary, char const *);
4febdd96 81static void unexpected_newline (boundary, char const *);
e9955c83
AD
82
83%}
e9071366
AD
84 /* A C-like comment in directives/rules. */
85%x SC_YACC_COMMENT
86 /* Strings and characters in directives/rules. */
e9955c83 87%x SC_ESCAPED_STRING SC_ESCAPED_CHARACTER
e9071366
AD
88 /* A identifier was just read in directives/rules. Special state
89 to capture the sequence `identifier :'. */
90%x SC_AFTER_IDENTIFIER
e9071366
AD
91
92 /* Three types of user code:
93 - prologue (code between `%{' `%}' in the first section, before %%);
94 - actions, printers, union, etc, (between braced in the middle section);
95 - epilogue (everything after the second %%). */
96%x SC_PROLOGUE SC_BRACED_CODE SC_EPILOGUE
97 /* C and C++ comments in code. */
98%x SC_COMMENT SC_LINE_COMMENT
99 /* Strings and characters in code. */
100%x SC_STRING SC_CHARACTER
e9955c83 101
29c01725
AD
102letter [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
103id {letter}({letter}|[0-9])*
104directive %{letter}({letter}|[0-9]|-)*
624a35e2 105int [0-9]+
d8d3f94a
PE
106
107/* POSIX says that a tag must be both an id and a C union member, but
108 historically almost any character is allowed in a tag. We disallow
109 NUL and newline, as this simplifies our implementation. */
110tag [^\0\n>]+
111
112/* Zero or more instances of backslash-newline. Following GCC, allow
113 white space between the backslash and the newline. */
114splice (\\[ \f\t\v]*\n)*
e9955c83
AD
115
116%%
117%{
a706a1cc 118 /* Nesting level of the current code in braces. */
1a9e39f1
PE
119 int braces_level IF_LINT (= 0);
120
3f2d73f1
PE
121 /* Parent context state, when applicable. */
122 int context_state IF_LINT (= 0);
a706a1cc 123
3f2d73f1 124 /* Location of most recent identifier, when applicable. */
a2bc9dbc 125 location id_loc IF_LINT (= empty_location);
3f2d73f1 126
a2bc9dbc
PE
127 /* Where containing code started, when applicable. Its initial
128 value is relevant only when yylex is invoked in the SC_EPILOGUE
129 start condition. */
130 boundary code_start = scanner_cursor;
3f2d73f1 131
223ff46e
PE
132 /* Where containing comment or string or character literal started,
133 when applicable. */
a2bc9dbc 134 boundary token_start IF_LINT (= scanner_cursor);
e9955c83
AD
135%}
136
137
3f2d73f1
PE
138 /*-----------------------.
139 | Scanning white space. |
140 `-----------------------*/
141
58d7a1a1 142<INITIAL,SC_AFTER_IDENTIFIER>
3f2d73f1 143{
4febdd96 144 /* Comments and white space. */
83adb046 145 "," warn_at (*loc, _("stray `,' treated as white space"));
4febdd96 146 [ \f\n\t\v] |
3f2d73f1 147 "//".* ;
83adb046
PE
148 "/*" {
149 token_start = loc->start;
150 context_state = YY_START;
151 BEGIN SC_YACC_COMMENT;
152 }
3f2d73f1
PE
153
154 /* #line directives are not documented, and may be withdrawn or
155 modified in future versions of Bison. */
156 ^"#line "{int}" \"".*"\"\n" {
4517da37 157 handle_syncline (yytext + sizeof "#line " - 1, *loc);
3f2d73f1
PE
158 }
159}
160
161
e9955c83
AD
162 /*----------------------------.
163 | Scanning Bison directives. |
164 `----------------------------*/
165<INITIAL>
166{
34f98f46
JD
167 "%after-header" return PERCENT_AFTER_HEADER;
168 "%before-header" return PERCENT_BEFORE_HEADER;
58d7a1a1
AD
169 "%binary" return PERCENT_NONASSOC;
170 "%debug" return PERCENT_DEBUG;
171 "%default"[-_]"prec" return PERCENT_DEFAULT_PREC;
172 "%define" return PERCENT_DEFINE;
173 "%defines" return PERCENT_DEFINES;
174 "%destructor" return PERCENT_DESTRUCTOR;
175 "%dprec" return PERCENT_DPREC;
34f98f46 176 "%end-header" return PERCENT_END_HEADER;
58d7a1a1
AD
177 "%error"[-_]"verbose" return PERCENT_ERROR_VERBOSE;
178 "%expect" return PERCENT_EXPECT;
179 "%expect"[-_]"rr" return PERCENT_EXPECT_RR;
180 "%file-prefix" return PERCENT_FILE_PREFIX;
e9955c83 181 "%fixed"[-_]"output"[-_]"files" return PERCENT_YACC;
58d7a1a1
AD
182 "%initial-action" return PERCENT_INITIAL_ACTION;
183 "%glr-parser" return PERCENT_GLR_PARSER;
184 "%left" return PERCENT_LEFT;
185 "%lex-param" return PERCENT_LEX_PARAM;
186 "%locations" return PERCENT_LOCATIONS;
187 "%merge" return PERCENT_MERGE;
188 "%name"[-_]"prefix" return PERCENT_NAME_PREFIX;
189 "%no"[-_]"default"[-_]"prec" return PERCENT_NO_DEFAULT_PREC;
190 "%no"[-_]"lines" return PERCENT_NO_LINES;
191 "%nonassoc" return PERCENT_NONASSOC;
192 "%nondeterministic-parser" return PERCENT_NONDETERMINISTIC_PARSER;
193 "%nterm" return PERCENT_NTERM;
194 "%output" return PERCENT_OUTPUT;
195 "%parse-param" return PERCENT_PARSE_PARAM;
196 "%prec" return PERCENT_PREC;
197 "%printer" return PERCENT_PRINTER;
198 "%pure"[-_]"parser" return PERCENT_PURE_PARSER;
199 "%require" return PERCENT_REQUIRE;
200 "%right" return PERCENT_RIGHT;
201 "%skeleton" return PERCENT_SKELETON;
202 "%start" return PERCENT_START;
34f98f46 203 "%start-header" return PERCENT_START_HEADER;
58d7a1a1
AD
204 "%term" return PERCENT_TOKEN;
205 "%token" return PERCENT_TOKEN;
206 "%token"[-_]"table" return PERCENT_TOKEN_TABLE;
207 "%type" return PERCENT_TYPE;
208 "%union" return PERCENT_UNION;
209 "%verbose" return PERCENT_VERBOSE;
210 "%yacc" return PERCENT_YACC;
e9955c83 211
3f2d73f1 212 {directive} {
41141c56 213 complain_at (*loc, _("invalid directive: %s"), quote (yytext));
412f8a59 214 }
900c5db5 215
e9955c83 216 "=" return EQUAL;
e9071366 217 "|" return PIPE;
e9955c83
AD
218 ";" return SEMICOLON;
219
3f2d73f1 220 {id} {
58d7a1a1 221 val->uniqstr = uniqstr_new (yytext);
3f2d73f1 222 id_loc = *loc;
3f2d73f1 223 BEGIN SC_AFTER_IDENTIFIER;
e9955c83
AD
224 }
225
d8d3f94a 226 {int} {
1452af69
PE
227 val->integer = scan_integer (yytext, 10, *loc);
228 return INT;
229 }
230 0[xX][0-9abcdefABCDEF]+ {
231 val->integer = scan_integer (yytext, 16, *loc);
d8d3f94a
PE
232 return INT;
233 }
e9955c83
AD
234
235 /* Characters. We don't check there is only one. */
3f2d73f1 236 "'" STRING_GROW; token_start = loc->start; BEGIN SC_ESCAPED_CHARACTER;
e9955c83
AD
237
238 /* Strings. */
ca407bdf 239 "\"" token_start = loc->start; BEGIN SC_ESCAPED_STRING;
e9955c83
AD
240
241 /* Prologue. */
3f2d73f1 242 "%{" code_start = loc->start; BEGIN SC_PROLOGUE;
e9955c83
AD
243
244 /* Code in between braces. */
3f2d73f1
PE
245 "{" {
246 STRING_GROW;
247 braces_level = 0;
248 code_start = loc->start;
249 BEGIN SC_BRACED_CODE;
250 }
e9955c83
AD
251
252 /* A type. */
d8d3f94a 253 "<"{tag}">" {
223ff46e 254 obstack_grow (&obstack_for_string, yytext + 1, yyleng - 2);
41141c56 255 STRING_FINISH;
223ff46e 256 val->uniqstr = uniqstr_new (last_string);
41141c56 257 STRING_FREE;
4cdb01db
AD
258 return TYPE;
259 }
260
a706a1cc
PE
261 "%%" {
262 static int percent_percent_count;
e9955c83 263 if (++percent_percent_count == 2)
a2bc9dbc 264 BEGIN SC_EPILOGUE;
e9955c83
AD
265 return PERCENT_PERCENT;
266 }
267
a706a1cc 268 . {
41141c56 269 complain_at (*loc, _("invalid character: %s"), quote (yytext));
3f2d73f1 270 }
379f0ac8
PE
271
272 <<EOF>> {
273 loc->start = loc->end = scanner_cursor;
274 yyterminate ();
275 }
3f2d73f1
PE
276}
277
278
279 /*-----------------------------------------------------------------.
280 | Scanning after an identifier, checking whether a colon is next. |
281 `-----------------------------------------------------------------*/
282
283<SC_AFTER_IDENTIFIER>
284{
285 ":" {
3f2d73f1
PE
286 *loc = id_loc;
287 BEGIN INITIAL;
288 return ID_COLON;
289 }
290 . {
291 scanner_cursor.column -= mbsnwidth (yytext, yyleng, 0);
292 yyless (0);
293 *loc = id_loc;
294 BEGIN INITIAL;
295 return ID;
296 }
297 <<EOF>> {
298 *loc = id_loc;
299 BEGIN INITIAL;
300 return ID;
e9955c83
AD
301 }
302}
303
304
d8d3f94a
PE
305 /*---------------------------------------------------------------.
306 | Scanning a Yacc comment. The initial `/ *' is already eaten. |
307 `---------------------------------------------------------------*/
e9955c83 308
d8d3f94a 309<SC_YACC_COMMENT>
e9955c83 310{
3f2d73f1 311 "*/" BEGIN context_state;
a706a1cc 312 .|\n ;
aa418041 313 <<EOF>> unexpected_eof (token_start, "*/"); BEGIN context_state;
d8d3f94a
PE
314}
315
316
317 /*------------------------------------------------------------.
318 | Scanning a C comment. The initial `/ *' is already eaten. |
319 `------------------------------------------------------------*/
320
321<SC_COMMENT>
322{
3f2d73f1 323 "*"{splice}"/" STRING_GROW; BEGIN context_state;
aa418041 324 <<EOF>> unexpected_eof (token_start, "*/"); BEGIN context_state;
e9955c83
AD
325}
326
327
d8d3f94a
PE
328 /*--------------------------------------------------------------.
329 | Scanning a line comment. The initial `//' is already eaten. |
330 `--------------------------------------------------------------*/
331
332<SC_LINE_COMMENT>
333{
3f2d73f1 334 "\n" STRING_GROW; BEGIN context_state;
41141c56 335 {splice} STRING_GROW;
3f2d73f1 336 <<EOF>> BEGIN context_state;
d8d3f94a
PE
337}
338
339
4febdd96
PE
340 /*------------------------------------------------.
341 | Scanning a Bison string, including its escapes. |
342 | The initial quote is already eaten. |
343 `------------------------------------------------*/
e9955c83
AD
344
345<SC_ESCAPED_STRING>
346{
db2cc12f 347 "\"" {
41141c56 348 STRING_FINISH;
3f2d73f1 349 loc->start = token_start;
223ff46e 350 val->chars = last_string;
a706a1cc 351 BEGIN INITIAL;
e9955c83
AD
352 return STRING;
353 }
4febdd96
PE
354 \n unexpected_newline (token_start, "\""); BEGIN INITIAL;
355 <<EOF>> unexpected_eof (token_start, "\""); BEGIN INITIAL;
e9955c83
AD
356}
357
4febdd96
PE
358 /*----------------------------------------------------------.
359 | Scanning a Bison character literal, decoding its escapes. |
360 | The initial quote is already eaten. |
361 `----------------------------------------------------------*/
e9955c83
AD
362
363<SC_ESCAPED_CHARACTER>
364{
db2cc12f 365 "'" {
41141c56
PE
366 STRING_GROW;
367 STRING_FINISH;
3f2d73f1 368 loc->start = token_start;
58d7a1a1 369 val->character = last_string[1];
41141c56 370 STRING_FREE;
a706a1cc 371 BEGIN INITIAL;
58d7a1a1 372 return CHAR;
e9955c83 373 }
4febdd96
PE
374 \n unexpected_newline (token_start, "'"); BEGIN INITIAL;
375 <<EOF>> unexpected_eof (token_start, "'"); BEGIN INITIAL;
376}
a706a1cc 377
4febdd96
PE
378<SC_ESCAPED_CHARACTER,SC_ESCAPED_STRING>
379{
92ac3705 380 \0 complain_at (*loc, _("invalid null character"));
e9955c83
AD
381}
382
383
384 /*----------------------------.
385 | Decode escaped characters. |
386 `----------------------------*/
387
388<SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>
389{
d8d3f94a 390 \\[0-7]{1,3} {
4517da37 391 unsigned long int c = strtoul (yytext + 1, NULL, 8);
d8d3f94a 392 if (UCHAR_MAX < c)
3f2d73f1 393 complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
05ac60f3 394 else if (! c)
92ac3705 395 complain_at (*loc, _("invalid null character: %s"), quote (yytext));
e9955c83 396 else
223ff46e 397 obstack_1grow (&obstack_for_string, c);
e9955c83
AD
398 }
399
6b0d38ab 400 \\x[0-9abcdefABCDEF]+ {
4517da37
PE
401 verify (UCHAR_MAX < ULONG_MAX);
402 unsigned long int c = strtoul (yytext + 2, NULL, 16);
403 if (UCHAR_MAX < c)
3f2d73f1 404 complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
92ac3705
PE
405 else if (! c)
406 complain_at (*loc, _("invalid null character: %s"), quote (yytext));
d8d3f94a 407 else
223ff46e 408 obstack_1grow (&obstack_for_string, c);
e9955c83
AD
409 }
410
223ff46e
PE
411 \\a obstack_1grow (&obstack_for_string, '\a');
412 \\b obstack_1grow (&obstack_for_string, '\b');
413 \\f obstack_1grow (&obstack_for_string, '\f');
414 \\n obstack_1grow (&obstack_for_string, '\n');
415 \\r obstack_1grow (&obstack_for_string, '\r');
416 \\t obstack_1grow (&obstack_for_string, '\t');
417 \\v obstack_1grow (&obstack_for_string, '\v');
412f8a59
PE
418
419 /* \\[\"\'?\\] would be shorter, but it confuses xgettext. */
223ff46e 420 \\("\""|"'"|"?"|"\\") obstack_1grow (&obstack_for_string, yytext[1]);
412f8a59 421
6b0d38ab 422 \\(u|U[0-9abcdefABCDEF]{4})[0-9abcdefABCDEF]{4} {
d8d3f94a
PE
423 int c = convert_ucn_to_byte (yytext);
424 if (c < 0)
3f2d73f1 425 complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
92ac3705
PE
426 else if (! c)
427 complain_at (*loc, _("invalid null character: %s"), quote (yytext));
d8d3f94a 428 else
223ff46e 429 obstack_1grow (&obstack_for_string, c);
d8d3f94a 430 }
4f25ebb0 431 \\(.|\n) {
3f2d73f1 432 complain_at (*loc, _("unrecognized escape sequence: %s"), quote (yytext));
41141c56 433 STRING_GROW;
e9955c83
AD
434 }
435}
436
4febdd96
PE
437 /*--------------------------------------------.
438 | Scanning user-code characters and strings. |
439 `--------------------------------------------*/
e9955c83 440
4febdd96
PE
441<SC_CHARACTER,SC_STRING>
442{
e9071366 443 {splice}|\\{splice}[^\n\[\]] STRING_GROW;
4febdd96 444}
e9955c83
AD
445
446<SC_CHARACTER>
447{
4febdd96
PE
448 "'" STRING_GROW; BEGIN context_state;
449 \n unexpected_newline (token_start, "'"); BEGIN context_state;
450 <<EOF>> unexpected_eof (token_start, "'"); BEGIN context_state;
e9955c83
AD
451}
452
e9955c83
AD
453<SC_STRING>
454{
4febdd96
PE
455 "\"" STRING_GROW; BEGIN context_state;
456 \n unexpected_newline (token_start, "\""); BEGIN context_state;
457 <<EOF>> unexpected_eof (token_start, "\""); BEGIN context_state;
e9955c83
AD
458}
459
460
461 /*---------------------------------------------------.
462 | Strings, comments etc. can be found in user code. |
463 `---------------------------------------------------*/
464
465<SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>
466{
3f2d73f1
PE
467 "'" {
468 STRING_GROW;
469 context_state = YY_START;
470 token_start = loc->start;
471 BEGIN SC_CHARACTER;
472 }
473 "\"" {
474 STRING_GROW;
475 context_state = YY_START;
476 token_start = loc->start;
477 BEGIN SC_STRING;
478 }
479 "/"{splice}"*" {
480 STRING_GROW;
481 context_state = YY_START;
482 token_start = loc->start;
483 BEGIN SC_COMMENT;
484 }
485 "/"{splice}"/" {
486 STRING_GROW;
487 context_state = YY_START;
488 BEGIN SC_LINE_COMMENT;
489 }
e9955c83
AD
490}
491
492
624a35e2 493
58d7a1a1
AD
494 /*-----------------------------------------------------------.
495 | Scanning some code in braces (actions). The initial "{" is |
496 | already eaten. |
497 `-----------------------------------------------------------*/
e9955c83
AD
498
499<SC_BRACED_CODE>
500{
41141c56
PE
501 "{"|"<"{splice}"%" STRING_GROW; braces_level++;
502 "%"{splice}">" STRING_GROW; braces_level--;
e9955c83 503 "}" {
25522739
PE
504 obstack_1grow (&obstack_for_string, '}');
505
2346344a
AD
506 --braces_level;
507 if (braces_level < 0)
e9955c83 508 {
41141c56 509 STRING_FINISH;
3f2d73f1 510 loc->start = code_start;
223ff46e 511 val->chars = last_string;
e9071366 512 gram_last_braced_code_loc = *loc;
a706a1cc 513 BEGIN INITIAL;
58d7a1a1 514 return BRACED_CODE;
e9955c83
AD
515 }
516 }
517
a706a1cc
PE
518 /* Tokenize `<<%' correctly (as `<<' `%') rather than incorrrectly
519 (as `<' `<%'). */
41141c56 520 "<"{splice}"<" STRING_GROW;
a706a1cc 521
aa418041 522 <<EOF>> unexpected_eof (code_start, "}"); BEGIN INITIAL;
e9955c83
AD
523}
524
525
526 /*--------------------------------------------------------------.
527 | Scanning some prologue: from "%{" (already scanned) to "%}". |
528 `--------------------------------------------------------------*/
529
530<SC_PROLOGUE>
531{
532 "%}" {
41141c56 533 STRING_FINISH;
3f2d73f1 534 loc->start = code_start;
223ff46e 535 val->chars = last_string;
a706a1cc 536 BEGIN INITIAL;
e9955c83
AD
537 return PROLOGUE;
538 }
539
aa418041 540 <<EOF>> unexpected_eof (code_start, "%}"); BEGIN INITIAL;
e9955c83
AD
541}
542
543
544 /*---------------------------------------------------------------.
545 | Scanning the epilogue (everything after the second "%%", which |
d8d3f94a 546 | has already been eaten). |
e9955c83
AD
547 `---------------------------------------------------------------*/
548
549<SC_EPILOGUE>
550{
e9955c83 551 <<EOF>> {
41141c56 552 STRING_FINISH;
3f2d73f1 553 loc->start = code_start;
223ff46e 554 val->chars = last_string;
a706a1cc 555 BEGIN INITIAL;
e9955c83
AD
556 return EPILOGUE;
557 }
558}
559
560
4febdd96
PE
561 /*-----------------------------------------------------.
562 | By default, grow the string obstack with the input. |
563 `-----------------------------------------------------*/
564
565<SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE,SC_STRING,SC_CHARACTER,SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>. |
566<SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>\n STRING_GROW;
567
e9955c83
AD
568%%
569
6c30d641
PE
570/* Read bytes from FP into buffer BUF of size SIZE. Return the
571 number of bytes read. Remove '\r' from input, treating \r\n
572 and isolated \r as \n. */
573
574static size_t
575no_cr_read (FILE *fp, char *buf, size_t size)
576{
a737b216
PE
577 size_t bytes_read = fread (buf, 1, size, fp);
578 if (bytes_read)
6c30d641 579 {
a737b216 580 char *w = memchr (buf, '\r', bytes_read);
6c30d641
PE
581 if (w)
582 {
583 char const *r = ++w;
a737b216 584 char const *lim = buf + bytes_read;
6c30d641
PE
585
586 for (;;)
587 {
588 /* Found an '\r'. Treat it like '\n', but ignore any
589 '\n' that immediately follows. */
590 w[-1] = '\n';
591 if (r == lim)
592 {
593 int ch = getc (fp);
594 if (ch != '\n' && ungetc (ch, fp) != ch)
595 break;
596 }
597 else if (*r == '\n')
598 r++;
599
600 /* Copy until the next '\r'. */
601 do
602 {
603 if (r == lim)
604 return w - buf;
605 }
606 while ((*w++ = *r++) != '\r');
607 }
608
609 return w - buf;
610 }
611 }
612
a737b216 613 return bytes_read;
6c30d641
PE
614}
615
616
f25bfb75 617
1452af69
PE
618/*------------------------------------------------------.
619| Scan NUMBER for a base-BASE integer at location LOC. |
620`------------------------------------------------------*/
621
622static unsigned long int
623scan_integer (char const *number, int base, location loc)
624{
4517da37
PE
625 verify (INT_MAX < ULONG_MAX);
626 unsigned long int num = strtoul (number, NULL, base);
627
628 if (INT_MAX < num)
1452af69
PE
629 {
630 complain_at (loc, _("integer out of range: %s"), quote (number));
631 num = INT_MAX;
632 }
4517da37 633
1452af69
PE
634 return num;
635}
636
637
d8d3f94a
PE
638/*------------------------------------------------------------------.
639| Convert universal character name UCN to a single-byte character, |
640| and return that character. Return -1 if UCN does not correspond |
641| to a single-byte character. |
642`------------------------------------------------------------------*/
643
644static int
645convert_ucn_to_byte (char const *ucn)
646{
4517da37
PE
647 verify (UCHAR_MAX <= INT_MAX);
648 unsigned long int code = strtoul (ucn + 2, NULL, 16);
d8d3f94a
PE
649
650 /* FIXME: Currently we assume Unicode-compatible unibyte characters
651 on ASCII hosts (i.e., Latin-1 on hosts with 8-bit bytes). On
652 non-ASCII hosts we support only the portable C character set.
653 These limitations should be removed once we add support for
654 multibyte characters. */
655
656 if (UCHAR_MAX < code)
657 return -1;
658
659#if ! ('$' == 0x24 && '@' == 0x40 && '`' == 0x60 && '~' == 0x7e)
660 {
661 /* A non-ASCII host. Use CODE to index into a table of the C
662 basic execution character set, which is guaranteed to exist on
663 all Standard C platforms. This table also includes '$', '@',
8e6ef483 664 and '`', which are not in the basic execution character set but
d8d3f94a
PE
665 which are unibyte characters on all the platforms that we know
666 about. */
667 static signed char const table[] =
668 {
669 '\0', -1, -1, -1, -1, -1, -1, '\a',
670 '\b', '\t', '\n', '\v', '\f', '\r', -1, -1,
671 -1, -1, -1, -1, -1, -1, -1, -1,
672 -1, -1, -1, -1, -1, -1, -1, -1,
673 ' ', '!', '"', '#', '$', '%', '&', '\'',
674 '(', ')', '*', '+', ',', '-', '.', '/',
675 '0', '1', '2', '3', '4', '5', '6', '7',
676 '8', '9', ':', ';', '<', '=', '>', '?',
677 '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
678 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
679 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
680 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
681 '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
682 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
683 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
684 'x', 'y', 'z', '{', '|', '}', '~'
685 };
686
687 code = code < sizeof table ? table[code] : -1;
688 }
689#endif
c4d720cd 690
d8d3f94a
PE
691 return code;
692}
693
694
900c5db5
AD
695/*----------------------------------------------------------------.
696| Handle `#line INT "FILE"'. ARGS has already skipped `#line '. |
697`----------------------------------------------------------------*/
698
699static void
4517da37 700handle_syncline (char *args, location loc)
900c5db5 701{
4517da37
PE
702 char *after_num;
703 unsigned long int lineno = strtoul (args, &after_num, 10);
704 char *file = strchr (after_num, '"') + 1;
705 *strchr (file, '"') = '\0';
706 if (INT_MAX <= lineno)
707 {
708 warn_at (loc, _("line number overflow"));
709 lineno = INT_MAX;
710 }
e9071366 711 current_file = uniqstr_new (file);
0c8e079f 712 boundary_set (&scanner_cursor, current_file, lineno, 1);
4517da37
PE
713}
714
715
4febdd96
PE
716/*----------------------------------------------------------------.
717| For a token or comment starting at START, report message MSGID, |
718| which should say that an end marker was found before |
719| the expected TOKEN_END. |
720`----------------------------------------------------------------*/
721
722static void
723unexpected_end (boundary start, char const *msgid, char const *token_end)
724{
725 location loc;
726 loc.start = start;
727 loc.end = scanner_cursor;
728 complain_at (loc, _(msgid), token_end);
729}
730
731
3f2d73f1
PE
732/*------------------------------------------------------------------------.
733| Report an unexpected EOF in a token or comment starting at START. |
734| An end of file was encountered and the expected TOKEN_END was missing. |
3f2d73f1 735`------------------------------------------------------------------------*/
a706a1cc
PE
736
737static void
aa418041 738unexpected_eof (boundary start, char const *token_end)
a706a1cc 739{
4febdd96
PE
740 unexpected_end (start, N_("missing `%s' at end of file"), token_end);
741}
742
743
744/*----------------------------------------.
745| Likewise, but for unexpected newlines. |
746`----------------------------------------*/
747
748static void
749unexpected_newline (boundary start, char const *token_end)
750{
751 unexpected_end (start, N_("missing `%s' at end of line"), token_end);
a706a1cc
PE
752}
753
754
f25bfb75
AD
755/*-------------------------.
756| Initialize the scanner. |
757`-------------------------*/
758
1d6412ad 759void
e9071366 760gram_scanner_initialize (void)
1d6412ad 761{
223ff46e 762 obstack_init (&obstack_for_string);
1d6412ad
AD
763}
764
765
f25bfb75
AD
766/*-----------------------------------------------.
767| Free all the memory allocated to the scanner. |
768`-----------------------------------------------*/
769
4cdb01db 770void
e9071366 771gram_scanner_free (void)
4cdb01db 772{
223ff46e 773 obstack_free (&obstack_for_string, 0);
536545f3
AD
774 /* Reclaim Flex's buffers. */
775 yy_delete_buffer (YY_CURRENT_BUFFER);
4cdb01db 776}