/* target.h -- Public #include File (module.h template V1.0) Copyright (C) 1995, 1996, 2002, 2003 Free Software Foundation, Inc. Contributed by James Craig Burley. This file is part of GNU Fortran. GNU Fortran is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Fortran is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Fortran; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. Owning Modules: target.c Modifications: */ /* Allow multiple inclusion to work. */ #ifndef GCC_F_TARGET_H #define GCC_F_TARGET_H #ifndef TREE_CODE #include "tree.h" #endif /* Simple definitions and enumerations. */ #define FFETARGET_charactersizeNONE (-1) #ifndef FFETARGET_charactersizeMAXIMUM #define FFETARGET_charactersizeMAXIMUM 2147483647 #endif #ifndef FFETARGET_defaultIS_90 #define FFETARGET_defaultIS_90 0 #endif #ifndef FFETARGET_defaultIS_AUTOMATIC #define FFETARGET_defaultIS_AUTOMATIC 1 #endif #ifndef FFETARGET_defaultIS_BACKSLASH #define FFETARGET_defaultIS_BACKSLASH 1 #endif #ifndef FFETARGET_defaultIS_INIT_LOCAL_ZERO #define FFETARGET_defaultIS_INIT_LOCAL_ZERO 0 #endif #ifndef FFETARGET_defaultIS_DOLLAR_OK #define FFETARGET_defaultIS_DOLLAR_OK 0 #endif #ifndef FFETARGET_defaultIS_F2C #define FFETARGET_defaultIS_F2C 1 #endif #ifndef FFETARGET_defaultIS_F2C_LIBRARY #define FFETARGET_defaultIS_F2C_LIBRARY 1 #endif #ifndef FFETARGET_defaultIS_FREE_FORM #define FFETARGET_defaultIS_FREE_FORM 0 #endif #ifndef FFETARGET_defaultIS_PEDANTIC #define FFETARGET_defaultIS_PEDANTIC 0 #endif #ifndef FFETARGET_defaultCASE_INTRIN #define FFETARGET_defaultCASE_INTRIN FFE_caseLOWER #endif #ifndef FFETARGET_defaultCASE_MATCH #define FFETARGET_defaultCASE_MATCH FFE_caseLOWER #endif #ifndef FFETARGET_defaultCASE_SOURCE #define FFETARGET_defaultCASE_SOURCE FFE_caseLOWER #endif #ifndef FFETARGET_defaultCASE_SYMBOL #define FFETARGET_defaultCASE_SYMBOL FFE_caseNONE #endif #ifndef FFETARGET_defaultFIXED_LINE_LENGTH #define FFETARGET_defaultFIXED_LINE_LENGTH 72 #endif /* 1 if external Fortran names ("FOO" in SUBROUTINE FOO, COMMON /FOO/, and even enforced/default-for-unnamed PROGRAM, blank-COMMON, and BLOCK DATA names, but not names of library functions implementing intrinsics or names of local/internal variables) should have an underscore appended (for compatibility with existing systems). */ #ifndef FFETARGET_defaultEXTERNAL_UNDERSCORED #define FFETARGET_defaultEXTERNAL_UNDERSCORED 1 #endif /* 1 if external Fortran names with underscores already in them should have an extra underscore appended (in addition to the one they might already have appened if FFETARGET_defaultEXTERNAL_UNDERSCORED). */ #ifndef FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED #define FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED 1 #endif /* If FFETARGET_defaultEXTERNAL_UNDERSCORED is 0, the following definitions might also need to be overridden to make g77 objects compatible with f2c+gcc objects. Although I don't think the unnamed BLOCK DATA one is an issue at all. Of course, on some systems it isn't f2c compatibility that is the issue -- maybe compatibility with some other compiler(s). I don't know what to recommend for systems where there is no existing Fortran compiler -- I suppose porting f2c and pretending it's the existing one is best for now. */ /* 1 if the "FOO" in "PROGRAM FOO" should be overridden and a particular name imposed in place of it in the actual code (normally the case, because the library's main entry point on most systems calls the main function by a particular name). Someday g77 might do the f2c trick of also outputting a "FOO" procedure that just calls the main procedure, but that'll wait until somebody shows why it is needed. */ #ifndef FFETARGET_isENFORCED_MAIN #define FFETARGET_isENFORCED_MAIN 1 #endif /* The enforced name of the main program if ENFORCED_MAIN is 1. */ #ifndef FFETARGET_nameENFORCED_MAIN_NAME #define FFETARGET_nameENFORCED_MAIN_NAME "MAIN__" #endif /* The name used for an unnamed main program if ENFORCED_MAIN is 0. */ #ifndef FFETARGET_nameUNNAMED_MAIN #define FFETARGET_nameUNNAMED_MAIN "MAIN__" #endif /* The name used for an unnamed block data program. */ #ifndef FFETARGET_nameUNNAMED_BLOCK_DATA #define FFETARGET_nameUNNAMED_BLOCK_DATA "_BLOCK_DATA__" #endif /* The name used for blank common. */ #ifndef FFETARGET_nameBLANK_COMMON #define FFETARGET_nameBLANK_COMMON "_BLNK__" #endif #ifndef FFETARGET_integerSMALLEST_POSITIVE #define FFETARGET_integerSMALLEST_POSITIVE 0 #endif #ifndef FFETARGET_integerLARGEST_POSITIVE #define FFETARGET_integerLARGEST_POSITIVE 2147483647 #endif #ifndef FFETARGET_integerBIG_MAGICAL #define FFETARGET_integerBIG_MAGICAL 020000000000 /* 2147483648 */ #endif #ifndef FFETARGET_integerALMOST_BIG_MAGICAL #define FFETARGET_integerALMOST_BIG_MAGICAL 214748364 #endif #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY #define FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY 0x80000000 #endif #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_HEX #define FFETARGET_integerALMOST_BIG_OVERFLOW_HEX 0x10000000 #endif #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL #define FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL 0x20000000 #endif #ifndef FFETARGET_integerFINISH_BIG_MAGICAL #define FFETARGET_integerFINISH_BIG_MAGICAL 8 #endif #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY #define FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY 0 #endif #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_HEX #define FFETARGET_integerFINISH_BIG_OVERFLOW_HEX 0 #endif #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL #define FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL 0 #endif #ifndef FFETARGET_offsetNONE #define FFETARGET_offsetNONE 0 /* Not used by FFE, for backend if needed. */ #endif #define FFETARGET_okINTEGER1 1 #define FFETARGET_okINTEGER2 1 #define FFETARGET_okINTEGER3 1 #define FFETARGET_okINTEGER4 1 #define FFETARGET_okLOGICAL1 1 #define FFETARGET_okLOGICAL2 1 #define FFETARGET_okLOGICAL3 1 #define FFETARGET_okLOGICAL4 1 #define FFETARGET_okREAL1 1 #define FFETARGET_okREAL2 1 #define FFETARGET_okREAL3 0 #define FFETARGET_okREALQUAD FFETARGET_okREAL3 #define FFETARGET_okCOMPLEX1 1 #define FFETARGET_okCOMPLEX2 1 #define FFETARGET_okCOMPLEX3 0 #define FFETARGET_okCOMPLEXDOUBLE FFETARGET_okCOMPLEX2 #define FFETARGET_okCOMPLEXQUAD FFETARGET_okCOMPLEX3 #define FFETARGET_okCHARACTER1 1 #define FFETARGET_f2cTYUNKNOWN 0 #define FFETARGET_f2cTYADDR 1 #define FFETARGET_f2cTYSHORT 2 #define FFETARGET_f2cTYLONG 3 #define FFETARGET_f2cTYREAL 4 #define FFETARGET_f2cTYDREAL 5 #define FFETARGET_f2cTYCOMPLEX 6 #define FFETARGET_f2cTYDCOMPLEX 7 #define FFETARGET_f2cTYLOGICAL 8 #define FFETARGET_f2cTYCHAR 9 #define FFETARGET_f2cTYSUBR 10 #define FFETARGET_f2cTYINT1 11 #define FFETARGET_f2cTYLOGICAL1 12 #define FFETARGET_f2cTYLOGICAL2 13 #define FFETARGET_f2cTYQUAD 14 #if (!defined(__alpha__) \ && (!defined(__hppa__) || !defined(__LP64__)) \ && (!defined(__ia64__) || !defined(__LP64__)) \ && !defined(__MMIX__) \ && (!defined (_ARCH_PPC) || !defined (__64BIT__)) \ && !defined(__powerpc64__) \ && !defined(__s390x__) \ && (!defined(__sparc__) || (!defined(__sparcv9) && !defined(__arch64__)))\ && !defined(__x86_64__)) #define FFETARGET_32bit_longs #endif /* Typedefs. */ typedef unsigned char ffetargetAlign; /* ffetargetOffset for alignment. */ #define ffetargetAlign_f "" typedef long ffetargetCharacterSize; #define ffetargetCharacterSize_f "l" typedef void (*ffetargetCopyfunc) (void *, void *, size_t); typedef ffetargetCharacterSize ffetargetHollerithSize; #define ffetargetHollerithSize_f "l" typedef long long ffetargetOffset; #define ffetargetOffset_f "ll" #if FFETARGET_okINTEGER1 #ifdef FFETARGET_32bit_longs typedef long int ffetargetInteger1; #define ffetargetInteger1_f "l" #else typedef int ffetargetInteger1; #define ffetargetInteger1_f "" #endif #endif #if FFETARGET_okINTEGER2 typedef signed char ffetargetInteger2; #define ffetargetInteger2_f "" #endif #if FFETARGET_okINTEGER3 typedef short int ffetargetInteger3; #define ffetargetInteger3_f "" #endif #if FFETARGET_okINTEGER4 typedef long long int ffetargetInteger4; #define ffetargetInteger4_f "ll" #endif #if FFETARGET_okLOGICAL1 #ifdef FFETARGET_32bit_longs typedef long int ffetargetLogical1; #define ffetargetLogical1_f "l" #else typedef int ffetargetLogical1; #define ffetargetLogical1_f "" #endif #endif #if FFETARGET_okLOGICAL2 typedef signed char ffetargetLogical2; #define ffetargetLogical2_f "" #endif #if FFETARGET_okLOGICAL3 typedef short int ffetargetLogical3; #define ffetargetLogical3_f "" #endif #if FFETARGET_okLOGICAL4 typedef long long int ffetargetLogical4; #define ffetargetLogical4_f "ll" #endif #if FFETARGET_okREAL1 typedef int ffetargetReal1; #define ffetargetReal1_f "" #define ffetarget_cvt_r1_to_rv_(in) \ ({ REAL_VALUE_TYPE _rv; \ long _in = (in); \ real_from_target (&_rv, &_in, mode_for_size (32, MODE_FLOAT, 0)); \ _rv; }) #define ffetarget_cvt_rv_to_r1_(in, out) \ ({ long _tmp; \ REAL_VALUE_TO_TARGET_SINGLE ((in), _tmp); \ (out) = (ffetargetReal1) _tmp; }) #endif #if FFETARGET_okREAL2 typedef struct { int v[2]; } ffetargetReal2; #define ffetargetReal2_f "" #define ffetarget_cvt_r2_to_rv_(in) \ ({ REAL_VALUE_TYPE _rv; long _tmp[2]; \ _tmp[0] = (in)[0]; _tmp[1] = (in)[1]; \ real_from_target (&_rv, _tmp, mode_for_size (64, MODE_FLOAT, 0)); \ _rv; }) #define ffetarget_cvt_rv_to_r2_(in, out) \ ({ long _tmp[2]; \ REAL_VALUE_TO_TARGET_DOUBLE ((in), _tmp); \ (out)[0] = (int)_tmp[0]; (out)[1] = (int)_tmp[1]; }) #endif #if FFETARGET_okREAL3 typedef long ffetargetReal3[?]; ? #endif #if FFETARGET_okCOMPLEX1 struct _ffetarget_complex_1_ { ffetargetReal1 real; ffetargetReal1 imaginary; }; typedef struct _ffetarget_complex_1_ ffetargetComplex1; #endif #if FFETARGET_okCOMPLEX2 struct _ffetarget_complex_2_ { ffetargetReal2 real; ffetargetReal2 imaginary; }; typedef struct _ffetarget_complex_2_ ffetargetComplex2; #endif #if FFETARGET_okCOMPLEX3 struct _ffetarget_complex_3_ { ffetargetReal3 real; ffetargetReal3 imaginary; }; typedef struct _ffetarget_complex_3_ ffetargetComplex3; #endif #if FFETARGET_okCHARACTER1 struct _ffetarget_char_1_ { ffetargetCharacterSize length; unsigned char *text; }; typedef struct _ffetarget_char_1_ ffetargetCharacter1; typedef unsigned char ffetargetCharacterUnit1; #endif typedef unsigned long long int ffetargetTypeless; struct _ffetarget_hollerith_ { ffetargetHollerithSize length; unsigned char *text; }; typedef struct _ffetarget_hollerith_ ffetargetHollerith; typedef ffetargetCharacter1 ffetargetCharacterDefault; typedef ffetargetComplex1 ffetargetComplexDefault; #if FFETARGET_okCOMPLEXDOUBLE typedef ffetargetComplex2 ffetargetComplexDouble; #endif #if FFETARGET_okCOMPLEXQUAD typedef ffetargetComplex3 ffetargetComplexQuad; #endif typedef ffetargetInteger1 ffetargetIntegerDefault; #define ffetargetIntegerDefault_f ffetargetInteger1_f typedef ffetargetLogical1 ffetargetLogicalDefault; #define ffetargetLogicalDefault_f ffetargetLogical1_f typedef ffetargetReal1 ffetargetRealDefault; #define ffetargetRealDefault_f ffetargetReal1_f typedef ffetargetReal2 ffetargetRealDouble; #define ffetargetRealDouble_f ffetargetReal2_f #if FFETARGET_okREALQUAD typedef ffetargetReal3 ffetargetRealQuad; #define ffetargetRealQuad_f ffetargetReal3_f #endif /* Include files needed by this one. */ #include "bad.h" #include "info.h" #include "lex.h" #include "malloc.h" /* Structure definitions. */ /* Global objects accessed by users of this module. */ extern char ffetarget_string_[40]; /* Temp for ascii-to-double (atof). */ extern HOST_WIDE_INT ffetarget_long_val_; extern HOST_WIDE_INT ffetarget_long_junk_; /* Declare functions with prototypes. */ void ffetarget_aggregate_info (ffeinfoBasictype *ebt, ffeinfoKindtype *ekt, ffetargetAlign *units, ffeinfoBasictype abt, ffeinfoKindtype akt); ffetargetAlign ffetarget_align (ffetargetAlign *updated_alignment, ffetargetAlign *updated_modulo, ffetargetOffset offset, ffetargetAlign alignment, ffetargetAlign modulo); #if FFETARGET_okCHARACTER1 bool ffetarget_character1 (ffetargetCharacter1 *val, ffelexToken character, mallocPool pool); int ffetarget_cmp_character1 (ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_concatenate_character1 (ffetargetCharacter1 *res, ffetargetCharacter1 l, ffetargetCharacter1 r, mallocPool pool, ffetargetCharacterSize *len); ffebad ffetarget_convert_character1_character1 (ffetargetCharacter1 *res, ffetargetCharacterSize res_size, ffetargetCharacter1 l, mallocPool pool); ffebad ffetarget_convert_character1_hollerith (ffetargetCharacter1 *res, ffetargetCharacterSize res_size, ffetargetHollerith l, mallocPool pool); ffebad ffetarget_convert_character1_integer4 (ffetargetCharacter1 *res, ffetargetCharacterSize res_size, ffetargetInteger4 l, mallocPool pool); ffebad ffetarget_convert_character1_logical4 (ffetargetCharacter1 *res, ffetargetCharacterSize res_size, ffetargetLogical4 l, mallocPool pool); ffebad ffetarget_convert_character1_typeless (ffetargetCharacter1 *res, ffetargetCharacterSize res_size, ffetargetTypeless l, mallocPool pool); ffebad ffetarget_eq_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_le_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_ge_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_gt_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_lt_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_ne_character1 (bool *res, ffetargetCharacter1 l, ffetargetCharacter1 r); ffebad ffetarget_substr_character1 (ffetargetCharacter1 *res, ffetargetCharacter1 l, ffetargetCharacterSize first, ffetargetCharacterSize last, mallocPool pool, ffetargetCharacterSize *len); #endif int ffetarget_cmp_hollerith (ffetargetHollerith l, ffetargetHollerith r); bool ffetarget_hollerith (ffetargetHollerith *val, ffelexToken hollerith, mallocPool pool); int ffetarget_cmp_typeless (ffetargetTypeless l, ffetargetTypeless r); ffebad ffetarget_convert_any_character1_ (char *res, size_t size, ffetargetCharacter1 l); ffebad ffetarget_convert_any_hollerith_ (char *res, size_t size, ffetargetHollerith l); ffebad ffetarget_convert_any_typeless_ (char *res, size_t size, ffetargetTypeless l); #if FFETARGET_okCOMPLEX1 ffebad ffetarget_divide_complex1 (ffetargetComplex1 *res, ffetargetComplex1 l, ffetargetComplex1 r); #endif #if FFETARGET_okCOMPLEX2 ffebad ffetarget_divide_complex2 (ffetargetComplex2 *res, ffetargetComplex2 l, ffetargetComplex2 r); #endif #if FFETARGET_okCOMPLEX3 ffebad ffetarget_divide_complex3 (ffetargetComplex3 *res, ffetargetComplex3 l, ffetargetComplex3 r); #endif #if FFETARGET_okINTEGER1 bool ffetarget_integer1 (ffetargetInteger1 *val, ffelexToken integer); #endif #if FFETARGET_okINTEGER2 bool ffetarget_integer2 (ffetargetInteger2 *val, ffelexToken integer); #endif #if FFETARGET_okINTEGER3 bool ffetarget_integer3 (ffetargetInteger3 *val, ffelexToken integer); #endif #if FFETARGET_okINTEGER4 bool ffetarget_integer4 (ffetargetInteger4 *val, ffelexToken integer); #endif bool ffetarget_integerbinary (ffetargetIntegerDefault *val, ffelexToken integer); bool ffetarget_integerhex (ffetargetIntegerDefault *val, ffelexToken integer); bool ffetarget_integeroctal (ffetargetIntegerDefault *val, ffelexToken integer); void ffetarget_integer_bad_magical (ffelexToken t); void ffetarget_integer_bad_magical_binary (ffelexToken integer, ffelexToken minus); void ffetarget_integer_bad_magical_precedence (ffelexToken integer, ffelexToken uminus, ffelexToken higher_op); void ffetarget_integer_bad_magical_precedence_binary (ffelexToken integer, ffelexToken minus, ffelexToken higher_op); #if FFETARGET_okCHARACTER1 bool ffetarget_iszero_character1 (ffetargetCharacter1 constant); #endif bool ffetarget_iszero_hollerith (ffetargetHollerith constant); void ffetarget_layout (const char *error_text, ffetargetAlign *alignment, ffetargetAlign *modulo, ffetargetOffset *size, ffeinfoBasictype bt, ffeinfoKindtype kt, ffetargetCharacterSize charsize, ffetargetIntegerDefault num_elements); #if FFETARGET_okCOMPLEX1 ffebad ffetarget_multiply_complex1 (ffetargetComplex1 *res, ffetargetComplex1 l, ffetargetComplex1 r); #endif #if FFETARGET_okCOMPLEX2 ffebad ffetarget_multiply_complex2 (ffetargetComplex2 *res, ffetargetComplex2 l, ffetargetComplex2 r); #endif #if FFETARGET_okCOMPLEX3 ffebad ffetarget_multiply_complex3 (ffetargetComplex3 *res, ffetargetComplex3 l, ffetargetComplex3 r); #endif ffebad ffetarget_power_complexdefault_integerdefault (ffetargetComplexDefault *res, ffetargetComplexDefault l, ffetargetIntegerDefault r); #if FFETARGET_okCOMPLEXDOUBLE ffebad ffetarget_power_complexdouble_integerdefault (ffetargetComplexDouble *res, ffetargetComplexDouble l, ffetargetIntegerDefault r); #endif ffebad ffetarget_power_integerdefault_integerdefault (ffetargetIntegerDefault *res, ffetargetIntegerDefault l, ffetargetIntegerDefault r); ffebad ffetarget_power_realdefault_integerdefault (ffetargetRealDefault *res, ffetargetRealDefault l, ffetargetIntegerDefault r); ffebad ffetarget_power_realdouble_integerdefault (ffetargetRealDouble *res, ffetargetRealDouble l, ffetargetIntegerDefault r); void ffetarget_print_binary (FILE *f, ffetargetTypeless val); void ffetarget_print_character1 (FILE *f, ffetargetCharacter1 val); void ffetarget_print_hollerith (FILE *f, ffetargetHollerith val); void ffetarget_print_octal (FILE *f, ffetargetTypeless val); void ffetarget_print_hex (FILE *f, ffetargetTypeless val); #if FFETARGET_okREAL1 bool ffetarget_real1 (ffetargetReal1 *value, ffelexToken integer, ffelexToken decimal, ffelexToken fraction, ffelexToken exponent, ffelexToken exponent_sign, ffelexToken exponent_digits); #endif #if FFETARGET_okREAL2 bool ffetarget_real2 (ffetargetReal2 *value, ffelexToken integer, ffelexToken decimal, ffelexToken fraction, ffelexToken exponent, ffelexToken exponent_sign, ffelexToken exponent_digits); #endif #if FFETARGET_okREAL3 bool ffetarget_real3 (ffetargetReal3 *value, ffelexToken integer, ffelexToken decimal, ffelexToken fraction, ffelexToken exponent, ffelexToken exponent_sign, ffelexToken exponent_digits); #endif bool ffetarget_typeless_binary (ffetargetTypeless *value, ffelexToken token); bool ffetarget_typeless_octal (ffetargetTypeless *value, ffelexToken token); bool ffetarget_typeless_hex (ffetargetTypeless *value, ffelexToken token); void ffetarget_verify_character1 (mallocPool pool, ffetargetCharacter1 val); int ffetarget_num_digits_ (ffelexToken t); void *ffetarget_memcpy_ (void *dst, void *src, size_t len); /* Define macros. */ #define FFETARGET_REAL_VALUE_FROM_INT_(resr, lf, kt) \ REAL_VALUE_FROM_INT (resr, (HOST_WIDE_INT) lf, \ (HOST_WIDE_INT) ((lf < 0) ? -1 : 0), \ mode_for_size (kt == 1 ? 32 : 64, MODE_FLOAT, 0)) #if HOST_BITS_PER_LONGLONG > HOST_BITS_PER_WIDE_INT #define FFETARGET_REAL_VALUE_FROM_LONGLONG_(resr, lf, kt) \ REAL_VALUE_FROM_INT (resr, (HOST_WIDE_INT) lf, \ (HOST_WIDE_INT) (lf >> HOST_BITS_PER_WIDE_INT), \ mode_for_size (kt == 1 ? 32 : 64, MODE_FLOAT, 0)) #define FFETARGET_LONGLONG_FROM_INTS_(hi, lo) \ (((long long int) hi << HOST_BITS_PER_WIDE_INT) \ | (long long int) ((unsigned HOST_WIDE_INT) lo)) #else #define FFETARGET_REAL_VALUE_FROM_LONGLONG_(resr, lf, kt) \ FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, kt) #define FFETARGET_LONGLONG_FROM_INTS_(hi, lo) lo #endif #define ffetarget_add_complex1(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ rr = ffetarget_cvt_r1_to_rv_ ((r).real); \ ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \ REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \ REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \ ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \ FFEBAD; }) #define ffetarget_add_complex2(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \ ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \ REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \ REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \ FFEBAD; }) #define ffetarget_add_integer1(res,l,r) (*(res) = (l) + (r), FFEBAD) #define ffetarget_add_integer2(res,l,r) (*(res) = (l) + (r), FFEBAD) #define ffetarget_add_integer3(res,l,r) (*(res) = (l) + (r), FFEBAD) #define ffetarget_add_integer4(res,l,r) (*(res) = (l) + (r), FFEBAD) #define ffetarget_add_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_add_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_aggregate_ptr_memcpy(dbt,dkt,sbt,skt) \ ((ffetargetCopyfunc) ffetarget_memcpy_) #define ffetarget_and_integer1(res,l,r) (*(res) = (l) & (r), FFEBAD) #define ffetarget_and_integer2(res,l,r) (*(res) = (l) & (r), FFEBAD) #define ffetarget_and_integer3(res,l,r) (*(res) = (l) & (r), FFEBAD) #define ffetarget_and_integer4(res,l,r) (*(res) = (l) & (r), FFEBAD) #define ffetarget_and_logical1(res,l,r) (*(res) = (l) && (r), FFEBAD) #define ffetarget_and_logical2(res,l,r) (*(res) = (l) && (r), FFEBAD) #define ffetarget_and_logical3(res,l,r) (*(res) = (l) && (r), FFEBAD) #define ffetarget_and_logical4(res,l,r) (*(res) = (l) && (r), FFEBAD) #define ffetarget_binarymil(v,t) ffetarget_typeless_binary (v, t) #define ffetarget_binaryvxt(v,t) ffetarget_typeless_binary (v, t) #define ffetarget_cmp_integer1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_integer2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_integer3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_integer4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_logical1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_logical2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_logical3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_logical4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1)) #define ffetarget_cmp_real1(l,r) memcmp (&(l), &(r), sizeof(l)) #define ffetarget_cmp_real2(l,r) memcmp (&(l), &(r), sizeof(l)) #define ffetarget_cmp_real3(l,r) memcmp (&(l), &(r), sizeof(l)) #define ffetarget_cmp_typeless(l,r) \ memcmp (&(l), &(r), sizeof ((l))) #define ffetarget_convert_character1_integer1(res,res_size,l,pool) \ ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool) #define ffetarget_convert_character1_integer2(res,res_size,l,pool) \ ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool) #define ffetarget_convert_character1_integer3(res,res_size,l,pool) \ ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool) #define ffetarget_convert_character1_logical1(res,res_size,l,pool) \ ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool) #define ffetarget_convert_character1_logical2(res,res_size,l,pool) \ ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool) #define ffetarget_convert_character1_logical3(res,res_size,l,pool) \ ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool) #define ffetarget_convert_complex1_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex1_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex1_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex1_complex2(res,l) \ ({ REAL_VALUE_TYPE lr, li; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (li, (res)->imaginary), \ FFEBAD; }) #define ffetarget_convert_complex1_integer(res,l) \ ({ REAL_VALUE_TYPE resi, resr; \ ffetargetInteger1 lf = (l); \ FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \ resi = dconst0; \ ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \ FFEBAD; }) #define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer #define ffetarget_convert_complex1_integer2 ffetarget_convert_complex1_integer #define ffetarget_convert_complex1_integer3 ffetarget_convert_complex1_integer #define ffetarget_convert_complex1_integer4(res,l) \ ({ REAL_VALUE_TYPE resi, resr; \ ffetargetInteger4 lf = (l); \ FFETARGET_REAL_VALUE_FROM_LONGLONG_ (resr, lf, 1); \ resi = dconst0; \ ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \ FFEBAD; }) #define ffetarget_convert_complex1_real1(res,l) \ ((res)->real = (l), \ ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \ FFEBAD) #define ffetarget_convert_complex1_real2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \ FFEBAD; }) #define ffetarget_convert_complex2_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex2_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex2_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_complex2_complex1(res,l) \ ({ REAL_VALUE_TYPE lr, li; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (li, &((res)->imaginary.v[0])), \ FFEBAD; }) #define ffetarget_convert_complex2_integer(res,l) \ ({ REAL_VALUE_TYPE resi, resr; \ ffetargetInteger1 lf = (l); \ FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \ resi = dconst0; \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \ FFEBAD; }) #define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer #define ffetarget_convert_complex2_integer2 ffetarget_convert_complex2_integer #define ffetarget_convert_complex2_integer3 ffetarget_convert_complex2_integer #define ffetarget_convert_complex2_integer4(res,l) \ ({ REAL_VALUE_TYPE resi, resr; \ ffetargetInteger4 lf = (l); \ FFETARGET_REAL_VALUE_FROM_LONGLONG_ (resr, lf, 2); \ resi = dconst0; \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \ FFEBAD; }) #define ffetarget_convert_complex2_real1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ (l); \ ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \ FFEBAD; }) #define ffetarget_convert_complex2_real2(res,l) \ ((res)->real = (l), \ ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \ FFEBAD) #define ffetarget_convert_integer2_character1(res,l) \ ffetarget_convert_integer1_character1(res,l) #define ffetarget_convert_integer2_complex1(res,l) \ ffetarget_convert_integer1_complex1(res,l) #define ffetarget_convert_integer2_complex2(res,l) \ ffetarget_convert_integer1_complex2(res,l) #define ffetarget_convert_integer2_hollerith(res,l) \ ffetarget_convert_integer1_hollerith(res,l) #define ffetarget_convert_integer2_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer2_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer2_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer2_logical1(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer2_logical2(res,l) \ ffetarget_convert_integer2_logical1(res,l) #define ffetarget_convert_integer2_logical3(res,l) \ ffetarget_convert_integer2_logical1(res,l) #define ffetarget_convert_integer2_logical4(res,l) \ ffetarget_convert_integer2_logical1(res,l) #define ffetarget_convert_integer2_real1(res,l) \ ffetarget_convert_integer1_real1(res,l) #define ffetarget_convert_integer2_real2(res,l) \ ffetarget_convert_integer1_real2(res,l) #define ffetarget_convert_integer2_typeless(res,l) \ ffetarget_convert_integer1_typeless(res,l) #define ffetarget_convert_integer3_character1(res,l) \ ffetarget_convert_integer1_character1(res,l) #define ffetarget_convert_integer3_complex1(res,l) \ ffetarget_convert_integer1_complex1(res,l) #define ffetarget_convert_integer3_complex2(res,l) \ ffetarget_convert_integer1_complex2(res,l) #define ffetarget_convert_integer3_hollerith(res,l) \ ffetarget_convert_integer1_hollerith(res,l) #define ffetarget_convert_integer3_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer3_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer3_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer3_logical1(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer3_logical2(res,l) \ ffetarget_convert_integer3_logical1(res,l) #define ffetarget_convert_integer3_logical3(res,l) \ ffetarget_convert_integer3_logical1(res,l) #define ffetarget_convert_integer3_logical4(res,l) \ ffetarget_convert_integer3_logical1(res,l) #define ffetarget_convert_integer3_real1(res,l) \ ffetarget_convert_integer1_real1(res,l) #define ffetarget_convert_integer3_real2(res,l) \ ffetarget_convert_integer1_real2(res,l) #define ffetarget_convert_integer3_typeless(res,l) \ ffetarget_convert_integer1_typeless(res,l) #define ffetarget_convert_integer4_character1(res,l) \ ffetarget_convert_integer1_character1(res,l) #define ffetarget_convert_integer4_complex1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = FFETARGET_LONGLONG_FROM_INTS_ (ffetarget_long_junk_, \ ffetarget_long_val_); \ FFEBAD; }) #define ffetarget_convert_integer4_complex2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = FFETARGET_LONGLONG_FROM_INTS_ (ffetarget_long_junk_, \ ffetarget_long_val_); \ FFEBAD; }) #define ffetarget_convert_integer4_hollerith(res,l) \ ffetarget_convert_integer1_hollerith(res,l) #define ffetarget_convert_integer4_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer4_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer4_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer4_logical1(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer4_logical2(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer4_logical3(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer4_logical4(res,l) \ ffetarget_convert_integer1_logical1(res,l) #define ffetarget_convert_integer4_real1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ (l); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = FFETARGET_LONGLONG_FROM_INTS_ (ffetarget_long_junk_, \ ffetarget_long_val_); \ FFEBAD; }) #define ffetarget_convert_integer4_real2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = FFETARGET_LONGLONG_FROM_INTS_ (ffetarget_long_junk_, \ ffetarget_long_val_); \ FFEBAD; }) #define ffetarget_convert_integer4_typeless(res,l) \ ffetarget_convert_integer1_typeless(res,l) #define ffetarget_convert_logical1_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical1_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical1_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical1_logical2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_logical3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_logical4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical1_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical2_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical2_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical2_logical1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_logical3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_logical4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical2_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical3_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical3_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical3_logical1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_logical2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_logical4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical3_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical4_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical4_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_logical4_logical1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_logical2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_logical3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_integer1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_logical4_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_integer1_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_integer1_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_integer1_integer2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_integer3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_integer4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_logical1(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_logical2(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_logical3(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_logical4(res,l) (*(res) = (l), FFEBAD) #define ffetarget_convert_integer1_real1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ (l); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = ffetarget_long_val_; \ FFEBAD; }) #define ffetarget_convert_integer1_real2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = ffetarget_long_val_; \ FFEBAD; }) #define ffetarget_convert_integer1_complex1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = ffetarget_long_val_; \ FFEBAD; }) #define ffetarget_convert_integer1_complex2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \ *(res) = ffetarget_long_val_; \ FFEBAD; }) #define ffetarget_convert_real1_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real1_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real1_integer2(res,l) \ ffetarget_convert_real1_integer1(res,l) #define ffetarget_convert_real1_integer3(res,l) \ ffetarget_convert_real1_integer1(res,l) #define ffetarget_convert_real1_integer4(res,l) \ ({ REAL_VALUE_TYPE resr; \ ffetargetInteger4 lf = (l); \ FFETARGET_REAL_VALUE_FROM_LONGLONG_ (resr, lf, 1); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_convert_real1_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real1_complex1(res,l) (*(res) = (l).real, FFEBAD) #define ffetarget_convert_real1_complex2(res,l) \ ffetarget_convert_real1_real2 ((res), (l).real) #define ffetarget_convert_real1_integer1(res,l) \ ({ REAL_VALUE_TYPE resr; \ ffetargetInteger1 lf = (l); \ FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_convert_real1_real2(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ ffetarget_cvt_rv_to_r1_ (lr, *(res)); \ FFEBAD; }) #define ffetarget_convert_real2_character1(res,l) \ ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real2_hollerith(res,l) \ ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real2_integer2(res,l) \ ffetarget_convert_real2_integer1(res,l) #define ffetarget_convert_real2_integer3(res,l) \ ffetarget_convert_real2_integer1(res,l) #define ffetarget_convert_real2_integer4(res,l) \ ({ REAL_VALUE_TYPE resr; \ ffetargetInteger4 lf = (l); \ FFETARGET_REAL_VALUE_FROM_LONGLONG_ (resr, lf, 2); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_convert_real2_typeless(res,l) \ ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l) #define ffetarget_convert_real2_complex1(res,l) \ ffetarget_convert_real2_real1 ((res), (l).real) #define ffetarget_convert_real2_complex2(res,l) (*(res) = (l).real, FFEBAD) #define ffetarget_convert_real2_integer(res,l) \ ({ REAL_VALUE_TYPE resr; \ ffetargetInteger1 lf = (l); \ FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer #define ffetarget_convert_real2_real1(res,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ ffetarget_cvt_rv_to_r2_ (lr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_divide_integer1(res,l,r) \ (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO) \ : (((r) == -1) ? (*(res) = -(l), FFEBAD) \ : (*(res) = (l) / (r), FFEBAD))) #define ffetarget_divide_integer2(res,l,r) \ ffetarget_divide_integer1(res,l,r) #define ffetarget_divide_integer3(res,l,r) \ ffetarget_divide_integer1(res,l,r) #define ffetarget_divide_integer4(res,l,r) \ ffetarget_divide_integer1(res,l,r) #define ffetarget_divide_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ REAL_VALUES_EQUAL (rr, dconst0) \ ? ({ ffetarget_cvt_rv_to_r1_ (dconst0, *(res)); \ FFEBAD_DIV_BY_ZERO; \ }) \ : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; \ }); \ }) #define ffetarget_divide_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ REAL_VALUES_EQUAL (rr, dconst0) \ ? ({ ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0])); \ FFEBAD_DIV_BY_ZERO; \ }) \ : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; \ }); \ }) #define ffetarget_eq_complex1(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ rr = ffetarget_cvt_r1_to_rv_ ((r).real); \ ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \ *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \ ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_eq_complex2(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \ ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \ *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \ ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_eq_integer1(res,l,r) \ (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_eq_integer2(res,l,r) \ (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_eq_integer3(res,l,r) \ (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_eq_integer4(res,l,r) \ (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_eq_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_eq_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_eqv_integer1(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD) #define ffetarget_eqv_integer2(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD) #define ffetarget_eqv_integer3(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD) #define ffetarget_eqv_integer4(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD) #define ffetarget_eqv_logical1(res,l,r) (*(res) = (l) == (r), FFEBAD) #define ffetarget_eqv_logical2(res,l,r) (*(res) = (l) == (r), FFEBAD) #define ffetarget_eqv_logical3(res,l,r) (*(res) = (l) == (r), FFEBAD) #define ffetarget_eqv_logical4(res,l,r) (*(res) = (l) == (r), FFEBAD) #define ffetarget_ge_integer1(res,l,r) \ (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ge_integer2(res,l,r) \ (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ge_integer3(res,l,r) \ (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ge_integer4(res,l,r) \ (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ge_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_ge_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_gt_integer1(res,l,r) \ (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_gt_integer2(res,l,r) \ (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_gt_integer3(res,l,r) \ (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_gt_integer4(res,l,r) \ (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_gt_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \ ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_gt_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \ ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_hexxmil(v,t) ffetarget_typeless_hex (v, t) #define ffetarget_hexxvxt(v,t) ffetarget_typeless_hex (v, t) #define ffetarget_hexzmil(v,t) ffetarget_typeless_hex (v, t) #define ffetarget_hexzvxt(v,t) ffetarget_typeless_hex (v, t) #define ffetarget_init_0() #define ffetarget_init_1() #define ffetarget_init_2() #define ffetarget_init_3() #define ffetarget_init_4() #ifdef FFETARGET_32bit_longs #define ffetarget_integerdefault_is_magical(i) \ (((unsigned long int) i) == FFETARGET_integerBIG_MAGICAL) #else #define ffetarget_integerdefault_is_magical(i) \ (((unsigned int) i) == FFETARGET_integerBIG_MAGICAL) #endif #define ffetarget_iszero_real1(l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ REAL_VALUES_EQUAL (lr, dconst0); \ }) #define ffetarget_iszero_real2(l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ REAL_VALUES_EQUAL (lr, dconst0); \ }) #define ffetarget_iszero_typeless(l) ((l) == 0) #define ffetarget_logical1(v,truth) (*(v) = truth ? 1 : 0) #define ffetarget_le_integer1(res,l,r) \ (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_le_integer2(res,l,r) \ (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_le_integer3(res,l,r) \ (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_le_integer4(res,l,r) \ (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_le_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \ ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_le_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \ ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_lt_integer1(res,l,r) \ (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_lt_integer2(res,l,r) \ (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_lt_integer3(res,l,r) \ (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_lt_integer4(res,l,r) \ (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_lt_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_lt_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \ FFEBAD; }) #define ffetarget_length_character1(c) ((c).length) #define ffetarget_length_characterdefault ffetarget_length_character1 #define ffetarget_make_real1(res,lr) \ ffetarget_cvt_rv_to_r1_ ((lr), *(res)) #define ffetarget_make_real2(res,lr) \ ffetarget_cvt_rv_to_r2_ ((lr), &((res)->v[0])) #define ffetarget_multiply_integer1(res,l,r) (*(res) = (l) * (r), FFEBAD) #define ffetarget_multiply_integer2(res,l,r) (*(res) = (l) * (r), FFEBAD) #define ffetarget_multiply_integer3(res,l,r) (*(res) = (l) * (r), FFEBAD) #define ffetarget_multiply_integer4(res,l,r) (*(res) = (l) * (r), FFEBAD) #define ffetarget_multiply_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_multiply_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_ne_complex1(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ rr = ffetarget_cvt_r1_to_rv_ ((r).real); \ ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \ *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \ ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_ne_complex2(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \ ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \ *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \ ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_ne_integer1(res,l,r) \ (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ne_integer2(res,l,r) \ (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ne_integer3(res,l,r) \ (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ne_integer4(res,l,r) \ (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD) #define ffetarget_ne_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_ne_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \ FFEBAD; }) #define ffetarget_neqv_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_neqv_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_neqv_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_neqv_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_neqv_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_neqv_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_neqv_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_neqv_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_not_integer1(res,l) (*(res) = ~(l), FFEBAD) #define ffetarget_not_integer2(res,l) (*(res) = ~(l), FFEBAD) #define ffetarget_not_integer3(res,l) (*(res) = ~(l), FFEBAD) #define ffetarget_not_integer4(res,l) (*(res) = ~(l), FFEBAD) #define ffetarget_not_logical1(res,l) (*(res) = !(l), FFEBAD) #define ffetarget_not_logical2(res,l) (*(res) = !(l), FFEBAD) #define ffetarget_not_logical3(res,l) (*(res) = !(l), FFEBAD) #define ffetarget_not_logical4(res,l) (*(res) = !(l), FFEBAD) #define ffetarget_octalmil(v,t) ffetarget_typeless_octal (v, t) #define ffetarget_octalvxt(v,t) ffetarget_typeless_octal (v, t) #define ffetarget_offset(res,l) (*(res) = (l), TRUE) /* Overflow? */ #define ffetarget_offset_add(res,l,r) (*(res) = (l) + (r), TRUE) /* Overflow? */ #define ffetarget_offset_charsize(res,l,u) (*(res) = (l) * (u), TRUE) /* Ov? */ #define ffetarget_offset_multiply(res,l,r) (*(res) = (l) * (r), TRUE) /* Ov? */ #define ffetarget_offset_overflow(text) ((void) 0) /* ~~no message? */ #define ffetarget_or_integer1(res,l,r) (*(res) = (l) | (r), FFEBAD) #define ffetarget_or_integer2(res,l,r) (*(res) = (l) | (r), FFEBAD) #define ffetarget_or_integer3(res,l,r) (*(res) = (l) | (r), FFEBAD) #define ffetarget_or_integer4(res,l,r) (*(res) = (l) | (r), FFEBAD) #define ffetarget_or_logical1(res,l,r) (*(res) = (l) || (r), FFEBAD) #define ffetarget_or_logical2(res,l,r) (*(res) = (l) || (r), FFEBAD) #define ffetarget_or_logical3(res,l,r) (*(res) = (l) || (r), FFEBAD) #define ffetarget_or_logical4(res,l,r) (*(res) = (l) || (r), FFEBAD) #define ffetarget_print_binarymil(f,v) ffetarget_print_binary (f, v) #define ffetarget_print_binaryvxt(f,v) ffetarget_print_binary (f, v) #define ffetarget_print_hexxmil(f,v) ffetarget_print_hex (f, v) #define ffetarget_print_hexxvxt(f,v) ffetarget_print_hex (f, v) #define ffetarget_print_hexzmil(f,v) ffetarget_print_hex (f, v) #define ffetarget_print_hexzvxt(f,v) ffetarget_print_hex (f, v) #define ffetarget_print_integer1(f,v) \ fprintf ((f), "%" ffetargetInteger1_f "d", (v)) #define ffetarget_print_integer2(f,v) \ fprintf ((f), "%" ffetargetInteger2_f "d", (v)) #define ffetarget_print_integer3(f,v) \ fprintf ((f), "%" ffetargetInteger3_f "d", (v)) #define ffetarget_print_integer4(f,v) \ fprintf ((f), "%" ffetargetInteger4_f "d", (v)) #define ffetarget_print_logical1(f,v) \ fprintf ((f), "%" ffetargetLogical1_f "d", (v)) #define ffetarget_print_logical2(f,v) \ fprintf ((f), "%" ffetargetLogical2_f "d", (v)) #define ffetarget_print_logical3(f,v) \ fprintf ((f), "%" ffetargetLogical3_f "d", (v)) #define ffetarget_print_logical4(f,v) \ fprintf ((f), "%" ffetargetLogical4_f "d", (v)) #define ffetarget_print_octalmil(f,v) ffetarget_print_octal(f,v) #define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v) #define ffetarget_print_real1(f,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ real_to_decimal (ffetarget_string_, &lr \ sizeof(ffetarget_string_), 0, 1); \ fputs (ffetarget_string_, (f)); \ }) #define ffetarget_print_real2(f,l) \ ({ REAL_VALUE_TYPE lr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ real_to_decimal (ffetarget_string_, &lr, \ sizeof(ffetarget_string_), 0, 1); \ fputs (ffetarget_string_, (f)); \ }) #define ffetarget_real1_one(res) ffetarget_cvt_rv_to_r1_ (dconst1, *(res)) #define ffetarget_real2_one(res) ffetarget_cvt_rv_to_r2_ (dconst1, &((res)->v[0])) #define ffetarget_real1_two(res) ffetarget_cvt_rv_to_r1_ (dconst2, *(res)) #define ffetarget_real2_two(res) ffetarget_cvt_rv_to_r2_ (dconst2, &((res)->v[0])) #define ffetarget_real1_zero(res) ffetarget_cvt_rv_to_r1_ (dconst0, *(res)) #define ffetarget_real2_zero(res) ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0])) #define ffetarget_size_typeless_binary(t) ((ffetarget_num_digits_(t) + 7) / 8) #define ffetarget_size_typeless_octal(t) \ ((ffetarget_num_digits_(t) * 3 + 7) / 8) #define ffetarget_size_typeless_hex(t) ((ffetarget_num_digits_(t) + 1) / 2) #define ffetarget_subtract_complex1(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ rr = ffetarget_cvt_r1_to_rv_ ((r).real); \ ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \ REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \ REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \ ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \ FFEBAD; }) #define ffetarget_subtract_complex2(res,l,r) \ ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \ ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \ REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \ REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \ FFEBAD; }) #define ffetarget_subtract_integer1(res,l,r) (*(res) = (l) - (r), FFEBAD) #define ffetarget_subtract_integer2(res,l,r) (*(res) = (l) - (r), FFEBAD) #define ffetarget_subtract_integer3(res,l,r) (*(res) = (l) - (r), FFEBAD) #define ffetarget_subtract_integer4(res,l,r) (*(res) = (l) - (r), FFEBAD) #define ffetarget_subtract_real1(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ rr = ffetarget_cvt_r1_to_rv_ ((r)); \ REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_subtract_real2(res,l,r) \ ({ REAL_VALUE_TYPE lr, rr, resr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \ REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_terminate_0() #define ffetarget_terminate_1() #define ffetarget_terminate_2() #define ffetarget_terminate_3() #define ffetarget_terminate_4() #define ffetarget_text_character1(c) ((c).text) #define ffetarget_text_characterdefault ffetarget_text_character1 #define ffetarget_uminus_complex1(res,l) \ ({ REAL_VALUE_TYPE lr, li, resr, resi; \ lr = ffetarget_cvt_r1_to_rv_ ((l).real); \ li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \ resr = REAL_VALUE_NEGATE (lr); \ resi = REAL_VALUE_NEGATE (li); \ ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \ ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \ FFEBAD; }) #define ffetarget_uminus_complex2(res,l) \ ({ REAL_VALUE_TYPE lr, li, resr, resi; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \ li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \ resr = REAL_VALUE_NEGATE (lr); \ resi = REAL_VALUE_NEGATE (li); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \ ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \ FFEBAD; }) #define ffetarget_uminus_integer1(res,l) (*(res) = -(l), FFEBAD) #define ffetarget_uminus_integer2(res,l) (*(res) = -(l), FFEBAD) #define ffetarget_uminus_integer3(res,l) (*(res) = -(l), FFEBAD) #define ffetarget_uminus_integer4(res,l) (*(res) = -(l), FFEBAD) #define ffetarget_uminus_real1(res,l) \ ({ REAL_VALUE_TYPE lr, resr; \ lr = ffetarget_cvt_r1_to_rv_ ((l)); \ resr = REAL_VALUE_NEGATE (lr); \ ffetarget_cvt_rv_to_r1_ (resr, *(res)); \ FFEBAD; }) #define ffetarget_uminus_real2(res,l) \ ({ REAL_VALUE_TYPE lr, resr; \ lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \ resr = REAL_VALUE_NEGATE (lr); \ ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \ FFEBAD; }) #define ffetarget_value_real1(lr) ffetarget_cvt_r1_to_rv_ ((lr)) #define ffetarget_value_real2(lr) ffetarget_cvt_r2_to_rv_ (&((lr).v[0])) #define ffetarget_xor_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_xor_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_xor_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_xor_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD) #define ffetarget_xor_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_xor_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_xor_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD) #define ffetarget_xor_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD) /* End of #include file. */ #endif /* ! GCC_F_TARGET_H */