int _marx_get_parameters (Param_File_Type *p, _Marx_Parameter_Table_Type *table) /*{{{*/
{
char *name;
int status;
char buf[PF_MAX_LINE_LEN];
while ((name = table->name) != NULL)
{
switch (table->type)
{
case PF_INTEGER_TYPE:
status = pf_get_integer (p, name, table->value);
break;
case PF_REAL_TYPE:
status = pf_get_double (p, name, table->value);
break;
case PF_BOOLEAN_TYPE:
status = pf_get_boolean (p, name, table->value);
break;
case PF_FILE_TYPE:
/* drop */
case PF_STRING_TYPE:
if (table->type == PF_STRING_TYPE)
status = pf_get_string (p, name, buf);
else status = pf_get_file (p, name, buf);
if (status != -1)
{
char *s = (char *) SLMALLOC (strlen (buf) + 1);
if (s == NULL)
{
marx_error ("Malloc error.");
return -1;
}
strcpy (s, buf);
*((char **)table->value) = s;
}
break;
default:
marx_error ("Unknown type");
return -1;
}
if (status == -1)
{
marx_error ("Requested parameter %s not found in parameter file.",
name);
return -1;
}
table++;
}
return 0;
}
SLFUTURE_VOID *SLdebug_malloc (unsigned long n)
{
char *p;
if ((p = (char *) SLMALLOC (n + 2 * Chunk)) == NULL) return NULL;
fixup ((unsigned char *) p, n, "MALLOC");
return (SLFUTURE_VOID *)(p + Chunk);
}
void *_JDMmalloc (unsigned long nbytes, char *err)
{
void *p;
p = SLMALLOC (nbytes);
if (p == NULL)
{
JDMath_Error = JDMATH_MALLOC_ERROR;
JDMmsg_error (err);
}
return p;
}
int JDMread_column_fdata (char *file, float **data, int *cindex, unsigned int n, unsigned int *num_read)
{
char buf[512];
unsigned int space = 1024;
unsigned int nread = 0;
int do_close;
unsigned int i;
#define MAX_COLUMNS 20
float dum[MAX_COLUMNS];
FILE *fp;
*num_read = 0;
if (n > MAX_COLUMNS)
{
JDMath_Error = JDMATH_INVALID_PARAMETER;
JDMmsg_error ("JDMread_column_fdata");
return -1;
}
if (file == NULL)
{
fp = stdin;
do_close = 0;
file = "<stdin>";
}
else
{
if (NULL == (fp = fopen (file, "r")))
{
JDMath_Error = JDMATH_FILE_OPEN_ERROR;
JDMmsg_error2 ("JDMread_column_fdata", file);
return -1;
}
do_close = 1;
}
/* initialize everything to NULL */
for (i = 0; i < n; i++) data[i] = NULL;
for (i = 0; i < n; i++)
{
float *ptr;
if (cindex[i] == 0) continue;
ptr = (float *) SLMALLOC (space * sizeof (float));
if (ptr == NULL) goto return_error;
data[i] = ptr;
}
while (NULL != fgets (buf, sizeof (buf) - 1, fp))
{
if ((int)n > sscanf (buf, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
dum+0, dum+1, dum+2, dum+3, dum+4,
dum+5, dum+6, dum+7, dum+8, dum+9,
dum+10, dum+11, dum+12, dum+13, dum+14,
dum+15, dum+16, dum+17, dum+18, dum+19
))
continue;
if (nread == space)
{
space += 1024;
for (i = 0; i < n; i++)
{
float *ptr;
if (cindex[i] == 0) continue;
ptr = (float *) SLREALLOC (data[i], space * sizeof (float));
if (ptr == NULL) goto return_error;
data[i] = ptr;
}
}
for (i = 0; i < n; i++)
{
if (cindex[i] == 0) continue;
data[i][nread] = dum[i];
}
nread++;
}
if (nread == 0)
{
JDMath_Error = JDMATH_CORRUPT_FILE_ERROR;
JDMmsg_error2 ("JDMread_column_fdata", file);
goto read_error;
}
if (file != NULL) fclose (fp);
*num_read = nread;
return 0;
return_error:
JDMath_Error = JDMATH_MALLOC_ERROR;
read_error:
if (do_close) fclose (fp);
JDMmsg_error2 ("JDMread_column_fdata", file);
for (i = 0; i < n; i++)
{
if (data[i] != NULL) SLFREE (data[i]);
}
return -1;
}
int jdfits_bintable_parse_headers (JDFits_Type *ft) /*{{{*/
{
JDFits_Header_Type *h = NULL;
JDFits_Keyword_Type *kwt = NULL;
JDFits_Bintable_Type *bt = NULL;
JDFits_Bintable_Field_Type *bft = NULL;
int tfields, i;
/* Check to make sure this is a bintable */
if ((ft == NULL) || (NULL == (h = ft->header)))
{
jdfits_error ("jdfits_bintable_parse_headers: header is NULL.");
return -1;
}
if (h->type == JDFITS_EXTENSION_HEADER)
{
if ((h->name != NULL) && !strcmp ((char *) h->name, "BINTABLE"))
h->type = JDFITS_BINTABLE_HEADER;
}
if (h->type != JDFITS_BINTABLE_HEADER)
{
jdfits_error ("jdfits_bintable_parse_headers: Not a BINTABLE header.");
return -1;
}
/* Check to make sure the header meets the other basic requirements. */
if ((h->bitpix != 8)
|| (h->naxis != 2)
|| (h->gcount != 1))
{
jdfits_error ("jdfits_bintable_parse_headers: Header does not meet bintable requirements.");
return -1;
}
if (h->ext.bintable != NULL)
return 0; /* already parsed */
/* Now look for the tfields header. */
if ((NULL == (kwt = jdfits_parse_keyword (h, "TFIELDS", JDFITS_INT_TYPE)))
|| ((tfields = kwt->v.ival) < 0) || (tfields > 999))
{
jdfits_error ("jdfits_bintable_parse_headers: Bad or missing TFIELDS entry.");
goto free_error;
}
if (NULL == (bt = (JDFits_Bintable_Type *) SLMALLOC (sizeof (JDFits_Bintable_Type))))
{
jdfits_error ("jdfits_bintable_parse_headers: Malloc Error.");
goto free_error;
}
memset ((char *) bt, 0, sizeof (JDFits_Bintable_Type));
if (0 != tfields)
{
bft = (JDFits_Bintable_Field_Type *) SLCALLOC (tfields, sizeof (JDFits_Bintable_Field_Type));
if (bft == NULL)
{
jdfits_error ("jdfits_bintable_parse_headers: Calloc Error.");
goto free_error;
}
}
bt->finfo = bft;
bt->tfields = tfields;
if (NULL != (kwt = jdfits_parse_keyword (h, "EXTNAME", JDFITS_STRING_TYPE)))
bt->extname = (char *) kwt->v.sval;
for (i = 1; i <= tfields; i++)
{
char buf[9], *b;
unsigned char ch;
unsigned int repeat, type, size;
char *fmt, *default_format;
JDFits_Bintable_Field_Type *bfti = bft + (i - 1);
sprintf (buf, "TFORM%d", i);
kwt = jdfits_parse_keyword (h, buf, JDFITS_STRING_TYPE);
if (kwt == NULL)
{
jdfits_error ("jdfits_bintable_parse_headers: Bad or missing %s entry.", buf);
goto free_error;
}
b = (char *) kwt->v.sval;
ch = *b;
/* Some files produced by ftools use spaces like: " 1J " */
while (ch == ' ')
{
b++;
ch = *b;
}
if (isdigit (ch) == 0)
repeat = 1;
else
{
repeat = 0;
while (((ch = (unsigned char) *b) != 0) && isdigit (ch))
{
repeat = 10 * repeat + (ch - '0');
b++;
}
}
bfti->repeat = repeat;
default_format = "% 16.9E";
type = 0;
pointer_type_label:
switch (ch)
{
case 'L':
type |= JDFITS_BOOL_TYPE;
size = 8;
fmt = "%d";
break;
case 'X':
switch (repeat)
{
/* FIXME: I need to use hex formats, but that requires
* proper parsing of the format string in the dump function.
*/
case 8:
type |= JDFITS_BYTE_TYPE;
bfti->repeat = 1;
size = 8;
fmt = "%d";
break;
case 16:
type |= JDFITS_INT16_TYPE;
bfti->repeat = 1;
size = 16;
fmt = JDFITS_FMT_16;
break;
case 32:
type |= JDFITS_INT32_TYPE;
bfti->repeat = 1;
size = 32;
fmt = JDFITS_FMT_32;
break;
default:
type |= JDFITS_BIT_TYPE;
size = 1;
fmt = "%X";
break;
}
break;
case 'B':
type |= JDFITS_BYTE_TYPE;
size = 8;
fmt = "%c";
break;
case 'I':
type |= JDFITS_INT16_TYPE;
size = 16;
fmt = JDFITS_FMT_16;
break;
case 'P': /* variable length array */
if (repeat > 1)
{
jdfits_error ("jdfits_bintable_parse_headers: The repeat count must be 0 or 1 for P type.");
goto free_error;
}
if (repeat) repeat = 2;
bfti->repeat = repeat;
b++;
ch = *b;
type = JDFITS_POINTER_FLAG;
goto pointer_type_label;
case 'J':
type |= JDFITS_INT32_TYPE;
size = 32;
fmt = JDFITS_FMT_32;
break;
case 'A':
type |= JDFITS_STRING_TYPE;
size = 8;
fmt = "%s";
break;
case 'E':
type |= JDFITS_FLOAT32_TYPE;
fmt = "% 15.7E";
size = 32;
break;
case 'D':
type |= JDFITS_FLOAT64_TYPE;
size = 64;
fmt = "% 16.9E";
break;
case 0:
ch = '0';
/* drop */
case 'C': /* complex */
case 'M': /* double precision complex */
default:
jdfits_error ("jdfits_bintable_parse_headers: Field type '%c' is not implemented. (%s)",
ch, buf);
goto free_error;
}
bfti->size = size;
bfti->type = type;
/* Now pick up the remaining indexed keywords. */
if (NULL == (kwt = bt_parse_index_kw (h, "TTYPE", i, JDFITS_STRING_TYPE)))
bfti->ttype = NULL;
else bfti->ttype = kwt->v.sval;
if (NULL == (kwt = bt_parse_index_kw (h, "TUNIT", i, JDFITS_STRING_TYPE)))
bfti->tunit = NULL;
else bfti->tunit = kwt->v.sval;
if (NULL == (kwt = bt_parse_index_kw (h, "TDIM", i, JDFITS_STRING_TYPE)))
bfti->tdim = NULL;
else bfti->tdim = kwt->v.sval;
if (NULL == (kwt = bt_parse_index_kw (h, "TNULL", i, JDFITS_INT_TYPE)))
bfti->tnull = 0;
else bfti->tnull = kwt->v.ival;
bfti->has_scaling = 0;
if (NULL == (kwt = bt_parse_index_kw (h, "TSCAL", i, JDFITS_FLOAT64_TYPE)))
{
bfti->tscal = 1.0;
}
else
{
bfti->tscal = kwt->v.dval;
bfti->has_scaling = 1;
}
if (NULL == (kwt = bt_parse_index_kw (h, "TZERO", i, JDFITS_FLOAT64_TYPE)))
bfti->tzero = 0.0;
else
{
bfti->tzero = kwt->v.dval;
bfti->has_scaling = 1;
}
if (NULL == (kwt = bt_parse_index_kw (h, "TCRPX", i, JDFITS_FLOAT64_TYPE)))
bfti->tcrpx = 0.0;
else
{
bfti->tcrpx = kwt->v.dval;
bfti->has_scaling = 1;
}
if (NULL == (kwt = bt_parse_index_kw (h, "TCRVL", i, JDFITS_FLOAT64_TYPE)))
bfti->tcrvl = 0.0;
else
{
bfti->tcrvl = kwt->v.dval;
bfti->has_scaling = 1;
}
if (NULL == (kwt = bt_parse_index_kw (h, "TCDLT", i, JDFITS_FLOAT64_TYPE)))
bfti->tcdlt = 1.0;
else
{
bfti->tcdlt = kwt->v.dval;
bfti->has_scaling = 1;
}
#if 0
/* We do not yet handled the unsigned int hack. So avoid float format */
if (bfti->has_scaling) fmt = default_format;
#endif
if ((NULL == (kwt = bt_parse_index_kw (h, "TDISP", i, JDFITS_STRING_TYPE)))
|| (-1 == jdfits_ffmt_to_cfmt (kwt->v.sval, bfti->tdisp)))
strcpy ((char *) bfti->tdisp, fmt);
}
h->ext.bintable = bt;
h->free_routine = free_bintable;
/* Now set up the remaining fields. Note that the positions of
* naxis1 and naxis2 are fixed.
*/
bt->naxis1 = h->keys[3].v.ival;
bt->naxis2 = h->keys[4].v.ival;
return 0;
/* Only get here if something goes wrong. Here all malloced items in this
* function are freed.
*/
free_error:
h->ext.bintable = NULL;
if (bt != NULL) SLFREE (bt);
if (bft != NULL) SLFREE (bft);
return -1;
}
