OSDN Git Service

gcc/fortran/
[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   int flag_f2c;
1423
1424   int q_kind;
1425
1426   int warn_std;
1427   int allow_std;
1428   int warn_nonstd_intrinsics;
1429 }
1430 gfc_option_t;
1431
1432 extern gfc_option_t gfc_option;
1433
1434
1435 /* Constructor nodes for array and structure constructors.  */
1436 typedef struct gfc_constructor
1437 {
1438   gfc_expr *expr;
1439   gfc_iterator *iterator;
1440   locus where;
1441   struct gfc_constructor *next;
1442   struct
1443   {
1444     mpz_t offset; /* Record the offset of array element which appears in
1445                      data statement like "data a(5)/4/".  */
1446     gfc_component *component; /* Record the component being initialized.  */
1447   }
1448   n;
1449   mpz_t repeat; /* Record the repeat number of initial values in data
1450                  statement like "data a/5*10/".  */
1451 }
1452 gfc_constructor;
1453
1454
1455 typedef struct iterator_stack
1456 {
1457   gfc_symtree *variable;
1458   mpz_t value;
1459   struct iterator_stack *prev;
1460 }
1461 iterator_stack;
1462 extern iterator_stack *iter_stack;
1463
1464 /************************ Function prototypes *************************/
1465
1466 /* data.c  */
1467 void gfc_formalize_init_value (gfc_symbol *);
1468 void gfc_get_section_index (gfc_array_ref *, mpz_t *, mpz_t *);
1469 void gfc_assign_data_value (gfc_expr *, gfc_expr *, mpz_t);
1470 void gfc_assign_data_value_range (gfc_expr *, gfc_expr *, mpz_t, mpz_t);
1471 void gfc_advance_section (mpz_t *, gfc_array_ref *, mpz_t *);
1472
1473 /* scanner.c */
1474 void gfc_scanner_done_1 (void);
1475 void gfc_scanner_init_1 (void);
1476
1477 void gfc_add_include_path (const char *);
1478 void gfc_release_include_path (void);
1479 FILE *gfc_open_included_file (const char *);
1480
1481 int gfc_at_end (void);
1482 int gfc_at_eof (void);
1483 int gfc_at_bol (void);
1484 int gfc_at_eol (void);
1485 void gfc_advance_line (void);
1486 int gfc_check_include (void);
1487
1488 void gfc_skip_comments (void);
1489 int gfc_next_char_literal (int);
1490 int gfc_next_char (void);
1491 int gfc_peek_char (void);
1492 void gfc_error_recovery (void);
1493 void gfc_gobble_whitespace (void);
1494 try gfc_new_file (const char *, gfc_source_form);
1495
1496 extern gfc_source_form gfc_current_form;
1497 extern char *gfc_source_file;
1498 extern locus gfc_current_locus;
1499
1500 /* misc.c */
1501 void *gfc_getmem (size_t) ATTRIBUTE_MALLOC;
1502 void gfc_free (void *);
1503 int gfc_terminal_width(void);
1504 void gfc_clear_ts (gfc_typespec *);
1505 FILE *gfc_open_file (const char *);
1506 const char *gfc_article (const char *);
1507 const char *gfc_basic_typename (bt);
1508 const char *gfc_typename (gfc_typespec *);
1509
1510 #define gfc_op2string(OP) (OP == INTRINSIC_ASSIGN ? \
1511                            "=" : gfc_code2string (intrinsic_operators, OP))
1512
1513 const char *gfc_code2string (const mstring *, int);
1514 int gfc_string2code (const mstring *, const char *);
1515 const char *gfc_intent_string (sym_intent);
1516
1517 void gfc_init_1 (void);
1518 void gfc_init_2 (void);
1519 void gfc_done_1 (void);
1520 void gfc_done_2 (void);
1521
1522 /* options.c */
1523 unsigned int gfc_init_options (unsigned int, const char **);
1524 int gfc_handle_option (size_t, const char *, int);
1525 bool gfc_post_options (const char **);
1526
1527 /* iresolve.c */
1528 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
1529
1530 /* error.c */
1531
1532 typedef struct gfc_error_buf
1533 {
1534   int flag;
1535   char message[MAX_ERROR_MESSAGE];
1536 } gfc_error_buf;
1537
1538 void gfc_error_init_1 (void);
1539 void gfc_buffer_error (int);
1540
1541 void gfc_warning (const char *, ...);
1542 void gfc_warning_now (const char *, ...);
1543 void gfc_clear_warning (void);
1544 void gfc_warning_check (void);
1545
1546 void gfc_error (const char *, ...);
1547 void gfc_error_now (const char *, ...);
1548 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN;
1549 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN;
1550 void gfc_clear_error (void);
1551 int gfc_error_check (void);
1552
1553 try gfc_notify_std (int, const char *, ...);
1554
1555 /* A general purpose syntax error.  */
1556 #define gfc_syntax_error(ST)    \
1557   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
1558
1559 void gfc_push_error (gfc_error_buf *);
1560 void gfc_pop_error (gfc_error_buf *);
1561
1562 void gfc_status (const char *, ...) ATTRIBUTE_PRINTF_1;
1563 void gfc_status_char (char);
1564
1565 void gfc_get_errors (int *, int *);
1566
1567 /* arith.c */
1568 void gfc_arith_init_1 (void);
1569 void gfc_arith_done_1 (void);
1570
1571 /* trans-types.c */
1572 int gfc_validate_kind (bt, int, bool);
1573 extern int gfc_index_integer_kind;
1574 extern int gfc_default_integer_kind;
1575 extern int gfc_max_integer_kind;
1576 extern int gfc_default_real_kind;
1577 extern int gfc_default_double_kind;
1578 extern int gfc_default_character_kind;
1579 extern int gfc_default_logical_kind;
1580 extern int gfc_default_complex_kind;
1581 extern int gfc_c_int_kind;
1582
1583 /* symbol.c */
1584 void gfc_clear_new_implicit (void);
1585 try gfc_add_new_implicit_range (int, int);
1586 try gfc_merge_new_implicit (gfc_typespec *);
1587 void gfc_set_implicit_none (void);
1588
1589 gfc_typespec *gfc_get_default_type (gfc_symbol *, gfc_namespace *);
1590 try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
1591
1592 void gfc_set_component_attr (gfc_component *, symbol_attribute *);
1593 void gfc_get_component_attr (symbol_attribute *, gfc_component *);
1594
1595 void gfc_set_sym_referenced (gfc_symbol * sym);
1596
1597 try gfc_add_allocatable (symbol_attribute *, locus *);
1598 try gfc_add_dimension (symbol_attribute *, const char *, locus *);
1599 try gfc_add_external (symbol_attribute *, locus *);
1600 try gfc_add_intrinsic (symbol_attribute *, locus *);
1601 try gfc_add_optional (symbol_attribute *, locus *);
1602 try gfc_add_pointer (symbol_attribute *, locus *);
1603 try gfc_add_result (symbol_attribute *, const char *, locus *);
1604 try gfc_add_save (symbol_attribute *, const char *, locus *);
1605 try gfc_add_saved_common (symbol_attribute *, locus *);
1606 try gfc_add_target (symbol_attribute *, locus *);
1607 try gfc_add_dummy (symbol_attribute *, const char *, locus *);
1608 try gfc_add_generic (symbol_attribute *, const char *, locus *);
1609 try gfc_add_common (symbol_attribute *, locus *);
1610 try gfc_add_in_common (symbol_attribute *, const char *, locus *);
1611 try gfc_add_data (symbol_attribute *, const char *, locus *);
1612 try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
1613 try gfc_add_sequence (symbol_attribute *, const char *, locus *);
1614 try gfc_add_elemental (symbol_attribute *, locus *);
1615 try gfc_add_pure (symbol_attribute *, locus *);
1616 try gfc_add_recursive (symbol_attribute *, locus *);
1617 try gfc_add_function (symbol_attribute *, const char *, locus *);
1618 try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
1619
1620 try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
1621 try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
1622 try gfc_add_entry (symbol_attribute *, const char *, locus *);
1623 try gfc_add_procedure (symbol_attribute *, procedure_type,
1624                        const char *, locus *);
1625 try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
1626 try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
1627                                 gfc_formal_arglist *, locus *);
1628 try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
1629
1630 void gfc_clear_attr (symbol_attribute *);
1631 try gfc_missing_attr (symbol_attribute *, locus *);
1632 try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
1633
1634 try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
1635 gfc_symbol *gfc_use_derived (gfc_symbol *);
1636 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
1637 gfc_component *gfc_find_component (gfc_symbol *, const char *);
1638
1639 gfc_st_label *gfc_get_st_label (int);
1640 void gfc_free_st_label (gfc_st_label *);
1641 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
1642 try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
1643
1644 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
1645 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
1646 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
1647 gfc_user_op *gfc_get_uop (const char *);
1648 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
1649 void gfc_free_symbol (gfc_symbol *);
1650 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
1651 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
1652 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
1653 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
1654 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **);
1655 int gfc_get_ha_symbol (const char *, gfc_symbol **);
1656 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
1657
1658 int gfc_symbols_could_alias (gfc_symbol *, gfc_symbol *);
1659
1660 void gfc_undo_symbols (void);
1661 void gfc_commit_symbols (void);
1662 void gfc_free_namespace (gfc_namespace *);
1663
1664 void gfc_symbol_init_2 (void);
1665 void gfc_symbol_done_2 (void);
1666
1667 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
1668 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
1669 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
1670 void gfc_save_all (gfc_namespace *);
1671
1672 void gfc_symbol_state (void);
1673
1674 gfc_gsymbol *gfc_get_gsymbol (const char *);
1675 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
1676
1677 /* intrinsic.c */
1678 extern int gfc_init_expr;
1679
1680 /* Given a symbol that we have decided is intrinsic, mark it as such
1681    by placing it into a special module that is otherwise impossible to
1682    read or write.  */
1683
1684 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
1685
1686 void gfc_intrinsic_init_1 (void);
1687 void gfc_intrinsic_done_1 (void);
1688
1689 char gfc_type_letter (bt);
1690 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
1691 try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
1692 try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
1693 int gfc_generic_intrinsic (const char *);
1694 int gfc_specific_intrinsic (const char *);
1695 int gfc_intrinsic_name (const char *, int);
1696 gfc_intrinsic_sym *gfc_find_function (const char *);
1697
1698 match gfc_intrinsic_func_interface (gfc_expr *, int);
1699 match gfc_intrinsic_sub_interface (gfc_code *, int);
1700
1701 /* simplify.c */
1702 void gfc_simplify_init_1 (void);
1703
1704 /* match.c -- FIXME */
1705 void gfc_free_iterator (gfc_iterator *, int);
1706 void gfc_free_forall_iterator (gfc_forall_iterator *);
1707 void gfc_free_alloc_list (gfc_alloc *);
1708 void gfc_free_namelist (gfc_namelist *);
1709 void gfc_free_equiv (gfc_equiv *);
1710 void gfc_free_data (gfc_data *);
1711 void gfc_free_case_list (gfc_case *);
1712
1713 /* expr.c */
1714 void gfc_free_actual_arglist (gfc_actual_arglist *);
1715 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
1716 const char *gfc_extract_int (gfc_expr *, int *);
1717
1718 gfc_expr *gfc_build_conversion (gfc_expr *);
1719 void gfc_free_ref_list (gfc_ref *);
1720 void gfc_type_convert_binary (gfc_expr *);
1721 int gfc_is_constant_expr (gfc_expr *);
1722 try gfc_simplify_expr (gfc_expr *, int);
1723
1724 gfc_expr *gfc_get_expr (void);
1725 void gfc_free_expr (gfc_expr *);
1726 void gfc_replace_expr (gfc_expr *, gfc_expr *);
1727 gfc_expr *gfc_int_expr (int);
1728 gfc_expr *gfc_logical_expr (int, locus *);
1729 mpz_t *gfc_copy_shape (mpz_t *, int);
1730 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
1731 gfc_expr *gfc_copy_expr (gfc_expr *);
1732
1733 try gfc_specification_expr (gfc_expr *);
1734
1735 int gfc_numeric_ts (gfc_typespec *);
1736 int gfc_kind_max (gfc_expr *, gfc_expr *);
1737
1738 try gfc_check_conformance (const char *, gfc_expr *, gfc_expr *);
1739 try gfc_check_assign (gfc_expr *, gfc_expr *, int);
1740 try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
1741 try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
1742
1743 gfc_expr *gfc_default_initializer (gfc_typespec *);
1744 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
1745
1746
1747 /* st.c */
1748 extern gfc_code new_st;
1749
1750 void gfc_clear_new_st (void);
1751 gfc_code *gfc_get_code (void);
1752 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
1753 void gfc_free_statement (gfc_code *);
1754 void gfc_free_statements (gfc_code *);
1755
1756 /* resolve.c */
1757 try gfc_resolve_expr (gfc_expr *);
1758 void gfc_resolve (gfc_namespace *);
1759 int gfc_impure_variable (gfc_symbol *);
1760 int gfc_pure (gfc_symbol *);
1761 int gfc_elemental (gfc_symbol *);
1762 try gfc_resolve_iterator (gfc_iterator *, bool);
1763 try gfc_resolve_index (gfc_expr *, int);
1764
1765 /* array.c */
1766 void gfc_free_array_spec (gfc_array_spec *);
1767 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
1768
1769 try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
1770 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
1771 try gfc_resolve_array_spec (gfc_array_spec *, int);
1772
1773 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
1774
1775 gfc_expr *gfc_start_constructor (bt, int, locus *);
1776 void gfc_append_constructor (gfc_expr *, gfc_expr *);
1777 void gfc_free_constructor (gfc_constructor *);
1778 void gfc_simplify_iterator_var (gfc_expr *);
1779 try gfc_expand_constructor (gfc_expr *);
1780 int gfc_constant_ac (gfc_expr *);
1781 int gfc_expanded_ac (gfc_expr *);
1782 try gfc_resolve_array_constructor (gfc_expr *);
1783 try gfc_check_constructor_type (gfc_expr *);
1784 try gfc_check_iter_variable (gfc_expr *);
1785 try gfc_check_constructor (gfc_expr *, try (*)(gfc_expr *));
1786 gfc_constructor *gfc_copy_constructor (gfc_constructor * src);
1787 gfc_expr *gfc_get_array_element (gfc_expr *, int);
1788 try gfc_array_size (gfc_expr *, mpz_t *);
1789 try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
1790 try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
1791 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
1792 void gfc_insert_constructor (gfc_expr *, gfc_constructor *);
1793 gfc_constructor *gfc_get_constructor (void);
1794 tree gfc_conv_array_initializer (tree type, gfc_expr * expr);
1795 try spec_size (gfc_array_spec *, mpz_t *);
1796 int gfc_is_compile_time_shape (gfc_array_spec *);
1797
1798 /* interface.c -- FIXME: some of these should be in symbol.c */
1799 void gfc_free_interface (gfc_interface *);
1800 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
1801 void gfc_check_interfaces (gfc_namespace *);
1802 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
1803 gfc_symbol *gfc_search_interface (gfc_interface *, int,
1804                                   gfc_actual_arglist **);
1805 try gfc_extend_expr (gfc_expr *);
1806 void gfc_free_formal_arglist (gfc_formal_arglist *);
1807 try gfc_extend_assign (gfc_code *, gfc_namespace *);
1808 try gfc_add_interface (gfc_symbol * sym);
1809
1810 /* io.c */
1811 extern gfc_st_label format_asterisk;
1812
1813 void gfc_free_open (gfc_open *);
1814 try gfc_resolve_open (gfc_open *);
1815 void gfc_free_close (gfc_close *);
1816 try gfc_resolve_close (gfc_close *);
1817 void gfc_free_filepos (gfc_filepos *);
1818 try gfc_resolve_filepos (gfc_filepos *);
1819 void gfc_free_inquire (gfc_inquire *);
1820 try gfc_resolve_inquire (gfc_inquire *);
1821 void gfc_free_dt (gfc_dt *);
1822 try gfc_resolve_dt (gfc_dt *);
1823
1824 /* module.c */
1825 void gfc_module_init_2 (void);
1826 void gfc_module_done_2 (void);
1827 void gfc_dump_module (const char *, int);
1828 bool gfc_check_access (gfc_access, gfc_access);
1829
1830 /* primary.c */
1831 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
1832 symbol_attribute gfc_expr_attr (gfc_expr *);
1833
1834 /* trans.c */
1835 void gfc_generate_code (gfc_namespace *);
1836 void gfc_generate_module_code (gfc_namespace *);
1837
1838 /* bbt.c */
1839 typedef int (*compare_fn) (void *, void *);
1840 void gfc_insert_bbt (void *, void *, compare_fn);
1841 void gfc_delete_bbt (void *, void *, compare_fn);
1842
1843 /* dump-parse-tree.c */
1844 void gfc_show_namespace (gfc_namespace *);
1845
1846 /* parse.c */
1847 try gfc_parse_file (void);
1848
1849 #endif /* GCC_GFORTRAN_H  */