/*** do cyclic coordinate descent optimization for fixed lambda1 * repeat coordinate descent algorithm until solution is converged ***/ bool cdescent_do_update_one_cycle (cdescent *cd) { int ccd_iter = 0; bool converged = false; update_one_cycle update_func; update_func = (cd->rule == CDESCENT_SELECTION_RULE_STOCHASTIC) ? cdescent_do_update_once_cycle_stochastic : cdescent_do_update_once_cycle_cyclic; if (!cd) error_and_exit ("cdescent_do_cyclic_update", "cdescent *cd is empty.", __FILE__, __LINE__); while (!converged) { converged = update_func (cd); if (++ccd_iter >= cd->maxiter) { printf_warning ("cdescent_do_cyclic_update", "reaching max number of iterations.", __FILE__, __LINE__); break; } } cd->total_iter += ccd_iter; return converged; }
//---------------------------------------------------------------------- bool create_func_frame(func_t *pfn) // create frame of newly created function { bool std_vars_func = true; if ( pfn != NULL ) { if ( pfn->frame == BADNODE ) { ea_t ea = pfn->startEA; int regsize = 0; while (ea < pfn->endEA) // check for register pushs { decode_insn(ea); ea += cmd.size; // считаем кол-во push if ( (cmd.itype == OAK_Dsp_push) && (cmd.Op1.type == o_reg) ) regsize++; else break; } ea = pfn->startEA; int16 localsize = 0; while (ea < pfn->endEA) // check for frame creation { decode_insn(ea); ea += cmd.size; // Попытка определить команду типа ADDV #,SP if ( (cmd.itype == OAK_Dsp_addv) && (cmd.Op1.type == o_imm) && (cmd.Op2.type == o_reg) && (cmd.Op2.reg == SP) ) { localsize = (uint16)cmd.Op1.value; break; } // Если встретили команду mov #, rb --> не надо создавать фрейм такой ф-ции, и объявлять локальные переменные if ( (cmd.itype == OAK_Dsp_mov) && (cmd.Op1.type == o_imm) && (cmd.Op2.type == o_reg) && (cmd.Op2.reg == RB) ) { std_vars_func = false; break; } } if (std_vars_func) { pfn->flags |= FUNC_FRAME; update_func(pfn); } add_frame(pfn, -localsize, (ushort)regsize, 0); } } return 0; }
gboolean tm_work_object_update(TMWorkObject *work_object, gboolean force , gboolean recurse, gboolean update_parent) { if ((NULL != work_object) && (work_object->type > 0) && (work_object->type < s_work_object_subclasses->len) && (s_work_object_subclasses->pdata[work_object->type] != NULL)) { TMUpdateFunc update_func = ((TMWorkObjectClass *)s_work_object_subclasses->pdata[work_object->type])->update_func; if (NULL != update_func) return update_func(work_object, force, recurse, update_parent); } return FALSE; }
static void _cleanup_get_all_subdirs (gftp_transfer * transfer, char *oldfromdir, char *oldtodir, void (*update_func) (gftp_transfer * transfer)) { if (update_func != NULL) { transfer->numfiles = transfer->numdirs = -1; update_func (transfer); } if (oldfromdir != NULL) g_free (oldfromdir); if (oldtodir != NULL) g_free (oldtodir); }
//---------------------------------------------------------------------- static void setup_far_func(func_t *pfn) { if ( (pfn->flags & FUNC_FAR) == 0 ) { ea_t ea1 = pfn->startEA; ea_t ea2 = pfn->endEA; while ( ea1 < ea2 ) { if ( isCode(get_flags_novalue(ea1)) ) { decode_insn(ea1); if ( is_far_ending() ) { pfn->flags |= FUNC_FAR; update_func(pfn); break; } } ea1 = next_head(ea1, ea2); } } }
void EIF::receive_spike() { update_func(); }
void QuadIF::receive_spike() { update_func(); }
void StochLIF::receive_spike() { update_func(); }
static TEE_Result tee_buffer_update( TEE_OperationHandle op, TEE_Result(*update_func)(unsigned long state, const void *src, size_t slen, void *dst, uint64_t *dlen), const void *src_data, size_t src_len, void *dest_data, uint64_t *dest_len) { TEE_Result res; const uint8_t *src = src_data; size_t slen = src_len; uint8_t *dst = dest_data; size_t dlen = *dest_len; size_t acc_dlen = 0; uint64_t tmp_dlen; size_t l; size_t buffer_size; size_t buffer_left; if (op->buffer_two_blocks) { buffer_size = op->block_size * 2; buffer_left = 1; } else { buffer_size = op->block_size; buffer_left = 0; } if (op->buffer_offs > 0) { /* Fill up complete block */ if (op->buffer_offs < op->block_size) l = MIN(slen, op->block_size - op->buffer_offs); else l = MIN(slen, buffer_size - op->buffer_offs); memcpy(op->buffer + op->buffer_offs, src, l); op->buffer_offs += l; src += l; slen -= l; if ((op->buffer_offs % op->block_size) != 0) goto out; /* Nothing left to do */ } /* If we can feed from buffer */ if ((op->buffer_offs > 0) && ((op->buffer_offs + slen) >= (buffer_size + buffer_left))) { l = ROUNDUP(op->buffer_offs + slen - buffer_size, op->block_size); l = MIN(op->buffer_offs, l); tmp_dlen = dlen; res = update_func(op->state, op->buffer, l, dst, &tmp_dlen); if (res != TEE_SUCCESS) TEE_Panic(res); dst += tmp_dlen; dlen -= tmp_dlen; acc_dlen += tmp_dlen; op->buffer_offs -= l; if (op->buffer_offs > 0) { /* * Slen is small enough to be contained in rest buffer. */ memcpy(op->buffer, op->buffer + l, buffer_size - l); memcpy(op->buffer + op->buffer_offs, src, slen); op->buffer_offs += slen; goto out; /* Nothing left to do */ } } if (slen >= (buffer_size + buffer_left)) { /* Buffer is empty, feed as much as possible from src */ l = ROUNDUP(slen - buffer_size + 1, op->block_size); tmp_dlen = dlen; res = update_func(op->state, src, l, dst, &tmp_dlen); if (res != TEE_SUCCESS) TEE_Panic(res); src += l; slen -= l; dst += tmp_dlen; dlen -= tmp_dlen; acc_dlen += tmp_dlen; } /* Slen is small enough to be contained in buffer. */ memcpy(op->buffer + op->buffer_offs, src, slen); op->buffer_offs += slen; out: *dest_len = acc_dlen; return TEE_SUCCESS; }
//---------------------------------------------------------------------- int idaapi emu(void) { uint32 Feature = cmd.get_canon_feature(); int flag1 = is_forced_operand(cmd.ea, 0); int flag2 = is_forced_operand(cmd.ea, 1); int flag3 = is_forced_operand(cmd.ea, 2); flow = ((Feature & CF_STOP) == 0); if ( Feature & CF_USE1 ) process_operand(cmd.Op1, flag1, 1); if ( Feature & CF_USE2 ) process_operand(cmd.Op2, flag2, 1); if ( Feature & CF_USE3 ) process_operand(cmd.Op3, flag3, 1); if ( Feature & CF_CHG1 ) process_operand(cmd.Op1, flag1, 0); if ( Feature & CF_CHG2 ) process_operand(cmd.Op2, flag2, 0); if ( Feature & CF_CHG3 ) process_operand(cmd.Op3, flag3, 0); // // Determine if the next instruction should be executed // if ( segtype(cmd.ea) == SEG_XTRN ) flow = false; // // Handle loads to segment registers // sel_t v = BADSEL; switch ( cmd.itype ) { case H8500_andc: if ( cmd.Op1.value == 0 ) v = 0; goto SPLIT; case H8500_orc: if ( cmd.Op1.value == 0xFF ) v = 0xFF; goto SPLIT; case H8500_ldc: if ( cmd.Op1.type == o_imm ) v = cmd.Op1.value; case H8500_xorc: SPLIT: if ( cmd.Op2.reg >= BR && cmd.Op2.reg <= TP ) split_srarea(cmd.ea+cmd.size, cmd.Op2.reg, v, SR_auto); break; } if ( (Feature & CF_CALL) != 0 ) { ea_t callee = find_callee(); if ( !handle_function_call(callee) ) flow = false; } // // Handle SP modifications // if ( may_trace_sp() ) { func_t *pfn = get_func(cmd.ea); if ( pfn != NULL ) { if ( (pfn->flags & FUNC_USERFAR) == 0 && (pfn->flags & FUNC_FAR) == 0 && is_far_ending() ) { pfn->flags |= FUNC_FAR; update_func(pfn); reanalyze_callers(pfn->startEA, 0); } if ( !flow ) recalc_spd(cmd.ea); // recalculate SP register for the next insn else trace_sp(); } } if ( flow ) ua_add_cref(0, cmd.ea+cmd.size, fl_F); return 1; }
void WINAPI WinMainCRTStartup() #endif { PIXELFORMATDESCRIPTOR pfd; pfd.cColorBits = pfd.cDepthBits = 32; pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; #ifdef NDEBUG DEVMODE deviceMode; deviceMode.dmSize = sizeof(deviceMode); deviceMode.dmPelsWidth = WIDTH; deviceMode.dmPelsHeight = HEIGHT; deviceMode.dmBitsPerPel = 32; deviceMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; ChangeDisplaySettings(&deviceMode, CDS_FULLSCREEN); #endif #ifdef NDEBUG HDC hDC = GetDC( CreateWindow("edit", 0, WS_POPUP|WS_VISIBLE|WS_MAXIMIZE, 0, 0, 0, 0, 0, 0, 0, 0) ); #else HDC hDC = GetDC( CreateWindow("edit", 0, WS_POPUP|WS_VISIBLE, 0, 0, 800, 600, 0, 0, 0, 0) ); #endif SetPixelFormat( hDC, ChoosePixelFormat ( hDC, &pfd) , &pfd ); wglMakeCurrent( hDC, wglCreateContext(hDC) ); ShowCursor(FALSE); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); SwapBuffers(hDC); // Init InitGL(); glowInitTextures(); InitDome( g_dome_panels, g_dome_verlets, 1, 0 ); InitMirrors(); #ifndef NO_SOUND initAndStartSound(); #endif // Run DWORD start = GetTickCount(); int run_time = 0; int cur_seq = 0; do { // Get frames to advance DWORD cur = GetTickCount(); DWORD diff = cur - start; if ( diff > 10000 ) { start = cur; continue; } int frames = diff / MS_PER_FRAME; if ( frames <= 0 ) continue; int ms = frames * MS_PER_FRAME; run_time += ms; start += ms; // Advance the sequnce //int runtime_sec = run_time >> 10; // roughly /1000 int runtime_sec = run_time >> 9; if ( runtime_sec > g_seq_times[ cur_seq ] ) ++cur_seq; SeqFunc update_func = g_seq_funcs[ cur_seq ]; if ( update_func == 0 ) break; // Advance beginBaseTextureRender(); while ( frames-- > 0 ) { // Init the OpenGL glShadeModel( GL_SMOOTH ); glEnable( GL_NORMALIZE ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE ); glEnable( GL_COLOR_MATERIAL ); //glColorMaterial( GL_FRONT_AND_BACK, GL_DIFFUSE ); glEnable( GL_DEPTH_TEST ); glDisable( GL_CULL_FACE ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); //glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glLineWidth( 7 ); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); // Update & render update_func(); } endBaseTextureRender(); beginGlow(); glowRender(); endGlow(); // Swap it SwapBuffers( hDC ); #ifndef NO_SOUND //updateSound(); #endif Sleep(1); } while ( !GetAsyncKeyState(VK_ESCAPE) ); #ifdef NDEBUG ChangeDisplaySettings( NULL, 0 ); #endif ExitProcess( 0 ); #ifdef _DEBUG return 0; #endif }
bool FlareManager::Flare::update() { lifespan -= 0.01; // figure this out if (update_func) update_func(this); return !(lifespan < 0); }
static int search_dir(char *abs_dir_name, void (*update_func)(char *filename, char *dirname), struct z_story_list *story_list, bool recursive, struct babel_info *babel) { z_dir *current_dir; struct z_dir_ent z_dir_entry; char *dirname = NULL; int dirname_size = 0; int len; char *cwd = fsi->get_cwd(); TRACE_LOG("Trying to readdir \"%s\".\n", abs_dir_name); if ((fsi->ch_dir(abs_dir_name)) == -1) { return -1; } if ((current_dir = fsi->open_dir(".")) == NULL) { printf("\"%s\":\n", abs_dir_name); perror("could not opendir"); return -1; } if ( (show_progress == true) && (update_func != NULL) ) update_func(NULL, abs_dir_name); while (fsi->read_dir(&z_dir_entry, current_dir) == 0) { if ( (strcmp(z_dir_entry.d_name, ".") == 0) || (strcmp(z_dir_entry.d_name, "..") == 0) ) continue; len = strlen(abs_dir_name) + strlen(z_dir_entry.d_name) + 2; if (len > dirname_size) { dirname = (char*)fizmo_realloc(dirname, len); dirname_size = len; } strcpy(dirname, abs_dir_name); if (dirname[strlen(dirname) - 1] != '/') strcat(dirname, "/"); strcat(dirname, z_dir_entry.d_name); if (fsi->is_filename_directory(z_dir_entry.d_name) == true) { if (recursive == true) search_dir(dirname, update_func, story_list, true, babel); } else { if ( (show_progress == true) && (update_func != NULL) ) update_func(z_dir_entry.d_name, NULL); detect_and_add_z_file(dirname, NULL, babel, story_list); } } if (dirname != NULL) free(dirname); fsi->close_dir(current_dir); fsi->ch_dir(cwd); free(cwd); return 0; }
int gftp_get_all_subdirs (gftp_transfer * transfer, void (*update_func) (gftp_transfer * transfer)) { GList * templist, * lastlist; char *oldfromdir, *oldtodir; GHashTable * device_hash; gftp_file * curfle; off_t linksize; mode_t st_mode; int ret; g_return_val_if_fail (transfer != NULL, GFTP_EFATAL); g_return_val_if_fail (transfer->fromreq != NULL, GFTP_EFATAL); g_return_val_if_fail (transfer->files != NULL, GFTP_EFATAL); if (transfer->files == NULL) return (0); ret = 0; lastlist = _setup_current_directory_transfer (transfer, &ret); if (lastlist == NULL) return (ret); oldfromdir = oldtodir = NULL; device_hash = g_hash_table_new (uint_hash_function, uint_hash_compare); for (templist = transfer->files; templist != NULL; templist = templist->next) { curfle = templist->data; if (_lookup_curfle_in_device_hash (transfer->fromreq, curfle, device_hash)) continue; if (S_ISLNK (curfle->st_mode) && !S_ISDIR (curfle->st_mode)) { st_mode = 0; linksize = 0; ret = gftp_stat_filename (transfer->fromreq, curfle->file, &st_mode, &linksize); if (ret == GFTP_EFATAL) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); return (ret); } else if (ret == 0) { if (S_ISDIR (st_mode)) curfle->st_mode = st_mode; else curfle->size = linksize; } } if (!S_ISDIR (curfle->st_mode)) { transfer->numfiles++; continue; } /* Got a directory... */ transfer->numdirs++; if (oldfromdir == NULL) oldfromdir = g_strdup (transfer->fromreq->directory); ret = gftp_set_directory (transfer->fromreq, curfle->file); if (ret < 0) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); _free_device_hash (device_hash); return (ret); } if (transfer->toreq != NULL) { if (oldtodir == NULL) oldtodir = g_strdup (transfer->toreq->directory); if (curfle->exists_other_side) { ret = gftp_set_directory (transfer->toreq, curfle->destfile); if (ret == GFTP_EFATAL) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); _free_device_hash (device_hash); return (ret); } } else { if (transfer->toreq->directory != NULL) g_free (transfer->toreq->directory); transfer->toreq->directory = g_strdup (curfle->destfile); } } ret = 0; lastlist->next = gftp_get_dir_listing (transfer, curfle->exists_other_side, &ret); if (ret < 0) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); _free_device_hash (device_hash); return (ret); } if (lastlist->next != NULL) { lastlist->next->prev = lastlist; for (; lastlist->next != NULL; lastlist = lastlist->next); } if (update_func != NULL) update_func (transfer); } _free_device_hash (device_hash); if (oldfromdir != NULL) { ret = gftp_set_directory (transfer->fromreq, oldfromdir); if (ret == GFTP_EFATAL) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); return (ret); } } if (oldtodir != NULL) { ret = gftp_set_directory (transfer->toreq, oldtodir); if (ret == GFTP_EFATAL) { _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); return (ret); } } _cleanup_get_all_subdirs (transfer, oldfromdir, oldtodir, update_func); return (0); }
void HH::receive_spike() { update_func(); }
void Node::receive_spike() { update_func(); }
static TEE_Result tee_buffer_update( TEE_OperationHandle op, TEE_Result(*update_func) (uint32_t state, const void *src, size_t slen, void *dst, size_t *dlen), const void *src_data, size_t src_len, void *dest_data, size_t *dest_len) { TEE_Result res; const uint8_t *src = src_data; size_t slen = src_len; uint8_t *dst = dest_data; size_t dlen = *dest_len; size_t acc_dlen = 0; size_t tmp_dlen; size_t l; size_t buffer_size; if (op->buffer_two_blocks) buffer_size = op->block_size * 2; else buffer_size = op->block_size; if (op->buffer_offs > 0) { /* Fill up complete block */ if (op->buffer_offs < op->block_size) l = MIN(slen, op->block_size - op->buffer_offs); else l = MIN(slen, buffer_size - op->buffer_offs); memcpy(op->buffer + op->buffer_offs, src, l); op->buffer_offs += l; src += l; slen -= l; if ((op->buffer_offs % op->block_size) != 0) goto out; /* Nothing left to do */ } /* If we can feed from buffer */ if (op->buffer_offs > 0 && (op->buffer_offs + slen) > buffer_size) { l = ROUNDUP(op->buffer_offs + slen - buffer_size, op->block_size); l = MIN(op->buffer_offs, l); tmp_dlen = dlen; res = update_func(op->state, op->buffer, l, dst, &tmp_dlen); if (res != TEE_SUCCESS) TEE_Panic(res); dst += tmp_dlen; dlen -= tmp_dlen; acc_dlen += tmp_dlen; op->buffer_offs -= l; if (op->buffer_offs > 0) { /* * Slen is small enough to be contained in rest buffer. */ memcpy(op->buffer, op->buffer + l, buffer_size - l); memcpy(op->buffer + op->buffer_offs, src, slen); op->buffer_offs += slen; goto out; /* Nothing left to do */ } } if (slen > buffer_size) { /* Buffer is empty, feed as much as possible from src */ if (TEE_ALIGNMENT_IS_OK(src, uint32_t)) { l = ROUNDUP(slen - buffer_size + 1, op->block_size); tmp_dlen = dlen; res = update_func(op->state, src, l, dst, &tmp_dlen); if (res != TEE_SUCCESS) TEE_Panic(res); src += l; slen -= l; dst += tmp_dlen; dlen -= tmp_dlen; acc_dlen += tmp_dlen; } else { /* * Supplied data isn't well aligned, we're forced to * feed through the buffer. */ while (slen >= op->block_size) { memcpy(op->buffer, src, op->block_size); tmp_dlen = dlen; res = update_func(op->state, op->buffer, op->block_size, dst, &tmp_dlen); if (res != TEE_SUCCESS) TEE_Panic(res); src += op->block_size; slen -= op->block_size; dst += tmp_dlen; dlen -= tmp_dlen; acc_dlen += tmp_dlen; } } } /* Slen is small enough to be contained in buffer. */ memcpy(op->buffer + op->buffer_offs, src, slen); op->buffer_offs += slen; out: *dest_len = acc_dlen; return TEE_SUCCESS; }