contrib/libedit/history.c

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