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
41static 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
56static const char hist_cookie[] = "_HiStOrY_V2_\n";
57
58#include "histedit.h"
59#include "chartype.h"
60
61typedef int (*history_gfun_t)(void *, TYPE(HistEvent) *);
62typedef int (*history_efun_t)(void *, TYPE(HistEvent) *, const Char *);
63typedef void (*history_vfun_t)(void *, TYPE(HistEvent) *);
64typedef int (*history_sfun_t)(void *, TYPE(HistEvent) *, const int);
65
66struct 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
97typedef struct {
98    int		num;
99    Char	*str;
100} HistEventPrivate;
101
102
103
104private int history_setsize(TYPE(History) *, TYPE(HistEvent) *, int);
105private int history_getsize(TYPE(History) *, TYPE(HistEvent) *);
106private int history_setunique(TYPE(History) *, TYPE(HistEvent) *, int);
107private int history_getunique(TYPE(History) *, TYPE(HistEvent) *);
108private int history_set_fun(TYPE(History) *, TYPE(History) *);
109private int history_load(TYPE(History) *, const char *);
110private int history_save(TYPE(History) *, const char *);
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():
791 *	TYPE(History) save function
792 */
793private int
794history_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	}
834oomem:
835	h_free(ptr);
836done:
837	(void) fclose(fp);
838	return i;
839}
840
841
842/* history_prev_event():
843 *	Find the previous event, with number given
844 */
845private int
846history_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
859private int
860history_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 */
879private int
880history_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 */
896private int
897history_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 */
914private int
915history_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 */
932int
933FUNW(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