jeanlemotan/EASTL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First

Browse Source
This commit is contained in:
jeanlemotan
2024-07-02 18:10:39 +02:00
commit 48ab06b1d9
733 changed files with 321088 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/packages/EAMain/source/EAMain.cpp
+749
View File
@@ -0,0 +1,749 @@
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
///////////////////////////////////////////////////////////////////////////////
#ifdef _MSC_VER
#pragma warning(disable: 4530 4548 4509)
#pragma warning(disable: 6320) // Exception-filter expression is the constant EXCEPTION_EXECUTE_HANDLER.
#pragma warning(disable: 4472 4355) // additional warnings generated by XDK with VS2015
#endif
#include <EAAssert/eaassert.h>
#include <EAMain/EAMain.h>
#include <eathread/eathread.h>
#include <eathread/eathread_atomic.h>
#ifdef EA_PLATFORM_ANDROID
#include <eathread/eathread_futex.h>
#endif
#include <EAStdC/EAString.h>
#include <EAStdC/EASprintf.h>
#include <EAStdC/EADateTime.h>
#include <EAStdC/EAProcess.h>
#include <EAMain/internal/EAMainStartupShutdown.h>
#include <EAMain/internal/EAMainPrintManager.h>
#include <EABase/eabase.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <stdarg.h>
#if defined(EA_PLATFORM_MICROSOFT)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <Windows.h>
#elif defined(__APPLE__) // OS X, iPhone, iPad, etc.
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sysctl.h>
#import <mach/mach.h>
#import <mach/mach_host.h>
#elif defined(EA_PLATFORM_BSD)
#include <sys/types.h>
#include <sys/ptrace.h>
#elif defined(EA_HAVE_SYS_PTRACE_H)
#include <unistd.h>
#include <sys/ptrace.h>
#elif defined(EA_PLATFORM_ANDROID)
#include <unistd.h>
#include <android/log.h>
#endif
EA_RESTORE_ALL_VC_WARNINGS()
///////////////////////////////////////////////////////////////////////////////
// EA_COMPILER_VA_COPY_REQUIRED
//
// This is already present in EABase version >= 2.00.40a report may not cause a flush
// See EABase for documentation.
//
#ifndef EA_COMPILER_VA_COPY_REQUIRED
#if (EABASE_VERSION_N < 20040) // If not already handled by EABase...
#if ((defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__)) && (!defined(__i386__) || defined(__x86_64__)) && !defined(__ppc__) && !defined(__PPC__) && !defined(__PPC64__)
#define EA_COMPILER_VA_COPY_REQUIRED 1
#endif
#endif
#endif
namespace EA
{
namespace EAMain
{
namespace Internal
{
EAMAIN_API EAMainFunction gEAMainFunction;
/// ReportDefault
///
/// This is the default report function.
/// It does not append any newlines to the output nor does it require
/// the user to do so. It simply passes on the input to stdout.
/// If the user wants the output to have a newline, the user must supply it.
/// This allows the user to report multiple text items to the same line if desired.
/// It does not send the input to stderr, as the output of a unit test
/// is deemed to be test results (success or failure) and not errors.
///
#ifdef EA_PLATFORM_ANDROID
static const size_t ANDROID_REPORT_BUFFER_SIZE = 1023;
static char gAndroidReportBuffer[ANDROID_REPORT_BUFFER_SIZE + 1];
static char *gAndroidReportBufferWritePtr = gAndroidReportBuffer;
static EA::Thread::Futex gBufferFutex;
static EA::Thread::ThreadTime gLastThreadTime = EA::Thread::kTimeoutImmediate;
static EA::Thread::ThreadTime gMinTimeBetweenPrints = EA::Thread::ThreadTime(1);
// This function assumes that the buffer futex above is held
// prior to entry. Please ensure that the buffer futex is either
// held by the calling code.
static void FlushAndroidReportBuffer()
{
if (gAndroidReportBufferWritePtr != gAndroidReportBuffer)
{
*gAndroidReportBufferWritePtr = 0;
__android_log_write(ANDROID_LOG_INFO, "EAMain", gAndroidReportBuffer);
// We found that if the OS is spammed too quickly with log info, it stops taking output from the app
// because it thinks it's a DDOS attack. So we sleep to give the OS time in the case the last
// log output was too recent.
EA::Thread::ThreadTime currentTime = EA::Thread::GetThreadTime();
if (gLastThreadTime != EA::Thread::kTimeoutImmediate &&
((currentTime - gLastThreadTime) < gMinTimeBetweenPrints))
{
EA::Thread::ThreadSleep(gMinTimeBetweenPrints);
}
gLastThreadTime = currentTime;
gAndroidReportBufferWritePtr = gAndroidReportBuffer;
}
}
static void AppendToReportBuffer(char8_t c)
{
char *ptr = gAndroidReportBufferWritePtr;
char *end = &gAndroidReportBuffer[ANDROID_REPORT_BUFFER_SIZE];
if (ptr >= end)
{
FlushAndroidReportBuffer();
}
*gAndroidReportBufferWritePtr++ = c;
}
static void AndroidReport(const char8_t *pMessage)
{
using namespace EA::StdC;
using namespace EA::Thread;
AutoFutex autoFutex(gBufferFutex);
size_t messageLength = Strlen(pMessage);
for (size_t i = 0; i < messageLength; ++i)
{
char8_t c = pMessage[i];
switch (c)
{
case '\n':
FlushAndroidReportBuffer();
break;
default:
AppendToReportBuffer(c);
break;
}
}
}
#endif
static void ReportDefault(const char8_t* pMessage)
{
if (!pMessage)
{
return;
}
// It's possible that the underlying print back end can't handle large
// output sizes. For example, the OutputDebugStringA call below drops
// chars beyond about 4096.
size_t length = EA::StdC::Strlen(pMessage); // It might be faster to make a custom Strlen which quits after N chars.
const size_t kMaxLength = 1024;
if(length > kMaxLength)
{
for(size_t i = 0, copiedLength = 0; i < length; i += copiedLength)
{
char8_t buffer[kMaxLength + 1];
size_t c;
copiedLength = ((length - i) >= kMaxLength) ? kMaxLength : (length - i);
for(c = 0; c < copiedLength; c++)
buffer[c] = pMessage[i + c];
buffer[c] = 0;
ReportDefault(buffer);
}
}
else
{
#if defined(EA_PLATFORM_MICROSOFT) && !defined(CS_UNDEFINED_STRING) // No need to do this for Microsoft console platforms, as the fputs below covers that.
OutputDebugStringA(pMessage);
#endif
#if defined(EA_PLATFORM_ANDROID)
// Android doesn't implement stdio (e.g. fputs), though sometimes we use compiler
// linking statements to redirect stdio functions to our own implementations which
// allow it to work.
//
// __android_log_write can write only 512 bytes at a time. Normally we don't write
// so much text in unit test output, but if this becomes a problem then we can loop
// and write blocks of the output. The primary downside to such an approach is that
// __android_log_write appends a \n to your output for each call. See the EAStdC
// EASprintfCore.cpp code for example loop code.
AndroidReport(pMessage);
#else
fputs(pMessage, stdout);
fflush(stdout);
#endif
}
}
EAMAIN_API const char *ExtractPrintServerAddress(int argc, char **argv)
{
CommandLine commandLine(argc, argv);
const char *printServerAddress = NULL;
if (commandLine.FindSwitch("PrintServerIPAddress", false, &printServerAddress, 0, '=') >= 0)
{
if (EA::StdC::Strlen(printServerAddress) > 0)
{
return printServerAddress;
}
}
return NULL;
}
}
ReportFunction gpReportFunction = EA::EAMain::Internal::ReportDefault;
EAMAIN_API void SetReportFunction(ReportFunction pReportFunction)
{
gpReportFunction = pReportFunction;
}
EAMAIN_API ReportFunction GetReportFunction()
{
return gpReportFunction;
}
EAMAIN_API ReportFunction GetDefaultReportFunction()
{
using namespace EA::EAMain::Internal;
return ReportDefault;
}
///////////////////////////////////////////////////////////////////////////////
// GetVerbosity / SetVerbosity
///////////////////////////////////////////////////////////////////////////////
unsigned gVerbosity = 0; // 0 means to display just failures.
EAMAIN_API unsigned GetVerbosity()
{
return gVerbosity;
}
EAMAIN_API void SetVerbosity(unsigned verbosity)
{
gVerbosity = verbosity;
}
///////////////////////////////////////////////////////////////////////////////
// ReportVaList
//
static void ReportVaList(unsigned minVerbosity, ReportFunction pReportFunction, const char8_t* pFormat, va_list arguments)
{
if(pFormat && (GetVerbosity() >= minVerbosity))
{
#if defined(EA_PLATFORM_DESKTOP)
const int kBufferSize = 2048;
#else
const int kBufferSize = 512;
#endif
char buffer[kBufferSize];
#if defined(EA_COMPILER_VA_COPY_REQUIRED)
va_list argumentsSaved;
va_copy(argumentsSaved, arguments);
#endif
const int nReturnValue = EA::StdC::Vsnprintf(buffer, kBufferSize, pFormat, arguments);
if(!pReportFunction)
pReportFunction = gpReportFunction;
if(pReportFunction)
{
if((nReturnValue >= 0) && (nReturnValue < (int)kBufferSize))
pReportFunction(buffer);
else if(nReturnValue < 0) // If we simply didn't have enough buffer space.
{
pReportFunction("Invalid format specified.\n Format: ");
pReportFunction(pFormat);
}
else // Else we simply didn't have enough buffer space.
{
char* pBuffer = static_cast<char *>(calloc(nReturnValue + 1, 1));
if(pBuffer)
{
#if defined(EA_COMPILER_VA_COPY_REQUIRED)
va_end(arguments);
va_copy(arguments, argumentsSaved);
#endif
EA::StdC::Vsnprintf(pBuffer, nReturnValue + 1, pFormat, arguments);
pReportFunction(pBuffer);
free(pBuffer);
}
else
pReportFunction("Unable to allocate buffer space for large printf.\n");
}
}
#if defined(EA_COMPILER_VA_COPY_REQUIRED)
// The caller will call va_end(arguments)
va_end(argumentsSaved);
#endif
}
}
///////////////////////////////////////////////////////////////////////////////
// Report
//
EAMAIN_API void Report(const char8_t* pFormat, ...)
{
va_list arguments;
va_start(arguments, pFormat);
ReportVaList(0, gpReportFunction, pFormat, arguments);
va_end(arguments);
}
///////////////////////////////////////////////////////////////////////////////
// ReportVerbosity
//
EAMAIN_API void ReportVerbosity(unsigned minVerbosity, const char8_t* pFormat, ...)
{
va_list arguments;
va_start(arguments, pFormat);
ReportVaList(minVerbosity, gpReportFunction, pFormat, arguments);
va_end(arguments);
}
///////////////////////////////////////////////////////////////////////////////
// VReport
//
EAMAIN_API void VReport(const char8_t* pFormat, va_list arguments)
{
ReportVaList(0, gpReportFunction, pFormat, arguments);
}
///////////////////////////////////////////////////////////////////////////////
// VReportVerbosity
//
EAMAIN_API void VReportVerbosity(unsigned minVerbosity, const char8_t* pFormat, va_list arguments)
{
ReportVaList(minVerbosity, gpReportFunction, pFormat, arguments);
}
///////////////////////////////////////////////////////////////////////////////
// PlatformStartup
//
EAMAIN_API void PlatformStartup()
{
// Routed to EAMainStartup to centralize
// the platform specific startup code.
PlatformStartup(NULL);
}
EAMAIN_API void PlatformStartup(int argc, char **argv)
{
const char *printServerNetworkAddress = Internal::ExtractPrintServerAddress(argc, argv);
PlatformStartup(printServerNetworkAddress);
}
EAMAIN_API void PlatformStartup(const char *printServerNetworkAddress)
{
// Routed to EAMainStartup to centralize
// the platform specific startup code.
EA::EAMain::Internal::EAMainStartup(printServerNetworkAddress);
}
///////////////////////////////////////////////////////////////////////////////
// PlatformShutdown
//
EAMAIN_API void PlatformShutdown(int errorCount)
{
#ifdef EA_PLATFORM_ANDROID
// The Android reporting functions will flush the output buffers
// when a newline is encountered. Calling AndroidReport with a
// single newline will cause any accumulated output to flush to
// the log.
//
// An alternative would be to call the FlushAndroidReportBuffer
// function but doing so would necessitate having separate locks
// for both FlushAndroidReportBuffer and AndroidReport, as both
// of these could be caused at the same time. To avoid this
// complication, FlushAndroidReportBuffer will only be called by
// AndroidReport or its children.
// -mburke
Internal::AndroidReport("\n");
#endif
// Routed to EAMainShutdown to centralize
// the platform specific shutdown code.
EA::EAMain::Internal::EAMainShutdown(errorCount);
}
///////////////////////////////////////////////////////////////////////////////
// CommandLine
///////////////////////////////////////////////////////////////////////////////
CommandLine::CommandLine(int argc, char** argv)
: mArgc(argc)
, mArgv(NULL)
, mCommandLine(NULL)
{
mArgv = static_cast<char **>(calloc(argc + 1, sizeof(char *)));
EA_ASSERT(mArgv != NULL);
for (int i = 0; i < argc; ++i)
{
mArgv[i] = argv[i];
}
mArgv[argc] = NULL;
// Microsoft fails to support argc/argv on Xenon. Sometimes it works; sometimes it doesn't.
}
CommandLine::CommandLine(const char *args)
: mArgc(0),
mArgv(NULL),
mCommandLine(NULL)
{
ParseCommandLine(args, FLAG_NONE);
}
CommandLine::CommandLine(const char *args, unsigned int flags)
: mArgc(0),
mArgv(NULL),
mCommandLine(NULL)
{
ParseCommandLine(args, flags);
}
CommandLine::~CommandLine()
{
if (mArgv)
{
free(mArgv);
mArgv = NULL;
}
if (mCommandLine)
{
free(mCommandLine);
mCommandLine = NULL;
}
}
/// Stristr
/// We implement this here because it isn't consistently present with all compiler-supplied C libraries.
static char* Stristr(const char* s1, const char* s2)
{
const char* cp = s1;
if(!*s2)
return (char*)s1;
while(*cp)
{
const char* s = cp;
const char* t = s2;
while(*s && *t && (tolower(*s) == tolower(*t)))
++s, ++t;
if(*t == 0)
return (char*)cp;
++cp;
}
return 0;
}
//Returns position switch is found at. Returns -1 if not found
int CommandLine::FindSwitch(const char* pSwitch, bool bCaseSensitive, const char** pResult, int nStartingIndex, char delimeter) const
{
const char8_t kSwitchIDs[] = { '-', '/' };
const int kSwitchIDCount = sizeof(kSwitchIDs)/sizeof(kSwitchIDs[0]);
static const char sEmptyString[] = { 0 };
if(nStartingIndex < 0)
{
nStartingIndex = 0;
}
if (pResult)
{
*pResult = sEmptyString;
}
// Here we move the input pSwitch past any one leading switch indicator such as '-'.
for(int i = 0; i < kSwitchIDCount; ++i)
{
if(*pSwitch == kSwitchIDs[i])
{
++pSwitch;
break;
}
}
const size_t nSwitchLength = strlen(pSwitch);
if (!nSwitchLength || (nStartingIndex >= mArgc))
return -1;
for(int i = nStartingIndex; i < mArgc; ++i)
{
const char *sCurrent = mArgv[i];
if(strlen(sCurrent) >= 2) // Enough, for example, for "-x".
{
int j;
// Make sure the string starts with a switch ID (e.g. '-').
for(j = 0; j < kSwitchIDCount; ++j)
{
if(sCurrent[0] == kSwitchIDs[j])
break;
}
if(j < kSwitchIDCount) // If a leading '-' was found...
{
const char* pCurrent = bCaseSensitive ? strstr(sCurrent + 1, pSwitch) : Stristr(sCurrent + 1, pSwitch);
const char* pCStr = sCurrent;
if(pCurrent == (pCStr + 1)) // If the user's input switch matched at least the start of the current argument switch...
{
pCurrent += nSwitchLength; // Move pCurrent past the input switch.
// At this point, we require that *pCurrent is either 0 or delimeter.
if((*pCurrent == 0) || (*pCurrent == delimeter))
{
// We have a match. Now possibly return a result string.
if(*pCurrent == delimeter)
{
if(*++pCurrent)
{
if(pResult)
{
*pResult = pCurrent;
}
}
}
return i;
}
}
}
}
}
return -1;
}
bool CommandLine::HasHelpSwitch() const
{
if((FindSwitch("-help", false, NULL, 0) >= 0) ||
(FindSwitch("-h", false, NULL, 0) >= 0) ||
(FindSwitch("-?", false, NULL, 0) >= 0))
{
return true;
}
return false;
}
void CommandLine::ParseCommandLine(const char *inputCommandLine, unsigned int flags)
{
size_t commandLineLength = strlen(inputCommandLine);
size_t allocSize = commandLineLength + 1;
size_t startOffset = 0;
if (flags & FLAG_NO_PROGRAM_NAME)
{
allocSize += 1;
startOffset = 1;
}
char *commandLine = static_cast<char *>(calloc(allocSize, 1));
EA_ASSERT(commandLine != NULL);
memcpy(commandLine + startOffset, inputCommandLine, commandLineLength);
int argc = 0;
char **argv = static_cast<char **>(calloc(MAX_COMMANDLINE_ARGS, sizeof(char *)));
EA_ASSERT(argv != NULL);
char *start = commandLine + startOffset;
char *ptr = start;
char *end = start + commandLineLength;
bool isQuoted = false;
const char quote = '"';
if (flags & FLAG_NO_PROGRAM_NAME)
{
argv[argc++] = commandLine;
}
while (ptr < end)
{
// The two cases this parser handles for quotes are:
// "this is a quoted parameter"; and
// -D:"this is a quoted parameter"
// The parser does not handle edge cases like
// "this is a quoted parameter"and"this is the same"
char *quoteStart = NULL;
for (;;)
{
while ((ptr < end) && !isspace((unsigned char)*ptr))
{
if (*ptr == quote && !isQuoted)
{
isQuoted = true;
quoteStart = ptr;
}
++ptr;
}
if (isQuoted)
{
if (*(ptr - 1) == quote)
{
// If we find a quote, shift the whole string back
// by one character, ie:
// -D:"this is a quoted parameter"
// becomes
// -D:this is a quoted parameter"
// The trailing quote is removed below when we place
// a null terminator at the end of our argument.
memmove(quoteStart, quoteStart + 1, (end - quoteStart));
--end;
ptr -= 2;
isQuoted = false;
break;
}
++ptr;
}
else
{
break;
}
}
if (ptr != start)
{
*ptr = 0;
argv[argc++] = start;
++ptr;
}
while ((ptr < end) && isspace((unsigned char)*ptr))
{
++ptr;
}
start = ptr;
}
mArgc = argc;
mArgv = argv;
mCommandLine = commandLine;
}
}
}
// WinRT-based Windows:
#if (defined(EA_PLATFORM_MICROSOFT) && !defined(CS_UNDEFINED_STRING) && !EA_WINAPI_FAMILY_PARTITION(EA_WINAPI_PARTITION_DESKTOP))
EA_DISABLE_VC_WARNING(4350 4571 4625 4626 4265)
#include <future>
EA_RESTORE_ALL_VC_WARNINGS()
extern "C" int EAMain(int argc, char** argv);
namespace EA
{
namespace EAMain
{
class WinRTRunner : public IWinRTRunner
{
private:
// The copy/assignment operator is explicitly inaccessible due to the base class 'IWinRTRunner' containing a member
// that is non-copyable (eg. std::future).
WinRTRunner(const WinRTRunner &);
WinRTRunner& operator=(const WinRTRunner &);
public:
WinRTRunner() {}
virtual void Run(int argc, char** argv) override
{
mResult = std::async(std::launch::async, [=]() {
const char *printServerAddress = Internal::ExtractPrintServerAddress(argc, argv);
EA::EAMain::Internal::EAMainStartup(printServerAddress);
int result = EA::EAMain::Internal::gEAMainFunction(argc, argv);
EA::EAMain::Internal::EAMainShutdown(result);
return result;
});
}
virtual bool IsFinished() override { return mResult.wait_for(std::chrono::milliseconds(33)) == std::future_status::ready; }
virtual void ReportResult() override
{
char output[100];
EA::StdC::Snprintf(output, EAArrayCount(output), "EXIT(%d)\n", mResult.get());
// Using OutputDebugStringA directly here as opposed to Report as someone may overload
// the default reporter. And this is what counts for EARunner to know what to do.
OutputDebugStringA(output);
}
std::future<int> mResult;
};
EAMAIN_API IWinRTRunner* CreateWinRTRunner()
{
return new WinRTRunner();
}
} // namespace EAMain
} // namespace EA
#endif // WinRT-based Windows