Open64: osprey/kgccfe/gnu/f/target.h Source File

00001 /* target.h -- Public #include File (module.h template V1.0)
00002    Copyright (C) 1995, 1996, 2002 Free Software Foundation, Inc.
00003    Contributed by James Craig Burley.
00004 
00005 This file is part of GNU Fortran.
00006 
00007 GNU Fortran is free software; you can redistribute it and/or modify
00008 it under the terms of the GNU General Public License as published by
00009 the Free Software Foundation; either version 2, or (at your option)
00010 any later version.
00011 
00012 GNU Fortran is distributed in the hope that it will be useful,
00013 but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 GNU General Public License for more details.
00016 
00017 You should have received a copy of the GNU General Public License
00018 along with GNU Fortran; see the file COPYING.  If not, write to
00019 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
00020 02111-1307, USA.
00021 
00022    Owning Modules:
00023       target.c
00024 
00025    Modifications:
00026 */
00027 
00028 /* Allow multiple inclusion to work. */
00029 
00030 #ifndef GCC_F_TARGET_H
00031 #define GCC_F_TARGET_H
00032 
00033 #ifdef FFE_STANDALONE
00034 #define HOST_WIDE_INT long
00035 #else
00036 #ifndef TREE_CODE
00037 #include "tree.h"
00038 #endif
00039 #endif
00040 
00041 /* For now, g77 requires the ability to determine the exact bit pattern
00042    of a float on the target machine.  (Hopefully this will be changed
00043    soon).  Make sure we can do this.  */
00044 
00045 #if !defined (REAL_ARITHMETIC) \
00046   && ((TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT) \
00047       || (FLOAT_WORDS_BIG_ENDIAN != HOST_FLOAT_WORDS_BIG_ENDIAN))
00048 #error "g77 requires ability to access exact FP representation of target machine"
00049 #endif
00050 
00051 /* Simple definitions and enumerations. */
00052 
00053 #define FFETARGET_charactersizeNONE (-1)
00054 #ifndef FFETARGET_charactersizeMAXIMUM
00055 #define FFETARGET_charactersizeMAXIMUM 2147483647
00056 #endif
00057 
00058 #ifndef FFETARGET_defaultIS_90
00059 #define FFETARGET_defaultIS_90 0
00060 #endif
00061 #ifndef FFETARGET_defaultIS_AUTOMATIC
00062 #define FFETARGET_defaultIS_AUTOMATIC 1
00063 #endif
00064 #ifndef FFETARGET_defaultIS_BACKSLASH
00065 #define FFETARGET_defaultIS_BACKSLASH 1
00066 #endif
00067 #ifndef FFETARGET_defaultIS_INIT_LOCAL_ZERO
00068 #define FFETARGET_defaultIS_INIT_LOCAL_ZERO 0
00069 #endif
00070 #ifndef FFETARGET_defaultIS_DOLLAR_OK
00071 #define FFETARGET_defaultIS_DOLLAR_OK 0
00072 #endif
00073 #ifndef FFETARGET_defaultIS_F2C
00074 #define FFETARGET_defaultIS_F2C 1
00075 #endif
00076 #ifndef FFETARGET_defaultIS_F2C_LIBRARY
00077 #define FFETARGET_defaultIS_F2C_LIBRARY 1
00078 #endif
00079 #ifndef FFETARGET_defaultIS_FREE_FORM
00080 #define FFETARGET_defaultIS_FREE_FORM 0
00081 #endif
00082 #ifndef FFETARGET_defaultIS_PEDANTIC
00083 #define FFETARGET_defaultIS_PEDANTIC 0
00084 #endif
00085 #ifndef FFETARGET_defaultCASE_INTRIN
00086 #define FFETARGET_defaultCASE_INTRIN FFE_caseLOWER
00087 #endif
00088 #ifndef FFETARGET_defaultCASE_MATCH
00089 #define FFETARGET_defaultCASE_MATCH FFE_caseLOWER
00090 #endif
00091 #ifndef FFETARGET_defaultCASE_SOURCE
00092 #define FFETARGET_defaultCASE_SOURCE FFE_caseLOWER
00093 #endif
00094 #ifndef FFETARGET_defaultCASE_SYMBOL
00095 #define FFETARGET_defaultCASE_SYMBOL FFE_caseNONE
00096 #endif
00097 
00098 #ifndef FFETARGET_defaultFIXED_LINE_LENGTH
00099 #define FFETARGET_defaultFIXED_LINE_LENGTH 72
00100 #endif
00101 
00102 /* 1 if external Fortran names ("FOO" in SUBROUTINE FOO, COMMON /FOO/,
00103    and even enforced/default-for-unnamed PROGRAM, blank-COMMON, and
00104    BLOCK DATA names, but not names of library functions implementing
00105    intrinsics or names of local/internal variables) should have an
00106    underscore appended (for compatibility with existing systems).  */
00107 
00108 #ifndef FFETARGET_defaultEXTERNAL_UNDERSCORED
00109 #define FFETARGET_defaultEXTERNAL_UNDERSCORED 1
00110 #endif
00111 
00112 /* 1 if external Fortran names with underscores already in them should
00113    have an extra underscore appended (in addition to the one they
00114    might already have appened if FFETARGET_defaultEXTERNAL_UNDERSCORED). */
00115 
00116 #ifndef FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED
00117 #define FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED 1
00118 #endif
00119 
00120 /* If FFETARGET_defaultEXTERNAL_UNDERSCORED is 0, the following definitions
00121    might also need to be overridden to make g77 objects compatible with
00122    f2c+gcc objects.  Although I don't think the unnamed BLOCK DATA one
00123    is an issue at all.  Of course, on some systems it isn't f2c
00124    compatibility that is the issue -- maybe compatibility with some
00125    other compiler(s).  I don't know what to recommend for systems where
00126    there is no existing Fortran compiler -- I suppose porting f2c and
00127    pretending it's the existing one is best for now.  */
00128 
00129 /* 1 if the "FOO" in "PROGRAM FOO" should be overridden and a particular
00130    name imposed in place of it in the actual code (normally the case,
00131    because the library's main entry point on most systems calls the main
00132    function by a particular name).  Someday g77 might do the f2c trick
00133    of also outputting a "FOO" procedure that just calls the main procedure,
00134    but that'll wait until somebody shows why it is needed.  */
00135 
00136 #ifndef FFETARGET_isENFORCED_MAIN
00137 #define FFETARGET_isENFORCED_MAIN 1
00138 #endif
00139 
00140 /* The enforced name of the main program if ENFORCED_MAIN is 1.  */
00141 
00142 #ifndef FFETARGET_nameENFORCED_MAIN_NAME
00143 #define FFETARGET_nameENFORCED_MAIN_NAME "MAIN__"
00144 #endif
00145 
00146 /* The name used for an unnamed main program if ENFORCED_MAIN is 0.  */
00147 
00148 #ifndef FFETARGET_nameUNNAMED_MAIN
00149 #define FFETARGET_nameUNNAMED_MAIN "MAIN__"
00150 #endif
00151 
00152 /* The name used for an unnamed block data program.  */
00153 
00154 #ifndef FFETARGET_nameUNNAMED_BLOCK_DATA
00155 #define FFETARGET_nameUNNAMED_BLOCK_DATA "_BLOCK_DATA__"
00156 #endif
00157 
00158 /* The name used for blank common.  */
00159 
00160 #ifndef FFETARGET_nameBLANK_COMMON
00161 #define FFETARGET_nameBLANK_COMMON "_BLNK__"
00162 #endif
00163 
00164 #ifndef FFETARGET_integerSMALLEST_POSITIVE
00165 #define FFETARGET_integerSMALLEST_POSITIVE 0
00166 #endif
00167 #ifndef FFETARGET_integerLARGEST_POSITIVE
00168 #define FFETARGET_integerLARGEST_POSITIVE 2147483647
00169 #endif
00170 #ifndef FFETARGET_integerBIG_MAGICAL
00171 #define FFETARGET_integerBIG_MAGICAL 020000000000 /* 2147483648 */
00172 #endif
00173 #ifndef FFETARGET_integerALMOST_BIG_MAGICAL
00174 #define FFETARGET_integerALMOST_BIG_MAGICAL 214748364
00175 #endif
00176 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY
00177 #define FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY 0x80000000
00178 #endif
00179 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_HEX
00180 #define FFETARGET_integerALMOST_BIG_OVERFLOW_HEX 0x10000000
00181 #endif
00182 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL
00183 #define FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL 0x20000000
00184 #endif
00185 #ifndef FFETARGET_integerFINISH_BIG_MAGICAL
00186 #define FFETARGET_integerFINISH_BIG_MAGICAL 8
00187 #endif
00188 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY
00189 #define FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY 0
00190 #endif
00191 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_HEX
00192 #define FFETARGET_integerFINISH_BIG_OVERFLOW_HEX 0
00193 #endif
00194 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL
00195 #define FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL 0
00196 #endif
00197 
00198 #ifndef FFETARGET_offsetNONE
00199 #define FFETARGET_offsetNONE 0  /* Not used by FFE, for backend if needed. */
00200 #endif
00201 
00202 #define FFETARGET_okINTEGER1 1
00203 #define FFETARGET_okINTEGER2 1
00204 #define FFETARGET_okINTEGER3 1
00205 #define FFETARGET_okINTEGER4 1
00206 #define FFETARGET_okLOGICAL1 1
00207 #define FFETARGET_okLOGICAL2 1
00208 #define FFETARGET_okLOGICAL3 1
00209 #define FFETARGET_okLOGICAL4 1
00210 #define FFETARGET_okREAL1 1
00211 #define FFETARGET_okREAL2 1
00212 #define FFETARGET_okREAL3 0
00213 #define FFETARGET_okREALQUAD FFETARGET_okREAL3
00214 #define FFETARGET_okCOMPLEX1 1
00215 #define FFETARGET_okCOMPLEX2 1
00216 #define FFETARGET_okCOMPLEX3 0
00217 #define FFETARGET_okCOMPLEXDOUBLE FFETARGET_okCOMPLEX2
00218 #define FFETARGET_okCOMPLEXQUAD FFETARGET_okCOMPLEX3
00219 #define FFETARGET_okCHARACTER1 1
00220 
00221 #define FFETARGET_f2cTYUNKNOWN 0
00222 #define FFETARGET_f2cTYADDR 1
00223 #define FFETARGET_f2cTYSHORT 2
00224 #define FFETARGET_f2cTYLONG 3
00225 #define FFETARGET_f2cTYREAL 4
00226 #define FFETARGET_f2cTYDREAL 5
00227 #define FFETARGET_f2cTYCOMPLEX 6
00228 #define FFETARGET_f2cTYDCOMPLEX 7
00229 #define FFETARGET_f2cTYLOGICAL 8
00230 #define FFETARGET_f2cTYCHAR 9
00231 #define FFETARGET_f2cTYSUBR 10
00232 #define FFETARGET_f2cTYINT1 11
00233 #define FFETARGET_f2cTYLOGICAL1 12
00234 #define FFETARGET_f2cTYLOGICAL2 13
00235 #define FFETARGET_f2cTYQUAD 14
00236 
00237 #if (!defined(__alpha__) \
00238      && (!defined(__hppa__) || !defined(__LP64__)) \
00239      && (!defined(__ia64__) || !defined(__LP64__)) \
00240      && !defined(__MMIX__) \
00241      && (!defined (_ARCH_PPC) || !defined (__64BIT__)) \
00242      && !defined(__powerpc64__) \
00243      && !defined(__s390x__) \
00244      && (!defined(__sparc__) || (!defined(__sparcv9) && !defined(__arch64__)))\
00245      && !defined(__x86_64__))
00246 #define FFETARGET_32bit_longs
00247 #endif
00248 
00249 /* Typedefs. */
00250 
00251 typedef unsigned char ffetargetAlign; /* ffetargetOffset for alignment. */
00252 #define ffetargetAlign_f ""
00253 typedef long ffetargetCharacterSize;
00254 #define ffetargetCharacterSize_f "l"
00255 typedef void (*ffetargetCopyfunc) (void *, void *, size_t);
00256 typedef ffetargetCharacterSize ffetargetHollerithSize;
00257 #define ffetargetHollerithSize_f "l"
00258 typedef long long ffetargetOffset;
00259 #define ffetargetOffset_f "ll"
00260 
00261 #if FFETARGET_okINTEGER1
00262 #ifdef FFETARGET_32bit_longs
00263 typedef long int ffetargetInteger1;
00264 #define ffetargetInteger1_f "l"
00265 #else
00266 typedef int ffetargetInteger1;
00267 #define ffetargetInteger1_f ""
00268 #endif
00269 #endif
00270 #if FFETARGET_okINTEGER2
00271 typedef signed char ffetargetInteger2;
00272 #define ffetargetInteger2_f ""
00273 #endif
00274 #if FFETARGET_okINTEGER3
00275 typedef short int ffetargetInteger3;
00276 #define ffetargetInteger3_f ""
00277 #endif
00278 #if FFETARGET_okINTEGER4
00279 typedef long long int ffetargetInteger4;
00280 #define ffetargetInteger4_f "ll"
00281 #endif
00282 #if FFETARGET_okINTEGER5
00283 typedef ? ffetargetInteger5;
00284 #define ffetargetInteger5_f
00285 ?
00286 #endif
00287 #if FFETARGET_okINTEGER6
00288 typedef ? ffetargetInteger6;
00289 #define ffetargetInteger6_f
00290 ?
00291 #endif
00292 #if FFETARGET_okINTEGER7
00293 typedef ? ffetargetInteger7;
00294 #define ffetargetInteger7_f
00295 ?
00296 #endif
00297 #if FFETARGET_okINTEGER8
00298 typedef ? ffetargetInteger8;
00299 #define ffetargetInteger8_f
00300 ?
00301 #endif
00302 #if FFETARGET_okLOGICAL1
00303 #ifdef FFETARGET_32bit_longs
00304 typedef long int ffetargetLogical1;
00305 #define ffetargetLogical1_f "l"
00306 #else
00307 typedef int ffetargetLogical1;
00308 #define ffetargetLogical1_f ""
00309 #endif
00310 #endif
00311 #if FFETARGET_okLOGICAL2
00312 typedef signed char ffetargetLogical2;
00313 #define ffetargetLogical2_f ""
00314 #endif
00315 #if FFETARGET_okLOGICAL3
00316 typedef short int ffetargetLogical3;
00317 #define ffetargetLogical3_f ""
00318 #endif
00319 #if FFETARGET_okLOGICAL4
00320 typedef long long int ffetargetLogical4;
00321 #define ffetargetLogical4_f "ll"
00322 #endif
00323 #if FFETARGET_okLOGICAL5
00324 typedef ? ffetargetLogical5;
00325 #define ffetargetLogical5_f
00326 ?
00327 #endif
00328 #if FFETARGET_okLOGICAL6
00329 typedef ? ffetargetLogical6;
00330 #define ffetargetLogical6_f
00331 ?
00332 #endif
00333 #if FFETARGET_okLOGICAL7
00334 typedef ? ffetargetLogical7;
00335 #define ffetargetLogical7_f
00336 ?
00337 #endif
00338 #if FFETARGET_okLOGICAL8
00339 typedef ? ffetargetLogical8;
00340 #define ffetargetLogical8_f
00341 ?
00342 #endif
00343 #if FFETARGET_okREAL1
00344 #ifdef REAL_ARITHMETIC
00345 #ifdef FFETARGET_32bit_longs
00346 typedef long int ffetargetReal1;
00347 #define ffetargetReal1_f "l"
00348 #define ffetarget_cvt_r1_to_rv_ REAL_VALUE_UNTO_TARGET_SINGLE
00349 #define ffetarget_cvt_rv_to_r1_ REAL_VALUE_TO_TARGET_SINGLE
00350 #else
00351 typedef int ffetargetReal1;
00352 #define ffetargetReal1_f ""
00353 #define ffetarget_cvt_r1_to_rv_(in) \
00354   ({ REAL_VALUE_TYPE _rv; \
00355      _rv = REAL_VALUE_UNTO_TARGET_SINGLE ((long) (in)); \
00356      _rv; })
00357 #define ffetarget_cvt_rv_to_r1_(in, out) \
00358   ({ long _tmp; \
00359      REAL_VALUE_TO_TARGET_SINGLE ((in), _tmp); \
00360      (out) = (ffetargetReal1) _tmp; })
00361 #endif
00362 #else /* REAL_ARITHMETIC */
00363 typedef float ffetargetReal1;
00364 #define ffetargetReal1_f ""
00365 #endif  /* REAL_ARITHMETIC */
00366 #endif
00367 #if FFETARGET_okREAL2
00368 #ifdef REAL_ARITHMETIC
00369 #ifdef FFETARGET_32bit_longs
00370 typedef struct
00371   {
00372     long int v[2];
00373   }
00374 ffetargetReal2;
00375 #define ffetargetReal2_f "l"
00376 #define ffetarget_cvt_r2_to_rv_ REAL_VALUE_UNTO_TARGET_DOUBLE
00377 #define ffetarget_cvt_rv_to_r2_ REAL_VALUE_TO_TARGET_DOUBLE
00378 #else
00379 typedef struct
00380   {
00381     int v[2];
00382   }
00383 ffetargetReal2;
00384 #define ffetargetReal2_f ""
00385 #define ffetarget_cvt_r2_to_rv_(in) \
00386   ({ REAL_VALUE_TYPE _rv; \
00387      long _tmp[2]; \
00388      _tmp[0] = (in)[0]; \
00389      _tmp[1] = (in)[1]; \
00390      _rv = REAL_VALUE_UNTO_TARGET_DOUBLE (_tmp); \
00391      _rv; })
00392 #define ffetarget_cvt_rv_to_r2_(in, out) \
00393   ({ long _tmp[2]; \
00394      REAL_VALUE_TO_TARGET_DOUBLE ((in), _tmp); \
00395      (out)[0] = (int) (_tmp[0]); \
00396      (out)[1] = (int) (_tmp[1]); })
00397 #endif
00398 #else
00399 typedef double ffetargetReal2;
00400 #define ffetargetReal2_f ""
00401 #endif
00402 #endif
00403 #if FFETARGET_okREAL3
00404 #ifdef REAL_ARITHMETIC
00405 typedef long ffetargetReal3[?];
00406 #else
00407 typedef ? ffetargetReal3;
00408 #define ffetargetReal3_f
00409 #endif
00410 ?
00411 #endif
00412 #if FFETARGET_okREAL4
00413 #ifdef REAL_ARITHMETIC
00414 typedef long ffetargetReal4[?];
00415 #else
00416 typedef ? ffetargetReal4;
00417 #define ffetargetReal4_f
00418 #endif
00419 ?
00420 #endif
00421 #if FFETARGET_okREAL5
00422 #ifdef REAL_ARITHMETIC
00423 typedef long ffetargetReal5[?];
00424 #else
00425 typedef ? ffetargetReal5;
00426 #define ffetargetReal5_f
00427 #endif
00428 ?
00429 #endif
00430 #if FFETARGET_okREAL6
00431 #ifdef REAL_ARITHMETIC
00432 typedef long ffetargetReal6[?];
00433 #else
00434 typedef ? ffetargetReal6;
00435 #define ffetargetReal6_f
00436 #endif
00437 ?
00438 #endif
00439 #if FFETARGET_okREAL7
00440 #ifdef REAL_ARITHMETIC
00441 typedef long ffetargetReal7[?];
00442 #else
00443 typedef ? ffetargetReal7;
00444 #define ffetargetReal7_f
00445 #endif
00446 ?
00447 #endif
00448 #if FFETARGET_okREAL8
00449 #ifdef REAL_ARITHMETIC
00450 typedef long ffetargetReal8[?];
00451 #else
00452 typedef ? ffetargetReal8;
00453 #define ffetargetReal8_f
00454 #endif
00455 ?
00456 #endif
00457 #if FFETARGET_okCOMPLEX1
00458 struct _ffetarget_complex_1_
00459   {
00460     ffetargetReal1 real;
00461     ffetargetReal1 imaginary;
00462   };
00463 typedef struct _ffetarget_complex_1_ ffetargetComplex1;
00464 #endif
00465 #if FFETARGET_okCOMPLEX2
00466 struct _ffetarget_complex_2_
00467   {
00468     ffetargetReal2 real;
00469     ffetargetReal2 imaginary;
00470   };
00471 typedef struct _ffetarget_complex_2_ ffetargetComplex2;
00472 #endif
00473 #if FFETARGET_okCOMPLEX3
00474 struct _ffetarget_complex_3_
00475   {
00476     ffetargetReal3 real;
00477     ffetargetReal3 imaginary;
00478   };
00479 typedef struct _ffetarget_complex_3_ ffetargetComplex3;
00480 #endif
00481 #if FFETARGET_okCOMPLEX4
00482 struct _ffetarget_complex_4_
00483   {
00484     ffetargetReal4 real;
00485     ffetargetReal4 imaginary;
00486   };
00487 typedef struct _ffetarget_complex_4_ ffetargetComplex4;
00488 #endif
00489 #if FFETARGET_okCOMPLEX5
00490 struct _ffetarget_complex_5_
00491   {
00492     ffetargetReal5 real;
00493     ffetargetReal5 imaginary;
00494   };
00495 typedef struct _ffetarget_complex_5_ ffetargetComplex5;
00496 #endif
00497 #if FFETARGET_okCOMPLEX6
00498 struct _ffetarget_complex_6_
00499   {
00500     ffetargetReal6 real;
00501     ffetargetReal6 imaginary;
00502   };
00503 typedef struct _ffetarget_complex_6_ ffetargetComplex6;
00504 #endif
00505 #if FFETARGET_okCOMPLEX7
00506 struct _ffetarget_complex_7_
00507   {
00508     ffetargetReal7 real;
00509     ffetargetReal7 imaginary;
00510   };
00511 typedef struct _ffetarget_complex_7_ ffetargetComplex7;
00512 #endif
00513 #if FFETARGET_okCOMPLEX8
00514 struct _ffetarget_complex_8_
00515   {
00516     ffetargetReal8 real;
00517     ffetargetReal8 imaginary;
00518   };
00519 typedef struct _ffetarget_complex_8_ ffetargetComplex8;
00520 #endif
00521 #if FFETARGET_okCHARACTER1
00522 struct _ffetarget_char_1_
00523   {
00524     ffetargetCharacterSize length;
00525     unsigned char *text;
00526   };
00527 typedef struct _ffetarget_char_1_ ffetargetCharacter1;
00528 typedef unsigned char ffetargetCharacterUnit1;
00529 #endif
00530 #if FFETARGET_okCHARACTER2
00531 typedef ? ffetargetCharacter2;
00532 typedef ? ffetargetCharacterUnit2;
00533 #endif
00534 #if FFETARGET_okCHARACTER3
00535 typedef ? ffetargetCharacter3;
00536 typedef ? ffetargetCharacterUnit3;
00537 #endif
00538 #if FFETARGET_okCHARACTER4
00539 typedef ? ffetargetCharacter4;
00540 typedef ? ffetargetCharacterUnit4;
00541 #endif
00542 #if FFETARGET_okCHARACTER5
00543 typedef ? ffetargetCharacter5;
00544 typedef ? ffetargetCharacterUnit5;
00545 #endif
00546 #if FFETARGET_okCHARACTER6
00547 typedef ? ffetargetCharacter6;
00548 typedef ? ffetargetCharacterUnit6;
00549 #endif
00550 #if FFETARGET_okCHARACTER7
00551 typedef ? ffetargetCharacter7;
00552 typedef ? ffetargetCharacterUnit7;
00553 #endif
00554 #if FFETARGET_okCHARACTER8
00555 typedef ? ffetargetCharacter8;
00556 typedef ? ffetargetCharacterUnit8;
00557 #endif
00558 
00559 typedef unsigned long long int ffetargetTypeless;
00560 
00561 struct _ffetarget_hollerith_
00562   {
00563     ffetargetHollerithSize length;
00564     unsigned char *text;
00565   };
00566 typedef struct _ffetarget_hollerith_ ffetargetHollerith;
00567 
00568 typedef ffetargetCharacter1 ffetargetCharacterDefault;
00569 typedef ffetargetComplex1 ffetargetComplexDefault;
00570 #if FFETARGET_okCOMPLEXDOUBLE
00571 typedef ffetargetComplex2 ffetargetComplexDouble;
00572 #endif
00573 #if FFETARGET_okCOMPLEXQUAD
00574 typedef ffetargetComplex3 ffetargetComplexQuad;
00575 #endif
00576 typedef ffetargetInteger1 ffetargetIntegerDefault;
00577 #define ffetargetIntegerDefault_f ffetargetInteger1_f
00578 typedef ffetargetLogical1 ffetargetLogicalDefault;
00579 #define ffetargetLogicalDefault_f ffetargetLogical1_f
00580 typedef ffetargetReal1 ffetargetRealDefault;
00581 #define ffetargetRealDefault_f ffetargetReal1_f
00582 typedef ffetargetReal2 ffetargetRealDouble;
00583 #define ffetargetRealDouble_f ffetargetReal2_f
00584 #if FFETARGET_okREALQUAD
00585 typedef ffetargetReal3 ffetargetRealQuad;
00586 #define ffetargetRealQuad_f ffetargetReal3_f
00587 #endif
00588 
00589 /* Include files needed by this one. */
00590 
00591 #include "bad.h"
00592 #include "info.h"
00593 #include "lex.h"
00594 #include "malloc.h"
00595 
00596 /* Structure definitions. */
00597 
00598 
00599 /* Global objects accessed by users of this module. */
00600 
00601 extern char ffetarget_string_[40];  /* Temp for ascii-to-double (atof). */
00602 extern HOST_WIDE_INT ffetarget_long_val_;
00603 extern HOST_WIDE_INT ffetarget_long_junk_;
00604 
00605 /* Declare functions with prototypes. */
00606 
00607 void ffetarget_aggregate_info (ffeinfoBasictype *ebt, ffeinfoKindtype *ekt,
00608              ffetargetAlign *units, ffeinfoBasictype abt,
00609              ffeinfoKindtype akt);
00610 ffetargetAlign ffetarget_align (ffetargetAlign *updated_alignment,
00611         ffetargetAlign *updated_modulo,
00612         ffetargetOffset offset,
00613         ffetargetAlign alignment,
00614         ffetargetAlign modulo);
00615 #if FFETARGET_okCHARACTER1
00616 bool ffetarget_character1 (ffetargetCharacter1 *val, ffelexToken character,
00617          mallocPool pool);
00618 int ffetarget_cmp_character1 (ffetargetCharacter1 l, ffetargetCharacter1 r);
00619 ffebad ffetarget_concatenate_character1 (ffetargetCharacter1 *res,
00620            ffetargetCharacter1 l,
00621            ffetargetCharacter1 r,
00622            mallocPool pool,
00623            ffetargetCharacterSize *len);
00624 ffebad ffetarget_convert_character1_character1 (ffetargetCharacter1 *res,
00625               ffetargetCharacterSize res_size,
00626             ffetargetCharacter1 l,
00627             mallocPool pool);
00628 ffebad ffetarget_convert_character1_hollerith (ffetargetCharacter1 *res,
00629               ffetargetCharacterSize res_size,
00630                  ffetargetHollerith l,
00631                  mallocPool pool);
00632 ffebad ffetarget_convert_character1_integer4 (ffetargetCharacter1 *res,
00633                 ffetargetCharacterSize res_size,
00634                 ffetargetInteger4 l,
00635                 mallocPool pool);
00636 ffebad ffetarget_convert_character1_logical4 (ffetargetCharacter1 *res,
00637                 ffetargetCharacterSize res_size,
00638                 ffetargetLogical4 l,
00639                 mallocPool pool);
00640 ffebad ffetarget_convert_character1_typeless (ffetargetCharacter1 *res,
00641               ffetargetCharacterSize res_size,
00642                 ffetargetTypeless l,
00643                 mallocPool pool);
00644 ffebad ffetarget_eq_character1 (bool *res, ffetargetCharacter1 l,
00645         ffetargetCharacter1 r);
00646 ffebad ffetarget_le_character1 (bool *res, ffetargetCharacter1 l,
00647         ffetargetCharacter1 r);
00648 ffebad ffetarget_ge_character1 (bool *res, ffetargetCharacter1 l,
00649         ffetargetCharacter1 r);
00650 ffebad ffetarget_gt_character1 (bool *res, ffetargetCharacter1 l,
00651         ffetargetCharacter1 r);
00652 ffebad ffetarget_lt_character1 (bool *res, ffetargetCharacter1 l,
00653         ffetargetCharacter1 r);
00654 ffebad ffetarget_ne_character1 (bool *res, ffetargetCharacter1 l,
00655         ffetargetCharacter1 r);
00656 ffebad ffetarget_substr_character1 (ffetargetCharacter1 *res,
00657             ffetargetCharacter1 l,
00658             ffetargetCharacterSize first,
00659             ffetargetCharacterSize last,
00660             mallocPool pool,
00661             ffetargetCharacterSize *len);
00662 #endif
00663 int ffetarget_cmp_hollerith (ffetargetHollerith l, ffetargetHollerith r);
00664 bool ffetarget_hollerith (ffetargetHollerith *val, ffelexToken hollerith,
00665         mallocPool pool);
00666 int ffetarget_cmp_typeless (ffetargetTypeless l, ffetargetTypeless r);
00667 ffebad ffetarget_convert_any_character1_ (char *res, size_t size,
00668             ffetargetCharacter1 l);
00669 ffebad ffetarget_convert_any_hollerith_ (char *res, size_t size,
00670            ffetargetHollerith l);
00671 ffebad ffetarget_convert_any_typeless_ (char *res, size_t size,
00672           ffetargetTypeless l);
00673 #if FFETARGET_okCOMPLEX1
00674 ffebad ffetarget_divide_complex1 (ffetargetComplex1 *res, ffetargetComplex1 l,
00675           ffetargetComplex1 r);
00676 #endif
00677 #if FFETARGET_okCOMPLEX2
00678 ffebad ffetarget_divide_complex2 (ffetargetComplex2 *res, ffetargetComplex2 l,
00679           ffetargetComplex2 r);
00680 #endif
00681 #if FFETARGET_okCOMPLEX3
00682 ffebad ffetarget_divide_complex3 (ffetargetComplex3 *res, ffetargetComplex3 l,
00683           ffetargetComplex3 r);
00684 #endif
00685 #if FFETARGET_okCOMPLEX4
00686 ffebad ffetarget_divide_complex4 (ffetargetComplex4 *res, ffetargetComplex4 l,
00687           ffetargetComplex4 r);
00688 #endif
00689 #if FFETARGET_okCOMPLEX5
00690 ffebad ffetarget_divide_complex5 (ffetargetComplex5 *res, ffetargetComplex5 l,
00691           ffetargetComplex5 r);
00692 #endif
00693 #if FFETARGET_okCOMPLEX6
00694 ffebad ffetarget_divide_complex6 (ffetargetComplex6 *res, ffetargetComplex6 l,
00695           ffetargetComplex6 r);
00696 #endif
00697 #if FFETARGET_okCOMPLEX7
00698 ffebad ffetarget_divide_complex7 (ffetargetComplex7 *res, ffetargetComplex7 l,
00699           ffetargetComplex7 r);
00700 #endif
00701 #if FFETARGET_okCOMPLEX8
00702 ffebad ffetarget_divide_complex8 (ffetargetComplex8 *res, ffetargetComplex8 l,
00703           ffetargetComplex8 r);
00704 #endif
00705 #if FFETARGET_okINTEGER1
00706 bool ffetarget_integer1 (ffetargetInteger1 *val, ffelexToken integer);
00707 #endif
00708 #if FFETARGET_okINTEGER2
00709 bool ffetarget_integer2 (ffetargetInteger2 *val, ffelexToken integer);
00710 #endif
00711 #if FFETARGET_okINTEGER3
00712 bool ffetarget_integer3 (ffetargetInteger3 *val, ffelexToken integer);
00713 #endif
00714 #if FFETARGET_okINTEGER4
00715 bool ffetarget_integer4 (ffetargetInteger4 *val, ffelexToken integer);
00716 #endif
00717 #if FFETARGET_okINTEGER5
00718 bool ffetarget_integer5 (ffetargetInteger5 *val, ffelexToken integer);
00719 #endif
00720 #if FFETARGET_okINTEGER6
00721 bool ffetarget_integer6 (ffetargetInteger6 *val, ffelexToken integer);
00722 #endif
00723 #if FFETARGET_okINTEGER7
00724 bool ffetarget_integer7 (ffetargetInteger7 *val, ffelexToken integer);
00725 #endif
00726 #if FFETARGET_okINTEGER8
00727 bool ffetarget_integer8 (ffetargetInteger8 *val, ffelexToken integer);
00728 #endif
00729 bool ffetarget_integerbinary (ffetargetIntegerDefault *val,
00730            ffelexToken integer);
00731 bool ffetarget_integerhex (ffetargetIntegerDefault *val,
00732            ffelexToken integer);
00733 bool ffetarget_integeroctal (ffetargetIntegerDefault *val,
00734            ffelexToken integer);
00735 void ffetarget_integer_bad_magical (ffelexToken t);
00736 void ffetarget_integer_bad_magical_binary (ffelexToken integer, ffelexToken minus);
00737 void ffetarget_integer_bad_magical_precedence (ffelexToken integer,
00738                  ffelexToken uminus,
00739                  ffelexToken higher_op);
00740 void ffetarget_integer_bad_magical_precedence_binary (ffelexToken integer,
00741                   ffelexToken minus,
00742                   ffelexToken higher_op);
00743 #if FFETARGET_okCHARACTER1
00744 bool ffetarget_iszero_character1 (ffetargetCharacter1 constant);
00745 #endif
00746 bool ffetarget_iszero_hollerith (ffetargetHollerith constant);
00747 void ffetarget_layout (const char *error_text, ffetargetAlign *alignment,
00748            ffetargetAlign *modulo, ffetargetOffset *size,
00749            ffeinfoBasictype bt, ffeinfoKindtype kt,
00750            ffetargetCharacterSize charsize,
00751            ffetargetIntegerDefault num_elements);
00752 #if FFETARGET_okCOMPLEX1
00753 ffebad ffetarget_multiply_complex1 (ffetargetComplex1 *res,
00754             ffetargetComplex1 l,
00755             ffetargetComplex1 r);
00756 #endif
00757 #if FFETARGET_okCOMPLEX2
00758 ffebad ffetarget_multiply_complex2 (ffetargetComplex2 *res,
00759             ffetargetComplex2 l,
00760             ffetargetComplex2 r);
00761 #endif
00762 #if FFETARGET_okCOMPLEX3
00763 ffebad ffetarget_multiply_complex3 (ffetargetComplex3 *res,
00764             ffetargetComplex3 l,
00765             ffetargetComplex3 r);
00766 #endif
00767 #if FFETARGET_okCOMPLEX4
00768 ffebad ffetarget_multiply_complex4 (ffetargetComplex4 *res,
00769             ffetargetComplex4 l,
00770             ffetargetComplex4 r);
00771 #endif
00772 #if FFETARGET_okCOMPLEX5
00773 ffebad ffetarget_multiply_complex5 (ffetargetComplex5 *res,
00774             ffetargetComplex5 l,
00775             ffetargetComplex5 r);
00776 #endif
00777 #if FFETARGET_okCOMPLEX6
00778 ffebad ffetarget_multiply_complex6 (ffetargetComplex6 *res,
00779             ffetargetComplex6 l,
00780             ffetargetComplex6 r);
00781 #endif
00782 #if FFETARGET_okCOMPLEX7
00783 ffebad ffetarget_multiply_complex7 (ffetargetComplex7 *res,
00784             ffetargetComplex7 l,
00785             ffetargetComplex7 r);
00786 #endif
00787 #if FFETARGET_okCOMPLEX8
00788 ffebad ffetarget_multiply_complex8 (ffetargetComplex8 *res,
00789             ffetargetComplex8 l,
00790             ffetargetComplex8 r);
00791 #endif
00792 ffebad ffetarget_power_complexdefault_integerdefault (ffetargetComplexDefault *res,
00793               ffetargetComplexDefault l,
00794              ffetargetIntegerDefault r);
00795 #if FFETARGET_okCOMPLEXDOUBLE
00796 ffebad ffetarget_power_complexdouble_integerdefault (ffetargetComplexDouble *res,
00797                ffetargetComplexDouble l,
00798              ffetargetIntegerDefault r);
00799 #endif
00800 ffebad ffetarget_power_integerdefault_integerdefault (ffetargetIntegerDefault *res,
00801               ffetargetIntegerDefault l,
00802              ffetargetIntegerDefault r);
00803 ffebad ffetarget_power_realdefault_integerdefault (ffetargetRealDefault *res,
00804                ffetargetRealDefault l,
00805              ffetargetIntegerDefault r);
00806 ffebad ffetarget_power_realdouble_integerdefault (ffetargetRealDouble *res,
00807               ffetargetRealDouble l,
00808               ffetargetIntegerDefault r);
00809 void ffetarget_print_binary (FILE *f, ffetargetTypeless val);
00810 void ffetarget_print_character1 (FILE *f, ffetargetCharacter1 val);
00811 void ffetarget_print_hollerith (FILE *f, ffetargetHollerith val);
00812 void ffetarget_print_octal (FILE *f, ffetargetTypeless val);
00813 void ffetarget_print_hex (FILE *f, ffetargetTypeless val);
00814 #if FFETARGET_okREAL1
00815 bool ffetarget_real1 (ffetargetReal1 *value, ffelexToken integer,
00816           ffelexToken decimal, ffelexToken fraction,
00817           ffelexToken exponent, ffelexToken exponent_sign,
00818           ffelexToken exponent_digits);
00819 #endif
00820 #if FFETARGET_okREAL2
00821 bool ffetarget_real2 (ffetargetReal2 *value, ffelexToken integer,
00822           ffelexToken decimal, ffelexToken fraction,
00823           ffelexToken exponent, ffelexToken exponent_sign,
00824           ffelexToken exponent_digits);
00825 #endif
00826 #if FFETARGET_okREAL3
00827 bool ffetarget_real3 (ffetargetReal3 *value, ffelexToken integer,
00828           ffelexToken decimal, ffelexToken fraction,
00829           ffelexToken exponent, ffelexToken exponent_sign,
00830           ffelexToken exponent_digits);
00831 #endif
00832 #if FFETARGET_okREAL4
00833 bool ffetarget_real4 (ffetargetReal4 *value, ffelexToken integer,
00834           ffelexToken decimal, ffelexToken fraction,
00835           ffelexToken exponent, ffelexToken exponent_sign,
00836           ffelexToken exponent_digits);
00837 #endif
00838 #if FFETARGET_okREAL5
00839 bool ffetarget_real5 (ffetargetReal5 *value, ffelexToken integer,
00840           ffelexToken decimal, ffelexToken fraction,
00841           ffelexToken exponent, ffelexToken exponent_sign,
00842           ffelexToken exponent_digits);
00843 #endif
00844 #if FFETARGET_okREAL6
00845 bool ffetarget_real6 (ffetargetReal6 *value, ffelexToken integer,
00846           ffelexToken decimal, ffelexToken fraction,
00847           ffelexToken exponent, ffelexToken exponent_sign,
00848           ffelexToken exponent_digits);
00849 #endif
00850 #if FFETARGET_okREAL7
00851 bool ffetarget_real7 (ffetargetReal7 *value, ffelexToken integer,
00852           ffelexToken decimal, ffelexToken fraction,
00853           ffelexToken exponent, ffelexToken exponent_sign,
00854           ffelexToken exponent_digits);
00855 #endif
00856 #if FFETARGET_okREAL8
00857 bool ffetarget_real8 (ffetargetReal8 *value, ffelexToken integer,
00858           ffelexToken decimal, ffelexToken fraction,
00859           ffelexToken exponent, ffelexToken exponent_sign,
00860           ffelexToken exponent_digits);
00861 #endif
00862 bool ffetarget_typeless_binary (ffetargetTypeless *value, ffelexToken token);
00863 bool ffetarget_typeless_octal (ffetargetTypeless *value, ffelexToken token);
00864 bool ffetarget_typeless_hex (ffetargetTypeless *value, ffelexToken token);
00865 void ffetarget_verify_character1 (mallocPool pool, ffetargetCharacter1 val);
00866 int ffetarget_num_digits_ (ffelexToken t);
00867 void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
00868 
00869 /* Define macros. */
00870 
00871 #define FFETARGET_REAL_VALUE_FROM_INT_(resr, lf, kt)      \
00872   REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0), \
00873            ((kt == 1) ? SFmode : DFmode))
00874 
00875 #ifdef REAL_ARITHMETIC
00876 #define ffetarget_add_complex1(res,l,r) \
00877   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
00878      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
00879      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
00880      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
00881      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
00882      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
00883      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
00884      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
00885      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
00886      FFEBAD; })
00887 #define ffetarget_add_complex2(res,l,r) \
00888   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
00889      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
00890      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
00891      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
00892      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
00893      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
00894      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
00895      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
00896      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
00897      FFEBAD; })
00898 #else
00899 #define ffetarget_add_complex1(res,l,r) \
00900   ((res)->real = (l).real + (r).real, \
00901    (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
00902 #define ffetarget_add_complex2(res,l,r) \
00903   ((res)->real = (l).real + (r).real, \
00904    (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
00905 #endif
00906 #define ffetarget_add_integer1(res,l,r) (*(res) = (l) + (r), FFEBAD)
00907 #define ffetarget_add_integer2(res,l,r) (*(res) = (l) + (r), FFEBAD)
00908 #define ffetarget_add_integer3(res,l,r) (*(res) = (l) + (r), FFEBAD)
00909 #define ffetarget_add_integer4(res,l,r) (*(res) = (l) + (r), FFEBAD)
00910 #ifdef REAL_ARITHMETIC
00911 #define ffetarget_add_real1(res,l,r) \
00912   ({ REAL_VALUE_TYPE lr, rr, resr; \
00913      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
00914      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
00915      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
00916      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
00917      FFEBAD; })
00918 #define ffetarget_add_real2(res,l,r) \
00919   ({ REAL_VALUE_TYPE lr, rr, resr; \
00920      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
00921      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
00922      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
00923      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
00924      FFEBAD; })
00925 #else
00926 #define ffetarget_add_real1(res,l,r) (*(res) = (l) + (r), FFEBAD)
00927 #define ffetarget_add_real2(res,l,r) (*(res) = (l) + (r), FFEBAD)
00928 #endif
00929 #define ffetarget_aggregate_ptr_memcpy(dbt,dkt,sbt,skt) \
00930   ((ffetargetCopyfunc) ffetarget_memcpy_)
00931 #define ffetarget_and_integer1(res,l,r) (*(res) = (l) & (r), FFEBAD)
00932 #define ffetarget_and_integer2(res,l,r) (*(res) = (l) & (r), FFEBAD)
00933 #define ffetarget_and_integer3(res,l,r) (*(res) = (l) & (r), FFEBAD)
00934 #define ffetarget_and_integer4(res,l,r) (*(res) = (l) & (r), FFEBAD)
00935 #define ffetarget_and_logical1(res,l,r) (*(res) = (l) && (r), FFEBAD)
00936 #define ffetarget_and_logical2(res,l,r) (*(res) = (l) && (r), FFEBAD)
00937 #define ffetarget_and_logical3(res,l,r) (*(res) = (l) && (r), FFEBAD)
00938 #define ffetarget_and_logical4(res,l,r) (*(res) = (l) && (r), FFEBAD)
00939 #define ffetarget_binarymil(v,t) ffetarget_typeless_binary (v, t)
00940 #define ffetarget_binaryvxt(v,t) ffetarget_typeless_binary (v, t)
00941 #define ffetarget_cmp_integer1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00942 #define ffetarget_cmp_integer2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00943 #define ffetarget_cmp_integer3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00944 #define ffetarget_cmp_integer4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00945 #define ffetarget_cmp_logical1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00946 #define ffetarget_cmp_logical2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00947 #define ffetarget_cmp_logical3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00948 #define ffetarget_cmp_logical4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
00949 #define ffetarget_cmp_real1(l,r) memcmp (&(l), &(r), sizeof(l))
00950 #define ffetarget_cmp_real2(l,r) memcmp (&(l), &(r), sizeof(l))
00951 #define ffetarget_cmp_real3(l,r) memcmp (&(l), &(r), sizeof(l))
00952 #define ffetarget_cmp_typeless(l,r) \
00953   memcmp (&(l), &(r), sizeof ((l)))
00954 #define ffetarget_convert_character1_integer1(res,res_size,l,pool) \
00955         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
00956 #define ffetarget_convert_character1_integer2(res,res_size,l,pool) \
00957         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
00958 #define ffetarget_convert_character1_integer3(res,res_size,l,pool) \
00959         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
00960 #define ffetarget_convert_character1_logical1(res,res_size,l,pool) \
00961         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
00962 #define ffetarget_convert_character1_logical2(res,res_size,l,pool) \
00963         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
00964 #define ffetarget_convert_character1_logical3(res,res_size,l,pool) \
00965         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
00966 #define ffetarget_convert_complex1_character1(res,l) \
00967   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
00968 #define ffetarget_convert_complex1_hollerith(res,l) \
00969   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
00970 #define ffetarget_convert_complex1_typeless(res,l) \
00971   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
00972 #ifdef REAL_ARITHMETIC
00973 #define ffetarget_convert_complex1_complex2(res,l) \
00974   ({ REAL_VALUE_TYPE lr, li; \
00975      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
00976      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
00977      ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
00978      ffetarget_cvt_rv_to_r1_ (li, (res)->imaginary), \
00979      FFEBAD; })
00980 #else
00981 #define ffetarget_convert_complex1_complex2(res,l) \
00982   ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
00983 #endif
00984 #ifdef REAL_ARITHMETIC
00985 #define ffetarget_convert_complex1_integer(res,l) \
00986   ({ REAL_VALUE_TYPE resi, resr; \
00987      ffetargetInteger1 lf = (l); \
00988      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \
00989      resi = dconst0; \
00990      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
00991      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
00992      FFEBAD; })
00993 #else
00994 #define ffetarget_convert_complex1_integer(res,l) \
00995   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
00996 #endif
00997 #define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer
00998 #define ffetarget_convert_complex1_integer2 ffetarget_convert_complex1_integer
00999 #define ffetarget_convert_complex1_integer3 ffetarget_convert_complex1_integer
01000 #ifdef REAL_ARITHMETIC
01001 #define ffetarget_convert_complex1_integer4(res,l) FFEBAD_NOCANDO
01002 #else
01003 #define ffetarget_convert_complex1_integer4 ffetarget_convert_complex1_integer
01004 #endif
01005 #ifdef REAL_ARITHMETIC
01006 #define ffetarget_convert_complex1_real1(res,l) \
01007   ((res)->real = (l), \
01008    ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
01009    FFEBAD)
01010 #define ffetarget_convert_complex1_real2(res,l) \
01011   ({ REAL_VALUE_TYPE lr; \
01012      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01013      ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
01014      ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
01015      FFEBAD; })
01016 #else
01017 #define ffetarget_convert_complex1_real1(res,l) \
01018   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
01019 #define ffetarget_convert_complex1_real2(res,l) \
01020   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
01021 #endif
01022 #define ffetarget_convert_complex2_character1(res,l) \
01023   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01024 #define ffetarget_convert_complex2_hollerith(res,l) \
01025   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01026 #define ffetarget_convert_complex2_typeless(res,l) \
01027   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01028 #ifdef REAL_ARITHMETIC
01029 #define ffetarget_convert_complex2_complex1(res,l) \
01030   ({ REAL_VALUE_TYPE lr, li; \
01031      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01032      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
01033      ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \
01034      ffetarget_cvt_rv_to_r2_ (li, &((res)->imaginary.v[0])), \
01035      FFEBAD; })
01036 #else
01037 #define ffetarget_convert_complex2_complex1(res,l) \
01038   ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
01039 #endif
01040 #ifdef REAL_ARITHMETIC
01041 #define ffetarget_convert_complex2_integer(res,l) \
01042   ({ REAL_VALUE_TYPE resi, resr; \
01043      ffetargetInteger1 lf = (l); \
01044      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \
01045      resi = dconst0; \
01046      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
01047      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
01048      FFEBAD; })
01049 #else
01050 #define ffetarget_convert_complex2_integer(res,l) \
01051   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
01052 #endif
01053 #define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer
01054 #define ffetarget_convert_complex2_integer2 ffetarget_convert_complex2_integer
01055 #define ffetarget_convert_complex2_integer3 ffetarget_convert_complex2_integer
01056 #ifdef REAL_ARITHMETIC
01057 #define ffetarget_convert_complex2_integer4(res,l) FFEBAD_NOCANDO
01058 #else
01059 #define ffetarget_convert_complex2_integer4 ffetarget_convert_complex2_integer
01060 #endif
01061 #ifdef REAL_ARITHMETIC
01062 #define ffetarget_convert_complex2_real1(res,l) \
01063   ({ REAL_VALUE_TYPE lr; \
01064      lr = ffetarget_cvt_r1_to_rv_ (l); \
01065      ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \
01066      ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \
01067      FFEBAD; })
01068 #define ffetarget_convert_complex2_real2(res,l) \
01069   ((res)->real = (l), \
01070    ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \
01071    FFEBAD)
01072 #else
01073 #define ffetarget_convert_complex2_real1(res,l) \
01074   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
01075 #define ffetarget_convert_complex2_real2(res,l) \
01076   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
01077 #endif
01078 #define ffetarget_convert_integer2_character1(res,l) \
01079         ffetarget_convert_integer1_character1(res,l)
01080 #define ffetarget_convert_integer2_complex1(res,l) \
01081         ffetarget_convert_integer1_complex1(res,l)
01082 #define ffetarget_convert_integer2_complex2(res,l) \
01083         ffetarget_convert_integer1_complex2(res,l)
01084 #define ffetarget_convert_integer2_hollerith(res,l) \
01085         ffetarget_convert_integer1_hollerith(res,l)
01086 #define ffetarget_convert_integer2_integer1(res,l) (*(res) = (l), FFEBAD)
01087 #define ffetarget_convert_integer2_integer3(res,l) (*(res) = (l), FFEBAD)
01088 #define ffetarget_convert_integer2_integer4(res,l) (*(res) = (l), FFEBAD)
01089 #define ffetarget_convert_integer2_logical1(res,l) \
01090         ffetarget_convert_integer1_logical1(res,l)
01091 #define ffetarget_convert_integer2_logical2(res,l) \
01092         ffetarget_convert_integer2_logical1(res,l)
01093 #define ffetarget_convert_integer2_logical3(res,l) \
01094         ffetarget_convert_integer2_logical1(res,l)
01095 #define ffetarget_convert_integer2_logical4(res,l) \
01096         ffetarget_convert_integer2_logical1(res,l)
01097 #define ffetarget_convert_integer2_real1(res,l) \
01098         ffetarget_convert_integer1_real1(res,l)
01099 #define ffetarget_convert_integer2_real2(res,l) \
01100         ffetarget_convert_integer1_real2(res,l)
01101 #define ffetarget_convert_integer2_typeless(res,l) \
01102         ffetarget_convert_integer1_typeless(res,l)
01103 #define ffetarget_convert_integer3_character1(res,l) \
01104         ffetarget_convert_integer1_character1(res,l)
01105 #define ffetarget_convert_integer3_complex1(res,l) \
01106         ffetarget_convert_integer1_complex1(res,l)
01107 #define ffetarget_convert_integer3_complex2(res,l) \
01108         ffetarget_convert_integer1_complex2(res,l)
01109 #define ffetarget_convert_integer3_hollerith(res,l) \
01110         ffetarget_convert_integer1_hollerith(res,l)
01111 #define ffetarget_convert_integer3_integer1(res,l) (*(res) = (l), FFEBAD)
01112 #define ffetarget_convert_integer3_integer2(res,l) (*(res) = (l), FFEBAD)
01113 #define ffetarget_convert_integer3_integer4(res,l) (*(res) = (l), FFEBAD)
01114 #define ffetarget_convert_integer3_logical1(res,l) \
01115         ffetarget_convert_integer1_logical1(res,l)
01116 #define ffetarget_convert_integer3_logical2(res,l) \
01117         ffetarget_convert_integer3_logical1(res,l)
01118 #define ffetarget_convert_integer3_logical3(res,l) \
01119         ffetarget_convert_integer3_logical1(res,l)
01120 #define ffetarget_convert_integer3_logical4(res,l) \
01121         ffetarget_convert_integer3_logical1(res,l)
01122 #define ffetarget_convert_integer3_real1(res,l) \
01123         ffetarget_convert_integer1_real1(res,l)
01124 #define ffetarget_convert_integer3_real2(res,l) \
01125         ffetarget_convert_integer1_real2(res,l)
01126 #define ffetarget_convert_integer3_typeless(res,l) \
01127         ffetarget_convert_integer1_typeless(res,l)
01128 #define ffetarget_convert_integer4_character1(res,l) \
01129         ffetarget_convert_integer1_character1(res,l)
01130 #ifdef REAL_ARITHMETIC
01131 #define ffetarget_convert_integer4_complex1(res,l) FFEBAD_NOCANDO
01132 #define ffetarget_convert_integer4_complex2(res,l) FFEBAD_NOCANDO
01133 #else
01134 #define ffetarget_convert_integer4_complex1(res,l) \
01135         ffetarget_convert_integer1_complex1(res,l)
01136 #define ffetarget_convert_integer4_complex2(res,l) \
01137         ffetarget_convert_integer1_complex2(res,l)
01138 #endif
01139 #define ffetarget_convert_integer4_hollerith(res,l) \
01140         ffetarget_convert_integer1_hollerith(res,l)
01141 #define ffetarget_convert_integer4_integer1(res,l) (*(res) = (l), FFEBAD)
01142 #define ffetarget_convert_integer4_integer2(res,l) (*(res) = (l), FFEBAD)
01143 #define ffetarget_convert_integer4_integer3(res,l) (*(res) = (l), FFEBAD)
01144 #define ffetarget_convert_integer4_logical1(res,l) \
01145         ffetarget_convert_integer1_logical1(res,l)
01146 #define ffetarget_convert_integer4_logical2(res,l) \
01147         ffetarget_convert_integer1_logical1(res,l)
01148 #define ffetarget_convert_integer4_logical3(res,l) \
01149         ffetarget_convert_integer1_logical1(res,l)
01150 #define ffetarget_convert_integer4_logical4(res,l) \
01151         ffetarget_convert_integer1_logical1(res,l)
01152 #ifdef REAL_ARITHMETIC
01153 #define ffetarget_convert_integer4_real1(res,l) FFEBAD_NOCANDO
01154 #define ffetarget_convert_integer4_real2(res,l) FFEBAD_NOCANDO
01155 #else
01156 #define ffetarget_convert_integer4_real1(res,l) \
01157         ffetarget_convert_integer1_real1(res,l)
01158 #define ffetarget_convert_integer4_real2(res,l) \
01159         ffetarget_convert_integer1_real2(res,l)
01160 #endif
01161 #define ffetarget_convert_integer4_typeless(res,l) \
01162         ffetarget_convert_integer1_typeless(res,l)
01163 #define ffetarget_convert_logical1_character1(res,l) \
01164   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01165 #define ffetarget_convert_logical1_hollerith(res,l) \
01166   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01167 #define ffetarget_convert_logical1_typeless(res,l) \
01168   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01169 #define ffetarget_convert_logical1_logical2(res,l) (*(res) = (l), FFEBAD)
01170 #define ffetarget_convert_logical1_logical3(res,l) (*(res) = (l), FFEBAD)
01171 #define ffetarget_convert_logical1_logical4(res,l) (*(res) = (l), FFEBAD)
01172 #define ffetarget_convert_logical1_integer1(res,l) (*(res) = (l), FFEBAD)
01173 #define ffetarget_convert_logical1_integer2(res,l) (*(res) = (l), FFEBAD)
01174 #define ffetarget_convert_logical1_integer3(res,l) (*(res) = (l), FFEBAD)
01175 #define ffetarget_convert_logical1_integer4(res,l) (*(res) = (l), FFEBAD)
01176 #define ffetarget_convert_logical2_character1(res,l) \
01177   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01178 #define ffetarget_convert_logical2_hollerith(res,l) \
01179   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01180 #define ffetarget_convert_logical2_typeless(res,l) \
01181   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01182 #define ffetarget_convert_logical2_logical1(res,l) (*(res) = (l), FFEBAD)
01183 #define ffetarget_convert_logical2_logical3(res,l) (*(res) = (l), FFEBAD)
01184 #define ffetarget_convert_logical2_logical4(res,l) (*(res) = (l), FFEBAD)
01185 #define ffetarget_convert_logical2_integer1(res,l) (*(res) = (l), FFEBAD)
01186 #define ffetarget_convert_logical2_integer2(res,l) (*(res) = (l), FFEBAD)
01187 #define ffetarget_convert_logical2_integer3(res,l) (*(res) = (l), FFEBAD)
01188 #define ffetarget_convert_logical2_integer4(res,l) (*(res) = (l), FFEBAD)
01189 #define ffetarget_convert_logical3_character1(res,l) \
01190   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01191 #define ffetarget_convert_logical3_hollerith(res,l) \
01192   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01193 #define ffetarget_convert_logical3_typeless(res,l) \
01194   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01195 #define ffetarget_convert_logical3_logical1(res,l) (*(res) = (l), FFEBAD)
01196 #define ffetarget_convert_logical3_logical2(res,l) (*(res) = (l), FFEBAD)
01197 #define ffetarget_convert_logical3_logical4(res,l) (*(res) = (l), FFEBAD)
01198 #define ffetarget_convert_logical3_integer1(res,l) (*(res) = (l), FFEBAD)
01199 #define ffetarget_convert_logical3_integer2(res,l) (*(res) = (l), FFEBAD)
01200 #define ffetarget_convert_logical3_integer3(res,l) (*(res) = (l), FFEBAD)
01201 #define ffetarget_convert_logical3_integer4(res,l) (*(res) = (l), FFEBAD)
01202 #define ffetarget_convert_logical4_character1(res,l) \
01203   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01204 #define ffetarget_convert_logical4_hollerith(res,l) \
01205   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01206 #define ffetarget_convert_logical4_typeless(res,l) \
01207   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01208 #define ffetarget_convert_logical4_logical1(res,l) (*(res) = (l), FFEBAD)
01209 #define ffetarget_convert_logical4_logical2(res,l) (*(res) = (l), FFEBAD)
01210 #define ffetarget_convert_logical4_logical3(res,l) (*(res) = (l), FFEBAD)
01211 #define ffetarget_convert_logical4_integer1(res,l) (*(res) = (l), FFEBAD)
01212 #define ffetarget_convert_logical4_integer2(res,l) (*(res) = (l), FFEBAD)
01213 #define ffetarget_convert_logical4_integer3(res,l) (*(res) = (l), FFEBAD)
01214 #define ffetarget_convert_logical4_integer4(res,l) (*(res) = (l), FFEBAD)
01215 #define ffetarget_convert_integer1_character1(res,l) \
01216   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01217 #define ffetarget_convert_integer1_hollerith(res,l) \
01218   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01219 #define ffetarget_convert_integer1_typeless(res,l) \
01220   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01221 #define ffetarget_convert_integer1_integer2(res,l) (*(res) = (l), FFEBAD)
01222 #define ffetarget_convert_integer1_integer3(res,l) (*(res) = (l), FFEBAD)
01223 #define ffetarget_convert_integer1_integer4(res,l) (*(res) = (l), FFEBAD)
01224 #define ffetarget_convert_integer1_logical1(res,l) (*(res) = (l), FFEBAD)
01225 #define ffetarget_convert_integer1_logical2(res,l) (*(res) = (l), FFEBAD)
01226 #define ffetarget_convert_integer1_logical3(res,l) (*(res) = (l), FFEBAD)
01227 #define ffetarget_convert_integer1_logical4(res,l) (*(res) = (l), FFEBAD)
01228 #ifdef REAL_ARITHMETIC
01229 #define ffetarget_convert_integer1_real1(res,l) \
01230   ({ REAL_VALUE_TYPE lr; \
01231      lr = ffetarget_cvt_r1_to_rv_ (l); \
01232      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
01233      *(res) = ffetarget_long_val_; \
01234      FFEBAD; })
01235 #define ffetarget_convert_integer1_real2(res,l) \
01236   ({ REAL_VALUE_TYPE lr; \
01237      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01238      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
01239      *(res) = ffetarget_long_val_; \
01240      FFEBAD; })
01241 #define ffetarget_convert_integer1_complex1(res,l) \
01242   ({ REAL_VALUE_TYPE lr; \
01243      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01244      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
01245      *(res) = ffetarget_long_val_; \
01246      FFEBAD; })
01247 #define ffetarget_convert_integer1_complex2(res,l) \
01248   ({ REAL_VALUE_TYPE lr; \
01249      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
01250      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
01251      *(res) = ffetarget_long_val_; \
01252      FFEBAD; })
01253 #else
01254 #define ffetarget_convert_integer1_real1(res,l) (*(res) = (l), FFEBAD)
01255 #define ffetarget_convert_integer1_real2(res,l) (*(res) = (l), FFEBAD)
01256 #define ffetarget_convert_integer1_complex1(res,l) (*(res) = (l).real, FFEBAD)
01257 #define ffetarget_convert_integer1_complex2(res,l) (*(res) = (l).real, FFEBAD)
01258 #endif
01259 #define ffetarget_convert_real1_character1(res,l) \
01260   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01261 #define ffetarget_convert_real1_hollerith(res,l) \
01262   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01263 #define ffetarget_convert_real1_integer2(res,l) \
01264         ffetarget_convert_real1_integer1(res,l)
01265 #define ffetarget_convert_real1_integer3(res,l) \
01266         ffetarget_convert_real1_integer1(res,l)
01267 #ifdef REAL_ARITHMETIC
01268 #define ffetarget_convert_real1_integer4(res,l) FFEBAD_NOCANDO
01269 #else
01270 #define ffetarget_convert_real1_integer4(res,l) \
01271         ffetarget_convert_real1_integer1(res,l)
01272 #endif
01273 #define ffetarget_convert_real1_typeless(res,l) \
01274   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01275 #define ffetarget_convert_real1_complex1(res,l) (*(res) = (l).real, FFEBAD)
01276 #define ffetarget_convert_real1_complex2(res,l) \
01277   ffetarget_convert_real1_real2 ((res), (l).real)
01278 #ifdef REAL_ARITHMETIC
01279 #define ffetarget_convert_real1_integer1(res,l) \
01280   ({ REAL_VALUE_TYPE resr; \
01281      ffetargetInteger1 lf = (l); \
01282      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \
01283      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
01284      FFEBAD; })
01285 #else
01286 #define ffetarget_convert_real1_integer1(res,l) (*(res) = (l), FFEBAD)
01287 #endif
01288 #ifdef REAL_ARITHMETIC
01289 #define ffetarget_convert_real1_real2(res,l) \
01290   ({ REAL_VALUE_TYPE lr; \
01291      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01292      ffetarget_cvt_rv_to_r1_ (lr, *(res)); \
01293      FFEBAD; })
01294 #else
01295 #define ffetarget_convert_real1_real2(res,l) (*(res) = (l), FFEBAD)
01296 #endif
01297 #define ffetarget_convert_real2_character1(res,l) \
01298   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
01299 #define ffetarget_convert_real2_hollerith(res,l) \
01300   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
01301 #define ffetarget_convert_real2_integer2(res,l) \
01302         ffetarget_convert_real2_integer1(res,l)
01303 #define ffetarget_convert_real2_integer3(res,l) \
01304         ffetarget_convert_real2_integer1(res,l)
01305 #ifdef REAL_ARITHMETIC
01306 #define ffetarget_convert_real2_integer4(res,l) FFEBAD_NOCANDO
01307 #else
01308 #define ffetarget_convert_real2_integer4(res,l) \
01309         ffetarget_convert_real2_integer1(res,l)
01310 #endif
01311 #define ffetarget_convert_real2_typeless(res,l) \
01312   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
01313 #define ffetarget_convert_real2_complex1(res,l) \
01314   ffetarget_convert_real2_real1 ((res), (l).real)
01315 #define ffetarget_convert_real2_complex2(res,l) (*(res) = (l).real, FFEBAD)
01316 #ifdef REAL_ARITHMETIC
01317 #define ffetarget_convert_real2_integer(res,l) \
01318   ({ REAL_VALUE_TYPE resr; \
01319      ffetargetInteger1 lf = (l); \
01320      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \
01321      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
01322      FFEBAD; })
01323 #define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer
01324 #else
01325 #define ffetarget_convert_real2_integer1(res,l) (*(res) = (l), FFEBAD)
01326 #endif
01327 #ifdef REAL_ARITHMETIC
01328 #define ffetarget_convert_real2_real1(res,l) \
01329   ({ REAL_VALUE_TYPE lr; \
01330      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01331      ffetarget_cvt_rv_to_r2_ (lr, &((res)->v[0])); \
01332      FFEBAD; })
01333 #else
01334 #define ffetarget_convert_real2_real1(res,l) (*(res) = (l), FFEBAD)
01335 #endif
01336 #define ffetarget_divide_integer1(res,l,r) \
01337   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
01338    : (*(res) = (l) / (r), FFEBAD))
01339 #define ffetarget_divide_integer2(res,l,r) \
01340         ffetarget_divide_integer1(res,l,r)
01341 #define ffetarget_divide_integer3(res,l,r) \
01342         ffetarget_divide_integer1(res,l,r)
01343 #define ffetarget_divide_integer4(res,l,r) \
01344         ffetarget_divide_integer1(res,l,r)
01345 #ifdef REAL_ARITHMETIC
01346 #define ffetarget_divide_real1(res,l,r) \
01347   ({ REAL_VALUE_TYPE lr, rr, resr; \
01348      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01349      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01350      REAL_VALUES_EQUAL (rr, dconst0) \
01351        ? ({ ffetarget_cvt_rv_to_r1_ (dconst0, *(res)); \
01352       FFEBAD_DIV_BY_ZERO; \
01353     }) \
01354    : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
01355         ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
01356         FFEBAD; \
01357       }); \
01358    })
01359 #define ffetarget_divide_real2(res,l,r) \
01360   ({ REAL_VALUE_TYPE lr, rr, resr; \
01361      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01362      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01363      REAL_VALUES_EQUAL (rr, dconst0) \
01364        ? ({ ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0])); \
01365       FFEBAD_DIV_BY_ZERO; \
01366     }) \
01367    : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
01368         ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
01369         FFEBAD; \
01370       }); \
01371    })
01372 #else
01373 #define ffetarget_divide_real1(res,l,r) \
01374   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
01375    : (*(res) = (l) / (r), FFEBAD))
01376 #define ffetarget_divide_real2(res,l,r) \
01377   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
01378    : (*(res) = (l) / (r), FFEBAD))
01379 #endif
01380 #ifdef REAL_ARITHMETIC
01381 #define ffetarget_eq_complex1(res,l,r) \
01382   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
01383      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01384      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
01385      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
01386      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
01387      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
01388        ? TRUE : FALSE; \
01389      FFEBAD; })
01390 #define ffetarget_eq_complex2(res,l,r) \
01391   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
01392      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
01393      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
01394      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
01395      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
01396      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
01397        ? TRUE : FALSE; \
01398      FFEBAD; })
01399 #else
01400 #define ffetarget_eq_complex1(res,l,r) \
01401   (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
01402    ? TRUE : FALSE, FFEBAD)
01403 #define ffetarget_eq_complex2(res,l,r) \
01404   (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
01405    ? TRUE : FALSE, FFEBAD)
01406 #endif
01407 #define ffetarget_eq_integer1(res,l,r) \
01408   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01409 #define ffetarget_eq_integer2(res,l,r) \
01410   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01411 #define ffetarget_eq_integer3(res,l,r) \
01412   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01413 #define ffetarget_eq_integer4(res,l,r) \
01414   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01415 #ifdef REAL_ARITHMETIC
01416 #define ffetarget_eq_real1(res,l,r) \
01417   ({ REAL_VALUE_TYPE lr, rr; \
01418      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01419      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01420      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
01421      FFEBAD; })
01422 #define ffetarget_eq_real2(res,l,r) \
01423   ({ REAL_VALUE_TYPE lr, rr; \
01424      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01425      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01426      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
01427      FFEBAD; })
01428 #else
01429 #define ffetarget_eq_real1(res,l,r) \
01430   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01431 #define ffetarget_eq_real2(res,l,r) \
01432   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
01433 #endif
01434 #define ffetarget_eqv_integer1(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
01435 #define ffetarget_eqv_integer2(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
01436 #define ffetarget_eqv_integer3(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
01437 #define ffetarget_eqv_integer4(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
01438 #define ffetarget_eqv_logical1(res,l,r) (*(res) = (l) == (r), FFEBAD)
01439 #define ffetarget_eqv_logical2(res,l,r) (*(res) = (l) == (r), FFEBAD)
01440 #define ffetarget_eqv_logical3(res,l,r) (*(res) = (l) == (r), FFEBAD)
01441 #define ffetarget_eqv_logical4(res,l,r) (*(res) = (l) == (r), FFEBAD)
01442 #define ffetarget_ge_integer1(res,l,r) \
01443   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01444 #define ffetarget_ge_integer2(res,l,r) \
01445   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01446 #define ffetarget_ge_integer3(res,l,r) \
01447   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01448 #define ffetarget_ge_integer4(res,l,r) \
01449   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01450 #ifdef REAL_ARITHMETIC
01451 #define ffetarget_ge_real1(res,l,r) \
01452   ({ REAL_VALUE_TYPE lr, rr; \
01453      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01454      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01455      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
01456      FFEBAD; })
01457 #define ffetarget_ge_real2(res,l,r) \
01458   ({ REAL_VALUE_TYPE lr, rr; \
01459      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01460      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01461      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
01462      FFEBAD; })
01463 #else
01464 #define ffetarget_ge_real1(res,l,r) \
01465   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01466 #define ffetarget_ge_real2(res,l,r) \
01467   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
01468 #endif
01469 #define ffetarget_gt_integer1(res,l,r) \
01470   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01471 #define ffetarget_gt_integer2(res,l,r) \
01472   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01473 #define ffetarget_gt_integer3(res,l,r) \
01474   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01475 #define ffetarget_gt_integer4(res,l,r) \
01476   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01477 #ifdef REAL_ARITHMETIC
01478 #define ffetarget_gt_real1(res,l,r) \
01479   ({ REAL_VALUE_TYPE lr, rr; \
01480      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01481      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01482      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
01483        ? FALSE : TRUE; \
01484      FFEBAD; })
01485 #define ffetarget_gt_real2(res,l,r) \
01486   ({ REAL_VALUE_TYPE lr, rr; \
01487      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01488      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01489      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
01490        ? FALSE : TRUE; \
01491      FFEBAD; })
01492 #else
01493 #define ffetarget_gt_real1(res,l,r) \
01494   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01495 #define ffetarget_gt_real2(res,l,r) \
01496   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
01497 #endif
01498 #define ffetarget_hexxmil(v,t) ffetarget_typeless_hex (v, t)
01499 #define ffetarget_hexxvxt(v,t) ffetarget_typeless_hex (v, t)
01500 #define ffetarget_hexzmil(v,t) ffetarget_typeless_hex (v, t)
01501 #define ffetarget_hexzvxt(v,t) ffetarget_typeless_hex (v, t)
01502 #define ffetarget_init_0()
01503 #define ffetarget_init_1()
01504 #define ffetarget_init_2()
01505 #define ffetarget_init_3()
01506 #define ffetarget_init_4()
01507 #ifdef FFETARGET_32bit_longs
01508 #define ffetarget_integerdefault_is_magical(i) \
01509   (((unsigned long int) i) == FFETARGET_integerBIG_MAGICAL)
01510 #else
01511 #define ffetarget_integerdefault_is_magical(i) \
01512   (((unsigned int) i) == FFETARGET_integerBIG_MAGICAL)
01513 #endif
01514 #ifdef REAL_ARITHMETIC
01515 #define ffetarget_iszero_real1(l) \
01516   ({ REAL_VALUE_TYPE lr; \
01517      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01518      REAL_VALUES_EQUAL (lr, dconst0); \
01519    })
01520 #define ffetarget_iszero_real2(l) \
01521   ({ REAL_VALUE_TYPE lr; \
01522      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01523      REAL_VALUES_EQUAL (lr, dconst0); \
01524    })
01525 #else
01526 #define ffetarget_iszero_real1(l) ((l) == 0.)
01527 #define ffetarget_iszero_real2(l) ((l) == 0.)
01528 #endif
01529 #define ffetarget_iszero_typeless(l) ((l) == 0)
01530 #define ffetarget_logical1(v,truth) (*(v) = truth ? 1 : 0)
01531 #define ffetarget_le_integer1(res,l,r) \
01532   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01533 #define ffetarget_le_integer2(res,l,r) \
01534   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01535 #define ffetarget_le_integer3(res,l,r) \
01536   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01537 #define ffetarget_le_integer4(res,l,r) \
01538   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01539 #ifdef REAL_ARITHMETIC
01540 #define ffetarget_le_real1(res,l,r) \
01541   ({ REAL_VALUE_TYPE lr, rr; \
01542      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01543      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01544      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
01545        ? TRUE : FALSE; \
01546      FFEBAD; })
01547 #define ffetarget_le_real2(res,l,r) \
01548   ({ REAL_VALUE_TYPE lr, rr; \
01549      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01550      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01551      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
01552        ? TRUE : FALSE; \
01553      FFEBAD; })
01554 #else
01555 #define ffetarget_le_real1(res,l,r) \
01556   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01557 #define ffetarget_le_real2(res,l,r) \
01558   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
01559 #endif
01560 #define ffetarget_lt_integer1(res,l,r) \
01561   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01562 #define ffetarget_lt_integer2(res,l,r) \
01563   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01564 #define ffetarget_lt_integer3(res,l,r) \
01565   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01566 #define ffetarget_lt_integer4(res,l,r) \
01567   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01568 #ifdef REAL_ARITHMETIC
01569 #define ffetarget_lt_real1(res,l,r) \
01570   ({ REAL_VALUE_TYPE lr, rr; \
01571      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01572      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01573      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
01574      FFEBAD; })
01575 #define ffetarget_lt_real2(res,l,r) \
01576   ({ REAL_VALUE_TYPE lr, rr; \
01577      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01578      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01579      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
01580      FFEBAD; })
01581 #else
01582 #define ffetarget_lt_real1(res,l,r) \
01583   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01584 #define ffetarget_lt_real2(res,l,r) \
01585   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
01586 #endif
01587 #define ffetarget_length_character1(c) ((c).length)
01588 #define ffetarget_length_characterdefault ffetarget_length_character1
01589 #ifdef REAL_ARITHMETIC
01590 #define ffetarget_make_real1(res,lr) \
01591   ffetarget_cvt_rv_to_r1_ ((lr), *(res))
01592 #define ffetarget_make_real2(res,lr) \
01593   ffetarget_cvt_rv_to_r2_ ((lr), &((res)->v[0]))
01594 #else
01595 #define ffetarget_make_real1(res,lr) (*(res) = (lr))
01596 #define ffetarget_make_real2(res,lr) (*(res) = (lr))
01597 #endif
01598 #define ffetarget_multiply_integer1(res,l,r) (*(res) = (l) * (r), FFEBAD)
01599 #define ffetarget_multiply_integer2(res,l,r) (*(res) = (l) * (r), FFEBAD)
01600 #define ffetarget_multiply_integer3(res,l,r) (*(res) = (l) * (r), FFEBAD)
01601 #define ffetarget_multiply_integer4(res,l,r) (*(res) = (l) * (r), FFEBAD)
01602 #ifdef REAL_ARITHMETIC
01603 #define ffetarget_multiply_real1(res,l,r) \
01604   ({ REAL_VALUE_TYPE lr, rr, resr; \
01605      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01606      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01607      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
01608      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
01609      FFEBAD; })
01610 #define ffetarget_multiply_real2(res,l,r) \
01611   ({ REAL_VALUE_TYPE lr, rr, resr; \
01612      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01613      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01614      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
01615      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
01616      FFEBAD; })
01617 #else
01618 #define ffetarget_multiply_real1(res,l,r) (*(res) = (l) * (r), FFEBAD)
01619 #define ffetarget_multiply_real2(res,l,r) (*(res) = (l) * (r), FFEBAD)
01620 #endif
01621 #ifdef REAL_ARITHMETIC
01622 #define ffetarget_ne_complex1(res,l,r) \
01623   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
01624      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01625      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
01626      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
01627      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
01628      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
01629        ? FALSE : TRUE; \
01630      FFEBAD; })
01631 #define ffetarget_ne_complex2(res,l,r) \
01632   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
01633      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
01634      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
01635      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
01636      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
01637      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
01638        ? FALSE : TRUE; \
01639      FFEBAD; })
01640 #else
01641 #define ffetarget_ne_complex1(res,l,r) \
01642   (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
01643    ? TRUE : FALSE, FFEBAD)
01644 #define ffetarget_ne_complex2(res,l,r) \
01645   (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
01646    ? TRUE : FALSE, FFEBAD)
01647 #endif
01648 #define ffetarget_ne_integer1(res,l,r) \
01649   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01650 #define ffetarget_ne_integer2(res,l,r) \
01651   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01652 #define ffetarget_ne_integer3(res,l,r) \
01653   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01654 #define ffetarget_ne_integer4(res,l,r) \
01655   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01656 #ifdef REAL_ARITHMETIC
01657 #define ffetarget_ne_real1(res,l,r) \
01658   ({ REAL_VALUE_TYPE lr, rr; \
01659      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01660      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01661      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
01662      FFEBAD; })
01663 #define ffetarget_ne_real2(res,l,r) \
01664   ({ REAL_VALUE_TYPE lr, rr; \
01665      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01666      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01667      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
01668      FFEBAD; })
01669 #else
01670 #define ffetarget_ne_real1(res,l,r) \
01671   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01672 #define ffetarget_ne_real2(res,l,r) \
01673   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
01674 #endif
01675 #define ffetarget_neqv_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01676 #define ffetarget_neqv_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01677 #define ffetarget_neqv_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01678 #define ffetarget_neqv_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01679 #define ffetarget_neqv_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD)
01680 #define ffetarget_neqv_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD)
01681 #define ffetarget_neqv_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD)
01682 #define ffetarget_neqv_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD)
01683 #define ffetarget_not_integer1(res,l) (*(res) = ~(l), FFEBAD)
01684 #define ffetarget_not_integer2(res,l) (*(res) = ~(l), FFEBAD)
01685 #define ffetarget_not_integer3(res,l) (*(res) = ~(l), FFEBAD)
01686 #define ffetarget_not_integer4(res,l) (*(res) = ~(l), FFEBAD)
01687 #define ffetarget_not_logical1(res,l) (*(res) = !(l), FFEBAD)
01688 #define ffetarget_not_logical2(res,l) (*(res) = !(l), FFEBAD)
01689 #define ffetarget_not_logical3(res,l) (*(res) = !(l), FFEBAD)
01690 #define ffetarget_not_logical4(res,l) (*(res) = !(l), FFEBAD)
01691 #define ffetarget_octalmil(v,t) ffetarget_typeless_octal (v, t)
01692 #define ffetarget_octalvxt(v,t) ffetarget_typeless_octal (v, t)
01693 #define ffetarget_offset(res,l) (*(res) = (l), TRUE)  /* Overflow? */
01694 #define ffetarget_offset_add(res,l,r) (*(res) = (l) + (r), TRUE)  /* Overflow? */
01695 #define ffetarget_offset_charsize(res,l,u) (*(res) = (l) * (u), TRUE) /* Ov? */
01696 #define ffetarget_offset_multiply(res,l,r) (*(res) = (l) * (r), TRUE) /* Ov? */
01697 #define ffetarget_offset_overflow(text) ((void) 0)  /* ~~no message? */
01698 #define ffetarget_or_integer1(res,l,r) (*(res) = (l) | (r), FFEBAD)
01699 #define ffetarget_or_integer2(res,l,r) (*(res) = (l) | (r), FFEBAD)
01700 #define ffetarget_or_integer3(res,l,r) (*(res) = (l) | (r), FFEBAD)
01701 #define ffetarget_or_integer4(res,l,r) (*(res) = (l) | (r), FFEBAD)
01702 #define ffetarget_or_logical1(res,l,r) (*(res) = (l) || (r), FFEBAD)
01703 #define ffetarget_or_logical2(res,l,r) (*(res) = (l) || (r), FFEBAD)
01704 #define ffetarget_or_logical3(res,l,r) (*(res) = (l) || (r), FFEBAD)
01705 #define ffetarget_or_logical4(res,l,r) (*(res) = (l) || (r), FFEBAD)
01706 #define ffetarget_print_binarymil(f,v) ffetarget_print_binary (f, v)
01707 #define ffetarget_print_binaryvxt(f,v) ffetarget_print_binary (f, v)
01708 #define ffetarget_print_hexxmil(f,v) ffetarget_print_hex (f, v)
01709 #define ffetarget_print_hexxvxt(f,v) ffetarget_print_hex (f, v)
01710 #define ffetarget_print_hexzmil(f,v) ffetarget_print_hex (f, v)
01711 #define ffetarget_print_hexzvxt(f,v) ffetarget_print_hex (f, v)
01712 #define ffetarget_print_integer1(f,v) \
01713   fprintf ((f), "%" ffetargetInteger1_f "d", (v))
01714 #define ffetarget_print_integer2(f,v) \
01715   fprintf ((f), "%" ffetargetInteger2_f "d", (v))
01716 #define ffetarget_print_integer3(f,v) \
01717   fprintf ((f), "%" ffetargetInteger3_f "d", (v))
01718 #define ffetarget_print_integer4(f,v) \
01719   fprintf ((f), "%" ffetargetInteger4_f "d", (v))
01720 #define ffetarget_print_logical1(f,v) \
01721   fprintf ((f), "%" ffetargetLogical1_f "d", (v))
01722 #define ffetarget_print_logical2(f,v) \
01723   fprintf ((f), "%" ffetargetLogical2_f "d", (v))
01724 #define ffetarget_print_logical3(f,v) \
01725   fprintf ((f), "%" ffetargetLogical3_f "d", (v))
01726 #define ffetarget_print_logical4(f,v) \
01727   fprintf ((f), "%" ffetargetLogical4_f "d", (v))
01728 #define ffetarget_print_octalmil(f,v) ffetarget_print_octal(f,v)
01729 #define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v)
01730 #ifdef REAL_ARITHMETIC
01731 #define ffetarget_print_real1(f,l) \
01732   ({ REAL_VALUE_TYPE lr; \
01733      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01734      REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
01735      fputs (ffetarget_string_, (f)); \
01736    })
01737 #define ffetarget_print_real2(f,l) \
01738   ({ REAL_VALUE_TYPE lr; \
01739      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01740      REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
01741      fputs (ffetarget_string_, (f)); \
01742    })
01743 #else
01744 #define ffetarget_print_real1(f,v) \
01745   fprintf ((f), "%" ffetargetReal1_f "g", (v))
01746 #define ffetarget_print_real2(f,v) \
01747   fprintf ((f), "%" ffetargetReal2_f "g", (v))
01748 #endif
01749 #ifdef REAL_ARITHMETIC
01750 #define ffetarget_real1_one(res) ffetarget_cvt_rv_to_r1_ (dconst1, *(res))
01751 #define ffetarget_real2_one(res) ffetarget_cvt_rv_to_r2_ (dconst1, &((res)->v[0]))
01752 #else
01753 #define ffetarget_real1_one(res) (*(res) = (float) 1.)
01754 #define ffetarget_real2_one(res) (*(res) = 1.)
01755 #endif
01756 #ifdef REAL_ARITHMETIC
01757 #define ffetarget_real1_two(res) ffetarget_cvt_rv_to_r1_ (dconst2, *(res))
01758 #define ffetarget_real2_two(res) ffetarget_cvt_rv_to_r2_ (dconst2, &((res)->v[0]))
01759 #else
01760 #define ffetarget_real1_two(res) (*(res) = (float) 2.)
01761 #define ffetarget_real2_two(res) (*(res) = 2.)
01762 #endif
01763 #ifdef REAL_ARITHMETIC
01764 #define ffetarget_real1_zero(res) ffetarget_cvt_rv_to_r1_ (dconst0, *(res))
01765 #define ffetarget_real2_zero(res) ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0]))
01766 #else
01767 #define ffetarget_real1_zero(res) (*(res) = (float) 0.)
01768 #define ffetarget_real2_zero(res) (*(res) = 0.)
01769 #endif
01770 #define ffetarget_size_typeless_binary(t) ((ffetarget_num_digits_(t) + 7) / 8)
01771 #define ffetarget_size_typeless_octal(t) \
01772   ((ffetarget_num_digits_(t) * 3 + 7) / 8)
01773 #define ffetarget_size_typeless_hex(t) ((ffetarget_num_digits_(t) + 1) / 2)
01774 #ifdef REAL_ARITHMETIC
01775 #define ffetarget_subtract_complex1(res,l,r) \
01776   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
01777      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01778      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
01779      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
01780      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
01781      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
01782      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
01783      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
01784      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
01785      FFEBAD; })
01786 #define ffetarget_subtract_complex2(res,l,r) \
01787   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
01788      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
01789      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
01790      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
01791      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
01792      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
01793      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
01794      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
01795      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
01796      FFEBAD; })
01797 #else
01798 #define ffetarget_subtract_complex1(res,l,r) \
01799   ((res)->real = (l).real - (r).real, \
01800    (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
01801 #define ffetarget_subtract_complex2(res,l,r) \
01802   ((res)->real = (l).real - (r).real, \
01803    (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
01804 #endif
01805 #define ffetarget_subtract_integer1(res,l,r) (*(res) = (l) - (r), FFEBAD)
01806 #define ffetarget_subtract_integer2(res,l,r) (*(res) = (l) - (r), FFEBAD)
01807 #define ffetarget_subtract_integer3(res,l,r) (*(res) = (l) - (r), FFEBAD)
01808 #define ffetarget_subtract_integer4(res,l,r) (*(res) = (l) - (r), FFEBAD)
01809 #ifdef REAL_ARITHMETIC
01810 #define ffetarget_subtract_real1(res,l,r) \
01811   ({ REAL_VALUE_TYPE lr, rr, resr; \
01812      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01813      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
01814      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
01815      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
01816      FFEBAD; })
01817 #define ffetarget_subtract_real2(res,l,r) \
01818   ({ REAL_VALUE_TYPE lr, rr, resr; \
01819      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01820      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
01821      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
01822      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
01823      FFEBAD; })
01824 #else
01825 #define ffetarget_subtract_real1(res,l,r) (*(res) = (l) - (r), FFEBAD)
01826 #define ffetarget_subtract_real2(res,l,r) (*(res) = (l) - (r), FFEBAD)
01827 #endif
01828 #define ffetarget_terminate_0()
01829 #define ffetarget_terminate_1()
01830 #define ffetarget_terminate_2()
01831 #define ffetarget_terminate_3()
01832 #define ffetarget_terminate_4()
01833 #define ffetarget_text_character1(c) ((c).text)
01834 #define ffetarget_text_characterdefault ffetarget_text_character1
01835 #ifdef REAL_ARITHMETIC
01836 #define ffetarget_uminus_complex1(res,l) \
01837   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
01838      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
01839      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
01840      resr = REAL_VALUE_NEGATE (lr); \
01841      resi = REAL_VALUE_NEGATE (li); \
01842      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
01843      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
01844      FFEBAD; })
01845 #define ffetarget_uminus_complex2(res,l) \
01846   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
01847      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
01848      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
01849      resr = REAL_VALUE_NEGATE (lr); \
01850      resi = REAL_VALUE_NEGATE (li); \
01851      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
01852      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
01853      FFEBAD; })
01854 #else
01855 #define ffetarget_uminus_complex1(res,l) \
01856   ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
01857 #define ffetarget_uminus_complex2(res,l) \
01858   ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
01859 #endif
01860 #define ffetarget_uminus_integer1(res,l) (*(res) = -(l), FFEBAD)
01861 #define ffetarget_uminus_integer2(res,l) (*(res) = -(l), FFEBAD)
01862 #define ffetarget_uminus_integer3(res,l) (*(res) = -(l), FFEBAD)
01863 #define ffetarget_uminus_integer4(res,l) (*(res) = -(l), FFEBAD)
01864 #ifdef REAL_ARITHMETIC
01865 #define ffetarget_uminus_real1(res,l) \
01866   ({ REAL_VALUE_TYPE lr, resr; \
01867      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
01868      resr = REAL_VALUE_NEGATE (lr); \
01869      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
01870      FFEBAD; })
01871 #define ffetarget_uminus_real2(res,l) \
01872   ({ REAL_VALUE_TYPE lr, resr; \
01873      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
01874      resr = REAL_VALUE_NEGATE (lr); \
01875      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
01876      FFEBAD; })
01877 #else
01878 #define ffetarget_uminus_real1(res,l) (*(res) = -(l), FFEBAD)
01879 #define ffetarget_uminus_real2(res,l) (*(res) = -(l), FFEBAD)
01880 #endif
01881 #ifdef REAL_ARITHMETIC
01882 #define ffetarget_value_real1(lr) ffetarget_cvt_r1_to_rv_ ((lr))
01883 #define ffetarget_value_real2(lr) ffetarget_cvt_r2_to_rv_ (&((lr).v[0]))
01884 #else
01885 #define ffetarget_value_real1
01886 #define ffetarget_value_real2
01887 #endif
01888 #define ffetarget_xor_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01889 #define ffetarget_xor_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01890 #define ffetarget_xor_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01891 #define ffetarget_xor_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
01892 #define ffetarget_xor_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD)
01893 #define ffetarget_xor_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD)
01894 #define ffetarget_xor_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD)
01895 #define ffetarget_xor_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD)
01896 
01897 /* End of #include file. */
01898 
01899 #endif /* ! GCC_F_TARGET_H */