PageRenderTime 52ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/other/netcdf_write_matrix/src/libsrc/t_ncxx.m4

http://github.com/jbeezley/wrf-fire
m4 | 956 lines | 773 code | 106 blank | 77 comment | 0 complexity | 6009d3d0c602c38feea2660e39360ec3 MD5 | raw file
Possible License(s): AGPL-1.0
  1. dnl This is m4 source.
  2. dnl Process using m4 to produce 'C' language file.
  3. dnl
  4. dnl If you see this line, you can ignore the next one.
  5. /* Do not edit this file. It is produced from the corresponding .m4 source */
  6. dnl
  7. /*
  8. * Copyright 1996, University Corporation for Atmospheric Research
  9. * See netcdf/COPYRIGHT file for copying and redistribution conditions.
  10. */
  11. /* "$Id: t_ncxx.m4,v 2.17 2005/05/20 14:48:14 russ Exp $" */
  12. /*
  13. * This program tests the aggregate external representation conversion
  14. * functions "ncx_[pad_]{put,get}n_*()" declared in ncx.h.
  15. * Unlike t_ncx.c, it only checks self consistency,
  16. * not consistency with the xdr library.
  17. *
  18. * Link like this:
  19. * cc t_ncxx.c ncx.o -o t_nxc
  20. * (The xdr library is not needed.)
  21. *
  22. * If an assertion fails, there is a problem.
  23. * Otherwise, the program is silent and has exit code 0.
  24. */
  25. #undef NDEBUG /* always active assert() in this file */
  26. #include <stdio.h>
  27. #include <string.h>
  28. #include <limits.h>
  29. /* alias poorly named limits.h macros */
  30. #define SHORT_MAX SHRT_MAX
  31. #define SHORT_MIN SHRT_MIN
  32. #define USHORT_MAX USHRT_MAX
  33. #include <assert.h>
  34. #include "ncx.h"
  35. #define X_SIZEOF_SCHAR X_SIZEOF_CHAR
  36. #define X_LONG_MAX X_INT_MAX
  37. #define X_LONG_MIN X_INT_MIN
  38. #define XBSZ 1024
  39. char ncxb[XBSZ];
  40. char lbuf[XBSZ];
  41. #define ArraySize(thang) (sizeof(thang)/sizeof(thang[0]))
  42. #define eSizeOf(thang) ((size_t)(sizeof(thang[0])))
  43. /*
  44. * Some test data
  45. * The ideas is that ncx_putn_type_type(...., types)
  46. * should not return NC_ERANGE.
  47. */
  48. #if SCHAR_MAX == X_SCHAR_MAX && SCHAR_MIN == X_SCHAR_MIN
  49. static schar schars[] = {
  50. SCHAR_MIN, SCHAR_MIN +1,
  51. -1, 0, 1,
  52. SCHAR_MAX - 1, SCHAR_MAX
  53. };
  54. #else
  55. /* The implementation and this test assume 8 bit bytes. */
  56. #error "Not 8 bit bytes ??"
  57. #endif
  58. static short shorts[] = {
  59. #if SHORT_MAX <= X_SHORT_MAX
  60. SHORT_MIN, SHORT_MIN + 1,
  61. # if SCHAR_MAX < X_SHORT_MAX
  62. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  63. # endif
  64. -1, 0, 1,
  65. # if SCHAR_MAX < X_SHORT_MAX
  66. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  67. # endif
  68. SHORT_MAX - 1, SHORT_MAX
  69. #else
  70. X_SHORT_MIN, X_SHORT_MIN + 1,
  71. # if SCHAR_MAX < X_SHORT_MAX
  72. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  73. # endif
  74. -1, 0, 1,
  75. # if SCHAR_MAX < X_SHORT_MAX
  76. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  77. # endif
  78. X_SHORT_MAX - 1, X_SHORT_MAX
  79. #endif
  80. };
  81. static int ints[] = {
  82. #if INT_MAX <= X_INT_MAX
  83. INT_MIN, INT_MIN +1,
  84. # if SHORT_MAX < X_INT_MAX
  85. SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
  86. # endif
  87. # if SCHAR_MAX < X_INT_MAX
  88. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  89. # endif
  90. -1, 0, 1,
  91. # if SCHAR_MAX < X_INT_MAX
  92. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  93. # endif
  94. # if SHORT_MAX < X_INT_MAX
  95. SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
  96. # endif
  97. INT_MAX - 1, INT_MAX
  98. #else
  99. X_INT_MIN, X_INT_MIN +1,
  100. # if SHORT_MAX < X_INT_MAX
  101. SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
  102. # endif
  103. # if SCHAR_MAX < X_INT_MAX
  104. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  105. # endif
  106. -1, 0, 1,
  107. # if SCHAR_MAX < X_INT_MAX
  108. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  109. # endif
  110. # if SHORT_MAX < X_INT_MAX
  111. SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
  112. # endif
  113. X_INT_MAX - 1, X_INT_MAX
  114. #endif /* INT */
  115. };
  116. /* N.B. only testing longs over X_INT range for now */
  117. static long longs[] = {
  118. #if LONG_MAX <= X_INT_MAX
  119. LONG_MIN, LONG_MIN +1,
  120. # if INT_MAX < X_INT_MAX
  121. INT_MIN -1, INT_MIN, INT_MIN + 1,
  122. # endif
  123. # if SHORT_MAX < X_INT_MAX
  124. SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
  125. # endif
  126. # if SCHAR_MAX < X_INT_MAX
  127. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  128. # endif
  129. -1, 0, 1,
  130. # if SCHAR_MAX < X_INT_MAX
  131. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  132. # endif
  133. # if SHORT_MAX < X_INT_MAX
  134. SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
  135. # endif
  136. # if INT_MAX < X_INT_MAX
  137. INT_MAX -1, INT_MAX, INT_MAX + 1,
  138. # endif
  139. LONG_MAX - 1, LONG_MAX
  140. #else
  141. X_INT_MIN, X_INT_MIN +1,
  142. # if SHORT_MAX < X_INT_MAX
  143. SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
  144. # endif
  145. # if SCHAR_MAX < X_INT_MAX
  146. SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
  147. # endif
  148. -1, 0, 1,
  149. # if SCHAR_MAX < X_INT_MAX
  150. SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
  151. # endif
  152. # if SHORT_MAX < X_INT_MAX
  153. SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
  154. # endif
  155. X_INT_MAX - 1, X_INT_MAX
  156. #endif
  157. };
  158. static float floats[] = {
  159. -1.E9F,
  160. -16777215, -16777214,
  161. -999999,
  162. -32769, -32768, -32767,
  163. -129, -128, 127,
  164. -1, 0, 1,
  165. 126, 127, 128,
  166. 32766, 32767, 32768,
  167. 999999,
  168. 16777214, 16777215, /* 2^24 -1 */
  169. 1.E9F
  170. };
  171. static double doubles[] = {
  172. -1.E20,
  173. -4503599627370495., -4503599627370494.,
  174. -999999999999999.,
  175. -1.E9,
  176. -16777215, -16777214,
  177. -999999,
  178. -32769, -32768, -32767,
  179. -129, -128, 127,
  180. -1, 0, 1,
  181. 126, 127, 128,
  182. 32766, 32767, 32768,
  183. 999999,
  184. 16777214, 16777215, /* 2^24 -1 */
  185. 1.E9,
  186. 999999999999999.,
  187. 4503599627370494., 4503599627370495., /* 2^53 -1 */
  188. 1.E20
  189. };
  190. static uchar uchars[] = {
  191. 0, 1,
  192. UCHAR_MAX/2 -1, UCHAR_MAX/2, UCHAR_MAX/2 +1,
  193. UCHAR_MAX - 1, UCHAR_MAX
  194. };
  195. /* End of test data */
  196. dnl dnl dnl
  197. dnl
  198. dnl Macros
  199. dnl
  200. dnl dnl dnl
  201. dnl
  202. dnl Upcase(str)
  203. dnl
  204. define(`Upcase',dnl
  205. `dnl
  206. translit($1, abcdefghijklmnopqrstuvwxyz, ABCDEFGHIJKLMNOPQRSTUVWXYZ)')dnl
  207. dnl dnl dnl
  208. dnl
  209. dnl Xsizeof(Xtype)
  210. dnl
  211. define(`Xsizeof', ``X_SIZEOF_'Upcase($1)')dnl
  212. dnl dnl dnl
  213. define(`XMin', ``X_'Upcase($1)`_MIN'')dnl
  214. define(`XMax', ``X_'Upcase($1)`_MAX'')dnl
  215. dnl dnl dnl
  216. dnl
  217. dnl T_PUTN(XType, Type)
  218. dnl
  219. define(`T_PUTN',dnl
  220. `dnl
  221. static void
  222. t_putn_$1_$2(char *const buf)
  223. {
  224. char *xp = buf;
  225. const $2 *tp = `$2's;
  226. size_t nelems = ArraySize(`$2's);
  227. int status = ncx_putn_$1_$2((void **)&xp, nelems, tp);
  228. assert(xp == buf + nelems * Xsizeof($1));
  229. {
  230. size_t ii;
  231. for(ii = 0; ii < nelems; ii++)
  232. {
  233. if((double) tp[ii] > XMax($1))
  234. {
  235. assert(status == NC_ERANGE);
  236. return;
  237. }
  238. if((double) tp[ii] < XMin($1))
  239. {
  240. assert(status == NC_ERANGE);
  241. return;
  242. }
  243. }
  244. assert(status == 0);
  245. }
  246. }
  247. ')dnl
  248. dnl dnl dnl
  249. dnl
  250. dnl T_PUTN_U(XType, Type)
  251. dnl Doesn't make signed comparisons to unsigned type
  252. dnl
  253. define(`T_PUTN_U',dnl
  254. `dnl
  255. static void
  256. t_putn_$1_$2(char *const buf)
  257. {
  258. char *xp = buf;
  259. const $2 *tp = `$2's;
  260. size_t nelems = ArraySize(`$2's);
  261. int status = ncx_putn_$1_$2((void **)&xp, nelems, tp);
  262. assert(xp == buf + nelems * Xsizeof($1));
  263. {
  264. size_t ii;
  265. for(ii = 0; ii < nelems; ii++)
  266. {
  267. if((double) tp[ii] > XMax($1))
  268. {
  269. assert(status == NC_ERANGE);
  270. return;
  271. }
  272. }
  273. assert(status == 0);
  274. }
  275. }
  276. ')dnl
  277. dnl dnl dnl
  278. dnl
  279. dnl T_PAD_PUTN(XType, Type)
  280. dnl
  281. define(`T_PAD_PUTN',dnl
  282. `dnl
  283. static void
  284. t_pad_putn_$1_$2(char *const buf)
  285. {
  286. char *xp = buf;
  287. const $2 *tp = `$2's;
  288. size_t nelems = ArraySize(`$2's);
  289. const char *end = buf + nelems * Xsizeof($1);
  290. int status = ncx_pad_putn_$1_$2((void **)&xp, nelems, tp);
  291. assert(xp >= end);
  292. assert((xp - end) < 4);
  293. assert((xp - buf)%4 == 0);
  294. {
  295. size_t ii;
  296. for(ii = 0; ii < nelems; ii++)
  297. {
  298. if((double) tp[ii] > XMax($1))
  299. {
  300. assert(status == NC_ERANGE);
  301. return;
  302. }
  303. if((double) tp[ii] < XMin($1))
  304. {
  305. assert(status == NC_ERANGE);
  306. return;
  307. }
  308. }
  309. assert(status == 0);
  310. }
  311. }
  312. ')dnl
  313. dnl dnl dnl
  314. dnl
  315. dnl T_GETN(XType, Type)
  316. dnl
  317. define(`T_GETN',dnl
  318. `dnl
  319. static void
  320. t_getn_$1_$2(const char *const buf)
  321. {
  322. const char *xp = buf;
  323. const $2 *tp = `$2's;
  324. $2 *lp = ($2 *)lbuf;
  325. size_t nelems = ArraySize(`$2's);
  326. int status = ncx_getn_$1_$2((const void **)&xp, nelems, lp);
  327. assert(xp == buf + nelems * Xsizeof($1));
  328. assert(status == 0);
  329. {
  330. size_t ii;
  331. for(ii = 0; ii < nelems; ii++)
  332. {
  333. if(((double)tp[ii] <= XMax($1))
  334. && ((double)tp[ii] >= XMin($1)))
  335. {
  336. assert(tp[ii] == lp[ii]);
  337. }
  338. }
  339. }
  340. }
  341. ')dnl
  342. dnl dnl dnl
  343. dnl
  344. dnl T_GETN_U(XType, Type)
  345. dnl Doesn't make signed comparisons to unsigned type
  346. dnl
  347. define(`T_GETN_U',dnl
  348. `dnl
  349. static void
  350. t_getn_$1_$2(const char *const buf)
  351. {
  352. const char *xp = buf;
  353. const $2 *tp = `$2's;
  354. $2 *lp = ($2 *)lbuf;
  355. size_t nelems = ArraySize(`$2's);
  356. int status = ncx_getn_$1_$2((const void **)&xp, nelems, lp);
  357. assert(xp == buf + nelems * Xsizeof($1));
  358. assert(status == 0);
  359. {
  360. size_t ii;
  361. for(ii = 0; ii < nelems; ii++)
  362. {
  363. if((double) tp[ii] <= XMax($1))
  364. {
  365. assert(tp[ii] == lp[ii]);
  366. }
  367. }
  368. }
  369. }
  370. ')dnl
  371. dnl dnl dnl
  372. dnl
  373. dnl T_PAD_GETN(XType, Type)
  374. dnl
  375. define(`T_PAD_GETN',dnl
  376. `dnl
  377. static void
  378. t_pad_getn_$1_$2(const char *const buf)
  379. {
  380. const char *xp = buf;
  381. const $2 *tp = `$2's;
  382. $2 *lp = ($2 *)lbuf;
  383. size_t nelems = ArraySize(`$2's);
  384. const char *end = buf + nelems * Xsizeof($1);
  385. int status = ncx_pad_getn_$1_$2((const void **)&xp, nelems, lp);
  386. assert(xp >= end);
  387. assert((xp - end) < 4);
  388. assert((xp - buf)%4 == 0);
  389. assert(status == 0);
  390. {
  391. size_t ii;
  392. for(ii = 0; ii < nelems; ii++)
  393. {
  394. if(((double) tp[ii] <= XMax($1))
  395. && ((double) tp[ii] >= XMin($1)))
  396. {
  397. assert(tp[ii] == lp[ii]);
  398. }
  399. }
  400. }
  401. }
  402. ')dnl
  403. dnl dnl dnl
  404. dnl
  405. dnl Declare & define test routines
  406. dnl
  407. dnl dnl dnl
  408. T_PUTN(schar, schar)
  409. dnl T_PUTN(schar, uchar) replaced by special case code.
  410. dnl - we don't return conversion errors putting uchar to schar.
  411. static void
  412. t_putn_schar_uchar(char *const buf)
  413. {
  414. char *xp = buf;
  415. const uchar *tp = uchars;
  416. size_t nelems = ArraySize(schars);
  417. int status = ncx_putn_schar_uchar((void **)&xp, nelems, tp);
  418. assert(xp == buf + nelems * X_SIZEOF_SCHAR);
  419. assert(status == 0);
  420. }
  421. T_PUTN(schar, short)
  422. T_PUTN(schar, int)
  423. T_PUTN(schar, long)
  424. T_PUTN(schar, float)
  425. T_PUTN(schar, double)
  426. T_PAD_PUTN(schar, schar)
  427. dnl T_PAD_PUTN(schar, uchar) replaced by special case code.
  428. dnl - we don't return conversion errors putting uchar to schar.
  429. static void
  430. t_pad_putn_schar_uchar(char *const buf)
  431. {
  432. char *xp = buf;
  433. const uchar *tp = uchars;
  434. size_t nelems = ArraySize(uchars);
  435. const char *end = buf + nelems * X_SIZEOF_SCHAR;
  436. int status = ncx_pad_putn_schar_uchar((void **)&xp, nelems, tp);
  437. assert(xp >= end);
  438. assert((xp - end) < 4);
  439. assert((xp - buf)%4 == 0);
  440. assert(status == 0);
  441. }
  442. T_PAD_PUTN(schar, short)
  443. T_PAD_PUTN(schar, int)
  444. T_PAD_PUTN(schar, long)
  445. T_PAD_PUTN(schar, float)
  446. T_PAD_PUTN(schar, double)
  447. T_PUTN(short, schar)
  448. T_PUTN_U(short, uchar)
  449. T_PUTN(short, short)
  450. T_PUTN(short, int)
  451. T_PUTN(short, long)
  452. T_PUTN(short, float)
  453. T_PUTN(short, double)
  454. T_PAD_PUTN(short, schar)
  455. dnl T_PAD_PUTN(short, uchar)
  456. dnl Don't make signed comparisons to usigned type
  457. static void
  458. t_pad_putn_short_uchar(char *const buf)
  459. {
  460. char *xp = buf;
  461. const uchar *tp = uchars;
  462. size_t nelems = ArraySize(uchars);
  463. const char *end = buf + nelems * X_SIZEOF_SHORT;
  464. int status = ncx_pad_putn_short_uchar((void **)&xp, nelems, tp);
  465. assert(xp >= end);
  466. assert((xp - end) < 4);
  467. assert((xp - buf)%4 == 0);
  468. {
  469. size_t ii;
  470. for(ii = 0; ii < nelems; ii++)
  471. {
  472. if(tp[ii] > X_SHORT_MAX)
  473. {
  474. assert(status == NC_ERANGE);
  475. return;
  476. }
  477. }
  478. assert(status == 0);
  479. }
  480. }
  481. T_PAD_PUTN(short, short)
  482. T_PAD_PUTN(short, int)
  483. T_PAD_PUTN(short, long)
  484. T_PAD_PUTN(short, float)
  485. T_PAD_PUTN(short, double)
  486. T_PUTN(int, schar)
  487. T_PUTN_U(int, uchar)
  488. T_PUTN(int, short)
  489. T_PUTN(int, int)
  490. T_PUTN(int, long)
  491. T_PUTN(int, float)
  492. T_PUTN(int, double)
  493. T_PUTN(float, schar)
  494. T_PUTN_U(float, uchar)
  495. T_PUTN(float, short)
  496. T_PUTN(float, int)
  497. T_PUTN(float, long)
  498. T_PUTN(float, float)
  499. T_PUTN(float, double)
  500. T_PUTN(double, schar)
  501. T_PUTN_U(double, uchar)
  502. T_PUTN(double, short)
  503. T_PUTN(double, int)
  504. T_PUTN(double, long)
  505. T_PUTN(double, float)
  506. T_PUTN(double, double)
  507. T_GETN(schar, schar)
  508. dnl T_GETN(schar, uchar)
  509. dnl - we don't return conversion errors gettin schar to uchar.
  510. static void
  511. t_getn_schar_uchar(const char *const buf)
  512. {
  513. const char *xp = buf;
  514. const uchar *tp = uchars;
  515. uchar *lp = (uchar *)lbuf;
  516. size_t nelems = ArraySize(schars);
  517. int status = ncx_getn_schar_uchar((const void **)&xp, nelems, lp);
  518. assert(xp == buf + nelems * X_SIZEOF_SCHAR);
  519. assert(status == 0);
  520. {
  521. size_t ii;
  522. for(ii = 0; ii < nelems; ii++)
  523. {
  524. assert(tp[ii] == lp[ii]);
  525. }
  526. }
  527. }
  528. T_GETN(schar, short)
  529. T_GETN(schar, int)
  530. T_GETN(schar, long)
  531. T_GETN(schar, float)
  532. T_GETN(schar, double)
  533. T_PAD_GETN(schar, schar)
  534. dnl T_PAD_GETN(schar, uchar)
  535. dnl - we don't return conversion errors gettin schar to uchar.
  536. static void
  537. t_pad_getn_schar_uchar(const char *const buf)
  538. {
  539. const char *xp = buf;
  540. const uchar *tp = uchars;
  541. uchar *lp = (uchar *)lbuf;
  542. size_t nelems = ArraySize(schars);
  543. const char *end = buf + nelems * X_SIZEOF_SCHAR;
  544. int status = ncx_pad_getn_schar_uchar((const void **)&xp, nelems, lp);
  545. assert(xp >= end);
  546. assert((xp - end) < 4);
  547. assert((xp - buf)%4 == 0);
  548. assert(status == 0);
  549. {
  550. size_t ii;
  551. for(ii = 0; ii < nelems; ii++)
  552. {
  553. assert(tp[ii] == lp[ii]);
  554. }
  555. }
  556. }
  557. T_PAD_GETN(schar, short)
  558. T_PAD_GETN(schar, int)
  559. T_PAD_GETN(schar, long)
  560. T_PAD_GETN(schar, float)
  561. T_PAD_GETN(schar, double)
  562. T_GETN(short, schar)
  563. T_GETN_U(short, uchar)
  564. T_GETN(short, short)
  565. T_GETN(short, int)
  566. T_GETN(short, long)
  567. T_GETN(short, float)
  568. T_GETN(short, double)
  569. T_PAD_GETN(short, schar)
  570. dnl T_PAD_GETN(short, uchar)
  571. dnl Don't make signed comparisons to usigned type
  572. static void
  573. t_pad_getn_short_uchar(const char *const buf)
  574. {
  575. const char *xp = buf;
  576. const uchar *tp = uchars;
  577. uchar *lp = (uchar *)lbuf;
  578. size_t nelems = ArraySize(uchars);
  579. const char *end = buf + nelems * X_SIZEOF_SHORT;
  580. int status = ncx_pad_getn_short_uchar((const void **)&xp, nelems, lp);
  581. assert(xp >= end);
  582. assert((xp - end) < 4);
  583. assert((xp - buf)%4 == 0);
  584. assert(status == 0);
  585. {
  586. size_t ii;
  587. for(ii = 0; ii < nelems; ii++)
  588. {
  589. if((tp[ii] <= X_SHORT_MAX))
  590. {
  591. assert(tp[ii] == lp[ii]);
  592. }
  593. }
  594. }
  595. }
  596. T_PAD_GETN(short, short)
  597. T_PAD_GETN(short, int)
  598. T_PAD_GETN(short, long)
  599. T_PAD_GETN(short, float)
  600. T_PAD_GETN(short, double)
  601. T_GETN(int, schar)
  602. T_GETN_U(int, uchar)
  603. T_GETN(int, short)
  604. T_GETN(int, int)
  605. T_GETN(int, long)
  606. T_GETN(int, float)
  607. T_GETN(int, double)
  608. T_GETN(float, schar)
  609. T_GETN_U(float, uchar)
  610. T_GETN(float, short)
  611. dnl T_GETN(float, int)
  612. dnl Exact conversion of int to x_float is limited by external float mantissa
  613. static void
  614. t_getn_float_int(const char *const buf)
  615. {
  616. const char *xp = buf;
  617. const int *tp = ints;
  618. int *lp = (int *)lbuf;
  619. size_t nelems = ArraySize(ints);
  620. int status = ncx_getn_float_int((const void **)&xp, nelems, lp);
  621. assert(xp == buf + nelems * X_SIZEOF_FLOAT);
  622. /* If the system rounds up can get NC_ERANGE */
  623. assert(status == 0 || status == NC_ERANGE);
  624. {
  625. size_t ii;
  626. for(ii = 0; ii < nelems; ii++)
  627. {
  628. /* limited by x_float mantissa nbits */
  629. if((tp[ii] <= 16777215)
  630. && (tp[ii] >= -16777215))
  631. {
  632. assert(tp[ii] == lp[ii]);
  633. }
  634. }
  635. }
  636. }
  637. dnl T_GETN(float, long)
  638. dnl Exact conversion of long to x_float is limited by external float mantissa
  639. static void
  640. t_getn_float_long(const char *const buf)
  641. {
  642. const char *xp = buf;
  643. const long *tp = longs;
  644. long *lp = (long *)lbuf;
  645. size_t nelems = ArraySize(longs);
  646. int status = ncx_getn_float_long((const void **)&xp, nelems, lp);
  647. assert(xp == buf + nelems * X_SIZEOF_FLOAT);
  648. /* If the system rounds up can get NC_ERANGE */
  649. assert(status == 0 || status == NC_ERANGE);
  650. {
  651. size_t ii;
  652. for(ii = 0; ii < nelems; ii++)
  653. {
  654. /* limited by x_float mantissa nbits */
  655. if((tp[ii] <= 16777215)
  656. && (tp[ii] >= 16777215))
  657. {
  658. if(tp[ii] != lp[ii])
  659. (void) fprintf(stderr,
  660. "%.9e != %.9e float_float (diff %.9e)\n",
  661. (double)tp[ii], (double)lp[ii],
  662. (double)(tp[ii] - lp[ii]));
  663. }
  664. }
  665. }
  666. }
  667. T_GETN(float, float)
  668. dnl T_GETN(float, double)
  669. dnl Exact conversion of double to x_float is limited by external float mantissa
  670. static void
  671. t_getn_float_double(const char *const buf)
  672. {
  673. const char *xp = buf;
  674. const double *tp = doubles;
  675. double *lp = (double *)lbuf;
  676. size_t nelems = ArraySize(doubles);
  677. int status = ncx_getn_float_double((const void **)&xp, nelems, lp);
  678. assert(xp == buf + nelems * X_SIZEOF_FLOAT);
  679. assert(status == 0);
  680. {
  681. size_t ii;
  682. for(ii = 0; ii < nelems; ii++)
  683. {
  684. if((tp[ii] <= X_FLOAT_MAX)
  685. && (tp[ii] >= X_FLOAT_MIN))
  686. {
  687. if(((float)tp[ii]) != lp[ii])
  688. {
  689. if(tp[ii] != 0)
  690. {
  691. double eps = (tp[ii] - lp[ii])/tp[ii];
  692. if(eps > 1.19209290E-07F) /* X_FLT_EPSILON */
  693. {
  694. (void) fprintf(stderr,
  695. "%.9e != %.9e float_double (eps %.9e)\n",
  696. tp[ii], lp[ii], eps);
  697. }
  698. }
  699. else
  700. {
  701. (void) fprintf(stderr,
  702. "%.9e != %.9e float_double (diff %.9e)\n",
  703. tp[ii], lp[ii], tp[ii] - lp[ii]);
  704. }
  705. }
  706. }
  707. }
  708. }
  709. }
  710. T_GETN(double, schar)
  711. T_GETN_U(double, uchar)
  712. T_GETN(double, short)
  713. T_GETN(double, int)
  714. T_GETN(double, long)
  715. T_GETN(double, float)
  716. T_GETN(double, double)
  717. #if defined(_CRAYIEEE) && !defined(_CRAYMPP) /* T90 */
  718. #include <signal.h>
  719. #endif /* T90 */
  720. int
  721. main(int ac, char *av[])
  722. {
  723. #if defined(_CRAYIEEE) && !defined(_CRAYMPP) /* T90 */
  724. /*
  725. * Some of the extreme test assignments in this program trigger
  726. * floating point exceptions on CRAY T90
  727. */
  728. (void) signal(SIGFPE, SIG_IGN);
  729. #endif /* T90 */
  730. /* x_schar */
  731. t_putn_schar_schar(ncxb);
  732. t_getn_schar_schar(ncxb);
  733. t_putn_schar_uchar(ncxb);
  734. t_getn_schar_uchar(ncxb);
  735. t_putn_schar_short(ncxb);
  736. t_getn_schar_short(ncxb);
  737. t_putn_schar_int(ncxb);
  738. t_getn_schar_int(ncxb);
  739. t_putn_schar_long(ncxb);
  740. t_getn_schar_long(ncxb);
  741. t_putn_schar_float(ncxb);
  742. t_getn_schar_float(ncxb);
  743. t_putn_schar_double(ncxb);
  744. t_getn_schar_double(ncxb);
  745. /* pad x_schar */
  746. t_pad_putn_schar_schar(ncxb);
  747. t_getn_schar_schar(ncxb);
  748. t_pad_getn_schar_schar(ncxb);
  749. t_pad_putn_schar_uchar(ncxb);
  750. t_getn_schar_uchar(ncxb);
  751. t_pad_getn_schar_uchar(ncxb);
  752. t_pad_putn_schar_short(ncxb);
  753. t_getn_schar_short(ncxb);
  754. t_pad_getn_schar_short(ncxb);
  755. t_pad_putn_schar_int(ncxb);
  756. t_getn_schar_int(ncxb);
  757. t_pad_getn_schar_int(ncxb);
  758. t_pad_putn_schar_long(ncxb);
  759. t_getn_schar_long(ncxb);
  760. t_pad_getn_schar_long(ncxb);
  761. t_pad_putn_schar_float(ncxb);
  762. t_getn_schar_float(ncxb);
  763. t_pad_getn_schar_float(ncxb);
  764. t_pad_putn_schar_double(ncxb);
  765. t_getn_schar_double(ncxb);
  766. t_pad_getn_schar_double(ncxb);
  767. /* x_short */
  768. t_putn_short_schar(ncxb);
  769. t_getn_short_schar(ncxb);
  770. t_putn_short_uchar(ncxb);
  771. t_getn_short_uchar(ncxb);
  772. t_putn_short_short(ncxb);
  773. t_getn_short_short(ncxb);
  774. t_putn_short_int(ncxb);
  775. t_getn_short_int(ncxb);
  776. t_putn_short_long(ncxb);
  777. t_getn_short_long(ncxb);
  778. t_putn_short_float(ncxb);
  779. t_getn_short_float(ncxb);
  780. t_putn_short_double(ncxb);
  781. t_getn_short_double(ncxb);
  782. /* pad x_short */
  783. t_pad_putn_short_schar(ncxb);
  784. t_getn_short_schar(ncxb);
  785. t_pad_getn_short_schar(ncxb);
  786. t_pad_putn_short_uchar(ncxb);
  787. t_getn_short_uchar(ncxb);
  788. t_pad_getn_short_uchar(ncxb);
  789. t_pad_putn_short_short(ncxb);
  790. t_getn_short_short(ncxb);
  791. t_pad_getn_short_short(ncxb);
  792. t_pad_putn_short_int(ncxb);
  793. t_getn_short_int(ncxb);
  794. t_pad_getn_short_int(ncxb);
  795. t_pad_putn_short_long(ncxb);
  796. t_getn_short_long(ncxb);
  797. t_pad_getn_short_long(ncxb);
  798. t_pad_putn_short_float(ncxb);
  799. t_getn_short_float(ncxb);
  800. t_pad_getn_short_float(ncxb);
  801. t_pad_putn_short_double(ncxb);
  802. t_getn_short_double(ncxb);
  803. t_pad_getn_short_double(ncxb);
  804. /* x_int */
  805. t_putn_int_schar(ncxb);
  806. t_getn_int_schar(ncxb);
  807. t_putn_int_uchar(ncxb);
  808. t_getn_int_uchar(ncxb);
  809. t_putn_int_short(ncxb);
  810. t_getn_int_short(ncxb);
  811. t_putn_int_int(ncxb);
  812. t_getn_int_int(ncxb);
  813. t_putn_int_long(ncxb);
  814. t_getn_int_long(ncxb);
  815. t_putn_int_float(ncxb);
  816. t_getn_int_float(ncxb);
  817. t_putn_int_double(ncxb);
  818. t_getn_int_double(ncxb);
  819. /* x_float */
  820. t_putn_float_schar(ncxb);
  821. t_getn_float_schar(ncxb);
  822. t_putn_float_uchar(ncxb);
  823. t_getn_float_uchar(ncxb);
  824. t_putn_float_short(ncxb);
  825. t_getn_float_short(ncxb);
  826. t_putn_float_int(ncxb);
  827. t_getn_float_int(ncxb);
  828. t_putn_float_long(ncxb);
  829. t_getn_float_long(ncxb);
  830. t_putn_float_float(ncxb);
  831. t_getn_float_float(ncxb);
  832. t_putn_float_double(ncxb);
  833. t_getn_float_double(ncxb);
  834. /* x_double */
  835. t_putn_double_schar(ncxb);
  836. t_getn_double_schar(ncxb);
  837. t_putn_double_uchar(ncxb);
  838. t_getn_double_uchar(ncxb);
  839. t_putn_double_short(ncxb);
  840. t_getn_double_short(ncxb);
  841. t_putn_double_int(ncxb);
  842. t_getn_double_int(ncxb);
  843. t_putn_double_long(ncxb);
  844. t_getn_double_long(ncxb);
  845. t_putn_double_float(ncxb);
  846. t_getn_double_float(ncxb);
  847. t_putn_double_double(ncxb);
  848. t_getn_double_double(ncxb);
  849. return 0;
  850. }