1 /* Lexical analyzer for GNU CHILL. -*- C -*-
2 Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC 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, or (at your option)
12 GNU CC 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 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
37 #ifdef MULTIBYTE_CHARS
41 /* include the keyword recognizers */
47 static int last_token = 0;
48 /* Sun's C compiler warns about the safer sequence
50 when there's a 'return' inside the braces, so don't use it */
51 #define RETURN_TOKEN(X) { last_token = X; return (X); }
54 /* This is set non-zero to force incoming tokens to lowercase. */
55 extern int ignore_case;
57 extern int module_number;
58 extern int serious_errors;
60 /* This is non-zero to recognize only uppercase special words. */
61 extern int special_UC;
63 extern struct obstack permanent_obstack;
64 extern struct obstack temporary_obstack;
66 /* forward declarations */
67 static void close_input_file PARAMS ((const char *));
68 static tree convert_bitstring PARAMS ((char *));
69 static tree convert_integer PARAMS ((char *));
70 static void maybe_downcase PARAMS ((char *));
71 static int maybe_number PARAMS ((const char *));
72 static tree equal_number PARAMS ((void));
73 static void handle_use_seizefile_directive PARAMS ((int));
74 static int handle_name PARAMS ((tree));
75 static char *readstring PARAMS ((int, int *));
76 static void read_directive PARAMS ((void));
77 static tree read_identifier PARAMS ((int));
78 static tree read_number PARAMS ((int));
79 static void skip_c_comment PARAMS ((void));
80 static void skip_line_comment PARAMS ((void));
81 static int skip_whitespace PARAMS ((void));
82 static tree string_or_char PARAMS ((int, const char *));
83 static void ch_lex_init PARAMS ((void));
84 static void skip_directive PARAMS ((void));
85 static int same_file PARAMS ((const char *, const char *));
86 static int getlc PARAMS ((FILE *));
88 /* next variables are public, because ch-actions uses them */
90 /* the default grantfile name, set by lang_init */
91 tree default_grant_file = 0;
93 /* These tasking-related variables are NULL at the start of each
94 compiler pass, and are set to an expression tree if and when
95 a compiler directive is parsed containing an expression.
96 The NULL state is significant; it means 'no user-specified
97 signal_code (or whatever) has been parsed'. */
99 /* process type, set by <> PROCESS_TYPE = number <> */
100 tree process_type = NULL_TREE;
102 /* send buffer default priority,
103 set by <> SEND_BUFFER_DEFAULT_PRIORITY = number <> */
104 tree send_buffer_prio = NULL_TREE;
106 /* send signal default priority,
107 set by <> SEND_SIGNAL_DEFAULT_PRIORITY = number <> */
108 tree send_signal_prio = NULL_TREE;
110 /* signal code, set by <> SIGNAL_CODE = number <> */
111 tree signal_code = NULL_TREE;
113 /* flag for range checking */
114 int range_checking = 1;
116 /* flag for NULL pointer checking */
117 int empty_checking = 1;
119 /* flag to indicate making all procedure local variables
121 int all_static_flag = 0;
123 /* flag to indicate -fruntime-checking command line option.
124 Needed for initializing range_checking and empty_checking
126 int runtime_checking_flag = 1;
128 /* The elements of `ridpointers' are identifier nodes
129 for the reserved type names and storage classes.
130 It is indexed by a RID_... value. */
131 tree ridpointers[(int) RID_MAX];
133 /* Nonzero tells yylex to ignore \ in string constants. */
134 static int ignore_escape_flag = 0;
136 static int maxtoken; /* Current nominal length of token buffer. */
137 char *token_buffer; /* Pointer to token buffer.
138 Actual allocated length is maxtoken + 2.
139 This is not static because objc-parse.y uses it. */
141 /* implement yylineno handling for flex */
142 #define yylineno lineno
144 static int inside_c_comment = 0;
146 static int saw_eol = 0; /* 1 if we've just seen a '\n' */
147 static int saw_eof = 0; /* 1 if we've just seen an EOF */
149 typedef struct string_list
151 struct string_list *next;
155 /* list of paths specified on the compiler command line by -L options. */
156 static STRING_LIST *seize_path_list = (STRING_LIST *)0;
158 /* List of seize file names. Each TREE_VALUE is an identifier
159 (file name) from a <>USE_SEIZE_FILE<> directive.
160 The TREE_PURPOSE is non-NULL if a USE_SEIZE_FILE directive has been
161 written to the grant file. */
162 static tree files_to_seize = NULL_TREE;
163 /* Last node on files_to_seize list. */
164 static tree last_file_to_seize = NULL_TREE;
165 /* Pointer into files_to_seize list: Next unparsed file to read. */
166 static tree next_file_to_seize = NULL_TREE;
168 /* The most recent use_seize_file directive. */
169 tree use_seizefile_name = NULL_TREE;
171 /* If non-NULL, the name of the seizefile we're currently processing. */
172 tree current_seizefile_name = NULL_TREE;
174 /* called to reset for pass 2 */
178 current_seizefile_name = NULL_TREE;
184 /* Initialize these compiler-directive variables. */
185 process_type = NULL_TREE;
186 send_buffer_prio = NULL_TREE;
187 send_signal_prio = NULL_TREE;
188 signal_code = NULL_TREE;
190 /* reinitialize rnage checking and empty checking */
191 range_checking = runtime_checking_flag;
192 empty_checking = runtime_checking_flag;
197 init_parse (filename)
198 const char *filename;
200 int lowercase_standard_names = ignore_case || ! special_UC;
202 /* Open input file. */
203 if (filename == 0 || !strcmp (filename, "-"))
209 finput = fopen (filename, "r");
212 fatal_io_error ("can't open %s", filename);
214 #ifdef IO_BUFFER_SIZE
215 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
218 /* Make identifier nodes long enough for the language-specific slots. */
219 set_identifier_size (sizeof (struct lang_identifier));
221 /* Start it at 0, because check_newline is called at the very beginning
222 and will increment it to 1. */
225 /* Initialize these compiler-directive variables. */
226 process_type = NULL_TREE;
227 send_buffer_prio = NULL_TREE;
228 send_signal_prio = NULL_TREE;
229 signal_code = NULL_TREE;
232 token_buffer = xmalloc ((unsigned)(maxtoken + 2));
234 init_chill_expand ();
236 #define ENTER_STANDARD_NAME(RID, LOWER, UPPER) \
237 ridpointers[(int) RID] = \
238 get_identifier (lowercase_standard_names ? LOWER : UPPER)
240 ENTER_STANDARD_NAME (RID_ALL, "all", "ALL");
241 ENTER_STANDARD_NAME (RID_ASSERTFAIL, "assertfail", "ASSERTFAIL");
242 ENTER_STANDARD_NAME (RID_ASSOCIATION, "association", "ASSOCIATION");
243 ENTER_STANDARD_NAME (RID_BIN, "bin", "BIN");
244 ENTER_STANDARD_NAME (RID_BOOL, "bool", "BOOL");
245 ENTER_STANDARD_NAME (RID_BOOLS, "bools", "BOOLS");
246 ENTER_STANDARD_NAME (RID_BYTE, "byte", "BYTE");
247 ENTER_STANDARD_NAME (RID_CHAR, "char", "CHAR");
248 ENTER_STANDARD_NAME (RID_DOUBLE, "double", "DOUBLE");
249 ENTER_STANDARD_NAME (RID_DURATION, "duration", "DURATION");
250 ENTER_STANDARD_NAME (RID_DYNAMIC, "dynamic", "DYNAMIC");
251 ENTER_STANDARD_NAME (RID_ELSE, "else", "ELSE");
252 ENTER_STANDARD_NAME (RID_EMPTY, "empty", "EMPTY");
253 ENTER_STANDARD_NAME (RID_FALSE, "false", "FALSE");
254 ENTER_STANDARD_NAME (RID_FLOAT, "float", "FLOAT");
255 ENTER_STANDARD_NAME (RID_GENERAL, "general", "GENERAL");
256 ENTER_STANDARD_NAME (RID_IN, "in", "IN");
257 ENTER_STANDARD_NAME (RID_INLINE, "inline", "INLINE");
258 ENTER_STANDARD_NAME (RID_INOUT, "inout", "INOUT");
259 ENTER_STANDARD_NAME (RID_INSTANCE, "instance", "INSTANCE");
260 ENTER_STANDARD_NAME (RID_INT, "int", "INT");
261 ENTER_STANDARD_NAME (RID_LOC, "loc", "LOC");
262 ENTER_STANDARD_NAME (RID_LONG, "long", "LONG");
263 ENTER_STANDARD_NAME (RID_LONG_REAL, "long_real", "LONG_REAL");
264 ENTER_STANDARD_NAME (RID_NULL, "null", "NULL");
265 ENTER_STANDARD_NAME (RID_OUT, "out", "OUT");
266 ENTER_STANDARD_NAME (RID_OVERFLOW, "overflow", "OVERFLOW");
267 ENTER_STANDARD_NAME (RID_PTR, "ptr", "PTR");
268 ENTER_STANDARD_NAME (RID_READ, "read", "READ");
269 ENTER_STANDARD_NAME (RID_REAL, "real", "REAL");
270 ENTER_STANDARD_NAME (RID_RANGE, "range", "RANGE");
271 ENTER_STANDARD_NAME (RID_RANGEFAIL, "rangefail", "RANGEFAIL");
272 ENTER_STANDARD_NAME (RID_RECURSIVE, "recursive", "RECURSIVE");
273 ENTER_STANDARD_NAME (RID_SHORT, "short", "SHORT");
274 ENTER_STANDARD_NAME (RID_SIMPLE, "simple", "SIMPLE");
275 ENTER_STANDARD_NAME (RID_TIME, "time", "TIME");
276 ENTER_STANDARD_NAME (RID_TRUE, "true", "TRUE");
277 ENTER_STANDARD_NAME (RID_UBYTE, "ubyte", "UBYTE");
278 ENTER_STANDARD_NAME (RID_UINT, "uint", "UINT");
279 ENTER_STANDARD_NAME (RID_ULONG, "ulong", "ULONG");
280 ENTER_STANDARD_NAME (RID_UNSIGNED, "unsigned", "UNSIGNED");
281 ENTER_STANDARD_NAME (RID_USHORT, "ushort", "USHORT");
282 ENTER_STANDARD_NAME (RID_VOID, "void", "VOID");
294 static int yywrap PARAMS ((void));
295 static int yy_refill PARAMS ((void));
297 #define YY_PUTBACK_SIZE 5
298 #define YY_BUF_SIZE 1000
300 static char yy_buffer[YY_PUTBACK_SIZE + YY_BUF_SIZE];
301 static char *yy_cur = yy_buffer + YY_PUTBACK_SIZE;
302 static char *yy_lim = yy_buffer + YY_PUTBACK_SIZE;
307 char *buf = yy_buffer + YY_PUTBACK_SIZE;
309 bcopy (yy_cur - YY_PUTBACK_SIZE, yy_buffer, YY_PUTBACK_SIZE);
324 c = check_newline ();
337 while (result < YY_BUF_SIZE)
347 /* Because we might switch input files on a compiler directive
348 (that end with '>', don't read past a '>', just in case. */
357 fprintf (stderr, "-------------------------- finished Line %d\n",
365 yy_lim = yy_cur + result;
367 return yy_lim > yy_cur ? *yy_cur++ : EOF;
370 #define input() (yy_cur < yy_lim ? *yy_cur++ : yy_refill ())
372 #define unput(c) (*--yy_cur = (c))
375 int starting_pass_2 = 0;
395 case ' ': case '\t': case '\n': case '\f': case '\b': case '\v': case '\r':
417 else if (nextc == '=')
433 skip_line_comment ();
446 else if (nextc == '=')
448 else if (nextc == '*')
491 int len = 0; /* Number of hex digits seen. */
499 if (!ISXDIGIT (ch)) /* error on non-hex digit */
502 error ("invalid C'xx' ");
513 if (len & 1) /* collected two digits, save byte */
514 obstack_1grow (&temporary_obstack, (char) byte_val);
517 start = obstack_finish (&temporary_obstack);
518 yylval.ttype = string_or_char (len >> 1, start);
519 obstack_free (&temporary_obstack, start);
520 return len == 2 ? SINGLECHAR : STRING;
530 obstack_1grow (&temporary_obstack, ch);
531 obstack_1grow (&temporary_obstack, nextc);
536 obstack_1grow (&temporary_obstack, ch);
540 obstack_1grow (&temporary_obstack, '\0');
541 start = obstack_finish (&temporary_obstack);
545 yylval.ttype = convert_integer (start); /* Pass base? */
550 yylval.ttype = convert_bitstring (start);
558 case 'F': case 'G': case 'I': case 'J':
559 case 'K': case 'L': case 'M': case 'N':
560 case 'P': case 'Q': case 'R': case 'S': case 'T':
561 case 'U': case 'V': case 'W': case 'X': case 'Y':
564 case 'f': case 'g': case 'i': case 'j':
565 case 'k': case 'l': case 'm': case 'n':
566 case 'p': case 'q': case 'r': case 's': case 't':
567 case 'u': case 'v': case 'w': case 'x': case 'y':
571 return handle_name (read_identifier (ch));
573 tmp = readstring ('\'', &len);
574 yylval.ttype = string_or_char (len, tmp);
576 return len == 1 ? SINGLECHAR : STRING;
578 tmp = readstring ('\"', &len);
579 yylval.ttype = build_chill_string (len, tmp);
585 if (ISDIGIT (nextc)) /* || nextc == '_') we don't start numbers with '_' */
588 case '0': case '1': case '2': case '3': case '4':
589 case '5': case '6': case '7': case '8': case '9':
591 yylval.ttype = read_number (ch);
592 return TREE_CODE (yylval.ttype) == REAL_CST ? FLOATING : NUMBER;
599 close_input_file (fn)
605 if (finput != stdin && fclose (finput) == EOF)
607 error ("can't close %s", fn);
613 /* Return an identifier, starting with FIRST and then reading
614 more characters using input(). Return an IDENTIFIER_NODE. */
617 read_identifier (first)
618 int first; /* First letter of identifier */
624 obstack_1grow (&temporary_obstack, first);
628 if (! ISALNUM (first) && first != '_')
634 obstack_1grow (&temporary_obstack, '\0');
635 start = obstack_finish (&temporary_obstack);
636 maybe_downcase (start);
637 id = get_identifier (start);
638 obstack_free (&temporary_obstack, start);
642 /* Given an identifier ID, check to see if it is a reserved name,
643 and return the appropriate token type. */
650 tp = in_word_set (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
652 && special_UC == ISUPPER ((unsigned char) tp->name[0])
653 && (tp->flags == RESERVED || tp->flags == PREDEF))
655 if (tp->rid != NORID)
656 yylval.ttype = ridpointers[tp->rid];
657 else if (tp->token == THIS)
658 yylval.ttype = lookup_name (get_identifier ("__whoami"));
667 int ch; /* Initial character */
675 obstack_1grow (&temporary_obstack, ch);
677 if (! ISDIGIT (ch) && ch != '_')
685 obstack_1grow (&temporary_obstack, ch);
687 } while (ISDIGIT (ch) || ch == '_');
690 if (ch == 'd' || ch == 'D' || ch == 'e' || ch == 'E')
692 /* Convert exponent indication [eEdD] to 'e'. */
693 obstack_1grow (&temporary_obstack, 'e');
695 if (ch == '+' || ch == '-')
697 obstack_1grow (&temporary_obstack, ch);
700 if (ISDIGIT (ch) || ch == '_')
705 obstack_1grow (&temporary_obstack, ch);
707 } while (ISDIGIT (ch) || ch == '_');
711 error ("malformed exponent part of floating-point literal");
717 obstack_1grow (&temporary_obstack, '\0');
718 start = obstack_finish (&temporary_obstack);
721 REAL_VALUE_TYPE value;
722 tree type = double_type_node;
724 value = REAL_VALUE_ATOF (start, TYPE_MODE (type));
725 obstack_free (&temporary_obstack, start);
726 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
727 && REAL_VALUE_ISINF (value) && pedantic)
728 pedwarn ("real number exceeds range of REAL");
729 num = build_real (type, value);
732 num = convert_integer (start);
733 CH_DERIVED_FLAG (num) = 1;
737 /* Skip to the end of a compiler directive. */
747 error ("end-of-file in '<>' directive");
763 /* Read a compiler directive. ("<>{WS}" have already been read. ) */
769 int ch = skip_whitespace();
770 if (ISALPHA (ch) || ch == '_')
771 id = read_identifier (ch);
774 error ("end-of-file in '<>' directive");
775 to_global_binding_level ();
780 warning ("unrecognized compiler directive");
784 tp = in_word_set (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
785 if (tp == NULL || special_UC != ISUPPER ((unsigned char) tp->name[0]))
788 warning ("unrecognized compiler directive `%s'",
789 IDENTIFIER_POINTER (id));
806 case IGNORED_DIRECTIVE:
808 case PROCESS_TYPE_TOKEN:
809 process_type = equal_number ();
817 case SEND_SIGNAL_DEFAULT_PRIORITY:
818 send_signal_prio = equal_number ();
820 case SEND_BUFFER_DEFAULT_PRIORITY:
821 send_buffer_prio = equal_number ();
824 signal_code = equal_number ();
827 handle_use_seizefile_directive (0);
829 case USE_SEIZE_FILE_RESTRICTED:
830 handle_use_seizefile_directive (1);
834 warning ("unrecognized compiler directive `%s'",
835 IDENTIFIER_POINTER (id));
843 build_chill_string (len, str)
849 push_obstacks (&permanent_obstack, &permanent_obstack);
850 t = build_string (len, str);
851 TREE_TYPE (t) = build_string_type (char_type_node,
852 build_int_2 (len, 0));
853 CH_DERIVED_FLAG (t) = 1;
860 string_or_char (len, str)
866 push_obstacks (&permanent_obstack, &permanent_obstack);
869 result = build_int_2 ((unsigned char)str[0], 0);
870 CH_DERIVED_FLAG (result) = 1;
871 TREE_TYPE (result) = char_type_node;
874 result = build_chill_string (len, str);
888 *str = TOLOWER (*str);
900 /* check for decimal number */
901 if (*s >= '0' && *s <= '9')
905 if (*s >= '0' && *s <= '9')
923 if (*s < '0' || *s > '9')
928 if (!ISXDIGIT ((unsigned char) *s))
933 if (*s < '0' || *s > '1')
938 if (*s < '0' || *s > '7')
950 readstring (terminator, len)
955 unsigned allocated = 1024;
956 char *tmp = xmalloc (allocated);
964 if ((c = input ()) != terminator)
972 if (c == '\n' || c == EOF)
977 if (c == EOF || c == '\n')
991 if (cc == terminator)
993 if (!(terminator == '\'' && next_apos))
995 error ("unterminated control sequence");
1000 if (cc == EOF || cc == '\n')
1010 error ("invalid integer literal in control sequence");
1016 if (cc == ' ' || cc == '\t')
1020 if ((c < 0 || c > 255) && (pass == 1))
1021 error ("control sequence overflow");
1022 if (! count && pass == 1)
1023 error ("invalid control sequence");
1028 if ((c < 0 || c > 255) && (pass == 1))
1029 error ("control sequence overflow");
1030 if (! count && pass == 1)
1031 error ("invalid control sequence");
1036 tmp = xrealloc (tmp, allocated);
1045 if (! count && pass == 1)
1046 error ("invalid integer literal in control sequence");
1051 if (cc == 'D' || cc == 'd')
1056 else if (cc == 'H' || cc == 'h')
1061 else if (cc == 'O' || cc == 'o')
1066 else if (cc == 'B' || cc == 'b')
1077 if (cc < '0' || cc > '1')
1084 if (cc < '0' || cc > '8')
1089 else if (base == 10)
1096 else if (base == 16)
1111 error ("invalid base in read control sequence");
1116 /* error in control sequence */
1118 error ("invalid digit in control sequence");
1121 c = (c * base) + cc;
1133 tmp = xrealloc (tmp, allocated);
1137 tmp [*len = i] = '\0';
1145 error ("unterminated string literal");
1146 to_global_binding_level ();
1151 /* Convert an integer INTCHARS into an INTEGER_CST.
1152 INTCHARS is on the temporary_obstack, and is popped by this function. */
1155 convert_integer (intchars)
1164 int valid_chars = 0;
1167 HOST_WIDE_INT val_lo = 0, val_hi = 0;
1170 /* determine the base */
1193 if (!ISDIGIT (*p)) /* this test is for equal_number () */
1195 obstack_free (&temporary_obstack, intchars);
1204 if ((tmp == '\'') || (tmp == '_'))
1208 if (tmp >= 'a') /* uppercase the char */
1210 switch (base) /* validate the characters */
1227 if (tmp > '9' && tmp < 'A')
1236 if (mul_double (val_lo, val_hi, base, 0, &val_lo, &val_hi))
1238 add_double (val_lo, val_hi, tmp, 0, &val_lo, &val_hi);
1244 obstack_free (&temporary_obstack, intchars);
1248 error ("invalid number format `%s'", oldp);
1251 val = build_int_2 (val_lo, val_hi);
1252 /* We set the type to long long (or long long unsigned) so that
1253 constant fold of literals is less likely to overflow. */
1254 if (int_fits_type_p (val, long_long_integer_type_node))
1255 type = long_long_integer_type_node;
1258 if (! int_fits_type_p (val, long_long_unsigned_type_node))
1260 type = long_long_unsigned_type_node;
1262 TREE_TYPE (val) = type;
1263 CH_DERIVED_FLAG (val) = 1;
1266 error ("integer literal too big");
1271 /* Convert a bitstring literal on the temporary_obstack to
1272 a bitstring CONSTRUCTOR. Free the literal from the obstack. */
1275 convert_bitstring (p)
1281 int bl = 0, valid_chars = 0, bits_per_char = 0, c, k;
1282 tree initlist = NULL_TREE;
1285 /* Move p to stack so we can re-use temporary_obstack for result. */
1286 char *oldp = (char*) alloca (strlen (p) + 1);
1288 obstack_free (&temporary_obstack, p);
1311 if (c == '_' || c == '\'')
1320 for (k = BYTES_BIG_ENDIAN ? bits_per_char - 1 : 0;
1321 BYTES_BIG_ENDIAN ? k >= 0 : k < bits_per_char;
1322 bl++, BYTES_BIG_ENDIAN ? k-- : k++)
1325 initlist = tree_cons (NULL_TREE, build_int_2 (bl, 0), initlist);
1329 /* as long as BOOLS(0) is valid it must tbe possible to
1330 specify an empty bitstring */
1334 error ("invalid number format `%s'", oldp);
1338 val = build (CONSTRUCTOR,
1339 build_bitstring_type (size_int (bl)),
1340 NULL_TREE, nreverse (initlist));
1341 TREE_CONSTANT (val) = 1;
1342 CH_DERIVED_FLAG (val) = 1;
1346 /* Check if two filenames name the same file.
1347 This is done by stat'ing both files and comparing their inodes.
1349 Note: we have to take care of seize_path_list. Therefore do it the same
1350 way as in yywrap. FIXME: This probably can be done better. */
1353 same_file (filename1, filename2)
1354 const char *filename1;
1355 const char *filename2;
1358 const char *fn_input[2];
1361 if (grant_only_flag)
1362 /* do nothing in this case */
1365 /* if filenames are equal -- return 1, cause there is no need
1366 to search in the include list in this case */
1367 if (strcmp (filename1, filename2) == 0)
1370 fn_input[0] = filename1;
1371 fn_input[1] = filename2;
1373 for (i = 0; i < 2; i++)
1375 stat_status = stat (fn_input[i], &s[i]);
1377 && strchr (fn_input[i], '/') == 0)
1382 for (plp = seize_path_list; plp != 0; plp = plp->next)
1384 path = (char *) xmalloc (strlen (fn_input[i])
1385 + strlen (plp->str) + 2);
1386 sprintf (path, "%s/%s", plp->str, fn_input[i]);
1387 stat_status = stat (path, &s[i]);
1389 if (stat_status >= 0)
1394 if (stat_status < 0)
1395 fatal_io_error ("can't find %s", fn_input[i]);
1397 return s[0].st_ino == s[1].st_ino && s[0].st_dev == s[1].st_dev;
1401 * Note that simply appending included file names to a list in this
1402 * way completely eliminates the need for nested files, and the
1403 * associated book-keeping, since the EOF processing in the lexer
1404 * will simply process the files one at a time, in the order that the
1405 * USE_SEIZE_FILE directives were scanned.
1408 handle_use_seizefile_directive (restricted)
1413 int c = skip_whitespace ();
1414 char *use_seizefile_str = readstring (c, &len);
1419 if (c != '\'' && c != '\"')
1421 error ("USE_SEIZE_FILE directive must be followed by string");
1425 use_seizefile_name = get_identifier (use_seizefile_str);
1426 CH_USE_SEIZEFILE_RESTRICTED (use_seizefile_name) = restricted;
1428 if (!grant_only_flag)
1430 /* If file foo.ch contains a <> use_seize_file "bar.grt" <>,
1431 and file bar.ch contains a <> use_seize_file "foo.grt" <>,
1432 then if we're compiling foo.ch, we will indirectly be
1433 asked to seize foo.grt. Don't. */
1434 extern char *grant_file_name;
1435 if (strcmp (use_seizefile_str, grant_file_name) == 0)
1438 /* Check if the file is already on the list. */
1439 for (seen = files_to_seize; seen != NULL_TREE; seen = TREE_CHAIN (seen))
1440 if (same_file (IDENTIFIER_POINTER (TREE_VALUE (seen)),
1442 return; /* Previously seen; nothing to do. */
1445 /* Haven't been asked to seize this file yet, so add
1446 its name to the list. */
1448 tree pl = perm_tree_cons (0, use_seizefile_name, NULL_TREE);
1449 if (files_to_seize == NULL_TREE)
1450 files_to_seize = pl;
1452 TREE_CHAIN (last_file_to_seize) = pl;
1453 if (next_file_to_seize == NULL_TREE)
1454 next_file_to_seize = pl;
1455 last_file_to_seize = pl;
1461 * get input, convert to lower case for comparison
1475 #if defined HANDLE_PRAGMA
1476 /* Local versions of these macros, that can be passed as function pointers. */
1480 return getc (finput);
1487 ungetc (arg, finput);
1489 #endif /* HANDLE_PRAGMA */
1491 #ifdef HANDLE_GENERIC_PRAGMAS
1492 /* Handle a generic #pragma directive.
1493 BUFFER contains the text we read after `#pragma'. Processes the entire input
1494 line and return non-zero iff the pragma was successfully processed. */
1497 handle_generic_pragma (buffer)
1506 handle_pragma_token (buffer, NULL);
1510 while (c == ' ' || c == '\t')
1514 if (c == '\n' || c == EOF)
1515 return handle_pragma_token (NULL, NULL);
1517 /* Read the next word of the pragma into the buffer. */
1524 while (c != EOF && ! ISSPACE (c) && buff < buffer + 128);
1525 /* XXX shared knowledge about size of buffer. */
1532 #endif /* HANDLE_GENERIC_PRAGMAS */
1534 /* At the beginning of a line, increment the line number and process
1535 any #-directive on this line. If the line is a #-directive, read
1536 the entire line and return a newline. Otherwise, return the line's
1537 first non-whitespace character.
1539 (Each language front end has a check_newline() function that is called
1540 from lang_init() for that language. One of the things this function
1541 must do is read the first line of the input file, and if it is a #line
1542 directive, extract the filename from it and use it to initialize
1543 main_input_filename. Proper generation of debugging information in
1544 the normal "front end calls cpp then calls cc1XXXX environment" depends
1545 upon this being done.) */
1554 /* Read first nonwhite char on the line. */
1558 while (c == ' ' || c == '\t')
1561 if (c != '#' || inside_c_comment)
1563 /* If not #, return it so caller will use it. */
1567 /* Read first nonwhite char after the `#'. */
1570 while (c == ' ' || c == '\t')
1573 /* If a letter follows, then if the word here is `line', skip
1574 it and ignore it; otherwise, ignore the line, with an error
1575 if the word isn't `pragma', `ident', `define', or `undef'. */
1580 if (c >= 'a' && c <= 'z')
1584 if (getlc (finput) == 'r'
1585 && getlc (finput) == 'a'
1586 && getlc (finput) == 'g'
1587 && getlc (finput) == 'm'
1588 && getlc (finput) == 'a'
1589 && (c = getlc (finput), ISSPACE (c)))
1591 #ifdef HANDLE_PRAGMA
1592 static char buffer [128];
1593 char * buff = buffer;
1595 /* Read the pragma name into a buffer. */
1596 while (c = getlc (finput), ISSPACE (c))
1604 while (c != EOF && ! ISSPACE (c) && c != '\n'
1605 && buff < buffer + 128);
1611 if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc, buffer))
1613 #endif /* HANDLE_PRAGMA */
1615 #ifdef HANDLE_GENERIC_PRAGMAS
1616 if (handle_generic_pragma (buffer))
1618 #endif /* HANDLE_GENERIC_PRAGMAS */
1626 if (getlc (finput) == 'e'
1627 && getlc (finput) == 'f'
1628 && getlc (finput) == 'i'
1629 && getlc (finput) == 'n'
1630 && getlc (finput) == 'e'
1631 && (c = getlc (finput), ISSPACE (c)))
1633 #if 0 /*def DWARF_DEBUGGING_INFO*/
1635 && (debug_info_level == DINFO_LEVEL_VERBOSE)
1636 && (write_symbols == DWARF_DEBUG))
1637 dwarfout_define (lineno, get_directive_line (finput));
1638 #endif /* DWARF_DEBUGGING_INFO */
1644 if (getlc (finput) == 'n'
1645 && getlc (finput) == 'd'
1646 && getlc (finput) == 'e'
1647 && getlc (finput) == 'f'
1648 && (c = getlc (finput), ISSPACE (c)))
1650 #if 0 /*def DWARF_DEBUGGING_INFO*/
1652 && (debug_info_level == DINFO_LEVEL_VERBOSE)
1653 && (write_symbols == DWARF_DEBUG))
1654 dwarfout_undef (lineno, get_directive_line (finput));
1655 #endif /* DWARF_DEBUGGING_INFO */
1661 if (getlc (finput) == 'i'
1662 && getlc (finput) == 'n'
1663 && getlc (finput) == 'e'
1664 && ((c = getlc (finput)) == ' ' || c == '\t'))
1670 if (getlc (finput) == 'd'
1671 && getlc (finput) == 'e'
1672 && getlc (finput) == 'n'
1673 && getlc (finput) == 't'
1674 && ((c = getlc (finput)) == ' ' || c == '\t'))
1676 /* #ident. The pedantic warning is now in cpp. */
1678 /* Here we have just seen `#ident '.
1679 A string constant should follow. */
1681 while (c == ' ' || c == '\t')
1684 /* If no argument, ignore the line. */
1691 || TREE_CODE (yylval.ttype) != STRING_CST)
1693 error ("invalid #ident");
1699 #ifdef ASM_OUTPUT_IDENT
1700 extern FILE *asm_out_file;
1701 ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
1705 /* Skip the rest of this line. */
1711 error ("undefined or invalid # directive");
1716 /* Here we have either `#line' or `# <nonletter>'.
1717 In either case, it should be a line number; a digit should follow. */
1719 while (c == ' ' || c == '\t')
1722 /* If the # is the only nonwhite char on the line,
1723 just ignore it. Check the new newline. */
1727 /* Something follows the #; read a token. */
1731 int old_lineno = lineno;
1734 extern struct obstack permanent_obstack;
1738 l = l * 10 + (c - '0'); /* FIXME Not portable */
1740 } while (ISDIGIT(c));
1741 /* subtract one, because it is the following line that
1742 gets the specified number */
1746 /* Is this the last nonwhite stuff on the line? */
1748 while (c == ' ' || c == '\t')
1752 /* No more: store the line number and check following line. */
1757 /* More follows: it must be a string constant (filename). */
1759 /* Read the string constant, but don't treat \ as special. */
1760 ignore_escape_flag = 1;
1761 ignore_escape_flag = 0;
1765 error ("invalid #line");
1772 if (c == EOF || c == '\n')
1774 error ("invalid #line");
1779 obstack_1grow(&permanent_obstack, 0);
1780 input_filename = obstack_finish (&permanent_obstack);
1783 obstack_1grow(&permanent_obstack, c);
1788 /* Each change of file name
1789 reinitializes whether we are now in a system header. */
1790 in_system_header = 0;
1792 if (main_input_filename == 0)
1793 main_input_filename = input_filename;
1795 /* Is this the last nonwhite stuff on the line? */
1797 while (c == ' ' || c == '\t')
1804 /* `1' after file name means entering new file.
1805 `2' after file name means just left a file. */
1811 /* Pushing to a new file. */
1812 struct file_stack *p
1813 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
1814 input_file_stack->line = old_lineno;
1815 p->next = input_file_stack;
1816 p->name = input_filename;
1817 input_file_stack = p;
1818 input_file_stack_tick++;
1819 #ifdef DWARF_DEBUGGING_INFO
1820 if (debug_info_level == DINFO_LEVEL_VERBOSE
1821 && write_symbols == DWARF_DEBUG)
1822 dwarfout_start_new_source_file (input_filename);
1823 #endif /* DWARF_DEBUGGING_INFO */
1829 /* Popping out of a file. */
1830 if (input_file_stack->next)
1832 struct file_stack *p = input_file_stack;
1833 input_file_stack = p->next;
1835 input_file_stack_tick++;
1836 #ifdef DWARF_DEBUGGING_INFO
1837 if (debug_info_level == DINFO_LEVEL_VERBOSE
1838 && write_symbols == DWARF_DEBUG)
1839 dwarfout_resume_previous_source_file (input_file_stack->line);
1840 #endif /* DWARF_DEBUGGING_INFO */
1843 error ("#-lines for entering and leaving files don't match");
1849 /* If we have handled a `1' or a `2',
1850 see if there is another number to read. */
1853 /* Is this the last nonwhite stuff on the line? */
1855 while (c == ' ' || c == '\t')
1862 /* `3' after file name means this is a system header file. */
1865 in_system_header = 1;
1868 error ("invalid #-line");
1870 /* skip the rest of this line. */
1872 while (c != '\n' && c != EOF)
1879 get_chill_filename ()
1881 return (build_chill_string (
1882 strlen (input_filename) + 1, /* +1 to get a zero terminated string */
1887 get_chill_linenumber ()
1889 return build_int_2 ((HOST_WIDE_INT)lineno, 0);
1893 /* Assuming '/' and '*' have been read, skip until we've
1894 read the terminating '*' and '/'. */
1900 int start_line = lineno;
1906 error_with_file_and_line (input_filename, start_line,
1907 "unterminated comment");
1912 else if ((c = input ()) == '/')
1918 /* Assuming "--" has been read, skip until '\n'. */
1921 skip_line_comment ()
1945 if (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v')
1966 skip_line_comment ();
1980 * avoid recursive calls to yylex to parse the ' = digits' or
1981 * ' = SYNvalue' which are supposed to follow certain compiler
1982 * directives. Read the input stream, and return the value parsed.
1984 /* FIXME: overflow check in here */
1985 /* FIXME: check for EOF around here */
1992 tree retval = integer_zero_node;
1994 c = skip_whitespace();
1998 error ("missing `=' in compiler directive");
1999 return integer_zero_node;
2001 c = skip_whitespace();
2003 /* collect token into tokenbuf for later analysis */
2006 if (ISSPACE (c) || c == '<')
2008 obstack_1grow (&temporary_obstack, c);
2011 unput (c); /* put uninteresting char back */
2012 obstack_1grow (&temporary_obstack, '\0'); /* terminate token */
2013 tokenbuf = obstack_finish (&temporary_obstack);
2014 maybe_downcase (tokenbuf);
2016 if (*tokenbuf == '-')
2017 /* will fail in the next test */
2019 else if (maybe_number (tokenbuf))
2022 return integer_zero_node;
2023 push_obstacks_nochange ();
2024 end_temporary_allocation ();
2025 yylval.ttype = convert_integer (tokenbuf);
2026 tokenbuf = 0; /* Was freed by convert_integer. */
2027 result = yylval.ttype ? NUMBER : 0;
2033 if (result == NUMBER)
2035 retval = yylval.ttype;
2037 else if (result == BITSTRING)
2040 error ("invalid value follows `=' in compiler directive");
2043 else /* not a number */
2047 if (!ISALPHA (c) && c != '_')
2050 error ("invalid value follows `=' in compiler directive");
2054 for (cursor = &tokenbuf[1]; *cursor != '\0'; cursor++)
2055 if (ISALPHA ((unsigned char) *cursor) || *cursor == '_' ||
2061 error ("invalid `%c' character in name", *cursor);
2068 tree value = lookup_name (get_identifier (tokenbuf));
2069 if (value == NULL_TREE
2070 || TREE_CODE (value) != CONST_DECL
2071 || TREE_CODE (DECL_INITIAL (value)) != INTEGER_CST)
2074 error ("`%s' not integer constant synonym ",
2078 obstack_free (&temporary_obstack, tokenbuf);
2080 push_obstacks_nochange ();
2081 end_temporary_allocation ();
2082 retval = convert (chill_taskingcode_type_node, DECL_INITIAL (value));
2087 /* check the value */
2088 if (TREE_CODE (retval) != INTEGER_CST)
2091 error ("invalid value follows `=' in compiler directive");
2093 else if (TREE_INT_CST_HIGH (retval) != 0 ||
2094 TREE_INT_CST_LOW (retval) > TREE_INT_CST_LOW (TYPE_MAX_VALUE (chill_unsigned_type_node)))
2097 error ("value out of range in compiler directive");
2101 obstack_free (&temporary_obstack, tokenbuf);
2106 * add a possible grant-file path to the list
2109 register_seize_path (path)
2112 int pathlen = strlen (path);
2113 char *new_path = (char *)xmalloc (pathlen + 1);
2114 STRING_LIST *pl = (STRING_LIST *)xmalloc (sizeof (STRING_LIST));
2116 /* strip off trailing slash if any */
2117 if (path[pathlen - 1] == '/')
2120 memcpy (new_path, path, pathlen);
2122 pl->next = seize_path_list;
2123 seize_path_list = pl;
2127 /* Used by decode_decl to indicate that a <> use_seize_file NAME <>
2128 directive has been written to the grantfile. */
2131 mark_use_seizefile_written (name)
2136 for (node = files_to_seize; node != NULL_TREE; node = TREE_CHAIN (node))
2137 if (TREE_VALUE (node) == name)
2139 TREE_PURPOSE (node) = integer_one_node;
2148 extern char *chill_real_input_filename;
2150 close_input_file (input_filename);
2152 use_seizefile_name = NULL_TREE;
2154 if (next_file_to_seize && !grant_only_flag)
2156 FILE *grt_in = NULL;
2157 const char *seizefile_name_chars
2158 = IDENTIFIER_POINTER (TREE_VALUE (next_file_to_seize));
2160 /* find a seize file, open it. If it's not at the path the
2161 * user gave us, and that path contains no slashes, look on
2162 * the seize_file paths, specified by the '-I' options.
2164 grt_in = fopen (seizefile_name_chars, "r");
2166 && strchr (seizefile_name_chars, '/') == NULL)
2171 for (plp = seize_path_list; plp != NULL; plp = plp->next)
2173 path = (char *)xmalloc (strlen (seizefile_name_chars)
2174 + strlen (plp->str) + 2);
2176 sprintf (path, "%s/%s", plp->str, seizefile_name_chars);
2177 grt_in = fopen (path, "r");
2182 seizefile_name_chars = path;
2189 fatal_io_error ("can't open %s", seizefile_name_chars);
2192 input_filename = seizefile_name_chars;
2195 current_seizefile_name = TREE_VALUE (next_file_to_seize);
2197 next_file_to_seize = TREE_CHAIN (next_file_to_seize);
2205 next_file_to_seize = files_to_seize;
2206 current_seizefile_name = NULL_TREE;
2208 if (strcmp (main_input_filename, "stdin"))
2209 finput = fopen (chill_real_input_filename, "r");
2214 error ("can't reopen %s", chill_real_input_filename);
2217 input_filename = main_input_filename;
2220 /* Read a line directive if there is one. */
2221 ungetc (check_newline (), finput);
2222 starting_pass_2 = 1;
2224 if (module_number == 0)
2225 warning ("no modules seen");