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

Changed save state system to accept machine parameters where

Browse Source 
appropriate, and to keep all global variables hanging off the
machine structure. Once again, this means all state registration
call sites have been touched:

  - state_save_register_global* now takes a machine parameter
  - state_save_register_item* now takes a machine parameter
  - added new state_save_register_device_item* which now uses
     the device name and tag to generate the base name

Extended the fake sound devices to have more populated fields.
Modified sound cores to use tags from the devices and simplified
the start function.

Renumbered CPU and sound get/set info constants to align with
the device constants, and shared values where they were perfectly
aligned.

Set the type field in the fake device_configs for CPU and sound
chips to a get_info stub which calls through to the CPU and sound
specific get_info functions. This means the device_get_info()
functions work for CPU and sound cores, even in their fake state.

Changed device information getters from device_info() to
device_get_info() to match the CPU and sound macros.
This commit is contained in:
Aaron Giles 2008-12-05 08:00:13 +00:00
parent 9c88aa96d0
commit 3c6eacc96f
594 changed files with 6249 additions and 6057 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/emu/audio/generic.c
View File

@ -33,7 +33,7 @@ static UINT8 latch_read[4];
register for save states
-------------------------------------------------*/
int generic_sound_init(void)
int generic_sound_init(running_machine *machine)
{
/* reset latches */
latch_clear_value = 0;
@ -41,8 +41,8 @@ int generic_sound_init(void)
memset(latch_read, 0, sizeof(latch_read));
/* register globals with the save state system */
state_save_register_global_array(latched_value);
state_save_register_global_array(latch_read);
state_save_register_global_array(machine, latched_value);
state_save_register_global_array(machine, latch_read);
return 0;
}

2
src/emu/audio/generic.h
View File

@ -24,7 +24,7 @@
***************************************************************************/
int generic_sound_init(void);
int generic_sound_init(running_machine *machine);
/* latch readers */
READ8_HANDLER( soundlatch_r );

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

@ -615,85 +615,85 @@ static adsp2100_state *adsp21xx_init(const device_config *device, int index, int
adsp->shift_xregs[7] = &adsp->core.sr.srx.sr1;
/* "core" */
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ax0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ax1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ay0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ay1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ar.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.af.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mx0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mx1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.my0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.my1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mr.mr);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mf.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.si.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.se.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.sb.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.sr.sr);
state_save_register_item("adsp2100", device->tag, 0, adsp->core.zero.u);
state_save_register_device_item(device, 0, adsp->core.ax0.u);
state_save_register_device_item(device, 0, adsp->core.ax1.u);
state_save_register_device_item(device, 0, adsp->core.ay0.u);
state_save_register_device_item(device, 0, adsp->core.ay1.u);
state_save_register_device_item(device, 0, adsp->core.ar.u);
state_save_register_device_item(device, 0, adsp->core.af.u);
state_save_register_device_item(device, 0, adsp->core.mx0.u);
state_save_register_device_item(device, 0, adsp->core.mx1.u);
state_save_register_device_item(device, 0, adsp->core.my0.u);
state_save_register_device_item(device, 0, adsp->core.my1.u);
state_save_register_device_item(device, 0, adsp->core.mr.mr);
state_save_register_device_item(device, 0, adsp->core.mf.u);
state_save_register_device_item(device, 0, adsp->core.si.u);
state_save_register_device_item(device, 0, adsp->core.se.u);
state_save_register_device_item(device, 0, adsp->core.sb.u);
state_save_register_device_item(device, 0, adsp->core.sr.sr);
state_save_register_device_item(device, 0, adsp->core.zero.u);
/* "alt" */
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ax0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ax1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ay0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ay1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ar.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.af.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mx0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mx1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.my0.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.my1.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mr.mr);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mf.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.si.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.se.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.sb.u);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.sr.sr);
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.zero.u);
state_save_register_device_item(device, 0, adsp->alt.ax0.u);
state_save_register_device_item(device, 0, adsp->alt.ax1.u);
state_save_register_device_item(device, 0, adsp->alt.ay0.u);
state_save_register_device_item(device, 0, adsp->alt.ay1.u);
state_save_register_device_item(device, 0, adsp->alt.ar.u);
state_save_register_device_item(device, 0, adsp->alt.af.u);
state_save_register_device_item(device, 0, adsp->alt.mx0.u);
state_save_register_device_item(device, 0, adsp->alt.mx1.u);
state_save_register_device_item(device, 0, adsp->alt.my0.u);
state_save_register_device_item(device, 0, adsp->alt.my1.u);
state_save_register_device_item(device, 0, adsp->alt.mr.mr);
state_save_register_device_item(device, 0, adsp->alt.mf.u);
state_save_register_device_item(device, 0, adsp->alt.si.u);
state_save_register_device_item(device, 0, adsp->alt.se.u);
state_save_register_device_item(device, 0, adsp->alt.sb.u);
state_save_register_device_item(device, 0, adsp->alt.sr.sr);
state_save_register_device_item(device, 0, adsp->alt.zero.u);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->i);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->m);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->l);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->lmask);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->base);
state_save_register_item("adsp2100", device->tag, 0, adsp->px);
state_save_register_device_item_array(device, 0, adsp->i);
state_save_register_device_item_array(device, 0, adsp->m);
state_save_register_device_item_array(device, 0, adsp->l);
state_save_register_device_item_array(device, 0, adsp->lmask);
state_save_register_device_item_array(device, 0, adsp->base);
state_save_register_device_item(device, 0, adsp->px);
state_save_register_item("adsp2100", device->tag, 0, adsp->pc);
state_save_register_item("adsp2100", device->tag, 0, adsp->ppc);
state_save_register_item("adsp2100", device->tag, 0, adsp->loop);
state_save_register_item("adsp2100", device->tag, 0, adsp->loop_condition);
state_save_register_item("adsp2100", device->tag, 0, adsp->cntr);
state_save_register_item("adsp2100", device->tag, 0, adsp->astat);
state_save_register_item("adsp2100", device->tag, 0, adsp->sstat);
state_save_register_item("adsp2100", device->tag, 0, adsp->mstat);
state_save_register_item("adsp2100", device->tag, 0, adsp->astat_clear);
state_save_register_item("adsp2100", device->tag, 0, adsp->idle);
state_save_register_device_item(device, 0, adsp->pc);
state_save_register_device_item(device, 0, adsp->ppc);
state_save_register_device_item(device, 0, adsp->loop);
state_save_register_device_item(device, 0, adsp->loop_condition);
state_save_register_device_item(device, 0, adsp->cntr);
state_save_register_device_item(device, 0, adsp->astat);
state_save_register_device_item(device, 0, adsp->sstat);
state_save_register_device_item(device, 0, adsp->mstat);
state_save_register_device_item(device, 0, adsp->astat_clear);
state_save_register_device_item(device, 0, adsp->idle);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->loop_stack);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->cntr_stack);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->pc_stack);
state_save_register_item_2d_array("adsp2100", device->tag, 0, adsp->stat_stack);
state_save_register_device_item_array(device, 0, adsp->loop_stack);
state_save_register_device_item_array(device, 0, adsp->cntr_stack);
state_save_register_device_item_array(device, 0, adsp->pc_stack);
state_save_register_device_item_2d_array(device, 0, adsp->stat_stack);
state_save_register_item("adsp2100", device->tag, 0, adsp->pc_sp);
state_save_register_item("adsp2100", device->tag, 0, adsp->cntr_sp);
state_save_register_item("adsp2100", device->tag, 0, adsp->stat_sp);
state_save_register_item("adsp2100", device->tag, 0, adsp->loop_sp);
state_save_register_device_item(device, 0, adsp->pc_sp);
state_save_register_device_item(device, 0, adsp->cntr_sp);
state_save_register_device_item(device, 0, adsp->stat_sp);
state_save_register_device_item(device, 0, adsp->loop_sp);
state_save_register_item("adsp2100", device->tag, 0, adsp->flagout);
state_save_register_item("adsp2100", device->tag, 0, adsp->flagin);
state_save_register_item("adsp2100", device->tag, 0, adsp->fl0);
state_save_register_item("adsp2100", device->tag, 0, adsp->fl1);
state_save_register_item("adsp2100", device->tag, 0, adsp->fl2);
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_addr);
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_cache);
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_offs);
state_save_register_device_item(device, 0, adsp->flagout);
state_save_register_device_item(device, 0, adsp->flagin);
state_save_register_device_item(device, 0, adsp->fl0);
state_save_register_device_item(device, 0, adsp->fl1);
state_save_register_device_item(device, 0, adsp->fl2);
state_save_register_device_item(device, 0, adsp->idma_addr);
state_save_register_device_item(device, 0, adsp->idma_cache);
state_save_register_device_item(device, 0, adsp->idma_offs);
state_save_register_item("adsp2100", device->tag, 0, adsp->imask);
state_save_register_item("adsp2100", device->tag, 0, adsp->icntl);
state_save_register_item("adsp2100", device->tag, 0, adsp->ifc);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->irq_state);
state_save_register_item_array("adsp2100", device->tag, 0, adsp->irq_latch);
state_save_register_device_item(device, 0, adsp->imask);
state_save_register_device_item(device, 0, adsp->icntl);
state_save_register_device_item(device, 0, adsp->ifc);
state_save_register_device_item_array(device, 0, adsp->irq_state);
state_save_register_device_item_array(device, 0, adsp->irq_latch);
return adsp;
}

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

@ -669,27 +669,27 @@ static CPU_INIT( ALPHA8201 )
R.device = device;
R.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item_array("ALPHA8201", device->tag, 0, R.RAM);
state_save_register_item("ALPHA8201", device->tag, 0, R.PREVPC);
state_save_register_item("ALPHA8201", device->tag, 0, PC);
state_save_register_item("ALPHA8201", device->tag, 0, regPTR);
state_save_register_item("ALPHA8201", device->tag, 0, ZF);
state_save_register_item("ALPHA8201", device->tag, 0, CF);
state_save_register_item("ALPHA8201", device->tag, 0, R.mb);
state_save_register_device_item_array(device, 0, R.RAM);
state_save_register_device_item(device, 0, R.PREVPC);
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, regPTR);
state_save_register_device_item(device, 0, ZF);
state_save_register_device_item(device, 0, CF);
state_save_register_device_item(device, 0, R.mb);
#if HANDLE_HALT_LINE
state_save_register_item("ALPHA8201", device->tag, 0, R.halt);
state_save_register_device_item(device, 0, R.halt);
#endif
state_save_register_item("ALPHA8201", device->tag, 0, IX0);
state_save_register_item("ALPHA8201", device->tag, 0, IX1);
state_save_register_item("ALPHA8201", device->tag, 0, IX2);
state_save_register_item("ALPHA8201", device->tag, 0, LP0);
state_save_register_item("ALPHA8201", device->tag, 0, LP1);
state_save_register_item("ALPHA8201", device->tag, 0, LP2);
state_save_register_item("ALPHA8201", device->tag, 0, R.A);
state_save_register_item("ALPHA8201", device->tag, 0, R.B);
state_save_register_item("ALPHA8201", device->tag, 0, R.retptr);
state_save_register_item("ALPHA8201", device->tag, 0, R.savec);
state_save_register_item("ALPHA8201", device->tag, 0, R.savez);
state_save_register_device_item(device, 0, IX0);
state_save_register_device_item(device, 0, IX1);
state_save_register_device_item(device, 0, IX2);
state_save_register_device_item(device, 0, LP0);
state_save_register_device_item(device, 0, LP1);
state_save_register_device_item(device, 0, LP2);
state_save_register_device_item(device, 0, R.A);
state_save_register_device_item(device, 0, R.B);
state_save_register_device_item(device, 0, R.retptr);
state_save_register_device_item(device, 0, R.savec);
state_save_register_device_item(device, 0, R.savez);
}
/****************************************************************************
* Reset registers to their initial values

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

@ -511,10 +511,10 @@ static CPU_INIT( arm )
arm.device = device;
arm.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item_array("arm", device->tag, 0, arm.sArmRegister);
state_save_register_item_array("arm", device->tag, 0, arm.coproRegister);
state_save_register_item("arm", device->tag, 0, arm.pendingIrq);
state_save_register_item("arm", device->tag, 0, arm.pendingFiq);
state_save_register_device_item_array(device, 0, arm.sArmRegister);
state_save_register_device_item_array(device, 0, arm.coproRegister);
state_save_register_device_item(device, 0, arm.pendingIrq);
state_save_register_device_item(device, 0, arm.pendingFiq);
}
/***************************************************************************/

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

@ -512,13 +512,13 @@ static void arm7_core_init(const char *cpuname, const device_config *device)
{
arm_state *cpustate = device->token;
state_save_register_item_array(cpuname, device->tag, 0, cpustate->sArmRegister);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingIrq);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingFiq);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingAbtD);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingAbtP);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingUnd);
state_save_register_item(cpuname, device->tag, 0, cpustate->pendingSwi);
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
state_save_register_device_item(device, 0, cpustate->pendingAbtD);
state_save_register_device_item(device, 0, cpustate->pendingAbtP);
state_save_register_device_item(device, 0, cpustate->pendingUnd);
state_save_register_device_item(device, 0, cpustate->pendingSwi);
}
// CPU RESET

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

@ -137,25 +137,25 @@ static CPU_INIT( ccpu )
cpustate->data = memory_find_address_space(device, ADDRESS_SPACE_DATA);
cpustate->io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("ccpu", device->tag, 0, cpustate->PC);
state_save_register_item("ccpu", device->tag, 0, cpustate->A);
state_save_register_item("ccpu", device->tag, 0, cpustate->B);
state_save_register_item("ccpu", device->tag, 0, cpustate->I);
state_save_register_item("ccpu", device->tag, 0, cpustate->J);
state_save_register_item("ccpu", device->tag, 0, cpustate->P);
state_save_register_item("ccpu", device->tag, 0, cpustate->X);
state_save_register_item("ccpu", device->tag, 0, cpustate->Y);
state_save_register_item("ccpu", device->tag, 0, cpustate->T);
state_save_register_item("ccpu", device->tag, 0, cpustate->a0flag);
state_save_register_item("ccpu", device->tag, 0, cpustate->ncflag);
state_save_register_item("ccpu", device->tag, 0, cpustate->cmpacc);
state_save_register_item("ccpu", device->tag, 0, cpustate->cmpval);
state_save_register_item("ccpu", device->tag, 0, cpustate->miflag);
state_save_register_item("ccpu", device->tag, 0, cpustate->nextmiflag);
state_save_register_item("ccpu", device->tag, 0, cpustate->nextnextmiflag);
state_save_register_item("ccpu", device->tag, 0, cpustate->drflag);
state_save_register_item("ccpu", device->tag, 0, cpustate->waiting);
state_save_register_item("ccpu", device->tag, 0, cpustate->watchdog);
state_save_register_device_item(device, 0, cpustate->PC);
state_save_register_device_item(device, 0, cpustate->A);
state_save_register_device_item(device, 0, cpustate->B);
state_save_register_device_item(device, 0, cpustate->I);
state_save_register_device_item(device, 0, cpustate->J);
state_save_register_device_item(device, 0, cpustate->P);
state_save_register_device_item(device, 0, cpustate->X);
state_save_register_device_item(device, 0, cpustate->Y);
state_save_register_device_item(device, 0, cpustate->T);
state_save_register_device_item(device, 0, cpustate->a0flag);
state_save_register_device_item(device, 0, cpustate->ncflag);
state_save_register_device_item(device, 0, cpustate->cmpacc);
state_save_register_device_item(device, 0, cpustate->cmpval);
state_save_register_device_item(device, 0, cpustate->miflag);
state_save_register_device_item(device, 0, cpustate->nextmiflag);
state_save_register_device_item(device, 0, cpustate->nextnextmiflag);
state_save_register_device_item(device, 0, cpustate->drflag);
state_save_register_device_item(device, 0, cpustate->waiting);
state_save_register_device_item(device, 0, cpustate->watchdog);
}

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

@ -906,24 +906,24 @@ static CPU_INIT( cdp1802 )
/* register for state saving */
state_save_register_item("cdp1802", device->tag, 0, cpustate->p);
state_save_register_item("cdp1802", device->tag, 0, cpustate->x);
state_save_register_item("cdp1802", device->tag, 0, cpustate->d);
state_save_register_item("cdp1802", device->tag, 0, cpustate->b);
state_save_register_item("cdp1802", device->tag, 0, cpustate->t);
state_save_register_item_array("cdp1802", device->tag, 0, cpustate->r);
state_save_register_item("cdp1802", device->tag, 0, cpustate->df);
state_save_register_item("cdp1802", device->tag, 0, cpustate->ie);
state_save_register_item("cdp1802", device->tag, 0, cpustate->q);
state_save_register_item("cdp1802", device->tag, 0, cpustate->n);
state_save_register_item("cdp1802", device->tag, 0, cpustate->i);
state_save_register_item("cdp1802", device->tag, 0, cpustate->state);
state_save_register_item("cdp1802", device->tag, 0, cpustate->prevmode);
state_save_register_item("cdp1802", device->tag, 0, cpustate->mode);
state_save_register_item("cdp1802", device->tag, 0, cpustate->irq);
state_save_register_item("cdp1802", device->tag, 0, cpustate->dmain);
state_save_register_item("cdp1802", device->tag, 0, cpustate->dmaout);
state_save_register_item("cdp1802", device->tag, 0, cpustate->ef);
state_save_register_device_item(device, 0, cpustate->p);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->d);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->t);
state_save_register_device_item_array(device, 0, cpustate->r);
state_save_register_device_item(device, 0, cpustate->df);
state_save_register_device_item(device, 0, cpustate->ie);
state_save_register_device_item(device, 0, cpustate->q);
state_save_register_device_item(device, 0, cpustate->n);
state_save_register_device_item(device, 0, cpustate->i);
state_save_register_device_item(device, 0, cpustate->state);
state_save_register_device_item(device, 0, cpustate->prevmode);
state_save_register_device_item(device, 0, cpustate->mode);
state_save_register_device_item(device, 0, cpustate->irq);
state_save_register_device_item(device, 0, cpustate->dmain);
state_save_register_device_item(device, 0, cpustate->dmaout);
state_save_register_device_item(device, 0, cpustate->ef);
}
static CPU_GET_CONTEXT( cdp1802 ) { }

38
src/emu/cpu/cop400/cop410.c
View File

@ -218,25 +218,25 @@ static CPU_INIT( cop410 )
/* register for state saving */
state_save_register_item("cop410", device->tag, 0, cop400->pc);
state_save_register_item("cop410", device->tag, 0, cop400->prevpc);
state_save_register_item("cop410", device->tag, 0, cop400->a);
state_save_register_item("cop410", device->tag, 0, cop400->b);
state_save_register_item("cop410", device->tag, 0, cop400->c);
state_save_register_item("cop410", device->tag, 0, cop400->en);
state_save_register_item("cop410", device->tag, 0, cop400->g);
state_save_register_item("cop410", device->tag, 0, cop400->q);
state_save_register_item("cop410", device->tag, 0, cop400->sa);
state_save_register_item("cop410", device->tag, 0, cop400->sb);
state_save_register_item("cop410", device->tag, 0, cop400->sio);
state_save_register_item("cop410", device->tag, 0, cop400->skl);
state_save_register_item("cop410", device->tag, 0, cop400->skip);
state_save_register_item("cop410", device->tag, 0, cop400->skip_lbi);
state_save_register_item("cop410", device->tag, 0, cop400->g_mask);
state_save_register_item("cop410", device->tag, 0, cop400->d_mask);
state_save_register_item("cop410", device->tag, 0, cop400->si);
state_save_register_item("cop410", device->tag, 0, cop400->microbus_int);
state_save_register_item("cop410", device->tag, 0, cop400->halt);
state_save_register_device_item(device, 0, cop400->pc);
state_save_register_device_item(device, 0, cop400->prevpc);
state_save_register_device_item(device, 0, cop400->a);
state_save_register_device_item(device, 0, cop400->b);
state_save_register_device_item(device, 0, cop400->c);
state_save_register_device_item(device, 0, cop400->en);
state_save_register_device_item(device, 0, cop400->g);
state_save_register_device_item(device, 0, cop400->q);
state_save_register_device_item(device, 0, cop400->sa);
state_save_register_device_item(device, 0, cop400->sb);
state_save_register_device_item(device, 0, cop400->sio);
state_save_register_device_item(device, 0, cop400->skl);
state_save_register_device_item(device, 0, cop400->skip);
state_save_register_device_item(device, 0, cop400->skip_lbi);
state_save_register_device_item(device, 0, cop400->g_mask);
state_save_register_device_item(device, 0, cop400->d_mask);
state_save_register_device_item(device, 0, cop400->si);
state_save_register_device_item(device, 0, cop400->microbus_int);
state_save_register_device_item(device, 0, cop400->halt);
}
static CPU_INIT( cop411 )

50
src/emu/cpu/cop400/cop420.c
View File

@ -244,31 +244,31 @@ static CPU_INIT( cop420 )
/* register for state saving */
state_save_register_item("cop420", device->tag, 0, cop400->pc);
state_save_register_item("cop420", device->tag, 0, cop400->prevpc);
state_save_register_item("cop420", device->tag, 0, cop400->a);
state_save_register_item("cop420", device->tag, 0, cop400->b);
state_save_register_item("cop420", device->tag, 0, cop400->c);
state_save_register_item("cop420", device->tag, 0, cop400->en);
state_save_register_item("cop420", device->tag, 0, cop400->g);
state_save_register_item("cop420", device->tag, 0, cop400->q);
state_save_register_item("cop420", device->tag, 0, cop400->sa);
state_save_register_item("cop420", device->tag, 0, cop400->sb);
state_save_register_item("cop420", device->tag, 0, cop400->sc);
state_save_register_item("cop420", device->tag, 0, cop400->sio);
state_save_register_item("cop420", device->tag, 0, cop400->skl);
state_save_register_item("cop420", device->tag, 0, cop400->skip);
state_save_register_item("cop420", device->tag, 0, cop400->skip_lbi);
state_save_register_item("cop420", device->tag, 0, cop400->t);
state_save_register_item("cop420", device->tag, 0, cop400->skt_latch);
state_save_register_item("cop420", device->tag, 0, cop400->g_mask);
state_save_register_item("cop420", device->tag, 0, cop400->d_mask);
state_save_register_item("cop420", device->tag, 0, cop400->in_mask);
state_save_register_item("cop420", device->tag, 0, cop400->si);
state_save_register_item("cop420", device->tag, 0, cop400->last_skip);
state_save_register_item_array("cop420", device->tag, 0, cop400->in);
state_save_register_item("cop420", device->tag, 0, cop400->microbus_int);
state_save_register_item("cop420", device->tag, 0, cop400->halt);
state_save_register_device_item(device, 0, cop400->pc);
state_save_register_device_item(device, 0, cop400->prevpc);
state_save_register_device_item(device, 0, cop400->a);
state_save_register_device_item(device, 0, cop400->b);
state_save_register_device_item(device, 0, cop400->c);
state_save_register_device_item(device, 0, cop400->en);
state_save_register_device_item(device, 0, cop400->g);
state_save_register_device_item(device, 0, cop400->q);
state_save_register_device_item(device, 0, cop400->sa);
state_save_register_device_item(device, 0, cop400->sb);
state_save_register_device_item(device, 0, cop400->sc);
state_save_register_device_item(device, 0, cop400->sio);
state_save_register_device_item(device, 0, cop400->skl);
state_save_register_device_item(device, 0, cop400->skip);
state_save_register_device_item(device, 0, cop400->skip_lbi);
state_save_register_device_item(device, 0, cop400->t);
state_save_register_device_item(device, 0, cop400->skt_latch);
state_save_register_device_item(device, 0, cop400->g_mask);
state_save_register_device_item(device, 0, cop400->d_mask);
state_save_register_device_item(device, 0, cop400->in_mask);
state_save_register_device_item(device, 0, cop400->si);
state_save_register_device_item(device, 0, cop400->last_skip);
state_save_register_device_item_array(device, 0, cop400->in);
state_save_register_device_item(device, 0, cop400->microbus_int);
state_save_register_device_item(device, 0, cop400->halt);
}
static CPU_INIT( cop421 )

50
src/emu/cpu/cop400/cop440.c
View File

@ -256,31 +256,31 @@ static CPU_INIT( cop444 )
/* register for state saving */
state_save_register_item("cop420", device->tag, 0, cop400->pc);
state_save_register_item("cop420", device->tag, 0, cop400->prevpc);
state_save_register_item("cop420", device->tag, 0, cop400->a);
state_save_register_item("cop420", device->tag, 0, cop400->b);
state_save_register_item("cop420", device->tag, 0, cop400->c);
state_save_register_item("cop420", device->tag, 0, cop400->en);
state_save_register_item("cop420", device->tag, 0, cop400->g);
state_save_register_item("cop420", device->tag, 0, cop400->q);
state_save_register_item("cop420", device->tag, 0, cop400->sa);
state_save_register_item("cop420", device->tag, 0, cop400->sb);
state_save_register_item("cop420", device->tag, 0, cop400->sc);
state_save_register_item("cop420", device->tag, 0, cop400->sio);
state_save_register_item("cop420", device->tag, 0, cop400->skl);
state_save_register_item("cop420", device->tag, 0, cop400->skip);
state_save_register_item("cop420", device->tag, 0, cop400->skip_lbi);
state_save_register_item("cop420", device->tag, 0, cop400->t);
state_save_register_item("cop420", device->tag, 0, cop400->skt_latch);
state_save_register_item("cop420", device->tag, 0, cop400->g_mask);
state_save_register_item("cop420", device->tag, 0, cop400->d_mask);
state_save_register_item("cop420", device->tag, 0, cop400->in_mask);
state_save_register_item("cop420", device->tag, 0, cop400->si);
state_save_register_item("cop420", device->tag, 0, cop400->last_skip);
state_save_register_item_array("cop420", device->tag, 0, cop400->in);
state_save_register_item("cop420", device->tag, 0, cop400->microbus_int);
state_save_register_item("cop420", device->tag, 0, cop400->halt);
state_save_register_device_item(device, 0, cop400->pc);
state_save_register_device_item(device, 0, cop400->prevpc);
state_save_register_device_item(device, 0, cop400->a);
state_save_register_device_item(device, 0, cop400->b);
state_save_register_device_item(device, 0, cop400->c);
state_save_register_device_item(device, 0, cop400->en);
state_save_register_device_item(device, 0, cop400->g);
state_save_register_device_item(device, 0, cop400->q);
state_save_register_device_item(device, 0, cop400->sa);
state_save_register_device_item(device, 0, cop400->sb);
state_save_register_device_item(device, 0, cop400->sc);
state_save_register_device_item(device, 0, cop400->sio);
state_save_register_device_item(device, 0, cop400->skl);
state_save_register_device_item(device, 0, cop400->skip);
state_save_register_device_item(device, 0, cop400->skip_lbi);
state_save_register_device_item(device, 0, cop400->t);
state_save_register_device_item(device, 0, cop400->skt_latch);
state_save_register_device_item(device, 0, cop400->g_mask);
state_save_register_device_item(device, 0, cop400->d_mask);
state_save_register_device_item(device, 0, cop400->in_mask);
state_save_register_device_item(device, 0, cop400->si);
state_save_register_device_item(device, 0, cop400->last_skip);
state_save_register_device_item_array(device, 0, cop400->in);
state_save_register_device_item(device, 0, cop400->microbus_int);
state_save_register_device_item(device, 0, cop400->halt);
}
static CPU_INIT( cop425 )

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

@ -324,22 +324,22 @@ static STATE_POSTLOAD( cquestsnd_postload )
static void cquestsnd_state_register(const device_config *device, const char *type)
{
state_save_register_item_array(type, device->tag, 0, cquestsnd.ram);
state_save_register_item(type, device->tag, 0, cquestsnd.q);
state_save_register_item(type, device->tag, 0, cquestsnd.f);
state_save_register_item(type, device->tag, 0, cquestsnd.y);
state_save_register_item(type, device->tag, 0, cquestsnd.cflag);
state_save_register_item(type, device->tag, 0, cquestsnd.vflag);
state_save_register_device_item_array(device, 0, cquestsnd.ram);
state_save_register_device_item(device, 0, cquestsnd.q);
state_save_register_device_item(device, 0, cquestsnd.f);
state_save_register_device_item(device, 0, cquestsnd.y);
state_save_register_device_item(device, 0, cquestsnd.cflag);
state_save_register_device_item(device, 0, cquestsnd.vflag);
state_save_register_item(type, device->tag, 0, cquestsnd.pc);
state_save_register_item(type, device->tag, 0, cquestsnd.platch);
state_save_register_item(type, device->tag, 0, cquestsnd.rtnlatch);
state_save_register_item(type, device->tag, 0, cquestsnd.adrcntr);
state_save_register_item(type, device->tag, 0, cquestsnd.adrlatch);
state_save_register_item(type, device->tag, 0, cquestsnd.dinlatch);
state_save_register_item(type, device->tag, 0, cquestsnd.ramwlatch);
state_save_register_item(type, device->tag, 0, cquestsnd.prev_ipram);
state_save_register_item(type, device->tag, 0, cquestsnd.prev_ipwrt);
state_save_register_device_item(device, 0, cquestsnd.pc);
state_save_register_device_item(device, 0, cquestsnd.platch);
state_save_register_device_item(device, 0, cquestsnd.rtnlatch);
state_save_register_device_item(device, 0, cquestsnd.adrcntr);
state_save_register_device_item(device, 0, cquestsnd.adrlatch);
state_save_register_device_item(device, 0, cquestsnd.dinlatch);
state_save_register_device_item(device, 0, cquestsnd.ramwlatch);
state_save_register_device_item(device, 0, cquestsnd.prev_ipram);
state_save_register_device_item(device, 0, cquestsnd.prev_ipwrt);
state_save_register_postload(device->machine, cquestsnd_postload, (void *)device);
}
@ -386,31 +386,31 @@ static STATE_POSTLOAD( cquestrot_postload )
static void cquestrot_state_register(const device_config *device, const char *type)
{
state_save_register_item_array(type, device->tag, 0, cquestrot.ram);
state_save_register_item(type, device->tag, 0, cquestrot.q);
state_save_register_item(type, device->tag, 0, cquestrot.f);
state_save_register_item(type, device->tag, 0, cquestrot.y);
state_save_register_item(type, device->tag, 0, cquestrot.cflag);
state_save_register_item(type, device->tag, 0, cquestrot.vflag);
state_save_register_device_item_array(device, 0, cquestrot.ram);
state_save_register_device_item(device, 0, cquestrot.q);
state_save_register_device_item(device, 0, cquestrot.f);
state_save_register_device_item(device, 0, cquestrot.y);
state_save_register_device_item(device, 0, cquestrot.cflag);
state_save_register_device_item(device, 0, cquestrot.vflag);
state_save_register_item(type, device->tag, 0, cquestrot.pc);
state_save_register_item(type, device->tag, 0, cquestrot.seqcnt);
state_save_register_item(type, device->tag, 0, cquestrot.dsrclatch);
state_save_register_item(type, device->tag, 0, cquestrot.rsrclatch);
state_save_register_item(type, device->tag, 0, cquestrot.dynaddr);
state_save_register_item(type, device->tag, 0, cquestrot.dyndata);
state_save_register_item(type, device->tag, 0, cquestrot.yrlatch);
state_save_register_item(type, device->tag, 0, cquestrot.ydlatch);
state_save_register_item(type, device->tag, 0, cquestrot.dinlatch);
state_save_register_item(type, device->tag, 0, cquestrot.divreg);
state_save_register_item(type, device->tag, 0, cquestrot.linedata);
state_save_register_item(type, device->tag, 0, cquestrot.lineaddr);
state_save_register_item(type, device->tag, 0, cquestrot.prev_dred);
state_save_register_item(type, device->tag, 0, cquestrot.prev_dwrt);
state_save_register_item(type, device->tag, 0, cquestrot.wc);
state_save_register_device_item(device, 0, cquestrot.pc);
state_save_register_device_item(device, 0, cquestrot.seqcnt);
state_save_register_device_item(device, 0, cquestrot.dsrclatch);
state_save_register_device_item(device, 0, cquestrot.rsrclatch);
state_save_register_device_item(device, 0, cquestrot.dynaddr);
state_save_register_device_item(device, 0, cquestrot.dyndata);
state_save_register_device_item(device, 0, cquestrot.yrlatch);
state_save_register_device_item(device, 0, cquestrot.ydlatch);
state_save_register_device_item(device, 0, cquestrot.dinlatch);
state_save_register_device_item(device, 0, cquestrot.divreg);
state_save_register_device_item(device, 0, cquestrot.linedata);
state_save_register_device_item(device, 0, cquestrot.lineaddr);
state_save_register_device_item(device, 0, cquestrot.prev_dred);
state_save_register_device_item(device, 0, cquestrot.prev_dwrt);
state_save_register_device_item(device, 0, cquestrot.wc);
state_save_register_item_pointer(type, device->tag, 0, cquestrot.dram, 16384);
state_save_register_item_pointer(type, device->tag, 0, cquestrot.sram, 2048);
state_save_register_device_item_pointer(device, 0, cquestrot.dram, 16384);
state_save_register_device_item_pointer(device, 0, cquestrot.sram, 2048);
state_save_register_postload(device->machine, cquestrot_postload, (void *)device);
}
@ -461,35 +461,35 @@ static STATE_POSTLOAD( cquestlin_postload )
static void cquestlin_state_register(const device_config *device, const char *type)
{
state_save_register_item_array(type, device->tag, 0, cquestlin.ram);
state_save_register_item(type, device->tag, 0, cquestlin.q);
state_save_register_item(type, device->tag, 0, cquestlin.f);
state_save_register_item(type, device->tag, 0, cquestlin.y);
state_save_register_item(type, device->tag, 0, cquestlin.cflag);
state_save_register_item(type, device->tag, 0, cquestlin.vflag);
state_save_register_device_item_array(device, 0, cquestlin.ram);
state_save_register_device_item(device, 0, cquestlin.q);
state_save_register_device_item(device, 0, cquestlin.f);
state_save_register_device_item(device, 0, cquestlin.y);
state_save_register_device_item(device, 0, cquestlin.cflag);
state_save_register_device_item(device, 0, cquestlin.vflag);
state_save_register_item(type, device->tag, 0, cquestlin.pc[0]);
state_save_register_item(type, device->tag, 0, cquestlin.pc[1]);
state_save_register_item(type, device->tag, 0, cquestlin.seqcnt);
state_save_register_item(type, device->tag, 0, cquestlin.clatch);
state_save_register_item(type, device->tag, 0, cquestlin.zlatch);
state_save_register_item(type, device->tag, 0, cquestlin.xcnt);
state_save_register_item(type, device->tag, 0, cquestlin.ycnt);
state_save_register_item(type, device->tag, 0, cquestlin.sreg);
state_save_register_item(type, device->tag, 0, cquestlin.fadlatch);
state_save_register_item(type, device->tag, 0, cquestlin.badlatch);
state_save_register_item(type, device->tag, 0, cquestlin.sramdlatch);
state_save_register_item(type, device->tag, 0, cquestlin.fglatch);
state_save_register_item(type, device->tag, 0, cquestlin.bglatch);
state_save_register_item(type, device->tag, 0, cquestlin.gt0reg);
state_save_register_item(type, device->tag, 0, cquestlin.fdxreg);
state_save_register_item(type, device->tag, 0, cquestlin.field);
state_save_register_item(type, device->tag, 0, cquestlin.clkcnt);
state_save_register_device_item(device, 0, cquestlin.pc[0]);
state_save_register_device_item(device, 0, cquestlin.pc[1]);
state_save_register_device_item(device, 0, cquestlin.seqcnt);
state_save_register_device_item(device, 0, cquestlin.clatch);
state_save_register_device_item(device, 0, cquestlin.zlatch);
state_save_register_device_item(device, 0, cquestlin.xcnt);
state_save_register_device_item(device, 0, cquestlin.ycnt);
state_save_register_device_item(device, 0, cquestlin.sreg);
state_save_register_device_item(device, 0, cquestlin.fadlatch);
state_save_register_device_item(device, 0, cquestlin.badlatch);
state_save_register_device_item(device, 0, cquestlin.sramdlatch);
state_save_register_device_item(device, 0, cquestlin.fglatch);
state_save_register_device_item(device, 0, cquestlin.bglatch);
state_save_register_device_item(device, 0, cquestlin.gt0reg);
state_save_register_device_item(device, 0, cquestlin.fdxreg);
state_save_register_device_item(device, 0, cquestlin.field);
state_save_register_device_item(device, 0, cquestlin.clkcnt);
state_save_register_item_pointer(type, device->tag, 0, cquestlin.sram, 4096);
state_save_register_item_pointer(type, device->tag, 0, cquestlin.ptr_ram, 1024);
state_save_register_item_pointer(type, device->tag, 0, cquestlin.e_stack, 32768);
state_save_register_item_pointer(type, device->tag, 0, cquestlin.o_stack, 32768);
state_save_register_device_item_pointer(device, 0, cquestlin.sram, 4096);
state_save_register_device_item_pointer(device, 0, cquestlin.ptr_ram, 1024);
state_save_register_device_item_pointer(device, 0, cquestlin.e_stack, 32768);
state_save_register_device_item_pointer(device, 0, cquestlin.o_stack, 32768);
state_save_register_postload(device->machine, cquestlin_postload, (void *)device);
}

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

@ -397,7 +397,7 @@ static CPU_INIT( dsp56k )
core.reset_state = FALSE;
/* Save the core's state */
// state_save_register_item("dsp56k", device->tag, 0, modA_state);
// state_save_register_device_item(device, 0, modA_state);
// ...
//core.config = device->static_config;

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

@ -1529,15 +1529,15 @@ static void hyperstone_init(const device_config *device, int index, int clock, c
{
hyperstone_state *cpustate = device->token;
state_save_register_item_array("E132XS", device->tag, 0, cpustate->global_regs);
state_save_register_item_array("E132XS", device->tag, 0, cpustate->local_regs);
state_save_register_item("E132XS", device->tag, 0, cpustate->ppc);
state_save_register_item("E132XS", device->tag, 0, cpustate->trap_entry);
state_save_register_item("E132XS", device->tag, 0, cpustate->delay.delay_pc);
state_save_register_item("E132XS", device->tag, 0, cpustate->instruction_length);
state_save_register_item("E132XS", device->tag, 0, cpustate->intblock);
state_save_register_item("E132XS", device->tag, 0, cpustate->delay.delay_cmd);
state_save_register_item("E132XS", device->tag, 0, cpustate->tr_clocks_per_tick);
state_save_register_device_item_array(device, 0, cpustate->global_regs);
state_save_register_device_item_array(device, 0, cpustate->local_regs);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->trap_entry);
state_save_register_device_item(device, 0, cpustate->delay.delay_pc);
state_save_register_device_item(device, 0, cpustate->instruction_length);
state_save_register_device_item(device, 0, cpustate->intblock);
state_save_register_device_item(device, 0, cpustate->delay.delay_cmd);
state_save_register_device_item(device, 0, cpustate->tr_clocks_per_tick);
cpustate->irq_callback = irqcallback;
cpustate->device = device;

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

@ -332,30 +332,30 @@ static CPU_INIT( g65816 )
cpustate->device = device;
cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("G65816", device->tag, 0, cpustate->a);
state_save_register_item("G65816", device->tag, 0, cpustate->b);
state_save_register_item("G65816", device->tag, 0, cpustate->x);
state_save_register_item("G65816", device->tag, 0, cpustate->y);
state_save_register_item("G65816", device->tag, 0, cpustate->s);
state_save_register_item("G65816", device->tag, 0, cpustate->pc);
state_save_register_item("G65816", device->tag, 0, cpustate->ppc);
state_save_register_item("G65816", device->tag, 0, cpustate->pb);
state_save_register_item("G65816", device->tag, 0, cpustate->db);
state_save_register_item("G65816", device->tag, 0, cpustate->d);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_e);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_m);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_x);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_n);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_v);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_d);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_i);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_z);
state_save_register_item("G65816", device->tag, 0, cpustate->flag_c);
state_save_register_item("G65816", device->tag, 0, cpustate->line_irq);
state_save_register_item("G65816", device->tag, 0, cpustate->line_nmi);
state_save_register_item("G65816", device->tag, 0, cpustate->ir);
state_save_register_item("G65816", device->tag, 0, cpustate->irq_delay);
state_save_register_item("G65816", device->tag, 0, cpustate->stopped);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->s);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->pb);
state_save_register_device_item(device, 0, cpustate->db);
state_save_register_device_item(device, 0, cpustate->d);
state_save_register_device_item(device, 0, cpustate->flag_e);
state_save_register_device_item(device, 0, cpustate->flag_m);
state_save_register_device_item(device, 0, cpustate->flag_x);
state_save_register_device_item(device, 0, cpustate->flag_n);
state_save_register_device_item(device, 0, cpustate->flag_v);
state_save_register_device_item(device, 0, cpustate->flag_d);
state_save_register_device_item(device, 0, cpustate->flag_i);
state_save_register_device_item(device, 0, cpustate->flag_z);
state_save_register_device_item(device, 0, cpustate->flag_c);
state_save_register_device_item(device, 0, cpustate->line_irq);
state_save_register_device_item(device, 0, cpustate->line_nmi);
state_save_register_device_item(device, 0, cpustate->ir);
state_save_register_device_item(device, 0, cpustate->irq_delay);
state_save_register_device_item(device, 0, cpustate->stopped);
state_save_register_postload(device->machine, g65816_restore_state, cpustate);
}

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

@ -162,32 +162,32 @@ static void set_irq_line(int irqline, int state);
/*****************************************************************************/
static CPU_INIT( h6280 )
{
state_save_register_item("h6280", device->tag, 0, h6280.ppc.w.l);
state_save_register_item("h6280", device->tag, 0, h6280.pc.w.l);
state_save_register_item("h6280", device->tag, 0, h6280.sp.w.l);
state_save_register_item("h6280", device->tag, 0, h6280.zp.w.l);
state_save_register_item("h6280", device->tag, 0, h6280.ea.w.l);
state_save_register_item("h6280", device->tag, 0, h6280.a);
state_save_register_item("h6280", device->tag, 0, h6280.x);
state_save_register_item("h6280", device->tag, 0, h6280.y);
state_save_register_item("h6280", device->tag, 0, h6280.p);
state_save_register_item_array("h6280", device->tag, 0, h6280.mmr);
state_save_register_item("h6280", device->tag, 0, h6280.irq_mask);
state_save_register_item("h6280", device->tag, 0, h6280.timer_status);
state_save_register_item("h6280", device->tag, 0, h6280.timer_ack);
state_save_register_item("h6280", device->tag, 0, h6280.clocks_per_cycle);
state_save_register_item("h6280", device->tag, 0, h6280.timer_value);
state_save_register_item("h6280", device->tag, 0, h6280.timer_load);
state_save_register_item("h6280", device->tag, 0, h6280.nmi_state);
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[0]);
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[1]);
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[2]);
state_save_register_item("h6280", device->tag, 0, h6280.irq_pending);
state_save_register_device_item(device, 0, h6280.ppc.w.l);
state_save_register_device_item(device, 0, h6280.pc.w.l);
state_save_register_device_item(device, 0, h6280.sp.w.l);
state_save_register_device_item(device, 0, h6280.zp.w.l);
state_save_register_device_item(device, 0, h6280.ea.w.l);
state_save_register_device_item(device, 0, h6280.a);
state_save_register_device_item(device, 0, h6280.x);
state_save_register_device_item(device, 0, h6280.y);
state_save_register_device_item(device, 0, h6280.p);
state_save_register_device_item_array(device, 0, h6280.mmr);
state_save_register_device_item(device, 0, h6280.irq_mask);
state_save_register_device_item(device, 0, h6280.timer_status);
state_save_register_device_item(device, 0, h6280.timer_ack);
state_save_register_device_item(device, 0, h6280.clocks_per_cycle);
state_save_register_device_item(device, 0, h6280.timer_value);
state_save_register_device_item(device, 0, h6280.timer_load);
state_save_register_device_item(device, 0, h6280.nmi_state);
state_save_register_device_item(device, 0, h6280.irq_state[0]);
state_save_register_device_item(device, 0, h6280.irq_state[1]);
state_save_register_device_item(device, 0, h6280.irq_state[2]);
state_save_register_device_item(device, 0, h6280.irq_pending);
#if LAZY_FLAGS
state_save_register_item("h6280", device->tag, 0, h6280.NZ);
state_save_register_device_item(device, 0, h6280.NZ);
#endif
state_save_register_item("h6280", device->tag, 0, h6280.io_buffer);
state_save_register_device_item(device, 0, h6280.io_buffer);
h6280.irq_callback = irqcallback;
h6280.device = device;

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

@ -215,18 +215,18 @@ static CPU_INIT(h8)
h8->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
h8->io = cpu_get_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("H8/3002", device->tag, 0, h8->h8err);
state_save_register_item_array("H8/3002", device->tag, 0, h8->regs);
state_save_register_item("H8/3002", device->tag, 0, h8->pc);
state_save_register_item("H8/3002", device->tag, 0, h8->ppc);
state_save_register_item("H8/3002", device->tag, 0, h8->h8_IRQrequestH);
state_save_register_item("H8/3002", device->tag, 0, h8->h8_IRQrequestL);
state_save_register_item("H8/3002", device->tag, 0, h8->ccr);
state_save_register_item("H8/3002", device->tag, 0, h8->mode_8bit);
state_save_register_device_item(device, 0, h8->h8err);
state_save_register_device_item_array(device, 0, h8->regs);
state_save_register_device_item(device, 0, h8->pc);
state_save_register_device_item(device, 0, h8->ppc);
state_save_register_device_item(device, 0, h8->h8_IRQrequestH);
state_save_register_device_item(device, 0, h8->h8_IRQrequestL);
state_save_register_device_item(device, 0, h8->ccr);
state_save_register_device_item(device, 0, h8->mode_8bit);
state_save_register_item_array("H8/3002", device->tag, 0, h8->per_regs);
state_save_register_item("H8/3002", device->tag, 0, h8->h8TSTR);
state_save_register_item_array("H8/3002", device->tag, 0, h8->h8TCNT);
state_save_register_device_item_array(device, 0, h8->per_regs);
state_save_register_device_item(device, 0, h8->h8TSTR);
state_save_register_device_item_array(device, 0, h8->h8TCNT);
state_save_register_postload(device->machine, h8_onstateload, h8);

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

@ -225,18 +225,18 @@ static CPU_INIT(h8bit)
h8->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
h8->io = cpu_get_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("H8/300", device->tag, 0, h8->h8err);
state_save_register_item_array("H8/300", device->tag, 0, h8->regs);
state_save_register_item("H8/300", device->tag, 0, h8->pc);
state_save_register_item("H8/300", device->tag, 0, h8->ppc);
state_save_register_item("H8/300", device->tag, 0, h8->h8_IRQrequestH);
state_save_register_item("H8/300", device->tag, 0, h8->h8_IRQrequestL);
state_save_register_item("H8/300", device->tag, 0, h8->ccr);
state_save_register_item("H8/300", device->tag, 0, h8->mode_8bit);
state_save_register_device_item(device, 0, h8->h8err);
state_save_register_device_item_array(device, 0, h8->regs);
state_save_register_device_item(device, 0, h8->pc);
state_save_register_device_item(device, 0, h8->ppc);
state_save_register_device_item(device, 0, h8->h8_IRQrequestH);
state_save_register_device_item(device, 0, h8->h8_IRQrequestL);
state_save_register_device_item(device, 0, h8->ccr);
state_save_register_device_item(device, 0, h8->mode_8bit);
state_save_register_item_array("H8/300", device->tag, 0, h8->per_regs);
state_save_register_item("H8/300", device->tag, 0, h8->h8TSTR);
state_save_register_item_array("H8/300", device->tag, 0, h8->h8TCNT);
state_save_register_device_item_array(device, 0, h8->per_regs);
state_save_register_device_item(device, 0, h8->h8TSTR);
state_save_register_device_item_array(device, 0, h8->h8TCNT);
state_save_register_postload(h8->device->machine, h8_onstateload, h8);
}

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

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

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

@ -527,59 +527,59 @@ static CPU_INIT( i386 )
I.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
I.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item_array(state_type, device->tag, 0, I.reg.d);
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].flags);
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].flags);
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].flags);
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].flags);
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].flags);
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].selector);
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].base);
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].limit);
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].flags);
state_save_register_item(state_type, device->tag, 0, I.eip);
state_save_register_item(state_type, device->tag, 0, I.prev_eip);
state_save_register_item(state_type, device->tag, 0, I.CF);
state_save_register_item(state_type, device->tag, 0, I.DF);
state_save_register_item(state_type, device->tag, 0, I.SF);
state_save_register_item(state_type, device->tag, 0, I.OF);
state_save_register_item(state_type, device->tag, 0, I.ZF);
state_save_register_item(state_type, device->tag, 0, I.PF);
state_save_register_item(state_type, device->tag, 0, I.AF);
state_save_register_item(state_type, device->tag, 0, I.IF);
state_save_register_item(state_type, device->tag, 0, I.TF);
state_save_register_item_array(state_type, device->tag, 0, I.cr);
state_save_register_item_array(state_type, device->tag, 0, I.dr);
state_save_register_item_array(state_type, device->tag, 0, I.tr);
state_save_register_item(state_type, device->tag, 0, I.idtr.base);
state_save_register_item(state_type, device->tag, 0, I.idtr.limit);
state_save_register_item(state_type, device->tag, 0, I.gdtr.base);
state_save_register_item(state_type, device->tag, 0, I.gdtr.limit);
state_save_register_item(state_type, device->tag, 0, I.task.base);
state_save_register_item(state_type, device->tag, 0, I.task.segment);
state_save_register_item(state_type, device->tag, 0, I.task.limit);
state_save_register_item(state_type, device->tag, 0, I.task.flags);
state_save_register_item(state_type, device->tag, 0, I.ldtr.base);
state_save_register_item(state_type, device->tag, 0, I.ldtr.segment);
state_save_register_item(state_type, device->tag, 0, I.ldtr.limit);
state_save_register_item(state_type, device->tag, 0, I.ldtr.flags);
state_save_register_item(state_type, device->tag, 0, I.irq_state);
state_save_register_item(state_type, device->tag, 0, I.performed_intersegment_jump);
state_save_register_device_item_array(device, 0, I.reg.d);
state_save_register_device_item(device, 0, I.sreg[ES].selector);
state_save_register_device_item(device, 0, I.sreg[ES].base);
state_save_register_device_item(device, 0, I.sreg[ES].limit);
state_save_register_device_item(device, 0, I.sreg[ES].flags);
state_save_register_device_item(device, 0, I.sreg[CS].selector);
state_save_register_device_item(device, 0, I.sreg[CS].base);
state_save_register_device_item(device, 0, I.sreg[CS].limit);
state_save_register_device_item(device, 0, I.sreg[CS].flags);
state_save_register_device_item(device, 0, I.sreg[SS].selector);
state_save_register_device_item(device, 0, I.sreg[SS].base);
state_save_register_device_item(device, 0, I.sreg[SS].limit);
state_save_register_device_item(device, 0, I.sreg[SS].flags);
state_save_register_device_item(device, 0, I.sreg[DS].selector);
state_save_register_device_item(device, 0, I.sreg[DS].base);
state_save_register_device_item(device, 0, I.sreg[DS].limit);
state_save_register_device_item(device, 0, I.sreg[DS].flags);
state_save_register_device_item(device, 0, I.sreg[FS].selector);
state_save_register_device_item(device, 0, I.sreg[FS].base);
state_save_register_device_item(device, 0, I.sreg[FS].limit);
state_save_register_device_item(device, 0, I.sreg[FS].flags);
state_save_register_device_item(device, 0, I.sreg[GS].selector);
state_save_register_device_item(device, 0, I.sreg[GS].base);
state_save_register_device_item(device, 0, I.sreg[GS].limit);
state_save_register_device_item(device, 0, I.sreg[GS].flags);
state_save_register_device_item(device, 0, I.eip);
state_save_register_device_item(device, 0, I.prev_eip);
state_save_register_device_item(device, 0, I.CF);
state_save_register_device_item(device, 0, I.DF);
state_save_register_device_item(device, 0, I.SF);
state_save_register_device_item(device, 0, I.OF);
state_save_register_device_item(device, 0, I.ZF);
state_save_register_device_item(device, 0, I.PF);
state_save_register_device_item(device, 0, I.AF);
state_save_register_device_item(device, 0, I.IF);
state_save_register_device_item(device, 0, I.TF);
state_save_register_device_item_array(device, 0, I.cr);
state_save_register_device_item_array(device, 0, I.dr);
state_save_register_device_item_array(device, 0, I.tr);
state_save_register_device_item(device, 0, I.idtr.base);
state_save_register_device_item(device, 0, I.idtr.limit);
state_save_register_device_item(device, 0, I.gdtr.base);
state_save_register_device_item(device, 0, I.gdtr.limit);
state_save_register_device_item(device, 0, I.task.base);
state_save_register_device_item(device, 0, I.task.segment);
state_save_register_device_item(device, 0, I.task.limit);
state_save_register_device_item(device, 0, I.task.flags);
state_save_register_device_item(device, 0, I.ldtr.base);
state_save_register_device_item(device, 0, I.ldtr.segment);
state_save_register_device_item(device, 0, I.ldtr.limit);
state_save_register_device_item(device, 0, I.ldtr.flags);
state_save_register_device_item(device, 0, I.irq_state);
state_save_register_device_item(device, 0, I.performed_intersegment_jump);
state_save_register_postload(device->machine, i386_postload, NULL);
}

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

@ -1365,21 +1365,21 @@ static CPU_INIT( i8085 )
I.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
I.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("i8085", device->tag, 0, I.AF.w.l);
state_save_register_item("i8085", device->tag, 0, I.BC.w.l);
state_save_register_item("i8085", device->tag, 0, I.DE.w.l);
state_save_register_item("i8085", device->tag, 0, I.HL.w.l);
state_save_register_item("i8085", device->tag, 0, I.SP.w.l);
state_save_register_item("i8085", device->tag, 0, I.PC.w.l);
state_save_register_item("i8085", device->tag, 0, I.HALT);
state_save_register_item("i8085", device->tag, 0, I.IM);
state_save_register_item("i8085", device->tag, 0, I.IREQ);
state_save_register_item("i8085", device->tag, 0, I.ISRV);
state_save_register_item("i8085", device->tag, 0, I.INTR);
state_save_register_item("i8085", device->tag, 0, I.IRQ2);
state_save_register_item("i8085", device->tag, 0, I.IRQ1);
state_save_register_item("i8085", device->tag, 0, I.STATUS);
state_save_register_item_array("i8085", device->tag, 0, I.irq_state);
state_save_register_device_item(device, 0, I.AF.w.l);
state_save_register_device_item(device, 0, I.BC.w.l);
state_save_register_device_item(device, 0, I.DE.w.l);
state_save_register_device_item(device, 0, I.HL.w.l);
state_save_register_device_item(device, 0, I.SP.w.l);
state_save_register_device_item(device, 0, I.PC.w.l);
state_save_register_device_item(device, 0, I.HALT);
state_save_register_device_item(device, 0, I.IM);
state_save_register_device_item(device, 0, I.IREQ);
state_save_register_device_item(device, 0, I.ISRV);
state_save_register_device_item(device, 0, I.INTR);
state_save_register_device_item(device, 0, I.IRQ2);
state_save_register_device_item(device, 0, I.IRQ1);
state_save_register_device_item(device, 0, I.STATUS);
state_save_register_device_item_array(device, 0, I.irq_state);
}
/****************************************************************************
@ -1602,21 +1602,21 @@ static CPU_INIT( i8080 )
I.irq_callback = irqcallback;
I.device = device;
state_save_register_item("i8080", device->tag, 0, I.AF.w.l);
state_save_register_item("i8080", device->tag, 0, I.BC.w.l);
state_save_register_item("i8080", device->tag, 0, I.DE.w.l);
state_save_register_item("i8080", device->tag, 0, I.HL.w.l);
state_save_register_item("i8080", device->tag, 0, I.SP.w.l);
state_save_register_item("i8080", device->tag, 0, I.PC.w.l);
state_save_register_item("i8080", device->tag, 0, I.HALT);
state_save_register_item("i8085", device->tag, 0, I.IM);
state_save_register_item("i8080", device->tag, 0, I.IREQ);
state_save_register_item("i8080", device->tag, 0, I.ISRV);
state_save_register_item("i8080", device->tag, 0, I.INTR);
state_save_register_item("i8080", device->tag, 0, I.IRQ2);
state_save_register_item("i8080", device->tag, 0, I.IRQ1);
state_save_register_item("i8080", device->tag, 0, I.STATUS);
state_save_register_item_array("i8080", device->tag, 0, I.irq_state);
state_save_register_device_item(device, 0, I.AF.w.l);
state_save_register_device_item(device, 0, I.BC.w.l);
state_save_register_device_item(device, 0, I.DE.w.l);
state_save_register_device_item(device, 0, I.HL.w.l);
state_save_register_device_item(device, 0, I.SP.w.l);
state_save_register_device_item(device, 0, I.PC.w.l);
state_save_register_device_item(device, 0, I.HALT);
state_save_register_device_item(device, 0, I.IM);
state_save_register_device_item(device, 0, I.IREQ);
state_save_register_device_item(device, 0, I.ISRV);
state_save_register_device_item(device, 0, I.INTR);
state_save_register_device_item(device, 0, I.IRQ2);
state_save_register_device_item(device, 0, I.IRQ1);
state_save_register_device_item(device, 0, I.STATUS);
state_save_register_device_item_array(device, 0, I.irq_state);
}
static void i8080_set_irq_line(int irqline, int state)

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

@ -253,40 +253,40 @@ static CPU_DISASSEMBLE( i80286 )
static CPU_INIT( i80286 )
{
static const char type[] = "80286";
state_save_register_item_array(type, device->tag, 0, I.regs.w);
state_save_register_item(type, device->tag, 0, I.amask);
state_save_register_item(type, device->tag, 0, I.pc);
state_save_register_item(type, device->tag, 0, I.prevpc);
state_save_register_item(type, device->tag, 0, I.msw);
state_save_register_item_array(type, device->tag, 0, I.base);
state_save_register_item_array(type, device->tag, 0, I.sregs);
state_save_register_item_array(type, device->tag, 0, I.limit);
state_save_register_item_array(type, device->tag, 0, I.rights);
state_save_register_item(type, device->tag, 0, I.gdtr.base);
state_save_register_item(type, device->tag, 0, I.gdtr.limit);
state_save_register_item(type, device->tag, 0, I.idtr.base);
state_save_register_item(type, device->tag, 0, I.idtr.limit);
state_save_register_item(type, device->tag, 0, I.ldtr.sel);
state_save_register_item(type, device->tag, 0, I.ldtr.base);
state_save_register_item(type, device->tag, 0, I.ldtr.limit);
state_save_register_item(type, device->tag, 0, I.ldtr.rights);
state_save_register_item(type, device->tag, 0, I.tr.sel);
state_save_register_item(type, device->tag, 0, I.tr.base);
state_save_register_item(type, device->tag, 0, I.tr.limit);
state_save_register_item(type, device->tag, 0, I.tr.rights);
state_save_register_item(type, device->tag, 0, I.AuxVal);
state_save_register_item(type, device->tag, 0, I.OverVal);
state_save_register_item(type, device->tag, 0, I.SignVal);
state_save_register_item(type, device->tag, 0, I.ZeroVal);
state_save_register_item(type, device->tag, 0, I.CarryVal);
state_save_register_item(type, device->tag, 0, I.DirVal);
state_save_register_item(type, device->tag, 0, I.ParityVal);
state_save_register_item(type, device->tag, 0, I.TF);
state_save_register_item(type, device->tag, 0, I.IF);
state_save_register_item(type, device->tag, 0, I.int_vector);
state_save_register_item(type, device->tag, 0, I.nmi_state);
state_save_register_item(type, device->tag, 0, I.irq_state);
state_save_register_item(type, device->tag, 0, I.extra_cycles);
state_save_register_device_item_array(device, 0, I.regs.w);
state_save_register_device_item(device, 0, I.amask);
state_save_register_device_item(device, 0, I.pc);
state_save_register_device_item(device, 0, I.prevpc);
state_save_register_device_item(device, 0, I.msw);
state_save_register_device_item_array(device, 0, I.base);
state_save_register_device_item_array(device, 0, I.sregs);
state_save_register_device_item_array(device, 0, I.limit);
state_save_register_device_item_array(device, 0, I.rights);
state_save_register_device_item(device, 0, I.gdtr.base);
state_save_register_device_item(device, 0, I.gdtr.limit);
state_save_register_device_item(device, 0, I.idtr.base);
state_save_register_device_item(device, 0, I.idtr.limit);
state_save_register_device_item(device, 0, I.ldtr.sel);
state_save_register_device_item(device, 0, I.ldtr.base);
state_save_register_device_item(device, 0, I.ldtr.limit);
state_save_register_device_item(device, 0, I.ldtr.rights);
state_save_register_device_item(device, 0, I.tr.sel);
state_save_register_device_item(device, 0, I.tr.base);
state_save_register_device_item(device, 0, I.tr.limit);
state_save_register_device_item(device, 0, I.tr.rights);
state_save_register_device_item(device, 0, I.AuxVal);
state_save_register_device_item(device, 0, I.OverVal);
state_save_register_device_item(device, 0, I.SignVal);
state_save_register_device_item(device, 0, I.ZeroVal);
state_save_register_device_item(device, 0, I.CarryVal);
state_save_register_device_item(device, 0, I.DirVal);
state_save_register_device_item(device, 0, I.ParityVal);
state_save_register_device_item(device, 0, I.TF);
state_save_register_device_item(device, 0, I.IF);
state_save_register_device_item(device, 0, I.int_vector);
state_save_register_device_item(device, 0, I.nmi_state);
state_save_register_device_item(device, 0, I.irq_state);
state_save_register_device_item(device, 0, I.extra_cycles);
I.irq_callback = irqcallback;
I.device = device;

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

@ -95,27 +95,27 @@ static struct i80x86_timing timing;
static void i8086_state_register(const device_config *device)
{
static const char type[] = "I8086";
state_save_register_item_array(type, device->tag, 0, I.regs.w);
state_save_register_item(type, device->tag, 0, I.pc);
state_save_register_item(type, device->tag, 0, I.prevpc);
state_save_register_item_array(type, device->tag, 0, I.base);
state_save_register_item_array(type, device->tag, 0, I.sregs);
state_save_register_item(type, device->tag, 0, I.flags);
state_save_register_item(type, device->tag, 0, I.AuxVal);
state_save_register_item(type, device->tag, 0, I.OverVal);
state_save_register_item(type, device->tag, 0, I.SignVal);
state_save_register_item(type, device->tag, 0, I.ZeroVal);
state_save_register_item(type, device->tag, 0, I.CarryVal);
state_save_register_item(type, device->tag, 0, I.DirVal);
state_save_register_item(type, device->tag, 0, I.ParityVal);
state_save_register_item(type, device->tag, 0, I.TF);
state_save_register_item(type, device->tag, 0, I.IF);
state_save_register_item(type, device->tag, 0, I.MF);
state_save_register_item(type, device->tag, 0, I.int_vector);
state_save_register_item(type, device->tag, 0, I.nmi_state);
state_save_register_item(type, device->tag, 0, I.irq_state);
state_save_register_item(type, device->tag, 0, I.extra_cycles);
state_save_register_item(type, device->tag, 0, I.test_state); /* PJB 03/05 */
state_save_register_device_item_array(device, 0, I.regs.w);
state_save_register_device_item(device, 0, I.pc);
state_save_register_device_item(device, 0, I.prevpc);
state_save_register_device_item_array(device, 0, I.base);
state_save_register_device_item_array(device, 0, I.sregs);
state_save_register_device_item(device, 0, I.flags);
state_save_register_device_item(device, 0, I.AuxVal);
state_save_register_device_item(device, 0, I.OverVal);
state_save_register_device_item(device, 0, I.SignVal);
state_save_register_device_item(device, 0, I.ZeroVal);
state_save_register_device_item(device, 0, I.CarryVal);
state_save_register_device_item(device, 0, I.DirVal);
state_save_register_device_item(device, 0, I.ParityVal);
state_save_register_device_item(device, 0, I.TF);
state_save_register_device_item(device, 0, I.IF);
state_save_register_device_item(device, 0, I.MF);
state_save_register_device_item(device, 0, I.int_vector);
state_save_register_device_item(device, 0, I.nmi_state);
state_save_register_device_item(device, 0, I.irq_state);
state_save_register_device_item(device, 0, I.extra_cycles);
state_save_register_device_item(device, 0, I.test_state); /* PJB 03/05 */
}
static CPU_INIT( i8086 )

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

@ -848,21 +848,21 @@ static CPU_INIT( i8x41 )
upi41_state->subtype = 8041;
upi41_state->ram_mask = I8X41_intRAM_MASK;
state_save_register_item("i8x41", device->tag, 0, upi41_state->ppc);
state_save_register_item("i8x41", device->tag, 0, upi41_state->pc);
state_save_register_item("i8x41", device->tag, 0, upi41_state->timer);
state_save_register_item("i8x41", device->tag, 0, upi41_state->prescaler);
state_save_register_item("i8x41", device->tag, 0, upi41_state->subtype);
state_save_register_item("i8x41", device->tag, 0, upi41_state->a);
state_save_register_item("i8x41", device->tag, 0, upi41_state->psw);
state_save_register_item("i8x41", device->tag, 0, upi41_state->state);
state_save_register_item("i8x41", device->tag, 0, upi41_state->enable);
state_save_register_item("i8x41", device->tag, 0, upi41_state->control);
state_save_register_item("i8x41", device->tag, 0, upi41_state->dbbi);
state_save_register_item("i8x41", device->tag, 0, upi41_state->dbbo);
state_save_register_item("i8x41", device->tag, 0, upi41_state->p1);
state_save_register_item("i8x41", device->tag, 0, upi41_state->p2);
state_save_register_item("i8x41", device->tag, 0, upi41_state->p2_hs);
state_save_register_device_item(device, 0, upi41_state->ppc);
state_save_register_device_item(device, 0, upi41_state->pc);
state_save_register_device_item(device, 0, upi41_state->timer);
state_save_register_device_item(device, 0, upi41_state->prescaler);
state_save_register_device_item(device, 0, upi41_state->subtype);
state_save_register_device_item(device, 0, upi41_state->a);
state_save_register_device_item(device, 0, upi41_state->psw);
state_save_register_device_item(device, 0, upi41_state->state);
state_save_register_device_item(device, 0, upi41_state->enable);
state_save_register_device_item(device, 0, upi41_state->control);
state_save_register_device_item(device, 0, upi41_state->dbbi);
state_save_register_device_item(device, 0, upi41_state->dbbo);
state_save_register_device_item(device, 0, upi41_state->p1);
state_save_register_device_item(device, 0, upi41_state->p2);
state_save_register_device_item(device, 0, upi41_state->p2_hs);
}
static CPU_INIT( i8042 )

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

@ -2060,16 +2060,16 @@ static CPU_INIT( i960 )
i960->device = device;
i960->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("i960", device->tag, 0, i960->PIP);
state_save_register_item("i960", device->tag, 0, i960->SAT);
state_save_register_item("i960", device->tag, 0, i960->PRCB);
state_save_register_item("i960", device->tag, 0, i960->PC);
state_save_register_item("i960", device->tag, 0, i960->AC);
state_save_register_item("i960", device->tag, 0, i960->ICR);
state_save_register_item_array("i960", device->tag, 0, i960->r);
state_save_register_item_array("i960", device->tag, 0, i960->fp);
state_save_register_item_2d_array("i960", device->tag, 0, i960->rcache);
state_save_register_item_array("i960", device->tag, 0, i960->rcache_frame_addr);
state_save_register_device_item(device, 0, i960->PIP);
state_save_register_device_item(device, 0, i960->SAT);
state_save_register_device_item(device, 0, i960->PRCB);
state_save_register_device_item(device, 0, i960->PC);
state_save_register_device_item(device, 0, i960->AC);
state_save_register_device_item(device, 0, i960->ICR);
state_save_register_device_item_array(device, 0, i960->r);
state_save_register_device_item_array(device, 0, i960->fp);
state_save_register_device_item_2d_array(device, 0, i960->rcache);
state_save_register_device_item_array(device, 0, i960->rcache_frame_addr);
}
static CPU_DISASSEMBLE( i960 )

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

@ -422,10 +422,10 @@ static void init_common(int isdsp, const device_config *device, cpu_irq_callback
if (configdata != NULL)
jaguar->cpu_interrupt = configdata->cpu_int_callback;
state_save_register_item_array("jaguar", device->tag, 0, jaguar->r);
state_save_register_item_array("jaguar", device->tag, 0, jaguar->a);
state_save_register_item_array("jaguar", device->tag, 0, jaguar->ctrl);
state_save_register_item("jaguar", device->tag, 0, jaguar->ppc);
state_save_register_device_item_array(device, 0, jaguar->r);
state_save_register_device_item_array(device, 0, jaguar->a);
state_save_register_device_item_array(device, 0, jaguar->ctrl);
state_save_register_device_item(device, 0, jaguar->ppc);
state_save_register_postload(device->machine, jaguar_postload, (void *)device);
}

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

@ -390,18 +390,18 @@ static CPU_INIT( konami )
konami.device = device;
konami.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("KONAMI", device->tag, 0, PC);
state_save_register_item("KONAMI", device->tag, 0, U);
state_save_register_item("KONAMI", device->tag, 0, S);
state_save_register_item("KONAMI", device->tag, 0, X);
state_save_register_item("KONAMI", device->tag, 0, Y);
state_save_register_item("KONAMI", device->tag, 0, D);
state_save_register_item("KONAMI", device->tag, 0, DP);
state_save_register_item("KONAMI", device->tag, 0, CC);
state_save_register_item("KONAMI", device->tag, 0, konami.int_state);
state_save_register_item("KONAMI", device->tag, 0, konami.nmi_state);
state_save_register_item("KONAMI", device->tag, 0, konami.irq_state[0]);
state_save_register_item("KONAMI", device->tag, 0, konami.irq_state[1]);
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, U);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, Y);
state_save_register_device_item(device, 0, D);
state_save_register_device_item(device, 0, DP);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item(device, 0, konami.int_state);
state_save_register_device_item(device, 0, konami.nmi_state);
state_save_register_device_item(device, 0, konami.irq_state[0]);
state_save_register_device_item(device, 0, konami.irq_state[1]);
}
static CPU_RESET( konami )

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

@ -961,54 +961,54 @@ static CPU_INIT( m37710 )
for (i = 0; i < 8; i++)
cpustate->timers[i] = timer_alloc(device->machine, m37710_timer_cb, cpustate);
state_save_register_item("M377xx", device->tag, 0, cpustate->a);
state_save_register_item("M377xx", device->tag, 0, cpustate->b);
state_save_register_item("M377xx", device->tag, 0, cpustate->ba);
state_save_register_item("M377xx", device->tag, 0, cpustate->bb);
state_save_register_item("M377xx", device->tag, 0, cpustate->x);
state_save_register_item("M377xx", device->tag, 0, cpustate->y);
state_save_register_item("M377xx", device->tag, 0, cpustate->s);
state_save_register_item("M377xx", device->tag, 0, cpustate->pc);
state_save_register_item("M377xx", device->tag, 0, cpustate->ppc);
state_save_register_item("M377xx", device->tag, 0, cpustate->pb);
state_save_register_item("M377xx", device->tag, 0, cpustate->db);
state_save_register_item("M377xx", device->tag, 0, cpustate->d);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_e);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_m);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_x);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_n);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_v);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_d);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_i);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_z);
state_save_register_item("M377xx", device->tag, 0, cpustate->flag_c);
state_save_register_item("M377xx", device->tag, 0, cpustate->line_irq);
state_save_register_item("M377xx", device->tag, 0, cpustate->ipl);
state_save_register_item("M377xx", device->tag, 0, cpustate->ir);
state_save_register_item("M377xx", device->tag, 0, cpustate->im);
state_save_register_item("M377xx", device->tag, 0, cpustate->im2);
state_save_register_item("M377xx", device->tag, 0, cpustate->im3);
state_save_register_item("M377xx", device->tag, 0, cpustate->im4);
state_save_register_item("M377xx", device->tag, 0, cpustate->irq_delay);
state_save_register_item("M377xx", device->tag, 0, cpustate->irq_level);
state_save_register_item("M377xx", device->tag, 0, cpustate->stopped);
state_save_register_item_array("M377xx", device->tag, 0, cpustate->m37710_regs);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[0].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[0].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[1].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[1].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[2].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[2].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[3].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[3].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[4].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[4].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[5].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[5].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[6].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[6].attoseconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[7].seconds);
state_save_register_item("M377xx", device->tag, 0, cpustate->reload[7].attoseconds);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->b);
state_save_register_device_item(device, 0, cpustate->ba);
state_save_register_device_item(device, 0, cpustate->bb);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->s);
state_save_register_device_item(device, 0, cpustate->pc);
state_save_register_device_item(device, 0, cpustate->ppc);
state_save_register_device_item(device, 0, cpustate->pb);
state_save_register_device_item(device, 0, cpustate->db);
state_save_register_device_item(device, 0, cpustate->d);
state_save_register_device_item(device, 0, cpustate->flag_e);
state_save_register_device_item(device, 0, cpustate->flag_m);
state_save_register_device_item(device, 0, cpustate->flag_x);
state_save_register_device_item(device, 0, cpustate->flag_n);
state_save_register_device_item(device, 0, cpustate->flag_v);
state_save_register_device_item(device, 0, cpustate->flag_d);
state_save_register_device_item(device, 0, cpustate->flag_i);
state_save_register_device_item(device, 0, cpustate->flag_z);
state_save_register_device_item(device, 0, cpustate->flag_c);
state_save_register_device_item(device, 0, cpustate->line_irq);
state_save_register_device_item(device, 0, cpustate->ipl);
state_save_register_device_item(device, 0, cpustate->ir);
state_save_register_device_item(device, 0, cpustate->im);
state_save_register_device_item(device, 0, cpustate->im2);
state_save_register_device_item(device, 0, cpustate->im3);
state_save_register_device_item(device, 0, cpustate->im4);
state_save_register_device_item(device, 0, cpustate->irq_delay);
state_save_register_device_item(device, 0, cpustate->irq_level);
state_save_register_device_item(device, 0, cpustate->stopped);
state_save_register_device_item_array(device, 0, cpustate->m37710_regs);
state_save_register_device_item(device, 0, cpustate->reload[0].seconds);
state_save_register_device_item(device, 0, cpustate->reload[0].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[1].seconds);
state_save_register_device_item(device, 0, cpustate->reload[1].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[2].seconds);
state_save_register_device_item(device, 0, cpustate->reload[2].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[3].seconds);
state_save_register_device_item(device, 0, cpustate->reload[3].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[4].seconds);
state_save_register_device_item(device, 0, cpustate->reload[4].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[5].seconds);
state_save_register_device_item(device, 0, cpustate->reload[5].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[6].seconds);
state_save_register_device_item(device, 0, cpustate->reload[6].attoseconds);
state_save_register_device_item(device, 0, cpustate->reload[7].seconds);
state_save_register_device_item(device, 0, cpustate->reload[7].attoseconds);
state_save_register_postload(device->machine, m37710_restore_state, cpustate);
}

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

@ -147,23 +147,23 @@ static void m6502_common_init(const device_config *device, int index, int clock,
cpustate->rdmem_id = default_rdmem_id;
cpustate->wrmem_id = default_wdmem_id;
state_save_register_item(type, device->tag, 0, cpustate->pc.w.l);
state_save_register_item(type, device->tag, 0, cpustate->sp.w.l);
state_save_register_item(type, device->tag, 0, cpustate->p);
state_save_register_item(type, device->tag, 0, cpustate->a);
state_save_register_item(type, device->tag, 0, cpustate->x);
state_save_register_item(type, device->tag, 0, cpustate->y);
state_save_register_item(type, device->tag, 0, cpustate->pending_irq);
state_save_register_item(type, device->tag, 0, cpustate->after_cli);
state_save_register_item(type, device->tag, 0, cpustate->nmi_state);
state_save_register_item(type, device->tag, 0, cpustate->irq_state);
state_save_register_item(type, device->tag, 0, cpustate->so_state);
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->p);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->pending_irq);
state_save_register_device_item(device, 0, cpustate->after_cli);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->so_state);
#if (HAS_M6510) || (HAS_M6510T) || (HAS_M8502) || (HAS_M7501)
if (subtype == SUBTYPE_6510)
{
state_save_register_item(type, device->tag, 0, cpustate->port);
state_save_register_item(type, device->tag, 0, cpustate->ddr);
state_save_register_device_item(device, 0, cpustate->port);
state_save_register_device_item(device, 0, cpustate->ddr);
}
#endif
}

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

@ -839,47 +839,47 @@ static TIMER_CALLBACK(m6800_rx_tick)
****************************************************************************/
static void state_register(m68_state_t *m68_state, const char *type)
{
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ppc.w.l);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->pc.w.l);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->s.w.l);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->x.w.l);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->d.w.l);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->cc);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->wai_state);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->nmi_state);
state_save_register_item_array(type, m68_state->device->tag, 0, m68_state->irq_state);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ic_eddge);
state_save_register_device_item(m68_state->device, 0, m68_state->ppc.w.l);
state_save_register_device_item(m68_state->device, 0, m68_state->pc.w.l);
state_save_register_device_item(m68_state->device, 0, m68_state->s.w.l);
state_save_register_device_item(m68_state->device, 0, m68_state->x.w.l);
state_save_register_device_item(m68_state->device, 0, m68_state->d.w.l);
state_save_register_device_item(m68_state->device, 0, m68_state->cc);
state_save_register_device_item(m68_state->device, 0, m68_state->wai_state);
state_save_register_device_item(m68_state->device, 0, m68_state->nmi_state);
state_save_register_device_item_array(m68_state->device, 0, m68_state->irq_state);
state_save_register_device_item(m68_state->device, 0, m68_state->ic_eddge);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port1_ddr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port2_ddr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port3_ddr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port4_ddr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port1_data);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port2_data);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port3_data);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port4_data);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tcsr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->pending_tcsr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->irq2);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ram_ctrl);
state_save_register_device_item(m68_state->device, 0, m68_state->port1_ddr);
state_save_register_device_item(m68_state->device, 0, m68_state->port2_ddr);
state_save_register_device_item(m68_state->device, 0, m68_state->port3_ddr);
state_save_register_device_item(m68_state->device, 0, m68_state->port4_ddr);
state_save_register_device_item(m68_state->device, 0, m68_state->port1_data);
state_save_register_device_item(m68_state->device, 0, m68_state->port2_data);
state_save_register_device_item(m68_state->device, 0, m68_state->port3_data);
state_save_register_device_item(m68_state->device, 0, m68_state->port4_data);
state_save_register_device_item(m68_state->device, 0, m68_state->tcsr);
state_save_register_device_item(m68_state->device, 0, m68_state->pending_tcsr);
state_save_register_device_item(m68_state->device, 0, m68_state->irq2);
state_save_register_device_item(m68_state->device, 0, m68_state->ram_ctrl);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->counter.d);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->output_compare.d);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->input_capture);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->timer_over.d);
state_save_register_device_item(m68_state->device, 0, m68_state->counter.d);
state_save_register_device_item(m68_state->device, 0, m68_state->output_compare.d);
state_save_register_device_item(m68_state->device, 0, m68_state->input_capture);
state_save_register_device_item(m68_state->device, 0, m68_state->timer_over.d);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->clock);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->trcsr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rmcr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rdr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tdr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rsr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tsr);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rxbits);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->txbits);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->txstate);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->trcsr_read);
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tx);
state_save_register_device_item(m68_state->device, 0, m68_state->clock);
state_save_register_device_item(m68_state->device, 0, m68_state->trcsr);
state_save_register_device_item(m68_state->device, 0, m68_state->rmcr);
state_save_register_device_item(m68_state->device, 0, m68_state->rdr);
state_save_register_device_item(m68_state->device, 0, m68_state->tdr);
state_save_register_device_item(m68_state->device, 0, m68_state->rsr);
state_save_register_device_item(m68_state->device, 0, m68_state->tsr);
state_save_register_device_item(m68_state->device, 0, m68_state->rxbits);
state_save_register_device_item(m68_state->device, 0, m68_state->txbits);
state_save_register_device_item(m68_state->device, 0, m68_state->txstate);
state_save_register_device_item(m68_state->device, 0, m68_state->trcsr_read);
state_save_register_device_item(m68_state->device, 0, m68_state->tx);
}
static CPU_INIT( m6800 )

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

@ -515,23 +515,23 @@ static CPU_INIT( m68k )
}
/* Note, D covers A because the dar array is common, REG_A=REG_D+8 */
state_save_register_item_array("m68k", device->tag, 0, REG_D);
state_save_register_item("m68k", device->tag, 0, REG_PPC);
state_save_register_item("m68k", device->tag, 0, REG_PC);
state_save_register_item("m68k", device->tag, 0, REG_USP);
state_save_register_item("m68k", device->tag, 0, REG_ISP);
state_save_register_item("m68k", device->tag, 0, REG_MSP);
state_save_register_item("m68k", device->tag, 0, m68k->vbr);
state_save_register_item("m68k", device->tag, 0, m68k->sfc);
state_save_register_item("m68k", device->tag, 0, m68k->dfc);
state_save_register_item("m68k", device->tag, 0, m68k->cacr);
state_save_register_item("m68k", device->tag, 0, m68k->caar);
state_save_register_item("m68k", device->tag, 0, m68k->save_sr);
state_save_register_item("m68k", device->tag, 0, m68k->int_level);
state_save_register_item("m68k", device->tag, 0, m68k->save_stopped);
state_save_register_item("m68k", device->tag, 0, m68k->save_halted);
state_save_register_item("m68k", device->tag, 0, m68k->pref_addr);
state_save_register_item("m68k", device->tag, 0, m68k->pref_data);
state_save_register_device_item_array(device, 0, REG_D);
state_save_register_device_item(device, 0, REG_PPC);
state_save_register_device_item(device, 0, REG_PC);
state_save_register_device_item(device, 0, REG_USP);
state_save_register_device_item(device, 0, REG_ISP);
state_save_register_device_item(device, 0, REG_MSP);
state_save_register_device_item(device, 0, m68k->vbr);
state_save_register_device_item(device, 0, m68k->sfc);
state_save_register_device_item(device, 0, m68k->dfc);
state_save_register_device_item(device, 0, m68k->cacr);
state_save_register_device_item(device, 0, m68k->caar);
state_save_register_device_item(device, 0, m68k->save_sr);
state_save_register_device_item(device, 0, m68k->int_level);
state_save_register_device_item(device, 0, m68k->save_stopped);
state_save_register_device_item(device, 0, m68k->save_halted);
state_save_register_device_item(device, 0, m68k->pref_addr);
state_save_register_device_item(device, 0, m68k->pref_data);
state_save_register_presave(device->machine, m68k_presave, m68k);
state_save_register_postload(device->machine, m68k_postload, m68k);
}

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

@ -419,13 +419,13 @@ static void Interrupt(void)
static void state_register(const char *type, const device_config *device)
{
state_save_register_item(type, device->tag, 0, A);
state_save_register_item(type, device->tag, 0, PC);
state_save_register_item(type, device->tag, 0, S);
state_save_register_item(type, device->tag, 0, X);
state_save_register_item(type, device->tag, 0, CC);
state_save_register_item(type, device->tag, 0, m6805.pending_interrupts);
state_save_register_item_array(type, device->tag, 0, m6805.irq_state);
state_save_register_device_item(device, 0, A);
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item(device, 0, m6805.pending_interrupts);
state_save_register_device_item_array(device, 0, m6805.irq_state);
}
static CPU_INIT( m6805 )

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

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

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

@ -139,7 +139,7 @@ static CPU_INIT( mb86233 )
mb86233.BRAM = &mb86233.RAM[0x200];
mb86233.Tables = (UINT32*) memory_region(device->machine, _config->tablergn);
state_save_register_global_pointer(mb86233.RAM,2 * 0x200 * sizeof(UINT32));
state_save_register_global_pointer(device->machine, mb86233.RAM,2 * 0x200 * sizeof(UINT32));
}
static CPU_RESET( mb86233 )

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

@ -134,27 +134,27 @@ static CPU_INIT( mb88 )
mb88.data = memory_find_address_space(device, ADDRESS_SPACE_DATA);
mb88.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("mb88", device->tag, 0, mb88.PC);
state_save_register_item("mb88", device->tag, 0, mb88.PA);
state_save_register_item("mb88", device->tag, 0, mb88.SP[0]);
state_save_register_item("mb88", device->tag, 0, mb88.SP[1]);
state_save_register_item("mb88", device->tag, 0, mb88.SP[2]);
state_save_register_item("mb88", device->tag, 0, mb88.SP[3]);
state_save_register_item("mb88", device->tag, 0, mb88.SI);
state_save_register_item("mb88", device->tag, 0, mb88.A);
state_save_register_item("mb88", device->tag, 0, mb88.X);
state_save_register_item("mb88", device->tag, 0, mb88.Y);
state_save_register_item("mb88", device->tag, 0, mb88.st);
state_save_register_item("mb88", device->tag, 0, mb88.zf);
state_save_register_item("mb88", device->tag, 0, mb88.cf);
state_save_register_item("mb88", device->tag, 0, mb88.vf);
state_save_register_item("mb88", device->tag, 0, mb88.sf);
state_save_register_item("mb88", device->tag, 0, mb88.nf);
state_save_register_item("mb88", device->tag, 0, mb88.pio);
state_save_register_item("mb88", device->tag, 0, mb88.TH);
state_save_register_item("mb88", device->tag, 0, mb88.TL);
state_save_register_item("mb88", device->tag, 0, mb88.SB);
state_save_register_item("mb88", device->tag, 0, mb88.pending_interrupt);
state_save_register_device_item(device, 0, mb88.PC);
state_save_register_device_item(device, 0, mb88.PA);
state_save_register_device_item(device, 0, mb88.SP[0]);
state_save_register_device_item(device, 0, mb88.SP[1]);
state_save_register_device_item(device, 0, mb88.SP[2]);
state_save_register_device_item(device, 0, mb88.SP[3]);
state_save_register_device_item(device, 0, mb88.SI);
state_save_register_device_item(device, 0, mb88.A);
state_save_register_device_item(device, 0, mb88.X);
state_save_register_device_item(device, 0, mb88.Y);
state_save_register_device_item(device, 0, mb88.st);
state_save_register_device_item(device, 0, mb88.zf);
state_save_register_device_item(device, 0, mb88.cf);
state_save_register_device_item(device, 0, mb88.vf);
state_save_register_device_item(device, 0, mb88.sf);
state_save_register_device_item(device, 0, mb88.nf);
state_save_register_device_item(device, 0, mb88.pio);
state_save_register_device_item(device, 0, mb88.TH);
state_save_register_device_item(device, 0, mb88.TL);
state_save_register_device_item(device, 0, mb88.SB);
state_save_register_device_item(device, 0, mb88.pending_interrupt);
}
static CPU_RESET( mb88 )

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

@ -716,25 +716,25 @@ static void mcs48_init(const device_config *device, int index, int clock, cpu_ir
/* ensure that regptr is valid before get_info gets called */
update_regptr(cpustate);
state_save_register_item("mcs48", device->tag, 0, cpustate->prevpc.w.l);
state_save_register_item("mcs48", device->tag, 0, PC);
state_save_register_item("mcs48", device->tag, 0, A);
state_save_register_item("mcs48", device->tag, 0, PSW);
state_save_register_item("mcs48", device->tag, 0, cpustate->p1);
state_save_register_item("mcs48", device->tag, 0, cpustate->p2);
state_save_register_item("mcs48", device->tag, 0, cpustate->f1);
state_save_register_item("mcs48", device->tag, 0, cpustate->ea);
state_save_register_item("mcs48", device->tag, 0, cpustate->timer);
state_save_register_item("mcs48", device->tag, 0, cpustate->prescaler);
state_save_register_item("mcs48", device->tag, 0, cpustate->t1_history);
state_save_register_item("mcs48", device->tag, 0, cpustate->irq_state);
state_save_register_item("mcs48", device->tag, 0, cpustate->irq_in_progress);
state_save_register_item("mcs48", device->tag, 0, cpustate->timer_overflow);
state_save_register_item("mcs48", device->tag, 0, cpustate->timer_flag);
state_save_register_item("mcs48", device->tag, 0, cpustate->tirq_enabled);
state_save_register_item("mcs48", device->tag, 0, cpustate->xirq_enabled);
state_save_register_item("mcs48", device->tag, 0, cpustate->timecount_enabled);
state_save_register_item("mcs48", device->tag, 0, cpustate->a11);
state_save_register_device_item(device, 0, cpustate->prevpc.w.l);
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, A);
state_save_register_device_item(device, 0, PSW);
state_save_register_device_item(device, 0, cpustate->p1);
state_save_register_device_item(device, 0, cpustate->p2);
state_save_register_device_item(device, 0, cpustate->f1);
state_save_register_device_item(device, 0, cpustate->ea);
state_save_register_device_item(device, 0, cpustate->timer);
state_save_register_device_item(device, 0, cpustate->prescaler);
state_save_register_device_item(device, 0, cpustate->t1_history);
state_save_register_device_item(device, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->irq_in_progress);
state_save_register_device_item(device, 0, cpustate->timer_overflow);
state_save_register_device_item(device, 0, cpustate->timer_flag);
state_save_register_device_item(device, 0, cpustate->tirq_enabled);
state_save_register_device_item(device, 0, cpustate->xirq_enabled);
state_save_register_device_item(device, 0, cpustate->timecount_enabled);
state_save_register_device_item(device, 0, cpustate->a11);
}

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

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

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

@ -101,17 +101,17 @@ void mips3com_init(mips3_state *mips, mips3_flavor flavor, int bigendian, const
mips3com_reset(mips);
/* register for save states */
state_save_register_item("mips3", device->tag, 0, mips->pc);
state_save_register_item_array("mips3", device->tag, 0, mips->r);
state_save_register_item_2d_array("mips3", device->tag, 0, mips->cpr);
state_save_register_item_2d_array("mips3", device->tag, 0, mips->ccr);
state_save_register_item("mips3", device->tag, 0, mips->llbit);
state_save_register_item("mips3", device->tag, 0, mips->count_zero_time);
state_save_register_device_item(device, 0, mips->pc);
state_save_register_device_item_array(device, 0, mips->r);
state_save_register_device_item_2d_array(device, 0, mips->cpr);
state_save_register_device_item_2d_array(device, 0, mips->ccr);
state_save_register_device_item(device, 0, mips->llbit);
state_save_register_device_item(device, 0, mips->count_zero_time);
for (tlbindex = 0; tlbindex < ARRAY_LENGTH(mips->tlb); tlbindex++)
{
state_save_register_item("mips3", device->tag, tlbindex, mips->tlb[tlbindex].page_mask);
state_save_register_item("mips3", device->tag, tlbindex, mips->tlb[tlbindex].entry_hi);
state_save_register_item_array("mips3", device->tag, tlbindex, mips->tlb[tlbindex].entry_lo);
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].page_mask);
state_save_register_device_item(device, tlbindex, mips->tlb[tlbindex].entry_hi);
state_save_register_device_item_array(device, tlbindex, mips->tlb[tlbindex].entry_lo);
}
}

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

@ -1599,23 +1599,23 @@ static void mips_state_register( const char *type, const device_config *device )
{
psxcpu_state *psxcpu = device->token;
state_save_register_item( type, device->tag, 0, psxcpu->op );
state_save_register_item( type, device->tag, 0, psxcpu->pc );
state_save_register_item( type, device->tag, 0, psxcpu->delayv );
state_save_register_item( type, device->tag, 0, psxcpu->delayr );
state_save_register_item( type, device->tag, 0, psxcpu->hi );
state_save_register_item( type, device->tag, 0, psxcpu->lo );
state_save_register_item( type, device->tag, 0, psxcpu->biu );
state_save_register_item_array( type, device->tag, 0, psxcpu->r );
state_save_register_item_array( type, device->tag, 0, psxcpu->cp0r );
state_save_register_item_array( type, device->tag, 0, psxcpu->cp2cr );
state_save_register_item_array( type, device->tag, 0, psxcpu->cp2dr );
state_save_register_item_array( type, device->tag, 0, psxcpu->icacheTag );
state_save_register_item_array( type, device->tag, 0, psxcpu->icache );
state_save_register_item_array( type, device->tag, 0, psxcpu->dcache );
state_save_register_item( type, device->tag, 0, psxcpu->multiplier_operation );
state_save_register_item( type, device->tag, 0, psxcpu->multiplier_operand1 );
state_save_register_item( type, device->tag, 0, psxcpu->multiplier_operand2 );
state_save_register_device_item( device, 0, psxcpu->op );
state_save_register_device_item( device, 0, psxcpu->pc );
state_save_register_device_item( device, 0, psxcpu->delayv );
state_save_register_device_item( device, 0, psxcpu->delayr );
state_save_register_device_item( device, 0, psxcpu->hi );
state_save_register_device_item( device, 0, psxcpu->lo );
state_save_register_device_item( device, 0, psxcpu->biu );
state_save_register_device_item_array( device, 0, psxcpu->r );
state_save_register_device_item_array( device, 0, psxcpu->cp0r );
state_save_register_device_item_array( device, 0, psxcpu->cp2cr );
state_save_register_device_item_array( device, 0, psxcpu->cp2dr );
state_save_register_device_item_array( device, 0, psxcpu->icacheTag );
state_save_register_device_item_array( device, 0, psxcpu->icache );
state_save_register_device_item_array( device, 0, psxcpu->dcache );
state_save_register_device_item( device, 0, psxcpu->multiplier_operation );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand1 );
state_save_register_device_item( device, 0, psxcpu->multiplier_operand2 );
state_save_register_postload( device->machine, mips_postload, psxcpu );
}

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

@ -1095,30 +1095,28 @@ static void nec_init(const device_config *device, int index, int clock, cpu_irq_
const nec_config *config = device->static_config ? device->static_config : &default_config;
nec_state_t *nec_state = device->token;
static const char *const names[]={"V20","V30","V33"};
nec_state->config = config;
state_save_register_item_array(names[type], device->tag, 0, nec_state->regs.w);
state_save_register_item_array(names[type], device->tag, 0, nec_state->sregs);
state_save_register_device_item_array(device, 0, nec_state->regs.w);
state_save_register_device_item_array(device, 0, nec_state->sregs);
state_save_register_item(names[type], device->tag, 0, nec_state->ip);
state_save_register_item(names[type], device->tag, 0, nec_state->TF);
state_save_register_item(names[type], device->tag, 0, nec_state->IF);
state_save_register_item(names[type], device->tag, 0, nec_state->DF);
state_save_register_item(names[type], device->tag, 0, nec_state->MF);
state_save_register_item(names[type], device->tag, 0, nec_state->SignVal);
state_save_register_item(names[type], device->tag, 0, nec_state->int_vector);
state_save_register_item(names[type], device->tag, 0, nec_state->pending_irq);
state_save_register_item(names[type], device->tag, 0, nec_state->nmi_state);
state_save_register_item(names[type], device->tag, 0, nec_state->irq_state);
state_save_register_item(names[type], device->tag, 0, nec_state->poll_state);
state_save_register_item(names[type], device->tag, 0, nec_state->AuxVal);
state_save_register_item(names[type], device->tag, 0, nec_state->OverVal);
state_save_register_item(names[type], device->tag, 0, nec_state->ZeroVal);
state_save_register_item(names[type], device->tag, 0, nec_state->CarryVal);
state_save_register_item(names[type], device->tag, 0, nec_state->ParityVal);
state_save_register_device_item(device, 0, nec_state->ip);
state_save_register_device_item(device, 0, nec_state->TF);
state_save_register_device_item(device, 0, nec_state->IF);
state_save_register_device_item(device, 0, nec_state->DF);
state_save_register_device_item(device, 0, nec_state->MF);
state_save_register_device_item(device, 0, nec_state->SignVal);
state_save_register_device_item(device, 0, nec_state->int_vector);
state_save_register_device_item(device, 0, nec_state->pending_irq);
state_save_register_device_item(device, 0, nec_state->nmi_state);
state_save_register_device_item(device, 0, nec_state->irq_state);
state_save_register_device_item(device, 0, nec_state->poll_state);
state_save_register_device_item(device, 0, nec_state->AuxVal);
state_save_register_device_item(device, 0, nec_state->OverVal);
state_save_register_device_item(device, 0, nec_state->ZeroVal);
state_save_register_device_item(device, 0, nec_state->CarryVal);
state_save_register_device_item(device, 0, nec_state->ParityVal);
nec_state->irq_callback = irqcallback;
nec_state->device = device;

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

@ -693,33 +693,33 @@ static const opcode_fn opcode_000_other[16]=
static CPU_INIT( pic16C5x )
{
state_save_register_item("pic16C5x", device->tag, 0, old_data);
state_save_register_item("pic16C5x", device->tag, 0, R.W);
state_save_register_item("pic16C5x", device->tag, 0, R.ALU);
state_save_register_item("pic16C5x", device->tag, 0, R.OPTION);
state_save_register_item("pic16C5x", device->tag, 0, R.TMR0);
state_save_register_item("pic16C5x", device->tag, 0, R.PCL);
state_save_register_item("pic16C5x", device->tag, 0, R.STATUS);
state_save_register_item("pic16C5x", device->tag, 0, R.FSR);
state_save_register_item("pic16C5x", device->tag, 0, R.PORTA);
state_save_register_item("pic16C5x", device->tag, 0, R.PORTB);
state_save_register_item("pic16C5x", device->tag, 0, R.PORTC);
state_save_register_item("pic16C5x", device->tag, 0, R.TRISA);
state_save_register_item("pic16C5x", device->tag, 0, R.TRISB);
state_save_register_item("pic16C5x", device->tag, 0, R.TRISC);
state_save_register_item("pic16C5x", device->tag, 0, old_T0);
state_save_register_item("pic16C5x", device->tag, 0, picRAMmask);
state_save_register_item("pic16C5x", device->tag, 0, R.WDT);
state_save_register_item("pic16C5x", device->tag, 0, R.prescaler);
state_save_register_item("pic16C5x", device->tag, 0, R.STACK[0]);
state_save_register_item("pic16C5x", device->tag, 0, R.STACK[1]);
state_save_register_item("pic16C5x", device->tag, 0, R.PC);
state_save_register_item("pic16C5x", device->tag, 0, R.PREVPC);
state_save_register_item("pic16C5x", device->tag, 0, R.CONFIG);
state_save_register_item("pic16C5x", device->tag, 0, R.opcode.d);
state_save_register_item("pic16C5x", device->tag, 0, delay_timer);
state_save_register_item("pic16C5x", device->tag, 0, picmodel);
state_save_register_item("pic16C5x", device->tag, 0, pic16C5x_reset_vector);
state_save_register_device_item(device, 0, old_data);
state_save_register_device_item(device, 0, R.W);
state_save_register_device_item(device, 0, R.ALU);
state_save_register_device_item(device, 0, R.OPTION);
state_save_register_device_item(device, 0, R.TMR0);
state_save_register_device_item(device, 0, R.PCL);
state_save_register_device_item(device, 0, R.STATUS);
state_save_register_device_item(device, 0, R.FSR);
state_save_register_device_item(device, 0, R.PORTA);
state_save_register_device_item(device, 0, R.PORTB);
state_save_register_device_item(device, 0, R.PORTC);
state_save_register_device_item(device, 0, R.TRISA);
state_save_register_device_item(device, 0, R.TRISB);
state_save_register_device_item(device, 0, R.TRISC);
state_save_register_device_item(device, 0, old_T0);
state_save_register_device_item(device, 0, picRAMmask);
state_save_register_device_item(device, 0, R.WDT);
state_save_register_device_item(device, 0, R.prescaler);
state_save_register_device_item(device, 0, R.STACK[0]);
state_save_register_device_item(device, 0, R.STACK[1]);
state_save_register_device_item(device, 0, R.PC);
state_save_register_device_item(device, 0, R.PREVPC);
state_save_register_device_item(device, 0, R.CONFIG);
state_save_register_device_item(device, 0, R.opcode.d);
state_save_register_device_item(device, 0, delay_timer);
state_save_register_device_item(device, 0, picmodel);
state_save_register_device_item(device, 0, pic16C5x_reset_vector);
R.device = device;
R.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);

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

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

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

@ -766,18 +766,18 @@ static CPU_INIT( s2650 )
s2650c->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
s2650c->io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("s2650", device->tag, 0, s2650c->ppc);
state_save_register_item("s2650", device->tag, 0, s2650c->page);
state_save_register_item("s2650", device->tag, 0, s2650c->iar);
state_save_register_item("s2650", device->tag, 0, s2650c->ea);
state_save_register_item("s2650", device->tag, 0, s2650c->psl);
state_save_register_item("s2650", device->tag, 0, s2650c->psu);
state_save_register_item("s2650", device->tag, 0, s2650c->r);
state_save_register_item_array("s2650", device->tag, 0, s2650c->reg);
state_save_register_item("s2650", device->tag, 0, s2650c->halt);
state_save_register_item("s2650", device->tag, 0, s2650c->ir);
state_save_register_item_array("s2650", device->tag, 0, s2650c->ras);
state_save_register_item("s2650", device->tag, 0, s2650c->irq_state);
state_save_register_device_item(device, 0, s2650c->ppc);
state_save_register_device_item(device, 0, s2650c->page);
state_save_register_device_item(device, 0, s2650c->iar);
state_save_register_device_item(device, 0, s2650c->ea);
state_save_register_device_item(device, 0, s2650c->psl);
state_save_register_device_item(device, 0, s2650c->psu);
state_save_register_device_item(device, 0, s2650c->r);
state_save_register_device_item_array(device, 0, s2650c->reg);
state_save_register_device_item(device, 0, s2650c->halt);
state_save_register_device_item(device, 0, s2650c->ir);
state_save_register_device_item_array(device, 0, s2650c->ras);
state_save_register_device_item(device, 0, s2650c->irq_state);
}
static CPU_RESET( s2650 )

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

@ -107,29 +107,29 @@ static CPU_INIT( saturn )
saturn.device = device;
saturn.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R0]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R1]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R2]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R3]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R4]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[A]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[B]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[C]);
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[D]);
state_save_register_item_array("saturn",device->tag, 0,saturn.d);
state_save_register_item("saturn",device->tag, 0,saturn.pc);
state_save_register_item("saturn",device->tag, 0,saturn.oldpc);
state_save_register_item_array("saturn",device->tag, 0,saturn.rstk);
state_save_register_item("saturn",device->tag, 0,saturn.out);
state_save_register_item("saturn",device->tag, 0,saturn.carry);
state_save_register_item("saturn",device->tag, 0,saturn.st);
state_save_register_item("saturn",device->tag, 0,saturn.hst);
state_save_register_item("saturn",device->tag, 0,saturn.nmi_state);
state_save_register_item("saturn",device->tag, 0,saturn.irq_state);
state_save_register_item("saturn",device->tag, 0,saturn.irq_enable);
state_save_register_item("saturn",device->tag, 0,saturn.in_irq);
state_save_register_item("saturn",device->tag, 0,saturn.pending_irq);
state_save_register_item("saturn",device->tag, 0,saturn.sleeping);
state_save_register_device_item_array(device, 0,saturn.reg[R0]);
state_save_register_device_item_array(device, 0,saturn.reg[R1]);
state_save_register_device_item_array(device, 0,saturn.reg[R2]);
state_save_register_device_item_array(device, 0,saturn.reg[R3]);
state_save_register_device_item_array(device, 0,saturn.reg[R4]);
state_save_register_device_item_array(device, 0,saturn.reg[A]);
state_save_register_device_item_array(device, 0,saturn.reg[B]);
state_save_register_device_item_array(device, 0,saturn.reg[C]);
state_save_register_device_item_array(device, 0,saturn.reg[D]);
state_save_register_device_item_array(device, 0,saturn.d);
state_save_register_device_item(device, 0,saturn.pc);
state_save_register_device_item(device, 0,saturn.oldpc);
state_save_register_device_item_array(device, 0,saturn.rstk);
state_save_register_device_item(device, 0,saturn.out);
state_save_register_device_item(device, 0,saturn.carry);
state_save_register_device_item(device, 0,saturn.st);
state_save_register_device_item(device, 0,saturn.hst);
state_save_register_device_item(device, 0,saturn.nmi_state);
state_save_register_device_item(device, 0,saturn.irq_state);
state_save_register_device_item(device, 0,saturn.irq_enable);
state_save_register_device_item(device, 0,saturn.in_irq);
state_save_register_device_item(device, 0,saturn.pending_irq);
state_save_register_device_item(device, 0,saturn.sleeping);
}
static CPU_RESET( saturn )

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

@ -737,29 +737,29 @@ void sh2_common_init(int alloc, const device_config *device, int index, int cloc
sh2->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
sh2->internal = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("sh2", device->tag, 0, sh2->pc);
state_save_register_item("sh2", device->tag, 0, sh2->r[15]);
state_save_register_item("sh2", device->tag, 0, sh2->sr);
state_save_register_item("sh2", device->tag, 0, sh2->pr);
state_save_register_item("sh2", device->tag, 0, sh2->gbr);
state_save_register_item("sh2", device->tag, 0, sh2->vbr);
state_save_register_item("sh2", device->tag, 0, sh2->mach);
state_save_register_item("sh2", device->tag, 0, sh2->macl);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 0]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 1]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 2]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 3]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 4]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 5]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 6]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 7]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 8]);
state_save_register_item("sh2", device->tag, 0, sh2->r[ 9]);
state_save_register_item("sh2", device->tag, 0, sh2->r[10]);
state_save_register_item("sh2", device->tag, 0, sh2->r[11]);
state_save_register_item("sh2", device->tag, 0, sh2->r[12]);
state_save_register_item("sh2", device->tag, 0, sh2->r[13]);
state_save_register_item("sh2", device->tag, 0, sh2->r[14]);
state_save_register_item("sh2", device->tag, 0, sh2->ea);
state_save_register_device_item(device, 0, sh2->pc);
state_save_register_device_item(device, 0, sh2->r[15]);
state_save_register_device_item(device, 0, sh2->sr);
state_save_register_device_item(device, 0, sh2->pr);
state_save_register_device_item(device, 0, sh2->gbr);
state_save_register_device_item(device, 0, sh2->vbr);
state_save_register_device_item(device, 0, sh2->mach);
state_save_register_device_item(device, 0, sh2->macl);
state_save_register_device_item(device, 0, sh2->r[ 0]);
state_save_register_device_item(device, 0, sh2->r[ 1]);
state_save_register_device_item(device, 0, sh2->r[ 2]);
state_save_register_device_item(device, 0, sh2->r[ 3]);
state_save_register_device_item(device, 0, sh2->r[ 4]);
state_save_register_device_item(device, 0, sh2->r[ 5]);
state_save_register_device_item(device, 0, sh2->r[ 6]);
state_save_register_device_item(device, 0, sh2->r[ 7]);
state_save_register_device_item(device, 0, sh2->r[ 8]);
state_save_register_device_item(device, 0, sh2->r[ 9]);
state_save_register_device_item(device, 0, sh2->r[10]);
state_save_register_device_item(device, 0, sh2->r[11]);
state_save_register_device_item(device, 0, sh2->r[12]);
state_save_register_device_item(device, 0, sh2->r[13]);
state_save_register_device_item(device, 0, sh2->r[14]);
state_save_register_device_item(device, 0, sh2->ea);
}

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

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

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

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

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

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

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

@ -277,19 +277,19 @@ static CPU_INIT( t11 )
cpustate->device = device;
cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("t11", device->tag, 0, cpustate->ppc.w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[0].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[1].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[2].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[3].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[4].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[5].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[6].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->reg[7].w.l);
state_save_register_item("t11", device->tag, 0, cpustate->psw.w.l);
state_save_register_item("t11", device->tag, 0, cpustate->initial_pc);
state_save_register_item("t11", device->tag, 0, cpustate->wait_state);
state_save_register_item("t11", device->tag, 0, cpustate->irq_state);
state_save_register_device_item(device, 0, cpustate->ppc.w.l);
state_save_register_device_item(device, 0, cpustate->reg[0].w.l);
state_save_register_device_item(device, 0, cpustate->reg[1].w.l);
state_save_register_device_item(device, 0, cpustate->reg[2].w.l);
state_save_register_device_item(device, 0, cpustate->reg[3].w.l);
state_save_register_device_item(device, 0, cpustate->reg[4].w.l);
state_save_register_device_item(device, 0, cpustate->reg[5].w.l);
state_save_register_device_item(device, 0, cpustate->reg[6].w.l);
state_save_register_device_item(device, 0, cpustate->reg[7].w.l);
state_save_register_device_item(device, 0, cpustate->psw.w.l);
state_save_register_device_item(device, 0, cpustate->initial_pc);
state_save_register_device_item(device, 0, cpustate->wait_state);
state_save_register_device_item(device, 0, cpustate->irq_state);
}

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

@ -2619,7 +2619,7 @@ static CPU_INIT( t90 )
{
int i, p;
// state_save_register_item("z80", device->tag, 0, Z80.prvpc.w.l);
// state_save_register_device_item(device, 0, Z80.prvpc.w.l);
for (i = 0; i < 256; i++)
{

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

@ -715,21 +715,21 @@ static const opcode_fn opcode_7F_other[32]=
****************************************************************************/
static CPU_INIT( tms32010 )
{
state_save_register_item("tms32010", device->tag, 0, R.PC);
state_save_register_item("tms32010", device->tag, 0, R.PREVPC);
state_save_register_item("tms32010", device->tag, 0, R.STR);
state_save_register_item("tms32010", device->tag, 0, R.ACC.d);
state_save_register_item("tms32010", device->tag, 0, R.ALU.d);
state_save_register_item("tms32010", device->tag, 0, R.Preg.d);
state_save_register_item("tms32010", device->tag, 0, R.Treg);
state_save_register_item("tms32010", device->tag, 0, R.AR[0]);
state_save_register_item("tms32010", device->tag, 0, R.AR[1]);
state_save_register_item("tms32010", device->tag, 0, R.STACK[0]);
state_save_register_item("tms32010", device->tag, 0, R.STACK[1]);
state_save_register_item("tms32010", device->tag, 0, R.STACK[2]);
state_save_register_item("tms32010", device->tag, 0, R.STACK[3]);
state_save_register_item("tms32010", device->tag, 0, R.INTF);
state_save_register_item("tms32010", device->tag, 0, R.opcode.d);
state_save_register_device_item(device, 0, R.PC);
state_save_register_device_item(device, 0, R.PREVPC);
state_save_register_device_item(device, 0, R.STR);
state_save_register_device_item(device, 0, R.ACC.d);
state_save_register_device_item(device, 0, R.ALU.d);
state_save_register_device_item(device, 0, R.Preg.d);
state_save_register_device_item(device, 0, R.Treg);
state_save_register_device_item(device, 0, R.AR[0]);
state_save_register_device_item(device, 0, R.AR[1]);
state_save_register_device_item(device, 0, R.STACK[0]);
state_save_register_device_item(device, 0, R.STACK[1]);
state_save_register_device_item(device, 0, R.STACK[2]);
state_save_register_device_item(device, 0, R.STACK[3]);
state_save_register_device_item(device, 0, R.INTF);
state_save_register_device_item(device, 0, R.opcode.d);
R.device = device;
R.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);

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

@ -1740,38 +1740,38 @@ static CPU_INIT( tms32025 )
R.data = memory_find_address_space(device, ADDRESS_SPACE_DATA);
R.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("tms32025", device->tag, 0, R.PC);
state_save_register_item("tms32025", device->tag, 0, R.STR0);
state_save_register_item("tms32025", device->tag, 0, R.STR1);
state_save_register_item("tms32025", device->tag, 0, R.PFC);
state_save_register_item("tms32025", device->tag, 0, R.IFR);
state_save_register_item("tms32025", device->tag, 0, R.RPTC);
state_save_register_item("tms32025", device->tag, 0, R.ACC.d);
state_save_register_item("tms32025", device->tag, 0, R.ALU.d);
state_save_register_item("tms32025", device->tag, 0, R.Preg.d);
state_save_register_item("tms32025", device->tag, 0, R.Treg);
state_save_register_item("tms32025", device->tag, 0, R.AR[0]);
state_save_register_item("tms32025", device->tag, 0, R.AR[1]);
state_save_register_item("tms32025", device->tag, 0, R.AR[2]);
state_save_register_item("tms32025", device->tag, 0, R.AR[3]);
state_save_register_item("tms32025", device->tag, 0, R.AR[4]);
state_save_register_item("tms32025", device->tag, 0, R.AR[5]);
state_save_register_item("tms32025", device->tag, 0, R.AR[6]);
state_save_register_item("tms32025", device->tag, 0, R.AR[7]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[0]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[1]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[2]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[3]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[4]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[5]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[6]);
state_save_register_item("tms32025", device->tag, 0, R.STACK[7]);
state_save_register_device_item(device, 0, R.PC);
state_save_register_device_item(device, 0, R.STR0);
state_save_register_device_item(device, 0, R.STR1);
state_save_register_device_item(device, 0, R.PFC);
state_save_register_device_item(device, 0, R.IFR);
state_save_register_device_item(device, 0, R.RPTC);
state_save_register_device_item(device, 0, R.ACC.d);
state_save_register_device_item(device, 0, R.ALU.d);
state_save_register_device_item(device, 0, R.Preg.d);
state_save_register_device_item(device, 0, R.Treg);
state_save_register_device_item(device, 0, R.AR[0]);
state_save_register_device_item(device, 0, R.AR[1]);
state_save_register_device_item(device, 0, R.AR[2]);
state_save_register_device_item(device, 0, R.AR[3]);
state_save_register_device_item(device, 0, R.AR[4]);
state_save_register_device_item(device, 0, R.AR[5]);
state_save_register_device_item(device, 0, R.AR[6]);
state_save_register_device_item(device, 0, R.AR[7]);
state_save_register_device_item(device, 0, R.STACK[0]);
state_save_register_device_item(device, 0, R.STACK[1]);
state_save_register_device_item(device, 0, R.STACK[2]);
state_save_register_device_item(device, 0, R.STACK[3]);
state_save_register_device_item(device, 0, R.STACK[4]);
state_save_register_device_item(device, 0, R.STACK[5]);
state_save_register_device_item(device, 0, R.STACK[6]);
state_save_register_device_item(device, 0, R.STACK[7]);
state_save_register_item("tms32025", device->tag, 0, R.idle);
state_save_register_item("tms32025", device->tag, 0, R.hold);
state_save_register_item("tms32025", device->tag, 0, R.external_mem_access);
state_save_register_item("tms32025", device->tag, 0, R.init_load_addr);
state_save_register_item("tms32025", device->tag, 0, R.PREVPC);
state_save_register_device_item(device, 0, R.idle);
state_save_register_device_item(device, 0, R.hold);
state_save_register_device_item(device, 0, R.external_mem_access);
state_save_register_device_item(device, 0, R.init_load_addr);
state_save_register_device_item(device, 0, R.PREVPC);
}
/****************************************************************************

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

@ -387,15 +387,15 @@ static CPU_INIT( tms32031 )
tms->iack_w = configdata->iack_w;
}
state_save_register_item("tms32031", device->tag, 0, tms->pc);
state_save_register_device_item(device, 0, tms->pc);
for (i = 0; i < 36; i++)
state_save_register_generic("tms32031", device->tag, i, "reg", tms->r[i].i8, UINT8, 8);
state_save_register_item("tms32031", device->tag, 0, tms->bkmask);
state_save_register_item("tms32031", device->tag, 0, tms->irq_state);
state_save_register_item("tms32031", device->tag, 0, tms->delayed);
state_save_register_item("tms32031", device->tag, 0, tms->irq_pending);
state_save_register_item("tms32031", device->tag, 0, tms->mcu_mode);
state_save_register_item("tms32031", device->tag, 0, tms->is_idling);
state_save_register_generic(device->machine, "tms32031", device->tag, i, "reg", tms->r[i].i8, UINT8, 8);
state_save_register_device_item(device, 0, tms->bkmask);
state_save_register_device_item(device, 0, tms->irq_state);
state_save_register_device_item(device, 0, tms->delayed);
state_save_register_device_item(device, 0, tms->irq_pending);
state_save_register_device_item(device, 0, tms->mcu_mode);
state_save_register_device_item(device, 0, tms->is_idling);
}
static CPU_RESET( tms32031 )

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

@ -633,17 +633,17 @@ static CPU_INIT( tms34010 )
/* allocate the shiftreg */
tms->shiftreg = auto_malloc(SHIFTREG_SIZE);
state_save_register_item("tms34010", device->tag, 0, tms->pc);
state_save_register_item("tms34010", device->tag, 0, tms->st);
state_save_register_item("tms34010", device->tag, 0, tms->reset_deferred);
state_save_register_item_pointer("tms34010", device->tag, 0, tms->shiftreg, SHIFTREG_SIZE / 2);
state_save_register_item_array("tms34010", device->tag, 0, tms->IOregs);
state_save_register_item("tms34010", device->tag, 0, tms->convsp);
state_save_register_item("tms34010", device->tag, 0, tms->convdp);
state_save_register_item("tms34010", device->tag, 0, tms->convmp);
state_save_register_item("tms34010", device->tag, 0, tms->pixelshift);
state_save_register_item("tms34010", device->tag, 0, tms->gfxcycles);
state_save_register_item_pointer("tms34010", device->tag, 0, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
state_save_register_device_item(device, 0, tms->pc);
state_save_register_device_item(device, 0, tms->st);
state_save_register_device_item(device, 0, tms->reset_deferred);
state_save_register_device_item_pointer(device, 0, tms->shiftreg, SHIFTREG_SIZE / 2);
state_save_register_device_item_array(device, 0, tms->IOregs);
state_save_register_device_item(device, 0, tms->convsp);
state_save_register_device_item(device, 0, tms->convdp);
state_save_register_device_item(device, 0, tms->convmp);
state_save_register_device_item(device, 0, tms->pixelshift);
state_save_register_device_item(device, 0, tms->gfxcycles);
state_save_register_device_item_pointer(device, 0, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
state_save_register_postload(device->machine, tms34010_state_postload, tms);
}
@ -1107,12 +1107,16 @@ VIDEO_UPDATE( tms340x0 )
for (cpunum = 0; cpunum < ARRAY_LENGTH(screen->machine->cpu); cpunum++)
{
const device_config *cpudevice = screen->machine->cpu[cpunum];
if (cpudevice != NULL && (cpudevice->type == (device_type)CPU_TMS34010 || cpudevice->type == (device_type)CPU_TMS34020))
if (cpudevice != NULL)
{
tms = cpudevice->token;
if (tms->config != NULL && tms->config->scanline_callback != NULL && tms->screen == screen)
break;
tms = NULL;
const cpu_class_header *classdata = cpudevice->classtoken;
if (classdata->cputype == CPU_TMS34010 || classdata->cputype == CPU_TMS34020)
{
tms = cpudevice->token;
if (tms->config != NULL && tms->config->scanline_callback != NULL && tms->screen == screen)
break;
tms = NULL;
}
}
}
if (tms == NULL)

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

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

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

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

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

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

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

@ -926,26 +926,24 @@ static CPU_DISASSEMBLE( nec )
static void nec_init(const device_config *device, int index, int clock, cpu_irq_callback irqcallback, int type)
{
static const char *const names[]={"V20","V30","V33","V30MZ"};
state_save_register_device_item_array(device, 0, I.regs.w);
state_save_register_device_item_array(device, 0, I.sregs);
state_save_register_item_array(names[type], device->tag, 0, I.regs.w);
state_save_register_item_array(names[type], device->tag, 0, I.sregs);
state_save_register_item(names[type], device->tag, 0, I.ip);
state_save_register_item(names[type], device->tag, 0, I.TF);
state_save_register_item(names[type], device->tag, 0, I.IF);
state_save_register_item(names[type], device->tag, 0, I.DF);
state_save_register_item(names[type], device->tag, 0, I.MF);
state_save_register_item(names[type], device->tag, 0, I.SignVal);
state_save_register_item(names[type], device->tag, 0, I.int_vector);
state_save_register_item(names[type], device->tag, 0, I.pending_irq);
state_save_register_item(names[type], device->tag, 0, I.nmi_state);
state_save_register_item(names[type], device->tag, 0, I.irq_state);
state_save_register_item(names[type], device->tag, 0, I.AuxVal);
state_save_register_item(names[type], device->tag, 0, I.OverVal);
state_save_register_item(names[type], device->tag, 0, I.ZeroVal);
state_save_register_item(names[type], device->tag, 0, I.CarryVal);
state_save_register_item(names[type], device->tag, 0, I.ParityVal);
state_save_register_device_item(device, 0, I.ip);
state_save_register_device_item(device, 0, I.TF);
state_save_register_device_item(device, 0, I.IF);
state_save_register_device_item(device, 0, I.DF);
state_save_register_device_item(device, 0, I.MF);
state_save_register_device_item(device, 0, I.SignVal);
state_save_register_device_item(device, 0, I.int_vector);
state_save_register_device_item(device, 0, I.pending_irq);
state_save_register_device_item(device, 0, I.nmi_state);
state_save_register_device_item(device, 0, I.irq_state);
state_save_register_device_item(device, 0, I.AuxVal);
state_save_register_device_item(device, 0, I.OverVal);
state_save_register_device_item(device, 0, I.ZeroVal);
state_save_register_device_item(device, 0, I.CarryVal);
state_save_register_device_item(device, 0, I.ParityVal);
I.irq_callback = irqcallback;
I.device = device;

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

@ -310,14 +310,14 @@ static void base_init(const char *type, const device_config *device, int index,
v60.irq_line = CLEAR_LINE;
v60.nmi_line = CLEAR_LINE;
state_save_register_item_array(type, device->tag, 0, v60.reg);
state_save_register_item(type, device->tag, 0, v60.irq_line);
state_save_register_item(type, device->tag, 0, v60.nmi_line);
state_save_register_item(type, device->tag, 0, v60.PPC);
state_save_register_item(type, device->tag, 0, _CY);
state_save_register_item(type, device->tag, 0, _OV);
state_save_register_item(type, device->tag, 0, _S);
state_save_register_item(type, device->tag, 0, _Z);
state_save_register_device_item_array(device, 0, v60.reg);
state_save_register_device_item(device, 0, v60.irq_line);
state_save_register_device_item(device, 0, v60.nmi_line);
state_save_register_device_item(device, 0, v60.PPC);
state_save_register_device_item(device, 0, _CY);
state_save_register_device_item(device, 0, _OV);
state_save_register_device_item(device, 0, _S);
state_save_register_device_item(device, 0, _Z);
}
static CPU_INIT( v60 )

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

@ -957,10 +957,10 @@ static CPU_INIT( v810 )
v810.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
v810.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item_array("v810", device->tag, 0, v810.reg);
state_save_register_item("v810", device->tag, 0, v810.irq_line);
state_save_register_item("v810", device->tag, 0, v810.nmi_line);
state_save_register_item("v810", device->tag, 0, v810.PPC);
state_save_register_device_item_array(device, 0, v810.reg);
state_save_register_device_item(device, 0, v810.irq_line);
state_save_register_device_item(device, 0, v810.nmi_line);
state_save_register_device_item(device, 0, v810.PPC);
}

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

@ -80,19 +80,19 @@ vtlb_state *vtlb_alloc(const device_config *cpu, int space, int fixed_entries, i
/* allocate the entry array */
vtlb->live = malloc_or_die(sizeof(vtlb->live[0]) * (fixed_entries + dynamic_entries));
memset(vtlb->live, 0, sizeof(vtlb->live[0]) * (fixed_entries + dynamic_entries));
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->live, fixed_entries + dynamic_entries);
state_save_register_device_item_pointer(cpu, space, vtlb->live, fixed_entries + dynamic_entries);
/* allocate the lookup table */
vtlb->table = malloc_or_die(sizeof(vtlb->table[0]) << (vtlb->addrwidth - vtlb->pageshift));
memset(vtlb->table, 0, sizeof(vtlb->table[0]) << (vtlb->addrwidth - vtlb->pageshift));
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->table, 1 << (vtlb->addrwidth - vtlb->pageshift));
state_save_register_device_item_pointer(cpu, space, vtlb->table, 1 << (vtlb->addrwidth - vtlb->pageshift));
/* allocate the fixed page count array */
if (fixed_entries > 0)
{
vtlb->fixedpages = malloc_or_die(sizeof(vtlb->fixedpages[0]) * fixed_entries);
memset(vtlb->fixedpages, 0, sizeof(vtlb->fixedpages[0]) * fixed_entries);
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->fixedpages, fixed_entries);
state_save_register_device_item_pointer(cpu, space, vtlb->fixedpages, fixed_entries);
}
return vtlb;
}

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

@ -1909,31 +1909,31 @@ static CPU_INIT( z180 )
Z180.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
Z180.iospace = memory_find_address_space(device, ADDRESS_SPACE_IO);
state_save_register_item("z180", device->tag, 0, Z180.AF.w.l);
state_save_register_item("z180", device->tag, 0, Z180.BC.w.l);
state_save_register_item("z180", device->tag, 0, Z180.DE.w.l);
state_save_register_item("z180", device->tag, 0, Z180.HL.w.l);
state_save_register_item("z180", device->tag, 0, Z180.IX.w.l);
state_save_register_item("z180", device->tag, 0, Z180.IY.w.l);
state_save_register_item("z180", device->tag, 0, Z180.PC.w.l);
state_save_register_item("z180", device->tag, 0, Z180.SP.w.l);
state_save_register_item("z180", device->tag, 0, Z180.AF2.w.l);
state_save_register_item("z180", device->tag, 0, Z180.BC2.w.l);
state_save_register_item("z180", device->tag, 0, Z180.DE2.w.l);
state_save_register_item("z180", device->tag, 0, Z180.HL2.w.l);
state_save_register_item("z180", device->tag, 0, Z180.R);
state_save_register_item("z180", device->tag, 0, Z180.R2);
state_save_register_item("z180", device->tag, 0, Z180.IFF1);
state_save_register_item("z180", device->tag, 0, Z180.IFF2);
state_save_register_item("z180", device->tag, 0, Z180.HALT);
state_save_register_item("z180", device->tag, 0, Z180.IM);
state_save_register_item("z180", device->tag, 0, Z180.I);
state_save_register_item("z180", device->tag, 0, Z180.nmi_state);
state_save_register_item("z180", device->tag, 0, Z180.nmi_pending);
state_save_register_item("z180", device->tag, 0, Z180.irq_state[0]);
state_save_register_item("z180", device->tag, 0, Z180.irq_state[1]);
state_save_register_item("z180", device->tag, 0, Z180.irq_state[2]);
state_save_register_item("z180", device->tag, 0, Z180.after_EI);
state_save_register_device_item(device, 0, Z180.AF.w.l);
state_save_register_device_item(device, 0, Z180.BC.w.l);
state_save_register_device_item(device, 0, Z180.DE.w.l);
state_save_register_device_item(device, 0, Z180.HL.w.l);
state_save_register_device_item(device, 0, Z180.IX.w.l);
state_save_register_device_item(device, 0, Z180.IY.w.l);
state_save_register_device_item(device, 0, Z180.PC.w.l);
state_save_register_device_item(device, 0, Z180.SP.w.l);
state_save_register_device_item(device, 0, Z180.AF2.w.l);
state_save_register_device_item(device, 0, Z180.BC2.w.l);
state_save_register_device_item(device, 0, Z180.DE2.w.l);
state_save_register_device_item(device, 0, Z180.HL2.w.l);
state_save_register_device_item(device, 0, Z180.R);
state_save_register_device_item(device, 0, Z180.R2);
state_save_register_device_item(device, 0, Z180.IFF1);
state_save_register_device_item(device, 0, Z180.IFF2);
state_save_register_device_item(device, 0, Z180.HALT);
state_save_register_device_item(device, 0, Z180.IM);
state_save_register_device_item(device, 0, Z180.I);
state_save_register_device_item(device, 0, Z180.nmi_state);
state_save_register_device_item(device, 0, Z180.nmi_pending);
state_save_register_device_item(device, 0, Z180.irq_state[0]);
state_save_register_device_item(device, 0, Z180.irq_state[1]);
state_save_register_device_item(device, 0, Z180.irq_state[2]);
state_save_register_device_item(device, 0, Z180.after_EI);
}
/****************************************************************************

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

@ -3358,31 +3358,31 @@ static CPU_INIT( z80 )
if( (i & 0x0f) == 0x0f ) SZHV_dec[i] |= HF;
}
state_save_register_item("z80", device->tag, 0, z80->prvpc.w.l);
state_save_register_item("z80", device->tag, 0, z80->PC);
state_save_register_item("z80", device->tag, 0, z80->SP);
state_save_register_item("z80", device->tag, 0, z80->AF);
state_save_register_item("z80", device->tag, 0, z80->BC);
state_save_register_item("z80", device->tag, 0, z80->DE);
state_save_register_item("z80", device->tag, 0, z80->HL);
state_save_register_item("z80", device->tag, 0, z80->IX);
state_save_register_item("z80", device->tag, 0, z80->IY);
state_save_register_item("z80", device->tag, 0, z80->MEMPTR);
state_save_register_item("z80", device->tag, 0, z80->af2.w.l);
state_save_register_item("z80", device->tag, 0, z80->bc2.w.l);
state_save_register_item("z80", device->tag, 0, z80->de2.w.l);
state_save_register_item("z80", device->tag, 0, z80->hl2.w.l);
state_save_register_item("z80", device->tag, 0, z80->r);
state_save_register_item("z80", device->tag, 0, z80->r2);
state_save_register_item("z80", device->tag, 0, z80->iff1);
state_save_register_item("z80", device->tag, 0, z80->iff2);
state_save_register_item("z80", device->tag, 0, z80->halt);
state_save_register_item("z80", device->tag, 0, z80->im);
state_save_register_item("z80", device->tag, 0, z80->i);
state_save_register_item("z80", device->tag, 0, z80->nmi_state);
state_save_register_item("z80", device->tag, 0, z80->nmi_pending);
state_save_register_item("z80", device->tag, 0, z80->irq_state);
state_save_register_item("z80", device->tag, 0, z80->after_ei);
state_save_register_device_item(device, 0, z80->prvpc.w.l);
state_save_register_device_item(device, 0, z80->PC);
state_save_register_device_item(device, 0, z80->SP);
state_save_register_device_item(device, 0, z80->AF);
state_save_register_device_item(device, 0, z80->BC);
state_save_register_device_item(device, 0, z80->DE);
state_save_register_device_item(device, 0, z80->HL);
state_save_register_device_item(device, 0, z80->IX);
state_save_register_device_item(device, 0, z80->IY);
state_save_register_device_item(device, 0, z80->MEMPTR);
state_save_register_device_item(device, 0, z80->af2.w.l);
state_save_register_device_item(device, 0, z80->bc2.w.l);
state_save_register_device_item(device, 0, z80->de2.w.l);
state_save_register_device_item(device, 0, z80->hl2.w.l);
state_save_register_device_item(device, 0, z80->r);
state_save_register_device_item(device, 0, z80->r2);
state_save_register_device_item(device, 0, z80->iff1);
state_save_register_device_item(device, 0, z80->iff2);
state_save_register_device_item(device, 0, z80->halt);
state_save_register_device_item(device, 0, z80->im);
state_save_register_device_item(device, 0, z80->i);
state_save_register_device_item(device, 0, z80->nmi_state);
state_save_register_device_item(device, 0, z80->nmi_pending);
state_save_register_device_item(device, 0, z80->irq_state);
state_save_register_device_item(device, 0, z80->after_ei);
/* Reset registers to their initial values */
memset(z80, 0, sizeof(*z80));

44
src/emu/cpuexec.c
View File

@ -167,6 +167,12 @@ INLINE void suspend_until_trigger(const device_config *device, int trigger, int
each CPU
-------------------------------------------------*/
static DEVICE_GET_INFO( cpuclass )
{
cpu_class_data *classdata = device->classtoken;
(*classdata->header.get_info)(device, state, (cpuinfo *)info);
}
const device_config *cpuexec_create_cpu_device(const cpu_config *config)
{
device_config *device;
@ -175,7 +181,7 @@ const device_config *cpuexec_create_cpu_device(const cpu_config *config)
device = malloc_or_die(sizeof(*device) + strlen(config->tag));
memset(device, 0, sizeof(*device));
strcpy(device->tag, config->tag);
device->type = (device_type)config->type;
device->type = DEVICE_GET_INFO_NAME(cpuclass);
device->class = DEVICE_CLASS_CPU_CHIP;
device->inline_config = (void *)config;
device->static_config = config->reset_param;
@ -245,9 +251,9 @@ void cpuexec_init(running_machine *machine)
/* initialize this CPU */
state_save_push_tag(cpunum + 1);
num_regs = state_save_get_reg_count();
num_regs = state_save_get_reg_count(machine);
cpu_init(device, cpunum, classdata->clock, standard_irq_callback);
num_regs = state_save_get_reg_count() - num_regs;
num_regs = state_save_get_reg_count(machine) - num_regs;
state_save_pop_tag();
/* fetch post-initialization data */
@ -917,7 +923,7 @@ void cpu_set_input_line_and_vector(const device_config *device, int line, int st
/* catch errors where people use PULSE_LINE for CPUs that don't support it */
if (state == PULSE_LINE && line != INPUT_LINE_NMI && line != INPUT_LINE_RESET)
{
switch ((cpu_type)device->type)
switch (classdata->header.cputype)
{
case CPU_Z80:
case CPU_Z180:
@ -1341,7 +1347,7 @@ static TIMER_CALLBACK( empty_event_queue )
{
case PULSE_LINE:
/* temporary: PULSE_LINE only makes sense for NMI lines on Z80 */
assert((cpu_type)device->type != CPU_Z80 || param == INPUT_LINE_NMI);
assert(classdata->header.cputype != CPU_Z80 || param == INPUT_LINE_NMI);
cpu_set_info_int(device, CPUINFO_INT_INPUT_STATE + param, ASSERT_LINE);
cpu_set_info_int(device, CPUINFO_INT_INPUT_STATE + param, CLEAR_LINE);
break;
@ -1418,26 +1424,26 @@ static void register_save_states(const device_config *device)
cpu_class_data *classdata = device->classtoken;
int line;
state_save_register_item("cpu", device->tag, 0, classdata->suspend);
state_save_register_item("cpu", device->tag, 0, classdata->nextsuspend);
state_save_register_item("cpu", device->tag, 0, classdata->eatcycles);
state_save_register_item("cpu", device->tag, 0, classdata->nexteatcycles);
state_save_register_item("cpu", device->tag, 0, classdata->trigger);
state_save_register_device_item(device, 0, classdata->suspend);
state_save_register_device_item(device, 0, classdata->nextsuspend);
state_save_register_device_item(device, 0, classdata->eatcycles);
state_save_register_device_item(device, 0, classdata->nexteatcycles);
state_save_register_device_item(device, 0, classdata->trigger);
state_save_register_item("cpu", device->tag, 0, classdata->iloops);
state_save_register_device_item(device, 0, classdata->iloops);
state_save_register_item("cpu", device->tag, 0, classdata->totalcycles);
state_save_register_item("cpu", device->tag, 0, classdata->localtime.seconds);
state_save_register_item("cpu", device->tag, 0, classdata->localtime.attoseconds);
state_save_register_item("cpu", device->tag, 0, classdata->clock);
state_save_register_item("cpu", device->tag, 0, classdata->clockscale);
state_save_register_device_item(device, 0, classdata->totalcycles);
state_save_register_device_item(device, 0, classdata->localtime.seconds);
state_save_register_device_item(device, 0, classdata->localtime.attoseconds);
state_save_register_device_item(device, 0, classdata->clock);
state_save_register_device_item(device, 0, classdata->clockscale);
for (line = 0; line < ARRAY_LENGTH(classdata->input); line++)
{
cpu_input_data *inputline = &classdata->input[line];
state_save_register_item("cpu", device->tag, line, inputline->vector);
state_save_register_item("cpu", device->tag, line, inputline->curvector);
state_save_register_item("cpu", device->tag, line, inputline->curstate);
state_save_register_device_item(device, line, inputline->vector);
state_save_register_device_item(device, line, inputline->curvector);
state_save_register_device_item(device, line, inputline->curstate);
}
}

140
src/emu/cpuintrf.h
View File

@ -71,81 +71,95 @@ enum
enum
{
/* --- the following bits of info are returned as 64-bit signed integers --- */
CPUINFO_INT_FIRST = 0x00000,
CPUINFO_INT_FIRST = DEVINFO_INT_FIRST,
CPUINFO_INT_CONTEXT_SIZE = CPUINFO_INT_FIRST, /* R/O: size of CPU context in bytes */
CPUINFO_INT_INPUT_LINES, /* R/O: number of input lines */
CPUINFO_INT_OUTPUT_LINES, /* R/O: number of output lines */
CPUINFO_INT_DEFAULT_IRQ_VECTOR, /* R/O: default IRQ vector */
CPUINFO_INT_ENDIANNESS, /* R/O: either ENDIANNESS_BIG or ENDIANNESS_LITTLE */
CPUINFO_INT_CLOCK_MULTIPLIER, /* R/O: internal clock multiplier */
CPUINFO_INT_CLOCK_DIVIDER, /* R/O: internal clock divider */
CPUINFO_INT_MIN_INSTRUCTION_BYTES, /* R/O: minimum bytes per instruction */
CPUINFO_INT_MAX_INSTRUCTION_BYTES, /* R/O: maximum bytes per instruction */
CPUINFO_INT_MIN_CYCLES, /* R/O: minimum cycles for a single instruction */
CPUINFO_INT_MAX_CYCLES, /* R/O: maximum cycles for a single instruction */
/* direct map to device data */
CPUINFO_INT_CONTEXT_SIZE = DEVINFO_INT_TOKEN_BYTES, /* R/O: size of CPU context in bytes */
CPUINFO_INT_DATABUS_WIDTH, /* R/O: data bus size for each address space (8,16,32,64) */
CPUINFO_INT_DATABUS_WIDTH_LAST = CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_ADDRBUS_WIDTH, /* R/O: address bus size for each address space (12-32) */
CPUINFO_INT_ADDRBUS_WIDTH_LAST = CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_ADDRBUS_SHIFT, /* R/O: shift applied to addresses each address space (+3 means >>3, -1 means <<1) */
CPUINFO_INT_ADDRBUS_SHIFT_LAST = CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACES - 1,
CPUINFO_INT_LOGADDR_WIDTH, /* R/O: address bus size for logical accesses in each space (0=same as physical) */
CPUINFO_INT_LOGADDR_WIDTH_LAST = CPUINFO_INT_LOGADDR_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_PAGE_SHIFT, /* R/O: size of a page log 2 (i.e., 12=4096), or 0 if paging not supported */
CPUINFO_INT_PAGE_SHIFT_LAST = CPUINFO_INT_PAGE_SHIFT + ADDRESS_SPACES - 1,
/* CPU-specific additions */
CPUINFO_INT_INPUT_LINES = DEVINFO_INT_CLASS_SPECIFIC, /* R/O: number of input lines */
CPUINFO_INT_OUTPUT_LINES, /* R/O: number of output lines */
CPUINFO_INT_DEFAULT_IRQ_VECTOR, /* R/O: default IRQ vector */
CPUINFO_INT_ENDIANNESS, /* R/O: either ENDIANNESS_BIG or ENDIANNESS_LITTLE */
CPUINFO_INT_CLOCK_MULTIPLIER, /* R/O: internal clock multiplier */
CPUINFO_INT_CLOCK_DIVIDER, /* R/O: internal clock divider */
CPUINFO_INT_MIN_INSTRUCTION_BYTES, /* R/O: minimum bytes per instruction */
CPUINFO_INT_MAX_INSTRUCTION_BYTES, /* R/O: maximum bytes per instruction */
CPUINFO_INT_MIN_CYCLES, /* R/O: minimum cycles for a single instruction */
CPUINFO_INT_MAX_CYCLES, /* R/O: maximum cycles for a single instruction */
CPUINFO_INT_SP, /* R/W: the current stack pointer value */
CPUINFO_INT_PC, /* R/W: the current PC value */
CPUINFO_INT_PREVIOUSPC, /* R/W: the previous PC value */
CPUINFO_INT_INPUT_STATE, /* R/W: states for each input line */
CPUINFO_INT_INPUT_STATE_LAST = CPUINFO_INT_INPUT_STATE + MAX_INPUT_LINES - 1,
CPUINFO_INT_OUTPUT_STATE, /* R/W: states for each output line */
CPUINFO_INT_OUTPUT_STATE_LAST = CPUINFO_INT_OUTPUT_STATE + MAX_OUTPUT_LINES - 1,
CPUINFO_INT_REGISTER, /* R/W: values of up to MAX_REGs registers */
CPUINFO_INT_REGISTER_LAST = CPUINFO_INT_REGISTER + MAX_REGS - 1,
CPUINFO_INT_DATABUS_WIDTH, /* R/O: data bus size for each address space (8,16,32,64) */
CPUINFO_INT_DATABUS_WIDTH_LAST = CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_ADDRBUS_WIDTH, /* R/O: address bus size for each address space (12-32) */
CPUINFO_INT_ADDRBUS_WIDTH_LAST = CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_ADDRBUS_SHIFT, /* R/O: shift applied to addresses each address space (+3 means >>3, -1 means <<1) */
CPUINFO_INT_ADDRBUS_SHIFT_LAST = CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACES - 1,
CPUINFO_INT_LOGADDR_WIDTH, /* R/O: address bus size for logical accesses in each space (0=same as physical) */
CPUINFO_INT_LOGADDR_WIDTH_LAST = CPUINFO_INT_LOGADDR_WIDTH + ADDRESS_SPACES - 1,
CPUINFO_INT_PAGE_SHIFT, /* R/O: size of a page log 2 (i.e., 12=4096), or 0 if paging not supported */
CPUINFO_INT_PAGE_SHIFT_LAST = CPUINFO_INT_PAGE_SHIFT + ADDRESS_SPACES - 1,
CPUINFO_INT_CPU_SPECIFIC = 0x08000, /* R/W: CPU-specific values start here */
CPUINFO_INT_SP, /* R/W: the current stack pointer value */
CPUINFO_INT_PC, /* R/W: the current PC value */
CPUINFO_INT_PREVIOUSPC, /* R/W: the previous PC value */
CPUINFO_INT_INPUT_STATE, /* R/W: states for each input line */
CPUINFO_INT_INPUT_STATE_LAST = CPUINFO_INT_INPUT_STATE + MAX_INPUT_LINES - 1,
CPUINFO_INT_OUTPUT_STATE, /* R/W: states for each output line */
CPUINFO_INT_OUTPUT_STATE_LAST = CPUINFO_INT_OUTPUT_STATE + MAX_OUTPUT_LINES - 1,
CPUINFO_INT_REGISTER, /* R/W: values of up to MAX_REGs registers */
CPUINFO_INT_REGISTER_LAST = CPUINFO_INT_REGISTER + MAX_REGS - 1,
CPUINFO_INT_CPU_SPECIFIC = 0x08000, /* R/W: CPU-specific values start here */
/* --- the following bits of info are returned as pointers to data or functions --- */
CPUINFO_PTR_FIRST = 0x10000,
CPUINFO_PTR_FIRST = DEVINFO_PTR_FIRST,
CPUINFO_PTR_SET_INFO = CPUINFO_PTR_FIRST, /* R/O: void (*set_info)(UINT32 state, INT64 data, void *ptr) */
CPUINFO_PTR_GET_CONTEXT, /* R/O: void (*get_context)(void *buffer) */
CPUINFO_PTR_SET_CONTEXT, /* R/O: void (*set_context)(void *buffer) */
CPUINFO_PTR_INIT, /* R/O: void (*init)(int index, int clock, int (*irqcallback)(const device_config *device, int)) */
CPUINFO_PTR_RESET, /* R/O: void (*reset)(void) */
CPUINFO_PTR_EXIT, /* R/O: void (*exit)(void) */
CPUINFO_PTR_EXECUTE, /* R/O: int (*execute)(int cycles) */
CPUINFO_PTR_BURN, /* R/O: void (*burn)(int cycles) */
CPUINFO_PTR_DISASSEMBLE, /* R/O: offs_t (*disassemble)(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram) */
CPUINFO_PTR_TRANSLATE, /* R/O: int (*translate)(int space, int intention, offs_t *address) */
CPUINFO_PTR_READ, /* R/O: int (*read)(int space, UINT32 offset, int size, UINT64 *value) */
CPUINFO_PTR_WRITE, /* R/O: int (*write)(int space, UINT32 offset, int size, UINT64 value) */
CPUINFO_PTR_READOP, /* R/O: int (*readop)(UINT32 offset, int size, UINT64 *value) */
CPUINFO_PTR_DEBUG_INIT, /* R/O: void (*debug_init)(void) */
CPUINFO_PTR_INSTRUCTION_COUNTER, /* R/O: int *icount */
CPUINFO_PTR_INTERNAL_MEMORY_MAP, /* R/O: const addrmap_token *map */
CPUINFO_PTR_INTERNAL_MEMORY_MAP_LAST = CPUINFO_PTR_INTERNAL_MEMORY_MAP + ADDRESS_SPACES - 1,
CPUINFO_PTR_DEBUG_REGISTER_LIST, /* R/O: int *list: list of registers for the debugger */
CPUINFO_PTR_VALIDITY_CHECK, /* R/O: int (*validity_check)(const void *config) */
/* CPU-specific additions */
CPUINFO_PTR_INSTRUCTION_COUNTER = DEVINFO_PTR_CLASS_SPECIFIC,
/* R/O: int *icount */
CPUINFO_PTR_INTERNAL_MEMORY_MAP, /* R/O: const addrmap_token *map */
CPUINFO_PTR_INTERNAL_MEMORY_MAP_LAST = CPUINFO_PTR_INTERNAL_MEMORY_MAP + ADDRESS_SPACES - 1,
CPUINFO_PTR_DEBUG_REGISTER_LIST, /* R/O: int *list: list of registers for the debugger */
CPUINFO_PTR_CPU_SPECIFIC = 0x18000, /* R/W: CPU-specific values start here */
CPUINFO_PTR_CPU_SPECIFIC = DEVINFO_PTR_DEVICE_SPECIFIC, /* R/W: CPU-specific values start here */
/* --- the following bits of info are returned as pointers to functions --- */
CPUINFO_FCT_FIRST = DEVINFO_FCT_FIRST,
/* CPU-specific additions */
CPUINFO_PTR_RESET = DEVINFO_FCT_RESET, /* R/O: void (*reset)(const device_config *device) */
CPUINFO_PTR_EXIT = DEVINFO_FCT_STOP, /* R/O: void (*exit)(const device_config *device) */
CPUINFO_PTR_SET_INFO = DEVINFO_FCT_CLASS_SPECIFIC, /* R/O: void (*set_info)(const device_config *device, UINT32 state, INT64 data, void *ptr) */
CPUINFO_PTR_GET_CONTEXT, /* R/O: void (*get_context)(void *buffer) */
CPUINFO_PTR_SET_CONTEXT, /* R/O: void (*set_context)(void *buffer) */
CPUINFO_PTR_INIT, /* R/O: void (*init)(const device_config *device, int index, int clock, int (*irqcallback)(const device_config *device, int)) */
CPUINFO_PTR_EXECUTE, /* R/O: int (*execute)(const device_config *device, int cycles) */
CPUINFO_PTR_BURN, /* R/O: void (*burn)(const device_config *device, int cycles) */
CPUINFO_PTR_DISASSEMBLE, /* R/O: offs_t (*disassemble)(const device_config *device, char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram) */
CPUINFO_PTR_TRANSLATE, /* R/O: int (*translate)(const device_config *device, int space, int intention, offs_t *address) */
CPUINFO_PTR_READ, /* R/O: int (*read)(const device_config *device, int space, UINT32 offset, int size, UINT64 *value) */
CPUINFO_PTR_WRITE, /* R/O: int (*write)(const device_config *device, int space, UINT32 offset, int size, UINT64 value) */
CPUINFO_PTR_READOP, /* R/O: int (*readop)(const device_config *device, UINT32 offset, int size, UINT64 *value) */
CPUINFO_PTR_DEBUG_INIT, /* R/O: void (*debug_init)(const device_config *device) */
CPUINFO_PTR_VALIDITY_CHECK, /* R/O: int (*validity_check)(const game_driver *driver, const void *config) */
/* --- the following bits of info are returned as NULL-terminated strings --- */
CPUINFO_STR_FIRST = 0x20000,
CPUINFO_STR_FIRST = DEVINFO_STR_FIRST,
CPUINFO_STR_NAME = CPUINFO_STR_FIRST, /* R/O: name of the CPU */
CPUINFO_STR_CORE_FAMILY, /* R/O: family of the CPU */
CPUINFO_STR_CORE_VERSION, /* R/O: version of the CPU core */
CPUINFO_STR_CORE_FILE, /* R/O: file containing the CPU core */
CPUINFO_STR_CORE_CREDITS, /* R/O: credits for the CPU core */
CPUINFO_STR_FLAGS, /* R/O: string representation of the main flags value */
CPUINFO_STR_REGISTER, /* R/O: string representation of up to MAX_REGs registers */
CPUINFO_STR_REGISTER_LAST = CPUINFO_STR_REGISTER + MAX_REGS - 1,
/* direct map to device data */
CPUINFO_STR_NAME = DEVINFO_STR_NAME, /* R/O: name of the CPU */
CPUINFO_STR_CORE_FAMILY = DEVINFO_STR_FAMILY, /* R/O: family of the CPU */
CPUINFO_STR_CORE_VERSION = DEVINFO_STR_VERSION, /* R/O: version of the CPU core */
CPUINFO_STR_CORE_FILE = DEVINFO_STR_SOURCE_FILE, /* R/O: file containing the CPU core */
CPUINFO_STR_CORE_CREDITS = DEVINFO_STR_CREDITS, /* R/O: credits for the CPU core */
CPUINFO_STR_CPU_SPECIFIC = 0x28000 /* R/W: CPU-specific values start here */
/* CPU-specific additions */
CPUINFO_STR_FLAGS = DEVINFO_STR_CLASS_SPECIFIC, /* R/O: string representation of the main flags value */
CPUINFO_STR_REGISTER, /* R/O: string representation of up to MAX_REGs registers */
CPUINFO_STR_REGISTER_LAST = CPUINFO_STR_REGISTER + MAX_REGS - 1,
CPUINFO_STR_CPU_SPECIFIC = DEVINFO_STR_DEVICE_SPECIFIC /* R/W: CPU-specific values start here */
};

2
src/emu/debug/debugcmd.c
View File

@ -140,7 +140,7 @@ void debug_command_init(running_machine *machine)
void *base;
/* stop when we run out of items */
name = state_save_get_indexed_item(itemnum, &base, &valsize, &valcount);
name = state_save_get_indexed_item(machine, itemnum, &base, &valsize, &valcount);
if (name == NULL)
break;

2
src/emu/debug/debugvw.c
View File

@ -2458,7 +2458,7 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
void *base;
/* stop when we run out of items */
name = state_save_get_indexed_item(itemnum, &base, &valsize, &valcount);
name = state_save_get_indexed_item(machine, itemnum, &base, &valsize, &valcount);
if (name == NULL)
break;

33
src/emu/devintrf.c
View File

@ -10,6 +10,7 @@
***************************************************************************/
#include "driver.h"
#include "cpuintrf.h"
@ -93,7 +94,7 @@ device_config *device_list_add(device_config **listheadptr, device_type type, co
/* find the end of the list, and ensure no duplicates along the way */
for (devptr = listheadptr; *devptr != NULL; devptr = &(*devptr)->next)
if (type == (*devptr)->type && strcmp(tag, (*devptr)->tag) == 0)
fatalerror("Attempted to add duplicate device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("Attempted to add duplicate device: type=%s tag=%s\n", devtype_get_name(type), tag);
/* get the size of the inline config */
configlen = (UINT32)devtype_get_info_int(type, DEVINFO_INT_INLINE_CONFIG_BYTES);
@ -164,7 +165,7 @@ void device_list_remove(device_config **listheadptr, device_type type, const cha
if (type == (*devptr)->type && strcmp(tag, (*devptr)->tag) == 0)
break;
if (*devptr == NULL)
fatalerror("Attempted to remove non-existant device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("Attempted to remove non-existant device: type=%s tag=%s\n", devtype_get_name(type), tag);
/* remove the device from the list */
device = *devptr;
@ -515,7 +516,7 @@ void device_list_start(running_machine *machine)
/* get the size of the token data */
tokenlen = (UINT32)devtype_get_info_int(device->type, DEVINFO_INT_TOKEN_BYTES);
if (tokenlen == 0)
fatalerror("Device %s specifies a 0 token length!\n", devtype_name(device->type));
fatalerror("Device %s specifies a 0 token length!\n", devtype_get_name(device->type));
/* allocate memory for the token */
device->token = malloc_or_die(tokenlen);
@ -626,7 +627,7 @@ void devtag_reset(running_machine *machine, device_type type, const char *tag)
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_reset failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_reset failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
device_reset(device);
}
@ -651,7 +652,7 @@ void *devtag_get_token(running_machine *machine, device_type type, const char *t
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_token failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_token failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device->token;
}
@ -671,7 +672,7 @@ const device_config *devtag_get_device(running_machine *machine, device_type typ
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_device failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_device failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device;
}
@ -692,7 +693,7 @@ const void *devtag_get_static_config(running_machine *machine, device_type type,
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_static_config failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_static_config failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device->static_config;
}
@ -713,7 +714,7 @@ const void *devtag_get_inline_config(running_machine *machine, device_type type,
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_inline_config failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_inline_config failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device->inline_config;
}
@ -750,7 +751,7 @@ INT64 devtag_get_info_int(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_info_int failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_info_int failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device_get_info_int(device, state);
}
@ -786,7 +787,7 @@ void *devtag_get_info_ptr(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_get_info_ptr failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_get_info_ptr failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device_get_info_ptr(device, state);
}
@ -822,7 +823,7 @@ genf *devtag_get_info_fct(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("device_get_info_fct failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("device_get_info_fct failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device_get_info_fct(device, state);
}
@ -858,7 +859,7 @@ const char *devtag_get_info_string(running_machine *machine, device_type type, c
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("device_get_info_string failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("device_get_info_string failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
return device_get_info_string(device, state);
}
@ -900,7 +901,7 @@ const char *devtype_get_info_string(device_type type, UINT32 state)
assert(type != NULL);
assert(state >= DEVINFO_STR_FIRST && state <= DEVINFO_STR_LAST);
/* retrieve the value */
info.s = get_temp_string_buffer();
(*type)(NULL, state, &info);
@ -944,7 +945,7 @@ void devtag_set_info_int(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_set_info_int failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_set_info_int failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
device_set_info_int(device, state, data);
}
@ -980,7 +981,7 @@ void devtag_set_info_ptr(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_set_info_ptr failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_set_info_ptr failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
device_set_info_ptr(device, state, data);
}
@ -1016,6 +1017,6 @@ void devtag_set_info_fct(running_machine *machine, device_type type, const char
device = device_list_find_by_tag(machine->config->devicelist, type, tag);
if (device == NULL)
fatalerror("devtag_set_info_fct failed to find device: type=%s tag=%s\n", devtype_name(type), tag);
fatalerror("devtag_set_info_fct failed to find device: type=%s tag=%s\n", devtype_get_name(type), tag);
device_set_info_fct(device, state, data);
}

21
src/emu/devintrf.h
View File

@ -60,6 +60,7 @@ enum
DEVINFO_INT_INLINE_CONFIG_BYTES, /* R/O: bytes to allocate for the inline configuration */
DEVINFO_INT_CLASS, /* R/O: the device's class */
DEVINFO_INT_CLASS_SPECIFIC = 0x04000, /* R/W: device-specific values start here */
DEVINFO_INT_DEVICE_SPECIFIC = 0x08000, /* R/W: device-specific values start here */
DEVINFO_INT_LAST = 0x0ffff,
@ -69,6 +70,7 @@ enum
DEVINFO_PTR_ROM_REGION = DEVINFO_PTR_FIRST, /* R/O: pointer to device-specific ROM region */
DEVINFO_PTR_MACHINE_CONFIG, /* R/O: pointer to device-specific machine config */
DEVINFO_PTR_CLASS_SPECIFIC = 0x14000, /* R/W: device-specific values start here */
DEVINFO_PTR_DEVICE_SPECIFIC = 0x18000, /* R/W: device-specific values start here */
DEVINFO_PTR_LAST = 0x1ffff,
@ -82,6 +84,7 @@ enum
DEVINFO_FCT_VALIDITY_CHECK, /* R/O: device_validity_check_func */
DEVINFO_FCT_NVRAM, /* R/O: device_nvram_func */
DEVINFO_FCT_CLASS_SPECIFIC = 0x24000, /* R/W: device-specific values start here */
DEVINFO_FCT_DEVICE_SPECIFIC = 0x28000, /* R/W: device-specific values start here */
DEVINFO_FCT_LAST = 0x2ffff,
@ -94,6 +97,7 @@ enum
DEVINFO_STR_SOURCE_FILE, /* R/O: file containing the device implementation */
DEVINFO_STR_CREDITS, /* R/O: credits for the device implementation */
DEVINFO_STR_CLASS_SPECIFIC = 0x34000, /* R/W: device-specific values start here */
DEVINFO_STR_DEVICE_SPECIFIC = 0x38000, /* R/W: device-specific values start here */
DEVINFO_STR_LAST = 0x3ffff
};
@ -341,12 +345,19 @@ void devtag_set_info_fct(running_machine *machine, device_type type, const char
INLINE FUNCTIONS
***************************************************************************/
/* return common strings based on device instances */
INLINE const char *device_get_name(const device_config *device) { return device_get_info_string(device, DEVINFO_STR_NAME); }
INLINE const char *device_get_family(const device_config *device) { return device_get_info_string(device, DEVINFO_STR_FAMILY); }
INLINE const char *device_get_version(const device_config *device) { return device_get_info_string(device, DEVINFO_STR_VERSION); }
INLINE const char *device_get_source_file(const device_config *device) { return device_get_info_string(device, DEVINFO_STR_SOURCE_FILE); }
INLINE const char *device_get_credits(const device_config *device) { return device_get_info_string(device, DEVINFO_STR_CREDITS); }
/* return common strings based on device types */
INLINE const char *devtype_name(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_NAME); }
INLINE const char *devtype_family(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_FAMILY); }
INLINE const char *devtype_version(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_VERSION); }
INLINE const char *devtype_source_file(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_SOURCE_FILE); }
INLINE const char *devtype_credits(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_CREDITS); }
INLINE const char *devtype_get_name(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_NAME); }
INLINE const char *devtype_get_family(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_FAMILY); }
INLINE const char *devtype_get_version(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_VERSION); }
INLINE const char *devtype_get_source_file(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_SOURCE_FILE); }
INLINE const char *devtype_get_credits(device_type devtype) { return devtype_get_info_string(devtype, DEVINFO_STR_CREDITS); }
#endif /* __DEVINTRF_H__ */

8
src/emu/emupal.c
View File

@ -148,8 +148,8 @@ void palette_init(running_machine *machine)
numcolors = palette_get_num_colors(machine->palette);
palette->save_pen = auto_malloc(sizeof(*palette->save_pen) * numcolors);
palette->save_bright = auto_malloc(sizeof(*palette->save_bright) * numcolors);
state_save_register_global_pointer(palette->save_pen, numcolors);
state_save_register_global_pointer(palette->save_bright, numcolors);
state_save_register_global_pointer(machine, palette->save_pen, numcolors);
state_save_register_global_pointer(machine, palette->save_bright, numcolors);
state_save_register_presave(machine, palette_presave, palette);
state_save_register_postload(machine, palette_postload, palette);
}
@ -342,13 +342,13 @@ colortable_t *colortable_alloc(running_machine *machine, UINT32 palettesize)
ctable->raw = auto_malloc(ctable->entries * sizeof(*ctable->raw));
for (index = 0; index < ctable->entries; index++)
ctable->raw[index] = index % ctable->palentries;
state_save_register_global_pointer(ctable->raw, ctable->entries);
state_save_register_global_pointer(machine, ctable->raw, ctable->entries);
/* allocate the palette */
ctable->palette = auto_malloc(ctable->palentries * sizeof(*ctable->palette));
for (index = 0; index < ctable->palentries; index++)
ctable->palette[index] = MAKE_ARGB(0x80,0xff,0xff,0xff);
state_save_register_global_pointer(ctable->palette, ctable->palentries);
state_save_register_global_pointer(machine, ctable->palette, ctable->palentries);
return ctable;
}

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

@ -166,38 +166,38 @@ static DEVICE_START( cia )
timer_pulse(device->machine, ATTOTIME_IN_HZ(intf->tod_clock), (void *) device, 0, cia_clock_tod_callback);
/* state save support */
state_save_register_item("6526cia", device->tag, 0, cia->port[0].ddr);
state_save_register_item("6526cia", device->tag, 0, cia->port[0].latch);
state_save_register_item("6526cia", device->tag, 0, cia->port[0].in);
state_save_register_item("6526cia", device->tag, 0, cia->port[0].out);
state_save_register_item("6526cia", device->tag, 0, cia->port[0].mask_value);
state_save_register_item("6526cia", device->tag, 0, cia->port[1].ddr);
state_save_register_item("6526cia", device->tag, 0, cia->port[1].latch);
state_save_register_item("6526cia", device->tag, 0, cia->port[1].in);
state_save_register_item("6526cia", device->tag, 0, cia->port[1].out);
state_save_register_item("6526cia", device->tag, 0, cia->port[1].mask_value);
state_save_register_item("6526cia", device->tag, 0, cia->timer[0].latch);
state_save_register_item("6526cia", device->tag, 0, cia->timer[0].count);
state_save_register_item("6526cia", device->tag, 0, cia->timer[0].mode);
state_save_register_item("6526cia", device->tag, 0, cia->timer[0].irq);
state_save_register_item("6526cia", device->tag, 0, cia->timer[1].latch);
state_save_register_item("6526cia", device->tag, 0, cia->timer[1].count);
state_save_register_item("6526cia", device->tag, 0, cia->timer[1].mode);
state_save_register_item("6526cia", device->tag, 0, cia->timer[1].irq);
state_save_register_item("6526cia", device->tag, 0, cia->tod);
state_save_register_item("6526cia", device->tag, 0, cia->tod_latch);
state_save_register_item("6526cia", device->tag, 0, cia->tod_latched);
state_save_register_item("6526cia", device->tag, 0, cia->tod_running);
state_save_register_item("6526cia", device->tag, 0, cia->alarm);
state_save_register_item("6526cia", device->tag, 0, cia->icr);
state_save_register_item("6526cia", device->tag, 0, cia->ics);
state_save_register_item("6526cia", device->tag, 0, cia->irq);
state_save_register_item("6526cia", device->tag, 0, cia->loaded);
state_save_register_item("6526cia", device->tag, 0, cia->sdr);
state_save_register_item("6526cia", device->tag, 0, cia->sp);
state_save_register_item("6526cia", device->tag, 0, cia->cnt);
state_save_register_item("6526cia", device->tag, 0, cia->shift);
state_save_register_item("6526cia", device->tag, 0, cia->serial);
state_save_register_device_item(device, 0, cia->port[0].ddr);
state_save_register_device_item(device, 0, cia->port[0].latch);
state_save_register_device_item(device, 0, cia->port[0].in);
state_save_register_device_item(device, 0, cia->port[0].out);
state_save_register_device_item(device, 0, cia->port[0].mask_value);
state_save_register_device_item(device, 0, cia->port[1].ddr);
state_save_register_device_item(device, 0, cia->port[1].latch);
state_save_register_device_item(device, 0, cia->port[1].in);
state_save_register_device_item(device, 0, cia->port[1].out);
state_save_register_device_item(device, 0, cia->port[1].mask_value);
state_save_register_device_item(device, 0, cia->timer[0].latch);
state_save_register_device_item(device, 0, cia->timer[0].count);
state_save_register_device_item(device, 0, cia->timer[0].mode);
state_save_register_device_item(device, 0, cia->timer[0].irq);
state_save_register_device_item(device, 0, cia->timer[1].latch);
state_save_register_device_item(device, 0, cia->timer[1].count);
state_save_register_device_item(device, 0, cia->timer[1].mode);
state_save_register_device_item(device, 0, cia->timer[1].irq);
state_save_register_device_item(device, 0, cia->tod);
state_save_register_device_item(device, 0, cia->tod_latch);
state_save_register_device_item(device, 0, cia->tod_latched);
state_save_register_device_item(device, 0, cia->tod_running);
state_save_register_device_item(device, 0, cia->alarm);
state_save_register_device_item(device, 0, cia->icr);
state_save_register_device_item(device, 0, cia->ics);
state_save_register_device_item(device, 0, cia->irq);
state_save_register_device_item(device, 0, cia->loaded);
state_save_register_device_item(device, 0, cia->sdr);
state_save_register_device_item(device, 0, cia->sp);
state_save_register_device_item(device, 0, cia->cnt);
state_save_register_device_item(device, 0, cia->shift);
state_save_register_device_item(device, 0, cia->serial);
return DEVICE_START_OK;
}

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

@ -449,21 +449,21 @@ static DEVICE_START( riot6532 )
riot->timer = timer_alloc(device->machine, timer_end_callback, (void *)device);
/* register for save states */
state_save_register_item("riot6532", device->tag, 0, riot->port[0].in);
state_save_register_item("riot6532", device->tag, 0, riot->port[0].out);
state_save_register_item("riot6532", device->tag, 0, riot->port[0].ddr);
state_save_register_item("riot6532", device->tag, 0, riot->port[1].in);
state_save_register_item("riot6532", device->tag, 0, riot->port[1].out);
state_save_register_item("riot6532", device->tag, 0, riot->port[1].ddr);
state_save_register_device_item(device, 0, riot->port[0].in);
state_save_register_device_item(device, 0, riot->port[0].out);
state_save_register_device_item(device, 0, riot->port[0].ddr);
state_save_register_device_item(device, 0, riot->port[1].in);
state_save_register_device_item(device, 0, riot->port[1].out);
state_save_register_device_item(device, 0, riot->port[1].ddr);
state_save_register_item("riot6532", device->tag, 0, riot->irqstate);
state_save_register_item("riot6532", device->tag, 0, riot->irqenable);
state_save_register_device_item(device, 0, riot->irqstate);
state_save_register_device_item(device, 0, riot->irqenable);
state_save_register_item("riot6532", device->tag, 0, riot->pa7dir);
state_save_register_item("riot6532", device->tag, 0, riot->pa7prev);
state_save_register_device_item(device, 0, riot->pa7dir);
state_save_register_device_item(device, 0, riot->pa7prev);
state_save_register_item("riot6532", device->tag, 0, riot->timershift);
state_save_register_item("riot6532", device->tag, 0, riot->timerstate);
state_save_register_device_item(device, 0, riot->timershift);
state_save_register_device_item(device, 0, riot->timerstate);
return DEVICE_START_OK;
}

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

@ -127,38 +127,38 @@ void pia_config(int which, const pia6821_interface *intf)
p->intf = intf;
state_save_register_item("6821pia", NULL, which, p->in_a);
state_save_register_item("6821pia", NULL, which, p->in_ca1);
state_save_register_item("6821pia", NULL, which, p->in_ca2);
state_save_register_item("6821pia", NULL, which, p->out_a);
state_save_register_item("6821pia", NULL, which, p->out_ca2);
state_save_register_item("6821pia", NULL, which, p->port_a_z_mask);
state_save_register_item("6821pia", NULL, which, p->ddr_a);
state_save_register_item("6821pia", NULL, which, p->ctl_a);
state_save_register_item("6821pia", NULL, which, p->irq_a1);
state_save_register_item("6821pia", NULL, which, p->irq_a2);
state_save_register_item("6821pia", NULL, which, p->irq_a_state);
state_save_register_item("6821pia", NULL, which, p->in_b);
state_save_register_item("6821pia", NULL, which, p->in_cb1);
state_save_register_item("6821pia", NULL, which, p->in_cb2);
state_save_register_item("6821pia", NULL, which, p->out_b);
state_save_register_item("6821pia", NULL, which, p->out_cb2);
state_save_register_item("6821pia", NULL, which, p->last_out_cb2_z);
state_save_register_item("6821pia", NULL, which, p->ddr_b);
state_save_register_item("6821pia", NULL, which, p->ctl_b);
state_save_register_item("6821pia", NULL, which, p->irq_b1);
state_save_register_item("6821pia", NULL, which, p->irq_b2);
state_save_register_item("6821pia", NULL, which, p->irq_b_state);
state_save_register_item("6821pia", NULL, which, p->in_a_pushed);
state_save_register_item("6821pia", NULL, which, p->out_a_needs_pulled);
state_save_register_item("6821pia", NULL, which, p->in_ca1_pushed);
state_save_register_item("6821pia", NULL, which, p->in_ca2_pushed);
state_save_register_item("6821pia", NULL, which, p->out_ca2_needs_pulled);
state_save_register_item("6821pia", NULL, which, p->in_b_pushed);
state_save_register_item("6821pia", NULL, which, p->out_b_needs_pulled);
state_save_register_item("6821pia", NULL, which, p->in_cb1_pushed);
state_save_register_item("6821pia", NULL, which, p->in_cb2_pushed);
state_save_register_item("6821pia", NULL, which, p->out_cb2_needs_pulled);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_a);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_ca1);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_ca2);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_a);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_ca2);
state_save_register_item(Machine, "6821pia", NULL, which, p->port_a_z_mask);
state_save_register_item(Machine, "6821pia", NULL, which, p->ddr_a);
state_save_register_item(Machine, "6821pia", NULL, which, p->ctl_a);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_a1);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_a2);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_a_state);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_b);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_cb1);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_cb2);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_b);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_cb2);
state_save_register_item(Machine, "6821pia", NULL, which, p->last_out_cb2_z);
state_save_register_item(Machine, "6821pia", NULL, which, p->ddr_b);
state_save_register_item(Machine, "6821pia", NULL, which, p->ctl_b);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_b1);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_b2);
state_save_register_item(Machine, "6821pia", NULL, which, p->irq_b_state);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_a_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_a_needs_pulled);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_ca1_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_ca2_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_ca2_needs_pulled);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_b_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_b_needs_pulled);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_cb1_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->in_cb2_pushed);
state_save_register_item(Machine, "6821pia", NULL, which, p->out_cb2_needs_pulled);
}

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

@ -402,25 +402,25 @@ void ptm6840_config(running_machine *machine, int which, const ptm6840_interface
timer_enable(ptm[which].timer[i], FALSE);
}
state_save_register_item("6840ptm", NULL, which, currptr->lsb_buffer);
state_save_register_item("6840ptm", NULL, which, currptr->msb_buffer);
state_save_register_item("6840ptm", NULL, which, currptr->status_read_since_int);
state_save_register_item("6840ptm", NULL, which, currptr->status_reg);
state_save_register_item("6840ptm", NULL, which, currptr->t3_divisor);
state_save_register_item("6840ptm", NULL, which, currptr->t3_scaler);
state_save_register_item("6840ptm", NULL, which, currptr->internal_clock);
state_save_register_item("6840ptm", NULL, which, currptr->IRQ);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->lsb_buffer);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->msb_buffer);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->status_read_since_int);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->status_reg);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->t3_divisor);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->t3_scaler);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->internal_clock);
state_save_register_item(machine, "6840ptm", NULL, which, currptr->IRQ);
state_save_register_item_array("6840ptm", NULL, which, currptr->control_reg);
state_save_register_item_array("6840ptm", NULL, which, currptr->output);
state_save_register_item_array("6840ptm", NULL, which, currptr->gate);
state_save_register_item_array("6840ptm", NULL, which, currptr->clock);
state_save_register_item_array("6840ptm", NULL, which, currptr->mode);
state_save_register_item_array("6840ptm", NULL, which, currptr->fired);
state_save_register_item_array("6840ptm", NULL, which, currptr->enabled);
state_save_register_item_array("6840ptm", NULL, which, currptr->external_clock);
state_save_register_item_array("6840ptm", NULL, which, currptr->counter);
state_save_register_item_array("6840ptm", NULL, which, currptr->latch);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->control_reg);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->output);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->gate);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->clock);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->mode);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->fired);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->enabled);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->external_clock);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->counter);
state_save_register_item_array(machine, "6840ptm", NULL, which, currptr->latch);
ptm6840_reset(which);
}

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

@ -234,29 +234,29 @@ static DEVICE_START( acia6850 )
timer_reset(acia_p->rx_timer, attotime_never);
timer_reset(acia_p->tx_timer, attotime_never);
state_save_register_item("acia6850", device->tag, 0, acia_p->ctrl);
state_save_register_item("acia6850", device->tag, 0, acia_p->status);
state_save_register_item("acia6850", device->tag, 0, acia_p->rx_clock);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_clock);
state_save_register_item("acia6850", device->tag, 0, acia_p->rx_counter);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_counter);
state_save_register_item("acia6850", device->tag, 0, acia_p->rx_shift);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_shift);
state_save_register_item("acia6850", device->tag, 0, acia_p->rdr);
state_save_register_item("acia6850", device->tag, 0, acia_p->tdr);
state_save_register_item("acia6850", device->tag, 0, acia_p->rx_bits);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_bits);
state_save_register_item("acia6850", device->tag, 0, acia_p->rx_parity);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_parity);
state_save_register_item("acia6850", device->tag, 0, acia_p->tx_int);
state_save_register_device_item(device, 0, acia_p->ctrl);
state_save_register_device_item(device, 0, acia_p->status);
state_save_register_device_item(device, 0, acia_p->rx_clock);
state_save_register_device_item(device, 0, acia_p->tx_clock);
state_save_register_device_item(device, 0, acia_p->rx_counter);
state_save_register_device_item(device, 0, acia_p->tx_counter);
state_save_register_device_item(device, 0, acia_p->rx_shift);
state_save_register_device_item(device, 0, acia_p->tx_shift);
state_save_register_device_item(device, 0, acia_p->rdr);
state_save_register_device_item(device, 0, acia_p->tdr);
state_save_register_device_item(device, 0, acia_p->rx_bits);
state_save_register_device_item(device, 0, acia_p->tx_bits);
state_save_register_device_item(device, 0, acia_p->rx_parity);
state_save_register_device_item(device, 0, acia_p->tx_parity);
state_save_register_device_item(device, 0, acia_p->tx_int);
state_save_register_item("acia6850", device->tag, 0, acia_p->divide);
state_save_register_item("acia6850", device->tag, 0, acia_p->overrun);
state_save_register_item("acia6850", device->tag, 0, acia_p->reset);
state_save_register_item("acia6850", device->tag, 0, acia_p->first_reset);
state_save_register_item("acia6850", device->tag, 0, acia_p->rts);
state_save_register_item("acia6850", device->tag, 0, acia_p->brk);
state_save_register_item("acia6850", device->tag, 0, acia_p->status_read);
state_save_register_device_item(device, 0, acia_p->divide);
state_save_register_device_item(device, 0, acia_p->overrun);
state_save_register_device_item(device, 0, acia_p->reset);
state_save_register_device_item(device, 0, acia_p->first_reset);
state_save_register_device_item(device, 0, acia_p->rts);
state_save_register_device_item(device, 0, acia_p->brk);
state_save_register_device_item(device, 0, acia_p->status_read);
return DEVICE_START_OK;
}

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

@ -542,45 +542,45 @@ static DEVICE_START(duart68681)
assert(device != NULL);
assert(device->tag != NULL);
state_save_register_item("DUART68681", device->tag, 0, duart68681->ACR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->IMR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->ISR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->IVR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->OPCR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->CTR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->IP_last_state);
state_save_register_device_item(device, 0, duart68681->ACR);
state_save_register_device_item(device, 0, duart68681->IMR);
state_save_register_device_item(device, 0, duart68681->ISR);
state_save_register_device_item(device, 0, duart68681->IVR);
state_save_register_device_item(device, 0, duart68681->OPCR);
state_save_register_device_item(device, 0, duart68681->CTR);
state_save_register_device_item(device, 0, duart68681->IP_last_state);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].CR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].CSR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR1);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR2);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].SR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].baud_rate);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_enabled);
state_save_register_item_array("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_read_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_write_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_num);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_enabled);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_data);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_ready);
state_save_register_device_item(device, 0, duart68681->channel[0].CR);
state_save_register_device_item(device, 0, duart68681->channel[0].CSR);
state_save_register_device_item(device, 0, duart68681->channel[0].MR1);
state_save_register_device_item(device, 0, duart68681->channel[0].MR2);
state_save_register_device_item(device, 0, duart68681->channel[0].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].SR);
state_save_register_device_item(device, 0, duart68681->channel[0].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[0].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_ready);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].CR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].CSR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR1);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR2);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].SR);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].baud_rate);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_enabled);
state_save_register_item_array("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_read_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_write_ptr);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_num);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_enabled);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_data);
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_ready);
state_save_register_device_item(device, 0, duart68681->channel[1].CR);
state_save_register_device_item(device, 0, duart68681->channel[1].CSR);
state_save_register_device_item(device, 0, duart68681->channel[1].MR1);
state_save_register_device_item(device, 0, duart68681->channel[1].MR2);
state_save_register_device_item(device, 0, duart68681->channel[1].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].SR);
state_save_register_device_item(device, 0, duart68681->channel[1].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[1].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_ready);
return DEVICE_START_OK;
}

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

@ -205,9 +205,9 @@ static DEVICE_START( ttl74123 )
chip->clear = chip->intf->clear;
/* register for state saving */
state_save_register_item("ttl74123", device->tag, 0, chip->a);
state_save_register_item("ttl74123", device->tag, 0, chip->b);
state_save_register_item("ttl74123", device->tag, 0, chip->clear);
state_save_register_device_item(device, 0, chip->a);
state_save_register_device_item(device, 0, chip->b);
state_save_register_device_item(device, 0, chip->clear);
return DEVICE_START_OK;
}

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

@ -39,9 +39,9 @@ void TTL74181_config(running_machine *machine, int which, void *intf)
c->dirty = 1;
state_save_register_item_array("TTL74181", NULL, which, c->inputs);
state_save_register_item_array("TTL74181", NULL, which, c->outputs);
state_save_register_item ("TTL74181", NULL, which, c->dirty);
state_save_register_item_array(machine, "TTL74181", NULL, which, c->inputs);
state_save_register_item_array(machine, "TTL74181", NULL, which, c->outputs);
state_save_register_item (machine, "TTL74181", NULL, which, c->dirty);
}

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

@ -38,6 +38,7 @@
*****************************************************************************/
#include "driver.h"
#include "deprecat.h"
#include "7474.h"
@ -161,13 +162,13 @@ void TTL7474_config(int which, const struct TTL7474_interface *intf)
chip->last_output = -1;
chip->last_output_comp = -1;
state_save_register_item("ttl7474", NULL, which, chip->clear);
state_save_register_item("ttl7474", NULL, which, chip->preset);
state_save_register_item("ttl7474", NULL, which, chip->clock);
state_save_register_item("ttl7474", NULL, which, chip->d);
state_save_register_item("ttl7474", NULL, which, chip->output);
state_save_register_item("ttl7474", NULL, which, chip->output_comp);
state_save_register_item("ttl7474", NULL, which, chip->last_clock);
state_save_register_item("ttl7474", NULL, which, chip->last_output);
state_save_register_item("ttl7474", NULL, which, chip->last_output_comp);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->clear);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->preset);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->clock);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->d);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->output);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->output_comp);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->last_clock);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->last_output);
state_save_register_item(Machine, "ttl7474", NULL, which, chip->last_output_comp);
}

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

@ -518,22 +518,22 @@ static DEVICE_START( ppi8255 ) {
ppi8255->port_write[2] = ppi8255->intf->port_c_write;
/* register for state saving */
state_save_register_item("ppi8255", device->tag, 0, ppi8255->group_a_mode);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->group_b_mode);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_a_dir);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_b_dir);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_ch_dir);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_cl_dir);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->obf_a);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->obf_b);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->ibf_a);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->ibf_b);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->inte_a);
state_save_register_item("ppi8255", device->tag, 0, ppi8255->inte_b);
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->in_mask);
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->out_mask);
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->read);
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->latch);
state_save_register_device_item(device, 0, ppi8255->group_a_mode);
state_save_register_device_item(device, 0, ppi8255->group_b_mode);
state_save_register_device_item(device, 0, ppi8255->port_a_dir);
state_save_register_device_item(device, 0, ppi8255->port_b_dir);
state_save_register_device_item(device, 0, ppi8255->port_ch_dir);
state_save_register_device_item(device, 0, ppi8255->port_cl_dir);
state_save_register_device_item(device, 0, ppi8255->obf_a);
state_save_register_device_item(device, 0, ppi8255->obf_b);
state_save_register_device_item(device, 0, ppi8255->ibf_a);
state_save_register_device_item(device, 0, ppi8255->ibf_b);
state_save_register_device_item(device, 0, ppi8255->inte_a);
state_save_register_device_item(device, 0, ppi8255->inte_b);
state_save_register_device_item_array(device, 0, ppi8255->in_mask);
state_save_register_device_item_array(device, 0, ppi8255->out_mask);
state_save_register_device_item_array(device, 0, ppi8255->read);
state_save_register_device_item_array(device, 0, ppi8255->latch);
return DEVICE_START_OK;
}

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

@ -374,16 +374,16 @@ static DEVICE_START( dma8257 )
dma8257->timer = timer_alloc(device->machine, dma8257_timerproc, (void *) device);
dma8257->msbflip_timer = timer_alloc(device->machine, dma8257_msbflip_timerproc, (void *) device);
state_save_register_item_array("dma8257", device->tag, 0, dma8257->address);
state_save_register_item_array("dma8257", device->tag, 0, dma8257->count);
state_save_register_item_array("dma8257", device->tag, 0, dma8257->rwmode);
state_save_register_item_array("dma8257", device->tag, 0, dma8257->registers);
state_save_register_device_item_array(device, 0, dma8257->address);
state_save_register_device_item_array(device, 0, dma8257->count);
state_save_register_device_item_array(device, 0, dma8257->rwmode);
state_save_register_device_item_array(device, 0, dma8257->registers);
state_save_register_item("dma8257", device->tag, 0, dma8257->mode);
state_save_register_item("dma8257", device->tag, 0, dma8257->rr);
state_save_register_item("dma8257", device->tag, 0, dma8257->msb);
state_save_register_item("dma8257", device->tag, 0, dma8257->drq);
state_save_register_item("dma8257", device->tag, 0, dma8257->status);
state_save_register_device_item(device, 0, dma8257->mode);
state_save_register_device_item(device, 0, dma8257->rr);
state_save_register_device_item(device, 0, dma8257->msb);
state_save_register_device_item(device, 0, dma8257->drq);
state_save_register_device_item(device, 0, dma8257->status);
return DEVICE_START_OK;
}

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

@ -114,19 +114,19 @@ void adc083x_init( int chip, int type, double (*input_callback)(int input) )
break;
}
state_save_register_item( "adc083x", NULL, chip, c->CS );
state_save_register_item( "adc083x", NULL, chip, c->CLK );
state_save_register_item( "adc083x", NULL, chip, c->DI );
state_save_register_item( "adc083x", NULL, chip, c->SE );
state_save_register_item( "adc083x", NULL, chip, c->SARS );
state_save_register_item( "adc083x", NULL, chip, c->DO );
state_save_register_item( "adc083x", NULL, chip, c->SGL );
state_save_register_item( "adc083x", NULL, chip, c->ODD );
state_save_register_item( "adc083x", NULL, chip, c->SEL1 );
state_save_register_item( "adc083x", NULL, chip, c->SEL0 );
state_save_register_item( "adc083x", NULL, chip, c->state );
state_save_register_item( "adc083x", NULL, chip, c->bit );
state_save_register_item( "adc083x", NULL, chip, c->output );
state_save_register_item( Machine, "adc083x", NULL, chip, c->CS );
state_save_register_item( Machine, "adc083x", NULL, chip, c->CLK );
state_save_register_item( Machine, "adc083x", NULL, chip, c->DI );
state_save_register_item( Machine, "adc083x", NULL, chip, c->SE );
state_save_register_item( Machine, "adc083x", NULL, chip, c->SARS );
state_save_register_item( Machine, "adc083x", NULL, chip, c->DO );
state_save_register_item( Machine, "adc083x", NULL, chip, c->SGL );
state_save_register_item( Machine, "adc083x", NULL, chip, c->ODD );
state_save_register_item( Machine, "adc083x", NULL, chip, c->SEL1 );
state_save_register_item( Machine, "adc083x", NULL, chip, c->SEL0 );
state_save_register_item( Machine, "adc083x", NULL, chip, c->state );
state_save_register_item( Machine, "adc083x", NULL, chip, c->bit );
state_save_register_item( Machine, "adc083x", NULL, chip, c->output );
}
void adc083x_cs_write( int chip, int cs )

11
src/emu/machine/am53cf96.c
View File

@ -10,6 +10,7 @@
*/
#include "driver.h"
#include "deprecat.h"
#include "am53cf96.h"
static UINT8 scsi_regs[32], fifo[16], fptr = 0, xfer_state, last_id;
@ -224,11 +225,11 @@ void am53cf96_init( const struct AM53CF96interface *interface )
SCSIAllocInstance( interface->scsidevs->devices[i].scsiClass, &devices[interface->scsidevs->devices[i].scsiID], interface->scsidevs->devices[i].diskregion );
}
state_save_register_global_array(scsi_regs);
state_save_register_global_array(fifo);
state_save_register_global(fptr);
state_save_register_global(xfer_state);
state_save_register_global(last_id);
state_save_register_global_array(Machine, scsi_regs);
state_save_register_global_array(Machine, fifo);
state_save_register_global(Machine, fptr);
state_save_register_global(Machine, xfer_state);
state_save_register_global(Machine, last_id);
}
void am53cf96_exit( const struct AM53CF96interface *interface )

10
src/emu/machine/at28c16.c
View File

@ -147,11 +147,11 @@ static DEVICE_START(at28c16)
}
/* create the name for save states */
state_save_register_item_pointer( "at28c16", device->tag, 0, c->data, SIZE_DATA );
state_save_register_item_pointer( "at28c16", device->tag, 0, c->id, SIZE_ID );
state_save_register_item( "at28c16", device->tag, 0, c->a9_12v );
state_save_register_item( "at28c16", device->tag, 0, c->oe_12v );
state_save_register_item( "at28c16", device->tag, 0, c->last_write );
state_save_register_device_item_pointer( device, 0, c->data, SIZE_DATA );
state_save_register_device_item_pointer( device, 0, c->id, SIZE_ID );
state_save_register_device_item( device, 0, c->a9_12v );
state_save_register_device_item( device, 0, c->oe_12v );
state_save_register_device_item( device, 0, c->last_write );
return DEVICE_START_OK;
}

10
src/emu/machine/cdp1852.c
View File

@ -147,11 +147,11 @@ static DEVICE_START( cdp1852 )
}
/* register for state saving */
state_save_register_item("cdp1852", device->tag, 0, cdp1852->new_data);
state_save_register_item("cdp1852", device->tag, 0, cdp1852->data);
state_save_register_item("cdp1852", device->tag, 0, cdp1852->next_data);
state_save_register_item("cdp1852", device->tag, 0, cdp1852->sr);
state_save_register_item("cdp1852", device->tag, 0, cdp1852->next_sr);
state_save_register_device_item(device, 0, cdp1852->new_data);
state_save_register_device_item(device, 0, cdp1852->data);
state_save_register_device_item(device, 0, cdp1852->next_data);
state_save_register_device_item(device, 0, cdp1852->sr);
state_save_register_device_item(device, 0, cdp1852->next_sr);
return DEVICE_START_OK;
}

7
src/emu/machine/cr589.c
View File

@ -4,6 +4,7 @@
*/
#include "driver.h"
#include "deprecat.h"
#include "cr589.h"
typedef struct
@ -115,9 +116,9 @@ static void cr589_alloc_instance( SCSIInstance *scsiInstance, const char *diskre
our_this->download = 0;
memcpy( &our_this->buffer[ identity_offset ], "MATSHITACD-ROM CR-589 GS0N", 28 );
state_save_register_item( "cr589", diskregion, 0, our_this->download );
state_save_register_item_array( "cr589", diskregion, 0, our_this->buffer );
state_save_register_item( "cr589", diskregion, 0, our_this->bufferOffset );
state_save_register_item( Machine, "cr589", diskregion, 0, our_this->download );
state_save_register_item_array( Machine, "cr589", diskregion, 0, our_this->buffer );
state_save_register_item( Machine, "cr589", diskregion, 0, our_this->bufferOffset );
}
static int cr589_dispatch( int operation, void *file, INT64 intparm, void *ptrparm )

12
src/emu/machine/ds2401.c
View File

@ -156,12 +156,12 @@ void ds2401_init( int which, const UINT8 *data )
c->t_pdh = ATTOTIME_IN_USEC( 15 );
c->t_pdl = ATTOTIME_IN_USEC( 60 );
state_save_register_item( "ds2401", NULL, which, c->state );
state_save_register_item( "ds2401", NULL, which, c->bit );
state_save_register_item( "ds2401", NULL, which, c->byte );
state_save_register_item( "ds2401", NULL, which, c->shift );
state_save_register_item( "ds2401", NULL, which, c->rx );
state_save_register_item( "ds2401", NULL, which, c->tx );
state_save_register_item(Machine, "ds2401", NULL, which, c->state );
state_save_register_item(Machine, "ds2401", NULL, which, c->bit );
state_save_register_item(Machine, "ds2401", NULL, which, c->byte );
state_save_register_item(Machine, "ds2401", NULL, which, c->shift );
state_save_register_item(Machine, "ds2401", NULL, which, c->rx );
state_save_register_item(Machine, "ds2401", NULL, which, c->tx );
c->timer = timer_alloc(Machine, ds2401_tick , NULL);
c->reset_timer = timer_alloc(Machine, ds2401_reset , NULL);

23
src/emu/machine/eeprom.c
View File

@ -1,4 +1,5 @@
#include "driver.h"
#include "deprecat.h"
#include "eeprom.h"
#define VERBOSE 0
@ -146,17 +147,17 @@ void eeprom_init(const eeprom_interface *interface)
if (intf->cmd_unlock) locked = 1;
else locked = 0;
state_save_register_global_array(eeprom_data);
state_save_register_global_array(serial_buffer);
state_save_register_global(clock_line);
state_save_register_global(reset_line);
state_save_register_global(locked);
state_save_register_global(serial_count);
state_save_register_global(latch);
state_save_register_global(reset_delay);
state_save_register_global(eeprom_clock_count);
state_save_register_global(eeprom_data_bits);
state_save_register_global(eeprom_read_address);
state_save_register_global_array(Machine, eeprom_data);
state_save_register_global_array(Machine, serial_buffer);
state_save_register_global(Machine, clock_line);
state_save_register_global(Machine, reset_line);
state_save_register_global(Machine, locked);
state_save_register_global(Machine, serial_count);
state_save_register_global(Machine, latch);
state_save_register_global(Machine, reset_delay);
state_save_register_global(Machine, eeprom_clock_count);
state_save_register_global(Machine, eeprom_data_bits);
state_save_register_global(Machine, eeprom_read_address);
}
static void eeprom_write(int bit)

10
src/emu/machine/generic.c
View File

@ -72,9 +72,9 @@ void generic_machine_init(running_machine *machine)
}
/* register coin save state */
state_save_register_item_array("coin", NULL, 0, coin_count);
state_save_register_item_array("coin", NULL, 0, coinlockedout);
state_save_register_item_array("coin", NULL, 0, lastcoin);
state_save_register_item_array(machine, "coin", NULL, 0, coin_count);
state_save_register_item_array(machine, "coin", NULL, 0, coinlockedout);
state_save_register_item_array(machine, "coin", NULL, 0, lastcoin);
/* reset NVRAM size and pointers */
generic_nvram_size = 0;
@ -87,7 +87,7 @@ void generic_machine_init(running_machine *machine)
/* register a reset callback and save state for interrupt enable */
add_reset_callback(machine, interrupt_reset);
state_save_register_item_array("cpu", NULL, 0, interrupt_enable);
state_save_register_item_array(machine, "cpu", NULL, 0, interrupt_enable);
/* register for configuration */
config_register(machine, "counters", counters_load, counters_save);
@ -95,7 +95,7 @@ void generic_machine_init(running_machine *machine)
/* for memory cards, request save state and an exit callback */
if (machine->config->memcard_handler != NULL)
{
state_save_register_global(memcard_inserted);
state_save_register_global(machine, memcard_inserted);
add_exit_callback(machine, memcard_eject);
}
}

26
src/emu/machine/i2cmem.c
View File

@ -121,19 +121,19 @@ void i2cmem_init( int chip, int slave_address, int page_size, int data_size, uns
c->data = data;
c->page = page;
state_save_register_item( "i2cmem", NULL, chip, c->scl );
state_save_register_item( "i2cmem", NULL, chip, c->sdaw );
state_save_register_item( "i2cmem", NULL, chip, c->e0 );
state_save_register_item( "i2cmem", NULL, chip, c->e1 );
state_save_register_item( "i2cmem", NULL, chip, c->e2 );
state_save_register_item( "i2cmem", NULL, chip, c->wc );
state_save_register_item( "i2cmem", NULL, chip, c->sdar );
state_save_register_item( "i2cmem", NULL, chip, c->state );
state_save_register_item( "i2cmem", NULL, chip, c->bits );
state_save_register_item( "i2cmem", NULL, chip, c->shift );
state_save_register_item( "i2cmem", NULL, chip, c->devsel );
state_save_register_item( "i2cmem", NULL, chip, c->byteaddr );
state_save_register_item_pointer( "i2cmem", NULL, chip, c->data, c->data_size );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->scl );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->sdaw );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->e0 );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->e1 );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->e2 );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->wc );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->sdar );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->state );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->bits );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->shift );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->devsel );
state_save_register_item( Machine, "i2cmem", NULL, chip, c->byteaddr );
state_save_register_item_pointer( Machine, "i2cmem", NULL, chip, c->data, c->data_size );
}
static int select_device( struct i2cmem_chip *c )

70
src/emu/machine/idectrl.c
View File

@ -1709,50 +1709,50 @@ static DEVICE_START( ide_controller )
ide->reset_timer = timer_alloc(device->machine, reset_callback, (void *)device);
/* register ide states */
state_save_register_item("ide_controller", device->tag, 0, ide->adapter_control);
state_save_register_item("ide_controller", device->tag, 0, ide->status);
state_save_register_item("ide_controller", device->tag, 0, ide->error);
state_save_register_item("ide_controller", device->tag, 0, ide->command);
state_save_register_item("ide_controller", device->tag, 0, ide->interrupt_pending);
state_save_register_item("ide_controller", device->tag, 0, ide->precomp_offset);
state_save_register_device_item(device, 0, ide->adapter_control);
state_save_register_device_item(device, 0, ide->status);
state_save_register_device_item(device, 0, ide->error);
state_save_register_device_item(device, 0, ide->command);
state_save_register_device_item(device, 0, ide->interrupt_pending);
state_save_register_device_item(device, 0, ide->precomp_offset);
state_save_register_item_array("ide_controller", device->tag, 0, ide->buffer);
state_save_register_item_array("ide_controller", device->tag, 0, ide->features);
state_save_register_item("ide_controller", device->tag, 0, ide->buffer_offset);
state_save_register_item("ide_controller", device->tag, 0, ide->sector_count);
state_save_register_device_item_array(device, 0, ide->buffer);
state_save_register_device_item_array(device, 0, ide->features);
state_save_register_device_item(device, 0, ide->buffer_offset);
state_save_register_device_item(device, 0, ide->sector_count);
state_save_register_item("ide_controller", device->tag, 0, ide->block_count);
state_save_register_item("ide_controller", device->tag, 0, ide->sectors_until_int);
state_save_register_device_item(device, 0, ide->block_count);
state_save_register_device_item(device, 0, ide->sectors_until_int);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_active);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_cpu);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_address_xor);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_last_buffer);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_address);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_descriptor);
state_save_register_item("ide_controller", device->tag, 0, ide->dma_bytes_left);
state_save_register_device_item(device, 0, ide->dma_active);
state_save_register_device_item(device, 0, ide->dma_cpu);
state_save_register_device_item(device, 0, ide->dma_address_xor);
state_save_register_device_item(device, 0, ide->dma_last_buffer);
state_save_register_device_item(device, 0, ide->dma_address);
state_save_register_device_item(device, 0, ide->dma_descriptor);
state_save_register_device_item(device, 0, ide->dma_bytes_left);
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_command);
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_status);
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_descriptor);
state_save_register_device_item(device, 0, ide->bus_master_command);
state_save_register_device_item(device, 0, ide->bus_master_status);
state_save_register_device_item(device, 0, ide->bus_master_descriptor);
state_save_register_item("ide_controller", device->tag, 0, ide->cur_cylinder);
state_save_register_item("ide_controller", device->tag, 0, ide->cur_sector);
state_save_register_item("ide_controller", device->tag, 0, ide->cur_head);
state_save_register_item("ide_controller", device->tag, 0, ide->cur_head_reg);
state_save_register_device_item(device, 0, ide->cur_cylinder);
state_save_register_device_item(device, 0, ide->cur_sector);
state_save_register_device_item(device, 0, ide->cur_head);
state_save_register_device_item(device, 0, ide->cur_head_reg);
state_save_register_item("ide_controller", device->tag, 0, ide->cur_lba);
state_save_register_device_item(device, 0, ide->cur_lba);
state_save_register_item("ide_controller", device->tag, 0, ide->num_cylinders);
state_save_register_item("ide_controller", device->tag, 0, ide->num_sectors);
state_save_register_item("ide_controller", device->tag, 0, ide->num_heads);
state_save_register_device_item(device, 0, ide->num_cylinders);
state_save_register_device_item(device, 0, ide->num_sectors);
state_save_register_device_item(device, 0, ide->num_heads);
state_save_register_item("ide_controller", device->tag, 0, ide->config_unknown);
state_save_register_item_array("ide_controller", device->tag, 0, ide->config_register);
state_save_register_item("ide_controller", device->tag, 0, ide->config_register_num);
state_save_register_device_item(device, 0, ide->config_unknown);
state_save_register_device_item_array(device, 0, ide->config_register);
state_save_register_device_item(device, 0, ide->config_register_num);
state_save_register_item("ide_controller", device->tag, 0, ide->master_password_enable);
state_save_register_item("ide_controller", device->tag, 0, ide->user_password_enable);
state_save_register_device_item(device, 0, ide->master_password_enable);
state_save_register_device_item(device, 0, ide->user_password_enable);
return DEVICE_START_OK;
}

8
src/emu/machine/intelfsh.c
View File

@ -135,10 +135,10 @@ void intelflash_init(int chip, int type, void *data)
c->timer = timer_alloc(Machine, erase_finished, c);
c->flash_memory = data;
state_save_register_item( "intelfsh", NULL, chip, c->status );
state_save_register_item( "intelfsh", NULL, chip, c->flash_mode );
state_save_register_item( "intelfsh", NULL, chip, c->flash_master_lock );
state_save_register_memory( "intelfsh", NULL, chip, "flash_memory", c->flash_memory, c->bits/8, c->size / (c->bits/8) );
state_save_register_item( Machine, "intelfsh", NULL, chip, c->status );
state_save_register_item( Machine, "intelfsh", NULL, chip, c->flash_mode );
state_save_register_item( Machine, "intelfsh", NULL, chip, c->flash_master_lock );
state_save_register_memory( Machine, "intelfsh", NULL, chip, "flash_memory", c->flash_memory, c->bits/8, c->size / (c->bits/8) );
}
UINT32 intelflash_read(int chip, UINT32 address)

2
src/emu/machine/latch8.c
View File

@ -221,7 +221,7 @@ static DEVICE_START( latch8 )
latch8->has_read = 1;
}
state_save_register_item("latch8", device->tag, 0, latch8->value);
state_save_register_device_item(device, 0, latch8->value);
return DEVICE_START_OK;
}

2
src/emu/machine/mb3773.c
View File

@ -36,5 +36,5 @@ void mb3773_init( void )
{
watchdog_timer = timer_alloc(Machine, watchdog_timeout, NULL);
reset_timer();
state_save_register_global( ck );
state_save_register_global(Machine, ck );
}

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

@ -120,18 +120,18 @@ void microtouch_init(void (*tx_cb)(UINT8 data),
microtouch.timer = timer_alloc(Machine, microtouch_timer_callback, NULL);
timer_adjust_periodic(microtouch.timer, ATTOTIME_IN_HZ(167*5), 0, ATTOTIME_IN_HZ(167*5));
state_save_register_item("microtouch", NULL, 0, microtouch.reset_done);
state_save_register_item("microtouch", NULL, 0, microtouch.format_tablet);
state_save_register_item("microtouch", NULL, 0, microtouch.mode_inactive);
state_save_register_item("microtouch", NULL, 0, microtouch.mode_stream);
state_save_register_item("microtouch", NULL, 0, microtouch.last_touch_state);
state_save_register_item("microtouch", NULL, 0, microtouch.last_x);
state_save_register_item("microtouch", NULL, 0, microtouch.last_y);
state_save_register_item_array("microtouch", NULL, 0, microtouch.rx_buffer);
state_save_register_item("microtouch", NULL, 0, microtouch.rx_buffer_ptr);
state_save_register_item_array("microtouch", NULL, 0, microtouch.tx_buffer);
state_save_register_item("microtouch", NULL, 0, microtouch.tx_buffer_num);
state_save_register_item("microtouch", NULL, 0, microtouch.tx_buffer_ptr);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.reset_done);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.format_tablet);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.mode_inactive);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.mode_stream);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.last_touch_state);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.last_x);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.last_y);
state_save_register_item_array(Machine, "microtouch", NULL, 0, microtouch.rx_buffer);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.rx_buffer_ptr);
state_save_register_item_array(Machine, "microtouch", NULL, 0, microtouch.tx_buffer);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.tx_buffer_num);
state_save_register_item(Machine, "microtouch", NULL, 0, microtouch.tx_buffer_ptr);
};

39
src/emu/machine/pd4990a.c
View File

@ -31,6 +31,7 @@
*/
#include "driver.h"
#include "deprecat.h"
#include "machine/pd4990a.h"
@ -342,27 +343,27 @@ void pd4990a_init(void)
clock_line = 0;
command_line =0;
state_save_register_item("pd4990a", NULL, 0, pd4990a.seconds);
state_save_register_item("pd4990a", NULL, 0, pd4990a.minutes);
state_save_register_item("pd4990a", NULL, 0, pd4990a.hours);
state_save_register_item("pd4990a", NULL, 0, pd4990a.days);
state_save_register_item("pd4990a", NULL, 0, pd4990a.month);
state_save_register_item("pd4990a", NULL, 0, pd4990a.year);
state_save_register_item("pd4990a", NULL, 0, pd4990a.weekday);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.seconds);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.minutes);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.hours);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.days);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.month);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.year);
state_save_register_item(Machine, "pd4990a", NULL, 0, pd4990a.weekday);
state_save_register_item("pd4990a", NULL, 0, shiftlo);
state_save_register_item("pd4990a", NULL, 0, shifthi);
state_save_register_item(Machine, "pd4990a", NULL, 0, shiftlo);
state_save_register_item(Machine, "pd4990a", NULL, 0, shifthi);
state_save_register_item("pd4990a", NULL, 0, retraces);
state_save_register_item("pd4990a", NULL, 0, testwaits);
state_save_register_item("pd4990a", NULL, 0, maxwaits);
state_save_register_item("pd4990a", NULL, 0, testbit);
state_save_register_item(Machine, "pd4990a", NULL, 0, retraces);
state_save_register_item(Machine, "pd4990a", NULL, 0, testwaits);
state_save_register_item(Machine, "pd4990a", NULL, 0, maxwaits);
state_save_register_item(Machine, "pd4990a", NULL, 0, testbit);
state_save_register_item("pd4990a", NULL, 0, outputbit);
state_save_register_item("pd4990a", NULL, 0, bitno);
state_save_register_item("pd4990a", NULL, 0, reading);
state_save_register_item("pd4990a", NULL, 0, writting);
state_save_register_item(Machine, "pd4990a", NULL, 0, outputbit);
state_save_register_item(Machine, "pd4990a", NULL, 0, bitno);
state_save_register_item(Machine, "pd4990a", NULL, 0, reading);
state_save_register_item(Machine, "pd4990a", NULL, 0, writting);
state_save_register_item("pd4990a", NULL, 0, clock_line);
state_save_register_item("pd4990a", NULL, 0, command_line);
state_save_register_item(Machine, "pd4990a", NULL, 0, clock_line);
state_save_register_item(Machine, "pd4990a", NULL, 0, command_line);
}

40
src/emu/machine/pit8253.c
View File

@ -1063,26 +1063,26 @@ static device_start_err common_start( const device_config *device, int device_ty
timer_adjust_oneshot(timer->updatetimer, attotime_never, timerno);
/* set up state save values */
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->clockin);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->control);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->status);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->lowcount);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latch);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->count);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->value);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->wmsb);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->rmsb);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->output);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->gate);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latched_count);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latched_status);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->null_count);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->phase);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->cycles_to_output);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->last_updated.seconds);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->last_updated.attoseconds);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->programmed);
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->clock);
state_save_register_device_item(device, timerno, timer->clockin);
state_save_register_device_item(device, timerno, timer->control);
state_save_register_device_item(device, timerno, timer->status);
state_save_register_device_item(device, timerno, timer->lowcount);
state_save_register_device_item(device, timerno, timer->latch);
state_save_register_device_item(device, timerno, timer->count);
state_save_register_device_item(device, timerno, timer->value);
state_save_register_device_item(device, timerno, timer->wmsb);
state_save_register_device_item(device, timerno, timer->rmsb);
state_save_register_device_item(device, timerno, timer->output);
state_save_register_device_item(device, timerno, timer->gate);
state_save_register_device_item(device, timerno, timer->latched_count);
state_save_register_device_item(device, timerno, timer->latched_status);
state_save_register_device_item(device, timerno, timer->null_count);
state_save_register_device_item(device, timerno, timer->phase);
state_save_register_device_item(device, timerno, timer->cycles_to_output);
state_save_register_device_item(device, timerno, timer->last_updated.seconds);
state_save_register_device_item(device, timerno, timer->last_updated.attoseconds);
state_save_register_device_item(device, timerno, timer->programmed);
state_save_register_device_item(device, timerno, timer->clock);
}
return DEVICE_START_OK;

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

@ -4,14 +4,14 @@
***************************************************************************/
#include "state.h"
#include "scsidev.h"
#include "cdrom.h"
#include "sound/cdda.h"
#include "state.h"
#ifdef MESS
#include "devices/chd_cd.h"
#include "deprecat.h"
#endif
#include "deprecat.h"
#include "scsicd.h"
typedef struct
@ -683,13 +683,13 @@ static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskr
our_this->cur_subblock = 0;
our_this->play_err_flag = 0;
state_save_register_item( "scsicd", diskregion, 0, our_this->lba );
state_save_register_item( "scsicd", diskregion, 0, our_this->blocks );
state_save_register_item( "scsicd", diskregion, 0, our_this->last_lba );
state_save_register_item( "scsicd", diskregion, 0, our_this->bytes_per_sector );
state_save_register_item( "scsicd", diskregion, 0, our_this->num_subblocks );
state_save_register_item( "scsicd", diskregion, 0, our_this->cur_subblock );
state_save_register_item( "scsicd", diskregion, 0, our_this->play_err_flag );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->lba );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->blocks );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->last_lba );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->bytes_per_sector );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->num_subblocks );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->cur_subblock );
state_save_register_item( Machine, "scsicd", diskregion, 0, our_this->play_err_flag );
#ifdef MESS
/* TODO: get rid of this ifdef MESS section */

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

@ -102,9 +102,9 @@ static void scsidev_alloc_instance( SCSIInstance *scsiInstance, const char *disk
{
SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
state_save_register_item_array( "scsidev", diskregion, 0, our_this->command );
state_save_register_item( "scsidev", diskregion, 0, our_this->commandLength );
state_save_register_item( "scsidev", diskregion, 0, our_this->phase );
state_save_register_item_array( Machine, "scsidev", diskregion, 0, our_this->command );
state_save_register_item( Machine, "scsidev", diskregion, 0, our_this->commandLength );
state_save_register_item( Machine, "scsidev", diskregion, 0, our_this->phase );
}
static int scsidev_dispatch( int operation, void *file, INT64 intparm, void *ptrparm )

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

@ -10,8 +10,8 @@
#ifdef MESS
#include "devices/harddriv.h"
#include "deprecat.h"
#endif
#include "deprecat.h"
#include "scsihd.h"
typedef struct
@ -230,8 +230,8 @@ static void scsihd_alloc_instance( SCSIInstance *scsiInstance, const char *diskr
our_this->lba = 0;
our_this->blocks = 0;
state_save_register_item( "scsihd", diskregion, 0, our_this->lba );
state_save_register_item( "scsihd", diskregion, 0, our_this->blocks );
state_save_register_item( Machine, "scsihd", diskregion, 0, our_this->lba );
state_save_register_item( Machine, "scsihd", diskregion, 0, our_this->blocks );
#ifdef MESS
/* TODO: get rid of this ifdef MESS section */

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