![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to arff.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / etc|
Return to arff.c CVS log | Up to [CSRG BSD Unix] / 42BSD / etc |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)arff.c 4.16 (Berkeley) 83/07/10";
3: #endif
4:
5: #include <sys/types.h>
6: #include <sys/stat.h>
7: #include <sys/time.h>
8: #include <signal.h>
9: #include <stdio.h>
10: #include <sys/file.h>
11:
12: #define dbprintf printf
13:
14: struct rt_dat {
15: u_short rt_yr:5; /* year-1972 */
16: u_short rt_dy:5; /* day */
17: u_short rt_mo:5; /* month */
18: };
19:
20: struct rt_axent {
21: char rt_sent[14];
22: };
23:
24: struct rt_ent {
25: char rt_pad; /* unusued */
26: char rt_stat; /* type of entry, or end of seg */
27: u_short rt_name[3]; /* name, 3 words in rad50 form */
28: u_short rt_len; /* length of file */
29: char rt_chan; /* only used in temporary files */
30: char rt_job; /* only used in temporary files */
31: struct rt_dat rt_date; /* creation date */
32: };
33:
34: #define RT_TEMP 1
35: #define RT_NULL 2
36: #define RT_FILE 4
37: #define RT_ESEG 8
38:
39: #define RT_BLOCK 512 /* block size */
40: #define RT_DIRSIZE 31 /* max # of directory segments */
41:
42: struct rt_head {
43: short rt_numseg; /* # of segments available */
44: short rt_nxtseg; /* # of next logical segment */
45: short rt_lstseg; /* highest seg currently open */
46: u_short rt_entpad; /* extra words/directory entry */
47: short rt_stfile; /* block # where files begin */
48: };
49:
50: struct rt_dir {
51: struct rt_head rt_axhead;
52: struct rt_ent rt_ents[72];
53: char _dirpad[6];
54: };
55:
56: typedef struct fldope {
57: int startad;
58: int count;
59: struct rt_ent *rtdope;
60: } FLDOPE;
61:
62: FLDOPE *lookup();
63:
64: #define rt(p) ((struct rt_ent *) p )
65: #define Ain1 03100
66: #define Ain2 050
67: #define flag(c) (flg[('c') - 'a'])
68:
69: char *man = "rxtd";
70: char zeroes[512];
71:
72: extern char *val;
73: extern char table[256];
74: struct rt_dir rt_dir[RT_DIRSIZE] = {
75: { 4, 0, 1, 0, 14 },
76: { { 0, RT_NULL, { 0, 0, 0 }, 494, 0 },
77: { 0, RT_ESEG } }
78: };
79:
80: int rt_entsiz;
81: int rt_nleft;
82: struct rt_ent *rt_curend[RT_DIRSIZE];
83: int floppydes;
84: int dirdirty;
85: char *rt_last;
86: char *defdev = "/dev/floppy";
87:
88: char *opt = "vf";
89:
90: int signum[] = {SIGHUP, SIGINT, SIGQUIT, 0};
91: extern long lseek();
92: int rcmd(), dcmd(), xcmd(), tcmd();
93:
94: int (*comfun)();
95: char flg[26];
96: char **namv;
97: int namc;
98: int file;
99:
100: main(argc, argv)
101: char *argv[];
102: {
103: register char *cp;
104:
105: if (argc < 2)
106: usage();
107: for (cp = argv[1]; *cp; cp++)
108: switch (*cp) {
109:
110: case 'm':
111: case 'v':
112: case 'u':
113: case 'w':
114: flg[*cp-'a']++;
115: continue;
116: case 'c':
117: flag(c)++;
118: dirdirty++;
119: continue;
120:
121: case 'r':
122: setcom(rcmd);
123: flag(r)++;
124: continue;
125:
126: case 'd':
127: setcom(dcmd);
128: flag(d)++;
129: continue;
130:
131: case 'x':
132: setcom(xcmd);
133: continue;
134:
135: case 't':
136: setcom(tcmd);
137: continue;
138:
139: case 'f':
140: defdev = argv[2];
141: argv++;
142: argc--;
143: continue;
144:
145: default:
146: fprintf(stderr, "arff: bad option `%c'\n", *cp);
147: exit(1);
148: }
149:
150: namv = argv+2;
151: namc = argc-2;
152: if (comfun == 0) {
153: if (flag(u) == 0) {
154: fprintf(stderr, "arff: one of [%s] must be specified\n",
155: man);
156: exit(1);
157: }
158: setcom(rcmd);
159: }
160: (*comfun)();
161: exit(notfound());
162: }
163:
164: setcom(fun)
165: int (*fun)();
166: {
167: if (comfun != 0) {
168: fprintf(stderr, "arff: only one of [%s] allowed\n", man);
169: exit(1);
170: }
171: comfun = fun;
172: }
173:
174: usage()
175: {
176: fprintf(stderr, "usage: ar [%s][%s] archive files ...\n", opt, man);
177: exit(1);
178: }
179:
180: notfound()
181: {
182: register i, n = 0;
183:
184: for (i = 0; i < namc; i++)
185: if (namv[i]) {
186: fprintf(stderr, "arff: %s not found\n", namv[i]);
187: n++;
188: }
189: return (n);
190: }
191:
192: mesg(c)
193: {
194: if (flag(v))
195: if (c != 'c' || flag(v) > 1)
196: printf("%c - %s\n", c, file);
197: }
198:
199: tcmd()
200: {
201: register char *de, *last;
202: FLDOPE *lookup(), *dope;
203: int segnum, nleft;
204: register i;
205: register struct rt_ent *rde;
206:
207: rt_init();
208: if (namc != 0) {
209: for (i = 0; i < namc; i++)
210: if (dope = lookup(namv[i])) {
211: rde = dope->rtdope;
212: rtls(rde);
213: namv[i] = 0;
214: }
215: return;
216: }
217: for (segnum = 0; segnum != -1;
218: segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
219: last = rt_last + segnum*2*RT_BLOCK;
220: for (de = ((char *)&rt_dir[segnum])+10; de <= last;
221: de += rt_entsiz)
222: if (rtls(rt(de))) {
223: nleft = (last-de)/rt_entsiz;
224: #define ENTRIES "\n%d entries remaining in directory segment %d.\n"
225: printf(ENTRIES, nleft, segnum+1);
226: break;
227: }
228: }
229: }
230:
231: rtls(de)
232: register struct rt_ent *de;
233: {
234: int month, day, year;
235: char name[12], ext[4];
236:
237: switch (de->rt_stat) {
238:
239: case RT_TEMP:
240: if (flag(v))
241: printf("Tempfile:\n");
242: /* fall thru...*/
243:
244: case RT_FILE:
245: if (!flag(v)) {
246: sunrad50(name, de->rt_name);
247: printf("%s\n", name);
248: break;
249: }
250: unrad50(2, de->rt_name, name);
251: unrad50(1, &(de->rt_name[2]), ext);
252: day = de->rt_date.rt_dy;
253: year = de->rt_date.rt_yr+72;
254: month = de->rt_date.rt_mo;
255: printf("%6.6s %3.3s %02d/%02d/%02d %d\n",name,
256: ext, month, day, year, de->rt_len);
257: break;
258:
259: case RT_NULL:
260: printf("%-25.9s %d\n","<UNUSED>", de->rt_len);
261: break;
262:
263: case RT_ESEG:
264: return (1);
265: }
266: return (0);
267: }
268:
269: xcmd()
270: {
271: register char *de, *last;
272: int segnum;
273: char name[12];
274: register int i;
275:
276: rt_init();
277: if (namc != 0) {
278: for (i = 0; i < namc; i++)
279: if (rtx(namv[i]) == 0)
280: namv[i] = 0;
281: return;
282: }
283: for (segnum = 0; segnum != -1;
284: segnum = rt_dir[segnum].rt_axhead.rt_nxtseg-1)
285: for (last = rt_last+(segnum*2*RT_BLOCK),
286: de = ((char *)&rt_dir[segnum])+10; de <= last;
287: de += rt_entsiz)
288: switch (rt(de)->rt_stat) {
289:
290: case RT_ESEG:
291: return;
292:
293: case RT_TEMP:
294: case RT_FILE:
295: sunrad50(name,rt(de)->rt_name);
296: rtx(name);
297:
298: case RT_NULL:
299: break;
300: }
301: }
302:
303: rtx(name)
304: char *name;
305: {
306: register FLDOPE *dope;
307: FLDOPE *lookup();
308: register startad, count;
309: int file;
310: char buff[512];
311:
312:
313: if (dope = lookup(name)) {
314: if (flag(v))
315: rtls(dope->rtdope);
316: else
317: printf("x - %s\n",name);
318:
319: if ((file = creat(name, 0666)) < 0)
320: return (1);
321: count = dope->count;
322: startad = dope->startad;
323: for( ; count > 0 ; count -= 512) {
324: lread(startad, 512, buff);
325: write(file, buff, 512);
326: startad += 512;
327: }
328: close(file);
329: return (0);
330: }
331: return (1);
332: }
333:
334: rt_init()
335: {
336: static initized = 0;
337: register char *de, *last;
338: register i;
339: int dirnum;
340: char *mode;
341: FILE *temp_floppydes;
342:
343: if (initized)
344: return;
345: initized = 1;
346: if (flag(c)) {
347: struct stat sb;
348: char response[128];
349: int tty;
350:
351: if (stat(defdev, &sb) >= 0 && (sb.st_mode & S_IFMT) == S_IFREG)
352: goto ignore;
353: tty = open("/dev/tty", O_RDWR);
354: #define SURE "Are you sure you want to clobber the floppy? "
355: write(tty, SURE, sizeof (SURE));
356: read(tty, response, sizeof (response));
357: if (*response != 'y')
358: exit(50);
359: close(tty);
360: ignore:
361: ;
362: }
363: if (flag(c) || flag(d) || flag(r))
364: mode = "r+";
365: else
366: mode = "r";
367: if ((temp_floppydes = fopen(defdev, mode)) == NULL) {
368: perror(defdev);
369: exit(1);
370: } else
371: floppydes = fileno(temp_floppydes);
372: if (!flag(c)) {
373: lread(6*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[0]);
374: dirnum = rt_dir[0].rt_axhead.rt_numseg;
375: /* check for blank/uninitialized diskette */
376: if (dirnum <= 0) {
377: fprintf(stderr,"arff: bad directory format\n");
378: exit(1);
379: }
380: if (dirnum > RT_DIRSIZE) {
381: fprintf(stderr,"arff: too many directory segments\n");
382: exit(1);
383: }
384: for (i = 1; i < dirnum; i++)
385: lread((6+2*i)*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[i]);
386: } else
387: dirnum = 1;
388:
389: rt_entsiz = 2*rt_dir[0].rt_axhead.rt_entpad + 14;
390: rt_entsiz = 14; /* assume rt_entpad = 0 ??? */
391: rt_last = ((char *) &rt_dir[0]) + 10 + 1014/rt_entsiz*rt_entsiz;
392: rt_nleft = 0;
393:
394: for (i = 0; i < dirnum; i++) {
395: last = rt_last + i*2*RT_BLOCK;
396: for (de = ((char *)&rt_dir[i])+10; de <= last; de += rt_entsiz)
397: if (rt(de)->rt_stat == RT_ESEG)
398: break;
399: rt_curend[i] = rt(de);
400: rt_nleft += (last-de)/rt_entsiz;
401: }
402: }
403:
404: static FLDOPE result;
405:
406: FLDOPE *
407: lookup(name)
408: char *name;
409: {
410: unsigned short rname[3];
411: register char *de, *last;
412: int segnum;
413: register index;
414:
415: srad50(name,rname);
416:
417: /*
418: * Search for name, accumulate blocks in index
419: */
420: rt_init();
421: for (segnum = 0; segnum != -1;
422: segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1)
423: {
424: index = 0;
425: last = rt_last + segnum*2*RT_BLOCK;
426: for (de=((char *)&rt_dir[segnum])+10;
427: rt(de)->rt_stat != RT_ESEG; de += rt_entsiz)
428: switch(rt(de)->rt_stat) {
429:
430: case RT_FILE:
431: case RT_TEMP:
432: if(samename(rname,rt(de)->rt_name)) {
433: result.count = rt(de)->rt_len * 512;
434: result.startad = 512*
435: (rt_dir[segnum].rt_axhead.rt_stfile + index);
436: result.rtdope = (struct rt_ent *) de;
437: return (&result);
438: }
439:
440: case RT_NULL:
441: index += rt(de)->rt_len;
442: }
443: }
444: return ((FLDOPE *) 0);
445:
446: }
447:
448: static
449: samename(a, b)
450: u_short a[], b[];
451: {
452: return (*a == *b && a[1] == b[1] && a[2] == b[2] );
453: }
454:
455: rad50(cp, out)
456: register u_char *cp;
457: u_short *out;
458: {
459: register index, temp;
460:
461: for (index = 0; *cp; index++) {
462: temp = Ain1 * table[*cp++];
463: if (*cp!=0) {
464: temp += Ain2 * table[*cp++];
465: if(*cp!=0)
466: temp += table[*cp++];
467: }
468: out[index] = temp;
469: }
470: }
471:
472: #define reduce(x, p, q) (x = v[p/q], p %= q);
473:
474: unrad50(count, in, cp)
475: u_short *in;
476: register char *cp;
477: {
478: register i, temp;
479: register u_char *v = (u_char *) val;
480:
481: for (i = 0; i < count; i++) {
482: temp = in[i];
483: reduce(*cp++, temp, Ain1);
484: reduce(*cp++, temp, Ain2);
485: reduce(*cp++, temp, 1);
486: }
487: *cp=0;
488: }
489:
490: srad50(name, rname)
491: register char *name;
492: register u_short *rname;
493: {
494: register index;
495: register char *cp;
496: char file[7], ext[4];
497:
498: /*
499: * Find end of pathname
500: */
501: for (cp = name; *cp++; )
502: ;
503: while (cp >= name && *--cp != '/')
504: ;
505: cp++;
506: /*
507: * Change to rad50
508: */
509: for (index = 0; *cp; ) {
510: file[index++] = *cp++;
511: if (*cp == '.') {
512: cp++;
513: break;
514: }
515: if (index >= 6) {
516: break;
517: }
518: }
519: file[index] = 0;
520: for (index = 0; *cp; ) {
521: ext[index++] = *cp++;
522: if (*cp == '.' || index >= 3)
523: break;
524: }
525: ext[index]=0;
526: rname[0] = rname[1] = rname[2] = 0;
527: rad50((u_char *)file, rname);
528: rad50((u_char *)ext, rname+2);
529: }
530:
531: sunrad50(name, rname)
532: u_short rname[];
533: register char *name;
534: {
535: register char *cp, *cp2;
536: char ext[4];
537:
538: unrad50(2, rname, name);
539: unrad50(1, rname + 2, ext);
540: /*
541: * Jam name and extension together with a dot
542: * deleting white space
543: */
544: for (cp = name; *cp++;)
545: ;
546: --cp;
547: while (*--cp == ' ' && cp >= name)
548: ;
549: *++cp = '.';
550: cp++;
551: for (cp2 = ext; *cp2 != ' ' && cp2 < ext+3;)
552: *cp++ = *cp2++;
553: *cp=0;
554: if (cp[-1] == '.')
555: cp[-1] = 0;
556: }
557:
558: static char *oval = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$.@0123456789";
559: static char *val = " abcdefghijklmnopqrstuvwxyz$.@0123456789";
560:
561: static char table[256] = {
562: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
563: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
564: 0, 29, 29, 29, 27, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29,
565: 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 29, 29, 29, 29, 29, 29,
566: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
567: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29,
568: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
569: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29,
570: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
571: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
572: 0, 29, 29, 29, 27, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29,
573: 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 29, 29, 29, 29, 29, 29,
574: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
575: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29,
576: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
577: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29 };
578:
579: /*
580: * Logical to physical adress translation
581: */
582: long
583: trans(logical)
584: register int logical;
585: {
586: register int sector, bytes, track;
587:
588: logical += 26*128;
589: bytes = (logical&127);
590: logical >>= 7;
591: sector = logical%26;
592: if(sector >= 13)
593: sector = sector*2+1;
594: else
595: sector *= 2;
596: sector += 26 + ((track = (logical/26))-1)*6;
597: sector %= 26;
598: return ((((track*26)+sector) << 7) + bytes);
599: }
600:
601: lread(startad, count, obuff)
602: register startad, count;
603: register char *obuff;
604: {
605: long trans();
606: extern floppydes;
607: register int size = flag(m) ? 512 : 128;
608:
609: rt_init();
610: while ((count -= size) >= 0) {
611: lseek(floppydes, flag(m) ?
612: (long)startad : trans(startad), 0);
613: if (read(floppydes, obuff, size) != size)
614: fprintf(stderr, "arff: read error block %d\n",
615: startad/size);
616: obuff += size;
617: startad += size;
618: }
619: }
620:
621: lwrite(startad, count, obuff)
622: register startad, count;
623: register char *obuff;
624: {
625: long trans();
626: extern floppydes;
627: register int size = flag(m) ? 512 : 128;
628:
629: rt_init();
630: while ((count -= size) >= 0) {
631: lseek(floppydes, flag(m) ?
632: (long)startad : trans(startad), 0);
633: if (write(floppydes, obuff, size) != size)
634: fprintf(stderr, "arff: write error block %d\n",
635: startad/size);
636: obuff += size;
637: startad += size;
638: }
639: }
640:
641: rcmd()
642: {
643: register int i;
644:
645: rt_init();
646: if (namc > 0)
647: for (i = 0; i < namc; i++)
648: if (rtr(namv[i]) == 0)
649: namv[i] = 0;
650: }
651:
652: rtr(name)
653: char *name;
654: {
655: register FLDOPE *dope;
656: register struct rt_ent *de;
657: struct stat buf;
658: register struct stat *bufp = &buf;
659: int segnum;
660: register char *last;
661:
662: if (stat(name, bufp) < 0) {
663: perror(name);
664: return (-1);
665: }
666: if (dope = lookup(name)) {
667: /* can replace, no problem */
668: de = dope->rtdope;
669: if (bufp->st_size <= (de->rt_len * 512))
670: printf("r - %s\n",name),
671: toflop(name, bufp->st_size, dope);
672: else {
673: fprintf(stderr,
674: "%s will not fit in currently used file on floppy\n",
675: name);
676: return (-1);
677: }
678: goto found;
679: }
680: /*
681: * Search for vacant spot
682: */
683: for (segnum = 0; segnum != -1;
684: segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1)
685: {
686: last = rt_last + segnum*2*RT_BLOCK;
687: for (de = rt_dir[segnum].rt_ents;
688: rt(de)->rt_stat != RT_ESEG; de++)
689: if ((de)->rt_stat == RT_NULL) {
690: if (bufp->st_size <= (de->rt_len*512)) {
691: printf("a - %s\n",name),
692: mkent(de, segnum, bufp,name);
693: goto found;
694: }
695: continue;
696: }
697: }
698: printf("%s: no slot for file\n", name);
699: return (-1);
700:
701: found:
702: if (dope = lookup(name)) {
703: toflop(name, bufp->st_size, dope);
704: return (0);
705: }
706: printf("%s: internal error, added then not found\n", name);
707: return (-1);
708: }
709:
710: mkent(de, segnum, bufp, name)
711: register struct rt_ent *de;
712: int segnum;
713: register struct stat *bufp;
714: char *name;
715: {
716: struct tm *localtime();
717: register struct tm *timp;
718: register struct rt_ent *workp;
719: int count;
720:
721: count = (((bufp->st_size -1) >>9) + 1);
722: /* make sure there is room */
723: if (de->rt_len == count)
724: goto overwrite;
725: if ((char *)rt_curend[segnum] == (rt_last + (segnum*2*RT_BLOCK))) {
726: /* no entries left on segment */
727: if (flag(o))
728: goto overwrite;
729: fprintf(stderr, "Directory segment #%d full on %s\n",
730: segnum+1, defdev);
731: exit(1);
732: }
733: /* copy directory entries up */
734: for (workp = rt_curend[segnum]+1; workp > de; workp--)
735: *workp = workp[-1];
736: de[1].rt_len -= count;
737: de->rt_len = count;
738: rt_curend[segnum]++;
739: rt_nleft--;
740:
741: overwrite:
742: srad50(name,de->rt_name);
743: timp = localtime(&bufp->st_mtime);
744: de->rt_date.rt_dy = timp->tm_mday;
745: de->rt_date.rt_mo = timp->tm_mon + 1;
746: de->rt_date.rt_yr = timp->tm_year - 72;
747: de->rt_stat = RT_FILE;
748: de->rt_pad = 0;
749: de->rt_chan = 0;
750: de->rt_job = 0;
751: lwrite((6+segnum*2)*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[segnum]);
752: }
753:
754: toflop(name, ocount, dope)
755: char *name;
756: register FLDOPE *dope;
757: long ocount;
758: {
759: register file, n, startad = dope->startad, count = ocount;
760: char buff[512];
761:
762: file = open(name, 0);
763: if (file < 0) {
764: fprintf(stderr, "arff: couldn't open %s\n",name);
765: exit(1);
766: }
767: for( ; count >= 512; count -= 512) {
768: read(file, buff, 512);
769: lwrite(startad, 512, buff);
770: startad += 512;
771: }
772: read(file, buff, count);
773: close(file);
774: if (count <= 0)
775: return;
776: for (n = count; n < 512; n ++)
777: buff[n] = 0;
778: lwrite(startad, 512, buff);
779: count = (dope->rtdope->rt_len*512-ocount)/512 ;
780: if (count <= 0)
781: return;
782: for ( ; count > 0 ; count--) {
783: startad += 512;
784: lwrite(startad, 512, zeroes);
785: }
786: }
787:
788: dcmd()
789: {
790: register int i;
791:
792: rt_init();
793: if (namc)
794: for (i = 0; i < namc; i++)
795: if (rtk(namv[i])==0)
796: namv[i]=0;
797: if (dirdirty)
798: scrunch();
799: }
800:
801: rtk(name)
802: char *name;
803: {
804: register FLDOPE *dope;
805: register struct rt_ent *de;
806: FLDOPE *lookup();
807:
808: if (dope = lookup(name)) {
809: printf("d - %s\n",name);
810: de = dope->rtdope;
811: de->rt_stat = RT_NULL;
812: de->rt_name[0] = 0;
813: de->rt_name[1] = 0;
814: de->rt_name[2] = 0;
815: *((u_short *)&(de->rt_date)) = 0;
816: dirdirty = 1;
817: return (0);
818: }
819: return (1);
820: }
821:
822: scrunch()
823: {
824: register struct rt_ent *de , *workp;
825: register segnum;
826:
827: for (segnum = 0; segnum != -1;
828: segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
829: for (de = rt_dir[segnum].rt_ents; de <= rt_curend[segnum]; de++)
830: if (de->rt_stat == RT_NULL &&
831: (de+1)->rt_stat == RT_NULL) {
832: (de+1)->rt_len += de->rt_len;
833: for (workp=de; workp<rt_curend[segnum]; workp++)
834: *workp = workp[1];
835: de--;
836: rt_curend[segnum]--;
837: rt_nleft++;
838: }
839: lwrite((6+segnum*2)*RT_BLOCK, 2*RT_BLOCK,
840: (char *)&rt_dir[segnum]);
841: }
842: dirdirty = 0;
843: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.