server/stringbuffer.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#include <global.h>
#include <stdarg.h>

static void stringbuffer_ensure(StringBuffer *sb, size_t len);

StringBuffer *stringbuffer_new()
{
    StringBuffer *sb = malloc(sizeof(StringBuffer));

    if (!sb)
    {
        LOG(llevError, "stringbuffer_new(): Out of memory.");
    }

    sb->size = MAX_BUF;
    sb->buf = malloc(sb->size);
    sb->pos = 0;
    return sb;
}

char *stringbuffer_finish(StringBuffer *sb)
{
    char *result;

    sb->buf[sb->pos] = '\0';
    result = sb->buf;
    free(sb);
    return result;
}

const char *stringbuffer_finish_shared(StringBuffer *sb)
{
    char *str = stringbuffer_finish(sb);
    const char *result = add_string(str);

    free(str);
    return result;
}

void stringbuffer_append_string(StringBuffer *sb, const char *str)
{
    size_t len = strlen(str);

    stringbuffer_ensure(sb, len + 1);
    memcpy(sb->buf + sb->pos, str, len);
    sb->pos += len;
}

void stringbuffer_append_printf(StringBuffer *sb, const char *format, ...)
{
    size_t size = MAX_BUF;

    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;
        }

        /* Precisely what is needed */
        if (n > -1)
        {
            size = n + 1;
        }
        /* Twice the old size */
        else
        {
            size *= 2;
        }
    }
}

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;
    size_t new_size;

    if (sb->pos + len <= sb->size)
    {
        return;
    }

    new_size = sb->pos + len + MAX_BUF;
    tmp = realloc(sb->buf, new_size);

    if (tmp == NULL)
    {
        LOG(llevError, "stringbuffer_ensure(): Out of memory.\n");
    }

    sb->buf = tmp;
    sb->size = new_size;
}

size_t stringbuffer_length(StringBuffer *sb)
{
    return sb->pos;
}