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