format.hpp

Go to the documentation of this file.

 
#ifndef __DCONV_FORMAT_HPP__
#define __DCONV_FORMAT_HPP__
 
// dconv.
#include <dconv/digits.hpp>
 
// C.
#include <cstring>
#include <cassert>
#include <cstdint>
 
namespace dconv
{
    namespace details
    {
        inline char* writeExponent (char* buffer, int k) noexcept
        {
            *buffer = '-';
            buffer += (k < 0);
            k = (k < 0) ? -k : k;
            if (k >= 100)
            {
                *buffer++ = static_cast<char> ('0' + k / 100);
                __builtin_memcpy (buffer, &digitPairs[(k % 100) * 2], 2);
                buffer += 2;
            }
            else if (k >= 10)
            {
                __builtin_memcpy (buffer, &digitPairs[k * 2], 2);
                buffer += 2;
            }
            else
            {
                *buffer++ = static_cast<char> ('0' + k);
            }
            return buffer;
        }
 
        inline char* prettify (char* buffer, int length, int k) noexcept
        {
            assert (length > 0);
            const int kk = length + k;
 
            if ((length <= kk) && (kk <= 21))
            {
                memset (buffer + length, '0', kk - length);
                buffer[kk] = '.';
                buffer[kk + 1] = '0';
                return &buffer[kk + 2];
            }
            else if ((0 < kk) && (kk <= 21))
            {
                if ((length - kk <= 16) && (kk <= 7))
                {
                    char tmp[16];
                    memcpy (tmp, &buffer[kk], 16);
                    memcpy (&buffer[kk + 1], tmp, 16);
                }
                else
                {
                    memmove (&buffer[kk + 1], &buffer[kk], length - kk);
                }
                buffer[kk] = '.';
                return &buffer[length + 1];
            }
            else if ((-6 < kk) && (kk <= 0))
            {
                int offset = 2 - kk;
                memmove (&buffer[offset], &buffer[0], length);
                buffer[0] = '0';
                buffer[1] = '.';
                memset (&buffer[2], '0', offset - 2);
                return &buffer[length + offset];
            }
            else if (length == 1)
            {
                buffer[1] = 'e';
                return writeExponent (&buffer[2], kk - 1);
            }
            else
            {
                if (length - 1 <= 16)
                {
                    char tmp[16];
                    memcpy (tmp, &buffer[1], 16);
                    memcpy (&buffer[2], tmp, 16);
                }
                else
                {
                    memmove (&buffer[2], &buffer[1], length - 1);
                }
                buffer[1] = '.';
                buffer[length + 1] = 'e';
                return writeExponent (&buffer[length + 2], kk - 1);
            }
        }
 
        inline char* format (char* buffer, uint64_t digits, int length, int k) noexcept
        {
            const int kk = length + k;
 
            if ((kk > 21) || (kk <= -6))
            {
                length -= writeDigits (buffer + 1, digits, length);
                buffer[0] = buffer[1];
                buffer[1] = '.';
                const int position = (length > 1) ? length + 1 : 1;
                buffer[position] = 'e';
                return writeExponent (&buffer[position + 1], kk - 1);
            }
 
            if (length <= kk)
            {
                writeDigits (buffer, digits, length);
                for (int i = length; i < kk; ++i)
                {
                    buffer[i] = '0';
                }
                buffer[kk] = '.';
                buffer[kk + 1] = '0';
                return &buffer[kk + 2];
            }
            else if (0 < kk)
            {
                length -= writeDigits (buffer + 1, digits, length);
                for (int i = 0; i < kk; ++i)
                {
                    buffer[i] = buffer[i + 1];
                }
                buffer[kk] = '.';
                return &buffer[length + 1];
            }
            else
            {
                const int offset = 2 - kk;
                buffer[0] = '0';
                buffer[1] = '.';
                for (int i = 2; i < offset; ++i)
                {
                    buffer[i] = '0';
                }
                length -= writeDigits (buffer + offset, digits, length);
                return &buffer[length + offset];
            }
        }
    }
}
 
#endif