Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 08:41:31 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Get rid of state_save_register_device_* macros in favor of direct

Browse Source 
calls on the device object.

Regex used:

state_save_register_device_item( *)\(( *)([^,]+), *([^,]+),( *)([^ )]+)( *)\)
\3->save_item\1\(\2NAME\(\6\),\5\4\7\)

state_save_register_device_item_array( *)\(( *)([^,]+), *([^,]+),( *)([^ )]+)( *)\)
\3->save_item\1\(\2NAME\(\6\),\5\4\7\)

state_save_register_device_item_2d_array( *)\(( *)([^,]+), *([^,]+),( *)([^ )]+)( *)\)
\3->save_item\1\(\2NAME\(\6\),\5\4\7\)

state_save_register_device_item_bitmap( *)\(( *)([^,]+), *([^,]+),( *)([^ )]+)( *)\)
\3->save_item\1\(\2NAME\(\*\6\),\5\4\7\)

state_save_register_device_item_pointer( *)\(( *)([^,]+), *([^,]+),( *)([^,]+), *([^ )]+)( *)\)
\3->save_pointer\1\(\2NAME\(\6\),\5\7,\5\4\8\)

this->save_
save_

(save_item[^;]+), *0( *)\);
\1\2\);

(save_pointer[^;]+), *0( *)\);
\1\2\);
This commit is contained in:
Aaron Giles 2011-02-09 05:51:04 +00:00
parent 9f05843690
commit a38c67f27b
241 changed files with 4297 additions and 4316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
src/emu/cpu/adsp2100/adsp2100.c
View File

@ -612,86 +612,86 @@ void adsp21xx_device::device_start()
m_io = space(AS_IO);
// "core"
state_save_register_device_item(this, 0, m_core.ax0.u);
state_save_register_device_item(this, 0, m_core.ax1.u);
state_save_register_device_item(this, 0, m_core.ay0.u);
state_save_register_device_item(this, 0, m_core.ay1.u);
state_save_register_device_item(this, 0, m_core.ar.u);
state_save_register_device_item(this, 0, m_core.af.u);
state_save_register_device_item(this, 0, m_core.mx0.u);
state_save_register_device_item(this, 0, m_core.mx1.u);
state_save_register_device_item(this, 0, m_core.my0.u);
state_save_register_device_item(this, 0, m_core.my1.u);
state_save_register_device_item(this, 0, m_core.mr.mr);
state_save_register_device_item(this, 0, m_core.mf.u);
state_save_register_device_item(this, 0, m_core.si.u);
state_save_register_device_item(this, 0, m_core.se.u);
state_save_register_device_item(this, 0, m_core.sb.u);
state_save_register_device_item(this, 0, m_core.sr.sr);
state_save_register_device_item(this, 0, m_core.zero.u);
save_item(NAME(m_core.ax0.u));
save_item(NAME(m_core.ax1.u));
save_item(NAME(m_core.ay0.u));
save_item(NAME(m_core.ay1.u));
save_item(NAME(m_core.ar.u));
save_item(NAME(m_core.af.u));
save_item(NAME(m_core.mx0.u));
save_item(NAME(m_core.mx1.u));
save_item(NAME(m_core.my0.u));
save_item(NAME(m_core.my1.u));
save_item(NAME(m_core.mr.mr));
save_item(NAME(m_core.mf.u));
save_item(NAME(m_core.si.u));
save_item(NAME(m_core.se.u));
save_item(NAME(m_core.sb.u));
save_item(NAME(m_core.sr.sr));
save_item(NAME(m_core.zero.u));
// "alt"
state_save_register_device_item(this, 0, m_alt.ax0.u);
state_save_register_device_item(this, 0, m_alt.ax1.u);
state_save_register_device_item(this, 0, m_alt.ay0.u);
state_save_register_device_item(this, 0, m_alt.ay1.u);
state_save_register_device_item(this, 0, m_alt.ar.u);
state_save_register_device_item(this, 0, m_alt.af.u);
state_save_register_device_item(this, 0, m_alt.mx0.u);
state_save_register_device_item(this, 0, m_alt.mx1.u);
state_save_register_device_item(this, 0, m_alt.my0.u);
state_save_register_device_item(this, 0, m_alt.my1.u);
state_save_register_device_item(this, 0, m_alt.mr.mr);
state_save_register_device_item(this, 0, m_alt.mf.u);
state_save_register_device_item(this, 0, m_alt.si.u);
state_save_register_device_item(this, 0, m_alt.se.u);
state_save_register_device_item(this, 0, m_alt.sb.u);
state_save_register_device_item(this, 0, m_alt.sr.sr);
state_save_register_device_item(this, 0, m_alt.zero.u);
save_item(NAME(m_alt.ax0.u));
save_item(NAME(m_alt.ax1.u));
save_item(NAME(m_alt.ay0.u));
save_item(NAME(m_alt.ay1.u));
save_item(NAME(m_alt.ar.u));
save_item(NAME(m_alt.af.u));
save_item(NAME(m_alt.mx0.u));
save_item(NAME(m_alt.mx1.u));
save_item(NAME(m_alt.my0.u));
save_item(NAME(m_alt.my1.u));
save_item(NAME(m_alt.mr.mr));
save_item(NAME(m_alt.mf.u));
save_item(NAME(m_alt.si.u));
save_item(NAME(m_alt.se.u));
save_item(NAME(m_alt.sb.u));
save_item(NAME(m_alt.sr.sr));
save_item(NAME(m_alt.zero.u));
state_save_register_device_item_array(this, 0, m_i);
state_save_register_device_item_array(this, 0, m_m);
state_save_register_device_item_array(this, 0, m_l);
state_save_register_device_item_array(this, 0, m_lmask);
state_save_register_device_item_array(this, 0, m_base);
state_save_register_device_item(this, 0, m_px);
save_item(NAME(m_i));
save_item(NAME(m_m));
save_item(NAME(m_l));
save_item(NAME(m_lmask));
save_item(NAME(m_base));
save_item(NAME(m_px));
state_save_register_device_item(this, 0, m_pc);
state_save_register_device_item(this, 0, m_ppc);
state_save_register_device_item(this, 0, m_loop);
state_save_register_device_item(this, 0, m_loop_condition);
state_save_register_device_item(this, 0, m_cntr);
state_save_register_device_item(this, 0, m_astat);
state_save_register_device_item(this, 0, m_sstat);
state_save_register_device_item(this, 0, m_mstat);
state_save_register_device_item(this, 0, m_mstat_prev);
state_save_register_device_item(this, 0, m_astat_clear);
state_save_register_device_item(this, 0, m_idle);
save_item(NAME(m_pc));
save_item(NAME(m_ppc));
save_item(NAME(m_loop));
save_item(NAME(m_loop_condition));
save_item(NAME(m_cntr));
save_item(NAME(m_astat));
save_item(NAME(m_sstat));
save_item(NAME(m_mstat));
save_item(NAME(m_mstat_prev));
save_item(NAME(m_astat_clear));
save_item(NAME(m_idle));
state_save_register_device_item_array(this, 0, m_loop_stack);
state_save_register_device_item_array(this, 0, m_cntr_stack);
state_save_register_device_item_array(this, 0, m_pc_stack);
state_save_register_device_item_2d_array(this, 0, m_stat_stack);
save_item(NAME(m_loop_stack));
save_item(NAME(m_cntr_stack));
save_item(NAME(m_pc_stack));
save_item(NAME(m_stat_stack));
state_save_register_device_item(this, 0, m_pc_sp);
state_save_register_device_item(this, 0, m_cntr_sp);
state_save_register_device_item(this, 0, m_stat_sp);
state_save_register_device_item(this, 0, m_loop_sp);
save_item(NAME(m_pc_sp));
save_item(NAME(m_cntr_sp));
save_item(NAME(m_stat_sp));
save_item(NAME(m_loop_sp));
state_save_register_device_item(this, 0, m_flagout);
state_save_register_device_item(this, 0, m_flagin);
state_save_register_device_item(this, 0, m_fl0);
state_save_register_device_item(this, 0, m_fl1);
state_save_register_device_item(this, 0, m_fl2);
state_save_register_device_item(this, 0, m_idma_addr);
state_save_register_device_item(this, 0, m_idma_cache);
state_save_register_device_item(this, 0, m_idma_offs);
save_item(NAME(m_flagout));
save_item(NAME(m_flagin));
save_item(NAME(m_fl0));
save_item(NAME(m_fl1));
save_item(NAME(m_fl2));
save_item(NAME(m_idma_addr));
save_item(NAME(m_idma_cache));
save_item(NAME(m_idma_offs));
state_save_register_device_item(this, 0, m_imask);
state_save_register_device_item(this, 0, m_icntl);
state_save_register_device_item(this, 0, m_ifc);
state_save_register_device_item_array(this, 0, m_irq_state);
state_save_register_device_item_array(this, 0, m_irq_latch);
save_item(NAME(m_imask));
save_item(NAME(m_icntl));
save_item(NAME(m_ifc));
save_item(NAME(m_irq_state));
save_item(NAME(m_irq_latch));
// register state with the debugger
state_add(ADSP2100_PC, "PC", m_pc);

38
src/emu/cpu/alph8201/alph8201.c
View File

@ -672,27 +672,27 @@ static CPU_INIT( alpha8201 )
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
state_save_register_device_item_array(device, 0, cpustate->RAM);
state_save_register_device_item(device, 0, cpustate->PREVPC);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->regPtr);
state_save_register_device_item(device, 0, cpustate->zf);
state_save_register_device_item(device, 0, cpustate->cf);
state_save_register_device_item(device, 0, cpustate->mb);
device->save_item(NAME(cpustate->RAM));
device->save_item(NAME(cpustate->PREVPC));
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->regPtr));
device->save_item(NAME(cpustate->zf));
device->save_item(NAME(cpustate->cf));
device->save_item(NAME(cpustate->mb));
#if HANDLE_HALT_LINE
state_save_register_device_item(device, 0, cpustate->halt);
device->save_item(NAME(cpustate->halt));
#endif
state_save_register_device_item(device, 0, cpustate->IX0);
state_save_register_device_item(device, 0, cpustate->IX1);
state_save_register_device_item(device, 0, cpustate->IX2);
state_save_register_device_item(device, 0, cpustate->LP0);
state_save_register_device_item(device, 0, cpustate->LP1);
state_save_register_device_item(device, 0, cpustate->LP2);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->B);
state_save_register_device_item(device, 0, cpustate->retptr);
state_save_register_device_item(device, 0, cpustate->savec);
state_save_register_device_item(device, 0, cpustate->savez);
device->save_item(NAME(cpustate->IX0));
device->save_item(NAME(cpustate->IX1));
device->save_item(NAME(cpustate->IX2));
device->save_item(NAME(cpustate->LP0));
device->save_item(NAME(cpustate->LP1));
device->save_item(NAME(cpustate->LP2));
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->B));
device->save_item(NAME(cpustate->retptr));
device->save_item(NAME(cpustate->savec));
device->save_item(NAME(cpustate->savez));
}
/****************************************************************************
* Reset registers to their initial values

76
src/emu/cpu/am29000/am29000.c
View File

@ -162,52 +162,52 @@ static CPU_INIT( am29000 )
am29000->cfg = (PRL_AM29000 | PRL_REV_D) << CFG_PRL_SHIFT;
/* Register state for saving */
state_save_register_device_item(device, 0, am29000->icount);
state_save_register_device_item(device, 0, am29000->pc);
state_save_register_device_item_array(device, 0, am29000->r);
state_save_register_device_item_array(device, 0, am29000->tlb);
device->save_item(NAME(am29000->icount));
device->save_item(NAME(am29000->pc));
device->save_item(NAME(am29000->r));
device->save_item(NAME(am29000->tlb));
state_save_register_device_item(device, 0, am29000->vab);
state_save_register_device_item(device, 0, am29000->ops);
state_save_register_device_item(device, 0, am29000->cps);
state_save_register_device_item(device, 0, am29000->cfg);
state_save_register_device_item(device, 0, am29000->cha);
state_save_register_device_item(device, 0, am29000->chd);
state_save_register_device_item(device, 0, am29000->chc);
state_save_register_device_item(device, 0, am29000->rbp);
state_save_register_device_item(device, 0, am29000->tmc);
state_save_register_device_item(device, 0, am29000->tmr);
state_save_register_device_item(device, 0, am29000->pc0);
state_save_register_device_item(device, 0, am29000->pc1);
state_save_register_device_item(device, 0, am29000->pc2);
state_save_register_device_item(device, 0, am29000->mmu);
state_save_register_device_item(device, 0, am29000->lru);
device->save_item(NAME(am29000->vab));
device->save_item(NAME(am29000->ops));
device->save_item(NAME(am29000->cps));
device->save_item(NAME(am29000->cfg));
device->save_item(NAME(am29000->cha));
device->save_item(NAME(am29000->chd));
device->save_item(NAME(am29000->chc));
device->save_item(NAME(am29000->rbp));
device->save_item(NAME(am29000->tmc));
device->save_item(NAME(am29000->tmr));
device->save_item(NAME(am29000->pc0));
device->save_item(NAME(am29000->pc1));
device->save_item(NAME(am29000->pc2));
device->save_item(NAME(am29000->mmu));
device->save_item(NAME(am29000->lru));
state_save_register_device_item(device, 0, am29000->ipc);
state_save_register_device_item(device, 0, am29000->ipa);
state_save_register_device_item(device, 0, am29000->ipb);
state_save_register_device_item(device, 0, am29000->q);
device->save_item(NAME(am29000->ipc));
device->save_item(NAME(am29000->ipa));
device->save_item(NAME(am29000->ipb));
device->save_item(NAME(am29000->q));
state_save_register_device_item(device, 0, am29000->alu);
state_save_register_device_item(device, 0, am29000->fpe);
state_save_register_device_item(device, 0, am29000->inte);
state_save_register_device_item(device, 0, am29000->fps);
device->save_item(NAME(am29000->alu));
device->save_item(NAME(am29000->fpe));
device->save_item(NAME(am29000->inte));
device->save_item(NAME(am29000->fps));
state_save_register_device_item(device, 0, am29000->exceptions);
state_save_register_device_item_array(device, 0, am29000->exception_queue);
device->save_item(NAME(am29000->exceptions));
device->save_item(NAME(am29000->exception_queue));
state_save_register_device_item(device, 0, am29000->irq_active);
state_save_register_device_item(device, 0, am29000->irq_lines);
device->save_item(NAME(am29000->irq_active));
device->save_item(NAME(am29000->irq_lines));
state_save_register_device_item(device, 0, am29000->exec_ir);
state_save_register_device_item(device, 0, am29000->next_ir);
device->save_item(NAME(am29000->exec_ir));
device->save_item(NAME(am29000->next_ir));
state_save_register_device_item(device, 0, am29000->pl_flags);
state_save_register_device_item(device, 0, am29000->next_pl_flags);
device->save_item(NAME(am29000->pl_flags));
device->save_item(NAME(am29000->next_pl_flags));
state_save_register_device_item(device, 0, am29000->iret_pc);
state_save_register_device_item(device, 0, am29000->exec_pc);
state_save_register_device_item(device, 0, am29000->next_pc);
device->save_item(NAME(am29000->iret_pc));
device->save_item(NAME(am29000->exec_pc));
device->save_item(NAME(am29000->next_pc));
}
static CPU_RESET( am29000 )

16
src/emu/cpu/apexc/apexc.c
View File

@ -804,14 +804,14 @@ static CPU_INIT( apexc )
cpustate->program = device->space(AS_PROGRAM);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->r);
state_save_register_device_item(device, 0, cpustate->cr);
state_save_register_device_item(device, 0, cpustate->ml);
state_save_register_device_item(device, 0, cpustate->working_store);
state_save_register_device_item(device, 0, cpustate->current_word);
state_save_register_device_item(device, 0, cpustate->running);
state_save_register_device_item(device, 0, cpustate->pc);
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->r));
device->save_item(NAME(cpustate->cr));
device->save_item(NAME(cpustate->ml));
device->save_item(NAME(cpustate->working_store));
device->save_item(NAME(cpustate->current_word));
device->save_item(NAME(cpustate->running));
device->save_item(NAME(cpustate->pc));
}
static CPU_RESET( apexc )

16
src/emu/cpu/arm/arm.c
View File

@ -531,10 +531,10 @@ static CPU_INIT( arm )
cpustate->program = device->space(AS_PROGRAM);
cpustate->endian = ENDIANNESS_LITTLE;
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item_array(device, 0, cpustate->coproRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
device->save_item(NAME(cpustate->sArmRegister));
device->save_item(NAME(cpustate->coproRegister));
device->save_item(NAME(cpustate->pendingIrq));
device->save_item(NAME(cpustate->pendingFiq));
}
@ -547,10 +547,10 @@ static CPU_INIT( arm_be )
cpustate->program = device->space(AS_PROGRAM);
cpustate->endian = ENDIANNESS_BIG;
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item_array(device, 0, cpustate->coproRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
device->save_item(NAME(cpustate->sArmRegister));
device->save_item(NAME(cpustate->coproRegister));
device->save_item(NAME(cpustate->pendingIrq));
device->save_item(NAME(cpustate->pendingFiq));
}

14
src/emu/cpu/arm7/arm7core.c
View File

@ -571,13 +571,13 @@ static void arm7_core_init(device_t *device, const char *cpuname)
{
arm_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
state_save_register_device_item(device, 0, cpustate->pendingAbtD);
state_save_register_device_item(device, 0, cpustate->pendingAbtP);
state_save_register_device_item(device, 0, cpustate->pendingUnd);
state_save_register_device_item(device, 0, cpustate->pendingSwi);
device->save_item(NAME(cpustate->sArmRegister));
device->save_item(NAME(cpustate->pendingIrq));
device->save_item(NAME(cpustate->pendingFiq));
device->save_item(NAME(cpustate->pendingAbtD));
device->save_item(NAME(cpustate->pendingAbtP));
device->save_item(NAME(cpustate->pendingUnd));
device->save_item(NAME(cpustate->pendingSwi));
}
// CPU RESET

20
src/emu/cpu/asap/asap.c
View File

@ -334,16 +334,16 @@ void asap_device::device_start()
state_add(ASAP_R0 + regnum, tempstr.format("R%d", regnum), m_src2val[REGBASE + regnum]);
// register our state for saving
state_save_register_device_item(this, 0, m_pc);
state_save_register_device_item(this, 0, m_pflag);
state_save_register_device_item(this, 0, m_iflag);
state_save_register_device_item(this, 0, m_cflag);
state_save_register_device_item(this, 0, m_vflag);
state_save_register_device_item(this, 0, m_znflag);
state_save_register_device_item(this, 0, m_op);
state_save_register_device_item(this, 0, m_ppc);
state_save_register_device_item(this, 0, m_nextpc);
state_save_register_device_item(this, 0, m_irq_state);
save_item(NAME(m_pc));
save_item(NAME(m_pflag));
save_item(NAME(m_iflag));
save_item(NAME(m_cflag));
save_item(NAME(m_vflag));
save_item(NAME(m_znflag));
save_item(NAME(m_op));
save_item(NAME(m_ppc));
save_item(NAME(m_nextpc));
save_item(NAME(m_irq_state));
// set our instruction counter
m_icountptr = &m_icount;

2
src/emu/cpu/avr8/avr8.c
View File

@ -193,7 +193,7 @@ static CPU_INIT( avr8 )
WRITE_IO_8(cpustate, AVR8_IO_SREG, 0);
state_save_register_device_item(device, 0, cpustate->pc);
device->save_item(NAME(cpustate->pc));
}
static CPU_EXIT( avr8 )

38
src/emu/cpu/ccpu/ccpu.c
View File

@ -136,25 +136,25 @@ static CPU_INIT( ccpu )
cpustate->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->B);
state_save_register_device_item(device, 0, cpustate->I);
state_save_register_device_item(device, 0, cpustate->J);
state_save_register_device_item(device, 0, cpustate->P);
state_save_register_device_item(device, 0, cpustate->X);
state_save_register_device_item(device, 0, cpustate->Y);
state_save_register_device_item(device, 0, cpustate->T);
state_save_register_device_item(device, 0, cpustate->a0flag);
state_save_register_device_item(device, 0, cpustate->ncflag);
state_save_register_device_item(device, 0, cpustate->cmpacc);
state_save_register_device_item(device, 0, cpustate->cmpval);
state_save_register_device_item(device, 0, cpustate->miflag);
state_save_register_device_item(device, 0, cpustate->nextmiflag);
state_save_register_device_item(device, 0, cpustate->nextnextmiflag);
state_save_register_device_item(device, 0, cpustate->drflag);
state_save_register_device_item(device, 0, cpustate->waiting);
state_save_register_device_item(device, 0, cpustate->watchdog);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->B));
device->save_item(NAME(cpustate->I));
device->save_item(NAME(cpustate->J));
device->save_item(NAME(cpustate->P));
device->save_item(NAME(cpustate->X));
device->save_item(NAME(cpustate->Y));
device->save_item(NAME(cpustate->T));
device->save_item(NAME(cpustate->a0flag));
device->save_item(NAME(cpustate->ncflag));
device->save_item(NAME(cpustate->cmpacc));
device->save_item(NAME(cpustate->cmpval));
device->save_item(NAME(cpustate->miflag));
device->save_item(NAME(cpustate->nextmiflag));
device->save_item(NAME(cpustate->nextnextmiflag));
device->save_item(NAME(cpustate->drflag));
device->save_item(NAME(cpustate->waiting));
device->save_item(NAME(cpustate->watchdog));
}

52
src/emu/cpu/cop400/cop400.c
View File

@ -915,32 +915,32 @@ static void cop400_init(legacy_cpu_device *device, UINT8 g_mask, UINT8 d_mask, U
/* register for state saving */
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->prevpc);
state_save_register_device_item(device, 0, cpustate->n);
state_save_register_device_item(device, 0, cpustate->sa);
state_save_register_device_item(device, 0, cpustate->sb);
state_save_register_device_item(device, 0, cpustate->sc);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->c);
state_save_register_device_item(device, 0, cpustate->g);
state_save_register_device_item(device, 0, cpustate->h);
state_save_register_device_item(device, 0, cpustate->q);
state_save_register_device_item(device, 0, cpustate->r);
state_save_register_device_item(device, 0, cpustate->en);
state_save_register_device_item(device, 0, cpustate->sio);
state_save_register_device_item(device, 0, cpustate->skl);
state_save_register_device_item(device, 0, cpustate->t);
state_save_register_device_item(device, 0, cpustate->skip);
state_save_register_device_item(device, 0, cpustate->skip_lbi);
state_save_register_device_item(device, 0, cpustate->skt_latch);
state_save_register_device_item(device, 0, cpustate->si);
state_save_register_device_item(device, 0, cpustate->last_skip);
state_save_register_device_item_array(device, 0, cpustate->in);
state_save_register_device_item(device, 0, cpustate->microbus_int);
state_save_register_device_item(device, 0, cpustate->halt);
state_save_register_device_item(device, 0, cpustate->idle);
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->prevpc));
device->save_item(NAME(cpustate->n));
device->save_item(NAME(cpustate->sa));
device->save_item(NAME(cpustate->sb));
device->save_item(NAME(cpustate->sc));
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->b));
device->save_item(NAME(cpustate->c));
device->save_item(NAME(cpustate->g));
device->save_item(NAME(cpustate->h));
device->save_item(NAME(cpustate->q));
device->save_item(NAME(cpustate->r));
device->save_item(NAME(cpustate->en));
device->save_item(NAME(cpustate->sio));
device->save_item(NAME(cpustate->skl));
device->save_item(NAME(cpustate->t));
device->save_item(NAME(cpustate->skip));
device->save_item(NAME(cpustate->skip_lbi));
device->save_item(NAME(cpustate->skt_latch));
device->save_item(NAME(cpustate->si));
device->save_item(NAME(cpustate->last_skip));
device->save_item(NAME(cpustate->in));
device->save_item(NAME(cpustate->microbus_int));
device->save_item(NAME(cpustate->halt));
device->save_item(NAME(cpustate->idle));
}
static void cop410_init_opcodes(device_t *device)

42
src/emu/cpu/cosmac/cosmac.c
View File

@ -393,27 +393,27 @@ void cosmac_device::device_start()
devcb_resolve_write_line(&m_out_tpb_func, &m_config.m_out_tpb_func, this);
// register our state for saving
state_save_register_device_item(this, 0, m_op);
state_save_register_device_item(this, 0, m_flagsio);
state_save_register_device_item(this, 0, m_state);
state_save_register_device_item(this, 0, m_mode);
state_save_register_device_item(this, 0, m_pmode);
state_save_register_device_item(this, 0, m_irq);
state_save_register_device_item(this, 0, m_dmain);
state_save_register_device_item(this, 0, m_dmaout);
state_save_register_device_item_array(this, 0, m_ef);
state_save_register_device_item(this, 0, m_d);
state_save_register_device_item(this, 0, m_b);
state_save_register_device_item_array(this, 0, m_r);
state_save_register_device_item(this, 0, m_p);
state_save_register_device_item(this, 0, m_x);
state_save_register_device_item(this, 0, m_n);
state_save_register_device_item(this, 0, m_i);
state_save_register_device_item(this, 0, m_t);
state_save_register_device_item(this, 0, m_df);
state_save_register_device_item(this, 0, m_ie);
state_save_register_device_item(this, 0, m_q);
state_save_register_device_item(this, 0, m_icount);
save_item(NAME(m_op));
save_item(NAME(m_flagsio));
save_item(NAME(m_state));
save_item(NAME(m_mode));
save_item(NAME(m_pmode));
save_item(NAME(m_irq));
save_item(NAME(m_dmain));
save_item(NAME(m_dmaout));
save_item(NAME(m_ef));
save_item(NAME(m_d));
save_item(NAME(m_b));
save_item(NAME(m_r));
save_item(NAME(m_p));
save_item(NAME(m_x));
save_item(NAME(m_n));
save_item(NAME(m_i));
save_item(NAME(m_t));
save_item(NAME(m_df));
save_item(NAME(m_ie));
save_item(NAME(m_q));
save_item(NAME(m_icount));
// set our instruction counter
m_icountptr = &m_icount;

22
src/emu/cpu/cp1610/cp1610.c
View File

@ -3391,17 +3391,17 @@ static CPU_INIT( cp1610 )
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);
state_save_register_device_item_array(device, 0, cpustate->r);
state_save_register_device_item(device, 0, cpustate->flags);
state_save_register_device_item(device, 0, cpustate->intr_enabled);
state_save_register_device_item(device, 0, cpustate->intr_vector);
state_save_register_device_item(device, 0, cpustate->reset_state);
state_save_register_device_item(device, 0, cpustate->intr_state);
state_save_register_device_item(device, 0, cpustate->intrm_state);
state_save_register_device_item(device, 0, cpustate->reset_pending);
state_save_register_device_item(device, 0, cpustate->intr_pending);
state_save_register_device_item(device, 0, cpustate->intrm_pending);
state_save_register_device_item(device, 0, cpustate->mask_interrupts);
device->save_item(NAME(cpustate->r));
device->save_item(NAME(cpustate->flags));
device->save_item(NAME(cpustate->intr_enabled));
device->save_item(NAME(cpustate->intr_vector));
device->save_item(NAME(cpustate->reset_state));
device->save_item(NAME(cpustate->intr_state));
device->save_item(NAME(cpustate->intrm_state));
device->save_item(NAME(cpustate->reset_pending));
device->save_item(NAME(cpustate->intr_pending));
device->save_item(NAME(cpustate->intrm_pending));
device->save_item(NAME(cpustate->mask_interrupts));
}
static void cp1610_set_irq_line(cp1610_state *cpustate, UINT32 irqline, int state)

130
src/emu/cpu/cubeqcpu/cubeqcpu.c
View File

@ -258,22 +258,22 @@ static STATE_POSTLOAD( cquestsnd_postload )
static void cquestsnd_state_register(device_t *device)
{
cquestsnd_state *cpustate = get_safe_token_snd(device);
state_save_register_device_item_array(device, 0, cpustate->ram);
state_save_register_device_item(device, 0, cpustate->q);
state_save_register_device_item(device, 0, cpustate->f);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->cflag);
state_save_register_device_item(device, 0, cpustate->vflag);
device->save_item(NAME(cpustate->ram));
device->save_item(NAME(cpustate->q));
device->save_item(NAME(cpustate->f));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->cflag));
device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->platch);
state_save_register_device_item(device, 0, cpustate->rtnlatch);
state_save_register_device_item(device, 0, cpustate->adrcntr);
state_save_register_device_item(device, 0, cpustate->adrlatch);
state_save_register_device_item(device, 0, cpustate->dinlatch);
state_save_register_device_item(device, 0, cpustate->ramwlatch);
state_save_register_device_item(device, 0, cpustate->prev_ipram);
state_save_register_device_item(device, 0, cpustate->prev_ipwrt);
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->platch));
device->save_item(NAME(cpustate->rtnlatch));
device->save_item(NAME(cpustate->adrcntr));
device->save_item(NAME(cpustate->adrlatch));
device->save_item(NAME(cpustate->dinlatch));
device->save_item(NAME(cpustate->ramwlatch));
device->save_item(NAME(cpustate->prev_ipram));
device->save_item(NAME(cpustate->prev_ipwrt));
device->machine->state().register_postload(cquestsnd_postload, (void *)device);
}
@ -323,31 +323,31 @@ static STATE_POSTLOAD( cquestrot_postload )
static void cquestrot_state_register(device_t *device)
{
cquestrot_state *cpustate = get_safe_token_rot(device);
state_save_register_device_item_array(device, 0, cpustate->ram);
state_save_register_device_item(device, 0, cpustate->q);
state_save_register_device_item(device, 0, cpustate->f);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->cflag);
state_save_register_device_item(device, 0, cpustate->vflag);
device->save_item(NAME(cpustate->ram));
device->save_item(NAME(cpustate->q));
device->save_item(NAME(cpustate->f));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->cflag));
device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->seqcnt);
state_save_register_device_item(device, 0, cpustate->dsrclatch);
state_save_register_device_item(device, 0, cpustate->rsrclatch);
state_save_register_device_item(device, 0, cpustate->dynaddr);
state_save_register_device_item(device, 0, cpustate->dyndata);
state_save_register_device_item(device, 0, cpustate->yrlatch);
state_save_register_device_item(device, 0, cpustate->ydlatch);
state_save_register_device_item(device, 0, cpustate->dinlatch);
state_save_register_device_item(device, 0, cpustate->divreg);
state_save_register_device_item(device, 0, cpustate->linedata);
state_save_register_device_item(device, 0, cpustate->lineaddr);
state_save_register_device_item(device, 0, cpustate->prev_dred);
state_save_register_device_item(device, 0, cpustate->prev_dwrt);
state_save_register_device_item(device, 0, cpustate->wc);
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->seqcnt));
device->save_item(NAME(cpustate->dsrclatch));
device->save_item(NAME(cpustate->rsrclatch));
device->save_item(NAME(cpustate->dynaddr));
device->save_item(NAME(cpustate->dyndata));
device->save_item(NAME(cpustate->yrlatch));
device->save_item(NAME(cpustate->ydlatch));
device->save_item(NAME(cpustate->dinlatch));
device->save_item(NAME(cpustate->divreg));
device->save_item(NAME(cpustate->linedata));
device->save_item(NAME(cpustate->lineaddr));
device->save_item(NAME(cpustate->prev_dred));
device->save_item(NAME(cpustate->prev_dwrt));
device->save_item(NAME(cpustate->wc));
state_save_register_device_item_pointer(device, 0, cpustate->dram, 16384);
state_save_register_device_item_pointer(device, 0, cpustate->sram, 2048);
device->save_pointer(NAME(cpustate->dram), 16384);
device->save_pointer(NAME(cpustate->sram), 2048);
device->machine->state().register_postload(cquestrot_postload, (void *)device);
}
@ -403,35 +403,35 @@ static void cquestlin_state_register(device_t *device)
{
cquestlin_state *cpustate = get_safe_token_lin(device);
state_save_register_device_item_array(device, 0, cpustate->ram);
state_save_register_device_item(device, 0, cpustate->q);
state_save_register_device_item(device, 0, cpustate->f);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->cflag);
state_save_register_device_item(device, 0, cpustate->vflag);
device->save_item(NAME(cpustate->ram));
device->save_item(NAME(cpustate->q));
device->save_item(NAME(cpustate->f));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->cflag));
device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc[0]);
state_save_register_device_item(device, 0, cpustate->pc[1]);
state_save_register_device_item(device, 0, cpustate->seqcnt);
state_save_register_device_item(device, 0, cpustate->clatch);
state_save_register_device_item(device, 0, cpustate->zlatch);
state_save_register_device_item(device, 0, cpustate->xcnt);
state_save_register_device_item(device, 0, cpustate->ycnt);
state_save_register_device_item(device, 0, cpustate->sreg);
state_save_register_device_item(device, 0, cpustate->fadlatch);
state_save_register_device_item(device, 0, cpustate->badlatch);
state_save_register_device_item(device, 0, cpustate->sramdlatch);
state_save_register_device_item(device, 0, cpustate->fglatch);
state_save_register_device_item(device, 0, cpustate->bglatch);
state_save_register_device_item(device, 0, cpustate->gt0reg);
state_save_register_device_item(device, 0, cpustate->fdxreg);
state_save_register_device_item(device, 0, cpustate->field);
state_save_register_device_item(device, 0, cpustate->clkcnt);
device->save_item(NAME(cpustate->pc[0]));
device->save_item(NAME(cpustate->pc[1]));
device->save_item(NAME(cpustate->seqcnt));
device->save_item(NAME(cpustate->clatch));
device->save_item(NAME(cpustate->zlatch));
device->save_item(NAME(cpustate->xcnt));
device->save_item(NAME(cpustate->ycnt));
device->save_item(NAME(cpustate->sreg));
device->save_item(NAME(cpustate->fadlatch));
device->save_item(NAME(cpustate->badlatch));
device->save_item(NAME(cpustate->sramdlatch));
device->save_item(NAME(cpustate->fglatch));
device->save_item(NAME(cpustate->bglatch));
device->save_item(NAME(cpustate->gt0reg));
device->save_item(NAME(cpustate->fdxreg));
device->save_item(NAME(cpustate->field));
device->save_item(NAME(cpustate->clkcnt));
state_save_register_device_item_pointer(device, 0, cpustate->sram, 4096);
state_save_register_device_item_pointer(device, 0, cpustate->ptr_ram, 1024);
state_save_register_device_item_pointer(device, 0, cpustate->e_stack, 32768);
state_save_register_device_item_pointer(device, 0, cpustate->o_stack, 32768);
device->save_pointer(NAME(cpustate->sram), 4096);
device->save_pointer(NAME(cpustate->ptr_ram), 1024);
device->save_pointer(NAME(cpustate->e_stack), 32768);
device->save_pointer(NAME(cpustate->o_stack), 32768);
device->machine->state().register_postload(cquestlin_postload, (void *)device);
}

2
src/emu/cpu/dsp16/dsp16.c
View File

@ -146,7 +146,7 @@ void dsp16_device::device_start()
m_program = space(AS_PROGRAM);
m_direct = &m_program->direct();
state_save_register_device_item(this, 0, m_pc);
save_item(NAME(m_pc));
// register state with the debugger
state_add(DSP16_PC, "PC", m_pc);

66
src/emu/cpu/dsp32/dsp32.c
View File

@ -383,39 +383,39 @@ void dsp32c_device::device_start()
state_add(DSP32_IOC, "IOC", m_r[27]).mask(0xfffff);
// register our state for saving
state_save_register_device_item_array(this, 0, m_r);
state_save_register_device_item(this, 0, m_pin);
state_save_register_device_item(this, 0, m_pout);
state_save_register_device_item(this, 0, m_ivtp);
state_save_register_device_item(this, 0, m_nzcflags);
state_save_register_device_item(this, 0, m_vflags);
state_save_register_device_item_array(this, 0, m_a);
state_save_register_device_item(this, 0, m_NZflags);
state_save_register_device_item(this, 0, m_VUflags);
state_save_register_device_item_array(this, 0, m_abuf);
state_save_register_device_item_array(this, 0, m_abufreg);
state_save_register_device_item_array(this, 0, m_abufVUflags);
state_save_register_device_item_array(this, 0, m_abufNZflags);
state_save_register_device_item_array(this, 0, m_abufcycle);
state_save_register_device_item(this, 0, m_abuf_index);
state_save_register_device_item_array(this, 0, m_mbufaddr);
state_save_register_device_item_array(this, 0, m_mbufdata);
state_save_register_device_item(this, 0, m_par);
state_save_register_device_item(this, 0, m_pare);
state_save_register_device_item(this, 0, m_pdr);
state_save_register_device_item(this, 0, m_pdr2);
state_save_register_device_item(this, 0, m_pir);
state_save_register_device_item(this, 0, m_pcr);
state_save_register_device_item(this, 0, m_emr);
state_save_register_device_item(this, 0, m_esr);
state_save_register_device_item(this, 0, m_pcw);
state_save_register_device_item(this, 0, m_piop);
state_save_register_device_item(this, 0, m_ibuf);
state_save_register_device_item(this, 0, m_isr);
state_save_register_device_item(this, 0, m_obuf);
state_save_register_device_item(this, 0, m_osr);
state_save_register_device_item(this, 0, m_lastpins);
state_save_register_device_item(this, 0, m_ppc);
save_item(NAME(m_r));
save_item(NAME(m_pin));
save_item(NAME(m_pout));
save_item(NAME(m_ivtp));
save_item(NAME(m_nzcflags));
save_item(NAME(m_vflags));
save_item(NAME(m_a));
save_item(NAME(m_NZflags));
save_item(NAME(m_VUflags));
save_item(NAME(m_abuf));
save_item(NAME(m_abufreg));
save_item(NAME(m_abufVUflags));
save_item(NAME(m_abufNZflags));
save_item(NAME(m_abufcycle));
save_item(NAME(m_abuf_index));
save_item(NAME(m_mbufaddr));
save_item(NAME(m_mbufdata));
save_item(NAME(m_par));
save_item(NAME(m_pare));
save_item(NAME(m_pdr));
save_item(NAME(m_pdr2));
save_item(NAME(m_pir));
save_item(NAME(m_pcr));
save_item(NAME(m_emr));
save_item(NAME(m_esr));
save_item(NAME(m_pcw));
save_item(NAME(m_piop));
save_item(NAME(m_ibuf));
save_item(NAME(m_isr));
save_item(NAME(m_obuf));
save_item(NAME(m_osr));
save_item(NAME(m_lastpins));
save_item(NAME(m_ppc));
}

70
src/emu/cpu/dsp56k/dsp56k.c
View File

@ -165,28 +165,28 @@ static void set_irq_line(dsp56k_core* cpustate, int irqline, int state)
static void agu_init(dsp56k_core* cpustate, device_t *device)
{
/* save states - dsp56k_agu members */
state_save_register_device_item(device, 0, cpustate->AGU.r0);
state_save_register_device_item(device, 0, cpustate->AGU.r1);
state_save_register_device_item(device, 0, cpustate->AGU.r2);
state_save_register_device_item(device, 0, cpustate->AGU.r3);
state_save_register_device_item(device, 0, cpustate->AGU.n0);
state_save_register_device_item(device, 0, cpustate->AGU.n1);
state_save_register_device_item(device, 0, cpustate->AGU.n2);
state_save_register_device_item(device, 0, cpustate->AGU.n3);
state_save_register_device_item(device, 0, cpustate->AGU.m0);
state_save_register_device_item(device, 0, cpustate->AGU.m1);
state_save_register_device_item(device, 0, cpustate->AGU.m2);
state_save_register_device_item(device, 0, cpustate->AGU.m3);
state_save_register_device_item(device, 0, cpustate->AGU.temp);
device->save_item(NAME(cpustate->AGU.r0));
device->save_item(NAME(cpustate->AGU.r1));
device->save_item(NAME(cpustate->AGU.r2));
device->save_item(NAME(cpustate->AGU.r3));
device->save_item(NAME(cpustate->AGU.n0));
device->save_item(NAME(cpustate->AGU.n1));
device->save_item(NAME(cpustate->AGU.n2));
device->save_item(NAME(cpustate->AGU.n3));
device->save_item(NAME(cpustate->AGU.m0));
device->save_item(NAME(cpustate->AGU.m1));
device->save_item(NAME(cpustate->AGU.m2));
device->save_item(NAME(cpustate->AGU.m3));
device->save_item(NAME(cpustate->AGU.temp));
}
static void alu_init(dsp56k_core* cpustate, device_t *device)
{
/* save states - dsp56k_alu members */
state_save_register_device_item(device, 0, cpustate->ALU.x);
state_save_register_device_item(device, 0, cpustate->ALU.y);
state_save_register_device_item(device, 0, cpustate->ALU.a);
state_save_register_device_item(device, 0, cpustate->ALU.b);
device->save_item(NAME(cpustate->ALU.x));
device->save_item(NAME(cpustate->ALU.y));
device->save_item(NAME(cpustate->ALU.a));
device->save_item(NAME(cpustate->ALU.b));
}
static CPU_INIT( dsp56k )
@ -208,26 +208,26 @@ static CPU_INIT( dsp56k )
cpustate->reset_state = FALSE;
/* save states - dsp56k_core members */
state_save_register_device_item(device, 0, cpustate->modA_state);
state_save_register_device_item(device, 0, cpustate->modB_state);
state_save_register_device_item(device, 0, cpustate->modC_state);
state_save_register_device_item(device, 0, cpustate->reset_state);
state_save_register_device_item(device, 0, cpustate->bootstrap_mode);
state_save_register_device_item(device, 0, cpustate->repFlag);
state_save_register_device_item(device, 0, cpustate->repAddr);
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->op);
state_save_register_device_item(device, 0, cpustate->interrupt_cycles);
device->save_item(NAME(cpustate->modA_state));
device->save_item(NAME(cpustate->modB_state));
device->save_item(NAME(cpustate->modC_state));
device->save_item(NAME(cpustate->reset_state));
device->save_item(NAME(cpustate->bootstrap_mode));
device->save_item(NAME(cpustate->repFlag));
device->save_item(NAME(cpustate->repAddr));
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->ppc));
device->save_item(NAME(cpustate->op));
device->save_item(NAME(cpustate->interrupt_cycles));
/* save states - dsp56k_host_interface members */
state_save_register_device_item(device, 0, cpustate->HI.icr);
state_save_register_device_item(device, 0, cpustate->HI.cvr);
state_save_register_device_item(device, 0, cpustate->HI.isr);
state_save_register_device_item(device, 0, cpustate->HI.ivr);
state_save_register_device_item(device, 0, cpustate->HI.trxh);
state_save_register_device_item(device, 0, cpustate->HI.trxl);
state_save_register_device_item(device, 0, cpustate->HI.bootstrap_offset);
device->save_item(NAME(cpustate->HI.icr));
device->save_item(NAME(cpustate->HI.cvr));
device->save_item(NAME(cpustate->HI.isr));
device->save_item(NAME(cpustate->HI.ivr));
device->save_item(NAME(cpustate->HI.trxh));
device->save_item(NAME(cpustate->HI.trxl));
device->save_item(NAME(cpustate->HI.bootstrap_offset));
//cpustate->config = device->baseconfig().static_config();
//cpustate->irq_callback = irqcallback;

18
src/emu/cpu/dsp56k/dsp56pcu.c
View File

@ -102,15 +102,15 @@ void pcu_init(dsp56k_core* cpustate, device_t *device)
dsp56k_irq_table_init();
/* save states - dsp56k_pcu members */
state_save_register_device_item(device, 0, cpustate->PCU.pc);
state_save_register_device_item(device, 0, cpustate->PCU.la);
state_save_register_device_item(device, 0, cpustate->PCU.lc);
state_save_register_device_item(device, 0, cpustate->PCU.sr);
state_save_register_device_item(device, 0, cpustate->PCU.omr);
state_save_register_device_item(device, 0, cpustate->PCU.sp);
state_save_register_device_item_array(device, 0, cpustate->PCU.ss);
state_save_register_device_item_array(device, 0, cpustate->PCU.pending_interrupts);
state_save_register_device_item(device, 0, cpustate->PCU.reset_vector);
device->save_item(NAME(cpustate->PCU.pc));
device->save_item(NAME(cpustate->PCU.la));
device->save_item(NAME(cpustate->PCU.lc));
device->save_item(NAME(cpustate->PCU.sr));
device->save_item(NAME(cpustate->PCU.omr));
device->save_item(NAME(cpustate->PCU.sp));
device->save_item(NAME(cpustate->PCU.ss));
device->save_item(NAME(cpustate->PCU.pending_interrupts));
device->save_item(NAME(cpustate->PCU.reset_vector));
}
void pcu_reset(dsp56k_core* cpustate)

18
src/emu/cpu/e132xs/e132xs.c
View File

@ -1531,15 +1531,15 @@ static void hyperstone_init(legacy_cpu_device *device, device_irq_callback irqca
{
hyperstone_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->global_regs);
state_save_register_device_item_array(device, 0, cpustate->local_regs);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->trap_entry);
state_save_register_device_item(device, 0, cpustate->delay.delay_pc);
state_save_register_device_item(device, 0, cpustate->instruction_length);
state_save_register_device_item(device, 0, cpustate->intblock);
state_save_register_device_item(device, 0, cpustate->delay.delay_cmd);
state_save_register_device_item(device, 0, cpustate->tr_clocks_per_tick);
device->save_item(NAME(cpustate->global_regs));
device->save_item(NAME(cpustate->local_regs));
device->save_item(NAME(cpustate->ppc));
device->save_item(NAME(cpustate->trap_entry));
device->save_item(NAME(cpustate->delay.delay_pc));
device->save_item(NAME(cpustate->instruction_length));
device->save_item(NAME(cpustate->intblock));
device->save_item(NAME(cpustate->delay.delay_cmd));
device->save_item(NAME(cpustate->tr_clocks_per_tick));
cpustate->irq_callback = irqcallback;
cpustate->device = device;

84
src/emu/cpu/esrip/esrip.c
View File

@ -272,48 +272,48 @@ static CPU_INIT( esrip )
make_ops(cpustate);
/* Register stuff for state saving */
state_save_register_device_item(device, 0, cpustate->acc);
state_save_register_device_item_array(device, 0, cpustate->ram);
state_save_register_device_item(device, 0, cpustate->d_latch);
state_save_register_device_item(device, 0, cpustate->i_latch);
state_save_register_device_item(device, 0, cpustate->result);
state_save_register_device_item(device, 0, cpustate->new_status);
state_save_register_device_item(device, 0, cpustate->status);
state_save_register_device_item(device, 0, cpustate->inst);
state_save_register_device_item(device, 0, cpustate->immflag);
state_save_register_device_item(device, 0, cpustate->ct);
state_save_register_device_item(device, 0, cpustate->t);
state_save_register_device_item(device, 0, cpustate->l1);
state_save_register_device_item(device, 0, cpustate->l2);
state_save_register_device_item(device, 0, cpustate->l3);
state_save_register_device_item(device, 0, cpustate->l4);
state_save_register_device_item(device, 0, cpustate->l5);
state_save_register_device_item(device, 0, cpustate->l6);
state_save_register_device_item(device, 0, cpustate->l7);
state_save_register_device_item(device, 0, cpustate->pl1);
state_save_register_device_item(device, 0, cpustate->pl2);
state_save_register_device_item(device, 0, cpustate->pl3);
state_save_register_device_item(device, 0, cpustate->pl4);
state_save_register_device_item(device, 0, cpustate->pl5);
state_save_register_device_item(device, 0, cpustate->pl6);
state_save_register_device_item(device, 0, cpustate->pl7);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->status_out);
state_save_register_device_item(device, 0, cpustate->x_scale);
state_save_register_device_item(device, 0, cpustate->y_scale);
state_save_register_device_item(device, 0, cpustate->img_bank);
state_save_register_device_item(device, 0, cpustate->line_latch);
state_save_register_device_item(device, 0, cpustate->fig_latch);
state_save_register_device_item(device, 0, cpustate->attr_latch);
state_save_register_device_item(device, 0, cpustate->adl_latch);
state_save_register_device_item(device, 0, cpustate->adr_latch);
state_save_register_device_item(device, 0, cpustate->iaddr_latch);
state_save_register_device_item(device, 0, cpustate->c_latch);
state_save_register_device_item(device, 0, cpustate->fdt_cnt);
state_save_register_device_item(device, 0, cpustate->ipt_cnt);
state_save_register_device_item(device, 0, cpustate->fig);
state_save_register_device_item(device, 0, cpustate->fig_cycles);
state_save_register_device_item_pointer(device, 0, cpustate->ipt_ram, IPT_RAM_SIZE / sizeof(UINT16));
device->save_item(NAME(cpustate->acc));
device->save_item(NAME(cpustate->ram));
device->save_item(NAME(cpustate->d_latch));
device->save_item(NAME(cpustate->i_latch));
device->save_item(NAME(cpustate->result));
device->save_item(NAME(cpustate->new_status));
device->save_item(NAME(cpustate->status));
device->save_item(NAME(cpustate->inst));
device->save_item(NAME(cpustate->immflag));
device->save_item(NAME(cpustate->ct));
device->save_item(NAME(cpustate->t));
device->save_item(NAME(cpustate->l1));
device->save_item(NAME(cpustate->l2));
device->save_item(NAME(cpustate->l3));
device->save_item(NAME(cpustate->l4));
device->save_item(NAME(cpustate->l5));
device->save_item(NAME(cpustate->l6));
device->save_item(NAME(cpustate->l7));
device->save_item(NAME(cpustate->pl1));
device->save_item(NAME(cpustate->pl2));
device->save_item(NAME(cpustate->pl3));
device->save_item(NAME(cpustate->pl4));
device->save_item(NAME(cpustate->pl5));
device->save_item(NAME(cpustate->pl6));
device->save_item(NAME(cpustate->pl7));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->status_out));
device->save_item(NAME(cpustate->x_scale));
device->save_item(NAME(cpustate->y_scale));
device->save_item(NAME(cpustate->img_bank));
device->save_item(NAME(cpustate->line_latch));
device->save_item(NAME(cpustate->fig_latch));
device->save_item(NAME(cpustate->attr_latch));
device->save_item(NAME(cpustate->adl_latch));
device->save_item(NAME(cpustate->adr_latch));
device->save_item(NAME(cpustate->iaddr_latch));
device->save_item(NAME(cpustate->c_latch));
device->save_item(NAME(cpustate->fdt_cnt));
device->save_item(NAME(cpustate->ipt_cnt));
device->save_item(NAME(cpustate->fig));
device->save_item(NAME(cpustate->fig_cycles));
device->save_pointer(NAME(cpustate->ipt_ram), IPT_RAM_SIZE / sizeof(UINT16));
}

24
src/emu/cpu/f8/f8.c
View File

@ -1903,18 +1903,18 @@ static CPU_INIT( f8 )
cpustate->direct = &cpustate->program->direct();
cpustate->iospace = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->pc0);
state_save_register_device_item(device, 0, cpustate->pc1);
state_save_register_device_item(device, 0, cpustate->dc0);
state_save_register_device_item(device, 0, cpustate->dc1);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->w);
state_save_register_device_item(device, 0, cpustate->is);
state_save_register_device_item(device, 0, cpustate->dbus);
state_save_register_device_item(device, 0, cpustate->io);
state_save_register_device_item(device, 0, cpustate->irq_vector);
state_save_register_device_item(device, 0, cpustate->irq_request);
state_save_register_device_item_array(device, 0, cpustate->r);
device->save_item(NAME(cpustate->pc0));
device->save_item(NAME(cpustate->pc1));
device->save_item(NAME(cpustate->dc0));
device->save_item(NAME(cpustate->dc1));
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->w));
device->save_item(NAME(cpustate->is));
device->save_item(NAME(cpustate->dbus));
device->save_item(NAME(cpustate->io));
device->save_item(NAME(cpustate->irq_vector));
device->save_item(NAME(cpustate->irq_request));
device->save_item(NAME(cpustate->r));
}
static CPU_SET_INFO( f8 )

48
src/emu/cpu/g65816/g65816.c
View File

@ -340,30 +340,30 @@ static CPU_INIT( g65816 )
cpustate->program = device->space(AS_PROGRAM);
cpustate->cpu_type = CPU_TYPE_G65816;
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->s);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->pb);
state_save_register_device_item(device, 0, cpustate->db);
state_save_register_device_item(device, 0, cpustate->d);
state_save_register_device_item(device, 0, cpustate->flag_e);
state_save_register_device_item(device, 0, cpustate->flag_m);
state_save_register_device_item(device, 0, cpustate->flag_x);
state_save_register_device_item(device, 0, cpustate->flag_n);
state_save_register_device_item(device, 0, cpustate->flag_v);
state_save_register_device_item(device, 0, cpustate->flag_d);
state_save_register_device_item(device, 0, cpustate->flag_i);
state_save_register_device_item(device, 0, cpustate->flag_z);
state_save_register_device_item(device, 0, cpustate->flag_c);
state_save_register_device_item(device, 0, cpustate->line_irq);
state_save_register_device_item(device, 0, cpustate->line_nmi);
state_save_register_device_item(device, 0, cpustate->ir);
state_save_register_device_item(device, 0, cpustate->irq_delay);
state_save_register_device_item(device, 0, cpustate->stopped);
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->b));
device->save_item(NAME(cpustate->x));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->s));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->ppc));
device->save_item(NAME(cpustate->pb));
device->save_item(NAME(cpustate->db));
device->save_item(NAME(cpustate->d));
device->save_item(NAME(cpustate->flag_e));
device->save_item(NAME(cpustate->flag_m));
device->save_item(NAME(cpustate->flag_x));
device->save_item(NAME(cpustate->flag_n));
device->save_item(NAME(cpustate->flag_v));
device->save_item(NAME(cpustate->flag_d));
device->save_item(NAME(cpustate->flag_i));
device->save_item(NAME(cpustate->flag_z));
device->save_item(NAME(cpustate->flag_c));
device->save_item(NAME(cpustate->line_irq));
device->save_item(NAME(cpustate->line_nmi));
device->save_item(NAME(cpustate->ir));
device->save_item(NAME(cpustate->irq_delay));
device->save_item(NAME(cpustate->stopped));
device->machine->state().register_postload(g65816_restore_state, cpustate);
}

46
src/emu/cpu/h6280/h6280.c
View File

@ -132,32 +132,32 @@ static CPU_INIT( h6280 )
{
h6280_Regs* cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->ppc.w.l);
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->zp.w.l);
state_save_register_device_item(device, 0, cpustate->ea.w.l);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->p);
state_save_register_device_item_array(device, 0, cpustate->mmr);
state_save_register_device_item(device, 0, cpustate->irq_mask);
state_save_register_device_item(device, 0, cpustate->timer_status);
state_save_register_device_item(device, 0, cpustate->timer_ack);
state_save_register_device_item(device, 0, cpustate->clocks_per_cycle);
state_save_register_device_item(device, 0, cpustate->timer_value);
state_save_register_device_item(device, 0, cpustate->timer_load);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state[0]);
state_save_register_device_item(device, 0, cpustate->irq_state[1]);
state_save_register_device_item(device, 0, cpustate->irq_state[2]);
state_save_register_device_item(device, 0, cpustate->irq_pending);
device->save_item(NAME(cpustate->ppc.w.l));
device->save_item(NAME(cpustate->pc.w.l));
device->save_item(NAME(cpustate->sp.w.l));
device->save_item(NAME(cpustate->zp.w.l));
device->save_item(NAME(cpustate->ea.w.l));
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->x));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->p));
device->save_item(NAME(cpustate->mmr));
device->save_item(NAME(cpustate->irq_mask));
device->save_item(NAME(cpustate->timer_status));
device->save_item(NAME(cpustate->timer_ack));
device->save_item(NAME(cpustate->clocks_per_cycle));
device->save_item(NAME(cpustate->timer_value));
device->save_item(NAME(cpustate->timer_load));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state[0]));
device->save_item(NAME(cpustate->irq_state[1]));
device->save_item(NAME(cpustate->irq_state[2]));
device->save_item(NAME(cpustate->irq_pending));
#if LAZY_FLAGS
state_save_register_device_item(device, 0, cpustate->NZ);
device->save_item(NAME(cpustate->NZ));
#endif
state_save_register_device_item(device, 0, cpustate->io_buffer);
device->save_item(NAME(cpustate->io_buffer));
cpustate->irq_callback = irqcallback;
cpustate->device = device;

22
src/emu/cpu/h83002/h8_16.c
View File

@ -224,18 +224,18 @@ static CPU_INIT(h8)
h8->direct = &h8->program->direct();
h8->io = device->space(AS_IO);
state_save_register_device_item(device, 0, h8->h8err);
state_save_register_device_item_array(device, 0, h8->regs);
state_save_register_device_item(device, 0, h8->pc);
state_save_register_device_item(device, 0, h8->ppc);
state_save_register_device_item(device, 0, h8->h8_IRQrequestH);
state_save_register_device_item(device, 0, h8->h8_IRQrequestL);
state_save_register_device_item(device, 0, h8->ccr);
state_save_register_device_item(device, 0, h8->mode_8bit);
device->save_item(NAME(h8->h8err));
device->save_item(NAME(h8->regs));
device->save_item(NAME(h8->pc));
device->save_item(NAME(h8->ppc));
device->save_item(NAME(h8->h8_IRQrequestH));
device->save_item(NAME(h8->h8_IRQrequestL));
device->save_item(NAME(h8->ccr));
device->save_item(NAME(h8->mode_8bit));
state_save_register_device_item_array(device, 0, h8->per_regs);
state_save_register_device_item(device, 0, h8->h8TSTR);
state_save_register_device_item_array(device, 0, h8->h8TCNT);
device->save_item(NAME(h8->per_regs));
device->save_item(NAME(h8->h8TSTR));
device->save_item(NAME(h8->h8TCNT));
device->machine->state().register_postload(h8_onstateload, h8);

22
src/emu/cpu/h83002/h8_8.c
View File

@ -246,18 +246,18 @@ static CPU_INIT(h8bit)
h8->timer[2] = h8->device->machine->scheduler().timer_alloc(FUNC(h8_timer_2_cb), h8);
h8->timer[3] = h8->device->machine->scheduler().timer_alloc(FUNC(h8_timer_3_cb), h8);
state_save_register_device_item(device, 0, h8->h8err);
state_save_register_device_item_array(device, 0, h8->regs);
state_save_register_device_item(device, 0, h8->pc);
state_save_register_device_item(device, 0, h8->ppc);
state_save_register_device_item(device, 0, h8->h8_IRQrequestH);
state_save_register_device_item(device, 0, h8->h8_IRQrequestL);
state_save_register_device_item(device, 0, h8->ccr);
state_save_register_device_item(device, 0, h8->mode_8bit);
device->save_item(NAME(h8->h8err));
device->save_item(NAME(h8->regs));
device->save_item(NAME(h8->pc));
device->save_item(NAME(h8->ppc));
device->save_item(NAME(h8->h8_IRQrequestH));
device->save_item(NAME(h8->h8_IRQrequestL));
device->save_item(NAME(h8->ccr));
device->save_item(NAME(h8->mode_8bit));
state_save_register_device_item_array(device, 0, h8->per_regs);
state_save_register_device_item(device, 0, h8->h8TSTR);
state_save_register_device_item_array(device, 0, h8->h8TCNT);
device->save_item(NAME(h8->per_regs));
device->save_item(NAME(h8->h8TSTR));
device->save_item(NAME(h8->h8TCNT));
h8->device->machine->state().register_postload(h8_onstateload, h8);
}

28
src/emu/cpu/hd61700/hd61700.c
View File

@ -172,20 +172,20 @@ void hd61700_cpu_device::device_start()
m_sec_timer->adjust(attotime::from_seconds(1), 0, attotime::from_seconds(1));
// save state
state_save_register_device_item(this, 0, m_ppc);
state_save_register_device_item(this, 0, m_curpc);
state_save_register_device_item(this, 0, m_pc);
state_save_register_device_item(this, 0, m_flags);
state_save_register_device_item(this, 0, m_fetch_addr);
state_save_register_device_item(this, 0, m_irq_status);
state_save_register_device_item(this, 0, m_state);
state_save_register_device_item(this, 0, prev_ua);
state_save_register_device_item(this, 0, m_icount);
state_save_register_device_item_array(this, 0, m_regsir);
state_save_register_device_item_array(this, 0, m_reg8bit);
state_save_register_device_item_array(this, 0, m_reg16bit);
state_save_register_device_item_array(this, 0, m_regmain);
state_save_register_device_item_array(this, 0, m_lines_status);
save_item(NAME(m_ppc));
save_item(NAME(m_curpc));
save_item(NAME(m_pc));
save_item(NAME(m_flags));
save_item(NAME(m_fetch_addr));
save_item(NAME(m_irq_status));
save_item(NAME(m_state));
save_item(NAME(prev_ua));
save_item(NAME(m_icount));
save_item(NAME(m_regsir));
save_item(NAME(m_reg8bit));
save_item(NAME(m_reg16bit));
save_item(NAME(m_regmain));
save_item(NAME(m_lines_status));
// register state for debugger
state_add(HD61700_PC, "pc", m_pc).callimport().callexport().formatstr("%04X");

26
src/emu/cpu/hd6309/hd6309.c
View File

@ -532,20 +532,20 @@ static CPU_INIT( hd6309 )
m68_state->regTable[2] = &(B);
m68_state->regTable[3] = &m68_state->dummy_byte;
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, U);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, Y);
state_save_register_device_item(device, 0, V);
state_save_register_device_item(device, 0, DP);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item(device, 0, MD);
device->save_item(NAME(PC));
device->save_item(NAME(U));
device->save_item(NAME(S));
device->save_item(NAME(X));
device->save_item(NAME(Y));
device->save_item(NAME(V));
device->save_item(NAME(DP));
device->save_item(NAME(CC));
device->save_item(NAME(MD));
device->machine->state().register_postload(hd6309_postload, (void *) device);
state_save_register_device_item(device, 0, m68_state->int_state);
state_save_register_device_item(device, 0, m68_state->nmi_state);
state_save_register_device_item(device, 0, m68_state->irq_state[0]);
state_save_register_device_item(device, 0, m68_state->irq_state[1]);
device->save_item(NAME(m68_state->int_state));
device->save_item(NAME(m68_state->nmi_state));
device->save_item(NAME(m68_state->irq_state[0]));
device->save_item(NAME(m68_state->irq_state[1]));
}
/****************************************************************************/

106
src/emu/cpu/i386/i386.c
View File

@ -552,59 +552,59 @@ static CPU_INIT( i386 )
cpustate->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO);
state_save_register_device_item_array(device, 0, cpustate->reg.d);
state_save_register_device_item(device, 0, cpustate->sreg[ES].selector);
state_save_register_device_item(device, 0, cpustate->sreg[ES].base);
state_save_register_device_item(device, 0, cpustate->sreg[ES].limit);
state_save_register_device_item(device, 0, cpustate->sreg[ES].flags);
state_save_register_device_item(device, 0, cpustate->sreg[CS].selector);
state_save_register_device_item(device, 0, cpustate->sreg[CS].base);
state_save_register_device_item(device, 0, cpustate->sreg[CS].limit);
state_save_register_device_item(device, 0, cpustate->sreg[CS].flags);
state_save_register_device_item(device, 0, cpustate->sreg[SS].selector);
state_save_register_device_item(device, 0, cpustate->sreg[SS].base);
state_save_register_device_item(device, 0, cpustate->sreg[SS].limit);
state_save_register_device_item(device, 0, cpustate->sreg[SS].flags);
state_save_register_device_item(device, 0, cpustate->sreg[DS].selector);
state_save_register_device_item(device, 0, cpustate->sreg[DS].base);
state_save_register_device_item(device, 0, cpustate->sreg[DS].limit);
state_save_register_device_item(device, 0, cpustate->sreg[DS].flags);
state_save_register_device_item(device, 0, cpustate->sreg[FS].selector);
state_save_register_device_item(device, 0, cpustate->sreg[FS].base);
state_save_register_device_item(device, 0, cpustate->sreg[FS].limit);
state_save_register_device_item(device, 0, cpustate->sreg[FS].flags);
state_save_register_device_item(device, 0, cpustate->sreg[GS].selector);
state_save_register_device_item(device, 0, cpustate->sreg[GS].base);
state_save_register_device_item(device, 0, cpustate->sreg[GS].limit);
state_save_register_device_item(device, 0, cpustate->sreg[GS].flags);
state_save_register_device_item(device, 0, cpustate->eip);
state_save_register_device_item(device, 0, cpustate->prev_eip);
state_save_register_device_item(device, 0, cpustate->CF);
state_save_register_device_item(device, 0, cpustate->DF);
state_save_register_device_item(device, 0, cpustate->SF);
state_save_register_device_item(device, 0, cpustate->OF);
state_save_register_device_item(device, 0, cpustate->ZF);
state_save_register_device_item(device, 0, cpustate->PF);
state_save_register_device_item(device, 0, cpustate->AF);
state_save_register_device_item(device, 0, cpustate->IF);
state_save_register_device_item(device, 0, cpustate->TF);
state_save_register_device_item_array(device, 0, cpustate->cr);
state_save_register_device_item_array(device, 0, cpustate->dr);
state_save_register_device_item_array(device, 0, cpustate->tr);
state_save_register_device_item(device, 0, cpustate->idtr.base);
state_save_register_device_item(device, 0, cpustate->idtr.limit);
state_save_register_device_item(device, 0, cpustate->gdtr.base);
state_save_register_device_item(device, 0, cpustate->gdtr.limit);
state_save_register_device_item(device, 0, cpustate->task.base);
state_save_register_device_item(device, 0, cpustate->task.segment);
state_save_register_device_item(device, 0, cpustate->task.limit);
state_save_register_device_item(device, 0, cpustate->task.flags);
state_save_register_device_item(device, 0, cpustate->ldtr.base);
state_save_register_device_item(device, 0, cpustate->ldtr.segment);
state_save_register_device_item(device, 0, cpustate->ldtr.limit);
state_save_register_device_item(device, 0, cpustate->ldtr.flags);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->performed_intersegment_jump);
device->save_item(NAME( cpustate->reg.d));
device->save_item(NAME(cpustate->sreg[ES].selector));
device->save_item(NAME(cpustate->sreg[ES].base));
device->save_item(NAME(cpustate->sreg[ES].limit));
device->save_item(NAME(cpustate->sreg[ES].flags));
device->save_item(NAME(cpustate->sreg[CS].selector));
device->save_item(NAME(cpustate->sreg[CS].base));
device->save_item(NAME(cpustate->sreg[CS].limit));
device->save_item(NAME(cpustate->sreg[CS].flags));
device->save_item(NAME(cpustate->sreg[SS].selector));
device->save_item(NAME(cpustate->sreg[SS].base));
device->save_item(NAME(cpustate->sreg[SS].limit));
device->save_item(NAME(cpustate->sreg[SS].flags));
device->save_item(NAME(cpustate->sreg[DS].selector));
device->save_item(NAME(cpustate->sreg[DS].base));
device->save_item(NAME(cpustate->sreg[DS].limit));
device->save_item(NAME(cpustate->sreg[DS].flags));
device->save_item(NAME(cpustate->sreg[FS].selector));
device->save_item(NAME(cpustate->sreg[FS].base));
device->save_item(NAME(cpustate->sreg[FS].limit));
device->save_item(NAME(cpustate->sreg[FS].flags));
device->save_item(NAME(cpustate->sreg[GS].selector));
device->save_item(NAME(cpustate->sreg[GS].base));
device->save_item(NAME(cpustate->sreg[GS].limit));
device->save_item(NAME(cpustate->sreg[GS].flags));
device->save_item(NAME(cpustate->eip));
device->save_item(NAME(cpustate->prev_eip));
device->save_item(NAME(cpustate->CF));
device->save_item(NAME(cpustate->DF));
device->save_item(NAME(cpustate->SF));
device->save_item(NAME(cpustate->OF));
device->save_item(NAME(cpustate->ZF));
device->save_item(NAME(cpustate->PF));
device->save_item(NAME(cpustate->AF));
device->save_item(NAME(cpustate->IF));
device->save_item(NAME(cpustate->TF));
device->save_item(NAME( cpustate->cr));
device->save_item(NAME( cpustate->dr));
device->save_item(NAME( cpustate->tr));
device->save_item(NAME(cpustate->idtr.base));
device->save_item(NAME(cpustate->idtr.limit));
device->save_item(NAME(cpustate->gdtr.base));
device->save_item(NAME(cpustate->gdtr.limit));
device->save_item(NAME(cpustate->task.base));
device->save_item(NAME(cpustate->task.segment));
device->save_item(NAME(cpustate->task.limit));
device->save_item(NAME(cpustate->task.flags));
device->save_item(NAME(cpustate->ldtr.base));
device->save_item(NAME(cpustate->ldtr.segment));
device->save_item(NAME(cpustate->ldtr.limit));
device->save_item(NAME(cpustate->ldtr.flags));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->performed_intersegment_jump));
device->machine->state().register_postload(i386_postload, (void *)device);
}

36
src/emu/cpu/i4004/i4004.c
View File

@ -468,24 +468,24 @@ static CPU_INIT( i4004 )
cpustate->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->C);
state_save_register_device_item(device, 0, cpustate->TEST);
state_save_register_device_item(device, 0, cpustate->pc_pos);
state_save_register_device_item(device, 0, cpustate->ADDR[0]);
state_save_register_device_item(device, 0, cpustate->ADDR[1]);
state_save_register_device_item(device, 0, cpustate->ADDR[2]);
state_save_register_device_item(device, 0, cpustate->ADDR[3]);
state_save_register_device_item(device, 0, cpustate->R[0]);
state_save_register_device_item(device, 0, cpustate->R[1]);
state_save_register_device_item(device, 0, cpustate->R[2]);
state_save_register_device_item(device, 0, cpustate->R[3]);
state_save_register_device_item(device, 0, cpustate->R[4]);
state_save_register_device_item(device, 0, cpustate->R[5]);
state_save_register_device_item(device, 0, cpustate->R[6]);
state_save_register_device_item(device, 0, cpustate->R[7]);
state_save_register_device_item(device, 0, cpustate->RAM);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->C));
device->save_item(NAME(cpustate->TEST));
device->save_item(NAME(cpustate->pc_pos));
device->save_item(NAME(cpustate->ADDR[0]));
device->save_item(NAME(cpustate->ADDR[1]));
device->save_item(NAME(cpustate->ADDR[2]));
device->save_item(NAME(cpustate->ADDR[3]));
device->save_item(NAME(cpustate->R[0]));
device->save_item(NAME(cpustate->R[1]));
device->save_item(NAME(cpustate->R[2]));
device->save_item(NAME(cpustate->R[3]));
device->save_item(NAME(cpustate->R[4]));
device->save_item(NAME(cpustate->R[5]));
device->save_item(NAME(cpustate->R[6]));
device->save_item(NAME(cpustate->R[7]));
device->save_item(NAME(cpustate->RAM));
}

46
src/emu/cpu/i8008/i8008.c
View File

@ -551,29 +551,29 @@ static CPU_INIT( i8008 )
init_tables();
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->B);
state_save_register_device_item(device, 0, cpustate->C);
state_save_register_device_item(device, 0, cpustate->D);
state_save_register_device_item(device, 0, cpustate->E);
state_save_register_device_item(device, 0, cpustate->H);
state_save_register_device_item(device, 0, cpustate->L);
state_save_register_device_item(device, 0, cpustate->CF);
state_save_register_device_item(device, 0, cpustate->SF);
state_save_register_device_item(device, 0, cpustate->ZF);
state_save_register_device_item(device, 0, cpustate->PF);
state_save_register_device_item(device, 0, cpustate->pc_pos);
state_save_register_device_item(device, 0, cpustate->ADDR[0]);
state_save_register_device_item(device, 0, cpustate->ADDR[1]);
state_save_register_device_item(device, 0, cpustate->ADDR[2]);
state_save_register_device_item(device, 0, cpustate->ADDR[3]);
state_save_register_device_item(device, 0, cpustate->ADDR[4]);
state_save_register_device_item(device, 0, cpustate->ADDR[5]);
state_save_register_device_item(device, 0, cpustate->ADDR[6]);
state_save_register_device_item(device, 0, cpustate->ADDR[7]);
state_save_register_device_item(device, 0, cpustate->HALT);
state_save_register_device_item(device, 0, cpustate->irq_state);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->B));
device->save_item(NAME(cpustate->C));
device->save_item(NAME(cpustate->D));
device->save_item(NAME(cpustate->E));
device->save_item(NAME(cpustate->H));
device->save_item(NAME(cpustate->L));
device->save_item(NAME(cpustate->CF));
device->save_item(NAME(cpustate->SF));
device->save_item(NAME(cpustate->ZF));
device->save_item(NAME(cpustate->PF));
device->save_item(NAME(cpustate->pc_pos));
device->save_item(NAME(cpustate->ADDR[0]));
device->save_item(NAME(cpustate->ADDR[1]));
device->save_item(NAME(cpustate->ADDR[2]));
device->save_item(NAME(cpustate->ADDR[3]));
device->save_item(NAME(cpustate->ADDR[4]));
device->save_item(NAME(cpustate->ADDR[5]));
device->save_item(NAME(cpustate->ADDR[6]));
device->save_item(NAME(cpustate->ADDR[7]));
device->save_item(NAME(cpustate->HALT));
device->save_item(NAME(cpustate->irq_state));
}

30
src/emu/cpu/i8085/i8085.c
View File

@ -1017,21 +1017,21 @@ static void init_808x_common(legacy_cpu_device *device, device_irq_callback irqc
devcb_resolve_write_line(&cpustate->out_sod_func, &cpustate->config.out_sod_func, device);
/* register for state saving */
state_save_register_device_item(device, 0, cpustate->PC.w.l);
state_save_register_device_item(device, 0, cpustate->SP.w.l);
state_save_register_device_item(device, 0, cpustate->AF.w.l);
state_save_register_device_item(device, 0, cpustate->BC.w.l);
state_save_register_device_item(device, 0, cpustate->DE.w.l);
state_save_register_device_item(device, 0, cpustate->HL.w.l);
state_save_register_device_item(device, 0, cpustate->HALT);
state_save_register_device_item(device, 0, cpustate->IM);
state_save_register_device_item(device, 0, cpustate->STATUS);
state_save_register_device_item(device, 0, cpustate->after_ei);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item_array(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->trap_pending);
state_save_register_device_item(device, 0, cpustate->trap_im_copy);
state_save_register_device_item(device, 0, cpustate->sod_state);
device->save_item(NAME(cpustate->PC.w.l));
device->save_item(NAME(cpustate->SP.w.l));
device->save_item(NAME(cpustate->AF.w.l));
device->save_item(NAME(cpustate->BC.w.l));
device->save_item(NAME(cpustate->DE.w.l));
device->save_item(NAME(cpustate->HL.w.l));
device->save_item(NAME(cpustate->HALT));
device->save_item(NAME(cpustate->IM));
device->save_item(NAME(cpustate->STATUS));
device->save_item(NAME(cpustate->after_ei));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->trap_pending));
device->save_item(NAME(cpustate->trap_im_copy));
device->save_item(NAME(cpustate->sod_state));
}
static CPU_INIT( i8080 )

70
src/emu/cpu/i86/i286.c
View File

@ -253,41 +253,41 @@ static CPU_INIT( i80286 )
{
i80286_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->regs.w);
state_save_register_device_item(device, 0, cpustate->amask);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->prevpc);
state_save_register_device_item(device, 0, cpustate->msw);
state_save_register_device_item_array(device, 0, cpustate->base);
state_save_register_device_item_array(device, 0, cpustate->sregs);
state_save_register_device_item_array(device, 0, cpustate->limit);
state_save_register_device_item_array(device, 0, cpustate->rights);
state_save_register_device_item(device, 0, cpustate->gdtr.base);
state_save_register_device_item(device, 0, cpustate->gdtr.limit);
state_save_register_device_item(device, 0, cpustate->idtr.base);
state_save_register_device_item(device, 0, cpustate->idtr.limit);
state_save_register_device_item(device, 0, cpustate->ldtr.sel);
state_save_register_device_item(device, 0, cpustate->ldtr.base);
state_save_register_device_item(device, 0, cpustate->ldtr.limit);
state_save_register_device_item(device, 0, cpustate->ldtr.rights);
state_save_register_device_item(device, 0, cpustate->tr.sel);
state_save_register_device_item(device, 0, cpustate->tr.base);
state_save_register_device_item(device, 0, cpustate->tr.limit);
state_save_register_device_item(device, 0, cpustate->tr.rights);
state_save_register_device_item(device, 0, cpustate->AuxVal);
state_save_register_device_item(device, 0, cpustate->OverVal);
state_save_register_device_item(device, 0, cpustate->SignVal);
state_save_register_device_item(device, 0, cpustate->ZeroVal);
state_save_register_device_item(device, 0, cpustate->CarryVal);
state_save_register_device_item(device, 0, cpustate->DirVal);
state_save_register_device_item(device, 0, cpustate->ParityVal);
state_save_register_device_item(device, 0, cpustate->TF);
state_save_register_device_item(device, 0, cpustate->IF);
state_save_register_device_item(device, 0, cpustate->int_vector);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->extra_cycles);
state_save_register_device_item(device, 0, cpustate->rep_in_progress);
device->save_item(NAME(cpustate->regs.w));
device->save_item(NAME(cpustate->amask));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->prevpc));
device->save_item(NAME(cpustate->msw));
device->save_item(NAME(cpustate->base));
device->save_item(NAME(cpustate->sregs));
device->save_item(NAME(cpustate->limit));
device->save_item(NAME(cpustate->rights));
device->save_item(NAME(cpustate->gdtr.base));
device->save_item(NAME(cpustate->gdtr.limit));
device->save_item(NAME(cpustate->idtr.base));
device->save_item(NAME(cpustate->idtr.limit));
device->save_item(NAME(cpustate->ldtr.sel));
device->save_item(NAME(cpustate->ldtr.base));
device->save_item(NAME(cpustate->ldtr.limit));
device->save_item(NAME(cpustate->ldtr.rights));
device->save_item(NAME(cpustate->tr.sel));
device->save_item(NAME(cpustate->tr.base));
device->save_item(NAME(cpustate->tr.limit));
device->save_item(NAME(cpustate->tr.rights));
device->save_item(NAME(cpustate->AuxVal));
device->save_item(NAME(cpustate->OverVal));
device->save_item(NAME(cpustate->SignVal));
device->save_item(NAME(cpustate->ZeroVal));
device->save_item(NAME(cpustate->CarryVal));
device->save_item(NAME(cpustate->DirVal));
device->save_item(NAME(cpustate->ParityVal));
device->save_item(NAME(cpustate->TF));
device->save_item(NAME(cpustate->IF));
device->save_item(NAME(cpustate->int_vector));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->extra_cycles));
device->save_item(NAME(cpustate->rep_in_progress));
cpustate->irq_callback = irqcallback;
cpustate->device = device;

46
src/emu/cpu/i86/i86.c
View File

@ -114,29 +114,29 @@ static UINT8 parity_table[256];
static void i8086_state_register(device_t *device)
{
i8086_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->regs.w);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->prevpc);
state_save_register_device_item_array(device, 0, cpustate->base);
state_save_register_device_item_array(device, 0, cpustate->sregs);
state_save_register_device_item(device, 0, cpustate->flags);
state_save_register_device_item(device, 0, cpustate->AuxVal);
state_save_register_device_item(device, 0, cpustate->OverVal);
state_save_register_device_item(device, 0, cpustate->SignVal);
state_save_register_device_item(device, 0, cpustate->ZeroVal);
state_save_register_device_item(device, 0, cpustate->CarryVal);
state_save_register_device_item(device, 0, cpustate->DirVal);
state_save_register_device_item(device, 0, cpustate->ParityVal);
state_save_register_device_item(device, 0, cpustate->TF);
state_save_register_device_item(device, 0, cpustate->IF);
state_save_register_device_item(device, 0, cpustate->MF);
state_save_register_device_item(device, 0, cpustate->int_vector);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->extra_cycles);
state_save_register_device_item(device, 0, cpustate->halted);
state_save_register_device_item(device, 0, cpustate->test_state); /* PJB 03/05 */
state_save_register_device_item(device, 0, cpustate->rep_in_progress); /* PJB 03/05 */
device->save_item(NAME(cpustate->regs.w));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->prevpc));
device->save_item(NAME(cpustate->base));
device->save_item(NAME(cpustate->sregs));
device->save_item(NAME(cpustate->flags));
device->save_item(NAME(cpustate->AuxVal));
device->save_item(NAME(cpustate->OverVal));
device->save_item(NAME(cpustate->SignVal));
device->save_item(NAME(cpustate->ZeroVal));
device->save_item(NAME(cpustate->CarryVal));
device->save_item(NAME(cpustate->DirVal));
device->save_item(NAME(cpustate->ParityVal));
device->save_item(NAME(cpustate->TF));
device->save_item(NAME(cpustate->IF));
device->save_item(NAME(cpustate->MF));
device->save_item(NAME(cpustate->int_vector));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->extra_cycles));
device->save_item(NAME(cpustate->halted));
device->save_item(NAME(cpustate->test_state)); /* PJB 03/05 */
device->save_item(NAME(cpustate->rep_in_progress)); /* PJB 03/05 */
}
static CPU_INIT( i8086 )

8
src/emu/cpu/i860/i860.c
View File

@ -36,10 +36,10 @@ static CPU_INIT( i860 )
i860_set_pin(device, DEC_PIN_RESET, 0);
cpustate->single_stepping = 0;
state_save_register_device_item_array(device, 0, cpustate->iregs);
state_save_register_device_item_array(device, 0, cpustate->cregs);
state_save_register_device_item_array(device, 0, cpustate->frg);
state_save_register_device_item(device, 0, cpustate->pc);
device->save_item(NAME(cpustate->iregs));
device->save_item(NAME(cpustate->cregs));
device->save_item(NAME(cpustate->frg));
device->save_item(NAME(cpustate->pc));
}
static CPU_RESET( i860 )

20
src/emu/cpu/i960/i960.c
View File

@ -2071,16 +2071,16 @@ static CPU_INIT( i960 )
i960->program = device->space(AS_PROGRAM);
i960->direct = &i960->program->direct();
state_save_register_device_item(device, 0, i960->PIP);
state_save_register_device_item(device, 0, i960->SAT);
state_save_register_device_item(device, 0, i960->PRCB);
state_save_register_device_item(device, 0, i960->PC);
state_save_register_device_item(device, 0, i960->AC);
state_save_register_device_item(device, 0, i960->ICR);
state_save_register_device_item_array(device, 0, i960->r);
state_save_register_device_item_array(device, 0, i960->fp);
state_save_register_device_item_2d_array(device, 0, i960->rcache);
state_save_register_device_item_array(device, 0, i960->rcache_frame_addr);
device->save_item(NAME(i960->PIP));
device->save_item(NAME(i960->SAT));
device->save_item(NAME(i960->PRCB));
device->save_item(NAME(i960->PC));
device->save_item(NAME(i960->AC));
device->save_item(NAME(i960->ICR));
device->save_item(NAME(i960->r));
device->save_item(NAME(i960->fp));
device->save_item(NAME(i960->rcache));
device->save_item(NAME(i960->rcache_frame_addr));
}
static CPU_RESET( i960 )

8
src/emu/cpu/jaguar/jaguar.c
View File

@ -426,10 +426,10 @@ static void init_common(int isdsp, legacy_cpu_device *device, device_irq_callbac
if (configdata != NULL)
jaguar->cpu_interrupt = configdata->cpu_int_callback;
state_save_register_device_item_array(device, 0, jaguar->r);
state_save_register_device_item_array(device, 0, jaguar->a);
state_save_register_device_item_array(device, 0, jaguar->ctrl);
state_save_register_device_item(device, 0, jaguar->ppc);
device->save_item(NAME(jaguar->r));
device->save_item(NAME(jaguar->a));
device->save_item(NAME(jaguar->ctrl));
device->save_item(NAME(jaguar->ppc));
device->machine->state().register_postload(jaguar_postload, (void *)device);
}

26
src/emu/cpu/konami/konami.c
View File

@ -407,19 +407,19 @@ static CPU_INIT( konami )
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, U);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, Y);
state_save_register_device_item(device, 0, D);
state_save_register_device_item(device, 0, DP);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item(device, 0, cpustate->int_state);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->nmi_pending);
state_save_register_device_item(device, 0, cpustate->irq_state[0]);
state_save_register_device_item(device, 0, cpustate->irq_state[1]);
device->save_item(NAME(PC));
device->save_item(NAME(U));
device->save_item(NAME(S));
device->save_item(NAME(X));
device->save_item(NAME(Y));
device->save_item(NAME(D));
device->save_item(NAME(DP));
device->save_item(NAME(CC));
device->save_item(NAME(cpustate->int_state));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->nmi_pending));
device->save_item(NAME(cpustate->irq_state[0]));
device->save_item(NAME(cpustate->irq_state[1]));
}
static CPU_RESET( konami )

80
src/emu/cpu/m37710/m37710.c
View File

@ -908,46 +908,46 @@ static CPU_INIT( m37710 )
for (i = 0; i < 8; i++)
cpustate->timers[i] = device->machine->scheduler().timer_alloc(FUNC(m37710_timer_cb), cpustate);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->ba);
state_save_register_device_item(device, 0, cpustate->bb);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->s);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->pb);
state_save_register_device_item(device, 0, cpustate->db);
state_save_register_device_item(device, 0, cpustate->d);
state_save_register_device_item(device, 0, cpustate->flag_e);
state_save_register_device_item(device, 0, cpustate->flag_m);
state_save_register_device_item(device, 0, cpustate->flag_x);
state_save_register_device_item(device, 0, cpustate->flag_n);
state_save_register_device_item(device, 0, cpustate->flag_v);
state_save_register_device_item(device, 0, cpustate->flag_d);
state_save_register_device_item(device, 0, cpustate->flag_i);
state_save_register_device_item(device, 0, cpustate->flag_z);
state_save_register_device_item(device, 0, cpustate->flag_c);
state_save_register_device_item(device, 0, cpustate->line_irq);
state_save_register_device_item(device, 0, cpustate->ipl);
state_save_register_device_item(device, 0, cpustate->ir);
state_save_register_device_item(device, 0, cpustate->im);
state_save_register_device_item(device, 0, cpustate->im2);
state_save_register_device_item(device, 0, cpustate->im3);
state_save_register_device_item(device, 0, cpustate->im4);
state_save_register_device_item(device, 0, cpustate->irq_delay);
state_save_register_device_item(device, 0, cpustate->irq_level);
state_save_register_device_item(device, 0, cpustate->stopped);
state_save_register_device_item_array(device, 0, cpustate->m37710_regs);
state_save_register_device_item(device, 0, cpustate->reload[0]);
state_save_register_device_item(device, 0, cpustate->reload[1]);
state_save_register_device_item(device, 0, cpustate->reload[2]);
state_save_register_device_item(device, 0, cpustate->reload[3]);
state_save_register_device_item(device, 0, cpustate->reload[4]);
state_save_register_device_item(device, 0, cpustate->reload[5]);
state_save_register_device_item(device, 0, cpustate->reload[6]);
state_save_register_device_item(device, 0, cpustate->reload[7]);
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->b));
device->save_item(NAME(cpustate->ba));
device->save_item(NAME(cpustate->bb));
device->save_item(NAME(cpustate->x));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->s));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->ppc));
device->save_item(NAME(cpustate->pb));
device->save_item(NAME(cpustate->db));
device->save_item(NAME(cpustate->d));
device->save_item(NAME(cpustate->flag_e));
device->save_item(NAME(cpustate->flag_m));
device->save_item(NAME(cpustate->flag_x));
device->save_item(NAME(cpustate->flag_n));
device->save_item(NAME(cpustate->flag_v));
device->save_item(NAME(cpustate->flag_d));
device->save_item(NAME(cpustate->flag_i));
device->save_item(NAME(cpustate->flag_z));
device->save_item(NAME(cpustate->flag_c));
device->save_item(NAME(cpustate->line_irq));
device->save_item(NAME(cpustate->ipl));
device->save_item(NAME(cpustate->ir));
device->save_item(NAME(cpustate->im));
device->save_item(NAME(cpustate->im2));
device->save_item(NAME(cpustate->im3));
device->save_item(NAME(cpustate->im4));
device->save_item(NAME(cpustate->irq_delay));
device->save_item(NAME(cpustate->irq_level));
device->save_item(NAME(cpustate->stopped));
device->save_item(NAME(cpustate->m37710_regs));
device->save_item(NAME(cpustate->reload[0]));
device->save_item(NAME(cpustate->reload[1]));
device->save_item(NAME(cpustate->reload[2]));
device->save_item(NAME(cpustate->reload[3]));
device->save_item(NAME(cpustate->reload[4]));
device->save_item(NAME(cpustate->reload[5]));
device->save_item(NAME(cpustate->reload[6]));
device->save_item(NAME(cpustate->reload[7]));
device->machine->state().register_postload(m37710_restore_state, cpustate);
}

26
src/emu/cpu/m6502/m6502.c
View File

@ -159,22 +159,22 @@ static void m6502_common_init(legacy_cpu_device *device, device_irq_callback irq
cpustate->port_write = intf->port_write_func;
}
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->p);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->pending_irq);
state_save_register_device_item(device, 0, cpustate->after_cli);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->so_state);
device->save_item(NAME(cpustate->pc.w.l));
device->save_item(NAME(cpustate->sp.w.l));
device->save_item(NAME(cpustate->p));
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->x));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->pending_irq));
device->save_item(NAME(cpustate->after_cli));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->so_state));
if (subtype == SUBTYPE_6510)
{
state_save_register_device_item(device, 0, cpustate->port);
state_save_register_device_item(device, 0, cpustate->ddr);
device->save_item(NAME(cpustate->port));
device->save_item(NAME(cpustate->ddr));
}
}

90
src/emu/cpu/m6800/m6800.c
View File

@ -987,54 +987,54 @@ static TIMER_CALLBACK( sci_tick )
****************************************************************************/
static void state_register(m6800_state *cpustate, const char *type)
{
state_save_register_device_item(cpustate->device, 0, cpustate->ppc.w.l);
state_save_register_device_item(cpustate->device, 0, cpustate->pc.w.l);
state_save_register_device_item(cpustate->device, 0, cpustate->s.w.l);
state_save_register_device_item(cpustate->device, 0, cpustate->x.w.l);
state_save_register_device_item(cpustate->device, 0, cpustate->d.w.l);
state_save_register_device_item(cpustate->device, 0, cpustate->cc);
state_save_register_device_item(cpustate->device, 0, cpustate->wai_state);
state_save_register_device_item(cpustate->device, 0, cpustate->nmi_state);
state_save_register_device_item(cpustate->device, 0, cpustate->nmi_pending);
state_save_register_device_item_array(cpustate->device, 0, cpustate->irq_state);
state_save_register_device_item(cpustate->device, 0, cpustate->ic_eddge);
cpustate->device->save_item(NAME(cpustate->ppc.w.l));
cpustate->device->save_item(NAME(cpustate->pc.w.l));
cpustate->device->save_item(NAME(cpustate->s.w.l));
cpustate->device->save_item(NAME(cpustate->x.w.l));
cpustate->device->save_item(NAME(cpustate->d.w.l));
cpustate->device->save_item(NAME(cpustate->cc));
cpustate->device->save_item(NAME(cpustate->wai_state));
cpustate->device->save_item(NAME(cpustate->nmi_state));
cpustate->device->save_item(NAME(cpustate->nmi_pending));
cpustate->device->save_item(NAME(cpustate->irq_state));
cpustate->device->save_item(NAME(cpustate->ic_eddge));
state_save_register_device_item(cpustate->device, 0, cpustate->port1_ddr);
state_save_register_device_item(cpustate->device, 0, cpustate->port2_ddr);
state_save_register_device_item(cpustate->device, 0, cpustate->port3_ddr);
state_save_register_device_item(cpustate->device, 0, cpustate->port4_ddr);
state_save_register_device_item(cpustate->device, 0, cpustate->port1_data);
state_save_register_device_item(cpustate->device, 0, cpustate->port2_data);
state_save_register_device_item(cpustate->device, 0, cpustate->port3_data);
state_save_register_device_item(cpustate->device, 0, cpustate->port4_data);
state_save_register_device_item(cpustate->device, 0, cpustate->port2_written);
state_save_register_device_item(cpustate->device, 0, cpustate->port3_latched);
state_save_register_device_item(cpustate->device, 0, cpustate->p3csr);
state_save_register_device_item(cpustate->device, 0, cpustate->p3csr_is3_flag_read);
state_save_register_device_item(cpustate->device, 0, cpustate->tcsr);
state_save_register_device_item(cpustate->device, 0, cpustate->pending_tcsr);
state_save_register_device_item(cpustate->device, 0, cpustate->irq2);
state_save_register_device_item(cpustate->device, 0, cpustate->ram_ctrl);
cpustate->device->save_item(NAME(cpustate->port1_ddr));
cpustate->device->save_item(NAME(cpustate->port2_ddr));
cpustate->device->save_item(NAME(cpustate->port3_ddr));
cpustate->device->save_item(NAME(cpustate->port4_ddr));
cpustate->device->save_item(NAME(cpustate->port1_data));
cpustate->device->save_item(NAME(cpustate->port2_data));
cpustate->device->save_item(NAME(cpustate->port3_data));
cpustate->device->save_item(NAME(cpustate->port4_data));
cpustate->device->save_item(NAME(cpustate->port2_written));
cpustate->device->save_item(NAME(cpustate->port3_latched));
cpustate->device->save_item(NAME(cpustate->p3csr));
cpustate->device->save_item(NAME(cpustate->p3csr_is3_flag_read));
cpustate->device->save_item(NAME(cpustate->tcsr));
cpustate->device->save_item(NAME(cpustate->pending_tcsr));
cpustate->device->save_item(NAME(cpustate->irq2));
cpustate->device->save_item(NAME(cpustate->ram_ctrl));
state_save_register_device_item(cpustate->device, 0, cpustate->counter.d);
state_save_register_device_item(cpustate->device, 0, cpustate->output_compare.d);
state_save_register_device_item(cpustate->device, 0, cpustate->input_capture);
state_save_register_device_item(cpustate->device, 0, cpustate->timer_over.d);
cpustate->device->save_item(NAME(cpustate->counter.d));
cpustate->device->save_item(NAME(cpustate->output_compare.d));
cpustate->device->save_item(NAME(cpustate->input_capture));
cpustate->device->save_item(NAME(cpustate->timer_over.d));
state_save_register_device_item(cpustate->device, 0, cpustate->clock);
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr);
state_save_register_device_item(cpustate->device, 0, cpustate->rmcr);
state_save_register_device_item(cpustate->device, 0, cpustate->rdr);
state_save_register_device_item(cpustate->device, 0, cpustate->tdr);
state_save_register_device_item(cpustate->device, 0, cpustate->rsr);
state_save_register_device_item(cpustate->device, 0, cpustate->tsr);
state_save_register_device_item(cpustate->device, 0, cpustate->rxbits);
state_save_register_device_item(cpustate->device, 0, cpustate->txbits);
state_save_register_device_item(cpustate->device, 0, cpustate->txstate);
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_tdre);
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_orfe);
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_rdrf);
state_save_register_device_item(cpustate->device, 0, cpustate->tx);
cpustate->device->save_item(NAME(cpustate->clock));
cpustate->device->save_item(NAME(cpustate->trcsr));
cpustate->device->save_item(NAME(cpustate->rmcr));
cpustate->device->save_item(NAME(cpustate->rdr));
cpustate->device->save_item(NAME(cpustate->tdr));
cpustate->device->save_item(NAME(cpustate->rsr));
cpustate->device->save_item(NAME(cpustate->tsr));
cpustate->device->save_item(NAME(cpustate->rxbits));
cpustate->device->save_item(NAME(cpustate->txbits));
cpustate->device->save_item(NAME(cpustate->txstate));
cpustate->device->save_item(NAME(cpustate->trcsr_read_tdre));
cpustate->device->save_item(NAME(cpustate->trcsr_read_orfe));
cpustate->device->save_item(NAME(cpustate->trcsr_read_rdrf));
cpustate->device->save_item(NAME(cpustate->tx));
}
static CPU_INIT( m6800 )

34
src/emu/cpu/m68000/m68kcpu.c
View File

@ -752,23 +752,23 @@ static CPU_INIT( m68k )
}
/* Note, D covers A because the dar array is common, REG_A=REG_D+8 */
state_save_register_device_item_array(device, 0, REG_D);
state_save_register_device_item(device, 0, REG_PPC);
state_save_register_device_item(device, 0, REG_PC);
state_save_register_device_item(device, 0, REG_USP);
state_save_register_device_item(device, 0, REG_ISP);
state_save_register_device_item(device, 0, REG_MSP);
state_save_register_device_item(device, 0, m68k->vbr);
state_save_register_device_item(device, 0, m68k->sfc);
state_save_register_device_item(device, 0, m68k->dfc);
state_save_register_device_item(device, 0, m68k->cacr);
state_save_register_device_item(device, 0, m68k->caar);
state_save_register_device_item(device, 0, m68k->save_sr);
state_save_register_device_item(device, 0, m68k->int_level);
state_save_register_device_item(device, 0, m68k->save_stopped);
state_save_register_device_item(device, 0, m68k->save_halted);
state_save_register_device_item(device, 0, m68k->pref_addr);
state_save_register_device_item(device, 0, m68k->pref_data);
device->save_item(NAME(REG_D));
device->save_item(NAME(REG_PPC));
device->save_item(NAME(REG_PC));
device->save_item(NAME(REG_USP));
device->save_item(NAME(REG_ISP));
device->save_item(NAME(REG_MSP));
device->save_item(NAME(m68k->vbr));
device->save_item(NAME(m68k->sfc));
device->save_item(NAME(m68k->dfc));
device->save_item(NAME(m68k->cacr));
device->save_item(NAME(m68k->caar));
device->save_item(NAME(m68k->save_sr));
device->save_item(NAME(m68k->int_level));
device->save_item(NAME(m68k->save_stopped));
device->save_item(NAME(m68k->save_halted));
device->save_item(NAME(m68k->pref_addr));
device->save_item(NAME(m68k->pref_data));
device->machine->state().register_presave(m68k_presave, m68k);
device->machine->state().register_postload(m68k_postload, m68k);
}

14
src/emu/cpu/m6805/m6805.c
View File

@ -462,13 +462,13 @@ static void Interrupt( m6805_Regs *cpustate )
static void state_register(m6805_Regs *cpustate, const char *type, legacy_cpu_device *device)
{
state_save_register_device_item(device, 0, A);
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item(device, 0, cpustate->pending_interrupts);
state_save_register_device_item_array(device, 0, cpustate->irq_state);
device->save_item(NAME(A));
device->save_item(NAME(PC));
device->save_item(NAME(S));
device->save_item(NAME(X));
device->save_item(NAME(CC));
device->save_item(NAME(cpustate->pending_interrupts));
device->save_item(NAME(cpustate->irq_state));
}
static CPU_INIT( m6805 )

24
src/emu/cpu/m6809/m6809.c
View File

@ -383,18 +383,18 @@ static CPU_INIT( m6809 )
/* setup regtable */
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, PPC);
state_save_register_device_item(device, 0, D);
state_save_register_device_item(device, 0, DP);
state_save_register_device_item(device, 0, U);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, Y);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item_array(device, 0, m68_state->irq_state);
state_save_register_device_item(device, 0, m68_state->int_state);
state_save_register_device_item(device, 0, m68_state->nmi_state);
device->save_item(NAME(PC));
device->save_item(NAME(PPC));
device->save_item(NAME(D));
device->save_item(NAME(DP));
device->save_item(NAME(U));
device->save_item(NAME(S));
device->save_item(NAME(X));
device->save_item(NAME(Y));
device->save_item(NAME(CC));
device->save_item(NAME(m68_state->irq_state));
device->save_item(NAME(m68_state->int_state));
device->save_item(NAME(m68_state->nmi_state));
}

48
src/emu/cpu/mb88xx/mb88xx.c
View File

@ -151,30 +151,30 @@ static CPU_INIT( mb88 )
cpustate->serial = device->machine->scheduler().timer_alloc(FUNC(serial_timer), (void *)device);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->PA);
state_save_register_device_item(device, 0, cpustate->SP[0]);
state_save_register_device_item(device, 0, cpustate->SP[1]);
state_save_register_device_item(device, 0, cpustate->SP[2]);
state_save_register_device_item(device, 0, cpustate->SP[3]);
state_save_register_device_item(device, 0, cpustate->SI);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->X);
state_save_register_device_item(device, 0, cpustate->Y);
state_save_register_device_item(device, 0, cpustate->st);
state_save_register_device_item(device, 0, cpustate->zf);
state_save_register_device_item(device, 0, cpustate->cf);
state_save_register_device_item(device, 0, cpustate->vf);
state_save_register_device_item(device, 0, cpustate->sf);
state_save_register_device_item(device, 0, cpustate->nf);
state_save_register_device_item(device, 0, cpustate->pio);
state_save_register_device_item(device, 0, cpustate->TH);
state_save_register_device_item(device, 0, cpustate->TL);
state_save_register_device_item(device, 0, cpustate->TP);
state_save_register_device_item(device, 0, cpustate->ctr);
state_save_register_device_item(device, 0, cpustate->SB);
state_save_register_device_item(device, 0, cpustate->SBcount);
state_save_register_device_item(device, 0, cpustate->pending_interrupt);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->PA));
device->save_item(NAME(cpustate->SP[0]));
device->save_item(NAME(cpustate->SP[1]));
device->save_item(NAME(cpustate->SP[2]));
device->save_item(NAME(cpustate->SP[3]));
device->save_item(NAME(cpustate->SI));
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->X));
device->save_item(NAME(cpustate->Y));
device->save_item(NAME(cpustate->st));
device->save_item(NAME(cpustate->zf));
device->save_item(NAME(cpustate->cf));
device->save_item(NAME(cpustate->vf));
device->save_item(NAME(cpustate->sf));
device->save_item(NAME(cpustate->nf));
device->save_item(NAME(cpustate->pio));
device->save_item(NAME(cpustate->TH));
device->save_item(NAME(cpustate->TL));
device->save_item(NAME(cpustate->TP));
device->save_item(NAME(cpustate->ctr));
device->save_item(NAME(cpustate->SB));
device->save_item(NAME(cpustate->SBcount));
device->save_item(NAME(cpustate->pending_interrupt));
}
static CPU_RESET( mb88 )

46
src/emu/cpu/mcs48/mcs48.c
View File

@ -897,32 +897,32 @@ static void mcs48_init(legacy_cpu_device *device, device_irq_callback irqcallbac
/* ensure that regptr is valid before get_info gets called */
update_regptr(cpustate);
state_save_register_device_item(device, 0, cpustate->prevpc);
state_save_register_device_item(device, 0, cpustate->pc);
device->save_item(NAME(cpustate->prevpc));
device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->psw);
state_save_register_device_item(device, 0, cpustate->p1);
state_save_register_device_item(device, 0, cpustate->p2);
state_save_register_device_item(device, 0, cpustate->ea);
state_save_register_device_item(device, 0, cpustate->timer);
state_save_register_device_item(device, 0, cpustate->prescaler);
state_save_register_device_item(device, 0, cpustate->t1_history);
state_save_register_device_item(device, 0, cpustate->sts);
state_save_register_device_item(device, 0, cpustate->dbbi);
state_save_register_device_item(device, 0, cpustate->dbbo);
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->psw));
device->save_item(NAME(cpustate->p1));
device->save_item(NAME(cpustate->p2));
device->save_item(NAME(cpustate->ea));
device->save_item(NAME(cpustate->timer));
device->save_item(NAME(cpustate->prescaler));
device->save_item(NAME(cpustate->t1_history));
device->save_item(NAME(cpustate->sts));
device->save_item(NAME(cpustate->dbbi));
device->save_item(NAME(cpustate->dbbo));
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->irq_in_progress);
state_save_register_device_item(device, 0, cpustate->timer_overflow);
state_save_register_device_item(device, 0, cpustate->timer_flag);
state_save_register_device_item(device, 0, cpustate->tirq_enabled);
state_save_register_device_item(device, 0, cpustate->xirq_enabled);
state_save_register_device_item(device, 0, cpustate->timecount_enabled);
state_save_register_device_item(device, 0, cpustate->flags_enabled);
state_save_register_device_item(device, 0, cpustate->dma_enabled);
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->irq_in_progress));
device->save_item(NAME(cpustate->timer_overflow));
device->save_item(NAME(cpustate->timer_flag));
device->save_item(NAME(cpustate->tirq_enabled));
device->save_item(NAME(cpustate->xirq_enabled));
device->save_item(NAME(cpustate->timecount_enabled));
device->save_item(NAME(cpustate->flags_enabled));
device->save_item(NAME(cpustate->dma_enabled));
state_save_register_device_item(device, 0, cpustate->a11);
device->save_item(NAME(cpustate->a11));
}

30
src/emu/cpu/mcs51/mcs51.c
View File

@ -2091,18 +2091,18 @@ static CPU_INIT( mcs51 )
/* Save states */
state_save_register_device_item(device, 0, mcs51_state->ppc);
state_save_register_device_item(device, 0, mcs51_state->pc);
state_save_register_device_item(device, 0, mcs51_state->rwm );
state_save_register_device_item(device, 0, mcs51_state->cur_irq_prio );
state_save_register_device_item(device, 0, mcs51_state->last_line_state );
state_save_register_device_item(device, 0, mcs51_state->t0_cnt );
state_save_register_device_item(device, 0, mcs51_state->t1_cnt );
state_save_register_device_item(device, 0, mcs51_state->t2_cnt );
state_save_register_device_item(device, 0, mcs51_state->t2ex_cnt );
state_save_register_device_item(device, 0, mcs51_state->recalc_parity );
state_save_register_device_item_array(device, 0, mcs51_state->irq_prio );
state_save_register_device_item(device, 0, mcs51_state->irq_active );
device->save_item(NAME(mcs51_state->ppc));
device->save_item(NAME(mcs51_state->pc));
device->save_item(NAME(mcs51_state->rwm) );
device->save_item(NAME(mcs51_state->cur_irq_prio) );
device->save_item(NAME(mcs51_state->last_line_state) );
device->save_item(NAME(mcs51_state->t0_cnt) );
device->save_item(NAME(mcs51_state->t1_cnt) );
device->save_item(NAME(mcs51_state->t2_cnt) );
device->save_item(NAME(mcs51_state->t2ex_cnt) );
device->save_item(NAME(mcs51_state->recalc_parity) );
device->save_item(NAME(mcs51_state->irq_prio) );
device->save_item(NAME(mcs51_state->irq_active) );
}
static CPU_INIT( i80c51 )
@ -2395,9 +2395,9 @@ static CPU_INIT( ds5002fp )
mcs51_state->sfr_read = ds5002fp_sfr_read;
mcs51_state->sfr_write = ds5002fp_sfr_write;
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.previous_ta );
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.ta_window );
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.range );
device->save_item(NAME(mcs51_state->ds5002fp.previous_ta) );
device->save_item(NAME(mcs51_state->ds5002fp.ta_window) );
device->save_item(NAME(mcs51_state->ds5002fp.range) );
}

18
src/emu/cpu/mips/mips3com.c
View File

@ -111,17 +111,17 @@ void mips3com_init(mips3_state *mips, mips3_flavor flavor, int bigendian, legacy
mips3com_reset(mips);
/* register for save states */
state_save_register_device_item(device, 0, mips->pc);
state_save_register_device_item_array(device, 0, mips->r);
state_save_register_device_item_2d_array(device, 0, mips->cpr);
state_save_register_device_item_2d_array(device, 0, mips->ccr);
state_save_register_device_item(device, 0, mips->llbit);
state_save_register_device_item(device, 0, mips->count_zero_time);
device->save_item(NAME(mips->pc));
device->save_item(NAME(mips->r));
device->save_item(NAME(mips->cpr));
device->save_item(NAME(mips->ccr));
device->save_item(NAME(mips->llbit));
device->save_item(NAME(mips->count_zero_time));
for (tlbindex = 0; tlbindex < mips->tlbentries; tlbindex++)
{
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].page_mask);
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].entry_hi);
state_save_register_device_item_array(device, tlbindex, mips->tlb[tlbindex].entry_lo);
device->save_item(NAME(mips->tlb[tlbindex].page_mask), tlbindex);
device->save_item(NAME(mips->tlb[tlbindex].entry_hi), tlbindex);
device->save_item(NAME(mips->tlb[tlbindex].entry_lo), tlbindex);
}
}

34
src/emu/cpu/mips/psx.c
View File

@ -1610,23 +1610,23 @@ static void mips_state_register( const char *type, legacy_cpu_device *device )
{
psxcpu_state *psxcpu = get_safe_token(device);
state_save_register_device_item( device, 0, psxcpu->op );
state_save_register_device_item( device, 0, psxcpu->pc );
state_save_register_device_item( device, 0, psxcpu->delayv );
state_save_register_device_item( device, 0, psxcpu->delayr );
state_save_register_device_item( device, 0, psxcpu->hi );
state_save_register_device_item( device, 0, psxcpu->lo );
state_save_register_device_item( device, 0, psxcpu->biu );
state_save_register_device_item_array( device, 0, psxcpu->r );
state_save_register_device_item_array( device, 0, psxcpu->cp0r );
state_save_register_device_item_array( device, 0, psxcpu->cp2cr );
state_save_register_device_item_array( device, 0, psxcpu->cp2dr );
state_save_register_device_item_array( device, 0, psxcpu->icacheTag );
state_save_register_device_item_array( device, 0, psxcpu->icache );
state_save_register_device_item_array( device, 0, psxcpu->dcache );
state_save_register_device_item( device, 0, psxcpu->multiplier_operation );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand1 );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand2 );
device->save_item( NAME(psxcpu->op) );
device->save_item( NAME(psxcpu->pc) );
device->save_item( NAME(psxcpu->delayv) );
device->save_item( NAME(psxcpu->delayr) );
device->save_item( NAME(psxcpu->hi) );
device->save_item( NAME(psxcpu->lo) );
device->save_item( NAME(psxcpu->biu) );
device->save_item( NAME(psxcpu->r) );
device->save_item( NAME(psxcpu->cp0r) );
device->save_item( NAME(psxcpu->cp2cr) );
device->save_item( NAME(psxcpu->cp2dr) );
device->save_item( NAME(psxcpu->icacheTag) );
device->save_item( NAME(psxcpu->icache) );
device->save_item( NAME(psxcpu->dcache) );
device->save_item( NAME(psxcpu->multiplier_operation) );
device->save_item( NAME(psxcpu->multiplier_operand1) );
device->save_item( NAME(psxcpu->multiplier_operand2) );
device->machine->state().register_postload( mips_postload, psxcpu );
}

28
src/emu/cpu/mn10200/mn10200.c
View File

@ -278,20 +278,20 @@ static CPU_INIT(mn10200)
cpustate->program = device->space(AS_PROGRAM);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item_array(device, 0, cpustate->d);
state_save_register_device_item_array(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->nmicr);
state_save_register_device_item(device, 0, cpustate->iagr);
state_save_register_device_item_array(device, 0, cpustate->icrl);
state_save_register_device_item_array(device, 0, cpustate->icrh);
state_save_register_device_item(device, 0, cpustate->psw);
state_save_register_device_item(device, 0, cpustate->mdr);
// state_save_register_device_item_array(device, 0, cpustate->simple_timer);
// state_save_register_device_item_array(device, 0, cpustate->prescaler);
// state_save_register_device_item_array(device, 0, cpustate->dma);
// state_save_register_device_item_array(device, 0, cpustate->serial);
state_save_register_device_item_array(device, 0, cpustate->ddr);
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->d));
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->nmicr));
device->save_item(NAME(cpustate->iagr));
device->save_item(NAME(cpustate->icrl));
device->save_item(NAME(cpustate->icrh));
device->save_item(NAME(cpustate->psw));
device->save_item(NAME(cpustate->mdr));
// device->save_item(NAME(cpustate->simple_timer));
// device->save_item(NAME(cpustate->prescaler));
// device->save_item(NAME(cpustate->dma));
// device->save_item(NAME(cpustate->serial));
device->save_item(NAME(cpustate->ddr));
for (tmr = 0; tmr < NUM_TIMERS_8BIT; tmr++)
{

34
src/emu/cpu/nec/nec.c
View File

@ -338,24 +338,24 @@ static void nec_init(legacy_cpu_device *device, device_irq_callback irqcallback,
memset(nec_state, 0, sizeof(nec_state));
state_save_register_device_item_array(device, 0, nec_state->regs.w);
state_save_register_device_item_array(device, 0, nec_state->sregs);
device->save_item(NAME(nec_state->regs.w));
device->save_item(NAME(nec_state->sregs));
state_save_register_device_item(device, 0, nec_state->ip);
state_save_register_device_item(device, 0, nec_state->TF);
state_save_register_device_item(device, 0, nec_state->IF);
state_save_register_device_item(device, 0, nec_state->DF);
state_save_register_device_item(device, 0, nec_state->MF);
state_save_register_device_item(device, 0, nec_state->SignVal);
state_save_register_device_item(device, 0, nec_state->AuxVal);
state_save_register_device_item(device, 0, nec_state->OverVal);
state_save_register_device_item(device, 0, nec_state->ZeroVal);
state_save_register_device_item(device, 0, nec_state->CarryVal);
state_save_register_device_item(device, 0, nec_state->ParityVal);
state_save_register_device_item(device, 0, nec_state->pending_irq);
state_save_register_device_item(device, 0, nec_state->nmi_state);
state_save_register_device_item(device, 0, nec_state->irq_state);
state_save_register_device_item(device, 0, nec_state->poll_state);
device->save_item(NAME(nec_state->ip));
device->save_item(NAME(nec_state->TF));
device->save_item(NAME(nec_state->IF));
device->save_item(NAME(nec_state->DF));
device->save_item(NAME(nec_state->MF));
device->save_item(NAME(nec_state->SignVal));
device->save_item(NAME(nec_state->AuxVal));
device->save_item(NAME(nec_state->OverVal));
device->save_item(NAME(nec_state->ZeroVal));
device->save_item(NAME(nec_state->CarryVal));
device->save_item(NAME(nec_state->ParityVal));
device->save_item(NAME(nec_state->pending_irq));
device->save_item(NAME(nec_state->nmi_state));
device->save_item(NAME(nec_state->irq_state));
device->save_item(NAME(nec_state->poll_state));
nec_state->irq_callback = irqcallback;
nec_state->device = device;

84
src/emu/cpu/nec/v25.c
View File

@ -432,49 +432,49 @@ static void v25_init(legacy_cpu_device *device, device_irq_callback irqcallback,
for (int i = 0; i < 4; i++)
nec_state->timers[i] = device->machine->scheduler().timer_alloc(FUNC(v25_timer_callback), nec_state);
state_save_register_device_item_array(device, 0, nec_state->ram.w);
state_save_register_device_item_array(device, 0, nec_state->intp_state);
device->save_item(NAME(nec_state->ram.w));
device->save_item(NAME(nec_state->intp_state));
state_save_register_device_item(device, 0, nec_state->ip);
state_save_register_device_item(device, 0, nec_state->IBRK);
state_save_register_device_item(device, 0, nec_state->F0);
state_save_register_device_item(device, 0, nec_state->F1);
state_save_register_device_item(device, 0, nec_state->TF);
state_save_register_device_item(device, 0, nec_state->IF);
state_save_register_device_item(device, 0, nec_state->DF);
state_save_register_device_item(device, 0, nec_state->MF);
state_save_register_device_item(device, 0, nec_state->RBW);
state_save_register_device_item(device, 0, nec_state->RBB);
state_save_register_device_item(device, 0, nec_state->SignVal);
state_save_register_device_item(device, 0, nec_state->AuxVal);
state_save_register_device_item(device, 0, nec_state->OverVal);
state_save_register_device_item(device, 0, nec_state->ZeroVal);
state_save_register_device_item(device, 0, nec_state->CarryVal);
state_save_register_device_item(device, 0, nec_state->ParityVal);
state_save_register_device_item(device, 0, nec_state->pending_irq);
state_save_register_device_item(device, 0, nec_state->unmasked_irq);
state_save_register_device_item(device, 0, nec_state->bankswitch_irq);
state_save_register_device_item(device, 0, nec_state->priority_inttu);
state_save_register_device_item(device, 0, nec_state->priority_intd);
state_save_register_device_item(device, 0, nec_state->priority_intp);
state_save_register_device_item(device, 0, nec_state->priority_ints0);
state_save_register_device_item(device, 0, nec_state->priority_ints1);
state_save_register_device_item(device, 0, nec_state->IRQS);
state_save_register_device_item(device, 0, nec_state->ISPR);
state_save_register_device_item(device, 0, nec_state->nmi_state);
state_save_register_device_item(device, 0, nec_state->irq_state);
state_save_register_device_item(device, 0, nec_state->poll_state);
state_save_register_device_item(device, 0, nec_state->mode_state);
state_save_register_device_item(device, 0, nec_state->TM0);
state_save_register_device_item(device, 0, nec_state->MD0);
state_save_register_device_item(device, 0, nec_state->TM1);
state_save_register_device_item(device, 0, nec_state->MD1);
state_save_register_device_item(device, 0, nec_state->TMC0);
state_save_register_device_item(device, 0, nec_state->TMC1);
state_save_register_device_item(device, 0, nec_state->RAMEN);
state_save_register_device_item(device, 0, nec_state->TB);
state_save_register_device_item(device, 0, nec_state->PCK);
state_save_register_device_item(device, 0, nec_state->IDB);
device->save_item(NAME(nec_state->ip));
device->save_item(NAME(nec_state->IBRK));
device->save_item(NAME(nec_state->F0));
device->save_item(NAME(nec_state->F1));
device->save_item(NAME(nec_state->TF));
device->save_item(NAME(nec_state->IF));
device->save_item(NAME(nec_state->DF));
device->save_item(NAME(nec_state->MF));
device->save_item(NAME(nec_state->RBW));
device->save_item(NAME(nec_state->RBB));
device->save_item(NAME(nec_state->SignVal));
device->save_item(NAME(nec_state->AuxVal));
device->save_item(NAME(nec_state->OverVal));
device->save_item(NAME(nec_state->ZeroVal));
device->save_item(NAME(nec_state->CarryVal));
device->save_item(NAME(nec_state->ParityVal));
device->save_item(NAME(nec_state->pending_irq));
device->save_item(NAME(nec_state->unmasked_irq));
device->save_item(NAME(nec_state->bankswitch_irq));
device->save_item(NAME(nec_state->priority_inttu));
device->save_item(NAME(nec_state->priority_intd));
device->save_item(NAME(nec_state->priority_intp));
device->save_item(NAME(nec_state->priority_ints0));
device->save_item(NAME(nec_state->priority_ints1));
device->save_item(NAME(nec_state->IRQS));
device->save_item(NAME(nec_state->ISPR));
device->save_item(NAME(nec_state->nmi_state));
device->save_item(NAME(nec_state->irq_state));
device->save_item(NAME(nec_state->poll_state));
device->save_item(NAME(nec_state->mode_state));
device->save_item(NAME(nec_state->TM0));
device->save_item(NAME(nec_state->MD0));
device->save_item(NAME(nec_state->TM1));
device->save_item(NAME(nec_state->MD1));
device->save_item(NAME(nec_state->TMC0));
device->save_item(NAME(nec_state->TMC1));
device->save_item(NAME(nec_state->RAMEN));
device->save_item(NAME(nec_state->TB));
device->save_item(NAME(nec_state->PCK));
device->save_item(NAME(nec_state->IDB));
nec_state->irq_callback = irqcallback;
nec_state->device = device;

60
src/emu/cpu/pic16c5x/pic16c5x.c
View File

@ -737,37 +737,37 @@ static CPU_INIT( pic16c5x )
/* ensure the internal ram pointers are set before get_info is called */
update_internalram_ptr(cpustate);
state_save_register_device_item(device, 0, cpustate->W);
state_save_register_device_item(device, 0, cpustate->ALU);
state_save_register_device_item(device, 0, cpustate->OPTION);
state_save_register_device_item(device, 0, cpustate->TMR0);
state_save_register_device_item(device, 0, cpustate->PCL);
state_save_register_device_item(device, 0, cpustate->STATUS);
state_save_register_device_item(device, 0, cpustate->FSR);
state_save_register_device_item(device, 0, cpustate->PORTA);
state_save_register_device_item(device, 0, cpustate->PORTB);
state_save_register_device_item(device, 0, cpustate->PORTC);
state_save_register_device_item(device, 0, cpustate->TRISA);
state_save_register_device_item(device, 0, cpustate->TRISB);
state_save_register_device_item(device, 0, cpustate->TRISC);
state_save_register_device_item(device, 0, cpustate->old_T0);
state_save_register_device_item(device, 0, cpustate->old_data);
state_save_register_device_item(device, 0, cpustate->picRAMmask);
state_save_register_device_item(device, 0, cpustate->WDT);
state_save_register_device_item(device, 0, cpustate->prescaler);
state_save_register_device_item(device, 0, cpustate->STACK[0]);
state_save_register_device_item(device, 0, cpustate->STACK[1]);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->PREVPC);
state_save_register_device_item(device, 0, cpustate->CONFIG);
state_save_register_device_item(device, 0, cpustate->opcode.d);
state_save_register_device_item(device, 0, cpustate->delay_timer);
state_save_register_device_item(device, 0, cpustate->picmodel);
state_save_register_device_item(device, 0, cpustate->reset_vector);
device->save_item(NAME(cpustate->W));
device->save_item(NAME(cpustate->ALU));
device->save_item(NAME(cpustate->OPTION));
device->save_item(NAME(cpustate->TMR0));
device->save_item(NAME(cpustate->PCL));
device->save_item(NAME(cpustate->STATUS));
device->save_item(NAME(cpustate->FSR));
device->save_item(NAME(cpustate->PORTA));
device->save_item(NAME(cpustate->PORTB));
device->save_item(NAME(cpustate->PORTC));
device->save_item(NAME(cpustate->TRISA));
device->save_item(NAME(cpustate->TRISB));
device->save_item(NAME(cpustate->TRISC));
device->save_item(NAME(cpustate->old_T0));
device->save_item(NAME(cpustate->old_data));
device->save_item(NAME(cpustate->picRAMmask));
device->save_item(NAME(cpustate->WDT));
device->save_item(NAME(cpustate->prescaler));
device->save_item(NAME(cpustate->STACK[0]));
device->save_item(NAME(cpustate->STACK[1]));
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->PREVPC));
device->save_item(NAME(cpustate->CONFIG));
device->save_item(NAME(cpustate->opcode.d));
device->save_item(NAME(cpustate->delay_timer));
device->save_item(NAME(cpustate->picmodel));
device->save_item(NAME(cpustate->reset_vector));
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->temp_config);
state_save_register_device_item(device, 0, cpustate->inst_cycles);
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->temp_config));
device->save_item(NAME(cpustate->inst_cycles));
}

70
src/emu/cpu/pic16c62x/pic16c62x.c
View File

@ -849,42 +849,42 @@ static CPU_INIT( pic16c62x )
build_opcode_table();
state_save_register_device_item(device, 0, cpustate->W);
state_save_register_device_item(device, 0, cpustate->ALU);
state_save_register_device_item(device, 0, cpustate->OPTION);
state_save_register_device_item(device, 0, cpustate->PCLATH);
state_save_register_device_item(device, 0, cpustate->TMR0);
state_save_register_device_item(device, 0, cpustate->PCL);
state_save_register_device_item(device, 0, cpustate->STATUS);
state_save_register_device_item(device, 0, cpustate->FSR);
state_save_register_device_item(device, 0, cpustate->PORTA);
state_save_register_device_item(device, 0, cpustate->PORTB);
state_save_register_device_item(device, 0, cpustate->TRISA);
state_save_register_device_item(device, 0, cpustate->TRISB);
state_save_register_device_item(device, 0, cpustate->old_T0);
state_save_register_device_item(device, 0, cpustate->old_data);
state_save_register_device_item(device, 0, cpustate->picRAMmask);
state_save_register_device_item(device, 0, cpustate->WDT);
state_save_register_device_item(device, 0, cpustate->prescaler);
state_save_register_device_item(device, 0, cpustate->STACK[0]);
state_save_register_device_item(device, 0, cpustate->STACK[1]);
state_save_register_device_item(device, 0, cpustate->STACK[2]);
state_save_register_device_item(device, 0, cpustate->STACK[3]);
state_save_register_device_item(device, 0, cpustate->STACK[4]);
state_save_register_device_item(device, 0, cpustate->STACK[5]);
state_save_register_device_item(device, 0, cpustate->STACK[6]);
state_save_register_device_item(device, 0, cpustate->STACK[7]);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->PREVPC);
state_save_register_device_item(device, 0, cpustate->CONFIG);
state_save_register_device_item(device, 0, cpustate->opcode.d);
state_save_register_device_item(device, 0, cpustate->delay_timer);
state_save_register_device_item(device, 0, cpustate->picmodel);
state_save_register_device_item(device, 0, cpustate->reset_vector);
device->save_item(NAME(cpustate->W));
device->save_item(NAME(cpustate->ALU));
device->save_item(NAME(cpustate->OPTION));
device->save_item(NAME(cpustate->PCLATH));
device->save_item(NAME(cpustate->TMR0));
device->save_item(NAME(cpustate->PCL));
device->save_item(NAME(cpustate->STATUS));
device->save_item(NAME(cpustate->FSR));
device->save_item(NAME(cpustate->PORTA));
device->save_item(NAME(cpustate->PORTB));
device->save_item(NAME(cpustate->TRISA));
device->save_item(NAME(cpustate->TRISB));
device->save_item(NAME(cpustate->old_T0));
device->save_item(NAME(cpustate->old_data));
device->save_item(NAME(cpustate->picRAMmask));
device->save_item(NAME(cpustate->WDT));
device->save_item(NAME(cpustate->prescaler));
device->save_item(NAME(cpustate->STACK[0]));
device->save_item(NAME(cpustate->STACK[1]));
device->save_item(NAME(cpustate->STACK[2]));
device->save_item(NAME(cpustate->STACK[3]));
device->save_item(NAME(cpustate->STACK[4]));
device->save_item(NAME(cpustate->STACK[5]));
device->save_item(NAME(cpustate->STACK[6]));
device->save_item(NAME(cpustate->STACK[7]));
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->PREVPC));
device->save_item(NAME(cpustate->CONFIG));
device->save_item(NAME(cpustate->opcode.d));
device->save_item(NAME(cpustate->delay_timer));
device->save_item(NAME(cpustate->picmodel));
device->save_item(NAME(cpustate->reset_vector));
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->temp_config);
state_save_register_device_item(device, 0, cpustate->inst_cycles);
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->temp_config));
device->save_item(NAME(cpustate->inst_cycles));
}

48
src/emu/cpu/powerpc/ppccom.c
View File

@ -339,36 +339,36 @@ void ppccom_init(powerpc_state *ppc, powerpc_flavor flavor, UINT8 cap, int tb_di
}
/* register for save states */
state_save_register_device_item(device, 0, ppc->pc);
state_save_register_device_item_array(device, 0, ppc->r);
state_save_register_device_item_array(device, 0, ppc->f);
state_save_register_device_item_array(device, 0, ppc->cr);
state_save_register_device_item(device, 0, ppc->xerso);
state_save_register_device_item(device, 0, ppc->fpscr);
state_save_register_device_item(device, 0, ppc->msr);
state_save_register_device_item_array(device, 0, ppc->sr);
state_save_register_device_item_array(device, 0, ppc->spr);
state_save_register_device_item_array(device, 0, ppc->dcr);
device->save_item(NAME(ppc->pc));
device->save_item(NAME(ppc->r));
device->save_item(NAME(ppc->f));
device->save_item(NAME(ppc->cr));
device->save_item(NAME(ppc->xerso));
device->save_item(NAME(ppc->fpscr));
device->save_item(NAME(ppc->msr));
device->save_item(NAME(ppc->sr));
device->save_item(NAME(ppc->spr));
device->save_item(NAME(ppc->dcr));
if (cap & PPCCAP_4XX)
{
state_save_register_device_item_array(device, 0, ppc->spu.regs);
state_save_register_device_item(device, 0, ppc->spu.txbuf);
state_save_register_device_item(device, 0, ppc->spu.rxbuf);
state_save_register_device_item_array(device, 0, ppc->spu.rxbuffer);
state_save_register_device_item(device, 0, ppc->spu.rxin);
state_save_register_device_item(device, 0, ppc->spu.rxout);
state_save_register_device_item(device, 0, ppc->pit_reload);
state_save_register_device_item(device, 0, ppc->irqstate);
device->save_item(NAME(ppc->spu.regs));
device->save_item(NAME(ppc->spu.txbuf));
device->save_item(NAME(ppc->spu.rxbuf));
device->save_item(NAME(ppc->spu.rxbuffer));
device->save_item(NAME(ppc->spu.rxin));
device->save_item(NAME(ppc->spu.rxout));
device->save_item(NAME(ppc->pit_reload));
device->save_item(NAME(ppc->irqstate));
}
if (cap & PPCCAP_603_MMU)
{
state_save_register_device_item(device, 0, ppc->mmu603_cmp);
state_save_register_device_item_array(device, 0, ppc->mmu603_hash);
state_save_register_device_item_array(device, 0, ppc->mmu603_r);
device->save_item(NAME(ppc->mmu603_cmp));
device->save_item(NAME(ppc->mmu603_hash));
device->save_item(NAME(ppc->mmu603_r));
}
state_save_register_device_item(device, 0, ppc->irq_pending);
state_save_register_device_item(device, 0, ppc->tb_zero_cycles);
state_save_register_device_item(device, 0, ppc->dec_zero_cycles);
device->save_item(NAME(ppc->irq_pending));
device->save_item(NAME(ppc->tb_zero_cycles));
device->save_item(NAME(ppc->dec_zero_cycles));
}

18
src/emu/cpu/pps4/pps4.c
View File

@ -343,15 +343,15 @@ static CPU_INIT( pps4 )
cpustate->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->X);
state_save_register_device_item(device, 0, cpustate->P);
state_save_register_device_item(device, 0, cpustate->SA);
state_save_register_device_item(device, 0, cpustate->SB);
state_save_register_device_item(device, 0, cpustate->B);
state_save_register_device_item(device, 0, cpustate->C);
state_save_register_device_item(device, 0, cpustate->FF1);
state_save_register_device_item(device, 0, cpustate->FF2);
device->save_item(NAME(cpustate->A));
device->save_item(NAME(cpustate->X));
device->save_item(NAME(cpustate->P));
device->save_item(NAME(cpustate->SA));
device->save_item(NAME(cpustate->SB));
device->save_item(NAME(cpustate->B));
device->save_item(NAME(cpustate->C));
device->save_item(NAME(cpustate->FF1));
device->save_item(NAME(cpustate->FF2));
}
/***************************************************************************

24
src/emu/cpu/s2650/s2650.c
View File

@ -800,18 +800,18 @@ static CPU_INIT( s2650 )
s2650c->direct = &s2650c->program->direct();
s2650c->io = device->space(AS_IO);
state_save_register_device_item(device, 0, s2650c->ppc);
state_save_register_device_item(device, 0, s2650c->page);
state_save_register_device_item(device, 0, s2650c->iar);
state_save_register_device_item(device, 0, s2650c->ea);
state_save_register_device_item(device, 0, s2650c->psl);
state_save_register_device_item(device, 0, s2650c->psu);
state_save_register_device_item(device, 0, s2650c->r);
state_save_register_device_item_array(device, 0, s2650c->reg);
state_save_register_device_item(device, 0, s2650c->halt);
state_save_register_device_item(device, 0, s2650c->ir);
state_save_register_device_item_array(device, 0, s2650c->ras);
state_save_register_device_item(device, 0, s2650c->irq_state);
device->save_item(NAME(s2650c->ppc));
device->save_item(NAME(s2650c->page));
device->save_item(NAME(s2650c->iar));
device->save_item(NAME(s2650c->ea));
device->save_item(NAME(s2650c->psl));
device->save_item(NAME(s2650c->psu));
device->save_item(NAME(s2650c->r));
device->save_item(NAME(s2650c->reg));
device->save_item(NAME(s2650c->halt));
device->save_item(NAME(s2650c->ir));
device->save_item(NAME(s2650c->ras));
device->save_item(NAME(s2650c->irq_state));
}
static CPU_RESET( s2650 )

46
src/emu/cpu/saturn/saturn.c
View File

@ -118,29 +118,29 @@ static CPU_INIT( saturn )
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
state_save_register_device_item_array(device, 0,cpustate->reg[R0]);
state_save_register_device_item_array(device, 0,cpustate->reg[R1]);
state_save_register_device_item_array(device, 0,cpustate->reg[R2]);
state_save_register_device_item_array(device, 0,cpustate->reg[R3]);
state_save_register_device_item_array(device, 0,cpustate->reg[R4]);
state_save_register_device_item_array(device, 0,cpustate->reg[A]);
state_save_register_device_item_array(device, 0,cpustate->reg[B]);
state_save_register_device_item_array(device, 0,cpustate->reg[C]);
state_save_register_device_item_array(device, 0,cpustate->reg[D]);
state_save_register_device_item_array(device, 0,cpustate->d);
state_save_register_device_item(device, 0,cpustate->pc);
state_save_register_device_item(device, 0,cpustate->oldpc);
state_save_register_device_item_array(device, 0,cpustate->rstk);
state_save_register_device_item(device, 0,cpustate->out);
state_save_register_device_item(device, 0,cpustate->carry);
state_save_register_device_item(device, 0,cpustate->st);
state_save_register_device_item(device, 0,cpustate->hst);
state_save_register_device_item(device, 0,cpustate->nmi_state);
state_save_register_device_item(device, 0,cpustate->irq_state);
state_save_register_device_item(device, 0,cpustate->irq_enable);
state_save_register_device_item(device, 0,cpustate->in_irq);
state_save_register_device_item(device, 0,cpustate->pending_irq);
state_save_register_device_item(device, 0,cpustate->sleeping);
device->save_item(NAME(cpustate->reg[R0]));
device->save_item(NAME(cpustate->reg[R1]));
device->save_item(NAME(cpustate->reg[R2]));
device->save_item(NAME(cpustate->reg[R3]));
device->save_item(NAME(cpustate->reg[R4]));
device->save_item(NAME(cpustate->reg[A]));
device->save_item(NAME(cpustate->reg[B]));
device->save_item(NAME(cpustate->reg[C]));
device->save_item(NAME(cpustate->reg[D]));
device->save_item(NAME(cpustate->d));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->oldpc));
device->save_item(NAME(cpustate->rstk));
device->save_item(NAME(cpustate->out));
device->save_item(NAME(cpustate->carry));
device->save_item(NAME(cpustate->st));
device->save_item(NAME(cpustate->hst));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->irq_enable));
device->save_item(NAME(cpustate->in_irq));
device->save_item(NAME(cpustate->pending_irq));
device->save_item(NAME(cpustate->sleeping));
}
static CPU_RESET( saturn )

14
src/emu/cpu/scmp/scmp.c
View File

@ -525,13 +525,13 @@ static CPU_INIT( scmp )
devcb_resolve_read_line(&cpustate->senseb_func, &cpustate->config.senseb_func, device);
devcb_resolve_write_line(&cpustate->halt_func, &cpustate->config.halt_func, device);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->P1);
state_save_register_device_item(device, 0, cpustate->P2);
state_save_register_device_item(device, 0, cpustate->P3);
state_save_register_device_item(device, 0, cpustate->AC);
state_save_register_device_item(device, 0, cpustate->ER);
state_save_register_device_item(device, 0, cpustate->SR);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->P1));
device->save_item(NAME(cpustate->P2));
device->save_item(NAME(cpustate->P3));
device->save_item(NAME(cpustate->AC));
device->save_item(NAME(cpustate->ER));
device->save_item(NAME(cpustate->SR));
}

78
src/emu/cpu/sh2/sh2comn.c
View File

@ -954,47 +954,47 @@ void sh2_common_init(sh2_state *sh2, legacy_cpu_device *device, device_irq_callb
sh2->direct = &sh2->program->direct();
sh2->internal = device->space(AS_PROGRAM);
state_save_register_device_item(device, 0, sh2->pc);
state_save_register_device_item(device, 0, sh2->sr);
state_save_register_device_item(device, 0, sh2->pr);
state_save_register_device_item(device, 0, sh2->gbr);
state_save_register_device_item(device, 0, sh2->vbr);
state_save_register_device_item(device, 0, sh2->mach);
state_save_register_device_item(device, 0, sh2->macl);
state_save_register_device_item_array(device, 0, sh2->r);
state_save_register_device_item(device, 0, sh2->ea);
state_save_register_device_item(device, 0, sh2->delay);
state_save_register_device_item(device, 0, sh2->cpu_off);
state_save_register_device_item(device, 0, sh2->dvsr);
state_save_register_device_item(device, 0, sh2->dvdnth);
state_save_register_device_item(device, 0, sh2->dvdntl);
state_save_register_device_item(device, 0, sh2->dvcr);
state_save_register_device_item(device, 0, sh2->pending_irq);
state_save_register_device_item(device, 0, sh2->test_irq);
state_save_register_device_item(device, 0, sh2->pending_nmi);
state_save_register_device_item(device, 0, sh2->irqline);
state_save_register_device_item(device, 0, sh2->evec);
state_save_register_device_item(device, 0, sh2->irqsr);
state_save_register_device_item(device, 0, sh2->target);
device->save_item(NAME(sh2->pc));
device->save_item(NAME(sh2->sr));
device->save_item(NAME(sh2->pr));
device->save_item(NAME(sh2->gbr));
device->save_item(NAME(sh2->vbr));
device->save_item(NAME(sh2->mach));
device->save_item(NAME(sh2->macl));
device->save_item(NAME(sh2->r));
device->save_item(NAME(sh2->ea));
device->save_item(NAME(sh2->delay));
device->save_item(NAME(sh2->cpu_off));
device->save_item(NAME(sh2->dvsr));
device->save_item(NAME(sh2->dvdnth));
device->save_item(NAME(sh2->dvdntl));
device->save_item(NAME(sh2->dvcr));
device->save_item(NAME(sh2->pending_irq));
device->save_item(NAME(sh2->test_irq));
device->save_item(NAME(sh2->pending_nmi));
device->save_item(NAME(sh2->irqline));
device->save_item(NAME(sh2->evec));
device->save_item(NAME(sh2->irqsr));
device->save_item(NAME(sh2->target));
for (i = 0; i < 16; ++i)
{
state_save_register_device_item(device, i, sh2->irq_queue[i].irq_vector);
state_save_register_device_item(device, i, sh2->irq_queue[i].irq_priority);
device->save_item(NAME(sh2->irq_queue[i].irq_vector), i);
device->save_item(NAME(sh2->irq_queue[i].irq_priority), i);
}
state_save_register_device_item(device, 0, sh2->pcfsel);
state_save_register_device_item(device, 0, sh2->maxpcfsel);
state_save_register_device_item_array(device, 0, sh2->pcflushes);
state_save_register_device_item_array(device, 0, sh2->irq_line_state);
state_save_register_device_item_pointer(device, 0, sh2->m, 0x200/4);
state_save_register_device_item(device, 0, sh2->nmi_line_state);
state_save_register_device_item(device, 0, sh2->frc);
state_save_register_device_item(device, 0, sh2->ocra);
state_save_register_device_item(device, 0, sh2->ocrb);
state_save_register_device_item(device, 0, sh2->icr);
state_save_register_device_item(device, 0, sh2->frc_base);
state_save_register_device_item(device, 0, sh2->frt_input);
state_save_register_device_item(device, 0, sh2->internal_irq_level);
state_save_register_device_item(device, 0, sh2->internal_irq_vector);
state_save_register_device_item_array(device, 0, sh2->dma_timer_active);
device->save_item(NAME(sh2->pcfsel));
device->save_item(NAME(sh2->maxpcfsel));
device->save_item(NAME(sh2->pcflushes));
device->save_item(NAME(sh2->irq_line_state));
device->save_pointer(NAME(sh2->m), 0x200/4);
device->save_item(NAME(sh2->nmi_line_state));
device->save_item(NAME(sh2->frc));
device->save_item(NAME(sh2->ocra));
device->save_item(NAME(sh2->ocrb));
device->save_item(NAME(sh2->icr));
device->save_item(NAME(sh2->frc_base));
device->save_item(NAME(sh2->frt_input));
device->save_item(NAME(sh2->internal_irq_level));
device->save_item(NAME(sh2->internal_irq_vector));
device->save_item(NAME(sh2->dma_timer_active));
}

128
src/emu/cpu/sh4/sh4.c
View File

@ -3393,70 +3393,70 @@ static CPU_INIT( sh4 )
sh4->irln = 15;
sh4->test_irq = 0;
state_save_register_device_item(device, 0, sh4->pc);
state_save_register_device_item(device, 0, sh4->r[15]);
state_save_register_device_item(device, 0, sh4->sr);
state_save_register_device_item(device, 0, sh4->pr);
state_save_register_device_item(device, 0, sh4->gbr);
state_save_register_device_item(device, 0, sh4->vbr);
state_save_register_device_item(device, 0, sh4->mach);
state_save_register_device_item(device, 0, sh4->macl);
state_save_register_device_item(device, 0, sh4->spc);
state_save_register_device_item(device, 0, sh4->ssr);
state_save_register_device_item(device, 0, sh4->sgr);
state_save_register_device_item(device, 0, sh4->fpscr);
state_save_register_device_item(device, 0, sh4->r[ 0]);
state_save_register_device_item(device, 0, sh4->r[ 1]);
state_save_register_device_item(device, 0, sh4->r[ 2]);
state_save_register_device_item(device, 0, sh4->r[ 3]);
state_save_register_device_item(device, 0, sh4->r[ 4]);
state_save_register_device_item(device, 0, sh4->r[ 5]);
state_save_register_device_item(device, 0, sh4->r[ 6]);
state_save_register_device_item(device, 0, sh4->r[ 7]);
state_save_register_device_item(device, 0, sh4->r[ 8]);
state_save_register_device_item(device, 0, sh4->r[ 9]);
state_save_register_device_item(device, 0, sh4->r[10]);
state_save_register_device_item(device, 0, sh4->r[11]);
state_save_register_device_item(device, 0, sh4->r[12]);
state_save_register_device_item(device, 0, sh4->r[13]);
state_save_register_device_item(device, 0, sh4->r[14]);
state_save_register_device_item(device, 0, sh4->fr[ 0]);
state_save_register_device_item(device, 0, sh4->fr[ 1]);
state_save_register_device_item(device, 0, sh4->fr[ 2]);
state_save_register_device_item(device, 0, sh4->fr[ 3]);
state_save_register_device_item(device, 0, sh4->fr[ 4]);
state_save_register_device_item(device, 0, sh4->fr[ 5]);
state_save_register_device_item(device, 0, sh4->fr[ 6]);
state_save_register_device_item(device, 0, sh4->fr[ 7]);
state_save_register_device_item(device, 0, sh4->fr[ 8]);
state_save_register_device_item(device, 0, sh4->fr[ 9]);
state_save_register_device_item(device, 0, sh4->fr[10]);
state_save_register_device_item(device, 0, sh4->fr[11]);
state_save_register_device_item(device, 0, sh4->fr[12]);
state_save_register_device_item(device, 0, sh4->fr[13]);
state_save_register_device_item(device, 0, sh4->fr[14]);
state_save_register_device_item(device, 0, sh4->fr[15]);
state_save_register_device_item(device, 0, sh4->xf[ 0]);
state_save_register_device_item(device, 0, sh4->xf[ 1]);
state_save_register_device_item(device, 0, sh4->xf[ 2]);
state_save_register_device_item(device, 0, sh4->xf[ 3]);
state_save_register_device_item(device, 0, sh4->xf[ 4]);
state_save_register_device_item(device, 0, sh4->xf[ 5]);
state_save_register_device_item(device, 0, sh4->xf[ 6]);
state_save_register_device_item(device, 0, sh4->xf[ 7]);
state_save_register_device_item(device, 0, sh4->xf[ 8]);
state_save_register_device_item(device, 0, sh4->xf[ 9]);
state_save_register_device_item(device, 0, sh4->xf[10]);
state_save_register_device_item(device, 0, sh4->xf[11]);
state_save_register_device_item(device, 0, sh4->xf[12]);
state_save_register_device_item(device, 0, sh4->xf[13]);
state_save_register_device_item(device, 0, sh4->xf[14]);
state_save_register_device_item(device, 0, sh4->xf[15]);
state_save_register_device_item(device, 0, sh4->ea);
state_save_register_device_item(device, 0, sh4->fpul);
state_save_register_device_item(device, 0, sh4->dbr);
state_save_register_device_item_array(device, 0, sh4->exception_priority);
state_save_register_device_item_array(device, 0, sh4->exception_requesting);
device->save_item(NAME(sh4->pc));
device->save_item(NAME(sh4->r[15]));
device->save_item(NAME(sh4->sr));
device->save_item(NAME(sh4->pr));
device->save_item(NAME(sh4->gbr));
device->save_item(NAME(sh4->vbr));
device->save_item(NAME(sh4->mach));
device->save_item(NAME(sh4->macl));
device->save_item(NAME(sh4->spc));
device->save_item(NAME(sh4->ssr));
device->save_item(NAME(sh4->sgr));
device->save_item(NAME(sh4->fpscr));
device->save_item(NAME(sh4->r[ 0]));
device->save_item(NAME(sh4->r[ 1]));
device->save_item(NAME(sh4->r[ 2]));
device->save_item(NAME(sh4->r[ 3]));
device->save_item(NAME(sh4->r[ 4]));
device->save_item(NAME(sh4->r[ 5]));
device->save_item(NAME(sh4->r[ 6]));
device->save_item(NAME(sh4->r[ 7]));
device->save_item(NAME(sh4->r[ 8]));
device->save_item(NAME(sh4->r[ 9]));
device->save_item(NAME(sh4->r[10]));
device->save_item(NAME(sh4->r[11]));
device->save_item(NAME(sh4->r[12]));
device->save_item(NAME(sh4->r[13]));
device->save_item(NAME(sh4->r[14]));
device->save_item(NAME(sh4->fr[ 0]));
device->save_item(NAME(sh4->fr[ 1]));
device->save_item(NAME(sh4->fr[ 2]));
device->save_item(NAME(sh4->fr[ 3]));
device->save_item(NAME(sh4->fr[ 4]));
device->save_item(NAME(sh4->fr[ 5]));
device->save_item(NAME(sh4->fr[ 6]));
device->save_item(NAME(sh4->fr[ 7]));
device->save_item(NAME(sh4->fr[ 8]));
device->save_item(NAME(sh4->fr[ 9]));
device->save_item(NAME(sh4->fr[10]));
device->save_item(NAME(sh4->fr[11]));
device->save_item(NAME(sh4->fr[12]));
device->save_item(NAME(sh4->fr[13]));
device->save_item(NAME(sh4->fr[14]));
device->save_item(NAME(sh4->fr[15]));
device->save_item(NAME(sh4->xf[ 0]));
device->save_item(NAME(sh4->xf[ 1]));
device->save_item(NAME(sh4->xf[ 2]));
device->save_item(NAME(sh4->xf[ 3]));
device->save_item(NAME(sh4->xf[ 4]));
device->save_item(NAME(sh4->xf[ 5]));
device->save_item(NAME(sh4->xf[ 6]));
device->save_item(NAME(sh4->xf[ 7]));
device->save_item(NAME(sh4->xf[ 8]));
device->save_item(NAME(sh4->xf[ 9]));
device->save_item(NAME(sh4->xf[10]));
device->save_item(NAME(sh4->xf[11]));
device->save_item(NAME(sh4->xf[12]));
device->save_item(NAME(sh4->xf[13]));
device->save_item(NAME(sh4->xf[14]));
device->save_item(NAME(sh4->xf[15]));
device->save_item(NAME(sh4->ea));
device->save_item(NAME(sh4->fpul));
device->save_item(NAME(sh4->dbr));
device->save_item(NAME(sh4->exception_priority));
device->save_item(NAME(sh4->exception_requesting));
}

178
src/emu/cpu/sharc/sharc.c
View File

@ -434,120 +434,120 @@ static CPU_INIT( sharc )
cpustate->internal_ram_block0 = &cpustate->internal_ram[0];
cpustate->internal_ram_block1 = &cpustate->internal_ram[0x20000/2];
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item_pointer(device, 0, (&cpustate->r[0].r), ARRAY_LENGTH(cpustate->r));
state_save_register_device_item_pointer(device, 0, (&cpustate->reg_alt[0].r), ARRAY_LENGTH(cpustate->reg_alt));
state_save_register_device_item(device, 0, cpustate->mrf);
state_save_register_device_item(device, 0, cpustate->mrb);
device->save_item(NAME(cpustate->pc));
device->save_pointer(NAME(&cpustate->r[0].r), ARRAY_LENGTH(cpustate->r));
device->save_pointer(NAME(&cpustate->reg_alt[0].r), ARRAY_LENGTH(cpustate->reg_alt));
device->save_item(NAME(cpustate->mrf));
device->save_item(NAME(cpustate->mrb));
state_save_register_device_item_array(device, 0, cpustate->pcstack);
state_save_register_device_item_array(device, 0, cpustate->lcstack);
state_save_register_device_item_array(device, 0, cpustate->lastack);
state_save_register_device_item(device, 0, cpustate->lstkp);
device->save_item(NAME(cpustate->pcstack));
device->save_item(NAME(cpustate->lcstack));
device->save_item(NAME(cpustate->lastack));
device->save_item(NAME(cpustate->lstkp));
state_save_register_device_item(device, 0, cpustate->faddr);
state_save_register_device_item(device, 0, cpustate->daddr);
state_save_register_device_item(device, 0, cpustate->pcstk);
state_save_register_device_item(device, 0, cpustate->pcstkp);
state_save_register_device_item(device, 0, cpustate->laddr);
state_save_register_device_item(device, 0, cpustate->curlcntr);
state_save_register_device_item(device, 0, cpustate->lcntr);
device->save_item(NAME(cpustate->faddr));
device->save_item(NAME(cpustate->daddr));
device->save_item(NAME(cpustate->pcstk));
device->save_item(NAME(cpustate->pcstkp));
device->save_item(NAME(cpustate->laddr));
device->save_item(NAME(cpustate->curlcntr));
device->save_item(NAME(cpustate->lcntr));
state_save_register_device_item_array(device, 0, cpustate->dag1.i);
state_save_register_device_item_array(device, 0, cpustate->dag1.m);
state_save_register_device_item_array(device, 0, cpustate->dag1.b);
state_save_register_device_item_array(device, 0, cpustate->dag1.l);
state_save_register_device_item_array(device, 0, cpustate->dag2.i);
state_save_register_device_item_array(device, 0, cpustate->dag2.m);
state_save_register_device_item_array(device, 0, cpustate->dag2.b);
state_save_register_device_item_array(device, 0, cpustate->dag2.l);
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.i);
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.m);
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.b);
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.l);
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.i);
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.m);
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.b);
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.l);
device->save_item(NAME(cpustate->dag1.i));
device->save_item(NAME(cpustate->dag1.m));
device->save_item(NAME(cpustate->dag1.b));
device->save_item(NAME(cpustate->dag1.l));
device->save_item(NAME(cpustate->dag2.i));
device->save_item(NAME(cpustate->dag2.m));
device->save_item(NAME(cpustate->dag2.b));
device->save_item(NAME(cpustate->dag2.l));
device->save_item(NAME(cpustate->dag1_alt.i));
device->save_item(NAME(cpustate->dag1_alt.m));
device->save_item(NAME(cpustate->dag1_alt.b));
device->save_item(NAME(cpustate->dag1_alt.l));
device->save_item(NAME(cpustate->dag2_alt.i));
device->save_item(NAME(cpustate->dag2_alt.m));
device->save_item(NAME(cpustate->dag2_alt.b));
device->save_item(NAME(cpustate->dag2_alt.l));
for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->dma); saveindex++)
{
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].control);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_index);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_modifier);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_count);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].chain_ptr);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].gen_purpose);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_index);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_modifier);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_count);
device->save_item(NAME(cpustate->dma[saveindex].control), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].int_index), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].int_modifier), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].int_count), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].chain_ptr), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].gen_purpose), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].ext_index), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].ext_modifier), saveindex);
device->save_item(NAME(cpustate->dma[saveindex].ext_count), saveindex);
}
state_save_register_device_item(device, 0, cpustate->mode1);
state_save_register_device_item(device, 0, cpustate->mode2);
state_save_register_device_item(device, 0, cpustate->astat);
state_save_register_device_item(device, 0, cpustate->stky);
state_save_register_device_item(device, 0, cpustate->irptl);
state_save_register_device_item(device, 0, cpustate->imask);
state_save_register_device_item(device, 0, cpustate->imaskp);
state_save_register_device_item(device, 0, cpustate->ustat1);
state_save_register_device_item(device, 0, cpustate->ustat2);
device->save_item(NAME(cpustate->mode1));
device->save_item(NAME(cpustate->mode2));
device->save_item(NAME(cpustate->astat));
device->save_item(NAME(cpustate->stky));
device->save_item(NAME(cpustate->irptl));
device->save_item(NAME(cpustate->imask));
device->save_item(NAME(cpustate->imaskp));
device->save_item(NAME(cpustate->ustat1));
device->save_item(NAME(cpustate->ustat2));
state_save_register_device_item_array(device, 0, cpustate->flag);
device->save_item(NAME(cpustate->flag));
state_save_register_device_item(device, 0, cpustate->syscon);
state_save_register_device_item(device, 0, cpustate->sysstat);
device->save_item(NAME(cpustate->syscon));
device->save_item(NAME(cpustate->sysstat));
for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->status_stack); saveindex++)
{
state_save_register_device_item(device, saveindex, cpustate->status_stack[saveindex].mode1);
state_save_register_device_item(device, saveindex, cpustate->status_stack[saveindex].astat);
device->save_item(NAME(cpustate->status_stack[saveindex].mode1), saveindex);
device->save_item(NAME(cpustate->status_stack[saveindex].astat), saveindex);
}
state_save_register_device_item(device, 0, cpustate->status_stkp);
device->save_item(NAME(cpustate->status_stkp));
state_save_register_device_item(device, 0, cpustate->px);
device->save_item(NAME(cpustate->px));
state_save_register_device_item_pointer(device, 0, cpustate->internal_ram, 2 * 0x10000);
device->save_pointer(NAME(cpustate->internal_ram), 2 * 0x10000);
state_save_register_device_item(device, 0, cpustate->opcode);
state_save_register_device_item(device, 0, cpustate->fetch_opcode);
state_save_register_device_item(device, 0, cpustate->decode_opcode);
device->save_item(NAME(cpustate->opcode));
device->save_item(NAME(cpustate->fetch_opcode));
device->save_item(NAME(cpustate->decode_opcode));
state_save_register_device_item(device, 0, cpustate->nfaddr);
device->save_item(NAME(cpustate->nfaddr));
state_save_register_device_item(device, 0, cpustate->idle);
state_save_register_device_item(device, 0, cpustate->irq_active);
state_save_register_device_item(device, 0, cpustate->active_irq_num);
device->save_item(NAME(cpustate->idle));
device->save_item(NAME(cpustate->irq_active));
device->save_item(NAME(cpustate->active_irq_num));
state_save_register_device_item(device, 0, cpustate->dmaop_src);
state_save_register_device_item(device, 0, cpustate->dmaop_dst);
state_save_register_device_item(device, 0, cpustate->dmaop_chain_ptr);
state_save_register_device_item(device, 0, cpustate->dmaop_src_modifier);
state_save_register_device_item(device, 0, cpustate->dmaop_dst_modifier);
state_save_register_device_item(device, 0, cpustate->dmaop_src_count);
state_save_register_device_item(device, 0, cpustate->dmaop_dst_count);
state_save_register_device_item(device, 0, cpustate->dmaop_pmode);
state_save_register_device_item(device, 0, cpustate->dmaop_cycles);
state_save_register_device_item(device, 0, cpustate->dmaop_channel);
state_save_register_device_item(device, 0, cpustate->dmaop_chained_direction);
device->save_item(NAME(cpustate->dmaop_src));
device->save_item(NAME(cpustate->dmaop_dst));
device->save_item(NAME(cpustate->dmaop_chain_ptr));
device->save_item(NAME(cpustate->dmaop_src_modifier));
device->save_item(NAME(cpustate->dmaop_dst_modifier));
device->save_item(NAME(cpustate->dmaop_src_count));
device->save_item(NAME(cpustate->dmaop_dst_count));
device->save_item(NAME(cpustate->dmaop_pmode));
device->save_item(NAME(cpustate->dmaop_cycles));
device->save_item(NAME(cpustate->dmaop_channel));
device->save_item(NAME(cpustate->dmaop_chained_direction));
state_save_register_device_item(device, 0, cpustate->interrupt_active);
device->save_item(NAME(cpustate->interrupt_active));
state_save_register_device_item(device, 0, cpustate->iop_latency_cycles);
state_save_register_device_item(device, 0, cpustate->iop_latency_reg);
state_save_register_device_item(device, 0, cpustate->iop_latency_data);
device->save_item(NAME(cpustate->iop_latency_cycles));
device->save_item(NAME(cpustate->iop_latency_reg));
device->save_item(NAME(cpustate->iop_latency_data));
state_save_register_device_item(device, 0, cpustate->delay_slot1);
state_save_register_device_item(device, 0, cpustate->delay_slot2);
device->save_item(NAME(cpustate->delay_slot1));
device->save_item(NAME(cpustate->delay_slot2));
state_save_register_device_item(device, 0, cpustate->systemreg_latency_cycles);
state_save_register_device_item(device, 0, cpustate->systemreg_latency_reg);
state_save_register_device_item(device, 0, cpustate->systemreg_latency_data);
state_save_register_device_item(device, 0, cpustate->systemreg_previous_data);
device->save_item(NAME(cpustate->systemreg_latency_cycles));
device->save_item(NAME(cpustate->systemreg_latency_reg));
device->save_item(NAME(cpustate->systemreg_latency_data));
device->save_item(NAME(cpustate->systemreg_previous_data));
state_save_register_device_item(device, 0, cpustate->astat_old);
state_save_register_device_item(device, 0, cpustate->astat_old_old);
state_save_register_device_item(device, 0, cpustate->astat_old_old_old);
device->save_item(NAME(cpustate->astat_old));
device->save_item(NAME(cpustate->astat_old_old));
device->save_item(NAME(cpustate->astat_old_old_old));
}
static CPU_RESET( sharc )

54
src/emu/cpu/spc700/spc700.c
View File

@ -1249,33 +1249,33 @@ static void state_register( legacy_cpu_device *device )
{
spc700i_cpu *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->s);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->flag_n);
state_save_register_device_item(device, 0, cpustate->flag_z);
state_save_register_device_item(device, 0, cpustate->flag_v);
state_save_register_device_item(device, 0, cpustate->flag_p);
state_save_register_device_item(device, 0, cpustate->flag_b);
state_save_register_device_item(device, 0, cpustate->flag_h);
state_save_register_device_item(device, 0, cpustate->flag_i);
state_save_register_device_item(device, 0, cpustate->flag_c);
state_save_register_device_item(device, 0, cpustate->line_irq);
state_save_register_device_item(device, 0, cpustate->line_nmi);
state_save_register_device_item(device, 0, cpustate->line_rst);
state_save_register_device_item(device, 0, cpustate->ir);
state_save_register_device_item(device, 0, cpustate->stopped);
state_save_register_device_item(device, 0, cpustate->ICount);
state_save_register_device_item(device, 0, cpustate->source);
state_save_register_device_item(device, 0, cpustate->destination);
state_save_register_device_item(device, 0, cpustate->temp1);
state_save_register_device_item(device, 0, cpustate->temp2);
state_save_register_device_item(device, 0, cpustate->temp3);
state_save_register_device_item(device, 0, cpustate->spc_int16);
state_save_register_device_item(device, 0, cpustate->spc_int32);
device->save_item(NAME(cpustate->a));
device->save_item(NAME(cpustate->x));
device->save_item(NAME(cpustate->y));
device->save_item(NAME(cpustate->s));
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->ppc));
device->save_item(NAME(cpustate->flag_n));
device->save_item(NAME(cpustate->flag_z));
device->save_item(NAME(cpustate->flag_v));
device->save_item(NAME(cpustate->flag_p));
device->save_item(NAME(cpustate->flag_b));
device->save_item(NAME(cpustate->flag_h));
device->save_item(NAME(cpustate->flag_i));
device->save_item(NAME(cpustate->flag_c));
device->save_item(NAME(cpustate->line_irq));
device->save_item(NAME(cpustate->line_nmi));
device->save_item(NAME(cpustate->line_rst));
device->save_item(NAME(cpustate->ir));
device->save_item(NAME(cpustate->stopped));
device->save_item(NAME(cpustate->ICount));
device->save_item(NAME(cpustate->source));
device->save_item(NAME(cpustate->destination));
device->save_item(NAME(cpustate->temp1));
device->save_item(NAME(cpustate->temp2));
device->save_item(NAME(cpustate->temp3));
device->save_item(NAME(cpustate->spc_int16));
device->save_item(NAME(cpustate->spc_int32));
}
static CPU_INIT( spc700 )

22
src/emu/cpu/ssp1601/ssp1601.c
View File

@ -513,17 +513,17 @@ static CPU_INIT( ssp1601 )
{
ssp1601_state_t *ssp1601_state = get_safe_token(device);
state_save_register_device_item(device, 0, rX);
state_save_register_device_item(device, 0, rY);
state_save_register_device_item(device, 0, rA32);
state_save_register_device_item(device, 0, rST);
state_save_register_device_item(device, 0, rSTACK);
state_save_register_device_item(device, 0, rPC);
state_save_register_device_item(device, 0, rP.d);
state_save_register_device_item(device, 0, PPC);
state_save_register_device_item_array(device, 0, ssp1601_state->stack);
state_save_register_device_item_array(device, 0, ssp1601_state->r);
state_save_register_device_item_array(device, 0, ssp1601_state->RAM);
device->save_item(NAME(rX));
device->save_item(NAME(rY));
device->save_item(NAME(rA32));
device->save_item(NAME(rST));
device->save_item(NAME(rSTACK));
device->save_item(NAME(rPC));
device->save_item(NAME(rP.d));
device->save_item(NAME(PPC));
device->save_item(NAME(ssp1601_state->stack));
device->save_item(NAME(ssp1601_state->r));
device->save_item(NAME(ssp1601_state->RAM));
/* clear the state */
memset(ssp1601_state, 0, sizeof(ssp1601_state_t));

66
src/emu/cpu/superfx/superfx.c
View File

@ -673,51 +673,51 @@ static void superfx_register_save( legacy_cpu_device *device )
superfx_state *cpustate = get_safe_token(device);
int i;
state_save_register_device_item(device, 0, cpustate->pipeline);
state_save_register_device_item(device, 0, cpustate->ramaddr);
device->save_item(NAME(cpustate->pipeline));
device->save_item(NAME(cpustate->ramaddr));
state_save_register_device_item_array(device, 0, cpustate->r);
state_save_register_device_item(device, 0, cpustate->sfr);
state_save_register_device_item(device, 0, cpustate->pbr);
state_save_register_device_item(device, 0, cpustate->rombr);
state_save_register_device_item(device, 0, cpustate->rambr);
state_save_register_device_item(device, 0, cpustate->cbr);
state_save_register_device_item(device, 0, cpustate->scbr);
state_save_register_device_item(device, 0, cpustate->scmr);
state_save_register_device_item(device, 0, cpustate->colr);
state_save_register_device_item(device, 0, cpustate->por);
state_save_register_device_item(device, 0, cpustate->bramr);
state_save_register_device_item(device, 0, cpustate->vcr);
state_save_register_device_item(device, 0, cpustate->cfgr);
state_save_register_device_item(device, 0, cpustate->clsr);
device->save_item(NAME(cpustate->r));
device->save_item(NAME(cpustate->sfr));
device->save_item(NAME(cpustate->pbr));
device->save_item(NAME(cpustate->rombr));
device->save_item(NAME(cpustate->rambr));
device->save_item(NAME(cpustate->cbr));
device->save_item(NAME(cpustate->scbr));
device->save_item(NAME(cpustate->scmr));
device->save_item(NAME(cpustate->colr));
device->save_item(NAME(cpustate->por));
device->save_item(NAME(cpustate->bramr));
device->save_item(NAME(cpustate->vcr));
device->save_item(NAME(cpustate->cfgr));
device->save_item(NAME(cpustate->clsr));
state_save_register_device_item(device, 0, cpustate->romcl);
state_save_register_device_item(device, 0, cpustate->romdr);
device->save_item(NAME(cpustate->romcl));
device->save_item(NAME(cpustate->romdr));
state_save_register_device_item(device, 0, cpustate->ramcl);
state_save_register_device_item(device, 0, cpustate->ramar);
state_save_register_device_item(device, 0, cpustate->ramdr);
device->save_item(NAME(cpustate->ramcl));
device->save_item(NAME(cpustate->ramar));
device->save_item(NAME(cpustate->ramdr));
state_save_register_device_item(device, 0, cpustate->sreg_idx);
state_save_register_device_item(device, 0, cpustate->dreg_idx);
state_save_register_device_item(device, 0, cpustate->r15_modified);
device->save_item(NAME(cpustate->sreg_idx));
device->save_item(NAME(cpustate->dreg_idx));
device->save_item(NAME(cpustate->r15_modified));
state_save_register_device_item(device, 0, cpustate->irq);
device->save_item(NAME(cpustate->irq));
state_save_register_device_item(device, 0, cpustate->cache_access_speed);
state_save_register_device_item(device, 0, cpustate->memory_access_speed);
device->save_item(NAME(cpustate->cache_access_speed));
device->save_item(NAME(cpustate->memory_access_speed));
state_save_register_device_item_array(device, 0, cpustate->cache.buffer);
state_save_register_device_item_array(device, 0, cpustate->cache.valid);
device->save_item(NAME(cpustate->cache.buffer));
device->save_item(NAME(cpustate->cache.valid));
for (i = 0; i < 2; i++)
{
state_save_register_device_item(device, i, cpustate->pixelcache[i].offset);
state_save_register_device_item(device, i, cpustate->pixelcache[i].bitpend);
state_save_register_device_item_array(device, i, cpustate->pixelcache[i].data);
device->save_item(NAME(cpustate->pixelcache[i].offset), i);
device->save_item(NAME(cpustate->pixelcache[i].bitpend), i);
device->save_item(NAME(cpustate->pixelcache[i].data), i);
}
state_save_register_device_item(device, 0, cpustate->icount);
device->save_item(NAME(cpustate->icount));
}
static CPU_INIT( superfx )

26
src/emu/cpu/t11/t11.c
View File

@ -267,19 +267,19 @@ static CPU_INIT( t11 )
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
state_save_register_device_item(device, 0, cpustate->ppc.w.l);
state_save_register_device_item(device, 0, cpustate->reg[0].w.l);
state_save_register_device_item(device, 0, cpustate->reg[1].w.l);
state_save_register_device_item(device, 0, cpustate->reg[2].w.l);
state_save_register_device_item(device, 0, cpustate->reg[3].w.l);
state_save_register_device_item(device, 0, cpustate->reg[4].w.l);
state_save_register_device_item(device, 0, cpustate->reg[5].w.l);
state_save_register_device_item(device, 0, cpustate->reg[6].w.l);
state_save_register_device_item(device, 0, cpustate->reg[7].w.l);
state_save_register_device_item(device, 0, cpustate->psw.w.l);
state_save_register_device_item(device, 0, cpustate->initial_pc);
state_save_register_device_item(device, 0, cpustate->wait_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
device->save_item(NAME(cpustate->ppc.w.l));
device->save_item(NAME(cpustate->reg[0].w.l));
device->save_item(NAME(cpustate->reg[1].w.l));
device->save_item(NAME(cpustate->reg[2].w.l));
device->save_item(NAME(cpustate->reg[3].w.l));
device->save_item(NAME(cpustate->reg[4].w.l));
device->save_item(NAME(cpustate->reg[5].w.l));
device->save_item(NAME(cpustate->reg[6].w.l));
device->save_item(NAME(cpustate->reg[7].w.l));
device->save_item(NAME(cpustate->psw.w.l));
device->save_item(NAME(cpustate->initial_pc));
device->save_item(NAME(cpustate->wait_state));
device->save_item(NAME(cpustate->irq_state));
}

68
src/emu/cpu/tlcs90/tlcs90.c
View File

@ -2636,45 +2636,45 @@ static void state_register( legacy_cpu_device *device )
{
t90_Regs *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->prvpc.w.l);
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->af.w.l);
state_save_register_device_item(device, 0, cpustate->bc.w.l);
state_save_register_device_item(device, 0, cpustate->de.w.l);
state_save_register_device_item(device, 0, cpustate->hl.w.l);
state_save_register_device_item(device, 0, cpustate->ix.w.l);
state_save_register_device_item(device, 0, cpustate->iy.w.l);
state_save_register_device_item(device, 0, cpustate->af2.w.l);
state_save_register_device_item(device, 0, cpustate->bc2.w.l);
state_save_register_device_item(device, 0, cpustate->de2.w.l);
state_save_register_device_item(device, 0, cpustate->hl2.w.l);
state_save_register_device_item(device, 0, cpustate->halt);
state_save_register_device_item(device, 0, cpustate->after_EI);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->irq_mask);
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->extra_cycles);
device->save_item(NAME(cpustate->prvpc.w.l));
device->save_item(NAME(cpustate->pc.w.l));
device->save_item(NAME(cpustate->sp.w.l));
device->save_item(NAME(cpustate->af.w.l));
device->save_item(NAME(cpustate->bc.w.l));
device->save_item(NAME(cpustate->de.w.l));
device->save_item(NAME(cpustate->hl.w.l));
device->save_item(NAME(cpustate->ix.w.l));
device->save_item(NAME(cpustate->iy.w.l));
device->save_item(NAME(cpustate->af2.w.l));
device->save_item(NAME(cpustate->bc2.w.l));
device->save_item(NAME(cpustate->de2.w.l));
device->save_item(NAME(cpustate->hl2.w.l));
device->save_item(NAME(cpustate->halt));
device->save_item(NAME(cpustate->after_EI));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->irq_mask));
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->extra_cycles));
state_save_register_device_item_array(device, 0, cpustate->internal_registers);
state_save_register_device_item(device, 0, cpustate->ixbase);
state_save_register_device_item(device, 0, cpustate->iybase);
device->save_item(NAME(cpustate->internal_registers));
device->save_item(NAME(cpustate->ixbase));
device->save_item(NAME(cpustate->iybase));
state_save_register_device_item_array(device, 0, cpustate->timer_value);
state_save_register_device_item(device, 0, cpustate->timer4_value);
device->save_item(NAME(cpustate->timer_value));
device->save_item(NAME(cpustate->timer4_value));
// Work registers
state_save_register_device_item(device, 0, cpustate->op);
state_save_register_device_item(device, 0, cpustate->mode1);
state_save_register_device_item(device, 0, cpustate->r1);
state_save_register_device_item(device, 0, cpustate->r1b);
state_save_register_device_item(device, 0, cpustate->mode2);
state_save_register_device_item(device, 0, cpustate->r2);
state_save_register_device_item(device, 0, cpustate->r2b);
device->save_item(NAME(cpustate->op));
device->save_item(NAME(cpustate->mode1));
device->save_item(NAME(cpustate->r1));
device->save_item(NAME(cpustate->r1b));
device->save_item(NAME(cpustate->mode2));
device->save_item(NAME(cpustate->r2));
device->save_item(NAME(cpustate->r2b));
state_save_register_device_item(device, 0, cpustate->cyc_t);
state_save_register_device_item(device, 0, cpustate->cyc_f);
state_save_register_device_item(device, 0, cpustate->addr);
device->save_item(NAME(cpustate->cyc_t));
device->save_item(NAME(cpustate->cyc_f));
device->save_item(NAME(cpustate->addr));
}

52
src/emu/cpu/tlcs900/tlcs900.c
View File

@ -225,32 +225,32 @@ static CPU_INIT( tlcs900 )
devcb_resolve_write8( &cpustate->to1, &cpustate->intf->to1, device );
devcb_resolve_write8( &cpustate->to3, &cpustate->intf->to3, device );
state_save_register_device_item_array( device, 0, cpustate->xwa );
state_save_register_device_item_array( device, 0, cpustate->xbc );
state_save_register_device_item_array( device, 0, cpustate->xde );
state_save_register_device_item_array( device, 0, cpustate->xhl );
state_save_register_device_item( device, 0, cpustate->xix );
state_save_register_device_item( device, 0, cpustate->xiy );
state_save_register_device_item( device, 0, cpustate->xiz );
state_save_register_device_item( device, 0, cpustate->xssp );
state_save_register_device_item( device, 0, cpustate->xnsp );
state_save_register_device_item( device, 0, cpustate->pc );
state_save_register_device_item( device, 0, cpustate->sr );
state_save_register_device_item( device, 0, cpustate->f2 );
state_save_register_device_item_array( device, 0, cpustate->dmas );
state_save_register_device_item_array( device, 0, cpustate->dmad );
state_save_register_device_item_array( device, 0, cpustate->dmac );
state_save_register_device_item_array( device, 0, cpustate->dmam );
state_save_register_device_item_array( device, 0, cpustate->reg );
state_save_register_device_item( device, 0, cpustate->timer_pre );
state_save_register_device_item_array( device, 0, cpustate->timer );
state_save_register_device_item( device, 0, cpustate->tff1 );
state_save_register_device_item( device, 0, cpustate->tff3 );
state_save_register_device_item_array( device, 0, cpustate->timer_change );
state_save_register_device_item_array( device, 0, cpustate->level );
state_save_register_device_item( device, 0, cpustate->check_irqs );
state_save_register_device_item( device, 0, cpustate->ad_cycles_left );
state_save_register_device_item( device, 0, cpustate->nmi_state );
device->save_item( NAME(cpustate->xwa) );
device->save_item( NAME(cpustate->xbc) );
device->save_item( NAME(cpustate->xde) );
device->save_item( NAME(cpustate->xhl) );
device->save_item( NAME(cpustate->xix) );
device->save_item( NAME(cpustate->xiy) );
device->save_item( NAME(cpustate->xiz) );
device->save_item( NAME(cpustate->xssp) );
device->save_item( NAME(cpustate->xnsp) );
device->save_item( NAME(cpustate->pc) );
device->save_item( NAME(cpustate->sr) );
device->save_item( NAME(cpustate->f2) );
device->save_item( NAME(cpustate->dmas) );
device->save_item( NAME(cpustate->dmad) );
device->save_item( NAME(cpustate->dmac) );
device->save_item( NAME(cpustate->dmam) );
device->save_item( NAME(cpustate->reg) );
device->save_item( NAME(cpustate->timer_pre) );
device->save_item( NAME(cpustate->timer) );
device->save_item( NAME(cpustate->tff1) );
device->save_item( NAME(cpustate->tff3) );
device->save_item( NAME(cpustate->timer_change) );
device->save_item( NAME(cpustate->level) );
device->save_item( NAME(cpustate->check_irqs) );
device->save_item( NAME(cpustate->ad_cycles_left) );
device->save_item( NAME(cpustate->nmi_state) );
}

64
src/emu/cpu/tms0980/tms0980.c
View File

@ -507,38 +507,38 @@ static void cpu_init_tms_common( legacy_cpu_device *device, const UINT32* decode
cpustate->program = device->space( AS_PROGRAM );
cpustate->data = device->space( AS_PROGRAM );
state_save_register_device_item( device, 0, cpustate->prev_pc );
state_save_register_device_item( device, 0, cpustate->prev_pa );
state_save_register_device_item( device, 0, cpustate->pc );
state_save_register_device_item( device, 0, cpustate->pa );
state_save_register_device_item( device, 0, cpustate->sr );
state_save_register_device_item( device, 0, cpustate->pb );
state_save_register_device_item( device, 0, cpustate->a );
state_save_register_device_item( device, 0, cpustate->x );
state_save_register_device_item( device, 0, cpustate->y );
state_save_register_device_item( device, 0, cpustate->dam );
state_save_register_device_item( device, 0, cpustate->ca );
state_save_register_device_item( device, 0, cpustate->cb );
state_save_register_device_item( device, 0, cpustate->cs );
state_save_register_device_item( device, 0, cpustate->r );
state_save_register_device_item( device, 0, cpustate->o );
state_save_register_device_item( device, 0, cpustate->cki_bus );
state_save_register_device_item( device, 0, cpustate->p );
state_save_register_device_item( device, 0, cpustate->n );
state_save_register_device_item( device, 0, cpustate->adder_result );
state_save_register_device_item( device, 0, cpustate->carry_in );
state_save_register_device_item( device, 0, cpustate->status );
state_save_register_device_item( device, 0, cpustate->status_latch );
state_save_register_device_item( device, 0, cpustate->special_status );
state_save_register_device_item( device, 0, cpustate->call_latch );
state_save_register_device_item( device, 0, cpustate->add_latch );
state_save_register_device_item( device, 0, cpustate->branch_latch );
state_save_register_device_item( device, 0, cpustate->subcycle );
state_save_register_device_item( device, 0, cpustate->ram_address );
state_save_register_device_item( device, 0, cpustate->ram_data );
state_save_register_device_item( device, 0, cpustate->rom_address );
state_save_register_device_item( device, 0, cpustate->opcode );
state_save_register_device_item( device, 0, cpustate->decode );
device->save_item( NAME(cpustate->prev_pc) );
device->save_item( NAME(cpustate->prev_pa) );
device->save_item( NAME(cpustate->pc) );
device->save_item( NAME(cpustate->pa) );
device->save_item( NAME(cpustate->sr) );
device->save_item( NAME(cpustate->pb) );
device->save_item( NAME(cpustate->a) );
device->save_item( NAME(cpustate->x) );
device->save_item( NAME(cpustate->y) );
device->save_item( NAME(cpustate->dam) );
device->save_item( NAME(cpustate->ca) );
device->save_item( NAME(cpustate->cb) );
device->save_item( NAME(cpustate->cs) );
device->save_item( NAME(cpustate->r) );
device->save_item( NAME(cpustate->o) );
device->save_item( NAME(cpustate->cki_bus) );
device->save_item( NAME(cpustate->p) );
device->save_item( NAME(cpustate->n) );
device->save_item( NAME(cpustate->adder_result) );
device->save_item( NAME(cpustate->carry_in) );
device->save_item( NAME(cpustate->status) );
device->save_item( NAME(cpustate->status_latch) );
device->save_item( NAME(cpustate->special_status) );
device->save_item( NAME(cpustate->call_latch) );
device->save_item( NAME(cpustate->add_latch) );
device->save_item( NAME(cpustate->branch_latch) );
device->save_item( NAME(cpustate->subcycle) );
device->save_item( NAME(cpustate->ram_address) );
device->save_item( NAME(cpustate->ram_data) );
device->save_item( NAME(cpustate->rom_address) );
device->save_item( NAME(cpustate->opcode) );
device->save_item( NAME(cpustate->decode) );
}

38
src/emu/cpu/tms32010/tms32010.c
View File

@ -807,25 +807,25 @@ static CPU_INIT( tms32010 )
{
tms32010_state *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->PREVPC);
state_save_register_device_item(device, 0, cpustate->STR);
state_save_register_device_item(device, 0, cpustate->ACC.d);
state_save_register_device_item(device, 0, cpustate->ALU.d);
state_save_register_device_item(device, 0, cpustate->Preg.d);
state_save_register_device_item(device, 0, cpustate->Treg);
state_save_register_device_item(device, 0, cpustate->AR[0]);
state_save_register_device_item(device, 0, cpustate->AR[1]);
state_save_register_device_item(device, 0, cpustate->STACK[0]);
state_save_register_device_item(device, 0, cpustate->STACK[1]);
state_save_register_device_item(device, 0, cpustate->STACK[2]);
state_save_register_device_item(device, 0, cpustate->STACK[3]);
state_save_register_device_item(device, 0, cpustate->INTF);
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->opcode.d);
state_save_register_device_item(device, 0, cpustate->oldacc.d);
state_save_register_device_item(device, 0, cpustate->memaccess);
state_save_register_device_item(device, 0, cpustate->addr_mask);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->PREVPC));
device->save_item(NAME(cpustate->STR));
device->save_item(NAME(cpustate->ACC.d));
device->save_item(NAME(cpustate->ALU.d));
device->save_item(NAME(cpustate->Preg.d));
device->save_item(NAME(cpustate->Treg));
device->save_item(NAME(cpustate->AR[0]));
device->save_item(NAME(cpustate->AR[1]));
device->save_item(NAME(cpustate->STACK[0]));
device->save_item(NAME(cpustate->STACK[1]));
device->save_item(NAME(cpustate->STACK[2]));
device->save_item(NAME(cpustate->STACK[3]));
device->save_item(NAME(cpustate->INTF));
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->opcode.d));
device->save_item(NAME(cpustate->oldacc.d));
device->save_item(NAME(cpustate->memaccess));
device->save_item(NAME(cpustate->addr_mask));
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);

72
src/emu/cpu/tms32025/tms32025.c
View File

@ -1727,45 +1727,45 @@ static CPU_INIT( tms32025 )
cpustate->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->STR0);
state_save_register_device_item(device, 0, cpustate->STR1);
state_save_register_device_item(device, 0, cpustate->PFC);
state_save_register_device_item(device, 0, cpustate->IFR);
state_save_register_device_item(device, 0, cpustate->RPTC);
state_save_register_device_item(device, 0, cpustate->ACC.d);
state_save_register_device_item(device, 0, cpustate->ALU.d);
state_save_register_device_item(device, 0, cpustate->Preg.d);
state_save_register_device_item(device, 0, cpustate->Treg);
state_save_register_device_item(device, 0, cpustate->AR[0]);
state_save_register_device_item(device, 0, cpustate->AR[1]);
state_save_register_device_item(device, 0, cpustate->AR[2]);
state_save_register_device_item(device, 0, cpustate->AR[3]);
state_save_register_device_item(device, 0, cpustate->AR[4]);
state_save_register_device_item(device, 0, cpustate->AR[5]);
state_save_register_device_item(device, 0, cpustate->AR[6]);
state_save_register_device_item(device, 0, cpustate->AR[7]);
state_save_register_device_item(device, 0, cpustate->STACK[0]);
state_save_register_device_item(device, 0, cpustate->STACK[1]);
state_save_register_device_item(device, 0, cpustate->STACK[2]);
state_save_register_device_item(device, 0, cpustate->STACK[3]);
state_save_register_device_item(device, 0, cpustate->STACK[4]);
state_save_register_device_item(device, 0, cpustate->STACK[5]);
state_save_register_device_item(device, 0, cpustate->STACK[6]);
state_save_register_device_item(device, 0, cpustate->STACK[7]);
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->STR0));
device->save_item(NAME(cpustate->STR1));
device->save_item(NAME(cpustate->PFC));
device->save_item(NAME(cpustate->IFR));
device->save_item(NAME(cpustate->RPTC));
device->save_item(NAME(cpustate->ACC.d));
device->save_item(NAME(cpustate->ALU.d));
device->save_item(NAME(cpustate->Preg.d));
device->save_item(NAME(cpustate->Treg));
device->save_item(NAME(cpustate->AR[0]));
device->save_item(NAME(cpustate->AR[1]));
device->save_item(NAME(cpustate->AR[2]));
device->save_item(NAME(cpustate->AR[3]));
device->save_item(NAME(cpustate->AR[4]));
device->save_item(NAME(cpustate->AR[5]));
device->save_item(NAME(cpustate->AR[6]));
device->save_item(NAME(cpustate->AR[7]));
device->save_item(NAME(cpustate->STACK[0]));
device->save_item(NAME(cpustate->STACK[1]));
device->save_item(NAME(cpustate->STACK[2]));
device->save_item(NAME(cpustate->STACK[3]));
device->save_item(NAME(cpustate->STACK[4]));
device->save_item(NAME(cpustate->STACK[5]));
device->save_item(NAME(cpustate->STACK[6]));
device->save_item(NAME(cpustate->STACK[7]));
state_save_register_device_item(device, 0, cpustate->oldacc);
state_save_register_device_item(device, 0, cpustate->memaccess);
state_save_register_device_item(device, 0, cpustate->icount);
state_save_register_device_item(device, 0, cpustate->mHackIgnoreARP);
device->save_item(NAME(cpustate->oldacc));
device->save_item(NAME(cpustate->memaccess));
device->save_item(NAME(cpustate->icount));
device->save_item(NAME(cpustate->mHackIgnoreARP));
state_save_register_device_item(device, 0, cpustate->idle);
state_save_register_device_item(device, 0, cpustate->hold);
state_save_register_device_item(device, 0, cpustate->external_mem_access);
state_save_register_device_item(device, 0, cpustate->init_load_addr);
state_save_register_device_item(device, 0, cpustate->PREVPC);
device->save_item(NAME(cpustate->idle));
device->save_item(NAME(cpustate->hold));
device->save_item(NAME(cpustate->external_mem_access));
device->save_item(NAME(cpustate->init_load_addr));
device->save_item(NAME(cpustate->PREVPC));
// state_save_register_device_item_pointer(device, 0, cpustate->intRAM, 0x800*2);
// device->save_pointer(NAME(cpustate->intRAM), 0x800*2);
}
/****************************************************************************

16
src/emu/cpu/tms32031/tms32031.c
View File

@ -491,15 +491,15 @@ void tms3203x_device::device_start()
m_direct = &m_program->direct();
// save state
state_save_register_device_item(this, 0, m_pc);
save_item(NAME(m_pc));
for (int regnum = 0; regnum < 36; regnum++)
state_save_register_device_item_array(this, regnum, m_r[regnum].i32);
state_save_register_device_item(this, 0, m_bkmask);
state_save_register_device_item(this, 0, m_irq_state);
state_save_register_device_item(this, 0, m_delayed);
state_save_register_device_item(this, 0, m_irq_pending);
state_save_register_device_item(this, 0, m_mcu_mode);
state_save_register_device_item(this, 0, m_is_idling);
save_item(NAME(m_r[regnum].i32), regnum);
save_item(NAME(m_bkmask));
save_item(NAME(m_irq_state));
save_item(NAME(m_delayed));
save_item(NAME(m_irq_pending));
save_item(NAME(m_mcu_mode));
save_item(NAME(m_is_idling));
// register our state for the debugger
state_add(TMS3203X_PC, "PC", m_pc);

22
src/emu/cpu/tms34010/tms34010.c
View File

@ -658,17 +658,17 @@ static CPU_INIT( tms34010 )
/* allocate the shiftreg */
tms->shiftreg = auto_alloc_array(device->machine, UINT16, SHIFTREG_SIZE/2);
state_save_register_device_item(device, 0, tms->pc);
state_save_register_device_item(device, 0, tms->st);
state_save_register_device_item(device, 0, tms->reset_deferred);
state_save_register_device_item_pointer(device, 0, tms->shiftreg, SHIFTREG_SIZE / 2);
state_save_register_device_item_array(device, 0, tms->IOregs);
state_save_register_device_item(device, 0, tms->convsp);
state_save_register_device_item(device, 0, tms->convdp);
state_save_register_device_item(device, 0, tms->convmp);
state_save_register_device_item(device, 0, tms->pixelshift);
state_save_register_device_item(device, 0, tms->gfxcycles);
state_save_register_device_item_pointer(device, 0, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
device->save_item(NAME(tms->pc));
device->save_item(NAME(tms->st));
device->save_item(NAME(tms->reset_deferred));
device->save_pointer(NAME(tms->shiftreg), SHIFTREG_SIZE / 2);
device->save_item(NAME(tms->IOregs));
device->save_item(NAME(tms->convsp));
device->save_item(NAME(tms->convdp));
device->save_item(NAME(tms->convmp));
device->save_item(NAME(tms->pixelshift));
device->save_item(NAME(tms->gfxcycles));
device->save_pointer(NAME(&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
device->machine->state().register_postload(tms34010_state_postload, tms);
}

20
src/emu/cpu/tms7000/tms7000.c
View File

@ -173,23 +173,23 @@ static CPU_INIT( tms7000 )
memset(cpustate->rf, 0, 0x80);
/* Save register state */
state_save_register_device_item(device, 0, pPC);
state_save_register_device_item(device, 0, pSP);
state_save_register_device_item(device, 0, pSR);
device->save_item(NAME(pPC));
device->save_item(NAME(pSP));
device->save_item(NAME(pSR));
/* Save Interrupt state */
state_save_register_device_item_array(device, 0, cpustate->irq_state);
device->save_item(NAME(cpustate->irq_state));
/* Save register and perpherial file state */
state_save_register_device_item_array(device, 0, cpustate->rf);
state_save_register_device_item_array(device, 0, cpustate->pf);
device->save_item(NAME(cpustate->rf));
device->save_item(NAME(cpustate->pf));
/* Save timer state */
state_save_register_device_item(device, 0, cpustate->t1_prescaler);
state_save_register_device_item(device, 0, cpustate->t1_capture_latch);
state_save_register_device_item(device, 0, cpustate->t1_decrementer);
device->save_item(NAME(cpustate->t1_prescaler));
device->save_item(NAME(cpustate->t1_capture_latch));
device->save_item(NAME(cpustate->t1_decrementer));
state_save_register_device_item(device, 0, cpustate->idle_state);
device->save_item(NAME(cpustate->idle_state));
}
static CPU_RESET( tms7000 )

86
src/emu/cpu/tms9900/99xxcore.h
View File

@ -1211,76 +1211,76 @@ static void set_flag1(tms99xx_state *cpustate, int val);
static void register_for_save_state(device_t *device)
{
tms99xx_state *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->WP);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->STATUS);
state_save_register_device_item(device, 0, cpustate->interrupt_pending);
device->save_item(NAME(cpustate->WP));
device->save_item(NAME(cpustate->PC));
device->save_item(NAME(cpustate->STATUS));
device->save_item(NAME(cpustate->interrupt_pending));
#if ! ((TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID))
state_save_register_device_item(device, 0, cpustate->load_state);
device->save_item(NAME(cpustate->load_state));
#endif
#if (TMS99XX_MODEL == TI990_10_ID) || (TMS99XX_MODEL == TMS9900_ID) || (TMS99XX_MODEL == TMS9980_ID)
state_save_register_device_item(device, 0, cpustate->irq_level);
state_save_register_device_item(device, 0, cpustate->irq_state);
device->save_item(NAME(cpustate->irq_level));
device->save_item(NAME(cpustate->irq_state));
#elif (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->irq_level);
state_save_register_device_item(device, 0, cpustate->int_state);
state_save_register_device_item(device, 0, cpustate->int_latch);
device->save_item(NAME(cpustate->irq_level));
device->save_item(NAME(cpustate->int_state));
device->save_item(NAME(cpustate->int_latch));
#endif
state_save_register_device_item(device, 0, cpustate->IDLE);
device->save_item(NAME(cpustate->IDLE));
#if HAS_MAPPING
state_save_register_device_item(device, 0, cpustate->mapping_on);
state_save_register_device_item_array(device, 0, cpustate->map_files[0].L);
state_save_register_device_item_array(device, 0, cpustate->map_files[0].B);
state_save_register_device_item_array(device, 0, cpustate->map_files[0].limit);
state_save_register_device_item_array(device, 0, cpustate->map_files[0].bias);
state_save_register_device_item_array(device, 0, cpustate->map_files[1].L);
state_save_register_device_item_array(device, 0, cpustate->map_files[1].B);
state_save_register_device_item_array(device, 0, cpustate->map_files[1].limit);
state_save_register_device_item_array(device, 0, cpustate->map_files[1].bias);
state_save_register_device_item_array(device, 0, cpustate->map_files[2].L);
state_save_register_device_item_array(device, 0, cpustate->map_files[2].B);
state_save_register_device_item_array(device, 0, cpustate->map_files[2].limit);
state_save_register_device_item_array(device, 0, cpustate->map_files[2].bias);
state_save_register_device_item(device, 0, cpustate->cur_map);
state_save_register_device_item(device, 0, cpustate->cur_src_map);
state_save_register_device_item(device, 0, cpustate->cur_dst_map);
device->save_item(NAME(cpustate->mapping_on));
device->save_item(NAME(cpustate->map_files[0].L));
device->save_item(NAME(cpustate->map_files[0].B));
device->save_item(NAME(cpustate->map_files[0].limit));
device->save_item(NAME(cpustate->map_files[0].bias));
device->save_item(NAME(cpustate->map_files[1].L));
device->save_item(NAME(cpustate->map_files[1].B));
device->save_item(NAME(cpustate->map_files[1].limit));
device->save_item(NAME(cpustate->map_files[1].bias));
device->save_item(NAME(cpustate->map_files[2].L));
device->save_item(NAME(cpustate->map_files[2].B));
device->save_item(NAME(cpustate->map_files[2].limit));
device->save_item(NAME(cpustate->map_files[2].bias));
device->save_item(NAME(cpustate->cur_map));
device->save_item(NAME(cpustate->cur_src_map));
device->save_item(NAME(cpustate->cur_dst_map));
#if (TMS99XX_MODEL == TI990_10_ID)
state_save_register_device_item(device, 0, cpustate->reset_maperr);
state_save_register_device_item(device, 0, cpustate->mapper_address_latch);
state_save_register_device_item(device, 0, cpustate->mapper_cru_read_register);
state_save_register_device_item(device, 0, cpustate->diaglat);
state_save_register_device_item_array(device, 0, cpustate->latch_control);
device->save_item(NAME(cpustate->reset_maperr));
device->save_item(NAME(cpustate->mapper_address_latch));
device->save_item(NAME(cpustate->mapper_cru_read_register));
device->save_item(NAME(cpustate->diaglat));
device->save_item(NAME(cpustate->latch_control));
#endif
#endif
#if (TMS99XX_MODEL == TI990_10_ID)
state_save_register_device_item(device, 0, cpustate->error_interrupt_register);
device->save_item(NAME(cpustate->error_interrupt_register));
#endif
#if (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item_array(device, 0, cpustate->RAM);
device->save_item(NAME(cpustate->RAM));
#endif
#if (TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->decrementer_enabled);
state_save_register_device_item(device, 0, cpustate->decrementer_interval);
state_save_register_device_item(device, 0, cpustate->decrementer_count);
device->save_item(NAME(cpustate->decrementer_enabled));
device->save_item(NAME(cpustate->decrementer_interval));
device->save_item(NAME(cpustate->decrementer_count));
#endif
#if (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->flag);
state_save_register_device_item(device, 0, cpustate->MID_flag);
state_save_register_device_item(device, 0, cpustate->memory_wait_states_byte);
state_save_register_device_item(device, 0, cpustate->memory_wait_states_word);
state_save_register_device_item(device, 0, cpustate->is_mp9537);
device->save_item(NAME(cpustate->flag));
device->save_item(NAME(cpustate->MID_flag));
device->save_item(NAME(cpustate->memory_wait_states_byte));
device->save_item(NAME(cpustate->memory_wait_states_word));
device->save_item(NAME(cpustate->is_mp9537));
#endif
state_save_register_device_item(device, 0, cpustate->disable_interrupt_recognition);
device->save_item(NAME(cpustate->disable_interrupt_recognition));
}

56
src/emu/cpu/upd7725/upd7725.c
View File

@ -208,34 +208,34 @@ void necdsp_device::device_start()
state_add(UPD7725_IDB, "IDB", regs.idb);
// save state registrations
state_save_register_device_item(this, 0, regs.pc);
state_save_register_device_item(this, 0, regs.rp);
state_save_register_device_item(this, 0, regs.dp);
state_save_register_device_item(this, 0, regs.sp);
state_save_register_device_item(this, 0, regs.k);
state_save_register_device_item(this, 0, regs.l);
state_save_register_device_item(this, 0, regs.m);
state_save_register_device_item(this, 0, regs.n);
state_save_register_device_item(this, 0, regs.a);
state_save_register_device_item(this, 0, regs.b);
state_save_register_device_item(this, 0, regs.tr);
state_save_register_device_item(this, 0, regs.trb);
state_save_register_device_item(this, 0, regs.dr);
state_save_register_device_item(this, 0, regs.so);
state_save_register_device_item(this, 0, regs.idb);
state_save_register_device_item(this, 0, regs.sr.rqm);
state_save_register_device_item(this, 0, regs.sr.usf0);
state_save_register_device_item(this, 0, regs.sr.usf1);
state_save_register_device_item(this, 0, regs.sr.drs);
state_save_register_device_item(this, 0, regs.sr.dma);
state_save_register_device_item(this, 0, regs.sr.drc);
state_save_register_device_item(this, 0, regs.sr.soc);
state_save_register_device_item(this, 0, regs.sr.sic);
state_save_register_device_item(this, 0, regs.sr.ei);
state_save_register_device_item(this, 0, regs.sr.p0);
state_save_register_device_item(this, 0, regs.sr.p1);
state_save_register_device_item_array(this, 0, regs.stack);
state_save_register_device_item_array(this, 0, dataRAM);
save_item(NAME(regs.pc));
save_item(NAME(regs.rp));
save_item(NAME(regs.dp));
save_item(NAME(regs.sp));
save_item(NAME(regs.k));
save_item(NAME(regs.l));
save_item(NAME(regs.m));
save_item(NAME(regs.n));
save_item(NAME(regs.a));
save_item(NAME(regs.b));
save_item(NAME(regs.tr));
save_item(NAME(regs.trb));
save_item(NAME(regs.dr));
save_item(NAME(regs.so));
save_item(NAME(regs.idb));
save_item(NAME(regs.sr.rqm));
save_item(NAME(regs.sr.usf0));
save_item(NAME(regs.sr.usf1));
save_item(NAME(regs.sr.drs));
save_item(NAME(regs.sr.dma));
save_item(NAME(regs.sr.drc));
save_item(NAME(regs.sr.soc));
save_item(NAME(regs.sr.sic));
save_item(NAME(regs.sr.ei));
save_item(NAME(regs.sr.p0));
save_item(NAME(regs.sr.p1));
save_item(NAME(regs.stack));
save_item(NAME(dataRAM));
m_icountptr = &m_icount;
}

128
src/emu/cpu/upd7810/upd7810.c
View File

@ -1707,70 +1707,70 @@ static CPU_INIT( upd7810 )
cpustate->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->ppc.w.l);
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->psw);
state_save_register_device_item(device, 0, cpustate->op);
state_save_register_device_item(device, 0, cpustate->op2);
state_save_register_device_item(device, 0, cpustate->iff);
state_save_register_device_item(device, 0, cpustate->ea.w.l);
state_save_register_device_item(device, 0, cpustate->va.w.l);
state_save_register_device_item(device, 0, cpustate->bc.w.l);
state_save_register_device_item(device, 0, cpustate->de.w.l);
state_save_register_device_item(device, 0, cpustate->hl.w.l);
state_save_register_device_item(device, 0, cpustate->ea2.w.l);
state_save_register_device_item(device, 0, cpustate->va2.w.l);
state_save_register_device_item(device, 0, cpustate->bc2.w.l);
state_save_register_device_item(device, 0, cpustate->de2.w.l);
state_save_register_device_item(device, 0, cpustate->hl2.w.l);
state_save_register_device_item(device, 0, cpustate->cnt.d);
state_save_register_device_item(device, 0, cpustate->tm.d);
state_save_register_device_item(device, 0, cpustate->ecnt.d);
state_save_register_device_item(device, 0, cpustate->etm.d);
state_save_register_device_item(device, 0, cpustate->ma);
state_save_register_device_item(device, 0, cpustate->mb);
state_save_register_device_item(device, 0, cpustate->mcc);
state_save_register_device_item(device, 0, cpustate->mc);
state_save_register_device_item(device, 0, cpustate->mm);
state_save_register_device_item(device, 0, cpustate->mf);
state_save_register_device_item(device, 0, cpustate->tmm);
state_save_register_device_item(device, 0, cpustate->etmm);
state_save_register_device_item(device, 0, cpustate->eom);
state_save_register_device_item(device, 0, cpustate->sml);
state_save_register_device_item(device, 0, cpustate->smh);
state_save_register_device_item(device, 0, cpustate->anm);
state_save_register_device_item(device, 0, cpustate->mkl);
state_save_register_device_item(device, 0, cpustate->mkh);
state_save_register_device_item(device, 0, cpustate->zcm);
state_save_register_device_item(device, 0, cpustate->pa_out);
state_save_register_device_item(device, 0, cpustate->pb_out);
state_save_register_device_item(device, 0, cpustate->pc_out);
state_save_register_device_item(device, 0, cpustate->pd_out);
state_save_register_device_item(device, 0, cpustate->pf_out);
state_save_register_device_item(device, 0, cpustate->cr0);
state_save_register_device_item(device, 0, cpustate->cr1);
state_save_register_device_item(device, 0, cpustate->cr2);
state_save_register_device_item(device, 0, cpustate->cr3);
state_save_register_device_item(device, 0, cpustate->txb);
state_save_register_device_item(device, 0, cpustate->rxb);
state_save_register_device_item(device, 0, cpustate->txd);
state_save_register_device_item(device, 0, cpustate->rxd);
state_save_register_device_item(device, 0, cpustate->sck);
state_save_register_device_item(device, 0, cpustate->ti);
state_save_register_device_item(device, 0, cpustate->to);
state_save_register_device_item(device, 0, cpustate->ci);
state_save_register_device_item(device, 0, cpustate->co0);
state_save_register_device_item(device, 0, cpustate->co1);
state_save_register_device_item(device, 0, cpustate->irr);
state_save_register_device_item(device, 0, cpustate->itf);
state_save_register_device_item(device, 0, cpustate->ovc0);
state_save_register_device_item(device, 0, cpustate->ovc1);
state_save_register_device_item(device, 0, cpustate->ovcf);
state_save_register_device_item(device, 0, cpustate->ovcs);
state_save_register_device_item(device, 0, cpustate->edges);
state_save_register_device_item(device, 0, cpustate->int1);
state_save_register_device_item(device, 0, cpustate->int2);
device->save_item(NAME(cpustate->ppc.w.l));
device->save_item(NAME(cpustate->pc.w.l));
device->save_item(NAME(cpustate->sp.w.l));
device->save_item(NAME(cpustate->psw));
device->save_item(NAME(cpustate->op));
device->save_item(NAME(cpustate->op2));
device->save_item(NAME(cpustate->iff));
device->save_item(NAME(cpustate->ea.w.l));
device->save_item(NAME(cpustate->va.w.l));
device->save_item(NAME(cpustate->bc.w.l));
device->save_item(NAME(cpustate->de.w.l));
device->save_item(NAME(cpustate->hl.w.l));
device->save_item(NAME(cpustate->ea2.w.l));
device->save_item(NAME(cpustate->va2.w.l));
device->save_item(NAME(cpustate->bc2.w.l));
device->save_item(NAME(cpustate->de2.w.l));
device->save_item(NAME(cpustate->hl2.w.l));
device->save_item(NAME(cpustate->cnt.d));
device->save_item(NAME(cpustate->tm.d));
device->save_item(NAME(cpustate->ecnt.d));
device->save_item(NAME(cpustate->etm.d));
device->save_item(NAME(cpustate->ma));
device->save_item(NAME(cpustate->mb));
device->save_item(NAME(cpustate->mcc));
device->save_item(NAME(cpustate->mc));
device->save_item(NAME(cpustate->mm));
device->save_item(NAME(cpustate->mf));
device->save_item(NAME(cpustate->tmm));
device->save_item(NAME(cpustate->etmm));
device->save_item(NAME(cpustate->eom));
device->save_item(NAME(cpustate->sml));
device->save_item(NAME(cpustate->smh));
device->save_item(NAME(cpustate->anm));
device->save_item(NAME(cpustate->mkl));
device->save_item(NAME(cpustate->mkh));
device->save_item(NAME(cpustate->zcm));
device->save_item(NAME(cpustate->pa_out));
device->save_item(NAME(cpustate->pb_out));
device->save_item(NAME(cpustate->pc_out));
device->save_item(NAME(cpustate->pd_out));
device->save_item(NAME(cpustate->pf_out));
device->save_item(NAME(cpustate->cr0));
device->save_item(NAME(cpustate->cr1));
device->save_item(NAME(cpustate->cr2));
device->save_item(NAME(cpustate->cr3));
device->save_item(NAME(cpustate->txb));
device->save_item(NAME(cpustate->rxb));
device->save_item(NAME(cpustate->txd));
device->save_item(NAME(cpustate->rxd));
device->save_item(NAME(cpustate->sck));
device->save_item(NAME(cpustate->ti));
device->save_item(NAME(cpustate->to));
device->save_item(NAME(cpustate->ci));
device->save_item(NAME(cpustate->co0));
device->save_item(NAME(cpustate->co1));
device->save_item(NAME(cpustate->irr));
device->save_item(NAME(cpustate->itf));
device->save_item(NAME(cpustate->ovc0));
device->save_item(NAME(cpustate->ovc1));
device->save_item(NAME(cpustate->ovcf));
device->save_item(NAME(cpustate->ovcs));
device->save_item(NAME(cpustate->edges));
device->save_item(NAME(cpustate->int1));
device->save_item(NAME(cpustate->int2));
}
#include "7810tbl.c"

34
src/emu/cpu/v30mz/v30mz.c
View File

@ -939,24 +939,24 @@ static void nec_init(legacy_cpu_device *device, device_irq_callback irqcallback,
const nec_config *config = &default_config;
state_save_register_device_item_array(device, 0, cpustate->regs.w);
state_save_register_device_item_array(device, 0, cpustate->sregs);
device->save_item(NAME(cpustate->regs.w));
device->save_item(NAME(cpustate->sregs));
state_save_register_device_item(device, 0, cpustate->ip);
state_save_register_device_item(device, 0, cpustate->TF);
state_save_register_device_item(device, 0, cpustate->IF);
state_save_register_device_item(device, 0, cpustate->DF);
state_save_register_device_item(device, 0, cpustate->MF);
state_save_register_device_item(device, 0, cpustate->SignVal);
state_save_register_device_item(device, 0, cpustate->int_vector);
state_save_register_device_item(device, 0, cpustate->pending_irq);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->AuxVal);
state_save_register_device_item(device, 0, cpustate->OverVal);
state_save_register_device_item(device, 0, cpustate->ZeroVal);
state_save_register_device_item(device, 0, cpustate->CarryVal);
state_save_register_device_item(device, 0, cpustate->ParityVal);
device->save_item(NAME(cpustate->ip));
device->save_item(NAME(cpustate->TF));
device->save_item(NAME(cpustate->IF));
device->save_item(NAME(cpustate->DF));
device->save_item(NAME(cpustate->MF));
device->save_item(NAME(cpustate->SignVal));
device->save_item(NAME(cpustate->int_vector));
device->save_item(NAME(cpustate->pending_irq));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->AuxVal));
device->save_item(NAME(cpustate->OverVal));
device->save_item(NAME(cpustate->ZeroVal));
device->save_item(NAME(cpustate->CarryVal));
device->save_item(NAME(cpustate->ParityVal));
cpustate->config = config;
cpustate->irq_callback = irqcallback;

16
src/emu/cpu/v60/v60.c
View File

@ -334,14 +334,14 @@ static void base_init(legacy_cpu_device *device, device_irq_callback irqcallback
cpustate->irq_line = CLEAR_LINE;
cpustate->nmi_line = CLEAR_LINE;
state_save_register_device_item_array(device, 0, cpustate->reg);
state_save_register_device_item(device, 0, cpustate->irq_line);
state_save_register_device_item(device, 0, cpustate->nmi_line);
state_save_register_device_item(device, 0, cpustate->PPC);
state_save_register_device_item(device, 0, cpustate->_CY);
state_save_register_device_item(device, 0, cpustate->_OV);
state_save_register_device_item(device, 0, cpustate->_S);
state_save_register_device_item(device, 0, cpustate->_Z);
device->save_item(NAME(cpustate->reg));
device->save_item(NAME(cpustate->irq_line));
device->save_item(NAME(cpustate->nmi_line));
device->save_item(NAME(cpustate->PPC));
device->save_item(NAME(cpustate->_CY));
device->save_item(NAME(cpustate->_OV));
device->save_item(NAME(cpustate->_S));
device->save_item(NAME(cpustate->_Z));
}
static CPU_INIT( v60 )

10
src/emu/cpu/v810/v810.c
View File

@ -1026,11 +1026,11 @@ static CPU_INIT( v810 )
cpustate->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO);
state_save_register_device_item_array(device, 0, cpustate->reg);
state_save_register_device_item(device, 0, cpustate->irq_line);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->nmi_line);
state_save_register_device_item(device, 0, cpustate->PPC);
device->save_item(NAME(cpustate->reg));
device->save_item(NAME(cpustate->irq_line));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->nmi_line));
device->save_item(NAME(cpustate->PPC));
}

6
src/emu/cpu/vtlb.c
View File

@ -77,17 +77,17 @@ vtlb_state *vtlb_alloc(device_t *cpu, int space, int fixed_entries, int dynamic_
/* allocate the entry array */
vtlb->live = auto_alloc_array_clear(cpu->machine, offs_t, fixed_entries + dynamic_entries);
state_save_register_device_item_pointer(cpu, space, vtlb->live, fixed_entries + dynamic_entries);
cpu->save_pointer(NAME(vtlb->live), fixed_entries + dynamic_entries, space);
/* allocate the lookup table */
vtlb->table = auto_alloc_array_clear(cpu->machine, vtlb_entry, (size_t) 1 << (vtlb->addrwidth - vtlb->pageshift));
state_save_register_device_item_pointer(cpu, space, vtlb->table, 1 << (vtlb->addrwidth - vtlb->pageshift));
cpu->save_pointer(NAME(vtlb->table), 1 << (vtlb->addrwidth - vtlb->pageshift), space);
/* allocate the fixed page count array */
if (fixed_entries > 0)
{
vtlb->fixedpages = auto_alloc_array_clear(cpu->machine, int, fixed_entries);
state_save_register_device_item_pointer(cpu, space, vtlb->fixedpages, fixed_entries);
cpu->save_pointer(NAME(vtlb->fixedpages), fixed_entries, space);
}
return vtlb;
}

72
src/emu/cpu/z180/z180.c
View File

@ -2050,46 +2050,46 @@ static CPU_INIT( z180 )
state->state_add(Z180_IOCR, "IOCR", cpustate->IO_IOCR);
}
state_save_register_device_item(device, 0, cpustate->AF.w.l);
state_save_register_device_item(device, 0, cpustate->BC.w.l);
state_save_register_device_item(device, 0, cpustate->DE.w.l);
state_save_register_device_item(device, 0, cpustate->HL.w.l);
state_save_register_device_item(device, 0, cpustate->IX.w.l);
state_save_register_device_item(device, 0, cpustate->IY.w.l);
state_save_register_device_item(device, 0, cpustate->PC.w.l);
state_save_register_device_item(device, 0, cpustate->SP.w.l);
state_save_register_device_item(device, 0, cpustate->AF2.w.l);
state_save_register_device_item(device, 0, cpustate->BC2.w.l);
state_save_register_device_item(device, 0, cpustate->DE2.w.l);
state_save_register_device_item(device, 0, cpustate->HL2.w.l);
state_save_register_device_item(device, 0, cpustate->R);
state_save_register_device_item(device, 0, cpustate->R2);
state_save_register_device_item(device, 0, cpustate->IFF1);
state_save_register_device_item(device, 0, cpustate->IFF2);
state_save_register_device_item(device, 0, cpustate->HALT);
state_save_register_device_item(device, 0, cpustate->IM);
state_save_register_device_item(device, 0, cpustate->I);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->nmi_pending);
state_save_register_device_item_array(device, 0, cpustate->irq_state);
state_save_register_device_item_array(device, 0, cpustate->int_pending);
state_save_register_device_item(device, 0, cpustate->timer_cnt);
state_save_register_device_item(device, 0, cpustate->dma0_cnt);
state_save_register_device_item(device, 0, cpustate->dma1_cnt);
state_save_register_device_item(device, 0, cpustate->after_EI);
device->save_item(NAME(cpustate->AF.w.l));
device->save_item(NAME(cpustate->BC.w.l));
device->save_item(NAME(cpustate->DE.w.l));
device->save_item(NAME(cpustate->HL.w.l));
device->save_item(NAME(cpustate->IX.w.l));
device->save_item(NAME(cpustate->IY.w.l));
device->save_item(NAME(cpustate->PC.w.l));
device->save_item(NAME(cpustate->SP.w.l));
device->save_item(NAME(cpustate->AF2.w.l));
device->save_item(NAME(cpustate->BC2.w.l));
device->save_item(NAME(cpustate->DE2.w.l));
device->save_item(NAME(cpustate->HL2.w.l));
device->save_item(NAME(cpustate->R));
device->save_item(NAME(cpustate->R2));
device->save_item(NAME(cpustate->IFF1));
device->save_item(NAME(cpustate->IFF2));
device->save_item(NAME(cpustate->HALT));
device->save_item(NAME(cpustate->IM));
device->save_item(NAME(cpustate->I));
device->save_item(NAME(cpustate->nmi_state));
device->save_item(NAME(cpustate->nmi_pending));
device->save_item(NAME(cpustate->irq_state));
device->save_item(NAME(cpustate->int_pending));
device->save_item(NAME(cpustate->timer_cnt));
device->save_item(NAME(cpustate->dma0_cnt));
device->save_item(NAME(cpustate->dma1_cnt));
device->save_item(NAME(cpustate->after_EI));
state_save_register_device_item_array(device, 0, cpustate->tif);
device->save_item(NAME(cpustate->tif));
state_save_register_device_item_array(device, 0, cpustate->read_tcr_tmdr);
state_save_register_device_item_array(device, 0, cpustate->tmdr_value);
state_save_register_device_item_array(device, 0, cpustate->tmdrh);
state_save_register_device_item(device, 0, cpustate->tmdr_latch);
device->save_item(NAME(cpustate->read_tcr_tmdr));
device->save_item(NAME(cpustate->tmdr_value));
device->save_item(NAME(cpustate->tmdrh));
device->save_item(NAME(cpustate->tmdr_latch));
state_save_register_device_item_array(device, 0, cpustate->io);
state_save_register_device_item(device, 0, cpustate->iol);
state_save_register_device_item(device, 0, cpustate->ioltemp);
device->save_item(NAME(cpustate->io));
device->save_item(NAME(cpustate->iol));
device->save_item(NAME(cpustate->ioltemp));
state_save_register_device_item_array(device, 0, cpustate->mmu);
device->save_item(NAME(cpustate->mmu));
}

10
src/emu/cpu/z8/z8.c
View File

@ -673,11 +673,11 @@ static CPU_INIT( z8 )
cpustate->t1_timer = device->machine->scheduler().timer_alloc(FUNC(t1_tick), cpustate);
/* register for state saving */
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item_array(device, 0, cpustate->r);
state_save_register_device_item_array(device, 0, cpustate->input);
state_save_register_device_item_array(device, 0, cpustate->output);
state_save_register_device_item_array(device, 0, cpustate->irq);
device->save_item(NAME(cpustate->pc));
device->save_item(NAME(cpustate->r));
device->save_item(NAME(cpustate->input));
device->save_item(NAME(cpustate->output));
device->save_item(NAME(cpustate->irq));
}
/***************************************************************************

54
src/emu/cpu/z80/z80.c
View File

@ -3421,32 +3421,32 @@ static CPU_INIT( z80 )
if( (i & 0x0f) == 0x0f ) SZHV_dec[i] |= HF;
}
state_save_register_device_item(device, 0, z80->prvpc.w.l);
state_save_register_device_item(device, 0, z80->PC);
state_save_register_device_item(device, 0, z80->SP);
state_save_register_device_item(device, 0, z80->AF);
state_save_register_device_item(device, 0, z80->BC);
state_save_register_device_item(device, 0, z80->DE);
state_save_register_device_item(device, 0, z80->HL);
state_save_register_device_item(device, 0, z80->IX);
state_save_register_device_item(device, 0, z80->IY);
state_save_register_device_item(device, 0, z80->WZ);
state_save_register_device_item(device, 0, z80->af2.w.l);
state_save_register_device_item(device, 0, z80->bc2.w.l);
state_save_register_device_item(device, 0, z80->de2.w.l);
state_save_register_device_item(device, 0, z80->hl2.w.l);
state_save_register_device_item(device, 0, z80->r);
state_save_register_device_item(device, 0, z80->r2);
state_save_register_device_item(device, 0, z80->iff1);
state_save_register_device_item(device, 0, z80->iff2);
state_save_register_device_item(device, 0, z80->halt);
state_save_register_device_item(device, 0, z80->im);
state_save_register_device_item(device, 0, z80->i);
state_save_register_device_item(device, 0, z80->nmi_state);
state_save_register_device_item(device, 0, z80->nmi_pending);
state_save_register_device_item(device, 0, z80->irq_state);
state_save_register_device_item(device, 0, z80->after_ei);
state_save_register_device_item(device, 0, z80->after_ldair);
device->save_item(NAME(z80->prvpc.w.l));
device->save_item(NAME(z80->PC));
device->save_item(NAME(z80->SP));
device->save_item(NAME(z80->AF));
device->save_item(NAME(z80->BC));
device->save_item(NAME(z80->DE));
device->save_item(NAME(z80->HL));
device->save_item(NAME(z80->IX));
device->save_item(NAME(z80->IY));
device->save_item(NAME(z80->WZ));
device->save_item(NAME(z80->af2.w.l));
device->save_item(NAME(z80->bc2.w.l));
device->save_item(NAME(z80->de2.w.l));
device->save_item(NAME(z80->hl2.w.l));
device->save_item(NAME(z80->r));
device->save_item(NAME(z80->r2));
device->save_item(NAME(z80->iff1));
device->save_item(NAME(z80->iff2));
device->save_item(NAME(z80->halt));
device->save_item(NAME(z80->im));
device->save_item(NAME(z80->i));
device->save_item(NAME(z80->nmi_state));
device->save_item(NAME(z80->nmi_pending));
device->save_item(NAME(z80->irq_state));
device->save_item(NAME(z80->after_ei));
device->save_item(NAME(z80->after_ldair));
/* Reset registers to their initial values */
z80->PRVPC = 0;
@ -3535,7 +3535,7 @@ static CPU_INIT( z80 )
static CPU_INIT( nsc800 )
{
z80_state *z80 = get_safe_token(device);
state_save_register_device_item_array(device, 0, z80->nsc800_irq_state);
device->save_item(NAME(z80->nsc800_irq_state));
CPU_INIT_CALL (z80);
}

6
src/emu/devintrf.c
View File

@ -756,9 +756,9 @@ void device_t::start()
}
// register our save states
state_save_register_device_item(this, 0, m_clock);
state_save_register_device_item(this, 0, m_unscaled_clock);
state_save_register_device_item(this, 0, m_clock_scale);
save_item(NAME(m_clock));
save_item(NAME(m_unscaled_clock));
save_item(NAME(m_clock_scale));
// we're now officially started
m_started = true;

22
src/emu/diexec.c
View File

@ -563,14 +563,14 @@ void device_execute_interface::interface_pre_start()
m_timedint_timer = device().machine->scheduler().timer_alloc(FUNC(static_trigger_periodic_interrupt), (void *)this);
// register for save states
state_save_register_device_item(&m_device, 0, m_suspend);
state_save_register_device_item(&m_device, 0, m_nextsuspend);
state_save_register_device_item(&m_device, 0, m_eatcycles);
state_save_register_device_item(&m_device, 0, m_nexteatcycles);
state_save_register_device_item(&m_device, 0, m_trigger);
state_save_register_device_item(&m_device, 0, m_totalcycles);
state_save_register_device_item(&m_device, 0, m_localtime);
state_save_register_device_item(&m_device, 0, m_iloops);
m_device.save_item(NAME(m_suspend));
m_device.save_item(NAME(m_nextsuspend));
m_device.save_item(NAME(m_eatcycles));
m_device.save_item(NAME(m_nexteatcycles));
m_device.save_item(NAME(m_trigger));
m_device.save_item(NAME(m_totalcycles));
m_device.save_item(NAME(m_localtime));
m_device.save_item(NAME(m_iloops));
}
@ -856,9 +856,9 @@ void device_execute_interface::device_input::start(device_execute_interface *exe
reset();
state_save_register_device_item(m_device, m_linenum, m_stored_vector);
state_save_register_device_item(m_device, m_linenum, m_curvector);
state_save_register_device_item(m_device, m_linenum, m_curstate);
m_device->save_item(NAME(m_stored_vector), m_linenum);
m_device->save_item(NAME(m_curvector), m_linenum);
m_device->save_item(NAME(m_curstate), m_linenum);
}

56
src/emu/machine/6522via.c
View File

@ -229,34 +229,34 @@ void via6522_device::device_start()
}
/* save state register */
state_save_register_device_item(this, 0, m_in_a);
state_save_register_device_item(this, 0, m_in_ca1);
state_save_register_device_item(this, 0, m_in_ca2);
state_save_register_device_item(this, 0, m_out_a);
state_save_register_device_item(this, 0, m_out_ca2);
state_save_register_device_item(this, 0, m_ddr_a);
state_save_register_device_item(this, 0, m_in_b);
state_save_register_device_item(this, 0, m_in_cb1);
state_save_register_device_item(this, 0, m_in_cb2);
state_save_register_device_item(this, 0, m_out_b);
state_save_register_device_item(this, 0, m_out_cb2);
state_save_register_device_item(this, 0, m_ddr_b);
state_save_register_device_item(this, 0, m_t1cl);
state_save_register_device_item(this, 0, m_t1ch);
state_save_register_device_item(this, 0, m_t1ll);
state_save_register_device_item(this, 0, m_t1lh);
state_save_register_device_item(this, 0, m_t2cl);
state_save_register_device_item(this, 0, m_t2ch);
state_save_register_device_item(this, 0, m_t2ll);
state_save_register_device_item(this, 0, m_t2lh);
state_save_register_device_item(this, 0, m_sr);
state_save_register_device_item(this, 0, m_pcr);
state_save_register_device_item(this, 0, m_acr);
state_save_register_device_item(this, 0, m_ier);
state_save_register_device_item(this, 0, m_ifr);
state_save_register_device_item(this, 0, m_t1_active);
state_save_register_device_item(this, 0, m_t2_active);
state_save_register_device_item(this, 0, m_shift_counter);
save_item(NAME(m_in_a));
save_item(NAME(m_in_ca1));
save_item(NAME(m_in_ca2));
save_item(NAME(m_out_a));
save_item(NAME(m_out_ca2));
save_item(NAME(m_ddr_a));
save_item(NAME(m_in_b));
save_item(NAME(m_in_cb1));
save_item(NAME(m_in_cb2));
save_item(NAME(m_out_b));
save_item(NAME(m_out_cb2));
save_item(NAME(m_ddr_b));
save_item(NAME(m_t1cl));
save_item(NAME(m_t1ch));
save_item(NAME(m_t1ll));
save_item(NAME(m_t1lh));
save_item(NAME(m_t2cl));
save_item(NAME(m_t2ch));
save_item(NAME(m_t2ll));
save_item(NAME(m_t2lh));
save_item(NAME(m_sr));
save_item(NAME(m_pcr));
save_item(NAME(m_acr));
save_item(NAME(m_ier));
save_item(NAME(m_ifr));
save_item(NAME(m_t1_active));
save_item(NAME(m_t2_active));
save_item(NAME(m_shift_counter));
}

66
src/emu/machine/6526cia.c
View File

@ -212,39 +212,39 @@ void mos6526_device::device_start()
}
/* state save support */
state_save_register_device_item(this, 0, m_port[0].m_ddr);
state_save_register_device_item(this, 0, m_port[0].m_latch);
state_save_register_device_item(this, 0, m_port[0].m_in);
state_save_register_device_item(this, 0, m_port[0].m_out);
state_save_register_device_item(this, 0, m_port[0].m_mask_value);
state_save_register_device_item(this, 0, m_port[1].m_ddr);
state_save_register_device_item(this, 0, m_port[1].m_latch);
state_save_register_device_item(this, 0, m_port[1].m_in);
state_save_register_device_item(this, 0, m_port[1].m_out);
state_save_register_device_item(this, 0, m_port[1].m_mask_value);
state_save_register_device_item(this, 0, m_timer[0].m_latch);
state_save_register_device_item(this, 0, m_timer[0].m_count);
state_save_register_device_item(this, 0, m_timer[0].m_mode);
state_save_register_device_item(this, 0, m_timer[0].m_irq);
state_save_register_device_item(this, 0, m_timer[1].m_latch);
state_save_register_device_item(this, 0, m_timer[1].m_count);
state_save_register_device_item(this, 0, m_timer[1].m_mode);
state_save_register_device_item(this, 0, m_timer[1].m_irq);
state_save_register_device_item(this, 0, m_tod);
state_save_register_device_item(this, 0, m_tod_latch);
state_save_register_device_item(this, 0, m_tod_latched);
state_save_register_device_item(this, 0, m_tod_running);
state_save_register_device_item(this, 0, m_alarm);
state_save_register_device_item(this, 0, m_icr);
state_save_register_device_item(this, 0, m_ics);
state_save_register_device_item(this, 0, m_irq);
state_save_register_device_item(this, 0, m_flag);
state_save_register_device_item(this, 0, m_loaded);
state_save_register_device_item(this, 0, m_sdr);
state_save_register_device_item(this, 0, m_sp);
state_save_register_device_item(this, 0, m_cnt);
state_save_register_device_item(this, 0, m_shift);
state_save_register_device_item(this, 0, m_serial);
save_item(NAME(m_port[0].m_ddr));
save_item(NAME(m_port[0].m_latch));
save_item(NAME(m_port[0].m_in));
save_item(NAME(m_port[0].m_out));
save_item(NAME(m_port[0].m_mask_value));
save_item(NAME(m_port[1].m_ddr));
save_item(NAME(m_port[1].m_latch));
save_item(NAME(m_port[1].m_in));
save_item(NAME(m_port[1].m_out));
save_item(NAME(m_port[1].m_mask_value));
save_item(NAME(m_timer[0].m_latch));
save_item(NAME(m_timer[0].m_count));
save_item(NAME(m_timer[0].m_mode));
save_item(NAME(m_timer[0].m_irq));
save_item(NAME(m_timer[1].m_latch));
save_item(NAME(m_timer[1].m_count));
save_item(NAME(m_timer[1].m_mode));
save_item(NAME(m_timer[1].m_irq));
save_item(NAME(m_tod));
save_item(NAME(m_tod_latch));
save_item(NAME(m_tod_latched));
save_item(NAME(m_tod_running));
save_item(NAME(m_alarm));
save_item(NAME(m_icr));
save_item(NAME(m_ics));
save_item(NAME(m_irq));
save_item(NAME(m_flag));
save_item(NAME(m_loaded));
save_item(NAME(m_sdr));
save_item(NAME(m_sp));
save_item(NAME(m_cnt));
save_item(NAME(m_shift));
save_item(NAME(m_serial));
}

24
src/emu/machine/6532riot.c
View File

@ -537,21 +537,21 @@ void riot6532_device::device_start()
m_timer = m_machine.scheduler().timer_alloc(FUNC(timer_end_callback), (void *)this);
/* register for save states */
state_save_register_device_item(this, 0, m_port[0].m_in);
state_save_register_device_item(this, 0, m_port[0].m_out);
state_save_register_device_item(this, 0, m_port[0].m_ddr);
state_save_register_device_item(this, 0, m_port[1].m_in);
state_save_register_device_item(this, 0, m_port[1].m_out);
state_save_register_device_item(this, 0, m_port[1].m_ddr);
save_item(NAME(m_port[0].m_in));
save_item(NAME(m_port[0].m_out));
save_item(NAME(m_port[0].m_ddr));
save_item(NAME(m_port[1].m_in));
save_item(NAME(m_port[1].m_out));
save_item(NAME(m_port[1].m_ddr));
state_save_register_device_item(this, 0, m_irqstate);
state_save_register_device_item(this, 0, m_irqenable);
save_item(NAME(m_irqstate));
save_item(NAME(m_irqenable));
state_save_register_device_item(this, 0, m_pa7dir);
state_save_register_device_item(this, 0, m_pa7prev);
save_item(NAME(m_pa7dir));
save_item(NAME(m_pa7prev));
state_save_register_device_item(this, 0, m_timershift);
state_save_register_device_item(this, 0, m_timerstate);
save_item(NAME(m_timershift));
save_item(NAME(m_timerstate));
}

64
src/emu/machine/6821pia.c
View File

@ -142,38 +142,38 @@ void pia6821_device::device_start()
devcb_resolve_write_line(&m_irq_a_func, &m_config.m_irq_a_func, this);
devcb_resolve_write_line(&m_irq_b_func, &m_config.m_irq_b_func, this);
state_save_register_device_item(this, 0, m_in_a);
state_save_register_device_item(this, 0, m_in_ca1);
state_save_register_device_item(this, 0, m_in_ca2);
state_save_register_device_item(this, 0, m_out_a);
state_save_register_device_item(this, 0, m_out_ca2);
state_save_register_device_item(this, 0, m_port_a_z_mask);
state_save_register_device_item(this, 0, m_ddr_a);
state_save_register_device_item(this, 0, m_ctl_a);
state_save_register_device_item(this, 0, m_irq_a1);
state_save_register_device_item(this, 0, m_irq_a2);
state_save_register_device_item(this, 0, m_irq_a_state);
state_save_register_device_item(this, 0, m_in_b);
state_save_register_device_item(this, 0, m_in_cb1);
state_save_register_device_item(this, 0, m_in_cb2);
state_save_register_device_item(this, 0, m_out_b);
state_save_register_device_item(this, 0, m_out_cb2);
state_save_register_device_item(this, 0, m_last_out_cb2_z);
state_save_register_device_item(this, 0, m_ddr_b);
state_save_register_device_item(this, 0, m_ctl_b);
state_save_register_device_item(this, 0, m_irq_b1);
state_save_register_device_item(this, 0, m_irq_b2);
state_save_register_device_item(this, 0, m_irq_b_state);
state_save_register_device_item(this, 0, m_in_a_pushed);
state_save_register_device_item(this, 0, m_out_a_needs_pulled);
state_save_register_device_item(this, 0, m_in_ca1_pushed);
state_save_register_device_item(this, 0, m_in_ca2_pushed);
state_save_register_device_item(this, 0, m_out_ca2_needs_pulled);
state_save_register_device_item(this, 0, m_in_b_pushed);
state_save_register_device_item(this, 0, m_out_b_needs_pulled);
state_save_register_device_item(this, 0, m_in_cb1_pushed);
state_save_register_device_item(this, 0, m_in_cb2_pushed);
state_save_register_device_item(this, 0, m_out_cb2_needs_pulled);
save_item(NAME(m_in_a));
save_item(NAME(m_in_ca1));
save_item(NAME(m_in_ca2));
save_item(NAME(m_out_a));
save_item(NAME(m_out_ca2));
save_item(NAME(m_port_a_z_mask));
save_item(NAME(m_ddr_a));
save_item(NAME(m_ctl_a));
save_item(NAME(m_irq_a1));
save_item(NAME(m_irq_a2));
save_item(NAME(m_irq_a_state));
save_item(NAME(m_in_b));
save_item(NAME(m_in_cb1));
save_item(NAME(m_in_cb2));
save_item(NAME(m_out_b));
save_item(NAME(m_out_cb2));
save_item(NAME(m_last_out_cb2_z));
save_item(NAME(m_ddr_b));
save_item(NAME(m_ctl_b));
save_item(NAME(m_irq_b1));
save_item(NAME(m_irq_b2));
save_item(NAME(m_irq_b_state));
save_item(NAME(m_in_a_pushed));
save_item(NAME(m_out_a_needs_pulled));
save_item(NAME(m_in_ca1_pushed));
save_item(NAME(m_in_ca2_pushed));
save_item(NAME(m_out_ca2_needs_pulled));
save_item(NAME(m_in_b_pushed));
save_item(NAME(m_out_b_needs_pulled));
save_item(NAME(m_in_cb1_pushed));
save_item(NAME(m_in_cb2_pushed));
save_item(NAME(m_out_cb2_needs_pulled));
}

36
src/emu/machine/6840ptm.c
View File

@ -144,25 +144,25 @@ void ptm6840_device::device_start()
devcb_resolve_write_line(&m_irq_func, &m_config.m_irq_func, this);
/* register for state saving */
state_save_register_device_item(this, 0, m_lsb_buffer);
state_save_register_device_item(this, 0, m_msb_buffer);
state_save_register_device_item(this, 0, m_status_read_since_int);
state_save_register_device_item(this, 0, m_status_reg);
state_save_register_device_item(this, 0, m_t3_divisor);
state_save_register_device_item(this, 0, m_t3_scaler);
state_save_register_device_item(this, 0, m_internal_clock);
state_save_register_device_item(this, 0, m_IRQ);
save_item(NAME(m_lsb_buffer));
save_item(NAME(m_msb_buffer));
save_item(NAME(m_status_read_since_int));
save_item(NAME(m_status_reg));
save_item(NAME(m_t3_divisor));
save_item(NAME(m_t3_scaler));
save_item(NAME(m_internal_clock));
save_item(NAME(m_IRQ));
state_save_register_device_item_array(this, 0, m_control_reg);
state_save_register_device_item_array(this, 0, m_output);
state_save_register_device_item_array(this, 0, m_gate);
state_save_register_device_item_array(this, 0, m_clk);
state_save_register_device_item_array(this, 0, m_mode);
state_save_register_device_item_array(this, 0, m_fired);
state_save_register_device_item_array(this, 0, m_enabled);
state_save_register_device_item_array(this, 0, m_external_clock);
state_save_register_device_item_array(this, 0, m_counter);
state_save_register_device_item_array(this, 0, m_latch);
save_item(NAME(m_control_reg));
save_item(NAME(m_output));
save_item(NAME(m_gate));
save_item(NAME(m_clk));
save_item(NAME(m_mode));
save_item(NAME(m_fired));
save_item(NAME(m_enabled));
save_item(NAME(m_external_clock));
save_item(NAME(m_counter));
save_item(NAME(m_latch));
}

44
src/emu/machine/6850acia.c
View File

@ -125,29 +125,29 @@ void acia6850_device::device_start()
m_rx_timer->reset();
m_tx_timer->reset();
state_save_register_device_item(this, 0, m_ctrl);
state_save_register_device_item(this, 0, m_status);
state_save_register_device_item(this, 0, m_rx_clock);
state_save_register_device_item(this, 0, m_tx_clock);
state_save_register_device_item(this, 0, m_rx_counter);
state_save_register_device_item(this, 0, m_tx_counter);
state_save_register_device_item(this, 0, m_rx_shift);
state_save_register_device_item(this, 0, m_tx_shift);
state_save_register_device_item(this, 0, m_rdr);
state_save_register_device_item(this, 0, m_tdr);
state_save_register_device_item(this, 0, m_rx_bits);
state_save_register_device_item(this, 0, m_tx_bits);
state_save_register_device_item(this, 0, m_rx_parity);
state_save_register_device_item(this, 0, m_tx_parity);
state_save_register_device_item(this, 0, m_tx_int);
save_item(NAME(m_ctrl));
save_item(NAME(m_status));
save_item(NAME(m_rx_clock));
save_item(NAME(m_tx_clock));
save_item(NAME(m_rx_counter));
save_item(NAME(m_tx_counter));
save_item(NAME(m_rx_shift));
save_item(NAME(m_tx_shift));
save_item(NAME(m_rdr));
save_item(NAME(m_tdr));
save_item(NAME(m_rx_bits));
save_item(NAME(m_tx_bits));
save_item(NAME(m_rx_parity));
save_item(NAME(m_tx_parity));
save_item(NAME(m_tx_int));
state_save_register_device_item(this, 0, m_divide);
state_save_register_device_item(this, 0, m_overrun);
state_save_register_device_item(this, 0, m_reset);
state_save_register_device_item(this, 0, m_first_reset);
state_save_register_device_item(this, 0, m_rts);
state_save_register_device_item(this, 0, m_brk);
state_save_register_device_item(this, 0, m_status_read);
save_item(NAME(m_divide));
save_item(NAME(m_overrun));
save_item(NAME(m_reset));
save_item(NAME(m_first_reset));
save_item(NAME(m_rts));
save_item(NAME(m_brk));
save_item(NAME(m_status_read));
}

74
src/emu/machine/68681.c
View File

@ -714,45 +714,45 @@ static DEVICE_START(duart68681)
duart68681->channel[1].tx_timer = device->machine->scheduler().timer_alloc(FUNC(tx_timer_callback), (void*)device);
duart68681->duart_timer = device->machine->scheduler().timer_alloc(FUNC(duart_timer_callback), (void*)device);
state_save_register_device_item(device, 0, duart68681->ACR);
state_save_register_device_item(device, 0, duart68681->IMR);
state_save_register_device_item(device, 0, duart68681->ISR);
state_save_register_device_item(device, 0, duart68681->IVR);
state_save_register_device_item(device, 0, duart68681->OPCR);
state_save_register_device_item(device, 0, duart68681->CTR);
state_save_register_device_item(device, 0, duart68681->IP_last_state);
device->save_item(NAME(duart68681->ACR));
device->save_item(NAME(duart68681->IMR));
device->save_item(NAME(duart68681->ISR));
device->save_item(NAME(duart68681->IVR));
device->save_item(NAME(duart68681->OPCR));
device->save_item(NAME(duart68681->CTR));
device->save_item(NAME(duart68681->IP_last_state));
state_save_register_device_item(device, 0, duart68681->channel[0].CR);
state_save_register_device_item(device, 0, duart68681->channel[0].CSR);
state_save_register_device_item(device, 0, duart68681->channel[0].MR1);
state_save_register_device_item(device, 0, duart68681->channel[0].MR2);
state_save_register_device_item(device, 0, duart68681->channel[0].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].SR);
state_save_register_device_item(device, 0, duart68681->channel[0].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[0].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_ready);
device->save_item(NAME(duart68681->channel[0].CR));
device->save_item(NAME(duart68681->channel[0].CSR));
device->save_item(NAME(duart68681->channel[0].MR1));
device->save_item(NAME(duart68681->channel[0].MR2));
device->save_item(NAME(duart68681->channel[0].MR_ptr));
device->save_item(NAME(duart68681->channel[0].SR));
device->save_item(NAME(duart68681->channel[0].baud_rate));
device->save_item(NAME(duart68681->channel[0].rx_enabled));
device->save_item(NAME(duart68681->channel[0].rx_fifo));
device->save_item(NAME(duart68681->channel[0].rx_fifo_read_ptr));
device->save_item(NAME(duart68681->channel[0].rx_fifo_write_ptr));
device->save_item(NAME(duart68681->channel[0].rx_fifo_num));
device->save_item(NAME(duart68681->channel[0].tx_enabled));
device->save_item(NAME(duart68681->channel[0].tx_data));
device->save_item(NAME(duart68681->channel[0].tx_ready));
state_save_register_device_item(device, 0, duart68681->channel[1].CR);
state_save_register_device_item(device, 0, duart68681->channel[1].CSR);
state_save_register_device_item(device, 0, duart68681->channel[1].MR1);
state_save_register_device_item(device, 0, duart68681->channel[1].MR2);
state_save_register_device_item(device, 0, duart68681->channel[1].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].SR);
state_save_register_device_item(device, 0, duart68681->channel[1].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[1].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_ready);
device->save_item(NAME(duart68681->channel[1].CR));
device->save_item(NAME(duart68681->channel[1].CSR));
device->save_item(NAME(duart68681->channel[1].MR1));
device->save_item(NAME(duart68681->channel[1].MR2));
device->save_item(NAME(duart68681->channel[1].MR_ptr));
device->save_item(NAME(duart68681->channel[1].SR));
device->save_item(NAME(duart68681->channel[1].baud_rate));
device->save_item(NAME(duart68681->channel[1].rx_enabled));
device->save_item(NAME(duart68681->channel[1].rx_fifo));
device->save_item(NAME(duart68681->channel[1].rx_fifo_read_ptr));
device->save_item(NAME(duart68681->channel[1].rx_fifo_write_ptr));
device->save_item(NAME(duart68681->channel[1].rx_fifo_num));
device->save_item(NAME(duart68681->channel[1].tx_enabled));
device->save_item(NAME(duart68681->channel[1].tx_data));
device->save_item(NAME(duart68681->channel[1].tx_ready));
}
/*-------------------------------------------------

6
src/emu/machine/74123.c
View File

@ -114,9 +114,9 @@ void ttl74123_device::device_start()
m_clear = m_config.m_clear;
/* register for state saving */
state_save_register_device_item(this, 0, m_a);
state_save_register_device_item(this, 0, m_b);
state_save_register_device_item(this, 0, m_clear);
save_item(NAME(m_a));
save_item(NAME(m_b));
save_item(NAME(m_clear));
}

16
src/emu/machine/74148.c
View File

@ -184,14 +184,14 @@ static DEVICE_START( ttl74148 )
ttl74148_state *state = get_safe_token(device);
state->output_cb = config->output_cb;
state_save_register_device_item_array(device, 0, state->input_lines);
state_save_register_device_item(device, 0, state->enable_input);
state_save_register_device_item(device, 0, state->output);
state_save_register_device_item(device, 0, state->output_valid);
state_save_register_device_item(device, 0, state->enable_output);
state_save_register_device_item(device, 0, state->last_output);
state_save_register_device_item(device, 0, state->last_output_valid);
state_save_register_device_item(device, 0, state->last_enable_output);
device->save_item(NAME(state->input_lines));
device->save_item(NAME(state->enable_input));
device->save_item(NAME(state->output));
device->save_item(NAME(state->output_valid));
device->save_item(NAME(state->enable_output));
device->save_item(NAME(state->last_output));
device->save_item(NAME(state->last_output_valid));
device->save_item(NAME(state->last_enable_output));
}

24
src/emu/machine/74153.c
View File

@ -140,18 +140,18 @@ static DEVICE_START( ttl74153 )
ttl74153_state *state = get_safe_token(device);
state->output_cb = config->output_cb;
state_save_register_device_item_array(device, 0, state->enable);
state_save_register_device_item_array(device, 0, state->last_output);
state_save_register_device_item(device, 0, state->input_lines[0][0]);
state_save_register_device_item(device, 0, state->input_lines[0][1]);
state_save_register_device_item(device, 0, state->input_lines[0][2]);
state_save_register_device_item(device, 0, state->input_lines[0][3]);
state_save_register_device_item(device, 0, state->input_lines[1][0]);
state_save_register_device_item(device, 0, state->input_lines[1][1]);
state_save_register_device_item(device, 0, state->input_lines[1][2]);
state_save_register_device_item(device, 0, state->input_lines[1][3]);
state_save_register_device_item(device, 0, state->a);
state_save_register_device_item(device, 0, state->b);
device->save_item(NAME(state->enable));
device->save_item(NAME(state->last_output));
device->save_item(NAME(state->input_lines[0][0]));
device->save_item(NAME(state->input_lines[0][1]));
device->save_item(NAME(state->input_lines[0][2]));
device->save_item(NAME(state->input_lines[0][3]));
device->save_item(NAME(state->input_lines[1][0]));
device->save_item(NAME(state->input_lines[1][1]));
device->save_item(NAME(state->input_lines[1][2]));
device->save_item(NAME(state->input_lines[1][3]));
device->save_item(NAME(state->a));
device->save_item(NAME(state->b));
}

18
src/emu/machine/7474.c
View File

@ -155,15 +155,15 @@ ttl7474_device::ttl7474_device(running_machine &_machine, const ttl7474_device_c
void ttl7474_device::device_start()
{
state_save_register_device_item(this, 0, m_clear);
state_save_register_device_item(this, 0, m_preset);
state_save_register_device_item(this, 0, m_clk);
state_save_register_device_item(this, 0, m_d);
state_save_register_device_item(this, 0, m_output);
state_save_register_device_item(this, 0, m_output_comp);
state_save_register_device_item(this, 0, m_last_clock);
state_save_register_device_item(this, 0, m_last_output);
state_save_register_device_item(this, 0, m_last_output_comp);
save_item(NAME(m_clear));
save_item(NAME(m_preset));
save_item(NAME(m_clk));
save_item(NAME(m_d));
save_item(NAME(m_output));
save_item(NAME(m_output_comp));
save_item(NAME(m_last_clock));
save_item(NAME(m_last_output));
save_item(NAME(m_last_output_comp));
devcb_resolve_write_line(&m_output_cb, &m_config.m_output_cb, this);
devcb_resolve_write_line(&m_comp_output_cb, &m_config.m_comp_output_cb, this);

36
src/emu/machine/8255ppi.c
View File

@ -161,24 +161,24 @@ void ppi8255_device::device_start()
devcb_resolve_write8(&m_port_write[2], &m_config.m_port_c_write, this);
/* register for state saving */
state_save_register_device_item(this, 0, m_group_a_mode);
state_save_register_device_item(this, 0, m_group_b_mode);
state_save_register_device_item(this, 0, m_port_a_dir);
state_save_register_device_item(this, 0, m_port_b_dir);
state_save_register_device_item(this, 0, m_port_ch_dir);
state_save_register_device_item(this, 0, m_port_cl_dir);
state_save_register_device_item(this, 0, m_obf_a);
state_save_register_device_item(this, 0, m_obf_b);
state_save_register_device_item(this, 0, m_ibf_a);
state_save_register_device_item(this, 0, m_ibf_b);
state_save_register_device_item(this, 0, m_inte_a);
state_save_register_device_item(this, 0, m_inte_b);
state_save_register_device_item(this, 0, m_inte_1);
state_save_register_device_item(this, 0, m_inte_2);
state_save_register_device_item_array(this, 0, m_in_mask);
state_save_register_device_item_array(this, 0, m_out_mask);
state_save_register_device_item_array(this, 0, m_read);
state_save_register_device_item_array(this, 0, m_latch);
save_item(NAME(m_group_a_mode));
save_item(NAME(m_group_b_mode));
save_item(NAME(m_port_a_dir));
save_item(NAME(m_port_b_dir));
save_item(NAME(m_port_ch_dir));
save_item(NAME(m_port_cl_dir));
save_item(NAME(m_obf_a));
save_item(NAME(m_obf_b));
save_item(NAME(m_ibf_a));
save_item(NAME(m_ibf_b));
save_item(NAME(m_inte_a));
save_item(NAME(m_inte_b));
save_item(NAME(m_inte_1));
save_item(NAME(m_inte_2));
save_item(NAME(m_in_mask));
save_item(NAME(m_out_mask));
save_item(NAME(m_read));
save_item(NAME(m_latch));
}

18
src/emu/machine/8257dma.c
View File

@ -141,15 +141,15 @@ void i8257_device::device_start()
m_msbflip_timer = timer_alloc(TIMER_MSBFLIP);
/* register for state saving */
state_save_register_device_item_array(this, 0, m_address);
state_save_register_device_item_array(this, 0, m_count);
state_save_register_device_item_array(this, 0, m_rwmode);
state_save_register_device_item_array(this, 0, m_registers);
state_save_register_device_item(this, 0, m_mode);
state_save_register_device_item(this, 0, m_rr);
state_save_register_device_item(this, 0, m_msb);
state_save_register_device_item(this, 0, m_drq);
state_save_register_device_item(this, 0, m_status);
save_item(NAME(m_address));
save_item(NAME(m_count));
save_item(NAME(m_rwmode));
save_item(NAME(m_registers));
save_item(NAME(m_mode));
save_item(NAME(m_rr));
save_item(NAME(m_msb));
save_item(NAME(m_drq));
save_item(NAME(m_status));
}

28
src/emu/machine/adc083x.c
View File

@ -475,20 +475,20 @@ static DEVICE_START( adc0831 )
adc083x->input_callback_r = intf->input_callback_r;
/* register for state saving */
state_save_register_device_item( device, 0, adc083x->cs );
state_save_register_device_item( device, 0, adc083x->clk );
state_save_register_device_item( device, 0, adc083x->di );
state_save_register_device_item( device, 0, adc083x->se );
state_save_register_device_item( device, 0, adc083x->sars );
state_save_register_device_item( device, 0, adc083x->_do );
state_save_register_device_item( device, 0, adc083x->sgl );
state_save_register_device_item( device, 0, adc083x->odd );
state_save_register_device_item( device, 0, adc083x->sel1 );
state_save_register_device_item( device, 0, adc083x->sel0 );
state_save_register_device_item( device, 0, adc083x->state );
state_save_register_device_item( device, 0, adc083x->bit );
state_save_register_device_item( device, 0, adc083x->output );
state_save_register_device_item( device, 0, adc083x->mux_bits );
device->save_item( NAME(adc083x->cs) );
device->save_item( NAME(adc083x->clk) );
device->save_item( NAME(adc083x->di) );
device->save_item( NAME(adc083x->se) );
device->save_item( NAME(adc083x->sars) );
device->save_item( NAME(adc083x->_do) );
device->save_item( NAME(adc083x->sgl) );
device->save_item( NAME(adc083x->odd) );
device->save_item( NAME(adc083x->sel1) );
device->save_item( NAME(adc083x->sel0) );
device->save_item( NAME(adc083x->state) );
device->save_item( NAME(adc083x->bit) );
device->save_item( NAME(adc083x->output) );
device->save_item( NAME(adc083x->mux_bits) );
}

14
src/emu/machine/adc1038.c
View File

@ -139,13 +139,13 @@ static DEVICE_START( adc1038 )
adc1038->gticlub_hack = intf->gticlub_hack;
adc1038->input_callback_r = intf->input_callback_r;
state_save_register_device_item(device, 0, adc1038->cycle);
state_save_register_device_item(device, 0, adc1038->clk);
state_save_register_device_item(device, 0, adc1038->adr);
state_save_register_device_item(device, 0, adc1038->data_in);
state_save_register_device_item(device, 0, adc1038->data_out);
state_save_register_device_item(device, 0, adc1038->adc_data);
state_save_register_device_item(device, 0, adc1038->sars);
device->save_item(NAME(adc1038->cycle));
device->save_item(NAME(adc1038->clk));
device->save_item(NAME(adc1038->adr));
device->save_item(NAME(adc1038->data_in));
device->save_item(NAME(adc1038->data_out));
device->save_item(NAME(adc1038->adc_data));
device->save_item(NAME(adc1038->sars));
}
static DEVICE_RESET( adc1038 )

24
src/emu/machine/adc1213x.c
View File

@ -319,18 +319,18 @@ static DEVICE_START( adc12138 )
adc1213x->input_callback_r = intf->input_callback_r;
/* register for state saving */
state_save_register_device_item(device, 0, adc1213x->cycle);
state_save_register_device_item(device, 0, adc1213x->data_out);
state_save_register_device_item(device, 0, adc1213x->data_in);
state_save_register_device_item(device, 0, adc1213x->conv_mode);
state_save_register_device_item(device, 0, adc1213x->auto_cal);
state_save_register_device_item(device, 0, adc1213x->auto_zero);
state_save_register_device_item(device, 0, adc1213x->acq_time);
state_save_register_device_item(device, 0, adc1213x->data_out_sign);
state_save_register_device_item(device, 0, adc1213x->mode);
state_save_register_device_item(device, 0, adc1213x->input_shift_reg);
state_save_register_device_item(device, 0, adc1213x->output_shift_reg);
state_save_register_device_item(device, 0, adc1213x->end_conv);
device->save_item(NAME(adc1213x->cycle));
device->save_item(NAME(adc1213x->data_out));
device->save_item(NAME(adc1213x->data_in));
device->save_item(NAME(adc1213x->conv_mode));
device->save_item(NAME(adc1213x->auto_cal));
device->save_item(NAME(adc1213x->auto_zero));
device->save_item(NAME(adc1213x->acq_time));
device->save_item(NAME(adc1213x->data_out_sign));
device->save_item(NAME(adc1213x->mode));
device->save_item(NAME(adc1213x->input_shift_reg));
device->save_item(NAME(adc1213x->output_shift_reg));
device->save_item(NAME(adc1213x->end_conv));
}

Some files were not shown because too many files have changed in this diff Show More