void
__NCPrint(
FILE* stream,
CFStringRef format,
va_list argv,
Boolean addNewline
)
{
CFDataRef externalRep;
CFStringRef string;
CFRange range = CFStringFind(format,CFSTR("%!"),0);
// Look for ANSI formatting directives:
if (range.location != kCFNotFound) {
format = __NCParseExtendedFormatString(format);
string = CFStringCreateWithFormatAndArguments(
kCFAllocatorDefault,
NULL,
format,
argv);
CFRelease(format);
} else {
string = CFStringCreateWithFormatAndArguments(
kCFAllocatorDefault,
NULL,
format,
argv);
}
if (string) {
externalRep = CFStringCreateExternalRepresentation(
kCFAllocatorDefault,
string,
CFCStringGetDefaultEncoding(),
'?');
CFRelease(string);
if (externalRep) {
if ( addNewline )
fprintf(stream,"%.*s\n",
(int)CFDataGetLength(externalRep),
(char*)CFDataGetBytePtr(externalRep)
);
else
fprintf(stream,"%.*s",
(int)CFDataGetLength(externalRep),
(char*)CFDataGetBytePtr(externalRep)
);
CFRelease(externalRep);
fflush(stream);
}
}
}
static CFErrorRef GTMCFLaunchCreateUnlocalizedError(CFIndex code,
CFStringRef format, ...) {
CFDictionaryRef user_info = NULL;
if (format) {
va_list args;
va_start(args, format);
CFStringRef string
= CFStringCreateWithFormatAndArguments(kCFAllocatorDefault,
NULL,
format,
args);
user_info = CFDictionaryCreate(kCFAllocatorDefault,
(const void **)&kCFErrorDescriptionKey,
(const void **)&string,
1,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFRelease(string);
va_end(args);
}
CFErrorRef error = CFErrorCreate(kCFAllocatorDefault,
kCFErrorDomainPOSIX,
code,
user_info);
if (user_info) {
CFRelease(user_info);
}
return error;
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if USE(CF) && !OS(WINDOWS)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
logToStderr(buffer);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#if USE(APPLE_SYSTEM_LOG)
va_list copyOfArgs;
va_copy(copyOfArgs, args);
asl_vlog(0, 0, ASL_LEVEL_NOTICE, format, copyOfArgs);
va_end(copyOfArgs);
#endif
// Fall through to write to stderr in the same manner as other platforms.
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (vsnprintf(buffer, size, format, args) != -1) {
OutputDebugStringA(buffer);
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
CFStringRef myCFStringCreateWithFormat(CFAllocatorRef allocator, CFDictionaryRef options, CFStringRef format, ...)
{
va_list args;
va_start(args, format);
CFStringRef str = CFStringCreateWithFormatAndArguments(allocator, options, format, args);
va_end(args);
return str;
}
void __security_debug(const char *scope, const char *function,
const char *file, int line, const char *format, ...)
{
#if !defined(NDEBUG)
pthread_once(&__security_debug_once, __security_debug_init);
CFStringRef scopeName = NULL;
/* Scope NULL is always enabled. */
if (scope) {
/* Check if the scope is enabled. */
if (scopeSet) {
scopeName = copyScopeName(scope, strlen(scope));
if (negate == CFSetContainsValue(scopeSet, scopeName)) {
CFRelease(scopeName);
return;
}
} else if (!negate) {
return;
}
}
CFStringRef formatStr = CFStringCreateWithCString(kCFAllocatorDefault,
format, kCFStringEncodingUTF8);
va_list args;
va_start(args, format);
CFStringRef message = CFStringCreateWithFormatAndArguments(
kCFAllocatorDefault, NULL, formatStr, args);
va_end(args);
time_t now = time(NULL);
char *date = ctime(&now);
date[19] = '\0';
CFStringRef logStr = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%s %-*s %s %@\n"), date + 4, MAX_SCOPE_LENGTH - 1,
scope ? scope : "", function, message);
CFShow(logStr);
char logMsg[4096];
if (CFStringGetCString(logStr, logMsg, sizeof(logMsg), kCFStringEncodingUTF8)) {
#if 0
asl_log(NULL, NULL, ASL_LEVEL_INFO, logMsg);
#else
aslmsg msg = asl_new(ASL_TYPE_MSG);
if (scope) {
asl_set(msg, ASL_KEY_FACILITY, scope);
}
asl_set(msg, ASL_KEY_LEVEL, ASL_STRING_INFO);
asl_set(msg, ASL_KEY_MSG, logMsg);
asl_send(NULL, msg);
asl_free(msg);
#endif
}
CFRelease(logStr);
CFRelease(message);
CFRelease(formatStr);
if (scopeName)
CFRelease(scopeName);
#endif
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#elif PLATFORM(BLACKBERRY)
BlackBerry::Platform::logV(BlackBerry::Platform::LogLevelInfo, format, args);
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
void CFLogWithPrefix(const char* prefix, CFLogLevel level,
CFStringRef format, va_list arguments)
{
if (level < _kCFLogLevelFirst || level >= _kCFLogLevelLast) {
return;
}
CFStringRef message = CFStringCreateWithFormatAndArguments(
kCFAllocatorSystemDefault,
NULL, format, arguments);
CFPlatformLog(prefix, level, message);
CFRelease(message);
}
void
CF_syslog(int level, CFStringRef message,...)
{
char buf[8192];
CFStringRef cooked_msg;
va_list ap;
va_start(ap, message);
cooked_msg = CFStringCreateWithFormatAndArguments(NULL, NULL, message, ap);
va_end(ap);
if (CFStringGetCString(cooked_msg, buf, sizeof(buf), kCFStringEncodingUTF8))
syslog(level, "%s", buf);
CFRelease(cooked_msg);
}
IOKIT_SC_SYMBOL(CFStringRef, SCDynamicStoreKeyCreate)(
CFAllocatorRef allocator,
CFStringRef fmt,
...
)
{
// Local implementation of a SCDynamicStore wrapper function
va_list val;
va_start(val, fmt);
CFStringRef key =
CFStringCreateWithFormatAndArguments(allocator, NULL, fmt, val);
va_end(val);
return key;
}
void show(CFStringRef formatString, ...) {
CFStringRef resultString;
CFDataRef data;
va_list argList;
va_start(argList, formatString);
resultString = CFStringCreateWithFormatAndArguments(NULL, NULL, formatString, argList);
va_end(argList);
data = CFStringCreateExternalRepresentation(NULL, resultString, CFStringGetSystemEncoding(), '?');
if (data != NULL) {
printf ("%.*s\n\n", (int)CFDataGetLength(data), CFDataGetBytePtr(data));
CFRelease(data);
}
CFRelease(resultString);
}
static void
CFPrintf(CFStringRef format, ...)
{
CFStringRef cfstring;
va_list argList;
va_start(argList, format);
cfstring = CFStringCreateWithFormatAndArguments(NULL, NULL, format, argList);
va_end(argList);
CFIndex cfstringSize = CFStringGetLength(cfstring);
CFIndex stringSize = CFStringGetMaximumSizeForEncoding(cfstringSize, kCFStringEncodingUTF8) + 1;
char *string = malloc(stringSize);
if (CFStringGetCString(cfstring, string, stringSize, kCFStringEncodingUTF8)) {
printf("%s", string);
}
free(string);
}
void secdebug_internal(const char* scope, const char* format, ...)
{
if (__builtin_expect(SECURITY_DEBUG_LOG_ENABLED(), 0))
{
va_list list;
va_start(list, format);
CFStringRef formatString = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef message = CFStringCreateWithFormatAndArguments(kCFAllocatorDefault, NULL, formatString, list);
CFRelease(formatString);
CFIndex maxLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(message), kCFStringEncodingUTF8) + 1;
char buffer[maxLength];
CFStringGetCString(message, buffer, sizeof(buffer), kCFStringEncodingUTF8);
CFRelease(message);
SECURITY_DEBUG_LOG((char *)(scope), (buffer));
va_end(list);
}
}
static void logIt(CFStringRef format, ...) {
va_list args;
va_start(args, format);
CFStringRef str = CFStringCreateWithFormatAndArguments(kCFAllocatorSystemDefault, NULL, format, args);
if (!str) return;
CFIndex blen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char *buf = str ? (char *)malloc(blen + 1) : 0;
if (buf) {
Boolean converted = CFStringGetCString(str, buf, blen, kCFStringEncodingUTF8);
if (converted) {
// null-terminate
buf[blen] = 0;
printf("%s\n", buf);
}
}
if (buf) free(buf);
if (str) CFRelease(str); va_end(args);
}
static jint JNICALL java_vfprintf(FILE *fp, const char *format, va_list args)
{
jint result = 0;
CFStringRef formatRef = CFStringCreateWithCString(NULL, format, kCFStringEncodingASCII);
if (formatRef) {
CFStringRef text = CFStringCreateWithFormatAndArguments(NULL, NULL, formatRef, args);
CFRelease(formatRef);
if (text) {
ConsoleMessage* message = new ConsoleMessage(text);
if (message) {
if (message->send() != noErr)
delete message;
}
result = ::CFStringGetLength(text);
::CFRelease(text);
}
}
return result;
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
} else
#elif COMPILER(MSVC)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
OutputDebugStringA(buffer);
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
// We can't use String::format for two reasons:
// 1) It doesn't handle non-ASCII characters in the format string.
// 2) It doesn't handle the %2$d syntax.
// Note that because |format| is used as the second parameter to va_start, it cannot be a reference
// type according to section 18.7/3 of the C++ N1905 standard.
static String formatLocalizedString(String format, ...)
{
#if USE(CF)
va_list arguments;
va_start(arguments, format);
RetainPtr<CFStringRef> formatCFString(AdoptCF, format.createCFString());
RetainPtr<CFStringRef> result(AdoptCF, CFStringCreateWithFormatAndArguments(0, 0, formatCFString.get(), arguments));
va_end(arguments);
return result.get();
#elif PLATFORM(QT)
va_list arguments;
va_start(arguments, format);
QString result;
result.vsprintf(format.latin1().data(), arguments);
va_end(arguments);
return result;
#else
notImplemented();
return format;
#endif
}
// We can't use String::format for two reasons:
// 1) It doesn't handle non-ASCII characters in the format string.
// 2) It doesn't handle the %2$d syntax.
// Note that because |format| is used as the second parameter to va_start, it cannot be a reference
// type according to section 18.7/3 of the C++ N1905 standard.
static String formatLocalizedString(String format, ...)
{
#if USE(CF)
va_list arguments;
va_start(arguments, format);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
RetainPtr<CFStringRef> result = adoptCF(CFStringCreateWithFormatAndArguments(0, 0, format.createCFString().get(), arguments));
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
va_end(arguments);
return result.get();
#else
notImplemented();
return format;
#endif
}
static void vprintf_stderr_common(const char* format, va_list args)
{
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
} else
#if OS(SYMBIAN)
vfprintf(stdout, format, args);
#else
vfprintf(stderr, format, args);
#endif
}
static void fprint_string(FILE *file, CFStringRef string) {
UInt8 buf[256];
CFRange range = { .location = 0 };
range.length = CFStringGetLength(string);
while (range.length > 0) {
CFIndex bytesUsed = 0;
CFIndex converted = CFStringGetBytes(string, range, kCFStringEncodingUTF8, 0, false, buf, sizeof(buf), &bytesUsed);
fwrite(buf, 1, bytesUsed, file);
range.length -= converted;
range.location += converted;
}
}
static void cffprint(FILE *file, CFStringRef fmt, ...) CF_FORMAT_FUNCTION(2,0);
static void cffprint(FILE *file, CFStringRef fmt, ...) {
va_list args;
va_start(args, fmt);
CFStringRef line = CFStringCreateWithFormatAndArguments(NULL, NULL, fmt, args);
va_end(args);
fprint_string(file, line);
CFRelease(line);
}
void DebugMessage(int level, __DEBUGSTR_ARG__ format, ...)
{
va_list args;
CFIndex index;
CFStringRef cfstr = NULL;
const char * cstr = NULL;
char * buffer = NULL;
if (gDebugEnabled)
{
_DebugEnter();
if (!gPreflighted)
DebugPreflight(NULL, false, DEBUG_LEVEL_ERROR, 0);
// Format the string, accepting %@ qualifier for CFType/NSObject
va_start(args, format);
cfstr = CFStringCreateWithFormatAndArguments(
kCFAllocatorDefault, NULL, format, args);
va_end(args);
// Convert the opaque CFStringRef to a UTF8 buffer
if (cfstr)
{
#if ! DEBUG_SHORTEN_PATHS
// Try for the fast case, fall back to buffering otherwise
cstr = CFStringGetCStringPtr(cfstr, kCFStringEncodingUTF8);
#endif // ! DEBUG_SHORTEN_PATHS
if (!cstr)
{
// Maximum conversion per UTF8 character = 4 bytes
size_t buflen = CFStringGetLength(cfstr) * 4 + 1;
if ((buffer = malloc(CFStringGetLength(cfstr) * 4 + 1)) &&
CFStringGetCString(cfstr, buffer, buflen, kCFStringEncodingUTF8))
{
#if DEBUG_SHORTEN_PATHS
cstr = _DebugShortenPath(buffer);
#else
cstr = buffer;
#endif // DEBUG_SHORTEN_PATHS
}
}
}
if (cstr)
{
char stamp[24] = "";
const char * eol = "";
// Optionally prefix the entry with a timestamp
if (gDebugStamp)
{
struct tm ltime;
time_t now = time(NULL);
strftime(stamp, sizeof(stamp), "[%F %T] ", localtime_r(&now, <ime));
}
// Append a trailing linefeed if necessary
index = CFStringGetLength(format);
if (index && (CFStringGetCharacterAtIndex(format,index-1) != '\n'))
eol = "\n";
// Print out the requested message
fprintf(gOutputFILE, "%s%s%s", stamp, cstr, eol);
}
_DebugLeave();
// Free any allocated buffers
if (cfstr) CFRelease(cfstr);
free(buffer);
}
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
} else
#elif PLATFORM(BREWMP)
// When str is 0, the return value is the number of bytes needed
// to accept the result including null termination.
int size = vsnprintf(0, 0, format, args);
if (size > 0) {
Vector<char> buffer(size);
vsnprintf(buffer.data(), size, format, args);
printLog(buffer);
}
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
#if OS(SYMBIAN)
vfprintf(stdout, format, args);
#else
vfprintf(stderr, format, args);
#endif
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if OS(DARWIN)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#ifdef __clang__
#pragma clang diagnostic pop
#endif
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
#if !PLATFORM(APOLLO)
fputs(buffer, stderr);
#endif
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
} else
#elif COMPILER(MSVC) && !defined(WINCEBASIC)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
#if OS(SYMBIAN)
vfprintf(stdout, format, args);
#else
vfprintf(stderr, format, args);
#endif
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if USE(CF) && !OS(WINDOWS)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
#if USE(APPLE_SYSTEM_LOG)
asl_log(0, 0, ASL_LEVEL_NOTICE, "%s", buffer);
#endif
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#if USE(APPLE_SYSTEM_LOG)
va_list copyOfArgs;
va_copy(copyOfArgs, args);
asl_vlog(0, 0, ASL_LEVEL_NOTICE, format, copyOfArgs);
va_end(copyOfArgs);
#endif
// Fall through to write to stderr in the same manner as other platforms.
#elif PLATFORM(BLACKBERRY)
BBLOGV(BlackBerry::Platform::LogLevelCritical, format, args);
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
#if !PLATFORM(BLACKBERRY)
vfprintf(stderr, format, args);
#endif
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if USE(CF) && !OS(WIN)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
#if USE(APPLE_SYSTEM_LOG)
asl_log(0, 0, ASL_LEVEL_NOTICE, "%s", buffer);
#endif
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#if USE(APPLE_SYSTEM_LOG)
va_list copyOfArgs;
va_copy(copyOfArgs, args);
asl_vlog(0, 0, ASL_LEVEL_NOTICE, format, copyOfArgs);
va_end(copyOfArgs);
#endif
// Fall through to write to stderr in the same manner as other platforms.
#elif OS(ANDROID)
__android_log_vprint(ANDROID_LOG_WARN, "WebKit", format, args);
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if 1 // def MINIBLINK_NOT_IMPLEMENTED
int cbMultiByte = (int)strlen(buffer);
DWORD dwMinSize = MultiByteToWideChar(CP_UTF8, 0, buffer, cbMultiByte, NULL, 0);
WCHAR* wbuffer = (WCHAR*)malloc((dwMinSize + 1) * sizeof(WCHAR));
memset(wbuffer, 0, (dwMinSize + 1) * sizeof(WCHAR));
MultiByteToWideChar(CP_UTF8, 0, buffer, cbMultiByte, wbuffer, dwMinSize);
OutputDebugStringW(wbuffer);
free(wbuffer);
#else
String utf8 = String::fromUTF8(buffer);
OutputDebugStringW(utf8.charactersWithNullTermination().data());
#endif // MINIBLINK_NOT_IMPLEMENTED
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
static void vprintf_stderr_common(bool shouldAssert, const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#elif PLATFORM(BREWMP)
// When str is 0, the return value is the number of bytes needed
// to accept the result including null termination.
int size = vsnprintf(0, 0, format, args);
if (size > 0) {
Vector<char> buffer(size);
vsnprintf(buffer.data(), size, format, args);
printLog(buffer);
}
#elif PLATFORM(EA)
if (JSLogCallback logger = JSGetLogCallback())
{
eastl::string8 str;
str.sprintf_va_list(format, args);
logger(str, shouldAssert);
}
#if _DEBUG //Print a log in debug in case the logger does not exist yet (For example,Assert before Init is called)
else
{
eastl::string8 str;
str.sprintf_va_list(format, args);
#if defined(_MSC_VER)
OutputDebugStringA(str.c_str());
OutputDebugStringA("\n");
#else
printf("%s", str.c_str());
printf("\n");
#endif
}
#endif //_DEBUG
return;
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
#if OS(SYMBIAN)
vfprintf(stdout, format, args);
#else
vfprintf(stderr, format, args);
#endif
}
