Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-07 06:44:51 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

De-converted MACHINE_DRIVER from tokens back to constructor functions, regaining

Browse Source 
type safety. If legacy devices still use inline data, those types are not checked.
However, new devices no longer have access to the generic m_inline_data. Instead
their MDRV_* macros should map to calls to static functions in the device config
class which downcast a generic device_config to the specific device config, and
then set the appropriate values. This is not to be done inline in order to prevent
further code bloat in the constructors. See eeprom/7474/i2cmem/okim6295 for examples.

#ifdef'ed several unused machine driver definitions that weren't referenced.
This commit is contained in:
Aaron Giles 2010-08-26 15:21:19 +00:00
parent 33e4664bb2
commit 47dd9fe568
41 changed files with 759 additions and 978 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/emu/deprecat.h
View File

@ -31,9 +31,7 @@
*************************************/
#define MDRV_CPU_VBLANK_INT_HACK(_func, _rate) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DIEXEC_VBLANK_INT, 8, _rate, 24), \
TOKEN_PTR(cpu_interrupt, _func), \
TOKEN_PTR(stringptr, NULL), \
device_config_execute_interface::static_set_vblank_int(device, _func, NULL, _rate); \

2
src/emu/devcpu.h
View File

@ -420,7 +420,7 @@ protected:
public:
// basic information getters
virtual const rom_entry *rom_region() const { return reinterpret_cast<const rom_entry *>(get_legacy_config_ptr(DEVINFO_PTR_ROM_REGION)); }
virtual const machine_config_token *machine_config_tokens() const { return reinterpret_cast<const machine_config_token *>(get_legacy_config_ptr(DEVINFO_PTR_MACHINE_CONFIG)); }
virtual machine_config_constructor machine_config_additions() const { return reinterpret_cast<machine_config_constructor>(get_legacy_config_ptr(DEVINFO_PTR_MACHINE_CONFIG)); }
protected:
// device_config_execute_interface overrides

151
src/emu/devintrf.c
View File

@ -272,17 +272,6 @@ void device_config_interface::interface_config_complete()
}
//-------------------------------------------------
// interface_process_token - default token
// processing for a given interface
//-------------------------------------------------
bool device_config_interface::interface_process_token(UINT32 entrytype, const machine_config_token *&tokens)
{
return false;
}
//-------------------------------------------------
// interface_validity_check - default validation
// for a device after the configuration has been
@ -317,8 +306,6 @@ device_config::device_config(const machine_config &mconfig, device_type type, co
m_tag(tag),
m_config_complete(false)
{
memset(m_inline_data, 0, sizeof(m_inline_data));
// derive the clock from our owner if requested
if ((m_clock & 0xff000000) == 0xff000000)
{
@ -353,124 +340,6 @@ void device_config::config_complete()
}
//-------------------------------------------------
// process_token - process tokens
//-------------------------------------------------
void device_config::process_token(UINT32 entrytype, const machine_config_token *&tokens)
{
int size, offset, bits, index;
UINT32 data32;
UINT64 data64;
bool processed = false;
// first process stuff we know about
switch (entrytype)
{
// specify device clock
case MCONFIG_TOKEN_DEVICE_CLOCK:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, m_clock, 32);
processed = true;
break;
// specify pointer to static device configuration
case MCONFIG_TOKEN_DEVICE_CONFIG:
m_static_config = TOKEN_GET_PTR(tokens, voidptr);
processed = true;
break;
// provide inline device data packed into a 16-bit space
case MCONFIG_TOKEN_DEVICE_INLINE_DATA16:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, index, 8, data32, 16);
assert(index >= 0 && index < ARRAY_LENGTH(m_inline_data));
m_inline_data[index] = data32;
processed = true;
break;
// provide inline device data packed into a 32-bit space
case MCONFIG_TOKEN_DEVICE_INLINE_DATA32:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, index, 8);
assert(index >= 0 && index < ARRAY_LENGTH(m_inline_data));
m_inline_data[index] = TOKEN_GET_UINT32(tokens);
processed = true;
break;
// provide inline device data packed into a 64-bit space
case MCONFIG_TOKEN_DEVICE_INLINE_DATA64:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, index, 8);
assert(index >= 0 && index < ARRAY_LENGTH(m_inline_data));
TOKEN_EXTRACT_UINT64(tokens, m_inline_data[index]);
processed = true;
break;
// provide inline device data packed into a 32-bit word
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA32:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data32; break;
case 2: *(UINT16 *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data32; break;
case 4: *(UINT32 *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data32; break;
}
processed = true;
break;
// provide inline device data packed into a 64-bit word
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA64:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
TOKEN_EXTRACT_UINT64(tokens, data64);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data64; break;
case 2: *(UINT16 *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data64; break;
case 4: *(UINT32 *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data64; break;
case 8: *(UINT64 *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = data64; break;
}
processed = true;
break;
// provide inline floating-point device data packed into a fixed-point 32-bit word
case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, size, 4, bits, 6, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 4: *(float *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = (float)(INT32)data32 / (float)(1 << bits); break;
case 8: *(double *)((UINT8 *)downcast<legacy_device_config_base *>(this)->inline_config() + offset) = (double)(INT32)data32 / (double)(1 << bits); break;
}
processed = true;
break;
}
// anything else might be handled by one of our interfaces
for (device_config_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
if (intf->interface_process_token(entrytype, tokens))
{
assert(!processed);
processed = true;
}
// or it might be processed by the device itself
if (device_process_token(entrytype, tokens))
{
assert(!processed);
processed = true;
}
// regardless, *somebody* must handle it
if (!processed)
throw emu_fatalerror("Unhandled token %d for device '%s'", entrytype, tag());
}
//-------------------------------------------------
// validity_check - validate a device after the
// configuration has been constructed
@ -505,18 +374,6 @@ void device_config::device_config_complete()
}
//-------------------------------------------------
// device_process_token - process basic device
// tokens
//-------------------------------------------------
bool device_config::device_process_token(UINT32 entrytype, const machine_config_token *&tokens)
{
// handle nothing by default
return false;
}
//-------------------------------------------------
// device_validity_check - validate a device after
// the configuration has been constructed
@ -541,12 +398,12 @@ const rom_entry *device_config::rom_region() const
//-------------------------------------------------
// machine_config_tokens - return a pointer to
// a set of machine configuration tokens
// describing sub-devices for this device
// machine_config - return a pointer to a machine
// config constructor describing sub-devices for
// this device
//-------------------------------------------------
const machine_config_token *device_config::machine_config_tokens() const
machine_config_constructor device_config::machine_config_additions() const
{
return NULL;
}

38
src/emu/devintrf.h
View File

@ -66,32 +66,13 @@
// configure devices
#define MDRV_DEVICE_CONFIG(_config) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_CONFIG, 8), \
TOKEN_PTR(voidptr, &(_config)),
device_config::static_set_static_config(device, &(_config)); \
#define MDRV_DEVICE_CONFIG_CLEAR() \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_CONFIG, 8), \
TOKEN_PTR(voidptr, NULL),
device_config::static_set_static_config(device, NULL); \
#define MDRV_DEVICE_CLOCK(_clock) \
TOKEN_UINT64_PACK2(MCONFIG_TOKEN_DEVICE_CLOCK, 8, _clock, 32),
#define MDRV_DEVICE_INLINE_DATA16(_index, _data) \
TOKEN_UINT32_PACK3(MCONFIG_TOKEN_DEVICE_INLINE_DATA16, 8, _index, 8, (UINT16)(_data), 16), \
#define MDRV_DEVICE_INLINE_DATA32(_index, _data) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DEVICE_INLINE_DATA32, 8, _index, 8), \
TOKEN_UINT32((UINT32)(_data)),
#define MDRV_DEVICE_INLINE_DATA64(_index, _data) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DEVICE_INLINE_DATA64, 8, _index, 8), \
TOKEN_UINT64((UINT64)(_data)),
#ifdef PTR64
#define MDRV_DEVICE_INLINE_DATAPTR(_index, _data) MDRV_DEVICE_INLINE_DATA64(_index, (FPTR)(_data))
#else
#define MDRV_DEVICE_INLINE_DATAPTR(_index, _data) MDRV_DEVICE_INLINE_DATA32(_index, (FPTR)(_data))
#endif
device_config::static_set_clock(device, _clock); \
@ -110,7 +91,6 @@ class device_execute_interface;
class device_memory_interface;
class device_state_interface;
struct rom_entry;
union machine_config_token;
class machine_config;
@ -265,9 +245,12 @@ public:
const void *static_config() const { return m_static_config; }
// methods that wrap both interface-level and device-level behavior
void process_token(UINT32 entrytype, const machine_config_token *&tokens);
void config_complete();
bool validity_check(const game_driver &driver) const;
// configuration helpers
static void static_set_clock(device_config *device, UINT32 clock) { device->m_clock = clock; }
static void static_set_static_config(device_config *device, const void *config) { device->m_static_config = config; }
//------------------- begin derived class overrides
@ -276,14 +259,13 @@ public:
// optional operation overrides
protected:
virtual bool device_process_token(UINT32 entrytype, const machine_config_token *&tokens);
virtual void device_config_complete();
virtual bool device_validity_check(const game_driver &driver) const;
public:
// optional information overrides
virtual const rom_entry *rom_region() const;
virtual const machine_config_token *machine_config_tokens() const;
virtual machine_config_constructor machine_config_additions() const;
//------------------- end derived class overrides
@ -298,7 +280,6 @@ protected:
const machine_config & m_machine_config; // reference to the machine's configuration
const void * m_static_config; // static device configuration
UINT64 m_inline_data[16]; // array of inline configuration values
astring m_name; // name of the device
@ -333,7 +314,6 @@ public:
// optional operation overrides
virtual void interface_config_complete();
virtual bool interface_process_token(UINT32 entrytype, const machine_config_token *&tokens);
virtual bool interface_validity_check(const game_driver &driver) const;
protected:
@ -416,7 +396,7 @@ public:
// machine and ROM configuration getters ... pass through to underlying config
const rom_entry *rom_region() const { return m_baseconfig.rom_region(); }
const machine_config_token *machine_config_tokens() const { return m_baseconfig.machine_config_tokens(); }
machine_config_constructor machine_config_additions() const { return m_baseconfig.machine_config_additions(); }
public:
running_machine * machine;

59
src/emu/devlegcy.c
View File

@ -127,6 +127,65 @@ const char *legacy_device_config_base::get_legacy_config_string(UINT32 state) co
}
//-------------------------------------------------
// static_set_inline32 - configuration helper to
// set a 32-bit value in the inline configuration
//-------------------------------------------------
void legacy_device_config_base::static_set_inline32(device_config *device, UINT32 offset, UINT32 size, UINT32 value)
{
legacy_device_config_base *legacy = downcast<legacy_device_config_base *>(device);
void *dest = reinterpret_cast<UINT8 *>(legacy->m_inline_config) + offset;
if (size == 1)
*reinterpret_cast<UINT8 *>(dest) = value;
else if (size == 2)
*reinterpret_cast<UINT16 *>(dest) = value;
else if (size == 4)
*reinterpret_cast<UINT32 *>(dest) = value;
else
throw emu_fatalerror("Unexpected size %d in legacy_device_config_base::static_set_inline32", size);
}
//-------------------------------------------------
// static_set_inline64 - configuration helper to
// set a 64-bit value in the inline configuration
//-------------------------------------------------
void legacy_device_config_base::static_set_inline64(device_config *device, UINT32 offset, UINT32 size, UINT64 value)
{
legacy_device_config_base *legacy = downcast<legacy_device_config_base *>(device);
void *dest = reinterpret_cast<UINT8 *>(legacy->m_inline_config) + offset;
if (size == 1)
*reinterpret_cast<UINT8 *>(dest) = value;
else if (size == 2)
*reinterpret_cast<UINT16 *>(dest) = value;
else if (size == 4)
*reinterpret_cast<UINT32 *>(dest) = value;
else if (size == 8)
*reinterpret_cast<UINT64 *>(dest) = value;
else
throw emu_fatalerror("Unexpected size %d in legacy_device_config_base::static_set_inline64", size);
}
//-------------------------------------------------
// static_set_inline_float - configuration helper
// to set a floating-point value in the inline
// configuration
//-------------------------------------------------
void legacy_device_config_base::static_set_inline_float(device_config *device, UINT32 offset, UINT32 size, float value)
{
legacy_device_config_base *legacy = downcast<legacy_device_config_base *>(device);
void *dest = reinterpret_cast<UINT8 *>(legacy->m_inline_config) + offset;
if (size == 4)
*reinterpret_cast<float *>(dest) = value;
else
throw emu_fatalerror("Unexpected size %d in legacy_device_config_base::static_set_inline_float", size);
}
//-------------------------------------------------
// device_validity_check - perform validity
// checks on a device configuration

22
src/emu/devlegcy.h
View File

@ -275,10 +275,11 @@ const device_type name = configclass::static_alloc_device_config
// DEVICE_CONFIGURATION_MACROS
//**************************************************************************
#define structsizeof(_struct, _field) sizeof(((_struct *)NULL)->_field)
// inline device configurations that require 32 bits of storage in the token
#define MDRV_DEVICE_CONFIG_DATA32_EXPLICIT(_size, _offset, _val) \
TOKEN_UINT32_PACK3(MCONFIG_TOKEN_DEVICE_CONFIG_DATA32, 8, _size, 4, _offset, 12), \
TOKEN_UINT32((UINT32)(_val)),
legacy_device_config_base::static_set_inline32(device, _offset, _size, (UINT32)(_val));
#define MDRV_DEVICE_CONFIG_DATA32(_struct, _field, _val) \
MDRV_DEVICE_CONFIG_DATA32_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val)
@ -301,8 +302,7 @@ const device_type name = configclass::static_alloc_device_config
// inline device configurations that require 32 bits of fixed-point storage in the token
#define MDRV_DEVICE_CONFIG_DATAFP32_EXPLICIT(_size, _offset, _val, _fixbits) \
TOKEN_UINT32_PACK4(MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32, 8, _size, 4, _fixbits, 6, _offset, 12), \
TOKEN_UINT32((INT32)((float)(_val) * (float)(1 << (_fixbits)))),
legacy_device_config_base::static_set_inline_float(device, _offset, _size, (float)(_val));
#define MDRV_DEVICE_CONFIG_DATAFP32(_struct, _field, _val, _fixbits) \
MDRV_DEVICE_CONFIG_DATAFP32_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val, _fixbits)
@ -325,8 +325,7 @@ const device_type name = configclass::static_alloc_device_config
// inline device configurations that require 64 bits of storage in the token
#define MDRV_DEVICE_CONFIG_DATA64_EXPLICIT(_size, _offset, _val) \
TOKEN_UINT32_PACK3(MCONFIG_TOKEN_DEVICE_CONFIG_DATA64, 8, _size, 4, _offset, 12), \
TOKEN_UINT64((UINT64)(_val)),
legacy_device_config_base::static_set_inline64(device, _offset, _size, (UINT64)(_val));
#define MDRV_DEVICE_CONFIG_DATA64(_struct, _field, _val) \
MDRV_DEVICE_CONFIG_DATA64_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val)
@ -373,6 +372,8 @@ const device_type name = configclass::static_alloc_device_config
//**************************************************************************
union deviceinfo;
class machine_config;
class device_config;
char *get_temp_string_buffer(void);
resource_pool &machine_get_pool(running_machine &machine);
@ -402,7 +403,7 @@ union deviceinfo
device_execute_func execute; // DEVINFO_FCT_EXECUTE
device_nvram_func nvram; // DEVINFO_FCT_NVRAM
const rom_entry * romregion; // DEVINFO_PTR_ROM_REGION
const machine_config_token *machine_config; // DEVINFO_PTR_MACHINE_CONFIG
machine_config_constructor machine_config; // DEVINFO_PTR_MACHINE_CONFIG
address_map_constructor internal_map8; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
address_map_constructor internal_map16; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
address_map_constructor internal_map32; // DEVINFO_PTR_INTERNAL_MEMORY_MAP
@ -433,11 +434,16 @@ protected:
// basic information getters
public:
virtual const rom_entry *rom_region() const { return reinterpret_cast<const rom_entry *>(get_legacy_config_ptr(DEVINFO_PTR_ROM_REGION)); }
virtual const machine_config_token *machine_config_tokens() const { return reinterpret_cast<const machine_config_token *>(get_legacy_config_ptr(DEVINFO_PTR_MACHINE_CONFIG)); }
virtual machine_config_constructor machine_config_additions() const { return reinterpret_cast<machine_config_constructor>(get_legacy_config_ptr(DEVINFO_PTR_MACHINE_CONFIG)); }
// access to legacy inline configuartion
void *inline_config() const { return m_inline_config; }
// inline configuration helpers
static void static_set_inline32(device_config *device, UINT32 offset, UINT32 size, UINT32 value);
static void static_set_inline64(device_config *device, UINT32 offset, UINT32 size, UINT64 value);
static void static_set_inline_float(device_config *device, UINT32 offset, UINT32 size, float value);
protected:
// overrides
virtual bool device_validity_check(const game_driver &driver) const;

90
src/emu/diexec.c
View File

@ -78,7 +78,7 @@ device_config_execute_interface::device_config_execute_interface(const machine_c
m_vblank_interrupts_per_frame(0),
m_vblank_interrupt_screen(NULL),
m_timed_interrupt(NULL),
m_timed_interrupt_period(0)
m_timed_interrupt_period(attotime_zero)
{
}
@ -92,6 +92,51 @@ device_config_execute_interface::~device_config_execute_interface()
}
//-------------------------------------------------
// static_set_disable - configuration helper to
// set the disabled state of a device
//-------------------------------------------------
void device_config_execute_interface::static_set_disable(device_config *device)
{
device_config_execute_interface *exec = dynamic_cast<device_config_execute_interface *>(device);
if (exec == NULL)
throw emu_fatalerror("MDRV_DEVICE_DISABLE called on device '%s' with no execute interface", device->tag());
exec->m_disabled = true;
}
//-------------------------------------------------
// static_set_vblank_int - configuration helper
// to set up VBLANK interrupts on the device
//-------------------------------------------------
void device_config_execute_interface::static_set_vblank_int(device_config *device, device_interrupt_func function, const char *tag, int rate)
{
device_config_execute_interface *exec = dynamic_cast<device_config_execute_interface *>(device);
if (exec == NULL)
throw emu_fatalerror("MDRV_DEVICE_VBLANK_INT called on device '%s' with no execute interface", device->tag());
exec->m_vblank_interrupt = function;
exec->m_vblank_interrupts_per_frame = rate;
exec->m_vblank_interrupt_screen = tag;
}
//-------------------------------------------------
// static_set_periodic_int - configuration helper
// to set up periodic interrupts on the device
//-------------------------------------------------
void device_config_execute_interface::static_set_periodic_int(device_config *device, device_interrupt_func function, attotime rate)
{
device_config_execute_interface *exec = dynamic_cast<device_config_execute_interface *>(device);
if (exec == NULL)
throw emu_fatalerror("MDRV_DEVICE_PERIODIC_INT called on device '%s' with no execute interface", device->tag());
exec->m_timed_interrupt = function;
exec->m_timed_interrupt_period = rate;
}
//-------------------------------------------------
// execute_clocks_to_cycles - convert the number
// of clocks to cycles, rounding down if necessary
@ -160,39 +205,6 @@ UINT32 device_config_execute_interface::execute_default_irq_vector() const
}
//-------------------------------------------------
// interface_process_token - token processing for
// the sound interface
//-------------------------------------------------
bool device_config_execute_interface::interface_process_token(UINT32 entrytype, const machine_config_token *&tokens)
{
switch (entrytype)
{
// disable a device
case MCONFIG_TOKEN_DIEXEC_DISABLE:
m_disabled = true;
return true;
// VBLANK interrupt
case MCONFIG_TOKEN_DIEXEC_VBLANK_INT:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, m_vblank_interrupts_per_frame, 24);
m_vblank_interrupt = TOKEN_GET_PTR(tokens, cpu_interrupt);
m_vblank_interrupt_screen = TOKEN_GET_STRING(tokens);
return true;
// timed interrupt
case MCONFIG_TOKEN_DIEXEC_PERIODIC_INT:
m_timed_interrupt = TOKEN_GET_PTR(tokens, cpu_interrupt);
TOKEN_EXTRACT_UINT64(tokens, m_timed_interrupt_period);
return true;
}
return false;
}
//-------------------------------------------------
// interface_validity_check - validation for a
// device after the configuration has been
@ -234,12 +246,12 @@ bool device_config_execute_interface::interface_validity_check(const game_driver
error = true;
}
if (m_timed_interrupt != NULL && m_timed_interrupt_period == 0)
if (m_timed_interrupt != NULL && attotime_compare(m_timed_interrupt_period, attotime_zero) == 0)
{
mame_printf_error("%s: %s device '%s' has a timer interrupt handler with 0 period!\n", driver.source_file, driver.name, devconfig->tag());
error = true;
}
else if (m_timed_interrupt == NULL && m_timed_interrupt_period != 0)
else if (m_timed_interrupt == NULL && attotime_compare(m_timed_interrupt_period, attotime_zero) != 0)
{
mame_printf_error("%s: %s device '%s' has a no timer interrupt handler but has a non-0 period given!\n", driver.source_file, driver.name, devconfig->tag());
error = true;
@ -548,7 +560,7 @@ void device_execute_interface::interface_pre_start()
// allocate timers if we need them
if (m_execute_config.m_vblank_interrupts_per_frame > 1)
m_partial_frame_timer = timer_alloc(&m_machine, static_trigger_partial_frame_interrupt, (void *)this);
if (m_execute_config.m_timed_interrupt_period != 0)
if (attotime_compare(m_execute_config.m_timed_interrupt_period, attotime_zero) != 0)
m_timedint_timer = timer_alloc(&m_machine, static_trigger_periodic_interrupt, (void *)this);
// register for save states
@ -624,9 +636,9 @@ void device_execute_interface::interface_post_reset()
}
// reconfigure periodic interrupts
if (m_execute_config.m_timed_interrupt_period != 0)
if (attotime_compare(m_execute_config.m_timed_interrupt_period, attotime_zero) != 0)
{
attotime timedint_period = UINT64_ATTOTIME_TO_ATTOTIME(m_execute_config.m_timed_interrupt_period);
attotime timedint_period = m_execute_config.m_timed_interrupt_period;
assert(m_timedint_timer != NULL);
timer_adjust_periodic(m_timedint_timer, timedint_period, 0, timedint_period);
}

18
src/emu/diexec.h
View File

@ -109,17 +109,13 @@ enum
//**************************************************************************
#define MDRV_DEVICE_DISABLE() \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DIEXEC_DISABLE, 8), \
device_config_execute_interface::static_set_disable(device); \
#define MDRV_DEVICE_VBLANK_INT(_tag, _func) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DIEXEC_VBLANK_INT, 8, 0, 24), \
TOKEN_PTR(device_interrupt, _func), \
TOKEN_PTR(stringptr, _tag), \
device_config_execute_interface::static_set_vblank_int(device, _func, _tag); \
#define MDRV_DEVICE_PERIODIC_INT(_func, _rate) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DIEXEC_PERIODIC_INT, 8), \
TOKEN_PTR(device_interrupt, _func), \
TOKEN_UINT64(UINT64_ATTOTIME_IN_HZ(_rate)), \
device_config_execute_interface::static_set_periodic_int(device, _func, ATTOTIME_IN_HZ(_rate)); \
@ -164,6 +160,11 @@ public:
UINT32 input_lines() const { return execute_input_lines(); }
UINT32 default_irq_vector() const { return execute_default_irq_vector(); }
// static inline helpers
static void static_set_disable(device_config *device);
static void static_set_vblank_int(device_config *device, device_interrupt_func function, const char *tag, int rate = 0);
static void static_set_periodic_int(device_config *device, device_interrupt_func function, attotime rate);
protected:
// clock and cycle information getters
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const;
@ -176,7 +177,6 @@ protected:
virtual UINT32 execute_default_irq_vector() const;
// optional operation overrides
virtual bool interface_process_token(UINT32 entrytype, const machine_config_token *&tokens);
virtual bool interface_validity_check(const game_driver &driver) const;
bool m_disabled;
@ -184,7 +184,7 @@ protected:
int m_vblank_interrupts_per_frame; // usually 1
const char * m_vblank_interrupt_screen; // the screen that causes the VBLANK interrupt
device_interrupt_func m_timed_interrupt; // for interrupts not tied to VBLANK
UINT64 m_timed_interrupt_period; // period for periodic interrupts
attotime m_timed_interrupt_period; // period for periodic interrupts
};

26
src/emu/dimemory.c
View File

@ -144,26 +144,18 @@ const address_space_config *device_config_memory_interface::memory_space_config(
//-------------------------------------------------
// interface_process_token - token processing for
// the memory interface
// static_set_vblank_int - configuration helper
// to set up VBLANK interrupts on the device
//-------------------------------------------------
bool device_config_memory_interface::interface_process_token(UINT32 entrytype, const machine_config_token *&tokens)
void device_config_memory_interface::static_set_addrmap(device_config *device, int spacenum, address_map_constructor map)
{
UINT32 data32;
switch (entrytype)
{
// specify device address map
case MCONFIG_TOKEN_DIMEMORY_MAP:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, data32, 8);
assert(data32 < ARRAY_LENGTH(m_address_map));
m_address_map[data32] = TOKEN_GET_PTR(tokens, addrmap);
return true;
}
return false;
device_config_memory_interface *memory = dynamic_cast<device_config_memory_interface *>(device);
if (memory == NULL)
throw emu_fatalerror("MDRV_DEVICE_ADDRESS_MAP called on device '%s' with no memory interface", device->tag());
if (spacenum >= ARRAY_LENGTH(memory->m_address_map))
throw emu_fatalerror("MDRV_DEVICE_ADDRESS_MAP called with out-of-range space number %d", device->tag(), spacenum);
memory->m_address_map[spacenum] = map;
}

7
src/emu/dimemory.h
View File

@ -82,8 +82,7 @@ const int TRANSLATE_FETCH_DEBUG = (TRANSLATE_FETCH | TRANSLATE_DEBUG_MASK);
//**************************************************************************
#define MDRV_DEVICE_ADDRESS_MAP(_space, _map) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DIMEMORY_MAP, 8, _space, 8), \
TOKEN_PTR(addrmap, (address_map_constructor)ADDRESS_MAP_NAME(_map)),
device_config_memory_interface::static_set_addrmap(device, _space, ADDRESS_MAP_NAME(_map));
#define MDRV_DEVICE_PROGRAM_MAP(_map) \
MDRV_DEVICE_ADDRESS_MAP(AS_PROGRAM, _map)
@ -116,12 +115,14 @@ public:
address_map_constructor address_map(int spacenum = 0) const { return (spacenum < ARRAY_LENGTH(m_address_map)) ? m_address_map[spacenum] : NULL; }
const address_space_config *space_config(int spacenum = 0) const { return memory_space_config(spacenum); }
// static inline helpers
static void static_set_addrmap(device_config *device, int spacenum, address_map_constructor map);
protected:
// required overrides
virtual const address_space_config *memory_space_config(int spacenum) const = 0;
// optional operation overrides
virtual bool interface_process_token(UINT32 entrytype, const machine_config_token *&tokens);
virtual bool interface_validity_check(const game_driver &driver) const;
address_map_constructor m_address_map[ADDRESS_SPACES]; // address maps for each address space

49
src/emu/disound.c
View File

@ -68,41 +68,34 @@ device_config_sound_interface::~device_config_sound_interface()
//-------------------------------------------------
// interface_process_token - token processing for
// the sound interface
// static_add_route - configuration helper to add
// a new route to the device
//-------------------------------------------------
bool device_config_sound_interface::interface_process_token(UINT32 entrytype, const machine_config_token *&tokens)
void device_config_sound_interface::static_add_route(device_config *device, UINT32 output, const char *target, double gain, UINT32 input)
{
switch (entrytype)
{
// custom config 1 is a new route
case MCONFIG_TOKEN_DISOUND_ROUTE:
{
// put back the token that was originally fetched so we can grab a packed 64-bit token
TOKEN_UNGET_UINT32(tokens);
device_config_sound_interface *sound = dynamic_cast<device_config_sound_interface *>(device);
if (sound == NULL)
throw emu_fatalerror("MDRV_SOUND_ROUTE called on device '%s' with no sound interface", device->tag());
// extract data
int output, input;
UINT32 gain;
TOKEN_GET_UINT64_UNPACK4(tokens, entrytype, 8, output, 12, input, 12, gain, 32);
float fgain = (float)gain * (1.0f / (float)(1 << 24));
const char *target = TOKEN_GET_STRING(tokens);
sound_route **routeptr;
for (routeptr = &sound->m_route_list; *routeptr != NULL; routeptr = &(*routeptr)->m_next) ;
*routeptr = global_alloc(sound_route(output, input, gain, target));
}
// allocate a new route
sound_route **routeptr;
for (routeptr = &m_route_list; *routeptr != NULL; routeptr = &(*routeptr)->m_next) ;
*routeptr = global_alloc(sound_route(output, input, fgain, target));
return true;
}
// custom config 2 resets the sound routes
case MCONFIG_TOKEN_DISOUND_RESET:
reset_routes();
return true;
}
//-------------------------------------------------
// static_reset_routes - configuration helper to
// reset all existing routes to the device
//-------------------------------------------------
return false;
void device_config_sound_interface::static_reset_routes(device_config *device)
{
device_config_sound_interface *sound = dynamic_cast<device_config_sound_interface *>(device);
if (sound == NULL)
throw emu_fatalerror("MDRV_SOUND_ROUTES_RESET called on device '%s' with no sound interface", device->tag());
sound->reset_routes();
}

10
src/emu/disound.h
View File

@ -76,14 +76,13 @@ const int ALL_OUTPUTS = MAX_OUTPUTS; // special value indicating all outputs fo
MDRV_DEVICE_CONFIG(_config)
#define MDRV_SOUND_ROUTE_EX(_output, _target, _gain, _input) \
TOKEN_UINT64_PACK4(MCONFIG_TOKEN_DISOUND_ROUTE, 8, _output, 12, _input, 12, ((float)(_gain) * (float)(1 << 24)), 32), \
TOKEN_PTR(stringptr, _target),
device_config_sound_interface::static_add_route(device, _output, _target, _gain, _input); \
#define MDRV_SOUND_ROUTE(_output, _target, _gain) \
MDRV_SOUND_ROUTE_EX(_output, _target, _gain, 0)
#define MDRV_SOUND_ROUTES_RESET() \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DISOUND_RESET, 8),
device_config_sound_interface::static_reset_routes(device); \
@ -118,9 +117,12 @@ public:
sound_route * m_route_list; // list of sound routes
// static inline helpers
static void static_add_route(device_config *device, UINT32 output, const char *target, double gain, UINT32 input = 0);
static void static_reset_routes(device_config *device);
protected:
// optional operation overrides
virtual bool interface_process_token(UINT32 entrytype, const machine_config_token *&tokens);
virtual bool interface_validity_check(const game_driver &driver) const;
void reset_routes();

2
src/emu/driver.h
View File

@ -67,7 +67,7 @@ struct game_driver
const char * description; /* full name of the game */
const char * year; /* year the game was released */
const char * manufacturer; /* manufacturer of the game */
const machine_config_token *machine_config; /* machine driver tokens */
machine_config_constructor machine_config; /* machine driver tokens */
const input_port_token *ipt; /* pointer to array of input port tokens */
void (*driver_init)(running_machine *machine); /* DRIVER_INIT callback */
const rom_entry * rom; /* pointer to list of ROMs for the game */

6
src/emu/emu.h
View File

@ -69,6 +69,12 @@
#include "memory.h"
#include "addrmap.h"
// define machine_config_constructor here due to circular dependency
// between devices and the machine config
class machine_config;
class device_config;
typedef void (*machine_config_constructor)(machine_config &config, device_config *owner);
// devices and callbacks
#include "devintrf.h"
#include "devcb.h"

6
src/emu/image.c
View File

@ -517,10 +517,10 @@ void image_add_device_with_subdevices(device_t *owner, device_type type, const c
device_config *devconfig = type(*config, owner->subtag(tempstring,tag), &owner->baseconfig(), clock);
running_device *device = device_list->append(devconfig->tag(), devconfig->alloc_device(*owner->machine));
const machine_config_token *tokens = device->machine_config_tokens();
if (tokens != NULL)
machine_config_constructor machconfig = device->machine_config_additions();
if (machconfig != NULL)
{
config->detokenize(tokens,devconfig);
(*machconfig)(*config, devconfig);
for (const device_config *config_dev = config->m_devicelist.first(); config_dev != NULL; config_dev = config_dev->next())
{
if (config_dev->owner()==devconfig) {

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

@ -75,30 +75,52 @@ device_t *ttl7474_device_config::alloc_device(running_machine &machine) const
}
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_set_target_tag - configuration helper
// to set the target tag
//-------------------------------------------------
void ttl7474_device_config::device_config_complete()
void ttl7474_device_config::static_set_target_tag(device_config *device, const char *tag)
{
m_target_tag = reinterpret_cast<const char *>(m_inline_data[INLINE_TARGET_TAG]);
m_base_output_cb = reinterpret_cast<void (*)(device_t *device, INT32)>(m_inline_data[INLINE_OUTPUT_CB]);
m_base_comp_output_cb = reinterpret_cast<void (*)(device_t *device, INT32)>(m_inline_data[INLINE_COMP_OUTPUT_CB]);
ttl7474_device_config *ttl7474 = downcast<ttl7474_device_config *>(device);
ttl7474->m_output_cb.tag = tag;
ttl7474->m_comp_output_cb.tag = tag;
}
m_output_cb.type = DEVCB_TYPE_DEVICE;
m_output_cb.tag = m_target_tag;
m_output_cb.writeline = m_base_output_cb;
m_output_cb.writedevice = NULL;
m_output_cb.writespace = NULL;
m_comp_output_cb.type = DEVCB_TYPE_DEVICE;
m_comp_output_cb.tag = m_target_tag;
m_comp_output_cb.writeline = m_base_comp_output_cb;
m_comp_output_cb.writedevice = NULL;
m_comp_output_cb.writespace = NULL;
//-------------------------------------------------
// static_set_output_cb - configuration helper
// to set the output callback
//-------------------------------------------------
void ttl7474_device_config::static_set_output_cb(device_config *device, write_line_device_func callback)
{
ttl7474_device_config *ttl7474 = downcast<ttl7474_device_config *>(device);
if (callback != NULL)
{
ttl7474->m_output_cb.type = DEVCB_TYPE_DEVICE;
ttl7474->m_output_cb.writeline = callback;
}
else
ttl7474->m_output_cb.type = DEVCB_TYPE_NULL;
}
//-------------------------------------------------
// static_set_comp_output_cb - configuration
// helper to set the comp. output callback
//-------------------------------------------------
void ttl7474_device_config::static_set_comp_output_cb(device_config *device, write_line_device_func callback)
{
ttl7474_device_config *ttl7474 = downcast<ttl7474_device_config *>(device);
if (callback != NULL)
{
ttl7474->m_comp_output_cb.type = DEVCB_TYPE_DEVICE;
ttl7474->m_comp_output_cb.writeline = callback;
}
else
ttl7474->m_comp_output_cb.type = DEVCB_TYPE_NULL;
}

24
src/emu/machine/7474.h
View File

@ -63,13 +63,13 @@
MDRV_7474_COMP_OUTPUT_CB(_comp_output_cb)
#define MDRV_7474_TARGET_TAG(_target_tag) \
MDRV_DEVICE_INLINE_DATAPTR(ttl7474_device_config::INLINE_TARGET_TAG, _target_tag)
ttl7474_device_config::static_set_target_tag(device, _target_tag); \
#define MDRV_7474_OUTPUT_CB(_cb) \
MDRV_DEVICE_INLINE_DATAPTR(ttl7474_device_config::INLINE_OUTPUT_CB, _cb)
ttl7474_device_config::static_set_output_cb(device, _cb); \
#define MDRV_7474_COMP_OUTPUT_CB(_cb) \
MDRV_DEVICE_INLINE_DATAPTR(ttl7474_device_config::INLINE_COMP_OUTPUT_CB, _cb)
ttl7474_device_config::static_set_comp_output_cb(device, _cb); \
@ -91,23 +91,13 @@ public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
// inline configuration indexes go here
enum
{
INLINE_TARGET_TAG,
INLINE_OUTPUT_CB,
INLINE_COMP_OUTPUT_CB
};
// inline configuration helpers
static void static_set_target_tag(device_config *device, const char *tag);
static void static_set_output_cb(device_config *device, write_line_device_func callback);
static void static_set_comp_output_cb(device_config *device, write_line_device_func callback);
protected:
// device_config overrides
virtual void device_config_complete();
// internal state goes here
const char *m_target_tag;
void (*m_base_output_cb)(device_t *device, INT32);
void (*m_base_comp_output_cb)(device_t *device, INT32);
devcb_write_line m_output_cb;
devcb_write_line m_comp_output_cb;
};

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

@ -107,28 +107,55 @@ device_t *eeprom_device_config::alloc_device(running_machine &machine) const
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_set_interface - configuration helper
// to set the interface
//-------------------------------------------------
void eeprom_device_config::device_config_complete()
void eeprom_device_config::static_set_interface(device_config *device, const eeprom_interface &interface)
{
// extract inline configuration from raw data
const eeprom_interface *intf = reinterpret_cast<const eeprom_interface *>(m_inline_data[INLINE_INTERFACE]);
m_default_data = reinterpret_cast<const UINT8 *>(m_inline_data[INLINE_DATAPTR]);
m_default_data_size = m_inline_data[INLINE_DATASIZE];
m_default_value = m_inline_data[INLINE_DEFVALUE];
eeprom_device_config *eeprom = downcast<eeprom_device_config *>(device);
*static_cast<eeprom_interface *>(eeprom) = interface;
// inherit a copy of the static data
if (intf != NULL)
*static_cast<eeprom_interface *>(this) = *intf;
// now describe our address space
if (m_data_bits == 8)
m_space_config = address_space_config("eeprom", ENDIANNESS_BIG, 8, m_address_bits, 0, *ADDRESS_MAP_NAME(eeprom_map8));
// describe our address space
if (eeprom->m_data_bits == 8)
eeprom->m_space_config = address_space_config("eeprom", ENDIANNESS_BIG, 8, eeprom->m_address_bits, 0, *ADDRESS_MAP_NAME(eeprom_map8));
else
m_space_config = address_space_config("eeprom", ENDIANNESS_BIG, 16, m_address_bits * 2, 0, *ADDRESS_MAP_NAME(eeprom_map16));
eeprom->m_space_config = address_space_config("eeprom", ENDIANNESS_BIG, 16, eeprom->m_address_bits * 2, 0, *ADDRESS_MAP_NAME(eeprom_map16));
}
//-------------------------------------------------
// static_set_default_data - configuration helpers
// to set the default data
//-------------------------------------------------
void eeprom_device_config::static_set_default_data(device_config *device, const UINT8 *data, UINT32 size)
{
eeprom_device_config *eeprom = downcast<eeprom_device_config *>(device);
if (eeprom->m_data_bits != 8) mame_printf_warning("16-bit EEPROM set with 8-bit data\n");
// assert(eeprom->m_data_bits == 8);
eeprom->m_default_data = data;
eeprom->m_default_data_size = size;
}
void eeprom_device_config::static_set_default_data(device_config *device, const UINT16 *data, UINT32 size)
{
eeprom_device_config *eeprom = downcast<eeprom_device_config *>(device);
if (eeprom->m_data_bits != 16) mame_printf_warning("8-bit EEPROM set with 16-bit data\n");
// assert(eeprom->m_data_bits == 16);
eeprom->m_default_data = reinterpret_cast<const UINT8 *>(data);
eeprom->m_default_data_size = size;
}
//-------------------------------------------------
// static_set_default_value - configuration helper
// to set the default value
//-------------------------------------------------
void eeprom_device_config::static_set_default_value(device_config *device, UINT16 value)
{
downcast<eeprom_device_config *>(device)->m_default_value = 0x10000 | value;
}
@ -141,12 +168,7 @@ bool eeprom_device_config::device_validity_check(const game_driver &driver) cons
{
bool error = false;
if (m_inline_data[INLINE_INTERFACE] == 0)
{
mame_printf_error("%s: %s eeprom device '%s' did not specify an interface\n", driver.source_file, driver.name, tag());
error = true;
}
else if (m_data_bits != 8 && m_data_bits != 16)
if (m_data_bits != 8 && m_data_bits != 16)
{
mame_printf_error("%s: %s eeprom device '%s' specified invalid data width %d\n", driver.source_file, driver.name, tag(), m_data_bits);
error = true;

25
src/emu/machine/eeprom.h
View File

@ -19,7 +19,7 @@
#define MDRV_EEPROM_ADD(_tag, _interface) \
MDRV_DEVICE_ADD(_tag, EEPROM, 0) \
MDRV_DEVICE_INLINE_DATAPTR(eeprom_device_config::INLINE_INTERFACE, &_interface)
eeprom_device_config::static_set_interface(device, _interface); \
#define MDRV_EEPROM_93C46_ADD(_tag) \
MDRV_EEPROM_ADD(_tag, eeprom_interface_93C46)
@ -28,11 +28,10 @@
MDRV_EEPROM_ADD(_tag, eeprom_interface_93C66B)
#define MDRV_EEPROM_DATA(_data, _size) \
MDRV_DEVICE_INLINE_DATAPTR(eeprom_device_config::INLINE_DATAPTR, &_data) \
MDRV_DEVICE_INLINE_DATA16(eeprom_device_config::INLINE_DATASIZE, _size)
eeprom_device_config::static_set_default_data(device, _data, _size); \
#define MDRV_EEPROM_DEFAULT_VALUE(_value) \
MDRV_DEVICE_INLINE_DATA32(eeprom_device_config::INLINE_DEFVALUE, 0x10000 | ((_value) & 0xffff))
eeprom_device_config::static_set_default_value(device, _value); \
@ -76,28 +75,26 @@ public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
// inline configuration indexes
enum
{
INLINE_INTERFACE,
INLINE_DATAPTR,
INLINE_DATASIZE,
INLINE_DEFVALUE
};
// inline configuration helpers
static void static_set_interface(device_config *deviec, const eeprom_interface &interface);
static void static_set_default_data(device_config *device, const UINT8 *data, UINT32 size);
static void static_set_default_data(device_config *device, const UINT16 *data, UINT32 size);
static void static_set_default_value(device_config *device, UINT16 value);
protected:
// device_config overrides
virtual void device_config_complete();
virtual bool device_validity_check(const game_driver &driver) const;
// device_config_memory_interface overrides
virtual const address_space_config *memory_space_config(int spacenum = 0) const;
// device-specific configuration
address_space_config m_space_config;
// internal state
const UINT8 * m_default_data;
int m_default_data_size;
UINT32 m_default_value;
address_space_config m_space_config;
};

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

@ -109,6 +109,18 @@ device_t *i2cmem_device_config::alloc_device( running_machine &machine ) const
}
//-------------------------------------------------
// static_set_interface - set the device
// configuration
//-------------------------------------------------
void i2cmem_device_config::static_set_interface(device_config *device, const i2cmem_interface &interface)
{
i2cmem_device_config *i2cmem = downcast<i2cmem_device_config *>(device);
*static_cast<i2cmem_interface *>(i2cmem) = interface;
}
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
@ -117,15 +129,6 @@ device_t *i2cmem_device_config::alloc_device( running_machine &machine ) const
void i2cmem_device_config::device_config_complete()
{
// extract inline configuration from raw data
const i2cmem_interface *intf = reinterpret_cast<const i2cmem_interface *>( m_inline_data[ INLINE_INTERFACE ] );
// inherit a copy of the static data
if( intf != NULL )
{
*static_cast<i2cmem_interface *>(this) = *intf;
}
m_space_config = address_space_config( "i2cmem", ENDIANNESS_BIG, 8, m_address_bits, 0, *ADDRESS_MAP_NAME( i2cmem_map8 ) );
}
@ -138,13 +141,6 @@ void i2cmem_device_config::device_config_complete()
bool i2cmem_device_config::device_validity_check( const game_driver &driver ) const
{
bool error = false;
if( m_inline_data[ INLINE_INTERFACE ] == 0 )
{
mame_printf_error( "%s: %s i2cmem device '%s' did not specify an interface\n", driver.source_file, driver.name, tag() );
error = true;
}
return error;
}

9
src/emu/machine/i2cmem.h
View File

@ -26,7 +26,7 @@
#define MDRV_I2CMEM_ADD( _tag, _interface ) \
MDRV_DEVICE_ADD( _tag, I2CMEM, 0 ) \
MDRV_DEVICE_INLINE_DATAPTR( i2cmem_device_config::INLINE_INTERFACE, &_interface )
i2cmem_device_config::static_set_interface(device, _interface);
//**************************************************************************
@ -61,11 +61,8 @@ public:
static device_config *static_alloc_device_config( const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock );
virtual device_t *alloc_device( running_machine &machine ) const;
// inline configuration indexes
enum
{
INLINE_INTERFACE
};
// inline configuration
static void static_set_interface(device_config *device, const i2cmem_interface &interface);
protected:
// device_config overrides

2
src/emu/machine/ldcore.h
View File

@ -148,7 +148,7 @@ struct _ldplayer_interface
size_t statesize; /* size of the state */
const char * name; /* name of the player */
const rom_entry * romregion; /* pointer to ROM region information */
const machine_config_token *machine_config; /* pointer to machine configuration */
machine_config_constructor machine_config; /* pointer to machine configuration */
laserdisc_init_func init; /* initialization callback */
laserdisc_vsync_func vsync; /* vsync begin callback */
laserdisc_update_func update; /* update callback (line 16) */

282
src/emu/mconfig.c
View File

@ -49,7 +49,7 @@
// machine_config - constructor
//-------------------------------------------------
machine_config::machine_config(const machine_config_token *tokens)
machine_config::machine_config(machine_config_constructor constructor)
: m_driver_data_alloc(NULL),
m_minimum_quantum(attotime_zero),
m_perfect_cpu_quantum(NULL),
@ -72,8 +72,25 @@ machine_config::machine_config(const machine_config_token *tokens)
m_sound_reset(NULL),
m_parse_level(0)
{
// parse tokens into the config
detokenize(tokens);
// construct the config
(*constructor)(*this, NULL);
// process any device-specific machine configurations
for (device_config *devconfig = m_devicelist.first(); devconfig != NULL; devconfig = devconfig->next())
if (!devconfig->m_config_complete)
{
machine_config_constructor additions = devconfig->machine_config_additions();
if (additions != NULL)
(*additions)(*this, devconfig);
}
// then notify all devices that their configuration is complete
for (device_config *devconfig = m_devicelist.first(); devconfig != NULL; devconfig = devconfig->next())
if (!devconfig->m_config_complete)
{
devconfig->config_complete();
devconfig->m_config_complete = true;
}
}
@ -87,219 +104,56 @@ machine_config::~machine_config()
//-------------------------------------------------
// detokenize - detokenize a machine config
// device_add - configuration helper to add a
// new device
//-------------------------------------------------
void machine_config::detokenize(const machine_config_token *tokens, const device_config *owner)
device_config *machine_config::device_add(device_config *owner, const char *tag, device_type type, UINT32 clock)
{
device_config *device = NULL;
astring tempstring;
// increase the parse level
m_parse_level++;
// loop over tokens until we hit the end
UINT32 entrytype = MCONFIG_TOKEN_INVALID;
while (entrytype != MCONFIG_TOKEN_END)
{
device_type devtype;
const char *tag;
UINT64 data64;
UINT32 clock;
// unpack the token from the first entry
TOKEN_GET_UINT32_UNPACK1(tokens, entrytype, 8);
switch (entrytype)
{
// end
case MCONFIG_TOKEN_END:
break;
// including
case MCONFIG_TOKEN_INCLUDE:
detokenize(TOKEN_GET_PTR(tokens, tokenptr), owner);
break;
// device management
case MCONFIG_TOKEN_DEVICE_ADD:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, clock, 32);
devtype = TOKEN_GET_PTR(tokens, devtype);
tag = owner->subtag(tempstring, TOKEN_GET_STRING(tokens));
device = m_devicelist.append(tag, (*devtype)(*this, tag, owner, clock));
break;
case MCONFIG_TOKEN_DEVICE_REPLACE:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, clock, 32);
devtype = TOKEN_GET_PTR(tokens, devtype);
tag = owner->subtag(tempstring, TOKEN_GET_STRING(tokens));
device = m_devicelist.replace(tag, (*devtype)(*this, tag, owner, clock));
break;
case MCONFIG_TOKEN_DEVICE_REMOVE:
tag = TOKEN_GET_STRING(tokens);
m_devicelist.remove(owner->subtag(tempstring, tag));
device = NULL;
break;
case MCONFIG_TOKEN_DEVICE_MODIFY:
tag = TOKEN_GET_STRING(tokens);
device = m_devicelist.find(owner->subtag(tempstring, tag).cstr());
if (device == NULL)
fatalerror("Unable to find device: tag=%s\n", tempstring.cstr());
break;
case MCONFIG_TOKEN_DEVICE_CLOCK:
case MCONFIG_TOKEN_DEVICE_CONFIG:
case MCONFIG_TOKEN_DEVICE_INLINE_DATA16:
case MCONFIG_TOKEN_DEVICE_INLINE_DATA32:
case MCONFIG_TOKEN_DEVICE_INLINE_DATA64:
case MCONFIG_TOKEN_DIEXEC_DISABLE:
case MCONFIG_TOKEN_DIEXEC_VBLANK_INT:
case MCONFIG_TOKEN_DIEXEC_PERIODIC_INT:
case MCONFIG_TOKEN_DIMEMORY_MAP:
case MCONFIG_TOKEN_DISOUND_ROUTE:
case MCONFIG_TOKEN_DISOUND_RESET:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_1:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_2:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_3:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_4:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_5:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_6:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_7:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_8:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_9:
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA32:
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA64:
case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_FREE:
assert(device != NULL);
device->process_token(entrytype, tokens);
break;
// core parameters
case MCONFIG_TOKEN_DRIVER_DATA:
m_driver_data_alloc = TOKEN_GET_PTR(tokens, driver_data_alloc);
break;
case MCONFIG_TOKEN_QUANTUM_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
m_minimum_quantum = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
case MCONFIG_TOKEN_QUANTUM_PERFECT_CPU:
m_perfect_cpu_quantum = TOKEN_GET_STRING(tokens);
break;
case MCONFIG_TOKEN_WATCHDOG_VBLANK:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, m_watchdog_vblank_count, 24);
break;
case MCONFIG_TOKEN_WATCHDOG_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
m_watchdog_time = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
// core functions
case MCONFIG_TOKEN_MACHINE_START:
m_machine_start = TOKEN_GET_PTR(tokens, machine_start);
break;
case MCONFIG_TOKEN_MACHINE_RESET:
m_machine_reset = TOKEN_GET_PTR(tokens, machine_reset);
break;
case MCONFIG_TOKEN_NVRAM_HANDLER:
m_nvram_handler = TOKEN_GET_PTR(tokens, nvram_handler);
break;
case MCONFIG_TOKEN_MEMCARD_HANDLER:
m_memcard_handler = TOKEN_GET_PTR(tokens, memcard_handler);
break;
// core video parameters
case MCONFIG_TOKEN_VIDEO_ATTRIBUTES:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, m_video_attributes, 24);
break;
case MCONFIG_TOKEN_GFXDECODE:
m_gfxdecodeinfo = TOKEN_GET_PTR(tokens, gfxdecode);
break;
case MCONFIG_TOKEN_PALETTE_LENGTH:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, m_total_colors, 24);
break;
case MCONFIG_TOKEN_DEFAULT_LAYOUT:
m_default_layout = TOKEN_GET_STRING(tokens);
break;
// core video functions
case MCONFIG_TOKEN_PALETTE_INIT:
m_init_palette = TOKEN_GET_PTR(tokens, palette_init);
break;
case MCONFIG_TOKEN_VIDEO_START:
m_video_start = TOKEN_GET_PTR(tokens, video_start);
break;
case MCONFIG_TOKEN_VIDEO_RESET:
m_video_reset = TOKEN_GET_PTR(tokens, video_reset);
break;
case MCONFIG_TOKEN_VIDEO_EOF:
m_video_eof = TOKEN_GET_PTR(tokens, video_eof);
break;
case MCONFIG_TOKEN_VIDEO_UPDATE:
m_video_update = TOKEN_GET_PTR(tokens, video_update);
break;
// core sound functions
case MCONFIG_TOKEN_SOUND_START:
m_sound_start = TOKEN_GET_PTR(tokens, sound_start);
break;
case MCONFIG_TOKEN_SOUND_RESET:
m_sound_reset = TOKEN_GET_PTR(tokens, sound_reset);
break;
default:
fatalerror("Invalid token %d in machine config\n", entrytype);
break;
}
}
// if we started at parse level 0 (and are thus at level 1), do post-processing
if (m_parse_level == 1)
{
// process any device-specific machine configurations
for (const device_config *devconfig = m_devicelist.first(); devconfig != NULL; devconfig = devconfig->next())
if (!devconfig->m_config_complete)
{
tokens = devconfig->machine_config_tokens();
if (tokens != NULL)
detokenize(tokens, devconfig);
}
// then notify all devices that their configuration is complete
for (device_config *devconfig = m_devicelist.first(); devconfig != NULL; devconfig = devconfig->next())
if (!devconfig->m_config_complete)
{
devconfig->config_complete();
devconfig->m_config_complete = true;
}
}
// bump down the parse level
m_parse_level--;
const char *fulltag = owner->subtag(tempstring, tag);
return m_devicelist.append(fulltag, (*type)(*this, fulltag, owner, clock));
}
//-------------------------------------------------
// device_replace - configuration helper to
// replace one device with a new device
//-------------------------------------------------
device_config *machine_config::device_replace(device_config *owner, const char *tag, device_type type, UINT32 clock)
{
astring tempstring;
const char *fulltag = owner->subtag(tempstring, tag);
return m_devicelist.replace(fulltag, (*type)(*this, fulltag, owner, clock));
}
//-------------------------------------------------
// device_remove - configuration helper to
// remove a device
//-------------------------------------------------
device_config *machine_config::device_remove(device_config *owner, const char *tag)
{
astring tempstring;
const char *fulltag = owner->subtag(tempstring, tag);
m_devicelist.remove(fulltag);
return NULL;
}
//-------------------------------------------------
// device_find - configuration helper to
// locate a device
//-------------------------------------------------
device_config *machine_config::device_find(device_config *owner, const char *tag)
{
astring tempstring;
const char *fulltag = owner->subtag(tempstring, tag);
device_config *device = m_devicelist.find(fulltag);
if (device == NULL)
throw emu_fatalerror("Unable to find device: tag=%s\n", fulltag);
return device;
}

305
src/emu/mconfig.h
View File

@ -47,6 +47,42 @@
#define __MCONFIG_H__
//**************************************************************************
// CONSTANTS
//**************************************************************************
// by convention, tags should all lowercase and between 2-15 characters
#define MIN_TAG_LENGTH 2
#define MAX_TAG_LENGTH 15
// ----- flags for video_attributes -----
// should VIDEO_UPDATE by called at the start of VBLANK or at the end?
#define VIDEO_UPDATE_BEFORE_VBLANK 0x0000
#define VIDEO_UPDATE_AFTER_VBLANK 0x0004
// indicates VIDEO_UPDATE will add container bits its
#define VIDEO_SELF_RENDER 0x0008
// automatically extend the palette creating a darker copy for shadows
#define VIDEO_HAS_SHADOWS 0x0010
// automatically extend the palette creating a brighter copy for highlights
#define VIDEO_HAS_HIGHLIGHTS 0x0020
// Mish 181099: See comments in video/generic.c for details
#define VIDEO_BUFFERS_SPRITERAM 0x0040
// force VIDEO_UPDATE to be called even for skipped frames
#define VIDEO_ALWAYS_UPDATE 0x0080
// calls VIDEO_UPDATE for every visible scanline, even for skipped frames
#define VIDEO_UPDATE_SCANLINE 0x0100
#define NVRAM_HANDLER_NAME(name) nvram_handler_##name
#define NVRAM_HANDLER(name) void NVRAM_HANDLER_NAME(name)(running_machine *machine, mame_file *file, int read_or_write)
#define NVRAM_HANDLER_CALL(name) NVRAM_HANDLER_NAME(name)(machine, file, read_or_write)
@ -106,8 +142,18 @@
#define video_update_0 NULL
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// forward references
struct gfx_decode_entry;
class driver_data_t;
// various callback functions
typedef void (*nvram_handler_func)(running_machine *machine, mame_file *file, int read_or_write);
typedef void (*memcard_handler_func)(running_machine *machine, mame_file *file, int action);
typedef void (*machine_start_func)(running_machine *machine);
@ -118,128 +164,14 @@ typedef void (*video_start_func)(running_machine *machine);
typedef void (*video_reset_func)(running_machine *machine);
typedef void (*palette_init_func)(running_machine *machine, const UINT8 *color_prom);
typedef void (*video_eof_func)(running_machine *machine);
typedef UINT32 (*video_update_func)(device_t *screen, bitmap_t *bitmap, const rectangle *cliprect);
typedef UINT32 (*video_update_func)(screen_device *screen, bitmap_t *bitmap, const rectangle *cliprect);
typedef driver_data_t *(*driver_data_alloc_func)(running_machine &machine);
/***************************************************************************
CONSTANTS
***************************************************************************/
// by convention, tags should all lowercase and between 2-15 characters
#define MIN_TAG_LENGTH 2
#define MAX_TAG_LENGTH 15
// token types
enum
{
MCONFIG_TOKEN_INVALID,
MCONFIG_TOKEN_END,
MCONFIG_TOKEN_INCLUDE,
MCONFIG_TOKEN_DRIVER_DATA,
MCONFIG_TOKEN_QUANTUM_TIME,
MCONFIG_TOKEN_QUANTUM_PERFECT_CPU,
MCONFIG_TOKEN_WATCHDOG_VBLANK,
MCONFIG_TOKEN_WATCHDOG_TIME,
MCONFIG_TOKEN_MACHINE_START,
MCONFIG_TOKEN_MACHINE_RESET,
MCONFIG_TOKEN_NVRAM_HANDLER,
MCONFIG_TOKEN_MEMCARD_HANDLER,
MCONFIG_TOKEN_VIDEO_ATTRIBUTES,
MCONFIG_TOKEN_GFXDECODE,
MCONFIG_TOKEN_PALETTE_LENGTH,
MCONFIG_TOKEN_DEFAULT_LAYOUT,
MCONFIG_TOKEN_PALETTE_INIT,
MCONFIG_TOKEN_VIDEO_START,
MCONFIG_TOKEN_VIDEO_RESET,
MCONFIG_TOKEN_VIDEO_EOF,
MCONFIG_TOKEN_VIDEO_UPDATE,
MCONFIG_TOKEN_SOUND_START,
MCONFIG_TOKEN_SOUND_RESET,
MCONFIG_TOKEN_DEVICE_ADD,
MCONFIG_TOKEN_DEVICE_REPLACE,
MCONFIG_TOKEN_DEVICE_REMOVE,
MCONFIG_TOKEN_DEVICE_MODIFY,
// device-specific tokens
MCONFIG_TOKEN_DEVICE_CLOCK,
MCONFIG_TOKEN_DEVICE_CONFIG,
MCONFIG_TOKEN_DEVICE_INLINE_DATA16,
MCONFIG_TOKEN_DEVICE_INLINE_DATA32,
MCONFIG_TOKEN_DEVICE_INLINE_DATA64,
// execute interface-specific tokens
MCONFIG_TOKEN_DIEXEC_DISABLE,
MCONFIG_TOKEN_DIEXEC_VBLANK_INT,
MCONFIG_TOKEN_DIEXEC_PERIODIC_INT,
// memory interface-specific tokens
MCONFIG_TOKEN_DIMEMORY_MAP,
// sound interface-specific tokens
MCONFIG_TOKEN_DISOUND_ROUTE,
MCONFIG_TOKEN_DISOUND_RESET,
// legacy custom tokens
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_1,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_2,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_3,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_4,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_5,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_6,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_7,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_8,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_9,
MCONFIG_TOKEN_DEVICE_CONFIG_DATA32,
MCONFIG_TOKEN_DEVICE_CONFIG_DATA64,
MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32,
MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_FREE,
};
// ----- flags for video_attributes -----
// should VIDEO_UPDATE by called at the start of VBLANK or at the end?
#define VIDEO_UPDATE_BEFORE_VBLANK 0x0000
#define VIDEO_UPDATE_AFTER_VBLANK 0x0004
// indicates VIDEO_UPDATE will add container bits its
#define VIDEO_SELF_RENDER 0x0008
// automatically extend the palette creating a darker copy for shadows
#define VIDEO_HAS_SHADOWS 0x0010
// automatically extend the palette creating a brighter copy for highlights
#define VIDEO_HAS_HIGHLIGHTS 0x0020
// Mish 181099: See comments in video/generic.c for details
#define VIDEO_BUFFERS_SPRITERAM 0x0040
// force VIDEO_UPDATE to be called even for skipped frames
#define VIDEO_ALWAYS_UPDATE 0x0080
// calls VIDEO_UPDATE for every visible scanline, even for skipped frames
#define VIDEO_UPDATE_SCANLINE 0x0100
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
// forward references
struct gfx_decode_entry;
// ======================> address_map_entry
// machine configuration definition
class machine_config
{
DISABLE_COPYING(machine_config);
@ -247,11 +179,9 @@ class machine_config
friend class running_machine;
public:
machine_config(const machine_config_token *tokens);
machine_config(machine_config_constructor constructor);
~machine_config();
void detokenize(const machine_config_token *tokens, const device_config *owner = NULL);
driver_data_alloc_func m_driver_data_alloc; // allocator for driver data
attotime m_minimum_quantum; // minimum scheduling quantum
@ -281,176 +211,129 @@ public:
device_config_list m_devicelist; // list of device configs
// helpers during configuration; not for general use
device_config *device_add(device_config *owner, const char *tag, device_type type, UINT32 clock);
device_config *device_replace(device_config *owner, const char *tag, device_type type, UINT32 clock);
device_config *device_remove(device_config *owner, const char *tag);
device_config *device_find(device_config *owner, const char *tag);
private:
int m_parse_level; // nested parsing level
};
/***************************************************************************
MACROS FOR BUILDING MACHINE DRIVERS
***************************************************************************/
// this type is used to encode machine configuration definitions
union machine_config_token
{
TOKEN_COMMON_FIELDS
const machine_config_token *tokenptr;
const gfx_decode_entry *gfxdecode;
address_map_constructor addrmap;
device_type devtype;
nvram_handler_func nvram_handler;
memcard_handler_func memcard_handler;
machine_start_func machine_start;
machine_reset_func machine_reset;
sound_start_func sound_start;
sound_reset_func sound_reset;
video_start_func video_start;
video_reset_func video_reset;
palette_init_func palette_init;
video_eof_func video_eof;
video_update_func video_update;
device_interrupt_func cpu_interrupt;
driver_data_alloc_func driver_data_alloc;
};
// helper macro for returning the size of a field within a struct; similar to offsetof()
#define structsizeof(_struct, _field) sizeof(((_struct *)NULL)->_field)
#define DEVCONFIG_OFFSETOF(_class, _member) \
((FPTR)&static_cast<_class *>(reinterpret_cast<device_config *>(1000000))->_member - 1000000)
#define DEVCONFIG_SIZEOF(_class, _member) \
sizeof(reinterpret_cast<_class *>(NULL)->_member)
//**************************************************************************
// MACHINE CONFIG MACROS
//**************************************************************************
// start/end tags for the machine driver
#define MACHINE_DRIVER_NAME(_name) \
machine_config_##_name
#define MACHINE_DRIVER_NAME(_name) construct_machine_config_##_name
#define MACHINE_DRIVER_START(_name) \
const machine_config_token MACHINE_DRIVER_NAME(_name)[] = {
void MACHINE_DRIVER_NAME(_name)(machine_config &config, device_config *owner) \
{ \
device_config *device = NULL; \
const char *tag; \
astring tempstring; \
(void)device; \
(void)tag; \
#define MACHINE_DRIVER_END \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_END, 8) };
}
// use this to declare external references to a machine driver
#define MACHINE_DRIVER_EXTERN(_name) \
extern const machine_config_token MACHINE_DRIVER_NAME(_name)[]
extern void MACHINE_DRIVER_NAME(_name)(machine_config &config, device_config *owner)
// importing data from other machine drivers
#define MDRV_IMPORT_FROM(_name) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_INCLUDE, 8), \
TOKEN_PTR(tokenptr, MACHINE_DRIVER_NAME(_name)),
MACHINE_DRIVER_NAME(_name)(config, owner);
// core parameters
#define MDRV_DRIVER_DATA(_class) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DRIVER_DATA, 8), \
TOKEN_PTR(m_driver_data_alloc, _class::alloc),
config.m_driver_data_alloc = &_class::alloc; \
#define MDRV_QUANTUM_TIME(_time) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_QUANTUM_TIME, 8), \
TOKEN_UINT64(UINT64_ATTOTIME_IN_##_time),
config.m_minimum_quantum = ATTOTIME_IN_##_time; \
#define MDRV_QUANTUM_PERFECT_CPU(_cputag) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_QUANTUM_PERFECT_CPU, 8), \
TOKEN_STRING(_cputag),
config.m_perfect_cpu_quantum = _cputag; \
#define MDRV_WATCHDOG_VBLANK_INIT(_count) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_WATCHDOG_VBLANK, 8, _count, 24),
config.m_watchdog_vblank_count = _count; \
#define MDRV_WATCHDOG_TIME_INIT(_time) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_WATCHDOG_TIME, 8), \
TOKEN_UINT64(UINT64_ATTOTIME_IN_##_time),
config.m_watchdog_time = ATTOTIME_IN_##_time; \
// core functions
#define MDRV_MACHINE_START(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MACHINE_START, 8), \
TOKEN_PTR(machine_start, MACHINE_START_NAME(_func)),
config.m_machine_start = MACHINE_START_NAME(_func); \
#define MDRV_MACHINE_RESET(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MACHINE_RESET, 8), \
TOKEN_PTR(machine_reset, MACHINE_RESET_NAME(_func)),
config.m_machine_reset = MACHINE_RESET_NAME(_func); \
#define MDRV_NVRAM_HANDLER(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_NVRAM_HANDLER, 8), \
TOKEN_PTR(nvram_handler, NVRAM_HANDLER_NAME(_func)),
config.m_nvram_handler = NVRAM_HANDLER_NAME(_func); \
#define MDRV_MEMCARD_HANDLER(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MEMCARD_HANDLER, 8), \
TOKEN_PTR(memcard_handler, MEMCARD_HANDLER_NAME(_func)),
config.m_memcard_handler = MEMCARD_HANDLER_NAME(_func); \
// core video parameters
#define MDRV_VIDEO_ATTRIBUTES(_flags) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_VIDEO_ATTRIBUTES, 8, _flags, 24),
config.m_video_attributes = _flags; \
#define MDRV_GFXDECODE(_gfx) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_GFXDECODE, 8), \
TOKEN_PTR(gfxdecode, GFXDECODE_NAME(_gfx)),
config.m_gfxdecodeinfo = GFXDECODE_NAME(_gfx); \
#define MDRV_PALETTE_LENGTH(_length) \
TOKEN_UINT32_PACK2(MCONFIG_TOKEN_PALETTE_LENGTH, 8, _length, 24),
config.m_total_colors = _length; \
#define MDRV_DEFAULT_LAYOUT(_layout) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEFAULT_LAYOUT, 8), \
TOKEN_STRING(&(_layout)[0]),
config.m_default_layout = &(_layout)[0]; \
// core video functions
#define MDRV_PALETTE_INIT(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_PALETTE_INIT, 8), \
TOKEN_PTR(palette_init, PALETTE_INIT_NAME(_func)),
config.m_init_palette = PALETTE_INIT_NAME(_func); \
#define MDRV_VIDEO_START(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_START, 8), \
TOKEN_PTR(video_start, VIDEO_START_NAME(_func)),
config.m_video_start = VIDEO_START_NAME(_func); \
#define MDRV_VIDEO_RESET(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_RESET, 8), \
TOKEN_PTR(video_reset, VIDEO_RESET_NAME(_func)),
config.m_video_reset = VIDEO_RESET_NAME(_func); \
#define MDRV_VIDEO_EOF(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_EOF, 8), \
TOKEN_PTR(video_eof, VIDEO_EOF_NAME(_func)),
config.m_video_eof = VIDEO_EOF_NAME(_func); \
#define MDRV_VIDEO_UPDATE(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_UPDATE, 8), \
TOKEN_PTR(video_update, VIDEO_UPDATE_NAME(_func)),
config.m_video_update = VIDEO_UPDATE_NAME(_func); \
// core sound functions
#define MDRV_SOUND_START(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_START, 8), \
TOKEN_PTR(sound_start, SOUND_START_NAME(_func)),
config.m_sound_start = SOUND_START_NAME(_func); \
#define MDRV_SOUND_RESET(_func) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_RESET, 8), \
TOKEN_PTR(sound_reset, SOUND_RESET_NAME(_func)),
config.m_sound_reset = SOUND_RESET_NAME(_func); \
// add/remove devices
#define MDRV_DEVICE_ADD(_tag, _type, _clock) \
TOKEN_UINT64_PACK2(MCONFIG_TOKEN_DEVICE_ADD, 8, _clock, 32), \
TOKEN_PTR(devtype, _type), \
TOKEN_STRING(_tag),
device = config.device_add(owner, _tag, _type, _clock); \
#define MDRV_DEVICE_REPLACE(_tag, _type, _clock) \
TOKEN_UINT64_PACK2(MCONFIG_TOKEN_DEVICE_REPLACE, 8, _clock, 32), \
TOKEN_PTR(devtype, _type), \
TOKEN_STRING(_tag),
device = config.device_replace(owner, _tag, _type, _clock); \
#define MDRV_DEVICE_REMOVE(_tag) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_REMOVE, 8), \
TOKEN_STRING(_tag),
device = config.device_remove(owner, _tag); \
#define MDRV_DEVICE_MODIFY(_tag) \
TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_MODIFY, 8), \
TOKEN_STRING(_tag),
device = config.device_find(owner, _tag); \
#endif /* __MCONFIG_H__ */

15
src/emu/sound.c
View File

@ -496,17 +496,16 @@ device_t *speaker_device_config::alloc_device(running_machine &machine) const
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_set_position - configuration helper to
// set the speaker position
//-------------------------------------------------
void speaker_device_config::device_config_complete()
void speaker_device_config::static_set_position(device_config *device, double x, double y, double z)
{
// move inline data into its final home
m_x = static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_X])) / (double)(1 << 24);
m_y = static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_Y])) / (double)(1 << 24);
m_z = static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_Z])) / (double)(1 << 24);
speaker_device_config *speaker = downcast<speaker_device_config *>(device);
speaker->m_x = x;
speaker->m_y = y;
speaker->m_z = z;
}

18
src/emu/sound.h
View File

@ -49,19 +49,11 @@ public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
// indexes to inline data
enum
{
INLINE_X,
INLINE_Y,
INLINE_Z
};
// inline configuration helpers
static void static_set_position(device_config *device, double x, double y, double z);
protected:
// device_config overrides
virtual void device_config_complete();
// internal state
// inline configuration state
double m_x;
double m_y;
double m_z;
@ -133,9 +125,7 @@ extern const device_type SPEAKER;
/* add/remove speakers */
#define MDRV_SPEAKER_ADD(_tag, _x, _y, _z) \
MDRV_DEVICE_ADD(_tag, SPEAKER, 0) \
MDRV_DEVICE_INLINE_DATA32(speaker_device_config::INLINE_X, (INT32)((_x) * (double)(1 << 24))) \
MDRV_DEVICE_INLINE_DATA32(speaker_device_config::INLINE_Y, (INT32)((_y) * (double)(1 << 24))) \
MDRV_DEVICE_INLINE_DATA32(speaker_device_config::INLINE_Z, (INT32)((_z) * (double)(1 << 24)))
speaker_device_config::static_set_position(device, _x, _y, _z); \
#define MDRV_SPEAKER_STANDARD_MONO(_tag) \
MDRV_SPEAKER_ADD(_tag, 0.0, 0.0, 1.0)

11
src/emu/sound/okim6295.c
View File

@ -118,15 +118,14 @@ device_t *okim6295_device_config::alloc_device(running_machine &machine) const
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_set_pin7 - configuration helper to set
// the pin 7 state
//-------------------------------------------------
void okim6295_device_config::device_config_complete()
void okim6295_device_config::static_set_pin7(device_config *device, int pin7)
{
// copy the pin7 state from inline data
m_pin7 = m_inline_data[INLINE_PIN7];
okim6295_device_config *okim6295 = downcast<okim6295_device_config *>(device);
okim6295->m_pin7 = pin7;
}

12
src/emu/sound/okim6295.h
View File

@ -40,7 +40,7 @@ enum
MDRV_OKIM6295_PIN7(_pin7)
#define MDRV_OKIM6295_PIN7(_pin7) \
MDRV_DEVICE_INLINE_DATA16(okim6295_device_config::INLINE_PIN7, _pin7)
okim6295_device_config::static_set_pin7(device, _pin7); \
@ -89,19 +89,17 @@ public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
// inline configuration indexes
enum
{
INLINE_PIN7
};
// inline configuration helpers
static void static_set_pin7(device_config *device, int pin7);
protected:
// device_config overrides
virtual void device_config_complete();
virtual const address_space_config *memory_space_config(int spacenum = 0) const;
// internal state
const address_space_config m_space_config;
// inline data
UINT8 m_pin7;
};

118
src/emu/timer.c
View File

@ -943,8 +943,8 @@ timer_device_config::timer_device_config(const machine_config &mconfig, const ch
m_type(TIMER_TYPE_GENERIC),
m_callback(NULL),
m_ptr(NULL),
m_start_delay(0),
m_period(0),
m_start_delay(attotime_zero),
m_period(attotime_zero),
m_param(0),
m_screen(NULL),
m_first_vpos(0),
@ -975,23 +975,93 @@ device_t *timer_device_config::alloc_device(running_machine &machine) const
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_configure_generic - configuration
// helper to set up a generic timer
//-------------------------------------------------
void timer_device_config::device_config_complete()
void timer_device_config::static_configure_generic(device_config *device, timer_device_fired_func callback)
{
// move inline data into its final home
m_type = static_cast<timer_type>(m_inline_data[INLINE_TYPE]);
m_callback = reinterpret_cast<timer_device_fired_func>(m_inline_data[INLINE_CALLBACK]);
m_ptr = reinterpret_cast<void *>(m_inline_data[INLINE_PTR]);
m_start_delay = static_cast<UINT64>(m_inline_data[INLINE_DELAY]);
m_period = static_cast<UINT64>(m_inline_data[INLINE_PERIOD]);
m_param = static_cast<UINT32>(m_inline_data[INLINE_PARAM]);
m_screen = reinterpret_cast<const char *>(m_inline_data[INLINE_SCREEN]);
m_first_vpos = static_cast<INT16>(m_inline_data[INLINE_FIRST_VPOS]);
m_increment = static_cast<INT16>(m_inline_data[INLINE_INCREMENT]);
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_type = TIMER_TYPE_GENERIC;
timer->m_callback = callback;
}
//-------------------------------------------------
// static_configure_periodic - configuration
// helper to set up a periodic timer
//-------------------------------------------------
void timer_device_config::static_configure_periodic(device_config *device, timer_device_fired_func callback, attotime period)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_type = TIMER_TYPE_PERIODIC;
timer->m_callback = callback;
timer->m_period = period;
}
//-------------------------------------------------
// static_configure_scanline - configuration
// helper to set up a scanline timer
//-------------------------------------------------
void timer_device_config::static_configure_scanline(device_config *device, timer_device_fired_func callback, const char *screen, int first_vpos, int increment)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_type = TIMER_TYPE_SCANLINE;
timer->m_callback = callback;
timer->m_screen = screen;
timer->m_first_vpos = first_vpos;
timer->m_increment = increment;
}
//-------------------------------------------------
// static_set_callback - configuration helper
// to set the callback
//-------------------------------------------------
void timer_device_config::static_set_callback(device_config *device, timer_device_fired_func callback)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_callback = callback;
}
//-------------------------------------------------
// static_set_start_delay - configuration helper
// to set the starting delay
//-------------------------------------------------
void timer_device_config::static_set_start_delay(device_config *device, attotime delay)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_start_delay = delay;
}
//-------------------------------------------------
// static_set_param - configuration helper to set
// the integer parameter
//-------------------------------------------------
void timer_device_config::static_set_param(device_config *device, int param)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_param = param;
}
//-------------------------------------------------
// static_set_ptr - configuration helper to set
// the pointer parameter
//-------------------------------------------------
void timer_device_config::static_set_ptr(device_config *device, void *ptr)
{
timer_device_config *timer = downcast<timer_device_config *>(device);
timer->m_ptr = ptr;
}
@ -1008,16 +1078,16 @@ bool timer_device_config::device_validity_check(const game_driver &driver) const
switch (m_type)
{
case TIMER_TYPE_GENERIC:
if (m_screen != NULL || m_first_vpos != 0 || m_start_delay != 0)
if (m_screen != NULL || m_first_vpos != 0 || attotime_compare(m_start_delay, attotime_zero) != 0)
mame_printf_warning("%s: %s generic timer '%s' specified parameters for a scanline timer\n", driver.source_file, driver.name, tag());
if (m_period != 0 || m_start_delay != 0)
if (attotime_compare(m_period, attotime_zero) != 0 || attotime_compare(m_start_delay, attotime_zero) != 0)
mame_printf_warning("%s: %s generic timer '%s' specified parameters for a periodic timer\n", driver.source_file, driver.name, tag());
break;
case TIMER_TYPE_PERIODIC:
if (m_screen != NULL || m_first_vpos != 0)
mame_printf_warning("%s: %s periodic timer '%s' specified parameters for a scanline timer\n", driver.source_file, driver.name, tag());
if (m_period <= 0)
if (attotime_compare(m_period, attotime_zero) <= 0)
{
mame_printf_error("%s: %s periodic timer '%s' specified invalid period\n", driver.source_file, driver.name, tag());
error = true;
@ -1025,7 +1095,7 @@ bool timer_device_config::device_validity_check(const game_driver &driver) const
break;
case TIMER_TYPE_SCANLINE:
if (m_period != 0 || m_start_delay != 0)
if (attotime_compare(m_period, attotime_zero) != 0 || attotime_compare(m_start_delay, attotime_zero) != 0)
mame_printf_warning("%s: %s scanline timer '%s' specified parameters for a periodic timer\n", driver.source_file, driver.name, tag());
if (m_param != 0)
mame_printf_warning("%s: %s scanline timer '%s' specified parameter which is ignored\n", driver.source_file, driver.name, tag());
@ -1104,14 +1174,14 @@ void timer_device::device_reset()
{
// convert the period into attotime
attotime period = attotime_never;
if (m_config.m_period > 0)
if (attotime_compare(m_config.m_period, attotime_zero) > 0)
{
period = UINT64_ATTOTIME_TO_ATTOTIME(m_config.m_period);
period = m_config.m_period;
// convert the start_delay into attotime
attotime start_delay = attotime_zero;
if (m_config.m_start_delay > 0)
start_delay = UINT64_ATTOTIME_TO_ATTOTIME(m_config.m_start_delay);
if (attotime_compare(m_config.m_start_delay, attotime_zero) > 0)
start_delay = m_config.m_start_delay;
// allocate and start the backing timer
timer_adjust_periodic(m_timer, start_delay, m_config.m_param, period);

55
src/emu/timer.h
View File

@ -80,37 +80,30 @@ struct timer_execution_state
#define MDRV_TIMER_ADD(_tag, _callback) \
MDRV_DEVICE_ADD(_tag, TIMER, 0) \
MDRV_DEVICE_INLINE_DATA16(timer_device_config::INLINE_TYPE, timer_device_config::TIMER_TYPE_GENERIC) \
MDRV_DEVICE_INLINE_DATAPTR(timer_device_config::INLINE_CALLBACK, _callback)
timer_device_config::static_configure_generic(device, _callback); \
#define MDRV_TIMER_ADD_PERIODIC(_tag, _callback, _period) \
MDRV_DEVICE_ADD(_tag, TIMER, 0) \
MDRV_DEVICE_INLINE_DATA16(timer_device_config::INLINE_TYPE, timer_device_config::TIMER_TYPE_PERIODIC) \
MDRV_DEVICE_INLINE_DATAPTR(timer_device_config::INLINE_CALLBACK, _callback) \
MDRV_DEVICE_INLINE_DATA64(timer_device_config::INLINE_PERIOD, UINT64_ATTOTIME_IN_##_period)
timer_device_config::static_configure_periodic(device, _callback, ATTOTIME_IN_##_period); \
#define MDRV_TIMER_ADD_SCANLINE(_tag, _callback, _screen, _first_vpos, _increment) \
MDRV_DEVICE_ADD(_tag, TIMER, 0) \
MDRV_DEVICE_INLINE_DATA16(timer_device_config::INLINE_TYPE, timer_device_config::TIMER_TYPE_SCANLINE) \
MDRV_DEVICE_INLINE_DATAPTR(timer_device_config::INLINE_CALLBACK, _callback) \
MDRV_DEVICE_INLINE_DATAPTR(timer_device_config::INLINE_SCREEN, _screen) \
MDRV_DEVICE_INLINE_DATA16(timer_device_config::INLINE_FIRST_VPOS, _first_vpos) \
MDRV_DEVICE_INLINE_DATA16(timer_device_config::INLINE_INCREMENT, _increment)
timer_device_config::static_configure_scanline(device, _callback, _screen, _first_vpos, _increment); \
#define MDRV_TIMER_MODIFY(_tag) \
MDRV_DEVICE_MODIFY(_tag)
#define MDRV_TIMER_CALLBACK(_callback) \
MDRV_DEVICE_INLINE_DATA32(timer_device_config::INLINE_CALLBACK, _callback)
timer_device_config::static_set_callback(device, _callback); \
#define MDRV_TIMER_START_DELAY(_start_delay) \
MDRV_DEVICE_INLINE_DATA64(timer_device_config::INLINE_DELAY, UINT64_ATTOTIME_IN_##_start_delay)
timer_device_config::static_set_start_delay(device, ATTOTIME_IN_##_start_delay); \
#define MDRV_TIMER_PARAM(_param) \
MDRV_DEVICE_INLINE_DATA32(timer_device_config::INLINE_PARAM, _param)
timer_device_config::static_set_param(device, _param); \
#define MDRV_TIMER_PTR(_ptr) \
MDRV_DEVICE_INLINE_DATAPTR(timer_device_config::INLINE_PTR, _ptr)
timer_device_config::static_set_ptr(device, (void *)(_ptr)); \
@ -233,19 +226,18 @@ public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
// indexes to inline data
enum
{
INLINE_TYPE,
INLINE_CALLBACK,
INLINE_PERIOD,
INLINE_SCREEN,
INLINE_FIRST_VPOS,
INLINE_INCREMENT,
INLINE_DELAY,
INLINE_PARAM,
INLINE_PTR
};
// inline configuration helpers
static void static_configure_generic(device_config *device, timer_device_fired_func callback);
static void static_configure_periodic(device_config *device, timer_device_fired_func callback, attotime period);
static void static_configure_scanline(device_config *device, timer_device_fired_func callback, const char *screen, int first_vpos, int increment);
static void static_set_callback(device_config *device, timer_device_fired_func callback);
static void static_set_start_delay(device_config *device, attotime delay);
static void static_set_param(device_config *device, int param);
static void static_set_ptr(device_config *device, void *ptr);
private:
// device_config overrides
virtual bool device_validity_check(const game_driver &driver) const;
// timer types
enum timer_type
@ -255,19 +247,14 @@ public:
TIMER_TYPE_GENERIC
};
private:
// device_config overrides
virtual void device_config_complete();
virtual bool device_validity_check(const game_driver &driver) const;
// configuration data
timer_type m_type; // type of timer
timer_device_fired_func m_callback; // the timer's callback function
void * m_ptr; // the pointer parameter passed to the timer callback
// periodic timers only
UINT64 m_start_delay; // delay before the timer fires for the first time
UINT64 m_period; // period of repeated timer firings
attotime m_start_delay; // delay before the timer fires for the first time
attotime m_period; // period of repeated timer firings
INT32 m_param; // the integer parameter passed to the timer callback
// scanline timers only

125
src/emu/video.c
View File

@ -1721,29 +1721,114 @@ device_t *screen_device_config::alloc_device(running_machine &machine) const
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
// static_set_format - configuration helper
// to set the bitmap format
//-------------------------------------------------
void screen_device_config::device_config_complete()
void screen_device_config::static_set_format(device_config *device, bitmap_format format)
{
// move inline data into its final home
m_type = static_cast<screen_type_enum>(m_inline_data[INLINE_TYPE]);
m_width = static_cast<INT16>(m_inline_data[INLINE_WIDTH]);
m_height = static_cast<INT16>(m_inline_data[INLINE_HEIGHT]);
m_visarea.min_x = static_cast<INT16>(m_inline_data[INLINE_VIS_MINX]);
m_visarea.min_y = static_cast<INT16>(m_inline_data[INLINE_VIS_MINY]);
m_visarea.max_x = static_cast<INT16>(m_inline_data[INLINE_VIS_MAXX]);
m_visarea.max_y = static_cast<INT16>(m_inline_data[INLINE_VIS_MAXY]);
m_oldstyle_vblank_supplied = (m_inline_data[INLINE_OLDVBLANK] != 0);
m_refresh = m_inline_data[INLINE_REFRESH];
m_vblank = m_inline_data[INLINE_VBLANK];
m_format = static_cast<bitmap_format>(m_inline_data[INLINE_FORMAT]);
m_xoffset = static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_XOFFSET])) / (double)(1 << 24);
m_yoffset = static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_YOFFSET])) / (double)(1 << 24);
m_xscale = (m_inline_data[INLINE_XSCALE] == 0) ? 1.0 : (static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_XSCALE])) / (double)(1 << 24));
m_yscale = (m_inline_data[INLINE_YSCALE] == 0) ? 1.0 : (static_cast<double>(static_cast<INT32>(m_inline_data[INLINE_YSCALE])) / (double)(1 << 24));
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_format = format;
}
//-------------------------------------------------
// static_set_type - configuration helper
// to set the screen type
//-------------------------------------------------
void screen_device_config::static_set_type(device_config *device, screen_type_enum type)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_type = type;
}
//-------------------------------------------------
// static_set_raw - configuration helper
// to set the raw screen parameters
//-------------------------------------------------
void screen_device_config::static_set_raw(device_config *device, UINT32 pixclock, UINT16 htotal, UINT16 hbend, UINT16 hbstart, UINT16 vtotal, UINT16 vbend, UINT16 vbstart)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_refresh = HZ_TO_ATTOSECONDS(pixclock) * htotal * vtotal;
screen->m_vblank = screen->m_refresh / vtotal * (vtotal - (vbstart - vbend));
screen->m_width = htotal;
screen->m_height = vtotal;
screen->m_visarea.min_x = hbend;
screen->m_visarea.max_x = hbstart - 1;
screen->m_visarea.min_y = vbend;
screen->m_visarea.max_y = vbstart - 1;
}
//-------------------------------------------------
// static_set_refresh - configuration helper
// to set the refresh rate
//-------------------------------------------------
void screen_device_config::static_set_refresh(device_config *device, attoseconds_t rate)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_refresh = rate;
}
//-------------------------------------------------
// static_set_vblank_time - configuration helper
// to set the VBLANK duration
//-------------------------------------------------
void screen_device_config::static_set_vblank_time(device_config *device, attoseconds_t time)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_vblank = time;
screen->m_oldstyle_vblank_supplied = true;
}
//-------------------------------------------------
// static_set_size - configuration helper to set
// the width/height of the screen
//-------------------------------------------------
void screen_device_config::static_set_size(device_config *device, UINT16 width, UINT16 height)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_width = width;
screen->m_height = height;
}
//-------------------------------------------------
// static_set_visarea - configuration helper to
// set the visible area of the screen
//-------------------------------------------------
void screen_device_config::static_set_visarea(device_config *device, INT16 minx, INT16 maxx, INT16 miny, INT16 maxy)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_visarea.min_x = minx;
screen->m_visarea.max_x = maxx;
screen->m_visarea.min_y = miny;
screen->m_visarea.max_y = maxy;
}
//-------------------------------------------------
// static_set_default_position - configuration
// helper to set the default position and scale
// factors for the screen
//-------------------------------------------------
void screen_device_config::static_set_default_position(device_config *device, double xscale, double xoffs, double yscale, double yoffs)
{
screen_device_config *screen = downcast<screen_device_config *>(device);
screen->m_xscale = xscale;
screen->m_xoffset = xoffs;
screen->m_yscale = yscale;
screen->m_yoffset = yoffs;
}

64
src/emu/video.h
View File

@ -108,32 +108,21 @@ public:
float xscale() const { return m_xscale; }
float yscale() const { return m_yscale; }
// indexes to inline data
enum
{
INLINE_TYPE,
INLINE_FORMAT,
INLINE_REFRESH,
INLINE_VBLANK,
INLINE_WIDTH,
INLINE_HEIGHT,
INLINE_VIS_MINX,
INLINE_VIS_MAXX,
INLINE_VIS_MINY,
INLINE_VIS_MAXY,
INLINE_XOFFSET,
INLINE_XSCALE,
INLINE_YOFFSET,
INLINE_YSCALE,
INLINE_OLDVBLANK
};
// inline configuration helpers
static void static_set_format(device_config *device, bitmap_format format);
static void static_set_type(device_config *device, screen_type_enum type);
static void static_set_raw(device_config *device, UINT32 pixclock, UINT16 htotal, UINT16 hbend, UINT16 hbstart, UINT16 vtotal, UINT16 vbend, UINT16 vbstart);
static void static_set_refresh(device_config *device, attoseconds_t rate);
static void static_set_vblank_time(device_config *device, attoseconds_t time);
static void static_set_size(device_config *device, UINT16 width, UINT16 height);
static void static_set_visarea(device_config *device, INT16 minx, INT16 maxx, INT16 miny, INT16 maxy);
static void static_set_default_position(device_config *device, double xscale, double xoffs, double yscale, double yoffs);
private:
// device_config overrides
virtual void device_config_complete();
virtual bool device_validity_check(const game_driver &driver) const;
// configuration data
// inline configuration data
screen_type_enum m_type; // type of screen
int m_width, m_height; // default total width/height (HTOTAL, VTOTAL)
rectangle m_visarea; // default visible area (HBLANK end/start, VBLANK end/start)
@ -279,49 +268,34 @@ extern const device_type SCREEN;
#define MDRV_SCREEN_ADD(_tag, _type) \
MDRV_DEVICE_ADD(_tag, SCREEN, 0) \
MDRV_SCREEN_TYPE(_type)
MDRV_SCREEN_TYPE(_type) \
#define MDRV_SCREEN_MODIFY(_tag) \
MDRV_DEVICE_MODIFY(_tag)
#define MDRV_SCREEN_FORMAT(_format) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_FORMAT, _format)
screen_device_config::static_set_format(device, _format); \
#define MDRV_SCREEN_TYPE(_type) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_TYPE, SCREEN_TYPE_##_type)
screen_device_config::static_set_type(device, SCREEN_TYPE_##_type); \
#define MDRV_SCREEN_RAW_PARAMS(_pixclock, _htotal, _hbend, _hbstart, _vtotal, _vbend, _vbstart) \
MDRV_DEVICE_INLINE_DATA64(screen_device_config::INLINE_REFRESH, HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) \
MDRV_DEVICE_INLINE_DATA64(screen_device_config::INLINE_VBLANK, ((HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) / (_vtotal)) * ((_vtotal) - ((_vbstart) - (_vbend)))) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_WIDTH, _htotal) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_HEIGHT, _vtotal) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MINX, _hbend) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MAXX, (_hbstart) - 1) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MINY, _vbend) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MAXY, (_vbstart) - 1)
screen_device_config::static_set_raw(device, _pixclock, _htotal, _hbend, _hbstart, _vtotal, _vbend, _vbstart);
#define MDRV_SCREEN_REFRESH_RATE(_rate) \
MDRV_DEVICE_INLINE_DATA64(screen_device_config::INLINE_REFRESH, HZ_TO_ATTOSECONDS(_rate))
screen_device_config::static_set_refresh(device, HZ_TO_ATTOSECONDS(_rate)); \
#define MDRV_SCREEN_VBLANK_TIME(_time) \
MDRV_DEVICE_INLINE_DATA64(screen_device_config::INLINE_VBLANK, _time) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_OLDVBLANK, true)
screen_device_config::static_set_vblank_time(device, _time); \
#define MDRV_SCREEN_SIZE(_width, _height) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_WIDTH, _width) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_HEIGHT, _height)
screen_device_config::static_set_size(device, _width, _height); \
#define MDRV_SCREEN_VISIBLE_AREA(_minx, _maxx, _miny, _maxy) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MINX, _minx) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MAXX, _maxx) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MINY, _miny) \
MDRV_DEVICE_INLINE_DATA16(screen_device_config::INLINE_VIS_MAXY, _maxy)
screen_device_config::static_set_visarea(device, _minx, _maxx, _miny, _maxy); \
#define MDRV_SCREEN_DEFAULT_POSITION(_xscale, _xoffs, _yscale, _yoffs) \
MDRV_DEVICE_INLINE_DATA32(screen_device_config::INLINE_XOFFSET, (INT32)((_xoffs) * (double)(1 << 24))) \
MDRV_DEVICE_INLINE_DATA32(screen_device_config::INLINE_XSCALE, (INT32)((_xscale) * (double)(1 << 24))) \
MDRV_DEVICE_INLINE_DATA32(screen_device_config::INLINE_YOFFSET, (INT32)((_yoffs) * (double)(1 << 24))) \
MDRV_DEVICE_INLINE_DATA32(screen_device_config::INLINE_YSCALE, (INT32)((_yscale) * (double)(1 << 24)))
screen_device_config::static_set_default_position(device, _xscale, _xoffs, _yscale, _yoffs); \

2
src/mame/drivers/goldstar.c
View File

@ -5855,6 +5855,7 @@ static MACHINE_DRIVER_START( cmasterc )
MACHINE_DRIVER_END
#ifdef UNUSED_CODE
static MACHINE_DRIVER_START( cmnobmp )
MDRV_DRIVER_DATA(goldstar_state)
@ -5891,6 +5892,7 @@ static MACHINE_DRIVER_START( cmnobmp )
MDRV_SOUND_CONFIG(cm_ay8910_config)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
MACHINE_DRIVER_END
#endif
static MACHINE_DRIVER_START( cmast91 )

2
src/mame/drivers/itgamble.c
View File

@ -217,6 +217,7 @@ static MACHINE_DRIVER_START( mnumber )
MACHINE_DRIVER_END
#ifdef UNUSED_CODE
static MACHINE_DRIVER_START( ejollyx5 )
MDRV_IMPORT_FROM(itgamble)
@ -227,6 +228,7 @@ static MACHINE_DRIVER_START( ejollyx5 )
MDRV_OKIM6295_REPLACE("oki", MNUMBER_SND_CLOCK/16, OKIM6295_PIN7_HIGH) /* clock frequency & pin 7 not verified */
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
MACHINE_DRIVER_END
#endif
/*************************

4
src/mame/drivers/norautp.c
View File

@ -848,10 +848,12 @@ static ADDRESS_MAP_START( norautx4_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x6000, 0x67ff) AM_RAM AM_BASE_SIZE_GENERIC(nvram) /* 6116 */
ADDRESS_MAP_END
#ifdef UNUSED_CODE
static ADDRESS_MAP_START( norautx8_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x0000, 0x7fff) AM_ROM /* need to be checked */
AM_RANGE(0xc000, 0xc7ff) AM_RAM AM_BASE_SIZE_GENERIC(nvram) /* 6116 */
ADDRESS_MAP_END
#endif
static ADDRESS_MAP_START( kimble_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x0000, 0xbfff) AM_ROM
@ -1322,6 +1324,7 @@ static MACHINE_DRIVER_START( norautx4 )
MACHINE_DRIVER_END
#ifdef UNUSED_CODE
static MACHINE_DRIVER_START( norautx8 )
MDRV_IMPORT_FROM(noraut_base)
@ -1330,6 +1333,7 @@ static MACHINE_DRIVER_START( norautx8 )
MDRV_CPU_PROGRAM_MAP(norautx8_map)
MDRV_CPU_VBLANK_INT("screen", irq0_line_hold)
MACHINE_DRIVER_END
#endif
static MACHINE_DRIVER_START( kimble )

2
src/mame/drivers/taito_l.c
View File

@ -2323,6 +2323,7 @@ static MACHINE_DRIVER_START( evilston )
MDRV_TC0140SYT_ADD("tc0140syt", taitol_tc0140syt_intf)
MACHINE_DRIVER_END
#ifdef UNUSED_CODE
static MACHINE_DRIVER_START( lagirl )
/* basic machine hardware */
@ -2336,6 +2337,7 @@ static MACHINE_DRIVER_START( lagirl )
MDRV_MACHINE_RESET(cachat)
MACHINE_DRIVER_END
#endif
ROM_START( raimais )

2
src/mame/drivers/tecmo.c
View File

@ -736,6 +736,7 @@ static MACHINE_DRIVER_START( silkworm )
MDRV_CPU_PROGRAM_MAP(silkworm_map)
MACHINE_DRIVER_END
#ifdef UNUSED_CODE
static MACHINE_DRIVER_START( backfirt )
/* basic machine hardware */
@ -772,6 +773,7 @@ static MACHINE_DRIVER_START( backfirt )
/* no MSM on this PCB */
MACHINE_DRIVER_END
#endif
/***************************************************************************

2
src/mame/includes/galaxian.h
View File

@ -56,7 +56,7 @@ WRITE8_HANDLER( scramble_background_blue_w );
WRITE8_HANDLER( galaxian_gfxbank_w );
TIMER_CALLBACK( galaxian_stars_blink_timer );
TIMER_DEVICE_CALLBACK( galaxian_stars_blink_timer );
/* video extension callbacks */
typedef void (*galaxian_extend_tile_info_func)(UINT16 *code, UINT8 *color, UINT8 attrib, UINT8 x);

2
src/mame/video/galaxian.c
View File

@ -879,7 +879,7 @@ static void stars_update_origin(running_machine *machine)
*
*************************************/
TIMER_CALLBACK( galaxian_stars_blink_timer )
TIMER_DEVICE_CALLBACK( galaxian_stars_blink_timer )
{
stars_blink_state++;
}

5
src/mame/video/gp9001.c
View File

@ -205,9 +205,10 @@ device_t *gp9001vdp_device_config::alloc_device(running_machine &machine) const
return auto_alloc(&machine, gp9001vdp_device(machine, *this));
}
void gp9001vdp_device_config::device_config_complete()
void gp9001vdp_device_config::static_set_gfx_region(device_config *device, int gfxregion)
{
m_gfxregion = m_inline_data[0];
gp9001vdp_device_config *vdp = downcast<gp9001vdp_device_config *>(device);
vdp->m_gfxregion = gfxregion;
}
bool gp9001vdp_device_config::device_validity_check(const game_driver &driver) const

7
src/mame/video/gp9001.h
View File

@ -8,13 +8,12 @@ class gp9001vdp_device_config : public device_config,
public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
static void static_set_gfx_region(device_config *device, int gfxregion);
protected:
virtual void device_config_complete();
virtual bool device_validity_check(const game_driver &driver) const;
virtual const address_space_config *memory_space_config(int spacenum = 0) const;
address_space_config m_space_config;
UINT8 m_gfxregion;
};
class gp9001vdp_device : public device_t,
@ -102,12 +101,12 @@ ADDRESS_MAP_EXTERN( gp9001vdp1_map, 16 );
/* vdp map 0, gfx region 0 */
#define MDRV_DEVICE_ADD_VDP0 \
MDRV_DEVICE_ADD("gp9001vdp0", gp9001vdp_, 0) \
MDRV_DEVICE_INLINE_DATA16(0, 0) \
gp9001vdp_device_config::static_set_gfx_region(device, 0); \
/* vdp map 1, gfx region 2 */
#define MDRV_DEVICE_ADD_VDP1 \
MDRV_DEVICE_ADD("gp9001vdp1", gp9001vdp_, 0) \
MDRV_DEVICE_INLINE_DATA16(0, 2) \
gp9001vdp_device_config::static_set_gfx_region(device, 2); \
// access to VDP