Subversion Repositories scarts

/* gfortran header file

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

   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 2, 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 COPYING.  If not, write to the Free

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

#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.  */

#include "system.h"

#include "intl.h"

#include "coretypes.h"

#include "input.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

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

#define GFC_MAX_DIMENSIONS 7    /* Maximum dimensions in an array.  */

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

#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 a 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;

/* Flags to specify which standard/extension contains a feature.  */

#define GFC_STD_LEGACY          (1<<6) /* Backward compatibility.  */

#define GFC_STD_GNU             (1<<5)    /* GNU Fortran extension.  */

#define GFC_STD_F2003           (1<<4)    /* New in F2003.  */

/* Note that no features were obsoleted nor deleted in F2003.  */

#define GFC_STD_F95             (1<<3)    /* New in F95.  */

#define GFC_STD_F95_DEL         (1<<2)    /* Deleted in F95.  */

#define GFC_STD_F95_OBS         (1<<1)    /* Obsoleted in F95.  */

#define GFC_STD_F77             (1<<0)    /* Up to and including F77.  */

/* Bitmasks for the various FPE that can be enabled.  */

#define GFC_FPE_INVALID    (1<<0)

#define GFC_FPE_DENORMAL   (1<<1)

#define GFC_FPE_ZERO       (1<<2)

#define GFC_FPE_OVERFLOW   (1<<3)

#define GFC_FPE_UNDERFLOW  (1<<4)

#define GFC_FPE_PRECISION  (1<<5)

/* Keep this in sync with libgfortran/io/io.h ! */

typedef enum

  { CONVERT_NATIVE=0, CONVERT_SWAP, CONVERT_BIG, CONVERT_LITTLE }

options_convert;

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

/* 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 }

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;

typedef enum

{ BT_UNKNOWN = 1, BT_INTEGER, BT_REAL, BT_COMPLEX,

  BT_LOGICAL, BT_CHARACTER, BT_DERIVED, BT_PROCEDURE, BT_HOLLERITH

}

bt;

/* Expression node types.  */

typedef enum

{ EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,

  EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL

}

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, INTRINSIC_NOT, INTRINSIC_USER,

  INTRINSIC_ASSIGN, INTRINSIC_PARENTHESES,

  GFC_INTRINSIC_END /* Sentinel */

}

gfc_intrinsic_op;

/* Strings for all intrinsic operators.  */

extern mstring intrinsic_operators[];

/* 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;

/* Statements.  */

typedef enum

{

  ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_BACKSPACE, 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_DATA, ST_ENDDO, ST_IMPLIED_ENDDO,

  ST_END_FILE, 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_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_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_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_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

}

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.

   4 elements = 2 bits.  */

typedef enum ifsrc

{ IFSRC_UNKNOWN = 0, IFSRC_DECL, IFSRC_IFBODY, IFSRC_USAGE

}

ifsrc;

/* 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[];

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

   backend for identification of a function.  */

enum gfc_generic_isym_id

{

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

     the backend (eg. KIND).  */

  GFC_ISYM_NONE = 0,

  GFC_ISYM_ABS,

  GFC_ISYM_ACHAR,

  GFC_ISYM_ACOS,

  GFC_ISYM_ACOSH,

  GFC_ISYM_ADJUSTL,

  GFC_ISYM_ADJUSTR,

  GFC_ISYM_AIMAG,

  GFC_ISYM_AINT,

  GFC_ISYM_ALL,

  GFC_ISYM_ALLOCATED,

  GFC_ISYM_ANINT,

  GFC_ISYM_AND,

  GFC_ISYM_ANY,

  GFC_ISYM_ASIN,

  GFC_ISYM_ASINH,

  GFC_ISYM_ASSOCIATED,

  GFC_ISYM_ATAN,

  GFC_ISYM_ATANH,

  GFC_ISYM_ATAN2,

  GFC_ISYM_J0,

  GFC_ISYM_J1,

  GFC_ISYM_JN,

  GFC_ISYM_Y0,

  GFC_ISYM_Y1,

  GFC_ISYM_YN,

  GFC_ISYM_BTEST,

  GFC_ISYM_CEILING,

  GFC_ISYM_CHAR,

  GFC_ISYM_CHDIR,

  GFC_ISYM_CMPLX,

  GFC_ISYM_COMMAND_ARGUMENT_COUNT,

  GFC_ISYM_COMPLEX,

  GFC_ISYM_CONJG,

  GFC_ISYM_COS,

  GFC_ISYM_COSH,

  GFC_ISYM_COUNT,

  GFC_ISYM_CSHIFT,

  GFC_ISYM_CTIME,

  GFC_ISYM_DBLE,

  GFC_ISYM_DIM,

  GFC_ISYM_DOT_PRODUCT,

  GFC_ISYM_DPROD,

  GFC_ISYM_EOSHIFT,

  GFC_ISYM_ERF,

  GFC_ISYM_ERFC,

  GFC_ISYM_ETIME,

  GFC_ISYM_EXP,

  GFC_ISYM_EXPONENT,

  GFC_ISYM_FDATE,

  GFC_ISYM_FGET,

  GFC_ISYM_FGETC,

  GFC_ISYM_FLOOR,

  GFC_ISYM_FNUM,

  GFC_ISYM_FPUT,

  GFC_ISYM_FPUTC,

  GFC_ISYM_FRACTION,

  GFC_ISYM_FSTAT,

  GFC_ISYM_FTELL,

  GFC_ISYM_GETCWD,

  GFC_ISYM_GETGID,

  GFC_ISYM_GETPID,

  GFC_ISYM_GETUID,

  GFC_ISYM_HOSTNM,

  GFC_ISYM_IACHAR,

  GFC_ISYM_IAND,

  GFC_ISYM_IARGC,

  GFC_ISYM_IBCLR,

  GFC_ISYM_IBITS,

  GFC_ISYM_IBSET,

  GFC_ISYM_ICHAR,

  GFC_ISYM_IEOR,

  GFC_ISYM_IERRNO,

  GFC_ISYM_INDEX,

  GFC_ISYM_INT,

  GFC_ISYM_IOR,

  GFC_ISYM_IRAND,

  GFC_ISYM_ISATTY,

  GFC_ISYM_ISHFT,

  GFC_ISYM_ISHFTC,

  GFC_ISYM_KILL,

  GFC_ISYM_LBOUND,

  GFC_ISYM_LEN,

  GFC_ISYM_LEN_TRIM,

  GFC_ISYM_LINK,

  GFC_ISYM_LGE,

  GFC_ISYM_LGT,

  GFC_ISYM_LLE,

  GFC_ISYM_LLT,

  GFC_ISYM_LOG,

  GFC_ISYM_LOC,

  GFC_ISYM_LOG10,

  GFC_ISYM_LOGICAL,

  GFC_ISYM_MALLOC,

  GFC_ISYM_MATMUL,

  GFC_ISYM_MAX,

  GFC_ISYM_MAXLOC,

  GFC_ISYM_MAXVAL,

  GFC_ISYM_MERGE,

  GFC_ISYM_MIN,

  GFC_ISYM_MINLOC,

  GFC_ISYM_MINVAL,

  GFC_ISYM_MOD,

  GFC_ISYM_MODULO,

  GFC_ISYM_NEAREST,

  GFC_ISYM_NINT,

  GFC_ISYM_NOT,

  GFC_ISYM_OR,

  GFC_ISYM_PACK,

  GFC_ISYM_PRESENT,

  GFC_ISYM_PRODUCT,

  GFC_ISYM_RAND,

  GFC_ISYM_REAL,

  GFC_ISYM_RENAME,

  GFC_ISYM_REPEAT,

  GFC_ISYM_RESHAPE,

  GFC_ISYM_RRSPACING,

  GFC_ISYM_SCALE,

  GFC_ISYM_SCAN,

  GFC_ISYM_SECOND,

  GFC_ISYM_SECNDS,

  GFC_ISYM_SET_EXPONENT,

  GFC_ISYM_SHAPE,

  GFC_ISYM_SI_KIND,

  GFC_ISYM_SIGN,

  GFC_ISYM_SIGNAL,

  GFC_ISYM_SIN,

  GFC_ISYM_SINH,

  GFC_ISYM_SIZE,

  GFC_ISYM_SPACING,

  GFC_ISYM_SPREAD,

  GFC_ISYM_SQRT,

  GFC_ISYM_SR_KIND,

  GFC_ISYM_STAT,

  GFC_ISYM_SUM,

  GFC_ISYM_SYMLNK,

  GFC_ISYM_SYSTEM,

  GFC_ISYM_TAN,

  GFC_ISYM_TANH,

  GFC_ISYM_TIME,

  GFC_ISYM_TIME8,

  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_CONVERSION

};

typedef enum gfc_generic_isym_id gfc_generic_isym_id;

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

/* Symbol attribute structure.  */

typedef struct

{

  /* Variable attributes.  */

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

    optional:1, pointer:1, save:1, target:1,

    dummy:1, result:1, assign:1;

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

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

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

  unsigned function:1, subroutine:1, generic:1;

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

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

  /* Function/subroutine attributes */

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

  unsigned unmaskable:1, masked:1, contained: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 the is the symbol for the main program.  This is the least

     cumbersome way to communicate this function property without

     strcmp'ing with __MAIN everywhere.  */

  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;

}

symbol_attribute;

/* 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

   which file it resides in

   locus point to the sourceline and the character in the source

   line.

*/

typedef struct gfc_file

{

  struct gfc_file *included_by, *next, *up;

  int inclusion_line, line;

  char *filename;

} gfc_file;

typedef struct gfc_linebuf

{

#ifdef USE_MAPPED_LOCATION

  source_location location;

#else

  int linenum;

#endif

  struct gfc_file *file;

  struct gfc_linebuf *next;

  int truncated;

  char line[1];

} gfc_linebuf;

#define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))

typedef struct

{

  char *nextc;

  gfc_linebuf *lb;

} locus;

/* In order for the "gfc" format checking to work correctly, you must

   have declared a typedef locus first.  */

#if GCC_VERSION >= 4001

#define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)

#else

#define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)

#endif

extern int gfc_suppress_error;

/* Character length structures hold the expression that gives the

   length of a character variable.  We avoid putting these into

   gfc_typespec because doing so prevents us from doing structure

   copies and forces us to deallocate any typespecs we create, as well

   as structures that contain typespecs.  They also can have multiple

   character typespecs pointing to them.

   These structures form a singly linked list within the current

   namespace and are deallocated with the namespace.  It is possible to

   end up with gfc_charlen structures that have nothing pointing to them.  */

typedef struct gfc_charlen

{

  struct gfc_expr *length;

  struct gfc_charlen *next;

  tree backend_decl;

  int resolved;

}

gfc_charlen;

#define gfc_get_charlen() gfc_getmem(sizeof(gfc_charlen))

/* Type specification structure.  FIXME: derived and cl could be union???  */

typedef struct

{

  bt type;

  int kind;

  struct gfc_symbol *derived;

  gfc_charlen *cl;      /* For character types only.  */

}

gfc_typespec;

/* Array specification.  */

typedef struct

{

  int rank;     /* A rank of zero means that a variable is a scalar.  */

  array_type type;

  struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];

  /* These two fields are used with the Cray Pointer extension.  */

  bool cray_pointee; /* True iff this spec belongs to a cray pointee.  */

  bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to

                        AS_EXPLICIT, but we want to remember that we

                        did this.  */

}

gfc_array_spec;

#define gfc_get_array_spec() gfc_getmem(sizeof(gfc_array_spec))

/* Components of derived types.  */

typedef struct gfc_component

{

  const char *name;

  gfc_typespec ts;

  int pointer, dimension;

  gfc_array_spec *as;

  tree backend_decl;

  locus loc;

  struct gfc_expr *initializer;

  struct gfc_component *next;

}

gfc_component;

#define gfc_get_component() gfc_getmem(sizeof(gfc_component))

/* Formal argument lists are lists of symbols.  */

typedef struct gfc_formal_arglist

{

  /* Symbol representing the argument at this position in the arglist.  */

  struct gfc_symbol *sym;

  /* Points to the next formal argument.  */

  struct gfc_formal_arglist *next;

}

gfc_formal_arglist;

#define gfc_get_formal_arglist() gfc_getmem(sizeof(gfc_formal_arglist))

/* The gfc_actual_arglist structure is for actual arguments.  */

typedef struct gfc_actual_arglist

{

  const char *name;

  /* Alternate return label when the expr member is null.  */

  struct gfc_st_label *label;

  /* This is set to the type of an eventual omitted optional

     argument. This is used to determine if a hidden string length

     argument has to be added to a function call.  */

  bt missing_arg_type;

  struct gfc_expr *expr;

  struct gfc_actual_arglist *next;

}

gfc_actual_arglist;

#define gfc_get_actual_arglist() gfc_getmem(sizeof(gfc_actual_arglist))

/* Because a symbol can belong to multiple namelists, they must be

   linked externally to the symbol itself.  */

typedef struct gfc_namelist

{

  struct gfc_symbol *sym;

  struct gfc_namelist *next;

}

gfc_namelist;

#define gfc_get_namelist() gfc_getmem(sizeof(gfc_namelist))

/* The gfc_st_label structure is a doubly linked list attached to a

   namespace that records the usage of statement labels within that

   space.  */

/* TODO: Make format/statement specifics a union.  */

typedef struct gfc_st_label

{

  int value;

  gfc_sl_type defined, referenced;

  struct gfc_expr *format;

  tree backend_decl;

  locus where;

  struct gfc_st_label *prev, *next;

}

gfc_st_label;

/* gfc_interface()-- Interfaces are lists of symbols strung together.  */

typedef struct gfc_interface

{

  struct gfc_symbol *sym;

  locus where;

  struct gfc_interface *next;

}

gfc_interface;

#define gfc_get_interface() gfc_getmem(sizeof(gfc_interface))

/* User operator nodes.  These are like stripped down symbols.  */

typedef struct

{

  const char *name;

  gfc_interface *operator;

  struct gfc_namespace *ns;

  gfc_access access;

}

gfc_user_op;

/* Symbol nodes.  These are important things.  They are what the

   standard refers to as "entities".  The possibly multiple names that

   refer to the same entity are accomplished by a binary tree of

   symtree structures that is balanced by the red-black method-- more

   than one symtree node can point to any given symbol.  */

typedef struct gfc_symbol

{

  const char *name;     /* Primary name, before renaming */

  const char *module;   /* Module this symbol came from */

  locus declared_at;

  gfc_typespec ts;

  symbol_attribute attr;

  /* The interface member points to the formal argument list if the

     symbol is a function or subroutine name.  If the symbol is a

     generic name, the generic member points to the list of

     interfaces.  */

  gfc_interface *generic;

  gfc_access component_access;

  gfc_formal_arglist *formal;

  struct gfc_namespace *formal_ns;

  struct gfc_expr *value;       /* Parameter/Initializer value */

  gfc_array_spec *as;

  struct gfc_symbol *result;    /* function result symbol */

  gfc_component *components;    /* Derived type components */

  /* Defined only for Cray pointees; points to their pointer.  */

  struct gfc_symbol *cp_pointer;

  struct gfc_symbol *common_next;       /* Links for COMMON syms */

  /* This is in fact a gfc_common_head but it is only used for pointer

     comparisons to check if symbols are in the same common block.  */

  struct gfc_common_head* common_head;

  /* Make sure setup code for dummy arguments is generated in the correct

     order.  */

  int dummy_order;

  gfc_namelist *namelist, *namelist_tail;

  /* Change management fields.  Symbols that might be modified by the

     current statement have the mark member nonzero and are kept in a

     singly linked list through the tlink field.  Of these symbols,

     symbols with old_symbol equal to NULL are symbols created within

     the current statement.  Otherwise, old_symbol points to a copy of

     the old symbol.  */

  struct gfc_symbol *old_symbol, *tlink;

  unsigned mark:1, new:1;