]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/gengtype-state.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
backport: As described in http://gcc.gnu.org/ml/gcc/2012-08/msg00015.html...
[thirdparty/gcc.git] / gcc / gengtype-state.c
CommitLineData
92724e1d
BS		 1/* Gengtype persistent state serialization & de-serialization.
2 Useful for gengtype in plugin mode.
3
4 Copyright (C) 2010 Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>.
21
22 Contributed by Jeremie Salvucci <jeremie.salvucci@free.fr>
23 and Basile Starynkevitch <basile@starynkevitch.net>
24*/
25
f142b5bc 26#ifdef GENERATOR_FILE
92724e1d 27#include "bconfig.h"
f142b5bc
RG		 28#else
29#include "config.h"
30#endif
92724e1d
BS		 31#include "system.h"
32#include "errors.h" /* For fatal. */
33#include "double-int.h"
34#include "hashtab.h"
35#include "version.h" /* For version_string & pkgversion_string. */
36#include "obstack.h"
37#include "gengtype.h"
38
39
40
41/* Gives the file location of a type, if any. */
42static inline struct fileloc*
43type_lineloc (const_type_p ty)
44{
45 if (!ty)
46 return NULL;
47 switch (ty->kind)
48 {
49 case TYPE_NONE:
50 gcc_unreachable ();
51 case TYPE_STRUCT:
52 case TYPE_UNION:
53 case TYPE_LANG_STRUCT:
0823efed 54 case TYPE_USER_STRUCT:
92724e1d
BS		 55 return CONST_CAST (struct fileloc*, &ty->u.s.line);
56 case TYPE_PARAM_STRUCT:
57 return CONST_CAST (struct fileloc*, &ty->u.param_struct.line);
58 case TYPE_SCALAR:
59 case TYPE_STRING:
60 case TYPE_POINTER:
61 case TYPE_ARRAY:
62 return NULL;
63 default:
64 gcc_unreachable ();
65 }
66}
67
68/* The state file has simplistic lispy lexical tokens. Its lexer gives
073a8998 69 a linked list of struct state_token_st, through the peek_state_token
92724e1d
BS		 70 function. Lexical tokens are consumed with next_state_tokens. */
71
72
73/* The lexical kind of each lispy token. */
74enum state_token_en
75{
76 STOK_NONE, /* Never used. */
77 STOK_INTEGER, /* Integer token. */
78 STOK_STRING, /* String token. */
79 STOK_LEFTPAR, /* Left opening parenthesis. */
80 STOK_RIGHTPAR, /* Right closing parenthesis. */
81 STOK_NAME /* hash-consed name or identifier. */
82};
83
84
85/* Structure and hash-table used to share identifiers or names. */
86struct state_ident_st
87{
88 /* TODO: We could improve the parser by reserving identifiers for
89 state keywords and adding a keyword number for them. That would
90 mean adding another field in this state_ident_st struct. */
91 char stid_name[1]; /* actually bigger & null terminated */
92};
93static htab_t state_ident_tab;
94
95
96/* The state_token_st structure is for lexical tokens in the read
97 state file. The stok_kind field discriminates the union. Tokens
98 are allocated by peek_state_token which calls read_a_state_token
99 which allocate them. Tokens are freed by calls to
100 next_state_tokens. Token are organized in a FIFO look-ahead queue
101 filled by peek_state_token. */
102struct state_token_st
103{
104 enum state_token_en stok_kind; /* the lexical kind
105 discriminates the stok_un
106 union */
107 int stok_line; /* the line number */
108 int stok_col; /* the column number */
109 const char *stok_file; /* the file path */
110 struct state_token_st *stok_next; /* the next token in the
111 queue, when peeked */
112 union /* discriminated by stok_kind! */
113 {
114 int stok_num; /* when STOK_INTEGER */
115 char stok_string[1]; /* when STOK_STRING, actual size is
116 bigger and null terminated */
117 struct state_ident_st *stok_ident; /* when STOK_IDENT */
118 void *stok_ptr; /* null otherwise */
119 }
120 stok_un;
121};
122
123
124
125
126#define NULL_STATE_TOKEN (struct state_token_st*)0
127
128/* the state_token pointer contains the leftmost current token. The
129 tokens are organized in a linked queue, using stok_next, for token
130 look-ahead. */
131struct state_token_st *state_token = NULL_STATE_TOKEN;
132
133/* Used by the reading lexer. */
134static FILE *state_file;
135static const char *state_path = NULL;
136static int state_line = 0;
137static long state_bol = 0; /* offset of beginning of line */
138
139
140/* Counter of written types. */
141static int state_written_type_count = 0;
142
143
144/* Fatal error messages when reading the state. They are extremely
145 unlikely, and only appear when this gengtype-state.c file is buggy,
146 or when reading a gengtype state which was not generated by the
147 same version of gengtype or GCC. */
148
149
150/* Fatal message while reading state. */
151static inline void
152fatal_reading_state (struct state_token_st* tok, const char*msg)
153{
154 if (tok)
155 fatal ("%s:%d:%d: Invalid state file; %s",
156 tok->stok_file, tok->stok_line, tok->stok_col,
157 msg);
158 else
159 fatal ("%s:%d: Invalid state file; %s",
160 state_path, state_line, msg);
161}
162
163
164/* Fatal printf-like message while reading state. This can't be a
165 function, because there is no way to pass a va_arg to a variant of
166 fatal. */
167#define fatal_reading_state_printf(Tok,Fmt,...) do { \
168 struct state_token_st* badtok = Tok; \
169 if (badtok) \
170 fatal ("%s:%d:%d: Invalid state file; " Fmt, \
171 badtok->stok_file, \
172 badtok->stok_line, \
173 badtok->stok_col, __VA_ARGS__); \
174 else \
175 fatal ("%s:%d: Invalid state file; " Fmt, \
176 state_path, state_line, __VA_ARGS__); \
177 } while(0)
178
179
180/* Find or allocate an identifier in our name hash table. */
181static struct state_ident_st *
182state_ident_by_name (const char *name, enum insert_option optins)
183{
184 PTR *slot = NULL;
185 int namlen = 0;
186 struct state_ident_st *stid = NULL;
187
188 if (!name || !name[0])
189 return NULL;
190
191 slot = htab_find_slot (state_ident_tab, name, optins);
192 if (!slot)
193 return NULL;
194
195 namlen = strlen (name);
196 stid =
197 (struct state_ident_st *) xmalloc (sizeof (struct state_ident_st) +
198 namlen);
199 memset (stid, 0, sizeof (struct state_ident_st) + namlen);
200 strcpy (stid->stid_name, name);
201 *slot = stid;
202
203 return stid;
204}
205
206/* Our token lexer is heavily inspired by MELT's lexer, and share some
207 code with the file gcc/melt-runtime.c of the GCC MELT branch! We
208 really want the gengtype state to be easily parsable by MELT. This
209 is a usual lispy lexing routine, dealing with spaces and comments,
210 numbers, parenthesis, names, strings. */
211static struct state_token_st *
212read_a_state_token (void)
213{
214 int c = 0;
215 long curoff = 0;
216 struct state_token_st *tk = NULL;
217
218 again: /* Read again, e.g. after a comment or spaces. */
219 c = getc (state_file);
220 if (c == EOF)
221 return NULL;
222
223 /* Handle spaces, count lines. */
224 if (c == '\n')
225 {
226 state_line++;
227 state_bol = curoff = ftell (state_file);
228 goto again;
229 };
230 if (ISSPACE (c))
231 goto again;
232 /* Skip comments starting with semi-colon. */
233 if (c == ';')
234 {
235 do
236 {
237 c = getc (state_file);
238 }
239 while (c > 0 && c != '\n');
240 if (c == '\n')
241 {
242 state_line++;
243 state_bol = curoff = ftell (state_file);
244 }
245 goto again;
246 };
247 /* Read signed numbers. */
248 if (ISDIGIT (c) || c == '-' || c == '+')
249 { /* number */
250 int n = 0;
251 ungetc (c, state_file);
252 curoff = ftell (state_file);
253 if (fscanf (state_file, "%d", &n) <= 0)
254 fatal_reading_state (NULL_STATE_TOKEN, "Lexical error in number");
255 tk = XCNEW (struct state_token_st);
256 tk->stok_kind = STOK_INTEGER;
257 tk->stok_line = state_line;
258 tk->stok_col = curoff - state_bol;
259 tk->stok_file = state_path;
260 tk->stok_next = NULL;
261 tk->stok_un.stok_num = n;
262
263 return tk;
264 }
265 /* Read an opening left parenthesis. */
266 else if (c == '(')
267 {
268 curoff = ftell (state_file);
269 tk = XCNEW (struct state_token_st);
270 tk->stok_kind = STOK_LEFTPAR;
271 tk->stok_line = state_line;
272 tk->stok_col = curoff - state_bol;
273 tk->stok_file = state_path;
274 tk->stok_next = NULL;
275
276 return tk;
277 }
278 /* Read an closing right parenthesis. */
279 else if (c == ')')
280 {
281 curoff = ftell (state_file);
282 tk = XCNEW (struct state_token_st);
283 tk->stok_kind = STOK_RIGHTPAR;
284 tk->stok_line = state_line;
285 tk->stok_col = curoff - state_bol;
286 tk->stok_file = state_path;
287 tk->stok_next = NULL;
288
289 return tk;
290 }
291 /* Read identifiers, using an obstack. */
292 else if (ISALPHA (c) || c == '_' || c == '$' || c == '!' || c == '#')
293 {
294 struct obstack id_obstack;
295 struct state_ident_st *sid = NULL;
296 char *ids = NULL;
297 obstack_init (&id_obstack);
298 curoff = ftell (state_file);
299 while (ISALNUM (c) || c == '_' || c == '$' || c == '!' || c == '#')
300 {
301 obstack_1grow (&id_obstack, c);
302 c = getc (state_file);
303 if (c < 0)
304 break;
305 };
306 if (c >= 0)
307 ungetc (c, state_file);
308 obstack_1grow (&id_obstack, (char) 0);
309 ids = XOBFINISH (&id_obstack, char *);
310 sid = state_ident_by_name (ids, INSERT);
23756963 311 obstack_free (&id_obstack, NULL);
92724e1d
BS		 312 ids = NULL;
313 tk = XCNEW (struct state_token_st);
314 tk->stok_kind = STOK_NAME;
315 tk->stok_line = state_line;
316 tk->stok_col = curoff - state_bol;
317 tk->stok_file = state_path;
318 tk->stok_next = NULL;
319 tk->stok_un.stok_ident = sid;
320
321 return tk;
322 }
323 /* Read a string, dealing with escape sequences a la C! */
324 else if (c == '"')
325 {
326 char *cstr = NULL;
327 int cslen = 0;
328 struct obstack bstring_obstack;
329 obstack_init (&bstring_obstack);
330 curoff = ftell (state_file);
331 while ((c = getc (state_file)) != '"' && c >= 0)
332 {
333 if (ISPRINT (c) && c != '\\')
334 obstack_1grow (&bstring_obstack, (char) c);
335 else if (ISSPACE (c) && c != '\n')
336 obstack_1grow (&bstring_obstack, (char) c);
337 else if (c == '\\')
338 {
339 c = getc (state_file);
340 switch (c)
341 {
342 case 'a':
343 obstack_1grow (&bstring_obstack, '\a');
344 c = getc (state_file);
345 break;
346 case 'b':
347 obstack_1grow (&bstring_obstack, '\b');
348 c = getc (state_file);
349 break;
350 case 't':
351 obstack_1grow (&bstring_obstack, '\t');
352 c = getc (state_file);
353 break;
354 case 'n':
355 obstack_1grow (&bstring_obstack, '\n');
356 c = getc (state_file);
357 break;
358 case 'v':
359 obstack_1grow (&bstring_obstack, '\v');
360 c = getc (state_file);
361 break;
362 case 'f':
363 obstack_1grow (&bstring_obstack, '\f');
364 c = getc (state_file);
365 break;
366 case 'r':
367 obstack_1grow (&bstring_obstack, '\r');
368 c = getc (state_file);
369 break;
370 case '"':
371 obstack_1grow (&bstring_obstack, '\"');
372 c = getc (state_file);
373 break;
374 case '\\':
375 obstack_1grow (&bstring_obstack, '\\');
376 c = getc (state_file);
377 break;
378 case ' ':
379 obstack_1grow (&bstring_obstack, ' ');
380 c = getc (state_file);
381 break;
382 case 'x':
383 {
384 unsigned int cx = 0;
385 if (fscanf (state_file, "%02x", &cx) > 0 && cx > 0)
386 obstack_1grow (&bstring_obstack, cx);
387 else
388 fatal_reading_state
389 (NULL_STATE_TOKEN,
390 "Lexical error in string hex escape");
391 c = getc (state_file);
392 break;
393 }
394 default:
395 fatal_reading_state
396 (NULL_STATE_TOKEN,
397 "Lexical error - unknown string escape");
398 }
399 }
400 else
401 fatal_reading_state (NULL_STATE_TOKEN, "Lexical error...");
402 };
403 if (c != '"')
404 fatal_reading_state (NULL_STATE_TOKEN, "Unterminated string");
405 obstack_1grow (&bstring_obstack, '\0');
406 cstr = XOBFINISH (&bstring_obstack, char *);
407 cslen = strlen (cstr);
408 tk = (struct state_token_st *)
409 xcalloc (sizeof (struct state_token_st) + cslen, 1);
410 tk->stok_kind = STOK_STRING;
411 tk->stok_line = state_line;
412 tk->stok_col = curoff - state_bol;
413 tk->stok_file = state_path;
414 tk->stok_next = NULL;
415 strcpy (tk->stok_un.stok_string, cstr);
23756963 416 obstack_free (&bstring_obstack, NULL);
92724e1d
BS		 417
418 return tk;
419 }
420 /* Got an unexpected character. */
421 fatal_reading_state_printf
422 (NULL_STATE_TOKEN,
423 "Lexical error at offset %ld - bad character \\%03o = '%c'",
424 ftell (state_file), c, c);
425}
426
427/* Used for lexical look-ahead. Retrieves the lexical token of rank
428 DEPTH, starting with 0 when reading the state file. Gives null on
429 end of file. */
430static struct state_token_st *
431peek_state_token (int depth)
432{
433 int remdepth = depth;
434 struct state_token_st **ptoken = &state_token;
435 struct state_token_st *tok = NULL;
436
437 while (remdepth >= 0)
438 {
439 if (*ptoken == NULL)
440 {
441 *ptoken = tok = read_a_state_token ();
442 if (tok == NULL)
443 return NULL;
444 }
445 tok = *ptoken;
446 ptoken = &((*ptoken)->stok_next);
447 remdepth--;
448 }
449
450 return tok;
451}
452
453/* Consume the next DEPTH tokens and free them. */
454static void
455next_state_tokens (int depth)
456{
457 struct state_token_st *n;
458
459 while (depth > 0)
460 {
461 if (state_token != NULL)
462 {
463 n = state_token->stok_next;
464 free (state_token);
465 state_token = n;
466 }
467 else
468 fatal_reading_state (NULL_STATE_TOKEN, "Tokens stack empty");
469
470 depth--;
471 }
472}
473
474/* Safely retrieve the lexical kind of a token. */
475static inline enum state_token_en
476state_token_kind (struct state_token_st *p)
477{
478 if (p == NULL)
479 return STOK_NONE;
480 else
481 return p->stok_kind;
482}
483
484/* Test if a token is a given name i.e. an identifier. */
485static inline bool
486state_token_is_name (struct state_token_st *p, const char *name)
487{
488 if (p == NULL)
489 return false;
490
491 if (p->stok_kind != STOK_NAME)
492 return false;
493
494 return !strcmp (p->stok_un.stok_ident->stid_name, name);
495}
496
497
498/* Following routines are useful for serializing datas.
499 *
500 * We want to serialize :
501 * - typedefs list
502 * - structures list
503 * - param_structs list
504 * - variables list
505 *
506 * So, we have one routine for each kind of data. The main writing
507 * routine is write_state. The main reading routine is
508 * read_state. Most writing routines write_state_FOO have a
509 * corresponding reading routine read_state_FOO. Reading is done in a
510 * recursive descending way, and any read error is fatal.
511 */
512
513/* When reading the state, we need to remember the previously seen
514 types by their state_number, since GTY-ed types are usually
515 shared. */
516static htab_t state_seen_types;
517
518/* Return the length of a linked list made of pairs. */
519static int pair_list_length (pair_p list);
520
521/* Write a pair */
522static void write_state_pair (pair_p);
523
524/* return the number of pairs written. Should match the length given
525 by pair_list_length. */
526static int write_state_pair_list (pair_p list);
527
528/* Write a type. When a type is written, its state_number is updated,
529 to ensure that a "reference" to a seen type is written on next
530 occurrences. */
531static void write_state_type (type_p);
532
533/* Write a null-terminatel string using our Lispy lexical conventions,
534 similar to those of C or MELT. */
535static void write_state_a_string (const char *s);
536
537/* Compute the length of a list of pairs, starting from the first
538 one. */
539static int
540pair_list_length (pair_p list)
541{
542 int nbpair = 0;
543 pair_p l = NULL;
544 for (l = list; l; l = l->next)
545 nbpair++;
546 return nbpair;
547}
548
549/* Write a file location. Files relative to $(srcdir) are quite
550 frequent and are handled specially. This ensures that two gengtype
551 state file-s produced by gengtype on the same GCC source tree are
552 very similar and can be reasonably compared with diff, even if the
553 two GCC source trees have different absolute paths. */
554static void
555write_state_fileloc (struct fileloc *floc)
556{
557
558 if (floc != NULL && floc->line > 0)
559 {
560 const char *srcrelpath = NULL;
561 gcc_assert (floc->file != NULL);
562 /* Most of the files are inside $(srcdir) so it is worth to
563 handle them specially. */
564 srcrelpath = get_file_srcdir_relative_path (floc->file);
565 if (srcrelpath != NULL)
566 {
567 fprintf (state_file, "\n(!srcfileloc ");
568 write_state_a_string (srcrelpath);
569 }
570 else
571 {
572 fprintf (state_file, "\n(!fileloc ");
573 write_state_a_string (get_input_file_name (floc->file));
574 }
575 fprintf (state_file, " %d", floc->line);
576 fprintf (state_file, ")\n");
577 }
578 else
579 fprintf (state_file, "nil ");
580}
581
582/* Write a list of fields. */
583static void
584write_state_fields (pair_p fields)
585{
586 int nbfields = pair_list_length (fields);
587 int nbpairs = 0;
588 fprintf (state_file, "\n(!fields %d ", nbfields);
589 nbpairs = write_state_pair_list (fields);
590 gcc_assert (nbpairs == nbfields);
591 fprintf (state_file, ")\n");
592}
593
594/* Write a null-terminated string in our lexical convention, very
595 similar to the convention of C. */
596static void
597write_state_a_string (const char *s)
598{
599 char c;
600
601 fputs (" \"", state_file);
602 for (; *s != 0; s++)
603 {
604 c = *s;
605 switch (c)
606 {
607 case '\a':
608 fputs ("\\a", state_file);
609 break;
610 case '\b':
611 fputs ("\\b", state_file);
612 break;
613 case '\t':
614 fputs ("\\t", state_file);
615 break;
616 case '\n':
617 fputs ("\\n", state_file);
618 break;
619 case '\v':
620 fputs ("\\v", state_file);
621 break;
622 case '\f':
623 fputs ("\\f", state_file);
624 break;
625 case '\r':
626 fputs ("\\r", state_file);
627 break;
628 case '\"':
629 fputs ("\\\"", state_file);
630 break;
631 case '\\':
632 fputs ("\\\\", state_file);
633 break;
634 default:
635 if (ISPRINT (c))
636 putc (c, state_file);
637 else
638 fprintf (state_file, "\\x%02x", (unsigned) c);
639 }
640 }
641 fputs ("\"", state_file);
642}
643
644/* Our option-s have three kinds, each with its writer. */
645static void
646write_state_string_option (options_p current)
647{
648 fprintf (state_file, "string ");
649 if (current->info.string != NULL)
650 write_state_a_string (current->info.string);
651 else
652 fprintf (state_file, " nil ");
653}
654
655static void
656write_state_type_option (options_p current)
657{
658 fprintf (state_file, "type ");
659 write_state_type (current->info.type);
660}
661
662static void
663write_state_nested_option (options_p current)
664{
665 fprintf (state_file, "nested ");
666 write_state_type (current->info.nested->type);
667 if (current->info.nested->convert_from != NULL)
668 write_state_a_string (current->info.nested->convert_from);
669 else
670 fprintf (state_file, " nil ");
671
672 if (current->info.nested->convert_to != NULL)
673 write_state_a_string (current->info.nested->convert_to);
674 else
675 fprintf (state_file, " nil ");
676}
677
678static void
679write_state_option (options_p current)
680{
681 fprintf (state_file, "\n(!option ");
682
683 if (current->name != NULL)
684 fprintf (state_file, "%s ", current->name);
685 else
686 fprintf (state_file, "nil ");
687
688 switch (current->kind)
689 {
690 case OPTION_STRING:
691 write_state_string_option (current);
692 break;
693 case OPTION_TYPE:
694 write_state_type_option (current);
695 break;
696 case OPTION_NESTED:
697 write_state_nested_option (current);
698 break;
699 default:
700 fatal ("Option tag unknown");
701 }
702
703 fprintf (state_file, ")\n");
704}
705
706
707
708/* Write a list of GTY options. */
709static void
710write_state_options (options_p opt)
711{
712 options_p current;
713
714 if (opt == NULL)
715 {
716 fprintf (state_file, "nil ");
717 return;
718 }
719
720 fprintf (state_file, "\n(!options ");
721 for (current = opt; current != NULL; current = current->next)
722 write_state_option (current);
723 fprintf (state_file, ")\n");
724}
725
726
727/* Write a bitmap representing a set of GCC front-end languages. */
728static void
729write_state_lang_bitmap (lang_bitmap bitmap)
730{
731 fprintf (state_file, "%d ", (int) bitmap);
732}
733
734/* Write version information. */
735static void
736write_state_version (const char *version)
737{
738 fprintf (state_file, "\n(!version ");
739 write_state_a_string (version);
740 fprintf (state_file, ")\n");
741}
742
743/* Common routine to write the common content of all types. */
744static void write_state_common_type_content (type_p current);
745
746/* Write a scalar type. We have only two of these. */
747static void
748write_state_scalar_type (type_p current)
749{
750 if (current == &scalar_nonchar)
751 fprintf (state_file, "scalar_nonchar ");
752 else if (current == &scalar_char)
753 fprintf (state_file, "scalar_char ");
754 else
755 fatal ("Unexpected type in write_state_scalar_type");
756
757 write_state_common_type_content (current);
758}
759
760/* Write the string type. There is only one such thing! */
761static void
762write_state_string_type (type_p current)
763{
764 if (current == &string_type)
765 {
766 fprintf (state_file, "string ");
767 write_state_common_type_content (current);
768 }
769 else
770 fatal ("Unexpected type in write_state_string_type");
771}
772
773
774/* Common code to write structure like types. */
775static void
776write_state_struct_union_type (type_p current, const char *kindstr)
777{
778 DBGPRINTF ("%s type @ %p #%d '%s'", kindstr, (void *) current,
779 current->state_number, current->u.s.tag);
780 fprintf (state_file, "%s ", kindstr);
781 write_state_common_type_content (current);
782 if (current->u.s.tag != NULL)
783 write_state_a_string (current->u.s.tag);
784 else
785 fprintf (state_file, "nil");
786
787 write_state_fileloc (type_lineloc (current));
788 write_state_fields (current->u.s.fields);
789 write_state_options (current->u.s.opt);
790 write_state_lang_bitmap (current->u.s.bitmap);
791}
792
793
794/* Write a GTY struct type. */
795static void
796write_state_struct_type (type_p current)
797{
798 write_state_struct_union_type (current, "struct");
799 write_state_type (current->u.s.lang_struct);
800}
801
0823efed
DN		 802/* Write a GTY user-defined struct type. */
803static void
804write_state_user_struct_type (type_p current)
805{
806 DBGPRINTF ("user_struct type @ %p #%d '%s'", (void *) current,
807 current->state_number, current->u.s.tag);
808 fprintf (state_file, "user_struct ");
809 write_state_common_type_content (current);
810 if (current->u.s.tag != NULL)
811 write_state_a_string (current->u.s.tag);
812 else
813 fprintf (state_file, "nil");
814 write_state_fileloc (type_lineloc (current));
815 write_state_fields (current->u.s.fields);
816}
817
92724e1d
BS		 818/* write a GTY union type. */
819static void
820write_state_union_type (type_p current)
821{
822 write_state_struct_union_type (current, "union");
823 write_state_type (current->u.s.lang_struct);
824}
825
826/* Write a lang_struct type. This is tricky and was painful to debug,
827 we deal with the next field specifically within their lang_struct
828 subfield, which points to a linked list of homonumous types.
829 Change this function with extreme care, see also
830 read_state_lang_struct_type. */
831static void
832write_state_lang_struct_type (type_p current)
833{
834 int nbhomontype = 0;
835 type_p hty = NULL;
836 const char *homoname = 0;
837 write_state_struct_union_type (current, "lang_struct");
073a8998 838 /* lang_struct-ures are particularly tricky, since their
92724e1d
BS		 839 u.s.lang_struct field gives a list of homonymous struct-s or
840 union-s! */
841 DBGPRINTF ("lang_struct @ %p #%d", (void *) current, current->state_number);
842 for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next)
843 {
844 nbhomontype++;
845 DBGPRINTF ("homonymous #%d hty @ %p #%d '%s'", nbhomontype,
846 (void *) hty, hty->state_number, hty->u.s.tag);
847 /* Every member of the homonymous list should have the same tag. */
0823efed 848 gcc_assert (union_or_struct_p (hty));
92724e1d
BS		 849 gcc_assert (hty->u.s.lang_struct == current);
850 if (!homoname)
851 homoname = hty->u.s.tag;
852 gcc_assert (strcmp (homoname, hty->u.s.tag) == 0);
853 }
854 fprintf (state_file, "(!homotypes %d\n", nbhomontype);
855 for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next)
856 write_state_type (hty);
857 fprintf (state_file, ")\n");
858}
859
860/* Write a parametrized structure GTY type. */
861static void
862write_state_param_struct_type (type_p current)
863{
864 int i;
865
866 fprintf (state_file, "param_struct ");
867 write_state_common_type_content (current);
868 write_state_type (current->u.param_struct.stru);
869 for (i = 0; i < NUM_PARAM; i++)
870 {
871 if (current->u.param_struct.param[i] != NULL)
872 write_state_type (current->u.param_struct.param[i]);
873 else
874 fprintf (state_file, "nil ");
875 }
876 write_state_fileloc (&current->u.param_struct.line);
877}
878
879/* Write a pointer type. */
880static void
881write_state_pointer_type (type_p current)
882{
883 fprintf (state_file, "pointer ");
884 write_state_common_type_content (current);
885 write_state_type (current->u.p);
886}
887
888/* Write an array type. */
889static void
890write_state_array_type (type_p current)
891{
892 fprintf (state_file, "array ");
893 write_state_common_type_content (current);
894 if (current->u.a.len != NULL)
895 write_state_a_string (current->u.a.len);
896 else
897 fprintf (state_file, " nil");
898
899 fprintf (state_file, " ");
900 write_state_type (current->u.a.p);
901}
902
903/* Write the gc_used information. */
904static void
905write_state_gc_used (enum gc_used_enum gus)
906{
907 switch (gus)
908 {
909 case GC_UNUSED:
910 fprintf (state_file, " gc_unused");
911 break;
912 case GC_USED:
913 fprintf (state_file, " gc_used");
914 break;
915 case GC_MAYBE_POINTED_TO:
916 fprintf (state_file, " gc_maybe_pointed_to");
917 break;
918 case GC_POINTED_TO:
919 fprintf (state_file, " gc_pointed_to");
920 break;
921 default:
922 gcc_unreachable ();
923 }
924}
925
926/* Utility routine to write the common content of all types. Notice
927 that the next field is *not* written on purpose. */
928static void
929write_state_common_type_content (type_p current)
930{
931 fprintf (state_file, "%d ", current->state_number);
932 /* We do not write the next type, because list of types are
933 explicitly written. However, lang_struct are special in that
934 respect. See function write_state_lang_struct_type for more. */
935 write_state_type (current->pointer_to);
936 write_state_gc_used (current->gc_used);
937}
938
939
940/* The important and recursive routine writing GTY types as understood
941 by gengtype. Types which have a positive state_number have already
942 been seen and written. */
943static void
944write_state_type (type_p current)
945{
946 if (current == NULL)
947 {
948 fprintf (state_file, "nil ");
949 return;
950 }
951
952 fprintf (state_file, "\n(!type ");
953
954 if (current->state_number > 0)
955 fprintf (state_file, "already_seen %d", current->state_number);
956 else
957 {
958 state_written_type_count++;
959 DBGPRINTF ("writing type #%d @%p old number %d", state_written_type_count,
960 (void *) current, current->state_number);
961 current->state_number = state_written_type_count;
962 switch (current->kind)
963 {
964 case TYPE_STRUCT:
965 write_state_struct_type (current);
966 break;
0823efed
DN		 967 case TYPE_USER_STRUCT:
968 write_state_user_struct_type (current);
969 break;
92724e1d
BS		 970 case TYPE_UNION:
971 write_state_union_type (current);
972 break;
973 case TYPE_POINTER:
974 write_state_pointer_type (current);
975 break;
976 case TYPE_ARRAY:
977 write_state_array_type (current);
978 break;
979 case TYPE_LANG_STRUCT:
980 write_state_lang_struct_type (current);
981 break;
982 case TYPE_PARAM_STRUCT:
983 write_state_param_struct_type (current);
984 break;
985 case TYPE_SCALAR:
986 write_state_scalar_type (current);
987 break;
988 case TYPE_STRING:
989 write_state_string_type (current);
990 break;
991
992 default:
993 fatal ("Unexpected type...");
994 }
995 }
996
997 fprintf (state_file, ")\n");
998}
999
1000
1001/* Write a pair. */
1002static void
1003write_state_pair (pair_p current)
1004{
1005 if (current == NULL)
1006 {
1007 fprintf (state_file, "nil)");
1008 return;
1009 }
1010
1011 fprintf (state_file, "\n(!pair ");
1012
1013 if (current->name != NULL)
1014 write_state_a_string (current->name);
1015 else
1016 write_state_a_string ("nil");
1017
1018 write_state_type (current->type);
1019 write_state_fileloc (&(current->line));
1020 write_state_options (current->opt);
1021
1022 fprintf (state_file, ")");
1023}
1024
1025/* Write a pair list and return the number of pairs written. */
1026static int
1027write_state_pair_list (pair_p list)
1028{
1029 int nbpair = 0;
1030 pair_p current;
1031
1032 for (current = list; current != NULL; current = current->next)
1033 {
1034 write_state_pair (current);
1035 nbpair++;
1036 }
1037 return nbpair;
1038
1039}
1040
1041/* When writing imported linked lists, like typedefs, structures,
1042 param_structs, ... we count their length first and write it. These
1043 eases the reading, and enables an extra verification on the number
1044 of actually read items. */
1045
1046/* Write our typedefs. */
1047static void
1048write_state_typedefs (void)
1049{
1050 int nbtypedefs = pair_list_length (typedefs);
1051 int nbpairs = 0;
1052 fprintf (state_file, "\n(!typedefs %d\n", nbtypedefs);
1053 nbpairs = write_state_pair_list (typedefs);
1054 gcc_assert (nbpairs == nbtypedefs);
1055 fprintf (state_file, ")\n");
1056 if (verbosity_level >= 2)
1057 printf ("%s wrote %d typedefs\n", progname, nbtypedefs);
1058}
1059
1060/* Write our structures. */
1061static void
1062write_state_structures (void)
1063{
1064 int nbstruct = 0;
1065 type_p current;
1066
1067 for (current = structures; current != NULL; current = current->next)
1068 nbstruct++;
1069
1070 fprintf (state_file, "\n(!structures %d\n", nbstruct);
1071
1072 for (current = structures; current != NULL; current = current->next)
1073 write_state_type (current);
1074
1075 fprintf (state_file, ")\n");
1076 if (verbosity_level >= 2)
1077 printf ("%s wrote %d structures in state\n", progname, nbstruct);
1078}
1079
1080/* Write our param_struct-s. */
1081static void
1082write_state_param_structs (void)
1083{
1084 int nbparamstruct = 0;
1085 type_p current;
1086
1087 for (current = param_structs; current != NULL; current = current->next)
1088 nbparamstruct++;
1089
1090 fprintf (state_file, "\n(!param_structs %d\n", nbparamstruct);
1091
1092 for (current = param_structs; current != NULL; current = current->next)
1093 write_state_type (current);
1094
1095 fprintf (state_file, ")\n");
1096}
1097
1098/* Write our variables. */
1099static void
1100write_state_variables (void)
1101{
1102 int nbvars = pair_list_length (variables);
1103 int nbpairs = 0;
1104 fprintf (state_file, "\n(!variables %d\n", nbvars);
1105 nbpairs = write_state_pair_list (variables);
1106 gcc_assert (nbpairs == nbvars);
1107 fprintf (state_file, ")\n");
1108 if (verbosity_level >= 2)
1109 printf ("%s wrote %d variables.\n", progname, nbvars);
1110}
1111
1112/* Write the source directory. File locations within the source
1113 directory have been written specifically. */
1114static void
1115write_state_srcdir (void)
1116{
1117 fprintf (state_file, "\n(!srcdir ");
1118 write_state_a_string (srcdir);
1119 fprintf (state_file, ")\n");
1120}
1121
1122/* Count and write the list of our files. */
1123static void
1124write_state_files_list (void)
1125{
1126 int i = 0;
1127 /* Write the list of files with their lang_bitmap. */
1128 fprintf (state_file, "\n(!fileslist %d\n", (int) num_gt_files);
1129 for (i = 0; i < (int) num_gt_files; i++)
1130 {
1131 const char *cursrcrelpath = NULL;
1132 const input_file *curfil = gt_files[i];
1133 /* Most of the files are inside $(srcdir) so it is worth to
1134 handle them specially. */
1135 cursrcrelpath = get_file_srcdir_relative_path (curfil);
1136 if (cursrcrelpath)
1137 {
1138 fprintf (state_file, "(!srcfile %d ", get_lang_bitmap (curfil));
1139 write_state_a_string (cursrcrelpath);
1140 }
1141 else
1142 {
1143 fprintf (state_file, "(!file %d ", get_lang_bitmap (curfil));
1144 write_state_a_string (get_input_file_name (curfil));
1145 }
1146 fprintf (state_file, ")\n");
1147 }
1148 fprintf (state_file, ")\n");
1149}
1150
1151/* Write the list of GCC front-end languages. */
1152static void
1153write_state_languages (void)
1154{
1155 int i = 0;
1156 fprintf (state_file, "\n(!languages %d", (int) num_lang_dirs);
1157 for (i = 0; i < (int) num_lang_dirs; i++)
1158 {
1159 /* Languages names are identifiers, we expect only letters or
1160 underscores or digits in them. In particular, C++ is not a
1161 valid language name, but cp is valid. */
1162 fprintf (state_file, " %s", lang_dir_names[i]);
1163 }
1164 fprintf (state_file, ")\n");
1165}
1166
1167/* Write the trailer. */
1168static void
1169write_state_trailer (void)
1170{
1171 /* This test should probably catch IO errors like disk full... */
1172 if (fputs ("\n(!endfile)\n", state_file) == EOF)
1173 fatal ("failed to write state trailer [%s]", xstrerror (errno));
1174}
1175
1176/* The write_state routine is the only writing routine called by main
1177 in gengtype.c. To avoid messing the state if gengtype is
1178 interrupted or aborted, we write a temporary file and rename it
1179 after having written it in totality. */
1180void
1181write_state (const char *state_path)
1182{
1183 long statelen = 0;
1184 time_t now = 0;
1185 char *temp_state_path = NULL;
1186 char tempsuffix[40];
1187 time (&now);
1188
1189 /* We write a unique temporary file which is renamed when complete
1190 * only. So even if gengtype is interrupted, the written state file
1191 * won't be partially written, since the temporary file is not yet
1192 * renamed in that case. */
1193 memset (tempsuffix, 0, sizeof (tempsuffix));
1194 snprintf (tempsuffix, sizeof (tempsuffix) - 1, "-%ld-%d.tmp", (long) now,
1195 (int) getpid ());
1196 temp_state_path = concat (state_path, tempsuffix, NULL);
1197 state_file = fopen (temp_state_path, "w");
1198 if (state_file == NULL)
1199 fatal ("Failed to open file %s for writing state: %s",
1200 temp_state_path, xstrerror (errno));
1201 if (verbosity_level >= 3)
1202 printf ("%s writing state file %s temporarily in %s\n",
1203 progname, state_path, temp_state_path);
1204 /* This is the first line of the state. Perhaps the file utility
1205 could know about that, so don't change it often. */
1206 fprintf (state_file, ";;;;@@@@ GCC gengtype state\n");
1207 /* Output a few comments for humans. */
1208 fprintf (state_file,
1209 ";;; DON'T EDIT THIS FILE, since generated by GCC's gengtype\n");
1210 fprintf (state_file,
1211 ";;; The format of this file is tied to a particular version of GCC.\n");
1212 fprintf (state_file,
1213 ";;; Don't parse this file wihout knowing GCC gengtype internals.\n");
1214 fprintf (state_file,
1215 ";;; This file should be parsed by the same %s which wrote it.\n",
1216 progname);
92724e1d
BS		 1217 /* The first non-comment significant line gives the version string. */
1218 write_state_version (version_string);
1219 write_state_srcdir ();
1220 write_state_languages ();
1221 write_state_files_list ();
1222 write_state_structures ();
1223 write_state_typedefs ();
1224 write_state_param_structs ();
1225 write_state_variables ();
1226 write_state_trailer ();
1227 statelen = ftell (state_file);
1228 if (ferror (state_file))
1229 fatal ("output error when writing state file %s [%s]",
1230 temp_state_path, xstrerror (errno));
1231 if (fclose (state_file))
1232 fatal ("failed to close state file %s [%s]",
1233 temp_state_path, xstrerror (errno));
1234 if (rename (temp_state_path, state_path))
1235 fatal ("failed to rename %s to state file %s [%s]", temp_state_path,
1236 state_path, xstrerror (errno));
1237 free (temp_state_path);
1238
1239 if (verbosity_level >= 1)
1240 printf ("%s wrote state file %s of %ld bytes with %d GTY-ed types\n",
1241 progname, state_path, statelen, state_written_type_count);
1242
1243}
1244\f
1245/** End of writing routines! The corresponding reading routines follow. **/
1246
1247
1248
1249/* Forward declarations, since some read_state_* functions are
1250 recursive! */
1251static void read_state_fileloc (struct fileloc *line);
1252static void read_state_options (options_p *opt);
1253static void read_state_type (type_p *current);
1254static void read_state_pair (pair_p *pair);
1255/* Return the number of pairs actually read. */
1256static int read_state_pair_list (pair_p *list);
1257static void read_state_fields (pair_p *fields);
1258static void read_state_common_type_content (type_p current);
1259
1260
1261
1262
1263/* Record into the state_seen_types hash-table a type which we are
1264 reading, to enable recursive or circular references to it. */
1265static void
1266record_type (type_p type)
1267{
1268 PTR *slot;
1269
1270 slot = htab_find_slot (state_seen_types, type, INSERT);
1271 gcc_assert (slot);
1272
1273 *slot = type;
1274}
1275
1276/* Read an already seen type. */
1277static void
1278read_state_already_seen_type (type_p *type)
1279{
1280 struct state_token_st *t0 = peek_state_token (0);
1281
1282 if (state_token_kind (t0) == STOK_INTEGER)
1283 {
1284 PTR *slot = NULL;
1285 struct type loctype = { TYPE_SCALAR, 0, 0, 0, GC_UNUSED, {0} };
1286
1287 loctype.state_number = t0->stok_un.stok_num;
1288 slot = htab_find_slot (state_seen_types, &loctype, NO_INSERT);
1289 if (slot == NULL)
1290 {
1291 fatal_reading_state (t0, "Unknown type");
1292 }
1293
1294 next_state_tokens (1);
1295 *type = (type_p) *slot;
1296 }
1297 else
1298 {
1299 fatal_reading_state (t0, "Bad seen type");
1300 }
1301}
1302
1303
1304/* Read the scalar_nonchar type. */
1305static void
1306read_state_scalar_nonchar_type (type_p *type)
1307{
1308 *type = &scalar_nonchar;
1309 read_state_common_type_content (*type);
1310}
1311
1312
1313/* Read the scalar_char type. */
1314static void
1315read_state_scalar_char_type (type_p *type)
1316{
1317 *type = &scalar_char;
1318 read_state_common_type_content (*type);
1319}
1320
1321
1322/* Read the string_type. */
1323static void
1324read_state_string_type (type_p *type)
1325{
1326 *type = &string_type;
1327 read_state_common_type_content (*type);
1328}
1329
1330
1331/* Read a lang_bitmap representing a set of GCC front-end languages. */
1332static void
1333read_state_lang_bitmap (lang_bitmap *bitmap)
1334{
1335 struct state_token_st *t;
1336
1337 t = peek_state_token (0);
1338 if (state_token_kind (t) == STOK_INTEGER)
1339 {
1340 *bitmap = t->stok_un.stok_num;
1341 next_state_tokens (1);
1342 }
1343 else
1344 {
1345 fatal_reading_state (t, "Bad syntax for bitmap");
1346 }
1347}
1348
1349
1350/* Read a GTY-ed struct type. */
1351static void
1352read_state_struct_type (type_p type)
1353{
1354 struct state_token_st *t0;
1355
1356 type->kind = TYPE_STRUCT;
1357 read_state_common_type_content (type);
1358 t0 = peek_state_token (0);
1359 if (state_token_kind (t0) == STOK_STRING)
1360 {
1361 if (state_token_is_name (t0, "nil"))
1362 {
1363 type->u.s.tag = NULL;
1364 DBGPRINTF ("read anonymous struct type @%p #%d",
1365 (void *) type, type->state_number);
1366 }
1367 else
1368 {
1369 type->u.s.tag = xstrdup (t0->stok_un.stok_string);
1370 DBGPRINTF ("read struct type @%p #%d '%s'",
1371 (void *) type, type->state_number, type->u.s.tag);
1372 }
1373
1374 next_state_tokens (1);
1375 read_state_fileloc (&(type->u.s.line));
1376 read_state_fields (&(type->u.s.fields));
1377 read_state_options (&(type->u.s.opt));
1378 read_state_lang_bitmap (&(type->u.s.bitmap));
1379 read_state_type (&(type->u.s.lang_struct));
1380 }
1381 else
1382 {
1383 fatal_reading_state (t0, "Bad tag in struct type");
1384 }
1385}
1386
1387
0823efed
DN		 1388/* Read a GTY-ed user-provided struct TYPE. */
1389
1390static void
1391read_state_user_struct_type (type_p type)
1392{
1393 struct state_token_st *t0;
1394
1395 type->kind = TYPE_USER_STRUCT;
1396 read_state_common_type_content (type);
1397 t0 = peek_state_token (0);
1398 if (state_token_kind (t0) == STOK_STRING)
1399 {
1400 if (state_token_is_name (t0, "nil"))
1401 {
1402 type->u.s.tag = NULL;
1403 DBGPRINTF ("read anonymous struct type @%p #%d",
1404 (void *) type, type->state_number);
1405 }
1406 else
1407 {
1408 type->u.s.tag = xstrdup (t0->stok_un.stok_string);
1409 DBGPRINTF ("read struct type @%p #%d '%s'",
1410 (void *) type, type->state_number, type->u.s.tag);
1411 }
1412
1413 next_state_tokens (1);
1414 read_state_fileloc (&(type->u.s.line));
1415 read_state_fields (&(type->u.s.fields));
1416 }
1417 else
1418 {
1419 fatal_reading_state (t0, "Bad tag in user-struct type");
1420 }
1421}
1422
1423
92724e1d
BS		 1424/* Read a GTY-ed union type. */
1425static void
1426read_state_union_type (type_p type)
1427{
1428 struct state_token_st *t0;
1429
1430 type->kind = TYPE_UNION;
1431 read_state_common_type_content (type);
1432 t0 = peek_state_token (0);
1433 if (state_token_kind (t0) == STOK_STRING)
1434 {
1435 if (state_token_is_name (t0, "nil"))
1436 {
1437 type->u.s.tag = NULL;
1438 DBGPRINTF ("read anonymous union type @%p #%d",
1439 (void *) type, type->state_number);
1440 }
1441 else
1442 {
1443 type->u.s.tag = xstrdup (t0->stok_un.stok_string);
1444 DBGPRINTF ("read union type @%p #%d '%s'",
1445 (void *) type, type->state_number, type->u.s.tag);
1446 }
1447 next_state_tokens (1);
1448 read_state_fileloc (&(type->u.s.line));
1449 read_state_fields (&(type->u.s.fields));
1450 read_state_options (&(type->u.s.opt));
1451 read_state_lang_bitmap (&(type->u.s.bitmap));
1452 read_state_type (&(type->u.s.lang_struct));
1453 }
1454 else
1455 fatal_reading_state (t0, "Bad tag in union type");
1456}
1457
1458
1459/* Read a GTY-ed pointer type. */
1460static void
1461read_state_pointer_type (type_p type)
1462{
1463 type->kind = TYPE_POINTER;
1464 read_state_common_type_content (type);
1465 DBGPRINTF ("read pointer type @%p #%d", (void *) type, type->state_number);
1466 read_state_type (&(type->u.p));
1467}
1468
1469
1470/* Read a GTY-ed array type. */
1471static void
1472read_state_array_type (type_p type)
1473{
1474 struct state_token_st *t0;
1475
1476 type->kind = TYPE_ARRAY;
1477 read_state_common_type_content (type);
1478 t0 = peek_state_token (0);
1479 if (state_token_kind (t0) == STOK_STRING)
1480 {
1481 type->u.a.len = xstrdup (t0->stok_un.stok_string);
1482 DBGPRINTF ("read array type @%p #%d length '%s'",
1483 (void *) type, type->state_number, type->u.a.len);
1484 next_state_tokens (1);
1485 }
1486
1487 else if (state_token_is_name (t0, "nil"))
1488 {
1489 type->u.a.len = NULL;
1490 DBGPRINTF ("read array type @%p #%d without length",
1491 (void *) type, type->state_number);
1492 next_state_tokens (1);
1493 }
1494
1495 else
1496 fatal_reading_state (t0, "Bad array name type");
1497 read_state_type (&(type->u.a.p));
1498}
1499
1500
1501
1502/* Read a lang_struct type for GTY-ed struct-s which depends upon GCC
1503 front-end languages. This is a tricky function and it was painful
1504 to debug. Change it with extreme care. See also
1505 write_state_lang_struct_type. */
1506static void
1507read_state_lang_struct_type (type_p type)
1508{
1509 struct state_token_st *t0 = NULL;
1510 struct state_token_st *t1 = NULL;
1511 struct state_token_st *t2 = NULL;
1512
1513 type->kind = TYPE_LANG_STRUCT;
1514 read_state_common_type_content (type);
1515 t0 = peek_state_token (0);
1516 if (state_token_kind (t0) == STOK_STRING)
1517 {
1518 if (state_token_is_name (t0, "nil"))
1519 {
1520 DBGPRINTF ("read anonymous lang_struct type @%p #%d",
1521 (void *) type, type->state_number);
1522 type->u.s.tag = NULL;
1523 }
1524 else
1525 {
1526 type->u.s.tag = xstrdup (t0->stok_un.stok_string);
1527 DBGPRINTF ("read lang_struct type @%p #%d '%s'",
1528 (void *) type, type->state_number, type->u.s.tag);
1529 }
1530 next_state_tokens (1);
1531 }
1532 else
1533 fatal_reading_state (t0, "Bad tag in lang struct type");
1534 read_state_fileloc (&(type->u.s.line));
1535 read_state_fields (&(type->u.s.fields));
1536 read_state_options (&(type->u.s.opt));
1537 read_state_lang_bitmap (&(type->u.s.bitmap));
1538 /* Within lang_struct-ures, the lang_struct field is a linked list
1539 of homonymous types! */
1540 t0 = peek_state_token (0);
1541 t1 = peek_state_token (1);
1542 t2 = peek_state_token (2);
1543 /* Parse (!homotypes <number-types> <type-1> .... <type-n>) */
1544 if (state_token_kind (t0) == STOK_LEFTPAR
1545 && state_token_is_name (t1, "!homotypes")
1546 && state_token_kind (t2) == STOK_INTEGER)
1547 {
1548 type_p *prevty = &type->u.s.lang_struct;
1549 int nbhomotype = t2->stok_un.stok_num;
1550 int i = 0;
1551 t0 = t1 = t2 = NULL;
1552 next_state_tokens (3);
1553 for (i = 0; i < nbhomotype; i++)
1554 {
1555 read_state_type (prevty);
1556 t0 = peek_state_token (0);
1557 if (*prevty)
1558 prevty = &(*prevty)->next;
1559 else
1560 fatal_reading_state (t0,
1561 "expecting type in homotype list for lang_struct");
1562 };
1563 if (state_token_kind (t0) != STOK_RIGHTPAR)
1564 fatal_reading_state (t0,
1565 "expecting ) in homotype list for lang_struct");
1566 next_state_tokens (1);
1567 }
1568 else
1569 fatal_reading_state (t0, "expecting !homotypes for lang_struct");
1570}
1571
1572
1573/* Read a param_struct type for GTY parametrized structures. */
1574static void
1575read_state_param_struct_type (type_p type)
1576{
1577 int i;
1578 struct state_token_st *t0;
1579
1580 type->kind = TYPE_PARAM_STRUCT;
1581 read_state_common_type_content (type);
1582 DBGPRINTF ("read param_struct type @%p #%d",
1583 (void *) type, type->state_number);
1584 read_state_type (&(type->u.param_struct.stru));
1585
1586 for (i = 0; i < NUM_PARAM; i++)
1587 {
1588 t0 = peek_state_token (0);
1589 if (state_token_is_name (t0, "nil"))
1590 {
1591 type->u.param_struct.param[i] = NULL;
1592 next_state_tokens (1);
1593 }
1594 else
1595 read_state_type (&(type->u.param_struct.param[i]));
1596 }
1597 read_state_fileloc (&(type->u.param_struct.line));
1598}
1599
1600
1601/* Read the gc used information. */
1602static void
1603read_state_gc_used (enum gc_used_enum *pgus)
1604{
1605 struct state_token_st *t0 = peek_state_token (0);
1606 if (state_token_is_name (t0, "gc_unused"))
1607 *pgus = GC_UNUSED;
1608 else if (state_token_is_name (t0, "gc_used"))
1609 *pgus = GC_USED;
1610 else if (state_token_is_name (t0, "gc_maybe_pointed_to"))
1611 *pgus = GC_MAYBE_POINTED_TO;
1612 else if (state_token_is_name (t0, "gc_pointed_to"))
1613 *pgus = GC_POINTED_TO;
1614 else
1615 fatal_reading_state (t0, "invalid gc_used information");
1616 next_state_tokens (1);
1617}
1618
1619
1620/* Utility function to read the common content of types. */
1621static void
1622read_state_common_type_content (type_p current)
1623{
1624 struct state_token_st *t0 = peek_state_token (0);
1625
1626 if (state_token_kind (t0) == STOK_INTEGER)
1627 {
1628 current->state_number = t0->stok_un.stok_num;
1629 next_state_tokens (1);
1630 record_type (current);
1631 }
1632 else
1633 fatal_reading_state_printf (t0,
1634 "Expected integer for state_number line %d",
1635 state_line);
1636 /* We don't read the next field of the type. */
1637 read_state_type (&current->pointer_to);
1638 read_state_gc_used (&current->gc_used);
1639}
1640
1641
1642/* Read a GTY-ed type. */
1643void
1644read_state_type (type_p *current)
1645{
1646 struct state_token_st *t0 = peek_state_token (0);
1647 struct state_token_st *t1 = peek_state_token (1);
1648
1649 if (state_token_kind (t0) == STOK_LEFTPAR &&
1650 state_token_is_name (t1, "!type"))
1651 {
1652 next_state_tokens (2);
1653 t0 = peek_state_token (0);
1654 if (state_token_is_name (t0, "already_seen"))
1655 {
1656 next_state_tokens (1);
1657 read_state_already_seen_type (current);
1658 }
1659 else
1660 {
1661 t0 = peek_state_token (0);
1662
1663 if (state_token_is_name (t0, "scalar_nonchar"))
1664 {
1665 next_state_tokens (1);
1666 read_state_scalar_nonchar_type (current);
1667 }
1668 else if (state_token_is_name (t0, "scalar_char"))
1669 {
1670 next_state_tokens (1);
1671 read_state_scalar_char_type (current);
1672 }
1673 else if (state_token_is_name (t0, "string"))
1674 {
1675 next_state_tokens (1);
1676 read_state_string_type (current);
1677 }
1678 else if (state_token_is_name (t0, "struct"))
1679 {
1680 *current = XCNEW (struct type);
1681 next_state_tokens (1);
1682 read_state_struct_type (*current);
1683 }
1684 else if (state_token_is_name (t0, "union"))
1685 {
1686 *current = XCNEW (struct type);
1687 next_state_tokens (1);
1688 read_state_union_type (*current);
1689 }
1690 else if (state_token_is_name (t0, "lang_struct"))
1691 {
1692 *current = XCNEW (struct type);
1693 next_state_tokens (1);
1694 read_state_lang_struct_type (*current);
1695 }
1696 else if (state_token_is_name (t0, "param_struct"))
1697 {
1698 *current = XCNEW (struct type);
1699 next_state_tokens (1);
1700 read_state_param_struct_type (*current);
1701 }
1702 else if (state_token_is_name (t0, "pointer"))
1703 {
1704 *current = XCNEW (struct type);
1705 next_state_tokens (1);
1706 read_state_pointer_type (*current);
1707 }
1708 else if (state_token_is_name (t0, "array"))
1709 {
1710 *current = XCNEW (struct type);
1711 next_state_tokens (1);
1712 read_state_array_type (*current);
1713 }
0823efed
DN		 1714 else if (state_token_is_name (t0, "user_struct"))
1715 {
1716 *current = XCNEW (struct type);
1717 next_state_tokens (1);
1718 read_state_user_struct_type (*current);
1719 }
92724e1d
BS		 1720 else
1721 fatal_reading_state (t0, "bad type in (!type");
1722 }
1723 t0 = peek_state_token (0);
1724 if (state_token_kind (t0) != STOK_RIGHTPAR)
1725 fatal_reading_state (t0, "missing ) in type");
1726 next_state_tokens (1);
1727 }
1728 else if (state_token_is_name (t0, "nil"))
1729 {
1730 next_state_tokens (1);
1731 *current = NULL;
1732 }
1733 else
1734 fatal_reading_state (t0, "bad type syntax");
1735}
1736
1737
1738/* Read a file location. Files within the source directory are dealt
1739 with specifically. */
1740void
1741read_state_fileloc (struct fileloc *floc)
1742{
1743 bool issrcfile = false;
1744 struct state_token_st *t0 = peek_state_token (0);
1745 struct state_token_st *t1 = peek_state_token (1);
1746
1747 gcc_assert (floc != NULL);
1748 gcc_assert (srcdir != NULL);
1749
1750 if (state_token_kind (t0) == STOK_LEFTPAR &&
1751 (state_token_is_name (t1, "!fileloc")
1752 || (issrcfile = state_token_is_name (t1, "!srcfileloc"))))
1753 {
1754 next_state_tokens (2);
1755 t0 = peek_state_token (0);
1756 t1 = peek_state_token (1);
1757 if (state_token_kind (t0) == STOK_STRING &&
1758 state_token_kind (t1) == STOK_INTEGER)
1759 {
1760 char *path = t0->stok_un.stok_string;
1761 if (issrcfile)
1762 {
1763 static const char dirsepstr[2] = { DIR_SEPARATOR, (char) 0 };
1764 char *fullpath = concat (srcdir, dirsepstr, path, NULL);
1765 floc->file = input_file_by_name (fullpath);
1766 free (fullpath);
1767 }
1768 else
1769 floc->file = input_file_by_name (path);
1770 floc->line = t1->stok_un.stok_num;
1771 next_state_tokens (2);
1772 }
1773 else
1774 fatal_reading_state (t0,
1775 "Bad fileloc syntax, expected path string and line");
1776 t0 = peek_state_token (0);
1777 if (state_token_kind (t0) != STOK_RIGHTPAR)
1778 fatal_reading_state (t0, "Bad fileloc syntax, expected )");
1779 next_state_tokens (1);
1780 }
1781 else if (state_token_is_name (t0, "nil"))
1782 {
1783 next_state_tokens (1);
1784 floc->file = NULL;
1785 floc->line = 0;
1786 }
1787 else
1788 fatal_reading_state (t0, "Bad fileloc syntax");
1789}
1790
1791
1792/* Read the fields of a GTY-ed type. */
1793void
1794read_state_fields (pair_p *fields)
1795{
1796 pair_p tmp = NULL;
1797 struct state_token_st *t0 = peek_state_token (0);
1798 struct state_token_st *t1 = peek_state_token (1);
1799 struct state_token_st *t2 = peek_state_token (2);
1800
1801 if (state_token_kind (t0) == STOK_LEFTPAR
1802 && state_token_is_name (t1, "!fields")
1803 && state_token_kind (t2) == STOK_INTEGER)
1804 {
1805 int nbfields = t2->stok_un.stok_num;
1806 int nbpairs = 0;
1807 next_state_tokens (3);
1808 nbpairs = read_state_pair_list (&tmp);
1809 t0 = peek_state_token (0);
1810 if (nbpairs != nbfields)
1811 fatal_reading_state_printf
1812 (t0,
1813 "Mismatched fields number, expected %d got %d", nbpairs, nbfields);
1814 if (state_token_kind (t0) == STOK_RIGHTPAR)
1815 next_state_tokens (1);
1816 else
1817 fatal_reading_state (t0, "Bad fields expecting )");
1818 }
1819
1820 *fields = tmp;
1821}
1822
1823
1824/* Read a string option. */
1825static void
1826read_state_string_option (options_p opt)
1827{
1828 struct state_token_st *t0 = peek_state_token (0);
1829 opt->kind = OPTION_STRING;
1830 if (state_token_kind (t0) == STOK_STRING)
1831 {
1832 opt->info.string = xstrdup (t0->stok_un.stok_string);
1833 next_state_tokens (1);
1834 }
1835 else if (state_token_is_name (t0, "nil"))
1836 {
1837 opt->info.string = NULL;
1838 next_state_tokens (1);
1839 }
1840 else
1841 fatal_reading_state (t0, "Missing name in string option");
1842}
1843
1844
1845/* Read a type option. */
1846static void
1847read_state_type_option (options_p opt)
1848{
1849 opt->kind = OPTION_TYPE;
1850 read_state_type (&(opt->info.type));
1851}
1852
1853
1854/* Read a nested option. */
1855static void
1856read_state_nested_option (options_p opt)
1857{
1858 struct state_token_st *t0;
1859
1860 opt->info.nested = XCNEW (struct nested_ptr_data);
1861 opt->kind = OPTION_NESTED;
1862 read_state_type (&(opt->info.nested->type));
1863 t0 = peek_state_token (0);
1864 if (state_token_kind (t0) == STOK_STRING)
1865 {
1866 opt->info.nested->convert_from = xstrdup (t0->stok_un.stok_string);
1867 next_state_tokens (1);
1868 }
1869 else if (state_token_is_name (t0, "nil"))
1870 {
1871 opt->info.nested->convert_from = NULL;
1872 next_state_tokens (1);
1873 }
1874 else
1875 fatal_reading_state (t0, "Bad nested convert_from option");
1876
1877 t0 = peek_state_token (0);
1878 if (state_token_kind (t0) == STOK_STRING)
1879 {
1880 opt->info.nested->convert_to = xstrdup (t0->stok_un.stok_string);
1881 next_state_tokens (1);
1882 }
1883 else if (state_token_is_name (t0, "nil"))
1884 {
1885 opt->info.nested->convert_to = NULL;
1886 next_state_tokens (1);
1887 }
1888 else
1889 fatal_reading_state (t0, "Bad nested convert_from option");
1890}
1891
1892
1893/* Read an GTY option. */
1894static void
1895read_state_option (options_p *opt)
1896{
1897 struct state_token_st *t0 = peek_state_token (0);
1898 struct state_token_st *t1 = peek_state_token (1);
1899
1900 if (state_token_kind (t0) == STOK_LEFTPAR &&
1901 state_token_is_name (t1, "!option"))
1902 {
1903 next_state_tokens (2);
1904 t0 = peek_state_token (0);
1905 if (state_token_kind (t0) == STOK_NAME)
1906 {
1907 *opt = XCNEW (struct options);
1908 if (state_token_is_name (t0, "nil"))
1909 (*opt)->name = NULL;
1910 else
1911 (*opt)->name = t0->stok_un.stok_ident->stid_name;
1912 next_state_tokens (1);
1913 t0 = peek_state_token (0);
1914 if (state_token_kind (t0) == STOK_NAME)
1915 {
1916 if (state_token_is_name (t0, "string"))
1917 {
1918 next_state_tokens (1);
1919 read_state_string_option (*opt);
1920 }
1921 else if (state_token_is_name (t0, "type"))
1922 {
1923 next_state_tokens (1);
1924 read_state_type_option (*opt);
1925 }
1926 else if (state_token_is_name (t0, "nested"))
1927 {
1928 next_state_tokens (1);
1929 read_state_nested_option (*opt);
1930 }
1931 else
1932 fatal_reading_state (t0, "Bad option type");
1933 t0 = peek_state_token (0);
1934 if (state_token_kind (t0) != STOK_RIGHTPAR)
1935 fatal_reading_state (t0, "Bad syntax in option, expecting )");
1936
1937 next_state_tokens (1);
1938 }
1939 else
1940 fatal_reading_state (t0, "Missing option type");
1941 }
1942 else
1943 fatal_reading_state (t0, "Bad name for option");
1944 }
1945 else
1946 fatal_reading_state (t0, "Bad option, waiting for )");
1947}
1948
1949/* Read a list of options. */
1950void
1951read_state_options (options_p *opt)
1952{
1953 options_p head = NULL;
1954 options_p previous = NULL;
1955 options_p current_option = NULL;
1956 struct state_token_st *t0 = peek_state_token (0);
1957 struct state_token_st *t1 = peek_state_token (1);
1958
1959 if (state_token_kind (t0) == STOK_LEFTPAR &&
1960 state_token_is_name (t1, "!options"))
1961 {
1962 next_state_tokens (2);
1963 t0 = peek_state_token (0);
1964 while (state_token_kind (t0) != STOK_RIGHTPAR)
1965 {
1966 read_state_option (&current_option);
1967 if (head == NULL)
1968 {
1969 head = current_option;
1970 previous = head;
1971 }
1972 else
1973 {
1974 previous->next = current_option;
1975 previous = current_option;
1976 }
1977 t0 = peek_state_token (0);
1978 }
1979 next_state_tokens (1);
1980 }
1981 else if (state_token_is_name (t0, "nil"))
1982 {
1983 next_state_tokens (1);
1984 }
1985 else
1986 fatal_reading_state (t0, "Bad options syntax");
1987
1988 *opt = head;
1989}
1990
1991
1992/* Read a version, and check against the version of the gengtype. */
1993static void
1994read_state_version (const char *version_string)
1995{
1996 struct state_token_st *t0 = peek_state_token (0);
1997 struct state_token_st *t1 = peek_state_token (1);
1998
1999 if (state_token_kind (t0) == STOK_LEFTPAR &&
2000 state_token_is_name (t1, "!version"))
2001 {
2002 next_state_tokens (2);
2003 t0 = peek_state_token (0);
2004 t1 = peek_state_token (1);
2005 if (state_token_kind (t0) == STOK_STRING &&
2006 state_token_kind (t1) == STOK_RIGHTPAR)
2007 {
2008 /* Check that the read version string is the same as current
2009 version. */
2010 if (strcmp (version_string, t0->stok_un.stok_string))
2011 fatal_reading_state_printf (t0,
2012 "version string mismatch; expecting %s but got %s",
2013 version_string,
2014 t0->stok_un.stok_string);
2015 next_state_tokens (2);
2016 }
2017 else
2018 fatal_reading_state (t0, "Missing version or right parenthesis");
2019 }
2020 else
2021 fatal_reading_state (t0, "Bad version syntax");
2022}
2023
2024
2025/* Read a pair. */
2026void
2027read_state_pair (pair_p *current)
2028{
2029 struct state_token_st *t0 = peek_state_token (0);
2030 struct state_token_st *t1 = peek_state_token (1);
2031 if (state_token_kind (t0) == STOK_LEFTPAR &&
2032 state_token_is_name (t1, "!pair"))
2033 {
2034 *current = XCNEW (struct pair);
2035 next_state_tokens (2);
2036 t0 = peek_state_token (0);
2037 if (state_token_kind (t0) == STOK_STRING)
2038 {
2039 if (strcmp (t0->stok_un.stok_string, "nil") == 0)
2040 {
2041 (*current)->name = NULL;
2042 }
2043 else
2044 {
2045 (*current)->name = xstrdup (t0->stok_un.stok_string);
2046 }
2047 next_state_tokens (1);
2048 read_state_type (&((*current)->type));
2049 read_state_fileloc (&((*current)->line));
2050 read_state_options (&((*current)->opt));;
2051 t0 = peek_state_token (0);
2052 if (state_token_kind (t0) == STOK_RIGHTPAR)
2053 {
2054 next_state_tokens (1);
2055 }
2056 else
2057 {
2058 fatal_reading_state (t0, "Bad syntax for pair, )");
2059 }
2060 }
2061 else
2062 {
2063 fatal_reading_state (t0, "Bad name for pair");
2064 }
2065 }
2066 else if (state_token_kind (t0) == STOK_NAME &&
2067 state_token_is_name (t0, "nil"))
2068 {
2069 next_state_tokens (1);
2070 *current = NULL;
2071 }
2072 else
2073 fatal_reading_state_printf (t0, "Bad syntax for pair, (!pair %d",
2074 state_token->stok_kind);
2075}
2076
2077
2078/* Return the number of pairs actually read. */
2079int
2080read_state_pair_list (pair_p *list)
2081{
2082 int nbpair = 0;
2083 pair_p head = NULL;
2084 pair_p previous = NULL;
2085 pair_p tmp = NULL;
2086 struct state_token_st *t0 = peek_state_token (0);
2087 while (t0 && state_token_kind (t0) != STOK_RIGHTPAR)
2088 {
2089 read_state_pair (&tmp);
2090 if (head == NULL)
2091 {
2092 head = tmp;
2093 previous = head;
2094 }
2095 else
2096 {
2097 previous->next = tmp;
2098 previous = tmp;
2099 }
2100 t0 = peek_state_token (0);
2101 nbpair++;
2102 }
2103
2104 /* don't consume the ); the caller will eat it. */
2105 *list = head;
2106 return nbpair;
2107}
2108
2109/* Read the typedefs. */
2110static void
2111read_state_typedefs (pair_p *typedefs)
2112{
2113 int nbtypedefs = 0;
2114 pair_p list = NULL;
2115 struct state_token_st *t0 = peek_state_token (0);
2116 struct state_token_st *t1 = peek_state_token (1);
2117 struct state_token_st *t2 = peek_state_token (2);
2118
2119 if (state_token_kind (t0) == STOK_LEFTPAR
2120 && state_token_is_name (t1, "!typedefs")
2121 && state_token_kind (t2) == STOK_INTEGER)
2122 {
2123 int nbpairs = 0;
2124 nbtypedefs = t2->stok_un.stok_num;
2125 next_state_tokens (3);
2126 nbpairs = read_state_pair_list (&list);
2127 t0 = peek_state_token (0);
2128 if (nbpairs != nbtypedefs)
2129 fatal_reading_state_printf
2130 (t0,
2131 "invalid number of typedefs, expected %d but got %d",
2132 nbtypedefs, nbpairs);
2133 if (state_token_kind (t0) == STOK_RIGHTPAR)
2134 next_state_tokens (1);
2135 else
2136 fatal_reading_state (t0, "Bad typedefs syntax )");
2137 }
2138 else
2139 fatal_reading_state (t0, "Bad typedefs syntax (!typedefs");
2140
2141 if (verbosity_level >= 2)
2142 printf ("%s read %d typedefs from state\n", progname, nbtypedefs);
2143 *typedefs = list;
2144}
2145
2146
2147/* Read the structures. */
2148static void
2149read_state_structures (type_p *structures)
2150{
2151 type_p head = NULL;
be827591 2152 type_p previous = NULL;
92724e1d
BS		 2153 type_p tmp;
2154 int nbstruct = 0, countstruct = 0;
2155 struct state_token_st *t0 = peek_state_token (0);
2156 struct state_token_st *t1 = peek_state_token (1);
2157 struct state_token_st *t2 = peek_state_token (2);
2158
2159 if (state_token_kind (t0) == STOK_LEFTPAR
2160 && state_token_is_name (t1, "!structures")
2161 && state_token_kind (t2) == STOK_INTEGER)
2162 {
2163 nbstruct = t2->stok_un.stok_num;
2164 next_state_tokens (3);
2165 t0 = peek_state_token (0);
2166 while (t0 && state_token_kind (t0) != STOK_RIGHTPAR)
2167 {
2168 tmp = NULL;
2169 read_state_type (&tmp);
2170 countstruct++;
2171 if (head == NULL)
2172 {
2173 head = tmp;
2174 previous = head;
2175 }
2176 else
2177 {
2178 previous->next = tmp;
2179 previous = tmp;
2180 }
2181 t0 = peek_state_token (0);
2182 }
2183 next_state_tokens (1);
2184 }
2185 else
2186 fatal_reading_state (t0, "Bad structures syntax");
2187 if (countstruct != nbstruct)
2188 fatal_reading_state_printf (NULL_STATE_TOKEN,
2189 "expected %d structures but got %d",
2190 nbstruct, countstruct);
2191 if (verbosity_level >= 2)
2192 printf ("%s read %d structures from state\n", progname, nbstruct);
2193 *structures = head;
2194}
2195
2196
2197/* Read the param_struct-s. */
2198static void
2199read_state_param_structs (type_p *param_structs)
2200{
2201 int nbparamstructs = 0;
2202 int countparamstructs = 0;
2203 type_p head = NULL;
70efc82d 2204 type_p previous = NULL;
92724e1d
BS		 2205 type_p tmp;
2206 struct state_token_st *t0 = peek_state_token (0);
2207 struct state_token_st *t1 = peek_state_token (1);
2208 struct state_token_st *t2 = peek_state_token (2);
2209
2210 if (state_token_kind (t0) == STOK_LEFTPAR
2211 && state_token_is_name (t1, "!param_structs")
2212 && state_token_kind (t2) == STOK_INTEGER)
2213 {
2214 nbparamstructs = t2->stok_un.stok_num;
2215 next_state_tokens (3);
2216 t0 = t1 = t2 = NULL;
2217 t0 = peek_state_token (0);
2218 while (state_token_kind (t0) != STOK_RIGHTPAR)
2219 {
2220 tmp = NULL;
2221 read_state_type (&tmp);
2222 if (head == NULL)
2223 {
2224 head = tmp;
2225 previous = head;
2226 }
2227 else
2228 {
2229 previous->next = tmp;
2230 previous = tmp;
2231 }
2232 t0 = peek_state_token (0);
2233 countparamstructs++;
2234 }
2235 next_state_tokens (1);
2236 }
2237 else
2238 fatal_reading_state (t0, "Bad param_structs syntax");
2239 t0 = peek_state_token (0);
2240 if (countparamstructs != nbparamstructs)
2241 fatal_reading_state_printf
2242 (t0,
2243 "invalid number of param_structs expected %d got %d",
2244 nbparamstructs, countparamstructs);
2245 *param_structs = head;
2246}
2247
2248
2249/* Read the variables. */
2250static void
2251read_state_variables (pair_p *variables)
2252{
2253 pair_p list = NULL;
2254 int nbvars = 0;
2255 struct state_token_st *t0 = peek_state_token (0);
2256 struct state_token_st *t1 = peek_state_token (1);
2257 struct state_token_st *t2 = peek_state_token (2);
2258
2259 if (state_token_kind (t0) == STOK_LEFTPAR
2260 && state_token_is_name (t1, "!variables")
2261 && state_token_kind (t2) == STOK_INTEGER)
2262 {
2263 int nbpairs = 0;
2264 nbvars = t2->stok_un.stok_num;
2265 next_state_tokens (3);
2266 nbpairs = read_state_pair_list (&list);
2267 t0 = peek_state_token (0);
2268 if (nbpairs != nbvars)
2269 fatal_reading_state_printf
2270 (t0, "Invalid number of variables, expected %d but got %d",
2271 nbvars, nbpairs);
2272 if (state_token_kind (t0) == STOK_RIGHTPAR)
2273 next_state_tokens (1);
2274 else
2275 fatal_reading_state (t0, "Waiting for ) in variables");
2276 }
2277 else
2278 fatal_reading_state (t0, "Bad variables syntax");
2279 *variables = list;
2280 if (verbosity_level >= 2)
2281 printf ("%s read %d variables from state\n", progname, nbvars);
2282}
2283
2284
2285/* Read the source directory. */
2286static void
2287read_state_srcdir (void)
2288{
2289 struct state_token_st *t0 = peek_state_token (0);
2290 struct state_token_st *t1 = peek_state_token (1);
2291 if (state_token_kind (t0) == STOK_LEFTPAR &&
2292 state_token_is_name (t1, "!srcdir"))
2293 {
2294 next_state_tokens (2);
2295 t0 = peek_state_token (0);
2296 t1 = peek_state_token (1);
2297 if (state_token_kind (t0) == STOK_STRING &&
2298 state_token_kind (t1) == STOK_RIGHTPAR)
2299 {
2300 srcdir = xstrdup (t0->stok_un.stok_string);
2301 srcdir_len = strlen (srcdir);
2302 next_state_tokens (2);
2303 return;
2304 }
2305 }
2306
2307 fatal_reading_state (t0, "Bad srcdir in state_file");
2308}
2309
2310
2311/* Read the sequence of GCC front-end languages. */
2312static void
2313read_state_languages (void)
2314{
2315 struct state_token_st *t0 = peek_state_token (0);
2316 struct state_token_st *t1 = peek_state_token (1);
2317 struct state_token_st *t2 = peek_state_token (2);
2318 if (state_token_kind (t0) == STOK_LEFTPAR
2319 && state_token_is_name (t1, "!languages")
2320 && state_token_kind (t2) == STOK_INTEGER)
2321 {
2322 int i = 0;
2323 num_lang_dirs = t2->stok_un.stok_num;
2324 lang_dir_names = XCNEWVEC (const char *, num_lang_dirs);
2325 next_state_tokens (3);
2326 t0 = t1 = t2 = NULL;
2327 for (i = 0; i < (int) num_lang_dirs; i++)
2328 {
2329 t0 = peek_state_token (0);
2330 if (state_token_kind (t0) != STOK_NAME)
2331 fatal_reading_state (t0, "expecting language name in state file");
2332 lang_dir_names[i] = t0->stok_un.stok_ident->stid_name;
2333 next_state_tokens (1);
2334 }
2335 t0 = peek_state_token (0);
2336 if (state_token_kind (t0) != STOK_RIGHTPAR)
2337 fatal_reading_state (t0, "missing ) in languages list of state file");
2338 next_state_tokens (1);
2339 }
2340 else
2341 fatal_reading_state (t0, "expecting languages list in state file");
2342
2343}
2344
2345/* Read the sequence of files. */
2346static void
2347read_state_files_list (void)
2348{
2349 struct state_token_st *t0 = peek_state_token (0);
2350 struct state_token_st *t1 = peek_state_token (1);
2351 struct state_token_st *t2 = peek_state_token (2);
2352
2353 if (state_token_kind (t0) == STOK_LEFTPAR
2354 && state_token_is_name (t1, "!fileslist")
2355 && state_token_kind (t2) == STOK_INTEGER)
2356 {
2357 int i = 0;
2358 num_gt_files = t2->stok_un.stok_num;
2359 next_state_tokens (3);
2360 t0 = t1 = t2 = NULL;
2361 gt_files = XCNEWVEC (const input_file *, num_gt_files);
2362 for (i = 0; i < (int) num_gt_files; i++)
2363 {
2364 bool issrcfile = FALSE;
2365 t0 = t1 = t2 = NULL;
2366 t0 = peek_state_token (0);
2367 t1 = peek_state_token (1);
2368 t2 = peek_state_token (2);
2369 if (state_token_kind (t0) == STOK_LEFTPAR
2370 && (state_token_is_name (t1, "!file")
2371 || (issrcfile = state_token_is_name (t1, "!srcfile")))
2372 && state_token_kind (t2) == STOK_INTEGER)
2373 {
2374 lang_bitmap bmap = t2->stok_un.stok_num;
2375 next_state_tokens (3);
2376 t0 = t1 = t2 = NULL;
2377 t0 = peek_state_token (0);
2378 t1 = peek_state_token (1);
2379 if (state_token_kind (t0) == STOK_STRING
2380 && state_token_kind (t1) == STOK_RIGHTPAR)
2381 {
2382 const char *fnam = t0->stok_un.stok_string;
2383 /* Allocate & fill a gt_file entry with space for the lang_bitmap before! */
2384 input_file *curgt = NULL;
2385 if (issrcfile)
2386 {
2387 static const char dirsepstr[2] =
2388 { DIR_SEPARATOR, (char) 0 };
2389 char *fullpath = concat (srcdir, dirsepstr, fnam, NULL);
2390 curgt = input_file_by_name (fullpath);
2391 free (fullpath);
2392 }
2393 else
2394 curgt = input_file_by_name (fnam);
2395 set_lang_bitmap (curgt, bmap);
2396 gt_files[i] = curgt;
2397 next_state_tokens (2);
2398 }
2399 else
2400 fatal_reading_state (t0,
2401 "bad file in !fileslist of state file");
2402 }
2403 else
2404 fatal_reading_state (t0,
2405 "expecting file in !fileslist of state file");
2406 };
2407 t0 = peek_state_token (0);
2408 if (!state_token_kind (t0) == STOK_RIGHTPAR)
2409 fatal_reading_state (t0, "missing ) for !fileslist in state file");
2410 next_state_tokens (1);
2411 }
2412 else
2413 fatal_reading_state (t0, "missing !fileslist in state file");
2414}
2415
2416
2417/* Read the trailer. */
2418static void
2419read_state_trailer (void)
2420{
2421 struct state_token_st *t0 = peek_state_token (0);
2422 struct state_token_st *t1 = peek_state_token (1);
2423 struct state_token_st *t2 = peek_state_token (2);
2424
2425 if (state_token_kind (t0) == STOK_LEFTPAR
2426 && state_token_is_name (t1, "!endfile")
2427 && state_token_kind (t2) == STOK_RIGHTPAR)
2428 next_state_tokens (3);
2429 else
2430 fatal_reading_state (t0, "missing !endfile in state file");
2431}
2432
2433
2434/* Utility functions for the state_seen_types hash table. */
2435static unsigned
2436hash_type_number (const void *ty)
2437{
2438 const struct type *type = (const struct type *) ty;
2439
2440 return type->state_number;
2441}
2442
2443static int
2444equals_type_number (const void *ty1, const void *ty2)
2445{
2446 const struct type *type1 = (const struct type *) ty1;
2447 const struct type *type2 = (const struct type *) ty2;
2448
2449 return type1->state_number == type2->state_number;
2450}
2451
897e0a89
NP		 2452static int
2453string_eq (const void *a, const void *b)
2454{
2455 const char *a0 = (const char *)a;
2456 const char *b0 = (const char *)b;
2457
2458 return (strcmp (a0, b0) == 0);
2459}
2460
92724e1d
BS		 2461
2462/* The function reading the state, called by main from gengtype.c. */
2463void
2464read_state (const char *path)
2465{
2466 state_file = fopen (path, "r");
2467 if (state_file == NULL)
2468 fatal ("Failed to open state file %s for reading [%s]", path,
2469 xstrerror (errno));
2470 state_path = path;
2471 state_line = 1;
2472
2473 if (verbosity_level >= 1)
2474 {
2475 printf ("%s reading state file %s;", progname, state_path);
2476 if (verbosity_level >= 2)
2477 putchar ('\n');
2478 fflush (stdout);
2479 }
2480
2481 state_seen_types =
2482 htab_create (2017, hash_type_number, equals_type_number, NULL);
2483 state_ident_tab =
897e0a89 2484 htab_create (4027, htab_hash_string, string_eq, NULL);
92724e1d
BS		 2485 read_state_version (version_string);
2486 read_state_srcdir ();
2487 read_state_languages ();
2488 read_state_files_list ();
2489 read_state_structures (&structures);
2490 if (ferror (state_file))
2491 fatal_reading_state_printf
2492 (NULL_STATE_TOKEN, "input error while reading state [%s]",
2493 xstrerror (errno));
2494 read_state_typedefs (&typedefs);
2495 read_state_param_structs (&param_structs);
2496 read_state_variables (&variables);
2497 read_state_trailer ();
2498
2499 if (verbosity_level >= 1)
2500 {
2501 printf ("%s read %ld bytes.\n", progname, ftell (state_file));
2502 fflush (stdout);
2503 };
2504
2505 if (fclose (state_file))
2506 fatal ("failed to close read state file %s [%s]",
2507 path, xstrerror (errno));
2508 state_file = NULL;
2509 state_path = NULL;
2510}
2511
2512/* End of file gengtype-state.c. */
Mirror of https://gcc.gnu.org/git/gcc.git