file reorg, pathnames.h, paths.h

[unix-history] / usr / src / old / arff / arff.c

diff --git a/usr/src/old/arff/arff.c b/usr/src/old/arff/arff.c
index 2639e29..98533f2 100644 (file)
--- a/usr/src/old/arff/arff.c
+++ b/usr/src/old/arff/arff.c
@@ -1,12 +1,26 @@
+/*
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif not lint
+

 #ifndef lint
 #ifndef lint

-static char sccsid[] = "@(#)arff.c     4.15 (Berkeley) 83/07/02";
-#endif
+static char sccsid[] = "@(#)arff.c     5.7 (Berkeley) %G%";
+#endif not lint

 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>

-#include <signal.h>
+#include <sys/signal.h>
+#include <sys/file.h>

 #include <stdio.h>
 #include <stdio.h>

+#include "pathnames.h"

 
 #define dbprintf printf
 
 
 #define dbprintf printf
 


@@ -22,10 +36,10 @@ struct      rt_axent {
 
 struct rt_ent {
        char    rt_pad;         /* unusued */
 
 struct rt_ent {
        char    rt_pad;         /* unusued */

-       char    rt_stat;        /* type of entry, or end of seg */
+       u_char  rt_stat;        /* type of entry, or end of seg */

        u_short rt_name[3];     /* name, 3 words in rad50 form */
        u_short rt_len;         /* length of file */
        u_short rt_name[3];     /* name, 3 words in rad50 form */
        u_short rt_len;         /* length of file */

-       char    rt_chan;        /* only used in temporary files */
+       u_char  rt_chan;        /* only used in temporary files */

        char    rt_job;         /* only used in temporary files */
        struct  rt_dat rt_date; /* creation date */
 };
        char    rt_job;         /* only used in temporary files */
        struct  rt_dat rt_date; /* creation date */
 };


@@ -33,6 +47,7 @@ struct rt_ent {
 #define RT_TEMP                1
 #define RT_NULL                2
 #define RT_FILE                4
 #define RT_TEMP                1
 #define RT_NULL                2
 #define RT_FILE                4

+#define RT_PFILE       (0200|RT_FILE)  /* protected file */

 #define RT_ESEG                8
 
 #define RT_BLOCK       512     /* block size */
 #define RT_ESEG                8
 
 #define RT_BLOCK       512     /* block size */


@@ -52,6 +67,12 @@ struct       rt_dir {
        char            _dirpad[6];
 };
 
        char            _dirpad[6];
 };
 

+#define rd_numseg rt_axhead.rt_numseg
+#define rd_nxtseg rt_axhead.rt_nxtseg
+#define rd_lstseg rt_axhead.rt_lstseg
+#define rd_entpad rt_axhead.rt_entpad
+#define rd_stfile rt_axhead.rt_stfile
+

 typedef struct fldope {
        int     startad;
        int     count;
 typedef struct fldope {
        int     startad;
        int     count;


@@ -71,8 +92,16 @@ char zeroes[512];
 extern char *val;
 extern char table[256];
 struct rt_dir rt_dir[RT_DIRSIZE] = {
 extern char *val;
 extern char table[256];
 struct rt_dir rt_dir[RT_DIRSIZE] = {

+       {

        { 4, 0, 1, 0, 14 },
        { 4, 0, 1, 0, 14 },

-       { { 0, RT_NULL, { 0, 0, 0 }, 494, 0 },
+       { { 0, RT_NULL, { 0, 0, 0 }, 486, 0 },
+         { 0, RT_ESEG } }
+       }
+};
+
+struct rt_dir rt_nulldir = {
+       { 0, 0, 0, 0, 0 },
+       { { 0, RT_NULL, { 0, 0, 0 }, 0, 0 },

          { 0, RT_ESEG } }
 };
 
          { 0, RT_ESEG } }
 };
 


@@ -82,11 +111,10 @@ struct rt_ent *rt_curend[RT_DIRSIZE];
 int    floppydes;
 int    dirdirty;
 char   *rt_last;
 int    floppydes;
 int    dirdirty;
 char   *rt_last;

-char   *defdev = "/dev/floppy";
+char   *defdev = _PATH_FLOPPY;

 
 

-char *opt = "vf";
+char *opt = "vfbcm";

 
 

-int    signum[] = {SIGHUP, SIGINT, SIGQUIT, 0};

 extern long lseek();
 int    rcmd(), dcmd(), xcmd(), tcmd();
 
 extern long lseek();
 int    rcmd(), dcmd(), xcmd(), tcmd();
 


@@ -94,7 +122,6 @@ int  (*comfun)();
 char   flg[26];
 char   **namv;
 int    namc;
 char   flg[26];
 char   **namv;
 int    namc;

-int    file;

 
 main(argc, argv)
        char *argv[];
 
 main(argc, argv)
        char *argv[];


@@ -110,22 +137,11 @@ main(argc, argv)
                case 'v':
                case 'u':
                case 'w':
                case 'v':
                case 'u':
                case 'w':

+               case 'b':

                        flg[*cp-'a']++;
                        continue;
                case 'c':
                        flg[*cp-'a']++;
                        continue;
                case 'c':

-                       {
-#define SURE   "Are you sure you want to clobber the floppy?"
-                               int tty;
-                               char response[128];
-
-                               tty = open("/dev/tty", 2);
-                               write(tty, SURE, sizeof(SURE));
-                               read(tty, response, sizeof(response));
-                               if (*response != 'y')
-                                       exit(50);
-                               flag(c)++;
-                               close(tty);
-                       }
+                       flag(c)++;

                        dirdirty++;
                        continue;
 
                        dirdirty++;
                        continue;
 


@@ -200,13 +216,6 @@ notfound()
        return (n);
 }
 
        return (n);
 }
 

-mesg(c)
-{
-       if (flag(v))
-               if (c != 'c' || flag(v) > 1)
-                       printf("%c - %s\n", c, file);
-}
-

 tcmd()
 {
        register char *de, *last;
 tcmd()
 {
        register char *de, *last;


@@ -220,13 +229,13 @@ tcmd()
                for (i = 0; i < namc; i++)
                        if (dope = lookup(namv[i])) {
                                rde = dope->rtdope;
                for (i = 0; i < namc; i++)
                        if (dope = lookup(namv[i])) {
                                rde = dope->rtdope;

-                               rtls(rde);
+                               (void) rtls(rde);

                                namv[i] = 0;
                        }
                return;
        }
        for (segnum = 0; segnum != -1;
                                namv[i] = 0;
                        }
                return;
        }
        for (segnum = 0; segnum != -1;

-         segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
+         segnum = rt_dir[segnum].rd_nxtseg - 1) {

                last = rt_last + segnum*2*RT_BLOCK;
                for (de = ((char *)&rt_dir[segnum])+10; de <= last; 
                    de += rt_entsiz)
                last = rt_last + segnum*2*RT_BLOCK;
                for (de = ((char *)&rt_dir[segnum])+10; de <= last; 
                    de += rt_entsiz)


@@ -253,6 +262,7 @@ rtls(de)
                /* fall thru...*/
 
        case RT_FILE:
                /* fall thru...*/
 
        case RT_FILE:

+       case RT_PFILE:

                if (!flag(v)) {
                        sunrad50(name, de->rt_name);
                        printf("%s\n", name);
                if (!flag(v)) {
                        sunrad50(name, de->rt_name);
                        printf("%s\n", name);


@@ -292,23 +302,27 @@ xcmd()
                return;
        }
        for (segnum = 0; segnum != -1;
                return;
        }
        for (segnum = 0; segnum != -1;

-            segnum = rt_dir[segnum].rt_axhead.rt_nxtseg-1)
+            segnum = rt_dir[segnum].rd_nxtseg-1)

                for (last = rt_last+(segnum*2*RT_BLOCK),
                     de = ((char *)&rt_dir[segnum])+10; de <= last; 
                for (last = rt_last+(segnum*2*RT_BLOCK),
                     de = ((char *)&rt_dir[segnum])+10; de <= last; 

-                    de += rt_entsiz)
+                    de += rt_entsiz) {

                        switch (rt(de)->rt_stat) {
 
                        case RT_ESEG:
                        switch (rt(de)->rt_stat) {
 
                        case RT_ESEG:

-                               return;
+                               break;  /* exit loop and try next segment */

 
                        case RT_TEMP:
                        case RT_FILE:
 
                        case RT_TEMP:
                        case RT_FILE:

+                       case RT_PFILE:

                                sunrad50(name,rt(de)->rt_name);
                                sunrad50(name,rt(de)->rt_name);

-                               rtx(name);
+                               (void) rtx(name);

 
                        case RT_NULL:
 
                        case RT_NULL:

-                               break;
+                       default:
+                               continue;

                        }
                        }

+                       break;
+               }

 }
 
 rtx(name)
 }
 
 rtx(name)


@@ -323,7 +337,7 @@ rtx(name)
 
        if (dope = lookup(name)) {
                if (flag(v))
 
        if (dope = lookup(name)) {
                if (flag(v))

-                       rtls(dope->rtdope);
+                       (void) rtls(dope->rtdope);

                else
                        printf("x - %s\n",name);
 
                else
                        printf("x - %s\n",name);
 


@@ -332,11 +346,11 @@ rtx(name)
                count = dope->count;
                startad = dope->startad;
                for( ; count > 0 ; count -= 512) {
                count = dope->count;
                startad = dope->startad;
                for( ; count > 0 ; count -= 512) {

-                       lread(startad, 512, buff);
-                       write(file, buff, 512);
+                       (void) lread(startad, 512, buff);
+                       (void) write(file, buff, 512);

                        startad += 512;
                }
                        startad += 512;
                }

-               close(file);
+               (void) close(file);

                return (0);
        }
        return (1);
                return (0);
        }
        return (1);


@@ -354,6 +368,23 @@ rt_init()
        if (initized)
                return;
        initized = 1;
        if (initized)
                return;
        initized = 1;

+       if (flag(c)) {
+               struct stat sb;
+               char response[128];
+               int tty;
+
+               if (stat(defdev, &sb) >= 0 && (sb.st_mode & S_IFMT) == S_IFREG)
+                       goto ignore;
+               tty = open(_PATH_TTY, O_RDWR);
+#define SURE   "Are you sure you want to clobber the floppy? "
+               (void) write(tty, SURE, sizeof (SURE));
+               (void) read(tty, response, sizeof (response));
+               if (*response != 'y')
+                       exit(50);
+               (void) close(tty);
+ignore:
+               ;
+       }

        if (flag(c) || flag(d) || flag(r))
                mode = "r+";
        else
        if (flag(c) || flag(d) || flag(r))
                mode = "r+";
        else


@@ -364,8 +395,9 @@ rt_init()
        } else
                floppydes = fileno(temp_floppydes);
        if (!flag(c)) {
        } else
                floppydes = fileno(temp_floppydes);
        if (!flag(c)) {

-               lread(6*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[0]);
-               dirnum = rt_dir[0].rt_axhead.rt_numseg;
+               if (lread(6*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[0]))
+                       exit(2);
+               dirnum = rt_dir[0].rd_numseg;

                /* check for blank/uninitialized diskette */
                if (dirnum <= 0) {
                        fprintf(stderr,"arff: bad directory format\n");
                /* check for blank/uninitialized diskette */
                if (dirnum <= 0) {
                        fprintf(stderr,"arff: bad directory format\n");


@@ -376,12 +408,25 @@ rt_init()
                        exit(1);
                }
                for (i = 1; i < dirnum; i++)
                        exit(1);
                }
                for (i = 1; i < dirnum; i++)

-                       lread((6+2*i)*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[i]);
-       } else
+                   if (lread((6+2*i)*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[i]))
+                       exit(1);
+       } else {

                dirnum = 1;
                dirnum = 1;

+               if (flag(b)) {
+                       rt_dir[0].rd_numseg = 31;
+                       rt_dir[0].rd_stfile = 68;
+                       rt_dir[0].rt_ents[0].rt_len = 20480 - 68;
+               }
+       }

 
 

-       rt_entsiz = 2*rt_dir[0].rt_axhead.rt_entpad + 14;
-       rt_entsiz = 14;                 /* assume rt_entpad = 0 ??? */
+       rt_entsiz = 2*rt_dir[0].rd_entpad + 14;
+       /*
+        * We assume that the directory entries have no padding.  This
+        * may not be a valid assumption, but there are numerous point
+        * in the code where it assumes it is an rt_ent structure and
+        * not an rt_entsiz sized structure.
+        */
+       rt_entsiz = 14;

        rt_last = ((char *) &rt_dir[0]) + 10 + 1014/rt_entsiz*rt_entsiz; 
        rt_nleft = 0;
        
        rt_last = ((char *) &rt_dir[0]) + 10 + 1014/rt_entsiz*rt_entsiz; 
        rt_nleft = 0;
        


@@ -402,7 +447,7 @@ lookup(name)
        char *name;
 {
        unsigned short rname[3];
        char *name;
 {
        unsigned short rname[3];

-       register char *de, *last;
+       register char *de;

        int segnum;
        register index;
 
        int segnum;
        register index;
 


@@ -413,20 +458,20 @@ lookup(name)
         */
        rt_init();
        for (segnum = 0; segnum != -1;
         */
        rt_init();
        for (segnum = 0; segnum != -1;

-            segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1)
+            segnum = rt_dir[segnum].rd_nxtseg - 1)

        {
                index = 0;
        {
                index = 0;

-               last = rt_last + segnum*2*RT_BLOCK;

                for (de=((char *)&rt_dir[segnum])+10; 
                     rt(de)->rt_stat != RT_ESEG; de += rt_entsiz)
                        switch(rt(de)->rt_stat) {
 
                        case RT_FILE:
                for (de=((char *)&rt_dir[segnum])+10; 
                     rt(de)->rt_stat != RT_ESEG; de += rt_entsiz)
                        switch(rt(de)->rt_stat) {
 
                        case RT_FILE:

+                       case RT_PFILE:

                        case RT_TEMP:
                                if(samename(rname,rt(de)->rt_name)) {
                                        result.count = rt(de)->rt_len * 512;
                                        result.startad = 512*
                        case RT_TEMP:
                                if(samename(rname,rt(de)->rt_name)) {
                                        result.count = rt(de)->rt_len * 512;
                                        result.startad = 512*

-                                               (rt_dir[segnum].rt_axhead.rt_stfile + index);
+                                           (rt_dir[segnum].rd_stfile + index);

                                        result.rtdope = (struct rt_ent *) de;
                                        return (&result);
                                }
                                        result.rtdope = (struct rt_ent *) de;
                                        return (&result);
                                }


@@ -549,7 +594,6 @@ sunrad50(name, rname)
                cp[-1] = 0;
 }
 
                cp[-1] = 0;
 }
 

-static char *oval = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$.@0123456789";

 static char *val = " abcdefghijklmnopqrstuvwxyz$.@0123456789";
 
 static char table[256] = {
 static char *val = " abcdefghijklmnopqrstuvwxyz$.@0123456789";
 
 static char table[256] = {


@@ -599,17 +643,24 @@ lread(startad, count, obuff)
        long trans();
        extern floppydes;
        register int size = flag(m) ? 512 : 128;
        long trans();
        extern floppydes;
        register int size = flag(m) ? 512 : 128;

+       int error = 0;
+       extern int errno;

 
        rt_init();
        while ((count -= size) >= 0) {
 
        rt_init();
        while ((count -= size) >= 0) {

-               lseek(floppydes, flag(m) ?
+               (void) lseek(floppydes, flag(m) ?

                        (long)startad : trans(startad), 0);
                        (long)startad : trans(startad), 0);

-               if (read(floppydes, obuff, size) != size)
-                       fprintf(stderr, "arff: read error block %d\n",
+               if (read(floppydes, obuff, size) != size) {
+                       error = errno;
+                       fprintf(stderr, "arff: read error block %d: ",

                                startad/size);
                                startad/size);

+                       errno = error;
+                       perror("");
+               }

                obuff += size;
                startad += size;
        }
                obuff += size;
                startad += size;
        }

+       return (error);

 }
 
 lwrite(startad, count, obuff)
 }
 
 lwrite(startad, count, obuff)


@@ -622,7 +673,7 @@ lwrite(startad, count, obuff)
 
        rt_init();
        while ((count -= size) >= 0) {
 
        rt_init();
        while ((count -= size) >= 0) {

-               lseek(floppydes, flag(m) ?
+               (void) lseek(floppydes, flag(m) ?

                        (long)startad : trans(startad), 0);
                if (write(floppydes, obuff, size) != size)
                        fprintf(stderr, "arff: write error block %d\n",
                        (long)startad : trans(startad), 0);
                if (write(floppydes, obuff, size) != size)
                        fprintf(stderr, "arff: write error block %d\n",


@@ -651,45 +702,52 @@ rtr(name)
        struct stat buf;
        register struct stat *bufp = &buf;
        int segnum;
        struct stat buf;
        register struct stat *bufp = &buf;
        int segnum;

-       register char *last;
+       char type;

 
        if (stat(name, bufp) < 0) {
                perror(name);
                return (-1);
        }
 
        if (stat(name, bufp) < 0) {
                perror(name);
                return (-1);
        }

+       type = 'a';

        if (dope = lookup(name)) {
                /* can replace, no problem */
                de = dope->rtdope;
        if (dope = lookup(name)) {
                /* can replace, no problem */
                de = dope->rtdope;

-               if (bufp->st_size <= (de->rt_len * 512))
-                       printf("r - %s\n",name),
+               if (bufp->st_size <= (de->rt_len * 512)) {
+                       printf("r - %s\n",name);

                        toflop(name, bufp->st_size, dope);
                        toflop(name, bufp->st_size, dope);

-               else {
-                       fprintf(stderr,
-                         "%s will not fit in currently used file on floppy\n",
-                         name);
-                       return (-1);
+                       goto found;
+               } else {
+                       de = dope->rtdope;
+                       type = 'r';
+                       de->rt_stat = RT_NULL;
+                       de->rt_name[0] = 0;
+                       de->rt_name[1] = 0;
+                       de->rt_name[2] = 0;
+                       *((u_short *)&(de->rt_date)) = 0;
+                       scrunch();

                }
                }

-               goto found;

        }
        /*
         * Search for vacant spot
         */
        for (segnum = 0; segnum != -1;
        }
        /*
         * Search for vacant spot
         */
        for (segnum = 0; segnum != -1;

-            segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1)
+            segnum = rt_dir[segnum].rd_nxtseg - 1)

        {
        {

-               last = rt_last + segnum*2*RT_BLOCK;

                for (de = rt_dir[segnum].rt_ents;
                    rt(de)->rt_stat != RT_ESEG; de++)
                        if ((de)->rt_stat == RT_NULL) {
                                if (bufp->st_size <= (de->rt_len*512)) {
                for (de = rt_dir[segnum].rt_ents;
                    rt(de)->rt_stat != RT_ESEG; de++)
                        if ((de)->rt_stat == RT_NULL) {
                                if (bufp->st_size <= (de->rt_len*512)) {

-                                       printf("a - %s\n",name),
+                                       printf("%c - %s\n", type, name),

                                        mkent(de, segnum, bufp,name);
                                        goto found;
                                }
                                continue;
                        }
        }
                                        mkent(de, segnum, bufp,name);
                                        goto found;
                                }
                                continue;
                        }
        }

-       printf("%s: no slot for file\n", name);
+       if (type == 'r')
+               printf("%s: no slot for file, file deleted\n",name);
+       else
+               printf("%s: no slot for file\n", name);

        return (-1);
 
 found:
        return (-1);
 
 found:


@@ -717,12 +775,54 @@ mkent(de, segnum, bufp, name)
        if (de->rt_len == count)
                goto overwrite;
        if ((char *)rt_curend[segnum] == (rt_last + (segnum*2*RT_BLOCK))) {
        if (de->rt_len == count)
                goto overwrite;
        if ((char *)rt_curend[segnum] == (rt_last + (segnum*2*RT_BLOCK))) {

-               /* no entries left on segment */
-               if (flag(o))
-                       goto overwrite;
-               fprintf(stderr, "Directory segment #%d full on  %s\n",
-                       segnum+1, defdev);
-               exit(1);
+               /* no entries left on segment, trying adding new segment */
+               if (rt_dir[0].rd_numseg > rt_dir[0].rd_lstseg) {
+                       short newseg;
+                       register int i;
+                       int maxseg;
+                       short size;
+
+                       newseg = rt_dir[0].rd_lstseg++;
+                       rt_dir[newseg] = rt_nulldir;
+                       rt_dir[newseg].rd_nxtseg = rt_dir[segnum].rd_nxtseg;
+                       rt_dir[segnum].rd_nxtseg = newseg + 1;
+                       rt_dir[newseg].rd_entpad = rt_dir[0].rd_entpad;
+                       rt_dir[newseg].rd_numseg = rt_dir[0].rd_numseg;
+                       size = 0;
+                       maxseg = 0;
+                       for(i = newseg - 1; i >= 0; i--) {
+                               workp = rt_curend[i] - 1;
+                               if (workp->rt_stat != RT_NULL)
+                                       continue;
+                               if (workp->rt_len < size)
+                                       continue;
+                               size = workp->rt_len;
+                               maxseg = i;
+                       }
+                       size = 0;
+                       for (workp = &rt_dir[maxseg].rt_ents[0]; 
+                           workp->rt_stat != RT_ESEG; workp++) {
+                               size += workp->rt_len;
+                       }
+                       workp--;
+                       rt_dir[newseg].rt_ents[0].rt_len = workp->rt_len;
+                       rt_dir[newseg].rd_stfile = 
+                           rt_dir[maxseg].rd_stfile + size - workp->rt_len;
+                       workp->rt_len = 0;
+                       rt_curend[newseg] = &rt_dir[newseg].rt_ents[1];
+                       lwrite(6*RT_BLOCK, 2*RT_BLOCK, (char *)&rt_dir[0]);
+                       if (segnum != 0)
+                               lwrite((6+segnum*2)*RT_BLOCK, 2*RT_BLOCK,
+                                   (char *)&rt_dir[segnum]);
+                       lwrite((6+newseg*2)*RT_BLOCK, 2*RT_BLOCK,
+                           (char *)&rt_dir[newseg]);
+                       segnum = newseg;
+                       de = &rt_dir[newseg].rt_ents[0];
+               } else {
+                       fprintf(stderr, "All directory segments full on  %s\n",
+                               defdev);
+                       exit(1);
+               }

        }       
        /* copy directory entries up */
        for (workp = rt_curend[segnum]+1; workp > de; workp--)
        }       
        /* copy directory entries up */
        for (workp = rt_curend[segnum]+1; workp > de; workp--)


@@ -759,12 +859,12 @@ toflop(name, ocount, dope)
                exit(1);
        }
        for( ; count >= 512; count -= 512) {
                exit(1);
        }
        for( ; count >= 512; count -= 512) {

-               read(file, buff, 512);
+               (void) read(file, buff, 512);

                lwrite(startad, 512, buff);
                startad += 512;
        }
                lwrite(startad, 512, buff);
                startad += 512;
        }

-       read(file, buff, count);
-       close(file);
+       (void) read(file, buff, count);
+       (void) close(file);

        if (count <= 0)
                return;
        for (n = count; n < 512; n ++)
        if (count <= 0)
                return;
        for (n = count; n < 512; n ++)


@@ -819,7 +919,7 @@ scrunch()
        register segnum;
 
        for (segnum = 0; segnum != -1;
        register segnum;
 
        for (segnum = 0; segnum != -1;

-            segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
+            segnum = rt_dir[segnum].rd_nxtseg - 1) {

                for (de = rt_dir[segnum].rt_ents; de <= rt_curend[segnum]; de++)
                        if (de->rt_stat == RT_NULL &&
                            (de+1)->rt_stat == RT_NULL) {
                for (de = rt_dir[segnum].rt_ents; de <= rt_curend[segnum]; de++)
                        if (de->rt_stat == RT_NULL &&
                            (de+1)->rt_stat == RT_NULL) {