OSDN Git Service

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