static
const LispString* GetIntegerArgument(LispEnvironment& aEnvironment, LispInt aStackTop, LispInt aArgNr)
{
const LispString* str = aEnvironment.iStack.GetElement(aStackTop + aArgNr)->String();
CheckArg(str, aArgNr, aEnvironment, aStackTop);
CheckArg(IsNumber(str->c_str(),false), aArgNr, aEnvironment, aStackTop);
return str;
}
void LispCharString(LispEnvironment& aEnvironment, LispInt aStackTop)
{
const LispString* str = ARGUMENT(1)->String();
CheckArg(str, 2, aEnvironment, aStackTop);
CheckArg(IsNumber(str->c_str(), false), 2, aEnvironment, aStackTop);
LispInt asciiCode = InternalAsciiToInt(*str);
LispChar ascii[4];
ascii[0] = '\"';
ascii[1] = (LispChar)asciiCode;
ascii[2] = '\"';
ascii[3] = '\0';
RESULT = (LispAtom::New(aEnvironment,ascii));
}
void LispLocalSymbols(LispEnvironment& aEnvironment, LispInt aStackTop)
{
LispInt nrArguments = InternalListLength(ARGUMENT(0));
LispInt nrSymbols = nrArguments-2;
std::vector<const LispString*> names(nrSymbols);
std::vector<const LispString*> localnames(nrSymbols);
LispInt uniquenumber = aEnvironment.GetUniqueId();
LispInt i;
for (i=0;i<nrSymbols;i++)
{
const LispString* atomname = Argument(ARGUMENT(0), i+1)->String();
CheckArg(atomname, i + 1, aEnvironment, aStackTop);
names[i] = atomname;
std::string newname = "$";
newname.append(*atomname);
newname.append(std::to_string(uniquenumber));
localnames[i] = aEnvironment.HashTable().LookUp(newname);
}
LocalSymbolBehaviour behaviour(aEnvironment, std::move(names), std::move(localnames));
LispPtr result;
InternalSubstitute(result, Argument(ARGUMENT(0), nrArguments-1), behaviour);
InternalEval(aEnvironment, RESULT, result);
}
bool
RunAsLauncherProcess(int& argc, wchar_t** argv)
{
// NB: We run all tests in this function instead of returning early in order
// to ensure that all side effects take place, such as clearing environment
// variables.
bool result = false;
#if defined(MOZ_LAUNCHER_PROCESS)
result = !IsSameBinaryAsParentProcess();
#endif // defined(MOZ_LAUNCHER_PROCESS)
if (mozilla::EnvHasValue("MOZ_LAUNCHER_PROCESS")) {
mozilla::SaveToEnv("MOZ_LAUNCHER_PROCESS=");
result = true;
}
result |= CheckArg(argc, argv, L"launcher",
static_cast<const wchar_t**>(nullptr),
CheckArgFlag::RemoveArg) == ARG_FOUND;
if (!result) {
// In this case, we will be proceeding to run as the browser.
// We should check MOZ_DEBUG_BROWSER_* env vars.
MaybeBreakForBrowserDebugging();
}
return result;
}
TreeExamples::TreeExamples(const Examples &other) {
schema_ = other.schema_;
auto otherAsTreeExamples = dynamic_cast<TreeExamples*>(&other);
if (otherAsTreeExamples != nullptr) {
features_ = move(otherAsTreeExamples->features_);
labels_ = move(otherAsTreeExamples->labels_);
weights_ = move(otherAsTreeExamples->weights_);
}
else {
cout << "Converting data format from row-based data to column-based ... ";
size_t dimension = schema_->Dimension();
positiveCounts_.resize(dimension);
positiveSums_.resize(dimension);
negativeCounts_.resize(dimension);
negativeSums_.resize(dimension);
vector<IntVec> featureColumns(dimension);
size_t n = 0;
for (Example& example : other) {
float label = example.Label;
labels_.push_back(example.Label);
float weight = example.Weight;
count_ += weight;
weights_.push_back(example.Weight);
double weightedLabel = weight * label;
sum_ += weightedLabel;
EnumeratePair ivPair = example.Features().AsEnumeratePair();
IntVec& indices = ivPair.first;
FloatVec& values = ivPair.second;
for (int i = 0; i < indices.size(); ++i) {
CheckArg(values[i] == 1, "The source dataset contains non-binary features.");
size_t c = indices[i];
featureColumns[c].Add(n);
positiveCounts_[c] += weight;
positiveSums_[c] += weightedLabel;
}
++n;
}
featureColumns_.resize(dimension);
for (int c = 0; c < dimension; ++c)
featureColumns_[c] = BinaryVector(n, featureColumns[c]);
cout << "done" << endl;
}
state_ = UREF<NoState>(new NoState());
}
bool
xplayerNPObject::GetDoubleFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
double& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Double))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_DOUBLE (arg)) {
_result = NPVARIANT_TO_DOUBLE (arg);
} else if (NPVARIANT_IS_INT32 (arg)) {
_result = double (NPVARIANT_TO_INT32 (arg));
}
return true;
}
bool
xplayerNPObject::GetObjectFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
NPObject*& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Object))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_STRING (arg)) {
_result = NPVARIANT_TO_OBJECT (arg);
} else if (NPVARIANT_IS_NULL (arg) ||
NPVARIANT_IS_VOID (arg)) {
_result = NULL;
}
return true;
}
bool
xplayerNPObject::GetInt32FromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
int32_t& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Int32))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_INT32 (arg)) {
_result = NPVARIANT_TO_INT32 (arg);
} else if (NPVARIANT_IS_DOUBLE (arg)) {
_result = int32_t (NPVARIANT_TO_DOUBLE (arg));
/* FIXMEchpe: overflow? */
}
return true;
}
bool
xplayerNPObject::GetNPStringFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
NPString& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_String))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_STRING (arg)) {
_result = NPVARIANT_TO_STRING (arg);
} else if (NPVARIANT_IS_NULL (arg) ||
NPVARIANT_IS_VOID (arg)) {
_result.UTF8Characters = NULL;
_result.UTF8Length = 0;
}
return true;
}
bool
xplayerNPObject::GetBoolFromArguments (const NPVariant* argv,
uint32_t argc,
uint32_t argNum,
bool& _result)
{
if (!CheckArg (argv, argc, argNum, NPVariantType_Bool))
return false;
NPVariant arg = argv[argNum];
if (NPVARIANT_IS_BOOLEAN (arg)) {
_result = NPVARIANT_TO_BOOLEAN (arg);
} else if (NPVARIANT_IS_INT32 (arg)) {
_result = NPVARIANT_TO_INT32 (arg) != 0;
} else if (NPVARIANT_IS_DOUBLE (arg)) {
_result = NPVARIANT_TO_DOUBLE (arg) != 0.0;
} else {
/* void/null */
_result = false;
}
return true;
}
INT IIS_ScanCmdl(INT argc, TEXTCHAR* argv[], const TEXTCHAR* str, ...)
{
INT i = 0;
INT found_and_set = 0;
INT nArgs = 0;
INT* switches_used = 0;
INT* b_str_opt = 0;
TEXTCHAR* s_str = 0;
TEXTCHAR* c_str_type = 0;
TEXTCHAR* str_clean = 0;
va_list ap;
if (argc == 0 || argc == 1)
{
FDKprintf("No command line arguments\n");
goto bail;
}
str_clean = (TEXTCHAR*) FDKcalloc((unsigned int)_tcslen(str), sizeof(TEXTCHAR));
if (str_clean == NULL) {
FDKprintf("Error allocating memory line %d, file %s\n", __LINE__, __FILE__);
return 0;
}
RemoveWhiteSpace(str, str_clean );
GetNumberOfArgs(str_clean, &nArgs);
b_str_opt = (INT*) FDKcalloc(nArgs, sizeof(INT));
s_str = (TEXTCHAR*) FDKcalloc(nArgs*CMDL_MAX_ARGC, sizeof(TEXTCHAR) );
c_str_type = (TEXTCHAR*) FDKcalloc(nArgs, sizeof(TEXTCHAR));
switches_used = (INT*) FDKcalloc(argc, sizeof(INT));
if (b_str_opt == NULL || s_str == NULL || c_str_type == NULL || switches_used == NULL) {
FDKprintf("Error allocating memory line %d, file %s\n", __LINE__, __FILE__);
goto bail;
}
if ( ParseString( str_clean, b_str_opt, s_str, c_str_type )) {
goto bail;
}
va_start(ap, str);
for ( i = 0; i < nArgs; i++ )
{
TEXTCHAR arg[CMDL_MAX_STRLEN] = {L'\0'};
TEXTCHAR* p_arg = arg;
TEXTCHAR* current_str = &(s_str[i*CMDL_MAX_ARGC]);
if (GetArgFromString(argc, argv, current_str, c_str_type[i], arg, switches_used )
&& !b_str_opt[i] )
{
#ifdef _UNICODE
_ftprintf(stderr, _TEXT("\n\nError: Parsing argument for required switch '%ls'.\n" ), current_str);
#else
_ftprintf(stderr, _TEXT("\n\nError: Parsing argument for required switch '%s'.\n" ), current_str);
#endif
found_and_set = 0;
goto bail;
}
if (CheckArg(p_arg, s_str, nArgs, c_str_type[i], current_str))
{
goto bail;
}
switch (c_str_type[i] )
{
case 's':
{
TEXTCHAR* tmp;
tmp = va_arg(ap, TEXTCHAR*);
if ( arg[0] == '\0' )
break;
_tcsncpy( tmp, arg, CMDL_MAX_STRLEN );
/* Remove quotes. Windows Mobile Workaround. */
removeQuotes(tmp);
found_and_set++;
break;
}
case 'd':
{
INT* tmp = va_arg(ap, INT*);
if ( arg[0] == '\0' )
break;
*tmp = _tcstol(arg, NULL, 0);
found_and_set++;
break;
}
case 'c':
{
char* tmp = va_arg(ap, char*);
if ( arg[0] == '\0' )
break;
*tmp = *arg;
found_and_set++;
break;
}
case 'u':
{
UCHAR* tmp = va_arg(ap, UCHAR*);
if ( arg[0] == '\0' )
break;
*tmp = _tstoi(arg);
found_and_set++;
break;
}
case 'f':
{
float* tmp = (float*) va_arg( ap,double*);
if ( arg[0] == '\0' )
break;
*tmp = (float) _tstof(arg);
found_and_set++;
break;
}
case 'y': // support 'data type double'
{
double* tmp = (double*) va_arg( ap,double*);
// use sscanf instead _tstof because of gcc
//_tstof(arg,"%lf",tmp); // '%lf' reads as double
*tmp = _tstof(arg); // '%lf' reads as double
found_and_set++;
break;
}
case '1':
{
INT* tmp = va_arg( ap, INT*);
if ( arg[0] == '\0' )
break;
*tmp = 1;
found_and_set++;
break;
}
default:
FDKprintfErr("Bug: unsupported data identifier \"%c\"\n", c_str_type[i]);
break;
}
}
va_end(ap);
CheckForUnusedSwitches(argc, /*argv,*/ switches_used);
bail:
if (b_str_opt) FDKfree(b_str_opt);
if (s_str) FDKfree(s_str);
if (c_str_type) FDKfree(c_str_type);
if (str_clean) FDKfree(str_clean);
if (switches_used) FDKfree(switches_used);
return found_and_set;
}
int wmain(int argc, wchar_t *argv[])
{
WCHAR path[MAX_PATH];
if (argc > 1 && !wcscmp(argv[1], L"-exec"))
{
WCHAR ** newArgs = new WCHAR*[argc+2];
newArgs[0] = argv[2];
DBG("\nPASS2: now run %ws\n", newArgs[0]);
int j=0;
for(int a=2; a < argc; a++)
{
DBG("\tArg[%d]: %ws\n", j, argv[a]);
newArgs[j++] = CheckArg(argv[a]);
}
newArgs[j] = 0;
int sts = _wspawnv(_P_OVERLAY, newArgs[0], newArgs);
return(sts);
//fprintf(stderr, "ERROR: failed to start %ws\n", newArgs[0]);
//return(1);
}
HMODULE hMod = GetModuleHandle(0);
GetModuleFileName(hMod, path,sizeof(path)-1);
HANDLE handle = CreateFile( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
DBG("CALLING EXEWRAP %ws - %ws\n", argv[0], path);
BY_HANDLE_FILE_INFORMATION bhf;
if (GetFileInformationByHandle(handle, &bhf))
{
WCHAR redPath[2*MAX_PATH+8];
DWORD bytesRead;
DWORD offset = bhf.nFileSizeLow - sizeof(redPath);
SetFilePointer(handle, offset, NULL, FILE_BEGIN);
ReadFile(handle, redPath, sizeof(redPath), &bytesRead, NULL);
WCHAR *p = redPath;
if (!memcmp(p, L"ABCD", sizeof(WCHAR)*4))
{
WCHAR *procName = p+4;
WCHAR *wrapperPath = p+8+MAX_PATH;
DBG("WRAP %ws, wrapper=%ws\n", procName, wrapperPath);
WCHAR ** newArgs = new WCHAR*[argc+4];
newArgs[0] = wrapperPath;
newArgs[1] = (wchar_t*) L"-exec";
newArgs[2] = procName;
int j=3;
for(int a=1; a < argc; a++)
{
DBG("\tArg[%d]: %ws\n", j, argv[a]);
newArgs[j++] = CheckArg(argv[a]);
}
newArgs[j] = 0;
DBG("RERUN %ws -exec %ws\n", wrapperPath, procName);
int sts = _wspawnv(_P_OVERLAY, newArgs[0], newArgs);
return(sts);
//fprintf(stderr, "ERROR: failed to wrap %ws\n", wrapperPath);
//return(1);
#if 0
//_wexecv((const wchar_t*) argv[0], (const wchar_t* const*)argv);
PROCESS_INFORMATION pi;
STARTUPINFO si;
bool bOK = CreateProcess(
0,
procName,
0,
0,
FALSE,
0, // CREATE_SUSPENDED | CREATE_NEW_CONSOLE,
0,
0,
&si,
&pi);
if (!bOK)
printf("FAILED to create proc: %ws\n", procName);
else
printf("started proc: %ws\n", procName);
#endif
}
}
//printf("IN=%s, PROG=%s, myPID=%d\n", argv[0], prog, getpid());
//argv[0] = prog;
//spawnv(_P_WAIT, argv[0], argv);
//printf("failed to exec %s\n", argv[0]);
return(0);
}
static int bfddMain(int argc, char *argv[])
{
int argIndex;
SockAddr connectAddr;
const char *valueString;
//gLog.LogToFile("/tmp/bfd.log");
UtilsInit();
gLog.LogToSyslog("bfdd-control", false);
gLog.Optional(Log::App, "Startup %x", getpid());
//Parse command line options
for (argIndex = 1; argIndex < argc; argIndex++)
{
if (0 == strcmp("--altport", argv[argIndex]))
{
if (connectAddr.IsValid())
{
fprintf(stderr, "Only a single --altport or --control option is allowed.\n");
exit(1);
}
// Backwards compatability only ... use --control
connectAddr.FromString("127.0.0.1", ALT_PORTNUM);
}
else if (CheckArg("--control", argv[argIndex], &valueString))
{
if (!valueString || *valueString == '\0')
{
fprintf(stderr, "--control must be followed by an '=' and a ip address with a port.\n");
exit(1);
}
if (!connectAddr.FromString(valueString))
{
fprintf(stderr, "--control address <%s> is not an IPv4 or IPv6 address.\n", valueString);
exit(1);
}
if (!connectAddr.HasPort())
{
fprintf(stderr, "--control address must have a port specified. The address <%s> does not conatin a port.\n", valueString);
exit(1);
}
}
else if (0 == strncmp("--", argv[argIndex], 2))
{
fprintf(stderr, "Unrecognized %s command line option %s.\n", ControlAppName, argv[argIndex]);
exit(1);
}
else
break;
}
if (argIndex >= argc)
{
fprintf(stderr, "No command. Try \"man %s\" for a list of commands.\n", ControlAppName);
exit(1);
}
// "version" is special because we tell first. Than lest the beacon handle it.
if (0 == strcmp(argv[argIndex], "version"))
{
fprintf(stdout, "%s v%s\n", ControlAppName, SofwareVesrion);
}
if (!connectAddr.IsValid())
connectAddr.FromString("127.0.0.1", PORTNUM);
// "load" is special because we send a series of commands..
if (0 == strcmp(argv[argIndex], "load"))
{
argIndex++;
if (argIndex >= argc)
{
fprintf(stderr, "Must supply a script file after 'load'\n");
exit(1);
}
fprintf(stdout, "Running script from file <%s>\n", argv[argIndex]);
if (!doLoadScript(argv[argIndex], connectAddr))
{
fprintf(stderr, "Script load failed.\n");
exit(1);
}
fprintf(stdout, "Completed script from file <%s>\n", argv[argIndex]);
exit(0);
}
// To allow for quotes, we concatenate all the arguments, separating them with
// "NULL".
vector<char> buffer;
buffer.reserve(MaxCommandSize);
for (; argIndex < argc; argIndex++)
{
AddParamToBuffer(buffer, argv[argIndex]);
}
if (buffer.size() == 0)
{
fprintf(stderr, "No command. Try \"man %s\" for a list of commands.\n", ControlAppName);
exit(1);
}
// argIndex is double null terminated.
buffer.push_back('\0');
if (!SendData(&buffer.front(), buffer.size(), connectAddr))
exit(1);
exit(0);
}
//
// Info::trStmnt_Move_W
//
void Info::trStmnt_Move_W()
{
CheckArgC(stmnt, 2);
CheckArg(stmnt->args[0], stmnt->pos);
CheckArg(stmnt->args[1], stmnt->pos);
switch(stmnt->args[0].a)
{
case IR::ArgBase::GblArr:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk:
trStmnt_Move_W__Arr_Stk(stmnt->args[0].aGblArr);
break;
default: goto badcase;
}
break;
case IR::ArgBase::GblReg:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk: break;
default: goto badcase;
}
break;
case IR::ArgBase::LocReg:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk: break;
default: goto badcase;
}
break;
case IR::ArgBase::MapArr:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk:
trStmnt_Move_W__Arr_Stk(stmnt->args[0].aMapArr);
break;
default: goto badcase;
}
break;
case IR::ArgBase::MapReg:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk: break;
default: goto badcase;
}
break;
case IR::ArgBase::Nul:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk: break;
default: goto badcase;
}
break;
case IR::ArgBase::Stk:
switch(stmnt->args[1].a)
{
case IR::ArgBase::GblReg: break;
case IR::ArgBase::LocReg: break;
case IR::ArgBase::MapReg: break;
case IR::ArgBase::WldReg: break;
case IR::ArgBase::Lit: break;
case IR::ArgBase::GblArr:
trStmnt_Move_W__Stk_Arr(stmnt->args[1].aGblArr);
break;
case IR::ArgBase::MapArr:
trStmnt_Move_W__Stk_Arr(stmnt->args[1].aMapArr);
break;
case IR::ArgBase::WldArr:
trStmnt_Move_W__Stk_Arr(stmnt->args[1].aWldArr);
break;
default: goto badcase;
}
break;
case IR::ArgBase::WldArr:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk:
trStmnt_Move_W__Arr_Stk(stmnt->args[0].aWldArr);
break;
default: goto badcase;
}
break;
case IR::ArgBase::WldReg:
switch(stmnt->args[1].a)
{
case IR::ArgBase::Stk: break;
default: goto badcase;
}
break;
default:
badcase:
std::cerr << "ERROR: " << stmnt->pos << ": bad Code::Move_W("
<< stmnt->args[0].a << ',' << stmnt->args[1].a << ")\n";
throw EXIT_FAILURE;
}
}
