Subversion Repositories openrisc_me

/* gfortran header file

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

   2009, 2010

   Free Software Foundation, Inc.

   Contributed by Andy Vaught

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#ifndef GCC_GFORTRAN_H

#define GCC_GFORTRAN_H

/* It's probably insane to have this large of a header file, but it

   seemed like everything had to be recompiled anyway when a change

   was made to a header file, and there were ordering issues with

   multiple header files.  Besides, Microsoft's winnt.h was 250k last

   time I looked, so by comparison this is perfectly reasonable.  */

/* Declarations common to the front-end and library are put in

   libgfortran/libgfortran_frontend.h  */

#include "libgfortran.h"

#include "system.h"

#include "intl.h"

#include "coretypes.h"

#include "input.h"

#include "splay-tree.h"

/* The following ifdefs are recommended by the autoconf documentation

   for any code using alloca.  */

/* AIX requires this to be the first thing in the file.  */

#ifdef __GNUC__

#else /* not __GNUC__ */

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#else /* do not HAVE_ALLOCA_H */

#ifdef _AIX

#pragma alloca

#else

#ifndef alloca                  /* predefined by HP cc +Olibcalls */

char *alloca ();

#endif /* not predefined */

#endif /* not _AIX */

#endif /* do not HAVE_ALLOCA_H */

#endif /* not __GNUC__ */

/* Major control parameters.  */

#define GFC_MAX_SYMBOL_LEN 63   /* Must be at least 63 for F2003.  */

#define GFC_MAX_BINDING_LABEL_LEN 126 /* (2 * GFC_MAX_SYMBOL_LEN) */

#define GFC_MAX_LINE 132        /* Characters beyond this are not seen.  */

#define GFC_LETTERS 26          /* Number of letters in the alphabet.  */

#define MAX_SUBRECORD_LENGTH 2147483639   /* 2**31-9 */

#define free(x) Use_gfc_free_instead_of_free()

#define gfc_is_whitespace(c) ((c==' ') || (c=='\t'))

#ifndef NULL

#define NULL ((void *) 0)

#endif

/* Stringization.  */

#define stringize(x) expand_macro(x)

#define expand_macro(x) # x

/* For the runtime library, a standard prefix is a requirement to

   avoid cluttering the namespace with things nobody asked for.  It's

   ugly to look at and a pain to type when you add the prefix by hand,

   so we hide it behind a macro.  */

#define PREFIX(x) "_gfortran_" x

#define PREFIX_LEN 10

#define BLANK_COMMON_NAME "__BLNK__"

/* Macro to initialize an mstring structure.  */

#define minit(s, t) { s, NULL, t }

/* Structure for storing strings to be matched by gfc_match_string.  */

typedef struct

{

  const char *string;

  const char *mp;

  int tag;

}

mstring;

/*************************** Enums *****************************/

/* Used when matching and resolving data I/O transfer statements.  */

typedef enum

{ M_READ, M_WRITE, M_PRINT, M_INQUIRE }

io_kind;

/* The author remains confused to this day about the convention of

   returning '0' for 'SUCCESS'... or was it the other way around?  The

   following enum makes things much more readable.  We also start

   values off at one instead of zero.  */

typedef enum

{ SUCCESS = 1, FAILURE }

gfc_try;

/* This is returned by gfc_notification_std to know if, given the flags

   that were given (-std=, -pedantic) we should issue an error, a warning

   or nothing.  */

typedef enum

{ SILENT, WARNING, ERROR }

notification;

/* Matchers return one of these three values.  The difference between

   MATCH_NO and MATCH_ERROR is that MATCH_ERROR means that a match was

   successful, but that something non-syntactic is wrong and an error

   has already been issued.  */

typedef enum

{ MATCH_NO = 1, MATCH_YES, MATCH_ERROR }

match;

typedef enum

{ FORM_FREE, FORM_FIXED, FORM_UNKNOWN }

gfc_source_form;

/* Basic types.  BT_VOID is used by ISO C Binding so funcs like c_f_pointer

   can take any arg with the pointer attribute as a param.  */

typedef enum

{ BT_UNKNOWN = 1, BT_INTEGER, BT_REAL, BT_COMPLEX, BT_LOGICAL, BT_CHARACTER,

  BT_DERIVED, BT_CLASS, BT_PROCEDURE, BT_HOLLERITH, BT_VOID

}

bt;

/* Expression node types.  */

typedef enum

{ EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,

  EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL, EXPR_COMPCALL, EXPR_PPC

}

expr_t;

/* Array types.  */

typedef enum

{ AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,

  AS_ASSUMED_SIZE, AS_UNKNOWN

}

array_type;

typedef enum

{ AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN }

ar_type;

/* Statement label types.  */

typedef enum

{ ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET,

  ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT

}

gfc_sl_type;

/* Intrinsic operators.  */

typedef enum

{ GFC_INTRINSIC_BEGIN = 0,

  INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,

  INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,

  INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,

  INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,

  /* ==, /=, >, >=, <, <=  */

  INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,

  INTRINSIC_LT, INTRINSIC_LE,

  /* .EQ., .NE., .GT., .GE., .LT., .LE. (OS = Old-Style)  */

  INTRINSIC_EQ_OS, INTRINSIC_NE_OS, INTRINSIC_GT_OS, INTRINSIC_GE_OS,

  INTRINSIC_LT_OS, INTRINSIC_LE_OS,

  INTRINSIC_NOT, INTRINSIC_USER, INTRINSIC_ASSIGN,

  INTRINSIC_PARENTHESES, GFC_INTRINSIC_END /* Sentinel */

}

gfc_intrinsic_op;

/* This macro is the number of intrinsic operators that exist.

   Assumptions are made about the numbering of the interface_op enums.  */

#define GFC_INTRINSIC_OPS GFC_INTRINSIC_END

/* Arithmetic results.  */

typedef enum

{ ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,

  ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC, ARITH_PROHIBIT

}

arith;

/* Statements.  */

typedef enum

{

  ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_BACKSPACE,

  ST_BLOCK, ST_BLOCK_DATA,

  ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,

  ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,

  ST_ELSEWHERE, ST_END_BLOCK, ST_END_BLOCK_DATA, ST_ENDDO, ST_IMPLIED_ENDDO,

  ST_END_FILE, ST_FINAL, ST_FLUSH, ST_END_FORALL, ST_END_FUNCTION, ST_ENDIF,

  ST_END_INTERFACE, ST_END_MODULE, ST_END_PROGRAM, ST_END_SELECT,

  ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE, ST_ENTRY, ST_EQUIVALENCE,

  ST_EXIT, ST_FORALL, ST_FORALL_BLOCK, ST_FORMAT, ST_FUNCTION, ST_GOTO,

  ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE, ST_IMPORT,

  ST_INQUIRE, ST_INTERFACE,

  ST_PARAMETER, ST_MODULE, ST_MODULE_PROC, ST_NAMELIST, ST_NULLIFY, ST_OPEN,

  ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC, ST_READ, ST_RETURN, ST_REWIND,

  ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE, ST_WHERE_BLOCK, ST_WHERE, ST_WAIT,

  ST_WRITE, ST_ASSIGNMENT, ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE,

  ST_SIMPLE_IF, ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT,

  ST_ENUM, ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,

  ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_CRITICAL,

  ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED, ST_OMP_END_PARALLEL,

  ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,

  ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,

  ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,

  ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,

  ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,

  ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,

  ST_OMP_TASKWAIT, ST_PROCEDURE, ST_GENERIC,

  ST_GET_FCN_CHARACTERISTICS, ST_NONE

}

gfc_statement;

/* Types of interfaces that we can have.  Assignment interfaces are

   considered to be intrinsic operators.  */

typedef enum

{

  INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,

  INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP, INTERFACE_ABSTRACT

}

interface_type;

/* Symbol flavors: these are all mutually exclusive.

   10 elements = 4 bits.  */

typedef enum sym_flavor

{

  FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,

  FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,

  FL_VOID

}

sym_flavor;

/* Procedure types.  7 elements = 3 bits.  */

typedef enum procedure_type

{ PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,

  PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL

}

procedure_type;

/* Intent types.  */

typedef enum sym_intent

{ INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT

}

sym_intent;

/* Access types.  */

typedef enum gfc_access

{ ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE

}

gfc_access;

/* Flags to keep track of where an interface came from.

   3 elements = 2 bits.  */

typedef enum ifsrc

{ IFSRC_UNKNOWN = 0,     /* Interface unknown, only return type may be known.  */

  IFSRC_DECL,           /* FUNCTION or SUBROUTINE declaration.  */

  IFSRC_IFBODY          /* INTERFACE statement or PROCEDURE statement

                           with explicit interface.  */

}

ifsrc;

/* Whether a SAVE attribute was set explicitly or implicitly.  */

typedef enum save_state

{ SAVE_NONE = 0, SAVE_EXPLICIT, SAVE_IMPLICIT

}

save_state;

/* Strings for all symbol attributes.  We use these for dumping the

   parse tree, in error messages, and also when reading and writing

   modules.  In symbol.c.  */

extern const mstring flavors[];

extern const mstring procedures[];

extern const mstring intents[];

extern const mstring access_types[];

extern const mstring ifsrc_types[];

extern const mstring save_status[];

/* Enumeration of all the generic intrinsic functions.  Used by the

   backend for identification of a function.  */

enum gfc_isym_id

{

  /* GFC_ISYM_NONE is used for intrinsics which will never be seen by

     the backend (e.g. KIND).  */

  GFC_ISYM_NONE = 0,

  GFC_ISYM_ABORT,

  GFC_ISYM_ABS,

  GFC_ISYM_ACCESS,

  GFC_ISYM_ACHAR,

  GFC_ISYM_ACOS,

  GFC_ISYM_ACOSH,

  GFC_ISYM_ADJUSTL,

  GFC_ISYM_ADJUSTR,

  GFC_ISYM_AIMAG,

  GFC_ISYM_AINT,

  GFC_ISYM_ALARM,

  GFC_ISYM_ALL,

  GFC_ISYM_ALLOCATED,

  GFC_ISYM_AND,

  GFC_ISYM_ANINT,

  GFC_ISYM_ANY,

  GFC_ISYM_ASIN,

  GFC_ISYM_ASINH,

  GFC_ISYM_ASSOCIATED,

  GFC_ISYM_ATAN,

  GFC_ISYM_ATAN2,

  GFC_ISYM_ATANH,

  GFC_ISYM_BIT_SIZE,

  GFC_ISYM_BTEST,

  GFC_ISYM_CEILING,

  GFC_ISYM_CHAR,

  GFC_ISYM_CHDIR,

  GFC_ISYM_CHMOD,

  GFC_ISYM_CMPLX,

  GFC_ISYM_COMMAND_ARGUMENT_COUNT,

  GFC_ISYM_COMPLEX,

  GFC_ISYM_CONJG,

  GFC_ISYM_CONVERSION,

  GFC_ISYM_COS,

  GFC_ISYM_COSH,

  GFC_ISYM_COUNT,

  GFC_ISYM_CPU_TIME,

  GFC_ISYM_CSHIFT,

  GFC_ISYM_CTIME,

  GFC_ISYM_DATE_AND_TIME,

  GFC_ISYM_DBLE,

  GFC_ISYM_DIGITS,

  GFC_ISYM_DIM,

  GFC_ISYM_DOT_PRODUCT,

  GFC_ISYM_DPROD,

  GFC_ISYM_DTIME,

  GFC_ISYM_EOSHIFT,

  GFC_ISYM_EPSILON,

  GFC_ISYM_ERF,

  GFC_ISYM_ERFC,

  GFC_ISYM_ERFC_SCALED,

  GFC_ISYM_ETIME,

  GFC_ISYM_EXIT,

  GFC_ISYM_EXP,

  GFC_ISYM_EXPONENT,

  GFC_ISYM_EXTENDS_TYPE_OF,

  GFC_ISYM_FDATE,

  GFC_ISYM_FGET,

  GFC_ISYM_FGETC,

  GFC_ISYM_FLOOR,

  GFC_ISYM_FLUSH,

  GFC_ISYM_FNUM,

  GFC_ISYM_FPUT,

  GFC_ISYM_FPUTC,

  GFC_ISYM_FRACTION,

  GFC_ISYM_FREE,

  GFC_ISYM_FSEEK,

  GFC_ISYM_FSTAT,

  GFC_ISYM_FTELL,

  GFC_ISYM_TGAMMA,

  GFC_ISYM_GERROR,

  GFC_ISYM_GETARG,

  GFC_ISYM_GET_COMMAND,

  GFC_ISYM_GET_COMMAND_ARGUMENT,

  GFC_ISYM_GETCWD,

  GFC_ISYM_GETENV,

  GFC_ISYM_GET_ENVIRONMENT_VARIABLE,

  GFC_ISYM_GETGID,

  GFC_ISYM_GETLOG,

  GFC_ISYM_GETPID,

  GFC_ISYM_GETUID,

  GFC_ISYM_GMTIME,

  GFC_ISYM_HOSTNM,

  GFC_ISYM_HUGE,

  GFC_ISYM_HYPOT,

  GFC_ISYM_IACHAR,

  GFC_ISYM_IAND,

  GFC_ISYM_IARGC,

  GFC_ISYM_IBCLR,

  GFC_ISYM_IBITS,

  GFC_ISYM_IBSET,

  GFC_ISYM_ICHAR,

  GFC_ISYM_IDATE,

  GFC_ISYM_IEOR,

  GFC_ISYM_IERRNO,

  GFC_ISYM_INDEX,

  GFC_ISYM_INT,

  GFC_ISYM_INT2,

  GFC_ISYM_INT8,

  GFC_ISYM_IOR,

  GFC_ISYM_IRAND,

  GFC_ISYM_ISATTY,

  GFC_ISYM_IS_IOSTAT_END,

  GFC_ISYM_IS_IOSTAT_EOR,

  GFC_ISYM_ISNAN,

  GFC_ISYM_ISHFT,

  GFC_ISYM_ISHFTC,

  GFC_ISYM_ITIME,

  GFC_ISYM_J0,

  GFC_ISYM_J1,

  GFC_ISYM_JN,

  GFC_ISYM_KILL,

  GFC_ISYM_KIND,

  GFC_ISYM_LBOUND,

  GFC_ISYM_LEADZ,

  GFC_ISYM_LEN,

  GFC_ISYM_LEN_TRIM,

  GFC_ISYM_LGAMMA,

  GFC_ISYM_LGE,

  GFC_ISYM_LGT,

  GFC_ISYM_LINK,

  GFC_ISYM_LLE,

  GFC_ISYM_LLT,

  GFC_ISYM_LOC,

  GFC_ISYM_LOG,

  GFC_ISYM_LOG10,

  GFC_ISYM_LOGICAL,

  GFC_ISYM_LONG,

  GFC_ISYM_LSHIFT,

  GFC_ISYM_LSTAT,

  GFC_ISYM_LTIME,

  GFC_ISYM_MALLOC,

  GFC_ISYM_MATMUL,

  GFC_ISYM_MAX,

  GFC_ISYM_MAXEXPONENT,

  GFC_ISYM_MAXLOC,

  GFC_ISYM_MAXVAL,

  GFC_ISYM_MCLOCK,

  GFC_ISYM_MCLOCK8,

  GFC_ISYM_MERGE,

  GFC_ISYM_MIN,

  GFC_ISYM_MINEXPONENT,

  GFC_ISYM_MINLOC,

  GFC_ISYM_MINVAL,

  GFC_ISYM_MOD,

  GFC_ISYM_MODULO,

  GFC_ISYM_MOVE_ALLOC,

  GFC_ISYM_MVBITS,

  GFC_ISYM_NEAREST,

  GFC_ISYM_NEW_LINE,

  GFC_ISYM_NINT,

  GFC_ISYM_NOT,

  GFC_ISYM_NULL,

  GFC_ISYM_OR,

  GFC_ISYM_PACK,

  GFC_ISYM_PERROR,

  GFC_ISYM_PRECISION,

  GFC_ISYM_PRESENT,

  GFC_ISYM_PRODUCT,

  GFC_ISYM_RADIX,

  GFC_ISYM_RAND,

  GFC_ISYM_RANDOM_NUMBER,

  GFC_ISYM_RANDOM_SEED,

  GFC_ISYM_RANGE,

  GFC_ISYM_REAL,

  GFC_ISYM_RENAME,

  GFC_ISYM_REPEAT,

  GFC_ISYM_RESHAPE,

  GFC_ISYM_RRSPACING,

  GFC_ISYM_RSHIFT,

  GFC_ISYM_SAME_TYPE_AS,

  GFC_ISYM_SC_KIND,

  GFC_ISYM_SCALE,

  GFC_ISYM_SCAN,

  GFC_ISYM_SECNDS,

  GFC_ISYM_SECOND,

  GFC_ISYM_SET_EXPONENT,

  GFC_ISYM_SHAPE,

  GFC_ISYM_SIGN,

  GFC_ISYM_SIGNAL,

  GFC_ISYM_SI_KIND,

  GFC_ISYM_SIN,

  GFC_ISYM_SINH,

  GFC_ISYM_SIZE,

  GFC_ISYM_SLEEP,

  GFC_ISYM_SIZEOF,

  GFC_ISYM_SPACING,

  GFC_ISYM_SPREAD,

  GFC_ISYM_SQRT,

  GFC_ISYM_SRAND,

  GFC_ISYM_SR_KIND,

  GFC_ISYM_STAT,

  GFC_ISYM_SUM,

  GFC_ISYM_SYMLINK,

  GFC_ISYM_SYMLNK,

  GFC_ISYM_SYSTEM,

  GFC_ISYM_SYSTEM_CLOCK,

  GFC_ISYM_TAN,

  GFC_ISYM_TANH,

  GFC_ISYM_TIME,

  GFC_ISYM_TIME8,

  GFC_ISYM_TINY,

  GFC_ISYM_TRAILZ,

  GFC_ISYM_TRANSFER,

  GFC_ISYM_TRANSPOSE,

  GFC_ISYM_TRIM,

  GFC_ISYM_TTYNAM,

  GFC_ISYM_UBOUND,

  GFC_ISYM_UMASK,

  GFC_ISYM_UNLINK,

  GFC_ISYM_UNPACK,

  GFC_ISYM_VERIFY,

  GFC_ISYM_XOR,

  GFC_ISYM_Y0,

  GFC_ISYM_Y1,

  GFC_ISYM_YN

};

typedef enum gfc_isym_id gfc_isym_id;

typedef enum

{

  GFC_INIT_REAL_OFF = 0,

  GFC_INIT_REAL_ZERO,

  GFC_INIT_REAL_NAN,

  GFC_INIT_REAL_SNAN,

  GFC_INIT_REAL_INF,

  GFC_INIT_REAL_NEG_INF

}

init_local_real;

typedef enum

{

  GFC_INIT_LOGICAL_OFF = 0,

  GFC_INIT_LOGICAL_FALSE,

  GFC_INIT_LOGICAL_TRUE

}

init_local_logical;

typedef enum

{

  GFC_INIT_CHARACTER_OFF = 0,

  GFC_INIT_CHARACTER_ON

}

init_local_character;

typedef enum

{

  GFC_INIT_INTEGER_OFF = 0,

  GFC_INIT_INTEGER_ON

}

init_local_integer;

/************************* Structures *****************************/

/* Used for keeping things in balanced binary trees.  */

#define BBT_HEADER(self) int priority; struct self *left, *right

#define NAMED_INTCST(a,b,c,d) a,

typedef enum

{

  ISOFORTRANENV_INVALID = -1,

#include "iso-fortran-env.def"

  ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST

}

iso_fortran_env_symbol;

#undef NAMED_INTCST

#define NAMED_INTCST(a,b,c,d) a,

#define NAMED_REALCST(a,b,c) a,

#define NAMED_CMPXCST(a,b,c) a,

#define NAMED_LOGCST(a,b,c) a,

#define NAMED_CHARKNDCST(a,b,c) a,

#define NAMED_CHARCST(a,b,c) a,

#define DERIVED_TYPE(a,b,c) a,

#define PROCEDURE(a,b) a,

typedef enum

{

  ISOCBINDING_INVALID = -1,

#include "iso-c-binding.def"

  ISOCBINDING_LAST,

  ISOCBINDING_NUMBER = ISOCBINDING_LAST

}

iso_c_binding_symbol;

#undef NAMED_INTCST

#undef NAMED_REALCST

#undef NAMED_CMPXCST

#undef NAMED_LOGCST

#undef NAMED_CHARKNDCST

#undef NAMED_CHARCST

#undef DERIVED_TYPE

#undef PROCEDURE

typedef enum

{

  INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING

}

intmod_id;

typedef struct

{

  char name[GFC_MAX_SYMBOL_LEN + 1];

  int value;  /* Used for both integer and character values.  */

  bt f90_type;

}

CInteropKind_t;

/* Array of structs, where the structs represent the C interop kinds.

   The list will be implemented based on a hash of the kind name since

   these could be accessed multiple times.

   Declared in trans-types.c as a global, since it's in that file

   that the list is initialized.  */

extern CInteropKind_t c_interop_kinds_table[];

/* Structure and list of supported extension attributes.  */

typedef enum

{

  EXT_ATTR_DLLIMPORT = 0,

  EXT_ATTR_DLLEXPORT,

  EXT_ATTR_STDCALL,

  EXT_ATTR_CDECL,

  EXT_ATTR_FASTCALL,

  EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST

}

ext_attr_id_t;

typedef struct

{

  const char *name;

  unsigned id;

  const char *middle_end_name;

}

ext_attr_t;

extern const ext_attr_t ext_attr_list[];

/* Symbol attribute structure.  */

typedef struct

{

  /* Variable attributes.  */

  unsigned allocatable:1, dimension:1, external:1, intrinsic:1,

    optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,

    dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,

    implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1;

  /* For CLASS containers, the pointer attribute is sometimes set internally

     even though it was not directly specified.  In this case, keep the

     "real" (original) value here.  */

  unsigned class_pointer:1;

  ENUM_BITFIELD (save_state) save:2;

  unsigned data:1,              /* Symbol is named in a DATA statement.  */

    is_protected:1,             /* Symbol has been marked as protected.  */

    use_assoc:1,                /* Symbol has been use-associated.  */

    use_only:1,                 /* Symbol has been use-associated, with ONLY.  */

    use_rename:1,               /* Symbol has been use-associated and renamed.  */

    imported:1,                 /* Symbol has been associated by IMPORT.  */

    host_assoc:1;               /* Symbol has been host associated.  */

  unsigned in_namelist:1, in_common:1, in_equivalence:1;

  unsigned function:1, subroutine:1, procedure:1;

  unsigned generic:1, generic_copy:1;

  unsigned implicit_type:1;     /* Type defined via implicit rules.  */

  unsigned untyped:1;           /* No implicit type could be found.  */

  unsigned is_bind_c:1;         /* say if is bound to C.  */

  unsigned extension:8;         /* extension level of a derived type.  */

  unsigned is_class:1;          /* is a CLASS container.  */

  unsigned class_ok:1;          /* is a CLASS object with correct attributes.  */

  unsigned vtab:1;              /* is a derived type vtab.  */

  /* These flags are both in the typespec and attribute.  The attribute

     list is what gets read from/written to a module file.  The typespec

     is created from a decl being processed.  */

  unsigned is_c_interop:1;      /* It's c interoperable.  */

  unsigned is_iso_c:1;          /* Symbol is from iso_c_binding.  */

  /* Function/subroutine attributes */

  unsigned sequence:1, elemental:1, pure:1, recursive:1;

  unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;

  /* This is set if the subroutine doesn't return.  Currently, this

     is only possible for intrinsic subroutines.  */

  unsigned noreturn:1;

  /* Set if this procedure is an alternate entry point.  These procedures

     don't have any code associated, and the backend will turn them into

     thunks to the master function.  */

  unsigned entry:1;

  /* Set if this is the master function for a procedure with multiple

     entry points.  */

  unsigned entry_master:1;

  /* Set if this is the master function for a function with multiple

     entry points where characteristics of the entry points differ.  */

  unsigned mixed_entry_master:1;

  /* Set if a function must always be referenced by an explicit interface.  */

  unsigned always_explicit:1;

  /* Set if the symbol has been referenced in an expression.  No further

     modification of type or type parameters is permitted.  */

  unsigned referenced:1;

  /* Set if this is the symbol for the main program.  */

  unsigned is_main_program:1;

  /* Mutually exclusive multibit attributes.  */

  ENUM_BITFIELD (gfc_access) access:2;

  ENUM_BITFIELD (sym_intent) intent:2;

  ENUM_BITFIELD (sym_flavor) flavor:4;

  ENUM_BITFIELD (ifsrc) if_source:2;

  ENUM_BITFIELD (procedure_type) proc:3;

  /* Special attributes for Cray pointers, pointees.  */

  unsigned cray_pointer:1, cray_pointee:1;

  /* The symbol is a derived type with allocatable components, pointer

     components or private components, procedure pointer components,

     possibly nested.  zero_comp is true if the derived type has no

     component at all.  */

  unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,

           private_comp:1, zero_comp:1;

  /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES).  */

  unsigned ext_attr:EXT_ATTR_NUM;

  /* The namespace where the attribute has been set.  */

  struct gfc_namespace *volatile_ns, *asynchronous_ns;

}

symbol_attribute;

/* We need to store source lines as sequences of multibyte source

   characters. We define here a type wide enough to hold any multibyte

   source character, just like libcpp does.  A 32-bit type is enough.  */

#if HOST_BITS_PER_INT >= 32

typedef unsigned int gfc_char_t;

#elif HOST_BITS_PER_LONG >= 32

typedef unsigned long gfc_char_t;

#elif defined(HAVE_LONG_LONG) && (HOST_BITS_PER_LONGLONG >= 32)

typedef unsigned long long gfc_char_t;

#else

# error "Cannot find an integer type with at least 32 bits"

#endif

/* The following three structures are used to identify a location in

   the sources.

   gfc_file is used to maintain a tree of the source files and how

   they include each other

   gfc_linebuf holds a single line of source code and information