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