// dnsResolve(host) javascript implementation static bool PACDnsResolve(JSContext *cx, unsigned int argc, JS::Value *vp) { JS::CallArgs args = CallArgsFromVp(argc, vp); if (NS_IsMainThread()) { NS_WARNING("DNS Resolution From PAC on Main Thread. How did that happen?"); return false; } JS::Rooted<JSString*> arg1(cx); if (!JS_ConvertArguments(cx, args, "S", arg1.address())) return false; nsDependentJSString hostName; nsAutoCString dottedDecimal; if (!hostName.init(cx, arg1)) return false; if (PACResolveToString(NS_ConvertUTF16toUTF8(hostName), dottedDecimal, 0)) { JSString *dottedDecimalString = JS_NewStringCopyZ(cx, dottedDecimal.get()); args.rval().setString(dottedDecimalString); } else { args.rval().setNull(); } return true; }
// dnsResolve(host) javascript implementation static bool PACDnsResolve(JSContext *cx, unsigned int argc, JS::Value *vp) { if (NS_IsMainThread()) { NS_WARNING("DNS Resolution From PAC on Main Thread. How did that happen?"); return false; } JS::Rooted<JSString*> arg1(cx); if (!JS_ConvertArguments(cx, argc, JS_ARGV(cx, vp), "S", arg1.address())) return false; nsDependentJSString hostName; nsAutoCString dottedDecimal; if (!hostName.init(cx, arg1)) return false; if (PACResolveToString(NS_ConvertUTF16toUTF8(hostName), dottedDecimal, 0)) { JSString *dottedDecimalString = JS_NewStringCopyZ(cx, dottedDecimal.get()); JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(dottedDecimalString)); } else { JS_SET_RVAL(cx, vp, JSVAL_NULL); } return true; }
const std::string& CmdServerStart::execute( const std::vector< std::string >& arguments ) { _cmdResult = ""; if ( arguments.size() < 1 ) { _cmdResult = getUsage(); return _cmdResult; } // get the full binary path std::string cmd = yaf3d::Application::get()->getFullBinPath(); std::string levelfile = arguments[ 0 ]; std::string arg1( "-server" ); std::string arg2( "-level" ); std::string arg3( levelfile ); // use utility function to start the server std::string args = arg1 + " " + arg2 + " " + arg3; YAF3D_SPAWN_PROC_ID serverProcHandle = yaf3d::spawnApplication( cmd, args ); if ( serverProcHandle ) _cmdResult = "trying to start server with level file '" + levelfile + "'."; else _cmdResult = "* error starting server with level file '" + levelfile + "'."; return _cmdResult; }
bool xpathplugin_xbn_select::operator() (xbn_state &state, xbn_xpath *pxpath ) { // Hole linke Seite xbn_state arg1(state); if( !pxpath->process( arg1, *(state.pCurrent_token) ) ) { return true; } // Und verknuepfe diese mit allen ergebnissen der rechten seite uint_xbn pos=0, col_size = arg1.ResultNodeList.size(); for( xbnode_list::iterator pc=arg1.ResultNodeList.begin(),pe=arg1.ResultNodeList.end(); pc!=pe;++pc,++pos ) { xbn_state arg2(state); uint_xbn current_token = *(state.pCurrent_token); arg2.pCurrent_token = ¤t_token; arg2.pCurrentNode = *pc; arg2.current_node_position = pos; arg2.last_node_position = col_size-1; if( pxpath->process( arg2, *(arg2.pCurrent_token) ) ) { // Ergebnis auflisten state.addNodeList( arg2.ResultNodeList ); //if( state.ResultNodeList.size()>state.MaxResultSize ) break; } } return true; }
bool xpathplugin_ceiling::operator() (xbn_state &state, xbn_xpath *pxpath ) { if( !state.pCurrentNode ) return false; xbn_state arg1(state); if( !pxpath->process( arg1, *(state.pCurrent_token) ) ) { pxpath->raiseError( this->name + " could not process arg1", &state,__FILE__,__LINE__ ); return false; } for( xbnode_list::iterator pc_arg1=arg1.ResultNodeList.begin(),pe_arg1=arg1.ResultNodeList.end(); pc_arg1!=pe_arg1; ++pc_arg1 ) { if( (*pc_arg1)->isNumeric() ) { int c = (int)( (*pc_arg1)->getNumeric()+0.99999 ); state.ResultNodeList.push_back( state.pStack->createTempNode( zahlToString(c) ) ); } else { pxpath->raiseError( this->name + "() arg1 is not numeric", &state,__FILE__,__LINE__ ); return false; } } return true; }
EXPORT_C void RMemSpySession::SetThreadPriorityL(TThreadId aId, TInt aPriority) { TPckgBuf<TThreadId> arg1( aId ); TPckgBuf<TInt> arg2( aPriority ); User::LeaveIfError(SendReceive( EMemSpyClientServerOpSetThreadPriority, TIpcArgs(&arg1, &arg2))); }
// ---------------------------------------------------------------------- double f_3g(double *x, double *par) { // par[0] -> const // par[1] -> mean // par[2] -> sigma // par[3] -> const // par[4] -> mean // par[5] -> sigma // par[6] -> const // par[7] -> mean // par[8] -> sigma Double_t arg1(0.), arg2(0.), arg3(0.), fitval1(0.), fitval2(0.), fitval3(0.); if (par[2] > 0) { arg1 = (x[0] - par[1]) / par[2]; fitval1 = par[0]*TMath::Exp(-0.5*arg1*arg1); } if (par[5] > 0.) { arg2 = (x[0] - par[4]) / par[5]; fitval2 = par[3]*par[0]*TMath::Exp(-0.5*arg2*arg2); } if (par[8] > 0.) { arg3 = (x[0] - par[7]) / par[8]; fitval3 = par[6]*par[0]*TMath::Exp(-0.5*arg3*arg3); } Double_t fitval = fitval1 + fitval2 + fitval3; return fitval; }
void handle_arguments(int argc, char** argv) { for (int i = 1; i < argc; ++i) { std::string arg1(argv[i]); if (arg1 == "-o" || arg1 == "--host") { if (i + 1 < argc) host = argv[i + 1]; ++i; } else if (arg1 == "-d" || arg1 == "--domain") { if (i + 1 < argc) settings.write_domain = argv[i + 1]; ++i; } else if (arg1 == "-i" || arg1 == "--id") { if (i + 1 < argc) { std::stringstream buffer(argv[i + 1]); buffer >> settings.id; } ++i; } else if (arg1 == "-f" || arg1 == "--logfile")
/// /// 実行 void invoke() override{ const T* cp = reinterpret_cast<const T*>(target()); T3_NULL_ASSERT(cp); T* p = const_cast<T*>(cp); Arg1* arg = reinterpret_cast<Arg1*>(arg1()); func_(*p, *arg); }
void test_values() { RPN::Context cxt; //Constant node (boring) cxt.insert("c", new RPN::ConstantNode(42)); insist_equal(evaluate("c", cxt), 42.0); //Variable node double x; cxt.insert("x", new RPN::VariableNode(&x)); x = 17; RPN::Expression var("x", cxt); insist_equal(var.evaluate(), 17.0); x = 23; insist_equal(var.evaluate(), 23.0); //Expression node cxt.insert("e", new RPN::ExpressionNode(&var)); insist_equal(evaluate("e", cxt), 23.0); //Argument node RPN::Evaluator eval; //One argument... cxt.insert("arg11", new RPN::ArgumentNode(1, 1)); RPN::Expression arg1("arg11", cxt, 1); eval.push(12); insist_equal(arg1.evaluate(eval), 12.0); insist_equal(arg1.evaluate(7.5), 7.5); insist_zero(eval.count()); //Two arguments... cxt.insert("arg12", new RPN::ArgumentNode(-2)); cxt.insert("arg22", new RPN::ArgumentNode(-1)); RPN::Expression arg2("arg12 + arg22", cxt, 2); eval.push(13); eval.push(14); insist_equal(arg2.evaluate(eval), 27.0); insist_equal(arg2.evaluate(7.5, 8.5), 16.0); insist_zero(eval.count()); //Three arguments... cxt.insert("arg13", new RPN::ArgumentNode(1, 3)); cxt.insert("arg23", new RPN::ArgumentNode(-2)); cxt.insert("arg33", new RPN::ArgumentNode(3, 3)); RPN::Expression arg3("arg13 + arg23 + arg33", cxt, 3); eval.push(101); eval.push(202); eval.push(303); insist_equal(arg3.evaluate(eval), 606.0); insist_equal(arg3.evaluate(1, 2, 3), 6.0); insist_zero(eval.count()); }
void Run(int PolynomialOrder, int Href, std::string GeoGridFile, int div) { int pOrder = PolynomialOrder; TPZReadGIDGrid myreader; TPZGeoMesh * gmesh = myreader.GeometricGIDMesh(GeoGridFile); { // Print Geometrical Base Mesh std::ofstream arg1("BaseGeoMesh.txt"); gmesh->Print(arg1); std::ofstream file1("BaseGeoMesh.vtk"); // In this option true -> let you use shrink paraview filter // PrintGMeshVTK(gmesh,file1); TPZVTKGeoMesh::PrintGMeshVTK(gmesh,file1, true); } // Modifying Geometric Mesh RefinamentoUniforme(gmesh, Href); { // Print Geometrical refined Base Mesh std::ofstream arg1("RefineGeoMesh.txt"); gmesh->Print(arg1); std::ofstream file1("RefineGeoMesh.vtk"); TPZVTKGeoMesh::PrintGMeshVTK(gmesh,file1, true); } TPZCompMesh * cmesh = ComputationalMesh(gmesh,PolynomialOrder); TPZAnalysis *MyAnalysis = new TPZAnalysis(cmesh); TPZSkylineStructMatrix strskyl(cmesh); MyAnalysis->SetStructuralMatrix(strskyl); TPZStepSolver<STATE> direct; direct.SetDirect(ELDLt); MyAnalysis->SetSolver(direct); REAL deltaT = 0.5; REAL maxTime = 10.0; SolveSystemTransient(deltaT, maxTime, MyAnalysis,cmesh); // MyAnalysis->Run(); // std::string plotfile("MyProblemSolution.vtk"); // PosProcess(myreader.fProblemDimension,*MyAnalysis, plotfile, div); }
QJsonObject Blink1Input::toJson2() { QJsonObject obj; obj.insert("iname", name()); obj.insert("type",type()); if(mtype!="IFTTT.COM") obj.insert("arg1",arg1()); return obj; }
// handle command line arguments void handle_arguments(int argc, char** argv) { for (int i = 1; i < argc; ++i) { std::string arg1(argv[i]); if (arg1 == "-m" || arg1 == "--multicast") { if (i + 1 < argc) { settings.hosts.push_back(argv[i + 1]); settings.type = transport::MULTICAST; } ++i; } else if (arg1 == "-b" || arg1 == "--broadcast") { if (i + 1 < argc) { settings.hosts.push_back(argv[i + 1]); settings.type = transport::BROADCAST; } ++i; } else if (arg1 == "-u" || arg1 == "--udp") { if (i + 1 < argc) { settings.hosts.push_back(argv[i + 1]); settings.type = transport::UDP; } ++i; } else if (arg1 == "-o" || arg1 == "--host") { if (i + 1 < argc) host = argv[i + 1]; ++i; } else if (arg1 == "-d" || arg1 == "--domain") { if (i + 1 < argc) settings.write_domain = argv[i + 1]; ++i; } else if (arg1 == "-i" || arg1 == "--id") { if (i + 1 < argc) { std::stringstream buffer(argv[i + 1]); buffer >> settings.id; } ++i; } else if (arg1 == "-p" || arg1 == "--processes")
ref<Expr> ShadowArray::createBinaryOfSameKind(ref<Expr> originalExpr, ref<Expr> newLhs, ref<Expr> newRhs) { std::vector<Expr::CreateArg> exprs; Expr::CreateArg arg1(newLhs); Expr::CreateArg arg2(newRhs); exprs.push_back(arg1); exprs.push_back(arg2); return Expr::createFromKind(originalExpr->getKind(), exprs); }
EXPORT_C TInt RMemSpySession::SwitchToThread( TThreadId aId, TBool aBrought ) { TPckgBuf<TThreadId> arg1( aId ); TPckgBuf<TBool> arg2( aBrought ); TIpcArgs args( &arg1, &arg2 ); TInt error = SendReceive( EMemSpyClientServerOpSwitchToThread, args ); return error; }
Variant c_DOMException::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) { if (UNLIKELY(mcp.obj == 0)) { return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_DOMException); } c_DOMException *self ATTRIBUTE_UNUSED (static_cast<c_DOMException*>(mcp.obj)); if (UNLIKELY(count != 2)) return throw_wrong_arguments("DOMException::__construct", count, 2, 2, 2); CVarRef arg0(a0); CVarRef arg1(a1); return (self->t___construct(arg0, arg1), null); }
EXPORT_C TInt RMemSpySession::EndThreadL( TThreadId aId, TMemSpyEndType aType ) { TPckgBuf<TThreadId> arg1( aId ); TPckgBuf<TMemSpyEndType> arg2( aType ); TIpcArgs args( &arg1, &arg2 ); TInt error = SendReceive( EMemSpyClientServerOpEndThread, args ); return error; }
EXPORT_C TInt RMemSpySession::ThreadSystemPermanentOrCritical( TThreadId aId, TBool aValue ) { TPckgBuf<TThreadId> arg1( aId ); TPckgBuf<TBool> arg2( aValue ); TIpcArgs args( &arg1, &arg2 ); TInt error = SendReceive( EMemSpyClientServerOpThreadSystemPermanentOrCritical, args ); aValue = arg2(); return error; }
/* Allocates memory */ void factor_vm::general_error(vm_error_type error, cell arg1_, cell arg2_) { data_root<object> arg1(arg1_, this); data_root<object> arg2(arg2_, this); faulting_p = true; /* If we had an underflow or overflow, data or retain stack pointers might be out of bounds, so fix them before allocating anything */ ctx->fix_stacks(); /* If error was thrown during heap scan, we re-enable the GC */ gc_off = false; /* If the error handler is set, we rewind any C stack frames and pass the error to user-space. */ if (!current_gc && to_boolean(special_objects[ERROR_HANDLER_QUOT])) { #ifdef FACTOR_DEBUG /* Doing a GC here triggers all kinds of funny errors */ primitive_compact_gc(); #endif /* Now its safe to allocate and GC */ cell error_object = allot_array_4(tag_fixnum(KERNEL_ERROR), tag_fixnum(error), arg1.value(), arg2.value()); ctx->push(error_object); /* Clear the data roots since arg1 and arg2's destructors won't be called. */ data_roots.clear(); /* The unwind-native-frames subprimitive will clear faulting_p if it was successfully reached. */ unwind_native_frames(special_objects[ERROR_HANDLER_QUOT], ctx->callstack_top); } /* Error was thrown in early startup before error handler is set, so just crash. */ else { std::cout << "You have triggered a bug in Factor. Please report.\n"; std::cout << "error: " << error << std::endl; std::cout << "arg 1: "; print_obj(std::cout, arg1.value()); std::cout << std::endl; std::cout << "arg 2: "; print_obj(std::cout, arg2.value()); std::cout << std::endl; factorbug(); abort(); } }
EXPORT_C TInt RMemSpySession::GetInfoItemType( TInt aIndex, TThreadId aId, TMemSpyThreadInfoItemType &aType ) { TPckgBuf<TInt> arg1( aIndex ); TPckgBuf<TThreadId> arg2( aId ); TPckgBuf<TMemSpyThreadInfoItemType> arg3; TIpcArgs args( &arg1, &arg2, &arg3 ); TInt error = SendReceive( EMemSpyClientServerOpGetInfoItemType, args ); aType = arg3(); return error; }
QJsonObject Blink1Input::toJson() { QJsonObject obj; obj.insert("name", name()); obj.insert("type",type()); obj.insert("arg1",arg1()); obj.insert("arg2",arg2()); obj.insert("date",date()); obj.insert("patternName",patternName()); obj.insert("freq",freq()); obj.insert("freqCounter",freqCounter()); return obj; }
int main(int argc, char* argv[]) { if (argc > 1) { std::string arg1(argv[1]); std::cout << "Yes.\n"; makeMap(arg1); } else { std::cout << "No.\n"; } return 0; }
void qtregexp(sqlite3_context* ctx, int argc, sqlite3_value** argv) { Q_UNUSED(argc) QRegExp regex; QString arg0((const char*)sqlite3_value_text(argv[0])); QString arg1((const char*)sqlite3_value_text(argv[1])); regex.setPattern(arg0); //regex.setCaseSensitivity(Qt::CaseInsensitive); if(arg1.contains(regex)) sqlite3_result_int(ctx, 1); else sqlite3_result_int(ctx, 0); }
bool auto_ptr_test( ) { bool rc = true; // Basic tests // ----------- std::auto_ptr< int > p1( new int( -2 ) ); if( *p1 != -2 ) FAIL std::auto_ptr< int > p2( p1 ); if( p1.get( ) != 0 ) FAIL if( *p2 != -2 ) FAIL std::auto_ptr< int > p3; p3 = p2; if( p2.get( ) != 0 ) FAIL if( *p3 != -2 ) FAIL // Check base/derived conversions // ------------------------------ std::auto_ptr< Derived > pder( new Derived ); pder->b_member = -2; std::auto_ptr< Base > pbas( pder ); if( pder.get( ) != 0 ) FAIL if( pbas->b_member != -2 ) FAIL pder.reset( new Derived ); pder->b_member = -3; pbas = pder; if( pder.get( ) != 0 ) FAIL if( pbas->b_member != -3 ) FAIL // Check auto_ptr as function argument type or return type // ------------------------------------------------------- std::auto_ptr< int > arg1( new int( 24 ) ); f( arg1 ); if( arg1.get( ) != 0 ) FAIL const std::auto_ptr< int > arg2( new int( 24 ) ); g( arg2 ); if( *arg2 != 42 ) FAIL return( rc ); }
Call::Call(const Function& fcn, const vector<MX>& arg) : fcn_(fcn) { // Number inputs and outputs int num_in = fcn.n_in(); casadi_assert_message(arg.size()==num_in, "Argument list length (" << arg.size() << ") does not match number of inputs (" << num_in << ")" << " for function " << fcn.name()); // Create arguments of the right dimensions and sparsity vector<MX> arg1(num_in); for (int i=0; i<num_in; ++i) { arg1[i] = projectArg(arg[i], fcn_.sparsity_in(i), i); } setDependencies(arg1); setSparsity(Sparsity::scalar()); }
// handle command line arguments void handle_arguments(int argc, char ** argv) { for (int i = 1; i < argc; ++i) { std::string arg1(argv[i]); if (arg1 == "-b" || arg1 == "--broadcast") { if (i + 1 < argc && argv[i + 1][0] != '-') { settings.hosts.push_back(argv[i + 1]); settings.type = madara::transport::BROADCAST; } else { print_usage(argv[0]); } ++i; } else if (arg1 == "-c" || arg1 == "--checkpoint") { if (i + 1 < argc) { chkpt_settings.filename = argv[i + 1]; } else { print_usage(argv[0]); } ++i; } else if (arg1 == "-cz" || arg1 == "--checkpoint-hz") { if (i + 1 < argc && argv[i + 1][0] != '-') { std::stringstream buffer(argv[i + 1]); buffer >> checkpoint_hertz; } else { print_usage(argv[0]); } ++i; }
/*! * \brief 範囲指定による順序付きリスト * \param[in] line 行番号 * \param[in] arg_list マクロ実引数リスト * \param[in] p_ctx マクロコンテキスト * \retval マクロ返却値 * 第1マクロ実引数で最初の値を、第2マクロ実引数で最後の値を指定する。 * { 最初の値, 最初の値 + 1, ... 最後の値 } * となる順序付きリストを生成する。 * 引数が正しくない場合は空値を返す。 */ var_t bf_range( text_line const& line, std::vector< var_t > const& arg_list, context const* p_ctx ) { var_t result; if ( macro_processor::check_arity( line, arg_list.size(), 2, "RANGE" ) ) { std::tr1::int64_t arg1( get_i( arg_list[0], p_ctx ) ); std::tr1::int64_t arg2( get_i( arg_list[1], p_ctx ) ); for ( ; arg1 <= arg2; ++arg1 ) { element e; e.i = arg1; result.push_back( e ); } } return result; }
void handle_arguments (int argc, char ** argv) { for (int i = 1; i < argc; ++i) { std::string arg1 (argv[i]); if (arg1 == "-p" || arg1 == "--poll-frequency") { if (i + 1 < argc) { std::stringstream buffer (argv[i + 1]); buffer >> wait_settings.poll_frequency; } ++i; } else if (arg1 == "-m" || arg1 == "--max")
// handle command line arguments void handle_arguments (int argc, char ** argv) { for (int i = 1; i < argc; ++i) { std::string arg1 (argv[i]); if (arg1 == "-c" || arg1 == "--counters") { if (i + 1 < argc) { std::stringstream buffer (argv[i + 1]); buffer >> counters; } ++i; } else if (arg1 == "-f" || arg1 == "--logfile")
void ByteCode::setup(eOpCode opcode, m::u8 A, m::u8 B, m::u8 C) { opCode(opcode); res(A); arg1(B); arg2(C); }