libukcprog/src/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.7 1995/11/26 15:59:21 mtr 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.1
Committed:	Sat Mar 29 16:30:33 2003 UTC (21 years, 8 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	LIBUKCPROG_1_0_2, LIBUKCPROG_1_0_1, LIBUKCPROG_1_0, HEAD
Log Message:	libukcprog is now a seperate package. I doubt this will be much use to anyone other than us, but I see no reason why we can't package it up and distribute it. Obviously we can't attach the GPL to this, as we don't own it.
#	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.7 1995/11/26 15:59:21 mtr 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	}