home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / g77-0.5.15-src.tgz / tar.out / fsf / g77 / f / target.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  63KB  |  1,640 lines
  1. /* target.h -- Public #include File (module.h template V1.0)
  2.    Copyright (C) 1995 Free Software Foundation, Inc.
  3.    Contributed by James Craig Burley (burley@gnu.ai.mit.edu).
  4.  
  5. This file is part of GNU Fortran.
  6.  
  7. GNU Fortran is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU Fortran is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Fortran; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.    Owning Modules:
  22.       target.c
  23.  
  24.    Modifications:
  25. */
  26.  
  27. /* Allow multiple inclusion to work. */
  28.  
  29. #ifndef _H_f_target
  30. #define _H_f_target
  31.  
  32. #ifdef FFE_STANDALONE
  33. #define HOST_WIDE_INT long
  34. #else
  35. #ifndef TREE_CODE
  36. #include "tree.j"
  37. #endif
  38. #endif
  39.  
  40. /* For now, g77 requires the ability to determine the exact bit pattern
  41.    of a float on the target machine.  (Hopefully this will be changed
  42.    soon).  Make sure we can do this.  */
  43.  
  44. #if !defined (REAL_ARITHMETIC) \
  45.   && ((TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT) \
  46.       || (FLOAT_WORDS_BIG_ENDIAN != HOST_FLOAT_WORDS_BIG_ENDIAN))
  47. #error g77 requires ability to access exact FP representation of target machine
  48. #endif
  49.  
  50. /* Simple definitions and enumerations. */
  51.  
  52. #define FFETARGET_charactersizeNONE (-1)
  53. #ifndef FFETARGET_charactersizeMAXIMUM
  54. #define FFETARGET_charactersizeMAXIMUM 2147483647
  55. #endif
  56.  
  57. #ifndef FFETARGET_defaultIS_90
  58. #define FFETARGET_defaultIS_90 0
  59. #endif
  60. #ifndef FFETARGET_defaultIS_AUTOMATIC
  61. #define FFETARGET_defaultIS_AUTOMATIC 1
  62. #endif
  63. #ifndef FFETARGET_defaultIS_BACKSLASH
  64. #define FFETARGET_defaultIS_BACKSLASH 1
  65. #endif
  66. #ifndef FFETARGET_defaultIS_INIT_LOCAL_ZERO
  67. #define FFETARGET_defaultIS_INIT_LOCAL_ZERO 0
  68. #endif
  69. #ifndef FFETARGET_defaultIS_DOLLAR_OK
  70. #define FFETARGET_defaultIS_DOLLAR_OK 0
  71. #endif
  72. #ifndef FFETARGET_defaultIS_F2C
  73. #define FFETARGET_defaultIS_F2C 1
  74. #endif
  75. #ifndef FFETARGET_defaultIS_F2C_LIBRARY
  76. #define FFETARGET_defaultIS_F2C_LIBRARY 1
  77. #endif
  78. #ifndef FFETARGET_defaultIS_FREE_FORM
  79. #define FFETARGET_defaultIS_FREE_FORM 0
  80. #endif
  81. #ifndef FFETARGET_defaultIS_PEDANTIC
  82. #define FFETARGET_defaultIS_PEDANTIC 0
  83. #endif
  84. #ifndef FFETARGET_defaultIS_UGLY
  85. #define FFETARGET_defaultIS_UGLY 0
  86. #endif
  87. #ifndef FFETARGET_defaultIS_UGLY_ARGS
  88. #define FFETARGET_defaultIS_UGLY_ARGS 1
  89. #endif
  90. #ifndef FFETARGET_defaultIS_UGLY_INIT
  91. #define FFETARGET_defaultIS_UGLY_INIT 1
  92. #endif
  93. #ifndef FFETARGET_defaultIS_VXT_NOT_90
  94. #define FFETARGET_defaultIS_VXT_NOT_90 0
  95. #endif
  96. #ifndef FFETARGET_defaultCASE_INTRIN
  97. #define FFETARGET_defaultCASE_INTRIN FFE_caseLOWER
  98. #endif
  99. #ifndef FFETARGET_defaultCASE_MATCH
  100. #define FFETARGET_defaultCASE_MATCH FFE_caseLOWER
  101. #endif
  102. #ifndef FFETARGET_defaultCASE_SOURCE
  103. #define FFETARGET_defaultCASE_SOURCE FFE_caseLOWER
  104. #endif
  105. #ifndef FFETARGET_defaultCASE_SYMBOL
  106. #define FFETARGET_defaultCASE_SYMBOL FFE_caseNONE
  107. #endif
  108. #ifndef FFETARGET_defaultSTATE_DCP
  109. #define FFETARGET_defaultSTATE_DCP FFE_intrinsicstateENABLED
  110. #endif
  111. #ifndef FFETARGET_defaultSTATE_F2C
  112. #define FFETARGET_defaultSTATE_F2C FFE_intrinsicstateENABLED
  113. #endif
  114. #ifndef FFETARGET_defaultSTATE_F90
  115. #define FFETARGET_defaultSTATE_F90 FFE_intrinsicstateDELETED
  116. #endif
  117. #ifndef FFETARGET_defaultSTATE_MIL
  118. #define FFETARGET_defaultSTATE_MIL FFE_intrinsicstateENABLED
  119. #endif
  120. #ifndef FFETARGET_defaultSTATE_VXT
  121. #define FFETARGET_defaultSTATE_VXT FFE_intrinsicstateDELETED
  122. #endif
  123.  
  124. #ifndef FFETARGET_defaultFIXED_LINE_LENGTH
  125. #define FFETARGET_defaultFIXED_LINE_LENGTH 72
  126. #endif
  127.  
  128. /* 1 if external Fortran names ("FOO" in SUBROUTINE FOO, COMMON /FOO/,
  129.    and even enforced/default-for-unnamed PROGRAM, blank-COMMON, and
  130.    BLOCK DATA names, but not names of library functions implementing
  131.    intrinsics or names of local/internal variables) should have an
  132.    underscore appended (for compatibility with existing systems).  */
  133.  
  134. #ifndef FFETARGET_isEXTERNAL_UNDERSCORED
  135. #define FFETARGET_isEXTERNAL_UNDERSCORED 1
  136. #endif
  137.  
  138. /* 1 if external Fortran names with underscores already in them should
  139.    have an extra underscore appended (in addition to the one they
  140.    might already have appened if FFETARGET_isEXTERNAL_UNDERSCORED).  */
  141.  
  142. #ifndef FFETARGET_isUNDERSCORED_EXTERNAL_UNDERSCORED
  143. #define FFETARGET_isUNDERSCORED_EXTERNAL_UNDERSCORED FFETARGET_isEXTERNAL_UNDERSCORED
  144. #endif
  145.  
  146. /* If FFETARGET_isEXTERNAL_UNDERSCORED is 0, the following definitions
  147.    might also need to be overridden to make g77 objects compatible with
  148.    f2c+gcc objects.  Although I don't think the unnamed BLOCK DATA one
  149.    is an issue at all.  Of course, on some systems it isn't f2c
  150.    compatibility that is the issue -- maybe compatibility with some
  151.    other compiler(s).  I don't know what to recommend for systems where
  152.    there is no existing Fortran compiler -- I suppose porting f2c and
  153.    pretending it's the existing one is best for now.  */
  154.  
  155. /* 1 if the "FOO" in "PROGRAM FOO" should be overridden and a particular
  156.    name imposed in place of it in the actual code (normally the case,
  157.    because the library's main entry point on most systems calls the main
  158.    function by a particular name).  Someday g77 might do the f2c trick
  159.    of also outputting a "FOO" procedure that just calls the main procedure,
  160.    but that'll wait until somebody shows why it is needed.  */
  161.  
  162. #ifndef FFETARGET_isENFORCED_MAIN
  163. #define FFETARGET_isENFORCED_MAIN 1
  164. #endif
  165.  
  166. /* The enforced name of the main program if ENFORCED_MAIN is 1.  */
  167.  
  168. #ifndef FFETARGET_nameENFORCED_MAIN_NAME
  169. #define FFETARGET_nameENFORCED_MAIN_NAME "MAIN__"
  170. #endif
  171.  
  172. /* The name used for an unnamed main program if ENFORCED_MAIN is 0.  */
  173.  
  174. #ifndef FFETARGET_nameUNNAMED_MAIN
  175. #define FFETARGET_nameUNNAMED_MAIN "MAIN__"
  176. #endif
  177.  
  178. /* The name used for an unnamed block data program.  */
  179.  
  180. #ifndef FFETARGET_nameUNNAMED_BLOCK_DATA
  181. #define FFETARGET_nameUNNAMED_BLOCK_DATA "_BLOCK_DATA__"
  182. #endif
  183.  
  184. /* The name used for blank common.  */
  185.  
  186. #ifndef FFETARGET_nameBLANK_COMMON
  187. #define FFETARGET_nameBLANK_COMMON "_BLNK__"
  188. #endif
  189.  
  190. #ifndef FFETARGET_integerSMALLEST_POSITIVE
  191. #define FFETARGET_integerSMALLEST_POSITIVE 0
  192. #endif
  193. #ifndef FFETARGET_integerLARGEST_POSITIVE
  194. #define FFETARGET_integerLARGEST_POSITIVE 2147483647
  195. #endif
  196. #ifndef FFETARGET_integerBIG_MAGICAL
  197. #define FFETARGET_integerBIG_MAGICAL 020000000000    /* 2147483648 */
  198. #endif
  199. #ifndef FFETARGET_integerALMOST_BIG_MAGICAL
  200. #define FFETARGET_integerALMOST_BIG_MAGICAL 214748364
  201. #endif
  202. #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL
  203. #define FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL 04000000000
  204. #endif
  205. #ifndef FFETARGET_integerFINISH_BIG_MAGICAL
  206. #define FFETARGET_integerFINISH_BIG_MAGICAL 8
  207. #endif
  208. #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL
  209. #define FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL 0
  210. #endif
  211.  
  212. #ifndef FFETARGET_offsetNONE
  213. #define FFETARGET_offsetNONE 0    /* Not used by FFE, for backend if needed. */
  214. #endif
  215.  
  216. #define FFETARGET_okINTEGER1 1
  217. #define FFETARGET_okINTEGER2 0
  218. #define FFETARGET_okINTEGER3 0
  219. #define FFETARGET_okINTEGER4 0
  220. #define FFETARGET_okLOGICAL1 1
  221. #define FFETARGET_okLOGICAL2 0
  222. #define FFETARGET_okLOGICAL3 0
  223. #define FFETARGET_okLOGICAL4 0
  224. #define FFETARGET_okREAL1 1
  225. #define FFETARGET_okREAL2 1
  226. #define FFETARGET_okREAL3 0
  227. #define FFETARGET_okCOMPLEX1 1
  228. #define FFETARGET_okCOMPLEX2 1
  229. #define FFETARGET_okCOMPLEX3 0
  230. #define FFETARGET_okCHARACTER1 1
  231.  
  232. #define FFETARGET_f2cTYUNKNOWN 0
  233. #define FFETARGET_f2cTYADDR 1
  234. #define FFETARGET_f2cTYSHORT 2
  235. #define FFETARGET_f2cTYLONG 3
  236. #define FFETARGET_f2cTYREAL 4
  237. #define FFETARGET_f2cTYDREAL 5
  238. #define FFETARGET_f2cTYCOMPLEX 6
  239. #define FFETARGET_f2cTYDCOMPLEX 7
  240. #define FFETARGET_f2cTYLOGICAL 8
  241. #define FFETARGET_f2cTYCHAR 9
  242. #define FFETARGET_f2cTYSUBR 10
  243. #define FFETARGET_f2cTYINT1 11
  244. #define FFETARGET_f2cTYLOGICAL1 12
  245. #define FFETARGET_f2cTYLOGICAL2 13
  246. #define FFETARGET_f2cTYQUAD 14
  247.  
  248. /* Typedefs. */
  249.  
  250. typedef unsigned char ffetargetAlign;    /* ffetargetOffset for alignment. */
  251. #define ffetargetAlign_f ""
  252. typedef unsigned long ffetargetCharacterSize;
  253. #define ffetargetCharacterSize_f "l"
  254. typedef void (*ffetargetCopyfunc) (void *, void *, size_t);
  255. typedef ffetargetCharacterSize ffetargetHollerithSize;
  256. #define ffetargetHollerithSize_f "l"
  257. typedef unsigned long ffetargetOffset;
  258. #define ffetargetOffset_f "l"
  259.  
  260. #if FFETARGET_okINTEGER1
  261. typedef long int ffetargetInteger1;
  262. #define ffetargetInteger1_f "l"
  263. #endif
  264. #if FFETARGET_okINTEGER2
  265. typedef signed char ffetargetInteger2;
  266. #define ffetargetInteger2_f ""
  267. #endif
  268. #if FFETARGET_okINTEGER3
  269. typedef short int ffetargetInteger3;
  270. #define ffetargetInteger3_f ""
  271. #endif
  272. #if FFETARGET_okINTEGER4
  273. typedef long long int ffetargetInteger4;
  274. #define ffetargetInteger4_f
  275. ?
  276. #endif
  277. #if FFETARGET_okINTEGER5
  278. typedef ? ffetargetInteger5;
  279. #define ffetargetInteger5_f
  280. ?
  281. #endif
  282. #if FFETARGET_okINTEGER6
  283. typedef ? ffetargetInteger6;
  284. #define ffetargetInteger6_f
  285. ?
  286. #endif
  287. #if FFETARGET_okINTEGER7
  288. typedef ? ffetargetInteger7;
  289. #define ffetargetInteger7_f
  290. ?
  291. #endif
  292. #if FFETARGET_okINTEGER8
  293. typedef ? ffetargetInteger8;
  294. #define ffetargetInteger8_f
  295. ?
  296. #endif
  297. #if FFETARGET_okLOGICAL1
  298. typedef long int ffetargetLogical1;
  299. #define ffetargetLogical1_f "l"
  300. #endif
  301. #if FFETARGET_okLOGICAL2
  302. typedef signed char ffetargetLogical2;
  303. #define ffetargetLogical2_f ""
  304. #endif
  305. #if FFETARGET_okLOGICAL3
  306. typedef short int ffetargetLogical3;
  307. #define ffetargetLogical3_f ""
  308. #endif
  309. #if FFETARGET_okLOGICAL4
  310. typedef long long int ffetargetLogical4;
  311. #define ffetargetLogical4_f
  312. ?
  313. #endif
  314. #if FFETARGET_okLOGICAL5
  315. typedef ? ffetargetLogical5;
  316. #define ffetargetLogical5_f
  317. ?
  318. #endif
  319. #if FFETARGET_okLOGICAL6
  320. typedef ? ffetargetLogical6;
  321. #define ffetargetLogical6_f
  322. ?
  323. #endif
  324. #if FFETARGET_okLOGICAL7
  325. typedef ? ffetargetLogical7;
  326. #define ffetargetLogical7_f
  327. ?
  328. #endif
  329. #if FFETARGET_okLOGICAL8
  330. typedef ? ffetargetLogical8;
  331. #define ffetargetLogical8_f
  332. ?
  333. #endif
  334. #if FFETARGET_okREAL1
  335. #ifdef REAL_ARITHMETIC
  336. typedef HOST_WIDE_INT ffetargetReal1;
  337. #else
  338. typedef float ffetargetReal1;
  339. #define ffetargetReal1_f ""
  340. #endif
  341. #endif
  342. #if FFETARGET_okREAL2
  343. #ifdef REAL_ARITHMETIC
  344. typedef struct
  345.   {
  346.     HOST_WIDE_INT v[2];
  347.   }
  348. ffetargetReal2;
  349. #else
  350. typedef double ffetargetReal2;
  351. #define ffetargetReal2_f ""
  352. #endif
  353. #endif
  354. #if FFETARGET_okREAL3
  355. #ifdef REAL_ARITHMETIC
  356. typedef long ffetargetReal3[?];
  357. #else
  358. typedef ? ffetargetReal3;
  359. #define ffetargetReal3_f
  360. #endif
  361. ?
  362. #endif
  363. #if FFETARGET_okREAL4
  364. #ifdef REAL_ARITHMETIC
  365. typedef long ffetargetReal4[?];
  366. #else
  367. typedef ? ffetargetReal4;
  368. #define ffetargetReal4_f
  369. #endif
  370. ?
  371. #endif
  372. #if FFETARGET_okREAL5
  373. #ifdef REAL_ARITHMETIC
  374. typedef long ffetargetReal5[?];
  375. #else
  376. typedef ? ffetargetReal5;
  377. #define ffetargetReal5_f
  378. #endif
  379. ?
  380. #endif
  381. #if FFETARGET_okREAL6
  382. #ifdef REAL_ARITHMETIC
  383. typedef long ffetargetReal6[?];
  384. #else
  385. typedef ? ffetargetReal6;
  386. #define ffetargetReal6_f
  387. #endif
  388. ?
  389. #endif
  390. #if FFETARGET_okREAL7
  391. #ifdef REAL_ARITHMETIC
  392. typedef long ffetargetReal7[?];
  393. #else
  394. typedef ? ffetargetReal7;
  395. #define ffetargetReal7_f
  396. #endif
  397. ?
  398. #endif
  399. #if FFETARGET_okREAL8
  400. #ifdef REAL_ARITHMETIC
  401. typedef long ffetargetReal8[?];
  402. #else
  403. typedef ? ffetargetReal8;
  404. #define ffetargetReal8_f
  405. #endif
  406. ?
  407. #endif
  408. #if FFETARGET_okCOMPLEX1
  409. struct _ffetarget_complex_1_
  410.   {
  411.     ffetargetReal1 real;
  412.     ffetargetReal1 imaginary;
  413.   };
  414. typedef struct _ffetarget_complex_1_ ffetargetComplex1;
  415. #endif
  416. #if FFETARGET_okCOMPLEX2
  417. struct _ffetarget_complex_2_
  418.   {
  419.     ffetargetReal2 real;
  420.     ffetargetReal2 imaginary;
  421.   };
  422. typedef struct _ffetarget_complex_2_ ffetargetComplex2;
  423. #endif
  424. #if FFETARGET_okCOMPLEX3
  425. struct _ffetarget_complex_3_
  426.   {
  427.     ffetargetReal3 real;
  428.     ffetargetReal3 imaginary;
  429.   };
  430. typedef struct _ffetarget_complex_3_ ffetargetComplex3;
  431. #endif
  432. #if FFETARGET_okCOMPLEX4
  433. struct _ffetarget_complex_4_
  434.   {
  435.     ffetargetReal4 real;
  436.     ffetargetReal4 imaginary;
  437.   };
  438. typedef struct _ffetarget_complex_4_ ffetargetComplex4;
  439. #endif
  440. #if FFETARGET_okCOMPLEX5
  441. struct _ffetarget_complex_5_
  442.   {
  443.     ffetargetReal5 real;
  444.     ffetargetReal5 imaginary;
  445.   };
  446. typedef struct _ffetarget_complex_5_ ffetargetComplex5;
  447. #endif
  448. #if FFETARGET_okCOMPLEX6
  449. struct _ffetarget_complex_6_
  450.   {
  451.     ffetargetReal6 real;
  452.     ffetargetReal6 imaginary;
  453.   };
  454. typedef struct _ffetarget_complex_6_ ffetargetComplex6;
  455. #endif
  456. #if FFETARGET_okCOMPLEX7
  457. struct _ffetarget_complex_7_
  458.   {
  459.     ffetargetReal7 real;
  460.     ffetargetReal7 imaginary;
  461.   };
  462. typedef struct _ffetarget_complex_7_ ffetargetComplex7;
  463. #endif
  464. #if FFETARGET_okCOMPLEX8
  465. struct _ffetarget_complex_8_
  466.   {
  467.     ffetargetReal8 real;
  468.     ffetargetReal8 imaginary;
  469.   };
  470. typedef struct _ffetarget_complex_8_ ffetargetComplex8;
  471. #endif
  472. #if FFETARGET_okCHARACTER1
  473. struct _ffetarget_char_1_
  474.   {
  475.     ffetargetCharacterSize length;
  476.     unsigned char *text;
  477.   };
  478. typedef struct _ffetarget_char_1_ ffetargetCharacter1;
  479. typedef unsigned char ffetargetCharacterUnit1;
  480. #endif
  481. #if FFETARGET_okCHARACTER2
  482. typedef ? ffetargetCharacter2;
  483. typedef ? ffetargetCharacterUnit2;
  484. #endif
  485. #if FFETARGET_okCHARACTER3
  486. typedef ? ffetargetCharacter3;
  487. typedef ? ffetargetCharacterUnit3;
  488. #endif
  489. #if FFETARGET_okCHARACTER4
  490. typedef ? ffetargetCharacter4;
  491. typedef ? ffetargetCharacterUnit4;
  492. #endif
  493. #if FFETARGET_okCHARACTER5
  494. typedef ? ffetargetCharacter5;
  495. typedef ? ffetargetCharacterUnit5;
  496. #endif
  497. #if FFETARGET_okCHARACTER6
  498. typedef ? ffetargetCharacter6;
  499. typedef ? ffetargetCharacterUnit6;
  500. #endif
  501. #if FFETARGET_okCHARACTER7
  502. typedef ? ffetargetCharacter7;
  503. typedef ? ffetargetCharacterUnit7;
  504. #endif
  505. #if FFETARGET_okCHARACTER8
  506. typedef ? ffetargetCharacter8;
  507. typedef ? ffetargetCharacterUnit8;
  508. #endif
  509.  
  510. typedef unsigned long long int ffetargetTypeless;
  511.  
  512. struct _ffetarget_hollerith_
  513.   {
  514.     ffetargetHollerithSize length;
  515.     unsigned char *text;
  516.   };
  517. typedef struct _ffetarget_hollerith_ ffetargetHollerith;
  518.  
  519. typedef ffetargetCharacter1 ffetargetCharacterDefault;
  520. typedef ffetargetComplex1 ffetargetComplexDefault;
  521. #if FFETARGET_okCOMPLEXDOUBLE
  522. typedef ffetargetComplex2 ffetargetComplexDouble;
  523. #endif
  524. #if FFETARGET_okCOMPLEXQUAD
  525. typedef ffetargetComplex3 ffetargetComplexQuad;
  526. #endif
  527. typedef ffetargetInteger1 ffetargetIntegerDefault;
  528. #define ffetargetIntegerDefault_f ffetargetInteger1_f
  529. typedef ffetargetLogical1 ffetargetLogicalDefault;
  530. #define ffetargetLogicalDefault_f ffetargetLogical1_f
  531. typedef ffetargetReal1 ffetargetRealDefault;
  532. #define ffetargetRealDefault_f ffetargetReal1_f
  533. typedef ffetargetReal2 ffetargetRealDouble;
  534. #define ffetargetRealDouble_f ffetargetReal2_f
  535. #if FFETARGET_okREALQUAD
  536. typedef ffetargetReal3 ffetargetRealQuad;
  537. #define ffetargetRealQuad_f ffetargetReal3_f
  538. #endif
  539.  
  540. /* Include files needed by this one. */
  541.  
  542. #include "bad.h"
  543. #include "info.h"
  544. #include "lex.h"
  545. #include "malloc.h"
  546.  
  547. /* Structure definitions. */
  548.  
  549.  
  550. /* Global objects accessed by users of this module. */
  551.  
  552. extern char ffetarget_string_[40];    /* Temp for ascii-to-double (atof). */
  553. extern HOST_WIDE_INT ffetarget_long_val_;
  554. extern HOST_WIDE_INT ffetarget_long_junk_;
  555.  
  556. /* Declare functions with prototypes. */
  557.  
  558. void ffetarget_aggregate_info (ffeinfoBasictype *ebt, ffeinfoKindtype *ekt,
  559.                    ffetargetAlign *units, ffeinfoBasictype abt,
  560.                    ffeinfoKindtype akt);
  561. ffetargetAlign ffetarget_align (ffetargetAlign *updated_alignment,
  562.                 ffetargetAlign *updated_modulo,
  563.                 ffetargetOffset offset,
  564.                 ffetargetAlign alignment,
  565.                 ffetargetAlign modulo);
  566. #if FFETARGET_okCHARACTER1
  567. bool ffetarget_character1 (ffetargetCharacter1 *val, ffelexToken character,
  568.                mallocPool pool);
  569. int ffetarget_cmp_character1 (ffetargetCharacter1 l, ffetargetCharacter1 r);
  570. ffebad ffetarget_concatenate_character1 (ffetargetCharacter1 *res,
  571.                      ffetargetCharacter1 l,
  572.                      ffetargetCharacter1 r,
  573.                      mallocPool pool,
  574.                      ffetargetCharacterSize *len);
  575. ffebad ffetarget_convert_character1_character1 (ffetargetCharacter1 *res,
  576.                         ffetargetCharacterSize res_size,
  577.                         ffetargetCharacter1 l,
  578.                         mallocPool pool);
  579. ffebad ffetarget_convert_character1_hollerith (ffetargetCharacter1 *res,
  580.                         ffetargetCharacterSize res_size,
  581.                            ffetargetHollerith l,
  582.                            mallocPool pool);
  583. ffebad ffetarget_convert_character1_integer1 (ffetargetCharacter1 *res,
  584.                           ffetargetCharacterSize res_size,
  585.                           ffetargetInteger1 l,
  586.                           mallocPool pool);
  587. ffebad ffetarget_convert_character1_logical1 (ffetargetCharacter1 *res,
  588.                           ffetargetCharacterSize res_size,
  589.                           ffetargetLogical1 l,
  590.                           mallocPool pool);
  591. ffebad ffetarget_convert_character1_typeless (ffetargetCharacter1 *res,
  592.                         ffetargetCharacterSize res_size,
  593.                           ffetargetTypeless l,
  594.                           mallocPool pool);
  595. ffebad ffetarget_eq_character1 (bool *res, ffetargetCharacter1 l,
  596.                 ffetargetCharacter1 r);
  597. ffebad ffetarget_le_character1 (bool *res, ffetargetCharacter1 l,
  598.                 ffetargetCharacter1 r);
  599. ffebad ffetarget_ge_character1 (bool *res, ffetargetCharacter1 l,
  600.                 ffetargetCharacter1 r);
  601. ffebad ffetarget_gt_character1 (bool *res, ffetargetCharacter1 l,
  602.                 ffetargetCharacter1 r);
  603. ffebad ffetarget_lt_character1 (bool *res, ffetargetCharacter1 l,
  604.                 ffetargetCharacter1 r);
  605. ffebad ffetarget_ne_character1 (bool *res, ffetargetCharacter1 l,
  606.                 ffetargetCharacter1 r);
  607. ffebad ffetarget_substr_character1 (ffetargetCharacter1 *res,
  608.                     ffetargetCharacter1 l,
  609.                     ffetargetCharacterSize first,
  610.                     ffetargetCharacterSize last,
  611.                     mallocPool pool,
  612.                     ffetargetCharacterSize *len);
  613. #endif
  614. int ffetarget_cmp_hollerith (ffetargetHollerith l, ffetargetHollerith r);
  615. bool ffetarget_hollerith (ffetargetHollerith *val, ffelexToken hollerith,
  616.               mallocPool pool);
  617. int ffetarget_cmp_typeless (ffetargetTypeless l, ffetargetTypeless r);
  618. ffebad ffetarget_convert_any_character1_ (char *res, size_t size,
  619.                       ffetargetCharacter1 l);
  620. ffebad ffetarget_convert_any_hollerith_ (char *res, size_t size,
  621.                      ffetargetHollerith l);
  622. ffebad ffetarget_convert_any_typeless_ (char *res, size_t size,
  623.                     ffetargetTypeless l);
  624. #if FFETARGET_okCOMPLEX1
  625. ffebad ffetarget_divide_complex1 (ffetargetComplex1 *res, ffetargetComplex1 l,
  626.                   ffetargetComplex1 r);
  627. #endif
  628. #if FFETARGET_okCOMPLEX2
  629. ffebad ffetarget_divide_complex2 (ffetargetComplex2 *res, ffetargetComplex2 l,
  630.                   ffetargetComplex2 r);
  631. #endif
  632. #if FFETARGET_okCOMPLEX3
  633. ffebad ffetarget_divide_complex3 (ffetargetComplex3 *res, ffetargetComplex3 l,
  634.                   ffetargetComplex3 r);
  635. #endif
  636. #if FFETARGET_okCOMPLEX4
  637. ffebad ffetarget_divide_complex4 (ffetargetComplex4 *res, ffetargetComplex4 l,
  638.                   ffetargetComplex4 r);
  639. #endif
  640. #if FFETARGET_okCOMPLEX5
  641. ffebad ffetarget_divide_complex5 (ffetargetComplex5 *res, ffetargetComplex5 l,
  642.                   ffetargetComplex5 r);
  643. #endif
  644. #if FFETARGET_okCOMPLEX6
  645. ffebad ffetarget_divide_complex6 (ffetargetComplex6 *res, ffetargetComplex6 l,
  646.                   ffetargetComplex6 r);
  647. #endif
  648. #if FFETARGET_okCOMPLEX7
  649. ffebad ffetarget_divide_complex7 (ffetargetComplex7 *res, ffetargetComplex7 l,
  650.                   ffetargetComplex7 r);
  651. #endif
  652. #if FFETARGET_okCOMPLEX8
  653. ffebad ffetarget_divide_complex8 (ffetargetComplex8 *res, ffetargetComplex8 l,
  654.                   ffetargetComplex8 r);
  655. #endif
  656. #if FFETARGET_okINTEGER1
  657. bool ffetarget_integer1 (ffetargetInteger1 *val, ffelexToken integer);
  658. #endif
  659. #if FFETARGET_okINTEGER2
  660. bool ffetarget_integer2 (ffetargetInteger2 *val, ffelexToken integer);
  661. #endif
  662. #if FFETARGET_okINTEGER3
  663. bool ffetarget_integer3 (ffetargetInteger3 *val, ffelexToken integer);
  664. #endif
  665. #if FFETARGET_okINTEGER4
  666. bool ffetarget_integer4 (ffetargetInteger4 *val, ffelexToken integer);
  667. #endif
  668. #if FFETARGET_okINTEGER5
  669. bool ffetarget_integer5 (ffetargetInteger5 *val, ffelexToken integer);
  670. #endif
  671. #if FFETARGET_okINTEGER6
  672. bool ffetarget_integer6 (ffetargetInteger6 *val, ffelexToken integer);
  673. #endif
  674. #if FFETARGET_okINTEGER7
  675. bool ffetarget_integer7 (ffetargetInteger7 *val, ffelexToken integer);
  676. #endif
  677. #if FFETARGET_okINTEGER8
  678. bool ffetarget_integer8 (ffetargetInteger8 *val, ffelexToken integer);
  679. #endif
  680. bool ffetarget_integeroctal (ffetargetIntegerDefault *val,
  681.                  ffelexToken integer);
  682. void ffetarget_integer_bad_magical (ffelexToken t);
  683. void ffetarget_integer_bad_magical_binary (ffelexToken integer, ffelexToken minus);
  684. void ffetarget_integer_bad_magical_precedence (ffelexToken integer,
  685.                            ffelexToken uminus,
  686.                            ffelexToken higher_op);
  687. void ffetarget_integer_bad_magical_precedence_binary (ffelexToken integer,
  688.                               ffelexToken minus,
  689.                               ffelexToken higher_op);
  690. void ffetarget_layout (char *error_text, ffetargetAlign *alignment,
  691.                ffetargetAlign *modulo, ffetargetOffset *size,
  692.                ffeinfoBasictype bt, ffeinfoKindtype kt,
  693.                ffetargetCharacterSize charsize,
  694.                ffetargetIntegerDefault num_elements);
  695. #if FFETARGET_okCOMPLEX1
  696. ffebad ffetarget_multiply_complex1 (ffetargetComplex1 *res,
  697.                     ffetargetComplex1 l,
  698.                     ffetargetComplex1 r);
  699. #endif
  700. #if FFETARGET_okCOMPLEX2
  701. ffebad ffetarget_multiply_complex2 (ffetargetComplex2 *res,
  702.                     ffetargetComplex2 l,
  703.                     ffetargetComplex2 r);
  704. #endif
  705. #if FFETARGET_okCOMPLEX3
  706. ffebad ffetarget_multiply_complex3 (ffetargetComplex3 *res,
  707.                     ffetargetComplex3 l,
  708.                     ffetargetComplex3 r);
  709. #endif
  710. #if FFETARGET_okCOMPLEX4
  711. ffebad ffetarget_multiply_complex4 (ffetargetComplex4 *res,
  712.                     ffetargetComplex4 l,
  713.                     ffetargetComplex4 r);
  714. #endif
  715. #if FFETARGET_okCOMPLEX5
  716. ffebad ffetarget_multiply_complex5 (ffetargetComplex5 *res,
  717.                     ffetargetComplex5 l,
  718.                     ffetargetComplex5 r);
  719. #endif
  720. #if FFETARGET_okCOMPLEX6
  721. ffebad ffetarget_multiply_complex6 (ffetargetComplex6 *res,
  722.                     ffetargetComplex6 l,
  723.                     ffetargetComplex6 r);
  724. #endif
  725. #if FFETARGET_okCOMPLEX7
  726. ffebad ffetarget_multiply_complex7 (ffetargetComplex7 *res,
  727.                     ffetargetComplex7 l,
  728.                     ffetargetComplex7 r);
  729. #endif
  730. #if FFETARGET_okCOMPLEX8
  731. ffebad ffetarget_multiply_complex8 (ffetargetComplex8 *res,
  732.                     ffetargetComplex8 l,
  733.                     ffetargetComplex8 r);
  734. #endif
  735. ffebad ffetarget_power_complexdefault_integerdefault (ffetargetComplexDefault *res,
  736.                           ffetargetComplexDefault l,
  737.                          ffetargetIntegerDefault r);
  738. #if FFETARGET_okCOMPLEXDOUBLE
  739. ffebad ffetarget_power_complexdouble_integerdefault (ffetargetComplexDouble *res,
  740.                            ffetargetComplexDouble l,
  741.                          ffetargetIntegerDefault r);
  742. #endif
  743. ffebad ffetarget_power_integerdefault_integerdefault (ffetargetIntegerDefault *res,
  744.                           ffetargetIntegerDefault l,
  745.                          ffetargetIntegerDefault r);
  746. ffebad ffetarget_power_realdefault_integerdefault (ffetargetRealDefault *res,
  747.                            ffetargetRealDefault l,
  748.                          ffetargetIntegerDefault r);
  749. ffebad ffetarget_power_realdouble_integerdefault (ffetargetRealDouble *res,
  750.                           ffetargetRealDouble l,
  751.                           ffetargetIntegerDefault r);
  752. void ffetarget_print_binary (FILE *f, ffetargetTypeless val);
  753. void ffetarget_print_character1 (FILE *f, ffetargetCharacter1 val);
  754. void ffetarget_print_hollerith (FILE *f, ffetargetHollerith val);
  755. void ffetarget_print_octal (FILE *f, ffetargetTypeless val);
  756. void ffetarget_print_hex (FILE *f, ffetargetTypeless val);
  757. #if FFETARGET_okREAL1
  758. bool ffetarget_real1 (ffetargetReal1 *value, ffelexToken integer,
  759.               ffelexToken decimal, ffelexToken fraction,
  760.               ffelexToken exponent, ffelexToken exponent_sign,
  761.               ffelexToken exponent_digits);
  762. #endif
  763. #if FFETARGET_okREAL2
  764. bool ffetarget_real2 (ffetargetReal2 *value, ffelexToken integer,
  765.               ffelexToken decimal, ffelexToken fraction,
  766.               ffelexToken exponent, ffelexToken exponent_sign,
  767.               ffelexToken exponent_digits);
  768. #endif
  769. #if FFETARGET_okREAL3
  770. bool ffetarget_real3 (ffetargetReal3 *value, ffelexToken integer,
  771.               ffelexToken decimal, ffelexToken fraction,
  772.               ffelexToken exponent, ffelexToken exponent_sign,
  773.               ffelexToken exponent_digits);
  774. #endif
  775. #if FFETARGET_okREAL4
  776. bool ffetarget_real4 (ffetargetReal4 *value, ffelexToken integer,
  777.               ffelexToken decimal, ffelexToken fraction,
  778.               ffelexToken exponent, ffelexToken exponent_sign,
  779.               ffelexToken exponent_digits);
  780. #endif
  781. #if FFETARGET_okREAL5
  782. bool ffetarget_real5 (ffetargetReal5 *value, ffelexToken integer,
  783.               ffelexToken decimal, ffelexToken fraction,
  784.               ffelexToken exponent, ffelexToken exponent_sign,
  785.               ffelexToken exponent_digits);
  786. #endif
  787. #if FFETARGET_okREAL6
  788. bool ffetarget_real6 (ffetargetReal6 *value, ffelexToken integer,
  789.               ffelexToken decimal, ffelexToken fraction,
  790.               ffelexToken exponent, ffelexToken exponent_sign,
  791.               ffelexToken exponent_digits);
  792. #endif
  793. #if FFETARGET_okREAL7
  794. bool ffetarget_real7 (ffetargetReal7 *value, ffelexToken integer,
  795.               ffelexToken decimal, ffelexToken fraction,
  796.               ffelexToken exponent, ffelexToken exponent_sign,
  797.               ffelexToken exponent_digits);
  798. #endif
  799. #if FFETARGET_okREAL8
  800. bool ffetarget_real8 (ffetargetReal8 *value, ffelexToken integer,
  801.               ffelexToken decimal, ffelexToken fraction,
  802.               ffelexToken exponent, ffelexToken exponent_sign,
  803.               ffelexToken exponent_digits);
  804. #endif
  805. bool ffetarget_typeless_binary (ffetargetTypeless *value, ffelexToken token);
  806. bool ffetarget_typeless_octal (ffetargetTypeless *value, ffelexToken token);
  807. bool ffetarget_typeless_hex (ffetargetTypeless *value, ffelexToken token);
  808. int ffetarget_num_digits_ (ffelexToken t);
  809. void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
  810.  
  811. /* Define macros. */
  812.  
  813. #ifdef REAL_ARITHMETIC
  814. #define ffetarget_add_complex1(res,l,r) \
  815.   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
  816.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  817.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  818.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
  819.      ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
  820.      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
  821.      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
  822.      REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
  823.      REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
  824.      FFEBAD; })
  825. #define ffetarget_add_complex2(res,l,r) \
  826.   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
  827.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  828.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  829.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
  830.      ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
  831.      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
  832.      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
  833.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
  834.      REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
  835.      FFEBAD; })
  836. #else
  837. #define ffetarget_add_complex1(res,l,r) \
  838.   ((res)->real = (l).real + (r).real, \
  839.    (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
  840. #define ffetarget_add_complex2(res,l,r) \
  841.   ((res)->real = (l).real + (r).real, \
  842.    (res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
  843. #endif
  844. #define ffetarget_add_integer1(res,l,r) (*(res) = (l) + (r), FFEBAD)
  845. #define ffetarget_add_integer2(res,l,r) (*(res) = (l) + (r), FFEBAD)
  846. #define ffetarget_add_integer3(res,l,r) (*(res) = (l) + (r), FFEBAD)
  847. #ifdef REAL_ARITHMETIC
  848. #define ffetarget_add_real1(res,l,r) \
  849.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  850.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  851.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  852.      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
  853.      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  854.      FFEBAD; })
  855. #define ffetarget_add_real2(res,l,r) \
  856.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  857.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  858.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  859.      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
  860.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  861.      FFEBAD; })
  862. #else
  863. #define ffetarget_add_real1(res,l,r) (*(res) = (l) + (r), FFEBAD)
  864. #define ffetarget_add_real2(res,l,r) (*(res) = (l) + (r), FFEBAD)
  865. #endif
  866. #define ffetarget_aggregate_ptr_memcpy(dbt,dkt,sbt,skt) \
  867.   ((ffetargetCopyfunc) ffetarget_memcpy_)
  868. #define ffetarget_and_integer1(res,l,r) (*(res) = (l) & (r), FFEBAD)
  869. #define ffetarget_and_integer2(res,l,r) (*(res) = (l) & (r), FFEBAD)
  870. #define ffetarget_and_integer3(res,l,r) (*(res) = (l) & (r), FFEBAD)
  871. #define ffetarget_and_logical1(res,l,r) (*(res) = (l) && (r), FFEBAD)
  872. #define ffetarget_and_logical2(res,l,r) (*(res) = (l) && (r), FFEBAD)
  873. #define ffetarget_and_logical3(res,l,r) (*(res) = (l) && (r), FFEBAD)
  874. #define ffetarget_binarymil(v,t) ffetarget_typeless_binary (v, t)
  875. #define ffetarget_binaryvxt(v,t) ffetarget_typeless_binary (v, t)
  876. #define ffetarget_cmp_integer1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  877. #define ffetarget_cmp_integer2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  878. #define ffetarget_cmp_integer3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  879. #define ffetarget_cmp_logical1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  880. #define ffetarget_cmp_logical2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  881. #define ffetarget_cmp_logical3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
  882. #define ffetarget_cmp_real1(l,r) memcmp (&(l), &(r), sizeof(l))
  883. #define ffetarget_cmp_real2(l,r) memcmp (&(l), &(r), sizeof(l))
  884. #define ffetarget_cmp_real3(l,r) memcmp (&(l), &(r), sizeof(l))
  885. #define ffetarget_cmp_typeless(l,r) \
  886.   memcmp (&(l), &(r), sizeof ((l)))
  887. #define ffetarget_convert_complex1_character1(res,l) \
  888.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  889. #define ffetarget_convert_complex1_hollerith(res,l) \
  890.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  891. #define ffetarget_convert_complex1_typeless(res,l) \
  892.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  893. #ifdef REAL_ARITHMETIC
  894. #define ffetarget_convert_complex1_complex2(res,l) \
  895.   ({ REAL_VALUE_TYPE lr, li; \
  896.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  897.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  898.      REAL_VALUE_TO_TARGET_SINGLE (lr, (res)->real); \
  899.      REAL_VALUE_TO_TARGET_SINGLE (li, (res)->imaginary), \
  900.      FFEBAD; })
  901. #else
  902. #define ffetarget_convert_complex1_complex2(res,l) \
  903.   ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
  904. #endif
  905. #ifdef REAL_ARITHMETIC
  906. #define ffetarget_convert_complex1_integer(res,l) \
  907.   ({ REAL_VALUE_TYPE resi, resr; \
  908.      ffetargetInteger1 lf = (l); \
  909.      REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
  910.      resi = dconst0; \
  911.      REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
  912.      REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
  913.      FFEBAD; })
  914. #else
  915. #define ffetarget_convert_complex1_integer(res,l) \
  916.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  917. #endif
  918. #define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer
  919. #ifdef REAL_ARITHMETIC
  920. #define ffetarget_convert_complex1_real1(res,l) \
  921.   ((res)->real = (l), \
  922.    REAL_VALUE_TO_TARGET_SINGLE (dconst0, (res)->imaginary), \
  923.    FFEBAD)
  924. #define ffetarget_convert_complex1_real2(res,l) \
  925.   ({ REAL_VALUE_TYPE lr; \
  926.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  927.      REAL_VALUE_TO_TARGET_SINGLE (lr, (res)->real); \
  928.      REAL_VALUE_TO_TARGET_SINGLE (dconst0, (res)->imaginary), \
  929.      FFEBAD; })
  930. #else
  931. #define ffetarget_convert_complex1_real1(res,l) \
  932.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  933. #define ffetarget_convert_complex1_real2(res,l) \
  934.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  935. #endif
  936. #define ffetarget_convert_complex2_character1(res,l) \
  937.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  938. #define ffetarget_convert_complex2_hollerith(res,l) \
  939.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  940. #define ffetarget_convert_complex2_typeless(res,l) \
  941.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  942. #ifdef REAL_ARITHMETIC
  943. #define ffetarget_convert_complex2_complex1(res,l) \
  944.   ({ REAL_VALUE_TYPE lr, li; \
  945.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  946.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  947.      REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->real.v[0])); \
  948.      REAL_VALUE_TO_TARGET_DOUBLE (li, (long *) &((res)->imaginary.v[0])), \
  949.      FFEBAD; })
  950. #else
  951. #define ffetarget_convert_complex2_complex1(res,l) \
  952.   ((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
  953. #endif
  954. #ifdef REAL_ARITHMETIC
  955. #define ffetarget_convert_complex2_integer(res,l) \
  956.   ({ REAL_VALUE_TYPE resi, resr; \
  957.      ffetargetInteger1 lf = (l); \
  958.      REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
  959.      resi = dconst0; \
  960.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
  961.      REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
  962.      FFEBAD; })
  963. #else
  964. #define ffetarget_convert_complex2_integer(res,l) \
  965.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  966. #endif
  967. #define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer
  968. #ifdef REAL_ARITHMETIC
  969. #define ffetarget_convert_complex2_real1(res,l) \
  970.   ({ REAL_VALUE_TYPE lr; \
  971.      lr = REAL_VALUE_FROM_TARGET_SINGLE (l); \
  972.      REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->real.v[0])); \
  973.      REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->imaginary.v[0])), \
  974.      FFEBAD; })
  975. #define ffetarget_convert_complex2_real2(res,l) \
  976.   ((res)->real = (l), \
  977.    REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->imaginary.v[0])), \
  978.    FFEBAD)
  979. #else
  980. #define ffetarget_convert_complex2_real1(res,l) \
  981.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  982. #define ffetarget_convert_complex2_real2(res,l) \
  983.   ((res)->real = (l), (res)->imaginary = 0, FFEBAD)
  984. #endif
  985. #define ffetarget_convert_logical1_character1(res,l) \
  986.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  987. #define ffetarget_convert_logical1_hollerith(res,l) \
  988.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  989. #define ffetarget_convert_logical1_typeless(res,l) \
  990.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  991. #define ffetarget_convert_logical1_logical2(res,l) (*(res) = (l), FFEBAD)
  992. #define ffetarget_convert_logical1_logical3(res,l) (*(res) = (l), FFEBAD)
  993. #define ffetarget_convert_logical1_integer1(res,l) (*(res) = (l), FFEBAD)
  994. #define ffetarget_convert_logical1_integer2(res,l) (*(res) = (l), FFEBAD)
  995. #define ffetarget_convert_logical1_integer3(res,l) (*(res) = (l), FFEBAD)
  996. #define ffetarget_convert_logical2_character1(res,l) \
  997.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  998. #define ffetarget_convert_logical2_hollerith(res,l) \
  999.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  1000. #define ffetarget_convert_logical2_typeless(res,l) \
  1001.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  1002. #define ffetarget_convert_logical2_logical1(res,l) (*(res) = (l), FFEBAD)
  1003. #define ffetarget_convert_logical2_logical3(res,l) (*(res) = (l), FFEBAD)
  1004. #define ffetarget_convert_logical2_integer1(res,l) (*(res) = (l), FFEBAD)
  1005. #define ffetarget_convert_logical2_integer2(res,l) (*(res) = (l), FFEBAD)
  1006. #define ffetarget_convert_logical2_integer3(res,l) (*(res) = (l), FFEBAD)
  1007. #define ffetarget_convert_logical3_character1(res,l) \
  1008.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  1009. #define ffetarget_convert_logical3_hollerith(res,l) \
  1010.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  1011. #define ffetarget_convert_logical3_typeless(res,l) \
  1012.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  1013. #define ffetarget_convert_logical3_logical1(res,l) (*(res) = (l), FFEBAD)
  1014. #define ffetarget_convert_logical3_logical2(res,l) (*(res) = (l), FFEBAD)
  1015. #define ffetarget_convert_logical3_integer1(res,l) (*(res) = (l), FFEBAD)
  1016. #define ffetarget_convert_logical3_integer2(res,l) (*(res) = (l), FFEBAD)
  1017. #define ffetarget_convert_logical3_integer3(res,l) (*(res) = (l), FFEBAD)
  1018. #define ffetarget_convert_integer1_character1(res,l) \
  1019.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  1020. #define ffetarget_convert_integer1_hollerith(res,l) \
  1021.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  1022. #define ffetarget_convert_integer1_typeless(res,l) \
  1023.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  1024. #define ffetarget_convert_integer1_integer2(res,l) (*(res) = (l), FFEBAD)
  1025. #define ffetarget_convert_integer1_integer3(res,l) (*(res) = (l), FFEBAD)
  1026. #define ffetarget_convert_integer1_logical1(res,l) (*(res) = (l), FFEBAD)
  1027. #define ffetarget_convert_integer1_logical2(res,l) (*(res) = (l), FFEBAD)
  1028. #define ffetarget_convert_integer1_logical3(res,l) (*(res) = (l), FFEBAD)
  1029. #ifdef REAL_ARITHMETIC
  1030. #define ffetarget_convert_integer1_real1(res,l) \
  1031.   ({ REAL_VALUE_TYPE lr; \
  1032.      lr = REAL_VALUE_FROM_TARGET_SINGLE (l); \
  1033.      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
  1034.      *(res) = ffetarget_long_val_; \
  1035.      FFEBAD; })
  1036. #define ffetarget_convert_integer1_real2(res,l) \
  1037.   ({ REAL_VALUE_TYPE lr; \
  1038.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1039.      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
  1040.      *(res) = ffetarget_long_val_; \
  1041.      FFEBAD; })
  1042. #define ffetarget_convert_integer1_complex1(res,l) \
  1043.   ({ REAL_VALUE_TYPE lr; \
  1044.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  1045.      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
  1046.      *(res) = ffetarget_long_val_; \
  1047.      FFEBAD; })
  1048. #define ffetarget_convert_integer1_complex2(res,l) \
  1049.   ({ REAL_VALUE_TYPE lr; \
  1050.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  1051.      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
  1052.      *(res) = ffetarget_long_val_; \
  1053.      FFEBAD; })
  1054. #else
  1055. #define ffetarget_convert_integer1_real1(res,l) (*(res) = (l), FFEBAD)
  1056. #define ffetarget_convert_integer1_real2(res,l) (*(res) = (l), FFEBAD)
  1057. #define ffetarget_convert_integer1_complex1(res,l) (*(res) = (l).real, FFEBAD)
  1058. #define ffetarget_convert_integer1_complex2(res,l) (*(res) = (l).real, FFEBAD)
  1059. #endif
  1060. #define ffetarget_convert_real1_character1(res,l) \
  1061.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  1062. #define ffetarget_convert_real1_hollerith(res,l) \
  1063.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  1064. #define ffetarget_convert_real1_typeless(res,l) \
  1065.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  1066. #define ffetarget_convert_real1_complex1(res,l) (*(res) = (l).real, FFEBAD)
  1067. #define ffetarget_convert_real1_complex2(res,l) \
  1068.   ffetarget_convert_real1_real2 ((res), (l).real)
  1069. #ifdef REAL_ARITHMETIC
  1070. #define ffetarget_convert_real1_integer1(res,l) \
  1071.   ({ REAL_VALUE_TYPE resr; \
  1072.      ffetargetInteger1 lf = (l); \
  1073.      REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
  1074.      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  1075.      FFEBAD; })
  1076. #else
  1077. #define ffetarget_convert_real1_integer1(res,l) (*(res) = (l), FFEBAD)
  1078. #endif
  1079. #ifdef REAL_ARITHMETIC
  1080. #define ffetarget_convert_real1_real2(res,l) \
  1081.   ({ REAL_VALUE_TYPE lr; \
  1082.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1083.      REAL_VALUE_TO_TARGET_SINGLE (lr, *(res)); \
  1084.      FFEBAD; })
  1085. #else
  1086. #define ffetarget_convert_real1_real2(res,l) (*(res) = (l), FFEBAD)
  1087. #endif
  1088. #define ffetarget_convert_real2_character1(res,l) \
  1089.   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
  1090. #define ffetarget_convert_real2_hollerith(res,l) \
  1091.   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
  1092. #define ffetarget_convert_real2_typeless(res,l) \
  1093.   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
  1094. #define ffetarget_convert_real2_complex1(res,l) \
  1095.   ffetarget_convert_real2_real1 ((res), (l).real)
  1096. #define ffetarget_convert_real2_complex2(res,l) (*(res) = (l).real, FFEBAD)
  1097. #ifdef REAL_ARITHMETIC
  1098. #define ffetarget_convert_real2_integer(res,l) \
  1099.   ({ REAL_VALUE_TYPE resr; \
  1100.      ffetargetInteger1 lf = (l); \
  1101.      REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0)); \
  1102.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  1103.      FFEBAD; })
  1104. #define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer
  1105. #else
  1106. #define ffetarget_convert_real2_integer1(res,l) (*(res) = (l), FFEBAD)
  1107. #endif
  1108. #ifdef REAL_ARITHMETIC
  1109. #define ffetarget_convert_real2_real1(res,l) \
  1110.   ({ REAL_VALUE_TYPE lr; \
  1111.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1112.      REAL_VALUE_TO_TARGET_DOUBLE (lr, (long *) &((res)->v[0])); \
  1113.      FFEBAD; })
  1114. #else
  1115. #define ffetarget_convert_real2_real1(res,l) (*(res) = (l), FFEBAD)
  1116. #endif
  1117. #define ffetarget_divide_integer1(res,l,r) \
  1118.   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
  1119.    : (*(res) = (l) / (r), FFEBAD))
  1120. #ifdef REAL_ARITHMETIC
  1121. #define ffetarget_divide_real1(res,l,r) \
  1122.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1123.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1124.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1125.      REAL_VALUES_EQUAL (rr, dconst0) \
  1126.        ? ({ REAL_VALUE_TO_TARGET_SINGLE (dconst0, *(res)); \
  1127.         FFEBAD_DIV_BY_ZERO; \
  1128.       }) \
  1129.      : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
  1130.           REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  1131.           FFEBAD; \
  1132.         }); \
  1133.      })
  1134. #define ffetarget_divide_real2(res,l,r) \
  1135.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1136.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1137.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1138.      REAL_VALUES_EQUAL (rr, dconst0) \
  1139.        ? ({ REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->v[0])); \
  1140.         FFEBAD_DIV_BY_ZERO; \
  1141.       }) \
  1142.      : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
  1143.           REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  1144.           FFEBAD; \
  1145.         }); \
  1146.      })
  1147. #else
  1148. #define ffetarget_divide_real1(res,l,r) \
  1149.   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
  1150.    : (*(res) = (l) / (r), FFEBAD))
  1151. #define ffetarget_divide_real2(res,l,r) \
  1152.   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
  1153.    : (*(res) = (l) / (r), FFEBAD))
  1154. #endif
  1155. #ifdef REAL_ARITHMETIC
  1156. #define ffetarget_eq_complex1(res,l,r) \
  1157.   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
  1158.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  1159.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  1160.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
  1161.      ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
  1162.      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
  1163.        ? TRUE : FALSE; \
  1164.      FFEBAD; })
  1165. #define ffetarget_eq_complex2(res,l,r) \
  1166.   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
  1167.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  1168.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  1169.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
  1170.      ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
  1171.      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
  1172.        ? TRUE : FALSE; \
  1173.      FFEBAD; })
  1174. #else
  1175. #define ffetarget_eq_complex1(res,l,r) \
  1176.   (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
  1177.    ? TRUE : FALSE, FFEBAD)
  1178. #define ffetarget_eq_complex2(res,l,r) \
  1179.   (*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary))  \
  1180.    ? TRUE : FALSE, FFEBAD)
  1181. #endif
  1182. #define ffetarget_eq_integer1(res,l,r) \
  1183.   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
  1184. #define ffetarget_eq_integer2(res,l,r) \
  1185.   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
  1186. #define ffetarget_eq_integer3(res,l,r) \
  1187.   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
  1188. #ifdef REAL_ARITHMETIC
  1189. #define ffetarget_eq_real1(res,l,r) \
  1190.   ({ REAL_VALUE_TYPE lr, rr; \
  1191.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1192.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1193.      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
  1194.      FFEBAD; })
  1195. #define ffetarget_eq_real2(res,l,r) \
  1196.   ({ REAL_VALUE_TYPE lr, rr; \
  1197.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1198.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1199.      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
  1200.      FFEBAD; })
  1201. #else
  1202. #define ffetarget_eq_real1(res,l,r) \
  1203.   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
  1204. #define ffetarget_eq_real2(res,l,r) \
  1205.   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
  1206. #endif
  1207. #define ffetarget_eqv_integer1(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
  1208. #define ffetarget_eqv_integer2(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
  1209. #define ffetarget_eqv_integer3(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
  1210. #define ffetarget_eqv_logical1(res,l,r) (*(res) = !!(l) == !!(r), FFEBAD)
  1211. #define ffetarget_eqv_logical2(res,l,r) (*(res) = !!(l) == !!(r), FFEBAD)
  1212. #define ffetarget_eqv_logical3(res,l,r) (*(res) = !!(l) == !!(r), FFEBAD)
  1213. #define ffetarget_ge_integer1(res,l,r) \
  1214.   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
  1215. #define ffetarget_ge_integer2(res,l,r) \
  1216.   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
  1217. #define ffetarget_ge_integer3(res,l,r) \
  1218.   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
  1219. #ifdef REAL_ARITHMETIC
  1220. #define ffetarget_ge_real1(res,l,r) \
  1221.   ({ REAL_VALUE_TYPE lr, rr; \
  1222.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1223.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1224.      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
  1225.      FFEBAD; })
  1226. #define ffetarget_ge_real2(res,l,r) \
  1227.   ({ REAL_VALUE_TYPE lr, rr; \
  1228.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1229.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1230.      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
  1231.      FFEBAD; })
  1232. #else
  1233. #define ffetarget_ge_real1(res,l,r) \
  1234.   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
  1235. #define ffetarget_ge_real2(res,l,r) \
  1236.   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
  1237. #endif
  1238. #define ffetarget_gt_integer1(res,l,r) \
  1239.   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
  1240. #define ffetarget_gt_integer2(res,l,r) \
  1241.   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
  1242. #define ffetarget_gt_integer3(res,l,r) \
  1243.   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
  1244. #ifdef REAL_ARITHMETIC
  1245. #define ffetarget_gt_real1(res,l,r) \
  1246.   ({ REAL_VALUE_TYPE lr, rr; \
  1247.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1248.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1249.      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
  1250.        ? FALSE : TRUE; \
  1251.      FFEBAD; })
  1252. #define ffetarget_gt_real2(res,l,r) \
  1253.   ({ REAL_VALUE_TYPE lr, rr; \
  1254.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1255.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1256.      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
  1257.        ? FALSE : TRUE; \
  1258.      FFEBAD; })
  1259. #else
  1260. #define ffetarget_gt_real1(res,l,r) \
  1261.   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
  1262. #define ffetarget_gt_real2(res,l,r) \
  1263.   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
  1264. #endif
  1265. #define ffetarget_hexxmil(v,t) ffetarget_typeless_hex (v, t)
  1266. #define ffetarget_hexxvxt(v,t) ffetarget_typeless_hex (v, t)
  1267. #define ffetarget_hexzmil(v,t) ffetarget_typeless_hex (v, t)
  1268. #define ffetarget_hexzvxt(v,t) ffetarget_typeless_hex (v, t)
  1269. #define ffetarget_init_0()
  1270. #define ffetarget_init_1()
  1271. #define ffetarget_init_2()
  1272. #define ffetarget_init_3()
  1273. #define ffetarget_init_4()
  1274. #define ffetarget_integerdefault_is_magical(i) \
  1275.   (i == FFETARGET_integerBIG_MAGICAL)
  1276. #ifdef REAL_ARITHMETIC
  1277. #define ffetarget_iszero_real1(l) \
  1278.   ({ REAL_VALUE_TYPE lr; \
  1279.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1280.      REAL_VALUES_EQUAL (lr, dconst0); \
  1281.    })
  1282. #define ffetarget_iszero_real2(l) \
  1283.   ({ REAL_VALUE_TYPE lr; \
  1284.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1285.      REAL_VALUES_EQUAL (lr, dconst0); \
  1286.    })
  1287. #else
  1288. #define ffetarget_iszero_real1(l) ((l) == 0.)
  1289. #define ffetarget_iszero_real2(l) ((l) == 0.)
  1290. #endif
  1291. #define ffetarget_logical1(v,truth) (*(v) = truth ? 1 : 0)
  1292. #define ffetarget_le_integer1(res,l,r) \
  1293.   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
  1294. #define ffetarget_le_integer2(res,l,r) \
  1295.   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
  1296. #define ffetarget_le_integer3(res,l,r) \
  1297.   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
  1298. #ifdef REAL_ARITHMETIC
  1299. #define ffetarget_le_real1(res,l,r) \
  1300.   ({ REAL_VALUE_TYPE lr, rr; \
  1301.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1302.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1303.      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
  1304.        ? TRUE : FALSE; \
  1305.      FFEBAD; })
  1306. #define ffetarget_le_real2(res,l,r) \
  1307.   ({ REAL_VALUE_TYPE lr, rr; \
  1308.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1309.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1310.      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
  1311.        ? TRUE : FALSE; \
  1312.      FFEBAD; })
  1313. #else
  1314. #define ffetarget_le_real1(res,l,r) \
  1315.   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
  1316. #define ffetarget_le_real2(res,l,r) \
  1317.   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
  1318. #endif
  1319. #define ffetarget_lt_integer1(res,l,r) \
  1320.   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
  1321. #define ffetarget_lt_integer2(res,l,r) \
  1322.   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
  1323. #define ffetarget_lt_integer3(res,l,r) \
  1324.   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
  1325. #ifdef REAL_ARITHMETIC
  1326. #define ffetarget_lt_real1(res,l,r) \
  1327.   ({ REAL_VALUE_TYPE lr, rr; \
  1328.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1329.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1330.      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
  1331.      FFEBAD; })
  1332. #define ffetarget_lt_real2(res,l,r) \
  1333.   ({ REAL_VALUE_TYPE lr, rr; \
  1334.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1335.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1336.      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
  1337.      FFEBAD; })
  1338. #else
  1339. #define ffetarget_lt_real1(res,l,r) \
  1340.   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
  1341. #define ffetarget_lt_real2(res,l,r) \
  1342.   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
  1343. #endif
  1344. #define ffetarget_length_character1(c) ((c).length)
  1345. #define ffetarget_length_characterdefault ffetarget_length_character1
  1346. #ifdef REAL_ARITHMETIC
  1347. #define ffetarget_make_real1(res,lr) \
  1348.   REAL_VALUE_TO_TARGET_SINGLE ((lr), *(res))
  1349. #define ffetarget_make_real2(res,lr) \
  1350.   REAL_VALUE_TO_TARGET_DOUBLE ((lr), (long *) &((res)->v[0]))
  1351. #else
  1352. #define ffetarget_make_real1(res,lr) (*(res) = (lr))
  1353. #define ffetarget_make_real2(res,lr) (*(res) = (lr))
  1354. #endif
  1355. #define ffetarget_multiply_integer1(res,l,r) (*(res) = (l) * (r), FFEBAD)
  1356. #define ffetarget_multiply_integer2(res,l,r) (*(res) = (l) * (r), FFEBAD)
  1357. #define ffetarget_multiply_integer3(res,l,r) (*(res) = (l) * (r), FFEBAD)
  1358. #ifdef REAL_ARITHMETIC
  1359. #define ffetarget_multiply_real1(res,l,r) \
  1360.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1361.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1362.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1363.      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
  1364.      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  1365.      FFEBAD; })
  1366. #define ffetarget_multiply_real2(res,l,r) \
  1367.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1368.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1369.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1370.      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
  1371.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  1372.      FFEBAD; })
  1373. #else
  1374. #define ffetarget_multiply_real1(res,l,r) (*(res) = (l) * (r), FFEBAD)
  1375. #define ffetarget_multiply_real2(res,l,r) (*(res) = (l) * (r), FFEBAD)
  1376. #endif
  1377. #ifdef REAL_ARITHMETIC
  1378. #define ffetarget_ne_complex1(res,l,r) \
  1379.   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
  1380.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  1381.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  1382.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
  1383.      ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
  1384.      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
  1385.        ? FALSE : TRUE; \
  1386.      FFEBAD; })
  1387. #define ffetarget_ne_complex2(res,l,r) \
  1388.   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
  1389.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  1390.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  1391.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
  1392.      ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
  1393.      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
  1394.        ? FALSE : TRUE; \
  1395.      FFEBAD; })
  1396. #else
  1397. #define ffetarget_ne_complex1(res,l,r) \
  1398.   (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
  1399.    ? TRUE : FALSE, FFEBAD)
  1400. #define ffetarget_ne_complex2(res,l,r) \
  1401.   (*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary))  \
  1402.    ? TRUE : FALSE, FFEBAD)
  1403. #endif
  1404. #define ffetarget_ne_integer1(res,l,r) \
  1405.   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
  1406. #define ffetarget_ne_integer2(res,l,r) \
  1407.   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
  1408. #define ffetarget_ne_integer3(res,l,r) \
  1409.   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
  1410. #ifdef REAL_ARITHMETIC
  1411. #define ffetarget_ne_real1(res,l,r) \
  1412.   ({ REAL_VALUE_TYPE lr, rr; \
  1413.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1414.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1415.      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
  1416.      FFEBAD; })
  1417. #define ffetarget_ne_real2(res,l,r) \
  1418.   ({ REAL_VALUE_TYPE lr, rr; \
  1419.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1420.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1421.      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
  1422.      FFEBAD; })
  1423. #else
  1424. #define ffetarget_ne_real1(res,l,r) \
  1425.   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
  1426. #define ffetarget_ne_real2(res,l,r) \
  1427.   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
  1428. #endif
  1429. #define ffetarget_neqv_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1430. #define ffetarget_neqv_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1431. #define ffetarget_neqv_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1432. #define ffetarget_neqv_logical1(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1433. #define ffetarget_neqv_logical2(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1434. #define ffetarget_neqv_logical3(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1435. #define ffetarget_not_integer1(res,l) (*(res) = ~(l), FFEBAD)
  1436. #define ffetarget_not_integer2(res,l) (*(res) = ~(l), FFEBAD)
  1437. #define ffetarget_not_integer3(res,l) (*(res) = ~(l), FFEBAD)
  1438. #define ffetarget_not_logical1(res,l) (*(res) = !(l), FFEBAD)
  1439. #define ffetarget_not_logical2(res,l) (*(res) = !(l), FFEBAD)
  1440. #define ffetarget_not_logical3(res,l) (*(res) = !(l), FFEBAD)
  1441. #define ffetarget_octalmil(v,t) ffetarget_typeless_octal (v, t)
  1442. #define ffetarget_octalvxt(v,t) ffetarget_typeless_octal (v, t)
  1443. #define ffetarget_offset(res,l) (*(res) = (l), TRUE)    /* Overflow? */
  1444. #define ffetarget_offset_add(res,l,r) (*(res) = (l) + (r), TRUE)    /* Overflow? */
  1445. #define ffetarget_offset_charsize(res,l,u) (*(res) = (l) * (u), TRUE)    /* Ov? */
  1446. #define ffetarget_offset_multiply(res,l,r) (*(res) = (l) * (r), TRUE)    /* Ov? */
  1447. #define ffetarget_offset_overflow(text) ((void) 0)    /* ~~no message? */
  1448. #define ffetarget_or_integer1(res,l,r) (*(res) = (l) | (r), FFEBAD)
  1449. #define ffetarget_or_integer2(res,l,r) (*(res) = (l) | (r), FFEBAD)
  1450. #define ffetarget_or_integer3(res,l,r) (*(res) = (l) | (r), FFEBAD)
  1451. #define ffetarget_or_logical1(res,l,r) (*(res) = (l) || (r), FFEBAD)
  1452. #define ffetarget_or_logical2(res,l,r) (*(res) = (l) || (r), FFEBAD)
  1453. #define ffetarget_or_logical3(res,l,r) (*(res) = (l) || (r), FFEBAD)
  1454. #define ffetarget_print_binarymil(f,v) ffetarget_print_binary (f, v)
  1455. #define ffetarget_print_binaryvxt(f,v) ffetarget_print_binary (f, v)
  1456. #define ffetarget_print_hexxmil(f,v) ffetarget_print_hex (f, v)
  1457. #define ffetarget_print_hexxvxt(f,v) ffetarget_print_hex (f, v)
  1458. #define ffetarget_print_hexzmil(f,v) ffetarget_print_hex (f, v)
  1459. #define ffetarget_print_hexzvxt(f,v) ffetarget_print_hex (f, v)
  1460. #define ffetarget_print_integer1(f,v) \
  1461.   fprintf ((f), "%" ffetargetInteger1_f "d", (v))
  1462. #define ffetarget_print_integer2(f,v) \
  1463.   fprintf ((f), "%" ffetargetInteger2_f "d", (v))
  1464. #define ffetarget_print_integer3(f,v) \
  1465.   fprintf ((f), "%" ffetargetInteger3_f "d", (v))
  1466. #define ffetarget_print_logical1(f,v) \
  1467.   fprintf ((f), "%" ffetargetLogical1_f "d", (v))
  1468. #define ffetarget_print_logical2(f,v) \
  1469.   fprintf ((f), "%" ffetargetLogical2_f "d", (v))
  1470. #define ffetarget_print_logical3(f,v) \
  1471.   fprintf ((f), "%" ffetargetLogical3_f "d", (v))
  1472. #define ffetarget_print_octalmil(f,v) ffetarget_print_octal(f,v)
  1473. #define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v)
  1474. #ifdef REAL_ARITHMETIC
  1475. #define ffetarget_print_real1(f,l) \
  1476.   ({ REAL_VALUE_TYPE lr; \
  1477.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1478.      REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
  1479.      fputs (ffetarget_string_, (f)); \
  1480.    })
  1481. #define ffetarget_print_real2(f,l) \
  1482.   ({ REAL_VALUE_TYPE lr; \
  1483.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1484.      REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
  1485.      fputs (ffetarget_string_, (f)); \
  1486.    })
  1487. #else
  1488. #define ffetarget_print_real1(f,v) \
  1489.   fprintf ((f), "%" ffetargetReal1_f "g", (v))
  1490. #define ffetarget_print_real2(f,v) \
  1491.   fprintf ((f), "%" ffetargetReal2_f "g", (v))
  1492. #endif
  1493. #ifdef REAL_ARITHMETIC
  1494. #define ffetarget_real1_one(res) REAL_VALUE_TO_TARGET_SINGLE (dconst1, *(res))
  1495. #define ffetarget_real2_one(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst1, (long *) &((res)->v[0]))
  1496. #else
  1497. #define ffetarget_real1_one(res) (*(res) = (float) 1.)
  1498. #define ffetarget_real2_one(res) (*(res) = 1.)
  1499. #endif
  1500. #ifdef REAL_ARITHMETIC
  1501. #define ffetarget_real1_two(res) REAL_VALUE_TO_TARGET_SINGLE (dconst2, *(res))
  1502. #define ffetarget_real2_two(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst2, (long *) &((res)->v[0]))
  1503. #else
  1504. #define ffetarget_real1_two(res) (*(res) = (float) 2.)
  1505. #define ffetarget_real2_two(res) (*(res) = 2.)
  1506. #endif
  1507. #ifdef REAL_ARITHMETIC
  1508. #define ffetarget_real1_zero(res) REAL_VALUE_TO_TARGET_SINGLE (dconst0, *(res))
  1509. #define ffetarget_real2_zero(res) REAL_VALUE_TO_TARGET_DOUBLE (dconst0, (long *) &((res)->v[0]))
  1510. #else
  1511. #define ffetarget_real1_zero(res) (*(res) = (float) 0.)
  1512. #define ffetarget_real2_zero(res) (*(res) = 0.)
  1513. #endif
  1514. #define ffetarget_size_typeless_binary(t) ((ffetarget_num_digits_(t) + 7) / 8)
  1515. #define ffetarget_size_typeless_octal(t) \
  1516.   ((ffetarget_num_digits_(t) * 3 + 7) / 8)
  1517. #define ffetarget_size_typeless_hex(t) ((ffetarget_num_digits_(t) + 1) / 2)
  1518. #ifdef REAL_ARITHMETIC
  1519. #define ffetarget_subtract_complex1(res,l,r) \
  1520.   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
  1521.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  1522.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  1523.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r).real); \
  1524.      ri = REAL_VALUE_FROM_TARGET_SINGLE ((r).imaginary); \
  1525.      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
  1526.      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
  1527.      REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
  1528.      REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
  1529.      FFEBAD; })
  1530. #define ffetarget_subtract_complex2(res,l,r) \
  1531.   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
  1532.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  1533.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  1534.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).real.v[0])); \
  1535.      ri = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).imaginary.v[0])); \
  1536.      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
  1537.      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
  1538.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
  1539.      REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
  1540.      FFEBAD; })
  1541. #else
  1542. #define ffetarget_subtract_complex1(res,l,r) \
  1543.   ((res)->real = (l).real - (r).real, \
  1544.    (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
  1545. #define ffetarget_subtract_complex2(res,l,r) \
  1546.   ((res)->real = (l).real - (r).real, \
  1547.    (res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
  1548. #endif
  1549. #define ffetarget_subtract_integer1(res,l,r) (*(res) = (l) - (r), FFEBAD)
  1550. #define ffetarget_subtract_integer2(res,l,r) (*(res) = (l) - (r), FFEBAD)
  1551. #define ffetarget_subtract_integer3(res,l,r) (*(res) = (l) - (r), FFEBAD)
  1552. #ifdef REAL_ARITHMETIC
  1553. #define ffetarget_subtract_real1(res,l,r) \
  1554.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1555.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1556.      rr = REAL_VALUE_FROM_TARGET_SINGLE ((r)); \
  1557.      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
  1558.      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  1559.      FFEBAD; })
  1560. #define ffetarget_subtract_real2(res,l,r) \
  1561.   ({ REAL_VALUE_TYPE lr, rr, resr; \
  1562.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1563.      rr = REAL_VALUE_FROM_TARGET_DOUBLE (&((r).v[0])); \
  1564.      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
  1565.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  1566.      FFEBAD; })
  1567. #else
  1568. #define ffetarget_subtract_real1(res,l,r) (*(res) = (l) - (r), FFEBAD)
  1569. #define ffetarget_subtract_real2(res,l,r) (*(res) = (l) - (r), FFEBAD)
  1570. #endif
  1571. #define ffetarget_terminate_0()
  1572. #define ffetarget_terminate_1()
  1573. #define ffetarget_terminate_2()
  1574. #define ffetarget_terminate_3()
  1575. #define ffetarget_terminate_4()
  1576. #define ffetarget_text_character1(c) ((c).text)
  1577. #define ffetarget_text_characterdefault ffetarget_text_character1
  1578. #ifdef REAL_ARITHMETIC
  1579. #define ffetarget_uminus_complex1(res,l) \
  1580.   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
  1581.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l).real); \
  1582.      li = REAL_VALUE_FROM_TARGET_SINGLE ((l).imaginary); \
  1583.      resr = REAL_VALUE_NEGATE (lr); \
  1584.      resi = REAL_VALUE_NEGATE (li); \
  1585.      REAL_VALUE_TO_TARGET_SINGLE (resr, (res)->real); \
  1586.      REAL_VALUE_TO_TARGET_SINGLE (resi, (res)->imaginary); \
  1587.      FFEBAD; })
  1588. #define ffetarget_uminus_complex2(res,l) \
  1589.   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
  1590.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).real.v[0])); \
  1591.      li = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).imaginary.v[0])); \
  1592.      resr = REAL_VALUE_NEGATE (lr); \
  1593.      resi = REAL_VALUE_NEGATE (li); \
  1594.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->real.v[0])); \
  1595.      REAL_VALUE_TO_TARGET_DOUBLE (resi, (long *) &((res)->imaginary.v[0])); \
  1596.      FFEBAD; })
  1597. #else
  1598. #define ffetarget_uminus_complex1(res,l) \
  1599.   ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
  1600. #define ffetarget_uminus_complex2(res,l) \
  1601.   ((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
  1602. #endif
  1603. #define ffetarget_uminus_integer1(res,l) (*(res) = -(l), FFEBAD)
  1604. #define ffetarget_uminus_integer2(res,l) (*(res) = -(l), FFEBAD)
  1605. #define ffetarget_uminus_integer3(res,l) (*(res) = -(l), FFEBAD)
  1606. #ifdef REAL_ARITHMETIC
  1607. #define ffetarget_uminus_real1(res,l) \
  1608.   ({ REAL_VALUE_TYPE lr, resr; \
  1609.      lr = REAL_VALUE_FROM_TARGET_SINGLE ((l)); \
  1610.      resr = REAL_VALUE_NEGATE (lr); \
  1611.      REAL_VALUE_TO_TARGET_SINGLE (resr, *(res)); \
  1612.      FFEBAD; })
  1613. #define ffetarget_uminus_real2(res,l) \
  1614.   ({ REAL_VALUE_TYPE lr, resr; \
  1615.      lr = REAL_VALUE_FROM_TARGET_DOUBLE (&((l).v[0])); \
  1616.      resr = REAL_VALUE_NEGATE (lr); \
  1617.      REAL_VALUE_TO_TARGET_DOUBLE (resr, (long *) &((res)->v[0])); \
  1618.      FFEBAD; })
  1619. #else
  1620. #define ffetarget_uminus_real1(res,l) (*(res) = -(l), FFEBAD)
  1621. #define ffetarget_uminus_real2(res,l) (*(res) = -(l), FFEBAD)
  1622. #endif
  1623. #ifdef REAL_ARITHMETIC
  1624. #define ffetarget_value_real1(lr) REAL_VALUE_FROM_TARGET_SINGLE ((lr))
  1625. #define ffetarget_value_real2(lr) REAL_VALUE_FROM_TARGET_DOUBLE (&((lr).v[0]))
  1626. #else
  1627. #define ffetarget_value_real1
  1628. #define ffetarget_value_real2
  1629. #endif
  1630. #define ffetarget_xor_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1631. #define ffetarget_xor_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1632. #define ffetarget_xor_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
  1633. #define ffetarget_xor_logical1(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1634. #define ffetarget_xor_logical2(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1635. #define ffetarget_xor_logical3(res,l,r) (*(res) = !!(l) != !!(r), FFEBAD)
  1636.  
  1637. /* End of #include file. */
  1638.  
  1639. #endif
  1640.