libgfortran/libgfortran.h

   1 /* Common declarations for all of libgfor.
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Paul Brook <paul@nowt.org>, and
   4    Andy Vaught <andy@xena.eas.asu.edu>
   5
   6 This file is part of the GNU Fortran 95 runtime library (libgfortran).
   7
   8 Libgfortran is free software; you can redistribute it and/or
   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
  13 Libgfortran is distributed in the hope that it will be useful,
  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,
  20 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  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
  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
  41 #include "config.h"
  42 #include "c99_protos.h"
  43
  44 #if HAVE_COMPLEX_H
  45 # include <complex.h>
  46 #else
  47 #define complex __complex__
  48 #endif
  49
  50 #if HAVE_IEEEFP_H
  51 #include <ieeefp.h>
  52 #endif
  53
  54 #if HAVE_STDINT_H
  55 #include <stdint.h>
  56 #endif
  57
  58 #if HAVE_INTTYPES_H
  59 #include <inttypes.h>
  60 #endif
  61
  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
  73 #if HAVE_SYS_TYPES_H
  74 #include <sys/types.h>
  75 #endif
  76 typedef off_t gfc_offset;
  77
  78 #ifndef NULL
  79 #define NULL (void *) 0
  80 #endif
  81
  82 #ifndef __GNUC__
  83 #define __attribute__(x)
  84 #endif
  85
  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
 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
 172 /* The isfinite macro is only available with C99, but some non-C99
 173    systems still provide fpclassify, and there is a `finite' function
 174    in BSD.
 175
 176    Also, isfinite is broken on Cygwin.
 177
 178    When isfinite is not available, try to use one of the
 179    alternatives, or bail out.  */
 180 #if (!defined(isfinite) || defined(__CYGWIN__))
 181 #undef isfinite
 182 static inline int
 183 isfinite (double x)
 184 {
 185 #if defined(fpclassify)
 186   return (fpclassify(x) != FP_NAN && fpclassify(x) != FP_INFINITE);
 187 #elif defined(HAVE_FINITE)
 188   return finite (x);
 189 #else
 190 #error "libgfortran needs isfinite, fpclassify, or finite"
 191 #endif
 192 }
 193 #endif /* !defined(isfinite)  */
 194
 195 /* TODO: find the C99 version of these an move into above ifdef.  */
 196 #define REALPART(z) (__real__(z))
 197 #define IMAGPART(z) (__imag__(z))
 198 #define COMPLEX_ASSIGN(z_, r_, i_) {__real__(z_) = (r_); __imag__(z_) = (i_);}
 199
 200 #include "kinds.h"
 201
 202 /* The following two definitions must be consistent with the types used
 203    by the compiler.  */
 204 /* The type used of array indices, amongst other things.  */
 205 typedef ssize_t index_type;
 206 /* The type used for the lengths of character variables.  */
 207 typedef GFC_INTEGER_4 gfc_charlen_type;
 208
 209 /* This will be 0 on little-endian machines and one on big-endian machines.  */
 210 extern int l8_to_l4_offset;
 211 internal_proto(l8_to_l4_offset);
 212
 213 #define GFOR_POINTER_L8_TO_L4(p8) \
 214   (l8_to_l4_offset + (GFC_LOGICAL_4 *)(p8))
 215
 216 #define GFC_INTEGER_4_HUGE \
 217   (GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
 218 #define GFC_INTEGER_8_HUGE \
 219   (GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
 220 #define GFC_REAL_4_HUGE FLT_MAX
 221 #define GFC_REAL_8_HUGE DBL_MAX
 222
 223 #ifndef GFC_MAX_DIMENSIONS
 224 #define GFC_MAX_DIMENSIONS 7
 225 #endif
 226
 227 typedef struct descriptor_dimension
 228 {
 229   index_type stride;
 230   index_type lbound;
 231   index_type ubound;
 232 }
 233 descriptor_dimension;
 234
 235 #define GFC_ARRAY_DESCRIPTOR(r, type) \
 236 struct {\
 237   type *data;\
 238   type *base;\
 239   index_type dtype;\
 240   descriptor_dimension dim[r];\
 241 }
 242
 243 /* Commonly used array descriptor types.  */
 244 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
 245 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
 246 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
 247 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
 248 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
 249 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
 250 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
 251 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
 252 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
 253 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;
 254
 255 #define GFC_DTYPE_RANK_MASK 0x07
 256 #define GFC_DTYPE_TYPE_SHIFT 3
 257 #define GFC_DTYPE_TYPE_MASK 0x38
 258 #define GFC_DTYPE_SIZE_SHIFT 6
 259
 260 enum
 261 {
 262   GFC_DTYPE_UNKNOWN = 0,
 263   GFC_DTYPE_INTEGER,
 264   /* TODO: recognize logical types.  */
 265   GFC_DTYPE_LOGICAL,
 266   GFC_DTYPE_REAL,
 267   GFC_DTYPE_COMPLEX,
 268   GFC_DTYPE_DERIVED,
 269   GFC_DTYPE_CHARACTER
 270 };
 271
 272 #define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
 273 #define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
 274                                    >> GFC_DTYPE_TYPE_SHIFT)
 275 #define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
 276 #define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
 277 #define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
 278
 279 /* Runtime library include.  */
 280 #define stringize(x) expand_macro(x)
 281 #define expand_macro(x) # x
 282
 283 /* Runtime options structure.  */
 284
 285 typedef struct
 286 {
 287   int stdin_unit, stdout_unit, stderr_unit, optional_plus;
 288   int allocate_init_flag, allocate_init_value;
 289   int locus;
 290
 291   int separator_len;
 292   const char *separator;
 293
 294   int mem_check;
 295   int use_stderr, all_unbuffered, default_recl;
 296
 297   int fpu_round, fpu_precision, fpu_invalid, fpu_denormal, fpu_zerodiv,
 298     fpu_overflow, fpu_underflow, fpu_precision_loss;
 299
 300   int sighup, sigint;
 301 }
 302 options_t;
 303
 304
 305 extern options_t options;
 306 internal_proto(options);
 307
 308
 309 /* Structure for statement options.  */
 310
 311 typedef struct
 312 {
 313   const char *name;
 314   int value;
 315 }
 316 st_option;
 317
 318 /* Runtime errors.  The EOR and EOF errors are required to be negative.  */
 319
 320 typedef enum
 321 {
 322   ERROR_FIRST = -3,             /* Marker for the first error.  */
 323   ERROR_EOR = -2,
 324   ERROR_END = -1,
 325   ERROR_OK = 0,                 /* Indicates success, must be zero.  */
 326   ERROR_OS,                     /* Operating system error, more info in errno.  */
 327   ERROR_OPTION_CONFLICT,
 328   ERROR_BAD_OPTION,
 329   ERROR_MISSING_OPTION,
 330   ERROR_ALREADY_OPEN,
 331   ERROR_BAD_UNIT,
 332   ERROR_FORMAT,
 333   ERROR_BAD_ACTION,
 334   ERROR_ENDFILE,
 335   ERROR_BAD_US,
 336   ERROR_READ_VALUE,
 337   ERROR_READ_OVERFLOW,
 338   ERROR_LAST                    /* Not a real error, the last error # + 1.  */
 339 }
 340 error_codes;
 341
 342
 343 /* The filename and line number don't go inside the globals structure.
 344    They are set by the rest of the program and must be linked to.  */
 345
 346 /* Location of the current library call (optional).  */
 347 extern unsigned line;
 348 iexport_data_proto(line);
 349
 350 extern char *filename;
 351 iexport_data_proto(filename);
 352
 353 /* Avoid conflicting prototypes of alloca() in system headers by using
 354    GCC's builtin alloca().  */
 355 #define gfc_alloca(x)  __builtin_alloca(x)
 356
 357
 358 /* main.c */
 359
 360 extern void library_start (void);
 361 internal_proto(library_start);
 362
 363 extern void library_end (void);
 364 internal_proto(library_end);
 365
 366 extern void set_args (int, char **);
 367 export_proto(set_args);
 368
 369 extern void get_args (int *, char ***);
 370 internal_proto(get_args);
 371
 372 /* error.c */
 373
 374 extern char *gfc_itoa (GFC_INTEGER_LARGEST);
 375 internal_proto(gfc_itoa);
 376
 377 extern char *xtoa (GFC_UINTEGER_LARGEST);
 378 internal_proto(xtoa);
 379
 380 extern void os_error (const char *) __attribute__ ((noreturn));
 381 internal_proto(os_error);
 382
 383 extern void show_locus (void);
 384 internal_proto(show_locus);
 385
 386 extern void runtime_error (const char *) __attribute__ ((noreturn));
 387 iexport_proto(runtime_error);
 388
 389 extern void internal_error (const char *) __attribute__ ((noreturn));
 390 internal_proto(internal_error);
 391
 392 extern const char *get_oserror (void);
 393 internal_proto(get_oserror);
 394
 395 extern void sys_exit (int) __attribute__ ((noreturn));
 396 internal_proto(sys_exit);
 397
 398 extern int st_printf (const char *, ...)
 399   __attribute__ ((format (printf, 1, 2)));
 400 internal_proto(st_printf);
 401
 402 extern void st_sprintf (char *, const char *, ...)
 403   __attribute__ ((format (printf, 2, 3)));
 404 internal_proto(st_sprintf);
 405
 406 extern const char *translate_error (int);
 407 internal_proto(translate_error);
 408
 409 extern void generate_error (int, const char *);
 410 internal_proto(generate_error);
 411
 412 /* memory.c */
 413
 414 extern void *get_mem (size_t) __attribute__ ((malloc));
 415 internal_proto(get_mem);
 416
 417 extern void free_mem (void *);
 418 internal_proto(free_mem);
 419
 420 extern void *internal_malloc_size (size_t);
 421 internal_proto(internal_malloc_size);
 422
 423 extern void internal_free (void *);
 424 iexport_proto(internal_free);
 425
 426 /* environ.c */
 427
 428 extern int check_buffered (int);
 429 internal_proto(check_buffered);
 430
 431 extern void init_variables (void);
 432 internal_proto(init_variables);
 433
 434 extern void show_variables (void);
 435 internal_proto(show_variables);
 436
 437 /* string.c */
 438
 439 extern int find_option (const char *, int, st_option *, const char *);
 440 internal_proto(find_option);
 441
 442 extern int fstrlen (const char *, int);
 443 internal_proto(fstrlen);
 444
 445 extern void fstrcpy (char *, int, const char *, int);
 446 internal_proto(fstrcpy);
 447
 448 extern void cf_strcpy (char *, int, const char *);
 449 internal_proto(cf_strcpy);
 450
 451 /* io.c */
 452
 453 extern void init_units (void);
 454 internal_proto(init_units);
 455
 456 extern void close_units (void);
 457 internal_proto(close_units);
 458
 459 /* stop.c */
 460
 461 extern void stop_numeric (GFC_INTEGER_4);
 462 iexport_proto(stop_numeric);
 463
 464 /* reshape_packed.c */
 465
 466 extern void reshape_packed (char *, index_type, const char *, index_type,
 467                             const char *, index_type);
 468 internal_proto(reshape_packed);
 469
 470 /* Repacking functions.  */
 471
 472 /* ??? These eight aren't currently used by the compiler, though we
 473    certainly could do so.  */
 474 GFC_INTEGER_4 *internal_pack_4 (gfc_array_i4 *);
 475 internal_proto(internal_pack_4);
 476
 477 GFC_INTEGER_8 *internal_pack_8 (gfc_array_i8 *);
 478 internal_proto(internal_pack_8);
 479
 480 GFC_COMPLEX_4 *internal_pack_c4 (gfc_array_c4 *);
 481 internal_proto(internal_pack_c4);
 482
 483 GFC_COMPLEX_8 *internal_pack_c8 (gfc_array_c8 *);
 484 internal_proto(internal_pack_c8);
 485
 486 extern void internal_unpack_4 (gfc_array_i4 *, const GFC_INTEGER_4 *);
 487 internal_proto(internal_unpack_4);
 488
 489 extern void internal_unpack_8 (gfc_array_i8 *, const GFC_INTEGER_8 *);
 490 internal_proto(internal_unpack_8);
 491
 492 extern void internal_unpack_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *);
 493 internal_proto(internal_unpack_c4);
 494
 495 extern void internal_unpack_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *);
 496 internal_proto(internal_unpack_c8);
 497
 498 /* string_intrinsics.c */
 499
 500 extern GFC_INTEGER_4 compare_string (GFC_INTEGER_4, const char *,
 501                                      GFC_INTEGER_4, const char *);
 502 iexport_proto(compare_string);
 503
 504 /* random.c */
 505
 506 extern void random_seed (GFC_INTEGER_4 * size, gfc_array_i4 * put,
 507                          gfc_array_i4 * get);
 508 iexport_proto(random_seed);
 509
 510 /* normalize.c */
 511
 512 extern GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER_4, GFC_UINTEGER_4);
 513 internal_proto(normalize_r4_i4);
 514
 515 extern GFC_REAL_8 normalize_r8_i8 (GFC_UINTEGER_8, GFC_UINTEGER_8);
 516 internal_proto(normalize_r8_i8);
 517
 518 /* size.c */
 519
 520 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
 521
 522 extern index_type size0 (const array_t * array);
 523 iexport_proto(size0);
 524
 525 #endif  /* LIBGFOR_H  */