gcc/fortran/gfortran.h

   1 /* gfortran header file
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Andy Vaught
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  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 /* Declarations common to the front-end and library are put in
  33    libgfortran/libgfortran_frontend.h  */
  34 #include "libgfortran.h"
  35
  36
  37 #include "intl.h"
  38 #include "coretypes.h"
  39 #include "input.h"
  40 #include "splay-tree.h"
  41
  42 /* Major control parameters.  */
  43
  44 #define GFC_MAX_SYMBOL_LEN 63   /* Must be at least 63 for F2003.  */
  45 #define GFC_MAX_LINE 132        /* Characters beyond this are not seen.  */
  46 #define GFC_LETTERS 26          /* Number of letters in the alphabet.  */
  47
  48 #define MAX_SUBRECORD_LENGTH 2147483639   /* 2**31-9 */
  49
  50
  51 #define gfc_is_whitespace(c) ((c==' ') || (c=='\t'))
  52
  53 /* Stringization.  */
  54 #define stringize(x) expand_macro(x)
  55 #define expand_macro(x) # x
  56
  57 /* For the runtime library, a standard prefix is a requirement to
  58    avoid cluttering the namespace with things nobody asked for.  It's
  59    ugly to look at and a pain to type when you add the prefix by hand,
  60    so we hide it behind a macro.  */
  61 #define PREFIX(x) "_gfortran_" x
  62 #define PREFIX_LEN 10
  63
  64 /* A prefix for internal variables, which are not user-visible.  */
  65 #if !defined (NO_DOT_IN_LABEL)
  66 # define GFC_PREFIX(x) "_F." x
  67 #elif !defined (NO_DOLLAR_IN_LABEL)
  68 # define GFC_PREFIX(x) "_F$" x
  69 #else
  70 # define GFC_PREFIX(x) "_F_" x
  71 #endif
  72
  73 #define BLANK_COMMON_NAME "__BLNK__"
  74
  75 /* Macro to initialize an mstring structure.  */
  76 #define minit(s, t) { s, NULL, t }
  77
  78 /* Structure for storing strings to be matched by gfc_match_string.  */
  79 typedef struct
  80 {
  81   const char *string;
  82   const char *mp;
  83   int tag;
  84 }
  85 mstring;
  86
  87
  88
  89 /*************************** Enums *****************************/
  90
  91 /* Used when matching and resolving data I/O transfer statements.  */
  92
  93 typedef enum
  94 { M_READ, M_WRITE, M_PRINT, M_INQUIRE }
  95 io_kind;
  96
  97 /* The author remains confused to this day about the convention of
  98    returning '0' for 'SUCCESS'... or was it the other way around?  The
  99    following enum makes things much more readable.  We also start
 100    values off at one instead of zero.  */
 101
 102 typedef enum
 103 { SUCCESS = 1, FAILURE }
 104 gfc_try;
 105
 106 /* These are flags for identifying whether we are reading a character literal
 107    between quotes or normal source code.  */
 108
 109 typedef enum
 110 { NONSTRING = 0, INSTRING_WARN, INSTRING_NOWARN }
 111 gfc_instring;
 112
 113 /* This is returned by gfc_notification_std to know if, given the flags
 114    that were given (-std=, -pedantic) we should issue an error, a warning
 115    or nothing.  */
 116
 117 typedef enum
 118 { SILENT, WARNING, ERROR }
 119 notification;
 120
 121 /* Matchers return one of these three values.  The difference between
 122    MATCH_NO and MATCH_ERROR is that MATCH_ERROR means that a match was
 123    successful, but that something non-syntactic is wrong and an error
 124    has already been issued.  */
 125
 126 typedef enum
 127 { MATCH_NO = 1, MATCH_YES, MATCH_ERROR }
 128 match;
 129
 130 /* Used for different Fortran source forms in places like scanner.c.  */
 131 typedef enum
 132 { FORM_FREE, FORM_FIXED, FORM_UNKNOWN }
 133 gfc_source_form;
 134
 135 /* Expression node types.  */
 136 typedef enum
 137 { EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,
 138   EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL, EXPR_COMPCALL, EXPR_PPC
 139 }
 140 expr_t;
 141
 142 /* Array types.  */
 143 typedef enum
 144 { AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,
 145   AS_ASSUMED_SIZE, AS_IMPLIED_SHAPE, AS_UNKNOWN
 146 }
 147 array_type;
 148
 149 typedef enum
 150 { AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN }
 151 ar_type;
 152
 153 /* Statement label types.  */
 154 typedef enum
 155 { ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET,
 156   ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT
 157 }
 158 gfc_sl_type;
 159
 160 /* Intrinsic operators.  */
 161 typedef enum
 162 { GFC_INTRINSIC_BEGIN = 0,
 163   INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,
 164   INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,
 165   INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,
 166   INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,
 167   /* ==, /=, >, >=, <, <=  */
 168   INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,
 169   INTRINSIC_LT, INTRINSIC_LE,
 170   /* .EQ., .NE., .GT., .GE., .LT., .LE. (OS = Old-Style)  */
 171   INTRINSIC_EQ_OS, INTRINSIC_NE_OS, INTRINSIC_GT_OS, INTRINSIC_GE_OS,
 172   INTRINSIC_LT_OS, INTRINSIC_LE_OS,
 173   INTRINSIC_NOT, INTRINSIC_USER, INTRINSIC_ASSIGN,
 174   INTRINSIC_PARENTHESES, GFC_INTRINSIC_END /* Sentinel */
 175 }
 176 gfc_intrinsic_op;
 177
 178 /* This macro is the number of intrinsic operators that exist.
 179    Assumptions are made about the numbering of the interface_op enums.  */
 180 #define GFC_INTRINSIC_OPS GFC_INTRINSIC_END
 181
 182 /* Arithmetic results.  */
 183 typedef enum
 184 { ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,
 185   ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC, ARITH_PROHIBIT
 186 }
 187 arith;
 188
 189 /* Statements.  */
 190 typedef enum
 191 {
 192   ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_ASSOCIATE,
 193   ST_BACKSPACE, ST_BLOCK, ST_BLOCK_DATA,
 194   ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,
 195   ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,
 196   ST_ELSEWHERE, ST_END_ASSOCIATE, ST_END_BLOCK, ST_END_BLOCK_DATA,
 197   ST_ENDDO, ST_IMPLIED_ENDDO,
 198   ST_END_FILE, ST_FINAL, ST_FLUSH, ST_END_FORALL, ST_END_FUNCTION, ST_ENDIF,
 199   ST_END_INTERFACE, ST_END_MODULE, ST_END_PROGRAM, ST_END_SELECT,
 200   ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE, ST_ENTRY, ST_EQUIVALENCE,
 201   ST_ERROR_STOP, ST_EXIT, ST_FORALL, ST_FORALL_BLOCK, ST_FORMAT, ST_FUNCTION,
 202   ST_GOTO, ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE, ST_IMPORT,
 203   ST_INQUIRE, ST_INTERFACE, ST_SYNC_ALL, ST_SYNC_MEMORY, ST_SYNC_IMAGES,
 204   ST_PARAMETER, ST_MODULE, ST_MODULE_PROC, ST_NAMELIST, ST_NULLIFY, ST_OPEN,
 205   ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC, ST_READ, ST_RETURN, ST_REWIND,
 206   ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE, ST_WHERE_BLOCK, ST_WHERE, ST_WAIT,
 207   ST_WRITE, ST_ASSIGNMENT, ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE,
 208   ST_SIMPLE_IF, ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT,
 209   ST_ENUM, ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,
 210   ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_ATOMIC,
 211   ST_OMP_END_CRITICAL, ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED,
 212   ST_OMP_END_PARALLEL, ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,
 213   ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,
 214   ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,
 215   ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
 216   ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
 217   ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,
 218   ST_OMP_TASKWAIT, ST_OMP_TASKYIELD, ST_PROCEDURE, ST_GENERIC, ST_CRITICAL,
 219   ST_END_CRITICAL, ST_GET_FCN_CHARACTERISTICS, ST_LOCK, ST_UNLOCK, ST_NONE
 220 }
 221 gfc_statement;
 222
 223 /* Types of interfaces that we can have.  Assignment interfaces are
 224    considered to be intrinsic operators.  */
 225 typedef enum
 226 {
 227   INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,
 228   INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP, INTERFACE_ABSTRACT
 229 }
 230 interface_type;
 231
 232 /* Symbol flavors: these are all mutually exclusive.
 233    10 elements = 4 bits.  */
 234 typedef enum sym_flavor
 235 {
 236   FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
 237   FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,
 238   FL_VOID
 239 }
 240 sym_flavor;
 241
 242 /* Procedure types.  7 elements = 3 bits.  */
 243 typedef enum procedure_type
 244 { PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,
 245   PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL
 246 }
 247 procedure_type;
 248
 249 /* Intent types.  */
 250 typedef enum sym_intent
 251 { INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT
 252 }
 253 sym_intent;
 254
 255 /* Access types.  */
 256 typedef enum gfc_access
 257 { ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE
 258 }
 259 gfc_access;
 260
 261 /* Flags to keep track of where an interface came from.
 262    3 elements = 2 bits.  */
 263 typedef enum ifsrc
 264 { IFSRC_UNKNOWN = 0,    /* Interface unknown, only return type may be known.  */
 265   IFSRC_DECL,           /* FUNCTION or SUBROUTINE declaration.  */
 266   IFSRC_IFBODY          /* INTERFACE statement or PROCEDURE statement
 267                            with explicit interface.  */
 268 }
 269 ifsrc;
 270
 271 /* Whether a SAVE attribute was set explicitly or implicitly.  */
 272 typedef enum save_state
 273 { SAVE_NONE = 0, SAVE_EXPLICIT, SAVE_IMPLICIT
 274 }
 275 save_state;
 276
 277 /* Strings for all symbol attributes.  We use these for dumping the
 278    parse tree, in error messages, and also when reading and writing
 279    modules.  In symbol.c.  */
 280 extern const mstring flavors[];
 281 extern const mstring procedures[];
 282 extern const mstring intents[];
 283 extern const mstring access_types[];
 284 extern const mstring ifsrc_types[];
 285 extern const mstring save_status[];
 286
 287 /* Enumeration of all the generic intrinsic functions.  Used by the
 288    backend for identification of a function.  */
 289
 290 enum gfc_isym_id
 291 {
 292   /* GFC_ISYM_NONE is used for intrinsics which will never be seen by
 293      the backend (e.g. KIND).  */
 294   GFC_ISYM_NONE = 0,
 295   GFC_ISYM_ABORT,
 296   GFC_ISYM_ABS,
 297   GFC_ISYM_ACCESS,
 298   GFC_ISYM_ACHAR,
 299   GFC_ISYM_ACOS,
 300   GFC_ISYM_ACOSH,
 301   GFC_ISYM_ADJUSTL,
 302   GFC_ISYM_ADJUSTR,
 303   GFC_ISYM_AIMAG,
 304   GFC_ISYM_AINT,
 305   GFC_ISYM_ALARM,
 306   GFC_ISYM_ALL,
 307   GFC_ISYM_ALLOCATED,
 308   GFC_ISYM_AND,
 309   GFC_ISYM_ANINT,
 310   GFC_ISYM_ANY,
 311   GFC_ISYM_ASIN,
 312   GFC_ISYM_ASINH,
 313   GFC_ISYM_ASSOCIATED,
 314   GFC_ISYM_ATAN,
 315   GFC_ISYM_ATAN2,
 316   GFC_ISYM_ATANH,
 317   GFC_ISYM_ATOMIC_DEF,
 318   GFC_ISYM_ATOMIC_REF,
 319   GFC_ISYM_BGE,
 320   GFC_ISYM_BGT,
 321   GFC_ISYM_BIT_SIZE,
 322   GFC_ISYM_BLE,
 323   GFC_ISYM_BLT,
 324   GFC_ISYM_BTEST,
 325   GFC_ISYM_CEILING,
 326   GFC_ISYM_CHAR,
 327   GFC_ISYM_CHDIR,
 328   GFC_ISYM_CHMOD,
 329   GFC_ISYM_CMPLX,
 330   GFC_ISYM_COMMAND_ARGUMENT_COUNT,
 331   GFC_ISYM_COMPILER_OPTIONS,
 332   GFC_ISYM_COMPILER_VERSION,
 333   GFC_ISYM_COMPLEX,
 334   GFC_ISYM_CONJG,
 335   GFC_ISYM_CONVERSION,
 336   GFC_ISYM_COS,
 337   GFC_ISYM_COSH,
 338   GFC_ISYM_COUNT,
 339   GFC_ISYM_CPU_TIME,
 340   GFC_ISYM_CSHIFT,
 341   GFC_ISYM_CTIME,
 342   GFC_ISYM_C_SIZEOF,
 343   GFC_ISYM_DATE_AND_TIME,
 344   GFC_ISYM_DBLE,
 345   GFC_ISYM_DIGITS,
 346   GFC_ISYM_DIM,
 347   GFC_ISYM_DOT_PRODUCT,
 348   GFC_ISYM_DPROD,
 349   GFC_ISYM_DSHIFTL,
 350   GFC_ISYM_DSHIFTR,
 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_EXECUTE_COMMAND_LINE,
 359   GFC_ISYM_EXIT,
 360   GFC_ISYM_EXP,
 361   GFC_ISYM_EXPONENT,
 362   GFC_ISYM_EXTENDS_TYPE_OF,
 363   GFC_ISYM_FDATE,
 364   GFC_ISYM_FGET,
 365   GFC_ISYM_FGETC,
 366   GFC_ISYM_FLOOR,
 367   GFC_ISYM_FLUSH,
 368   GFC_ISYM_FNUM,
 369   GFC_ISYM_FPUT,
 370   GFC_ISYM_FPUTC,
 371   GFC_ISYM_FRACTION,
 372   GFC_ISYM_FREE,
 373   GFC_ISYM_FSEEK,
 374   GFC_ISYM_FSTAT,
 375   GFC_ISYM_FTELL,
 376   GFC_ISYM_TGAMMA,
 377   GFC_ISYM_GERROR,
 378   GFC_ISYM_GETARG,
 379   GFC_ISYM_GET_COMMAND,
 380   GFC_ISYM_GET_COMMAND_ARGUMENT,
 381   GFC_ISYM_GETCWD,
 382   GFC_ISYM_GETENV,
 383   GFC_ISYM_GET_ENVIRONMENT_VARIABLE,
 384   GFC_ISYM_GETGID,
 385   GFC_ISYM_GETLOG,
 386   GFC_ISYM_GETPID,
 387   GFC_ISYM_GETUID,
 388   GFC_ISYM_GMTIME,
 389   GFC_ISYM_HOSTNM,
 390   GFC_ISYM_HUGE,
 391   GFC_ISYM_HYPOT,
 392   GFC_ISYM_IACHAR,
 393   GFC_ISYM_IALL,
 394   GFC_ISYM_IAND,
 395   GFC_ISYM_IANY,
 396   GFC_ISYM_IARGC,
 397   GFC_ISYM_IBCLR,
 398   GFC_ISYM_IBITS,
 399   GFC_ISYM_IBSET,
 400   GFC_ISYM_ICHAR,
 401   GFC_ISYM_IDATE,
 402   GFC_ISYM_IEOR,
 403   GFC_ISYM_IERRNO,
 404   GFC_ISYM_IMAGE_INDEX,
 405   GFC_ISYM_INDEX,
 406   GFC_ISYM_INT,
 407   GFC_ISYM_INT2,
 408   GFC_ISYM_INT8,
 409   GFC_ISYM_IOR,
 410   GFC_ISYM_IPARITY,
 411   GFC_ISYM_IRAND,
 412   GFC_ISYM_ISATTY,
 413   GFC_ISYM_IS_IOSTAT_END,
 414   GFC_ISYM_IS_IOSTAT_EOR,
 415   GFC_ISYM_ISNAN,
 416   GFC_ISYM_ISHFT,
 417   GFC_ISYM_ISHFTC,
 418   GFC_ISYM_ITIME,
 419   GFC_ISYM_J0,
 420   GFC_ISYM_J1,
 421   GFC_ISYM_JN,
 422   GFC_ISYM_JN2,
 423   GFC_ISYM_KILL,
 424   GFC_ISYM_KIND,
 425   GFC_ISYM_LBOUND,
 426   GFC_ISYM_LCOBOUND,
 427   GFC_ISYM_LEADZ,
 428   GFC_ISYM_LEN,
 429   GFC_ISYM_LEN_TRIM,
 430   GFC_ISYM_LGAMMA,
 431   GFC_ISYM_LGE,
 432   GFC_ISYM_LGT,
 433   GFC_ISYM_LINK,
 434   GFC_ISYM_LLE,
 435   GFC_ISYM_LLT,
 436   GFC_ISYM_LOC,
 437   GFC_ISYM_LOG,
 438   GFC_ISYM_LOG10,
 439   GFC_ISYM_LOGICAL,
 440   GFC_ISYM_LONG,
 441   GFC_ISYM_LSHIFT,
 442   GFC_ISYM_LSTAT,
 443   GFC_ISYM_LTIME,
 444   GFC_ISYM_MALLOC,
 445   GFC_ISYM_MASKL,
 446   GFC_ISYM_MASKR,
 447   GFC_ISYM_MATMUL,
 448   GFC_ISYM_MAX,
 449   GFC_ISYM_MAXEXPONENT,
 450   GFC_ISYM_MAXLOC,
 451   GFC_ISYM_MAXVAL,
 452   GFC_ISYM_MCLOCK,
 453   GFC_ISYM_MCLOCK8,
 454   GFC_ISYM_MERGE,
 455   GFC_ISYM_MERGE_BITS,
 456   GFC_ISYM_MIN,
 457   GFC_ISYM_MINEXPONENT,
 458   GFC_ISYM_MINLOC,
 459   GFC_ISYM_MINVAL,
 460   GFC_ISYM_MOD,
 461   GFC_ISYM_MODULO,
 462   GFC_ISYM_MOVE_ALLOC,
 463   GFC_ISYM_MVBITS,
 464   GFC_ISYM_NEAREST,
 465   GFC_ISYM_NEW_LINE,
 466   GFC_ISYM_NINT,
 467   GFC_ISYM_NORM2,
 468   GFC_ISYM_NOT,
 469   GFC_ISYM_NULL,
 470   GFC_ISYM_NUM_IMAGES,
 471   GFC_ISYM_OR,
 472   GFC_ISYM_PACK,
 473   GFC_ISYM_PARITY,
 474   GFC_ISYM_PERROR,
 475   GFC_ISYM_POPCNT,
 476   GFC_ISYM_POPPAR,
 477   GFC_ISYM_PRECISION,
 478   GFC_ISYM_PRESENT,
 479   GFC_ISYM_PRODUCT,
 480   GFC_ISYM_RADIX,
 481   GFC_ISYM_RAND,
 482   GFC_ISYM_RANDOM_NUMBER,
 483   GFC_ISYM_RANDOM_SEED,
 484   GFC_ISYM_RANGE,
 485   GFC_ISYM_RANK,
 486   GFC_ISYM_REAL,
 487   GFC_ISYM_RENAME,
 488   GFC_ISYM_REPEAT,
 489   GFC_ISYM_RESHAPE,
 490   GFC_ISYM_RRSPACING,
 491   GFC_ISYM_RSHIFT,
 492   GFC_ISYM_SAME_TYPE_AS,
 493   GFC_ISYM_SC_KIND,
 494   GFC_ISYM_SCALE,
 495   GFC_ISYM_SCAN,
 496   GFC_ISYM_SECNDS,
 497   GFC_ISYM_SECOND,
 498   GFC_ISYM_SET_EXPONENT,
 499   GFC_ISYM_SHAPE,
 500   GFC_ISYM_SHIFTA,
 501   GFC_ISYM_SHIFTL,
 502   GFC_ISYM_SHIFTR,
 503   GFC_ISYM_SIGN,
 504   GFC_ISYM_SIGNAL,
 505   GFC_ISYM_SI_KIND,
 506   GFC_ISYM_SIN,
 507   GFC_ISYM_SINH,
 508   GFC_ISYM_SIZE,
 509   GFC_ISYM_SLEEP,
 510   GFC_ISYM_SIZEOF,
 511   GFC_ISYM_SPACING,
 512   GFC_ISYM_SPREAD,
 513   GFC_ISYM_SQRT,
 514   GFC_ISYM_SRAND,
 515   GFC_ISYM_SR_KIND,
 516   GFC_ISYM_STAT,
 517   GFC_ISYM_STORAGE_SIZE,
 518   GFC_ISYM_SUM,
 519   GFC_ISYM_SYMLINK,
 520   GFC_ISYM_SYMLNK,
 521   GFC_ISYM_SYSTEM,
 522   GFC_ISYM_SYSTEM_CLOCK,
 523   GFC_ISYM_TAN,
 524   GFC_ISYM_TANH,
 525   GFC_ISYM_THIS_IMAGE,
 526   GFC_ISYM_TIME,
 527   GFC_ISYM_TIME8,
 528   GFC_ISYM_TINY,
 529   GFC_ISYM_TRAILZ,
 530   GFC_ISYM_TRANSFER,
 531   GFC_ISYM_TRANSPOSE,
 532   GFC_ISYM_TRIM,
 533   GFC_ISYM_TTYNAM,
 534   GFC_ISYM_UBOUND,
 535   GFC_ISYM_UCOBOUND,
 536   GFC_ISYM_UMASK,
 537   GFC_ISYM_UNLINK,
 538   GFC_ISYM_UNPACK,
 539   GFC_ISYM_VERIFY,
 540   GFC_ISYM_XOR,
 541   GFC_ISYM_Y0,
 542   GFC_ISYM_Y1,
 543   GFC_ISYM_YN,
 544   GFC_ISYM_YN2
 545 };
 546 typedef enum gfc_isym_id gfc_isym_id;
 547
 548
 549 typedef enum
 550 {
 551   GFC_INIT_REAL_OFF = 0,
 552   GFC_INIT_REAL_ZERO,
 553   GFC_INIT_REAL_NAN,
 554   GFC_INIT_REAL_SNAN,
 555   GFC_INIT_REAL_INF,
 556   GFC_INIT_REAL_NEG_INF
 557 }
 558 init_local_real;
 559
 560 typedef enum
 561 {
 562   GFC_INIT_LOGICAL_OFF = 0,
 563   GFC_INIT_LOGICAL_FALSE,
 564   GFC_INIT_LOGICAL_TRUE
 565 }
 566 init_local_logical;
 567
 568 typedef enum
 569 {
 570   GFC_INIT_CHARACTER_OFF = 0,
 571   GFC_INIT_CHARACTER_ON
 572 }
 573 init_local_character;
 574
 575 typedef enum
 576 {
 577   GFC_INIT_INTEGER_OFF = 0,
 578   GFC_INIT_INTEGER_ON
 579 }
 580 init_local_integer;
 581
 582 typedef enum
 583 {
 584   GFC_FCOARRAY_NONE = 0,
 585   GFC_FCOARRAY_SINGLE,
 586   GFC_FCOARRAY_LIB
 587 }
 588 gfc_fcoarray;
 589
 590 typedef enum
 591 {
 592   GFC_ENABLE_REVERSE,
 593   GFC_FORWARD_SET,
 594   GFC_REVERSE_SET,
 595   GFC_INHIBIT_REVERSE
 596 }
 597 gfc_reverse;
 598
 599 /************************* Structures *****************************/
 600
 601 /* Used for keeping things in balanced binary trees.  */
 602 #define BBT_HEADER(self) int priority; struct self *left, *right
 603
 604 #define NAMED_INTCST(a,b,c,d) a,
 605 #define NAMED_KINDARRAY(a,b,c,d) a,
 606 #define NAMED_FUNCTION(a,b,c,d) a,
 607 #define NAMED_DERIVED_TYPE(a,b,c,d) a,
 608 typedef enum
 609 {
 610   ISOFORTRANENV_INVALID = -1,
 611 #include "iso-fortran-env.def"
 612   ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST
 613 }
 614 iso_fortran_env_symbol;
 615 #undef NAMED_INTCST
 616 #undef NAMED_KINDARRAY
 617 #undef NAMED_FUNCTION
 618 #undef NAMED_DERIVED_TYPE
 619
 620 #define NAMED_INTCST(a,b,c,d) a,
 621 #define NAMED_REALCST(a,b,c,d) a,
 622 #define NAMED_CMPXCST(a,b,c,d) a,
 623 #define NAMED_LOGCST(a,b,c) a,
 624 #define NAMED_CHARKNDCST(a,b,c) a,
 625 #define NAMED_CHARCST(a,b,c) a,
 626 #define DERIVED_TYPE(a,b,c) a,
 627 #define PROCEDURE(a,b) a,
 628 #define NAMED_FUNCTION(a,b,c,d) a,
 629 typedef enum
 630 {
 631   ISOCBINDING_INVALID = -1,
 632 #include "iso-c-binding.def"
 633   ISOCBINDING_LAST,
 634   ISOCBINDING_NUMBER = ISOCBINDING_LAST
 635 }
 636 iso_c_binding_symbol;
 637 #undef NAMED_INTCST
 638 #undef NAMED_REALCST
 639 #undef NAMED_CMPXCST
 640 #undef NAMED_LOGCST
 641 #undef NAMED_CHARKNDCST
 642 #undef NAMED_CHARCST
 643 #undef DERIVED_TYPE
 644 #undef PROCEDURE
 645 #undef NAMED_FUNCTION
 646
 647 typedef enum
 648 {
 649   INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING
 650 }
 651 intmod_id;
 652
 653 typedef struct
 654 {
 655   char name[GFC_MAX_SYMBOL_LEN + 1];
 656   int value;  /* Used for both integer and character values.  */
 657   bt f90_type;
 658 }
 659 CInteropKind_t;
 660
 661 /* Array of structs, where the structs represent the C interop kinds.
 662    The list will be implemented based on a hash of the kind name since
 663    these could be accessed multiple times.
 664    Declared in trans-types.c as a global, since it's in that file
 665    that the list is initialized.  */
 666 extern CInteropKind_t c_interop_kinds_table[];
 667
 668
 669 /* Structure and list of supported extension attributes.  */
 670 typedef enum
 671 {
 672   EXT_ATTR_DLLIMPORT = 0,
 673   EXT_ATTR_DLLEXPORT,
 674   EXT_ATTR_STDCALL,
 675   EXT_ATTR_CDECL,
 676   EXT_ATTR_FASTCALL,
 677   EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST
 678 }
 679 ext_attr_id_t;
 680
 681 typedef struct
 682 {
 683   const char *name;
 684   unsigned id;
 685   const char *middle_end_name;
 686 }
 687 ext_attr_t;
 688
 689 extern const ext_attr_t ext_attr_list[];
 690
 691 /* Symbol attribute structure.  */
 692 typedef struct
 693 {
 694   /* Variable attributes.  */
 695   unsigned allocatable:1, dimension:1, codimension:1, external:1, intrinsic:1,
 696     optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,
 697     dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,
 698     implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1,
 699     contiguous:1;
 700
 701   /* For CLASS containers, the pointer attribute is sometimes set internally
 702      even though it was not directly specified.  In this case, keep the
 703      "real" (original) value here.  */
 704   unsigned class_pointer:1;
 705
 706   ENUM_BITFIELD (save_state) save:2;
 707
 708   unsigned data:1,              /* Symbol is named in a DATA statement.  */
 709     is_protected:1,             /* Symbol has been marked as protected.  */
 710     use_assoc:1,                /* Symbol has been use-associated.  */
 711     use_only:1,                 /* Symbol has been use-associated, with ONLY.  */
 712     use_rename:1,               /* Symbol has been use-associated and renamed.  */
 713     imported:1,                 /* Symbol has been associated by IMPORT.  */
 714     host_assoc:1;               /* Symbol has been host associated.  */
 715
 716   unsigned in_namelist:1, in_common:1, in_equivalence:1;
 717   unsigned function:1, subroutine:1, procedure:1;
 718   unsigned generic:1, generic_copy:1;
 719   unsigned implicit_type:1;     /* Type defined via implicit rules.  */
 720   unsigned untyped:1;           /* No implicit type could be found.  */
 721
 722   unsigned is_bind_c:1;         /* say if is bound to C.  */
 723   unsigned extension:8;         /* extension level of a derived type.  */
 724   unsigned is_class:1;          /* is a CLASS container.  */
 725   unsigned class_ok:1;          /* is a CLASS object with correct attributes.  */
 726   unsigned vtab:1;              /* is a derived type vtab, pointed to by CLASS objects.  */
 727   unsigned vtype:1;             /* is a derived type of a vtab.  */
 728
 729   /* These flags are both in the typespec and attribute.  The attribute
 730      list is what gets read from/written to a module file.  The typespec
 731      is created from a decl being processed.  */
 732   unsigned is_c_interop:1;      /* It's c interoperable.  */
 733   unsigned is_iso_c:1;          /* Symbol is from iso_c_binding.  */
 734
 735   /* Function/subroutine attributes */
 736   unsigned sequence:1, elemental:1, pure:1, recursive:1;
 737   unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;
 738
 739   /* This is set if a contained procedure could be declared pure.  This is
 740      used for certain optimizations that require the result or arguments
 741      cannot alias.  Note that this is zero for PURE procedures.  */
 742   unsigned implicit_pure:1;
 743
 744   /* This is set if the subroutine doesn't return.  Currently, this
 745      is only possible for intrinsic subroutines.  */
 746   unsigned noreturn:1;
 747
 748   /* Set if this procedure is an alternate entry point.  These procedures
 749      don't have any code associated, and the backend will turn them into
 750      thunks to the master function.  */
 751   unsigned entry:1;
 752
 753   /* Set if this is the master function for a procedure with multiple
 754      entry points.  */
 755   unsigned entry_master:1;
 756
 757   /* Set if this is the master function for a function with multiple
 758      entry points where characteristics of the entry points differ.  */
 759   unsigned mixed_entry_master:1;
 760
 761   /* Set if a function must always be referenced by an explicit interface.  */
 762   unsigned always_explicit:1;
 763
 764   /* Set if the symbol has been referenced in an expression.  No further
 765      modification of type or type parameters is permitted.  */
 766   unsigned referenced:1;
 767
 768   /* Set if this is the symbol for the main program.  */
 769   unsigned is_main_program:1;
 770
 771   /* Mutually exclusive multibit attributes.  */
 772   ENUM_BITFIELD (gfc_access) access:2;
 773   ENUM_BITFIELD (sym_intent) intent:2;
 774   ENUM_BITFIELD (sym_flavor) flavor:4;
 775   ENUM_BITFIELD (ifsrc) if_source:2;
 776
 777   ENUM_BITFIELD (procedure_type) proc:3;
 778
 779   /* Special attributes for Cray pointers, pointees.  */
 780   unsigned cray_pointer:1, cray_pointee:1;
 781
 782   /* The symbol is a derived type with allocatable components, pointer
 783      components or private components, procedure pointer components,
 784      possibly nested.  zero_comp is true if the derived type has no
 785      component at all.  */
 786   unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,
 787            private_comp:1, zero_comp:1, coarray_comp:1, lock_comp:1;
 788
 789   /* This is a temporary selector for SELECT TYPE.  */
 790   unsigned select_type_temporary:1;
 791
 792   /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES).  */
 793   unsigned ext_attr:EXT_ATTR_NUM;
 794
 795   /* The namespace where the attribute has been set.  */
 796   struct gfc_namespace *volatile_ns, *asynchronous_ns;
 797 }
 798 symbol_attribute;
 799
 800
 801 /* We need to store source lines as sequences of multibyte source
 802    characters. We define here a type wide enough to hold any multibyte
 803    source character, just like libcpp does.  A 32-bit type is enough.  */
 804
 805 #if HOST_BITS_PER_INT >= 32
 806 typedef unsigned int gfc_char_t;
 807 #elif HOST_BITS_PER_LONG >= 32
 808 typedef unsigned long gfc_char_t;
 809 #elif defined(HAVE_LONG_LONG) && (HOST_BITS_PER_LONGLONG >= 32)
 810 typedef unsigned long long gfc_char_t;
 811 #else
 812 # error "Cannot find an integer type with at least 32 bits"
 813 #endif
 814
 815
 816 /* The following three structures are used to identify a location in
 817    the sources.
 818
 819    gfc_file is used to maintain a tree of the source files and how
 820    they include each other
 821
 822    gfc_linebuf holds a single line of source code and information
 823    which file it resides in
 824
 825    locus point to the sourceline and the character in the source
 826    line.
 827 */
 828
 829 typedef struct gfc_file
 830 {
 831   struct gfc_file *next, *up;
 832   int inclusion_line, line;
 833   char *filename;
 834 } gfc_file;
 835
 836 typedef struct gfc_linebuf
 837 {
 838   source_location location;
 839   struct gfc_file *file;
 840   struct gfc_linebuf *next;
 841
 842   int truncated;
 843   bool dbg_emitted;
 844
 845   gfc_char_t line[1];
 846 } gfc_linebuf;
 847
 848 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
 849
 850 #define gfc_linebuf_linenum(LBUF) (LOCATION_LINE ((LBUF)->location))
 851
 852 typedef struct
 853 {
 854   gfc_char_t *nextc;
 855   gfc_linebuf *lb;
 856 } locus;
 857
 858 /* In order for the "gfc" format checking to work correctly, you must
 859    have declared a typedef locus first.  */
 860 #if GCC_VERSION >= 4001
 861 #define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)
 862 #else
 863 #define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)
 864 #endif
 865
 866
 867 /* Suppress error messages or re-enable them.  */
 868
 869 void gfc_push_suppress_errors (void);
 870 void gfc_pop_suppress_errors (void);
 871
 872
 873 /* Character length structures hold the expression that gives the
 874    length of a character variable.  We avoid putting these into
 875    gfc_typespec because doing so prevents us from doing structure
 876    copies and forces us to deallocate any typespecs we create, as well
 877    as structures that contain typespecs.  They also can have multiple
 878    character typespecs pointing to them.
 879
 880    These structures form a singly linked list within the current
 881    namespace and are deallocated with the namespace.  It is possible to
 882    end up with gfc_charlen structures that have nothing pointing to them.  */
 883
 884 typedef struct gfc_charlen
 885 {
 886   struct gfc_expr *length;
 887   struct gfc_charlen *next;
 888   bool length_from_typespec; /* Length from explicit array ctor typespec?  */
 889   tree backend_decl;
 890   tree passed_length; /* Length argument explicitly passed.  */
 891
 892   int resolved;
 893 }
 894 gfc_charlen;
 895
 896 #define gfc_get_charlen() XCNEW (gfc_charlen)
 897
 898 /* Type specification structure.  */
 899 typedef struct
 900 {
 901   bt type;
 902   int kind;
 903
 904   union
 905   {
 906     struct gfc_symbol *derived; /* For derived types only.  */
 907     gfc_charlen *cl;            /* For character types only.  */
 908     int pad;                    /* For hollerith types only.  */
 909   }
 910   u;
 911
 912   struct gfc_symbol *interface; /* For PROCEDURE declarations.  */
 913   int is_c_interop;
 914   int is_iso_c;
 915   bt f90_type;
 916   bool deferred;
 917 }
 918 gfc_typespec;
 919
 920 /* Array specification.  */
 921 typedef struct
 922 {
 923   int rank;     /* A rank of zero means that a variable is a scalar.  */
 924   int corank;
 925   array_type type, cotype;
 926   struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
 927
 928   /* These two fields are used with the Cray Pointer extension.  */
 929   bool cray_pointee; /* True iff this spec belongs to a cray pointee.  */
 930   bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to
 931                         AS_EXPLICIT, but we want to remember that we
 932                         did this.  */
 933
 934 }
 935 gfc_array_spec;
 936
 937 #define gfc_get_array_spec() XCNEW (gfc_array_spec)
 938
 939
 940 /* Components of derived types.  */
 941 typedef struct gfc_component
 942 {
 943   const char *name;
 944   gfc_typespec ts;
 945
 946   symbol_attribute attr;
 947   gfc_array_spec *as;
 948
 949   tree backend_decl;
 950   /* Used to cache a FIELD_DECL matching this same component
 951      but applied to a different backend containing type that was
 952      generated by gfc_nonrestricted_type.  */
 953   tree norestrict_decl;
 954   locus loc;
 955   struct gfc_expr *initializer;
 956   struct gfc_component *next;
 957
 958   /* Needed for procedure pointer components.  */
 959   struct gfc_formal_arglist *formal;
 960   struct gfc_namespace *formal_ns;
 961   struct gfc_typebound_proc *tb;
 962 }
 963 gfc_component;
 964
 965 #define gfc_get_component() XCNEW (gfc_component)
 966
 967 /* Formal argument lists are lists of symbols.  */
 968 typedef struct gfc_formal_arglist
 969 {
 970   /* Symbol representing the argument at this position in the arglist.  */
 971   struct gfc_symbol *sym;
 972   /* Points to the next formal argument.  */
 973   struct gfc_formal_arglist *next;
 974 }
 975 gfc_formal_arglist;
 976
 977 #define gfc_get_formal_arglist() XCNEW (gfc_formal_arglist)
 978
 979
 980 /* The gfc_actual_arglist structure is for actual arguments.  */
 981 typedef struct gfc_actual_arglist
 982 {
 983   const char *name;
 984   /* Alternate return label when the expr member is null.  */
 985   struct gfc_st_label *label;
 986
 987   /* This is set to the type of an eventual omitted optional
 988      argument. This is used to determine if a hidden string length
 989      argument has to be added to a function call.  */
 990   bt missing_arg_type;
 991
 992   struct gfc_expr *expr;
 993   struct gfc_actual_arglist *next;
 994 }
 995 gfc_actual_arglist;
 996
 997 #define gfc_get_actual_arglist() XCNEW (gfc_actual_arglist)
 998
 999
1000 /* Because a symbol can belong to multiple namelists, they must be
1001    linked externally to the symbol itself.  */
1002 typedef struct gfc_namelist
1003 {
1004   struct gfc_symbol *sym;
1005   struct gfc_namelist *next;
1006 }
1007 gfc_namelist;
1008
1009 #define gfc_get_namelist() XCNEW (gfc_namelist)
1010
1011 enum
1012 {
1013   OMP_LIST_PRIVATE,
1014   OMP_LIST_FIRSTPRIVATE,
1015   OMP_LIST_LASTPRIVATE,
1016   OMP_LIST_COPYPRIVATE,
1017   OMP_LIST_SHARED,
1018   OMP_LIST_COPYIN,
1019   OMP_LIST_PLUS,
1020   OMP_LIST_REDUCTION_FIRST = OMP_LIST_PLUS,
1021   OMP_LIST_MULT,
1022   OMP_LIST_SUB,
1023   OMP_LIST_AND,
1024   OMP_LIST_OR,
1025   OMP_LIST_EQV,
1026   OMP_LIST_NEQV,
1027   OMP_LIST_MAX,
1028   OMP_LIST_MIN,
1029   OMP_LIST_IAND,
1030   OMP_LIST_IOR,
1031   OMP_LIST_IEOR,
1032   OMP_LIST_REDUCTION_LAST = OMP_LIST_IEOR,
1033   OMP_LIST_NUM
1034 };
1035
1036 /* Because a symbol can belong to multiple namelists, they must be
1037    linked externally to the symbol itself.  */
1038
1039 enum gfc_omp_sched_kind
1040 {
1041   OMP_SCHED_NONE,
1042   OMP_SCHED_STATIC,
1043   OMP_SCHED_DYNAMIC,
1044   OMP_SCHED_GUIDED,
1045   OMP_SCHED_RUNTIME,
1046   OMP_SCHED_AUTO
1047 };
1048
1049 enum gfc_omp_default_sharing
1050 {
1051   OMP_DEFAULT_UNKNOWN,
1052   OMP_DEFAULT_NONE,
1053   OMP_DEFAULT_PRIVATE,
1054   OMP_DEFAULT_SHARED,
1055   OMP_DEFAULT_FIRSTPRIVATE
1056 };
1057
1058 typedef struct gfc_omp_clauses
1059 {
1060   struct gfc_expr *if_expr;
1061   struct gfc_expr *final_expr;
1062   struct gfc_expr *num_threads;
1063   gfc_namelist *lists[OMP_LIST_NUM];
1064   enum gfc_omp_sched_kind sched_kind;
1065   struct gfc_expr *chunk_size;
1066   enum gfc_omp_default_sharing default_sharing;
1067   int collapse;
1068   bool nowait, ordered, untied, mergeable;
1069 }
1070 gfc_omp_clauses;
1071
1072 #define gfc_get_omp_clauses() XCNEW (gfc_omp_clauses)
1073
1074
1075 /* The gfc_st_label structure is a BBT attached to a namespace that
1076    records the usage of statement labels within that space.  */
1077
1078 typedef struct gfc_st_label
1079 {
1080   BBT_HEADER(gfc_st_label);
1081
1082   int value;
1083
1084   gfc_sl_type defined, referenced;
1085
1086   struct gfc_expr *format;
1087
1088   tree backend_decl;
1089
1090   locus where;
1091 }
1092 gfc_st_label;
1093
1094
1095 /* gfc_interface()-- Interfaces are lists of symbols strung together.  */
1096 typedef struct gfc_interface
1097 {
1098   struct gfc_symbol *sym;
1099   locus where;
1100   struct gfc_interface *next;
1101 }
1102 gfc_interface;
1103
1104 #define gfc_get_interface() XCNEW (gfc_interface)
1105
1106 /* User operator nodes.  These are like stripped down symbols.  */
1107 typedef struct
1108 {
1109   const char *name;
1110
1111   gfc_interface *op;
1112   struct gfc_namespace *ns;
1113   gfc_access access;
1114 }
1115 gfc_user_op;
1116
1117
1118 /* A list of specific bindings that are associated with a generic spec.  */
1119 typedef struct gfc_tbp_generic
1120 {
1121   /* The parser sets specific_st, upon resolution we look for the corresponding
1122      gfc_typebound_proc and set specific for further use.  */
1123   struct gfc_symtree* specific_st;
1124   struct gfc_typebound_proc* specific;
1125
1126   struct gfc_tbp_generic* next;
1127   bool is_operator;
1128 }
1129 gfc_tbp_generic;
1130
1131 #define gfc_get_tbp_generic() XCNEW (gfc_tbp_generic)
1132
1133
1134 /* Data needed for type-bound procedures.  */
1135 typedef struct gfc_typebound_proc
1136 {
1137   locus where; /* Where the PROCEDURE/GENERIC definition was.  */
1138
1139   union
1140   {
1141     struct gfc_symtree* specific; /* The interface if DEFERRED.  */
1142     gfc_tbp_generic* generic;
1143   }
1144   u;
1145
1146   gfc_access access;
1147   const char* pass_arg; /* Argument-name for PASS.  NULL if not specified.  */
1148
1149   /* The overridden type-bound proc (or GENERIC with this name in the
1150      parent-type) or NULL if non.  */
1151   struct gfc_typebound_proc* overridden;
1152
1153   /* Once resolved, we use the position of pass_arg in the formal arglist of
1154      the binding-target procedure to identify it.  The first argument has
1155      number 1 here, the second 2, and so on.  */
1156   unsigned pass_arg_num;
1157
1158   unsigned nopass:1; /* Whether we have NOPASS (PASS otherwise).  */
1159   unsigned non_overridable:1;
1160   unsigned deferred:1;
1161   unsigned is_generic:1;
1162   unsigned function:1, subroutine:1;
1163   unsigned error:1; /* Ignore it, when an error occurred during resolution.  */
1164   unsigned ppc:1;
1165 }
1166 gfc_typebound_proc;
1167
1168
1169 /* Symbol nodes.  These are important things.  They are what the
1170    standard refers to as "entities".  The possibly multiple names that
1171    refer to the same entity are accomplished by a binary tree of
1172    symtree structures that is balanced by the red-black method-- more
1173    than one symtree node can point to any given symbol.  */
1174
1175 typedef struct gfc_symbol
1176 {
1177   const char *name;     /* Primary name, before renaming */
1178   const char *module;   /* Module this symbol came from */
1179   locus declared_at;
1180
1181   gfc_typespec ts;
1182   symbol_attribute attr;
1183
1184   /* The formal member points to the formal argument list if the
1185      symbol is a function or subroutine name.  If the symbol is a
1186      generic name, the generic member points to the list of
1187      interfaces.  */
1188
1189   gfc_interface *generic;
1190   gfc_access component_access;
1191
1192   gfc_formal_arglist *formal;
1193   struct gfc_namespace *formal_ns;
1194   struct gfc_namespace *f2k_derived;
1195
1196   struct gfc_expr *value;       /* Parameter/Initializer value */
1197   gfc_array_spec *as;
1198   struct gfc_symbol *result;    /* function result symbol */
1199   gfc_component *components;    /* Derived type components */
1200
1201   /* Defined only for Cray pointees; points to their pointer.  */
1202   struct gfc_symbol *cp_pointer;
1203
1204   int entry_id;                 /* Used in resolve.c for entries.  */
1205
1206   /* CLASS hashed name for declared and dynamic types in the class.  */
1207   int hash_value;
1208
1209   struct gfc_symbol *common_next;       /* Links for COMMON syms */
1210
1211   /* This is in fact a gfc_common_head but it is only used for pointer
1212      comparisons to check if symbols are in the same common block.  */
1213   struct gfc_common_head* common_head;
1214
1215   /* Make sure setup code for dummy arguments is generated in the correct
1216      order.  */
1217   int dummy_order;
1218
1219   gfc_namelist *namelist, *namelist_tail;
1220
1221   /* Change management fields.  Symbols that might be modified by the
1222      current statement have the mark member nonzero and are kept in a
1223      singly linked list through the tlink field.  Of these symbols,
1224      symbols with old_symbol equal to NULL are symbols created within
1225      the current statement.  Otherwise, old_symbol points to a copy of
1226      the old symbol.  */
1227
1228   struct gfc_symbol *old_symbol, *tlink;
1229   unsigned mark:1, gfc_new:1;
1230   /* Nonzero if all equivalences associated with this symbol have been
1231      processed.  */
1232   unsigned equiv_built:1;
1233   /* Set if this variable is used as an index name in a FORALL.  */
1234   unsigned forall_index:1;
1235   int refs;
1236   struct gfc_namespace *ns;     /* namespace containing this symbol */
1237
1238   tree backend_decl;
1239
1240   /* Identity of the intrinsic module the symbol comes from, or
1241      INTMOD_NONE if it's not imported from a intrinsic module.  */
1242   intmod_id from_intmod;
1243   /* Identity of the symbol from intrinsic modules, from enums maintained
1244      separately by each intrinsic module.  Used together with from_intmod,
1245      it uniquely identifies a symbol from an intrinsic module.  */
1246   int intmod_sym_id;
1247
1248   /* This may be repetitive, since the typespec now has a binding
1249      label field.  */
1250   const char* binding_label;
1251   /* Store a reference to the common_block, if this symbol is in one.  */
1252   struct gfc_common_head *common_block;
1253
1254   /* Link to corresponding association-list if this is an associate name.  */
1255   struct gfc_association_list *assoc;
1256 }
1257 gfc_symbol;
1258
1259
1260 /* This structure is used to keep track of symbols in common blocks.  */
1261 typedef struct gfc_common_head
1262 {
1263   locus where;
1264   char use_assoc, saved, threadprivate;
1265   char name[GFC_MAX_SYMBOL_LEN + 1];
1266   struct gfc_symbol *head;
1267   const char* binding_label;
1268   int is_bind_c;
1269 }
1270 gfc_common_head;
1271
1272 #define gfc_get_common_head() XCNEW (gfc_common_head)
1273
1274
1275 /* A list of all the alternate entry points for a procedure.  */
1276
1277 typedef struct gfc_entry_list
1278 {
1279   /* The symbol for this entry point.  */
1280   gfc_symbol *sym;
1281   /* The zero-based id of this entry point.  */
1282   int id;
1283   /* The LABEL_EXPR marking this entry point.  */
1284   tree label;
1285   /* The next item in the list.  */
1286   struct gfc_entry_list *next;
1287 }
1288 gfc_entry_list;
1289
1290 #define gfc_get_entry_list() XCNEW (gfc_entry_list)
1291
1292 /* Lists of rename info for the USE statement.  */
1293
1294 typedef struct gfc_use_rename
1295 {
1296   char local_name[GFC_MAX_SYMBOL_LEN + 1], use_name[GFC_MAX_SYMBOL_LEN + 1];
1297   struct gfc_use_rename *next;
1298   int found;
1299   gfc_intrinsic_op op;
1300   locus where;
1301 }
1302 gfc_use_rename;
1303
1304 #define gfc_get_use_rename() XCNEW (gfc_use_rename);
1305
1306 /* A list of all USE statements in a namespace.  */
1307
1308 typedef struct gfc_use_list
1309 {
1310   const char *module_name;
1311   bool intrinsic;
1312   bool non_intrinsic;
1313   bool only_flag;
1314   struct gfc_use_rename *rename;
1315   locus where;
1316   /* Next USE statement.  */
1317   struct gfc_use_list *next;
1318 }
1319 gfc_use_list;
1320
1321 #define gfc_get_use_list() XCNEW (gfc_use_list)
1322
1323 /* Within a namespace, symbols are pointed to by symtree nodes that
1324    are linked together in a balanced binary tree.  There can be
1325    several symtrees pointing to the same symbol node via USE
1326    statements.  */
1327
1328 typedef struct gfc_symtree
1329 {
1330   BBT_HEADER (gfc_symtree);
1331   const char *name;
1332   int ambiguous;
1333   union
1334   {
1335     gfc_symbol *sym;            /* Symbol associated with this node */
1336     gfc_user_op *uop;
1337     gfc_common_head *common;
1338     gfc_typebound_proc *tb;
1339   }
1340   n;
1341 }
1342 gfc_symtree;
1343
1344 /* A linked list of derived types in the namespace.  */
1345 typedef struct gfc_dt_list
1346 {
1347   struct gfc_symbol *derived;
1348   struct gfc_dt_list *next;
1349 }
1350 gfc_dt_list;
1351
1352 #define gfc_get_dt_list() XCNEW (gfc_dt_list)
1353
1354   /* A list of all derived types.  */
1355   extern gfc_dt_list *gfc_derived_types;
1356
1357 /* A namespace describes the contents of procedure, module, interface block
1358    or BLOCK construct.  */
1359 /* ??? Anything else use these?  */
1360
1361 typedef struct gfc_namespace
1362 {
1363   /* Tree containing all the symbols in this namespace.  */
1364   gfc_symtree *sym_root;
1365   /* Tree containing all the user-defined operators in the namespace.  */
1366   gfc_symtree *uop_root;
1367   /* Tree containing all the common blocks.  */
1368   gfc_symtree *common_root;
1369
1370   /* Tree containing type-bound procedures.  */
1371   gfc_symtree *tb_sym_root;
1372   /* Type-bound user operators.  */
1373   gfc_symtree *tb_uop_root;
1374   /* For derived-types, store type-bound intrinsic operators here.  */
1375   gfc_typebound_proc *tb_op[GFC_INTRINSIC_OPS];
1376   /* Linked list of finalizer procedures.  */
1377   struct gfc_finalizer *finalizers;
1378
1379   /* If set_flag[letter] is set, an implicit type has been set for letter.  */
1380   int set_flag[GFC_LETTERS];
1381   /* Keeps track of the implicit types associated with the letters.  */
1382   gfc_typespec default_type[GFC_LETTERS];
1383   /* Store the positions of IMPLICIT statements.  */
1384   locus implicit_loc[GFC_LETTERS];
1385
1386   /* If this is a namespace of a procedure, this points to the procedure.  */
1387   struct gfc_symbol *proc_name;
1388   /* If this is the namespace of a unit which contains executable
1389      code, this points to it.  */
1390   struct gfc_code *code;
1391
1392   /* Points to the equivalences set up in this namespace.  */
1393   struct gfc_equiv *equiv, *old_equiv;
1394
1395   /* Points to the equivalence groups produced by trans_common.  */
1396   struct gfc_equiv_list *equiv_lists;
1397
1398   gfc_interface *op[GFC_INTRINSIC_OPS];
1399
1400   /* Points to the parent namespace, i.e. the namespace of a module or
1401      procedure in which the procedure belonging to this namespace is
1402      contained. The parent namespace points to this namespace either
1403      directly via CONTAINED, or indirectly via the chain built by
1404      SIBLING.  */
1405   struct gfc_namespace *parent;
1406   /* CONTAINED points to the first contained namespace. Sibling
1407      namespaces are chained via SIBLING.  */
1408   struct gfc_namespace  *contained, *sibling;
1409
1410   gfc_common_head blank_common;
1411   gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
1412
1413   gfc_st_label *st_labels;
1414   /* This list holds information about all the data initializers in
1415      this namespace.  */
1416   struct gfc_data *data;
1417
1418   gfc_charlen *cl_list, *old_cl_list;
1419
1420   gfc_dt_list *derived_types;
1421
1422   int save_all, seen_save, seen_implicit_none;
1423
1424   /* Normally we don't need to refcount namespaces.  However when we read
1425      a module containing a function with multiple entry points, this
1426      will appear as several functions with the same formal namespace.  */
1427   int refs;
1428
1429   /* A list of all alternate entry points to this procedure (or NULL).  */
1430   gfc_entry_list *entries;
1431
1432   /* A list of USE statements in this namespace.  */
1433   gfc_use_list *use_stmts;
1434
1435   /* Set to 1 if namespace is a BLOCK DATA program unit.  */
1436   unsigned is_block_data:1;
1437
1438   /* Set to 1 if namespace is an interface body with "IMPORT" used.  */
1439   unsigned has_import_set:1;
1440
1441   /* Set to 1 if resolved has been called for this namespace.
1442      Holds -1 during resolution.  */
1443   signed resolved:2;
1444
1445   /* Set to 1 if code has been generated for this namespace.  */
1446   unsigned translated:1;
1447
1448   /* Set to 1 if symbols in this namespace should be 'construct entities',
1449      i.e. for BLOCK local variables.  */
1450   unsigned construct_entities:1;
1451 }
1452 gfc_namespace;
1453
1454 extern gfc_namespace *gfc_current_ns;
1455 extern gfc_namespace *gfc_global_ns_list;
1456
1457 /* Global symbols are symbols of global scope. Currently we only use
1458    this to detect collisions already when parsing.
1459    TODO: Extend to verify procedure calls.  */
1460
1461 enum gfc_symbol_type
1462 {
1463   GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
1464   GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA
1465 };
1466
1467 typedef struct gfc_gsymbol
1468 {
1469   BBT_HEADER(gfc_gsymbol);
1470
1471   const char *name;
1472   const char *sym_name;
1473   const char *mod_name;
1474   const char *binding_label;
1475   enum gfc_symbol_type type;
1476
1477   int defined, used;
1478   locus where;
1479   gfc_namespace *ns;
1480 }
1481 gfc_gsymbol;
1482
1483 extern gfc_gsymbol *gfc_gsym_root;
1484
1485 /* Information on interfaces being built.  */
1486 typedef struct
1487 {
1488   interface_type type;
1489   gfc_symbol *sym;
1490   gfc_namespace *ns;
1491   gfc_user_op *uop;
1492   gfc_intrinsic_op op;
1493 }
1494 gfc_interface_info;
1495
1496 extern gfc_interface_info current_interface;
1497
1498
1499 /* Array reference.  */
1500
1501 enum gfc_array_ref_dimen_type
1502 {
1503   DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_STAR, DIMEN_THIS_IMAGE, DIMEN_UNKNOWN
1504 };
1505
1506 typedef struct gfc_array_ref
1507 {
1508   ar_type type;
1509   int dimen;                    /* # of components in the reference */
1510   int codimen;
1511   bool in_allocate;             /* For coarray checks. */
1512   locus where;
1513   gfc_array_spec *as;
1514
1515   locus c_where[GFC_MAX_DIMENSIONS];    /* All expressions can be NULL */
1516   struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
1517     *stride[GFC_MAX_DIMENSIONS];
1518
1519   enum gfc_array_ref_dimen_type dimen_type[GFC_MAX_DIMENSIONS];
1520
1521   struct gfc_expr *offset;
1522 }
1523 gfc_array_ref;
1524
1525 #define gfc_get_array_ref() XCNEW (gfc_array_ref)
1526
1527
1528 /* Component reference nodes.  A variable is stored as an expression
1529    node that points to the base symbol.  After that, a singly linked
1530    list of component reference nodes gives the variable's complete
1531    resolution.  The array_ref component may be present and comes
1532    before the component component.  */
1533
1534 typedef enum
1535   { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING }
1536 ref_type;
1537
1538 typedef struct gfc_ref
1539 {
1540   ref_type type;
1541
1542   union
1543   {
1544     struct gfc_array_ref ar;
1545
1546     struct
1547     {
1548       gfc_component *component;
1549       gfc_symbol *sym;
1550     }
1551     c;
1552
1553     struct
1554     {
1555       struct gfc_expr *start, *end;     /* Substring */
1556       gfc_charlen *length;
1557     }
1558     ss;
1559
1560   }
1561   u;
1562
1563   struct gfc_ref *next;
1564 }
1565 gfc_ref;
1566
1567 #define gfc_get_ref() XCNEW (gfc_ref)
1568
1569
1570 /* Structures representing intrinsic symbols and their arguments lists.  */
1571 typedef struct gfc_intrinsic_arg
1572 {
1573   char name[GFC_MAX_SYMBOL_LEN + 1];
1574
1575   gfc_typespec ts;
1576   unsigned optional:1, value:1;
1577   ENUM_BITFIELD (sym_intent) intent:2;
1578   gfc_actual_arglist *actual;
1579
1580   struct gfc_intrinsic_arg *next;
1581
1582 }
1583 gfc_intrinsic_arg;
1584
1585
1586 /* Specifies the various kinds of check functions used to verify the
1587    argument lists of intrinsic functions. fX with X an integer refer
1588    to check functions of intrinsics with X arguments. f1m is used for
1589    the MAX and MIN intrinsics which can have an arbitrary number of
1590    arguments, f3ml is used for the MINLOC and MAXLOC intrinsics as
1591    these have special semantics.  */
1592
1593 typedef union
1594 {
1595   gfc_try (*f0)(void);
1596   gfc_try (*f1)(struct gfc_expr *);
1597   gfc_try (*f1m)(gfc_actual_arglist *);
1598   gfc_try (*f2)(struct gfc_expr *, struct gfc_expr *);
1599   gfc_try (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1600   gfc_try (*f3ml)(gfc_actual_arglist *);
1601   gfc_try (*f3red)(gfc_actual_arglist *);
1602   gfc_try (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1603             struct gfc_expr *);
1604   gfc_try (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1605             struct gfc_expr *, struct gfc_expr *);
1606 }
1607 gfc_check_f;
1608
1609 /* Like gfc_check_f, these specify the type of the simplification
1610    function associated with an intrinsic. The fX are just like in
1611    gfc_check_f. cc is used for type conversion functions.  */
1612
1613 typedef union
1614 {
1615   struct gfc_expr *(*f0)(void);
1616   struct gfc_expr *(*f1)(struct gfc_expr *);
1617   struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
1618   struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
1619                          struct gfc_expr *);
1620   struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
1621                          struct gfc_expr *, struct gfc_expr *);
1622   struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
1623                          struct gfc_expr *, struct gfc_expr *,
1624                          struct gfc_expr *);
1625   struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
1626 }
1627 gfc_simplify_f;
1628
1629 /* Again like gfc_check_f, these specify the type of the resolution
1630    function associated with an intrinsic. The fX are just like in
1631    gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort().  */
1632
1633 typedef union
1634 {
1635   void (*f0)(struct gfc_expr *);
1636   void (*f1)(struct gfc_expr *, struct gfc_expr *);
1637   void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
1638   void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1639   void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1640              struct gfc_expr *);
1641   void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1642              struct gfc_expr *, struct gfc_expr *);
1643   void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
1644              struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
1645   void (*s1)(struct gfc_code *);
1646 }
1647 gfc_resolve_f;
1648
1649
1650 typedef struct gfc_intrinsic_sym
1651 {
1652   const char *name, *lib_name;
1653   gfc_intrinsic_arg *formal;
1654   gfc_typespec ts;
1655   unsigned elemental:1, inquiry:1, transformational:1, pure:1,
1656     generic:1, specific:1, actual_ok:1, noreturn:1, conversion:1,
1657     from_module:1;
1658
1659   int standard;
1660
1661   gfc_simplify_f simplify;
1662   gfc_check_f check;
1663   gfc_resolve_f resolve;
1664   struct gfc_intrinsic_sym *specific_head, *next;
1665   gfc_isym_id id;
1666
1667 }
1668 gfc_intrinsic_sym;
1669
1670
1671 /* Expression nodes.  The expression node types deserve explanations,
1672    since the last couple can be easily misconstrued:
1673
1674    EXPR_OP         Operator node pointing to one or two other nodes
1675    EXPR_FUNCTION   Function call, symbol points to function's name
1676    EXPR_CONSTANT   A scalar constant: Logical, String, Real, Int or Complex
1677    EXPR_VARIABLE   An Lvalue with a root symbol and possible reference list
1678                    which expresses structure, array and substring refs.
1679    EXPR_NULL       The NULL pointer value (which also has a basic type).
1680    EXPR_SUBSTRING  A substring of a constant string
1681    EXPR_STRUCTURE  A structure constructor
1682    EXPR_ARRAY      An array constructor.
1683    EXPR_COMPCALL   Function (or subroutine) call of a procedure pointer
1684                    component or type-bound procedure.  */
1685
1686 #include <gmp.h>
1687 #include <mpfr.h>
1688 #include <mpc.h>
1689 #define GFC_RND_MODE GMP_RNDN
1690 #define GFC_MPC_RND_MODE MPC_RNDNN
1691
1692 typedef splay_tree gfc_constructor_base;
1693
1694 typedef struct gfc_expr
1695 {
1696   expr_t expr_type;
1697
1698   gfc_typespec ts;      /* These two refer to the overall expression */
1699
1700   int rank;
1701   mpz_t *shape;         /* Can be NULL if shape is unknown at compile time */
1702
1703   /* Nonnull for functions and structure constructors, may also used to hold the
1704      base-object for component calls.  */
1705   gfc_symtree *symtree;
1706
1707   gfc_ref *ref;
1708
1709   locus where;
1710
1711   /* Used to store the base expression in component calls, when the expression
1712      is not a variable.  */
1713   struct gfc_expr *base_expr;
1714
1715   /* is_boz is true if the integer is regarded as BOZ bitpatten and is_snan
1716      denotes a signalling not-a-number.  */
1717   unsigned int is_boz : 1, is_snan : 1;
1718
1719   /* Sometimes, when an error has been emitted, it is necessary to prevent
1720       it from recurring.  */
1721   unsigned int error : 1;
1722
1723   /* Mark an expression where a user operator has been substituted by
1724      a function call in interface.c(gfc_extend_expr).  */
1725   unsigned int user_operator : 1;
1726
1727   /* Mark an expression as being a MOLD argument of ALLOCATE.  */
1728   unsigned int mold : 1;
1729
1730   /* If an expression comes from a Hollerith constant or compile-time
1731      evaluation of a transfer statement, it may have a prescribed target-
1732      memory representation, and these cannot always be backformed from
1733      the value.  */
1734   struct
1735   {
1736     int length;
1737     char *string;
1738   }
1739   representation;
1740
1741   union
1742   {
1743     int logical;
1744
1745     io_kind iokind;
1746
1747     mpz_t integer;
1748
1749     mpfr_t real;
1750
1751     mpc_t complex;
1752
1753     struct
1754     {
1755       gfc_intrinsic_op op;
1756       gfc_user_op *uop;
1757       struct gfc_expr *op1, *op2;
1758     }
1759     op;
1760
1761     struct
1762     {
1763       gfc_actual_arglist *actual;
1764       const char *name; /* Points to the ultimate name of the function */
1765       gfc_intrinsic_sym *isym;
1766       gfc_symbol *esym;
1767     }
1768     function;
1769
1770     struct
1771     {
1772       gfc_actual_arglist* actual;
1773       const char* name;
1774       /* Base-object, whose component was called.  NULL means that it should
1775          be taken from symtree/ref.  */
1776       struct gfc_expr* base_object;
1777       gfc_typebound_proc* tbp; /* Should overlap with esym.  */
1778
1779       /* For type-bound operators, we want to call PASS procedures but already
1780          have the full arglist; mark this, so that it is not extended by the
1781          PASS argument.  */
1782       unsigned ignore_pass:1;
1783
1784       /* Do assign-calls rather than calls, that is appropriate dependency
1785          checking.  */
1786       unsigned assign:1;
1787     }
1788     compcall;
1789
1790     struct
1791     {
1792       int length;
1793       gfc_char_t *string;
1794     }
1795     character;
1796
1797     gfc_constructor_base constructor;
1798   }
1799   value;
1800
1801 }
1802 gfc_expr;
1803
1804
1805 #define gfc_get_shape(rank) (XCNEWVEC (mpz_t, (rank)))
1806
1807 /* Structures for information associated with different kinds of
1808    numbers.  The first set of integer parameters define all there is
1809    to know about a particular kind.  The rest of the elements are
1810    computed from the first elements.  */
1811
1812 typedef struct
1813 {
1814   /* Values really representable by the target.  */
1815   mpz_t huge, pedantic_min_int, min_int;
1816
1817   int kind, radix, digits, bit_size, range;
1818
1819   /* True if the C type of the given name maps to this precision.
1820      Note that more than one bit can be set.  */
1821   unsigned int c_char : 1;
1822   unsigned int c_short : 1;
1823   unsigned int c_int : 1;
1824   unsigned int c_long : 1;
1825   unsigned int c_long_long : 1;
1826 }
1827 gfc_integer_info;
1828
1829 extern gfc_integer_info gfc_integer_kinds[];
1830
1831
1832 typedef struct
1833 {
1834   int kind, bit_size;
1835
1836   /* True if the C++ type bool, C99 type _Bool, maps to this precision.  */
1837   unsigned int c_bool : 1;
1838 }
1839 gfc_logical_info;
1840
1841 extern gfc_logical_info gfc_logical_kinds[];
1842
1843
1844 typedef struct
1845 {
1846   mpfr_t epsilon, huge, tiny, subnormal;
1847   int kind, radix, digits, min_exponent, max_exponent;
1848   int range, precision;
1849
1850   /* The precision of the type as reported by GET_MODE_PRECISION.  */
1851   int mode_precision;
1852
1853   /* True if the C type of the given name maps to this precision.
1854      Note that more than one bit can be set.  */
1855   unsigned int c_float : 1;
1856   unsigned int c_double : 1;
1857   unsigned int c_long_double : 1;
1858   unsigned int c_float128 : 1;
1859 }
1860 gfc_real_info;
1861
1862 extern gfc_real_info gfc_real_kinds[];
1863
1864 typedef struct
1865 {
1866   int kind, bit_size;
1867   const char *name;
1868 }
1869 gfc_character_info;
1870
1871 extern gfc_character_info gfc_character_kinds[];
1872
1873
1874 /* Equivalence structures.  Equivalent lvalues are linked along the
1875    *eq pointer, equivalence sets are strung along the *next node.  */
1876 typedef struct gfc_equiv
1877 {
1878   struct gfc_equiv *next, *eq;
1879   gfc_expr *expr;
1880   const char *module;
1881   int used;
1882 }
1883 gfc_equiv;
1884
1885 #define gfc_get_equiv() XCNEW (gfc_equiv)
1886
1887 /* Holds a single equivalence member after processing.  */
1888 typedef struct gfc_equiv_info
1889 {
1890   gfc_symbol *sym;
1891   HOST_WIDE_INT offset;
1892   HOST_WIDE_INT length;
1893   struct gfc_equiv_info *next;
1894 } gfc_equiv_info;
1895
1896 /* Holds equivalence groups, after they have been processed.  */
1897 typedef struct gfc_equiv_list
1898 {
1899   gfc_equiv_info *equiv;
1900   struct gfc_equiv_list *next;
1901 } gfc_equiv_list;
1902
1903 /* gfc_case stores the selector list of a case statement.  The *low
1904    and *high pointers can point to the same expression in the case of
1905    a single value.  If *high is NULL, the selection is from *low
1906    upwards, if *low is NULL the selection is *high downwards.
1907
1908    This structure has separate fields to allow single and double linked
1909    lists of CASEs at the same time.  The singe linked list along the NEXT
1910    field is a list of cases for a single CASE label.  The double linked
1911    list along the LEFT/RIGHT fields is used to detect overlap and to
1912    build a table of the cases for SELECT constructs with a CHARACTER
1913    case expression.  */
1914
1915 typedef struct gfc_case
1916 {
1917   /* Where we saw this case.  */
1918   locus where;
1919   int n;
1920
1921   /* Case range values.  If (low == high), it's a single value.  If one of
1922      the labels is NULL, it's an unbounded case.  If both are NULL, this
1923      represents the default case.  */
1924   gfc_expr *low, *high;
1925
1926   /* Only used for SELECT TYPE.  */
1927   gfc_typespec ts;
1928
1929   /* Next case label in the list of cases for a single CASE label.  */
1930   struct gfc_case *next;
1931
1932   /* Used for detecting overlap, and for code generation.  */
1933   struct gfc_case *left, *right;
1934
1935   /* True if this case label can never be matched.  */
1936   int unreachable;
1937 }
1938 gfc_case;
1939
1940 #define gfc_get_case() XCNEW (gfc_case)
1941
1942
1943 typedef struct
1944 {
1945   gfc_expr *var, *start, *end, *step;
1946 }
1947 gfc_iterator;
1948
1949 #define gfc_get_iterator() XCNEW (gfc_iterator)
1950
1951
1952 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements.  */
1953
1954 typedef struct gfc_alloc
1955 {
1956   gfc_expr *expr;
1957   struct gfc_alloc *next;
1958 }
1959 gfc_alloc;
1960
1961 #define gfc_get_alloc() XCNEW (gfc_alloc)
1962
1963
1964 typedef struct
1965 {
1966   gfc_expr *unit, *file, *status, *access, *form, *recl,
1967     *blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert,
1968     *decimal, *encoding, *round, *sign, *asynchronous, *id, *newunit;
1969   gfc_st_label *err;
1970 }
1971 gfc_open;
1972
1973
1974 typedef struct
1975 {
1976   gfc_expr *unit, *status, *iostat, *iomsg;
1977   gfc_st_label *err;
1978 }
1979 gfc_close;
1980
1981
1982 typedef struct
1983 {
1984   gfc_expr *unit, *iostat, *iomsg;
1985   gfc_st_label *err;
1986 }
1987 gfc_filepos;
1988
1989
1990 typedef struct
1991 {
1992   gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
1993     *name, *access, *sequential, *direct, *form, *formatted,
1994     *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
1995     *write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert, *strm_pos,
1996     *asynchronous, *decimal, *encoding, *pending, *round, *sign, *size, *id;
1997
1998   gfc_st_label *err;
1999
2000 }
2001 gfc_inquire;
2002
2003
2004 typedef struct
2005 {
2006   gfc_expr *unit, *iostat, *iomsg, *id;
2007   gfc_st_label *err, *end, *eor;
2008 }
2009 gfc_wait;
2010
2011
2012 typedef struct
2013 {
2014   gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg,
2015            *id, *pos, *asynchronous, *blank, *decimal, *delim, *pad, *round,
2016            *sign, *extra_comma, *dt_io_kind;
2017
2018   gfc_symbol *namelist;
2019   /* A format_label of `format_asterisk' indicates the "*" format */
2020   gfc_st_label *format_label;
2021   gfc_st_label *err, *end, *eor;
2022
2023   locus eor_where, end_where, err_where;
2024 }
2025 gfc_dt;
2026
2027
2028 typedef struct gfc_forall_iterator
2029 {
2030   gfc_expr *var, *start, *end, *stride;
2031   struct gfc_forall_iterator *next;
2032 }
2033 gfc_forall_iterator;
2034
2035
2036 /* Linked list to store associations in an ASSOCIATE statement.  */
2037
2038 typedef struct gfc_association_list
2039 {
2040   struct gfc_association_list *next;
2041
2042   /* Whether this is association to a variable that can be changed; otherwise,
2043      it's association to an expression and the name may not be used as
2044      lvalue.  */
2045   unsigned variable:1;
2046
2047   /* True if this struct is currently only linked to from a gfc_symbol rather
2048      than as part of a real list in gfc_code->ext.block.assoc.  This may
2049      happen for SELECT TYPE temporaries and must be considered
2050      for memory handling.  */
2051   unsigned dangling:1;
2052
2053   char name[GFC_MAX_SYMBOL_LEN + 1];
2054   gfc_symtree *st; /* Symtree corresponding to name.  */
2055   locus where;
2056
2057   gfc_expr *target;
2058 }
2059 gfc_association_list;
2060 #define gfc_get_association_list() XCNEW (gfc_association_list)
2061
2062
2063 /* Executable statements that fill gfc_code structures.  */
2064 typedef enum
2065 {
2066   EXEC_NOP = 1, EXEC_END_NESTED_BLOCK, EXEC_END_BLOCK, EXEC_ASSIGN,
2067   EXEC_LABEL_ASSIGN, EXEC_POINTER_ASSIGN, EXEC_CRITICAL, EXEC_ERROR_STOP,
2068   EXEC_GOTO, EXEC_CALL, EXEC_COMPCALL, EXEC_ASSIGN_CALL, EXEC_RETURN,
2069   EXEC_ENTRY, EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE, EXEC_INIT_ASSIGN,
2070   EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_CONCURRENT, EXEC_DO_WHILE,
2071   EXEC_SELECT, EXEC_BLOCK, EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT,
2072   EXEC_CALL_PPC, EXEC_ALLOCATE, EXEC_DEALLOCATE, EXEC_END_PROCEDURE,
2073   EXEC_SELECT_TYPE, EXEC_SYNC_ALL, EXEC_SYNC_MEMORY, EXEC_SYNC_IMAGES,
2074   EXEC_OPEN, EXEC_CLOSE, EXEC_WAIT,
2075   EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
2076   EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
2077   EXEC_LOCK, EXEC_UNLOCK,
2078   EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
2079   EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
2080   EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
2081   EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
2082   EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
2083   EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT,
2084   EXEC_OMP_TASKYIELD
2085 }
2086 gfc_exec_op;
2087
2088 typedef enum
2089 {
2090   GFC_OMP_ATOMIC_UPDATE,
2091   GFC_OMP_ATOMIC_READ,
2092   GFC_OMP_ATOMIC_WRITE,
2093   GFC_OMP_ATOMIC_CAPTURE
2094 }
2095 gfc_omp_atomic_op;
2096
2097 typedef struct gfc_code
2098 {
2099   gfc_exec_op op;
2100
2101   struct gfc_code *block, *next;
2102   locus loc;
2103
2104   gfc_st_label *here, *label1, *label2, *label3;
2105   gfc_symtree *symtree;
2106   gfc_expr *expr1, *expr2, *expr3, *expr4;
2107   /* A name isn't sufficient to identify a subroutine, we need the actual
2108      symbol for the interface definition.
2109   const char *sub_name;  */
2110   gfc_symbol *resolved_sym;
2111   gfc_intrinsic_sym *resolved_isym;
2112
2113   union
2114   {
2115     gfc_actual_arglist *actual;
2116     gfc_iterator *iterator;
2117
2118     struct
2119     {
2120       gfc_typespec ts;
2121       gfc_alloc *list;
2122     }
2123     alloc;
2124
2125     struct
2126     {
2127       gfc_namespace *ns;
2128       gfc_association_list *assoc;
2129       gfc_case *case_list;
2130     }
2131     block;
2132
2133     gfc_open *open;
2134     gfc_close *close;
2135     gfc_filepos *filepos;
2136     gfc_inquire *inquire;
2137     gfc_wait *wait;
2138     gfc_dt *dt;
2139     gfc_forall_iterator *forall_iterator;
2140     struct gfc_code *which_construct;
2141     int stop_code;
2142     gfc_entry_list *entry;
2143     gfc_omp_clauses *omp_clauses;
2144     const char *omp_name;
2145     gfc_namelist *omp_namelist;
2146     bool omp_bool;
2147     gfc_omp_atomic_op omp_atomic;
2148   }
2149   ext;          /* Points to additional structures required by statement */
2150
2151   /* Cycle and break labels in constructs.  */
2152   tree cycle_label;
2153   tree exit_label;
2154 }
2155 gfc_code;
2156
2157
2158 /* Storage for DATA statements.  */
2159 typedef struct gfc_data_variable
2160 {
2161   gfc_expr *expr;
2162   gfc_iterator iter;
2163   struct gfc_data_variable *list, *next;
2164 }
2165 gfc_data_variable;
2166
2167
2168 typedef struct gfc_data_value
2169 {
2170   mpz_t repeat;
2171   gfc_expr *expr;
2172   struct gfc_data_value *next;
2173 }
2174 gfc_data_value;
2175
2176
2177 typedef struct gfc_data
2178 {
2179   gfc_data_variable *var;
2180   gfc_data_value *value;
2181   locus where;
2182
2183   struct gfc_data *next;
2184 }
2185 gfc_data;
2186
2187
2188 /* Structure for holding compile options */
2189 typedef struct
2190 {
2191   char *module_dir;
2192   gfc_source_form source_form;
2193   /* Maximum line lengths in fixed- and free-form source, respectively.
2194      When fixed_line_length or free_line_length are 0, the whole line is used,
2195      regardless of length.
2196
2197      If the user requests a fixed_line_length <7 then gfc_init_options()
2198      emits a fatal error.  */
2199   int fixed_line_length;
2200   int free_line_length;
2201   /* Maximum number of continuation lines in fixed- and free-form source,
2202      respectively.  */
2203   int max_continue_fixed;
2204   int max_continue_free;
2205   int max_identifier_length;
2206   int dump_fortran_original;
2207   int dump_fortran_optimized;
2208
2209   int warn_aliasing;
2210   int warn_ampersand;
2211   int gfc_warn_conversion;
2212   int warn_conversion_extra;
2213   int warn_function_elimination;
2214   int warn_implicit_interface;
2215   int warn_implicit_procedure;
2216   int warn_line_truncation;
2217   int warn_surprising;
2218   int warn_tabs;
2219   int warn_underflow;
2220   int warn_intrinsic_shadow;
2221   int warn_intrinsics_std;
2222   int warn_character_truncation;
2223   int warn_array_temp;
2224   int warn_align_commons;
2225   int warn_real_q_constant;
2226   int warn_unused_dummy_argument;
2227   int max_errors;
2228
2229   int flag_all_intrinsics;
2230   int flag_default_double;
2231   int flag_default_integer;
2232   int flag_default_real;
2233   int flag_integer4_kind;
2234   int flag_real4_kind;
2235   int flag_real8_kind;
2236   int flag_dollar_ok;
2237   int flag_underscoring;
2238   int flag_second_underscore;
2239   int flag_implicit_none;
2240   int flag_max_stack_var_size;
2241   int flag_max_array_constructor;
2242   int flag_range_check;
2243   int flag_pack_derived;
2244   int flag_repack_arrays;
2245   int flag_preprocessed;
2246   int flag_f2c;
2247   int flag_automatic;
2248   int flag_backslash;
2249   int flag_backtrace;
2250   int flag_allow_leading_underscore;
2251   int flag_external_blas;
2252   int blas_matmul_limit;
2253   int flag_cray_pointer;
2254   int flag_d_lines;
2255   int gfc_flag_openmp;
2256   int flag_sign_zero;
2257   int flag_stack_arrays;
2258   int flag_module_private;
2259   int flag_recursive;
2260   int flag_init_local_zero;
2261   int flag_init_integer;
2262   int flag_init_integer_value;
2263   int flag_init_real;
2264   int flag_init_logical;
2265   int flag_init_character;
2266   char flag_init_character_value;
2267   int flag_align_commons;
2268   int flag_whole_file;
2269   int flag_protect_parens;
2270   int flag_realloc_lhs;
2271   int flag_aggressive_function_elimination;
2272   int flag_frontend_optimize;
2273
2274   int fpe;
2275   int rtcheck;
2276   gfc_fcoarray coarray;
2277
2278   int warn_std;
2279   int allow_std;
2280   int convert;
2281   int record_marker;
2282   int max_subrecord_length;
2283 }
2284 gfc_option_t;
2285
2286 extern gfc_option_t gfc_option;
2287
2288 /* Constructor nodes for array and structure constructors.  */
2289 typedef struct gfc_constructor
2290 {
2291   gfc_constructor_base base;
2292   mpz_t offset;               /* Offset within a constructor, used as
2293                                  key within base. */
2294
2295   gfc_expr *expr;
2296   gfc_iterator *iterator;
2297   locus where;
2298
2299   union
2300   {
2301      gfc_component *component; /* Record the component being initialized.  */
2302   }
2303   n;
2304   mpz_t repeat; /* Record the repeat number of initial values in data
2305                   statement like "data a/5*10/".  */
2306 }
2307 gfc_constructor;
2308
2309
2310 typedef struct iterator_stack
2311 {
2312   gfc_symtree *variable;
2313   mpz_t value;
2314   struct iterator_stack *prev;
2315 }
2316 iterator_stack;
2317 extern iterator_stack *iter_stack;
2318
2319
2320 /* Used for (possibly nested) SELECT TYPE statements.  */
2321 typedef struct gfc_select_type_stack
2322 {
2323   gfc_symbol *selector;                 /* Current selector variable.  */
2324   gfc_symtree *tmp;                     /* Current temporary variable.  */
2325   struct gfc_select_type_stack *prev;   /* Previous element on stack.  */
2326 }
2327 gfc_select_type_stack;
2328 extern gfc_select_type_stack *select_type_stack;
2329 #define gfc_get_select_type_stack() XCNEW (gfc_select_type_stack)
2330
2331
2332 /* Node in the linked list used for storing finalizer procedures.  */
2333
2334 typedef struct gfc_finalizer
2335 {
2336   struct gfc_finalizer* next;
2337   locus where; /* Where the FINAL declaration occurred.  */
2338
2339   /* Up to resolution, we want the gfc_symbol, there we lookup the corresponding
2340      symtree and later need only that.  This way, we can access and call the
2341      finalizers from every context as they should be "always accessible".  I
2342      don't make this a union because we need the information whether proc_sym is
2343      still referenced or not for dereferencing it on deleting a gfc_finalizer
2344      structure.  */
2345   gfc_symbol*  proc_sym;
2346   gfc_symtree* proc_tree;
2347 }
2348 gfc_finalizer;
2349 #define gfc_get_finalizer() XCNEW (gfc_finalizer)
2350
2351
2352 /************************ Function prototypes *************************/
2353
2354 /* decl.c */
2355 bool gfc_in_match_data (void);
2356 match gfc_match_char_spec (gfc_typespec *);
2357
2358 /* scanner.c */
2359 void gfc_scanner_done_1 (void);
2360 void gfc_scanner_init_1 (void);
2361
2362 void gfc_add_include_path (const char *, bool, bool);
2363 void gfc_add_intrinsic_modules_path (const char *);
2364 void gfc_release_include_path (void);
2365 FILE *gfc_open_included_file (const char *, bool, bool);
2366 FILE *gfc_open_intrinsic_module (const char *);
2367
2368 int gfc_at_end (void);
2369 int gfc_at_eof (void);
2370 int gfc_at_bol (void);
2371 int gfc_at_eol (void);
2372 void gfc_advance_line (void);
2373 int gfc_check_include (void);
2374 int gfc_define_undef_line (void);
2375
2376 int gfc_wide_is_printable (gfc_char_t);
2377 int gfc_wide_is_digit (gfc_char_t);
2378 int gfc_wide_fits_in_byte (gfc_char_t);
2379 gfc_char_t gfc_wide_tolower (gfc_char_t);
2380 gfc_char_t gfc_wide_toupper (gfc_char_t);
2381 size_t gfc_wide_strlen (const gfc_char_t *);
2382 int gfc_wide_strncasecmp (const gfc_char_t *, const char *, size_t);
2383 gfc_char_t *gfc_wide_memset (gfc_char_t *, gfc_char_t, size_t);
2384 char *gfc_widechar_to_char (const gfc_char_t *, int);
2385 gfc_char_t *gfc_char_to_widechar (const char *);
2386
2387 #define gfc_get_wide_string(n) XCNEWVEC (gfc_char_t, n)
2388
2389 void gfc_skip_comments (void);
2390 gfc_char_t gfc_next_char_literal (gfc_instring);
2391 gfc_char_t gfc_next_char (void);
2392 char gfc_next_ascii_char (void);
2393 gfc_char_t gfc_peek_char (void);
2394 char gfc_peek_ascii_char (void);
2395 void gfc_error_recovery (void);
2396 void gfc_gobble_whitespace (void);
2397 gfc_try gfc_new_file (void);
2398 const char * gfc_read_orig_filename (const char *, const char **);
2399
2400 extern gfc_source_form gfc_current_form;
2401 extern const char *gfc_source_file;
2402 extern locus gfc_current_locus;
2403
2404 void gfc_start_source_files (void);
2405 void gfc_end_source_files (void);
2406
2407 /* misc.c */
2408 int gfc_terminal_width (void);
2409 void gfc_clear_ts (gfc_typespec *);
2410 FILE *gfc_open_file (const char *);
2411 const char *gfc_basic_typename (bt);
2412 const char *gfc_typename (gfc_typespec *);
2413 const char *gfc_op2string (gfc_intrinsic_op);
2414 const char *gfc_code2string (const mstring *, int);
2415 int gfc_string2code (const mstring *, const char *);
2416 const char *gfc_intent_string (sym_intent);
2417
2418 void gfc_init_1 (void);
2419 void gfc_init_2 (void);
2420 void gfc_done_1 (void);
2421 void gfc_done_2 (void);
2422
2423 int get_c_kind (const char *, CInteropKind_t *);
2424
2425 /* options.c */
2426 unsigned int gfc_option_lang_mask (void);
2427 void gfc_init_options_struct (struct gcc_options *);
2428 void gfc_init_options (unsigned int,
2429                        struct cl_decoded_option *);
2430 bool gfc_handle_option (size_t, const char *, int, int, location_t,
2431                         const struct cl_option_handlers *);
2432 bool gfc_post_options (const char **);
2433 char *gfc_get_option_string (void);
2434
2435 /* f95-lang.c */
2436 void gfc_maybe_initialize_eh (void);
2437
2438 /* iresolve.c */
2439 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
2440 bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *);
2441
2442 /* error.c */
2443
2444 typedef struct gfc_error_buf
2445 {
2446   int flag;
2447   size_t allocated, index;
2448   char *message;
2449 } gfc_error_buf;
2450
2451 void gfc_error_init_1 (void);
2452 void gfc_buffer_error (int);
2453
2454 const char *gfc_print_wide_char (gfc_char_t);
2455
2456 void gfc_warning (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2457 void gfc_warning_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2458 void gfc_clear_warning (void);
2459 void gfc_warning_check (void);
2460
2461 void gfc_error (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2462 void gfc_error_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
2463 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2464 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
2465 void gfc_clear_error (void);
2466 int gfc_error_check (void);
2467 int gfc_error_flag_test (void);
2468
2469 notification gfc_notification_std (int);
2470 gfc_try gfc_notify_std (int, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
2471
2472 /* A general purpose syntax error.  */
2473 #define gfc_syntax_error(ST)    \
2474   gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
2475
2476 void gfc_push_error (gfc_error_buf *);
2477 void gfc_pop_error (gfc_error_buf *);
2478 void gfc_free_error (gfc_error_buf *);
2479
2480 void gfc_get_errors (int *, int *);
2481 void gfc_errors_to_warnings (int);
2482
2483 /* arith.c */
2484 void gfc_arith_init_1 (void);
2485 void gfc_arith_done_1 (void);
2486 arith gfc_check_integer_range (mpz_t p, int kind);
2487 bool gfc_check_character_range (gfc_char_t, int);
2488
2489 /* trans-types.c */
2490 gfc_try gfc_check_any_c_kind (gfc_typespec *);
2491 int gfc_validate_kind (bt, int, bool);
2492 int gfc_get_int_kind_from_width_isofortranenv (int size);
2493 int gfc_get_real_kind_from_width_isofortranenv (int size);
2494 tree gfc_get_derived_type (gfc_symbol * derived);
2495 extern int gfc_index_integer_kind;
2496 extern int gfc_default_integer_kind;
2497 extern int gfc_max_integer_kind;
2498 extern int gfc_default_real_kind;
2499 extern int gfc_default_double_kind;
2500 extern int gfc_default_character_kind;
2501 extern int gfc_default_logical_kind;
2502 extern int gfc_default_complex_kind;
2503 extern int gfc_c_int_kind;
2504 extern int gfc_atomic_int_kind;
2505 extern int gfc_atomic_logical_kind;
2506 extern int gfc_intio_kind;
2507 extern int gfc_charlen_int_kind;
2508 extern int gfc_numeric_storage_size;
2509 extern int gfc_character_storage_size;
2510
2511 /* symbol.c */
2512 void gfc_clear_new_implicit (void);
2513 gfc_try gfc_add_new_implicit_range (int, int);
2514 gfc_try gfc_merge_new_implicit (gfc_typespec *);
2515 void gfc_set_implicit_none (void);
2516 void gfc_check_function_type (gfc_namespace *);
2517 bool gfc_is_intrinsic_typename (const char *);
2518
2519 gfc_typespec *gfc_get_default_type (const char *, gfc_namespace *);
2520 gfc_try gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
2521
2522 void gfc_set_sym_referenced (gfc_symbol *);
2523
2524 gfc_try gfc_add_attribute (symbol_attribute *, locus *);
2525 gfc_try gfc_add_ext_attribute (symbol_attribute *, ext_attr_id_t, locus *);
2526 gfc_try gfc_add_allocatable (symbol_attribute *, locus *);
2527 gfc_try gfc_add_codimension (symbol_attribute *, const char *, locus *);
2528 gfc_try gfc_add_contiguous (symbol_attribute *, const char *, locus *);
2529 gfc_try gfc_add_dimension (symbol_attribute *, const char *, locus *);
2530 gfc_try gfc_add_external (symbol_attribute *, locus *);
2531 gfc_try gfc_add_intrinsic (symbol_attribute *, locus *);
2532 gfc_try gfc_add_optional (symbol_attribute *, locus *);
2533 gfc_try gfc_add_pointer (symbol_attribute *, locus *);
2534 gfc_try gfc_add_cray_pointer (symbol_attribute *, locus *);
2535 gfc_try gfc_add_cray_pointee (symbol_attribute *, locus *);
2536 match gfc_mod_pointee_as (gfc_array_spec *);
2537 gfc_try gfc_add_protected (symbol_attribute *, const char *, locus *);
2538 gfc_try gfc_add_result (symbol_attribute *, const char *, locus *);
2539 gfc_try gfc_add_save (symbol_attribute *, save_state, const char *, locus *);
2540 gfc_try gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
2541 gfc_try gfc_add_saved_common (symbol_attribute *, locus *);
2542 gfc_try gfc_add_target (symbol_attribute *, locus *);
2543 gfc_try gfc_add_dummy (symbol_attribute *, const char *, locus *);
2544 gfc_try gfc_add_generic (symbol_attribute *, const char *, locus *);
2545 gfc_try gfc_add_common (symbol_attribute *, locus *);
2546 gfc_try gfc_add_in_common (symbol_attribute *, const char *, locus *);
2547 gfc_try gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
2548 gfc_try gfc_add_data (symbol_attribute *, const char *, locus *);
2549 gfc_try gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
2550 gfc_try gfc_add_sequence (symbol_attribute *, const char *, locus *);
2551 gfc_try gfc_add_elemental (symbol_attribute *, locus *);
2552 gfc_try gfc_add_pure (symbol_attribute *, locus *);
2553 gfc_try gfc_add_recursive (symbol_attribute *, locus *);
2554 gfc_try gfc_add_function (symbol_attribute *, const char *, locus *);
2555 gfc_try gfc_add_subroutine (symbol_attribute *, const char *, locus *);
2556 gfc_try gfc_add_volatile (symbol_attribute *, const char *, locus *);
2557 gfc_try gfc_add_asynchronous (symbol_attribute *, const char *, locus *);
2558 gfc_try gfc_add_proc (symbol_attribute *attr, const char *name, locus *where);
2559 gfc_try gfc_add_abstract (symbol_attribute* attr, locus* where);
2560
2561 gfc_try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
2562 gfc_try gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int);
2563 gfc_try gfc_add_extension (symbol_attribute *, locus *);
2564 gfc_try gfc_add_value (symbol_attribute *, const char *, locus *);
2565 gfc_try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
2566 gfc_try gfc_add_entry (symbol_attribute *, const char *, locus *);
2567 gfc_try gfc_add_procedure (symbol_attribute *, procedure_type,
2568                        const char *, locus *);
2569 gfc_try gfc_add_intent (symbol_attribute *, sym_intent, locus *);
2570 gfc_try gfc_add_explicit_interface (gfc_symbol *, ifsrc,
2571                                 gfc_formal_arglist *, locus *);
2572 gfc_try gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
2573
2574 void gfc_clear_attr (symbol_attribute *);
2575 gfc_try gfc_missing_attr (symbol_attribute *, locus *);
2576 gfc_try gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
2577
2578 gfc_try gfc_add_component (gfc_symbol *, const char *, gfc_component **);
2579 gfc_symbol *gfc_use_derived (gfc_symbol *);
2580 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
2581 gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool);
2582
2583 gfc_st_label *gfc_get_st_label (int);
2584 void gfc_free_st_label (gfc_st_label *);
2585 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
2586 gfc_try gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
2587
2588 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
2589 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
2590 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
2591 void gfc_delete_symtree (gfc_symtree **, const char *);
2592 gfc_symtree *gfc_get_unique_symtree (gfc_namespace *);
2593 gfc_user_op *gfc_get_uop (const char *);
2594 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
2595 void gfc_free_symbol (gfc_symbol *);
2596 void gfc_release_symbol (gfc_symbol *);
2597 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
2598 gfc_symtree* gfc_find_symtree_in_proc (const char *, gfc_namespace *);
2599 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
2600 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
2601 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
2602 gfc_try gfc_verify_c_interop (gfc_typespec *);
2603 gfc_try gfc_verify_c_interop_param (gfc_symbol *);
2604 gfc_try verify_bind_c_sym (gfc_symbol *, gfc_typespec *, int, gfc_common_head *);
2605 gfc_try verify_bind_c_derived_type (gfc_symbol *);
2606 gfc_try verify_com_block_vars_c_interop (gfc_common_head *);
2607 void generate_isocbinding_symbol (const char *, iso_c_binding_symbol, const char *);
2608 gfc_symbol *get_iso_c_sym (gfc_symbol *, char *, const char *, int);
2609 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **, bool);
2610 int gfc_get_ha_symbol (const char *, gfc_symbol **);
2611 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
2612
2613 void gfc_undo_symbols (void);
2614 void gfc_commit_symbols (void);
2615 void gfc_commit_symbol (gfc_symbol *);
2616 gfc_charlen *gfc_new_charlen (gfc_namespace *, gfc_charlen *);
2617 void gfc_free_charlen (gfc_charlen *, gfc_charlen *);
2618 void gfc_free_namespace (gfc_namespace *);
2619
2620 void gfc_symbol_init_2 (void);
2621 void gfc_symbol_done_2 (void);
2622
2623 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
2624 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
2625 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
2626 void gfc_save_all (gfc_namespace *);
2627
2628 void gfc_enforce_clean_symbol_state (void);
2629 void gfc_free_dt_list (void);
2630
2631
2632 gfc_gsymbol *gfc_get_gsymbol (const char *);
2633 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
2634
2635 gfc_typebound_proc* gfc_get_typebound_proc (gfc_typebound_proc*);
2636 gfc_symbol* gfc_get_derived_super_type (gfc_symbol*);
2637 gfc_symbol* gfc_get_ultimate_derived_super_type (gfc_symbol*);
2638 bool gfc_type_is_extension_of (gfc_symbol *, gfc_symbol *);
2639 bool gfc_type_compatible (gfc_typespec *, gfc_typespec *);
2640
2641 void gfc_copy_formal_args (gfc_symbol *, gfc_symbol *);
2642 void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *);
2643 void gfc_copy_formal_args_ppc (gfc_component *, gfc_symbol *);
2644
2645 void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.c, too  */
2646
2647 gfc_try gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus);
2648 gfc_namespace* gfc_find_proc_namespace (gfc_namespace*);
2649
2650 bool gfc_is_associate_pointer (gfc_symbol*);
2651 gfc_symbol * gfc_find_dt_in_generic (gfc_symbol *);
2652
2653 /* intrinsic.c -- true if working in an init-expr, false otherwise.  */
2654 extern bool gfc_init_expr_flag;
2655
2656 /* Given a symbol that we have decided is intrinsic, mark it as such
2657    by placing it into a special module that is otherwise impossible to
2658    read or write.  */
2659
2660 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
2661
2662 void gfc_intrinsic_init_1 (void);
2663 void gfc_intrinsic_done_1 (void);
2664
2665 char gfc_type_letter (bt);
2666 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
2667 gfc_try gfc_convert_type (gfc_expr *, gfc_typespec *, int);
2668 gfc_try gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
2669 gfc_try gfc_convert_chartype (gfc_expr *, gfc_typespec *);
2670 int gfc_generic_intrinsic (const char *);
2671 int gfc_specific_intrinsic (const char *);
2672 bool gfc_is_intrinsic (gfc_symbol*, int, locus);
2673 int gfc_intrinsic_actual_ok (const char *, const bool);
2674 gfc_intrinsic_sym *gfc_find_function (const char *);
2675 gfc_intrinsic_sym *gfc_find_subroutine (const char *);
2676 gfc_intrinsic_sym *gfc_intrinsic_function_by_id (gfc_isym_id);
2677
2678 match gfc_intrinsic_func_interface (gfc_expr *, int);
2679 match gfc_intrinsic_sub_interface (gfc_code *, int);
2680
2681 void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool);
2682 gfc_try gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**,
2683                                       bool, locus);
2684
2685 /* match.c -- FIXME */
2686 void gfc_free_iterator (gfc_iterator *, int);
2687 void gfc_free_forall_iterator (gfc_forall_iterator *);
2688 void gfc_free_alloc_list (gfc_alloc *);
2689 void gfc_free_namelist (gfc_namelist *);
2690 void gfc_free_equiv (gfc_equiv *);
2691 void gfc_free_equiv_until (gfc_equiv *, gfc_equiv *);
2692 void gfc_free_data (gfc_data *);
2693 void gfc_free_case_list (gfc_case *);
2694
2695 /* matchexp.c -- FIXME too?  */
2696 gfc_expr *gfc_get_parentheses (gfc_expr *);
2697
2698 /* openmp.c */
2699 struct gfc_omp_saved_state { void *ptrs[2]; int ints[1]; };
2700 void gfc_free_omp_clauses (gfc_omp_clauses *);
2701 void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
2702 void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *);
2703 void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
2704 void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
2705 void gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *);
2706 void gfc_omp_restore_state (struct gfc_omp_saved_state *);
2707
2708 /* expr.c */
2709 void gfc_free_actual_arglist (gfc_actual_arglist *);
2710 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
2711 const char *gfc_extract_int (gfc_expr *, int *);
2712 bool is_subref_array (gfc_expr *);
2713 bool gfc_is_simply_contiguous (gfc_expr *, bool);
2714
2715 gfc_expr *gfc_build_conversion (gfc_expr *);
2716 void gfc_free_ref_list (gfc_ref *);
2717 void gfc_type_convert_binary (gfc_expr *, int);
2718 int gfc_is_constant_expr (gfc_expr *);
2719 gfc_try gfc_simplify_expr (gfc_expr *, int);
2720 int gfc_has_vector_index (gfc_expr *);
2721
2722 gfc_expr *gfc_get_expr (void);
2723 gfc_expr *gfc_get_array_expr (bt type, int kind, locus *);
2724 gfc_expr *gfc_get_null_expr (locus *);
2725 gfc_expr *gfc_get_operator_expr (locus *, gfc_intrinsic_op,gfc_expr *, gfc_expr *);
2726 gfc_expr *gfc_get_structure_constructor_expr (bt, int, locus *);
2727 gfc_expr *gfc_get_constant_expr (bt, int, locus *);
2728 gfc_expr *gfc_get_character_expr (int, locus *, const char *, int len);
2729 gfc_expr *gfc_get_int_expr (int, locus *, int);
2730 gfc_expr *gfc_get_logical_expr (int, locus *, bool);
2731 gfc_expr *gfc_get_iokind_expr (locus *, io_kind);
2732
2733 void gfc_clear_shape (mpz_t *shape, int rank);
2734 void gfc_free_shape (mpz_t **shape, int rank);
2735 void gfc_free_expr (gfc_expr *);
2736 void gfc_replace_expr (gfc_expr *, gfc_expr *);
2737 mpz_t *gfc_copy_shape (mpz_t *, int);
2738 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
2739 gfc_expr *gfc_copy_expr (gfc_expr *);
2740 gfc_ref* gfc_copy_ref (gfc_ref*);
2741
2742 gfc_try gfc_specification_expr (gfc_expr *);
2743
2744 int gfc_numeric_ts (gfc_typespec *);
2745 int gfc_kind_max (gfc_expr *, gfc_expr *);
2746
2747 gfc_try gfc_check_conformance (gfc_expr *, gfc_expr *, const char *, ...) ATTRIBUTE_PRINTF_3;
2748 gfc_try gfc_check_assign (gfc_expr *, gfc_expr *, int);
2749 gfc_try gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
2750 gfc_try gfc_check_assign_symbol (gfc_symbol *, gfc_expr *);
2751
2752 bool gfc_has_default_initializer (gfc_symbol *);
2753 gfc_expr *gfc_default_initializer (gfc_typespec *);
2754 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
2755 gfc_expr * gfc_lval_expr_from_sym (gfc_symbol *);
2756
2757 gfc_array_spec *gfc_get_full_arrayspec_from_expr (gfc_expr *expr);
2758
2759 bool gfc_traverse_expr (gfc_expr *, gfc_symbol *,
2760                         bool (*)(gfc_expr *, gfc_symbol *, int*),
2761                         int);
2762 void gfc_expr_set_symbols_referenced (gfc_expr *);
2763 gfc_try gfc_expr_check_typed (gfc_expr*, gfc_namespace*, bool);
2764 void gfc_expr_replace_symbols (gfc_expr *, gfc_symbol *);
2765 void gfc_expr_replace_comp (gfc_expr *, gfc_component *);
2766
2767 bool gfc_is_proc_ptr_comp (gfc_expr *, gfc_component **);
2768
2769 bool gfc_ref_this_image (gfc_ref *ref);
2770 bool gfc_is_coindexed (gfc_expr *);
2771 bool gfc_is_coarray (gfc_expr *);
2772 int gfc_get_corank (gfc_expr *);
2773 bool gfc_has_ultimate_allocatable (gfc_expr *);
2774 bool gfc_has_ultimate_pointer (gfc_expr *);
2775
2776 gfc_expr* gfc_build_intrinsic_call (gfc_namespace *, gfc_isym_id, const char*,
2777                                     locus, unsigned, ...);
2778 gfc_try gfc_check_vardef_context (gfc_expr*, bool, bool, const char*);
2779
2780
2781 /* st.c */
2782 extern gfc_code new_st;
2783
2784 void gfc_clear_new_st (void);
2785 gfc_code *gfc_get_code (void);
2786 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
2787 void gfc_free_statement (gfc_code *);
2788 void gfc_free_statements (gfc_code *);
2789 void gfc_free_association_list (gfc_association_list *);
2790
2791 /* resolve.c */
2792 gfc_try gfc_resolve_expr (gfc_expr *);
2793 void gfc_resolve (gfc_namespace *);
2794 void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
2795 int gfc_impure_variable (gfc_symbol *);
2796 int gfc_pure (gfc_symbol *);
2797 int gfc_implicit_pure (gfc_symbol *);
2798 int gfc_elemental (gfc_symbol *);
2799 gfc_try gfc_resolve_iterator (gfc_iterator *, bool);
2800 gfc_try find_forall_index (gfc_expr *, gfc_symbol *, int);
2801 gfc_try gfc_resolve_index (gfc_expr *, int);
2802 gfc_try gfc_resolve_dim_arg (gfc_expr *);
2803 int gfc_is_formal_arg (void);
2804 void gfc_resolve_substring_charlen (gfc_expr *);
2805 match gfc_iso_c_sub_interface(gfc_code *, gfc_symbol *);
2806 gfc_expr *gfc_expr_to_initialize (gfc_expr *);
2807 bool gfc_type_is_extensible (gfc_symbol *sym);
2808
2809
2810 /* array.c */
2811 gfc_iterator *gfc_copy_iterator (gfc_iterator *);
2812
2813 void gfc_free_array_spec (gfc_array_spec *);
2814 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
2815
2816 gfc_try gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
2817 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
2818 gfc_try gfc_resolve_array_spec (gfc_array_spec *, int);
2819
2820 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
2821
2822 void gfc_simplify_iterator_var (gfc_expr *);
2823 gfc_try gfc_expand_constructor (gfc_expr *, bool);
2824 int gfc_constant_ac (gfc_expr *);
2825 int gfc_expanded_ac (gfc_expr *);
2826 gfc_try gfc_resolve_character_array_constructor (gfc_expr *);
2827 gfc_try gfc_resolve_array_constructor (gfc_expr *);
2828 gfc_try gfc_check_constructor_type (gfc_expr *);
2829 gfc_try gfc_check_iter_variable (gfc_expr *);
2830 gfc_try gfc_check_constructor (gfc_expr *, gfc_try (*)(gfc_expr *));
2831 gfc_try gfc_array_size (gfc_expr *, mpz_t *);
2832 gfc_try gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
2833 gfc_try gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
2834 gfc_array_ref *gfc_find_array_ref (gfc_expr *);
2835 tree gfc_conv_array_initializer (tree type, gfc_expr *);
2836 gfc_try spec_size (gfc_array_spec *, mpz_t *);
2837 gfc_try spec_dimen_size (gfc_array_spec *, int, mpz_t *);
2838 int gfc_is_compile_time_shape (gfc_array_spec *);
2839
2840 gfc_try gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *);
2841
2842
2843 /* interface.c -- FIXME: some of these should be in symbol.c */
2844 void gfc_free_interface (gfc_interface *);
2845 int gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
2846 int gfc_compare_types (gfc_typespec *, gfc_typespec *);
2847 int gfc_compare_interfaces (gfc_symbol*, gfc_symbol*, const char *, int, int,
2848                             char *, int);
2849 void gfc_check_interfaces (gfc_namespace *);
2850 void gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
2851 void gfc_ppc_use (gfc_component *, gfc_actual_arglist **, locus *);
2852 gfc_symbol *gfc_search_interface (gfc_interface *, int,
2853                                   gfc_actual_arglist **);
2854 match gfc_extend_expr (gfc_expr *);
2855 void gfc_free_formal_arglist (gfc_formal_arglist *);
2856 gfc_try gfc_extend_assign (gfc_code *, gfc_namespace *);
2857 gfc_try gfc_add_interface (gfc_symbol *);
2858 gfc_interface *gfc_current_interface_head (void);
2859 void gfc_set_current_interface_head (gfc_interface *);
2860 gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*);
2861 bool gfc_arglist_matches_symbol (gfc_actual_arglist**, gfc_symbol*);
2862 bool gfc_check_operator_interface (gfc_symbol*, gfc_intrinsic_op, locus);
2863 int gfc_has_vector_subscript (gfc_expr*);
2864 gfc_intrinsic_op gfc_equivalent_op (gfc_intrinsic_op);
2865 gfc_try gfc_check_typebound_override (gfc_symtree*, gfc_symtree*);
2866
2867 /* io.c */
2868 extern gfc_st_label format_asterisk;
2869
2870 void gfc_free_open (gfc_open *);
2871 gfc_try gfc_resolve_open (gfc_open *);
2872 void gfc_free_close (gfc_close *);
2873 gfc_try gfc_resolve_close (gfc_close *);
2874 void gfc_free_filepos (gfc_filepos *);
2875 gfc_try gfc_resolve_filepos (gfc_filepos *);
2876 void gfc_free_inquire (gfc_inquire *);
2877 gfc_try gfc_resolve_inquire (gfc_inquire *);
2878 void gfc_free_dt (gfc_dt *);
2879 gfc_try gfc_resolve_dt (gfc_dt *, locus *);
2880 void gfc_free_wait (gfc_wait *);
2881 gfc_try gfc_resolve_wait (gfc_wait *);
2882
2883 /* module.c */
2884 void gfc_module_init_2 (void);
2885 void gfc_module_done_2 (void);
2886 void gfc_dump_module (const char *, int);
2887 bool gfc_check_symbol_access (gfc_symbol *);
2888 void gfc_free_use_stmts (gfc_use_list *);
2889
2890 /* primary.c */
2891 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
2892 symbol_attribute gfc_expr_attr (gfc_expr *);
2893 match gfc_match_rvalue (gfc_expr **);
2894 match gfc_match_varspec (gfc_expr*, int, bool, bool);
2895 int gfc_check_digit (char, int);
2896 bool gfc_is_function_return_value (gfc_symbol *, gfc_namespace *);
2897 gfc_try gfc_convert_to_structure_constructor (gfc_expr *, gfc_symbol *,
2898                                               gfc_expr **,
2899                                               gfc_actual_arglist **, bool);
2900
2901 /* trans.c */
2902 void gfc_generate_code (gfc_namespace *);
2903 void gfc_generate_module_code (gfc_namespace *);
2904 void gfc_init_coarray_decl (bool);
2905
2906 /* trans-intrinsic.c */
2907 bool gfc_inline_intrinsic_function_p (gfc_expr *);
2908
2909 /* bbt.c */
2910 typedef int (*compare_fn) (void *, void *);
2911 void gfc_insert_bbt (void *, void *, compare_fn);
2912 void gfc_delete_bbt (void *, void *, compare_fn);
2913
2914 /* dump-parse-tree.c */
2915 void gfc_dump_parse_tree (gfc_namespace *, FILE *);
2916
2917 /* parse.c */
2918 gfc_try gfc_parse_file (void);
2919 void gfc_global_used (gfc_gsymbol *, locus *);
2920 gfc_namespace* gfc_build_block_ns (gfc_namespace *);
2921
2922 /* dependency.c */
2923 int gfc_dep_compare_functions (gfc_expr *, gfc_expr *, bool);
2924 int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
2925
2926 /* check.c */
2927 gfc_try gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*);
2928 gfc_try gfc_calculate_transfer_sizes (gfc_expr*, gfc_expr*, gfc_expr*,
2929                                       size_t*, size_t*, size_t*);
2930
2931 /* class.c */
2932 void gfc_fix_class_refs (gfc_expr *e);
2933 void gfc_add_component_ref (gfc_expr *, const char *);
2934 void gfc_add_class_array_ref (gfc_expr *);
2935 #define gfc_add_data_component(e)     gfc_add_component_ref(e,"_data")
2936 #define gfc_add_vptr_component(e)     gfc_add_component_ref(e,"_vptr")
2937 #define gfc_add_hash_component(e)     gfc_add_component_ref(e,"_hash")
2938 #define gfc_add_size_component(e)     gfc_add_component_ref(e,"_size")
2939 #define gfc_add_def_init_component(e) gfc_add_component_ref(e,"_def_init")
2940 bool gfc_is_class_array_ref (gfc_expr *, bool *);
2941 bool gfc_is_class_scalar_expr (gfc_expr *);
2942 gfc_expr *gfc_class_null_initializer (gfc_typespec *);
2943 unsigned int gfc_hash_value (gfc_symbol *);
2944 gfc_try gfc_build_class_symbol (gfc_typespec *, symbol_attribute *,
2945                                 gfc_array_spec **, bool);
2946 gfc_symbol *gfc_find_derived_vtab (gfc_symbol *);
2947 gfc_symtree* gfc_find_typebound_proc (gfc_symbol*, gfc_try*,
2948                                       const char*, bool, locus*);
2949 gfc_symtree* gfc_find_typebound_user_op (gfc_symbol*, gfc_try*,
2950                                          const char*, bool, locus*);
2951 gfc_typebound_proc* gfc_find_typebound_intrinsic_op (gfc_symbol*, gfc_try*,
2952                                                      gfc_intrinsic_op, bool,
2953                                                      locus*);
2954 gfc_symtree* gfc_get_tbp_symtree (gfc_symtree**, const char*);
2955
2956 #define CLASS_DATA(sym) sym->ts.u.derived->components
2957
2958 /* frontend-passes.c */
2959
2960 void gfc_run_passes (gfc_namespace *);
2961
2962 typedef int (*walk_code_fn_t) (gfc_code **, int *, void *);
2963 typedef int (*walk_expr_fn_t) (gfc_expr **, int *, void *);
2964
2965 int gfc_expr_walker (gfc_expr **, walk_expr_fn_t, void *);
2966 int gfc_code_walker (gfc_code **, walk_code_fn_t, walk_expr_fn_t, void *);
2967
2968 #endif /* GCC_GFORTRAN_H  */