OSDN Git Service

2005-06-14 Frank Ch. Eigler <fche@redhat.com>
[pf3gnuchains/gcc-fork.git] / 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 typedef int8_t GFC_INTEGER_1;
201 typedef int16_t GFC_INTEGER_2;
202 typedef int32_t GFC_INTEGER_4;
203 typedef int64_t GFC_INTEGER_8;
204 typedef uint8_t GFC_UINTEGER_1;
205 typedef uint16_t GFC_UINTEGER_2;
206 typedef uint32_t GFC_UINTEGER_4;
207 typedef uint64_t GFC_UINTEGER_8;
208 typedef GFC_INTEGER_4 GFC_LOGICAL_4;
209 typedef GFC_INTEGER_8 GFC_LOGICAL_8;
210 typedef float GFC_REAL_4;
211 typedef double GFC_REAL_8;
212 typedef complex float GFC_COMPLEX_4;
213 typedef complex double GFC_COMPLEX_8;
214
215 /* The following two definitions must be consistent with the types used
216    by the compiler.  */
217 /* The type used of array indices, amongst other things.  */
218 typedef ssize_t index_type;
219 /* The type used for the lengths of character variables.  */
220 typedef GFC_INTEGER_4 gfc_charlen_type;
221
222 /* This will be 0 on little-endian machines and one on big-endian machines.  */
223 extern int l8_to_l4_offset;
224 internal_proto(l8_to_l4_offset);
225
226 #define GFOR_POINTER_L8_TO_L4(p8) \
227   (l8_to_l4_offset + (GFC_LOGICAL_4 *)(p8))
228
229 #define GFC_INTEGER_4_HUGE \
230   (GFC_INTEGER_4)((((GFC_UINTEGER_4)1) << 31) - 1)
231 #define GFC_INTEGER_8_HUGE \
232   (GFC_INTEGER_8)((((GFC_UINTEGER_8)1) << 63) - 1)
233 #define GFC_REAL_4_HUGE FLT_MAX
234 #define GFC_REAL_8_HUGE DBL_MAX
235
236 #ifndef GFC_MAX_DIMENSIONS
237 #define GFC_MAX_DIMENSIONS 7
238 #endif
239
240 typedef struct descriptor_dimension
241 {
242   index_type stride;
243   index_type lbound;
244   index_type ubound;
245 }
246 descriptor_dimension;
247
248 #define GFC_ARRAY_DESCRIPTOR(r, type) \
249 struct {\
250   type *data;\
251   type *base;\
252   index_type dtype;\
253   descriptor_dimension dim[r];\
254 }
255
256 /* Commonly used array descriptor types.  */
257 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) gfc_array_void;
258 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) gfc_array_char;
259 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_4) gfc_array_i4;
260 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_INTEGER_8) gfc_array_i8;
261 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_4) gfc_array_r4;
262 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_REAL_8) gfc_array_r8;
263 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_4) gfc_array_c4;
264 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_COMPLEX_8) gfc_array_c8;
265 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_4) gfc_array_l4;
266 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_8) gfc_array_l8;
267
268 #define GFC_DTYPE_RANK_MASK 0x07
269 #define GFC_DTYPE_TYPE_SHIFT 3
270 #define GFC_DTYPE_TYPE_MASK 0x38
271 #define GFC_DTYPE_SIZE_SHIFT 6
272
273 enum
274 {
275   GFC_DTYPE_UNKNOWN = 0,
276   GFC_DTYPE_INTEGER,
277   /* TODO: recognize logical types.  */
278   GFC_DTYPE_LOGICAL,
279   GFC_DTYPE_REAL,
280   GFC_DTYPE_COMPLEX,
281   GFC_DTYPE_DERIVED,
282   GFC_DTYPE_CHARACTER
283 };
284
285 #define GFC_DESCRIPTOR_RANK(desc) ((desc)->dtype & GFC_DTYPE_RANK_MASK)
286 #define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
287                                    >> GFC_DTYPE_TYPE_SHIFT)
288 #define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
289 #define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
290 #define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
291
292 /* Runtime library include.  */
293 #define stringize(x) expand_macro(x)
294 #define expand_macro(x) # x
295
296 /* Runtime options structure.  */
297
298 typedef struct
299 {
300   int stdin_unit, stdout_unit, stderr_unit, optional_plus;
301   int allocate_init_flag, allocate_init_value;
302   int locus;
303
304   int separator_len;
305   const char *separator;
306
307   int mem_check;
308   int use_stderr, all_unbuffered, default_recl;
309
310   int fpu_round, fpu_precision, fpu_invalid, fpu_denormal, fpu_zerodiv,
311     fpu_overflow, fpu_underflow, fpu_precision_loss;
312
313   int sighup, sigint;
314 }
315 options_t;
316
317
318 extern options_t options;
319 internal_proto(options);
320
321
322 /* Structure for statement options.  */
323
324 typedef struct
325 {
326   const char *name;
327   int value;
328 }
329 st_option;
330
331 /* Runtime errors.  The EOR and EOF errors are required to be negative.  */
332
333 typedef enum
334 {
335   ERROR_FIRST = -3,             /* Marker for the first error.  */
336   ERROR_EOR = -2,
337   ERROR_END = -1,
338   ERROR_OK = 0,                 /* Indicates success, must be zero.  */
339   ERROR_OS,                     /* Operating system error, more info in errno.  */
340   ERROR_OPTION_CONFLICT,
341   ERROR_BAD_OPTION,
342   ERROR_MISSING_OPTION,
343   ERROR_ALREADY_OPEN,
344   ERROR_BAD_UNIT,
345   ERROR_FORMAT,
346   ERROR_BAD_ACTION,
347   ERROR_ENDFILE,
348   ERROR_BAD_US,
349   ERROR_READ_VALUE,
350   ERROR_READ_OVERFLOW,
351   ERROR_LAST                    /* Not a real error, the last error # + 1.  */
352 }
353 error_codes;
354
355
356 /* The filename and line number don't go inside the globals structure.
357    They are set by the rest of the program and must be linked to.  */
358
359 /* Location of the current library call (optional).  */
360 extern unsigned line;
361 iexport_data_proto(line);
362
363 extern char *filename;
364 iexport_data_proto(filename);
365
366 /* Avoid conflicting prototypes of alloca() in system headers by using 
367    GCC's builtin alloca().  */
368 #define gfc_alloca(x)  __builtin_alloca(x)
369
370
371 /* main.c */
372
373 extern void library_start (void);
374 internal_proto(library_start);
375
376 extern void library_end (void);
377 internal_proto(library_end);
378
379 extern void set_args (int, char **);
380 export_proto(set_args);
381
382 extern void get_args (int *, char ***);
383 internal_proto(get_args);
384
385 /* error.c */
386
387 extern char *gfc_itoa (int64_t);
388 internal_proto(gfc_itoa);
389
390 extern char *xtoa (uint64_t);
391 internal_proto(xtoa);
392
393 extern void os_error (const char *) __attribute__ ((noreturn));
394 internal_proto(os_error);
395
396 extern void show_locus (void);
397 internal_proto(show_locus);
398
399 extern void runtime_error (const char *) __attribute__ ((noreturn));
400 iexport_proto(runtime_error);
401
402 extern void internal_error (const char *) __attribute__ ((noreturn));
403 internal_proto(internal_error);
404
405 extern const char *get_oserror (void);
406 internal_proto(get_oserror);
407
408 extern void sys_exit (int) __attribute__ ((noreturn));
409 internal_proto(sys_exit);
410
411 extern int st_printf (const char *, ...)
412   __attribute__ ((format (printf, 1, 2)));
413 internal_proto(st_printf);
414
415 extern void st_sprintf (char *, const char *, ...)
416   __attribute__ ((format (printf, 2, 3)));
417 internal_proto(st_sprintf);
418
419 extern const char *translate_error (int);
420 internal_proto(translate_error);
421
422 extern void generate_error (int, const char *);
423 internal_proto(generate_error);
424
425 /* memory.c */
426
427 extern void *get_mem (size_t) __attribute__ ((malloc));
428 internal_proto(get_mem);
429
430 extern void free_mem (void *);
431 internal_proto(free_mem);
432
433 extern void *internal_malloc_size (size_t);
434 internal_proto(internal_malloc_size);
435
436 extern void internal_free (void *);
437 iexport_proto(internal_free);
438
439 /* environ.c */
440
441 extern int check_buffered (int);
442 internal_proto(check_buffered);
443
444 extern void init_variables (void);
445 internal_proto(init_variables);
446
447 extern void show_variables (void);
448 internal_proto(show_variables);
449
450 /* string.c */
451
452 extern int find_option (const char *, int, st_option *, const char *);
453 internal_proto(find_option);
454
455 extern int fstrlen (const char *, int);
456 internal_proto(fstrlen);
457
458 extern void fstrcpy (char *, int, const char *, int);
459 internal_proto(fstrcpy);
460
461 extern void cf_strcpy (char *, int, const char *);
462 internal_proto(cf_strcpy);
463
464 /* io.c */
465
466 extern void init_units (void);
467 internal_proto(init_units);
468
469 extern void close_units (void);
470 internal_proto(close_units);
471
472 /* stop.c */
473
474 extern void stop_numeric (GFC_INTEGER_4);
475 iexport_proto(stop_numeric);
476
477 /* reshape_packed.c */
478
479 extern void reshape_packed (char *, index_type, const char *, index_type,
480                             const char *, index_type);
481 internal_proto(reshape_packed);
482
483 /* Repacking functions.  */
484
485 /* ??? These eight aren't currently used by the compiler, though we
486    certainly could do so.  */
487 GFC_INTEGER_4 *internal_pack_4 (gfc_array_i4 *);
488 internal_proto(internal_pack_4);
489
490 GFC_INTEGER_8 *internal_pack_8 (gfc_array_i8 *);
491 internal_proto(internal_pack_8);
492
493 GFC_COMPLEX_4 *internal_pack_c4 (gfc_array_c4 *);
494 internal_proto(internal_pack_c4);
495
496 GFC_COMPLEX_8 *internal_pack_c8 (gfc_array_c8 *);
497 internal_proto(internal_pack_c8);
498
499 extern void internal_unpack_4 (gfc_array_i4 *, const GFC_INTEGER_4 *);
500 internal_proto(internal_unpack_4);
501
502 extern void internal_unpack_8 (gfc_array_i8 *, const GFC_INTEGER_8 *);
503 internal_proto(internal_unpack_8);
504
505 extern void internal_unpack_c4 (gfc_array_c4 *, const GFC_COMPLEX_4 *);
506 internal_proto(internal_unpack_c4);
507
508 extern void internal_unpack_c8 (gfc_array_c8 *, const GFC_COMPLEX_8 *);
509 internal_proto(internal_unpack_c8);
510
511 /* string_intrinsics.c */
512
513 extern GFC_INTEGER_4 compare_string (GFC_INTEGER_4, const char *,
514                                      GFC_INTEGER_4, const char *);
515 iexport_proto(compare_string);
516
517 /* random.c */
518
519 extern void random_seed (GFC_INTEGER_4 * size, gfc_array_i4 * put,
520                          gfc_array_i4 * get);
521 iexport_proto(random_seed);
522
523 /* normalize.c */
524
525 extern GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER_4, GFC_UINTEGER_4);
526 internal_proto(normalize_r4_i4);
527
528 extern GFC_REAL_8 normalize_r8_i8 (GFC_UINTEGER_8, GFC_UINTEGER_8);
529 internal_proto(normalize_r8_i8);
530
531 /* size.c */
532
533 typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
534
535 extern index_type size0 (const array_t * array); 
536 iexport_proto(size0);
537
538 #endif  /* LIBGFOR_H  */