1/* Process source files and output type information.
2   Copyright (C) 2002-2015 Free Software Foundation, Inc.
3
4   This file is part of GCC.
5
6   GCC is free software; you can redistribute it and/or modify it under
7   the terms of the GNU General Public License as published by the Free
8   Software Foundation; either version 3, or (at your option) any later
9   version.
10
11   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12   WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with GCC; see the file COPYING3.  If not see
18   <http://www.gnu.org/licenses/>.  */
19
20#ifndef GCC_GENGTYPE_H
21#define GCC_GENGTYPE_H
22
23#define obstack_chunk_alloc    xmalloc
24#define obstack_chunk_free     free
25#define OBSTACK_CHUNK_SIZE     0
26
27/* Sets of accepted source languages like C, C++, Ada... are
28   represented by a bitmap.  */
29typedef unsigned lang_bitmap;
30
31/* Variable length structure representing an input file.  A hash table
32   ensure uniqueness for a given input file name.  The only function
33   allocating input_file-s is input_file_by_name.  */
34struct input_file_st
35{
36  struct outf* inpoutf;  /* Cached corresponding output file, computed
37                            in get_output_file_with_visibility.  */
38  lang_bitmap inpbitmap; /* The set of languages using this file.  */
39  bool inpisplugin;      /* Flag set for plugin input files.  */
40  char inpname[1];       /* A variable-length array, ended by a null
41                            char.  */
42};
43typedef struct input_file_st input_file;
44
45/* A file position, mostly for error messages.
46   The FILE element may be compared using pointer equality.  */
47struct fileloc
48{
49  const input_file *file;
50  int line;
51};
52
53
54/* Table of all input files and its size.  */
55extern const input_file** gt_files;
56extern size_t num_gt_files;
57
58/* A number of places use the name of this "gengtype.c" file for a
59   location for things that we can't rely on the source to define.  We
60   also need to refer to the "system.h" file specifically.  These two
61   pointers are initialized early in main.  */
62extern input_file* this_file;
63extern input_file* system_h_file;
64
65/* Retrieve or create the input_file for a given name, which is a file
66   path.  This is the only function allocating input_file-s and it is
67   hash-consing them.  */
68input_file* input_file_by_name (const char* name);
69
70/* For F an input_file, return the relative path to F from $(srcdir)
71   if the latter is a prefix in F, NULL otherwise.  */
72const char *get_file_srcdir_relative_path (const input_file *inpf);
73
74/* Get the name of an input file.  */
75static inline const char*
76get_input_file_name (const input_file *inpf)
77{
78  if (inpf)
79      return inpf->inpname;
80  return NULL;
81}
82
83/* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
84   INPUT_FILE is used by <lang>.
85
86   This function should be written to assume that a file _is_ used
87   if the situation is unclear.  If it wrongly assumes a file _is_ used,
88   a linker error will result.  If it wrongly assumes a file _is not_ used,
89   some GC roots may be missed, which is a much harder-to-debug problem.
90  */
91
92static inline lang_bitmap
93get_lang_bitmap (const input_file* inpf)
94{
95  if (inpf == NULL)
96    return 0;
97  return inpf->inpbitmap;
98}
99
100/* Set the bitmap returned by get_lang_bitmap.  The only legitimate
101   callers of this function are read_input_list & read_state_*.  */
102static inline void
103set_lang_bitmap (input_file* inpf, lang_bitmap n)
104{
105  gcc_assert (inpf);
106  inpf->inpbitmap = n;
107}
108
109/* Vector of per-language directories.  */
110extern const char **lang_dir_names;
111extern size_t num_lang_dirs;
112
113/* Data types handed around within, but opaque to, the lexer and parser.  */
114typedef struct pair *pair_p;
115typedef struct type *type_p;
116typedef const struct type *const_type_p;
117typedef struct options *options_p;
118
119/* Variables used to communicate between the lexer and the parser.  */
120extern int lexer_toplevel_done;
121extern struct fileloc lexer_line;
122
123/* Various things, organized as linked lists, needed both in
124   gengtype.c & in gengtype-state.c files.  */
125extern pair_p typedefs;
126extern type_p structures;
127extern pair_p variables;
128
129/* An enum for distinguishing GGC vs PCH.  */
130
131enum write_types_kinds
132{
133  WTK_GGC,
134  WTK_PCH,
135
136  NUM_WTK
137};
138
139/* Discrimating kind of types we can understand.  */
140
141enum typekind {
142  TYPE_NONE=0,          /* Never used, so zeroed memory is invalid.  */
143  TYPE_UNDEFINED,	/* We have not yet seen a definition for this type.
144			   If a type is still undefined when generating code,
145			   an error will be generated.  */
146  TYPE_SCALAR,          /* Scalar types like char.  */
147  TYPE_STRING,          /* The string type.  */
148  TYPE_STRUCT,          /* Type for GTY-ed structs.  */
149  TYPE_UNION,           /* Type for GTY-ed discriminated unions.  */
150  TYPE_POINTER,         /* Pointer type to GTY-ed type.  */
151  TYPE_ARRAY,           /* Array of GTY-ed types.  */
152  TYPE_LANG_STRUCT,     /* GCC front-end language specific structs.
153                           Various languages may have homonymous but
154                           different structs.  */
155  TYPE_USER_STRUCT	/* User defined type.  Walkers and markers for
156			   this type are assumed to be provided by the
157			   user.  */
158};
159
160/* Discriminating kind for options.  */
161enum option_kind {
162  OPTION_NONE=0,        /* Never used, so zeroed memory is invalid.  */
163  OPTION_STRING,        /* A string-valued option.  Most options are
164                           strings.  */
165  OPTION_TYPE,          /* A type-valued option.  */
166  OPTION_NESTED         /* Option data for 'nested_ptr'.  */
167};
168
169
170/* A way to pass data through to the output end.  */
171struct options {
172  struct options *next;         /* next option of the same pair.  */
173  const char *name;             /* GTY option name.  */
174  enum option_kind kind;        /* discriminating option kind.  */
175  union {
176    const char* string;                    /* When OPTION_STRING.  */
177    type_p type;                           /* When OPTION_TYPE.  */
178    struct nested_ptr_data* nested;        /* when OPTION_NESTED.  */
179  } info;
180};
181
182
183/* Option data for the 'nested_ptr' option.  */
184struct nested_ptr_data {
185  type_p type;
186  const char *convert_to;
187  const char *convert_from;
188};
189
190/* Some functions to create various options structures with name NAME
191   and info INFO.  NEXT is the next option in the chain.  */
192
193/* Create a string option.  */
194options_p create_string_option (options_p next, const char* name,
195                                const char* info);
196
197/* Create a type option.  */
198options_p create_type_option (options_p next, const char* name,
199                              type_p info);
200
201/* Create a nested option.  */
202options_p create_nested_option (options_p next, const char* name,
203				struct nested_ptr_data* info);
204
205/* Create a nested pointer option.  */
206options_p create_nested_ptr_option (options_p, type_p t,
207			 	     const char *from, const char *to);
208
209/* A name and a type.  */
210struct pair {
211  pair_p next;                  /* The next pair in the linked list.  */
212  const char *name;             /* The defined name.  */
213  type_p type;                  /* Its GTY-ed type.  */
214  struct fileloc line;          /* The file location.  */
215  options_p opt;                /* GTY options, as a linked list.  */
216};
217
218/* Usage information for GTY-ed types.  Gengtype has to care only of
219   used GTY-ed types.  Types are initially unused, and their usage is
220   computed by set_gc_used_type and set_gc_used functions.  */
221
222enum gc_used_enum {
223
224  /* We need that zeroed types are initially unused.  */
225  GC_UNUSED=0,
226
227  /* The GTY-ed type is used, e.g by a GTY-ed variable or a field
228     inside a GTY-ed used type.  */
229  GC_USED,
230
231  /* For GTY-ed structures whose definitions we haven't seen so far
232     when we encounter a pointer to it that is annotated with
233     ``maybe_undef''.  If after reading in everything we don't have
234     source file information for it, we assume that it never has been
235     defined.  */
236  GC_MAYBE_POINTED_TO,
237
238  /* For known GTY-ed structures which are pointed to by GTY-ed
239     variables or fields.  */
240  GC_POINTED_TO
241};
242
243/* Our type structure describes all types handled by gengtype.  */
244struct type {
245  /* Discriminating kind, cannot be TYPE_NONE.  */
246  enum typekind kind;
247
248  /* For top-level structs or unions, the 'next' field links the
249     global list 'structures'; for lang_structs, their homonymous structs are
250     linked using this 'next' field.  The homonymous list starts at the
251     s.lang_struct field of the lang_struct.  See the new_structure function
252     for details.  This is tricky!  */
253  type_p next;
254
255  /* State number used when writing & reading the persistent state.  A
256     type with a positive number has already been written.  For ease
257     of debugging, newly allocated types have a unique negative
258     number.  */
259  int state_number;
260
261  /* Each GTY-ed type which is pointed to by some GTY-ed type knows
262     the GTY pointer type pointing to it.  See create_pointer
263     function.  */
264  type_p pointer_to;
265
266  /* Type usage information, computed by set_gc_used_type and
267     set_gc_used functions.  */
268  enum gc_used_enum gc_used;
269
270  /* The following union is discriminated by the 'kind' field above.  */
271  union {
272    /* TYPE__NONE is impossible.  */
273
274    /* when TYPE_POINTER:  */
275    type_p p;
276
277    /* when TYPE_STRUCT or TYPE_UNION or TYPE_LANG_STRUCT, we have an
278       aggregate type containing fields: */
279    struct {
280      const char *tag;          /* the aggragate tag, if any.  */
281      struct fileloc line;      /* the source location.  */
282      pair_p fields;            /* the linked list of fields.  */
283      options_p opt;            /* the GTY options if any.  */
284      lang_bitmap bitmap;       /* the set of front-end languages
285                                   using that GTY-ed aggregate.  */
286      /* For TYPE_LANG_STRUCT, the lang_struct field gives the first
287         element of a linked list of homonymous struct or union types.
288         Within this list, each homonymous type has as its lang_struct
289         field the original TYPE_LANG_STRUCT type.  This is a dirty
290         trick, see the new_structure function for details.  */
291      type_p lang_struct;
292
293      type_p base_class; /* the parent class, if any.  */
294
295      /* The following two fields are not serialized in state files, and
296	 are instead reconstructed on load.  */
297
298      /* The head of a singly-linked list of immediate descendents in
299	 the inheritance hierarchy.  */
300      type_p first_subclass;
301      /* The next in that list.  */
302      type_p next_sibling_class;
303
304      /* Have we already written ggc/pch user func for ptr to this?
305	 (in write_user_func_for_structure_ptr).  */
306      bool wrote_user_func_for_ptr[NUM_WTK];
307    } s;
308
309    /* when TYPE_SCALAR: */
310    bool scalar_is_char;
311
312    /* when TYPE_ARRAY: */
313    struct {
314      type_p p;                 /* The array component type.  */
315      const char *len;          /* The string if any giving its length.  */
316    } a;
317
318  } u;
319};
320
321/* The one and only TYPE_STRING.  */
322extern struct type string_type;
323
324/* The two and only TYPE_SCALARs.  Their u.scalar_is_char flags are
325   set early in main.  */
326extern struct type scalar_nonchar;
327extern struct type scalar_char;
328
329/* Test if a type is a union, either a plain one or a language
330   specific one.  */
331#define UNION_P(x)					\
332    ((x)->kind == TYPE_UNION				\
333     || ((x)->kind == TYPE_LANG_STRUCT			\
334         && (x)->u.s.lang_struct->kind == TYPE_UNION))
335
336/* Test if a type is a union or a structure, perhaps a language
337   specific one.  */
338static inline bool
339union_or_struct_p (enum typekind kind)
340{
341  return (kind == TYPE_UNION
342	  || kind == TYPE_STRUCT
343          || kind == TYPE_LANG_STRUCT
344	  || kind == TYPE_USER_STRUCT);
345}
346
347static inline bool
348union_or_struct_p (const_type_p x)
349{
350  return union_or_struct_p (x->kind);
351}
352
353/* Give the file location of a type, if any. */
354static inline struct fileloc*
355type_fileloc (type_p t)
356{
357  if (!t)
358    return NULL;
359  if (union_or_struct_p (t))
360    return &t->u.s.line;
361  return NULL;
362}
363
364/* Structure representing an output file.  */
365struct outf
366{
367  struct outf *next;
368  const char *name;
369  size_t buflength;
370  size_t bufused;
371  char *buf;
372};
373typedef struct outf *outf_p;
374
375/* The list of output files.  */
376extern outf_p output_files;
377
378/* The output header file that is included into pretty much every
379   source file.  */
380extern outf_p header_file;
381
382/* Print, like fprintf, to O.  No-op if O is NULL.  */
383void
384oprintf (outf_p o, const char *S, ...)
385  ATTRIBUTE_PRINTF_2;
386
387/* An output file, suitable for definitions, that can see declarations
388   made in INPF and is linked into every language that uses INPF.  May
389   return NULL in plugin mode.  The INPF argument is almost const, but
390   since the result is cached in its inpoutf field it cannot be
391   declared const.  */
392outf_p get_output_file_with_visibility (input_file* inpf);
393
394/* The name of an output file, suitable for definitions, that can see
395   declarations made in INPF and is linked into every language that
396   uses INPF.  May return NULL.  */
397const char *get_output_file_name (input_file *inpf);
398
399
400/* Source directory.  */
401extern const char *srcdir;	/* (-S) program argument. */
402
403/* Length of srcdir name.  */
404extern size_t srcdir_len;
405
406/* Variable used for reading and writing the state.  */
407extern const char *read_state_filename; /* (-r) program argument. */
408extern const char *write_state_filename; /* (-w) program argument. */
409
410/* Functions reading and writing the entire gengtype state, called from
411   main, and implemented in file gengtype-state.c.  */
412void read_state (const char* path);
413/* Write the state, and update the state_number field in types.  */
414void write_state (const char* path);
415
416
417/* Print an error message.  */
418extern void error_at_line
419(const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2;
420
421/* Constructor routines for types.  */
422extern void do_typedef (const char *s, type_p t, struct fileloc *pos);
423extern void do_scalar_typedef (const char *s, struct fileloc *pos);
424extern type_p resolve_typedef (const char *s, struct fileloc *pos);
425extern void add_subclass (type_p base, type_p subclass);
426extern type_p new_structure (const char *name, enum typekind kind,
427			     struct fileloc *pos, pair_p fields,
428			     options_p o, type_p base);
429type_p create_user_defined_type (const char *, struct fileloc *);
430extern type_p find_structure (const char *s, enum typekind kind);
431extern type_p create_scalar_type (const char *name);
432extern type_p create_pointer (type_p t);
433extern type_p create_array (type_p t, const char *len);
434extern pair_p create_field_at (pair_p next, type_p type,
435			       const char *name, options_p opt,
436			       struct fileloc *pos);
437extern pair_p nreverse_pairs (pair_p list);
438extern type_p adjust_field_type (type_p, options_p);
439extern void note_variable (const char *s, type_p t, options_p o,
440			   struct fileloc *pos);
441
442/* Lexer and parser routines.  */
443extern int yylex (const char **yylval);
444extern void yybegin (const char *fname);
445extern void yyend (void);
446extern void parse_file (const char *name);
447extern bool hit_error;
448
449/* Token codes.  */
450enum gty_token
451{
452  EOF_TOKEN = 0,
453
454  /* Per standard convention, codes in the range (0, UCHAR_MAX]
455     represent single characters with those character codes.  */
456  CHAR_TOKEN_OFFSET = UCHAR_MAX + 1,
457  GTY_TOKEN = CHAR_TOKEN_OFFSET,
458  TYPEDEF,
459  EXTERN,
460  STATIC,
461  UNION,
462  STRUCT,
463  ENUM,
464  ELLIPSIS,
465  PTR_ALIAS,
466  NESTED_PTR,
467  USER_GTY,
468  NUM,
469  SCALAR,
470  ID,
471  STRING,
472  CHAR,
473  ARRAY,
474  IGNORABLE_CXX_KEYWORD,
475
476  /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
477     a meaningful value to be printed.  */
478  FIRST_TOKEN_WITH_VALUE = USER_GTY
479};
480
481
482/* Level for verbose messages, e.g. output file generation...  */
483extern int verbosity_level;	/* (-v) program argument.  */
484
485/* For debugging purposes we provide two flags.  */
486
487/* Dump everything to understand gengtype's state. Might be useful to
488   gengtype users.  */
489extern int do_dump;		/* (-d) program argument. */
490
491/* Trace the execution by many DBGPRINTF (with the position inside
492   gengtype source code).  Only useful to debug gengtype itself.  */
493extern int do_debug;		/* (-D) program argument. */
494
495#if ENABLE_CHECKING
496#define DBGPRINTF(Fmt,...) do {if (do_debug)				\
497      fprintf (stderr, "%s:%d: " Fmt "\n",				\
498	       lbasename (__FILE__),__LINE__, ##__VA_ARGS__);} while (0)
499void dbgprint_count_type_at (const char *, int, const char *, type_p);
500#define DBGPRINT_COUNT_TYPE(Msg,Ty) do {if (do_debug)			\
501      dbgprint_count_type_at (__FILE__, __LINE__, Msg, Ty);}while (0)
502#else
503#define DBGPRINTF(Fmt,...) do {/*nodbgrintf*/} while (0)
504#define DBGPRINT_COUNT_TYPE(Msg,Ty) do{/*nodbgprint_count_type*/}while (0)
505#endif /*ENABLE_CHECKING */
506
507#define FOR_ALL_INHERITED_FIELDS(TYPE, FIELD_VAR) \
508  for (type_p sub = (TYPE); sub; sub = sub->u.s.base_class) \
509    for (FIELD_VAR = sub->u.s.fields; FIELD_VAR; FIELD_VAR = FIELD_VAR->next)
510
511extern bool
512opts_have (options_p opts, const char *str);
513
514
515#endif
516