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#include "config.h"
36#if !defined(lint) && !defined(SCCSID)
37#if 0
38static char sccsid[] = "@(#)history.c	8.1 (Berkeley) 6/4/93";
39#else
40__RCSID("$NetBSD: history.c,v 1.47 2014/05/11 01:05:17 christos Exp $");
41#endif
42#endif /* not lint && not SCCSID */
43#include <sys/cdefs.h>
44__FBSDID("$FreeBSD: releng/11.0/lib/libedit/history.c 296435 2016-03-06 21:32:54Z pfg $");
45
46/*
47 * hist.c: TYPE(History) access functions
48 */
49#include <string.h>
50#include <stdlib.h>
51#include <stdarg.h>
52#include <vis.h>
53#include <sys/stat.h>
54
55static const char hist_cookie[] = "_HiStOrY_V2_\n";
56
57#include "histedit.h"
58#include "chartype.h"
59
60typedef int (*history_gfun_t)(void *, TYPE(HistEvent) *);
61typedef int (*history_efun_t)(void *, TYPE(HistEvent) *, const Char *);
62typedef void (*history_vfun_t)(void *, TYPE(HistEvent) *);
63typedef int (*history_sfun_t)(void *, TYPE(HistEvent) *, const int);
64
65struct TYPE(history) {
66	void *h_ref;		/* Argument for history fcns	 */
67	int h_ent;		/* Last entry point for history	 */
68	history_gfun_t h_first;	/* Get the first element	 */
69	history_gfun_t h_next;	/* Get the next element		 */
70	history_gfun_t h_last;	/* Get the last element		 */
71	history_gfun_t h_prev;	/* Get the previous element	 */
72	history_gfun_t h_curr;	/* Get the current element	 */
73	history_sfun_t h_set;	/* Set the current element	 */
74	history_sfun_t h_del;	/* Set the given element	 */
75	history_vfun_t h_clear;	/* Clear the history list	 */
76	history_efun_t h_enter;	/* Add an element		 */
77	history_efun_t h_add;	/* Append to an element		 */
78};
79
80#define	HNEXT(h, ev)		(*(h)->h_next)((h)->h_ref, ev)
81#define	HFIRST(h, ev)		(*(h)->h_first)((h)->h_ref, ev)
82#define	HPREV(h, ev)		(*(h)->h_prev)((h)->h_ref, ev)
83#define	HLAST(h, ev)		(*(h)->h_last)((h)->h_ref, ev)
84#define	HCURR(h, ev)		(*(h)->h_curr)((h)->h_ref, ev)
85#define	HSET(h, ev, n)		(*(h)->h_set)((h)->h_ref, ev, n)
86#define	HCLEAR(h, ev)		(*(h)->h_clear)((h)->h_ref, ev)
87#define	HENTER(h, ev, str)	(*(h)->h_enter)((h)->h_ref, ev, str)
88#define	HADD(h, ev, str)	(*(h)->h_add)((h)->h_ref, ev, str)
89#define	HDEL(h, ev, n)		(*(h)->h_del)((h)->h_ref, ev, n)
90
91#define	h_strdup(a)	Strdup(a)
92#define	h_malloc(a)	malloc(a)
93#define	h_realloc(a, b)	realloc((a), (b))
94#define	h_free(a)	free(a)
95
96typedef struct {
97    int		num;
98    Char	*str;
99} HistEventPrivate;
100
101
102
103private int history_setsize(TYPE(History) *, TYPE(HistEvent) *, int);
104private int history_getsize(TYPE(History) *, TYPE(HistEvent) *);
105private int history_setunique(TYPE(History) *, TYPE(HistEvent) *, int);
106private int history_getunique(TYPE(History) *, TYPE(HistEvent) *);
107private int history_set_fun(TYPE(History) *, TYPE(History) *);
108private int history_load(TYPE(History) *, const char *);
109private int history_save(TYPE(History) *, const char *);
110private int history_save_fp(TYPE(History) *, FILE *);
111private int history_prev_event(TYPE(History) *, TYPE(HistEvent) *, int);
112private int history_next_event(TYPE(History) *, TYPE(HistEvent) *, int);
113private int history_next_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
114private int history_prev_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
115
116
117/***********************************************************************/
118
119/*
120 * Builtin- history implementation
121 */
122typedef 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
129typedef 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
139private int history_def_next(void *, TYPE(HistEvent) *);
140private int history_def_first(void *, TYPE(HistEvent) *);
141private int history_def_prev(void *, TYPE(HistEvent) *);
142private int history_def_last(void *, TYPE(HistEvent) *);
143private int history_def_curr(void *, TYPE(HistEvent) *);
144private int history_def_set(void *, TYPE(HistEvent) *, const int);
145private void history_def_clear(void *, TYPE(HistEvent) *);
146private int history_def_enter(void *, TYPE(HistEvent) *, const Char *);
147private int history_def_add(void *, TYPE(HistEvent) *, const Char *);
148private int history_def_del(void *, TYPE(HistEvent) *, const int);
149
150private int history_def_init(void **, TYPE(HistEvent) *, int);
151private int history_def_insert(history_t *, TYPE(HistEvent) *, const Char *);
152private void history_def_delete(history_t *, TYPE(HistEvent) *, hentry_t *);
153
154private int history_deldata_nth(history_t *, TYPE(HistEvent) *, int, void **);
155private 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 */
173static 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 */
212private int
213history_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 */
232private int
233history_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 */
252private int
253history_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 */
277private int
278history_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 */
303private int
304history_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 */
324private int
325history_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 */
351private int
352history_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 */
375private int
376history_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
401private int
402history_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 */
423private int
424history_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 */
441private void
442history_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 */
464private int
465history_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;
487oomem:
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 */
496private int
497history_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 */
523private int
524history_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 */
548private void
549history_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 */
568public TYPE(History) *
569FUN(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 */
599public void
600FUN(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 */
615private int
616history_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 */
635private int
636history_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 */
654private int
655history_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 */
670private int
671history_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 */
685private int
686history_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 */
732private int
733history_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	}
782oomem:
783	h_free(ptr);
784done:
785	(void) fclose(fp);
786	return i;
787}
788
789
790/* history_save_fp():
791 *	TYPE(History) save function
792 */
793private int
794history_save_fp(TYPE(History) *h, FILE *fp)
795{
796	TYPE(HistEvent) ev;
797	int i = -1, retval;
798	size_t len, max_size;
799	char *ptr;
800	const char *str;
801#ifdef WIDECHAR
802	static ct_buffer_t conv;
803#endif
804
805	if (fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1)
806		goto done;
807	if (fputs(hist_cookie, fp) == EOF)
808		goto done;
809	ptr = h_malloc((max_size = 1024) * sizeof(*ptr));
810	if (ptr == NULL)
811		goto done;
812	for (i = 0, retval = HLAST(h, &ev);
813	    retval != -1;
814	    retval = HPREV(h, &ev), i++) {
815		str = ct_encode_string(ev.str, &conv);
816		len = strlen(str) * 4;
817		if (len >= max_size) {
818			char *nptr;
819			max_size = (len + 1024) & (size_t)~1023;
820			nptr = h_realloc(ptr, max_size * sizeof(*ptr));
821			if (nptr == NULL) {
822				i = -1;
823				goto oomem;
824			}
825			ptr = nptr;
826		}
827		(void) strvis(ptr, str, VIS_WHITE);
828		(void) fprintf(fp, "%s\n", ptr);
829	}
830oomem:
831	h_free(ptr);
832done:
833	return i;
834}
835
836
837/* history_save():
838 *    History save function
839 */
840private int
841history_save(TYPE(History) *h, const char *fname)
842{
843    FILE *fp;
844    int i;
845
846    if ((fp = fopen(fname, "w")) == NULL)
847	return -1;
848
849    i = history_save_fp(h, fp);
850
851    (void) fclose(fp);
852    return i;
853}
854
855
856/* history_prev_event():
857 *	Find the previous event, with number given
858 */
859private int
860history_prev_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
861{
862	int retval;
863
864	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
865		if (ev->num == num)
866			return 0;
867
868	he_seterrev(ev, _HE_NOT_FOUND);
869	return -1;
870}
871
872
873private int
874history_next_evdata(TYPE(History) *h, TYPE(HistEvent) *ev, int num, void **d)
875{
876	int retval;
877
878	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
879		if (ev->num == num) {
880			if (d)
881				*d = ((history_t *)h->h_ref)->cursor->data;
882			return 0;
883		}
884
885	he_seterrev(ev, _HE_NOT_FOUND);
886	return -1;
887}
888
889
890/* history_next_event():
891 *	Find the next event, with number given
892 */
893private int
894history_next_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
895{
896	int retval;
897
898	for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
899		if (ev->num == num)
900			return 0;
901
902	he_seterrev(ev, _HE_NOT_FOUND);
903	return -1;
904}
905
906
907/* history_prev_string():
908 *	Find the previous event beginning with string
909 */
910private int
911history_prev_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
912{
913	size_t len = Strlen(str);
914	int retval;
915
916	for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
917		if (Strncmp(str, ev->str, len) == 0)
918			return 0;
919
920	he_seterrev(ev, _HE_NOT_FOUND);
921	return -1;
922}
923
924
925/* history_next_string():
926 *	Find the next event beginning with string
927 */
928private int
929history_next_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
930{
931	size_t len = Strlen(str);
932	int retval;
933
934	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
935		if (Strncmp(str, ev->str, len) == 0)
936			return 0;
937
938	he_seterrev(ev, _HE_NOT_FOUND);
939	return -1;
940}
941
942
943/* history():
944 *	User interface to history functions.
945 */
946int
947FUNW(history)(TYPE(History) *h, TYPE(HistEvent) *ev, int fun, ...)
948{
949	va_list va;
950	const Char *str;
951	int retval;
952
953	va_start(va, fun);
954
955	he_seterrev(ev, _HE_OK);
956
957	switch (fun) {
958	case H_GETSIZE:
959		retval = history_getsize(h, ev);
960		break;
961
962	case H_SETSIZE:
963		retval = history_setsize(h, ev, va_arg(va, int));
964		break;
965
966	case H_GETUNIQUE:
967		retval = history_getunique(h, ev);
968		break;
969
970	case H_SETUNIQUE:
971		retval = history_setunique(h, ev, va_arg(va, int));
972		break;
973
974	case H_ADD:
975		str = va_arg(va, const Char *);
976		retval = HADD(h, ev, str);
977		break;
978
979	case H_DEL:
980		retval = HDEL(h, ev, va_arg(va, const int));
981		break;
982
983	case H_ENTER:
984		str = va_arg(va, const Char *);
985		if ((retval = HENTER(h, ev, str)) != -1)
986			h->h_ent = ev->num;
987		break;
988
989	case H_APPEND:
990		str = va_arg(va, const Char *);
991		if ((retval = HSET(h, ev, h->h_ent)) != -1)
992			retval = HADD(h, ev, str);
993		break;
994
995	case H_FIRST:
996		retval = HFIRST(h, ev);
997		break;
998
999	case H_NEXT:
1000		retval = HNEXT(h, ev);
1001		break;
1002
1003	case H_LAST:
1004		retval = HLAST(h, ev);
1005		break;
1006
1007	case H_PREV:
1008		retval = HPREV(h, ev);
1009		break;
1010
1011	case H_CURR:
1012		retval = HCURR(h, ev);
1013		break;
1014
1015	case H_SET:
1016		retval = HSET(h, ev, va_arg(va, const int));
1017		break;
1018
1019	case H_CLEAR:
1020		HCLEAR(h, ev);
1021		retval = 0;
1022		break;
1023
1024	case H_LOAD:
1025		retval = history_load(h, va_arg(va, const char *));
1026		if (retval == -1)
1027			he_seterrev(ev, _HE_HIST_READ);
1028		break;
1029
1030	case H_SAVE:
1031		retval = history_save(h, va_arg(va, const char *));
1032		if (retval == -1)
1033			he_seterrev(ev, _HE_HIST_WRITE);
1034		break;
1035
1036	case H_SAVE_FP:
1037		retval = history_save_fp(h, va_arg(va, FILE *));
1038		if (retval == -1)
1039		    he_seterrev(ev, _HE_HIST_WRITE);
1040		break;
1041
1042	case H_PREV_EVENT:
1043		retval = history_prev_event(h, ev, va_arg(va, int));
1044		break;
1045
1046	case H_NEXT_EVENT:
1047		retval = history_next_event(h, ev, va_arg(va, int));
1048		break;
1049
1050	case H_PREV_STR:
1051		retval = history_prev_string(h, ev, va_arg(va, const Char *));
1052		break;
1053
1054	case H_NEXT_STR:
1055		retval = history_next_string(h, ev, va_arg(va, const Char *));
1056		break;
1057
1058	case H_FUNC:
1059	{
1060		TYPE(History) hf;
1061
1062		hf.h_ref = va_arg(va, void *);
1063		h->h_ent = -1;
1064		hf.h_first = va_arg(va, history_gfun_t);
1065		hf.h_next = va_arg(va, history_gfun_t);
1066		hf.h_last = va_arg(va, history_gfun_t);
1067		hf.h_prev = va_arg(va, history_gfun_t);
1068		hf.h_curr = va_arg(va, history_gfun_t);
1069		hf.h_set = va_arg(va, history_sfun_t);
1070		hf.h_clear = va_arg(va, history_vfun_t);
1071		hf.h_enter = va_arg(va, history_efun_t);
1072		hf.h_add = va_arg(va, history_efun_t);
1073		hf.h_del = va_arg(va, history_sfun_t);
1074
1075		if ((retval = history_set_fun(h, &hf)) == -1)
1076			he_seterrev(ev, _HE_PARAM_MISSING);
1077		break;
1078	}
1079
1080	case H_END:
1081		FUN(history,end)(h);
1082		retval = 0;
1083		break;
1084
1085	case H_NEXT_EVDATA:
1086	{
1087		int num = va_arg(va, int);
1088		void **d = va_arg(va, void **);
1089		retval = history_next_evdata(h, ev, num, d);
1090		break;
1091	}
1092
1093	case H_DELDATA:
1094	{
1095		int num = va_arg(va, int);
1096		void **d = va_arg(va, void **);
1097		retval = history_deldata_nth((history_t *)h->h_ref, ev, num, d);
1098		break;
1099	}
1100
1101	case H_REPLACE: /* only use after H_NEXT_EVDATA */
1102	{
1103		const Char *line = va_arg(va, const Char *);
1104		void *d = va_arg(va, void *);
1105		const Char *s;
1106		if(!line || !(s = Strdup(line))) {
1107			retval = -1;
1108			break;
1109		}
1110		((history_t *)h->h_ref)->cursor->ev.str = s;
1111		((history_t *)h->h_ref)->cursor->data = d;
1112		retval = 0;
1113		break;
1114	}
1115
1116	default:
1117		retval = -1;
1118		he_seterrev(ev, _HE_UNKNOWN);
1119		break;
1120	}
1121	va_end(va);
1122	return retval;
1123}
1124