/usr/src/lib/libedit/history.c

Bug Summary

File:	src/lib/libedit/history.c
Warning:	line 582, column 3 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name history.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libedit/obj -resource-dir /usr/local/lib/clang/13.0.0 -I . -I /usr/src/lib/libedit -I . -I /usr/src/lib/libedit -D PIC -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libedit/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libedit/history.c
1/*	$OpenBSD: history.c,v 1.28 2016/04/11 21:17:29 schwarze Exp $	*/
2/*	$NetBSD: history.c,v 1.37 2010/01/03 18:27:10 christos Exp $	*/

4/*-
* Copyright (c) 1992, 1993
*	The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Christos Zoulas of Cornell University.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

36#include "config.h"

38/*
* hist.c: TYPE(History) access functions
*/
41#include <sys/stat.h>
42#include <stdarg.h>
43#include <stdlib.h>
44#include <string.h>
45#ifdef HAVE_VIS_H1
46#include <vis.h>
47#else
48#include "np/vis.h"
49#endif

51static const char hist_cookie[] = "_HiStOrY_V2_\n";

53#include "histedit.h"


56#ifdef NARROWCHAR

58#define	Charwchar_t			char
59#define	FUN(prefix, rest)prefix_wrest	prefix ## _ ## rest
60#define	FUNW(type)type_w		type
61#define	TYPE(type)typeW		type
62#define	STR(x)Lx			x

64#define	Strlen(s)wcslen(s)		strlen(s)
65#define	Strdup(s)wcsdup(s)		strdup(s)
66#define	Strcmp(d, s)wcscmp(d, s)		strcmp(d, s)
67#define	Strncmp(d, s, n)wcsncmp(d, s, n)	strncmp(d, s, n)
68#define	Strncpy(d, s, n)wcsncpy(d, s, n)	strncpy(d, s, n)
69#define	Strncat(d, s, n)wcsncat(d, s, n)	strncat(d, s, n)
70#define	ct_decode_string(s, b)	(s)
71#define	ct_encode_string(s, b)	(s)

73#else
74#include "chartype.h"

76#define	Charwchar_t			wchar_t
77#define	FUN(prefix, rest)prefix_wrest	prefix ## _w ## rest
78#define	FUNW(type)type_w		type ## _w
79#define	TYPE(type)typeW		type ## W
80#define	STR(x)Lx			L ## x

82#define	Strlen(s)wcslen(s)		wcslen(s)
83#define	Strdup(s)wcsdup(s)		wcsdup(s)
84#define	Strcmp(d, s)wcscmp(d, s)		wcscmp(d, s)
85#define	Strncmp(d, s, n)wcsncmp(d, s, n)	wcsncmp(d, s, n)
86#define	Strncpy(d, s, n)wcsncpy(d, s, n)	wcsncpy(d, s, n)
87#define	Strncat(d, s, n)wcsncat(d, s, n)	wcsncat(d, s, n)

89#endif


92typedef int (*history_gfun_t)(void *, TYPE(HistEvent)HistEventW *);
93typedef int (*history_efun_t)(void *, TYPE(HistEvent)HistEventW *, const Charwchar_t *);
94typedef void (*history_vfun_t)(void *, TYPE(HistEvent)HistEventW *);
95typedef int (*history_sfun_t)(void *, TYPE(HistEvent)HistEventW *, const int);

97struct TYPE(history)historyW {
void *h_ref;		/* Argument for history fcns	 */
int h_ent;		/* Last entry point for history	 */
history_gfun_t h_first;	/* Get the first element	 */
history_gfun_t h_next;	/* Get the next element		 */
history_gfun_t h_last;	/* Get the last element		 */
history_gfun_t h_prev;	/* Get the previous element	 */
history_gfun_t h_curr;	/* Get the current element	 */
history_sfun_t h_set;	/* Set the current element	 */
history_sfun_t h_del;	/* Set the given element	 */
history_vfun_t h_clear;	/* Clear the history list	 */
history_efun_t h_enter;	/* Add an element		 */
history_efun_t h_add;	/* Append to an element		 */
110};

112#define	HNEXT(h, ev)(*(h)->h_next)((h)->h_ref, ev)		(*(h)->h_next)((h)->h_ref, ev)
113#define	HFIRST(h, ev)(*(h)->h_first)((h)->h_ref, ev)		(*(h)->h_first)((h)->h_ref, ev)
114#define	HPREV(h, ev)(*(h)->h_prev)((h)->h_ref, ev)		(*(h)->h_prev)((h)->h_ref, ev)
115#define	HLAST(h, ev)(*(h)->h_last)((h)->h_ref, ev)		(*(h)->h_last)((h)->h_ref, ev)
116#define	HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev)		(*(h)->h_curr)((h)->h_ref, ev)
117#define	HSET(h, ev, n)(*(h)->h_set)((h)->h_ref, ev, n)		(*(h)->h_set)((h)->h_ref, ev, n)
118#define	HCLEAR(h, ev)(*(h)->h_clear)((h)->h_ref, ev)		(*(h)->h_clear)((h)->h_ref, ev)
119#define	HENTER(h, ev, str)(*(h)->h_enter)((h)->h_ref, ev, str)	(*(h)->h_enter)((h)->h_ref, ev, str)
120#define	HADD(h, ev, str)(*(h)->h_add)((h)->h_ref, ev, str)	(*(h)->h_add)((h)->h_ref, ev, str)
121#define	HDEL(h, ev, n)(*(h)->h_del)((h)->h_ref, ev, n)		(*(h)->h_del)((h)->h_ref, ev, n)

123#define	h_strdup(a)wcsdup(a)	Strdup(a)wcsdup(a)

125typedef struct {
  int		num;
  Charwchar_t	*str;
128} HistEventPrivate;


131static int history_setsize(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *, int);
132static int history_getsize(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *);
133static int history_setunique(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *, int);
134static int history_getunique(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *);
135static int history_set_fun(TYPE(History)HistoryW *, TYPE(History)HistoryW *);
136static int history_load(TYPE(History)HistoryW *, const char *);
137static int history_save(TYPE(History)HistoryW *, const char *);
138static int history_save_fp(TYPE(History)HistoryW *, FILE *);
139static int history_prev_event(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *, int);
140static int history_next_event(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *, int);
141static int history_next_string(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *,
  const Charwchar_t *);
143static int history_prev_string(TYPE(History)HistoryW *, TYPE(HistEvent)HistEventW *,
  const Charwchar_t *);


147/***********************************************************************/

149/*
* Builtin- history implementation
*/
152typedef struct hentry_t {
TYPE(HistEvent)HistEventW ev;		/* What we return		 */
void *data;		/* data				 */
struct hentry_t *next;	/* Next entry			 */
struct hentry_t *prev;	/* Previous entry		 */
157} hentry_t;

159typedef struct history_t {
hentry_t list;		/* Fake list header element	*/
hentry_t *cursor;	/* Current element in the list	*/
int max;		/* Maximum number of events	*/
int cur;		/* Current number of events	*/
int eventid;		/* For generation of unique event id	 */
int flags;		/* TYPE(History) flags		*/
166#define H_UNIQUE1	1	/* Store only unique elements	*/
167} history_t;

169static int history_def_next(void *, TYPE(HistEvent)HistEventW *);
170static int history_def_first(void *, TYPE(HistEvent)HistEventW *);
171static int history_def_prev(void *, TYPE(HistEvent)HistEventW *);
172static int history_def_last(void *, TYPE(HistEvent)HistEventW *);
173static int history_def_curr(void *, TYPE(HistEvent)HistEventW *);
174static int history_def_set(void *, TYPE(HistEvent)HistEventW *, const int);
175static void history_def_clear(void *, TYPE(HistEvent)HistEventW *);
176static int history_def_enter(void *, TYPE(HistEvent)HistEventW *, const Charwchar_t *);
177static int history_def_add(void *, TYPE(HistEvent)HistEventW *, const Charwchar_t *);
178static int history_def_del(void *, TYPE(HistEvent)HistEventW *, const int);

180static int history_def_init(void **, TYPE(HistEvent)HistEventW *, int);
181static int history_def_insert(history_t *, TYPE(HistEvent)HistEventW *, const Charwchar_t *);
182static void history_def_delete(history_t *, TYPE(HistEvent)HistEventW *, hentry_t *);

184static int history_deldata_nth(history_t *, TYPE(HistEvent)HistEventW *, int, void **);
185static int history_set_nth(void *, TYPE(HistEvent)HistEventW *, int);

187#define	history_def_setsize(p, num)(void) (((history_t *)p)->max = (num))(void) (((history_t *)p)->max = (num))
188#define	history_def_getsize(p)(((history_t *)p)->cur)  (((history_t *)p)->cur)
189#define	history_def_getunique(p)(((((history_t *)p)->flags) & 1) != 0) (((((history_t *)p)->flags) & H_UNIQUE1) != 0)
190#define	history_def_setunique(p, uni)if (uni) (((history_t *)p)->flags) |= 1; else (((history_t
 *)p)->flags) &= ~1 \
  if (uni) \
(((history_t *)p)->flags) |= H_UNIQUE1; \
  else \
(((history_t *)p)->flags) &= ~H_UNIQUE1

196#define	he_strerror(code)he_errlist[code]	he_errlist[code]
197#define	he_seterrev(evp, code){ evp->num = code; evp->str = he_errlist[code]; }	{\
		    evp->num = code;\
		    evp->str = he_strerror(code)he_errlist[code];\
		}

202/* error messages */
203static const Charwchar_t *const he_errlist[] = {
STR("OK")L"OK",
STR("unknown error")L"unknown error",
STR("malloc() failed")L"malloc() failed",
STR("first event not found")L"first event not found",
STR("last event not found")L"last event not found",
STR("empty list")L"empty list",
STR("no next event")L"no next event",
STR("no previous event")L"no previous event",
STR("current event is invalid")L"current event is invalid",
STR("event not found")L"event not found",
STR("can't read history from file")L"can't read history from file",
STR("can't write history")L"can't write history",
STR("required parameter(s) not supplied")L"required parameter(s) not supplied",
STR("history size negative")L"history size negative",
STR("function not allowed with other history-functions-set the default")L"function not allowed with other history-functions-set the default",
STR("bad parameters")L"bad parameters"
220};
221/* error codes */
222#define	_HE_OK0                   0
223#define	_HE_UNKNOWN1		 1
224#define	_HE_MALLOC_FAILED2        2
225#define	_HE_FIRST_NOTFOUND3       3
226#define	_HE_LAST_NOTFOUND4        4
227#define	_HE_EMPTY_LIST5           5
228#define	_HE_END_REACHED6          6
229#define	_HE_START_REACHED7	 7
230#define	_HE_CURR_INVALID8	 8
231#define	_HE_NOT_FOUND9		 9
232#define	_HE_HIST_READ10		10
233#define	_HE_HIST_WRITE11		11
234#define	_HE_PARAM_MISSING12	12
235#define	_HE_SIZE_NEGATIVE13	13
236#define	_HE_NOT_ALLOWED14		14
237#define	_HE_BAD_PARAM15		15

239/* history_def_first():
*	Default function to return the first event in the history.
*/
242static int
243history_def_first(void *p, TYPE(HistEvent)HistEventW *ev)
244{
history_t *h = (history_t *) p;

h->cursor = h->list.next;
if (h->cursor != &h->list)
*ev = h->cursor->ev;
else {
he_seterrev(ev, _HE_FIRST_NOTFOUND){ ev->num = 3; ev->str = he_errlist[3]; };
return -1;
}

return 0;
256}


259/* history_def_last():
*	Default function to return the last event in the history.
*/
262static int
263history_def_last(void *p, TYPE(HistEvent)HistEventW *ev)
264{
history_t *h = (history_t *) p;

h->cursor = h->list.prev;
if (h->cursor != &h->list)
*ev = h->cursor->ev;
else {
he_seterrev(ev, _HE_LAST_NOTFOUND){ ev->num = 4; ev->str = he_errlist[4]; };
return -1;
}

return 0;
276}


279/* history_def_next():
*	Default function to return the next event in the history.
*/
282static int
283history_def_next(void *p, TYPE(HistEvent)HistEventW *ev)
284{
history_t *h = (history_t *) p;

if (h->cursor == &h->list) {
he_seterrev(ev, _HE_EMPTY_LIST){ ev->num = 5; ev->str = he_errlist[5]; };
return -1;
}

if (h->cursor->next == &h->list) {
he_seterrev(ev, _HE_END_REACHED){ ev->num = 6; ev->str = he_errlist[6]; };
return -1;
}

      h->cursor = h->cursor->next;
      *ev = h->cursor->ev;

return 0;
301}


304/* history_def_prev():
*	Default function to return the previous event in the history.
*/
307static int
308history_def_prev(void *p, TYPE(HistEvent)HistEventW *ev)
309{
history_t *h = (history_t *) p;

if (h->cursor == &h->list) {
he_seterrev(ev,{ ev->num = (h->cur > 0) ? 6 : 5; ev->str = he_errlist
[(h->cur > 0) ? 6 : 5]; }
    (h->cur > 0) ? _HE_END_REACHED : _HE_EMPTY_LIST){ ev->num = (h->cur > 0) ? 6 : 5; ev->str = he_errlist
[(h->cur > 0) ? 6 : 5]; };
return -1;
}

if (h->cursor->prev == &h->list) {
he_seterrev(ev, _HE_START_REACHED){ ev->num = 7; ev->str = he_errlist[7]; };
return -1;
}

      h->cursor = h->cursor->prev;
      *ev = h->cursor->ev;

return 0;
327}


330/* history_def_curr():
*	Default function to return the current event in the history.
*/
333static int
334history_def_curr(void *p, TYPE(HistEvent)HistEventW *ev)
335{
history_t *h = (history_t *) p;

if (h->cursor != &h->list)
*ev = h->cursor->ev;
else {
he_seterrev(ev,{ ev->num = (h->cur > 0) ? 8 : 5; ev->str = he_errlist
[(h->cur > 0) ? 8 : 5]; }
    (h->cur > 0) ? _HE_CURR_INVALID : _HE_EMPTY_LIST){ ev->num = (h->cur > 0) ? 8 : 5; ev->str = he_errlist
[(h->cur > 0) ? 8 : 5]; };
return -1;
}

return 0;
347}


350/* history_def_set():
*	Default function to set the current event in the history to the
*	given one.
*/
354static int
355history_def_set(void *p, TYPE(HistEvent)HistEventW *ev, const int n)
356{
history_t *h = (history_t *) p;

if (h->cur == 0) {
he_seterrev(ev, _HE_EMPTY_LIST){ ev->num = 5; ev->str = he_errlist[5]; };
return -1;
}
if (h->cursor == &h->list || h->cursor->ev.num != n) {
for (h->cursor = h->list.next; h->cursor != &h->list;
    h->cursor = h->cursor->next)
	if (h->cursor->ev.num == n)
		break;
}
if (h->cursor == &h->list) {
he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
}
return 0;
374}


377/* history_set_nth():
*	Default function to set the current event in the history to the
*	n-th one.
*/
381static int
382history_set_nth(void *p, TYPE(HistEvent)HistEventW *ev, int n)
383{
history_t *h = (history_t *) p;

if (h->cur == 0) {
he_seterrev(ev, _HE_EMPTY_LIST){ ev->num = 5; ev->str = he_errlist[5]; };
return -1;
}
for (h->cursor = h->list.prev; h->cursor != &h->list;
   h->cursor = h->cursor->prev)
if (n-- <= 0)
	break;
if (h->cursor == &h->list) {
he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
}
return 0;
399}


402/* history_def_add():
*	Append string to element
*/
405static int
406history_def_add(void *p, TYPE(HistEvent)HistEventW *ev, const Charwchar_t *str)
407{
history_t *h = (history_t *) p;
size_t len;
Charwchar_t *s;
HistEventPrivate *evp = (void *)&h->cursor->ev;

if (h->cursor == &h->list)
return history_def_enter(p, ev, str);
len = Strlen(evp->str)wcslen(evp->str) + Strlen(str)wcslen(str) + 1;
s = reallocarray(NULL((void *)0), len, sizeof(*s));
if (s == NULL((void *)0)) {
he_seterrev(ev, _HE_MALLOC_FAILED){ ev->num = 2; ev->str = he_errlist[2]; };
return -1;
}
(void) Strncpy(s, h->cursor->ev.str, len)wcsncpy(s, h->cursor->ev.str, len);
      s[len - 1] = '\0';
(void) Strncat(s, str, len - Strlen(s) - 1)wcsncat(s, str, len - wcslen(s) - 1);
free(evp->str);
evp->str = s;
*ev = h->cursor->ev;
return 0;
428}


431static int
432history_deldata_nth(history_t *h, TYPE(HistEvent)HistEventW *ev,
  int num, void **data)
434{
if (history_set_nth(h, ev, num) != 0)
return -1;
/* magic value to skip delete (just set to n-th history) */
if (data == (void **)-1)
return 0;
ev->str = Strdup(h->cursor->ev.str)wcsdup(h->cursor->ev.str);
ev->num = h->cursor->ev.num;
if (data)
*data = h->cursor->data;
history_def_delete(h, ev, h->cursor);
return 0;
446}


449/* history_def_del():
*	Delete element hp of the h list
*/
452/* ARGSUSED */
453static int
454history_def_del(void *p, TYPE(HistEvent)HistEventW *ev __attribute__((__unused__)),
  const int num)
456{
history_t *h = (history_t *) p;
if (history_def_set(h, ev, num) != 0)
return -1;
ev->str = Strdup(h->cursor->ev.str)wcsdup(h->cursor->ev.str);
ev->num = h->cursor->ev.num;
history_def_delete(h, ev, h->cursor);
return 0;
464}


467/* history_def_delete():
*	Delete element hp of the h list
*/
470/* ARGSUSED */
471static void
472history_def_delete(history_t *h,
   TYPE(HistEvent)HistEventW *ev __attribute__((__unused__)), hentry_t *hp)
474{
HistEventPrivate *evp = (void *)&hp->ev;
if (hp == &h->list)
8
←
Assuming the condition is false→
9
←
Taking false branch→
abort();
if (h->cursor == hp) {
10
←
Assuming 'hp' is not equal to field 'cursor'→
11
←
Taking false branch→
h->cursor = hp->prev;
if (h->cursor == &h->list)
	h->cursor = hp->next;
}
hp->prev->next = hp->next;
hp->next->prev = hp->prev;
free(evp->str);
free(hp);
12
←
Memory is released→
h->cur--;
488}


491/* history_def_insert():
*	Insert element with string str in the h list
*/
494static int
495history_def_insert(history_t *h, TYPE(HistEvent)HistEventW *ev, const Charwchar_t *str)
496{

h->cursor = (hentry_t *) malloc(sizeof(hentry_t));
if (h->cursor == NULL((void *)0))
goto oomem;
if ((h->cursor->ev.str = h_strdup(str)wcsdup(str)) == NULL((void *)0)) {
free(h->cursor);
goto oomem;
}
h->cursor->data = NULL((void *)0);
h->cursor->ev.num = ++h->eventid;
h->cursor->next = h->list.next;
h->cursor->prev = &h->list;
h->list.next->prev = h->cursor;
h->list.next = h->cursor;
h->cur++;

*ev = h->cursor->ev;
return 0;
515oomem:
he_seterrev(ev, _HE_MALLOC_FAILED){ ev->num = 2; ev->str = he_errlist[2]; };
return -1;
518}


521/* history_def_enter():
*	Default function to enter an item in the history
*/
524static int
525history_def_enter(void *p, TYPE(HistEvent)HistEventW *ev, const Charwchar_t *str)
526{
history_t *h = (history_t *) p;

if ((h->flags & H_UNIQUE1) != 0 && h->list.next != &h->list &&
   Strcmp(h->list.next->ev.str, str)wcscmp(h->list.next->ev.str, str) == 0)
   return 0;

if (history_def_insert(h, ev, str) == -1)
return -1;	/* error, keep error message */

/*
       * Always keep at least one entry.
       * This way we don't have to check for the empty list.
       */
while (h->cur > h->max && h->cur > 0)
history_def_delete(h, ev, h->list.prev);

return 1;
544}


547/* history_def_init():
*	Default history initialization function
*/
550/* ARGSUSED */
551static int
552history_def_init(void **p, TYPE(HistEvent)HistEventW *ev __attribute__((__unused__)), int n)
553{
history_t *h = (history_t *) malloc(sizeof(history_t));
if (h == NULL((void *)0))
return -1;

if (n <= 0)
n = 0;
h->eventid = 0;
h->cur = 0;
h->max = n;
h->list.next = h->list.prev = &h->list;
h->list.ev.str = NULL((void *)0);
h->list.ev.num = 0;
h->cursor = &h->list;
h->flags = 0;
*p = h;
return 0;
570}


573/* history_def_clear():
*	Default history cleanup function
*/
576static void
577history_def_clear(void *p, TYPE(HistEvent)HistEventW *ev)
578{
history_t *h = (history_t *) p;

while (h->list.prev != &h->list)
6
←
Loop condition is true.  Entering loop body→
14
←
Loop condition is true.  Entering loop body→
history_def_delete(h, ev, h->list.prev);
7
←
Calling 'history_def_delete'→
13
←
Returning; memory was released via 3rd parameter→
15
←
Use of memory after it is freed
h->eventid = 0;
h->cur = 0;
585}




590/************************************************************************/

592/* history_init():
*	Initialization function.
*/
595TYPE(History)HistoryW *
596FUN(history,init)history_winit(void)
597{
TYPE(HistEvent)HistEventW ev;
TYPE(History)HistoryW *h = (TYPE(History)HistoryW *) malloc(sizeof(TYPE(History)HistoryW));
if (h == NULL((void *)0))
return NULL((void *)0);

if (history_def_init(&h->h_ref, &ev, 0) == -1) {
free(h);
return NULL((void *)0);
}
h->h_ent = -1;
h->h_next = history_def_next;
h->h_first = history_def_first;
h->h_last = history_def_last;
h->h_prev = history_def_prev;
h->h_curr = history_def_curr;
h->h_set = history_def_set;
h->h_clear = history_def_clear;
h->h_enter = history_def_enter;
h->h_add = history_def_add;
h->h_del = history_def_del;

return h;
620}


623/* history_end():
*	clean up history;
*/
626void
627FUN(history,end)history_wend(TYPE(History)HistoryW *h)
628{
TYPE(HistEvent)HistEventW ev;

if (h->h_next == history_def_next)
3
←
Assuming field 'h_next' is equal to history_def_next→
4
←
Taking true branch→
history_def_clear(h->h_ref, &ev);
5
←
Calling 'history_def_clear'→
free(h->h_ref);
free(h);
635}



639/* history_setsize():
*	Set history number of events
*/
642static int
643history_setsize(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int num)
644{

if (h->h_next != history_def_next) {
he_seterrev(ev, _HE_NOT_ALLOWED){ ev->num = 14; ev->str = he_errlist[14]; };
return -1;
}
if (num < 0) {
he_seterrev(ev, _HE_BAD_PARAM){ ev->num = 15; ev->str = he_errlist[15]; };
return -1;
}
history_def_setsize(h->h_ref, num)(void) (((history_t *)h->h_ref)->max = (num));
return 0;
656}


659/* history_getsize():
*      Get number of events currently in history
*/
662static int
663history_getsize(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev)
664{
if (h->h_next != history_def_next) {
he_seterrev(ev, _HE_NOT_ALLOWED){ ev->num = 14; ev->str = he_errlist[14]; };
return -1;
}
ev->num = history_def_getsize(h->h_ref)(((history_t *)h->h_ref)->cur);
if (ev->num < -1) {
he_seterrev(ev, _HE_SIZE_NEGATIVE){ ev->num = 13; ev->str = he_errlist[13]; };
return -1;
}
return 0;
675}


678/* history_setunique():
*	Set if adjacent equal events should not be entered in history.
*/
681static int
682history_setunique(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int uni)
683{

if (h->h_next != history_def_next) {
he_seterrev(ev, _HE_NOT_ALLOWED){ ev->num = 14; ev->str = he_errlist[14]; };
return -1;
}
history_def_setunique(h->h_ref, uni)if (uni) (((history_t *)h->h_ref)->flags) |= 1; else ((
(history_t *)h->h_ref)->flags) &= ~1;
return 0;
691}


694/* history_getunique():
*	Get if adjacent equal events should not be entered in history.
*/
697static int
698history_getunique(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev)
699{
if (h->h_next != history_def_next) {
he_seterrev(ev, _HE_NOT_ALLOWED){ ev->num = 14; ev->str = he_errlist[14]; };
return -1;
}
ev->num = history_def_getunique(h->h_ref)(((((history_t *)h->h_ref)->flags) & 1) != 0);
return 0;
706}


709/* history_set_fun():
*	Set history functions
*/
712static int
713history_set_fun(TYPE(History)HistoryW *h, TYPE(History)HistoryW *nh)
714{
TYPE(HistEvent)HistEventW ev;

if (nh->h_first == NULL((void *)0) || nh->h_next == NULL((void *)0) || nh->h_last == NULL((void *)0) ||
   nh->h_prev == NULL((void *)0) || nh->h_curr == NULL((void *)0) || nh->h_set == NULL((void *)0) ||
   nh->h_enter == NULL((void *)0) || nh->h_add == NULL((void *)0) || nh->h_clear == NULL((void *)0) ||
   nh->h_del == NULL((void *)0) || nh->h_ref == NULL((void *)0)) {
if (h->h_next != history_def_next) {
	history_def_init(&h->h_ref, &ev, 0);
	h->h_first = history_def_first;
	h->h_next = history_def_next;
	h->h_last = history_def_last;
	h->h_prev = history_def_prev;
	h->h_curr = history_def_curr;
	h->h_set = history_def_set;
	h->h_clear = history_def_clear;
	h->h_enter = history_def_enter;
	h->h_add = history_def_add;
	h->h_del = history_def_del;
}
return -1;
}
if (h->h_next == history_def_next)
history_def_clear(h->h_ref, &ev);

h->h_ent = -1;
h->h_first = nh->h_first;
h->h_next = nh->h_next;
h->h_last = nh->h_last;
h->h_prev = nh->h_prev;
h->h_curr = nh->h_curr;
h->h_set = nh->h_set;
h->h_clear = nh->h_clear;
h->h_enter = nh->h_enter;
h->h_add = nh->h_add;
h->h_del = nh->h_del;

return 0;
752}


755/* history_load():
*	TYPE(History) load function
*/
758static int
759history_load(TYPE(History)HistoryW *h, const char *fname)
760{
FILE *fp;
char *line;
size_t llen;
ssize_t sz;
size_t max_size;
char *ptr;
int i = -1;
TYPE(HistEvent)HistEventW ev;
769#ifndef NARROWCHAR
static ct_buffer_t conv;
771#endif

if ((fp = fopen(fname, "r")) == NULL((void *)0))
return i;

line = NULL((void *)0);
llen = 0;
if ((sz = getline(&line, &llen, fp)) == -1)
goto done;

if (strncmp(line, hist_cookie, sz) != 0)
goto done;

ptr = malloc(max_size = 1024);
if (ptr == NULL((void *)0))
goto done;
for (i = 0; (sz = getline(&line, &llen, fp)) != -1; i++) {
if (sz > 0 && line[sz - 1] == '\n')
	line[--sz] = '\0';
if (max_size < sz) {
	char *nptr;
	max_size = (sz + 1024) & ~1023;
	nptr = realloc(ptr, max_size);
	if (nptr == NULL((void *)0)) {
		i = -1;
		goto oomem;
	}
	ptr = nptr;
}
(void) strunvis(ptr, line);
if (HENTER(h, &ev, ct_decode_string(ptr, &conv))(*(h)->h_enter)((h)->h_ref, &ev, ct_decode_string(ptr
, &conv)) == -1) {
	i = -1;
	goto oomem;
}
}
806oomem:
free(ptr);
808done:
free(line);
(void) fclose(fp);
return i;
812}


815/* history_save_fp():
*	TYPE(History) save function
*/
818static int
819history_save_fp(TYPE(History)HistoryW *h, FILE *fp)
820{
TYPE(HistEvent)HistEventW ev;
int i = -1, retval;
size_t len, max_size;
char *ptr;
825#ifndef NARROWCHAR
static ct_buffer_t conv;
827#endif

if (fchmod(fileno(fp)(!__isthreaded ? ((fp)->_file) : (fileno)(fp)), S_IRUSR0000400|S_IWUSR0000200) == -1)
goto done;
if (fputs(hist_cookie, fp) == EOF(-1))
goto done;
ptr = malloc(max_size = 1024);
if (ptr == NULL((void *)0))
goto done;
for (i = 0, retval = HLAST(h, &ev)(*(h)->h_last)((h)->h_ref, &ev);
   retval != -1;
   retval = HPREV(h, &ev)(*(h)->h_prev)((h)->h_ref, &ev), i++) {
len = Strlen(ev.str)wcslen(ev.str) * 4 + 1;
if (len > max_size) {
	char *nptr;
	max_size = (len + 1024) & ~1023;
	nptr = realloc(ptr, max_size);
	if (nptr == NULL((void *)0)) {
		i = -1;
		goto oomem;
	}
	ptr = nptr;
}
(void) strnvis(ptr, ct_encode_string(ev.str, &conv), max_size,
    VIS_WHITE(0x04 | 0x08 | 0x10));
(void) fprintf(fp, "%s\n", ptr);
}
854oomem:
free(ptr);
856done:
return i;
858}


861/* history_save():
*    History save function
*/
864static int
865history_save(TYPE(History)HistoryW *h, const char *fname)
866{
FILE *fp;
int i;

if ((fp = fopen(fname, "w")) == NULL((void *)0))
return -1;

i = history_save_fp(h, fp);

(void) fclose(fp);
return i;
877}


880/* history_prev_event():
*	Find the previous event, with number given
*/
883static int
884history_prev_event(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int num)
885{
int retval;

for (retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev); retval != -1; retval = HPREV(h, ev)(*(h)->h_prev)((h)->h_ref, ev))
if (ev->num == num)
	return 0;

he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
894}


897static int
898history_next_evdata(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int num, void **d)
899{
int retval;

for (retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev); retval != -1; retval = HPREV(h, ev)(*(h)->h_prev)((h)->h_ref, ev))
if (ev->num == num) {
	if (d)
		*d = ((history_t *)h->h_ref)->cursor->data;
	return 0;
}

he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
911}


914/* history_next_event():
*	Find the next event, with number given
*/
917static int
918history_next_event(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int num)
919{
int retval;

for (retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev); retval != -1; retval = HNEXT(h, ev)(*(h)->h_next)((h)->h_ref, ev))
if (ev->num == num)
	return 0;

he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
928}


931/* history_prev_string():
*	Find the previous event beginning with string
*/
934static int
935history_prev_string(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, const Charwchar_t *str)
936{
size_t len = Strlen(str)wcslen(str);
int retval;

for (retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev); retval != -1; retval = HNEXT(h, ev)(*(h)->h_next)((h)->h_ref, ev))
if (Strncmp(str, ev->str, len)wcsncmp(str, ev->str, len) == 0)
	return 0;

he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
946}


949/* history_next_string():
*	Find the next event beginning with string
*/
952static int
953history_next_string(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, const Charwchar_t *str)
954{
size_t len = Strlen(str)wcslen(str);
int retval;

for (retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev); retval != -1; retval = HPREV(h, ev)(*(h)->h_prev)((h)->h_ref, ev))
if (Strncmp(str, ev->str, len)wcsncmp(str, ev->str, len) == 0)
	return 0;

he_seterrev(ev, _HE_NOT_FOUND){ ev->num = 9; ev->str = he_errlist[9]; };
return -1;
964}


967/* history():
*	User interface to history functions.
*/
970int
971FUNW(history)history_w(TYPE(History)HistoryW *h, TYPE(HistEvent)HistEventW *ev, int fun, ...)
972{
va_list va;
const Charwchar_t *str;
int retval;

va_start(va, fun)__builtin_va_start(va, fun);

he_seterrev(ev, _HE_OK){ ev->num = 0; ev->str = he_errlist[0]; };

switch (fun) {
1
Control jumps to 'case 12:'  at line 1104→
case H_GETSIZE2:
retval = history_getsize(h, ev);
break;

case H_SETSIZE1:
retval = history_setsize(h, ev, va_arg(va, int)__builtin_va_arg(va, int));
break;

case H_GETUNIQUE21:
retval = history_getunique(h, ev);
break;

case H_SETUNIQUE20:
retval = history_setunique(h, ev, va_arg(va, int)__builtin_va_arg(va, int));
break;

case H_ADD9:
str = va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *);
retval = HADD(h, ev, str)(*(h)->h_add)((h)->h_ref, ev, str);
break;

case H_DEL22:
retval = HDEL(h, ev, va_arg(va, const int))(*(h)->h_del)((h)->h_ref, ev, __builtin_va_arg(va, const
 int));
break;

case H_ENTER10:
str = va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *);
if ((retval = HENTER(h, ev, str)(*(h)->h_enter)((h)->h_ref, ev, str)) != -1)
	h->h_ent = ev->num;
break;

case H_APPEND11:
str = va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *);
if ((retval = HSET(h, ev, h->h_ent)(*(h)->h_set)((h)->h_ref, ev, h->h_ent)) != -1)
	retval = HADD(h, ev, str)(*(h)->h_add)((h)->h_ref, ev, str);
break;

case H_FIRST3:
retval = HFIRST(h, ev)(*(h)->h_first)((h)->h_ref, ev);
break;

case H_NEXT6:
retval = HNEXT(h, ev)(*(h)->h_next)((h)->h_ref, ev);
break;

case H_LAST4:
retval = HLAST(h, ev)(*(h)->h_last)((h)->h_ref, ev);
break;

case H_PREV5:
retval = HPREV(h, ev)(*(h)->h_prev)((h)->h_ref, ev);
break;

case H_CURR8:
retval = HCURR(h, ev)(*(h)->h_curr)((h)->h_ref, ev);
break;

case H_SET7:
retval = HSET(h, ev, va_arg(va, const int))(*(h)->h_set)((h)->h_ref, ev, __builtin_va_arg(va, const
 int));
break;

case H_CLEAR19:
HCLEAR(h, ev)(*(h)->h_clear)((h)->h_ref, ev);
retval = 0;
break;

case H_LOAD17:
retval = history_load(h, va_arg(va, const char *)__builtin_va_arg(va, const char *));
if (retval == -1)
	he_seterrev(ev, _HE_HIST_READ){ ev->num = 10; ev->str = he_errlist[10]; };
break;

case H_SAVE18:
retval = history_save(h, va_arg(va, const char *)__builtin_va_arg(va, const char *));
if (retval == -1)
	he_seterrev(ev, _HE_HIST_WRITE){ ev->num = 11; ev->str = he_errlist[11]; };
break;

case H_SAVE_FP26:
retval = history_save_fp(h, va_arg(va, FILE *)__builtin_va_arg(va, FILE *));
if (retval == -1)
    he_seterrev(ev, _HE_HIST_WRITE){ ev->num = 11; ev->str = he_errlist[11]; };
break;

case H_PREV_EVENT16:
retval = history_prev_event(h, ev, va_arg(va, int)__builtin_va_arg(va, int));
break;

case H_NEXT_EVENT15:
retval = history_next_event(h, ev, va_arg(va, int)__builtin_va_arg(va, int));
break;

case H_PREV_STR14:
retval = history_prev_string(h, ev, va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *));
break;

case H_NEXT_STR13:
retval = history_next_string(h, ev, va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *));
break;

case H_FUNC0:
{
TYPE(History)HistoryW hf;

hf.h_ref = va_arg(va, void *)__builtin_va_arg(va, void *);
h->h_ent = -1;
hf.h_first = va_arg(va, history_gfun_t)__builtin_va_arg(va, history_gfun_t);
hf.h_next = va_arg(va, history_gfun_t)__builtin_va_arg(va, history_gfun_t);
hf.h_last = va_arg(va, history_gfun_t)__builtin_va_arg(va, history_gfun_t);
hf.h_prev = va_arg(va, history_gfun_t)__builtin_va_arg(va, history_gfun_t);
hf.h_curr = va_arg(va, history_gfun_t)__builtin_va_arg(va, history_gfun_t);
hf.h_set = va_arg(va, history_sfun_t)__builtin_va_arg(va, history_sfun_t);
hf.h_clear = va_arg(va, history_vfun_t)__builtin_va_arg(va, history_vfun_t);
hf.h_enter = va_arg(va, history_efun_t)__builtin_va_arg(va, history_efun_t);
hf.h_add = va_arg(va, history_efun_t)__builtin_va_arg(va, history_efun_t);
hf.h_del = va_arg(va, history_sfun_t)__builtin_va_arg(va, history_sfun_t);

if ((retval = history_set_fun(h, &hf)) == -1)
	he_seterrev(ev, _HE_PARAM_MISSING){ ev->num = 12; ev->str = he_errlist[12]; };
break;
}

case H_END12:
FUN(history,end)history_wend(h);
2
←
Calling 'history_wend'→
retval = 0;
break;

case H_NEXT_EVDATA23:
{
int num = va_arg(va, int)__builtin_va_arg(va, int);
void **d = va_arg(va, void **)__builtin_va_arg(va, void **);
retval = history_next_evdata(h, ev, num, d);
break;
}

case H_DELDATA24:
{
int num = va_arg(va, int)__builtin_va_arg(va, int);
void **d = va_arg(va, void **)__builtin_va_arg(va, void **);
retval = history_deldata_nth((history_t *)h->h_ref, ev, num, d);
break;
}

case H_REPLACE25: /* only use after H_NEXT_EVDATA */
{
const Charwchar_t *line = va_arg(va, const Char *)__builtin_va_arg(va, const wchar_t *);
void *d = va_arg(va, void *)__builtin_va_arg(va, void *);
const Charwchar_t *s;
if(!line || !(s = Strdup(line)wcsdup(line))) {
	retval = -1;
	break;
}
((history_t *)h->h_ref)->cursor->ev.str = s;
((history_t *)h->h_ref)->cursor->data = d;
retval = 0;
break;
}

default:
retval = -1;
he_seterrev(ev, _HE_UNKNOWN){ ev->num = 1; ev->str = he_errlist[1]; };
break;
}
va_end(va)__builtin_va_end(va);
return retval;
1147}