114 lines
2.6 KiB
C
114 lines
2.6 KiB
C
/* buffer.c for MudOS 0.9.x by John Garnett, 1993/11/07 */
|
|
|
|
#include "std.h"
|
|
|
|
#ifndef NO_BUFFER_TYPE
|
|
#include "crctab.h"
|
|
#include "lpc_incl.h"
|
|
#include "stralloc.h"
|
|
|
|
buffer_t null_buf =
|
|
{
|
|
1, /* Ref count, which will ensure that it will
|
|
* never be deallocated */
|
|
0 /* size */
|
|
};
|
|
|
|
INLINE buffer_t *
|
|
null_buffer()
|
|
{
|
|
null_buf.ref++;
|
|
return &null_buf;
|
|
} /* null_buffer() */
|
|
|
|
INLINE void
|
|
free_buffer (buffer_t * b)
|
|
{
|
|
b->ref--;
|
|
/* don't try to free the null_buffer (ref count might overflow) */
|
|
if ((b->ref > 0) || (b == &null_buf)) {
|
|
return;
|
|
}
|
|
FREE((char *) b);
|
|
} /* free_buffer() */
|
|
|
|
buffer_t *
|
|
allocate_buffer (int size)
|
|
{
|
|
buffer_t *buf;
|
|
|
|
#ifndef NO_BUFFER_TYPE
|
|
if ((size < 0) || (size > max_buffer_size)) {
|
|
error("Illegal buffer size.\n");
|
|
}
|
|
if (size == 0) {
|
|
return null_buffer();
|
|
}
|
|
/* using calloc() so that memory will be zero'd out when allocated */
|
|
buf = (buffer_t *) DCALLOC(sizeof(buffer_t) + size - 1, 1,
|
|
TAG_BUFFER, "allocate_buffer");
|
|
buf->size = size;
|
|
buf->ref = 1;
|
|
return buf;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
int write_buffer (buffer_t * buf, int start, const char * str, int theLength)
|
|
{
|
|
int size;
|
|
|
|
size = buf->size;
|
|
if (start < 0) {
|
|
start = size + start;
|
|
if (start < 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
/*
|
|
* can't write past the end of the buffer since we can't reallocate the
|
|
* buffer here (no easy way to propagate back the changes to the caller
|
|
*/
|
|
if ((start + theLength) > size) {
|
|
return 0;
|
|
}
|
|
memcpy(buf->item + start, str, theLength);
|
|
return 1;
|
|
} /* write_buffer() */
|
|
|
|
char *
|
|
read_buffer (buffer_t * b, int start, int len, int * rlen)
|
|
{
|
|
char *str;
|
|
unsigned int size;
|
|
|
|
if (len < 0)
|
|
return 0;
|
|
|
|
size = b->size;
|
|
if (start < 0) {
|
|
start = size + start;
|
|
if (start < 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
if (len == 0) {
|
|
len = size;
|
|
}
|
|
if (start >= size) {
|
|
return 0;
|
|
}
|
|
if ((start + len) > size) {
|
|
len = (size - start);
|
|
}
|
|
for (str = (char *)b->item + start, size = 0; *str && size < len; str++, size++)
|
|
;
|
|
str = new_string(size, "read_buffer: str");
|
|
memcpy(str, b->item + start, size);
|
|
str[*rlen = size] = '\0';
|
|
|
|
return str;
|
|
} /* read_buffer() */
|
|
#endif
|