contrib/tcsh/sh.hist.c

   1 /* $Header: /src/pub/tcsh/sh.hist.c,v 3.27 2000/06/10 22:07:56 kim Exp $ */
   2 /*
   3  * sh.hist.c: Shell history expansions and substitutions
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37 #include "sh.h"
  38
  39 RCSID("$Id: sh.hist.c,v 3.27 2000/06/10 22:07:56 kim Exp $")
  40
  41 #include "tc.h"
  42
  43 extern bool histvalid;
  44 extern Char histline[];
  45 Char HistLit = 0;
  46
  47 static  bool    heq     __P((struct wordent *, struct wordent *));
  48 static  void    hfree   __P((struct Hist *));
  49 static  void    dohist1 __P((struct Hist *, int *, int));
  50 static  void    phist   __P((struct Hist *, int));
  51
  52 #define HIST_ONLY       0x01
  53 #define HIST_SAVE       0x02
  54 #define HIST_LOAD       0x04
  55 #define HIST_REV        0x08
  56 #define HIST_CLEAR      0x10
  57 #define HIST_MERGE      0x20
  58 #define HIST_TIME       0x40
  59
  60 /*
  61  * C shell
  62  */
  63
  64 void
  65 savehist(sp, mflg)
  66     struct wordent *sp;
  67     bool mflg;
  68 {
  69     register struct Hist *hp, *np;
  70     register int histlen = 0;
  71     Char   *cp;
  72
  73     /* throw away null lines */
  74     if (sp && sp->next->word[0] == '\n')
  75         return;
  76     cp = varval(STRhistory);
  77     if (*cp) {
  78         register Char *p = cp;
  79
  80         while (*p) {
  81             if (!Isdigit(*p)) {
  82                 histlen = 0;
  83                 break;
  84             }
  85             histlen = histlen * 10 + *p++ - '0';
  86         }
  87     }
  88     if (sp)
  89         (void) enthist(++eventno, sp, 1, mflg);
  90     for (hp = &Histlist; (np = hp->Hnext) != NULL;)
  91         if (eventno - np->Href >= histlen || histlen == 0)
  92             hp->Hnext = np->Hnext, hfree(np);
  93         else
  94             hp = np;
  95 }
  96
  97 static bool
  98 heq(a0, b0)
  99     struct wordent *a0, *b0;
 100 {
 101     struct wordent *a = a0->next, *b = b0->next;
 102
 103     for (;;) {
 104         if (Strcmp(a->word, b->word) != 0)
 105             return 0;
 106         a = a->next;
 107         b = b->next;
 108         if (a == a0)
 109             return (b == b0) ? 1 : 0;
 110         if (b == b0)
 111             return 0;
 112     }
 113 }
 114
 115
 116 struct Hist *
 117 enthist(event, lp, docopy, mflg)
 118     int     event;
 119     register struct wordent *lp;
 120     bool    docopy;
 121     bool    mflg;
 122 {
 123     extern time_t Htime;
 124     struct Hist *p = NULL, *pp = &Histlist;
 125     int n, r;
 126     register struct Hist *np;
 127     Char *dp;
 128
 129     if ((dp = varval(STRhistdup)) != STRNULL) {
 130         if (eq(dp, STRerase)) {
 131             /* masaoki@akebono.tky.hp.com (Kobayashi Masaoki) */
 132             struct Hist *px;
 133             for (p = pp; (px = p, p = p->Hnext) != NULL;)
 134                 if (heq(lp, &(p->Hlex))){
 135                     px->Hnext = p->Hnext;
 136                     if (Htime != 0 && p->Htime > Htime)
 137                         Htime = p->Htime;
 138                     n = p->Href;
 139                     hfree(p);
 140                     for (p = px->Hnext; p != NULL; p = p->Hnext)
 141                         p->Href = n--;
 142                     break;
 143                 }
 144         }
 145         else if (eq(dp, STRall)) {
 146             for (p = pp; (p = p->Hnext) != NULL;)
 147                 if (heq(lp, &(p->Hlex))) {
 148                     eventno--;
 149                     break;
 150                 }
 151         }
 152         else if (eq(dp, STRprev)) {
 153             if (pp->Hnext && heq(lp, &(pp->Hnext->Hlex))) {
 154                 p = pp->Hnext;
 155                 eventno--;
 156             }
 157         }
 158     }
 159
 160     np = p ? p : (struct Hist *) xmalloc((size_t) sizeof(*np));
 161
 162     /* Pick up timestamp set by lex() in Htime if reading saved history */
 163     if (Htime != (time_t) 0) {
 164         np->Htime = Htime;
 165         Htime = 0;
 166     }
 167     else
 168         (void) time(&(np->Htime));
 169
 170     if (p == np)
 171         return np;
 172
 173     np->Hnum = np->Href = event;
 174     if (docopy) {
 175         copylex(&np->Hlex, lp);
 176         if (histvalid)
 177             np->histline = Strsave(histline);
 178         else
 179             np->histline = NULL;
 180     }
 181     else {
 182         np->Hlex.next = lp->next;
 183         lp->next->prev = &np->Hlex;
 184         np->Hlex.prev = lp->prev;
 185         lp->prev->next = &np->Hlex;
 186         np->histline = NULL;
 187     }
 188     if (mflg)
 189       {
 190         while ((p = pp->Hnext) && (p->Htime > np->Htime))
 191           pp = p;
 192         while (p && p->Htime == np->Htime)
 193           {
 194             if (heq(&p->Hlex, &np->Hlex))
 195               {
 196                 eventno--;
 197                 hfree(np);
 198                 return (p);
 199               }
 200             pp = p;
 201             p = p->Hnext;
 202           }
 203         for (p = Histlist.Hnext; p != pp->Hnext; p = p->Hnext)
 204           {
 205             n = p->Hnum; r = p->Href;
 206             p->Hnum = np->Hnum; p->Href = np->Href;
 207             np->Hnum = n; np->Href = r;
 208           }
 209       }
 210     np->Hnext = pp->Hnext;
 211     pp->Hnext = np;
 212     return (np);
 213 }
 214
 215 static void
 216 hfree(hp)
 217     register struct Hist *hp;
 218 {
 219
 220     freelex(&hp->Hlex);
 221     if (hp->histline)
 222         xfree((ptr_t) hp->histline);
 223     xfree((ptr_t) hp);
 224 }
 225
 226
 227 /*ARGSUSED*/
 228 void
 229 dohist(vp, c)
 230     Char  **vp;
 231     struct command *c;
 232 {
 233     int     n, hflg = 0;
 234
 235     USE(c);
 236     if (getn(varval(STRhistory)) == 0)
 237         return;
 238     if (setintr)
 239 #ifdef BSDSIGS
 240         (void) sigsetmask(sigblock((sigmask_t) 0) & ~sigmask(SIGINT));
 241 #else
 242         (void) sigrelse(SIGINT);
 243 #endif
 244     while (*++vp && **vp == '-') {
 245         Char   *vp2 = *vp;
 246
 247         while (*++vp2)
 248             switch (*vp2) {
 249             case 'c':
 250                 hflg |= HIST_CLEAR;
 251                 break;
 252             case 'h':
 253                 hflg |= HIST_ONLY;
 254                 break;
 255             case 'r':
 256                 hflg |= HIST_REV;
 257                 break;
 258             case 'S':
 259                 hflg |= HIST_SAVE;
 260                 break;
 261             case 'L':
 262                 hflg |= HIST_LOAD;
 263                 break;
 264             case 'M':
 265                 hflg |= HIST_MERGE;
 266                 break;
 267             case 'T':
 268                 hflg |= HIST_TIME;
 269                 break;
 270             default:
 271                 stderror(ERR_HISTUS, "chrSLMT");
 272                 break;
 273             }
 274     }
 275
 276     if (hflg & HIST_CLEAR) {
 277         struct Hist *np, *hp;
 278         for (hp = &Histlist; (np = hp->Hnext) != NULL;)
 279             hp->Hnext = np->Hnext, hfree(np);
 280     }
 281
 282     if (hflg & (HIST_LOAD | HIST_MERGE)) {
 283         loadhist(*vp, (hflg & HIST_MERGE) ? 1 : 0);
 284         return;
 285     }
 286     else if (hflg & HIST_SAVE) {
 287         rechist(*vp, 1);
 288         return;
 289     }
 290     if (*vp)
 291         n = getn(*vp);
 292     else {
 293         n = getn(varval(STRhistory));
 294     }
 295     dohist1(Histlist.Hnext, &n, hflg);
 296 }
 297
 298 static void
 299 dohist1(hp, np, hflg)
 300     struct Hist *hp;
 301     int    *np, hflg;
 302 {
 303     bool    print = (*np) > 0;
 304
 305     for (; hp != 0; hp = hp->Hnext) {
 306         (*np)--;
 307         if ((hflg & HIST_REV) == 0) {
 308             dohist1(hp->Hnext, np, hflg);
 309             if (print)
 310                 phist(hp, hflg);
 311             return;
 312         }
 313         if (*np >= 0)
 314             phist(hp, hflg);
 315     }
 316 }
 317
 318 static void
 319 phist(hp, hflg)
 320     register struct Hist *hp;
 321     int     hflg;
 322 {
 323     extern bool output_raw;
 324     if (hflg & HIST_ONLY) {
 325        /*
 326         * Control characters have to be written as is (output_raw).
 327         * This way one can preserve special characters (like tab) in
 328         * the history file.
 329         * From: mveksler@vnet.ibm.com (Veksler Michael)
 330         */
 331         output_raw= 1;
 332         if (hflg & HIST_TIME)
 333             /*
 334              * Make file entry with history time in format:
 335              * "+NNNNNNNNNN" (10 digits, left padded with ascii '0')
 336              */
 337
 338             xprintf("#+%010lu\n", hp->Htime);
 339
 340         if (HistLit && hp->histline)
 341             xprintf("%S\n", hp->histline);
 342         else
 343             prlex(&hp->Hlex);
 344         output_raw= 0;
 345     }
 346     else {
 347         Char   *cp = str2short("%h\t%T\t%R\n");
 348         Char buf[INBUFSIZE];
 349         struct varent *vp = adrof(STRhistory);
 350
 351         if (vp && vp->vec[0] && vp->vec[1])
 352             cp = vp->vec[1];
 353
 354         tprintf(FMT_HISTORY, buf, cp, INBUFSIZE, NULL, hp->Htime, (ptr_t) hp);
 355         for (cp = buf; *cp;)
 356             xputchar(*cp++);
 357     }
 358 }
 359
 360
 361 void
 362 fmthist(fmt, ptr, buf, bufsiz)
 363     int fmt;
 364     ptr_t ptr;
 365     char *buf;
 366     size_t bufsiz;
 367 {
 368     struct Hist *hp = (struct Hist *) ptr;
 369     switch (fmt) {
 370     case 'h':
 371         (void) xsnprintf(buf, bufsiz, "%6d", hp->Hnum);
 372         break;
 373     case 'R':
 374         if (HistLit && hp->histline)
 375             (void) xsnprintf(buf, bufsiz, "%S", hp->histline);
 376         else {
 377             Char ibuf[INBUFSIZE], *ip;
 378             char *p;
 379             (void) sprlex(ibuf, sizeof(ibuf) / sizeof(Char), &hp->Hlex);
 380             for (p = buf, ip = ibuf; (*p++ = (CHAR & *ip++)) != '\0'; )
 381                 continue;
 382         }
 383         break;
 384     default:
 385         buf[0] = '\0';
 386         break;
 387     }
 388
 389 }
 390
 391 void
 392 rechist(fname, ref)
 393     Char *fname;
 394     int ref;
 395 {
 396     Char    *snum;
 397     int     fp, ftmp, oldidfds;
 398     struct varent *shist;
 399     static Char   *dumphist[] = {STRhistory, STRmhT, 0, 0};
 400
 401     if (fname == NULL && !ref)
 402         return;
 403     /*
 404      * If $savehist is just set, we use the value of $history
 405      * else we use the value in $savehist
 406      */
 407     if (((snum = varval(STRsavehist)) == STRNULL) &&
 408         ((snum = varval(STRhistory)) == STRNULL))
 409         snum = STRmaxint;
 410
 411
 412     if (fname == NULL) {
 413         if ((fname = varval(STRhistfile)) == STRNULL)
 414             fname = Strspl(varval(STRhome), &STRtildothist[1]);
 415         else
 416             fname = Strsave(fname);
 417     }
 418     else
 419         fname = globone(fname, G_ERROR);
 420
 421     /*
 422      * The 'savehist merge' feature is intended for an environment
 423      * with numerous shells beeing in simultaneous use. Imagine
 424      * any kind of window system. All these shells 'share' the same
 425      * ~/.history file for recording their command line history.
 426      * Currently the automatic merge can only succeed when the shells
 427      * nicely quit one after another.
 428      *
 429      * Users that like to nuke their environment require here an atomic
 430      *  loadhist-creat-dohist(dumphist)-close
 431      * sequence.
 432      *
 433      * jw.
 434      */
 435     /*
 436      * We need the didfds stuff before loadhist otherwise
 437      * exec in a script will fail to print if merge is set.
 438      * From: mveksler@iil.intel.com (Veksler Michael)
 439      */
 440     oldidfds = didfds;
 441     didfds = 0;
 442     if ((shist = adrof(STRsavehist)) != NULL)
 443         if (shist->vec[1] && eq(shist->vec[1], STRmerge))
 444             loadhist(fname, 1);
 445     fp = creat(short2str(fname), 0600);
 446     if (fp == -1) {
 447         didfds = oldidfds;
 448         return;
 449     }
 450     ftmp = SHOUT;
 451     SHOUT = fp;
 452     dumphist[2] = snum;
 453     dohist(dumphist, NULL);
 454     (void) close(fp);
 455     SHOUT = ftmp;
 456     didfds = oldidfds;
 457     xfree((ptr_t) fname);
 458 }
 459
 460
 461 void
 462 loadhist(fname, mflg)
 463     Char *fname;
 464     bool mflg;
 465 {
 466     static Char   *loadhist_cmd[] = {STRsource, NULL, NULL, NULL};
 467     loadhist_cmd[1] = mflg ? STRmm : STRmh;
 468
 469     if (fname != NULL)
 470         loadhist_cmd[2] = fname;
 471     else if ((fname = varval(STRhistfile)) != STRNULL)
 472         loadhist_cmd[2] = fname;
 473     else
 474         loadhist_cmd[2] = STRtildothist;
 475
 476     dosource(loadhist_cmd, NULL);
 477 }