cmd/ie/history.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1984-2011 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                  David Korn <dgk@research.att.com>                   *
*                             Pat Sullivan                             *
*                                                                      *
***********************************************************************/
/*
 *   History file manipulation routines
 *
 *   David Korn
 *   AT&T Bell Laboratories
 *   Room 3C-526B
 *   Murray Hill, N. J. 07974
 *   Tel. x7975
 *
 */

/*
 * Each command in the history file starts on an even byte is null terminated.
 * The first byte must contain the special character H_UNDO and the second
 * byte is the version number.  The sequence H_UNDO 0, following a command,
 * nullifies the previous command. A six byte sequence starting with
 * H_CMDNO is used to store the command number so that it is not necessary
 * to read the file from beginning to end to get to the last block of
 * commands.  This format of this sequence is different in version 1
 * then in version 0.  Version 1 allows commands to use the full 8 bit
 * character set.  It can understand version 0 format files.
 */


#ifdef KSHELL
#   include "defs.h"
#   include "builtins.h"
#else
#   include "io.h"
#   include "edit.h"
#   include <signal.h>
#   include <ctype.h>
#endif  /* KSHELL */
#include    "history.h"
#ifdef MULTIBYTE
#   include "national.h"
#endif /* MULTIBYTE */
#include    <tm.h>

#ifndef KSHELL
#   define sh_heap(s)       strcpy(malloc(strlen(s)+1),(s))
#   define sh_arith(str)    (int)strtol(str,(char**)0,10)
#   define new_of(type,x)   ((type*)malloc((unsigned)sizeof(type)+(x)))
#   define e_unknown        "unknown"
#   define e_create     "cannot create"
#   define path_relative(x) (x)
    static int          io_readbuff();
    static off_t        io_seek();
    static void         io_fclose();
    static int          io_getc();
    static void         io_init();
    static int          io_renumber();
    static int          io_mktmp();
    const char hist_fname[] =   "/.history";
    struct history      *hist_ptr = 0;
#endif  /* KSHELL */


static int fixmask;
static int noclean;
static void hist_trim();
static int hist_nearend();
static int hist_check();
static int hist_clean();
static void hist_free();
static int hist_version;
static struct history *wasopen;
static off_t hist_marker;   /* offset of last command marker */
static char htrim;      /* set while in hist_trim */
static const unsigned char hist_stamp[2] = { H_UNDO, H_VERSION };

#define HIST_RECENT 600

/*
 * open the history file
 * if HISTNAME is not given and userid==0 then no history file.
 * if login_sh and HISTFILE is longer than HISTMAX bytes then it is
 * cleaned up.
 * hist_open() returns 1, if histor file is open
 */

int  hist_open()
{
    register int fd;
    register struct history *fp;
    register char *histname;
    char fname[TMPSIZ];
    char hname[256];
    int maxlines;
    register char *cp;
    register off_t hsize = 0;
    int his_start;

    if(hist_ptr)
        return(1);
    histname = nam_strval(HISTFILE);
    if(!histname)
    {

        if(cp=nam_strval(HOME))
            cp = sh_copy(cp,hname);
        else
            cp = hname;
        sh_copy(hist_fname,cp);
        histname = hname;
    }
    *fname = 0;
    if(fp=wasopen)
    {
        /* reuse history file if same name */
        wasopen = 0;
        hist_ptr = fp;
        if(strcmp(histname,fp->fixname)==0)
            return(1);
        else
            hist_free();
    }
retry:
    histname = path_relative(histname);
    if((fd=open(histname,O_APPEND|O_RDWR|O_CREAT|O_BINARY,S_IRUSR|S_IWUSR))>=0)
    {
        hsize=io_seek(fd,(off_t)0,SEEK_END);
    }
    /* make sure that file has history file format */
    if(hsize && hist_check(fd))
    {
        io_fclose(fd);
        hsize = 0;
        if(unlink(histname)>=0)
            goto retry;
        fd = -1;
    }
    if(fd < 0)
    {
#ifdef KSHELL
        /* don't allow root a history_file in /tmp */
        if(sh.userid)
#endif  /* KSHELL */
            fd = io_mktmp(fname, sizeof(fname));
    }
    if(fd<0)
        return(0);
    fd = io_renumber(fd,FCIO);
    if(cp=nam_strval(HISTSIZE))
        maxlines = (unsigned)sh_arith(cp);
    else
        maxlines = HIS_DFLT;
    for(fixmask=16;fixmask <= maxlines; fixmask <<=1 );
    if(!(fp=new_of(struct history,(--fixmask)*sizeof(off_t))))
    {
        io_fclose(fd);
        return(0);
    }
    hist_ptr = fp;
    fp->fixfd = fd;
    fp->fixmax = maxlines;
    io_init(fd,(struct fileblk*)0,(char*)0);
    fp->fixfp = io_ftable[fd];
    fp->fixind = 1;
    fp->fixcmds[1] = 2;
    fp->fixcnt = 2;
    fp->fixname = sh_heap(histname);
    if(hsize==0)
        /* put special characters at front of file */
    {
        write(fd,(char*)hist_stamp,2);
        p_setout(fd);
    }
    /* initialize history list */
    else
    {
        int first;
        off_t size = (HISMAX/4)+maxlines*HISLINE;
        first = fp->fixind = hist_nearend(fd,hsize-size);
        hist_eof();  /* this sets fixind to last command */
        his_start = fp->fixind-maxlines;
        if(his_start <=0)
            his_start = 1;
        while(first > his_start)
        {
            size += size;
            first = hist_nearend(fd,hsize-size);
            fp->fixind = first;
        }
        hist_eof();
    }
    if(*fname)
        unlink(fname);
    if(hist_clean(fp->fixfd) && his_start>1 && hsize > HISMAX)
    {
#ifdef DEBUG
        p_setout(ERRIO);
        p_num(getpid(),':');
        p_str("hist_trim hsize",'=');
        p_num(hsize,NL);
        p_flush();
#endif /* DEBUG */
        hist_trim(fp->fixind-maxlines);
    }
    return(1);
}

/*
 * close the history file and free the space
 */

static void hist_free()
{
    register struct history *fp = hist_ptr;
    io_fclose(fp->fixfd);
    free((char*)fp);
    hist_ptr = 0;
}

/*
 * check history file format to see if it begins with special byte
 */

static int hist_check(fd)
register int fd;
{
    unsigned char magic[2];
    io_seek(fd,(off_t)0,SEEK_SET);
    if((read(fd,(char*)magic,2)!=2) || (magic[0]!=H_UNDO))
        return(1);
    hist_version = magic[1];
    return(0);
}

/*
 * Decide whether to clean out the history file
 */

#ifdef YELLOWP
   /* NFS systems do not handle file locking correctly */
#  undef F_SETLK
#endif /* YELLOWP */
#ifdef _FLOCK
#  undef F_SETLK
#  ifndef LOCK_EX
#    include <sys/file.h>
#  endif
#endif /*_FLOCK */
#ifdef F_SETLK
#  if defined(F_SETLK) && !defined(F_WRLCK)
#     undef F_SETLK
#  endif
   static struct flock hislock = { F_WRLCK, 0, (off_t)0, (off_t)2, (pid_t)0 };
#endif
static int hist_clean(fd)
register int fd;
{
    register int r = 0;
    struct stat statb;
    if(noclean)
        return(0);
#ifdef _FLOCK
    r = (flock(fd,LOCK_NB|LOCK_EX)==0);
#else
#  ifdef F_SETLK
    r = (fcntl(fd,F_SETLK,&hislock)==0);
#  else
#   ifdef KSHELL
        r = sh.login_sh;
#   endif /* KSHELL */
#  endif
#endif
    if(fstat(fd,&statb)>=0)
    {
        /* see if history file was recently accessed */
        if(r)
        {
            if((time((time_t*)0)-statb.st_mtime) < HIST_RECENT)
                r = 0;
        }
    }
    return(r);
}

/*
 * Copy the last <n> commands to a new file and make this the history file
 */

static void hist_trim(n)
    int n;
{
    register int c;
    register struct fileblk *fp;
    register struct history *hist_new;
    struct history *hist_old = hist_ptr;
    off_t old,new=0;
    int fdo;
    /* move to an available descriptor >= USERIO */
    fdo= io_renumber(hist_ptr->fixfd,fcntl(hist_ptr->fixfd,F_DUPFD,USERIO));
    hist_ptr->fixfd = fdo;
    unlink(hist_ptr->fixname);
    hist_ptr = 0;
    if(!hist_open())
    {
        /* use the old history file */
        hist_ptr = hist_old;
        hist_ptr->fixfd = io_renumber(fdo,FCIO);
        return;
    }
    hist_new = hist_ptr;
    p_setout(hist_new->fixfd);
    fp = hist_new->fixfp;
    if(n < 0)
        n = 0;
    htrim++;
    do
    {
        hist_ptr = hist_old;
        old = new;
        new = io_seek(fdo,hist_position(++n),SEEK_SET);
        hist_ptr = hist_new;
        while((c=io_getc(fdo))!=EOF && c)
        {
            if(fp->ptr >= fp->last)
                p_flush();
            *fp->ptr++ = c;
            hist_new->fixcnt++;
        }
#ifdef KSHELL
        st.states |= FIXFLG;
#endif  /* KSHELL */
        hist_flush();
    }
    while(new>old && c!=EOF);
    htrim = 0;
    hist_cancel();
    io_fclose(fdo);
    free((char*)hist_old);
}

/*
 * position history file at size and find next command number
 */

static int hist_nearend(fd,size)
register int fd;
off_t size;
{
    register int n = 0;
    register int state = 0;
    register int c;
    if(size <=0)
        goto begin;
    io_seek(fd,size,SEEK_SET);
    /* skip to numbered command and return the number */
    /* numbering commands occur after a null and begin with H_CMDNO */
    while((c=io_getc(fd))!=EOF) switch(state)
    {
        case 1:
            if(c==H_CMDNO)
            {
                hist_ptr->fixcnt = size + n + 6;
                state = 2;
            }
            break;

        case 2:
            /* see if H_CMDNO is followed by 0 */
            if(hist_version && c)
            {
                n += 2;
                state = 0;
                break;
            }
            n = 0;

        case 3:
        case 4:
        case 5:
            if(hist_version)
                n = (n<<8) + c;
            else if(state<4)
                n = (n<<7) + (c&0177);
            state++;
            break;

        case 6:
            return(n);

        default:
            state = (c==0);
            n++;
    }
begin:
    io_seek(fd,(off_t)2,SEEK_SET);
    hist_ptr->fixcnt = 2;
    return(1);
}

/*
 * This routine marks the history file as closed.  The file actually
 * closes when the program exits, or when you open a history file
 * with a different name.
 */

void hist_close()
{
    wasopen = hist_ptr;
    hist_ptr = 0;
}

/*
 * This routine reads the history file from the present position
 * to the end-of-file and puts the information in the in-core
 * history table
 * Note that H_CMDNO is only recognized at the beginning of a command
 * and that H_UNDO as the first character of a command is skipped
 * unless it is followed by 0.  If followed by 0 then it cancels
 * the previous command.
 */

void hist_eof()
{
    register struct history *fp = hist_ptr;
    register int c;
    register int incr = 0;
    register int oldc = 0;
    register off_t count = fp->fixcnt;
    int skip = 0;
    io_seek(fp->fixfd,count,SEEK_SET);
#ifdef INT16
    while((c=io_getc(fp->fixfd))!=EOF)
    {
#else
    /* could use io_getc() but this is faster */
    while(1)
    {
        c = *(fp->fixfp->ptr)++;
        if(c==0 && (fp->fixfp->ptr > fp->fixfp->last))
        {
            c = io_readbuff(fp->fixfp);
            if(c == EOF)
                break;
        }
        c &= STRIP;
#endif /* INT16 */
        count++;
        if(skip-- > 0)
        {
            if(skip==2)
                hist_marker = count;
            oldc = 0;
            continue;
        }
        if(c == 0)
        {
            if(oldc==H_CMDNO && incr==0)
                skip = 3;
            fp->fixind += incr;
            fp->fixcmds[fp->fixind&fixmask] = count;
            incr = 0;
        }
        else if(oldc == 0)
        {
            if(c == H_CMDNO)
            {
                /* old format history file */
                if(hist_version==0)
                    skip = 4;
                incr = 0;
            }
            else if(c==H_UNDO)
                incr = -1;
        }
        else
            incr = 1;
        oldc = c;
    }
    fp->fixcnt = count;
    p_setout(fp->fixfd);
}

/*
 * This routine will cause the previous command to be cancelled
 */

void hist_cancel()
{
    register struct history *fp = hist_ptr;
    register int c;
    if(!fp)
        return;
    p_setout(fp->fixfd);
    p_char(H_UNDO);
    p_char(0);
    p_flush();
    fp->fixcnt += 2;
    c = (--fp->fixind)&fixmask;
    fp->fixcmds[c] = fp->fixcnt;
}

/*
 * This routine adds one or two null bytes and flushes the history buffer
 */

void hist_flush()
{
    register struct history *fp = hist_ptr;
    register struct fileblk *fd;
    register int c;
    int flush = 0;
    int savcount;
    if(!fp)
        return;
#ifdef KSHELL
    if(!(st.states&FIXFLG))
        return;
    st.states &= ~FIXFLG;
#endif  /* KSHELL */
    fd = fp->fixfp;
    if(htrim)
    {
        p_char(0);
        fp->fixcnt++;
        goto set_count;
    }
    if((fp->fixcnt=lseek(fp->fixfd,(off_t)0,SEEK_END)) <0)
    {
#ifdef DEBUG
        p_setout(ERRIO);
        p_num(getpid(),':');
        p_str("hist_flush: EOF seek failed errno",'=');
        p_num(errno,NL);
        p_flush();
#endif /* DEBUG */
        hist_free();
        noclean++;
        if(!htrim)
            hist_open();
        noclean = 0;
        return;
    }
    p_setout(fp->fixfd);
    /* remove whitespace from end of commands */
    while(--fd->ptr >= fd->base)
    {
        c= *fd->ptr;
        if(!isspace(c))
        {
            if(c=='\\' && *(fd->ptr+1)!='\n')
                fd->ptr++;
            break;
        }
    }
    /* don't count empty lines */
    if(++fd->ptr <= fd->base && !fp->fixflush)
    {
        fp->fixind--;
        goto set_count;
    }
    p_char('\n');
    p_char(0);
    flush++;
    fp->fixcnt += (fd->ptr-fd->base);
set_count:
    /* start each command on an even byte boundary */
    if(fp->fixcnt&01)
    {
        fp->fixcnt++;
        p_char(0);
        flush++;
    }
    c = (++fp->fixind)&fixmask;
    savcount = fp->fixcmds[c];
    fp->fixcmds[c] = fp->fixcnt;
    if(fp->fixcnt > hist_marker+IOBSIZE/2)
    {
        /* put line number in file */
        fp->fixcnt += 6;
        p_char(H_CMDNO);
        p_char(0);
        c = (fp->fixind>>16);
        p_char(c);
        c = (fp->fixind>>8);
        p_char(c);
        c = fp->fixind;
        p_char(c);
        p_char(0);
        flush++;
        fp->fixcmds[c&fixmask] = fp->fixcnt;
        hist_marker = fp->fixcnt;
    }
    if(flush && !htrim)
    {
        p_flush();
        /* check for write errors, like ulimit */
        if(fd->flag&IOERR)
        {
            c = (fp->fixind--)&fixmask;
            fp->fixcmds[c] = savcount;
        }
    }
    fp->fixflush = 0;
}

/*
 * return byte offset in history file for command <n>
 */

off_t hist_position(n)
int n;
{
    register struct history *fp = hist_ptr;
    return(fp->fixcmds[n&fixmask]);
}

/*
 * write the command starting at offset <offset> onto file <fd>.
 * if character <last> appears before newline it is deleted
 * each new-line character is replaced with string <nl>.
 */

void hist_list(offset,last,nl)
off_t offset;
int last;
char *nl;
{
    register int oldc=0;
    register int c;
    register struct history *fp = hist_ptr;
    if(offset<0 || !fp)
    {
        p_str(e_unknown,'\n');
        return;
    }
    io_seek(fp->fixfd,offset,SEEK_SET);
    while((c = io_getc(fp->fixfd)) != EOF)
    {
        if(c && oldc=='\n')
            p_str(nl,0);
        else if(oldc==last &&  c=='\n')
            return;
        else if(c==0 && last)
            return;
        else if(oldc)
            p_char(oldc);
        oldc = c;
        if(c==0)
            return;
    }
    return;
}

/*
 * find index for last line with given string
 * If flag==0 then line must begin with string
 * direction < 1 for backwards search
*/

histloc hist_find(string,index1,flag,direction)
char *string;
register int index1;
int flag;
int direction;
{
    register struct history *fp = hist_ptr;
    register int index2;
    off_t offset;
    histloc location;
    location.his_command = -1;
    if(!fp)
        return(location);
    /* leading ^ means beginning of line unless escaped */
    if(flag)
    {
        index2 = *string;
        if(index2=='\\')
            string++;
        else if(index2=='^')
        {
            flag=0;
            string++;
        }
    }
    index2 = fp->fixind;
    if(direction<0)
    {
        index2 -= fp->fixmax;
        if(index2<1)
            index2 = 1;
        if(index1 <= index2)
            return(location);
    }
    else if(index1 >= index2)
        return(location);
    while(index1!=index2)
    {
        direction>0?++index1:--index1;
        offset = hist_position(index1);
        if((location.his_line=hist_match(offset,string,flag))>=0)
        {
            location.his_command = index1;
            return(location);
        }
#ifdef KSHELL
        /* allow a search to be aborted */
        if(sh.trapnote&SIGSET)
            break;
#endif /* KSHELL */
    }
    return(location);
}

/*
 * search for <string> in history file starting at location <offset>
 * If flag==0 then line must begin with string
 * returns the line number of the match if successful, otherwise -1
 */

int hist_match(offset,string,flag)
off_t offset;
char *string;
int flag;
{
    register char *cp;
    register int c;
    register struct history *fp = hist_ptr;
    register off_t count;
    int line = 0;
#ifdef MULTIBYTE
    int nbytes = 0;
#endif /* MULTIBYTE */
    do
    {
        if(offset>=0)
        {
            io_seek(fp->fixfd,offset,SEEK_SET);
            count = offset;
        }
        offset = -1;
        for(cp=string;*cp;cp++)
        {
            if((c=io_getc(fp->fixfd)) == EOF || c ==0)
                break;
            count++;
#ifdef MULTIBYTE
            /* always position at character boundary */
            if(--nbytes > 0)
            {
                if(cp==string)
                {
                    cp--;
                    continue;
                }
            }
            else
            {
                nbytes = echarset(c);
                nbytes = in_csize(nbytes) + (nbytes>=2);
            }
#endif /* MULTIBYTE */
            if(c == '\n')
                line++;
            /* save earliest possible matching character */
            if(flag && c == *string && offset<0)
                offset = count;
            if(*cp != c )
                break;
        }
        if(*cp==0) /* match found */
            return(line);
    }
    while(flag && c && c != EOF);
    return(-1);
}


#if ESH || VSH
/*
 * copy command <command> from history file to s1
 * at most MAXLINE characters copied
 * if s1==0 the number of lines for the command is returned
 * line=linenumber  for emacs copy and only this line of command will be copied
 * line < 0 for full command copy
 * -1 returned if there is no history file
 */

int hist_copy(s1,command,line)
register char *s1;
int command, line;
{
    register int c;
    register struct history *fp = hist_ptr;
    register int count = 0;
    register char *s1max = s1+MAXLINE;
    off_t offset;
    if(!fp)
        return(-1);
    offset =  hist_position(command);
    io_seek(fp->fixfd,offset,SEEK_SET);
    while ((c = io_getc(fp->fixfd)) && c!=EOF)
    {
        if(c=='\n')
        {
            if(count++ ==line)
                break;
            else if(line >= 0)
                continue;
        }
        if(s1 && (line<0 || line==count))
        {
            if(s1 >= s1max)
            {
                *--s1 = 0;
                break;
            }
            *s1++ = c;
        }

    }
    io_seek(fp->fixfd,(off_t)0,SEEK_END);
    if(s1==0)
        return(count);
    if(count && (c= *(s1-1)) == '\n')
        s1--;
    *s1 = '\0';
    return(count);
}

/*
 * return word number <word> from command number <command>
 */

char *hist_word(s1,word)
char *s1;
int word;
{
    register int c;
    register char *cp = s1;
    register int flag = 0;
    if(hist_ptr==0)
#ifdef KSHELL
        return(sh.lastarg);
#else
        return((char*)0);
#endif /* KSHELL */
    hist_copy(s1,hist_ptr->fixind-1,-1);
    for(;c = *cp;cp++)
    {
        c = isspace(c);
        if(c && flag)
        {
            *cp = 0;
            if(--word==0)
                break;
            flag = 0;
        }
        else if(c==0 && flag==0)
        {
            s1 = cp;
            flag++;
        }
    }
    *cp = 0;
    return(s1);
}

#endif  /* ESH */

#ifdef ESH
/*
 * given the current command and line number,
 * and number of lines back or foward,
 * compute the new command and line number.
 */

histloc hist_locate(command,line,lines)
register int command;
register int line;
int lines;
{
    histloc next;
    line += lines;
    if(!hist_ptr)
    {
        command = -1;
        goto done;
    }
    if(lines > 0)
    {
        register int count;
        while(command <= hist_ptr->fixind)
        {
            count = hist_copy(NIL,command,-1);
            if(count > line)
                goto done;
            line -= count;
            command++;
        }
    }
    else
    {
        register int least = hist_ptr->fixind-hist_ptr->fixmax;
        while(1)
        {
            if(line >=0)
                goto done;
            if(--command < least)
                break;
            line += hist_copy(NIL,command,-1);
        }
        command = -1;
    }
    next.his_command = command;
    return(next);
done:
    next.his_line = line;
    next.his_command = command;
    return(next);
}
#endif  /* ESH */

#ifdef KSHELL

/*
 * given a file containing a command and a string of the form old=new,
 * execute the command with the string old replaced by new
 */
void hist_subst(command,fd,replace)
const char *command;
int fd;
char *replace;
{
    register char *new=replace;
    register char *sp;
    register int c;
    struct fileblk fb;
    char inbuff[IOBSIZE+1];
    char *string;
    while(*++new != '='); /* skip to '=' */
    io_init(fd,&fb,inbuff);
    stakseek(0);
    while ((c=io_getc(fd)) != EOF)
        stakputc(c);
    string = stakfreeze(1);
    io_fclose(fd);
    *new++ =  0;
    if((sp=sh_substitute(string,replace,new))==0)
        sh_fail(command,e_subst);
    *(new-1) =  '=';
    p_setout(hist_ptr->fixfd);
    p_str(sp,0);
    hist_flush();
    p_setout(ERRIO);
    p_str(sp,0);
    sh_eval(sp);
}

#else /* !KSHELL */

/*
 * initialize file structure
 */

static void io_init(fd,fp,buf)
int fd;
register struct fileblk *fp;
char *buf;
{
    if(!fp)
    {
        fp = new_of(struct fileblk,IOBSIZE+1);
        buf = (char*)(fp+1);
        fp->flag = IOFREE;
    }
    else
        fp->flag = 0;
    fp->fdes = fd;
    fp->fseek = 0;
    fp->base = fp->ptr  = fp->last = buf;
    *fp->ptr = 0;
    fp->flag |= (IORW|IOREAD);
    io_ftable[fd] = fp;
}

/*
 * returns the next character from file <fd>
 */

static int io_getc(fd)
int fd;
{
    register struct fileblk *fp = io_ftable[fd];
    register int c;
    if(!fp)
        return(EOF);
    if(c= *fp->ptr++)
        return(c&STRIP);
    if(fp->ptr <= fp->last)
        return(0);
    return(io_readbuff(fp));
}

/*
 * This special version does not handle ptrname==1
 * It also saves a lot of real seeks on history file
 */

static off_t hoffset;

static off_t io_seek(fd, offset, ptrname)
int fd;
off_t   offset;
register int    ptrname;
{
    register struct fileblk *fp;
    register int c;
    off_t   p;

    if(!(fp=io_ftable[fd]))
        return(lseek(fd,offset,ptrname));
    fp->flag &= ~IOEOF;
    if(!(fp->flag&IOREAD))
    {
        p_flush();
    }
    c = 0;
    /* check history file to see if already in the buffer */
    if(fd==FCIO && ptrname==0 && (fp->flag&IOREAD) && offset<hoffset)
    {
        p = hoffset - (fp->last - fp->base);
        if(offset >= p)
        {
            fp->ptr = fp->base + (int)(offset-p);
            return(offset);
        }
        else
        {
            c = offset&(IOBSIZE-1);
            offset -= c;
        }
    }
    if(fp->flag&IORW)
    {
        fp->flag &= ~(IOWRT|IOREAD);
        fp->last = fp->ptr = fp->base;
        *fp->last = 0;
    }
    p = lseek(fd, offset, ptrname);
    if(fd==FCIO)
    {
        if(ptrname==0)
            hoffset = p;
        else
            hoffset = -1;
        if(c)
        {
            io_readbuff(fp);
            fp->ptr += (c-1);
        }
    }
    return(p);
}

/*
 * Read from file into fp
 */

static int io_readbuff(fp)
register struct fileblk *fp;
{
    register int n;

    if (fp->flag & IORW)
        fp->flag |= IOREAD;
    if (!(fp->flag&IOREAD))
        return(EOF);

    fp->ptr = fp->last;
#ifdef SYSCALL
    n = syscall(3, filenum(fp),fp->base, IOBSIZE);
#else
    n = rEAd(filenum(fp),fp->base, IOBSIZE);
#endif /* SYSCALL */
    fp->ptr = fp->base;
    if(n > 0)
        fp->last = fp->base + n;
    else
        fp->last = fp->ptr;
    *fp->last = 0;
    if (n <= 0)
    {
        if (n == 0)
        {
            fp->flag |= IOEOF;
            if (fp->flag & IORW)
                fp->flag &= ~IOREAD;
        }
        else
            fp->flag |= IOERR;
        return(-1);
    }
    if(fp->fdes==FCIO)
        hoffset += n;
    return(*fp->ptr++&STRIP);
}


/*
 * close file stream and reopen for reading and writing
 */

static void io_fclose(fd)
register int fd;
{
    register struct fileblk *fp = io_ftable[fd];
    /* reposition seek pointer if necessary */
    if(fp && !(fp->flag&IOREAD))
        p_flush();
    close(fd);
    if(fp && (fp->flag&IOFREE))
        free(fp);
    io_ftable[fd] = 0;
}

/*
 * move the file number fa to unit fb
 */

static int io_renumber(fa, fb)
register int    fa;
register int    fb;
{
    if(fa >= 0)
    {
        close(fb);
        fcntl(fa,0,fb); /* normal dup */
        if(io_ftable[fb] = io_ftable[fa])
            io_ftable[fb]->fdes = fb;
        io_ftable[fa] = 0;
        close(fa);
        /* set fb close-on-exec */
#ifdef F_SETFD
        fcntl(fb,F_SETFD,1);
#else
#   ifdef FIOCLEX
        ioctl(fb, FIOCLEX, NULL);
#   endif /* FIOCLEX */
#endif  /* F_SETFD */
    }
    return(fb);
}

/*
 * return file descriptor for an open file
 */

static int io_mktmp(fname, len)
register char *fname;
int len;
{
    int fd;
    if(!pathtemp(fname,len,NiL,"hist",&fd))
    {
        sh_fail("tmp-file",e_create);
        fd = -1;
    }
    return(fd);
}

#endif /* KSHELL */