Indent qfits to GNU style, perhaps
parent
7621d31783
commit
db0415128c
File diff suppressed because it is too large
Load Diff
|
@ -66,14 +66,14 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
void * xmemory_malloc(size_t, const char *, int) ;
|
||||
void * xmemory_calloc(size_t, size_t, const char *, int) ;
|
||||
void * xmemory_realloc(void *, size_t, const char *, int) ;
|
||||
void xmemory_free(void *, const char *, int) ;
|
||||
char * xmemory_strdup(const char *, const char *, int) ;
|
||||
char * xmemory_falloc(char *, size_t, size_t *, const char *, int) ;
|
||||
void xmemory_fdealloc(void *, size_t, size_t, const char *, int) ;
|
||||
void *xmemory_malloc (size_t, const char *, int);
|
||||
void *xmemory_calloc (size_t, size_t, const char *, int);
|
||||
void *xmemory_realloc (void *, size_t, const char *, int);
|
||||
void xmemory_free (void *, const char *, int);
|
||||
char *xmemory_strdup (const char *, const char *, int);
|
||||
char *xmemory_falloc (char *, size_t, size_t *, const char *, int);
|
||||
void xmemory_fdealloc (void *, size_t, size_t, const char *, int);
|
||||
|
||||
void xmemory_status_(const char * filename, int lineno) ;
|
||||
void xmemory_status_ (const char *filename, int lineno);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -45,275 +45,307 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
void usage(char * pname) ;
|
||||
void parse_cmd_line(int, char **, int *, int *, int *) ;
|
||||
int dump_fits_filter(FILE *, int) ;
|
||||
int dump_fits(char *, int) ;
|
||||
char * rstrip(char *) ;
|
||||
void usage (char *pname);
|
||||
void parse_cmd_line (int, char **, int *, int *, int *);
|
||||
int dump_fits_filter (FILE *, int);
|
||||
int dump_fits (char *, int);
|
||||
char *rstrip (char *);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int xtnum ;
|
||||
int c_arg ;
|
||||
int filter ;
|
||||
int err ;
|
||||
int xtnum;
|
||||
int c_arg;
|
||||
int filter;
|
||||
int err;
|
||||
|
||||
/* No arguments prints out a usage message */
|
||||
if (argc<2) usage(argv[0]);
|
||||
/* No arguments prints out a usage message */
|
||||
if (argc < 2)
|
||||
usage (argv[0]);
|
||||
|
||||
/* Parse command-line options */
|
||||
parse_cmd_line(argc, argv, &xtnum, &filter, &c_arg);
|
||||
/* Parse command-line options */
|
||||
parse_cmd_line (argc, argv, &xtnum, &filter, &c_arg);
|
||||
|
||||
/* Filter mode: process data received from stdin */
|
||||
if (filter) {
|
||||
/* Filter mode: process data received from stdin */
|
||||
if (filter)
|
||||
{
|
||||
#if HAVE_ZLIB
|
||||
printf("filter mode does not support gzipped files\n");
|
||||
printf("use: gunzip -c file.fits | dfits -\n");
|
||||
return 1 ;
|
||||
printf ("filter mode does not support gzipped files\n");
|
||||
printf ("use: gunzip -c file.fits | dfits -\n");
|
||||
return 1;
|
||||
#else
|
||||
return dump_fits_filter(stdin, xtnum);
|
||||
return dump_fits_filter (stdin, xtnum);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Normal mode: loop on all file names given on command-line */
|
||||
err = 0 ;
|
||||
while (c_arg < argc) {
|
||||
err += dump_fits(argv[c_arg], xtnum);
|
||||
c_arg++;
|
||||
}
|
||||
return err ; /* Returns number of errors during process */
|
||||
/* Normal mode: loop on all file names given on command-line */
|
||||
err = 0;
|
||||
while (c_arg < argc)
|
||||
{
|
||||
err += dump_fits (argv[c_arg], xtnum);
|
||||
c_arg++;
|
||||
}
|
||||
return err; /* Returns number of errors during process */
|
||||
}
|
||||
|
||||
void usage(char * pname)
|
||||
void
|
||||
usage (char *pname)
|
||||
{
|
||||
printf(
|
||||
"\n\n"
|
||||
"usage: %s [-x xtnum] <list of FITS files>\n"
|
||||
"usage: %s [-x xtnum] -\n"
|
||||
"\n"
|
||||
"The former version expects file names.\n"
|
||||
"The latter expects data coming in from stdin.\n"
|
||||
"\n"
|
||||
"-x xtnum specifies the extension header to print\n"
|
||||
"-x 0 specifies main header + all extensions\n"
|
||||
"\n\n",
|
||||
pname, pname);
|
||||
printf ("\n\n"
|
||||
"usage: %s [-x xtnum] <list of FITS files>\n"
|
||||
"usage: %s [-x xtnum] -\n"
|
||||
"\n"
|
||||
"The former version expects file names.\n"
|
||||
"The latter expects data coming in from stdin.\n"
|
||||
"\n"
|
||||
"-x xtnum specifies the extension header to print\n"
|
||||
"-x 0 specifies main header + all extensions\n"
|
||||
"\n\n", pname, pname);
|
||||
|
||||
#if HAVE_ZLIB
|
||||
printf(
|
||||
"This program was compiled against zlib %s\n"
|
||||
"This means you can use it with gzipped FITS files\n"
|
||||
"as with uncompressed FITS files.\n"
|
||||
"NB: this does not apply to the '-' option (input from stdin)\n"
|
||||
"\n\n", ZLIB_VERSION);
|
||||
printf ("This program was compiled against zlib %s\n"
|
||||
"This means you can use it with gzipped FITS files\n"
|
||||
"as with uncompressed FITS files.\n"
|
||||
"NB: this does not apply to the '-' option (input from stdin)\n"
|
||||
"\n\n", ZLIB_VERSION);
|
||||
#endif
|
||||
exit(1) ;
|
||||
exit (1);
|
||||
}
|
||||
|
||||
void parse_cmd_line(
|
||||
int argc,
|
||||
char ** argv,
|
||||
int * xtnum,
|
||||
int * filter,
|
||||
int * c_arg)
|
||||
void
|
||||
parse_cmd_line (int argc, char **argv, int *xtnum, int *filter, int *c_arg)
|
||||
{
|
||||
*filter = 0 ;
|
||||
*xtnum = -1 ;
|
||||
*c_arg = argc-1 ;
|
||||
*filter = 0;
|
||||
*xtnum = -1;
|
||||
*c_arg = argc - 1;
|
||||
|
||||
/* If '-' is on the command-line, it must be the last argument */
|
||||
if (!strcmp(argv[argc-1], "-")) *filter = 1 ;
|
||||
/* If -x xtnum is on the command-line, it must be the first two arguments */
|
||||
if (!strcmp(argv[1], "-x")) {
|
||||
*xtnum = atoi(argv[2]);
|
||||
*c_arg = 3 ;
|
||||
} else {
|
||||
*c_arg = 1 ;
|
||||
}
|
||||
return ;
|
||||
/* If '-' is on the command-line, it must be the last argument */
|
||||
if (!strcmp (argv[argc - 1], "-"))
|
||||
*filter = 1;
|
||||
/* If -x xtnum is on the command-line, it must be the first two arguments */
|
||||
if (!strcmp (argv[1], "-x"))
|
||||
{
|
||||
*xtnum = atoi (argv[2]);
|
||||
*c_arg = 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
*c_arg = 1;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* Strip off all blank characters in a string from the right-side. */
|
||||
char * rstrip(char * s)
|
||||
char *
|
||||
rstrip (char *s)
|
||||
{
|
||||
int len ;
|
||||
if (s==NULL) return s ;
|
||||
len = strlen(s);
|
||||
if (len<1) return s ;
|
||||
len -- ;
|
||||
while (s[len]== ' ') {
|
||||
s[len]=(char)0 ;
|
||||
len --;
|
||||
if (len<0) break ;
|
||||
int len;
|
||||
if (s == NULL)
|
||||
return s;
|
||||
len = strlen (s);
|
||||
if (len < 1)
|
||||
return s;
|
||||
len--;
|
||||
while (s[len] == ' ')
|
||||
{
|
||||
s[len] = (char) 0;
|
||||
len--;
|
||||
if (len < 0)
|
||||
break;
|
||||
}
|
||||
return s ;
|
||||
return s;
|
||||
}
|
||||
|
||||
/* Dump the requested header (main or extension) from a filename. */
|
||||
int dump_fits(char * name, int xtnum)
|
||||
int
|
||||
dump_fits (char *name, int xtnum)
|
||||
{
|
||||
FILE * in ;
|
||||
int err ;
|
||||
FILE *in;
|
||||
int err;
|
||||
|
||||
if ((in=fopen(name, "r"))==NULL) {
|
||||
fprintf(stderr, "error: cannot open file [%s]\n", name);
|
||||
return 1 ;
|
||||
}
|
||||
if ((in = fopen (name, "r")) == NULL)
|
||||
{
|
||||
fprintf (stderr, "error: cannot open file [%s]\n", name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
printf("====> file %s (main) <====\n", name) ;
|
||||
err = dump_fits_filter(in, xtnum);
|
||||
fclose(in);
|
||||
return err ;
|
||||
printf ("====> file %s (main) <====\n", name);
|
||||
err = dump_fits_filter (in, xtnum);
|
||||
fclose (in);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Dump the requested header (main or extension) from a FILE * */
|
||||
int dump_fits_filter(FILE * in, int xtnum)
|
||||
int
|
||||
dump_fits_filter (FILE * in, int xtnum)
|
||||
{
|
||||
int n_xt ;
|
||||
char buf[LGTH+1];
|
||||
int err ;
|
||||
int data_bytes, naxis ;
|
||||
char * read_val ;
|
||||
int skip_blocks ;
|
||||
int seeked ;
|
||||
int n_xt;
|
||||
char buf[LGTH + 1];
|
||||
int err;
|
||||
int data_bytes, naxis;
|
||||
char *read_val;
|
||||
int skip_blocks;
|
||||
int seeked;
|
||||
|
||||
/* Try getting the first 80 chars */
|
||||
memset(buf, 0, LGTH+1);
|
||||
if (fread(buf, sizeof(char), LGTH, in)!=LGTH) {
|
||||
fprintf(stderr, "error reading input\n");
|
||||
return 1;
|
||||
}
|
||||
/* Check that it is indeed FITS */
|
||||
if (strncmp(buf, MAGIC, strlen(MAGIC))) {
|
||||
fprintf(stderr, "not a FITS file\n");
|
||||
return 1 ;
|
||||
}
|
||||
naxis = 0 ;
|
||||
data_bytes = 1 ;
|
||||
if (xtnum<1) {
|
||||
/* Output main header */
|
||||
printf("%s\n", rstrip(buf));
|
||||
data_bytes = 1 ;
|
||||
naxis = 0 ;
|
||||
while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
|
||||
printf("%s\n", rstrip(buf));
|
||||
/* Look for BITPIX keyword */
|
||||
if (buf[0]=='B' &&
|
||||
buf[1]=='I' &&
|
||||
buf[2]=='T' &&
|
||||
buf[3]=='P' &&
|
||||
buf[4]=='I' &&
|
||||
buf[5]=='X' &&
|
||||
buf[6]==' ') {
|
||||
read_val = qfits_getvalue(buf);
|
||||
data_bytes *= (int)atoi(read_val) / 8 ;
|
||||
if (data_bytes<0) data_bytes *= -1 ;
|
||||
} else
|
||||
/* Look for NAXIS keyword */
|
||||
if (buf[0]=='N' &&
|
||||
buf[1]=='A' &&
|
||||
buf[2]=='X' &&
|
||||
buf[3]=='I' &&
|
||||
buf[4]=='S') {
|
||||
/* Try getting the first 80 chars */
|
||||
memset (buf, 0, LGTH + 1);
|
||||
if (fread (buf, sizeof (char), LGTH, in) != LGTH)
|
||||
{
|
||||
fprintf (stderr, "error reading input\n");
|
||||
return 1;
|
||||
}
|
||||
/* Check that it is indeed FITS */
|
||||
if (strncmp (buf, MAGIC, strlen (MAGIC)))
|
||||
{
|
||||
fprintf (stderr, "not a FITS file\n");
|
||||
return 1;
|
||||
}
|
||||
naxis = 0;
|
||||
data_bytes = 1;
|
||||
if (xtnum < 1)
|
||||
{
|
||||
/* Output main header */
|
||||
printf ("%s\n", rstrip (buf));
|
||||
data_bytes = 1;
|
||||
naxis = 0;
|
||||
while ((err = fread (buf, sizeof (char), LGTH, in)) == LGTH)
|
||||
{
|
||||
printf ("%s\n", rstrip (buf));
|
||||
/* Look for BITPIX keyword */
|
||||
if (buf[0] == 'B' &&
|
||||
buf[1] == 'I' &&
|
||||
buf[2] == 'T' &&
|
||||
buf[3] == 'P' &&
|
||||
buf[4] == 'I' && buf[5] == 'X' && buf[6] == ' ')
|
||||
{
|
||||
read_val = qfits_getvalue (buf);
|
||||
data_bytes *= (int) atoi (read_val) / 8;
|
||||
if (data_bytes < 0)
|
||||
data_bytes *= -1;
|
||||
}
|
||||
else
|
||||
/* Look for NAXIS keyword */
|
||||
if (buf[0] == 'N' &&
|
||||
buf[1] == 'A' &&
|
||||
buf[2] == 'X' && buf[3] == 'I' && buf[4] == 'S')
|
||||
{
|
||||
|
||||
if (buf[5]==' ') {
|
||||
/* NAXIS keyword */
|
||||
read_val = qfits_getvalue(buf);
|
||||
naxis = (int)atoi(read_val);
|
||||
} else {
|
||||
/* NAXIS?? keyword (axis size) */
|
||||
read_val = qfits_getvalue(buf);
|
||||
data_bytes *= (int)atoi(read_val);
|
||||
}
|
||||
} else
|
||||
/* Look for END keyword */
|
||||
if (buf[0]=='E' &&
|
||||
buf[1]=='N' &&
|
||||
buf[2]=='D') {
|
||||
break ;
|
||||
}
|
||||
if (buf[5] == ' ')
|
||||
{
|
||||
/* NAXIS keyword */
|
||||
read_val = qfits_getvalue (buf);
|
||||
naxis = (int) atoi (read_val);
|
||||
}
|
||||
if (err!=LGTH) return 1 ;
|
||||
}
|
||||
if (xtnum<0) return 0 ;
|
||||
|
||||
n_xt=0 ;
|
||||
while (1) {
|
||||
/*
|
||||
* Skip the previous data section if pixels were declared
|
||||
*/
|
||||
if (naxis>0) {
|
||||
/* Skip as many blocks as there are declared pixels */
|
||||
skip_blocks = data_bytes/BLOCK_SIZE ;
|
||||
if ((data_bytes % BLOCK_SIZE)!=0) skip_blocks ++ ;
|
||||
seeked = fseek(in, skip_blocks*BLOCK_SIZE, SEEK_CUR);
|
||||
if (seeked<0) return -1 ;
|
||||
}
|
||||
|
||||
/* Look for next XTENSION keyword */
|
||||
while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
|
||||
if (buf[0]=='X' &&
|
||||
buf[1]=='T' &&
|
||||
buf[2]=='E' &&
|
||||
buf[3]=='N' &&
|
||||
buf[4]=='S' &&
|
||||
buf[5]=='I' &&
|
||||
buf[6]=='O' &&
|
||||
buf[7]=='N') break ;
|
||||
else
|
||||
{
|
||||
/* NAXIS?? keyword (axis size) */
|
||||
read_val = qfits_getvalue (buf);
|
||||
data_bytes *= (int) atoi (read_val);
|
||||
}
|
||||
if (err==0) break ;
|
||||
if (err!=LGTH) return 1 ;
|
||||
|
||||
n_xt++ ;
|
||||
|
||||
if (xtnum==0 || xtnum==n_xt) {
|
||||
printf("===> xtension %d\n", n_xt) ;
|
||||
printf("%s\n", rstrip(buf));
|
||||
}
|
||||
|
||||
data_bytes = 1 ;
|
||||
naxis = 0 ;
|
||||
while ((err=fread(buf, sizeof(char), LGTH, in))==LGTH) {
|
||||
if (xtnum==0 || xtnum==n_xt) printf("%s\n", rstrip(buf));
|
||||
|
||||
/* Look for BITPIX keyword */
|
||||
if (buf[0]=='B' &&
|
||||
buf[1]=='I' &&
|
||||
buf[2]=='T' &&
|
||||
buf[3]=='P' &&
|
||||
buf[4]=='I' &&
|
||||
buf[5]=='X' &&
|
||||
buf[6]==' ') {
|
||||
read_val = qfits_getvalue(buf);
|
||||
data_bytes *= (int)atoi(read_val) / 8 ;
|
||||
if (data_bytes<0) data_bytes *= -1 ;
|
||||
} else
|
||||
/* Look for NAXIS keyword */
|
||||
if (buf[0]=='N' &&
|
||||
buf[1]=='A' &&
|
||||
buf[2]=='X' &&
|
||||
buf[3]=='I' &&
|
||||
buf[4]=='S') {
|
||||
|
||||
if (buf[5]==' ') {
|
||||
/* NAXIS keyword */
|
||||
read_val = qfits_getvalue(buf);
|
||||
naxis = (int)atoi(read_val);
|
||||
} else {
|
||||
/* NAXIS?? keyword (axis size) */
|
||||
read_val = qfits_getvalue(buf);
|
||||
data_bytes *= (int)atoi(read_val);
|
||||
}
|
||||
} else
|
||||
/* Look for END keyword */
|
||||
if (buf[0]=='E' &&
|
||||
buf[1]=='N' &&
|
||||
buf[2]=='D') break ;
|
||||
}
|
||||
if (n_xt==xtnum) break ;
|
||||
}
|
||||
else
|
||||
/* Look for END keyword */
|
||||
if (buf[0] == 'E' && buf[1] == 'N' && buf[2] == 'D')
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
return 0 ;
|
||||
if (err != LGTH)
|
||||
return 1;
|
||||
}
|
||||
if (xtnum < 0)
|
||||
return 0;
|
||||
|
||||
n_xt = 0;
|
||||
while (1)
|
||||
{
|
||||
/*
|
||||
* Skip the previous data section if pixels were declared
|
||||
*/
|
||||
if (naxis > 0)
|
||||
{
|
||||
/* Skip as many blocks as there are declared pixels */
|
||||
skip_blocks = data_bytes / BLOCK_SIZE;
|
||||
if ((data_bytes % BLOCK_SIZE) != 0)
|
||||
skip_blocks++;
|
||||
seeked = fseek (in, skip_blocks * BLOCK_SIZE, SEEK_CUR);
|
||||
if (seeked < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Look for next XTENSION keyword */
|
||||
while ((err = fread (buf, sizeof (char), LGTH, in)) == LGTH)
|
||||
{
|
||||
if (buf[0] == 'X' &&
|
||||
buf[1] == 'T' &&
|
||||
buf[2] == 'E' &&
|
||||
buf[3] == 'N' &&
|
||||
buf[4] == 'S' &&
|
||||
buf[5] == 'I' && buf[6] == 'O' && buf[7] == 'N')
|
||||
break;
|
||||
}
|
||||
if (err == 0)
|
||||
break;
|
||||
if (err != LGTH)
|
||||
return 1;
|
||||
|
||||
n_xt++;
|
||||
|
||||
if (xtnum == 0 || xtnum == n_xt)
|
||||
{
|
||||
printf ("===> xtension %d\n", n_xt);
|
||||
printf ("%s\n", rstrip (buf));
|
||||
}
|
||||
|
||||
data_bytes = 1;
|
||||
naxis = 0;
|
||||
while ((err = fread (buf, sizeof (char), LGTH, in)) == LGTH)
|
||||
{
|
||||
if (xtnum == 0 || xtnum == n_xt)
|
||||
printf ("%s\n", rstrip (buf));
|
||||
|
||||
/* Look for BITPIX keyword */
|
||||
if (buf[0] == 'B' &&
|
||||
buf[1] == 'I' &&
|
||||
buf[2] == 'T' &&
|
||||
buf[3] == 'P' &&
|
||||
buf[4] == 'I' && buf[5] == 'X' && buf[6] == ' ')
|
||||
{
|
||||
read_val = qfits_getvalue (buf);
|
||||
data_bytes *= (int) atoi (read_val) / 8;
|
||||
if (data_bytes < 0)
|
||||
data_bytes *= -1;
|
||||
}
|
||||
else
|
||||
/* Look for NAXIS keyword */
|
||||
if (buf[0] == 'N' &&
|
||||
buf[1] == 'A' &&
|
||||
buf[2] == 'X' && buf[3] == 'I' && buf[4] == 'S')
|
||||
{
|
||||
|
||||
if (buf[5] == ' ')
|
||||
{
|
||||
/* NAXIS keyword */
|
||||
read_val = qfits_getvalue (buf);
|
||||
naxis = (int) atoi (read_val);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* NAXIS?? keyword (axis size) */
|
||||
read_val = qfits_getvalue (buf);
|
||||
data_bytes *= (int) atoi (read_val);
|
||||
}
|
||||
}
|
||||
else
|
||||
/* Look for END keyword */
|
||||
if (buf[0] == 'E' && buf[1] == 'N' && buf[2] == 'D')
|
||||
break;
|
||||
}
|
||||
if (n_xt == xtnum)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
1004
qfits/main/dtfits.c
1004
qfits/main/dtfits.c
File diff suppressed because it is too large
Load Diff
|
@ -37,132 +37,149 @@
|
|||
* Swap pixels between position p1 and p2, regardless of the pixel
|
||||
* type and endian-ness of the local host.
|
||||
*/
|
||||
static void swap_pix(char * buf, int p1, int p2, int psize)
|
||||
static void
|
||||
swap_pix (char *buf, int p1, int p2, int psize)
|
||||
{
|
||||
int i ;
|
||||
char c ;
|
||||
int i;
|
||||
char c;
|
||||
|
||||
for (i=0 ; i<psize ; i++) {
|
||||
c = buf[p1+i] ;
|
||||
buf[p1+i] = buf[p2+i];
|
||||
buf[p2+i] = c ;
|
||||
}
|
||||
for (i = 0; i < psize; i++)
|
||||
{
|
||||
c = buf[p1 + i];
|
||||
buf[p1 + i] = buf[p2 + i];
|
||||
buf[p2 + i] = c;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Main processing function. It expects one only file name
|
||||
* and will flip pixels on the input frame.
|
||||
*/
|
||||
static int fits_flip(char * pname, char * filename)
|
||||
static int
|
||||
fits_flip (char *pname, char *filename)
|
||||
{
|
||||
char * sval ;
|
||||
int dstart;
|
||||
int lx, ly ;
|
||||
int bpp ;
|
||||
int i, j ;
|
||||
char * buf ;
|
||||
char * fbuf ;
|
||||
int psize;
|
||||
struct stat fileinfo ;
|
||||
int fd ;
|
||||
char *sval;
|
||||
int dstart;
|
||||
int lx, ly;
|
||||
int bpp;
|
||||
int i, j;
|
||||
char *buf;
|
||||
char *fbuf;
|
||||
int psize;
|
||||
struct stat fileinfo;
|
||||
int fd;
|
||||
|
||||
printf("%s: processing %s\n", pname, filename);
|
||||
printf ("%s: processing %s\n", pname, filename);
|
||||
|
||||
if (stat(filename, &fileinfo)!=0) {
|
||||
return -1 ;
|
||||
}
|
||||
if (fileinfo.st_size<1) {
|
||||
printf("cannot stat file\n");
|
||||
return -1 ;
|
||||
}
|
||||
if (stat (filename, &fileinfo) != 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
if (fileinfo.st_size < 1)
|
||||
{
|
||||
printf ("cannot stat file\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Retrieve image attributes */
|
||||
if (is_fits_file(filename)!=1) {
|
||||
printf("not a FITS file\n");
|
||||
return -1 ;
|
||||
}
|
||||
/* Retrieve image attributes */
|
||||
if (is_fits_file (filename) != 1)
|
||||
{
|
||||
printf ("not a FITS file\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
sval = qfits_query_hdr(filename, "NAXIS1");
|
||||
if (sval==NULL) {
|
||||
printf("cannot read NAXIS1\n");
|
||||
return -1 ;
|
||||
}
|
||||
lx = atoi(sval);
|
||||
sval = qfits_query_hdr(filename, "NAXIS2");
|
||||
if (sval==NULL) {
|
||||
printf("cannot read NAXIS2\n");
|
||||
return -1 ;
|
||||
}
|
||||
ly = atoi(sval);
|
||||
sval = qfits_query_hdr(filename, "BITPIX");
|
||||
if (sval==NULL) {
|
||||
printf("cannot read BITPIX\n");
|
||||
return -1 ;
|
||||
}
|
||||
bpp = atoi(sval);
|
||||
sval = qfits_query_hdr (filename, "NAXIS1");
|
||||
if (sval == NULL)
|
||||
{
|
||||
printf ("cannot read NAXIS1\n");
|
||||
return -1;
|
||||
}
|
||||
lx = atoi (sval);
|
||||
sval = qfits_query_hdr (filename, "NAXIS2");
|
||||
if (sval == NULL)
|
||||
{
|
||||
printf ("cannot read NAXIS2\n");
|
||||
return -1;
|
||||
}
|
||||
ly = atoi (sval);
|
||||
sval = qfits_query_hdr (filename, "BITPIX");
|
||||
if (sval == NULL)
|
||||
{
|
||||
printf ("cannot read BITPIX\n");
|
||||
return -1;
|
||||
}
|
||||
bpp = atoi (sval);
|
||||
|
||||
psize = bpp/8 ;
|
||||
if (psize<0) psize=-psize ;
|
||||
psize = bpp / 8;
|
||||
if (psize < 0)
|
||||
psize = -psize;
|
||||
|
||||
/* Retrieve start of first data section */
|
||||
if (qfits_get_hdrinfo(filename, 0, &dstart, NULL)!=0) {
|
||||
printf("reading header information\n");
|
||||
return -1 ;
|
||||
}
|
||||
/* Retrieve start of first data section */
|
||||
if (qfits_get_hdrinfo (filename, 0, &dstart, NULL) != 0)
|
||||
{
|
||||
printf ("reading header information\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Map the input file in read/write mode (input file is modified) */
|
||||
if ((fd=open(filename, O_RDWR))==-1) {
|
||||
perror("open");
|
||||
printf("reading file\n");
|
||||
return -1 ;
|
||||
}
|
||||
fbuf = (char*)mmap(0,
|
||||
fileinfo.st_size,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
fd,
|
||||
0);
|
||||
if (fbuf==(char*)-1) {
|
||||
perror("mmap");
|
||||
printf("mapping file\n");
|
||||
return -1 ;
|
||||
}
|
||||
buf = fbuf + dstart ;
|
||||
/* Map the input file in read/write mode (input file is modified) */
|
||||
if ((fd = open (filename, O_RDWR)) == -1)
|
||||
{
|
||||
perror ("open");
|
||||
printf ("reading file\n");
|
||||
return -1;
|
||||
}
|
||||
fbuf = (char *) mmap (0,
|
||||
fileinfo.st_size,
|
||||
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
if (fbuf == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
printf ("mapping file\n");
|
||||
return -1;
|
||||
}
|
||||
buf = fbuf + dstart;
|
||||
|
||||
/* Double loop */
|
||||
for (j=0 ; j<ly ; j++) {
|
||||
for (i=0 ; i<lx/2 ; i++) {
|
||||
/* Swap bytes */
|
||||
swap_pix(buf, i*psize, (lx-i-1)*psize, psize);
|
||||
}
|
||||
buf += lx * psize ;
|
||||
/* Double loop */
|
||||
for (j = 0; j < ly; j++)
|
||||
{
|
||||
for (i = 0; i < lx / 2; i++)
|
||||
{
|
||||
/* Swap bytes */
|
||||
swap_pix (buf, i * psize, (lx - i - 1) * psize, psize);
|
||||
}
|
||||
if (munmap(fbuf, fileinfo.st_size)!=0) {
|
||||
printf("unmapping file\n");
|
||||
return -1 ;
|
||||
}
|
||||
return 0 ;
|
||||
buf += lx * psize;
|
||||
}
|
||||
if (munmap (fbuf, fileinfo.st_size) != 0)
|
||||
{
|
||||
printf ("unmapping file\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char * argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int i ;
|
||||
int err ;
|
||||
int i;
|
||||
int err;
|
||||
|
||||
if (argc<2) {
|
||||
printf("use: %s <list of FITS files...>\n", argv[0]);
|
||||
return 1 ;
|
||||
}
|
||||
err=0 ;
|
||||
for (i=1 ; i<argc ; i++) {
|
||||
err += fits_flip(argv[0], argv[i]) ;
|
||||
}
|
||||
if (err>0) {
|
||||
fprintf(stderr, "%s: %d error(s) occurred\n", argv[0], err);
|
||||
return -1 ;
|
||||
}
|
||||
return 0 ;
|
||||
if (argc < 2)
|
||||
{
|
||||
printf ("use: %s <list of FITS files...>\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
err = 0;
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
err += fits_flip (argv[0], argv[i]);
|
||||
}
|
||||
if (err > 0)
|
||||
{
|
||||
fprintf (stderr, "%s: %d error(s) occurred\n", argv[0], err);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -33,31 +33,33 @@
|
|||
-----------------------------------------------------------------------------*/
|
||||
|
||||
/* Frame informations needed to classify it */
|
||||
typedef struct _framei {
|
||||
char * name ;
|
||||
char * tplid ;
|
||||
char * origfile ;
|
||||
int expno ;
|
||||
int nexp ;
|
||||
typedef struct _framei
|
||||
{
|
||||
char *name;
|
||||
char *tplid;
|
||||
char *origfile;
|
||||
int expno;
|
||||
int nexp;
|
||||
|
||||
struct _framei * next ;
|
||||
} framei ;
|
||||
struct _framei *next;
|
||||
} framei;
|
||||
|
||||
/* Frame queue: is mostly a pointer to a list of frame information objects */
|
||||
typedef struct _frameq {
|
||||
framei * first ;
|
||||
int n ;
|
||||
} frameq ;
|
||||
typedef struct _frameq
|
||||
{
|
||||
framei *first;
|
||||
int n;
|
||||
} frameq;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Global variables
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
/* List of strings to identify unwanted templates. */
|
||||
char * tpl_filter[] = {
|
||||
"_acq_",
|
||||
"_CheckAoCorrection",
|
||||
NULL
|
||||
char *tpl_filter[] = {
|
||||
"_acq_",
|
||||
"_CheckAoCorrection",
|
||||
NULL
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -71,43 +73,56 @@ char * tpl_filter[] = {
|
|||
@return A newly allocated framei obj. NULL in error case
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static framei * framei_new(char * filename)
|
||||
static framei *
|
||||
framei_new (char *filename)
|
||||
{
|
||||
framei * fi ;
|
||||
char * sval ;
|
||||
char * sval2 ;
|
||||
int i ;
|
||||
framei *fi;
|
||||
char *sval;
|
||||
char *sval2;
|
||||
int i;
|
||||
|
||||
fi = malloc(sizeof(framei));
|
||||
fi->name = strdup(filename);
|
||||
sval = qfits_query_hdr(filename, "tpl.id");
|
||||
if (sval!=NULL) {
|
||||
/* Filter out unwanted template IDs */
|
||||
i=0 ;
|
||||
while (tpl_filter[i]!=NULL) {
|
||||
if (strstr(sval, tpl_filter[i])!=NULL) return NULL ;
|
||||
i++ ;
|
||||
}
|
||||
fi->tplid = strdup(qfits_pretty_string(sval)) ;
|
||||
} else {
|
||||
fi->tplid = NULL ;
|
||||
fi = malloc (sizeof (framei));
|
||||
fi->name = strdup (filename);
|
||||
sval = qfits_query_hdr (filename, "tpl.id");
|
||||
if (sval != NULL)
|
||||
{
|
||||
/* Filter out unwanted template IDs */
|
||||
i = 0;
|
||||
while (tpl_filter[i] != NULL)
|
||||
{
|
||||
if (strstr (sval, tpl_filter[i]) != NULL)
|
||||
return NULL;
|
||||
i++;
|
||||
}
|
||||
fi->tplid = strdup (qfits_pretty_string (sval));
|
||||
}
|
||||
sval = qfits_query_hdr(filename, "origfile");
|
||||
if (sval!=NULL) {
|
||||
sval2 = qfits_pretty_string(sval) ;
|
||||
fi->origfile = strdup(qfits_get_root_name(sval2)) ;
|
||||
} else {
|
||||
fi->origfile = NULL ;
|
||||
else
|
||||
{
|
||||
fi->tplid = NULL;
|
||||
}
|
||||
sval = qfits_query_hdr(filename, "tpl.expno");
|
||||
if (sval!=NULL) fi->expno = (int)atoi(sval);
|
||||
else fi->expno = -1 ;
|
||||
sval = qfits_query_hdr(filename, "tpl.nexp");
|
||||
if (sval!=NULL) fi->nexp = (int)atoi(sval);
|
||||
else fi->nexp = -1 ;
|
||||
sval = qfits_query_hdr (filename, "origfile");
|
||||
if (sval != NULL)
|
||||
{
|
||||
sval2 = qfits_pretty_string (sval);
|
||||
fi->origfile = strdup (qfits_get_root_name (sval2));
|
||||
}
|
||||
else
|
||||
{
|
||||
fi->origfile = NULL;
|
||||
}
|
||||
sval = qfits_query_hdr (filename, "tpl.expno");
|
||||
if (sval != NULL)
|
||||
fi->expno = (int) atoi (sval);
|
||||
else
|
||||
fi->expno = -1;
|
||||
sval = qfits_query_hdr (filename, "tpl.nexp");
|
||||
if (sval != NULL)
|
||||
fi->nexp = (int) atoi (sval);
|
||||
else
|
||||
fi->nexp = -1;
|
||||
|
||||
fi->next = NULL ;
|
||||
return fi ;
|
||||
fi->next = NULL;
|
||||
return fi;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -116,18 +131,22 @@ static framei * framei_new(char * filename)
|
|||
@param fi Object to delete
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void framei_del(framei * fi)
|
||||
static void
|
||||
framei_del (framei * fi)
|
||||
{
|
||||
if (fi==NULL) return ;
|
||||
if (fi->name!=NULL)
|
||||
free(fi->name);
|
||||
if (fi->tplid!=NULL) {
|
||||
free(fi->tplid);
|
||||
if (fi == NULL)
|
||||
return;
|
||||
if (fi->name != NULL)
|
||||
free (fi->name);
|
||||
if (fi->tplid != NULL)
|
||||
{
|
||||
free (fi->tplid);
|
||||
}
|
||||
if (fi->origfile!=NULL) {
|
||||
free(fi->origfile);
|
||||
if (fi->origfile != NULL)
|
||||
{
|
||||
free (fi->origfile);
|
||||
}
|
||||
free(fi);
|
||||
free (fi);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -136,14 +155,15 @@ static void framei_del(framei * fi)
|
|||
@return A newly allocated empty frameq object
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
frameq * frameq_new(void)
|
||||
frameq *
|
||||
frameq_new (void)
|
||||
{
|
||||
frameq * fq ;
|
||||
frameq *fq;
|
||||
|
||||
fq = malloc(sizeof(frameq));
|
||||
fq->first = NULL ;
|
||||
fq->n = 0 ;
|
||||
return fq ;
|
||||
fq = malloc (sizeof (frameq));
|
||||
fq->first = NULL;
|
||||
fq->n = 0;
|
||||
return fq;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -152,21 +172,24 @@ frameq * frameq_new(void)
|
|||
@param fq The object to delete
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void frameq_del(frameq * fq)
|
||||
void
|
||||
frameq_del (frameq * fq)
|
||||
{
|
||||
framei * fi ;
|
||||
framei * fin ;
|
||||
framei *fi;
|
||||
framei *fin;
|
||||
|
||||
if (fq==NULL) return ;
|
||||
if (fq == NULL)
|
||||
return;
|
||||
|
||||
fi = fq->first ;
|
||||
while (fi!=NULL) {
|
||||
fin = fi->next ;
|
||||
framei_del(fi);
|
||||
fi = fin ;
|
||||
fi = fq->first;
|
||||
while (fi != NULL)
|
||||
{
|
||||
fin = fi->next;
|
||||
framei_del (fi);
|
||||
fi = fin;
|
||||
}
|
||||
free(fq);
|
||||
return ;
|
||||
free (fq);
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -176,28 +199,31 @@ void frameq_del(frameq * fq)
|
|||
@param filename The file to append name
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void frameq_append(frameq * fq, char * filename)
|
||||
void
|
||||
frameq_append (frameq * fq, char *filename)
|
||||
{
|
||||
framei * fi ;
|
||||
framei * fn ;
|
||||
framei *fi;
|
||||
framei *fn;
|
||||
|
||||
if (fq==NULL || filename==NULL) return ;
|
||||
fi = framei_new(filename);
|
||||
if (fi==NULL)
|
||||
return ;
|
||||
if (fq->n==0) {
|
||||
fq->first = fi ;
|
||||
fq->n = 1 ;
|
||||
return ;
|
||||
if (fq == NULL || filename == NULL)
|
||||
return;
|
||||
fi = framei_new (filename);
|
||||
if (fi == NULL)
|
||||
return;
|
||||
if (fq->n == 0)
|
||||
{
|
||||
fq->first = fi;
|
||||
fq->n = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
fn = fq->first ;
|
||||
while (fn->next!=NULL)
|
||||
fn = fn->next ;
|
||||
fn = fq->first;
|
||||
while (fn->next != NULL)
|
||||
fn = fn->next;
|
||||
|
||||
fn->next = fi ;
|
||||
fq->n ++ ;
|
||||
return ;
|
||||
fn->next = fi;
|
||||
fq->n++;
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -206,14 +232,15 @@ void frameq_append(frameq * fq, char * filename)
|
|||
@param fq The frame queue
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void frameq_pop(frameq * fq)
|
||||
void
|
||||
frameq_pop (frameq * fq)
|
||||
{
|
||||
framei * first ;
|
||||
framei *first;
|
||||
|
||||
first = fq->first->next ;
|
||||
framei_del(fq->first);
|
||||
fq->first = first ;
|
||||
fq->n -- ;
|
||||
first = fq->first->next;
|
||||
framei_del (fq->first);
|
||||
fq->first = first;
|
||||
fq->n--;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -223,20 +250,18 @@ void frameq_pop(frameq * fq)
|
|||
@param out File where the queue is dumped
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void frameq_dump(frameq * fq, FILE * out)
|
||||
void
|
||||
frameq_dump (frameq * fq, FILE * out)
|
||||
{
|
||||
int i ;
|
||||
framei * fi ;
|
||||
int i;
|
||||
framei *fi;
|
||||
|
||||
fi = fq->first ;
|
||||
for (i=0 ; i<fq->n ; i++) {
|
||||
fprintf(out,
|
||||
"%s %s %02d/%02d\n",
|
||||
fi->name,
|
||||
fi->tplid,
|
||||
fi->expno,
|
||||
fi->nexp);
|
||||
fi = fi->next ;
|
||||
fi = fq->first;
|
||||
for (i = 0; i < fq->n; i++)
|
||||
{
|
||||
fprintf (out,
|
||||
"%s %s %02d/%02d\n", fi->name, fi->tplid, fi->expno, fi->nexp);
|
||||
fi = fi->next;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -247,42 +272,46 @@ void frameq_dump(frameq * fq, FILE * out)
|
|||
@return A newly allocated frame queue
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
frameq * frameq_load(char * dirname)
|
||||
frameq *
|
||||
frameq_load (char *dirname)
|
||||
{
|
||||
frameq * fq ;
|
||||
int i ;
|
||||
glob_t pglob ;
|
||||
char filename[FILENAMESZ];
|
||||
frameq *fq;
|
||||
int i;
|
||||
glob_t pglob;
|
||||
char filename[FILENAMESZ];
|
||||
|
||||
/* Look for *.fits *.FITS *.fits.gz *.FITS.gz */
|
||||
sprintf(filename, "%s/*.fits", dirname);
|
||||
glob(filename, GLOB_MARK, NULL, &pglob);
|
||||
sprintf(filename, "%s/*.FITS", dirname);
|
||||
glob(filename, GLOB_APPEND, NULL, &pglob);
|
||||
sprintf(filename, "%s/*.fits.gz", dirname);
|
||||
glob(filename, GLOB_APPEND, NULL, &pglob);
|
||||
sprintf(filename, "%s/*.FITS.gz", dirname);
|
||||
glob(filename, GLOB_APPEND, NULL, &pglob);
|
||||
if (pglob.gl_pathc<1) {
|
||||
printf("found no frame\n");
|
||||
return NULL ;
|
||||
/* Look for *.fits *.FITS *.fits.gz *.FITS.gz */
|
||||
sprintf (filename, "%s/*.fits", dirname);
|
||||
glob (filename, GLOB_MARK, NULL, &pglob);
|
||||
sprintf (filename, "%s/*.FITS", dirname);
|
||||
glob (filename, GLOB_APPEND, NULL, &pglob);
|
||||
sprintf (filename, "%s/*.fits.gz", dirname);
|
||||
glob (filename, GLOB_APPEND, NULL, &pglob);
|
||||
sprintf (filename, "%s/*.FITS.gz", dirname);
|
||||
glob (filename, GLOB_APPEND, NULL, &pglob);
|
||||
if (pglob.gl_pathc < 1)
|
||||
{
|
||||
printf ("found no frame\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Build frame queue */
|
||||
fq = frameq_new();
|
||||
for (i=0 ; i<pglob.gl_pathc ; i++) {
|
||||
printf("\radding %d of %d", i+1, pglob.gl_pathc);
|
||||
fflush(stdout);
|
||||
frameq_append(fq, pglob.gl_pathv[i]);
|
||||
/* Build frame queue */
|
||||
fq = frameq_new ();
|
||||
for (i = 0; i < pglob.gl_pathc; i++)
|
||||
{
|
||||
printf ("\radding %d of %d", i + 1, pglob.gl_pathc);
|
||||
fflush (stdout);
|
||||
frameq_append (fq, pglob.gl_pathv[i]);
|
||||
}
|
||||
printf("\n");
|
||||
globfree(&pglob);
|
||||
return fq ;
|
||||
printf ("\n");
|
||||
globfree (&pglob);
|
||||
return fq;
|
||||
}
|
||||
|
||||
static int stringsort(const void * e1, const void * e2)
|
||||
static int
|
||||
stringsort (const void *e1, const void *e2)
|
||||
{
|
||||
return strcmp(*(char**)e1, *(char**)e2);
|
||||
return strcmp (*(char **) e1, *(char **) e2);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -293,53 +322,64 @@ static int stringsort(const void * e1, const void * e2)
|
|||
@return List of n strings
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char ** frameq_get_tplid(frameq * fq, int * n)
|
||||
char **
|
||||
frameq_get_tplid (frameq * fq, int *n)
|
||||
{
|
||||
framei * fn ;
|
||||
char ** tplid_all ;
|
||||
char ** tplid ;
|
||||
int i, j ;
|
||||
int ntplid ;
|
||||
framei *fn;
|
||||
char **tplid_all;
|
||||
char **tplid;
|
||||
int i, j;
|
||||
int ntplid;
|
||||
|
||||
/* Get all possible values for tplid */
|
||||
tplid_all = malloc(fq->n * sizeof(char*));
|
||||
fn = fq->first ;
|
||||
for (i=0 ; i<fq->n ; i++) {
|
||||
if (fn->tplid==NULL) {
|
||||
tplid_all[i] = strdup("none");
|
||||
} else {
|
||||
tplid_all[i] = strdup(fn->tplid);
|
||||
}
|
||||
fn = fn->next ;
|
||||
/* Get all possible values for tplid */
|
||||
tplid_all = malloc (fq->n * sizeof (char *));
|
||||
fn = fq->first;
|
||||
for (i = 0; i < fq->n; i++)
|
||||
{
|
||||
if (fn->tplid == NULL)
|
||||
{
|
||||
tplid_all[i] = strdup ("none");
|
||||
}
|
||||
else
|
||||
{
|
||||
tplid_all[i] = strdup (fn->tplid);
|
||||
}
|
||||
fn = fn->next;
|
||||
}
|
||||
/* Sort all tplid's */
|
||||
qsort(tplid_all, fq->n, sizeof(char*), stringsort);
|
||||
/* Sort all tplid's */
|
||||
qsort (tplid_all, fq->n, sizeof (char *), stringsort);
|
||||
|
||||
/* Compute how many different tplid's can be found */
|
||||
ntplid=1 ;
|
||||
for (i=1 ; i<fq->n ; i++) {
|
||||
if (strcmp(tplid_all[i], tplid_all[i-1])) {
|
||||
ntplid++ ;
|
||||
}
|
||||
/* Compute how many different tplid's can be found */
|
||||
ntplid = 1;
|
||||
for (i = 1; i < fq->n; i++)
|
||||
{
|
||||
if (strcmp (tplid_all[i], tplid_all[i - 1]))
|
||||
{
|
||||
ntplid++;
|
||||
}
|
||||
}
|
||||
|
||||
tplid = malloc(ntplid * sizeof(char*));
|
||||
tplid[0] = tplid_all[0] ;
|
||||
tplid_all[0] = NULL ;
|
||||
j=0 ;
|
||||
for (i=1 ; i<fq->n ; i++) {
|
||||
if (strcmp(tplid_all[i], tplid[j])) {
|
||||
j++ ;
|
||||
tplid[j] = tplid_all[i] ;
|
||||
} else {
|
||||
free(tplid_all[i]);
|
||||
}
|
||||
tplid_all[i] = NULL ;
|
||||
tplid = malloc (ntplid * sizeof (char *));
|
||||
tplid[0] = tplid_all[0];
|
||||
tplid_all[0] = NULL;
|
||||
j = 0;
|
||||
for (i = 1; i < fq->n; i++)
|
||||
{
|
||||
if (strcmp (tplid_all[i], tplid[j]))
|
||||
{
|
||||
j++;
|
||||
tplid[j] = tplid_all[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
free (tplid_all[i]);
|
||||
}
|
||||
tplid_all[i] = NULL;
|
||||
}
|
||||
free(tplid_all);
|
||||
free (tplid_all);
|
||||
|
||||
*n = ntplid ;
|
||||
return tplid ;
|
||||
*n = ntplid;
|
||||
return tplid;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -349,29 +389,34 @@ char ** frameq_get_tplid(frameq * fq, int * n)
|
|||
@return Setting number
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int frameq_getsetnum(char * dirname)
|
||||
int
|
||||
frameq_getsetnum (char *dirname)
|
||||
{
|
||||
char pattern[FILENAMESZ];
|
||||
glob_t pglob ;
|
||||
int i ;
|
||||
int max ;
|
||||
int num ;
|
||||
char pattern[FILENAMESZ];
|
||||
glob_t pglob;
|
||||
int i;
|
||||
int max;
|
||||
int num;
|
||||
|
||||
sprintf(pattern, "%s/set*", dirname);
|
||||
glob(pattern, GLOB_MARK, NULL, &pglob);
|
||||
if (pglob.gl_pathc<1) {
|
||||
max=0 ;
|
||||
} else {
|
||||
sprintf(pattern, "%s/set%%02d", dirname);
|
||||
max=0 ;
|
||||
for (i=0 ; i<pglob.gl_pathc ; i++) {
|
||||
sscanf(pglob.gl_pathv[i], pattern, &num);
|
||||
if (num>max)
|
||||
max=num ;
|
||||
}
|
||||
sprintf (pattern, "%s/set*", dirname);
|
||||
glob (pattern, GLOB_MARK, NULL, &pglob);
|
||||
if (pglob.gl_pathc < 1)
|
||||
{
|
||||
max = 0;
|
||||
}
|
||||
globfree(&pglob);
|
||||
return max+1 ;
|
||||
else
|
||||
{
|
||||
sprintf (pattern, "%s/set%%02d", dirname);
|
||||
max = 0;
|
||||
for (i = 0; i < pglob.gl_pathc; i++)
|
||||
{
|
||||
sscanf (pglob.gl_pathv[i], pattern, &num);
|
||||
if (num > max)
|
||||
max = num;
|
||||
}
|
||||
}
|
||||
globfree (&pglob);
|
||||
return max + 1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -380,82 +425,93 @@ int frameq_getsetnum(char * dirname)
|
|||
@param fq Frame queue
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void frameq_makelists(frameq * fq)
|
||||
void
|
||||
frameq_makelists (frameq * fq)
|
||||
{
|
||||
FILE * list ;
|
||||
char filename[FILENAMESZ];
|
||||
framei * fi ;
|
||||
int setnum ;
|
||||
int count ;
|
||||
int batches ;
|
||||
FILE *list;
|
||||
char filename[FILENAMESZ];
|
||||
framei *fi;
|
||||
int setnum;
|
||||
int count;
|
||||
int batches;
|
||||
|
||||
/* Count # of batches in input */
|
||||
fi = fq->first ;
|
||||
batches=0 ;
|
||||
while (fi!=NULL) {
|
||||
if (fi->expno==1)
|
||||
batches++ ;
|
||||
fi = fi->next ;
|
||||
/* Count # of batches in input */
|
||||
fi = fq->first;
|
||||
batches = 0;
|
||||
while (fi != NULL)
|
||||
{
|
||||
if (fi->expno == 1)
|
||||
batches++;
|
||||
fi = fi->next;
|
||||
}
|
||||
|
||||
fi = fq->first ;
|
||||
count=0 ;
|
||||
list=NULL ;
|
||||
while (fi!=NULL) {
|
||||
printf("\rclassifying batches: %d of %d", count, batches);
|
||||
fflush(stdout);
|
||||
if (fi->expno<0) {
|
||||
fi=fi->next ;
|
||||
continue ;
|
||||
}
|
||||
if (fi->expno==1) {
|
||||
count++ ;
|
||||
if (list!=NULL) {
|
||||
fclose(list);
|
||||
}
|
||||
if (fi->tplid == NULL) {
|
||||
printf("No TPL ID - abort\n") ;
|
||||
return ;
|
||||
}
|
||||
if (fi->origfile == NULL) {
|
||||
printf("No ORIGFILE - abort\n") ;
|
||||
return ;
|
||||
}
|
||||
mkdir(fi->tplid, 0755);
|
||||
setnum = frameq_getsetnum(fi->tplid);
|
||||
sprintf(filename, "%s/%s_%02d", fi->tplid, fi->origfile, fi->nexp);
|
||||
mkdir(filename, 0755);
|
||||
sprintf(filename, "%s/%s_%02d/IN", fi->tplid,fi->origfile,fi->nexp);
|
||||
list = fopen(filename, "w");
|
||||
fprintf(list,"# TPL.ID= %s\n", fi->tplid);
|
||||
fprintf(list,"# NEXP = %02d\n", fi->nexp);
|
||||
}
|
||||
if (list) fprintf(list, "%s\n", fi->name);
|
||||
fi = fi->next ;
|
||||
fi = fq->first;
|
||||
count = 0;
|
||||
list = NULL;
|
||||
while (fi != NULL)
|
||||
{
|
||||
printf ("\rclassifying batches: %d of %d", count, batches);
|
||||
fflush (stdout);
|
||||
if (fi->expno < 0)
|
||||
{
|
||||
fi = fi->next;
|
||||
continue;
|
||||
}
|
||||
if (fi->expno == 1)
|
||||
{
|
||||
count++;
|
||||
if (list != NULL)
|
||||
{
|
||||
fclose (list);
|
||||
}
|
||||
if (fi->tplid == NULL)
|
||||
{
|
||||
printf ("No TPL ID - abort\n");
|
||||
return;
|
||||
}
|
||||
if (fi->origfile == NULL)
|
||||
{
|
||||
printf ("No ORIGFILE - abort\n");
|
||||
return;
|
||||
}
|
||||
mkdir (fi->tplid, 0755);
|
||||
setnum = frameq_getsetnum (fi->tplid);
|
||||
sprintf (filename, "%s/%s_%02d", fi->tplid, fi->origfile, fi->nexp);
|
||||
mkdir (filename, 0755);
|
||||
sprintf (filename, "%s/%s_%02d/IN", fi->tplid, fi->origfile,
|
||||
fi->nexp);
|
||||
list = fopen (filename, "w");
|
||||
fprintf (list, "# TPL.ID= %s\n", fi->tplid);
|
||||
fprintf (list, "# NEXP = %02d\n", fi->nexp);
|
||||
}
|
||||
if (list)
|
||||
fprintf (list, "%s\n", fi->name);
|
||||
fi = fi->next;
|
||||
}
|
||||
printf("\n");
|
||||
return ;
|
||||
printf ("\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char * argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
frameq * fq ;
|
||||
frameq *fq;
|
||||
|
||||
if (argc<2) {
|
||||
printf("use: %s <dirname>\n", argv[0]);
|
||||
return 1 ;
|
||||
}
|
||||
if (argc < 2)
|
||||
{
|
||||
printf ("use: %s <dirname>\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
printf("loading frames from %s...\n", argv[1]);
|
||||
fq = frameq_load(argv[1]);
|
||||
printf("processing lists...\n");
|
||||
frameq_makelists(fq);
|
||||
frameq_del(fq);
|
||||
printf("done\n");
|
||||
printf ("loading frames from %s...\n", argv[1]);
|
||||
fq = frameq_load (argv[1]);
|
||||
printf ("processing lists...\n");
|
||||
frameq_makelists (fq);
|
||||
frameq_del (fq);
|
||||
printf ("done\n");
|
||||
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,243 +25,269 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static int textract_write_ext(char *, int) ;
|
||||
static int iextract_write_ext(char *, int) ;
|
||||
static char prog_desc[] = "Extract and write FITS extensions" ;
|
||||
static void usage(char *) ;
|
||||
static int textract_write_ext (char *, int);
|
||||
static int iextract_write_ext (char *, int);
|
||||
static char prog_desc[] = "Extract and write FITS extensions";
|
||||
static void usage (char *);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
char * name_in ;
|
||||
int ext ;
|
||||
int nb_ext ;
|
||||
int ext_type ;
|
||||
char *name_in;
|
||||
int ext;
|
||||
int nb_ext;
|
||||
int ext_type;
|
||||
|
||||
if (argc<3) usage(argv[0]) ;
|
||||
if (argc < 3)
|
||||
usage (argv[0]);
|
||||
|
||||
/* Get input file name and extension number */
|
||||
name_in = strdup(argv[1]) ;
|
||||
ext = (int)atoi(argv[2]) ;
|
||||
/* Get input file name and extension number */
|
||||
name_in = strdup (argv[1]);
|
||||
ext = (int) atoi (argv[2]);
|
||||
|
||||
/* Check if the file is a FITS file */
|
||||
if (!is_fits_file(name_in)) {
|
||||
printf("[%s] is not a FITS file\n", name_in) ;
|
||||
free(name_in) ;
|
||||
return -1 ;
|
||||
/* Check if the file is a FITS file */
|
||||
if (!is_fits_file (name_in))
|
||||
{
|
||||
printf ("[%s] is not a FITS file\n", name_in);
|
||||
free (name_in);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Check if the extension is valid */
|
||||
nb_ext = qfits_query_n_ext(name_in) ;
|
||||
if (nb_ext < ext) {
|
||||
printf("Only %d extensions in this file\n", nb_ext) ;
|
||||
free(name_in) ;
|
||||
return -1 ;
|
||||
/* Check if the extension is valid */
|
||||
nb_ext = qfits_query_n_ext (name_in);
|
||||
if (nb_ext < ext)
|
||||
{
|
||||
printf ("Only %d extensions in this file\n", nb_ext);
|
||||
free (name_in);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Check if it's a table or an image */
|
||||
ext_type = qfits_is_table(name_in, ext) ;
|
||||
/* Check if it's a table or an image */
|
||||
ext_type = qfits_is_table (name_in, ext);
|
||||
|
||||
switch (ext_type) {
|
||||
case QFITS_BINTABLE:
|
||||
case QFITS_ASCIITABLE:
|
||||
if (textract_write_ext(name_in, ext) == -1) {
|
||||
printf("cannot read-write extension no %d\n", ext) ;
|
||||
free(name_in) ;
|
||||
return -1 ;
|
||||
}
|
||||
break ;
|
||||
case QFITS_INVALIDTABLE:
|
||||
if (iextract_write_ext(name_in, ext) == -1) {
|
||||
printf("cannot read-write extension no %d\n", ext) ;
|
||||
free(name_in) ;
|
||||
return -1 ;
|
||||
}
|
||||
break ;
|
||||
default:
|
||||
printf("Unrecognized FITS type\n") ;
|
||||
free(name_in) ;
|
||||
return -1 ;
|
||||
switch (ext_type)
|
||||
{
|
||||
case QFITS_BINTABLE:
|
||||
case QFITS_ASCIITABLE:
|
||||
if (textract_write_ext (name_in, ext) == -1)
|
||||
{
|
||||
printf ("cannot read-write extension no %d\n", ext);
|
||||
free (name_in);
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
case QFITS_INVALIDTABLE:
|
||||
if (iextract_write_ext (name_in, ext) == -1)
|
||||
{
|
||||
printf ("cannot read-write extension no %d\n", ext);
|
||||
free (name_in);
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
printf ("Unrecognized FITS type\n");
|
||||
free (name_in);
|
||||
return -1;
|
||||
}
|
||||
free(name_in) ;
|
||||
free (name_in);
|
||||
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Functions code
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static void usage(char * pname)
|
||||
static void
|
||||
usage (char *pname)
|
||||
{
|
||||
printf("%s : %s\n", pname, prog_desc) ;
|
||||
printf(
|
||||
"use : %s <in> <extension>\n"
|
||||
"\n", pname) ;
|
||||
exit(0) ;
|
||||
printf ("%s : %s\n", pname, prog_desc);
|
||||
printf ("use : %s <in> <extension>\n" "\n", pname);
|
||||
exit (0);
|
||||
}
|
||||
|
||||
static int textract_write_ext(
|
||||
char * in,
|
||||
int ext)
|
||||
static int
|
||||
textract_write_ext (char *in, int ext)
|
||||
{
|
||||
qfits_table * th ;
|
||||
void ** array ;
|
||||
qfits_header * fh ;
|
||||
int array_size ;
|
||||
int i ;
|
||||
qfits_table *th;
|
||||
void **array;
|
||||
qfits_header *fh;
|
||||
int array_size;
|
||||
int i;
|
||||
|
||||
/* Get the table infos */
|
||||
if ((th = qfits_table_open(in, ext)) == NULL) {
|
||||
printf("cannot read extension: %d\n", ext) ;
|
||||
return -1 ;
|
||||
/* Get the table infos */
|
||||
if ((th = qfits_table_open (in, ext)) == NULL)
|
||||
{
|
||||
printf ("cannot read extension: %d\n", ext);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Compute array_size */
|
||||
array_size = 0 ;
|
||||
for (i=0 ; i<th->nc ; i++) {
|
||||
switch (th->col[i].atom_type) {
|
||||
case TFITS_ASCII_TYPE_A:
|
||||
case TFITS_ASCII_TYPE_I:
|
||||
case TFITS_ASCII_TYPE_E:
|
||||
case TFITS_ASCII_TYPE_F:
|
||||
case TFITS_ASCII_TYPE_D:
|
||||
case TFITS_BIN_TYPE_A:
|
||||
case TFITS_BIN_TYPE_L:
|
||||
case TFITS_BIN_TYPE_B:
|
||||
case TFITS_BIN_TYPE_X:
|
||||
array_size += sizeof(char*) ;
|
||||
break ;
|
||||
/* Compute array_size */
|
||||
array_size = 0;
|
||||
for (i = 0; i < th->nc; i++)
|
||||
{
|
||||
switch (th->col[i].atom_type)
|
||||
{
|
||||
case TFITS_ASCII_TYPE_A:
|
||||
case TFITS_ASCII_TYPE_I:
|
||||
case TFITS_ASCII_TYPE_E:
|
||||
case TFITS_ASCII_TYPE_F:
|
||||
case TFITS_ASCII_TYPE_D:
|
||||
case TFITS_BIN_TYPE_A:
|
||||
case TFITS_BIN_TYPE_L:
|
||||
case TFITS_BIN_TYPE_B:
|
||||
case TFITS_BIN_TYPE_X:
|
||||
array_size += sizeof (char *);
|
||||
break;
|
||||
|
||||
case TFITS_BIN_TYPE_I:
|
||||
array_size += sizeof(short*) ;
|
||||
break ;
|
||||
case TFITS_BIN_TYPE_I:
|
||||
array_size += sizeof (short *);
|
||||
break;
|
||||
|
||||
case TFITS_BIN_TYPE_J:
|
||||
case TFITS_BIN_TYPE_E:
|
||||
array_size += sizeof(int*) ;
|
||||
break ;
|
||||
case TFITS_BIN_TYPE_J:
|
||||
case TFITS_BIN_TYPE_E:
|
||||
array_size += sizeof (int *);
|
||||
break;
|
||||
|
||||
case TFITS_BIN_TYPE_C:
|
||||
case TFITS_BIN_TYPE_P:
|
||||
array_size += sizeof(float*) ;
|
||||
break ;
|
||||
case TFITS_BIN_TYPE_C:
|
||||
case TFITS_BIN_TYPE_P:
|
||||
array_size += sizeof (float *);
|
||||
break;
|
||||
|
||||
case TFITS_BIN_TYPE_D:
|
||||
case TFITS_BIN_TYPE_M:
|
||||
array_size += sizeof(double*) ;
|
||||
break ;
|
||||
default:
|
||||
return -1 ;
|
||||
}
|
||||
case TFITS_BIN_TYPE_D:
|
||||
case TFITS_BIN_TYPE_M:
|
||||
array_size += sizeof (double *);
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allocate memory for array */
|
||||
array = malloc(array_size) ;
|
||||
/* Allocate memory for array */
|
||||
array = malloc (array_size);
|
||||
|
||||
/* Load columns in array */
|
||||
for (i=0 ; i<th->nc ; i++) {
|
||||
array[i] = qfits_query_column_data(th, i, NULL, NULL) ;
|
||||
if (array[i] == NULL) {
|
||||
printf("cannot read column %d\n", i+1) ;
|
||||
}
|
||||
/* Load columns in array */
|
||||
for (i = 0; i < th->nc; i++)
|
||||
{
|
||||
array[i] = qfits_query_column_data (th, i, NULL, NULL);
|
||||
if (array[i] == NULL)
|
||||
{
|
||||
printf ("cannot read column %d\n", i + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Update th : filename */
|
||||
sprintf(th->filename, "ext%d.tfits", ext) ;
|
||||
/* Update th : filename */
|
||||
sprintf (th->filename, "ext%d.tfits", ext);
|
||||
|
||||
/* Get fits primary header */
|
||||
if ((fh = qfits_header_read(in)) == NULL) {
|
||||
for (i=0 ; i<th->nc ; i++) if (array[i] != NULL) free(array[i]) ;
|
||||
qfits_table_close(th) ;
|
||||
free(array) ;
|
||||
printf("cannot read fits header\n") ;
|
||||
return -1 ;
|
||||
/* Get fits primary header */
|
||||
if ((fh = qfits_header_read (in)) == NULL)
|
||||
{
|
||||
for (i = 0; i < th->nc; i++)
|
||||
if (array[i] != NULL)
|
||||
free (array[i]);
|
||||
qfits_table_close (th);
|
||||
free (array);
|
||||
printf ("cannot read fits header\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ext != 0) {
|
||||
/* No data in primary HDU */
|
||||
qfits_header_mod(fh, "NAXIS", "0", NULL) ;
|
||||
qfits_header_del(fh, "NAXIS1") ;
|
||||
qfits_header_del(fh, "NAXIS2") ;
|
||||
if (ext != 0)
|
||||
{
|
||||
/* No data in primary HDU */
|
||||
qfits_header_mod (fh, "NAXIS", "0", NULL);
|
||||
qfits_header_del (fh, "NAXIS1");
|
||||
qfits_header_del (fh, "NAXIS2");
|
||||
}
|
||||
|
||||
/* Write the tfits file */
|
||||
if (qfits_save_table_hdrdump((void **)array, th, fh) == -1) {
|
||||
qfits_header_destroy(fh) ;
|
||||
for (i=0 ; i<th->nc ; i++) if (array[i] != NULL) free(array[i]) ;
|
||||
qfits_table_close(th) ;
|
||||
free(array) ;
|
||||
printf("cannot write fits table\n") ;
|
||||
return -1 ;
|
||||
/* Write the tfits file */
|
||||
if (qfits_save_table_hdrdump ((void **) array, th, fh) == -1)
|
||||
{
|
||||
qfits_header_destroy (fh);
|
||||
for (i = 0; i < th->nc; i++)
|
||||
if (array[i] != NULL)
|
||||
free (array[i]);
|
||||
qfits_table_close (th);
|
||||
free (array);
|
||||
printf ("cannot write fits table\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Free and return */
|
||||
qfits_header_destroy(fh) ;
|
||||
for (i=0 ; i<th->nc ; i++) if (array[i] != NULL) free(array[i]) ;
|
||||
qfits_table_close(th) ;
|
||||
free(array) ;
|
||||
return 0 ;
|
||||
/* Free and return */
|
||||
qfits_header_destroy (fh);
|
||||
for (i = 0; i < th->nc; i++)
|
||||
if (array[i] != NULL)
|
||||
free (array[i]);
|
||||
qfits_table_close (th);
|
||||
free (array);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int iextract_write_ext(
|
||||
char * in,
|
||||
int ext)
|
||||
static int
|
||||
iextract_write_ext (char *in, int ext)
|
||||
{
|
||||
qfitsloader ql ;
|
||||
qfitsdumper qd ;
|
||||
qfits_header * fh ;
|
||||
char outname[1024] ;
|
||||
FILE * out ;
|
||||
qfitsloader ql;
|
||||
qfitsdumper qd;
|
||||
qfits_header *fh;
|
||||
char outname[1024];
|
||||
FILE *out;
|
||||
|
||||
sprintf(outname, "ext%d.fits", ext) ;
|
||||
sprintf (outname, "ext%d.fits", ext);
|
||||
|
||||
/* Initialize a FITS loader */
|
||||
ql.filename = in ;
|
||||
ql.xtnum = ext ;
|
||||
ql.pnum = 0 ;
|
||||
ql.map = 1 ;
|
||||
ql.ptype = PTYPE_DOUBLE ;
|
||||
if (qfitsloader_init(&ql)!=0) return -1 ;
|
||||
/* Initialize a FITS loader */
|
||||
ql.filename = in;
|
||||
ql.xtnum = ext;
|
||||
ql.pnum = 0;
|
||||
ql.map = 1;
|
||||
ql.ptype = PTYPE_DOUBLE;
|
||||
if (qfitsloader_init (&ql) != 0)
|
||||
return -1;
|
||||
|
||||
/* Load the primary header */
|
||||
if ((fh = qfits_header_read(ql.filename)) == NULL) return -1 ;
|
||||
/* Load the primary header */
|
||||
if ((fh = qfits_header_read (ql.filename)) == NULL)
|
||||
return -1;
|
||||
|
||||
if (ext != 0) {
|
||||
/* No data in primary HDU */
|
||||
qfits_header_mod(fh, "NAXIS", "0", NULL) ;
|
||||
qfits_header_del(fh, "NAXIS1") ;
|
||||
qfits_header_del(fh, "NAXIS2") ;
|
||||
if (ext != 0)
|
||||
{
|
||||
/* No data in primary HDU */
|
||||
qfits_header_mod (fh, "NAXIS", "0", NULL);
|
||||
qfits_header_del (fh, "NAXIS1");
|
||||
qfits_header_del (fh, "NAXIS2");
|
||||
}
|
||||
|
||||
/* Dump the primary header */
|
||||
if ((out = fopen(outname, "w")) == NULL) return -1 ;
|
||||
qfits_header_dump(fh, out);
|
||||
qfits_header_destroy(fh) ;
|
||||
/* Dump the primary header */
|
||||
if ((out = fopen (outname, "w")) == NULL)
|
||||
return -1;
|
||||
qfits_header_dump (fh, out);
|
||||
qfits_header_destroy (fh);
|
||||
|
||||
if (ext != 0) {
|
||||
/* Load the extension header */
|
||||
if ((fh = qfits_header_readext(ql.filename, ext)) == NULL) return -1 ;
|
||||
/* Dump the extension header */
|
||||
qfits_header_dump(fh, out);
|
||||
qfits_header_destroy(fh) ;
|
||||
if (ext != 0)
|
||||
{
|
||||
/* Load the extension header */
|
||||
if ((fh = qfits_header_readext (ql.filename, ext)) == NULL)
|
||||
return -1;
|
||||
/* Dump the extension header */
|
||||
qfits_header_dump (fh, out);
|
||||
qfits_header_destroy (fh);
|
||||
}
|
||||
fclose(out) ;
|
||||
fclose (out);
|
||||
|
||||
/* Load the FITS image */
|
||||
if (qfits_loadpix(&ql)!=0) return -1 ;
|
||||
/* Load the FITS image */
|
||||
if (qfits_loadpix (&ql) != 0)
|
||||
return -1;
|
||||
|
||||
/* Write the FITS image */
|
||||
qd.filename = outname ;
|
||||
qd.npix = ql.lx * ql.ly ;
|
||||
qd.ptype = PTYPE_DOUBLE ;
|
||||
qd.dbuf = ql.dbuf ;
|
||||
qd.out_ptype = ql.bitpix ;
|
||||
if (qfits_pixdump(&qd)!=0) return -1 ;
|
||||
/* qfits_zeropad(outname) ; */
|
||||
free(ql.dbuf) ;
|
||||
/* Write the FITS image */
|
||||
qd.filename = outname;
|
||||
qd.npix = ql.lx * ql.ly;
|
||||
qd.ptype = PTYPE_DOUBLE;
|
||||
qd.dbuf = ql.dbuf;
|
||||
qd.out_ptype = ql.bitpix;
|
||||
if (qfits_pixdump (&qd) != 0)
|
||||
return -1;
|
||||
/* qfits_zeropad(outname) ; */
|
||||
free (ql.dbuf);
|
||||
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -31,182 +31,231 @@
|
|||
Functions prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static char prog_desc[] = "replace keyword in a FITS header" ;
|
||||
static void usage(char *) ;
|
||||
static char prog_desc[] = "replace keyword in a FITS header";
|
||||
static void usage (char *);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
char * name_in ;
|
||||
char * card ;
|
||||
char * place ;
|
||||
char * key ;
|
||||
char * key_tmp ;
|
||||
char * val ;
|
||||
char * val_tmp ;
|
||||
char * com ;
|
||||
char * com_tmp ;
|
||||
int keep_com ;
|
||||
int numeric ;
|
||||
char * stmp ;
|
||||
int i ;
|
||||
char *name_in;
|
||||
char *card;
|
||||
char *place;
|
||||
char *key;
|
||||
char *key_tmp;
|
||||
char *val;
|
||||
char *val_tmp;
|
||||
char *com;
|
||||
char *com_tmp;
|
||||
int keep_com;
|
||||
int numeric;
|
||||
char *stmp;
|
||||
int i;
|
||||
|
||||
char card_tmp[NM_SIZ] ;
|
||||
char card_tmp[NM_SIZ];
|
||||
|
||||
if (argc<2) usage(argv[0]) ;
|
||||
if (argc < 2)
|
||||
usage (argv[0]);
|
||||
|
||||
/* Initialize */
|
||||
name_in = NULL ;
|
||||
card = NULL ;
|
||||
place = NULL ;
|
||||
key = NULL ;
|
||||
val = NULL ;
|
||||
com = NULL ;
|
||||
keep_com = 0 ;
|
||||
numeric = 0 ;
|
||||
/* Initialize */
|
||||
name_in = NULL;
|
||||
card = NULL;
|
||||
place = NULL;
|
||||
key = NULL;
|
||||
val = NULL;
|
||||
com = NULL;
|
||||
keep_com = 0;
|
||||
numeric = 0;
|
||||
|
||||
/* Command line handling */
|
||||
i=1 ;
|
||||
while (i<argc) {
|
||||
if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) {
|
||||
usage(argv[0]);
|
||||
} else if (!strcmp(argv[i], "-p")) {
|
||||
if ((i+1)>=argc) {
|
||||
fprintf(stderr, "option -p needs an argument\n");
|
||||
return -1 ;
|
||||
}
|
||||
i++ ;
|
||||
place = strdup(argv[i]);
|
||||
} else if (!strcmp(argv[i], "-k")) {
|
||||
if ((i+1)>=argc) {
|
||||
fprintf(stderr, "option -k needs an argument\n");
|
||||
return -1 ;
|
||||
}
|
||||
i++ ;
|
||||
key = strdup(argv[i]);
|
||||
} else if (!strcmp(argv[i], "-v")) {
|
||||
if ((i+1)>=argc) {
|
||||
fprintf(stderr, "option -v needs an argument\n");
|
||||
return -1 ;
|
||||
}
|
||||
i++ ;
|
||||
val = strdup(argv[i]);
|
||||
} else if (!strcmp(argv[i], "-c")) {
|
||||
if ((i+1)>=argc) {
|
||||
fprintf(stderr, "option -c needs an argument\n");
|
||||
return -1 ;
|
||||
}
|
||||
i++ ;
|
||||
com = strdup(argv[i]);
|
||||
} else if (!strcmp(argv[i], "-C")) {
|
||||
keep_com = 1 ;
|
||||
} else if (!strcmp(argv[i], "-n")) {
|
||||
numeric = 1 ;
|
||||
} else {
|
||||
break ;
|
||||
}
|
||||
i++ ;
|
||||
/* Command line handling */
|
||||
i = 1;
|
||||
while (i < argc)
|
||||
{
|
||||
if (!strcmp (argv[i], "--help") || !strcmp (argv[i], "-h"))
|
||||
{
|
||||
usage (argv[0]);
|
||||
}
|
||||
else if (!strcmp (argv[i], "-p"))
|
||||
{
|
||||
if ((i + 1) >= argc)
|
||||
{
|
||||
fprintf (stderr, "option -p needs an argument\n");
|
||||
return -1;
|
||||
}
|
||||
i++;
|
||||
place = strdup (argv[i]);
|
||||
}
|
||||
else if (!strcmp (argv[i], "-k"))
|
||||
{
|
||||
if ((i + 1) >= argc)
|
||||
{
|
||||
fprintf (stderr, "option -k needs an argument\n");
|
||||
return -1;
|
||||
}
|
||||
i++;
|
||||
key = strdup (argv[i]);
|
||||
}
|
||||
else if (!strcmp (argv[i], "-v"))
|
||||
{
|
||||
if ((i + 1) >= argc)
|
||||
{
|
||||
fprintf (stderr, "option -v needs an argument\n");
|
||||
return -1;
|
||||
}
|
||||
i++;
|
||||
val = strdup (argv[i]);
|
||||
}
|
||||
else if (!strcmp (argv[i], "-c"))
|
||||
{
|
||||
if ((i + 1) >= argc)
|
||||
{
|
||||
fprintf (stderr, "option -c needs an argument\n");
|
||||
return -1;
|
||||
}
|
||||
i++;
|
||||
com = strdup (argv[i]);
|
||||
}
|
||||
else if (!strcmp (argv[i], "-C"))
|
||||
{
|
||||
keep_com = 1;
|
||||
}
|
||||
else if (!strcmp (argv[i], "-n"))
|
||||
{
|
||||
numeric = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
/* Check options coherence */
|
||||
if ((keep_com == 1) && (com != NULL)) {
|
||||
fprintf(stderr, "options -c and -C should not be used together\n") ;
|
||||
if (place) free(place) ;
|
||||
if (key) free(key) ;
|
||||
if (val) free(val) ;
|
||||
free(com) ;
|
||||
return -1 ;
|
||||
/* Check options coherence */
|
||||
if ((keep_com == 1) && (com != NULL))
|
||||
{
|
||||
fprintf (stderr, "options -c and -C should not be used together\n");
|
||||
if (place)
|
||||
free (place);
|
||||
if (key)
|
||||
free (key);
|
||||
if (val)
|
||||
free (val);
|
||||
free (com);
|
||||
return -1;
|
||||
}
|
||||
if (place == NULL) {
|
||||
fprintf(stderr, "options -p has to be used\n") ;
|
||||
if (key) free(key) ;
|
||||
if (val) free(val) ;
|
||||
if (com) free(com) ;
|
||||
return -1 ;
|
||||
if (place == NULL)
|
||||
{
|
||||
fprintf (stderr, "options -p has to be used\n");
|
||||
if (key)
|
||||
free (key);
|
||||
if (val)
|
||||
free (val);
|
||||
if (com)
|
||||
free (com);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Get input file name */
|
||||
if ((argc-i)<1) {
|
||||
fprintf(stderr, "missing input file name\n");
|
||||
return -1 ;
|
||||
/* Get input file name */
|
||||
if ((argc - i) < 1)
|
||||
{
|
||||
fprintf (stderr, "missing input file name\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Loop on the input files */
|
||||
while (argc-i >= 1) {
|
||||
name_in = strdup(argv[i]) ;
|
||||
/* Loop on the input files */
|
||||
while (argc - i >= 1)
|
||||
{
|
||||
name_in = strdup (argv[i]);
|
||||
|
||||
/* Set keyword to write */
|
||||
key_tmp = NULL ;
|
||||
if (key==NULL) key_tmp = strdup(place) ;
|
||||
else key_tmp = strdup(key) ;
|
||||
/* Set keyword to write */
|
||||
key_tmp = NULL;
|
||||
if (key == NULL)
|
||||
key_tmp = strdup (place);
|
||||
else
|
||||
key_tmp = strdup (key);
|
||||
|
||||
/* Set value to write */
|
||||
val_tmp = NULL ;
|
||||
if (val==NULL) {
|
||||
card = qfits_query_card(name_in, place) ;
|
||||
if (card!= NULL) {
|
||||
stmp = qfits_getvalue(card) ;
|
||||
val_tmp = strdup(stmp) ;
|
||||
}
|
||||
} else val_tmp = strdup(val) ;
|
||||
/* Set value to write */
|
||||
val_tmp = NULL;
|
||||
if (val == NULL)
|
||||
{
|
||||
card = qfits_query_card (name_in, place);
|
||||
if (card != NULL)
|
||||
{
|
||||
stmp = qfits_getvalue (card);
|
||||
val_tmp = strdup (stmp);
|
||||
}
|
||||
}
|
||||
else
|
||||
val_tmp = strdup (val);
|
||||
|
||||
com_tmp = NULL ;
|
||||
/* Set comment to write */
|
||||
if ((com == NULL) && (keep_com == 1)) {
|
||||
if (card == NULL) card = qfits_query_card(name_in, place) ;
|
||||
if (card != NULL) {
|
||||
stmp = qfits_getcomment(card) ;
|
||||
com_tmp = strdup(stmp) ;
|
||||
}
|
||||
} else if (com != NULL) com_tmp = strdup(com) ;
|
||||
if (card != NULL) free(card) ;
|
||||
card = NULL ;
|
||||
printf("DEBUG: %s\n", key_tmp) ;
|
||||
com_tmp = NULL;
|
||||
/* Set comment to write */
|
||||
if ((com == NULL) && (keep_com == 1))
|
||||
{
|
||||
if (card == NULL)
|
||||
card = qfits_query_card (name_in, place);
|
||||
if (card != NULL)
|
||||
{
|
||||
stmp = qfits_getcomment (card);
|
||||
com_tmp = strdup (stmp);
|
||||
}
|
||||
}
|
||||
else if (com != NULL)
|
||||
com_tmp = strdup (com);
|
||||
if (card != NULL)
|
||||
free (card);
|
||||
card = NULL;
|
||||
printf ("DEBUG: %s\n", key_tmp);
|
||||
|
||||
/* Create the card */
|
||||
keytuple2str(card_tmp, key_tmp, val_tmp, com_tmp) ;
|
||||
if (key_tmp) free(key_tmp) ;
|
||||
if (val_tmp) free(val_tmp) ;
|
||||
if (com_tmp) free(com_tmp) ;
|
||||
card = strdup(card_tmp) ;
|
||||
/* Create the card */
|
||||
keytuple2str (card_tmp, key_tmp, val_tmp, com_tmp);
|
||||
if (key_tmp)
|
||||
free (key_tmp);
|
||||
if (val_tmp)
|
||||
free (val_tmp);
|
||||
if (com_tmp)
|
||||
free (com_tmp);
|
||||
card = strdup (card_tmp);
|
||||
|
||||
/* Display what will be written where */
|
||||
printf("File %s\n", name_in) ;
|
||||
printf("\tcard : \n\t\t%s\n", card) ;
|
||||
printf("\tplace : \n\t\t%s\n", place) ;
|
||||
/* Display what will be written where */
|
||||
printf ("File %s\n", name_in);
|
||||
printf ("\tcard : \n\t\t%s\n", card);
|
||||
printf ("\tplace : \n\t\t%s\n", place);
|
||||
|
||||
/* Try to replace the first key */
|
||||
if (qfits_replace_card(name_in, place, card) == -1) {
|
||||
fprintf(stderr, "cannot replace the key %s\n", place) ;
|
||||
}
|
||||
free(name_in);
|
||||
free(card) ;
|
||||
card = NULL ;
|
||||
i++ ;
|
||||
/* Try to replace the first key */
|
||||
if (qfits_replace_card (name_in, place, card) == -1)
|
||||
{
|
||||
fprintf (stderr, "cannot replace the key %s\n", place);
|
||||
}
|
||||
free (name_in);
|
||||
free (card);
|
||||
card = NULL;
|
||||
i++;
|
||||
}
|
||||
|
||||
if (val) free(val) ;
|
||||
if (com) free(com) ;
|
||||
if (key) free(key) ;
|
||||
free(place) ;
|
||||
/* Free and return */
|
||||
return 0 ;
|
||||
if (val)
|
||||
free (val);
|
||||
if (com)
|
||||
free (com);
|
||||
if (key)
|
||||
free (key);
|
||||
free (place);
|
||||
/* Free and return */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void usage(char * pname)
|
||||
static void
|
||||
usage (char *pname)
|
||||
{
|
||||
printf("%s : %s\n", pname, prog_desc) ;
|
||||
printf(
|
||||
"use : %s [options] <in>\n"
|
||||
"options are:\n"
|
||||
"\t-p place gives the keyword to write over (required).\n"
|
||||
"\t-k key gives the new keyword name (optional).\n"
|
||||
"\t-v val gives the value to write (optional).\n"
|
||||
"\t-c com gives the comment to write (optional).\n"
|
||||
"\t-C flag to keep comment\n"
|
||||
"\n", pname) ;
|
||||
exit(0) ;
|
||||
printf ("%s : %s\n", pname, prog_desc);
|
||||
printf ("use : %s [options] <in>\n"
|
||||
"options are:\n"
|
||||
"\t-p place gives the keyword to write over (required).\n"
|
||||
"\t-k key gives the new keyword name (optional).\n"
|
||||
"\t-v val gives the value to write (optional).\n"
|
||||
"\t-c com gives the comment to write (optional).\n"
|
||||
"\t-C flag to keep comment\n" "\n", pname);
|
||||
exit (0);
|
||||
}
|
||||
|
||||
|
|
1225
qfits/saft/fitsmd5.c
1225
qfits/saft/fitsmd5.c
File diff suppressed because it is too large
Load Diff
|
@ -61,147 +61,178 @@
|
|||
-----------------------------------------------------------------------------*/
|
||||
|
||||
/* This holds a keyword value and a flag to indicate its presence */
|
||||
typedef struct _KEYWORD_ {
|
||||
char value[MAX_STRING] ;
|
||||
int present ;
|
||||
} keyword ;
|
||||
typedef struct _KEYWORD_
|
||||
{
|
||||
char value[MAX_STRING];
|
||||
int present;
|
||||
} keyword;
|
||||
|
||||
/* Each detected file in input has such an associated structure */
|
||||
typedef struct _RECORD_ {
|
||||
char filename[MAX_STRING] ;
|
||||
keyword listkw[MAX_KEY] ;
|
||||
} record ;
|
||||
typedef struct _RECORD_
|
||||
{
|
||||
char filename[MAX_STRING];
|
||||
keyword listkw[MAX_KEY];
|
||||
} record;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static int isfilename(char *string) ;
|
||||
static void getfilename(char *line, char *word) ;
|
||||
static char * expand_hierarch_keyword(char *, char *) ;
|
||||
static int isdetectedkeyword(char *line, char *keywords[], int nkeys) ;
|
||||
static void getkeywordvalue(char *line, char *word) ;
|
||||
static int isfilename (char *string);
|
||||
static void getfilename (char *line, char *word);
|
||||
static char *expand_hierarch_keyword (char *, char *);
|
||||
static int isdetectedkeyword (char *line, char *keywords[], int nkeys);
|
||||
static void getkeywordvalue (char *line, char *word);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
char curline[MAX_STRING] ;
|
||||
char word[MAX_STRING] ;
|
||||
int i, j ;
|
||||
int nfiles ;
|
||||
record *allrecords ;
|
||||
int kwnum ;
|
||||
int len ;
|
||||
int max_width[MAX_KEY] ;
|
||||
int max_filnam ;
|
||||
char fmt[8] ;
|
||||
int flag ;
|
||||
int printnames ;
|
||||
int print_hdr ;
|
||||
char curline[MAX_STRING];
|
||||
char word[MAX_STRING];
|
||||
int i, j;
|
||||
int nfiles;
|
||||
record *allrecords;
|
||||
int kwnum;
|
||||
int len;
|
||||
int max_width[MAX_KEY];
|
||||
int max_filnam;
|
||||
char fmt[8];
|
||||
int flag;
|
||||
int printnames;
|
||||
int print_hdr;
|
||||
|
||||
if (argc<2) {
|
||||
printf("\n\nuse : %s [-d] KEY1 KEY2 ... KEYn\n", argv[0]) ;
|
||||
printf("Input data is received from stdin\n") ;
|
||||
printf("See man page for more details and examples\n\n") ;
|
||||
return 0 ;
|
||||
if (argc < 2)
|
||||
{
|
||||
printf ("\n\nuse : %s [-d] KEY1 KEY2 ... KEYn\n", argv[0]);
|
||||
printf ("Input data is received from stdin\n");
|
||||
printf ("See man page for more details and examples\n\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Initialize */
|
||||
printnames = 0 ;
|
||||
print_hdr = 1 ;
|
||||
nfiles = 0 ;
|
||||
allrecords = (record*)calloc(1, sizeof(record));
|
||||
if (!strcmp(argv[1], "-d")) {
|
||||
print_hdr = 0;
|
||||
argv++ ;
|
||||
argc-- ;
|
||||
}
|
||||
argv++ ;
|
||||
|
||||
/* Uppercase all inputs */
|
||||
for (i=0 ; i<(argc-1) ; i++) {
|
||||
j=0 ;
|
||||
while (argv[i][j]!=0) {
|
||||
argv[i][j] = toupper(argv[i][j]);
|
||||
j++ ;
|
||||
}
|
||||
}
|
||||
|
||||
while (fgets(curline, MAX_STRING, stdin) != (char*)NULL) {
|
||||
flag=isfilename(curline) ;
|
||||
if (flag == 1) {
|
||||
/* New file name is detected, get the new file name */
|
||||
printnames = 1 ;
|
||||
getfilename(curline, allrecords[nfiles].filename) ;
|
||||
nfiles++ ;
|
||||
|
||||
/* Initialize a new record structure to store data for this file. */
|
||||
allrecords = (record*)realloc(allrecords,(nfiles+1)*sizeof(record));
|
||||
for (i=0 ; i<MAX_KEY ; i++) allrecords[nfiles].listkw[i].present=0;
|
||||
} else if (flag==0) {
|
||||
/* Is not a file name, is it a searched keyword? */
|
||||
if ((kwnum = isdetectedkeyword( curline, argv, argc-1)) != -1) {
|
||||
/* Is there anything allocated yet to store this? */
|
||||
if (nfiles>0) {
|
||||
/* It has been detected as a searched keyword. */
|
||||
/* Get its value, store it, present flag up */
|
||||
getkeywordvalue(curline, word) ;
|
||||
strcpy(allrecords[nfiles-1].listkw[kwnum].value, word) ;
|
||||
allrecords[nfiles-1].listkw[kwnum].present ++ ;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Initialize */
|
||||
printnames = 0;
|
||||
print_hdr = 1;
|
||||
nfiles = 0;
|
||||
allrecords = (record *) calloc (1, sizeof (record));
|
||||
if (!strcmp (argv[1], "-d"))
|
||||
{
|
||||
print_hdr = 0;
|
||||
argv++;
|
||||
argc--;
|
||||
}
|
||||
for (i=0 ; i<argc-1 ; i++) max_width[i] = (int)strlen(argv[i]) ;
|
||||
argv++;
|
||||
|
||||
/* Record the maximum width for each column */
|
||||
max_filnam = 0 ;
|
||||
for (i=0 ; i<nfiles ; i++) {
|
||||
len = (int)strlen(allrecords[i].filename) ;
|
||||
if (len>max_filnam) max_filnam=len ;
|
||||
for (kwnum=0 ; kwnum<argc-1 ; kwnum++) {
|
||||
if (allrecords[i].listkw[kwnum].present) {
|
||||
len = (int)strlen(allrecords[i].listkw[kwnum].value) ;
|
||||
} else {
|
||||
len = 0 ;
|
||||
}
|
||||
if (len>max_width[kwnum]) max_width[kwnum] = len ;
|
||||
}
|
||||
/* Uppercase all inputs */
|
||||
for (i = 0; i < (argc - 1); i++)
|
||||
{
|
||||
j = 0;
|
||||
while (argv[i][j] != 0)
|
||||
{
|
||||
argv[i][j] = toupper (argv[i][j]);
|
||||
j++;
|
||||
}
|
||||
|
||||
/* Print out header line */
|
||||
if (print_hdr) {
|
||||
sprintf(fmt, FMT_STRING, max_filnam) ;
|
||||
if (printnames) printf(fmt, "FILE");
|
||||
for (i=0 ; i<argc-1 ; i++) {
|
||||
sprintf(fmt, FMT_STRING, max_width[i]) ;
|
||||
printf(fmt, argv[i]) ;
|
||||
}
|
||||
printf("\n") ;
|
||||
}
|
||||
|
||||
/* Now print out stored data */
|
||||
if (nfiles<1) {
|
||||
printf("*** error: no input data corresponding to dfits output\n");
|
||||
return -1 ;
|
||||
}
|
||||
for (i=0 ; i<nfiles ; i++) {
|
||||
if (printnames) {
|
||||
sprintf(fmt, FMT_STRING, max_filnam) ;
|
||||
printf(fmt, allrecords[i].filename) ;
|
||||
}
|
||||
for (kwnum=0 ; kwnum<argc-1 ; kwnum++) {
|
||||
sprintf(fmt, FMT_STRING, max_width[kwnum]);
|
||||
if (allrecords[i].listkw[kwnum].present)
|
||||
printf(fmt, allrecords[i].listkw[kwnum].value) ;
|
||||
else printf(fmt, " ");
|
||||
}
|
||||
printf("\n") ;
|
||||
}
|
||||
free(allrecords) ;
|
||||
return 0 ;
|
||||
|
||||
while (fgets (curline, MAX_STRING, stdin) != (char *) NULL)
|
||||
{
|
||||
flag = isfilename (curline);
|
||||
if (flag == 1)
|
||||
{
|
||||
/* New file name is detected, get the new file name */
|
||||
printnames = 1;
|
||||
getfilename (curline, allrecords[nfiles].filename);
|
||||
nfiles++;
|
||||
|
||||
/* Initialize a new record structure to store data for this file. */
|
||||
allrecords =
|
||||
(record *) realloc (allrecords, (nfiles + 1) * sizeof (record));
|
||||
for (i = 0; i < MAX_KEY; i++)
|
||||
allrecords[nfiles].listkw[i].present = 0;
|
||||
}
|
||||
else if (flag == 0)
|
||||
{
|
||||
/* Is not a file name, is it a searched keyword? */
|
||||
if ((kwnum = isdetectedkeyword (curline, argv, argc - 1)) != -1)
|
||||
{
|
||||
/* Is there anything allocated yet to store this? */
|
||||
if (nfiles > 0)
|
||||
{
|
||||
/* It has been detected as a searched keyword. */
|
||||
/* Get its value, store it, present flag up */
|
||||
getkeywordvalue (curline, word);
|
||||
strcpy (allrecords[nfiles - 1].listkw[kwnum].value, word);
|
||||
allrecords[nfiles - 1].listkw[kwnum].present++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < argc - 1; i++)
|
||||
max_width[i] = (int) strlen (argv[i]);
|
||||
|
||||
/* Record the maximum width for each column */
|
||||
max_filnam = 0;
|
||||
for (i = 0; i < nfiles; i++)
|
||||
{
|
||||
len = (int) strlen (allrecords[i].filename);
|
||||
if (len > max_filnam)
|
||||
max_filnam = len;
|
||||
for (kwnum = 0; kwnum < argc - 1; kwnum++)
|
||||
{
|
||||
if (allrecords[i].listkw[kwnum].present)
|
||||
{
|
||||
len = (int) strlen (allrecords[i].listkw[kwnum].value);
|
||||
}
|
||||
else
|
||||
{
|
||||
len = 0;
|
||||
}
|
||||
if (len > max_width[kwnum])
|
||||
max_width[kwnum] = len;
|
||||
}
|
||||
}
|
||||
|
||||
/* Print out header line */
|
||||
if (print_hdr)
|
||||
{
|
||||
sprintf (fmt, FMT_STRING, max_filnam);
|
||||
if (printnames)
|
||||
printf (fmt, "FILE");
|
||||
for (i = 0; i < argc - 1; i++)
|
||||
{
|
||||
sprintf (fmt, FMT_STRING, max_width[i]);
|
||||
printf (fmt, argv[i]);
|
||||
}
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
/* Now print out stored data */
|
||||
if (nfiles < 1)
|
||||
{
|
||||
printf ("*** error: no input data corresponding to dfits output\n");
|
||||
return -1;
|
||||
}
|
||||
for (i = 0; i < nfiles; i++)
|
||||
{
|
||||
if (printnames)
|
||||
{
|
||||
sprintf (fmt, FMT_STRING, max_filnam);
|
||||
printf (fmt, allrecords[i].filename);
|
||||
}
|
||||
for (kwnum = 0; kwnum < argc - 1; kwnum++)
|
||||
{
|
||||
sprintf (fmt, FMT_STRING, max_width[kwnum]);
|
||||
if (allrecords[i].listkw[kwnum].present)
|
||||
printf (fmt, allrecords[i].listkw[kwnum].value);
|
||||
else
|
||||
printf (fmt, " ");
|
||||
}
|
||||
printf ("\n");
|
||||
}
|
||||
free (allrecords);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -218,11 +249,14 @@ int main(int argc, char *argv[])
|
|||
extension, 0 otherwise.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int isfilename(char * string)
|
||||
static int
|
||||
isfilename (char *string)
|
||||
{
|
||||
if (!strncmp(string, "====>", 5)) return 1 ;
|
||||
if (!strncmp(string, "===>", 4)) return 2 ;
|
||||
return 0 ;
|
||||
if (!strncmp (string, "====>", 5))
|
||||
return 1;
|
||||
if (!strncmp (string, "===>", 4))
|
||||
return 2;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -234,11 +268,12 @@ static int isfilename(char * string)
|
|||
This is dfits dependent.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void getfilename(char * line, char * word)
|
||||
static void
|
||||
getfilename (char *line, char *word)
|
||||
{
|
||||
/* get filename from a dfits output */
|
||||
sscanf(line, "%*s %*s %s", word) ;
|
||||
return ;
|
||||
/* get filename from a dfits output */
|
||||
sscanf (line, "%*s %*s %s", word);
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -254,41 +289,45 @@ static void getfilename(char * line, char * word)
|
|||
otherwise, -1 is returned.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int isdetectedkeyword(
|
||||
char * line,
|
||||
char * keywords[],
|
||||
int nkeys)
|
||||
static int
|
||||
isdetectedkeyword (char *line, char *keywords[], int nkeys)
|
||||
{
|
||||
char kw[MAX_STRING] ;
|
||||
char esokw[MAX_STRING] ;
|
||||
int i ;
|
||||
char kw[MAX_STRING];
|
||||
char esokw[MAX_STRING];
|
||||
int i;
|
||||
|
||||
/* The keyword is up to the equal character, with trailing blanks removed */
|
||||
strcpy(kw, line) ;
|
||||
strtok(kw, "=") ;
|
||||
/* Now remove all trailing blanks (if any) */
|
||||
i = (int)strlen(kw) -1 ;
|
||||
while (kw[i] == ' ') i -- ;
|
||||
kw[i+1] = (char)0 ;
|
||||
/* The keyword is up to the equal character, with trailing blanks removed */
|
||||
strcpy (kw, line);
|
||||
strtok (kw, "=");
|
||||
/* Now remove all trailing blanks (if any) */
|
||||
i = (int) strlen (kw) - 1;
|
||||
while (kw[i] == ' ')
|
||||
i--;
|
||||
kw[i + 1] = (char) 0;
|
||||
|
||||
/* Now compare what we got with what's available */
|
||||
for (i=0 ; i<nkeys ; i++) {
|
||||
if (strstr(keywords[i], ".")!=NULL) {
|
||||
/*
|
||||
* keyword contains a dot, it is a hierarchical keyword that
|
||||
* must be expanded. Pattern is:
|
||||
* A.B.C... becomes HIERARCH ESO A B C ...
|
||||
*/
|
||||
expand_hierarch_keyword(keywords[i], esokw) ;
|
||||
if (!strcmp(kw, esokw)) {
|
||||
return i ;
|
||||
}
|
||||
} else if (!strcmp(kw, keywords[i])) {
|
||||
return i ;
|
||||
}
|
||||
/* Now compare what we got with what's available */
|
||||
for (i = 0; i < nkeys; i++)
|
||||
{
|
||||
if (strstr (keywords[i], ".") != NULL)
|
||||
{
|
||||
/*
|
||||
* keyword contains a dot, it is a hierarchical keyword that
|
||||
* must be expanded. Pattern is:
|
||||
* A.B.C... becomes HIERARCH ESO A B C ...
|
||||
*/
|
||||
expand_hierarch_keyword (keywords[i], esokw);
|
||||
if (!strcmp (kw, esokw))
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
else if (!strcmp (kw, keywords[i]))
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
/* Keyword not found */
|
||||
return -1 ;
|
||||
/* Keyword not found */
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -299,22 +338,22 @@ static int isdetectedkeyword(
|
|||
@return char *, pointer to second input string (modified)
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static char * expand_hierarch_keyword(
|
||||
char * dotkey,
|
||||
char * hierarchy)
|
||||
static char *
|
||||
expand_hierarch_keyword (char *dotkey, char *hierarchy)
|
||||
{
|
||||
char * token ;
|
||||
char ws[MAX_STRING] ;
|
||||
char *token;
|
||||
char ws[MAX_STRING];
|
||||
|
||||
sprintf(hierarchy, "HIERARCH ESO");
|
||||
strcpy(ws, dotkey) ;
|
||||
token = strtok(ws, ".") ;
|
||||
while (token!=NULL) {
|
||||
strcat(hierarchy, " ") ;
|
||||
strcat(hierarchy, token) ;
|
||||
token = strtok(NULL, ".");
|
||||
}
|
||||
return hierarchy ;
|
||||
sprintf (hierarchy, "HIERARCH ESO");
|
||||
strcpy (ws, dotkey);
|
||||
token = strtok (ws, ".");
|
||||
while (token != NULL)
|
||||
{
|
||||
strcat (hierarchy, " ");
|
||||
strcat (hierarchy, token);
|
||||
token = strtok (NULL, ".");
|
||||
}
|
||||
return hierarchy;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -326,48 +365,54 @@ static char * expand_hierarch_keyword(
|
|||
No complex value is recognized
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void getkeywordvalue(
|
||||
char * line,
|
||||
char * word)
|
||||
static void
|
||||
getkeywordvalue (char *line, char *word)
|
||||
{
|
||||
int c, w ;
|
||||
char tmp[MAX_STRING] ;
|
||||
char *begin, *end ;
|
||||
int length ;
|
||||
int quote = 0 ;
|
||||
int search = 1 ;
|
||||
int c, w;
|
||||
char tmp[MAX_STRING];
|
||||
char *begin, *end;
|
||||
int length;
|
||||
int quote = 0;
|
||||
int search = 1;
|
||||
|
||||
memset(tmp, (char)0, MAX_STRING) ;
|
||||
memset(word, (char)0, MAX_STRING) ;
|
||||
c = w = 0;
|
||||
memset (tmp, (char) 0, MAX_STRING);
|
||||
memset (word, (char) 0, MAX_STRING);
|
||||
c = w = 0;
|
||||
|
||||
/* Parse the line till the equal '=' sign is found */
|
||||
while (line[c] != '=') c++ ;
|
||||
c++ ;
|
||||
/* Parse the line till the equal '=' sign is found */
|
||||
while (line[c] != '=')
|
||||
c++;
|
||||
c++;
|
||||
|
||||
/* Copy the line till the slash '/' sign or the end of data is found. */
|
||||
while (search == 1) {
|
||||
if (c>=80) search = 0 ;
|
||||
else if ((line[c] == '/') && (quote == 0)) search = 0 ;
|
||||
if (line[c] == '\'') quote = !quote ;
|
||||
tmp[w++] = line[c++] ;
|
||||
/* Copy the line till the slash '/' sign or the end of data is found. */
|
||||
while (search == 1)
|
||||
{
|
||||
if (c >= 80)
|
||||
search = 0;
|
||||
else if ((line[c] == '/') && (quote == 0))
|
||||
search = 0;
|
||||
if (line[c] == '\'')
|
||||
quote = !quote;
|
||||
tmp[w++] = line[c++];
|
||||
}
|
||||
|
||||
/* NULL termination of the string */
|
||||
tmp[--w] = (char)0 ;
|
||||
/* NULL termination of the string */
|
||||
tmp[--w] = (char) 0;
|
||||
|
||||
/* Return the keyword only : a diff is made between text fields and nbs. */
|
||||
if ((begin = strchr(tmp, '\'')) != (char*)NULL) {
|
||||
/* A quote has been found: it is a string value */
|
||||
begin++ ;
|
||||
end = strrchr(tmp, '\'') ;
|
||||
length = (int)strlen(begin) - (int)strlen(end) ;
|
||||
strncpy(word, begin, length) ;
|
||||
} else {
|
||||
/* No quote, just get the value (only one, no complex supported) */
|
||||
sscanf(tmp, "%s", word) ;
|
||||
/* Return the keyword only : a diff is made between text fields and nbs. */
|
||||
if ((begin = strchr (tmp, '\'')) != (char *) NULL)
|
||||
{
|
||||
/* A quote has been found: it is a string value */
|
||||
begin++;
|
||||
end = strrchr (tmp, '\'');
|
||||
length = (int) strlen (begin) - (int) strlen (end);
|
||||
strncpy (word, begin, length);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* No quote, just get the value (only one, no complex supported) */
|
||||
sscanf (tmp, "%s", word);
|
||||
}
|
||||
|
||||
return ;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -40,136 +40,136 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static char prog_desc[] = "header conversion from ESO to standard FITS" ;
|
||||
static void usage(char *) ;
|
||||
static int convert_eso_to_std_FITS(char *, char *) ;
|
||||
static void free_keys(char **, int n) ;
|
||||
static void strip_beg_end(char *) ;
|
||||
static int search_and_replace_kw(char *, int, char **, char **, int) ;
|
||||
static void search_rep(char *, char *, char *);
|
||||
static void generate_default_convtab(void);
|
||||
static char * convert_deg_to_str(double deg) ;
|
||||
static char prog_desc[] = "header conversion from ESO to standard FITS";
|
||||
static void usage (char *);
|
||||
static int convert_eso_to_std_FITS (char *, char *);
|
||||
static void free_keys (char **, int n);
|
||||
static void strip_beg_end (char *);
|
||||
static int search_and_replace_kw (char *, int, char **, char **, int);
|
||||
static void search_rep (char *, char *, char *);
|
||||
static void generate_default_convtab (void);
|
||||
static char *convert_deg_to_str (double deg);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Static variables
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static char CONVTAB_DEFAULT1[] =
|
||||
"#\n"
|
||||
"# Example of conversion table for hierarch28\n"
|
||||
"#\n"
|
||||
"# A note about this file's format:\n"
|
||||
"# Any blank line or line starting with a hash is ignored.\n"
|
||||
"# Declare the keyword names to search and replace with:\n"
|
||||
"#\n"
|
||||
"# OLDKEYWORD = NEWKEYWORD\n"
|
||||
"#\n"
|
||||
"# Spaces are allowed within keyword names, to allow e.g.:\n"
|
||||
"#\n"
|
||||
"# HIERARCH ESO DET NDIT = DET NDIT\n"
|
||||
"#\n"
|
||||
"# The most important restriction is that new keywords shall not be\n"
|
||||
"# longer than the keywords they replace.\n"
|
||||
"#\n" ;
|
||||
"#\n"
|
||||
"# Example of conversion table for hierarch28\n"
|
||||
"#\n"
|
||||
"# A note about this file's format:\n"
|
||||
"# Any blank line or line starting with a hash is ignored.\n"
|
||||
"# Declare the keyword names to search and replace with:\n"
|
||||
"#\n"
|
||||
"# OLDKEYWORD = NEWKEYWORD\n"
|
||||
"#\n"
|
||||
"# Spaces are allowed within keyword names, to allow e.g.:\n"
|
||||
"#\n"
|
||||
"# HIERARCH ESO DET NDIT = DET NDIT\n"
|
||||
"#\n"
|
||||
"# The most important restriction is that new keywords shall not be\n"
|
||||
"# longer than the keywords they replace.\n" "#\n";
|
||||
|
||||
|
||||
static char CONVTAB_DEFAULT2[] =
|
||||
"#\n"
|
||||
"# Translation table for basic keywords used by IRAF\n"
|
||||
"# -------------------------------------------------\n"
|
||||
"#\n"
|
||||
"# Note: hierarch28 will replace keywords in the main header\n"
|
||||
"# and also in extensions.\n"
|
||||
"#\n"
|
||||
"# Disclaimer:\n"
|
||||
"# this table has been compiled to best knowledge of present\n"
|
||||
"# IRAF packages. Please let us know of any addition/change.\n"
|
||||
"#\n"
|
||||
"\n" ;
|
||||
"#\n"
|
||||
"# Translation table for basic keywords used by IRAF\n"
|
||||
"# -------------------------------------------------\n"
|
||||
"#\n"
|
||||
"# Note: hierarch28 will replace keywords in the main header\n"
|
||||
"# and also in extensions.\n"
|
||||
"#\n"
|
||||
"# Disclaimer:\n"
|
||||
"# this table has been compiled to best knowledge of present\n"
|
||||
"# IRAF packages. Please let us know of any addition/change.\n"
|
||||
"#\n" "\n";
|
||||
|
||||
|
||||
static char CONVTAB_DEFAULT3[] =
|
||||
"UTC = UT\n"
|
||||
"LST = ST\n"
|
||||
"RA = RA\n"
|
||||
"DEC = DEC\n"
|
||||
"\n"
|
||||
"HIERARCH ESO TEL AIRM START = AIRMASS\n"
|
||||
"HIERARCH ESO DPR TYPE = IMAGETYP\n"
|
||||
"HIERARCH ESO INS FILT1 NAME = FILTER1\n"
|
||||
"HIERARCH ESO INS SLIT2 NAME = SLIT\n"
|
||||
"HIERARCH ESO INS GRIS1 NAME = GRISM\n"
|
||||
"HIERARCH ESO INS GRAT NAME = GRAT\n"
|
||||
"HIERARCH ESO INS GRAT1 NAME = GRAT1\n"
|
||||
"HIERARCH ESO INS GRAT2 NAME = GRAT2\n"
|
||||
"HIERARCH ESO INS GRAT WLEN = WLEN\n"
|
||||
"HIERARCH ESO INS GRAT1 WLEN = WLEN1\n"
|
||||
"HIERARCH ESO INS GRAT2 WLEN = WLEN2\n"
|
||||
"HIERARCH ESO INS GRAT ORDER = ORDER\n"
|
||||
"\n" ;
|
||||
"UTC = UT\n"
|
||||
"LST = ST\n"
|
||||
"RA = RA\n"
|
||||
"DEC = DEC\n"
|
||||
"\n"
|
||||
"HIERARCH ESO TEL AIRM START = AIRMASS\n"
|
||||
"HIERARCH ESO DPR TYPE = IMAGETYP\n"
|
||||
"HIERARCH ESO INS FILT1 NAME = FILTER1\n"
|
||||
"HIERARCH ESO INS SLIT2 NAME = SLIT\n"
|
||||
"HIERARCH ESO INS GRIS1 NAME = GRISM\n"
|
||||
"HIERARCH ESO INS GRAT NAME = GRAT\n"
|
||||
"HIERARCH ESO INS GRAT1 NAME = GRAT1\n"
|
||||
"HIERARCH ESO INS GRAT2 NAME = GRAT2\n"
|
||||
"HIERARCH ESO INS GRAT WLEN = WLEN\n"
|
||||
"HIERARCH ESO INS GRAT1 WLEN = WLEN1\n"
|
||||
"HIERARCH ESO INS GRAT2 WLEN = WLEN2\n"
|
||||
"HIERARCH ESO INS GRAT ORDER = ORDER\n" "\n";
|
||||
|
||||
static char CONVTAB_DEFAULT4[] =
|
||||
"#\n"
|
||||
"# A note for IRAF users:\n"
|
||||
"# Be aware also that the ESO convention names the keywords UTC and\n"
|
||||
"# LST, whereas the IRAF convention is 'UT' and 'ST'.\n"
|
||||
"#\n"
|
||||
"# The ESO standard (see http://archive.eso.org/dicb) defines these\n"
|
||||
"# keywords as floating point values with the units degrees for RA/DEC\n"
|
||||
"# and elapsed seconds since midnight for UT/ST.\n"
|
||||
"#\n"
|
||||
"# In order to have this tranlation performed, add\n"
|
||||
"# RA = RA\n"
|
||||
"# DEC = DEC\n"
|
||||
"# UTC = UT\n"
|
||||
"# LST = ST\n"
|
||||
"# to the conversion table.\n"
|
||||
"#\n";
|
||||
"#\n"
|
||||
"# A note for IRAF users:\n"
|
||||
"# Be aware also that the ESO convention names the keywords UTC and\n"
|
||||
"# LST, whereas the IRAF convention is 'UT' and 'ST'.\n"
|
||||
"#\n"
|
||||
"# The ESO standard (see http://archive.eso.org/dicb) defines these\n"
|
||||
"# keywords as floating point values with the units degrees for RA/DEC\n"
|
||||
"# and elapsed seconds since midnight for UT/ST.\n"
|
||||
"#\n"
|
||||
"# In order to have this tranlation performed, add\n"
|
||||
"# RA = RA\n"
|
||||
"# DEC = DEC\n"
|
||||
"# UTC = UT\n" "# LST = ST\n" "# to the conversion table.\n" "#\n";
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
char name_conv[NM_SIZ] ;
|
||||
char name_in[NM_SIZ] ;
|
||||
char name_conv[NM_SIZ];
|
||||
char name_in[NM_SIZ];
|
||||
|
||||
if (argc<2) usage(argv[0]) ;
|
||||
if (!strcmp(argv[1], "-g")) {
|
||||
generate_default_convtab() ;
|
||||
return 0 ;
|
||||
if (argc < 2)
|
||||
usage (argv[0]);
|
||||
if (!strcmp (argv[1], "-g"))
|
||||
{
|
||||
generate_default_convtab ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
strcpy(name_in, argv[1]) ;
|
||||
if (argc==3) {
|
||||
strcpy(name_conv, argv[2]) ;
|
||||
} else {
|
||||
strcpy(name_conv, "table.conv") ;
|
||||
strcpy (name_in, argv[1]);
|
||||
if (argc == 3)
|
||||
{
|
||||
strcpy (name_conv, argv[2]);
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy (name_conv, "table.conv");
|
||||
}
|
||||
|
||||
if (convert_eso_to_std_FITS(name_in, name_conv) != 0) {
|
||||
fprintf(stderr, "error during conversion: aborting\n") ;
|
||||
if (convert_eso_to_std_FITS (name_in, name_conv) != 0)
|
||||
{
|
||||
fprintf (stderr, "error during conversion: aborting\n");
|
||||
}
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void usage(char * pname)
|
||||
static void
|
||||
usage (char *pname)
|
||||
{
|
||||
printf(
|
||||
"\n\n"
|
||||
"hierarch28 (hierarch-to-eight)\n"
|
||||
"%s : %s\n"
|
||||
"use : %s [options] <in> [table]\n"
|
||||
"options are:\n"
|
||||
"\t-g generates a generic table\n"
|
||||
"\n"
|
||||
"default conversion table name is 'table.conv'\n"
|
||||
"\n"
|
||||
"More help can be found in the comments included in the default\n"
|
||||
"conversion table. Generate one with the -g option and read it.\n"
|
||||
"\n\n",
|
||||
pname, prog_desc, pname);
|
||||
exit(0) ;
|
||||
printf ("\n\n"
|
||||
"hierarch28 (hierarch-to-eight)\n"
|
||||
"%s : %s\n"
|
||||
"use : %s [options] <in> [table]\n"
|
||||
"options are:\n"
|
||||
"\t-g generates a generic table\n"
|
||||
"\n"
|
||||
"default conversion table name is 'table.conv'\n"
|
||||
"\n"
|
||||
"More help can be found in the comments included in the default\n"
|
||||
"conversion table. Generate one with the -g option and read it.\n"
|
||||
"\n\n", pname, prog_desc, pname);
|
||||
exit (0);
|
||||
}
|
||||
|
||||
|
||||
|
@ -185,132 +185,140 @@ static void usage(char * pname)
|
|||
keyword values are also modified to follow the IRAF convention.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int convert_eso_to_std_FITS(char * name_in, char * name_conv)
|
||||
static int
|
||||
convert_eso_to_std_FITS (char *name_in, char *name_conv)
|
||||
{
|
||||
FILE * convtab ;
|
||||
int nkeys ;
|
||||
int i ;
|
||||
char ** key_in ;
|
||||
char ** key_out ;
|
||||
int fd ;
|
||||
char * buf ;
|
||||
char line[NM_SIZ] ;
|
||||
char kw1[FITS_LINE],
|
||||
kw2[FITS_LINE] ;
|
||||
int lineno ;
|
||||
int fs ;
|
||||
struct stat fileinfo ;
|
||||
FILE *convtab;
|
||||
int nkeys;
|
||||
int i;
|
||||
char **key_in;
|
||||
char **key_out;
|
||||
int fd;
|
||||
char *buf;
|
||||
char line[NM_SIZ];
|
||||
char kw1[FITS_LINE], kw2[FITS_LINE];
|
||||
int lineno;
|
||||
int fs;
|
||||
struct stat fileinfo;
|
||||
|
||||
/* Read conversion table and translate it to key_in, key_out */
|
||||
if ((convtab = fopen(name_conv, "r")) == NULL) {
|
||||
fprintf(stderr, "cannot open conversion table: %s\n", name_conv) ;
|
||||
return -1 ;
|
||||
/* Read conversion table and translate it to key_in, key_out */
|
||||
if ((convtab = fopen (name_conv, "r")) == NULL)
|
||||
{
|
||||
fprintf (stderr, "cannot open conversion table: %s\n", name_conv);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* First, count how many keywords we need to translate */
|
||||
nkeys = 0 ;
|
||||
while (fgets(line, FITS_LINE, convtab)!=NULL) {
|
||||
if ((line[0] != '#') && (line[0] != '\n')) {
|
||||
nkeys ++ ;
|
||||
}
|
||||
/* First, count how many keywords we need to translate */
|
||||
nkeys = 0;
|
||||
while (fgets (line, FITS_LINE, convtab) != NULL)
|
||||
{
|
||||
if ((line[0] != '#') && (line[0] != '\n'))
|
||||
{
|
||||
nkeys++;
|
||||
}
|
||||
}
|
||||
rewind(convtab) ;
|
||||
rewind (convtab);
|
||||
|
||||
/* Allocate space to store keyword info */
|
||||
key_in = malloc(nkeys * sizeof(char*)) ;
|
||||
key_out = malloc(nkeys * sizeof(char*)) ;
|
||||
/* Allocate space to store keyword info */
|
||||
key_in = malloc (nkeys * sizeof (char *));
|
||||
key_out = malloc (nkeys * sizeof (char *));
|
||||
|
||||
/* Now read the file through and get the keywords */
|
||||
i = 0 ;
|
||||
lineno = 0 ;
|
||||
while (fgets(line, FITS_LINE, convtab)!=NULL) {
|
||||
lineno++ ;
|
||||
if ((line[0]!='#') && (line[0]!='\n')) {
|
||||
if (sscanf(line, "%[^=] = %[^;#]", kw1, kw2)!=2) {
|
||||
fprintf(stderr,
|
||||
"*** error parsing table file %s\n", name_conv);
|
||||
fprintf(stderr, "line: %d\n", lineno) ;
|
||||
free_keys(key_in, i) ;
|
||||
free_keys(key_out, i) ;
|
||||
fclose(convtab) ;
|
||||
return -1 ;
|
||||
}
|
||||
strip_beg_end(kw1) ;
|
||||
strip_beg_end(kw2) ;
|
||||
if (strlen(kw2)>strlen(kw1)) {
|
||||
fprintf(stderr,
|
||||
"*** error in conversion table %s (line %d)\n",
|
||||
name_conv, lineno);
|
||||
fprintf(stderr,
|
||||
"*** error: dest keyword is longer than original\n");
|
||||
fprintf(stderr, "orig: [%s] dest: [%s]\n", kw1, kw2);
|
||||
fclose(convtab) ;
|
||||
free_keys(key_in, i) ;
|
||||
free_keys(key_out, i) ;
|
||||
return -1 ;
|
||||
}
|
||||
key_in[i] = strdup(kw1) ;
|
||||
key_out[i] = strdup(kw2) ;
|
||||
i++ ;
|
||||
}
|
||||
/* Now read the file through and get the keywords */
|
||||
i = 0;
|
||||
lineno = 0;
|
||||
while (fgets (line, FITS_LINE, convtab) != NULL)
|
||||
{
|
||||
lineno++;
|
||||
if ((line[0] != '#') && (line[0] != '\n'))
|
||||
{
|
||||
if (sscanf (line, "%[^=] = %[^;#]", kw1, kw2) != 2)
|
||||
{
|
||||
fprintf (stderr,
|
||||
"*** error parsing table file %s\n", name_conv);
|
||||
fprintf (stderr, "line: %d\n", lineno);
|
||||
free_keys (key_in, i);
|
||||
free_keys (key_out, i);
|
||||
fclose (convtab);
|
||||
return -1;
|
||||
}
|
||||
strip_beg_end (kw1);
|
||||
strip_beg_end (kw2);
|
||||
if (strlen (kw2) > strlen (kw1))
|
||||
{
|
||||
fprintf (stderr,
|
||||
"*** error in conversion table %s (line %d)\n",
|
||||
name_conv, lineno);
|
||||
fprintf (stderr,
|
||||
"*** error: dest keyword is longer than original\n");
|
||||
fprintf (stderr, "orig: [%s] dest: [%s]\n", kw1, kw2);
|
||||
fclose (convtab);
|
||||
free_keys (key_in, i);
|
||||
free_keys (key_out, i);
|
||||
return -1;
|
||||
}
|
||||
key_in[i] = strdup (kw1);
|
||||
key_out[i] = strdup (kw2);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
fclose(convtab) ;
|
||||
fclose (convtab);
|
||||
|
||||
/* Print out some information about what is being done */
|
||||
printf("\n\n") ;
|
||||
printf("*** hierarch28\n") ;
|
||||
printf("\n") ;
|
||||
printf("searching %s and replacing the following keywords:\n", name_in) ;
|
||||
for (i=0 ; i<nkeys ; i++) {
|
||||
printf("\t[%s]\t=>\t[%s]\n", key_in[i], key_out[i]) ;
|
||||
/* Print out some information about what is being done */
|
||||
printf ("\n\n");
|
||||
printf ("*** hierarch28\n");
|
||||
printf ("\n");
|
||||
printf ("searching %s and replacing the following keywords:\n", name_in);
|
||||
for (i = 0; i < nkeys; i++)
|
||||
{
|
||||
printf ("\t[%s]\t=>\t[%s]\n", key_in[i], key_out[i]);
|
||||
}
|
||||
printf("\n\n") ;
|
||||
printf ("\n\n");
|
||||
|
||||
/* mmap the input file entirely */
|
||||
if (stat(name_in, &fileinfo)!=0) {
|
||||
fprintf(stderr, "*** error: accessing file [%s]\n", name_in);
|
||||
free_keys(key_in, nkeys) ;
|
||||
free_keys(key_out, nkeys) ;
|
||||
return -1 ;
|
||||
/* mmap the input file entirely */
|
||||
if (stat (name_in, &fileinfo) != 0)
|
||||
{
|
||||
fprintf (stderr, "*** error: accessing file [%s]\n", name_in);
|
||||
free_keys (key_in, nkeys);
|
||||
free_keys (key_out, nkeys);
|
||||
return -1;
|
||||
}
|
||||
fs = (int)fileinfo.st_size ;
|
||||
if (fs < 1) {
|
||||
fprintf(stderr, "error getting FITS header size for %s\n", name_in);
|
||||
free_keys(key_in, nkeys) ;
|
||||
free_keys(key_out, nkeys) ;
|
||||
return -1 ;
|
||||
fs = (int) fileinfo.st_size;
|
||||
if (fs < 1)
|
||||
{
|
||||
fprintf (stderr, "error getting FITS header size for %s\n", name_in);
|
||||
free_keys (key_in, nkeys);
|
||||
free_keys (key_out, nkeys);
|
||||
return -1;
|
||||
}
|
||||
fd = open(name_in, O_RDWR) ;
|
||||
if (fd == -1) {
|
||||
fprintf(stderr, "cannot open %s: aborting\n", name_in) ;
|
||||
free_keys(key_in, nkeys) ;
|
||||
free_keys(key_out, nkeys) ;
|
||||
return -1 ;
|
||||
fd = open (name_in, O_RDWR);
|
||||
if (fd == -1)
|
||||
{
|
||||
fprintf (stderr, "cannot open %s: aborting\n", name_in);
|
||||
free_keys (key_in, nkeys);
|
||||
free_keys (key_out, nkeys);
|
||||
return -1;
|
||||
}
|
||||
buf = (char*)mmap(0,
|
||||
fs,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
fd,
|
||||
0) ;
|
||||
if (buf == (char*)-1) {
|
||||
perror("mmap") ;
|
||||
fprintf(stderr, "cannot mmap file: %s\n", name_in) ;
|
||||
free_keys(key_in, nkeys) ;
|
||||
free_keys(key_out, nkeys) ;
|
||||
close(fd) ;
|
||||
return -1 ;
|
||||
buf = (char *) mmap (0, fs, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
if (buf == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
fprintf (stderr, "cannot mmap file: %s\n", name_in);
|
||||
free_keys (key_in, nkeys);
|
||||
free_keys (key_out, nkeys);
|
||||
close (fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Apply search and replace for the input keyword lists */
|
||||
if (search_and_replace_kw(buf, fs, key_in, key_out, nkeys) != 0) {
|
||||
fprintf(stderr, "error while doing search and replace\n") ;
|
||||
/* Apply search and replace for the input keyword lists */
|
||||
if (search_and_replace_kw (buf, fs, key_in, key_out, nkeys) != 0)
|
||||
{
|
||||
fprintf (stderr, "error while doing search and replace\n");
|
||||
}
|
||||
free_keys(key_in, nkeys) ;
|
||||
free_keys(key_out, nkeys) ;
|
||||
close(fd) ;
|
||||
munmap(buf, fs) ;
|
||||
return 0 ;
|
||||
free_keys (key_in, nkeys);
|
||||
free_keys (key_out, nkeys);
|
||||
close (fd);
|
||||
munmap (buf, fs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -325,19 +333,22 @@ static int convert_eso_to_std_FITS(char * name_in, char * name_conv)
|
|||
characters (like FITS keywords).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void strip_beg_end(char * s)
|
||||
static void
|
||||
strip_beg_end (char *s)
|
||||
{
|
||||
int beg, len ;
|
||||
int beg, len;
|
||||
|
||||
beg = 0 ;
|
||||
while (!isalnum((unsigned char)(s[beg]))) beg++ ;
|
||||
beg = 0;
|
||||
while (!isalnum ((unsigned char) (s[beg])))
|
||||
beg++;
|
||||
|
||||
len = (int)strlen(s) -1 ;
|
||||
while (!isalnum((unsigned char)(s[len]))) len -- ;
|
||||
len = (int) strlen (s) - 1;
|
||||
while (!isalnum ((unsigned char) (s[len])))
|
||||
len--;
|
||||
|
||||
strncpy(s, s+beg, len-beg+1) ;
|
||||
s[len-beg+1] = (char)0 ;
|
||||
return ;
|
||||
strncpy (s, s + beg, len - beg + 1);
|
||||
s[len - beg + 1] = (char) 0;
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -351,13 +362,16 @@ static void strip_beg_end(char * s)
|
|||
keys and the master table pointer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void free_keys(char ** keyt, int n)
|
||||
static void
|
||||
free_keys (char **keyt, int n)
|
||||
{
|
||||
int i ;
|
||||
int i;
|
||||
|
||||
if (n<1) return ;
|
||||
for (i=0 ; i<n ; i++) free(keyt[i]) ;
|
||||
free(keyt) ;
|
||||
if (n < 1)
|
||||
return;
|
||||
for (i = 0; i < n; i++)
|
||||
free (keyt[i]);
|
||||
free (keyt);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -374,74 +388,82 @@ static void free_keys(char ** keyt, int n)
|
|||
keyword changes in extensions too. Heavily optimized for speed.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int search_and_replace_kw(
|
||||
char * buf,
|
||||
int bufsize,
|
||||
char ** key_in,
|
||||
char ** key_out,
|
||||
int nk)
|
||||
static int
|
||||
search_and_replace_kw (char *buf,
|
||||
int bufsize, char **key_in, char **key_out, int nk)
|
||||
{
|
||||
char * w ;
|
||||
int i, j ;
|
||||
int in_header ;
|
||||
int match_flag ;
|
||||
int * keysizes ;
|
||||
char *w;
|
||||
int i, j;
|
||||
int in_header;
|
||||
int match_flag;
|
||||
int *keysizes;
|
||||
|
||||
/* Pre-compute key sizes to gain time */
|
||||
keysizes = malloc(nk * sizeof(int));
|
||||
for (i=0 ; i<nk ; i++) keysizes[i] = (int)strlen(key_in[i]);
|
||||
/* Pre-compute key sizes to gain time */
|
||||
keysizes = malloc (nk * sizeof (int));
|
||||
for (i = 0; i < nk; i++)
|
||||
keysizes[i] = (int) strlen (key_in[i]);
|
||||
|
||||
/* Browse through file line by line */
|
||||
w = buf ;
|
||||
in_header=1 ;
|
||||
while ((w-buf+FITS_LINE)<bufsize) {
|
||||
if (in_header) { /* Currently browsing a header */
|
||||
if (w[0]=='E' &&
|
||||
w[1]=='N' &&
|
||||
w[2]=='D' &&
|
||||
w[3]==' ') {
|
||||
/* Found an END keyword: exit from header */
|
||||
in_header=0 ;
|
||||
} else {
|
||||
/* Compare the current line with all searched keys */
|
||||
for (i=0 ; i<nk ; i++) {
|
||||
match_flag=1 ;
|
||||
for (j=0 ; j<=keysizes[i] ; j++) {
|
||||
if (j<keysizes[i]) {
|
||||
if (key_in[i][j]!=w[j]) {
|
||||
match_flag=0 ;
|
||||
break ;
|
||||
}
|
||||
} else {
|
||||
if ((w[j] != '=') && (w[j] != ' ')) {
|
||||
match_flag=0 ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (match_flag) {
|
||||
search_rep(w, key_in[i], key_out[i]);
|
||||
}
|
||||
}
|
||||
/* Browse through file line by line */
|
||||
w = buf;
|
||||
in_header = 1;
|
||||
while ((w - buf + FITS_LINE) < bufsize)
|
||||
{
|
||||
if (in_header)
|
||||
{ /* Currently browsing a header */
|
||||
if (w[0] == 'E' && w[1] == 'N' && w[2] == 'D' && w[3] == ' ')
|
||||
{
|
||||
/* Found an END keyword: exit from header */
|
||||
in_header = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Compare the current line with all searched keys */
|
||||
for (i = 0; i < nk; i++)
|
||||
{
|
||||
match_flag = 1;
|
||||
for (j = 0; j <= keysizes[i]; j++)
|
||||
{
|
||||
if (j < keysizes[i])
|
||||
{
|
||||
if (key_in[i][j] != w[j])
|
||||
{
|
||||
match_flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Currently out of header, look for next extension */
|
||||
if (w[0]=='X' &&
|
||||
w[1]=='T' &&
|
||||
w[2]=='E' &&
|
||||
w[3]=='N' &&
|
||||
w[4]=='S' &&
|
||||
w[5]=='I' &&
|
||||
w[6]=='O' &&
|
||||
w[7]=='N') {
|
||||
/* Found a header start */
|
||||
in_header=1 ;
|
||||
else
|
||||
{
|
||||
if ((w[j] != '=') && (w[j] != ' '))
|
||||
{
|
||||
match_flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (match_flag)
|
||||
{
|
||||
search_rep (w, key_in[i], key_out[i]);
|
||||
}
|
||||
}
|
||||
w+=FITS_LINE ;
|
||||
}
|
||||
}
|
||||
free(keysizes);
|
||||
return 0 ;
|
||||
else
|
||||
{
|
||||
/* Currently out of header, look for next extension */
|
||||
if (w[0] == 'X' &&
|
||||
w[1] == 'T' &&
|
||||
w[2] == 'E' &&
|
||||
w[3] == 'N' &&
|
||||
w[4] == 'S' && w[5] == 'I' && w[6] == 'O' && w[7] == 'N')
|
||||
{
|
||||
/* Found a header start */
|
||||
in_header = 1;
|
||||
}
|
||||
}
|
||||
w += FITS_LINE;
|
||||
}
|
||||
free (keysizes);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -457,92 +479,114 @@ static int search_and_replace_kw(
|
|||
conventions.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void search_rep(char * line, char * key_i, char * key_o)
|
||||
static void
|
||||
search_rep (char *line, char *key_i, char *key_o)
|
||||
{
|
||||
int i, j ;
|
||||
char * equal ;
|
||||
int to_copy ;
|
||||
char * p ;
|
||||
char tmp[FITS_LINE+1];
|
||||
char comment[FITS_LINE+1];
|
||||
int i, j;
|
||||
char *equal;
|
||||
int to_copy;
|
||||
char *p;
|
||||
char tmp[FITS_LINE + 1];
|
||||
char comment[FITS_LINE + 1];
|
||||
|
||||
equal = strstr(line, "=");
|
||||
to_copy = FITS_LINE - (equal-line);
|
||||
for (i=0 ; i<(int)strlen(key_o) ; i++) {
|
||||
line[i] = key_o[i] ;
|
||||
equal = strstr (line, "=");
|
||||
to_copy = FITS_LINE - (equal - line);
|
||||
for (i = 0; i < (int) strlen (key_o); i++)
|
||||
{
|
||||
line[i] = key_o[i];
|
||||
}
|
||||
if (strlen (key_o) <= 8)
|
||||
{
|
||||
/* Blank-pad until equal sign is reached */
|
||||
for (; i < 8; i++)
|
||||
{
|
||||
line[i] = ' ';
|
||||
}
|
||||
if (strlen(key_o)<=8) {
|
||||
/* Blank-pad until equal sign is reached */
|
||||
for ( ; i<8 ; i++) {
|
||||
line[i]=' ';
|
||||
}
|
||||
/* Add equal sign */
|
||||
line[i] = '=' ;
|
||||
i++ ;
|
||||
/* Add equal sign */
|
||||
line[i] = '=';
|
||||
i++;
|
||||
|
||||
/* Handle special cases: the value also needs conversion */
|
||||
if(!strcmp(key_o, "RA")) {
|
||||
if (*(equal+2)!='\'') {
|
||||
/* out key is RA, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr(line+i, '/');
|
||||
if (p)
|
||||
strncpy(comment, p, line+FITS_LINE-p);
|
||||
sprintf(tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str(atof(equal+1)/15.),
|
||||
(p)? comment : "/ Right Ascension");
|
||||
memcpy(line+i, tmp, 71);
|
||||
}
|
||||
} else if(!strcmp(key_o, "DEC")) {
|
||||
if( *(equal+2)!='\'') {
|
||||
/* out key is DEC, translate to '+DD:MM:SS.SSS' */
|
||||
p = strchr(line+i, '/');
|
||||
if (p)
|
||||
strncpy(comment, p, line+FITS_LINE-p);
|
||||
sprintf(tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str(atof(equal+1)),
|
||||
(p)? comment : "/ Declination");
|
||||
memcpy(line+i, tmp, 71);
|
||||
}
|
||||
} else if(!strcmp(key_o, "UT")) {
|
||||
if( *(equal+2)!='\'') {
|
||||
/* out key is UT, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr(line+i, '/');
|
||||
if (p)
|
||||
strncpy(comment, p, line+FITS_LINE-p);
|
||||
sprintf(tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str(atof(equal+1)/3600.),
|
||||
(p)? comment : "/ UT");
|
||||
memcpy(line+i, tmp, 71);
|
||||
}
|
||||
} else if(!strcmp(key_o, "ST")) {
|
||||
if( *(equal+2)!='\'') {
|
||||
/* out key is ST, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr(line+i, '/');
|
||||
if (p)
|
||||
strncpy(comment, p, line+FITS_LINE-p);
|
||||
sprintf(tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str(atof(equal+1)/3600.),
|
||||
(p)? comment : "/ ST");
|
||||
memcpy(line+i, tmp, 71);
|
||||
}
|
||||
} else {
|
||||
/* Copy line from first char after real equal sign */
|
||||
for (j=0 ; j<to_copy ; j++) {
|
||||
line[i+j] = equal[j+1];
|
||||
}
|
||||
i+=to_copy-1 ;
|
||||
/* Blank padding */
|
||||
for ( ; i<FITS_LINE ; i++) {
|
||||
line[i]=' ';
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Blank padding */
|
||||
for (i=(int)strlen(key_o) ; i<(int)strlen(key_i) ; i++) {
|
||||
line[i]=' ';
|
||||
}
|
||||
/* Handle special cases: the value also needs conversion */
|
||||
if (!strcmp (key_o, "RA"))
|
||||
{
|
||||
if (*(equal + 2) != '\'')
|
||||
{
|
||||
/* out key is RA, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr (line + i, '/');
|
||||
if (p)
|
||||
strncpy (comment, p, line + FITS_LINE - p);
|
||||
sprintf (tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str (atof (equal + 1) / 15.),
|
||||
(p) ? comment : "/ Right Ascension");
|
||||
memcpy (line + i, tmp, 71);
|
||||
}
|
||||
}
|
||||
return ;
|
||||
else if (!strcmp (key_o, "DEC"))
|
||||
{
|
||||
if (*(equal + 2) != '\'')
|
||||
{
|
||||
/* out key is DEC, translate to '+DD:MM:SS.SSS' */
|
||||
p = strchr (line + i, '/');
|
||||
if (p)
|
||||
strncpy (comment, p, line + FITS_LINE - p);
|
||||
sprintf (tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str (atof (equal + 1)),
|
||||
(p) ? comment : "/ Declination");
|
||||
memcpy (line + i, tmp, 71);
|
||||
}
|
||||
}
|
||||
else if (!strcmp (key_o, "UT"))
|
||||
{
|
||||
if (*(equal + 2) != '\'')
|
||||
{
|
||||
/* out key is UT, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr (line + i, '/');
|
||||
if (p)
|
||||
strncpy (comment, p, line + FITS_LINE - p);
|
||||
sprintf (tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str (atof (equal + 1) / 3600.),
|
||||
(p) ? comment : "/ UT");
|
||||
memcpy (line + i, tmp, 71);
|
||||
}
|
||||
}
|
||||
else if (!strcmp (key_o, "ST"))
|
||||
{
|
||||
if (*(equal + 2) != '\'')
|
||||
{
|
||||
/* out key is ST, translate to ' HH:MM:SS.SSS' */
|
||||
p = strchr (line + i, '/');
|
||||
if (p)
|
||||
strncpy (comment, p, line + FITS_LINE - p);
|
||||
sprintf (tmp, " %-29.29s %-40.40s",
|
||||
convert_deg_to_str (atof (equal + 1) / 3600.),
|
||||
(p) ? comment : "/ ST");
|
||||
memcpy (line + i, tmp, 71);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Copy line from first char after real equal sign */
|
||||
for (j = 0; j < to_copy; j++)
|
||||
{
|
||||
line[i + j] = equal[j + 1];
|
||||
}
|
||||
i += to_copy - 1;
|
||||
/* Blank padding */
|
||||
for (; i < FITS_LINE; i++)
|
||||
{
|
||||
line[i] = ' ';
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Blank padding */
|
||||
for (i = (int) strlen (key_o); i < (int) strlen (key_i); i++)
|
||||
{
|
||||
line[i] = ' ';
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -555,20 +599,22 @@ static void search_rep(char * line, char * key_i, char * key_o)
|
|||
instrument is specified (ins==NULL) a default table is generated.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void generate_default_convtab(void)
|
||||
static void
|
||||
generate_default_convtab (void)
|
||||
{
|
||||
FILE * convtab ;
|
||||
FILE *convtab;
|
||||
|
||||
if ((convtab = fopen("table.conv", "w")) == NULL) {
|
||||
fprintf(stderr, "*** error: cannot create table.conv: aborting\n") ;
|
||||
return ;
|
||||
if ((convtab = fopen ("table.conv", "w")) == NULL)
|
||||
{
|
||||
fprintf (stderr, "*** error: cannot create table.conv: aborting\n");
|
||||
return;
|
||||
}
|
||||
fprintf(convtab, CONVTAB_DEFAULT1);
|
||||
fprintf(convtab, CONVTAB_DEFAULT2);
|
||||
fprintf(convtab, CONVTAB_DEFAULT3);
|
||||
fprintf(convtab, CONVTAB_DEFAULT4);
|
||||
fclose(convtab) ;
|
||||
return ;
|
||||
fprintf (convtab, CONVTAB_DEFAULT1);
|
||||
fprintf (convtab, CONVTAB_DEFAULT2);
|
||||
fprintf (convtab, CONVTAB_DEFAULT3);
|
||||
fprintf (convtab, CONVTAB_DEFAULT4);
|
||||
fclose (convtab);
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -582,22 +628,24 @@ static void generate_default_convtab(void)
|
|||
string.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static char * convert_deg_to_str( double deg )
|
||||
static char *
|
||||
convert_deg_to_str (double deg)
|
||||
{
|
||||
int d, m;
|
||||
double s;
|
||||
int sign;
|
||||
static char buf[13];
|
||||
int d, m;
|
||||
double s;
|
||||
int sign;
|
||||
static char buf[13];
|
||||
|
||||
sign = 1;
|
||||
if(deg < 0.) sign = -1;
|
||||
sign = 1;
|
||||
if (deg < 0.)
|
||||
sign = -1;
|
||||
|
||||
deg *= sign;
|
||||
d = (int)deg;
|
||||
m = (int)( (deg - d) * 60);
|
||||
s = (deg - d) * 3600. - m * 60;
|
||||
deg *= sign;
|
||||
d = (int) deg;
|
||||
m = (int) ((deg - d) * 60);
|
||||
s = (deg - d) * 3600. - m * 60;
|
||||
|
||||
sprintf(buf, "'%c%02d:%02d:%06.3f'", (sign<0)? '-' : ' ', d, m, s);
|
||||
sprintf (buf, "'%c%02d:%02d:%06.3f'", (sign < 0) ? '-' : ' ', d, m, s);
|
||||
|
||||
return(buf);
|
||||
return (buf);
|
||||
}
|
||||
|
|
2353
qfits/saft/iofits.c
2353
qfits/saft/iofits.c
File diff suppressed because it is too large
Load Diff
|
@ -53,32 +53,35 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static int dump_pix(char*, char*);
|
||||
static int get_FITS_header_size(char *) ;
|
||||
static int filesize(char*) ;
|
||||
static int get_bitpix(char*) ;
|
||||
static int get_npix(char*) ;
|
||||
static int dump_pix (char *, char *);
|
||||
static int get_FITS_header_size (char *);
|
||||
static int filesize (char *);
|
||||
static int get_bitpix (char *);
|
||||
static int get_npix (char *);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Main
|
||||
-----------------------------------------------------------------------------*/
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
if (argc<3) {
|
||||
printf("\n\n") ;
|
||||
printf("use: %s <in> <out>\n", argv[0]) ;
|
||||
printf("\n") ;
|
||||
printf("\t<in> is a valid FITS file in the current directory\n") ;
|
||||
printf("\t<out> is the name of the output file\n") ;
|
||||
printf("\n\n") ;
|
||||
return 0 ;
|
||||
if (argc < 3)
|
||||
{
|
||||
printf ("\n\n");
|
||||
printf ("use: %s <in> <out>\n", argv[0]);
|
||||
printf ("\n");
|
||||
printf ("\t<in> is a valid FITS file in the current directory\n");
|
||||
printf ("\t<out> is the name of the output file\n");
|
||||
printf ("\n\n");
|
||||
return 0;
|
||||
}
|
||||
if (!strcmp(argv[1], argv[2])) {
|
||||
fprintf(stderr, "cannot convert a file to itself\n") ;
|
||||
fprintf(stderr, "specify another name for the output\n") ;
|
||||
return -1 ;
|
||||
if (!strcmp (argv[1], argv[2]))
|
||||
{
|
||||
fprintf (stderr, "cannot convert a file to itself\n");
|
||||
fprintf (stderr, "specify another name for the output\n");
|
||||
return -1;
|
||||
}
|
||||
return dump_pix(argv[1], argv[2]);
|
||||
return dump_pix (argv[1], argv[2]);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -90,108 +93,117 @@ int main(int argc, char *argv[])
|
|||
Heavy use of mmap() to speed up the process
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int dump_pix(
|
||||
char * name_in,
|
||||
char * name_out)
|
||||
static int
|
||||
dump_pix (char *name_in, char *name_out)
|
||||
{
|
||||
int fd_in,
|
||||
fd_out ;
|
||||
char * buf_in ;
|
||||
char * buf_out ;
|
||||
int fsize_in,
|
||||
fsize_out,
|
||||
header_size ;
|
||||
int npix ;
|
||||
int fd_in, fd_out;
|
||||
char *buf_in;
|
||||
char *buf_out;
|
||||
int fsize_in, fsize_out, header_size;
|
||||
int npix;
|
||||
|
||||
/*
|
||||
* Open input file and get information we need:
|
||||
* - pixel depth
|
||||
* - number of pixels
|
||||
*/
|
||||
/*
|
||||
* Open input file and get information we need:
|
||||
* - pixel depth
|
||||
* - number of pixels
|
||||
*/
|
||||
|
||||
fsize_in = filesize(name_in) ;
|
||||
header_size = get_FITS_header_size(name_in) ;
|
||||
if ((fd_in = open(name_in, O_RDONLY)) == -1) {
|
||||
fprintf(stderr, "cannot open file %s: aborting\n", name_in) ;
|
||||
return -1 ;
|
||||
fsize_in = filesize (name_in);
|
||||
header_size = get_FITS_header_size (name_in);
|
||||
if ((fd_in = open (name_in, O_RDONLY)) == -1)
|
||||
{
|
||||
fprintf (stderr, "cannot open file %s: aborting\n", name_in);
|
||||
return -1;
|
||||
}
|
||||
buf_in = (char*)mmap(0, fsize_in, PROT_READ, MAP_SHARED, fd_in, 0) ;
|
||||
if (buf_in == (char*)-1) {
|
||||
perror("mmap") ;
|
||||
fprintf(stderr, "cannot mmap file: %s\n", name_in) ;
|
||||
close(fd_in) ;
|
||||
return -1 ;
|
||||
buf_in = (char *) mmap (0, fsize_in, PROT_READ, MAP_SHARED, fd_in, 0);
|
||||
if (buf_in == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
fprintf (stderr, "cannot mmap file: %s\n", name_in);
|
||||
close (fd_in);
|
||||
return -1;
|
||||
}
|
||||
if (get_bitpix(buf_in) != -32) {
|
||||
fprintf(stderr, "only 32-bit IEEE floating point format supported\n");
|
||||
close(fd_in) ; munmap(buf_in, fsize_in) ;
|
||||
return -1 ;
|
||||
if (get_bitpix (buf_in) != -32)
|
||||
{
|
||||
fprintf (stderr, "only 32-bit IEEE floating point format supported\n");
|
||||
close (fd_in);
|
||||
munmap (buf_in, fsize_in);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute the size of the output file
|
||||
* same header size, + pixel area + blank padding
|
||||
*/
|
||||
npix = get_npix(buf_in) ;
|
||||
if (npix < 1) {
|
||||
fprintf(stderr, "cannot compute number of pixels\n");
|
||||
close(fd_in) ;
|
||||
munmap(buf_in, fsize_in) ;
|
||||
return -1 ;
|
||||
/*
|
||||
* Compute the size of the output file
|
||||
* same header size, + pixel area + blank padding
|
||||
*/
|
||||
npix = get_npix (buf_in);
|
||||
if (npix < 1)
|
||||
{
|
||||
fprintf (stderr, "cannot compute number of pixels\n");
|
||||
close (fd_in);
|
||||
munmap (buf_in, fsize_in);
|
||||
return -1;
|
||||
}
|
||||
fsize_out = npix * 4 ;
|
||||
/*
|
||||
* Now create the output file and fill it with zeros, then mmap it.
|
||||
* The permissions are rw-rw-r-- by default.
|
||||
*/
|
||||
if ((fd_out=creat(name_out,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH))==-1){
|
||||
perror("creat") ;
|
||||
fprintf(stderr, "cannot create file %s: aborting\n", name_out) ;
|
||||
close(fd_in) ; munmap(buf_in, fsize_in) ;
|
||||
return -1 ;
|
||||
fsize_out = npix * 4;
|
||||
/*
|
||||
* Now create the output file and fill it with zeros, then mmap it.
|
||||
* The permissions are rw-rw-r-- by default.
|
||||
*/
|
||||
if ((fd_out =
|
||||
creat (name_out,
|
||||
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH)) == -1)
|
||||
{
|
||||
perror ("creat");
|
||||
fprintf (stderr, "cannot create file %s: aborting\n", name_out);
|
||||
close (fd_in);
|
||||
munmap (buf_in, fsize_in);
|
||||
return -1;
|
||||
}
|
||||
|
||||
buf_out = malloc(fsize_out) ;
|
||||
if (buf_out == NULL) {
|
||||
fprintf(stderr, "not enough memory\n");
|
||||
fprintf(stderr, "failed to allocate %d bytes\n", fsize_out);
|
||||
close(fd_in) ; munmap(buf_in, fsize_in) ;
|
||||
return -1;
|
||||
buf_out = malloc (fsize_out);
|
||||
if (buf_out == NULL)
|
||||
{
|
||||
fprintf (stderr, "not enough memory\n");
|
||||
fprintf (stderr, "failed to allocate %d bytes\n", fsize_out);
|
||||
close (fd_in);
|
||||
munmap (buf_in, fsize_in);
|
||||
return -1;
|
||||
}
|
||||
write(fd_out, buf_out, fsize_out);
|
||||
close(fd_out);
|
||||
free(buf_out);
|
||||
write (fd_out, buf_out, fsize_out);
|
||||
close (fd_out);
|
||||
free (buf_out);
|
||||
|
||||
fd_out = open(name_out, O_RDWR);
|
||||
if (fd_out==-1) {
|
||||
fprintf(stderr, "error opening file %s\n", name_out);
|
||||
close(fd_in) ; munmap(buf_in, fsize_in) ;
|
||||
return -1;
|
||||
fd_out = open (name_out, O_RDWR);
|
||||
if (fd_out == -1)
|
||||
{
|
||||
fprintf (stderr, "error opening file %s\n", name_out);
|
||||
close (fd_in);
|
||||
munmap (buf_in, fsize_in);
|
||||
return -1;
|
||||
}
|
||||
buf_out = (char*)mmap(0,
|
||||
fsize_out,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
fd_out,
|
||||
0) ;
|
||||
if (buf_out == (char*)-1) {
|
||||
perror("mmap") ;
|
||||
fprintf(stderr, "cannot mmap file: %s\n", name_out) ;
|
||||
munmap(buf_in, fsize_in) ; close(fd_in) ; close(fd_out) ;
|
||||
return -1 ;
|
||||
buf_out = (char *) mmap (0,
|
||||
fsize_out,
|
||||
PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, 0);
|
||||
if (buf_out == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
fprintf (stderr, "cannot mmap file: %s\n", name_out);
|
||||
munmap (buf_in, fsize_in);
|
||||
close (fd_in);
|
||||
close (fd_out);
|
||||
return -1;
|
||||
}
|
||||
/*
|
||||
* Copy FITS header from input to output, modify BITPIX
|
||||
*/
|
||||
memcpy(buf_out, buf_in+header_size, fsize_out) ;
|
||||
/*
|
||||
* Close, unmap, goodbye
|
||||
*/
|
||||
close(fd_in) ;
|
||||
close(fd_out) ;
|
||||
munmap(buf_in, fsize_in) ;
|
||||
munmap(buf_out, fsize_out) ;
|
||||
return 0 ;
|
||||
/*
|
||||
* Copy FITS header from input to output, modify BITPIX
|
||||
*/
|
||||
memcpy (buf_out, buf_in + header_size, fsize_out);
|
||||
/*
|
||||
* Close, unmap, goodbye
|
||||
*/
|
||||
close (fd_in);
|
||||
close (fd_out);
|
||||
munmap (buf_in, fsize_in);
|
||||
munmap (buf_out, fsize_out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -203,40 +215,47 @@ static int dump_pix(
|
|||
80 characters are found per line.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int get_FITS_header_size(char * name)
|
||||
static int
|
||||
get_FITS_header_size (char *name)
|
||||
{
|
||||
FILE * in ;
|
||||
char line[81] ;
|
||||
int found = 0 ;
|
||||
int count ;
|
||||
int hs ;
|
||||
FILE *in;
|
||||
char line[81];
|
||||
int found = 0;
|
||||
int count;
|
||||
int hs;
|
||||
|
||||
if ((in = fopen(name, "r")) == NULL) {
|
||||
fprintf(stderr, "cannot open %s: aborting\n", name) ;
|
||||
return 0 ;
|
||||
if ((in = fopen (name, "r")) == NULL)
|
||||
{
|
||||
fprintf (stderr, "cannot open %s: aborting\n", name);
|
||||
return 0;
|
||||
}
|
||||
count = 0 ;
|
||||
while (!found) {
|
||||
if (fread(line, 1, 80, in)!=80) {
|
||||
break ;
|
||||
}
|
||||
count ++ ;
|
||||
if (!strncmp(line, "END ", 4)) {
|
||||
found = 1 ;
|
||||
}
|
||||
count = 0;
|
||||
while (!found)
|
||||
{
|
||||
if (fread (line, 1, 80, in) != 80)
|
||||
{
|
||||
break;
|
||||
}
|
||||
count++;
|
||||
if (!strncmp (line, "END ", 4))
|
||||
{
|
||||
found = 1;
|
||||
}
|
||||
}
|
||||
fclose(in);
|
||||
fclose (in);
|
||||
|
||||
if (!found) return 0 ;
|
||||
/*
|
||||
* The size is the number of found cards times 80,
|
||||
* rounded to the closest higher multiple of 2880.
|
||||
*/
|
||||
hs = count * 80 ;
|
||||
if ((hs % FITS_BLSZ) != 0) {
|
||||
hs = (1+(hs/FITS_BLSZ)) * FITS_BLSZ ;
|
||||
if (!found)
|
||||
return 0;
|
||||
/*
|
||||
* The size is the number of found cards times 80,
|
||||
* rounded to the closest higher multiple of 2880.
|
||||
*/
|
||||
hs = count * 80;
|
||||
if ((hs % FITS_BLSZ) != 0)
|
||||
{
|
||||
hs = (1 + (hs / FITS_BLSZ)) * FITS_BLSZ;
|
||||
}
|
||||
return hs ;
|
||||
return hs;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -247,18 +266,22 @@ static int get_FITS_header_size(char * name)
|
|||
Strongly non portable. Only on Unix systems!
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int filesize(char *filename)
|
||||
static int
|
||||
filesize (char *filename)
|
||||
{
|
||||
int size ;
|
||||
struct stat fileinfo ;
|
||||
int size;
|
||||
struct stat fileinfo;
|
||||
|
||||
/* POSIX compliant */
|
||||
if (stat(filename, &fileinfo) != 0) {
|
||||
size = (int)0 ;
|
||||
} else {
|
||||
size = (int)fileinfo.st_size ;
|
||||
/* POSIX compliant */
|
||||
if (stat (filename, &fileinfo) != 0)
|
||||
{
|
||||
size = (int) 0;
|
||||
}
|
||||
return size ;
|
||||
else
|
||||
{
|
||||
size = (int) fileinfo.st_size;
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -268,28 +291,28 @@ static int filesize(char *filename)
|
|||
@return int 8 16 32 -32 or -64 or 0 if cannot find it
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int get_bitpix(char * buf)
|
||||
static int
|
||||
get_bitpix (char *buf)
|
||||
{
|
||||
int bitpix ;
|
||||
char * where ;
|
||||
int bitpix;
|
||||
char *where;
|
||||
|
||||
where = strstr(buf, "BITPIX") ;
|
||||
if (where == NULL) {
|
||||
fprintf(stderr, "cannot find BITPIX in header: aborting\n") ;
|
||||
return 0 ;
|
||||
where = strstr (buf, "BITPIX");
|
||||
if (where == NULL)
|
||||
{
|
||||
fprintf (stderr, "cannot find BITPIX in header: aborting\n");
|
||||
return 0;
|
||||
}
|
||||
sscanf(where, "%*[^=] = %d", &bitpix) ;
|
||||
/*
|
||||
* Check the returned value makes sense
|
||||
*/
|
||||
if ((bitpix != 8) &&
|
||||
(bitpix != 16) &&
|
||||
(bitpix != 32) &&
|
||||
(bitpix != -32) &&
|
||||
(bitpix != -64)) {
|
||||
bitpix = 0 ;
|
||||
sscanf (where, "%*[^=] = %d", &bitpix);
|
||||
/*
|
||||
* Check the returned value makes sense
|
||||
*/
|
||||
if ((bitpix != 8) &&
|
||||
(bitpix != 16) && (bitpix != 32) && (bitpix != -32) && (bitpix != -64))
|
||||
{
|
||||
bitpix = 0;
|
||||
}
|
||||
return bitpix ;
|
||||
return bitpix;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -300,41 +323,45 @@ static int get_bitpix(char * buf)
|
|||
Does not support extensions!
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static int get_npix(char * buf)
|
||||
static int
|
||||
get_npix (char *buf)
|
||||
{
|
||||
int naxes ;
|
||||
int npix ;
|
||||
int naxis ;
|
||||
char * where ;
|
||||
char lookfor[80] ;
|
||||
int i ;
|
||||
int naxes;
|
||||
int npix;
|
||||
int naxis;
|
||||
char *where;
|
||||
char lookfor[80];
|
||||
int i;
|
||||
|
||||
where = strstr(buf, "NAXIS") ;
|
||||
if (where == NULL) {
|
||||
fprintf(stderr, "cannot find NAXIS in header: aborting\n") ;
|
||||
return 0 ;
|
||||
where = strstr (buf, "NAXIS");
|
||||
if (where == NULL)
|
||||
{
|
||||
fprintf (stderr, "cannot find NAXIS in header: aborting\n");
|
||||
return 0;
|
||||
}
|
||||
sscanf(where, "%*[^=] = %d", &naxes) ;
|
||||
if ((naxes<1) || (naxes>999)) {
|
||||
fprintf(stderr, "illegal value for %s: %d\n", lookfor, naxes) ;
|
||||
return 0 ;
|
||||
sscanf (where, "%*[^=] = %d", &naxes);
|
||||
if ((naxes < 1) || (naxes > 999))
|
||||
{
|
||||
fprintf (stderr, "illegal value for %s: %d\n", lookfor, naxes);
|
||||
return 0;
|
||||
}
|
||||
npix = 1 ;
|
||||
for (i=1 ; i<=naxes ; i++) {
|
||||
sprintf(lookfor, "NAXIS%d", i) ;
|
||||
where = strstr(buf, lookfor) ;
|
||||
if (where == NULL) {
|
||||
fprintf(stderr, "cannot find %s in header: aborting\n",
|
||||
lookfor) ;
|
||||
return 0 ;
|
||||
}
|
||||
sscanf(where, "%*[^=] = %d", &naxis) ;
|
||||
if (naxis<1) {
|
||||
fprintf(stderr, "error: found %s=%d\n", lookfor, naxis);
|
||||
return 0 ;
|
||||
}
|
||||
npix *= (int)naxis ;
|
||||
npix = 1;
|
||||
for (i = 1; i <= naxes; i++)
|
||||
{
|
||||
sprintf (lookfor, "NAXIS%d", i);
|
||||
where = strstr (buf, lookfor);
|
||||
if (where == NULL)
|
||||
{
|
||||
fprintf (stderr, "cannot find %s in header: aborting\n", lookfor);
|
||||
return 0;
|
||||
}
|
||||
sscanf (where, "%*[^=] = %d", &naxis);
|
||||
if (naxis < 1)
|
||||
{
|
||||
fprintf (stderr, "error: found %s=%d\n", lookfor, naxis);
|
||||
return 0;
|
||||
}
|
||||
npix *= (int) naxis;
|
||||
}
|
||||
return npix ;
|
||||
return npix;
|
||||
}
|
||||
|
||||
|
|
|
@ -51,15 +51,16 @@
|
|||
modifying the passed argument. Assembler included for x86 architectures.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
unsigned short __NOTRACE__ swap_bytes_16(unsigned short w)
|
||||
unsigned short __NOTRACE__
|
||||
swap_bytes_16 (unsigned short w)
|
||||
{
|
||||
#ifdef CPU_X86
|
||||
__asm("xchgb %b0,%h0" :
|
||||
"=q" (w) :
|
||||
"0" (w));
|
||||
return w ;
|
||||
__asm ("xchgb %b0,%h0":
|
||||
"=q" (w):
|
||||
"0" (w));
|
||||
return w;
|
||||
#else
|
||||
return (((w) & 0x00ff) << 8 | ((w) & 0xff00) >> 8);
|
||||
return (((w) & 0x00ff) << 8 | ((w) & 0xff00) >> 8);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -74,23 +75,22 @@ unsigned short __NOTRACE__ swap_bytes_16(unsigned short w)
|
|||
and optimized for processors above 386.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
unsigned int __NOTRACE__ swap_bytes_32(unsigned int dw)
|
||||
unsigned int __NOTRACE__
|
||||
swap_bytes_32 (unsigned int dw)
|
||||
{
|
||||
#ifdef CPU_X86
|
||||
#if CPU_X86 > 386
|
||||
__asm("bswap %0":
|
||||
"=r" (dw) :
|
||||
__asm ("bswap %0":
|
||||
"=r" (dw):
|
||||
#else
|
||||
__asm("xchgb %b0,%h0\n"
|
||||
" rorl $16,%0\n"
|
||||
" xchgb %b0,%h0":
|
||||
"=q" (dw) :
|
||||
__asm ("xchgb %b0,%h0\n" " rorl $16,%0\n" " xchgb %b0,%h0":
|
||||
"=q" (dw):
|
||||
#endif
|
||||
"0" (dw));
|
||||
return dw ;
|
||||
"0" (dw));
|
||||
return dw;
|
||||
#else
|
||||
return ((((dw) & 0xff000000) >> 24) | (((dw) & 0x00ff0000) >> 8) |
|
||||
(((dw) & 0x0000ff00) << 8) | (((dw) & 0x000000ff) << 24));
|
||||
return ((((dw) & 0xff000000) >> 24) | (((dw) & 0x00ff0000) >> 8) |
|
||||
(((dw) & 0x0000ff00) << 8) | (((dw) & 0x000000ff) << 24));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -107,17 +107,19 @@ unsigned int __NOTRACE__ swap_bytes_32(unsigned int dw)
|
|||
everywhere this file compiles.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void __NOTRACE__ swap_bytes(void * p, int s)
|
||||
void __NOTRACE__
|
||||
swap_bytes (void *p, int s)
|
||||
{
|
||||
unsigned char tmp, *a, *b ;
|
||||
unsigned char tmp, *a, *b;
|
||||
|
||||
a = (unsigned char*)p ;
|
||||
b = a + s ;
|
||||
a = (unsigned char *) p;
|
||||
b = a + s;
|
||||
|
||||
while (a<b) {
|
||||
tmp = *a ;
|
||||
*a++ = *--b ;
|
||||
*b = tmp ;
|
||||
while (a < b)
|
||||
{
|
||||
tmp = *a;
|
||||
*a++ = *--b;
|
||||
*b = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -131,10 +133,11 @@ void __NOTRACE__ swap_bytes(void * p, int s)
|
|||
MOTOROLA-like one does not.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int need_byteswapping(void)
|
||||
int
|
||||
need_byteswapping (void)
|
||||
{
|
||||
short ps = 0xFF ;
|
||||
return ((*((char*)(&ps))) ? 1 : 0 ) ;
|
||||
short ps = 0xFF;
|
||||
return ((*((char *) (&ps))) ? 1 : 0);
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
1073
qfits/src/cache.c
1073
qfits/src/cache.c
File diff suppressed because it is too large
Load Diff
|
@ -56,7 +56,7 @@
|
|||
fairly small, you should not need to care too much about this.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_cache_purge(void);
|
||||
void qfits_cache_purge (void);
|
||||
/* </dox> */
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -116,7 +116,7 @@ void qfits_cache_purge(void);
|
|||
of the FITS file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_query(char * filename, int what);
|
||||
int qfits_query (char *filename, int what);
|
||||
|
||||
#endif
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -40,20 +40,23 @@
|
|||
@return string
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static char * expkey_strupc(const char * s)
|
||||
static char *
|
||||
expkey_strupc (const char *s)
|
||||
{
|
||||
static char l[ASCIILINESZ+1];
|
||||
int i ;
|
||||
static char l[ASCIILINESZ + 1];
|
||||
int i;
|
||||
|
||||
if (s==NULL) return NULL ;
|
||||
memset(l, 0, ASCIILINESZ+1);
|
||||
i=0 ;
|
||||
while (s[i] && i<ASCIILINESZ) {
|
||||
l[i] = (char)toupper((int)s[i]);
|
||||
i++ ;
|
||||
if (s == NULL)
|
||||
return NULL;
|
||||
memset (l, 0, ASCIILINESZ + 1);
|
||||
i = 0;
|
||||
while (s[i] && i < ASCIILINESZ)
|
||||
{
|
||||
l[i] = (char) toupper ((int) s[i]);
|
||||
i++;
|
||||
}
|
||||
l[ASCIILINESZ]=(char)0;
|
||||
return l ;
|
||||
l[ASCIILINESZ] = (char) 0;
|
||||
return l;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -76,28 +79,33 @@ static char * expkey_strupc(const char * s)
|
|||
not dots '.') the result is identical to the input.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_expand_keyword(const char * keyword)
|
||||
char *
|
||||
qfits_expand_keyword (const char *keyword)
|
||||
{
|
||||
static char expanded[81];
|
||||
char ws[81];
|
||||
char * token ;
|
||||
static char expanded[81];
|
||||
char ws[81];
|
||||
char *token;
|
||||
|
||||
/* Bulletproof entries */
|
||||
if (keyword==NULL) return NULL ;
|
||||
/* If regular keyword, copy the uppercased input and return */
|
||||
if (strstr(keyword, ".")==NULL) {
|
||||
strcpy(expanded, expkey_strupc(keyword));
|
||||
return expanded ;
|
||||
}
|
||||
/* Regular shortFITS keyword */
|
||||
sprintf(expanded, "HIERARCH ESO");
|
||||
strcpy(ws, expkey_strupc(keyword));
|
||||
token = strtok(ws, ".");
|
||||
while (token!=NULL) {
|
||||
strcat(expanded, " ");
|
||||
strcat(expanded, token);
|
||||
token = strtok(NULL, ".");
|
||||
}
|
||||
return expanded ;
|
||||
/* Bulletproof entries */
|
||||
if (keyword == NULL)
|
||||
return NULL;
|
||||
/* If regular keyword, copy the uppercased input and return */
|
||||
if (strstr (keyword, ".") == NULL)
|
||||
{
|
||||
strcpy (expanded, expkey_strupc (keyword));
|
||||
return expanded;
|
||||
}
|
||||
/* Regular shortFITS keyword */
|
||||
sprintf (expanded, "HIERARCH ESO");
|
||||
strcpy (ws, expkey_strupc (keyword));
|
||||
token = strtok (ws, ".");
|
||||
while (token != NULL)
|
||||
{
|
||||
strcat (expanded, " ");
|
||||
strcat (expanded, token);
|
||||
token = strtok (NULL, ".");
|
||||
}
|
||||
return expanded;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -46,7 +46,7 @@
|
|||
not dots '.') the result is identical to the input.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_expand_keyword(const char * keyword);
|
||||
char *qfits_expand_keyword (const char *keyword);
|
||||
/* </dox> */
|
||||
|
||||
#endif
|
||||
|
|
1530
qfits/src/fits_h.c
1530
qfits/src/fits_h.c
File diff suppressed because it is too large
Load Diff
|
@ -23,7 +23,8 @@
|
|||
#define FITS_HEADER_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -50,11 +51,12 @@ extern "C" {
|
|||
accessor functions.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef struct qfits_header {
|
||||
void * first ; /* Pointer to list start */
|
||||
void * last ; /* Pointer to list end */
|
||||
int n ; /* Number of cards in list */
|
||||
} qfits_header ;
|
||||
typedef struct qfits_header
|
||||
{
|
||||
void *first; /* Pointer to list start */
|
||||
void *last; /* Pointer to list end */
|
||||
int n; /* Number of cards in list */
|
||||
} qfits_header;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function ANSI prototypes
|
||||
|
@ -69,7 +71,7 @@ typedef struct qfits_header {
|
|||
an allocated linked-list handler with an empty card list.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_new(void) ;
|
||||
qfits_header *qfits_header_new (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -81,7 +83,7 @@ qfits_header * qfits_header_new(void) ;
|
|||
(SIMPLE=T) and the last one (END).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_default(void) ;
|
||||
qfits_header *qfits_header_default (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -99,12 +101,8 @@ qfits_header * qfits_header_default(void) ;
|
|||
are allowed to get NULL values.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_add(
|
||||
qfits_header * hdr,
|
||||
char * key,
|
||||
char * val,
|
||||
char * com,
|
||||
char * lin) ;
|
||||
void qfits_header_add (qfits_header * hdr,
|
||||
char *key, char *val, char *com, char *lin);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -122,13 +120,9 @@ void qfits_header_add(
|
|||
can be NULL, except after and key.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_add_after(
|
||||
qfits_header * hdr,
|
||||
char * after,
|
||||
char * key,
|
||||
char * val,
|
||||
char * com,
|
||||
char * lin) ;
|
||||
void qfits_header_add_after (qfits_header * hdr,
|
||||
char *after,
|
||||
char *key, char *val, char *com, char *lin);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -144,12 +138,10 @@ void qfits_header_add_after(
|
|||
NULL except key.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_append(
|
||||
qfits_header * hdr,
|
||||
const char * key,
|
||||
const char * val,
|
||||
const char * com,
|
||||
const char * lin) ;
|
||||
void qfits_header_append (qfits_header * hdr,
|
||||
const char *key,
|
||||
const char *val,
|
||||
const char *com, const char *lin);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -162,7 +154,7 @@ void qfits_header_append(
|
|||
the key is removed.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_del(qfits_header * hdr, char * key) ;
|
||||
void qfits_header_del (qfits_header * hdr, char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -178,7 +170,7 @@ void qfits_header_del(qfits_header * hdr, char * key) ;
|
|||
line is set to NULL in the card.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_mod(qfits_header * hdr, char * key, char * val, char * com) ;
|
||||
void qfits_header_mod (qfits_header * hdr, char *key, char *val, char *com);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -187,7 +179,7 @@ void qfits_header_mod(qfits_header * hdr, char * key, char * val, char * com) ;
|
|||
@return -1 in error case, 0 otherwise
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_sort(qfits_header ** hdr) ;
|
||||
int qfits_header_sort (qfits_header ** hdr);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -199,7 +191,7 @@ int qfits_header_sort(qfits_header ** hdr) ;
|
|||
header. The returned header must be freed using qfits_header_destroy.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_copy(qfits_header * src) ;
|
||||
qfits_header *qfits_header_copy (qfits_header * src);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -211,7 +203,7 @@ qfits_header * qfits_header_copy(qfits_header * src) ;
|
|||
freed and set to NULL. Useful when a header needs to be reformatted.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_touchall(qfits_header * hdr) ;
|
||||
void qfits_header_touchall (qfits_header * hdr);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -222,7 +214,7 @@ void qfits_header_touchall(qfits_header * hdr) ;
|
|||
Dump a FITS header to stdout. Mostly for debugging purposes.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_consoledump(qfits_header * hdr) ;
|
||||
void qfits_header_consoledump (qfits_header * hdr);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -233,7 +225,7 @@ void qfits_header_consoledump(qfits_header * hdr) ;
|
|||
Frees all memory associated to a given qfits_header object.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_header_destroy(qfits_header * hdr) ;
|
||||
void qfits_header_destroy (qfits_header * hdr);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -249,7 +241,7 @@ void qfits_header_destroy(qfits_header * hdr) ;
|
|||
Returns NULL if no matching key is found or no value is attached.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_header_getstr(qfits_header * hdr, const char * key) ;
|
||||
char *qfits_header_getstr (qfits_header * hdr, const char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -273,7 +265,7 @@ char * qfits_header_getstr(qfits_header * hdr, const char * key) ;
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_header_findmatch(qfits_header * hdr, char * key) ;
|
||||
char *qfits_header_findmatch (qfits_header * hdr, char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -312,13 +304,9 @@ char * qfits_header_findmatch(qfits_header * hdr, char * key) ;
|
|||
available in this module.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_getitem(
|
||||
qfits_header * hdr,
|
||||
int idx,
|
||||
char * key,
|
||||
char * val,
|
||||
char * com,
|
||||
char * lin) ;
|
||||
int qfits_header_getitem (qfits_header * hdr,
|
||||
int idx,
|
||||
char *key, char *val, char *com, char *lin);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -334,7 +322,7 @@ int qfits_header_getitem(
|
|||
Returns NULL if no matching key is found or no line is attached.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_header_getline(qfits_header * hdr, char * key) ;
|
||||
char *qfits_header_getline (qfits_header * hdr, char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -351,7 +339,7 @@ char * qfits_header_getline(qfits_header * hdr, char * key) ;
|
|||
Returns NULL if no matching key is found or no comment is attached.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_header_getcom(qfits_header * hdr, char * key) ;
|
||||
char *qfits_header_getcom (qfits_header * hdr, char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -366,7 +354,7 @@ char * qfits_header_getcom(qfits_header * hdr, char * key) ;
|
|||
attached.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_getint(qfits_header * hdr, const char * key, int errval) ;
|
||||
int qfits_header_getint (qfits_header * hdr, const char *key, int errval);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -381,7 +369,8 @@ int qfits_header_getint(qfits_header * hdr, const char * key, int errval) ;
|
|||
attached.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
double qfits_header_getdouble(qfits_header * hdr, const char * key, double errval) ;
|
||||
double qfits_header_getdouble (qfits_header * hdr, const char *key,
|
||||
double errval);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -405,7 +394,8 @@ double qfits_header_getdouble(qfits_header * hdr, const char * key, double errva
|
|||
beginning with a 'n' (no), a 'f' (false) or the digit '0'.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_getboolean(qfits_header * hdr, const char * key, int errval) ;
|
||||
int qfits_header_getboolean (qfits_header * hdr, const char *key,
|
||||
int errval);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -421,7 +411,7 @@ int qfits_header_getboolean(qfits_header * hdr, const char * key, int errval) ;
|
|||
Formatting is done according to FITS standard.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void keytuple2str(char * line, char * key, char * val, char * com) ;
|
||||
void keytuple2str (char *line, char *key, char *val, char *com);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -433,7 +423,7 @@ void keytuple2str(char * line, char * key, char * val, char * com) ;
|
|||
Dumps a FITS header to an opened file pointer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_dump(qfits_header * hdr, FILE * out) ;
|
||||
int qfits_header_dump (qfits_header * hdr, FILE * out);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -446,7 +436,7 @@ int qfits_header_dump(qfits_header * hdr, FILE * out) ;
|
|||
This function is meant to create hdr files.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_header_dump_hdr(qfits_header * hdr, FILE * out) ;
|
||||
int qfits_header_dump_hdr (qfits_header * hdr, FILE * out);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -464,7 +454,7 @@ int qfits_header_dump_hdr(qfits_header * hdr, FILE * out) ;
|
|||
'hsize'. The returned block must be deallocated using free().
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_header_to_memblock(qfits_header * fh, int * hsize) ;
|
||||
char *qfits_header_to_memblock (qfits_header * fh, int *hsize);
|
||||
/* </dox> */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -58,121 +58,128 @@
|
|||
of error.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_datamd5(char * filename)
|
||||
char *
|
||||
qfits_datamd5 (char *filename)
|
||||
{
|
||||
static char datamd5[MD5HASHSZ+1] ;
|
||||
struct MD5Context ctx ;
|
||||
unsigned char digest[16] ;
|
||||
FILE * in ;
|
||||
char buf[FITS_BLOCK_SIZE];
|
||||
char * buf_c ;
|
||||
int i ;
|
||||
int in_header ;
|
||||
int check_fits ;
|
||||
static char datamd5[MD5HASHSZ + 1];
|
||||
struct MD5Context ctx;
|
||||
unsigned char digest[16];
|
||||
FILE *in;
|
||||
char buf[FITS_BLOCK_SIZE];
|
||||
char *buf_c;
|
||||
int i;
|
||||
int in_header;
|
||||
int check_fits;
|
||||
|
||||
/* Check entries */
|
||||
if (filename==NULL) return NULL ;
|
||||
/* Open input file */
|
||||
if ((in=fopen(filename, "r"))==NULL) {
|
||||
qfits_error("cannot open file %s", filename);
|
||||
return NULL ;
|
||||
/* Check entries */
|
||||
if (filename == NULL)
|
||||
return NULL;
|
||||
/* Open input file */
|
||||
if ((in = fopen (filename, "r")) == NULL)
|
||||
{
|
||||
qfits_error ("cannot open file %s", filename);
|
||||
return NULL;
|
||||
}
|
||||
/* Initialize all variables */
|
||||
MD5Init(&ctx);
|
||||
in_header=1 ;
|
||||
check_fits=0 ;
|
||||
/* Loop over input file */
|
||||
while (fread(buf, 1, FITS_BLOCK_SIZE, in)==FITS_BLOCK_SIZE) {
|
||||
/* First time in the loop: check the file is FITS */
|
||||
if (check_fits==0) {
|
||||
/* Examine first characters in block */
|
||||
if (buf[0]!='S' ||
|
||||
buf[1]!='I' ||
|
||||
buf[2]!='M' ||
|
||||
buf[3]!='P' ||
|
||||
buf[4]!='L' ||
|
||||
buf[5]!='E' ||
|
||||
buf[6]!=' ' ||
|
||||
buf[7]!=' ' ||
|
||||
buf[8]!='=') {
|
||||
qfits_error("file [%s] is not FITS\n", filename);
|
||||
fclose(in);
|
||||
return NULL ;
|
||||
} else {
|
||||
check_fits=1 ;
|
||||
}
|
||||
}
|
||||
if (in_header) {
|
||||
buf_c = buf ;
|
||||
for (i=0 ; i<FITS_NCARDS ; i++) {
|
||||
if (buf_c[0]=='E' &&
|
||||
buf_c[1]=='N' &&
|
||||
buf_c[2]=='D' &&
|
||||
buf_c[3]==' ') {
|
||||
in_header=0 ;
|
||||
break ;
|
||||
}
|
||||
buf_c += FITS_LINESZ ;
|
||||
}
|
||||
} else {
|
||||
/* If current block is a data block */
|
||||
/* Try to locate an extension header */
|
||||
if (buf[0]=='X' &&
|
||||
buf[1]=='T' &&
|
||||
buf[2]=='E' &&
|
||||
buf[3]=='N' &&
|
||||
buf[4]=='S' &&
|
||||
buf[5]=='I' &&
|
||||
buf[6]=='O' &&
|
||||
buf[7]=='N' &&
|
||||
buf[8]=='=') {
|
||||
in_header=1 ;
|
||||
buf_c = buf ;
|
||||
for (i=0 ; i<FITS_NCARDS ; i++) {
|
||||
/* Try to find an END marker in this block */
|
||||
if (buf_c[0]=='E' &&
|
||||
buf_c[1]=='N' &&
|
||||
buf_c[2]=='D' &&
|
||||
buf_c[3]==' ') {
|
||||
/* Found END marker in same block as XTENSION */
|
||||
in_header=0;
|
||||
break ;
|
||||
}
|
||||
buf_c += FITS_LINESZ ;
|
||||
}
|
||||
} else {
|
||||
MD5Update(&ctx, (unsigned char *)buf, FITS_BLOCK_SIZE);
|
||||
}
|
||||
}
|
||||
}
|
||||
fclose(in);
|
||||
if (check_fits==0) {
|
||||
/* Never went through the read loop: file is not FITS */
|
||||
qfits_error("file [%s] is not FITS", filename);
|
||||
return NULL ;
|
||||
/* Initialize all variables */
|
||||
MD5Init (&ctx);
|
||||
in_header = 1;
|
||||
check_fits = 0;
|
||||
/* Loop over input file */
|
||||
while (fread (buf, 1, FITS_BLOCK_SIZE, in) == FITS_BLOCK_SIZE)
|
||||
{
|
||||
/* First time in the loop: check the file is FITS */
|
||||
if (check_fits == 0)
|
||||
{
|
||||
/* Examine first characters in block */
|
||||
if (buf[0] != 'S' ||
|
||||
buf[1] != 'I' ||
|
||||
buf[2] != 'M' ||
|
||||
buf[3] != 'P' ||
|
||||
buf[4] != 'L' ||
|
||||
buf[5] != 'E' ||
|
||||
buf[6] != ' ' || buf[7] != ' ' || buf[8] != '=')
|
||||
{
|
||||
qfits_error ("file [%s] is not FITS\n", filename);
|
||||
fclose (in);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
check_fits = 1;
|
||||
}
|
||||
}
|
||||
/* Got to the end of file: summarize */
|
||||
MD5Final(digest, &ctx);
|
||||
/* Write digest into a string */
|
||||
sprintf(datamd5,
|
||||
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
digest[ 0],
|
||||
digest[ 1],
|
||||
digest[ 2],
|
||||
digest[ 3],
|
||||
digest[ 4],
|
||||
digest[ 5],
|
||||
digest[ 6],
|
||||
digest[ 7],
|
||||
digest[ 8],
|
||||
digest[ 9],
|
||||
digest[10],
|
||||
digest[11],
|
||||
digest[12],
|
||||
digest[13],
|
||||
digest[14],
|
||||
digest[15]);
|
||||
return datamd5 ;
|
||||
if (in_header)
|
||||
{
|
||||
buf_c = buf;
|
||||
for (i = 0; i < FITS_NCARDS; i++)
|
||||
{
|
||||
if (buf_c[0] == 'E' &&
|
||||
buf_c[1] == 'N' && buf_c[2] == 'D' && buf_c[3] == ' ')
|
||||
{
|
||||
in_header = 0;
|
||||
break;
|
||||
}
|
||||
buf_c += FITS_LINESZ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* If current block is a data block */
|
||||
/* Try to locate an extension header */
|
||||
if (buf[0] == 'X' &&
|
||||
buf[1] == 'T' &&
|
||||
buf[2] == 'E' &&
|
||||
buf[3] == 'N' &&
|
||||
buf[4] == 'S' &&
|
||||
buf[5] == 'I' &&
|
||||
buf[6] == 'O' && buf[7] == 'N' && buf[8] == '=')
|
||||
{
|
||||
in_header = 1;
|
||||
buf_c = buf;
|
||||
for (i = 0; i < FITS_NCARDS; i++)
|
||||
{
|
||||
/* Try to find an END marker in this block */
|
||||
if (buf_c[0] == 'E' &&
|
||||
buf_c[1] == 'N' && buf_c[2] == 'D' && buf_c[3] == ' ')
|
||||
{
|
||||
/* Found END marker in same block as XTENSION */
|
||||
in_header = 0;
|
||||
break;
|
||||
}
|
||||
buf_c += FITS_LINESZ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
MD5Update (&ctx, (unsigned char *) buf, FITS_BLOCK_SIZE);
|
||||
}
|
||||
}
|
||||
}
|
||||
fclose (in);
|
||||
if (check_fits == 0)
|
||||
{
|
||||
/* Never went through the read loop: file is not FITS */
|
||||
qfits_error ("file [%s] is not FITS", filename);
|
||||
return NULL;
|
||||
}
|
||||
/* Got to the end of file: summarize */
|
||||
MD5Final (digest, &ctx);
|
||||
/* Write digest into a string */
|
||||
sprintf (datamd5,
|
||||
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
digest[0],
|
||||
digest[1],
|
||||
digest[2],
|
||||
digest[3],
|
||||
digest[4],
|
||||
digest[5],
|
||||
digest[6],
|
||||
digest[7],
|
||||
digest[8],
|
||||
digest[9],
|
||||
digest[10],
|
||||
digest[11], digest[12], digest[13], digest[14], digest[15]);
|
||||
return datamd5;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -49,7 +49,7 @@
|
|||
of error.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_datamd5(char * filename);
|
||||
char *qfits_datamd5 (char *filename);
|
||||
/* </dox> */
|
||||
|
||||
#endif
|
||||
|
|
|
@ -50,63 +50,73 @@
|
|||
allocated in this function, so do not modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getkey(char * line)
|
||||
char *
|
||||
qfits_getkey (char *line)
|
||||
{
|
||||
static char key[81];
|
||||
int i ;
|
||||
static char key[81];
|
||||
int i;
|
||||
|
||||
if (line==NULL) {
|
||||
if (line == NULL)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getkey: NULL input line\n");
|
||||
printf ("qfits_getkey: NULL input line\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Special case: blank keyword */
|
||||
if (!strncmp(line, " ", 8)) {
|
||||
strcpy(key, " ");
|
||||
return key ;
|
||||
}
|
||||
/* Sort out special cases: HISTORY, COMMENT, END do not have = in line */
|
||||
if (!strncmp(line, "HISTORY ", 8)) {
|
||||
strcpy(key, "HISTORY");
|
||||
return key ;
|
||||
}
|
||||
if (!strncmp(line, "COMMENT ", 8)) {
|
||||
strcpy(key, "COMMENT");
|
||||
return key ;
|
||||
}
|
||||
if (!strncmp(line, "END ", 4)) {
|
||||
strcpy(key, "END");
|
||||
return key ;
|
||||
}
|
||||
/* Special case: blank keyword */
|
||||
if (!strncmp (line, " ", 8))
|
||||
{
|
||||
strcpy (key, " ");
|
||||
return key;
|
||||
}
|
||||
/* Sort out special cases: HISTORY, COMMENT, END do not have = in line */
|
||||
if (!strncmp (line, "HISTORY ", 8))
|
||||
{
|
||||
strcpy (key, "HISTORY");
|
||||
return key;
|
||||
}
|
||||
if (!strncmp (line, "COMMENT ", 8))
|
||||
{
|
||||
strcpy (key, "COMMENT");
|
||||
return key;
|
||||
}
|
||||
if (!strncmp (line, "END ", 4))
|
||||
{
|
||||
strcpy (key, "END");
|
||||
return key;
|
||||
}
|
||||
|
||||
memset(key, 0, 81);
|
||||
/* General case: look for the first equal sign */
|
||||
i=0 ;
|
||||
while (line[i]!='=' && i<80) i++ ;
|
||||
if (i>=80) {
|
||||
memset (key, 0, 81);
|
||||
/* General case: look for the first equal sign */
|
||||
i = 0;
|
||||
while (line[i] != '=' && i < 80)
|
||||
i++;
|
||||
if (i >= 80)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getkey: cannot find equal sign\n");
|
||||
printf ("qfits_getkey: cannot find equal sign\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
i-- ;
|
||||
/* Equal sign found, now backtrack on blanks */
|
||||
while (line[i]==' ' && i>=0) i-- ;
|
||||
if (i<=0) {
|
||||
return NULL;
|
||||
}
|
||||
i--;
|
||||
/* Equal sign found, now backtrack on blanks */
|
||||
while (line[i] == ' ' && i >= 0)
|
||||
i--;
|
||||
if (i <= 0)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getkey: error backtracking on blanks\n");
|
||||
printf ("qfits_getkey: error backtracking on blanks\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
i++ ;
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy(key, line, i) ;
|
||||
/* Null-terminate the string */
|
||||
key[i+1] = (char)0;
|
||||
return key ;
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy (key, line, i);
|
||||
/* Null-terminate the string */
|
||||
key[i + 1] = (char) 0;
|
||||
return key;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -121,124 +131,145 @@ char * qfits_getkey(char * line)
|
|||
modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getvalue(char * line)
|
||||
char *
|
||||
qfits_getvalue (char *line)
|
||||
{
|
||||
static char value[81] ;
|
||||
int i ;
|
||||
int from, to ;
|
||||
int inq ;
|
||||
static char value[81];
|
||||
int i;
|
||||
int from, to;
|
||||
int inq;
|
||||
|
||||
if (line==NULL) {
|
||||
if (line == NULL)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: NULL input line\n");
|
||||
printf ("qfits_getvalue: NULL input line\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
/* Special cases */
|
||||
|
||||
/* END has no associated value */
|
||||
if (!strncmp(line, "END ", 4)) {
|
||||
return NULL ;
|
||||
}
|
||||
/*
|
||||
* HISTORY has for value everything else on the line, stripping
|
||||
* blanks before and after. Blank HISTORY is also accepted.
|
||||
*/
|
||||
memset(value, 0, 81);
|
||||
|
||||
if (!strncmp(line, "HISTORY ", 8) || !strncmp(line, " ", 8)) {
|
||||
i=7 ;
|
||||
/* Strip blanks from the left side */
|
||||
while (line[i]==' ' && i<80) i++ ;
|
||||
if (i>=80) return NULL ; /* Blank HISTORY */
|
||||
from=i ;
|
||||
|
||||
/* Strip blanks from the right side */
|
||||
to=79 ;
|
||||
while (line[to]==' ') to-- ;
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy(value, line+from, to-from+1);
|
||||
/* Null-terminate the string */
|
||||
value[to-from+1] = (char)0;
|
||||
return value ;
|
||||
} else if (!strncmp(line, "COMMENT ", 8)) {
|
||||
/* COMMENT is like HISTORY */
|
||||
/* Strip blanks from the left side */
|
||||
i=7 ;
|
||||
while (line[i]==' ' && i<80) i++ ;
|
||||
if (i>=80) return NULL ;
|
||||
from=i ;
|
||||
|
||||
/* Strip blanks from the right side */
|
||||
to=79 ;
|
||||
while (line[to]==' ') to-- ;
|
||||
|
||||
if (to<from) {
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: inconsistent value search in COMMENT\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy(value, line+from, to-from+1);
|
||||
/* Null-terminate the string */
|
||||
value[to-from+1] = (char)0;
|
||||
return value ;
|
||||
}
|
||||
/* General case - Get past the keyword */
|
||||
i=0 ;
|
||||
while (line[i]!='=' && i<80) i++ ;
|
||||
if (i>80) {
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: no equal sign found on line\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
i++ ;
|
||||
while (line[i]==' ' && i<80) i++ ;
|
||||
if (i>80) {
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: no value past the equal sign\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
from=i;
|
||||
|
||||
/* Now value section: Look for the first slash '/' outside a string */
|
||||
inq = 0 ;
|
||||
while (i<80) {
|
||||
if (line[i]=='\'')
|
||||
inq=!inq ;
|
||||
if (line[i]=='/')
|
||||
if (!inq)
|
||||
break ;
|
||||
i++;
|
||||
return NULL;
|
||||
}
|
||||
i-- ;
|
||||
|
||||
/* Backtrack on blanks */
|
||||
while (line[i]==' ' && i>=0) i-- ;
|
||||
if (i<0) {
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: error backtracking on blanks\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
to=i ;
|
||||
/* Special cases */
|
||||
|
||||
if (to<from) {
|
||||
/* END has no associated value */
|
||||
if (!strncmp (line, "END ", 4))
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
/*
|
||||
* HISTORY has for value everything else on the line, stripping
|
||||
* blanks before and after. Blank HISTORY is also accepted.
|
||||
*/
|
||||
memset (value, 0, 81);
|
||||
|
||||
if (!strncmp (line, "HISTORY ", 8) || !strncmp (line, " ", 8))
|
||||
{
|
||||
i = 7;
|
||||
/* Strip blanks from the left side */
|
||||
while (line[i] == ' ' && i < 80)
|
||||
i++;
|
||||
if (i >= 80)
|
||||
return NULL; /* Blank HISTORY */
|
||||
from = i;
|
||||
|
||||
/* Strip blanks from the right side */
|
||||
to = 79;
|
||||
while (line[to] == ' ')
|
||||
to--;
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy (value, line + from, to - from + 1);
|
||||
/* Null-terminate the string */
|
||||
value[to - from + 1] = (char) 0;
|
||||
return value;
|
||||
}
|
||||
else if (!strncmp (line, "COMMENT ", 8))
|
||||
{
|
||||
/* COMMENT is like HISTORY */
|
||||
/* Strip blanks from the left side */
|
||||
i = 7;
|
||||
while (line[i] == ' ' && i < 80)
|
||||
i++;
|
||||
if (i >= 80)
|
||||
return NULL;
|
||||
from = i;
|
||||
|
||||
/* Strip blanks from the right side */
|
||||
to = 79;
|
||||
while (line[to] == ' ')
|
||||
to--;
|
||||
|
||||
if (to < from)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getvalue: from>to?\n");
|
||||
printf("line=[%s]\n", line);
|
||||
printf ("qfits_getvalue: inconsistent value search in COMMENT\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
return NULL;
|
||||
}
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy(value, line+from, to-from+1);
|
||||
/* Null-terminate the string */
|
||||
value[to-from+1] = (char)0;
|
||||
return value ;
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy (value, line + from, to - from + 1);
|
||||
/* Null-terminate the string */
|
||||
value[to - from + 1] = (char) 0;
|
||||
return value;
|
||||
}
|
||||
/* General case - Get past the keyword */
|
||||
i = 0;
|
||||
while (line[i] != '=' && i < 80)
|
||||
i++;
|
||||
if (i > 80)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf ("qfits_getvalue: no equal sign found on line\n");
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
while (line[i] == ' ' && i < 80)
|
||||
i++;
|
||||
if (i > 80)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf ("qfits_getvalue: no value past the equal sign\n");
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
from = i;
|
||||
|
||||
/* Now value section: Look for the first slash '/' outside a string */
|
||||
inq = 0;
|
||||
while (i < 80)
|
||||
{
|
||||
if (line[i] == '\'')
|
||||
inq = !inq;
|
||||
if (line[i] == '/')
|
||||
if (!inq)
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
i--;
|
||||
|
||||
/* Backtrack on blanks */
|
||||
while (line[i] == ' ' && i >= 0)
|
||||
i--;
|
||||
if (i < 0)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf ("qfits_getvalue: error backtracking on blanks\n");
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
to = i;
|
||||
|
||||
if (to < from)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf ("qfits_getvalue: from>to?\n");
|
||||
printf ("line=[%s]\n", line);
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy (value, line + from, to - from + 1);
|
||||
/* Null-terminate the string */
|
||||
value[to - from + 1] = (char) 0;
|
||||
return value;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -253,74 +284,87 @@ char * qfits_getvalue(char * line)
|
|||
modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getcomment(char * line)
|
||||
char *
|
||||
qfits_getcomment (char *line)
|
||||
{
|
||||
static char comment[81];
|
||||
int i ;
|
||||
int from, to ;
|
||||
int inq ;
|
||||
static char comment[81];
|
||||
int i;
|
||||
int from, to;
|
||||
int inq;
|
||||
|
||||
if (line==NULL) {
|
||||
if (line == NULL)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getcomment: null line in input\n");
|
||||
printf ("qfits_getcomment: null line in input\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Special cases: END, HISTORY, COMMENT and blank have no comment */
|
||||
if (!strncmp(line, "END ", 4)) return NULL ;
|
||||
if (!strncmp(line, "HISTORY ", 8)) return NULL ;
|
||||
if (!strncmp(line, "COMMENT ", 8)) return NULL ;
|
||||
if (!strncmp(line, " ", 8)) return NULL ;
|
||||
/* Special cases: END, HISTORY, COMMENT and blank have no comment */
|
||||
if (!strncmp (line, "END ", 4))
|
||||
return NULL;
|
||||
if (!strncmp (line, "HISTORY ", 8))
|
||||
return NULL;
|
||||
if (!strncmp (line, "COMMENT ", 8))
|
||||
return NULL;
|
||||
if (!strncmp (line, " ", 8))
|
||||
return NULL;
|
||||
|
||||
memset(comment, 0, 81);
|
||||
/* Get past the keyword */
|
||||
i=0 ;
|
||||
while (line[i]!='=' && i<80) i++ ;
|
||||
if (i>=80) {
|
||||
memset (comment, 0, 81);
|
||||
/* Get past the keyword */
|
||||
i = 0;
|
||||
while (line[i] != '=' && i < 80)
|
||||
i++;
|
||||
if (i >= 80)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getcomment: no equal sign on line\n");
|
||||
printf ("qfits_getcomment: no equal sign on line\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
i++ ;
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
|
||||
/* Get past the value until the slash */
|
||||
inq = 0 ;
|
||||
while (i<80) {
|
||||
if (line[i]=='\'')
|
||||
inq = !inq ;
|
||||
if (line[i]=='/')
|
||||
if (!inq)
|
||||
break ;
|
||||
i++ ;
|
||||
}
|
||||
if (i>=80) {
|
||||
/* Get past the value until the slash */
|
||||
inq = 0;
|
||||
while (i < 80)
|
||||
{
|
||||
if (line[i] == '\'')
|
||||
inq = !inq;
|
||||
if (line[i] == '/')
|
||||
if (!inq)
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
if (i >= 80)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getcomment: no slash found on line\n");
|
||||
printf ("qfits_getcomment: no slash found on line\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
i++ ;
|
||||
/* Get past the first blanks */
|
||||
while (line[i]==' ') i++ ;
|
||||
from=i ;
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
/* Get past the first blanks */
|
||||
while (line[i] == ' ')
|
||||
i++;
|
||||
from = i;
|
||||
|
||||
/* Now backtrack from the end of the line to the first non-blank char */
|
||||
to=79 ;
|
||||
while (line[to]==' ') to-- ;
|
||||
/* Now backtrack from the end of the line to the first non-blank char */
|
||||
to = 79;
|
||||
while (line[to] == ' ')
|
||||
to--;
|
||||
|
||||
if (to<from) {
|
||||
if (to < from)
|
||||
{
|
||||
#ifdef DEBUG_FITSHEADER
|
||||
printf("qfits_getcomment: from>to?\n");
|
||||
printf ("qfits_getcomment: from>to?\n");
|
||||
#endif
|
||||
return NULL ;
|
||||
}
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy(comment, line+from, to-from+1);
|
||||
/* Null-terminate the string */
|
||||
comment[to-from+1] = (char)0;
|
||||
return comment ;
|
||||
return NULL;
|
||||
}
|
||||
/* Copy relevant characters into output buffer */
|
||||
strncpy (comment, line + from, to - from + 1);
|
||||
/* Null-terminate the string */
|
||||
comment[to - from + 1] = (char) 0;
|
||||
return comment;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -22,7 +22,8 @@
|
|||
#define FITSEP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/* <dox> */
|
||||
|
@ -41,7 +42,7 @@ extern "C" {
|
|||
allocated in this function, so do not modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getkey(char * line) ;
|
||||
char *qfits_getkey (char *line);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -55,7 +56,7 @@ char * qfits_getkey(char * line) ;
|
|||
modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getvalue(char * line) ;
|
||||
char *qfits_getvalue (char *line);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -69,7 +70,7 @@ char * qfits_getvalue(char * line) ;
|
|||
modify or try to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_getcomment(char * line) ;
|
||||
char *qfits_getcomment (char *line);
|
||||
/* </dox> */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -35,14 +35,17 @@
|
|||
/*-----------------------------------------------------------------------------
|
||||
Private to this module
|
||||
-----------------------------------------------------------------------------*/
|
||||
static int is_blank_line(char * s)
|
||||
static int
|
||||
is_blank_line (char *s)
|
||||
{
|
||||
int i ;
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<(int)strlen(s) ; i++) {
|
||||
if (s[i]!=' ') return 0 ;
|
||||
for (i = 0; i < (int) strlen (s); i++)
|
||||
{
|
||||
if (s[i] != ' ')
|
||||
return 0;
|
||||
}
|
||||
return 1 ;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -70,10 +73,11 @@ static int is_blank_line(char * s)
|
|||
Value, comment, and original line might be NULL pointers.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read(char * filename)
|
||||
qfits_header *
|
||||
qfits_header_read (char *filename)
|
||||
{
|
||||
/* Forward job to readext */
|
||||
return qfits_header_readext(filename, 0);
|
||||
/* Forward job to readext */
|
||||
return qfits_header_readext (filename, 0);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -88,76 +92,86 @@ qfits_header * qfits_header_read(char * filename)
|
|||
a hdr file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read_hdr(char * filename)
|
||||
qfits_header *
|
||||
qfits_header_read_hdr (char *filename)
|
||||
{
|
||||
qfits_header * hdr ;
|
||||
FILE * in ;
|
||||
char line[81];
|
||||
char * key,
|
||||
* val,
|
||||
* com ;
|
||||
int i, j ;
|
||||
qfits_header *hdr;
|
||||
FILE *in;
|
||||
char line[81];
|
||||
char *key, *val, *com;
|
||||
int i, j;
|
||||
|
||||
/* Check input */
|
||||
if (filename==NULL) return NULL ;
|
||||
/* Check input */
|
||||
if (filename == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Initialise */
|
||||
key = val = com = NULL ;
|
||||
/* Initialise */
|
||||
key = val = com = NULL;
|
||||
|
||||
/* Open the file */
|
||||
if ((in=fopen(filename, "r"))==NULL) {
|
||||
qfits_error("cannot read [%s]", filename) ;
|
||||
return NULL ;
|
||||
/* Open the file */
|
||||
if ((in = fopen (filename, "r")) == NULL)
|
||||
{
|
||||
qfits_error ("cannot read [%s]", filename);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create the header */
|
||||
hdr = qfits_header_new() ;
|
||||
/* Create the header */
|
||||
hdr = qfits_header_new ();
|
||||
|
||||
/* Go through the file */
|
||||
while (fgets(line, 81, in)!=NULL) {
|
||||
for (i=0 ; i<81 ; i++) {
|
||||
if (line[i] == '\n') {
|
||||
for (j=i ; j<81 ; j++) line[j] = ' ' ;
|
||||
line[80] = (char)0 ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (!strcmp(line, "END")) {
|
||||
line[3] = ' ';
|
||||
line[4] = (char)0 ;
|
||||
}
|
||||
/* Go through the file */
|
||||
while (fgets (line, 81, in) != NULL)
|
||||
{
|
||||
for (i = 0; i < 81; i++)
|
||||
{
|
||||
if (line[i] == '\n')
|
||||
{
|
||||
for (j = i; j < 81; j++)
|
||||
line[j] = ' ';
|
||||
line[80] = (char) 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!strcmp (line, "END"))
|
||||
{
|
||||
line[3] = ' ';
|
||||
line[4] = (char) 0;
|
||||
}
|
||||
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line(line)) {
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line (line))
|
||||
{
|
||||
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey(line);
|
||||
val = qfits_getvalue(line);
|
||||
com = qfits_getcomment(line);
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey (line);
|
||||
val = qfits_getvalue (line);
|
||||
com = qfits_getcomment (line);
|
||||
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key==NULL) {
|
||||
qfits_header_destroy(hdr);
|
||||
fclose(in) ;
|
||||
return NULL ;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append(hdr, key, val, com, NULL);
|
||||
}
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key == NULL)
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
fclose (in);
|
||||
return NULL;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append (hdr, key, val, com, NULL);
|
||||
}
|
||||
}
|
||||
fclose(in) ;
|
||||
fclose (in);
|
||||
|
||||
/* The last key should be 'END' */
|
||||
if (strlen(key)!=3) {
|
||||
qfits_header_destroy(hdr);
|
||||
return NULL ;
|
||||
/* The last key should be 'END' */
|
||||
if (strlen (key) != 3)
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
return NULL;
|
||||
}
|
||||
if (key[0]!='E' || key[1]!='N' || key[2]!='D') {
|
||||
qfits_header_destroy(hdr);
|
||||
return NULL ;
|
||||
if (key[0] != 'E' || key[1] != 'N' || key[2] != 'D')
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return hdr ;
|
||||
return hdr;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -171,74 +185,81 @@ qfits_header * qfits_header_read_hdr(char * filename)
|
|||
object.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read_hdr_string(
|
||||
unsigned char * hdr_str,
|
||||
int nb_char)
|
||||
qfits_header *
|
||||
qfits_header_read_hdr_string (unsigned char *hdr_str, int nb_char)
|
||||
{
|
||||
qfits_header * hdr ;
|
||||
char line[81];
|
||||
char * key,
|
||||
* val,
|
||||
* com ;
|
||||
int ind ;
|
||||
int i, j ;
|
||||
qfits_header *hdr;
|
||||
char line[81];
|
||||
char *key, *val, *com;
|
||||
int ind;
|
||||
int i, j;
|
||||
|
||||
/* Check input */
|
||||
if (hdr_str==NULL) return NULL ;
|
||||
/* Check input */
|
||||
if (hdr_str == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Initialise */
|
||||
key = val = com = NULL ;
|
||||
/* Initialise */
|
||||
key = val = com = NULL;
|
||||
|
||||
/* Create the header */
|
||||
hdr = qfits_header_new() ;
|
||||
/* Create the header */
|
||||
hdr = qfits_header_new ();
|
||||
|
||||
/* Go through the file */
|
||||
ind = 0 ;
|
||||
while (ind <= nb_char - 80) {
|
||||
strncpy(line, (char*)hdr_str + ind, 80) ;
|
||||
line[80] = (char)0 ;
|
||||
for (i=0 ; i<81 ; i++) {
|
||||
if (line[i] == '\n') {
|
||||
for (j=i ; j<81 ; j++) line[j] = ' ' ;
|
||||
line[80] = (char)0 ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (!strcmp(line, "END")) {
|
||||
line[3] = ' ';
|
||||
line[4] = (char)0 ;
|
||||
}
|
||||
/* Go through the file */
|
||||
ind = 0;
|
||||
while (ind <= nb_char - 80)
|
||||
{
|
||||
strncpy (line, (char *) hdr_str + ind, 80);
|
||||
line[80] = (char) 0;
|
||||
for (i = 0; i < 81; i++)
|
||||
{
|
||||
if (line[i] == '\n')
|
||||
{
|
||||
for (j = i; j < 81; j++)
|
||||
line[j] = ' ';
|
||||
line[80] = (char) 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!strcmp (line, "END"))
|
||||
{
|
||||
line[3] = ' ';
|
||||
line[4] = (char) 0;
|
||||
}
|
||||
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line(line)) {
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line (line))
|
||||
{
|
||||
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey(line);
|
||||
val = qfits_getvalue(line);
|
||||
com = qfits_getcomment(line);
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey (line);
|
||||
val = qfits_getvalue (line);
|
||||
com = qfits_getcomment (line);
|
||||
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key==NULL) {
|
||||
qfits_header_destroy(hdr);
|
||||
return NULL ;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append(hdr, key, val, com, NULL);
|
||||
}
|
||||
ind += 80 ;
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key == NULL)
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
return NULL;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append (hdr, key, val, com, NULL);
|
||||
}
|
||||
ind += 80;
|
||||
}
|
||||
|
||||
/* The last key should be 'END' */
|
||||
if (strlen(key)!=3) {
|
||||
qfits_header_destroy(hdr);
|
||||
return NULL ;
|
||||
/* The last key should be 'END' */
|
||||
if (strlen (key) != 3)
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
return NULL;
|
||||
}
|
||||
if (key[0]!='E' || key[1]!='N' || key[2]!='D') {
|
||||
qfits_header_destroy(hdr);
|
||||
return NULL ;
|
||||
if (key[0] != 'E' || key[1] != 'N' || key[2] != 'D')
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return hdr ;
|
||||
return hdr;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -255,80 +276,85 @@ qfits_header * qfits_header_read_hdr_string(
|
|||
Returns NULL in case of error.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_readext(char * filename, int xtnum)
|
||||
qfits_header *
|
||||
qfits_header_readext (char *filename, int xtnum)
|
||||
{
|
||||
qfits_header* hdr ;
|
||||
int n_ext ;
|
||||
char line[81];
|
||||
char * where ;
|
||||
char * start ;
|
||||
char * key,
|
||||
* val,
|
||||
* com ;
|
||||
int seg_start ;
|
||||
int seg_size ;
|
||||
size_t size ;
|
||||
qfits_header *hdr;
|
||||
int n_ext;
|
||||
char line[81];
|
||||
char *where;
|
||||
char *start;
|
||||
char *key, *val, *com;
|
||||
int seg_start;
|
||||
int seg_size;
|
||||
size_t size;
|
||||
|
||||
/* Check input */
|
||||
if (filename==NULL || xtnum<0)
|
||||
return NULL ;
|
||||
/* Check input */
|
||||
if (filename == NULL || xtnum < 0)
|
||||
return NULL;
|
||||
|
||||
/* Check that there are enough extensions */
|
||||
if (xtnum>0) {
|
||||
n_ext = qfits_query_n_ext(filename);
|
||||
if (xtnum>n_ext) {
|
||||
return NULL ;
|
||||
}
|
||||
/* Check that there are enough extensions */
|
||||
if (xtnum > 0)
|
||||
{
|
||||
n_ext = qfits_query_n_ext (filename);
|
||||
if (xtnum > n_ext)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Get offset to the extension header */
|
||||
if (qfits_get_hdrinfo(filename, xtnum, &seg_start, &seg_size)!=0) {
|
||||
return NULL ;
|
||||
/* Get offset to the extension header */
|
||||
if (qfits_get_hdrinfo (filename, xtnum, &seg_start, &seg_size) != 0)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Memory-map the input file */
|
||||
start = falloc(filename, seg_start, &size) ;
|
||||
if (start==NULL) return NULL ;
|
||||
/* Memory-map the input file */
|
||||
start = falloc (filename, seg_start, &size);
|
||||
if (start == NULL)
|
||||
return NULL;
|
||||
|
||||
hdr = qfits_header_new() ;
|
||||
where = start ;
|
||||
while (1) {
|
||||
memcpy(line, where, 80);
|
||||
line[80] = (char)0;
|
||||
hdr = qfits_header_new ();
|
||||
where = start;
|
||||
while (1)
|
||||
{
|
||||
memcpy (line, where, 80);
|
||||
line[80] = (char) 0;
|
||||
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line(line)) {
|
||||
/* Rule out blank lines */
|
||||
if (!is_blank_line (line))
|
||||
{
|
||||
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey(line);
|
||||
val = qfits_getvalue(line);
|
||||
com = qfits_getcomment(line);
|
||||
/* Get key, value, comment for the current line */
|
||||
key = qfits_getkey (line);
|
||||
val = qfits_getvalue (line);
|
||||
com = qfits_getcomment (line);
|
||||
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key==NULL) {
|
||||
qfits_header_destroy(hdr);
|
||||
hdr = NULL ;
|
||||
break ;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append(hdr, key, val, com, line);
|
||||
/* Check for END keyword */
|
||||
if (strlen(key)==3)
|
||||
if (key[0]=='E' &&
|
||||
key[1]=='N' &&
|
||||
key[2]=='D')
|
||||
break ;
|
||||
}
|
||||
where += 80 ;
|
||||
/* If reaching the end of file, trigger an error */
|
||||
if ((int)(where-start)>=(int)(seg_size+80)) {
|
||||
qfits_header_destroy(hdr);
|
||||
hdr = NULL ;
|
||||
break ;
|
||||
}
|
||||
/* If key or value cannot be found, trigger an error */
|
||||
if (key == NULL)
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
hdr = NULL;
|
||||
break;
|
||||
}
|
||||
/* Append card to linked-list */
|
||||
qfits_header_append (hdr, key, val, com, line);
|
||||
/* Check for END keyword */
|
||||
if (strlen (key) == 3)
|
||||
if (key[0] == 'E' && key[1] == 'N' && key[2] == 'D')
|
||||
break;
|
||||
}
|
||||
where += 80;
|
||||
/* If reaching the end of file, trigger an error */
|
||||
if ((int) (where - start) >= (int) (seg_size + 80))
|
||||
{
|
||||
qfits_header_destroy (hdr);
|
||||
hdr = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
fdealloc(start, seg_start, size) ;
|
||||
return hdr ;
|
||||
fdealloc (start, seg_start, size);
|
||||
return hdr;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -341,34 +367,38 @@ qfits_header * qfits_header_readext(char * filename, int xtnum)
|
|||
for the file size to reach a multiple of 2880, as required by FITS.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_zeropad(char * filename)
|
||||
void
|
||||
qfits_zeropad (char *filename)
|
||||
{
|
||||
struct stat sta ;
|
||||
int size ;
|
||||
int remaining;
|
||||
FILE * out ;
|
||||
char * buf;
|
||||
struct stat sta;
|
||||
int size;
|
||||
int remaining;
|
||||
FILE *out;
|
||||
char *buf;
|
||||
|
||||
if (filename==NULL) return ;
|
||||
if (filename == NULL)
|
||||
return;
|
||||
|
||||
/* Get file size in bytes */
|
||||
if (stat(filename, &sta)!=0) {
|
||||
return ;
|
||||
/* Get file size in bytes */
|
||||
if (stat (filename, &sta) != 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
size = (int)sta.st_size ;
|
||||
/* Compute number of zeros to pad */
|
||||
remaining = size % FITS_BLOCK_SIZE ;
|
||||
if (remaining==0) return ;
|
||||
remaining = FITS_BLOCK_SIZE - remaining ;
|
||||
size = (int) sta.st_size;
|
||||
/* Compute number of zeros to pad */
|
||||
remaining = size % FITS_BLOCK_SIZE;
|
||||
if (remaining == 0)
|
||||
return;
|
||||
remaining = FITS_BLOCK_SIZE - remaining;
|
||||
|
||||
/* Open file, dump zeros, exit */
|
||||
if ((out=fopen(filename, "a"))==NULL)
|
||||
return ;
|
||||
buf = calloc(remaining, sizeof(char));
|
||||
fwrite(buf, 1, remaining, out);
|
||||
fclose(out);
|
||||
free(buf);
|
||||
return ;
|
||||
/* Open file, dump zeros, exit */
|
||||
if ((out = fopen (filename, "a")) == NULL)
|
||||
return;
|
||||
buf = calloc (remaining, sizeof (char));
|
||||
fwrite (buf, 1, remaining, out);
|
||||
fclose (out);
|
||||
free (buf);
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -381,28 +411,31 @@ void qfits_zeropad(char * filename)
|
|||
0 else. If the file does not exist, returns -1.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int is_fits_file(char *filename)
|
||||
int
|
||||
is_fits_file (char *filename)
|
||||
{
|
||||
FILE * fp ;
|
||||
char * magic ;
|
||||
int isfits ;
|
||||
FILE *fp;
|
||||
char *magic;
|
||||
int isfits;
|
||||
|
||||
if (filename==NULL) return -1 ;
|
||||
if ((fp = fopen(filename, "r"))==NULL) {
|
||||
qfits_error("cannot open file [%s]", filename) ;
|
||||
return -1 ;
|
||||
if (filename == NULL)
|
||||
return -1;
|
||||
if ((fp = fopen (filename, "r")) == NULL)
|
||||
{
|
||||
qfits_error ("cannot open file [%s]", filename);
|
||||
return -1;
|
||||
}
|
||||
|
||||
magic = calloc(FITS_MAGIC_SZ+1, sizeof(char)) ;
|
||||
fread(magic, 1, FITS_MAGIC_SZ, fp) ;
|
||||
fclose(fp) ;
|
||||
magic[FITS_MAGIC_SZ] = (char)0 ;
|
||||
if (strstr(magic, FITS_MAGIC)!=NULL)
|
||||
isfits = 1 ;
|
||||
else
|
||||
isfits = 0 ;
|
||||
free(magic) ;
|
||||
return isfits ;
|
||||
magic = calloc (FITS_MAGIC_SZ + 1, sizeof (char));
|
||||
fread (magic, 1, FITS_MAGIC_SZ, fp);
|
||||
fclose (fp);
|
||||
magic[FITS_MAGIC_SZ] = (char) 0;
|
||||
if (strstr (magic, FITS_MAGIC) != NULL)
|
||||
isfits = 1;
|
||||
else
|
||||
isfits = 0;
|
||||
free (magic);
|
||||
return isfits;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -19,7 +19,8 @@
|
|||
#define FITS_RW_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -55,7 +56,7 @@ extern "C" {
|
|||
Value, comment, and original line might be NULL pointers.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read(char * filename) ;
|
||||
qfits_header *qfits_header_read (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -69,7 +70,7 @@ qfits_header * qfits_header_read(char * filename) ;
|
|||
a hdr file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read_hdr(char * filename) ;
|
||||
qfits_header *qfits_header_read_hdr (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -82,9 +83,8 @@ qfits_header * qfits_header_read_hdr(char * filename) ;
|
|||
object.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_read_hdr_string(
|
||||
unsigned char * hdr_str,
|
||||
int nb_char) ;
|
||||
qfits_header *qfits_header_read_hdr_string (unsigned char *hdr_str,
|
||||
int nb_char);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -100,7 +100,7 @@ qfits_header * qfits_header_read_hdr_string(
|
|||
Returns NULL in case of error.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_header_readext(char * filename, int xtnum) ;
|
||||
qfits_header *qfits_header_readext (char *filename, int xtnum);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -112,7 +112,7 @@ qfits_header * qfits_header_readext(char * filename, int xtnum) ;
|
|||
for the file size to reach a multiple of 2880, as required by FITS.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_zeropad(char * filename) ;
|
||||
void qfits_zeropad (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -124,7 +124,7 @@ void qfits_zeropad(char * filename) ;
|
|||
0 else. If the file does not exist, returns -1.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int is_fits_file(char *filename) ;
|
||||
int is_fits_file (char *filename);
|
||||
/* </dox> */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -89,33 +89,35 @@
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_dir_name(char * filename)
|
||||
char *
|
||||
qfits_get_dir_name (char *filename)
|
||||
{
|
||||
static char path[MAXNAMESZ];
|
||||
char *last_slash;
|
||||
static char path[MAXNAMESZ];
|
||||
char *last_slash;
|
||||
|
||||
if (strlen(filename)>MAXNAMESZ) return NULL ;
|
||||
strcpy(path, filename);
|
||||
/* Find last '/'. */
|
||||
last_slash = path != NULL ? strrchr (path, '/') : NULL;
|
||||
if (strlen (filename) > MAXNAMESZ)
|
||||
return NULL;
|
||||
strcpy (path, filename);
|
||||
/* Find last '/'. */
|
||||
last_slash = path != NULL ? strrchr (path, '/') : NULL;
|
||||
|
||||
if (last_slash == path)
|
||||
if (last_slash == path)
|
||||
/* The last slash is the first character in the string. We have to
|
||||
return "/". */
|
||||
++last_slash;
|
||||
else if (last_slash != NULL && last_slash[1] == '\0')
|
||||
/* The '/' is the last character, we have to look further. */
|
||||
last_slash = memchr (path, last_slash - path, '/');
|
||||
return "/". */
|
||||
++last_slash;
|
||||
else if (last_slash != NULL && last_slash[1] == '\0')
|
||||
/* The '/' is the last character, we have to look further. */
|
||||
last_slash = memchr (path, last_slash - path, '/');
|
||||
|
||||
if (last_slash != NULL)
|
||||
/* Terminate the path. */
|
||||
last_slash[0] = '\0';
|
||||
else
|
||||
/* This assignment is ill-designed but the XPG specs require to
|
||||
return a string containing "." in any case no directory part is
|
||||
found and so a static and constant string is required. */
|
||||
strcpy(path, ".");
|
||||
return path;
|
||||
if (last_slash != NULL)
|
||||
/* Terminate the path. */
|
||||
last_slash[0] = '\0';
|
||||
else
|
||||
/* This assignment is ill-designed but the XPG specs require to
|
||||
return a string containing "." in any case no directory part is
|
||||
found and so a static and constant string is required. */
|
||||
strcpy (path, ".");
|
||||
return path;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -138,11 +140,12 @@ char * qfits_get_dir_name(char * filename)
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_base_name(const char *filename)
|
||||
char *
|
||||
qfits_get_base_name (const char *filename)
|
||||
{
|
||||
char *p ;
|
||||
p = strrchr (filename, '/');
|
||||
return p ? p + 1 : (char *) filename;
|
||||
char *p;
|
||||
p = strrchr (filename, '/');
|
||||
return p ? p + 1 : (char *) filename;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -176,26 +179,29 @@ char * qfits_get_base_name(const char *filename)
|
|||
to free it or modify its contents.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_root_name(char * filename)
|
||||
char *
|
||||
qfits_get_root_name (char *filename)
|
||||
{
|
||||
static char path[MAXNAMESZ+1];
|
||||
char * lastdot ;
|
||||
static char path[MAXNAMESZ + 1];
|
||||
char *lastdot;
|
||||
|
||||
if (strlen(filename)>MAXNAMESZ) return NULL ;
|
||||
memset(path, MAXNAMESZ, 0);
|
||||
strcpy(path, filename);
|
||||
lastdot = strrchr(path, '.');
|
||||
if (lastdot == NULL) return path ;
|
||||
if ((!strcmp(lastdot, ".fits")) || (!strcmp(lastdot, ".FITS")) ||
|
||||
(!strcmp(lastdot, ".paf")) || (!strcmp(lastdot, ".PAF")) ||
|
||||
(!strcmp(lastdot, ".dat")) || (!strcmp(lastdot, ".DAT")) ||
|
||||
(!strcmp(lastdot, ".txt")) || (!strcmp(lastdot, ".TXT")) ||
|
||||
(!strcmp(lastdot, ".tfits")) || (!strcmp(lastdot, ".TFITS")) ||
|
||||
(!strcmp(lastdot, ".ascii")) || (!strcmp(lastdot, ".ASCII")))
|
||||
if (strlen (filename) > MAXNAMESZ)
|
||||
return NULL;
|
||||
memset (path, MAXNAMESZ, 0);
|
||||
strcpy (path, filename);
|
||||
lastdot = strrchr (path, '.');
|
||||
if (lastdot == NULL)
|
||||
return path;
|
||||
if ((!strcmp (lastdot, ".fits")) || (!strcmp (lastdot, ".FITS")) ||
|
||||
(!strcmp (lastdot, ".paf")) || (!strcmp (lastdot, ".PAF")) ||
|
||||
(!strcmp (lastdot, ".dat")) || (!strcmp (lastdot, ".DAT")) ||
|
||||
(!strcmp (lastdot, ".txt")) || (!strcmp (lastdot, ".TXT")) ||
|
||||
(!strcmp (lastdot, ".tfits")) || (!strcmp (lastdot, ".TFITS")) ||
|
||||
(!strcmp (lastdot, ".ascii")) || (!strcmp (lastdot, ".ASCII")))
|
||||
{
|
||||
lastdot[0] = (char)0;
|
||||
lastdot[0] = (char) 0;
|
||||
}
|
||||
return path ;
|
||||
return path;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -219,11 +225,12 @@ char * qfits_get_root_name(char * filename)
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_ext_name(char * filename)
|
||||
char *
|
||||
qfits_get_ext_name (char *filename)
|
||||
{
|
||||
char * p;
|
||||
p = strrchr(filename, '.');
|
||||
return p ? p+1 : NULL ;
|
||||
char *p;
|
||||
p = strrchr (filename, '.');
|
||||
return p ? p + 1 : NULL;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -240,17 +247,20 @@ char * qfits_get_ext_name(char * filename)
|
|||
string which first character is a null character.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_login_name(void)
|
||||
char *
|
||||
qfits_get_login_name (void)
|
||||
{
|
||||
struct passwd * pw ;
|
||||
static char name[32];
|
||||
struct passwd *pw;
|
||||
static char name[32];
|
||||
|
||||
pw = getpwuid(getuid());
|
||||
if (pw!=NULL) {
|
||||
strcpy(name, pw->pw_name);
|
||||
} else {
|
||||
name[0]=0 ;
|
||||
pw = getpwuid (getuid ());
|
||||
if (pw != NULL)
|
||||
{
|
||||
strcpy (name, pw->pw_name);
|
||||
}
|
||||
return name ;
|
||||
else
|
||||
{
|
||||
name[0] = 0;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
|
|
|
@ -20,7 +20,8 @@
|
|||
#define GET_NAME_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
|
||||
|
@ -51,7 +52,7 @@ extern "C" {
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_dir_name(char * filename) ;
|
||||
char *qfits_get_dir_name (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -73,7 +74,7 @@ char * qfits_get_dir_name(char * filename) ;
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_base_name(const char *filename) ;
|
||||
char *qfits_get_base_name (const char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -105,7 +106,7 @@ char * qfits_get_base_name(const char *filename) ;
|
|||
to free it or modify its contents.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_root_name(char * filename) ;
|
||||
char *qfits_get_root_name (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -128,7 +129,7 @@ char * qfits_get_root_name(char * filename) ;
|
|||
@endverbatim
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_ext_name(char * filename) ;
|
||||
char *qfits_get_ext_name (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -144,7 +145,7 @@ char * qfits_get_ext_name(char * filename) ;
|
|||
point to a string which first character is a null character.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_login_name(void) ;
|
||||
char *qfits_get_login_name (void);
|
||||
|
||||
/* </dox> */
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -38,85 +38,94 @@
|
|||
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
/* Little endian ordering */
|
||||
typedef union _ieee_double_pattern_ {
|
||||
double d ;
|
||||
struct {
|
||||
unsigned int lsw ;
|
||||
unsigned int msw ;
|
||||
} p ;
|
||||
} ieee_double_pattern ;
|
||||
typedef union _ieee_double_pattern_
|
||||
{
|
||||
double d;
|
||||
struct
|
||||
{
|
||||
unsigned int lsw;
|
||||
unsigned int msw;
|
||||
} p;
|
||||
} ieee_double_pattern;
|
||||
#else
|
||||
/* Big endian ordering */
|
||||
typedef union _ieee_double_pattern_ {
|
||||
double d ;
|
||||
struct {
|
||||
unsigned int msw ;
|
||||
unsigned int lsw ;
|
||||
} p ;
|
||||
} ieee_double_pattern ;
|
||||
typedef union _ieee_double_pattern_
|
||||
{
|
||||
double d;
|
||||
struct
|
||||
{
|
||||
unsigned int msw;
|
||||
unsigned int lsw;
|
||||
} p;
|
||||
} ieee_double_pattern;
|
||||
#endif
|
||||
|
||||
typedef union _ieee_float_pattern_ {
|
||||
float f ;
|
||||
int i ;
|
||||
} ieee_float_pattern ;
|
||||
typedef union _ieee_float_pattern_
|
||||
{
|
||||
float f;
|
||||
int i;
|
||||
} ieee_float_pattern;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function codes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
int _qfits_isnanf(float f)
|
||||
int
|
||||
_qfits_isnanf (float f)
|
||||
{
|
||||
ieee_float_pattern ip ;
|
||||
int ix ;
|
||||
ieee_float_pattern ip;
|
||||
int ix;
|
||||
|
||||
ip.f = f ;
|
||||
ix = ip.i ;
|
||||
ix &= 0x7fffffff ;
|
||||
ix = 0x7f800000 - ix ;
|
||||
return (int)(((unsigned int)(ix))>>31);
|
||||
ip.f = f;
|
||||
ix = ip.i;
|
||||
ix &= 0x7fffffff;
|
||||
ix = 0x7f800000 - ix;
|
||||
return (int) (((unsigned int) (ix)) >> 31);
|
||||
}
|
||||
|
||||
int _qfits_isinff(float f)
|
||||
int
|
||||
_qfits_isinff (float f)
|
||||
{
|
||||
ieee_float_pattern ip ;
|
||||
int ix, t ;
|
||||
ieee_float_pattern ip;
|
||||
int ix, t;
|
||||
|
||||
ip.f = f ;
|
||||
ix = ip.i ;
|
||||
t = ix & 0x7fffffff;
|
||||
t ^= 0x7f800000;
|
||||
t |= -t;
|
||||
return ~(t >> 31) & (ix >> 30);
|
||||
ip.f = f;
|
||||
ix = ip.i;
|
||||
t = ix & 0x7fffffff;
|
||||
t ^= 0x7f800000;
|
||||
t |= -t;
|
||||
return ~(t >> 31) & (ix >> 30);
|
||||
}
|
||||
|
||||
int _qfits_isnand(double d)
|
||||
int
|
||||
_qfits_isnand (double d)
|
||||
{
|
||||
ieee_double_pattern id ;
|
||||
int hx, lx ;
|
||||
ieee_double_pattern id;
|
||||
int hx, lx;
|
||||
|
||||
id.d = d ;
|
||||
lx = id.p.lsw ;
|
||||
hx = id.p.msw ;
|
||||
id.d = d;
|
||||
lx = id.p.lsw;
|
||||
hx = id.p.msw;
|
||||
|
||||
hx &= 0x7fffffff;
|
||||
hx |= (unsigned int)(lx|(-lx))>>31;
|
||||
hx = 0x7ff00000 - hx;
|
||||
return (int)(((unsigned int)hx)>>31);
|
||||
hx &= 0x7fffffff;
|
||||
hx |= (unsigned int) (lx | (-lx)) >> 31;
|
||||
hx = 0x7ff00000 - hx;
|
||||
return (int) (((unsigned int) hx) >> 31);
|
||||
}
|
||||
|
||||
int _qfits_isinfd(double d)
|
||||
int
|
||||
_qfits_isinfd (double d)
|
||||
{
|
||||
ieee_double_pattern id ;
|
||||
int hx, lx ;
|
||||
ieee_double_pattern id;
|
||||
int hx, lx;
|
||||
|
||||
id.d = d ;
|
||||
lx = id.p.lsw ;
|
||||
hx = id.p.msw ;
|
||||
id.d = d;
|
||||
lx = id.p.lsw;
|
||||
hx = id.p.msw;
|
||||
|
||||
lx |= (hx & 0x7fffffff) ^ 0x7ff00000;
|
||||
lx |= -lx;
|
||||
return ~(lx >> 31) & (hx >> 30);
|
||||
lx |= (hx & 0x7fffffff) ^ 0x7ff00000;
|
||||
lx |= -lx;
|
||||
return ~(lx >> 31) & (hx >> 30);
|
||||
}
|
||||
|
||||
|
||||
|
@ -133,88 +142,99 @@ int _qfits_isinfd(double d)
|
|||
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
/* Little endian patterns */
|
||||
static unsigned char fnan_pat[] = {0, 0, 0xc0, 0x7f};
|
||||
static unsigned char dnan_pat[] = {0, 0, 0, 0, 0, 0, 0xf8, 0x7f};
|
||||
static unsigned char finf_pat[] = {0, 0, 0x80, 0x7f};
|
||||
static unsigned char dinf_pat[] = {0, 0, 0, 0, 0, 0, 0xf0, 0x7f};
|
||||
static unsigned char fminf_pat[] = {0, 0, 0x80, 0xff};
|
||||
static unsigned char fnan_pat[] = { 0, 0, 0xc0, 0x7f };
|
||||
static unsigned char dnan_pat[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };
|
||||
static unsigned char finf_pat[] = { 0, 0, 0x80, 0x7f };
|
||||
static unsigned char dinf_pat[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
|
||||
static unsigned char fminf_pat[] = { 0, 0, 0x80, 0xff };
|
||||
|
||||
/* static unsigned char dminf_pat[] = {0, 0, 0, 0, 0, 0, 0xf0, 0xff}; */
|
||||
static unsigned char dminf_pat[] = {0, 0, 0, 0, 0, 0, 0xf0, 0x7f};
|
||||
static unsigned char dminf_pat[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
|
||||
#else
|
||||
/* Big endian patterns */
|
||||
static unsigned char fnan_pat[] = {0x7f, 0xc0, 0, 0};
|
||||
static unsigned char dnan_pat[] = {0x7f, 0xf8, 0, 0, 0, 0, 0, 0};
|
||||
static unsigned char finf_pat[] = {0x7f, 0x80, 0, 0};
|
||||
static unsigned char dinf_pat[] = {0x7f, 0xf0, 0, 0, 0, 0, 0, 0};
|
||||
static unsigned char fminf_pat[] = {0xff, 0x80, 0, 0};
|
||||
static unsigned char dminf_pat[] = {0xff, 0xf0, 0, 0, 0, 0, 0, 0};
|
||||
static unsigned char fnan_pat[] = { 0x7f, 0xc0, 0, 0 };
|
||||
static unsigned char dnan_pat[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 };
|
||||
static unsigned char finf_pat[] = { 0x7f, 0x80, 0, 0 };
|
||||
static unsigned char dinf_pat[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
|
||||
static unsigned char fminf_pat[] = { 0xff, 0x80, 0, 0 };
|
||||
static unsigned char dminf_pat[] = { 0xff, 0xf0, 0, 0, 0, 0, 0, 0 };
|
||||
#endif
|
||||
|
||||
static void hexdump(void * p, int s)
|
||||
static void
|
||||
hexdump (void *p, int s)
|
||||
{
|
||||
unsigned char * c ;
|
||||
int i ;
|
||||
unsigned char *c;
|
||||
int i;
|
||||
|
||||
c=(unsigned char*)p ;
|
||||
c = (unsigned char *) p;
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
for (i=s-1 ; i>=0 ; i--) {
|
||||
for (i = s - 1; i >= 0; i--)
|
||||
{
|
||||
#else
|
||||
for (i=0 ; i<s ; i++) {
|
||||
for (i = 0; i < s; i++)
|
||||
{
|
||||
#endif
|
||||
printf("%02x", c[i]);
|
||||
}
|
||||
printf("\n");
|
||||
printf ("%02x", c[i]);
|
||||
}
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
float f ;
|
||||
double d ;
|
||||
float f;
|
||||
double d;
|
||||
|
||||
printf("Testing Nan...\n");
|
||||
memcpy(&f, fnan_pat, 4);
|
||||
memcpy(&d, dnan_pat, 8);
|
||||
printf("f=%g d=%g\n", f, d);
|
||||
hexdump(&f, sizeof(float));
|
||||
hexdump(&d, sizeof(double));
|
||||
printf ("Testing Nan...\n");
|
||||
memcpy (&f, fnan_pat, 4);
|
||||
memcpy (&d, dnan_pat, 8);
|
||||
printf ("f=%g d=%g\n", f, d);
|
||||
hexdump (&f, sizeof (float));
|
||||
hexdump (&d, sizeof (double));
|
||||
|
||||
if (qfits_isnan(f)) {
|
||||
printf("f is NaN\n");
|
||||
if (qfits_isnan (f))
|
||||
{
|
||||
printf ("f is NaN\n");
|
||||
}
|
||||
if (qfits_isnan(d)) {
|
||||
printf("d is NaN\n");
|
||||
if (qfits_isnan (d))
|
||||
{
|
||||
printf ("d is NaN\n");
|
||||
}
|
||||
|
||||
printf("Testing +Inf...\n");
|
||||
memcpy(&f, finf_pat, 4);
|
||||
memcpy(&d, dinf_pat, 8);
|
||||
printf("f=%g d=%g\n", f, d);
|
||||
hexdump(&f, sizeof(float));
|
||||
hexdump(&d, sizeof(double));
|
||||
printf ("Testing +Inf...\n");
|
||||
memcpy (&f, finf_pat, 4);
|
||||
memcpy (&d, dinf_pat, 8);
|
||||
printf ("f=%g d=%g\n", f, d);
|
||||
hexdump (&f, sizeof (float));
|
||||
hexdump (&d, sizeof (double));
|
||||
|
||||
if (qfits_isinf(f)) {
|
||||
printf("f is Inf\n");
|
||||
if (qfits_isinf (f))
|
||||
{
|
||||
printf ("f is Inf\n");
|
||||
}
|
||||
if (qfits_isinf(d)) {
|
||||
printf("d is Inf\n");
|
||||
if (qfits_isinf (d))
|
||||
{
|
||||
printf ("d is Inf\n");
|
||||
}
|
||||
|
||||
printf("Testing -Inf...\n");
|
||||
memcpy(&f, fminf_pat, 4);
|
||||
memcpy(&d, dminf_pat, 8);
|
||||
printf("f=%g d=%g\n", f, d);
|
||||
hexdump(&f, sizeof(float));
|
||||
hexdump(&d, sizeof(double));
|
||||
printf ("Testing -Inf...\n");
|
||||
memcpy (&f, fminf_pat, 4);
|
||||
memcpy (&d, dminf_pat, 8);
|
||||
printf ("f=%g d=%g\n", f, d);
|
||||
hexdump (&f, sizeof (float));
|
||||
hexdump (&d, sizeof (double));
|
||||
|
||||
if (qfits_isinf(f)) {
|
||||
printf("f is (-)Inf\n");
|
||||
if (qfits_isinf (f))
|
||||
{
|
||||
printf ("f is (-)Inf\n");
|
||||
}
|
||||
if (qfits_isinf(d)) {
|
||||
printf("d is (-)Inf\n");
|
||||
if (qfits_isinf (d))
|
||||
{
|
||||
printf ("d is (-)Inf\n");
|
||||
}
|
||||
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -82,22 +82,22 @@
|
|||
* Test a float variable for NaN value.
|
||||
* Do not call directly, call qfits_isnan().
|
||||
*/
|
||||
int _qfits_isnanf(float f);
|
||||
int _qfits_isnanf (float f);
|
||||
/**
|
||||
* Test a float variable for Inf value.
|
||||
* Do not call directly, call qfits_isinf().
|
||||
*/
|
||||
int _qfits_isinff(float f);
|
||||
int _qfits_isinff (float f);
|
||||
/**
|
||||
* Test a double variable for NaN value.
|
||||
* Do not call directly, call qfits_isnan().
|
||||
*/
|
||||
int _qfits_isnand(double d);
|
||||
int _qfits_isnand (double d);
|
||||
/**
|
||||
* Test a double variable for Inf value.
|
||||
* Do not call directly, call qfits_isinf().
|
||||
*/
|
||||
int _qfits_isinfd(double d);
|
||||
int _qfits_isinfd (double d);
|
||||
|
||||
/* </dox> */
|
||||
#endif
|
||||
|
|
312
qfits/src/md5.c
312
qfits/src/md5.c
|
@ -37,7 +37,7 @@
|
|||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static void byteReverse(unsigned char *buf, unsigned longs) ;
|
||||
static void byteReverse (unsigned char *buf, unsigned longs);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function codes
|
||||
|
@ -46,123 +46,135 @@ static void byteReverse(unsigned char *buf, unsigned longs) ;
|
|||
/*
|
||||
* Note: this code is harmless on little-endian machines.
|
||||
*/
|
||||
static void byteReverse(unsigned char *buf, unsigned longs)
|
||||
static void
|
||||
byteReverse (unsigned char *buf, unsigned longs)
|
||||
{
|
||||
word32 t;
|
||||
do {
|
||||
t = (word32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
|
||||
((unsigned) buf[1] << 8 | buf[0]);
|
||||
*(word32 *) buf = t;
|
||||
buf += 4;
|
||||
} while (--longs);
|
||||
word32 t;
|
||||
do
|
||||
{
|
||||
t = (word32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
|
||||
((unsigned) buf[1] << 8 | buf[0]);
|
||||
*(word32 *) buf = t;
|
||||
buf += 4;
|
||||
}
|
||||
while (--longs);
|
||||
}
|
||||
|
||||
/*
|
||||
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
|
||||
* initialization constants.
|
||||
*/
|
||||
void MD5Init(struct MD5Context *ctx)
|
||||
void
|
||||
MD5Init (struct MD5Context *ctx)
|
||||
{
|
||||
ctx->buf[0] = 0x67452301;
|
||||
ctx->buf[1] = 0xefcdab89;
|
||||
ctx->buf[2] = 0x98badcfe;
|
||||
ctx->buf[3] = 0x10325476;
|
||||
ctx->buf[0] = 0x67452301;
|
||||
ctx->buf[1] = 0xefcdab89;
|
||||
ctx->buf[2] = 0x98badcfe;
|
||||
ctx->buf[3] = 0x10325476;
|
||||
|
||||
ctx->bits[0] = 0;
|
||||
ctx->bits[1] = 0;
|
||||
ctx->bits[0] = 0;
|
||||
ctx->bits[1] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update context to reflect the concatenation of another buffer full
|
||||
* of bytes.
|
||||
*/
|
||||
void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
|
||||
void
|
||||
MD5Update (struct MD5Context *ctx, unsigned char const *buf, unsigned len)
|
||||
{
|
||||
register word32 t;
|
||||
register word32 t;
|
||||
|
||||
/* Update bitcount */
|
||||
/* Update bitcount */
|
||||
|
||||
t = ctx->bits[0];
|
||||
if ((ctx->bits[0] = t + ((word32) len << 3)) < t)
|
||||
ctx->bits[1]++; /* Carry from low to high */
|
||||
ctx->bits[1] += len >> 29;
|
||||
t = ctx->bits[0];
|
||||
if ((ctx->bits[0] = t + ((word32) len << 3)) < t)
|
||||
ctx->bits[1]++; /* Carry from low to high */
|
||||
ctx->bits[1] += len >> 29;
|
||||
|
||||
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
|
||||
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
|
||||
|
||||
/* Handle any leading odd-sized chunks */
|
||||
/* Handle any leading odd-sized chunks */
|
||||
|
||||
if (t) {
|
||||
unsigned char *p = (unsigned char *) ctx->in + t;
|
||||
if (t)
|
||||
{
|
||||
unsigned char *p = (unsigned char *) ctx->in + t;
|
||||
|
||||
t = 64 - t;
|
||||
if (len < t) {
|
||||
memmove(p, buf, len);
|
||||
return;
|
||||
t = 64 - t;
|
||||
if (len < t)
|
||||
{
|
||||
memmove (p, buf, len);
|
||||
return;
|
||||
}
|
||||
memmove(p, buf, t);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (word32 *) ctx->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
memmove (p, buf, t);
|
||||
byteReverse (ctx->in, 16);
|
||||
MD5Transform (ctx->buf, (word32 *) ctx->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
}
|
||||
/* Process data in 64-byte chunks */
|
||||
/* Process data in 64-byte chunks */
|
||||
|
||||
while (len >= 64) {
|
||||
memmove(ctx->in, buf, 64);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (word32 *) ctx->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
while (len >= 64)
|
||||
{
|
||||
memmove (ctx->in, buf, 64);
|
||||
byteReverse (ctx->in, 16);
|
||||
MD5Transform (ctx->buf, (word32 *) ctx->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
}
|
||||
|
||||
/* Handle any remaining bytes of data. */
|
||||
/* Handle any remaining bytes of data. */
|
||||
|
||||
memmove(ctx->in, buf, len);
|
||||
memmove (ctx->in, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* Final wrapup - pad to 64-byte boundary with the bit pattern
|
||||
* 1 0* (64-bit count of bits processed, MSB-first)
|
||||
*/
|
||||
void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
|
||||
void
|
||||
MD5Final (unsigned char digest[16], struct MD5Context *ctx)
|
||||
{
|
||||
unsigned int count;
|
||||
unsigned char *p;
|
||||
unsigned int count;
|
||||
unsigned char *p;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
count = (ctx->bits[0] >> 3) & 0x3F;
|
||||
/* Compute number of bytes mod 64 */
|
||||
count = (ctx->bits[0] >> 3) & 0x3F;
|
||||
|
||||
/* Set the first char of padding to 0x80. This is safe since there is
|
||||
always at least one byte free */
|
||||
p = ctx->in + count;
|
||||
*p++ = 0x80;
|
||||
/* Set the first char of padding to 0x80. This is safe since there is
|
||||
always at least one byte free */
|
||||
p = ctx->in + count;
|
||||
*p++ = 0x80;
|
||||
|
||||
/* Bytes of padding needed to make 64 bytes */
|
||||
count = 64 - 1 - count;
|
||||
/* Bytes of padding needed to make 64 bytes */
|
||||
count = 64 - 1 - count;
|
||||
|
||||
/* Pad out to 56 mod 64 */
|
||||
if (count < 8) {
|
||||
/* Two lots of padding: Pad the first block to 64 bytes */
|
||||
memset(p, 0, count);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (word32 *) ctx->in);
|
||||
/* Pad out to 56 mod 64 */
|
||||
if (count < 8)
|
||||
{
|
||||
/* Two lots of padding: Pad the first block to 64 bytes */
|
||||
memset (p, 0, count);
|
||||
byteReverse (ctx->in, 16);
|
||||
MD5Transform (ctx->buf, (word32 *) ctx->in);
|
||||
|
||||
/* Now fill the next block with 56 bytes */
|
||||
memset(ctx->in, 0, 56);
|
||||
} else {
|
||||
/* Pad block to 56 bytes */
|
||||
memset(p, 0, count - 8);
|
||||
/* Now fill the next block with 56 bytes */
|
||||
memset (ctx->in, 0, 56);
|
||||
}
|
||||
byteReverse(ctx->in, 14);
|
||||
else
|
||||
{
|
||||
/* Pad block to 56 bytes */
|
||||
memset (p, 0, count - 8);
|
||||
}
|
||||
byteReverse (ctx->in, 14);
|
||||
|
||||
/* Append length in bits and transform */
|
||||
((word32 *) ctx->in)[14] = ctx->bits[0];
|
||||
((word32 *) ctx->in)[15] = ctx->bits[1];
|
||||
/* Append length in bits and transform */
|
||||
((word32 *) ctx->in)[14] = ctx->bits[0];
|
||||
((word32 *) ctx->in)[15] = ctx->bits[1];
|
||||
|
||||
MD5Transform(ctx->buf, (word32 *) ctx->in);
|
||||
byteReverse((unsigned char *) ctx->buf, 4);
|
||||
memmove(digest, ctx->buf, 16);
|
||||
memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
|
||||
MD5Transform (ctx->buf, (word32 *) ctx->in);
|
||||
byteReverse ((unsigned char *) ctx->buf, 4);
|
||||
memmove (digest, ctx->buf, 16);
|
||||
memset (ctx, 0, sizeof (ctx)); /* In case it's sensitive */
|
||||
}
|
||||
|
||||
/* The four core functions - F1 is optimized somewhat */
|
||||
|
@ -182,86 +194,88 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
|
|||
* reflect the addition of 16 longwords of new data. MD5Update blocks
|
||||
* the data and converts bytes into longwords for this routine.
|
||||
*/
|
||||
void MD5Transform(word32 buf[4], word32 const in[16])
|
||||
void
|
||||
MD5Transform (word32 buf[4], word32 const in[16])
|
||||
{
|
||||
register word32 a, b, c, d;
|
||||
register word32 a, b, c, d;
|
||||
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
|
||||
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
|
||||
MD5STEP (F1, a, b, c, d, in[0] + 0xd76aa478, 7);
|
||||
MD5STEP (F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
|
||||
MD5STEP (F1, c, d, a, b, in[2] + 0x242070db, 17);
|
||||
MD5STEP (F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
|
||||
MD5STEP (F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
|
||||
MD5STEP (F1, d, a, b, c, in[5] + 0x4787c62a, 12);
|
||||
MD5STEP (F1, c, d, a, b, in[6] + 0xa8304613, 17);
|
||||
MD5STEP (F1, b, c, d, a, in[7] + 0xfd469501, 22);
|
||||
MD5STEP (F1, a, b, c, d, in[8] + 0x698098d8, 7);
|
||||
MD5STEP (F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
|
||||
MD5STEP (F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
|
||||
MD5STEP (F1, b, c, d, a, in[11] + 0x895cd7be, 22);
|
||||
MD5STEP (F1, a, b, c, d, in[12] + 0x6b901122, 7);
|
||||
MD5STEP (F1, d, a, b, c, in[13] + 0xfd987193, 12);
|
||||
MD5STEP (F1, c, d, a, b, in[14] + 0xa679438e, 17);
|
||||
MD5STEP (F1, b, c, d, a, in[15] + 0x49b40821, 22);
|
||||
|
||||
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
|
||||
MD5STEP (F2, a, b, c, d, in[1] + 0xf61e2562, 5);
|
||||
MD5STEP (F2, d, a, b, c, in[6] + 0xc040b340, 9);
|
||||
MD5STEP (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
|
||||
MD5STEP (F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
|
||||
MD5STEP (F2, a, b, c, d, in[5] + 0xd62f105d, 5);
|
||||
MD5STEP (F2, d, a, b, c, in[10] + 0x02441453, 9);
|
||||
MD5STEP (F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
|
||||
MD5STEP (F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
|
||||
MD5STEP (F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
|
||||
MD5STEP (F2, d, a, b, c, in[14] + 0xc33707d6, 9);
|
||||
MD5STEP (F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
|
||||
MD5STEP (F2, b, c, d, a, in[8] + 0x455a14ed, 20);
|
||||
MD5STEP (F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
|
||||
MD5STEP (F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
|
||||
MD5STEP (F2, c, d, a, b, in[7] + 0x676f02d9, 14);
|
||||
MD5STEP (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
|
||||
|
||||
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
|
||||
MD5STEP (F3, a, b, c, d, in[5] + 0xfffa3942, 4);
|
||||
MD5STEP (F3, d, a, b, c, in[8] + 0x8771f681, 11);
|
||||
MD5STEP (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
|
||||
MD5STEP (F3, b, c, d, a, in[14] + 0xfde5380c, 23);
|
||||
MD5STEP (F3, a, b, c, d, in[1] + 0xa4beea44, 4);
|
||||
MD5STEP (F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
|
||||
MD5STEP (F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
|
||||
MD5STEP (F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
|
||||
MD5STEP (F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
|
||||
MD5STEP (F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
|
||||
MD5STEP (F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
|
||||
MD5STEP (F3, b, c, d, a, in[6] + 0x04881d05, 23);
|
||||
MD5STEP (F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
|
||||
MD5STEP (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
|
||||
MD5STEP (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
|
||||
MD5STEP (F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
|
||||
|
||||
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
|
||||
MD5STEP (F4, a, b, c, d, in[0] + 0xf4292244, 6);
|
||||
MD5STEP (F4, d, a, b, c, in[7] + 0x432aff97, 10);
|
||||
MD5STEP (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
|
||||
MD5STEP (F4, b, c, d, a, in[5] + 0xfc93a039, 21);
|
||||
MD5STEP (F4, a, b, c, d, in[12] + 0x655b59c3, 6);
|
||||
MD5STEP (F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
|
||||
MD5STEP (F4, c, d, a, b, in[10] + 0xffeff47d, 15);
|
||||
MD5STEP (F4, b, c, d, a, in[1] + 0x85845dd1, 21);
|
||||
MD5STEP (F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
|
||||
MD5STEP (F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
|
||||
MD5STEP (F4, c, d, a, b, in[6] + 0xa3014314, 15);
|
||||
MD5STEP (F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
|
||||
MD5STEP (F4, a, b, c, d, in[4] + 0xf7537e82, 6);
|
||||
MD5STEP (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
|
||||
MD5STEP (F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
|
||||
MD5STEP (F4, b, c, d, a, in[9] + 0xeb86d391, 21);
|
||||
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -1,19 +1,20 @@
|
|||
#ifndef MD5_H
|
||||
#define MD5_H
|
||||
|
||||
typedef unsigned int word32 ;
|
||||
typedef unsigned int word32;
|
||||
|
||||
struct MD5Context {
|
||||
word32 buf[4];
|
||||
word32 bits[2];
|
||||
unsigned char in[64];
|
||||
struct MD5Context
|
||||
{
|
||||
word32 buf[4];
|
||||
word32 bits[2];
|
||||
unsigned char in[64];
|
||||
};
|
||||
|
||||
void MD5Init(struct MD5Context *context);
|
||||
void MD5Update(struct MD5Context *context, unsigned char const *buf,
|
||||
unsigned len);
|
||||
void MD5Final(unsigned char digest[16], struct MD5Context *context);
|
||||
void MD5Transform(word32 buf[4], word32 const in[16]);
|
||||
void MD5Init (struct MD5Context *context);
|
||||
void MD5Update (struct MD5Context *context, unsigned char const *buf,
|
||||
unsigned len);
|
||||
void MD5Final (unsigned char digest[16], struct MD5Context *context);
|
||||
void MD5Transform (word32 buf[4], word32 const in[16]);
|
||||
|
||||
/*
|
||||
* This is needed to make RSAREF happy on some MS-DOS compilers.
|
||||
|
|
228
qfits/src/pafs.c
228
qfits/src/pafs.c
|
@ -33,7 +33,7 @@
|
|||
/*-----------------------------------------------------------------------------
|
||||
Function prototypes
|
||||
-----------------------------------------------------------------------------*/
|
||||
static char * qfits_strcrop(char * s) ;
|
||||
static char *qfits_strcrop (char *s);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function codes
|
||||
|
@ -65,32 +65,31 @@ static char * qfits_strcrop(char * s) ;
|
|||
the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
FILE * qfits_paf_print_header(
|
||||
char * filename,
|
||||
char * paf_id,
|
||||
char * paf_desc,
|
||||
char * login_name,
|
||||
char * datetime)
|
||||
FILE *
|
||||
qfits_paf_print_header (char *filename,
|
||||
char *paf_id,
|
||||
char *paf_desc, char *login_name, char *datetime)
|
||||
{
|
||||
FILE * paf ;
|
||||
FILE *paf;
|
||||
|
||||
if ((paf=fopen(filename, "w"))==NULL) {
|
||||
qfits_error("cannot create PAF file [%s]", filename);
|
||||
return NULL ;
|
||||
}
|
||||
fprintf(paf, "PAF.HDR.START ;# start of header\n");
|
||||
fprintf(paf, "PAF.TYPE \"pipeline product\" ;\n");
|
||||
fprintf(paf, "PAF.ID \"%s\"\n", paf_id);
|
||||
fprintf(paf, "PAF.NAME \"%s\"\n", filename);
|
||||
fprintf(paf, "PAF.DESC \"%s\"\n", paf_desc);
|
||||
fprintf(paf, "PAF.CRTE.NAME \"%s\"\n", login_name) ;
|
||||
fprintf(paf, "PAF.CRTE.DAYTIM \"%s\"\n", datetime) ;
|
||||
fprintf(paf, "PAF.LCHG.NAME \"%s\"\n", login_name) ;
|
||||
fprintf(paf, "PAF.LCHG.DAYTIM \"%s\"\n", datetime) ;
|
||||
fprintf(paf, "PAF.CHCK.CHECKSUM \"\"\n");
|
||||
fprintf(paf, "PAF.HDR.END ;# end of header\n");
|
||||
fprintf(paf, "\n");
|
||||
return paf ;
|
||||
if ((paf = fopen (filename, "w")) == NULL)
|
||||
{
|
||||
qfits_error ("cannot create PAF file [%s]", filename);
|
||||
return NULL;
|
||||
}
|
||||
fprintf (paf, "PAF.HDR.START ;# start of header\n");
|
||||
fprintf (paf, "PAF.TYPE \"pipeline product\" ;\n");
|
||||
fprintf (paf, "PAF.ID \"%s\"\n", paf_id);
|
||||
fprintf (paf, "PAF.NAME \"%s\"\n", filename);
|
||||
fprintf (paf, "PAF.DESC \"%s\"\n", paf_desc);
|
||||
fprintf (paf, "PAF.CRTE.NAME \"%s\"\n", login_name);
|
||||
fprintf (paf, "PAF.CRTE.DAYTIM \"%s\"\n", datetime);
|
||||
fprintf (paf, "PAF.LCHG.NAME \"%s\"\n", login_name);
|
||||
fprintf (paf, "PAF.LCHG.DAYTIM \"%s\"\n", datetime);
|
||||
fprintf (paf, "PAF.CHCK.CHECKSUM \"\"\n");
|
||||
fprintf (paf, "PAF.HDR.END ;# end of header\n");
|
||||
fprintf (paf, "\n");
|
||||
return paf;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -107,57 +106,65 @@ FILE * qfits_paf_print_header(
|
|||
If the key is not found, this function returns NULL.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_paf_query(
|
||||
char * filename,
|
||||
char * key)
|
||||
char *
|
||||
qfits_paf_query (char *filename, char *key)
|
||||
{
|
||||
static char value[ASCIILINESZ];
|
||||
FILE * paf ;
|
||||
char line[ASCIILINESZ+1];
|
||||
char val[ASCIILINESZ+1];
|
||||
char head[ASCIILINESZ+1];
|
||||
int found ;
|
||||
int len ;
|
||||
static char value[ASCIILINESZ];
|
||||
FILE *paf;
|
||||
char line[ASCIILINESZ + 1];
|
||||
char val[ASCIILINESZ + 1];
|
||||
char head[ASCIILINESZ + 1];
|
||||
int found;
|
||||
int len;
|
||||
|
||||
/* Check inputs */
|
||||
if (filename==NULL || key==NULL) return NULL ;
|
||||
/* Check inputs */
|
||||
if (filename == NULL || key == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Check PAF validity */
|
||||
if (qfits_is_paf_file(filename)!=1) {
|
||||
qfits_error("not a PAF file: [%s]", filename);
|
||||
return NULL ;
|
||||
/* Check PAF validity */
|
||||
if (qfits_is_paf_file (filename) != 1)
|
||||
{
|
||||
qfits_error ("not a PAF file: [%s]", filename);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Open file and read it */
|
||||
paf = fopen (filename, "r");
|
||||
if (paf == NULL)
|
||||
{
|
||||
qfits_error ("opening [%s]", filename);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
found = 0;
|
||||
while (fgets (line, ASCIILINESZ, paf) != NULL)
|
||||
{
|
||||
sscanf (line, "%[^ ]", head);
|
||||
if (!strcmp (head, key))
|
||||
{
|
||||
/* Get value */
|
||||
sscanf (line, "%*[^ ] %[^;]", value);
|
||||
found++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
return NULL;
|
||||
|
||||
/* Open file and read it */
|
||||
paf = fopen(filename, "r");
|
||||
if (paf==NULL) {
|
||||
qfits_error("opening [%s]", filename);
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
found = 0 ;
|
||||
while (fgets(line, ASCIILINESZ, paf)!=NULL) {
|
||||
sscanf(line, "%[^ ]", head);
|
||||
if (!strcmp(head, key)) {
|
||||
/* Get value */
|
||||
sscanf(line, "%*[^ ] %[^;]", value);
|
||||
found ++ ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (!found) return NULL ;
|
||||
|
||||
/* Remove trailing blanks */
|
||||
strcpy(val, qfits_strcrop(value));
|
||||
/* Get rid of possible quotes */
|
||||
len = strlen(val);
|
||||
if (val[0]=='\"' && val[len-1]=='\"') {
|
||||
strncpy(value, val+1, len-2);
|
||||
value[len-2]=(char)0;
|
||||
} else {
|
||||
strcpy(value, val);
|
||||
}
|
||||
return value ;
|
||||
/* Remove trailing blanks */
|
||||
strcpy (val, qfits_strcrop (value));
|
||||
/* Get rid of possible quotes */
|
||||
len = strlen (val);
|
||||
if (val[0] == '\"' && val[len - 1] == '\"')
|
||||
{
|
||||
strncpy (value, val + 1, len - 2);
|
||||
value[len - 2] = (char) 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy (value, val);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -170,34 +177,40 @@ char * qfits_paf_query(
|
|||
is checked with the presence of PAF.HDR.START at the beginning
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_paf_file(char * filename)
|
||||
int
|
||||
qfits_is_paf_file (char *filename)
|
||||
{
|
||||
FILE * fp ;
|
||||
int is_paf ;
|
||||
char line[ASCIILINESZ] ;
|
||||
FILE *fp;
|
||||
int is_paf;
|
||||
char line[ASCIILINESZ];
|
||||
|
||||
if (filename==NULL) return -1 ;
|
||||
if (filename == NULL)
|
||||
return -1;
|
||||
|
||||
/* Initialize is_paf */
|
||||
is_paf = 0 ;
|
||||
/* Initialize is_paf */
|
||||
is_paf = 0;
|
||||
|
||||
/* Open file */
|
||||
if ((fp = fopen(filename, "r"))==NULL) {
|
||||
qfits_error("cannot open file [%s]", filename) ;
|
||||
return -1 ;
|
||||
/* Open file */
|
||||
if ((fp = fopen (filename, "r")) == NULL)
|
||||
{
|
||||
qfits_error ("cannot open file [%s]", filename);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Parse file */
|
||||
while (fgets (line, ASCIILINESZ, fp) != NULL)
|
||||
{
|
||||
if (line[0] != '#')
|
||||
{
|
||||
if (!strncmp (line, PAF_MAGIC, PAF_MAGIC_SZ))
|
||||
is_paf = 1;
|
||||
(void) fclose (fp);
|
||||
return is_paf;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse file */
|
||||
while (fgets(line, ASCIILINESZ, fp) != NULL) {
|
||||
if (line[0] != '#') {
|
||||
if (!strncmp(line, PAF_MAGIC, PAF_MAGIC_SZ)) is_paf = 1 ;
|
||||
(void)fclose(fp) ;
|
||||
return is_paf ;
|
||||
}
|
||||
}
|
||||
|
||||
(void)fclose(fp) ;
|
||||
return is_paf ;
|
||||
(void) fclose (fp);
|
||||
return is_paf;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -214,22 +227,25 @@ int qfits_is_paf_file(char * filename)
|
|||
(not re-entrant).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static char * qfits_strcrop(char * s)
|
||||
static char *
|
||||
qfits_strcrop (char *s)
|
||||
{
|
||||
static char l[ASCIILINESZ+1];
|
||||
char * last ;
|
||||
static char l[ASCIILINESZ + 1];
|
||||
char *last;
|
||||
|
||||
if (s==NULL) return NULL ;
|
||||
memset(l, 0, ASCIILINESZ+1);
|
||||
strcpy(l, s);
|
||||
last = l + strlen(l);
|
||||
while (last > l) {
|
||||
if (!isspace((int)*(last-1)))
|
||||
break ;
|
||||
last -- ;
|
||||
if (s == NULL)
|
||||
return NULL;
|
||||
memset (l, 0, ASCIILINESZ + 1);
|
||||
strcpy (l, s);
|
||||
last = l + strlen (l);
|
||||
while (last > l)
|
||||
{
|
||||
if (!isspace ((int) *(last - 1)))
|
||||
break;
|
||||
last--;
|
||||
}
|
||||
*last = (char)0;
|
||||
return l ;
|
||||
*last = (char) 0;
|
||||
return l;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -21,7 +21,8 @@
|
|||
#define PAFS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -65,12 +66,10 @@ extern "C" {
|
|||
the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
FILE * qfits_paf_print_header(
|
||||
char * filename,
|
||||
char * paf_id,
|
||||
char * paf_desc,
|
||||
char * login_name,
|
||||
char * datetime) ;
|
||||
FILE *qfits_paf_print_header (char *filename,
|
||||
char *paf_id,
|
||||
char *paf_desc,
|
||||
char *login_name, char *datetime);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -86,9 +85,7 @@ FILE * qfits_paf_print_header(
|
|||
If the key is not found, this function returns NULL.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_paf_query(
|
||||
char * filename,
|
||||
char * key) ;
|
||||
char *qfits_paf_query (char *filename, char *key);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -100,7 +97,7 @@ char * qfits_paf_query(
|
|||
is checked with the presence of PAF.HDR.START at the beginning
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_paf_file(char * filename) ;
|
||||
int qfits_is_paf_file (char *filename);
|
||||
|
||||
/* </dox> */
|
||||
#ifdef __cplusplus
|
||||
|
|
1813
qfits/src/pixio.c
1813
qfits/src/pixio.c
File diff suppressed because it is too large
Load Diff
|
@ -53,7 +53,7 @@
|
|||
for readability.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef unsigned char byte ;
|
||||
typedef unsigned char byte;
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -126,49 +126,50 @@ int main(int argc, char * argv[])
|
|||
@endcode
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef struct qfitsloader {
|
||||
typedef struct qfitsloader
|
||||
{
|
||||
|
||||
/** Private field to see if structure has been initialized */
|
||||
int _init ;
|
||||
int _init;
|
||||
|
||||
/** input: Name of the file you want to read pixels from */
|
||||
char * filename ;
|
||||
char *filename;
|
||||
/** input: xtension number you want to read */
|
||||
int xtnum ;
|
||||
int xtnum;
|
||||
/** input: Index of the plane you want, from 0 to np-1 */
|
||||
int pnum ;
|
||||
int pnum;
|
||||
/** input: Pixel type you want (PTYPE_FLOAT, PTYPE_INT or PTYPE_DOUBLE) */
|
||||
int ptype ;
|
||||
int ptype;
|
||||
/** input: Guarantee file copy or allow file mapping */
|
||||
int map ;
|
||||
int map;
|
||||
|
||||
/** output: Total number of extensions found in file */
|
||||
int exts ;
|
||||
int exts;
|
||||
/** output: Size in X of the requested plane */
|
||||
int lx ;
|
||||
int lx;
|
||||
/** output: Size in Y of the requested plane */
|
||||
int ly ;
|
||||
int ly;
|
||||
/** output: Number of planes present in this extension */
|
||||
int np ;
|
||||
int np;
|
||||
/** output: BITPIX for this extension */
|
||||
int bitpix ;
|
||||
int bitpix;
|
||||
/** output: Start of the data segment (in bytes) for your request */
|
||||
int seg_start ;
|
||||
int seg_start;
|
||||
/** output: Size of the data segment (in bytes) for your request */
|
||||
int seg_size ;
|
||||
int seg_size;
|
||||
/** output: BSCALE found for this extension */
|
||||
double bscale ;
|
||||
double bscale;
|
||||
/** output: BZERO found for this extension */
|
||||
double bzero ;
|
||||
double bzero;
|
||||
|
||||
/** output: Pointer to pixel buffer loaded as integer values */
|
||||
int * ibuf ;
|
||||
int *ibuf;
|
||||
/** output: Pointer to pixel buffer loaded as float values */
|
||||
float * fbuf ;
|
||||
float *fbuf;
|
||||
/** output: Pointer to pixel buffer loaded as double values */
|
||||
double * dbuf ;
|
||||
double *dbuf;
|
||||
|
||||
} qfitsloader ;
|
||||
} qfitsloader;
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -215,25 +216,26 @@ typedef struct qfitsloader {
|
|||
could have been re-directed).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef struct qfitsdumper {
|
||||
typedef struct qfitsdumper
|
||||
{
|
||||
|
||||
/** Name of the file to dump to, "STDOUT" to dump to stdout */
|
||||
char * filename ;
|
||||
char *filename;
|
||||
/** Number of pixels in the buffer to dump */
|
||||
int npix ;
|
||||
int npix;
|
||||
/** Buffer type: PTYPE_FLOAT, PTYPE_INT or PTYPE_DOUBLE */
|
||||
int ptype ;
|
||||
int ptype;
|
||||
|
||||
/** Pointer to input integer pixel buffer */
|
||||
int * ibuf ;
|
||||
int *ibuf;
|
||||
/** Pointer to input float pixel buffer */
|
||||
float * fbuf ;
|
||||
float *fbuf;
|
||||
/** Pointer to input double pixel buffer */
|
||||
double * dbuf ;
|
||||
double *dbuf;
|
||||
|
||||
/** Requested BITPIX in output FITS file */
|
||||
int out_ptype ;
|
||||
} qfitsdumper ;
|
||||
int out_ptype;
|
||||
} qfitsdumper;
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -265,7 +267,7 @@ typedef struct qfitsdumper {
|
|||
is performed by qfits_loadpix() afterwards.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfitsloader_init(qfitsloader * ql);
|
||||
int qfitsloader_init (qfitsloader * ql);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -287,7 +289,7 @@ int qfitsloader_init(qfitsloader * ql);
|
|||
code before you make calls to the pixel loader here.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_loadpix(qfitsloader * ql);
|
||||
int qfits_loadpix (qfitsloader * ql);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -310,7 +312,7 @@ int qfits_loadpix(qfitsloader * ql);
|
|||
free on the returned pointer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
float * qfits_pixin_float (byte *, int, int, double, double);
|
||||
float *qfits_pixin_float (byte *, int, int, double, double);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -333,7 +335,7 @@ float * qfits_pixin_float (byte *, int, int, double, double);
|
|||
free on the returned pointer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int * qfits_pixin_int (byte *, int, int, double, double);
|
||||
int *qfits_pixin_int (byte *, int, int, double, double);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -356,7 +358,7 @@ int * qfits_pixin_int (byte *, int, int, double, double);
|
|||
free on the returned pointer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
double * qfits_pixin_double(byte *, int, int, double, double);
|
||||
double *qfits_pixin_double (byte *, int, int, double, double);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -393,7 +395,7 @@ double * qfits_pixin_double(byte *, int, int, double, double);
|
|||
will be performed to stdout.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_pixdump(qfitsdumper * qd) ;
|
||||
int qfits_pixdump (qfitsdumper * qd);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -409,7 +411,7 @@ int qfits_pixdump(qfitsdumper * qd) ;
|
|||
using the free() function offered by xmemory.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
byte * qfits_pixdump_float(float * buf, int npix, int ptype);
|
||||
byte *qfits_pixdump_float (float *buf, int npix, int ptype);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -425,7 +427,7 @@ byte * qfits_pixdump_float(float * buf, int npix, int ptype);
|
|||
using the free() function offered by xmemory.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
byte * qfits_pixdump_int(int * buf, int npix, int ptype);
|
||||
byte *qfits_pixdump_int (int *buf, int npix, int ptype);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -441,7 +443,7 @@ byte * qfits_pixdump_int(int * buf, int npix, int ptype);
|
|||
using the free() function offered by xmemory.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
byte * qfits_pixdump_double(double * buf, int npix, int ptype);
|
||||
byte *qfits_pixdump_double (double *buf, int npix, int ptype);
|
||||
|
||||
/* </dox> */
|
||||
#endif
|
||||
|
|
|
@ -41,16 +41,21 @@
|
|||
-----------------------------------------------------------------------------*/
|
||||
|
||||
/* Type of a display function only defined for legibility here */
|
||||
typedef void (*qfits_err_dispfunc)(char *) ;
|
||||
typedef void (*qfits_err_dispfunc) (char *);
|
||||
/* Default display function prints out msg to stderr */
|
||||
static void qfits_err_display_stderr(char * s)
|
||||
{ fprintf(stderr, "qfits: %s\n", s); }
|
||||
static void
|
||||
qfits_err_display_stderr (char *s)
|
||||
{
|
||||
fprintf (stderr, "qfits: %s\n", s);
|
||||
}
|
||||
|
||||
/* Static control structure, completely private */
|
||||
static struct {
|
||||
qfits_err_dispfunc disp[QFITS_ERR_MAXERRDISP] ;
|
||||
int n ;
|
||||
int active ;
|
||||
} qfits_err_control = {{qfits_err_display_stderr}, 1, 0} ;
|
||||
static struct
|
||||
{
|
||||
qfits_err_dispfunc disp[QFITS_ERR_MAXERRDISP];
|
||||
int n;
|
||||
int active;
|
||||
} qfits_err_control = { {qfits_err_display_stderr}, 1, 0 };
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function codes
|
||||
|
@ -64,21 +69,24 @@ static struct {
|
|||
It calls registered display functions one after another.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static void qfits_err_main_display(char * msg)
|
||||
static void
|
||||
qfits_err_main_display (char *msg)
|
||||
{
|
||||
int i ;
|
||||
int i;
|
||||
|
||||
/* Check if there is a message in input */
|
||||
if (msg==NULL)
|
||||
return ;
|
||||
/* Check if there is a message in input */
|
||||
if (msg == NULL)
|
||||
return;
|
||||
|
||||
/* Loop on all registered functions and call them */
|
||||
for (i=0 ; i<qfits_err_control.n ; i++) {
|
||||
if (qfits_err_control.disp[i]) {
|
||||
qfits_err_control.disp[i](msg);
|
||||
}
|
||||
/* Loop on all registered functions and call them */
|
||||
for (i = 0; i < qfits_err_control.n; i++)
|
||||
{
|
||||
if (qfits_err_control.disp[i])
|
||||
{
|
||||
qfits_err_control.disp[i] (msg);
|
||||
}
|
||||
return ;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -91,9 +99,10 @@ static void qfits_err_main_display(char * msg)
|
|||
messages using the registered functions, otherwise they do nothing.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_statget(void)
|
||||
int
|
||||
qfits_err_statget (void)
|
||||
{
|
||||
return qfits_err_control.active ;
|
||||
return qfits_err_control.active;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -114,12 +123,13 @@ int qfits_err_statget(void)
|
|||
@endcode
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_statset(int sta)
|
||||
int
|
||||
qfits_err_statset (int sta)
|
||||
{
|
||||
int prev ;
|
||||
prev = qfits_err_control.active ;
|
||||
qfits_err_control.active=sta ;
|
||||
return prev ;
|
||||
int prev;
|
||||
prev = qfits_err_control.active;
|
||||
qfits_err_control.active = sta;
|
||||
return prev;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -146,53 +156,60 @@ int qfits_err_statset(int sta)
|
|||
returning -1.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_register(qfits_err_dispfunc dispfn)
|
||||
int
|
||||
qfits_err_register (qfits_err_dispfunc dispfn)
|
||||
{
|
||||
if (qfits_err_control.n==QFITS_ERR_MAXERRDISP) {
|
||||
/* Cannot register any more function */
|
||||
return -1 ;
|
||||
}
|
||||
qfits_err_control.disp[qfits_err_control.n] = dispfn ;
|
||||
qfits_err_control.n ++ ;
|
||||
return 0 ;
|
||||
if (qfits_err_control.n == QFITS_ERR_MAXERRDISP)
|
||||
{
|
||||
/* Cannot register any more function */
|
||||
return -1;
|
||||
}
|
||||
qfits_err_control.disp[qfits_err_control.n] = dispfn;
|
||||
qfits_err_control.n++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Public warning/error functions */
|
||||
void qfits_warning(const char *fmt, ...)
|
||||
void
|
||||
qfits_warning (const char *fmt, ...)
|
||||
{
|
||||
char msg[QFITS_ERR_MSGSIZE] ;
|
||||
char all[QFITS_ERR_MSGSIZE] ;
|
||||
va_list ap ;
|
||||
char msg[QFITS_ERR_MSGSIZE];
|
||||
char all[QFITS_ERR_MSGSIZE];
|
||||
va_list ap;
|
||||
|
||||
/* Check if display is activated */
|
||||
if (qfits_err_control.active==0) {
|
||||
return ;
|
||||
}
|
||||
va_start(ap, fmt) ;
|
||||
vsprintf(msg, fmt, ap) ;
|
||||
va_end(ap);
|
||||
/* Check if display is activated */
|
||||
if (qfits_err_control.active == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
va_start (ap, fmt);
|
||||
vsprintf (msg, fmt, ap);
|
||||
va_end (ap);
|
||||
|
||||
sprintf(all, "*** %s", msg);
|
||||
qfits_err_main_display(all);
|
||||
return ;
|
||||
sprintf (all, "*** %s", msg);
|
||||
qfits_err_main_display (all);
|
||||
return;
|
||||
}
|
||||
void qfits_error(const char *fmt, ...)
|
||||
|
||||
void
|
||||
qfits_error (const char *fmt, ...)
|
||||
{
|
||||
char msg[QFITS_ERR_MSGSIZE] ;
|
||||
char all[QFITS_ERR_MSGSIZE] ;
|
||||
va_list ap ;
|
||||
char msg[QFITS_ERR_MSGSIZE];
|
||||
char all[QFITS_ERR_MSGSIZE];
|
||||
va_list ap;
|
||||
|
||||
/* Check if display is activated */
|
||||
if (qfits_err_control.active==0) {
|
||||
return ;
|
||||
}
|
||||
va_start(ap, fmt) ;
|
||||
vsprintf(msg, fmt, ap) ;
|
||||
va_end(ap);
|
||||
/* Check if display is activated */
|
||||
if (qfits_err_control.active == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
va_start (ap, fmt);
|
||||
vsprintf (msg, fmt, ap);
|
||||
va_end (ap);
|
||||
|
||||
sprintf(all, "error: %s", msg);
|
||||
qfits_err_main_display(all);
|
||||
return ;
|
||||
sprintf (all, "error: %s", msg);
|
||||
qfits_err_main_display (all);
|
||||
return;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
messages using the registered functions, otherwise they do nothing.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_statget(void);
|
||||
int qfits_err_statget (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -60,7 +60,7 @@ int qfits_err_statget(void);
|
|||
\end{verbatim}
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_statset(int sta);
|
||||
int qfits_err_statset (int sta);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -86,12 +86,12 @@ int qfits_err_statset(int sta);
|
|||
returning -1.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_err_register( void (*dispfn)(char*) ) ;
|
||||
int qfits_err_register (void (*dispfn) (char *));
|
||||
/* </dox> */
|
||||
|
||||
/* Public warning/error functions */
|
||||
void qfits_warning(const char *fmt, ...);
|
||||
void qfits_error(const char *fmt, ...);
|
||||
void qfits_warning (const char *fmt, ...);
|
||||
void qfits_error (const char *fmt, ...);
|
||||
|
||||
#endif
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -50,14 +50,14 @@
|
|||
*/
|
||||
/** A regular expression matching a floating-point number */
|
||||
static char regex_float[] =
|
||||
"^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?$";
|
||||
"^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?$";
|
||||
|
||||
/** A regular expression matching an integer */
|
||||
static char regex_int[] = "^[+-]?[0-9]+$";
|
||||
|
||||
/** A regular expression matching a complex number (int or float) */
|
||||
static char regex_cmp[] =
|
||||
"^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?[ ]+[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?$";
|
||||
"^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?[ ]+[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eEdD][+-]?[0-9]+)?$";
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function codes
|
||||
|
@ -90,9 +90,10 @@ static char regex_cmp[] =
|
|||
Returns NULL in case the requested keyword cannot be found.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_hdr(char * filename, const char * keyword)
|
||||
char *
|
||||
qfits_query_hdr (char *filename, const char *keyword)
|
||||
{
|
||||
return qfits_query_ext(filename, keyword, 0);
|
||||
return qfits_query_ext (filename, keyword, 0);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -108,90 +109,99 @@ char * qfits_query_hdr(char * filename, const char * keyword)
|
|||
strictly identical to qfits_query_hdr().
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_ext(char * filename, const char * keyword, int xtnum)
|
||||
char *
|
||||
qfits_query_ext (char *filename, const char *keyword, int xtnum)
|
||||
{
|
||||
char * exp_key ;
|
||||
char * where ;
|
||||
char * start ;
|
||||
char * value ;
|
||||
char test1, test2 ;
|
||||
int i ;
|
||||
int len ;
|
||||
int different ;
|
||||
int seg_start ;
|
||||
int seg_size ;
|
||||
long bufcount ;
|
||||
size_t size ;
|
||||
char *exp_key;
|
||||
char *where;
|
||||
char *start;
|
||||
char *value;
|
||||
char test1, test2;
|
||||
int i;
|
||||
int len;
|
||||
int different;
|
||||
int seg_start;
|
||||
int seg_size;
|
||||
long bufcount;
|
||||
size_t size;
|
||||
|
||||
/* Bulletproof entries */
|
||||
if (filename==NULL || keyword==NULL || xtnum<0) return NULL ;
|
||||
/* Bulletproof entries */
|
||||
if (filename == NULL || keyword == NULL || xtnum < 0)
|
||||
return NULL;
|
||||
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword(keyword);
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword (keyword);
|
||||
|
||||
/*
|
||||
* Find out offsets to the required extension
|
||||
* Record the xtension start and stop offsets
|
||||
*/
|
||||
if (qfits_get_hdrinfo(filename, xtnum, &seg_start, &seg_size)==-1) {
|
||||
return NULL ;
|
||||
/*
|
||||
* Find out offsets to the required extension
|
||||
* Record the xtension start and stop offsets
|
||||
*/
|
||||
if (qfits_get_hdrinfo (filename, xtnum, &seg_start, &seg_size) == -1)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get a hand on requested buffer
|
||||
*/
|
||||
/*
|
||||
* Get a hand on requested buffer
|
||||
*/
|
||||
|
||||
start = falloc(filename, seg_start, &size);
|
||||
if (start==NULL) return NULL ;
|
||||
start = falloc (filename, seg_start, &size);
|
||||
if (start == NULL)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Look for keyword in header
|
||||
*/
|
||||
/*
|
||||
* Look for keyword in header
|
||||
*/
|
||||
|
||||
bufcount=0 ;
|
||||
where = start ;
|
||||
len = (int)strlen(exp_key);
|
||||
while (1) {
|
||||
different=0 ;
|
||||
for (i=0 ; i<len ; i++) {
|
||||
if (where[i]!=exp_key[i]) {
|
||||
different++ ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (!different) {
|
||||
/* Get 2 chars after keyword */
|
||||
test1=where[len];
|
||||
test2=where[len+1];
|
||||
/* If first subsequent character is the equal sign, bingo. */
|
||||
if (test1=='=') break ;
|
||||
/* If subsequent char is equal sign, bingo */
|
||||
if (test1==' ' && (test2=='=' || test2==' '))
|
||||
break ;
|
||||
}
|
||||
/* Watch out for header end */
|
||||
if ((where[0]=='E') &&
|
||||
(where[1]=='N') &&
|
||||
(where[2]=='D') &&
|
||||
(where[3]==' ')) {
|
||||
/* Detected header end */
|
||||
fdealloc(start, seg_start, size) ;
|
||||
return NULL ;
|
||||
}
|
||||
/* Forward one line */
|
||||
where += 80 ;
|
||||
bufcount += 80 ;
|
||||
if (bufcount>seg_size) {
|
||||
/* File is damaged or not FITS: bailout */
|
||||
fdealloc(start, seg_start, size) ;
|
||||
return NULL ;
|
||||
}
|
||||
bufcount = 0;
|
||||
where = start;
|
||||
len = (int) strlen (exp_key);
|
||||
while (1)
|
||||
{
|
||||
different = 0;
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
if (where[i] != exp_key[i])
|
||||
{
|
||||
different++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!different)
|
||||
{
|
||||
/* Get 2 chars after keyword */
|
||||
test1 = where[len];
|
||||
test2 = where[len + 1];
|
||||
/* If first subsequent character is the equal sign, bingo. */
|
||||
if (test1 == '=')
|
||||
break;
|
||||
/* If subsequent char is equal sign, bingo */
|
||||
if (test1 == ' ' && (test2 == '=' || test2 == ' '))
|
||||
break;
|
||||
}
|
||||
/* Watch out for header end */
|
||||
if ((where[0] == 'E') &&
|
||||
(where[1] == 'N') && (where[2] == 'D') && (where[3] == ' '))
|
||||
{
|
||||
/* Detected header end */
|
||||
fdealloc (start, seg_start, size);
|
||||
return NULL;
|
||||
}
|
||||
/* Forward one line */
|
||||
where += 80;
|
||||
bufcount += 80;
|
||||
if (bufcount > seg_size)
|
||||
{
|
||||
/* File is damaged or not FITS: bailout */
|
||||
fdealloc (start, seg_start, size);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Found the keyword, now get its value */
|
||||
value = qfits_getvalue(where);
|
||||
fdealloc(start, seg_start, size) ;
|
||||
return value;
|
||||
/* Found the keyword, now get its value */
|
||||
value = qfits_getvalue (where);
|
||||
fdealloc (start, seg_start, size);
|
||||
return value;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -203,9 +213,10 @@ char * qfits_query_ext(char * filename, const char * keyword, int xtnum)
|
|||
extension is found, and -1 if an error occurred.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_query_n_ext(char * filename)
|
||||
int
|
||||
qfits_query_n_ext (char *filename)
|
||||
{
|
||||
return qfits_query(filename, QFITS_QUERY_N_EXT);
|
||||
return qfits_query (filename, QFITS_QUERY_N_EXT);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -218,45 +229,54 @@ int qfits_query_n_ext(char * filename)
|
|||
and -1 if an error occurred.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_query_nplanes(char * filename, int extnum)
|
||||
int
|
||||
qfits_query_nplanes (char *filename, int extnum)
|
||||
{
|
||||
char * sval ;
|
||||
int next ;
|
||||
int naxes ;
|
||||
int nplanes ;
|
||||
char *sval;
|
||||
int next;
|
||||
int naxes;
|
||||
int nplanes;
|
||||
|
||||
/* Check file existence */
|
||||
if (filename == NULL) return -1 ;
|
||||
/* Check validity of extnum */
|
||||
next = qfits_query_n_ext(filename) ;
|
||||
if (extnum>next) {
|
||||
qfits_error("invalid extension specified") ;
|
||||
return -1 ;
|
||||
/* Check file existence */
|
||||
if (filename == NULL)
|
||||
return -1;
|
||||
/* Check validity of extnum */
|
||||
next = qfits_query_n_ext (filename);
|
||||
if (extnum > next)
|
||||
{
|
||||
qfits_error ("invalid extension specified");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Find the number of axes */
|
||||
naxes = 0;
|
||||
if ((sval = qfits_query_ext (filename, "NAXIS", extnum)) == NULL)
|
||||
{
|
||||
qfits_error ("missing key in header: NAXIS");
|
||||
return -1;
|
||||
}
|
||||
naxes = atoi (sval);
|
||||
|
||||
/* Check validity of naxes */
|
||||
if ((naxes < 2) || (naxes > 3))
|
||||
return -1;
|
||||
|
||||
/* Two dimensions cube */
|
||||
if (naxes == 2)
|
||||
nplanes = 1;
|
||||
else
|
||||
{
|
||||
/* For 3D cubes, get the third dimension size */
|
||||
if ((sval = qfits_query_ext (filename, "NAXIS3", extnum)) == NULL)
|
||||
{
|
||||
qfits_error ("missing key in header: NAXIS3");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Find the number of axes */
|
||||
naxes = 0 ;
|
||||
if ((sval = qfits_query_ext(filename, "NAXIS", extnum)) == NULL) {
|
||||
qfits_error("missing key in header: NAXIS");
|
||||
return -1 ;
|
||||
}
|
||||
naxes = atoi(sval) ;
|
||||
|
||||
/* Check validity of naxes */
|
||||
if ((naxes < 2) || (naxes > 3)) return -1 ;
|
||||
|
||||
/* Two dimensions cube */
|
||||
if (naxes == 2) nplanes = 1 ;
|
||||
else {
|
||||
/* For 3D cubes, get the third dimension size */
|
||||
if ((sval = qfits_query_ext(filename, "NAXIS3", extnum))==NULL) {
|
||||
qfits_error("missing key in header: NAXIS3");
|
||||
return -1 ;
|
||||
}
|
||||
nplanes = atoi(sval);
|
||||
if (nplanes < 1) nplanes = 0 ;
|
||||
}
|
||||
return nplanes ;
|
||||
nplanes = atoi (sval);
|
||||
if (nplanes < 1)
|
||||
nplanes = 0;
|
||||
}
|
||||
return nplanes;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -278,51 +298,61 @@ int qfits_query_nplanes(char * filename, int extnum)
|
|||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
#define PRETTY_STRING_STATICBUFS 8
|
||||
char * qfits_pretty_string(char * s)
|
||||
char *
|
||||
qfits_pretty_string (char *s)
|
||||
{
|
||||
static char pretty_buf[PRETTY_STRING_STATICBUFS][81] ;
|
||||
static int flip=0 ;
|
||||
char * pretty ;
|
||||
int i,j ;
|
||||
static char pretty_buf[PRETTY_STRING_STATICBUFS][81];
|
||||
static int flip = 0;
|
||||
char *pretty;
|
||||
int i, j;
|
||||
|
||||
/* bulletproof */
|
||||
if (s==NULL) return NULL ;
|
||||
/* bulletproof */
|
||||
if (s == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Switch between static buffers */
|
||||
pretty = pretty_buf[flip];
|
||||
flip++ ;
|
||||
if (flip==PRETTY_STRING_STATICBUFS)
|
||||
flip=0 ;
|
||||
/* Switch between static buffers */
|
||||
pretty = pretty_buf[flip];
|
||||
flip++;
|
||||
if (flip == PRETTY_STRING_STATICBUFS)
|
||||
flip = 0;
|
||||
|
||||
pretty[0] = (char)0 ;
|
||||
if (s[0]!='\'') return s ;
|
||||
pretty[0] = (char) 0;
|
||||
if (s[0] != '\'')
|
||||
return s;
|
||||
|
||||
/* skip first quote */
|
||||
i=1 ;
|
||||
j=0 ;
|
||||
/* trim left-side blanks */
|
||||
while (s[i]==' ') {
|
||||
if (i==(int)strlen(s)) break ;
|
||||
i++ ;
|
||||
/* skip first quote */
|
||||
i = 1;
|
||||
j = 0;
|
||||
/* trim left-side blanks */
|
||||
while (s[i] == ' ')
|
||||
{
|
||||
if (i == (int) strlen (s))
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
if (i>=(int)(strlen(s)-1)) return pretty ;
|
||||
/* copy string, changing double quotes to single ones */
|
||||
while (i<(int)strlen(s)) {
|
||||
if (s[i]=='\'') {
|
||||
i++ ;
|
||||
}
|
||||
pretty[j]=s[i];
|
||||
i++ ;
|
||||
j++ ;
|
||||
}
|
||||
/* NULL-terminate the pretty string */
|
||||
pretty[j+1]=(char)0;
|
||||
/* trim right-side blanks */
|
||||
j = (int)strlen(pretty)-1;
|
||||
while (pretty[j]==' ') j-- ;
|
||||
pretty[j+1]=(char)0;
|
||||
if (i >= (int) (strlen (s) - 1))
|
||||
return pretty;
|
||||
/* copy string, changing double quotes to single ones */
|
||||
while (i < (int) strlen (s))
|
||||
{
|
||||
if (s[i] == '\'')
|
||||
{
|
||||
i++;
|
||||
}
|
||||
pretty[j] = s[i];
|
||||
i++;
|
||||
j++;
|
||||
}
|
||||
/* NULL-terminate the pretty string */
|
||||
pretty[j + 1] = (char) 0;
|
||||
/* trim right-side blanks */
|
||||
j = (int) strlen (pretty) - 1;
|
||||
while (pretty[j] == ' ')
|
||||
j--;
|
||||
pretty[j + 1] = (char) 0;
|
||||
return pretty;
|
||||
}
|
||||
|
||||
#undef PRETTY_STRING_STATICBUFS
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -334,13 +364,18 @@ char * qfits_pretty_string(char * s)
|
|||
Identifies if a FITS value is boolean.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_boolean(char * s)
|
||||
int
|
||||
qfits_is_boolean (char *s)
|
||||
{
|
||||
if (s==NULL) return 0 ;
|
||||
if (s[0]==0) return 0 ;
|
||||
if ((int)strlen(s)>1) return 0 ;
|
||||
if (s[0]=='T' || s[0]=='F') return 1 ;
|
||||
return 0 ;
|
||||
if (s == NULL)
|
||||
return 0;
|
||||
if (s[0] == 0)
|
||||
return 0;
|
||||
if ((int) strlen (s) > 1)
|
||||
return 0;
|
||||
if (s[0] == 'T' || s[0] == 'F')
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -352,20 +387,24 @@ int qfits_is_boolean(char * s)
|
|||
Identifies if a FITS value is an integer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_int(char * s)
|
||||
int
|
||||
qfits_is_int (char *s)
|
||||
{
|
||||
regex_t re_int ;
|
||||
int status ;
|
||||
regex_t re_int;
|
||||
int status;
|
||||
|
||||
if (s==NULL) return 0 ;
|
||||
if (s[0]==0) return 0 ;
|
||||
if (regcomp(&re_int, ®ex_int[0], REG_EXTENDED|REG_NOSUB)!=0) {
|
||||
qfits_error("internal error: compiling int rule");
|
||||
exit(-1);
|
||||
if (s == NULL)
|
||||
return 0;
|
||||
if (s[0] == 0)
|
||||
return 0;
|
||||
if (regcomp (&re_int, ®ex_int[0], REG_EXTENDED | REG_NOSUB) != 0)
|
||||
{
|
||||
qfits_error ("internal error: compiling int rule");
|
||||
exit (-1);
|
||||
}
|
||||
status = regexec(&re_int, s, 0, NULL, 0) ;
|
||||
regfree(&re_int) ;
|
||||
return (status) ? 0 : 1 ;
|
||||
status = regexec (&re_int, s, 0, NULL, 0);
|
||||
regfree (&re_int);
|
||||
return (status) ? 0 : 1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -377,20 +416,24 @@ int qfits_is_int(char * s)
|
|||
Identifies if a FITS value is float.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_float(char * s)
|
||||
int
|
||||
qfits_is_float (char *s)
|
||||
{
|
||||
regex_t re_float;
|
||||
int status ;
|
||||
regex_t re_float;
|
||||
int status;
|
||||
|
||||
if (s==NULL) return 0 ;
|
||||
if (s[0]==0) return 0 ;
|
||||
if (regcomp(&re_float, ®ex_float[0], REG_EXTENDED|REG_NOSUB)!=0) {
|
||||
qfits_error("internal error: compiling float rule");
|
||||
exit(-1);
|
||||
if (s == NULL)
|
||||
return 0;
|
||||
if (s[0] == 0)
|
||||
return 0;
|
||||
if (regcomp (&re_float, ®ex_float[0], REG_EXTENDED | REG_NOSUB) != 0)
|
||||
{
|
||||
qfits_error ("internal error: compiling float rule");
|
||||
exit (-1);
|
||||
}
|
||||
status = regexec(&re_float, s, 0, NULL, 0) ;
|
||||
regfree(&re_float) ;
|
||||
return (status) ? 0 : 1 ;
|
||||
status = regexec (&re_float, s, 0, NULL, 0);
|
||||
regfree (&re_float);
|
||||
return (status) ? 0 : 1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -402,20 +445,24 @@ int qfits_is_float(char * s)
|
|||
Identifies if a FITS value is complex.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_complex(char * s)
|
||||
int
|
||||
qfits_is_complex (char *s)
|
||||
{
|
||||
regex_t re_cmp ;
|
||||
int status ;
|
||||
regex_t re_cmp;
|
||||
int status;
|
||||
|
||||
if (s==NULL) return 0 ;
|
||||
if (s[0]==0) return 0 ;
|
||||
if (regcomp(&re_cmp, ®ex_cmp[0], REG_EXTENDED|REG_NOSUB)!=0) {
|
||||
qfits_error("internal error: compiling complex rule");
|
||||
exit(-1);
|
||||
if (s == NULL)
|
||||
return 0;
|
||||
if (s[0] == 0)
|
||||
return 0;
|
||||
if (regcomp (&re_cmp, ®ex_cmp[0], REG_EXTENDED | REG_NOSUB) != 0)
|
||||
{
|
||||
qfits_error ("internal error: compiling complex rule");
|
||||
exit (-1);
|
||||
}
|
||||
status = regexec(&re_cmp, s, 0, NULL, 0) ;
|
||||
regfree(&re_cmp) ;
|
||||
return (status) ? 0 : 1 ;
|
||||
status = regexec (&re_cmp, s, 0, NULL, 0);
|
||||
regfree (&re_cmp);
|
||||
return (status) ? 0 : 1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -427,11 +474,14 @@ int qfits_is_complex(char * s)
|
|||
Identifies if a FITS value is a string.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_string(char * s)
|
||||
int
|
||||
qfits_is_string (char *s)
|
||||
{
|
||||
if (s==NULL) return 0 ;
|
||||
if (s[0]=='\'') return 1 ;
|
||||
return 0 ;
|
||||
if (s == NULL)
|
||||
return 0;
|
||||
if (s[0] == '\'')
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -450,14 +500,20 @@ int qfits_is_string(char * s)
|
|||
- QFITS_STRING (5) for a FITS string.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_type(char * s)
|
||||
int
|
||||
qfits_get_type (char *s)
|
||||
{
|
||||
if (s==NULL) return QFITS_UNKNOWN ;
|
||||
if (qfits_is_boolean(s)) return QFITS_BOOLEAN ;
|
||||
if (qfits_is_int(s)) return QFITS_INT ;
|
||||
if (qfits_is_float(s)) return QFITS_FLOAT ;
|
||||
if (qfits_is_complex(s)) return QFITS_COMPLEX ;
|
||||
return QFITS_STRING ;
|
||||
if (s == NULL)
|
||||
return QFITS_UNKNOWN;
|
||||
if (qfits_is_boolean (s))
|
||||
return QFITS_BOOLEAN;
|
||||
if (qfits_is_int (s))
|
||||
return QFITS_INT;
|
||||
if (qfits_is_float (s))
|
||||
return QFITS_FLOAT;
|
||||
if (qfits_is_complex (s))
|
||||
return QFITS_COMPLEX;
|
||||
return QFITS_STRING;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -479,26 +535,27 @@ int qfits_get_type(char * s)
|
|||
main header in the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_hdrinfo(
|
||||
char * filename,
|
||||
int xtnum,
|
||||
int * seg_start,
|
||||
int * seg_size)
|
||||
int
|
||||
qfits_get_hdrinfo (char *filename, int xtnum, int *seg_start, int *seg_size)
|
||||
{
|
||||
if (filename==NULL || xtnum<0 || (seg_start==NULL && seg_size==NULL)) {
|
||||
return -1 ;
|
||||
if (filename == NULL || xtnum < 0
|
||||
|| (seg_start == NULL && seg_size == NULL))
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
if (seg_start!=NULL) {
|
||||
*seg_start = qfits_query(filename, QFITS_QUERY_HDR_START | xtnum);
|
||||
if (*seg_start<0)
|
||||
return -1 ;
|
||||
if (seg_start != NULL)
|
||||
{
|
||||
*seg_start = qfits_query (filename, QFITS_QUERY_HDR_START | xtnum);
|
||||
if (*seg_start < 0)
|
||||
return -1;
|
||||
}
|
||||
if (seg_size!=NULL) {
|
||||
*seg_size = qfits_query(filename, QFITS_QUERY_HDR_SIZE | xtnum);
|
||||
if (*seg_size<0)
|
||||
return -1 ;
|
||||
if (seg_size != NULL)
|
||||
{
|
||||
*seg_size = qfits_query (filename, QFITS_QUERY_HDR_SIZE | xtnum);
|
||||
if (*seg_size < 0)
|
||||
return -1;
|
||||
}
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -520,26 +577,27 @@ int qfits_get_hdrinfo(
|
|||
main header in the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_datinfo(
|
||||
char * filename,
|
||||
int xtnum,
|
||||
int * seg_start,
|
||||
int * seg_size)
|
||||
int
|
||||
qfits_get_datinfo (char *filename, int xtnum, int *seg_start, int *seg_size)
|
||||
{
|
||||
if (filename==NULL || xtnum<0 || (seg_start==NULL && seg_size==NULL)) {
|
||||
return -1 ;
|
||||
if (filename == NULL || xtnum < 0
|
||||
|| (seg_start == NULL && seg_size == NULL))
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
if (seg_start!=NULL) {
|
||||
*seg_start = qfits_query(filename, QFITS_QUERY_DAT_START | xtnum);
|
||||
if (*seg_start<0)
|
||||
return -1 ;
|
||||
if (seg_start != NULL)
|
||||
{
|
||||
*seg_start = qfits_query (filename, QFITS_QUERY_DAT_START | xtnum);
|
||||
if (*seg_start < 0)
|
||||
return -1;
|
||||
}
|
||||
if (seg_size!=NULL) {
|
||||
*seg_size = qfits_query(filename, QFITS_QUERY_DAT_SIZE | xtnum);
|
||||
if (*seg_size<0)
|
||||
return -1 ;
|
||||
if (seg_size != NULL)
|
||||
{
|
||||
*seg_size = qfits_query (filename, QFITS_QUERY_DAT_SIZE | xtnum);
|
||||
if (*seg_size < 0)
|
||||
return -1;
|
||||
}
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -550,72 +608,74 @@ int qfits_get_datinfo(
|
|||
@return Allocated string containing the card or NULL
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_card(
|
||||
char * filename,
|
||||
char * keyword)
|
||||
char *
|
||||
qfits_query_card (char *filename, char *keyword)
|
||||
{
|
||||
char * exp_key ;
|
||||
int fd ;
|
||||
char * buf ;
|
||||
char * buf2 ;
|
||||
char * where ;
|
||||
int hs ;
|
||||
char * card ;
|
||||
char *exp_key;
|
||||
int fd;
|
||||
char *buf;
|
||||
char *buf2;
|
||||
char *where;
|
||||
int hs;
|
||||
char *card;
|
||||
|
||||
/* Bulletproof entries */
|
||||
if (filename==NULL || keyword==NULL) return NULL ;
|
||||
/* Bulletproof entries */
|
||||
if (filename == NULL || keyword == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword(keyword) ;
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword (keyword);
|
||||
|
||||
/* Memory-map the FITS header of the input file */
|
||||
qfits_get_hdrinfo(filename, 0, NULL, &hs) ;
|
||||
if (hs < 1) {
|
||||
qfits_error("error getting FITS header size for %s", filename);
|
||||
return NULL ;
|
||||
/* Memory-map the FITS header of the input file */
|
||||
qfits_get_hdrinfo (filename, 0, NULL, &hs);
|
||||
if (hs < 1)
|
||||
{
|
||||
qfits_error ("error getting FITS header size for %s", filename);
|
||||
return NULL;
|
||||
}
|
||||
fd = open(filename, O_RDWR) ;
|
||||
if (fd == -1) return NULL ;
|
||||
buf = (char*)mmap(0,
|
||||
hs,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
fd,
|
||||
0) ;
|
||||
if (buf == (char*)-1) {
|
||||
perror("mmap") ;
|
||||
close(fd) ;
|
||||
return NULL ;
|
||||
fd = open (filename, O_RDWR);
|
||||
if (fd == -1)
|
||||
return NULL;
|
||||
buf = (char *) mmap (0, hs, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
if (buf == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
close (fd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Apply search for the input keyword */
|
||||
buf2 = malloc(hs+1) ;
|
||||
memcpy(buf2, buf, hs) ;
|
||||
buf2[hs] = (char)0 ;
|
||||
where = buf2 ;
|
||||
do {
|
||||
where = strstr(where, exp_key);
|
||||
if (where == NULL) {
|
||||
close(fd);
|
||||
munmap(buf,hs);
|
||||
free(buf2) ;
|
||||
return NULL ;
|
||||
}
|
||||
if ((where-buf2)%80) where++ ;
|
||||
} while ((where-buf2)%80) ;
|
||||
/* Apply search for the input keyword */
|
||||
buf2 = malloc (hs + 1);
|
||||
memcpy (buf2, buf, hs);
|
||||
buf2[hs] = (char) 0;
|
||||
where = buf2;
|
||||
do
|
||||
{
|
||||
where = strstr (where, exp_key);
|
||||
if (where == NULL)
|
||||
{
|
||||
close (fd);
|
||||
munmap (buf, hs);
|
||||
free (buf2);
|
||||
return NULL;
|
||||
}
|
||||
if ((where - buf2) % 80)
|
||||
where++;
|
||||
}
|
||||
while ((where - buf2) % 80);
|
||||
|
||||
where = buf + (int)(where - buf2) ;
|
||||
where = buf + (int) (where - buf2);
|
||||
|
||||
/* Create the card */
|
||||
card = malloc(81*sizeof(char)) ;
|
||||
strncpy(card, where, 80) ;
|
||||
card[80] = (char)0 ;
|
||||
/* Create the card */
|
||||
card = malloc (81 * sizeof (char));
|
||||
strncpy (card, where, 80);
|
||||
card[80] = (char) 0;
|
||||
|
||||
/* Free and return */
|
||||
close(fd) ;
|
||||
munmap(buf, hs) ;
|
||||
free(buf2) ;
|
||||
return card ;
|
||||
/* Free and return */
|
||||
close (fd);
|
||||
munmap (buf, hs);
|
||||
free (buf2);
|
||||
return card;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -637,76 +697,77 @@ char * qfits_query_card(
|
|||
Returns 0 if everything worked Ok, -1 otherwise.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_replace_card(
|
||||
char * filename,
|
||||
const char * keyword,
|
||||
char * substitute)
|
||||
int
|
||||
qfits_replace_card (char *filename, const char *keyword, char *substitute)
|
||||
{
|
||||
char * exp_key ;
|
||||
int fd ;
|
||||
char * buf ;
|
||||
char * buf2 ;
|
||||
char * where ;
|
||||
int hs ;
|
||||
char *exp_key;
|
||||
int fd;
|
||||
char *buf;
|
||||
char *buf2;
|
||||
char *where;
|
||||
int hs;
|
||||
|
||||
|
||||
/* Bulletproof entries */
|
||||
if (filename==NULL || keyword==NULL || substitute==NULL) return -1 ;
|
||||
/* Bulletproof entries */
|
||||
if (filename == NULL || keyword == NULL || substitute == NULL)
|
||||
return -1;
|
||||
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword(keyword);
|
||||
/*
|
||||
* Memory-map the FITS header of the input file
|
||||
*/
|
||||
/* Expand keyword */
|
||||
exp_key = qfits_expand_keyword (keyword);
|
||||
/*
|
||||
* Memory-map the FITS header of the input file
|
||||
*/
|
||||
|
||||
qfits_get_hdrinfo(filename, 0, NULL, &hs) ;
|
||||
if (hs < 1) {
|
||||
qfits_error("error getting FITS header size for %s", filename);
|
||||
return -1 ;
|
||||
qfits_get_hdrinfo (filename, 0, NULL, &hs);
|
||||
if (hs < 1)
|
||||
{
|
||||
qfits_error ("error getting FITS header size for %s", filename);
|
||||
return -1;
|
||||
}
|
||||
fd = open(filename, O_RDWR) ;
|
||||
if (fd == -1) {
|
||||
return -1 ;
|
||||
fd = open (filename, O_RDWR);
|
||||
if (fd == -1)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
buf = (char*)mmap(0,
|
||||
hs,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED,
|
||||
fd,
|
||||
0) ;
|
||||
if (buf == (char*)-1) {
|
||||
perror("mmap") ;
|
||||
close(fd) ;
|
||||
return -1 ;
|
||||
buf = (char *) mmap (0, hs, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
if (buf == (char *) -1)
|
||||
{
|
||||
perror ("mmap");
|
||||
close (fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Apply search and replace for the input keyword lists */
|
||||
buf2 = malloc(hs+1) ;
|
||||
memcpy(buf2, buf, hs) ;
|
||||
buf2[hs] = (char)0 ;
|
||||
where = buf2 ;
|
||||
do {
|
||||
where = strstr(where, exp_key);
|
||||
if (where == NULL) {
|
||||
close(fd);
|
||||
munmap(buf,hs);
|
||||
free(buf2) ;
|
||||
return -1 ;
|
||||
}
|
||||
if ((where-buf2)%80) where++ ;
|
||||
} while ((where-buf2)%80) ;
|
||||
/* Apply search and replace for the input keyword lists */
|
||||
buf2 = malloc (hs + 1);
|
||||
memcpy (buf2, buf, hs);
|
||||
buf2[hs] = (char) 0;
|
||||
where = buf2;
|
||||
do
|
||||
{
|
||||
where = strstr (where, exp_key);
|
||||
if (where == NULL)
|
||||
{
|
||||
close (fd);
|
||||
munmap (buf, hs);
|
||||
free (buf2);
|
||||
return -1;
|
||||
}
|
||||
if ((where - buf2) % 80)
|
||||
where++;
|
||||
}
|
||||
while ((where - buf2) % 80);
|
||||
|
||||
where = buf + (int)(where - buf2) ;
|
||||
where = buf + (int) (where - buf2);
|
||||
|
||||
/* Replace current placeholder by blanks */
|
||||
memset(where, ' ', 80);
|
||||
/* Copy substitute into placeholder */
|
||||
memcpy(where, substitute, strlen(substitute));
|
||||
/* Replace current placeholder by blanks */
|
||||
memset (where, ' ', 80);
|
||||
/* Copy substitute into placeholder */
|
||||
memcpy (where, substitute, strlen (substitute));
|
||||
|
||||
close(fd) ;
|
||||
munmap(buf, hs) ;
|
||||
free(buf2) ;
|
||||
return 0 ;
|
||||
close (fd);
|
||||
munmap (buf, hs);
|
||||
free (buf2);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -22,7 +22,8 @@
|
|||
#define SIMPLE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -82,7 +83,7 @@ extern "C" {
|
|||
Returns NULL in case the requested keyword cannot be found.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_hdr(char * filename, const char * keyword) ;
|
||||
char *qfits_query_hdr (char *filename, const char *keyword);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -97,7 +98,7 @@ char * qfits_query_hdr(char * filename, const char * keyword) ;
|
|||
strictly identical to qfits_query_hdr().
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_ext(char * filename, const char * keyword, int xtnum) ;
|
||||
char *qfits_query_ext (char *filename, const char *keyword, int xtnum);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -109,7 +110,7 @@ char * qfits_query_ext(char * filename, const char * keyword, int xtnum) ;
|
|||
extension is found, and -1 if an error occurred.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_query_n_ext(char * filename) ;
|
||||
int qfits_query_n_ext (char *filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -121,7 +122,7 @@ int qfits_query_n_ext(char * filename) ;
|
|||
and -1 if an error occurred.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_query_nplanes(char * filename, int extnum) ;
|
||||
int qfits_query_nplanes (char *filename, int extnum);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -141,7 +142,7 @@ int qfits_query_nplanes(char * filename, int extnum) ;
|
|||
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_pretty_string(char * s) ;
|
||||
char *qfits_pretty_string (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -152,7 +153,7 @@ char * qfits_pretty_string(char * s) ;
|
|||
Identifies if a FITS value is boolean.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_boolean(char * s) ;
|
||||
int qfits_is_boolean (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -163,7 +164,7 @@ int qfits_is_boolean(char * s) ;
|
|||
Identifies if a FITS value is an integer.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_int(char * s) ;
|
||||
int qfits_is_int (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -174,7 +175,7 @@ int qfits_is_int(char * s) ;
|
|||
Identifies if a FITS value is float.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_float(char * s) ;
|
||||
int qfits_is_float (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -185,7 +186,7 @@ int qfits_is_float(char * s) ;
|
|||
Identifies if a FITS value is complex.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_complex(char * s) ;
|
||||
int qfits_is_complex (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -196,7 +197,7 @@ int qfits_is_complex(char * s) ;
|
|||
Identifies if a FITS value is a string.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_string(char * s) ;
|
||||
int qfits_is_string (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -214,7 +215,7 @@ int qfits_is_string(char * s) ;
|
|||
- QFITS_STRING (5) for a FITS string.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_type(char * s) ;
|
||||
int qfits_get_type (char *s);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -235,11 +236,8 @@ int qfits_get_type(char * s) ;
|
|||
main header in the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_hdrinfo(
|
||||
char * filename,
|
||||
int xtnum,
|
||||
int * seg_start,
|
||||
int * seg_size) ;
|
||||
int qfits_get_hdrinfo (char *filename,
|
||||
int xtnum, int *seg_start, int *seg_size);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -260,11 +258,8 @@ int qfits_get_hdrinfo(
|
|||
main header in the file.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_get_datinfo(
|
||||
char * filename,
|
||||
int xtnum,
|
||||
int * seg_start,
|
||||
int * seg_size) ;
|
||||
int qfits_get_datinfo (char *filename,
|
||||
int xtnum, int *seg_start, int *seg_size);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -274,9 +269,7 @@ int qfits_get_datinfo(
|
|||
@return Allocated string containing the card or NULL
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_query_card(
|
||||
char * filename,
|
||||
char * keyword) ;
|
||||
char *qfits_query_card (char *filename, char *keyword);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -297,10 +290,8 @@ char * qfits_query_card(
|
|||
Returns 0 if everything worked Ok, -1 otherwise.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_replace_card(
|
||||
char * filename,
|
||||
const char * keyword,
|
||||
char * substitute) ;
|
||||
int qfits_replace_card (char *filename,
|
||||
const char *keyword, char *substitute);
|
||||
|
||||
/* </dox> */
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -19,7 +19,8 @@
|
|||
#define STATIC_SZ_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/* <dox> */
|
||||
|
|
|
@ -75,8 +75,8 @@
|
|||
Private to this module
|
||||
-----------------------------------------------------------------------------*/
|
||||
|
||||
static long timer_to_date(time_t time_secs) ;
|
||||
static long timer_to_time(time_t time_secs) ;
|
||||
static long timer_to_date (time_t time_secs);
|
||||
static long timer_to_time (time_t time_secs);
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Static Function code
|
||||
|
@ -95,9 +95,10 @@ static long timer_to_time(time_t time_secs) ;
|
|||
Example: 19 Oct 2000 is returned as 20001019
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
long qfits_date_now (void)
|
||||
long
|
||||
qfits_date_now (void)
|
||||
{
|
||||
return (timer_to_date (time (NULL)));
|
||||
return (timer_to_date (time (NULL)));
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -111,13 +112,13 @@ long qfits_date_now (void)
|
|||
Example: 15:36:12.84 is returned as 15361284
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
long qfits_time_now(void)
|
||||
long
|
||||
qfits_time_now (void)
|
||||
{
|
||||
struct timeval time_struct;
|
||||
struct timeval time_struct;
|
||||
|
||||
gettimeofday (&time_struct, 0);
|
||||
return (timer_to_time (time_struct.tv_sec)
|
||||
+ time_struct.tv_usec / 10000);
|
||||
gettimeofday (&time_struct, 0);
|
||||
return (timer_to_time (time_struct.tv_sec) + time_struct.tv_usec / 10000);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -133,25 +134,31 @@ long qfits_time_now(void)
|
|||
(GMT).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static long timer_to_date(time_t time_secs)
|
||||
static long
|
||||
timer_to_date (time_t time_secs)
|
||||
{
|
||||
struct tm *time_struct;
|
||||
struct tm *time_struct;
|
||||
|
||||
if (time_secs == 0) {
|
||||
return 0;
|
||||
} else {
|
||||
/* Convert into a long value CCYYMMDD */
|
||||
time_struct = localtime (&time_secs);
|
||||
if (time_struct) {
|
||||
time_struct-> tm_year += 1900;
|
||||
return (MAKE_DATE ( time_struct-> tm_year / 100,
|
||||
time_struct-> tm_year % 100,
|
||||
time_struct-> tm_mon + 1,
|
||||
time_struct-> tm_mday));
|
||||
} else {
|
||||
return (19700101);
|
||||
}
|
||||
if (time_secs == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Convert into a long value CCYYMMDD */
|
||||
time_struct = localtime (&time_secs);
|
||||
if (time_struct)
|
||||
{
|
||||
time_struct->tm_year += 1900;
|
||||
return (MAKE_DATE (time_struct->tm_year / 100,
|
||||
time_struct->tm_year % 100,
|
||||
time_struct->tm_mon + 1, time_struct->tm_mday));
|
||||
}
|
||||
else
|
||||
{
|
||||
return (19700101);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -167,24 +174,29 @@ static long timer_to_date(time_t time_secs)
|
|||
(GMT).
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
static long timer_to_time(time_t time_secs)
|
||||
static long
|
||||
timer_to_time (time_t time_secs)
|
||||
{
|
||||
struct tm *time_struct;
|
||||
struct tm *time_struct;
|
||||
|
||||
if (time_secs == 0) {
|
||||
return 0;
|
||||
} else {
|
||||
/* Convert into a long value HHMMSS00 */
|
||||
time_struct = localtime (&time_secs);
|
||||
if (time_struct) {
|
||||
return (MAKE_TIME (time_struct-> tm_hour,
|
||||
time_struct-> tm_min,
|
||||
time_struct-> tm_sec,
|
||||
0));
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
if (time_secs == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Convert into a long value HHMMSS00 */
|
||||
time_struct = localtime (&time_secs);
|
||||
if (time_struct)
|
||||
{
|
||||
return (MAKE_TIME (time_struct->tm_hour,
|
||||
time_struct->tm_min, time_struct->tm_sec, 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -201,17 +213,16 @@ static long timer_to_time(time_t time_secs)
|
|||
in the function, so no need to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_date_iso8601(void)
|
||||
char *
|
||||
qfits_get_date_iso8601 (void)
|
||||
{
|
||||
static char date_iso8601[20] ;
|
||||
long curdate ;
|
||||
static char date_iso8601[20];
|
||||
long curdate;
|
||||
|
||||
curdate = qfits_date_now() ;
|
||||
sprintf(date_iso8601, "%04d-%02d-%02d",
|
||||
GET_CCYEAR(curdate),
|
||||
GET_MONTH(curdate),
|
||||
GET_DAY(curdate));
|
||||
return date_iso8601 ;
|
||||
curdate = qfits_date_now ();
|
||||
sprintf (date_iso8601, "%04d-%02d-%02d",
|
||||
GET_CCYEAR (curdate), GET_MONTH (curdate), GET_DAY (curdate));
|
||||
return date_iso8601;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -224,38 +235,37 @@ char * qfits_get_date_iso8601(void)
|
|||
statically allocated string in the function, so no need to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_datetime_iso8601(void)
|
||||
char *
|
||||
qfits_get_datetime_iso8601 (void)
|
||||
{
|
||||
static char date_iso8601[20] ;
|
||||
long curdate ;
|
||||
long curtime ;
|
||||
static char date_iso8601[20];
|
||||
long curdate;
|
||||
long curtime;
|
||||
|
||||
curdate = qfits_date_now() ;
|
||||
curtime = qfits_time_now() ;
|
||||
curdate = qfits_date_now ();
|
||||
curtime = qfits_time_now ();
|
||||
|
||||
sprintf(date_iso8601, "%04d-%02d-%02dT%02d:%02d:%02d",
|
||||
GET_CCYEAR(curdate),
|
||||
GET_MONTH(curdate),
|
||||
GET_DAY(curdate),
|
||||
GET_HOUR(curtime),
|
||||
GET_MINUTE(curtime),
|
||||
GET_SECOND(curtime));
|
||||
return date_iso8601 ;
|
||||
sprintf (date_iso8601, "%04d-%02d-%02dT%02d:%02d:%02d",
|
||||
GET_CCYEAR (curdate),
|
||||
GET_MONTH (curdate),
|
||||
GET_DAY (curdate),
|
||||
GET_HOUR (curtime), GET_MINUTE (curtime), GET_SECOND (curtime));
|
||||
return date_iso8601;
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
int main(int argc, char *argv[])
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
printf( "date now %ld\n"
|
||||
"time now %ld\n"
|
||||
"date iso8601 %s\n"
|
||||
"date/time iso 8601 %s\n",
|
||||
qfits_date_now(),
|
||||
qfits_time_now(),
|
||||
qfits_get_date_iso8601(),
|
||||
qfits_get_datetime_iso8601());
|
||||
printf ("date now %ld\n"
|
||||
"time now %ld\n"
|
||||
"date iso8601 %s\n"
|
||||
"date/time iso 8601 %s\n",
|
||||
qfits_date_now (),
|
||||
qfits_time_now (),
|
||||
qfits_get_date_iso8601 (), qfits_get_datetime_iso8601 ());
|
||||
|
||||
return 0 ;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
/* vim: set ts=4 et sw=4 tw=75 */
|
||||
|
|
|
@ -23,7 +23,8 @@
|
|||
#define T_ISO8601_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
|
||||
|
@ -46,7 +47,7 @@ extern "C" {
|
|||
Example: 19 Oct 2000 is returned as 20001019
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
long qfits_date_now (void);
|
||||
long qfits_date_now (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -58,7 +59,7 @@ long qfits_date_now (void);
|
|||
Example: 15:36:12.84 is returned as 15361284
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
long qfits_time_now(void);
|
||||
long qfits_time_now (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -70,7 +71,7 @@ long qfits_time_now(void);
|
|||
in the function, so no need to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_date_iso8601(void);
|
||||
char *qfits_get_date_iso8601 (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -82,7 +83,7 @@ char * qfits_get_date_iso8601(void);
|
|||
statically allocated string in the function, so no need to free it.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_get_datetime_iso8601(void);
|
||||
char *qfits_get_datetime_iso8601 (void);
|
||||
|
||||
/* </dox> */
|
||||
#ifdef __cplusplus
|
||||
|
|
3901
qfits/src/tfits.c
3901
qfits/src/tfits.c
File diff suppressed because it is too large
Load Diff
|
@ -19,7 +19,8 @@
|
|||
#define TFITS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
|
@ -55,25 +56,26 @@ extern "C" {
|
|||
@brief Column data type
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef enum _TFITS_DATA_TYPE_ {
|
||||
TFITS_ASCII_TYPE_A,
|
||||
TFITS_ASCII_TYPE_D,
|
||||
TFITS_ASCII_TYPE_E,
|
||||
TFITS_ASCII_TYPE_F,
|
||||
TFITS_ASCII_TYPE_I,
|
||||
TFITS_BIN_TYPE_A,
|
||||
TFITS_BIN_TYPE_B,
|
||||
TFITS_BIN_TYPE_C,
|
||||
TFITS_BIN_TYPE_D,
|
||||
TFITS_BIN_TYPE_E,
|
||||
TFITS_BIN_TYPE_I,
|
||||
TFITS_BIN_TYPE_J,
|
||||
TFITS_BIN_TYPE_L,
|
||||
TFITS_BIN_TYPE_M,
|
||||
TFITS_BIN_TYPE_P,
|
||||
TFITS_BIN_TYPE_X,
|
||||
TFITS_BIN_TYPE_UNKNOWN
|
||||
} tfits_type ;
|
||||
typedef enum _TFITS_DATA_TYPE_
|
||||
{
|
||||
TFITS_ASCII_TYPE_A,
|
||||
TFITS_ASCII_TYPE_D,
|
||||
TFITS_ASCII_TYPE_E,
|
||||
TFITS_ASCII_TYPE_F,
|
||||
TFITS_ASCII_TYPE_I,
|
||||
TFITS_BIN_TYPE_A,
|
||||
TFITS_BIN_TYPE_B,
|
||||
TFITS_BIN_TYPE_C,
|
||||
TFITS_BIN_TYPE_D,
|
||||
TFITS_BIN_TYPE_E,
|
||||
TFITS_BIN_TYPE_I,
|
||||
TFITS_BIN_TYPE_J,
|
||||
TFITS_BIN_TYPE_L,
|
||||
TFITS_BIN_TYPE_M,
|
||||
TFITS_BIN_TYPE_P,
|
||||
TFITS_BIN_TYPE_X,
|
||||
TFITS_BIN_TYPE_UNKNOWN
|
||||
} tfits_type;
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -87,8 +89,8 @@ typedef enum _TFITS_DATA_TYPE_ {
|
|||
generate a FITS table.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef struct qfits_col
|
||||
{
|
||||
typedef struct qfits_col
|
||||
{
|
||||
/**
|
||||
Number of atoms in one field.
|
||||
In ASCII tables, it is the number of characters in the field as defined
|
||||
|
@ -97,13 +99,13 @@ typedef struct qfits_col
|
|||
it is the number of characters. A field with two complex object will
|
||||
have atom_nb = 4.
|
||||
*/
|
||||
int atom_nb ;
|
||||
int atom_nb;
|
||||
|
||||
/**
|
||||
Number of decimals in a ASCII field.
|
||||
This value is always 0 for BIN tables
|
||||
*/
|
||||
int atom_dec_nb ;
|
||||
int atom_dec_nb;
|
||||
|
||||
/**
|
||||
Size of one element in bytes. In ASCII tables, atom_size is the size
|
||||
|
@ -124,26 +126,26 @@ typedef struct qfits_col
|
|||
conversion of the field is atom_size.
|
||||
In BIN tables, the size in bytes of a field is always atom_nb*atom_size.
|
||||
*/
|
||||
int atom_size ;
|
||||
int atom_size;
|
||||
|
||||
/**
|
||||
Type of data in the column as specified in TFORM keyword
|
||||
In ASCII tables : TFITS_ASCII_TYPE_* with *=A, I, F, E or D
|
||||
In BIN tables : TFITS_BIN_TYPE_* with *=L, X, B, I, J, A, E, D, C, M or P
|
||||
*/
|
||||
tfits_type atom_type ;
|
||||
tfits_type atom_type;
|
||||
|
||||
/** Label of the column */
|
||||
char tlabel[FITSVALSZ] ;
|
||||
char tlabel[FITSVALSZ];
|
||||
|
||||
/** Unit of the data */
|
||||
char tunit[FITSVALSZ] ;
|
||||
char tunit[FITSVALSZ];
|
||||
|
||||
/** Null value */
|
||||
char nullval[FITSVALSZ] ;
|
||||
char nullval[FITSVALSZ];
|
||||
|
||||
/** Display format */
|
||||
char tdisp[FITSVALSZ] ;
|
||||
char tdisp[FITSVALSZ];
|
||||
|
||||
/**
|
||||
zero and scale are used when the quantity in the field does not
|
||||
|
@ -151,17 +153,17 @@ typedef struct qfits_col
|
|||
when they are present: physical_value = zero + scale * field_value
|
||||
They are read from TZERO and TSCAL in the header
|
||||
*/
|
||||
int zero_present ;
|
||||
float zero ;
|
||||
int scale_present ;
|
||||
float scale ;
|
||||
int zero_present;
|
||||
float zero;
|
||||
int scale_present;
|
||||
float scale;
|
||||
|
||||
/** Offset between the beg. of the table and the beg. of the column. */
|
||||
int off_beg ;
|
||||
int off_beg;
|
||||
|
||||
/** Flag to know if the column is readable. An empty col is not readable */
|
||||
int readable ;
|
||||
} qfits_col ;
|
||||
int readable;
|
||||
} qfits_col;
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -195,26 +197,26 @@ typedef struct qfits_col
|
|||
@endcode
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
typedef struct qfits_table
|
||||
{
|
||||
typedef struct qfits_table
|
||||
{
|
||||
/**
|
||||
Name of the file the table comes from or it is intended to end to
|
||||
*/
|
||||
char filename[FILENAMESZ] ;
|
||||
char filename[FILENAMESZ];
|
||||
/**
|
||||
Table type.
|
||||
Possible values: QFITS_INVALIDTABLE, QFITS_BINTABLE, QFITS_ASCIITABLE
|
||||
*/
|
||||
int tab_t ;
|
||||
int tab_t;
|
||||
/** Width in bytes of the table */
|
||||
int tab_w ;
|
||||
int tab_w;
|
||||
/** Number of columns */
|
||||
int nc ;
|
||||
int nc;
|
||||
/** Number of raws */
|
||||
int nr ;
|
||||
int nr;
|
||||
/** Array of qfits_col objects */
|
||||
qfits_col * col ;
|
||||
} qfits_table ;
|
||||
qfits_col *col;
|
||||
} qfits_table;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Function prototypes
|
||||
|
@ -231,7 +233,7 @@ typedef struct qfits_table
|
|||
FITS table.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_is_table(char * filename, int xtnum) ;
|
||||
int qfits_is_table (char *filename, int xtnum);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -239,7 +241,7 @@ int qfits_is_table(char * filename, int xtnum) ;
|
|||
@return the header object
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_table_prim_header_default(void) ;
|
||||
qfits_header *qfits_table_prim_header_default (void);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -247,7 +249,7 @@ qfits_header * qfits_table_prim_header_default(void) ;
|
|||
@return the header object
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_header * qfits_table_ext_header_default(qfits_table *) ;
|
||||
qfits_header *qfits_table_ext_header_default (qfits_table *);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -262,12 +264,9 @@ qfits_header * qfits_table_ext_header_default(qfits_table *) ;
|
|||
qfits_table_close()
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_table * qfits_table_new(
|
||||
char * filename,
|
||||
int table_type,
|
||||
int table_width,
|
||||
int nb_cols,
|
||||
int nb_raws) ;
|
||||
qfits_table *qfits_table_new (char *filename,
|
||||
int table_type,
|
||||
int table_width, int nb_cols, int nb_raws);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -293,21 +292,18 @@ qfits_table * qfits_table_new(
|
|||
@return -1 in error case, 0 otherwise
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_col_fill(
|
||||
qfits_col * qc,
|
||||
int atom_nb,
|
||||
int atom_dec_nb,
|
||||
int atom_size,
|
||||
tfits_type atom_type,
|
||||
char * label,
|
||||
char * unit,
|
||||
char * nullval,
|
||||
char * disp,
|
||||
int zero_present,
|
||||
float zero,
|
||||
int scale_present,
|
||||
float scale,
|
||||
int offset_beg) ;
|
||||
int qfits_col_fill (qfits_col * qc,
|
||||
int atom_nb,
|
||||
int atom_dec_nb,
|
||||
int atom_size,
|
||||
tfits_type atom_type,
|
||||
char *label,
|
||||
char *unit,
|
||||
char *nullval,
|
||||
char *disp,
|
||||
int zero_present,
|
||||
float zero,
|
||||
int scale_present, float scale, int offset_beg);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -320,9 +316,7 @@ int qfits_col_fill(
|
|||
newly allocated qfits_table structure.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
qfits_table * qfits_table_open(
|
||||
char * filename,
|
||||
int xtnum) ;
|
||||
qfits_table *qfits_table_open (char *filename, int xtnum);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -332,7 +326,7 @@ qfits_table * qfits_table_open(
|
|||
Frees all memory associated to a qfits_table structure.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void qfits_table_close(qfits_table * t) ;
|
||||
void qfits_table_close (qfits_table * t);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -363,10 +357,8 @@ void qfits_table_close(qfits_table * t) ;
|
|||
the pixel loader here.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
unsigned char * qfits_query_column(
|
||||
qfits_table * th,
|
||||
int colnum,
|
||||
int * selection) ;
|
||||
unsigned char *qfits_query_column (qfits_table * th,
|
||||
int colnum, int *selection);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -380,11 +372,9 @@ unsigned char * qfits_query_column(
|
|||
Spares the overhead of the selection object allocation
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
unsigned char * qfits_query_column_seq(
|
||||
qfits_table * th,
|
||||
int colnum,
|
||||
int start_ind,
|
||||
int nb_rows) ;
|
||||
unsigned char *qfits_query_column_seq (qfits_table * th,
|
||||
int colnum,
|
||||
int start_ind, int nb_rows);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -393,7 +383,7 @@ unsigned char * qfits_query_column_seq(
|
|||
@return the width (-1 in error case)
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_compute_table_width(qfits_table * th) ;
|
||||
int qfits_compute_table_width (qfits_table * th);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -420,11 +410,9 @@ int qfits_compute_table_width(qfits_table * th) ;
|
|||
the pixel loader here.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void * qfits_query_column_data(
|
||||
qfits_table * th,
|
||||
int colnum,
|
||||
int * selection,
|
||||
void * null_value) ;
|
||||
void *qfits_query_column_data (qfits_table * th,
|
||||
int colnum,
|
||||
int *selection, void *null_value);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -439,12 +427,10 @@ void * qfits_query_column_data(
|
|||
of rows. Spares the overhead of the selection object allocation
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
void * qfits_query_column_seq_data(
|
||||
qfits_table * th,
|
||||
int colnum,
|
||||
int start_ind,
|
||||
int nb_rows,
|
||||
void * null_value) ;
|
||||
void *qfits_query_column_seq_data (qfits_table * th,
|
||||
int colnum,
|
||||
int start_ind,
|
||||
int nb_rows, void *null_value);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -457,12 +443,9 @@ void * qfits_query_column_seq_data(
|
|||
@return array with 1 for NULLs and 0 for non-NULLs
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int * qfits_query_column_nulls(
|
||||
qfits_table * th,
|
||||
int colnum,
|
||||
int * selection,
|
||||
int * nb_vals,
|
||||
int * nb_nulls) ;
|
||||
int *qfits_query_column_nulls (qfits_table * th,
|
||||
int colnum,
|
||||
int *selection, int *nb_vals, int *nb_nulls);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -473,10 +456,8 @@ int * qfits_query_column_nulls(
|
|||
@return -1 in error case, 0 otherwise
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_save_table_hdrdump(
|
||||
void ** array,
|
||||
qfits_table * table,
|
||||
qfits_header * fh) ;
|
||||
int qfits_save_table_hdrdump (void **array,
|
||||
qfits_table * table, qfits_header * fh);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -494,10 +475,8 @@ int qfits_save_table_hdrdump(
|
|||
Notice that no main header is produced, only the extension part.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_table_append_xtension(
|
||||
FILE * outfile,
|
||||
qfits_table * t,
|
||||
void ** data) ;
|
||||
int qfits_table_append_xtension (FILE * outfile,
|
||||
qfits_table * t, void **data);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -515,11 +494,9 @@ int qfits_table_append_xtension(
|
|||
Notice that no main header is produced, only the extension part.
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
int qfits_table_append_xtension_hdr(
|
||||
FILE * outfile,
|
||||
qfits_table * t,
|
||||
void ** data,
|
||||
qfits_header * hdr) ;
|
||||
int qfits_table_append_xtension_hdr (FILE * outfile,
|
||||
qfits_table * t,
|
||||
void **data, qfits_header * hdr);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
@ -531,11 +508,9 @@ int qfits_table_append_xtension_hdr(
|
|||
@return the string to write
|
||||
*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
char * qfits_table_field_to_string(
|
||||
qfits_table * table,
|
||||
int col_id,
|
||||
int row_id,
|
||||
int use_zero_scale) ;
|
||||
char *qfits_table_field_to_string (qfits_table * table,
|
||||
int col_id,
|
||||
int row_id, int use_zero_scale);
|
||||
|
||||
/* </dox> */
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
|
||||
/* Library version */
|
||||
static const char *
|
||||
_qfits_version = "5.4.0" ;
|
||||
static const char *_qfits_version = "5.4.0";
|
||||
|
||||
const char * qfits_version(void)
|
||||
const char *
|
||||
qfits_version (void)
|
||||
{
|
||||
return _qfits_version ;
|
||||
return _qfits_version;
|
||||
}
|
||||
|
|
1772
qfits/src/xmemory.c
1772
qfits/src/xmemory.c
File diff suppressed because it is too large
Load Diff
1688
qfits/sysconf.c
1688
qfits/sysconf.c
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue