history.c File Reference

#include "spice.h"
#include "cpdefs.h"
#include "suffix.h"

Include dependency graph for history.c:

Go to the source code of this file.

Functions
static wordlist *	dohsubst ()
static wordlist *	dohmod ()
static wordlist *	hpattern ()
static wordlist *	hprefix ()
static wordlist *	getevent ()
static void	freehist ()
static char *	dohs ()
void	cp_histsubst (wordlist **list)
static wordlist *	dohsubst (char *string)
static wordlist *	dohmod (char **string, wordlist *wl)
static wordlist *	hpattern (char *buf)
static wordlist *	hprefix (char *buf)
void	cp_addhistent (int event, wordlist *wlist)
static wordlist *	getevent (int num)
void	cp_hprint (int eventhi, int eventlo, bool rev)
static void	freehist (int num)
static char *	dohs (char *patrn, char *str)
void	com_history (wordlist *wl)

Variables
struct histent *	cp_lastone = NULL
int	cp_maxhistlength = 1000
char	cp_hat = '^'
char	cp_bang = '!'
bool	cp_didhsubst
static int	histlength = 0

Function Documentation

void com_history

(

wordlist *

wl

)

Definition at line 536 of file history.c.

{
    bool rev = false;

    if (wl && eq(wl->wl_word, "-r")) {
        wl = wl->wl_next;
        rev = true;
    }
    if (wl == NULL)
        cp_hprint(cp_event - 1, cp_event - histlength, rev);
    else
        cp_hprint(cp_event - 1, cp_event - 1 - atoi(wl->wl_word), rev);
    return;
}

void cp_addhistent	(	int	event,
		wordlist *	wlist
	)

Definition at line 359 of file history.c.

{
    if (cp_lastone && !cp_lastone->hi_wlist)
        fprintf(cp_err, "Internal error: bad history list\n");
    if (cp_lastone == NULL) {
        cp_lastone = alloc(struct histent);
    }
    else {
        cp_lastone->hi_next = alloc(struct histent);
        cp_lastone->hi_next->hi_prev = cp_lastone;
        cp_lastone = cp_lastone->hi_next;
    }
    cp_lastone->hi_event = event;
    cp_lastone->hi_wlist = wl_copy(wlist);
    freehist(histlength - cp_maxhistlength);
    histlength++;
    return;
}

void cp_histsubst

(

wordlist **

list

)

Definition at line 51 of file history.c.

{
    wordlist *nwl, *w, *n, *wlist;
    char buf[BSIZE_SP], *s, *b;

    /* Replace ^old^new with !:s^old^new. */

    if (list == NULL)
        return;
    wlist = *list;
    cp_didhsubst = false;
    if (*wlist->wl_word == cp_hat) {
        (void) sprintf(buf, "%c%c:s%s", cp_bang, cp_bang, 
            wlist->wl_word);
        tfree(wlist->wl_word);
        wlist->wl_word = copy(buf);
    }
    for (w = wlist; w; w = w->wl_next) {
        b = w->wl_word;
        for (s = b; *s; s++)
            if (*s == cp_bang) {
                cp_didhsubst = true;
                n = dohsubst(s + 1);
                if (!n) {
                    wl_free(wlist);
                    *list = NULL;
                    return;
                }
                if (b < s) {
                    (void) sprintf(buf, "%.*s%s", s - b, b, 
                        n->wl_word);
                    tfree(n->wl_word);
                    n->wl_word = copy(buf);
                }
                nwl = wl_splice(w, n);
                if (wlist == w)
                    wlist = n;
                w = nwl;
                break;
            }
    }
    *list = wlist;
    return;
}

void cp_hprint	(	int	eventhi,
		int	eventlo,
		bool	rev
	)

Definition at line 409 of file history.c.

{
    struct histent *hi;

    if (rev) {
        for (hi = cp_lastone; hi; hi = hi->hi_prev) {
            if ((hi->hi_event <= eventhi) && 
                    (hi->hi_event >= eventlo) &&
                    hi->hi_wlist) {
                out_printf("%d\t", hi->hi_event);
                out_wlprint(hi->hi_wlist);
                out_send("\n");
            }
        }
    }
    else if (cp_lastone) {
        for (hi = cp_lastone; hi->hi_prev; hi = hi->hi_prev)
            ;
        for (; hi; hi = hi->hi_next) {
            if ((hi->hi_event <= eventhi) && 
                    (hi->hi_event >= eventlo) &&
                    hi->hi_wlist) {
                out_printf("%d\t", hi->hi_event);
                out_wlprint(hi->hi_wlist);
                out_send("\n");
            }
        }
    }
    return;
}

static wordlist* dohmod ( )

static

static wordlist* dohmod ( char **  string, wordlist *  wl  )

static

Definition at line 200 of file history.c.

{
    wordlist *w;
    char *s;
    char *r = NULL, *t;
    int numwords, eventlo, eventhi, i;
    bool globalsubst;

anothermod:
    numwords = wl_length(wl);
    globalsubst = false;
    eventlo = 0;
    eventhi = numwords - 1;

    /* Now we know what wordlist we want. Take care of modifiers now. */
    r = NULL;
    for (s = ":^$*-%"; *s; s++) {
        t = strchr(*string, *s);
        if (t && ((t < r) || (r == NULL)))
            r = t;
    }
    if (!r)     /* No more modifiers. */
        return (wl);

    *string = r;
    if (**string == ':')
        (*string)++;

    switch(**string) {
        case '$':   /* Last word. */
            eventhi = eventlo = numwords - 1;
            break;
        case '*':   /* Words 1 through $ */
            if (numwords == 1)
                return (NULL);
            eventlo = 1;
            eventhi = numwords - 1;
            break;
        case '-':   /* Words 0 through ... */
            eventlo = 0;
            if (*(*string + 1))
                eventhi = scannum(*string + 1);
            else
                eventhi = numwords - 1;
            if (eventhi > numwords - 1)
                eventhi = numwords - 1;
            break;
        case 'p':   /* Print the command and don't execute it. 
                 * This doesn't work quite like csh.
                 */
            wl_print(wl, cp_out);
            (void) putc('\n', cp_out);
            return (NULL);
        case 's':   /* Do a substitution. */
            for (w = wl; w; w = w->wl_next) {
                s = dohs(*string + 1, w->wl_word);
                if (s) {
                    tfree(w->wl_word);
                    w->wl_word = s;
                    if (globalsubst == false) {
                        while (**string)
                            (*string)++;
                        break;
                    }
                }
            }
            /* In case globalsubst is true... */
            while (**string)
                (*string)++;
            break;
        default:
            if (!isdigit(**string)) {
                fprintf(cp_err, "Error: %s: bad modifier.\n",
                    *string);
                return (NULL);
            }
            i = scannum(*string);
            if (i > eventhi) {
                fprintf(cp_err, "Error: bad event number %d\n",
                        i);
                return (NULL);
            }
            eventhi = eventlo = i;
            while (isdigit(**string))
                (*string)++;
            if (**string == '*')
                eventhi = numwords - 1;
            if (**string == '-')
                if (!isdigit(*(*string + 1)))
                    eventhi = numwords - 1;
                else {
                    eventhi = scannum(++*string);
                    while (isdigit(**string))
                        (*string)++;
                }
    }
    /* Now change the word list accordingly and make another pass
     * if there is more of the substitute left.
     */
    
    wl = wl_range(wl, eventlo, eventhi);
    numwords = wl_length(wl);
    if (**string && *++*string)
        goto anothermod;
    return (wl);
}

static char* dohs ( )

static

static char* dohs ( char *  patrn, char *  str  )

static

Definition at line 492 of file history.c.

{
    char schar, *s, *p, buf[BSIZE_SP], *pat, pbuf[BSIZE_SP];
    int i = 0, plen;
    bool ok = false;

    if (patrn == NULL)
        goto err;
    strcpy(pbuf,patrn);
    pat = pbuf;
    schar = *pat++;
    s = strchr(pat, schar);
    if (s == NULL) {
        fprintf(cp_err, "Bad substitute.\n");
        goto err;
    }
    *s++ = '\0';
    p = strchr(s, schar);
    if (p)
        *p = '\0';
    plen = strlen(pat) - 1;
    for (i = 0; *str; str++) {
        if ((*str == *pat) && prefix(pat, str) && (ok == false)) {
            for (p = s; *p; p++)
                buf[i++] = *p;
            str += plen;
            ok = true;
        }
        else
            buf[i++] = *str;
    }
    buf[i] = '\0';
    if (ok)
        return (copy(buf));
err:
    return (NULL);
}

static wordlist* dohsubst ( )

static

static wordlist* dohsubst ( char *  string )

static

Definition at line 105 of file history.c.

{
    wordlist *wl, *nwl;
    char buf[BSIZE_SP], *s, *r = NULL, *t;

    if (*string == cp_bang) {
        if (cp_lastone) {
            wl = cp_lastone->hi_wlist;
            string++;
        }
        else {
            fprintf(cp_err, "0: event not found.\n");
            return (NULL);
        }
    }
    else {
        switch(*string) {

            case '-':
                wl = getevent(cp_event - scannum(++string));
                if (!wl)
                    return (NULL);
                while (isdigit(*string))
                    string++;
                break;

            case '?':
                (void) strcpy(buf, string + 1);
                if (s = strchr(buf, '?'))
                    *s = '\0';
                wl = hpattern(buf);
                if (!wl)
                    return (NULL);
                if (s == NULL) /* No modifiers on this one. */
                    return (wl_copy(wl));
                break;

            case '\0':  /* Maybe this should be cp_event. */
                wl = alloc(struct wordlist);
                wl->wl_word = copy("!");
                cp_didhsubst = false;
                return (wl);

            default:
                if (isdigit(*string)) {
                    wl = getevent(scannum(string));
                    if (!wl)
                        return (NULL);
                    while (isdigit(*string))
                        string++;
                }
                else {
                    (void) strcpy(buf, string);
                    for (s = ":^$*-%"; *s; s++) {
                        t = strchr(buf, *s);
                        if (t && ((t < r) || !r)) {
                            r = t;
                            string += r - buf;
                        }
                    }
                    if (r)
                        *r = '\0';
                    else 
                        while (*string)
                            string++;
                    if ((buf[0] == '\0') && cp_lastone)
                        wl = cp_lastone->hi_wlist;
                    else
                        wl = hprefix(buf);
                    if (!wl)
                        return (NULL);
                }
        }
    }
    if (wl == NULL) {   /* Shouldn't happen. */
        fprintf(cp_err, "Event not found.\n");
        return (NULL);
    }
    nwl = dohmod(&string, wl_copy(wl));
    if (!nwl)
        return (NULL);
    if (*string) {
        for (wl = nwl; wl->wl_next; wl = wl->wl_next)
            ;
        (void) sprintf(buf, "%s%s", wl->wl_word, string);
        tfree(wl->wl_word);
        wl->wl_word = copy(buf);
    }
    return (nwl);
}

static void freehist ( )

static

static void freehist ( int  num )

static

Definition at line 449 of file history.c.

{
    struct histent *hi, *ht;

    if (num < 1 || !cp_lastone)
        return;

    histlength -= num;
    if (histlength <= 0) {
        histlength = 0;
        for (ht = cp_lastone; ht; ht = hi) {
            hi = ht->hi_prev;
            wl_free(ht->hi_wlist);
            txfree((char*)ht);
        }
        cp_lastone = NULL;
        return;
    }

    num = histlength;
    hi = cp_lastone;
    while (num-- && hi->hi_prev)
        hi = hi->hi_prev;
    if (hi->hi_prev) {
        ht = hi->hi_prev;
        hi->hi_prev = NULL;
        for (; ht; ht = hi) {
            hi = ht->hi_prev;
            wl_free(ht->hi_wlist);
            txfree((char*)ht);
        }
    }
    else {
        fprintf(cp_err, "Internal error: history list mangled\n");
    }
}

static wordlist* getevent ( )

static

static wordlist* getevent ( int  num )

static

Definition at line 387 of file history.c.

{
    struct histent *hi;

    for (hi = cp_lastone; hi; hi = hi->hi_prev)
        if (hi->hi_event == num)
            break;
    if (hi == NULL) {
        fprintf(cp_err, "%d: event not found.\n", num);
        return (NULL);
    }
    return (hi->hi_wlist);
}

static wordlist* hpattern ( )

static

static wordlist* hpattern ( char *  buf )

static

Definition at line 314 of file history.c.

{
    struct histent *hi;
    wordlist *wl;

    if (*buf == '\0') {
        fprintf(cp_err, "Bad pattern specification.\n");
        return (NULL);
    }
    for (hi = cp_lastone; hi; hi = hi->hi_prev)
        for (wl = hi->hi_wlist; wl; wl = wl->wl_next)
            if (substring(buf, wl->wl_word))
                return (hi->hi_wlist);
    fprintf(cp_err, "%s: event not found.\n", buf);
    return (NULL);
}

static wordlist* hprefix ( )

static

static wordlist* hprefix ( char *  buf )

static

Definition at line 335 of file history.c.

{
    struct histent *hi;

    if (*buf == '\0') {
        fprintf(cp_err, "Bad pattern specification.\n");
        return (NULL);
    }
    for (hi = cp_lastone; hi; hi = hi->hi_prev)
        if (hi->hi_wlist && prefix(buf, hi->hi_wlist->wl_word))
            return (hi->hi_wlist);
    fprintf(cp_err, "%s: event not found.\n", buf);
    return (NULL);
}

Variable Documentation

char cp_bang = '!'

Definition at line 37 of file history.c.

bool cp_didhsubst

Definition at line 38 of file history.c.

char cp_hat = '^'

Definition at line 36 of file history.c.

struct histent* cp_lastone = NULL

Definition at line 34 of file history.c.

int cp_maxhistlength = 1000

Definition at line 35 of file history.c.

int histlength = 0

static

Definition at line 40 of file history.c.