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