OSDN Git Service

2010-09-24 Tobias Burnus <burnus@net-b.de>
[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 #define NAMED_KINDARRAY(a,b,c,d) a,
617 typedef enum
618 {
619   ISOFORTRANENV_INVALID = -1,
620 #include "iso-fortran-env.def"
621   ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST
622 }
623 iso_fortran_env_symbol;
624 #undef NAMED_KINDARRAY
625
626 #define NAMED_INTCST(a,b,c,d) a,
627 #define NAMED_REALCST(a,b,c) a,
628 #define NAMED_CMPXCST(a,b,c) a,
629 #define NAMED_LOGCST(a,b,c) a,
630 #define NAMED_CHARKNDCST(a,b,c) a,
631 #define NAMED_CHARCST(a,b,c) a,
632 #define DERIVED_TYPE(a,b,c) a,
633 #define PROCEDURE(a,b) a,
634 typedef enum
635 {
636   ISOCBINDING_INVALID = -1, 
637 #include "iso-c-binding.def"
638   ISOCBINDING_LAST,
639   ISOCBINDING_NUMBER = ISOCBINDING_LAST
640 }
641 iso_c_binding_symbol;
642 #undef NAMED_INTCST
643 #undef NAMED_REALCST
644 #undef NAMED_CMPXCST
645 #undef NAMED_LOGCST
646 #undef NAMED_CHARKNDCST
647 #undef NAMED_CHARCST
648 #undef DERIVED_TYPE
649 #undef PROCEDURE
650
651 typedef enum
652 {
653   INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING
654 }
655 intmod_id;
656
657 typedef struct
658 {
659   char name[GFC_MAX_SYMBOL_LEN + 1];
660   int value;  /* Used for both integer and character values.  */
661   bt f90_type;
662 }
663 CInteropKind_t;
664
665 /* Array of structs, where the structs represent the C interop kinds.
666    The list will be implemented based on a hash of the kind name since
667    these could be accessed multiple times.
668    Declared in trans-types.c as a global, since it's in that file
669    that the list is initialized.  */
670 extern CInteropKind_t c_interop_kinds_table[];
671
672
673 /* Structure and list of supported extension attributes.  */
674 typedef enum
675 {
676   EXT_ATTR_DLLIMPORT = 0,
677   EXT_ATTR_DLLEXPORT,
678   EXT_ATTR_STDCALL,
679   EXT_ATTR_CDECL,
680   EXT_ATTR_FASTCALL,
681   EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST
682 }
683 ext_attr_id_t;
684
685 typedef struct
686 {
687   const char *name;
688   unsigned id;
689   const char *middle_end_name;
690 }
691 ext_attr_t;
692
693 extern const ext_attr_t ext_attr_list[];
694
695 /* Symbol attribute structure.  */
696 typedef struct
697 {
698   /* Variable attributes.  */
699   unsigned allocatable:1, dimension:1, codimension:1, external:1, intrinsic:1,
700     optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,
701     dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,
702     implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1,
703     contiguous:1;
704
705   /* For CLASS containers, the pointer attribute is sometimes set internally
706      even though it was not directly specified.  In this case, keep the
707      "real" (original) value here.  */
708   unsigned class_pointer:1;
709
710   ENUM_BITFIELD (save_state) save:2;
711
712   unsigned data:1,              /* Symbol is named in a DATA statement.  */
713     is_protected:1,             /* Symbol has been marked as protected.  */
714     use_assoc:1,                /* Symbol has been use-associated.  */
715     use_only:1,                 /* Symbol has been use-associated, with ONLY.  */
716     use_rename:1,               /* Symbol has been use-associated and renamed.  */
717     imported:1,                 /* Symbol has been associated by IMPORT.  */
718     host_assoc:1;               /* Symbol has been host associated.  */ 
719
720   unsigned in_namelist:1, in_common:1, in_equivalence:1;
721   unsigned function:1, subroutine:1, procedure:1;
722   unsigned generic:1, generic_copy:1;
723   unsigned implicit_type:1;     /* Type defined via implicit rules.  */
724   unsigned untyped:1;           /* No implicit type could be found.  */
725
726   unsigned is_bind_c:1;         /* say if is bound to C.  */
727   unsigned extension:8;         /* extension level of a derived type.  */
728   unsigned is_class:1;          /* is a CLASS container.  */
729   unsigned class_ok:1;          /* is a CLASS object with correct attributes.  */
730   unsigned vtab:1;              /* is a derived type vtab, pointed to by CLASS objects.  */
731   unsigned vtype:1;             /* is a derived type of a vtab.  */
732
733   /* These flags are both in the typespec and attribute.  The attribute
734      list is what gets read from/written to a module file.  The typespec
735      is created from a decl being processed.  */
736   unsigned is_c_interop:1;      /* It's c interoperable.  */
737   unsigned is_iso_c:1;          /* Symbol is from iso_c_binding.  */
738
739   /* Function/subroutine attributes */
740   unsigned sequence:1, elemental:1, pure:1, recursive:1;
741   unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;
742
743   /* This is set if the subroutine doesn't return.  Currently, this
744      is only possible for intrinsic subroutines.  */
745   unsigned noreturn:1;
746
747   /* Set if this procedure is an alternate entry point.  These procedures
748      don't have any code associated, and the backend will turn them into
749      thunks to the master function.  */
750   unsigned entry:1;
751
752   /* Set if this is the master function for a procedure with multiple
753      entry points.  */
754   unsigned entry_master:1;
755
756   /* Set if this is the master function for a function with multiple
757      entry points where characteristics of the entry points differ.  */
758   unsigned mixed_entry_master:1;
759
760   /* Set if a function must always be referenced by an explicit interface.  */
761   unsigned always_explicit:1;
762
763   /* Set if the symbol has been referenced in an expression.  No further
764      modification of type or type parameters is permitted.  */
765   unsigned referenced:1;
766
767   /* Set if this is the symbol for the main program.  */
768   unsigned is_main_program:1;
769
770   /* Mutually exclusive multibit attributes.  */
771   ENUM_BITFIELD (gfc_access) access:2;
772   ENUM_BITFIELD (sym_intent) intent:2;
773   ENUM_BITFIELD (sym_flavor) flavor:4;
774   ENUM_BITFIELD (ifsrc) if_source:2;
775
776   ENUM_BITFIELD (procedure_type) proc:3;
777
778   /* Special attributes for Cray pointers, pointees.  */
779   unsigned cray_pointer:1, cray_pointee:1;
780
781   /* The symbol is a derived type with allocatable components, pointer 
782      components or private components, procedure pointer components,
783      possibly nested.  zero_comp is true if the derived type has no
784      component at all.  */
785   unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,
786            private_comp:1, zero_comp:1, coarray_comp:1;
787
788   /* This is a temporary selector for SELECT TYPE.  */
789   unsigned select_type_temporary:1;
790
791   /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES).  */
792   unsigned ext_attr:EXT_ATTR_NUM;
793
794   /* The namespace where the attribute has been set.  */
795   struct gfc_namespace *volatile_ns, *asynchronous_ns;
796 }
797 symbol_attribute;
798
799
800 /* We need to store source lines as sequences of multibyte source
801    characters. We define here a type wide enough to hold any multibyte
802    source character, just like libcpp does.  A 32-bit type is enough.  */
803
804 #if HOST_BITS_PER_INT >= 32
805 typedef unsigned int gfc_char_t;
806 #elif HOST_BITS_PER_LONG >= 32
807 typedef unsigned long gfc_char_t;
808 #elif defined(HAVE_LONG_LONG) && (HOST_BITS_PER_LONGLONG >= 32)
809 typedef unsigned long long gfc_char_t;
810 #else
811 # error "Cannot find an integer type with at least 32 bits"
812 #endif
813
814
815 /* The following three structures are used to identify a location in
816    the sources.
817
818    gfc_file is used to maintain a tree of the source files and how
819    they include each other
820
821    gfc_linebuf holds a single line of source code and information
822    which file it resides in
823
824    locus point to the sourceline and the character in the source
825    line.
826 */
827
828 typedef struct gfc_file
829 {
830   struct gfc_file *next, *up;
831   int inclusion_line, line;
832   char *filename;
833 } gfc_file;
834
835 typedef struct gfc_linebuf
836 {
837   source_location location;
838   struct gfc_file *file;
839   struct gfc_linebuf *next;
840
841   int truncated;
842   bool dbg_emitted;
843
844   gfc_char_t line[1];
845 } gfc_linebuf;
846
847 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
848
849 #define gfc_linebuf_linenum(LBUF) (LOCATION_LINE ((LBUF)->location))
850
851 typedef struct
852 {
853   gfc_char_t *nextc;
854   gfc_linebuf *lb;
855 } locus;
856
857 /* In order for the "gfc" format checking to work correctly, you must
858    have declared a typedef locus first.  */
859 #if GCC_VERSION >= 4001
860 #define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)
861 #else
862 #define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)
863 #endif
864
865
866 /* Suppress error messages or re-enable them.  */
867
868 void gfc_push_suppress_errors (void);
869 void gfc_pop_suppress_errors (void);
870
871
872 /* Character length structures hold the expression that gives the
873    length of a character variable.  We avoid putting these into
874    gfc_typespec because doing so prevents us from doing structure
875    copies and forces us to deallocate any typespecs we create, as well
876    as structures that contain typespecs.  They also can have multiple
877    character typespecs pointing to them.
878
879    These structures form a singly linked list within the current
880    namespace and are deallocated with the namespace.  It is possible to
881    end up with gfc_charlen structures that have nothing pointing to them.  */
882
883 typedef struct gfc_charlen
884 {
885   struct gfc_expr *length;
886   struct gfc_charlen *next;
887   bool length_from_typespec; /* Length from explicit array ctor typespec?  */
888   tree backend_decl;
889   tree passed_length; /* Length argument explicitelly passed.  */
890
891   int resolved;
892 }
893 gfc_charlen;
894
895 #define gfc_get_charlen() XCNEW (gfc_charlen)
896
897 /* Type specification structure.  */
898 typedef struct
899 {
900   bt type;
901   int kind;
902
903   union
904   {
905     struct gfc_symbol *derived; /* For derived types only.  */
906     gfc_charlen *cl;            /* For character types only.  */
907     int pad;                    /* For hollerith types only.  */
908   }
909   u;
910
911   struct gfc_symbol *interface; /* For PROCEDURE declarations.  */
912   int is_c_interop;
913   int is_iso_c;
914   bt f90_type; 
915 }
916 gfc_typespec;
917
918 /* Array specification.  */
919 typedef struct
920 {
921   int rank;     /* A rank of zero means that a variable is a scalar.  */
922   int corank;
923   array_type type, cotype;
924   struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
925
926   /* These two fields are used with the Cray Pointer extension.  */
927   bool cray_pointee; /* True iff this spec belongs to a cray pointee.  */
928   bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to
929                         AS_EXPLICIT, but we want to remember that we
930                         did this.  */
931
932 }
933 gfc_array_spec;
934
935 #define gfc_get_array_spec() XCNEW (gfc_array_spec)
936
937
938 /* Components of derived types.  */
939 typedef struct gfc_component
940 {
941   const char *name;
942   gfc_typespec ts;
943
944   symbol_attribute attr;
945   gfc_array_spec *as;
946
947   tree backend_decl;
948   locus loc;
949   struct gfc_expr *initializer;
950   struct gfc_component *next;
951
952   /* Needed for procedure pointer components.  */
953   struct gfc_formal_arglist *formal;
954   struct gfc_namespace *formal_ns;
955   struct gfc_typebound_proc *tb;
956 }
957 gfc_component;
958
959 #define gfc_get_component() XCNEW (gfc_component)
960
961 /* Formal argument lists are lists of symbols.  */
962 typedef struct gfc_formal_arglist
963 {
964   /* Symbol representing the argument at this position in the arglist.  */
965   struct gfc_symbol *sym;
966   /* Points to the next formal argument.  */
967   struct gfc_formal_arglist *next;
968 }
969 gfc_formal_arglist;
970
971 #define gfc_get_formal_arglist() XCNEW (gfc_formal_arglist)
972
973
974 /* The gfc_actual_arglist structure is for actual arguments.  */
975 typedef struct gfc_actual_arglist
976 {
977   const char *name;
978   /* Alternate return label when the expr member is null.  */
979   struct gfc_st_label *label;
980
981   /* This is set to the type of an eventual omitted optional
982      argument. This is used to determine if a hidden string length
983      argument has to be added to a function call.  */
984   bt missing_arg_type;
985
986   struct gfc_expr *expr;
987   struct gfc_actual_arglist *next;
988 }
989 gfc_actual_arglist;
990
991 #define gfc_get_actual_arglist() XCNEW (gfc_actual_arglist)
992
993
994 /* Because a symbol can belong to multiple namelists, they must be
995    linked externally to the symbol itself.  */
996 typedef struct gfc_namelist
997 {
998   struct gfc_symbol *sym;
999   struct gfc_namelist *next;
1000 }
1001 gfc_namelist;
1002
1003 #define gfc_get_namelist() XCNEW (gfc_namelist)
1004
1005 enum
1006 {
1007   OMP_LIST_PRIVATE,
1008   OMP_LIST_FIRSTPRIVATE,
1009   OMP_LIST_LASTPRIVATE,
1010   OMP_LIST_COPYPRIVATE,
1011   OMP_LIST_SHARED,
1012   OMP_LIST_COPYIN,
1013   OMP_LIST_PLUS,
1014   OMP_LIST_REDUCTION_FIRST = OMP_LIST_PLUS,
1015   OMP_LIST_MULT,
1016   OMP_LIST_SUB,
1017   OMP_LIST_AND,
1018   OMP_LIST_OR,
1019   OMP_LIST_EQV,
1020   OMP_LIST_NEQV,
1021   OMP_LIST_MAX,
1022   OMP_LIST_MIN,
1023   OMP_LIST_IAND,
1024   OMP_LIST_IOR,
1025   OMP_LIST_IEOR,
1026   OMP_LIST_REDUCTION_LAST = OMP_LIST_IEOR,
1027   OMP_LIST_NUM
1028 };
1029
1030 /* Because a symbol can belong to multiple namelists, they must be
1031    linked externally to the symbol itself.  */
1032
1033 enum gfc_omp_sched_kind
1034 {
1035   OMP_SCHED_NONE,
1036   OMP_SCHED_STATIC,
1037   OMP_SCHED_DYNAMIC,
1038   OMP_SCHED_GUIDED,
1039   OMP_SCHED_RUNTIME,
1040   OMP_SCHED_AUTO
1041 };
1042
1043 enum gfc_omp_default_sharing
1044 {
1045   OMP_DEFAULT_UNKNOWN,
1046   OMP_DEFAULT_NONE,
1047   OMP_DEFAULT_PRIVATE,
1048   OMP_DEFAULT_SHARED,
1049   OMP_DEFAULT_FIRSTPRIVATE
1050 };
1051
1052 typedef struct gfc_omp_clauses
1053 {
1054   struct gfc_expr *if_expr;
1055   struct gfc_expr *num_threads;
1056   gfc_namelist *lists[OMP_LIST_NUM];
1057   enum gfc_omp_sched_kind sched_kind;
1058   struct gfc_expr *chunk_size;
1059   enum gfc_omp_default_sharing default_sharing;
1060   int collapse;
1061   bool nowait, ordered, untied;
1062 }
1063 gfc_omp_clauses;
1064
1065 #define gfc_get_omp_clauses() XCNEW (gfc_omp_clauses)
1066
1067
1068 /* The gfc_st_label structure is a BBT attached to a namespace that
1069    records the usage of statement labels within that space.  */
1070
1071 typedef struct gfc_st_label
1072 {
1073   BBT_HEADER(gfc_st_label);
1074
1075   int value;
1076
1077   gfc_sl_type defined, referenced;
1078
1079   struct gfc_expr *format;
1080
1081   tree backend_decl;
1082
1083   locus where;
1084 }
1085 gfc_st_label;
1086
1087
1088 /* gfc_interface()-- Interfaces are lists of symbols strung together.  */
1089 typedef struct gfc_interface
1090 {
1091   struct gfc_symbol *sym;
1092   locus where;
1093   struct gfc_interface *next;
1094 }
1095 gfc_interface;
1096
1097 #define gfc_get_interface() XCNEW (gfc_interface)
1098
1099 /* User operator nodes.  These are like stripped down symbols.  */
1100 typedef struct
1101 {
1102   const char *name;
1103
1104   gfc_interface *op;
1105   struct gfc_namespace *ns;
1106   gfc_access access;
1107 }
1108 gfc_user_op;
1109
1110
1111 /* A list of specific bindings that are associated with a generic spec.  */
1112 typedef struct gfc_tbp_generic
1113 {
1114   /* The parser sets specific_st, upon resolution we look for the corresponding
1115      gfc_typebound_proc and set specific for further use.  */
1116   struct gfc_symtree* specific_st;
1117   struct gfc_typebound_proc* specific;
1118
1119   struct gfc_tbp_generic* next;
1120 }
1121 gfc_tbp_generic;
1122
1123 #define gfc_get_tbp_generic() XCNEW (gfc_tbp_generic)
1124
1125
1126 /* Data needed for type-bound procedures.  */
1127 typedef struct gfc_typebound_proc
1128 {
1129   locus where; /* Where the PROCEDURE/GENERIC definition was.  */
1130
1131   union
1132   {
1133     struct gfc_symtree* specific; /* The interface if DEFERRED.  */
1134     gfc_tbp_generic* generic;
1135   }
1136   u;
1137
1138   gfc_access access;
1139   const char* pass_arg; /* Argument-name for PASS.  NULL if not specified.  */
1140
1141   /* The overridden type-bound proc (or GENERIC with this name in the
1142      parent-type) or NULL if non.  */
1143   struct gfc_typebound_proc* overridden;
1144
1145   /* Once resolved, we use the position of pass_arg in the formal arglist of
1146      the binding-target procedure to identify it.  The first argument has
1147      number 1 here, the second 2, and so on.  */
1148   unsigned pass_arg_num;
1149
1150   unsigned nopass:1; /* Whether we have NOPASS (PASS otherwise).  */
1151   unsigned non_overridable:1;
1152   unsigned deferred:1;
1153   unsigned is_generic:1;
1154   unsigned function:1, subroutine:1;
1155   unsigned error:1; /* Ignore it, when an error occurred during resolution.  */
1156   unsigned ppc:1;
1157 }
1158 gfc_typebound_proc;
1159
1160
1161 /* Symbol nodes.  These are important things.  They are what the
1162    standard refers to as "entities".  The possibly multiple names that
1163    refer to the same entity are accomplished by a binary tree of
1164    symtree structures that is balanced by the red-black method-- more
1165    than one symtree node can point to any given symbol.  */
1166
1167 typedef struct gfc_symbol
1168 {
1169   const char *name;     /* Primary name, before renaming */
1170   const char *module;   /* Module this symbol came from */
1171   locus declared_at;
1172
1173   gfc_typespec ts;
1174   symbol_attribute attr;
1175
1176   /* The formal member points to the formal argument list if the
1177      symbol is a function or subroutine name.  If the symbol is a
1178      generic name, the generic member points to the list of
1179      interfaces.  */
1180
1181   gfc_interface *generic;
1182   gfc_access component_access;
1183
1184   gfc_formal_arglist *formal;
1185   struct gfc_namespace *formal_ns;
1186   struct gfc_namespace *f2k_derived;
1187
1188   struct gfc_expr *value;       /* Parameter/Initializer value */
1189   gfc_array_spec *as;
1190   struct gfc_symbol *result;    /* function result symbol */
1191   gfc_component *components;    /* Derived type components */
1192
1193   /* Defined only for Cray pointees; points to their pointer.  */
1194   struct gfc_symbol *cp_pointer;
1195
1196   int entry_id;                 /* Used in resolve.c for entries.  */
1197
1198   /* CLASS hashed name for declared and dynamic types in the class.  */
1199   int hash_value;
1200
1201   struct gfc_symbol *common_next;       /* Links for COMMON syms */
1202
1203   /* This is in fact a gfc_common_head but it is only used for pointer
1204      comparisons to check if symbols are in the same common block.  */
1205   struct gfc_common_head* common_head;
1206
1207   /* Make sure setup code for dummy arguments is generated in the correct
1208      order.  */
1209   int dummy_order;
1210
1211   gfc_namelist *namelist, *namelist_tail;
1212
1213   /* Change management fields.  Symbols that might be modified by the
1214      current statement have the mark member nonzero and are kept in a
1215      singly linked list through the tlink field.  Of these symbols,
1216      symbols with old_symbol equal to NULL are symbols created within
1217      the current statement.  Otherwise, old_symbol points to a copy of
1218      the old symbol.  */
1219
1220   struct gfc_symbol *old_symbol, *tlink;
1221   unsigned mark:1, gfc_new:1;
1222   /* Nonzero if all equivalences associated with this symbol have been
1223      processed.  */
1224   unsigned equiv_built:1;
1225   /* Set if this variable is used as an index name in a FORALL.  */
1226   unsigned forall_index:1;
1227   int refs;
1228   struct gfc_namespace *ns;     /* namespace containing this symbol */
1229
1230   tree backend_decl;
1231    
1232   /* Identity of the intrinsic module the symbol comes from, or
1233      INTMOD_NONE if it's not imported from a intrinsic module.  */
1234   intmod_id from_intmod;
1235   /* Identity of the symbol from intrinsic modules, from enums maintained
1236      separately by each intrinsic module.  Used together with from_intmod,
1237      it uniquely identifies a symbol from an intrinsic module.  */
1238   int intmod_sym_id;
1239
1240   /* This may be repetitive, since the typespec now has a binding
1241      label field.  */
1242   char binding_label[GFC_MAX_BINDING_LABEL_LEN + 1];
1243   /* Store a reference to the common_block, if this symbol is in one.  */
1244   struct gfc_common_head *common_block;
1245
1246   /* Link to corresponding association-list if this is an associate name.  */
1247   struct gfc_association_list *assoc;
1248 }
1249 gfc_symbol;
1250
1251
1252 /* This structure is used to keep track of symbols in common blocks.  */
1253 typedef struct gfc_common_head
1254 {
1255   locus where;
1256   char use_assoc, saved, threadprivate;
1257   char name[GFC_MAX_SYMBOL_LEN + 1];
1258   struct gfc_symbol *head;
1259   char binding_label[GFC_MAX_BINDING_LABEL_LEN + 1];
1260   int is_bind_c;
1261 }
1262 gfc_common_head;
1263
1264 #define gfc_get_common_head() XCNEW (gfc_common_head)
1265
1266
1267 /* A list of all the alternate entry points for a procedure.  */
1268
1269 typedef struct gfc_entry_list
1270 {
1271   /* The symbol for this entry point.  */
1272   gfc_symbol *sym;
1273   /* The zero-based id of this entry point.  */
1274   int id;
1275   /* The LABEL_EXPR marking this entry point.  */
1276   tree label;
1277   /* The next item in the list.  */
1278   struct gfc_entry_list *next;
1279 }
1280 gfc_entry_list;
1281
1282 #define gfc_get_entry_list() \
1283   (gfc_entry_list *) gfc_getmem(sizeof(gfc_entry_list))
1284
1285 /* Lists of rename info for the USE statement.  */
1286
1287 typedef struct gfc_use_rename
1288 {
1289   char local_name[GFC_MAX_SYMBOL_LEN + 1], use_name[GFC_MAX_SYMBOL_LEN + 1];
1290   struct gfc_use_rename *next;
1291   int found;
1292   gfc_intrinsic_op op;
1293   locus where;
1294 }
1295 gfc_use_rename;
1296
1297 #define gfc_get_use_rename() XCNEW (gfc_use_rename);
1298
1299 /* A list of all USE statements in a namespace.  */
1300
1301 typedef struct gfc_use_list
1302 {
1303   const char *module_name;
1304   int only_flag;
1305   struct gfc_use_rename *rename;
1306   locus where;
1307   /* Next USE statement.  */
1308   struct gfc_use_list *next;
1309 }
1310 gfc_use_list;
1311
1312 #define gfc_get_use_list() \
1313   (gfc_use_list *) gfc_getmem(sizeof(gfc_use_list))
1314
1315 /* Within a namespace, symbols are pointed to by symtree nodes that
1316    are linked together in a balanced binary tree.  There can be
1317    several symtrees pointing to the same symbol node via USE
1318    statements.  */
1319
1320 typedef struct gfc_symtree
1321 {
1322   BBT_HEADER (gfc_symtree);
1323   const char *name;
1324   int ambiguous;
1325   union
1326   {
1327     gfc_symbol *sym;            /* Symbol associated with this node */
1328     gfc_user_op *uop;
1329     gfc_common_head *common;
1330     gfc_typebound_proc *tb;
1331   }
1332   n;
1333 }
1334 gfc_symtree;
1335
1336 /* A linked list of derived types in the namespace.  */
1337 typedef struct gfc_dt_list
1338 {
1339   struct gfc_symbol *derived;
1340   struct gfc_dt_list *next;
1341 }
1342 gfc_dt_list;
1343
1344 #define gfc_get_dt_list() XCNEW (gfc_dt_list)
1345
1346   /* A list of all derived types.  */
1347   extern gfc_dt_list *gfc_derived_types;
1348
1349 /* A namespace describes the contents of procedure, module, interface block
1350    or BLOCK construct.  */
1351 /* ??? Anything else use these?  */
1352
1353 typedef struct gfc_namespace
1354 {
1355   /* Tree containing all the symbols in this namespace.  */
1356   gfc_symtree *sym_root;
1357   /* Tree containing all the user-defined operators in the namespace.  */
1358   gfc_symtree *uop_root;
1359   /* Tree containing all the common blocks.  */
1360   gfc_symtree *common_root;
1361
1362   /* Tree containing type-bound procedures.  */
1363   gfc_symtree *tb_sym_root;
1364   /* Type-bound user operators.  */
1365   gfc_symtree *tb_uop_root;
1366   /* For derived-types, store type-bound intrinsic operators here.  */
1367   gfc_typebound_proc *tb_op[GFC_INTRINSIC_OPS];
1368   /* Linked list of finalizer procedures.  */
1369   struct gfc_finalizer *finalizers;
1370
1371   /* If set_flag[letter] is set, an implicit type has been set for letter.  */
1372   int set_flag[GFC_LETTERS];
1373   /* Keeps track of the implicit types associated with the letters.  */
1374   gfc_typespec default_type[GFC_LETTERS];
1375   /* Store the positions of IMPLICIT statements.  */
1376   locus implicit_loc[GFC_LETTERS];
1377
1378   /* If this is a namespace of a procedure, this points to the procedure.  */
1379   struct gfc_symbol *proc_name;
1380   /* If this is the namespace of a unit which contains executable
1381      code, this points to it.  */
1382   struct gfc_code *code;
1383
1384   /* Points to the equivalences set up in this namespace.  */
1385   struct gfc_equiv *equiv, *old_equiv;
1386
1387   /* Points to the equivalence groups produced by trans_common.  */
1388   struct gfc_equiv_list *equiv_lists;
1389
1390   gfc_interface *op[GFC_INTRINSIC_OPS];
1391
1392   /* Points to the parent namespace, i.e. the namespace of a module or
1393      procedure in which the procedure belonging to this namespace is
1394      contained. The parent namespace points to this namespace either
1395      directly via CONTAINED, or indirectly via the chain built by
1396      SIBLING.  */
1397   struct gfc_namespace *parent;
1398   /* CONTAINED points to the first contained namespace. Sibling
1399      namespaces are chained via SIBLING.  */
1400   struct gfc_namespace  *contained, *sibling;
1401
1402   gfc_common_head blank_common;
1403   gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
1404
1405   gfc_st_label *st_labels;
1406   /* This list holds information about all the data initializers in
1407      this namespace.  */
1408   struct gfc_data *data;
1409
1410   gfc_charlen *cl_list, *old_cl_list;
1411
1412   gfc_dt_list *derived_types;
1413
1414   int save_all, seen_save, seen_implicit_none;
1415
1416   /* Normally we don't need to refcount namespaces.  However when we read
1417      a module containing a function with multiple entry points, this
1418      will appear as several functions with the same formal namespace.  */
1419   int refs;
1420
1421   /* A list of all alternate entry points to this procedure (or NULL).  */
1422   gfc_entry_list *entries;
1423
1424   /* A list of USE statements in this namespace.  */
1425   gfc_use_list *use_stmts;
1426
1427   /* Set to 1 if namespace is a BLOCK DATA program unit.  */
1428   unsigned is_block_data:1;
1429
1430   /* Set to 1 if namespace is an interface body with "IMPORT" used.  */
1431   unsigned has_import_set:1;
1432
1433   /* Set to 1 if resolved has been called for this namespace.
1434      Holds -1 during resolution.  */
1435   signed resolved:2;
1436
1437   /* Set to 1 if code has been generated for this namespace.  */
1438   unsigned translated:1;
1439
1440   /* Set to 1 if symbols in this namespace should be 'construct entities',
1441      i.e. for BLOCK local variables.  */
1442   unsigned construct_entities:1;
1443 }
1444 gfc_namespace;
1445
1446 extern gfc_namespace *gfc_current_ns;
1447 extern gfc_namespace *gfc_global_ns_list;
1448
1449 /* Global symbols are symbols of global scope. Currently we only use
1450    this to detect collisions already when parsing.
1451    TODO: Extend to verify procedure calls.  */
1452
1453 enum gfc_symbol_type
1454 {
1455   GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
1456   GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA
1457 };
1458
1459 typedef struct gfc_gsymbol
1460 {
1461   BBT_HEADER(gfc_gsymbol);
1462
1463   const char *name;
1464   const char *sym_name;
1465   const char *mod_name;
1466   const char *binding_label;
1467   enum gfc_symbol_type type;
1468
1469   int defined, used;
1470   locus where;
1471   gfc_namespace *ns;
1472 }
1473 gfc_gsymbol;
1474
1475 extern gfc_gsymbol *gfc_gsym_root;
1476
1477 /* Information on interfaces being built.  */
1478 typedef struct
1479 {
1480   interface_type type;
1481   gfc_symbol *sym;
1482   gfc_namespace *ns;
1483   gfc_user_op *uop;
1484   gfc_intrinsic_op op;
1485 }
1486 gfc_interface_info;
1487
1488 extern gfc_interface_info current_interface;
1489
1490
1491 /* Array reference.  */
1492
1493 enum gfc_array_ref_dimen_type
1494 {
1495   DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_STAR, DIMEN_UNKNOWN
1496 };
1497
1498 typedef struct gfc_array_ref
1499 {
1500   ar_type type;
1501   int dimen;                    /* # of components in the reference */
1502   int codimen;
1503   bool in_allocate;             /* For coarray checks. */
1504   locus where;
1505   gfc_array_spec *as;
1506
1507   locus c_where[GFC_MAX_DIMENSIONS];    /* All expressions can be NULL */
1508   struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
1509     *stride[GFC_MAX_DIMENSIONS];
1510
1511   enum gfc_array_ref_dimen_type dimen_type[GFC_MAX_DIMENSIONS];
1512
1513   struct gfc_expr *offset;
1514 }
1515 gfc_array_ref;
1516
1517 #define gfc_get_array_ref() XCNEW (gfc_array_ref)
1518
1519
1520 /* Component reference nodes.  A variable is stored as an expression
1521    node that points to the base symbol.  After that, a singly linked
1522    list of component reference nodes gives the variable's complete
1523    resolution.  The array_ref component may be present and comes
1524    before the component component.  */
1525
1526 typedef enum
1527   { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING }
1528 ref_type;
1529
1530 typedef struct gfc_ref
1531 {
1532   ref_type type;
1533
1534   union
1535   {
1536     struct gfc_array_ref ar;
1537
1538     struct
1539     {
1540       gfc_component *component;
1541       gfc_symbol *sym;
1542     }
1543     c;
1544
1545     struct
1546     {
1547       struct gfc_expr *start, *end;     /* Substring */
1548       gfc_charlen *length;
1549     }
1550     ss;
1551
1552   }
1553   u;
1554
1555   struct gfc_ref *next;
1556 }
1557 gfc_ref;
1558
1559 #define gfc_get_ref() XCNEW (gfc_ref)
1560
1561
1562 /* Structures representing intrinsic symbols and their arguments lists.  */
1563 typedef struct gfc_intrinsic_arg
1564 {
1565   char name[GFC_MAX_SYMBOL_LEN + 1];
1566
1567   gfc_typespec ts;
1568   unsigned optional:1, value:1;
1569   ENUM_BITFIELD (sym_intent) intent:2;
1570   gfc_actual_arglist *actual;
1571
1572   struct gfc_intrinsic_arg *next;
1573
1574 }
1575 gfc_intrinsic_arg;
1576
1577
1578 /* Specifies the various kinds of check functions used to verify the
1579    argument lists of intrinsic functions. fX with X an integer refer
1580    to check functions of intrinsics with X arguments. f1m is used for
1581    the MAX and MIN intrinsics which can have an arbitrary number of
1582    arguments, f3ml is used for the MINLOC and MAXLOC intrinsics as
1583    these have special semantics.  */
1584
1585 typedef union
1586 {
1587   gfc_try (*f0)(void);
1588   gfc_try (*f1)(struct gfc_expr *);
1589   gfc_try (*f1m)(gfc_actual_arglist *);
1590   gfc_try (*f2)(struct gfc_expr *, struct gfc_expr *);
1591   gfc_try (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1592   gfc_try (*f3ml)(gfc_actual_arglist *);
1593   gfc_try (*f3red)(gfc_actual_arglist *);
1594   gfc_try (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1595             struct gfc_expr *);
1596   gfc_try (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1597             struct gfc_expr *, struct gfc_expr *);
1598 }
1599 gfc_check_f;
1600
1601 /* Like gfc_check_f, these specify the type of the simplification
1602    function associated with an intrinsic. The fX are just like in
1603    gfc_check_f. cc is used for type conversion functions.  */
1604
1605 typedef union
1606 {
1607   struct gfc_expr *(*f0)(void);
1608   struct gfc_expr *(*f1)(struct gfc_expr *);
1609   struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
1610   struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
1611                          struct gfc_expr *);
1612   struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
1613                          struct gfc_expr *, struct gfc_expr *);
1614   struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
1615                          struct gfc_expr *, struct gfc_expr *,
1616                          struct gfc_expr *);
1617   struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
1618 }
1619 gfc_simplify_f;
1620
1621 /* Again like gfc_check_f, these specify the type of the resolution
1622    function associated with an intrinsic. The fX are just like in
1623    gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort().  */
1624
1625 typedef union
1626 {
1627   void (*f0)(struct gfc_expr *);
1628   void (*f1)(struct gfc_expr *, struct gfc_expr *);
1629   void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
1630   void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1631   void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1632              struct gfc_expr *);
1633   void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1634              struct gfc_expr *, struct gfc_expr *);
1635   void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1636              struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1637   void (*s1)(struct gfc_code *);
1638 }
1639 gfc_resolve_f;
1640
1641
1642 typedef struct gfc_intrinsic_sym
1643 {
1644   const char *name, *lib_name;
1645   gfc_intrinsic_arg *formal;
1646   gfc_typespec ts;
1647   unsigned elemental:1, inquiry:1, transformational:1, pure:1, 
1648     generic:1, specific:1, actual_ok:1, noreturn:1, conversion:1;
1649
1650   int standard;
1651
1652   gfc_simplify_f simplify;
1653   gfc_check_f check;
1654   gfc_resolve_f resolve;
1655   struct gfc_intrinsic_sym *specific_head, *next;
1656   gfc_isym_id id;
1657
1658 }
1659 gfc_intrinsic_sym;
1660
1661
1662 /* Expression nodes.  The expression node types deserve explanations,
1663    since the last couple can be easily misconstrued:
1664
1665    EXPR_OP         Operator node pointing to one or two other nodes
1666    EXPR_FUNCTION   Function call, symbol points to function's name
1667    EXPR_CONSTANT   A scalar constant: Logical, String, Real, Int or Complex
1668    EXPR_VARIABLE   An Lvalue with a root symbol and possible reference list
1669                    which expresses structure, array and substring refs.
1670    EXPR_NULL       The NULL pointer value (which also has a basic type).
1671    EXPR_SUBSTRING  A substring of a constant string
1672    EXPR_STRUCTURE  A structure constructor
1673    EXPR_ARRAY      An array constructor.
1674    EXPR_COMPCALL   Function (or subroutine) call of a procedure pointer
1675                    component or type-bound procedure.  */
1676
1677 #include <gmp.h>
1678 #include <mpfr.h>
1679 #include <mpc.h>
1680 #define GFC_RND_MODE GMP_RNDN
1681 #define GFC_MPC_RND_MODE MPC_RNDNN
1682
1683 typedef splay_tree gfc_constructor_base;
1684
1685 typedef struct gfc_expr
1686 {
1687   expr_t expr_type;
1688
1689   gfc_typespec ts;      /* These two refer to the overall expression */
1690
1691   int rank;
1692   mpz_t *shape;         /* Can be NULL if shape is unknown at compile time */
1693
1694   /* Nonnull for functions and structure constructors, may also used to hold the
1695      base-object for component calls.  */
1696   gfc_symtree *symtree;
1697
1698   gfc_ref *ref;
1699
1700   locus where;
1701
1702   /* is_boz is true if the integer is regarded as BOZ bitpatten and is_snan
1703      denotes a signalling not-a-number.  */
1704   unsigned int is_boz : 1, is_snan : 1;
1705
1706   /* Sometimes, when an error has been emitted, it is necessary to prevent
1707       it from recurring.  */
1708   unsigned int error : 1;
1709   
1710   /* Mark an expression where a user operator has been substituted by
1711      a function call in interface.c(gfc_extend_expr).  */
1712   unsigned int user_operator : 1;
1713
1714   /* Mark an expression as being a MOLD argument of ALLOCATE.  */
1715   unsigned int mold : 1;
1716   
1717   /* If an expression comes from a Hollerith constant or compile-time
1718      evaluation of a transfer statement, it may have a prescribed target-
1719      memory representation, and these cannot always be backformed from
1720      the value.  */
1721   struct
1722   {
1723     int length;
1724     char *string;
1725   }
1726   representation;
1727
1728   union
1729   {
1730     int logical;
1731
1732     io_kind iokind;
1733
1734     mpz_t integer;
1735
1736     mpfr_t real;
1737
1738     mpc_t complex;
1739
1740     struct
1741     {
1742       gfc_intrinsic_op op;
1743       gfc_user_op *uop;
1744       struct gfc_expr *op1, *op2;
1745     }
1746     op;
1747
1748     struct
1749     {
1750       gfc_actual_arglist *actual;
1751       const char *name; /* Points to the ultimate name of the function */
1752       gfc_intrinsic_sym *isym;
1753       gfc_symbol *esym;
1754     }
1755     function;
1756
1757     struct
1758     {
1759       gfc_actual_arglist* actual;
1760       const char* name;
1761       /* Base-object, whose component was called.  NULL means that it should
1762          be taken from symtree/ref.  */
1763       struct gfc_expr* base_object;
1764       gfc_typebound_proc* tbp; /* Should overlap with esym.  */
1765
1766       /* For type-bound operators, we want to call PASS procedures but already
1767          have the full arglist; mark this, so that it is not extended by the
1768          PASS argument.  */
1769       unsigned ignore_pass:1;
1770
1771       /* Do assign-calls rather than calls, that is appropriate dependency
1772          checking.  */
1773       unsigned assign:1;
1774     }
1775     compcall;
1776
1777     struct
1778     {
1779       int length;
1780       gfc_char_t *string;
1781     }
1782     character;
1783
1784     gfc_constructor_base constructor;
1785   }
1786   value;
1787
1788 }
1789 gfc_expr;
1790
1791
1792 #define gfc_get_shape(rank) ((mpz_t *) gfc_getmem((rank)*sizeof(mpz_t)))
1793
1794 /* Structures for information associated with different kinds of
1795    numbers.  The first set of integer parameters define all there is
1796    to know about a particular kind.  The rest of the elements are
1797    computed from the first elements.  */
1798
1799 typedef struct
1800 {
1801   /* Values really representable by the target.  */
1802   mpz_t huge, pedantic_min_int, min_int;
1803
1804   int kind, radix, digits, bit_size, range;
1805
1806   /* True if the C type of the given name maps to this precision.
1807      Note that more than one bit can be set.  */
1808   unsigned int c_char : 1;
1809   unsigned int c_short : 1;
1810   unsigned int c_int : 1;
1811   unsigned int c_long : 1;
1812   unsigned int c_long_long : 1;
1813 }
1814 gfc_integer_info;
1815
1816 extern gfc_integer_info gfc_integer_kinds[];
1817
1818
1819 typedef struct
1820 {
1821   int kind, bit_size;
1822
1823   /* True if the C++ type bool, C99 type _Bool, maps to this precision.  */
1824   unsigned int c_bool : 1;
1825 }
1826 gfc_logical_info;
1827
1828 extern gfc_logical_info gfc_logical_kinds[];
1829
1830
1831 typedef struct
1832 {
1833   mpfr_t epsilon, huge, tiny, subnormal;
1834   int kind, radix, digits, min_exponent, max_exponent;
1835   int range, precision;
1836
1837   /* The precision of the type as reported by GET_MODE_PRECISION.  */
1838   int mode_precision;
1839
1840   /* True if the C type of the given name maps to this precision.
1841      Note that more than one bit can be set.  */
1842   unsigned int c_float : 1;
1843   unsigned int c_double : 1;
1844   unsigned int c_long_double : 1;
1845   unsigned int c_float128 : 1;
1846 }
1847 gfc_real_info;
1848
1849 extern gfc_real_info gfc_real_kinds[];
1850
1851 typedef struct
1852 {
1853   int kind, bit_size;
1854   const char *name;
1855 }
1856 gfc_character_info;
1857
1858 extern gfc_character_info gfc_character_kinds[];
1859
1860
1861 /* Equivalence structures.  Equivalent lvalues are linked along the
1862    *eq pointer, equivalence sets are strung along the *next node.  */
1863 typedef struct gfc_equiv
1864 {
1865   struct gfc_equiv *next, *eq;
1866   gfc_expr *expr;
1867   const char *module;
1868   int used;
1869 }
1870 gfc_equiv;
1871
1872 #define gfc_get_equiv() XCNEW (gfc_equiv)
1873
1874 /* Holds a single equivalence member after processing.  */
1875 typedef struct gfc_equiv_info
1876 {
1877   gfc_symbol *sym;
1878   HOST_WIDE_INT offset;
1879   HOST_WIDE_INT length;
1880   struct gfc_equiv_info *next;
1881 } gfc_equiv_info;
1882
1883 /* Holds equivalence groups, after they have been processed.  */
1884 typedef struct gfc_equiv_list
1885 {
1886   gfc_equiv_info *equiv;
1887   struct gfc_equiv_list *next;
1888 } gfc_equiv_list;
1889
1890 /* gfc_case stores the selector list of a case statement.  The *low
1891    and *high pointers can point to the same expression in the case of
1892    a single value.  If *high is NULL, the selection is from *low
1893    upwards, if *low is NULL the selection is *high downwards.
1894
1895    This structure has separate fields to allow single and double linked
1896    lists of CASEs at the same time.  The singe linked list along the NEXT
1897    field is a list of cases for a single CASE label.  The double linked
1898    list along the LEFT/RIGHT fields is used to detect overlap and to
1899    build a table of the cases for SELECT constructs with a CHARACTER
1900    case expression.  */
1901
1902 typedef struct gfc_case
1903 {
1904   /* Where we saw this case.  */
1905   locus where;
1906   int n;
1907
1908   /* Case range values.  If (low == high), it's a single value.  If one of
1909      the labels is NULL, it's an unbounded case.  If both are NULL, this
1910      represents the default case.  */
1911   gfc_expr *low, *high;
1912
1913   /* Only used for SELECT TYPE.  */
1914   gfc_typespec ts;
1915
1916   /* Next case label in the list of cases for a single CASE label.  */
1917   struct gfc_case *next;
1918
1919   /* Used for detecting overlap, and for code generation.  */
1920   struct gfc_case *left, *right;
1921
1922   /* True if this case label can never be matched.  */
1923   int unreachable;
1924 }
1925 gfc_case;
1926
1927 #define gfc_get_case() XCNEW (gfc_case)
1928
1929
1930 typedef struct
1931 {
1932   gfc_expr *var, *start, *end, *step;
1933 }
1934 gfc_iterator;
1935
1936 #define gfc_get_iterator() XCNEW (gfc_iterator)
1937
1938
1939 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements.  */
1940
1941 typedef struct gfc_alloc
1942 {
1943   gfc_expr *expr;
1944   struct gfc_alloc *next;
1945 }
1946 gfc_alloc;
1947
1948 #define gfc_get_alloc() XCNEW (gfc_alloc)
1949
1950
1951 typedef struct
1952 {
1953   gfc_expr *unit, *file, *status, *access, *form, *recl,
1954     *blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert,
1955     *decimal, *encoding, *round, *sign, *asynchronous, *id, *newunit;
1956   gfc_st_label *err;
1957 }
1958 gfc_open;
1959
1960
1961 typedef struct
1962 {
1963   gfc_expr *unit, *status, *iostat, *iomsg;
1964   gfc_st_label *err;
1965 }
1966 gfc_close;
1967
1968
1969 typedef struct
1970 {
1971   gfc_expr *unit, *iostat, *iomsg;
1972   gfc_st_label *err;
1973 }
1974 gfc_filepos;
1975
1976
1977 typedef struct
1978 {
1979   gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
1980     *name, *access, *sequential, *direct, *form, *formatted,
1981     *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
1982     *write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert, *strm_pos,
1983     *asynchronous, *decimal, *encoding, *pending, *round, *sign, *size, *id;
1984
1985   gfc_st_label *err;
1986
1987 }
1988 gfc_inquire;
1989
1990
1991 typedef struct
1992 {
1993   gfc_expr *unit, *iostat, *iomsg, *id;
1994   gfc_st_label *err, *end, *eor;
1995 }
1996 gfc_wait;
1997
1998
1999 typedef struct
2000 {
2001   gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg,
2002            *id, *pos, *asynchronous, *blank, *decimal, *delim, *pad, *round,
2003            *sign, *extra_comma;
2004
2005   gfc_symbol *namelist;
2006   /* A format_label of `format_asterisk' indicates the "*" format */
2007   gfc_st_label *format_label;
2008   gfc_st_label *err, *end, *eor;
2009
2010   locus eor_where, end_where, err_where;
2011 }
2012 gfc_dt;
2013
2014
2015 typedef struct gfc_forall_iterator
2016 {
2017   gfc_expr *var, *start, *end, *stride;
2018   struct gfc_forall_iterator *next;
2019 }
2020 gfc_forall_iterator;
2021
2022
2023 /* Linked list to store associations in an ASSOCIATE statement.  */
2024
2025 typedef struct gfc_association_list
2026 {
2027   struct gfc_association_list *next; 
2028
2029   /* Whether this is association to a variable that can be changed; otherwise,
2030      it's association to an expression and the name may not be used as
2031      lvalue.  */
2032   unsigned variable:1;
2033
2034   /* True if this struct is currently only linked to from a gfc_symbol rather
2035      than as part of a real list in gfc_code->ext.block.assoc.  This may
2036      happen for SELECT TYPE temporaries and must be considered
2037      for memory handling.  */
2038   unsigned dangling:1;
2039
2040   char name[GFC_MAX_SYMBOL_LEN + 1];
2041   gfc_symtree *st; /* Symtree corresponding to name.  */
2042   locus where;
2043
2044   gfc_expr *target;
2045 }
2046 gfc_association_list;
2047 #define gfc_get_association_list() XCNEW (gfc_association_list)
2048
2049
2050 /* Executable statements that fill gfc_code structures.  */
2051 typedef enum
2052 {
2053   EXEC_NOP = 1, EXEC_END_BLOCK, EXEC_ASSIGN, EXEC_LABEL_ASSIGN,
2054   EXEC_POINTER_ASSIGN, EXEC_CRITICAL, EXEC_ERROR_STOP,
2055   EXEC_GOTO, EXEC_CALL, EXEC_COMPCALL, EXEC_ASSIGN_CALL, EXEC_RETURN,
2056   EXEC_ENTRY, EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE, EXEC_INIT_ASSIGN,
2057   EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_WHILE, EXEC_SELECT, EXEC_BLOCK,
2058   EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT, EXEC_CALL_PPC,
2059   EXEC_ALLOCATE, EXEC_DEALLOCATE, EXEC_END_PROCEDURE, EXEC_SELECT_TYPE,
2060   EXEC_SYNC_ALL, EXEC_SYNC_MEMORY, EXEC_SYNC_IMAGES,
2061   EXEC_OPEN, EXEC_CLOSE, EXEC_WAIT,
2062   EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
2063   EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
2064   EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
2065   EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
2066   EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
2067   EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
2068   EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
2069   EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT
2070 }
2071 gfc_exec_op;
2072
2073 typedef struct gfc_code
2074 {
2075   gfc_exec_op op;
2076
2077   struct gfc_code *block, *next;
2078   locus loc;
2079
2080   gfc_st_label *here, *label1, *label2, *label3;
2081   gfc_symtree *symtree;
2082   gfc_expr *expr1, *expr2, *expr3;
2083   /* A name isn't sufficient to identify a subroutine, we need the actual
2084      symbol for the interface definition.
2085   const char *sub_name;  */
2086   gfc_symbol *resolved_sym;
2087   gfc_intrinsic_sym *resolved_isym;
2088
2089   union
2090   {
2091     gfc_actual_arglist *actual;
2092     gfc_case *case_list;
2093     gfc_iterator *iterator;
2094
2095     struct
2096     {
2097       gfc_typespec ts;
2098       gfc_alloc *list;
2099     }
2100     alloc;
2101
2102     struct
2103     {
2104       gfc_namespace *ns;
2105       gfc_association_list *assoc;
2106     }
2107     block;
2108
2109     gfc_open *open;
2110     gfc_close *close;
2111     gfc_filepos *filepos;
2112     gfc_inquire *inquire;
2113     gfc_wait *wait;
2114     gfc_dt *dt;
2115     gfc_forall_iterator *forall_iterator;
2116     struct gfc_code *which_construct;
2117     int stop_code;
2118     gfc_entry_list *entry;
2119     gfc_omp_clauses *omp_clauses;
2120     const char *omp_name;
2121     gfc_namelist *omp_namelist;
2122     bool omp_bool;
2123   }
2124   ext;          /* Points to additional structures required by statement */
2125
2126   /* Cycle and break labels in constructs.  */
2127   tree cycle_label;
2128   tree exit_label;
2129 }
2130 gfc_code;
2131
2132
2133 /* Storage for DATA statements.  */
2134 typedef struct gfc_data_variable
2135 {
2136   gfc_expr *expr;
2137   gfc_iterator iter;
2138   struct gfc_data_variable *list, *next;
2139 }
2140 gfc_data_variable;
2141
2142
2143 typedef struct gfc_data_value
2144 {
2145   mpz_t repeat;
2146   gfc_expr *expr;
2147   struct gfc_data_value *next;
2148 }
2149 gfc_data_value;
2150
2151
2152 typedef struct gfc_data
2153 {
2154   gfc_data_variable *var;
2155   gfc_data_value *value;
2156   locus where;
2157
2158   struct gfc_data *next;
2159 }
2160 gfc_data;
2161
2162
2163 /* Structure for holding compile options */
2164 typedef struct
2165 {
2166   char *module_dir;
2167   gfc_source_form source_form;
2168   /* Maximum line lengths in fixed- and free-form source, respectively.
2169      When fixed_line_length or free_line_length are 0, the whole line is used,
2170      regardless of length.
2171
2172      If the user requests a fixed_line_length <7 then gfc_init_options()
2173      emits a fatal error.  */
2174   int fixed_line_length;
2175   int free_line_length;
2176   /* Maximum number of continuation lines in fixed- and free-form source,
2177      respectively.  */
2178   int max_continue_fixed;
2179   int max_continue_free;
2180   int max_identifier_length;
2181   int dump_parse_tree;
2182
2183   int warn_aliasing;
2184   int warn_ampersand;
2185   int warn_conversion;
2186   int warn_conversion_extra;
2187   int warn_implicit_interface;
2188   int warn_implicit_procedure;
2189   int warn_line_truncation;
2190   int warn_surprising;
2191   int warn_tabs;
2192   int warn_underflow;
2193   int warn_intrinsic_shadow;
2194   int warn_intrinsics_std;
2195   int warn_character_truncation;
2196   int warn_array_temp;
2197   int warn_align_commons;
2198   int warn_unused_dummy_argument;
2199   int max_errors;
2200
2201   int flag_all_intrinsics;
2202   int flag_default_double;
2203   int flag_default_integer;
2204   int flag_default_real;
2205   int flag_dollar_ok;
2206   int flag_underscoring;
2207   int flag_second_underscore;
2208   int flag_implicit_none;
2209   int flag_max_stack_var_size;
2210   int flag_max_array_constructor;
2211   int flag_range_check;
2212   int flag_pack_derived;
2213   int flag_repack_arrays;
2214   int flag_preprocessed;
2215   int flag_f2c;
2216   int flag_automatic;
2217   int flag_backslash;
2218   int flag_backtrace;
2219   int flag_allow_leading_underscore;
2220   int flag_dump_core;
2221   int flag_external_blas;
2222   int blas_matmul_limit;
2223   int flag_cray_pointer;
2224   int flag_d_lines;
2225   int flag_openmp;
2226   int flag_sign_zero;
2227   int flag_module_private;
2228   int flag_recursive;
2229   int flag_init_local_zero;
2230   int flag_init_integer;
2231   int flag_init_integer_value;
2232   int flag_init_real;
2233   int flag_init_logical;
2234   int flag_init_character;
2235   char flag_init_character_value;
2236   int flag_align_commons;
2237   int flag_whole_file;
2238   int flag_protect_parens;
2239
2240   int fpe;
2241   int rtcheck;
2242   gfc_fcoarray coarray;
2243
2244   int warn_std;
2245   int allow_std;
2246   int convert;
2247   int record_marker;
2248   int max_subrecord_length;
2249 }
2250 gfc_option_t;
2251
2252 extern gfc_option_t gfc_option;
2253
2254 /* Constructor nodes for array and structure constructors.  */
2255 typedef struct gfc_constructor
2256 {
2257   gfc_constructor_base base;
2258   mpz_t offset;               /* Offset within a constructor, used as
2259                                  key within base. */
2260
2261   gfc_expr *expr;
2262   gfc_iterator *iterator;
2263   locus where;
2264
2265   union
2266   {
2267      gfc_component *component; /* Record the component being initialized.  */
2268   }
2269   n;
2270 }
2271 gfc_constructor;
2272
2273
2274 typedef struct iterator_stack
2275 {
2276   gfc_symtree *variable;
2277   mpz_t value;
2278   struct iterator_stack *prev;
2279 }
2280 iterator_stack;
2281 extern iterator_stack *iter_stack;
2282
2283
2284 /* Used for (possibly nested) SELECT TYPE statements.  */
2285 typedef struct gfc_select_type_stack
2286 {
2287   gfc_symbol *selector;                 /* Current selector variable.  */
2288   gfc_symtree *tmp;                     /* Current temporary variable.  */
2289   struct gfc_select_type_stack *prev;   /* Previous element on stack.  */
2290 }
2291 gfc_select_type_stack;
2292 extern gfc_select_type_stack *select_type_stack;
2293 #define gfc_get_select_type_stack() XCNEW (gfc_select_type_stack)
2294
2295
2296 /* Node in the linked list used for storing finalizer procedures.  */
2297
2298 typedef struct gfc_finalizer
2299 {
2300   struct gfc_finalizer* next;
2301   locus where; /* Where the FINAL declaration occurred.  */
2302
2303   /* Up to resolution, we want the gfc_symbol, there we lookup the corresponding
2304      symtree and later need only that.  This way, we can access and call the
2305      finalizers from every context as they should be "always accessible".  I
2306      don't make this a union because we need the information whether proc_sym is
2307      still referenced or not for dereferencing it on deleting a gfc_finalizer
2308      structure.  */
2309   gfc_symbol*  proc_sym;
2310   gfc_symtree* proc_tree; 
2311 }
2312 gfc_finalizer;
2313 #define gfc_get_finalizer() XCNEW (gfc_finalizer)
2314
2315
2316 /************************ Function prototypes *************************/
2317
2318 /* decl.c */
2319 bool gfc_in_match_data (void);
2320 match gfc_match_char_spec (gfc_typespec *);
2321
2322 /* scanner.c */
2323 void gfc_scanner_done_1 (void);
2324 void gfc_scanner_init_1 (void);
2325
2326 void gfc_add_include_path (const char *, bool, bool);
2327 void gfc_add_intrinsic_modules_path (const char *);
2328 void gfc_release_include_path (void);
2329 FILE *gfc_open_included_file (const char *, bool, bool);
2330 FILE *gfc_open_intrinsic_module (const char *);
2331
2332 int gfc_at_end (void);
2333 int gfc_at_eof (void);
2334 int gfc_at_bol (void);
2335 int gfc_at_eol (void);
2336 void gfc_advance_line (void);
2337 int gfc_check_include (void);
2338 int gfc_define_undef_line (void);
2339
2340 int gfc_wide_is_printable (gfc_char_t);
2341 int gfc_wide_is_digit (gfc_char_t);
2342 int gfc_wide_fits_in_byte (gfc_char_t);
2343 gfc_char_t gfc_wide_tolower (gfc_char_t);
2344 gfc_char_t gfc_wide_toupper (gfc_char_t);
2345 size_t gfc_wide_strlen (const gfc_char_t *);
2346 int gfc_wide_strncasecmp (const gfc_char_t *, const char *, size_t);
2347 gfc_char_t *gfc_wide_memset (gfc_char_t *, gfc_char_t, size_t);
2348 char *gfc_widechar_to_char (const gfc_char_t *, int);
2349 gfc_char_t *gfc_char_to_widechar (const char *);
2350
2351 #define gfc_get_wide_string(n) XCNEWVEC (gfc_char_t, n)
2352
2353 void gfc_skip_comments (void);
2354 gfc_char_t gfc_next_char_literal (int);
2355 gfc_char_t gfc_next_char (void);
2356 char gfc_next_ascii_char (void);
2357 gfc_char_t gfc_peek_char (void);
2358 char gfc_peek_ascii_char (void);
2359 void gfc_error_recovery (void);
2360 void gfc_gobble_whitespace (void);
2361 gfc_try gfc_new_file (void);
2362 const char * gfc_read_orig_filename (const char *, const char **);
2363
2364 extern gfc_source_form gfc_current_form;
2365 extern const char *gfc_source_file;
2366 extern locus gfc_current_locus;
2367
2368 void gfc_start_source_files (void);
2369 void gfc_end_source_files (void);
2370
2371 /* misc.c */
2372 void *gfc_getmem (size_t) ATTRIBUTE_MALLOC;
2373 void gfc_free (void *);
2374 int gfc_terminal_width (void);
2375 void gfc_clear_ts (gfc_typespec *);
2376 FILE *gfc_open_file (const char *);
2377 const char *gfc_basic_typename (bt);
2378 const char *gfc_typename (gfc_typespec *);
2379 const char *gfc_op2string (gfc_intrinsic_op);
2380 const char *gfc_code2string (const mstring *, int);
2381 int gfc_string2code (const mstring *, const char *);
2382 const char *gfc_intent_string (sym_intent);
2383
2384 void gfc_init_1 (void);
2385 void gfc_init_2 (void);
2386 void gfc_done_1 (void);
2387 void gfc_done_2 (void);
2388
2389 int get_c_kind (const char *, CInteropKind_t *);
2390
2391 /* options.c */
2392 unsigned int gfc_option_lang_mask (void);
2393 void gfc_init_options (unsigned int,
2394                        struct cl_decoded_option *);
2395 bool gfc_handle_option (size_t, const char *, int, int,
2396                         const struct cl_option_handlers *);
2397 bool gfc_post_options (const char **);
2398
2399 /* f95-lang.c */
2400 void gfc_maybe_initialize_eh (void);
2401
2402 /* iresolve.c */
2403 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
2404 bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *);
2405
2406 /* error.c */
2407
2408 typedef struct gfc_error_buf
2409 {
2410   int flag;
2411   size_t allocated, index;
2412   char *message;
2413 } gfc_error_buf;
2414
2415 void gfc_error_init_1 (void);
2416 void gfc_buffer_error (int);
2417
2418 const char *gfc_print_wide_char (gfc_char_t);
2419
2420 void gfc_warning (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2421 void gfc_warning_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2422 void gfc_clear_warning (void);
2423 void gfc_warning_check (void);
2424
2425 void gfc_error (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2426 void gfc_error_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2427 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2428 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2429 void gfc_clear_error (void);
2430 int gfc_error_check (void);
2431 int gfc_error_flag_test (void);
2432
2433 notification gfc_notification_std (int);
2434 gfc_try gfc_notify_std (int, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
2435
2436 /* A general purpose syntax error.  */
2437 #define gfc_syntax_error(ST)    \
2438   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
2439
2440 void gfc_push_error (gfc_error_buf *);
2441 void gfc_pop_error (gfc_error_buf *);
2442 void gfc_free_error (gfc_error_buf *);
2443
2444 void gfc_get_errors (int *, int *);
2445 void gfc_errors_to_warnings (int);
2446
2447 /* arith.c */
2448 void gfc_arith_init_1 (void);
2449 void gfc_arith_done_1 (void);
2450 arith gfc_check_integer_range (mpz_t p, int kind);
2451 bool gfc_check_character_range (gfc_char_t, int);
2452
2453 /* trans-types.c */
2454 gfc_try gfc_check_any_c_kind (gfc_typespec *);
2455 int gfc_validate_kind (bt, int, bool);
2456 int gfc_get_int_kind_from_width_isofortranenv (int size);
2457 int gfc_get_real_kind_from_width_isofortranenv (int size);
2458 tree gfc_get_derived_type (gfc_symbol * derived);
2459 extern int gfc_index_integer_kind;
2460 extern int gfc_default_integer_kind;
2461 extern int gfc_max_integer_kind;
2462 extern int gfc_default_real_kind;
2463 extern int gfc_default_double_kind;
2464 extern int gfc_default_character_kind;
2465 extern int gfc_default_logical_kind;
2466 extern int gfc_default_complex_kind;
2467 extern int gfc_c_int_kind;
2468 extern int gfc_intio_kind;
2469 extern int gfc_charlen_int_kind;
2470 extern int gfc_numeric_storage_size;
2471 extern int gfc_character_storage_size;
2472
2473 /* symbol.c */
2474 void gfc_clear_new_implicit (void);
2475 gfc_try gfc_add_new_implicit_range (int, int);
2476 gfc_try gfc_merge_new_implicit (gfc_typespec *);
2477 void gfc_set_implicit_none (void);
2478 void gfc_check_function_type (gfc_namespace *);
2479 bool gfc_is_intrinsic_typename (const char *);
2480
2481 gfc_typespec *gfc_get_default_type (const char *, gfc_namespace *);
2482 gfc_try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
2483
2484 void gfc_set_sym_referenced (gfc_symbol *);
2485
2486 gfc_try gfc_add_attribute (symbol_attribute *, locus *);
2487 gfc_try gfc_add_ext_attribute (symbol_attribute *, ext_attr_id_t, locus *);
2488 gfc_try gfc_add_allocatable (symbol_attribute *, locus *);
2489 gfc_try gfc_add_codimension (symbol_attribute *, const char *, locus *);
2490 gfc_try gfc_add_contiguous (symbol_attribute *, const char *, locus *);
2491 gfc_try gfc_add_dimension (symbol_attribute *, const char *, locus *);
2492 gfc_try gfc_add_external (symbol_attribute *, locus *);
2493 gfc_try gfc_add_intrinsic (symbol_attribute *, locus *);
2494 gfc_try gfc_add_optional (symbol_attribute *, locus *);
2495 gfc_try gfc_add_pointer (symbol_attribute *, locus *);
2496 gfc_try gfc_add_cray_pointer (symbol_attribute *, locus *);
2497 gfc_try gfc_add_cray_pointee (symbol_attribute *, locus *);
2498 match gfc_mod_pointee_as (gfc_array_spec *);
2499 gfc_try gfc_add_protected (symbol_attribute *, const char *, locus *);
2500 gfc_try gfc_add_result (symbol_attribute *, const char *, locus *);
2501 gfc_try gfc_add_save (symbol_attribute *, save_state, const char *, locus *);
2502 gfc_try gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
2503 gfc_try gfc_add_saved_common (symbol_attribute *, locus *);
2504 gfc_try gfc_add_target (symbol_attribute *, locus *);
2505 gfc_try gfc_add_dummy (symbol_attribute *, const char *, locus *);
2506 gfc_try gfc_add_generic (symbol_attribute *, const char *, locus *);
2507 gfc_try gfc_add_common (symbol_attribute *, locus *);
2508 gfc_try gfc_add_in_common (symbol_attribute *, const char *, locus *);
2509 gfc_try gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
2510 gfc_try gfc_add_data (symbol_attribute *, const char *, locus *);
2511 gfc_try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
2512 gfc_try gfc_add_sequence (symbol_attribute *, const char *, locus *);
2513 gfc_try gfc_add_elemental (symbol_attribute *, locus *);
2514 gfc_try gfc_add_pure (symbol_attribute *, locus *);
2515 gfc_try gfc_add_recursive (symbol_attribute *, locus *);
2516 gfc_try gfc_add_function (symbol_attribute *, const char *, locus *);
2517 gfc_try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
2518 gfc_try gfc_add_volatile (symbol_attribute *, const char *, locus *);
2519 gfc_try gfc_add_asynchronous (symbol_attribute *, const char *, locus *);
2520 gfc_try gfc_add_proc (symbol_attribute *attr, const char *name, locus *where);
2521 gfc_try gfc_add_abstract (symbol_attribute* attr, locus* where);
2522
2523 gfc_try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
2524 gfc_try gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int);
2525 gfc_try gfc_add_extension (symbol_attribute *, locus *);
2526 gfc_try gfc_add_value (symbol_attribute *, const char *, locus *);
2527 gfc_try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
2528 gfc_try gfc_add_entry (symbol_attribute *, const char *, locus *);
2529 gfc_try gfc_add_procedure (symbol_attribute *, procedure_type,
2530                        const char *, locus *);
2531 gfc_try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
2532 gfc_try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
2533                                 gfc_formal_arglist *, locus *);
2534 gfc_try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
2535
2536 void gfc_clear_attr (symbol_attribute *);
2537 gfc_try gfc_missing_attr (symbol_attribute *, locus *);
2538 gfc_try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
2539
2540 gfc_try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
2541 gfc_symbol *gfc_use_derived (gfc_symbol *);
2542 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
2543 gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool);
2544
2545 gfc_st_label *gfc_get_st_label (int);
2546 void gfc_free_st_label (gfc_st_label *);
2547 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
2548 gfc_try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
2549
2550 gfc_expr * gfc_lval_expr_from_sym (gfc_symbol *);
2551
2552 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
2553 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
2554 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
2555 void gfc_delete_symtree (gfc_symtree **, const char *);
2556 gfc_symtree *gfc_get_unique_symtree (gfc_namespace *);
2557 gfc_user_op *gfc_get_uop (const char *);
2558 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
2559 void gfc_free_symbol (gfc_symbol *);
2560 void gfc_release_symbol (gfc_symbol *);
2561 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
2562 gfc_symtree* gfc_find_symtree_in_proc (const char *, gfc_namespace *);
2563 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
2564 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
2565 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
2566 gfc_try verify_c_interop (gfc_typespec *);
2567 gfc_try verify_c_interop_param (gfc_symbol *);
2568 gfc_try verify_bind_c_sym (gfc_symbol *, gfc_typespec *, int, gfc_common_head *);
2569 gfc_try verify_bind_c_derived_type (gfc_symbol *);
2570 gfc_try verify_com_block_vars_c_interop (gfc_common_head *);
2571 void generate_isocbinding_symbol (const char *, iso_c_binding_symbol, const char *);
2572 gfc_symbol *get_iso_c_sym (gfc_symbol *, char *, char *, int);
2573 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **, bool);
2574 int gfc_get_ha_symbol (const char *, gfc_symbol **);
2575 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
2576
2577 int gfc_symbols_could_alias (gfc_symbol *, gfc_symbol *);
2578
2579 void gfc_undo_symbols (void);
2580 void gfc_commit_symbols (void);
2581 void gfc_commit_symbol (gfc_symbol *);
2582 gfc_charlen *gfc_new_charlen (gfc_namespace *, gfc_charlen *);
2583 void gfc_free_charlen (gfc_charlen *, gfc_charlen *);
2584 void gfc_free_namespace (gfc_namespace *);
2585
2586 void gfc_symbol_init_2 (void);
2587 void gfc_symbol_done_2 (void);
2588
2589 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
2590 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
2591 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
2592 void gfc_save_all (gfc_namespace *);
2593
2594 void gfc_enforce_clean_symbol_state (void);
2595 void gfc_free_dt_list (void);
2596
2597
2598 gfc_gsymbol *gfc_get_gsymbol (const char *);
2599 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
2600
2601 gfc_typebound_proc* gfc_get_typebound_proc (gfc_typebound_proc*);
2602 gfc_symbol* gfc_get_derived_super_type (gfc_symbol*);
2603 gfc_symbol* gfc_get_ultimate_derived_super_type (gfc_symbol*);
2604 bool gfc_type_is_extension_of (gfc_symbol *, gfc_symbol *);
2605 bool gfc_type_compatible (gfc_typespec *, gfc_typespec *);
2606
2607 void gfc_copy_formal_args (gfc_symbol *, gfc_symbol *);
2608 void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *);
2609 void gfc_copy_formal_args_ppc (gfc_component *, gfc_symbol *);
2610
2611 void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.c, too  */
2612
2613 gfc_try gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus);
2614 gfc_namespace* gfc_find_proc_namespace (gfc_namespace*);
2615
2616 bool gfc_is_associate_pointer (gfc_symbol*);
2617
2618 /* intrinsic.c -- true if working in an init-expr, false otherwise.  */
2619 extern bool gfc_init_expr_flag;
2620
2621 /* Given a symbol that we have decided is intrinsic, mark it as such
2622    by placing it into a special module that is otherwise impossible to
2623    read or write.  */
2624
2625 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
2626
2627 void gfc_intrinsic_init_1 (void);
2628 void gfc_intrinsic_done_1 (void);
2629
2630 char gfc_type_letter (bt);
2631 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
2632 gfc_try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
2633 gfc_try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
2634 gfc_try gfc_convert_chartype (gfc_expr *, gfc_typespec *);
2635 int gfc_generic_intrinsic (const char *);
2636 int gfc_specific_intrinsic (const char *);
2637 bool gfc_is_intrinsic (gfc_symbol*, int, locus);
2638 int gfc_intrinsic_actual_ok (const char *, const bool);
2639 gfc_intrinsic_sym *gfc_find_function (const char *);
2640 gfc_intrinsic_sym *gfc_find_subroutine (const char *);
2641
2642 match gfc_intrinsic_func_interface (gfc_expr *, int);
2643 match gfc_intrinsic_sub_interface (gfc_code *, int);
2644
2645 void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool);
2646 gfc_try gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**,
2647                                       bool, locus);
2648
2649 /* match.c -- FIXME */
2650 void gfc_free_iterator (gfc_iterator *, int);
2651 void gfc_free_forall_iterator (gfc_forall_iterator *);
2652 void gfc_free_alloc_list (gfc_alloc *);
2653 void gfc_free_namelist (gfc_namelist *);
2654 void gfc_free_equiv (gfc_equiv *);
2655 void gfc_free_equiv_until (gfc_equiv *, gfc_equiv *);
2656 void gfc_free_data (gfc_data *);
2657 void gfc_free_case_list (gfc_case *);
2658
2659 /* matchexp.c -- FIXME too?  */
2660 gfc_expr *gfc_get_parentheses (gfc_expr *);
2661
2662 /* openmp.c */
2663 void gfc_free_omp_clauses (gfc_omp_clauses *);
2664 void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
2665 void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *);
2666 void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
2667 void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
2668
2669 /* expr.c */
2670 void gfc_free_actual_arglist (gfc_actual_arglist *);
2671 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
2672 const char *gfc_extract_int (gfc_expr *, int *);
2673 bool is_subref_array (gfc_expr *);
2674 bool gfc_is_simply_contiguous (gfc_expr *, bool);
2675
2676 gfc_expr *gfc_build_conversion (gfc_expr *);
2677 void gfc_free_ref_list (gfc_ref *);
2678 void gfc_type_convert_binary (gfc_expr *, int);
2679 int gfc_is_constant_expr (gfc_expr *);
2680 gfc_try gfc_simplify_expr (gfc_expr *, int);
2681 int gfc_has_vector_index (gfc_expr *);
2682
2683 gfc_expr *gfc_get_expr (void);
2684 gfc_expr *gfc_get_array_expr (bt type, int kind, locus *);
2685 gfc_expr *gfc_get_null_expr (locus *);
2686 gfc_expr *gfc_get_operator_expr (locus *, gfc_intrinsic_op,gfc_expr *, gfc_expr *);
2687 gfc_expr *gfc_get_structure_constructor_expr (bt, int, locus *);
2688 gfc_expr *gfc_get_constant_expr (bt, int, locus *);
2689 gfc_expr *gfc_get_character_expr (int, locus *, const char *, int len);
2690 gfc_expr *gfc_get_int_expr (int, locus *, int);
2691 gfc_expr *gfc_get_logical_expr (int, locus *, bool);
2692 gfc_expr *gfc_get_iokind_expr (locus *, io_kind);
2693
2694 void gfc_free_expr (gfc_expr *);
2695 void gfc_replace_expr (gfc_expr *, gfc_expr *);
2696 mpz_t *gfc_copy_shape (mpz_t *, int);
2697 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
2698 gfc_expr *gfc_copy_expr (gfc_expr *);
2699 gfc_ref* gfc_copy_ref (gfc_ref*);
2700
2701 gfc_try gfc_specification_expr (gfc_expr *);
2702
2703 int gfc_numeric_ts (gfc_typespec *);
2704 int gfc_kind_max (gfc_expr *, gfc_expr *);
2705
2706 gfc_try gfc_check_conformance (gfc_expr *, gfc_expr *, const char *, ...) ATTRIBUTE_PRINTF_3;
2707 gfc_try gfc_check_assign (gfc_expr *, gfc_expr *, int);
2708 gfc_try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
2709 gfc_try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
2710
2711 bool gfc_has_default_initializer (gfc_symbol *);
2712 gfc_expr *gfc_default_initializer (gfc_typespec *);
2713 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
2714
2715 gfc_array_spec *gfc_get_full_arrayspec_from_expr (gfc_expr *expr);
2716
2717 bool gfc_traverse_expr (gfc_expr *, gfc_symbol *,
2718                         bool (*)(gfc_expr *, gfc_symbol *, int*),
2719                         int);
2720 void gfc_expr_set_symbols_referenced (gfc_expr *);
2721 gfc_try gfc_expr_check_typed (gfc_expr*, gfc_namespace*, bool);
2722 void gfc_expr_replace_symbols (gfc_expr *, gfc_symbol *);
2723 void gfc_expr_replace_comp (gfc_expr *, gfc_component *);
2724
2725 bool gfc_is_proc_ptr_comp (gfc_expr *, gfc_component **);
2726
2727 bool gfc_is_coindexed (gfc_expr *);
2728 bool gfc_get_corank (gfc_expr *);
2729 bool gfc_has_ultimate_allocatable (gfc_expr *);
2730 bool gfc_has_ultimate_pointer (gfc_expr *);
2731
2732 gfc_expr* gfc_build_intrinsic_call (const char*, locus, unsigned, ...);
2733 gfc_try gfc_check_vardef_context (gfc_expr*, bool, const char*);
2734
2735
2736 /* st.c */
2737 extern gfc_code new_st;
2738
2739 void gfc_clear_new_st (void);
2740 gfc_code *gfc_get_code (void);
2741 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
2742 void gfc_free_statement (gfc_code *);
2743 void gfc_free_statements (gfc_code *);
2744 void gfc_free_association_list (gfc_association_list *);
2745
2746 /* resolve.c */
2747 gfc_try gfc_resolve_expr (gfc_expr *);
2748 void gfc_resolve (gfc_namespace *);
2749 void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
2750 int gfc_impure_variable (gfc_symbol *);
2751 int gfc_pure (gfc_symbol *);
2752 int gfc_elemental (gfc_symbol *);
2753 gfc_try gfc_resolve_iterator (gfc_iterator *, bool);
2754 gfc_try find_forall_index (gfc_expr *, gfc_symbol *, int);
2755 gfc_try gfc_resolve_index (gfc_expr *, int);
2756 gfc_try gfc_resolve_dim_arg (gfc_expr *);
2757 int gfc_is_formal_arg (void);
2758 void gfc_resolve_substring_charlen (gfc_expr *);
2759 match gfc_iso_c_sub_interface(gfc_code *, gfc_symbol *);
2760 gfc_expr *gfc_expr_to_initialize (gfc_expr *);
2761 bool gfc_type_is_extensible (gfc_symbol *sym);
2762
2763
2764 /* array.c */
2765 gfc_iterator *gfc_copy_iterator (gfc_iterator *);
2766
2767 void gfc_free_array_spec (gfc_array_spec *);
2768 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
2769
2770 gfc_try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
2771 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
2772 gfc_try gfc_resolve_array_spec (gfc_array_spec *, int);
2773
2774 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
2775
2776 void gfc_simplify_iterator_var (gfc_expr *);
2777 gfc_try gfc_expand_constructor (gfc_expr *, bool);
2778 int gfc_constant_ac (gfc_expr *);
2779 int gfc_expanded_ac (gfc_expr *);
2780 gfc_try gfc_resolve_character_array_constructor (gfc_expr *);
2781 gfc_try gfc_resolve_array_constructor (gfc_expr *);
2782 gfc_try gfc_check_constructor_type (gfc_expr *);
2783 gfc_try gfc_check_iter_variable (gfc_expr *);
2784 gfc_try gfc_check_constructor (gfc_expr *, gfc_try (*)(gfc_expr *));
2785 gfc_try gfc_array_size (gfc_expr *, mpz_t *);
2786 gfc_try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
2787 gfc_try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
2788 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
2789 tree gfc_conv_array_initializer (tree type, gfc_expr *);
2790 gfc_try spec_size (gfc_array_spec *, mpz_t *);
2791 gfc_try spec_dimen_size (gfc_array_spec *, int, mpz_t *);
2792 int gfc_is_compile_time_shape (gfc_array_spec *);
2793
2794 gfc_try gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *);
2795
2796
2797 /* interface.c -- FIXME: some of these should be in symbol.c */
2798 void gfc_free_interface (gfc_interface *);
2799 int gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
2800 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
2801 int gfc_compare_interfaces (gfc_symbol*, gfc_symbol*, const char *, int, int,
2802                             char *, int);
2803 void gfc_check_interfaces (gfc_namespace *);
2804 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
2805 void gfc_ppc_use (gfc_component *, gfc_actual_arglist **, locus *);
2806 gfc_symbol *gfc_search_interface (gfc_interface *, int,
2807                                   gfc_actual_arglist **);
2808 gfc_try gfc_extend_expr (gfc_expr *, bool *);
2809 void gfc_free_formal_arglist (gfc_formal_arglist *);
2810 gfc_try gfc_extend_assign (gfc_code *, gfc_namespace *);
2811 gfc_try gfc_add_interface (gfc_symbol *);
2812 gfc_interface *gfc_current_interface_head (void);
2813 void gfc_set_current_interface_head (gfc_interface *);
2814 gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*);
2815 bool gfc_arglist_matches_symbol (gfc_actual_arglist**, gfc_symbol*);
2816 bool gfc_check_operator_interface (gfc_symbol*, gfc_intrinsic_op, locus);
2817 int gfc_has_vector_subscript (gfc_expr*);
2818
2819 /* io.c */
2820 extern gfc_st_label format_asterisk;
2821
2822 void gfc_free_open (gfc_open *);
2823 gfc_try gfc_resolve_open (gfc_open *);
2824 void gfc_free_close (gfc_close *);
2825 gfc_try gfc_resolve_close (gfc_close *);
2826 void gfc_free_filepos (gfc_filepos *);
2827 gfc_try gfc_resolve_filepos (gfc_filepos *);
2828 void gfc_free_inquire (gfc_inquire *);
2829 gfc_try gfc_resolve_inquire (gfc_inquire *);
2830 void gfc_free_dt (gfc_dt *);
2831 gfc_try gfc_resolve_dt (gfc_dt *, locus *);
2832 void gfc_free_wait (gfc_wait *);
2833 gfc_try gfc_resolve_wait (gfc_wait *);
2834
2835 /* module.c */
2836 void gfc_module_init_2 (void);
2837 void gfc_module_done_2 (void);
2838 void gfc_dump_module (const char *, int);
2839 bool gfc_check_access (gfc_access, gfc_access);
2840 void gfc_free_use_stmts (gfc_use_list *);
2841
2842 /* primary.c */
2843 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
2844 symbol_attribute gfc_expr_attr (gfc_expr *);
2845 match gfc_match_rvalue (gfc_expr **);
2846 match gfc_match_varspec (gfc_expr*, int, bool, bool);
2847 int gfc_check_digit (char, int);
2848 bool gfc_is_function_return_value (gfc_symbol *, gfc_namespace *);
2849
2850 /* trans.c */
2851 void gfc_generate_code (gfc_namespace *);
2852 void gfc_generate_module_code (gfc_namespace *);
2853
2854 /* bbt.c */
2855 typedef int (*compare_fn) (void *, void *);
2856 void gfc_insert_bbt (void *, void *, compare_fn);
2857 void gfc_delete_bbt (void *, void *, compare_fn);
2858
2859 /* dump-parse-tree.c */
2860 void gfc_dump_parse_tree (gfc_namespace *, FILE *);
2861
2862 /* parse.c */
2863 gfc_try gfc_parse_file (void);
2864 void gfc_global_used (gfc_gsymbol *, locus *);
2865 gfc_namespace* gfc_build_block_ns (gfc_namespace *);
2866
2867 /* dependency.c */
2868 int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
2869
2870 /* check.c */
2871 gfc_try gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*);
2872
2873 /* class.c */
2874 void gfc_add_component_ref (gfc_expr *, const char *);
2875 gfc_expr *gfc_class_null_initializer (gfc_typespec *);
2876 gfc_try gfc_build_class_symbol (gfc_typespec *, symbol_attribute *,
2877                                 gfc_array_spec **, bool);
2878 gfc_symbol *gfc_find_derived_vtab (gfc_symbol *);
2879 gfc_symtree* gfc_find_typebound_proc (gfc_symbol*, gfc_try*,
2880                                       const char*, bool, locus*);
2881 gfc_symtree* gfc_find_typebound_user_op (gfc_symbol*, gfc_try*,
2882                                          const char*, bool, locus*);
2883 gfc_typebound_proc* gfc_find_typebound_intrinsic_op (gfc_symbol*, gfc_try*,
2884                                                      gfc_intrinsic_op, bool,
2885                                                      locus*);
2886 gfc_symtree* gfc_get_tbp_symtree (gfc_symtree**, const char*);
2887
2888 #define CLASS_DATA(sym) sym->ts.u.derived->components
2889
2890 /* frontend-passes.c */
2891
2892 void gfc_run_passes (gfc_namespace *);
2893
2894 typedef int (*walk_code_fn_t) (gfc_code **, int *, void *);
2895 typedef int (*walk_expr_fn_t) (gfc_expr **, int *, void *);
2896
2897 int gfc_expr_walker (gfc_expr **, walk_expr_fn_t, void *);
2898 int gfc_code_walker (gfc_code **, walk_code_fn_t, walk_expr_fn_t, void *);
2899
2900 #endif /* GCC_GFORTRAN_H  */