Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-08 09:30:17 +03:00
Code Issues Actions 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); m_io = space(AS_IO);
// "core" // "core"
state_save_register_device_item(this, 0, m_core.ax0.u); save_item(NAME(m_core.ax0.u));
state_save_register_device_item(this, 0, m_core.ax1.u); save_item(NAME(m_core.ax1.u));
state_save_register_device_item(this, 0, m_core.ay0.u); save_item(NAME(m_core.ay0.u));
state_save_register_device_item(this, 0, m_core.ay1.u); save_item(NAME(m_core.ay1.u));
state_save_register_device_item(this, 0, m_core.ar.u); save_item(NAME(m_core.ar.u));
state_save_register_device_item(this, 0, m_core.af.u); save_item(NAME(m_core.af.u));
state_save_register_device_item(this, 0, m_core.mx0.u); save_item(NAME(m_core.mx0.u));
state_save_register_device_item(this, 0, m_core.mx1.u); save_item(NAME(m_core.mx1.u));
state_save_register_device_item(this, 0, m_core.my0.u); save_item(NAME(m_core.my0.u));
state_save_register_device_item(this, 0, m_core.my1.u); save_item(NAME(m_core.my1.u));
state_save_register_device_item(this, 0, m_core.mr.mr); save_item(NAME(m_core.mr.mr));
state_save_register_device_item(this, 0, m_core.mf.u); save_item(NAME(m_core.mf.u));
state_save_register_device_item(this, 0, m_core.si.u); save_item(NAME(m_core.si.u));
state_save_register_device_item(this, 0, m_core.se.u); save_item(NAME(m_core.se.u));
state_save_register_device_item(this, 0, m_core.sb.u); save_item(NAME(m_core.sb.u));
state_save_register_device_item(this, 0, m_core.sr.sr); save_item(NAME(m_core.sr.sr));
state_save_register_device_item(this, 0, m_core.zero.u); save_item(NAME(m_core.zero.u));
// "alt" // "alt"
state_save_register_device_item(this, 0, m_alt.ax0.u); save_item(NAME(m_alt.ax0.u));
state_save_register_device_item(this, 0, m_alt.ax1.u); save_item(NAME(m_alt.ax1.u));
state_save_register_device_item(this, 0, m_alt.ay0.u); save_item(NAME(m_alt.ay0.u));
state_save_register_device_item(this, 0, m_alt.ay1.u); save_item(NAME(m_alt.ay1.u));
state_save_register_device_item(this, 0, m_alt.ar.u); save_item(NAME(m_alt.ar.u));
state_save_register_device_item(this, 0, m_alt.af.u); save_item(NAME(m_alt.af.u));
state_save_register_device_item(this, 0, m_alt.mx0.u); save_item(NAME(m_alt.mx0.u));
state_save_register_device_item(this, 0, m_alt.mx1.u); save_item(NAME(m_alt.mx1.u));
state_save_register_device_item(this, 0, m_alt.my0.u); save_item(NAME(m_alt.my0.u));
state_save_register_device_item(this, 0, m_alt.my1.u); save_item(NAME(m_alt.my1.u));
state_save_register_device_item(this, 0, m_alt.mr.mr); save_item(NAME(m_alt.mr.mr));
state_save_register_device_item(this, 0, m_alt.mf.u); save_item(NAME(m_alt.mf.u));
state_save_register_device_item(this, 0, m_alt.si.u); save_item(NAME(m_alt.si.u));
state_save_register_device_item(this, 0, m_alt.se.u); save_item(NAME(m_alt.se.u));
state_save_register_device_item(this, 0, m_alt.sb.u); save_item(NAME(m_alt.sb.u));
state_save_register_device_item(this, 0, m_alt.sr.sr); save_item(NAME(m_alt.sr.sr));
state_save_register_device_item(this, 0, m_alt.zero.u); save_item(NAME(m_alt.zero.u));
state_save_register_device_item_array(this, 0, m_i); save_item(NAME(m_i));
state_save_register_device_item_array(this, 0, m_m); save_item(NAME(m_m));
state_save_register_device_item_array(this, 0, m_l); save_item(NAME(m_l));
state_save_register_device_item_array(this, 0, m_lmask); save_item(NAME(m_lmask));
state_save_register_device_item_array(this, 0, m_base); save_item(NAME(m_base));
state_save_register_device_item(this, 0, m_px); save_item(NAME(m_px));
state_save_register_device_item(this, 0, m_pc); save_item(NAME(m_pc));
state_save_register_device_item(this, 0, m_ppc); save_item(NAME(m_ppc));
state_save_register_device_item(this, 0, m_loop); save_item(NAME(m_loop));
state_save_register_device_item(this, 0, m_loop_condition); save_item(NAME(m_loop_condition));
state_save_register_device_item(this, 0, m_cntr); save_item(NAME(m_cntr));
state_save_register_device_item(this, 0, m_astat); save_item(NAME(m_astat));
state_save_register_device_item(this, 0, m_sstat); save_item(NAME(m_sstat));
state_save_register_device_item(this, 0, m_mstat); save_item(NAME(m_mstat));
state_save_register_device_item(this, 0, m_mstat_prev); save_item(NAME(m_mstat_prev));
state_save_register_device_item(this, 0, m_astat_clear); save_item(NAME(m_astat_clear));
state_save_register_device_item(this, 0, m_idle); save_item(NAME(m_idle));
state_save_register_device_item_array(this, 0, m_loop_stack); save_item(NAME(m_loop_stack));
state_save_register_device_item_array(this, 0, m_cntr_stack); save_item(NAME(m_cntr_stack));
state_save_register_device_item_array(this, 0, m_pc_stack); save_item(NAME(m_pc_stack));
state_save_register_device_item_2d_array(this, 0, m_stat_stack); save_item(NAME(m_stat_stack));
state_save_register_device_item(this, 0, m_pc_sp); save_item(NAME(m_pc_sp));
state_save_register_device_item(this, 0, m_cntr_sp); save_item(NAME(m_cntr_sp));
state_save_register_device_item(this, 0, m_stat_sp); save_item(NAME(m_stat_sp));
state_save_register_device_item(this, 0, m_loop_sp); save_item(NAME(m_loop_sp));
state_save_register_device_item(this, 0, m_flagout); save_item(NAME(m_flagout));
state_save_register_device_item(this, 0, m_flagin); save_item(NAME(m_flagin));
state_save_register_device_item(this, 0, m_fl0); save_item(NAME(m_fl0));
state_save_register_device_item(this, 0, m_fl1); save_item(NAME(m_fl1));
state_save_register_device_item(this, 0, m_fl2); save_item(NAME(m_fl2));
state_save_register_device_item(this, 0, m_idma_addr); save_item(NAME(m_idma_addr));
state_save_register_device_item(this, 0, m_idma_cache); save_item(NAME(m_idma_cache));
state_save_register_device_item(this, 0, m_idma_offs); save_item(NAME(m_idma_offs));
state_save_register_device_item(this, 0, m_imask); save_item(NAME(m_imask));
state_save_register_device_item(this, 0, m_icntl); save_item(NAME(m_icntl));
state_save_register_device_item(this, 0, m_ifc); save_item(NAME(m_ifc));
state_save_register_device_item_array(this, 0, m_irq_state); save_item(NAME(m_irq_state));
state_save_register_device_item_array(this, 0, m_irq_latch); save_item(NAME(m_irq_latch));
// register state with the debugger // register state with the debugger
state_add(ADSP2100_PC, "PC", m_pc); 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->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct(); cpustate->direct = &cpustate->program->direct();
state_save_register_device_item_array(device, 0, cpustate->RAM); device->save_item(NAME(cpustate->RAM));
state_save_register_device_item(device, 0, cpustate->PREVPC); device->save_item(NAME(cpustate->PREVPC));
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->regPtr); device->save_item(NAME(cpustate->regPtr));
state_save_register_device_item(device, 0, cpustate->zf); device->save_item(NAME(cpustate->zf));
state_save_register_device_item(device, 0, cpustate->cf); device->save_item(NAME(cpustate->cf));
state_save_register_device_item(device, 0, cpustate->mb); device->save_item(NAME(cpustate->mb));
#if HANDLE_HALT_LINE #if HANDLE_HALT_LINE
state_save_register_device_item(device, 0, cpustate->halt); device->save_item(NAME(cpustate->halt));
#endif #endif
state_save_register_device_item(device, 0, cpustate->IX0); device->save_item(NAME(cpustate->IX0));
state_save_register_device_item(device, 0, cpustate->IX1); device->save_item(NAME(cpustate->IX1));
state_save_register_device_item(device, 0, cpustate->IX2); device->save_item(NAME(cpustate->IX2));
state_save_register_device_item(device, 0, cpustate->LP0); device->save_item(NAME(cpustate->LP0));
state_save_register_device_item(device, 0, cpustate->LP1); device->save_item(NAME(cpustate->LP1));
state_save_register_device_item(device, 0, cpustate->LP2); device->save_item(NAME(cpustate->LP2));
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->B); device->save_item(NAME(cpustate->B));
state_save_register_device_item(device, 0, cpustate->retptr); device->save_item(NAME(cpustate->retptr));
state_save_register_device_item(device, 0, cpustate->savec); device->save_item(NAME(cpustate->savec));
state_save_register_device_item(device, 0, cpustate->savez); device->save_item(NAME(cpustate->savez));
} }
/**************************************************************************** /****************************************************************************
* Reset registers to their initial values * 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; am29000->cfg = (PRL_AM29000 | PRL_REV_D) << CFG_PRL_SHIFT;
/* Register state for saving */ /* Register state for saving */
state_save_register_device_item(device, 0, am29000->icount); device->save_item(NAME(am29000->icount));
state_save_register_device_item(device, 0, am29000->pc); device->save_item(NAME(am29000->pc));
state_save_register_device_item_array(device, 0, am29000->r); device->save_item(NAME(am29000->r));
state_save_register_device_item_array(device, 0, am29000->tlb); device->save_item(NAME(am29000->tlb));
state_save_register_device_item(device, 0, am29000->vab); device->save_item(NAME(am29000->vab));
state_save_register_device_item(device, 0, am29000->ops); device->save_item(NAME(am29000->ops));
state_save_register_device_item(device, 0, am29000->cps); device->save_item(NAME(am29000->cps));
state_save_register_device_item(device, 0, am29000->cfg); device->save_item(NAME(am29000->cfg));
state_save_register_device_item(device, 0, am29000->cha); device->save_item(NAME(am29000->cha));
state_save_register_device_item(device, 0, am29000->chd); device->save_item(NAME(am29000->chd));
state_save_register_device_item(device, 0, am29000->chc); device->save_item(NAME(am29000->chc));
state_save_register_device_item(device, 0, am29000->rbp); device->save_item(NAME(am29000->rbp));
state_save_register_device_item(device, 0, am29000->tmc); device->save_item(NAME(am29000->tmc));
state_save_register_device_item(device, 0, am29000->tmr); device->save_item(NAME(am29000->tmr));
state_save_register_device_item(device, 0, am29000->pc0); device->save_item(NAME(am29000->pc0));
state_save_register_device_item(device, 0, am29000->pc1); device->save_item(NAME(am29000->pc1));
state_save_register_device_item(device, 0, am29000->pc2); device->save_item(NAME(am29000->pc2));
state_save_register_device_item(device, 0, am29000->mmu); device->save_item(NAME(am29000->mmu));
state_save_register_device_item(device, 0, am29000->lru); device->save_item(NAME(am29000->lru));
state_save_register_device_item(device, 0, am29000->ipc); device->save_item(NAME(am29000->ipc));
state_save_register_device_item(device, 0, am29000->ipa); device->save_item(NAME(am29000->ipa));
state_save_register_device_item(device, 0, am29000->ipb); device->save_item(NAME(am29000->ipb));
state_save_register_device_item(device, 0, am29000->q); device->save_item(NAME(am29000->q));
state_save_register_device_item(device, 0, am29000->alu); device->save_item(NAME(am29000->alu));
state_save_register_device_item(device, 0, am29000->fpe); device->save_item(NAME(am29000->fpe));
state_save_register_device_item(device, 0, am29000->inte); device->save_item(NAME(am29000->inte));
state_save_register_device_item(device, 0, am29000->fps); device->save_item(NAME(am29000->fps));
state_save_register_device_item(device, 0, am29000->exceptions); device->save_item(NAME(am29000->exceptions));
state_save_register_device_item_array(device, 0, am29000->exception_queue); device->save_item(NAME(am29000->exception_queue));
state_save_register_device_item(device, 0, am29000->irq_active); device->save_item(NAME(am29000->irq_active));
state_save_register_device_item(device, 0, am29000->irq_lines); device->save_item(NAME(am29000->irq_lines));
state_save_register_device_item(device, 0, am29000->exec_ir); device->save_item(NAME(am29000->exec_ir));
state_save_register_device_item(device, 0, am29000->next_ir); device->save_item(NAME(am29000->next_ir));
state_save_register_device_item(device, 0, am29000->pl_flags); device->save_item(NAME(am29000->pl_flags));
state_save_register_device_item(device, 0, am29000->next_pl_flags); device->save_item(NAME(am29000->next_pl_flags));
state_save_register_device_item(device, 0, am29000->iret_pc); device->save_item(NAME(am29000->iret_pc));
state_save_register_device_item(device, 0, am29000->exec_pc); device->save_item(NAME(am29000->exec_pc));
state_save_register_device_item(device, 0, am29000->next_pc); device->save_item(NAME(am29000->next_pc));
} }
static CPU_RESET( am29000 ) 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->program = device->space(AS_PROGRAM);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
state_save_register_device_item(device, 0, cpustate->cr); device->save_item(NAME(cpustate->cr));
state_save_register_device_item(device, 0, cpustate->ml); device->save_item(NAME(cpustate->ml));
state_save_register_device_item(device, 0, cpustate->working_store); device->save_item(NAME(cpustate->working_store));
state_save_register_device_item(device, 0, cpustate->current_word); device->save_item(NAME(cpustate->current_word));
state_save_register_device_item(device, 0, cpustate->running); device->save_item(NAME(cpustate->running));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
} }
static CPU_RESET( apexc ) 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->program = device->space(AS_PROGRAM);
cpustate->endian = ENDIANNESS_LITTLE; cpustate->endian = ENDIANNESS_LITTLE;
state_save_register_device_item_array(device, 0, cpustate->sArmRegister); device->save_item(NAME(cpustate->sArmRegister));
state_save_register_device_item_array(device, 0, cpustate->coproRegister); device->save_item(NAME(cpustate->coproRegister));
state_save_register_device_item(device, 0, cpustate->pendingIrq); device->save_item(NAME(cpustate->pendingIrq));
state_save_register_device_item(device, 0, cpustate->pendingFiq); device->save_item(NAME(cpustate->pendingFiq));
} }
@ -547,10 +547,10 @@ static CPU_INIT( arm_be )
cpustate->program = device->space(AS_PROGRAM); cpustate->program = device->space(AS_PROGRAM);
cpustate->endian = ENDIANNESS_BIG; cpustate->endian = ENDIANNESS_BIG;
state_save_register_device_item_array(device, 0, cpustate->sArmRegister); device->save_item(NAME(cpustate->sArmRegister));
state_save_register_device_item_array(device, 0, cpustate->coproRegister); device->save_item(NAME(cpustate->coproRegister));
state_save_register_device_item(device, 0, cpustate->pendingIrq); device->save_item(NAME(cpustate->pendingIrq));
state_save_register_device_item(device, 0, cpustate->pendingFiq); 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); arm_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->sArmRegister); device->save_item(NAME(cpustate->sArmRegister));
state_save_register_device_item(device, 0, cpustate->pendingIrq); device->save_item(NAME(cpustate->pendingIrq));
state_save_register_device_item(device, 0, cpustate->pendingFiq); device->save_item(NAME(cpustate->pendingFiq));
state_save_register_device_item(device, 0, cpustate->pendingAbtD); device->save_item(NAME(cpustate->pendingAbtD));
state_save_register_device_item(device, 0, cpustate->pendingAbtP); device->save_item(NAME(cpustate->pendingAbtP));
state_save_register_device_item(device, 0, cpustate->pendingUnd); device->save_item(NAME(cpustate->pendingUnd));
state_save_register_device_item(device, 0, cpustate->pendingSwi); device->save_item(NAME(cpustate->pendingSwi));
} }
// CPU RESET // 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]); state_add(ASAP_R0 + regnum, tempstr.format("R%d", regnum), m_src2val[REGBASE + regnum]);
// register our state for saving // register our state for saving
state_save_register_device_item(this, 0, m_pc); save_item(NAME(m_pc));
state_save_register_device_item(this, 0, m_pflag); save_item(NAME(m_pflag));
state_save_register_device_item(this, 0, m_iflag); save_item(NAME(m_iflag));
state_save_register_device_item(this, 0, m_cflag); save_item(NAME(m_cflag));
state_save_register_device_item(this, 0, m_vflag); save_item(NAME(m_vflag));
state_save_register_device_item(this, 0, m_znflag); save_item(NAME(m_znflag));
state_save_register_device_item(this, 0, m_op); save_item(NAME(m_op));
state_save_register_device_item(this, 0, m_ppc); save_item(NAME(m_ppc));
state_save_register_device_item(this, 0, m_nextpc); save_item(NAME(m_nextpc));
state_save_register_device_item(this, 0, m_irq_state); save_item(NAME(m_irq_state));
// set our instruction counter // set our instruction counter
m_icountptr = &m_icount; 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); 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 ) 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->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->B); device->save_item(NAME(cpustate->B));
state_save_register_device_item(device, 0, cpustate->I); device->save_item(NAME(cpustate->I));
state_save_register_device_item(device, 0, cpustate->J); device->save_item(NAME(cpustate->J));
state_save_register_device_item(device, 0, cpustate->P); device->save_item(NAME(cpustate->P));
state_save_register_device_item(device, 0, cpustate->X); device->save_item(NAME(cpustate->X));
state_save_register_device_item(device, 0, cpustate->Y); device->save_item(NAME(cpustate->Y));
state_save_register_device_item(device, 0, cpustate->T); device->save_item(NAME(cpustate->T));
state_save_register_device_item(device, 0, cpustate->a0flag); device->save_item(NAME(cpustate->a0flag));
state_save_register_device_item(device, 0, cpustate->ncflag); device->save_item(NAME(cpustate->ncflag));
state_save_register_device_item(device, 0, cpustate->cmpacc); device->save_item(NAME(cpustate->cmpacc));
state_save_register_device_item(device, 0, cpustate->cmpval); device->save_item(NAME(cpustate->cmpval));
state_save_register_device_item(device, 0, cpustate->miflag); device->save_item(NAME(cpustate->miflag));
state_save_register_device_item(device, 0, cpustate->nextmiflag); device->save_item(NAME(cpustate->nextmiflag));
state_save_register_device_item(device, 0, cpustate->nextnextmiflag); device->save_item(NAME(cpustate->nextnextmiflag));
state_save_register_device_item(device, 0, cpustate->drflag); device->save_item(NAME(cpustate->drflag));
state_save_register_device_item(device, 0, cpustate->waiting); device->save_item(NAME(cpustate->waiting));
state_save_register_device_item(device, 0, cpustate->watchdog); 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 */ /* register for state saving */
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->prevpc); device->save_item(NAME(cpustate->prevpc));
state_save_register_device_item(device, 0, cpustate->n); device->save_item(NAME(cpustate->n));
state_save_register_device_item(device, 0, cpustate->sa); device->save_item(NAME(cpustate->sa));
state_save_register_device_item(device, 0, cpustate->sb); device->save_item(NAME(cpustate->sb));
state_save_register_device_item(device, 0, cpustate->sc); device->save_item(NAME(cpustate->sc));
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->b); device->save_item(NAME(cpustate->b));
state_save_register_device_item(device, 0, cpustate->c); device->save_item(NAME(cpustate->c));
state_save_register_device_item(device, 0, cpustate->g); device->save_item(NAME(cpustate->g));
state_save_register_device_item(device, 0, cpustate->h); device->save_item(NAME(cpustate->h));
state_save_register_device_item(device, 0, cpustate->q); device->save_item(NAME(cpustate->q));
state_save_register_device_item(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
state_save_register_device_item(device, 0, cpustate->en); device->save_item(NAME(cpustate->en));
state_save_register_device_item(device, 0, cpustate->sio); device->save_item(NAME(cpustate->sio));
state_save_register_device_item(device, 0, cpustate->skl); device->save_item(NAME(cpustate->skl));
state_save_register_device_item(device, 0, cpustate->t); device->save_item(NAME(cpustate->t));
state_save_register_device_item(device, 0, cpustate->skip); device->save_item(NAME(cpustate->skip));
state_save_register_device_item(device, 0, cpustate->skip_lbi); device->save_item(NAME(cpustate->skip_lbi));
state_save_register_device_item(device, 0, cpustate->skt_latch); device->save_item(NAME(cpustate->skt_latch));
state_save_register_device_item(device, 0, cpustate->si); device->save_item(NAME(cpustate->si));
state_save_register_device_item(device, 0, cpustate->last_skip); device->save_item(NAME(cpustate->last_skip));
state_save_register_device_item_array(device, 0, cpustate->in); device->save_item(NAME(cpustate->in));
state_save_register_device_item(device, 0, cpustate->microbus_int); device->save_item(NAME(cpustate->microbus_int));
state_save_register_device_item(device, 0, cpustate->halt); device->save_item(NAME(cpustate->halt));
state_save_register_device_item(device, 0, cpustate->idle); device->save_item(NAME(cpustate->idle));
} }
static void cop410_init_opcodes(device_t *device) 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); devcb_resolve_write_line(&m_out_tpb_func, &m_config.m_out_tpb_func, this);
// register our state for saving // register our state for saving
state_save_register_device_item(this, 0, m_op); save_item(NAME(m_op));
state_save_register_device_item(this, 0, m_flagsio); save_item(NAME(m_flagsio));
state_save_register_device_item(this, 0, m_state); save_item(NAME(m_state));
state_save_register_device_item(this, 0, m_mode); save_item(NAME(m_mode));
state_save_register_device_item(this, 0, m_pmode); save_item(NAME(m_pmode));
state_save_register_device_item(this, 0, m_irq); save_item(NAME(m_irq));
state_save_register_device_item(this, 0, m_dmain); save_item(NAME(m_dmain));
state_save_register_device_item(this, 0, m_dmaout); save_item(NAME(m_dmaout));
state_save_register_device_item_array(this, 0, m_ef); save_item(NAME(m_ef));
state_save_register_device_item(this, 0, m_d); save_item(NAME(m_d));
state_save_register_device_item(this, 0, m_b); save_item(NAME(m_b));
state_save_register_device_item_array(this, 0, m_r); save_item(NAME(m_r));
state_save_register_device_item(this, 0, m_p); save_item(NAME(m_p));
state_save_register_device_item(this, 0, m_x); save_item(NAME(m_x));
state_save_register_device_item(this, 0, m_n); save_item(NAME(m_n));
state_save_register_device_item(this, 0, m_i); save_item(NAME(m_i));
state_save_register_device_item(this, 0, m_t); save_item(NAME(m_t));
state_save_register_device_item(this, 0, m_df); save_item(NAME(m_df));
state_save_register_device_item(this, 0, m_ie); save_item(NAME(m_ie));
state_save_register_device_item(this, 0, m_q); save_item(NAME(m_q));
state_save_register_device_item(this, 0, m_icount); save_item(NAME(m_icount));
// set our instruction counter // set our instruction counter
m_icountptr = &m_icount; 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->device = device;
cpustate->program = device->space(AS_PROGRAM); cpustate->program = device->space(AS_PROGRAM);
state_save_register_device_item_array(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
state_save_register_device_item(device, 0, cpustate->flags); device->save_item(NAME(cpustate->flags));
state_save_register_device_item(device, 0, cpustate->intr_enabled); device->save_item(NAME(cpustate->intr_enabled));
state_save_register_device_item(device, 0, cpustate->intr_vector); device->save_item(NAME(cpustate->intr_vector));
state_save_register_device_item(device, 0, cpustate->reset_state); device->save_item(NAME(cpustate->reset_state));
state_save_register_device_item(device, 0, cpustate->intr_state); device->save_item(NAME(cpustate->intr_state));
state_save_register_device_item(device, 0, cpustate->intrm_state); device->save_item(NAME(cpustate->intrm_state));
state_save_register_device_item(device, 0, cpustate->reset_pending); device->save_item(NAME(cpustate->reset_pending));
state_save_register_device_item(device, 0, cpustate->intr_pending); device->save_item(NAME(cpustate->intr_pending));
state_save_register_device_item(device, 0, cpustate->intrm_pending); device->save_item(NAME(cpustate->intrm_pending));
state_save_register_device_item(device, 0, cpustate->mask_interrupts); device->save_item(NAME(cpustate->mask_interrupts));
} }
static void cp1610_set_irq_line(cp1610_state *cpustate, UINT32 irqline, int state) 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) static void cquestsnd_state_register(device_t *device)
{ {
cquestsnd_state *cpustate = get_safe_token_snd(device); cquestsnd_state *cpustate = get_safe_token_snd(device);
state_save_register_device_item_array(device, 0, cpustate->ram); device->save_item(NAME(cpustate->ram));
state_save_register_device_item(device, 0, cpustate->q); device->save_item(NAME(cpustate->q));
state_save_register_device_item(device, 0, cpustate->f); device->save_item(NAME(cpustate->f));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->cflag); device->save_item(NAME(cpustate->cflag));
state_save_register_device_item(device, 0, cpustate->vflag); device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->platch); device->save_item(NAME(cpustate->platch));
state_save_register_device_item(device, 0, cpustate->rtnlatch); device->save_item(NAME(cpustate->rtnlatch));
state_save_register_device_item(device, 0, cpustate->adrcntr); device->save_item(NAME(cpustate->adrcntr));
state_save_register_device_item(device, 0, cpustate->adrlatch); device->save_item(NAME(cpustate->adrlatch));
state_save_register_device_item(device, 0, cpustate->dinlatch); device->save_item(NAME(cpustate->dinlatch));
state_save_register_device_item(device, 0, cpustate->ramwlatch); device->save_item(NAME(cpustate->ramwlatch));
state_save_register_device_item(device, 0, cpustate->prev_ipram); device->save_item(NAME(cpustate->prev_ipram));
state_save_register_device_item(device, 0, cpustate->prev_ipwrt); device->save_item(NAME(cpustate->prev_ipwrt));
device->machine->state().register_postload(cquestsnd_postload, (void *)device); 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) static void cquestrot_state_register(device_t *device)
{ {
cquestrot_state *cpustate = get_safe_token_rot(device); cquestrot_state *cpustate = get_safe_token_rot(device);
state_save_register_device_item_array(device, 0, cpustate->ram); device->save_item(NAME(cpustate->ram));
state_save_register_device_item(device, 0, cpustate->q); device->save_item(NAME(cpustate->q));
state_save_register_device_item(device, 0, cpustate->f); device->save_item(NAME(cpustate->f));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->cflag); device->save_item(NAME(cpustate->cflag));
state_save_register_device_item(device, 0, cpustate->vflag); device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->seqcnt); device->save_item(NAME(cpustate->seqcnt));
state_save_register_device_item(device, 0, cpustate->dsrclatch); device->save_item(NAME(cpustate->dsrclatch));
state_save_register_device_item(device, 0, cpustate->rsrclatch); device->save_item(NAME(cpustate->rsrclatch));
state_save_register_device_item(device, 0, cpustate->dynaddr); device->save_item(NAME(cpustate->dynaddr));
state_save_register_device_item(device, 0, cpustate->dyndata); device->save_item(NAME(cpustate->dyndata));
state_save_register_device_item(device, 0, cpustate->yrlatch); device->save_item(NAME(cpustate->yrlatch));
state_save_register_device_item(device, 0, cpustate->ydlatch); device->save_item(NAME(cpustate->ydlatch));
state_save_register_device_item(device, 0, cpustate->dinlatch); device->save_item(NAME(cpustate->dinlatch));
state_save_register_device_item(device, 0, cpustate->divreg); device->save_item(NAME(cpustate->divreg));
state_save_register_device_item(device, 0, cpustate->linedata); device->save_item(NAME(cpustate->linedata));
state_save_register_device_item(device, 0, cpustate->lineaddr); device->save_item(NAME(cpustate->lineaddr));
state_save_register_device_item(device, 0, cpustate->prev_dred); device->save_item(NAME(cpustate->prev_dred));
state_save_register_device_item(device, 0, cpustate->prev_dwrt); device->save_item(NAME(cpustate->prev_dwrt));
state_save_register_device_item(device, 0, cpustate->wc); device->save_item(NAME(cpustate->wc));
state_save_register_device_item_pointer(device, 0, cpustate->dram, 16384); device->save_pointer(NAME(cpustate->dram), 16384);
state_save_register_device_item_pointer(device, 0, cpustate->sram, 2048); device->save_pointer(NAME(cpustate->sram), 2048);
device->machine->state().register_postload(cquestrot_postload, (void *)device); 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); cquestlin_state *cpustate = get_safe_token_lin(device);
state_save_register_device_item_array(device, 0, cpustate->ram); device->save_item(NAME(cpustate->ram));
state_save_register_device_item(device, 0, cpustate->q); device->save_item(NAME(cpustate->q));
state_save_register_device_item(device, 0, cpustate->f); device->save_item(NAME(cpustate->f));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->cflag); device->save_item(NAME(cpustate->cflag));
state_save_register_device_item(device, 0, cpustate->vflag); device->save_item(NAME(cpustate->vflag));
state_save_register_device_item(device, 0, cpustate->pc[0]); device->save_item(NAME(cpustate->pc[0]));
state_save_register_device_item(device, 0, cpustate->pc[1]); device->save_item(NAME(cpustate->pc[1]));
state_save_register_device_item(device, 0, cpustate->seqcnt); device->save_item(NAME(cpustate->seqcnt));
state_save_register_device_item(device, 0, cpustate->clatch); device->save_item(NAME(cpustate->clatch));
state_save_register_device_item(device, 0, cpustate->zlatch); device->save_item(NAME(cpustate->zlatch));
state_save_register_device_item(device, 0, cpustate->xcnt); device->save_item(NAME(cpustate->xcnt));
state_save_register_device_item(device, 0, cpustate->ycnt); device->save_item(NAME(cpustate->ycnt));
state_save_register_device_item(device, 0, cpustate->sreg); device->save_item(NAME(cpustate->sreg));
state_save_register_device_item(device, 0, cpustate->fadlatch); device->save_item(NAME(cpustate->fadlatch));
state_save_register_device_item(device, 0, cpustate->badlatch); device->save_item(NAME(cpustate->badlatch));
state_save_register_device_item(device, 0, cpustate->sramdlatch); device->save_item(NAME(cpustate->sramdlatch));
state_save_register_device_item(device, 0, cpustate->fglatch); device->save_item(NAME(cpustate->fglatch));
state_save_register_device_item(device, 0, cpustate->bglatch); device->save_item(NAME(cpustate->bglatch));
state_save_register_device_item(device, 0, cpustate->gt0reg); device->save_item(NAME(cpustate->gt0reg));
state_save_register_device_item(device, 0, cpustate->fdxreg); device->save_item(NAME(cpustate->fdxreg));
state_save_register_device_item(device, 0, cpustate->field); device->save_item(NAME(cpustate->field));
state_save_register_device_item(device, 0, cpustate->clkcnt); device->save_item(NAME(cpustate->clkcnt));
state_save_register_device_item_pointer(device, 0, cpustate->sram, 4096); device->save_pointer(NAME(cpustate->sram), 4096);
state_save_register_device_item_pointer(device, 0, cpustate->ptr_ram, 1024); device->save_pointer(NAME(cpustate->ptr_ram), 1024);
state_save_register_device_item_pointer(device, 0, cpustate->e_stack, 32768); device->save_pointer(NAME(cpustate->e_stack), 32768);
state_save_register_device_item_pointer(device, 0, cpustate->o_stack, 32768); device->save_pointer(NAME(cpustate->o_stack), 32768);
device->machine->state().register_postload(cquestlin_postload, (void *)device); 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_program = space(AS_PROGRAM);
m_direct = &m_program->direct(); m_direct = &m_program->direct();
state_save_register_device_item(this, 0, m_pc); save_item(NAME(m_pc));
// register state with the debugger // register state with the debugger
state_add(DSP16_PC, "PC", m_pc); 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); state_add(DSP32_IOC, "IOC", m_r[27]).mask(0xfffff);
// register our state for saving // register our state for saving
state_save_register_device_item_array(this, 0, m_r); save_item(NAME(m_r));
state_save_register_device_item(this, 0, m_pin); save_item(NAME(m_pin));
state_save_register_device_item(this, 0, m_pout); save_item(NAME(m_pout));
state_save_register_device_item(this, 0, m_ivtp); save_item(NAME(m_ivtp));
state_save_register_device_item(this, 0, m_nzcflags); save_item(NAME(m_nzcflags));
state_save_register_device_item(this, 0, m_vflags); save_item(NAME(m_vflags));
state_save_register_device_item_array(this, 0, m_a); save_item(NAME(m_a));
state_save_register_device_item(this, 0, m_NZflags); save_item(NAME(m_NZflags));
state_save_register_device_item(this, 0, m_VUflags); save_item(NAME(m_VUflags));
state_save_register_device_item_array(this, 0, m_abuf); save_item(NAME(m_abuf));
state_save_register_device_item_array(this, 0, m_abufreg); save_item(NAME(m_abufreg));
state_save_register_device_item_array(this, 0, m_abufVUflags); save_item(NAME(m_abufVUflags));
state_save_register_device_item_array(this, 0, m_abufNZflags); save_item(NAME(m_abufNZflags));
state_save_register_device_item_array(this, 0, m_abufcycle); save_item(NAME(m_abufcycle));
state_save_register_device_item(this, 0, m_abuf_index); save_item(NAME(m_abuf_index));
state_save_register_device_item_array(this, 0, m_mbufaddr); save_item(NAME(m_mbufaddr));
state_save_register_device_item_array(this, 0, m_mbufdata); save_item(NAME(m_mbufdata));
state_save_register_device_item(this, 0, m_par); save_item(NAME(m_par));
state_save_register_device_item(this, 0, m_pare); save_item(NAME(m_pare));
state_save_register_device_item(this, 0, m_pdr); save_item(NAME(m_pdr));
state_save_register_device_item(this, 0, m_pdr2); save_item(NAME(m_pdr2));
state_save_register_device_item(this, 0, m_pir); save_item(NAME(m_pir));
state_save_register_device_item(this, 0, m_pcr); save_item(NAME(m_pcr));
state_save_register_device_item(this, 0, m_emr); save_item(NAME(m_emr));
state_save_register_device_item(this, 0, m_esr); save_item(NAME(m_esr));
state_save_register_device_item(this, 0, m_pcw); save_item(NAME(m_pcw));
state_save_register_device_item(this, 0, m_piop); save_item(NAME(m_piop));
state_save_register_device_item(this, 0, m_ibuf); save_item(NAME(m_ibuf));
state_save_register_device_item(this, 0, m_isr); save_item(NAME(m_isr));
state_save_register_device_item(this, 0, m_obuf); save_item(NAME(m_obuf));
state_save_register_device_item(this, 0, m_osr); save_item(NAME(m_osr));
state_save_register_device_item(this, 0, m_lastpins); save_item(NAME(m_lastpins));
state_save_register_device_item(this, 0, m_ppc); 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) static void agu_init(dsp56k_core* cpustate, device_t *device)
{ {
/* save states - dsp56k_agu members */ /* save states - dsp56k_agu members */
state_save_register_device_item(device, 0, cpustate->AGU.r0); device->save_item(NAME(cpustate->AGU.r0));
state_save_register_device_item(device, 0, cpustate->AGU.r1); device->save_item(NAME(cpustate->AGU.r1));
state_save_register_device_item(device, 0, cpustate->AGU.r2); device->save_item(NAME(cpustate->AGU.r2));
state_save_register_device_item(device, 0, cpustate->AGU.r3); device->save_item(NAME(cpustate->AGU.r3));
state_save_register_device_item(device, 0, cpustate->AGU.n0); device->save_item(NAME(cpustate->AGU.n0));
state_save_register_device_item(device, 0, cpustate->AGU.n1); device->save_item(NAME(cpustate->AGU.n1));
state_save_register_device_item(device, 0, cpustate->AGU.n2); device->save_item(NAME(cpustate->AGU.n2));
state_save_register_device_item(device, 0, cpustate->AGU.n3); device->save_item(NAME(cpustate->AGU.n3));
state_save_register_device_item(device, 0, cpustate->AGU.m0); device->save_item(NAME(cpustate->AGU.m0));
state_save_register_device_item(device, 0, cpustate->AGU.m1); device->save_item(NAME(cpustate->AGU.m1));
state_save_register_device_item(device, 0, cpustate->AGU.m2); device->save_item(NAME(cpustate->AGU.m2));
state_save_register_device_item(device, 0, cpustate->AGU.m3); device->save_item(NAME(cpustate->AGU.m3));
state_save_register_device_item(device, 0, cpustate->AGU.temp); device->save_item(NAME(cpustate->AGU.temp));
} }
static void alu_init(dsp56k_core* cpustate, device_t *device) static void alu_init(dsp56k_core* cpustate, device_t *device)
{ {
/* save states - dsp56k_alu members */ /* save states - dsp56k_alu members */
state_save_register_device_item(device, 0, cpustate->ALU.x); device->save_item(NAME(cpustate->ALU.x));
state_save_register_device_item(device, 0, cpustate->ALU.y); device->save_item(NAME(cpustate->ALU.y));
state_save_register_device_item(device, 0, cpustate->ALU.a); device->save_item(NAME(cpustate->ALU.a));
state_save_register_device_item(device, 0, cpustate->ALU.b); device->save_item(NAME(cpustate->ALU.b));
} }
static CPU_INIT( dsp56k ) static CPU_INIT( dsp56k )
@ -208,26 +208,26 @@ static CPU_INIT( dsp56k )
cpustate->reset_state = FALSE; cpustate->reset_state = FALSE;
/* save states - dsp56k_core members */ /* save states - dsp56k_core members */
state_save_register_device_item(device, 0, cpustate->modA_state); device->save_item(NAME(cpustate->modA_state));
state_save_register_device_item(device, 0, cpustate->modB_state); device->save_item(NAME(cpustate->modB_state));
state_save_register_device_item(device, 0, cpustate->modC_state); device->save_item(NAME(cpustate->modC_state));
state_save_register_device_item(device, 0, cpustate->reset_state); device->save_item(NAME(cpustate->reset_state));
state_save_register_device_item(device, 0, cpustate->bootstrap_mode); device->save_item(NAME(cpustate->bootstrap_mode));
state_save_register_device_item(device, 0, cpustate->repFlag); device->save_item(NAME(cpustate->repFlag));
state_save_register_device_item(device, 0, cpustate->repAddr); device->save_item(NAME(cpustate->repAddr));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->ppc); device->save_item(NAME(cpustate->ppc));
state_save_register_device_item(device, 0, cpustate->op); device->save_item(NAME(cpustate->op));
state_save_register_device_item(device, 0, cpustate->interrupt_cycles); device->save_item(NAME(cpustate->interrupt_cycles));
/* save states - dsp56k_host_interface members */ /* save states - dsp56k_host_interface members */
state_save_register_device_item(device, 0, cpustate->HI.icr); device->save_item(NAME(cpustate->HI.icr));
state_save_register_device_item(device, 0, cpustate->HI.cvr); device->save_item(NAME(cpustate->HI.cvr));
state_save_register_device_item(device, 0, cpustate->HI.isr); device->save_item(NAME(cpustate->HI.isr));
state_save_register_device_item(device, 0, cpustate->HI.ivr); device->save_item(NAME(cpustate->HI.ivr));
state_save_register_device_item(device, 0, cpustate->HI.trxh); device->save_item(NAME(cpustate->HI.trxh));
state_save_register_device_item(device, 0, cpustate->HI.trxl); device->save_item(NAME(cpustate->HI.trxl));
state_save_register_device_item(device, 0, cpustate->HI.bootstrap_offset); device->save_item(NAME(cpustate->HI.bootstrap_offset));
//cpustate->config = device->baseconfig().static_config(); //cpustate->config = device->baseconfig().static_config();
//cpustate->irq_callback = irqcallback; //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(); dsp56k_irq_table_init();
/* save states - dsp56k_pcu members */ /* save states - dsp56k_pcu members */
state_save_register_device_item(device, 0, cpustate->PCU.pc); device->save_item(NAME(cpustate->PCU.pc));
state_save_register_device_item(device, 0, cpustate->PCU.la); device->save_item(NAME(cpustate->PCU.la));
state_save_register_device_item(device, 0, cpustate->PCU.lc); device->save_item(NAME(cpustate->PCU.lc));
state_save_register_device_item(device, 0, cpustate->PCU.sr); device->save_item(NAME(cpustate->PCU.sr));
state_save_register_device_item(device, 0, cpustate->PCU.omr); device->save_item(NAME(cpustate->PCU.omr));
state_save_register_device_item(device, 0, cpustate->PCU.sp); device->save_item(NAME(cpustate->PCU.sp));
state_save_register_device_item_array(device, 0, cpustate->PCU.ss); device->save_item(NAME(cpustate->PCU.ss));
state_save_register_device_item_array(device, 0, cpustate->PCU.pending_interrupts); device->save_item(NAME(cpustate->PCU.pending_interrupts));
state_save_register_device_item(device, 0, cpustate->PCU.reset_vector); device->save_item(NAME(cpustate->PCU.reset_vector));
} }
void pcu_reset(dsp56k_core* cpustate) 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); hyperstone_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->global_regs); device->save_item(NAME(cpustate->global_regs));
state_save_register_device_item_array(device, 0, cpustate->local_regs); device->save_item(NAME(cpustate->local_regs));
state_save_register_device_item(device, 0, cpustate->ppc); device->save_item(NAME(cpustate->ppc));
state_save_register_device_item(device, 0, cpustate->trap_entry); device->save_item(NAME(cpustate->trap_entry));
state_save_register_device_item(device, 0, cpustate->delay.delay_pc); device->save_item(NAME(cpustate->delay.delay_pc));
state_save_register_device_item(device, 0, cpustate->instruction_length); device->save_item(NAME(cpustate->instruction_length));
state_save_register_device_item(device, 0, cpustate->intblock); device->save_item(NAME(cpustate->intblock));
state_save_register_device_item(device, 0, cpustate->delay.delay_cmd); device->save_item(NAME(cpustate->delay.delay_cmd));
state_save_register_device_item(device, 0, cpustate->tr_clocks_per_tick); device->save_item(NAME(cpustate->tr_clocks_per_tick));
cpustate->irq_callback = irqcallback; cpustate->irq_callback = irqcallback;
cpustate->device = device; cpustate->device = device;

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

@ -272,48 +272,48 @@ static CPU_INIT( esrip )
make_ops(cpustate); make_ops(cpustate);
/* Register stuff for state saving */ /* Register stuff for state saving */
state_save_register_device_item(device, 0, cpustate->acc); device->save_item(NAME(cpustate->acc));
state_save_register_device_item_array(device, 0, cpustate->ram); device->save_item(NAME(cpustate->ram));
state_save_register_device_item(device, 0, cpustate->d_latch); device->save_item(NAME(cpustate->d_latch));
state_save_register_device_item(device, 0, cpustate->i_latch); device->save_item(NAME(cpustate->i_latch));
state_save_register_device_item(device, 0, cpustate->result); device->save_item(NAME(cpustate->result));
state_save_register_device_item(device, 0, cpustate->new_status); device->save_item(NAME(cpustate->new_status));
state_save_register_device_item(device, 0, cpustate->status); device->save_item(NAME(cpustate->status));
state_save_register_device_item(device, 0, cpustate->inst); device->save_item(NAME(cpustate->inst));
state_save_register_device_item(device, 0, cpustate->immflag); device->save_item(NAME(cpustate->immflag));
state_save_register_device_item(device, 0, cpustate->ct); device->save_item(NAME(cpustate->ct));
state_save_register_device_item(device, 0, cpustate->t); device->save_item(NAME(cpustate->t));
state_save_register_device_item(device, 0, cpustate->l1); device->save_item(NAME(cpustate->l1));
state_save_register_device_item(device, 0, cpustate->l2); device->save_item(NAME(cpustate->l2));
state_save_register_device_item(device, 0, cpustate->l3); device->save_item(NAME(cpustate->l3));
state_save_register_device_item(device, 0, cpustate->l4); device->save_item(NAME(cpustate->l4));
state_save_register_device_item(device, 0, cpustate->l5); device->save_item(NAME(cpustate->l5));
state_save_register_device_item(device, 0, cpustate->l6); device->save_item(NAME(cpustate->l6));
state_save_register_device_item(device, 0, cpustate->l7); device->save_item(NAME(cpustate->l7));
state_save_register_device_item(device, 0, cpustate->pl1); device->save_item(NAME(cpustate->pl1));
state_save_register_device_item(device, 0, cpustate->pl2); device->save_item(NAME(cpustate->pl2));
state_save_register_device_item(device, 0, cpustate->pl3); device->save_item(NAME(cpustate->pl3));
state_save_register_device_item(device, 0, cpustate->pl4); device->save_item(NAME(cpustate->pl4));
state_save_register_device_item(device, 0, cpustate->pl5); device->save_item(NAME(cpustate->pl5));
state_save_register_device_item(device, 0, cpustate->pl6); device->save_item(NAME(cpustate->pl6));
state_save_register_device_item(device, 0, cpustate->pl7); device->save_item(NAME(cpustate->pl7));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->status_out); device->save_item(NAME(cpustate->status_out));
state_save_register_device_item(device, 0, cpustate->x_scale); device->save_item(NAME(cpustate->x_scale));
state_save_register_device_item(device, 0, cpustate->y_scale); device->save_item(NAME(cpustate->y_scale));
state_save_register_device_item(device, 0, cpustate->img_bank); device->save_item(NAME(cpustate->img_bank));
state_save_register_device_item(device, 0, cpustate->line_latch); device->save_item(NAME(cpustate->line_latch));
state_save_register_device_item(device, 0, cpustate->fig_latch); device->save_item(NAME(cpustate->fig_latch));
state_save_register_device_item(device, 0, cpustate->attr_latch); device->save_item(NAME(cpustate->attr_latch));
state_save_register_device_item(device, 0, cpustate->adl_latch); device->save_item(NAME(cpustate->adl_latch));
state_save_register_device_item(device, 0, cpustate->adr_latch); device->save_item(NAME(cpustate->adr_latch));
state_save_register_device_item(device, 0, cpustate->iaddr_latch); device->save_item(NAME(cpustate->iaddr_latch));
state_save_register_device_item(device, 0, cpustate->c_latch); device->save_item(NAME(cpustate->c_latch));
state_save_register_device_item(device, 0, cpustate->fdt_cnt); device->save_item(NAME(cpustate->fdt_cnt));
state_save_register_device_item(device, 0, cpustate->ipt_cnt); device->save_item(NAME(cpustate->ipt_cnt));
state_save_register_device_item(device, 0, cpustate->fig); device->save_item(NAME(cpustate->fig));
state_save_register_device_item(device, 0, cpustate->fig_cycles); device->save_item(NAME(cpustate->fig_cycles));
state_save_register_device_item_pointer(device, 0, cpustate->ipt_ram, IPT_RAM_SIZE / sizeof(UINT16)); 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->direct = &cpustate->program->direct();
cpustate->iospace = device->space(AS_IO); cpustate->iospace = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->pc0); device->save_item(NAME(cpustate->pc0));
state_save_register_device_item(device, 0, cpustate->pc1); device->save_item(NAME(cpustate->pc1));
state_save_register_device_item(device, 0, cpustate->dc0); device->save_item(NAME(cpustate->dc0));
state_save_register_device_item(device, 0, cpustate->dc1); device->save_item(NAME(cpustate->dc1));
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->w); device->save_item(NAME(cpustate->w));
state_save_register_device_item(device, 0, cpustate->is); device->save_item(NAME(cpustate->is));
state_save_register_device_item(device, 0, cpustate->dbus); device->save_item(NAME(cpustate->dbus));
state_save_register_device_item(device, 0, cpustate->io); device->save_item(NAME(cpustate->io));
state_save_register_device_item(device, 0, cpustate->irq_vector); device->save_item(NAME(cpustate->irq_vector));
state_save_register_device_item(device, 0, cpustate->irq_request); device->save_item(NAME(cpustate->irq_request));
state_save_register_device_item_array(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
} }
static CPU_SET_INFO( f8 ) 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->program = device->space(AS_PROGRAM);
cpustate->cpu_type = CPU_TYPE_G65816; cpustate->cpu_type = CPU_TYPE_G65816;
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->b); device->save_item(NAME(cpustate->b));
state_save_register_device_item(device, 0, cpustate->x); device->save_item(NAME(cpustate->x));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->s); device->save_item(NAME(cpustate->s));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->ppc); device->save_item(NAME(cpustate->ppc));
state_save_register_device_item(device, 0, cpustate->pb); device->save_item(NAME(cpustate->pb));
state_save_register_device_item(device, 0, cpustate->db); device->save_item(NAME(cpustate->db));
state_save_register_device_item(device, 0, cpustate->d); device->save_item(NAME(cpustate->d));
state_save_register_device_item(device, 0, cpustate->flag_e); device->save_item(NAME(cpustate->flag_e));
state_save_register_device_item(device, 0, cpustate->flag_m); device->save_item(NAME(cpustate->flag_m));
state_save_register_device_item(device, 0, cpustate->flag_x); device->save_item(NAME(cpustate->flag_x));
state_save_register_device_item(device, 0, cpustate->flag_n); device->save_item(NAME(cpustate->flag_n));
state_save_register_device_item(device, 0, cpustate->flag_v); device->save_item(NAME(cpustate->flag_v));
state_save_register_device_item(device, 0, cpustate->flag_d); device->save_item(NAME(cpustate->flag_d));
state_save_register_device_item(device, 0, cpustate->flag_i); device->save_item(NAME(cpustate->flag_i));
state_save_register_device_item(device, 0, cpustate->flag_z); device->save_item(NAME(cpustate->flag_z));
state_save_register_device_item(device, 0, cpustate->flag_c); device->save_item(NAME(cpustate->flag_c));
state_save_register_device_item(device, 0, cpustate->line_irq); device->save_item(NAME(cpustate->line_irq));
state_save_register_device_item(device, 0, cpustate->line_nmi); device->save_item(NAME(cpustate->line_nmi));
state_save_register_device_item(device, 0, cpustate->ir); device->save_item(NAME(cpustate->ir));
state_save_register_device_item(device, 0, cpustate->irq_delay); device->save_item(NAME(cpustate->irq_delay));
state_save_register_device_item(device, 0, cpustate->stopped); device->save_item(NAME(cpustate->stopped));
device->machine->state().register_postload(g65816_restore_state, cpustate); 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); h6280_Regs* cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->ppc.w.l); device->save_item(NAME(cpustate->ppc.w.l));
state_save_register_device_item(device, 0, cpustate->pc.w.l); device->save_item(NAME(cpustate->pc.w.l));
state_save_register_device_item(device, 0, cpustate->sp.w.l); device->save_item(NAME(cpustate->sp.w.l));
state_save_register_device_item(device, 0, cpustate->zp.w.l); device->save_item(NAME(cpustate->zp.w.l));
state_save_register_device_item(device, 0, cpustate->ea.w.l); device->save_item(NAME(cpustate->ea.w.l));
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->x); device->save_item(NAME(cpustate->x));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->p); device->save_item(NAME(cpustate->p));
state_save_register_device_item_array(device, 0, cpustate->mmr); device->save_item(NAME(cpustate->mmr));
state_save_register_device_item(device, 0, cpustate->irq_mask); device->save_item(NAME(cpustate->irq_mask));
state_save_register_device_item(device, 0, cpustate->timer_status); device->save_item(NAME(cpustate->timer_status));
state_save_register_device_item(device, 0, cpustate->timer_ack); device->save_item(NAME(cpustate->timer_ack));
state_save_register_device_item(device, 0, cpustate->clocks_per_cycle); device->save_item(NAME(cpustate->clocks_per_cycle));
state_save_register_device_item(device, 0, cpustate->timer_value); device->save_item(NAME(cpustate->timer_value));
state_save_register_device_item(device, 0, cpustate->timer_load); device->save_item(NAME(cpustate->timer_load));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->irq_state[0]); device->save_item(NAME(cpustate->irq_state[0]));
state_save_register_device_item(device, 0, cpustate->irq_state[1]); device->save_item(NAME(cpustate->irq_state[1]));
state_save_register_device_item(device, 0, cpustate->irq_state[2]); device->save_item(NAME(cpustate->irq_state[2]));
state_save_register_device_item(device, 0, cpustate->irq_pending); device->save_item(NAME(cpustate->irq_pending));
#if LAZY_FLAGS #if LAZY_FLAGS
state_save_register_device_item(device, 0, cpustate->NZ); device->save_item(NAME(cpustate->NZ));
#endif #endif
state_save_register_device_item(device, 0, cpustate->io_buffer); device->save_item(NAME(cpustate->io_buffer));
cpustate->irq_callback = irqcallback; cpustate->irq_callback = irqcallback;
cpustate->device = device; 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->direct = &h8->program->direct();
h8->io = device->space(AS_IO); h8->io = device->space(AS_IO);
state_save_register_device_item(device, 0, h8->h8err); device->save_item(NAME(h8->h8err));
state_save_register_device_item_array(device, 0, h8->regs); device->save_item(NAME(h8->regs));
state_save_register_device_item(device, 0, h8->pc); device->save_item(NAME(h8->pc));
state_save_register_device_item(device, 0, h8->ppc); device->save_item(NAME(h8->ppc));
state_save_register_device_item(device, 0, h8->h8_IRQrequestH); device->save_item(NAME(h8->h8_IRQrequestH));
state_save_register_device_item(device, 0, h8->h8_IRQrequestL); device->save_item(NAME(h8->h8_IRQrequestL));
state_save_register_device_item(device, 0, h8->ccr); device->save_item(NAME(h8->ccr));
state_save_register_device_item(device, 0, h8->mode_8bit); device->save_item(NAME(h8->mode_8bit));
state_save_register_device_item_array(device, 0, h8->per_regs); device->save_item(NAME(h8->per_regs));
state_save_register_device_item(device, 0, h8->h8TSTR); device->save_item(NAME(h8->h8TSTR));
state_save_register_device_item_array(device, 0, h8->h8TCNT); device->save_item(NAME(h8->h8TCNT));
device->machine->state().register_postload(h8_onstateload, h8); 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[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); h8->timer[3] = h8->device->machine->scheduler().timer_alloc(FUNC(h8_timer_3_cb), h8);
state_save_register_device_item(device, 0, h8->h8err); device->save_item(NAME(h8->h8err));
state_save_register_device_item_array(device, 0, h8->regs); device->save_item(NAME(h8->regs));
state_save_register_device_item(device, 0, h8->pc); device->save_item(NAME(h8->pc));
state_save_register_device_item(device, 0, h8->ppc); device->save_item(NAME(h8->ppc));
state_save_register_device_item(device, 0, h8->h8_IRQrequestH); device->save_item(NAME(h8->h8_IRQrequestH));
state_save_register_device_item(device, 0, h8->h8_IRQrequestL); device->save_item(NAME(h8->h8_IRQrequestL));
state_save_register_device_item(device, 0, h8->ccr); device->save_item(NAME(h8->ccr));
state_save_register_device_item(device, 0, h8->mode_8bit); device->save_item(NAME(h8->mode_8bit));
state_save_register_device_item_array(device, 0, h8->per_regs); device->save_item(NAME(h8->per_regs));
state_save_register_device_item(device, 0, h8->h8TSTR); device->save_item(NAME(h8->h8TSTR));
state_save_register_device_item_array(device, 0, h8->h8TCNT); device->save_item(NAME(h8->h8TCNT));
h8->device->machine->state().register_postload(h8_onstateload, h8); 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)); m_sec_timer->adjust(attotime::from_seconds(1), 0, attotime::from_seconds(1));
// save state // save state
state_save_register_device_item(this, 0, m_ppc); save_item(NAME(m_ppc));
state_save_register_device_item(this, 0, m_curpc); save_item(NAME(m_curpc));
state_save_register_device_item(this, 0, m_pc); save_item(NAME(m_pc));
state_save_register_device_item(this, 0, m_flags); save_item(NAME(m_flags));
state_save_register_device_item(this, 0, m_fetch_addr); save_item(NAME(m_fetch_addr));
state_save_register_device_item(this, 0, m_irq_status); save_item(NAME(m_irq_status));
state_save_register_device_item(this, 0, m_state); save_item(NAME(m_state));
state_save_register_device_item(this, 0, prev_ua); save_item(NAME(prev_ua));
state_save_register_device_item(this, 0, m_icount); save_item(NAME(m_icount));
state_save_register_device_item_array(this, 0, m_regsir); save_item(NAME(m_regsir));
state_save_register_device_item_array(this, 0, m_reg8bit); save_item(NAME(m_reg8bit));
state_save_register_device_item_array(this, 0, m_reg16bit); save_item(NAME(m_reg16bit));
state_save_register_device_item_array(this, 0, m_regmain); save_item(NAME(m_regmain));
state_save_register_device_item_array(this, 0, m_lines_status); save_item(NAME(m_lines_status));
// register state for debugger // register state for debugger
state_add(HD61700_PC, "pc", m_pc).callimport().callexport().formatstr("%04X"); 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[2] = &(B);
m68_state->regTable[3] = &m68_state->dummy_byte; m68_state->regTable[3] = &m68_state->dummy_byte;
state_save_register_device_item(device, 0, PC); device->save_item(NAME(PC));
state_save_register_device_item(device, 0, U); device->save_item(NAME(U));
state_save_register_device_item(device, 0, S); device->save_item(NAME(S));
state_save_register_device_item(device, 0, X); device->save_item(NAME(X));
state_save_register_device_item(device, 0, Y); device->save_item(NAME(Y));
state_save_register_device_item(device, 0, V); device->save_item(NAME(V));
state_save_register_device_item(device, 0, DP); device->save_item(NAME(DP));
state_save_register_device_item(device, 0, CC); device->save_item(NAME(CC));
state_save_register_device_item(device, 0, MD); device->save_item(NAME(MD));
device->machine->state().register_postload(hd6309_postload, (void *) device); device->machine->state().register_postload(hd6309_postload, (void *) device);
state_save_register_device_item(device, 0, m68_state->int_state); device->save_item(NAME(m68_state->int_state));
state_save_register_device_item(device, 0, m68_state->nmi_state); device->save_item(NAME(m68_state->nmi_state));
state_save_register_device_item(device, 0, m68_state->irq_state[0]); device->save_item(NAME(m68_state->irq_state[0]));
state_save_register_device_item(device, 0, m68_state->irq_state[1]); 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->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item_array(device, 0, cpustate->reg.d); device->save_item(NAME( cpustate->reg.d));
state_save_register_device_item(device, 0, cpustate->sreg[ES].selector); device->save_item(NAME(cpustate->sreg[ES].selector));
state_save_register_device_item(device, 0, cpustate->sreg[ES].base); device->save_item(NAME(cpustate->sreg[ES].base));
state_save_register_device_item(device, 0, cpustate->sreg[ES].limit); device->save_item(NAME(cpustate->sreg[ES].limit));
state_save_register_device_item(device, 0, cpustate->sreg[ES].flags); device->save_item(NAME(cpustate->sreg[ES].flags));
state_save_register_device_item(device, 0, cpustate->sreg[CS].selector); device->save_item(NAME(cpustate->sreg[CS].selector));
state_save_register_device_item(device, 0, cpustate->sreg[CS].base); device->save_item(NAME(cpustate->sreg[CS].base));
state_save_register_device_item(device, 0, cpustate->sreg[CS].limit); device->save_item(NAME(cpustate->sreg[CS].limit));
state_save_register_device_item(device, 0, cpustate->sreg[CS].flags); device->save_item(NAME(cpustate->sreg[CS].flags));
state_save_register_device_item(device, 0, cpustate->sreg[SS].selector); device->save_item(NAME(cpustate->sreg[SS].selector));
state_save_register_device_item(device, 0, cpustate->sreg[SS].base); device->save_item(NAME(cpustate->sreg[SS].base));
state_save_register_device_item(device, 0, cpustate->sreg[SS].limit); device->save_item(NAME(cpustate->sreg[SS].limit));
state_save_register_device_item(device, 0, cpustate->sreg[SS].flags); device->save_item(NAME(cpustate->sreg[SS].flags));
state_save_register_device_item(device, 0, cpustate->sreg[DS].selector); device->save_item(NAME(cpustate->sreg[DS].selector));
state_save_register_device_item(device, 0, cpustate->sreg[DS].base); device->save_item(NAME(cpustate->sreg[DS].base));
state_save_register_device_item(device, 0, cpustate->sreg[DS].limit); device->save_item(NAME(cpustate->sreg[DS].limit));
state_save_register_device_item(device, 0, cpustate->sreg[DS].flags); device->save_item(NAME(cpustate->sreg[DS].flags));
state_save_register_device_item(device, 0, cpustate->sreg[FS].selector); device->save_item(NAME(cpustate->sreg[FS].selector));
state_save_register_device_item(device, 0, cpustate->sreg[FS].base); device->save_item(NAME(cpustate->sreg[FS].base));
state_save_register_device_item(device, 0, cpustate->sreg[FS].limit); device->save_item(NAME(cpustate->sreg[FS].limit));
state_save_register_device_item(device, 0, cpustate->sreg[FS].flags); device->save_item(NAME(cpustate->sreg[FS].flags));
state_save_register_device_item(device, 0, cpustate->sreg[GS].selector); device->save_item(NAME(cpustate->sreg[GS].selector));
state_save_register_device_item(device, 0, cpustate->sreg[GS].base); device->save_item(NAME(cpustate->sreg[GS].base));
state_save_register_device_item(device, 0, cpustate->sreg[GS].limit); device->save_item(NAME(cpustate->sreg[GS].limit));
state_save_register_device_item(device, 0, cpustate->sreg[GS].flags); device->save_item(NAME(cpustate->sreg[GS].flags));
state_save_register_device_item(device, 0, cpustate->eip); device->save_item(NAME(cpustate->eip));
state_save_register_device_item(device, 0, cpustate->prev_eip); device->save_item(NAME(cpustate->prev_eip));
state_save_register_device_item(device, 0, cpustate->CF); device->save_item(NAME(cpustate->CF));
state_save_register_device_item(device, 0, cpustate->DF); device->save_item(NAME(cpustate->DF));
state_save_register_device_item(device, 0, cpustate->SF); device->save_item(NAME(cpustate->SF));
state_save_register_device_item(device, 0, cpustate->OF); device->save_item(NAME(cpustate->OF));
state_save_register_device_item(device, 0, cpustate->ZF); device->save_item(NAME(cpustate->ZF));
state_save_register_device_item(device, 0, cpustate->PF); device->save_item(NAME(cpustate->PF));
state_save_register_device_item(device, 0, cpustate->AF); device->save_item(NAME(cpustate->AF));
state_save_register_device_item(device, 0, cpustate->IF); device->save_item(NAME(cpustate->IF));
state_save_register_device_item(device, 0, cpustate->TF); device->save_item(NAME(cpustate->TF));
state_save_register_device_item_array(device, 0, cpustate->cr); device->save_item(NAME( cpustate->cr));
state_save_register_device_item_array(device, 0, cpustate->dr); device->save_item(NAME( cpustate->dr));
state_save_register_device_item_array(device, 0, cpustate->tr); device->save_item(NAME( cpustate->tr));
state_save_register_device_item(device, 0, cpustate->idtr.base); device->save_item(NAME(cpustate->idtr.base));
state_save_register_device_item(device, 0, cpustate->idtr.limit); device->save_item(NAME(cpustate->idtr.limit));
state_save_register_device_item(device, 0, cpustate->gdtr.base); device->save_item(NAME(cpustate->gdtr.base));
state_save_register_device_item(device, 0, cpustate->gdtr.limit); device->save_item(NAME(cpustate->gdtr.limit));
state_save_register_device_item(device, 0, cpustate->task.base); device->save_item(NAME(cpustate->task.base));
state_save_register_device_item(device, 0, cpustate->task.segment); device->save_item(NAME(cpustate->task.segment));
state_save_register_device_item(device, 0, cpustate->task.limit); device->save_item(NAME(cpustate->task.limit));
state_save_register_device_item(device, 0, cpustate->task.flags); device->save_item(NAME(cpustate->task.flags));
state_save_register_device_item(device, 0, cpustate->ldtr.base); device->save_item(NAME(cpustate->ldtr.base));
state_save_register_device_item(device, 0, cpustate->ldtr.segment); device->save_item(NAME(cpustate->ldtr.segment));
state_save_register_device_item(device, 0, cpustate->ldtr.limit); device->save_item(NAME(cpustate->ldtr.limit));
state_save_register_device_item(device, 0, cpustate->ldtr.flags); device->save_item(NAME(cpustate->ldtr.flags));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->performed_intersegment_jump); device->save_item(NAME(cpustate->performed_intersegment_jump));
device->machine->state().register_postload(i386_postload, (void *)device); 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->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->C); device->save_item(NAME(cpustate->C));
state_save_register_device_item(device, 0, cpustate->TEST); device->save_item(NAME(cpustate->TEST));
state_save_register_device_item(device, 0, cpustate->pc_pos); device->save_item(NAME(cpustate->pc_pos));
state_save_register_device_item(device, 0, cpustate->ADDR[0]); device->save_item(NAME(cpustate->ADDR[0]));
state_save_register_device_item(device, 0, cpustate->ADDR[1]); device->save_item(NAME(cpustate->ADDR[1]));
state_save_register_device_item(device, 0, cpustate->ADDR[2]); device->save_item(NAME(cpustate->ADDR[2]));
state_save_register_device_item(device, 0, cpustate->ADDR[3]); device->save_item(NAME(cpustate->ADDR[3]));
state_save_register_device_item(device, 0, cpustate->R[0]); device->save_item(NAME(cpustate->R[0]));
state_save_register_device_item(device, 0, cpustate->R[1]); device->save_item(NAME(cpustate->R[1]));
state_save_register_device_item(device, 0, cpustate->R[2]); device->save_item(NAME(cpustate->R[2]));
state_save_register_device_item(device, 0, cpustate->R[3]); device->save_item(NAME(cpustate->R[3]));
state_save_register_device_item(device, 0, cpustate->R[4]); device->save_item(NAME(cpustate->R[4]));
state_save_register_device_item(device, 0, cpustate->R[5]); device->save_item(NAME(cpustate->R[5]));
state_save_register_device_item(device, 0, cpustate->R[6]); device->save_item(NAME(cpustate->R[6]));
state_save_register_device_item(device, 0, cpustate->R[7]); device->save_item(NAME(cpustate->R[7]));
state_save_register_device_item(device, 0, cpustate->RAM); 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(); init_tables();
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->B); device->save_item(NAME(cpustate->B));
state_save_register_device_item(device, 0, cpustate->C); device->save_item(NAME(cpustate->C));
state_save_register_device_item(device, 0, cpustate->D); device->save_item(NAME(cpustate->D));
state_save_register_device_item(device, 0, cpustate->E); device->save_item(NAME(cpustate->E));
state_save_register_device_item(device, 0, cpustate->H); device->save_item(NAME(cpustate->H));
state_save_register_device_item(device, 0, cpustate->L); device->save_item(NAME(cpustate->L));
state_save_register_device_item(device, 0, cpustate->CF); device->save_item(NAME(cpustate->CF));
state_save_register_device_item(device, 0, cpustate->SF); device->save_item(NAME(cpustate->SF));
state_save_register_device_item(device, 0, cpustate->ZF); device->save_item(NAME(cpustate->ZF));
state_save_register_device_item(device, 0, cpustate->PF); device->save_item(NAME(cpustate->PF));
state_save_register_device_item(device, 0, cpustate->pc_pos); device->save_item(NAME(cpustate->pc_pos));
state_save_register_device_item(device, 0, cpustate->ADDR[0]); device->save_item(NAME(cpustate->ADDR[0]));
state_save_register_device_item(device, 0, cpustate->ADDR[1]); device->save_item(NAME(cpustate->ADDR[1]));
state_save_register_device_item(device, 0, cpustate->ADDR[2]); device->save_item(NAME(cpustate->ADDR[2]));
state_save_register_device_item(device, 0, cpustate->ADDR[3]); device->save_item(NAME(cpustate->ADDR[3]));
state_save_register_device_item(device, 0, cpustate->ADDR[4]); device->save_item(NAME(cpustate->ADDR[4]));
state_save_register_device_item(device, 0, cpustate->ADDR[5]); device->save_item(NAME(cpustate->ADDR[5]));
state_save_register_device_item(device, 0, cpustate->ADDR[6]); device->save_item(NAME(cpustate->ADDR[6]));
state_save_register_device_item(device, 0, cpustate->ADDR[7]); device->save_item(NAME(cpustate->ADDR[7]));
state_save_register_device_item(device, 0, cpustate->HALT); device->save_item(NAME(cpustate->HALT));
state_save_register_device_item(device, 0, cpustate->irq_state); 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); devcb_resolve_write_line(&cpustate->out_sod_func, &cpustate->config.out_sod_func, device);
/* register for state saving */ /* register for state saving */
state_save_register_device_item(device, 0, cpustate->PC.w.l); device->save_item(NAME(cpustate->PC.w.l));
state_save_register_device_item(device, 0, cpustate->SP.w.l); device->save_item(NAME(cpustate->SP.w.l));
state_save_register_device_item(device, 0, cpustate->AF.w.l); device->save_item(NAME(cpustate->AF.w.l));
state_save_register_device_item(device, 0, cpustate->BC.w.l); device->save_item(NAME(cpustate->BC.w.l));
state_save_register_device_item(device, 0, cpustate->DE.w.l); device->save_item(NAME(cpustate->DE.w.l));
state_save_register_device_item(device, 0, cpustate->HL.w.l); device->save_item(NAME(cpustate->HL.w.l));
state_save_register_device_item(device, 0, cpustate->HALT); device->save_item(NAME(cpustate->HALT));
state_save_register_device_item(device, 0, cpustate->IM); device->save_item(NAME(cpustate->IM));
state_save_register_device_item(device, 0, cpustate->STATUS); device->save_item(NAME(cpustate->STATUS));
state_save_register_device_item(device, 0, cpustate->after_ei); device->save_item(NAME(cpustate->after_ei));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item_array(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->trap_pending); device->save_item(NAME(cpustate->trap_pending));
state_save_register_device_item(device, 0, cpustate->trap_im_copy); device->save_item(NAME(cpustate->trap_im_copy));
state_save_register_device_item(device, 0, cpustate->sod_state); device->save_item(NAME(cpustate->sod_state));
} }
static CPU_INIT( i8080 ) 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); i80286_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->regs.w); device->save_item(NAME(cpustate->regs.w));
state_save_register_device_item(device, 0, cpustate->amask); device->save_item(NAME(cpustate->amask));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->prevpc); device->save_item(NAME(cpustate->prevpc));
state_save_register_device_item(device, 0, cpustate->msw); device->save_item(NAME(cpustate->msw));
state_save_register_device_item_array(device, 0, cpustate->base); device->save_item(NAME(cpustate->base));
state_save_register_device_item_array(device, 0, cpustate->sregs); device->save_item(NAME(cpustate->sregs));
state_save_register_device_item_array(device, 0, cpustate->limit); device->save_item(NAME(cpustate->limit));
state_save_register_device_item_array(device, 0, cpustate->rights); device->save_item(NAME(cpustate->rights));
state_save_register_device_item(device, 0, cpustate->gdtr.base); device->save_item(NAME(cpustate->gdtr.base));
state_save_register_device_item(device, 0, cpustate->gdtr.limit); device->save_item(NAME(cpustate->gdtr.limit));
state_save_register_device_item(device, 0, cpustate->idtr.base); device->save_item(NAME(cpustate->idtr.base));
state_save_register_device_item(device, 0, cpustate->idtr.limit); device->save_item(NAME(cpustate->idtr.limit));
state_save_register_device_item(device, 0, cpustate->ldtr.sel); device->save_item(NAME(cpustate->ldtr.sel));
state_save_register_device_item(device, 0, cpustate->ldtr.base); device->save_item(NAME(cpustate->ldtr.base));
state_save_register_device_item(device, 0, cpustate->ldtr.limit); device->save_item(NAME(cpustate->ldtr.limit));
state_save_register_device_item(device, 0, cpustate->ldtr.rights); device->save_item(NAME(cpustate->ldtr.rights));
state_save_register_device_item(device, 0, cpustate->tr.sel); device->save_item(NAME(cpustate->tr.sel));
state_save_register_device_item(device, 0, cpustate->tr.base); device->save_item(NAME(cpustate->tr.base));
state_save_register_device_item(device, 0, cpustate->tr.limit); device->save_item(NAME(cpustate->tr.limit));
state_save_register_device_item(device, 0, cpustate->tr.rights); device->save_item(NAME(cpustate->tr.rights));
state_save_register_device_item(device, 0, cpustate->AuxVal); device->save_item(NAME(cpustate->AuxVal));
state_save_register_device_item(device, 0, cpustate->OverVal); device->save_item(NAME(cpustate->OverVal));
state_save_register_device_item(device, 0, cpustate->SignVal); device->save_item(NAME(cpustate->SignVal));
state_save_register_device_item(device, 0, cpustate->ZeroVal); device->save_item(NAME(cpustate->ZeroVal));
state_save_register_device_item(device, 0, cpustate->CarryVal); device->save_item(NAME(cpustate->CarryVal));
state_save_register_device_item(device, 0, cpustate->DirVal); device->save_item(NAME(cpustate->DirVal));
state_save_register_device_item(device, 0, cpustate->ParityVal); device->save_item(NAME(cpustate->ParityVal));
state_save_register_device_item(device, 0, cpustate->TF); device->save_item(NAME(cpustate->TF));
state_save_register_device_item(device, 0, cpustate->IF); device->save_item(NAME(cpustate->IF));
state_save_register_device_item(device, 0, cpustate->int_vector); device->save_item(NAME(cpustate->int_vector));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->extra_cycles); device->save_item(NAME(cpustate->extra_cycles));
state_save_register_device_item(device, 0, cpustate->rep_in_progress); device->save_item(NAME(cpustate->rep_in_progress));
cpustate->irq_callback = irqcallback; cpustate->irq_callback = irqcallback;
cpustate->device = device; 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) static void i8086_state_register(device_t *device)
{ {
i8086_state *cpustate = get_safe_token(device); i8086_state *cpustate = get_safe_token(device);
state_save_register_device_item_array(device, 0, cpustate->regs.w); device->save_item(NAME(cpustate->regs.w));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->prevpc); device->save_item(NAME(cpustate->prevpc));
state_save_register_device_item_array(device, 0, cpustate->base); device->save_item(NAME(cpustate->base));
state_save_register_device_item_array(device, 0, cpustate->sregs); device->save_item(NAME(cpustate->sregs));
state_save_register_device_item(device, 0, cpustate->flags); device->save_item(NAME(cpustate->flags));
state_save_register_device_item(device, 0, cpustate->AuxVal); device->save_item(NAME(cpustate->AuxVal));
state_save_register_device_item(device, 0, cpustate->OverVal); device->save_item(NAME(cpustate->OverVal));
state_save_register_device_item(device, 0, cpustate->SignVal); device->save_item(NAME(cpustate->SignVal));
state_save_register_device_item(device, 0, cpustate->ZeroVal); device->save_item(NAME(cpustate->ZeroVal));
state_save_register_device_item(device, 0, cpustate->CarryVal); device->save_item(NAME(cpustate->CarryVal));
state_save_register_device_item(device, 0, cpustate->DirVal); device->save_item(NAME(cpustate->DirVal));
state_save_register_device_item(device, 0, cpustate->ParityVal); device->save_item(NAME(cpustate->ParityVal));
state_save_register_device_item(device, 0, cpustate->TF); device->save_item(NAME(cpustate->TF));
state_save_register_device_item(device, 0, cpustate->IF); device->save_item(NAME(cpustate->IF));
state_save_register_device_item(device, 0, cpustate->MF); device->save_item(NAME(cpustate->MF));
state_save_register_device_item(device, 0, cpustate->int_vector); device->save_item(NAME(cpustate->int_vector));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->extra_cycles); device->save_item(NAME(cpustate->extra_cycles));
state_save_register_device_item(device, 0, cpustate->halted); device->save_item(NAME(cpustate->halted));
state_save_register_device_item(device, 0, cpustate->test_state); /* PJB 03/05 */ device->save_item(NAME(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->rep_in_progress)); /* PJB 03/05 */
} }
static CPU_INIT( i8086 ) 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); i860_set_pin(device, DEC_PIN_RESET, 0);
cpustate->single_stepping = 0; cpustate->single_stepping = 0;
state_save_register_device_item_array(device, 0, cpustate->iregs); device->save_item(NAME(cpustate->iregs));
state_save_register_device_item_array(device, 0, cpustate->cregs); device->save_item(NAME(cpustate->cregs));
state_save_register_device_item_array(device, 0, cpustate->frg); device->save_item(NAME(cpustate->frg));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
} }
static CPU_RESET( i860 ) 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->program = device->space(AS_PROGRAM);
i960->direct = &i960->program->direct(); i960->direct = &i960->program->direct();
state_save_register_device_item(device, 0, i960->PIP); device->save_item(NAME(i960->PIP));
state_save_register_device_item(device, 0, i960->SAT); device->save_item(NAME(i960->SAT));
state_save_register_device_item(device, 0, i960->PRCB); device->save_item(NAME(i960->PRCB));
state_save_register_device_item(device, 0, i960->PC); device->save_item(NAME(i960->PC));
state_save_register_device_item(device, 0, i960->AC); device->save_item(NAME(i960->AC));
state_save_register_device_item(device, 0, i960->ICR); device->save_item(NAME(i960->ICR));
state_save_register_device_item_array(device, 0, i960->r); device->save_item(NAME(i960->r));
state_save_register_device_item_array(device, 0, i960->fp); device->save_item(NAME(i960->fp));
state_save_register_device_item_2d_array(device, 0, i960->rcache); device->save_item(NAME(i960->rcache));
state_save_register_device_item_array(device, 0, i960->rcache_frame_addr); device->save_item(NAME(i960->rcache_frame_addr));
} }
static CPU_RESET( i960 ) 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) if (configdata != NULL)
jaguar->cpu_interrupt = configdata->cpu_int_callback; jaguar->cpu_interrupt = configdata->cpu_int_callback;
state_save_register_device_item_array(device, 0, jaguar->r); device->save_item(NAME(jaguar->r));
state_save_register_device_item_array(device, 0, jaguar->a); device->save_item(NAME(jaguar->a));
state_save_register_device_item_array(device, 0, jaguar->ctrl); device->save_item(NAME(jaguar->ctrl));
state_save_register_device_item(device, 0, jaguar->ppc); device->save_item(NAME(jaguar->ppc));
device->machine->state().register_postload(jaguar_postload, (void *)device); 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->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct(); cpustate->direct = &cpustate->program->direct();
state_save_register_device_item(device, 0, PC); device->save_item(NAME(PC));
state_save_register_device_item(device, 0, U); device->save_item(NAME(U));
state_save_register_device_item(device, 0, S); device->save_item(NAME(S));
state_save_register_device_item(device, 0, X); device->save_item(NAME(X));
state_save_register_device_item(device, 0, Y); device->save_item(NAME(Y));
state_save_register_device_item(device, 0, D); device->save_item(NAME(D));
state_save_register_device_item(device, 0, DP); device->save_item(NAME(DP));
state_save_register_device_item(device, 0, CC); device->save_item(NAME(CC));
state_save_register_device_item(device, 0, cpustate->int_state); device->save_item(NAME(cpustate->int_state));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->nmi_pending); device->save_item(NAME(cpustate->nmi_pending));
state_save_register_device_item(device, 0, cpustate->irq_state[0]); device->save_item(NAME(cpustate->irq_state[0]));
state_save_register_device_item(device, 0, cpustate->irq_state[1]); device->save_item(NAME(cpustate->irq_state[1]));
} }
static CPU_RESET( konami ) 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++) for (i = 0; i < 8; i++)
cpustate->timers[i] = device->machine->scheduler().timer_alloc(FUNC(m37710_timer_cb), cpustate); cpustate->timers[i] = device->machine->scheduler().timer_alloc(FUNC(m37710_timer_cb), cpustate);
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->b); device->save_item(NAME(cpustate->b));
state_save_register_device_item(device, 0, cpustate->ba); device->save_item(NAME(cpustate->ba));
state_save_register_device_item(device, 0, cpustate->bb); device->save_item(NAME(cpustate->bb));
state_save_register_device_item(device, 0, cpustate->x); device->save_item(NAME(cpustate->x));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->s); device->save_item(NAME(cpustate->s));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->ppc); device->save_item(NAME(cpustate->ppc));
state_save_register_device_item(device, 0, cpustate->pb); device->save_item(NAME(cpustate->pb));
state_save_register_device_item(device, 0, cpustate->db); device->save_item(NAME(cpustate->db));
state_save_register_device_item(device, 0, cpustate->d); device->save_item(NAME(cpustate->d));
state_save_register_device_item(device, 0, cpustate->flag_e); device->save_item(NAME(cpustate->flag_e));
state_save_register_device_item(device, 0, cpustate->flag_m); device->save_item(NAME(cpustate->flag_m));
state_save_register_device_item(device, 0, cpustate->flag_x); device->save_item(NAME(cpustate->flag_x));
state_save_register_device_item(device, 0, cpustate->flag_n); device->save_item(NAME(cpustate->flag_n));
state_save_register_device_item(device, 0, cpustate->flag_v); device->save_item(NAME(cpustate->flag_v));
state_save_register_device_item(device, 0, cpustate->flag_d); device->save_item(NAME(cpustate->flag_d));
state_save_register_device_item(device, 0, cpustate->flag_i); device->save_item(NAME(cpustate->flag_i));
state_save_register_device_item(device, 0, cpustate->flag_z); device->save_item(NAME(cpustate->flag_z));
state_save_register_device_item(device, 0, cpustate->flag_c); device->save_item(NAME(cpustate->flag_c));
state_save_register_device_item(device, 0, cpustate->line_irq); device->save_item(NAME(cpustate->line_irq));
state_save_register_device_item(device, 0, cpustate->ipl); device->save_item(NAME(cpustate->ipl));
state_save_register_device_item(device, 0, cpustate->ir); device->save_item(NAME(cpustate->ir));
state_save_register_device_item(device, 0, cpustate->im); device->save_item(NAME(cpustate->im));
state_save_register_device_item(device, 0, cpustate->im2); device->save_item(NAME(cpustate->im2));
state_save_register_device_item(device, 0, cpustate->im3); device->save_item(NAME(cpustate->im3));
state_save_register_device_item(device, 0, cpustate->im4); device->save_item(NAME(cpustate->im4));
state_save_register_device_item(device, 0, cpustate->irq_delay); device->save_item(NAME(cpustate->irq_delay));
state_save_register_device_item(device, 0, cpustate->irq_level); device->save_item(NAME(cpustate->irq_level));
state_save_register_device_item(device, 0, cpustate->stopped); device->save_item(NAME(cpustate->stopped));
state_save_register_device_item_array(device, 0, cpustate->m37710_regs); device->save_item(NAME(cpustate->m37710_regs));
state_save_register_device_item(device, 0, cpustate->reload[0]); device->save_item(NAME(cpustate->reload[0]));
state_save_register_device_item(device, 0, cpustate->reload[1]); device->save_item(NAME(cpustate->reload[1]));
state_save_register_device_item(device, 0, cpustate->reload[2]); device->save_item(NAME(cpustate->reload[2]));
state_save_register_device_item(device, 0, cpustate->reload[3]); device->save_item(NAME(cpustate->reload[3]));
state_save_register_device_item(device, 0, cpustate->reload[4]); device->save_item(NAME(cpustate->reload[4]));
state_save_register_device_item(device, 0, cpustate->reload[5]); device->save_item(NAME(cpustate->reload[5]));
state_save_register_device_item(device, 0, cpustate->reload[6]); device->save_item(NAME(cpustate->reload[6]));
state_save_register_device_item(device, 0, cpustate->reload[7]); device->save_item(NAME(cpustate->reload[7]));
device->machine->state().register_postload(m37710_restore_state, cpustate); 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; cpustate->port_write = intf->port_write_func;
} }
state_save_register_device_item(device, 0, cpustate->pc.w.l); device->save_item(NAME(cpustate->pc.w.l));
state_save_register_device_item(device, 0, cpustate->sp.w.l); device->save_item(NAME(cpustate->sp.w.l));
state_save_register_device_item(device, 0, cpustate->p); device->save_item(NAME(cpustate->p));
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->x); device->save_item(NAME(cpustate->x));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->pending_irq); device->save_item(NAME(cpustate->pending_irq));
state_save_register_device_item(device, 0, cpustate->after_cli); device->save_item(NAME(cpustate->after_cli));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->so_state); device->save_item(NAME(cpustate->so_state));
if (subtype == SUBTYPE_6510) if (subtype == SUBTYPE_6510)
{ {
state_save_register_device_item(device, 0, cpustate->port); device->save_item(NAME(cpustate->port));
state_save_register_device_item(device, 0, cpustate->ddr); 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) static void state_register(m6800_state *cpustate, const char *type)
{ {
state_save_register_device_item(cpustate->device, 0, cpustate->ppc.w.l); cpustate->device->save_item(NAME(cpustate->ppc.w.l));
state_save_register_device_item(cpustate->device, 0, cpustate->pc.w.l); cpustate->device->save_item(NAME(cpustate->pc.w.l));
state_save_register_device_item(cpustate->device, 0, cpustate->s.w.l); cpustate->device->save_item(NAME(cpustate->s.w.l));
state_save_register_device_item(cpustate->device, 0, cpustate->x.w.l); cpustate->device->save_item(NAME(cpustate->x.w.l));
state_save_register_device_item(cpustate->device, 0, cpustate->d.w.l); cpustate->device->save_item(NAME(cpustate->d.w.l));
state_save_register_device_item(cpustate->device, 0, cpustate->cc); cpustate->device->save_item(NAME(cpustate->cc));
state_save_register_device_item(cpustate->device, 0, cpustate->wai_state); cpustate->device->save_item(NAME(cpustate->wai_state));
state_save_register_device_item(cpustate->device, 0, cpustate->nmi_state); cpustate->device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(cpustate->device, 0, cpustate->nmi_pending); cpustate->device->save_item(NAME(cpustate->nmi_pending));
state_save_register_device_item_array(cpustate->device, 0, cpustate->irq_state); cpustate->device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(cpustate->device, 0, cpustate->ic_eddge); cpustate->device->save_item(NAME(cpustate->ic_eddge));
state_save_register_device_item(cpustate->device, 0, cpustate->port1_ddr); cpustate->device->save_item(NAME(cpustate->port1_ddr));
state_save_register_device_item(cpustate->device, 0, cpustate->port2_ddr); cpustate->device->save_item(NAME(cpustate->port2_ddr));
state_save_register_device_item(cpustate->device, 0, cpustate->port3_ddr); cpustate->device->save_item(NAME(cpustate->port3_ddr));
state_save_register_device_item(cpustate->device, 0, cpustate->port4_ddr); cpustate->device->save_item(NAME(cpustate->port4_ddr));
state_save_register_device_item(cpustate->device, 0, cpustate->port1_data); cpustate->device->save_item(NAME(cpustate->port1_data));
state_save_register_device_item(cpustate->device, 0, cpustate->port2_data); cpustate->device->save_item(NAME(cpustate->port2_data));
state_save_register_device_item(cpustate->device, 0, cpustate->port3_data); cpustate->device->save_item(NAME(cpustate->port3_data));
state_save_register_device_item(cpustate->device, 0, cpustate->port4_data); cpustate->device->save_item(NAME(cpustate->port4_data));
state_save_register_device_item(cpustate->device, 0, cpustate->port2_written); cpustate->device->save_item(NAME(cpustate->port2_written));
state_save_register_device_item(cpustate->device, 0, cpustate->port3_latched); cpustate->device->save_item(NAME(cpustate->port3_latched));
state_save_register_device_item(cpustate->device, 0, cpustate->p3csr); cpustate->device->save_item(NAME(cpustate->p3csr));
state_save_register_device_item(cpustate->device, 0, cpustate->p3csr_is3_flag_read); cpustate->device->save_item(NAME(cpustate->p3csr_is3_flag_read));
state_save_register_device_item(cpustate->device, 0, cpustate->tcsr); cpustate->device->save_item(NAME(cpustate->tcsr));
state_save_register_device_item(cpustate->device, 0, cpustate->pending_tcsr); cpustate->device->save_item(NAME(cpustate->pending_tcsr));
state_save_register_device_item(cpustate->device, 0, cpustate->irq2); cpustate->device->save_item(NAME(cpustate->irq2));
state_save_register_device_item(cpustate->device, 0, cpustate->ram_ctrl); cpustate->device->save_item(NAME(cpustate->ram_ctrl));
state_save_register_device_item(cpustate->device, 0, cpustate->counter.d); cpustate->device->save_item(NAME(cpustate->counter.d));
state_save_register_device_item(cpustate->device, 0, cpustate->output_compare.d); cpustate->device->save_item(NAME(cpustate->output_compare.d));
state_save_register_device_item(cpustate->device, 0, cpustate->input_capture); cpustate->device->save_item(NAME(cpustate->input_capture));
state_save_register_device_item(cpustate->device, 0, cpustate->timer_over.d); cpustate->device->save_item(NAME(cpustate->timer_over.d));
state_save_register_device_item(cpustate->device, 0, cpustate->clock); cpustate->device->save_item(NAME(cpustate->clock));
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr); cpustate->device->save_item(NAME(cpustate->trcsr));
state_save_register_device_item(cpustate->device, 0, cpustate->rmcr); cpustate->device->save_item(NAME(cpustate->rmcr));
state_save_register_device_item(cpustate->device, 0, cpustate->rdr); cpustate->device->save_item(NAME(cpustate->rdr));
state_save_register_device_item(cpustate->device, 0, cpustate->tdr); cpustate->device->save_item(NAME(cpustate->tdr));
state_save_register_device_item(cpustate->device, 0, cpustate->rsr); cpustate->device->save_item(NAME(cpustate->rsr));
state_save_register_device_item(cpustate->device, 0, cpustate->tsr); cpustate->device->save_item(NAME(cpustate->tsr));
state_save_register_device_item(cpustate->device, 0, cpustate->rxbits); cpustate->device->save_item(NAME(cpustate->rxbits));
state_save_register_device_item(cpustate->device, 0, cpustate->txbits); cpustate->device->save_item(NAME(cpustate->txbits));
state_save_register_device_item(cpustate->device, 0, cpustate->txstate); cpustate->device->save_item(NAME(cpustate->txstate));
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_tdre); cpustate->device->save_item(NAME(cpustate->trcsr_read_tdre));
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_orfe); cpustate->device->save_item(NAME(cpustate->trcsr_read_orfe));
state_save_register_device_item(cpustate->device, 0, cpustate->trcsr_read_rdrf); cpustate->device->save_item(NAME(cpustate->trcsr_read_rdrf));
state_save_register_device_item(cpustate->device, 0, cpustate->tx); cpustate->device->save_item(NAME(cpustate->tx));
} }
static CPU_INIT( m6800 ) 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 */ /* 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); device->save_item(NAME(REG_D));
state_save_register_device_item(device, 0, REG_PPC); device->save_item(NAME(REG_PPC));
state_save_register_device_item(device, 0, REG_PC); device->save_item(NAME(REG_PC));
state_save_register_device_item(device, 0, REG_USP); device->save_item(NAME(REG_USP));
state_save_register_device_item(device, 0, REG_ISP); device->save_item(NAME(REG_ISP));
state_save_register_device_item(device, 0, REG_MSP); device->save_item(NAME(REG_MSP));
state_save_register_device_item(device, 0, m68k->vbr); device->save_item(NAME(m68k->vbr));
state_save_register_device_item(device, 0, m68k->sfc); device->save_item(NAME(m68k->sfc));
state_save_register_device_item(device, 0, m68k->dfc); device->save_item(NAME(m68k->dfc));
state_save_register_device_item(device, 0, m68k->cacr); device->save_item(NAME(m68k->cacr));
state_save_register_device_item(device, 0, m68k->caar); device->save_item(NAME(m68k->caar));
state_save_register_device_item(device, 0, m68k->save_sr); device->save_item(NAME(m68k->save_sr));
state_save_register_device_item(device, 0, m68k->int_level); device->save_item(NAME(m68k->int_level));
state_save_register_device_item(device, 0, m68k->save_stopped); device->save_item(NAME(m68k->save_stopped));
state_save_register_device_item(device, 0, m68k->save_halted); device->save_item(NAME(m68k->save_halted));
state_save_register_device_item(device, 0, m68k->pref_addr); device->save_item(NAME(m68k->pref_addr));
state_save_register_device_item(device, 0, m68k->pref_data); device->save_item(NAME(m68k->pref_data));
device->machine->state().register_presave(m68k_presave, m68k); device->machine->state().register_presave(m68k_presave, m68k);
device->machine->state().register_postload(m68k_postload, 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) static void state_register(m6805_Regs *cpustate, const char *type, legacy_cpu_device *device)
{ {
state_save_register_device_item(device, 0, A); device->save_item(NAME(A));
state_save_register_device_item(device, 0, PC); device->save_item(NAME(PC));
state_save_register_device_item(device, 0, S); device->save_item(NAME(S));
state_save_register_device_item(device, 0, X); device->save_item(NAME(X));
state_save_register_device_item(device, 0, CC); device->save_item(NAME(CC));
state_save_register_device_item(device, 0, cpustate->pending_interrupts); device->save_item(NAME(cpustate->pending_interrupts));
state_save_register_device_item_array(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
} }
static CPU_INIT( m6805 ) static CPU_INIT( m6805 )

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

@ -383,18 +383,18 @@ static CPU_INIT( m6809 )
/* setup regtable */ /* setup regtable */
state_save_register_device_item(device, 0, PC); device->save_item(NAME(PC));
state_save_register_device_item(device, 0, PPC); device->save_item(NAME(PPC));
state_save_register_device_item(device, 0, D); device->save_item(NAME(D));
state_save_register_device_item(device, 0, DP); device->save_item(NAME(DP));
state_save_register_device_item(device, 0, U); device->save_item(NAME(U));
state_save_register_device_item(device, 0, S); device->save_item(NAME(S));
state_save_register_device_item(device, 0, X); device->save_item(NAME(X));
state_save_register_device_item(device, 0, Y); device->save_item(NAME(Y));
state_save_register_device_item(device, 0, CC); device->save_item(NAME(CC));
state_save_register_device_item_array(device, 0, m68_state->irq_state); device->save_item(NAME(m68_state->irq_state));
state_save_register_device_item(device, 0, m68_state->int_state); device->save_item(NAME(m68_state->int_state));
state_save_register_device_item(device, 0, m68_state->nmi_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); cpustate->serial = device->machine->scheduler().timer_alloc(FUNC(serial_timer), (void *)device);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->PA); device->save_item(NAME(cpustate->PA));
state_save_register_device_item(device, 0, cpustate->SP[0]); device->save_item(NAME(cpustate->SP[0]));
state_save_register_device_item(device, 0, cpustate->SP[1]); device->save_item(NAME(cpustate->SP[1]));
state_save_register_device_item(device, 0, cpustate->SP[2]); device->save_item(NAME(cpustate->SP[2]));
state_save_register_device_item(device, 0, cpustate->SP[3]); device->save_item(NAME(cpustate->SP[3]));
state_save_register_device_item(device, 0, cpustate->SI); device->save_item(NAME(cpustate->SI));
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->X); device->save_item(NAME(cpustate->X));
state_save_register_device_item(device, 0, cpustate->Y); device->save_item(NAME(cpustate->Y));
state_save_register_device_item(device, 0, cpustate->st); device->save_item(NAME(cpustate->st));
state_save_register_device_item(device, 0, cpustate->zf); device->save_item(NAME(cpustate->zf));
state_save_register_device_item(device, 0, cpustate->cf); device->save_item(NAME(cpustate->cf));
state_save_register_device_item(device, 0, cpustate->vf); device->save_item(NAME(cpustate->vf));
state_save_register_device_item(device, 0, cpustate->sf); device->save_item(NAME(cpustate->sf));
state_save_register_device_item(device, 0, cpustate->nf); device->save_item(NAME(cpustate->nf));
state_save_register_device_item(device, 0, cpustate->pio); device->save_item(NAME(cpustate->pio));
state_save_register_device_item(device, 0, cpustate->TH); device->save_item(NAME(cpustate->TH));
state_save_register_device_item(device, 0, cpustate->TL); device->save_item(NAME(cpustate->TL));
state_save_register_device_item(device, 0, cpustate->TP); device->save_item(NAME(cpustate->TP));
state_save_register_device_item(device, 0, cpustate->ctr); device->save_item(NAME(cpustate->ctr));
state_save_register_device_item(device, 0, cpustate->SB); device->save_item(NAME(cpustate->SB));
state_save_register_device_item(device, 0, cpustate->SBcount); device->save_item(NAME(cpustate->SBcount));
state_save_register_device_item(device, 0, cpustate->pending_interrupt); device->save_item(NAME(cpustate->pending_interrupt));
} }
static CPU_RESET( mb88 ) 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 */ /* ensure that regptr is valid before get_info gets called */
update_regptr(cpustate); update_regptr(cpustate);
state_save_register_device_item(device, 0, cpustate->prevpc); device->save_item(NAME(cpustate->prevpc));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->psw); device->save_item(NAME(cpustate->psw));
state_save_register_device_item(device, 0, cpustate->p1); device->save_item(NAME(cpustate->p1));
state_save_register_device_item(device, 0, cpustate->p2); device->save_item(NAME(cpustate->p2));
state_save_register_device_item(device, 0, cpustate->ea); device->save_item(NAME(cpustate->ea));
state_save_register_device_item(device, 0, cpustate->timer); device->save_item(NAME(cpustate->timer));
state_save_register_device_item(device, 0, cpustate->prescaler); device->save_item(NAME(cpustate->prescaler));
state_save_register_device_item(device, 0, cpustate->t1_history); device->save_item(NAME(cpustate->t1_history));
state_save_register_device_item(device, 0, cpustate->sts); device->save_item(NAME(cpustate->sts));
state_save_register_device_item(device, 0, cpustate->dbbi); device->save_item(NAME(cpustate->dbbi));
state_save_register_device_item(device, 0, cpustate->dbbo); device->save_item(NAME(cpustate->dbbo));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->irq_in_progress); device->save_item(NAME(cpustate->irq_in_progress));
state_save_register_device_item(device, 0, cpustate->timer_overflow); device->save_item(NAME(cpustate->timer_overflow));
state_save_register_device_item(device, 0, cpustate->timer_flag); device->save_item(NAME(cpustate->timer_flag));
state_save_register_device_item(device, 0, cpustate->tirq_enabled); device->save_item(NAME(cpustate->tirq_enabled));
state_save_register_device_item(device, 0, cpustate->xirq_enabled); device->save_item(NAME(cpustate->xirq_enabled));
state_save_register_device_item(device, 0, cpustate->timecount_enabled); device->save_item(NAME(cpustate->timecount_enabled));
state_save_register_device_item(device, 0, cpustate->flags_enabled); device->save_item(NAME(cpustate->flags_enabled));
state_save_register_device_item(device, 0, cpustate->dma_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 */ /* Save states */
state_save_register_device_item(device, 0, mcs51_state->ppc); device->save_item(NAME(mcs51_state->ppc));
state_save_register_device_item(device, 0, mcs51_state->pc); device->save_item(NAME(mcs51_state->pc));
state_save_register_device_item(device, 0, mcs51_state->rwm ); device->save_item(NAME(mcs51_state->rwm) );
state_save_register_device_item(device, 0, mcs51_state->cur_irq_prio ); device->save_item(NAME(mcs51_state->cur_irq_prio) );
state_save_register_device_item(device, 0, mcs51_state->last_line_state ); device->save_item(NAME(mcs51_state->last_line_state) );
state_save_register_device_item(device, 0, mcs51_state->t0_cnt ); device->save_item(NAME(mcs51_state->t0_cnt) );
state_save_register_device_item(device, 0, mcs51_state->t1_cnt ); device->save_item(NAME(mcs51_state->t1_cnt) );
state_save_register_device_item(device, 0, mcs51_state->t2_cnt ); device->save_item(NAME(mcs51_state->t2_cnt) );
state_save_register_device_item(device, 0, mcs51_state->t2ex_cnt ); device->save_item(NAME(mcs51_state->t2ex_cnt) );
state_save_register_device_item(device, 0, mcs51_state->recalc_parity ); device->save_item(NAME(mcs51_state->recalc_parity) );
state_save_register_device_item_array(device, 0, mcs51_state->irq_prio ); device->save_item(NAME(mcs51_state->irq_prio) );
state_save_register_device_item(device, 0, mcs51_state->irq_active ); device->save_item(NAME(mcs51_state->irq_active) );
} }
static CPU_INIT( i80c51 ) static CPU_INIT( i80c51 )
@ -2395,9 +2395,9 @@ static CPU_INIT( ds5002fp )
mcs51_state->sfr_read = ds5002fp_sfr_read; mcs51_state->sfr_read = ds5002fp_sfr_read;
mcs51_state->sfr_write = ds5002fp_sfr_write; mcs51_state->sfr_write = ds5002fp_sfr_write;
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.previous_ta ); device->save_item(NAME(mcs51_state->ds5002fp.previous_ta) );
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.ta_window ); device->save_item(NAME(mcs51_state->ds5002fp.ta_window) );
state_save_register_device_item(device, 0, mcs51_state->ds5002fp.range ); 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); mips3com_reset(mips);
/* register for save states */ /* register for save states */
state_save_register_device_item(device, 0, mips->pc); device->save_item(NAME(mips->pc));
state_save_register_device_item_array(device, 0, mips->r); device->save_item(NAME(mips->r));
state_save_register_device_item_2d_array(device, 0, mips->cpr); device->save_item(NAME(mips->cpr));
state_save_register_device_item_2d_array(device, 0, mips->ccr); device->save_item(NAME(mips->ccr));
state_save_register_device_item(device, 0, mips->llbit); device->save_item(NAME(mips->llbit));
state_save_register_device_item(device, 0, mips->count_zero_time); device->save_item(NAME(mips->count_zero_time));
for (tlbindex = 0; tlbindex < mips->tlbentries; tlbindex++) for (tlbindex = 0; tlbindex < mips->tlbentries; tlbindex++)
{ {
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].page_mask); device->save_item(NAME(mips->tlb[tlbindex].page_mask), tlbindex);
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].entry_hi); device->save_item(NAME(mips->tlb[tlbindex].entry_hi), tlbindex);
state_save_register_device_item_array(device, tlbindex, mips->tlb[tlbindex].entry_lo); 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); psxcpu_state *psxcpu = get_safe_token(device);
state_save_register_device_item( device, 0, psxcpu->op ); device->save_item( NAME(psxcpu->op) );
state_save_register_device_item( device, 0, psxcpu->pc ); device->save_item( NAME(psxcpu->pc) );
state_save_register_device_item( device, 0, psxcpu->delayv ); device->save_item( NAME(psxcpu->delayv) );
state_save_register_device_item( device, 0, psxcpu->delayr ); device->save_item( NAME(psxcpu->delayr) );
state_save_register_device_item( device, 0, psxcpu->hi ); device->save_item( NAME(psxcpu->hi) );
state_save_register_device_item( device, 0, psxcpu->lo ); device->save_item( NAME(psxcpu->lo) );
state_save_register_device_item( device, 0, psxcpu->biu ); device->save_item( NAME(psxcpu->biu) );
state_save_register_device_item_array( device, 0, psxcpu->r ); device->save_item( NAME(psxcpu->r) );
state_save_register_device_item_array( device, 0, psxcpu->cp0r ); device->save_item( NAME(psxcpu->cp0r) );
state_save_register_device_item_array( device, 0, psxcpu->cp2cr ); device->save_item( NAME(psxcpu->cp2cr) );
state_save_register_device_item_array( device, 0, psxcpu->cp2dr ); device->save_item( NAME(psxcpu->cp2dr) );
state_save_register_device_item_array( device, 0, psxcpu->icacheTag ); device->save_item( NAME(psxcpu->icacheTag) );
state_save_register_device_item_array( device, 0, psxcpu->icache ); device->save_item( NAME(psxcpu->icache) );
state_save_register_device_item_array( device, 0, psxcpu->dcache ); device->save_item( NAME(psxcpu->dcache) );
state_save_register_device_item( device, 0, psxcpu->multiplier_operation ); device->save_item( NAME(psxcpu->multiplier_operation) );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand1 ); device->save_item( NAME(psxcpu->multiplier_operand1) );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand2 ); device->save_item( NAME(psxcpu->multiplier_operand2) );
device->machine->state().register_postload( mips_postload, psxcpu ); 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->program = device->space(AS_PROGRAM);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item_array(device, 0, cpustate->d); device->save_item(NAME(cpustate->d));
state_save_register_device_item_array(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->nmicr); device->save_item(NAME(cpustate->nmicr));
state_save_register_device_item(device, 0, cpustate->iagr); device->save_item(NAME(cpustate->iagr));
state_save_register_device_item_array(device, 0, cpustate->icrl); device->save_item(NAME(cpustate->icrl));
state_save_register_device_item_array(device, 0, cpustate->icrh); device->save_item(NAME(cpustate->icrh));
state_save_register_device_item(device, 0, cpustate->psw); device->save_item(NAME(cpustate->psw));
state_save_register_device_item(device, 0, cpustate->mdr); device->save_item(NAME(cpustate->mdr));
// state_save_register_device_item_array(device, 0, cpustate->simple_timer); // device->save_item(NAME(cpustate->simple_timer));
// state_save_register_device_item_array(device, 0, cpustate->prescaler); // device->save_item(NAME(cpustate->prescaler));
// state_save_register_device_item_array(device, 0, cpustate->dma); // device->save_item(NAME(cpustate->dma));
// state_save_register_device_item_array(device, 0, cpustate->serial); // device->save_item(NAME(cpustate->serial));
state_save_register_device_item_array(device, 0, cpustate->ddr); device->save_item(NAME(cpustate->ddr));
for (tmr = 0; tmr < NUM_TIMERS_8BIT; tmr++) 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)); memset(nec_state, 0, sizeof(nec_state));
state_save_register_device_item_array(device, 0, nec_state->regs.w); device->save_item(NAME(nec_state->regs.w));
state_save_register_device_item_array(device, 0, nec_state->sregs); device->save_item(NAME(nec_state->sregs));
state_save_register_device_item(device, 0, nec_state->ip); device->save_item(NAME(nec_state->ip));
state_save_register_device_item(device, 0, nec_state->TF); device->save_item(NAME(nec_state->TF));
state_save_register_device_item(device, 0, nec_state->IF); device->save_item(NAME(nec_state->IF));
state_save_register_device_item(device, 0, nec_state->DF); device->save_item(NAME(nec_state->DF));
state_save_register_device_item(device, 0, nec_state->MF); device->save_item(NAME(nec_state->MF));
state_save_register_device_item(device, 0, nec_state->SignVal); device->save_item(NAME(nec_state->SignVal));
state_save_register_device_item(device, 0, nec_state->AuxVal); device->save_item(NAME(nec_state->AuxVal));
state_save_register_device_item(device, 0, nec_state->OverVal); device->save_item(NAME(nec_state->OverVal));
state_save_register_device_item(device, 0, nec_state->ZeroVal); device->save_item(NAME(nec_state->ZeroVal));
state_save_register_device_item(device, 0, nec_state->CarryVal); device->save_item(NAME(nec_state->CarryVal));
state_save_register_device_item(device, 0, nec_state->ParityVal); device->save_item(NAME(nec_state->ParityVal));
state_save_register_device_item(device, 0, nec_state->pending_irq); device->save_item(NAME(nec_state->pending_irq));
state_save_register_device_item(device, 0, nec_state->nmi_state); device->save_item(NAME(nec_state->nmi_state));
state_save_register_device_item(device, 0, nec_state->irq_state); device->save_item(NAME(nec_state->irq_state));
state_save_register_device_item(device, 0, nec_state->poll_state); device->save_item(NAME(nec_state->poll_state));
nec_state->irq_callback = irqcallback; nec_state->irq_callback = irqcallback;
nec_state->device = device; 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++) for (int i = 0; i < 4; i++)
nec_state->timers[i] = device->machine->scheduler().timer_alloc(FUNC(v25_timer_callback), nec_state); 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); device->save_item(NAME(nec_state->ram.w));
state_save_register_device_item_array(device, 0, nec_state->intp_state); device->save_item(NAME(nec_state->intp_state));
state_save_register_device_item(device, 0, nec_state->ip); device->save_item(NAME(nec_state->ip));
state_save_register_device_item(device, 0, nec_state->IBRK); device->save_item(NAME(nec_state->IBRK));
state_save_register_device_item(device, 0, nec_state->F0); device->save_item(NAME(nec_state->F0));
state_save_register_device_item(device, 0, nec_state->F1); device->save_item(NAME(nec_state->F1));
state_save_register_device_item(device, 0, nec_state->TF); device->save_item(NAME(nec_state->TF));
state_save_register_device_item(device, 0, nec_state->IF); device->save_item(NAME(nec_state->IF));
state_save_register_device_item(device, 0, nec_state->DF); device->save_item(NAME(nec_state->DF));
state_save_register_device_item(device, 0, nec_state->MF); device->save_item(NAME(nec_state->MF));
state_save_register_device_item(device, 0, nec_state->RBW); device->save_item(NAME(nec_state->RBW));
state_save_register_device_item(device, 0, nec_state->RBB); device->save_item(NAME(nec_state->RBB));
state_save_register_device_item(device, 0, nec_state->SignVal); device->save_item(NAME(nec_state->SignVal));
state_save_register_device_item(device, 0, nec_state->AuxVal); device->save_item(NAME(nec_state->AuxVal));
state_save_register_device_item(device, 0, nec_state->OverVal); device->save_item(NAME(nec_state->OverVal));
state_save_register_device_item(device, 0, nec_state->ZeroVal); device->save_item(NAME(nec_state->ZeroVal));
state_save_register_device_item(device, 0, nec_state->CarryVal); device->save_item(NAME(nec_state->CarryVal));
state_save_register_device_item(device, 0, nec_state->ParityVal); device->save_item(NAME(nec_state->ParityVal));
state_save_register_device_item(device, 0, nec_state->pending_irq); device->save_item(NAME(nec_state->pending_irq));
state_save_register_device_item(device, 0, nec_state->unmasked_irq); device->save_item(NAME(nec_state->unmasked_irq));
state_save_register_device_item(device, 0, nec_state->bankswitch_irq); device->save_item(NAME(nec_state->bankswitch_irq));
state_save_register_device_item(device, 0, nec_state->priority_inttu); device->save_item(NAME(nec_state->priority_inttu));
state_save_register_device_item(device, 0, nec_state->priority_intd); device->save_item(NAME(nec_state->priority_intd));
state_save_register_device_item(device, 0, nec_state->priority_intp); device->save_item(NAME(nec_state->priority_intp));
state_save_register_device_item(device, 0, nec_state->priority_ints0); device->save_item(NAME(nec_state->priority_ints0));
state_save_register_device_item(device, 0, nec_state->priority_ints1); device->save_item(NAME(nec_state->priority_ints1));
state_save_register_device_item(device, 0, nec_state->IRQS); device->save_item(NAME(nec_state->IRQS));
state_save_register_device_item(device, 0, nec_state->ISPR); device->save_item(NAME(nec_state->ISPR));
state_save_register_device_item(device, 0, nec_state->nmi_state); device->save_item(NAME(nec_state->nmi_state));
state_save_register_device_item(device, 0, nec_state->irq_state); device->save_item(NAME(nec_state->irq_state));
state_save_register_device_item(device, 0, nec_state->poll_state); device->save_item(NAME(nec_state->poll_state));
state_save_register_device_item(device, 0, nec_state->mode_state); device->save_item(NAME(nec_state->mode_state));
state_save_register_device_item(device, 0, nec_state->TM0); device->save_item(NAME(nec_state->TM0));
state_save_register_device_item(device, 0, nec_state->MD0); device->save_item(NAME(nec_state->MD0));
state_save_register_device_item(device, 0, nec_state->TM1); device->save_item(NAME(nec_state->TM1));
state_save_register_device_item(device, 0, nec_state->MD1); device->save_item(NAME(nec_state->MD1));
state_save_register_device_item(device, 0, nec_state->TMC0); device->save_item(NAME(nec_state->TMC0));
state_save_register_device_item(device, 0, nec_state->TMC1); device->save_item(NAME(nec_state->TMC1));
state_save_register_device_item(device, 0, nec_state->RAMEN); device->save_item(NAME(nec_state->RAMEN));
state_save_register_device_item(device, 0, nec_state->TB); device->save_item(NAME(nec_state->TB));
state_save_register_device_item(device, 0, nec_state->PCK); device->save_item(NAME(nec_state->PCK));
state_save_register_device_item(device, 0, nec_state->IDB); device->save_item(NAME(nec_state->IDB));
nec_state->irq_callback = irqcallback; nec_state->irq_callback = irqcallback;
nec_state->device = device; 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 */ /* ensure the internal ram pointers are set before get_info is called */
update_internalram_ptr(cpustate); update_internalram_ptr(cpustate);
state_save_register_device_item(device, 0, cpustate->W); device->save_item(NAME(cpustate->W));
state_save_register_device_item(device, 0, cpustate->ALU); device->save_item(NAME(cpustate->ALU));
state_save_register_device_item(device, 0, cpustate->OPTION); device->save_item(NAME(cpustate->OPTION));
state_save_register_device_item(device, 0, cpustate->TMR0); device->save_item(NAME(cpustate->TMR0));
state_save_register_device_item(device, 0, cpustate->PCL); device->save_item(NAME(cpustate->PCL));
state_save_register_device_item(device, 0, cpustate->STATUS); device->save_item(NAME(cpustate->STATUS));
state_save_register_device_item(device, 0, cpustate->FSR); device->save_item(NAME(cpustate->FSR));
state_save_register_device_item(device, 0, cpustate->PORTA); device->save_item(NAME(cpustate->PORTA));
state_save_register_device_item(device, 0, cpustate->PORTB); device->save_item(NAME(cpustate->PORTB));
state_save_register_device_item(device, 0, cpustate->PORTC); device->save_item(NAME(cpustate->PORTC));
state_save_register_device_item(device, 0, cpustate->TRISA); device->save_item(NAME(cpustate->TRISA));
state_save_register_device_item(device, 0, cpustate->TRISB); device->save_item(NAME(cpustate->TRISB));
state_save_register_device_item(device, 0, cpustate->TRISC); device->save_item(NAME(cpustate->TRISC));
state_save_register_device_item(device, 0, cpustate->old_T0); device->save_item(NAME(cpustate->old_T0));
state_save_register_device_item(device, 0, cpustate->old_data); device->save_item(NAME(cpustate->old_data));
state_save_register_device_item(device, 0, cpustate->picRAMmask); device->save_item(NAME(cpustate->picRAMmask));
state_save_register_device_item(device, 0, cpustate->WDT); device->save_item(NAME(cpustate->WDT));
state_save_register_device_item(device, 0, cpustate->prescaler); device->save_item(NAME(cpustate->prescaler));
state_save_register_device_item(device, 0, cpustate->STACK[0]); device->save_item(NAME(cpustate->STACK[0]));
state_save_register_device_item(device, 0, cpustate->STACK[1]); device->save_item(NAME(cpustate->STACK[1]));
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->PREVPC); device->save_item(NAME(cpustate->PREVPC));
state_save_register_device_item(device, 0, cpustate->CONFIG); device->save_item(NAME(cpustate->CONFIG));
state_save_register_device_item(device, 0, cpustate->opcode.d); device->save_item(NAME(cpustate->opcode.d));
state_save_register_device_item(device, 0, cpustate->delay_timer); device->save_item(NAME(cpustate->delay_timer));
state_save_register_device_item(device, 0, cpustate->picmodel); device->save_item(NAME(cpustate->picmodel));
state_save_register_device_item(device, 0, cpustate->reset_vector); device->save_item(NAME(cpustate->reset_vector));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->temp_config); device->save_item(NAME(cpustate->temp_config));
state_save_register_device_item(device, 0, cpustate->inst_cycles); 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(); build_opcode_table();
state_save_register_device_item(device, 0, cpustate->W); device->save_item(NAME(cpustate->W));
state_save_register_device_item(device, 0, cpustate->ALU); device->save_item(NAME(cpustate->ALU));
state_save_register_device_item(device, 0, cpustate->OPTION); device->save_item(NAME(cpustate->OPTION));
state_save_register_device_item(device, 0, cpustate->PCLATH); device->save_item(NAME(cpustate->PCLATH));
state_save_register_device_item(device, 0, cpustate->TMR0); device->save_item(NAME(cpustate->TMR0));
state_save_register_device_item(device, 0, cpustate->PCL); device->save_item(NAME(cpustate->PCL));
state_save_register_device_item(device, 0, cpustate->STATUS); device->save_item(NAME(cpustate->STATUS));
state_save_register_device_item(device, 0, cpustate->FSR); device->save_item(NAME(cpustate->FSR));
state_save_register_device_item(device, 0, cpustate->PORTA); device->save_item(NAME(cpustate->PORTA));
state_save_register_device_item(device, 0, cpustate->PORTB); device->save_item(NAME(cpustate->PORTB));
state_save_register_device_item(device, 0, cpustate->TRISA); device->save_item(NAME(cpustate->TRISA));
state_save_register_device_item(device, 0, cpustate->TRISB); device->save_item(NAME(cpustate->TRISB));
state_save_register_device_item(device, 0, cpustate->old_T0); device->save_item(NAME(cpustate->old_T0));
state_save_register_device_item(device, 0, cpustate->old_data); device->save_item(NAME(cpustate->old_data));
state_save_register_device_item(device, 0, cpustate->picRAMmask); device->save_item(NAME(cpustate->picRAMmask));
state_save_register_device_item(device, 0, cpustate->WDT); device->save_item(NAME(cpustate->WDT));
state_save_register_device_item(device, 0, cpustate->prescaler); device->save_item(NAME(cpustate->prescaler));
state_save_register_device_item(device, 0, cpustate->STACK[0]); device->save_item(NAME(cpustate->STACK[0]));
state_save_register_device_item(device, 0, cpustate->STACK[1]); device->save_item(NAME(cpustate->STACK[1]));
state_save_register_device_item(device, 0, cpustate->STACK[2]); device->save_item(NAME(cpustate->STACK[2]));
state_save_register_device_item(device, 0, cpustate->STACK[3]); device->save_item(NAME(cpustate->STACK[3]));
state_save_register_device_item(device, 0, cpustate->STACK[4]); device->save_item(NAME(cpustate->STACK[4]));
state_save_register_device_item(device, 0, cpustate->STACK[5]); device->save_item(NAME(cpustate->STACK[5]));
state_save_register_device_item(device, 0, cpustate->STACK[6]); device->save_item(NAME(cpustate->STACK[6]));
state_save_register_device_item(device, 0, cpustate->STACK[7]); device->save_item(NAME(cpustate->STACK[7]));
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->PREVPC); device->save_item(NAME(cpustate->PREVPC));
state_save_register_device_item(device, 0, cpustate->CONFIG); device->save_item(NAME(cpustate->CONFIG));
state_save_register_device_item(device, 0, cpustate->opcode.d); device->save_item(NAME(cpustate->opcode.d));
state_save_register_device_item(device, 0, cpustate->delay_timer); device->save_item(NAME(cpustate->delay_timer));
state_save_register_device_item(device, 0, cpustate->picmodel); device->save_item(NAME(cpustate->picmodel));
state_save_register_device_item(device, 0, cpustate->reset_vector); device->save_item(NAME(cpustate->reset_vector));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->temp_config); device->save_item(NAME(cpustate->temp_config));
state_save_register_device_item(device, 0, cpustate->inst_cycles); 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 */ /* register for save states */
state_save_register_device_item(device, 0, ppc->pc); device->save_item(NAME(ppc->pc));
state_save_register_device_item_array(device, 0, ppc->r); device->save_item(NAME(ppc->r));
state_save_register_device_item_array(device, 0, ppc->f); device->save_item(NAME(ppc->f));
state_save_register_device_item_array(device, 0, ppc->cr); device->save_item(NAME(ppc->cr));
state_save_register_device_item(device, 0, ppc->xerso); device->save_item(NAME(ppc->xerso));
state_save_register_device_item(device, 0, ppc->fpscr); device->save_item(NAME(ppc->fpscr));
state_save_register_device_item(device, 0, ppc->msr); device->save_item(NAME(ppc->msr));
state_save_register_device_item_array(device, 0, ppc->sr); device->save_item(NAME(ppc->sr));
state_save_register_device_item_array(device, 0, ppc->spr); device->save_item(NAME(ppc->spr));
state_save_register_device_item_array(device, 0, ppc->dcr); device->save_item(NAME(ppc->dcr));
if (cap & PPCCAP_4XX) if (cap & PPCCAP_4XX)
{ {
state_save_register_device_item_array(device, 0, ppc->spu.regs); device->save_item(NAME(ppc->spu.regs));
state_save_register_device_item(device, 0, ppc->spu.txbuf); device->save_item(NAME(ppc->spu.txbuf));
state_save_register_device_item(device, 0, ppc->spu.rxbuf); device->save_item(NAME(ppc->spu.rxbuf));
state_save_register_device_item_array(device, 0, ppc->spu.rxbuffer); device->save_item(NAME(ppc->spu.rxbuffer));
state_save_register_device_item(device, 0, ppc->spu.rxin); device->save_item(NAME(ppc->spu.rxin));
state_save_register_device_item(device, 0, ppc->spu.rxout); device->save_item(NAME(ppc->spu.rxout));
state_save_register_device_item(device, 0, ppc->pit_reload); device->save_item(NAME(ppc->pit_reload));
state_save_register_device_item(device, 0, ppc->irqstate); device->save_item(NAME(ppc->irqstate));
} }
if (cap & PPCCAP_603_MMU) if (cap & PPCCAP_603_MMU)
{ {
state_save_register_device_item(device, 0, ppc->mmu603_cmp); device->save_item(NAME(ppc->mmu603_cmp));
state_save_register_device_item_array(device, 0, ppc->mmu603_hash); device->save_item(NAME(ppc->mmu603_hash));
state_save_register_device_item_array(device, 0, ppc->mmu603_r); device->save_item(NAME(ppc->mmu603_r));
} }
state_save_register_device_item(device, 0, ppc->irq_pending); device->save_item(NAME(ppc->irq_pending));
state_save_register_device_item(device, 0, ppc->tb_zero_cycles); device->save_item(NAME(ppc->tb_zero_cycles));
state_save_register_device_item(device, 0, ppc->dec_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->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->A); device->save_item(NAME(cpustate->A));
state_save_register_device_item(device, 0, cpustate->X); device->save_item(NAME(cpustate->X));
state_save_register_device_item(device, 0, cpustate->P); device->save_item(NAME(cpustate->P));
state_save_register_device_item(device, 0, cpustate->SA); device->save_item(NAME(cpustate->SA));
state_save_register_device_item(device, 0, cpustate->SB); device->save_item(NAME(cpustate->SB));
state_save_register_device_item(device, 0, cpustate->B); device->save_item(NAME(cpustate->B));
state_save_register_device_item(device, 0, cpustate->C); device->save_item(NAME(cpustate->C));
state_save_register_device_item(device, 0, cpustate->FF1); device->save_item(NAME(cpustate->FF1));
state_save_register_device_item(device, 0, cpustate->FF2); 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->direct = &s2650c->program->direct();
s2650c->io = device->space(AS_IO); s2650c->io = device->space(AS_IO);
state_save_register_device_item(device, 0, s2650c->ppc); device->save_item(NAME(s2650c->ppc));
state_save_register_device_item(device, 0, s2650c->page); device->save_item(NAME(s2650c->page));
state_save_register_device_item(device, 0, s2650c->iar); device->save_item(NAME(s2650c->iar));
state_save_register_device_item(device, 0, s2650c->ea); device->save_item(NAME(s2650c->ea));
state_save_register_device_item(device, 0, s2650c->psl); device->save_item(NAME(s2650c->psl));
state_save_register_device_item(device, 0, s2650c->psu); device->save_item(NAME(s2650c->psu));
state_save_register_device_item(device, 0, s2650c->r); device->save_item(NAME(s2650c->r));
state_save_register_device_item_array(device, 0, s2650c->reg); device->save_item(NAME(s2650c->reg));
state_save_register_device_item(device, 0, s2650c->halt); device->save_item(NAME(s2650c->halt));
state_save_register_device_item(device, 0, s2650c->ir); device->save_item(NAME(s2650c->ir));
state_save_register_device_item_array(device, 0, s2650c->ras); device->save_item(NAME(s2650c->ras));
state_save_register_device_item(device, 0, s2650c->irq_state); device->save_item(NAME(s2650c->irq_state));
} }
static CPU_RESET( s2650 ) 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->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct(); cpustate->direct = &cpustate->program->direct();
state_save_register_device_item_array(device, 0,cpustate->reg[R0]); device->save_item(NAME(cpustate->reg[R0]));
state_save_register_device_item_array(device, 0,cpustate->reg[R1]); device->save_item(NAME(cpustate->reg[R1]));
state_save_register_device_item_array(device, 0,cpustate->reg[R2]); device->save_item(NAME(cpustate->reg[R2]));
state_save_register_device_item_array(device, 0,cpustate->reg[R3]); device->save_item(NAME(cpustate->reg[R3]));
state_save_register_device_item_array(device, 0,cpustate->reg[R4]); device->save_item(NAME(cpustate->reg[R4]));
state_save_register_device_item_array(device, 0,cpustate->reg[A]); device->save_item(NAME(cpustate->reg[A]));
state_save_register_device_item_array(device, 0,cpustate->reg[B]); device->save_item(NAME(cpustate->reg[B]));
state_save_register_device_item_array(device, 0,cpustate->reg[C]); device->save_item(NAME(cpustate->reg[C]));
state_save_register_device_item_array(device, 0,cpustate->reg[D]); device->save_item(NAME(cpustate->reg[D]));
state_save_register_device_item_array(device, 0,cpustate->d); device->save_item(NAME(cpustate->d));
state_save_register_device_item(device, 0,cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0,cpustate->oldpc); device->save_item(NAME(cpustate->oldpc));
state_save_register_device_item_array(device, 0,cpustate->rstk); device->save_item(NAME(cpustate->rstk));
state_save_register_device_item(device, 0,cpustate->out); device->save_item(NAME(cpustate->out));
state_save_register_device_item(device, 0,cpustate->carry); device->save_item(NAME(cpustate->carry));
state_save_register_device_item(device, 0,cpustate->st); device->save_item(NAME(cpustate->st));
state_save_register_device_item(device, 0,cpustate->hst); device->save_item(NAME(cpustate->hst));
state_save_register_device_item(device, 0,cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0,cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0,cpustate->irq_enable); device->save_item(NAME(cpustate->irq_enable));
state_save_register_device_item(device, 0,cpustate->in_irq); device->save_item(NAME(cpustate->in_irq));
state_save_register_device_item(device, 0,cpustate->pending_irq); device->save_item(NAME(cpustate->pending_irq));
state_save_register_device_item(device, 0,cpustate->sleeping); device->save_item(NAME(cpustate->sleeping));
} }
static CPU_RESET( saturn ) 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_read_line(&cpustate->senseb_func, &cpustate->config.senseb_func, device);
devcb_resolve_write_line(&cpustate->halt_func, &cpustate->config.halt_func, device); devcb_resolve_write_line(&cpustate->halt_func, &cpustate->config.halt_func, device);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->P1); device->save_item(NAME(cpustate->P1));
state_save_register_device_item(device, 0, cpustate->P2); device->save_item(NAME(cpustate->P2));
state_save_register_device_item(device, 0, cpustate->P3); device->save_item(NAME(cpustate->P3));
state_save_register_device_item(device, 0, cpustate->AC); device->save_item(NAME(cpustate->AC));
state_save_register_device_item(device, 0, cpustate->ER); device->save_item(NAME(cpustate->ER));
state_save_register_device_item(device, 0, cpustate->SR); 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->direct = &sh2->program->direct();
sh2->internal = device->space(AS_PROGRAM); sh2->internal = device->space(AS_PROGRAM);
state_save_register_device_item(device, 0, sh2->pc); device->save_item(NAME(sh2->pc));
state_save_register_device_item(device, 0, sh2->sr); device->save_item(NAME(sh2->sr));
state_save_register_device_item(device, 0, sh2->pr); device->save_item(NAME(sh2->pr));
state_save_register_device_item(device, 0, sh2->gbr); device->save_item(NAME(sh2->gbr));
state_save_register_device_item(device, 0, sh2->vbr); device->save_item(NAME(sh2->vbr));
state_save_register_device_item(device, 0, sh2->mach); device->save_item(NAME(sh2->mach));
state_save_register_device_item(device, 0, sh2->macl); device->save_item(NAME(sh2->macl));
state_save_register_device_item_array(device, 0, sh2->r); device->save_item(NAME(sh2->r));
state_save_register_device_item(device, 0, sh2->ea); device->save_item(NAME(sh2->ea));
state_save_register_device_item(device, 0, sh2->delay); device->save_item(NAME(sh2->delay));
state_save_register_device_item(device, 0, sh2->cpu_off); device->save_item(NAME(sh2->cpu_off));
state_save_register_device_item(device, 0, sh2->dvsr); device->save_item(NAME(sh2->dvsr));
state_save_register_device_item(device, 0, sh2->dvdnth); device->save_item(NAME(sh2->dvdnth));
state_save_register_device_item(device, 0, sh2->dvdntl); device->save_item(NAME(sh2->dvdntl));
state_save_register_device_item(device, 0, sh2->dvcr); device->save_item(NAME(sh2->dvcr));
state_save_register_device_item(device, 0, sh2->pending_irq); device->save_item(NAME(sh2->pending_irq));
state_save_register_device_item(device, 0, sh2->test_irq); device->save_item(NAME(sh2->test_irq));
state_save_register_device_item(device, 0, sh2->pending_nmi); device->save_item(NAME(sh2->pending_nmi));
state_save_register_device_item(device, 0, sh2->irqline); device->save_item(NAME(sh2->irqline));
state_save_register_device_item(device, 0, sh2->evec); device->save_item(NAME(sh2->evec));
state_save_register_device_item(device, 0, sh2->irqsr); device->save_item(NAME(sh2->irqsr));
state_save_register_device_item(device, 0, sh2->target); device->save_item(NAME(sh2->target));
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)
{ {
state_save_register_device_item(device, i, sh2->irq_queue[i].irq_vector); device->save_item(NAME(sh2->irq_queue[i].irq_vector), i);
state_save_register_device_item(device, i, sh2->irq_queue[i].irq_priority); device->save_item(NAME(sh2->irq_queue[i].irq_priority), i);
} }
state_save_register_device_item(device, 0, sh2->pcfsel); device->save_item(NAME(sh2->pcfsel));
state_save_register_device_item(device, 0, sh2->maxpcfsel); device->save_item(NAME(sh2->maxpcfsel));
state_save_register_device_item_array(device, 0, sh2->pcflushes); device->save_item(NAME(sh2->pcflushes));
state_save_register_device_item_array(device, 0, sh2->irq_line_state); device->save_item(NAME(sh2->irq_line_state));
state_save_register_device_item_pointer(device, 0, sh2->m, 0x200/4); device->save_pointer(NAME(sh2->m), 0x200/4);
state_save_register_device_item(device, 0, sh2->nmi_line_state); device->save_item(NAME(sh2->nmi_line_state));
state_save_register_device_item(device, 0, sh2->frc); device->save_item(NAME(sh2->frc));
state_save_register_device_item(device, 0, sh2->ocra); device->save_item(NAME(sh2->ocra));
state_save_register_device_item(device, 0, sh2->ocrb); device->save_item(NAME(sh2->ocrb));
state_save_register_device_item(device, 0, sh2->icr); device->save_item(NAME(sh2->icr));
state_save_register_device_item(device, 0, sh2->frc_base); device->save_item(NAME(sh2->frc_base));
state_save_register_device_item(device, 0, sh2->frt_input); device->save_item(NAME(sh2->frt_input));
state_save_register_device_item(device, 0, sh2->internal_irq_level); device->save_item(NAME(sh2->internal_irq_level));
state_save_register_device_item(device, 0, sh2->internal_irq_vector); device->save_item(NAME(sh2->internal_irq_vector));
state_save_register_device_item_array(device, 0, sh2->dma_timer_active); 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->irln = 15;
sh4->test_irq = 0; sh4->test_irq = 0;
state_save_register_device_item(device, 0, sh4->pc); device->save_item(NAME(sh4->pc));
state_save_register_device_item(device, 0, sh4->r[15]); device->save_item(NAME(sh4->r[15]));
state_save_register_device_item(device, 0, sh4->sr); device->save_item(NAME(sh4->sr));
state_save_register_device_item(device, 0, sh4->pr); device->save_item(NAME(sh4->pr));
state_save_register_device_item(device, 0, sh4->gbr); device->save_item(NAME(sh4->gbr));
state_save_register_device_item(device, 0, sh4->vbr); device->save_item(NAME(sh4->vbr));
state_save_register_device_item(device, 0, sh4->mach); device->save_item(NAME(sh4->mach));
state_save_register_device_item(device, 0, sh4->macl); device->save_item(NAME(sh4->macl));
state_save_register_device_item(device, 0, sh4->spc); device->save_item(NAME(sh4->spc));
state_save_register_device_item(device, 0, sh4->ssr); device->save_item(NAME(sh4->ssr));
state_save_register_device_item(device, 0, sh4->sgr); device->save_item(NAME(sh4->sgr));
state_save_register_device_item(device, 0, sh4->fpscr); device->save_item(NAME(sh4->fpscr));
state_save_register_device_item(device, 0, sh4->r[ 0]); device->save_item(NAME(sh4->r[ 0]));
state_save_register_device_item(device, 0, sh4->r[ 1]); device->save_item(NAME(sh4->r[ 1]));
state_save_register_device_item(device, 0, sh4->r[ 2]); device->save_item(NAME(sh4->r[ 2]));
state_save_register_device_item(device, 0, sh4->r[ 3]); device->save_item(NAME(sh4->r[ 3]));
state_save_register_device_item(device, 0, sh4->r[ 4]); device->save_item(NAME(sh4->r[ 4]));
state_save_register_device_item(device, 0, sh4->r[ 5]); device->save_item(NAME(sh4->r[ 5]));
state_save_register_device_item(device, 0, sh4->r[ 6]); device->save_item(NAME(sh4->r[ 6]));
state_save_register_device_item(device, 0, sh4->r[ 7]); device->save_item(NAME(sh4->r[ 7]));
state_save_register_device_item(device, 0, sh4->r[ 8]); device->save_item(NAME(sh4->r[ 8]));
state_save_register_device_item(device, 0, sh4->r[ 9]); device->save_item(NAME(sh4->r[ 9]));
state_save_register_device_item(device, 0, sh4->r[10]); device->save_item(NAME(sh4->r[10]));
state_save_register_device_item(device, 0, sh4->r[11]); device->save_item(NAME(sh4->r[11]));
state_save_register_device_item(device, 0, sh4->r[12]); device->save_item(NAME(sh4->r[12]));
state_save_register_device_item(device, 0, sh4->r[13]); device->save_item(NAME(sh4->r[13]));
state_save_register_device_item(device, 0, sh4->r[14]); device->save_item(NAME(sh4->r[14]));
state_save_register_device_item(device, 0, sh4->fr[ 0]); device->save_item(NAME(sh4->fr[ 0]));
state_save_register_device_item(device, 0, sh4->fr[ 1]); device->save_item(NAME(sh4->fr[ 1]));
state_save_register_device_item(device, 0, sh4->fr[ 2]); device->save_item(NAME(sh4->fr[ 2]));
state_save_register_device_item(device, 0, sh4->fr[ 3]); device->save_item(NAME(sh4->fr[ 3]));
state_save_register_device_item(device, 0, sh4->fr[ 4]); device->save_item(NAME(sh4->fr[ 4]));
state_save_register_device_item(device, 0, sh4->fr[ 5]); device->save_item(NAME(sh4->fr[ 5]));
state_save_register_device_item(device, 0, sh4->fr[ 6]); device->save_item(NAME(sh4->fr[ 6]));
state_save_register_device_item(device, 0, sh4->fr[ 7]); device->save_item(NAME(sh4->fr[ 7]));
state_save_register_device_item(device, 0, sh4->fr[ 8]); device->save_item(NAME(sh4->fr[ 8]));
state_save_register_device_item(device, 0, sh4->fr[ 9]); device->save_item(NAME(sh4->fr[ 9]));
state_save_register_device_item(device, 0, sh4->fr[10]); device->save_item(NAME(sh4->fr[10]));
state_save_register_device_item(device, 0, sh4->fr[11]); device->save_item(NAME(sh4->fr[11]));
state_save_register_device_item(device, 0, sh4->fr[12]); device->save_item(NAME(sh4->fr[12]));
state_save_register_device_item(device, 0, sh4->fr[13]); device->save_item(NAME(sh4->fr[13]));
state_save_register_device_item(device, 0, sh4->fr[14]); device->save_item(NAME(sh4->fr[14]));
state_save_register_device_item(device, 0, sh4->fr[15]); device->save_item(NAME(sh4->fr[15]));
state_save_register_device_item(device, 0, sh4->xf[ 0]); device->save_item(NAME(sh4->xf[ 0]));
state_save_register_device_item(device, 0, sh4->xf[ 1]); device->save_item(NAME(sh4->xf[ 1]));
state_save_register_device_item(device, 0, sh4->xf[ 2]); device->save_item(NAME(sh4->xf[ 2]));
state_save_register_device_item(device, 0, sh4->xf[ 3]); device->save_item(NAME(sh4->xf[ 3]));
state_save_register_device_item(device, 0, sh4->xf[ 4]); device->save_item(NAME(sh4->xf[ 4]));
state_save_register_device_item(device, 0, sh4->xf[ 5]); device->save_item(NAME(sh4->xf[ 5]));
state_save_register_device_item(device, 0, sh4->xf[ 6]); device->save_item(NAME(sh4->xf[ 6]));
state_save_register_device_item(device, 0, sh4->xf[ 7]); device->save_item(NAME(sh4->xf[ 7]));
state_save_register_device_item(device, 0, sh4->xf[ 8]); device->save_item(NAME(sh4->xf[ 8]));
state_save_register_device_item(device, 0, sh4->xf[ 9]); device->save_item(NAME(sh4->xf[ 9]));
state_save_register_device_item(device, 0, sh4->xf[10]); device->save_item(NAME(sh4->xf[10]));
state_save_register_device_item(device, 0, sh4->xf[11]); device->save_item(NAME(sh4->xf[11]));
state_save_register_device_item(device, 0, sh4->xf[12]); device->save_item(NAME(sh4->xf[12]));
state_save_register_device_item(device, 0, sh4->xf[13]); device->save_item(NAME(sh4->xf[13]));
state_save_register_device_item(device, 0, sh4->xf[14]); device->save_item(NAME(sh4->xf[14]));
state_save_register_device_item(device, 0, sh4->xf[15]); device->save_item(NAME(sh4->xf[15]));
state_save_register_device_item(device, 0, sh4->ea); device->save_item(NAME(sh4->ea));
state_save_register_device_item(device, 0, sh4->fpul); device->save_item(NAME(sh4->fpul));
state_save_register_device_item(device, 0, sh4->dbr); device->save_item(NAME(sh4->dbr));
state_save_register_device_item_array(device, 0, sh4->exception_priority); device->save_item(NAME(sh4->exception_priority));
state_save_register_device_item_array(device, 0, sh4->exception_requesting); 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_block0 = &cpustate->internal_ram[0];
cpustate->internal_ram_block1 = &cpustate->internal_ram[0x20000/2]; cpustate->internal_ram_block1 = &cpustate->internal_ram[0x20000/2];
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item_pointer(device, 0, (&cpustate->r[0].r), ARRAY_LENGTH(cpustate->r)); device->save_pointer(NAME(&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)); device->save_pointer(NAME(&cpustate->reg_alt[0].r), ARRAY_LENGTH(cpustate->reg_alt));
state_save_register_device_item(device, 0, cpustate->mrf); device->save_item(NAME(cpustate->mrf));
state_save_register_device_item(device, 0, cpustate->mrb); device->save_item(NAME(cpustate->mrb));
state_save_register_device_item_array(device, 0, cpustate->pcstack); device->save_item(NAME(cpustate->pcstack));
state_save_register_device_item_array(device, 0, cpustate->lcstack); device->save_item(NAME(cpustate->lcstack));
state_save_register_device_item_array(device, 0, cpustate->lastack); device->save_item(NAME(cpustate->lastack));
state_save_register_device_item(device, 0, cpustate->lstkp); device->save_item(NAME(cpustate->lstkp));
state_save_register_device_item(device, 0, cpustate->faddr); device->save_item(NAME(cpustate->faddr));
state_save_register_device_item(device, 0, cpustate->daddr); device->save_item(NAME(cpustate->daddr));
state_save_register_device_item(device, 0, cpustate->pcstk); device->save_item(NAME(cpustate->pcstk));
state_save_register_device_item(device, 0, cpustate->pcstkp); device->save_item(NAME(cpustate->pcstkp));
state_save_register_device_item(device, 0, cpustate->laddr); device->save_item(NAME(cpustate->laddr));
state_save_register_device_item(device, 0, cpustate->curlcntr); device->save_item(NAME(cpustate->curlcntr));
state_save_register_device_item(device, 0, cpustate->lcntr); device->save_item(NAME(cpustate->lcntr));
state_save_register_device_item_array(device, 0, cpustate->dag1.i); device->save_item(NAME(cpustate->dag1.i));
state_save_register_device_item_array(device, 0, cpustate->dag1.m); device->save_item(NAME(cpustate->dag1.m));
state_save_register_device_item_array(device, 0, cpustate->dag1.b); device->save_item(NAME(cpustate->dag1.b));
state_save_register_device_item_array(device, 0, cpustate->dag1.l); device->save_item(NAME(cpustate->dag1.l));
state_save_register_device_item_array(device, 0, cpustate->dag2.i); device->save_item(NAME(cpustate->dag2.i));
state_save_register_device_item_array(device, 0, cpustate->dag2.m); device->save_item(NAME(cpustate->dag2.m));
state_save_register_device_item_array(device, 0, cpustate->dag2.b); device->save_item(NAME(cpustate->dag2.b));
state_save_register_device_item_array(device, 0, cpustate->dag2.l); device->save_item(NAME(cpustate->dag2.l));
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.i); device->save_item(NAME(cpustate->dag1_alt.i));
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.m); device->save_item(NAME(cpustate->dag1_alt.m));
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.b); device->save_item(NAME(cpustate->dag1_alt.b));
state_save_register_device_item_array(device, 0, cpustate->dag1_alt.l); device->save_item(NAME(cpustate->dag1_alt.l));
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.i); device->save_item(NAME(cpustate->dag2_alt.i));
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.m); device->save_item(NAME(cpustate->dag2_alt.m));
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.b); device->save_item(NAME(cpustate->dag2_alt.b));
state_save_register_device_item_array(device, 0, cpustate->dag2_alt.l); device->save_item(NAME(cpustate->dag2_alt.l));
for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->dma); saveindex++) for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->dma); saveindex++)
{ {
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].control); device->save_item(NAME(cpustate->dma[saveindex].control), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_index); device->save_item(NAME(cpustate->dma[saveindex].int_index), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_modifier); device->save_item(NAME(cpustate->dma[saveindex].int_modifier), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].int_count); device->save_item(NAME(cpustate->dma[saveindex].int_count), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].chain_ptr); device->save_item(NAME(cpustate->dma[saveindex].chain_ptr), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].gen_purpose); device->save_item(NAME(cpustate->dma[saveindex].gen_purpose), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_index); device->save_item(NAME(cpustate->dma[saveindex].ext_index), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_modifier); device->save_item(NAME(cpustate->dma[saveindex].ext_modifier), saveindex);
state_save_register_device_item(device, saveindex, cpustate->dma[saveindex].ext_count); device->save_item(NAME(cpustate->dma[saveindex].ext_count), saveindex);
} }
state_save_register_device_item(device, 0, cpustate->mode1); device->save_item(NAME(cpustate->mode1));
state_save_register_device_item(device, 0, cpustate->mode2); device->save_item(NAME(cpustate->mode2));
state_save_register_device_item(device, 0, cpustate->astat); device->save_item(NAME(cpustate->astat));
state_save_register_device_item(device, 0, cpustate->stky); device->save_item(NAME(cpustate->stky));
state_save_register_device_item(device, 0, cpustate->irptl); device->save_item(NAME(cpustate->irptl));
state_save_register_device_item(device, 0, cpustate->imask); device->save_item(NAME(cpustate->imask));
state_save_register_device_item(device, 0, cpustate->imaskp); device->save_item(NAME(cpustate->imaskp));
state_save_register_device_item(device, 0, cpustate->ustat1); device->save_item(NAME(cpustate->ustat1));
state_save_register_device_item(device, 0, cpustate->ustat2); 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); device->save_item(NAME(cpustate->syscon));
state_save_register_device_item(device, 0, cpustate->sysstat); device->save_item(NAME(cpustate->sysstat));
for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->status_stack); saveindex++) for (saveindex = 0; saveindex < ARRAY_LENGTH(cpustate->status_stack); saveindex++)
{ {
state_save_register_device_item(device, saveindex, cpustate->status_stack[saveindex].mode1); device->save_item(NAME(cpustate->status_stack[saveindex].mode1), saveindex);
state_save_register_device_item(device, saveindex, cpustate->status_stack[saveindex].astat); 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); device->save_item(NAME(cpustate->opcode));
state_save_register_device_item(device, 0, cpustate->fetch_opcode); device->save_item(NAME(cpustate->fetch_opcode));
state_save_register_device_item(device, 0, cpustate->decode_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); device->save_item(NAME(cpustate->idle));
state_save_register_device_item(device, 0, cpustate->irq_active); device->save_item(NAME(cpustate->irq_active));
state_save_register_device_item(device, 0, cpustate->active_irq_num); device->save_item(NAME(cpustate->active_irq_num));
state_save_register_device_item(device, 0, cpustate->dmaop_src); device->save_item(NAME(cpustate->dmaop_src));
state_save_register_device_item(device, 0, cpustate->dmaop_dst); device->save_item(NAME(cpustate->dmaop_dst));
state_save_register_device_item(device, 0, cpustate->dmaop_chain_ptr); device->save_item(NAME(cpustate->dmaop_chain_ptr));
state_save_register_device_item(device, 0, cpustate->dmaop_src_modifier); device->save_item(NAME(cpustate->dmaop_src_modifier));
state_save_register_device_item(device, 0, cpustate->dmaop_dst_modifier); device->save_item(NAME(cpustate->dmaop_dst_modifier));
state_save_register_device_item(device, 0, cpustate->dmaop_src_count); device->save_item(NAME(cpustate->dmaop_src_count));
state_save_register_device_item(device, 0, cpustate->dmaop_dst_count); device->save_item(NAME(cpustate->dmaop_dst_count));
state_save_register_device_item(device, 0, cpustate->dmaop_pmode); device->save_item(NAME(cpustate->dmaop_pmode));
state_save_register_device_item(device, 0, cpustate->dmaop_cycles); device->save_item(NAME(cpustate->dmaop_cycles));
state_save_register_device_item(device, 0, cpustate->dmaop_channel); device->save_item(NAME(cpustate->dmaop_channel));
state_save_register_device_item(device, 0, cpustate->dmaop_chained_direction); 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); device->save_item(NAME(cpustate->iop_latency_cycles));
state_save_register_device_item(device, 0, cpustate->iop_latency_reg); device->save_item(NAME(cpustate->iop_latency_reg));
state_save_register_device_item(device, 0, cpustate->iop_latency_data); device->save_item(NAME(cpustate->iop_latency_data));
state_save_register_device_item(device, 0, cpustate->delay_slot1); device->save_item(NAME(cpustate->delay_slot1));
state_save_register_device_item(device, 0, cpustate->delay_slot2); device->save_item(NAME(cpustate->delay_slot2));
state_save_register_device_item(device, 0, cpustate->systemreg_latency_cycles); device->save_item(NAME(cpustate->systemreg_latency_cycles));
state_save_register_device_item(device, 0, cpustate->systemreg_latency_reg); device->save_item(NAME(cpustate->systemreg_latency_reg));
state_save_register_device_item(device, 0, cpustate->systemreg_latency_data); device->save_item(NAME(cpustate->systemreg_latency_data));
state_save_register_device_item(device, 0, cpustate->systemreg_previous_data); device->save_item(NAME(cpustate->systemreg_previous_data));
state_save_register_device_item(device, 0, cpustate->astat_old); device->save_item(NAME(cpustate->astat_old));
state_save_register_device_item(device, 0, cpustate->astat_old_old); device->save_item(NAME(cpustate->astat_old_old));
state_save_register_device_item(device, 0, cpustate->astat_old_old_old); device->save_item(NAME(cpustate->astat_old_old_old));
} }
static CPU_RESET( sharc ) 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); spc700i_cpu *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->a); device->save_item(NAME(cpustate->a));
state_save_register_device_item(device, 0, cpustate->x); device->save_item(NAME(cpustate->x));
state_save_register_device_item(device, 0, cpustate->y); device->save_item(NAME(cpustate->y));
state_save_register_device_item(device, 0, cpustate->s); device->save_item(NAME(cpustate->s));
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item(device, 0, cpustate->ppc); device->save_item(NAME(cpustate->ppc));
state_save_register_device_item(device, 0, cpustate->flag_n); device->save_item(NAME(cpustate->flag_n));
state_save_register_device_item(device, 0, cpustate->flag_z); device->save_item(NAME(cpustate->flag_z));
state_save_register_device_item(device, 0, cpustate->flag_v); device->save_item(NAME(cpustate->flag_v));
state_save_register_device_item(device, 0, cpustate->flag_p); device->save_item(NAME(cpustate->flag_p));
state_save_register_device_item(device, 0, cpustate->flag_b); device->save_item(NAME(cpustate->flag_b));
state_save_register_device_item(device, 0, cpustate->flag_h); device->save_item(NAME(cpustate->flag_h));
state_save_register_device_item(device, 0, cpustate->flag_i); device->save_item(NAME(cpustate->flag_i));
state_save_register_device_item(device, 0, cpustate->flag_c); device->save_item(NAME(cpustate->flag_c));
state_save_register_device_item(device, 0, cpustate->line_irq); device->save_item(NAME(cpustate->line_irq));
state_save_register_device_item(device, 0, cpustate->line_nmi); device->save_item(NAME(cpustate->line_nmi));
state_save_register_device_item(device, 0, cpustate->line_rst); device->save_item(NAME(cpustate->line_rst));
state_save_register_device_item(device, 0, cpustate->ir); device->save_item(NAME(cpustate->ir));
state_save_register_device_item(device, 0, cpustate->stopped); device->save_item(NAME(cpustate->stopped));
state_save_register_device_item(device, 0, cpustate->ICount); device->save_item(NAME(cpustate->ICount));
state_save_register_device_item(device, 0, cpustate->source); device->save_item(NAME(cpustate->source));
state_save_register_device_item(device, 0, cpustate->destination); device->save_item(NAME(cpustate->destination));
state_save_register_device_item(device, 0, cpustate->temp1); device->save_item(NAME(cpustate->temp1));
state_save_register_device_item(device, 0, cpustate->temp2); device->save_item(NAME(cpustate->temp2));
state_save_register_device_item(device, 0, cpustate->temp3); device->save_item(NAME(cpustate->temp3));
state_save_register_device_item(device, 0, cpustate->spc_int16); device->save_item(NAME(cpustate->spc_int16));
state_save_register_device_item(device, 0, cpustate->spc_int32); device->save_item(NAME(cpustate->spc_int32));
} }
static CPU_INIT( spc700 ) 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); ssp1601_state_t *ssp1601_state = get_safe_token(device);
state_save_register_device_item(device, 0, rX); device->save_item(NAME(rX));
state_save_register_device_item(device, 0, rY); device->save_item(NAME(rY));
state_save_register_device_item(device, 0, rA32); device->save_item(NAME(rA32));
state_save_register_device_item(device, 0, rST); device->save_item(NAME(rST));
state_save_register_device_item(device, 0, rSTACK); device->save_item(NAME(rSTACK));
state_save_register_device_item(device, 0, rPC); device->save_item(NAME(rPC));
state_save_register_device_item(device, 0, rP.d); device->save_item(NAME(rP.d));
state_save_register_device_item(device, 0, PPC); device->save_item(NAME(PPC));
state_save_register_device_item_array(device, 0, ssp1601_state->stack); device->save_item(NAME(ssp1601_state->stack));
state_save_register_device_item_array(device, 0, ssp1601_state->r); device->save_item(NAME(ssp1601_state->r));
state_save_register_device_item_array(device, 0, ssp1601_state->RAM); device->save_item(NAME(ssp1601_state->RAM));
/* clear the state */ /* clear the state */
memset(ssp1601_state, 0, sizeof(ssp1601_state_t)); 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); superfx_state *cpustate = get_safe_token(device);
int i; int i;
state_save_register_device_item(device, 0, cpustate->pipeline); device->save_item(NAME(cpustate->pipeline));
state_save_register_device_item(device, 0, cpustate->ramaddr); device->save_item(NAME(cpustate->ramaddr));
state_save_register_device_item_array(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
state_save_register_device_item(device, 0, cpustate->sfr); device->save_item(NAME(cpustate->sfr));
state_save_register_device_item(device, 0, cpustate->pbr); device->save_item(NAME(cpustate->pbr));
state_save_register_device_item(device, 0, cpustate->rombr); device->save_item(NAME(cpustate->rombr));
state_save_register_device_item(device, 0, cpustate->rambr); device->save_item(NAME(cpustate->rambr));
state_save_register_device_item(device, 0, cpustate->cbr); device->save_item(NAME(cpustate->cbr));
state_save_register_device_item(device, 0, cpustate->scbr); device->save_item(NAME(cpustate->scbr));
state_save_register_device_item(device, 0, cpustate->scmr); device->save_item(NAME(cpustate->scmr));
state_save_register_device_item(device, 0, cpustate->colr); device->save_item(NAME(cpustate->colr));
state_save_register_device_item(device, 0, cpustate->por); device->save_item(NAME(cpustate->por));
state_save_register_device_item(device, 0, cpustate->bramr); device->save_item(NAME(cpustate->bramr));
state_save_register_device_item(device, 0, cpustate->vcr); device->save_item(NAME(cpustate->vcr));
state_save_register_device_item(device, 0, cpustate->cfgr); device->save_item(NAME(cpustate->cfgr));
state_save_register_device_item(device, 0, cpustate->clsr); device->save_item(NAME(cpustate->clsr));
state_save_register_device_item(device, 0, cpustate->romcl); device->save_item(NAME(cpustate->romcl));
state_save_register_device_item(device, 0, cpustate->romdr); device->save_item(NAME(cpustate->romdr));
state_save_register_device_item(device, 0, cpustate->ramcl); device->save_item(NAME(cpustate->ramcl));
state_save_register_device_item(device, 0, cpustate->ramar); device->save_item(NAME(cpustate->ramar));
state_save_register_device_item(device, 0, cpustate->ramdr); device->save_item(NAME(cpustate->ramdr));
state_save_register_device_item(device, 0, cpustate->sreg_idx); device->save_item(NAME(cpustate->sreg_idx));
state_save_register_device_item(device, 0, cpustate->dreg_idx); device->save_item(NAME(cpustate->dreg_idx));
state_save_register_device_item(device, 0, cpustate->r15_modified); 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); device->save_item(NAME(cpustate->cache_access_speed));
state_save_register_device_item(device, 0, cpustate->memory_access_speed); device->save_item(NAME(cpustate->memory_access_speed));
state_save_register_device_item_array(device, 0, cpustate->cache.buffer); device->save_item(NAME(cpustate->cache.buffer));
state_save_register_device_item_array(device, 0, cpustate->cache.valid); device->save_item(NAME(cpustate->cache.valid));
for (i = 0; i < 2; i++) for (i = 0; i < 2; i++)
{ {
state_save_register_device_item(device, i, cpustate->pixelcache[i].offset); device->save_item(NAME(cpustate->pixelcache[i].offset), i);
state_save_register_device_item(device, i, cpustate->pixelcache[i].bitpend); device->save_item(NAME(cpustate->pixelcache[i].bitpend), i);
state_save_register_device_item_array(device, i, cpustate->pixelcache[i].data); 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 ) 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->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct(); cpustate->direct = &cpustate->program->direct();
state_save_register_device_item(device, 0, cpustate->ppc.w.l); device->save_item(NAME(cpustate->ppc.w.l));
state_save_register_device_item(device, 0, cpustate->reg[0].w.l); device->save_item(NAME(cpustate->reg[0].w.l));
state_save_register_device_item(device, 0, cpustate->reg[1].w.l); device->save_item(NAME(cpustate->reg[1].w.l));
state_save_register_device_item(device, 0, cpustate->reg[2].w.l); device->save_item(NAME(cpustate->reg[2].w.l));
state_save_register_device_item(device, 0, cpustate->reg[3].w.l); device->save_item(NAME(cpustate->reg[3].w.l));
state_save_register_device_item(device, 0, cpustate->reg[4].w.l); device->save_item(NAME(cpustate->reg[4].w.l));
state_save_register_device_item(device, 0, cpustate->reg[5].w.l); device->save_item(NAME(cpustate->reg[5].w.l));
state_save_register_device_item(device, 0, cpustate->reg[6].w.l); device->save_item(NAME(cpustate->reg[6].w.l));
state_save_register_device_item(device, 0, cpustate->reg[7].w.l); device->save_item(NAME(cpustate->reg[7].w.l));
state_save_register_device_item(device, 0, cpustate->psw.w.l); device->save_item(NAME(cpustate->psw.w.l));
state_save_register_device_item(device, 0, cpustate->initial_pc); device->save_item(NAME(cpustate->initial_pc));
state_save_register_device_item(device, 0, cpustate->wait_state); device->save_item(NAME(cpustate->wait_state));
state_save_register_device_item(device, 0, cpustate->irq_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); t90_Regs *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->prvpc.w.l); device->save_item(NAME(cpustate->prvpc.w.l));
state_save_register_device_item(device, 0, cpustate->pc.w.l); device->save_item(NAME(cpustate->pc.w.l));
state_save_register_device_item(device, 0, cpustate->sp.w.l); device->save_item(NAME(cpustate->sp.w.l));
state_save_register_device_item(device, 0, cpustate->af.w.l); device->save_item(NAME(cpustate->af.w.l));
state_save_register_device_item(device, 0, cpustate->bc.w.l); device->save_item(NAME(cpustate->bc.w.l));
state_save_register_device_item(device, 0, cpustate->de.w.l); device->save_item(NAME(cpustate->de.w.l));
state_save_register_device_item(device, 0, cpustate->hl.w.l); device->save_item(NAME(cpustate->hl.w.l));
state_save_register_device_item(device, 0, cpustate->ix.w.l); device->save_item(NAME(cpustate->ix.w.l));
state_save_register_device_item(device, 0, cpustate->iy.w.l); device->save_item(NAME(cpustate->iy.w.l));
state_save_register_device_item(device, 0, cpustate->af2.w.l); device->save_item(NAME(cpustate->af2.w.l));
state_save_register_device_item(device, 0, cpustate->bc2.w.l); device->save_item(NAME(cpustate->bc2.w.l));
state_save_register_device_item(device, 0, cpustate->de2.w.l); device->save_item(NAME(cpustate->de2.w.l));
state_save_register_device_item(device, 0, cpustate->hl2.w.l); device->save_item(NAME(cpustate->hl2.w.l));
state_save_register_device_item(device, 0, cpustate->halt); device->save_item(NAME(cpustate->halt));
state_save_register_device_item(device, 0, cpustate->after_EI); device->save_item(NAME(cpustate->after_EI));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->irq_mask); device->save_item(NAME(cpustate->irq_mask));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->extra_cycles); device->save_item(NAME(cpustate->extra_cycles));
state_save_register_device_item_array(device, 0, cpustate->internal_registers); device->save_item(NAME(cpustate->internal_registers));
state_save_register_device_item(device, 0, cpustate->ixbase); device->save_item(NAME(cpustate->ixbase));
state_save_register_device_item(device, 0, cpustate->iybase); device->save_item(NAME(cpustate->iybase));
state_save_register_device_item_array(device, 0, cpustate->timer_value); device->save_item(NAME(cpustate->timer_value));
state_save_register_device_item(device, 0, cpustate->timer4_value); device->save_item(NAME(cpustate->timer4_value));
// Work registers // Work registers
state_save_register_device_item(device, 0, cpustate->op); device->save_item(NAME(cpustate->op));
state_save_register_device_item(device, 0, cpustate->mode1); device->save_item(NAME(cpustate->mode1));
state_save_register_device_item(device, 0, cpustate->r1); device->save_item(NAME(cpustate->r1));
state_save_register_device_item(device, 0, cpustate->r1b); device->save_item(NAME(cpustate->r1b));
state_save_register_device_item(device, 0, cpustate->mode2); device->save_item(NAME(cpustate->mode2));
state_save_register_device_item(device, 0, cpustate->r2); device->save_item(NAME(cpustate->r2));
state_save_register_device_item(device, 0, cpustate->r2b); device->save_item(NAME(cpustate->r2b));
state_save_register_device_item(device, 0, cpustate->cyc_t); device->save_item(NAME(cpustate->cyc_t));
state_save_register_device_item(device, 0, cpustate->cyc_f); device->save_item(NAME(cpustate->cyc_f));
state_save_register_device_item(device, 0, cpustate->addr); 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->to1, &cpustate->intf->to1, device );
devcb_resolve_write8( &cpustate->to3, &cpustate->intf->to3, device ); devcb_resolve_write8( &cpustate->to3, &cpustate->intf->to3, device );
state_save_register_device_item_array( device, 0, cpustate->xwa ); device->save_item( NAME(cpustate->xwa) );
state_save_register_device_item_array( device, 0, cpustate->xbc ); device->save_item( NAME(cpustate->xbc) );
state_save_register_device_item_array( device, 0, cpustate->xde ); device->save_item( NAME(cpustate->xde) );
state_save_register_device_item_array( device, 0, cpustate->xhl ); device->save_item( NAME(cpustate->xhl) );
state_save_register_device_item( device, 0, cpustate->xix ); device->save_item( NAME(cpustate->xix) );
state_save_register_device_item( device, 0, cpustate->xiy ); device->save_item( NAME(cpustate->xiy) );
state_save_register_device_item( device, 0, cpustate->xiz ); device->save_item( NAME(cpustate->xiz) );
state_save_register_device_item( device, 0, cpustate->xssp ); device->save_item( NAME(cpustate->xssp) );
state_save_register_device_item( device, 0, cpustate->xnsp ); device->save_item( NAME(cpustate->xnsp) );
state_save_register_device_item( device, 0, cpustate->pc ); device->save_item( NAME(cpustate->pc) );
state_save_register_device_item( device, 0, cpustate->sr ); device->save_item( NAME(cpustate->sr) );
state_save_register_device_item( device, 0, cpustate->f2 ); device->save_item( NAME(cpustate->f2) );
state_save_register_device_item_array( device, 0, cpustate->dmas ); device->save_item( NAME(cpustate->dmas) );
state_save_register_device_item_array( device, 0, cpustate->dmad ); device->save_item( NAME(cpustate->dmad) );
state_save_register_device_item_array( device, 0, cpustate->dmac ); device->save_item( NAME(cpustate->dmac) );
state_save_register_device_item_array( device, 0, cpustate->dmam ); device->save_item( NAME(cpustate->dmam) );
state_save_register_device_item_array( device, 0, cpustate->reg ); device->save_item( NAME(cpustate->reg) );
state_save_register_device_item( device, 0, cpustate->timer_pre ); device->save_item( NAME(cpustate->timer_pre) );
state_save_register_device_item_array( device, 0, cpustate->timer ); device->save_item( NAME(cpustate->timer) );
state_save_register_device_item( device, 0, cpustate->tff1 ); device->save_item( NAME(cpustate->tff1) );
state_save_register_device_item( device, 0, cpustate->tff3 ); device->save_item( NAME(cpustate->tff3) );
state_save_register_device_item_array( device, 0, cpustate->timer_change ); device->save_item( NAME(cpustate->timer_change) );
state_save_register_device_item_array( device, 0, cpustate->level ); device->save_item( NAME(cpustate->level) );
state_save_register_device_item( device, 0, cpustate->check_irqs ); device->save_item( NAME(cpustate->check_irqs) );
state_save_register_device_item( device, 0, cpustate->ad_cycles_left ); device->save_item( NAME(cpustate->ad_cycles_left) );
state_save_register_device_item( device, 0, cpustate->nmi_state ); 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->program = device->space( AS_PROGRAM );
cpustate->data = device->space( AS_PROGRAM ); cpustate->data = device->space( AS_PROGRAM );
state_save_register_device_item( device, 0, cpustate->prev_pc ); device->save_item( NAME(cpustate->prev_pc) );
state_save_register_device_item( device, 0, cpustate->prev_pa ); device->save_item( NAME(cpustate->prev_pa) );
state_save_register_device_item( device, 0, cpustate->pc ); device->save_item( NAME(cpustate->pc) );
state_save_register_device_item( device, 0, cpustate->pa ); device->save_item( NAME(cpustate->pa) );
state_save_register_device_item( device, 0, cpustate->sr ); device->save_item( NAME(cpustate->sr) );
state_save_register_device_item( device, 0, cpustate->pb ); device->save_item( NAME(cpustate->pb) );
state_save_register_device_item( device, 0, cpustate->a ); device->save_item( NAME(cpustate->a) );
state_save_register_device_item( device, 0, cpustate->x ); device->save_item( NAME(cpustate->x) );
state_save_register_device_item( device, 0, cpustate->y ); device->save_item( NAME(cpustate->y) );
state_save_register_device_item( device, 0, cpustate->dam ); device->save_item( NAME(cpustate->dam) );
state_save_register_device_item( device, 0, cpustate->ca ); device->save_item( NAME(cpustate->ca) );
state_save_register_device_item( device, 0, cpustate->cb ); device->save_item( NAME(cpustate->cb) );
state_save_register_device_item( device, 0, cpustate->cs ); device->save_item( NAME(cpustate->cs) );
state_save_register_device_item( device, 0, cpustate->r ); device->save_item( NAME(cpustate->r) );
state_save_register_device_item( device, 0, cpustate->o ); device->save_item( NAME(cpustate->o) );
state_save_register_device_item( device, 0, cpustate->cki_bus ); device->save_item( NAME(cpustate->cki_bus) );
state_save_register_device_item( device, 0, cpustate->p ); device->save_item( NAME(cpustate->p) );
state_save_register_device_item( device, 0, cpustate->n ); device->save_item( NAME(cpustate->n) );
state_save_register_device_item( device, 0, cpustate->adder_result ); device->save_item( NAME(cpustate->adder_result) );
state_save_register_device_item( device, 0, cpustate->carry_in ); device->save_item( NAME(cpustate->carry_in) );
state_save_register_device_item( device, 0, cpustate->status ); device->save_item( NAME(cpustate->status) );
state_save_register_device_item( device, 0, cpustate->status_latch ); device->save_item( NAME(cpustate->status_latch) );
state_save_register_device_item( device, 0, cpustate->special_status ); device->save_item( NAME(cpustate->special_status) );
state_save_register_device_item( device, 0, cpustate->call_latch ); device->save_item( NAME(cpustate->call_latch) );
state_save_register_device_item( device, 0, cpustate->add_latch ); device->save_item( NAME(cpustate->add_latch) );
state_save_register_device_item( device, 0, cpustate->branch_latch ); device->save_item( NAME(cpustate->branch_latch) );
state_save_register_device_item( device, 0, cpustate->subcycle ); device->save_item( NAME(cpustate->subcycle) );
state_save_register_device_item( device, 0, cpustate->ram_address ); device->save_item( NAME(cpustate->ram_address) );
state_save_register_device_item( device, 0, cpustate->ram_data ); device->save_item( NAME(cpustate->ram_data) );
state_save_register_device_item( device, 0, cpustate->rom_address ); device->save_item( NAME(cpustate->rom_address) );
state_save_register_device_item( device, 0, cpustate->opcode ); device->save_item( NAME(cpustate->opcode) );
state_save_register_device_item( device, 0, cpustate->decode ); 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); tms32010_state *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->PREVPC); device->save_item(NAME(cpustate->PREVPC));
state_save_register_device_item(device, 0, cpustate->STR); device->save_item(NAME(cpustate->STR));
state_save_register_device_item(device, 0, cpustate->ACC.d); device->save_item(NAME(cpustate->ACC.d));
state_save_register_device_item(device, 0, cpustate->ALU.d); device->save_item(NAME(cpustate->ALU.d));
state_save_register_device_item(device, 0, cpustate->Preg.d); device->save_item(NAME(cpustate->Preg.d));
state_save_register_device_item(device, 0, cpustate->Treg); device->save_item(NAME(cpustate->Treg));
state_save_register_device_item(device, 0, cpustate->AR[0]); device->save_item(NAME(cpustate->AR[0]));
state_save_register_device_item(device, 0, cpustate->AR[1]); device->save_item(NAME(cpustate->AR[1]));
state_save_register_device_item(device, 0, cpustate->STACK[0]); device->save_item(NAME(cpustate->STACK[0]));
state_save_register_device_item(device, 0, cpustate->STACK[1]); device->save_item(NAME(cpustate->STACK[1]));
state_save_register_device_item(device, 0, cpustate->STACK[2]); device->save_item(NAME(cpustate->STACK[2]));
state_save_register_device_item(device, 0, cpustate->STACK[3]); device->save_item(NAME(cpustate->STACK[3]));
state_save_register_device_item(device, 0, cpustate->INTF); device->save_item(NAME(cpustate->INTF));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->opcode.d); device->save_item(NAME(cpustate->opcode.d));
state_save_register_device_item(device, 0, cpustate->oldacc.d); device->save_item(NAME(cpustate->oldacc.d));
state_save_register_device_item(device, 0, cpustate->memaccess); device->save_item(NAME(cpustate->memaccess));
state_save_register_device_item(device, 0, cpustate->addr_mask); device->save_item(NAME(cpustate->addr_mask));
cpustate->device = device; cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM); 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->data = device->space(AS_DATA);
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->STR0); device->save_item(NAME(cpustate->STR0));
state_save_register_device_item(device, 0, cpustate->STR1); device->save_item(NAME(cpustate->STR1));
state_save_register_device_item(device, 0, cpustate->PFC); device->save_item(NAME(cpustate->PFC));
state_save_register_device_item(device, 0, cpustate->IFR); device->save_item(NAME(cpustate->IFR));
state_save_register_device_item(device, 0, cpustate->RPTC); device->save_item(NAME(cpustate->RPTC));
state_save_register_device_item(device, 0, cpustate->ACC.d); device->save_item(NAME(cpustate->ACC.d));
state_save_register_device_item(device, 0, cpustate->ALU.d); device->save_item(NAME(cpustate->ALU.d));
state_save_register_device_item(device, 0, cpustate->Preg.d); device->save_item(NAME(cpustate->Preg.d));
state_save_register_device_item(device, 0, cpustate->Treg); device->save_item(NAME(cpustate->Treg));
state_save_register_device_item(device, 0, cpustate->AR[0]); device->save_item(NAME(cpustate->AR[0]));
state_save_register_device_item(device, 0, cpustate->AR[1]); device->save_item(NAME(cpustate->AR[1]));
state_save_register_device_item(device, 0, cpustate->AR[2]); device->save_item(NAME(cpustate->AR[2]));
state_save_register_device_item(device, 0, cpustate->AR[3]); device->save_item(NAME(cpustate->AR[3]));
state_save_register_device_item(device, 0, cpustate->AR[4]); device->save_item(NAME(cpustate->AR[4]));
state_save_register_device_item(device, 0, cpustate->AR[5]); device->save_item(NAME(cpustate->AR[5]));
state_save_register_device_item(device, 0, cpustate->AR[6]); device->save_item(NAME(cpustate->AR[6]));
state_save_register_device_item(device, 0, cpustate->AR[7]); device->save_item(NAME(cpustate->AR[7]));
state_save_register_device_item(device, 0, cpustate->STACK[0]); device->save_item(NAME(cpustate->STACK[0]));
state_save_register_device_item(device, 0, cpustate->STACK[1]); device->save_item(NAME(cpustate->STACK[1]));
state_save_register_device_item(device, 0, cpustate->STACK[2]); device->save_item(NAME(cpustate->STACK[2]));
state_save_register_device_item(device, 0, cpustate->STACK[3]); device->save_item(NAME(cpustate->STACK[3]));
state_save_register_device_item(device, 0, cpustate->STACK[4]); device->save_item(NAME(cpustate->STACK[4]));
state_save_register_device_item(device, 0, cpustate->STACK[5]); device->save_item(NAME(cpustate->STACK[5]));
state_save_register_device_item(device, 0, cpustate->STACK[6]); device->save_item(NAME(cpustate->STACK[6]));
state_save_register_device_item(device, 0, cpustate->STACK[7]); device->save_item(NAME(cpustate->STACK[7]));
state_save_register_device_item(device, 0, cpustate->oldacc); device->save_item(NAME(cpustate->oldacc));
state_save_register_device_item(device, 0, cpustate->memaccess); device->save_item(NAME(cpustate->memaccess));
state_save_register_device_item(device, 0, cpustate->icount); device->save_item(NAME(cpustate->icount));
state_save_register_device_item(device, 0, cpustate->mHackIgnoreARP); device->save_item(NAME(cpustate->mHackIgnoreARP));
state_save_register_device_item(device, 0, cpustate->idle); device->save_item(NAME(cpustate->idle));
state_save_register_device_item(device, 0, cpustate->hold); device->save_item(NAME(cpustate->hold));
state_save_register_device_item(device, 0, cpustate->external_mem_access); device->save_item(NAME(cpustate->external_mem_access));
state_save_register_device_item(device, 0, cpustate->init_load_addr); device->save_item(NAME(cpustate->init_load_addr));
state_save_register_device_item(device, 0, cpustate->PREVPC); 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(); m_direct = &m_program->direct();
// save state // save state
state_save_register_device_item(this, 0, m_pc); save_item(NAME(m_pc));
for (int regnum = 0; regnum < 36; regnum++) for (int regnum = 0; regnum < 36; regnum++)
state_save_register_device_item_array(this, regnum, m_r[regnum].i32); save_item(NAME(m_r[regnum].i32), regnum);
state_save_register_device_item(this, 0, m_bkmask); save_item(NAME(m_bkmask));
state_save_register_device_item(this, 0, m_irq_state); save_item(NAME(m_irq_state));
state_save_register_device_item(this, 0, m_delayed); save_item(NAME(m_delayed));
state_save_register_device_item(this, 0, m_irq_pending); save_item(NAME(m_irq_pending));
state_save_register_device_item(this, 0, m_mcu_mode); save_item(NAME(m_mcu_mode));
state_save_register_device_item(this, 0, m_is_idling); save_item(NAME(m_is_idling));
// register our state for the debugger // register our state for the debugger
state_add(TMS3203X_PC, "PC", m_pc); 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 */ /* allocate the shiftreg */
tms->shiftreg = auto_alloc_array(device->machine, UINT16, SHIFTREG_SIZE/2); tms->shiftreg = auto_alloc_array(device->machine, UINT16, SHIFTREG_SIZE/2);
state_save_register_device_item(device, 0, tms->pc); device->save_item(NAME(tms->pc));
state_save_register_device_item(device, 0, tms->st); device->save_item(NAME(tms->st));
state_save_register_device_item(device, 0, tms->reset_deferred); device->save_item(NAME(tms->reset_deferred));
state_save_register_device_item_pointer(device, 0, tms->shiftreg, SHIFTREG_SIZE / 2); device->save_pointer(NAME(tms->shiftreg), SHIFTREG_SIZE / 2);
state_save_register_device_item_array(device, 0, tms->IOregs); device->save_item(NAME(tms->IOregs));
state_save_register_device_item(device, 0, tms->convsp); device->save_item(NAME(tms->convsp));
state_save_register_device_item(device, 0, tms->convdp); device->save_item(NAME(tms->convdp));
state_save_register_device_item(device, 0, tms->convmp); device->save_item(NAME(tms->convmp));
state_save_register_device_item(device, 0, tms->pixelshift); device->save_item(NAME(tms->pixelshift));
state_save_register_device_item(device, 0, tms->gfxcycles); device->save_item(NAME(tms->gfxcycles));
state_save_register_device_item_pointer(device, 0, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs)); device->save_pointer(NAME(&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
device->machine->state().register_postload(tms34010_state_postload, tms); 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); memset(cpustate->rf, 0, 0x80);
/* Save register state */ /* Save register state */
state_save_register_device_item(device, 0, pPC); device->save_item(NAME(pPC));
state_save_register_device_item(device, 0, pSP); device->save_item(NAME(pSP));
state_save_register_device_item(device, 0, pSR); device->save_item(NAME(pSR));
/* Save Interrupt state */ /* 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 */ /* Save register and perpherial file state */
state_save_register_device_item_array(device, 0, cpustate->rf); device->save_item(NAME(cpustate->rf));
state_save_register_device_item_array(device, 0, cpustate->pf); device->save_item(NAME(cpustate->pf));
/* Save timer state */ /* Save timer state */
state_save_register_device_item(device, 0, cpustate->t1_prescaler); device->save_item(NAME(cpustate->t1_prescaler));
state_save_register_device_item(device, 0, cpustate->t1_capture_latch); device->save_item(NAME(cpustate->t1_capture_latch));
state_save_register_device_item(device, 0, cpustate->t1_decrementer); 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 ) 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) static void register_for_save_state(device_t *device)
{ {
tms99xx_state *cpustate = get_safe_token(device); tms99xx_state *cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->WP); device->save_item(NAME(cpustate->WP));
state_save_register_device_item(device, 0, cpustate->PC); device->save_item(NAME(cpustate->PC));
state_save_register_device_item(device, 0, cpustate->STATUS); device->save_item(NAME(cpustate->STATUS));
state_save_register_device_item(device, 0, cpustate->interrupt_pending); device->save_item(NAME(cpustate->interrupt_pending));
#if ! ((TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID)) #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 #endif
#if (TMS99XX_MODEL == TI990_10_ID) || (TMS99XX_MODEL == TMS9900_ID) || (TMS99XX_MODEL == TMS9980_ID) #if (TMS99XX_MODEL == TI990_10_ID) || (TMS99XX_MODEL == TMS9900_ID) || (TMS99XX_MODEL == TMS9980_ID)
state_save_register_device_item(device, 0, cpustate->irq_level); device->save_item(NAME(cpustate->irq_level));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
#elif (TMS99XX_MODEL == TMS9995_ID) #elif (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->irq_level); device->save_item(NAME(cpustate->irq_level));
state_save_register_device_item(device, 0, cpustate->int_state); device->save_item(NAME(cpustate->int_state));
state_save_register_device_item(device, 0, cpustate->int_latch); device->save_item(NAME(cpustate->int_latch));
#endif #endif
state_save_register_device_item(device, 0, cpustate->IDLE); device->save_item(NAME(cpustate->IDLE));
#if HAS_MAPPING #if HAS_MAPPING
state_save_register_device_item(device, 0, cpustate->mapping_on); device->save_item(NAME(cpustate->mapping_on));
state_save_register_device_item_array(device, 0, cpustate->map_files[0].L); device->save_item(NAME(cpustate->map_files[0].L));
state_save_register_device_item_array(device, 0, cpustate->map_files[0].B); device->save_item(NAME(cpustate->map_files[0].B));
state_save_register_device_item_array(device, 0, cpustate->map_files[0].limit); device->save_item(NAME(cpustate->map_files[0].limit));
state_save_register_device_item_array(device, 0, cpustate->map_files[0].bias); device->save_item(NAME(cpustate->map_files[0].bias));
state_save_register_device_item_array(device, 0, cpustate->map_files[1].L); device->save_item(NAME(cpustate->map_files[1].L));
state_save_register_device_item_array(device, 0, cpustate->map_files[1].B); device->save_item(NAME(cpustate->map_files[1].B));
state_save_register_device_item_array(device, 0, cpustate->map_files[1].limit); device->save_item(NAME(cpustate->map_files[1].limit));
state_save_register_device_item_array(device, 0, cpustate->map_files[1].bias); device->save_item(NAME(cpustate->map_files[1].bias));
state_save_register_device_item_array(device, 0, cpustate->map_files[2].L); device->save_item(NAME(cpustate->map_files[2].L));
state_save_register_device_item_array(device, 0, cpustate->map_files[2].B); device->save_item(NAME(cpustate->map_files[2].B));
state_save_register_device_item_array(device, 0, cpustate->map_files[2].limit); device->save_item(NAME(cpustate->map_files[2].limit));
state_save_register_device_item_array(device, 0, cpustate->map_files[2].bias); device->save_item(NAME(cpustate->map_files[2].bias));
state_save_register_device_item(device, 0, cpustate->cur_map); device->save_item(NAME(cpustate->cur_map));
state_save_register_device_item(device, 0, cpustate->cur_src_map); device->save_item(NAME(cpustate->cur_src_map));
state_save_register_device_item(device, 0, cpustate->cur_dst_map); device->save_item(NAME(cpustate->cur_dst_map));
#if (TMS99XX_MODEL == TI990_10_ID) #if (TMS99XX_MODEL == TI990_10_ID)
state_save_register_device_item(device, 0, cpustate->reset_maperr); device->save_item(NAME(cpustate->reset_maperr));
state_save_register_device_item(device, 0, cpustate->mapper_address_latch); device->save_item(NAME(cpustate->mapper_address_latch));
state_save_register_device_item(device, 0, cpustate->mapper_cru_read_register); device->save_item(NAME(cpustate->mapper_cru_read_register));
state_save_register_device_item(device, 0, cpustate->diaglat); device->save_item(NAME(cpustate->diaglat));
state_save_register_device_item_array(device, 0, cpustate->latch_control); device->save_item(NAME(cpustate->latch_control));
#endif #endif
#endif #endif
#if (TMS99XX_MODEL == TI990_10_ID) #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 #endif
#if (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID) #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 #endif
#if (TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID) #if (TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->decrementer_enabled); device->save_item(NAME(cpustate->decrementer_enabled));
state_save_register_device_item(device, 0, cpustate->decrementer_interval); device->save_item(NAME(cpustate->decrementer_interval));
state_save_register_device_item(device, 0, cpustate->decrementer_count); device->save_item(NAME(cpustate->decrementer_count));
#endif #endif
#if (TMS99XX_MODEL == TMS9995_ID) #if (TMS99XX_MODEL == TMS9995_ID)
state_save_register_device_item(device, 0, cpustate->flag); device->save_item(NAME(cpustate->flag));
state_save_register_device_item(device, 0, cpustate->MID_flag); device->save_item(NAME(cpustate->MID_flag));
state_save_register_device_item(device, 0, cpustate->memory_wait_states_byte); device->save_item(NAME(cpustate->memory_wait_states_byte));
state_save_register_device_item(device, 0, cpustate->memory_wait_states_word); device->save_item(NAME(cpustate->memory_wait_states_word));
state_save_register_device_item(device, 0, cpustate->is_mp9537); device->save_item(NAME(cpustate->is_mp9537));
#endif #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); state_add(UPD7725_IDB, "IDB", regs.idb);
// save state registrations // save state registrations
state_save_register_device_item(this, 0, regs.pc); save_item(NAME(regs.pc));
state_save_register_device_item(this, 0, regs.rp); save_item(NAME(regs.rp));
state_save_register_device_item(this, 0, regs.dp); save_item(NAME(regs.dp));
state_save_register_device_item(this, 0, regs.sp); save_item(NAME(regs.sp));
state_save_register_device_item(this, 0, regs.k); save_item(NAME(regs.k));
state_save_register_device_item(this, 0, regs.l); save_item(NAME(regs.l));
state_save_register_device_item(this, 0, regs.m); save_item(NAME(regs.m));
state_save_register_device_item(this, 0, regs.n); save_item(NAME(regs.n));
state_save_register_device_item(this, 0, regs.a); save_item(NAME(regs.a));
state_save_register_device_item(this, 0, regs.b); save_item(NAME(regs.b));
state_save_register_device_item(this, 0, regs.tr); save_item(NAME(regs.tr));
state_save_register_device_item(this, 0, regs.trb); save_item(NAME(regs.trb));
state_save_register_device_item(this, 0, regs.dr); save_item(NAME(regs.dr));
state_save_register_device_item(this, 0, regs.so); save_item(NAME(regs.so));
state_save_register_device_item(this, 0, regs.idb); save_item(NAME(regs.idb));
state_save_register_device_item(this, 0, regs.sr.rqm); save_item(NAME(regs.sr.rqm));
state_save_register_device_item(this, 0, regs.sr.usf0); save_item(NAME(regs.sr.usf0));
state_save_register_device_item(this, 0, regs.sr.usf1); save_item(NAME(regs.sr.usf1));
state_save_register_device_item(this, 0, regs.sr.drs); save_item(NAME(regs.sr.drs));
state_save_register_device_item(this, 0, regs.sr.dma); save_item(NAME(regs.sr.dma));
state_save_register_device_item(this, 0, regs.sr.drc); save_item(NAME(regs.sr.drc));
state_save_register_device_item(this, 0, regs.sr.soc); save_item(NAME(regs.sr.soc));
state_save_register_device_item(this, 0, regs.sr.sic); save_item(NAME(regs.sr.sic));
state_save_register_device_item(this, 0, regs.sr.ei); save_item(NAME(regs.sr.ei));
state_save_register_device_item(this, 0, regs.sr.p0); save_item(NAME(regs.sr.p0));
state_save_register_device_item(this, 0, regs.sr.p1); save_item(NAME(regs.sr.p1));
state_save_register_device_item_array(this, 0, regs.stack); save_item(NAME(regs.stack));
state_save_register_device_item_array(this, 0, dataRAM); save_item(NAME(dataRAM));
m_icountptr = &m_icount; 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->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item(device, 0, cpustate->ppc.w.l); device->save_item(NAME(cpustate->ppc.w.l));
state_save_register_device_item(device, 0, cpustate->pc.w.l); device->save_item(NAME(cpustate->pc.w.l));
state_save_register_device_item(device, 0, cpustate->sp.w.l); device->save_item(NAME(cpustate->sp.w.l));
state_save_register_device_item(device, 0, cpustate->psw); device->save_item(NAME(cpustate->psw));
state_save_register_device_item(device, 0, cpustate->op); device->save_item(NAME(cpustate->op));
state_save_register_device_item(device, 0, cpustate->op2); device->save_item(NAME(cpustate->op2));
state_save_register_device_item(device, 0, cpustate->iff); device->save_item(NAME(cpustate->iff));
state_save_register_device_item(device, 0, cpustate->ea.w.l); device->save_item(NAME(cpustate->ea.w.l));
state_save_register_device_item(device, 0, cpustate->va.w.l); device->save_item(NAME(cpustate->va.w.l));
state_save_register_device_item(device, 0, cpustate->bc.w.l); device->save_item(NAME(cpustate->bc.w.l));
state_save_register_device_item(device, 0, cpustate->de.w.l); device->save_item(NAME(cpustate->de.w.l));
state_save_register_device_item(device, 0, cpustate->hl.w.l); device->save_item(NAME(cpustate->hl.w.l));
state_save_register_device_item(device, 0, cpustate->ea2.w.l); device->save_item(NAME(cpustate->ea2.w.l));
state_save_register_device_item(device, 0, cpustate->va2.w.l); device->save_item(NAME(cpustate->va2.w.l));
state_save_register_device_item(device, 0, cpustate->bc2.w.l); device->save_item(NAME(cpustate->bc2.w.l));
state_save_register_device_item(device, 0, cpustate->de2.w.l); device->save_item(NAME(cpustate->de2.w.l));
state_save_register_device_item(device, 0, cpustate->hl2.w.l); device->save_item(NAME(cpustate->hl2.w.l));
state_save_register_device_item(device, 0, cpustate->cnt.d); device->save_item(NAME(cpustate->cnt.d));
state_save_register_device_item(device, 0, cpustate->tm.d); device->save_item(NAME(cpustate->tm.d));
state_save_register_device_item(device, 0, cpustate->ecnt.d); device->save_item(NAME(cpustate->ecnt.d));
state_save_register_device_item(device, 0, cpustate->etm.d); device->save_item(NAME(cpustate->etm.d));
state_save_register_device_item(device, 0, cpustate->ma); device->save_item(NAME(cpustate->ma));
state_save_register_device_item(device, 0, cpustate->mb); device->save_item(NAME(cpustate->mb));
state_save_register_device_item(device, 0, cpustate->mcc); device->save_item(NAME(cpustate->mcc));
state_save_register_device_item(device, 0, cpustate->mc); device->save_item(NAME(cpustate->mc));
state_save_register_device_item(device, 0, cpustate->mm); device->save_item(NAME(cpustate->mm));
state_save_register_device_item(device, 0, cpustate->mf); device->save_item(NAME(cpustate->mf));
state_save_register_device_item(device, 0, cpustate->tmm); device->save_item(NAME(cpustate->tmm));
state_save_register_device_item(device, 0, cpustate->etmm); device->save_item(NAME(cpustate->etmm));
state_save_register_device_item(device, 0, cpustate->eom); device->save_item(NAME(cpustate->eom));
state_save_register_device_item(device, 0, cpustate->sml); device->save_item(NAME(cpustate->sml));
state_save_register_device_item(device, 0, cpustate->smh); device->save_item(NAME(cpustate->smh));
state_save_register_device_item(device, 0, cpustate->anm); device->save_item(NAME(cpustate->anm));
state_save_register_device_item(device, 0, cpustate->mkl); device->save_item(NAME(cpustate->mkl));
state_save_register_device_item(device, 0, cpustate->mkh); device->save_item(NAME(cpustate->mkh));
state_save_register_device_item(device, 0, cpustate->zcm); device->save_item(NAME(cpustate->zcm));
state_save_register_device_item(device, 0, cpustate->pa_out); device->save_item(NAME(cpustate->pa_out));
state_save_register_device_item(device, 0, cpustate->pb_out); device->save_item(NAME(cpustate->pb_out));
state_save_register_device_item(device, 0, cpustate->pc_out); device->save_item(NAME(cpustate->pc_out));
state_save_register_device_item(device, 0, cpustate->pd_out); device->save_item(NAME(cpustate->pd_out));
state_save_register_device_item(device, 0, cpustate->pf_out); device->save_item(NAME(cpustate->pf_out));
state_save_register_device_item(device, 0, cpustate->cr0); device->save_item(NAME(cpustate->cr0));
state_save_register_device_item(device, 0, cpustate->cr1); device->save_item(NAME(cpustate->cr1));
state_save_register_device_item(device, 0, cpustate->cr2); device->save_item(NAME(cpustate->cr2));
state_save_register_device_item(device, 0, cpustate->cr3); device->save_item(NAME(cpustate->cr3));
state_save_register_device_item(device, 0, cpustate->txb); device->save_item(NAME(cpustate->txb));
state_save_register_device_item(device, 0, cpustate->rxb); device->save_item(NAME(cpustate->rxb));
state_save_register_device_item(device, 0, cpustate->txd); device->save_item(NAME(cpustate->txd));
state_save_register_device_item(device, 0, cpustate->rxd); device->save_item(NAME(cpustate->rxd));
state_save_register_device_item(device, 0, cpustate->sck); device->save_item(NAME(cpustate->sck));
state_save_register_device_item(device, 0, cpustate->ti); device->save_item(NAME(cpustate->ti));
state_save_register_device_item(device, 0, cpustate->to); device->save_item(NAME(cpustate->to));
state_save_register_device_item(device, 0, cpustate->ci); device->save_item(NAME(cpustate->ci));
state_save_register_device_item(device, 0, cpustate->co0); device->save_item(NAME(cpustate->co0));
state_save_register_device_item(device, 0, cpustate->co1); device->save_item(NAME(cpustate->co1));
state_save_register_device_item(device, 0, cpustate->irr); device->save_item(NAME(cpustate->irr));
state_save_register_device_item(device, 0, cpustate->itf); device->save_item(NAME(cpustate->itf));
state_save_register_device_item(device, 0, cpustate->ovc0); device->save_item(NAME(cpustate->ovc0));
state_save_register_device_item(device, 0, cpustate->ovc1); device->save_item(NAME(cpustate->ovc1));
state_save_register_device_item(device, 0, cpustate->ovcf); device->save_item(NAME(cpustate->ovcf));
state_save_register_device_item(device, 0, cpustate->ovcs); device->save_item(NAME(cpustate->ovcs));
state_save_register_device_item(device, 0, cpustate->edges); device->save_item(NAME(cpustate->edges));
state_save_register_device_item(device, 0, cpustate->int1); device->save_item(NAME(cpustate->int1));
state_save_register_device_item(device, 0, cpustate->int2); device->save_item(NAME(cpustate->int2));
} }
#include "7810tbl.c" #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; const nec_config *config = &default_config;
state_save_register_device_item_array(device, 0, cpustate->regs.w); device->save_item(NAME(cpustate->regs.w));
state_save_register_device_item_array(device, 0, cpustate->sregs); device->save_item(NAME(cpustate->sregs));
state_save_register_device_item(device, 0, cpustate->ip); device->save_item(NAME(cpustate->ip));
state_save_register_device_item(device, 0, cpustate->TF); device->save_item(NAME(cpustate->TF));
state_save_register_device_item(device, 0, cpustate->IF); device->save_item(NAME(cpustate->IF));
state_save_register_device_item(device, 0, cpustate->DF); device->save_item(NAME(cpustate->DF));
state_save_register_device_item(device, 0, cpustate->MF); device->save_item(NAME(cpustate->MF));
state_save_register_device_item(device, 0, cpustate->SignVal); device->save_item(NAME(cpustate->SignVal));
state_save_register_device_item(device, 0, cpustate->int_vector); device->save_item(NAME(cpustate->int_vector));
state_save_register_device_item(device, 0, cpustate->pending_irq); device->save_item(NAME(cpustate->pending_irq));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->AuxVal); device->save_item(NAME(cpustate->AuxVal));
state_save_register_device_item(device, 0, cpustate->OverVal); device->save_item(NAME(cpustate->OverVal));
state_save_register_device_item(device, 0, cpustate->ZeroVal); device->save_item(NAME(cpustate->ZeroVal));
state_save_register_device_item(device, 0, cpustate->CarryVal); device->save_item(NAME(cpustate->CarryVal));
state_save_register_device_item(device, 0, cpustate->ParityVal); device->save_item(NAME(cpustate->ParityVal));
cpustate->config = config; cpustate->config = config;
cpustate->irq_callback = irqcallback; 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->irq_line = CLEAR_LINE;
cpustate->nmi_line = CLEAR_LINE; cpustate->nmi_line = CLEAR_LINE;
state_save_register_device_item_array(device, 0, cpustate->reg); device->save_item(NAME(cpustate->reg));
state_save_register_device_item(device, 0, cpustate->irq_line); device->save_item(NAME(cpustate->irq_line));
state_save_register_device_item(device, 0, cpustate->nmi_line); device->save_item(NAME(cpustate->nmi_line));
state_save_register_device_item(device, 0, cpustate->PPC); device->save_item(NAME(cpustate->PPC));
state_save_register_device_item(device, 0, cpustate->_CY); device->save_item(NAME(cpustate->_CY));
state_save_register_device_item(device, 0, cpustate->_OV); device->save_item(NAME(cpustate->_OV));
state_save_register_device_item(device, 0, cpustate->_S); device->save_item(NAME(cpustate->_S));
state_save_register_device_item(device, 0, cpustate->_Z); device->save_item(NAME(cpustate->_Z));
} }
static CPU_INIT( v60 ) 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->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO); cpustate->io = device->space(AS_IO);
state_save_register_device_item_array(device, 0, cpustate->reg); device->save_item(NAME(cpustate->reg));
state_save_register_device_item(device, 0, cpustate->irq_line); device->save_item(NAME(cpustate->irq_line));
state_save_register_device_item(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item(device, 0, cpustate->nmi_line); device->save_item(NAME(cpustate->nmi_line));
state_save_register_device_item(device, 0, cpustate->PPC); 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 */ /* allocate the entry array */
vtlb->live = auto_alloc_array_clear(cpu->machine, offs_t, fixed_entries + dynamic_entries); 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 */ /* allocate the lookup table */
vtlb->table = auto_alloc_array_clear(cpu->machine, vtlb_entry, (size_t) 1 << (vtlb->addrwidth - vtlb->pageshift)); 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 */ /* allocate the fixed page count array */
if (fixed_entries > 0) if (fixed_entries > 0)
{ {
vtlb->fixedpages = auto_alloc_array_clear(cpu->machine, int, fixed_entries); 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; 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->state_add(Z180_IOCR, "IOCR", cpustate->IO_IOCR);
} }
state_save_register_device_item(device, 0, cpustate->AF.w.l); device->save_item(NAME(cpustate->AF.w.l));
state_save_register_device_item(device, 0, cpustate->BC.w.l); device->save_item(NAME(cpustate->BC.w.l));
state_save_register_device_item(device, 0, cpustate->DE.w.l); device->save_item(NAME(cpustate->DE.w.l));
state_save_register_device_item(device, 0, cpustate->HL.w.l); device->save_item(NAME(cpustate->HL.w.l));
state_save_register_device_item(device, 0, cpustate->IX.w.l); device->save_item(NAME(cpustate->IX.w.l));
state_save_register_device_item(device, 0, cpustate->IY.w.l); device->save_item(NAME(cpustate->IY.w.l));
state_save_register_device_item(device, 0, cpustate->PC.w.l); device->save_item(NAME(cpustate->PC.w.l));
state_save_register_device_item(device, 0, cpustate->SP.w.l); device->save_item(NAME(cpustate->SP.w.l));
state_save_register_device_item(device, 0, cpustate->AF2.w.l); device->save_item(NAME(cpustate->AF2.w.l));
state_save_register_device_item(device, 0, cpustate->BC2.w.l); device->save_item(NAME(cpustate->BC2.w.l));
state_save_register_device_item(device, 0, cpustate->DE2.w.l); device->save_item(NAME(cpustate->DE2.w.l));
state_save_register_device_item(device, 0, cpustate->HL2.w.l); device->save_item(NAME(cpustate->HL2.w.l));
state_save_register_device_item(device, 0, cpustate->R); device->save_item(NAME(cpustate->R));
state_save_register_device_item(device, 0, cpustate->R2); device->save_item(NAME(cpustate->R2));
state_save_register_device_item(device, 0, cpustate->IFF1); device->save_item(NAME(cpustate->IFF1));
state_save_register_device_item(device, 0, cpustate->IFF2); device->save_item(NAME(cpustate->IFF2));
state_save_register_device_item(device, 0, cpustate->HALT); device->save_item(NAME(cpustate->HALT));
state_save_register_device_item(device, 0, cpustate->IM); device->save_item(NAME(cpustate->IM));
state_save_register_device_item(device, 0, cpustate->I); device->save_item(NAME(cpustate->I));
state_save_register_device_item(device, 0, cpustate->nmi_state); device->save_item(NAME(cpustate->nmi_state));
state_save_register_device_item(device, 0, cpustate->nmi_pending); device->save_item(NAME(cpustate->nmi_pending));
state_save_register_device_item_array(device, 0, cpustate->irq_state); device->save_item(NAME(cpustate->irq_state));
state_save_register_device_item_array(device, 0, cpustate->int_pending); device->save_item(NAME(cpustate->int_pending));
state_save_register_device_item(device, 0, cpustate->timer_cnt); device->save_item(NAME(cpustate->timer_cnt));
state_save_register_device_item(device, 0, cpustate->dma0_cnt); device->save_item(NAME(cpustate->dma0_cnt));
state_save_register_device_item(device, 0, cpustate->dma1_cnt); device->save_item(NAME(cpustate->dma1_cnt));
state_save_register_device_item(device, 0, cpustate->after_EI); 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); device->save_item(NAME(cpustate->read_tcr_tmdr));
state_save_register_device_item_array(device, 0, cpustate->tmdr_value); device->save_item(NAME(cpustate->tmdr_value));
state_save_register_device_item_array(device, 0, cpustate->tmdrh); device->save_item(NAME(cpustate->tmdrh));
state_save_register_device_item(device, 0, cpustate->tmdr_latch); device->save_item(NAME(cpustate->tmdr_latch));
state_save_register_device_item_array(device, 0, cpustate->io); device->save_item(NAME(cpustate->io));
state_save_register_device_item(device, 0, cpustate->iol); device->save_item(NAME(cpustate->iol));
state_save_register_device_item(device, 0, cpustate->ioltemp); 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); cpustate->t1_timer = device->machine->scheduler().timer_alloc(FUNC(t1_tick), cpustate);
/* register for state saving */ /* register for state saving */
state_save_register_device_item(device, 0, cpustate->pc); device->save_item(NAME(cpustate->pc));
state_save_register_device_item_array(device, 0, cpustate->r); device->save_item(NAME(cpustate->r));
state_save_register_device_item_array(device, 0, cpustate->input); device->save_item(NAME(cpustate->input));
state_save_register_device_item_array(device, 0, cpustate->output); device->save_item(NAME(cpustate->output));
state_save_register_device_item_array(device, 0, cpustate->irq); 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; if( (i & 0x0f) == 0x0f ) SZHV_dec[i] |= HF;
} }
state_save_register_device_item(device, 0, z80->prvpc.w.l); device->save_item(NAME(z80->prvpc.w.l));
state_save_register_device_item(device, 0, z80->PC); device->save_item(NAME(z80->PC));
state_save_register_device_item(device, 0, z80->SP); device->save_item(NAME(z80->SP));
state_save_register_device_item(device, 0, z80->AF); device->save_item(NAME(z80->AF));
state_save_register_device_item(device, 0, z80->BC); device->save_item(NAME(z80->BC));
state_save_register_device_item(device, 0, z80->DE); device->save_item(NAME(z80->DE));
state_save_register_device_item(device, 0, z80->HL); device->save_item(NAME(z80->HL));
state_save_register_device_item(device, 0, z80->IX); device->save_item(NAME(z80->IX));
state_save_register_device_item(device, 0, z80->IY); device->save_item(NAME(z80->IY));
state_save_register_device_item(device, 0, z80->WZ); device->save_item(NAME(z80->WZ));
state_save_register_device_item(device, 0, z80->af2.w.l); device->save_item(NAME(z80->af2.w.l));
state_save_register_device_item(device, 0, z80->bc2.w.l); device->save_item(NAME(z80->bc2.w.l));
state_save_register_device_item(device, 0, z80->de2.w.l); device->save_item(NAME(z80->de2.w.l));
state_save_register_device_item(device, 0, z80->hl2.w.l); device->save_item(NAME(z80->hl2.w.l));
state_save_register_device_item(device, 0, z80->r); device->save_item(NAME(z80->r));
state_save_register_device_item(device, 0, z80->r2); device->save_item(NAME(z80->r2));
state_save_register_device_item(device, 0, z80->iff1); device->save_item(NAME(z80->iff1));
state_save_register_device_item(device, 0, z80->iff2); device->save_item(NAME(z80->iff2));
state_save_register_device_item(device, 0, z80->halt); device->save_item(NAME(z80->halt));
state_save_register_device_item(device, 0, z80->im); device->save_item(NAME(z80->im));
state_save_register_device_item(device, 0, z80->i); device->save_item(NAME(z80->i));
state_save_register_device_item(device, 0, z80->nmi_state); device->save_item(NAME(z80->nmi_state));
state_save_register_device_item(device, 0, z80->nmi_pending); device->save_item(NAME(z80->nmi_pending));
state_save_register_device_item(device, 0, z80->irq_state); device->save_item(NAME(z80->irq_state));
state_save_register_device_item(device, 0, z80->after_ei); device->save_item(NAME(z80->after_ei));
state_save_register_device_item(device, 0, z80->after_ldair); device->save_item(NAME(z80->after_ldair));
/* Reset registers to their initial values */ /* Reset registers to their initial values */
z80->PRVPC = 0; z80->PRVPC = 0;
@ -3535,7 +3535,7 @@ static CPU_INIT( z80 )
static CPU_INIT( nsc800 ) static CPU_INIT( nsc800 )
{ {
z80_state *z80 = get_safe_token(device); 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); CPU_INIT_CALL (z80);
} }

6
src/emu/devintrf.c
View File

@ -756,9 +756,9 @@ void device_t::start()
} }
// register our save states // register our save states
state_save_register_device_item(this, 0, m_clock); save_item(NAME(m_clock));
state_save_register_device_item(this, 0, m_unscaled_clock); save_item(NAME(m_unscaled_clock));
state_save_register_device_item(this, 0, m_clock_scale); save_item(NAME(m_clock_scale));
// we're now officially started // we're now officially started
m_started = true; 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); m_timedint_timer = device().machine->scheduler().timer_alloc(FUNC(static_trigger_periodic_interrupt), (void *)this);
// register for save states // register for save states
state_save_register_device_item(&m_device, 0, m_suspend); m_device.save_item(NAME(m_suspend));
state_save_register_device_item(&m_device, 0, m_nextsuspend); m_device.save_item(NAME(m_nextsuspend));
state_save_register_device_item(&m_device, 0, m_eatcycles); m_device.save_item(NAME(m_eatcycles));
state_save_register_device_item(&m_device, 0, m_nexteatcycles); m_device.save_item(NAME(m_nexteatcycles));
state_save_register_device_item(&m_device, 0, m_trigger); m_device.save_item(NAME(m_trigger));
state_save_register_device_item(&m_device, 0, m_totalcycles); m_device.save_item(NAME(m_totalcycles));
state_save_register_device_item(&m_device, 0, m_localtime); m_device.save_item(NAME(m_localtime));
state_save_register_device_item(&m_device, 0, m_iloops); m_device.save_item(NAME(m_iloops));
} }
@ -856,9 +856,9 @@ void device_execute_interface::device_input::start(device_execute_interface *exe
reset(); reset();
state_save_register_device_item(m_device, m_linenum, m_stored_vector); m_device->save_item(NAME(m_stored_vector), m_linenum);
state_save_register_device_item(m_device, m_linenum, m_curvector); m_device->save_item(NAME(m_curvector), m_linenum);
state_save_register_device_item(m_device, m_linenum, m_curstate); 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 */ /* save state register */
state_save_register_device_item(this, 0, m_in_a); save_item(NAME(m_in_a));
state_save_register_device_item(this, 0, m_in_ca1); save_item(NAME(m_in_ca1));
state_save_register_device_item(this, 0, m_in_ca2); save_item(NAME(m_in_ca2));
state_save_register_device_item(this, 0, m_out_a); save_item(NAME(m_out_a));
state_save_register_device_item(this, 0, m_out_ca2); save_item(NAME(m_out_ca2));
state_save_register_device_item(this, 0, m_ddr_a); save_item(NAME(m_ddr_a));
state_save_register_device_item(this, 0, m_in_b); save_item(NAME(m_in_b));
state_save_register_device_item(this, 0, m_in_cb1); save_item(NAME(m_in_cb1));
state_save_register_device_item(this, 0, m_in_cb2); save_item(NAME(m_in_cb2));
state_save_register_device_item(this, 0, m_out_b); save_item(NAME(m_out_b));
state_save_register_device_item(this, 0, m_out_cb2); save_item(NAME(m_out_cb2));
state_save_register_device_item(this, 0, m_ddr_b); save_item(NAME(m_ddr_b));
state_save_register_device_item(this, 0, m_t1cl); save_item(NAME(m_t1cl));
state_save_register_device_item(this, 0, m_t1ch); save_item(NAME(m_t1ch));
state_save_register_device_item(this, 0, m_t1ll); save_item(NAME(m_t1ll));
state_save_register_device_item(this, 0, m_t1lh); save_item(NAME(m_t1lh));
state_save_register_device_item(this, 0, m_t2cl); save_item(NAME(m_t2cl));
state_save_register_device_item(this, 0, m_t2ch); save_item(NAME(m_t2ch));
state_save_register_device_item(this, 0, m_t2ll); save_item(NAME(m_t2ll));
state_save_register_device_item(this, 0, m_t2lh); save_item(NAME(m_t2lh));
state_save_register_device_item(this, 0, m_sr); save_item(NAME(m_sr));
state_save_register_device_item(this, 0, m_pcr); save_item(NAME(m_pcr));
state_save_register_device_item(this, 0, m_acr); save_item(NAME(m_acr));
state_save_register_device_item(this, 0, m_ier); save_item(NAME(m_ier));
state_save_register_device_item(this, 0, m_ifr); save_item(NAME(m_ifr));
state_save_register_device_item(this, 0, m_t1_active); save_item(NAME(m_t1_active));
state_save_register_device_item(this, 0, m_t2_active); save_item(NAME(m_t2_active));
state_save_register_device_item(this, 0, m_shift_counter); 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 support */
state_save_register_device_item(this, 0, m_port[0].m_ddr); save_item(NAME(m_port[0].m_ddr));
state_save_register_device_item(this, 0, m_port[0].m_latch); save_item(NAME(m_port[0].m_latch));
state_save_register_device_item(this, 0, m_port[0].m_in); save_item(NAME(m_port[0].m_in));
state_save_register_device_item(this, 0, m_port[0].m_out); save_item(NAME(m_port[0].m_out));
state_save_register_device_item(this, 0, m_port[0].m_mask_value); save_item(NAME(m_port[0].m_mask_value));
state_save_register_device_item(this, 0, m_port[1].m_ddr); save_item(NAME(m_port[1].m_ddr));
state_save_register_device_item(this, 0, m_port[1].m_latch); save_item(NAME(m_port[1].m_latch));
state_save_register_device_item(this, 0, m_port[1].m_in); save_item(NAME(m_port[1].m_in));
state_save_register_device_item(this, 0, m_port[1].m_out); save_item(NAME(m_port[1].m_out));
state_save_register_device_item(this, 0, m_port[1].m_mask_value); save_item(NAME(m_port[1].m_mask_value));
state_save_register_device_item(this, 0, m_timer[0].m_latch); save_item(NAME(m_timer[0].m_latch));
state_save_register_device_item(this, 0, m_timer[0].m_count); save_item(NAME(m_timer[0].m_count));
state_save_register_device_item(this, 0, m_timer[0].m_mode); save_item(NAME(m_timer[0].m_mode));
state_save_register_device_item(this, 0, m_timer[0].m_irq); save_item(NAME(m_timer[0].m_irq));
state_save_register_device_item(this, 0, m_timer[1].m_latch); save_item(NAME(m_timer[1].m_latch));
state_save_register_device_item(this, 0, m_timer[1].m_count); save_item(NAME(m_timer[1].m_count));
state_save_register_device_item(this, 0, m_timer[1].m_mode); save_item(NAME(m_timer[1].m_mode));
state_save_register_device_item(this, 0, m_timer[1].m_irq); save_item(NAME(m_timer[1].m_irq));
state_save_register_device_item(this, 0, m_tod); save_item(NAME(m_tod));
state_save_register_device_item(this, 0, m_tod_latch); save_item(NAME(m_tod_latch));
state_save_register_device_item(this, 0, m_tod_latched); save_item(NAME(m_tod_latched));
state_save_register_device_item(this, 0, m_tod_running); save_item(NAME(m_tod_running));
state_save_register_device_item(this, 0, m_alarm); save_item(NAME(m_alarm));
state_save_register_device_item(this, 0, m_icr); save_item(NAME(m_icr));
state_save_register_device_item(this, 0, m_ics); save_item(NAME(m_ics));
state_save_register_device_item(this, 0, m_irq); save_item(NAME(m_irq));
state_save_register_device_item(this, 0, m_flag); save_item(NAME(m_flag));
state_save_register_device_item(this, 0, m_loaded); save_item(NAME(m_loaded));
state_save_register_device_item(this, 0, m_sdr); save_item(NAME(m_sdr));
state_save_register_device_item(this, 0, m_sp); save_item(NAME(m_sp));
state_save_register_device_item(this, 0, m_cnt); save_item(NAME(m_cnt));
state_save_register_device_item(this, 0, m_shift); save_item(NAME(m_shift));
state_save_register_device_item(this, 0, m_serial); 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); m_timer = m_machine.scheduler().timer_alloc(FUNC(timer_end_callback), (void *)this);
/* register for save states */ /* register for save states */
state_save_register_device_item(this, 0, m_port[0].m_in); save_item(NAME(m_port[0].m_in));
state_save_register_device_item(this, 0, m_port[0].m_out); save_item(NAME(m_port[0].m_out));
state_save_register_device_item(this, 0, m_port[0].m_ddr); save_item(NAME(m_port[0].m_ddr));
state_save_register_device_item(this, 0, m_port[1].m_in); save_item(NAME(m_port[1].m_in));
state_save_register_device_item(this, 0, m_port[1].m_out); save_item(NAME(m_port[1].m_out));
state_save_register_device_item(this, 0, m_port[1].m_ddr); save_item(NAME(m_port[1].m_ddr));
state_save_register_device_item(this, 0, m_irqstate); save_item(NAME(m_irqstate));
state_save_register_device_item(this, 0, m_irqenable); save_item(NAME(m_irqenable));
state_save_register_device_item(this, 0, m_pa7dir); save_item(NAME(m_pa7dir));
state_save_register_device_item(this, 0, m_pa7prev); save_item(NAME(m_pa7prev));
state_save_register_device_item(this, 0, m_timershift); save_item(NAME(m_timershift));
state_save_register_device_item(this, 0, m_timerstate); 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_a_func, &m_config.m_irq_a_func, this);
devcb_resolve_write_line(&m_irq_b_func, &m_config.m_irq_b_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); save_item(NAME(m_in_a));
state_save_register_device_item(this, 0, m_in_ca1); save_item(NAME(m_in_ca1));
state_save_register_device_item(this, 0, m_in_ca2); save_item(NAME(m_in_ca2));
state_save_register_device_item(this, 0, m_out_a); save_item(NAME(m_out_a));
state_save_register_device_item(this, 0, m_out_ca2); save_item(NAME(m_out_ca2));
state_save_register_device_item(this, 0, m_port_a_z_mask); save_item(NAME(m_port_a_z_mask));
state_save_register_device_item(this, 0, m_ddr_a); save_item(NAME(m_ddr_a));
state_save_register_device_item(this, 0, m_ctl_a); save_item(NAME(m_ctl_a));
state_save_register_device_item(this, 0, m_irq_a1); save_item(NAME(m_irq_a1));
state_save_register_device_item(this, 0, m_irq_a2); save_item(NAME(m_irq_a2));
state_save_register_device_item(this, 0, m_irq_a_state); save_item(NAME(m_irq_a_state));
state_save_register_device_item(this, 0, m_in_b); save_item(NAME(m_in_b));
state_save_register_device_item(this, 0, m_in_cb1); save_item(NAME(m_in_cb1));
state_save_register_device_item(this, 0, m_in_cb2); save_item(NAME(m_in_cb2));
state_save_register_device_item(this, 0, m_out_b); save_item(NAME(m_out_b));
state_save_register_device_item(this, 0, m_out_cb2); save_item(NAME(m_out_cb2));
state_save_register_device_item(this, 0, m_last_out_cb2_z); save_item(NAME(m_last_out_cb2_z));
state_save_register_device_item(this, 0, m_ddr_b); save_item(NAME(m_ddr_b));
state_save_register_device_item(this, 0, m_ctl_b); save_item(NAME(m_ctl_b));
state_save_register_device_item(this, 0, m_irq_b1); save_item(NAME(m_irq_b1));
state_save_register_device_item(this, 0, m_irq_b2); save_item(NAME(m_irq_b2));
state_save_register_device_item(this, 0, m_irq_b_state); save_item(NAME(m_irq_b_state));
state_save_register_device_item(this, 0, m_in_a_pushed); save_item(NAME(m_in_a_pushed));
state_save_register_device_item(this, 0, m_out_a_needs_pulled); save_item(NAME(m_out_a_needs_pulled));
state_save_register_device_item(this, 0, m_in_ca1_pushed); save_item(NAME(m_in_ca1_pushed));
state_save_register_device_item(this, 0, m_in_ca2_pushed); save_item(NAME(m_in_ca2_pushed));
state_save_register_device_item(this, 0, m_out_ca2_needs_pulled); save_item(NAME(m_out_ca2_needs_pulled));
state_save_register_device_item(this, 0, m_in_b_pushed); save_item(NAME(m_in_b_pushed));
state_save_register_device_item(this, 0, m_out_b_needs_pulled); save_item(NAME(m_out_b_needs_pulled));
state_save_register_device_item(this, 0, m_in_cb1_pushed); save_item(NAME(m_in_cb1_pushed));
state_save_register_device_item(this, 0, m_in_cb2_pushed); save_item(NAME(m_in_cb2_pushed));
state_save_register_device_item(this, 0, m_out_cb2_needs_pulled); 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); devcb_resolve_write_line(&m_irq_func, &m_config.m_irq_func, this);
/* register for state saving */ /* register for state saving */
state_save_register_device_item(this, 0, m_lsb_buffer); save_item(NAME(m_lsb_buffer));
state_save_register_device_item(this, 0, m_msb_buffer); save_item(NAME(m_msb_buffer));
state_save_register_device_item(this, 0, m_status_read_since_int); save_item(NAME(m_status_read_since_int));
state_save_register_device_item(this, 0, m_status_reg); save_item(NAME(m_status_reg));
state_save_register_device_item(this, 0, m_t3_divisor); save_item(NAME(m_t3_divisor));
state_save_register_device_item(this, 0, m_t3_scaler); save_item(NAME(m_t3_scaler));
state_save_register_device_item(this, 0, m_internal_clock); save_item(NAME(m_internal_clock));
state_save_register_device_item(this, 0, m_IRQ); save_item(NAME(m_IRQ));
state_save_register_device_item_array(this, 0, m_control_reg); save_item(NAME(m_control_reg));
state_save_register_device_item_array(this, 0, m_output); save_item(NAME(m_output));
state_save_register_device_item_array(this, 0, m_gate); save_item(NAME(m_gate));
state_save_register_device_item_array(this, 0, m_clk); save_item(NAME(m_clk));
state_save_register_device_item_array(this, 0, m_mode); save_item(NAME(m_mode));
state_save_register_device_item_array(this, 0, m_fired); save_item(NAME(m_fired));
state_save_register_device_item_array(this, 0, m_enabled); save_item(NAME(m_enabled));
state_save_register_device_item_array(this, 0, m_external_clock); save_item(NAME(m_external_clock));
state_save_register_device_item_array(this, 0, m_counter); save_item(NAME(m_counter));
state_save_register_device_item_array(this, 0, m_latch); 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_rx_timer->reset();
m_tx_timer->reset(); m_tx_timer->reset();
state_save_register_device_item(this, 0, m_ctrl); save_item(NAME(m_ctrl));
state_save_register_device_item(this, 0, m_status); save_item(NAME(m_status));
state_save_register_device_item(this, 0, m_rx_clock); save_item(NAME(m_rx_clock));
state_save_register_device_item(this, 0, m_tx_clock); save_item(NAME(m_tx_clock));
state_save_register_device_item(this, 0, m_rx_counter); save_item(NAME(m_rx_counter));
state_save_register_device_item(this, 0, m_tx_counter); save_item(NAME(m_tx_counter));
state_save_register_device_item(this, 0, m_rx_shift); save_item(NAME(m_rx_shift));
state_save_register_device_item(this, 0, m_tx_shift); save_item(NAME(m_tx_shift));
state_save_register_device_item(this, 0, m_rdr); save_item(NAME(m_rdr));
state_save_register_device_item(this, 0, m_tdr); save_item(NAME(m_tdr));
state_save_register_device_item(this, 0, m_rx_bits); save_item(NAME(m_rx_bits));
state_save_register_device_item(this, 0, m_tx_bits); save_item(NAME(m_tx_bits));
state_save_register_device_item(this, 0, m_rx_parity); save_item(NAME(m_rx_parity));
state_save_register_device_item(this, 0, m_tx_parity); save_item(NAME(m_tx_parity));
state_save_register_device_item(this, 0, m_tx_int); save_item(NAME(m_tx_int));
state_save_register_device_item(this, 0, m_divide); save_item(NAME(m_divide));
state_save_register_device_item(this, 0, m_overrun); save_item(NAME(m_overrun));
state_save_register_device_item(this, 0, m_reset); save_item(NAME(m_reset));
state_save_register_device_item(this, 0, m_first_reset); save_item(NAME(m_first_reset));
state_save_register_device_item(this, 0, m_rts); save_item(NAME(m_rts));
state_save_register_device_item(this, 0, m_brk); save_item(NAME(m_brk));
state_save_register_device_item(this, 0, m_status_read); 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->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); duart68681->duart_timer = device->machine->scheduler().timer_alloc(FUNC(duart_timer_callback), (void*)device);
state_save_register_device_item(device, 0, duart68681->ACR); device->save_item(NAME(duart68681->ACR));
state_save_register_device_item(device, 0, duart68681->IMR); device->save_item(NAME(duart68681->IMR));
state_save_register_device_item(device, 0, duart68681->ISR); device->save_item(NAME(duart68681->ISR));
state_save_register_device_item(device, 0, duart68681->IVR); device->save_item(NAME(duart68681->IVR));
state_save_register_device_item(device, 0, duart68681->OPCR); device->save_item(NAME(duart68681->OPCR));
state_save_register_device_item(device, 0, duart68681->CTR); device->save_item(NAME(duart68681->CTR));
state_save_register_device_item(device, 0, duart68681->IP_last_state); device->save_item(NAME(duart68681->IP_last_state));
state_save_register_device_item(device, 0, duart68681->channel[0].CR); device->save_item(NAME(duart68681->channel[0].CR));
state_save_register_device_item(device, 0, duart68681->channel[0].CSR); device->save_item(NAME(duart68681->channel[0].CSR));
state_save_register_device_item(device, 0, duart68681->channel[0].MR1); device->save_item(NAME(duart68681->channel[0].MR1));
state_save_register_device_item(device, 0, duart68681->channel[0].MR2); device->save_item(NAME(duart68681->channel[0].MR2));
state_save_register_device_item(device, 0, duart68681->channel[0].MR_ptr); device->save_item(NAME(duart68681->channel[0].MR_ptr));
state_save_register_device_item(device, 0, duart68681->channel[0].SR); device->save_item(NAME(duart68681->channel[0].SR));
state_save_register_device_item(device, 0, duart68681->channel[0].baud_rate); device->save_item(NAME(duart68681->channel[0].baud_rate));
state_save_register_device_item(device, 0, duart68681->channel[0].rx_enabled); device->save_item(NAME(duart68681->channel[0].rx_enabled));
state_save_register_device_item_array(device, 0, duart68681->channel[0].rx_fifo); device->save_item(NAME(duart68681->channel[0].rx_fifo));
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_read_ptr); device->save_item(NAME(duart68681->channel[0].rx_fifo_read_ptr));
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_write_ptr); device->save_item(NAME(duart68681->channel[0].rx_fifo_write_ptr));
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_num); device->save_item(NAME(duart68681->channel[0].rx_fifo_num));
state_save_register_device_item(device, 0, duart68681->channel[0].tx_enabled); device->save_item(NAME(duart68681->channel[0].tx_enabled));
state_save_register_device_item(device, 0, duart68681->channel[0].tx_data); device->save_item(NAME(duart68681->channel[0].tx_data));
state_save_register_device_item(device, 0, duart68681->channel[0].tx_ready); device->save_item(NAME(duart68681->channel[0].tx_ready));
state_save_register_device_item(device, 0, duart68681->channel[1].CR); device->save_item(NAME(duart68681->channel[1].CR));
state_save_register_device_item(device, 0, duart68681->channel[1].CSR); device->save_item(NAME(duart68681->channel[1].CSR));
state_save_register_device_item(device, 0, duart68681->channel[1].MR1); device->save_item(NAME(duart68681->channel[1].MR1));
state_save_register_device_item(device, 0, duart68681->channel[1].MR2); device->save_item(NAME(duart68681->channel[1].MR2));
state_save_register_device_item(device, 0, duart68681->channel[1].MR_ptr); device->save_item(NAME(duart68681->channel[1].MR_ptr));
state_save_register_device_item(device, 0, duart68681->channel[1].SR); device->save_item(NAME(duart68681->channel[1].SR));
state_save_register_device_item(device, 0, duart68681->channel[1].baud_rate); device->save_item(NAME(duart68681->channel[1].baud_rate));
state_save_register_device_item(device, 0, duart68681->channel[1].rx_enabled); device->save_item(NAME(duart68681->channel[1].rx_enabled));
state_save_register_device_item_array(device, 0, duart68681->channel[1].rx_fifo); device->save_item(NAME(duart68681->channel[1].rx_fifo));
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_read_ptr); device->save_item(NAME(duart68681->channel[1].rx_fifo_read_ptr));
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_write_ptr); device->save_item(NAME(duart68681->channel[1].rx_fifo_write_ptr));
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_num); device->save_item(NAME(duart68681->channel[1].rx_fifo_num));
state_save_register_device_item(device, 0, duart68681->channel[1].tx_enabled); device->save_item(NAME(duart68681->channel[1].tx_enabled));
state_save_register_device_item(device, 0, duart68681->channel[1].tx_data); device->save_item(NAME(duart68681->channel[1].tx_data));
state_save_register_device_item(device, 0, duart68681->channel[1].tx_ready); 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; m_clear = m_config.m_clear;
/* register for state saving */ /* register for state saving */
state_save_register_device_item(this, 0, m_a); save_item(NAME(m_a));
state_save_register_device_item(this, 0, m_b); save_item(NAME(m_b));
state_save_register_device_item(this, 0, m_clear); 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); ttl74148_state *state = get_safe_token(device);
state->output_cb = config->output_cb; state->output_cb = config->output_cb;
state_save_register_device_item_array(device, 0, state->input_lines); device->save_item(NAME(state->input_lines));
state_save_register_device_item(device, 0, state->enable_input); device->save_item(NAME(state->enable_input));
state_save_register_device_item(device, 0, state->output); device->save_item(NAME(state->output));
state_save_register_device_item(device, 0, state->output_valid); device->save_item(NAME(state->output_valid));
state_save_register_device_item(device, 0, state->enable_output); device->save_item(NAME(state->enable_output));
state_save_register_device_item(device, 0, state->last_output); device->save_item(NAME(state->last_output));
state_save_register_device_item(device, 0, state->last_output_valid); device->save_item(NAME(state->last_output_valid));
state_save_register_device_item(device, 0, state->last_enable_output); 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); ttl74153_state *state = get_safe_token(device);
state->output_cb = config->output_cb; state->output_cb = config->output_cb;
state_save_register_device_item_array(device, 0, state->enable); device->save_item(NAME(state->enable));
state_save_register_device_item_array(device, 0, state->last_output); device->save_item(NAME(state->last_output));
state_save_register_device_item(device, 0, state->input_lines[0][0]); device->save_item(NAME(state->input_lines[0][0]));
state_save_register_device_item(device, 0, state->input_lines[0][1]); device->save_item(NAME(state->input_lines[0][1]));
state_save_register_device_item(device, 0, state->input_lines[0][2]); device->save_item(NAME(state->input_lines[0][2]));
state_save_register_device_item(device, 0, state->input_lines[0][3]); device->save_item(NAME(state->input_lines[0][3]));
state_save_register_device_item(device, 0, state->input_lines[1][0]); device->save_item(NAME(state->input_lines[1][0]));
state_save_register_device_item(device, 0, state->input_lines[1][1]); device->save_item(NAME(state->input_lines[1][1]));
state_save_register_device_item(device, 0, state->input_lines[1][2]); device->save_item(NAME(state->input_lines[1][2]));
state_save_register_device_item(device, 0, state->input_lines[1][3]); device->save_item(NAME(state->input_lines[1][3]));
state_save_register_device_item(device, 0, state->a); device->save_item(NAME(state->a));
state_save_register_device_item(device, 0, state->b); 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() void ttl7474_device::device_start()
{ {
state_save_register_device_item(this, 0, m_clear); save_item(NAME(m_clear));
state_save_register_device_item(this, 0, m_preset); save_item(NAME(m_preset));
state_save_register_device_item(this, 0, m_clk); save_item(NAME(m_clk));
state_save_register_device_item(this, 0, m_d); save_item(NAME(m_d));
state_save_register_device_item(this, 0, m_output); save_item(NAME(m_output));
state_save_register_device_item(this, 0, m_output_comp); save_item(NAME(m_output_comp));
state_save_register_device_item(this, 0, m_last_clock); save_item(NAME(m_last_clock));
state_save_register_device_item(this, 0, m_last_output); save_item(NAME(m_last_output));
state_save_register_device_item(this, 0, m_last_output_comp); 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_output_cb, &m_config.m_output_cb, this);
devcb_resolve_write_line(&m_comp_output_cb, &m_config.m_comp_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); devcb_resolve_write8(&m_port_write[2], &m_config.m_port_c_write, this);
/* register for state saving */ /* register for state saving */
state_save_register_device_item(this, 0, m_group_a_mode); save_item(NAME(m_group_a_mode));
state_save_register_device_item(this, 0, m_group_b_mode); save_item(NAME(m_group_b_mode));
state_save_register_device_item(this, 0, m_port_a_dir); save_item(NAME(m_port_a_dir));
state_save_register_device_item(this, 0, m_port_b_dir); save_item(NAME(m_port_b_dir));
state_save_register_device_item(this, 0, m_port_ch_dir); save_item(NAME(m_port_ch_dir));
state_save_register_device_item(this, 0, m_port_cl_dir); save_item(NAME(m_port_cl_dir));
state_save_register_device_item(this, 0, m_obf_a); save_item(NAME(m_obf_a));
state_save_register_device_item(this, 0, m_obf_b); save_item(NAME(m_obf_b));
state_save_register_device_item(this, 0, m_ibf_a); save_item(NAME(m_ibf_a));
state_save_register_device_item(this, 0, m_ibf_b); save_item(NAME(m_ibf_b));
state_save_register_device_item(this, 0, m_inte_a); save_item(NAME(m_inte_a));
state_save_register_device_item(this, 0, m_inte_b); save_item(NAME(m_inte_b));
state_save_register_device_item(this, 0, m_inte_1); save_item(NAME(m_inte_1));
state_save_register_device_item(this, 0, m_inte_2); save_item(NAME(m_inte_2));
state_save_register_device_item_array(this, 0, m_in_mask); save_item(NAME(m_in_mask));
state_save_register_device_item_array(this, 0, m_out_mask); save_item(NAME(m_out_mask));
state_save_register_device_item_array(this, 0, m_read); save_item(NAME(m_read));
state_save_register_device_item_array(this, 0, m_latch); 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); m_msbflip_timer = timer_alloc(TIMER_MSBFLIP);
/* register for state saving */ /* register for state saving */
state_save_register_device_item_array(this, 0, m_address); save_item(NAME(m_address));
state_save_register_device_item_array(this, 0, m_count); save_item(NAME(m_count));
state_save_register_device_item_array(this, 0, m_rwmode); save_item(NAME(m_rwmode));
state_save_register_device_item_array(this, 0, m_registers); save_item(NAME(m_registers));
state_save_register_device_item(this, 0, m_mode); save_item(NAME(m_mode));
state_save_register_device_item(this, 0, m_rr); save_item(NAME(m_rr));
state_save_register_device_item(this, 0, m_msb); save_item(NAME(m_msb));
state_save_register_device_item(this, 0, m_drq); save_item(NAME(m_drq));
state_save_register_device_item(this, 0, m_status); 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; adc083x->input_callback_r = intf->input_callback_r;
/* register for state saving */ /* register for state saving */
state_save_register_device_item( device, 0, adc083x->cs ); device->save_item( NAME(adc083x->cs) );
state_save_register_device_item( device, 0, adc083x->clk ); device->save_item( NAME(adc083x->clk) );
state_save_register_device_item( device, 0, adc083x->di ); device->save_item( NAME(adc083x->di) );
state_save_register_device_item( device, 0, adc083x->se ); device->save_item( NAME(adc083x->se) );
state_save_register_device_item( device, 0, adc083x->sars ); device->save_item( NAME(adc083x->sars) );
state_save_register_device_item( device, 0, adc083x->_do ); device->save_item( NAME(adc083x->_do) );
state_save_register_device_item( device, 0, adc083x->sgl ); device->save_item( NAME(adc083x->sgl) );
state_save_register_device_item( device, 0, adc083x->odd ); device->save_item( NAME(adc083x->odd) );
state_save_register_device_item( device, 0, adc083x->sel1 ); device->save_item( NAME(adc083x->sel1) );
state_save_register_device_item( device, 0, adc083x->sel0 ); device->save_item( NAME(adc083x->sel0) );
state_save_register_device_item( device, 0, adc083x->state ); device->save_item( NAME(adc083x->state) );
state_save_register_device_item( device, 0, adc083x->bit ); device->save_item( NAME(adc083x->bit) );
state_save_register_device_item( device, 0, adc083x->output ); device->save_item( NAME(adc083x->output) );
state_save_register_device_item( device, 0, adc083x->mux_bits ); 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->gticlub_hack = intf->gticlub_hack;
adc1038->input_callback_r = intf->input_callback_r; adc1038->input_callback_r = intf->input_callback_r;
state_save_register_device_item(device, 0, adc1038->cycle); device->save_item(NAME(adc1038->cycle));
state_save_register_device_item(device, 0, adc1038->clk); device->save_item(NAME(adc1038->clk));
state_save_register_device_item(device, 0, adc1038->adr); device->save_item(NAME(adc1038->adr));
state_save_register_device_item(device, 0, adc1038->data_in); device->save_item(NAME(adc1038->data_in));
state_save_register_device_item(device, 0, adc1038->data_out); device->save_item(NAME(adc1038->data_out));
state_save_register_device_item(device, 0, adc1038->adc_data); device->save_item(NAME(adc1038->adc_data));
state_save_register_device_item(device, 0, adc1038->sars); device->save_item(NAME(adc1038->sars));
} }
static DEVICE_RESET( adc1038 ) 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; adc1213x->input_callback_r = intf->input_callback_r;
/* register for state saving */ /* register for state saving */
state_save_register_device_item(device, 0, adc1213x->cycle); device->save_item(NAME(adc1213x->cycle));
state_save_register_device_item(device, 0, adc1213x->data_out); device->save_item(NAME(adc1213x->data_out));
state_save_register_device_item(device, 0, adc1213x->data_in); device->save_item(NAME(adc1213x->data_in));
state_save_register_device_item(device, 0, adc1213x->conv_mode); device->save_item(NAME(adc1213x->conv_mode));
state_save_register_device_item(device, 0, adc1213x->auto_cal); device->save_item(NAME(adc1213x->auto_cal));
state_save_register_device_item(device, 0, adc1213x->auto_zero); device->save_item(NAME(adc1213x->auto_zero));
state_save_register_device_item(device, 0, adc1213x->acq_time); device->save_item(NAME(adc1213x->acq_time));
state_save_register_device_item(device, 0, adc1213x->data_out_sign); device->save_item(NAME(adc1213x->data_out_sign));
state_save_register_device_item(device, 0, adc1213x->mode); device->save_item(NAME(adc1213x->mode));
state_save_register_device_item(device, 0, adc1213x->input_shift_reg); device->save_item(NAME(adc1213x->input_shift_reg));
state_save_register_device_item(device, 0, adc1213x->output_shift_reg); device->save_item(NAME(adc1213x->output_shift_reg));
state_save_register_device_item(device, 0, adc1213x->end_conv); device->save_item(NAME(adc1213x->end_conv));
} }

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