if (type == NumberFormatType::ENGLISH || type == NumberFormatType::SYSTEM) {

try {

if (english_loc && type == NumberFormatType::ENGLISH)

ss.imbue(*english_loc);

else if (system_loc && type == NumberFormatType::SYSTEM)

ss.imbue(*system_loc);

} catch (std::exception &e) {

std::cerr << e.what() << std::endl;

}

}

if (type != NumberFormatType::SCIENTIFIC)

ss << std::fixed;

ss << std::setprecision(2);

static const size_t max_magnitude = sig_fig_db.size() - 1;

if (absnum <= 1)

return 0;

return std::min(max_magnitude, (size_t)std::floor(std::log2(absnum) * (1/std::log2(10))) + 1);

va_list lst;

va_start(lst, fmt);

std::string rv = stl_vsprintf(fmt, lst);

va_end(lst);

return rv;

/* Allow small (about single line) strings to be printed into stack memory

std::array<char,128> buf;

va_list args2;

va_copy(args2, args);

int rsz = vsnprintf(&buf[0], buf.size(), fmt, args2);

va_end(args2);

if (rsz < 0)

return std::string(); /* Error occurred */

if (static_cast<unsigned>(rsz) < buf.size())

return std::string(&buf[0], rsz); /* Whole string fits to a single line buffer */

std::string rv;

// Allocate enough memory for the output and null termination

rv.resize(rsz);

rsz = vsnprintf(&rv[0], rv.size()+1, fmt, args);

if (rsz < static_cast<int>(rv.size()))

rv.resize(std::max(rsz,0));

return rv;

const std::string &str, const std::string &separator, bool squash_empty)

{

out->clear();

size_t start = 0, pos;

if (!separator.empty())

{

while ((pos = str.find(separator,start)) != std::string::npos)

{

if (pos > start || !squash_empty)

out->push_back(str.substr(start, pos-start));

start = pos + separator.size();

}

}

if (start < str.size() || !squash_empty)

out->push_back(str.substr(start));

return out->size() > 1;

{

std::stringstream ss;

for (size_t i = 0; i < items.size(); i++)

{

if (i)

ss << separator;

ss << items[i];

}

return ss.str();

{

switch (c)

{

case (char)129: // 'ü'

return (char)154; // 'Ü'

case (char)164: // 'ñ'

return (char)165; // 'Ñ'

case (char)132: // 'ä'

return (char)142; // 'Ä'

case (char)134: // 'å'

return (char)143; // 'Å'

case (char)130: // 'é'

return (char)144; // 'É'

case (char)148: // 'ö'

return (char)153; // 'Ö'

case (char)135: // 'ç'

return (char)128; // 'Ç'

case (char)145: // 'æ'

return (char)146; // 'Æ'

default: // toupper consistently across locales

return (c >= 'a' && c <= 'z') ? c - ('a' - 'A') : c;

}

{

switch (c)

{

case (char)154: // 'Ü'

return (char)129; // 'ü'

case (char)165: // 'Ñ'

return (char)164; // 'ñ'

case (char)142: // 'Ä'

return (char)132; // 'ä'

case (char)143: // 'Å'

return (char)134; // 'å'

case (char)144: // 'É'

return (char)130; // 'é'

case (char)153: // 'Ö'

return (char)148; // 'ö'

case (char)128: // 'Ç'

return (char)135; // 'ç'

case (char)146: // 'Æ'

return (char)145; // 'æ'

default: // tolower consistently across locales

return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;

}

{

std::string rv(str.size(),' ');

for (unsigned i = 0; i < str.size(); ++i)

rv[i] = toupper_cp437(str[i]);

return rv;

{

std::string rv(str.size(),' ');

for (unsigned i = 0; i < str.size(); ++i)

rv[i] = tolower_cp437(str[i]);

return rv;

{

std::string result;

result.reserve(str.size());

for (char c : str)

{

const char *mapped = normalized_table[(uint8_t)c];

if (mapped == NULL)

result += tolower(c);

else

while (*mapped != '\0')

{

result += tolower(*mapped);

++mapped;

}

}

return result;

{ // Cleaned up from g_src/basics.cpp, and returns new string

std::string out = str;

bool starting = true;

int32_t bracket_count = 0;

bool conf;

for (size_t s = 0; s < out.length(); s++)

{

if (out[s] == '[') { ++bracket_count; continue; }

else if (out[s] == ']') { --bracket_count; continue; }

else if (bracket_count > 0) continue;

conf = false;

if (!starting)

{

if (out[s - 1] == ' ' || out[s - 1] == '\"')

conf = true;

// Discount single quote if it isn't preceded by space, comma, or nothing

else if (out[s - 1] == '\'' && s >= 2 && (out[s - 2] == ' ' || out[s - 2] == ','))

conf = true;

}

if (starting || conf)

{ // Capitalize

out[s] = toupper_cp437(out[s]);

starting = false;

}

}

return out;

word_wrap_whitespace_mode mode)

{

if (line_length == 0)

line_length = SIZE_MAX;

std::string line;

size_t break_pos = 0;

bool ignore_whitespace = false;

for (auto &c : str)

{

if (c == '\n')

{

out->push_back(line);

line.clear();

break_pos = 0;

ignore_whitespace = (mode == WSMODE_TRIM_LEADING);

continue;

}

if (isspace(c))

{

if (ignore_whitespace || (mode == WSMODE_COLLAPSE_ALL && break_pos == line.length()))

continue;

line.push_back((mode == WSMODE_COLLAPSE_ALL) ? ' ' : c);

break_pos = line.length();

}

else

{

line.push_back(c);

ignore_whitespace = false;

}

if (line.length() > line_length)

{

if (break_pos > 0)

{

// Break before last space, and skip that space

out->push_back(line.substr(0, break_pos - 1));

}

else

{

// Single word is too long, just break it

out->push_back(line.substr(0, line_length));

break_pos = line_length;

}

line = line.substr(break_pos);

break_pos = 0;

ignore_whitespace = (mode == WSMODE_TRIM_LEADING);

}

}

if (line.length())

out->push_back(line);

return true;

{ // Cleaned up from g_src/basics.cpp, return string instead of bool

std::string out;

// Go until you hit compc, ']', or the end

for (auto s = source.begin() + pos; s < source.end(); ++s)

{

if (*s == compc || *s == ']')

break;

out += *s;

}

return out;

{

size_t ksize = key.size();

size_t psize = prefix.size();

if (ksize < psize || memcmp(prefix.data(), key.data(), psize) != 0)

return false;

if (tail)

tail->clear();

if (ksize == psize)

return true;

if (psize == 0 || prefix[psize-1] == '/')

{

if (tail) *tail = key.substr(psize);

return true;

}

if (key[psize] == '/')

{

if (tail) *tail = key.substr(psize+1);

return true;

}

return false;

{

struct timeval tv;

gettimeofday(&tv, NULL);

uint64_t ret = tv.tv_usec;

// Convert from micro seconds (10^-6) to milliseconds (10^-3)

ret /= 1000;

// Adds the seconds (10^0) after converting them to milliseconds (10^-3)

ret += (tv.tv_sec * 1000);

return ret;

{

FILETIME ft;

LARGE_INTEGER li;

// Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC)

// and copy it to a LARGE_INTEGER structure.

GetSystemTimeAsFileTime(&ft);

li.LowPart = ft.dwLowDateTime;

li.HighPart = ft.dwHighDateTime;

uint64_t ret = li.QuadPart;

// Convert from file time to UNIX epoch time.

ret -= 116444736000000000LL;

// From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals

ret /= 10000;

return ret;

uint32_t type = utf8d[byte];

*codep = (*state != UTF8_ACCEPT) ?

(byte & 0x3fu) | (*codep << 6) :

(0xff >> type) & (byte);

*state = utf8d[256 + *state + type];

return *state;

if (c <= 0x7F)

{

out[0] = c;

return 1;

}

else if (c <= 0x7FF)

{

out[0] = (0xC0 | (c >> 6));

out[1] = (0x80 | (c & 0x3F));

return 2;

}

else /*if (c <= 0xFFFF)*/

{

out[0] = (0xE0 | (c >> 12));

out[1] = (0x80 | ((c >> 6) & 0x3F));

out[2] = (0x80 | (c & 0x3F));

return 3;

}

{

std::string out;

out.reserve(in.size());

uint8_t buf[4];

for (size_t i = 0; i < in.size(); i++)

{

int cnt = encode(buf, character_table[(uint8_t)in[i]]);

out.append(&buf[0], &buf[cnt]);

}

return out;

{

// Unicode to normal lookup table

static std::map<uint32_t, char> ctable;

if (ctable.empty())

{

for (uint16_t i = 0; i < 256; i++)

if (character_table[i] != i)

ctable[character_table[i]] = char(i);

}

// Actual conversion loop

size_t size = in.size();

std::string out(size, char(0));

uint32_t codepoint = 0;

uint32_t state = UTF8_ACCEPT, prev = UTF8_ACCEPT;

uint32_t pos = 0;

for (unsigned i = 0; i < size; prev = state, i++) {

switch (decode(&state, &codepoint, uint8_t(in[i]))) {

case UTF8_ACCEPT:

if (codepoint < 256 && character_table[codepoint] == codepoint) {

out[pos++] = char(codepoint);

} else {

char v = ctable[codepoint];

out[pos++] = v ? v : '?';

}

break;

case UTF8_REJECT:

out[pos++] = '?';

if (prev != UTF8_ACCEPT) --i;

state = UTF8_ACCEPT;

break;

}

}

if (pos != size)

out.resize(pos);

return out;