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; } }