libgfortran/libgfortran.h

   1 /* Common declarations for all of libgfortran.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
   3    Free Software Foundation, Inc.
   4    Contributed by Paul Brook <paul@nowt.org>, and
   5    Andy Vaught <andy@xena.eas.asu.edu>
   6
   7 This file is part of the GNU Fortran 95 runtime library (libgfortran).
   8
   9 Libgfortran is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU Lesser General Public
  11 License as published by the Free Software Foundation; either
  12 version 2.1 of the License, or (at your option) any later version.
  13
  14 Libgfortran is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU Lesser General Public License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public
  20 License along with libgfor; see the file COPYING.LIB.  If not,
  21 write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 /* As a special exception, if you link this library with other files,
  25    some of which are compiled with GCC, to produce an executable,
  26    this library does not by itself cause the resulting executable
  27    to be covered by the GNU General Public License.
  28    This exception does not however invalidate any other reasons why
  29    the executable file might be covered by the GNU General Public License.  */
  30
  31
  32 #ifndef LIBGFOR_H
  33 #define LIBGFOR_H
  34
  35 /* config.h MUST be first because it can affect system headers.  */
  36 #include "config.h"
  37
  38 #include <stdio.h>
  39 #include <math.h>
  40 #include <stddef.h>
  41 #include <float.h>
  42 #include <stdarg.h>
  43
  44 #if HAVE_COMPLEX_H
  45 # include <complex.h>
  46 #else
  47 #define complex __complex__
  48 #endif
  49
  50 #include "../gcc/fortran/libgfortran.h"
  51
  52 #include "c99_protos.h"
  53
  54 #if HAVE_IEEEFP_H
  55 #include <ieeefp.h>
  56 #endif
  57
  58 #include "gstdint.h"
  59
  60 #if HAVE_SYS_TYPES_H
  61 #include <sys/types.h>
  62 #endif
  63 typedef off_t gfc_offset;
  64
  65 #ifndef NULL
  66 #define NULL (void *) 0
  67 #endif
  68
  69 #ifndef __GNUC__
  70 #define __attribute__(x)
  71 #endif
  72
  73
  74 /* We use intptr_t and uintptr_t, which may not be always defined in
  75    system headers.  */
  76
  77 #ifndef HAVE_INTPTR_T
  78 #if __SIZEOF_POINTER__ == __SIZEOF_LONG__
  79 #define intptr_t long
  80 #elif __SIZEOF_POINTER__ == __SIZEOF_LONG_LONG__
  81 #define intptr_t long long
  82 #elif __SIZEOF_POINTER__ == __SIZEOF_INT__
  83 #define intptr_t int
  84 #elif __SIZEOF_POINTER__ == __SIZEOF_SHORT__
  85 #define intptr_t short
  86 #else
  87 #error "Pointer type with unexpected size"
  88 #endif
  89 #endif
  90
  91 #ifndef HAVE_UINTPTR_T
  92 #if __SIZEOF_POINTER__ == __SIZEOF_LONG__
  93 #define uintptr_t unsigned long
  94 #elif __SIZEOF_POINTER__ == __SIZEOF_LONG_LONG__
  95 #define uintptr_t unsigned long long
  96 #elif __SIZEOF_POINTER__ == __SIZEOF_INT__
  97 #define uintptr_t unsigned int
  98 #elif __SIZEOF_POINTER__ == __SIZEOF_SHORT__
  99 #define uintptr_t unsigned short
 100 #else
 101 #error "Pointer type with unexpected size"
 102 #endif
 103 #endif
 104
 105
 106 /* On mingw, work around the buggy Windows snprintf() by using the one
 107    mingw provides, __mingw_snprintf().  We also provide a prototype for
 108    __mingw_snprintf(), because the mingw headers currently don't have one.  */
 109 #if HAVE_MINGW_SNPRINTF
 110 extern int __mingw_snprintf (char *, size_t, const char *, ...);
 111 #undef snprintf
 112 #define snprintf __mingw_snprintf
 113 #endif
 114
 115
 116 /* For a library, a standard prefix is a requirement in order to partition
 117    the namespace.  IPREFIX is for symbols intended to be internal to the
 118    library.  */
 119 #define PREFIX(x)       _gfortran_ ## x
 120 #define IPREFIX(x)      _gfortrani_ ## x
 121
 122 /* Magic to rename a symbol at the compiler level.  You continue to refer
 123    to the symbol as OLD in the source, but it'll be named NEW in the asm.  */
 124 #define sym_rename(old, new) sym_rename1(old, __USER_LABEL_PREFIX__, new)
 125 #define sym_rename1(old, ulp, new) sym_rename2(old, ulp, new)
 126 #define sym_rename2(old, ulp, new) extern __typeof(old) old __asm__(#ulp #new)
 127
 128 /* There are several classifications of routines:
 129
 130      (1) Symbols used only within the library,
 131      (2) Symbols to be exported from the library,
 132      (3) Symbols to be exported from the library, but
 133          also used inside the library.
 134
 135    By telling the compiler about these different classifications we can
 136    tightly control the interface seen by the user, and get better code
 137    from the compiler at the same time.
 138
 139    One of the following should be used immediately after the declaration
 140    of each symbol:
 141
 142      internal_proto     Marks a symbol used only within the library,
 143                         and adds IPREFIX to the assembly-level symbol
 144                         name.  The later is important for maintaining
 145                         the namespace partition for the static library.
 146
 147      export_proto       Marks a symbol to be exported, and adds PREFIX
 148                         to the assembly-level symbol name.
 149
 150      export_proto_np    Marks a symbol to be exported without adding PREFIX.
 151
 152      iexport_proto      Marks a function to be exported, but with the
 153                         understanding that it can be used inside as well.
 154
 155      iexport_data_proto Similarly, marks a data symbol to be exported.
 156                         Unfortunately, some systems can't play the hidden
 157                         symbol renaming trick on data symbols, thanks to
 158                         the horribleness of COPY relocations.
 159
 160    If iexport_proto or iexport_data_proto is used, you must also use
 161    iexport or iexport_data after the *definition* of the symbol.  */
 162
 163 #if defined(HAVE_ATTRIBUTE_VISIBILITY)
 164 # define internal_proto(x) \
 165         sym_rename(x, IPREFIX (x)) __attribute__((__visibility__("hidden")))
 166 #else
 167 # define internal_proto(x)      sym_rename(x, IPREFIX(x))
 168 #endif
 169
 170 #if defined(HAVE_ATTRIBUTE_VISIBILITY) && defined(HAVE_ATTRIBUTE_ALIAS)
 171 # define export_proto(x)        sym_rename(x, PREFIX(x))
 172 # define export_proto_np(x)     extern char swallow_semicolon
 173 # define iexport_proto(x)       internal_proto(x)
 174 # define iexport(x)             iexport1(x, IPREFIX(x))
 175 # define iexport1(x,y)          iexport2(x,y)
 176 # define iexport2(x,y) \
 177         extern __typeof(x) PREFIX(x) __attribute__((__alias__(#y)))
 178 /* ??? We're not currently building a dll, and it's wrong to add dllexport
 179    to objects going into a static library archive.  */
 180 #elif 0 && defined(HAVE_ATTRIBUTE_DLLEXPORT)
 181 # define export_proto_np(x)     extern __typeof(x) x __attribute__((dllexport))
 182 # define export_proto(x)    sym_rename(x, PREFIX(x)) __attribute__((dllexport))
 183 # define iexport_proto(x)       export_proto(x)
 184 # define iexport(x)             extern char swallow_semicolon
 185 #else
 186 # define export_proto(x)        sym_rename(x, PREFIX(x))
 187 # define export_proto_np(x)     extern char swallow_semicolon
 188 # define iexport_proto(x)       export_proto(x)
 189 # define iexport(x)             extern char swallow_semicolon
 190 #endif
 191
 192 /* TODO: detect the case when we *can* hide the symbol.  */
 193 #define iexport_data_proto(x)   export_proto(x)
 194 #define iexport_data(x)         extern char swallow_semicolon
 195
 196 /* The only reliable way to get the offset of a field in a struct
 197    in a system independent way is via this macro.  */
 198 #ifndef offsetof
 199 #define offsetof(TYPE, MEMBER)  ((size_t) &((TYPE *) 0)->MEMBER)
 200 #endif
 201
 202 /* The isfinite macro is only available with C99, but some non-C99
 203    systems still provide fpclassify, and there is a `finite' function
 204    in BSD.
 205
 206    Also, isfinite is broken on Cygwin.
 207
 208    When isfinite is not available, try to use one of the
 209    alternatives, or bail out.  */
 210
 211 #if defined(HAVE_BROKEN_ISFINITE) || defined(__CYGWIN__)
 212 #undef isfinite
 213 #endif
 214
 215 #if defined(HAVE_BROKEN_ISNAN)
 216 #undef isnan
 217 #endif
 218
 219 #if defined(HAVE_BROKEN_FPCLASSIFY)
 220 #undef fpclassify
 221 #endif
 222
 223 #if !defined(isfinite)
 224 #if !defined(fpclassify)
 225 #define isfinite(x) ((x) - (x) == 0)
 226 #else
 227 #define isfinite(x) (fpclassify(x) != FP_NAN && fpclassify(x) != FP_INFINITE)
 228 #endif /* !defined(fpclassify) */
 229 #endif /* !defined(isfinite)  */
 230
 231 #if !defined(isnan)
 232 #if !defined(fpclassify)
 233 #define isnan(x) ((x) != (x))
 234 #else
 235 #define isnan(x) (fpclassify(x) == FP_NAN)
 236 #endif /* !defined(fpclassify) */
 237 #endif /* !defined(isfinite)  */
 238
 239 /* TODO: find the C99 version of these an move into above ifdef.  */
 240 #define REALPART(z) (__real__(z))
 241 #define IMAGPART(z) (__imag__(z))
 242 #define COMPLEX_ASSIGN(z_, r_, i_) {__real__(z_) = (r_); __imag__(z_) = (i_);}
 243
 244 #include "kinds.h"
 245
 246 /* Define the type used for the current record number for large file I/O.
 247    The size must be consistent with the size defined on the compiler side.  */
 248 #ifdef HAVE_GFC_INTEGER_8
 249 typedef GFC_INTEGER_8 GFC_IO_INT;
 250 #else
 251 #ifdef HAVE_GFC_INTEGER_4
 252 typedef GFC_INTEGER_4 GFC_IO_INT;
 253 #else
 254 #error "GFC_INTEGER_4 should be available for the library to compile".
 255 #endif
 256 #endif
 257
 258 /* The following two definitions must be consistent with the types used
 259    by the compiler.  */
 260 /* The type used of array indices, amongst other things.  */
 261 typedef ssize_t index_type;
 262
 263 /* The type used for the lengths of character variables.  */
 264 typedef GFC_INTEGER_4 gfc_charlen_type;
 265
 266 /* Definitions of CHARACTER data types:
 267      - CHARACTER(KIND=1) corresponds to the C char type,
 268      - CHARACTER(KIND=4) corresponds to an unsigned 32-bit integer.  */
 269 typedef GFC_UINTEGER_4 gfc_char4_t;
 270
 271 /* Byte size of character kinds.  For the kinds currently supported, it's
 272    simply equal to the kind parameter itself.  */
 273 #define GFC_SIZE_OF_CHAR_KIND(kind) (kind)
 274
 275 /* This will be 0 on little-endian machines and one on big-endian machines.  */
 276 extern int big_endian;
 277 internal_proto(big_endian);
 278
 279 #define GFOR_POINTER_TO_L1(p, kind) \
 280   (big_endian * (kind - 1) + (GFC_LOGICAL_1 *)(p))
 281
 282 #define GFC_INTEGER_1_HUGE \
 283   (GFC_INTEGER_1)((((GFC_UINTEGER_1)1) << 7) - 1)
 284 #define GFC_INTEGER_2_HUGE \
 285   (GFC_INTEGER_2)((((GFC_UINTEGER_2)1) << 15) - 1)
 286 #define GFC_INTEGER_4_HUGE \
 287   (GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
 288 #define GFC_INTEGER_8_HUGE \
 289   (GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
 290 #ifdef HAVE_GFC_INTEGER_16
 291 #define GFC_INTEGER_16_HUGE \
 292   (GFC_INTEGER_16)((((GFC_UINTEGER_16)1) << 127) - 1)
 293 #endif
 294
 295
 296 typedef struct descriptor_dimension
 297 {
 298   index_type stride;
 299   index_type lbound;
 300   index_type ubound;
 301 }
 302 descriptor_dimension;
 303
 304 #define GFC_ARRAY_DESCRIPTOR(r, type) \
 305 struct {\
 306   type *data;\
 307   size_t offset;\
 308   index_type dtype;\
 309   descriptor_dimension dim[r];\
 310 }
 311
 312 /* Commonly used array descriptor types.  */
 313 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
 314 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
 315 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_1) gfc_array_i1;
 316 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_2) gfc_array_i2;
 317 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
 318 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
 319 #ifdef HAVE_GFC_INTEGER_16
 320 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_16) gfc_array_i16;
 321 #endif
 322 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
 323 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
 324 #ifdef HAVE_GFC_REAL_10
 325 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_10) gfc_array_r10;
 326 #endif
 327 #ifdef HAVE_GFC_REAL_16
 328 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_16) gfc_array_r16;
 329 #endif
 330 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
 331 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
 332 #ifdef HAVE_GFC_COMPLEX_10
 333 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_10) gfc_array_c10;
 334 #endif
 335 #ifdef HAVE_GFC_COMPLEX_16
 336 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_16) gfc_array_c16;
 337 #endif
 338 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_1) gfc_array_l1;
 339 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_2) gfc_array_l2;
 340 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
 341 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;
 342 #ifdef HAVE_GFC_LOGICAL_16
 343 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_16) gfc_array_l16;
 344 #endif
 345
 346
 347 #define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
 348 #define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
 349                                    >> GFC_DTYPE_TYPE_SHIFT)
 350 #define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
 351 #define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
 352 #define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
 353
 354 /* Macros to get both the size and the type with a single masking operation  */
 355
 356 #define GFC_DTYPE_SIZE_MASK \
 357   ((~((index_type) 0) >> GFC_DTYPE_SIZE_SHIFT) << GFC_DTYPE_SIZE_SHIFT)
 358 #define GFC_DTYPE_TYPE_SIZE_MASK (GFC_DTYPE_SIZE_MASK | GFC_DTYPE_TYPE_MASK)
 359
 360 #define GFC_DTYPE_TYPE_SIZE(desc) ((desc)->dtype & GFC_DTYPE_TYPE_SIZE_MASK)
 361
 362 #define GFC_DTYPE_INTEGER_1 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 363    | (sizeof(GFC_INTEGER_1) << GFC_DTYPE_SIZE_SHIFT))
 364 #define GFC_DTYPE_INTEGER_2 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 365    | (sizeof(GFC_INTEGER_2) << GFC_DTYPE_SIZE_SHIFT))
 366 #define GFC_DTYPE_INTEGER_4 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 367    | (sizeof(GFC_INTEGER_4) << GFC_DTYPE_SIZE_SHIFT))
 368 #define GFC_DTYPE_INTEGER_8 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 369    | (sizeof(GFC_INTEGER_8) << GFC_DTYPE_SIZE_SHIFT))
 370 #ifdef HAVE_GFC_INTEGER_16
 371 #define GFC_DTYPE_INTEGER_16 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 372    | (sizeof(GFC_INTEGER_16) << GFC_DTYPE_SIZE_SHIFT))
 373 #endif
 374
 375 #define GFC_DTYPE_LOGICAL_1 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 376    | (sizeof(GFC_LOGICAL_1) << GFC_DTYPE_SIZE_SHIFT))
 377 #define GFC_DTYPE_LOGICAL_2 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 378    | (sizeof(GFC_LOGICAL_2) << GFC_DTYPE_SIZE_SHIFT))
 379 #define GFC_DTYPE_LOGICAL_4 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 380    | (sizeof(GFC_LOGICAL_4) << GFC_DTYPE_SIZE_SHIFT))
 381 #define GFC_DTYPE_LOGICAL_8 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 382    | (sizeof(GFC_LOGICAL_8) << GFC_DTYPE_SIZE_SHIFT))
 383 #ifdef HAVE_GFC_LOGICAL_16
 384 #define GFC_DTYPE_LOGICAL_16 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 385    | (sizeof(GFC_LOGICAL_16) << GFC_DTYPE_SIZE_SHIFT))
 386 #endif
 387
 388 #define GFC_DTYPE_REAL_4 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 389    | (sizeof(GFC_REAL_4) << GFC_DTYPE_SIZE_SHIFT))
 390 #define GFC_DTYPE_REAL_8 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 391    | (sizeof(GFC_REAL_8) << GFC_DTYPE_SIZE_SHIFT))
 392 #ifdef HAVE_GFC_REAL_10
 393 #define GFC_DTYPE_REAL_10  ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 394    | (sizeof(GFC_REAL_10) << GFC_DTYPE_SIZE_SHIFT))
 395 #endif
 396 #ifdef HAVE_GFC_REAL_16
 397 #define GFC_DTYPE_REAL_16 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 398    | (sizeof(GFC_REAL_16) << GFC_DTYPE_SIZE_SHIFT))
 399 #endif
 400
 401 #define GFC_DTYPE_COMPLEX_4 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 402    | (sizeof(GFC_COMPLEX_4) << GFC_DTYPE_SIZE_SHIFT))
 403 #define GFC_DTYPE_COMPLEX_8 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 404    | (sizeof(GFC_COMPLEX_8) << GFC_DTYPE_SIZE_SHIFT))
 405 #ifdef HAVE_GFC_COMPLEX_10
 406 #define GFC_DTYPE_COMPLEX_10 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 407    | (sizeof(GFC_COMPLEX_10) << GFC_DTYPE_SIZE_SHIFT))
 408 #endif
 409 #ifdef HAVE_GFC_COMPLEX_16
 410 #define GFC_DTYPE_COMPLEX_16 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 411    | (sizeof(GFC_COMPLEX_16) << GFC_DTYPE_SIZE_SHIFT))
 412 #endif
 413
 414 #define GFC_DTYPE_DERIVED_1 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 415    | (sizeof(GFC_INTEGER_1) << GFC_DTYPE_SIZE_SHIFT))
 416 #define GFC_DTYPE_DERIVED_2 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 417    | (sizeof(GFC_INTEGER_2) << GFC_DTYPE_SIZE_SHIFT))
 418 #define GFC_DTYPE_DERIVED_4 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 419    | (sizeof(GFC_INTEGER_4) << GFC_DTYPE_SIZE_SHIFT))
 420 #define GFC_DTYPE_DERIVED_8 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 421    | (sizeof(GFC_INTEGER_8) << GFC_DTYPE_SIZE_SHIFT))
 422 #ifdef HAVE_GFC_INTEGER_16
 423 #define GFC_DTYPE_DERIVED_16 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 424    | (sizeof(GFC_INTEGER_16) << GFC_DTYPE_SIZE_SHIFT))
 425 #endif
 426
 427 /* Macros to determine the alignment of pointers.  */
 428
 429 #define GFC_UNALIGNED_2(x) (((uintptr_t)(x)) & \
 430                             (__alignof__(GFC_INTEGER_2) - 1))
 431 #define GFC_UNALIGNED_4(x) (((uintptr_t)(x)) & \
 432                             (__alignof__(GFC_INTEGER_4) - 1))
 433 #define GFC_UNALIGNED_8(x) (((uintptr_t)(x)) & \
 434                             (__alignof__(GFC_INTEGER_8) - 1))
 435 #ifdef HAVE_GFC_INTEGER_16
 436 #define GFC_UNALIGNED_16(x) (((uintptr_t)(x)) & \
 437                              (__alignof__(GFC_INTEGER_16) - 1))
 438 #endif
 439
 440 /* Runtime library include.  */
 441 #define stringize(x) expand_macro(x)
 442 #define expand_macro(x) # x
 443
 444 /* Runtime options structure.  */
 445
 446 typedef struct
 447 {
 448   int stdin_unit, stdout_unit, stderr_unit, optional_plus;
 449   int locus;
 450
 451   int separator_len;
 452   const char *separator;
 453
 454   int use_stderr, all_unbuffered, unbuffered_preconnected, default_recl;
 455   int fpe, dump_core, backtrace;
 456 }
 457 options_t;
 458
 459 extern options_t options;
 460 internal_proto(options);
 461
 462 extern void handler (int);
 463 internal_proto(handler);
 464
 465
 466 /* Compile-time options that will influence the library.  */
 467
 468 typedef struct
 469 {
 470   int warn_std;
 471   int allow_std;
 472   int pedantic;
 473   int convert;
 474   int dump_core;
 475   int backtrace;
 476   int sign_zero;
 477   size_t record_marker;
 478   int max_subrecord_length;
 479   int bounds_check;
 480   int range_check;
 481 }
 482 compile_options_t;
 483
 484 extern compile_options_t compile_options;
 485 internal_proto(compile_options);
 486
 487 extern void init_compile_options (void);
 488 internal_proto(init_compile_options);
 489
 490 #define GFC_MAX_SUBRECORD_LENGTH 2147483639   /* 2**31 - 9 */
 491
 492 /* Structure for statement options.  */
 493
 494 typedef struct
 495 {
 496   const char *name;
 497   int value;
 498 }
 499 st_option;
 500
 501
 502 /* This is returned by notification_std to know if, given the flags
 503    that were given (-std=, -pedantic) we should issue an error, a warning
 504    or nothing.  */
 505 typedef enum
 506 { SILENT, WARNING, ERROR }
 507 notification;
 508
 509 /* This is returned by notify_std and several io functions.  */
 510 typedef enum
 511 { SUCCESS = 1, FAILURE }
 512 try;
 513
 514 /* The filename and line number don't go inside the globals structure.
 515    They are set by the rest of the program and must be linked to.  */
 516
 517 /* Location of the current library call (optional).  */
 518 extern unsigned line;
 519 iexport_data_proto(line);
 520
 521 extern char *filename;
 522 iexport_data_proto(filename);
 523
 524 /* Avoid conflicting prototypes of alloca() in system headers by using
 525    GCC's builtin alloca().  */
 526 #define gfc_alloca(x)  __builtin_alloca(x)
 527
 528
 529 /* Directory for creating temporary files.  Only used when none of the
 530    following environment variables exist: GFORTRAN_TMPDIR, TMP and TEMP.  */
 531 #define DEFAULT_TEMPDIR "/tmp"
 532
 533 /* The default value of record length for preconnected units is defined
 534    here. This value can be overriden by an environment variable.
 535    Default value is 1 Gb.  */
 536 #define DEFAULT_RECL 1073741824
 537
 538
 539 #define CHARACTER2(name) \
 540               gfc_charlen_type name ## _len; \
 541               char * name
 542
 543 typedef struct st_parameter_common
 544 {
 545   GFC_INTEGER_4 flags;
 546   GFC_INTEGER_4 unit;
 547   const char *filename;
 548   GFC_INTEGER_4 line;
 549   CHARACTER2 (iomsg);
 550   GFC_INTEGER_4 *iostat;
 551 }
 552 st_parameter_common;
 553
 554 #undef CHARACTER2
 555
 556 #define IOPARM_LIBRETURN_MASK           (3 << 0)
 557 #define IOPARM_LIBRETURN_OK             (0 << 0)
 558 #define IOPARM_LIBRETURN_ERROR          (1 << 0)
 559 #define IOPARM_LIBRETURN_END            (2 << 0)
 560 #define IOPARM_LIBRETURN_EOR            (3 << 0)
 561 #define IOPARM_ERR                      (1 << 2)
 562 #define IOPARM_END                      (1 << 3)
 563 #define IOPARM_EOR                      (1 << 4)
 564 #define IOPARM_HAS_IOSTAT               (1 << 5)
 565 #define IOPARM_HAS_IOMSG                (1 << 6)
 566
 567 #define IOPARM_COMMON_MASK              ((1 << 7) - 1)
 568
 569 #define IOPARM_OPEN_HAS_RECL_IN         (1 << 7)
 570 #define IOPARM_OPEN_HAS_FILE            (1 << 8)
 571 #define IOPARM_OPEN_HAS_STATUS          (1 << 9)
 572 #define IOPARM_OPEN_HAS_ACCESS          (1 << 10)
 573 #define IOPARM_OPEN_HAS_FORM            (1 << 11)
 574 #define IOPARM_OPEN_HAS_BLANK           (1 << 12)
 575 #define IOPARM_OPEN_HAS_POSITION        (1 << 13)
 576 #define IOPARM_OPEN_HAS_ACTION          (1 << 14)
 577 #define IOPARM_OPEN_HAS_DELIM           (1 << 15)
 578 #define IOPARM_OPEN_HAS_PAD             (1 << 16)
 579 #define IOPARM_OPEN_HAS_CONVERT         (1 << 17)
 580 #define IOPARM_OPEN_HAS_DECIMAL         (1 << 18)
 581 #define IOPARM_OPEN_HAS_ENCODING        (1 << 19)
 582 #define IOPARM_OPEN_HAS_ROUND           (1 << 20)
 583 #define IOPARM_OPEN_HAS_SIGN            (1 << 21)
 584 #define IOPARM_OPEN_HAS_ASYNCHRONOUS    (1 << 22)
 585
 586 /* library start function and end macro.  These can be expanded if needed
 587    in the future.  cmp is st_parameter_common *cmp  */
 588
 589 extern void library_start (st_parameter_common *);
 590 internal_proto(library_start);
 591
 592 #define library_end()
 593
 594 /* main.c */
 595
 596 extern void stupid_function_name_for_static_linking (void);
 597 internal_proto(stupid_function_name_for_static_linking);
 598
 599 extern void set_args (int, char **);
 600 export_proto(set_args);
 601
 602 extern void get_args (int *, char ***);
 603 internal_proto(get_args);
 604
 605 extern void store_exe_path (const char *);
 606 export_proto(store_exe_path);
 607
 608 extern char * full_exe_path (void);
 609 internal_proto(full_exe_path);
 610
 611 /* backtrace.c */
 612
 613 extern void show_backtrace (void);
 614 internal_proto(show_backtrace);
 615
 616 /* error.c */
 617
 618 #define GFC_ITOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 2)
 619 #define GFC_XTOA_BUF_SIZE (sizeof (GFC_UINTEGER_LARGEST) * 2 + 1)
 620 #define GFC_OTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 3 + 1)
 621 #define GFC_BTOA_BUF_SIZE (sizeof (GFC_INTEGER_LARGEST) * 8 + 1)
 622
 623 extern void sys_exit (int) __attribute__ ((noreturn));
 624 internal_proto(sys_exit);
 625
 626 extern const char *gfc_itoa (GFC_INTEGER_LARGEST, char *, size_t);
 627 internal_proto(gfc_itoa);
 628
 629 extern const char *xtoa (GFC_UINTEGER_LARGEST, char *, size_t);
 630 internal_proto(xtoa);
 631
 632 extern void os_error (const char *) __attribute__ ((noreturn));
 633 iexport_proto(os_error);
 634
 635 extern void show_locus (st_parameter_common *);
 636 internal_proto(show_locus);
 637
 638 extern void runtime_error (const char *, ...)
 639      __attribute__ ((noreturn, format (printf, 1, 2)));
 640 iexport_proto(runtime_error);
 641
 642 extern void runtime_error_at (const char *, const char *, ...)
 643      __attribute__ ((noreturn, format (printf, 2, 3)));
 644 iexport_proto(runtime_error_at);
 645
 646 extern void runtime_warning_at (const char *, const char *, ...);
 647 iexport_proto(runtime_warning_at);
 648
 649 extern void internal_error (st_parameter_common *, const char *)
 650   __attribute__ ((noreturn));
 651 internal_proto(internal_error);
 652
 653 extern const char *get_oserror (void);
 654 internal_proto(get_oserror);
 655
 656 extern const char *translate_error (int);
 657 internal_proto(translate_error);
 658
 659 extern void generate_error (st_parameter_common *, int, const char *);
 660 iexport_proto(generate_error);
 661
 662 extern try notify_std (st_parameter_common *, int, const char *);
 663 internal_proto(notify_std);
 664
 665 extern notification notification_std(int);
 666 internal_proto(notification_std);
 667
 668 /* fpu.c */
 669
 670 extern void set_fpu (void);
 671 internal_proto(set_fpu);
 672
 673 /* memory.c */
 674
 675 extern void *get_mem (size_t) __attribute__ ((malloc));
 676 internal_proto(get_mem);
 677
 678 extern void free_mem (void *);
 679 internal_proto(free_mem);
 680
 681 extern void *internal_malloc_size (size_t) __attribute__ ((malloc));
 682 internal_proto(internal_malloc_size);
 683
 684 /* environ.c */
 685
 686 extern int check_buffered (int);
 687 internal_proto(check_buffered);
 688
 689 extern void init_variables (void);
 690 internal_proto(init_variables);
 691
 692 extern void show_variables (void);
 693 internal_proto(show_variables);
 694
 695 unit_convert get_unformatted_convert (int);
 696 internal_proto(get_unformatted_convert);
 697
 698 /* string.c */
 699
 700 extern int find_option (st_parameter_common *, const char *, gfc_charlen_type,
 701                         const st_option *, const char *);
 702 internal_proto(find_option);
 703
 704 extern gfc_charlen_type fstrlen (const char *, gfc_charlen_type);
 705 internal_proto(fstrlen);
 706
 707 extern gfc_charlen_type fstrcpy (char *, gfc_charlen_type, const char *, gfc_charlen_type);
 708 internal_proto(fstrcpy);
 709
 710 extern gfc_charlen_type cf_strcpy (char *, gfc_charlen_type, const char *);
 711 internal_proto(cf_strcpy);
 712
 713 /* io/intrinsics.c */
 714
 715 extern void flush_all_units (void);
 716 internal_proto(flush_all_units);
 717
 718 /* io.c */
 719
 720 extern void init_units (void);
 721 internal_proto(init_units);
 722
 723 extern void close_units (void);
 724 internal_proto(close_units);
 725
 726 extern int unit_to_fd (int);
 727 internal_proto(unit_to_fd);
 728
 729 extern int st_printf (const char *, ...)
 730   __attribute__ ((format (printf, 1, 2)));
 731 internal_proto(st_printf);
 732
 733 extern int st_vprintf (const char *, va_list);
 734 internal_proto(st_vprintf);
 735
 736 extern char * filename_from_unit (int);
 737 internal_proto(filename_from_unit);
 738
 739 /* stop.c */
 740
 741 extern void stop_numeric (GFC_INTEGER_4) __attribute__ ((noreturn));
 742 iexport_proto(stop_numeric);
 743
 744 /* reshape_packed.c */
 745
 746 extern void reshape_packed (char *, index_type, const char *, index_type,
 747                             const char *, index_type);
 748 internal_proto(reshape_packed);
 749
 750 /* Repacking functions.  These are called internally by internal_pack
 751    and internal_unpack.  */
 752
 753 GFC_INTEGER_1 *internal_pack_1 (gfc_array_i1 *);
 754 internal_proto(internal_pack_1);
 755
 756 GFC_INTEGER_2 *internal_pack_2 (gfc_array_i2 *);
 757 internal_proto(internal_pack_2);
 758
 759 GFC_INTEGER_4 *internal_pack_4 (gfc_array_i4 *);
 760 internal_proto(internal_pack_4);
 761
 762 GFC_INTEGER_8 *internal_pack_8 (gfc_array_i8 *);
 763 internal_proto(internal_pack_8);
 764
 765 #if defined HAVE_GFC_INTEGER_16
 766 GFC_INTEGER_16 *internal_pack_16 (gfc_array_i16 *);
 767 internal_proto(internal_pack_16);
 768 #endif
 769
 770 GFC_REAL_4 *internal_pack_r4 (gfc_array_r4 *);
 771 internal_proto(internal_pack_r4);
 772
 773 GFC_REAL_8 *internal_pack_r8 (gfc_array_r8 *);
 774 internal_proto(internal_pack_r8);
 775
 776 #if defined HAVE_GFC_REAL_10
 777 GFC_REAL_10 *internal_pack_r10 (gfc_array_r10 *);
 778 internal_proto(internal_pack_r10);
 779 #endif
 780
 781 #if defined HAVE_GFC_REAL_16
 782 GFC_REAL_16 *internal_pack_r16 (gfc_array_r16 *);
 783 internal_proto(internal_pack_r16);
 784 #endif
 785
 786 GFC_COMPLEX_4 *internal_pack_c4 (gfc_array_c4 *);
 787 internal_proto(internal_pack_c4);
 788
 789 GFC_COMPLEX_8 *internal_pack_c8 (gfc_array_c8 *);
 790 internal_proto(internal_pack_c8);
 791
 792 #if defined HAVE_GFC_COMPLEX_10
 793 GFC_COMPLEX_10 *internal_pack_c10 (gfc_array_c10 *);
 794 internal_proto(internal_pack_c10);
 795 #endif
 796
 797 #if defined HAVE_GFC_COMPLEX_16
 798 GFC_COMPLEX_16 *internal_pack_c16 (gfc_array_c16 *);
 799 internal_proto(internal_pack_c16);
 800 #endif
 801
 802 extern void internal_unpack_1 (gfc_array_i1 *, const GFC_INTEGER_1 *);
 803 internal_proto(internal_unpack_1);
 804
 805 extern void internal_unpack_2 (gfc_array_i2 *, const GFC_INTEGER_2 *);
 806 internal_proto(internal_unpack_2);
 807
 808 extern void internal_unpack_4 (gfc_array_i4 *, const GFC_INTEGER_4 *);
 809 internal_proto(internal_unpack_4);
 810
 811 extern void internal_unpack_8 (gfc_array_i8 *, const GFC_INTEGER_8 *);
 812 internal_proto(internal_unpack_8);
 813
 814 #if defined HAVE_GFC_INTEGER_16
 815 extern void internal_unpack_16 (gfc_array_i16 *, const GFC_INTEGER_16 *);
 816 internal_proto(internal_unpack_16);
 817 #endif
 818
 819 extern void internal_unpack_r4 (gfc_array_r4 *, const GFC_REAL_4 *);
 820 internal_proto(internal_unpack_r4);
 821
 822 extern void internal_unpack_r8 (gfc_array_r8 *, const GFC_REAL_8 *);
 823 internal_proto(internal_unpack_r8);
 824
 825 #if defined HAVE_GFC_REAL_10
 826 extern void internal_unpack_r10 (gfc_array_r10 *, const GFC_REAL_10 *);
 827 internal_proto(internal_unpack_r10);
 828 #endif
 829
 830 #if defined HAVE_GFC_REAL_16
 831 extern void internal_unpack_r16 (gfc_array_r16 *, const GFC_REAL_16 *);
 832 internal_proto(internal_unpack_r16);
 833 #endif
 834
 835 extern void internal_unpack_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *);
 836 internal_proto(internal_unpack_c4);
 837
 838 extern void internal_unpack_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *);
 839 internal_proto(internal_unpack_c8);
 840
 841 #if defined HAVE_GFC_COMPLEX_10
 842 extern void internal_unpack_c10 (gfc_array_c10 *, const GFC_COMPLEX_10 *);
 843 internal_proto(internal_unpack_c10);
 844 #endif
 845
 846 #if defined HAVE_GFC_COMPLEX_16
 847 extern void internal_unpack_c16 (gfc_array_c16 *, const GFC_COMPLEX_16 *);
 848 internal_proto(internal_unpack_c16);
 849 #endif
 850
 851 /* Internal auxiliary functions for the pack intrinsic.  */
 852
 853 extern void pack_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 854                      const gfc_array_l1 *, const gfc_array_i1 *);
 855 internal_proto(pack_i1);
 856
 857 extern void pack_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 858                      const gfc_array_l1 *, const gfc_array_i2 *);
 859 internal_proto(pack_i2);
 860
 861 extern void pack_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 862                      const gfc_array_l1 *, const gfc_array_i4 *);
 863 internal_proto(pack_i4);
 864
 865 extern void pack_i8 (gfc_array_i8 *, const gfc_array_i8 *,
 866                      const gfc_array_l1 *, const gfc_array_i8 *);
 867 internal_proto(pack_i8);
 868
 869 #ifdef HAVE_GFC_INTEGER_16
 870 extern void pack_i16 (gfc_array_i16 *, const gfc_array_i16 *,
 871                      const gfc_array_l1 *, const gfc_array_i16 *);
 872 internal_proto(pack_i16);
 873 #endif
 874
 875 extern void pack_r4 (gfc_array_r4 *, const gfc_array_r4 *,
 876                      const gfc_array_l1 *, const gfc_array_r4 *);
 877 internal_proto(pack_r4);
 878
 879 extern void pack_r8 (gfc_array_r8 *, const gfc_array_r8 *,
 880                      const gfc_array_l1 *, const gfc_array_r8 *);
 881 internal_proto(pack_r8);
 882
 883 #ifdef HAVE_GFC_REAL_10
 884 extern void pack_r10 (gfc_array_r10 *, const gfc_array_r10 *,
 885                      const gfc_array_l1 *, const gfc_array_r10 *);
 886 internal_proto(pack_r10);
 887 #endif
 888
 889 #ifdef HAVE_GFC_REAL_16
 890 extern void pack_r16 (gfc_array_r16 *, const gfc_array_r16 *,
 891                      const gfc_array_l1 *, const gfc_array_r16 *);
 892 internal_proto(pack_r16);
 893 #endif
 894
 895 extern void pack_c4 (gfc_array_c4 *, const gfc_array_c4 *,
 896                      const gfc_array_l1 *, const gfc_array_c4 *);
 897 internal_proto(pack_c4);
 898
 899 extern void pack_c8 (gfc_array_c8 *, const gfc_array_c8 *,
 900                      const gfc_array_l1 *, const gfc_array_c8 *);
 901 internal_proto(pack_c8);
 902
 903 #ifdef HAVE_GFC_REAL_10
 904 extern void pack_c10 (gfc_array_c10 *, const gfc_array_c10 *,
 905                      const gfc_array_l1 *, const gfc_array_c10 *);
 906 internal_proto(pack_c10);
 907 #endif
 908
 909 #ifdef HAVE_GFC_REAL_16
 910 extern void pack_c16 (gfc_array_c16 *, const gfc_array_c16 *,
 911                      const gfc_array_l1 *, const gfc_array_c16 *);
 912 internal_proto(pack_c16);
 913 #endif
 914
 915 /* Internal auxiliary functions for the unpack intrinsic.  */
 916
 917 extern void unpack0_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 918                         const gfc_array_l1 *, const GFC_INTEGER_1 *);
 919 internal_proto(unpack0_i1);
 920
 921 extern void unpack0_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 922                         const gfc_array_l1 *, const GFC_INTEGER_2 *);
 923 internal_proto(unpack0_i2);
 924
 925 extern void unpack0_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 926                         const gfc_array_l1 *, const GFC_INTEGER_4 *);
 927 internal_proto(unpack0_i4);
 928
 929 extern void unpack0_i8 (gfc_array_i8 *, const gfc_array_i8 *,
 930                         const gfc_array_l1 *, const GFC_INTEGER_8 *);
 931 internal_proto(unpack0_i8);
 932
 933 #ifdef HAVE_GFC_INTEGER_16
 934
 935 extern void unpack0_i16 (gfc_array_i16 *, const gfc_array_i16 *,
 936                          const gfc_array_l1 *, const GFC_INTEGER_16 *);
 937 internal_proto(unpack0_i16);
 938
 939 #endif
 940
 941 extern void unpack0_r4 (gfc_array_r4 *, const gfc_array_r4 *,
 942                         const gfc_array_l1 *, const GFC_REAL_4 *);
 943 internal_proto(unpack0_r4);
 944
 945 extern void unpack0_r8 (gfc_array_r8 *, const gfc_array_r8 *,
 946                         const gfc_array_l1 *, const GFC_REAL_8 *);
 947 internal_proto(unpack0_r8);
 948
 949 #ifdef HAVE_GFC_REAL_10
 950
 951 extern void unpack0_r10 (gfc_array_r10 *, const gfc_array_r10 *,
 952                          const gfc_array_l1 *, const GFC_REAL_10 *);
 953 internal_proto(unpack0_r10);
 954
 955 #endif
 956
 957 #ifdef HAVE_GFC_REAL_16
 958
 959 extern void unpack0_r16 (gfc_array_r16 *, const gfc_array_r16 *,
 960                          const gfc_array_l1 *, const GFC_REAL_16 *);
 961 internal_proto(unpack0_r16);
 962
 963 #endif
 964
 965 extern void unpack0_c4 (gfc_array_c4 *, const gfc_array_c4 *,
 966                         const gfc_array_l1 *, const GFC_COMPLEX_4 *);
 967 internal_proto(unpack0_c4);
 968
 969 extern void unpack0_c8 (gfc_array_c8 *, const gfc_array_c8 *,
 970                         const gfc_array_l1 *, const GFC_COMPLEX_8 *);
 971 internal_proto(unpack0_c8);
 972
 973 #ifdef HAVE_GFC_COMPLEX_10
 974
 975 extern void unpack0_c10 (gfc_array_c10 *, const gfc_array_c10 *,
 976                          const gfc_array_l1 *mask, const GFC_COMPLEX_10 *);
 977 internal_proto(unpack0_c10);
 978
 979 #endif
 980
 981 #ifdef HAVE_GFC_COMPLEX_16
 982
 983 extern void unpack0_c16 (gfc_array_c16 *, const gfc_array_c16 *,
 984                          const gfc_array_l1 *, const GFC_COMPLEX_16 *);
 985 internal_proto(unpack0_c16);
 986
 987 #endif
 988
 989 extern void unpack1_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 990                         const gfc_array_l1 *, const gfc_array_i1 *);
 991 internal_proto(unpack1_i1);
 992
 993 extern void unpack1_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 994                         const gfc_array_l1 *, const gfc_array_i2 *);
 995 internal_proto(unpack1_i2);
 996
 997 extern void unpack1_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 998                         const gfc_array_l1 *, const gfc_array_i4 *);
 999 internal_proto(unpack1_i4);
1000
1001 extern void unpack1_i8 (gfc_array_i8 *, const gfc_array_i8 *,
1002                         const gfc_array_l1 *, const gfc_array_i8 *);
1003 internal_proto(unpack1_i8);
1004
1005 #ifdef HAVE_GFC_INTEGER_16
1006 extern void unpack1_i16 (gfc_array_i16 *, const gfc_array_i16 *,
1007                          const gfc_array_l1 *, const gfc_array_i16 *);
1008 internal_proto(unpack1_i16);
1009 #endif
1010
1011 extern void unpack1_r4 (gfc_array_r4 *, const gfc_array_r4 *,
1012                         const gfc_array_l1 *, const gfc_array_r4 *);
1013 internal_proto(unpack1_r4);
1014
1015 extern void unpack1_r8 (gfc_array_r8 *, const gfc_array_r8 *,
1016                         const gfc_array_l1 *, const gfc_array_r8 *);
1017 internal_proto(unpack1_r8);
1018
1019 #ifdef HAVE_GFC_REAL_10
1020 extern void unpack1_r10 (gfc_array_r10 *, const gfc_array_r10 *,
1021                          const gfc_array_l1 *, const gfc_array_r10 *);
1022 internal_proto(unpack1_r10);
1023 #endif
1024
1025 #ifdef HAVE_GFC_REAL_16
1026 extern void unpack1_r16 (gfc_array_r16 *, const gfc_array_r16 *,
1027                          const gfc_array_l1 *, const gfc_array_r16 *);
1028 internal_proto(unpack1_r16);
1029 #endif
1030
1031 extern void unpack1_c4 (gfc_array_c4 *, const gfc_array_c4 *,
1032                         const gfc_array_l1 *, const gfc_array_c4 *);
1033 internal_proto(unpack1_c4);
1034
1035 extern void unpack1_c8 (gfc_array_c8 *, const gfc_array_c8 *,
1036                         const gfc_array_l1 *, const gfc_array_c8 *);
1037 internal_proto(unpack1_c8);
1038
1039 #ifdef HAVE_GFC_COMPLEX_10
1040 extern void unpack1_c10 (gfc_array_c10 *, const gfc_array_c10 *,
1041                          const gfc_array_l1 *, const gfc_array_c10 *);
1042 internal_proto(unpack1_c10);
1043 #endif
1044
1045 #ifdef HAVE_GFC_COMPLEX_16
1046 extern void unpack1_c16 (gfc_array_c16 *, const gfc_array_c16 *,
1047                          const gfc_array_l1 *, const gfc_array_c16 *);
1048 internal_proto(unpack1_c16);
1049 #endif
1050
1051 /* Helper functions for spread.  */
1052
1053 extern void spread_i1 (gfc_array_i1 *, const gfc_array_i1 *,
1054                        const index_type, const index_type);
1055 internal_proto(spread_i1);
1056
1057 extern void spread_i2 (gfc_array_i2 *, const gfc_array_i2 *,
1058                        const index_type, const index_type);
1059 internal_proto(spread_i2);
1060
1061 extern void spread_i4 (gfc_array_i4 *, const gfc_array_i4 *,
1062                        const index_type, const index_type);
1063 internal_proto(spread_i4);
1064
1065 extern void spread_i8 (gfc_array_i8 *, const gfc_array_i8 *,
1066                        const index_type, const index_type);
1067 internal_proto(spread_i8);
1068
1069 #ifdef HAVE_GFC_INTEGER_16
1070 extern void spread_i16 (gfc_array_i16 *, const gfc_array_i16 *,
1071                        const index_type, const index_type);
1072 internal_proto(spread_i16);
1073
1074 #endif
1075
1076 extern void spread_r4 (gfc_array_r4 *, const gfc_array_r4 *,
1077                        const index_type, const index_type);
1078 internal_proto(spread_r4);
1079
1080 extern void spread_r8 (gfc_array_r8 *, const gfc_array_r8 *,
1081                        const index_type, const index_type);
1082 internal_proto(spread_r8);
1083
1084 #ifdef HAVE_GFC_REAL_10
1085 extern void spread_r10 (gfc_array_r10 *, const gfc_array_r10 *,
1086                        const index_type, const index_type);
1087 internal_proto(spread_r10);
1088
1089 #endif
1090
1091 #ifdef HAVE_GFC_REAL_16
1092 extern void spread_r16 (gfc_array_r16 *, const gfc_array_r16 *,
1093                        const index_type, const index_type);
1094 internal_proto(spread_r16);
1095
1096 #endif
1097
1098 extern void spread_c4 (gfc_array_c4 *, const gfc_array_c4 *,
1099                        const index_type, const index_type);
1100 internal_proto(spread_c4);
1101
1102 extern void spread_c8 (gfc_array_c8 *, const gfc_array_c8 *,
1103                        const index_type, const index_type);
1104 internal_proto(spread_c8);
1105
1106 #ifdef HAVE_GFC_COMPLEX_10
1107 extern void spread_c10 (gfc_array_c10 *, const gfc_array_c10 *,
1108                        const index_type, const index_type);
1109 internal_proto(spread_c10);
1110
1111 #endif
1112
1113 #ifdef HAVE_GFC_COMPLEX_16
1114 extern void spread_c16 (gfc_array_c16 *, const gfc_array_c16 *,
1115                        const index_type, const index_type);
1116 internal_proto(spread_c16);
1117
1118 #endif
1119
1120 extern void spread_scalar_i1 (gfc_array_i1 *, const GFC_INTEGER_1 *,
1121                               const index_type, const index_type);
1122 internal_proto(spread_scalar_i1);
1123
1124 extern void spread_scalar_i2 (gfc_array_i2 *, const GFC_INTEGER_2 *,
1125                               const index_type, const index_type);
1126 internal_proto(spread_scalar_i2);
1127
1128 extern void spread_scalar_i4 (gfc_array_i4 *, const GFC_INTEGER_4 *,
1129                               const index_type, const index_type);
1130 internal_proto(spread_scalar_i4);
1131
1132 extern void spread_scalar_i8 (gfc_array_i8 *, const GFC_INTEGER_8 *,
1133                               const index_type, const index_type);
1134 internal_proto(spread_scalar_i8);
1135
1136 #ifdef HAVE_GFC_INTEGER_16
1137 extern void spread_scalar_i16 (gfc_array_i16 *, const GFC_INTEGER_16 *,
1138                                const index_type, const index_type);
1139 internal_proto(spread_scalar_i16);
1140
1141 #endif
1142
1143 extern void spread_scalar_r4 (gfc_array_r4 *, const GFC_REAL_4 *,
1144                               const index_type, const index_type);
1145 internal_proto(spread_scalar_r4);
1146
1147 extern void spread_scalar_r8 (gfc_array_r8 *, const GFC_REAL_8 *,
1148                               const index_type, const index_type);
1149 internal_proto(spread_scalar_r8);
1150
1151 #ifdef HAVE_GFC_REAL_10
1152 extern void spread_scalar_r10 (gfc_array_r10 *, const GFC_REAL_10 *,
1153                                const index_type, const index_type);
1154 internal_proto(spread_scalar_r10);
1155
1156 #endif
1157
1158 #ifdef HAVE_GFC_REAL_16
1159 extern void spread_scalar_r16 (gfc_array_r16 *, const GFC_REAL_16 *,
1160                                const index_type, const index_type);
1161 internal_proto(spread_scalar_r16);
1162
1163 #endif
1164
1165 extern void spread_scalar_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *,
1166                               const index_type, const index_type);
1167 internal_proto(spread_scalar_c4);
1168
1169 extern void spread_scalar_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *,
1170                               const index_type, const index_type);
1171 internal_proto(spread_scalar_c8);
1172
1173 #ifdef HAVE_GFC_COMPLEX_10
1174 extern void spread_scalar_c10 (gfc_array_c10 *, const GFC_COMPLEX_10 *,
1175                                const index_type, const index_type);
1176 internal_proto(spread_scalar_c10);
1177
1178 #endif
1179
1180 #ifdef HAVE_GFC_COMPLEX_16
1181 extern void spread_scalar_c16 (gfc_array_c16 *, const GFC_COMPLEX_16 *,
1182                                const index_type, const index_type);
1183 internal_proto(spread_scalar_c16);
1184
1185 #endif
1186
1187 /* string_intrinsics.c */
1188
1189 extern int compare_string (gfc_charlen_type, const char *,
1190                            gfc_charlen_type, const char *);
1191 iexport_proto(compare_string);
1192
1193 extern int compare_string_char4 (gfc_charlen_type, const gfc_char4_t *,
1194                                  gfc_charlen_type, const gfc_char4_t *);
1195 iexport_proto(compare_string_char4);
1196
1197 /* random.c */
1198
1199 extern void random_seed_i4 (GFC_INTEGER_4 * size, gfc_array_i4 * put,
1200                             gfc_array_i4 * get);
1201 iexport_proto(random_seed_i4);
1202 extern void random_seed_i8 (GFC_INTEGER_8 * size, gfc_array_i8 * put,
1203                             gfc_array_i8 * get);
1204 iexport_proto(random_seed_i8);
1205
1206 /* size.c */
1207
1208 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
1209
1210 extern index_type size0 (const array_t * array);
1211 iexport_proto(size0);
1212
1213 #endif  /* LIBGFOR_H  */