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