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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [c-tree.h] - Blame information for rev 826

Details | Compare with Previous | View Log

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