OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [c-tree.h] - Blame information for rev 709

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Definitions for C parsing and type checking.
2
   Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4
   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
#ifndef GCC_C_TREE_H
23
#define GCC_C_TREE_H
24
 
25
#include "c-family/c-common.h"
26
#include "diagnostic.h"
27
 
28
/* struct lang_identifier is private to c-decl.c, but langhooks.c needs to
29
   know how big it is.  This is sanity-checked in c-decl.c.  */
30
#define C_SIZEOF_STRUCT_LANG_IDENTIFIER \
31
  (sizeof (struct c_common_identifier) + 3 * sizeof (void *))
32
 
33
/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
34
#define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1 (TYPE)
35
 
36
/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is volatile.  */
37
#define C_TYPE_FIELDS_VOLATILE(TYPE) TREE_LANG_FLAG_2 (TYPE)
38
 
39
/* In a RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE
40
   nonzero if the definition of the type has already started.  */
41
#define C_TYPE_BEING_DEFINED(TYPE) TYPE_LANG_FLAG_0 (TYPE)
42
 
43
/* In an incomplete RECORD_TYPE or UNION_TYPE, a list of variable
44
   declarations whose type would be completed by completing that type.  */
45
#define C_TYPE_INCOMPLETE_VARS(TYPE) TYPE_VFIELD (TYPE)
46
 
47
/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
48
   keyword.  C_RID_CODE (node) is then the RID_* value of the keyword,
49
   and C_RID_YYCODE is the token number wanted by Yacc.  */
50
#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_0 (ID)
51
 
52
/* Record whether a type or decl was written with nonconstant size.
53
   Note that TYPE_SIZE may have simplified to a constant.  */
54
#define C_TYPE_VARIABLE_SIZE(TYPE) TYPE_LANG_FLAG_1 (TYPE)
55
#define C_DECL_VARIABLE_SIZE(TYPE) DECL_LANG_FLAG_0 (TYPE)
56
 
57
/* Record whether a type is defined inside a struct or union type.
58
   This is used for -Wc++-compat. */
59
#define C_TYPE_DEFINED_IN_STRUCT(TYPE) TYPE_LANG_FLAG_2 (TYPE)
60
 
61
/* Record whether a typedef for type `int' was actually `signed int'.  */
62
#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
63
 
64
/* For a FUNCTION_DECL, nonzero if it was defined without an explicit
65
   return type.  */
66
#define C_FUNCTION_IMPLICIT_INT(EXP) DECL_LANG_FLAG_1 (EXP)
67
 
68
/* For a FUNCTION_DECL, nonzero if it was an implicit declaration.  */
69
#define C_DECL_IMPLICIT(EXP) DECL_LANG_FLAG_2 (EXP)
70
 
71
/* For FUNCTION_DECLs, evaluates true if the decl is built-in but has
72
   been declared.  */
73
#define C_DECL_DECLARED_BUILTIN(EXP)            \
74
  DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (EXP))
75
 
76
/* For FUNCTION_DECLs, evaluates true if the decl is built-in, has a
77
   built-in prototype and does not have a non-built-in prototype.  */
78
#define C_DECL_BUILTIN_PROTOTYPE(EXP)           \
79
  DECL_LANG_FLAG_6 (FUNCTION_DECL_CHECK (EXP))
80
 
81
/* Record whether a decl was declared register.  This is strictly a
82
   front-end flag, whereas DECL_REGISTER is used for code generation;
83
   they may differ for structures with volatile fields.  */
84
#define C_DECL_REGISTER(EXP) DECL_LANG_FLAG_4 (EXP)
85
 
86
/* Record whether a decl was used in an expression anywhere except an
87
   unevaluated operand of sizeof / typeof / alignof.  This is only
88
   used for functions declared static but not defined, though outside
89
   sizeof and typeof it is set for other function decls as well.  */
90
#define C_DECL_USED(EXP) DECL_LANG_FLAG_5 (FUNCTION_DECL_CHECK (EXP))
91
 
92
/* Record whether a variable has been declared threadprivate by
93
   #pragma omp threadprivate.  */
94
#define C_DECL_THREADPRIVATE_P(DECL) DECL_LANG_FLAG_3 (VAR_DECL_CHECK (DECL))
95
 
96
/* Nonzero for a decl which either doesn't exist or isn't a prototype.
97
   N.B. Could be simplified if all built-in decls had complete prototypes
98
   (but this is presently difficult because some of them need FILE*).  */
99
#define C_DECL_ISNT_PROTOTYPE(EXP)                      \
100
       (EXP == 0                                 \
101
        || (!prototype_p (TREE_TYPE (EXP))      \
102
            && !DECL_BUILT_IN (EXP)))
103
 
104
/* For FUNCTION_TYPE, a hidden list of types of arguments.  The same as
105
   TYPE_ARG_TYPES for functions with prototypes, but created for functions
106
   without prototypes.  */
107
#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_LANG_SLOT_1 (NODE)
108
 
109
/* For a CONSTRUCTOR, whether some initializer contains a
110
   subexpression meaning it is not a constant expression.  */
111
#define CONSTRUCTOR_NON_CONST(EXPR) TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (EXPR))
112
 
113
/* Record parser information about an expression that is irrelevant
114
   for code generation alongside a tree representing its value.  */
115
struct c_expr
116
{
117
  /* The value of the expression.  */
118
  tree value;
119
  /* Record the original unary/binary operator of an expression, which may
120
     have been changed by fold, STRING_CST for unparenthesized string
121
     constants, C_MAYBE_CONST_EXPR for __builtin_constant_p calls
122
     (even if parenthesized), for subexpressions, and for non-constant
123
     initializers, or ERROR_MARK for other expressions (including
124
     parenthesized expressions).  */
125
  enum tree_code original_code;
126
  /* If not NULL, the original type of an expression.  This will
127
     differ from the type of the value field for an enum constant.
128
     The type of an enum constant is a plain integer type, but this
129
     field will be the enum type.  */
130
  tree original_type;
131
};
132
 
133
/* Type alias for struct c_expr. This allows to use the structure
134
   inside the VEC types.  */
135
typedef struct c_expr c_expr_t;
136
 
137
/* A varray of c_expr_t.  */
138
DEF_VEC_O (c_expr_t);
139
DEF_VEC_ALLOC_O (c_expr_t, gc);
140
DEF_VEC_ALLOC_O (c_expr_t, heap);
141
 
142
/* Append a new c_expr_t element to V.  */
143
#define C_EXPR_APPEND(V, ELEM) \
144
  do { \
145
    c_expr_t *__elem_p = VEC_safe_push (c_expr_t, gc, V, NULL); \
146
    *__elem_p = (ELEM); \
147
  } while (0)
148
 
149
/* A kind of type specifier.  Note that this information is currently
150
   only used to distinguish tag definitions, tag references and typeof
151
   uses.  */
152
enum c_typespec_kind {
153
  /* No typespec.  This appears only in struct c_declspec.  */
154
  ctsk_none,
155
  /* A reserved keyword type specifier.  */
156
  ctsk_resword,
157
  /* A reference to a tag, previously declared, such as "struct foo".
158
     This includes where the previous declaration was as a different
159
     kind of tag, in which case this is only valid if shadowing that
160
     tag in an inner scope.  */
161
  ctsk_tagref,
162
  /* A reference to a tag, not previously declared in a visible
163
     scope.  */
164
  ctsk_tagfirstref,
165
  /* A definition of a tag such as "struct foo { int a; }".  */
166
  ctsk_tagdef,
167
  /* A typedef name.  */
168
  ctsk_typedef,
169
  /* An ObjC-specific kind of type specifier.  */
170
  ctsk_objc,
171
  /* A typeof specifier.  */
172
  ctsk_typeof
173
};
174
 
175
/* A type specifier: this structure is created in the parser and
176
   passed to declspecs_add_type only.  */
177
struct c_typespec {
178
  /* What kind of type specifier this is.  */
179
  enum c_typespec_kind kind;
180
  /* Whether the expression has operands suitable for use in constant
181
     expressions.  */
182
  bool expr_const_operands;
183
  /* The specifier itself.  */
184
  tree spec;
185
  /* An expression to be evaluated before the type specifier, in the
186
     case of typeof specifiers, or NULL otherwise or if no such
187
     expression is required for a particular typeof specifier.  In
188
     particular, when typeof is applied to an expression of variably
189
     modified type, that expression must be evaluated in order to
190
     determine array sizes that form part of the type, but the
191
     expression itself (as opposed to the array sizes) forms no part
192
     of the type and so needs to be recorded separately.  */
193
  tree expr;
194
};
195
 
196
/* A storage class specifier.  */
197
enum c_storage_class {
198
  csc_none,
199
  csc_auto,
200
  csc_extern,
201
  csc_register,
202
  csc_static,
203
  csc_typedef
204
};
205
 
206
/* A type specifier keyword "void", "_Bool", "char", "int", "float",
207
   "double", "_Decimal32", "_Decimal64", "_Decimal128", "_Fract", "_Accum",
208
   or none of these.  */
209
enum c_typespec_keyword {
210
  cts_none,
211
  cts_void,
212
  cts_bool,
213
  cts_char,
214
  cts_int,
215
  cts_float,
216
  cts_int128,
217
  cts_double,
218
  cts_dfloat32,
219
  cts_dfloat64,
220
  cts_dfloat128,
221
  cts_fract,
222
  cts_accum
223
};
224
 
225
/* A sequence of declaration specifiers in C.  */
226
struct c_declspecs {
227
  /* The type specified, if a single type specifier such as a struct,
228
     union or enum specifier, typedef name or typeof specifies the
229
     whole type, or NULL_TREE if none or a keyword such as "void" or
230
     "char" is used.  Does not include qualifiers.  */
231
  tree type;
232
  /* Any expression to be evaluated before the type, from a typeof
233
     specifier.  */
234
  tree expr;
235
  /* The attributes from a typedef decl.  */
236
  tree decl_attr;
237
  /* When parsing, the attributes.  Outside the parser, this will be
238
     NULL; attributes (possibly from multiple lists) will be passed
239
     separately.  */
240
  tree attrs;
241
  /* The base-2 log of the greatest alignment required by an _Alignas
242
     specifier, in bytes, or -1 if no such specifiers with nonzero
243
     alignment.  */
244
  int align_log;
245
  /* The storage class specifier, or csc_none if none.  */
246
  enum c_storage_class storage_class;
247
  /* Any type specifier keyword used such as "int", not reflecting
248
     modifiers such as "short", or cts_none if none.  */
249
  ENUM_BITFIELD (c_typespec_keyword) typespec_word : 8;
250
  /* The kind of type specifier if one has been seen, ctsk_none
251
     otherwise.  */
252
  ENUM_BITFIELD (c_typespec_kind) typespec_kind : 3;
253
  /* Whether any expressions in typeof specifiers may appear in
254
     constant expressions.  */
255
  BOOL_BITFIELD expr_const_operands : 1;
256
  /* Whether any declaration specifiers have been seen at all.  */
257
  BOOL_BITFIELD declspecs_seen_p : 1;
258
  /* Whether something other than a storage class specifier or
259
     attribute has been seen.  This is used to warn for the
260
     obsolescent usage of storage class specifiers other than at the
261
     start of the list.  (Doing this properly would require function
262
     specifiers to be handled separately from storage class
263
     specifiers.)  */
264
  BOOL_BITFIELD non_sc_seen_p : 1;
265
  /* Whether the type is specified by a typedef or typeof name.  */
266
  BOOL_BITFIELD typedef_p : 1;
267
  /* Whether the type is explicitly "signed" or specified by a typedef
268
     whose type is explicitly "signed".  */
269
  BOOL_BITFIELD explicit_signed_p : 1;
270
  /* Whether the specifiers include a deprecated typedef.  */
271
  BOOL_BITFIELD deprecated_p : 1;
272
  /* Whether the type defaulted to "int" because there were no type
273
     specifiers.  */
274
  BOOL_BITFIELD default_int_p : 1;
275
  /* Whether "long" was specified.  */
276
  BOOL_BITFIELD long_p : 1;
277
  /* Whether "long" was specified more than once.  */
278
  BOOL_BITFIELD long_long_p : 1;
279
  /* Whether "short" was specified.  */
280
  BOOL_BITFIELD short_p : 1;
281
  /* Whether "signed" was specified.  */
282
  BOOL_BITFIELD signed_p : 1;
283
  /* Whether "unsigned" was specified.  */
284
  BOOL_BITFIELD unsigned_p : 1;
285
  /* Whether "complex" was specified.  */
286
  BOOL_BITFIELD complex_p : 1;
287
  /* Whether "inline" was specified.  */
288
  BOOL_BITFIELD inline_p : 1;
289
  /* Whether "_Noreturn" was speciied.  */
290
  BOOL_BITFIELD noreturn_p : 1;
291
  /* Whether "__thread" was specified.  */
292
  BOOL_BITFIELD thread_p : 1;
293
  /* Whether "const" was specified.  */
294
  BOOL_BITFIELD const_p : 1;
295
  /* Whether "volatile" was specified.  */
296
  BOOL_BITFIELD volatile_p : 1;
297
  /* Whether "restrict" was specified.  */
298
  BOOL_BITFIELD restrict_p : 1;
299
  /* Whether "_Sat" was specified.  */
300
  BOOL_BITFIELD saturating_p : 1;
301
  /* Whether any alignment specifier (even with zero alignment) was
302
     specified.  */
303
  BOOL_BITFIELD alignas_p : 1;
304
  /* The address space that the declaration belongs to.  */
305
  addr_space_t address_space;
306
};
307
 
308
/* The various kinds of declarators in C.  */
309
enum c_declarator_kind {
310
  /* An identifier.  */
311
  cdk_id,
312
  /* A function.  */
313
  cdk_function,
314
  /* An array.  */
315
  cdk_array,
316
  /* A pointer.  */
317
  cdk_pointer,
318
  /* Parenthesized declarator with nested attributes.  */
319
  cdk_attrs
320
};
321
 
322
typedef struct c_arg_tag_d {
323
  /* The argument name.  */
324
  tree id;
325
  /* The type of the argument.  */
326
  tree type;
327
} c_arg_tag;
328
 
329
DEF_VEC_O(c_arg_tag);
330
DEF_VEC_ALLOC_O(c_arg_tag,gc);
331
 
332
/* Information about the parameters in a function declarator.  */
333
struct c_arg_info {
334
  /* A list of parameter decls.  */
335
  tree parms;
336
  /* A list of structure, union and enum tags defined.  */
337
  VEC(c_arg_tag,gc) *tags;
338
  /* A list of argument types to go in the FUNCTION_TYPE.  */
339
  tree types;
340
  /* A list of non-parameter decls (notably enumeration constants)
341
     defined with the parameters.  */
342
  tree others;
343
  /* A compound expression of VLA sizes from the parameters, or NULL.
344
     In a function definition, these are used to ensure that
345
     side-effects in sizes of arrays converted to pointers (such as a
346
     parameter int i[n++]) take place; otherwise, they are
347
     ignored.  */
348
  tree pending_sizes;
349
  /* True when these arguments had [*].  */
350
  BOOL_BITFIELD had_vla_unspec : 1;
351
};
352
 
353
/* A declarator.  */
354
struct c_declarator {
355
  /* The kind of declarator.  */
356
  enum c_declarator_kind kind;
357
  location_t id_loc; /* Currently only set for cdk_id, cdk_array. */
358
  /* Except for cdk_id, the contained declarator.  For cdk_id, NULL.  */
359
  struct c_declarator *declarator;
360
  union {
361
    /* For identifiers, an IDENTIFIER_NODE or NULL_TREE if an abstract
362
       declarator.  */
363
    tree id;
364
    /* For functions.  */
365
    struct c_arg_info *arg_info;
366
    /* For arrays.  */
367
    struct {
368
      /* The array dimension, or NULL for [] and [*].  */
369
      tree dimen;
370
      /* The qualifiers inside [].  */
371
      int quals;
372
      /* The attributes (currently ignored) inside [].  */
373
      tree attrs;
374
      /* Whether [static] was used.  */
375
      BOOL_BITFIELD static_p : 1;
376
      /* Whether [*] was used.  */
377
      BOOL_BITFIELD vla_unspec_p : 1;
378
    } array;
379
    /* For pointers, the qualifiers on the pointer type.  */
380
    int pointer_quals;
381
    /* For attributes.  */
382
    tree attrs;
383
  } u;
384
};
385
 
386
/* A type name.  */
387
struct c_type_name {
388
  /* The declaration specifiers.  */
389
  struct c_declspecs *specs;
390
  /* The declarator.  */
391
  struct c_declarator *declarator;
392
};
393
 
394
/* A parameter.  */
395
struct c_parm {
396
  /* The declaration specifiers, minus any prefix attributes.  */
397
  struct c_declspecs *specs;
398
  /* The attributes.  */
399
  tree attrs;
400
  /* The declarator.  */
401
  struct c_declarator *declarator;
402
};
403
 
404
/* Used when parsing an enum.  Initialized by start_enum.  */
405
struct c_enum_contents
406
{
407
  /* While defining an enum type, this is 1 plus the last enumerator
408
     constant value.  */
409
  tree enum_next_value;
410
 
411
  /* Nonzero means that there was overflow computing enum_next_value.  */
412
  int enum_overflow;
413
};
414
 
415
/* A type of reference to a static identifier in an inline
416
   function.  */
417
enum c_inline_static_type {
418
  /* Identifier with internal linkage used in function that may be an
419
     inline definition (i.e., file-scope static).  */
420
  csi_internal,
421
  /* Modifiable object with static storage duration defined in
422
     function that may be an inline definition (i.e., local
423
     static).  */
424
  csi_modifiable
425
};
426
 
427
 
428
/* in c-parser.c */
429
extern void c_parse_init (void);
430
 
431
/* in c-aux-info.c */
432
extern void gen_aux_info_record (tree, int, int, int);
433
 
434
/* in c-decl.c */
435
struct c_spot_bindings;
436
struct c_struct_parse_info;
437
extern struct obstack parser_obstack;
438
extern tree c_break_label;
439
extern tree c_cont_label;
440
 
441
extern bool global_bindings_p (void);
442
extern void push_scope (void);
443
extern tree pop_scope (void);
444
extern void c_bindings_start_stmt_expr (struct c_spot_bindings *);
445
extern void c_bindings_end_stmt_expr (struct c_spot_bindings *);
446
 
447
extern void record_inline_static (location_t, tree, tree,
448
                                  enum c_inline_static_type);
449
extern void c_init_decl_processing (void);
450
extern void c_print_identifier (FILE *, tree, int);
451
extern int quals_from_declspecs (const struct c_declspecs *);
452
extern struct c_declarator *build_array_declarator (location_t, tree,
453
                                                    struct c_declspecs *,
454
                                                    bool, bool);
455
extern tree build_enumerator (location_t, location_t, struct c_enum_contents *,
456
                              tree, tree);
457
extern tree check_for_loop_decls (location_t, bool);
458
extern void mark_forward_parm_decls (void);
459
extern void declare_parm_level (void);
460
extern void undeclared_variable (location_t, tree);
461
extern tree lookup_label_for_goto (location_t, tree);
462
extern tree declare_label (tree);
463
extern tree define_label (location_t, tree);
464
extern struct c_spot_bindings *c_get_switch_bindings (void);
465
extern void c_release_switch_bindings (struct c_spot_bindings *);
466
extern bool c_check_switch_jump_warnings (struct c_spot_bindings *,
467
                                          location_t, location_t);
468
extern void finish_decl (tree, location_t, tree, tree, tree);
469
extern tree finish_enum (tree, tree, tree);
470
extern void finish_function (void);
471
extern tree finish_struct (location_t, tree, tree, tree,
472
                           struct c_struct_parse_info *);
473
extern struct c_arg_info *build_arg_info (void);
474
extern struct c_arg_info *get_parm_info (bool, tree);
475
extern tree grokfield (location_t, struct c_declarator *,
476
                       struct c_declspecs *, tree, tree *);
477
extern tree groktypename (struct c_type_name *, tree *, bool *);
478
extern tree grokparm (const struct c_parm *, tree *);
479
extern tree implicitly_declare (location_t, tree);
480
extern void keep_next_level (void);
481
extern void pending_xref_error (void);
482
extern void c_push_function_context (void);
483
extern void c_pop_function_context (void);
484
extern void push_parm_decl (const struct c_parm *, tree *);
485
extern struct c_declarator *set_array_declarator_inner (struct c_declarator *,
486
                                                        struct c_declarator *);
487
extern tree c_builtin_function (tree);
488
extern tree c_builtin_function_ext_scope (tree);
489
extern void shadow_tag (const struct c_declspecs *);
490
extern void shadow_tag_warned (const struct c_declspecs *, int);
491
extern tree start_enum (location_t, struct c_enum_contents *, tree);
492
extern int  start_function (struct c_declspecs *, struct c_declarator *, tree);
493
extern tree start_decl (struct c_declarator *, struct c_declspecs *, bool,
494
                        tree);
495
extern tree start_struct (location_t, enum tree_code, tree,
496
                          struct c_struct_parse_info **);
497
extern void store_parm_decls (void);
498
extern void store_parm_decls_from (struct c_arg_info *);
499
extern tree xref_tag (enum tree_code, tree);
500
extern struct c_typespec parser_xref_tag (location_t, enum tree_code, tree);
501
extern int c_expand_decl (tree);
502
extern struct c_parm *build_c_parm (struct c_declspecs *, tree,
503
                                    struct c_declarator *);
504
extern struct c_declarator *build_attrs_declarator (tree,
505
                                                    struct c_declarator *);
506
extern struct c_declarator *build_function_declarator (struct c_arg_info *,
507
                                                       struct c_declarator *);
508
extern struct c_declarator *build_id_declarator (tree);
509
extern struct c_declarator *make_pointer_declarator (struct c_declspecs *,
510
                                                     struct c_declarator *);
511
extern struct c_declspecs *build_null_declspecs (void);
512
extern struct c_declspecs *declspecs_add_qual (struct c_declspecs *, tree);
513
extern struct c_declspecs *declspecs_add_type (location_t,
514
                                               struct c_declspecs *,
515
                                               struct c_typespec);
516
extern struct c_declspecs *declspecs_add_scspec (struct c_declspecs *, tree);
517
extern struct c_declspecs *declspecs_add_attrs (struct c_declspecs *, tree);
518
extern struct c_declspecs *declspecs_add_addrspace (struct c_declspecs *,
519
                                                    addr_space_t);
520
extern struct c_declspecs *declspecs_add_alignas (struct c_declspecs *, tree);
521
extern struct c_declspecs *finish_declspecs (struct c_declspecs *);
522
 
523
/* in c-objc-common.c */
524
extern bool c_objc_common_init (void);
525
extern bool c_missing_noreturn_ok_p (tree);
526
extern bool c_warn_unused_global_decl (const_tree);
527
extern void c_initialize_diagnostics (diagnostic_context *);
528
extern bool c_vla_unspec_p (tree x, tree fn);
529
 
530
/* in c-typeck.c */
531
extern int in_alignof;
532
extern int in_sizeof;
533
extern int in_typeof;
534
 
535
extern struct c_switch *c_switch_stack;
536
 
537
extern tree c_objc_common_truthvalue_conversion (location_t, tree);
538
extern tree require_complete_type (tree);
539
extern int same_translation_unit_p (const_tree, const_tree);
540
extern int comptypes (tree, tree);
541
extern int comptypes_check_different_types (tree, tree, bool *);
542
extern bool c_vla_type_p (const_tree);
543
extern bool c_mark_addressable (tree);
544
extern void c_incomplete_type_error (const_tree, const_tree);
545
extern tree c_type_promotes_to (tree);
546
extern struct c_expr default_function_array_conversion (location_t,
547
                                                        struct c_expr);
548
extern struct c_expr default_function_array_read_conversion (location_t,
549
                                                             struct c_expr);
550
extern void mark_exp_read (tree);
551
extern tree composite_type (tree, tree);
552
extern tree build_component_ref (location_t, tree, tree);
553
extern tree build_array_ref (location_t, tree, tree);
554
extern tree build_external_ref (location_t, tree, int, tree *);
555
extern void pop_maybe_used (bool);
556
extern struct c_expr c_expr_sizeof_expr (location_t, struct c_expr);
557
extern struct c_expr c_expr_sizeof_type (location_t, struct c_type_name *);
558
extern struct c_expr parser_build_unary_op (location_t, enum tree_code,
559
                                            struct c_expr);
560
extern struct c_expr parser_build_binary_op (location_t,
561
                                             enum tree_code, struct c_expr,
562
                                             struct c_expr);
563
extern tree build_conditional_expr (location_t, tree, bool, tree, tree,
564
                                    tree, tree);
565
extern tree build_compound_expr (location_t, tree, tree);
566
extern tree c_cast_expr (location_t, struct c_type_name *, tree);
567
extern tree build_c_cast (location_t, tree, tree);
568
extern void store_init_value (location_t, tree, tree, tree);
569
extern void error_init (const char *);
570
extern void pedwarn_init (location_t, int opt, const char *);
571
extern void maybe_warn_string_init (tree, struct c_expr);
572
extern void start_init (tree, tree, int);
573
extern void finish_init (void);
574
extern void really_start_incremental_init (tree);
575
extern void push_init_level (int, struct obstack *);
576
extern struct c_expr pop_init_level (int, struct obstack *);
577
extern void set_init_index (tree, tree, struct obstack *);
578
extern void set_init_label (tree, struct obstack *);
579
extern void process_init_element (struct c_expr, bool, struct obstack *);
580
extern tree build_compound_literal (location_t, tree, tree, bool);
581
extern void check_compound_literal_type (location_t, struct c_type_name *);
582
extern tree c_start_case (location_t, location_t, tree);
583
extern void c_finish_case (tree);
584
extern tree build_asm_expr (location_t, tree, tree, tree, tree, tree, bool);
585
extern tree build_asm_stmt (tree, tree);
586
extern int c_types_compatible_p (tree, tree);
587
extern tree c_begin_compound_stmt (bool);
588
extern tree c_end_compound_stmt (location_t, tree, bool);
589
extern void c_finish_if_stmt (location_t, tree, tree, tree, bool);
590
extern void c_finish_loop (location_t, tree, tree, tree, tree, tree, bool);
591
extern tree c_begin_stmt_expr (void);
592
extern tree c_finish_stmt_expr (location_t, tree);
593
extern tree c_process_expr_stmt (location_t, tree);
594
extern tree c_finish_expr_stmt (location_t, tree);
595
extern tree c_finish_return (location_t, tree, tree);
596
extern tree c_finish_bc_stmt (location_t, tree *, bool);
597
extern tree c_finish_goto_label (location_t, tree);
598
extern tree c_finish_goto_ptr (location_t, tree);
599
extern tree c_expr_to_decl (tree, bool *, bool *);
600
extern tree c_begin_omp_parallel (void);
601
extern tree c_finish_omp_parallel (location_t, tree, tree);
602
extern tree c_begin_omp_task (void);
603
extern tree c_finish_omp_task (location_t, tree, tree);
604
extern tree c_finish_omp_clauses (tree);
605
extern tree c_build_va_arg (location_t, tree, tree);
606
extern tree c_finish_transaction (location_t, tree, int);
607
extern tree c_build_vec_perm_expr (location_t, tree, tree, tree);
608
 
609
/* Set to 0 at beginning of a function definition, set to 1 if
610
   a return statement that specifies a return value is seen.  */
611
 
612
extern int current_function_returns_value;
613
 
614
/* Set to 0 at beginning of a function definition, set to 1 if
615
   a return statement with no argument is seen.  */
616
 
617
extern int current_function_returns_null;
618
 
619
/* Set to 0 at beginning of a function definition, set to 1 if
620
   a call to a noreturn function is seen.  */
621
 
622
extern int current_function_returns_abnormally;
623
 
624
/* Nonzero means we are reading code that came from a system header file.  */
625
 
626
extern int system_header_p;
627
 
628
/* In c-decl.c */
629
extern void c_finish_incomplete_decl (tree);
630
extern void c_write_global_declarations (void);
631
 
632
/* In c-errors.c */
633
extern void pedwarn_c90 (location_t, int opt, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
634
extern void pedwarn_c99 (location_t, int opt, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
635
 
636
#endif /* ! GCC_C_TREE_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.