1: /*
2: * $Id: global_bltin.c,v 1.7 2025/03/24 04:13:11 snw Exp $
3: * freem database engine
4: *
5: *
6: * Author: Serena Willis <snw@coherent-logic.com>
7: * Copyright (C) 1998 MUG Deutschland
8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
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: *
26: * $Log: global_bltin.c,v $
27: * Revision 1.7 2025/03/24 04:13:11 snw
28: * Replace action macro dat with fra_dat to avoid symbol conflict on OS/2
29: *
30: * Revision 1.6 2025/03/24 01:33:30 snw
31: * Guard declaration of time function in global_bltin.c for portability
32: *
33: * Revision 1.5 2025/03/22 22:52:24 snw
34: * Add STRLEN_GBL macro to manage global string length
35: *
36: * Revision 1.4 2025/03/09 19:14:25 snw
37: * First phase of REUSE compliance and header reformat
38: *
39: *
40: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
41: * SPDX-License-Identifier: AGPL-3.0-or-later
42: **/
43:
44: #include <sys/types.h>
45: #include <sys/stat.h>
46: #include <fcntl.h>
47: #include <unistd.h>
48: #include <string.h>
49:
50: #include <errno.h>
51:
52:
53: #include "mpsdef.h"
54:
55: static void b_free (short filedes, unsigned long blknbr);
56: static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr);
57: static void update (short filedes, char *ins_key, long keyl);
58: static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr);
59: static void scanpblk (char *block, long *adr, long *fnd);
60: static void scandblk (char *block, long *adr, long *fnd);
61: static void getnewblk (int filedes, unsigned long *blknbr);
62: static short int g_collate (char *t);
63: //static short int g_numeric (char *str);
64: short g_numeric (char *str);
65: void close_all_globals(void);
66: static void panic (void);
67:
68: #define ROOT 0L
69:
70: /* end of line symbol in global module is 30, which is a code not */
71: /* otherwise used in subscripts */
72: #define g_EOL 30
73:
74: #define EOL1 EOL
75:
76: /* numerics (('.'<<1)&037)==28 ; (('-'<<1)&037)==26; */
77: #define POINT 28
78: #define MINUS 26
79:
80: /* ALPHA and OMEGA are dummy subscripts in $order processing */
81: /* ALPHA sorts before all other subscripts */
82: /* OMEGA sorts after all other subscripts */
83: /* e.g. ("abc") -> "abc",OMEGA ; ("abc","") -> "abc",ALPHA */
84: #define OMEGA 29
85: #define ALPHA 31
86:
87: /* length of blocks. status bytes defined as offset to blocklength */
88: /* BLOCKLEN 1024 is defined in mpsdef0 include file */
89: #define DATALIM (BLOCKLEN-11)
90: #define LLPTR (BLOCKLEN-10)
91: #define NRBLK LLPTR
92: #define COLLA (BLOCKLEN- 7)
93: #define RLPTR (BLOCKLEN- 6)
94: #define FREE RLPTR
95: #define BTYP (BLOCKLEN- 3)
96: #define OFFS (BLOCKLEN- 2)
97:
98: /* length of blockpointers in bytes */
99: #define PLEN 3
100:
101: #define EMPTY 0
102: #define FBLK 1
103: #define POINTER 2
104: #define BOTTOM 6
105: #define DATA 8
106:
107: #if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)
108: long time ();
109: #endif
110:
111: /* globals management */
112:
113: /* 0 = set_sym 1 = get_sym */
114: /* 2 = kill_sym 3 = $data */
115: /* 5 = $fra_order */
116: /* 7 = $fra_query */
117: /* */
118: /* 14=killone 13=getnext */
119: /* 16=merge_sym 17=$zdata */
120: /* gvn as ASCII-string */
121:
122: /* returns OK action fulfilled */
123: /* (ierr) UNDEF missing in action */
124: /* NAKED illegal naked reference */
125: /* SBSCR illegal subscript */
126: /* DBDGD data base degradation */
127:
128: /* The data is organized in a B* tree structure on external storage.
129: * For a description of the principles of the algorithms see
130: * Donald E. Knuth "The Art of Computer Programming" vol. 3 p. 478.
131: * This tree structure guarantees fast disk access and is the
132: * canonical way to implement M globals.
133: *
134: * Each M global occupies a separate UNIX file in the directory
135: * specified in the globals_path directive for the current namespace
136: * in /etc/freem.conf. The default namespace on a new installation
137: * of FreeM is called "USER".
138: *
139: * Any global whose name begins with "%" will always be stored in the
140: * SYSTEM namespace, in the directory specified in its "globals_path"
141: * directive in /etc/freem.conf (by default, /var/local/freem/SYSTEM/globals).
142: *
143: * The UNIX file names are the same as the corresponding M global
144: * names; i.e. beginning with an '^'. However it is possible to access
145: * globals in other directories if the path name is specified.
146: * E.g. "S ^/usr/mumps/test=1" does "S ^test=1" in the file /usr/mumps/^test.
147: * If FreeM is started with the -s/--standard switches, it is not possible
148: * to specify a directory. There is a syntactic ambiguity: the '/' character
149: * in the directory name is in conflict with the '/' divide operator. Use
150: * parentheses to make things clear:
151: *
152: * ^/usr/mumps/test/2 ; '/2' is part of the name
153: * (^/usr/mumps/test)/2 ; ambiguity resolved
154: * ^test/2 ; '/2' is a divide operation
155: * ^/usr/mumps/test("ok")/2 ; '/2' is a divide
156: *
157: * To prevent jobs from messing the globals up, access is regulated
158: * with the 'locking' mechanism. (that is different from mumps LOCKs)
159: *
160: * Data is organized in blocks of 1024 bytes (BLOCKLEN) with the following
161: * layout:
162: * byte 0 - 1013 'stuff' 0...DATALIM
163: * organization is:
164: * length of key (minus offset into previous key)
165: * offset into previous key
166: * key (without EOL character)
167: * length of data or two bytes as pointer
168: * data(without EOL character) in pointer blocks
169: *
170: * byte 1014 - 1016 leftlink pointer LLPTR
171: * in root block: number of blocks NRBLK
172: * byte 1017 <reserved>
173: * byte 1017 in root block: type of collating sequence COLLA
174: * LSB=0: numeric(standard) LSB=1: alphabetic
175: * byte 1018 - 1020 rightlink pointer RLPTR
176: * in root block: number of free blocks list FREE
177: * byte 1021 block type BTYP
178: * (2=POINTER,6=BOTTOM LEVEL POINTER,8=DATA)
179: * byte 1022 - 1023 offset OFFS
180: * (pointer to unused part of 'stuff')
181: *
182: * the file is *not* closed on return. since access is regulated by the
183: * locking mechanism, that will not spell trouble.
184: */
185:
186: void global_bltin (short action, char *key, char *data)
187: {
188:
189: /* these must be static variables */
190:
191: static short filedes; /* filedescr for global access */
192: static char filnam[256]; /* name of global/unix file */
193:
194: /* the following vars may be */
195: /* static or dynamic */
196:
197: static unsigned long blknbr; /* block number */
198: static unsigned long oldblk;
199: static unsigned long newblk;
200: static unsigned long other;
201: static long j1;
202: static long limit;
203: static short typ; /* block type */
204: static long keyl, /* length of compacted key */
205: datal, /* length of data */
206: olddatal,
207: offset,
208: found,
209: addr, /* address of key in 'block' */
210: needed, /* new bytes needed to ins. stuff */
211: ret_to, /* return code */
212: kill_again;
213: static char key1[256];
214: static char tmp1[256]; /* intermediate storage for op= */
215: static char block[BLOCKLEN];
216: static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */
217: static int tryfast; /* try fast access if get_sym on */
218: /* previous global */
219:
220: struct stat dinf; /* get modification date */
221:
222: long savj,
223: savch; /* saved j and ch for multiple pathes */
224: register long int i,
225: j,
226: k,
227: ch;
228: long pathscan; /* flag for repeated scan of pathlist setting an undef global */
229:
230:
231: /* process optional limitations */
232: if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {
233:
234: if ((i = glvnflag.one[0])) { /* number of significant chars */
235:
236: j = 0;
237: while ((k = key[j]) != DELIM && k != EOL) {
238:
239: if (j >= i) {
240:
241: while ((k = key[++j]) != DELIM && k != EOL);
242:
243: stcpy (&key[i], &key[j]);
244:
245: break;
246: }
247:
248: j++;
249:
250: }
251: }
252:
253: if (glvnflag.one[1]) { /* upper/lower sensitivity */
254:
255: j = 0;
256:
257: while ((k = key[j]) != DELIM && k != EOL) {
258:
259: if (k >= 'a' && k <= 'z') key[j] = k - 32;
260:
261: j++;
262:
263: }
264:
265: }
266:
267: if ((i = glvnflag.one[2])) {
268:
269: if (stlen (key) > i) {
270: merr_raise (M75);
271: return;
272: } /* key length limit */
273:
274: }
275:
276: if ((i = glvnflag.one[3])) { /* subscript length limit */
277:
278: j = 0;
279:
280: while ((k = key[j++]) != DELIM && k != EOL);
281:
282: if (k == DELIM) {
283:
284: k = 0;
285: for (;;) {
286:
287: k = key[j++];
288:
289: if (k == DELIM || k == EOL) {
290:
291: if (k > i) {
292: merr_raise (M75);
293: return;
294: }
295:
296: k = 0;
297: }
298:
299: if (k == EOL) break;
300:
301: k++;
302: }
303: }
304: }
305: }
306:
307: if (action == getnext) {
308:
309: getnflag = TRUE;
310: varnam[0] = EOL;
311:
312: if (zref[0] == EOL) {
313: merr_raise (M7);
314: data[0] = EOL;
315:
316: return;
317: }
318:
319: stcpy (key, zref);
320:
321: action = fra_query;
322: ordercnt = 1L;
323: }
324: else {
325:
326: getnflag = FALSE;
327:
328: /* naked reference section */
329:
330: if (key[1] == DELIM) { /* resolve naked reference */
331:
332: while (--nakoffs >= 0) { /* naked reference pointer */
333: if (zref[nakoffs] == DELIM) break;
334: }
335:
336: if ((i = ++nakoffs) == 0) { /* illegal naked reference */
337: data[0] = EOL1;
338: merr_raise (NAKED);
339:
340: return;
341: }
342:
343: j = 2;
344: while ((zref[i] = key[j++]) != EOL) {
345:
346: if ((++i) >= STRLEN) {
347: zref[255] = EOL;
348: merr_raise (M75);
349:
350: return;
351: }
352:
353: }
354: nakoffs = stcpy (key, zref);
355: }
356: else {
357:
358: /* only save off $REFERENCE if the global isn't part of SSVN backing storage */
359: if (key[1] != '$') {
360: nakoffs = stcpy (zref, key); /* save reference */
361: }
362:
363: }
364: }
365:
366: if (v22ptr) {
367:
368: procv22 (key);
369:
370: if (key[0] != '^') {
371: char losav[256];
372:
373: stcpy (losav, l_o_val);
374: symtab (action, key, data);
375: stcpy (g_o_val, l_o_val);
376: stcpy (l_o_val, losav);
377:
378: return;
379: }
380: }
381:
382: /* construct full UNIX filename */
383: savj = 0;
384: savch = ch = EOL;
385: pathscan = TRUE;
386: nextpath:
387: k = 0;
388: j = savj;
389:
390: if (key[1] == '%' || key[1] == '$') { /* %-globals and SSVN backing storage, no explicit path */
391:
392: if (gloplib[0] != EOL) {
393:
394: /* append % global access path */
395: while ((ch = filnam[k++] = gloplib[j++]) != ':' && ch != EOL);
396:
397: }
398:
399: }
400: else if (key[1] != '/') { /* no explicit path specified */
401:
402: if (glopath[0] != EOL) {
403:
404: /* append global access path */
405: while ((ch = filnam[k++] = glopath[j++]) != ':' && ch != EOL);
406:
407: }
408:
409: }
410:
411: if (savj == 0 && ch == EOL) pathscan = FALSE; /* one path only: inhibit search */
412:
413: if (k > 0) {
414:
415: if (k == 1 || (k == 2 && filnam[0] == '.')) {
416: k = 0;
417: }
418: else {
419: filnam[k - 1] = '/';
420: }
421:
422: }
423:
424: savch = ch;
425: savj = j;
426: i = 0;
427: j = 0;
428:
429: while (key[i] != EOL) {
430:
431: if ((filnam[k] = key[i]) == DELIM) break;
432:
433: if (filnam[k] == '/') {
434:
435: j = i;
436:
437: if (k > i) {
438: i = 0;
439: j = 0;
440: k = 0;
441:
442: continue;
443: }
444:
445: }
446:
447: i++;
448: k++;
449:
450: }
451:
452: filnam[k] = NUL; /* NUL not EOL !!! */
453:
454: /* if a unix directory is specified, reposition '^' */
455: /* '^/usr/test' becomes '/usr/^test' */
456: if (j > 0) {
457:
458: for (k = 0; k < j; k++) {
459: filnam[k] = filnam[k + 1];
460: }
461:
462: filnam[j] = '^';
463:
464: }
465:
466: /* compact key to internal format: characters are shifted left */
467: /* delimiters become LSB of previous character */
468: /* test subscripts for being numeric or not */
469: /* numeric values are shifted into the code space */
470: /* that is available because of illegal CTRL subscipts */
471:
472: k = 0;
473:
474: if (key[i] == EOL) { /* unsubscripted variable */
475:
476: if (action == fra_order) {
477: g_o_val[0] = EOL;
478: merr_raise (NEXTER);
479:
480: return;
481: }
482:
483: }
484: else if (key[++i] == EOL) { /* empty (first) subscript */
485:
486: if ((action != fra_order) && (action != fra_query)) {
487: merr_raise (SBSCR);
488: return;
489: }
490:
491: }
492: else { /* non empty subscript */
493:
494: j1 = g_numeric (&key[i]);
495:
496: while ((ch = key[i++]) != EOL) {
497:
498: if (ch == DELIM) {
499:
500: if (k == 0) {
501: merr_raise (SBSCR);
502: return;
503: }
504:
505: if (compactkey[--k] & 01) {
506: merr_raise (SBSCR);
507: return;
508: }
509:
510: compactkey[k++] |= 01;
511: j1 = g_numeric (&key[i]);
512:
513: }
514: else if (UNSIGN (ch) >= DEL) { /* transform 8bit char to 7bit */
515:
516: compactkey[k++] = (DEL << 1);
517: ch = UNSIGN (ch) - DEL;
518:
519: if (UNSIGN (ch) >= DEL) {
520: compactkey[k++] = (DEL << 1);
521: ch = UNSIGN (ch) - DEL;
522: }
523:
524: compactkey[k++] = ch << 1;
525:
526: }
527: else if (ch < SP || ch >= DEL) {
528:
529: /*no CTRLs */
530:
531: merr_raise (SBSCR);
532: return;
533: }
534: else {
535: compactkey[k++] = (j1 ? (ch << 1) & 036 : ch << 1);
536: }
537: }
538:
539: }
540:
541: if (action == fra_order) {
542:
543: if (ordercnt > 0) {
544:
545: compactkey[k] = (k == 0 || (compactkey[k - 1] & 01) ? ALPHA : OMEGA);
546:
547: if (k > 0) compactkey[k - 1] |= 01;
548:
549: keyl = (++k);
550:
551: }
552: else if (ordercnt == 0) { /* no scan at all */
553:
554: k = 0;
555: i = 0;
556:
557: while ((ch = key[i++]) != EOL) {
558: if (ch == DELIM) k = i;
559: }
560:
561: stcpy (data, &key[k]);
562: g_o_val[0] = EOL;
563:
564: return;
565:
566: }
567: else { /* backward scanning */
568:
569: if (k == 0 || (compactkey[k - 1] & 01)) {
570:
571: compactkey[k] = OMEGA;
572:
573: if (k > 0) compactkey[k - 1] |= 01;
574:
575: k++;
576:
577: }
578: else {
579: compactkey[k - 1] |= 01;
580: }
581:
582: keyl = k;
583: }
584:
585: }
586: else {
587:
588: if ((keyl = k) > 0) {
589:
590: if ((compactkey[--k] & 01) && (action != fra_query)) {
591: merr_raise (SBSCR);
592: return;
593: }
594:
595: compactkey[k++] |= 01;
596: }
597: }
598:
599: compactkey[k] = g_EOL;
600:
601: /* look whether file is already open */
602: tryfast = FALSE;
603: ch = usage[i = j = inuse];
604:
605: while (i < NO_GLOBLS) {
606:
607: k = 0;
608:
609: while (filnam[k] == oldfil[i][k]) {
610:
611: if (filnam[k++] == NUL) {
612:
613: filedes = olddes[i];
614:
615: if (inuse == i && action == get_sym) {
616:
617: tryfast = TRUE;
618:
619: if (usage[i] != (-1)) usage[i]++;
620: if (lonelyflag) goto tfast2;
621:
622: fstat (filedes, &dinf);
623:
624: if (g_ages[i] > dinf.st_mtime) goto tfast2;
625:
626: g_ages[i] = time (0L);
627:
628: goto tfast0;
629:
630: }
631:
632: inuse = i;
633:
634: if (usage[i] != (-1)) usage[i]++;
635:
636: goto lock;
637: }
638:
639: }
640:
641: if (ch < 0 || (usage[i] >= 0 && usage[i] < ch)) ch = usage[j = i];
642:
643: if (i++ == inuse) {
644: inuse = (-1);
645: i = 0;
646: }
647:
648: }
649:
650: inuse = j;
651: usage[j] = 1;
652:
653: /* close previous file */
654: if ((filedes = olddes[j]) > 0) {
655: close (filedes);
656: olddes[j] = 0;
657: }
658:
659: strcpy (oldfil[j], filnam); /* save current filename */
660:
661: reopen:
662:
663: for (;;) {
664:
665: errno = 0;
666:
667: if ((filedes = open (filnam, 2)) != -1) break;
668: if (errno == EINTR) continue;
669:
670: if (errno == EMFILE || errno == ENFILE) { /* too many open files now */
671: close_all_globals ();
672:
673: continue;
674: }
675:
676: break;
677: }
678:
679: if (filedes == -1) {
680:
681: usage[inuse] = 0;
682: oldfil[inuse][0] = NUL;
683: olddes[inuse] = 0;
684: g_ages[inuse] = 0;
685:
686: if ((pathscan || errno != ENOENT) && (savch != EOL)) goto nextpath; /* try next access path */
687:
688: /* file not found */
689: if (action != set_sym) {
690:
691: if (errno != ENOENT) {
692: merr_raise (PROTECT);
693: return;
694: }
695:
696: if (action == fra_dat || action == zdata) {
697: data[0] = '0';
698: data[1] = EOL1;
699:
700: return;
701: }
702:
703: data[0] = EOL1;
704:
705: if (action == get_sym || getnflag) {
706: merr_raise (M7);
707: data[0] = EOL;
708: }
709: else if (action == fra_order || action == fra_query) {
710: g_o_val[0] = EOL;
711: }
712:
713: return;
714: }
715:
716: if (errno != ENOENT) {
717: merr_raise (PROTECT);
718: return;
719: }
720:
721: if (pathscan) {
722: savj = 0;
723: savch = ch = EOL;
724: pathscan = FALSE;
725:
726: goto nextpath;
727: }
728:
729: if (setop) {
730:
731: tmp1[0] = EOL;
732: m_op (tmp1, data, setop);
733: setop = 0;
734:
735: if (merr () > OK) return;
736:
737: datal = stcpy (data, tmp1);
738: }
739:
740: for (i = 0; i < BLOCKLEN; block[i++] = 0); /* clear block */
741:
742: stcpy0 (&block[2], compactkey, (long) keyl);
743:
744: block[0] = keyl; /* $length of key */
745: j = i = keyl + 2;
746: block[i++] = 0;
747: block[i++] = 0;
748: block[i++] = ROOT + 1; /* block 1 = data */
749: block[BTYP] = BOTTOM;
750: block[COLLA] = 0; /* collating sequence */
751: block[OFFS] = i / 256;
752: block[OFFS + 1] = i % 256;
753: block[NRBLK] = 0;
754: block[NRBLK + 1] = 0;
755: block[NRBLK + 2] = ROOT + 1; /* nr. of blocks */
756:
757: /* create file, write_lock it and initialize root block */
758: for (;;) {
759:
760: errno = 0;
761:
762: if ((filedes = creat (filnam, 0666)) != -1) break;
763:
764: if (errno == EMFILE || errno == ENFILE) {
765: close_all_globals ();
766: continue;
767: }
768:
769: merr_raise (PROTECT);
770: return;
771: }
772:
773: if (lonelyflag == FALSE) locking (filedes, 1, 0L);
774:
775: for (;;) {
776:
777: errno = 0;
778:
779: lseek (filedes, ROOT * BLOCKLEN, 0);
780: write (filedes, block, BLOCKLEN);
781:
782: if (errno == 0) break;
783:
784: panic ();
785: }
786:
787: block[NRBLK] = 0;
788: block[NRBLK + 1] = 0;
789: block[NRBLK + 2] = ROOT; /* clear */
790:
791: /* copy and write length of data */
792: block[j] = k = stcpy (&block[j + 1], data);
793: block[i = k + j + 1] = 0; /* clear EOL symbol */
794: block[BTYP] = DATA; /* type */
795: block[OFFS] = i / 256;
796: block[OFFS + 1] = i % 256;
797:
798: for (;;) {
799:
800: errno = 0;
801: write (filedes, block, BLOCKLEN);
802:
803: if (errno == 0) break;
804:
805: lseek (filedes, (ROOT + 1L) * BLOCKLEN, 0);
806: panic ();
807:
808: }
809:
810: close (filedes);
811:
812: if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */
813:
814: /* close new file, so other users can find it */
815: return;
816: }
817:
818: olddes[inuse] = filedes; /* save current filedescriptor */
819:
820: /* request global for exclusive use */
821: /* odd numbered actions get read access (get_sym,data,fra_order) 3 */
822: /* even ones read/write access (set_sym,kill_sym) 1 */
823:
824: lock:
825:
826: if (action == get_sym) {
827:
828: tfast0:
829:
830: if (lonelyflag == FALSE) locking (filedes, 3, 0L);
831: if (tryfast) goto tfast1; /* try again last block */
832:
833: blknbr = oldblk = ROOT; /* start with ROOT block */
834:
835: for (;;) {
836:
837:
838: tfast1:
839:
840: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
841: read (filedes, block, BLOCKLEN);
842:
843:
844: tfast2:
845:
846: if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */
847:
848: offset = UNSIGN (block[OFFS]) * 256 +
849: UNSIGN (block[OFFS + 1]);
850: j = UNSIGN (block[0]);
851: i = 0;
852:
853: stcpy0 (key1, &block[2], j); /* get first key */
854:
855: ch = keyl; /* ch is a register! */
856:
857: while (i < offset) {
858:
859: j = UNSIGN (block[i++]); /* length of key - offset */
860: k = UNSIGN (block[i++]); /* offset into previous entry */
861:
862: #ifdef VERSNEW
863:
864: stcpy0 (&key0[k], &block[i], j);
865: i += j;
866: j += k;
867:
868: #else
869:
870: j += k;
871:
872: while (k < j) key1[k++] = block[i++]; /* get key */
873:
874: #endif /* VERSNEW */
875:
876: if (j != ch) { /* keys have different length */
877:
878: i += UNSIGN (block[i]);
879: i++;
880:
881: continue;
882:
883: }
884:
885: /* key1[j]=g_EOL; */
886: j = ch;
887:
888: do {
889: j--;
890: } while (compactkey[j] == key1[j]); /* compare keys */
891:
892:
893: if (j < 0) {
894:
895: k = UNSIGN (block[i++]);
896: stcpy0 (data, &block[i], k); /* get value */
897: data[k] = EOL1; /* append EOL */
898:
899: goto quit;
900:
901: }
902:
903: i += UNSIGN (block[i]);
904: i++; /* skip data */
905:
906: }
907:
908: /* fast access failed. try normal path */
909: if (tryfast) {
910: tryfast = FALSE;
911: goto tfast0;
912: }
913:
914: merr_raise (M7);
915: data[0] = EOL;
916:
917: goto quit; /* variable not found */
918: }
919: else {
920:
921: if (tryfast) {
922: tryfast = FALSE;
923: goto tfast0;
924: }
925:
926: if (typ == EMPTY) {
927:
928: if (blknbr == ROOT) {
929: close (filedes);
930: goto reopen;
931: }
932:
933: merr_raise (DBDGD);
934: goto quit;
935:
936: }
937:
938: }
939:
940: scanpblk (block, &addr, &found);
941:
942: addr += UNSIGN (block[addr]) + 2; /* skip key */
943:
944: if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) {
945: merr_raise (DBDGD);
946: goto quit;
947: }
948:
949: addr += PLEN; /* skip data */
950: oldblk = blknbr;
951:
952: if (merr () == INRPT) goto quit;
953:
954: }
955: } /* end of get_sym */
956:
957:
958: if (lonelyflag == FALSE) locking (filedes, (action & 01 ? 3 : 1), 0L);
959:
960: /* a KILL on an unsubscripted global deletes the entire file */
961: if (action == kill_sym && compactkey[0] == g_EOL) {
962:
963: lseek (filedes, ROOT, 0);
964:
965: /* note : UNIX does not tell other */
966: block[BTYP] = EMPTY; /* jobs that a file has been unlinked */
967:
968: /* as long as they keep it open. */
969: /* so we mark this global as EMPTY */
970: write (filedes, block, BLOCKLEN);
971:
972: if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */
973:
974: close (filedes);
975:
976: olddes[inuse] = 0;
977: oldfil[inuse][0] = NUL;
978: usage[inuse] = 0;
979:
980: unlink (filnam);
981:
982: return;
983: }
984:
985: k_again: /* entry point for repeated kill operations */
986:
987: /* scan tree for the proper position of key */
988: blknbr = oldblk = ROOT; /* start with ROOT block */
989: trx = (-1);
990:
991: for (;;) {
992:
993: if (++trx >= TRLIM) {
994: merr_raise (STKOV);
995: goto quit;
996: }
997:
998: traceblk[trx] = blknbr;
999: traceadr[trx] = 0;
1000:
1001: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1002: read (filedes, block, BLOCKLEN);
1003:
1004: typ = block[BTYP];
1005:
1006: if (typ == DATA) {
1007: scandblk (block, &addr, &found);
1008: break;
1009: }
1010:
1011: if (typ == EMPTY) {
1012:
1013: if (blknbr == ROOT) {
1014: close (filedes);
1015: goto reopen;
1016: }
1017:
1018: merr_raise (DBDGD);
1019: goto quit;
1020: }
1021:
1022: scanpblk (block, &addr, &found);
1023:
1024: traceadr[trx] = addr;
1025: addr += UNSIGN (block[addr]);
1026: addr += 2; /* skip key */
1027:
1028: if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) {
1029: merr_raise (DBDGD);
1030: goto quit;
1031: }
1032:
1033: addr += PLEN; /* skip data */
1034: oldblk = blknbr;
1035: }
1036:
1037: traceadr[trx] = addr;
1038:
1039: switch (action) {
1040:
1041: case set_sym:
1042:
1043: datal = stlen (data);
1044: offset = UNSIGN (block[OFFS]) * 256 +
1045: UNSIGN (block[OFFS + 1]);
1046:
1047: if (found != 2) { /* new entry */
1048:
1049: if (setop) {
1050:
1051: tmp1[0] = EOL;
1052:
1053: m_op (tmp1, data, setop);
1054:
1055: setop = 0;
1056:
1057: if (merr () > OK) return;
1058:
1059: datal = stcpy (data, tmp1);
1060:
1061: }
1062:
1063: needed = keyl + datal + 3;
1064:
1065: if ((offset + needed) > DATALIM) {
1066: ret_to = 'n'; /* n=new */
1067: goto splitd;
1068: }
1069:
1070:
1071: s10: {
1072: long len; /* insert key */
1073: char key0[256];
1074:
1075: i = 0;
1076:
1077: while (i < addr) { /* compute offset into previous entry */
1078:
1079: len = UNSIGN (block[i++]);
1080:
1081: #ifdef VERSNEW
1082:
1083: k = UNSIGN (block[i++]);
1084: stcpy0 (&key0[k], &block[i], len);
1085:
1086: i += len;
1087: key0[k + len] = g_EOL;
1088:
1089: #else
1090:
1091: len += (k = UNSIGN (block[i++]));
1092:
1093: while (k < len) key0[k++] = block[i++];
1094:
1095: key0[k] = g_EOL;
1096:
1097: #endif /* VERSNEW */
1098:
1099: i += UNSIGN (block[i]);
1100: i++; /* skip data */
1101:
1102: }
1103:
1104: k = 0;
1105:
1106: if (addr > 0) {
1107:
1108: while (compactkey[k] == key0[k]) {
1109:
1110: if (key[k] == g_EOL) break;
1111:
1112: k++;
1113:
1114: }
1115:
1116: /* do *not* fully compact numerics */
1117: if ((i = UNSIGN (compactkey[k])) <= POINT) {
1118:
1119: while (--k >= 0 && (UNSIGN (compactkey[k]) & 01) == 0);
1120:
1121: k++;
1122: }
1123:
1124: }
1125:
1126: needed -= k;
1127: i = (offset += needed);
1128: block[OFFS] = i / 256;
1129: block[OFFS + 1] = i % 256;
1130:
1131: while (i >= addr) {
1132: block[i] = block[i - needed];
1133: i--;
1134: }
1135:
1136: #ifdef VERSNEW
1137:
1138: i = addr;
1139: block[i++] = j1 = keyl - k;
1140: block[i++] = k;
1141:
1142: stcpy0 (&block[i], &compactkey[k], j1);
1143:
1144: i += j1;
1145: block[i++] = datal;
1146:
1147: stcpy0 (&block[i], data, datal);
1148:
1149: #else
1150:
1151: block[addr + 1] = k;
1152: j1 = k;
1153: i = addr + 2;
1154:
1155: while (k < keyl) block[i++] = compactkey[k++];
1156:
1157: block[addr] = k - j1;
1158: addr = i++;
1159: k = 0;
1160:
1161: while (k < datal) block[i++] = data[k++];
1162:
1163: block[addr] = k;
1164:
1165: #endif /* VERSNEW */
1166:
1167: }
1168:
1169: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1170: write (filedes, block, BLOCKLEN);
1171:
1172: if (traceadr[trx] == 0) update (filedes, compactkey, keyl);
1173:
1174: break;
1175: }
1176:
1177: /* there was a previous entry */
1178: addr += UNSIGN (block[addr]);
1179: addr += 2;
1180: olddatal = UNSIGN (block[addr]);
1181:
1182: if (setop) {
1183:
1184: stcpy0 (tmp1, &block[addr + 1], (long) olddatal);
1185:
1186: tmp1[olddatal] = EOL;
1187:
1188: m_op (tmp1, data, setop);
1189:
1190: setop = 0;
1191:
1192: if (merr () > OK) return;
1193:
1194: datal = stcpy (data, tmp1);
1195: }
1196:
1197: if ((j1 = olddatal - datal) != 0) {
1198:
1199: if (j1 > 0) { /* surplus space */
1200:
1201: i = addr + datal;
1202: k = offset;
1203: offset -= j1;
1204: j1 += i;
1205:
1206: stcpy0 (&block[i], &block[j1], offset - i);
1207:
1208: i = offset;
1209:
1210: while (i < k) block[i++] = 0; /* clear area */
1211:
1212: }
1213: else {
1214: /* if (j1<0) */
1215: /* we need more space */
1216:
1217: if ((offset - j1) > DATALIM) {
1218: /* block too small */
1219: ret_to = 'u'; /* u=update */
1220:
1221: goto splitd;
1222: }
1223:
1224: s20:
1225:
1226: i = offset;
1227: k = addr + olddatal;
1228: offset -= j1;
1229: j1 = offset;
1230:
1231: while (i > k) block[j1--] = block[i--];
1232:
1233: }
1234:
1235: /* overwrite */
1236: block[OFFS] = offset / 256;
1237: block[OFFS + 1] = offset % 256;
1238: block[addr] = datal;
1239:
1240: }
1241: else { /* if nothing changes, do not write */
1242:
1243: i = 0;
1244: j = addr + 1;
1245:
1246: while (i < datal) {
1247: if (block[j++] != data[i]) break;
1248:
1249: i++;
1250: }
1251:
1252: if (i == datal) goto quit;
1253:
1254: }
1255:
1256: stcpy0 (&block[++addr], data, (long) datal);
1257: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1258: write (filedes, block, BLOCKLEN);
1259: break;
1260:
1261:
1262: case fra_dat:
1263:
1264: data[0] = '0';
1265: data[1] = EOL1;
1266: data[2] = EOL1;
1267:
1268: if (found == 2) { /* ... advance to next entry */
1269: addr += UNSIGN (block[addr]);
1270: addr += 2; /* skip key */
1271: addr += UNSIGN (block[addr]);
1272: addr++; /* skip data */
1273:
1274: data[0] = '1';
1275: }
1276:
1277: {
1278: long len;
1279: char key0[256];
1280:
1281: /* get following entry, eventually in the next blk */
1282: offset = UNSIGN (block[OFFS]) * 256 +
1283: UNSIGN (block[OFFS + 1]);
1284:
1285: if (addr >= offset) {
1286:
1287: if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) {
1288:
1289: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1290: read (filedes, block, BLOCKLEN);
1291: j1 = UNSIGN (block[0]);
1292:
1293: i = 0;
1294: j = 2;
1295:
1296: while (i < j1) key0[i++] = block[j++];
1297:
1298: key0[i] = g_EOL;
1299:
1300: }
1301: else {
1302: goto quit;
1303: }
1304:
1305: }
1306: else {
1307:
1308: i = 0;
1309:
1310: while (i <= addr) { /* compute offset complete key */
1311: len = UNSIGN (block[i++]);
1312:
1313: #ifdef VERSNEW
1314:
1315: k = UNSIGN (block[i++]);
1316: stcpy0 (&key0[k], &block[i], len);
1317: key0[k + len] = g_EOL;
1318: i += len;
1319:
1320: #else
1321:
1322: len += (j = UNSIGN (block[i++]));
1323:
1324: while (j < len) key0[j++] = block[i++];
1325:
1326: key0[j] = g_EOL;
1327:
1328: #endif /* VERSNEW */
1329:
1330: i += UNSIGN (block[i]);
1331: i++; /* skip data */
1332: }
1333:
1334: }
1335:
1336: /* is it a descendant? */
1337: if (compactkey[0] == g_EOL && key0[0] != g_EOL) {
1338: data[1] = data[0];
1339: data[0] = '1';
1340:
1341: break;
1342: }
1343:
1344: i = 0;
1345:
1346: while (compactkey[i] == key0[i]) i++;
1347:
1348: if (compactkey[i] == g_EOL) {
1349: data[1] = data[0];
1350: data[0] = '1';
1351: }
1352: }
1353:
1354: break;
1355:
1356:
1357: case fra_order:
1358:
1359: if (ordercnt < 0) goto zinv;
1360:
1361: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
1362:
1363: if (addr >= offset) { /* look in next block */
1364:
1365: if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
1366: data[0] = EOL1;
1367: g_o_val[0] = EOL;
1368:
1369: goto quit;
1370: } /* no next block */
1371:
1372: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1373: read (filedes, block, BLOCKLEN);
1374: scandblk (block, &addr, &found);
1375:
1376: }
1377:
1378: {
1379: long len;
1380: int ch0;
1381: char scratch[256];
1382: char key0[256];
1383:
1384: i = 0;
1385:
1386: while (i <= addr) { /* compute offset complete key */
1387:
1388: len = UNSIGN (block[i++]);
1389: len += (j = UNSIGN (block[i++]));
1390:
1391: while (j < len) key0[j++] = block[i++];
1392:
1393: key0[j] = g_EOL;
1394: i += UNSIGN (block[i]);
1395:
1396: i++; /* skip data */
1397: }
1398:
1399: /* save data value for inspection with $V(111) */
1400: i = addr;
1401: i += UNSIGN (block[i]);
1402: i += 2; /* skip key */
1403: j = UNSIGN (block[i++]);
1404: stcpy0 (g_o_val, &block[i], j); /* get value */
1405: g_o_val[j] = EOL; /* append EOL */
1406:
1407: i = 0;
1408: j = 0;
1409:
1410: while ((scratch[j++] = UNSIGN (key0[i++])) != g_EOL);
1411:
1412: if (compactkey[--keyl] == ALPHA) keyl++;
1413:
1414: /* count subscripts of key */
1415: i = 0;
1416: j1 = 0;
1417:
1418: while (i < keyl) if (compactkey[i++] & 01)
1419:
1420: j1++;
1421: i = 0;
1422: j = 0;
1423: k = 0;
1424:
1425: while (i < keyl) {
1426:
1427: if (scratch[i] != compactkey[j++]) {
1428: k++;
1429: break;
1430: }
1431:
1432: if (scratch[i++] & 01) k++;
1433:
1434: }
1435:
1436: if (k < j1) {
1437: data[0] = EOL1;
1438: g_o_val[0] = EOL;
1439:
1440: goto quit;
1441: }
1442:
1443: while (--i >= 0) {
1444: if ((scratch[i] & 01)) break;
1445: }
1446:
1447: i++;
1448: j = 0;
1449:
1450: while ((ch = UNSIGN (scratch[i++])) != g_EOL) {
1451:
1452: ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
1453: (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
1454: (ch >> 1) + SP)); /* '.' or '-' */
1455:
1456:
1457: if (ch0 == DEL) {
1458:
1459: if (((ch = UNSIGN (scratch[i++])) >> 1) == DEL) {
1460: ch0 += DEL;
1461: ch = UNSIGN (scratch[i++]);
1462: }
1463:
1464: ch0 += (ch >> 1);
1465: }
1466:
1467: data[j++] = ch0;
1468:
1469: if (ch & 01) break;
1470:
1471: }
1472:
1473: /* forget that data value if $d=10 */
1474: if (UNSIGN (scratch[i]) != g_EOL) g_o_val[0] = EOL;
1475:
1476: data[j] = EOL1;
1477: ordercounter++;
1478:
1479: if (--ordercnt > 0) { /* repeated forward scanning */
1480:
1481: if (ch != g_EOL) scratch[i] = g_EOL;
1482:
1483: stcpy0 (compactkey, scratch, i + 1);
1484:
1485: compactkey[i - 1] |= 01;
1486: compactkey[i] = OMEGA;
1487: keyl = i + 1;
1488:
1489: goto k_again;
1490:
1491: }
1492:
1493: }
1494:
1495: break;
1496:
1497:
1498: case fra_query:
1499:
1500: if (ordercnt < 1) {
1501: merr_raise (ARGLIST);
1502: goto quit;
1503: }
1504:
1505: if (found == 2) { /* ... advance to next entry */
1506: addr += UNSIGN (block[addr]);
1507: addr += 2; /* skip key */
1508: addr += UNSIGN (block[addr]);
1509: addr++; /* skip data */
1510: }
1511:
1512: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
1513:
1514: while (--ordercnt > 0) { /* repeated forward query */
1515:
1516: addr += UNSIGN (block[addr]);
1517: addr += 2; /* skip key */
1518: addr += UNSIGN (block[addr]);
1519: addr++; /* skip data */
1520:
1521: if (addr >= offset) { /* look in next block */
1522:
1523: if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
1524: data[0] = EOL1;
1525:
1526: goto quit; /* no next block */
1527: }
1528:
1529: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1530: read (filedes, block, BLOCKLEN);
1531:
1532: addr = 0;
1533: offset = UNSIGN (block[OFFS]) * 256 +
1534: UNSIGN (block[OFFS + 1]);
1535: }
1536:
1537: }
1538:
1539: if (addr >= offset) { /* look in next block */
1540:
1541: if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
1542:
1543: if (getnflag) {
1544: zref[0] = EOL;
1545: merr_raise (ARGER);
1546: }
1547:
1548: data[0] = EOL1;
1549:
1550: goto quit; /* no next block */
1551: }
1552:
1553: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1554: read (filedes, block, BLOCKLEN);
1555:
1556: addr = 0;
1557: }
1558:
1559: {
1560: long len;
1561: char key0[256];
1562:
1563: i = 0;
1564:
1565: while (i <= addr) { /* compute offset complete key */
1566:
1567: len = UNSIGN (block[i++]);
1568: len += (j = UNSIGN (block[i++]));
1569:
1570: while (j < len) key0[j++] = block[i++];
1571:
1572: key0[j] = g_EOL;
1573: k = i; /* save i for getnflag processing */
1574: i += UNSIGN (block[i]);
1575: i++; /* skip data */
1576:
1577: }
1578:
1579: if (getnflag) {
1580:
1581: int ch0;
1582:
1583: i = k;
1584: k = UNSIGN (block[i++]);
1585:
1586: stcpy0 (data, &block[i], k); /* get value */
1587:
1588: data[k] = EOL1; /* append EOL */
1589: j = 0;
1590:
1591: while (zref[j] != DELIM && zref[j] != EOL) j++;
1592:
1593: if (zref[j] == EOL) zref[j] = DELIM;
1594:
1595: nakoffs = j;
1596: j++;
1597: i = 0; /* make this ref $ZR */
1598:
1599: while ((ch = UNSIGN (key0[i++])) != g_EOL) {
1600:
1601: ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
1602: (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
1603: (ch >> 1) + SP)); /* '.' or '-' */
1604:
1605:
1606: if (ch0 == DEL) {
1607:
1608: if (((ch = UNSIGN (key0[i++])) >> 1) == DEL) {
1609: ch0 += DEL;
1610: ch = UNSIGN (key0[i++]);
1611: }
1612:
1613: ch0 += (ch >> 1);
1614:
1615: }
1616:
1617: zref[j++] = ch0;
1618:
1619:
1620: if (j >= 252) {
1621: zref[j] = EOL;
1622: merr_raise (M75);
1623:
1624: goto quit;
1625: }
1626:
1627: if (ch & 01) {
1628: nakoffs = j;
1629: zref[j++] = DELIM;
1630: }
1631:
1632: }
1633:
1634: zref[--j] = EOL;
1635:
1636: break;
1637:
1638: }
1639: else { /* save data value for inspection with $V(111) */
1640:
1641: int ch0;
1642:
1643: i = addr;
1644: i += UNSIGN (block[i]);
1645: i += 2; /* skip key */
1646: j = UNSIGN (block[i++]);
1647:
1648: stcpy0 (g_o_val, &block[i], j); /* get value */
1649:
1650: g_o_val[j] = EOL; /* append EOL */
1651:
1652: j = 0;
1653: i = 0;
1654:
1655: while ((data[j] = zref[j]) != DELIM) {
1656:
1657: if (data[j] == EOL1) {
1658: data[j] = '(';
1659: break;
1660: }
1661:
1662: j++;
1663:
1664: }
1665:
1666: data[j++] = '(';
1667: k = 1;
1668:
1669: while ((ch = UNSIGN (key0[i++])) != g_EOL) {
1670: int typ;
1671:
1672: if (k) {
1673: k = 0;
1674:
1675: if ((typ = (ch > SP))) data[j++] = '"';
1676: }
1677:
1678: ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
1679: (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
1680: (ch >> 1) + SP)); /* '.' or '-' */
1681:
1682: if (ch0 == DEL) {
1683:
1684: if (((ch = UNSIGN (key0[i++])) >> 1) == DEL) {
1685: ch0 += DEL;
1686: ch = UNSIGN (key0[i++]);
1687: }
1688:
1689: ch0 += (ch >> 1);
1690: }
1691:
1692: data[j] = ch0;
1693:
1694: if (j >= 252) {
1695: data[j] = EOL1;
1696: merr_raise (M75);
1697:
1698: goto quit;
1699: }
1700:
1701: if (data[j++] == '"') data[j++] = '"';
1702:
1703: if (ch & 01) {
1704:
1705: if (typ) data[j++] = '"';
1706:
1707: data[j++] = ',';
1708: k = 1;
1709:
1710: }
1711: }
1712:
1713: data[j--] = EOL1;
1714: data[j] = ')';
1715:
1716: }
1717: }
1718:
1719: break;
1720:
1721:
1722: case kill_sym: /* search and destroy */
1723:
1724: killo: /* entry from killone section */
1725: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
1726:
1727: i = 0;
1728: key1[0] = g_EOL;
1729:
1730: while (i < addr) { /* compute complete key */
1731:
1732: k = UNSIGN (block[i++]);
1733: k += (j = UNSIGN (block[i++]));
1734:
1735: while (j < k) key1[j++] = block[i++];
1736:
1737: key1[j] = g_EOL;
1738: i += UNSIGN (block[i]);
1739:
1740: i++; /* skip data */
1741:
1742: }
1743:
1744: /* look whether there's something to do at all */
1745: if (found != 2) { /* is it a descendant ? */
1746:
1747: char key0[256];
1748: long trxsav;
1749:
1750: if (addr >= offset) { /* nothing to kill in that block */
1751:
1752: blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]);
1753:
1754: if (blknbr == 0) break; /* there is no next block */
1755:
1756: /* maybe there's something in the next block ... */
1757: trxsav = trx;
1758:
1759: for (;;) {
1760:
1761: other = traceblk[--trx];
1762: addr = traceadr[trx];
1763:
1764: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
1765: read (filedes, block, BLOCKLEN);
1766:
1767: addr += UNSIGN (block[addr]);
1768: addr += (2 + PLEN); /* skip previous entry */
1769: offset = UNSIGN (block[OFFS]) * 256 +
1770: UNSIGN (block[OFFS + 1]);
1771: traceadr[trx] = addr;
1772:
1773: if (addr < offset) break;
1774:
1775: traceadr[trx] = 0;
1776: traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +
1777: UNSIGN (block[RLPTR + 1]) * 256 +
1778: UNSIGN (block[RLPTR + 2]);
1779:
1780: }
1781:
1782: trx = trxsav;
1783:
1784: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
1785: read (filedes, block, BLOCKLEN);
1786:
1787: offset = UNSIGN (block[OFFS]) * 256 +
1788: UNSIGN (block[OFFS + 1]);
1789: addr = 0;
1790: k = UNSIGN (block[0]);
1791: stcpy0 (key0, &block[2], k);
1792: key0[k] = g_EOL;
1793:
1794: }
1795: else { /* get following entry */
1796:
1797: stcpy0 (key0, key1, j);
1798: i = addr;
1799: k = UNSIGN (block[i++]);
1800: k += (j = UNSIGN (block[i++]));
1801:
1802: while (j < k) key0[j++] = block[i++];
1803:
1804: key0[j] = g_EOL;
1805: }
1806:
1807: /* is it a descendant? */
1808: i = 0;
1809:
1810: while (compactkey[i] == key0[i]) i++;
1811:
1812: if (compactkey[i] != g_EOL) break; /* nothing to kill */
1813: }
1814:
1815: /* scan this block for all descendants */
1816: {
1817:
1818: long begadr, endadr, len;
1819: char key0[256];
1820:
1821: stcpy0 (key0, compactkey, (long) keyl);
1822:
1823: begadr = endadr = i = addr;
1824:
1825: if (action == killone) {
1826:
1827: i += UNSIGN (block[i]);
1828: i += 2; /* skip key */
1829: i += UNSIGN (block[i]);
1830: i++; /* skip data */
1831:
1832: endadr = i;
1833: }
1834: else {
1835:
1836: while (i < offset) {
1837:
1838: len = UNSIGN (block[i++]);
1839: k = j = UNSIGN (block[i++]);
1840:
1841: if (k >= keyl) {
1842: i += len;
1843: }
1844: else {
1845:
1846: len += k;
1847:
1848: while (j < len) key0[j++] = block[i++];
1849:
1850: key0[j] = g_EOL;
1851:
1852: /* k=0; ueberfluessig */
1853: while (compactkey[k] == key0[k]) {
1854:
1855: if (compactkey[k] == g_EOL) break;
1856:
1857: k++;
1858: }
1859:
1860: if (compactkey[k] != g_EOL) break; /* no descendant */
1861:
1862: }
1863:
1864: i += UNSIGN (block[i]);
1865: i++; /* skip data */
1866: endadr = i;
1867:
1868: }
1869:
1870: }
1871:
1872: kill_again = (endadr == offset && action != killone); /* may be there's more to kill */
1873:
1874: if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */
1875:
1876: long left,
1877: right;
1878: char block0[BLOCKLEN];
1879:
1880: p_empty: /* entry if pointer block goes empty */
1881:
1882: left = UNSIGN (block[LLPTR]) * 65536 +
1883: UNSIGN (block[LLPTR + 1]) * 256 +
1884: UNSIGN (block[LLPTR + 2]);
1885: right = UNSIGN (block[RLPTR]) * 65536 +
1886: UNSIGN (block[RLPTR + 1]) * 256 +
1887: UNSIGN (block[RLPTR + 2]);
1888:
1889: if (left) {
1890:
1891: lseek (filedes, (long) left * (long) (BLOCKLEN), 0);
1892: read (filedes, block0, BLOCKLEN);
1893:
1894: block0[RLPTR] = block[RLPTR];
1895: block0[RLPTR + 1] = block[RLPTR + 1];
1896: block0[RLPTR + 2] = block[RLPTR + 2];
1897:
1898: lseek (filedes, (long) left * (long) (BLOCKLEN), 0);
1899: write (filedes, block0, BLOCKLEN);
1900:
1901: }
1902:
1903: if (right) {
1904:
1905: lseek (filedes, (long) right * (long) (BLOCKLEN), 0);
1906: read (filedes, block0, BLOCKLEN);
1907:
1908: block0[LLPTR] = block[LLPTR];
1909: block0[LLPTR + 1] = block[LLPTR + 1];
1910: block0[LLPTR + 2] = block[LLPTR + 2];
1911:
1912: lseek (filedes, (long) right * (long) (BLOCKLEN), 0);
1913: write (filedes, block0, BLOCKLEN);
1914:
1915: }
1916:
1917: b_free (filedes, blknbr); /* modify free list */
1918:
1919: /* delete pointer */
1920: /**************************/
1921: {
1922: long trxsav;
1923: long freecnt;
1924:
1925: trxsav = trx;
1926:
1927: blknbr = traceblk[--trx];
1928: addr = traceadr[trx];
1929:
1930: lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0);
1931: read (filedes, block, BLOCKLEN);
1932: offset = UNSIGN (block[OFFS]) * 256 +
1933: UNSIGN (block[OFFS + 1]);
1934: freecnt = UNSIGN (block[addr]) + 2 + PLEN;
1935:
1936: /* delete key */
1937: offset -= freecnt;
1938:
1939: if (offset == 0) { /* pointer block went empty */
1940:
1941: if (blknbr == ROOT) { /* global went empty */
1942:
1943: lseek (filedes, 0L, 0);
1944:
1945: /* note : UNIX does not tell other */
1946: block[BTYP] = EMPTY; /* jobs that a file has been unlinked */
1947:
1948: /* as long as they keep it open. */
1949: /* so we mark this global as EMPTY */
1950: write (filedes, block, BLOCKLEN);
1951: close (filedes);
1952: unlink (filnam);
1953:
1954: if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */
1955:
1956: olddes[inuse] = 0;
1957: oldfil[inuse][0] = NUL;
1958: usage[inuse] = 0;
1959:
1960: return;
1961:
1962: }
1963:
1964: goto p_empty; /* clear pointer block */
1965:
1966: }
1967:
1968: block[OFFS] = offset / 256;
1969: block[OFFS + 1] = offset % 256;
1970:
1971: stcpy0 (&block[addr], &block[addr + freecnt], (long) (offset - addr));
1972:
1973: for (i = offset; i < offset + freecnt; block[i++] = 0);
1974:
1975: lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0);
1976: write (filedes, block, BLOCKLEN);
1977:
1978: if (addr == 0) { /* update of pointer */
1979: traceadr[trx] = 0;
1980:
1981: update (filedes, &block[2], (long) UNSIGN (block[0]));
1982: }
1983:
1984: trx = trxsav;
1985:
1986: }
1987:
1988: if (kill_again) goto k_again;
1989:
1990: break;
1991: }
1992:
1993: i = begadr;
1994: j = endadr;
1995:
1996: while (j < offset) block[i++] = block[j++];
1997: while (i < offset) block[i++] = 0;
1998:
1999: /** clear rest */
2000: offset += (begadr - endadr);
2001: if (begadr < offset && block[begadr + 1]) { /* new key_offset for next entry */
2002: i = block[begadr];
2003: j = block[begadr + 1];
2004: k = 0;
2005: if (begadr)
2006: while (key0[k] == key1[k])
2007: k++; /* new key_offset */
2008: if (k < j) {
2009: ch = j - k; /* space requirement */
2010: block[begadr] = i + ch; /* new key_length */
2011: block[begadr + 1] = k; /* new key_offset */
2012: i = offset;
2013: j = i + ch;
2014: offset = j;
2015: begadr++;
2016: while (i > begadr)
2017: block[j--] = block[i--];
2018: stcpy0 (&block[begadr + 1], &key0[k], ch);
2019: }
2020: }
2021: block[OFFS] = offset / 256;
2022: block[OFFS + 1] = offset % 256;
2023: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2024: write (filedes, block, BLOCKLEN);
2025: if (addr < 3) { /* update of pointer */
2026: traceadr[trx] = 0;
2027: update (filedes, &block[2], (long) UNSIGN (block[0]));
2028: }
2029: }
2030:
2031: if (kill_again) goto k_again;
2032:
2033: break;
2034:
2035: zinv:
2036:
2037: {
2038: long len;
2039: int ch0;
2040: char scratch[256];
2041: char key0[256];
2042:
2043: if (addr <= 0) { /* look in previous block */
2044:
2045: if ((blknbr = UNSIGN (block[LLPTR]) * 65536 + UNSIGN (block[LLPTR + 1]) * 256 + UNSIGN (block[LLPTR + 2])) == 0) {
2046: data[0] = EOL1;
2047: goto quit;
2048: } /* no previous block */
2049:
2050: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2051: read (filedes, block, BLOCKLEN);
2052:
2053: addr = UNSIGN (block[OFFS]) * 256 +
2054: UNSIGN (block[OFFS + 1]);
2055:
2056: }
2057:
2058: i = 0;
2059:
2060: while (i < addr) { /* compute offset complete key */
2061:
2062: len = UNSIGN (block[i++]);
2063: len += (j = UNSIGN (block[i++]));
2064:
2065: while (j < len) key0[j++] = block[i++];
2066:
2067: key0[j] = g_EOL;
2068: j1 = i;
2069: i += UNSIGN (block[i]);
2070: i++; /* skip data */
2071:
2072: }
2073:
2074: /* save data value for inspection with $V(111) */
2075: j = UNSIGN (block[j1++]);
2076:
2077: stcpy0 (g_o_val, &block[j1], j); /* get value */
2078: g_o_val[j] = EOL; /* append EOL */
2079:
2080: i = 0;
2081: j = 0;
2082:
2083: while ((scratch[j++] = UNSIGN (key0[i++])) != g_EOL);
2084:
2085: /* count subscripts of key */
2086: i = 0;
2087: j1 = 0;
2088:
2089: while (i < keyl) {
2090:
2091: if (compactkey[i++] & 01) {
2092: j1++;
2093: }
2094:
2095: }
2096:
2097: i = 0;
2098: j = 0;
2099: k = 0;
2100:
2101: while (i < keyl) {
2102:
2103: if (scratch[i] != compactkey[j++]) {
2104: k++;
2105: break;
2106: }
2107:
2108: if (scratch[i++] & 01) k++;
2109:
2110: }
2111:
2112: if (k < j1) {
2113: data[0] = EOL1;
2114: g_o_val[0] = EOL;
2115:
2116: goto quit;
2117: }
2118:
2119: while (--i >= 0) {
2120: if ((scratch[i] & 01)) break;
2121: }
2122:
2123: i++;
2124: j = 0;
2125:
2126: while ((ch = UNSIGN (scratch[i++])) != g_EOL) {
2127:
2128: ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
2129: (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
2130: (ch >> 1) + SP)); /* '.' or '-' */
2131:
2132: if (ch0 == DEL) {
2133:
2134: if (((ch = UNSIGN (scratch[i++])) >> 1) == DEL) {
2135: ch0 += DEL;
2136: ch = UNSIGN (scratch[i++]);
2137: }
2138:
2139: ch0 += (ch >> 1);
2140:
2141: }
2142:
2143: data[j++] = ch0;
2144:
2145: if (ch & 01) break;
2146:
2147: }
2148:
2149: data[j] = EOL1;
2150:
2151: if (j == 0) break;
2152:
2153: ordercounter++;
2154:
2155: if (ordercnt++ < (-1)) { /* repeated backward scanning */
2156:
2157: if (ch != g_EOL) scratch[i] = g_EOL;
2158:
2159: stcpy0 (compactkey, scratch, i + 1);
2160:
2161: compactkey[i - 1] |= 01;
2162: keyl = i;
2163:
2164: goto k_again;
2165:
2166: }
2167:
2168: }
2169:
2170: break;
2171:
2172:
2173: case zdata: /* nonstandard data function */
2174:
2175: {
2176: long counties[128];
2177: char key0[256];
2178: int icnt, icnt0, len;
2179:
2180: i = 0;
2181:
2182: while (i < 128) counties[i++] = 0L; /* init count; */
2183:
2184: if (found == 2) { /* ... advance to next entry */
2185: addr += UNSIGN (block[addr]);
2186: addr += 2; /* skip key */
2187: addr += UNSIGN (block[addr]);
2188: addr++; /* skip data */
2189:
2190: counties[0] = 1L;
2191: }
2192:
2193: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
2194: icnt = 0;
2195: i = 0;
2196:
2197: while ((ch = compactkey[i++]) != g_EOL) {
2198:
2199: if (ch & 01) {
2200: icnt++;
2201: }
2202:
2203: }
2204:
2205: len = i - 1;
2206: i = 0;
2207:
2208: while (i < addr) { /* compute offset complete key */
2209:
2210: icnt0 = UNSIGN (block[i++]);
2211: icnt0 += (j = UNSIGN (block[i++]));
2212:
2213: while (j < icnt0) key0[j++] = block[i++];
2214:
2215: key0[j] = g_EOL;
2216: i += UNSIGN (block[i]);
2217:
2218: i++; /* skip data */
2219:
2220: }
2221:
2222: for (;;) { /* is it still a descendant ??? */
2223:
2224: if (addr >= offset) { /* look in next block */
2225:
2226: if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
2227: break; /* no next block */
2228: }
2229:
2230: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2231: read (filedes, block, BLOCKLEN);
2232:
2233: addr = 0;
2234: offset = UNSIGN (block[OFFS]) * 256 +
2235: UNSIGN (block[OFFS + 1]);
2236:
2237: }
2238:
2239: i = UNSIGN (block[addr++]);
2240: i += (j = UNSIGN (block[addr++]));
2241:
2242: while (j < i) key0[j++] = block[addr++];
2243:
2244: addr += UNSIGN (block[addr]);
2245: addr++; /* skip data */
2246: icnt0 = 0;
2247: i = 0;
2248:
2249: while (i < j) if (key0[i++] & 01)
2250:
2251: icnt0++;
2252:
2253: if (icnt0 <= icnt) break;
2254:
2255: i = 0;
2256:
2257: while (i < len) {
2258:
2259: if (key0[i] != compactkey[i]) break;
2260:
2261: i++;
2262:
2263: }
2264:
2265: if (i < len) break;
2266:
2267: counties[icnt0 - icnt]++;
2268:
2269: }
2270:
2271: i = 128;
2272:
2273: while (counties[--i] == 0L);
2274:
2275: lintstr (data, counties[0]);
2276:
2277: j = 1;
2278: tmp1[0] = ',';
2279:
2280: while (j <= i) {
2281: lintstr (&tmp1[1], counties[j++]);
2282: stcat (data, tmp1);
2283: }
2284:
2285: }
2286:
2287: break;
2288:
2289: case getinc:
2290:
2291: {
2292: int setopsav;
2293:
2294: setopsav = setop;
2295: setop = '+';
2296: data[0] = '1';
2297: data[1] = EOL;
2298:
2299: global (set_sym, key, data);
2300:
2301: setop = setopsav;
2302:
2303: return;
2304: }
2305:
2306: case killone:
2307:
2308: {
2309: if (found == 2) goto killo; /* entry found use normal kill routine */
2310:
2311: goto quit;
2312: }
2313:
2314: case merge_sym:
2315:
2316: printf("MERGE NOT IMPLEMENTED FOR GLOBALS\n");
2317:
2318: #ifdef DEBUG_GBL
2319:
2320: int loop;
2321:
2322: printf ("DEBUG MERGE: ");
2323: printf ("[key] is [");
2324:
2325: for (loop = 0; key[loop] != EOL; loop++) printf ("%c", (key[loop] == DELIM) ? '!' : key[loop]);
2326:
2327: printf ("]\r\n");
2328: printf ("[data] is [");
2329:
2330: for(loop = 0; data[loop] != EOL; loop++) printf ("%c", (data[loop] == DELIM) ? '!' : data[loop]);
2331:
2332: printf("]\r\n");
2333:
2334: #endif
2335: return;
2336:
2337: default:
2338:
2339: merr_raise (INVREF); /* accidental call with wrong action code (v22-stuff) */
2340: } /* end of switch */
2341:
2342: quit:
2343:
2344: /* clean things up */
2345:
2346: lseek (filedes, ROOT, 0);
2347:
2348: if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */
2349:
2350: return;
2351:
2352:
2353: splitd: /* split data block in two sections */
2354:
2355: /* part of the data is taken to an other location. */
2356: /* old information in 'block' stored at 'blknbr' */
2357: /* 'addr' there I would like to insert, if possible (which is not) */
2358: /* 'offset' filled up to this limit */
2359:
2360: getnewblk (filedes, &newblk); /* get a new block */
2361:
2362: /* if we have to insert at the begin or end of a block */
2363: /* we don't split - we just start a new block */
2364: /* if an insert in the midst of a block, we split */
2365:
2366: if (addr >= offset) {
2367: long right,
2368: right1,
2369: right2;
2370:
2371: right = UNSIGN (block[RLPTR]);
2372: right1 = UNSIGN (block[RLPTR + 1]);
2373: right2 = UNSIGN (block[RLPTR + 2]);
2374: block[RLPTR] = newblk / 65536;
2375: block[RLPTR + 1] = newblk % 65536 / 256;
2376: block[RLPTR + 2] = newblk % 256;
2377:
2378: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2379: write (filedes, block, BLOCKLEN);
2380:
2381: block[RLPTR] = right;
2382: block[RLPTR + 1] = right1;
2383: block[RLPTR + 2] = right2;
2384: block[LLPTR] = blknbr / 65536;
2385: block[LLPTR + 1] = blknbr % 65536 / 256;
2386: block[LLPTR + 2] = blknbr % 256;
2387: offset = 0;
2388: addr = 0;
2389: blknbr = newblk;
2390:
2391: insert (filedes, compactkey, keyl, newblk);
2392:
2393: /* up-date LL-PTR of RL-block */
2394: if ((other = right * 65536 + right1 * 256 + right2)) {
2395:
2396: char block0[BLOCKLEN];
2397:
2398: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2399: read (filedes, block0, BLOCKLEN);
2400:
2401: block0[LLPTR] = blknbr / 65536;
2402: block0[LLPTR + 1] = blknbr % 65536 / 256;
2403: block0[LLPTR + 2] = blknbr % 256;
2404:
2405: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2406: write (filedes, block0, BLOCKLEN);
2407:
2408: }
2409:
2410: goto spltex;
2411: }
2412:
2413: if (addr == 0) {
2414: long left, left1, left2;
2415:
2416: left = UNSIGN (block[LLPTR]);
2417: left1 = UNSIGN (block[LLPTR + 1]);
2418: left2 = UNSIGN (block[LLPTR + 2]);
2419:
2420: block[LLPTR] = newblk / 65536;
2421: block[LLPTR + 1] = newblk % 65536 / 256;
2422: block[LLPTR + 2] = newblk % 256;
2423:
2424: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2425: write (filedes, block, BLOCKLEN);
2426:
2427: block[LLPTR] = left;
2428: block[LLPTR + 1] = left1;
2429: block[LLPTR + 2] = left2;
2430: block[RLPTR] = blknbr / 65536;
2431: block[RLPTR + 1] = blknbr % 65536 / 256;
2432: block[RLPTR + 2] = blknbr % 256;
2433: offset = 0;
2434: blknbr = newblk;
2435: traceadr[trx] = (-1); /* inhibit second update of pointers */
2436:
2437: insert (filedes, compactkey, keyl, newblk);
2438:
2439: if (addr < 3) { /* update of pointer */
2440: traceadr[trx] = 0;
2441:
2442: update (filedes, compactkey, keyl);
2443: }
2444:
2445: /* other is ***always*** zero !!!
2446: * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block
2447: * { char block0[BLOCKLEN];
2448: * lseek(filedes,(long)other*(long)(BLOCKLEN),0);
2449: * read(filedes,block0,BLOCKLEN);
2450: * block0[RLPTR ]=blknbr/65536;
2451: * block0[RLPTR+1]=blknbr%65536/256;
2452: * block0[RLPTR+2]=blknbr%256;
2453: * lseek(filedes,(long)other*(long)(BLOCKLEN),0);
2454: * write(filedes,block0,BLOCKLEN);
2455: * }
2456: */
2457:
2458: goto spltex;
2459:
2460: }
2461:
2462: {
2463: char block0[BLOCKLEN];
2464: char key0[256];
2465: int newlimit;
2466:
2467: block0[BTYP] = DATA;
2468:
2469: /* now search for a dividing line */
2470: limit = (offset + needed) / 2;
2471: i = (offset - needed) / 2;
2472:
2473: if (addr < i) limit = i;
2474:
2475: i = 0;
2476: newlimit = i;
2477:
2478: while (i < limit) {
2479:
2480: newlimit = i;
2481: j = UNSIGN (block[i++]); /* length of key - offset */
2482: k = UNSIGN (block[i++]); /* offset into previous entry */
2483: j += k;
2484:
2485: while (k < j) key0[k++] = block[i++]; /* get key */
2486:
2487: key0[k] = g_EOL;
2488: i += UNSIGN (block[i]);
2489: i++; /* skip data */
2490:
2491: }
2492:
2493: limit = newlimit;
2494: i = newlimit;
2495:
2496: j = i;
2497: i = 0; /* copy part of old to new blk */
2498:
2499: if ((k = UNSIGN (block[j + 1])) != 0) { /* expand key */
2500:
2501: block0[i++] = UNSIGN (block[j++]) + k;
2502: block0[i++] = 0;
2503:
2504: if (addr > limit) addr += k;
2505:
2506: j = 0;
2507:
2508: while (j < k) block0[i++] = key0[j++];
2509:
2510: j = limit + 2;
2511:
2512: }
2513:
2514: while (j < offset) {
2515:
2516: block0[i++] = block[j];
2517: block[j] = 0;
2518:
2519: j++;
2520:
2521: }
2522:
2523: while (i <= DATALIM) block0[i++] = 0; /* clear rest of block */
2524:
2525: offset -= limit;
2526:
2527: if (k > 0) offset += k; /* new offsets */
2528:
2529: block[OFFS] = limit / 256;
2530: block[OFFS + 1] = limit % 256;
2531: block0[OFFS] = offset / 256;
2532: block0[OFFS + 1] = offset % 256;
2533:
2534: if (addr <= limit) { /* save new block away */
2535:
2536: /* update rightlink and leftlink pointers */
2537: other = UNSIGN (block[RLPTR]) * 65536 +
2538: UNSIGN (block[RLPTR + 1]) * 256 +
2539: UNSIGN (block[RLPTR + 2]);
2540: block0[RLPTR] = block[RLPTR];
2541: block0[RLPTR + 1] = block[RLPTR + 1];
2542: block0[RLPTR + 2] = block[RLPTR + 2];
2543: block[RLPTR] = newblk / 65536;
2544: block[RLPTR + 1] = newblk % 65536 / 256;
2545: block[RLPTR + 2] = newblk % 256;
2546: block0[LLPTR] = blknbr / 65536;
2547: block0[LLPTR + 1] = blknbr % 65536 / 256;
2548: block0[LLPTR + 2] = blknbr % 256;
2549:
2550: lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);
2551: write (filedes, block0, BLOCKLEN);
2552:
2553: offset = limit;
2554: /* insert new block in pointer structure */
2555:
2556: insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);
2557:
2558: /* up-date LL-PTR of RL-block */
2559: if (other != 0) {
2560:
2561: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2562: read (filedes, block0, BLOCKLEN);
2563:
2564: block0[LLPTR] = newblk / 65536;
2565: block0[LLPTR + 1] = newblk % 65536 / 256;
2566: block0[LLPTR + 2] = newblk % 256;
2567:
2568: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2569: write (filedes, block0, BLOCKLEN);
2570:
2571: }
2572:
2573: }
2574: else {
2575: /* save old block away and make new block the current block */
2576: /* update rightlink and leftlink pointers */
2577: other = UNSIGN (block[RLPTR]) * 65536 +
2578: UNSIGN (block[RLPTR + 1]) * 256 +
2579: UNSIGN (block[RLPTR + 2]);
2580: block0[RLPTR] = block[RLPTR];
2581: block0[RLPTR + 1] = block[RLPTR + 1];
2582: block0[RLPTR + 2] = block[RLPTR + 2];
2583: block[RLPTR] = newblk / 65536;
2584: block[RLPTR + 1] = newblk % 65536 / 256;
2585: block[RLPTR + 2] = newblk % 256;
2586: block0[LLPTR] = blknbr / 65536;
2587: block0[LLPTR + 1] = blknbr % 65536 / 256;
2588: block0[LLPTR + 2] = blknbr % 256;
2589:
2590: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2591: write (filedes, block, BLOCKLEN);
2592: stcpy0 (block, block0, (long) BLOCKLEN);
2593:
2594: traceadr[trx] = (addr -= limit);
2595: traceblk[trx] = (blknbr = newblk);
2596:
2597: /* insert new block in pointer structure */
2598: insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);
2599:
2600: /* up-date LL-PTR of RL-block */
2601: if (other != 0) {
2602:
2603: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2604: read (filedes, block0, BLOCKLEN);
2605:
2606: block0[LLPTR] = newblk / 65536;
2607: block0[LLPTR + 1] = newblk % 65536 / 256;
2608: block0[LLPTR + 2] = newblk % 256;
2609:
2610: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2611: write (filedes, block0, BLOCKLEN);
2612:
2613: }
2614:
2615: }
2616: }
2617:
2618: spltex:
2619:
2620: if (ret_to == 'n') goto s10;
2621:
2622: goto s20;
2623: } /* end global() */
2624:
2625: /*
2626: * split pointer block in two sections
2627: * filedes: global file descriptor
2628: * block: old block (which is too small)
2629: * addr: addr of entry where to insert
2630: * offs: offset of block
2631: * blknbr: number of old block
2632: *
2633: * part of the data is taken to an other location.
2634: * old information in 'block' stored at 'blknbr'
2635: * 'addr' there I would like to insert, if possible (which is not)
2636: * 'offset' filled up to this limit
2637: */
2638: static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr)
2639: {
2640:
2641: char block0[BLOCKLEN];
2642: long limit;
2643: unsigned long newblk;
2644: unsigned long other;
2645: register int i, j;
2646:
2647: getnewblk (filedes, &newblk); /* get a new block */
2648:
2649: if (*blknbr == ROOT) { /* ROOT overflow is special */
2650:
2651: stcpy0 (block0, block, (long) BLOCKLEN);
2652:
2653: /* clear pointers */
2654: block[LLPTR] = 0;
2655: block[LLPTR + 1] = 0;
2656: block[LLPTR + 2] = 0;
2657: block[RLPTR] = 0;
2658: block[RLPTR + 1] = 0;
2659: block[RLPTR + 2] = 0;
2660:
2661: /* old root block is a 'normal' block now */
2662: /* new root points to a single block */
2663: i = UNSIGN (block0[0]) + 2;
2664: block0[i++] = newblk / 65536;
2665: block0[i++] = newblk % 65536 / 256;
2666: block0[i++] = newblk % 256;
2667: block0[OFFS] = i / 256;
2668: block0[OFFS + 1] = i % 256;
2669:
2670: while (i < DATALIM) block0[i++] = 0; /* clear rest */
2671:
2672: /* update number of blocks ! */
2673: i = UNSIGN (block0[NRBLK]) * 65536 +
2674: UNSIGN (block0[NRBLK + 1]) * 256 +
2675: UNSIGN (block0[NRBLK + 2]) + 1;
2676:
2677: block0[NRBLK] = i / 65536;
2678: block0[NRBLK + 1] = i % 65536 / 256;
2679: block0[NRBLK + 2] = i % 256;
2680: block0[BTYP] = POINTER;
2681:
2682: lseek (filedes, ROOT, 0);
2683: write (filedes, block0, BLOCKLEN);
2684:
2685: /* shift trace_stack */
2686: j = trx++;
2687: i = trx;
2688:
2689: /** if (j>=TRLIM) 'global too big' */
2690: while (j >= 0) {
2691: traceblk[i] = traceblk[j];
2692: traceadr[i--] = traceadr[j--];
2693: }
2694:
2695: traceblk[0] = 0; /*ROOT */
2696: traceadr[0] = 0;
2697: traceblk[1] = newblk;
2698: *blknbr = newblk;
2699:
2700: getnewblk (filedes, &newblk); /* get a new block */
2701:
2702: }
2703:
2704: block0[BTYP] = block[BTYP];
2705:
2706: /* now search for a dividing line */
2707: i = 0;
2708: limit = (*offs) / 2;
2709:
2710: while (i < limit) {
2711: i += UNSIGN (block[i]);
2712: i += 2; /* skip key */
2713: i += PLEN; /* skip data */
2714: }
2715:
2716: /* new offsets */
2717: limit = i;
2718:
2719: i = (*offs) - limit;
2720:
2721: block[OFFS] = limit / 256;
2722: block[OFFS + 1] = limit % 256;
2723: block0[OFFS] = i / 256;
2724: block0[OFFS + 1] = i % 256;
2725:
2726: for (i = 0; i <= DATALIM; block0[i++] = 0);
2727:
2728: i = 0;
2729: j = limit; /* copy part of old to new blk */
2730:
2731: while (j < (*offs)) {
2732: block0[i++] = block[j];
2733: block[j] = 0;
2734:
2735: j++;
2736: }
2737:
2738: if ((*addr) <= limit) { /* save new block away */
2739:
2740: /* update rightlink and leftlink pointers */
2741: other = UNSIGN (block[RLPTR]) * 65536 +
2742: UNSIGN (block[RLPTR + 1]) * 256 +
2743: UNSIGN (block[RLPTR + 2]);
2744: block0[RLPTR] = block[RLPTR];
2745: block0[RLPTR + 1] = block[RLPTR + 1];
2746: block0[RLPTR + 2] = block[RLPTR + 2];
2747: block[RLPTR] = newblk / 65536;
2748: block[RLPTR + 1] = newblk % 65536 / 256;
2749: block[RLPTR + 2] = newblk % 256;
2750: block0[LLPTR] = (*blknbr) / 65536;
2751: block0[LLPTR + 1] = (*blknbr) % 65536 / 256;
2752: block0[LLPTR + 2] = (*blknbr) % 256;
2753:
2754: lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);
2755: write (filedes, block0, BLOCKLEN);
2756:
2757: (*offs) = limit;
2758:
2759: insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);
2760:
2761: /* up-date LL-PTR of RL-block */
2762: if (other != 0) {
2763:
2764: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2765: read (filedes, block0, BLOCKLEN);
2766:
2767: block0[LLPTR] = newblk / 65536;
2768: block0[LLPTR + 1] = newblk % 65536 / 256;
2769: block0[LLPTR + 2] = newblk % 256;
2770:
2771: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2772: write (filedes, block0, BLOCKLEN);
2773:
2774: }
2775:
2776: }
2777: else { /* save old block away and make new block the current block */
2778:
2779: /* update rightlink and leftlink pointers */
2780: other = UNSIGN (block[RLPTR]) * 65536 +
2781: UNSIGN (block[RLPTR + 1]) * 256 +
2782: UNSIGN (block[RLPTR + 2]);
2783:
2784: block0[RLPTR] = block[RLPTR];
2785: block0[RLPTR + 1] = block[RLPTR + 1];
2786: block0[RLPTR + 2] = block[RLPTR + 2];
2787: block[RLPTR] = newblk / 65536;
2788: block[RLPTR + 1] = newblk % 65536 / 256;
2789: block[RLPTR + 2] = newblk % 256;
2790: block0[LLPTR] = (*blknbr) / 65536;
2791: block0[LLPTR + 1] = (*blknbr) % 65536 / 256;
2792: block0[LLPTR + 2] = (*blknbr) % 256;
2793:
2794: (*addr) -= limit;
2795: (*offs) -= limit;
2796:
2797: lseek (filedes, (long) (*blknbr) * (long) (BLOCKLEN), 0);
2798: write (filedes, block, BLOCKLEN);
2799: stcpy0 (block, block0, (long) BLOCKLEN);
2800:
2801: (*blknbr) = newblk;
2802:
2803: insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);
2804:
2805: /* up-date LL-PTR of RL-block */
2806: if (other != 0) {
2807:
2808: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2809: read (filedes, block0, BLOCKLEN);
2810:
2811: block0[LLPTR] = newblk / 65536;
2812: block0[LLPTR + 1] = newblk % 65536 / 256;
2813: block0[LLPTR + 2] = newblk % 256;
2814:
2815: lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
2816: write (filedes, block0, BLOCKLEN);
2817:
2818: }
2819:
2820: }
2821:
2822: return;
2823:
2824: } /* end of splitp() */
2825:
2826: /* update pointer
2827: * filedes: file descriptor
2828: * ins_key: key to be inserted
2829: * keyl: length of that key
2830: */
2831: static void update (short filedes, char *ins_key, long keyl)
2832: {
2833: long offset;
2834: long addr;
2835: unsigned long blknbr;
2836: char block[BLOCKLEN];
2837: long i, j, k;
2838:
2839: while (traceadr[trx] == 0) { /* update of pointer blocks necessary */
2840:
2841: if (--trx < 0) break;
2842:
2843: blknbr = traceblk[trx];
2844: addr = traceadr[trx];
2845:
2846: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2847: read (filedes, block, BLOCKLEN);
2848:
2849: {
2850: long oldkeyl;
2851:
2852: oldkeyl = UNSIGN (block[addr]);
2853:
2854: i = addr + keyl + 1;
2855: j = oldkeyl - keyl;
2856:
2857: offset = UNSIGN (block[OFFS]) * 256 +
2858: UNSIGN (block[OFFS + 1]);
2859:
2860: if (j > 0) { /* surplus space */
2861:
2862: k = offset;
2863: offset -= j;
2864: j += i;
2865:
2866: while (i < offset) block[i++] = block[j++];
2867:
2868: while (i < k) block[i++] = 0; /* clear area */
2869:
2870: }
2871: else if (j < 0) { /* we need more space */
2872:
2873: /* block too small */
2874: if ((offset - j) > DATALIM) splitp (filedes, block, &addr, &offset, &blknbr);
2875:
2876: i = offset;
2877: offset -= j;
2878: j = offset;
2879: k = addr + oldkeyl;
2880:
2881: while (i > k) block[j--] = block[i--];
2882:
2883: }
2884:
2885: block[OFFS] = offset / 256;
2886: block[OFFS + 1] = offset % 256;
2887: block[addr] = keyl;
2888:
2889: /* overwrite */
2890: i = 0;
2891: j = (++addr);
2892: block[j++] = 0; /*!!! */
2893:
2894: while (i < keyl) block[j++] = ins_key[i++];
2895:
2896: /* block pointed to remains the same */
2897: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2898: write (filedes, block, BLOCKLEN);
2899:
2900: }
2901:
2902: lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
2903: read (filedes, block, BLOCKLEN);
2904:
2905: }
2906:
2907: return;
2908:
2909: } /* end of update() */
2910:
2911: /*
2912: * insert pointer
2913: * filedes: file descriptor
2914: * ins_key: key to be inserted
2915: * key_len: length of that key
2916: * blknbr: key points to this block
2917: */
2918: static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr) /* insert pointer */
2919: {
2920: unsigned long blk;
2921: char block[BLOCKLEN];
2922: long trxsav;
2923: long offset;
2924: long needed;
2925: long addr;
2926: register int i, k;
2927:
2928: trxsav = trx--;
2929: blk = traceblk[trx];
2930: addr = traceadr[trx];
2931:
2932: lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);
2933: read (filedes, block, BLOCKLEN);
2934:
2935: offset = UNSIGN (block[OFFS]) * 256 +
2936: UNSIGN (block[OFFS + 1]);
2937:
2938: if (traceadr[trx + 1] != (-1)) {
2939: addr += UNSIGN (block[addr]);
2940: addr += (2 + PLEN);
2941: } /* advance to next entry */
2942:
2943: needed = key_len + 2 + PLEN;
2944:
2945: if ((offset + needed) > DATALIM) splitp (filedes, block, &addr, &offset, &blk);
2946:
2947: /* insert key */
2948: i = (offset += needed);
2949:
2950: block[OFFS] = i / 256;
2951: block[OFFS + 1] = i % 256;
2952:
2953: while (i >= addr) {
2954: block[i] = block[i - needed];
2955: i--;
2956: }
2957:
2958: i = addr + 2;
2959: k = 0;
2960:
2961: while (k < key_len) block[i++] = ins_key[k++];
2962:
2963: block[addr] = k;
2964: block[addr + 1] = 0; /* !!! */
2965: block[i++] = blknbr / 65536;
2966: block[i++] = blknbr % 65536 / 256;
2967: block[i] = blknbr % 256;
2968:
2969: lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);
2970: write (filedes, block, BLOCKLEN);
2971:
2972: trx = trxsav;
2973:
2974: return;
2975: } /* end of insert() */
2976:
2977: /*
2978: * mark 'blknbr' as free
2979: * filedes: global file descriptor
2980: * blknbr: block to be freed
2981: */
2982: static void b_free (short filedes, unsigned long blknbr)
2983: {
2984: char block0[BLOCKLEN];
2985: unsigned long free;
2986: unsigned long other;
2987: long i;
2988: long offset;
2989:
2990: /* mark block as empty */
2991: lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);
2992: read (filedes, block0, BLOCKLEN);
2993:
2994: block0[BTYP] = EMPTY;
2995:
2996: lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);
2997: write (filedes, block0, BLOCKLEN);
2998:
2999: /* do we have a list of free blocks? */
3000: lseek (filedes, ROOT, 0);
3001: read (filedes, block0, BLOCKLEN);
3002:
3003: if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {
3004:
3005: for (;;) {
3006:
3007: lseek (filedes, (long) free * (long) BLOCKLEN, 0);
3008: read (filedes, block0, BLOCKLEN);
3009:
3010: other = UNSIGN (block0[RLPTR]) * 65536 +
3011: UNSIGN (block0[RLPTR + 1]) * 256 +
3012: UNSIGN (block0[RLPTR + 2]);
3013:
3014: if (other == 0) break;
3015:
3016: free = other;
3017:
3018: }
3019:
3020: offset = UNSIGN (block0[OFFS]) * 256 + UNSIGN (block0[OFFS + 1]);
3021:
3022: /* if list is full, start new page */
3023: if (offset > (DATALIM - PLEN)) {
3024:
3025: offset -= PLEN;
3026: other = UNSIGN (block0[offset]) * 65536 +
3027:
3028: UNSIGN (block0[offset + 1]) * 256 +
3029: UNSIGN (block0[offset + 2]);
3030:
3031: block0[offset] = 0;
3032: block0[offset + 1] = 0;
3033: block0[offset + 2] = 0;
3034: block0[OFFS] = offset / 256;
3035: block0[OFFS + 1] = offset % 256;
3036: block0[RLPTR] = other / 65536;
3037: block0[RLPTR + 1] = other % 65536 / 256;
3038: block0[RLPTR + 2] = other % 256;
3039:
3040: lseek (filedes, (long) free * (long) BLOCKLEN, 0);
3041: write (filedes, block0, BLOCKLEN);
3042:
3043: for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
3044:
3045: block0[BTYP] = FBLK;
3046: block0[LLPTR] = free / 65536;
3047: block0[LLPTR + 1] = free % 65536 / 256;
3048: block0[LLPTR + 2] = free % 256;
3049: offset = 0;
3050:
3051: free = other;
3052:
3053: }
3054:
3055: }
3056: else {
3057:
3058: getnewblk (filedes, &free);
3059:
3060: /* set FBLK free blocks pointer */
3061: lseek (filedes, ROOT, 0);
3062: read (filedes, block0, BLOCKLEN);
3063:
3064: block0[FREE] = free / 65536;
3065: block0[FREE + 1] = free % 65536 / 256;
3066: block0[FREE + 2] = free % 256;
3067:
3068: lseek (filedes, ROOT, 0);
3069: write (filedes, block0, BLOCKLEN);
3070:
3071: for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
3072:
3073: block0[BTYP] = FBLK;
3074: offset = 0;
3075: }
3076:
3077: /* enter 'blknbr' */
3078: block0[offset++] = blknbr / 65536;
3079: block0[offset++] = blknbr % 65536 / 256;
3080: block0[offset++] = blknbr % 256;
3081: block0[OFFS] = offset / 256;
3082: block0[OFFS + 1] = offset % 256;
3083:
3084: lseek (filedes, (long) free * (long) BLOCKLEN, 0);
3085: write (filedes, block0, BLOCKLEN);
3086:
3087: return;
3088: } /* end of b_free() */
3089:
3090: /*
3091: * scan pointer 'block' for 'compactkey'
3092: *
3093: * 'adr' will return an adress
3094: * 2 heureka; key found at adr
3095: * 1 not found, adr=following entry
3096: */
3097: static void scanpblk (char *block, long *adr, long *fnd)
3098: {
3099: register int i = 0;
3100: register int k;
3101: long j, offset, len;
3102: char key0[256];
3103:
3104: *adr = 0;
3105: offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
3106:
3107: while (i < offset) {
3108:
3109: #ifdef VERSNEW
3110:
3111: j = i; /* save adress of current entry */
3112: len = UNSIGN (block[i++]);
3113:
3114: stcpy0 (key0, &block[++i], len);
3115:
3116: key0[len] = g_EOL;
3117: i += len;
3118:
3119: #else
3120:
3121: j = i++;
3122: len = UNSIGN (block[j]);
3123: k = 0;
3124: i++;
3125:
3126: while (k < len) key0[k++] = block[i++];
3127:
3128: key0[k] = g_EOL;
3129:
3130: #endif /* VERSNEW */
3131:
3132: if (((*fnd) = g_collate (key0)) == 1) return;
3133:
3134: *adr = j;
3135:
3136: if ((*fnd) == 2) return;
3137:
3138: i += PLEN;
3139:
3140: }
3141:
3142: return;
3143:
3144: } /* end of scanpblk() */
3145:
3146: /*
3147: * scan 'block' for 'compactkey'
3148: * same stuff as scanpblk for the params.
3149: */
3150: static void scandblk (char *block, long *adr, long *fnd)
3151: {
3152: register int i = 0;
3153: register int k;
3154: long offset, len;
3155: char key0[256];
3156:
3157: offset = UNSIGN (block[OFFS]) * 256 +
3158: UNSIGN (block[OFFS + 1]);
3159:
3160: while (i < offset) {
3161:
3162: #ifdef VERSNEW
3163:
3164: *adr = i;
3165:
3166: len = UNSIGN (block[i++]);
3167: k = UNSIGN (block[i++]);
3168:
3169: stcpy0 (&key0[k], &block[i], len);
3170:
3171: key0[k + len] = g_EOL;
3172: i += len;
3173:
3174: #else
3175:
3176: *adr = i++;
3177:
3178: len = UNSIGN (block[*adr]) + (k = UNSIGN (block[i++]));
3179:
3180: while (k < len) key0[k++] = block[i++];
3181:
3182: key0[k] = g_EOL;
3183:
3184: #endif /* VERSNEW */
3185:
3186: if (((*fnd) = g_collate (key0)) != 0) return;
3187:
3188: i += UNSIGN (block[i]);
3189:
3190: i++; /* skip data */
3191:
3192: }
3193:
3194: *adr = i;
3195:
3196: return;
3197:
3198: } /* end of scandblk() */
3199:
3200: /*
3201: * get a new block
3202: * filedes: global file descriptor
3203: * blknbr: number of new block
3204: */
3205: static void getnewblk (int filedes, unsigned long *blknbr)
3206: {
3207: char nblock[BLOCKLEN];
3208: unsigned long freeblks, no_of_blks;
3209: long other;
3210: long offset;
3211:
3212: lseek (filedes, ROOT, 0);
3213: read (filedes, nblock, BLOCKLEN);
3214:
3215: freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]);
3216: no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);
3217:
3218: if (freeblks) {
3219:
3220: lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);
3221: read (filedes, nblock, BLOCKLEN);
3222:
3223: offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);
3224:
3225: if (offset == 0) { /* free list is empty. return free list blk as new block. */
3226:
3227: *blknbr = freeblks;
3228: other = UNSIGN (nblock[RLPTR]) * 65536 + UNSIGN (nblock[RLPTR + 1]) * 256 + UNSIGN (nblock[RLPTR + 2]);
3229:
3230: /* update RL-block, if any */
3231: if (other) {
3232:
3233: lseek (filedes, (long) (other) * BLOCKLEN, 0);
3234: read (filedes, nblock, BLOCKLEN);
3235:
3236: nblock[LLPTR] = 0;
3237: nblock[LLPTR + 1] = 0;
3238: nblock[LLPTR + 2] = 0;
3239:
3240: lseek (filedes, (long) (other) * BLOCKLEN, 0);
3241: write (filedes, nblock, BLOCKLEN);
3242:
3243: }
3244:
3245: /* update ROOT block */
3246: lseek (filedes, ROOT, 0);
3247: read (filedes, nblock, BLOCKLEN);
3248:
3249: nblock[FREE] = other / 65536;
3250: nblock[FREE + 1] = other % 65536 / 256;
3251: nblock[FREE + 2] = other % 256;
3252:
3253: lseek (filedes, ROOT, 0);
3254: write (filedes, nblock, BLOCKLEN);
3255:
3256: return;
3257:
3258: }
3259:
3260: offset -= PLEN;
3261: *blknbr = UNSIGN (nblock[offset]) * 65536 + UNSIGN (nblock[offset + 1]) * 256 + UNSIGN (nblock[offset + 2]);
3262: nblock[offset] = 0;
3263: nblock[offset + 1] = 0;
3264: nblock[OFFS] = offset / 256;
3265: nblock[OFFS + 1] = offset % 256;
3266:
3267: lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);
3268: write (filedes, nblock, BLOCKLEN);
3269:
3270: return;
3271:
3272: }
3273:
3274: /* else ** freeblk==0 ** */
3275: no_of_blks++;
3276: nblock[NRBLK] = no_of_blks / 65536;
3277: nblock[NRBLK + 1] = no_of_blks % 65536 / 256;
3278: nblock[NRBLK + 2] = no_of_blks % 256;
3279:
3280: lseek (filedes, ROOT, 0);
3281: write (filedes, nblock, BLOCKLEN);
3282:
3283: *blknbr = no_of_blks;
3284:
3285: for (;;) {
3286:
3287: errno = 0;
3288:
3289: lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0);
3290: write (filedes, nblock, BLOCKLEN);
3291:
3292: if (errno == 0) break;
3293:
3294: panic ();
3295:
3296: }
3297:
3298: return;
3299:
3300: } /* end of getnewblk() */
3301:
3302: /*
3303: * return TRUE if 't' follows 'compactkey' in MUMPS collating sequence
3304: */
3305: static short int g_collate (char *t)
3306: {
3307: char *s = compactkey;
3308: register int chs = *s;
3309: register int cht = *t;
3310: register int tx = 0;
3311: register int sx;
3312: short dif;
3313:
3314: /* the empty one is the leader! */
3315: if (chs == g_EOL) {
3316:
3317: if (cht == g_EOL) return 2;
3318:
3319: return TRUE;
3320:
3321: }
3322:
3323: if (cht == g_EOL) return FALSE;
3324:
3325: while (cht == s[tx]) {
3326:
3327: if (cht == g_EOL) return 2;
3328:
3329: cht = t[++tx];
3330:
3331: } /* (s==t) */
3332:
3333: chs = s[tx];
3334:
3335: if (chs == OMEGA) return FALSE;
3336: if (chs == ALPHA) return cht != g_EOL;
3337: if (chs == g_EOL && t[tx - 1] & 01) return TRUE;
3338: if (cht == g_EOL && s[tx - 1] & 01) return FALSE;
3339:
3340: if (tx > 0) {
3341:
3342: tx--;
3343:
3344: while ((t[tx] & 01) == 0) {
3345:
3346: tx--;
3347:
3348: if (tx < 0) break;
3349:
3350: }
3351:
3352: tx++;
3353:
3354: }
3355:
3356: chs = s[tx];
3357: cht = t[tx];
3358:
3359: if (UNSIGN (chs) <= POINT) { /* then come numerics */
3360:
3361: if (UNSIGN (cht) > POINT) return UNSIGN (cht) != g_EOL;
3362:
3363: /* both are numeric! now compare numeric values */
3364:
3365: if (chs == MINUS) {
3366: if (cht != MINUS) return TRUE;
3367: }
3368: else {
3369: if (cht == MINUS) return FALSE;
3370: }
3371:
3372: if (chs == 1 && cht == POINT) return TRUE;
3373: if (cht == 1 && chs == POINT) return FALSE;
3374:
3375: dif = sx = tx;
3376:
3377: while (s[sx] != POINT) {
3378: if (s[sx++] & 01) break;
3379: }
3380:
3381: while (t[tx] != POINT) {
3382: if (t[tx++] & 01) break;
3383: }
3384:
3385: if (tx > sx) return cht != MINUS;
3386: if (tx < sx) return cht == MINUS;
3387:
3388: tx = dif;
3389: while ((cht >> 1) == (chs >> 1)) {
3390:
3391: if (cht & 01) return t[dif] == MINUS;
3392: if (chs & 01) return t[dif] != MINUS;
3393:
3394: chs = s[++tx];
3395: cht = t[tx];
3396:
3397: }
3398:
3399: return (((cht >> 1) > (chs >> 1)) == (t[dif] != MINUS)) && (t[tx] != s[tx]);
3400:
3401: }
3402:
3403: if (UNSIGN (cht) <= POINT) return FALSE;
3404:
3405: while ((dif = (UNSIGN (cht) >> 1) - (UNSIGN (chs) >> 1)) == 0) { /* ASCII collating */
3406:
3407: if ((cht & 01) && ((chs & 01) == 0)) return FALSE;
3408: if ((chs & 01) && ((cht & 01) == 0)) return TRUE;
3409:
3410: chs = s[++tx];
3411: cht = t[tx];
3412:
3413: }
3414:
3415: if (chs == g_EOL) return TRUE;
3416: if (cht == g_EOL) return FALSE;
3417:
3418: return dif > 0;
3419:
3420: } /* end g_collate() */
3421:
3422: /*
3423: * test whether 'str' is canonical
3424: */
3425: //static short int g_numeric (char *str)
3426: short g_numeric (char *str)
3427: {
3428: register int ptr = 0, ch;
3429: register int point = 0;
3430:
3431: if (str[0] == '-') {
3432: if ((ch = str[++ptr]) == EOL || (ch == DELIM) || (ch == '0')) return FALSE;
3433: }
3434: else if (str[0] == '0') {
3435:
3436: if ((ch = str[ptr + 1]) == EOL || ch == DELIM) return TRUE;
3437:
3438: return FALSE; /* leading zero */
3439: }
3440:
3441: while ((ch = str[ptr++]) != EOL && ch != DELIM) {
3442:
3443: if (ch > '9') return FALSE;
3444:
3445: if (ch < '0') {
3446:
3447: if (ch != '.') return FALSE;
3448: if (point) return FALSE; /* multiple points */
3449:
3450: point = TRUE;
3451:
3452: }
3453:
3454: }
3455:
3456: if (point) {
3457:
3458: ch = str[ptr - 2];
3459:
3460: if (ch == '0' || ch == '.') return FALSE;
3461:
3462: }
3463:
3464: return TRUE;
3465:
3466: } /* end g_numeric() */
3467:
3468: void close_all_globals (void)
3469: {
3470: register int i;
3471:
3472: for (i = 0; i < NO_GLOBLS; i++) {
3473:
3474: if (oldfil[i][0] != NUL) {
3475:
3476: close (olddes[i]);
3477:
3478: usage[i] = 0;
3479: olddes[i] = 0;
3480: oldfil[i][0] = NUL;
3481:
3482: }
3483:
3484: }
3485:
3486: return;
3487:
3488: } /* end close_all_globals() */
3489:
3490: static void panic (void)
3491: {
3492: printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007");
3493: sleep (1);
3494: printf ("\033[m\007\033[2K\033[u");
3495:
3496: /* restore screen 'cause system messed up screen */
3497:
3498: #ifdef NOWRITEM
3499:
3500: write_m ("\033[4~\201");
3501:
3502: #endif /* NOWRITEM */
3503:
3504: return;
3505:
3506: } /* end panic() */
3507:
3508:
3509: void gbl_dump_stat(void)
3510: {
3511: register int i;
3512:
3513: printf ("FreeM Global Statistics [PID %d]\r\n", pid);
3514:
3515: printf ("%-10s%-20s%s\r\n", "USECT", "AGE", "FILE");
3516: printf ("%-10s%-20s%s\r\n", "=====", "===", "====");
3517:
3518: for (i = 0; i < NO_GLOBLS; i++) {
3519: printf ("%-10d%-20ld%s\r\n", usage[i], g_ages[i], oldfil[i]);
3520: }
3521:
3522: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to global_bltin.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src