int ngp_extract_tokens(NGP_RAW_LINE *cl)
{ char *p, *s;
int cl_flags, i;
p = cl->line; /* start from beginning of line */
if (NULL == p) return(NGP_NUL_PTR);
cl->name = cl->value = cl->comment = NULL;
cl->type = NGP_TTYPE_UNKNOWN;
cl->format = NGP_FORMAT_OK;
cl_flags = 0;
for (i=0;; i++) /* if 8 spaces at beginning then line is comment */
{ if ((0 == *p) || ('\n' == *p))
{ /* if line has only blanks -> write blank keyword */
cl->line[0] = 0; /* create empty name (0 length string) */
cl->comment = cl->name = cl->line;
cl->type = NGP_TTYPE_RAW; /* signal write unformatted to FITS file */
return(NGP_OK);
}
if ((' ' != *p) && ('\t' != *p)) break;
if (i >= 7)
{
cl->comment = p + 1;
for (s = cl->comment;; s++) /* filter out any EOS characters in comment */
{ if ('\n' == *s) *s = 0;
if (0 == *s) break;
}
cl->line[0] = 0; /* create empty name (0 length string) */
cl->name = cl->line;
cl->type = NGP_TTYPE_RAW;
return(NGP_OK);
}
p++;
}
cl->name = p;
for (;;) /* we need to find 1st whitespace */
{ if ((0 == *p) || ('\n' == *p))
{ *p = 0;
break;
}
/*
from Richard Mathar, 2002-05-03, add 10 lines:
if upper/lowercase HIERARCH followed also by an equal sign...
*/
if( strncasecmp("HIERARCH",p,strlen("HIERARCH")) == 0 )
{
char * const eqsi=strchr(p,'=') ;
if( eqsi )
{
cl_flags |= NGP_FOUND_EQUAL_SIGN ;
p=eqsi ;
break ;
}
}
if ((' ' == *p) || ('\t' == *p)) break;
if ('=' == *p)
{ cl_flags |= NGP_FOUND_EQUAL_SIGN;
break;
}
p++;
}
if (*p) *(p++) = 0; /* found end of keyname so terminate string with zero */
if ((!ngp_strcasecmp("HISTORY", cl->name))
|| (!ngp_strcasecmp("COMMENT", cl->name))
|| (!ngp_strcasecmp("CONTINUE", cl->name)))
{ cl->comment = p;
for (s = cl->comment;; s++) /* filter out any EOS characters in comment */
{ if ('\n' == *s) *s = 0;
if (0 == *s) break;
}
cl->type = NGP_TTYPE_RAW;
return(NGP_OK);
}
if (!ngp_strcasecmp("\\INCLUDE", cl->name))
{
for (;; p++) if ((' ' != *p) && ('\t' != *p)) break; /* skip whitespace */
cl->value = p;
for (s = cl->value;; s++) /* filter out any EOS characters */
{ if ('\n' == *s) *s = 0;
if (0 == *s) break;
}
cl->type = NGP_TTYPE_UNKNOWN;
return(NGP_OK);
}
for (;; p++)
{ if ((0 == *p) || ('\n' == *p)) return(NGP_OK); /* test if at end of string */
if ((' ' == *p) || ('\t' == *p)) continue; /* skip whitespace */
if (cl_flags & NGP_FOUND_EQUAL_SIGN) break;
if ('=' != *p) break; /* ignore initial equal sign */
cl_flags |= NGP_FOUND_EQUAL_SIGN;
}
if ('/' == *p) /* no value specified, comment only */
{ p++;
if ((' ' == *p) || ('\t' == *p)) p++;
cl->comment = p;
for (s = cl->comment;; s++) /* filter out any EOS characters in comment */
{ if ('\n' == *s) *s = 0;
if (0 == *s) break;
}
return(NGP_OK);
}
if ('\'' == *p) /* we have found string within quotes */
{ cl->value = s = ++p; /* set pointer to beginning of that string */
cl->type = NGP_TTYPE_STRING; /* signal that it is of string type */
for (;;) /* analyze it */
{ if ((0 == *p) || ('\n' == *p)) /* end of line -> end of string */
{ *s = 0; return(NGP_OK); }
if ('\'' == *p) /* we have found doublequote */
{ if ((0 == p[1]) || ('\n' == p[1]))/* doublequote is the last character in line */
{ *s = 0; return(NGP_OK); }
if (('\t' == p[1]) || (' ' == p[1])) /* duoblequote was string terminator */
{ *s = 0; p++; break; }
if ('\'' == p[1]) p++; /* doublequote is inside string, convert "" -> " */
}
*(s++) = *(p++); /* compact string in place, necess. by "" -> " conversion */
}
}
else /* regular token */
{
cl->value = p; /* set pointer to token */
cl->type = NGP_TTYPE_UNKNOWN; /* we dont know type at the moment */
for (;; p++) /* we need to find 1st whitespace */
{ if ((0 == *p) || ('\n' == *p))
{ *p = 0; return(NGP_OK); }
if ((' ' == *p) || ('\t' == *p)) break;
}
if (*p) *(p++) = 0; /* found so terminate string with zero */
}
for (;; p++)
{ if ((0 == *p) || ('\n' == *p)) return(NGP_OK); /* test if at end of string */
if ((' ' != *p) && ('\t' != *p)) break; /* skip whitespace */
}
if ('/' == *p) /* no value specified, comment only */
{ p++;
if ((' ' == *p) || ('\t' == *p)) p++;
cl->comment = p;
for (s = cl->comment;; s++) /* filter out any EOS characters in comment */
{ if ('\n' == *s) *s = 0;
if (0 == *s) break;
}
return(NGP_OK);
}
cl->format = NGP_FORMAT_ERROR;
return(NGP_OK); /* too many tokens ... */
}
int ngp_read_line(int ignore_blank_lines)
{ int r, nc;
unsigned k;
if (ngp_inclevel <= 0) /* do some sanity checking first */
{ ngp_keyidx = NGP_TOKEN_EOF; /* no parents, so report error */
return(NGP_OK);
}
if (ngp_inclevel > NGP_MAX_INCLUDE) return(NGP_INC_NESTING);
if (NULL == ngp_fp[ngp_inclevel - 1]) return(NGP_NUL_PTR);
for (;;)
{ switch (r = ngp_read_line_buffered(ngp_fp[ngp_inclevel - 1]))
{ case NGP_EOF:
ngp_inclevel--; /* end of file, revert to parent */
if (ngp_fp[ngp_inclevel]) /* we can close old file */
fclose(ngp_fp[ngp_inclevel]);
ngp_fp[ngp_inclevel] = NULL;
if (ngp_inclevel <= 0)
{ ngp_keyidx = NGP_TOKEN_EOF; /* no parents, so report error */
return(NGP_OK);
}
continue;
case NGP_OK:
if (ngp_curline.flags & NGP_LINE_REREAD) return(r);
break;
default:
return(r);
}
switch (ngp_curline.line[0])
{ case 0: if (0 == ignore_blank_lines) break; /* ignore empty lines if told so */
case '#': continue; /* ignore comment lines */
}
r = ngp_extract_tokens(&ngp_curline); /* analyse line, extract tokens and comment */
if (NGP_OK != r) return(r);
if (NULL == ngp_curline.name) continue; /* skip lines consisting only of whitespaces */
for (k = 0; k < strlen(ngp_curline.name); k++)
{ if ((ngp_curline.name[k] >= 'a') && (ngp_curline.name[k] <= 'z'))
ngp_curline.name[k] += 'A' - 'a'; /* force keyword to be upper case */
if (k == 7) break; /* only first 8 chars are required to be upper case */
}
for (k=0;; k++) /* find index of keyword in keyword table */
{ if (NGP_TOKEN_UNKNOWN == ngp_tkdef[k].code) break;
if (0 == strcmp(ngp_curline.name, ngp_tkdef[k].name)) break;
}
ngp_keyidx = ngp_tkdef[k].code; /* save this index, grammar parser will need this */
if (NGP_TOKEN_INCLUDE == ngp_keyidx) /* if this is \INCLUDE keyword, try to include file */
{ if (NGP_OK != (r = ngp_include_file(ngp_curline.value))) return(r);
continue; /* and read next line */
}
ngp_linkey.type = NGP_TTYPE_UNKNOWN; /* now, get the keyword type, it's a long story ... */
if (NULL != ngp_curline.value) /* if no value given signal it */
{ if (NGP_TTYPE_STRING == ngp_curline.type) /* string type test */
{ ngp_linkey.type = NGP_TTYPE_STRING;
ngp_linkey.value.s = ngp_curline.value;
}
if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* bool type test */
{ if ((!ngp_strcasecmp("T", ngp_curline.value)) || (!ngp_strcasecmp("F", ngp_curline.value)))
{ ngp_linkey.type = NGP_TTYPE_BOOL;
ngp_linkey.value.b = (ngp_strcasecmp("T", ngp_curline.value) ? 0 : 1);
}
}
if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* complex type test */
{ if (2 == sscanf(ngp_curline.value, "(%lg,%lg)%n", &(ngp_linkey.value.c.re), &(ngp_linkey.value.c.im), &nc))
{ if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
|| ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
{ ngp_linkey.type = NGP_TTYPE_COMPLEX;
}
}
}
if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* real type test */
{ if (strchr(ngp_curline.value, '.') && (1 == sscanf(ngp_curline.value, "%lg%n", &(ngp_linkey.value.d), &nc)))
{ if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
|| ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
{ ngp_linkey.type = NGP_TTYPE_REAL;
}
}
}
if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* integer type test */
{ if (1 == sscanf(ngp_curline.value, "%d%n", &(ngp_linkey.value.i), &nc))
{ if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
|| ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
{ ngp_linkey.type = NGP_TTYPE_INT;
}
}
}
if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* force string type */
{ ngp_linkey.type = NGP_TTYPE_STRING;
ngp_linkey.value.s = ngp_curline.value;
}
}
else
{ if (NGP_TTYPE_RAW == ngp_curline.type) ngp_linkey.type = NGP_TTYPE_RAW;
else ngp_linkey.type = NGP_TTYPE_NULL;
}
if (NULL != ngp_curline.comment)
{ strncpy(ngp_linkey.comment, ngp_curline.comment, NGP_MAX_COMMENT); /* store comment */
ngp_linkey.comment[NGP_MAX_COMMENT - 1] = 0;
}
else
{ ngp_linkey.comment[0] = 0;
}
strncpy(ngp_linkey.name, ngp_curline.name, NGP_MAX_NAME); /* and keyword's name */
ngp_linkey.name[NGP_MAX_NAME - 1] = 0;
if (strlen(ngp_linkey.name) > FLEN_KEYWORD) /* WDP: 20-Jun-2002: mod to support HIERARCH */
{
return(NGP_BAD_ARG); /* cfitsio does not allow names > 8 chars */
}
return(NGP_OK); /* we have valid non empty line, so return success */
}
}
int ngp_read_xtension(fitsfile *ff, int parent_hn, int simple_mode)
{ int r, exflg, l, my_hn, tmp0, incrementor_index, i, j;
int ngph_dim, ngph_bitpix, ngph_node_type, my_version;
char incrementor_name[NGP_MAX_STRING], ngph_ctmp;
char *ngph_extname = 0;
long ngph_size[NGP_MAX_ARRAY_DIM];
NGP_HDU ngph;
long lv;
incrementor_name[0] = 0; /* signal no keyword+'#' found yet */
incrementor_index = 0;
if (NGP_OK != (r = ngp_hdu_init(&ngph))) return(r);
if (NGP_OK != (r = ngp_read_line(0))) return(r); /* EOF always means error here */
switch (NGP_XTENSION_SIMPLE & simple_mode)
{
case 0: if (NGP_TOKEN_XTENSION != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
break;
default: if (NGP_TOKEN_SIMPLE != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
break;
}
if (NGP_OK != (r = ngp_hdu_insert_token(&ngph, &ngp_linkey))) return(r);
for (;;)
{ if (NGP_OK != (r = ngp_read_line(0))) return(r); /* EOF always means error here */
exflg = 0;
switch (ngp_keyidx)
{
case NGP_TOKEN_SIMPLE:
r = NGP_TOKEN_NOT_EXPECT;
break;
case NGP_TOKEN_END:
case NGP_TOKEN_XTENSION:
case NGP_TOKEN_GROUP:
r = ngp_unread_line(); /* WARNING - not break here .... */
case NGP_TOKEN_EOF:
exflg = 1;
break;
default: l = strlen(ngp_linkey.name);
if ((l >= 2) && (l <= 6))
{ if ('#' == ngp_linkey.name[l - 1])
{ if (0 == incrementor_name[0])
{ memcpy(incrementor_name, ngp_linkey.name, l - 1);
incrementor_name[l - 1] = 0;
}
if (((l - 1) == (int)strlen(incrementor_name)) && (0 == memcmp(incrementor_name, ngp_linkey.name, l - 1)))
{ incrementor_index++;
}
sprintf(ngp_linkey.name + l - 1, "%d", incrementor_index);
}
}
r = ngp_hdu_insert_token(&ngph, &ngp_linkey);
break;
}
if ((NGP_OK != r) || exflg) break;
}
if (NGP_OK == r)
{ /* we should scan keywords, and calculate HDU's */
/* structure ourselves .... */
ngph_node_type = NGP_NODE_INVALID; /* init variables */
ngph_bitpix = 0;
ngph_extname = NULL;
for (i=0; i<NGP_MAX_ARRAY_DIM; i++) ngph_size[i] = 0;
ngph_dim = 0;
for (i=0; i<ngph.tokcnt; i++)
{ if (!strcmp("XTENSION", ngph.tok[i].name))
{ if (NGP_TTYPE_STRING == ngph.tok[i].type)
{ if (!ngp_strcasecmp("BINTABLE", ngph.tok[i].value.s)) ngph_node_type = NGP_NODE_BTABLE;
if (!ngp_strcasecmp("ASCIITABLE", ngph.tok[i].value.s)) ngph_node_type = NGP_NODE_ATABLE;
if (!ngp_strcasecmp("IMAGE", ngph.tok[i].value.s)) ngph_node_type = NGP_NODE_IMAGE;
}
}
else if (!strcmp("SIMPLE", ngph.tok[i].name))
{ if (NGP_TTYPE_BOOL == ngph.tok[i].type)
{ if (ngph.tok[i].value.b) ngph_node_type = NGP_NODE_IMAGE;
}
}
else if (!strcmp("BITPIX", ngph.tok[i].name))
{ if (NGP_TTYPE_INT == ngph.tok[i].type) ngph_bitpix = ngph.tok[i].value.i;
}
else if (!strcmp("NAXIS", ngph.tok[i].name))
{ if (NGP_TTYPE_INT == ngph.tok[i].type) ngph_dim = ngph.tok[i].value.i;
}
else if (!strcmp("EXTNAME", ngph.tok[i].name)) /* assign EXTNAME, I hope struct does not move */
{ if (NGP_TTYPE_STRING == ngph.tok[i].type) ngph_extname = ngph.tok[i].value.s;
}
else if (1 == sscanf(ngph.tok[i].name, "NAXIS%d%c", &j, &ngph_ctmp))
{ if (NGP_TTYPE_INT == ngph.tok[i].type)
if ((j>=1) && (j <= NGP_MAX_ARRAY_DIM))
{ ngph_size[j - 1] = ngph.tok[i].value.i;
}
}
}
switch (ngph_node_type)
{ case NGP_NODE_IMAGE:
if (NGP_XTENSION_FIRST == ((NGP_XTENSION_FIRST | NGP_XTENSION_SIMPLE) & simple_mode))
{ /* if caller signals that this is 1st HDU in file */
/* and it is IMAGE defined with XTENSION, then we */
/* need create dummy Primary HDU */
fits_create_img(ff, 16, 0, NULL, &r);
}
/* create image */
fits_create_img(ff, ngph_bitpix, ngph_dim, ngph_size, &r);
/* update keywords */
if (NGP_OK == r) r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
break;
case NGP_NODE_ATABLE:
case NGP_NODE_BTABLE:
/* create table, 0 rows and 0 columns for the moment */
fits_create_tbl(ff, ((NGP_NODE_ATABLE == ngph_node_type)
? ASCII_TBL : BINARY_TBL),
0, 0, NULL, NULL, NULL, NULL, &r);
if (NGP_OK != r) break;
/* add columns ... */
r = ngp_append_columns(ff, &ngph, 0);
if (NGP_OK != r) break;
/* add remaining keywords */
r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
if (NGP_OK != r) break;
/* if requested add rows */
if (ngph_size[1] > 0) fits_insert_rows(ff, 0, ngph_size[1], &r);
break;
default: r = NGP_BAD_ARG;
break;
}
}
if ((NGP_OK == r) && (NULL != ngph_extname))
{ r = ngp_get_extver(ngph_extname, &my_version); /* write correct ext version number */
lv = my_version; /* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
fits_write_key(ff, TLONG, "EXTVER", &lv, "auto assigned by template parser", &r);
}
if (NGP_OK == r)
{ if (parent_hn > 0)
{ fits_get_hdu_num(ff, &my_hn);
fits_movabs_hdu(ff, parent_hn, &tmp0, &r); /* link us to parent */
fits_add_group_member(ff, NULL, my_hn, &r);
fits_movabs_hdu(ff, my_hn, &tmp0, &r);
if (NGP_OK != r) return(r);
}
}
if (NGP_OK != r) /* in case of error - delete hdu */
{ tmp0 = 0;
fits_delete_hdu(ff, NULL, &tmp0);
}
ngp_hdu_clear(&ngph);
return(r);
}
