void quickPow(long a[2][2], long n, long result[2][2]) { // int j=0; long i=1; // long swap; long swap[2][2], pow1[2][2], pow2[2][2]; // result[2][2]={1, 0, 0, 1}; assignment(pow2, a); // assignment(result, a); if(n>0) { // return result; // pow2=a; while(i<=n) { if((i&n)!=0) { multMat2(result, pow2, swap); assignment(result, swap); } i<<=1; multMat2(pow2, pow2, pow1); assignment(pow2,pow1); } } }
void AstCompiler::statement(Statement *statement) { if (statement->type() == CLASS_DEFINITION) { cout << "CLASS" << ((Assignment*)statement)->id << endl; } else if (statement->type() == ASSIGNMENT) { assignment((Assignment*)statement); } }
int main(int argc, char** argv) { init(); assignment(); finish(); exit(0); }
static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { expdesc e; check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, "syntax error"); if (testnext(ls, ',')) { /* assignment -> `,' primaryexp assignment */ struct LHS_assign nv; nv.prev = lh; primaryexp(ls, &nv.v); if (nv.v.k == VLOCAL) check_conflict(ls, lh, &nv.v); assignment(ls, &nv, nvars+1); } else { /* assignment -> `=' explist1 */ int nexps; checknext(ls, '='); nexps = explist1(ls, &e); if (nexps != nvars) { adjust_assign(ls, nvars, nexps, &e); if (nexps > nvars) ls->fs->freereg -= nexps - nvars; /* remove extra values */ } else { luaK_setoneret(ls->fs, &e); /* close last expression */ luaK_storevar(ls->fs, &lh->v, &e); return; /* avoid default */ } } init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ luaK_storevar(ls->fs, &lh->v, &e); }
IMPMULTIFIT_BEGIN_NAMESPACE void get_anchors_for_density(em::DensityMap *dmap, int number_of_means, float density_threshold, std::string pdb_filename, std::string cmm_filename, std::string seg_filename, std::string txt_filename) { dmap->set_was_used(true); IMP_NEW(multifit::DensityDataPoints, ddp, (dmap, density_threshold)); IMP::statistics::internal::VQClustering vq(ddp, number_of_means); ddp->set_was_used(true); vq.run(); multifit::DataPointsAssignment assignment(ddp, &vq); multifit::AnchorsData ad(assignment.get_centers(), *(assignment.get_edges())); multifit::write_pdb(pdb_filename, assignment); // also write cmm string into a file: if (cmm_filename != "") { multifit::write_cmm(cmm_filename, "anchor_graph", ad); } if (seg_filename != "") { float apix = dmap->get_spacing(); multifit::write_segments_as_mrc(dmap, assignment, apix, apix, density_threshold, seg_filename); } if (txt_filename != "") { multifit::write_txt(txt_filename, ad); } }
void CodeGen::assignmentCode(realSlotRef* dataRef) { prologue(true, 0 ); move(Temp1, LArgLocation(0)); assert(!haveStackFrame, "LReceiverReg only for no frame"); assignment(LReceiverReg, dataRef, Temp1); epilogue(LReceiverReg); }
//! Expand "vector (opop)" to "vector (op)= 1", and then call for the expansion of this last expression Node* UnaryArithmeticAssignmentNode::expandAbstractNodes(std::wostream* dump) { assert(children.size() == 1); Node* memoryVector = children[0]; // create a vector of 1's std::auto_ptr<TupleVectorNode> constant(new TupleVectorNode(sourcePos)); for (unsigned int i = 0; i < memoryVector->getVectorSize(); i++) constant->addImmediateValue(1); // expand to "vector (op)= 1" std::auto_ptr<ArithmeticAssignmentNode> assignment(new ArithmeticAssignmentNode(sourcePos, arithmeticOp, memoryVector, constant.get())); constant.release(); // perform the expansion of ArithmeticAssignmentNode std::auto_ptr<Node> finalBlock(assignment->expandAbstractNodes(dump)); if (assignment.get() != finalBlock.get()) // delete the orphaned node assignment.reset(); else assignment.release(); // let our children to stay with the new node // otherwise they will be freed when we are cleared children.clear(); return finalBlock.release(); }
int main(int argc, char *argv[]) { int keepRunning = 1; int command; while (keepRunning == 1) { showRegisters(); command = inputCommand(); switch (command) { case 0: keepRunning--; break; case 1: assignment(); break; case 2: addRegisters(); break; case 3: subtractRegisters(); break; } } return 0; }
void test_assignment() { const char *tokensv[] = { "a", "=", "2" }; unsigned int tokensc = 3; const char *expected_calls[] = { "lex_advance", "lex_look_ahead", "lex_advance", "lex_look_ahead", "lex_advance", "stack_name_pos", "output_stack_assign_int", }; unsigned int count = 7; ecc_context *ctx; mock_data *data; ctx = init_fake_context(tokensv, tokensc); /* mock out the stack name pos response */ data = (mock_data *)ctx->data; data->mock_return_uint_vals[0] = 7; assignment(ctx, tokensv[0]); check_expected_calls(ctx, "test_assignment", expected_calls, count); }
int main (int argc, const char * argv[]) { init(); #ifdef RELEASE asmheader(); #endif do { switch (look) { case '?': input(); break; case '!': output(); break; default: assignment(); break; } newLine(); } while ('.' != look); #ifdef RELEASE asmfooter(); #endif return 0; }
atom::Hierarchy create_coarse_molecule_from_molecule( const atom::Hierarchy &mh,int num_beads, Model *mdl, float bead_radius, bool add_conn_restraint) { IMP_NEW(IMP::statistics::internal::ParticlesDataPoints, ddp, (core::get_leaves(mh))); IMP::statistics::internal::VQClustering vq(ddp,num_beads); vq.run(); multifit::DataPointsAssignment assignment(ddp,&vq); atom::Selections sel; algebra::Vector3Ds vecs; for (int i=0;i<num_beads;i++){ IMP::statistics::internal::Array1DD xyz = assignment.get_cluster_engine()->get_center(i); vecs.push_back(algebra::Vector3D(xyz[0],xyz[1],xyz[2])); } //todo - mass should be a parameter atom::Hierarchy ret_prot=create_molecule(vecs,bead_radius,3,mdl); ParticlesTemp leaves=core::get_leaves(ret_prot); for (ParticlesTemp::iterator it = leaves.begin();it != leaves.end();it++){ sel.push_back(atom::Selection(atom::Hierarchy(*it))); } if (add_conn_restraint){ int k=1;//todo - make this a parameter Restraint *r = atom::create_connectivity_restraint(sel,k); if (r != nullptr){ mdl->add_restraint(r);} } return ret_prot; }
/* List of variable assignments, i.e. "name = value" */ static void assign_list(void) { while (ct.type != TOK_EOF) { assignment(); } }
void goto_convertt::read(exprt &expr, goto_programt &dest) { if(expr.is_constant()) return; if(expr.id()=="symbol") { // see if we already renamed it } symbolt &new_symbol=new_tmp_symbol(expr.type()); codet assignment("assign"); assignment.reserve_operands(2); assignment.copy_to_operands(symbol_expr(new_symbol)); assignment.move_to_operands(expr); goto_programt tmp_program; convert(assignment, tmp_program); dest.destructive_append(tmp_program); expr=symbol_expr(new_symbol); }
goto_programt::targett scratch_programt::assign(const exprt &lhs, const exprt &rhs) { code_assignt assignment(lhs, rhs); targett instruction = add_instruction(ASSIGN); instruction->code = assignment; return instruction; }
static Value * eval(const Ast *expr) { switch(expr->class) { case N_CALL: return call(expr); case N_ASSIGNMENT: return assignment(expr); case N_IDENTIFIER: return identifier(expr); case N_NEG: return _neg(expr); case N_NOT: return _not(expr); case N_EQ: return _eq(expr); case N_NEQ: return _neq(expr); case N_AND: return _and(expr); case N_IOR: return _ior(expr); case N_XOR: return _neq(expr); // alias case N_LT: return _lt(expr); case N_LE: return _le(expr); case N_GE: return _ge(expr); case N_GT: return _gt(expr); case N_ADD: return _add(expr); case N_SUB: return _sub(expr); case N_MUL: return _mul(expr); case N_DIV: return _div(expr); case N_POW: return _pow(expr); case N_MOD: return _mod(expr); case N_BOOLEAN: return _bool(expr); case N_INTEGER: return _int(expr); case N_FLOAT: return _float(expr); case N_STRING: return _string(expr); case N_SET: return _set(expr); case N_R: return _relation(expr); } printf("EVALFAIL %d ", expr->class); pn(expr); assert(false && "should not be reached"); }
void VTerrainDecorationEntityModel::RenderBatchDepthFill(VTerrainVisibilityCollectorComponent *pInfoComp, VTerrainDecorationInstance **pInstList, int iCount) { // depth fill rendering INSERT_PERF_MARKER_SCOPE("VTerrainDecorationEntityModel::RenderBatchDepthFill"); VisDrawCallInfo_t surfaceShaderList[RLP_MAX_ENTITY_SURFACESHADERS]; const int iNumSubmeshes = m_spMesh->GetSubmeshCount(); int iAsmCount = 0; for (int i=0;i<iNumSubmeshes;i++) { VDynamicSubmesh *pSubmesh = m_spMesh->GetSubmesh(i); VisSurface_cl *pSurface = pSubmesh->GetSurface(); if (pSurface->m_spDepthFill==NULL) continue; VisDrawCallInfo_t &assignment(surfaceShaderList[iAsmCount]); assignment.Set(pSubmesh, pSurface, pSurface->m_spDepthFill->GetShader(0)); iAsmCount++; } Vision::RenderLoopHelper.BeginEntityRendering(); for (int i=0;i<iCount;i++) { hkvMat4 transform(pInstList[i]->m_Orientation,pInstList[i]->m_vPosition); Vision::RenderLoopHelper.RenderModelWithSurfaceShaderList(m_spMesh, transform.getPointer (),iAsmCount,surfaceShaderList); } Vision::RenderLoopHelper.EndEntityRendering(); }
void get_segmentation(em::DensityMap *dmap, double apix, double density_threshold, int num_means, const std::string pdb_filename, const std::string cmm_filename, const std::string seg_filename, const std::string txt_filename) { IMP_LOG_VERBOSE("start setting trn_em" << std::endl); IMP_NEW(DensityDataPoints, ddp, (dmap, density_threshold)); IMP_LOG_VERBOSE("initialize calculation of initial centers" << std::endl); statistics::internal::VQClustering vq(ddp, num_means); vq.run(); DataPointsAssignment assignment(ddp, &vq); AnchorsData ad(assignment.get_centers(), *(assignment.get_edges())); multifit::write_pdb(pdb_filename, assignment); // also write cmm string into a file: if (cmm_filename != "") { write_cmm(cmm_filename, "anchor_graph", ad); } if (seg_filename != "") { write_segments_as_mrc(dmap, assignment, apix, apix, density_threshold, seg_filename); } if (txt_filename != "") { write_txt(txt_filename, ad); } }
//**// void statementlists(){ if (lookahead == IF){ //分支语句 switchStatement(); } else if (lookahead == id){ //赋值语句 assignment(); } else if (lookahead == WHILE){ //while语句 loopStatement(); } else if (lookahead == input){ //输入语句 inputStatement(); } else if (lookahead == output){ //输出 outputStatement(); } else if (lookahead == call){ //函数调用 functioncall(); } else if (lookahead == var){ //变量定义 varDefinition(); } else if (lookahead == begin){ //复合语句 complexStatementlists(); } }
void goto_convertt::do_printf( const exprt &lhs, const exprt &function, const exprt::operandst &arguments, goto_programt &dest) { const irep_idt &f_id=function.get(ID_identifier); if(f_id==CPROVER_PREFIX "printf" || f_id=="printf") { typet return_type=static_cast<const typet &>(function.type().find(ID_return_type)); side_effect_exprt printf_code(ID_printf, return_type); printf_code.operands()=arguments; printf_code.add_source_location()=function.source_location(); if(lhs.is_not_nil()) { code_assignt assignment(lhs, printf_code); assignment.add_source_location()=function.source_location(); copy(assignment, ASSIGN, dest); } else { printf_code.id(ID_code); printf_code.type()=typet(ID_code); copy(to_code(printf_code), OTHER, dest); } } else assert(false); }
void Parser::block(std::string l) { while (input.getChar() != '}') { fin(); switch (input.getChar()) { case 'i': doIf(l); break; case 'w': doWhile(); break; case 'l': doLoop(); break; case 'r': doDoWhile(); break; case 'f': doFor(); break; case 'd': doDo(); break; case 'b': doBreak(l); break; default: assignment(); break; } fin(); } }
int main() { unit_test::timeout(); assignment(); named_functions(); operators(); return fail; }
int main(void) { int solution[5]; assignment(solution); ft_read(solution); return (0); }
/* PROGRAMA PRINCIPAL */ int main(){ init(); assignment(); if (look != '\n') expected("NewLine"); return 0; }
void Parser::assignments(MethodGenerationContext* mgenc, list<StdString>& l) { if (symIsIdentifier()) { l.push_back(assignment(mgenc)); Peek(); if (nextSym == Assign) assignments(mgenc, l); } }
void MDParser::inversionstatement() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling switch ( LA(1)) { case ID: { assignment(); astFactory->addASTChild( currentAST, returnAST ); inversionstatement_AST = currentAST.root; break; } case CENTER: { ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; tmp97_AST = astFactory->create(LT(1)); astFactory->makeASTRoot(currentAST, tmp97_AST); match(CENTER); match(LPAREN); intConst(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); inversionstatement_AST = currentAST.root; break; } case SATELLITES: { ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; tmp101_AST = astFactory->create(LT(1)); astFactory->makeASTRoot(currentAST, tmp101_AST); match(SATELLITES); match(LPAREN); inttuple(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); inversionstatement_AST = currentAST.root; break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); recover(ex,_tokenSet_14); } returnAST = inversionstatement_AST; }
void MDParser::atomstatement() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling switch ( LA(1)) { case ID: { assignment(); astFactory->addASTChild( currentAST, returnAST ); atomstatement_AST = currentAST.root; break; } case POSITION: { ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; tmp75_AST = astFactory->create(LT(1)); astFactory->makeASTRoot(currentAST, tmp75_AST); match(POSITION); match(LPAREN); doubleNumberTuple(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); atomstatement_AST = currentAST.root; break; } case ORIENTATION: { ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; tmp79_AST = astFactory->create(LT(1)); astFactory->makeASTRoot(currentAST, tmp79_AST); match(ORIENTATION); match(LPAREN); doubleNumberTuple(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); atomstatement_AST = currentAST.root; break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); recover(ex,_tokenSet_11); } returnAST = atomstatement_AST; }
/* PROGRAMA PRINCIPAL */ int main(){ init(); assignment(); if (look != '\n') expected("NewLine"); printf("%d\n", expression()); return 0; }
Z3_ast Z3_API Z3_get_context_assignment(Z3_context c) { Z3_TRY; LOG_Z3_get_context_assignment(c); RESET_ERROR_CODE(); ast_manager& m = mk_c(c)->m(); expr_ref result(m); expr_ref_vector assignment(m); mk_c(c)->get_smt_kernel().get_assignments(assignment); result = mk_c(c)->mk_and(assignment.size(), assignment.c_ptr()); RETURN_Z3(of_ast(result.get())); Z3_CATCH_RETURN(0); }
static void exprstat (LexState *ls) { /* stat -> func | assignment */ FuncState *fs = ls->fs; struct LHS_assign v; primaryexp(ls, &v.v); if (v.v.k == VCALL) /* stat -> func */ SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ else { /* stat -> assignment */ v.prev = NULL; assignment(ls, &v, 1); } }
static void exprstat (LexState *ls) { #if LUA_MUTATION_OPERATORS /* stat -> func | compound | assignment */ #else /* stat -> func | assignment */ #endif /* LUA_MUTATION_OPERATORS */ FuncState *fs = ls->fs; struct LHS_assign v; primaryexp(ls, &v.v); if (v.v.k == VCALL) /* stat -> func */ SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ #if LUA_MUTATION_OPERATORS else { /* stat -> compound | assignment */ v.prev = NULL; switch(ls->t.token) { case TK_ADD_EQ: case TK_SUB_EQ: case TK_MUL_EQ: case TK_DIV_EQ: case TK_MOD_EQ: case TK_POW_EQ: compound(ls, &v); break; case ',': case '=': assignment(ls, &v, 1); break; default: luaX_syntaxerror(ls, luaO_pushfstring(ls->L, "'+=','-=','*=', '/=', '%=', '^=', '=' expected")); break; } #else else { /* stat -> assignment */ v.prev = NULL; assignment(ls, &v, 1); #endif /* LUA_MUTATION_OPERATORS */ } }