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