int
main(int argc, char *argv[]) {
int aret;
char *me;
AIR_UNUSED(argc);
me = argv[0];
aret = airSanity();
if (airInsane_not == aret) {
char stmp[AIR_STRLEN_SMALL];
fprintf(stderr, "%s: air sanity check passed.\n", me);
fprintf(stderr, "\n");
fprintf(stderr, "airMyEndian() == %d\n", airMyEndian());
fprintf(stderr, "AIR_QNANHIBIT == %d\n", AIR_QNANHIBIT);
fprintf(stderr, "AIR_DIO == %d\n", AIR_DIO);
fprintf(stderr, "sizeof(size_t) = %s\n",
airSprintSize_t(stmp, sizeof(size_t)));
fprintf(stderr, "sizeof(void*) = %s\n",
airSprintSize_t(stmp, sizeof(void*)));
return 0;
}
/* else */
fprintf(stderr, "%s: air sanity check FAILED:\n%s\n",
me, airInsaneErr(aret));
return 1;
}
int
main(int argc, char *argv[]) {
int aret;
char *me;
AIR_UNUSED(argc);
me = argv[0];
aret = airSanity();
if (airInsane_not == aret) {
fprintf(stderr, "%s: air sanity check passed.\n", me);
fprintf(stderr, "\n");
fprintf(stderr, "AIR_ENDIAN == %d\n", AIR_ENDIAN);
fprintf(stderr, "AIR_QNANHIBIT == %d\n", AIR_QNANHIBIT);
fprintf(stderr, "AIR_DIO == %d\n", AIR_DIO);
fprintf(stderr, "AIR_32BIT == %d\n", AIR_32BIT);
fprintf(stderr, "sizeof(size_t) = " _AIR_SIZE_T_CNV
"; sizeof(void*) = " _AIR_SIZE_T_CNV "\n",
sizeof(size_t), sizeof(void*));
fprintf(stderr, "_AIR_SIZE_T_CNV = \"%s\"\n", _AIR_SIZE_T_CNV);
return 0;
}
/* else */
fprintf(stderr, "%s: air sanity check FAILED:\n%s\n",
me, airInsaneErr(aret));
return 1;
}
/*
****** nrrdSanity
**
** makes sure that all the basic assumptions of nrrd hold for
** the architecture/etc which we're currently running on.
**
** returns 1 if all is okay, 0 if there is a problem
*/
int /*Teem: biff if (!ret) */
nrrdSanity(void) {
static const char me[]="nrrdSanity";
int aret, type;
size_t maxsize;
airLLong tmpLLI;
airULLong tmpULLI;
static int _nrrdSanity = 0;
if (_nrrdSanity) {
/* we've been through this once before and things looked okay ... */
/* Is this thread-safe? I think so. If we assume that any two
threads are going to compute the same value, isn't it the case
that, at worse, both of them will go through all the tests and
then set _nrrdSanity to the same thing? */
return 1;
}
aret = airSanity();
if (aret != airInsane_not) {
biffAddf(NRRD, "%s: airSanity() failed: %s", me,
airInsaneErr(aret));
return 0;
}
if (airEnumValCheck(nrrdEncodingType, nrrdDefaultWriteEncodingType)) {
biffAddf(NRRD,
"%s: nrrdDefaultWriteEncodingType (%d) not in valid "
"range [%d,%d]", me, nrrdDefaultWriteEncodingType,
nrrdEncodingTypeUnknown+1, nrrdEncodingTypeLast-1);
return 0;
}
if (airEnumValCheck(nrrdCenter, nrrdDefaultCenter)) {
biffAddf(NRRD,
"%s: nrrdDefaultCenter (%d) not in valid range [%d,%d]",
me, nrrdDefaultCenter,
nrrdCenterUnknown+1, nrrdCenterLast-1);
return 0;
}
if (!( nrrdTypeSize[nrrdTypeChar] == sizeof(char)
&& nrrdTypeSize[nrrdTypeUChar] == sizeof(unsigned char)
&& nrrdTypeSize[nrrdTypeShort] == sizeof(short)
&& nrrdTypeSize[nrrdTypeUShort] == sizeof(unsigned short)
&& nrrdTypeSize[nrrdTypeInt] == sizeof(int)
&& nrrdTypeSize[nrrdTypeUInt] == sizeof(unsigned int)
&& nrrdTypeSize[nrrdTypeLLong] == sizeof(airLLong)
&& nrrdTypeSize[nrrdTypeULLong] == sizeof(airULLong)
&& nrrdTypeSize[nrrdTypeFloat] == sizeof(float)
&& nrrdTypeSize[nrrdTypeDouble] == sizeof(double) )) {
biffAddf(NRRD, "%s: sizeof() for nrrd types has problem: "
"expected (%u,%u,%u,%u,%u,%u,%u,%u,%u,%u) "
"but got (%u,%u,%u,%u,%u,%u,%u,%u,%u,%u)", me,
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeChar]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUChar]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeShort]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUShort]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeInt]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUInt]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeLLong]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeULLong]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeFloat]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeDouble]),
AIR_CAST(unsigned int, sizeof(char)),
AIR_CAST(unsigned int, sizeof(unsigned char)),
AIR_CAST(unsigned int, sizeof(short)),
AIR_CAST(unsigned int, sizeof(unsigned short)),
AIR_CAST(unsigned int, sizeof(int)),
AIR_CAST(unsigned int, sizeof(unsigned int)),
AIR_CAST(unsigned int, sizeof(airLLong)),
AIR_CAST(unsigned int, sizeof(airULLong)),
AIR_CAST(unsigned int, sizeof(float)),
AIR_CAST(unsigned int, sizeof(double)));
return 0;
}
/*
******** nrrdSanity()
**
** makes sure that all the basic assumptions of nrrd hold for
** the architecture/etc which we're currently running on.
**
** returns 1 if all is okay, 0 if there is a problem
*/
int
nrrdSanity(void) {
char me[]="nrrdSanity", err[BIFF_STRLEN];
int aret, type;
size_t maxsize;
airLLong tmpLLI;
airULLong tmpULLI;
static int _nrrdSanity = 0;
if (_nrrdSanity) {
/* we've been through this once before and things looked okay ... */
/* Is this thread-safe? I think so. If we assume that any two
threads are going to compute the same value, isn't it the case
that, at worse, both of them will go through all the tests and
then set _nrrdSanity to the same thing? */
return 1;
}
aret = airSanity();
if (aret != airInsane_not) {
sprintf(err, "%s: airSanity() failed: %s", me, airInsaneErr(aret));
biffAdd(NRRD, err); return 0;
}
if (airEnumValCheck(nrrdEncodingType, nrrdDefaultWriteEncodingType)) {
sprintf(err, "%s: nrrdDefaultWriteEncodingType (%d) not in valid "
"range [%d,%d]", me, nrrdDefaultWriteEncodingType,
nrrdEncodingTypeUnknown+1, nrrdEncodingTypeLast-1);
biffAdd(NRRD, err); return 0;
}
if (airEnumValCheck(nrrdCenter, nrrdDefaultCenter)) {
sprintf(err, "%s: nrrdDefaultCenter (%d) not in valid range [%d,%d]",
me, nrrdDefaultCenter,
nrrdCenterUnknown+1, nrrdCenterLast-1);
biffAdd(NRRD, err); return 0;
}
/* ---- BEGIN non-NrrdIO */
if (!( nrrdTypeDefault == nrrdDefaultResampleType
|| !airEnumValCheck(nrrdType, nrrdDefaultResampleType) )) {
sprintf(err, "%s: nrrdDefaultResampleType (%d) not in valid range [%d,%d]",
me, nrrdDefaultResampleType,
nrrdTypeUnknown, nrrdTypeLast-1);
biffAdd(NRRD, err); return 0;
}
if (airEnumValCheck(nrrdBoundary, nrrdDefaultResampleBoundary)) {
sprintf(err, "%s: nrrdDefaultResampleBoundary (%d) "
"not in valid range [%d,%d]",
me, nrrdDefaultResampleBoundary,
nrrdBoundaryUnknown+1, nrrdBoundaryLast-1);
biffAdd(NRRD, err); return 0;
}
if (airEnumValCheck(nrrdType, nrrdStateMeasureType)) {
sprintf(err, "%s: nrrdStateMeasureType (%d) not in valid range [%d,%d]",
me, nrrdStateMeasureType,
nrrdTypeUnknown+1, nrrdTypeLast-1);
biffAdd(NRRD, err); return 0;
}
if (airEnumValCheck(nrrdType, nrrdStateMeasureHistoType)) {
sprintf(err,
"%s: nrrdStateMeasureHistoType (%d) not in valid range [%d,%d]",
me, nrrdStateMeasureType,
nrrdTypeUnknown+1, nrrdTypeLast-1);
biffAdd(NRRD, err); return 0;
}
/* ---- END non-NrrdIO */
if (!( nrrdTypeSize[nrrdTypeChar] == sizeof(char)
&& nrrdTypeSize[nrrdTypeUChar] == sizeof(unsigned char)
&& nrrdTypeSize[nrrdTypeShort] == sizeof(short)
&& nrrdTypeSize[nrrdTypeUShort] == sizeof(unsigned short)
&& nrrdTypeSize[nrrdTypeInt] == sizeof(int)
&& nrrdTypeSize[nrrdTypeUInt] == sizeof(unsigned int)
&& nrrdTypeSize[nrrdTypeLLong] == sizeof(airLLong)
&& nrrdTypeSize[nrrdTypeULLong] == sizeof(airULLong)
&& nrrdTypeSize[nrrdTypeFloat] == sizeof(float)
&& nrrdTypeSize[nrrdTypeDouble] == sizeof(double) )) {
sprintf(err, "%s: sizeof() for nrrd types has problem: "
"expected (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d) "
"but got (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)", me,
(int)nrrdTypeSize[nrrdTypeChar],
(int)nrrdTypeSize[nrrdTypeUChar],
(int)nrrdTypeSize[nrrdTypeShort],
(int)nrrdTypeSize[nrrdTypeUShort],
(int)nrrdTypeSize[nrrdTypeInt],
(int)nrrdTypeSize[nrrdTypeUInt],
(int)nrrdTypeSize[nrrdTypeLLong],
(int)nrrdTypeSize[nrrdTypeULLong],
(int)nrrdTypeSize[nrrdTypeFloat],
(int)nrrdTypeSize[nrrdTypeDouble],
(int)sizeof(char),
(int)sizeof(unsigned char),
(int)sizeof(short),
(int)sizeof(unsigned short),
(int)sizeof(int),
(int)sizeof(unsigned int),
(int)sizeof(airLLong),
(int)sizeof(airULLong),
(int)sizeof(float),
(int)sizeof(double));
biffAdd(NRRD, err); return 0;
}
/* check on NRRD_TYPE_SIZE_MAX */
maxsize = 0;
for (type=nrrdTypeUnknown+1; type<=nrrdTypeLast-2; type++) {
maxsize = AIR_MAX(maxsize, nrrdTypeSize[type]);
}
if (maxsize != NRRD_TYPE_SIZE_MAX) {
sprintf(err, "%s: actual max type size is %d != %d == NRRD_TYPE_SIZE_MAX",
me, (int)maxsize, NRRD_TYPE_SIZE_MAX);
biffAdd(NRRD, err); return 0;
}
/* check on NRRD_TYPE_BIGGEST */
if (maxsize != sizeof(NRRD_TYPE_BIGGEST)) {
sprintf(err, "%s: actual max type size is %d != "
"%d == sizeof(NRRD_TYPE_BIGGEST)",
me, (int)maxsize, (int)sizeof(NRRD_TYPE_BIGGEST));
biffAdd(NRRD, err); return 0;
}
/* nrrd-defined type min/max values */
tmpLLI = NRRD_LLONG_MAX;
if (tmpLLI != NRRD_LLONG_MAX) {
sprintf(err, "%s: long long int can't hold NRRD_LLONG_MAX ("
AIR_ULLONG_FMT ")", me,
NRRD_LLONG_MAX);
biffAdd(NRRD, err); return 0;
}
tmpLLI += 1;
if (NRRD_LLONG_MIN != tmpLLI) {
sprintf(err, "%s: long long int min (" AIR_LLONG_FMT ") or max ("
AIR_LLONG_FMT ") incorrect", me,
NRRD_LLONG_MIN, NRRD_LLONG_MAX);
biffAdd(NRRD, err); return 0;
}
tmpULLI = NRRD_ULLONG_MAX;
if (tmpULLI != NRRD_ULLONG_MAX) {
sprintf(err,
"%s: unsigned long long int can't hold NRRD_ULLONG_MAX ("
AIR_ULLONG_FMT ")",
me, NRRD_ULLONG_MAX);
biffAdd(NRRD, err); return 0;
}
tmpULLI += 1;
if (tmpULLI != 0) {
sprintf(err, "%s: unsigned long long int max (" AIR_ULLONG_FMT
") incorrect", me,
NRRD_ULLONG_MAX);
biffAdd(NRRD, err); return 0;
}
if (_nrrdCheckEnums()) {
sprintf(err, "%s: problem with enum definition", me);
biffAdd(NRRD, err); return 0;
}
if (!( NRRD_DIM_MAX >= 3 )) {
sprintf(err, "%s: NRRD_DIM_MAX == %d seems awfully small, doesn't it?",
me, NRRD_DIM_MAX);
biffAdd(NRRD, err); return 0;
}
if (!nrrdTypeIsIntegral[nrrdTypeBlock]) {
sprintf(err, "%s: nrrdTypeInteger[nrrdTypeBlock] is not true, things "
"could get wacky", me);
biffAdd(NRRD, err); return 0;
}
/* HEY: any other assumptions built into Teem? */
_nrrdSanity = 1;
return 1;
}
/*
****** nrrdSanity
**
** makes sure that all the basic assumptions of nrrd hold for
** the architecture/etc which we're currently running on.
**
** returns 1 if all is okay, 0 if there is a problem
*/
int /*Teem: biff if (!ret) */
nrrdSanity(void) {
static const char me[]="nrrdSanity";
int aret, type;
size_t maxsize;
airLLong tmpLLI;
airULLong tmpULLI;
static int _nrrdSanity = 0;
if (_nrrdSanity) {
/* we've been through this once before and things looked okay ... */
/* Is this thread-safe? I think so. If we assume that any two
threads are going to compute the same value, isn't it the case
that, at worse, both of them will go through all the tests and
then set _nrrdSanity to the same thing? */
return 1;
}
aret = airSanity();
if (aret != airInsane_not) {
biffAddf(NRRD, "%s: airSanity() failed: %s", me,
airInsaneErr(aret));
return 0;
}
/* ---- BEGIN non-NrrdIO */
/* Odd: this sanity checker isn't part of airSanity, nor can it be
without adding to airInsaneErr's list of what can go wrong, but
someone should be calling it, since we have no other correctness
test of the Mersenne-Twister code within Teem (not counting the
CTests in teem/Testing) */
if (!airRandMTSanity()) {
biffAddf(NRRD, "%s: airRandMTSanity failed", me);
return 0;
}
/* ---- END non-NrrdIO */
if (airEnumValCheck(nrrdEncodingType, nrrdDefaultWriteEncodingType)) {
biffAddf(NRRD,
"%s: nrrdDefaultWriteEncodingType (%d) not in valid "
"range [%d,%d]", me, nrrdDefaultWriteEncodingType,
nrrdEncodingTypeUnknown+1, nrrdEncodingTypeLast-1);
return 0;
}
if (airEnumValCheck(nrrdCenter, nrrdDefaultCenter)) {
biffAddf(NRRD,
"%s: nrrdDefaultCenter (%d) not in valid range [%d,%d]",
me, nrrdDefaultCenter,
nrrdCenterUnknown+1, nrrdCenterLast-1);
return 0;
}
/* ---- BEGIN non-NrrdIO */
if (!( nrrdTypeDefault == nrrdDefaultResampleType
|| !airEnumValCheck(nrrdType, nrrdDefaultResampleType) )) {
biffAddf(NRRD,
"%s: nrrdDefaultResampleType (%d) not in valid range [%d,%d]",
me, nrrdDefaultResampleType,
nrrdTypeUnknown, nrrdTypeLast-1);
return 0;
}
if (airEnumValCheck(nrrdBoundary, nrrdDefaultResampleBoundary)) {
biffAddf(NRRD, "%s: nrrdDefaultResampleBoundary (%d) "
"not in valid range [%d,%d]",
me, nrrdDefaultResampleBoundary,
nrrdBoundaryUnknown+1, nrrdBoundaryLast-1);
return 0;
}
if (airEnumValCheck(nrrdType, nrrdStateMeasureType)) {
biffAddf(NRRD,
"%s: nrrdStateMeasureType (%d) not in valid range [%d,%d]",
me, nrrdStateMeasureType,
nrrdTypeUnknown+1, nrrdTypeLast-1);
return 0;
}
if (airEnumValCheck(nrrdType, nrrdStateMeasureHistoType)) {
biffAddf(NRRD,
"%s: nrrdStateMeasureHistoType (%d) not in "
"valid range [%d,%d]", me, nrrdStateMeasureType,
nrrdTypeUnknown+1, nrrdTypeLast-1);
return 0;
}
/* ---- END non-NrrdIO */
if (!( nrrdTypeSize[nrrdTypeChar] == sizeof(char)
&& nrrdTypeSize[nrrdTypeUChar] == sizeof(unsigned char)
&& nrrdTypeSize[nrrdTypeShort] == sizeof(short)
&& nrrdTypeSize[nrrdTypeUShort] == sizeof(unsigned short)
&& nrrdTypeSize[nrrdTypeInt] == sizeof(int)
&& nrrdTypeSize[nrrdTypeUInt] == sizeof(unsigned int)
&& nrrdTypeSize[nrrdTypeLLong] == sizeof(airLLong)
&& nrrdTypeSize[nrrdTypeULLong] == sizeof(airULLong)
&& nrrdTypeSize[nrrdTypeFloat] == sizeof(float)
&& nrrdTypeSize[nrrdTypeDouble] == sizeof(double) )) {
biffAddf(NRRD, "%s: sizeof() for nrrd types has problem: "
"expected (%u,%u,%u,%u,%u,%u,%u,%u,%u,%u) "
"but got (%u,%u,%u,%u,%u,%u,%u,%u,%u,%u)", me,
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeChar]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUChar]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeShort]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUShort]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeInt]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeUInt]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeLLong]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeULLong]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeFloat]),
AIR_CAST(unsigned int, nrrdTypeSize[nrrdTypeDouble]),
AIR_CAST(unsigned int, sizeof(char)),
AIR_CAST(unsigned int, sizeof(unsigned char)),
AIR_CAST(unsigned int, sizeof(short)),
AIR_CAST(unsigned int, sizeof(unsigned short)),
AIR_CAST(unsigned int, sizeof(int)),
AIR_CAST(unsigned int, sizeof(unsigned int)),
AIR_CAST(unsigned int, sizeof(airLLong)),
AIR_CAST(unsigned int, sizeof(airULLong)),
AIR_CAST(unsigned int, sizeof(float)),
AIR_CAST(unsigned int, sizeof(double)));
return 0;
}
