void weak_shared( boost::weak_ptr<FIRST>& first, boost::shared_ptr<SECOND>& second ){ const char * testfile = boost::archive::tmpnam(NULL); BOOST_REQUIRE(NULL != testfile); int firstm = first.lock()->m_x; int secondm = second->m_x; save2(testfile, first, second); // Clear the pointers, thereby destroying the objects they contain first.reset(); second.reset(); load2(testfile, first, second); // Check data member BOOST_CHECK(firstm == first.lock()->m_x); BOOST_CHECK(secondm == second->m_x); // Check pointer to vtable BOOST_CHECK(boost::dynamic_pointer_cast<Sub>(first.lock())); BOOST_CHECK(boost::dynamic_pointer_cast<Sub>(second)); std::remove(testfile); }
void shared_weak( SP & first, WP & second ){ const char * testfile = boost::archive::tmpnam(NULL); BOOST_REQUIRE(NULL != testfile); int firstm = first->m_x; BOOST_REQUIRE(! second.expired()); int secondm = second.lock()->m_x; save2(testfile, first, second); // Clear the pointers, thereby destroying the objects they contain second.reset(); first.reset(); load2(testfile, first, second); BOOST_CHECK(! second.expired()); // Check data member BOOST_CHECK(firstm == first->m_x); BOOST_CHECK(secondm == second.lock()->m_x); // Check pointer to vtable BOOST_CHECK(::dynamic_pointer_cast<Sub>(first)); BOOST_CHECK(::dynamic_pointer_cast<Sub>(second.lock())); std::remove(testfile); }
static void execSave(Inst inst) { RegisterExp regExp = insGetSave(inst); char* name = rexGetName(regExp); Register reg = rexGetReg(regExp); #ifdef STACK_GUARDED save2(name, reg); #else save(reg); #endif rsAdvancePc(); }
int main() { int num; int count = 0; TMOD=0x01; TH0=(65536-50000)/256; TL0=(65536-50000)%256; EA=1; ET0=1; //开中断 TR0=1; init(); P2=0xff; st: lock=0; while(1) { write_com(0x01); write_lcd(0x40,"save take"); num = key(); if(num == 10) //存放模式 { NO1 = TH0; NO2 = TL0; save2(); } if(num == 11) //取出模式 { take2(); } if(lock>4) { lk: write_com(0x01); write_lcd(0x00," lock on! "); while(1) { if(key() == 13) { write_lcd(0x00,"admin: "); if(admin_key() == 1) { lock = 0; goto st; } goto lk; } } } } return 0; }
void to_hex(std::ostream& out, BinarySequence::const_iterator begin, BinarySequence::const_iterator end) { boost::io::ios_flags_saver save1(out); boost::io::ios_width_saver save2(out); boost::io::ios_precision_saver save3(out); out << std::hex << std::setw(1) << std::setprecision(1); while(end - begin >= 4) { int x = 0; for(int i=0; i<4; ++i) { x |= begin.pop<bool>() << i; } out << x; } }
// Run tests by serializing two shared_ptrs into an archive, // clearing them (deleting the objects) and then reloading the // objects back from an archive. void save_and_load2(boost::shared_ptr<A>& first, boost::shared_ptr<A>& second) { const char * testfile = boost::archive::tmpnam(NULL); BOOST_REQUIRE(NULL != testfile); save2(testfile, first, second); // Clear the pointers, thereby destroying the objects they contain first.reset(); second.reset(); load2(testfile, first, second); BOOST_CHECK(first == second); std::remove(testfile); }
/*================================== ParseColorPattern ===================================*/ void PTPatternView::ParseColorPattern( Handle inPattern, SUOffscreen **outColor, SUOffscreen **outBW ) { // See IM V-79 for details StSaveGWorld save1; StHandleLocker save2( inPattern ); PixPatPtr p = (PixPatPtr) *inPattern; CTabHandle theTable = nil; SUOffscreen *tempColorBuffer = nil, *colorBuffer = nil, *bwBuffer = nil; try { if ( p->patType != 1 ) LException::Throw( err_InvalidImageFormat ); /******************************************* first handle the b&w pattern ********************************************/ bwBuffer = this->BWPatternToOffscreen( p->pat1Data ); /******************************************* now the color pattern ********************************************/ PixMapPtr theMap = (PixMapPtr)( *inPattern + (SInt32) p->patMap ); UInt8 * theData = (UInt8*)( *inPattern + (SInt32) p->patData ); SInt32 depth = theMap->pixelSize; SInt32 width = theMap->bounds.right - theMap->bounds.left; SInt32 height = theMap->bounds.bottom - theMap->bounds.top; SInt32 rowBytes = theMap->rowBytes & 0x3FFF; // clear flags if ( (depth != 1) && (depth != 2) && (depth != 4) && (depth != 8) ) LException::Throw( err_InvalidImageDepth ); if ( (width <= 3) || (width > 64) || (height <= 3) || (height > 64) ) LException::Throw( err_InvalidImageSize ); theTable = SUColorUtils::NewColorTableFromPtr( depth, (UInt8*)( *inPattern + (SInt32)theMap->pmTable) ); tempColorBuffer = SUOffscreen::CreateBuffer( width, height, depth, theTable ); tempColorBuffer->CopyFromRawData( theData, rowBytes ); // now switch to a 32-bit buffer colorBuffer = SUOffscreen::CreateBuffer( width, height, 32 ); colorBuffer->CopyFrom( tempColorBuffer ); } catch( ... ) { delete colorBuffer; delete bwBuffer; delete tempColorBuffer; if ( theTable ) ::DisposeCTable( theTable ); throw; } *outColor = colorBuffer; *outBW = bwBuffer; if ( theTable ) ::DisposeCTable( theTable ); delete tempColorBuffer; }
/* An explicit control evaluator, taken almost directly from SICP, section * 5.2. list is a flat list of expressions to evaluate. where is a label to * begin at. Return value depends on where. */ NODE *evaluator(NODE *list, enum labels where) { /* registers */ NODE *exp = NIL, /* the current expression */ *val = NIL, /* the value of the last expression */ *proc = NIL, /* the procedure definition */ *argl = NIL, /* evaluated argument list */ *unev = NIL, /* list of unevaluated expressions */ *stack = NIL, /* register stack */ *parm = NIL, /* the current formal */ *catch_tag = NIL, *arg = NIL; /* the current actual */ /* registers that don't get reference counted, so we pretend they're ints */ FIXNUM vsp = 0, /* temp ptr into var_stack */ cont = 0, /* where to go next */ formals = (FIXNUM)NIL; /* list of formal parameters */ int i, nargs; BOOLEAN tracing; /* are we tracing the current procedure? */ FIXNUM oldtailcall; /* in case of reentrant use of evaluator */ FIXNUM repcount; /* count for repeat */ FIXNUM old_ift_iff; oldtailcall = tailcall; old_ift_iff = ift_iff_flag; save2(var,this_line); assign(var, var_stack); save2(fun,ufun); cont = (FIXNUM)all_done; numsave((FIXNUM)cont); newcont(where); goto fetch_cont; begin_line: ref(list); assign(this_line, list); newcont(end_line); begin_seq: make_tree(list); if (!is_tree(list)) { assign(val, UNBOUND); goto fetch_cont; } assign(unev, tree__tree(list)); assign(val, UNBOUND); goto eval_sequence; end_line: if (val != UNBOUND) { if (NOT_THROWING) err_logo(DK_WHAT, val); deref(val); } val = NIL; deref(list); goto fetch_cont; /* ----------------- EVAL ---------------------------------- */ tail_eval_dispatch: tailcall = 1; eval_dispatch: switch (nodetype(exp)) { case QUOTE: /* quoted literal */ assign(val, node__quote(exp)); goto fetch_cont; case COLON: /* variable */ assign(val, valnode__colon(exp)); while (val == UNBOUND && NOT_THROWING) assign(val, err_logo(NO_VALUE, node__colon(exp))); goto fetch_cont; case CONS: /* procedure application */ if (tailcall == 1 && is_macro(car(exp)) && is_list(procnode__caseobj(car(exp)))) { /* tail call to user-defined macro must be treated as non-tail * because the expression returned by the macro * remains to be evaluated in the caller's context */ assign(unev, NIL); goto non_tail_eval; } assign(fun, car(exp)); if (cdr(exp) != NIL) goto ev_application; else goto ev_no_args; default: assign(val, exp); /* self-evaluating */ goto fetch_cont; } ev_no_args: /* Evaluate an application of a procedure with no arguments. */ assign(argl, NIL); goto apply_dispatch; /* apply the procedure */ ev_application: /* Evaluate an application of a procedure with arguments. */ assign(unev, cdr(exp)); assign(argl, NIL); mixsave(tailcall,var); num2save(val_status,ift_iff_flag); save2(didnt_get_output,didnt_output_name); eval_arg_loop: if (unev == NIL) goto eval_args_done; assign(exp, car(unev)); if (exp == Not_Enough_Node) { if (NOT_THROWING) err_logo(NOT_ENOUGH, NIL); goto eval_args_done; } save(argl); save2(unev,fun); save2(ufun,last_ufun); save2(this_line,last_line); assign(var, var_stack); tailcall = -1; val_status = 1; assign(didnt_get_output, cons_list(0,fun,ufun,this_line,END_OF_LIST)); assign(didnt_output_name, NIL); newcont(accumulate_arg); goto eval_dispatch; /* evaluate the current argument */ accumulate_arg: /* Put the evaluated argument into the argl list. */ reset_args(var); restore2(this_line,last_line); restore2(ufun,last_ufun); assign(last_call, fun); restore2(unev,fun); restore(argl); while (NOT_THROWING && val == UNBOUND) { assign(val, err_logo(DIDNT_OUTPUT, NIL)); } push(val, argl); pop(unev); goto eval_arg_loop; eval_args_done: restore2(didnt_get_output,didnt_output_name); num2restore(val_status,ift_iff_flag); mixrestore(tailcall,var); if (stopping_flag == THROWING) { assign(val, UNBOUND); goto fetch_cont; } assign(argl, reverse(argl)); /* --------------------- APPLY ---------------------------- */ apply_dispatch: /* Load in the procedure's definition and decide whether it's a compound * procedure or a primitive procedure. */ proc = procnode__caseobj(fun); if (is_macro(fun)) { num2save(val_status,tailcall); val_status = 1; newcont(macro_return); } if (proc == UNDEFINED) { if (ufun != NIL) { untreeify_proc(ufun); } if (NOT_THROWING) assign(val, err_logo(DK_HOW, fun)); else assign(val, UNBOUND); goto fetch_cont; } if (is_list(proc)) goto compound_apply; /* primitive_apply */ if (NOT_THROWING) assign(val, (*getprimfun(proc))(argl)); else assign(val, UNBOUND); #define do_case(x) case x: goto x; fetch_cont: { enum labels x = (enum labels)cont; cont = (FIXNUM)car(stack); numpop(&stack); switch (x) { do_list(do_case) default: abort(); } } compound_apply: #ifdef mac check_mac_stop(); #endif #ifdef ibm check_ibm_stop(); #endif if (tracing = flag__caseobj(fun, PROC_TRACED)) { for (i = 0; i < trace_level; i++) print_space(writestream); trace_level++; ndprintf(writestream, "( %s ", fun); } /* Bind the actuals to the formals */ vsp = (FIXNUM)var_stack; /* remember where we came in */ for (formals = (FIXNUM)formals__procnode(proc); formals != (FIXNUM)NIL; formals = (FIXNUM)cdr((NODE *)formals)) { parm = car((NODE *)formals); if (nodetype(parm) == INT) break; /* default # args */ if (argl != NIL) { arg = car(argl); if (tracing) { print_node(writestream, maybe_quote(arg)); print_space(writestream); } } else arg = UNBOUND; if (nodetype(parm) == CASEOBJ) { if (not_local(parm,(NODE *)vsp)) { push(parm, var_stack); setobject(var_stack, valnode__caseobj(parm)); } tell_shadow(parm); setvalnode__caseobj(parm, arg); } else if (nodetype(parm) == CONS) { /* parm is optional or rest */ if (not_local(car(parm),(NODE *)vsp)) { push(car(parm), var_stack); setobject(var_stack, valnode__caseobj(car(parm))); } tell_shadow(car(parm)); if (cdr(parm) == NIL) { /* parm is rest */ setvalnode__caseobj(car(parm), argl); break; } if (arg == UNBOUND) { /* use default */ save2(fun,var); save2(ufun,last_ufun); save2(this_line,last_line); save2(didnt_output_name,didnt_get_output); num2save(ift_iff_flag,val_status); assign(var, var_stack); tailcall = -1; val_status = 1; mixsave(formals,argl); numsave(vsp); assign(list, cdr(parm)); if (NOT_THROWING) make_tree(list); else assign(list, NIL); if (!is_tree(list)) { assign(val, UNBOUND); goto set_args_continue; } assign(unev, tree__tree(list)); assign(val, UNBOUND); newcont(set_args_continue); goto eval_sequence; set_args_continue: numrestore(vsp); mixrestore(formals,argl); parm = car((NODE *)formals); reset_args(var); num2restore(ift_iff_flag,val_status); restore2(didnt_output_name,didnt_get_output); restore2(this_line,last_line); restore2(ufun,last_ufun); restore2(fun,var); arg = val; } setvalnode__caseobj(car(parm), arg); } if (argl != NIL) pop(argl); } if (check_throwing) { assign(val, UNBOUND); goto fetch_cont; } vsp = 0; if (tracing = flag__caseobj(fun, PROC_TRACED)) { if (NOT_THROWING) print_char(writestream, ')'); new_line(writestream); save(fun); newcont(compound_apply_continue); } assign(val, UNBOUND); assign(last_ufun, ufun); assign(ufun, fun); assign(last_line, this_line); assign(this_line, NIL); proc = procnode__caseobj(fun); assign(list, bodylist__procnode(proc)); /* get the body ... */ make_tree_from_body(list); if (!is_tree(list)) { goto fetch_cont; } assign(unev, tree__tree(list)); if (NOT_THROWING) stopping_flag = RUN; assign(output_node, UNBOUND); if (val_status == 1) val_status = 2; else if (val_status == 5) val_status = 3; else val_status = 0; eval_sequence: /* Evaluate each expression in the sequence. Stop as soon as * val != UNBOUND. */ if (!RUNNING || val != UNBOUND) { goto fetch_cont; } if (nodetype(unev) == LINE) { assign(this_line, unparsed__line(unev)); if (flag__caseobj(ufun, PROC_STEPPED)) { char junk[20]; if (tracing) { int i = 1; while (i++ < trace_level) print_space(stdout); } print_node(stdout, this_line); ndprintf(stdout, " >>> "); input_blocking++; #ifndef TIOCSTI if (!setjmp(iblk_buf)) #endif #ifdef __ZTC__ ztc_getcr(); #else fgets(junk, 19, stdin); #endif input_blocking = 0; update_coords('\n'); } } assign(exp, car(unev)); pop(unev); if (is_list(exp) && (is_tailform(procnode__caseobj(car(exp))))) { if (nameis(car(exp),Output) || nameis(car(exp),Op)) { assign(didnt_get_output, cons_list(0,car(exp),ufun,this_line,END_OF_LIST)); assign(didnt_output_name, NIL); if (val_status == 2 || val_status == 3) { val_status = 1; assign(exp, cadr(exp)); goto tail_eval_dispatch; } else if (ufun == NIL) { err_logo(AT_TOPLEVEL,car(exp)); assign(val, UNBOUND); goto fetch_cont; } else if (val_status < 4) { val_status = 1; assign(exp, cadr(exp)); assign(unev, NIL); goto non_tail_eval; /* compute value then give error */ } } else if (nameis(car(exp),Stop)) { if (ufun == NIL) { err_logo(AT_TOPLEVEL,car(exp)); assign(val, UNBOUND); goto fetch_cont; } else if (val_status == 0 || val_status == 3) { assign(val, UNBOUND); goto fetch_cont; } else if (val_status < 4) { assign(didnt_output_name, fun); assign(val, UNBOUND); goto fetch_cont; } } else { /* maybeoutput */ assign(exp, cadr(exp)); val_status = 5; goto tail_eval_dispatch; } } if (unev == NIL) { if (val_status == 2 || val_status == 4) { assign(didnt_output_name, fun); assign(unev, UNBOUND); goto non_tail_eval; } else { goto tail_eval_dispatch; } } if (is_list(car(unev)) && nameis(car(car(unev)),Stop)) { if ((val_status == 0 || val_status == 3) && ufun != NIL) { goto tail_eval_dispatch; } else if (val_status < 4) { assign(didnt_output_name, fun); goto tail_eval_dispatch; } } non_tail_eval: save2(unev,fun); num2save(ift_iff_flag,val_status); save2(ufun,last_ufun); save2(this_line,last_line); save(var); assign(var, var_stack); tailcall = 0; newcont(eval_sequence_continue); goto eval_dispatch; eval_sequence_continue: reset_args(var); restore(var); restore2(this_line,last_line); restore2(ufun,last_ufun); if (dont_fix_ift) { num2restore(dont_fix_ift,val_status); dont_fix_ift = 0; } else num2restore(ift_iff_flag,val_status); restore2(unev,fun); if (stopping_flag == MACRO_RETURN) { if (unev == UNBOUND) assign(unev, NIL); assign(unev, append(val, unev)); assign(val, UNBOUND); stopping_flag = RUN; if (unev == NIL) goto fetch_cont; } else if (val_status < 4) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2 && NOT_THROWING) { assign(didnt_output_name,Output); err_logo(DIDNT_OUTPUT,Output); } if (val == UNBOUND && val_status == 1 && NOT_THROWING) { assign(didnt_output_name,Stop); err_logo(DIDNT_OUTPUT,Output); } goto fetch_cont; } } if (val != UNBOUND) { err_logo((unev == NIL ? DK_WHAT_UP : DK_WHAT), val); assign(val, UNBOUND); } if (NOT_THROWING && (unev == NIL || unev == UNBOUND)) { if (val_status != 4) err_logo(DIDNT_OUTPUT,NIL); goto fetch_cont; } goto eval_sequence; compound_apply_continue: /* Only get here if tracing */ restore(fun); --trace_level; if (NOT_THROWING) { for (i = 0; i < trace_level; i++) print_space(writestream); print_node(writestream, fun); if (val == UNBOUND) ndprintf(writestream, " stops\n"); else { ref(val); ndprintf(writestream, " outputs %s\n", maybe_quote(val)); deref(val); } } goto fetch_cont; /* --------------------- MACROS ---------------------------- */ macro_return: num2restore(val_status,tailcall); while (!is_list(val) && NOT_THROWING) { assign(val,err_logo(ERR_MACRO,val)); } if (NOT_THROWING) { if (is_cont(val)) { newcont(cont__cont(val)); val->n_car = NIL; assign(val, val__cont(val)); goto fetch_cont; } macro_reval: if (tailcall == 0) { make_tree(val); stopping_flag = MACRO_RETURN; if (!is_tree(val)) assign(val, NIL); else assign(val, tree__tree(val)); goto fetch_cont; } assign(list,val); goto begin_seq; } assign(val, UNBOUND); goto fetch_cont; runresult_continuation: assign(list, val); newcont(runresult_followup); val_status = 5; goto begin_seq; runresult_followup: if (val == UNBOUND) { assign(val, NIL); } else { assign(val, cons(val, NIL)); } goto fetch_cont; repeat_continuation: assign(list, cdr(val)); repcount = getint(car(val)); repeat_again: assign(val, UNBOUND); if (repcount == 0) goto fetch_cont; mixsave(repcount,list); num2save(val_status,tailcall); val_status = 4; newcont(repeat_followup); goto begin_seq; repeat_followup: if (val != UNBOUND && NOT_THROWING) { ref(val); err_logo(DK_WHAT, val); unref(val); } num2restore(val_status,tailcall); mixrestore(repcount,list); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } goto fetch_cont; } } if (repcount > 0) /* negative means forever */ --repcount; #ifdef mac check_mac_stop(); #endif #ifdef ibm check_ibm_stop(); #endif if (RUNNING) goto repeat_again; assign(val, UNBOUND); goto fetch_cont; catch_continuation: assign(list, cdr(val)); assign(catch_tag, car(val)); if (compare_node(catch_tag,Error,TRUE) == 0) { push(Erract, var_stack); setobject(var_stack, valnode__caseobj(Erract)); setvalnode__caseobj(Erract, UNBOUND); } save(catch_tag); save2(didnt_output_name,didnt_get_output); num2save(val_status,tailcall); newcont(catch_followup); val_status = 5; goto begin_seq; catch_followup: num2restore(val_status,tailcall); restore2(didnt_output_name,didnt_get_output); restore(catch_tag); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } } } if (stopping_flag == THROWING && compare_node(throw_node, catch_tag, TRUE) == 0) { throw_node = reref(throw_node, UNBOUND); stopping_flag = RUN; assign(val, output_node); } goto fetch_cont; begin_apply: /* This is for lapply. */ assign(fun, car(val)); while (nodetype(fun) == ARRAY && NOT_THROWING) assign(fun, err_logo(APPLY_BAD_DATA, fun)); assign(argl, cadr(val)); assign(val, UNBOUND); while (!is_list(argl) && NOT_THROWING) assign(argl, err_logo(APPLY_BAD_DATA, argl)); if (NOT_THROWING && fun != NIL) { if (is_list(fun)) { /* template */ if (is_list(car(fun)) && cdr(fun) != NIL) { /* lambda form */ formals = (FIXNUM)car(fun); numsave(tailcall); tailcall = 0; llocal((NODE *)formals); /* bind the formals locally */ numrestore(tailcall); for ( ; formals && argl && NOT_THROWING; formals = (FIXNUM)cdr((NODE *)formals), assign(argl, cdr(argl))) setvalnode__caseobj(car((NODE *)formals), car(argl)); assign(val, cdr(fun)); goto macro_reval; } else { /* question-mark form */ save(qm_list); assign(qm_list, argl); assign(list, fun); make_tree(list); if (list == NIL || !is_tree(list)) { goto qm_failed; } assign(unev, tree__tree(list)); save2(didnt_output_name,didnt_get_output); num2save(val_status,tailcall); newcont(qm_continue); val_status = 5; goto eval_sequence; qm_continue: num2restore(val_status,tailcall); restore2(didnt_output_name,didnt_get_output); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } } } qm_failed: restore(qm_list); goto fetch_cont; } } else { /* name of procedure to apply */ int min, max, n; NODE *arg; assign(fun, intern(fun)); if (procnode__caseobj(fun) == UNDEFINED && NOT_THROWING && fun != Null_Word) silent_load(fun, NULL); /* try ./<fun>.lg */ if (procnode__caseobj(fun) == UNDEFINED && NOT_THROWING && fun != Null_Word) silent_load(fun, logolib); /* try <logolib>/<fun> */ proc = procnode__caseobj(fun); while (proc == UNDEFINED && NOT_THROWING) { assign(val, err_logo(DK_HOW_UNREC, fun)); } if (NOT_THROWING) { if (nodetype(proc) == CONS) { min = getint(minargs__procnode(proc)); max = getint(maxargs__procnode(proc)); } else { if (getprimdflt(proc) < 0) { /* special form */ err_logo(DK_HOW_UNREC, fun); /* can't apply */ goto fetch_cont; } else { min = getprimmin(proc); max = getprimmax(proc); } } for (n = 0, arg = argl; arg != NIL; n++, arg = cdr(arg)); if (n < min) { err_logo(NOT_ENOUGH, NIL); } else if (n > max && max >= 0) { err_logo(TOO_MUCH, NIL); } else { goto apply_dispatch; } } } } goto fetch_cont; all_done: tailcall = oldtailcall; ift_iff_flag = old_ift_iff; restore2(fun,ufun); reset_args(var); restore2(var,this_line); deref(argl);deref(unev);deref(stack);deref(catch_tag);deref(exp); return(val); }
void Keys::save(void) { data->crc8 = crc8( (uint8_t*)data, sizeof(KeysCRCed), CRC8INIT ); eeprom_write_block((const void*)data, (void*)EEPROM_KEYS_OFFSET, sizeof(KeysShared)); save2(); }
void shakil::first() { tm=0; showmouseptr(); while(1) { getmousepos(&button,&x,&y); if(tm==0) { hidemouseptr(); setcolor(7); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,7); floodfill(110,110,7); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,7); floodfill(110,170,7); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,7); floodfill(110,220,7); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,7); floodfill(110,270,7); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,7); floodfill(110,320,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); tm=10; showmouseptr(); } p=x;m=y; if(p>105&&p<345) {if((m>105&&m<155)&&tm!=1) {tm=1; hidemouseptr(); setcolor(123); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,123); floodfill(110,110,123); setcolor(7); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,7); floodfill(110,170,7); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,7); floodfill(110,220,7); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,7); floodfill(110,270,7); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,7); floodfill(110,320,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); showmouseptr(); } if((m>160&&m<205)&&tm!=2) { tm=2; hidemouseptr(); setcolor(123); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,123); floodfill(110,170,123); setcolor(7); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,7); floodfill(110,110,7); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,7); floodfill(110,220,7); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,7); floodfill(110,270,7); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,7); floodfill(110,320,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); showmouseptr(); } if((m>210&&m<255)&&tm!=3) { tm=3; hidemouseptr(); setcolor(123); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,123); floodfill(110,220,123); setcolor(7); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,7); floodfill(110,170,7); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,7); floodfill(110,110,7); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,7); floodfill(110,270,7); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,7); floodfill(110,320,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); showmouseptr(); } if((m>260&&m<305)&&tm!=4) {tm=4; hidemouseptr(); setcolor(123); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,123); floodfill(110,270,123); setcolor(7); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,7); floodfill(110,170,7); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,7); floodfill(110,220,7); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,7); floodfill(110,110,7); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,7); floodfill(110,320,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); showmouseptr(); } if((m>310&&m<345)&&tm!=5) {tm=5; hidemouseptr(); setcolor(123); rectangle(105,310,345,345); setfillstyle(SOLID_FILL,123); floodfill(110,320,123); setcolor(7); rectangle(105,160,345,205); setfillstyle(SOLID_FILL,7); floodfill(110,170,7); rectangle(105,210,345,255); setfillstyle(SOLID_FILL,7); floodfill(110,220,7); rectangle(105,105,345,155); setfillstyle(SOLID_FILL,7); floodfill(110,110,7); rectangle(105,260,345,305); setfillstyle(SOLID_FILL,7); floodfill(110,270,7); setcolor(RED); settextstyle(1,0,5); outtextxy(130,106," NEW "); outtextxy(130,161," EASY "); outtextxy(130,211," EXIT "); outtextxy(95,255," LOAD GAME"); outtextxy(105,300,"TURNAMENT"); rectangle(100,100,350,350); showmouseptr(); } if(m<105||m>345) if(tm!=0) tm=0; } else if(tm!=0) tm=0; if((button & 1)==1) {if(x>=105&&x<=345) { if(y>=210&&y<=255) break; if(y>=105&&y<=155) {result=0; hidemouseptr(); new1(); continue; } if(y>=160&&y<=250) {result=0; hidemouseptr(); easy(); continue; } if(y>=260&&y<=305) {result=0; save2(); continue; } if(y>=310&&y<=345) {result=0; turna(); continue; } }} delay(100); } }
int main(int argc, char **argv) { PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL); int iter = 1; double Re = 1; double cfl = 10; double mu_l = 1.0; double rho_l = 1.0; //Solver *solverP = new PetscSolver(KSPPREONLY,PCNONE); Solver *solverP = new PetscSolver(KSPCG,PCSOR); Solver *solverV = new PetscSolver(KSPCG,PCICC); const char *binFolder = "./bin/"; const char *datFolder = "./dat/"; const char *vtkFolder = "./vtk/"; const char *simFolder = "./sim/"; string meshFile = "disk6-10-20.vtk"; string meshDir = (string) getenv("DATA_DIR"); meshDir += "/mesh/3d/" + meshFile; const char *mesh = meshDir.c_str(); Model3D m1; m1.setMeshDisk(6,10,10); m1.setAdimenDisk(); m1.setMapping(); #if NUMGLEU == 5 m1.setMiniElement(); #else m1.setQuadElement(); #endif m1.setNeighbour(); m1.setTriEdge(); m1.setMapEdgeTri(); m1.setInitSurfaceArea(); m1.setSurfaceArea(); m1.setInitSurfaceVolume(); m1.setSurfaceVolume(); m1.tetMeshStats(); Model3D mOld = m1; // F, G and H m1.setInfiniteSphereBC(0.0,0.0,0.0); //m1.setCDiskBC(); InOut save2(m1); // cria objeto de gravacao save2.saveVTK(vtkFolder,"disk"); m1.transformDiskToSphere(); InOut save3(m1); // cria objeto de gravacao save3.saveVTK(vtkFolder,"sphere"); Simulator3D s1(m1); s1.setRe(Re); s1.setCfl(cfl); s1.setMu(mu_l); s1.setRho(rho_l); s1.setSolverVelocity(solverV); s1.setSolverPressure(solverP); s1.init(); //s1.initDiskBaseState("../../db/baseState/nuCte/","analiticoNuCte.dat"); s1.setDtEulerian(); s1.assembleNuCte(); //s1.assembleC(); s1.matMount(); //s1.matMountC(); s1.setUnCoupledBC(); //s1.setUnCoupledCBC(); if( (*(argv+1)) == NULL ) { cout << endl; cout << "--------------> STARTING FROM 0" << endl; cout << endl; } else if( strcmp( *(argv+1),"restart") == 0 ) { cout << endl; cout << "--------------> RE-STARTING..." << endl; cout << endl; iter = s1.loadSolution("./","sim",atoi(*(argv+2))); } InOut save(m1,s1); // cria objeto de gravacao save.saveVTK(vtkFolder,"geometry"); save.saveInfo("./","info",mesh); save.printSimulationReport(); int nIter = 1000; int nR = 10; for( int i=0;i<nIter;i++ ) { for( int j=0;j<nR;j++ ) { cout << color(none,magenta,black); cout << "____________________________________ Iteration: " << i*nR+j+iter << endl << endl; cout << resetColor(); /* dt variable */ //s1.setDtEulerian(); //s1.assembleNuCte(); ////s1.assembleC(); //s1.matMount(); ////s1.matMountC(); //s1.setUnCoupledBC(); //s1.setUnCoupledCBC(); s1.stepSL(); s1.setRHS(); //s1.setCRHS(); s1.unCoupled(); //s1.unCoupledC(); save.saveVonKarman(mOld,simFolder,"vk"); //-------------------------------------------------- // save.saveDiskRadiusError(simFolder, // "vkError", // "../../db/baseState/nuCte/analiticoNuCte.dat"); // save.saveDiskError(datFolder, // "diskError", // "../../db/baseState/nuCte/analiticoNuCte.dat"); //-------------------------------------------------- save.saveConvergence(datFolder,"convergence"); s1.saveOldData(); s1.timeStep(); cout << color(none,magenta,black); cout << "________________________________________ END of " << i*nR+j+iter << endl << endl;; cout << resetColor(); } save.saveVTK(vtkFolder,"sim",(i+1)*nR+iter-1); //save.saveVTKSurface(vtkFolder,"sim",(nR-1)+i*nR+iter-1); save.saveSol(binFolder,"sim",(i+1)*nR+iter-1); save.printMeshReport(); save.saveMeshInfo(datFolder); } PetscFinalize(); return 0; }