![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fma_globals.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src|
Return to fma_globals.c CVS log | Up to [Coherent Logic Development] / freem / src |
1.1 snw 1: /*
2: * *
3: * * *
4: * * *
5: * ***************
6: * * * * *
7: * * MUMPS *
8: * * * * *
9: * ***************
10: * * *
11: * * *
12: * *
13: *
14: * fma_globals.c
15: * fmadm - globals
16: *
17: *
18: * Author: Serena Willis <jpw@coherent-logic.com>
19: * Copyright (C) 1998 MUG Deutschland
20: * Copyright (C) 2020 Coherent Logic Development LLC
21: *
22: *
23: * This file is part of FreeM.
24: *
25: * FreeM is free software: you can redistribute it and/or modify
26: * it under the terms of the GNU Affero Public License as published by
27: * the Free Software Foundation, either version 3 of the License, or
28: * (at your option) any later version.
29: *
30: * FreeM is distributed in the hope that it will be useful,
31: * but WITHOUT ANY WARRANTY; without even the implied warranty of
32: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33: * GNU Affero Public License for more details.
34: *
35: * You should have received a copy of the GNU Affero Public License
36: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
37: *
38: **/
39:
40: #include <stdlib.h>
41: #include <stdio.h>
42: #include <stdlib.h>
43: #include <string.h>
44: #include <dirent.h>
45: #include <time.h>
46: #include <unistd.h>
47: #include <sys/types.h>
48: #include <sys/stat.h>
49: #include <fcntl.h>
50:
51: #include "fmadm.h"
52:
53: void gl (char *global, short kf, short df, short nr, int chop);
54: int gverify (char *gpath);
55: static short int g_collate (); /* if 't' follows 's' in MUMPS collating */
56: int key_check (char *key);
57: void check ();
58: void show ();
59:
60: /* global variables for gverify */
61: short filedes; /* file descriptor */
62: char block[MAXLEV][BLOCKLEN]; /* block to be read */
63: char *blck; /* dto. as pointer */
64: unsigned long llink[MAXLEV]; /* left link pointers */
65: unsigned long rlink[MAXLEV]; /* right link pointers */
66: short offsets[MAXLEV]; /* offsets */
67: short type[MAXLEV]; /* block type */
68: extern short level; /* current level */
69: unsigned long no_of_blks; /* number of blocks */
70: unsigned long freeblks; /* free blocks list */
71: char key[256]; /* current key in pointer block scan */
72: short exstat = 0; /* exit status */
73: void showpath (); /* display path of pointers */
74: /* end of global variables for gverify */
75:
76:
77: int fma_globals_list (int optc, char **opts)
78: {
79: DIR *dir;
80: struct dirent *ent;
81:
82: char filename[STRLEN];
83:
84: int ct = 0;
85:
86: printf ("\nFreeM Global Listing\n");
87: printf ("--------------------\n\n");
88:
89: printf ("Namespace: %s\n", fma_namespace);
90: printf ("Global Path: %s\n\n", fma_global_path);
91:
92: if ((dir = opendir (fma_global_path)) == NULL) {
93: fprintf (stderr, "fmadm: could not open global directory %s\n", fma_global_path);
94: return 1;
95: }
96:
97: while ((ent = readdir (dir)) != NULL) {
98:
99: strncpy (filename, ent->d_name, STRLEN - 1);
100:
101: if (filename[0] == '^' && filename[1] != '$') {
102: printf (" %s\n", filename);
103: ct++;
104: }
105:
106: }
107:
108: printf ("\n\n - %d globals found\n\n", ct);
109: closedir (dir);
110:
111: return 0;
112: }
113:
114: int fma_globals_examine (int optc, char **opts)
115: {
116:
117: DIR *dir;
118: struct dirent *ent;
119:
120: char gpath[STRLEN];
121: int i;
122: int ct = 0;
123:
124: if ((dir = opendir (fma_global_path)) == NULL) {
125: fprintf (stderr, "fmadm: could not open global directory %s\n", fma_global_path);
126: return 1;
127: }
128:
129: printf ("\nFreeM Global Examine\n");
130: printf ("--------------------\n\n");
131:
132: printf ("Namespace: %s\n", fma_namespace);
133: printf ("Global Path: %s\n", fma_global_path);
134: printf ("Globals Selected: ");
135:
136:
137: if (optc > 1) {
138:
139: for (i = fma_base_opt; i <= optc; i++) {
140: printf ("%s ", opts[i]);
141: }
142:
143: printf ("\n\n");
144:
145: }
146: else {
147: printf ("[ENTIRE NAMESPACE]\n\n");
148: }
149:
150:
151: if (optc > 1) {
152:
153: for (i = fma_base_opt; i < optc; i++) {
154:
155: snprintf (gpath, STRLEN - 1, "%s/%s", fma_global_path, opts[i]);
156: gl (gpath, FALSE, FALSE, FALSE, strlen (fma_global_path));
157:
158: ct++;
159:
160: }
161:
162: }
163: else {
164:
165: while ((ent = readdir (dir)) != NULL) {
166:
167: strncpy (gpath, ent->d_name, STRLEN - 1);
168:
169: if (gpath[0] == '^' && gpath[1] != '$') {
170:
171: snprintf (gpath, STRLEN - 1, "%s/%s", fma_global_path, ent->d_name);
172:
173: gl (gpath, FALSE, FALSE, FALSE, strlen (fma_global_path));
174:
175: ct++;
176:
177: }
178:
179: }
180:
181: }
182:
183: printf ("\n\n");
184: printf (" - %d globals examined\n\n", ct);
185:
186: return 0;
187:
188: }
189:
190: int fma_globals_remove (int optc, char **opts)
191: {
192:
193: char gpath[STRLEN];
194: int i;
195: int ct = 0;
196: int er = 0;
197: int tot = 0;
198:
199: printf ("\nFreeM Global Removal\n");
200: printf ("--------------------\n\n");
201:
202: printf ("Namespace: %s\n", fma_namespace);
203: printf ("Global Path: %s\n\n", fma_global_path);
204:
205: for (i = fma_base_opt; i < optc; i++) {
206: printf ("%-10s\t", opts[i]);
207:
208: snprintf (gpath, STRLEN - 1, "%s/%s", fma_global_path, opts[i]);
209:
210: if (unlink (gpath) == -1) {
211: printf ("[FAIL]\n");
212: er++;
213: }
214: else {
215: printf ("[OK]\n");
216: ct++;
217: }
218:
219: tot++;
220:
221: }
222:
223: printf ("\nRemoved %d globals [%d errors/%d attempted]\n\n", ct, er, tot);
224:
225: return 0;
226:
227: }
228:
229: int fma_globals_verify (int optc, char **opts)
230: {
231: DIR *dir;
232: struct dirent *ent;
233:
234: char gpath[STRLEN];
235: int i;
236: int ct = 0;
237:
238: if ((dir = opendir (fma_global_path)) == NULL) {
239: fprintf (stderr, "fmadm: could not open global directory %s\n", fma_global_path);
240: return 1;
241: }
242:
243: printf ("\nFreeM Global Verify\n");
244: printf ("-------------------\n\n");
245:
246: printf ("Namespace: %s\n", fma_namespace);
247: printf ("Global Path: %s\n", fma_global_path);
248: printf ("Globals Selected: ");
249:
250: if (optc > fma_base_opt) {
251:
252: for (i = fma_base_opt; i < optc; i++) {
253: printf ("%s ", opts[i]);
254: }
255:
256: printf ("\n\n");
257:
258: }
259: else {
260: printf ("[ENTIRE NAMESPACE]\n\n");
261: }
262:
263:
264: if (optc > fma_base_opt) {
265:
266: for (i = fma_base_opt; i < optc; i++) {
267:
268: snprintf (gpath, STRLEN - 1, "%s/%s", fma_global_path, opts[i]);
269:
270: exstat = 0;
271: gverify (gpath);
272:
273: printf ("\n\t%d error(s) in %s\n", exstat, gpath);
274:
275: ct++;
276:
277: }
278:
279: }
280: else {
281:
282: while ((ent = readdir (dir)) != NULL) {
283:
284: strncpy (gpath, ent->d_name, STRLEN - 1);
285:
286: if (gpath[0] == '^') {
287:
288: snprintf (gpath, STRLEN - 1, "%s/%s", fma_global_path, ent->d_name);
289:
290: exstat = 0;
291: gverify (gpath);
292:
293: printf ("\n\t%d errors in %s\n", exstat, gpath);
294:
295: ct++;
296:
297: }
298:
299: }
300:
301: }
302:
303: printf ("\n\n");
304: printf (" - %d globals verified\n\n", ct);
305:
306: return 0;
307:
308: }
309:
310:
311: /* PRIVATE FUNCTIONS */
312:
313: /***
314: * gl(): list global
315: *
316: * global: name of global
317: * kf: key flag
318: * df: data flag
319: * nr: naked reference flag
320: */
321: void gl (char *global, short kf, short df, short nr, int chop)
322: {
323: short filedes; /* file descriptor */
324: char block[BLOCKLEN]; /* block to be read */
325: char key[512];
326: char prevkey[512]; /* previous key */
327: char data[1024]; /* if data has CTRLs it may become */
328: /* so long */
329: unsigned long blknbr;
330: short offset;
331: short length;
332: short koffs;
333: short dkf = TRUE;
334:
335: short CtrlFlag;
336: short n, k1;
337: register int i, j, k, ch;
338:
339: if ((filedes = open (global, 0)) == -1) {
340: printf ("%s: cannot open\012\015", global);
341:
342: return;
343: }
344:
345: if (kf == FALSE && df == FALSE) {
346: kf = TRUE;
347: df = TRUE;
348: }
349: else {
350: dkf = FALSE;
351: }
352:
353: blknbr = ROOT;
354: prevkey[0] = 0;
355: prevkey[1] = 0;
356: prevkey[2] = 0;
357:
358: for (;;) {
359:
360: lseek (filedes, blknbr * BLOCKLEN, 0);
361:
362: if (read (filedes, block, BLOCKLEN) == 0) {
363: fprintf (stderr, "\015*** something wrong ***\033[K\n\r");
364: exit (0);
365: }
366:
367: if (block[BTYP] == DATA) goto first;
368:
369: i = UNSIGN (block[0]) + 2;
370: blknbr = UNSIGN (block[i]) * 65536 + UNSIGN (block[i + 1]) * 256 + UNSIGN (block[i + 2]);
371:
372: }
373:
374: again:
375:
376: if (blknbr == 0) {
377: close (filedes);
378: return;
379: }
380:
381: lseek (filedes, blknbr * 1024L, 0);
382: read (filedes, block, BLOCKLEN);
383:
384: first:
385:
386: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
387: blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]);
388:
389: i = 0;
390: while (i < offset) {
391:
392: length = UNSIGN (block[i++]);
393: k = koffs = UNSIGN (block[i++]);
394:
395: if ((i + length) > offset) break;
396:
397: for (j = 0; j < length; j++) key[k++] = block[i++];
398:
399: key[k] = g_EOL;
400: {
401:
402: short ch0, i, j, k;
403:
404: j = 0;
405: i = 0;
406: data[j++] = '(';
407: k = 1;
408:
409: while ((ch = UNSIGN (key[i++])) != g_EOL) {
410:
411: if (k) {
412: k = 0;
413: if (ch > SP) data[j++] = '"';
414: }
415:
416: ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
417: (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
418: (ch >> 1) + SP)); /* '.' or '-' */
419:
420: if (ch0 == DEL) {
421: if ((ch0 = (UNSIGN (key[i++]) >> 1)) == DEL) {
422: ch0 = (UNSIGN (key[i++]) >> 1) + DEL;
423: }
424:
425: ch0 += DEL;
426: data[j] = '<';
427: data[++j] = '0' + ch0 / 100;
428: data[++j] = '0' + (ch0 % 100) / 10;
429: data[++j] = '0' + ch0 % 10;
430: data[++j] = '>';
431:
432: }
433: else {
434: data[j] = ch0;
435: }
436:
437: if (data[j++] == '"') data[j++] = '"';
438:
439: if (ch & 01) {
440:
441: if (ch > SP) data[j++] = '"';
442:
443: data[j++] = ',';
444: k = 1;
445:
446: }
447:
448: }
449:
450: data[j--] = 0;
451: data[j] = ')';
452:
453: if (j == 0) data[0] = 0;
454:
455: while (j >= 0) {
456: if ((ch = data[--j]) < SP || ch >= DEL) break;
457: }
458:
459: k1 = 0;
460: if (nr) {
461:
462: if (prevkey[0]) {
463:
464: n = ch = 0;
465:
466: while (data[n] == prevkey[n]) {
467:
468: if (prevkey[n] == '"') ch = !ch;
469: if (!ch && k1 == 0 && (prevkey[n] == '(')) k1 = n + 1;
470: if (!ch && (prevkey[n] == ',')) k1 = n + 1;
471:
472: n++;
473:
474: }
475:
476: while (prevkey[n]) {
477:
478: if (prevkey[n] == '"') ch = !ch;
479:
480: if (!ch && (prevkey[n] == ',')) {
481: k1 = 0;
482: break;
483: }
484:
485: n++;
486:
487: }
488:
489: }
490:
491: strcpy (prevkey, data);
492:
493: if (k1 > 1) {
494: strcpy (&data[1], &data[k1]);
495: }
496:
497: }
498:
499: if (j < 0) {
500:
501: if (kf) {
502:
503: if (k1) {
504: printf ("%c%s", '^', data);
505: }
506: else {
507: printf ("%s%s", global + chop + 1, data);
508: }
509:
510: }
511:
512: if (dkf && !nr) {
513: printf ("=");
514: }
515: else if (kf) {
516: printf ("\n");
517: }
518:
519: }
520: else {
521: fprintf (stderr, "[%d][%d] <illegal subscript>\n", length, koffs);
522: }
523:
524: }
525:
526: length = UNSIGN (block[i++]);
527:
528: stcpy0 (data, &block[i], (long) length);
529:
530: data[length] = EOL;
531:
532: if (numeric (data)) {
533: data[length] = 0;
534: i += length;
535: }
536: else {
537:
538: CtrlFlag = 0;
539: data[0] = '"';
540: k = 1;
541:
542: while (length-- > 0) {
543:
544: ch = UNSIGN (block[i++]);
545:
546: if ((ch >= SP) && (ch < DEL)) {
547:
548: if (CtrlFlag) { /* close Bracket after CTRL */
549:
550: data[k++] = ')';
551: data[k++] = '_';
552: data[k++] = '"';
553:
554: CtrlFlag = 0;
555:
556: }
557:
558: if ((data[k++] = ch) == '"') data[k++] = ch;
559:
560: }
561: else {
562:
563: if (((ch >= NUL) && (ch < SP)) || ch == DEL) {
564:
565: if (CtrlFlag) {
566: data[k++] = ',';
567: }
568: else {
569:
570: if (k > 1) {
571: data[k++] = '"';
572: data[k++] = '_';
573: }
574: else {
575: k = 0;
576: }
577:
578: data[k++] = '$';
579: data[k++] = 'C';
580: data[k++] = '(';
581:
582: CtrlFlag = 1;
583:
584: }
585:
586: if (ch == DEL) {
587: data[k++] = '1';
588: ch -= 100;
589: }
590:
591: if (ch >= 10) {
592: data[k++] = ch / 10 + '0';
593: ch = ch % 10;
594: }
595:
596: data[k++] = ch + '0';
597:
598: }
599: else {
600:
601: if (CtrlFlag) { /* close Bracket after CTRL */
602:
603: data[k++] = ')';
604: data[k++] = '_';
605: data[k++] = '"';
606:
607: CtrlFlag = 0;
608:
609: }
610:
611: data[k++] = '<';
612:
613: if (ch > 99) {
614: data[k++] = '0' + (ch / 100);
615: ch = ch % 100;
616: }
617:
618: if (ch > 9) {
619: data[k++] = '0' + (ch / 10);
620: ch = ch % 10;
621: }
622:
623: data[k++] = '0' + ch;
624: data[k++] = '>';
625:
626: }
627: }
628: }
629:
630: if (CtrlFlag) {
631: data[k++] = ')';
632: }
633: else {
634: data[k++] = '"';
635: }
636:
637: data[k] = 0;
638:
639: }
640:
641: if (df) printf ("%s\n", data);
642:
643: }
644:
645: if (i != offset) fprintf (stderr, "\nwrong offset %d vs. %d\n", offset, i);
646:
647: goto again;
648:
649: }
650:
651: int gverify (char *gpath)
652: {
653: register int j;
654:
655: printf ("\n%s:\n\n", gpath);
656:
657: if ((filedes = open (gpath, 0)) == -1) {
658: fprintf (stderr, "Cannot open file %s\007\n\r", gpath);
659: return 1;
660: }
661:
662: j = 0;
663:
664: while (j < MAXLEV) {
665:
666: rlink[j] = 0;
667: llink[j] = 0;
668:
669: j++;
670:
671: }
672:
673: level = 0;
674:
675: check (ROOT);
676:
677: j = 1; /* ignore level zero: there is no rightlink pointer (freeblocks instead) */
678: while (j < MAXLEV) { /* check last right link pointers (all zero!) */
679:
680: if (rlink[j] != 0) {
681: printf ("\tblock #%ld right link pointer mismatch 0 vs. %ld\012\015", llink[j], rlink[j]);
682: showpath ();
683: }
684:
685: j++;
686:
687: }
688:
689: /* check free blocks */
690: freeblks = UNSIGN (block[0][FREE]) * 65536 +
691: UNSIGN (block[0][FREE + 1]) * 256 +
692: UNSIGN (block[0][FREE + 2]);
693:
694: while (freeblks) {
695:
696: unsigned long free;
697: int i;
698:
699: if (freeblks > no_of_blks) {
700: printf ("\tblock# %ld (free list) greater than number of blocks (%ld)\012\015", freeblks, no_of_blks);
701: showpath ();
702: }
703:
704: lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);
705:
706: if (read (filedes, block[0], BLOCKLEN) < BLOCKLEN) {
707:
708: printf ("\tblock #%ld is (partially) empty\012\015", freeblks);
709: showpath ();
710:
711: exit (exstat);
712:
713: }
714:
715: j = UNSIGN (block[0][OFFS]) * 256 +
716: UNSIGN (block[0][OFFS + 1]); /* offset */
717:
718: freeblks = UNSIGN (block[0][RLPTR]) * 65536 +
719: UNSIGN (block[0][RLPTR + 1]) * 256 +
720: UNSIGN (block[0][RLPTR + 1]);
721:
722: i = 0;
723:
724: while (i < j) {
725:
726: free = UNSIGN (block[0][i++]) * 65536;
727: free += UNSIGN (block[0][i++]) * 256;
728: free += UNSIGN (block[0][i++]);
729:
730: if (free > no_of_blks) {
731: printf ("\tblock #%ld (free) greater than number of blocks (%ld)\012\015", free, no_of_blks);
732: showpath ();
733: }
734:
735: lseek (filedes, free * BLOCKLEN, 0);
736: read (filedes, block[1], BLOCKLEN);
737:
738: if (block[1][BTYP] != EMPTY) {
739:
740: printf ("\tblock #%ld expected block type: EMPTY\012\015", free);
741:
742: if (++exstat >= ERRLIM) {
743: fprintf (stderr, "Error limit exceeded\012\015");
744: return exstat;
745: }
746:
747: }
748:
749: }
750:
751: }
752:
753: return exstat;
754:
755: }
756:
757: void check (unsigned long blknbr)
758: {
759: unsigned long left; /* current left link pointer */
760: unsigned long right; /* current right link pointer */
761: long i;
762: long k;
763:
764: lseek (filedes, blknbr * BLOCKLEN, 0);
765: blck = block[level];
766:
767: if (read (filedes, blck, BLOCKLEN) < BLOCKLEN) {
768: printf ("\tblock #%ld is (partially) empty\012\015", blknbr);
769: showpath ();
770: }
771:
772: type[level] = blck[BTYP];
773:
774: left = UNSIGN (blck[LLPTR]) * 65536 +
775: UNSIGN (blck[LLPTR + 1]) * 256 +
776: UNSIGN (blck[LLPTR + 2]);
777:
778: right = UNSIGN (blck[RLPTR]) * 65536 +
779: UNSIGN (blck[RLPTR + 1]) * 256 +
780: UNSIGN (blck[RLPTR + 2]);
781:
782: if (blknbr == ROOT) {
783: no_of_blks = UNSIGN (block[0][NRBLK]) * 65536 +
784: UNSIGN (block[0][NRBLK + 1]) * 256 +
785: UNSIGN (block[0][NRBLK + 2]);
786: }
787: else {
788:
789: if (blknbr > no_of_blks) {
790: printf ("\tblock# %ld greater than number of blocks (%ld)\012\015", blknbr, no_of_blks);
791: showpath ();
792: }
793:
794: }
795:
796: offsets[level] = UNSIGN (blck[OFFS]) * 256 + UNSIGN (blck[OFFS + 1]);
797:
798: if (rlink[level] != 0L && rlink[level] != blknbr) {
799: printf ("\tblock #%ld right link pointer mismatch %ld vs. %ld\012\015", llink[level], blknbr, rlink[level]);
800: showpath ();
801: }
802:
803: if (llink[level] != 0L && left != llink[level]) {
804: printf ("\tblock #%ld left link pointer mismatch %ld vs. %ld\012\015", blknbr, left, llink[level]);
805: showpath ();
806: }
807:
808: rlink[level] = right;
809: llink[level] = blknbr;
810:
811: if (blknbr != ROOT) {
812:
813: k = UNSIGN (blck[0]);
814: i = 0;
815:
816: while (i < k) {
817: if (blck[i + 2] != key[i]) {
818: printf ("\tblock #%ld first key mismatch to pointer block(%ld)\012\015", blknbr, llink[level - 1]);
819: showpath ();
820: break;
821: }
822: i++;
823: }
824:
825: }
826:
827: switch (type[level]) {
828:
829: case EMPTY:
830: printf ("\tblock #%ld unexpected block type: EMPTY\012\015", blknbr);
831: showpath ();
832: break;
833:
834: case FBLK:
835: printf ("\tblock #%ld unexpected block type: FBLK\012\015", blknbr);
836: showpath ();
837: break;
838:
839: case POINTER:
840: case BOTTOM:
841: /*******************************/
842: /* scan pointer block */
843: {
844: register long i;
845: register long k;
846: short j;
847: short len;
848: char key1[256];
849:
850: key1[0] = g_EOL;
851: i = 0;
852:
853: while (i < offsets[level]) {
854:
855: j = i++; /* save adress of current entry */
856:
857: if ((len = UNSIGN (blck[j]) + (k = UNSIGN (blck[i++]))) > 255) {
858: printf ("\tblock #%ld key too long\012\015", blknbr);
859: showpath ();
860: }
861: else {
862:
863: if (len == 0 && j) {
864: printf ("\tblock #%ld empty key\012\015", blknbr);
865: showpath ();
866: }
867:
868: while (k < len) key[k++] = blck[i++];
869:
870: key[k] = g_EOL;
871:
872: if (key_check (key)) {
873: printf ("\tblock #%ld illegal key\012\015", blknbr);
874: showpath ();
875: }
876:
877: if (g_collate (key1, key) == 0) {
878: printf ("\tblock #%ld collation mismatch\012\015", blknbr);
879: show (key1);
880: show (key);
881: showpath ();
882: }
883:
884: stcpy0 (key1, key, k + 1);
885: level++;
886:
887: check ((long) (UNSIGN (blck[i]) * 65536 +
888: UNSIGN (blck[i + 1]) * 256 +
889: UNSIGN (blck[i + 2])));
890:
891: blck = block[--level];
892:
893: }
894:
895: i += PLEN;
896:
897: if (i > DATALIM) {
898: printf ("\tblock #%ld pointer in status bytes\012\015", blknbr);
899: showpath ();
900: }
901:
902: }
903:
904: if (i > offsets[level]) {
905: printf ("\tblock #%ld offset mismatch %ld vs. %d\012\015", blknbr, i, offsets[level]);
906: showpath ();
907: }
908: }
909: break;
910:
911: case DATA:
912: /* scan data block */
913: {
914: register long i;
915: register long k;
916: short len;
917: char key0[256];
918: char key1[256];
919:
920: if (type[level - 1] != BOTTOM) {
921: printf ("\tblock #%ld unexpected block type: DATA\012\015", blknbr);
922: showpath ();
923: }
924:
925: key1[0] = g_EOL;
926: i = 0;
927:
928: while (i < offsets[level]) {
929:
930: len = UNSIGN (blck[i++]);
931: len += (k = UNSIGN (blck[i++]));
932:
933: if (len > 255) {
934: printf ("\tblock #%ld key too long\012\015", blknbr);
935: showpath ();
936: i += len - k;
937: }
938: else {
939:
940: if (len == 0 && i > 2) {
941: printf ("\tblock #%ld empty key\012\015", blknbr);
942: showpath ();
943: }
944:
945: while (k < len) key0[k++] = blck[i++];
946:
947: key0[k] = g_EOL;
948:
949: if (key_check (key0)) {
950: printf ("\tblock #%ld illegal key\012\015", blknbr);
951: showpath ();
952: }
953:
954: if (g_collate (key1, key0) == 0) {
955: printf ("\tblock #%ld collation mismatch\012\015", blknbr);
956: show (key1);
957: show (key0);
958: showpath ();
959: }
960:
961: stcpy0 (key1, key0, k + 1);
962: }
963:
964: k = i + 1;
965: len = UNSIGN (blck[i]);
966: i += UNSIGN (blck[i]);
967: i++; /* skip data */
968:
969: #ifdef NEVER
970: while (k < i) {
971: if (blck[k++] & ~0177) {
972: printf ("\tblock #%ld illegal character in data string\012\015", blknbr);
973: showpath ();
974: break;
975: }
976: }
977: #endif /* NEVER */
978:
979: if (i > DATALIM) {
980: printf ("\tblock #%ld data in status bytes\012\015", blknbr);
981: showpath ();
982: }
983:
984: }
985:
986: if (i > offsets[level]) {
987: printf ("\tblock #%ld offset mismatch %ld vs. %d\012\015", blknbr, i, offsets[level]);
988: showpath ();
989: }
990: }
991: break;
992:
993: default:
994: printf ("\tblock #%ld illegal type %d\012\015", blknbr, type[level]);
995: showpath ();
996:
997: }
998:
999: return;
1000:
1001: } /* end check */
1002: void
1003: showpath ()
1004: { /* display path of pointers */
1005: int i;
1006:
1007: if (level > 1)
1008: for (i = 0; i < level; i++)
1009: printf (" path level(%d)=%ld\012\015", i, llink[i]);
1010: if (++exstat >= ERRLIM) {
1011: fprintf (stderr, "Error limit exceeded (%hd errors)\012\015", exstat, ERRLIM);
1012: return;
1013: }
1014: return;
1015: }
1016: /******************************************************************************/
1017: int key_check (char *key) /* checks a global key in compressed form */
1018: {
1019: short ch,
1020: typ = 0;
1021:
1022: while ((ch = UNSIGN (*key++)) != g_EOL) {
1023: if (ch == (DEL << 1)) {
1024: if ((ch = UNSIGN (*key++)) == (DEL << 1))
1025: key++;
1026: ch = SP;
1027: }
1028: if (ch >= SP) {
1029: if (typ == 2)
1030: return 1;
1031: typ = 1;
1032: }
1033: /* alphabetics */
1034: else {
1035: if (typ == 1)
1036: return 1;
1037: typ = 2; /* numerics '.' '-' */
1038: if (ch >= 20 && ch != POINT && ch != MINUS)
1039: return 1; /* illegal character */
1040: }
1041: if (ch & 01)
1042: typ = 0; /* comma between two indices */
1043: }
1044: return 0;
1045: } /* end key_check */
1046: /******************************************************************************/
1047: static short int
1048: g_collate (s, t) /* if 't' follows 's' in MUMPS collating */
1049: char s[]; /* sequence a TRUE is returned */
1050: char t[];
1051:
1052: {
1053: register int chs = *s;
1054: register int cht = *t;
1055: register int tx = 0;
1056: register int sx;
1057: short dif;
1058:
1059: /* the empty one is the leader! */
1060: if (chs == g_EOL) {
1061: if (cht == g_EOL)
1062: return 2;
1063: return 1;
1064: }
1065: if (cht == g_EOL)
1066: return FALSE;
1067:
1068: while (cht == s[tx]) {
1069: if (cht == g_EOL)
1070: return 0;
1071: cht = t[++tx];
1072: } /* (s==t) */
1073: chs = s[tx];
1074: if (chs == OMEGA)
1075: return 0;
1076: if (chs == ALPHA)
1077: return cht != g_EOL;
1078: if (chs == g_EOL && t[tx - 1] & 01)
1079: return 1;
1080: if (cht == g_EOL && s[tx - 1] & 01)
1081: return 0;
1082:
1083: /* vade retro usque ad comma */
1084: if (tx > 0) {
1085: tx--;
1086: while ((t[tx] & 01) == 0)
1087: if (--tx < 0)
1088: break;
1089: tx++;
1090: }
1091: chs = s[tx];
1092: cht = t[tx];
1093: if (UNSIGN (chs) <= POINT) { /* then come numerics */
1094: if (UNSIGN (cht) > POINT)
1095: return UNSIGN (cht) != g_EOL;
1096: /* both are numeric! now compare numeric values */
1097: /*****g_comp()*********************************************************/
1098: if (chs == MINUS) {
1099: if (cht != MINUS)
1100: return 1;
1101: } else {
1102: if (cht == MINUS)
1103: return 0;
1104: }
1105: if (chs == 1 && cht == POINT)
1106: return 1;
1107: if (cht == 1 && chs == POINT)
1108: return 0;
1109: dif = sx = tx;
1110: while (s[sx] != POINT) {
1111: if (s[sx++] & 01)
1112: break;
1113: }
1114: while (t[tx] != POINT) {
1115: if (t[tx++] & 01)
1116: break;
1117: }
1118: if (tx > sx)
1119: return (cht != MINUS);
1120: if (tx < sx)
1121: return (cht == MINUS);
1122: tx = dif;
1123: while ((cht >> 1) == (chs >> 1)) {
1124: if (cht & 01)
1125: return t[dif] == MINUS;
1126: if (chs & 01)
1127: return t[dif] != MINUS;
1128: chs = s[++tx];
1129: cht = t[tx];
1130: }
1131: return (((cht >> 1) > (chs >> 1)) == (t[dif] != MINUS))
1132: && (t[tx] != s[tx]);
1133: /**********************************************************************/
1134: }
1135: if (UNSIGN (cht) <= POINT)
1136: return 0;
1137: while ((dif = (UNSIGN (cht) >> 1) - (UNSIGN (chs) >> 1)) == 0) { /* ASCII collating */
1138: if ((cht & 01) && ((chs & 01) == 0))
1139: return 0;
1140: if ((chs & 01) && ((cht & 01) == 0))
1141: return 1;
1142: chs = s[++tx];
1143: cht = t[tx];
1144: }
1145: if (chs == g_EOL)
1146: return 1;
1147: if (cht == g_EOL)
1148: return 0;
1149: return dif > 0;
1150: } /* end g_collate */
1151: /******************************************************************************/
1152: void
1153: show (key)
1154: char key[]; /* key in internal format to be expanded and shown */
1155: {
1156: int k,
1157: ch,
1158: i,
1159: j;
1160: char data[256];
1161:
1162: k = 0;
1163: i = 0;
1164: j = 0;
1165: while ((ch = UNSIGN (key[i++])) != g_EOL) {
1166: if (k) {
1167: k = 0;
1168: if (ch > ' ')
1169: data[j++] = '"';
1170: }
1171: data[j] = (ch > SP ? (ch >> 1) : (ch < 20 ? (ch >> 1) + '0' : (ch >> 1) + ' '));
1172: if (data[j++] == '"')
1173: data[j++] = '"';
1174: if (ch & 01) {
1175: if (ch > SP)
1176: data[j++] = '"';
1177: data[j++] = ',';
1178: k = 1;
1179: }
1180: }
1181: data[j--] = 0;
1182: printf ("(%s);", data);
1183: return;
1184: } /* end show() */
1185: /******************************************************************************/