OSDN Git Service

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