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