contrib/libedit/src/history.c

   1 /*      $NetBSD: history.c,v 1.47 2014/05/11 01:05:17 christos Exp $    */
   2
   3 /*-
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Christos Zoulas of Cornell University.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #ifndef NARROWCHAR
  36 #include "config.h"
  37 #endif
  38
  39 #if !defined(lint) && !defined(SCCSID)
  40 #if 0
  41 static char sccsid[] = "@(#)history.c   8.1 (Berkeley) 6/4/93";
  42 #else
  43 __RCSID("$NetBSD: history.c,v 1.47 2014/05/11 01:05:17 christos Exp $");
  44 #endif
  45 #endif /* not lint && not SCCSID */
  46
  47 /*
  48  * hist.c: TYPE(History) access functions
  49  */
  50 #include <string.h>
  51 #include <stdlib.h>
  52 #include <stdarg.h>
  53 #include <vis.h>
  54 #include <sys/stat.h>
  55
  56 static const char hist_cookie[] = "_HiStOrY_V2_\n";
  57
  58 #include "histedit.h"
  59 #include "chartype.h"
  60
  61 typedef int (*history_gfun_t)(void *, TYPE(HistEvent) *);
  62 typedef int (*history_efun_t)(void *, TYPE(HistEvent) *, const Char *);
  63 typedef void (*history_vfun_t)(void *, TYPE(HistEvent) *);
  64 typedef int (*history_sfun_t)(void *, TYPE(HistEvent) *, const int);
  65
  66 struct TYPE(history) {
  67         void *h_ref;            /* Argument for history fcns     */
  68         int h_ent;              /* Last entry point for history  */
  69         history_gfun_t h_first; /* Get the first element         */
  70         history_gfun_t h_next;  /* Get the next element          */
  71         history_gfun_t h_last;  /* Get the last element          */
  72         history_gfun_t h_prev;  /* Get the previous element      */
  73         history_gfun_t h_curr;  /* Get the current element       */
  74         history_sfun_t h_set;   /* Set the current element       */
  75         history_sfun_t h_del;   /* Set the given element         */
  76         history_vfun_t h_clear; /* Clear the history list        */
  77         history_efun_t h_enter; /* Add an element                */
  78         history_efun_t h_add;   /* Append to an element          */
  79 };
  80
  81 #define HNEXT(h, ev)            (*(h)->h_next)((h)->h_ref, ev)
  82 #define HFIRST(h, ev)           (*(h)->h_first)((h)->h_ref, ev)
  83 #define HPREV(h, ev)            (*(h)->h_prev)((h)->h_ref, ev)
  84 #define HLAST(h, ev)            (*(h)->h_last)((h)->h_ref, ev)
  85 #define HCURR(h, ev)            (*(h)->h_curr)((h)->h_ref, ev)
  86 #define HSET(h, ev, n)          (*(h)->h_set)((h)->h_ref, ev, n)
  87 #define HCLEAR(h, ev)           (*(h)->h_clear)((h)->h_ref, ev)
  88 #define HENTER(h, ev, str)      (*(h)->h_enter)((h)->h_ref, ev, str)
  89 #define HADD(h, ev, str)        (*(h)->h_add)((h)->h_ref, ev, str)
  90 #define HDEL(h, ev, n)          (*(h)->h_del)((h)->h_ref, ev, n)
  91
  92 #define h_strdup(a)     Strdup(a)
  93 #define h_malloc(a)     malloc(a)
  94 #define h_realloc(a, b) realloc((a), (b))
  95 #define h_free(a)       free(a)
  96
  97 typedef struct {
  98     int         num;
  99     Char        *str;
 100 } HistEventPrivate;
 101
 102
 103
 104 private int history_setsize(TYPE(History) *, TYPE(HistEvent) *, int);
 105 private int history_getsize(TYPE(History) *, TYPE(HistEvent) *);
 106 private int history_setunique(TYPE(History) *, TYPE(HistEvent) *, int);
 107 private int history_getunique(TYPE(History) *, TYPE(HistEvent) *);
 108 private int history_set_fun(TYPE(History) *, TYPE(History) *);
 109 private int history_load(TYPE(History) *, const char *);
 110 private int history_save(TYPE(History) *, const char *);
 111 private int history_save_fp(TYPE(History) *, FILE *);
 112 private int history_prev_event(TYPE(History) *, TYPE(HistEvent) *, int);
 113 private int history_next_event(TYPE(History) *, TYPE(HistEvent) *, int);
 114 private int history_next_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
 115 private int history_prev_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
 116
 117
 118 /***********************************************************************/
 119
 120 /*
 121  * Builtin- history implementation
 122  */
 123 typedef struct hentry_t {
 124         TYPE(HistEvent) ev;             /* What we return                */
 125         void *data;             /* data                          */
 126         struct hentry_t *next;  /* Next entry                    */
 127         struct hentry_t *prev;  /* Previous entry                */
 128 } hentry_t;
 129
 130 typedef struct history_t {
 131         hentry_t list;          /* Fake list header element     */
 132         hentry_t *cursor;       /* Current element in the list  */
 133         int max;                /* Maximum number of events     */
 134         int cur;                /* Current number of events     */
 135         int eventid;            /* For generation of unique event id     */
 136         int flags;              /* TYPE(History) flags          */
 137 #define H_UNIQUE        1       /* Store only unique elements   */
 138 } history_t;
 139
 140 private int history_def_next(void *, TYPE(HistEvent) *);
 141 private int history_def_first(void *, TYPE(HistEvent) *);
 142 private int history_def_prev(void *, TYPE(HistEvent) *);
 143 private int history_def_last(void *, TYPE(HistEvent) *);
 144 private int history_def_curr(void *, TYPE(HistEvent) *);
 145 private int history_def_set(void *, TYPE(HistEvent) *, const int);
 146 private void history_def_clear(void *, TYPE(HistEvent) *);
 147 private int history_def_enter(void *, TYPE(HistEvent) *, const Char *);
 148 private int history_def_add(void *, TYPE(HistEvent) *, const Char *);
 149 private int history_def_del(void *, TYPE(HistEvent) *, const int);
 150
 151 private int history_def_init(void **, TYPE(HistEvent) *, int);
 152 private int history_def_insert(history_t *, TYPE(HistEvent) *, const Char *);
 153 private void history_def_delete(history_t *, TYPE(HistEvent) *, hentry_t *);
 154
 155 private int history_deldata_nth(history_t *, TYPE(HistEvent) *, int, void **);
 156 private int history_set_nth(void *, TYPE(HistEvent) *, int);
 157
 158 #define history_def_setsize(p, num)(void) (((history_t *)p)->max = (num))
 159 #define history_def_getsize(p)  (((history_t *)p)->cur)
 160 #define history_def_getunique(p) (((((history_t *)p)->flags) & H_UNIQUE) != 0)
 161 #define history_def_setunique(p, uni) \
 162     if (uni) \
 163         (((history_t *)p)->flags) |= H_UNIQUE; \
 164     else \
 165         (((history_t *)p)->flags) &= ~H_UNIQUE
 166
 167 #define he_strerror(code)       he_errlist[code]
 168 #define he_seterrev(evp, code)  {\
 169                                     evp->num = code;\
 170                                     evp->str = he_strerror(code);\
 171                                 }
 172
 173 /* error messages */
 174 static const Char *const he_errlist[] = {
 175         STR("OK"),
 176         STR("unknown error"),
 177         STR("malloc() failed"),
 178         STR("first event not found"),
 179         STR("last event not found"),
 180         STR("empty list"),
 181         STR("no next event"),
 182         STR("no previous event"),
 183         STR("current event is invalid"),
 184         STR("event not found"),
 185         STR("can't read history from file"),
 186         STR("can't write history"),
 187         STR("required parameter(s) not supplied"),
 188         STR("history size negative"),
 189         STR("function not allowed with other history-functions-set the default"),
 190         STR("bad parameters")
 191 };
 192 /* error codes */
 193 #define _HE_OK                   0
 194 #define _HE_UNKNOWN              1
 195 #define _HE_MALLOC_FAILED        2
 196 #define _HE_FIRST_NOTFOUND       3
 197 #define _HE_LAST_NOTFOUND        4
 198 #define _HE_EMPTY_LIST           5
 199 #define _HE_END_REACHED          6
 200 #define _HE_START_REACHED        7
 201 #define _HE_CURR_INVALID         8
 202 #define _HE_NOT_FOUND            9
 203 #define _HE_HIST_READ           10
 204 #define _HE_HIST_WRITE          11
 205 #define _HE_PARAM_MISSING       12
 206 #define _HE_SIZE_NEGATIVE       13
 207 #define _HE_NOT_ALLOWED         14
 208 #define _HE_BAD_PARAM           15
 209
 210 /* history_def_first():
 211  *      Default function to return the first event in the history.
 212  */
 213 private int
 214 history_def_first(void *p, TYPE(HistEvent) *ev)
 215 {
 216         history_t *h = (history_t *) p;
 217
 218         h->cursor = h->list.next;
 219         if (h->cursor != &h->list)
 220                 *ev = h->cursor->ev;
 221         else {
 222                 he_seterrev(ev, _HE_FIRST_NOTFOUND);
 223                 return -1;
 224         }
 225
 226         return 0;
 227 }
 228
 229
 230 /* history_def_last():
 231  *      Default function to return the last event in the history.
 232  */
 233 private int
 234 history_def_last(void *p, TYPE(HistEvent) *ev)
 235 {
 236         history_t *h = (history_t *) p;
 237
 238         h->cursor = h->list.prev;
 239         if (h->cursor != &h->list)
 240                 *ev = h->cursor->ev;
 241         else {
 242                 he_seterrev(ev, _HE_LAST_NOTFOUND);
 243                 return -1;
 244         }
 245
 246         return 0;
 247 }
 248
 249
 250 /* history_def_next():
 251  *      Default function to return the next event in the history.
 252  */
 253 private int
 254 history_def_next(void *p, TYPE(HistEvent) *ev)
 255 {
 256         history_t *h = (history_t *) p;
 257
 258         if (h->cursor == &h->list) {
 259                 he_seterrev(ev, _HE_EMPTY_LIST);
 260                 return -1;
 261         }
 262
 263         if (h->cursor->next == &h->list) {
 264                 he_seterrev(ev, _HE_END_REACHED);
 265                 return -1;
 266         }
 267
 268         h->cursor = h->cursor->next;
 269         *ev = h->cursor->ev;
 270
 271         return 0;
 272 }
 273
 274
 275 /* history_def_prev():
 276  *      Default function to return the previous event in the history.
 277  */
 278 private int
 279 history_def_prev(void *p, TYPE(HistEvent) *ev)
 280 {
 281         history_t *h = (history_t *) p;
 282
 283         if (h->cursor == &h->list) {
 284                 he_seterrev(ev,
 285                     (h->cur > 0) ? _HE_END_REACHED : _HE_EMPTY_LIST);
 286                 return -1;
 287         }
 288
 289         if (h->cursor->prev == &h->list) {
 290                 he_seterrev(ev, _HE_START_REACHED);
 291                 return -1;
 292         }
 293
 294         h->cursor = h->cursor->prev;
 295         *ev = h->cursor->ev;
 296
 297         return 0;
 298 }
 299
 300
 301 /* history_def_curr():
 302  *      Default function to return the current event in the history.
 303  */
 304 private int
 305 history_def_curr(void *p, TYPE(HistEvent) *ev)
 306 {
 307         history_t *h = (history_t *) p;
 308
 309         if (h->cursor != &h->list)
 310                 *ev = h->cursor->ev;
 311         else {
 312                 he_seterrev(ev,
 313                     (h->cur > 0) ? _HE_CURR_INVALID : _HE_EMPTY_LIST);
 314                 return -1;
 315         }
 316
 317         return 0;
 318 }
 319
 320
 321 /* history_def_set():
 322  *      Default function to set the current event in the history to the
 323  *      given one.
 324  */
 325 private int
 326 history_def_set(void *p, TYPE(HistEvent) *ev, const int n)
 327 {
 328         history_t *h = (history_t *) p;
 329
 330         if (h->cur == 0) {
 331                 he_seterrev(ev, _HE_EMPTY_LIST);
 332                 return -1;
 333         }
 334         if (h->cursor == &h->list || h->cursor->ev.num != n) {
 335                 for (h->cursor = h->list.next; h->cursor != &h->list;
 336                     h->cursor = h->cursor->next)
 337                         if (h->cursor->ev.num == n)
 338                                 break;
 339         }
 340         if (h->cursor == &h->list) {
 341                 he_seterrev(ev, _HE_NOT_FOUND);
 342                 return -1;
 343         }
 344         return 0;
 345 }
 346
 347
 348 /* history_set_nth():
 349  *      Default function to set the current event in the history to the
 350  *      n-th one.
 351  */
 352 private int
 353 history_set_nth(void *p, TYPE(HistEvent) *ev, int n)
 354 {
 355         history_t *h = (history_t *) p;
 356
 357         if (h->cur == 0) {
 358                 he_seterrev(ev, _HE_EMPTY_LIST);
 359                 return -1;
 360         }
 361         for (h->cursor = h->list.prev; h->cursor != &h->list;
 362             h->cursor = h->cursor->prev)
 363                 if (n-- <= 0)
 364                         break;
 365         if (h->cursor == &h->list) {
 366                 he_seterrev(ev, _HE_NOT_FOUND);
 367                 return -1;
 368         }
 369         return 0;
 370 }
 371
 372
 373 /* history_def_add():
 374  *      Append string to element
 375  */
 376 private int
 377 history_def_add(void *p, TYPE(HistEvent) *ev, const Char *str)
 378 {
 379         history_t *h = (history_t *) p;
 380         size_t len;
 381         Char *s;
 382         HistEventPrivate *evp = (void *)&h->cursor->ev;
 383
 384         if (h->cursor == &h->list)
 385                 return history_def_enter(p, ev, str);
 386         len = Strlen(evp->str) + Strlen(str) + 1;
 387         s = h_malloc(len * sizeof(*s));
 388         if (s == NULL) {
 389                 he_seterrev(ev, _HE_MALLOC_FAILED);
 390                 return -1;
 391         }
 392         (void) Strncpy(s, h->cursor->ev.str, len);
 393         s[len - 1] = '\0';
 394         (void) Strncat(s, str, len - Strlen(s) - 1);
 395         h_free(evp->str);
 396         evp->str = s;
 397         *ev = h->cursor->ev;
 398         return 0;
 399 }
 400
 401
 402 private int
 403 history_deldata_nth(history_t *h, TYPE(HistEvent) *ev,
 404     int num, void **data)
 405 {
 406         if (history_set_nth(h, ev, num) != 0)
 407                 return -1;
 408         /* magic value to skip delete (just set to n-th history) */
 409         if (data == (void **)-1)
 410                 return 0;
 411         ev->str = Strdup(h->cursor->ev.str);
 412         ev->num = h->cursor->ev.num;
 413         if (data)
 414                 *data = h->cursor->data;
 415         history_def_delete(h, ev, h->cursor);
 416         return 0;
 417 }
 418
 419
 420 /* history_def_del():
 421  *      Delete element hp of the h list
 422  */
 423 /* ARGSUSED */
 424 private int
 425 history_def_del(void *p, TYPE(HistEvent) *ev __attribute__((__unused__)),
 426     const int num)
 427 {
 428         history_t *h = (history_t *) p;
 429         if (history_def_set(h, ev, num) != 0)
 430                 return -1;
 431         ev->str = Strdup(h->cursor->ev.str);
 432         ev->num = h->cursor->ev.num;
 433         history_def_delete(h, ev, h->cursor);
 434         return 0;
 435 }
 436
 437
 438 /* history_def_delete():
 439  *      Delete element hp of the h list
 440  */
 441 /* ARGSUSED */
 442 private void
 443 history_def_delete(history_t *h,
 444                    TYPE(HistEvent) *ev __attribute__((__unused__)), hentry_t *hp)
 445 {
 446         HistEventPrivate *evp = (void *)&hp->ev;
 447         if (hp == &h->list)
 448                 abort();
 449         if (h->cursor == hp) {
 450                 h->cursor = hp->prev;
 451                 if (h->cursor == &h->list)
 452                         h->cursor = hp->next;
 453         }
 454         hp->prev->next = hp->next;
 455         hp->next->prev = hp->prev;
 456         h_free(evp->str);
 457         h_free(hp);
 458         h->cur--;
 459 }
 460
 461
 462 /* history_def_insert():
 463  *      Insert element with string str in the h list
 464  */
 465 private int
 466 history_def_insert(history_t *h, TYPE(HistEvent) *ev, const Char *str)
 467 {
 468         hentry_t *c;
 469
 470         c = h_malloc(sizeof(*c));
 471         if (c == NULL)
 472                 goto oomem;
 473         if ((c->ev.str = h_strdup(str)) == NULL) {
 474                 h_free(c);
 475                 goto oomem;
 476         }
 477         c->data = NULL;
 478         c->ev.num = ++h->eventid;
 479         c->next = h->list.next;
 480         c->prev = &h->list;
 481         h->list.next->prev = c;
 482         h->list.next = c;
 483         h->cur++;
 484         h->cursor = c;
 485
 486         *ev = c->ev;
 487         return 0;
 488 oomem:
 489         he_seterrev(ev, _HE_MALLOC_FAILED);
 490         return -1;
 491 }
 492
 493
 494 /* history_def_enter():
 495  *      Default function to enter an item in the history
 496  */
 497 private int
 498 history_def_enter(void *p, TYPE(HistEvent) *ev, const Char *str)
 499 {
 500         history_t *h = (history_t *) p;
 501
 502         if ((h->flags & H_UNIQUE) != 0 && h->list.next != &h->list &&
 503             Strcmp(h->list.next->ev.str, str) == 0)
 504             return 0;
 505
 506         if (history_def_insert(h, ev, str) == -1)
 507                 return -1;      /* error, keep error message */
 508
 509         /*
 510          * Always keep at least one entry.
 511          * This way we don't have to check for the empty list.
 512          */
 513         while (h->cur > h->max && h->cur > 0)
 514                 history_def_delete(h, ev, h->list.prev);
 515
 516         return 1;
 517 }
 518
 519
 520 /* history_def_init():
 521  *      Default history initialization function
 522  */
 523 /* ARGSUSED */
 524 private int
 525 history_def_init(void **p, TYPE(HistEvent) *ev __attribute__((__unused__)), int n)
 526 {
 527         history_t *h = (history_t *) h_malloc(sizeof(*h));
 528         if (h == NULL)
 529                 return -1;
 530
 531         if (n <= 0)
 532                 n = 0;
 533         h->eventid = 0;
 534         h->cur = 0;
 535         h->max = n;
 536         h->list.next = h->list.prev = &h->list;
 537         h->list.ev.str = NULL;
 538         h->list.ev.num = 0;
 539         h->cursor = &h->list;
 540         h->flags = 0;
 541         *p = h;
 542         return 0;
 543 }
 544
 545
 546 /* history_def_clear():
 547  *      Default history cleanup function
 548  */
 549 private void
 550 history_def_clear(void *p, TYPE(HistEvent) *ev)
 551 {
 552         history_t *h = (history_t *) p;
 553
 554         while (h->list.prev != &h->list)
 555                 history_def_delete(h, ev, h->list.prev);
 556         h->cursor = &h->list;
 557         h->eventid = 0;
 558         h->cur = 0;
 559 }
 560
 561
 562
 563
 564 /************************************************************************/
 565
 566 /* history_init():
 567  *      Initialization function.
 568  */
 569 public TYPE(History) *
 570 FUN(history,init)(void)
 571 {
 572         TYPE(HistEvent) ev;
 573         TYPE(History) *h = (TYPE(History) *) h_malloc(sizeof(*h));
 574         if (h == NULL)
 575                 return NULL;
 576
 577         if (history_def_init(&h->h_ref, &ev, 0) == -1) {
 578                 h_free(h);
 579                 return NULL;
 580         }
 581         h->h_ent = -1;
 582         h->h_next = history_def_next;
 583         h->h_first = history_def_first;
 584         h->h_last = history_def_last;
 585         h->h_prev = history_def_prev;
 586         h->h_curr = history_def_curr;
 587         h->h_set = history_def_set;
 588         h->h_clear = history_def_clear;
 589         h->h_enter = history_def_enter;
 590         h->h_add = history_def_add;
 591         h->h_del = history_def_del;
 592
 593         return h;
 594 }
 595
 596
 597 /* history_end():
 598  *      clean up history;
 599  */
 600 public void
 601 FUN(history,end)(TYPE(History) *h)
 602 {
 603         TYPE(HistEvent) ev;
 604
 605         if (h->h_next == history_def_next)
 606                 history_def_clear(h->h_ref, &ev);
 607         h_free(h->h_ref);
 608         h_free(h);
 609 }
 610
 611
 612
 613 /* history_setsize():
 614  *      Set history number of events
 615  */
 616 private int
 617 history_setsize(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
 618 {
 619
 620         if (h->h_next != history_def_next) {
 621                 he_seterrev(ev, _HE_NOT_ALLOWED);
 622                 return -1;
 623         }
 624         if (num < 0) {
 625                 he_seterrev(ev, _HE_BAD_PARAM);
 626                 return -1;
 627         }
 628         history_def_setsize(h->h_ref, num);
 629         return 0;
 630 }
 631
 632
 633 /* history_getsize():
 634  *      Get number of events currently in history
 635  */
 636 private int
 637 history_getsize(TYPE(History) *h, TYPE(HistEvent) *ev)
 638 {
 639         if (h->h_next != history_def_next) {
 640                 he_seterrev(ev, _HE_NOT_ALLOWED);
 641                 return -1;
 642         }
 643         ev->num = history_def_getsize(h->h_ref);
 644         if (ev->num < -1) {
 645                 he_seterrev(ev, _HE_SIZE_NEGATIVE);
 646                 return -1;
 647         }
 648         return 0;
 649 }
 650
 651
 652 /* history_setunique():
 653  *      Set if adjacent equal events should not be entered in history.
 654  */
 655 private int
 656 history_setunique(TYPE(History) *h, TYPE(HistEvent) *ev, int uni)
 657 {
 658
 659         if (h->h_next != history_def_next) {
 660                 he_seterrev(ev, _HE_NOT_ALLOWED);
 661                 return -1;
 662         }
 663         history_def_setunique(h->h_ref, uni);
 664         return 0;
 665 }
 666
 667
 668 /* history_getunique():
 669  *      Get if adjacent equal events should not be entered in history.
 670  */
 671 private int
 672 history_getunique(TYPE(History) *h, TYPE(HistEvent) *ev)
 673 {
 674         if (h->h_next != history_def_next) {
 675                 he_seterrev(ev, _HE_NOT_ALLOWED);
 676                 return -1;
 677         }
 678         ev->num = history_def_getunique(h->h_ref);
 679         return 0;
 680 }
 681
 682
 683 /* history_set_fun():
 684  *      Set history functions
 685  */
 686 private int
 687 history_set_fun(TYPE(History) *h, TYPE(History) *nh)
 688 {
 689         TYPE(HistEvent) ev;
 690
 691         if (nh->h_first == NULL || nh->h_next == NULL || nh->h_last == NULL ||
 692             nh->h_prev == NULL || nh->h_curr == NULL || nh->h_set == NULL ||
 693             nh->h_enter == NULL || nh->h_add == NULL || nh->h_clear == NULL ||
 694             nh->h_del == NULL || nh->h_ref == NULL) {
 695                 if (h->h_next != history_def_next) {
 696                         if (history_def_init(&h->h_ref, &ev, 0) == -1)
 697                                 return -1;
 698                         h->h_first = history_def_first;
 699                         h->h_next = history_def_next;
 700                         h->h_last = history_def_last;
 701                         h->h_prev = history_def_prev;
 702                         h->h_curr = history_def_curr;
 703                         h->h_set = history_def_set;
 704                         h->h_clear = history_def_clear;
 705                         h->h_enter = history_def_enter;
 706                         h->h_add = history_def_add;
 707                         h->h_del = history_def_del;
 708                 }
 709                 return -1;
 710         }
 711         if (h->h_next == history_def_next)
 712                 history_def_clear(h->h_ref, &ev);
 713
 714         h->h_ent = -1;
 715         h->h_first = nh->h_first;
 716         h->h_next = nh->h_next;
 717         h->h_last = nh->h_last;
 718         h->h_prev = nh->h_prev;
 719         h->h_curr = nh->h_curr;
 720         h->h_set = nh->h_set;
 721         h->h_clear = nh->h_clear;
 722         h->h_enter = nh->h_enter;
 723         h->h_add = nh->h_add;
 724         h->h_del = nh->h_del;
 725
 726         return 0;
 727 }
 728
 729
 730 /* history_load():
 731  *      TYPE(History) load function
 732  */
 733 private int
 734 history_load(TYPE(History) *h, const char *fname)
 735 {
 736         FILE *fp;
 737         char *line;
 738         size_t sz, max_size;
 739         char *ptr;
 740         int i = -1;
 741         TYPE(HistEvent) ev;
 742 #ifdef WIDECHAR
 743         static ct_buffer_t conv;
 744 #endif
 745
 746         if ((fp = fopen(fname, "r")) == NULL)
 747                 return i;
 748
 749         if ((line = fgetln(fp, &sz)) == NULL)
 750                 goto done;
 751
 752         if (strncmp(line, hist_cookie, sz) != 0)
 753                 goto done;
 754
 755         ptr = h_malloc((max_size = 1024) * sizeof(*ptr));
 756         if (ptr == NULL)
 757                 goto done;
 758         for (i = 0; (line = fgetln(fp, &sz)) != NULL; i++) {
 759                 char c = line[sz];
 760
 761                 if (sz != 0 && line[sz - 1] == '\n')
 762                         line[--sz] = '\0';
 763                 else
 764                         line[sz] = '\0';
 765
 766                 if (max_size < sz) {
 767                         char *nptr;
 768                         max_size = (sz + 1024) & (size_t)~1023;
 769                         nptr = h_realloc(ptr, max_size * sizeof(*ptr));
 770                         if (nptr == NULL) {
 771                                 i = -1;
 772                                 goto oomem;
 773                         }
 774                         ptr = nptr;
 775                 }
 776                 (void) strunvis(ptr, line);
 777                 line[sz] = c;
 778                 if (HENTER(h, &ev, ct_decode_string(ptr, &conv)) == -1) {
 779                         i = -1;
 780                         goto oomem;
 781                 }
 782         }
 783 oomem:
 784         h_free(ptr);
 785 done:
 786         (void) fclose(fp);
 787         return i;
 788 }
 789
 790
 791 /* history_save_fp():
 792  *      TYPE(History) save function
 793  */
 794 private int
 795 history_save_fp(TYPE(History) *h, FILE *fp)
 796 {
 797         TYPE(HistEvent) ev;
 798         int i = -1, retval;
 799         size_t len, max_size;
 800         char *ptr;
 801         const char *str;
 802 #ifdef WIDECHAR
 803         static ct_buffer_t conv;
 804 #endif
 805
 806         if (fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1)
 807                 goto done;
 808         if (fputs(hist_cookie, fp) == EOF)
 809                 goto done;
 810         ptr = h_malloc((max_size = 1024) * sizeof(*ptr));
 811         if (ptr == NULL)
 812                 goto done;
 813         for (i = 0, retval = HLAST(h, &ev);
 814             retval != -1;
 815             retval = HPREV(h, &ev), i++) {
 816                 str = ct_encode_string(ev.str, &conv);
 817                 len = strlen(str) * 4;
 818                 if (len >= max_size) {
 819                         char *nptr;
 820                         max_size = (len + 1024) & (size_t)~1023;
 821                         nptr = h_realloc(ptr, max_size * sizeof(*ptr));
 822                         if (nptr == NULL) {
 823                                 i = -1;
 824                                 goto oomem;
 825                         }
 826                         ptr = nptr;
 827                 }
 828                 (void) strvis(ptr, str, VIS_WHITE);
 829                 (void) fprintf(fp, "%s\n", ptr);
 830         }
 831 oomem:
 832         h_free(ptr);
 833 done:
 834         return i;
 835 }
 836
 837
 838 /* history_save():
 839  *    History save function
 840  */
 841 private int
 842 history_save(TYPE(History) *h, const char *fname)
 843 {
 844     FILE *fp;
 845     int i;
 846
 847     if ((fp = fopen(fname, "w")) == NULL)
 848         return -1;
 849
 850     i = history_save_fp(h, fp);
 851
 852     (void) fclose(fp);
 853     return i;
 854 }
 855
 856
 857 /* history_prev_event():
 858  *      Find the previous event, with number given
 859  */
 860 private int
 861 history_prev_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
 862 {
 863         int retval;
 864
 865         for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 866                 if (ev->num == num)
 867                         return 0;
 868
 869         he_seterrev(ev, _HE_NOT_FOUND);
 870         return -1;
 871 }
 872
 873
 874 private int
 875 history_next_evdata(TYPE(History) *h, TYPE(HistEvent) *ev, int num, void **d)
 876 {
 877         int retval;
 878
 879         for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 880                 if (ev->num == num) {
 881                         if (d)
 882                                 *d = ((history_t *)h->h_ref)->cursor->data;
 883                         return 0;
 884                 }
 885
 886         he_seterrev(ev, _HE_NOT_FOUND);
 887         return -1;
 888 }
 889
 890
 891 /* history_next_event():
 892  *      Find the next event, with number given
 893  */
 894 private int
 895 history_next_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
 896 {
 897         int retval;
 898
 899         for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
 900                 if (ev->num == num)
 901                         return 0;
 902
 903         he_seterrev(ev, _HE_NOT_FOUND);
 904         return -1;
 905 }
 906
 907
 908 /* history_prev_string():
 909  *      Find the previous event beginning with string
 910  */
 911 private int
 912 history_prev_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
 913 {
 914         size_t len = Strlen(str);
 915         int retval;
 916
 917         for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
 918                 if (Strncmp(str, ev->str, len) == 0)
 919                         return 0;
 920
 921         he_seterrev(ev, _HE_NOT_FOUND);
 922         return -1;
 923 }
 924
 925
 926 /* history_next_string():
 927  *      Find the next event beginning with string
 928  */
 929 private int
 930 history_next_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
 931 {
 932         size_t len = Strlen(str);
 933         int retval;
 934
 935         for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 936                 if (Strncmp(str, ev->str, len) == 0)
 937                         return 0;
 938
 939         he_seterrev(ev, _HE_NOT_FOUND);
 940         return -1;
 941 }
 942
 943
 944 /* history():
 945  *      User interface to history functions.
 946  */
 947 int
 948 FUNW(history)(TYPE(History) *h, TYPE(HistEvent) *ev, int fun, ...)
 949 {
 950         va_list va;
 951         const Char *str;
 952         int retval;
 953
 954         va_start(va, fun);
 955
 956         he_seterrev(ev, _HE_OK);
 957
 958         switch (fun) {
 959         case H_GETSIZE:
 960                 retval = history_getsize(h, ev);
 961                 break;
 962
 963         case H_SETSIZE:
 964                 retval = history_setsize(h, ev, va_arg(va, int));
 965                 break;
 966
 967         case H_GETUNIQUE:
 968                 retval = history_getunique(h, ev);
 969                 break;
 970
 971         case H_SETUNIQUE:
 972                 retval = history_setunique(h, ev, va_arg(va, int));
 973                 break;
 974
 975         case H_ADD:
 976                 str = va_arg(va, const Char *);
 977                 retval = HADD(h, ev, str);
 978                 break;
 979
 980         case H_DEL:
 981                 retval = HDEL(h, ev, va_arg(va, const int));
 982                 break;
 983
 984         case H_ENTER:
 985                 str = va_arg(va, const Char *);
 986                 if ((retval = HENTER(h, ev, str)) != -1)
 987                         h->h_ent = ev->num;
 988                 break;
 989
 990         case H_APPEND:
 991                 str = va_arg(va, const Char *);
 992                 if ((retval = HSET(h, ev, h->h_ent)) != -1)
 993                         retval = HADD(h, ev, str);
 994                 break;
 995
 996         case H_FIRST:
 997                 retval = HFIRST(h, ev);
 998                 break;
 999
1000         case H_NEXT:
1001                 retval = HNEXT(h, ev);
1002                 break;
1003
1004         case H_LAST:
1005                 retval = HLAST(h, ev);
1006                 break;
1007
1008         case H_PREV:
1009                 retval = HPREV(h, ev);
1010                 break;
1011
1012         case H_CURR:
1013                 retval = HCURR(h, ev);
1014                 break;
1015
1016         case H_SET:
1017                 retval = HSET(h, ev, va_arg(va, const int));
1018                 break;
1019
1020         case H_CLEAR:
1021                 HCLEAR(h, ev);
1022                 retval = 0;
1023                 break;
1024
1025         case H_LOAD:
1026                 retval = history_load(h, va_arg(va, const char *));
1027                 if (retval == -1)
1028                         he_seterrev(ev, _HE_HIST_READ);
1029                 break;
1030
1031         case H_SAVE:
1032                 retval = history_save(h, va_arg(va, const char *));
1033                 if (retval == -1)
1034                         he_seterrev(ev, _HE_HIST_WRITE);
1035                 break;
1036
1037         case H_SAVE_FP:
1038                 retval = history_save_fp(h, va_arg(va, FILE *));
1039                 if (retval == -1)
1040                     he_seterrev(ev, _HE_HIST_WRITE);
1041                 break;
1042
1043         case H_PREV_EVENT:
1044                 retval = history_prev_event(h, ev, va_arg(va, int));
1045                 break;
1046
1047         case H_NEXT_EVENT:
1048                 retval = history_next_event(h, ev, va_arg(va, int));
1049                 break;
1050
1051         case H_PREV_STR:
1052                 retval = history_prev_string(h, ev, va_arg(va, const Char *));
1053                 break;
1054
1055         case H_NEXT_STR:
1056                 retval = history_next_string(h, ev, va_arg(va, const Char *));
1057                 break;
1058
1059         case H_FUNC:
1060         {
1061                 TYPE(History) hf;
1062
1063                 hf.h_ref = va_arg(va, void *);
1064                 h->h_ent = -1;
1065                 hf.h_first = va_arg(va, history_gfun_t);
1066                 hf.h_next = va_arg(va, history_gfun_t);
1067                 hf.h_last = va_arg(va, history_gfun_t);
1068                 hf.h_prev = va_arg(va, history_gfun_t);
1069                 hf.h_curr = va_arg(va, history_gfun_t);
1070                 hf.h_set = va_arg(va, history_sfun_t);
1071                 hf.h_clear = va_arg(va, history_vfun_t);
1072                 hf.h_enter = va_arg(va, history_efun_t);
1073                 hf.h_add = va_arg(va, history_efun_t);
1074                 hf.h_del = va_arg(va, history_sfun_t);
1075
1076                 if ((retval = history_set_fun(h, &hf)) == -1)
1077                         he_seterrev(ev, _HE_PARAM_MISSING);
1078                 break;
1079         }
1080
1081         case H_END:
1082                 FUN(history,end)(h);
1083                 retval = 0;
1084                 break;
1085
1086         case H_NEXT_EVDATA:
1087         {
1088                 int num = va_arg(va, int);
1089                 void **d = va_arg(va, void **);
1090                 retval = history_next_evdata(h, ev, num, d);
1091                 break;
1092         }
1093
1094         case H_DELDATA:
1095         {
1096                 int num = va_arg(va, int);
1097                 void **d = va_arg(va, void **);
1098                 retval = history_deldata_nth((history_t *)h->h_ref, ev, num, d);
1099                 break;
1100         }
1101
1102         case H_REPLACE: /* only use after H_NEXT_EVDATA */
1103         {
1104                 const Char *line = va_arg(va, const Char *);
1105                 void *d = va_arg(va, void *);
1106                 const Char *s;
1107                 if(!line || !(s = Strdup(line))) {
1108                         retval = -1;
1109                         break;
1110                 }
1111                 ((history_t *)h->h_ref)->cursor->ev.str = s;
1112                 ((history_t *)h->h_ref)->cursor->data = d;
1113                 retval = 0;
1114                 break;
1115         }
1116
1117         default:
1118                 retval = -1;
1119                 he_seterrev(ev, _HE_UNKNOWN);
1120                 break;
1121         }
1122         va_end(va);
1123         return retval;
1124 }