[thirdparty/gcc.git] / libgfortran / libgfortran.h

/* Common declarations for all of libgfor.
   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   Contributed by Paul Brook <paul@nowt.org>, and
   Andy Vaught <andy@xena.eas.asu.edu>

This file is part of the GNU Fortran 95 runtime library (libgfortran).

Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

Libgfortran 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with libgfor; see the file COPYING.LIB.  If not,
write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

/* As a special exception, if you link this library with other files,
   some of which are compiled with GCC, to produce an executable,
   this library does not by itself cause the resulting executable
   to be covered by the GNU General Public License.
   This exception does not however invalidate any other reasons why
   the executable file might be covered by the GNU General Public License.  */


#ifndef LIBGFOR_H
#define LIBGFOR_H

#include <math.h>
#include <stddef.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846264338327
#endif

#if HAVE_COMPLEX_H
# include <complex.h>
#else
#define complex __complex__
#endif

#include "config.h"
#include "c99_protos.h"

#if HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

#if HAVE_STDINT_H
#include <stdint.h>
#endif

#if HAVE_INTTYPES_H
#include <inttypes.h>
#endif

#if !defined(HAVE_STDINT_H) && !defined(HAVE_INTTYPES_H) && defined(TARGET_ILP32)
typedef char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
#endif

#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
typedef off_t gfc_offset;

#ifndef NULL
#define NULL (void *) 0
#endif

#ifndef __GNUC__
#define __attribute__(x)
#endif

/* For a library, a standard prefix is a requirement in order to partition
   the namespace.  IPREFIX is for symbols intended to be internal to the
   library.  */
#define PREFIX(x)	_gfortran_ ## x
#define IPREFIX(x)	_gfortrani_ ## x

/* Magic to rename a symbol at the compiler level.  You continue to refer
   to the symbol as OLD in the source, but it'll be named NEW in the asm.  */
#define sym_rename(old, new) sym_rename1(old, __USER_LABEL_PREFIX__, new)
#define sym_rename1(old, ulp, new) sym_rename2(old, ulp, new)
#define sym_rename2(old, ulp, new) extern __typeof(old) old __asm__(#ulp #new)

/* There are several classifications of routines:

     (1) Symbols used only within the library,
     (2) Symbols to be exported from the library,
     (3) Symbols to be exported from the library, but
	 also used inside the library.

   By telling the compiler about these different classifications we can
   tightly control the interface seen by the user, and get better code
   from the compiler at the same time.

   One of the following should be used immediately after the declaration
   of each symbol:

     internal_proto	Marks a symbol used only within the library,
			and adds IPREFIX to the assembly-level symbol
			name.  The later is important for maintaining
			the namespace partition for the static library.

     export_proto	Marks a symbol to be exported, and adds PREFIX
			to the assembly-level symbol name.

     export_proto_np	Marks a symbol to be exported without adding PREFIX.

     iexport_proto	Marks a function to be exported, but with the 
			understanding that it can be used inside as well.

     iexport_data_proto	Similarly, marks a data symbol to be exported.
			Unfortunately, some systems can't play the hidden
			symbol renaming trick on data symbols, thanks to
			the horribleness of COPY relocations.

   If iexport_proto or iexport_data_proto is used, you must also use
   iexport or iexport_data after the *definition* of the symbol.  */

#if defined(HAVE_ATTRIBUTE_VISIBILITY)
# define internal_proto(x) \
	sym_rename(x, IPREFIX (x)) __attribute__((__visibility__("hidden")))
#else
# define internal_proto(x)	sym_rename(x, IPREFIX(x))
#endif

#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS)
# define export_proto(x)	sym_rename(x, PREFIX(x))
# define export_proto_np(x)	extern char swallow_semicolon
# define iexport_proto(x)	internal_proto(x)
# define iexport(x)		iexport1(x, __USER_LABEL_PREFIX__, IPREFIX(x))
# define iexport1(x,p,y)	iexport2(x,p,y)
# define iexport2(x,p,y) \
	extern __typeof(x) PREFIX(x) __attribute__((__alias__(#p #y)))
/* ??? We're not currently building a dll, and it's wrong to add dllexport
   to objects going into a static library archive.  */
#elif 0 && defined(HAVE_ATTRIBUTE_DLLEXPORT)
# define export_proto_np(x)	extern __typeof(x) x __attribute__((dllexport))
# define export_proto(x)    sym_rename(x, PREFIX(x)) __attribute__((dllexport))
# define iexport_proto(x)	export_proto(x)
# define iexport(x)		extern char swallow_semicolon
#else
# define export_proto(x)	sym_rename(x, PREFIX(x))
# define export_proto_np(x)	extern char swallow_semicolon
# define iexport_proto(x)	export_proto(x)
# define iexport(x)		extern char swallow_semicolon
#endif

/* TODO: detect the case when we *can* hide the symbol.  */
#define iexport_data_proto(x)	export_proto(x)
#define iexport_data(x)		extern char swallow_semicolon

/* The only reliable way to get the offset of a field in a struct
   in a system independent way is via this macro.  */
#ifndef offsetof
#define offsetof(TYPE, MEMBER)  ((size_t) &((TYPE *) 0)->MEMBER)
#endif

/* The isfinite macro is only available with C99, but some non-C99
   systems still provide fpclassify, and there is a `finite' function
   in BSD.

   Also, isfinite is broken on Cygwin.

   When isfinite is not available, try to use one of the
   alternatives, or bail out.  */

#if defined(HAVE_BROKEN_ISFINITE) || defined(__CYGWIN__)
#undef isfinite
#endif

#if defined(HAVE_BROKEN_ISNAN)
#undef isnan
#endif

#if defined(HAVE_BROKEN_FPCLASSIFY)
#undef fpclassify
#endif

#if !defined(isfinite)
#if !defined(fpclassify)
#define isfinite(x) ((x) - (x) == 0)
#else
#define isfinite(x) (fpclassify(x) != FP_NAN && fpclassify(x) != FP_INFINITE)
#endif /* !defined(fpclassify) */
#endif /* !defined(isfinite)  */

#if !defined(isnan)
#if !defined(fpclassify)
#define isnan(x) ((x) != (x))
#else
#define isnan(x) (fpclassify(x) == FP_NAN)
#endif /* !defined(fpclassify) */
#endif /* !defined(isfinite)  */

/* TODO: find the C99 version of these an move into above ifdef.  */
#define REALPART(z) (__real__(z))
#define IMAGPART(z) (__imag__(z))
#define COMPLEX_ASSIGN(z_, r_, i_) {__real__(z_) = (r_); __imag__(z_) = (i_);}

#include "kinds.h"

/* The following two definitions must be consistent with the types used
   by the compiler.  */
/* The type used of array indices, amongst other things.  */
typedef ssize_t index_type;
/* The type used for the lengths of character variables.  */
typedef GFC_INTEGER_4 gfc_charlen_type;

/* This will be 0 on little-endian machines and one on big-endian machines.  */
extern int l8_to_l4_offset;
internal_proto(l8_to_l4_offset);

#define GFOR_POINTER_L8_TO_L4(p8) \
  (l8_to_l4_offset + (GFC_LOGICAL_4 *)(p8))

#define GFC_INTEGER_4_HUGE \
  (GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
#define GFC_INTEGER_8_HUGE \
  (GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
#define GFC_REAL_4_HUGE FLT_MAX
#define GFC_REAL_8_HUGE DBL_MAX

#ifndef GFC_MAX_DIMENSIONS
#define GFC_MAX_DIMENSIONS 7
#endif

typedef struct descriptor_dimension
{
  index_type stride;
  index_type lbound;
  index_type ubound;
}
descriptor_dimension;

#define GFC_ARRAY_DESCRIPTOR(r, type) \
struct {\
  type *data;\
  size_t offset;\
  index_type dtype;\
  descriptor_dimension dim[r];\
}

/* Commonly used array descriptor types.  */
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;

#define GFC_DTYPE_RANK_MASK 0x07
#define GFC_DTYPE_TYPE_SHIFT 3
#define GFC_DTYPE_TYPE_MASK 0x38
#define GFC_DTYPE_SIZE_SHIFT 6

enum
{
  GFC_DTYPE_UNKNOWN = 0,
  GFC_DTYPE_INTEGER,
  /* TODO: recognize logical types.  */
  GFC_DTYPE_LOGICAL,
  GFC_DTYPE_REAL,
  GFC_DTYPE_COMPLEX,
  GFC_DTYPE_DERIVED,
  GFC_DTYPE_CHARACTER
};

#define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
#define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
                                   >> GFC_DTYPE_TYPE_SHIFT)
#define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
#define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
#define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)

/* Runtime library include.  */
#define stringize(x) expand_macro(x)
#define expand_macro(x) # x

/* Runtime options structure.  */

typedef struct
{
  int stdin_unit, stdout_unit, stderr_unit, optional_plus;
  int allocate_init_flag, allocate_init_value;
  int locus;

  int separator_len;
  const char *separator;

  int mem_check;
  int use_stderr, all_unbuffered, default_recl;

  int fpu_round, fpu_precision, fpu_invalid, fpu_denormal, fpu_zerodiv,
    fpu_overflow, fpu_underflow, fpu_precision_loss;

  int sighup, sigint;
}
options_t;

extern options_t options;
internal_proto(options);


/* Compile-time options that will influence the library.  */

typedef struct
{
  int warn_std;
  int allow_std;
}
compile_options_t;

extern compile_options_t compile_options;
internal_proto(compile_options);

extern void init_compile_options (void);
internal_proto(init_compile_options);


/* Structure for statement options.  */

typedef struct
{
  const char *name;
  int value;
}
st_option;

/* Runtime errors.  The EOR and EOF errors are required to be negative.  */

typedef enum
{
  ERROR_FIRST = -3,		/* Marker for the first error.  */
  ERROR_EOR = -2,
  ERROR_END = -1,
  ERROR_OK = 0,			/* Indicates success, must be zero.  */
  ERROR_OS,			/* Operating system error, more info in errno.  */
  ERROR_OPTION_CONFLICT,
  ERROR_BAD_OPTION,
  ERROR_MISSING_OPTION,
  ERROR_ALREADY_OPEN,
  ERROR_BAD_UNIT,
  ERROR_FORMAT,
  ERROR_BAD_ACTION,
  ERROR_ENDFILE,
  ERROR_BAD_US,
  ERROR_READ_VALUE,
  ERROR_READ_OVERFLOW,
  ERROR_ARRAY_STRIDE,
  ERROR_LAST			/* Not a real error, the last error # + 1.  */
}
error_codes;


/* Flags to specify which standard/extension contains a feature.
   Keep them in sync with their counterparts in gcc/fortran/gfortran.h.  */
#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.  */


/* The filename and line number don't go inside the globals structure.
   They are set by the rest of the program and must be linked to.  */

/* Location of the current library call (optional).  */
extern unsigned line;
iexport_data_proto(line);

extern char *filename;
iexport_data_proto(filename);

/* Avoid conflicting prototypes of alloca() in system headers by using 
   GCC's builtin alloca().  */
#define gfc_alloca(x)  __builtin_alloca(x)


/* main.c */

extern void library_start (void);
internal_proto(library_start);

extern void library_end (void);
internal_proto(library_end);

extern void set_args (int, char **);
export_proto(set_args);

extern void get_args (int *, char ***);
internal_proto(get_args);

/* error.c */

#define GFC_ITOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 2)
#define GFC_XTOA_BUF_SIZE (sizeof (GFC_UINTEGER_LARGEST) * 2 + 1)
#define GFC_OTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 1)
#define GFC_BTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 8 + 1)

extern const char *gfc_itoa (GFC_INTEGER_LARGEST, char *, size_t);
internal_proto(gfc_itoa);

extern const char *xtoa (GFC_UINTEGER_LARGEST, char *, size_t);
internal_proto(xtoa);

extern void os_error (const char *) __attribute__ ((noreturn));
internal_proto(os_error);

extern void show_locus (void);
internal_proto(show_locus);

extern void runtime_error (const char *) __attribute__ ((noreturn));
iexport_proto(runtime_error);

extern void internal_error (const char *) __attribute__ ((noreturn));
internal_proto(internal_error);

extern const char *get_oserror (void);
internal_proto(get_oserror);

extern void sys_exit (int) __attribute__ ((noreturn));
internal_proto(sys_exit);

extern int st_printf (const char *, ...)
  __attribute__ ((format (printf, 1, 2)));
internal_proto(st_printf);

extern void st_sprintf (char *, const char *, ...)
  __attribute__ ((format (printf, 2, 3)));
internal_proto(st_sprintf);

extern const char *translate_error (int);
internal_proto(translate_error);

extern void generate_error (int, const char *);
internal_proto(generate_error);

/* memory.c */

extern void *get_mem (size_t) __attribute__ ((malloc));
internal_proto(get_mem);

extern void free_mem (void *);
internal_proto(free_mem);

extern void *internal_malloc_size (size_t);
internal_proto(internal_malloc_size);

extern void internal_free (void *);
iexport_proto(internal_free);

/* environ.c */

extern int check_buffered (int);
internal_proto(check_buffered);

extern void init_variables (void);
internal_proto(init_variables);

extern void show_variables (void);
internal_proto(show_variables);

/* string.c */

extern int find_option (const char *, int, const st_option *, const char *);
internal_proto(find_option);

extern int fstrlen (const char *, int);
internal_proto(fstrlen);

extern void fstrcpy (char *, int, const char *, int);
internal_proto(fstrcpy);

extern void cf_strcpy (char *, int, const char *);
internal_proto(cf_strcpy);

/* io.c */

extern void init_units (void);
internal_proto(init_units);

extern void close_units (void);
internal_proto(close_units);

/* stop.c */

extern void stop_numeric (GFC_INTEGER_4);
iexport_proto(stop_numeric);

/* reshape_packed.c */

extern void reshape_packed (char *, index_type, const char *, index_type,
			    const char *, index_type);
internal_proto(reshape_packed);

/* Repacking functions.  */

/* ??? These eight aren't currently used by the compiler, though we
   certainly could do so.  */
GFC_INTEGER_4 *internal_pack_4 (gfc_array_i4 *);
internal_proto(internal_pack_4);

GFC_INTEGER_8 *internal_pack_8 (gfc_array_i8 *);
internal_proto(internal_pack_8);

GFC_COMPLEX_4 *internal_pack_c4 (gfc_array_c4 *);
internal_proto(internal_pack_c4);

GFC_COMPLEX_8 *internal_pack_c8 (gfc_array_c8 *);
internal_proto(internal_pack_c8);

extern void internal_unpack_4 (gfc_array_i4 *, const GFC_INTEGER_4 *);
internal_proto(internal_unpack_4);

extern void internal_unpack_8 (gfc_array_i8 *, const GFC_INTEGER_8 *);
internal_proto(internal_unpack_8);

extern void internal_unpack_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *);
internal_proto(internal_unpack_c4);

extern void internal_unpack_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *);
internal_proto(internal_unpack_c8);

/* string_intrinsics.c */

extern GFC_INTEGER_4 compare_string (GFC_INTEGER_4, const char *,
				     GFC_INTEGER_4, const char *);
iexport_proto(compare_string);

/* random.c */

extern void random_seed (GFC_INTEGER_4 * size, gfc_array_i4 * put,
			 gfc_array_i4 * get);
iexport_proto(random_seed);

/* normalize.c */

extern GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER_4, GFC_UINTEGER_4);
internal_proto(normalize_r4_i4);

extern GFC_REAL_8 normalize_r8_i8 (GFC_UINTEGER_8, GFC_UINTEGER_8);
internal_proto(normalize_r8_i8);

/* size.c */

typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;

extern index_type size0 (const array_t * array); 
iexport_proto(size0);

#endif  /* LIBGFOR_H  */
Commit	Line	Data
4ee9c684	1	/* Common declarations for all of libgfor.
da6b28c3	2	Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4ee9c684	3	Contributed by Paul Brook <paul@nowt.org>, and
	4	Andy Vaught <andy@xena.eas.asu.edu>
	5
b417ea8c	6	This file is part of the GNU Fortran 95 runtime library (libgfortran).
4ee9c684	7
b417ea8c	8	Libgfortran is free software; you can redistribute it and/or
4ee9c684	9	modify it under the terms of the GNU Lesser General Public
	10	License as published by the Free Software Foundation; either
	11	version 2.1 of the License, or (at your option) any later version.
	12
b417ea8c	13	Libgfortran is distributed in the hope that it will be useful,
4ee9c684	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public
	19	License along with libgfor; see the file COPYING.LIB. If not,
5ac2525b	20	write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
5ac2525b	21	Boston, MA 02110-1301, USA. */
4ee9c684	22
b417ea8c	23	/* As a special exception, if you link this library with other files,
	24	some of which are compiled with GCC, to produce an executable,
	25	this library does not by itself cause the resulting executable
	26	to be covered by the GNU General Public License.
	27	This exception does not however invalidate any other reasons why
	28	the executable file might be covered by the GNU General Public License. */
	29
4ee9c684	30
	31	#ifndef LIBGFOR_H
	32	#define LIBGFOR_H
	33
	34	#include <math.h>
	35	#include <stddef.h>
	36
	37	#ifndef M_PI
	38	#define M_PI 3.14159265358979323846264338327
	39	#endif
	40
4ee9c684	41	#if HAVE_COMPLEX_H
	42	# include <complex.h>
	43	#else
	44	#define complex __complex__
	45	#endif
	46
d213114b	47	#include "config.h"
	48	#include "c99_protos.h"
	49
334f03a1	50	#if HAVE_IEEEFP_H
	51	#include <ieeefp.h>
	52	#endif
	53
4ee9c684	54	#if HAVE_STDINT_H
	55	#include <stdint.h>
	56	#endif
	57
	58	#if HAVE_INTTYPES_H
	59	#include <inttypes.h>
	60	#endif
	61
c436f700	62	#if !defined(HAVE_STDINT_H) && !defined(HAVE_INTTYPES_H) && defined(TARGET_ILP32)
	63	typedef char int8_t;
	64	typedef short int16_t;
	65	typedef int int32_t;
	66	typedef long long int64_t;
	67	typedef unsigned char uint8_t;
	68	typedef unsigned short uint16_t;
	69	typedef unsigned int uint32_t;
	70	typedef unsigned long long uint64_t;
	71	#endif
	72
4ee9c684	73	#if HAVE_SYS_TYPES_H
	74	#include <sys/types.h>
	75	#endif
b093181d	76	typedef off_t gfc_offset;
4ee9c684	77
	78	#ifndef NULL
	79	#define NULL (void *) 0
	80	#endif
	81
	82	#ifndef __GNUC__
	83	#define __attribute__(x)
	84	#endif
	85
7b6cb5bd	86	/* For a library, a standard prefix is a requirement in order to partition
	87	the namespace. IPREFIX is for symbols intended to be internal to the
	88	library. */
	89	#define PREFIX(x) _gfortran_ ## x
	90	#define IPREFIX(x) _gfortrani_ ## x
	91
	92	/* Magic to rename a symbol at the compiler level. You continue to refer
	93	to the symbol as OLD in the source, but it'll be named NEW in the asm. */
	94	#define sym_rename(old, new) sym_rename1(old, __USER_LABEL_PREFIX__, new)
	95	#define sym_rename1(old, ulp, new) sym_rename2(old, ulp, new)
	96	#define sym_rename2(old, ulp, new) extern __typeof(old) old __asm__(#ulp #new)
	97
	98	/* There are several classifications of routines:
	99
	100	(1) Symbols used only within the library,
	101	(2) Symbols to be exported from the library,
	102	(3) Symbols to be exported from the library, but
	103	also used inside the library.
	104
	105	By telling the compiler about these different classifications we can
	106	tightly control the interface seen by the user, and get better code
	107	from the compiler at the same time.
	108
	109	One of the following should be used immediately after the declaration
	110	of each symbol:
	111
	112	internal_proto Marks a symbol used only within the library,
	113	and adds IPREFIX to the assembly-level symbol
	114	name. The later is important for maintaining
	115	the namespace partition for the static library.
	116
	117	export_proto Marks a symbol to be exported, and adds PREFIX
	118	to the assembly-level symbol name.
	119
	120	export_proto_np Marks a symbol to be exported without adding PREFIX.
	121
	122	iexport_proto Marks a function to be exported, but with the
	123	understanding that it can be used inside as well.
	124
	125	iexport_data_proto Similarly, marks a data symbol to be exported.
	126	Unfortunately, some systems can't play the hidden
	127	symbol renaming trick on data symbols, thanks to
	128	the horribleness of COPY relocations.
	129
	130	If iexport_proto or iexport_data_proto is used, you must also use
	131	iexport or iexport_data after the definition of the symbol. */
	132
	133	#if defined(HAVE_ATTRIBUTE_VISIBILITY)
	134	# define internal_proto(x) \
	135	sym_rename(x, IPREFIX (x)) __attribute__((__visibility__("hidden")))
	136	#else
	137	# define internal_proto(x) sym_rename(x, IPREFIX(x))
	138	#endif
	139
	140	#if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS)
	141	# define export_proto(x) sym_rename(x, PREFIX(x))
	142	# define export_proto_np(x) extern char swallow_semicolon
	143	# define iexport_proto(x) internal_proto(x)
	144	# define iexport(x) iexport1(x, __USER_LABEL_PREFIX__, IPREFIX(x))
	145	# define iexport1(x,p,y) iexport2(x,p,y)
	146	# define iexport2(x,p,y) \
	147	extern __typeof(x) PREFIX(x) __attribute__((__alias__(#p #y)))
	148	/* ??? We're not currently building a dll, and it's wrong to add dllexport
	149	to objects going into a static library archive. */
150	#elif 0 && defined(HAVE_ATTRIBUTE_DLLEXPORT)
151	# define export_proto_np(x) extern __typeof(x) x __attribute__((dllexport))
152	# define export_proto(x) sym_rename(x, PREFIX(x)) __attribute__((dllexport))
153	# define iexport_proto(x) export_proto(x)
154	# define iexport(x) extern char swallow_semicolon
155	#else
156	# define export_proto(x) sym_rename(x, PREFIX(x))
157	# define export_proto_np(x) extern char swallow_semicolon
158	# define iexport_proto(x) export_proto(x)
159	# define iexport(x) extern char swallow_semicolon
160	#endif
161
162	/* TODO: detect the case when we can hide the symbol. */
163	#define iexport_data_proto(x) export_proto(x)
164	#define iexport_data(x) extern char swallow_semicolon
4ee9c684	165
	166	/* The only reliable way to get the offset of a field in a struct
	167	in a system independent way is via this macro. */
	168	#ifndef offsetof
	169	#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *) 0)->MEMBER)
	170	#endif
	171
fd48ced8	172	/* The isfinite macro is only available with C99, but some non-C99
fd48ced8	173	systems still provide fpclassify, and there is a `finite' function
b1c49a11	174	in BSD.
	175
	176	Also, isfinite is broken on Cygwin.
	177
	178	When isfinite is not available, try to use one of the
fd48ced8	179	alternatives, or bail out. */
839904a0	180
839904a0	181	#if defined(HAVE_BROKEN_ISFINITE) \|\| defined(__CYGWIN__)
b1c49a11	182	#undef isfinite
839904a0	183	#endif
	184
	185	#if defined(HAVE_BROKEN_ISNAN)
	186	#undef isnan
	187	#endif
	188
	189	#if defined(HAVE_BROKEN_FPCLASSIFY)
	190	#undef fpclassify
	191	#endif
	192
	193	#if !defined(isfinite)
	194	#if !defined(fpclassify)
	195	#define isfinite(x) ((x) - (x) == 0)
	196	#else
c14474b7	197	#define isfinite(x) (fpclassify(x) != FP_NAN && fpclassify(x) != FP_INFINITE)
839904a0	198	#endif /* !defined(fpclassify) */
	199	#endif /* !defined(isfinite) */
	200
	201	#if !defined(isnan)
	202	#if !defined(fpclassify)
	203	#define isnan(x) ((x) != (x))
fd48ced8	204	#else
839904a0	205	#define isnan(x) (fpclassify(x) == FP_NAN)
839904a0	206	#endif /* !defined(fpclassify) */
fd48ced8	207	#endif /* !defined(isfinite) */
fd48ced8	208
4ee9c684	209	/* TODO: find the C99 version of these an move into above ifdef. */
	210	#define REALPART(z) (__real__(z))
	211	#define IMAGPART(z) (__imag__(z))
	212	#define COMPLEX_ASSIGN(z_, r_, i_) {__real__(z_) = (r_); __imag__(z_) = (i_);}
	213
14c3c235	214	#include "kinds.h"
4ee9c684	215
b496d698	216	/* The following two definitions must be consistent with the types used
	217	by the compiler. */
	218	/* The type used of array indices, amongst other things. */
077620f0	219	typedef ssize_t index_type;
9ad09405	220	/* The type used for the lengths of character variables. */
9ad09405	221	typedef GFC_INTEGER_4 gfc_charlen_type;
4ee9c684	222
4ee9c684	223	/* This will be 0 on little-endian machines and one on big-endian machines. */
4ee9c684	224	extern int l8_to_l4_offset;
7b6cb5bd	225	internal_proto(l8_to_l4_offset);
4ee9c684	226
	227	#define GFOR_POINTER_L8_TO_L4(p8) \
	228	(l8_to_l4_offset + (GFC_LOGICAL_4 *)(p8))
	229
	230	#define GFC_INTEGER_4_HUGE \
	231	(GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
	232	#define GFC_INTEGER_8_HUGE \
	233	(GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
	234	#define GFC_REAL_4_HUGE FLT_MAX
	235	#define GFC_REAL_8_HUGE DBL_MAX
	236
	237	#ifndef GFC_MAX_DIMENSIONS
	238	#define GFC_MAX_DIMENSIONS 7
	239	#endif
	240
	241	typedef struct descriptor_dimension
	242	{
	243	index_type stride;
	244	index_type lbound;
	245	index_type ubound;
	246	}
	247	descriptor_dimension;
	248
	249	#define GFC_ARRAY_DESCRIPTOR(r, type) \
	250	struct {\
	251	type *data;\
93830de1	252	size_t offset;\
4ee9c684	253	index_type dtype;\
	254	descriptor_dimension dim[r];\
	255	}
	256
	257	/* Commonly used array descriptor types. */
	258	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
	259	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
	260	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
	261	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
	262	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
	263	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
	264	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
	265	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
	266	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
	267	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;
	268
	269	#define GFC_DTYPE_RANK_MASK 0x07
	270	#define GFC_DTYPE_TYPE_SHIFT 3
	271	#define GFC_DTYPE_TYPE_MASK 0x38
	272	#define GFC_DTYPE_SIZE_SHIFT 6
	273
	274	enum
	275	{
	276	GFC_DTYPE_UNKNOWN = 0,
	277	GFC_DTYPE_INTEGER,
	278	/* TODO: recognize logical types. */
	279	GFC_DTYPE_LOGICAL,
	280	GFC_DTYPE_REAL,
	281	GFC_DTYPE_COMPLEX,
	282	GFC_DTYPE_DERIVED,
	283	GFC_DTYPE_CHARACTER
	284	};
	285
	286	#define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
	287	#define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
	288	>> GFC_DTYPE_TYPE_SHIFT)
	289	#define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
	290	#define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
	291	#define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
	292
	293	/* Runtime library include. */
	294	#define stringize(x) expand_macro(x)
	295	#define expand_macro(x) # x
	296
	297	/* Runtime options structure. */
	298
	299	typedef struct
	300	{
ff81ee3b	301	int stdin_unit, stdout_unit, stderr_unit, optional_plus;
4ee9c684	302	int allocate_init_flag, allocate_init_value;
	303	int locus;
	304
	305	int separator_len;
	306	const char *separator;
	307
	308	int mem_check;
	309	int use_stderr, all_unbuffered, default_recl;
	310
	311	int fpu_round, fpu_precision, fpu_invalid, fpu_denormal, fpu_zerodiv,
	312	fpu_overflow, fpu_underflow, fpu_precision_loss;
	313
	314	int sighup, sigint;
	315	}
	316	options_t;
	317
4ee9c684	318	extern options_t options;
7b6cb5bd	319	internal_proto(options);
4ee9c684	320
4ee9c684	321
64fc3c4c	322	/* Compile-time options that will influence the library. */
	323
	324	typedef struct
	325	{
	326	int warn_std;
	327	int allow_std;
	328	}
	329	compile_options_t;
	330
	331	extern compile_options_t compile_options;
	332	internal_proto(compile_options);
	333
da6b28c3	334	extern void init_compile_options (void);
da6b28c3	335	internal_proto(init_compile_options);
64fc3c4c	336
64fc3c4c	337
4ee9c684	338	/* Structure for statement options. */
	339
	340	typedef struct
	341	{
	342	const char *name;
	343	int value;
	344	}
	345	st_option;
	346
	347	/* Runtime errors. The EOR and EOF errors are required to be negative. */
	348
	349	typedef enum
	350	{
	351	ERROR_FIRST = -3, /* Marker for the first error. */
	352	ERROR_EOR = -2,
	353	ERROR_END = -1,
	354	ERROR_OK = 0, /* Indicates success, must be zero. */
	355	ERROR_OS, /* Operating system error, more info in errno. */
	356	ERROR_OPTION_CONFLICT,
	357	ERROR_BAD_OPTION,
	358	ERROR_MISSING_OPTION,
	359	ERROR_ALREADY_OPEN,
	360	ERROR_BAD_UNIT,
	361	ERROR_FORMAT,
	362	ERROR_BAD_ACTION,
	363	ERROR_ENDFILE,
	364	ERROR_BAD_US,
	365	ERROR_READ_VALUE,
	366	ERROR_READ_OVERFLOW,
2639e4cd	367	ERROR_ARRAY_STRIDE,
4ee9c684	368	ERROR_LAST /* Not a real error, the last error # + 1. */
	369	}
	370	error_codes;
	371
	372
64fc3c4c	373	/* Flags to specify which standard/extension contains a feature.
	374	Keep them in sync with their counterparts in gcc/fortran/gfortran.h. */
	375	#define GFC_STD_LEGACY (1<<6) /* Backward compatibility. */
	376	#define GFC_STD_GNU (1<<5) /* GNU Fortran extension. */
	377	#define GFC_STD_F2003 (1<<4) /* New in F2003. */
	378	/* Note that no features were obsoleted nor deleted in F2003. */
	379	#define GFC_STD_F95 (1<<3) /* New in F95. */
	380	#define GFC_STD_F95_DEL (1<<2) /* Deleted in F95. */
	381	#define GFC_STD_F95_OBS (1<<1) /* Obsoleted in F95. */
	382	#define GFC_STD_F77 (1<<0) /* Up to and including F77. */
	383
	384
4ee9c684	385	/* The filename and line number don't go inside the globals structure.
	386	They are set by the rest of the program and must be linked to. */
	387
7b6cb5bd	388	/* Location of the current library call (optional). */
	389	extern unsigned line;
	390	iexport_data_proto(line);
4ee9c684	391
4ee9c684	392	extern char *filename;
7b6cb5bd	393	iexport_data_proto(filename);
4ee9c684	394
2b573e69	395	/* Avoid conflicting prototypes of alloca() in system headers by using
2b573e69	396	GCC's builtin alloca(). */
2b573e69	397	#define gfc_alloca(x) __builtin_alloca(x)
2b573e69	398
4ee9c684	399
	400	/* main.c */
	401
7b6cb5bd	402	extern void library_start (void);
7b6cb5bd	403	internal_proto(library_start);
4ee9c684	404
7b6cb5bd	405	extern void library_end (void);
7b6cb5bd	406	internal_proto(library_end);
4ee9c684	407
7b6cb5bd	408	extern void set_args (int, char **);
7b6cb5bd	409	export_proto(set_args);
4ee9c684	410
7b6cb5bd	411	extern void get_args (int , char **);
7b6cb5bd	412	internal_proto(get_args);
4ee9c684	413
4ee9c684	414	/* error.c */
4ee9c684	415
556d0269	416	#define GFC_ITOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 2)
	417	#define GFC_XTOA_BUF_SIZE (sizeof (GFC_UINTEGER_LARGEST) * 2 + 1)
	418	#define GFC_OTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 1)
	419	#define GFC_BTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 8 + 1)
	420
	421	extern const char gfc_itoa (GFC_INTEGER_LARGEST, char , size_t);
34991dc4	422	internal_proto(gfc_itoa);
4ee9c684	423
556d0269	424	extern const char xtoa (GFC_UINTEGER_LARGEST, char , size_t);
7b6cb5bd	425	internal_proto(xtoa);
4ee9c684	426
7b6cb5bd	427	extern void os_error (const char *) __attribute__ ((noreturn));
7b6cb5bd	428	internal_proto(os_error);
4ee9c684	429
7b6cb5bd	430	extern void show_locus (void);
7b6cb5bd	431	internal_proto(show_locus);
4ee9c684	432
7b6cb5bd	433	extern void runtime_error (const char *) __attribute__ ((noreturn));
7b6cb5bd	434	iexport_proto(runtime_error);
4ee9c684	435
7b6cb5bd	436	extern void internal_error (const char *) __attribute__ ((noreturn));
7b6cb5bd	437	internal_proto(internal_error);
4ee9c684	438
7b6cb5bd	439	extern const char *get_oserror (void);
7b6cb5bd	440	internal_proto(get_oserror);
4ee9c684	441
7b6cb5bd	442	extern void sys_exit (int) __attribute__ ((noreturn));
7b6cb5bd	443	internal_proto(sys_exit);
4ee9c684	444
7b6cb5bd	445	extern int st_printf (const char *, ...)
	446	__attribute__ ((format (printf, 1, 2)));
	447	internal_proto(st_printf);
4ee9c684	448
7b6cb5bd	449	extern void st_sprintf (char , const char , ...)
	450	__attribute__ ((format (printf, 2, 3)));
	451	internal_proto(st_sprintf);
4ee9c684	452
7b6cb5bd	453	extern const char *translate_error (int);
7b6cb5bd	454	internal_proto(translate_error);
4ee9c684	455
7b6cb5bd	456	extern void generate_error (int, const char *);
7b6cb5bd	457	internal_proto(generate_error);
4ee9c684	458
	459	/* memory.c */
	460
7b6cb5bd	461	extern void *get_mem (size_t) __attribute__ ((malloc));
7b6cb5bd	462	internal_proto(get_mem);
4ee9c684	463
7b6cb5bd	464	extern void free_mem (void *);
7b6cb5bd	465	internal_proto(free_mem);
4ee9c684	466
7b6cb5bd	467	extern void *internal_malloc_size (size_t);
7b6cb5bd	468	internal_proto(internal_malloc_size);
4ee9c684	469
7b6cb5bd	470	extern void internal_free (void *);
7b6cb5bd	471	iexport_proto(internal_free);
4ee9c684	472
	473	/* environ.c */
	474
7b6cb5bd	475	extern int check_buffered (int);
7b6cb5bd	476	internal_proto(check_buffered);
4ee9c684	477
7b6cb5bd	478	extern void init_variables (void);
7b6cb5bd	479	internal_proto(init_variables);
4ee9c684	480
7b6cb5bd	481	extern void show_variables (void);
7b6cb5bd	482	internal_proto(show_variables);
4ee9c684	483
	484	/* string.c */
	485
fb35179a	486	extern int find_option (const char , int, const st_option , const char *);
7b6cb5bd	487	internal_proto(find_option);
4ee9c684	488
7b6cb5bd	489	extern int fstrlen (const char *, int);
7b6cb5bd	490	internal_proto(fstrlen);
4ee9c684	491
7b6cb5bd	492	extern void fstrcpy (char , int, const char , int);
7b6cb5bd	493	internal_proto(fstrcpy);
4ee9c684	494
7b6cb5bd	495	extern void cf_strcpy (char , int, const char );
7b6cb5bd	496	internal_proto(cf_strcpy);
4ee9c684	497
	498	/* io.c */
	499
7b6cb5bd	500	extern void init_units (void);
7b6cb5bd	501	internal_proto(init_units);
4ee9c684	502
7b6cb5bd	503	extern void close_units (void);
7b6cb5bd	504	internal_proto(close_units);
4ee9c684	505
4ee9c684	506	/* stop.c */
7b6cb5bd	507
	508	extern void stop_numeric (GFC_INTEGER_4);
	509	iexport_proto(stop_numeric);
4ee9c684	510
4ee9c684	511	/* reshape_packed.c */
4ee9c684	512
7b6cb5bd	513	extern void reshape_packed (char , index_type, const char , index_type,
	514	const char *, index_type);
	515	internal_proto(reshape_packed);
4ee9c684	516
7b6cb5bd	517	/* Repacking functions. */
4ee9c684	518
f27ef643	519	/* ??? These eight aren't currently used by the compiler, though we
7b6cb5bd	520	certainly could do so. */
4ee9c684	521	GFC_INTEGER_4 internal_pack_4 (gfc_array_i4 );
7b6cb5bd	522	internal_proto(internal_pack_4);
4ee9c684	523
4ee9c684	524	GFC_INTEGER_8 internal_pack_8 (gfc_array_i8 );
7b6cb5bd	525	internal_proto(internal_pack_8);
4ee9c684	526
f27ef643	527	GFC_COMPLEX_4 internal_pack_c4 (gfc_array_c4 );
	528	internal_proto(internal_pack_c4);
	529
	530	GFC_COMPLEX_8 internal_pack_c8 (gfc_array_c8 );
	531	internal_proto(internal_pack_c8);
	532
7b6cb5bd	533	extern void internal_unpack_4 (gfc_array_i4 , const GFC_INTEGER_4 );
7b6cb5bd	534	internal_proto(internal_unpack_4);
4ee9c684	535
7b6cb5bd	536	extern void internal_unpack_8 (gfc_array_i8 , const GFC_INTEGER_8 );
7b6cb5bd	537	internal_proto(internal_unpack_8);
8db86b90	538
f27ef643	539	extern void internal_unpack_c4 (gfc_array_c4 , const GFC_COMPLEX_4 );
	540	internal_proto(internal_unpack_c4);
	541
	542	extern void internal_unpack_c8 (gfc_array_c8 , const GFC_COMPLEX_8 );
	543	internal_proto(internal_unpack_c8);
	544
4ee9c684	545	/* string_intrinsics.c */
4ee9c684	546
7b6cb5bd	547	extern GFC_INTEGER_4 compare_string (GFC_INTEGER_4, const char *,
	548	GFC_INTEGER_4, const char *);
	549	iexport_proto(compare_string);
4ee9c684	550
d694eb47	551	/* random.c */
d694eb47	552
7b6cb5bd	553	extern void random_seed (GFC_INTEGER_4 * size, gfc_array_i4 * put,
	554	gfc_array_i4 * get);
	555	iexport_proto(random_seed);
d694eb47	556
4db2deda	557	/* normalize.c */
4db2deda	558
7b6cb5bd	559	extern GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER_4, GFC_UINTEGER_4);
7b6cb5bd	560	internal_proto(normalize_r4_i4);
4db2deda	561
7b6cb5bd	562	extern GFC_REAL_8 normalize_r8_i8 (GFC_UINTEGER_8, GFC_UINTEGER_8);
7b6cb5bd	563	internal_proto(normalize_r8_i8);
4db2deda	564
5fcc57ce	565	/* size.c */
	566
	567	typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
	568
7b6cb5bd	569	extern index_type size0 (const array_t * array);
7b6cb5bd	570	iexport_proto(size0);
5fcc57ce	571
fd48ced8	572	#endif /* LIBGFOR_H */