OSDN Git Service

641e492ba648a8c56ce1f3534a974cb43ace8b88
[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   /* Set if this is the master function for a function with multiple
435      entry points where characteristics of the entry points differ.  */
436   unsigned mixed_entry_master:1;
437
438   /* Set if a function must always be referenced by an explicit interface.  */
439   unsigned always_explicit:1;
440
441   /* Set if the symbol has been referenced in an expression.  No further
442      modification of type or type parameters is permitted.  */
443   unsigned referenced:1;
444
445   /* Mutually exclusive multibit attributes.  */
446   ENUM_BITFIELD (gfc_access) access:2;
447   ENUM_BITFIELD (sym_intent) intent:2;
448   ENUM_BITFIELD (sym_flavor) flavor:4;
449   ENUM_BITFIELD (ifsrc) if_source:2;
450
451   ENUM_BITFIELD (procedure_type) proc:3;
452
453 }
454 symbol_attribute;
455
456
457 /* The following three structures are used to identify a location in
458    the sources. 
459    
460    gfc_file is used to maintain a tree of the source files and how
461    they include each other
462
463    gfc_linebuf holds a single line of source code and information
464    which file it resides in
465
466    locus point to the sourceline and the character in the source
467    line.  
468 */
469
470 typedef struct gfc_file 
471 {
472   struct gfc_file *included_by, *next, *up;
473   int inclusion_line, line;
474   char *filename;
475 } gfc_file;
476
477 typedef struct gfc_linebuf 
478 {
479 #ifdef USE_MAPPED_LOCATION
480   source_location location;
481 #else
482   int linenum;
483 #endif
484   struct gfc_file *file;
485   struct gfc_linebuf *next;
486
487   int truncated;
488
489   char line[1];
490 } gfc_linebuf;
491
492 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
493
494 typedef struct 
495 {
496   char *nextc;
497   gfc_linebuf *lb;
498 } locus;
499
500
501 #include <limits.h>
502 #ifndef PATH_MAX
503 # include <sys/param.h>
504 # define PATH_MAX MAXPATHLEN
505 #endif
506
507
508 extern int gfc_suppress_error;
509
510
511 /* Character length structures hold the expression that gives the
512    length of a character variable.  We avoid putting these into
513    gfc_typespec because doing so prevents us from doing structure
514    copies and forces us to deallocate any typespecs we create, as well
515    as structures that contain typespecs.  They also can have multiple
516    character typespecs pointing to them.
517
518    These structures form a singly linked list within the current
519    namespace and are deallocated with the namespace.  It is possible to
520    end up with gfc_charlen structures that have nothing pointing to them.  */
521
522 typedef struct gfc_charlen
523 {
524   struct gfc_expr *length;
525   struct gfc_charlen *next;
526   tree backend_decl;
527 }
528 gfc_charlen;
529
530 #define gfc_get_charlen() gfc_getmem(sizeof(gfc_charlen))
531
532 /* Type specification structure.  FIXME: derived and cl could be union???  */
533 typedef struct
534 {
535   bt type;
536   int kind;
537   struct gfc_symbol *derived;
538   gfc_charlen *cl;      /* For character types only.  */
539 }
540 gfc_typespec;
541
542 /* Array specification.  */
543 typedef struct
544 {
545   int rank;     /* A rank of zero means that a variable is a scalar.  */
546   array_type type;
547   struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
548 }
549 gfc_array_spec;
550
551 #define gfc_get_array_spec() gfc_getmem(sizeof(gfc_array_spec))
552
553
554 /* Components of derived types.  */
555 typedef struct gfc_component
556 {
557   const char *name;
558   gfc_typespec ts;
559
560   int pointer, dimension;
561   gfc_array_spec *as;
562
563   tree backend_decl;
564   locus loc;
565   struct gfc_expr *initializer;
566   struct gfc_component *next;
567 }
568 gfc_component;
569
570 #define gfc_get_component() gfc_getmem(sizeof(gfc_component))
571
572 /* Formal argument lists are lists of symbols.  */
573 typedef struct gfc_formal_arglist
574 {
575   /* Symbol representing the argument at this position in the arglist.  */
576   struct gfc_symbol *sym;
577   /* Points to the next formal argument.  */
578   struct gfc_formal_arglist *next;
579 }
580 gfc_formal_arglist;
581
582 #define gfc_get_formal_arglist() gfc_getmem(sizeof(gfc_formal_arglist))
583
584
585 /* The gfc_actual_arglist structure is for actual arguments.  */
586 typedef struct gfc_actual_arglist
587 {
588   const char *name;
589   /* Alternate return label when the expr member is null.  */
590   struct gfc_st_label *label;
591
592   /* This is set to the type of an eventual omitted optional
593      argument. This is used to determine if a hidden string length
594      argument has to be added to a function call.  */
595   bt missing_arg_type;
596
597   struct gfc_expr *expr;
598   struct gfc_actual_arglist *next;
599 }
600 gfc_actual_arglist;
601
602 #define gfc_get_actual_arglist() gfc_getmem(sizeof(gfc_actual_arglist))
603
604
605 /* Because a symbol can belong to multiple namelists, they must be
606    linked externally to the symbol itself.  */
607 typedef struct gfc_namelist
608 {
609   struct gfc_symbol *sym;
610   struct gfc_namelist *next;
611 }
612 gfc_namelist;
613
614 #define gfc_get_namelist() gfc_getmem(sizeof(gfc_namelist))
615
616
617 /* The gfc_st_label structure is a doubly linked list attached to a
618    namespace that records the usage of statement labels within that
619    space.  */
620 /* TODO: Make format/statement specifics a union.  */
621 typedef struct gfc_st_label
622 {
623   int value;
624
625   gfc_sl_type defined, referenced;
626
627   struct gfc_expr *format;
628
629   tree backend_decl;
630
631   locus where;
632
633   struct gfc_st_label *prev, *next;
634 }
635 gfc_st_label;
636
637
638 /* gfc_interface()-- Interfaces are lists of symbols strung together.  */
639 typedef struct gfc_interface
640 {
641   struct gfc_symbol *sym;
642   locus where;
643   struct gfc_interface *next;
644 }
645 gfc_interface;
646
647 #define gfc_get_interface() gfc_getmem(sizeof(gfc_interface))
648
649
650 /* User operator nodes.  These are like stripped down symbols.  */
651 typedef struct
652 {
653   const char *name;
654
655   gfc_interface *operator;
656   struct gfc_namespace *ns;
657   gfc_access access;
658 }
659 gfc_user_op;
660
661 /* Symbol nodes.  These are important things.  They are what the
662    standard refers to as "entities".  The possibly multiple names that
663    refer to the same entity are accomplished by a binary tree of
664    symtree structures that is balanced by the red-black method-- more
665    than one symtree node can point to any given symbol.  */
666
667 typedef struct gfc_symbol
668 {
669   const char *name;     /* Primary name, before renaming */
670   const char *module;   /* Module this symbol came from */
671   locus declared_at;
672
673   gfc_typespec ts;
674   symbol_attribute attr;
675
676   /* The interface member points to the formal argument list if the
677      symbol is a function or subroutine name.  If the symbol is a
678      generic name, the generic member points to the list of
679      interfaces.  */
680
681   gfc_interface *generic;
682   gfc_access component_access;
683
684   gfc_formal_arglist *formal;
685   struct gfc_namespace *formal_ns;
686
687   struct gfc_expr *value;       /* Parameter/Initializer value */
688   gfc_array_spec *as;
689   struct gfc_symbol *result;    /* function result symbol */
690   gfc_component *components;    /* Derived type components */
691
692   struct gfc_symbol *common_next;       /* Links for COMMON syms */
693   /* Make sure setup code for dummy arguments is generated in the correct
694      order.  */
695   int dummy_order;
696
697   gfc_namelist *namelist, *namelist_tail;
698
699   /* Change management fields.  Symbols that might be modified by the
700      current statement have the mark member nonzero and are kept in a
701      singly linked list through the tlink field.  Of these symbols,
702      symbols with old_symbol equal to NULL are symbols created within
703      the current statement.  Otherwise, old_symbol points to a copy of
704      the old symbol.  */
705
706   struct gfc_symbol *old_symbol, *tlink;
707   unsigned mark:1, new:1;
708   /* Nonzero if all equivalences associated with this symbol have been
709      processed.  */
710   unsigned equiv_built:1;
711   int refs;
712   struct gfc_namespace *ns;     /* namespace containing this symbol */
713
714   tree backend_decl;
715 }
716 gfc_symbol;
717
718
719 /* This structure is used to keep track of symbols in common blocks.  */
720
721 typedef struct
722 {
723   locus where;
724   int use_assoc, saved;
725   char name[GFC_MAX_SYMBOL_LEN + 1];
726   gfc_symbol *head;
727
728 gfc_common_head;
729
730 #define gfc_get_common_head() gfc_getmem(sizeof(gfc_common_head))
731
732
733 /* A list of all the alternate entry points for a procedure.  */
734
735 typedef struct gfc_entry_list
736 {
737   /* The symbol for this entry point.  */
738   gfc_symbol *sym;
739   /* The zero-based id of this entry point.  */
740   int id;
741   /* The LABEL_EXPR marking this entry point.  */
742   tree label;
743   /* The nest item in the list.  */
744   struct gfc_entry_list *next;
745 }
746 gfc_entry_list;
747
748 #define gfc_get_entry_list() \
749   (gfc_entry_list *) gfc_getmem(sizeof(gfc_entry_list))
750
751 /* Within a namespace, symbols are pointed to by symtree nodes that
752    are linked together in a balanced binary tree.  There can be
753    several symtrees pointing to the same symbol node via USE
754    statements.  */
755
756 #define BBT_HEADER(self) int priority; struct self *left, *right
757
758 typedef struct gfc_symtree
759 {
760   BBT_HEADER (gfc_symtree);
761   const char *name;
762   int ambiguous;
763   union
764   {
765     gfc_symbol *sym;            /* Symbol associated with this node */
766     gfc_user_op *uop;
767     gfc_common_head *common;
768   }
769   n;
770
771 }
772 gfc_symtree;
773
774
775 /* A namespace describes the contents of procedure, module or
776    interface block.  */
777 /* ??? Anything else use these?  */
778
779 typedef struct gfc_namespace
780 {
781   /* Tree containing all the symbols in this namespace.  */
782   gfc_symtree *sym_root;
783   /* Tree containing all the user-defined operators in the namespace.  */
784   gfc_symtree *uop_root;
785   /* Tree containing all the common blocks.  */
786   gfc_symtree *common_root;     
787
788   /* If set_flag[letter] is set, an implicit type has been set for letter.  */
789   int set_flag[GFC_LETTERS];
790   /* Keeps track of the implicit types associated with the letters.  */
791   gfc_typespec default_type[GFC_LETTERS];
792
793   /* If this is a namespace of a procedure, this points to the procedure.  */
794   struct gfc_symbol *proc_name;
795   /* If this is the namespace of a unit which contains executable
796      code, this points to it.  */
797   struct gfc_code *code;
798
799   /* Points to the equivalences set up in this namespace.  */
800   struct gfc_equiv *equiv;
801   gfc_interface *operator[GFC_INTRINSIC_OPS];
802
803   /* Points to the parent namespace, i.e. the namespace of a module or
804      procedure in which the procedure belonging to this namespace is
805      contained. The parent namespace points to this namespace either
806      directly via CONTAINED, or indirectly via the chain built by
807      SIBLING.  */
808   struct gfc_namespace *parent;
809   /* CONTAINED points to the first contained namespace. Sibling
810      namespaces are chained via SIBLING.  */
811   struct gfc_namespace  *contained, *sibling;
812
813   gfc_common_head blank_common;
814   gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
815
816   gfc_st_label *st_labels;
817   /* This list holds information about all the data initializers in
818      this namespace.  */
819   struct gfc_data *data;
820
821   gfc_charlen *cl_list;
822
823   int save_all, seen_save, seen_implicit_none;
824
825   /* Normally we don't need to refcount namespaces.  However when we read
826      a module containing a function with multiple entry points, this
827      will appear as several functions with the same formal namespace.  */
828   int refs;
829
830   /* A list of all alternate entry points to this procedure (or NULL).  */
831   gfc_entry_list *entries;
832
833   /* Set to 1 if namespace is a BLOCK DATA program unit.  */
834   int is_block_data;
835 }
836 gfc_namespace;
837
838 extern gfc_namespace *gfc_current_ns;
839
840 /* Global symbols are symbols of global scope. Currently we only use
841    this to detect collisions already when parsing.
842    TODO: Extend to verify procedure calls.  */
843
844 typedef struct gfc_gsymbol
845 {
846   BBT_HEADER(gfc_gsymbol);
847
848   const char *name;
849   enum { GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
850         GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA } type;
851
852   int defined, used;
853   locus where;
854 }
855 gfc_gsymbol;
856
857 extern gfc_gsymbol *gfc_gsym_root;
858
859 /* Information on interfaces being built.  */
860 typedef struct
861 {
862   interface_type type;
863   gfc_symbol *sym;
864   gfc_namespace *ns;
865   gfc_user_op *uop;
866   gfc_intrinsic_op op;
867 }
868 gfc_interface_info;
869
870 extern gfc_interface_info current_interface;
871
872
873 /* Array reference.  */
874 typedef struct gfc_array_ref
875 {
876   ar_type type;
877   int dimen;                    /* # of components in the reference */
878   locus where;
879   gfc_array_spec *as;
880
881   locus c_where[GFC_MAX_DIMENSIONS];    /* All expressions can be NULL */
882   struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
883     *stride[GFC_MAX_DIMENSIONS];
884
885   enum
886   { DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_UNKNOWN }
887   dimen_type[GFC_MAX_DIMENSIONS];
888
889   struct gfc_expr *offset;
890 }
891 gfc_array_ref;
892
893 #define gfc_get_array_ref() gfc_getmem(sizeof(gfc_array_ref))
894
895
896 /* Component reference nodes.  A variable is stored as an expression
897    node that points to the base symbol.  After that, a singly linked
898    list of component reference nodes gives the variable's complete
899    resolution.  The array_ref component may be present and comes
900    before the component component.  */
901
902 typedef enum
903   { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING }
904 ref_type;
905
906 typedef struct gfc_ref
907 {
908   ref_type type;
909
910   union
911   {
912     struct gfc_array_ref ar;
913
914     struct
915     {
916       gfc_component *component;
917       gfc_symbol *sym;
918     }
919     c;
920
921     struct
922     {
923       struct gfc_expr *start, *end;     /* Substring */
924       gfc_charlen *length;
925     }
926     ss;
927
928   }
929   u;
930
931   struct gfc_ref *next;
932 }
933 gfc_ref;
934
935 #define gfc_get_ref() gfc_getmem(sizeof(gfc_ref))
936
937
938 /* Structures representing intrinsic symbols and their arguments lists.  */
939 typedef struct gfc_intrinsic_arg
940 {
941   char name[GFC_MAX_SYMBOL_LEN + 1];
942
943   gfc_typespec ts;
944   int optional;
945   gfc_actual_arglist *actual;
946
947   struct gfc_intrinsic_arg *next;
948
949 }
950 gfc_intrinsic_arg;
951
952
953 /* Specifies the various kinds of check functions used to verify the
954    argument lists of intrinsic functions. fX with X an integer refer
955    to check functions of intrinsics with X arguments. f1m is used for
956    the MAX and MIN intrinsics which can have an arbitrary number of
957    arguments, f3ml is used for the MINLOC and MAXLOC intrinsics as
958    these have special semantics.  */
959
960 typedef union
961 {
962   try (*f0)(void);
963   try (*f1)(struct gfc_expr *);
964   try (*f1m)(gfc_actual_arglist *);
965   try (*f2)(struct gfc_expr *, struct gfc_expr *);
966   try (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
967   try (*f3ml)(gfc_actual_arglist *);
968   try (*f3red)(gfc_actual_arglist *);
969   try (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
970             struct gfc_expr *);
971   try (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
972             struct gfc_expr *, struct gfc_expr *);
973 }
974 gfc_check_f;
975
976 /* Like gfc_check_f, these specify the type of the simplification
977    function associated with an intrinsic. The fX are just like in
978    gfc_check_f. cc is used for type conversion functions.  */
979
980 typedef union
981 {
982   struct gfc_expr *(*f0)(void);
983   struct gfc_expr *(*f1)(struct gfc_expr *);
984   struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
985   struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
986                          struct gfc_expr *);
987   struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
988                          struct gfc_expr *, struct gfc_expr *);
989   struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
990                          struct gfc_expr *, struct gfc_expr *,
991                          struct gfc_expr *);
992   struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
993 }
994 gfc_simplify_f;
995
996 /* Again like gfc_check_f, these specify the type of the resolution
997    function associated with an intrinsic. The fX are just like in
998    gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort().
999    */
1000
1001 typedef union
1002 {
1003   void (*f0)(struct gfc_expr *);
1004   void (*f1)(struct gfc_expr *, struct gfc_expr *);
1005   void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
1006   void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1007   void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1008              struct gfc_expr *);
1009   void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1010              struct gfc_expr *, struct gfc_expr *);
1011   void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1012              struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1013   void (*s1)(struct gfc_code *);
1014 }
1015 gfc_resolve_f;
1016
1017
1018 typedef struct gfc_intrinsic_sym
1019 {
1020   const char *name, *lib_name;
1021   gfc_intrinsic_arg *formal;
1022   gfc_typespec ts;
1023   int elemental, pure, generic, specific, actual_ok, standard;
1024
1025   gfc_simplify_f simplify;
1026   gfc_check_f check;
1027   gfc_resolve_f resolve;
1028   struct gfc_intrinsic_sym *specific_head, *next;
1029   gfc_generic_isym_id generic_id;
1030
1031 }
1032 gfc_intrinsic_sym;
1033
1034
1035 /* Expression nodes.  The expression node types deserve explanations,
1036    since the last couple can be easily misconstrued:
1037
1038    EXPR_OP         Operator node pointing to one or two other nodes
1039    EXPR_FUNCTION   Function call, symbol points to function's name
1040    EXPR_CONSTANT   A scalar constant: Logical, String, Real, Int or Complex
1041    EXPR_VARIABLE   An Lvalue with a root symbol and possible reference list
1042                    which expresses structure, array and substring refs.
1043    EXPR_NULL       The NULL pointer value (which also has a basic type).
1044    EXPR_SUBSTRING  A substring of a constant string
1045    EXPR_STRUCTURE  A structure constructor
1046    EXPR_ARRAY      An array constructor.  */
1047
1048 #include <gmp.h>
1049 #include <mpfr.h>
1050 #define GFC_RND_MODE GMP_RNDN
1051
1052 typedef struct gfc_expr
1053 {
1054   expr_t expr_type;
1055
1056   gfc_typespec ts;      /* These two refer to the overall expression */
1057
1058   int rank;
1059   mpz_t *shape;         /* Can be NULL if shape is unknown at compile time */
1060
1061   /* Nonnull for functions and structure constructors */
1062   gfc_symtree *symtree;
1063
1064   gfc_ref *ref;
1065
1066   locus where;
1067
1068   union
1069   {
1070     int logical;
1071     mpz_t integer;
1072
1073     mpfr_t real;
1074
1075     struct
1076     {
1077       mpfr_t r, i;
1078     }
1079     complex;
1080
1081     struct
1082     {
1083       gfc_intrinsic_op operator;
1084       gfc_user_op *uop;
1085       struct gfc_expr *op1, *op2;
1086     }
1087     op;
1088
1089     struct
1090     {
1091       gfc_actual_arglist *actual;
1092       const char *name; /* Points to the ultimate name of the function */
1093       gfc_intrinsic_sym *isym;
1094       gfc_symbol *esym;
1095     }
1096     function;
1097
1098     struct
1099     {
1100       int length;
1101       char *string;
1102     }
1103     character;
1104
1105     struct gfc_constructor *constructor;
1106   }
1107   value;
1108
1109 }
1110 gfc_expr;
1111
1112
1113 #define gfc_get_shape(rank) ((mpz_t *) gfc_getmem((rank)*sizeof(mpz_t)))
1114
1115 /* Structures for information associated with different kinds of
1116    numbers.  The first set of integer parameters define all there is
1117    to know about a particular kind.  The rest of the elements are
1118    computed from the first elements.  */
1119
1120 typedef struct
1121 {
1122   /* Values really representable by the target.  */
1123   mpz_t huge, pedantic_min_int, min_int, max_int;
1124
1125   int kind, radix, digits, bit_size, range;
1126
1127   /* True if the C type of the given name maps to this precision.
1128      Note that more than one bit can be set.  */
1129   unsigned int c_char : 1;
1130   unsigned int c_short : 1;
1131   unsigned int c_int : 1;
1132   unsigned int c_long : 1;
1133   unsigned int c_long_long : 1;
1134 }
1135 gfc_integer_info;
1136
1137 extern gfc_integer_info gfc_integer_kinds[];
1138
1139
1140 typedef struct
1141 {
1142   int kind, bit_size;
1143
1144   /* True if the C++ type bool, C99 type _Bool, maps to this precision.  */
1145   unsigned int c_bool : 1;
1146 }
1147 gfc_logical_info;
1148
1149 extern gfc_logical_info gfc_logical_kinds[];
1150
1151
1152 typedef struct
1153 {
1154   mpfr_t epsilon, huge, tiny, subnormal;
1155   int kind, radix, digits, min_exponent, max_exponent;
1156   int range, precision;
1157
1158   /* The precision of the type as reported by GET_MODE_PRECISION.  */
1159   int mode_precision;
1160
1161   /* True if the C type of the given name maps to this precision.
1162      Note that more than one bit can be set.  */
1163   unsigned int c_float : 1;
1164   unsigned int c_double : 1;
1165   unsigned int c_long_double : 1;
1166 }
1167 gfc_real_info;
1168
1169 extern gfc_real_info gfc_real_kinds[];
1170
1171
1172 /* Equivalence structures.  Equivalent lvalues are linked along the
1173    *eq pointer, equivalence sets are strung along the *next node.  */
1174 typedef struct gfc_equiv
1175 {
1176   struct gfc_equiv *next, *eq;
1177   gfc_expr *expr;
1178   int used;
1179 }
1180 gfc_equiv;
1181
1182 #define gfc_get_equiv() gfc_getmem(sizeof(gfc_equiv))
1183
1184
1185 /* gfc_case stores the selector list of a case statement.  The *low
1186    and *high pointers can point to the same expression in the case of
1187    a single value.  If *high is NULL, the selection is from *low
1188    upwards, if *low is NULL the selection is *high downwards.
1189
1190    This structure has separate fields to allow single and double linked
1191    lists of CASEs at the same time.  The singe linked list along the NEXT
1192    field is a list of cases for a single CASE label.  The double linked
1193    list along the LEFT/RIGHT fields is used to detect overlap and to
1194    build a table of the cases for SELECT constructs with a CHARACTER
1195    case expression.  */
1196
1197 typedef struct gfc_case
1198 {
1199   /* Where we saw this case.  */
1200   locus where;
1201   int n;
1202
1203   /* Case range values.  If (low == high), it's a single value.  If one of
1204      the labels is NULL, it's an unbounded case.  If both are NULL, this
1205      represents the default case.  */
1206   gfc_expr *low, *high;
1207
1208   /* Next case label in the list of cases for a single CASE label.  */
1209   struct gfc_case *next;
1210
1211   /* Used for detecting overlap, and for code generation.  */
1212   struct gfc_case *left, *right;
1213
1214   /* True if this case label can never be matched.  */
1215   int unreachable;
1216 }
1217 gfc_case;
1218
1219 #define gfc_get_case() gfc_getmem(sizeof(gfc_case))
1220
1221
1222 typedef struct
1223 {
1224   gfc_expr *var, *start, *end, *step;
1225 }
1226 gfc_iterator;
1227
1228 #define gfc_get_iterator() gfc_getmem(sizeof(gfc_iterator))
1229
1230
1231 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements.  */
1232
1233 typedef struct gfc_alloc
1234 {
1235   gfc_expr *expr;
1236   struct gfc_alloc *next;
1237 }
1238 gfc_alloc;
1239
1240 #define gfc_get_alloc() gfc_getmem(sizeof(gfc_alloc))
1241
1242
1243 typedef struct
1244 {
1245   gfc_expr *unit, *file, *status, *access, *form, *recl,
1246     *blank, *position, *action, *delim, *pad, *iostat;
1247   gfc_st_label *err;
1248 }
1249 gfc_open;
1250
1251
1252 typedef struct
1253 {
1254   gfc_expr *unit, *status, *iostat;
1255   gfc_st_label *err;
1256 }
1257 gfc_close;
1258
1259
1260 typedef struct
1261 {
1262   gfc_expr *unit, *iostat;
1263   gfc_st_label *err;
1264 }
1265 gfc_filepos;
1266
1267
1268 typedef struct
1269 {
1270   gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
1271     *name, *access, *sequential, *direct, *form, *formatted,
1272     *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
1273     *write, *readwrite, *delim, *pad, *iolength;
1274
1275   gfc_st_label *err;
1276
1277 }
1278 gfc_inquire;
1279
1280
1281 typedef struct
1282 {
1283   gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size;
1284
1285   gfc_symbol *namelist;
1286   /* A format_label of `format_asterisk' indicates the "*" format */
1287   gfc_st_label *format_label;
1288   gfc_st_label *err, *end, *eor;
1289
1290   locus eor_where, end_where;
1291 }
1292 gfc_dt;
1293
1294
1295 typedef struct gfc_forall_iterator
1296 {
1297   gfc_expr *var, *start, *end, *stride;
1298   struct gfc_forall_iterator *next;
1299 }
1300 gfc_forall_iterator;
1301
1302
1303 /* Executable statements that fill gfc_code structures.  */
1304 typedef enum
1305 {
1306   EXEC_NOP = 1, EXEC_ASSIGN, EXEC_LABEL_ASSIGN, EXEC_POINTER_ASSIGN,
1307   EXEC_GOTO, EXEC_CALL, EXEC_RETURN, EXEC_ENTRY,
1308   EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE,
1309   EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_WHILE, EXEC_SELECT,
1310   EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT,
1311   EXEC_ALLOCATE, EXEC_DEALLOCATE,
1312   EXEC_OPEN, EXEC_CLOSE,
1313   EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
1314   EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND
1315 }
1316 gfc_exec_op;
1317
1318 typedef struct gfc_code
1319 {
1320   gfc_exec_op op;
1321
1322   struct gfc_code *block, *next;
1323   locus loc;
1324
1325   gfc_st_label *here, *label, *label2, *label3;
1326   gfc_symtree *symtree;
1327   gfc_expr *expr, *expr2;
1328   /* A name isn't sufficient to identify a subroutine, we need the actual
1329      symbol for the interface definition.
1330   const char *sub_name;  */
1331   gfc_symbol *resolved_sym;
1332
1333   union
1334   {
1335     gfc_actual_arglist *actual;
1336     gfc_case *case_list;
1337     gfc_iterator *iterator;
1338     gfc_alloc *alloc_list;
1339     gfc_open *open;
1340     gfc_close *close;
1341     gfc_filepos *filepos;
1342     gfc_inquire *inquire;
1343     gfc_dt *dt;
1344     gfc_forall_iterator *forall_iterator;
1345     struct gfc_code *whichloop;
1346     int stop_code;
1347     gfc_entry_list *entry;
1348   }
1349   ext;          /* Points to additional structures required by statement */
1350
1351   /* Backend_decl is used for cycle and break labels in do loops, and
1352    * probably for other constructs as well, once we translate them.  */
1353   tree backend_decl;
1354 }
1355 gfc_code;
1356
1357
1358 /* Storage for DATA statements.  */
1359 typedef struct gfc_data_variable
1360 {
1361   gfc_expr *expr;
1362   gfc_iterator iter;
1363   struct gfc_data_variable *list, *next;
1364 }
1365 gfc_data_variable;
1366
1367
1368 typedef struct gfc_data_value
1369 {
1370   unsigned int repeat;
1371   gfc_expr *expr;
1372   struct gfc_data_value *next;
1373 }
1374 gfc_data_value;
1375
1376
1377 typedef struct gfc_data
1378 {
1379   gfc_data_variable *var;
1380   gfc_data_value *value;
1381   locus where;
1382
1383   struct gfc_data *next;
1384 }
1385 gfc_data;
1386
1387 #define gfc_get_data_variable() gfc_getmem(sizeof(gfc_data_variable))
1388 #define gfc_get_data_value() gfc_getmem(sizeof(gfc_data_value))
1389 #define gfc_get_data() gfc_getmem(sizeof(gfc_data))
1390
1391
1392 /* Structure for holding compile options */
1393 typedef struct
1394 {
1395   const char *source;
1396   char *module_dir;
1397   gfc_source_form source_form;
1398   int fixed_line_length;
1399   int max_identifier_length;
1400   int verbose;
1401
1402   int warn_aliasing;
1403   int warn_conversion;
1404   int warn_implicit_interface;
1405   int warn_line_truncation;
1406   int warn_underflow;
1407   int warn_surprising;
1408   int warn_unused_labels;
1409
1410   int flag_default_double;
1411   int flag_default_integer;
1412   int flag_default_real;
1413   int flag_dollar_ok;
1414   int flag_underscoring;
1415   int flag_second_underscore;
1416   int flag_implicit_none;
1417   int flag_max_stack_var_size;
1418   int flag_module_access_private;
1419   int flag_no_backend;
1420   int flag_pack_derived;
1421   int flag_repack_arrays;
1422
1423   int q_kind;
1424
1425   int warn_std;
1426   int allow_std;
1427   int warn_nonstd_intrinsics;
1428 }
1429 gfc_option_t;
1430
1431 extern gfc_option_t gfc_option;
1432
1433
1434 /* Constructor nodes for array and structure constructors.  */
1435 typedef struct gfc_constructor
1436 {
1437   gfc_expr *expr;
1438   gfc_iterator *iterator;
1439   locus where;
1440   struct gfc_constructor *next;
1441   struct
1442   {
1443     mpz_t offset; /* Record the offset of array element which appears in
1444                      data statement like "data a(5)/4/".  */
1445     gfc_component *component; /* Record the component being initialized.  */
1446   }
1447   n;
1448   mpz_t repeat; /* Record the repeat number of initial values in data
1449                  statement like "data a/5*10/".  */
1450 }
1451 gfc_constructor;
1452
1453
1454 typedef struct iterator_stack
1455 {
1456   gfc_symtree *variable;
1457   mpz_t value;
1458   struct iterator_stack *prev;
1459 }
1460 iterator_stack;
1461 extern iterator_stack *iter_stack;
1462
1463 /************************ Function prototypes *************************/
1464
1465 /* data.c  */
1466 void gfc_formalize_init_value (gfc_symbol *);
1467 void gfc_get_section_index (gfc_array_ref *, mpz_t *, mpz_t *);
1468 void gfc_assign_data_value (gfc_expr *, gfc_expr *, mpz_t);
1469 void gfc_assign_data_value_range (gfc_expr *, gfc_expr *, mpz_t, mpz_t);
1470 void gfc_advance_section (mpz_t *, gfc_array_ref *, mpz_t *);
1471
1472 /* scanner.c */
1473 void gfc_scanner_done_1 (void);
1474 void gfc_scanner_init_1 (void);
1475
1476 void gfc_add_include_path (const char *);
1477 void gfc_release_include_path (void);
1478 FILE *gfc_open_included_file (const char *);
1479
1480 int gfc_at_end (void);
1481 int gfc_at_eof (void);
1482 int gfc_at_bol (void);
1483 int gfc_at_eol (void);
1484 void gfc_advance_line (void);
1485 int gfc_check_include (void);
1486
1487 void gfc_skip_comments (void);
1488 int gfc_next_char_literal (int);
1489 int gfc_next_char (void);
1490 int gfc_peek_char (void);
1491 void gfc_error_recovery (void);
1492 void gfc_gobble_whitespace (void);
1493 try gfc_new_file (const char *, gfc_source_form);
1494
1495 extern gfc_source_form gfc_current_form;
1496 extern char *gfc_source_file;
1497 extern locus gfc_current_locus;
1498
1499 /* misc.c */
1500 void *gfc_getmem (size_t) ATTRIBUTE_MALLOC;
1501 void gfc_free (void *);
1502 int gfc_terminal_width(void);
1503 void gfc_clear_ts (gfc_typespec *);
1504 FILE *gfc_open_file (const char *);
1505 const char *gfc_article (const char *);
1506 const char *gfc_basic_typename (bt);
1507 const char *gfc_typename (gfc_typespec *);
1508
1509 #define gfc_op2string(OP) (OP == INTRINSIC_ASSIGN ? \
1510                            "=" : gfc_code2string (intrinsic_operators, OP))
1511
1512 const char *gfc_code2string (const mstring *, int);
1513 int gfc_string2code (const mstring *, const char *);
1514 const char *gfc_intent_string (sym_intent);
1515
1516 void gfc_init_1 (void);
1517 void gfc_init_2 (void);
1518 void gfc_done_1 (void);
1519 void gfc_done_2 (void);
1520
1521 /* options.c */
1522 unsigned int gfc_init_options (unsigned int, const char **);
1523 int gfc_handle_option (size_t, const char *, int);
1524 bool gfc_post_options (const char **);
1525
1526 /* iresolve.c */
1527 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
1528
1529 /* error.c */
1530
1531 typedef struct gfc_error_buf
1532 {
1533   int flag;
1534   char message[MAX_ERROR_MESSAGE];
1535 } gfc_error_buf;
1536
1537 void gfc_error_init_1 (void);
1538 void gfc_buffer_error (int);
1539
1540 void gfc_warning (const char *, ...);
1541 void gfc_warning_now (const char *, ...);
1542 void gfc_clear_warning (void);
1543 void gfc_warning_check (void);
1544
1545 void gfc_error (const char *, ...);
1546 void gfc_error_now (const char *, ...);
1547 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN;
1548 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN;
1549 void gfc_clear_error (void);
1550 int gfc_error_check (void);
1551
1552 try gfc_notify_std (int, const char *, ...);
1553
1554 /* A general purpose syntax error.  */
1555 #define gfc_syntax_error(ST)    \
1556   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
1557
1558 void gfc_push_error (gfc_error_buf *);
1559 void gfc_pop_error (gfc_error_buf *);
1560
1561 void gfc_status (const char *, ...) ATTRIBUTE_PRINTF_1;
1562 void gfc_status_char (char);
1563
1564 void gfc_get_errors (int *, int *);
1565
1566 /* arith.c */
1567 void gfc_arith_init_1 (void);
1568 void gfc_arith_done_1 (void);
1569
1570 /* trans-types.c */
1571 int gfc_validate_kind (bt, int, bool);
1572 extern int gfc_index_integer_kind;
1573 extern int gfc_default_integer_kind;
1574 extern int gfc_max_integer_kind;
1575 extern int gfc_default_real_kind;
1576 extern int gfc_default_double_kind;
1577 extern int gfc_default_character_kind;
1578 extern int gfc_default_logical_kind;
1579 extern int gfc_default_complex_kind;
1580 extern int gfc_c_int_kind;
1581
1582 /* symbol.c */
1583 void gfc_clear_new_implicit (void);
1584 try gfc_add_new_implicit_range (int, int);
1585 try gfc_merge_new_implicit (gfc_typespec *);
1586 void gfc_set_implicit_none (void);
1587
1588 gfc_typespec *gfc_get_default_type (gfc_symbol *, gfc_namespace *);
1589 try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
1590
1591 void gfc_set_component_attr (gfc_component *, symbol_attribute *);
1592 void gfc_get_component_attr (symbol_attribute *, gfc_component *);
1593
1594 void gfc_set_sym_referenced (gfc_symbol * sym);
1595
1596 try gfc_add_allocatable (symbol_attribute *, locus *);
1597 try gfc_add_dimension (symbol_attribute *, const char *, locus *);
1598 try gfc_add_external (symbol_attribute *, locus *);
1599 try gfc_add_intrinsic (symbol_attribute *, locus *);
1600 try gfc_add_optional (symbol_attribute *, locus *);
1601 try gfc_add_pointer (symbol_attribute *, locus *);
1602 try gfc_add_result (symbol_attribute *, const char *, locus *);
1603 try gfc_add_save (symbol_attribute *, const char *, locus *);
1604 try gfc_add_saved_common (symbol_attribute *, locus *);
1605 try gfc_add_target (symbol_attribute *, locus *);
1606 try gfc_add_dummy (symbol_attribute *, const char *, locus *);
1607 try gfc_add_generic (symbol_attribute *, const char *, locus *);
1608 try gfc_add_common (symbol_attribute *, locus *);
1609 try gfc_add_in_common (symbol_attribute *, const char *, locus *);
1610 try gfc_add_data (symbol_attribute *, const char *, locus *);
1611 try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
1612 try gfc_add_sequence (symbol_attribute *, const char *, locus *);
1613 try gfc_add_elemental (symbol_attribute *, locus *);
1614 try gfc_add_pure (symbol_attribute *, locus *);
1615 try gfc_add_recursive (symbol_attribute *, locus *);
1616 try gfc_add_function (symbol_attribute *, const char *, locus *);
1617 try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
1618
1619 try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
1620 try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
1621 try gfc_add_entry (symbol_attribute *, const char *, locus *);
1622 try gfc_add_procedure (symbol_attribute *, procedure_type,
1623                        const char *, locus *);
1624 try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
1625 try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
1626                                 gfc_formal_arglist *, locus *);
1627 try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
1628
1629 void gfc_clear_attr (symbol_attribute *);
1630 try gfc_missing_attr (symbol_attribute *, locus *);
1631 try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
1632
1633 try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
1634 gfc_symbol *gfc_use_derived (gfc_symbol *);
1635 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
1636 gfc_component *gfc_find_component (gfc_symbol *, const char *);
1637
1638 gfc_st_label *gfc_get_st_label (int);
1639 void gfc_free_st_label (gfc_st_label *);
1640 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
1641 try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
1642
1643 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
1644 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
1645 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
1646 gfc_user_op *gfc_get_uop (const char *);
1647 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
1648 void gfc_free_symbol (gfc_symbol *);
1649 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
1650 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
1651 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
1652 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
1653 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **);
1654 int gfc_get_ha_symbol (const char *, gfc_symbol **);
1655 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
1656
1657 int gfc_symbols_could_alias (gfc_symbol *, gfc_symbol *);
1658
1659 void gfc_undo_symbols (void);
1660 void gfc_commit_symbols (void);
1661 void gfc_free_namespace (gfc_namespace *);
1662
1663 void gfc_symbol_init_2 (void);
1664 void gfc_symbol_done_2 (void);
1665
1666 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
1667 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
1668 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
1669 void gfc_save_all (gfc_namespace *);
1670
1671 void gfc_symbol_state (void);
1672
1673 gfc_gsymbol *gfc_get_gsymbol (const char *);
1674 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
1675
1676 /* intrinsic.c */
1677 extern int gfc_init_expr;
1678
1679 /* Given a symbol that we have decided is intrinsic, mark it as such
1680    by placing it into a special module that is otherwise impossible to
1681    read or write.  */
1682
1683 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
1684
1685 void gfc_intrinsic_init_1 (void);
1686 void gfc_intrinsic_done_1 (void);
1687
1688 char gfc_type_letter (bt);
1689 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
1690 try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
1691 try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
1692 int gfc_generic_intrinsic (const char *);
1693 int gfc_specific_intrinsic (const char *);
1694 int gfc_intrinsic_name (const char *, int);
1695 gfc_intrinsic_sym *gfc_find_function (const char *);
1696
1697 match gfc_intrinsic_func_interface (gfc_expr *, int);
1698 match gfc_intrinsic_sub_interface (gfc_code *, int);
1699
1700 /* simplify.c */
1701 void gfc_simplify_init_1 (void);
1702
1703 /* match.c -- FIXME */
1704 void gfc_free_iterator (gfc_iterator *, int);
1705 void gfc_free_forall_iterator (gfc_forall_iterator *);
1706 void gfc_free_alloc_list (gfc_alloc *);
1707 void gfc_free_namelist (gfc_namelist *);
1708 void gfc_free_equiv (gfc_equiv *);
1709 void gfc_free_data (gfc_data *);
1710 void gfc_free_case_list (gfc_case *);
1711
1712 /* expr.c */
1713 void gfc_free_actual_arglist (gfc_actual_arglist *);
1714 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
1715 const char *gfc_extract_int (gfc_expr *, int *);
1716
1717 gfc_expr *gfc_build_conversion (gfc_expr *);
1718 void gfc_free_ref_list (gfc_ref *);
1719 void gfc_type_convert_binary (gfc_expr *);
1720 int gfc_is_constant_expr (gfc_expr *);
1721 try gfc_simplify_expr (gfc_expr *, int);
1722
1723 gfc_expr *gfc_get_expr (void);
1724 void gfc_free_expr (gfc_expr *);
1725 void gfc_replace_expr (gfc_expr *, gfc_expr *);
1726 gfc_expr *gfc_int_expr (int);
1727 gfc_expr *gfc_logical_expr (int, locus *);
1728 mpz_t *gfc_copy_shape (mpz_t *, int);
1729 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
1730 gfc_expr *gfc_copy_expr (gfc_expr *);
1731
1732 try gfc_specification_expr (gfc_expr *);
1733
1734 int gfc_numeric_ts (gfc_typespec *);
1735 int gfc_kind_max (gfc_expr *, gfc_expr *);
1736
1737 try gfc_check_conformance (const char *, gfc_expr *, gfc_expr *);
1738 try gfc_check_assign (gfc_expr *, gfc_expr *, int);
1739 try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
1740 try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
1741
1742 gfc_expr *gfc_default_initializer (gfc_typespec *);
1743 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
1744
1745
1746 /* st.c */
1747 extern gfc_code new_st;
1748
1749 void gfc_clear_new_st (void);
1750 gfc_code *gfc_get_code (void);
1751 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
1752 void gfc_free_statement (gfc_code *);
1753 void gfc_free_statements (gfc_code *);
1754
1755 /* resolve.c */
1756 try gfc_resolve_expr (gfc_expr *);
1757 void gfc_resolve (gfc_namespace *);
1758 int gfc_impure_variable (gfc_symbol *);
1759 int gfc_pure (gfc_symbol *);
1760 int gfc_elemental (gfc_symbol *);
1761 try gfc_resolve_iterator (gfc_iterator *, bool);
1762 try gfc_resolve_index (gfc_expr *, int);
1763
1764 /* array.c */
1765 void gfc_free_array_spec (gfc_array_spec *);
1766 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
1767
1768 try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
1769 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
1770 try gfc_resolve_array_spec (gfc_array_spec *, int);
1771
1772 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
1773
1774 gfc_expr *gfc_start_constructor (bt, int, locus *);
1775 void gfc_append_constructor (gfc_expr *, gfc_expr *);
1776 void gfc_free_constructor (gfc_constructor *);
1777 void gfc_simplify_iterator_var (gfc_expr *);
1778 try gfc_expand_constructor (gfc_expr *);
1779 int gfc_constant_ac (gfc_expr *);
1780 int gfc_expanded_ac (gfc_expr *);
1781 try gfc_resolve_array_constructor (gfc_expr *);
1782 try gfc_check_constructor_type (gfc_expr *);
1783 try gfc_check_iter_variable (gfc_expr *);
1784 try gfc_check_constructor (gfc_expr *, try (*)(gfc_expr *));
1785 gfc_constructor *gfc_copy_constructor (gfc_constructor * src);
1786 gfc_expr *gfc_get_array_element (gfc_expr *, int);
1787 try gfc_array_size (gfc_expr *, mpz_t *);
1788 try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
1789 try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
1790 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
1791 void gfc_insert_constructor (gfc_expr *, gfc_constructor *);
1792 gfc_constructor *gfc_get_constructor (void);
1793 tree gfc_conv_array_initializer (tree type, gfc_expr * expr);
1794 try spec_size (gfc_array_spec *, mpz_t *);
1795 int gfc_is_compile_time_shape (gfc_array_spec *);
1796
1797 /* interface.c -- FIXME: some of these should be in symbol.c */
1798 void gfc_free_interface (gfc_interface *);
1799 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
1800 void gfc_check_interfaces (gfc_namespace *);
1801 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
1802 gfc_symbol *gfc_search_interface (gfc_interface *, int,
1803                                   gfc_actual_arglist **);
1804 try gfc_extend_expr (gfc_expr *);
1805 void gfc_free_formal_arglist (gfc_formal_arglist *);
1806 try gfc_extend_assign (gfc_code *, gfc_namespace *);
1807 try gfc_add_interface (gfc_symbol * sym);
1808
1809 /* io.c */
1810 extern gfc_st_label format_asterisk;
1811
1812 void gfc_free_open (gfc_open *);
1813 try gfc_resolve_open (gfc_open *);
1814 void gfc_free_close (gfc_close *);
1815 try gfc_resolve_close (gfc_close *);
1816 void gfc_free_filepos (gfc_filepos *);
1817 try gfc_resolve_filepos (gfc_filepos *);
1818 void gfc_free_inquire (gfc_inquire *);
1819 try gfc_resolve_inquire (gfc_inquire *);
1820 void gfc_free_dt (gfc_dt *);
1821 try gfc_resolve_dt (gfc_dt *);
1822
1823 /* module.c */
1824 void gfc_module_init_2 (void);
1825 void gfc_module_done_2 (void);
1826 void gfc_dump_module (const char *, int);
1827 bool gfc_check_access (gfc_access, gfc_access);
1828
1829 /* primary.c */
1830 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
1831 symbol_attribute gfc_expr_attr (gfc_expr *);
1832
1833 /* trans.c */
1834 void gfc_generate_code (gfc_namespace *);
1835 void gfc_generate_module_code (gfc_namespace *);
1836
1837 /* bbt.c */
1838 typedef int (*compare_fn) (void *, void *);
1839 void gfc_insert_bbt (void *, void *, compare_fn);
1840 void gfc_delete_bbt (void *, void *, compare_fn);
1841
1842 /* dump-parse-tree.c */
1843 void gfc_show_namespace (gfc_namespace *);
1844
1845 /* parse.c */
1846 try gfc_parse_file (void);
1847
1848 #endif /* GCC_GFORTRAN_H  */