Debian Codegraph @

cextern/cfitsio/utilities/fvrf_key.c

raw
1 #include "fverify.h"
2
3 int fits_parse_card(FILE *out, /* output file pointer */
4 int kpos, /* keyposition starting from 1 */
5 char *card, /* key card */
6 char *kname, /* key name */
7 kwdtyp *ktype, /* key type */
8 char *kvalue, /* key value */
9 char *kcomm /* comment */
10 )
11 /* Ref: Defininition of the Flexible Image Transport System(FITS),
12 Sec. 5.1 and 5.2.
13 */
14 {
15 char vind[3];
16 char *p;
17 char **pt;
18 int i;
19 char temp1[FLEN_CARD];
20 unsigned long stat = 0;
21
22 *kname = '\0';
23 *kvalue = '\0';
24 *kcomm = '\0';
25 *ktype = UNKNOWN;
26
27 if(strlen(card) > FLEN_CARD-1 ) {
28 strncpy(temp1,card,20);
29 temp1[21]='\0';
30 sprintf(errmes,"card %s is > 80.",card);
31 wrterr(out,errmes,1);
32 return 1;
33 }
34 card[FLEN_CARD-1] = '\0';
35
36 /* get the kname */
37 strncpy(kname, card, 8);
38 kname[8] = '\0';
39
40 /* take out the trailing space */
41 i = 7;
42 p = &kname[7];
43 while(i >= 0 && isspace((int)*p)) {*p = '\0'; p--; i--;}
44
45 /* Whether the keyword name is left justified */
46 i = 0;
47 p = &kname[0];
48 while(isspace((int)*p) && *p != '\0' ) { p++; i++;}
49 if( i < 8 && i > 0) {
50 sprintf(errmes,"Keyword #%d: Name %s is not left justified.",
51 kpos,kname);
52 wrterr(out,errmes,1);
53 }
54 /* Whether the characters in keyword name are valid */
55 while(*p != '\0' ){
56 if((*p < 'A' || *p > 'Z')&&
57 (*p < '0' || *p > '9')&&
58 (*p != '-' && *p != '_') ) {
59 sprintf(errmes,
60 "Keyword #%d: Name \"%s\" contains char \"%c\" which is not upper case letter, digit, \"-\", or \"_\".",kpos,kname,*p);
61 wrterr(out,errmes,1);
62 break;
63 }
64 p++; i++;
65 }
66
67 /* COMMENT, HISTORY, HIERARCH and "" keywords */
68 if( !strcmp(kname,"COMMENT") ||
69 !strcmp(kname,"HISTORY") ||
70 !strcmp(kname,"HIERARCH") ||
71 !strcmp(kname,"CONTINUE") ||
72 !strcmp(kname,"") ){
73
74 *ktype = COM_KEY;
75
76 p = &card[8];
77 strcpy(kcomm, p);
78 kcomm[FLEN_COMMENT-1] = '\0';
79 for( ; *p != '\0'; p++) {
80 if(!isprint((int)*p)) {
81 sprintf(errmes,
82 "Keyword #%d, %s: String contains non-text characters.",
83 kpos,kname);
84 wrterr(out,errmes,1);
85 return 1;
86 }
87 }
88 p = kname;
89 while(!isspace((int)*p)&& *p != '\0')p++;
90 *p = '\0';
91 return 0;
92 }
93
94 /* End Keyword: 9-80 shall be filled with ASCII blanks \x20 */
95 if( !strcmp(kname,"END") ){
96 *ktype = COM_KEY;
97 if(card[3] == '\0') return 0;
98 for( p = &card[8]; *p != '\0'; p++) {
99 if(*p != '\x20' ){
100 wrterr(out,"END keyword contains non-blank characters.",1);
101 return 1;
102 }
103 }
104 kname[3] = '\0';
105 return 0;
106 }
107
108
109 /* check for value indicator */
110 p = &card[8];
111 strncpy(vind,p,2);
112 vind[2] = '\0';
113 if(strcmp(vind,"= ") && strcmp(vind,"=") ){
114 /* no value indicator, so this is a commentary keyword */
115 *ktype = COM_KEY;
116 strcpy(kcomm, p);
117 kcomm[FLEN_COMMENT-1] = '\0';
118 for( ; *p != '\0'; p++) {
119 if(!isprint((int)*p)) {
120 sprintf(errmes,
121 "Keyword #%d, %s: String contains non-text characters.",
122 kpos,kname);
123 wrterr(out,errmes,1);
124 return 1;
125 }
126 }
127 p = kname;
128 while(!isspace((int)*p)&& *p != '\0')p++;
129 *p = '\0';
130 return 0;
131 }
132
133 p = &card[10];
134 while (isspace((int)*p) && *p != '\0') p++;
135 pt = &p;
136 switch (*p) {
137 case '\'': /* string */
138 get_str(pt, kvalue,&stat);
139 *ktype = STR_KEY;
140 p = *pt;
141 if(*p != '\0') get_comm(pt,kcomm,&stat);
142 break;
143 case 'T': case 'F': /*logical */
144 get_log(pt, kvalue, &stat);
145 *ktype = LOG_KEY;
146 p = *pt;
147 if(*p != '\0') get_comm(pt,kcomm,&stat);
148 break;
149 case '+': case '-': case '.': /* number */
150 case '0': case '1': case '2':
151 case '3': case '4': case '5':
152 case '6': case '7': case '8':
153 case '9':
154 get_num(pt, kvalue, ktype, &stat);
155 p = *pt;
156 if(*p != '\0') get_comm(pt,kcomm,&stat);
157 break;
158 case '(': /* complex number */
159 get_cmp(pt, kvalue, ktype, &stat);
160 p = *pt;
161 if(*p != '\0') get_comm(pt,kcomm,&stat);
162 break;
163 case '/': /* comment */
164 if(*p != '\0') get_comm(pt,kcomm,&stat);
165 *ktype = UNKNOWN;
166 break;
167 default:
168 get_unknown(pt,kvalue,ktype,&stat);
169 p = *pt;
170 if(*p != '\0') get_comm(pt,kcomm,&stat);
171 }
172 /* take out the trailing blanks for non-string keys */
173 if(*ktype != STR_KEY) {
174 i = strlen(kvalue);
175 p = &kvalue[i-1];
176 while(isspace((int)*p) && i >0) {
177 *p = '\0';
178 p--; i--;
179 }
180 if(i == 0 && isspace((int)*p))*p = '\0';
181 }
182 pr_kval_err(out,kpos,kname,kvalue,stat);
183 if(stat != 0) return 1;
184 return 0;
185 }
186
187 /* parse And test the string keys */
188 void get_str(char **pt, /* card string from character 11*/
189 char *kvalue, /* key value string */
190 unsigned long *stat /* error number */
191 )
192 {
193 char *pi;
194 char prev; /* previous char */
195 int nchar = 0;
196 char *p;
197
198 p = *pt;
199 pi = p;
200 p++;
201 prev = 'a';
202 while(*p != '\0') {
203 if( !isprint((int)*p) )*stat |= BAD_STR;
204 if(prev == '\'' && *p != '\'') break;
205 if(prev == '\'' && *p == '\'') { /* skip the '' */
206 p++;
207 prev = 'a';
208 }
209 else {
210 prev = *p;
211 p++;
212 }
213 }
214 p--;
215 if(*p != '\'') *stat |= NO_TRAIL_QUOTE;
216 pi++;
217 nchar = p - pi ; /* excluding the ' */
218 if (nchar < 0) nchar = 0;
219 strncpy(kvalue,pi,(size_t)nchar);
220 *(kvalue+nchar) = '\0';
221 pi = kvalue + (nchar -1) ;
222 while(pi >= kvalue && isspace((int)*pi)){ *pi = '\0'; pi--;} /* delete the trailing space */
223 p++; /* skip the ' */
224 while(isspace((int)*p) && *p != '\0') p++;
225 *pt = p;
226 return;
227 }
228
229 /* parse and test the logical keys */
230 void get_log(char **pt, /* card string */
231 char *kvalue, /* key value string */
232 unsigned long *stat /* error number */
233 )
234 {
235 char *p;
236
237 p = *pt;
238 *kvalue = *p;
239 kvalue[1] = '\0';
240 p++;
241 while(isspace((int)*p)) p++;
242 if(*p != '/' && *p != '\0') *stat |= BAD_LOGICAL;
243 *pt = p;
244 return;
245 }
246
247 /* parse and test the numerical keys */
248 void get_num(char **pt, /* card string */
249 char *kvalue, /* comment string */
250 kwdtyp *ktype,
251 unsigned long *stat /* error number */
252 )
253 {
254 char *pi;
255 int set_deci = 0;
256 int set_expo = 0;
257 int nchar;
258 char *p;
259
260 p = *pt;
261 pi = p;
262 *ktype = INT_KEY;
263
264 if( *p != '+' && *p != '-' && !isdigit((int)*p) &&*p != '.') {
265 *stat |= BAD_NUM;
266 return;
267 }
268 if(*p == '.') {
269 *ktype = FLT_KEY;
270 set_deci = 1;
271 }
272
273 p++;
274 while(!isspace((int)*p) && *p != '\0' && *p != '/') {
275 if( *p == '.' && !set_deci ){
276 set_deci = 1;
277 *ktype = FLT_KEY;
278 p++;
279 continue;
280 }
281 if( (*p == 'd'|| *p == 'e') && !set_expo) {
282 set_expo = 1;
283 *ktype = FLT_KEY;
284 p++;
285 if(*p == '+' || *p == '-') p++;
286 *stat |= LOWCASE_EXPO;
287 continue;
288 }
289 if( (*p == 'D'|| *p == 'E') && !set_expo) {
290 set_expo = 1;
291 *ktype = FLT_KEY;
292 p++;
293 if(*p == '+' || *p == '-') p++;
294 continue;
295 }
296 if(!isdigit((int)*p)) *stat |= BAD_NUM;
297 p++;
298 }
299 nchar = p - pi;
300 strncpy(kvalue,pi,nchar);
301 *(kvalue+nchar) = '\0';
302 while(isspace((int)*p) && *p != '\0') p++;
303 *pt = p;
304 return;
305 }
306
307 /* parse and test the complex keys */
308 void get_cmp(char **pt, /* card string */
309 char *kvalue, /* comment string */
310 kwdtyp *ktype,
311 unsigned long *stat /* error number */
312 )
313 {
314 char *p;
315 char **pp;
316 char *pr_beg; /* end of real part */
317 char *pr_end=0; /* end of real part */
318 char *pi_beg; /* beginning of the imaginay part */
319 char *pi_end=0; /* end of real part */
320 int nchar;
321 int set_comm = 0;
322 int set_paren = 0;
323
324 unsigned long tr = 0;
325 unsigned long ti = 0;
326 kwdtyp rtype, itype;
327 char temp[FLEN_CARD];
328 char card[FLEN_CARD];
329
330
331 strcpy(card,*pt); /* save the original */
332 card[FLEN_CARD-1] = '\0';
333
334 *ktype = CMI_KEY; /* default: integer complex */
335 p = card + 1;
336 pr_beg = p;
337
338 temp[0] = '\0';
339 while(*p != '\0' && *p != '/') {
340 if(*p == ')') {
341 set_paren = 1;
342 pi_end = p;
343 p++;
344 break;
345 }
346 if(!set_comm && *p == ',') {
347 set_comm = 1;
348 pr_end = p;
349 pi_beg = p+1;
350 }
351 else if(*p == ',') {
352 *stat |= TOO_MANY_COMMA;
353 }
354 p++;
355 }
356 if(!set_comm) *stat |= NO_COMMA;
357 if(!set_paren) {
358 *stat |= NO_TRAIL_PAREN;
359 pi_end = p;
360 pi_end--;
361 while(isspace((int)*pi_end))pi_end--;
362 pi_end++;
363 }
364
365 nchar = pi_end - card ;
366 strncpy(kvalue,card,nchar);
367 *(kvalue+nchar) = '\0';
368 while(isspace((int)*p)&& *p != '\0') p++;
369 *pt = *pt + (p - card);
370
371 /* analyse the real and imagine part */
372 *pr_end = '\0';
373 *pi_end = '\0';
374 while(isspace((int)*pr_beg) && *pr_beg != '\0') pr_beg++;
375 while(isspace((int)*pi_beg) && *pi_beg != '\0') pi_beg++;
376 temp[0] = '\0';
377 pp = &pr_beg;
378 get_num(pp, temp, &rtype, &tr);
379 if(tr)*stat |= BAD_REAL;
380 temp[0] = '\0';
381 pp = &pi_beg;
382 get_num(pp, temp, &itype, &ti);
383 if(ti)*stat |= BAD_IMG;
384 if(rtype == FLT_KEY || itype == FLT_KEY) *ktype = CMF_KEY;
385 return;
386 }
387
388 /* parse and test the comment keys */
389 void get_comm(char **pt, /* card string */
390 char *kcomm, /* comment string */
391 unsigned long *stat /* error number */
392 )
393 {
394 char *pi;
395 int nchar = 0;
396 char *p;
397
398 p = *pt;
399 pi = p;
400 if(*p != '/') {
401 *stat |= NO_START_SLASH;
402 }
403 p++;
404 while(*p != '\0') {
405 if(!isprint((int)*p) ) *stat |= BAD_COMMENT;
406 p++;
407 }
408 nchar = p - pi;
409 strncpy(kcomm,pi,nchar);
410 *(kcomm+nchar) = '\0';
411 return;
412 }
413
414 /* parsing the unknown keyword */
415 void get_unknown(char **pt, /* card string */
416 char *kvalue, /* comment string */
417 kwdtyp *ktype,
418 unsigned long *stat /* error number */
419 )
420 {
421 char *p;
422 char *p1;
423 char temp[FLEN_CARD];
424
425 p = *pt;
426 strcpy(temp,*pt);
427 p1 = temp;
428 while(*p != '\0' && *p != '/') { p++; p1++;}
429 *p1 = '\0';
430 p1 = temp;
431 *pt = p;
432
433 strcpy(kvalue, p1);
434 *ktype = UNKNOWN;
435 *stat |= UNKNOWN_TYPE;
436 return ;
437 }
438 /* routine to print out the error of keyword value/comment */
439 void pr_kval_err(FILE *out, /* output FILE */
440 int kpos, /* keyposition starting from 1 */
441 char *kname, /* keyword name */
442 char *kval, /* keyword value */
443 unsigned long errnum /* error number */
444 )
445 {
446 if(errnum == 0) return;
447 if(errnum & BAD_STR) {
448 sprintf(errmes,
449 "Keyword #%d, %s: String \"%s\" contains non-text characters.",
450 kpos,kname,kval);
451 wrterr(out,errmes,1);
452 }
453 if(errnum & NO_TRAIL_QUOTE) {
454 sprintf(errmes,
455 "Keyword #%d, %s: The closing \"\'\" is missing in the string." ,
456 kpos,kname);
457 wrterr(out,errmes,1);
458 }
459 if(errnum & BAD_LOGICAL) {
460 sprintf(errmes,"Keyword #%d, %s: Bad logical value \"%s\".",
461 kpos,kname,kval);
462 wrterr(out,errmes,1);
463 }
464 if(errnum & BAD_NUM) {
465 sprintf(errmes,"Keyword #%d, %s: Bad numerical value \"%s\".",
466 kpos,kname,kval);
467 wrterr(out,errmes,1);
468 }
469 if(errnum & LOWCASE_EXPO) {
470 sprintf(errmes,
471 "Keyword #%d, %s: lower-case exponent d or e is illegal in value %s.",
472 kpos,kname,kval);
473 wrterr(out,errmes,1);
474 }
475 if(errnum & NO_TRAIL_PAREN) {
476 sprintf(errmes,
477 "Keyword #%d, %s: Complex value \"%s\" misses closing \")\".",
478 kpos,kname, kval);
479 wrterr(out,errmes,1);
480 }
481 if(errnum & NO_COMMA) {
482 sprintf(errmes,
483 "keyword #%d, %s : Complex value \"%s\" misses \",\".",
484 kpos,kname,kval);
485 wrterr(out,errmes,1);
486 }
487 if(errnum & TOO_MANY_COMMA) {
488 sprintf(errmes,
489 "Keyword #%d, %s: Too many \",\" are in the complex value \"%s\".",
490 kpos,kname,kval);
491 wrterr(out,errmes,1);
492 }
493 if(errnum & BAD_REAL) {
494 sprintf(errmes,
495 "Keyword #%d, %s: Real part of complex value \"%s\" is bad.",
496 kpos,kname,kval);
497 wrterr(out,errmes,1);
498 }
499 if(errnum & BAD_IMG) {
500 sprintf(errmes,
501 "Keyword #%d, %s: Imagine part of complex value \"%s\" is bad.",
502 kpos,kname,kval);
503 wrterr(out,errmes,1);
504 }
505 if(errnum & NO_START_SLASH) {
506 sprintf(errmes,
507 "Keyword #%d, %s: Value and Comment not separated by a \"/\".",
508 kpos,kname);
509 wrterr(out,errmes,1);
510 }
511 if(errnum & BAD_COMMENT) {
512 sprintf(errmes,
513 "Keyword #%d, %s: Comment contains non-text characters.",
514 kpos,kname);
515 wrterr(out,errmes,1);
516 }
517
518 if(errnum & UNKNOWN_TYPE) {
519 if (*kval != 0) { /* don't report null keywords as an error */
520 sprintf(errmes,
521 "Keyword #%d, %s: Type of value \"%s\" is unknown.",
522 kpos,kname,kval);
523 wrterr(out,errmes,1);
524 }
525 }
526 return ;
527 }
528
529 int check_str(FitsKey* pkey, FILE *out)
530 {
531 if(pkey->ktype == UNKNOWN && *(pkey->kvalue) == 0) {
532 sprintf(errmes,"Keyword #%d, %s has a null value; expected a string.",
533 pkey->kindex,pkey->kname);
534 wrterr(out,errmes,1);
535 return 0;
536 } else if(pkey->ktype != STR_KEY) {
537 sprintf(errmes,"Keyword #%d, %s: \"%s\" is not a string.",
538 pkey->kindex,pkey->kname, pkey->kvalue);
539 wrterr(out,errmes,1);
540 return 0;
541 }
542 return 1;
543 }
544
545 int check_int(FitsKey* pkey, FILE *out)
546 {
547 if(pkey->ktype == UNKNOWN && *(pkey->kvalue) == 0) {
548 sprintf(errmes,"Keyword #%d, %s has a null value; expected an integer.",
549 pkey->kindex,pkey->kname);
550 wrterr(out,errmes,1);
551 return 0;
552 } else if(pkey->ktype != INT_KEY) {
553 sprintf(errmes,"Keyword #%d, %s: value = %s is not an integer.",
554 pkey->kindex,pkey->kname, pkey->kvalue);
555 if(pkey->ktype == STR_KEY)
556 strcat(errmes," The value is entered as a string. ");
557 wrterr(out,errmes,1);
558 return 0;
559 }
560 return 1;
561 }
562 int check_flt(FitsKey* pkey, FILE *out)
563 {
564 if(pkey->ktype == UNKNOWN && *(pkey->kvalue) == 0) {
565 sprintf(errmes,"Keyword #%d, %s has a null value; expected a float.",
566 pkey->kindex,pkey->kname);
567 wrterr(out,errmes,1);
568 return 0;
569 } else if(pkey->ktype != INT_KEY && pkey->ktype != FLT_KEY) {
570 sprintf(errmes,
571 "Keyword #%d, %s: value = %s is not a floating point number.",
572 pkey->kindex,pkey->kname, pkey->kvalue);
573 if(pkey->ktype == STR_KEY)
574 strcat(errmes," The value is entered as a string. ");
575 wrterr(out,errmes,1);
576 return 0;
577 }
578 return 1;
579 }
580
581 int check_cmi(FitsKey* pkey, FILE *out)
582 {
583 if(pkey->ktype != CMI_KEY ) {
584 sprintf(errmes,
585 "Keyword #%d, %s: value = %s is not a integer complex number.",
586 pkey->kindex,pkey->kname, pkey->kvalue);
587 if(pkey->ktype == STR_KEY)
588 strcat(errmes," The value is entered as a string. ");
589 wrterr(out,errmes,1);
590 return 0;
591 }
592 return 1;
593 }
594
595 int check_cmf(FitsKey* pkey, FILE *out)
596 {
597 if(pkey->ktype != CMI_KEY && pkey->ktype != CMF_KEY) {
598 sprintf(errmes,
599 "Keyword #%d, %s: value = %s is not a floating point complex number.",
600 pkey->kindex,pkey->kname, pkey->kvalue);
601 if(pkey->ktype == STR_KEY)
602 strcat(errmes," The value is entered as a string. ");
603 wrterr(out,errmes,1);
604 return 0;
605 }
606 return 1;
607 }
608 int check_log(FitsKey* pkey, FILE *out)
609 {
610 if(pkey->ktype != LOG_KEY ) {
611 sprintf(errmes,
612 "Keyword #%d, %s: value = %s is not a logical constant.",
613 pkey->kindex,pkey->kname, pkey->kvalue);
614 if(pkey->ktype == STR_KEY)
615 strcat(errmes," The value is entered as a string. ");
616 wrterr(out,errmes,1);
617 return 0;
618 }
619 return 1;
620 }
621 int check_fixed_int(char* card, FILE *out)
622 {
623 char *cptr;
624
625 /* fixed format integer must be right justified in columns 11-30 */
626
627 cptr = &card[10];
628
629 while (*cptr == ' ')cptr++; /* skip leading spaces */
630
631 if (*cptr == '-')
632 cptr++; /* skip leading minus sign */
633 else if (*cptr == '+')
634 cptr++; /* skip leading plus sign */
635
636 while (isdigit((int) *cptr))cptr++; /* skip digits */
637
638 /* should be pointing to column 31 of the card */
639
640 if ((cptr - card) != 30) {
641 sprintf(errmes,
642 "%.8s mandatory keyword is not in integer fixed format:",
643 card);
644 wrterr(out,errmes,1);
645 print_fmt(out,card,13);
646 print_fmt(out," -------------------^",13);
647
648 return 0;
649 }
650 return 1;
651 }
652 int check_fixed_log(char* card, FILE *out)
653 {
654 char *cptr;
655
656 /* fixed format logical must have T or F in column 30 */
657
658 cptr = &card[10];
659
660 while (*cptr == ' ')cptr++; /* skip leading spaces */
661
662 if (*cptr != 'T' && *cptr != 'F') {
663 sprintf(errmes,
664 "%.8s mandatory keyword does not have T or F logical value.",
665 card);
666 wrterr(out,errmes,1);
667 return 0;
668 }
669
670 /* should be pointing to column 31 of the card */
671
672 if ((cptr - card) != 29) {
673 sprintf(errmes,
674 "%.8s mandatory keyword is not in logical fixed format:",
675 card);
676 wrterr(out,errmes,1);
677 print_fmt(out,card,13);
678 print_fmt(out," -------------------^",13);
679
680 return 0;
681 }
682 return 1;
683 }
684 int check_fixed_str(char* card, FILE *out)
685 {
686 char *cptr;
687
688 /* fixed format string must have quotes in columns 11 and >= 20 */
689 /* This only applys to the XTENSION and TFORMn keywords. */
690
691 cptr = &card[10];
692
693 if (*cptr != '\'' ) {
694 sprintf(errmes,
695 "%.8s mandatory string keyword does not start in col 11.",
696 card);
697 wrterr(out,errmes,1);
698 print_fmt(out,card,13);
699 print_fmt(out," ^--------^",13);
700 return 0;
701 }
702
703 cptr++;
704
705 while (*cptr != '\'') {
706
707 if (*cptr == '\0') {
708 sprintf(errmes,
709 "%.8s mandatory string keyword missing closing quote character:",
710 card);
711 wrterr(out,errmes,1);
712 print_fmt(out,card,13);
713 return 0;
714 }
715 cptr++;
716 }
717
718 if ((cptr - card) < 19) {
719 sprintf(errmes,
720 "%.8s mandatory string keyword ends before column 20.",
721 card);
722 wrterr(out,errmes,1);
723 print_fmt(out,card,13);
724 print_fmt(out," ^--------^",13);
725
726 return 0;
727 }
728
729 return 1;
730 }