gcc/fortran/gfortran.h

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