OSDN Git Service

7335d942d48cbac69797fb3754a69497cd81c296
[pf3gnuchains/gcc-fork.git] / gcc / fortran / gfortran.h
1 /* gfortran header file
2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006
3    Free Software Foundation, Inc.
4    Contributed by Andy Vaught
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 2, 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 COPYING.  If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.  */
22
23 #ifndef GCC_GFORTRAN_H
24 #define GCC_GFORTRAN_H
25
26 /* It's probably insane to have this large of a header file, but it
27    seemed like everything had to be recompiled anyway when a change
28    was made to a header file, and there were ordering issues with
29    multiple header files.  Besides, Microsoft's winnt.h was 250k last
30    time I looked, so by comparison this is perfectly reasonable.  */
31
32 #include "system.h"
33 #include "intl.h"
34 #include "coretypes.h"
35 #include "input.h"
36
37 /* The following ifdefs are recommended by the autoconf documentation
38    for any code using alloca.  */
39
40 /* AIX requires this to be the first thing in the file.  */
41 #ifdef __GNUC__
42 #else /* not __GNUC__ */
43 #ifdef HAVE_ALLOCA_H
44 #include <alloca.h>
45 #else /* do not HAVE_ALLOCA_H */
46 #ifdef _AIX
47 #pragma alloca
48 #else
49 #ifndef alloca                  /* predefined by HP cc +Olibcalls */
50 char *alloca ();
51 #endif /* not predefined */
52 #endif /* not _AIX */
53 #endif /* do not HAVE_ALLOCA_H */
54 #endif /* not __GNUC__ */
55
56 /* Major control parameters.  */
57
58 #define GFC_MAX_SYMBOL_LEN 63
59 #define GFC_MAX_LINE 132        /* Characters beyond this are not seen.  */
60 #define GFC_MAX_DIMENSIONS 7    /* Maximum dimensions in an array.  */
61 #define GFC_LETTERS 26          /* Number of letters in the alphabet.  */
62
63 #define free(x) Use_gfc_free_instead_of_free()
64 #define gfc_is_whitespace(c) ((c==' ') || (c=='\t'))
65
66 #ifndef NULL
67 #define NULL ((void *) 0)
68 #endif
69
70 /* Stringization.  */
71 #define stringize(x) expand_macro(x)
72 #define expand_macro(x) # x
73
74 /* For a the runtime library, a standard prefix is a requirement to
75    avoid cluttering the namespace with things nobody asked for.  It's
76    ugly to look at and a pain to type when you add the prefix by hand,
77    so we hide it behind a macro.  */
78 #define PREFIX(x) "_gfortran_" x
79 #define PREFIX_LEN 10
80
81 #define BLANK_COMMON_NAME "__BLNK__"
82
83 /* Macro to initialize an mstring structure.  */
84 #define minit(s, t) { s, NULL, t }
85
86 /* Structure for storing strings to be matched by gfc_match_string.  */
87 typedef struct
88 {
89   const char *string;
90   const char *mp;
91   int tag;
92 }
93 mstring;
94
95
96 /* Flags to specify which standard/extension contains a feature.  */
97 #define GFC_STD_LEGACY          (1<<6) /* Backward compatibility.  */
98 #define GFC_STD_GNU             (1<<5)    /* GNU Fortran extension.  */
99 #define GFC_STD_F2003           (1<<4)    /* New in F2003.  */
100 /* Note that no features were obsoleted nor deleted in F2003.  */
101 #define GFC_STD_F95             (1<<3)    /* New in F95.  */
102 #define GFC_STD_F95_DEL         (1<<2)    /* Deleted in F95.  */
103 #define GFC_STD_F95_OBS         (1<<1)    /* Obsoleted in F95.  */
104 #define GFC_STD_F77             (1<<0)    /* Up to and including F77.  */
105
106 /* Bitmasks for the various FPE that can be enabled.  */
107 #define GFC_FPE_INVALID    (1<<0)
108 #define GFC_FPE_DENORMAL   (1<<1)
109 #define GFC_FPE_ZERO       (1<<2)
110 #define GFC_FPE_OVERFLOW   (1<<3)
111 #define GFC_FPE_UNDERFLOW  (1<<4)
112 #define GFC_FPE_PRECISION  (1<<5)
113
114 /* Keep this in sync with libgfortran/io/io.h ! */
115
116 typedef enum
117   { CONVERT_NATIVE=0, CONVERT_SWAP, CONVERT_BIG, CONVERT_LITTLE }
118 options_convert;
119
120
121 /*************************** Enums *****************************/
122
123 /* The author remains confused to this day about the convention of
124    returning '0' for 'SUCCESS'... or was it the other way around?  The
125    following enum makes things much more readable.  We also start
126    values off at one instead of zero.  */
127
128 typedef enum
129 { SUCCESS = 1, FAILURE }
130 try;
131
132 /* This is returned by gfc_notification_std to know if, given the flags
133    that were given (-std=, -pedantic) we should issue an error, a warning
134    or nothing.  */
135
136 typedef enum
137 { SILENT, WARNING, ERROR }
138 notification;
139
140 /* Matchers return one of these three values.  The difference between
141    MATCH_NO and MATCH_ERROR is that MATCH_ERROR means that a match was
142    successful, but that something non-syntactic is wrong and an error
143    has already been issued.  */
144
145 typedef enum
146 { MATCH_NO = 1, MATCH_YES, MATCH_ERROR }
147 match;
148
149 typedef enum
150 { FORM_FREE, FORM_FIXED, FORM_UNKNOWN }
151 gfc_source_form;
152
153 typedef enum
154 { BT_UNKNOWN = 1, BT_INTEGER, BT_REAL, BT_COMPLEX,
155   BT_LOGICAL, BT_CHARACTER, BT_DERIVED, BT_PROCEDURE, BT_HOLLERITH
156 }
157 bt;
158
159 /* Expression node types.  */
160 typedef enum
161 { EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,
162   EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL
163 }
164 expr_t;
165
166 /* Array types.  */
167 typedef enum
168 { AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,
169   AS_ASSUMED_SIZE, AS_UNKNOWN
170 }
171 array_type;
172
173 typedef enum
174 { AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN }
175 ar_type;
176
177 /* Statement label types.  */
178 typedef enum
179 { ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET,
180   ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT
181 }
182 gfc_sl_type;
183
184 /* Intrinsic operators.  */
185 typedef enum
186 { GFC_INTRINSIC_BEGIN = 0,
187   INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,
188   INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,
189   INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,
190   INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,
191   INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,
192   INTRINSIC_LT, INTRINSIC_LE, INTRINSIC_NOT, INTRINSIC_USER,
193   INTRINSIC_ASSIGN, INTRINSIC_PARENTHESES,
194   GFC_INTRINSIC_END /* Sentinel */
195 }
196 gfc_intrinsic_op;
197
198
199 /* Strings for all intrinsic operators.  */
200 extern mstring intrinsic_operators[];
201
202
203 /* This macro is the number of intrinsic operators that exist.
204    Assumptions are made about the numbering of the interface_op enums.  */
205 #define GFC_INTRINSIC_OPS GFC_INTRINSIC_END
206
207 /* Arithmetic results.  */
208 typedef enum
209 { ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,
210   ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC
211 }
212 arith;
213
214 /* Statements.  */
215 typedef enum
216 {
217   ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_BACKSPACE, ST_BLOCK_DATA,
218   ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,
219   ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,
220   ST_ELSEWHERE, ST_END_BLOCK_DATA, ST_ENDDO, ST_IMPLIED_ENDDO,
221   ST_END_FILE, ST_FLUSH, ST_END_FORALL, ST_END_FUNCTION, ST_ENDIF,
222   ST_END_INTERFACE, ST_END_MODULE, ST_END_PROGRAM, ST_END_SELECT,
223   ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE, ST_ENTRY, ST_EQUIVALENCE,
224   ST_EXIT, ST_FORALL, ST_FORALL_BLOCK, ST_FORMAT, ST_FUNCTION, ST_GOTO,
225   ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE, ST_INQUIRE, ST_INTERFACE,
226   ST_PARAMETER, ST_MODULE, ST_MODULE_PROC, ST_NAMELIST, ST_NULLIFY, ST_OPEN,
227   ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC, ST_READ, ST_RETURN, ST_REWIND,
228   ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE, ST_WHERE_BLOCK, ST_WHERE, ST_WRITE,
229   ST_ASSIGNMENT, ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE,
230   ST_SIMPLE_IF, ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT,
231   ST_ENUM, ST_ENUMERATOR, ST_END_ENUM,
232   ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_CRITICAL,
233   ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED, ST_OMP_END_PARALLEL,
234   ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,
235   ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,
236   ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,
237   ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
238   ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
239   ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE,
240   ST_NONE
241 }
242 gfc_statement;
243
244
245 /* Types of interfaces that we can have.  Assignment interfaces are
246    considered to be intrinsic operators.  */
247 typedef enum
248 {
249   INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,
250   INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP
251 }
252 interface_type;
253
254 /* Symbol flavors: these are all mutually exclusive.
255    10 elements = 4 bits.  */
256 typedef enum sym_flavor
257 {
258   FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
259   FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST
260 }
261 sym_flavor;
262
263 /* Procedure types.  7 elements = 3 bits.  */
264 typedef enum procedure_type
265 { PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,
266   PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL
267 }
268 procedure_type;
269
270 /* Intent types.  */
271 typedef enum sym_intent
272 { INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT
273 }
274 sym_intent;
275
276 /* Access types.  */
277 typedef enum gfc_access
278 { ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE
279 }
280 gfc_access;
281
282 /* Flags to keep track of where an interface came from.
283    4 elements = 2 bits.  */
284 typedef enum ifsrc
285 { IFSRC_UNKNOWN = 0, IFSRC_DECL, IFSRC_IFBODY, IFSRC_USAGE
286 }
287 ifsrc;
288
289 /* Strings for all symbol attributes.  We use these for dumping the
290    parse tree, in error messages, and also when reading and writing
291    modules.  In symbol.c.  */
292 extern const mstring flavors[];
293 extern const mstring procedures[];
294 extern const mstring intents[];
295 extern const mstring access_types[];
296 extern const mstring ifsrc_types[];
297
298 /* Enumeration of all the generic intrinsic functions.  Used by the
299    backend for identification of a function.  */
300
301 enum gfc_generic_isym_id
302 {
303   /* GFC_ISYM_NONE is used for intrinsics which will never be seen by
304      the backend (eg. KIND).  */
305   GFC_ISYM_NONE = 0,
306   GFC_ISYM_ABS,
307   GFC_ISYM_ACCESS,
308   GFC_ISYM_ACHAR,
309   GFC_ISYM_ACOS,
310   GFC_ISYM_ACOSH,
311   GFC_ISYM_ADJUSTL,
312   GFC_ISYM_ADJUSTR,
313   GFC_ISYM_AIMAG,
314   GFC_ISYM_AINT,
315   GFC_ISYM_ALL,
316   GFC_ISYM_ALLOCATED,
317   GFC_ISYM_ANINT,
318   GFC_ISYM_AND,
319   GFC_ISYM_ANY,
320   GFC_ISYM_ASIN,
321   GFC_ISYM_ASINH,
322   GFC_ISYM_ASSOCIATED,
323   GFC_ISYM_ATAN,
324   GFC_ISYM_ATANH,
325   GFC_ISYM_ATAN2,
326   GFC_ISYM_J0,
327   GFC_ISYM_J1,
328   GFC_ISYM_JN,
329   GFC_ISYM_Y0,
330   GFC_ISYM_Y1,
331   GFC_ISYM_YN,
332   GFC_ISYM_BTEST,
333   GFC_ISYM_CEILING,
334   GFC_ISYM_CHAR,
335   GFC_ISYM_CHDIR,
336   GFC_ISYM_CHMOD,
337   GFC_ISYM_CMPLX,
338   GFC_ISYM_COMMAND_ARGUMENT_COUNT,
339   GFC_ISYM_COMPLEX,
340   GFC_ISYM_CONJG,
341   GFC_ISYM_COS,
342   GFC_ISYM_COSH,
343   GFC_ISYM_COUNT,
344   GFC_ISYM_CSHIFT,
345   GFC_ISYM_CTIME,
346   GFC_ISYM_DBLE,
347   GFC_ISYM_DIM,
348   GFC_ISYM_DOT_PRODUCT,
349   GFC_ISYM_DPROD,
350   GFC_ISYM_EOSHIFT,
351   GFC_ISYM_ERF,
352   GFC_ISYM_ERFC,
353   GFC_ISYM_ETIME,
354   GFC_ISYM_EXP,
355   GFC_ISYM_EXPONENT,
356   GFC_ISYM_FDATE,
357   GFC_ISYM_FGET,
358   GFC_ISYM_FGETC,
359   GFC_ISYM_FLOOR,
360   GFC_ISYM_FNUM,
361   GFC_ISYM_FPUT,
362   GFC_ISYM_FPUTC,
363   GFC_ISYM_FRACTION,
364   GFC_ISYM_FSTAT,
365   GFC_ISYM_FTELL,
366   GFC_ISYM_GETCWD,
367   GFC_ISYM_GETGID,
368   GFC_ISYM_GETPID,
369   GFC_ISYM_GETUID,
370   GFC_ISYM_HOSTNM,
371   GFC_ISYM_IACHAR,
372   GFC_ISYM_IAND,
373   GFC_ISYM_IARGC,
374   GFC_ISYM_IBCLR,
375   GFC_ISYM_IBITS,
376   GFC_ISYM_IBSET,
377   GFC_ISYM_ICHAR,
378   GFC_ISYM_IEOR,
379   GFC_ISYM_IERRNO,
380   GFC_ISYM_INDEX,
381   GFC_ISYM_INT,
382   GFC_ISYM_INT2,
383   GFC_ISYM_INT8,
384   GFC_ISYM_IOR,
385   GFC_ISYM_IRAND,
386   GFC_ISYM_ISATTY,
387   GFC_ISYM_ISHFT,
388   GFC_ISYM_ISHFTC,
389   GFC_ISYM_KILL,
390   GFC_ISYM_LBOUND,
391   GFC_ISYM_LEN,
392   GFC_ISYM_LEN_TRIM,
393   GFC_ISYM_LINK,
394   GFC_ISYM_LGE,
395   GFC_ISYM_LGT,
396   GFC_ISYM_LLE,
397   GFC_ISYM_LLT,
398   GFC_ISYM_LOC,
399   GFC_ISYM_LOG,
400   GFC_ISYM_LOG10,
401   GFC_ISYM_LOGICAL,
402   GFC_ISYM_LONG,
403   GFC_ISYM_LSHIFT,
404   GFC_ISYM_LSTAT,
405   GFC_ISYM_MALLOC,
406   GFC_ISYM_MATMUL,
407   GFC_ISYM_MAX,
408   GFC_ISYM_MAXLOC,
409   GFC_ISYM_MAXVAL,
410   GFC_ISYM_MCLOCK,
411   GFC_ISYM_MCLOCK8,
412   GFC_ISYM_MERGE,
413   GFC_ISYM_MIN,
414   GFC_ISYM_MINLOC,
415   GFC_ISYM_MINVAL,
416   GFC_ISYM_MOD,
417   GFC_ISYM_MODULO,
418   GFC_ISYM_NEAREST,
419   GFC_ISYM_NINT,
420   GFC_ISYM_NOT,
421   GFC_ISYM_OR,
422   GFC_ISYM_PACK,
423   GFC_ISYM_PRESENT,
424   GFC_ISYM_PRODUCT,
425   GFC_ISYM_RAND,
426   GFC_ISYM_REAL,
427   GFC_ISYM_RENAME,
428   GFC_ISYM_REPEAT,
429   GFC_ISYM_RESHAPE,
430   GFC_ISYM_RSHIFT,
431   GFC_ISYM_RRSPACING,
432   GFC_ISYM_SCALE,
433   GFC_ISYM_SCAN,
434   GFC_ISYM_SECOND,
435   GFC_ISYM_SECNDS,
436   GFC_ISYM_SET_EXPONENT,
437   GFC_ISYM_SHAPE,
438   GFC_ISYM_SI_KIND,
439   GFC_ISYM_SIGN,
440   GFC_ISYM_SIGNAL,
441   GFC_ISYM_SIN,
442   GFC_ISYM_SINH,
443   GFC_ISYM_SIZE,
444   GFC_ISYM_SPACING,
445   GFC_ISYM_SPREAD,
446   GFC_ISYM_SQRT,
447   GFC_ISYM_SR_KIND,
448   GFC_ISYM_STAT,
449   GFC_ISYM_SUM,
450   GFC_ISYM_SYMLNK,
451   GFC_ISYM_SYSTEM,
452   GFC_ISYM_TAN,
453   GFC_ISYM_TANH,
454   GFC_ISYM_TIME,
455   GFC_ISYM_TIME8,
456   GFC_ISYM_TRANSFER,
457   GFC_ISYM_TRANSPOSE,
458   GFC_ISYM_TRIM,
459   GFC_ISYM_TTYNAM,
460   GFC_ISYM_UBOUND,
461   GFC_ISYM_UMASK,
462   GFC_ISYM_UNLINK,
463   GFC_ISYM_UNPACK,
464   GFC_ISYM_VERIFY,
465   GFC_ISYM_XOR,
466   GFC_ISYM_CONVERSION
467 };
468 typedef enum gfc_generic_isym_id gfc_generic_isym_id;
469
470 /************************* Structures *****************************/
471
472 /* Used for keeping things in balanced binary trees.  */
473 #define BBT_HEADER(self) int priority; struct self *left, *right
474
475 /* Symbol attribute structure.  */
476 typedef struct
477 {
478   /* Variable attributes.  */
479   unsigned allocatable:1, dimension:1, external:1, intrinsic:1,
480     optional:1, pointer:1, save:1, target:1,
481     dummy:1, result:1, assign:1, threadprivate:1;
482
483   unsigned data:1,              /* Symbol is named in a DATA statement.  */
484     use_assoc:1;                /* Symbol has been use-associated.  */
485
486   unsigned in_namelist:1, in_common:1, in_equivalence:1;
487   unsigned function:1, subroutine:1, generic:1;
488   unsigned implicit_type:1;     /* Type defined via implicit rules.  */
489   unsigned untyped:1;           /* No implicit type could be found.  */
490
491   /* Function/subroutine attributes */
492   unsigned sequence:1, elemental:1, pure:1, recursive:1;
493   unsigned unmaskable:1, masked:1, contained:1;
494
495   /* This is set if the subroutine doesn't return.  Currently, this
496      is only possible for intrinsic subroutines.  */
497   unsigned noreturn:1;
498
499   /* Set if this procedure is an alternate entry point.  These procedures
500      don't have any code associated, and the backend will turn them into
501      thunks to the master function.  */
502   unsigned entry:1;
503
504   /* Set if this is the master function for a procedure with multiple
505      entry points.  */
506   unsigned entry_master:1;
507
508   /* Set if this is the master function for a function with multiple
509      entry points where characteristics of the entry points differ.  */
510   unsigned mixed_entry_master:1;
511
512   /* Set if a function must always be referenced by an explicit interface.  */
513   unsigned always_explicit:1;
514
515   /* Set if the symbol has been referenced in an expression.  No further
516      modification of type or type parameters is permitted.  */
517   unsigned referenced:1;
518
519   /* Set if the is the symbol for the main program.  This is the least
520      cumbersome way to communicate this function property without
521      strcmp'ing with __MAIN everywhere.  */
522   unsigned is_main_program:1;
523
524   /* Mutually exclusive multibit attributes.  */
525   ENUM_BITFIELD (gfc_access) access:2;
526   ENUM_BITFIELD (sym_intent) intent:2;
527   ENUM_BITFIELD (sym_flavor) flavor:4;
528   ENUM_BITFIELD (ifsrc) if_source:2;
529
530   ENUM_BITFIELD (procedure_type) proc:3;
531
532   /* Special attributes for Cray pointers, pointees.  */
533   unsigned cray_pointer:1, cray_pointee:1;
534
535 }
536 symbol_attribute;
537
538
539 /* The following three structures are used to identify a location in
540    the sources.
541
542    gfc_file is used to maintain a tree of the source files and how
543    they include each other
544
545    gfc_linebuf holds a single line of source code and information
546    which file it resides in
547
548    locus point to the sourceline and the character in the source
549    line.
550 */
551
552 typedef struct gfc_file
553 {
554   struct gfc_file *included_by, *next, *up;
555   int inclusion_line, line;
556   char *filename;
557 } gfc_file;
558
559 typedef struct gfc_linebuf
560 {
561 #ifdef USE_MAPPED_LOCATION
562   source_location location;
563 #else
564   int linenum;
565 #endif
566   struct gfc_file *file;
567   struct gfc_linebuf *next;
568
569   int truncated;
570
571   char line[1];
572 } gfc_linebuf;
573
574 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
575
576 typedef struct
577 {
578   char *nextc;
579   gfc_linebuf *lb;
580 } locus;
581
582 /* In order for the "gfc" format checking to work correctly, you must
583    have declared a typedef locus first.  */
584 #if GCC_VERSION >= 4001
585 #define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)
586 #else
587 #define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)
588 #endif
589
590
591 extern int gfc_suppress_error;
592
593
594 /* Character length structures hold the expression that gives the
595    length of a character variable.  We avoid putting these into
596    gfc_typespec because doing so prevents us from doing structure
597    copies and forces us to deallocate any typespecs we create, as well
598    as structures that contain typespecs.  They also can have multiple
599    character typespecs pointing to them.
600
601    These structures form a singly linked list within the current
602    namespace and are deallocated with the namespace.  It is possible to
603    end up with gfc_charlen structures that have nothing pointing to them.  */
604
605 typedef struct gfc_charlen
606 {
607   struct gfc_expr *length;
608   struct gfc_charlen *next;
609   tree backend_decl;
610
611   int resolved;
612 }
613 gfc_charlen;
614
615 #define gfc_get_charlen() gfc_getmem(sizeof(gfc_charlen))
616
617 /* Type specification structure.  FIXME: derived and cl could be union???  */
618 typedef struct
619 {
620   bt type;
621   int kind;
622   struct gfc_symbol *derived;
623   gfc_charlen *cl;      /* For character types only.  */
624 }
625 gfc_typespec;
626
627 /* Array specification.  */
628 typedef struct
629 {
630   int rank;     /* A rank of zero means that a variable is a scalar.  */
631   array_type type;
632   struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
633
634   /* These two fields are used with the Cray Pointer extension.  */
635   bool cray_pointee; /* True iff this spec belongs to a cray pointee.  */
636   bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to
637                         AS_EXPLICIT, but we want to remember that we
638                         did this.  */
639
640 }
641 gfc_array_spec;
642
643 #define gfc_get_array_spec() gfc_getmem(sizeof(gfc_array_spec))
644
645
646 /* Components of derived types.  */
647 typedef struct gfc_component
648 {
649   const char *name;
650   gfc_typespec ts;
651
652   int pointer, dimension;
653   gfc_array_spec *as;
654
655   tree backend_decl;
656   locus loc;
657   struct gfc_expr *initializer;
658   struct gfc_component *next;
659 }
660 gfc_component;
661
662 #define gfc_get_component() gfc_getmem(sizeof(gfc_component))
663
664 /* Formal argument lists are lists of symbols.  */
665 typedef struct gfc_formal_arglist
666 {
667   /* Symbol representing the argument at this position in the arglist.  */
668   struct gfc_symbol *sym;
669   /* Points to the next formal argument.  */
670   struct gfc_formal_arglist *next;
671 }
672 gfc_formal_arglist;
673
674 #define gfc_get_formal_arglist() gfc_getmem(sizeof(gfc_formal_arglist))
675
676
677 /* The gfc_actual_arglist structure is for actual arguments.  */
678 typedef struct gfc_actual_arglist
679 {
680   const char *name;
681   /* Alternate return label when the expr member is null.  */
682   struct gfc_st_label *label;
683
684   /* This is set to the type of an eventual omitted optional
685      argument. This is used to determine if a hidden string length
686      argument has to be added to a function call.  */
687   bt missing_arg_type;
688
689   struct gfc_expr *expr;
690   struct gfc_actual_arglist *next;
691 }
692 gfc_actual_arglist;
693
694 #define gfc_get_actual_arglist() gfc_getmem(sizeof(gfc_actual_arglist))
695
696
697 /* Because a symbol can belong to multiple namelists, they must be
698    linked externally to the symbol itself.  */
699 typedef struct gfc_namelist
700 {
701   struct gfc_symbol *sym;
702   struct gfc_namelist *next;
703 }
704 gfc_namelist;
705
706 #define gfc_get_namelist() gfc_getmem(sizeof(gfc_namelist))
707
708 enum
709 {
710   OMP_LIST_PRIVATE,
711   OMP_LIST_FIRSTPRIVATE,
712   OMP_LIST_LASTPRIVATE,
713   OMP_LIST_COPYPRIVATE,
714   OMP_LIST_SHARED,
715   OMP_LIST_COPYIN,
716   OMP_LIST_PLUS,
717   OMP_LIST_REDUCTION_FIRST = OMP_LIST_PLUS,
718   OMP_LIST_MULT,
719   OMP_LIST_SUB,
720   OMP_LIST_AND,
721   OMP_LIST_OR,
722   OMP_LIST_EQV,
723   OMP_LIST_NEQV,
724   OMP_LIST_MAX,
725   OMP_LIST_MIN,
726   OMP_LIST_IAND,
727   OMP_LIST_IOR,
728   OMP_LIST_IEOR,
729   OMP_LIST_REDUCTION_LAST = OMP_LIST_IEOR,
730   OMP_LIST_NUM
731 };
732
733 /* Because a symbol can belong to multiple namelists, they must be
734    linked externally to the symbol itself.  */
735 typedef struct gfc_omp_clauses
736 {
737   struct gfc_expr *if_expr;
738   struct gfc_expr *num_threads;
739   gfc_namelist *lists[OMP_LIST_NUM];
740   enum
741     {
742       OMP_SCHED_NONE,
743       OMP_SCHED_STATIC,
744       OMP_SCHED_DYNAMIC,
745       OMP_SCHED_GUIDED,
746       OMP_SCHED_RUNTIME
747     } sched_kind;
748   struct gfc_expr *chunk_size;
749   enum
750     {
751       OMP_DEFAULT_UNKNOWN,
752       OMP_DEFAULT_NONE,
753       OMP_DEFAULT_PRIVATE,
754       OMP_DEFAULT_SHARED
755     } default_sharing;
756   bool nowait, ordered;
757 }
758 gfc_omp_clauses;
759
760 #define gfc_get_omp_clauses() gfc_getmem(sizeof(gfc_omp_clauses))
761
762
763 /* The gfc_st_label structure is a doubly linked list attached to a
764    namespace that records the usage of statement labels within that
765    space.  */
766 /* TODO: Make format/statement specifics a union.  */
767 typedef struct gfc_st_label
768 {
769   BBT_HEADER(gfc_st_label);
770
771   int value;
772
773   gfc_sl_type defined, referenced;
774
775   struct gfc_expr *format;
776
777   tree backend_decl;
778
779   locus where;
780 }
781 gfc_st_label;
782
783
784 /* gfc_interface()-- Interfaces are lists of symbols strung together.  */
785 typedef struct gfc_interface
786 {
787   struct gfc_symbol *sym;
788   locus where;
789   struct gfc_interface *next;
790 }
791 gfc_interface;
792
793 #define gfc_get_interface() gfc_getmem(sizeof(gfc_interface))
794
795
796 /* User operator nodes.  These are like stripped down symbols.  */
797 typedef struct
798 {
799   const char *name;
800
801   gfc_interface *operator;
802   struct gfc_namespace *ns;
803   gfc_access access;
804 }
805 gfc_user_op;
806
807 /* Symbol nodes.  These are important things.  They are what the
808    standard refers to as "entities".  The possibly multiple names that
809    refer to the same entity are accomplished by a binary tree of
810    symtree structures that is balanced by the red-black method-- more
811    than one symtree node can point to any given symbol.  */
812
813 typedef struct gfc_symbol
814 {
815   const char *name;     /* Primary name, before renaming */
816   const char *module;   /* Module this symbol came from */
817   locus declared_at;
818
819   gfc_typespec ts;
820   symbol_attribute attr;
821
822   /* The interface member points to the formal argument list if the
823      symbol is a function or subroutine name.  If the symbol is a
824      generic name, the generic member points to the list of
825      interfaces.  */
826
827   gfc_interface *generic;
828   gfc_access component_access;
829
830   gfc_formal_arglist *formal;
831   struct gfc_namespace *formal_ns;
832
833   struct gfc_expr *value;       /* Parameter/Initializer value */
834   gfc_array_spec *as;
835   struct gfc_symbol *result;    /* function result symbol */
836   gfc_component *components;    /* Derived type components */
837
838   /* Defined only for Cray pointees; points to their pointer.  */
839   struct gfc_symbol *cp_pointer;
840
841   struct gfc_symbol *common_next;       /* Links for COMMON syms */
842
843   /* This is in fact a gfc_common_head but it is only used for pointer
844      comparisons to check if symbols are in the same common block.  */
845   struct gfc_common_head* common_head;
846
847   /* Make sure setup code for dummy arguments is generated in the correct
848      order.  */
849   int dummy_order;
850
851   int entry_id;
852
853   gfc_namelist *namelist, *namelist_tail;
854
855   /* Change management fields.  Symbols that might be modified by the
856      current statement have the mark member nonzero and are kept in a
857      singly linked list through the tlink field.  Of these symbols,
858      symbols with old_symbol equal to NULL are symbols created within
859      the current statement.  Otherwise, old_symbol points to a copy of
860      the old symbol.  */
861
862   struct gfc_symbol *old_symbol, *tlink;
863   unsigned mark:1, new:1;
864   /* Nonzero if all equivalences associated with this symbol have been
865      processed.  */
866   unsigned equiv_built:1;
867   /* Set if this variable is used as an index name in a FORALL.  */
868   unsigned forall_index:1;
869   int refs;
870   struct gfc_namespace *ns;     /* namespace containing this symbol */
871
872   tree backend_decl;
873 }
874 gfc_symbol;
875
876
877 /* This structure is used to keep track of symbols in common blocks.  */
878
879 typedef struct gfc_common_head
880 {
881   locus where;
882   char use_assoc, saved, threadprivate;
883   char name[GFC_MAX_SYMBOL_LEN + 1];
884   struct gfc_symbol *head;
885 }
886 gfc_common_head;
887
888 #define gfc_get_common_head() gfc_getmem(sizeof(gfc_common_head))
889
890
891 /* A list of all the alternate entry points for a procedure.  */
892
893 typedef struct gfc_entry_list
894 {
895   /* The symbol for this entry point.  */
896   gfc_symbol *sym;
897   /* The zero-based id of this entry point.  */
898   int id;
899   /* The LABEL_EXPR marking this entry point.  */
900   tree label;
901   /* The nest item in the list.  */
902   struct gfc_entry_list *next;
903 }
904 gfc_entry_list;
905
906 #define gfc_get_entry_list() \
907   (gfc_entry_list *) gfc_getmem(sizeof(gfc_entry_list))
908
909 /* Within a namespace, symbols are pointed to by symtree nodes that
910    are linked together in a balanced binary tree.  There can be
911    several symtrees pointing to the same symbol node via USE
912    statements.  */
913
914 typedef struct gfc_symtree
915 {
916   BBT_HEADER (gfc_symtree);
917   const char *name;
918   int ambiguous;
919   union
920   {
921     gfc_symbol *sym;            /* Symbol associated with this node */
922     gfc_user_op *uop;
923     gfc_common_head *common;
924   }
925   n;
926
927 }
928 gfc_symtree;
929
930 /* A linked list of derived types in the namespace.  */
931 typedef struct gfc_dt_list
932 {
933   struct gfc_symbol *derived;
934   struct gfc_dt_list *next;
935 }
936 gfc_dt_list;
937
938 #define gfc_get_dt_list() gfc_getmem(sizeof(gfc_dt_list))
939
940
941 /* A namespace describes the contents of procedure, module or
942    interface block.  */
943 /* ??? Anything else use these?  */
944
945 typedef struct gfc_namespace
946 {
947   /* Tree containing all the symbols in this namespace.  */
948   gfc_symtree *sym_root;
949   /* Tree containing all the user-defined operators in the namespace.  */
950   gfc_symtree *uop_root;
951   /* Tree containing all the common blocks.  */
952   gfc_symtree *common_root;
953
954   /* If set_flag[letter] is set, an implicit type has been set for letter.  */
955   int set_flag[GFC_LETTERS];
956   /* Keeps track of the implicit types associated with the letters.  */
957   gfc_typespec default_type[GFC_LETTERS];
958
959   /* If this is a namespace of a procedure, this points to the procedure.  */
960   struct gfc_symbol *proc_name;
961   /* If this is the namespace of a unit which contains executable
962      code, this points to it.  */
963   struct gfc_code *code;
964
965   /* Points to the equivalences set up in this namespace.  */
966   struct gfc_equiv *equiv;
967
968   /* Points to the equivalence groups produced by trans_common.  */
969   struct gfc_equiv_list *equiv_lists;
970
971   gfc_interface *operator[GFC_INTRINSIC_OPS];
972
973   /* Points to the parent namespace, i.e. the namespace of a module or
974      procedure in which the procedure belonging to this namespace is
975      contained. The parent namespace points to this namespace either
976      directly via CONTAINED, or indirectly via the chain built by
977      SIBLING.  */
978   struct gfc_namespace *parent;
979   /* CONTAINED points to the first contained namespace. Sibling
980      namespaces are chained via SIBLING.  */
981   struct gfc_namespace  *contained, *sibling;
982
983   gfc_common_head blank_common;
984   gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
985
986   gfc_st_label *st_labels;
987   /* This list holds information about all the data initializers in
988      this namespace.  */
989   struct gfc_data *data;
990
991   gfc_charlen *cl_list;
992
993   int save_all, seen_save, seen_implicit_none;
994
995   /* Normally we don't need to refcount namespaces.  However when we read
996      a module containing a function with multiple entry points, this
997      will appear as several functions with the same formal namespace.  */
998   int refs;
999
1000   /* A list of all alternate entry points to this procedure (or NULL).  */
1001   gfc_entry_list *entries;
1002
1003   /* A list of all derived types in this procedure (or NULL).  */
1004   gfc_dt_list *derived_types;
1005
1006   /* Set to 1 if namespace is a BLOCK DATA program unit.  */
1007   int is_block_data;
1008 }
1009 gfc_namespace;
1010
1011 extern gfc_namespace *gfc_current_ns;
1012
1013 /* Global symbols are symbols of global scope. Currently we only use
1014    this to detect collisions already when parsing.
1015    TODO: Extend to verify procedure calls.  */
1016
1017 typedef struct gfc_gsymbol
1018 {
1019   BBT_HEADER(gfc_gsymbol);
1020
1021   const char *name;
1022   enum { GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
1023         GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA } type;
1024
1025   int defined, used;
1026   locus where;
1027 }
1028 gfc_gsymbol;
1029
1030 extern gfc_gsymbol *gfc_gsym_root;
1031
1032 /* Information on interfaces being built.  */
1033 typedef struct
1034 {
1035   interface_type type;
1036   gfc_symbol *sym;
1037   gfc_namespace *ns;
1038   gfc_user_op *uop;
1039   gfc_intrinsic_op op;
1040 }
1041 gfc_interface_info;
1042
1043 extern gfc_interface_info current_interface;
1044
1045
1046 /* Array reference.  */
1047 typedef struct gfc_array_ref
1048 {
1049   ar_type type;
1050   int dimen;                    /* # of components in the reference */
1051   locus where;
1052   gfc_array_spec *as;
1053
1054   locus c_where[GFC_MAX_DIMENSIONS];    /* All expressions can be NULL */
1055   struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
1056     *stride[GFC_MAX_DIMENSIONS];
1057
1058   enum
1059   { DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_UNKNOWN }
1060   dimen_type[GFC_MAX_DIMENSIONS];
1061
1062   struct gfc_expr *offset;
1063 }
1064 gfc_array_ref;
1065
1066 #define gfc_get_array_ref() gfc_getmem(sizeof(gfc_array_ref))
1067
1068
1069 /* Component reference nodes.  A variable is stored as an expression
1070    node that points to the base symbol.  After that, a singly linked
1071    list of component reference nodes gives the variable's complete
1072    resolution.  The array_ref component may be present and comes
1073    before the component component.  */
1074
1075 typedef enum
1076   { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING }
1077 ref_type;
1078
1079 typedef struct gfc_ref
1080 {
1081   ref_type type;
1082
1083   union
1084   {
1085     struct gfc_array_ref ar;
1086
1087     struct
1088     {
1089       gfc_component *component;
1090       gfc_symbol *sym;
1091     }
1092     c;
1093
1094     struct
1095     {
1096       struct gfc_expr *start, *end;     /* Substring */
1097       gfc_charlen *length;
1098     }
1099     ss;
1100
1101   }
1102   u;
1103
1104   struct gfc_ref *next;
1105 }
1106 gfc_ref;
1107
1108 #define gfc_get_ref() gfc_getmem(sizeof(gfc_ref))
1109
1110
1111 /* Structures representing intrinsic symbols and their arguments lists.  */
1112 typedef struct gfc_intrinsic_arg
1113 {
1114   char name[GFC_MAX_SYMBOL_LEN + 1];
1115
1116   gfc_typespec ts;
1117   int optional;
1118   gfc_actual_arglist *actual;
1119
1120   struct gfc_intrinsic_arg *next;
1121
1122 }
1123 gfc_intrinsic_arg;
1124
1125
1126 /* Specifies the various kinds of check functions used to verify the
1127    argument lists of intrinsic functions. fX with X an integer refer
1128    to check functions of intrinsics with X arguments. f1m is used for
1129    the MAX and MIN intrinsics which can have an arbitrary number of
1130    arguments, f3ml is used for the MINLOC and MAXLOC intrinsics as
1131    these have special semantics.  */
1132
1133 typedef union
1134 {
1135   try (*f0)(void);
1136   try (*f1)(struct gfc_expr *);
1137   try (*f1m)(gfc_actual_arglist *);
1138   try (*f2)(struct gfc_expr *, struct gfc_expr *);
1139   try (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1140   try (*f3ml)(gfc_actual_arglist *);
1141   try (*f3red)(gfc_actual_arglist *);
1142   try (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1143             struct gfc_expr *);
1144   try (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1145             struct gfc_expr *, struct gfc_expr *);
1146 }
1147 gfc_check_f;
1148
1149 /* Like gfc_check_f, these specify the type of the simplification
1150    function associated with an intrinsic. The fX are just like in
1151    gfc_check_f. cc is used for type conversion functions.  */
1152
1153 typedef union
1154 {
1155   struct gfc_expr *(*f0)(void);
1156   struct gfc_expr *(*f1)(struct gfc_expr *);
1157   struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
1158   struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
1159                          struct gfc_expr *);
1160   struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
1161                          struct gfc_expr *, struct gfc_expr *);
1162   struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
1163                          struct gfc_expr *, struct gfc_expr *,
1164                          struct gfc_expr *);
1165   struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
1166 }
1167 gfc_simplify_f;
1168
1169 /* Again like gfc_check_f, these specify the type of the resolution
1170    function associated with an intrinsic. The fX are just like in
1171    gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort().
1172    */
1173
1174 typedef union
1175 {
1176   void (*f0)(struct gfc_expr *);
1177   void (*f1)(struct gfc_expr *, struct gfc_expr *);
1178   void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
1179   void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1180   void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1181              struct gfc_expr *);
1182   void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1183              struct gfc_expr *, struct gfc_expr *);
1184   void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1185              struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1186   void (*s1)(struct gfc_code *);
1187 }
1188 gfc_resolve_f;
1189
1190
1191 typedef struct gfc_intrinsic_sym
1192 {
1193   const char *name, *lib_name;
1194   gfc_intrinsic_arg *formal;
1195   gfc_typespec ts;
1196   int elemental, pure, generic, specific, actual_ok, standard, noreturn;
1197
1198   gfc_simplify_f simplify;
1199   gfc_check_f check;
1200   gfc_resolve_f resolve;
1201   struct gfc_intrinsic_sym *specific_head, *next;
1202   gfc_generic_isym_id generic_id;
1203
1204 }
1205 gfc_intrinsic_sym;
1206
1207
1208 /* Expression nodes.  The expression node types deserve explanations,
1209    since the last couple can be easily misconstrued:
1210
1211    EXPR_OP         Operator node pointing to one or two other nodes
1212    EXPR_FUNCTION   Function call, symbol points to function's name
1213    EXPR_CONSTANT   A scalar constant: Logical, String, Real, Int or Complex
1214    EXPR_VARIABLE   An Lvalue with a root symbol and possible reference list
1215                    which expresses structure, array and substring refs.
1216    EXPR_NULL       The NULL pointer value (which also has a basic type).
1217    EXPR_SUBSTRING  A substring of a constant string
1218    EXPR_STRUCTURE  A structure constructor
1219    EXPR_ARRAY      An array constructor.  */
1220
1221 #include <gmp.h>
1222 #include <mpfr.h>
1223 #define GFC_RND_MODE GMP_RNDN
1224
1225 typedef struct gfc_expr
1226 {
1227   expr_t expr_type;
1228
1229   gfc_typespec ts;      /* These two refer to the overall expression */
1230
1231   int rank;
1232   mpz_t *shape;         /* Can be NULL if shape is unknown at compile time */
1233
1234   /* Nonnull for functions and structure constructors */
1235   gfc_symtree *symtree;
1236
1237   gfc_ref *ref;
1238
1239   locus where;
1240
1241   /* True if it is converted from Hollerith constant.  */
1242   unsigned int from_H : 1;
1243   /* True if the expression is a call to a function that returns an array,
1244      and if we have decided not to allocate temporary data for that array.  */
1245   unsigned int inline_noncopying_intrinsic : 1;
1246
1247   union
1248   {
1249     int logical;
1250     mpz_t integer;
1251
1252     mpfr_t real;
1253
1254     struct
1255     {
1256       mpfr_t r, i;
1257     }
1258     complex;
1259
1260     struct
1261     {
1262       gfc_intrinsic_op operator;
1263       gfc_user_op *uop;
1264       struct gfc_expr *op1, *op2;
1265     }
1266     op;
1267
1268     struct
1269     {
1270       gfc_actual_arglist *actual;
1271       const char *name; /* Points to the ultimate name of the function */
1272       gfc_intrinsic_sym *isym;
1273       gfc_symbol *esym;
1274     }
1275     function;
1276
1277     struct
1278     {
1279       int length;
1280       char *string;
1281     }
1282     character;
1283
1284     struct gfc_constructor *constructor;
1285   }
1286   value;
1287
1288 }
1289 gfc_expr;
1290
1291
1292 #define gfc_get_shape(rank) ((mpz_t *) gfc_getmem((rank)*sizeof(mpz_t)))
1293
1294 /* Structures for information associated with different kinds of
1295    numbers.  The first set of integer parameters define all there is
1296    to know about a particular kind.  The rest of the elements are
1297    computed from the first elements.  */
1298
1299 typedef struct
1300 {
1301   /* Values really representable by the target.  */
1302   mpz_t huge, pedantic_min_int, min_int, max_int;
1303
1304   int kind, radix, digits, bit_size, range;
1305
1306   /* True if the C type of the given name maps to this precision.
1307      Note that more than one bit can be set.  */
1308   unsigned int c_char : 1;
1309   unsigned int c_short : 1;
1310   unsigned int c_int : 1;
1311   unsigned int c_long : 1;
1312   unsigned int c_long_long : 1;
1313 }
1314 gfc_integer_info;
1315
1316 extern gfc_integer_info gfc_integer_kinds[];
1317
1318
1319 typedef struct
1320 {
1321   int kind, bit_size;
1322
1323   /* True if the C++ type bool, C99 type _Bool, maps to this precision.  */
1324   unsigned int c_bool : 1;
1325 }
1326 gfc_logical_info;
1327
1328 extern gfc_logical_info gfc_logical_kinds[];
1329
1330
1331 typedef struct
1332 {
1333   mpfr_t epsilon, huge, tiny, subnormal;
1334   int kind, radix, digits, min_exponent, max_exponent;
1335   int range, precision;
1336
1337   /* The precision of the type as reported by GET_MODE_PRECISION.  */
1338   int mode_precision;
1339
1340   /* True if the C type of the given name maps to this precision.
1341      Note that more than one bit can be set.  */
1342   unsigned int c_float : 1;
1343   unsigned int c_double : 1;
1344   unsigned int c_long_double : 1;
1345 }
1346 gfc_real_info;
1347
1348 extern gfc_real_info gfc_real_kinds[];
1349
1350
1351 /* Equivalence structures.  Equivalent lvalues are linked along the
1352    *eq pointer, equivalence sets are strung along the *next node.  */
1353 typedef struct gfc_equiv
1354 {
1355   struct gfc_equiv *next, *eq;
1356   gfc_expr *expr;
1357   const char *module;
1358   int used;
1359 }
1360 gfc_equiv;
1361
1362 #define gfc_get_equiv() gfc_getmem(sizeof(gfc_equiv))
1363
1364 /* Holds a single equivalence member after processing.  */
1365 typedef struct gfc_equiv_info
1366 {
1367   gfc_symbol *sym;
1368   HOST_WIDE_INT offset;
1369   HOST_WIDE_INT length;
1370   struct gfc_equiv_info *next;
1371 } gfc_equiv_info;
1372
1373 /* Holds equivalence groups, after they have been processed.  */
1374 typedef struct gfc_equiv_list
1375 {
1376   gfc_equiv_info *equiv;
1377   struct gfc_equiv_list *next;
1378 } gfc_equiv_list;
1379
1380 /* gfc_case stores the selector list of a case statement.  The *low
1381    and *high pointers can point to the same expression in the case of
1382    a single value.  If *high is NULL, the selection is from *low
1383    upwards, if *low is NULL the selection is *high downwards.
1384
1385    This structure has separate fields to allow single and double linked
1386    lists of CASEs at the same time.  The singe linked list along the NEXT
1387    field is a list of cases for a single CASE label.  The double linked
1388    list along the LEFT/RIGHT fields is used to detect overlap and to
1389    build a table of the cases for SELECT constructs with a CHARACTER
1390    case expression.  */
1391
1392 typedef struct gfc_case
1393 {
1394   /* Where we saw this case.  */
1395   locus where;
1396   int n;
1397
1398   /* Case range values.  If (low == high), it's a single value.  If one of
1399      the labels is NULL, it's an unbounded case.  If both are NULL, this
1400      represents the default case.  */
1401   gfc_expr *low, *high;
1402
1403   /* Next case label in the list of cases for a single CASE label.  */
1404   struct gfc_case *next;
1405
1406   /* Used for detecting overlap, and for code generation.  */
1407   struct gfc_case *left, *right;
1408
1409   /* True if this case label can never be matched.  */
1410   int unreachable;
1411 }
1412 gfc_case;
1413
1414 #define gfc_get_case() gfc_getmem(sizeof(gfc_case))
1415
1416
1417 typedef struct
1418 {
1419   gfc_expr *var, *start, *end, *step;
1420 }
1421 gfc_iterator;
1422
1423 #define gfc_get_iterator() gfc_getmem(sizeof(gfc_iterator))
1424
1425
1426 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements.  */
1427
1428 typedef struct gfc_alloc
1429 {
1430   gfc_expr *expr;
1431   struct gfc_alloc *next;
1432 }
1433 gfc_alloc;
1434
1435 #define gfc_get_alloc() gfc_getmem(sizeof(gfc_alloc))
1436
1437
1438 typedef struct
1439 {
1440   gfc_expr *unit, *file, *status, *access, *form, *recl,
1441     *blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert;
1442   gfc_st_label *err;
1443 }
1444 gfc_open;
1445
1446
1447 typedef struct
1448 {
1449   gfc_expr *unit, *status, *iostat, *iomsg;
1450   gfc_st_label *err;
1451 }
1452 gfc_close;
1453
1454
1455 typedef struct
1456 {
1457   gfc_expr *unit, *iostat, *iomsg;
1458   gfc_st_label *err;
1459 }
1460 gfc_filepos;
1461
1462
1463 typedef struct
1464 {
1465   gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
1466     *name, *access, *sequential, *direct, *form, *formatted,
1467     *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
1468     *write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert;
1469
1470   gfc_st_label *err;
1471
1472 }
1473 gfc_inquire;
1474
1475
1476 typedef struct
1477 {
1478   gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg;
1479
1480   gfc_symbol *namelist;
1481   /* A format_label of `format_asterisk' indicates the "*" format */
1482   gfc_st_label *format_label;
1483   gfc_st_label *err, *end, *eor;
1484
1485   locus eor_where, end_where, err_where;
1486 }
1487 gfc_dt;
1488
1489
1490 typedef struct gfc_forall_iterator
1491 {
1492   gfc_expr *var, *start, *end, *stride;
1493   struct gfc_forall_iterator *next;
1494 }
1495 gfc_forall_iterator;
1496
1497
1498 /* Executable statements that fill gfc_code structures.  */
1499 typedef enum
1500 {
1501   EXEC_NOP = 1, EXEC_ASSIGN, EXEC_LABEL_ASSIGN, EXEC_POINTER_ASSIGN,
1502   EXEC_GOTO, EXEC_CALL, EXEC_ASSIGN_CALL, EXEC_RETURN, EXEC_ENTRY,
1503   EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE,
1504   EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_WHILE, EXEC_SELECT,
1505   EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT,
1506   EXEC_ALLOCATE, EXEC_DEALLOCATE,
1507   EXEC_OPEN, EXEC_CLOSE,
1508   EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
1509   EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
1510   EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
1511   EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
1512   EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
1513   EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
1514   EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
1515   EXEC_OMP_END_SINGLE
1516 }
1517 gfc_exec_op;
1518
1519 typedef struct gfc_code
1520 {
1521   gfc_exec_op op;
1522
1523   struct gfc_code *block, *next;
1524   locus loc;
1525
1526   gfc_st_label *here, *label, *label2, *label3;
1527   gfc_symtree *symtree;
1528   gfc_expr *expr, *expr2;
1529   /* A name isn't sufficient to identify a subroutine, we need the actual
1530      symbol for the interface definition.
1531   const char *sub_name;  */
1532   gfc_symbol *resolved_sym;
1533
1534   union
1535   {
1536     gfc_actual_arglist *actual;
1537     gfc_case *case_list;
1538     gfc_iterator *iterator;
1539     gfc_alloc *alloc_list;
1540     gfc_open *open;
1541     gfc_close *close;
1542     gfc_filepos *filepos;
1543     gfc_inquire *inquire;
1544     gfc_dt *dt;
1545     gfc_forall_iterator *forall_iterator;
1546     struct gfc_code *whichloop;
1547     int stop_code;
1548     gfc_entry_list *entry;
1549     gfc_omp_clauses *omp_clauses;
1550     const char *omp_name;
1551     gfc_namelist *omp_namelist;
1552     bool omp_bool;
1553   }
1554   ext;          /* Points to additional structures required by statement */
1555
1556   /* Backend_decl is used for cycle and break labels in do loops, and
1557      probably for other constructs as well, once we translate them.  */
1558   tree backend_decl;
1559 }
1560 gfc_code;
1561
1562
1563 /* Storage for DATA statements.  */
1564 typedef struct gfc_data_variable
1565 {
1566   gfc_expr *expr;
1567   gfc_iterator iter;
1568   struct gfc_data_variable *list, *next;
1569 }
1570 gfc_data_variable;
1571
1572
1573 typedef struct gfc_data_value
1574 {
1575   unsigned int repeat;
1576   gfc_expr *expr;
1577   struct gfc_data_value *next;
1578 }
1579 gfc_data_value;
1580
1581
1582 typedef struct gfc_data
1583 {
1584   gfc_data_variable *var;
1585   gfc_data_value *value;
1586   locus where;
1587
1588   struct gfc_data *next;
1589 }
1590 gfc_data;
1591
1592 #define gfc_get_data_variable() gfc_getmem(sizeof(gfc_data_variable))
1593 #define gfc_get_data_value() gfc_getmem(sizeof(gfc_data_value))
1594 #define gfc_get_data() gfc_getmem(sizeof(gfc_data))
1595
1596
1597 /* Structure for holding compile options */
1598 typedef struct
1599 {
1600   char *module_dir;
1601   gfc_source_form source_form;
1602   /* When fixed_line_length or free_line_length are 0, the whole line is used.
1603
1604      Default is -1, the maximum line length mandated by the respective source
1605      form is used:
1606      for FORM_FREE GFC_MAX_LINE (132)
1607      else 72.
1608
1609      If fixed_line_length or free_line_length is not 0 nor -1 then the user has
1610      requested a specific line-length.
1611
1612      If the user requests a fixed_line_length <7 then gfc_init_options()
1613      emits a fatal error.  */
1614   int fixed_line_length; /* maximum line length in fixed-form.  */
1615   int free_line_length; /* maximum line length in free-form.  */
1616   int max_identifier_length;
1617   int verbose;
1618
1619   int warn_aliasing;
1620   int warn_ampersand;
1621   int warn_conversion;
1622   int warn_implicit_interface;
1623   int warn_line_truncation;
1624   int warn_surprising;
1625   int warn_tabs;
1626   int warn_underflow;
1627   int warn_unused_labels;
1628
1629   int flag_all_intrinsics;
1630   int flag_default_double;
1631   int flag_default_integer;
1632   int flag_default_real;
1633   int flag_dollar_ok;
1634   int flag_underscoring;
1635   int flag_second_underscore;
1636   int flag_implicit_none;
1637   int flag_max_stack_var_size;
1638   int flag_module_access_private;
1639   int flag_no_backend;
1640   int flag_range_check;
1641   int flag_pack_derived;
1642   int flag_repack_arrays;
1643   int flag_preprocessed;
1644   int flag_f2c;
1645   int flag_automatic;
1646   int flag_backslash;
1647   int flag_cray_pointer;
1648   int flag_d_lines;
1649   int flag_openmp;
1650
1651   int q_kind;
1652
1653   int fpe;
1654
1655   int warn_std;
1656   int allow_std;
1657   int warn_nonstd_intrinsics;
1658   int fshort_enums;
1659   int convert;
1660   int record_marker;
1661 }
1662 gfc_option_t;
1663
1664 extern gfc_option_t gfc_option;
1665
1666
1667 /* Constructor nodes for array and structure constructors.  */
1668 typedef struct gfc_constructor
1669 {
1670   gfc_expr *expr;
1671   gfc_iterator *iterator;
1672   locus where;
1673   struct gfc_constructor *next;
1674   struct
1675   {
1676     mpz_t offset; /* Record the offset of array element which appears in
1677                      data statement like "data a(5)/4/".  */
1678     gfc_component *component; /* Record the component being initialized.  */
1679   }
1680   n;
1681   mpz_t repeat; /* Record the repeat number of initial values in data
1682                  statement like "data a/5*10/".  */
1683 }
1684 gfc_constructor;
1685
1686
1687 typedef struct iterator_stack
1688 {
1689   gfc_symtree *variable;
1690   mpz_t value;
1691   struct iterator_stack *prev;
1692 }
1693 iterator_stack;
1694 extern iterator_stack *iter_stack;
1695
1696 /************************ Function prototypes *************************/
1697
1698 /* data.c  */
1699 void gfc_formalize_init_value (gfc_symbol *);
1700 void gfc_get_section_index (gfc_array_ref *, mpz_t *, mpz_t *);
1701 void gfc_assign_data_value (gfc_expr *, gfc_expr *, mpz_t);
1702 void gfc_assign_data_value_range (gfc_expr *, gfc_expr *, mpz_t, mpz_t);
1703 void gfc_advance_section (mpz_t *, gfc_array_ref *, mpz_t *);
1704
1705 /* scanner.c */
1706 void gfc_scanner_done_1 (void);
1707 void gfc_scanner_init_1 (void);
1708
1709 void gfc_add_include_path (const char *);
1710 void gfc_release_include_path (void);
1711 FILE *gfc_open_included_file (const char *, bool);
1712
1713 int gfc_at_end (void);
1714 int gfc_at_eof (void);
1715 int gfc_at_bol (void);
1716 int gfc_at_eol (void);
1717 void gfc_advance_line (void);
1718 int gfc_check_include (void);
1719
1720 void gfc_skip_comments (void);
1721 int gfc_next_char_literal (int);
1722 int gfc_next_char (void);
1723 int gfc_peek_char (void);
1724 void gfc_error_recovery (void);
1725 void gfc_gobble_whitespace (void);
1726 try gfc_new_file (void);
1727 const char * gfc_read_orig_filename (const char *, const char **);
1728
1729 extern gfc_source_form gfc_current_form;
1730 extern const char *gfc_source_file;
1731 extern locus gfc_current_locus;
1732
1733 /* misc.c */
1734 void *gfc_getmem (size_t) ATTRIBUTE_MALLOC;
1735 void gfc_free (void *);
1736 int gfc_terminal_width(void);
1737 void gfc_clear_ts (gfc_typespec *);
1738 FILE *gfc_open_file (const char *);
1739 const char *gfc_basic_typename (bt);
1740 const char *gfc_typename (gfc_typespec *);
1741
1742 #define gfc_op2string(OP) (OP == INTRINSIC_ASSIGN ? \
1743                            "=" : gfc_code2string (intrinsic_operators, OP))
1744
1745 const char *gfc_code2string (const mstring *, int);
1746 int gfc_string2code (const mstring *, const char *);
1747 const char *gfc_intent_string (sym_intent);
1748
1749 void gfc_init_1 (void);
1750 void gfc_init_2 (void);
1751 void gfc_done_1 (void);
1752 void gfc_done_2 (void);
1753
1754 /* options.c */
1755 unsigned int gfc_init_options (unsigned int, const char **);
1756 int gfc_handle_option (size_t, const char *, int);
1757 bool gfc_post_options (const char **);
1758
1759 /* iresolve.c */
1760 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
1761
1762 /* error.c */
1763
1764 typedef struct gfc_error_buf
1765 {
1766   int flag;
1767   size_t allocated, index;
1768   char *message;
1769 } gfc_error_buf;
1770
1771 void gfc_error_init_1 (void);
1772 void gfc_buffer_error (int);
1773
1774 void gfc_warning (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
1775 void gfc_warning_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
1776 void gfc_clear_warning (void);
1777 void gfc_warning_check (void);
1778
1779 void gfc_error (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
1780 void gfc_error_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
1781 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
1782 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
1783 void gfc_clear_error (void);
1784 int gfc_error_check (void);
1785
1786 notification gfc_notification_std (int);
1787 try gfc_notify_std (int, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
1788
1789 /* A general purpose syntax error.  */
1790 #define gfc_syntax_error(ST)    \
1791   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
1792
1793 void gfc_push_error (gfc_error_buf *);
1794 void gfc_pop_error (gfc_error_buf *);
1795 void gfc_free_error (gfc_error_buf *);
1796
1797 void gfc_status (const char *, ...) ATTRIBUTE_PRINTF_1;
1798 void gfc_status_char (char);
1799
1800 void gfc_get_errors (int *, int *);
1801
1802 /* arith.c */
1803 void gfc_arith_init_1 (void);
1804 void gfc_arith_done_1 (void);
1805 gfc_expr *gfc_enum_initializer (gfc_expr *, locus);
1806 arith gfc_check_integer_range (mpz_t p, int kind);
1807
1808 /* trans-types.c */
1809 int gfc_validate_kind (bt, int, bool);
1810 extern int gfc_index_integer_kind;
1811 extern int gfc_default_integer_kind;
1812 extern int gfc_max_integer_kind;
1813 extern int gfc_default_real_kind;
1814 extern int gfc_default_double_kind;
1815 extern int gfc_default_character_kind;
1816 extern int gfc_default_logical_kind;
1817 extern int gfc_default_complex_kind;
1818 extern int gfc_c_int_kind;
1819 extern int gfc_large_io_int_kind;
1820
1821 /* symbol.c */
1822 void gfc_clear_new_implicit (void);
1823 try gfc_add_new_implicit_range (int, int);
1824 try gfc_merge_new_implicit (gfc_typespec *);
1825 void gfc_set_implicit_none (void);
1826
1827 gfc_typespec *gfc_get_default_type (gfc_symbol *, gfc_namespace *);
1828 try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
1829
1830 void gfc_set_component_attr (gfc_component *, symbol_attribute *);
1831 void gfc_get_component_attr (symbol_attribute *, gfc_component *);
1832
1833 void gfc_set_sym_referenced (gfc_symbol * sym);
1834
1835 try gfc_add_attribute (symbol_attribute *, locus *, unsigned int);
1836 try gfc_add_allocatable (symbol_attribute *, locus *);
1837 try gfc_add_dimension (symbol_attribute *, const char *, locus *);
1838 try gfc_add_external (symbol_attribute *, locus *);
1839 try gfc_add_intrinsic (symbol_attribute *, locus *);
1840 try gfc_add_optional (symbol_attribute *, locus *);
1841 try gfc_add_pointer (symbol_attribute *, locus *);
1842 try gfc_add_cray_pointer (symbol_attribute *, locus *);
1843 try gfc_add_cray_pointee (symbol_attribute *, locus *);
1844 try gfc_mod_pointee_as (gfc_array_spec *as);
1845 try gfc_add_result (symbol_attribute *, const char *, locus *);
1846 try gfc_add_save (symbol_attribute *, const char *, locus *);
1847 try gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
1848 try gfc_add_saved_common (symbol_attribute *, locus *);
1849 try gfc_add_target (symbol_attribute *, locus *);
1850 try gfc_add_dummy (symbol_attribute *, const char *, locus *);
1851 try gfc_add_generic (symbol_attribute *, const char *, locus *);
1852 try gfc_add_common (symbol_attribute *, locus *);
1853 try gfc_add_in_common (symbol_attribute *, const char *, locus *);
1854 try gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
1855 try gfc_add_data (symbol_attribute *, const char *, locus *);
1856 try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
1857 try gfc_add_sequence (symbol_attribute *, const char *, locus *);
1858 try gfc_add_elemental (symbol_attribute *, locus *);
1859 try gfc_add_pure (symbol_attribute *, locus *);
1860 try gfc_add_recursive (symbol_attribute *, locus *);
1861 try gfc_add_function (symbol_attribute *, const char *, locus *);
1862 try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
1863
1864 try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
1865 try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
1866 try gfc_add_entry (symbol_attribute *, const char *, locus *);
1867 try gfc_add_procedure (symbol_attribute *, procedure_type,
1868                        const char *, locus *);
1869 try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
1870 try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
1871                                 gfc_formal_arglist *, locus *);
1872 try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
1873
1874 void gfc_clear_attr (symbol_attribute *);
1875 try gfc_missing_attr (symbol_attribute *, locus *);
1876 try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
1877
1878 try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
1879 gfc_symbol *gfc_use_derived (gfc_symbol *);
1880 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
1881 gfc_component *gfc_find_component (gfc_symbol *, const char *);
1882
1883 gfc_st_label *gfc_get_st_label (int);
1884 void gfc_free_st_label (gfc_st_label *);
1885 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
1886 try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
1887
1888 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
1889 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
1890 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
1891 gfc_user_op *gfc_get_uop (const char *);
1892 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
1893 void gfc_free_symbol (gfc_symbol *);
1894 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
1895 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
1896 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
1897 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
1898 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **);
1899 int gfc_get_ha_symbol (const char *, gfc_symbol **);
1900 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
1901
1902 int gfc_symbols_could_alias (gfc_symbol *, gfc_symbol *);
1903
1904 void gfc_undo_symbols (void);
1905 void gfc_commit_symbols (void);
1906 void gfc_commit_symbol (gfc_symbol * sym);
1907 void gfc_free_namespace (gfc_namespace *);
1908
1909 void gfc_symbol_init_2 (void);
1910 void gfc_symbol_done_2 (void);
1911
1912 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
1913 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
1914 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
1915 void gfc_save_all (gfc_namespace *);
1916
1917 void gfc_symbol_state (void);
1918
1919 gfc_gsymbol *gfc_get_gsymbol (const char *);
1920 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
1921
1922 /* intrinsic.c */
1923 extern int gfc_init_expr;
1924
1925 /* Given a symbol that we have decided is intrinsic, mark it as such
1926    by placing it into a special module that is otherwise impossible to
1927    read or write.  */
1928
1929 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
1930
1931 void gfc_intrinsic_init_1 (void);
1932 void gfc_intrinsic_done_1 (void);
1933
1934 char gfc_type_letter (bt);
1935 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
1936 try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
1937 try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
1938 int gfc_generic_intrinsic (const char *);
1939 int gfc_specific_intrinsic (const char *);
1940 int gfc_intrinsic_name (const char *, int);
1941 gfc_intrinsic_sym *gfc_find_function (const char *);
1942
1943 match gfc_intrinsic_func_interface (gfc_expr *, int);
1944 match gfc_intrinsic_sub_interface (gfc_code *, int);
1945
1946 /* simplify.c */
1947 void gfc_simplify_init_1 (void);
1948
1949 /* match.c -- FIXME */
1950 void gfc_free_iterator (gfc_iterator *, int);
1951 void gfc_free_forall_iterator (gfc_forall_iterator *);
1952 void gfc_free_alloc_list (gfc_alloc *);
1953 void gfc_free_namelist (gfc_namelist *);
1954 void gfc_free_equiv (gfc_equiv *);
1955 void gfc_free_data (gfc_data *);
1956 void gfc_free_case_list (gfc_case *);
1957
1958 /* matchexp.c -- FIXME too?  */
1959 gfc_expr *gfc_get_parentheses (gfc_expr *);
1960
1961 /* openmp.c */
1962 void gfc_free_omp_clauses (gfc_omp_clauses *);
1963 void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
1964 void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *);
1965 void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
1966 void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
1967
1968 /* expr.c */
1969 void gfc_free_actual_arglist (gfc_actual_arglist *);
1970 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
1971 const char *gfc_extract_int (gfc_expr *, int *);
1972
1973 gfc_expr *gfc_build_conversion (gfc_expr *);
1974 void gfc_free_ref_list (gfc_ref *);
1975 void gfc_type_convert_binary (gfc_expr *);
1976 int gfc_is_constant_expr (gfc_expr *);
1977 try gfc_simplify_expr (gfc_expr *, int);
1978 int gfc_has_vector_index (gfc_expr *);
1979
1980 gfc_expr *gfc_get_expr (void);
1981 void gfc_free_expr (gfc_expr *);
1982 void gfc_replace_expr (gfc_expr *, gfc_expr *);
1983 gfc_expr *gfc_int_expr (int);
1984 gfc_expr *gfc_logical_expr (int, locus *);
1985 mpz_t *gfc_copy_shape (mpz_t *, int);
1986 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
1987 gfc_expr *gfc_copy_expr (gfc_expr *);
1988
1989 try gfc_specification_expr (gfc_expr *);
1990
1991 int gfc_numeric_ts (gfc_typespec *);
1992 int gfc_kind_max (gfc_expr *, gfc_expr *);
1993
1994 try gfc_check_conformance (const char *, gfc_expr *, gfc_expr *);
1995 try gfc_check_assign (gfc_expr *, gfc_expr *, int);
1996 try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
1997 try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
1998
1999 gfc_expr *gfc_default_initializer (gfc_typespec *);
2000 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
2001
2002 void gfc_expr_set_symbols_referenced (gfc_expr * expr);
2003
2004 /* st.c */
2005 extern gfc_code new_st;
2006
2007 void gfc_clear_new_st (void);
2008 gfc_code *gfc_get_code (void);
2009 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
2010 void gfc_free_statement (gfc_code *);
2011 void gfc_free_statements (gfc_code *);
2012
2013 /* resolve.c */
2014 try gfc_resolve_expr (gfc_expr *);
2015 void gfc_resolve (gfc_namespace *);
2016 void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
2017 int gfc_impure_variable (gfc_symbol *);
2018 int gfc_pure (gfc_symbol *);
2019 int gfc_elemental (gfc_symbol *);
2020 try gfc_resolve_iterator (gfc_iterator *, bool);
2021 try gfc_resolve_index (gfc_expr *, int);
2022 try gfc_resolve_dim_arg (gfc_expr *);
2023 int gfc_is_formal_arg (void);
2024
2025 /* array.c */
2026 void gfc_free_array_spec (gfc_array_spec *);
2027 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
2028
2029 try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
2030 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
2031 try gfc_resolve_array_spec (gfc_array_spec *, int);
2032
2033 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
2034
2035 gfc_expr *gfc_start_constructor (bt, int, locus *);
2036 void gfc_append_constructor (gfc_expr *, gfc_expr *);
2037 void gfc_free_constructor (gfc_constructor *);
2038 void gfc_simplify_iterator_var (gfc_expr *);
2039 try gfc_expand_constructor (gfc_expr *);
2040 int gfc_constant_ac (gfc_expr *);
2041 int gfc_expanded_ac (gfc_expr *);
2042 void gfc_resolve_character_array_constructor (gfc_expr *);
2043 try gfc_resolve_array_constructor (gfc_expr *);
2044 try gfc_check_constructor_type (gfc_expr *);
2045 try gfc_check_iter_variable (gfc_expr *);
2046 try gfc_check_constructor (gfc_expr *, try (*)(gfc_expr *));
2047 gfc_constructor *gfc_copy_constructor (gfc_constructor * src);
2048 gfc_expr *gfc_get_array_element (gfc_expr *, int);
2049 try gfc_array_size (gfc_expr *, mpz_t *);
2050 try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
2051 try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
2052 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
2053 void gfc_insert_constructor (gfc_expr *, gfc_constructor *);
2054 gfc_constructor *gfc_get_constructor (void);
2055 tree gfc_conv_array_initializer (tree type, gfc_expr * expr);
2056 try spec_size (gfc_array_spec *, mpz_t *);
2057 int gfc_is_compile_time_shape (gfc_array_spec *);
2058
2059 /* interface.c -- FIXME: some of these should be in symbol.c */
2060 void gfc_free_interface (gfc_interface *);
2061 int gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
2062 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
2063 void gfc_check_interfaces (gfc_namespace *);
2064 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
2065 gfc_symbol *gfc_search_interface (gfc_interface *, int,
2066                                   gfc_actual_arglist **);
2067 try gfc_extend_expr (gfc_expr *);
2068 void gfc_free_formal_arglist (gfc_formal_arglist *);
2069 try gfc_extend_assign (gfc_code *, gfc_namespace *);
2070 try gfc_add_interface (gfc_symbol * sym);
2071
2072 /* io.c */
2073 extern gfc_st_label format_asterisk;
2074
2075 void gfc_free_open (gfc_open *);
2076 try gfc_resolve_open (gfc_open *);
2077 void gfc_free_close (gfc_close *);
2078 try gfc_resolve_close (gfc_close *);
2079 void gfc_free_filepos (gfc_filepos *);
2080 try gfc_resolve_filepos (gfc_filepos *);
2081 void gfc_free_inquire (gfc_inquire *);
2082 try gfc_resolve_inquire (gfc_inquire *);
2083 void gfc_free_dt (gfc_dt *);
2084 try gfc_resolve_dt (gfc_dt *);
2085
2086 /* module.c */
2087 void gfc_module_init_2 (void);
2088 void gfc_module_done_2 (void);
2089 void gfc_dump_module (const char *, int);
2090 bool gfc_check_access (gfc_access, gfc_access);
2091
2092 /* primary.c */
2093 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
2094 symbol_attribute gfc_expr_attr (gfc_expr *);
2095
2096 /* trans.c */
2097 void gfc_generate_code (gfc_namespace *);
2098 void gfc_generate_module_code (gfc_namespace *);
2099
2100 /* bbt.c */
2101 typedef int (*compare_fn) (void *, void *);
2102 void gfc_insert_bbt (void *, void *, compare_fn);
2103 void gfc_delete_bbt (void *, void *, compare_fn);
2104
2105 /* dump-parse-tree.c */
2106 void gfc_show_namespace (gfc_namespace *);
2107
2108 /* parse.c */
2109 try gfc_parse_file (void);
2110 void global_used (gfc_gsymbol *, locus *);
2111
2112 /* dependency.c */
2113 int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
2114
2115 #endif /* GCC_GFORTRAN_H  */