Subversion Repositories openrisc

// This file is part of the uSTL library, an STL implementation.

//

// Copyright (c) 2005-2009 by Mike Sharov <msharov@users.sourceforge.net>

// This file is free software, distributed under the MIT License.

#include "mistream.h"   // for istream_iterator, referenced in utf8.h

#include "sostream.h"

#include "ustring.h"

#include "ulimits.h"

#include <stdio.h>

namespace ustl {

/// Creates an output string stream linked to the given memory area.

ostringstream::ostringstream (void* p, size_t n)

: ostream (),

  m_Buffer (),

  m_Flags (0),

  m_Width (0),

  m_Base (10),

  m_Precision (2)

{

    exceptions (goodbit);

    link (p, n);

}

/// Creates an output string stream, initializing the buffer with v.

ostringstream::ostringstream (const string& v)

: ostream (),

  m_Buffer (v),

  m_Flags (0),

  m_Width (0),

  m_Base (10),

  m_Precision (2)

{

    exceptions (goodbit);

    ostream::link (m_Buffer);

}

/// Copies \p s to the internal buffer.

void ostringstream::str (const string& s)

{

    m_Buffer = s;

    ostream::link (m_Buffer);

    SetPos (m_Buffer.size());

}

/// Writes a single character into the stream.

void ostringstream::iwrite (uint8_t v)

{

    if (remaining() >= 1 || overflow() >= 1)

        ostream::iwrite (v);

}

/// Writes the contents of \p buffer of \p size into the stream.

ostringstream& ostringstream::write (const void* buffer, size_type sz)

{

    const char* buf = (const char*) buffer;

    for (size_type bw = 0; (bw = min(sz, remaining() ? remaining() : overflow(sz))); buf += bw, sz -= bw)

        ostream::write (buf, bw);

    return (*this);

}

/// Simple decimal encoding of \p n into \p fmt.

inline char* ostringstream::encode_dec (char* fmt, uint32_t n) const

{

    do {

        *fmt++ = '0' + n % 10;

    } while (n /= 10);

    return (fmt);

}

/// Generates a sprintf format string for the given type.

void ostringstream::fmtstring (char* fmt, const char* typestr, bool bInteger) const

{

    *fmt++ = '%';

    if (m_Width)

        fmt = encode_dec (fmt, m_Width);

    if (m_Flags & left)

        *fmt++ = '-';

    if (!bInteger) {

        *fmt++ = '.';

        fmt = encode_dec (fmt, m_Precision);

    }

    while (*typestr)

        *fmt++ = *typestr++;

    if (bInteger) {

        if (m_Base == 16)

            fmt[-1] = 'X';

        else if (m_Base == 8)

            fmt[-1] = 'o';

    } else {

        if (m_Flags & scientific)

            fmt[-1] = 'E';

    }

    *fmt = 0;

}

/// Writes \p v into the stream as utf8

void ostringstream::iwrite (wchar_t v)

{

    char buffer [8];

    *utf8out(buffer) = v;

    write (buffer, Utf8Bytes(v));

}

/// Writes value \p v into the stream as text.

void ostringstream::iwrite (bool v)

{

    static const char tf[2][8] = { "false", "true" };

    write (tf[v], 5 - v);

}

/// Equivalent to a vsprintf on the string.

int ostringstream::vformat (const char* fmt, va_list args)

{

#if HAVE_VA_COPY

    va_list args2;

#else

    #define args2 args

    #undef __va_copy

    #define __va_copy(x,y)

#endif

    size_t rv, space;

    do {

        space = remaining();

        __va_copy (args2, args);

        rv = vsnprintf (ipos(), space, fmt, args2);

        if (ssize_t(rv) < 0)

            rv = space;

    } while (rv >= space && rv < overflow(rv + 1));

    SetPos (pos() + min (rv, space));

    return (rv);

}

/// Equivalent to a sprintf on the string.

int ostringstream::format (const char* fmt, ...)

{

    va_list args;

    va_start (args, fmt);

    const int rv = vformat (fmt, args);

    va_end (args);

    return (rv);

}

/// Links to string \p l as resizable.

void ostringstream::link (void* p, size_type n)

{

    assert ((p || !n) && "The output string buffer must not be read-only");

    ostream::link (p, n);

    m_Buffer.link (p, n);

}

/// Attempts to create more output space. Returns remaining().

ostringstream::size_type ostringstream::overflow (size_type n)

{

    if (n > remaining()) {

        const uoff_t oldPos (pos());

        m_Buffer.reserve (oldPos + n, false);

        m_Buffer.resize (oldPos + n);

        ostream::link (m_Buffer);

        SetPos (oldPos);

    }

    verify_remaining ("write", "text", n);

    return (remaining());

}

} // namespace ustl