1 /* $NetBSD: history.c,v 1.38 2011/01/16 03:05:51 christos Exp $ */
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
7 * This code is derived from software contributed to Berkeley by
8 * Christos Zoulas of Cornell University.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
39 #if !defined(lint) && !defined(SCCSID)
41 static char sccsid
[] = "@(#)history.c 8.1 (Berkeley) 6/4/93";
43 __RCSID("$NetBSD: history.c,v 1.38 2011/01/16 03:05:51 christos Exp $");
45 #endif /* not lint && not SCCSID */
48 * hist.c: TYPE(History) access functions
56 static const char hist_cookie
[] = "_HiStOrY_V2_\n";
61 typedef int (*history_gfun_t
)(ptr_t
, TYPE(HistEvent
) *);
62 typedef int (*history_efun_t
)(ptr_t
, TYPE(HistEvent
) *, const Char
*);
63 typedef void (*history_vfun_t
)(ptr_t
, TYPE(HistEvent
) *);
64 typedef int (*history_sfun_t
)(ptr_t
, TYPE(HistEvent
) *, const int);
66 struct TYPE(history
) {
67 ptr_t 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 */
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)
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)
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
*);
117 /***********************************************************************/
120 * Builtin- history implementation
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 */
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 */
139 private int history_def_next(ptr_t
, TYPE(HistEvent
) *);
140 private int history_def_first(ptr_t
, TYPE(HistEvent
) *);
141 private int history_def_prev(ptr_t
, TYPE(HistEvent
) *);
142 private int history_def_last(ptr_t
, TYPE(HistEvent
) *);
143 private int history_def_curr(ptr_t
, TYPE(HistEvent
) *);
144 private int history_def_set(ptr_t
, TYPE(HistEvent
) *, const int);
145 private void history_def_clear(ptr_t
, TYPE(HistEvent
) *);
146 private int history_def_enter(ptr_t
, TYPE(HistEvent
) *, const Char
*);
147 private int history_def_add(ptr_t
, TYPE(HistEvent
) *, const Char
*);
148 private int history_def_del(ptr_t
, TYPE(HistEvent
) *, const int);
150 private int history_def_init(ptr_t
*, 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
*);
154 private int history_deldata_nth(history_t
*, TYPE(HistEvent
) *, int, void **);
155 private int history_set_nth(ptr_t
, TYPE(HistEvent
) *, int);
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) \
162 (((history_t *)p)->flags) |= H_UNIQUE; \
164 (((history_t *)p)->flags) &= ~H_UNIQUE
166 #define he_strerror(code) he_errlist[code]
167 #define he_seterrev(evp, code) {\
169 evp->str = he_strerror(code);\
173 static const Char
*const he_errlist
[] = {
175 STR("unknown error"),
176 STR("malloc() failed"),
177 STR("first event not found"),
178 STR("last event not found"),
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")
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
209 /* history_def_first():
210 * Default function to return the first event in the history.
213 history_def_first(ptr_t p
, TYPE(HistEvent
) *ev
)
215 history_t
*h
= (history_t
*) p
;
217 h
->cursor
= h
->list
.next
;
218 if (h
->cursor
!= &h
->list
)
221 he_seterrev(ev
, _HE_FIRST_NOTFOUND
);
229 /* history_def_last():
230 * Default function to return the last event in the history.
233 history_def_last(ptr_t p
, TYPE(HistEvent
) *ev
)
235 history_t
*h
= (history_t
*) p
;
237 h
->cursor
= h
->list
.prev
;
238 if (h
->cursor
!= &h
->list
)
241 he_seterrev(ev
, _HE_LAST_NOTFOUND
);
249 /* history_def_next():
250 * Default function to return the next event in the history.
253 history_def_next(ptr_t p
, TYPE(HistEvent
) *ev
)
255 history_t
*h
= (history_t
*) p
;
257 if (h
->cursor
== &h
->list
) {
258 he_seterrev(ev
, _HE_EMPTY_LIST
);
262 if (h
->cursor
->next
== &h
->list
) {
263 he_seterrev(ev
, _HE_END_REACHED
);
267 h
->cursor
= h
->cursor
->next
;
274 /* history_def_prev():
275 * Default function to return the previous event in the history.
278 history_def_prev(ptr_t p
, TYPE(HistEvent
) *ev
)
280 history_t
*h
= (history_t
*) p
;
282 if (h
->cursor
== &h
->list
) {
284 (h
->cur
> 0) ? _HE_END_REACHED
: _HE_EMPTY_LIST
);
288 if (h
->cursor
->prev
== &h
->list
) {
289 he_seterrev(ev
, _HE_START_REACHED
);
293 h
->cursor
= h
->cursor
->prev
;
300 /* history_def_curr():
301 * Default function to return the current event in the history.
304 history_def_curr(ptr_t p
, TYPE(HistEvent
) *ev
)
306 history_t
*h
= (history_t
*) p
;
308 if (h
->cursor
!= &h
->list
)
312 (h
->cur
> 0) ? _HE_CURR_INVALID
: _HE_EMPTY_LIST
);
320 /* history_def_set():
321 * Default function to set the current event in the history to the
325 history_def_set(ptr_t p
, TYPE(HistEvent
) *ev
, const int n
)
327 history_t
*h
= (history_t
*) p
;
330 he_seterrev(ev
, _HE_EMPTY_LIST
);
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
)
339 if (h
->cursor
== &h
->list
) {
340 he_seterrev(ev
, _HE_NOT_FOUND
);
347 /* history_set_nth():
348 * Default function to set the current event in the history to the
352 history_set_nth(ptr_t p
, TYPE(HistEvent
) *ev
, int n
)
354 history_t
*h
= (history_t
*) p
;
357 he_seterrev(ev
, _HE_EMPTY_LIST
);
360 for (h
->cursor
= h
->list
.prev
; h
->cursor
!= &h
->list
;
361 h
->cursor
= h
->cursor
->prev
)
364 if (h
->cursor
== &h
->list
) {
365 he_seterrev(ev
, _HE_NOT_FOUND
);
372 /* history_def_add():
373 * Append string to element
376 history_def_add(ptr_t p
, TYPE(HistEvent
) *ev
, const Char
*str
)
378 history_t
*h
= (history_t
*) p
;
381 HistEventPrivate
*evp
= (void *)&h
->cursor
->ev
;
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
));
388 he_seterrev(ev
, _HE_MALLOC_FAILED
);
391 (void) Strncpy(s
, h
->cursor
->ev
.str
, len
);
393 (void) Strncat(s
, str
, len
- Strlen(s
) - 1);
394 h_free((ptr_t
)evp
->str
);
402 history_deldata_nth(history_t
*h
, TYPE(HistEvent
) *ev
,
403 int num
, void **data
)
405 if (history_set_nth(h
, ev
, num
) != 0)
407 /* magic value to skip delete (just set to n-th history) */
408 if (data
== (void **)-1)
410 ev
->str
= Strdup(h
->cursor
->ev
.str
);
411 ev
->num
= h
->cursor
->ev
.num
;
413 *data
= h
->cursor
->data
;
414 history_def_delete(h
, ev
, h
->cursor
);
419 /* history_def_del():
420 * Delete element hp of the h list
424 history_def_del(ptr_t p
, TYPE(HistEvent
) *ev
__attribute__((__unused__
)),
427 history_t
*h
= (history_t
*) p
;
428 if (history_def_set(h
, ev
, num
) != 0)
430 ev
->str
= Strdup(h
->cursor
->ev
.str
);
431 ev
->num
= h
->cursor
->ev
.num
;
432 history_def_delete(h
, ev
, h
->cursor
);
437 /* history_def_delete():
438 * Delete element hp of the h list
442 history_def_delete(history_t
*h
,
443 TYPE(HistEvent
) *ev
__attribute__((__unused__
)), hentry_t
*hp
)
445 HistEventPrivate
*evp
= (void *)&hp
->ev
;
448 if (h
->cursor
== hp
) {
449 h
->cursor
= hp
->prev
;
450 if (h
->cursor
== &h
->list
)
451 h
->cursor
= hp
->next
;
453 hp
->prev
->next
= hp
->next
;
454 hp
->next
->prev
= hp
->prev
;
455 h_free((ptr_t
) evp
->str
);
461 /* history_def_insert():
462 * Insert element with string str in the h list
465 history_def_insert(history_t
*h
, TYPE(HistEvent
) *ev
, const Char
*str
)
468 h
->cursor
= (hentry_t
*) h_malloc(sizeof(hentry_t
));
469 if (h
->cursor
== NULL
)
471 if ((h
->cursor
->ev
.str
= h_strdup(str
)) == NULL
) {
472 h_free((ptr_t
)h
->cursor
);
475 h
->cursor
->data
= NULL
;
476 h
->cursor
->ev
.num
= ++h
->eventid
;
477 h
->cursor
->next
= h
->list
.next
;
478 h
->cursor
->prev
= &h
->list
;
479 h
->list
.next
->prev
= h
->cursor
;
480 h
->list
.next
= h
->cursor
;
486 he_seterrev(ev
, _HE_MALLOC_FAILED
);
491 /* history_def_enter():
492 * Default function to enter an item in the history
495 history_def_enter(ptr_t p
, TYPE(HistEvent
) *ev
, const Char
*str
)
497 history_t
*h
= (history_t
*) p
;
499 if ((h
->flags
& H_UNIQUE
) != 0 && h
->list
.next
!= &h
->list
&&
500 Strcmp(h
->list
.next
->ev
.str
, str
) == 0)
503 if (history_def_insert(h
, ev
, str
) == -1)
504 return (-1); /* error, keep error message */
507 * Always keep at least one entry.
508 * This way we don't have to check for the empty list.
510 while (h
->cur
> h
->max
&& h
->cur
> 0)
511 history_def_delete(h
, ev
, h
->list
.prev
);
517 /* history_def_init():
518 * Default history initialization function
522 history_def_init(ptr_t
*p
, TYPE(HistEvent
) *ev
__attribute__((__unused__
)), int n
)
524 history_t
*h
= (history_t
*) h_malloc(sizeof(history_t
));
533 h
->list
.next
= h
->list
.prev
= &h
->list
;
534 h
->list
.ev
.str
= NULL
;
536 h
->cursor
= &h
->list
;
543 /* history_def_clear():
544 * Default history cleanup function
547 history_def_clear(ptr_t p
, TYPE(HistEvent
) *ev
)
549 history_t
*h
= (history_t
*) p
;
551 while (h
->list
.prev
!= &h
->list
)
552 history_def_delete(h
, ev
, h
->list
.prev
);
560 /************************************************************************/
563 * Initialization function.
565 public TYPE(History
) *
566 FUN(history
,init
)(void)
569 TYPE(History
) *h
= (TYPE(History
) *) h_malloc(sizeof(TYPE(History
)));
573 if (history_def_init(&h
->h_ref
, &ev
, 0) == -1) {
578 h
->h_next
= history_def_next
;
579 h
->h_first
= history_def_first
;
580 h
->h_last
= history_def_last
;
581 h
->h_prev
= history_def_prev
;
582 h
->h_curr
= history_def_curr
;
583 h
->h_set
= history_def_set
;
584 h
->h_clear
= history_def_clear
;
585 h
->h_enter
= history_def_enter
;
586 h
->h_add
= history_def_add
;
587 h
->h_del
= history_def_del
;
597 FUN(history
,end
)(TYPE(History
) *h
)
601 if (h
->h_next
== history_def_next
)
602 history_def_clear(h
->h_ref
, &ev
);
609 /* history_setsize():
610 * Set history number of events
613 history_setsize(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int num
)
616 if (h
->h_next
!= history_def_next
) {
617 he_seterrev(ev
, _HE_NOT_ALLOWED
);
621 he_seterrev(ev
, _HE_BAD_PARAM
);
624 history_def_setsize(h
->h_ref
, num
);
629 /* history_getsize():
630 * Get number of events currently in history
633 history_getsize(TYPE(History
) *h
, TYPE(HistEvent
) *ev
)
635 if (h
->h_next
!= history_def_next
) {
636 he_seterrev(ev
, _HE_NOT_ALLOWED
);
639 ev
->num
= history_def_getsize(h
->h_ref
);
641 he_seterrev(ev
, _HE_SIZE_NEGATIVE
);
648 /* history_setunique():
649 * Set if adjacent equal events should not be entered in history.
652 history_setunique(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int uni
)
655 if (h
->h_next
!= history_def_next
) {
656 he_seterrev(ev
, _HE_NOT_ALLOWED
);
659 history_def_setunique(h
->h_ref
, uni
);
664 /* history_getunique():
665 * Get if adjacent equal events should not be entered in history.
668 history_getunique(TYPE(History
) *h
, TYPE(HistEvent
) *ev
)
670 if (h
->h_next
!= history_def_next
) {
671 he_seterrev(ev
, _HE_NOT_ALLOWED
);
674 ev
->num
= history_def_getunique(h
->h_ref
);
679 /* history_set_fun():
680 * Set history functions
683 history_set_fun(TYPE(History
) *h
, TYPE(History
) *nh
)
687 if (nh
->h_first
== NULL
|| nh
->h_next
== NULL
|| nh
->h_last
== NULL
||
688 nh
->h_prev
== NULL
|| nh
->h_curr
== NULL
|| nh
->h_set
== NULL
||
689 nh
->h_enter
== NULL
|| nh
->h_add
== NULL
|| nh
->h_clear
== NULL
||
690 nh
->h_del
== NULL
|| nh
->h_ref
== NULL
) {
691 if (h
->h_next
!= history_def_next
) {
692 history_def_init(&h
->h_ref
, &ev
, 0);
693 h
->h_first
= history_def_first
;
694 h
->h_next
= history_def_next
;
695 h
->h_last
= history_def_last
;
696 h
->h_prev
= history_def_prev
;
697 h
->h_curr
= history_def_curr
;
698 h
->h_set
= history_def_set
;
699 h
->h_clear
= history_def_clear
;
700 h
->h_enter
= history_def_enter
;
701 h
->h_add
= history_def_add
;
702 h
->h_del
= history_def_del
;
706 if (h
->h_next
== history_def_next
)
707 history_def_clear(h
->h_ref
, &ev
);
710 h
->h_first
= nh
->h_first
;
711 h
->h_next
= nh
->h_next
;
712 h
->h_last
= nh
->h_last
;
713 h
->h_prev
= nh
->h_prev
;
714 h
->h_curr
= nh
->h_curr
;
715 h
->h_set
= nh
->h_set
;
716 h
->h_clear
= nh
->h_clear
;
717 h
->h_enter
= nh
->h_enter
;
718 h
->h_add
= nh
->h_add
;
719 h
->h_del
= nh
->h_del
;
726 * TYPE(History) load function
729 history_load(TYPE(History
) *h
, const char *fname
)
738 static ct_buffer_t conv
;
741 if ((fp
= fopen(fname
, "r")) == NULL
)
744 if ((line
= fgetln(fp
, &sz
)) == NULL
)
747 if (strncmp(line
, hist_cookie
, sz
) != 0)
750 ptr
= h_malloc(max_size
= 1024);
753 for (i
= 0; (line
= fgetln(fp
, &sz
)) != NULL
; i
++) {
756 if (sz
!= 0 && line
[sz
- 1] == '\n')
763 max_size
= (sz
+ 1024) & ~1023;
764 nptr
= h_realloc(ptr
, max_size
);
771 (void) strunvis(ptr
, line
);
773 if (HENTER(h
, &ev
, ct_decode_string(ptr
, &conv
)) == -1) {
787 * TYPE(History) save function
790 history_save(TYPE(History
) *h
, const char *fname
)
795 size_t len
, max_size
;
798 static ct_buffer_t conv
;
801 if ((fp
= fopen(fname
, "w")) == NULL
)
804 if (fchmod(fileno(fp
), S_IRUSR
|S_IWUSR
) == -1)
806 if (fputs(hist_cookie
, fp
) == EOF
)
808 ptr
= h_malloc(max_size
= 1024);
811 for (i
= 0, retval
= HLAST(h
, &ev
);
813 retval
= HPREV(h
, &ev
), i
++) {
814 len
= Strlen(ev
.str
) * 4;
815 if (len
>= max_size
) {
817 max_size
= (len
+ 1024) & ~1023;
818 nptr
= h_realloc(ptr
, max_size
);
825 (void) strvis(ptr
, ct_encode_string(ev
.str
, &conv
), VIS_WHITE
);
826 (void) fprintf(fp
, "%s\n", ptr
);
836 /* history_prev_event():
837 * Find the previous event, with number given
840 history_prev_event(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int num
)
844 for (retval
= HCURR(h
, ev
); retval
!= -1; retval
= HPREV(h
, ev
))
848 he_seterrev(ev
, _HE_NOT_FOUND
);
854 history_next_evdata(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int num
, void **d
)
858 for (retval
= HCURR(h
, ev
); retval
!= -1; retval
= HPREV(h
, ev
))
859 if (ev
->num
== num
) {
861 *d
= ((history_t
*)h
->h_ref
)->cursor
->data
;
865 he_seterrev(ev
, _HE_NOT_FOUND
);
870 /* history_next_event():
871 * Find the next event, with number given
874 history_next_event(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int num
)
878 for (retval
= HCURR(h
, ev
); retval
!= -1; retval
= HNEXT(h
, ev
))
882 he_seterrev(ev
, _HE_NOT_FOUND
);
887 /* history_prev_string():
888 * Find the previous event beginning with string
891 history_prev_string(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, const Char
*str
)
893 size_t len
= Strlen(str
);
896 for (retval
= HCURR(h
, ev
); retval
!= -1; retval
= HNEXT(h
, ev
))
897 if (Strncmp(str
, ev
->str
, len
) == 0)
900 he_seterrev(ev
, _HE_NOT_FOUND
);
905 /* history_next_string():
906 * Find the next event beginning with string
909 history_next_string(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, const Char
*str
)
911 size_t len
= Strlen(str
);
914 for (retval
= HCURR(h
, ev
); retval
!= -1; retval
= HPREV(h
, ev
))
915 if (Strncmp(str
, ev
->str
, len
) == 0)
918 he_seterrev(ev
, _HE_NOT_FOUND
);
924 * User interface to history functions.
927 FUNW(history
)(TYPE(History
) *h
, TYPE(HistEvent
) *ev
, int fun
, ...)
935 he_seterrev(ev
, _HE_OK
);
939 retval
= history_getsize(h
, ev
);
943 retval
= history_setsize(h
, ev
, va_arg(va
, int));
947 retval
= history_getunique(h
, ev
);
951 retval
= history_setunique(h
, ev
, va_arg(va
, int));
955 str
= va_arg(va
, const Char
*);
956 retval
= HADD(h
, ev
, str
);
960 retval
= HDEL(h
, ev
, va_arg(va
, const int));
964 str
= va_arg(va
, const Char
*);
965 if ((retval
= HENTER(h
, ev
, str
)) != -1)
970 str
= va_arg(va
, const Char
*);
971 if ((retval
= HSET(h
, ev
, h
->h_ent
)) != -1)
972 retval
= HADD(h
, ev
, str
);
976 retval
= HFIRST(h
, ev
);
980 retval
= HNEXT(h
, ev
);
984 retval
= HLAST(h
, ev
);
988 retval
= HPREV(h
, ev
);
992 retval
= HCURR(h
, ev
);
996 retval
= HSET(h
, ev
, va_arg(va
, const int));
1005 retval
= history_load(h
, va_arg(va
, const char *));
1007 he_seterrev(ev
, _HE_HIST_READ
);
1011 retval
= history_save(h
, va_arg(va
, const char *));
1013 he_seterrev(ev
, _HE_HIST_WRITE
);
1017 retval
= history_prev_event(h
, ev
, va_arg(va
, int));
1021 retval
= history_next_event(h
, ev
, va_arg(va
, int));
1025 retval
= history_prev_string(h
, ev
, va_arg(va
, const Char
*));
1029 retval
= history_next_string(h
, ev
, va_arg(va
, const Char
*));
1036 hf
.h_ref
= va_arg(va
, ptr_t
);
1038 hf
.h_first
= va_arg(va
, history_gfun_t
);
1039 hf
.h_next
= va_arg(va
, history_gfun_t
);
1040 hf
.h_last
= va_arg(va
, history_gfun_t
);
1041 hf
.h_prev
= va_arg(va
, history_gfun_t
);
1042 hf
.h_curr
= va_arg(va
, history_gfun_t
);
1043 hf
.h_set
= va_arg(va
, history_sfun_t
);
1044 hf
.h_clear
= va_arg(va
, history_vfun_t
);
1045 hf
.h_enter
= va_arg(va
, history_efun_t
);
1046 hf
.h_add
= va_arg(va
, history_efun_t
);
1047 hf
.h_del
= va_arg(va
, history_sfun_t
);
1049 if ((retval
= history_set_fun(h
, &hf
)) == -1)
1050 he_seterrev(ev
, _HE_PARAM_MISSING
);
1055 FUN(history
,end
)(h
);
1061 int num
= va_arg(va
, int);
1062 void **d
= va_arg(va
, void **);
1063 retval
= history_next_evdata(h
, ev
, num
, d
);
1069 int num
= va_arg(va
, int);
1070 void **d
= va_arg(va
, void **);
1071 retval
= history_deldata_nth((history_t
*)h
->h_ref
, ev
, num
, d
);
1075 case H_REPLACE
: /* only use after H_NEXT_EVDATA */
1077 const Char
*line
= va_arg(va
, const Char
*);
1078 void *d
= va_arg(va
, void *);
1080 if(!line
|| !(s
= Strdup(line
))) {
1084 ((history_t
*)h
->h_ref
)->cursor
->ev
.str
= s
;
1085 ((history_t
*)h
->h_ref
)->cursor
->data
= d
;
1092 he_seterrev(ev
, _HE_UNKNOWN
);