02771 {
02772 
02773 #if defined(_CRAYIEEE) && !defined(_CRAYMPP) /* T90 */
02774         /*
02775          * Some of the extreme test assignments in this program trigger
02776          * floating point exceptions on CRAY T90
02777          */
02778         (void) signal(SIGFPE, SIG_IGN);
02779 #endif /* T90 */
02780 
02781   /* x_schar */
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   /* pad x_schar */
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   /* x_short */
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   /* pad x_short */
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   /* x_int */
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   /* x_float */
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   /* x_double */
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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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) /* X_FLT_EPSILON */
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 }

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 }

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         /* If the system rounds up can get NC_ERANGE */
02483         assert(status == 0 || status == NC_ERANGE);
02484 
02485         {
02486                 size_t ii;
02487                 for(ii = 0; ii < nelems; ii++)
02488                 {
02489                         /* limited by x_float mantissa nbits */
02490                         if((tp[ii] <= 16777215)
02491                                 && (tp[ii] >= -16777215))
02492                         {
02493                                 assert(tp[ii] == lp[ii]);
02494                         }
02495                 }
02496         }
02497 }

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         /* If the system rounds up can get NC_ERANGE */
02509         assert(status == 0 || status == NC_ERANGE);
02510 
02511         {
02512                 size_t ii;
02513                 for(ii = 0; ii < nelems; ii++)
02514                 {
02515                         /* limited by x_float mantissa nbits */
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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

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 }

 {
        -1.E20,
        -4503599627370495., -4503599627370494.,
        -999999999999999.,
        -1.E9,
        -16777215, -16777214,
        -999999,
        -32769, -32768, -32767,
        -129, -128, 127,
        -1, 0, 1,
        126, 127, 128,
        32766, 32767, 32768,
        999999,
        16777214, 16777215,     
        1.E9,
        999999999999999.,
        4503599627370494., 4503599627370495.,   
        1.E20
}

 {
        -1.E9F,
        -16777215, -16777214,
        -999999,
        -32769, -32768, -32767,
        -129, -128, 127,
        -1, 0, 1,
        126, 127, 128,
        32766, 32767, 32768,
        999999,
        16777214, 16777215,     
        1.E9F
}

 {

        SHORT_MIN, SHORT_MIN + 1,

        SCHAR_MIN - 1, SCHAR_MIN, SCHAR_MIN + 1,

        -1, 0, 1,

        SCHAR_MAX - 1, SCHAR_MAX, SCHAR_MAX + 1,

        SHORT_MAX - 1, SHORT_MAX











}

 {
        0, 1,
        UCHAR_MAX2 -1, UCHAR_MAX2, UCHAR_MAX2 +1,
        UCHAR_MAX - 1, UCHAR_MAX
}