int
meetHestPullVolParse(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
static const char me[]="meetHestPullVolParse";
meetPullVol *mpv, **mpvP;
airArray *mop;
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
mop = airMopNew();
mpvP = AIR_CAST(meetPullVol **, ptr);
*mpvP = mpv = meetPullVolNew();
airMopAdd(mop, mpvP, (airMopper)airSetNull, airMopOnError);
airMopAdd(mop, mpv, (airMopper)meetPullVolNix, airMopOnError);
if (meetPullVolParse(mpv, str)) {
char *ler;
airMopAdd(mop, ler = biffGetDone(MEET), airFree, airMopOnError);
airStrcpy(err, AIR_STRLEN_HUGE, ler);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
airEnumVal(const airEnum *enm, const char *str) {
char *strCpy, test[AIR_STRLEN_SMALL];
unsigned int ii;
if (!str) {
return airEnumUnknown(enm);
}
strCpy = airStrdup(str);
if (!enm->sense) {
airToLower(strCpy);
}
if (enm->strEqv) {
/* want strlen and not airStrlen here because the strEqv array
should be terminated by a non-null empty string */
for (ii=0; strlen(enm->strEqv[ii]); ii++) {
airStrcpy(test, AIR_STRLEN_SMALL, enm->strEqv[ii]);
if (!enm->sense) {
airToLower(test);
}
if (!strcmp(test, strCpy)) {
free(strCpy);
return enm->valEqv[ii];
}
}
} else {
/* enm->strEqv NULL */
for (ii=1; ii<=enm->M; ii++) {
airStrcpy(test, AIR_STRLEN_SMALL, enm->str[ii]);
if (!enm->sense) {
airToLower(test);
}
if (!strcmp(test, strCpy)) {
free(strCpy);
return enm->val ? enm->val[ii] : (int)ii; /* HEY scrutinize cast */
}
}
}
/* else we never matched a string */
free(strCpy);
return airEnumUnknown(enm);
}
int
_nrrdHestKernelSpecParse(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
NrrdKernelSpec **ksP;
char me[]="_nrrdHestKernelSpecParse", *nerr;
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
ksP = (NrrdKernelSpec **)ptr;
*ksP = nrrdKernelSpecNew();
if (nrrdKernelParse(&((*ksP)->kernel), (*ksP)->parm, str)) {
nerr = biffGetDone(NRRD);
airStrcpy(err, AIR_STRLEN_HUGE, nerr);
free(nerr);
return 1;
}
return 0;
}
int
_rvaHestLattSpecParse(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
static const char me[]="_rvaHestLattSpecParse";
rvaLattSpec **lspP;
char *perr;
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
lspP = (rvaLattSpec **)ptr;
*lspP = rvaLattSpecNew();
if (rvaLattSpecParse(*lspP, str)) {
perr = biffGetDone(RVA);
airStrcpy(err, AIR_STRLEN_HUGE, perr);
free(perr);
return 1;
}
return 0;
}
/*
******** airEnumFmtDesc()
**
** Formats a description line for one element "val" of airEnum "enm",
** and puts the result in a NEWLY ALLOCATED string which is the return
** of this function. The formatting is done via sprintf(), as governed
** by "fmt", which should contain to "%s" conversion sequences, the
** first for the string version "val", and the second for the
** description If "canon", then the canonical string representation
** will be used (the one in enm->str[]), otherwise the shortest string
** representation will be used (which differs from the canonical one
** when there is a strEqv[]/valEqv[] pair defining a shorter string)
*/
char *
airEnumFmtDesc(const airEnum *enm, int val, int canon, const char *fmt) {
const char *desc;
char *buff, ident[AIR_STRLEN_SMALL];
const char *_ident;
int i;
size_t len;
if (!(enm && enm->desc && fmt)) {
return airStrdup("(airEnumDesc: invalid args)");
}
if (airEnumValCheck(enm, val)) {
val = airEnumUnknown(enm);
}
_ident = airEnumStr(enm, val);
if (!canon && enm->strEqv) {
len = airStrlen(_ident);
for (i=0; airStrlen(enm->strEqv[i]); i++) {
if (val != enm->valEqv[i]) {
/* this isn't a string representing the value we care about */
continue;
}
if (airStrlen(enm->strEqv[i]) < len) {
/* this one is shorter */
len = airStrlen(enm->strEqv[i]);
_ident = enm->strEqv[i];
}
}
}
airStrcpy(ident, AIR_STRLEN_SMALL, _ident);
if (!enm->sense) {
airToLower(ident);
}
desc = enm->desc[_airEnumIndex(enm, val)];
buff = AIR_CALLOC(airStrlen(fmt) + airStrlen(ident) +
airStrlen(desc) + 1, char);
if (buff) {
sprintf(buff, fmt, ident, desc);
}
return buff;
}
int
_nrrdHestIterParse(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
char me[]="_nrrdHestIterParse", *nerr;
Nrrd *nrrd;
NrrdIter **iterP;
airArray *mop;
double val;
int ret;
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
iterP = (NrrdIter **)ptr;
mop = airMopNew();
*iterP = nrrdIterNew();
airMopAdd(mop, *iterP, (airMopper)nrrdIterNix, airMopOnError);
/* the challenge here is determining if a given string represents a
filename or a number. Obviously there are cases where it could
be both, so we'll assume its a filename first. Because: there
are different ways of writing the same number, such as "3" -->
"+3", "3.1" --> "3.10", so someone accidently using the file when
they mean to use the number has easy ways of changing the number
representation, since these trivial transformations will probably
not all result in valid filenames. Another problem is that one
really wants a general robust test to see if a given string is a
valid number representation AND NOTHING BUT THAT, and sscanf() is
not that test. In any case, if there are to be improved smarts
about this matter, they need to be implemented below and nowhere
else. */
nrrd = nrrdNew();
ret = nrrdLoad(nrrd, str, NULL);
if (!ret) {
/* first attempt at nrrdLoad() was SUCCESSFUL */
nrrdIterSetOwnNrrd(*iterP, nrrd);
} else {
/* so it didn't load as a nrrd- if its because fopen() failed,
then we'll try it as a number. If its for another reason,
then we complain */
nrrdNuke(nrrd);
if (2 != ret) {
/* it failed because of something besides the fopen(), so complain */
nerr = biffGetDone(NRRD);
airStrcpy(err, AIR_STRLEN_HUGE, nerr);
airMopError(mop); return 1;
} else {
/* fopen() failed, so it probably wasn't meant to be a filename */
free(biffGetDone(NRRD));
ret = airSingleSscanf(str, "%lf", &val);
if (_nrrdLooksLikeANumber(str)
|| (1 == ret && (!AIR_EXISTS(val)
|| AIR_ABS(AIR_PI - val) < 0.0001))) {
/* either it patently looks like a number, or,
it already parsed as a number and it is a special value */
if (1 == ret) {
nrrdIterSetValue(*iterP, val);
} else {
/* oh, this is bad. */
fprintf(stderr, "%s: PANIC, is it a number or not?", me);
exit(1);
}
} else {
/* it doesn't look like a number, but the fopen failed, so
we'll let it fail again and pass back the error messages */
if (nrrdLoad(nrrd = nrrdNew(), str, NULL)) {
nerr = biffGetDone(NRRD);
airStrcpy(err, AIR_STRLEN_HUGE, nerr);
airMopError(mop); return 1;
} else {
/* what the hell? */
fprintf(stderr, "%s: PANIC, is it a nrrd or not?", me);
exit(1);
}
}
}
}
airMopAdd(mop, iterP, (airMopper)airSetNull, airMopOnError);
airMopOkay(mop);
return 0;
}