00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #undef NDEBUG
00022
00023 #include <stdio.h>
00024 #include <string.h>
00025 #include <limits.h>
00026
00027 #define SHORT_MAX SHRT_MAX
00028 #define SHORT_MIN SHRT_MIN
00029 #define USHORT_MAX USHRT_MAX
00030 #include <assert.h>
00031 #include "ncx.h"
00032 #define X_SIZEOF_SCHAR X_SIZEOF_CHAR
00033 #define X_LONG_MAX X_INT_MAX
00034 #define X_LONG_MIN X_INT_MIN
00035
00036 #define XBSZ 1024
00037
00038 char ncxb[XBSZ];
00039 char lbuf[XBSZ];
00040
00041 #define ArraySize(thang) (sizeof(thang)/sizeof(thang[0]))
00042 #define eSizeOf(thang) ((size_t)(sizeof(thang[0])))
00043
00044
00045
00046
00047
00048
00049
00050 #if SCHAR_MAX == X_SCHAR_MAX && SCHAR_MIN == X_SCHAR_MIN
00051 static schar schars[] = {
00052 SCHAR_MIN, SCHAR_MIN +1,
00053 -1, 0, 1,
00054 SCHAR_MAX - 1, SCHAR_MAX
00055 };
00056 #else
00057
00058 #error "Not 8 bit bytes ??"
00059 #endif
00060
00061 static short shorts[] = {
00062 #if SHORT_MAX <= X_SHORT_MAX
00063 SHORT_MIN, SHORT_MIN + 1,
00064 # if SCHAR_MAX < X_SHORT_MAX
00065 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00066 # endif
00067 -1, 0, 1,
00068 # if SCHAR_MAX < X_SHORT_MAX
00069 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00070 # endif
00071 SHORT_MAX - 1, SHORT_MAX
00072 #else
00073 X_SHORT_MIN, X_SHORT_MIN + 1,
00074 # if SCHAR_MAX < X_SHORT_MAX
00075 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00076 # endif
00077 -1, 0, 1,
00078 # if SCHAR_MAX < X_SHORT_MAX
00079 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00080 # endif
00081 X_SHORT_MAX - 1, X_SHORT_MAX
00082 #endif
00083 };
00084
00085 static int ints[] = {
00086 #if INT_MAX <= X_INT_MAX
00087 INT_MIN, INT_MIN +1,
00088 # if SHORT_MAX < X_INT_MAX
00089 SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
00090 # endif
00091 # if SCHAR_MAX < X_INT_MAX
00092 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00093 # endif
00094 -1, 0, 1,
00095 # if SCHAR_MAX < X_INT_MAX
00096 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00097 # endif
00098 # if SHORT_MAX < X_INT_MAX
00099 SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
00100 # endif
00101 INT_MAX - 1, INT_MAX
00102 #else
00103 X_INT_MIN, X_INT_MIN +1,
00104 # if SHORT_MAX < X_INT_MAX
00105 SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
00106 # endif
00107 # if SCHAR_MAX < X_INT_MAX
00108 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00109 # endif
00110 -1, 0, 1,
00111 # if SCHAR_MAX < X_INT_MAX
00112 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00113 # endif
00114 # if SHORT_MAX < X_INT_MAX
00115 SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
00116 # endif
00117 X_INT_MAX - 1, X_INT_MAX
00118 #endif
00119 };
00120
00121
00122
00123 static long longs[] = {
00124 #if LONG_MAX <= X_INT_MAX
00125 LONG_MIN, LONG_MIN +1,
00126 # if INT_MAX < X_INT_MAX
00127 INT_MIN -1, INT_MIN, INT_MIN + 1,
00128 # endif
00129 # if SHORT_MAX < X_INT_MAX
00130 SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
00131 # endif
00132 # if SCHAR_MAX < X_INT_MAX
00133 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00134 # endif
00135 -1, 0, 1,
00136 # if SCHAR_MAX < X_INT_MAX
00137 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00138 # endif
00139 # if SHORT_MAX < X_INT_MAX
00140 SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
00141 # endif
00142 # if INT_MAX < X_INT_MAX
00143 INT_MAX -1, INT_MAX, INT_MAX + 1,
00144 # endif
00145 LONG_MAX - 1, LONG_MAX
00146 #else
00147 X_INT_MIN, X_INT_MIN +1,
00148 # if SHORT_MAX < X_INT_MAX
00149 SHORT_MIN -1, SHORT_MIN, SHORT_MIN + 1,
00150 # endif
00151 # if SCHAR_MAX < X_INT_MAX
00152 SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,
00153 # endif
00154 -1, 0, 1,
00155 # if SCHAR_MAX < X_INT_MAX
00156 SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,
00157 # endif
00158 # if SHORT_MAX < X_INT_MAX
00159 SHORT_MAX - 1, SHORT_MAX, SHORT_MAX +1,
00160 # endif
00161 X_INT_MAX - 1, X_INT_MAX
00162 #endif
00163 };
00164
00165 static float floats[] = {
00166 -1.E9F,
00167 -16777215, -16777214,
00168 -999999,
00169 -32769, -32768, -32767,
00170 -129, -128, 127,
00171 -1, 0, 1,
00172 126, 127, 128,
00173 32766, 32767, 32768,
00174 999999,
00175 16777214, 16777215,
00176 1.E9F
00177 };
00178
00179 static double doubles[] = {
00180 -1.E20,
00181 -4503599627370495., -4503599627370494.,
00182 -999999999999999.,
00183 -1.E9,
00184 -16777215, -16777214,
00185 -999999,
00186 -32769, -32768, -32767,
00187 -129, -128, 127,
00188 -1, 0, 1,
00189 126, 127, 128,
00190 32766, 32767, 32768,
00191 999999,
00192 16777214, 16777215,
00193 1.E9,
00194 999999999999999.,
00195 4503599627370494., 4503599627370495.,
00196 1.E20
00197 };
00198
00199 static uchar uchars[] = {
00200 0, 1,
00201 UCHAR_MAX/2 -1, UCHAR_MAX/2, UCHAR_MAX/2 +1,
00202 UCHAR_MAX - 1, UCHAR_MAX
00203 };
00204
00205
00206
00207
00208
00209 static void
00210 t_putn_schar_schar(char *const buf)
00211 {
00212 char *xp = buf;
00213 const schar *tp = schars;
00214 size_t nelems = ArraySize(schars);
00215 int status = ncx_putn_schar_schar((void **)&xp, nelems, tp);
00216 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00217 {
00218 size_t ii;
00219 for(ii = 0; ii < nelems; ii++)
00220 {
00221 if((double) tp[ii] > X_SCHAR_MAX)
00222 {
00223 assert(status == NC_ERANGE);
00224 return;
00225 }
00226 if((double) tp[ii] < X_SCHAR_MIN)
00227 {
00228 assert(status == NC_ERANGE);
00229 return;
00230 }
00231 }
00232 assert(status == 0);
00233 }
00234 }
00235
00236 static void
00237 t_putn_schar_uchar(char *const buf)
00238 {
00239 char *xp = buf;
00240 const uchar *tp = uchars;
00241 size_t nelems = ArraySize(schars);
00242 int status = ncx_putn_schar_uchar((void **)&xp, nelems, tp);
00243 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00244 assert(status == 0);
00245 }
00246
00247 static void
00248 t_putn_schar_short(char *const buf)
00249 {
00250 char *xp = buf;
00251 const short *tp = shorts;
00252 size_t nelems = ArraySize(shorts);
00253 int status = ncx_putn_schar_short((void **)&xp, nelems, tp);
00254 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00255 {
00256 size_t ii;
00257 for(ii = 0; ii < nelems; ii++)
00258 {
00259 if((double) tp[ii] > X_SCHAR_MAX)
00260 {
00261 assert(status == NC_ERANGE);
00262 return;
00263 }
00264 if((double) tp[ii] < X_SCHAR_MIN)
00265 {
00266 assert(status == NC_ERANGE);
00267 return;
00268 }
00269 }
00270 assert(status == 0);
00271 }
00272 }
00273
00274 static void
00275 t_putn_schar_int(char *const buf)
00276 {
00277 char *xp = buf;
00278 const int *tp = ints;
00279 size_t nelems = ArraySize(ints);
00280 int status = ncx_putn_schar_int((void **)&xp, nelems, tp);
00281 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00282 {
00283 size_t ii;
00284 for(ii = 0; ii < nelems; ii++)
00285 {
00286 if((double) tp[ii] > X_SCHAR_MAX)
00287 {
00288 assert(status == NC_ERANGE);
00289 return;
00290 }
00291 if((double) tp[ii] < X_SCHAR_MIN)
00292 {
00293 assert(status == NC_ERANGE);
00294 return;
00295 }
00296 }
00297 assert(status == 0);
00298 }
00299 }
00300
00301 static void
00302 t_putn_schar_long(char *const buf)
00303 {
00304 char *xp = buf;
00305 const long *tp = longs;
00306 size_t nelems = ArraySize(longs);
00307 int status = ncx_putn_schar_long((void **)&xp, nelems, tp);
00308 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00309 {
00310 size_t ii;
00311 for(ii = 0; ii < nelems; ii++)
00312 {
00313 if((double) tp[ii] > X_SCHAR_MAX)
00314 {
00315 assert(status == NC_ERANGE);
00316 return;
00317 }
00318 if((double) tp[ii] < X_SCHAR_MIN)
00319 {
00320 assert(status == NC_ERANGE);
00321 return;
00322 }
00323 }
00324 assert(status == 0);
00325 }
00326 }
00327
00328 static void
00329 t_putn_schar_float(char *const buf)
00330 {
00331 char *xp = buf;
00332 const float *tp = floats;
00333 size_t nelems = ArraySize(floats);
00334 int status = ncx_putn_schar_float((void **)&xp, nelems, tp);
00335 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00336 {
00337 size_t ii;
00338 for(ii = 0; ii < nelems; ii++)
00339 {
00340 if((double) tp[ii] > X_SCHAR_MAX)
00341 {
00342 assert(status == NC_ERANGE);
00343 return;
00344 }
00345 if((double) tp[ii] < X_SCHAR_MIN)
00346 {
00347 assert(status == NC_ERANGE);
00348 return;
00349 }
00350 }
00351 assert(status == 0);
00352 }
00353 }
00354
00355 static void
00356 t_putn_schar_double(char *const buf)
00357 {
00358 char *xp = buf;
00359 const double *tp = doubles;
00360 size_t nelems = ArraySize(doubles);
00361 int status = ncx_putn_schar_double((void **)&xp, nelems, tp);
00362 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
00363 {
00364 size_t ii;
00365 for(ii = 0; ii < nelems; ii++)
00366 {
00367 if((double) tp[ii] > X_SCHAR_MAX)
00368 {
00369 assert(status == NC_ERANGE);
00370 return;
00371 }
00372 if((double) tp[ii] < X_SCHAR_MIN)
00373 {
00374 assert(status == NC_ERANGE);
00375 return;
00376 }
00377 }
00378 assert(status == 0);
00379 }
00380 }
00381
00382
00383 static void
00384 t_pad_putn_schar_schar(char *const buf)
00385 {
00386 char *xp = buf;
00387 const schar *tp = schars;
00388 size_t nelems = ArraySize(schars);
00389 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00390 int status = ncx_pad_putn_schar_schar((void **)&xp, nelems, tp);
00391 assert(xp >= end);
00392 assert((xp - end) < 4);
00393 assert((xp - buf)%4 == 0);
00394 {
00395 size_t ii;
00396 for(ii = 0; ii < nelems; ii++)
00397 {
00398 if((double) tp[ii] > X_SCHAR_MAX)
00399 {
00400 assert(status == NC_ERANGE);
00401 return;
00402 }
00403 if((double) tp[ii] < X_SCHAR_MIN)
00404 {
00405 assert(status == NC_ERANGE);
00406 return;
00407 }
00408 }
00409 assert(status == 0);
00410 }
00411 }
00412
00413 static void
00414 t_pad_putn_schar_uchar(char *const buf)
00415 {
00416 char *xp = buf;
00417 const uchar *tp = uchars;
00418 size_t nelems = ArraySize(uchars);
00419 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00420 int status = ncx_pad_putn_schar_uchar((void **)&xp, nelems, tp);
00421 assert(xp >= end);
00422 assert((xp - end) < 4);
00423 assert((xp - buf)%4 == 0);
00424 assert(status == 0);
00425 }
00426
00427 static void
00428 t_pad_putn_schar_short(char *const buf)
00429 {
00430 char *xp = buf;
00431 const short *tp = shorts;
00432 size_t nelems = ArraySize(shorts);
00433 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00434 int status = ncx_pad_putn_schar_short((void **)&xp, nelems, tp);
00435 assert(xp >= end);
00436 assert((xp - end) < 4);
00437 assert((xp - buf)%4 == 0);
00438 {
00439 size_t ii;
00440 for(ii = 0; ii < nelems; ii++)
00441 {
00442 if((double) tp[ii] > X_SCHAR_MAX)
00443 {
00444 assert(status == NC_ERANGE);
00445 return;
00446 }
00447 if((double) tp[ii] < X_SCHAR_MIN)
00448 {
00449 assert(status == NC_ERANGE);
00450 return;
00451 }
00452 }
00453 assert(status == 0);
00454 }
00455 }
00456
00457 static void
00458 t_pad_putn_schar_int(char *const buf)
00459 {
00460 char *xp = buf;
00461 const int *tp = ints;
00462 size_t nelems = ArraySize(ints);
00463 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00464 int status = ncx_pad_putn_schar_int((void **)&xp, nelems, tp);
00465 assert(xp >= end);
00466 assert((xp - end) < 4);
00467 assert((xp - buf)%4 == 0);
00468 {
00469 size_t ii;
00470 for(ii = 0; ii < nelems; ii++)
00471 {
00472 if((double) tp[ii] > X_SCHAR_MAX)
00473 {
00474 assert(status == NC_ERANGE);
00475 return;
00476 }
00477 if((double) tp[ii] < X_SCHAR_MIN)
00478 {
00479 assert(status == NC_ERANGE);
00480 return;
00481 }
00482 }
00483 assert(status == 0);
00484 }
00485 }
00486
00487 static void
00488 t_pad_putn_schar_long(char *const buf)
00489 {
00490 char *xp = buf;
00491 const long *tp = longs;
00492 size_t nelems = ArraySize(longs);
00493 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00494 int status = ncx_pad_putn_schar_long((void **)&xp, nelems, tp);
00495 assert(xp >= end);
00496 assert((xp - end) < 4);
00497 assert((xp - buf)%4 == 0);
00498 {
00499 size_t ii;
00500 for(ii = 0; ii < nelems; ii++)
00501 {
00502 if((double) tp[ii] > X_SCHAR_MAX)
00503 {
00504 assert(status == NC_ERANGE);
00505 return;
00506 }
00507 if((double) tp[ii] < X_SCHAR_MIN)
00508 {
00509 assert(status == NC_ERANGE);
00510 return;
00511 }
00512 }
00513 assert(status == 0);
00514 }
00515 }
00516
00517 static void
00518 t_pad_putn_schar_float(char *const buf)
00519 {
00520 char *xp = buf;
00521 const float *tp = floats;
00522 size_t nelems = ArraySize(floats);
00523 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00524 int status = ncx_pad_putn_schar_float((void **)&xp, nelems, tp);
00525 assert(xp >= end);
00526 assert((xp - end) < 4);
00527 assert((xp - buf)%4 == 0);
00528 {
00529 size_t ii;
00530 for(ii = 0; ii < nelems; ii++)
00531 {
00532 if((double) tp[ii] > X_SCHAR_MAX)
00533 {
00534 assert(status == NC_ERANGE);
00535 return;
00536 }
00537 if((double) tp[ii] < X_SCHAR_MIN)
00538 {
00539 assert(status == NC_ERANGE);
00540 return;
00541 }
00542 }
00543 assert(status == 0);
00544 }
00545 }
00546
00547 static void
00548 t_pad_putn_schar_double(char *const buf)
00549 {
00550 char *xp = buf;
00551 const double *tp = doubles;
00552 size_t nelems = ArraySize(doubles);
00553 const char *end = buf + nelems * X_SIZEOF_SCHAR;
00554 int status = ncx_pad_putn_schar_double((void **)&xp, nelems, tp);
00555 assert(xp >= end);
00556 assert((xp - end) < 4);
00557 assert((xp - buf)%4 == 0);
00558 {
00559 size_t ii;
00560 for(ii = 0; ii < nelems; ii++)
00561 {
00562 if((double) tp[ii] > X_SCHAR_MAX)
00563 {
00564 assert(status == NC_ERANGE);
00565 return;
00566 }
00567 if((double) tp[ii] < X_SCHAR_MIN)
00568 {
00569 assert(status == NC_ERANGE);
00570 return;
00571 }
00572 }
00573 assert(status == 0);
00574 }
00575 }
00576
00577
00578 static void
00579 t_putn_short_schar(char *const buf)
00580 {
00581 char *xp = buf;
00582 const schar *tp = schars;
00583 size_t nelems = ArraySize(schars);
00584 int status = ncx_putn_short_schar((void **)&xp, nelems, tp);
00585 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00586 {
00587 size_t ii;
00588 for(ii = 0; ii < nelems; ii++)
00589 {
00590 if((double) tp[ii] > X_SHORT_MAX)
00591 {
00592 assert(status == NC_ERANGE);
00593 return;
00594 }
00595 if((double) tp[ii] < X_SHORT_MIN)
00596 {
00597 assert(status == NC_ERANGE);
00598 return;
00599 }
00600 }
00601 assert(status == 0);
00602 }
00603 }
00604
00605 static void
00606 t_putn_short_uchar(char *const buf)
00607 {
00608 char *xp = buf;
00609 const uchar *tp = uchars;
00610 size_t nelems = ArraySize(uchars);
00611 int status = ncx_putn_short_uchar((void **)&xp, nelems, tp);
00612 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00613 {
00614 size_t ii;
00615 for(ii = 0; ii < nelems; ii++)
00616 {
00617 if((double) tp[ii] > X_SHORT_MAX)
00618 {
00619 assert(status == NC_ERANGE);
00620 return;
00621 }
00622 }
00623 assert(status == 0);
00624 }
00625 }
00626
00627 static void
00628 t_putn_short_short(char *const buf)
00629 {
00630 char *xp = buf;
00631 const short *tp = shorts;
00632 size_t nelems = ArraySize(shorts);
00633 int status = ncx_putn_short_short((void **)&xp, nelems, tp);
00634 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00635 {
00636 size_t ii;
00637 for(ii = 0; ii < nelems; ii++)
00638 {
00639 if((double) tp[ii] > X_SHORT_MAX)
00640 {
00641 assert(status == NC_ERANGE);
00642 return;
00643 }
00644 if((double) tp[ii] < X_SHORT_MIN)
00645 {
00646 assert(status == NC_ERANGE);
00647 return;
00648 }
00649 }
00650 assert(status == 0);
00651 }
00652 }
00653
00654 static void
00655 t_putn_short_int(char *const buf)
00656 {
00657 char *xp = buf;
00658 const int *tp = ints;
00659 size_t nelems = ArraySize(ints);
00660 int status = ncx_putn_short_int((void **)&xp, nelems, tp);
00661 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00662 {
00663 size_t ii;
00664 for(ii = 0; ii < nelems; ii++)
00665 {
00666 if((double) tp[ii] > X_SHORT_MAX)
00667 {
00668 assert(status == NC_ERANGE);
00669 return;
00670 }
00671 if((double) tp[ii] < X_SHORT_MIN)
00672 {
00673 assert(status == NC_ERANGE);
00674 return;
00675 }
00676 }
00677 assert(status == 0);
00678 }
00679 }
00680
00681 static void
00682 t_putn_short_long(char *const buf)
00683 {
00684 char *xp = buf;
00685 const long *tp = longs;
00686 size_t nelems = ArraySize(longs);
00687 int status = ncx_putn_short_long((void **)&xp, nelems, tp);
00688 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00689 {
00690 size_t ii;
00691 for(ii = 0; ii < nelems; ii++)
00692 {
00693 if((double) tp[ii] > X_SHORT_MAX)
00694 {
00695 assert(status == NC_ERANGE);
00696 return;
00697 }
00698 if((double) tp[ii] < X_SHORT_MIN)
00699 {
00700 assert(status == NC_ERANGE);
00701 return;
00702 }
00703 }
00704 assert(status == 0);
00705 }
00706 }
00707
00708 static void
00709 t_putn_short_float(char *const buf)
00710 {
00711 char *xp = buf;
00712 const float *tp = floats;
00713 size_t nelems = ArraySize(floats);
00714 int status = ncx_putn_short_float((void **)&xp, nelems, tp);
00715 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00716 {
00717 size_t ii;
00718 for(ii = 0; ii < nelems; ii++)
00719 {
00720 if((double) tp[ii] > X_SHORT_MAX)
00721 {
00722 assert(status == NC_ERANGE);
00723 return;
00724 }
00725 if((double) tp[ii] < X_SHORT_MIN)
00726 {
00727 assert(status == NC_ERANGE);
00728 return;
00729 }
00730 }
00731 assert(status == 0);
00732 }
00733 }
00734
00735 static void
00736 t_putn_short_double(char *const buf)
00737 {
00738 char *xp = buf;
00739 const double *tp = doubles;
00740 size_t nelems = ArraySize(doubles);
00741 int status = ncx_putn_short_double((void **)&xp, nelems, tp);
00742 assert(xp == buf + nelems * X_SIZEOF_SHORT);
00743 {
00744 size_t ii;
00745 for(ii = 0; ii < nelems; ii++)
00746 {
00747 if((double) tp[ii] > X_SHORT_MAX)
00748 {
00749 assert(status == NC_ERANGE);
00750 return;
00751 }
00752 if((double) tp[ii] < X_SHORT_MIN)
00753 {
00754 assert(status == NC_ERANGE);
00755 return;
00756 }
00757 }
00758 assert(status == 0);
00759 }
00760 }
00761
00762
00763 static void
00764 t_pad_putn_short_schar(char *const buf)
00765 {
00766 char *xp = buf;
00767 const schar *tp = schars;
00768 size_t nelems = ArraySize(schars);
00769 const char *end = buf + nelems * X_SIZEOF_SHORT;
00770 int status = ncx_pad_putn_short_schar((void **)&xp, nelems, tp);
00771 assert(xp >= end);
00772 assert((xp - end) < 4);
00773 assert((xp - buf)%4 == 0);
00774 {
00775 size_t ii;
00776 for(ii = 0; ii < nelems; ii++)
00777 {
00778 if((double) tp[ii] > X_SHORT_MAX)
00779 {
00780 assert(status == NC_ERANGE);
00781 return;
00782 }
00783 if((double) tp[ii] < X_SHORT_MIN)
00784 {
00785 assert(status == NC_ERANGE);
00786 return;
00787 }
00788 }
00789 assert(status == 0);
00790 }
00791 }
00792
00793 static void
00794 t_pad_putn_short_uchar(char *const buf)
00795 {
00796 char *xp = buf;
00797 const uchar *tp = uchars;
00798 size_t nelems = ArraySize(uchars);
00799 const char *end = buf + nelems * X_SIZEOF_SHORT;
00800 int status = ncx_pad_putn_short_uchar((void **)&xp, nelems, tp);
00801 assert(xp >= end);
00802 assert((xp - end) < 4);
00803 assert((xp - buf)%4 == 0);
00804 {
00805 size_t ii;
00806 for(ii = 0; ii < nelems; ii++)
00807 {
00808 if(tp[ii] > X_SHORT_MAX)
00809 {
00810 assert(status == NC_ERANGE);
00811 return;
00812 }
00813 }
00814 assert(status == 0);
00815 }
00816 }
00817
00818 static void
00819 t_pad_putn_short_short(char *const buf)
00820 {
00821 char *xp = buf;
00822 const short *tp = shorts;
00823 size_t nelems = ArraySize(shorts);
00824 const char *end = buf + nelems * X_SIZEOF_SHORT;
00825 int status = ncx_pad_putn_short_short((void **)&xp, nelems, tp);
00826 assert(xp >= end);
00827 assert((xp - end) < 4);
00828 assert((xp - buf)%4 == 0);
00829 {
00830 size_t ii;
00831 for(ii = 0; ii < nelems; ii++)
00832 {
00833 if((double) tp[ii] > X_SHORT_MAX)
00834 {
00835 assert(status == NC_ERANGE);
00836 return;
00837 }
00838 if((double) tp[ii] < X_SHORT_MIN)
00839 {
00840 assert(status == NC_ERANGE);
00841 return;
00842 }
00843 }
00844 assert(status == 0);
00845 }
00846 }
00847
00848 static void
00849 t_pad_putn_short_int(char *const buf)
00850 {
00851 char *xp = buf;
00852 const int *tp = ints;
00853 size_t nelems = ArraySize(ints);
00854 const char *end = buf + nelems * X_SIZEOF_SHORT;
00855 int status = ncx_pad_putn_short_int((void **)&xp, nelems, tp);
00856 assert(xp >= end);
00857 assert((xp - end) < 4);
00858 assert((xp - buf)%4 == 0);
00859 {
00860 size_t ii;
00861 for(ii = 0; ii < nelems; ii++)
00862 {
00863 if((double) tp[ii] > X_SHORT_MAX)
00864 {
00865 assert(status == NC_ERANGE);
00866 return;
00867 }
00868 if((double) tp[ii] < X_SHORT_MIN)
00869 {
00870 assert(status == NC_ERANGE);
00871 return;
00872 }
00873 }
00874 assert(status == 0);
00875 }
00876 }
00877
00878 static void
00879 t_pad_putn_short_long(char *const buf)
00880 {
00881 char *xp = buf;
00882 const long *tp = longs;
00883 size_t nelems = ArraySize(longs);
00884 const char *end = buf + nelems * X_SIZEOF_SHORT;
00885 int status = ncx_pad_putn_short_long((void **)&xp, nelems, tp);
00886 assert(xp >= end);
00887 assert((xp - end) < 4);
00888 assert((xp - buf)%4 == 0);
00889 {
00890 size_t ii;
00891 for(ii = 0; ii < nelems; ii++)
00892 {
00893 if((double) tp[ii] > X_SHORT_MAX)
00894 {
00895 assert(status == NC_ERANGE);
00896 return;
00897 }
00898 if((double) tp[ii] < X_SHORT_MIN)
00899 {
00900 assert(status == NC_ERANGE);
00901 return;
00902 }
00903 }
00904 assert(status == 0);
00905 }
00906 }
00907
00908 static void
00909 t_pad_putn_short_float(char *const buf)
00910 {
00911 char *xp = buf;
00912 const float *tp = floats;
00913 size_t nelems = ArraySize(floats);
00914 const char *end = buf + nelems * X_SIZEOF_SHORT;
00915 int status = ncx_pad_putn_short_float((void **)&xp, nelems, tp);
00916 assert(xp >= end);
00917 assert((xp - end) < 4);
00918 assert((xp - buf)%4 == 0);
00919 {
00920 size_t ii;
00921 for(ii = 0; ii < nelems; ii++)
00922 {
00923 if((double) tp[ii] > X_SHORT_MAX)
00924 {
00925 assert(status == NC_ERANGE);
00926 return;
00927 }
00928 if((double) tp[ii] < X_SHORT_MIN)
00929 {
00930 assert(status == NC_ERANGE);
00931 return;
00932 }
00933 }
00934 assert(status == 0);
00935 }
00936 }
00937
00938 static void
00939 t_pad_putn_short_double(char *const buf)
00940 {
00941 char *xp = buf;
00942 const double *tp = doubles;
00943 size_t nelems = ArraySize(doubles);
00944 const char *end = buf + nelems * X_SIZEOF_SHORT;
00945 int status = ncx_pad_putn_short_double((void **)&xp, nelems, tp);
00946 assert(xp >= end);
00947 assert((xp - end) < 4);
00948 assert((xp - buf)%4 == 0);
00949 {
00950 size_t ii;
00951 for(ii = 0; ii < nelems; ii++)
00952 {
00953 if((double) tp[ii] > X_SHORT_MAX)
00954 {
00955 assert(status == NC_ERANGE);
00956 return;
00957 }
00958 if((double) tp[ii] < X_SHORT_MIN)
00959 {
00960 assert(status == NC_ERANGE);
00961 return;
00962 }
00963 }
00964 assert(status == 0);
00965 }
00966 }
00967
00968
00969 static void
00970 t_putn_int_schar(char *const buf)
00971 {
00972 char *xp = buf;
00973 const schar *tp = schars;
00974 size_t nelems = ArraySize(schars);
00975 int status = ncx_putn_int_schar((void **)&xp, nelems, tp);
00976 assert(xp == buf + nelems * X_SIZEOF_INT);
00977 {
00978 size_t ii;
00979 for(ii = 0; ii < nelems; ii++)
00980 {
00981 if((double) tp[ii] > X_INT_MAX)
00982 {
00983 assert(status == NC_ERANGE);
00984 return;
00985 }
00986 if((double) tp[ii] < X_INT_MIN)
00987 {
00988 assert(status == NC_ERANGE);
00989 return;
00990 }
00991 }
00992 assert(status == 0);
00993 }
00994 }
00995
00996 static void
00997 t_putn_int_uchar(char *const buf)
00998 {
00999 char *xp = buf;
01000 const uchar *tp = uchars;
01001 size_t nelems = ArraySize(uchars);
01002 int status = ncx_putn_int_uchar((void **)&xp, nelems, tp);
01003 assert(xp == buf + nelems * X_SIZEOF_INT);
01004 {
01005 size_t ii;
01006 for(ii = 0; ii < nelems; ii++)
01007 {
01008 if((double) tp[ii] > X_INT_MAX)
01009 {
01010 assert(status == NC_ERANGE);
01011 return;
01012 }
01013 }
01014 assert(status == 0);
01015 }
01016 }
01017
01018 static void
01019 t_putn_int_short(char *const buf)
01020 {
01021 char *xp = buf;
01022 const short *tp = shorts;
01023 size_t nelems = ArraySize(shorts);
01024 int status = ncx_putn_int_short((void **)&xp, nelems, tp);
01025 assert(xp == buf + nelems * X_SIZEOF_INT);
01026 {
01027 size_t ii;
01028 for(ii = 0; ii < nelems; ii++)
01029 {
01030 if((double) tp[ii] > X_INT_MAX)
01031 {
01032 assert(status == NC_ERANGE);
01033 return;
01034 }
01035 if((double) tp[ii] < X_INT_MIN)
01036 {
01037 assert(status == NC_ERANGE);
01038 return;
01039 }
01040 }
01041 assert(status == 0);
01042 }
01043 }
01044
01045 static void
01046 t_putn_int_int(char *const buf)
01047 {
01048 char *xp = buf;
01049 const int *tp = ints;
01050 size_t nelems = ArraySize(ints);
01051 int status = ncx_putn_int_int((void **)&xp, nelems, tp);
01052 assert(xp == buf + nelems * X_SIZEOF_INT);
01053 {
01054 size_t ii;
01055 for(ii = 0; ii < nelems; ii++)
01056 {
01057 if((double) tp[ii] > X_INT_MAX)
01058 {
01059 assert(status == NC_ERANGE);
01060 return;
01061 }
01062 if((double) tp[ii] < X_INT_MIN)
01063 {
01064 assert(status == NC_ERANGE);
01065 return;
01066 }
01067 }
01068 assert(status == 0);
01069 }
01070 }
01071
01072 static void
01073 t_putn_int_long(char *const buf)
01074 {
01075 char *xp = buf;
01076 const long *tp = longs;
01077 size_t nelems = ArraySize(longs);
01078 int status = ncx_putn_int_long((void **)&xp, nelems, tp);
01079 assert(xp == buf + nelems * X_SIZEOF_INT);
01080 {
01081 size_t ii;
01082 for(ii = 0; ii < nelems; ii++)
01083 {
01084 if((double) tp[ii] > X_INT_MAX)
01085 {
01086 assert(status == NC_ERANGE);
01087 return;
01088 }
01089 if((double) tp[ii] < X_INT_MIN)
01090 {
01091 assert(status == NC_ERANGE);
01092 return;
01093 }
01094 }
01095 assert(status == 0);
01096 }
01097 }
01098
01099 static void
01100 t_putn_int_float(char *const buf)
01101 {
01102 char *xp = buf;
01103 const float *tp = floats;
01104 size_t nelems = ArraySize(floats);
01105 int status = ncx_putn_int_float((void **)&xp, nelems, tp);
01106 assert(xp == buf + nelems * X_SIZEOF_INT);
01107 {
01108 size_t ii;
01109 for(ii = 0; ii < nelems; ii++)
01110 {
01111 if((double) tp[ii] > X_INT_MAX)
01112 {
01113 assert(status == NC_ERANGE);
01114 return;
01115 }
01116 if((double) tp[ii] < X_INT_MIN)
01117 {
01118 assert(status == NC_ERANGE);
01119 return;
01120 }
01121 }
01122 assert(status == 0);
01123 }
01124 }
01125
01126 static void
01127 t_putn_int_double(char *const buf)
01128 {
01129 char *xp = buf;
01130 const double *tp = doubles;
01131 size_t nelems = ArraySize(doubles);
01132 int status = ncx_putn_int_double((void **)&xp, nelems, tp);
01133 assert(xp == buf + nelems * X_SIZEOF_INT);
01134 {
01135 size_t ii;
01136 for(ii = 0; ii < nelems; ii++)
01137 {
01138 if((double) tp[ii] > X_INT_MAX)
01139 {
01140 assert(status == NC_ERANGE);
01141 return;
01142 }
01143 if((double) tp[ii] < X_INT_MIN)
01144 {
01145 assert(status == NC_ERANGE);
01146 return;
01147 }
01148 }
01149 assert(status == 0);
01150 }
01151 }
01152
01153
01154 static void
01155 t_putn_float_schar(char *const buf)
01156 {
01157 char *xp = buf;
01158 const schar *tp = schars;
01159 size_t nelems = ArraySize(schars);
01160 int status = ncx_putn_float_schar((void **)&xp, nelems, tp);
01161 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01162 {
01163 size_t ii;
01164 for(ii = 0; ii < nelems; ii++)
01165 {
01166 if((double) tp[ii] > X_FLOAT_MAX)
01167 {
01168 assert(status == NC_ERANGE);
01169 return;
01170 }
01171 if((double) tp[ii] < X_FLOAT_MIN)
01172 {
01173 assert(status == NC_ERANGE);
01174 return;
01175 }
01176 }
01177 assert(status == 0);
01178 }
01179 }
01180
01181 static void
01182 t_putn_float_uchar(char *const buf)
01183 {
01184 char *xp = buf;
01185 const uchar *tp = uchars;
01186 size_t nelems = ArraySize(uchars);
01187 int status = ncx_putn_float_uchar((void **)&xp, nelems, tp);
01188 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01189 {
01190 size_t ii;
01191 for(ii = 0; ii < nelems; ii++)
01192 {
01193 if((double) tp[ii] > X_FLOAT_MAX)
01194 {
01195 assert(status == NC_ERANGE);
01196 return;
01197 }
01198 }
01199 assert(status == 0);
01200 }
01201 }
01202
01203 static void
01204 t_putn_float_short(char *const buf)
01205 {
01206 char *xp = buf;
01207 const short *tp = shorts;
01208 size_t nelems = ArraySize(shorts);
01209 int status = ncx_putn_float_short((void **)&xp, nelems, tp);
01210 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01211 {
01212 size_t ii;
01213 for(ii = 0; ii < nelems; ii++)
01214 {
01215 if((double) tp[ii] > X_FLOAT_MAX)
01216 {
01217 assert(status == NC_ERANGE);
01218 return;
01219 }
01220 if((double) tp[ii] < X_FLOAT_MIN)
01221 {
01222 assert(status == NC_ERANGE);
01223 return;
01224 }
01225 }
01226 assert(status == 0);
01227 }
01228 }
01229
01230 static void
01231 t_putn_float_int(char *const buf)
01232 {
01233 char *xp = buf;
01234 const int *tp = ints;
01235 size_t nelems = ArraySize(ints);
01236 int status = ncx_putn_float_int((void **)&xp, nelems, tp);
01237 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01238 {
01239 size_t ii;
01240 for(ii = 0; ii < nelems; ii++)
01241 {
01242 if((double) tp[ii] > X_FLOAT_MAX)
01243 {
01244 assert(status == NC_ERANGE);
01245 return;
01246 }
01247 if((double) tp[ii] < X_FLOAT_MIN)
01248 {
01249 assert(status == NC_ERANGE);
01250 return;
01251 }
01252 }
01253 assert(status == 0);
01254 }
01255 }
01256
01257 static void
01258 t_putn_float_long(char *const buf)
01259 {
01260 char *xp = buf;
01261 const long *tp = longs;
01262 size_t nelems = ArraySize(longs);
01263 int status = ncx_putn_float_long((void **)&xp, nelems, tp);
01264 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01265 {
01266 size_t ii;
01267 for(ii = 0; ii < nelems; ii++)
01268 {
01269 if((double) tp[ii] > X_FLOAT_MAX)
01270 {
01271 assert(status == NC_ERANGE);
01272 return;
01273 }
01274 if((double) tp[ii] < X_FLOAT_MIN)
01275 {
01276 assert(status == NC_ERANGE);
01277 return;
01278 }
01279 }
01280 assert(status == 0);
01281 }
01282 }
01283
01284 static void
01285 t_putn_float_float(char *const buf)
01286 {
01287 char *xp = buf;
01288 const float *tp = floats;
01289 size_t nelems = ArraySize(floats);
01290 int status = ncx_putn_float_float((void **)&xp, nelems, tp);
01291 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01292 {
01293 size_t ii;
01294 for(ii = 0; ii < nelems; ii++)
01295 {
01296 if((double) tp[ii] > X_FLOAT_MAX)
01297 {
01298 assert(status == NC_ERANGE);
01299 return;
01300 }
01301 if((double) tp[ii] < X_FLOAT_MIN)
01302 {
01303 assert(status == NC_ERANGE);
01304 return;
01305 }
01306 }
01307 assert(status == 0);
01308 }
01309 }
01310
01311 static void
01312 t_putn_float_double(char *const buf)
01313 {
01314 char *xp = buf;
01315 const double *tp = doubles;
01316 size_t nelems = ArraySize(doubles);
01317 int status = ncx_putn_float_double((void **)&xp, nelems, tp);
01318 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
01319 {
01320 size_t ii;
01321 for(ii = 0; ii < nelems; ii++)
01322 {
01323 if((double) tp[ii] > X_FLOAT_MAX)
01324 {
01325 assert(status == NC_ERANGE);
01326 return;
01327 }
01328 if((double) tp[ii] < X_FLOAT_MIN)
01329 {
01330 assert(status == NC_ERANGE);
01331 return;
01332 }
01333 }
01334 assert(status == 0);
01335 }
01336 }
01337
01338
01339 static void
01340 t_putn_double_schar(char *const buf)
01341 {
01342 char *xp = buf;
01343 const schar *tp = schars;
01344 size_t nelems = ArraySize(schars);
01345 int status = ncx_putn_double_schar((void **)&xp, nelems, tp);
01346 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01347 {
01348 size_t ii;
01349 for(ii = 0; ii < nelems; ii++)
01350 {
01351 if((double) tp[ii] > X_DOUBLE_MAX)
01352 {
01353 assert(status == NC_ERANGE);
01354 return;
01355 }
01356 if((double) tp[ii] < X_DOUBLE_MIN)
01357 {
01358 assert(status == NC_ERANGE);
01359 return;
01360 }
01361 }
01362 assert(status == 0);
01363 }
01364 }
01365
01366 static void
01367 t_putn_double_uchar(char *const buf)
01368 {
01369 char *xp = buf;
01370 const uchar *tp = uchars;
01371 size_t nelems = ArraySize(uchars);
01372 int status = ncx_putn_double_uchar((void **)&xp, nelems, tp);
01373 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01374 {
01375 size_t ii;
01376 for(ii = 0; ii < nelems; ii++)
01377 {
01378 if((double) tp[ii] > X_DOUBLE_MAX)
01379 {
01380 assert(status == NC_ERANGE);
01381 return;
01382 }
01383 }
01384 assert(status == 0);
01385 }
01386 }
01387
01388 static void
01389 t_putn_double_short(char *const buf)
01390 {
01391 char *xp = buf;
01392 const short *tp = shorts;
01393 size_t nelems = ArraySize(shorts);
01394 int status = ncx_putn_double_short((void **)&xp, nelems, tp);
01395 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01396 {
01397 size_t ii;
01398 for(ii = 0; ii < nelems; ii++)
01399 {
01400 if((double) tp[ii] > X_DOUBLE_MAX)
01401 {
01402 assert(status == NC_ERANGE);
01403 return;
01404 }
01405 if((double) tp[ii] < X_DOUBLE_MIN)
01406 {
01407 assert(status == NC_ERANGE);
01408 return;
01409 }
01410 }
01411 assert(status == 0);
01412 }
01413 }
01414
01415 static void
01416 t_putn_double_int(char *const buf)
01417 {
01418 char *xp = buf;
01419 const int *tp = ints;
01420 size_t nelems = ArraySize(ints);
01421 int status = ncx_putn_double_int((void **)&xp, nelems, tp);
01422 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01423 {
01424 size_t ii;
01425 for(ii = 0; ii < nelems; ii++)
01426 {
01427 if((double) tp[ii] > X_DOUBLE_MAX)
01428 {
01429 assert(status == NC_ERANGE);
01430 return;
01431 }
01432 if((double) tp[ii] < X_DOUBLE_MIN)
01433 {
01434 assert(status == NC_ERANGE);
01435 return;
01436 }
01437 }
01438 assert(status == 0);
01439 }
01440 }
01441
01442 static void
01443 t_putn_double_long(char *const buf)
01444 {
01445 char *xp = buf;
01446 const long *tp = longs;
01447 size_t nelems = ArraySize(longs);
01448 int status = ncx_putn_double_long((void **)&xp, nelems, tp);
01449 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01450 {
01451 size_t ii;
01452 for(ii = 0; ii < nelems; ii++)
01453 {
01454 if((double) tp[ii] > X_DOUBLE_MAX)
01455 {
01456 assert(status == NC_ERANGE);
01457 return;
01458 }
01459 if((double) tp[ii] < X_DOUBLE_MIN)
01460 {
01461 assert(status == NC_ERANGE);
01462 return;
01463 }
01464 }
01465 assert(status == 0);
01466 }
01467 }
01468
01469 static void
01470 t_putn_double_float(char *const buf)
01471 {
01472 char *xp = buf;
01473 const float *tp = floats;
01474 size_t nelems = ArraySize(floats);
01475 int status = ncx_putn_double_float((void **)&xp, nelems, tp);
01476 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01477 {
01478 size_t ii;
01479 for(ii = 0; ii < nelems; ii++)
01480 {
01481 if((double) tp[ii] > X_DOUBLE_MAX)
01482 {
01483 assert(status == NC_ERANGE);
01484 return;
01485 }
01486 if((double) tp[ii] < X_DOUBLE_MIN)
01487 {
01488 assert(status == NC_ERANGE);
01489 return;
01490 }
01491 }
01492 assert(status == 0);
01493 }
01494 }
01495
01496 static void
01497 t_putn_double_double(char *const buf)
01498 {
01499 char *xp = buf;
01500 const double *tp = doubles;
01501 size_t nelems = ArraySize(doubles);
01502 int status = ncx_putn_double_double((void **)&xp, nelems, tp);
01503 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
01504 {
01505 size_t ii;
01506 for(ii = 0; ii < nelems; ii++)
01507 {
01508 if((double) tp[ii] > X_DOUBLE_MAX)
01509 {
01510 assert(status == NC_ERANGE);
01511 return;
01512 }
01513 if((double) tp[ii] < X_DOUBLE_MIN)
01514 {
01515 assert(status == NC_ERANGE);
01516 return;
01517 }
01518 }
01519 assert(status == 0);
01520 }
01521 }
01522
01523
01524
01525
01526 static void
01527 t_getn_schar_schar(const char *const buf)
01528 {
01529 const char *xp = buf;
01530 const schar *tp = schars;
01531 schar *lp = (schar *)lbuf;
01532 size_t nelems = ArraySize(schars);
01533 int status = ncx_getn_schar_schar((const void **)&xp, nelems, lp);
01534 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01535 assert(status == 0);
01536
01537 {
01538 size_t ii;
01539 for(ii = 0; ii < nelems; ii++)
01540 {
01541 if(((double)tp[ii] <= X_SCHAR_MAX)
01542 && ((double)tp[ii] >= X_SCHAR_MIN))
01543 {
01544 assert(tp[ii] == lp[ii]);
01545 }
01546 }
01547 }
01548 }
01549
01550 static void
01551 t_getn_schar_uchar(const char *const buf)
01552 {
01553 const char *xp = buf;
01554 const uchar *tp = uchars;
01555 uchar *lp = (uchar *)lbuf;
01556 size_t nelems = ArraySize(schars);
01557 int status = ncx_getn_schar_uchar((const void **)&xp, nelems, lp);
01558 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01559 assert(status == 0);
01560
01561 {
01562 size_t ii;
01563 for(ii = 0; ii < nelems; ii++)
01564 {
01565 assert(tp[ii] == lp[ii]);
01566 }
01567 }
01568 }
01569
01570 static void
01571 t_getn_schar_short(const char *const buf)
01572 {
01573 const char *xp = buf;
01574 const short *tp = shorts;
01575 short *lp = (short *)lbuf;
01576 size_t nelems = ArraySize(shorts);
01577 int status = ncx_getn_schar_short((const void **)&xp, nelems, lp);
01578 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01579 assert(status == 0);
01580
01581 {
01582 size_t ii;
01583 for(ii = 0; ii < nelems; ii++)
01584 {
01585 if(((double)tp[ii] <= X_SCHAR_MAX)
01586 && ((double)tp[ii] >= X_SCHAR_MIN))
01587 {
01588 assert(tp[ii] == lp[ii]);
01589 }
01590 }
01591 }
01592 }
01593
01594 static void
01595 t_getn_schar_int(const char *const buf)
01596 {
01597 const char *xp = buf;
01598 const int *tp = ints;
01599 int *lp = (int *)lbuf;
01600 size_t nelems = ArraySize(ints);
01601 int status = ncx_getn_schar_int((const void **)&xp, nelems, lp);
01602 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01603 assert(status == 0);
01604
01605 {
01606 size_t ii;
01607 for(ii = 0; ii < nelems; ii++)
01608 {
01609 if(((double)tp[ii] <= X_SCHAR_MAX)
01610 && ((double)tp[ii] >= X_SCHAR_MIN))
01611 {
01612 assert(tp[ii] == lp[ii]);
01613 }
01614 }
01615 }
01616 }
01617
01618 static void
01619 t_getn_schar_long(const char *const buf)
01620 {
01621 const char *xp = buf;
01622 const long *tp = longs;
01623 long *lp = (long *)lbuf;
01624 size_t nelems = ArraySize(longs);
01625 int status = ncx_getn_schar_long((const void **)&xp, nelems, lp);
01626 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01627 assert(status == 0);
01628
01629 {
01630 size_t ii;
01631 for(ii = 0; ii < nelems; ii++)
01632 {
01633 if(((double)tp[ii] <= X_SCHAR_MAX)
01634 && ((double)tp[ii] >= X_SCHAR_MIN))
01635 {
01636 assert(tp[ii] == lp[ii]);
01637 }
01638 }
01639 }
01640 }
01641
01642 static void
01643 t_getn_schar_float(const char *const buf)
01644 {
01645 const char *xp = buf;
01646 const float *tp = floats;
01647 float *lp = (float *)lbuf;
01648 size_t nelems = ArraySize(floats);
01649 int status = ncx_getn_schar_float((const void **)&xp, nelems, lp);
01650 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01651 assert(status == 0);
01652
01653 {
01654 size_t ii;
01655 for(ii = 0; ii < nelems; ii++)
01656 {
01657 if(((double)tp[ii] <= X_SCHAR_MAX)
01658 && ((double)tp[ii] >= X_SCHAR_MIN))
01659 {
01660 assert(tp[ii] == lp[ii]);
01661 }
01662 }
01663 }
01664 }
01665
01666 static void
01667 t_getn_schar_double(const char *const buf)
01668 {
01669 const char *xp = buf;
01670 const double *tp = doubles;
01671 double *lp = (double *)lbuf;
01672 size_t nelems = ArraySize(doubles);
01673 int status = ncx_getn_schar_double((const void **)&xp, nelems, lp);
01674 assert(xp == buf + nelems * X_SIZEOF_SCHAR);
01675 assert(status == 0);
01676
01677 {
01678 size_t ii;
01679 for(ii = 0; ii < nelems; ii++)
01680 {
01681 if(((double)tp[ii] <= X_SCHAR_MAX)
01682 && ((double)tp[ii] >= X_SCHAR_MIN))
01683 {
01684 assert(tp[ii] == lp[ii]);
01685 }
01686 }
01687 }
01688 }
01689
01690
01691 static void
01692 t_pad_getn_schar_schar(const char *const buf)
01693 {
01694 const char *xp = buf;
01695 const schar *tp = schars;
01696 schar *lp = (schar *)lbuf;
01697 size_t nelems = ArraySize(schars);
01698 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01699 int status = ncx_pad_getn_schar_schar((const void **)&xp, nelems, lp);
01700 assert(xp >= end);
01701 assert((xp - end) < 4);
01702 assert((xp - buf)%4 == 0);
01703 assert(status == 0);
01704
01705 {
01706 size_t ii;
01707 for(ii = 0; ii < nelems; ii++)
01708 {
01709 if(((double) tp[ii] <= X_SCHAR_MAX)
01710 && ((double) tp[ii] >= X_SCHAR_MIN))
01711 {
01712 assert(tp[ii] == lp[ii]);
01713 }
01714 }
01715 }
01716 }
01717
01718 static void
01719 t_pad_getn_schar_uchar(const char *const buf)
01720 {
01721 const char *xp = buf;
01722 const uchar *tp = uchars;
01723 uchar *lp = (uchar *)lbuf;
01724 size_t nelems = ArraySize(schars);
01725 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01726 int status = ncx_pad_getn_schar_uchar((const void **)&xp, nelems, lp);
01727 assert(xp >= end);
01728 assert((xp - end) < 4);
01729 assert((xp - buf)%4 == 0);
01730 assert(status == 0);
01731
01732 {
01733 size_t ii;
01734 for(ii = 0; ii < nelems; ii++)
01735 {
01736 assert(tp[ii] == lp[ii]);
01737 }
01738 }
01739 }
01740
01741 static void
01742 t_pad_getn_schar_short(const char *const buf)
01743 {
01744 const char *xp = buf;
01745 const short *tp = shorts;
01746 short *lp = (short *)lbuf;
01747 size_t nelems = ArraySize(shorts);
01748 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01749 int status = ncx_pad_getn_schar_short((const void **)&xp, nelems, lp);
01750 assert(xp >= end);
01751 assert((xp - end) < 4);
01752 assert((xp - buf)%4 == 0);
01753 assert(status == 0);
01754
01755 {
01756 size_t ii;
01757 for(ii = 0; ii < nelems; ii++)
01758 {
01759 if(((double) tp[ii] <= X_SCHAR_MAX)
01760 && ((double) tp[ii] >= X_SCHAR_MIN))
01761 {
01762 assert(tp[ii] == lp[ii]);
01763 }
01764 }
01765 }
01766 }
01767
01768 static void
01769 t_pad_getn_schar_int(const char *const buf)
01770 {
01771 const char *xp = buf;
01772 const int *tp = ints;
01773 int *lp = (int *)lbuf;
01774 size_t nelems = ArraySize(ints);
01775 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01776 int status = ncx_pad_getn_schar_int((const void **)&xp, nelems, lp);
01777 assert(xp >= end);
01778 assert((xp - end) < 4);
01779 assert((xp - buf)%4 == 0);
01780 assert(status == 0);
01781
01782 {
01783 size_t ii;
01784 for(ii = 0; ii < nelems; ii++)
01785 {
01786 if(((double) tp[ii] <= X_SCHAR_MAX)
01787 && ((double) tp[ii] >= X_SCHAR_MIN))
01788 {
01789 assert(tp[ii] == lp[ii]);
01790 }
01791 }
01792 }
01793 }
01794
01795 static void
01796 t_pad_getn_schar_long(const char *const buf)
01797 {
01798 const char *xp = buf;
01799 const long *tp = longs;
01800 long *lp = (long *)lbuf;
01801 size_t nelems = ArraySize(longs);
01802 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01803 int status = ncx_pad_getn_schar_long((const void **)&xp, nelems, lp);
01804 assert(xp >= end);
01805 assert((xp - end) < 4);
01806 assert((xp - buf)%4 == 0);
01807 assert(status == 0);
01808
01809 {
01810 size_t ii;
01811 for(ii = 0; ii < nelems; ii++)
01812 {
01813 if(((double) tp[ii] <= X_SCHAR_MAX)
01814 && ((double) tp[ii] >= X_SCHAR_MIN))
01815 {
01816 assert(tp[ii] == lp[ii]);
01817 }
01818 }
01819 }
01820 }
01821
01822 static void
01823 t_pad_getn_schar_float(const char *const buf)
01824 {
01825 const char *xp = buf;
01826 const float *tp = floats;
01827 float *lp = (float *)lbuf;
01828 size_t nelems = ArraySize(floats);
01829 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01830 int status = ncx_pad_getn_schar_float((const void **)&xp, nelems, lp);
01831 assert(xp >= end);
01832 assert((xp - end) < 4);
01833 assert((xp - buf)%4 == 0);
01834 assert(status == 0);
01835
01836 {
01837 size_t ii;
01838 for(ii = 0; ii < nelems; ii++)
01839 {
01840 if(((double) tp[ii] <= X_SCHAR_MAX)
01841 && ((double) tp[ii] >= X_SCHAR_MIN))
01842 {
01843 assert(tp[ii] == lp[ii]);
01844 }
01845 }
01846 }
01847 }
01848
01849 static void
01850 t_pad_getn_schar_double(const char *const buf)
01851 {
01852 const char *xp = buf;
01853 const double *tp = doubles;
01854 double *lp = (double *)lbuf;
01855 size_t nelems = ArraySize(doubles);
01856 const char *end = buf + nelems * X_SIZEOF_SCHAR;
01857 int status = ncx_pad_getn_schar_double((const void **)&xp, nelems, lp);
01858 assert(xp >= end);
01859 assert((xp - end) < 4);
01860 assert((xp - buf)%4 == 0);
01861 assert(status == 0);
01862
01863 {
01864 size_t ii;
01865 for(ii = 0; ii < nelems; ii++)
01866 {
01867 if(((double) tp[ii] <= X_SCHAR_MAX)
01868 && ((double) tp[ii] >= X_SCHAR_MIN))
01869 {
01870 assert(tp[ii] == lp[ii]);
01871 }
01872 }
01873 }
01874 }
01875
01876
01877 static void
01878 t_getn_short_schar(const char *const buf)
01879 {
01880 const char *xp = buf;
01881 const schar *tp = schars;
01882 schar *lp = (schar *)lbuf;
01883 size_t nelems = ArraySize(schars);
01884 int status = ncx_getn_short_schar((const void **)&xp, nelems, lp);
01885 assert(xp == buf + nelems * X_SIZEOF_SHORT);
01886 assert(status == 0);
01887
01888 {
01889 size_t ii;
01890 for(ii = 0; ii < nelems; ii++)
01891 {
01892 if(((double)tp[ii] <= X_SHORT_MAX)
01893 && ((double)tp[ii] >= X_SHORT_MIN))
01894 {
01895 assert(tp[ii] == lp[ii]);
01896 }
01897 }
01898 }
01899 }
01900
01901 static void
01902 t_getn_short_uchar(const char *const buf)
01903 {
01904 const char *xp = buf;
01905 const uchar *tp = uchars;
01906 uchar *lp = (uchar *)lbuf;
01907 size_t nelems = ArraySize(uchars);
01908 int status = ncx_getn_short_uchar((const void **)&xp, nelems, lp);
01909 assert(xp == buf + nelems * X_SIZEOF_SHORT);
01910 assert(status == 0);
01911
01912 {
01913 size_t ii;
01914 for(ii = 0; ii < nelems; ii++)
01915 {
01916 if((double) tp[ii] <= X_SHORT_MAX)
01917 {
01918 assert(tp[ii] == lp[ii]);
01919 }
01920 }
01921 }
01922 }
01923
01924 static void
01925 t_getn_short_short(const char *const buf)
01926 {
01927 const char *xp = buf;
01928 const short *tp = shorts;
01929 short *lp = (short *)lbuf;
01930 size_t nelems = ArraySize(shorts);
01931 int status = ncx_getn_short_short((const void **)&xp, nelems, lp);
01932 assert(xp == buf + nelems * X_SIZEOF_SHORT);
01933 assert(status == 0);
01934
01935 {
01936 size_t ii;
01937 for(ii = 0; ii < nelems; ii++)
01938 {
01939 if(((double)tp[ii] <= X_SHORT_MAX)
01940 && ((double)tp[ii] >= X_SHORT_MIN))
01941 {
01942 assert(tp[ii] == lp[ii]);
01943 }
01944 }
01945 }
01946 }
01947
01948 static void
01949 t_getn_short_int(const char *const buf)
01950 {
01951 const char *xp = buf;
01952 const int *tp = ints;
01953 int *lp = (int *)lbuf;
01954 size_t nelems = ArraySize(ints);
01955 int status = ncx_getn_short_int((const void **)&xp, nelems, lp);
01956 assert(xp == buf + nelems * X_SIZEOF_SHORT);
01957 assert(status == 0);
01958
01959 {
01960 size_t ii;
01961 for(ii = 0; ii < nelems; ii++)
01962 {
01963 if(((double)tp[ii] <= X_SHORT_MAX)
01964 && ((double)tp[ii] >= X_SHORT_MIN))
01965 {
01966 assert(tp[ii] == lp[ii]);
01967 }
01968 }
01969 }
01970 }
01971
01972 static void
01973 t_getn_short_long(const char *const buf)
01974 {
01975 const char *xp = buf;
01976 const long *tp = longs;
01977 long *lp = (long *)lbuf;
01978 size_t nelems = ArraySize(longs);
01979 int status = ncx_getn_short_long((const void **)&xp, nelems, lp);
01980 assert(xp == buf + nelems * X_SIZEOF_SHORT);
01981 assert(status == 0);
01982
01983 {
01984 size_t ii;
01985 for(ii = 0; ii < nelems; ii++)
01986 {
01987 if(((double)tp[ii] <= X_SHORT_MAX)
01988 && ((double)tp[ii] >= X_SHORT_MIN))
01989 {
01990 assert(tp[ii] == lp[ii]);
01991 }
01992 }
01993 }
01994 }
01995
01996 static void
01997 t_getn_short_float(const char *const buf)
01998 {
01999 const char *xp = buf;
02000 const float *tp = floats;
02001 float *lp = (float *)lbuf;
02002 size_t nelems = ArraySize(floats);
02003 int status = ncx_getn_short_float((const void **)&xp, nelems, lp);
02004 assert(xp == buf + nelems * X_SIZEOF_SHORT);
02005 assert(status == 0);
02006
02007 {
02008 size_t ii;
02009 for(ii = 0; ii < nelems; ii++)
02010 {
02011 if(((double)tp[ii] <= X_SHORT_MAX)
02012 && ((double)tp[ii] >= X_SHORT_MIN))
02013 {
02014 assert(tp[ii] == lp[ii]);
02015 }
02016 }
02017 }
02018 }
02019
02020 static void
02021 t_getn_short_double(const char *const buf)
02022 {
02023 const char *xp = buf;
02024 const double *tp = doubles;
02025 double *lp = (double *)lbuf;
02026 size_t nelems = ArraySize(doubles);
02027 int status = ncx_getn_short_double((const void **)&xp, nelems, lp);
02028 assert(xp == buf + nelems * X_SIZEOF_SHORT);
02029 assert(status == 0);
02030
02031 {
02032 size_t ii;
02033 for(ii = 0; ii < nelems; ii++)
02034 {
02035 if(((double)tp[ii] <= X_SHORT_MAX)
02036 && ((double)tp[ii] >= X_SHORT_MIN))
02037 {
02038 assert(tp[ii] == lp[ii]);
02039 }
02040 }
02041 }
02042 }
02043
02044
02045 static void
02046 t_pad_getn_short_schar(const char *const buf)
02047 {
02048 const char *xp = buf;
02049 const schar *tp = schars;
02050 schar *lp = (schar *)lbuf;
02051 size_t nelems = ArraySize(schars);
02052 const char *end = buf + nelems * X_SIZEOF_SHORT;
02053 int status = ncx_pad_getn_short_schar((const void **)&xp, nelems, lp);
02054 assert(xp >= end);
02055 assert((xp - end) < 4);
02056 assert((xp - buf)%4 == 0);
02057 assert(status == 0);
02058
02059 {
02060 size_t ii;
02061 for(ii = 0; ii < nelems; ii++)
02062 {
02063 if(((double) tp[ii] <= X_SHORT_MAX)
02064 && ((double) tp[ii] >= X_SHORT_MIN))
02065 {
02066 assert(tp[ii] == lp[ii]);
02067 }
02068 }
02069 }
02070 }
02071
02072 static void
02073 t_pad_getn_short_uchar(const char *const buf)
02074 {
02075 const char *xp = buf;
02076 const uchar *tp = uchars;
02077 uchar *lp = (uchar *)lbuf;
02078 size_t nelems = ArraySize(uchars);
02079 const char *end = buf + nelems * X_SIZEOF_SHORT;
02080 int status = ncx_pad_getn_short_uchar((const void **)&xp, nelems, lp);
02081 assert(xp >= end);
02082 assert((xp - end) < 4);
02083 assert((xp - buf)%4 == 0);
02084 assert(status == 0);
02085
02086 {
02087 size_t ii;
02088 for(ii = 0; ii < nelems; ii++)
02089 {
02090 if((tp[ii] <= X_SHORT_MAX))
02091 {
02092 assert(tp[ii] == lp[ii]);
02093 }
02094 }
02095 }
02096 }
02097
02098 static void
02099 t_pad_getn_short_short(const char *const buf)
02100 {
02101 const char *xp = buf;
02102 const short *tp = shorts;
02103 short *lp = (short *)lbuf;
02104 size_t nelems = ArraySize(shorts);
02105 const char *end = buf + nelems * X_SIZEOF_SHORT;
02106 int status = ncx_pad_getn_short_short((const void **)&xp, nelems, lp);
02107 assert(xp >= end);
02108 assert((xp - end) < 4);
02109 assert((xp - buf)%4 == 0);
02110 assert(status == 0);
02111
02112 {
02113 size_t ii;
02114 for(ii = 0; ii < nelems; ii++)
02115 {
02116 if(((double) tp[ii] <= X_SHORT_MAX)
02117 && ((double) tp[ii] >= X_SHORT_MIN))
02118 {
02119 assert(tp[ii] == lp[ii]);
02120 }
02121 }
02122 }
02123 }
02124
02125 static void
02126 t_pad_getn_short_int(const char *const buf)
02127 {
02128 const char *xp = buf;
02129 const int *tp = ints;
02130 int *lp = (int *)lbuf;
02131 size_t nelems = ArraySize(ints);
02132 const char *end = buf + nelems * X_SIZEOF_SHORT;
02133 int status = ncx_pad_getn_short_int((const void **)&xp, nelems, lp);
02134 assert(xp >= end);
02135 assert((xp - end) < 4);
02136 assert((xp - buf)%4 == 0);
02137 assert(status == 0);
02138
02139 {
02140 size_t ii;
02141 for(ii = 0; ii < nelems; ii++)
02142 {
02143 if(((double) tp[ii] <= X_SHORT_MAX)
02144 && ((double) tp[ii] >= X_SHORT_MIN))
02145 {
02146 assert(tp[ii] == lp[ii]);
02147 }
02148 }
02149 }
02150 }
02151
02152 static void
02153 t_pad_getn_short_long(const char *const buf)
02154 {
02155 const char *xp = buf;
02156 const long *tp = longs;
02157 long *lp = (long *)lbuf;
02158 size_t nelems = ArraySize(longs);
02159 const char *end = buf + nelems * X_SIZEOF_SHORT;
02160 int status = ncx_pad_getn_short_long((const void **)&xp, nelems, lp);
02161 assert(xp >= end);
02162 assert((xp - end) < 4);
02163 assert((xp - buf)%4 == 0);
02164 assert(status == 0);
02165
02166 {
02167 size_t ii;
02168 for(ii = 0; ii < nelems; ii++)
02169 {
02170 if(((double) tp[ii] <= X_SHORT_MAX)
02171 && ((double) tp[ii] >= X_SHORT_MIN))
02172 {
02173 assert(tp[ii] == lp[ii]);
02174 }
02175 }
02176 }
02177 }
02178
02179 static void
02180 t_pad_getn_short_float(const char *const buf)
02181 {
02182 const char *xp = buf;
02183 const float *tp = floats;
02184 float *lp = (float *)lbuf;
02185 size_t nelems = ArraySize(floats);
02186 const char *end = buf + nelems * X_SIZEOF_SHORT;
02187 int status = ncx_pad_getn_short_float((const void **)&xp, nelems, lp);
02188 assert(xp >= end);
02189 assert((xp - end) < 4);
02190 assert((xp - buf)%4 == 0);
02191 assert(status == 0);
02192
02193 {
02194 size_t ii;
02195 for(ii = 0; ii < nelems; ii++)
02196 {
02197 if(((double) tp[ii] <= X_SHORT_MAX)
02198 && ((double) tp[ii] >= X_SHORT_MIN))
02199 {
02200 assert(tp[ii] == lp[ii]);
02201 }
02202 }
02203 }
02204 }
02205
02206 static void
02207 t_pad_getn_short_double(const char *const buf)
02208 {
02209 const char *xp = buf;
02210 const double *tp = doubles;
02211 double *lp = (double *)lbuf;
02212 size_t nelems = ArraySize(doubles);
02213 const char *end = buf + nelems * X_SIZEOF_SHORT;
02214 int status = ncx_pad_getn_short_double((const void **)&xp, nelems, lp);
02215 assert(xp >= end);
02216 assert((xp - end) < 4);
02217 assert((xp - buf)%4 == 0);
02218 assert(status == 0);
02219
02220 {
02221 size_t ii;
02222 for(ii = 0; ii < nelems; ii++)
02223 {
02224 if(((double) tp[ii] <= X_SHORT_MAX)
02225 && ((double) tp[ii] >= X_SHORT_MIN))
02226 {
02227 assert(tp[ii] == lp[ii]);
02228 }
02229 }
02230 }
02231 }
02232
02233
02234 static void
02235 t_getn_int_schar(const char *const buf)
02236 {
02237 const char *xp = buf;
02238 const schar *tp = schars;
02239 schar *lp = (schar *)lbuf;
02240 size_t nelems = ArraySize(schars);
02241 int status = ncx_getn_int_schar((const void **)&xp, nelems, lp);
02242 assert(xp == buf + nelems * X_SIZEOF_INT);
02243 assert(status == 0);
02244
02245 {
02246 size_t ii;
02247 for(ii = 0; ii < nelems; ii++)
02248 {
02249 if(((double)tp[ii] <= X_INT_MAX)
02250 && ((double)tp[ii] >= X_INT_MIN))
02251 {
02252 assert(tp[ii] == lp[ii]);
02253 }
02254 }
02255 }
02256 }
02257
02258 static void
02259 t_getn_int_uchar(const char *const buf)
02260 {
02261 const char *xp = buf;
02262 const uchar *tp = uchars;
02263 uchar *lp = (uchar *)lbuf;
02264 size_t nelems = ArraySize(uchars);
02265 int status = ncx_getn_int_uchar((const void **)&xp, nelems, lp);
02266 assert(xp == buf + nelems * X_SIZEOF_INT);
02267 assert(status == 0);
02268
02269 {
02270 size_t ii;
02271 for(ii = 0; ii < nelems; ii++)
02272 {
02273 if((double) tp[ii] <= X_INT_MAX)
02274 {
02275 assert(tp[ii] == lp[ii]);
02276 }
02277 }
02278 }
02279 }
02280
02281 static void
02282 t_getn_int_short(const char *const buf)
02283 {
02284 const char *xp = buf;
02285 const short *tp = shorts;
02286 short *lp = (short *)lbuf;
02287 size_t nelems = ArraySize(shorts);
02288 int status = ncx_getn_int_short((const void **)&xp, nelems, lp);
02289 assert(xp == buf + nelems * X_SIZEOF_INT);
02290 assert(status == 0);
02291
02292 {
02293 size_t ii;
02294 for(ii = 0; ii < nelems; ii++)
02295 {
02296 if(((double)tp[ii] <= X_INT_MAX)
02297 && ((double)tp[ii] >= X_INT_MIN))
02298 {
02299 assert(tp[ii] == lp[ii]);
02300 }
02301 }
02302 }
02303 }
02304
02305 static void
02306 t_getn_int_int(const char *const buf)
02307 {
02308 const char *xp = buf;
02309 const int *tp = ints;
02310 int *lp = (int *)lbuf;
02311 size_t nelems = ArraySize(ints);
02312 int status = ncx_getn_int_int((const void **)&xp, nelems, lp);
02313 assert(xp == buf + nelems * X_SIZEOF_INT);
02314 assert(status == 0);
02315
02316 {
02317 size_t ii;
02318 for(ii = 0; ii < nelems; ii++)
02319 {
02320 if(((double)tp[ii] <= X_INT_MAX)
02321 && ((double)tp[ii] >= X_INT_MIN))
02322 {
02323 assert(tp[ii] == lp[ii]);
02324 }
02325 }
02326 }
02327 }
02328
02329 static void
02330 t_getn_int_long(const char *const buf)
02331 {
02332 const char *xp = buf;
02333 const long *tp = longs;
02334 long *lp = (long *)lbuf;
02335 size_t nelems = ArraySize(longs);
02336 int status = ncx_getn_int_long((const void **)&xp, nelems, lp);
02337 assert(xp == buf + nelems * X_SIZEOF_INT);
02338 assert(status == 0);
02339
02340 {
02341 size_t ii;
02342 for(ii = 0; ii < nelems; ii++)
02343 {
02344 if(((double)tp[ii] <= X_INT_MAX)
02345 && ((double)tp[ii] >= X_INT_MIN))
02346 {
02347 assert(tp[ii] == lp[ii]);
02348 }
02349 }
02350 }
02351 }
02352
02353 static void
02354 t_getn_int_float(const char *const buf)
02355 {
02356 const char *xp = buf;
02357 const float *tp = floats;
02358 float *lp = (float *)lbuf;
02359 size_t nelems = ArraySize(floats);
02360 int status = ncx_getn_int_float((const void **)&xp, nelems, lp);
02361 assert(xp == buf + nelems * X_SIZEOF_INT);
02362 assert(status == 0);
02363
02364 {
02365 size_t ii;
02366 for(ii = 0; ii < nelems; ii++)
02367 {
02368 if(((double)tp[ii] <= X_INT_MAX)
02369 && ((double)tp[ii] >= X_INT_MIN))
02370 {
02371 assert(tp[ii] == lp[ii]);
02372 }
02373 }
02374 }
02375 }
02376
02377 static void
02378 t_getn_int_double(const char *const buf)
02379 {
02380 const char *xp = buf;
02381 const double *tp = doubles;
02382 double *lp = (double *)lbuf;
02383 size_t nelems = ArraySize(doubles);
02384 int status = ncx_getn_int_double((const void **)&xp, nelems, lp);
02385 assert(xp == buf + nelems * X_SIZEOF_INT);
02386 assert(status == 0);
02387
02388 {
02389 size_t ii;
02390 for(ii = 0; ii < nelems; ii++)
02391 {
02392 if(((double)tp[ii] <= X_INT_MAX)
02393 && ((double)tp[ii] >= X_INT_MIN))
02394 {
02395 assert(tp[ii] == lp[ii]);
02396 }
02397 }
02398 }
02399 }
02400
02401
02402 static void
02403 t_getn_float_schar(const char *const buf)
02404 {
02405 const char *xp = buf;
02406 const schar *tp = schars;
02407 schar *lp = (schar *)lbuf;
02408 size_t nelems = ArraySize(schars);
02409 int status = ncx_getn_float_schar((const void **)&xp, nelems, lp);
02410 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02411 assert(status == 0);
02412
02413 {
02414 size_t ii;
02415 for(ii = 0; ii < nelems; ii++)
02416 {
02417 if(((double)tp[ii] <= X_FLOAT_MAX)
02418 && ((double)tp[ii] >= X_FLOAT_MIN))
02419 {
02420 assert(tp[ii] == lp[ii]);
02421 }
02422 }
02423 }
02424 }
02425
02426 static void
02427 t_getn_float_uchar(const char *const buf)
02428 {
02429 const char *xp = buf;
02430 const uchar *tp = uchars;
02431 uchar *lp = (uchar *)lbuf;
02432 size_t nelems = ArraySize(uchars);
02433 int status = ncx_getn_float_uchar((const void **)&xp, nelems, lp);
02434 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02435 assert(status == 0);
02436
02437 {
02438 size_t ii;
02439 for(ii = 0; ii < nelems; ii++)
02440 {
02441 if((double) tp[ii] <= X_FLOAT_MAX)
02442 {
02443 assert(tp[ii] == lp[ii]);
02444 }
02445 }
02446 }
02447 }
02448
02449 static void
02450 t_getn_float_short(const char *const buf)
02451 {
02452 const char *xp = buf;
02453 const short *tp = shorts;
02454 short *lp = (short *)lbuf;
02455 size_t nelems = ArraySize(shorts);
02456 int status = ncx_getn_float_short((const void **)&xp, nelems, lp);
02457 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02458 assert(status == 0);
02459
02460 {
02461 size_t ii;
02462 for(ii = 0; ii < nelems; ii++)
02463 {
02464 if(((double)tp[ii] <= X_FLOAT_MAX)
02465 && ((double)tp[ii] >= X_FLOAT_MIN))
02466 {
02467 assert(tp[ii] == lp[ii]);
02468 }
02469 }
02470 }
02471 }
02472
02473 static void
02474 t_getn_float_int(const char *const buf)
02475 {
02476 const char *xp = buf;
02477 const int *tp = ints;
02478 int *lp = (int *)lbuf;
02479 size_t nelems = ArraySize(ints);
02480 int status = ncx_getn_float_int((const void **)&xp, nelems, lp);
02481 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02482
02483 assert(status == 0 || status == NC_ERANGE);
02484
02485 {
02486 size_t ii;
02487 for(ii = 0; ii < nelems; ii++)
02488 {
02489
02490 if((tp[ii] <= 16777215)
02491 && (tp[ii] >= -16777215))
02492 {
02493 assert(tp[ii] == lp[ii]);
02494 }
02495 }
02496 }
02497 }
02498
02499 static void
02500 t_getn_float_long(const char *const buf)
02501 {
02502 const char *xp = buf;
02503 const long *tp = longs;
02504 long *lp = (long *)lbuf;
02505 size_t nelems = ArraySize(longs);
02506 int status = ncx_getn_float_long((const void **)&xp, nelems, lp);
02507 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02508
02509 assert(status == 0 || status == NC_ERANGE);
02510
02511 {
02512 size_t ii;
02513 for(ii = 0; ii < nelems; ii++)
02514 {
02515
02516 if((tp[ii] <= 16777215)
02517 && (tp[ii] >= 16777215))
02518 {
02519 if(tp[ii] != lp[ii])
02520 (void) fprintf(stderr,
02521 "%.9e != %.9e float_float (diff %.9e)\n",
02522 (double)tp[ii], (double)lp[ii],
02523 (double)(tp[ii] - lp[ii]));
02524 }
02525 }
02526 }
02527 }
02528 static void
02529 t_getn_float_float(const char *const buf)
02530 {
02531 const char *xp = buf;
02532 const float *tp = floats;
02533 float *lp = (float *)lbuf;
02534 size_t nelems = ArraySize(floats);
02535 int status = ncx_getn_float_float((const void **)&xp, nelems, lp);
02536 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02537 assert(status == 0);
02538
02539 {
02540 size_t ii;
02541 for(ii = 0; ii < nelems; ii++)
02542 {
02543 if(((double)tp[ii] <= X_FLOAT_MAX)
02544 && ((double)tp[ii] >= X_FLOAT_MIN))
02545 {
02546 assert(tp[ii] == lp[ii]);
02547 }
02548 }
02549 }
02550 }
02551
02552 static void
02553 t_getn_float_double(const char *const buf)
02554 {
02555 const char *xp = buf;
02556 const double *tp = doubles;
02557 double *lp = (double *)lbuf;
02558 size_t nelems = ArraySize(doubles);
02559 int status = ncx_getn_float_double((const void **)&xp, nelems, lp);
02560 assert(xp == buf + nelems * X_SIZEOF_FLOAT);
02561 assert(status == 0);
02562
02563 {
02564 size_t ii;
02565 for(ii = 0; ii < nelems; ii++)
02566 {
02567 if((tp[ii] <= X_FLOAT_MAX)
02568 && (tp[ii] >= X_FLOAT_MIN))
02569 {
02570 if(((float)tp[ii]) != lp[ii])
02571 {
02572 if(tp[ii] != 0)
02573 {
02574 double eps = (tp[ii] - lp[ii])/tp[ii];
02575 if(eps > 1.19209290E-07F)
02576 {
02577 (void) fprintf(stderr,
02578 "%.9e != %.9e float_double (eps %.9e)\n",
02579 tp[ii], lp[ii], eps);
02580 }
02581 }
02582 else
02583 {
02584 (void) fprintf(stderr,
02585 "%.9e != %.9e float_double (diff %.9e)\n",
02586 tp[ii], lp[ii], tp[ii] - lp[ii]);
02587
02588 }
02589 }
02590 }
02591 }
02592 }
02593 }
02594
02595
02596 static void
02597 t_getn_double_schar(const char *const buf)
02598 {
02599 const char *xp = buf;
02600 const schar *tp = schars;
02601 schar *lp = (schar *)lbuf;
02602 size_t nelems = ArraySize(schars);
02603 int status = ncx_getn_double_schar((const void **)&xp, nelems, lp);
02604 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02605 assert(status == 0);
02606
02607 {
02608 size_t ii;
02609 for(ii = 0; ii < nelems; ii++)
02610 {
02611 if(((double)tp[ii] <= X_DOUBLE_MAX)
02612 && ((double)tp[ii] >= X_DOUBLE_MIN))
02613 {
02614 assert(tp[ii] == lp[ii]);
02615 }
02616 }
02617 }
02618 }
02619
02620 static void
02621 t_getn_double_uchar(const char *const buf)
02622 {
02623 const char *xp = buf;
02624 const uchar *tp = uchars;
02625 uchar *lp = (uchar *)lbuf;
02626 size_t nelems = ArraySize(uchars);
02627 int status = ncx_getn_double_uchar((const void **)&xp, nelems, lp);
02628 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02629 assert(status == 0);
02630
02631 {
02632 size_t ii;
02633 for(ii = 0; ii < nelems; ii++)
02634 {
02635 if((double) tp[ii] <= X_DOUBLE_MAX)
02636 {
02637 assert(tp[ii] == lp[ii]);
02638 }
02639 }
02640 }
02641 }
02642
02643 static void
02644 t_getn_double_short(const char *const buf)
02645 {
02646 const char *xp = buf;
02647 const short *tp = shorts;
02648 short *lp = (short *)lbuf;
02649 size_t nelems = ArraySize(shorts);
02650 int status = ncx_getn_double_short((const void **)&xp, nelems, lp);
02651 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02652 assert(status == 0);
02653
02654 {
02655 size_t ii;
02656 for(ii = 0; ii < nelems; ii++)
02657 {
02658 if(((double)tp[ii] <= X_DOUBLE_MAX)
02659 && ((double)tp[ii] >= X_DOUBLE_MIN))
02660 {
02661 assert(tp[ii] == lp[ii]);
02662 }
02663 }
02664 }
02665 }
02666
02667 static void
02668 t_getn_double_int(const char *const buf)
02669 {
02670 const char *xp = buf;
02671 const int *tp = ints;
02672 int *lp = (int *)lbuf;
02673 size_t nelems = ArraySize(ints);
02674 int status = ncx_getn_double_int((const void **)&xp, nelems, lp);
02675 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02676 assert(status == 0);
02677
02678 {
02679 size_t ii;
02680 for(ii = 0; ii < nelems; ii++)
02681 {
02682 if(((double)tp[ii] <= X_DOUBLE_MAX)
02683 && ((double)tp[ii] >= X_DOUBLE_MIN))
02684 {
02685 assert(tp[ii] == lp[ii]);
02686 }
02687 }
02688 }
02689 }
02690
02691 static void
02692 t_getn_double_long(const char *const buf)
02693 {
02694 const char *xp = buf;
02695 const long *tp = longs;
02696 long *lp = (long *)lbuf;
02697 size_t nelems = ArraySize(longs);
02698 int status = ncx_getn_double_long((const void **)&xp, nelems, lp);
02699 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02700 assert(status == 0);
02701
02702 {
02703 size_t ii;
02704 for(ii = 0; ii < nelems; ii++)
02705 {
02706 if(((double)tp[ii] <= X_DOUBLE_MAX)
02707 && ((double)tp[ii] >= X_DOUBLE_MIN))
02708 {
02709 assert(tp[ii] == lp[ii]);
02710 }
02711 }
02712 }
02713 }
02714
02715 static void
02716 t_getn_double_float(const char *const buf)
02717 {
02718 const char *xp = buf;
02719 const float *tp = floats;
02720 float *lp = (float *)lbuf;
02721 size_t nelems = ArraySize(floats);
02722 int status = ncx_getn_double_float((const void **)&xp, nelems, lp);
02723 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02724 assert(status == 0);
02725
02726 {
02727 size_t ii;
02728 for(ii = 0; ii < nelems; ii++)
02729 {
02730 if(((double)tp[ii] <= X_DOUBLE_MAX)
02731 && ((double)tp[ii] >= X_DOUBLE_MIN))
02732 {
02733 assert(tp[ii] == lp[ii]);
02734 }
02735 }
02736 }
02737 }
02738
02739 static void
02740 t_getn_double_double(const char *const buf)
02741 {
02742 const char *xp = buf;
02743 const double *tp = doubles;
02744 double *lp = (double *)lbuf;
02745 size_t nelems = ArraySize(doubles);
02746 int status = ncx_getn_double_double((const void **)&xp, nelems, lp);
02747 assert(xp == buf + nelems * X_SIZEOF_DOUBLE);
02748 assert(status == 0);
02749
02750 {
02751 size_t ii;
02752 for(ii = 0; ii < nelems; ii++)
02753 {
02754 if(((double)tp[ii] <= X_DOUBLE_MAX)
02755 && ((double)tp[ii] >= X_DOUBLE_MIN))
02756 {
02757 assert(tp[ii] == lp[ii]);
02758 }
02759 }
02760 }
02761 }
02762
02763
02764
02765 #if defined(_CRAYIEEE) && !defined(_CRAYMPP)
02766 #include <signal.h>
02767 #endif
02768
02769 int
02770 main(int ac, char *av[])
02771 {
02772
02773 #if defined(_CRAYIEEE) && !defined(_CRAYMPP)
02774
02775
02776
02777
02778 (void) signal(SIGFPE, SIG_IGN);
02779 #endif
02780
02781
02782 t_putn_schar_schar(ncxb);
02783 t_getn_schar_schar(ncxb);
02784
02785 t_putn_schar_uchar(ncxb);
02786 t_getn_schar_uchar(ncxb);
02787
02788 t_putn_schar_short(ncxb);
02789 t_getn_schar_short(ncxb);
02790
02791 t_putn_schar_int(ncxb);
02792 t_getn_schar_int(ncxb);
02793
02794 t_putn_schar_long(ncxb);
02795 t_getn_schar_long(ncxb);
02796
02797 t_putn_schar_float(ncxb);
02798 t_getn_schar_float(ncxb);
02799
02800 t_putn_schar_double(ncxb);
02801 t_getn_schar_double(ncxb);
02802
02803
02804 t_pad_putn_schar_schar(ncxb);
02805 t_getn_schar_schar(ncxb);
02806 t_pad_getn_schar_schar(ncxb);
02807
02808 t_pad_putn_schar_uchar(ncxb);
02809 t_getn_schar_uchar(ncxb);
02810 t_pad_getn_schar_uchar(ncxb);
02811
02812 t_pad_putn_schar_short(ncxb);
02813 t_getn_schar_short(ncxb);
02814 t_pad_getn_schar_short(ncxb);
02815
02816 t_pad_putn_schar_int(ncxb);
02817 t_getn_schar_int(ncxb);
02818 t_pad_getn_schar_int(ncxb);
02819
02820 t_pad_putn_schar_long(ncxb);
02821 t_getn_schar_long(ncxb);
02822 t_pad_getn_schar_long(ncxb);
02823
02824 t_pad_putn_schar_float(ncxb);
02825 t_getn_schar_float(ncxb);
02826 t_pad_getn_schar_float(ncxb);
02827
02828 t_pad_putn_schar_double(ncxb);
02829 t_getn_schar_double(ncxb);
02830 t_pad_getn_schar_double(ncxb);
02831
02832
02833 t_putn_short_schar(ncxb);
02834 t_getn_short_schar(ncxb);
02835
02836 t_putn_short_uchar(ncxb);
02837 t_getn_short_uchar(ncxb);
02838
02839 t_putn_short_short(ncxb);
02840 t_getn_short_short(ncxb);
02841
02842 t_putn_short_int(ncxb);
02843 t_getn_short_int(ncxb);
02844
02845 t_putn_short_long(ncxb);
02846 t_getn_short_long(ncxb);
02847
02848 t_putn_short_float(ncxb);
02849 t_getn_short_float(ncxb);
02850
02851 t_putn_short_double(ncxb);
02852 t_getn_short_double(ncxb);
02853
02854
02855 t_pad_putn_short_schar(ncxb);
02856 t_getn_short_schar(ncxb);
02857 t_pad_getn_short_schar(ncxb);
02858
02859 t_pad_putn_short_uchar(ncxb);
02860 t_getn_short_uchar(ncxb);
02861 t_pad_getn_short_uchar(ncxb);
02862
02863 t_pad_putn_short_short(ncxb);
02864 t_getn_short_short(ncxb);
02865 t_pad_getn_short_short(ncxb);
02866
02867 t_pad_putn_short_int(ncxb);
02868 t_getn_short_int(ncxb);
02869 t_pad_getn_short_int(ncxb);
02870
02871 t_pad_putn_short_long(ncxb);
02872 t_getn_short_long(ncxb);
02873 t_pad_getn_short_long(ncxb);
02874
02875 t_pad_putn_short_float(ncxb);
02876 t_getn_short_float(ncxb);
02877 t_pad_getn_short_float(ncxb);
02878
02879 t_pad_putn_short_double(ncxb);
02880 t_getn_short_double(ncxb);
02881 t_pad_getn_short_double(ncxb);
02882
02883
02884 t_putn_int_schar(ncxb);
02885 t_getn_int_schar(ncxb);
02886
02887 t_putn_int_uchar(ncxb);
02888 t_getn_int_uchar(ncxb);
02889
02890 t_putn_int_short(ncxb);
02891 t_getn_int_short(ncxb);
02892
02893 t_putn_int_int(ncxb);
02894 t_getn_int_int(ncxb);
02895
02896 t_putn_int_long(ncxb);
02897 t_getn_int_long(ncxb);
02898
02899 t_putn_int_float(ncxb);
02900 t_getn_int_float(ncxb);
02901
02902 t_putn_int_double(ncxb);
02903 t_getn_int_double(ncxb);
02904
02905
02906 t_putn_float_schar(ncxb);
02907 t_getn_float_schar(ncxb);
02908
02909 t_putn_float_uchar(ncxb);
02910 t_getn_float_uchar(ncxb);
02911
02912 t_putn_float_short(ncxb);
02913 t_getn_float_short(ncxb);
02914
02915 t_putn_float_int(ncxb);
02916 t_getn_float_int(ncxb);
02917
02918 t_putn_float_long(ncxb);
02919 t_getn_float_long(ncxb);
02920
02921 t_putn_float_float(ncxb);
02922 t_getn_float_float(ncxb);
02923
02924 t_putn_float_double(ncxb);
02925 t_getn_float_double(ncxb);
02926
02927
02928 t_putn_double_schar(ncxb);
02929 t_getn_double_schar(ncxb);
02930
02931 t_putn_double_uchar(ncxb);
02932 t_getn_double_uchar(ncxb);
02933
02934 t_putn_double_short(ncxb);
02935 t_getn_double_short(ncxb);
02936
02937 t_putn_double_int(ncxb);
02938 t_getn_double_int(ncxb);
02939
02940 t_putn_double_long(ncxb);
02941 t_getn_double_long(ncxb);
02942
02943 t_putn_double_float(ncxb);
02944 t_getn_double_float(ncxb);
02945
02946 t_putn_double_double(ncxb);
02947 t_getn_double_double(ncxb);
02948
02949 return 0;
02950 }
