stringbuffer.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
 
#include "global.h"
#include "libproto.h"
#include "stringbuffer.h"
 
struct StringBuffer {
    char *buf;
 
    size_t pos;
 
    size_t size;
};
 
 
static void stringbuffer_ensure(StringBuffer *sb, size_t len);
 
 
StringBuffer *stringbuffer_new(void) {
    StringBuffer *sb;
 
    sb = static_cast<StringBuffer *>(malloc(sizeof(*sb)));
    if (sb == NULL) {
        fatal(OUT_OF_MEMORY);
    }
 
    sb->size = 512;
    sb->buf = static_cast<char *>(malloc(sb->size));
    sb->pos = 0;
    return sb;
}
 
void stringbuffer_delete(StringBuffer *sb) {
    free(sb->buf);
    free(sb);
}
 
char *stringbuffer_finish(StringBuffer *sb) {
    char *result;
 
    sb->buf[sb->pos] = '\0';
    result = sb->buf;
    free(sb);
    return result;
}
 
sstring stringbuffer_finish_shared(StringBuffer *sb) {
    char *str;
    sstring result;
 
    str = stringbuffer_finish(sb);
    result = add_string(str);
    free(str);
    return result;
}
 
void stringbuffer_append_string(StringBuffer *sb, const char *str) {
    size_t len;
 
    len = strlen(str);
    stringbuffer_ensure(sb, len+1);
    memcpy(sb->buf+sb->pos, str, len);
    sb->pos += len;
}
 
void stringbuffer_append_char(StringBuffer *sb, const char c) {
    stringbuffer_ensure(sb, 2); // character and NUL
    sb->buf[sb->pos] = c;
    sb->buf[sb->pos + 1] = '\0';
    sb->pos += 1;
}
 
void stringbuffer_append_int64(StringBuffer *sb, int64_t x) {
    if (x < 0) {
        stringbuffer_append_char(sb, '-');
        if (x == INT64_MIN) {
            x = INT64_MAX;
        } else {
            x = -x;
        }
    }
 
    const int MAX_DIGITS = 20; // handle at most 20 digits, since an int64_t has at most 19 digits
    char buf[MAX_DIGITS];
    int i;
    for (i = 0; i < MAX_DIGITS; i++) {
        buf[i] = x % 10 + '0';
        if ((x /= 10) == 0) {
            i++;
            break;
        }
    }
 
    // copy into sb in reverse
    for (int j = i - 1; j >= 0; j--) {
        stringbuffer_append_char(sb, buf[j]);
    }
}
 
void stringbuffer_append_printf(StringBuffer *sb, const char *format, ...) {
    size_t size;
 
    size = 100;                 /* arbitrary guess */
    for (;;) {
        int n;
        va_list arg;
 
        stringbuffer_ensure(sb, size);
 
        va_start(arg, format);
        n = vsnprintf(sb->buf+sb->pos, size, format, arg);
        va_end(arg);
 
        if (n > -1 && (size_t)n < size) {
            sb->pos += (size_t)n;
            break;
        }
 
        if (n > -1) {
            size = n+1;         /* precisely what is needed */
        } else {
            size *= 2;          /* twice the old size */
        }
    }
}
 
void stringbuffer_append_stringbuffer(StringBuffer *sb, const StringBuffer *sb2) {
    stringbuffer_ensure(sb, sb2->pos+1);
    memcpy(sb->buf+sb->pos, sb2->buf, sb2->pos);
    sb->pos += sb2->pos;
}
 
static void stringbuffer_ensure(StringBuffer *sb, size_t len) {
    char *tmp;
    const size_t newlen = sb->pos+len;
    if (newlen <= sb->size) {
        return;
    }
 
#if 0
    putchar('.');
    fflush(stdout);
#endif
 
    do {
        sb->size *= 1.5;
    } while (newlen > sb->size);
    tmp = static_cast<char *>(realloc(sb->buf, sb->size));
    if (tmp == NULL) {
        fatal(OUT_OF_MEMORY);
    }
    sb->buf = tmp;
}
 
void stringbuffer_append_multiline_block(StringBuffer *sb, const char *start, const char *content, const char *end) {
    char buf[100];
    if (!content || *content == '\0') {
        return;
    }
    if (end == NULL) {
        snprintf(buf, sizeof(buf), "end_%s", start);
        end = buf;
    }
    size_t ls = strlen(start), lc = strlen(content), le = strlen(end);
    size_t added = ls + lc + le + 3; // At most 3 newlines to add.
    stringbuffer_ensure(sb, added);
    snprintf(sb->buf + sb->pos, sb->size - sb->pos, "%s\n%s", start, content);
    sb->pos += ls + lc + 1;
    if ((lc > 0) && (content[lc - 1] != '\n')) {
        sb->buf[sb->pos] = '\n';
        sb->pos++;
    }
    snprintf(sb->buf + sb->pos, sb->size - sb->pos, "%s\n", end);
    sb->pos += le + 1;
}
 
size_t stringbuffer_length(StringBuffer *sb) {
    return sb->pos;
}
 
void stringbuffer_trim_whitespace(StringBuffer *sb) {
    while (sb->pos > 0 && isspace(sb->buf[sb->pos-1])) {
        sb->pos--;
    }
}