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
 276 /* This will be 0 on little-endian machines and one on big-endian machines.  */
 277 extern int l8_to_l4_offset;
 278 internal_proto(l8_to_l4_offset);
 279
 280 #define GFOR_POINTER_TO_L1(p, kind) \
 281   (l8_to_l4_offset * (kind - 1) + (GFC_LOGICAL_1 *)(p))
 282
 283 #define GFC_INTEGER_1_HUGE \
 284   (GFC_INTEGER_1)((((GFC_UINTEGER_1)1) << 7) - 1)
 285 #define GFC_INTEGER_2_HUGE \
 286   (GFC_INTEGER_2)((((GFC_UINTEGER_2)1) << 15) - 1)
 287 #define GFC_INTEGER_4_HUGE \
 288   (GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
 289 #define GFC_INTEGER_8_HUGE \
 290   (GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
 291 #ifdef HAVE_GFC_INTEGER_16
 292 #define GFC_INTEGER_16_HUGE \
 293   (GFC_INTEGER_16)((((GFC_UINTEGER_16)1) << 127) - 1)
 294 #endif
 295
 296
 297 typedef struct descriptor_dimension
 298 {
 299   index_type stride;
 300   index_type lbound;
 301   index_type ubound;
 302 }
 303 descriptor_dimension;
 304
 305 #define GFC_ARRAY_DESCRIPTOR(r, type) \
 306 struct {\
 307   type *data;\
 308   size_t offset;\
 309   index_type dtype;\
 310   descriptor_dimension dim[r];\
 311 }
 312
 313 /* Commonly used array descriptor types.  */
 314 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
 315 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
 316 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_1) gfc_array_i1;
 317 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_2) gfc_array_i2;
 318 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
 319 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
 320 #ifdef HAVE_GFC_INTEGER_16
 321 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_16) gfc_array_i16;
 322 #endif
 323 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
 324 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
 325 #ifdef HAVE_GFC_REAL_10
 326 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_10) gfc_array_r10;
 327 #endif
 328 #ifdef HAVE_GFC_REAL_16
 329 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_16) gfc_array_r16;
 330 #endif
 331 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
 332 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
 333 #ifdef HAVE_GFC_COMPLEX_10
 334 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_10) gfc_array_c10;
 335 #endif
 336 #ifdef HAVE_GFC_COMPLEX_16
 337 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_16) gfc_array_c16;
 338 #endif
 339 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_1) gfc_array_l1;
 340 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_2) gfc_array_l2;
 341 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
 342 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;
 343 #ifdef HAVE_GFC_LOGICAL_16
 344 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_16) gfc_array_l16;
 345 #endif
 346
 347
 348 #define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
 349 #define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
 350                                    >> GFC_DTYPE_TYPE_SHIFT)
 351 #define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
 352 #define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
 353 #define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
 354
 355 /* Macros to get both the size and the type with a single masking operation  */
 356
 357 #define GFC_DTYPE_SIZE_MASK \
 358   ((~((index_type) 0) >> GFC_DTYPE_SIZE_SHIFT) << GFC_DTYPE_SIZE_SHIFT)
 359 #define GFC_DTYPE_TYPE_SIZE_MASK (GFC_DTYPE_SIZE_MASK | GFC_DTYPE_TYPE_MASK)
 360
 361 #define GFC_DTYPE_TYPE_SIZE(desc) ((desc)->dtype & GFC_DTYPE_TYPE_SIZE_MASK)
 362
 363 #define GFC_DTYPE_INTEGER_1 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 364    | (sizeof(GFC_INTEGER_1) << GFC_DTYPE_SIZE_SHIFT))
 365 #define GFC_DTYPE_INTEGER_2 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 366    | (sizeof(GFC_INTEGER_2) << GFC_DTYPE_SIZE_SHIFT))
 367 #define GFC_DTYPE_INTEGER_4 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 368    | (sizeof(GFC_INTEGER_4) << GFC_DTYPE_SIZE_SHIFT))
 369 #define GFC_DTYPE_INTEGER_8 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 370    | (sizeof(GFC_INTEGER_8) << GFC_DTYPE_SIZE_SHIFT))
 371 #ifdef HAVE_GFC_INTEGER_16
 372 #define GFC_DTYPE_INTEGER_16 ((GFC_DTYPE_INTEGER << GFC_DTYPE_TYPE_SHIFT) \
 373    | (sizeof(GFC_INTEGER_16) << GFC_DTYPE_SIZE_SHIFT))
 374 #endif
 375
 376 #define GFC_DTYPE_LOGICAL_1 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 377    | (sizeof(GFC_LOGICAL_1) << GFC_DTYPE_SIZE_SHIFT))
 378 #define GFC_DTYPE_LOGICAL_2 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 379    | (sizeof(GFC_LOGICAL_2) << GFC_DTYPE_SIZE_SHIFT))
 380 #define GFC_DTYPE_LOGICAL_4 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 381    | (sizeof(GFC_LOGICAL_4) << GFC_DTYPE_SIZE_SHIFT))
 382 #define GFC_DTYPE_LOGICAL_8 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 383    | (sizeof(GFC_LOGICAL_8) << GFC_DTYPE_SIZE_SHIFT))
 384 #ifdef HAVE_GFC_LOGICAL_16
 385 #define GFC_DTYPE_LOGICAL_16 ((GFC_DTYPE_LOGICAL << GFC_DTYPE_TYPE_SHIFT) \
 386    | (sizeof(GFC_LOGICAL_16) << GFC_DTYPE_SIZE_SHIFT))
 387 #endif
 388
 389 #define GFC_DTYPE_REAL_4 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 390    | (sizeof(GFC_REAL_4) << GFC_DTYPE_SIZE_SHIFT))
 391 #define GFC_DTYPE_REAL_8 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 392    | (sizeof(GFC_REAL_8) << GFC_DTYPE_SIZE_SHIFT))
 393 #ifdef HAVE_GFC_REAL_10
 394 #define GFC_DTYPE_REAL_10  ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 395    | (sizeof(GFC_REAL_10) << GFC_DTYPE_SIZE_SHIFT))
 396 #endif
 397 #ifdef HAVE_GFC_REAL_16
 398 #define GFC_DTYPE_REAL_16 ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT) \
 399    | (sizeof(GFC_REAL_16) << GFC_DTYPE_SIZE_SHIFT))
 400 #endif
 401
 402 #define GFC_DTYPE_COMPLEX_4 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 403    | (sizeof(GFC_COMPLEX_4) << GFC_DTYPE_SIZE_SHIFT))
 404 #define GFC_DTYPE_COMPLEX_8 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 405    | (sizeof(GFC_COMPLEX_8) << GFC_DTYPE_SIZE_SHIFT))
 406 #ifdef HAVE_GFC_COMPLEX_10
 407 #define GFC_DTYPE_COMPLEX_10 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 408    | (sizeof(GFC_COMPLEX_10) << GFC_DTYPE_SIZE_SHIFT))
 409 #endif
 410 #ifdef HAVE_GFC_COMPLEX_16
 411 #define GFC_DTYPE_COMPLEX_16 ((GFC_DTYPE_COMPLEX << GFC_DTYPE_TYPE_SHIFT) \
 412    | (sizeof(GFC_COMPLEX_16) << GFC_DTYPE_SIZE_SHIFT))
 413 #endif
 414
 415 #define GFC_DTYPE_DERIVED_1 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 416    | (sizeof(GFC_INTEGER_1) << GFC_DTYPE_SIZE_SHIFT))
 417 #define GFC_DTYPE_DERIVED_2 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 418    | (sizeof(GFC_INTEGER_2) << GFC_DTYPE_SIZE_SHIFT))
 419 #define GFC_DTYPE_DERIVED_4 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 420    | (sizeof(GFC_INTEGER_4) << GFC_DTYPE_SIZE_SHIFT))
 421 #define GFC_DTYPE_DERIVED_8 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 422    | (sizeof(GFC_INTEGER_8) << GFC_DTYPE_SIZE_SHIFT))
 423 #ifdef HAVE_GFC_INTEGER_16
 424 #define GFC_DTYPE_DERIVED_16 ((GFC_DTYPE_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
 425    | (sizeof(GFC_INTEGER_16) << GFC_DTYPE_SIZE_SHIFT))
 426 #endif
 427
 428 /* Macros to determine the alignment of pointers.  */
 429
 430 #define GFC_UNALIGNED_2(x) (((uintptr_t)(x)) & \
 431                             (__alignof__(GFC_INTEGER_2) - 1))
 432 #define GFC_UNALIGNED_4(x) (((uintptr_t)(x)) & \
 433                             (__alignof__(GFC_INTEGER_4) - 1))
 434 #define GFC_UNALIGNED_8(x) (((uintptr_t)(x)) & \
 435                             (__alignof__(GFC_INTEGER_8) - 1))
 436 #ifdef HAVE_GFC_INTEGER_16
 437 #define GFC_UNALIGNED_16(x) (((uintptr_t)(x)) & \
 438                              (__alignof__(GFC_INTEGER_16) - 1))
 439 #endif
 440
 441 /* Runtime library include.  */
 442 #define stringize(x) expand_macro(x)
 443 #define expand_macro(x) # x
 444
 445 /* Runtime options structure.  */
 446
 447 typedef struct
 448 {
 449   int stdin_unit, stdout_unit, stderr_unit, optional_plus;
 450   int locus;
 451
 452   int separator_len;
 453   const char *separator;
 454
 455   int use_stderr, all_unbuffered, unbuffered_preconnected, default_recl;
 456   int fpe, dump_core, backtrace;
 457 }
 458 options_t;
 459
 460 extern options_t options;
 461 internal_proto(options);
 462
 463 extern void handler (int);
 464 internal_proto(handler);
 465
 466
 467 /* Compile-time options that will influence the library.  */
 468
 469 typedef struct
 470 {
 471   int warn_std;
 472   int allow_std;
 473   int pedantic;
 474   int convert;
 475   int dump_core;
 476   int backtrace;
 477   int sign_zero;
 478   size_t record_marker;
 479   int max_subrecord_length;
 480   int bounds_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 internal_error (st_parameter_common *, const char *)
 647   __attribute__ ((noreturn));
 648 internal_proto(internal_error);
 649
 650 extern const char *get_oserror (void);
 651 internal_proto(get_oserror);
 652
 653 extern const char *translate_error (int);
 654 internal_proto(translate_error);
 655
 656 extern void generate_error (st_parameter_common *, int, const char *);
 657 iexport_proto(generate_error);
 658
 659 extern try notify_std (st_parameter_common *, int, const char *);
 660 internal_proto(notify_std);
 661
 662 extern notification notification_std(int);
 663 internal_proto(notification_std);
 664
 665 /* fpu.c */
 666
 667 extern void set_fpu (void);
 668 internal_proto(set_fpu);
 669
 670 /* memory.c */
 671
 672 extern void *get_mem (size_t) __attribute__ ((malloc));
 673 internal_proto(get_mem);
 674
 675 extern void free_mem (void *);
 676 internal_proto(free_mem);
 677
 678 extern void *internal_malloc_size (size_t) __attribute__ ((malloc));
 679 internal_proto(internal_malloc_size);
 680
 681 /* environ.c */
 682
 683 extern int check_buffered (int);
 684 internal_proto(check_buffered);
 685
 686 extern void init_variables (void);
 687 internal_proto(init_variables);
 688
 689 extern void show_variables (void);
 690 internal_proto(show_variables);
 691
 692 unit_convert get_unformatted_convert (int);
 693 internal_proto(get_unformatted_convert);
 694
 695 /* string.c */
 696
 697 extern int find_option (st_parameter_common *, const char *, gfc_charlen_type,
 698                         const st_option *, const char *);
 699 internal_proto(find_option);
 700
 701 extern gfc_charlen_type fstrlen (const char *, gfc_charlen_type);
 702 internal_proto(fstrlen);
 703
 704 extern gfc_charlen_type fstrcpy (char *, gfc_charlen_type, const char *, gfc_charlen_type);
 705 internal_proto(fstrcpy);
 706
 707 extern gfc_charlen_type cf_strcpy (char *, gfc_charlen_type, const char *);
 708 internal_proto(cf_strcpy);
 709
 710 /* io/intrinsics.c */
 711
 712 extern void flush_all_units (void);
 713 internal_proto(flush_all_units);
 714
 715 /* io.c */
 716
 717 extern void init_units (void);
 718 internal_proto(init_units);
 719
 720 extern void close_units (void);
 721 internal_proto(close_units);
 722
 723 extern int unit_to_fd (int);
 724 internal_proto(unit_to_fd);
 725
 726 extern int st_printf (const char *, ...)
 727   __attribute__ ((format (printf, 1, 2)));
 728 internal_proto(st_printf);
 729
 730 extern int st_vprintf (const char *, va_list);
 731 internal_proto(st_vprintf);
 732
 733 extern char * filename_from_unit (int);
 734 internal_proto(filename_from_unit);
 735
 736 /* stop.c */
 737
 738 extern void stop_numeric (GFC_INTEGER_4) __attribute__ ((noreturn));
 739 iexport_proto(stop_numeric);
 740
 741 /* reshape_packed.c */
 742
 743 extern void reshape_packed (char *, index_type, const char *, index_type,
 744                             const char *, index_type);
 745 internal_proto(reshape_packed);
 746
 747 /* Repacking functions.  These are called internally by internal_pack
 748    and internal_unpack.  */
 749
 750 GFC_INTEGER_1 *internal_pack_1 (gfc_array_i1 *);
 751 internal_proto(internal_pack_1);
 752
 753 GFC_INTEGER_2 *internal_pack_2 (gfc_array_i2 *);
 754 internal_proto(internal_pack_2);
 755
 756 GFC_INTEGER_4 *internal_pack_4 (gfc_array_i4 *);
 757 internal_proto(internal_pack_4);
 758
 759 GFC_INTEGER_8 *internal_pack_8 (gfc_array_i8 *);
 760 internal_proto(internal_pack_8);
 761
 762 #if defined HAVE_GFC_INTEGER_16
 763 GFC_INTEGER_16 *internal_pack_16 (gfc_array_i16 *);
 764 internal_proto(internal_pack_16);
 765 #endif
 766
 767 GFC_REAL_4 *internal_pack_r4 (gfc_array_r4 *);
 768 internal_proto(internal_pack_r4);
 769
 770 GFC_REAL_8 *internal_pack_r8 (gfc_array_r8 *);
 771 internal_proto(internal_pack_r8);
 772
 773 #if defined HAVE_GFC_REAL_10
 774 GFC_REAL_10 *internal_pack_r10 (gfc_array_r10 *);
 775 internal_proto(internal_pack_r10);
 776 #endif
 777
 778 #if defined HAVE_GFC_REAL_16
 779 GFC_REAL_16 *internal_pack_r16 (gfc_array_r16 *);
 780 internal_proto(internal_pack_r16);
 781 #endif
 782
 783 GFC_COMPLEX_4 *internal_pack_c4 (gfc_array_c4 *);
 784 internal_proto(internal_pack_c4);
 785
 786 GFC_COMPLEX_8 *internal_pack_c8 (gfc_array_c8 *);
 787 internal_proto(internal_pack_c8);
 788
 789 #if defined HAVE_GFC_COMPLEX_10
 790 GFC_COMPLEX_10 *internal_pack_c10 (gfc_array_c10 *);
 791 internal_proto(internal_pack_c10);
 792 #endif
 793
 794 #if defined HAVE_GFC_COMPLEX_16
 795 GFC_COMPLEX_16 *internal_pack_c16 (gfc_array_c16 *);
 796 internal_proto(internal_pack_c16);
 797 #endif
 798
 799 extern void internal_unpack_1 (gfc_array_i1 *, const GFC_INTEGER_1 *);
 800 internal_proto(internal_unpack_1);
 801
 802 extern void internal_unpack_2 (gfc_array_i2 *, const GFC_INTEGER_2 *);
 803 internal_proto(internal_unpack_2);
 804
 805 extern void internal_unpack_4 (gfc_array_i4 *, const GFC_INTEGER_4 *);
 806 internal_proto(internal_unpack_4);
 807
 808 extern void internal_unpack_8 (gfc_array_i8 *, const GFC_INTEGER_8 *);
 809 internal_proto(internal_unpack_8);
 810
 811 #if defined HAVE_GFC_INTEGER_16
 812 extern void internal_unpack_16 (gfc_array_i16 *, const GFC_INTEGER_16 *);
 813 internal_proto(internal_unpack_16);
 814 #endif
 815
 816 extern void internal_unpack_r4 (gfc_array_r4 *, const GFC_REAL_4 *);
 817 internal_proto(internal_unpack_r4);
 818
 819 extern void internal_unpack_r8 (gfc_array_r8 *, const GFC_REAL_8 *);
 820 internal_proto(internal_unpack_r8);
 821
 822 #if defined HAVE_GFC_REAL_10
 823 extern void internal_unpack_r10 (gfc_array_r10 *, const GFC_REAL_10 *);
 824 internal_proto(internal_unpack_r10);
 825 #endif
 826
 827 #if defined HAVE_GFC_REAL_16
 828 extern void internal_unpack_r16 (gfc_array_r16 *, const GFC_REAL_16 *);
 829 internal_proto(internal_unpack_r16);
 830 #endif
 831
 832 extern void internal_unpack_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *);
 833 internal_proto(internal_unpack_c4);
 834
 835 extern void internal_unpack_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *);
 836 internal_proto(internal_unpack_c8);
 837
 838 #if defined HAVE_GFC_COMPLEX_10
 839 extern void internal_unpack_c10 (gfc_array_c10 *, const GFC_COMPLEX_10 *);
 840 internal_proto(internal_unpack_c10);
 841 #endif
 842
 843 #if defined HAVE_GFC_COMPLEX_16
 844 extern void internal_unpack_c16 (gfc_array_c16 *, const GFC_COMPLEX_16 *);
 845 internal_proto(internal_unpack_c16);
 846 #endif
 847
 848 /* Internal auxiliary functions for the pack intrinsic.  */
 849
 850 extern void pack_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 851                      const gfc_array_l1 *, const gfc_array_i1 *);
 852 internal_proto(pack_i1);
 853
 854 extern void pack_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 855                      const gfc_array_l1 *, const gfc_array_i2 *);
 856 internal_proto(pack_i2);
 857
 858 extern void pack_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 859                      const gfc_array_l1 *, const gfc_array_i4 *);
 860 internal_proto(pack_i4);
 861
 862 extern void pack_i8 (gfc_array_i8 *, const gfc_array_i8 *,
 863                      const gfc_array_l1 *, const gfc_array_i8 *);
 864 internal_proto(pack_i8);
 865
 866 #ifdef HAVE_GFC_INTEGER_16
 867 extern void pack_i16 (gfc_array_i16 *, const gfc_array_i16 *,
 868                      const gfc_array_l1 *, const gfc_array_i16 *);
 869 internal_proto(pack_i16);
 870 #endif
 871
 872 extern void pack_r4 (gfc_array_r4 *, const gfc_array_r4 *,
 873                      const gfc_array_l1 *, const gfc_array_r4 *);
 874 internal_proto(pack_r4);
 875
 876 extern void pack_r8 (gfc_array_r8 *, const gfc_array_r8 *,
 877                      const gfc_array_l1 *, const gfc_array_r8 *);
 878 internal_proto(pack_r8);
 879
 880 #ifdef HAVE_GFC_REAL_10
 881 extern void pack_r10 (gfc_array_r10 *, const gfc_array_r10 *,
 882                      const gfc_array_l1 *, const gfc_array_r10 *);
 883 internal_proto(pack_r10);
 884 #endif
 885
 886 #ifdef HAVE_GFC_REAL_16
 887 extern void pack_r16 (gfc_array_r16 *, const gfc_array_r16 *,
 888                      const gfc_array_l1 *, const gfc_array_r16 *);
 889 internal_proto(pack_r16);
 890 #endif
 891
 892 extern void pack_c4 (gfc_array_c4 *, const gfc_array_c4 *,
 893                      const gfc_array_l1 *, const gfc_array_c4 *);
 894 internal_proto(pack_c4);
 895
 896 extern void pack_c8 (gfc_array_c8 *, const gfc_array_c8 *,
 897                      const gfc_array_l1 *, const gfc_array_c8 *);
 898 internal_proto(pack_c8);
 899
 900 #ifdef HAVE_GFC_REAL_10
 901 extern void pack_c10 (gfc_array_c10 *, const gfc_array_c10 *,
 902                      const gfc_array_l1 *, const gfc_array_c10 *);
 903 internal_proto(pack_c10);
 904 #endif
 905
 906 #ifdef HAVE_GFC_REAL_16
 907 extern void pack_c16 (gfc_array_c16 *, const gfc_array_c16 *,
 908                      const gfc_array_l1 *, const gfc_array_c16 *);
 909 internal_proto(pack_c16);
 910 #endif
 911
 912 /* Internal auxiliary functions for the unpack intrinsic.  */
 913
 914 extern void unpack0_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 915                         const gfc_array_l1 *, const GFC_INTEGER_1 *);
 916 internal_proto(unpack0_i1);
 917
 918 extern void unpack0_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 919                         const gfc_array_l1 *, const GFC_INTEGER_2 *);
 920 internal_proto(unpack0_i2);
 921
 922 extern void unpack0_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 923                         const gfc_array_l1 *, const GFC_INTEGER_4 *);
 924 internal_proto(unpack0_i4);
 925
 926 extern void unpack0_i8 (gfc_array_i8 *, const gfc_array_i8 *,
 927                         const gfc_array_l1 *, const GFC_INTEGER_8 *);
 928 internal_proto(unpack0_i8);
 929
 930 #ifdef HAVE_GFC_INTEGER_16
 931
 932 extern void unpack0_i16 (gfc_array_i16 *, const gfc_array_i16 *,
 933                          const gfc_array_l1 *, const GFC_INTEGER_16 *);
 934 internal_proto(unpack0_i16);
 935
 936 #endif
 937
 938 extern void unpack0_r4 (gfc_array_r4 *, const gfc_array_r4 *,
 939                         const gfc_array_l1 *, const GFC_REAL_4 *);
 940 internal_proto(unpack0_r4);
 941
 942 extern void unpack0_r8 (gfc_array_r8 *, const gfc_array_r8 *,
 943                         const gfc_array_l1 *, const GFC_REAL_8 *);
 944 internal_proto(unpack0_r8);
 945
 946 #ifdef HAVE_GFC_REAL_10
 947
 948 extern void unpack0_r10 (gfc_array_r10 *, const gfc_array_r10 *,
 949                          const gfc_array_l1 *, const GFC_REAL_10 *);
 950 internal_proto(unpack0_r10);
 951
 952 #endif
 953
 954 #ifdef HAVE_GFC_REAL_16
 955
 956 extern void unpack0_r16 (gfc_array_r16 *, const gfc_array_r16 *,
 957                          const gfc_array_l1 *, const GFC_REAL_16 *);
 958 internal_proto(unpack0_r16);
 959
 960 #endif
 961
 962 extern void unpack0_c4 (gfc_array_c4 *, const gfc_array_c4 *,
 963                         const gfc_array_l1 *, const GFC_COMPLEX_4 *);
 964 internal_proto(unpack0_c4);
 965
 966 extern void unpack0_c8 (gfc_array_c8 *, const gfc_array_c8 *,
 967                         const gfc_array_l1 *, const GFC_COMPLEX_8 *);
 968 internal_proto(unpack0_c8);
 969
 970 #ifdef HAVE_GFC_COMPLEX_10
 971
 972 extern void unpack0_c10 (gfc_array_c10 *, const gfc_array_c10 *,
 973                          const gfc_array_l1 *mask, const GFC_COMPLEX_10 *);
 974 internal_proto(unpack0_c10);
 975
 976 #endif
 977
 978 #ifdef HAVE_GFC_COMPLEX_16
 979
 980 extern void unpack0_c16 (gfc_array_c16 *, const gfc_array_c16 *,
 981                          const gfc_array_l1 *, const GFC_COMPLEX_16 *);
 982 internal_proto(unpack0_c16);
 983
 984 #endif
 985
 986 extern void unpack1_i1 (gfc_array_i1 *, const gfc_array_i1 *,
 987                         const gfc_array_l1 *, const gfc_array_i1 *);
 988 internal_proto(unpack1_i1);
 989
 990 extern void unpack1_i2 (gfc_array_i2 *, const gfc_array_i2 *,
 991                         const gfc_array_l1 *, const gfc_array_i2 *);
 992 internal_proto(unpack1_i2);
 993
 994 extern void unpack1_i4 (gfc_array_i4 *, const gfc_array_i4 *,
 995                         const gfc_array_l1 *, const gfc_array_i4 *);
 996 internal_proto(unpack1_i4);
 997
 998 extern void unpack1_i8 (gfc_array_i8 *, const gfc_array_i8 *,
 999                         const gfc_array_l1 *, const gfc_array_i8 *);
1000 internal_proto(unpack1_i8);
1001
1002 #ifdef HAVE_GFC_INTEGER_16
1003 extern void unpack1_i16 (gfc_array_i16 *, const gfc_array_i16 *,
1004                          const gfc_array_l1 *, const gfc_array_i16 *);
1005 internal_proto(unpack1_i16);
1006 #endif
1007
1008 extern void unpack1_r4 (gfc_array_r4 *, const gfc_array_r4 *,
1009                         const gfc_array_l1 *, const gfc_array_r4 *);
1010 internal_proto(unpack1_r4);
1011
1012 extern void unpack1_r8 (gfc_array_r8 *, const gfc_array_r8 *,
1013                         const gfc_array_l1 *, const gfc_array_r8 *);
1014 internal_proto(unpack1_r8);
1015
1016 #ifdef HAVE_GFC_REAL_10
1017 extern void unpack1_r10 (gfc_array_r10 *, const gfc_array_r10 *,
1018                          const gfc_array_l1 *, const gfc_array_r10 *);
1019 internal_proto(unpack1_r10);
1020 #endif
1021
1022 #ifdef HAVE_GFC_REAL_16
1023 extern void unpack1_r16 (gfc_array_r16 *, const gfc_array_r16 *,
1024                          const gfc_array_l1 *, const gfc_array_r16 *);
1025 internal_proto(unpack1_r16);
1026 #endif
1027
1028 extern void unpack1_c4 (gfc_array_c4 *, const gfc_array_c4 *,
1029                         const gfc_array_l1 *, const gfc_array_c4 *);
1030 internal_proto(unpack1_c4);
1031
1032 extern void unpack1_c8 (gfc_array_c8 *, const gfc_array_c8 *,
1033                         const gfc_array_l1 *, const gfc_array_c8 *);
1034 internal_proto(unpack1_c8);
1035
1036 #ifdef HAVE_GFC_COMPLEX_10
1037 extern void unpack1_c10 (gfc_array_c10 *, const gfc_array_c10 *,
1038                          const gfc_array_l1 *, const gfc_array_c10 *);
1039 internal_proto(unpack1_c10);
1040 #endif
1041
1042 #ifdef HAVE_GFC_COMPLEX_16
1043 extern void unpack1_c16 (gfc_array_c16 *, const gfc_array_c16 *,
1044                          const gfc_array_l1 *, const gfc_array_c16 *);
1045 internal_proto(unpack1_c16);
1046 #endif
1047
1048 /* Helper functions for spread.  */
1049
1050 extern void spread_i1 (gfc_array_i1 *, const gfc_array_i1 *,
1051                        const index_type, const index_type);
1052 internal_proto(spread_i1);
1053
1054 extern void spread_i2 (gfc_array_i2 *, const gfc_array_i2 *,
1055                        const index_type, const index_type);
1056 internal_proto(spread_i2);
1057
1058 extern void spread_i4 (gfc_array_i4 *, const gfc_array_i4 *,
1059                        const index_type, const index_type);
1060 internal_proto(spread_i4);
1061
1062 extern void spread_i8 (gfc_array_i8 *, const gfc_array_i8 *,
1063                        const index_type, const index_type);
1064 internal_proto(spread_i8);
1065
1066 #ifdef HAVE_GFC_INTEGER_16
1067 extern void spread_i16 (gfc_array_i16 *, const gfc_array_i16 *,
1068                        const index_type, const index_type);
1069 internal_proto(spread_i16);
1070
1071 #endif
1072
1073 extern void spread_r4 (gfc_array_r4 *, const gfc_array_r4 *,
1074                        const index_type, const index_type);
1075 internal_proto(spread_r4);
1076
1077 extern void spread_r8 (gfc_array_r8 *, const gfc_array_r8 *,
1078                        const index_type, const index_type);
1079 internal_proto(spread_r8);
1080
1081 #ifdef HAVE_GFC_REAL_10
1082 extern void spread_r10 (gfc_array_r10 *, const gfc_array_r10 *,
1083                        const index_type, const index_type);
1084 internal_proto(spread_r10);
1085
1086 #endif
1087
1088 #ifdef HAVE_GFC_REAL_16
1089 extern void spread_r16 (gfc_array_r16 *, const gfc_array_r16 *,
1090                        const index_type, const index_type);
1091 internal_proto(spread_r16);
1092
1093 #endif
1094
1095 extern void spread_c4 (gfc_array_c4 *, const gfc_array_c4 *,
1096                        const index_type, const index_type);
1097 internal_proto(spread_c4);
1098
1099 extern void spread_c8 (gfc_array_c8 *, const gfc_array_c8 *,
1100                        const index_type, const index_type);
1101 internal_proto(spread_c8);
1102
1103 #ifdef HAVE_GFC_COMPLEX_10
1104 extern void spread_c10 (gfc_array_c10 *, const gfc_array_c10 *,
1105                        const index_type, const index_type);
1106 internal_proto(spread_c10);
1107
1108 #endif
1109
1110 #ifdef HAVE_GFC_COMPLEX_16
1111 extern void spread_c16 (gfc_array_c16 *, const gfc_array_c16 *,
1112                        const index_type, const index_type);
1113 internal_proto(spread_c16);
1114
1115 #endif
1116
1117 extern void spread_scalar_i1 (gfc_array_i1 *, const GFC_INTEGER_1 *,
1118                               const index_type, const index_type);
1119 internal_proto(spread_scalar_i1);
1120
1121 extern void spread_scalar_i2 (gfc_array_i2 *, const GFC_INTEGER_2 *,
1122                               const index_type, const index_type);
1123 internal_proto(spread_scalar_i2);
1124
1125 extern void spread_scalar_i4 (gfc_array_i4 *, const GFC_INTEGER_4 *,
1126                               const index_type, const index_type);
1127 internal_proto(spread_scalar_i4);
1128
1129 extern void spread_scalar_i8 (gfc_array_i8 *, const GFC_INTEGER_8 *,
1130                               const index_type, const index_type);
1131 internal_proto(spread_scalar_i8);
1132
1133 #ifdef HAVE_GFC_INTEGER_16
1134 extern void spread_scalar_i16 (gfc_array_i16 *, const GFC_INTEGER_16 *,
1135                                const index_type, const index_type);
1136 internal_proto(spread_scalar_i16);
1137
1138 #endif
1139
1140 extern void spread_scalar_r4 (gfc_array_r4 *, const GFC_REAL_4 *,
1141                               const index_type, const index_type);
1142 internal_proto(spread_scalar_r4);
1143
1144 extern void spread_scalar_r8 (gfc_array_r8 *, const GFC_REAL_8 *,
1145                               const index_type, const index_type);
1146 internal_proto(spread_scalar_r8);
1147
1148 #ifdef HAVE_GFC_REAL_10
1149 extern void spread_scalar_r10 (gfc_array_r10 *, const GFC_REAL_10 *,
1150                                const index_type, const index_type);
1151 internal_proto(spread_scalar_r10);
1152
1153 #endif
1154
1155 #ifdef HAVE_GFC_REAL_16
1156 extern void spread_scalar_r16 (gfc_array_r16 *, const GFC_REAL_16 *,
1157                                const index_type, const index_type);
1158 internal_proto(spread_scalar_r16);
1159
1160 #endif
1161
1162 extern void spread_scalar_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *,
1163                               const index_type, const index_type);
1164 internal_proto(spread_scalar_c4);
1165
1166 extern void spread_scalar_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *,
1167                               const index_type, const index_type);
1168 internal_proto(spread_scalar_c8);
1169
1170 #ifdef HAVE_GFC_COMPLEX_10
1171 extern void spread_scalar_c10 (gfc_array_c10 *, const GFC_COMPLEX_10 *,
1172                                const index_type, const index_type);
1173 internal_proto(spread_scalar_c10);
1174
1175 #endif
1176
1177 #ifdef HAVE_GFC_COMPLEX_16
1178 extern void spread_scalar_c16 (gfc_array_c16 *, const GFC_COMPLEX_16 *,
1179                                const index_type, const index_type);
1180 internal_proto(spread_scalar_c16);
1181
1182 #endif
1183
1184 /* string_intrinsics.c */
1185
1186 extern int compare_string (gfc_charlen_type, const char *,
1187                            gfc_charlen_type, const char *);
1188 iexport_proto(compare_string);
1189
1190 extern int compare_string_char4 (gfc_charlen_type, const gfc_char4_t *,
1191                                  gfc_charlen_type, const gfc_char4_t *);
1192 iexport_proto(compare_string_char4);
1193
1194 /* random.c */
1195
1196 extern void random_seed_i4 (GFC_INTEGER_4 * size, gfc_array_i4 * put,
1197                             gfc_array_i4 * get);
1198 iexport_proto(random_seed_i4);
1199 extern void random_seed_i8 (GFC_INTEGER_8 * size, gfc_array_i8 * put,
1200                             gfc_array_i8 * get);
1201 iexport_proto(random_seed_i8);
1202
1203 /* size.c */
1204
1205 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
1206
1207 extern index_type size0 (const array_t * array);
1208 iexport_proto(size0);
1209
1210 #endif  /* LIBGFOR_H  */