/* Run a number of tstates */
void link_wait(CPU_t *cpu, uint64_t tstates) {
uint64_t time_end = cpu->timer_c->tstates + tstates;
while (cpu->timer_c->tstates < time_end) {
CPU_step(cpu);
}
}
int calc_run_frame(LPCALC lpCalc) {
uint64_t end_time = lpCalc->timer_c.freq / FPS;
uint64_t cpu_sync = tc_tstates(&lpCalc->timer_c) + end_time - lpCalc->time_error;
while(lpCalc->running) {
CPU_step(&lpCalc->cpu);
if (tc_tstates(&lpCalc->timer_c) >= cpu_sync) {
lpCalc->time_error = (time_t)(tc_tstates((&lpCalc->timer_c)) - cpu_sync);
return 0;
}
}
return 0;
}
int calc_run_all(void) {
int i, j, active_calc = -1;
BOOL calc_waiting = FALSE;
for (i = 0; i < FRAME_SUBDIVISIONS; i++) {
link_hub[MAX_CALCS]->host = 0;
for (j = 0; j < MAX_CALCS; j++) {
char hostVal = 0;
for (int k = 0; k < MAX_CALCS; k++) {
if (link_hub[k] != NULL && link_hub[k]->host) {
hostVal |= link_hub[k]->host;
calc_waiting |= link_hub[k]->hasChanged;
}
}
if (hostVal != link_hub[MAX_CALCS]->host) {
link_hub[MAX_CALCS]->host = hostVal;
calc_waiting = TRUE;
for (int k = 0; k < MAX_CALCS; k++) {
if (link_hub[k]) {
link_hub[k]->hasChanged = TRUE;
link_hub[k]->changedTime = calcs[k].timer_c.tstates;
}
}
}
if (calcs[j].active) {
/*if (link_hub[j] != NULL && (!link_hub[MAX_CALCS]->host || link_hub[MAX_CALCS]->host != link_hub[j]->host)
&& calcs[j].cpu.is_link_instruction || ((int) (calcs[j].cpu.linking_time - calcs[j].cpu.timer_c->tstates) >= 100000)) {
calcs[j].cpu.is_link_instruction = FALSE;
calcs[j].cpu.linking_time = 0;
CPU_step(&calcs[j].cpu);
}*/
if (calcs[j].cpu.is_link_instruction && calcs[j].cpu.pio.link->changedTime - calcs[j].timer_c.tstates >= 100000) {
calcs[j].cpu.is_link_instruction = FALSE;
calcs[j].cpu.pio.link->changedTime = 0;
calcs[j].cpu.pio.link->hasChanged = FALSE;
CPU_step(&calcs[j].cpu);
}
active_calc = j;
int time = (int)((int64_t) calcs[j].speed * calcs[j].timer_c.freq / FPS / 100) / FRAME_SUBDIVISIONS;
if (!calcs[j].cpu.is_link_instruction || !calc_waiting || calcs[j].cpu.pio.link->hasChanged == TRUE) {
calc_run_tstates(&calcs[j], time);
} /*else {
calcs[j].cpu.linking_time += time;
}*/
}
}
if (link_hub_count > 1 && calc_waiting_link >= link_hub_count) {
for (int k = 0; k < MAX_CALCS; k++) {
if (calcs[k].cpu.is_link_instruction) {
calcs[k].cpu.is_link_instruction = FALSE;
CPU_step(&calcs[k].cpu);
}
}
calc_waiting_link = 0;
}
//this code handles screenshoting if were actually taking screenshots right now
if (active_calc >= 0 && !calc_waiting_link && calcs[active_calc].cpu.timer_c != NULL && calcs[active_calc].cpu.pio.lcd != NULL &&
((tc_elapsed(calcs[active_calc].cpu.timer_c) - calcs[active_calc].cpu.pio.lcd->lastgifframe) >= 0.01)) {
handle_screenshot();
calcs[active_calc].cpu.pio.lcd->lastgifframe += 0.01;
}
}
return 0;
}
int calc_run_tstates(LPCALC lpCalc, time_t tstates) {
uint64_t time_end = tc_tstates(&lpCalc->timer_c) + tstates - lpCalc->time_error;
while (lpCalc->running) {
if (check_break(&lpCalc->mem_c, addr_to_waddr(&lpCalc->mem_c, lpCalc->cpu.pc)) & 1) {
#ifdef WINVER
lpCalc->running = FALSE;
bank_t *bank = &lpCalc->mem_c.banks[mc_bank(lpCalc->cpu.pc)];
Z80_info_t z[2];
disassemble(lpCalc, REGULAR, addr_to_waddr(lpCalc->cpu.mem_c, lpCalc->cpu.pc), 1, z);
if (lpCalc->pCalcNotify != NULL) {
bank_t *bank = &lpCalc->mem_c.banks[mc_bank(lpCalc->cpu.pc)];
CCalcAddress *pCalcAddress = new CComObject<CCalcAddress>();
pCalcAddress->Initialize(lpCalc->pWabbitemu, bank->ram, bank->page, lpCalc->cpu.pc);
pCalcAddress->AddRef();
lpCalc->pCalcNotify->Breakpoint(pCalcAddress);
} else {
#endif
#ifndef MACVER
lpCalc->breakpoint_callback(lpCalc);
#else
printf("hit a breakpoint in run tstates\n");
lpCalc->running = FALSE;
lpCalc->breakpoint_callback(lpCalc,lpCalc->breakpoint_owner);
#endif
#ifdef WINVER
}
#endif
return 0;
}
uint64_t oldTStates;
uint16_t oldPC;
if (lpCalc->profiler.running) {
oldTStates = tc_tstates(&lpCalc->timer_c);
oldPC = lpCalc->cpu.pc % PAGE_SIZE;
}
if (link_hub_count > 1) {
CPU_connected_step(&lpCalc->cpu);
if (lpCalc->cpu.is_link_instruction) {
lpCalc->time_error = (time_t)(tc_tstates((&lpCalc->timer_c)) - time_end);
calc_waiting_link++;
break;
}
} else {
CPU_step(&lpCalc->cpu);
}
if (lpCalc->profiler.running) {
uint64_t time = tc_tstates(&lpCalc->timer_c) - oldTStates;
lpCalc->profiler.totalTime += time;
bank_t bank = lpCalc->cpu.mem_c->banks[mc_bank(oldPC)];
if (bank.ram) {
lpCalc->profiler.ram_data[bank.page][oldPC / lpCalc->profiler.blockSize] += (long) time;
} else {
lpCalc->profiler.flash_data[bank.page][oldPC / lpCalc->profiler.blockSize] += (long) time;
}
}
if (tc_tstates((&lpCalc->timer_c)) >= time_end) {
lpCalc->time_error = (time_t)(tc_tstates((&lpCalc->timer_c)) - time_end);
break;
}
}
return 0;
}
