plugins/libukcprog/ebuf.c

/* ebuf.c - an expanding buffer */

/*  Copyright 1993 Mark Russell, University of Kent at Canterbury
 *
 *  You can do what you like with this source code as long as
 *  you don't try to make money out of it and you include an
 *  unaltered copy of this message (including the copyright).
 */

char ukcprog_ebuf_sccsid[] = "$Id: ebuf.c,v 1.1 2002/03/08 14:37:29 tdb Exp $ UKC";

#include <stdlib.h>
#include <string.h>

#include "ukcprog.h"

struct ebuf_s {
        bool eb_errors_are_fatal;
        char *eb_buf;
        size_t eb_bufsize;
        size_t eb_pos;
};

ebuf_t *
ebuf_create(errors_are_fatal)
bool errors_are_fatal;
{
        ebuf_t *eb;
        char *buf;
        size_t bufsize;

        bufsize = 100;

        if (errors_are_fatal) {
                eb = (ebuf_t *)e_malloc(sizeof(ebuf_t));
                buf = e_malloc(bufsize);
        }
        else {
                if ((eb = (ebuf_t *)malloc(sizeof(ebuf_t))) == NULL)
                        return NULL;
                if ((buf = malloc(bufsize)) == NULL) {
                        free((char *)eb);
                        return NULL;
                }
        }

        eb->eb_errors_are_fatal = errors_are_fatal;
        eb->eb_buf = buf;
        eb->eb_bufsize = bufsize;
        eb->eb_pos = 0;

        return eb;
}

void
ebuf_reset(eb)
ebuf_t *eb;
{
        eb->eb_pos = 0;
}

/*  We would like this to take a pointer to a size_t, but that would
 *  break existing code (when compiling with gcc).  Maybe later.
 */
voidptr
ebuf_get(eb, p_len)
ebuf_t *eb;
int *p_len;
{
        if (p_len != NULL)
                *p_len = eb->eb_pos;
        return eb->eb_buf;
}

ebuf_t *
ebuf_start(eb, errors_are_fatal)
ebuf_t *eb;
bool errors_are_fatal;
{
        if (eb == NULL)
                eb = ebuf_create(errors_are_fatal);
        else
                ebuf_reset(eb);

        return eb;
}

void
ebuf_free(eb)
ebuf_t *eb;
{
        free(eb->eb_buf);
        free((char *)eb);
}

int
ebuf_add(eb, buf, count)
ebuf_t *eb;
constvoidptr buf;
size_t count;
{
        size_t size;

        for (size = eb->eb_bufsize; eb->eb_pos + count > size; size *= 2)
                ;

        if (size != eb->eb_bufsize) {
                if ((eb->eb_buf = realloc(eb->eb_buf, size)) == NULL) {
                        if (eb->eb_errors_are_fatal)
                                panic("realloc failed in ebuf_add");
                        return -1;
                }
                eb->eb_bufsize = size;
        }

        memcpy(eb->eb_buf + eb->eb_pos, buf, count);
        eb->eb_pos += count;

        return 0;
}

int
ebuf_addstr(eb, str)
ebuf_t *eb;
const char *str;
{
        return ebuf_add(eb, str, strlen(str));
}
Revision:	1.2
Committed:	Fri Mar 28 16:30:32 2003 UTC (21 years, 7 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Error occurred while calculating annotation data.
Log Message:	Removed some un-used code from CVS. We can always resurrect this later if someone feels they want to work on it. Gone are the old perl ihost which isn't needed now, winhost which is broken and shows no sign of being fixed, and DBReporter. If someone wants to revive them, I'll undelete them :-)
#	Content
1	/* ebuf.c - an expanding buffer */
2
3	/* Copyright 1993 Mark Russell, University of Kent at Canterbury
4	*
5	* You can do what you like with this source code as long as
6	* you don't try to make money out of it and you include an
7	* unaltered copy of this message (including the copyright).
8	*/
9
10	char ukcprog_ebuf_sccsid[] = "$Id: ebuf.c,v 1.1 2002/03/08 14:37:29 tdb Exp $ UKC";
11
12	#include <stdlib.h>
13	#include <string.h>
14
15	#include "ukcprog.h"
16
17	struct ebuf_s {
18	bool eb_errors_are_fatal;
19	char *eb_buf;
20	size_t eb_bufsize;
21	size_t eb_pos;
22	};
23
24	ebuf_t *
25	ebuf_create(errors_are_fatal)
26	bool errors_are_fatal;
27	{
28	ebuf_t *eb;
29	char *buf;
30	size_t bufsize;
31
32	bufsize = 100;
33
34	if (errors_are_fatal) {
35	eb = (ebuf_t *)e_malloc(sizeof(ebuf_t));
36	buf = e_malloc(bufsize);
37	}
38	else {
39	if ((eb = (ebuf_t *)malloc(sizeof(ebuf_t))) == NULL)
40	return NULL;
41	if ((buf = malloc(bufsize)) == NULL) {
42	free((char *)eb);
43	return NULL;
44	}
45	}
46
47	eb->eb_errors_are_fatal = errors_are_fatal;
48	eb->eb_buf = buf;
49	eb->eb_bufsize = bufsize;
50	eb->eb_pos = 0;
51
52	return eb;
53	}
54
55	void
56	ebuf_reset(eb)
57	ebuf_t *eb;
58	{
59	eb->eb_pos = 0;
60	}
61
62	/* We would like this to take a pointer to a size_t, but that would
63	* break existing code (when compiling with gcc). Maybe later.
64	*/
65	voidptr
66	ebuf_get(eb, p_len)
67	ebuf_t *eb;
68	int *p_len;
69	{
70	if (p_len != NULL)
71	*p_len = eb->eb_pos;
72	return eb->eb_buf;
73	}
74
75	ebuf_t *
76	ebuf_start(eb, errors_are_fatal)
77	ebuf_t *eb;
78	bool errors_are_fatal;
79	{
80	if (eb == NULL)
81	eb = ebuf_create(errors_are_fatal);
82	else
83	ebuf_reset(eb);
84
85	return eb;
86	}
87
88	void
89	ebuf_free(eb)
90	ebuf_t *eb;
91	{
92	free(eb->eb_buf);
93	free((char *)eb);
94	}
95
96	int
97	ebuf_add(eb, buf, count)
98	ebuf_t *eb;
99	constvoidptr buf;
100	size_t count;
101	{
102	size_t size;
103
104	for (size = eb->eb_bufsize; eb->eb_pos + count > size; size *= 2)
105	;
106
107	if (size != eb->eb_bufsize) {
108	if ((eb->eb_buf = realloc(eb->eb_buf, size)) == NULL) {
109	if (eb->eb_errors_are_fatal)
110	panic("realloc failed in ebuf_add");
111	return -1;
112	}
113	eb->eb_bufsize = size;
114	}
115
116	memcpy(eb->eb_buf + eb->eb_pos, buf, count);
117	eb->eb_pos += count;
118
119	return 0;
120	}
121
122	int
123	ebuf_addstr(eb, str)
124	ebuf_t *eb;
125	const char *str;
126	{
127	return ebuf_add(eb, str, strlen(str));
128	}