/* target.h -- Public #include File (module.h template V1.0)
   Copyright (C) 1995 Free Software Foundation, Inc.
   Contributed by James Craig Burley (burley@gnu.ai.mit.edu).

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, 675 Mass Ave, Cambridge, MA 02139, USA.

   Owning Modules:
      target.c

   Modifications:
*/

/* Allow multiple inclusion to work. */

#ifndef _H_f_target
#define _H_f_target

#ifdef FFE_STANDALONE
#define HOST_WIDE_INT long
#else
#ifndef TREE_CODE
#include "tree.j"
#endif
#endif

/* For now, g77 requires the ability to determine the exact bit pattern
   of a float on the target machine.  (Hopefully this will be changed
   soon).  Make sure we can do this.  */

#if !defined (REAL_ARITHMETIC) \
  && ((TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT) \
      || (FLOAT_WORDS_BIG_ENDIAN != HOST_FLOAT_WORDS_BIG_ENDIAN))
#error g77 requires ability to access exact FP representation of target machine
#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_defaultIS_UGLY
#define FFETARGET_defaultIS_UGLY 0
#endif
#ifndef FFETARGET_defaultIS_UGLY_ARGS
#define FFETARGET_defaultIS_UGLY_ARGS 1
#endif
#ifndef FFETARGET_defaultIS_UGLY_INIT
#define FFETARGET_defaultIS_UGLY_INIT 1
#endif
#ifndef FFETARGET_defaultIS_VXT_NOT_90
#define FFETARGET_defaultIS_VXT_NOT_90 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_defaultSTATE_DCP
#define FFETARGET_defaultSTATE_DCP FFE_intrinsicstateENABLED
#endif
#ifndef FFETARGET_defaultSTATE_F2C
#define FFETARGET_defaultSTATE_F2C FFE_intrinsicstateENABLED
#endif
#ifndef FFETARGET_defaultSTATE_F90
#define FFETARGET_defaultSTATE_F90 FFE_intrinsicstateDELETED
#endif
#ifndef FFETARGET_defaultSTATE_MIL
#define FFETARGET_defaultSTATE_MIL FFE_intrinsicstateENABLED
#endif
#ifndef FFETARGET_defaultSTATE_VXT
#define FFETARGET_defaultSTATE_VXT FFE_intrinsicstateDELETED
#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_isEXTERNAL_UNDERSCORED
#define FFETARGET_isEXTERNAL_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_isEXTERNAL_UNDERSCORED).  */

#ifndef FFETARGET_isUNDERSCORED_EXTERNAL_UNDERSCORED
#define FFETARGET_isUNDERSCORED_EXTERNAL_UNDERSCORED FFETARGET_isEXTERNAL_UNDERSCORED
#endif

/* If FFETARGET_isEXTERNAL_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_OCTAL
#define FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL 04000000000
#endif
#ifndef FFETARGET_integerFINISH_BIG_MAGICAL
#define FFETARGET_integerFINISH_BIG_MAGICAL 8
#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 0
#define FFETARGET_okINTEGER3 0
#define FFETARGET_okINTEGER4 0
#define FFETARGET_okLOGICAL1 1
#define FFETARGET_okLOGICAL2 0
#define FFETARGET_okLOGICAL3 0
#define FFETARGET_okLOGICAL4 0
#define FFETARGET_okREAL1 1
#define FFETARGET_okREAL2 1
#define FFETARGET_okREAL3 0
#define FFETARGET_okCOMPLEX1 1
#define FFETARGET_okCOMPLEX2 1
#define FFETARGET_okCOMPLEX3 0
#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

/* Typedefs. */

typedef unsigned char ffetargetAlign;	/* ffetargetOffset for alignment. */
#define ffetargetAlign_f ""
typedef unsigned long ffetargetCharacterSize;
#define ffetargetCharacterSize_f "l"
typedef void (*ffetargetCopyfunc) (void *, void *, size_t);
typedef ffetargetCharacterSize ffetargetHollerithSize;
#define ffetargetHollerithSize_f "l"
typedef unsigned long ffetargetOffset;
#define ffetargetOffset_f "l"

#if FFETARGET_okINTEGER1
typedef long int ffetargetInteger1;
#define ffetargetInteger1_f "l"
#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
?
#endif
#if FFETARGET_okINTEGER5
typedef ? ffetargetInteger5;
#define ffetargetInteger5_f
?
#endif
#if FFETARGET_okINTEGER6
typedef ? ffetargetInteger6;
#define ffetargetInteger6_f
?
#endif
#if FFETARGET_okINTEGER7
typedef ? ffetargetInteger7;
#define ffetargetInteger7_f
?
#endif
#if FFETARGET_okINTEGER8
typedef ? ffetargetInteger8;
#define ffetargetInteger8_f
?
#endif
#if FFETARGET_okLOGICAL1
typedef long int ffetargetLogical1;
#define ffetargetLogical1_f "l"
#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
?
#endif
#if FFETARGET_okLOGICAL5
typedef ? ffetargetLogical5;
#define ffetargetLogical5_f
?
#endif
#if FFETARGET_okLOGICAL6
typedef ? ffetargetLogical6;
#define ffetargetLogical6_f
?
#endif
#if FFETARGET_okLOGICAL7
typedef ? ffetargetLogical7;
#define ffetargetLogical7_f
?
#endif
#if FFETARGET_okLOGICAL8
typedef ? ffetargetLogical8;
#define ffetargetLogical8_f
?
#endif
#if FFETARGET_okREAL1
#ifdef REAL_ARITHMETIC
typedef HOST_WIDE_INT ffetargetReal1;
#else
typedef float ffetargetReal1;
#define ffetargetReal1_f ""
#endif
#endif
#if FFETARGET_okREAL2
#ifdef REAL_ARITHMETIC
typedef struct
  {
    HOST_WIDE_INT v[2];
  }
ffetargetReal2;
#else
typedef double ffetargetReal2;
#define ffetargetReal2_f ""
#endif
#endif
#if FFETARGET_okREAL3
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal3[?];
#else
typedef ? ffetargetReal3;
#define ffetargetReal3_f
#endif
?
#endif
#if FFETARGET_okREAL4
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal4[?];
#else
typedef ? ffetargetReal4;
#define ffetargetReal4_f
#endif
?
#endif
#if FFETARGET_okREAL5
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal5[?];
#else
typedef ? ffetargetReal5;
#define ffetargetReal5_f
#endif
?
#endif
#if FFETARGET_okREAL6
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal6[?];
#else
typedef ? ffetargetReal6;
#define ffetargetReal6_f
#endif
?
#endif
#if FFETARGET_okREAL7
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal7[?];
#else
typedef ? ffetargetReal7;
#define ffetargetReal7_f
#endif
?
#endif
#if FFETARGET_okREAL8
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal8[?];
#else
typedef ? ffetargetReal8;
#define ffetargetReal8_f
#endif
?
#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_okCOMPLEX4
struct _ffetarget_complex_4_
  {
    ffetargetReal4 real;
    ffetargetReal4 imaginary;
  };
typedef struct _ffetarget_complex_4_ ffetargetComplex4;
#endif
#if FFETARGET_okCOMPLEX5
struct _ffetarget_complex_5_
  {
    ffetargetReal5 real;
    ffetargetReal5 imaginary;
  };
typedef struct _ffetarget_complex_5_ ffetargetComplex5;
#endif
#if FFETARGET_okCOMPLEX6
struct _ffetarget_complex_6_
  {
    ffetargetReal6 real;
    ffetargetReal6 imaginary;
  };
typedef struct _ffetarget_complex_6_ ffetargetComplex6;
#endif
#if FFETARGET_okCOMPLEX7
struct _ffetarget_complex_7_
  {
    ffetargetReal7 real;
    ffetargetReal7 imaginary;
  };
typedef struct _ffetarget_complex_7_ ffetargetComplex7;
#endif
#if FFETARGET_okCOMPLEX8
struct _ffetarget_complex_8_
  {
    ffetargetReal8 real;
    ffetargetReal8 imaginary;
  };
typedef struct _ffetarget_complex_8_ ffetargetComplex8;
#endif
#if FFETARGET_okCHARACTER1
struct _ffetarget_char_1_
  {
    ffetargetCharacterSize length;
    unsigned char *text;
  };
typedef struct _ffetarget_char_1_ ffetargetCharacter1;
typedef unsigned char ffetargetCharacterUnit1;
#endif
#if FFETARGET_okCHARACTER2
typedef ? ffetargetCharacter2;
typedef ? ffetargetCharacterUnit2;
#endif
#if FFETARGET_okCHARACTER3
typedef ? ffetargetCharacter3;
typedef ? ffetargetCharacterUnit3;
#endif
#if FFETARGET_okCHARACTER4
typedef ? ffetargetCharacter4;
typedef ? ffetargetCharacterUnit4;
#endif
#if FFETARGET_okCHARACTER5
typedef ? ffetargetCharacter5;
typedef ? ffetargetCharacterUnit5;
#endif
#if FFETARGET_okCHARACTER6
typedef ? ffetargetCharacter6;
typedef ? ffetargetCharacterUnit6;
#endif
#if FFETARGET_okCHARACTER7
typedef ? ffetargetCharacter7;
typedef ? ffetargetCharacterUnit7;
#endif
#if FFETARGET_okCHARACTER8
typedef ? ffetargetCharacter8;
typedef ? ffetargetCharacterUnit8;
#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_integer1 (ffetargetCharacter1 *res,
					      ffetargetCharacterSize res_size,
					      ffetargetInteger1 l,
					      mallocPool pool);
ffebad ffetarget_convert_character1_logical1 (ffetargetCharacter1 *res,
					      ffetargetCharacterSize res_size,
					      ffetargetLogical1 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_okCOMPLEX4
ffebad ffetarget_divide_complex4 (ffetargetComplex4 *res, ffetargetComplex4 l,
				  ffetargetComplex4 r);
#endif
#if FFETARGET_okCOMPLEX5
ffebad ffetarget_divide_complex5 (ffetargetComplex5 *res, ffetargetComplex5 l,
				  ffetargetComplex5 r);
#endif
#if FFETARGET_okCOMPLEX6
ffebad ffetarget_divide_complex6 (ffetargetComplex6 *res, ffetargetComplex6 l,
				  ffetargetComplex6 r);
#endif
#if FFETARGET_okCOMPLEX7
ffebad ffetarget_divide_complex7 (ffetargetComplex7 *res, ffetargetComplex7 l,
				  ffetargetComplex7 r);
#endif
#if FFETARGET_okCOMPLEX8
ffebad ffetarget_divide_complex8 (ffetargetComplex8 *res, ffetargetComplex8 l,
				  ffetargetComplex8 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
#if FFETARGET_okINTEGER5
bool ffetarget_integer5 (ffetargetInteger5 *val, ffelexToken integer);
#endif
#if FFETARGET_okINTEGER6
bool ffetarget_integer6 (ffetargetInteger6 *val, ffelexToken integer);
#endif
#if FFETARGET_okINTEGER7
bool ffetarget_integer7 (ffetargetInteger7 *val, ffelexToken integer);
#endif
#if FFETARGET_okINTEGER8
bool ffetarget_integer8 (ffetargetInteger8 *val, ffelexToken integer);
#endif
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);
void ffetarget_layout (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
#if FFETARGET_okCOMPLEX4
ffebad ffetarget_multiply_complex4 (ffetargetComplex4 *res,
				    ffetargetComplex4 l,
				    ffetargetComplex4 r);
#endif
#if FFETARGET_okCOMPLEX5
ffebad ffetarget_multiply_complex5 (ffetargetComplex5 *res,
				    ffetargetComplex5 l,
				    ffetargetComplex5 r);
#endif
#if FFETARGET_okCOMPLEX6
ffebad ffetarget_multiply_complex6 (ffetargetComplex6 *res,
				    ffetargetComplex6 l,
				    ffetargetComplex6 r);
#endif
#if FFETARGET_okCOMPLEX7
ffebad ffetarget_multiply_complex7 (ffetargetComplex7 *res,
				    ffetargetComplex7 l,
				    ffetargetComplex7 r);
#endif
#if FFETARGET_okCOMPLEX8
ffebad ffetarget_multiply_complex8 (ffetargetComplex8 *res,
				    ffetargetComplex8 l,
				    ffetargetComplex8 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
#if FFETARGET_okREAL4
bool ffetarget_real4 (ffetargetReal4 *value, ffelexToken integer,
		      ffelexToken decimal, ffelexToken fraction,
		      ffelexToken exponent, ffelexToken exponent_sign,
		      ffelexToken exponent_digits);
#endif
#if FFETARGET_okREAL5
bool ffetarget_real5 (ffetargetReal5 *value, ffelexToken integer,
		      ffelexToken decimal, ffelexToken fraction,
		      ffelexToken exponent, ffelexToken exponent_sign,
		      ffelexToken exponent_digits);
#endif
#if FFETARGET_okREAL6
bool ffetarget_real6 (ffetargetReal6 *value, ffelexToken integer,
		      ffelexToken decimal, ffelexToken fraction,
		      ffelexToken exponent, ffelexToken exponent_sign,
		      ffelexToken exponent_digits);
#endif
#if FFETARGET_okREAL7
bool ffetarget_real7 (ffetargetReal7 *value, ffelexToken integer,
		      ffelexToken decimal, ffelexToken fraction,
		      ffelexToken exponent, ffelexToken exponent_sign,
		      ffelexToken exponent_digits);
#endif
#if FFETARGET_okREAL8
bool ffetarget_real8 (ffetargetReal8 *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);
int ffetarget_num_digits_ (ffelexToken t);
void *ffetarget_memcpy_ (void *dst, void *src, size_t len);

/* Define macros. */

#ifdef REAL_ARITHMETIC
#define ffetarget_add_complex1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
     ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
     REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
     REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
     FFEBAD; })
#define ffetarget_add_complex2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
     ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
     REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
     REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
     FFEBAD; })
#else
#define ffetarget_add_complex1(res,l,r) \
  ((res)->real = (l).real + (r).real, \
   (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
#define ffetarget_add_complex2(res,l,r) \
  ((res)->real = (l).real + (r).real, \
   (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_add_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
     FFEBAD; })
#define ffetarget_add_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
     FFEBAD; })
#else
#define ffetarget_add_real1(res,l,r) (*(res) = (l) + (r), FFEBAD)
#define ffetarget_add_real2(res,l,r) (*(res) = (l) + (r), FFEBAD)
#endif
#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_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_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_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_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_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)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_complex2(res,l) \
  ({ REAL_VALUE_TYPE lr, li; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     REAL_VALUE_TO_TARGET_SINGLE (lr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (li, (res)->imaginary), \
     FFEBAD; })
#else
#define ffetarget_convert_complex1_complex2(res,l) \
  ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_integer(res,l) \
  ({ REAL_VALUE_TYPE resi, resr; \
     ffetargetInteger1 lf = (l); \
     REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
     resi = dconst0; \
     REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
     FFEBAD; })
#else
#define ffetarget_convert_complex1_integer(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_real1(res,l) \
  ((res)->real = (l), \
   REAL_VALUE_TO_TARGET_SINGLE (dconst0, (res)->imaginary), \
   FFEBAD)
#define ffetarget_convert_complex1_real2(res,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     REAL_VALUE_TO_TARGET_SINGLE (lr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (dconst0, (res)->imaginary), \
     FFEBAD; })
#else
#define ffetarget_convert_complex1_real1(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#define ffetarget_convert_complex1_real2(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_complex1(res,l) \
  ({ REAL_VALUE_TYPE lr, li; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (li, (long *) &((res)->imaginary.v[0])), \
     FFEBAD; })
#else
#define ffetarget_convert_complex2_complex1(res,l) \
  ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_integer(res,l) \
  ({ REAL_VALUE_TYPE resi, resr; \
     ffetargetInteger1 lf = (l); \
     REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
     resi = dconst0; \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
     FFEBAD; })
#else
#define ffetarget_convert_complex2_integer(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_real1(res,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE (l); \
     REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->imaginary.v[0])), \
     FFEBAD; })
#define ffetarget_convert_complex2_real2(res,l) \
  ((res)->real = (l), \
   REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->imaginary.v[0])), \
   FFEBAD)
#else
#define ffetarget_convert_complex2_real1(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#define ffetarget_convert_complex2_real2(res,l) \
  ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#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_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_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_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_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_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_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_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)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_integer1_real1(res,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE (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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((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 = REAL_VALUE_FROM_TARGET_SINGLE ((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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
     *(res) = ffetarget_long_val_; \
     FFEBAD; })
#else
#define ffetarget_convert_integer1_real1(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_real2(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_complex1(res,l) (*(res) = (l).real, FFEBAD)
#define ffetarget_convert_integer1_complex2(res,l) (*(res) = (l).real, FFEBAD)
#endif
#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_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)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real1_integer1(res,l) \
  ({ REAL_VALUE_TYPE resr; \
     ffetargetInteger1 lf = (l); \
     REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
     FFEBAD; })
#else
#define ffetarget_convert_real1_integer1(res,l) (*(res) = (l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real1_real2(res,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     REAL_VALUE_TO_TARGET_SINGLE (lr, *(res)); \
     FFEBAD; })
#else
#define ffetarget_convert_real1_real2(res,l) (*(res) = (l), FFEBAD)
#endif
#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_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)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real2_integer(res,l) \
  ({ REAL_VALUE_TYPE resr; \
     ffetargetInteger1 lf = (l); \
     REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
     FFEBAD; })
#define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer
#else
#define ffetarget_convert_real2_integer1(res,l) (*(res) = (l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real2_real1(res,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->v[0])); \
     FFEBAD; })
#else
#define ffetarget_convert_real2_real1(res,l) (*(res) = (l), FFEBAD)
#endif
#define ffetarget_divide_integer1(res,l,r) \
  (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
   : (*(res) = (l) / (r), FFEBAD))
#ifdef REAL_ARITHMETIC
#define ffetarget_divide_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     REAL_VALUES_EQUAL (rr, dconst0) \
       ? ({ REAL_VALUE_TO_TARGET_SINGLE (dconst0, *(res)); \
	    FFEBAD_DIV_BY_ZERO; \
	  }) \
	 : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
	      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
	      FFEBAD; \
	    }); \
	 })
#define ffetarget_divide_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     REAL_VALUES_EQUAL (rr, dconst0) \
       ? ({ REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->v[0])); \
	    FFEBAD_DIV_BY_ZERO; \
	  }) \
	 : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
	      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
	      FFEBAD; \
	    }); \
	 })
#else
#define ffetarget_divide_real1(res,l,r) \
  (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
   : (*(res) = (l) / (r), FFEBAD))
#define ffetarget_divide_real2(res,l,r) \
  (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
   : (*(res) = (l) / (r), FFEBAD))
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_eq_complex1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
     ri = REAL_VALUE_FROM_TARGET_SINGLE ((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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
     ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
     *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
       ? TRUE : FALSE; \
     FFEBAD; })
#else
#define ffetarget_eq_complex1(res,l,r) \
  (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
   ? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_complex2(res,l,r) \
  (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
   ? TRUE : FALSE, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_eq_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
     FFEBAD; })
#define ffetarget_eq_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
     FFEBAD; })
#else
#define ffetarget_eq_real1(res,l,r) \
  (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_real2(res,l,r) \
  (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#endif
#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_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_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)
#ifdef REAL_ARITHMETIC
#define ffetarget_ge_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
     FFEBAD; })
#define ffetarget_ge_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
     FFEBAD; })
#else
#define ffetarget_ge_real1(res,l,r) \
  (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ge_real2(res,l,r) \
  (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_gt_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
       ? FALSE : TRUE; \
     FFEBAD; })
#else
#define ffetarget_gt_real1(res,l,r) \
  (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_gt_real2(res,l,r) \
  (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#endif
#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()
#define ffetarget_integerdefault_is_magical(i) \
  (i == FFETARGET_integerBIG_MAGICAL)
#ifdef REAL_ARITHMETIC
#define ffetarget_iszero_real1(l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     REAL_VALUES_EQUAL (lr, dconst0); \
   })
#define ffetarget_iszero_real2(l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     REAL_VALUES_EQUAL (lr, dconst0); \
   })
#else
#define ffetarget_iszero_real1(l) ((l) == 0.)
#define ffetarget_iszero_real2(l) ((l) == 0.)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_le_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
       ? TRUE : FALSE; \
     FFEBAD; })
#else
#define ffetarget_le_real1(res,l,r) \
  (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_le_real2(res,l,r) \
  (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_lt_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
     FFEBAD; })
#define ffetarget_lt_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
     FFEBAD; })
#else
#define ffetarget_lt_real1(res,l,r) \
  (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_lt_real2(res,l,r) \
  (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_length_character1(c) ((c).length)
#define ffetarget_length_characterdefault ffetarget_length_character1
#ifdef REAL_ARITHMETIC
#define ffetarget_make_real1(res,lr) \
  REAL_VALUE_TO_TARGET_SINGLE ((lr), *(res))
#define ffetarget_make_real2(res,lr) \
  REAL_VALUE_TO_TARGET_DOUBLE ((lr), (long *) &((res)->v[0]))
#else
#define ffetarget_make_real1(res,lr) (*(res) = (lr))
#define ffetarget_make_real2(res,lr) (*(res) = (lr))
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_multiply_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
     FFEBAD; })
#define ffetarget_multiply_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
     FFEBAD; })
#else
#define ffetarget_multiply_real1(res,l,r) (*(res) = (l) * (r), FFEBAD)
#define ffetarget_multiply_real2(res,l,r) (*(res) = (l) * (r), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_ne_complex1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
     ri = REAL_VALUE_FROM_TARGET_SINGLE ((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 = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
     ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
     *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
       ? FALSE : TRUE; \
     FFEBAD; })
#else
#define ffetarget_ne_complex1(res,l,r) \
  (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
   ? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_complex2(res,l,r) \
  (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
   ? TRUE : FALSE, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_ne_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
     FFEBAD; })
#define ffetarget_ne_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
     FFEBAD; })
#else
#define ffetarget_ne_real1(res,l,r) \
  (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_real2(res,l,r) \
  (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#endif
#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_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_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_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_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_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_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_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_octalmil(f,v) ffetarget_print_octal(f,v)
#define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v)
#ifdef REAL_ARITHMETIC
#define ffetarget_print_real1(f,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
     fputs (ffetarget_string_, (f)); \
   })
#define ffetarget_print_real2(f,l) \
  ({ REAL_VALUE_TYPE lr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
     fputs (ffetarget_string_, (f)); \
   })
#else
#define ffetarget_print_real1(f,v) \
  fprintf ((f), "%" ffetargetReal1_f "g", (v))
#define ffetarget_print_real2(f,v) \
  fprintf ((f), "%" ffetargetReal2_f "g", (v))
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_one(res) REAL_VALUE_TO_TARGET_SINGLE (dconst1, *(res))
#define ffetarget_real2_one(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst1, (long *) &((res)->v[0]))
#else
#define ffetarget_real1_one(res) (*(res) = (float) 1.)
#define ffetarget_real2_one(res) (*(res) = 1.)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_two(res) REAL_VALUE_TO_TARGET_SINGLE (dconst2, *(res))
#define ffetarget_real2_two(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst2, (long *) &((res)->v[0]))
#else
#define ffetarget_real1_two(res) (*(res) = (float) 2.)
#define ffetarget_real2_two(res) (*(res) = 2.)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_zero(res) REAL_VALUE_TO_TARGET_SINGLE (dconst0, *(res))
#define ffetarget_real2_zero(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->v[0]))
#else
#define ffetarget_real1_zero(res) (*(res) = (float) 0.)
#define ffetarget_real2_zero(res) (*(res) = 0.)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_subtract_complex1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
     ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
     REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
     REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
     FFEBAD; })
#define ffetarget_subtract_complex2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
     ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
     REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
     REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
     FFEBAD; })
#else
#define ffetarget_subtract_complex1(res,l,r) \
  ((res)->real = (l).real - (r).real, \
   (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
#define ffetarget_subtract_complex2(res,l,r) \
  ((res)->real = (l).real - (r).real, \
   (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_subtract_real1(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
     REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
     FFEBAD; })
#define ffetarget_subtract_real2(res,l,r) \
  ({ REAL_VALUE_TYPE lr, rr, resr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
     REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
     FFEBAD; })
#else
#define ffetarget_subtract_real1(res,l,r) (*(res) = (l) - (r), FFEBAD)
#define ffetarget_subtract_real2(res,l,r) (*(res) = (l) - (r), FFEBAD)
#endif
#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
#ifdef REAL_ARITHMETIC
#define ffetarget_uminus_complex1(res,l) \
  ({ REAL_VALUE_TYPE lr, li, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
     li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
     resr = REAL_VALUE_NEGATE (lr); \
     resi = REAL_VALUE_NEGATE (li); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
     REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
     FFEBAD; })
#define ffetarget_uminus_complex2(res,l) \
  ({ REAL_VALUE_TYPE lr, li, resr, resi; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
     li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
     resr = REAL_VALUE_NEGATE (lr); \
     resi = REAL_VALUE_NEGATE (li); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
     REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
     FFEBAD; })
#else
#define ffetarget_uminus_complex1(res,l) \
  ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
#define ffetarget_uminus_complex2(res,l) \
  ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
#endif
#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)
#ifdef REAL_ARITHMETIC
#define ffetarget_uminus_real1(res,l) \
  ({ REAL_VALUE_TYPE lr, resr; \
     lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
     resr = REAL_VALUE_NEGATE (lr); \
     REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
     FFEBAD; })
#define ffetarget_uminus_real2(res,l) \
  ({ REAL_VALUE_TYPE lr, resr; \
     lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
     resr = REAL_VALUE_NEGATE (lr); \
     REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
     FFEBAD; })
#else
#define ffetarget_uminus_real1(res,l) (*(res) = -(l), FFEBAD)
#define ffetarget_uminus_real2(res,l) (*(res) = -(l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_value_real1(lr) REAL_VALUE_FROM_TARGET_SINGLE ((lr))
#define ffetarget_value_real2(lr) REAL_VALUE_FROM_TARGET_DOUBLE (&((lr).v[0]))
#else
#define ffetarget_value_real1
#define ffetarget_value_real2
#endif
#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_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)

/* End of #include file. */

#endif
