/** \brief Load all the initial dictionary words. */ void init_dictionary(int dictsize) { init_compiler(dictsize); memory_words(); compile_primitives(); compile_core_constants(); core_words(); core_extension_words(); compile_dictionary_words(); controlflow_words(); more_core_words(); compile_double(); string_words(); exception_words(); file_words(); format_words(); compile_stack_words(); implementation_words(); vocabulary_words(); interpreter_words(); platform_words(); /* FIX - NEED TO DO THESE */ // Primitive( "d<", &lesser ); /* ( d1 d2 -- f ) */ // Primitive( "d>", &lesser ); /* ( d1 d2 -- f ) */ // Primitive( "u*", &um_star ); /* ( x y -- x*y ) */ // Primitive( "du*", &um_star ); /* ( x y -- x*y ) */ // Primitive( "du/mod", &um_star ); /* ( x y -- x*y ) */ // Primitive( "du<", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m+", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m-", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m*", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m*/", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m/", &um_star ); /* ( x y -- x*y ) */ // Primitive( "m/mod", &um_star ); /* ( x y -- x*y ) */ /* FIX - NEED TO DO THESE */ /* FIX - these two words are no longer used - why are they here ?? */ // Primitive( "um*", &um_star ); /* ( x y -- x*y ) */ // Colon( "udm*" ); /* ( d.lo d.hi n -- d.lo' d.hi' ) */ // c("tuck"); c("um*"); c("drop"); c("-rot"); c("um*"); // c("rot"); c("+"); End(); Colon( ".version" ); DotQuote("Portable ANS Forth - [email protected]"); c("cr"); End(); Colon( "rstrace" ); DotQuote("( R: "); c("rp@"); c("rp0"); c("@"); Do(); c("i"); c("."); c("space"); c("/cell"); PlusLoop(); DotQuote(" )"); c("cr"); End(); Variable( "argument-hook" ); /* To( Tick("ndrop"), "argument-hook" ); */ ACF x = find("unnest"); To( (Cell)x, "argument-hook" ); Colon( "cold" ); c(".version"); c("cold-chain"); /* included may be replaced with path-included which reads FORTH_PATH environment variable to look in selected directories */ c("debug"); c("@"); If(); DotQuote("Loading Forth files..."); Then(); /* StringLiteral("base.fth"); c("included"); */ DotQuote("loading base.fth"); c("cr"); StringLiteral("base.fth"); Tick("included"); c("catch"); c("?aborted"); If(); DotQuote("Failed to load."); c("cr"); Then(); c("debug"); c("@"); If(); DotQuote("done."); c("cr"); Then(); c("hex"); #if 0 c("argument-hook"); c("@"); Tick("execute"); c("catch"); c("?aborted"); If(); DotQuote("argument-hook failed"); c("cr"); Then(); #endif c("read-eval-loop"); End(); Colon( "warm" ); DotQuote( "Warm Started." ); c("cr"); c("rstrace"); c("quit"); End(); /* header */ Colon( "name," ); c("dup"); c("1+"); c("talign"); c("allot"); c("dup"); c("here"); c("1-"); c("c!"); c("here"); c("1-"); c("over"); c("-"); c("swap"); c("cmove"); End(); Colon( "header" ); c("name,"); c("link"); c("do-create"); c(","); End(); Colon( "create" ); c("parse-word"); c("header"); End(); Colon( "codefield" ); /* ( codefield -- ) */ c("lastacf"); c("!"); End(); Colon( ":" ); c("create"); c("hide"); c("do-colon"); c("codefield"); c("]"); End(); Colon( ";" ); c("compile"); c("unnest"); c("["); c("reveal"); End(); immediate(); }
double define_var(string s, double d){ if(is_declared(s)) error("declared twice"); names.push_back(Variable(s,d)); return d; }
Variable ParserScope::doGetField(const Variant &key, bool /*modifiable*/, bool /*createIfNeeded*/) { if (key.type() == Variant::stringType) { auto it = reserved.find(key.toString()); if (it != reserved.end()) { const auto id = it->second; switch (id) { case A_PEEK: return collector().lambda( [this](const VariableArgs& args, const VariableKeywordArgs&) ->Variable { if (parser() && args.size() >= 1) { Variant typeArg = args[0].value(); if (typeArg.type() == Variant::objectType) { std::streamoff offset = args.size() > 1 ? args[1].value().toInteger() : 0; const ObjectType& type = typeArg.toObjectType(); std::unique_ptr<Object> child(parser()->readVariable(type, offset)); if (child) { return collector().copy(child->value()); } } } return Variable(); }, memory()); case A_READ: return collector().lambda( [this](const VariableArgs& args, const VariableKeywordArgs&) ->Variable { if (parser()) { Variant typeArg = args[0].value(); if (typeArg.type() == Variant::objectType) { const ObjectType& type = typeArg.toObjectType(); std::unique_ptr<Object> child(parser()->readVariable(type)); if (child) { parser()->object().setPos(parser()->object().pos()+child->size()); return collector().copy(child->value()); } } } return Variable(); }, memory()); case A_FIND_BYTE_PATTERN: return collector().lambda( [this](const VariableArgs& args, const VariableKeywordArgs&) ->Variable { if (args.size() < 1) { return Variable(); } const Variant& value = args[0].value(); if (value.type() != Variant::stringType) { return Variable(); } if (parser()) { return collector().copy(parser()->findBytePattern(value.toString())); } return Variable(); } ); } } } return Variable(); }
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD<Base> CondExpOp( enum CompareOp cop , const AD<Base> &left , const AD<Base> &right , const AD<Base> &if_true , const AD<Base> &if_false ) { AD<Base> returnValue; CPPAD_ASSERT_UNKNOWN( Parameter(returnValue) ); // check first case where do not need to tape if( IdenticalPar(left) & IdenticalPar(right) ) { switch( cop ) { case CompareLt: if( left.value_ < right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareLe: if( left.value_ <= right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareEq: if( left.value_ == right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareGe: if( left.value_ >= right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareGt: if( left.value_ > right.value_ ) returnValue = if_true; else returnValue = if_false; break; default: CPPAD_ASSERT_UNKNOWN(0); returnValue = if_true; } return returnValue; } // must use CondExp incase Base is an AD type and recording returnValue.value_ = CondExpOp(cop, left.value_, right.value_, if_true.value_, if_false.value_); ADTape<Base> *tape = CPPAD_NULL; if( Variable(left) ) tape = left.tape_this(); if( Variable(right) ) tape = right.tape_this(); if( Variable(if_true) ) tape = if_true.tape_this(); if( Variable(if_false) ) tape = if_false.tape_this(); // add this operation to the tape if( tape != CPPAD_NULL ) tape->RecordCondExp(cop, returnValue, left, right, if_true, if_false); return returnValue; }
// (var, val, c)をvar_tableに追加する double Symbol_table::define_name(string var, double val, bool c){ if(is_declared(var)) error(var, " declared twice"); var_table.push_back(Variable(var, val, c)); }
NNC_Polyhedron Model::edge_cvx(const EDGE &edge, const NNC_Polyhedron &pre_poly) { int num_p = param_list.params.size(); int num_v = var_list.vars.size(); //int dim = 2*num_v + num_p + 1; const EDGE *it = &edge; NNC_Polyhedron cvx = pre_poly; string dest = it->dest; vector<Variable> Vars; int total = 0; for ( int i = 0; i < num_p; i++) Vars.push_back(Variable(total++)); for ( int i = 0; i < num_v; i++) Vars.push_back(Variable(total++)); // guard for ( vector<EXPR>::const_iterator iit = it->guard.begin(); iit != it->guard.end(); iit++) { Linear_Expression le; for ( int i = 0; i < num_p; i++) { le += Vars[i] * iit->find(param_list.params[i].name); } for ( unsigned i = 0; i < known_param_list.params.size(); i++) { le += atof (known_param_list.params[i].value.c_str()) * iit->find(known_param_list.params[i].name); } for ( int i = 0; i < num_v; i++) { le += Vars[num_p + i] * iit->find(var_list.vars[i]); } int right = atof(iit->value.c_str()); Constraint cs; if ( iit->op == "<") cs = ( le < right); if ( iit->op == "=") cs = ( le == right); if ( iit->op == "<=") cs = ( le <= right); if ( iit->op == ">") cs = ( le > right); if ( iit->op == ">=") cs = ( le >= right); cvx.add_constraint(cs); } // guard => updates for ( int i = 0; i < num_v; i++) Vars.push_back(Variable(total++)); for ( int i = 0; i < num_v; i++) { int i2 = total - num_v + i; int i1 = num_p + i; bool u_flag = false; UPDATE update; for ( vector<UPDATE>::const_iterator uit = it->updates.begin(); uit != it->updates.end(); uit++) { if (var_list.vars[i] == uit->left) { u_flag = true; update = *uit; break; } } Constraint cs; if (!u_flag) { cs = (Vars[i2] == Vars[i1]); cvx.add_constraint(cs); continue; } Linear_Expression le; for ( int j = 0; j < num_p; j++) { le += Vars[j] * update.find(param_list.params[j].name); } for ( unsigned j = 0; j < known_param_list.params.size(); j++) { le += atof (known_param_list.params[j].value.c_str()) * update.find(known_param_list.params[j].name); } for ( int j = 0; j < num_v; j++) { le += Vars[num_p + j] * update.find(var_list.vars[j]); } le += update.get_cons(); cs = (Vars[i2] == le); cvx.add_constraint(cs); } // guard => assign => reduce Variables_Set vs; for ( int i = total - 2*num_v; i < total - num_v; i++) { vs.insert(Vars[i]); } cvx.remove_space_dimensions(vs); cvx.add_space_dimensions_and_embed(num_v); //total -= (num_v); //Vars.clear(); //for ( int i = 0; i < total; i++) // Vars.push_back(Variable(i)); return cvx; }
VariableExpression::VariableExpression( text::attributes::SpeechPart sp, uint index ) : variable( Variable( sp, index ) ) { }
void Shader::SetSampler(const String& name, UINT index, ID3D11SamplerState* sampler) { Variable(name)->AsSampler()->SetSampler(index, sampler); }
void Shader::SetShaderResource(const String& name, ID3D11ShaderResourceView* shaderResource) { Variable(name)->AsShaderResource()->SetResource(shaderResource); }
void Shader::SetMatrix(const String& name, const Matrix& matrix) { Variable(name)->AsMatrix()->SetMatrix(matrix); }
void Shader::SetVector(const String& name, const Vector4& vector) { Variable(name)->AsVector()->SetFloatVector(vector); }
arithmtype Function(void) { char tcFonc[ 20 ], *pFonc; int Res = 0; /* which function ? */ pFonc = tcFonc; while((unsigned int)(pFonc-tcFonc)<sizeof(tcFonc)-1 && *Expr>='A' && *Expr<='Z') { *pFonc++ = *Expr; Expr++; } *pFonc = '\0'; /* functions with one parameter = variable */ if ( !strcmp(tcFonc, "ABS") ) { Expr++; /* ( */ Res = Variable( ); if ( Res<0 ) Res = Res * -1; Expr++; /* ) */ return Res; } /* functions with many parameters = many variables separated per ',' */ if ( !strcmp(tcFonc, "MINI") ) { Res = 0x7FFFFFFF; do { int iValVar; Expr++; /* ( -ou- , */ iValVar = Variable( ); if ( iValVar<Res ) Res = iValVar; } while( *Expr!=')' ); Expr++; /* ) */ return Res; } if ( !strcmp(tcFonc, "MAXI") ) { Res = 0x80000000; do { int iValVar; Expr++; /* ( -or- , */ iValVar = Variable( ); if ( iValVar>Res ) Res = iValVar; } while( *Expr!=')' ); Expr++; /* ) */ return Res; } if ( !strcmp(tcFonc, "MOY") /*original french term!*/ || !strcmp(tcFonc, "AVG") /*added latter!!!*/ ) { int NbrVars = 0; do { int ValVar; Expr++; /* ( -or- , */ ValVar = Variable( ); NbrVars++; Res = Res + ValVar; } while( *Expr!=')' ); Expr++; /* ) */ Res = Res/NbrVars; return Res; } /* functions with parameter = term */ // int iValeurTerm = Term(); // if ( !strcmp(tcFonc, "") ) // { // } ErrorDesc = "Unknown function"; SyntaxError(); return 0; }
AD<Base> operator - (const AD<Base> &left , const AD<Base> &right) { ADTape<Base> *tape = AD<Base>::tape_ptr(); bool var_left, var_right; # ifdef NDEBUG if( tape == CPPAD_NULL ) { var_left = false; var_right = false; } else { var_left = left.id_ == tape->id_; var_right = right.id_ == tape->id_; } # else var_left = Variable(left); var_right = Variable(right); CPPAD_ASSERT_KNOWN( (! var_left) || left.id_ == tape->id_ , "- left operand is a variable for a different thread" ); CPPAD_ASSERT_KNOWN( (! var_right) || right.id_ == tape->id_ , "- right operand is a variable for a different thread" ); # endif AD<Base> result; result.value_ = left.value_ - right.value_; CPPAD_ASSERT_UNKNOWN( Parameter(result) ); if( var_left ) { if( var_right ) { // result = variable - variable CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 ); // put operand addresses in tape tape->Rec_.PutArg(left.taddr_, right.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(SubvvOp); // make result a variable result.id_ = tape->id_; } else if( IdenticalZero(right.value_) ) { // result = variable - 0 result.make_variable(left.id_, left.taddr_); } else { // result = variable - parameter CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 ); // put operand addresses in tape size_t p = tape->Rec_.PutPar(right.value_); tape->Rec_.PutArg(left.taddr_, p); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(SubvpOp); // make result a variable result.id_ = tape->id_; } } else if( var_right ) { // result = parameter - variable CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 ); // put operand addresses in tape size_t p = tape->Rec_.PutPar(left.value_); tape->Rec_.PutArg(p, right.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(SubpvOp); // make result a variable result.id_ = tape->id_; } return result; }
VariableArray::VariableArray(const size_t size, const ::std::string& name) : VariableArrayContents() { for (size_t i = 0; i < size; ++i) { push_back(Variable(GADGETLIB2_FMT("%s[%d]", name.c_str(), i))); } }
void Model::update_cvx(const EDGE &edge, NNC_Polyhedron &cvx) { int dim = var_list.vars.size(); const EDGE *it = &edge; vector<Variable> Vars; for ( int i = 0; i <= dim; i++) Vars.push_back(Variable(i)); int p, c; Variables_Set vs; for ( int i = 0; i < dim; i++) { bool u_flag = false; UPDATE update; for ( vector<UPDATE>::const_iterator uit = it->updates.begin(); uit != it->updates.end(); uit++) { if (var_list.vars[i] == uit->left) { u_flag = true; update = *uit; break; } } if (!u_flag) { continue; } if ( i < dim/2) { cvx.unconstrain(Vars[i]); Constraint cs1 = (Vars[i] == 0); cvx.add_constraint(cs1); i = dim/2 - 1; continue; } cvx.expand_space_dimension(Vars[i], 1); cvx.unconstrain(Vars[i]); Linear_Expression le; for ( unsigned j = 0; j < known_param_list.params.size(); j++) { le += atof (known_param_list.params[j].value.c_str()) * update.find(known_param_list.params[j].name); } for ( int j = dim; j <= dim; j++) { le += Vars[j] * update.find(var_list.vars[i]); } le += update.get_cons(); Constraint cs2 = (Vars[i] == le); cvx.add_constraint(cs2); cvx.remove_higher_space_dimensions(dim); return; } }
void Shader::SetScalor(const String& name, float scalor) { Variable(name)->AsScalar()->SetFloat(scalor); }
NNC_Polyhedron Model::location_cvx(const Location *l, const NNC_Polyhedron *pre_cvx) { // a path leading to "target" is found if( l->is_bad && type != REACH) { if ( type == FAST_REACH) { //cout << "The target location is reached\n"; //return NNC_Polyhedron(0, EMPTY); //exit (0); fast_reach = true; } else { NNC_Polyhedron bad = *pre_cvx; bad.remove_higher_space_dimensions(param_list.params.size()); //if (bad.is_empty()) //return NNC_Polyhedron(0, EMPTY); restore_bad_paths(bad); return NNC_Polyhedron(0, EMPTY); } } NNC_Polyhedron cvx (*pre_cvx); int num_p = param_list.params.size(); int num_v = var_list.vars.size(); //int dim = 2*num_v + num_p + 1; vector<Variable> Vars; int total = 0; for (int i = 0; i < num_p; i++) Vars.push_back(Variable(total++)); for (int i = 0; i < num_v; i++) Vars.push_back(Variable(total++)); // invariant for ( vector<EXPR>::const_iterator it = l->invar.begin(); it != l->invar.end(); it++) { Linear_Expression le; for ( int i = 0; i < num_p; i++) { le += Vars[i] * it->find(param_list.params[i].name); } for ( unsigned i = 0; i < known_param_list.params.size(); i++) { le += atof (known_param_list.params[i].value.c_str()) * it->find(known_param_list.params[i].name); } for ( int i = 0; i < num_v; i++) { le += Vars[num_p + i] * it->find(var_list.vars[i]); } int right = atof(it->value.c_str()); Constraint cs; if ( it->op == "<") cs = ( le < right); if ( it->op == "=") cs = ( le == right); if ( it->op == "<=") cs = ( le <= right); if ( it->op == ">") cs = ( le > right); if ( it->op == ">=") cs = ( le >= right); cvx.add_constraint(cs); } // invar => time elapse Vars.push_back(Variable(total++)); Constraint cs = (Vars[total-1] >= 0); cvx.add_constraint(cs); for ( int i = 0; i < num_v; i++) Vars.push_back(Variable(total++)); for ( int i = 0; i < num_v; i++) { int i2 = total - num_v + i; int i1 = num_p + i; int i_co = l->rate.find(var_list.vars[i]); Constraint cs = (Vars[i1] + i_co * Vars[num_p + num_v] == Vars[i2]); cvx.add_constraint(cs); } // invar => time elapse => invar for ( vector<EXPR>::const_iterator it = l->invar.begin(); it != l->invar.end(); it++) { Linear_Expression le; for ( int i = 0; i < num_p; i++) { le += Vars[i] * it->find(param_list.params[i].name); } for ( unsigned i = 0; i < known_param_list.params.size(); i++) { le += atof (known_param_list.params[i].value.c_str()) * it->find(known_param_list.params[i].name); } for ( int i = 0; i < num_v; i++) { le += Vars[total - num_v + i] * it->find(var_list.vars[i]); } int right = atof(it->value.c_str()); Constraint cs; if ( it->op == "<") cs = ( le < right); if ( it->op == "=") cs = ( le == right); if ( it->op == "<=") cs = ( le <= right); if ( it->op == ">") cs = ( le > right); if ( it->op == ">=") cs = ( le >= right); cvx.add_constraint(cs); } // invar => time elapse => invar => reduce Variables_Set vs; for ( int i = total - 2*num_v - 1; i < total - num_v; i++) { vs.insert(Vars[i]); } cvx.remove_space_dimensions(vs); cvx.add_space_dimensions_and_embed(num_v+1); //total -= (num_2v + 1); //Vars.clear(); //for ( int i = 0; i < total; i++) // Vars.push_back(Variable(i)); return cvx; }
void Shader::SetRenderTargett(const String& name, ID3D11RenderTargetView* renderTarget) { Variable(name)->AsRenderTargetView()->SetRenderTarget(renderTarget); }
bool Model::forward_release(const shared_ptr<pair_sc>& state, unsigned ti) { if (state->tk_new) return false; Variable v(ti-1); NNC_Polyhedron poly = state->cvx; // current state contains p_i == T_i Constraint cs = ( v == atoi(known_param_list.params[3*(ti-1)].value.c_str())); poly.add_constraint(cs); if( ! poly.is_empty()) return false; // ti arrived earlier shared_ptr<pair_sc> origin = state->prior; bool idle_flag = false; while( origin != nullptr) { if ( ! origin->valid) return true; if (busy_period(origin->signature)) { poly = origin->cvx; Constraint cs = ( v == atoi(known_param_list.params[3*(ti-1)].value.c_str())); poly.add_constraint(cs); if ( ! poly.is_empty()) return true; if (origin->tk_new) break; } else { poly = origin->cvx; Constraint cs = ( v == atoi(known_param_list.params[3*(ti-1)].value.c_str())); poly.add_constraint(cs); if ( ! poly.is_empty()) { if (idle_flag) { //cout << " release not in latest idle period\n"; return true; } idle_flag = true; vector<Variable> vs; for ( int i = 1; i < N; i++) if ( (origin->signature & (unsigned)pow(2, i-1)) ==0 && (state->signature & (unsigned)pow(2, i-1)) !=0) vs.push_back(Variable(i-1)); poly = state->cvx; for (int i = 0; i < vs.size(); i++) { cs = (vs[i]==0); poly.add_constraint(cs); if (poly.is_empty()){ //cout << " release in latest idle period\n"; return true; } } } } origin = origin->prior; } //ti arrived before tk vector<Variable> vs; for ( int i = 1; i < N; i++) if ( (origin->prior->signature & (unsigned)pow(2, i-1)) ==0 && (state->signature & (unsigned)pow(2, i-1)) !=0) vs.push_back(Variable(i-1)); poly = state->cvx; for (int i = 0; i < vs.size(); i++) { cs = (vs[i]==0); poly.add_constraint(cs); if (poly.is_empty()){ //cout << " release before tk arrives\n"; return true; } } return false; }
void Shader::SetRasterizer(const String& name, UINT index, ID3D11RasterizerState* rasterizer) { Variable(name)->AsRasterizer()->SetRasterizerState(index, rasterizer); }
VariableExpression::VariableExpression( const Pattern & pt, uint index ) : variable( Variable( pt, index ) ) { }
void Shader::SetDepthStencilView(const String& name, ID3D11DepthStencilView* depthStencilView) { Variable(name)->AsDepthStencilView()->SetDepthStencil(depthStencilView); }
void ADTape<Base>::RecordCondExp( enum CompareOp cop , AD<Base> &returnValue , const AD<Base> &left , const AD<Base> &right , const AD<Base> &if_true , const AD<Base> &if_false ) { size_t ind0, ind1, ind2, ind3, ind4, ind5; size_t returnValue_taddr; // taddr_ of this variable CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 ); returnValue_taddr = Rec_.PutOp(CExpOp); // ind[0] = cop ind0 = addr_t( cop ); // ind[1] = base 2 representaion of the value // [Var(left), Var(right), Var(if_true), Var(if_false)] ind1 = 0; // Make sure returnValue is in the list of variables and set its taddr if( Parameter(returnValue) ) returnValue.make_variable(id_, returnValue_taddr ); else returnValue.taddr_ = returnValue_taddr; // ind[2] = left address if( Parameter(left) ) ind2 = Rec_.PutPar(left.value_); else { ind1 += 1; ind2 = left.taddr_; } // ind[3] = right address if( Parameter(right) ) ind3 = Rec_.PutPar(right.value_); else { ind1 += 2; ind3 = right.taddr_; } // ind[4] = if_true address if( Parameter(if_true) ) ind4 = Rec_.PutPar(if_true.value_); else { ind1 += 4; ind4 = if_true.taddr_; } // ind[5] = if_false address if( Parameter(if_false) ) ind5 = Rec_.PutPar(if_false.value_); else { ind1 += 8; ind5 = if_false.taddr_; } CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 ); CPPAD_ASSERT_UNKNOWN( ind1 > 0 ); Rec_.PutArg(ind0, ind1, ind2, ind3, ind4, ind5); // check that returnValue is a dependent variable CPPAD_ASSERT_UNKNOWN( Variable(returnValue) ); }
void Shader::SetDepthStencil(const String& name, UINT index, ID3D11DepthStencilState* depthStencil) { Variable(name)->AsDepthStencil()->SetDepthStencilState(index, depthStencil); }
double define_name(string var, double val) { if (is_declared(var)) error(var, " declared twice"); var_table.push_back(Variable(var, val)); return val; }
void Shader::SetBlend(const String& name, UINT index, ID3D11BlendState* blendState) { Variable(name)->AsBlend()->SetBlendState(index, blendState); }
Variable Object::CreateVariable(const NodeId& newVariableId, const QualifiedName& browseName, const VariableType& type) { return Variable(GetServices()); }
tValType add_variable(string s,tValType val){ if (is_declared(s)) error(s, " is declared"); var_table.push_back(Variable(s,val)); return val; }
Variable & Item::getVariable( const std::string &nm ) { auto v = myVariables.emplace( std::make_pair( nm, Variable( nm ) ) ); return v.first->second; }
bool Player::getProperty(const std::string_view prop, Variable& var) const { if (prop.empty() == true) { return false; } auto props = Utils::splitStringIn2(prop, '.'); auto propHash = str2int16(props.first); if (getLevelObjProp(propHash, props.second, var) == true) { return true; } switch (propHash) { case str2int16("name"): var = Variable(Name()); break; case str2int16("simpleName"): var = Variable(SimpleName()); break; case str2int16("d"): case str2int16("description"): { updateNameAndDescriptions(); size_t idx = Utils::strtou(props.second); if (idx >= descriptions.size()) { idx = 0; } var = Variable(descriptions[idx]); break; } case str2int16("eval"): var = Variable((int64_t)Formula::evalString(props.second, *this)); break; case str2int16("evalMin"): var = Variable((int64_t)Formula::evalMinString(props.second, *this)); break; case str2int16("evalMax"): var = Variable((int64_t)Formula::evalMaxString(props.second, *this)); break; case str2int16("evalf"): var = Variable(Formula::evalString(props.second, *this)); break; case str2int16("evalMinf"): var = Variable(Formula::evalMinString(props.second, *this)); break; case str2int16("evalMaxf"): var = Variable(Formula::evalMaxString(props.second, *this)); break; case str2int16("totalKills"): var = Variable((int64_t)Class()->TotalKills()); break; case str2int16("hasMaxStats"): var = Variable(hasMaxStats()); break; case str2int16("hasProperty"): var = Variable(hasInt(props.second)); break; case str2int16("canUseSelectedItem"): { if (selectedItem == nullptr) { return false; } var = Variable(canUseObject(*selectedItem)); break; } case str2int16("canUseSelectedSpell"): { if (selectedSpell == nullptr) { return false; } var = Variable(canUseObject(*selectedSpell->spell)); break; } case str2int16("canUseItem"): { std::string_view props2; size_t invIdx; size_t itemIdx; if (inventories.parseInventoryAndItem( props.second, props2, invIdx, itemIdx) == true) { auto item = inventories[invIdx].get(itemIdx); if (item != nullptr) { var = Variable(canUseObject(*item)); break; } } return false; } case str2int16("hasEquipedItemType"): var = Variable(hasEquipedItemType(props.second)); break; case str2int16("hasEquipedItemSubType"): var = Variable(hasEquipedItemSubType(props.second)); break; case str2int16("hasSelectedItem"): var = Variable(selectedItem != nullptr); break; case str2int16("hasItem"): { std::string_view props2; size_t invIdx; size_t itemIdx; if (inventories.parseInventoryAndItem( props.second, props2, invIdx, itemIdx) == true) { var = Variable(inventories[invIdx].get(itemIdx) != nullptr); break; } return false; } case str2int16("hasItemClass"): var = Variable(inventories.hasItem(str2int16(props.second))); break; case str2int16("hasSpell"): { var = Variable(getSpell(std::string(props.second)) != nullptr); break; } case str2int16("hasSelectedSpell"): { var = Variable(selectedSpell != nullptr); break; } case str2int16("isItemSlotInUse"): { std::string_view props2; size_t invIdx; size_t itemIdx; if (inventories.parseInventoryAndItem( props.second, props2, invIdx, itemIdx) == true) { var = Variable(inventories[invIdx].isSlotInUse(itemIdx)); break; } return false; } case str2int16("isStanding"): var = Variable(playerStatus == PlayerStatus::Stand); break; case str2int16("isWalking"): var = Variable(playerStatus == PlayerStatus::Walk); break; case str2int16("isAttacking"): var = Variable(playerStatus == PlayerStatus::Attack); break; case str2int16("isDead"): var = Variable(playerStatus == PlayerStatus::Dead); break; case str2int16("selectedItem"): { if (selectedItem != nullptr) { return selectedItem->getProperty(props.second, var); } return false; } case str2int16("item"): { std::string_view props2; size_t invIdx; size_t itemIdx; if (inventories.parseInventoryAndItem( props.second, props2, invIdx, itemIdx) == true) { auto item = inventories[invIdx].get(itemIdx); if (item != nullptr) { return item->getProperty(props2, var); } } return false; } case str2int16("inventory"): { auto props2 = Utils::splitStringIn2(props.second, '.'); auto invIdx = GameUtils::getPlayerInventoryIndex(props2.first); if (invIdx < inventories.size()) { return inventories[invIdx].getProperty(props2.second, var); } return false; } case str2int16("itemQuantity"): { auto classIdHash16 = str2int16(props.second); uint32_t itemQuantity = 0; if (itemQuantityCache.getValue(classIdHash16, itemQuantity) == false) { if (inventories.getQuantity(classIdHash16, itemQuantity) == true) { itemQuantityCache.updateValue(classIdHash16, itemQuantity); } } var = Variable((int64_t)itemQuantity); break; } case str2int16("selectedSpell"): { if (selectedSpell != nullptr) { return selectedSpell->getProperty(props.second, var); } return false; } case str2int16("spell"): { auto props2 = Utils::splitStringIn2(props.second, '.'); auto spell = getSpellInstance(std::string(props2.first)); if (spell != nullptr) { return spell->getProperty(props2.second, var); } return false; } default: { Number32 value; if (getNumberByHash(propHash, props.second, value) == true) { var = Variable(value.getInt64()); break; } return false; } } return true; }