gcc/fortran/gfortran.h

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