lib/libedit/history.c

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