time: Use clock_gettime

[dragonfly.git] / contrib / tcsh-6 / sh.hist.c

/* $Header: /p/tcsh/cvsroot/tcsh/sh.hist.c,v 3.60 2015/02/22 21:59:00 christos Exp $ */
/*
 * sh.hist.c: Shell history expansions and substitutions
 */
/*-
 * Copyright (c) 1980, 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "sh.h"

RCSID("$tcsh: sh.hist.c,v 3.60 2015/02/22 21:59:00 christos Exp $")

#include <stdio.h>      /* for rename(2), grr. */
#include <assert.h>
#include "tc.h"
#include "dotlock.h"

extern int histvalid;
extern struct Strbuf histline;
Char HistLit = 0;

static  int     heq     (const struct wordent *, const struct wordent *);
static  void    hfree   (struct Hist *);

#define HIST_ONLY       0x01
#define HIST_SAVE       0x02
#define HIST_LOAD       0x04
#define HIST_REV        0x08
#define HIST_CLEAR      0x10
#define HIST_MERGE      0x20
#define HIST_TIME       0x40

/*
 * C shell
 */

/* Static functions don't show up in gprof summaries.  So eliminate "static"
 * modifier from some frequently called functions. */
#ifdef PROF
#define PG_STATIC
#else
#define PG_STATIC static
#endif

/* #define DEBUG_HIST 1 */

static const int fastMergeErase = 1;
static unsigned histCount = 0;          /* number elements on history list */
static int histlen = 0;
static struct Hist *histTail = NULL;     /* last element on history list */
static struct Hist *histMerg = NULL;     /* last element merged by Htime */

static void insertHistHashTable(struct Hist *, unsigned);

/* Insert new element (hp) in history list after specified predecessor (pp). */
static void
hinsert(struct Hist *hp, struct Hist *pp)
{
    struct Hist *fp = pp->Hnext;        /* following element, if any */
    hp->Hnext = fp, hp->Hprev = pp;
    pp->Hnext = hp;
    if (fp)
        fp->Hprev = hp;
    else
        histTail = hp;                  /* meaning hp->Hnext == NULL */
    histCount++;
}

/* Remove the entry from the history list. */
static void
hremove(struct Hist *hp)
{
    struct Hist *pp = hp->Hprev;
    assert(pp);                         /* elements always have a previous */
    pp->Hnext = hp->Hnext;
    if (hp->Hnext)
        hp->Hnext->Hprev = pp;
    else
        histTail = pp;                  /* we must have been last */
    if (hp == histMerg)                 /* deleting this hint from list */
        histMerg = NULL;
    assert(histCount > 0);
    histCount--;
}

/* Prune length of history list to specified size by history variable. */
PG_STATIC void
discardExcess(int hlen)
{
    struct Hist *hp, *np;
    if (histTail == NULL) {
        assert(histCount == 0);
        return;                         /* no entries on history list */
    }
    /* Prune dummy entries from the front, then old entries from the back. If
     * the list is still too long scan the whole list as before.  But only do a
     * full scan if the list is more than 6% (1/16th) too long. */
    while (histCount > (unsigned)hlen && (np = Histlist.Hnext)) {
        if (eventno - np->Href >= hlen || hlen == 0)
            hremove(np), hfree(np);
        else
            break;
    }
    while (histCount > (unsigned)hlen && (np = histTail) != &Histlist) {
        if (eventno - np->Href >= hlen || hlen == 0)
            hremove(np), hfree(np);
        else
            break;
    }
    if (histCount - (hlen >> 4) <= (unsigned)hlen)
        return;                         /* don't bother doing the full scan */
    for (hp = &Histlist; histCount > (unsigned)hlen &&
        (np = hp->Hnext) != NULL;)
        if (eventno - np->Href >= hlen || hlen == 0)
            hremove(np), hfree(np);
        else
            hp = np;
}

/* Add the command "sp" to the history list. */
void
savehist(
  struct wordent *sp,
  int mflg)                             /* true if -m (merge) specified */
{
    /* throw away null lines */
    if (sp && sp->next->word[0] == '\n')
        return;
    if (sp)
        (void) enthist(++eventno, sp, 1, mflg, histlen);
    discardExcess(histlen);
}

#define USE_JENKINS_HASH 1
/* #define USE_ONE_AT_A_TIME 1 */
#undef PRIME_LENGTH                     /* no need for good HTL */

#ifdef USE_JENKINS_HASH
#define hashFcnName "lookup3"
/* From:
   lookup3.c, by Bob Jenkins, May 2006, Public Domain.
   "...  You can use this free for any purpose.  It's in
    the public domain.  It has no warranty."
   http://burtleburtle.net/bob/hash/index.html
 */

#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
#define mix(a,b,c) \
{ \
  a -= c;  a ^= rot(c, 4);  c += b; \
  b -= a;  b ^= rot(a, 6);  a += c; \
  c -= b;  c ^= rot(b, 8);  b += a; \
  a -= c;  a ^= rot(c,16);  c += b; \
  b -= a;  b ^= rot(a,19);  a += c; \
  c -= b;  c ^= rot(b, 4);  b += a; \
}
#define final(a,b,c) \
{ \
  c ^= b; c -= rot(b,14); \
  a ^= c; a -= rot(c,11); \
  b ^= a; b -= rot(a,25); \
  c ^= b; c -= rot(b,16); \
  a ^= c; a -= rot(c, 4); \
  b ^= a; b -= rot(a,14); \
  c ^= b; c -= rot(b,24); \
}

struct hashValue                  /* State used to hash a wordend word list. */
{
    uint32_t a, b, c;
};

/* Set up the internal state */
static void
initializeHash(struct hashValue *h)
{
    h->a = h->b = h->c = 0xdeadbeef;
}

/* This does a partial hash of the Chars in a single word.  For efficiency we
 * include 3 versions of the code to pack Chars into 32-bit words for the
 * mixing function. */
static void
addWordToHash(struct hashValue *h, const Char *word)
{
    uint32_t a = h->a, b = h->b, c = h->c;
#ifdef SHORT_STRINGS
#ifdef WIDE_STRINGS
    assert(sizeof(Char) >= 4);
    while (1) {
        unsigned k;
        if ((k = (uChar)*word++) == 0) break; a += k;
        if ((k = (uChar)*word++) == 0) break; b += k;
        if ((k = (uChar)*word++) == 0) break; c += k;
        mix(a, b, c);
    }
#else
    assert(sizeof(Char) == 2);
    while (1) {
        unsigned k;
        if ((k = (uChar)*word++) == 0) break; a += k;
        if ((k = (uChar)*word++) == 0) break; a += k << 16;
        if ((k = (uChar)*word++) == 0) break; b += k;
        if ((k = (uChar)*word++) == 0) break; b += k << 16;
        if ((k = (uChar)*word++) == 0) break; c += k;
        if ((k = (uChar)*word++) == 0) break; c += k << 16;
        mix(a, b, c);
    }
#endif
#else
    assert(sizeof(Char) == 1);
    while (1) {
        unsigned k;
        if ((k = *word++) == 0) break; a += k;
        if ((k = *word++) == 0) break; a += k << 8;
        if ((k = *word++) == 0) break; a += k << 16;
        if ((k = *word++) == 0) break; a += k << 24;
        if ((k = *word++) == 0) break; b += k;
        if ((k = *word++) == 0) break; b += k << 8;
        if ((k = *word++) == 0) break; b += k << 16;
        if ((k = *word++) == 0) break; b += k << 24;
        if ((k = *word++) == 0) break; c += k;
        if ((k = *word++) == 0) break; c += k << 8;
        if ((k = *word++) == 0) break; c += k << 16;
        if ((k = *word++) == 0) break; c += k << 24;
        mix(a, b, c);
    }
#endif
    h->a = a, h->b = b, h->c = c;
}

static void
addCharToHash(struct hashValue *h, Char ch)
{
    /* The compiler (gcc -O2) seems to do a good job optimizing this without
     * explicitly extracting into local variables. */
    h->a += (uChar)ch;
    mix(h->a, h->b, h->c);
}

static uint32_t
finalizeHash(struct hashValue *h)
{
    uint32_t a = h->a, b = h->b, c = h->c;
    final(a, b, c);
    return c;
}

#elif USE_ONE_AT_A_TIME
#define hashFcnName "one-at-a-time"
/* This one is also from Bob Jenkins, but is slower but simpler than lookup3.
   "...  The code given here are all public domain."
   http://burtleburtle.net/bob/hash/doobs.html */

#if 0
ub4
one_at_a_time(char *key, ub4 len)
{
  ub4   hash, i;
  for (hash=0, i=0; i<len; ++i)
  {
    hash += key[i];
    hash += (hash << 10);
    hash ^= (hash >> 6);
  }
  hash += (hash << 3);
  hash ^= (hash >> 11);
  hash += (hash << 15);
  return (hash & mask);
}
#endif

struct hashValue { uint32_t h; };
static void
initializeHash(struct hashValue *h)
{
    h->h = 0;
}

static void
addWordToHash(struct hashValue *h, const Char *word)
{
    unsigned k;
    uint32_t hash = h->h;
    while (k = (uChar)*word++)
        hash += k, hash += hash << 10, hash ^= hash >> 6;
    h->h = hash;
}

static void
addCharToHash(struct hashValue *h, Char c)
{
    Char b[2] = { c, 0 };
    addWordToHash(h, b);
}

static uint32_t
finalizeHash(struct hashValue *h)
{
    unsigned hash = h->h;
    hash += (hash << 3);
    hash ^= (hash >> 11);
    hash += (hash << 15);
    return hash;
}

#else
#define hashFcnName "add-mul"
/* Simple multipy and add hash. */
#define PRIME_LENGTH 1                  /* need "good" HTL */
struct hashValue { uint32_t h; };
static void
initializeHash(struct hashValue *h)
{
    h->h = 0xe13e2345;
}

static void
addWordToHash(struct hashValue *h, const Char *word)
{
    unsigned k;
    uint32_t hash = h->h;
    while (k = (uChar)*word++)
        hash = hash * 0x9e4167b9 + k;
    h->h = hash;
}

static void
addCharToHash(struct hashValue *h, Char c)
{
    h->h = h->h * 0x9e4167b9 + (uChar)c;
}

static uint32_t
finalizeHash(struct hashValue *h)
{
    return h->h;
}
#endif

static unsigned
hashhist(struct wordent *h0)
{
    struct hashValue s;
    struct wordent *firstWord = h0->next;
    struct wordent *h = firstWord;
    unsigned hash = 0;

    initializeHash(&s);
    for (; h != h0; h = h->next) {
        if (h->word[0] == '\n')
            break;                      /* don't hash newline */
        if (h != firstWord)
            addCharToHash(&s, ' ');     /* space between words */
        addWordToHash(&s, h->word);
    }
    hash = finalizeHash(&s);
    /* Zero means no hash value, so never return zero as a hash value. */
    return hash ? hash : 0x7fffffff;    /* prime! */
}

#if 0
unsigned
hashStr(Char *str)
{
    struct hashValue s;
    initializeHash(&s);
    addWordToHash(&s, str);
    return finalizeHash(&s);
}
#endif

#ifdef PRIME_LENGTH                     /* need good HTL */
#define hash2tableIndex(hash, len) ((hash) % len)
#else
#define hash2tableIndex(hash, len) ((hash) & (len-1))
#endif

/* This code can be enabled to test the above hash functions for speed and
 * collision avoidance.  The testing is enabled by "occasional" calls to
 * displayHistStats(), see which. */
#ifdef DEBUG_HIST

#ifdef BSDTIMES
static double
doTiming(int start) {
    static struct timeval beginTime;
    if (start) {
        gettimeofday(&beginTime, NULL);
        return 0.0;
    } else {
        struct timeval now;
        gettimeofday(&now, NULL);
        return (now.tv_sec-beginTime.tv_sec) +
            (now.tv_usec-beginTime.tv_usec)/1e6;
    }
}
#else
static double
doTiming(int start) {
    USE(start);
    return 0.0;
}
#endif

static void
generateHashes(int nChars, unsigned nWords, unsigned samples, unsigned *hashes,
    unsigned length)
{
    if (nChars < 1)
        return;
    nWords = (nWords < 1) ? 1 : (nWords > 4) ? 4 : nWords;
    Char *number = xmalloc((nChars+nWords)*sizeof(Char));
    struct wordent word[4];
    struct wordent base = { NULL, &word[0], &word[0] };
    word[0].word = number, word[0].next = &base, word[0].prev = &base;
    unsigned w = 0;                     /* word number */
    /* Generate multiple words of length 2, 3, 5, then all the rest. */
    unsigned wBoundaries[4] = { 2-1, 2+3-1, 2+3+5-1, 0 };
    /* Ensure the last word has at least 4 Chars in it. */
    while (nWords >= 2 && nChars < (wBoundaries[nWords-2]+1) + 4)
        nWords--;
    wBoundaries[nWords-1] = 0xffffffff; /* don't end word past this point */
    unsigned i;
    for (i = 0; i<nChars; i++) {
        /* In deference to the gawd awful add-mul hash, we won't use the worse
         * case here (setting all Chars to 1), but assume mostly (or at least
         * initially) ASCII data. */
        number[i+w] = '!';              /* 0x21 = 33 */

        if (i == wBoundaries[w]) {      /* end a word here and move to next */
            w++;                        /* next word */
            number[i+w] = 0;            /* terminate */
            word[w].word = &number[i+w+1];
            word[w].next = &base, word[w].prev = &word[w-1];
            word[w-1].next = &word[w], base.prev = &word[w];
        }
    }
    /* w is the index of the last word actually created. */
    number[nChars + w] = 0;             /* terminate last word */
    unsigned timeLimit = !samples;
    if (samples == 0)
        samples = 1000000000;
    doTiming(1);
    double sec;
    for (i = 0; i < samples; i++) {
        /* increment 4 digit base 255 number; last characters vary fastest */
        unsigned j = nChars-1 + w;
        while (1) {
            if (++number[j] != 0)
                break;
            /* else reset this digit and proceed to next one */
            number[j] = 1;
            if (&number[j] <= word[w].word)
                break;                  /* stop at beginning of last word */
            j--;
        }
        if (word[w].word[0] == '\n')
            word[w].word[0]++;          /* suppress newline character */
        unsigned hash = hashhist(&base);
        hashes[hash2tableIndex(hash, length)]++;
        if (timeLimit && (i & 0x3ffff) == 0x3ffff) {
            sec = doTiming(0);
            if (sec > 10)
                break;
        }
    }
    if (i >= samples)
        sec = doTiming(0);
    else
        samples = i;                    /* number we actually did */
    if (sec > 0.01) {
        xprintf("Hash %d (%d Char %u words) with %s: %d nsec/hash, %d mcps\n",
                samples, nChars, w+1, hashFcnName, (int)((sec/samples)*1e9),
                (int)((double)samples*nChars/sec/1e6));
    }
}
#endif /* DEBUG_HIST */

#ifdef DEBUG_HIST
static void
testHash(void)
{
    static const Char STRtestHashTimings[] =
        { 't','e','s','t','H','a','s','h','T','i','m','i','n','g','s', 0 };
    struct varent *vp = adrof(STRtestHashTimings);
    if (vp && vp->vec) {
        unsigned hashes[4];             /* dummy place to put hashes */
        Char **vals = vp->vec;
        while (*vals) {
            int length = getn(*vals);
            unsigned words =
                (length < 5) ? 1 : (length < 25) ? 2 : (length < 75) ? 3 : 4;
            if (length > 0)
                generateHashes(length, words, 0, hashes, 4);
            vals++;
        }
    }
    unsigned length = 1024;
#ifdef PRIME_LENGTH                     /* need good HTL */
    length = 1021;
#endif
    unsigned *hashes = xmalloc(length*sizeof(unsigned));
    memset(hashes, 0, length*sizeof(unsigned));
    /* Compute collision statistics for half full hashes modulo "length". */
    generateHashes(4, 1, length/2, hashes, length);
    /* Evaluate collisions by comparing occupancy rates (mean value 0.5).
     * One bin for each number of hits. */
    unsigned bins[155];
    memset(bins, 0, sizeof(bins));
    unsigned highest = 0;
    unsigned i;
    for (i = 0; i<length; i++) {
        unsigned hits = hashes[i];
        if (hits >= sizeof(bins)/sizeof(bins[0])) /* clip */
            hits = highest = sizeof(bins)/sizeof(bins[0]) - 1;
        if (hits > highest)
            highest = hits;
        bins[hits]++;
    }
    xprintf("Occupancy of %d buckets by %d hashes %d Chars %d word with %s\n",
            length, length/2, 4, 1, hashFcnName);
    for (i = 0; i <= highest; i++) {
        xprintf(" %d buckets (%d%%) with %d hits\n",
                bins[i], bins[i]*100/length, i);
    }
    /* Count run lengths to evaluate linear rehashing effectiveness.  Estimate
     * a little corrupted by edge effects. */
    memset(bins, 0, sizeof(bins));
    highest = 0;
    for (i = 0; hashes[i] == 0; i++);   /* find first occupied bucket */
    unsigned run = 0;
    unsigned rehashed = 0;
    for (; i<length; i++) {
        unsigned hits = hashes[i];
        if (hits == 0 && rehashed > 0)
            hits = 1 && rehashed--;
        else if (hits > 1)
            rehashed += hits-1;
        if (hits)
            run++;
        else {
            /* a real free slot, count it */
            if (run >= sizeof(bins)/sizeof(bins[0])) /* clip */
                run = highest = sizeof(bins)/sizeof(bins[0]) - 1;
            if (run > highest)
                highest = run;
            bins[run]++;
            run = 0;
        }
    }
    /* Ignore the partial run at end as we ignored the beginning. */
    double merit = 0.0, entries = 0;
    for (i = 0; i <= highest; i++) {
        entries += bins[i]*i;           /* total hashed objects */
        merit += bins[i]*i*i;
    }
    xprintf("Rehash collision figure of merit %u (ideal=100), run lengths:\n",
            (int)(100.0*merit/entries));
    for (i = 0; i <= highest; i++) {
        if (bins[i] != 0)
            xprintf(" %d runs of length %d buckets\n", bins[i], i);
    }
    xfree(hashes);
}
#endif /* DEBUG_HIST */

/* Compares two word lists for equality. */
static int
heq(const struct wordent *a0, const struct wordent *b0)
{
    const struct wordent *a = a0->next, *b = b0->next;

    for (;;) {
        if (Strcmp(a->word, b->word) != 0)
            return 0;
        a = a->next;
        b = b->next;
        if (a == a0)
            return (b == b0) ? 1 : 0;
        if (b == b0)
            return 0;
    }
}

/* Renumber entries following p, which we will be deleting. */
PG_STATIC void
renumberHist(struct Hist *p)
{
    int n = p->Href;
    while ((p = p->Hnext))
        p->Href = n--;
}

/* The hash table is implemented as an array of pointers to Hist entries.  Each
 * entry is located in the table using hash2tableIndex() and checking the
 * following entries in case of a collision (linear rehash).  Free entries in
 * the table are zero (0, NULL, emptyHTE).  Deleted entries that cannot yet be
 * freed are set to one (deletedHTE).  The Hist.Hhash member is non-zero iff
 * the entry is in the hash table.  When the hash table get too full, it is
 * reallocated to be approximately twice the history length (see
 * getHashTableSize). */
static struct Hist **histHashTable = NULL;
static unsigned histHashTableLength = 0; /* number of Hist pointers in table */

static struct Hist * const emptyHTE = NULL;
static struct Hist * const deletedHTE = (struct Hist *)1;

static struct {
    unsigned insertCount;
    unsigned removeCount;
    unsigned rehashes;
    int deleted;
} hashStats;

#ifdef DEBUG_HIST
void
checkHistHashTable(int print)
{
    unsigned occupied = 0;
    unsigned deleted = 0;
    unsigned i;
    for (i = 0; i<histHashTableLength; i++)
        if (histHashTable[i] == emptyHTE)
            continue;
        else if (histHashTable[i] == deletedHTE)
            deleted++;
        else
            occupied++;
    if (print)
        xprintf("  found len %u occupied %u deleted %u\n",
                histHashTableLength, occupied, deleted);
    assert(deleted == hashStats.deleted);
}

static int doneTest = 0;

/* Main entry point for displaying history statistics and hash function
 * behavior. */
void
displayHistStats(const char *reason)
{
    /* Just hash statistics for now. */
    xprintf("%s history hash table len %u count %u (deleted %d)\n", reason,
            histHashTableLength, histCount, hashStats.deleted);
    xprintf("  inserts %u rehashes %u%% each\n",
            hashStats.insertCount,
            (hashStats.insertCount
             ? 100*hashStats.rehashes/hashStats.insertCount : 0));
    xprintf("  removes %u net %u\n",
            hashStats.removeCount,
            hashStats.insertCount - hashStats.removeCount);
    assert(hashStats.insertCount >= hashStats.removeCount);
    checkHistHashTable(1);
    memset(&hashStats, 0, sizeof(hashStats));
    if (!doneTest) {
        testHash();
        doneTest = 1;
    }
}
#else
void
displayHistStats(const char *reason)
{
    USE(reason);
}
#endif

static void
discardHistHashTable(void)
{
    if (histHashTable == NULL)
        return;
    displayHistStats("Discarding");
    xfree(histHashTable);
    histHashTable = NULL;
}

/* Computes a new hash table size, when the current one is too small. */
static unsigned
getHashTableSize(int hlen)
{
    unsigned target = hlen * 2;
    unsigned e = 5;
    unsigned size;
    while ((size = 1<<e) < target)
        e++;
#ifdef PRIME_LENGTH                     /* need good HTL */
    /* Not all prime, but most are and none have factors smaller than 11. */
    return size+15;
#else
    assert((size & (size-1)) == 0);     /* must be a power of two */
    return size;
#endif
}

/* Create the hash table or resize, if necessary. */
static void
createHistHashTable(int hlen)
{
    if (hlen == 0) {
        discardHistHashTable();
        return;
    }
    if (hlen < 0) {
        if (histlen <= 0)
            return;                     /* no need for hash table */
        hlen = histlen;
    }
    if (histHashTable != NULL) {
        if (histCount < histHashTableLength * 3 / 4)
            return;                     /* good enough for now */
        discardHistHashTable();         /* too small */
    }
    histHashTableLength = getHashTableSize(
        hlen > (int)histCount ? hlen : (int)histCount);
    histHashTable = xmalloc(histHashTableLength * sizeof(struct Hist *));
    memset(histHashTable, 0, histHashTableLength * sizeof(struct Hist *));
    assert(histHashTable[0] == emptyHTE);

    /* Now insert all the entries on the history list into the hash table. */
    {
        struct Hist *hp;
        for (hp = &Histlist; (hp = hp->Hnext) != NULL;) {
            unsigned lpHash = hashhist(&hp->Hlex);
            assert(!hp->Hhash || hp->Hhash == lpHash);
            hp->Hhash = 0;              /* force insert to new hash table */
            insertHistHashTable(hp, lpHash);
        }
    }
}

/* Insert np into the hash table.  We assume that np is already on the
 * Histlist.  The specified hashval matches the new Hist entry but has not yet
 * been assigned to Hhash (or the element is already on the hash table). */
static void
insertHistHashTable(struct Hist *np, unsigned hashval)
{
    unsigned rehashes = 0;
    unsigned hi = 0;
    if (!histHashTable)
        return;
    if (np->Hhash != 0) {
        /* already in hash table */
        assert(hashval == np->Hhash);
        return;
    }
    assert(np != deletedHTE);
    /* Find a free (empty or deleted) slot, using linear rehash. */
    assert(histHashTable);
    for (rehashes = 0;
         ((hi = hash2tableIndex(hashval + rehashes, histHashTableLength)),
          histHashTable[hi] != emptyHTE && histHashTable[hi] != deletedHTE);
         rehashes++) {
        assert(np != histHashTable[hi]);
        if (rehashes >= histHashTableLength / 10) {
            /* Hash table is full, so grow it.  We assume the create function
             * will roughly double the size we give it.  Create initializes the
             * new table with everything on the Histlist, so we are done when
             * it returns.  */
#ifdef DEBUG_HIST
            xprintf("Growing history hash table from %d ...",
                histHashTableLength);
            flush();
#endif
            discardHistHashTable();
            createHistHashTable(histHashTableLength);
#ifdef DEBUG_HIST
            xprintf("to %d.\n", histHashTableLength);
#endif
            return;
        }
    }
    /* Might be sensible to grow hash table if rehashes is "too big" here. */
    if (histHashTable[hi] == deletedHTE)
        hashStats.deleted--;
    histHashTable[hi] = np;
    np->Hhash = hashval;
    hashStats.insertCount++;
    hashStats.rehashes += rehashes;
}

/* Remove the 'np' entry from the hash table. */
static void
removeHistHashTable(struct Hist *np)
{
    unsigned hi = np->Hhash;
    if (!histHashTable || !hi)
        return;                         /* no hash table or not on it */
    /* find desired entry */
    while ((hi = hash2tableIndex(hi, histHashTableLength)),
           histHashTable[hi] != emptyHTE) {
        if (np == histHashTable[hi]) {
            unsigned i;
            unsigned deletes = 0;
            histHashTable[hi] = deletedHTE; /* dummy, but non-zero entry */
            /* now peek ahead to see if the dummies are really necessary. */
            i = 1;
            while (histHashTable[hash2tableIndex(hi+i, histHashTableLength)] ==
                   deletedHTE)
                i++;
            if (histHashTable[hash2tableIndex(hi+i, histHashTableLength)] ==
                emptyHTE) {
                /* dummies are no longer necessary placeholders. */
                deletes = i;
                while (i-- > 0) {
                    histHashTable[hash2tableIndex(hi+i, histHashTableLength)] =
                        emptyHTE;
                }
            }
            hashStats.deleted += 1 - deletes; /* delta deleted entries */
            hashStats.removeCount++;
            return;
        }
        hi++;                           /* linear rehash */
    }
    assert(!"Hist entry not found in hash table");
}

/* Search the history hash table for a command matching lp, using hashval as
 * its hash value. */
static struct Hist *
findHistHashTable(struct wordent *lp, unsigned hashval)
{
    unsigned deleted = 0;               /* number of deleted entries skipped */
    unsigned hi = hashval;
    struct Hist *hp;
    if (!histHashTable)
        return NULL;
    while ((hi = hash2tableIndex(hi, histHashTableLength)),
           (hp = histHashTable[hi]) != emptyHTE) {
        if (hp == deletedHTE)
            deleted++;
        else if (hp->Hhash == hashval && heq(lp, &(hp->Hlex)))
            return hp;
        if (deleted > (histHashTableLength>>4)) {
            /* lots of deletes, so we need a sparser table. */
            discardHistHashTable();
            createHistHashTable(histHashTableLength);
            return findHistHashTable(lp, hashval);
        }
        hi++;                           /* linear rehash */
    }
    return NULL;
}

/* When merge semantics are in use, find the approximate predecessor for the
 * new entry, so that the Htime entries are decreasing.  Return the entry just
 * before the first entry with equal times, so the caller can check for
 * duplicates.  When pTime is not NULL, use it as a starting point for search,
 * otherwise search from beginning (largest time value) of history list. */
PG_STATIC struct Hist *
mergeInsertionPoint(
    struct Hist *np,                      /* new entry to be inserted */
    struct Hist *pTime)                   /* hint about where to insert */
{
    struct Hist *pp, *p;
    if (histTail && histTail->Htime >= np->Htime)
        pTime = histTail;               /* new entry goes at the end */
    if (histMerg && histMerg != &Histlist && histMerg != Histlist.Hnext) {
        /* Check above and below previous insertion point, in case we're adding
         * sequential times in the middle of the list (e.g. history -M). */
        if (histMerg->Htime >= np->Htime)
            pTime = histMerg;
        else if (histMerg->Hprev->Htime >= np->Htime)
            pTime = histMerg->Hprev;
    }
    if (pTime) {
        /* With hint, search up the list until Htime is greater.  We skip past
         * the equal ones, too, so our caller can elide duplicates. */
        pp = pTime;
        while (pp != &Histlist && pp->Htime <= np->Htime)
            pp = pp->Hprev;
    } else
        pp = &Histlist;
    /* Search down the list while current entry's time is too large. */
    while ((p = pp->Hnext) && (p->Htime > np->Htime))
            pp = p;                     /* advance insertion point */
    /* Remember recent position as hint for next time */
    histMerg = pp;
    return pp;
}

/* Bubble Hnum & Href in new entry down to pp through earlier part of list. */
PG_STATIC void bubbleHnumHrefDown(struct Hist *np, struct Hist *pp)
{
    struct Hist *p;
    for (p = Histlist.Hnext; p != pp->Hnext; p = p->Hnext) {
        /* swap Hnum & Href values of p and np. */
        int n = p->Hnum, r = p->Href;
        p->Hnum = np->Hnum; p->Href = np->Href;
        np->Hnum = n; np->Href = r;
    }
}

/* Enter new command into the history list according to current settings. */
struct Hist *
enthist(
  int event,                            /* newly incremented global eventno */
  struct wordent *lp,
  int docopy,
  int mflg,                             /* true if merge requested */
  int hlen)                             /* -1 if unknown */
{
    struct Hist *p = NULL, *pp = &Histlist, *pTime = NULL;
    struct Hist *np;
    const Char *dp;
    unsigned lpHash = 0;                /* non-zero if hashing entries */

    if ((dp = varval(STRhistdup)) != STRNULL) {
        if (eq(dp, STRerase)) {
            /* masaoki@akebono.tky.hp.com (Kobayashi Masaoki) */
            createHistHashTable(hlen);
            lpHash = hashhist(lp);
            assert(lpHash != 0);
            p = findHistHashTable(lp, lpHash);
            if (p) {
                if (Htime != 0 && p->Htime > Htime)
                    Htime = p->Htime;
                /* If we are merging, and the old entry is at the place we want
                 * to insert the new entry, then remember the place. */
                if (mflg && Htime != 0 && p->Hprev->Htime >= Htime)
                    pTime = p->Hprev;
                if (!fastMergeErase)
                    renumberHist(p);    /* Reset Href of subsequent entries */
                hremove(p);
                hfree(p);
                p = NULL;               /* so new entry is allocated below */
            }
        }
        else if (eq(dp, STRall)) {
            createHistHashTable(hlen);
            lpHash = hashhist(lp);
            assert(lpHash != 0);
            p = findHistHashTable(lp, lpHash);
            if (p)   /* p!=NULL, only update this entry's Htime below */
                eventno--;              /* not adding a new event */
        }
        else if (eq(dp, STRprev)) {
            if (pp->Hnext && heq(lp, &(pp->Hnext->Hlex))) {
                p = pp->Hnext;
                eventno--;
            }
        }
    }

    np = p ? p : xmalloc(sizeof(*np));

    /* Pick up timestamp set by lex() in Htime if reading saved history */
    if (Htime != 0) {
        np->Htime = Htime;
        Htime = 0;
    }
    else
        (void) time(&(np->Htime));

    if (p == np)
        return np;                      /* reused existing entry */

    /* Initialize the new entry. */
    np->Hnum = np->Href = event;
    if (docopy) {
        copylex(&np->Hlex, lp);
        if (histvalid)
            np->histline = Strsave(histline.s);
        else
            np->histline = NULL;
    }
    else {
        np->Hlex.next = lp->next;
        lp->next->prev = &np->Hlex;
        np->Hlex.prev = lp->prev;
        lp->prev->next = &np->Hlex;
        np->histline = NULL;
    }
    np->Hhash = 0;

    /* The head of history list is the default insertion point.
       If merging, advance insertion point, in pp, according to Htime. */
    /* XXX -- In histdup=all, Htime values can be non-monotonic. */
    if (mflg) {                         /* merge according to np->Htime */
        pp = mergeInsertionPoint(np, pTime);
        for (p = pp->Hnext; p && p->Htime == np->Htime; pp = p, p = p->Hnext) {
            if (heq(&p->Hlex, &np->Hlex)) {
                eventno--;              /* duplicate, so don't add new event */
                hfree(np);
                return (p);
              }
          }
        /* pp is now the last entry with time >= to np. */
        if (!fastMergeErase) {          /* renumber at end of loadhist */
            /* Before inserting np after pp, bubble its Hnum & Href values down
             * through the earlier part of list. */
            bubbleHnumHrefDown(np, pp);
        }
    }
    else
        pp = &Histlist;                 /* insert at beginning of history */
    hinsert(np, pp);
    if (lpHash && hlen != 0)            /* erase & all modes use hash table */
        insertHistHashTable(np, lpHash);
    else
        discardHistHashTable();
    return (np);
}

static void
hfree(struct Hist *hp)
{
    assert(hp != histMerg);
    if (hp->Hhash)
        removeHistHashTable(hp);
    freelex(&hp->Hlex);
    if (hp->histline)
        xfree(hp->histline);
    xfree(hp);
}

PG_STATIC void
phist(struct Hist *hp, int hflg)
{
    if (hp->Href < 0)
        return;
    if (hflg & HIST_ONLY) {
        int old_output_raw;

       /*
        * Control characters have to be written as is (output_raw).
        * This way one can preserve special characters (like tab) in
        * the history file.
        * From: mveksler@vnet.ibm.com (Veksler Michael)
        */
        old_output_raw = output_raw;
        output_raw = 1;
        cleanup_push(&old_output_raw, output_raw_restore);
        if (hflg & HIST_TIME)
            /* 
             * Make file entry with history time in format:
             * "+NNNNNNNNNN" (10 digits, left padded with ascii '0') 
             */

            xprintf("#+%010lu\n", (unsigned long)hp->Htime);

        if (HistLit && hp->histline)
            xprintf("%S\n", hp->histline);
        else
            prlex(&hp->Hlex);
        cleanup_until(&old_output_raw);
    }
    else {
        Char   *cp = str2short("%h\t%T\t%R\n");
        Char *p;
        struct varent *vp = adrof(STRhistory);

        if (vp && vp->vec != NULL && vp->vec[0] && vp->vec[1])
            cp = vp->vec[1];

        p = tprintf(FMT_HISTORY, cp, NULL, hp->Htime, hp);
        cleanup_push(p, xfree);
        for (cp = p; *cp;)
            xputwchar(*cp++);
        cleanup_until(p);
    }
}

PG_STATIC void
dophist(int n, int hflg)
{
    struct Hist *hp;
    if (setintr) {
        int old_pintr_disabled;

        pintr_push_enable(&old_pintr_disabled);
        cleanup_until(&old_pintr_disabled);
    }
    if ((hflg & HIST_REV) == 0) {
        /* Since the history list is stored most recent first, non-reversing
         * print needs to print (backwards) up the list. */
        if ((unsigned)n >= histCount)
            hp = histTail;
        else {
            for (hp = Histlist.Hnext;
                 --n > 0 && hp->Hnext != NULL;
                 hp = hp->Hnext)
                ;
        }
        if (hp == NULL)
            return;                     /* nothing to print */
        for (; hp != &Histlist; hp = hp->Hprev)
            phist(hp, hflg);
    } else {
        for (hp = Histlist.Hnext; n-- > 0 && hp != NULL; hp = hp->Hnext)
            phist(hp, hflg);
    }
}

/*ARGSUSED*/
void
dohist(Char **vp, struct command *c)
{
    int     n, hflg = 0;

    USE(c);
    if (getn(varval(STRhistory)) == 0)
        return;
    while (*++vp && **vp == '-') {
        Char   *vp2 = *vp;

        while (*++vp2)
            switch (*vp2) {
            case 'c':
                hflg |= HIST_CLEAR;
                break;
            case 'h':
                hflg |= HIST_ONLY;
                break;
            case 'r':
                hflg |= HIST_REV;
                break;
            case 'S':
                hflg |= HIST_SAVE;
                break;
            case 'L':
                hflg |= HIST_LOAD;
                break;
            case 'M':
                hflg |= HIST_MERGE;
                break;
            case 'T':
                hflg |= HIST_TIME;
                break;
            default:
                stderror(ERR_HISTUS, "chrSLMT");
                break;
            }
    }
    if (hflg & HIST_CLEAR) {
        struct Hist *np, *hp;
        for (hp = &Histlist; (np = hp->Hnext) != NULL;)
            hremove(np), hfree(np);
    }

    if (hflg & (HIST_LOAD | HIST_MERGE))
        loadhist(*vp, (hflg & HIST_MERGE) ? 1 : 0);
    else if (hflg & HIST_SAVE)
        rechist(*vp, 1);
    else {
        if (*vp)
            n = getn(*vp);
        else {
            n = getn(varval(STRhistory));
        }
        dophist(n, hflg);
    }
}


char *
fmthist(int fmt, ptr_t ptr)
{
    struct Hist *hp = ptr;
    char *buf;

    switch (fmt) {
    case 'h':
        return xasprintf("%6d", hp->Hnum);
    case 'R':
        if (HistLit && hp->histline)
            return xasprintf("%S", hp->histline);
        else {
            Char *istr, *ip;
            char *p;

            istr = sprlex(&hp->Hlex);
            buf = xmalloc(Strlen(istr) * MB_LEN_MAX + 1);

            for (p = buf, ip = istr; *ip != '\0'; ip++)
                p += one_wctomb(p, CHAR & *ip);

            *p = '\0';
            xfree(istr);
            return buf;
        }
    default:
        buf = xmalloc(1);
        buf[0] = '\0';
        return buf;
    }
}

static void
dotlock_cleanup(void* lockpath)
{
        dot_unlock((char*)lockpath);
}

/* Save history before exiting the shell. */
void
rechist(Char *fname, int ref)
{
    Char    *snum, *rs;
    int     fp, ftmp, oldidfds;
    struct varent *shist;
    char path[MAXPATHLEN];
    struct stat st;
    static Char   *dumphist[] = {STRhistory, STRmhT, 0, 0};

    if (fname == NULL && !ref) 
        return;
    /*
     * If $savehist is just set, we use the value of $history
     * else we use the value in $savehist
     */
    if (((snum = varval(STRsavehist)) == STRNULL) &&
        ((snum = varval(STRhistory)) == STRNULL))
        snum = STRmaxint;


    if (fname == NULL) {
        if ((fname = varval(STRhistfile)) == STRNULL)
            fname = Strspl(varval(STRhome), &STRtildothist[1]);
        else
            fname = Strsave(fname);
    }
    else
        fname = globone(fname, G_ERROR);
    cleanup_push(fname, xfree);

    /*
     * The 'savehist merge' feature is intended for an environment
     * with numerous shells being in simultaneous use. Imagine
     * any kind of window system. All these shells 'share' the same 
     * ~/.history file for recording their command line history. 
     * We try to handle the case of multiple shells trying to merge
     * histories at the same time, by creating semi-unique filenames
     * and saving the history there first and then trying to rename
     * them in the proper history file.
     *
     * Users that like to nuke their environment require here an atomic
     * loadhist-creat-dohist(dumphist)-close sequence which is given
                 * by optional lock parameter to savehist.
     *
     * jw.
     */ 
    /*
     * We need the didfds stuff before loadhist otherwise
     * exec in a script will fail to print if merge is set.
     * From: mveksler@iil.intel.com (Veksler Michael)
     */
    oldidfds = didfds;
    didfds = 0;
    if ((shist = adrof(STRsavehist)) != NULL && shist->vec != NULL) {
        size_t i;
        int merge = 0, lock = 0;

        for (i = 1; shist->vec[i]; i++) {
            if (eq(shist->vec[i], STRmerge))
                merge++;
            if (eq(shist->vec[i], STRlock))
                lock++;
        }

        if (merge) {
            if (lock) {
#ifndef WINNT_NATIVE
                char *lockpath = strsave(short2str(fname));
                cleanup_push(lockpath, xfree);
                /* Poll in 100 miliseconds interval to obtain the lock. */
                if ((dot_lock(lockpath, 100) == 0))
                    cleanup_push(lockpath, dotlock_cleanup);
#endif
            }
            loadhist(fname, 1);
        }
    }
    rs = randsuf();
    xsnprintf(path, sizeof(path), "%S.%S", fname, rs);
    xfree(rs);

    fp = xcreat(path, 0600);
    if (fp == -1) {
        didfds = oldidfds;
        cleanup_until(fname);
        return;
    }
    /* Try to preserve ownership and permissions of the original history file */
#ifndef WINNT_NATIVE
    if (stat(short2str(fname), &st) != -1) {
        TCSH_IGNORE(fchown(fp, st.st_uid, st.st_gid));
        TCSH_IGNORE(fchmod(fp, st.st_mode));
    }
#else
    UNREFERENCED_PARAMETER(st);
#endif
    ftmp = SHOUT;
    SHOUT = fp;
    dumphist[2] = snum;
    dohist(dumphist, NULL);
    xclose(fp);
    SHOUT = ftmp;
    didfds = oldidfds;
    (void)rename(path, short2str(fname));
    cleanup_until(fname);
}


/* This is the entry point for loading history data from a file. */
void
loadhist(Char *fname, int mflg)
{
    static Char   *loadhist_cmd[] = {STRsource, NULL, NULL, NULL};
    loadhist_cmd[1] = mflg ? STRmm : STRmh;

    if (fname != NULL)
        loadhist_cmd[2] = fname;
    else if ((fname = varval(STRhistfile)) != STRNULL)
        loadhist_cmd[2] = fname;
    else
        loadhist_cmd[2] = STRtildothist;

    dosource(loadhist_cmd, NULL);

    /* During history merging (enthist sees mflg set), we disable management of
     * Hnum and Href (because fastMergeErase is true).  So now reset all the
     * values based on the final ordering of the history list. */
    if (mflg) {
        int n = eventno;
        struct Hist *hp = &Histlist;
        while ((hp = hp->Hnext))
            hp->Hnum = hp->Href = n--;
    }
}

void
sethistory(int n)
{
    histlen = n;
    discardExcess(histlen);
}