Debian Codegraph @

libsrc/st/midkeya.c

raw
1 /*===========================================================================
2 Copyright (C) 1995-2009 European Southern Observatory (ESO)
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License as
6 published by the Free Software Foundation; either version 2 of
7 the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public
15 License along with this program; if not, write to the Free
16 Software Foundation, Inc., 675 Massachusetts Ave, Cambridge,
17 MA 02139, USA.
18
19 Correspondence concerning ESO-MIDAS should be addressed as follows:
20 Internet e-mail: [email protected]
21 Postal address: European Southern Observatory
22 Data Management Division
23 Karl-Schwarzschild-Strasse 2
24 D 85748 Garching bei Muenchen
25 GERMANY
26 ===========================================================================*/
27
28 /*+++++++++++++++++++++ Module MIDKEYA +++++++++++++++++++++++++++++++++++++++
29 .LANGUAGE C
30 .IDENTIFICATION Module MIDKEYA
31 .AUTHOR Klaus Banse ESO - Garching
32 .KEYWORDS Midas keyword utility routines: SHOKEY, DSPKEY
33 .ENVIRONMENT VMS and UNIX
34 .COMMENT
35 holds SHOKEY, DSPKEY
36 .VERSION
37
38 090326 last modif
39 ------------------------------------------------------------------------*/
40
41
42 #include <fileexts.h>
43
44 #include <stdlib.h>
45 #include <stdio.h>
46 #include <string.h>
47
48
49
50 static int kunit, kentry, noelem, bytelem;
51
52 static char kname[18], k_typ[4], work[96];
53
54 static struct KEY_STRUCT *keypntr;
55
56
57 /*
58
59 */
60
61 void MID_SHOKEY(flag,keywo)
62
63 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
64 .PURPOSE display keywords.
65 .RETURNS nothing
66 ---------------------------------------------------------------*/
67
68 int flag; /* IN: 0 - display keyword info on screen,
69 1 - only fill keyword M$INFO (this is only
70 applicable for individual keywords... */
71 char *keywo; /* IN: name of keyword,
72 `?' to show all keywords + system info,
73 `?+' to show only system info */
74
75 {
76 int sizbyt, typno, kk;
77 register int n, mm;
78
79 char k_typ;
80
81 struct KEY_STRUCT *locpntr;
82
83
84
85
86 if (*keywo != '?')
87 {
88 CGN_UPCOPY(kname,keywo,KEY_NAMELEN);
89 kname[KEY_NAMELEN] = '\0';
90 for (n=(int)strlen(kname); n<KEY_NAMELEN; n++)
91 kname[n] = ' ';
92
93
94 /* contrary to the rest, loop first through the local keywords
95 and look for LAST matching keyword name */
96
97 keypntr = KEYALL.KEYNAMES + KEYALL.GLOBENT;
98 locpntr = KEYALL.KEYNAMES;
99
100 for (mm=KEYALL.GLOBENT; mm <= KEYALL.LOCNO; mm++)
101 {
102 if (strncmp(kname,keypntr->IDENT,KEY_NAMELEN) == 0)
103 locpntr = keypntr; /* get last match */
104 keypntr ++;
105 }
106
107 if (locpntr != KEYALL.KEYNAMES)
108 {
109 keypntr = locpntr;
110 k_typ = keypntr->IDENT[15];
111 if (k_typ == 'I')
112 {
113 sizbyt = II_SIZE;
114 typno = 1;
115 }
116 else if (k_typ == 'R')
117 {
118 sizbyt = RR_SIZE;
119 typno = 2;
120 }
121 else if (k_typ == 'D')
122 {
123 sizbyt = DD_SIZE;
124 typno = 4;
125 }
126 else if (k_typ == 'C')
127 {
128 sizbyt = 1;
129 typno = 3;
130 }
131 else
132 { /* new type: size_t */
133 sizbyt = SS_SIZE;
134 typno = 5;
135 }
136
137 if (flag == 0)
138 {
139 kname[KEY_NAMELEN] = '\0';
140 (void)
141 snprintf(work,(size_t)88,
142 "No. %d, IDENT(Name,Type,Level): %s %c%c",mm,kname,
143 k_typ,keypntr->IDENT[16]);
144 SCTPUT(work);
145 (void)
146 snprintf(work,(size_t)88,
147 " bytes per element = %d, no. of elements = %d",
148 keypntr->BYTELEM,keypntr->NOELEM);
149 SCTPUT(work);
150 sizbyt *= keypntr->OFFSET;
151 (void)
152 (void) snprintf(work,(size_t)88,
153 " length = %d, offset = %d, Pad = %d (all in bytes)",
154 keypntr->LEN,sizbyt,keypntr->FRPAD);
155 SCTPUT(work);
156 }
157 else
158 {
159 n = OFF_INFO;
160 KIWORDS[n++] = typno;
161 KIWORDS[n++] = keypntr->NOELEM;
162 KIWORDS[n++] = keypntr->BYTELEM;
163 }
164 return;
165 }
166
167 keypntr = KEYALL.KEYNAMES;
168 for (mm=0; mm <= KEYALL.GLOBNO; mm++)
169 {
170 if (strncmp(kname,keypntr->IDENT,KEY_NAMELEN) == 0)
171 {
172 k_typ = keypntr->IDENT[15];
173 if (k_typ == 'I')
174 {
175 sizbyt = II_SIZE;
176 typno = 1;
177 }
178 else if (k_typ == 'R')
179 {
180 sizbyt = RR_SIZE;
181 typno = 2;
182 }
183 else if (k_typ == 'D')
184 {
185 sizbyt = DD_SIZE;
186 typno = 4;
187 }
188 else if (k_typ == 'C')
189 {
190 sizbyt = 1;
191 typno = 3;
192 }
193 else
194 { /* new type: size_t */
195 sizbyt = SS_SIZE;
196 typno = 5;
197 }
198
199 if (flag == 0)
200 {
201 kname[KEY_NAMELEN] = '\0';
202 (void)
203 snprintf(work,(size_t)88,
204 "No. %d, IDENT(Name,Type): %s %c",mm,kname,k_typ);
205 SCTPUT(work);
206 (void)
207 snprintf(work,(size_t)88,
208 " bytes per element = %d, no. of elements = %d",
209 keypntr->BYTELEM,keypntr->NOELEM);
210 SCTPUT(work);
211 sizbyt *= keypntr->OFFSET;
212 (void) snprintf(work,(size_t)88,
213 " length = %d, offset = %d, Pad = %d (all in bytes)",
214 keypntr->LEN,sizbyt,keypntr->FRPAD);
215 SCTPUT(work);
216 }
217 else
218 {
219 n = OFF_INFO;
220 KIWORDS[n++] = typno;
221 KIWORDS[n++] = keypntr->NOELEM;
222 KIWORDS[n++] = keypntr->BYTELEM;
223 }
224 return;
225 }
226 keypntr ++;
227 }
228
229 if (flag == 0)
230 {
231 (void) snprintf(work,(size_t)88,
232 "keyword %s not found \n",keywo);
233 SCTPUT(work);
234 }
235 else
236 KIWORDS[OFF_INFO] = 0; /* keyword not found */
237 return;
238 }
239
240
241 keywo++;
242 if (*keywo == '+') /* ?+ omits individual keywords */
243 goto last_info;
244
245 kname[8] = '\0';
246 (void) snprintf(work,(size_t)88,"global keywords:");
247 SCTPUT(work);
248 (void) snprintf(work,(size_t)88,"----------------\n");
249 SCTPUT(work);
250
251 keypntr = KEYALL.KEYNAMES;
252 for (mm=0; mm <= KEYALL.GLOBNO; mm++)
253 {
254 k_typ = keypntr->IDENT[15];
255 if (k_typ == 'I')
256 sizbyt = II_SIZE;
257 else if (k_typ == 'R')
258 sizbyt = RR_SIZE;
259 else if (k_typ == 'D')
260 sizbyt = DD_SIZE;
261 else if (k_typ == 'C')
262 sizbyt = 1;
263 else
264 sizbyt = SS_SIZE;
265
266 strncpy(kname,keypntr->IDENT,(size_t)KEY_NAMELEN);
267 (void)
268 snprintf(work,(size_t)88,
269 "No. %d, IDENT(Name,Type): %s %c",mm,kname,k_typ);
270 SCTPUT(work);
271 (void) snprintf(work,(size_t)88,
272 " bytes per element = %d, no. of elements = %d",
273 keypntr->BYTELEM,keypntr->NOELEM);
274 SCTPUT(work);
275 sizbyt *= keypntr->OFFSET;
276 (void) snprintf(work,(size_t)88,
277 " length = %d, offset = %d, Pad = %d (all in bytes)",
278 keypntr->LEN,sizbyt,keypntr->FRPAD);
279 SCTPUT(work);
280 keypntr ++;
281 }
282
283 if (KEYALL.LOCNO >= KEYALL.GLOBENT)
284 {
285 (void) snprintf(work,(size_t)88,"local keywords:");
286 SCTPUT(work);
287 (void) snprintf(work,(size_t)88,"---------------\n");
288 SCTPUT(work);
289 }
290
291 keypntr = KEYALL.KEYNAMES + KEYALL.GLOBENT;
292 for (mm=KEYALL.GLOBENT; mm <= KEYALL.LOCNO; mm++)
293 {
294 k_typ = keypntr->IDENT[15];
295 if (k_typ == 'I')
296 sizbyt = II_SIZE;
297 else if (k_typ == 'R')
298 sizbyt = RR_SIZE;
299 else if (k_typ == 'D')
300 sizbyt = DD_SIZE;
301 else if (k_typ == 'C')
302 sizbyt = 1;
303 else
304 sizbyt = SS_SIZE;
305
306 (void) strncpy(kname,keypntr->IDENT,(size_t)KEY_NAMELEN);
307 (void) snprintf(work,(size_t)88,
308 "No. %d, IDENT(Name,Type,Level): %s %c%c",mm,kname,
309 k_typ,keypntr->IDENT[16]);
310 SCTPUT(work);
311 (void) snprintf(work,(size_t)88,
312 " bytes per element = %d, no. of elements = %d",
313 keypntr->BYTELEM,keypntr->NOELEM);
314 SCTPUT(work);
315 sizbyt *= keypntr->OFFSET;
316 (void) snprintf(work,(size_t)88,
317 " length = %d, offset = %d, Pad = %d (all in bytes)",
318 keypntr->LEN,sizbyt,keypntr->FRPAD);
319 SCTPUT(work);
320 keypntr ++;
321 }
322
323 (void) snprintf(work,(size_t)88,"\n---------------------------------\n");
324 SCTPUT(work);
325
326 last_info:
327 mm = KEYALL.GLOBNO + 1; /* we counted from 0 on ... */
328 (void) snprintf(work,(size_t)88,
329 "global keys: no. = %d, space used = %d bytes",
330 mm,KEYALL.GLOBEND);
331 SCTPUT(work);
332 (void) snprintf(work,(size_t)88,
333 "max. global keys = %d (max. space = %d)",
334 KEYALL.GLOBENT,KEYALL.GLOBDAT);
335 SCTPUT(work);
336 kk = OFF_INFO;
337 KIWORDS[kk++] = mm;
338 KIWORDS[kk++] = KEYALL.GLOBEND;
339 KIWORDS[kk++] = KEYALL.GLOBENT;
340 KIWORDS[kk++] = KEYALL.GLOBDAT;
341
342 mm = (KEYALL.LOCNO + 1) - KEYALL.GLOBENT;
343 n = (KEYALL.LOCEND + 1) - KEYALL.GLOBDAT;
344 (void) snprintf(work,(size_t)88,
345 "local keys: no. = %d, space used = %d bytes",mm,n);
346 SCTPUT(work);
347 KIWORDS[kk++] = mm;
348 KIWORDS[kk++] = n;
349 mm = KEYALL.LOCENT - KEYALL.GLOBENT;
350 n = KEYALL.LOCDAT - KEYALL.GLOBDAT;
351 (void) snprintf(work,(size_t)88,
352 "max. local keys = %d (max. space = %d)",mm,n);
353 SCTPUT(work);
354 KIWORDS[kk++] = mm;
355 KIWORDS[kk] = n;
356 }
357
358 /*
359
360 */
361
362 #ifdef __STDC__
363 int MID_DSPKEY( char *name, char dflag)
364 #else
365 int MID_DSPKEY(name,dflag)
366 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
367 .PURPOSE
368 display the contents of keywords on the terminal
369 .ALGORITHM
370 find keyword entry + display keyword data
371 .RETURN
372 MIDAS error code
373 ----------------------------------------------------------------------*/
374
375 char *name; /* IN: name of keyword, if blank all keywords */
376 char dflag; /* IN: disp_flag, if = 'h' don't print header line */
377 #endif
378
379 {
380 int sta, nrl, kk, koffs, n1, n2, all;
381 int wcindx;
382 int n3 = 0;
383
384 register int nr;
385
386 char indstr[18], *datpntr;
387
388
389 sta = 0;
390 all = 0;
391 nrl = (int) strlen(name);
392
393 extra_key:
394 wcindx = 0;
395 n2 = CGN_EXTRSS(name,nrl,',',&sta,kname,KEY_NAMELEN);
396 if (n2 <= 0) /* line finished */
397 {
398 if (n2 == -2)
399 return (ERR_KEYBAD); /* keyname too long */
400 else
401 return (ERR_NORMAL);
402 }
403
404
405 /* check for wildcards */
406
407 if (kname[0] == '*') /* wildcard in the beginning */
408 {
409 all = 1;
410 kentry = 0;
411 if (kname[1] != '\0')
412 {
413 wcindx = -1;
414 CGN_UPCOPY(indstr,&kname[1],KEY_NAMELEN);
415 indstr[KEY_NAMELEN] = '\0';
416 n3 = (int) strlen(indstr);
417 }
418 goto key_loop;
419 }
420
421 if (kname[--n2] == '*') /* wildcard in the end */
422 {
423 wcindx = 1;
424 all = 1;
425 kentry = 0;
426 kname[n2] = '\0';
427 CGN_UPCOPY(indstr,kname,KEY_NAMELEN);
428 goto key_loop;
429 }
430
431 kentry = MID_FNDKEY(kname,k_typ,&bytelem,&noelem,&kunit);
432 if (kentry < 0) return (ERR_KEYBAD);
433
434
435 /* set name to keyword name */
436
437 key_loop:
438 keypntr = KEYALL.KEYNAMES + kentry; /* point to specific entry */
439 if (*keypntr->IDENT != '\\') /* no deleted keyword */
440 {
441 (void) strncpy(kname,keypntr->IDENT,(size_t)KEY_NAMELEN);
442 if (wcindx != 0) /* if wildcard, compare names */
443 {
444 kname[KEY_NAMELEN] = '\0';
445 n1 = CGN_INDEXS(kname,indstr);
446 if (wcindx > 0)
447 {
448 if (n1 != 0) goto wrap_up;
449 }
450 else
451 {
452 for (nr=1; nr<KEY_NAMELEN; nr++) /* get rid of trailing blanks */
453 {
454 if (kname[nr] == ' ')
455 {
456 kname[nr] = '\0';
457 break;
458 }
459 }
460 n2 = (int) strlen(kname);
461 if ((n1 < 0) || ((n1+n3)) != n2) goto wrap_up;
462 }
463 }
464 k_typ[0] = keypntr->IDENT[15];
465 bytelem = keypntr->BYTELEM;
466 noelem = keypntr->NOELEM;
467
468
469 /* keyname o.k. - treat data according to type */
470
471 koffs = keypntr->OFFSET;
472 n1 = 0;
473 memset((void *)work,32,(size_t)80); /* int 32 = ' ' */
474
475
476 /* integer data */
477
478 if (k_typ[0] == 'I')
479 {
480 if (dflag != 'h')
481 {
482 (void) snprintf(work,(size_t)88,
483 "keyword: %15.15s type: integer no_elems: %d",
484 kname,noelem);
485 SCTPUT(work);
486 }
487 n2 = 8;
488
489 sect_1000:
490 if (n2 > noelem) n2 = noelem;
491 memset((void *)work,32,(size_t)80); /* int 32 = ' ' */
492
493 for (nr=0; nr<(n2-n1)*10; nr+=10)
494 (void) snprintf(&work[nr],(size_t)88,"%10d",KIWORDS[koffs++]);
495 SCTPUT(work);
496 if (n2 < noelem)
497 {
498 n1 = n2;
499 n2 += 8;
500 goto sect_1000;
501 }
502 }
503
504
505 /* real data */
506
507 else if (k_typ[0] == 'R')
508 {
509 if (dflag != 'h')
510 {
511 (void) snprintf(work,(size_t)88,
512 "keyword: %15.15s type: real no_elems: %d",
513 kname,noelem);
514 SCTPUT(work);
515 }
516 n2 = 6;
517
518 sect_2000:
519 if (n2 > noelem) n2 = noelem;
520 memset((void *)work,32,(size_t)80); /* int 32 = ' ' */
521
522 for (nr=0; nr<(n2-n1)*13; nr+=13)
523 (void) snprintf(&work[nr],(size_t)88,"%13.6g",KRWORDS[koffs++]);
524 SCTPUT(work);
525 if (n2 < noelem)
526 {
527 n1 = n2;
528 n2 += 6;
529 goto sect_2000;
530 }
531 }
532
533 /* character data */
534
535 else if (k_typ[0] == 'C')
536 {
537 if (dflag != 'h')
538 {
539 (void) snprintf(work,(size_t)88,
540 "keyword: %15.15s type: char*%-3d no_elems: %d",
541 kname,bytelem,noelem);
542 SCTPUT(work);
543 }
544 n2 = 80;
545
546 if (bytelem > 1)
547 {
548 if (bytelem > 90) /* size of buffer `work' */
549 {
550 datpntr = malloc((size_t)(bytelem+2));
551 for (nr=0; nr<noelem; nr++)
552 {
553 (void) strncpy(datpntr,&KCWORDS[koffs],(size_t)bytelem);
554 *(datpntr+bytelem) = '\0';
555 SCTPUT(datpntr);
556 koffs += bytelem;
557 }
558 free (datpntr);
559 }
560 else
561 {
562 for (nr=0; nr<noelem; nr++)
563 {
564 (void) strncpy(work,&KCWORDS[koffs],(size_t)bytelem);
565 work[bytelem] = '\0';
566 SCTPUT(work);
567 koffs += bytelem;
568 }
569 }
570 }
571 else
572 {
573 sect_3000:
574 if (n2 > noelem) n2 = noelem;
575 kk = n2 - n1;
576 (void) strncpy(work,&KCWORDS[koffs],(size_t)kk);
577 work[kk] = '\0';
578 SCTPUT(work);
579 if (n2 < noelem)
580 {
581 n1 = n2;
582 n2 += 80;
583 koffs += 80;
584 goto sect_3000;
585 }
586 }
587 }
588
589
590 /* double precision data */
591
592 else if (k_typ[0] == 'D')
593 {
594 if (dflag != 'h')
595 {
596 (void) snprintf(work,(size_t)88,
597 "keyword: %15.15s type: double no_elems: %d",
598 kname,noelem);
599 SCTPUT(work);
600 }
601 n2 = 3;
602
603 sect_4000:
604 if (n2 > noelem) n2 = noelem;
605 memset((void *)work,32,(size_t)80); /* int 32 = ' ' */
606
607 for (nr=0; nr<(n2-n1)*25; nr+=25)
608 (void) snprintf(&work[nr],(size_t)88,"%25.18g",KDWORDS[koffs++]);
609 SCTPUT(work);
610 if (n2 < noelem)
611 {
612 n1 = n2;
613 n2 += 3;
614 goto sect_4000;
615 }
616 }
617
618 /* size_t data */
619
620 else if (k_typ[0] == 'S')
621 {
622 if (dflag != 'h')
623 {
624 (void) snprintf(work,(size_t)88,
625 "keyword: %15.15s type: size_t no_elems: %d",
626 kname,noelem);
627 SCTPUT(work);
628 }
629 n2 = 3;
630
631 sect_5000:
632 if (n2 > noelem) n2 = noelem;
633 memset((void *)work,32,(size_t)80); /* int 32 = ' ' */
634
635 for (nr=0; nr<(n2-n1)*25; nr+=25)
636 (void) snprintf(&work[nr],(size_t)88,"%25zd",KSWORDS[koffs++]);
637 SCTPUT(work);
638 if (n2 < noelem)
639 {
640 n1 = n2;
641 n2 += 3;
642 goto sect_5000;
643 }
644 }
645 }
646
647
648 wrap_up: /* decide if we loop more */
649 if (all == 3)
650 {
651 kentry --;
652 if (kentry >= KEYALL.GLOBENT) goto key_loop;
653 }
654
655 else if (all == 1)
656 {
657 kentry ++;
658 if (kentry <= KEYALL.GLOBNO) goto key_loop;
659
660 all = 3; /* now let's loop through the local k. */
661 kentry = KEYALL.LOCNO;
662 if (kentry >= KEYALL.GLOBENT)
663 {
664 if (wcindx == 0) SCTPUT("--- local keywords ---");
665 goto key_loop;
666 }
667 }
668
669 goto extra_key; /* see, if we can extract more */
670 }
671