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