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 */
}
}
