OSDN Git Service

94b2b19c7cb6c95d9ede41ceab1baadcb30a649b
[pf3gnuchains/gcc-fork.git] / gcc / fortran / gfortran.h
1 /* gfortran header file
2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3    2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Andy Vaught
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
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 /* Declarations common to the front-end and library are put in
33    libgfortran/libgfortran_frontend.h  */
34 #include "libgfortran.h"
35
36
37 #include "intl.h"
38 #include "coretypes.h"
39 #include "input.h"
40 #include "splay-tree.h"
41 /* The following ifdefs are recommended by the autoconf documentation
42    for any code using alloca.  */
43
44 /* AIX requires this to be the first thing in the file.  */
45 #ifdef __GNUC__
46 #else /* not __GNUC__ */
47 #ifdef HAVE_ALLOCA_H
48 #include <alloca.h>
49 #else /* do not HAVE_ALLOCA_H */
50 #ifdef _AIX
51 #pragma alloca
52 #else
53 #ifndef alloca                  /* predefined by HP cc +Olibcalls */
54 char *alloca ();
55 #endif /* not predefined */
56 #endif /* not _AIX */
57 #endif /* do not HAVE_ALLOCA_H */
58 #endif /* not __GNUC__ */
59
60 /* Major control parameters.  */
61
62 #define GFC_MAX_SYMBOL_LEN 63   /* Must be at least 63 for F2003.  */
63 #define GFC_MAX_BINDING_LABEL_LEN 126 /* (2 * GFC_MAX_SYMBOL_LEN) */
64 #define GFC_MAX_LINE 132        /* Characters beyond this are not seen.  */
65 #define GFC_LETTERS 26          /* Number of letters in the alphabet.  */
66
67 #define MAX_SUBRECORD_LENGTH 2147483639   /* 2**31-9 */
68
69
70 #define free(x) Use_gfc_free_instead_of_free()
71 #define gfc_is_whitespace(c) ((c==' ') || (c=='\t'))
72
73 #ifndef NULL
74 #define NULL ((void *) 0)
75 #endif
76
77 /* Stringization.  */
78 #define stringize(x) expand_macro(x)
79 #define expand_macro(x) # x
80
81 /* For the runtime library, a standard prefix is a requirement to
82    avoid cluttering the namespace with things nobody asked for.  It's
83    ugly to look at and a pain to type when you add the prefix by hand,
84    so we hide it behind a macro.  */
85 #define PREFIX(x) "_gfortran_" x
86 #define PREFIX_LEN 10
87
88 #define BLANK_COMMON_NAME "__BLNK__"
89
90 /* Macro to initialize an mstring structure.  */
91 #define minit(s, t) { s, NULL, t }
92
93 /* Structure for storing strings to be matched by gfc_match_string.  */
94 typedef struct
95 {
96   const char *string;
97   const char *mp;
98   int tag;
99 }
100 mstring;
101
102
103
104 /*************************** Enums *****************************/
105
106 /* Used when matching and resolving data I/O transfer statements.  */
107
108 typedef enum
109 { M_READ, M_WRITE, M_PRINT, M_INQUIRE }
110 io_kind;
111
112 /* The author remains confused to this day about the convention of
113    returning '0' for 'SUCCESS'... or was it the other way around?  The
114    following enum makes things much more readable.  We also start
115    values off at one instead of zero.  */
116
117 typedef enum
118 { SUCCESS = 1, FAILURE }
119 gfc_try;
120
121 /* This is returned by gfc_notification_std to know if, given the flags
122    that were given (-std=, -pedantic) we should issue an error, a warning
123    or nothing.  */
124
125 typedef enum
126 { SILENT, WARNING, ERROR }
127 notification;
128
129 /* Matchers return one of these three values.  The difference between
130    MATCH_NO and MATCH_ERROR is that MATCH_ERROR means that a match was
131    successful, but that something non-syntactic is wrong and an error
132    has already been issued.  */
133
134 typedef enum
135 { MATCH_NO = 1, MATCH_YES, MATCH_ERROR }
136 match;
137
138 typedef enum
139 { FORM_FREE, FORM_FIXED, FORM_UNKNOWN }
140 gfc_source_form;
141
142 /* Basic types.  BT_VOID is used by ISO C Binding so funcs like c_f_pointer
143    can take any arg with the pointer attribute as a param.  */
144 typedef enum
145 { BT_UNKNOWN = 1, BT_INTEGER, BT_REAL, BT_COMPLEX, BT_LOGICAL, BT_CHARACTER,
146   BT_DERIVED, BT_CLASS, BT_PROCEDURE, BT_HOLLERITH, BT_VOID
147 }
148 bt;
149
150 /* Expression node types.  */
151 typedef enum
152 { EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,
153   EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL, EXPR_COMPCALL, EXPR_PPC
154 }
155 expr_t;
156
157 /* Array types.  */
158 typedef enum
159 { AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,
160   AS_ASSUMED_SIZE, AS_IMPLIED_SHAPE, AS_UNKNOWN
161 }
162 array_type;
163
164 typedef enum
165 { AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN }
166 ar_type;
167
168 /* Statement label types.  */
169 typedef enum
170 { ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET,
171   ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT
172 }
173 gfc_sl_type;
174
175 /* Intrinsic operators.  */
176 typedef enum
177 { GFC_INTRINSIC_BEGIN = 0,
178   INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,
179   INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,
180   INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,
181   INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,
182   /* ==, /=, >, >=, <, <=  */
183   INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,
184   INTRINSIC_LT, INTRINSIC_LE, 
185   /* .EQ., .NE., .GT., .GE., .LT., .LE. (OS = Old-Style)  */
186   INTRINSIC_EQ_OS, INTRINSIC_NE_OS, INTRINSIC_GT_OS, INTRINSIC_GE_OS,
187   INTRINSIC_LT_OS, INTRINSIC_LE_OS, 
188   INTRINSIC_NOT, INTRINSIC_USER, INTRINSIC_ASSIGN, 
189   INTRINSIC_PARENTHESES, GFC_INTRINSIC_END /* Sentinel */
190 }
191 gfc_intrinsic_op;
192
193
194 /* This macro is the number of intrinsic operators that exist.
195    Assumptions are made about the numbering of the interface_op enums.  */
196 #define GFC_INTRINSIC_OPS GFC_INTRINSIC_END
197
198 /* Arithmetic results.  */
199 typedef enum
200 { ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,
201   ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC, ARITH_PROHIBIT
202 }
203 arith;
204
205 /* Statements.  */
206 typedef enum
207 {
208   ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_ASSOCIATE,
209   ST_BACKSPACE, ST_BLOCK, ST_BLOCK_DATA,
210   ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,
211   ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,
212   ST_ELSEWHERE, ST_END_ASSOCIATE, ST_END_BLOCK, ST_END_BLOCK_DATA,
213   ST_ENDDO, ST_IMPLIED_ENDDO,
214   ST_END_FILE, ST_FINAL, ST_FLUSH, ST_END_FORALL, ST_END_FUNCTION, ST_ENDIF,
215   ST_END_INTERFACE, ST_END_MODULE, ST_END_PROGRAM, ST_END_SELECT,
216   ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE, ST_ENTRY, ST_EQUIVALENCE,
217   ST_ERROR_STOP, ST_EXIT, ST_FORALL, ST_FORALL_BLOCK, ST_FORMAT, ST_FUNCTION,
218   ST_GOTO, ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE, ST_IMPORT,
219   ST_INQUIRE, ST_INTERFACE, ST_SYNC_ALL, ST_SYNC_MEMORY, ST_SYNC_IMAGES,
220   ST_PARAMETER, ST_MODULE, ST_MODULE_PROC, ST_NAMELIST, ST_NULLIFY, ST_OPEN,
221   ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC, ST_READ, ST_RETURN, ST_REWIND,
222   ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE, ST_WHERE_BLOCK, ST_WHERE, ST_WAIT, 
223   ST_WRITE, ST_ASSIGNMENT, ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE,
224   ST_SIMPLE_IF, ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT,
225   ST_ENUM, ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,
226   ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_CRITICAL,
227   ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED, ST_OMP_END_PARALLEL,
228   ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,
229   ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,
230   ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,
231   ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
232   ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
233   ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,
234   ST_OMP_TASKWAIT, ST_PROCEDURE, ST_GENERIC, ST_CRITICAL, ST_END_CRITICAL,
235   ST_GET_FCN_CHARACTERISTICS, ST_NONE
236 }
237 gfc_statement;
238
239
240 /* Types of interfaces that we can have.  Assignment interfaces are
241    considered to be intrinsic operators.  */
242 typedef enum
243 {
244   INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,
245   INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP, INTERFACE_ABSTRACT
246 }
247 interface_type;
248
249 /* Symbol flavors: these are all mutually exclusive.
250    10 elements = 4 bits.  */
251 typedef enum sym_flavor
252 {
253   FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
254   FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,
255   FL_VOID
256 }
257 sym_flavor;
258
259 /* Procedure types.  7 elements = 3 bits.  */
260 typedef enum procedure_type
261 { PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,
262   PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL
263 }
264 procedure_type;
265
266 /* Intent types.  */
267 typedef enum sym_intent
268 { INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT
269 }
270 sym_intent;
271
272 /* Access types.  */
273 typedef enum gfc_access
274 { ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE
275 }
276 gfc_access;
277
278 /* Flags to keep track of where an interface came from.
279    3 elements = 2 bits.  */
280 typedef enum ifsrc
281 { IFSRC_UNKNOWN = 0,    /* Interface unknown, only return type may be known.  */
282   IFSRC_DECL,           /* FUNCTION or SUBROUTINE declaration.  */
283   IFSRC_IFBODY          /* INTERFACE statement or PROCEDURE statement
284                            with explicit interface.  */
285 }
286 ifsrc;
287
288 /* Whether a SAVE attribute was set explicitly or implicitly.  */
289 typedef enum save_state
290 { SAVE_NONE = 0, SAVE_EXPLICIT, SAVE_IMPLICIT
291 }
292 save_state;
293
294 /* Strings for all symbol attributes.  We use these for dumping the
295    parse tree, in error messages, and also when reading and writing
296    modules.  In symbol.c.  */
297 extern const mstring flavors[];
298 extern const mstring procedures[];
299 extern const mstring intents[];
300 extern const mstring access_types[];
301 extern const mstring ifsrc_types[];
302 extern const mstring save_status[];
303
304 /* Enumeration of all the generic intrinsic functions.  Used by the
305    backend for identification of a function.  */
306
307 enum gfc_isym_id
308 {
309   /* GFC_ISYM_NONE is used for intrinsics which will never be seen by
310      the backend (e.g. KIND).  */
311   GFC_ISYM_NONE = 0,
312   GFC_ISYM_ABORT,
313   GFC_ISYM_ABS,
314   GFC_ISYM_ACCESS,
315   GFC_ISYM_ACHAR,
316   GFC_ISYM_ACOS,
317   GFC_ISYM_ACOSH,
318   GFC_ISYM_ADJUSTL,
319   GFC_ISYM_ADJUSTR,
320   GFC_ISYM_AIMAG,
321   GFC_ISYM_AINT,
322   GFC_ISYM_ALARM,
323   GFC_ISYM_ALL,
324   GFC_ISYM_ALLOCATED,
325   GFC_ISYM_AND,
326   GFC_ISYM_ANINT,
327   GFC_ISYM_ANY,
328   GFC_ISYM_ASIN,
329   GFC_ISYM_ASINH,
330   GFC_ISYM_ASSOCIATED,
331   GFC_ISYM_ATAN,
332   GFC_ISYM_ATAN2,
333   GFC_ISYM_ATANH,
334   GFC_ISYM_BGE,
335   GFC_ISYM_BGT,
336   GFC_ISYM_BIT_SIZE,
337   GFC_ISYM_BLE,
338   GFC_ISYM_BLT,
339   GFC_ISYM_BTEST,
340   GFC_ISYM_CEILING,
341   GFC_ISYM_CHAR,
342   GFC_ISYM_CHDIR,
343   GFC_ISYM_CHMOD,
344   GFC_ISYM_CMPLX,
345   GFC_ISYM_COMMAND_ARGUMENT_COUNT,
346   GFC_ISYM_COMPLEX,
347   GFC_ISYM_CONJG,
348   GFC_ISYM_CONVERSION,
349   GFC_ISYM_COS,
350   GFC_ISYM_COSH,
351   GFC_ISYM_COUNT,
352   GFC_ISYM_CPU_TIME,
353   GFC_ISYM_CSHIFT,
354   GFC_ISYM_CTIME,
355   GFC_ISYM_C_SIZEOF,
356   GFC_ISYM_DATE_AND_TIME,
357   GFC_ISYM_DBLE,
358   GFC_ISYM_DIGITS,
359   GFC_ISYM_DIM,
360   GFC_ISYM_DOT_PRODUCT,
361   GFC_ISYM_DPROD,
362   GFC_ISYM_DSHIFTL,
363   GFC_ISYM_DSHIFTR,
364   GFC_ISYM_DTIME,
365   GFC_ISYM_EOSHIFT,
366   GFC_ISYM_EPSILON,
367   GFC_ISYM_ERF,
368   GFC_ISYM_ERFC,
369   GFC_ISYM_ERFC_SCALED,
370   GFC_ISYM_ETIME,
371   GFC_ISYM_EXECUTE_COMMAND_LINE,
372   GFC_ISYM_EXIT,
373   GFC_ISYM_EXP,
374   GFC_ISYM_EXPONENT,
375   GFC_ISYM_EXTENDS_TYPE_OF,
376   GFC_ISYM_FDATE,
377   GFC_ISYM_FGET,
378   GFC_ISYM_FGETC,
379   GFC_ISYM_FLOOR,
380   GFC_ISYM_FLUSH,
381   GFC_ISYM_FNUM,
382   GFC_ISYM_FPUT,
383   GFC_ISYM_FPUTC,
384   GFC_ISYM_FRACTION,
385   GFC_ISYM_FREE,
386   GFC_ISYM_FSEEK,
387   GFC_ISYM_FSTAT,
388   GFC_ISYM_FTELL,
389   GFC_ISYM_TGAMMA,
390   GFC_ISYM_GERROR,
391   GFC_ISYM_GETARG,
392   GFC_ISYM_GET_COMMAND,
393   GFC_ISYM_GET_COMMAND_ARGUMENT,
394   GFC_ISYM_GETCWD,
395   GFC_ISYM_GETENV,
396   GFC_ISYM_GET_ENVIRONMENT_VARIABLE,
397   GFC_ISYM_GETGID,
398   GFC_ISYM_GETLOG,
399   GFC_ISYM_GETPID,
400   GFC_ISYM_GETUID,
401   GFC_ISYM_GMTIME,
402   GFC_ISYM_HOSTNM,
403   GFC_ISYM_HUGE,
404   GFC_ISYM_HYPOT,
405   GFC_ISYM_IACHAR,
406   GFC_ISYM_IALL,
407   GFC_ISYM_IAND,
408   GFC_ISYM_IANY,
409   GFC_ISYM_IARGC,
410   GFC_ISYM_IBCLR,
411   GFC_ISYM_IBITS,
412   GFC_ISYM_IBSET,
413   GFC_ISYM_ICHAR,
414   GFC_ISYM_IDATE,
415   GFC_ISYM_IEOR,
416   GFC_ISYM_IERRNO,
417   GFC_ISYM_IMAGE_INDEX,
418   GFC_ISYM_INDEX,
419   GFC_ISYM_INT,
420   GFC_ISYM_INT2,
421   GFC_ISYM_INT8,
422   GFC_ISYM_IOR,
423   GFC_ISYM_IPARITY,
424   GFC_ISYM_IRAND,
425   GFC_ISYM_ISATTY,
426   GFC_ISYM_IS_IOSTAT_END,
427   GFC_ISYM_IS_IOSTAT_EOR,
428   GFC_ISYM_ISNAN,
429   GFC_ISYM_ISHFT,
430   GFC_ISYM_ISHFTC,
431   GFC_ISYM_ITIME,
432   GFC_ISYM_J0,
433   GFC_ISYM_J1,
434   GFC_ISYM_JN,
435   GFC_ISYM_JN2,
436   GFC_ISYM_KILL,
437   GFC_ISYM_KIND,
438   GFC_ISYM_LBOUND,
439   GFC_ISYM_LCOBOUND,
440   GFC_ISYM_LEADZ,
441   GFC_ISYM_LEN,
442   GFC_ISYM_LEN_TRIM,
443   GFC_ISYM_LGAMMA,
444   GFC_ISYM_LGE,
445   GFC_ISYM_LGT,
446   GFC_ISYM_LINK,
447   GFC_ISYM_LLE,
448   GFC_ISYM_LLT,
449   GFC_ISYM_LOC,
450   GFC_ISYM_LOG,
451   GFC_ISYM_LOG10,
452   GFC_ISYM_LOGICAL,
453   GFC_ISYM_LONG,
454   GFC_ISYM_LSHIFT,
455   GFC_ISYM_LSTAT,
456   GFC_ISYM_LTIME,
457   GFC_ISYM_MALLOC,
458   GFC_ISYM_MASKL,
459   GFC_ISYM_MASKR,
460   GFC_ISYM_MATMUL,
461   GFC_ISYM_MAX,
462   GFC_ISYM_MAXEXPONENT,
463   GFC_ISYM_MAXLOC,
464   GFC_ISYM_MAXVAL,
465   GFC_ISYM_MCLOCK,
466   GFC_ISYM_MCLOCK8,
467   GFC_ISYM_MERGE,
468   GFC_ISYM_MERGE_BITS,
469   GFC_ISYM_MIN,
470   GFC_ISYM_MINEXPONENT,
471   GFC_ISYM_MINLOC,
472   GFC_ISYM_MINVAL,
473   GFC_ISYM_MOD,
474   GFC_ISYM_MODULO,
475   GFC_ISYM_MOVE_ALLOC,
476   GFC_ISYM_MVBITS,
477   GFC_ISYM_NEAREST,
478   GFC_ISYM_NEW_LINE,
479   GFC_ISYM_NINT,
480   GFC_ISYM_NORM2,
481   GFC_ISYM_NOT,
482   GFC_ISYM_NULL,
483   GFC_ISYM_NUMIMAGES,
484   GFC_ISYM_OR,
485   GFC_ISYM_PACK,
486   GFC_ISYM_PARITY,
487   GFC_ISYM_PERROR,
488   GFC_ISYM_POPCNT,
489   GFC_ISYM_POPPAR,
490   GFC_ISYM_PRECISION,
491   GFC_ISYM_PRESENT,
492   GFC_ISYM_PRODUCT,
493   GFC_ISYM_RADIX,
494   GFC_ISYM_RAND,
495   GFC_ISYM_RANDOM_NUMBER,
496   GFC_ISYM_RANDOM_SEED,
497   GFC_ISYM_RANGE,
498   GFC_ISYM_REAL,
499   GFC_ISYM_RENAME,
500   GFC_ISYM_REPEAT,
501   GFC_ISYM_RESHAPE,
502   GFC_ISYM_RRSPACING,
503   GFC_ISYM_RSHIFT,
504   GFC_ISYM_SAME_TYPE_AS,
505   GFC_ISYM_SC_KIND,
506   GFC_ISYM_SCALE,
507   GFC_ISYM_SCAN,
508   GFC_ISYM_SECNDS,
509   GFC_ISYM_SECOND,
510   GFC_ISYM_SET_EXPONENT,
511   GFC_ISYM_SHAPE,
512   GFC_ISYM_SHIFTA,
513   GFC_ISYM_SHIFTL,
514   GFC_ISYM_SHIFTR,
515   GFC_ISYM_SIGN,
516   GFC_ISYM_SIGNAL,
517   GFC_ISYM_SI_KIND,
518   GFC_ISYM_SIN,
519   GFC_ISYM_SINH,
520   GFC_ISYM_SIZE,
521   GFC_ISYM_SLEEP,
522   GFC_ISYM_SIZEOF,
523   GFC_ISYM_SPACING,
524   GFC_ISYM_SPREAD,
525   GFC_ISYM_SQRT,
526   GFC_ISYM_SRAND,
527   GFC_ISYM_SR_KIND,
528   GFC_ISYM_STAT,
529   GFC_ISYM_STORAGE_SIZE,
530   GFC_ISYM_SUM,
531   GFC_ISYM_SYMLINK,
532   GFC_ISYM_SYMLNK,
533   GFC_ISYM_SYSTEM,
534   GFC_ISYM_SYSTEM_CLOCK,
535   GFC_ISYM_TAN,
536   GFC_ISYM_TANH,
537   GFC_ISYM_THIS_IMAGE,
538   GFC_ISYM_TIME,
539   GFC_ISYM_TIME8,
540   GFC_ISYM_TINY,
541   GFC_ISYM_TRAILZ,
542   GFC_ISYM_TRANSFER,
543   GFC_ISYM_TRANSPOSE,
544   GFC_ISYM_TRIM,
545   GFC_ISYM_TTYNAM,
546   GFC_ISYM_UBOUND,
547   GFC_ISYM_UCOBOUND,
548   GFC_ISYM_UMASK,
549   GFC_ISYM_UNLINK,
550   GFC_ISYM_UNPACK,
551   GFC_ISYM_VERIFY,
552   GFC_ISYM_XOR,
553   GFC_ISYM_Y0,
554   GFC_ISYM_Y1,
555   GFC_ISYM_YN,
556   GFC_ISYM_YN2
557 };
558 typedef enum gfc_isym_id gfc_isym_id;
559
560
561 typedef enum
562 {
563   GFC_INIT_REAL_OFF = 0,
564   GFC_INIT_REAL_ZERO,
565   GFC_INIT_REAL_NAN,
566   GFC_INIT_REAL_SNAN,
567   GFC_INIT_REAL_INF,
568   GFC_INIT_REAL_NEG_INF
569 }
570 init_local_real;
571
572 typedef enum
573 {
574   GFC_INIT_LOGICAL_OFF = 0,
575   GFC_INIT_LOGICAL_FALSE,
576   GFC_INIT_LOGICAL_TRUE
577 }
578 init_local_logical;
579
580 typedef enum
581 {
582   GFC_INIT_CHARACTER_OFF = 0,
583   GFC_INIT_CHARACTER_ON
584 }
585 init_local_character;
586
587 typedef enum
588 {
589   GFC_INIT_INTEGER_OFF = 0,
590   GFC_INIT_INTEGER_ON
591 }
592 init_local_integer;
593
594 typedef enum
595 {
596   GFC_FCOARRAY_NONE = 0,
597   GFC_FCOARRAY_SINGLE
598 }
599 gfc_fcoarray;
600
601 typedef enum
602 {
603   GFC_REVERSE_NOT_SET,
604   GFC_REVERSE_SET,
605   GFC_CAN_REVERSE,
606   GFC_CANNOT_REVERSE
607 }
608 gfc_reverse;
609
610 /************************* Structures *****************************/
611
612 /* Used for keeping things in balanced binary trees.  */
613 #define BBT_HEADER(self) int priority; struct self *left, *right
614
615 #define NAMED_INTCST(a,b,c,d) a,
616 typedef enum
617 {
618   ISOFORTRANENV_INVALID = -1,
619 #include "iso-fortran-env.def"
620   ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST
621 }
622 iso_fortran_env_symbol;
623 #undef NAMED_INTCST
624
625 #define NAMED_INTCST(a,b,c,d) a,
626 #define NAMED_REALCST(a,b,c) a,
627 #define NAMED_CMPXCST(a,b,c) a,
628 #define NAMED_LOGCST(a,b,c) a,
629 #define NAMED_CHARKNDCST(a,b,c) a,
630 #define NAMED_CHARCST(a,b,c) a,
631 #define DERIVED_TYPE(a,b,c) a,
632 #define PROCEDURE(a,b) a,
633 typedef enum
634 {
635   ISOCBINDING_INVALID = -1, 
636 #include "iso-c-binding.def"
637   ISOCBINDING_LAST,
638   ISOCBINDING_NUMBER = ISOCBINDING_LAST
639 }
640 iso_c_binding_symbol;
641 #undef NAMED_INTCST
642 #undef NAMED_REALCST
643 #undef NAMED_CMPXCST
644 #undef NAMED_LOGCST
645 #undef NAMED_CHARKNDCST
646 #undef NAMED_CHARCST
647 #undef DERIVED_TYPE
648 #undef PROCEDURE
649
650 typedef enum
651 {
652   INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING
653 }
654 intmod_id;
655
656 typedef struct
657 {
658   char name[GFC_MAX_SYMBOL_LEN + 1];
659   int value;  /* Used for both integer and character values.  */
660   bt f90_type;
661 }
662 CInteropKind_t;
663
664 /* Array of structs, where the structs represent the C interop kinds.
665    The list will be implemented based on a hash of the kind name since
666    these could be accessed multiple times.
667    Declared in trans-types.c as a global, since it's in that file
668    that the list is initialized.  */
669 extern CInteropKind_t c_interop_kinds_table[];
670
671
672 /* Structure and list of supported extension attributes.  */
673 typedef enum
674 {
675   EXT_ATTR_DLLIMPORT = 0,
676   EXT_ATTR_DLLEXPORT,
677   EXT_ATTR_STDCALL,
678   EXT_ATTR_CDECL,
679   EXT_ATTR_FASTCALL,
680   EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST
681 }
682 ext_attr_id_t;
683
684 typedef struct
685 {
686   const char *name;
687   unsigned id;
688   const char *middle_end_name;
689 }
690 ext_attr_t;
691
692 extern const ext_attr_t ext_attr_list[];
693
694 /* Symbol attribute structure.  */
695 typedef struct
696 {
697   /* Variable attributes.  */
698   unsigned allocatable:1, dimension:1, codimension:1, external:1, intrinsic:1,
699     optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,
700     dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,
701     implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1,
702     contiguous:1;
703
704   /* For CLASS containers, the pointer attribute is sometimes set internally
705      even though it was not directly specified.  In this case, keep the
706      "real" (original) value here.  */
707   unsigned class_pointer:1;
708
709   ENUM_BITFIELD (save_state) save:2;
710
711   unsigned data:1,              /* Symbol is named in a DATA statement.  */
712     is_protected:1,             /* Symbol has been marked as protected.  */
713     use_assoc:1,                /* Symbol has been use-associated.  */
714     use_only:1,                 /* Symbol has been use-associated, with ONLY.  */
715     use_rename:1,               /* Symbol has been use-associated and renamed.  */
716     imported:1,                 /* Symbol has been associated by IMPORT.  */
717     host_assoc:1;               /* Symbol has been host associated.  */ 
718
719   unsigned in_namelist:1, in_common:1, in_equivalence:1;
720   unsigned function:1, subroutine:1, procedure:1;
721   unsigned generic:1, generic_copy:1;
722   unsigned implicit_type:1;     /* Type defined via implicit rules.  */
723   unsigned untyped:1;           /* No implicit type could be found.  */
724
725   unsigned is_bind_c:1;         /* say if is bound to C.  */
726   unsigned extension:8;         /* extension level of a derived type.  */
727   unsigned is_class:1;          /* is a CLASS container.  */
728   unsigned class_ok:1;          /* is a CLASS object with correct attributes.  */
729   unsigned vtab:1;              /* is a derived type vtab, pointed to by CLASS objects.  */
730   unsigned vtype:1;             /* is a derived type of a vtab.  */
731
732   /* These flags are both in the typespec and attribute.  The attribute
733      list is what gets read from/written to a module file.  The typespec
734      is created from a decl being processed.  */
735   unsigned is_c_interop:1;      /* It's c interoperable.  */
736   unsigned is_iso_c:1;          /* Symbol is from iso_c_binding.  */
737
738   /* Function/subroutine attributes */
739   unsigned sequence:1, elemental:1, pure:1, recursive:1;
740   unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;
741
742   /* This is set if the subroutine doesn't return.  Currently, this
743      is only possible for intrinsic subroutines.  */
744   unsigned noreturn:1;
745
746   /* Set if this procedure is an alternate entry point.  These procedures
747      don't have any code associated, and the backend will turn them into
748      thunks to the master function.  */
749   unsigned entry:1;
750
751   /* Set if this is the master function for a procedure with multiple
752      entry points.  */
753   unsigned entry_master:1;
754
755   /* Set if this is the master function for a function with multiple
756      entry points where characteristics of the entry points differ.  */
757   unsigned mixed_entry_master:1;
758
759   /* Set if a function must always be referenced by an explicit interface.  */
760   unsigned always_explicit:1;
761
762   /* Set if the symbol has been referenced in an expression.  No further
763      modification of type or type parameters is permitted.  */
764   unsigned referenced:1;
765
766   /* Set if this is the symbol for the main program.  */
767   unsigned is_main_program:1;
768
769   /* Mutually exclusive multibit attributes.  */
770   ENUM_BITFIELD (gfc_access) access:2;
771   ENUM_BITFIELD (sym_intent) intent:2;
772   ENUM_BITFIELD (sym_flavor) flavor:4;
773   ENUM_BITFIELD (ifsrc) if_source:2;
774
775   ENUM_BITFIELD (procedure_type) proc:3;
776
777   /* Special attributes for Cray pointers, pointees.  */
778   unsigned cray_pointer:1, cray_pointee:1;
779
780   /* The symbol is a derived type with allocatable components, pointer 
781      components or private components, procedure pointer components,
782      possibly nested.  zero_comp is true if the derived type has no
783      component at all.  */
784   unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,
785            private_comp:1, zero_comp:1, coarray_comp:1;
786
787   /* This is a temporary selector for SELECT TYPE.  */
788   unsigned select_type_temporary:1;
789
790   /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES).  */
791   unsigned ext_attr:EXT_ATTR_NUM;
792
793   /* The namespace where the attribute has been set.  */
794   struct gfc_namespace *volatile_ns, *asynchronous_ns;
795 }
796 symbol_attribute;
797
798
799 /* We need to store source lines as sequences of multibyte source
800    characters. We define here a type wide enough to hold any multibyte
801    source character, just like libcpp does.  A 32-bit type is enough.  */
802
803 #if HOST_BITS_PER_INT >= 32
804 typedef unsigned int gfc_char_t;
805 #elif HOST_BITS_PER_LONG >= 32
806 typedef unsigned long gfc_char_t;
807 #elif defined(HAVE_LONG_LONG) && (HOST_BITS_PER_LONGLONG >= 32)
808 typedef unsigned long long gfc_char_t;
809 #else
810 # error "Cannot find an integer type with at least 32 bits"
811 #endif
812
813
814 /* The following three structures are used to identify a location in
815    the sources.
816
817    gfc_file is used to maintain a tree of the source files and how
818    they include each other
819
820    gfc_linebuf holds a single line of source code and information
821    which file it resides in
822
823    locus point to the sourceline and the character in the source
824    line.
825 */
826
827 typedef struct gfc_file
828 {
829   struct gfc_file *next, *up;
830   int inclusion_line, line;
831   char *filename;
832 } gfc_file;
833
834 typedef struct gfc_linebuf
835 {
836   source_location location;
837   struct gfc_file *file;
838   struct gfc_linebuf *next;
839
840   int truncated;
841   bool dbg_emitted;
842
843   gfc_char_t line[1];
844 } gfc_linebuf;
845
846 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
847
848 #define gfc_linebuf_linenum(LBUF) (LOCATION_LINE ((LBUF)->location))
849
850 typedef struct
851 {
852   gfc_char_t *nextc;
853   gfc_linebuf *lb;
854 } locus;
855
856 /* In order for the "gfc" format checking to work correctly, you must
857    have declared a typedef locus first.  */
858 #if GCC_VERSION >= 4001
859 #define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)
860 #else
861 #define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)
862 #endif
863
864
865 /* Suppress error messages or re-enable them.  */
866
867 void gfc_push_suppress_errors (void);
868 void gfc_pop_suppress_errors (void);
869
870
871 /* Character length structures hold the expression that gives the
872    length of a character variable.  We avoid putting these into
873    gfc_typespec because doing so prevents us from doing structure
874    copies and forces us to deallocate any typespecs we create, as well
875    as structures that contain typespecs.  They also can have multiple
876    character typespecs pointing to them.
877
878    These structures form a singly linked list within the current
879    namespace and are deallocated with the namespace.  It is possible to
880    end up with gfc_charlen structures that have nothing pointing to them.  */
881
882 typedef struct gfc_charlen
883 {
884   struct gfc_expr *length;
885   struct gfc_charlen *next;
886   bool length_from_typespec; /* Length from explicit array ctor typespec?  */
887   tree backend_decl;
888   tree passed_length; /* Length argument explicitelly passed.  */
889
890   int resolved;
891 }
892 gfc_charlen;
893
894 #define gfc_get_charlen() XCNEW (gfc_charlen)
895
896 /* Type specification structure.  */
897 typedef struct
898 {
899   bt type;
900   int kind;
901
902   union
903   {
904     struct gfc_symbol *derived; /* For derived types only.  */
905     gfc_charlen *cl;            /* For character types only.  */
906     int pad;                    /* For hollerith types only.  */
907   }
908   u;
909
910   struct gfc_symbol *interface; /* For PROCEDURE declarations.  */
911   int is_c_interop;
912   int is_iso_c;
913   bt f90_type; 
914 }
915 gfc_typespec;
916
917 /* Array specification.  */
918 typedef struct
919 {
920   int rank;     /* A rank of zero means that a variable is a scalar.  */
921   int corank;
922   array_type type, cotype;
923   struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
924
925   /* These two fields are used with the Cray Pointer extension.  */
926   bool cray_pointee; /* True iff this spec belongs to a cray pointee.  */
927   bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to
928                         AS_EXPLICIT, but we want to remember that we
929                         did this.  */
930
931 }
932 gfc_array_spec;
933
934 #define gfc_get_array_spec() XCNEW (gfc_array_spec)
935
936
937 /* Components of derived types.  */
938 typedef struct gfc_component
939 {
940   const char *name;
941   gfc_typespec ts;
942
943   symbol_attribute attr;
944   gfc_array_spec *as;
945
946   tree backend_decl;
947   locus loc;
948   struct gfc_expr *initializer;
949   struct gfc_component *next;
950
951   /* Needed for procedure pointer components.  */
952   struct gfc_formal_arglist *formal;
953   struct gfc_namespace *formal_ns;
954   struct gfc_typebound_proc *tb;
955 }
956 gfc_component;
957
958 #define gfc_get_component() XCNEW (gfc_component)
959
960 /* Formal argument lists are lists of symbols.  */
961 typedef struct gfc_formal_arglist
962 {
963   /* Symbol representing the argument at this position in the arglist.  */
964   struct gfc_symbol *sym;
965   /* Points to the next formal argument.  */
966   struct gfc_formal_arglist *next;
967 }
968 gfc_formal_arglist;
969
970 #define gfc_get_formal_arglist() XCNEW (gfc_formal_arglist)
971
972
973 /* The gfc_actual_arglist structure is for actual arguments.  */
974 typedef struct gfc_actual_arglist
975 {
976   const char *name;
977   /* Alternate return label when the expr member is null.  */
978   struct gfc_st_label *label;
979
980   /* This is set to the type of an eventual omitted optional
981      argument. This is used to determine if a hidden string length
982      argument has to be added to a function call.  */
983   bt missing_arg_type;
984
985   struct gfc_expr *expr;
986   struct gfc_actual_arglist *next;
987 }
988 gfc_actual_arglist;
989
990 #define gfc_get_actual_arglist() XCNEW (gfc_actual_arglist)
991
992
993 /* Because a symbol can belong to multiple namelists, they must be
994    linked externally to the symbol itself.  */
995 typedef struct gfc_namelist
996 {
997   struct gfc_symbol *sym;
998   struct gfc_namelist *next;
999 }
1000 gfc_namelist;
1001
1002 #define gfc_get_namelist() XCNEW (gfc_namelist)
1003
1004 enum
1005 {
1006   OMP_LIST_PRIVATE,
1007   OMP_LIST_FIRSTPRIVATE,
1008   OMP_LIST_LASTPRIVATE,
1009   OMP_LIST_COPYPRIVATE,
1010   OMP_LIST_SHARED,
1011   OMP_LIST_COPYIN,
1012   OMP_LIST_PLUS,
1013   OMP_LIST_REDUCTION_FIRST = OMP_LIST_PLUS,
1014   OMP_LIST_MULT,
1015   OMP_LIST_SUB,
1016   OMP_LIST_AND,
1017   OMP_LIST_OR,
1018   OMP_LIST_EQV,
1019   OMP_LIST_NEQV,
1020   OMP_LIST_MAX,
1021   OMP_LIST_MIN,
1022   OMP_LIST_IAND,
1023   OMP_LIST_IOR,
1024   OMP_LIST_IEOR,
1025   OMP_LIST_REDUCTION_LAST = OMP_LIST_IEOR,
1026   OMP_LIST_NUM
1027 };
1028
1029 /* Because a symbol can belong to multiple namelists, they must be
1030    linked externally to the symbol itself.  */
1031
1032 enum gfc_omp_sched_kind
1033 {
1034   OMP_SCHED_NONE,
1035   OMP_SCHED_STATIC,
1036   OMP_SCHED_DYNAMIC,
1037   OMP_SCHED_GUIDED,
1038   OMP_SCHED_RUNTIME,
1039   OMP_SCHED_AUTO
1040 };
1041
1042 enum gfc_omp_default_sharing
1043 {
1044   OMP_DEFAULT_UNKNOWN,
1045   OMP_DEFAULT_NONE,
1046   OMP_DEFAULT_PRIVATE,
1047   OMP_DEFAULT_SHARED,
1048   OMP_DEFAULT_FIRSTPRIVATE
1049 };
1050
1051 typedef struct gfc_omp_clauses
1052 {
1053   struct gfc_expr *if_expr;
1054   struct gfc_expr *num_threads;
1055   gfc_namelist *lists[OMP_LIST_NUM];
1056   enum gfc_omp_sched_kind sched_kind;
1057   struct gfc_expr *chunk_size;
1058   enum gfc_omp_default_sharing default_sharing;
1059   int collapse;
1060   bool nowait, ordered, untied;
1061 }
1062 gfc_omp_clauses;
1063
1064 #define gfc_get_omp_clauses() XCNEW (gfc_omp_clauses)
1065
1066
1067 /* The gfc_st_label structure is a BBT attached to a namespace that
1068    records the usage of statement labels within that space.  */
1069
1070 typedef struct gfc_st_label
1071 {
1072   BBT_HEADER(gfc_st_label);
1073
1074   int value;
1075
1076   gfc_sl_type defined, referenced;
1077
1078   struct gfc_expr *format;
1079
1080   tree backend_decl;
1081
1082   locus where;
1083 }
1084 gfc_st_label;
1085
1086
1087 /* gfc_interface()-- Interfaces are lists of symbols strung together.  */
1088 typedef struct gfc_interface
1089 {
1090   struct gfc_symbol *sym;
1091   locus where;
1092   struct gfc_interface *next;
1093 }
1094 gfc_interface;
1095
1096 #define gfc_get_interface() XCNEW (gfc_interface)
1097
1098 /* User operator nodes.  These are like stripped down symbols.  */
1099 typedef struct
1100 {
1101   const char *name;
1102
1103   gfc_interface *op;
1104   struct gfc_namespace *ns;
1105   gfc_access access;
1106 }
1107 gfc_user_op;
1108
1109
1110 /* A list of specific bindings that are associated with a generic spec.  */
1111 typedef struct gfc_tbp_generic
1112 {
1113   /* The parser sets specific_st, upon resolution we look for the corresponding
1114      gfc_typebound_proc and set specific for further use.  */
1115   struct gfc_symtree* specific_st;
1116   struct gfc_typebound_proc* specific;
1117
1118   struct gfc_tbp_generic* next;
1119 }
1120 gfc_tbp_generic;
1121
1122 #define gfc_get_tbp_generic() XCNEW (gfc_tbp_generic)
1123
1124
1125 /* Data needed for type-bound procedures.  */
1126 typedef struct gfc_typebound_proc
1127 {
1128   locus where; /* Where the PROCEDURE/GENERIC definition was.  */
1129
1130   union
1131   {
1132     struct gfc_symtree* specific; /* The interface if DEFERRED.  */
1133     gfc_tbp_generic* generic;
1134   }
1135   u;
1136
1137   gfc_access access;
1138   const char* pass_arg; /* Argument-name for PASS.  NULL if not specified.  */
1139
1140   /* The overridden type-bound proc (or GENERIC with this name in the
1141      parent-type) or NULL if non.  */
1142   struct gfc_typebound_proc* overridden;
1143
1144   /* Once resolved, we use the position of pass_arg in the formal arglist of
1145      the binding-target procedure to identify it.  The first argument has
1146      number 1 here, the second 2, and so on.  */
1147   unsigned pass_arg_num;
1148
1149   unsigned nopass:1; /* Whether we have NOPASS (PASS otherwise).  */
1150   unsigned non_overridable:1;
1151   unsigned deferred:1;
1152   unsigned is_generic:1;
1153   unsigned function:1, subroutine:1;
1154   unsigned error:1; /* Ignore it, when an error occurred during resolution.  */
1155   unsigned ppc:1;
1156 }
1157 gfc_typebound_proc;
1158
1159
1160 /* Symbol nodes.  These are important things.  They are what the
1161    standard refers to as "entities".  The possibly multiple names that
1162    refer to the same entity are accomplished by a binary tree of
1163    symtree structures that is balanced by the red-black method-- more
1164    than one symtree node can point to any given symbol.  */
1165
1166 typedef struct gfc_symbol
1167 {
1168   const char *name;     /* Primary name, before renaming */
1169   const char *module;   /* Module this symbol came from */
1170   locus declared_at;
1171
1172   gfc_typespec ts;
1173   symbol_attribute attr;
1174
1175   /* The formal member points to the formal argument list if the
1176      symbol is a function or subroutine name.  If the symbol is a
1177      generic name, the generic member points to the list of
1178      interfaces.  */
1179
1180   gfc_interface *generic;
1181   gfc_access component_access;
1182
1183   gfc_formal_arglist *formal;
1184   struct gfc_namespace *formal_ns;
1185   struct gfc_namespace *f2k_derived;
1186
1187   struct gfc_expr *value;       /* Parameter/Initializer value */
1188   gfc_array_spec *as;
1189   struct gfc_symbol *result;    /* function result symbol */
1190   gfc_component *components;    /* Derived type components */
1191
1192   /* Defined only for Cray pointees; points to their pointer.  */
1193   struct gfc_symbol *cp_pointer;
1194
1195   int entry_id;                 /* Used in resolve.c for entries.  */
1196
1197   /* CLASS hashed name for declared and dynamic types in the class.  */
1198   int hash_value;
1199
1200   struct gfc_symbol *common_next;       /* Links for COMMON syms */
1201
1202   /* This is in fact a gfc_common_head but it is only used for pointer
1203      comparisons to check if symbols are in the same common block.  */
1204   struct gfc_common_head* common_head;
1205
1206   /* Make sure setup code for dummy arguments is generated in the correct
1207      order.  */
1208   int dummy_order;
1209
1210   gfc_namelist *namelist, *namelist_tail;
1211
1212   /* Change management fields.  Symbols that might be modified by the
1213      current statement have the mark member nonzero and are kept in a
1214      singly linked list through the tlink field.  Of these symbols,
1215      symbols with old_symbol equal to NULL are symbols created within
1216      the current statement.  Otherwise, old_symbol points to a copy of
1217      the old symbol.  */
1218
1219   struct gfc_symbol *old_symbol, *tlink;
1220   unsigned mark:1, gfc_new:1;
1221   /* Nonzero if all equivalences associated with this symbol have been
1222      processed.  */
1223   unsigned equiv_built:1;
1224   /* Set if this variable is used as an index name in a FORALL.  */
1225   unsigned forall_index:1;
1226   int refs;
1227   struct gfc_namespace *ns;     /* namespace containing this symbol */
1228
1229   tree backend_decl;
1230    
1231   /* Identity of the intrinsic module the symbol comes from, or
1232      INTMOD_NONE if it's not imported from a intrinsic module.  */
1233   intmod_id from_intmod;
1234   /* Identity of the symbol from intrinsic modules, from enums maintained
1235      separately by each intrinsic module.  Used together with from_intmod,
1236      it uniquely identifies a symbol from an intrinsic module.  */
1237   int intmod_sym_id;
1238
1239   /* This may be repetitive, since the typespec now has a binding
1240      label field.  */
1241   char binding_label[GFC_MAX_BINDING_LABEL_LEN + 1];
1242   /* Store a reference to the common_block, if this symbol is in one.  */
1243   struct gfc_common_head *common_block;
1244
1245   /* Link to corresponding association-list if this is an associate name.  */
1246   struct gfc_association_list *assoc;
1247 }
1248 gfc_symbol;
1249
1250
1251 /* This structure is used to keep track of symbols in common blocks.  */
1252 typedef struct gfc_common_head
1253 {
1254   locus where;
1255   char use_assoc, saved, threadprivate;
1256   char name[GFC_MAX_SYMBOL_LEN + 1];
1257   struct gfc_symbol *head;
1258   char binding_label[GFC_MAX_BINDING_LABEL_LEN + 1];
1259   int is_bind_c;
1260 }
1261 gfc_common_head;
1262
1263 #define gfc_get_common_head() XCNEW (gfc_common_head)
1264
1265
1266 /* A list of all the alternate entry points for a procedure.  */
1267
1268 typedef struct gfc_entry_list
1269 {
1270   /* The symbol for this entry point.  */
1271   gfc_symbol *sym;
1272   /* The zero-based id of this entry point.  */
1273   int id;
1274   /* The LABEL_EXPR marking this entry point.  */
1275   tree label;
1276   /* The next item in the list.  */
1277   struct gfc_entry_list *next;
1278 }
1279 gfc_entry_list;
1280
1281 #define gfc_get_entry_list() \
1282   (gfc_entry_list *) gfc_getmem(sizeof(gfc_entry_list))
1283
1284 /* Lists of rename info for the USE statement.  */
1285
1286 typedef struct gfc_use_rename
1287 {
1288   char local_name[GFC_MAX_SYMBOL_LEN + 1], use_name[GFC_MAX_SYMBOL_LEN + 1];
1289   struct gfc_use_rename *next;
1290   int found;
1291   gfc_intrinsic_op op;
1292   locus where;
1293 }
1294 gfc_use_rename;
1295
1296 #define gfc_get_use_rename() XCNEW (gfc_use_rename);
1297
1298 /* A list of all USE statements in a namespace.  */
1299
1300 typedef struct gfc_use_list
1301 {
1302   const char *module_name;
1303   int only_flag;
1304   struct gfc_use_rename *rename;
1305   locus where;
1306   /* Next USE statement.  */
1307   struct gfc_use_list *next;
1308 }
1309 gfc_use_list;
1310
1311 #define gfc_get_use_list() \
1312   (gfc_use_list *) gfc_getmem(sizeof(gfc_use_list))
1313
1314 /* Within a namespace, symbols are pointed to by symtree nodes that
1315    are linked together in a balanced binary tree.  There can be
1316    several symtrees pointing to the same symbol node via USE
1317    statements.  */
1318
1319 typedef struct gfc_symtree
1320 {
1321   BBT_HEADER (gfc_symtree);
1322   const char *name;
1323   int ambiguous;
1324   union
1325   {
1326     gfc_symbol *sym;            /* Symbol associated with this node */
1327     gfc_user_op *uop;
1328     gfc_common_head *common;
1329     gfc_typebound_proc *tb;
1330   }
1331   n;
1332 }
1333 gfc_symtree;
1334
1335 /* A linked list of derived types in the namespace.  */
1336 typedef struct gfc_dt_list
1337 {
1338   struct gfc_symbol *derived;
1339   struct gfc_dt_list *next;
1340 }
1341 gfc_dt_list;
1342
1343 #define gfc_get_dt_list() XCNEW (gfc_dt_list)
1344
1345   /* A list of all derived types.  */
1346   extern gfc_dt_list *gfc_derived_types;
1347
1348 /* A namespace describes the contents of procedure, module, interface block
1349    or BLOCK construct.  */
1350 /* ??? Anything else use these?  */
1351
1352 typedef struct gfc_namespace
1353 {
1354   /* Tree containing all the symbols in this namespace.  */
1355   gfc_symtree *sym_root;
1356   /* Tree containing all the user-defined operators in the namespace.  */
1357   gfc_symtree *uop_root;
1358   /* Tree containing all the common blocks.  */
1359   gfc_symtree *common_root;
1360
1361   /* Tree containing type-bound procedures.  */
1362   gfc_symtree *tb_sym_root;
1363   /* Type-bound user operators.  */
1364   gfc_symtree *tb_uop_root;
1365   /* For derived-types, store type-bound intrinsic operators here.  */
1366   gfc_typebound_proc *tb_op[GFC_INTRINSIC_OPS];
1367   /* Linked list of finalizer procedures.  */
1368   struct gfc_finalizer *finalizers;
1369
1370   /* If set_flag[letter] is set, an implicit type has been set for letter.  */
1371   int set_flag[GFC_LETTERS];
1372   /* Keeps track of the implicit types associated with the letters.  */
1373   gfc_typespec default_type[GFC_LETTERS];
1374   /* Store the positions of IMPLICIT statements.  */
1375   locus implicit_loc[GFC_LETTERS];
1376
1377   /* If this is a namespace of a procedure, this points to the procedure.  */
1378   struct gfc_symbol *proc_name;
1379   /* If this is the namespace of a unit which contains executable
1380      code, this points to it.  */
1381   struct gfc_code *code;
1382
1383   /* Points to the equivalences set up in this namespace.  */
1384   struct gfc_equiv *equiv, *old_equiv;
1385
1386   /* Points to the equivalence groups produced by trans_common.  */
1387   struct gfc_equiv_list *equiv_lists;
1388
1389   gfc_interface *op[GFC_INTRINSIC_OPS];
1390
1391   /* Points to the parent namespace, i.e. the namespace of a module or
1392      procedure in which the procedure belonging to this namespace is
1393      contained. The parent namespace points to this namespace either
1394      directly via CONTAINED, or indirectly via the chain built by
1395      SIBLING.  */
1396   struct gfc_namespace *parent;
1397   /* CONTAINED points to the first contained namespace. Sibling
1398      namespaces are chained via SIBLING.  */
1399   struct gfc_namespace  *contained, *sibling;
1400
1401   gfc_common_head blank_common;
1402   gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
1403
1404   gfc_st_label *st_labels;
1405   /* This list holds information about all the data initializers in
1406      this namespace.  */
1407   struct gfc_data *data;
1408
1409   gfc_charlen *cl_list, *old_cl_list;
1410
1411   gfc_dt_list *derived_types;
1412
1413   int save_all, seen_save, seen_implicit_none;
1414
1415   /* Normally we don't need to refcount namespaces.  However when we read
1416      a module containing a function with multiple entry points, this
1417      will appear as several functions with the same formal namespace.  */
1418   int refs;
1419
1420   /* A list of all alternate entry points to this procedure (or NULL).  */
1421   gfc_entry_list *entries;
1422
1423   /* A list of USE statements in this namespace.  */
1424   gfc_use_list *use_stmts;
1425
1426   /* Set to 1 if namespace is a BLOCK DATA program unit.  */
1427   unsigned is_block_data:1;
1428
1429   /* Set to 1 if namespace is an interface body with "IMPORT" used.  */
1430   unsigned has_import_set:1;
1431
1432   /* Set to 1 if resolved has been called for this namespace.
1433      Holds -1 during resolution.  */
1434   signed resolved:2;
1435
1436   /* Set to 1 if code has been generated for this namespace.  */
1437   unsigned translated:1;
1438
1439   /* Set to 1 if symbols in this namespace should be 'construct entities',
1440      i.e. for BLOCK local variables.  */
1441   unsigned construct_entities:1;
1442 }
1443 gfc_namespace;
1444
1445 extern gfc_namespace *gfc_current_ns;
1446 extern gfc_namespace *gfc_global_ns_list;
1447
1448 /* Global symbols are symbols of global scope. Currently we only use
1449    this to detect collisions already when parsing.
1450    TODO: Extend to verify procedure calls.  */
1451
1452 enum gfc_symbol_type
1453 {
1454   GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
1455   GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA
1456 };
1457
1458 typedef struct gfc_gsymbol
1459 {
1460   BBT_HEADER(gfc_gsymbol);
1461
1462   const char *name;
1463   const char *sym_name;
1464   const char *mod_name;
1465   const char *binding_label;
1466   enum gfc_symbol_type type;
1467
1468   int defined, used;
1469   locus where;
1470   gfc_namespace *ns;
1471 }
1472 gfc_gsymbol;
1473
1474 extern gfc_gsymbol *gfc_gsym_root;
1475
1476 /* Information on interfaces being built.  */
1477 typedef struct
1478 {
1479   interface_type type;
1480   gfc_symbol *sym;
1481   gfc_namespace *ns;
1482   gfc_user_op *uop;
1483   gfc_intrinsic_op op;
1484 }
1485 gfc_interface_info;
1486
1487 extern gfc_interface_info current_interface;
1488
1489
1490 /* Array reference.  */
1491
1492 enum gfc_array_ref_dimen_type
1493 {
1494   DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_STAR, DIMEN_UNKNOWN
1495 };
1496
1497 typedef struct gfc_array_ref
1498 {
1499   ar_type type;
1500   int dimen;                    /* # of components in the reference */
1501   int codimen;
1502   bool in_allocate;             /* For coarray checks. */
1503   locus where;
1504   gfc_array_spec *as;
1505
1506   locus c_where[GFC_MAX_DIMENSIONS];    /* All expressions can be NULL */
1507   struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
1508     *stride[GFC_MAX_DIMENSIONS];
1509
1510   enum gfc_array_ref_dimen_type dimen_type[GFC_MAX_DIMENSIONS];
1511
1512   struct gfc_expr *offset;
1513 }
1514 gfc_array_ref;
1515
1516 #define gfc_get_array_ref() XCNEW (gfc_array_ref)
1517
1518
1519 /* Component reference nodes.  A variable is stored as an expression
1520    node that points to the base symbol.  After that, a singly linked
1521    list of component reference nodes gives the variable's complete
1522    resolution.  The array_ref component may be present and comes
1523    before the component component.  */
1524
1525 typedef enum
1526   { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING }
1527 ref_type;
1528
1529 typedef struct gfc_ref
1530 {
1531   ref_type type;
1532
1533   union
1534   {
1535     struct gfc_array_ref ar;
1536
1537     struct
1538     {
1539       gfc_component *component;
1540       gfc_symbol *sym;
1541     }
1542     c;
1543
1544     struct
1545     {
1546       struct gfc_expr *start, *end;     /* Substring */
1547       gfc_charlen *length;
1548     }
1549     ss;
1550
1551   }
1552   u;
1553
1554   struct gfc_ref *next;
1555 }
1556 gfc_ref;
1557
1558 #define gfc_get_ref() XCNEW (gfc_ref)
1559
1560
1561 /* Structures representing intrinsic symbols and their arguments lists.  */
1562 typedef struct gfc_intrinsic_arg
1563 {
1564   char name[GFC_MAX_SYMBOL_LEN + 1];
1565
1566   gfc_typespec ts;
1567   unsigned optional:1, value:1;
1568   ENUM_BITFIELD (sym_intent) intent:2;
1569   gfc_actual_arglist *actual;
1570
1571   struct gfc_intrinsic_arg *next;
1572
1573 }
1574 gfc_intrinsic_arg;
1575
1576
1577 /* Specifies the various kinds of check functions used to verify the
1578    argument lists of intrinsic functions. fX with X an integer refer
1579    to check functions of intrinsics with X arguments. f1m is used for
1580    the MAX and MIN intrinsics which can have an arbitrary number of
1581    arguments, f3ml is used for the MINLOC and MAXLOC intrinsics as
1582    these have special semantics.  */
1583
1584 typedef union
1585 {
1586   gfc_try (*f0)(void);
1587   gfc_try (*f1)(struct gfc_expr *);
1588   gfc_try (*f1m)(gfc_actual_arglist *);
1589   gfc_try (*f2)(struct gfc_expr *, struct gfc_expr *);
1590   gfc_try (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1591   gfc_try (*f3ml)(gfc_actual_arglist *);
1592   gfc_try (*f3red)(gfc_actual_arglist *);
1593   gfc_try (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1594             struct gfc_expr *);
1595   gfc_try (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1596             struct gfc_expr *, struct gfc_expr *);
1597 }
1598 gfc_check_f;
1599
1600 /* Like gfc_check_f, these specify the type of the simplification
1601    function associated with an intrinsic. The fX are just like in
1602    gfc_check_f. cc is used for type conversion functions.  */
1603
1604 typedef union
1605 {
1606   struct gfc_expr *(*f0)(void);
1607   struct gfc_expr *(*f1)(struct gfc_expr *);
1608   struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
1609   struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
1610                          struct gfc_expr *);
1611   struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
1612                          struct gfc_expr *, struct gfc_expr *);
1613   struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
1614                          struct gfc_expr *, struct gfc_expr *,
1615                          struct gfc_expr *);
1616   struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
1617 }
1618 gfc_simplify_f;
1619
1620 /* Again like gfc_check_f, these specify the type of the resolution
1621    function associated with an intrinsic. The fX are just like in
1622    gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort().  */
1623
1624 typedef union
1625 {
1626   void (*f0)(struct gfc_expr *);
1627   void (*f1)(struct gfc_expr *, struct gfc_expr *);
1628   void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
1629   void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1630   void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1631              struct gfc_expr *);
1632   void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1633              struct gfc_expr *, struct gfc_expr *);
1634   void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1635              struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1636   void (*s1)(struct gfc_code *);
1637 }
1638 gfc_resolve_f;
1639
1640
1641 typedef struct gfc_intrinsic_sym
1642 {
1643   const char *name, *lib_name;
1644   gfc_intrinsic_arg *formal;
1645   gfc_typespec ts;
1646   unsigned elemental:1, inquiry:1, transformational:1, pure:1, 
1647     generic:1, specific:1, actual_ok:1, noreturn:1, conversion:1;
1648
1649   int standard;
1650
1651   gfc_simplify_f simplify;
1652   gfc_check_f check;
1653   gfc_resolve_f resolve;
1654   struct gfc_intrinsic_sym *specific_head, *next;
1655   gfc_isym_id id;
1656
1657 }
1658 gfc_intrinsic_sym;
1659
1660
1661 /* Expression nodes.  The expression node types deserve explanations,
1662    since the last couple can be easily misconstrued:
1663
1664    EXPR_OP         Operator node pointing to one or two other nodes
1665    EXPR_FUNCTION   Function call, symbol points to function's name
1666    EXPR_CONSTANT   A scalar constant: Logical, String, Real, Int or Complex
1667    EXPR_VARIABLE   An Lvalue with a root symbol and possible reference list
1668                    which expresses structure, array and substring refs.
1669    EXPR_NULL       The NULL pointer value (which also has a basic type).
1670    EXPR_SUBSTRING  A substring of a constant string
1671    EXPR_STRUCTURE  A structure constructor
1672    EXPR_ARRAY      An array constructor.
1673    EXPR_COMPCALL   Function (or subroutine) call of a procedure pointer
1674                    component or type-bound procedure.  */
1675
1676 #include <gmp.h>
1677 #include <mpfr.h>
1678 #include <mpc.h>
1679 #define GFC_RND_MODE GMP_RNDN
1680 #define GFC_MPC_RND_MODE MPC_RNDNN
1681
1682 typedef splay_tree gfc_constructor_base;
1683
1684 typedef struct gfc_expr
1685 {
1686   expr_t expr_type;
1687
1688   gfc_typespec ts;      /* These two refer to the overall expression */
1689
1690   int rank;
1691   mpz_t *shape;         /* Can be NULL if shape is unknown at compile time */
1692
1693   /* Nonnull for functions and structure constructors, may also used to hold the
1694      base-object for component calls.  */
1695   gfc_symtree *symtree;
1696
1697   gfc_ref *ref;
1698
1699   locus where;
1700
1701   /* is_boz is true if the integer is regarded as BOZ bitpatten and is_snan
1702      denotes a signalling not-a-number.  */
1703   unsigned int is_boz : 1, is_snan : 1;
1704
1705   /* Sometimes, when an error has been emitted, it is necessary to prevent
1706       it from recurring.  */
1707   unsigned int error : 1;
1708   
1709   /* Mark an expression where a user operator has been substituted by
1710      a function call in interface.c(gfc_extend_expr).  */
1711   unsigned int user_operator : 1;
1712
1713   /* Mark an expression as being a MOLD argument of ALLOCATE.  */
1714   unsigned int mold : 1;
1715   
1716   /* If an expression comes from a Hollerith constant or compile-time
1717      evaluation of a transfer statement, it may have a prescribed target-
1718      memory representation, and these cannot always be backformed from
1719      the value.  */
1720   struct
1721   {
1722     int length;
1723     char *string;
1724   }
1725   representation;
1726
1727   union
1728   {
1729     int logical;
1730
1731     io_kind iokind;
1732
1733     mpz_t integer;
1734
1735     mpfr_t real;
1736
1737     mpc_t complex;
1738
1739     struct
1740     {
1741       gfc_intrinsic_op op;
1742       gfc_user_op *uop;
1743       struct gfc_expr *op1, *op2;
1744     }
1745     op;
1746
1747     struct
1748     {
1749       gfc_actual_arglist *actual;
1750       const char *name; /* Points to the ultimate name of the function */
1751       gfc_intrinsic_sym *isym;
1752       gfc_symbol *esym;
1753     }
1754     function;
1755
1756     struct
1757     {
1758       gfc_actual_arglist* actual;
1759       const char* name;
1760       /* Base-object, whose component was called.  NULL means that it should
1761          be taken from symtree/ref.  */
1762       struct gfc_expr* base_object;
1763       gfc_typebound_proc* tbp; /* Should overlap with esym.  */
1764
1765       /* For type-bound operators, we want to call PASS procedures but already
1766          have the full arglist; mark this, so that it is not extended by the
1767          PASS argument.  */
1768       unsigned ignore_pass:1;
1769
1770       /* Do assign-calls rather than calls, that is appropriate dependency
1771          checking.  */
1772       unsigned assign:1;
1773     }
1774     compcall;
1775
1776     struct
1777     {
1778       int length;
1779       gfc_char_t *string;
1780     }
1781     character;
1782
1783     gfc_constructor_base constructor;
1784   }
1785   value;
1786
1787 }
1788 gfc_expr;
1789
1790
1791 #define gfc_get_shape(rank) ((mpz_t *) gfc_getmem((rank)*sizeof(mpz_t)))
1792
1793 /* Structures for information associated with different kinds of
1794    numbers.  The first set of integer parameters define all there is
1795    to know about a particular kind.  The rest of the elements are
1796    computed from the first elements.  */
1797
1798 typedef struct
1799 {
1800   /* Values really representable by the target.  */
1801   mpz_t huge, pedantic_min_int, min_int;
1802
1803   int kind, radix, digits, bit_size, range;
1804
1805   /* True if the C type of the given name maps to this precision.
1806      Note that more than one bit can be set.  */
1807   unsigned int c_char : 1;
1808   unsigned int c_short : 1;
1809   unsigned int c_int : 1;
1810   unsigned int c_long : 1;
1811   unsigned int c_long_long : 1;
1812 }
1813 gfc_integer_info;
1814
1815 extern gfc_integer_info gfc_integer_kinds[];
1816
1817
1818 typedef struct
1819 {
1820   int kind, bit_size;
1821
1822   /* True if the C++ type bool, C99 type _Bool, maps to this precision.  */
1823   unsigned int c_bool : 1;
1824 }
1825 gfc_logical_info;
1826
1827 extern gfc_logical_info gfc_logical_kinds[];
1828
1829
1830 typedef struct
1831 {
1832   mpfr_t epsilon, huge, tiny, subnormal;
1833   int kind, radix, digits, min_exponent, max_exponent;
1834   int range, precision;
1835
1836   /* The precision of the type as reported by GET_MODE_PRECISION.  */
1837   int mode_precision;
1838
1839   /* True if the C type of the given name maps to this precision.
1840      Note that more than one bit can be set.  */
1841   unsigned int c_float : 1;
1842   unsigned int c_double : 1;
1843   unsigned int c_long_double : 1;
1844   unsigned int c_float128 : 1;
1845 }
1846 gfc_real_info;
1847
1848 extern gfc_real_info gfc_real_kinds[];
1849
1850 typedef struct
1851 {
1852   int kind, bit_size;
1853   const char *name;
1854 }
1855 gfc_character_info;
1856
1857 extern gfc_character_info gfc_character_kinds[];
1858
1859
1860 /* Equivalence structures.  Equivalent lvalues are linked along the
1861    *eq pointer, equivalence sets are strung along the *next node.  */
1862 typedef struct gfc_equiv
1863 {
1864   struct gfc_equiv *next, *eq;
1865   gfc_expr *expr;
1866   const char *module;
1867   int used;
1868 }
1869 gfc_equiv;
1870
1871 #define gfc_get_equiv() XCNEW (gfc_equiv)
1872
1873 /* Holds a single equivalence member after processing.  */
1874 typedef struct gfc_equiv_info
1875 {
1876   gfc_symbol *sym;
1877   HOST_WIDE_INT offset;
1878   HOST_WIDE_INT length;
1879   struct gfc_equiv_info *next;
1880 } gfc_equiv_info;
1881
1882 /* Holds equivalence groups, after they have been processed.  */
1883 typedef struct gfc_equiv_list
1884 {
1885   gfc_equiv_info *equiv;
1886   struct gfc_equiv_list *next;
1887 } gfc_equiv_list;
1888
1889 /* gfc_case stores the selector list of a case statement.  The *low
1890    and *high pointers can point to the same expression in the case of
1891    a single value.  If *high is NULL, the selection is from *low
1892    upwards, if *low is NULL the selection is *high downwards.
1893
1894    This structure has separate fields to allow single and double linked
1895    lists of CASEs at the same time.  The singe linked list along the NEXT
1896    field is a list of cases for a single CASE label.  The double linked
1897    list along the LEFT/RIGHT fields is used to detect overlap and to
1898    build a table of the cases for SELECT constructs with a CHARACTER
1899    case expression.  */
1900
1901 typedef struct gfc_case
1902 {
1903   /* Where we saw this case.  */
1904   locus where;
1905   int n;
1906
1907   /* Case range values.  If (low == high), it's a single value.  If one of
1908      the labels is NULL, it's an unbounded case.  If both are NULL, this
1909      represents the default case.  */
1910   gfc_expr *low, *high;
1911
1912   /* Only used for SELECT TYPE.  */
1913   gfc_typespec ts;
1914
1915   /* Next case label in the list of cases for a single CASE label.  */
1916   struct gfc_case *next;
1917
1918   /* Used for detecting overlap, and for code generation.  */
1919   struct gfc_case *left, *right;
1920
1921   /* True if this case label can never be matched.  */
1922   int unreachable;
1923 }
1924 gfc_case;
1925
1926 #define gfc_get_case() XCNEW (gfc_case)
1927
1928
1929 typedef struct
1930 {
1931   gfc_expr *var, *start, *end, *step;
1932 }
1933 gfc_iterator;
1934
1935 #define gfc_get_iterator() XCNEW (gfc_iterator)
1936
1937
1938 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements.  */
1939
1940 typedef struct gfc_alloc
1941 {
1942   gfc_expr *expr;
1943   struct gfc_alloc *next;
1944 }
1945 gfc_alloc;
1946
1947 #define gfc_get_alloc() XCNEW (gfc_alloc)
1948
1949
1950 typedef struct
1951 {
1952   gfc_expr *unit, *file, *status, *access, *form, *recl,
1953     *blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert,
1954     *decimal, *encoding, *round, *sign, *asynchronous, *id, *newunit;
1955   gfc_st_label *err;
1956 }
1957 gfc_open;
1958
1959
1960 typedef struct
1961 {
1962   gfc_expr *unit, *status, *iostat, *iomsg;
1963   gfc_st_label *err;
1964 }
1965 gfc_close;
1966
1967
1968 typedef struct
1969 {
1970   gfc_expr *unit, *iostat, *iomsg;
1971   gfc_st_label *err;
1972 }
1973 gfc_filepos;
1974
1975
1976 typedef struct
1977 {
1978   gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
1979     *name, *access, *sequential, *direct, *form, *formatted,
1980     *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
1981     *write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert, *strm_pos,
1982     *asynchronous, *decimal, *encoding, *pending, *round, *sign, *size, *id;
1983
1984   gfc_st_label *err;
1985
1986 }
1987 gfc_inquire;
1988
1989
1990 typedef struct
1991 {
1992   gfc_expr *unit, *iostat, *iomsg, *id;
1993   gfc_st_label *err, *end, *eor;
1994 }
1995 gfc_wait;
1996
1997
1998 typedef struct
1999 {
2000   gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg,
2001            *id, *pos, *asynchronous, *blank, *decimal, *delim, *pad, *round,
2002            *sign, *extra_comma;
2003
2004   gfc_symbol *namelist;
2005   /* A format_label of `format_asterisk' indicates the "*" format */
2006   gfc_st_label *format_label;
2007   gfc_st_label *err, *end, *eor;
2008
2009   locus eor_where, end_where, err_where;
2010 }
2011 gfc_dt;
2012
2013
2014 typedef struct gfc_forall_iterator
2015 {
2016   gfc_expr *var, *start, *end, *stride;
2017   struct gfc_forall_iterator *next;
2018 }
2019 gfc_forall_iterator;
2020
2021
2022 /* Linked list to store associations in an ASSOCIATE statement.  */
2023
2024 typedef struct gfc_association_list
2025 {
2026   struct gfc_association_list *next; 
2027
2028   /* Whether this is association to a variable that can be changed; otherwise,
2029      it's association to an expression and the name may not be used as
2030      lvalue.  */
2031   unsigned variable:1;
2032
2033   /* True if this struct is currently only linked to from a gfc_symbol rather
2034      than as part of a real list in gfc_code->ext.block.assoc.  This may
2035      happen for SELECT TYPE temporaries and must be considered
2036      for memory handling.  */
2037   unsigned dangling:1;
2038
2039   char name[GFC_MAX_SYMBOL_LEN + 1];
2040   gfc_symtree *st; /* Symtree corresponding to name.  */
2041   locus where;
2042
2043   gfc_expr *target;
2044 }
2045 gfc_association_list;
2046 #define gfc_get_association_list() XCNEW (gfc_association_list)
2047
2048
2049 /* Executable statements that fill gfc_code structures.  */
2050 typedef enum
2051 {
2052   EXEC_NOP = 1, EXEC_END_BLOCK, EXEC_ASSIGN, EXEC_LABEL_ASSIGN,
2053   EXEC_POINTER_ASSIGN, EXEC_CRITICAL, EXEC_ERROR_STOP,
2054   EXEC_GOTO, EXEC_CALL, EXEC_COMPCALL, EXEC_ASSIGN_CALL, EXEC_RETURN,
2055   EXEC_ENTRY, EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE, EXEC_INIT_ASSIGN,
2056   EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_WHILE, EXEC_SELECT, EXEC_BLOCK,
2057   EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT, EXEC_CALL_PPC,
2058   EXEC_ALLOCATE, EXEC_DEALLOCATE, EXEC_END_PROCEDURE, EXEC_SELECT_TYPE,
2059   EXEC_SYNC_ALL, EXEC_SYNC_MEMORY, EXEC_SYNC_IMAGES,
2060   EXEC_OPEN, EXEC_CLOSE, EXEC_WAIT,
2061   EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
2062   EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
2063   EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
2064   EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
2065   EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
2066   EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
2067   EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
2068   EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT
2069 }
2070 gfc_exec_op;
2071
2072 typedef struct gfc_code
2073 {
2074   gfc_exec_op op;
2075
2076   struct gfc_code *block, *next;
2077   locus loc;
2078
2079   gfc_st_label *here, *label1, *label2, *label3;
2080   gfc_symtree *symtree;
2081   gfc_expr *expr1, *expr2, *expr3;
2082   /* A name isn't sufficient to identify a subroutine, we need the actual
2083      symbol for the interface definition.
2084   const char *sub_name;  */
2085   gfc_symbol *resolved_sym;
2086   gfc_intrinsic_sym *resolved_isym;
2087
2088   union
2089   {
2090     gfc_actual_arglist *actual;
2091     gfc_case *case_list;
2092     gfc_iterator *iterator;
2093
2094     struct
2095     {
2096       gfc_typespec ts;
2097       gfc_alloc *list;
2098     }
2099     alloc;
2100
2101     struct
2102     {
2103       gfc_namespace *ns;
2104       gfc_association_list *assoc;
2105     }
2106     block;
2107
2108     gfc_open *open;
2109     gfc_close *close;
2110     gfc_filepos *filepos;
2111     gfc_inquire *inquire;
2112     gfc_wait *wait;
2113     gfc_dt *dt;
2114     gfc_forall_iterator *forall_iterator;
2115     struct gfc_code *which_construct;
2116     int stop_code;
2117     gfc_entry_list *entry;
2118     gfc_omp_clauses *omp_clauses;
2119     const char *omp_name;
2120     gfc_namelist *omp_namelist;
2121     bool omp_bool;
2122   }
2123   ext;          /* Points to additional structures required by statement */
2124
2125   /* Cycle and break labels in constructs.  */
2126   tree cycle_label;
2127   tree exit_label;
2128 }
2129 gfc_code;
2130
2131
2132 /* Storage for DATA statements.  */
2133 typedef struct gfc_data_variable
2134 {
2135   gfc_expr *expr;
2136   gfc_iterator iter;
2137   struct gfc_data_variable *list, *next;
2138 }
2139 gfc_data_variable;
2140
2141
2142 typedef struct gfc_data_value
2143 {
2144   mpz_t repeat;
2145   gfc_expr *expr;
2146   struct gfc_data_value *next;
2147 }
2148 gfc_data_value;
2149
2150
2151 typedef struct gfc_data
2152 {
2153   gfc_data_variable *var;
2154   gfc_data_value *value;
2155   locus where;
2156
2157   struct gfc_data *next;
2158 }
2159 gfc_data;
2160
2161
2162 /* Structure for holding compile options */
2163 typedef struct
2164 {
2165   char *module_dir;
2166   gfc_source_form source_form;
2167   /* Maximum line lengths in fixed- and free-form source, respectively.
2168      When fixed_line_length or free_line_length are 0, the whole line is used,
2169      regardless of length.
2170
2171      If the user requests a fixed_line_length <7 then gfc_init_options()
2172      emits a fatal error.  */
2173   int fixed_line_length;
2174   int free_line_length;
2175   /* Maximum number of continuation lines in fixed- and free-form source,
2176      respectively.  */
2177   int max_continue_fixed;
2178   int max_continue_free;
2179   int max_identifier_length;
2180   int dump_parse_tree;
2181
2182   int warn_aliasing;
2183   int warn_ampersand;
2184   int warn_conversion;
2185   int warn_conversion_extra;
2186   int warn_implicit_interface;
2187   int warn_implicit_procedure;
2188   int warn_line_truncation;
2189   int warn_surprising;
2190   int warn_tabs;
2191   int warn_underflow;
2192   int warn_intrinsic_shadow;
2193   int warn_intrinsics_std;
2194   int warn_character_truncation;
2195   int warn_array_temp;
2196   int warn_align_commons;
2197   int warn_unused_dummy_argument;
2198   int max_errors;
2199
2200   int flag_all_intrinsics;
2201   int flag_default_double;
2202   int flag_default_integer;
2203   int flag_default_real;
2204   int flag_dollar_ok;
2205   int flag_underscoring;
2206   int flag_second_underscore;
2207   int flag_implicit_none;
2208   int flag_max_stack_var_size;
2209   int flag_max_array_constructor;
2210   int flag_range_check;
2211   int flag_pack_derived;
2212   int flag_repack_arrays;
2213   int flag_preprocessed;
2214   int flag_f2c;
2215   int flag_automatic;
2216   int flag_backslash;
2217   int flag_backtrace;
2218   int flag_allow_leading_underscore;
2219   int flag_dump_core;
2220   int flag_external_blas;
2221   int blas_matmul_limit;
2222   int flag_cray_pointer;
2223   int flag_d_lines;
2224   int flag_openmp;
2225   int flag_sign_zero;
2226   int flag_module_private;
2227   int flag_recursive;
2228   int flag_init_local_zero;
2229   int flag_init_integer;
2230   int flag_init_integer_value;
2231   int flag_init_real;
2232   int flag_init_logical;
2233   int flag_init_character;
2234   char flag_init_character_value;
2235   int flag_align_commons;
2236   int flag_whole_file;
2237   int flag_protect_parens;
2238
2239   int fpe;
2240   int rtcheck;
2241   gfc_fcoarray coarray;
2242
2243   int warn_std;
2244   int allow_std;
2245   int convert;
2246   int record_marker;
2247   int max_subrecord_length;
2248 }
2249 gfc_option_t;
2250
2251 extern gfc_option_t gfc_option;
2252
2253 /* Constructor nodes for array and structure constructors.  */
2254 typedef struct gfc_constructor
2255 {
2256   gfc_constructor_base base;
2257   mpz_t offset;               /* Offset within a constructor, used as
2258                                  key within base. */
2259
2260   gfc_expr *expr;
2261   gfc_iterator *iterator;
2262   locus where;
2263
2264   union
2265   {
2266      gfc_component *component; /* Record the component being initialized.  */
2267   }
2268   n;
2269 }
2270 gfc_constructor;
2271
2272
2273 typedef struct iterator_stack
2274 {
2275   gfc_symtree *variable;
2276   mpz_t value;
2277   struct iterator_stack *prev;
2278 }
2279 iterator_stack;
2280 extern iterator_stack *iter_stack;
2281
2282
2283 /* Used for (possibly nested) SELECT TYPE statements.  */
2284 typedef struct gfc_select_type_stack
2285 {
2286   gfc_symbol *selector;                 /* Current selector variable.  */
2287   gfc_symtree *tmp;                     /* Current temporary variable.  */
2288   struct gfc_select_type_stack *prev;   /* Previous element on stack.  */
2289 }
2290 gfc_select_type_stack;
2291 extern gfc_select_type_stack *select_type_stack;
2292 #define gfc_get_select_type_stack() XCNEW (gfc_select_type_stack)
2293
2294
2295 /* Node in the linked list used for storing finalizer procedures.  */
2296
2297 typedef struct gfc_finalizer
2298 {
2299   struct gfc_finalizer* next;
2300   locus where; /* Where the FINAL declaration occurred.  */
2301
2302   /* Up to resolution, we want the gfc_symbol, there we lookup the corresponding
2303      symtree and later need only that.  This way, we can access and call the
2304      finalizers from every context as they should be "always accessible".  I
2305      don't make this a union because we need the information whether proc_sym is
2306      still referenced or not for dereferencing it on deleting a gfc_finalizer
2307      structure.  */
2308   gfc_symbol*  proc_sym;
2309   gfc_symtree* proc_tree; 
2310 }
2311 gfc_finalizer;
2312 #define gfc_get_finalizer() XCNEW (gfc_finalizer)
2313
2314
2315 /************************ Function prototypes *************************/
2316
2317 /* decl.c */
2318 bool gfc_in_match_data (void);
2319 match gfc_match_char_spec (gfc_typespec *);
2320
2321 /* scanner.c */
2322 void gfc_scanner_done_1 (void);
2323 void gfc_scanner_init_1 (void);
2324
2325 void gfc_add_include_path (const char *, bool, bool);
2326 void gfc_add_intrinsic_modules_path (const char *);
2327 void gfc_release_include_path (void);
2328 FILE *gfc_open_included_file (const char *, bool, bool);
2329 FILE *gfc_open_intrinsic_module (const char *);
2330
2331 int gfc_at_end (void);
2332 int gfc_at_eof (void);
2333 int gfc_at_bol (void);
2334 int gfc_at_eol (void);
2335 void gfc_advance_line (void);
2336 int gfc_check_include (void);
2337 int gfc_define_undef_line (void);
2338
2339 int gfc_wide_is_printable (gfc_char_t);
2340 int gfc_wide_is_digit (gfc_char_t);
2341 int gfc_wide_fits_in_byte (gfc_char_t);
2342 gfc_char_t gfc_wide_tolower (gfc_char_t);
2343 gfc_char_t gfc_wide_toupper (gfc_char_t);
2344 size_t gfc_wide_strlen (const gfc_char_t *);
2345 int gfc_wide_strncasecmp (const gfc_char_t *, const char *, size_t);
2346 gfc_char_t *gfc_wide_memset (gfc_char_t *, gfc_char_t, size_t);
2347 char *gfc_widechar_to_char (const gfc_char_t *, int);
2348 gfc_char_t *gfc_char_to_widechar (const char *);
2349
2350 #define gfc_get_wide_string(n) XCNEWVEC (gfc_char_t, n)
2351
2352 void gfc_skip_comments (void);
2353 gfc_char_t gfc_next_char_literal (int);
2354 gfc_char_t gfc_next_char (void);
2355 char gfc_next_ascii_char (void);
2356 gfc_char_t gfc_peek_char (void);
2357 char gfc_peek_ascii_char (void);
2358 void gfc_error_recovery (void);
2359 void gfc_gobble_whitespace (void);
2360 gfc_try gfc_new_file (void);
2361 const char * gfc_read_orig_filename (const char *, const char **);
2362
2363 extern gfc_source_form gfc_current_form;
2364 extern const char *gfc_source_file;
2365 extern locus gfc_current_locus;
2366
2367 void gfc_start_source_files (void);
2368 void gfc_end_source_files (void);
2369
2370 /* misc.c */
2371 void *gfc_getmem (size_t) ATTRIBUTE_MALLOC;
2372 void gfc_free (void *);
2373 int gfc_terminal_width (void);
2374 void gfc_clear_ts (gfc_typespec *);
2375 FILE *gfc_open_file (const char *);
2376 const char *gfc_basic_typename (bt);
2377 const char *gfc_typename (gfc_typespec *);
2378 const char *gfc_op2string (gfc_intrinsic_op);
2379 const char *gfc_code2string (const mstring *, int);
2380 int gfc_string2code (const mstring *, const char *);
2381 const char *gfc_intent_string (sym_intent);
2382
2383 void gfc_init_1 (void);
2384 void gfc_init_2 (void);
2385 void gfc_done_1 (void);
2386 void gfc_done_2 (void);
2387
2388 int get_c_kind (const char *, CInteropKind_t *);
2389
2390 /* options.c */
2391 unsigned int gfc_option_lang_mask (void);
2392 void gfc_init_options (unsigned int,
2393                        struct cl_decoded_option *);
2394 bool gfc_handle_option (size_t, const char *, int, int,
2395                         const struct cl_option_handlers *);
2396 bool gfc_post_options (const char **);
2397
2398 /* f95-lang.c */
2399 void gfc_maybe_initialize_eh (void);
2400
2401 /* iresolve.c */
2402 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
2403 bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *);
2404
2405 /* error.c */
2406
2407 typedef struct gfc_error_buf
2408 {
2409   int flag;
2410   size_t allocated, index;
2411   char *message;
2412 } gfc_error_buf;
2413
2414 void gfc_error_init_1 (void);
2415 void gfc_buffer_error (int);
2416
2417 const char *gfc_print_wide_char (gfc_char_t);
2418
2419 void gfc_warning (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2420 void gfc_warning_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2421 void gfc_clear_warning (void);
2422 void gfc_warning_check (void);
2423
2424 void gfc_error (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2425 void gfc_error_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2426 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2427 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2428 void gfc_clear_error (void);
2429 int gfc_error_check (void);
2430 int gfc_error_flag_test (void);
2431
2432 notification gfc_notification_std (int);
2433 gfc_try gfc_notify_std (int, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
2434
2435 /* A general purpose syntax error.  */
2436 #define gfc_syntax_error(ST)    \
2437   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
2438
2439 void gfc_push_error (gfc_error_buf *);
2440 void gfc_pop_error (gfc_error_buf *);
2441 void gfc_free_error (gfc_error_buf *);
2442
2443 void gfc_get_errors (int *, int *);
2444 void gfc_errors_to_warnings (int);
2445
2446 /* arith.c */
2447 void gfc_arith_init_1 (void);
2448 void gfc_arith_done_1 (void);
2449 arith gfc_check_integer_range (mpz_t p, int kind);
2450 bool gfc_check_character_range (gfc_char_t, int);
2451
2452 /* trans-types.c */
2453 gfc_try gfc_check_any_c_kind (gfc_typespec *);
2454 int gfc_validate_kind (bt, int, bool);
2455 int gfc_get_int_kind_from_width_isofortranenv (int size);
2456 int gfc_get_real_kind_from_width_isofortranenv (int size);
2457 tree gfc_get_derived_type (gfc_symbol * derived);
2458 extern int gfc_index_integer_kind;
2459 extern int gfc_default_integer_kind;
2460 extern int gfc_max_integer_kind;
2461 extern int gfc_default_real_kind;
2462 extern int gfc_default_double_kind;
2463 extern int gfc_default_character_kind;
2464 extern int gfc_default_logical_kind;
2465 extern int gfc_default_complex_kind;
2466 extern int gfc_c_int_kind;
2467 extern int gfc_intio_kind;
2468 extern int gfc_charlen_int_kind;
2469 extern int gfc_numeric_storage_size;
2470 extern int gfc_character_storage_size;
2471
2472 /* symbol.c */
2473 void gfc_clear_new_implicit (void);
2474 gfc_try gfc_add_new_implicit_range (int, int);
2475 gfc_try gfc_merge_new_implicit (gfc_typespec *);
2476 void gfc_set_implicit_none (void);
2477 void gfc_check_function_type (gfc_namespace *);
2478 bool gfc_is_intrinsic_typename (const char *);
2479
2480 gfc_typespec *gfc_get_default_type (const char *, gfc_namespace *);
2481 gfc_try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
2482
2483 void gfc_set_sym_referenced (gfc_symbol *);
2484
2485 gfc_try gfc_add_attribute (symbol_attribute *, locus *);
2486 gfc_try gfc_add_ext_attribute (symbol_attribute *, ext_attr_id_t, locus *);
2487 gfc_try gfc_add_allocatable (symbol_attribute *, locus *);
2488 gfc_try gfc_add_codimension (symbol_attribute *, const char *, locus *);
2489 gfc_try gfc_add_contiguous (symbol_attribute *, const char *, locus *);
2490 gfc_try gfc_add_dimension (symbol_attribute *, const char *, locus *);
2491 gfc_try gfc_add_external (symbol_attribute *, locus *);
2492 gfc_try gfc_add_intrinsic (symbol_attribute *, locus *);
2493 gfc_try gfc_add_optional (symbol_attribute *, locus *);
2494 gfc_try gfc_add_pointer (symbol_attribute *, locus *);
2495 gfc_try gfc_add_cray_pointer (symbol_attribute *, locus *);
2496 gfc_try gfc_add_cray_pointee (symbol_attribute *, locus *);
2497 match gfc_mod_pointee_as (gfc_array_spec *);
2498 gfc_try gfc_add_protected (symbol_attribute *, const char *, locus *);
2499 gfc_try gfc_add_result (symbol_attribute *, const char *, locus *);
2500 gfc_try gfc_add_save (symbol_attribute *, save_state, const char *, locus *);
2501 gfc_try gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
2502 gfc_try gfc_add_saved_common (symbol_attribute *, locus *);
2503 gfc_try gfc_add_target (symbol_attribute *, locus *);
2504 gfc_try gfc_add_dummy (symbol_attribute *, const char *, locus *);
2505 gfc_try gfc_add_generic (symbol_attribute *, const char *, locus *);
2506 gfc_try gfc_add_common (symbol_attribute *, locus *);
2507 gfc_try gfc_add_in_common (symbol_attribute *, const char *, locus *);
2508 gfc_try gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
2509 gfc_try gfc_add_data (symbol_attribute *, const char *, locus *);
2510 gfc_try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
2511 gfc_try gfc_add_sequence (symbol_attribute *, const char *, locus *);
2512 gfc_try gfc_add_elemental (symbol_attribute *, locus *);
2513 gfc_try gfc_add_pure (symbol_attribute *, locus *);
2514 gfc_try gfc_add_recursive (symbol_attribute *, locus *);
2515 gfc_try gfc_add_function (symbol_attribute *, const char *, locus *);
2516 gfc_try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
2517 gfc_try gfc_add_volatile (symbol_attribute *, const char *, locus *);
2518 gfc_try gfc_add_asynchronous (symbol_attribute *, const char *, locus *);
2519 gfc_try gfc_add_proc (symbol_attribute *attr, const char *name, locus *where);
2520 gfc_try gfc_add_abstract (symbol_attribute* attr, locus* where);
2521
2522 gfc_try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
2523 gfc_try gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int);
2524 gfc_try gfc_add_extension (symbol_attribute *, locus *);
2525 gfc_try gfc_add_value (symbol_attribute *, const char *, locus *);
2526 gfc_try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
2527 gfc_try gfc_add_entry (symbol_attribute *, const char *, locus *);
2528 gfc_try gfc_add_procedure (symbol_attribute *, procedure_type,
2529                        const char *, locus *);
2530 gfc_try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
2531 gfc_try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
2532                                 gfc_formal_arglist *, locus *);
2533 gfc_try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
2534
2535 void gfc_clear_attr (symbol_attribute *);
2536 gfc_try gfc_missing_attr (symbol_attribute *, locus *);
2537 gfc_try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
2538
2539 gfc_try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
2540 gfc_symbol *gfc_use_derived (gfc_symbol *);
2541 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
2542 gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool);
2543
2544 gfc_st_label *gfc_get_st_label (int);
2545 void gfc_free_st_label (gfc_st_label *);
2546 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
2547 gfc_try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
2548
2549 gfc_expr * gfc_lval_expr_from_sym (gfc_symbol *);
2550
2551 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
2552 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
2553 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
2554 void gfc_delete_symtree (gfc_symtree **, const char *);
2555 gfc_symtree *gfc_get_unique_symtree (gfc_namespace *);
2556 gfc_user_op *gfc_get_uop (const char *);
2557 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
2558 void gfc_free_symbol (gfc_symbol *);
2559 void gfc_release_symbol (gfc_symbol *);
2560 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
2561 gfc_symtree* gfc_find_symtree_in_proc (const char *, gfc_namespace *);
2562 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
2563 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
2564 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
2565 gfc_try verify_c_interop (gfc_typespec *);
2566 gfc_try verify_c_interop_param (gfc_symbol *);
2567 gfc_try verify_bind_c_sym (gfc_symbol *, gfc_typespec *, int, gfc_common_head *);
2568 gfc_try verify_bind_c_derived_type (gfc_symbol *);
2569 gfc_try verify_com_block_vars_c_interop (gfc_common_head *);
2570 void generate_isocbinding_symbol (const char *, iso_c_binding_symbol, const char *);
2571 gfc_symbol *get_iso_c_sym (gfc_symbol *, char *, char *, int);
2572 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **, bool);
2573 int gfc_get_ha_symbol (const char *, gfc_symbol **);
2574 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
2575
2576 int gfc_symbols_could_alias (gfc_symbol *, gfc_symbol *);
2577
2578 void gfc_undo_symbols (void);
2579 void gfc_commit_symbols (void);
2580 void gfc_commit_symbol (gfc_symbol *);
2581 gfc_charlen *gfc_new_charlen (gfc_namespace *, gfc_charlen *);
2582 void gfc_free_charlen (gfc_charlen *, gfc_charlen *);
2583 void gfc_free_namespace (gfc_namespace *);
2584
2585 void gfc_symbol_init_2 (void);
2586 void gfc_symbol_done_2 (void);
2587
2588 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
2589 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
2590 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
2591 void gfc_save_all (gfc_namespace *);
2592
2593 void gfc_enforce_clean_symbol_state (void);
2594 void gfc_free_dt_list (void);
2595
2596
2597 gfc_gsymbol *gfc_get_gsymbol (const char *);
2598 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
2599
2600 gfc_typebound_proc* gfc_get_typebound_proc (gfc_typebound_proc*);
2601 gfc_symbol* gfc_get_derived_super_type (gfc_symbol*);
2602 gfc_symbol* gfc_get_ultimate_derived_super_type (gfc_symbol*);
2603 bool gfc_type_is_extension_of (gfc_symbol *, gfc_symbol *);
2604 bool gfc_type_compatible (gfc_typespec *, gfc_typespec *);
2605
2606 void gfc_copy_formal_args (gfc_symbol *, gfc_symbol *);
2607 void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *);
2608 void gfc_copy_formal_args_ppc (gfc_component *, gfc_symbol *);
2609
2610 void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.c, too  */
2611
2612 gfc_try gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus);
2613 gfc_namespace* gfc_find_proc_namespace (gfc_namespace*);
2614
2615 bool gfc_is_associate_pointer (gfc_symbol*);
2616
2617 /* intrinsic.c -- true if working in an init-expr, false otherwise.  */
2618 extern bool gfc_init_expr_flag;
2619
2620 /* Given a symbol that we have decided is intrinsic, mark it as such
2621    by placing it into a special module that is otherwise impossible to
2622    read or write.  */
2623
2624 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
2625
2626 void gfc_intrinsic_init_1 (void);
2627 void gfc_intrinsic_done_1 (void);
2628
2629 char gfc_type_letter (bt);
2630 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
2631 gfc_try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
2632 gfc_try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
2633 gfc_try gfc_convert_chartype (gfc_expr *, gfc_typespec *);
2634 int gfc_generic_intrinsic (const char *);
2635 int gfc_specific_intrinsic (const char *);
2636 bool gfc_is_intrinsic (gfc_symbol*, int, locus);
2637 int gfc_intrinsic_actual_ok (const char *, const bool);
2638 gfc_intrinsic_sym *gfc_find_function (const char *);
2639 gfc_intrinsic_sym *gfc_find_subroutine (const char *);
2640
2641 match gfc_intrinsic_func_interface (gfc_expr *, int);
2642 match gfc_intrinsic_sub_interface (gfc_code *, int);
2643
2644 void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool);
2645 gfc_try gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**,
2646                                       bool, locus);
2647
2648 /* match.c -- FIXME */
2649 void gfc_free_iterator (gfc_iterator *, int);
2650 void gfc_free_forall_iterator (gfc_forall_iterator *);
2651 void gfc_free_alloc_list (gfc_alloc *);
2652 void gfc_free_namelist (gfc_namelist *);
2653 void gfc_free_equiv (gfc_equiv *);
2654 void gfc_free_equiv_until (gfc_equiv *, gfc_equiv *);
2655 void gfc_free_data (gfc_data *);
2656 void gfc_free_case_list (gfc_case *);
2657
2658 /* matchexp.c -- FIXME too?  */
2659 gfc_expr *gfc_get_parentheses (gfc_expr *);
2660
2661 /* openmp.c */
2662 void gfc_free_omp_clauses (gfc_omp_clauses *);
2663 void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
2664 void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *);
2665 void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
2666 void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
2667
2668 /* expr.c */
2669 void gfc_free_actual_arglist (gfc_actual_arglist *);
2670 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
2671 const char *gfc_extract_int (gfc_expr *, int *);
2672 bool is_subref_array (gfc_expr *);
2673 bool gfc_is_simply_contiguous (gfc_expr *, bool);
2674
2675 gfc_expr *gfc_build_conversion (gfc_expr *);
2676 void gfc_free_ref_list (gfc_ref *);
2677 void gfc_type_convert_binary (gfc_expr *, int);
2678 int gfc_is_constant_expr (gfc_expr *);
2679 gfc_try gfc_simplify_expr (gfc_expr *, int);
2680 int gfc_has_vector_index (gfc_expr *);
2681
2682 gfc_expr *gfc_get_expr (void);
2683 gfc_expr *gfc_get_array_expr (bt type, int kind, locus *);
2684 gfc_expr *gfc_get_null_expr (locus *);
2685 gfc_expr *gfc_get_operator_expr (locus *, gfc_intrinsic_op,gfc_expr *, gfc_expr *);
2686 gfc_expr *gfc_get_structure_constructor_expr (bt, int, locus *);
2687 gfc_expr *gfc_get_constant_expr (bt, int, locus *);
2688 gfc_expr *gfc_get_character_expr (int, locus *, const char *, int len);
2689 gfc_expr *gfc_get_int_expr (int, locus *, int);
2690 gfc_expr *gfc_get_logical_expr (int, locus *, bool);
2691 gfc_expr *gfc_get_iokind_expr (locus *, io_kind);
2692
2693 void gfc_free_expr (gfc_expr *);
2694 void gfc_replace_expr (gfc_expr *, gfc_expr *);
2695 mpz_t *gfc_copy_shape (mpz_t *, int);
2696 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
2697 gfc_expr *gfc_copy_expr (gfc_expr *);
2698 gfc_ref* gfc_copy_ref (gfc_ref*);
2699
2700 gfc_try gfc_specification_expr (gfc_expr *);
2701
2702 int gfc_numeric_ts (gfc_typespec *);
2703 int gfc_kind_max (gfc_expr *, gfc_expr *);
2704
2705 gfc_try gfc_check_conformance (gfc_expr *, gfc_expr *, const char *, ...) ATTRIBUTE_PRINTF_3;
2706 gfc_try gfc_check_assign (gfc_expr *, gfc_expr *, int);
2707 gfc_try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
2708 gfc_try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
2709
2710 bool gfc_has_default_initializer (gfc_symbol *);
2711 gfc_expr *gfc_default_initializer (gfc_typespec *);
2712 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
2713
2714 gfc_array_spec *gfc_get_full_arrayspec_from_expr (gfc_expr *expr);
2715
2716 bool gfc_traverse_expr (gfc_expr *, gfc_symbol *,
2717                         bool (*)(gfc_expr *, gfc_symbol *, int*),
2718                         int);
2719 void gfc_expr_set_symbols_referenced (gfc_expr *);
2720 gfc_try gfc_expr_check_typed (gfc_expr*, gfc_namespace*, bool);
2721 void gfc_expr_replace_symbols (gfc_expr *, gfc_symbol *);
2722 void gfc_expr_replace_comp (gfc_expr *, gfc_component *);
2723
2724 bool gfc_is_proc_ptr_comp (gfc_expr *, gfc_component **);
2725
2726 bool gfc_is_coindexed (gfc_expr *);
2727 bool gfc_get_corank (gfc_expr *);
2728 bool gfc_has_ultimate_allocatable (gfc_expr *);
2729 bool gfc_has_ultimate_pointer (gfc_expr *);
2730
2731 gfc_expr* gfc_build_intrinsic_call (const char*, locus, unsigned, ...);
2732 gfc_try gfc_check_vardef_context (gfc_expr*, bool, const char*);
2733
2734
2735 /* st.c */
2736 extern gfc_code new_st;
2737
2738 void gfc_clear_new_st (void);
2739 gfc_code *gfc_get_code (void);
2740 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
2741 void gfc_free_statement (gfc_code *);
2742 void gfc_free_statements (gfc_code *);
2743 void gfc_free_association_list (gfc_association_list *);
2744
2745 /* resolve.c */
2746 gfc_try gfc_resolve_expr (gfc_expr *);
2747 void gfc_resolve (gfc_namespace *);
2748 void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
2749 int gfc_impure_variable (gfc_symbol *);
2750 int gfc_pure (gfc_symbol *);
2751 int gfc_elemental (gfc_symbol *);
2752 gfc_try gfc_resolve_iterator (gfc_iterator *, bool);
2753 gfc_try find_forall_index (gfc_expr *, gfc_symbol *, int);
2754 gfc_try gfc_resolve_index (gfc_expr *, int);
2755 gfc_try gfc_resolve_dim_arg (gfc_expr *);
2756 int gfc_is_formal_arg (void);
2757 void gfc_resolve_substring_charlen (gfc_expr *);
2758 match gfc_iso_c_sub_interface(gfc_code *, gfc_symbol *);
2759 gfc_expr *gfc_expr_to_initialize (gfc_expr *);
2760 bool gfc_type_is_extensible (gfc_symbol *sym);
2761
2762
2763 /* array.c */
2764 gfc_iterator *gfc_copy_iterator (gfc_iterator *);
2765
2766 void gfc_free_array_spec (gfc_array_spec *);
2767 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
2768
2769 gfc_try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
2770 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
2771 gfc_try gfc_resolve_array_spec (gfc_array_spec *, int);
2772
2773 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
2774
2775 void gfc_simplify_iterator_var (gfc_expr *);
2776 gfc_try gfc_expand_constructor (gfc_expr *, bool);
2777 int gfc_constant_ac (gfc_expr *);
2778 int gfc_expanded_ac (gfc_expr *);
2779 gfc_try gfc_resolve_character_array_constructor (gfc_expr *);
2780 gfc_try gfc_resolve_array_constructor (gfc_expr *);
2781 gfc_try gfc_check_constructor_type (gfc_expr *);
2782 gfc_try gfc_check_iter_variable (gfc_expr *);
2783 gfc_try gfc_check_constructor (gfc_expr *, gfc_try (*)(gfc_expr *));
2784 gfc_try gfc_array_size (gfc_expr *, mpz_t *);
2785 gfc_try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
2786 gfc_try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
2787 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
2788 tree gfc_conv_array_initializer (tree type, gfc_expr *);
2789 gfc_try spec_size (gfc_array_spec *, mpz_t *);
2790 gfc_try spec_dimen_size (gfc_array_spec *, int, mpz_t *);
2791 int gfc_is_compile_time_shape (gfc_array_spec *);
2792
2793 gfc_try gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *);
2794
2795
2796 /* interface.c -- FIXME: some of these should be in symbol.c */
2797 void gfc_free_interface (gfc_interface *);
2798 int gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
2799 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
2800 int gfc_compare_interfaces (gfc_symbol*, gfc_symbol*, const char *, int, int,
2801                             char *, int);
2802 void gfc_check_interfaces (gfc_namespace *);
2803 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
2804 void gfc_ppc_use (gfc_component *, gfc_actual_arglist **, locus *);
2805 gfc_symbol *gfc_search_interface (gfc_interface *, int,
2806                                   gfc_actual_arglist **);
2807 gfc_try gfc_extend_expr (gfc_expr *, bool *);
2808 void gfc_free_formal_arglist (gfc_formal_arglist *);
2809 gfc_try gfc_extend_assign (gfc_code *, gfc_namespace *);
2810 gfc_try gfc_add_interface (gfc_symbol *);
2811 gfc_interface *gfc_current_interface_head (void);
2812 void gfc_set_current_interface_head (gfc_interface *);
2813 gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*);
2814 bool gfc_arglist_matches_symbol (gfc_actual_arglist**, gfc_symbol*);
2815 bool gfc_check_operator_interface (gfc_symbol*, gfc_intrinsic_op, locus);
2816 int gfc_has_vector_subscript (gfc_expr*);
2817
2818 /* io.c */
2819 extern gfc_st_label format_asterisk;
2820
2821 void gfc_free_open (gfc_open *);
2822 gfc_try gfc_resolve_open (gfc_open *);
2823 void gfc_free_close (gfc_close *);
2824 gfc_try gfc_resolve_close (gfc_close *);
2825 void gfc_free_filepos (gfc_filepos *);
2826 gfc_try gfc_resolve_filepos (gfc_filepos *);
2827 void gfc_free_inquire (gfc_inquire *);
2828 gfc_try gfc_resolve_inquire (gfc_inquire *);
2829 void gfc_free_dt (gfc_dt *);
2830 gfc_try gfc_resolve_dt (gfc_dt *, locus *);
2831 void gfc_free_wait (gfc_wait *);
2832 gfc_try gfc_resolve_wait (gfc_wait *);
2833
2834 /* module.c */
2835 void gfc_module_init_2 (void);
2836 void gfc_module_done_2 (void);
2837 void gfc_dump_module (const char *, int);
2838 bool gfc_check_access (gfc_access, gfc_access);
2839 void gfc_free_use_stmts (gfc_use_list *);
2840
2841 /* primary.c */
2842 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
2843 symbol_attribute gfc_expr_attr (gfc_expr *);
2844 match gfc_match_rvalue (gfc_expr **);
2845 match gfc_match_varspec (gfc_expr*, int, bool, bool);
2846 int gfc_check_digit (char, int);
2847 bool gfc_is_function_return_value (gfc_symbol *, gfc_namespace *);
2848
2849 /* trans.c */
2850 void gfc_generate_code (gfc_namespace *);
2851 void gfc_generate_module_code (gfc_namespace *);
2852
2853 /* bbt.c */
2854 typedef int (*compare_fn) (void *, void *);
2855 void gfc_insert_bbt (void *, void *, compare_fn);
2856 void gfc_delete_bbt (void *, void *, compare_fn);
2857
2858 /* dump-parse-tree.c */
2859 void gfc_dump_parse_tree (gfc_namespace *, FILE *);
2860
2861 /* parse.c */
2862 gfc_try gfc_parse_file (void);
2863 void gfc_global_used (gfc_gsymbol *, locus *);
2864 gfc_namespace* gfc_build_block_ns (gfc_namespace *);
2865
2866 /* dependency.c */
2867 int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
2868
2869 /* check.c */
2870 gfc_try gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*);
2871
2872 /* class.c */
2873 void gfc_add_component_ref (gfc_expr *, const char *);
2874 gfc_expr *gfc_class_null_initializer (gfc_typespec *);
2875 gfc_try gfc_build_class_symbol (gfc_typespec *, symbol_attribute *,
2876                                 gfc_array_spec **, bool);
2877 gfc_symbol *gfc_find_derived_vtab (gfc_symbol *);
2878 gfc_symtree* gfc_find_typebound_proc (gfc_symbol*, gfc_try*,
2879                                       const char*, bool, locus*);
2880 gfc_symtree* gfc_find_typebound_user_op (gfc_symbol*, gfc_try*,
2881                                          const char*, bool, locus*);
2882 gfc_typebound_proc* gfc_find_typebound_intrinsic_op (gfc_symbol*, gfc_try*,
2883                                                      gfc_intrinsic_op, bool,
2884                                                      locus*);
2885 gfc_symtree* gfc_get_tbp_symtree (gfc_symtree**, const char*);
2886
2887 #define CLASS_DATA(sym) sym->ts.u.derived->components
2888
2889 /* frontend-passes.c */
2890
2891 void gfc_run_passes (gfc_namespace *);
2892
2893 typedef int (*walk_code_fn_t) (gfc_code **, int *, void *);
2894 typedef int (*walk_expr_fn_t) (gfc_expr **, int *, void *);
2895
2896 int gfc_expr_walker (gfc_expr **, walk_expr_fn_t, void *);
2897 int gfc_code_walker (gfc_code **, walk_code_fn_t, walk_expr_fn_t, void *);
2898
2899 #endif /* GCC_GFORTRAN_H  */