mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-17 05:44:08 -07:00
526 lines
12 KiB
C++
526 lines
12 KiB
C++
/* Copyright (c) 2010 Wildfire Games
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* implementation of sys_vswprintf.
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#if ARCH_IA32
|
|
|
|
/*
|
|
See http://www.opengroup.org/onlinepubs/009695399/functions/fprintf.html
|
|
for the specification (apparently an extension to ISO C) that was used
|
|
when creating this code.
|
|
*/
|
|
|
|
/*
|
|
Added features (compared to MSVC's printf):
|
|
Positional parameters (e.g. "%1$d", where '1' means '1st in the parameter list')
|
|
%lld (equivalent to %I64d in MSVC7.1, though it's supported natively by MSVC8)
|
|
|
|
Unsupported features (compared to a perfect implementation):
|
|
' <-- because MSVC doesn't support it
|
|
%S }
|
|
%C } because they're unnecessary and can cause confusion
|
|
* <-- probably works in some situations, but don't expect it to
|
|
*m$ <-- positional precision parameters, because they're not worthwhile
|
|
portability <-- just use GCC
|
|
efficiency <-- nothing in the spec says it should be as fast as possible
|
|
(the code could be made a lot faster if speed mattered more
|
|
than non-fixed size buffers)
|
|
|
|
*/
|
|
|
|
#ifndef _UNICODE
|
|
#define _UNICODE
|
|
#endif
|
|
#include <tchar.h>
|
|
#ifdef _UNICODE
|
|
# define tstring wstring
|
|
# define tstringstream wstringstream
|
|
#else
|
|
# define tstring string
|
|
# define tstringstream stringstream
|
|
#endif
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <stdio.h>
|
|
#include <sstream>
|
|
#include <stdarg.h>
|
|
|
|
#if MSC_VERSION < 1400
|
|
# define USE_I64_FORMAT 1
|
|
#else
|
|
# define USE_I64_FORMAT 0
|
|
#endif
|
|
|
|
enum
|
|
{
|
|
SPECFLAG_THOUSANDS = 1, // '
|
|
SPECFLAG_LEFTJUSTIFIED = 2, // -
|
|
SPECFLAG_SIGNED = 4, // +
|
|
SPECFLAG_SPACEPREFIX = 8, // <space>
|
|
SPECFLAG_ALTERNATE = 16, // #
|
|
SPECFLAG_ZEROPAD = 32 // 0
|
|
};
|
|
|
|
struct FormatChunk
|
|
{
|
|
virtual ~FormatChunk() { }
|
|
virtual int ChunkType() = 0; // 0 = FormatSpecification, 1 = FormatString
|
|
};
|
|
|
|
struct FormatVariable : public FormatChunk
|
|
{
|
|
int ChunkType() { return 0; }
|
|
int position; // undefined if the format includes no positional elements
|
|
char flags; // ['-+ #0]
|
|
int width; // -1 for *, 0 for unspecified
|
|
int precision; // -1 for *
|
|
int length; // "\0\0\0l", "\0\0hh", etc
|
|
char type; // 'd', etc
|
|
};
|
|
|
|
struct FormatString : public FormatChunk
|
|
{
|
|
int ChunkType() { return 1; }
|
|
FormatString(std::tstring t) : text(t) {}
|
|
std::tstring text;
|
|
};
|
|
|
|
|
|
int get_flag(TCHAR c)
|
|
{
|
|
switch (c)
|
|
{
|
|
case _T('\''): return SPECFLAG_THOUSANDS;
|
|
case _T('-'): return SPECFLAG_LEFTJUSTIFIED;
|
|
case _T('+'): return SPECFLAG_SIGNED;
|
|
case _T(' '): return SPECFLAG_SPACEPREFIX;
|
|
case _T('#'): return SPECFLAG_ALTERNATE;
|
|
case _T('0'): return SPECFLAG_ZEROPAD;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::tstring flags_to_string(char flags)
|
|
{
|
|
std::tstring s;
|
|
const char* c = "\'-+ #0";
|
|
for (int i=0; i<6; ++i)
|
|
if (flags & (1<<i))
|
|
s += c[i];
|
|
return s;
|
|
}
|
|
|
|
template<typename T>
|
|
std::tstring to_string(T n)
|
|
{
|
|
std::tstring s;
|
|
std::tstringstream str;
|
|
str << n;
|
|
str >> s;
|
|
return s;
|
|
}
|
|
|
|
int is_lengthmod(TCHAR c)
|
|
{
|
|
return
|
|
c == _T('h') ||
|
|
c == _T('l') ||
|
|
c == _T('j') ||
|
|
c == _T('z') ||
|
|
c == _T('t') ||
|
|
c == _T('L');
|
|
}
|
|
|
|
// _T2('l') == 'll'
|
|
#define _T2(a) ((a<<8) | a)
|
|
|
|
int type_size(TCHAR type, int length)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 'd':
|
|
case 'i':
|
|
switch (length)
|
|
{
|
|
case _T ('l'): return sizeof(long);
|
|
case _T2('l'): return sizeof(long long);
|
|
case _T ('h'): return sizeof(short);
|
|
case _T2('h'): return sizeof(char);
|
|
default: return sizeof(int);
|
|
}
|
|
case 'o':
|
|
case 'u':
|
|
case 'x':
|
|
case 'X': return sizeof(unsigned);
|
|
case 'f':
|
|
case 'F':
|
|
case 'e':
|
|
case 'E':
|
|
case 'g':
|
|
case 'G':
|
|
case 'a':
|
|
case 'A':
|
|
if (length == _T('L'))
|
|
return sizeof(long double);
|
|
else
|
|
return sizeof(double);
|
|
|
|
case 'c':
|
|
// "%lc" is a wide character, passed as a wint_t (ushort)
|
|
if (length == _T('l'))
|
|
return sizeof(wint_t);
|
|
// "%c" is an int, apparently
|
|
else
|
|
return sizeof(int);
|
|
|
|
case 's':
|
|
if (length == _T('l'))
|
|
return sizeof(wchar_t*);
|
|
else
|
|
return sizeof(char*);
|
|
|
|
case 'p':
|
|
return sizeof(void*);
|
|
|
|
case 'n':
|
|
return sizeof(int*);
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int sys_vswprintf(TCHAR* buffer, size_t count, const TCHAR* format, va_list argptr)
|
|
{
|
|
// To help quickly detect incorrect 'count' values, fill the buffer with 0s
|
|
memset(buffer, 0, count*sizeof(TCHAR));
|
|
|
|
/*
|
|
|
|
Format 'variable' specifications are (in pseudo-Perl regexp syntax):
|
|
|
|
% (\d+$)? ['-+ #0]? (* | \d+)? (. (* | \d*) )? (hh|h|l|ll|j|z|t|L)? [diouxXfFeEgGaAcspnCS%]
|
|
position flags width precision length type
|
|
|
|
*/
|
|
|
|
/**** Parse the format string into constant/variable chunks ****/
|
|
|
|
std::vector<FormatChunk*> specs;
|
|
std::tstring stringchunk;
|
|
|
|
TCHAR chr;
|
|
|
|
#define readchar(x) if ((x = *format++) == '\0') { delete s; goto finished_reading; }
|
|
|
|
while ((chr = *format++) != '\0')
|
|
{
|
|
if (chr == _T('%'))
|
|
{
|
|
// Handle %% correctly
|
|
if (*format == _T('%'))
|
|
{
|
|
stringchunk += _T('%');
|
|
continue;
|
|
}
|
|
|
|
// End the current string and start a new spec chunk
|
|
if (stringchunk.length())
|
|
{
|
|
specs.push_back(new FormatString(stringchunk));
|
|
stringchunk = _T("");
|
|
}
|
|
|
|
FormatVariable *s = new FormatVariable;
|
|
s->position = -1;
|
|
s->flags = 0;
|
|
s->width = 0;
|
|
s->precision = 0;
|
|
s->length = 0;
|
|
s->type = 0;
|
|
|
|
// Read either the position or the width
|
|
int number = 0;
|
|
|
|
while (1)
|
|
{
|
|
readchar(chr);
|
|
|
|
// Read flags (but not if it's a 0 appearing after other digits)
|
|
if (!number && get_flag(chr))
|
|
s->flags = (char)(s->flags|get_flag(chr));
|
|
|
|
// Read decimal numbers (position or width)
|
|
else if (isdigit(chr))
|
|
number = number*10 + (chr-'0');
|
|
|
|
// If we've reached a $, 'number' was the position,
|
|
// so remember it and start getting the width
|
|
else if (chr == _T('$'))
|
|
{
|
|
s->position = number;
|
|
number = 0;
|
|
}
|
|
|
|
// End of the number section
|
|
else
|
|
{
|
|
// Remember the width
|
|
s->width = number;
|
|
|
|
// Start looking for a precision
|
|
if (chr == _T('.'))
|
|
{
|
|
// Found a precision: read the digits
|
|
|
|
number = 0;
|
|
|
|
while (1)
|
|
{
|
|
readchar(chr);
|
|
|
|
if (isdigit(chr))
|
|
number = number*10 + (chr-'0');
|
|
else
|
|
{
|
|
s->precision = number;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finished dealing with any precision.
|
|
|
|
// Now check for length and type codes.
|
|
|
|
if (chr == _T('I'))
|
|
{
|
|
DEBUG_WARN_ERR(ERR::LOGIC); // MSVC-style \"%I64\" is not allowed!
|
|
}
|
|
|
|
if (is_lengthmod(chr))
|
|
{
|
|
s->length = chr;
|
|
|
|
// Check for ll and hh
|
|
if (chr == _T('l') || chr == _T('h'))
|
|
{
|
|
if (*format == chr)
|
|
{
|
|
s->length |= (chr << 8);
|
|
++format;
|
|
}
|
|
}
|
|
|
|
readchar(chr);
|
|
}
|
|
|
|
s->type = (char)chr;
|
|
|
|
specs.push_back(s);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stringchunk += chr;
|
|
}
|
|
}
|
|
|
|
#undef readchar
|
|
|
|
finished_reading:
|
|
|
|
if (stringchunk.length())
|
|
{
|
|
specs.push_back(new FormatString(stringchunk));
|
|
stringchunk = _T("");
|
|
}
|
|
|
|
/**** Build a new format string (to pass to the system printf) ****/
|
|
|
|
std::tstring newformat;
|
|
|
|
std::vector<int> varsizes; // stores the size of each variable type, to allow stack twiddling
|
|
|
|
typedef std::vector<FormatChunk*>::iterator ChunkIt;
|
|
|
|
for (ChunkIt it = specs.begin(); it != specs.end(); ++it)
|
|
{
|
|
if ((*it)->ChunkType() == 0)
|
|
{
|
|
FormatVariable* s = static_cast<FormatVariable*>(*it);
|
|
|
|
if (s->position > 0)
|
|
{
|
|
// Grow if necessary
|
|
if (s->position >= (int)varsizes.size())
|
|
varsizes.resize(s->position+1, -1);
|
|
// Store the size of the current type
|
|
varsizes[s->position] = type_size(s->type, s->length);
|
|
}
|
|
|
|
|
|
newformat += _T("%");
|
|
|
|
if (s->flags)
|
|
newformat += flags_to_string(s->flags);
|
|
|
|
if (s->width == -1)
|
|
newformat += '*';
|
|
else if (s->width)
|
|
newformat += to_string(s->width);
|
|
|
|
if (s->precision)
|
|
{
|
|
newformat += '.';
|
|
if (s->precision == -1)
|
|
newformat += '*';
|
|
else
|
|
newformat += to_string(s->precision);
|
|
}
|
|
|
|
if (s->length)
|
|
{
|
|
if (s->length > 256)
|
|
{
|
|
if (s->length == 0x00006c6c)
|
|
#if USE_I64_FORMAT
|
|
newformat += "I64";
|
|
#else
|
|
newformat += _T("ll");
|
|
#endif
|
|
else if (s->length == 0x00006868)
|
|
newformat += _T("hh");
|
|
}
|
|
else
|
|
{
|
|
newformat += (char) s->length;
|
|
}
|
|
}
|
|
|
|
newformat += s->type;
|
|
}
|
|
else
|
|
{
|
|
FormatString* s = static_cast<FormatString*>(*it);
|
|
newformat += s->text;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
varargs on x86:
|
|
|
|
All types are padded to 4 bytes, so size-in-stack == _INTSIZEOF(type).
|
|
No special alignment is required.
|
|
|
|
first+_INTSIZEOF(first) == first item in stack
|
|
|
|
Keep adding _INTSIZEOF(item) to get the next item
|
|
*/
|
|
|
|
// Because of those dangerous assumptions about varargs:
|
|
#if !ARCH_IA32
|
|
#error SLIGHTLY FATAL ERROR: Only x86 is supported!
|
|
#endif
|
|
|
|
// Highly efficient buffer to store the rearranged copy of the stack
|
|
std::string newstack;
|
|
|
|
std::vector< std::pair<char*, char*> > stackitems;
|
|
|
|
va_list arglist = argptr;
|
|
//va_start(arglist, format);
|
|
|
|
const u8* newstackptr;
|
|
|
|
if (varsizes.size())
|
|
{
|
|
|
|
for (size_t i = 1; i < varsizes.size(); ++i)
|
|
{
|
|
if (varsizes[i] <= 0)
|
|
{
|
|
DEBUG_WARN_ERR(ERR::LOGIC); // Invalid variable type somewhere - make sure all variable things are positional and defined
|
|
return -1;
|
|
}
|
|
|
|
// Based on _INTSIZEOF in stdarg.h:
|
|
// (Warning - slightly non-portable. But we use gcc's default printf
|
|
// when portability matters.)
|
|
#define INTSIZE(n) ( (n + sizeof(int) - 1) & ~(sizeof(int) - 1) )
|
|
|
|
size_t size = INTSIZE(varsizes[i]);
|
|
stackitems.push_back( std::pair<char*, char*>( arglist, arglist+size ));
|
|
arglist += size;
|
|
}
|
|
|
|
|
|
for (ChunkIt it = specs.begin(); it != specs.end(); ++it)
|
|
{
|
|
FormatChunk* chunk = *it;
|
|
if (chunk->ChunkType() == 0)
|
|
{
|
|
FormatVariable* s = static_cast<FormatVariable*>(chunk);
|
|
if (s->position <= 0)
|
|
{
|
|
DEBUG_WARN_ERR(ERR::LOGIC); // Invalid use of positional elements - make sure all variable things are positional and defined
|
|
return -1;
|
|
}
|
|
newstack += std::string( stackitems[s->position-1].first, stackitems[s->position-1].second );
|
|
}
|
|
}
|
|
|
|
newstackptr = (const u8*)newstack.c_str();
|
|
}
|
|
else
|
|
{
|
|
newstackptr = (const u8*)arglist;
|
|
}
|
|
|
|
for (ChunkIt it = specs.begin(); it != specs.end(); ++it)
|
|
if ((*it)->ChunkType() == 0)
|
|
delete static_cast<FormatVariable*>(*it);
|
|
else
|
|
delete static_cast<FormatString*>(*it);
|
|
|
|
int ret = _vsntprintf(buffer, count, newformat.c_str(), (va_list)newstackptr);
|
|
|
|
// For consistency with GCC's vsnprintf, make sure the buffer is null-terminated
|
|
// and return an error if that truncates the output
|
|
if(count > 0)
|
|
buffer[count-1] = '\0';
|
|
if (ret == (int)count)
|
|
return -1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif
|