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

Cleanups and version bump.

Browse Source
This commit is contained in:
Aaron Giles 2010-07-06 17:30:28 +00:00
parent bcd97e9880
commit 30662dcdef
63 changed files with 811 additions and 811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/emu/cheat.c
View File

@ -409,7 +409,7 @@ void cheat_reload(running_machine *machine)
/* load the cheat file, MESS will load a crc32.xml ( eg. 01234567.xml )
and MAME will load gamename.xml */
device_image_interface *image = NULL;
device_image_interface *image = NULL;
for (bool gotone = machine->m_devicelist.first(image); gotone; gotone = image->next(image))
{
if (image->exists())
@ -423,7 +423,7 @@ void cheat_reload(running_machine *machine)
}
}
}
if (cheatinfo->cheatlist == NULL)
if (cheatinfo->cheatlist == NULL)
{
cheatinfo->cheatlist = cheat_list_load(machine, machine->basename());
}

12
src/emu/clifront.c
View File

@ -97,7 +97,7 @@ static const options_entry cli_options[] =
{ "listdevices;ld", "0", OPTION_COMMAND, "list available devices" },
{ "listmedia;lm", "0", OPTION_COMMAND, "list available media for the system" },
{ "listsoftware", "0", OPTION_COMMAND, "list known software for the system" },
{ NULL }
};
@ -904,8 +904,8 @@ static int info_listsoftware(core_options *options, const char *gamename)
fprintf( out, "\t\t\t<part name=\"%s\"", part->name );
if ( part->interface_ )
fprintf( out, " interface=\"%s\"", part->interface_ );
// if ( part->feature )
// fprintf( out, " features=\"%s\"", part->feature );
// if ( part->feature )
// fprintf( out, " features=\"%s\"", part->feature );
fprintf( out, ">\n");
/* TODO: display rom region information */
@ -977,8 +977,8 @@ static int info_listsoftware(core_options *options, const char *gamename)
/*-------------------------------------------------
softlist_match_roms - scan for a matching
software ROM by hash
softlist_match_roms - scan for a matching
software ROM by hash
-------------------------------------------------*/
static void softlist_match_roms(core_options *options, const char *hash, int length, int *found)
{
@ -1073,7 +1073,7 @@ static int info_listmedia(core_options *options, const char *gamename)
printf("%-13s%-12s%-8s ", driver_name, name, paren_shortname);
driver_name = " ";
astring extensions(src);
char *ext = strtok((char*)extensions.cstr(),",");
while (ext != NULL)

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

@ -512,7 +512,7 @@ struct _tms99xx_state
INLINE tms99xx_state *get_safe_token(running_device *device)
{
assert(device != NULL);
// assert(device->type() == TMS99XX_GET_INFO);
// assert(device->type() == TMS99XX_GET_INFO);
return (tms99xx_state *)downcast<legacy_cpu_device *>(device)->token();
}

84
src/emu/debug/debugcpu.c
View File

@ -1529,7 +1529,7 @@ static UINT64 get_cpunum(void *globalref, void *ref)
{
running_machine *machine = (running_machine *)globalref;
device_t *target = machine->debugcpu_data->visiblecpu;
device_execute_interface *exec;
int index = 0;
for (bool gotone = machine->m_devicelist.first(exec); gotone; gotone = exec->next(exec))
@ -1579,7 +1579,7 @@ device_debug::device_debug(device_t &device, symbol_table *globalsyms)
{
memset(m_pc_history, 0, sizeof(m_pc_history));
memset(m_wplist, 0, sizeof(m_wplist));
// find out which interfaces we have to work with
device.interface(m_exec);
device.interface(m_memory);
@ -1592,7 +1592,7 @@ device_debug::device_debug(device_t &device, symbol_table *globalsyms)
// add a global symbol for the current instruction pointer
if (m_exec != NULL)
symtable_add_register(m_symtable, "cycles", NULL, get_cycles, NULL);
// add entries to enable/disable unmap reporting for each space
if (m_memory != NULL)
{
@ -1615,7 +1615,7 @@ device_debug::device_debug(device_t &device, symbol_table *globalsyms)
{
m_flags = DEBUG_FLAG_OBSERVING | DEBUG_FLAG_HISTORY;
m_opwidth = min_opcode_bytes();
// if no curpc, add one
if (m_state != NULL && symtable_find(m_symtable, "curpc") == NULL)
symtable_add_register(m_symtable, "curpc", NULL, get_current_pc, 0);
@ -1632,7 +1632,7 @@ device_debug::~device_debug()
// free the symbol table
if (m_symtable != NULL)
symtable_free(m_symtable);
// free breakpoints and watchpoints
breakpoint_clear_all();
watchpoint_clear_all();
@ -1640,7 +1640,7 @@ device_debug::~device_debug()
//-------------------------------------------------
// start_hook - the scheduler calls this hook
// start_hook - the scheduler calls this hook
// before beginning execution for the given device
//-------------------------------------------------
@ -1699,7 +1699,7 @@ void device_debug::start_hook(attotime endtime)
//-------------------------------------------------
// stop_hook - the scheduler calls this hook when
// stop_hook - the scheduler calls this hook when
// ending execution for the given device
//-------------------------------------------------
@ -1722,7 +1722,7 @@ void device_debug::stop_hook()
//-------------------------------------------------
// interrupt_hook - called when an interrupt is
// interrupt_hook - called when an interrupt is
// acknowledged
//-------------------------------------------------
@ -1741,7 +1741,7 @@ void device_debug::interrupt_hook(int irqline)
//-------------------------------------------------
// exception_hook - called when an exception is
// exception_hook - called when an exception is
// generated
//-------------------------------------------------
@ -1760,7 +1760,7 @@ void device_debug::exception_hook(int exception)
//-------------------------------------------------
// instruction_hook - called by the CPU cores
// instruction_hook - called by the CPU cores
// before executing each instruction
//-------------------------------------------------
@ -1889,8 +1889,8 @@ void device_debug::instruction_hook(offs_t curpc)
//-------------------------------------------------
// memory_read_hook - the memory system calls
// this hook when watchpoints are enabled and a
// memory_read_hook - the memory system calls
// this hook when watchpoints are enabled and a
// memory read happens
//-------------------------------------------------
@ -1906,8 +1906,8 @@ void device_debug::memory_read_hook(const address_space &space, offs_t address,
//-------------------------------------------------
// memory_write_hook - the memory system calls
// this hook when watchpoints are enabled and a
// memory_write_hook - the memory system calls
// this hook when watchpoints are enabled and a
// memory write happens
//-------------------------------------------------
@ -1918,7 +1918,7 @@ void device_debug::memory_write_hook(const address_space &space, offs_t address,
//-------------------------------------------------
// set_instruction_hook - set a hook to be
// set_instruction_hook - set a hook to be
// called on each instruction for a given device
//-------------------------------------------------
@ -1934,7 +1934,7 @@ void device_debug::set_instruction_hook(debug_instruction_hook_func hook)
//-------------------------------------------------
// disassemble - disassemble a line at a given
// disassemble - disassemble a line at a given
// PC on a given device
//-------------------------------------------------
@ -1988,14 +1988,14 @@ void device_debug::ignore(bool ignore)
//-------------------------------------------------
// single_step - single step the device past the
// single_step - single step the device past the
// requested number of instructions
//-------------------------------------------------
void device_debug::single_step(int numsteps)
{
debugcpu_private *global = m_device.machine->debugcpu_data;
assert(m_exec != NULL);
m_stepsleft = numsteps;
@ -2006,7 +2006,7 @@ void device_debug::single_step(int numsteps)
//-------------------------------------------------
// single_step_over - single step the device over
// single_step_over - single step the device over
// the requested number of instructions
//-------------------------------------------------
@ -2024,7 +2024,7 @@ void device_debug::single_step_over(int numsteps)
//-------------------------------------------------
// single_step_out - single step the device
// single_step_out - single step the device
// out of the current function
//-------------------------------------------------
@ -2042,7 +2042,7 @@ void device_debug::single_step_out()
//-------------------------------------------------
// go - execute the device until it hits the given
// go - execute the device until it hits the given
// address
//-------------------------------------------------
@ -2075,7 +2075,7 @@ void device_debug::go_vblank()
//-------------------------------------------------
// go_interrupt - execute until the specified
// go_interrupt - execute until the specified
// interrupt fires on the device
//-------------------------------------------------
@ -2092,7 +2092,7 @@ void device_debug::go_interrupt(int irqline)
//-------------------------------------------------
// go_exception - execute until the specified
// go_exception - execute until the specified
// exception fires on the visible CPU
//-------------------------------------------------
@ -2109,7 +2109,7 @@ void device_debug::go_exception(int exception)
//-------------------------------------------------
// go_milliseconds - execute until the specified
// go_milliseconds - execute until the specified
// delay elapses
//-------------------------------------------------
@ -2126,7 +2126,7 @@ void device_debug::go_milliseconds(UINT64 milliseconds)
//-------------------------------------------------
// go_next_device - execute until we hit the next
// go_next_device - execute until we hit the next
// device
//-------------------------------------------------
@ -2142,7 +2142,7 @@ void device_debug::go_next_device()
//-------------------------------------------------
// halt_on_next_instruction - halt in the
// halt_on_next_instruction - halt in the
// debugger on the next instruction
//-------------------------------------------------
@ -2175,7 +2175,7 @@ void device_debug::halt_on_next_instruction(const char *fmt, ...)
//-------------------------------------------------
// breakpoint_set - set a new breakpoint,
// breakpoint_set - set a new breakpoint,
// returning its index
//-------------------------------------------------
@ -2187,7 +2187,7 @@ int device_debug::breakpoint_set(offs_t address, parsed_expression *condition, c
// hook it into our list
bp->m_next = m_bplist;
m_bplist = bp;
// update the flags and return the index
breakpoint_update_flags();
return bp->m_index;
@ -2264,7 +2264,7 @@ void device_debug::breakpoint_enable_all(bool enable)
//-------------------------------------------------
// watchpoint_set - set a new watchpoint,
// watchpoint_set - set a new watchpoint,
// returning its index
//-------------------------------------------------
@ -2278,7 +2278,7 @@ int device_debug::watchpoint_set(const address_space &space, int type, offs_t ad
// hook it into our list
wp->m_next = m_wplist[space.spacenum];
m_wplist[space.spacenum] = wp;
// update the flags and return the index
watchpoint_update_flags(wp->m_space);
return wp->m_index;
@ -2360,7 +2360,7 @@ void device_debug::watchpoint_enable_all(bool enable)
//-------------------------------------------------
// hotspot_track - enable/disable tracking of
// hotspot_track - enable/disable tracking of
// hotspots
//-------------------------------------------------
@ -2673,7 +2673,7 @@ void device_debug::watchpoint_check(const address_space &space, int type, offs_t
//-------------------------------------------------
// hotspot_check - check for hotspots on a
// hotspot_check - check for hotspots on a
// memory read access
//-------------------------------------------------
@ -2836,7 +2836,7 @@ device_debug::breakpoint::breakpoint(int index, offs_t address, parsed_expressio
m_action((action != NULL) ? action : "")
{
}
//-------------------------------------------------
// ~breakpoint - destructor
@ -2854,7 +2854,7 @@ device_debug::breakpoint::~breakpoint()
//-------------------------------------------------
bool device_debug::breakpoint::hit(offs_t pc)
{
{
// don't hit if disabled
if (!m_enabled)
return false;
@ -2862,12 +2862,12 @@ bool device_debug::breakpoint::hit(offs_t pc)
// must match our address
if (m_address != pc)
return false;
// must satisfy the condition
UINT64 result;
if (m_condition != NULL && expression_execute(m_condition, &result) == EXPRERR_NONE && result == 0)
return false;
return true;
}
@ -2893,7 +2893,7 @@ device_debug::watchpoint::watchpoint(int index, const address_space &space, int
m_action((action != NULL) ? action : "")
{
}
//-------------------------------------------------
// ~watchpoint - destructor
@ -2915,7 +2915,7 @@ bool device_debug::watchpoint::hit(int type, offs_t address, int size)
// don't hit if disabled
if (!m_enabled)
return false;
// must match the type
if ((m_type & type) == 0)
return false;
@ -2923,12 +2923,12 @@ bool device_debug::watchpoint::hit(int type, offs_t address, int size)
// must match our address
if (address + size <= m_address || address >= m_address + m_length)
return false;
// must satisfy the condition
UINT64 result;
if (m_condition != NULL && expression_execute(m_condition, &result) == EXPRERR_NONE && result == 0)
return false;
return true;
}
@ -2967,7 +2967,7 @@ device_debug::tracer::~tracer()
//-------------------------------------------------
// update - log to the tracefile the data for a
// update - log to the tracefile the data for a
// given instruction
//-------------------------------------------------
@ -3047,7 +3047,7 @@ void device_debug::tracer::vprintf(const char *format, va_list va)
//-------------------------------------------------
// flush - flush any pending changes to the trace
// flush - flush any pending changes to the trace
// file
//-------------------------------------------------

28
src/emu/debug/debugcpu.h
View File

@ -74,12 +74,12 @@ public:
class breakpoint
{
friend class device_debug;
public:
// construction/destruction
breakpoint(int index, offs_t address, parsed_expression *condition = NULL, const char *action = NULL);
~breakpoint();
// getters
breakpoint *next() const { return m_next; }
int index() const { return m_index; }
@ -87,7 +87,7 @@ public:
offs_t address() const { return m_address; }
const char *condition() const { return (m_condition != NULL) ? expression_original_string(m_condition) : NULL; }
const char *action() const { return m_action; }
private:
// internals
bool hit(offs_t pc);
@ -109,7 +109,7 @@ public:
// construction/destruction
watchpoint(int index, const address_space &space, int type, offs_t address, offs_t length, parsed_expression *condition = NULL, const char *action = NULL);
~watchpoint();
// getters
watchpoint *next() const { return m_next; }
const address_space &space() const { return m_space; }
@ -120,7 +120,7 @@ public:
offs_t length() const { return m_length; }
const char *condition() const { return (m_condition != NULL) ? expression_original_string(m_condition) : NULL; }
const char *action() const { return m_action; }
private:
// internals
bool hit(int type, offs_t address, int size);
@ -140,7 +140,7 @@ public:
// construction/destruction
device_debug(device_t &device, symbol_table *globalsyms);
~device_debug();
// getters
symbol_table *symtable() const { return m_symtable; }
@ -150,7 +150,7 @@ public:
int min_opcode_bytes() const { return (m_disasm != NULL) ? m_disasm->max_opcode_bytes() : 1; }
int max_opcode_bytes() const { return (m_disasm != NULL) ? m_disasm->max_opcode_bytes() : 1; }
// hooks used by the rest of the system
// hooks used by the rest of the system
void start_hook(attotime endtime);
void stop_hook();
void interrupt_hook(int irqline);
@ -163,7 +163,7 @@ public:
void set_instruction_hook(debug_instruction_hook_func hook);
void set_dasm_override(dasm_override_func dasm_override) { m_dasm_override = dasm_override; }
// disassembly
// disassembly
offs_t disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram);
// debugger focus
@ -174,7 +174,7 @@ public:
void single_step(int numsteps = 1);
void single_step_over(int numsteps = 1);
void single_step_out();
// execution
void go(offs_t targetpc = ~0);
void go_vblank();
@ -204,7 +204,7 @@ public:
bool hotspot_tracking_enabled() const { return (m_hotspots != NULL); }
void hotspot_track(int numspots, int threshhold);
// history
// history
offs_t history_pc(int index) const;
// tracing
@ -236,7 +236,7 @@ private:
static void set_logunmap(void *globalref, void *ref, UINT64 value);
static UINT64 get_cpu_reg(void *globalref, void *ref);
static void set_state(void *globalref, void *ref, UINT64 value);
// basic device information
device_t & m_device; // device we are attached to
device_execute_interface *m_exec; // execute interface, if present
@ -278,11 +278,11 @@ private:
public:
tracer(device_debug &debug, FILE &file, bool trace_over, const char *action);
~tracer();
void update(offs_t pc);
void vprintf(const char *format, va_list va);
void flush();
private:
static const int TRACE_LOOPS = 64;
@ -330,7 +330,7 @@ private:
static const UINT32 DEBUG_FLAG_STEPPING_ANY = DEBUG_FLAG_STEPPING | DEBUG_FLAG_STEPPING_OVER | DEBUG_FLAG_STEPPING_OUT;
static const UINT32 DEBUG_FLAG_TRACING_ANY = DEBUG_FLAG_TRACING | DEBUG_FLAG_TRACING_OVER;
static const UINT32 DEBUG_FLAG_TRANSIENT = DEBUG_FLAG_STEPPING_ANY | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_STOP_CONTEXT |
static const UINT32 DEBUG_FLAG_TRANSIENT = DEBUG_FLAG_STEPPING_ANY | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_STOP_CONTEXT |
DEBUG_FLAG_STOP_INTERRUPT | DEBUG_FLAG_STOP_EXCEPTION | DEBUG_FLAG_STOP_VBLANK | DEBUG_FLAG_STOP_TIME;
public: // until comments get folded in

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

@ -150,7 +150,7 @@ void debug_view_source_list::reset()
m_head = source->m_next;
auto_free(&m_machine, source);
}
// reset the tail pointer and index
m_tail = NULL;
m_count = 0;
@ -158,7 +158,7 @@ void debug_view_source_list::reset()
//-------------------------------------------------
// append - add a view_source to the end of the
// append - add a view_source to the end of the
// list
//-------------------------------------------------
@ -237,7 +237,7 @@ debug_view::~debug_view()
//-------------------------------------------------
// end_update - bracket a sequence of changes so
// end_update - bracket a sequence of changes so
// that only one update occurs
//-------------------------------------------------
@ -272,7 +272,7 @@ void debug_view::end_update()
//-------------------------------------------------
// flush_osd_updates - notify the OSD of any
// flush_osd_updates - notify the OSD of any
// pending updates
//-------------------------------------------------
@ -285,7 +285,7 @@ void debug_view::flush_osd_updates()
//-------------------------------------------------
// set_visible_size - set the visible size in
// set_visible_size - set the visible size in
// rows and columns
//-------------------------------------------------*/
@ -303,8 +303,8 @@ void debug_view::set_visible_size(debug_view_xy size)
//-------------------------------------------------
// set_visible_position - set the top left
// position of the visible area in rows and
// set_visible_position - set the top left
// position of the visible area in rows and
// columns
//-------------------------------------------------
@ -322,7 +322,7 @@ void debug_view::set_visible_position(debug_view_xy pos)
//-------------------------------------------------
// set_cursor_position - set the current cursor
// set_cursor_position - set the current cursor
// position as a row and column
//-------------------------------------------------
@ -340,7 +340,7 @@ void debug_view::set_cursor_position(debug_view_xy pos)
//-------------------------------------------------
// set_cursor_visible - set the visible state of
// set_cursor_visible - set the visible state of
// the cursor
//-------------------------------------------------
@ -415,7 +415,7 @@ void debug_view::view_notify(debug_view_notification type)
//-------------------------------------------------
// view_char - handle a character typed within
// view_char - handle a character typed within
// the current view
//-------------------------------------------------
@ -480,11 +480,11 @@ debug_view *debug_view_manager::alloc_view(debug_view_type type, debug_view_osd_
return append(auto_alloc(&m_machine, debug_view_log(m_machine, osdupdate, osdprivate)));
case DVT_TIMERS:
// return append(auto_alloc(&m_machine, debug_view_timers(m_machine, osdupdate, osdprivate)));
// return append(auto_alloc(&m_machine, debug_view_timers(m_machine, osdupdate, osdprivate)));
case DVT_ALLOCS:
// return append(auto_alloc(&m_machine, debug_view_allocs(m_machine, osdupdate, osdprivate)));
// return append(auto_alloc(&m_machine, debug_view_allocs(m_machine, osdupdate, osdprivate)));
default:
fatalerror("Attempt to create invalid debug view type %d\n", type);
}
@ -523,13 +523,13 @@ void debug_view_manager::update_all(debug_view_type type)
//-------------------------------------------------
// flush_osd_updates - flush all pending OSD
// flush_osd_updates - flush all pending OSD
// updates
//-------------------------------------------------
void debug_view_manager::flush_osd_updates()
{
for (debug_view *view = m_viewlist; view != NULL; view = view->m_next)
for (debug_view *view = m_viewlist; view != NULL; view = view->m_next)
view->flush_osd_updates();
}
@ -591,7 +591,7 @@ void debug_view_expression::set_string(const char *string)
//-------------------------------------------------
// set_context - set the context for the
// set_context - set the context for the
// expression
//-------------------------------------------------
@ -603,7 +603,7 @@ void debug_view_expression::set_context(symbol_table *context)
//-------------------------------------------------
// recompute - recompute the value of an
// recompute - recompute the value of an
// expression
//-------------------------------------------------

22
src/emu/debug/debugvw.h
View File

@ -133,19 +133,19 @@ public:
class debug_view_source
{
DISABLE_COPYING(debug_view_source);
friend class debug_view_source_list;
public:
// construction/destruction
debug_view_source(const char *name, device_t *device = NULL);
virtual ~debug_view_source();
// getters
const char *name() const { return m_name; }
debug_view_source *next() const { return m_next; }
device_t *device() const { return m_device; }
private:
// internal state
debug_view_source * m_next; // link to next item
@ -163,19 +163,19 @@ public:
// construction/destruction
debug_view_source_list(running_machine &machine);
~debug_view_source_list();
// getters
const debug_view_source *head() const { return m_head; }
int count() const { return m_count; }
int index(const debug_view_source &source) const;
const debug_view_source *by_index(int index) const;
// operations
void reset();
void append(debug_view_source &view_source);
const debug_view_source *match_device(device_t *device) const;
int match_device_index(device_t *device) const { return index(*match_device(device)); }
private:
// internal state
running_machine & m_machine; // reference to our machine
@ -189,7 +189,7 @@ private:
class debug_view
{
friend class debug_view_manager;
protected:
// construction/destruction
debug_view(running_machine &machine, debug_view_type type, debug_view_osd_update_func osdupdate, void *osdprivate);
@ -242,7 +242,7 @@ protected:
running_machine & m_machine; // machine associated with this view
debug_view_type m_type; // type of view
const debug_view_source *m_source; // currently selected data source
debug_view_source_list m_source_list; // list of available data sources
debug_view_source_list m_source_list; // list of available data sources
// OSD data
debug_view_osd_update_func m_osdupdate; // callback for the update
@ -274,7 +274,7 @@ public:
debug_view_manager(running_machine &machine);
~debug_view_manager();
// view allocation
// view allocation
debug_view *alloc_view(debug_view_type type, debug_view_osd_update_func osdupdate, void *osdprivate);
void free_view(debug_view &view);
@ -299,7 +299,7 @@ public:
// construction/destruction
debug_view_expression(running_machine &machine);
~debug_view_expression();
// getters
bool dirty() const { return m_dirty; }
UINT64 last_value() const { return m_result; }
@ -307,7 +307,7 @@ public:
const char *string() const { return m_string; }
symbol_table *context() const { return m_context; }
// setters
// setters
void mark_dirty() { m_dirty = true; }
void set_string(const char *string);
void set_context(symbol_table *context);

26
src/emu/debug/dvdisasm.c
View File

@ -123,7 +123,7 @@ debug_view_disasm::~debug_view_disasm()
//-------------------------------------------------
// enumerate_sources - enumerate all possible
// enumerate_sources - enumerate all possible
// sources for a disassembly view
//-------------------------------------------------
@ -155,14 +155,14 @@ void debug_view_disasm::view_notify(debug_view_notification type)
{
if (type == VIEW_NOTIFY_CURSOR_CHANGED)
adjust_visible_y_for_cursor();
else if (type == VIEW_NOTIFY_SOURCE_CHANGED)
m_expression.set_context(downcast<const debug_view_disasm_source *>(m_source)->device().debug()->symtable());
}
//-------------------------------------------------
// view_char - handle a character typed within
// view_char - handle a character typed within
// the current view
//-------------------------------------------------
@ -233,7 +233,7 @@ void debug_view_disasm::view_char(int chval)
//-------------------------------------------------
// find_pc_backwards - back up the specified
// find_pc_backwards - back up the specified
// number of instructions from the given PC
//-------------------------------------------------
@ -312,7 +312,7 @@ offs_t debug_view_disasm::find_pc_backwards(offs_t targetpc, int numinstrs)
//-------------------------------------------------
// generate_bytes - generate the opcode byte
// generate_bytes - generate the opcode byte
// values
//-------------------------------------------------
@ -338,7 +338,7 @@ void debug_view_disasm::generate_bytes(offs_t pcbyte, int numbytes, int minbytes
//-------------------------------------------------
// recompute - recompute selected info for the
// recompute - recompute selected info for the
// disassembly view
//-------------------------------------------------
@ -460,7 +460,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
//-------------------------------------------------
// view_update - update the contents of the
// view_update - update the contents of the
// disassembly view
//-------------------------------------------------
@ -620,7 +620,7 @@ recompute:
//-------------------------------------------------
// selected_address - return the PC of the
// selected_address - return the PC of the
// currently selected address in the view
//-------------------------------------------------
@ -632,7 +632,7 @@ offs_t debug_view_disasm::selected_address()
//-------------------------------------------------
// set_sexpression - set the expression string
// set_sexpression - set the expression string
// describing the home address
//-------------------------------------------------
@ -646,7 +646,7 @@ void debug_view_disasm::set_expression(const char *expression)
//-------------------------------------------------
// set_right_column - set the contents of the
// set_right_column - set the contents of the
// right column
//-------------------------------------------------
@ -660,7 +660,7 @@ void debug_view_disasm::set_right_column(disasm_right_column contents)
//-------------------------------------------------
// set_backward_steps - set the number of
// set_backward_steps - set the number of
// instructions displayed before the home address
//-------------------------------------------------
@ -674,7 +674,7 @@ void debug_view_disasm::set_backward_steps(UINT32 steps)
//-------------------------------------------------
// set_disasm_width - set the width in characters
// set_disasm_width - set the width in characters
// of the main disassembly section
//-------------------------------------------------
@ -688,7 +688,7 @@ void debug_view_disasm::set_disasm_width(UINT32 width)
//-------------------------------------------------
// set_selected_address - set the PC of the
// set_selected_address - set the PC of the
// currently selected address in the view
//-------------------------------------------------

8
src/emu/debug/dvdisasm.h
View File

@ -66,7 +66,7 @@ enum disasm_right_column
class debug_view_disasm_source : public debug_view_source
{
friend class debug_view_disasm;
// construction/destruction
debug_view_disasm_source(const char *name, device_t &device);
@ -92,7 +92,7 @@ class debug_view_disasm : public debug_view
// construction/destruction
debug_view_disasm(running_machine &machine, debug_view_osd_update_func osdupdate, void *osdprivate);
virtual ~debug_view_disasm();
public:
// getters
const char *expression() const { return m_expression.string(); }
@ -100,7 +100,7 @@ public:
UINT32 backward_steps() const { return m_backwards_steps; }
UINT32 disasm_width() const { return m_dasm_width; }
offs_t selected_address();
// setters
void set_expression(const char *expression);
void set_right_column(disasm_right_column contents);
@ -135,7 +135,7 @@ private:
debug_view_xy m_allocated; // allocated rows/columns
offs_t * m_byteaddress; // addresses of the instructions
char * m_dasm; // disassembled instructions
// constants
static const int DEFAULT_DASM_LINES = 1000;
static const int DEFAULT_DASM_WIDTH = 50;

28
src/emu/debug/dvmemory.c
View File

@ -141,7 +141,7 @@ debug_view_memory::debug_view_memory(running_machine &machine, debug_view_osd_up
//-------------------------------------------------
// enumerate_sources - enumerate all possible
// enumerate_sources - enumerate all possible
// sources for a memory view
//-------------------------------------------------
@ -195,7 +195,7 @@ void debug_view_memory::enumerate_sources()
//-------------------------------------------------
// view_notify - handle notification of updates
// view_notify - handle notification of updates
// to cursor changes
//-------------------------------------------------
@ -308,7 +308,7 @@ void debug_view_memory::view_update()
//-------------------------------------------------
// view_char - handle a character typed within
// view_char - handle a character typed within
// the current view
//-------------------------------------------------
@ -426,7 +426,7 @@ void debug_view_memory::view_char(int chval)
//-------------------------------------------------
// recompute - recompute the internal data and
// recompute - recompute the internal data and
// structure of the memory view
//-------------------------------------------------
@ -502,7 +502,7 @@ void debug_view_memory::recompute()
//-------------------------------------------------
// needs_recompute - determine if anything has
// needs_recompute - determine if anything has
// changed that requires a recomputation
//-------------------------------------------------
@ -535,7 +535,7 @@ bool debug_view_memory::needs_recompute()
//-------------------------------------------------
// get_cursor_pos - return the cursor position as
// get_cursor_pos - return the cursor position as
// an address and a shift value
//-------------------------------------------------
@ -569,7 +569,7 @@ debug_view_memory::cursor_pos debug_view_memory::get_cursor_pos()
//-------------------------------------------------
// set_cursor_pos - set the cursor position as a
// set_cursor_pos - set the cursor position as a
// function of an address and a shift value
//-------------------------------------------------
@ -717,7 +717,7 @@ void debug_view_memory::write(UINT8 size, offs_t offs, UINT64 data)
//-------------------------------------------------
// set_expression - set the expression string
// set_expression - set the expression string
// describing the home address
//-------------------------------------------------
@ -731,7 +731,7 @@ void debug_view_memory::set_expression(const char *expression)
//-------------------------------------------------
// set_bytes_per_chunk - specify the number of
// set_bytes_per_chunk - specify the number of
// bytes displayed per chunk
//-------------------------------------------------
@ -756,7 +756,7 @@ void debug_view_memory::set_bytes_per_chunk(UINT8 chunkbytes)
//-------------------------------------------------
// set_chunks_per_row - specify the number of
// set_chunks_per_row - specify the number of
// chunks displayed across a row
//-------------------------------------------------
@ -773,7 +773,7 @@ void debug_view_memory::set_chunks_per_row(UINT32 rowchunks)
//-------------------------------------------------
// set_reverse - specify true if the memory view
// set_reverse - specify true if the memory view
// is displayed reverse
//-------------------------------------------------
@ -787,7 +787,7 @@ void debug_view_memory::set_reverse(bool reverse)
//-------------------------------------------------
// set_ascii - specify TRUE if the memory view
// set_ascii - specify TRUE if the memory view
// should display an ASCII representation
//-------------------------------------------------
@ -801,8 +801,8 @@ void debug_view_memory::set_ascii(bool ascii)
//-------------------------------------------------
// set_physical - specify true if the memory view
// should display physical addresses versus
// set_physical - specify true if the memory view
// should display physical addresses versus
// logical addresses
//-------------------------------------------------

2
src/emu/debug/dvmemory.h
View File

@ -51,7 +51,7 @@
class debug_view_memory_source : public debug_view_source
{
friend class debug_view_memory;
debug_view_memory_source(const char *name, const address_space &space);
debug_view_memory_source(const char *name, const region_info &region);
debug_view_memory_source(const char *name, void *base, int element_size, int num_elements);

12
src/emu/debug/dvstate.c
View File

@ -93,7 +93,7 @@ debug_view_state::~debug_view_state()
//-------------------------------------------------
// enumerate_sources - enumerate all possible
// enumerate_sources - enumerate all possible
// sources for a registers view
//-------------------------------------------------
@ -133,7 +133,7 @@ void debug_view_state::reset()
//-------------------------------------------------
// recompute - recompute all info for the
// recompute - recompute all info for the
// registers view
//-------------------------------------------------
@ -187,7 +187,7 @@ void debug_view_state::recompute()
maxtaglen = MAX(maxtaglen, item->m_symbol.len());
maxvallen = MAX(maxvallen, item->m_vallen);
}
// set the current divider and total cols
m_divider = 1 + maxtaglen + 1;
m_total.x = 1 + maxtaglen + 2 + maxvallen + 1;
@ -213,7 +213,7 @@ void debug_view_state::view_notify(debug_view_notification type)
//-------------------------------------------------
// view_update - update the contents of the
// view_update - update the contents of the
// register view
//-------------------------------------------------
@ -228,7 +228,7 @@ void debug_view_state::view_update()
UINT64 total_cycles = 0;
if (source.m_execintf != NULL)
total_cycles = source.m_execintf->total_cycles();
// find the first entry
state_item *curitem = m_state_list;
for (int index = 0; curitem != NULL && index < m_topleft.y; index++)
@ -335,7 +335,7 @@ void debug_view_state::view_update()
dest++;
col++;
}
// advance to the next item
curitem = curitem->m_next;
}

8
src/emu/debug/dvstate.h
View File

@ -51,7 +51,7 @@
class debug_view_state_source : public debug_view_source
{
friend class debug_view_state;
// construction/destruction
debug_view_state_source(const char *name, device_t &device);
@ -76,7 +76,7 @@ class debug_view_state : public debug_view
// construction/destruction
debug_view_state(running_machine &machine, debug_view_osd_update_func osdupdate, void *osdprivate);
virtual ~debug_view_state();
protected:
// view overrides
virtual void view_update();
@ -86,7 +86,7 @@ private:
struct state_item
{
state_item(int index, const char *name, UINT8 valuechars);
state_item * m_next; // next item
UINT64 m_lastval; // last value
UINT64 m_currval; // current value
@ -104,7 +104,7 @@ private:
int m_divider; // dividing column
UINT64 m_last_update; // execution counter at last update
state_item * m_state_list; // state data
// constants
static const int REG_DIVIDER = -10;
static const int REG_CYCLES = -11;

2
src/emu/devcpu.c
View File

@ -82,7 +82,7 @@ legacy_cpu_device_config::legacy_cpu_device_config(const machine_config &mconfig
m_space_config[spacenum].m_internal_map = reinterpret_cast<const addrmap_token *>(get_legacy_config_ptr(DEVINFO_PTR_INTERNAL_MEMORY_MAP + spacenum));
m_space_config[spacenum].m_default_map = reinterpret_cast<const addrmap_token *>(get_legacy_config_ptr(DEVINFO_PTR_DEFAULT_MEMORY_MAP + spacenum));
}
// set the real name
m_name = get_legacy_config_string(DEVINFO_STR_NAME);
}

2
src/emu/devcpu.h
View File

@ -209,7 +209,7 @@ device_config *basename##_device_config::static_alloc_device_config(const machin
return global_alloc(basename##_device_config(mconfig, static_alloc_device_config, tag, owner, clock)); \
} \
\
device_t *basename##_device_config::alloc_device(running_machine &machine) const \
device_t *basename##_device_config::alloc_device(running_machine &machine) const \
{ \
return pool_alloc(machine_get_pool(machine), basename##_device(machine, *this)); \
} \

22
src/emu/devimage.c
View File

@ -183,7 +183,7 @@ legacy_image_device_config_base::~legacy_image_device_config_base()
device_image_partialhash_func legacy_image_device_config_base::get_partial_hash() const
{
return reinterpret_cast<device_image_partialhash_func>(get_legacy_config_fct(DEVINFO_FCT_IMAGE_PARTIAL_HASH));
return reinterpret_cast<device_image_partialhash_func>(get_legacy_config_fct(DEVINFO_FCT_IMAGE_PARTIAL_HASH));
}
@ -225,7 +225,7 @@ bool legacy_image_device_base::is_loaded()
image_error_t legacy_image_device_base::load_image_by_path(UINT32 open_flags, const char *path)
{
file_error filerr = FILERR_NOT_FOUND;
image_error_t err = IMAGE_ERROR_FILENOTFOUND;
image_error_t err = IMAGE_ERROR_FILENOTFOUND;
astring revised_path;
/* attempt to read the file */
@ -272,7 +272,7 @@ image_error_t legacy_image_device_base::load_image_by_path(UINT32 open_flags, co
return err;
}
/*-------------------------------------------------
determine_open_plan - determines which open
flags to use, and in what order
@ -312,7 +312,7 @@ bool legacy_image_device_base::load_internal(const char *path, bool is_create, i
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
err = set_image_filename(path);
if (err)
@ -342,14 +342,14 @@ bool legacy_image_device_base::load_internal(const char *path, bool is_create, i
m_year = m_software_info_ptr->year;
//m_playable = m_software_info_ptr->supported;
}
/* did we fail to find the file? */
if (!is_loaded())
{
err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
@ -462,14 +462,14 @@ void legacy_image_device_base::clear()
{
if (m_file)
{
core_fclose(m_file);
core_fclose(m_file);
m_file = NULL;
}
m_name.reset();
m_writeable = FALSE;
m_created = FALSE;
m_longname.reset();
m_manufacturer.reset();
m_year.reset();
@ -480,7 +480,7 @@ void legacy_image_device_base::clear()
m_full_software_name = NULL;
m_software_info_ptr = NULL;
m_software_part_ptr = NULL;
m_software_part_ptr = NULL;
}
/*-------------------------------------------------
@ -526,7 +526,7 @@ void legacy_image_device_base::call_display()
device_image_partialhash_func legacy_image_device_base::get_partial_hash()
{
return reinterpret_cast<device_image_partialhash_func>(m_config.get_legacy_config_fct(DEVINFO_FCT_IMAGE_PARTIAL_HASH));
return reinterpret_cast<device_image_partialhash_func>(m_config.get_legacy_config_fct(DEVINFO_FCT_IMAGE_PARTIAL_HASH));
}
void legacy_image_device_base::call_get_devices()
@ -534,7 +534,7 @@ void legacy_image_device_base::call_get_devices()
device_image_get_devices_func func = reinterpret_cast<device_image_get_devices_func>(m_config.get_legacy_config_fct(DEVINFO_FCT_IMAGE_GET_DEVICES));
if (func) (*func)(*this);
}
void *legacy_image_device_base::get_device_specific_call()
{
return (void*) m_config.get_legacy_config_fct(DEVINFO_FCT_DEVICE_SPECIFIC);

6
src/emu/devintrf.h
View File

@ -376,7 +376,7 @@ public:
return true;
return false;
}
// specialized helpers
bool interface(device_execute_interface *&intf) { intf = m_execute; return (intf != NULL); }
bool interface(device_memory_interface *&intf) { intf = m_memory; return (intf != NULL); }
@ -405,7 +405,7 @@ public:
void set_clock_scale(double clockscale);
attotime clocks_to_attotime(UINT64 clocks) const;
UINT64 attotime_to_clocks(attotime duration) const;
// debugging
device_debug *debug() const { return m_debug; }
void set_debug(device_debug &debug) { m_debug = &debug; }
@ -445,7 +445,7 @@ protected:
running_machine & m_machine;
device_debug * m_debug;
// for speed
device_execute_interface *m_execute;
device_memory_interface *m_memory;

4
src/emu/devlegcy.c
View File

@ -58,7 +58,7 @@ legacy_device_config_base::legacy_device_config_base(const machine_config &mconf
UINT32 configlen = (UINT32)get_legacy_config_int(DEVINFO_INT_INLINE_CONFIG_BYTES);
if (configlen != 0)
m_inline_config = global_alloc_array_clear(UINT8, configlen);
// set the proper name
m_name = get_legacy_config_string(DEVINFO_STR_NAME);
}
@ -346,4 +346,4 @@ void legacy_nvram_device_base::nvram_write(mame_file &file)
{
device_nvram_func nvram_func = reinterpret_cast<device_nvram_func>(m_config.get_legacy_config_fct(DEVINFO_FCT_NVRAM));
(*nvram_func)(this, &file, TRUE);
}
}

10
src/emu/devlegcy.h
View File

@ -613,7 +613,7 @@ protected:
astring m_instance_name;
astring m_brief_instance_name;
astring m_interface_name;
/* creation info */
const option_guide *m_create_option_guide;
image_device_format *m_formatlist;
@ -630,8 +630,8 @@ public:
virtual bool load(const char *path);
virtual bool finish_load();
virtual void unload();
virtual bool create(const char *path, const image_device_format *create_format, option_resolution *create_args);
virtual bool create(const char *path, const image_device_format *create_format, option_resolution *create_args);
virtual int call_load();
virtual int call_create(int format_type, option_resolution *format_options);
virtual void call_unload();
@ -646,9 +646,9 @@ protected:
bool load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args);
void determine_open_plan(int is_create, UINT32 *open_plan);
image_error_t load_image_by_path(UINT32 open_flags, const char *path);
void clear();
void clear();
bool is_loaded();
bool m_is_loading;
};

20
src/emu/diimage.c
View File

@ -175,7 +175,7 @@ static void memory_error(const char *message)
device_image_interface::device_image_interface(running_machine &machine, const device_config &config, device_t &device)
: device_interface(machine, config, device),
m_image_config(dynamic_cast<const device_config_image_interface &>(config)),
m_image_config(dynamic_cast<const device_config_image_interface &>(config)),
m_file(NULL),
m_full_software_name(NULL),
m_software_info_ptr(NULL),
@ -192,7 +192,7 @@ device_image_interface::device_image_interface(running_machine &machine, const d
device_image_interface::~device_image_interface()
{
pool_free_lib(m_mempool);
pool_free_lib(m_mempool);
}
/*-------------------------------------------------
@ -205,7 +205,7 @@ image_error_t device_image_interface::set_image_filename(const char *filename)
m_name = filename;
zippath_parent(&m_working_directory, filename);
m_basename = m_name.cpy(m_name);
int loc1 = m_name.rchr(0,'\\');
int loc2 = m_name.rchr(0,'/');
int loc3 = m_name.rchr(0,':');
@ -328,7 +328,7 @@ void device_image_interface::seterror(image_error_t err, const char *message)
void device_image_interface::message(const char *format, ...)
{
va_list args;
char buffer[256];
char buffer[256];
/* format the message */
va_start(args, format);
@ -412,7 +412,7 @@ void device_image_interface::setup_working_directory()
// valid even if not mounted
//-------------------------------------------------
const char * device_image_interface::working_directory()
const char * device_image_interface::working_directory()
{
/* check to see if we've never initialized the working directory */
if (m_working_directory.len() == 0)
@ -544,7 +544,7 @@ int device_image_interface::read_hash_config(const char *sysname)
goto done;
/* copy the relevant entries */
m_longname = info->longname ? astring(info->longname) : "";
m_longname = info->longname ? astring(info->longname) : "";
m_manufacturer = info->manufacturer ? astring(info->manufacturer) : "";
m_year = info->year ? astring(info->year) : "";
m_playable = info->playable ? astring(info->playable) : "";
@ -625,11 +625,11 @@ void device_image_interface::image_checkhash()
return;
}
UINT32 device_image_interface::crc()
{
UINT32 device_image_interface::crc()
{
UINT32 crc = 0;
image_checkhash();
image_checkhash();
if (m_hash != NULL)
crc = hash_data_extract_crc32(m_hash);
@ -671,4 +671,4 @@ void device_image_interface::battery_save(const void *buffer, int length)
image_battery_save_by_name(astring_c(fname), buffer, length);
astring_free(fname);
}

58
src/emu/diimage.h
View File

@ -170,13 +170,13 @@ public:
virtual bool uses_file_extension(const char *file_extension) const = 0;
virtual const option_guide *create_option_guide() const = 0;
virtual image_device_format *formatlist() const = 0;
static const char *device_typename(iodevice_t type);
static const char *device_brieftypename(iodevice_t type);
static const char *device_brieftypename(iodevice_t type);
static iodevice_t device_typeid(const char *name);
virtual device_image_partialhash_func get_partial_hash() const = 0;
virtual void device_compute_hash(char *dest, const void *data, size_t length, unsigned int functions) const;
virtual void device_compute_hash(char *dest, const void *data, size_t length, unsigned int functions) const;
protected:
static const image_device_type_info *find_device_type(iodevice_t type);
static const image_device_type_info m_device_info_array[];
@ -198,7 +198,7 @@ public:
virtual bool load(const char *path) = 0;
virtual bool finish_load() = 0;
virtual void unload() = 0;
virtual int call_load() = 0;
virtual int call_create(int format_type, option_resolution *format_options) = 0;
virtual void call_unload() = 0;
@ -206,14 +206,14 @@ public:
virtual device_image_partialhash_func get_partial_hash() = 0;
virtual void call_get_devices() = 0;
virtual void *get_device_specific_call() = 0;
virtual const image_device_format *device_get_indexed_creatable_format(int index);
virtual const image_device_format *device_get_named_creatable_format(const char *format_name);
const option_guide *device_get_creation_option_guide() { return m_image_config.create_option_guide(); }
const image_device_format *device_get_creatable_formats() { return m_image_config.formatlist(); }
const image_device_format *device_get_creatable_formats() { return m_image_config.formatlist(); }
virtual bool create(const char *path, const image_device_format *create_format, option_resolution *create_args) = 0;
const char *error();
void seterror(image_error_t err, const char *message);
void message(const char *format, ...);
@ -234,34 +234,34 @@ public:
UINT64 ftell() { check_for_file(); return core_ftell(m_file); }
int fgetc() { char ch; if (fread(&ch, 1) != 1) ch = '\0'; return ch; }
char *fgets(char *buffer, UINT32 length) { check_for_file(); return core_fgets(buffer, length, m_file); }
int feof() { check_for_file(); return core_feof(m_file); }
void *ptr() {check_for_file(); return (void *) core_fbuffer(m_file); }
int feof() { check_for_file(); return core_feof(m_file); }
void *ptr() {check_for_file(); return (void *) core_fbuffer(m_file); }
// configuration access
const device_config_image_interface &image_config() const { return m_image_config; }
void set_init_phase() { m_init_phase = TRUE; }
const char* longname() { return m_longname; }
const char* manufacturer() { return m_manufacturer; }
const char* year() { return m_year; }
const char* playable() { return m_playable; }
const char* pcb() { return m_pcb; }
const char* extrainfo() { return m_extrainfo; }
const software_info *software_entry() { return m_software_info_ptr; }
virtual void set_working_directory(const char *working_directory) { m_working_directory = working_directory; }
virtual const char * working_directory();
virtual const char * working_directory();
UINT8 *get_software_region(const char *tag);
UINT32 get_software_region_length(const char *tag);
const char *get_feature(const char *feature_name);
void *image_malloc(size_t size);
char *image_strdup(const char *src);
void *image_realloc(void *ptr, size_t size);
void image_freeptr(void *ptr);
UINT32 crc();
void battery_load(void *buffer, int length, int fill);
@ -270,9 +270,9 @@ protected:
image_error_t set_image_filename(const char *filename);
void clear_error();
void check_for_file() { assert_always(m_file != NULL, "Illegal operation on unmounted image"); }
void setup_working_directory();
bool try_change_working_directory(const char *subdir);
@ -282,22 +282,22 @@ protected:
// derived class overrides
// configuration
const device_config_image_interface &m_image_config; // reference to our device_config_execute_interface
const device_config_image_interface &m_image_config; // reference to our device_config_execute_interface
/* error related info */
image_error_t m_err;
astring m_err_message;
astring m_err_message;
/* variables that are only non-zero when an image is mounted */
core_file *m_file;
astring m_name;
core_file *m_file;
astring m_name;
astring m_basename;
astring m_basename_noext;
astring m_filetype;
/* working directory; persists across mounts */
astring m_working_directory;
/* Software information */
char *m_full_software_name;
software_info *m_software_info_ptr;
@ -313,15 +313,15 @@ protected:
/* flags */
bool m_writeable;
bool m_created;
bool m_created;
bool m_init_phase;
/* special - used when creating */
int m_create_format;
option_resolution *m_create_args;
object_pool *m_mempool;
char *m_hash;
};

38
src/emu/image.c
View File

@ -68,7 +68,7 @@ static void image_dirs_load(running_machine *machine, int config_type, xml_data_
const char *dev_instance;
const char *working_directory;
device_image_interface *image = NULL;
if ((config_type == CONFIG_TYPE_GAME) && (parentnode != NULL))
{
for (node = xml_get_sibling(parentnode->child, "device"); node; node = xml_get_sibling(node->next, "device"))
@ -83,7 +83,7 @@ static void image_dirs_load(running_machine *machine, int config_type, xml_data_
working_directory = xml_get_attribute_string(node, "directory", NULL);
if (working_directory != NULL)
image->set_working_directory(working_directory);
}
}
}
}
}
@ -115,7 +115,7 @@ static void image_dirs_save(running_machine *machine, int config_type, xml_data_
{
xml_set_attribute(node, "instance", dev_instance);
xml_set_attribute(node, "directory", image->working_directory());
}
}
}
}
}
@ -160,16 +160,16 @@ static void image_options_extract(running_machine *machine)
{
/* only extract the device options if we've added them */
if (options_get_bool(machine->options(), OPTION_ADDED_DEVICE_OPTIONS)) {
int index = 0;
int index = 0;
device_image_interface *image = NULL;
for (bool gotone = machine->m_devicelist.first(image); gotone; gotone = image->next(image))
{
{
const char *filename = image->filename();
/* and set the option */
options_set_string(machine->options(), image->image_config().instance_name() , filename ? filename : "", OPTION_PRIORITY_CMDLINE);
options_set_string(machine->options(), image->image_config().instance_name() , filename ? filename : "", OPTION_PRIORITY_CMDLINE);
index++;
}
}
@ -188,7 +188,7 @@ void image_unload_all(running_machine &machine)
{
device_image_interface *image = NULL;
// extract the options
// extract the options
image_options_extract(&machine);
for (bool gotone = machine.m_devicelist.first(image); gotone; gotone = image->next(image))
@ -217,7 +217,7 @@ void image_device_init(running_machine *machine)
{
/* mark init state */
image->set_init_phase();
/* try to load this image */
bool result = image->load(image_name);
@ -245,7 +245,7 @@ void image_device_init(running_machine *machine)
fatalerror_exitcode(machine, MAMERR_DEVICE, "Driver requires that device \"%s\" must have an image to load", image->image_config().instance_name());
}
}
image->call_get_devices();
}
}
@ -434,7 +434,7 @@ astring *image_info_astring(running_machine *machine, astring *string)
else
{
astring_catprintf(string, "%s: ---\n", image->image_config().devconfig().name());
}
}
}
return string;
}
@ -489,7 +489,7 @@ void image_battery_save_by_name(const char *filename, const void *buffer, int le
/*-------------------------------------------------
image_from_absolute_index - retreives index number
of image in device list
of image in device list
-------------------------------------------------*/
device_image_interface *image_from_absolute_index(running_machine *machine, int absolute_index)
{
@ -506,21 +506,21 @@ device_image_interface *image_from_absolute_index(running_machine *machine, int
/*-------------------------------------------------
image_add_device_with_subdevices - adds
device with parameters sent, and all subdevices
from it's machine config devices list
device with parameters sent, and all subdevices
from it's machine config devices list
-------------------------------------------------*/
void image_add_device_with_subdevices(device_t *owner, device_type type, const char *tag, UINT32 clock)
{
astring tempstring;
device_list *device_list = &owner->machine->m_devicelist;
device_list *device_list = &owner->machine->m_devicelist;
machine_config *config = (machine_config *)owner->machine->config;
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)
{
if (tokens != NULL)
{
config->detokenize(tokens,devconfig);
for (const device_config *config_dev = config->m_devicelist.first(); config_dev != NULL; config_dev = config_dev->next())
{

30
src/emu/machine.c
View File

@ -79,7 +79,7 @@
- calls debugger_init() [debugger.c] to set up the debugger
- calls the driver's MACHINE_START, SOUND_START, and VIDEO_START callbacks
- calls cheat_init() [cheat.c] to initialize the cheat system
- calls image_init() [image.c] to initialize the image system
- calls image_init() [image.c] to initialize the image system
- calls config_load_settings() [config.c] to load the configuration file
- calls nvram_load [machine/generic.c] to load NVRAM
@ -313,7 +313,7 @@ void running_machine::start()
// start up the devices
m_devicelist.start_all();
// call the game driver's init function
// this is where decryption is done and memory maps are altered
// so this location in the init order is important
@ -481,7 +481,7 @@ void running_machine::schedule_exit()
//-------------------------------------------------
// schedule_hard_reset - schedule a hard-reset of
// schedule_hard_reset - schedule a hard-reset of
// the machine
//-------------------------------------------------
@ -495,7 +495,7 @@ void running_machine::schedule_hard_reset()
//-------------------------------------------------
// schedule_soft_reset - schedule a soft-reset of
// schedule_soft_reset - schedule a soft-reset of
// the system
//-------------------------------------------------
@ -512,7 +512,7 @@ void running_machine::schedule_soft_reset()
//-------------------------------------------------
// schedule_new_driver - schedule a new game to
// schedule_new_driver - schedule a new game to
// be loaded
//-------------------------------------------------
@ -548,7 +548,7 @@ void running_machine::set_saveload_filename(const char *filename)
//-------------------------------------------------
// schedule_save - schedule a save to occur as
// schedule_save - schedule a save to occur as
// soon as possible
//-------------------------------------------------
@ -567,7 +567,7 @@ void running_machine::schedule_save(const char *filename)
//-------------------------------------------------
// schedule_load - schedule a load to occur as
// schedule_load - schedule a load to occur as
// soon as possible
//-------------------------------------------------
@ -595,7 +595,7 @@ void running_machine::pause()
if (m_paused)
return;
m_paused = true;
// call the callbacks
call_notifiers(MACHINE_NOTIFY_PAUSE);
}
@ -611,7 +611,7 @@ void running_machine::resume()
if (!m_paused)
return;
m_paused = false;
// call the callbacks
call_notifiers(MACHINE_NOTIFY_RESUME);
}
@ -651,7 +651,7 @@ void running_machine::region_free(const char *name)
void running_machine::add_notifier(machine_notification event, notify_callback callback)
{
assert_always(m_current_phase == MACHINE_PHASE_INIT, "Can only call add_notifier at init time!");
// exit notifiers are added to the head, and executed in reverse order
if (event == MACHINE_NOTIFY_EXIT)
{
@ -726,7 +726,7 @@ void CLIB_DECL running_machine::vlogerror(const char *format, va_list args)
//-------------------------------------------------
// base_datetime - retrieve the time of the host
// base_datetime - retrieve the time of the host
// system; useful for RTC implementations
//-------------------------------------------------
@ -737,8 +737,8 @@ void running_machine::base_datetime(system_time &systime)
//-------------------------------------------------
// current_datetime - retrieve the current time
// (offset by the base); useful for RTC
// current_datetime - retrieve the current time
// (offset by the base); useful for RTC
// implementations
//-------------------------------------------------
@ -790,7 +790,7 @@ void running_machine::handle_saveload()
if (m_saveload_pending_file.len() == 0)
goto cancel;
// if there are anonymous timers, we can't save just yet, and we can't load yet either
// if there are anonymous timers, we can't save just yet, and we can't load yet either
// because the timers might overwrite data we have loaded
if (timer_count_anonymous(this) > 0)
{
@ -990,7 +990,7 @@ void system_time::set(time_t t)
//-------------------------------------------------
// get_tm_time - converts a tm struction to a
// get_tm_time - converts a tm struction to a
// MAME mame_system_tm structure
//-------------------------------------------------

42
src/emu/machine.h
View File

@ -183,7 +183,7 @@ public:
endianness_t endianness() const { return ((m_flags & ROMREGION_ENDIANMASK) == ROMREGION_LE) ? ENDIANNESS_LITTLE : ENDIANNESS_BIG; }
UINT8 width() const { return 1 << ((m_flags & ROMREGION_WIDTHMASK) >> 8); }
bool invert() const { return ((m_flags & ROMREGION_INVERTMASK) != 0); }
// data access
UINT8 &u8(offs_t offset = 0) const { return m_base.u8[offset]; }
UINT16 &u16(offs_t offset = 0) const { return m_base.u16[offset]; }
@ -241,20 +241,20 @@ public:
{
void set(struct tm &t);
UINT8 second; // seconds (0-59)
UINT8 minute; // minutes (0-59)
UINT8 hour; // hours (0-23)
UINT8 mday; // day of month (1-31)
UINT8 month; // month (0-11)
INT32 year; // year (1=1 AD)
UINT8 weekday; // day of week (0-6)
UINT16 day; // day of year (0-365)
UINT8 is_dst; // is this daylight savings?
UINT8 second; // seconds (0-59)
UINT8 minute; // minutes (0-59)
UINT8 hour; // hours (0-23)
UINT8 mday; // day of month (1-31)
UINT8 month; // month (0-11)
INT32 year; // year (1=1 AD)
UINT8 weekday; // day of week (0-6)
UINT16 day; // day of year (0-365)
UINT8 is_dst; // is this daylight savings?
};
INT64 time; // number of seconds elapsed since midnight, January 1 1970 UTC
full_time local_time; // local time
full_time utc_time; // UTC coordinated time
INT64 time; // number of seconds elapsed since midnight, January 1 1970 UTC
full_time local_time; // local time
full_time utc_time; // UTC coordinated time
};
@ -270,16 +270,16 @@ public:
// construction/destruction
running_machine(const game_driver &driver, const machine_config &config, core_options &options, bool exit_to_game_select = false);
~running_machine();
// fetch items by name
inline device_t *device(const char *tag);
template<class T> inline T *device(const char *tag) { return downcast<T *>(device(tag)); }
inline const input_port_config *port(const char *tag);
inline const region_info *region(const char *tag);
// configuration helpers
UINT32 total_colors() const { return m_config.m_total_colors; }
// getters
const char *basename() const { return m_basename; }
core_options *options() const { return &m_options; }
@ -299,7 +299,7 @@ public:
void add_notifier(machine_notification event, notify_callback callback);
void call_notifiers(machine_notification which);
void add_logerror_callback(logerror_callback callback);
// scheduled operations
void schedule_exit();
void schedule_hard_reset();
@ -311,7 +311,7 @@ public:
// time
void base_datetime(system_time &systime);
void current_datetime(system_time &systime);
// regions
region_info *region_alloc(const char *name, UINT32 length, UINT32 flags);
void region_free(const char *name);
@ -392,7 +392,7 @@ private:
void set_saveload_filename(const char *filename);
void fill_systime(system_time &systime, time_t t);
void handle_saveload();
static TIMER_CALLBACK( static_soft_reset );
void soft_reset();
@ -406,7 +406,7 @@ private:
notify_callback m_func;
};
notifier_callback_item *m_notifier_list[MACHINE_NOTIFY_COUNT];
// logerror callbacks
struct logerror_callback_item
{
@ -437,7 +437,7 @@ private:
SLS_NONE,
SLS_SAVE,
SLS_LOAD
};
};
saveload_schedule m_saveload_schedule;
attotime m_saveload_schedule_time;
astring m_saveload_pending_file;

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

@ -92,7 +92,7 @@ void generic_machine_init(running_machine *machine)
state->coinlockedout[counternum] = 0;
}
// map devices to the interrupt state
// map devices to the interrupt state
memset(state->interrupt_device, 0, sizeof(state->interrupt_device));
device_execute_interface *exec;
int index = 0;

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

@ -458,7 +458,7 @@ void z80dart_device::dart_channel::start(z80dart_device *device, int index, cons
{
m_index = index;
m_device = device;
devcb_resolve_read_line(&m_in_rxd_func, &in_rxd, m_device);
devcb_resolve_write_line(&m_out_txd_func, &out_txd, m_device);
devcb_resolve_write_line(&m_out_dtr_func, &out_dtr, m_device);

8
src/emu/mame.c
View File

@ -51,7 +51,7 @@
- calls debugger_init() [debugger.c] to set up the debugger
- calls the driver's MACHINE_START, SOUND_START, and VIDEO_START callbacks
- calls cheat_init() [cheat.c] to initialize the cheat system
- calls image_init() [image.c] to initialize the image system
- calls image_init() [image.c] to initialize the image system
- calls config_load_settings() [config.c] to load the configuration file
- calls nvram_load [machine/generic.c] to load NVRAM
@ -187,7 +187,7 @@ int mame_execute(core_options *options)
options_revert(options, OPTION_PRIORITY_INI);
mame_parse_ini_files(options, driver);
}
// create the machine configuration
const machine_config *config = global_alloc(machine_config(driver->machine_config));
@ -196,11 +196,11 @@ int mame_execute(core_options *options)
// looooong term: remove this
global_machine = machine;
// run the machine
error = machine->run(firstrun);
firstrun = false;
// check the state of the machine
if (machine->new_driver_pending())
{

6
src/emu/mconfig.c
View File

@ -94,7 +94,7 @@ void machine_config::detokenize(const machine_config_token *tokens, const device
{
device_config *device = NULL;
astring tempstring;
// increase the parse level
m_parse_level++;
@ -278,7 +278,7 @@ void machine_config::detokenize(const machine_config_token *tokens, const device
break;
}
}
// if we started at parse level 0 (and are thus at level 1), do post-processing
if (m_parse_level == 1)
{
@ -299,7 +299,7 @@ void machine_config::detokenize(const machine_config_token *tokens, const device
devconfig->m_config_complete = true;
}
}
// bump down the parse level
m_parse_level--;
}

10
src/emu/mconfig.h
View File

@ -243,11 +243,11 @@ class machine_config
DISABLE_COPYING(machine_config);
friend class running_machine;
public:
machine_config(const machine_config_token *tokens);
~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
@ -260,15 +260,15 @@ public:
machine_start_func m_machine_start; // one-time machine start callback
machine_reset_func m_machine_reset; // machine reset callback
nvram_handler_func m_nvram_handler; // NVRAM save/load callback
memcard_handler_func m_memcard_handler; // memory card save/load callback
nvram_handler_func m_nvram_handler; // NVRAM save/load callback
memcard_handler_func m_memcard_handler; // memory card save/load callback
UINT32 m_video_attributes; // flags describing the video system
const gfx_decode_entry *m_gfxdecodeinfo; // pointer to array of graphics decoding information
UINT32 m_total_colors; // total number of colors in the palette
const char * m_default_layout; // default layout for this machine
palette_init_func m_init_palette; // one-time palette init callback
palette_init_func m_init_palette; // one-time palette init callback
video_start_func m_video_start; // one-time video start callback
video_reset_func m_video_reset; // video reset callback
video_eof_func m_video_eof; // end-of-frame video callback

2
src/emu/memory.c
View File

@ -1848,7 +1848,7 @@ static void memory_init_preflight(running_machine *machine)
const region_info *region = machine->region(entry->region);
if (region == NULL)
fatalerror("Error: device '%s' %s space memory map entry %X-%X references non-existant region \"%s\"", space->cpu->tag(), space->name, entry->addrstart, entry->addrend, entry->region);
/* validate the region */
if (entry->rgnoffs + (entry->byteend - entry->bytestart + 1) > region->bytes())
fatalerror("Error: device '%s' %s space memory map entry %X-%X extends beyond region \"%s\" size (%X)", space->cpu->tag(), space->name, entry->addrstart, entry->addrend, entry->region, region->bytes());

12
src/emu/softlist.c
View File

@ -995,7 +995,7 @@ bool load_software_part(device_image_interface *image, const char *path, softwar
{
if ( swlists )
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(&swlists->baseconfig())->inline_config();
UINT32 i = DEVINFO_STR_SWLIST_0;
@ -1378,7 +1378,7 @@ static void ui_mess_menu_populate_software_list(running_machine *machine, ui_men
{
bool haveCompatible = FALSE;
const char *interface = image->image_config().image_interface();
for (const device_config *dev = machine->config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();
@ -1398,7 +1398,7 @@ static void ui_mess_menu_populate_software_list(running_machine *machine, ui_men
if (strcmp(interface,part->interface_)==0) {
found = TRUE;
}
}
}
if (found) {
ui_menu_item_append(menu, list->description, NULL, 0, swlist->list_name[i]);
}
@ -1408,7 +1408,7 @@ static void ui_mess_menu_populate_software_list(running_machine *machine, ui_men
}
}
}
for (const device_config *dev = machine->config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();
@ -1428,7 +1428,7 @@ static void ui_mess_menu_populate_software_list(running_machine *machine, ui_men
if (strcmp(interface,part->interface_)==0) {
found = TRUE;
}
}
}
if (found) {
if (!haveCompatible) {
ui_menu_item_append(menu, "[compatible lists]", NULL, 0, NULL);
@ -1442,7 +1442,7 @@ static void ui_mess_menu_populate_software_list(running_machine *machine, ui_men
}
}
}
}
void ui_image_menu_software(running_machine *machine, ui_menu *menu, void *parameter, void *state)

4
src/emu/sound/tms5220.c
View File

@ -142,7 +142,7 @@ OLDE is a status flag which is only used for determining whether
frame being parsed (which will become the new target frame) is zero.
It is used for determining whether interpolation of the next frame is
inhibited or not. It is updated at IP=0 PC=0 T=16. See next section.
Interpolation is inhibited (i.e. interpolation at IP frames will not happen
except for IP=0) under the following circumstances:
"P=0" != "OLDP" ("P=0" = 1, and OLDP = 0; OR "P=0" = 0, and OLDP = 1)
@ -150,7 +150,7 @@ Interpolation is inhibited (i.e. interpolation at IP frames will not happen
versa.
"OLDE" = 1 and "E=0" = 0
This means the new frame is not silent, and the old frame was silent.
****Documentation of chip commands:***

4
src/emu/ui.c
View File

@ -1261,8 +1261,8 @@ void ui_paste(running_machine *machine)
}
/*-------------------------------------------------
ui_image_handler_ingame - execute display
callback function for each image device
ui_image_handler_ingame - execute display
callback function for each image device
-------------------------------------------------*/
void ui_image_handler_ingame(running_machine *machine)

2
src/emu/uimenu.c
View File

@ -1537,7 +1537,7 @@ static void menu_main_populate(running_machine *machine, ui_menu *menu, void *st
ui_menu_item_append(menu, CAPSTARTGAMENOUN " Information", NULL, 0, (void *)menu_game_info);
device_image_interface *image = NULL;
if (machine->m_devicelist.first(image))
if (machine->m_devicelist.first(image))
{
/* add image info menu */
ui_menu_item_append(menu, "Image Information", NULL, 0, (void*)ui_image_menu_image_info);

16
src/lib/expat/expat.h
View File

@ -765,20 +765,20 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
(resumable = 0) an already suspended parser. Some call-backs may
still follow because they would otherwise get lost. Examples:
- endElementHandler() for empty elements when stopped in
startElementHandler(),
- endNameSpaceDeclHandler() when stopped in endElementHandler(),
startElementHandler(),
- endNameSpaceDeclHandler() when stopped in endElementHandler(),
and possibly others.
Can be called from most handlers, including DTD related call-backs,
except when parsing an external parameter entity and resumable != 0.
Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
Possible error codes:
Possible error codes:
- XML_ERROR_SUSPENDED: when suspending an already suspended parser.
- XML_ERROR_FINISHED: when the parser has already finished.
- XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
When resumable != 0 (true) then parsing is suspended, that is,
XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
When resumable != 0 (true) then parsing is suspended, that is,
XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
@ -789,7 +789,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
the externalEntityRefHandler() to call XML_StopParser() on the parent
parser (recursively), if one wants to stop parsing altogether.
When suspended, parsing can be resumed by calling XML_ResumeParser().
When suspended, parsing can be resumed by calling XML_ResumeParser().
*/
XMLPARSEAPI(enum XML_Status)
XML_StopParser(XML_Parser parser, XML_Bool resumable);
@ -797,7 +797,7 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
/* Resumes parsing after it has been suspended with XML_StopParser().
Must not be called from within a handler call-back. Returns same
status codes as XML_Parse() or XML_ParseBuffer().
Additional error code XML_ERROR_NOT_SUSPENDED possible.
Additional error code XML_ERROR_NOT_SUSPENDED possible.
*Note*:
This must be called on the most deeply nested child parser instance
@ -898,7 +898,7 @@ XML_GetErrorCode(XML_Parser parser);
be within the relevant markup. When called outside of the callback
functions, the position indicated will be just past the last parse
event (regardless of whether there was an associated callback).
They may also be called after returning from a call to XML_Parse
or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then
the location is the location of the character at which the error

2
src/lib/expat/expat_external.h
View File

@ -97,7 +97,7 @@ typedef char XML_LChar;
#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
typedef __int64 XML_Index;
typedef __int64 XML_Index;
typedef unsigned __int64 XML_Size;
#else
typedef long long XML_Index;

98
src/lib/expat/xmlparse.c
View File

@ -317,15 +317,15 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
static enum XML_Error
initializeEncoding(XML_Parser parser);
static enum XML_Error
doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
const char *end, int tok, const char *next, const char **nextPtr,
doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
const char *end, int tok, const char *next, const char **nextPtr,
XML_Bool haveMore);
static enum XML_Error
processInternalEntity(XML_Parser parser, ENTITY *entity,
processInternalEntity(XML_Parser parser, ENTITY *entity,
XML_Bool betweenDecl);
static enum XML_Error
doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
const char *start, const char *end, const char **endPtr,
const char *start, const char *end, const char **endPtr,
XML_Bool haveMore);
static enum XML_Error
doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
@ -343,7 +343,7 @@ static enum XML_Error
addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
const XML_Char *uri, BINDING **bindingsPtr);
static int
defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
static enum XML_Error
storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
@ -660,7 +660,7 @@ XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
static const XML_Char implicitContext[] = {
ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
@ -1449,7 +1449,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
positionPtr = bufferPtr;
return XML_STATUS_SUSPENDED;
case XML_INITIALIZED:
case XML_INITIALIZED:
case XML_PARSING:
ps_parsing = XML_FINISHED;
/* fall through */
@ -1572,7 +1572,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_INITIALIZED:
case XML_PARSING:
if (isFinal) {
ps_parsing = XML_FINISHED;
@ -1719,7 +1719,7 @@ XML_ResumeParser(XML_Parser parser)
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_INITIALIZED:
case XML_PARSING:
if (ps_finalBuffer) {
ps_parsing = XML_FINISHED;
@ -1946,7 +1946,7 @@ XML_GetFeatureList(void)
#endif
#ifdef XML_LARGE_SIZE
{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
#endif
#endif
{XML_FEATURE_END, NULL, 0}
};
@ -2009,7 +2009,7 @@ contentProcessor(XML_Parser parser,
const char *end,
const char **endPtr)
{
enum XML_Error result = doContent(parser, 0, encoding, start, end,
enum XML_Error result = doContent(parser, 0, encoding, start, end,
endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser))
@ -2091,7 +2091,7 @@ externalEntityInitProcessor3(XML_Parser parser,
if (result != XML_ERROR_NONE)
return result;
switch (ps_parsing) {
case XML_SUSPENDED:
case XML_SUSPENDED:
*endPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
@ -2125,7 +2125,7 @@ externalEntityContentProcessor(XML_Parser parser,
const char *end,
const char **endPtr)
{
enum XML_Error result = doContent(parser, 1, encoding, start, end,
enum XML_Error result = doContent(parser, 1, encoding, start, end,
endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser))
@ -2144,7 +2144,7 @@ doContent(XML_Parser parser,
XML_Bool haveMore)
{
/* save one level of indirection */
DTD * const dtd = _dtd;
DTD * const dtd = _dtd;
const char **eventPP;
const char **eventEndPP;
@ -2175,8 +2175,8 @@ doContent(XML_Parser parser,
}
else if (defaultHandler)
reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
*/
if (startTagLevel == 0)
return XML_ERROR_NO_ELEMENTS;
@ -2527,8 +2527,8 @@ doContent(XML_Parser parser,
}
else if (defaultHandler)
reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?
*/
if (startTagLevel == 0) {
*eventPP = end;
@ -2540,7 +2540,7 @@ doContent(XML_Parser parser,
}
*nextPtr = end;
return XML_ERROR_NONE;
case XML_TOK_DATA_CHARS:
case XML_TOK_DATA_CHARS:
{
XML_CharacterDataHandler charDataHandler = characterDataHandler;
if (charDataHandler) {
@ -2580,7 +2580,7 @@ doContent(XML_Parser parser,
}
*eventPP = s = next;
switch (ps_parsing) {
case XML_SUSPENDED:
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
@ -2939,27 +2939,27 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
static const XML_Char xmlNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
ASCII_e, '\0'
};
static const int xmlLen =
static const int xmlLen =
(int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
static const XML_Char xmlnsNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
ASCII_SLASH, '\0'
};
static const int xmlnsLen =
static const int xmlnsLen =
(int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
XML_Bool mustBeXML = XML_FALSE;
XML_Bool isXML = XML_TRUE;
XML_Bool isXMLNS = XML_TRUE;
BINDING *b;
int len;
@ -2986,7 +2986,7 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
isXML = XML_FALSE;
if (!mustBeXML && isXMLNS
if (!mustBeXML && isXMLNS
&& (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
isXMLNS = XML_FALSE;
}
@ -3197,7 +3197,7 @@ ignoreSectionProcessor(XML_Parser parser,
const char *end,
const char **endPtr)
{
enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
endPtr, (XML_Bool)!ps_finalBuffer);
if (result != XML_ERROR_NONE)
return result;
@ -3479,7 +3479,7 @@ entityValueInitProcessor(XML_Parser parser,
const char *next = start;
eventPtr = start;
for (;;) {
for (;;) {
tok = XmlPrologTok(encoding, start, end, &next);
eventEndPtr = next;
if (tok <= 0) {
@ -3507,7 +3507,7 @@ entityValueInitProcessor(XML_Parser parser,
if (result != XML_ERROR_NONE)
return result;
switch (ps_parsing) {
case XML_SUSPENDED:
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
@ -3572,7 +3572,7 @@ externalParEntProcessor(XML_Parser parser,
}
processor = prologProcessor;
return doProlog(parser, encoding, s, end, tok, next,
return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!ps_finalBuffer);
}
@ -3622,7 +3622,7 @@ prologProcessor(XML_Parser parser,
{
const char *next = s;
int tok = XmlPrologTok(encoding, s, end, &next);
return doProlog(parser, encoding, s, end, tok, next,
return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!ps_finalBuffer);
}
@ -3639,7 +3639,7 @@ doProlog(XML_Parser parser,
#ifdef XML_DTD
static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
#endif /* XML_DTD */
static const XML_Char atypeCDATA[] =
static const XML_Char atypeCDATA[] =
{ ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
static const XML_Char atypeIDREF[] =
@ -3660,7 +3660,7 @@ doProlog(XML_Parser parser,
static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
/* save one level of indirection */
DTD * const dtd = _dtd;
DTD * const dtd = _dtd;
const char **eventPP;
const char **eventEndPP;
@ -3834,8 +3834,8 @@ doProlog(XML_Parser parser,
entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead) {
if (!dtd->standalone &&
notStandaloneHandler &&
if (!dtd->standalone &&
notStandaloneHandler &&
!notStandaloneHandler(handlerArg))
return XML_ERROR_NOT_STANDALONE;
}
@ -4273,7 +4273,7 @@ doProlog(XML_Parser parser,
switch (tok) {
case XML_TOK_PARAM_ENTITY_REF:
/* PE references in internal subset are
not allowed within declarations. */
not allowed within declarations. */
return XML_ERROR_PARAM_ENTITY_REF;
case XML_TOK_XML_DECL:
return XML_ERROR_MISPLACED_XML_PI;
@ -4394,7 +4394,7 @@ doProlog(XML_Parser parser,
return XML_ERROR_RECURSIVE_ENTITY_REF;
if (entity->textPtr) {
enum XML_Error result;
XML_Bool betweenDecl =
XML_Bool betweenDecl =
(role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
result = processInternalEntity(parser, entity, betweenDecl);
if (result != XML_ERROR_NONE)
@ -4589,7 +4589,7 @@ doProlog(XML_Parser parser,
reportDefault(parser, enc, s, next);
switch (ps_parsing) {
case XML_SUSPENDED:
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
@ -4659,7 +4659,7 @@ epilogProcessor(XML_Parser parser,
}
eventPtr = s = next;
switch (ps_parsing) {
case XML_SUSPENDED:
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
@ -4702,12 +4702,12 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
#ifdef XML_DTD
if (entity->is_param) {
int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
next, &next, XML_FALSE);
}
else
else
#endif /* XML_DTD */
result = doContent(parser, tagLevel, internalEncoding, textStart,
result = doContent(parser, tagLevel, internalEncoding, textStart,
textEnd, &next, XML_FALSE);
if (result == XML_ERROR_NONE) {
@ -4747,13 +4747,13 @@ internalEntityProcessor(XML_Parser parser,
#ifdef XML_DTD
if (entity->is_param) {
int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
next, &next, XML_FALSE);
}
else
#endif /* XML_DTD */
result = doContent(parser, openEntity->startTagLevel, internalEncoding,
textStart, textEnd, &next, XML_FALSE);
result = doContent(parser, openEntity->startTagLevel, internalEncoding,
textStart, textEnd, &next, XML_FALSE);
if (result != XML_ERROR_NONE)
return result;
@ -4774,7 +4774,7 @@ internalEntityProcessor(XML_Parser parser,
int tok;
processor = prologProcessor;
tok = XmlPrologTok(encoding, s, end, &next);
return doProlog(parser, encoding, s, end, tok, next, nextPtr,
return doProlog(parser, encoding, s, end, tok, next, nextPtr,
(XML_Bool)!ps_finalBuffer);
}
else
@ -4783,8 +4783,8 @@ internalEntityProcessor(XML_Parser parser,
processor = contentProcessor;
/* see externalEntityContentProcessor vs contentProcessor */
return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
nextPtr, (XML_Bool)!ps_finalBuffer);
}
nextPtr, (XML_Bool)!ps_finalBuffer);
}
}
static enum XML_Error PTRCALL

4
src/lib/expat/xmltok.c
View File

@ -1333,7 +1333,7 @@ unknown_toUtf16(const ENCODING *enc,
ENCODING *
XmlInitUnknownEncoding(void *mem,
int *table,
CONVERTER convert,
CONVERTER convert,
void *userData)
{
int i;
@ -1627,7 +1627,7 @@ initScan(const ENCODING * const *encodingTable,
ENCODING *
XmlInitUnknownEncodingNS(void *mem,
int *table,
CONVERTER convert,
CONVERTER convert,
void *userData)
{
ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);

2
src/lib/util/astring.c
View File

@ -233,7 +233,7 @@ void astring_free(astring *str)
/*-------------------------------------------------
astring_expand - expand an astring to
astring_expand - expand an astring to
guarantee the given amount of space
-------------------------------------------------*/

20
src/mame/drivers/8080bw.c
View File

@ -1059,7 +1059,7 @@ static MACHINE_DRIVER_START( schaser )
/* basic machine hardware */
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_REPLACE("maincpu",I8080,1996800) /* 19.968MHz / 10 */
MDRV_CPU_REPLACE("maincpu",I8080,1996800) /* 19.968MHz / 10 */
MDRV_CPU_PROGRAM_MAP(schaser_map)
MDRV_CPU_IO_MAP(schaser_io_map)
MDRV_WATCHDOG_VBLANK_INIT(255)
@ -1468,7 +1468,7 @@ static MACHINE_DRIVER_START( polaris )
/* basic machine hardware */
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_REPLACE("maincpu",I8080,1996800) /* 19.968MHz / 10 */
MDRV_CPU_REPLACE("maincpu",I8080,1996800) /* 19.968MHz / 10 */
MDRV_CPU_PROGRAM_MAP(schaser_map)
MDRV_CPU_IO_MAP(polaris_io_map)
MDRV_WATCHDOG_VBLANK_INIT(255)
@ -2235,7 +2235,7 @@ static DRIVER_INIT( vortex )
/* unknown gun game by Model Racing, possibly Gun Champ?
BOARD 1:
_________________________________________________________________________________________________________________________________
_________________________________________________________________________________________________________________________________
| 12 13 14 15 16 17 18 19 |
| _________ _______ ___ ___ ___ ___ ___ ___ ___ ___ |
|___ 11 |74LS241N | |74LS159| |AM9| |AM9| |AM9| |AM9| |AM9| |AM9| |AM9| |AM9| |
@ -2292,11 +2292,11 @@ BOARD 1:
|_________________________________________________________________________________________________________________________________|
XTAL=19,66080MHz
XTAL=19,66080MHz
BOARD 2:
_________________________________________________________________________________________________________________________________
_________________________________________________________________________________________________________________________________
| |
| _______ _______ _______ _______ _________ |
|___ 11 |74LS175| |74LS151| |74LS151| |74LS153| |74LS244N | Model |
@ -2311,7 +2311,7 @@ BOARD 2:
| _| _______ _______ _______ _______ ____________ |
| _| |74LS174| |74LS151| |74LS151| |74LS153| 9 | | __|
| _| |_______| |_______| |_______| |_______| | | |
| _| | | |__
| _| | | |__
| _| | | =|
| _| _______ _______ _______ _______ | | =|
| _| |74LS174| |74LS151| |74LS151| |74LS153| 8 | | =|
@ -2337,7 +2337,7 @@ BOARD 2:
| _| =|
| _| _______ _______ ______________ _______ ____ __|
| _| 3 |74LS14N| |74LS74A| | SN76477N | |74LS107| |DIP1| |
| _| |_______| |_______| | 7923XY | |_______| |____| |__
| _| |_______| |_______| | 7923XY | |_______| |____| |__
| _| | SINGAPORE | |
| _| |______________| |
| _| _______ _______ _______ _______ _______ |
@ -2359,11 +2359,11 @@ BOARD 2:
// might need custom implementation
static ADDRESS_MAP_START( modelr_io_map, ADDRESS_SPACE_IO, 8 )
// AM_RANGE(0x00, 0x00) AM_DEVWRITE("mb14241", mb14241_shift_count_w)
// AM_RANGE(0x01, 0x01) AM_DEVREAD("mb14241", mb14241_shift_result_r)
// AM_RANGE(0x00, 0x00) AM_DEVWRITE("mb14241", mb14241_shift_count_w)
// AM_RANGE(0x01, 0x01) AM_DEVREAD("mb14241", mb14241_shift_result_r)
AM_RANGE(0x02, 0x02) AM_DEVWRITE("mb14241", mb14241_shift_data_w)
AM_RANGE(0x03, 0x03) AM_DEVREAD("mb14241", mb14241_shift_result_r)
// AM_RANGE(0x04, 0x04) AM_DEVWRITE("mb14241", mb14241_shift_count_w)
// AM_RANGE(0x04, 0x04) AM_DEVWRITE("mb14241", mb14241_shift_count_w)
AM_RANGE(0x05, 0x05) AM_WRITE(watchdog_reset_w)
ADDRESS_MAP_END

194
src/mame/drivers/aristmk4.c
View File

@ -1,12 +1,12 @@
/*
Driver: aristmk4
Manufacturer: Aristocrat Leisure Industries
Platform: Aristocrat 540 Video ( MK 2.5 Video / MK IV )
Driver by Palindrome & FraSher
Technical Notes:
68B09EP Motorola Processor
R6545AP for CRT video controller
UPD43256BCZ-70LL for 32kb of static ram used for 3 way electronic meters / 3 way memory
@ -16,59 +16,59 @@
2 x WF19054 = AY3-8910 sound chips driven by the 6522 VIA
1 x PML 2852 ( programmable logic ) used as address decoder.
1 x PML 2852 programmed as a PIA
PIA provides output signals to six mechanical meters.
It also provides the real time clock DS1287 to the CPU.
VIA drives the programmable sound generators and generates
a timing interrupt to the CPU (M6809_FIRQ_LINE)
The VIA uses Port A to write to the D0-D7 on the AY8910s. Port B hooks first 4 bits up to BC1/BC2/BDIR and A9 on AY1 and A8 on AY2
The remaining 4 bits are connected to other hardware, read via the VIA.
The AY8910 named ay1 has writes on PORT B to the ZN434 DA convertor.
The AY8910 named ay2 has writes to lamps and the light tower on Port A and B. these are implemented via the layout
*************************************************************************************************************
27/04/10 - FrasheR
2 x Sound Chips connected to the 6522 VIA.
16/05/10 - FrasheR
Fixed VIA for good. 5010 - 501F.
Hooked up push button inputs - FrasheR
Hooked up ports for the PML 2852 U3 - FrasheR
16/05/10 - Palindrome
Lamp outputs and layout added - Palindrome
NVRAM backup - Palindrome
NVRAM backup - Palindrome
20/05/10 - Palindrome
Connected SW7 for BGCOLOUR map select
Added LK13. 3Mhz or 1.5 Mhz CPU speed select
Added sound sample for mechanical meter pulse ( aristmk4.zip ).
30/5/10 - Palindrome
Now using mc146818 rtc driver instead of rtc_get_reg.
The mc146818 driver is buggy - reported problem to Firewave and issues will be addressed.
In this driver, the wrong day of the month is shown, wrong hours are shown.
rtc causes game to freeze if the game is left in audit mode with continuous writes to 0xA reg - 0x80 data.
TODO:
1.Create layouts for each game ( each game is currently using the generic aristmk4.lay for now ).
- Games may have different button configuration requirements ( ie.. 9 or 5 lines and different bet values )
2.Extend the driver to use the keno keyboard input for keno games.
3.Some with cashcade jackpot systems such as topgear do not work yet. Eforest does not work.
5.Add note acceptor support
6.Robot test
***********************************************************************************************************************************************/
#define MAIN_CLOCK XTAL_12MHz
@ -111,17 +111,17 @@ static VIDEO_START(aristmk4)
int tile;
for (tile = 0; tile < machine->gfx[0]->total_elements; tile++)
{
gfx_element_decode(machine->gfx[0], tile);
gfx_element_decode(machine->gfx[0], tile);
}
}
INLINE void uBackgroundColour(running_machine *machine)
{
/* SW7 can be set when the main door is open, this allows the colours for the background
to be adjusted whilst the machine is running.
/* SW7 can be set when the main door is open, this allows the colours for the background
to be adjusted whilst the machine is running.
There are 4 possible combinations for colour select via SW7, colours vary based on software installed.
*/
switch(input_port_read(machine, "SW7"))
{
@ -131,19 +131,19 @@ INLINE void uBackgroundColour(running_machine *machine)
// OE enabled on both shapes
break;
case 0x01:
// unselect U22 via SW7 . OE on U22 is low.
// unselect U22 via SW7 . OE on U22 is low.
memset(&shapeRomPtr[0x4000],0xff,0x2000); // fill unused space with 0xff
memcpy(&shapeRomPtr[0xa000],&shapeRom[0xa000], 0x2000); // restore defaults here
break;
case 0x02:
// unselect U47 via SW7 . OE on U47 is low.
// unselect U47 via SW7 . OE on U47 is low.
memcpy(&shapeRomPtr[0x4000],&shapeRom[0x4000], 0x2000);
memset(&shapeRomPtr[0xa000],0xff,0x2000);
memset(&shapeRomPtr[0xa000],0xff,0x2000);
break;
case 0x03:
// unselect U47 & u22 via SW7. both output enable low.
memset(&shapeRomPtr[0x4000],0xff,0x2000);
memset(&shapeRomPtr[0xa000],0xff,0x2000);
memset(&shapeRomPtr[0xa000],0xff,0x2000);
break;
}
}
@ -158,7 +158,7 @@ static VIDEO_UPDATE(aristmk4)
int bgtile;
int flipx;
int flipy;
for (y=27;y--;)
{
for (x=38;x--;)
@ -191,7 +191,7 @@ static READ8_HANDLER(ldsw)
static READ8_HANDLER(cgdrr)
{
if(cgdrsw) // is the LC closed
{
return ripple; // return a positive value from the ripple counter
@ -201,9 +201,9 @@ static READ8_HANDLER(cgdrr)
static WRITE8_HANDLER(cgdrw)
{
ripple = data;
}
static WRITE8_HANDLER(u3_p0)
@ -224,7 +224,7 @@ static READ8_HANDLER(u3_p2)
output_set_lamp_value(20, (u3_p3_ret >> 2) & 1); //jackpotkey light
if (u3_p0_w&0x20) // DOPTE on
{
{
if (u3_p3_ret&0x02) // door closed
u3_p2_ret = u3_p2_ret^0x08; // DOPTI on
}
@ -266,7 +266,7 @@ PORTB - MECHANICAL METERS
static READ8_HANDLER(mkiv_pia_ina)
{
{
return mc146818_port_r(space,1);
}
@ -278,15 +278,15 @@ static WRITE8_HANDLER(mkiv_pia_outa)
{
mc146818_port_w(space,1,data);
//logerror("rtc protocol write data: %02X\n",data);
}
else
else
{
mc146818_port_w(space,0,data);
//logerror("rtc protocol write address: %02X\n",data);
}
}
//output ca2
@ -316,18 +316,18 @@ static WRITE8_DEVICE_HANDLER(mkiv_pia_outb)
emet[0] = data & 0x01; /* emet1 - bit 1 - PB0 */
/* seren1 - bit 2 - PB1 */
emet[1] = data & 0x04; /* emet3 - bit 3 - PB2 */
emet[2] = data & 0x08; /* emet4 - bit 4 - PB3 */
emet[3] = data & 0x10; /* emet5 - bit 5 - PB4 */
emet[4] = data & 0x20; /* emet6 - bit 6 - PB5 */
emet[2] = data & 0x08; /* emet4 - bit 4 - PB3 */
emet[3] = data & 0x10; /* emet5 - bit 5 - PB4 */
emet[4] = data & 0x20; /* emet6 - bit 6 - PB5 */
for(i = 0;i<sizeof(emet);i++)
{
if(emet[i])
{
//logerror("Mechanical meter %d pulse: %02d\n",i+1, emet[i]);
sample_start(samples,i,0, FALSE); // pulse sound for mechanical meters
sample_start(samples,i,0, FALSE); // pulse sound for mechanical meters
}
}
@ -338,8 +338,8 @@ static WRITE8_DEVICE_HANDLER(mkiv_pia_outb)
static const char *const meter_sample_names[] =
{
"*aristmk4",
"tick.wav",
0
"tick.wav",
0
};
static const samples_interface meter_samples_interface =
@ -426,7 +426,7 @@ static READ8_DEVICE_HANDLER(via_b_r)
break;
default:
break; //timer will reset the input
break; //timer will reset the input
}
@ -578,7 +578,7 @@ static WRITE8_DEVICE_HANDLER(via_cb2_w)
// as soon as it is 1, HOPCO1 to remain 'ON'
if (data==0x01)
hopper_motor=data;
hopper_motor=data;
else if (hopper_motor<0x02)
hopper_motor=data;
}
@ -596,7 +596,7 @@ static WRITE8_DEVICE_HANDLER(pblp_out)
output_set_lamp_value(4, (data >> 5) & 1);
output_set_lamp_value(2, (data >> 6) & 1);
output_set_lamp_value(10,(data >> 7) & 1);
//logerror("Lights port A %02X\n",data);
}
@ -610,7 +610,7 @@ static WRITE8_DEVICE_HANDLER(pbltlp_out)
output_set_lamp_value(15, (data >> 5) & 1); // light tower
output_set_lamp_value(16, (data >> 6) & 1); // light tower
output_set_lamp_value(17, (data >> 7) & 1); // light tower
//logerror("Lights port B: %02X\n",data);
@ -641,7 +641,7 @@ static ADDRESS_MAP_START( aristmk4_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x1801, 0x1801) AM_DEVREADWRITE("crtc", mc6845_register_r, mc6845_register_w)
AM_RANGE(0x2000, 0x3fff) AM_ROM // graphics rom map
AM_RANGE(0x4000, 0x4fff) AM_RAMBANK("bank1") AM_BASE_SIZE_GENERIC(nvram)
AM_RANGE(0x5000, 0x5000) AM_WRITE(u3_p0)
AM_RANGE(0x5002, 0x5002) AM_READ(u3_p2)
AM_RANGE(0x5003, 0x5003) AM_READ_PORT("5003")
@ -652,7 +652,7 @@ static ADDRESS_MAP_START( aristmk4_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x5010, 0x501f) AM_DEVREADWRITE("via6522_0",via_r,via_w)
AM_RANGE(0x5200, 0x5200) AM_READ_PORT("5200")
AM_RANGE(0x5201, 0x5201) AM_READ_PORT("5201")
AM_RANGE(0x527f, 0x5281) AM_DEVREADWRITE("ppi8255_0", ppi8255_r, ppi8255_w)
AM_RANGE(0x527f, 0x5281) AM_DEVREADWRITE("ppi8255_0", ppi8255_r, ppi8255_w)
AM_RANGE(0x5300, 0x5300) AM_READ_PORT("5300")
AM_RANGE(0x5380, 0x5383) AM_DEVREADWRITE("pia6821_0",pia6821_r,pia6821_w) // RTC data - PORT A , mechanical meters - PORTB ??
AM_RANGE(0x5440, 0x5440) AM_WRITE(mlamps) // take win and gamble lamps
@ -663,7 +663,7 @@ ADDRESS_MAP_END
static INPUT_PORTS_START(aristmk4)
/***********************************************************************************************************/
PORT_START("via_port_b")
PORT_DIPNAME( 0x40, 0x40, "HOPCO1" )
PORT_DIPSETTING( 0x40, DEF_STR( On ) ) PORT_DIPLOCATION("AY:3")
@ -671,16 +671,16 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPSETTING( 0x80, DEF_STR( On ) ) PORT_DIPLOCATION("AY:4")
/************************************************************************************************************
5002
************************************************************************************************************/
PORT_START("5002")
PORT_DIPNAME( 0x01, 0x00, "HOPCO2") // coins out hopper 2 , why triggers logic door ?
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5002:1")
PORT_DIPSETTING( 0x01, DEF_STR( On ) )
PORT_DIPNAME( 0x02, 0x02, "CBOPT2") // coin in cash box 2
PORT_DIPNAME( 0x02, 0x02, "CBOPT2") // coin in cash box 2
PORT_DIPSETTING( 0x02, DEF_STR( On ) ) PORT_DIPLOCATION("5002:2")
PORT_DIPNAME( 0x04, 0x00, "HOPHI2") // hopper 2 full
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5002:3")
@ -688,7 +688,7 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPNAME( 0x08, 0x00, "DOPTI") // photo optic door
PORT_DIPSETTING( 0x00, DEF_STR( On ) )
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("AUDTSW") PORT_TOGGLE PORT_CODE(KEYCODE_K)
PORT_DIPNAME( 0x20, 0x00, "HOPLO1") // hopper 1 low
PORT_DIPNAME( 0x20, 0x00, "HOPLO1") // hopper 1 low
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5002:6")
PORT_DIPSETTING( 0x20, DEF_STR( On ) )
PORT_DIPNAME( 0x40, 0x00, "HOPLO2") // hopper 2 low
@ -698,16 +698,16 @@ static INPUT_PORTS_START(aristmk4)
/************************************************************************************************************
5003
************************************************************************************************************/
PORT_START("5003")
PORT_DIPNAME( 0x01, 0x00, "OPTAUI") // opto audit in
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5003:1")
PORT_DIPSETTING( 0x01, DEF_STR( On ) )
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("DSWDT") PORT_TOGGLE PORT_CODE(KEYCODE_M) // main door switch
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("DSWDT") PORT_TOGGLE PORT_CODE(KEYCODE_M) // main door switch
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("JKPTSW") PORT_TOGGLE PORT_CODE(KEYCODE_J) // jackpot reset switch
PORT_DIPNAME( 0x08, 0x00, "HOPHI1") // hopper 1 full
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5003:4")
@ -715,7 +715,7 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPNAME( 0x10, 0x00, "OPTA2") // coin in a2
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5003:5")
PORT_DIPSETTING( 0x10, DEF_STR( On ) )
PORT_DIPNAME( 0x20, 0x20, "OPTB2") // coin in b2
PORT_DIPNAME( 0x20, 0x20, "OPTB2") // coin in b2
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5003:6")
PORT_DIPSETTING( 0x20, DEF_STR( On ) )
PORT_DIPNAME( 0x40, 0x00, "PTRTAC") // printer taco
@ -724,13 +724,13 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPNAME( 0x80, 0x00, "PTRHOM") // printer home
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("5003:8")
PORT_DIPSETTING( 0x80, DEF_STR( On ) )
/************************************************************************************************************
5300
************************************************************************************************************/
PORT_START("5300")
PORT_DIPNAME( 0x01, 0x00, "5300-1")
PORT_DIPSETTING( 0X00, DEF_STR( Off ) ) PORT_DIPLOCATION("5300:1")
@ -761,31 +761,31 @@ static INPUT_PORTS_START(aristmk4)
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("5 CREDITS PER LINE") PORT_CODE(KEYCODE_T) // 5 credits per line
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("10 CREDITS PER LINE") PORT_CODE(KEYCODE_Y) // 10 credits per line
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("COLLECT") PORT_CODE(KEYCODE_Q)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("RESERVE") PORT_CODE(KEYCODE_A) // reserve
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("RESERVE") PORT_CODE(KEYCODE_A) // reserve
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("GAMBLE") PORT_CODE(KEYCODE_U) // auto gamble & gamble
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("TAKE WIN") PORT_CODE(KEYCODE_J)
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0-7") PORT_CODE(KEYCODE_U)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0-8") PORT_CODE(KEYCODE_I)
PORT_START("500e")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("1 CREDIT PER LINE") PORT_CODE(KEYCODE_W) // 1 credit per line
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 1") PORT_CODE(KEYCODE_S)
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 1") PORT_CODE(KEYCODE_S)
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("2 CREDITS PER LINE") PORT_CODE(KEYCODE_E) // 2 credits per line
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 9") PORT_CODE(KEYCODE_H)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 9") PORT_CODE(KEYCODE_H)
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("3 CREDITS PER LINE") PORT_CODE(KEYCODE_R) // 3 credits per line
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 7") PORT_CODE(KEYCODE_G)
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 5") PORT_CODE(KEYCODE_F)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PLAY 3") PORT_CODE(KEYCODE_D)
PORT_START("500f")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("2-1") PORT_CODE(KEYCODE_1)
PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("2-2") PORT_CODE(KEYCODE_2)
PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("2-3") PORT_CODE(KEYCODE_3)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("AUX - PB5") PORT_CODE(KEYCODE_X)
PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("AUX - PB5") PORT_CODE(KEYCODE_X)
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("MEM TEST - PB4") PORT_CODE(KEYCODE_C)
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("HOPPER TEST - PB3") PORT_CODE(KEYCODE_V)
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("PRINT DATA - PB2") PORT_CODE(KEYCODE_B)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("CLOCK INIT - PB1") PORT_CODE(KEYCODE_N)
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("CLOCK INIT - PB1") PORT_CODE(KEYCODE_N)
PORT_START("5200")
PORT_DIPNAME( 0x01, 0x00, "5200-1")
@ -843,28 +843,28 @@ static INPUT_PORTS_START(aristmk4)
PORT_START("insertcoin")
PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_COIN1 ) PORT_NAME("Insert Credit")
/************************************************************************************************************
Logic Door switch
************************************************************************************************************/
PORT_START("CGDRSW")
PORT_DIPNAME( 0x10, 0x10, "CGDRSW" ) PORT_DIPLOCATION("CGDRSW:1") /* toggle switch */
PORT_DIPSETTING( 0x00, "Open" )
PORT_DIPSETTING( 0x10, "Closed" )
/************************************** LINKS ***************************************************************/
PORT_START("LK13")
PORT_DIPNAME( 0x10, 0x10, "Speed Select" ) PORT_DIPLOCATION("LK13:1")
PORT_DIPNAME( 0x10, 0x10, "Speed Select" ) PORT_DIPLOCATION("LK13:1")
PORT_DIPSETTING( 0x00, "3 Mhz" )
PORT_DIPSETTING( 0x10, "1.5 Mhz" )
/********************************* Dip switch for background color *************************************************/
PORT_START("SW7")
PORT_DIPNAME( 0x01, 0x01, "SW7 - U22 BG COLOR" )
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("SW7:1")
@ -872,10 +872,10 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPNAME( 0x02, 0x00, "SW7 - U47 BG COLOR" )
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("SW7:2")
PORT_DIPSETTING( 0x02, DEF_STR( On ) )
/********************************* 9 way control rotary switches ***************************************************/
PORT_START("SW3")
PORT_DIPNAME( 0x0f, 0x00, "SW3 - M/C NO" )
PORT_DIPSETTING( 0x00, "0" )
@ -901,7 +901,7 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPSETTING( 0x07, "7" )
PORT_DIPSETTING( 0x08, "8" )
PORT_DIPSETTING( 0x09, "9" )
PORT_START("SW5")
PORT_DIPNAME( 0x0f, 0x00, "SW5 - M/C NO" )
PORT_DIPSETTING( 0x00, "0" )
@ -914,7 +914,7 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPSETTING( 0x07, "7" )
PORT_DIPSETTING( 0x08, "8" )
PORT_DIPSETTING( 0x09, "9" )
PORT_START("SW6")
PORT_DIPNAME( 0x0f, 0x00, "SW6 - M/C NO" )
PORT_DIPSETTING( 0x00, "0" )
@ -927,9 +927,9 @@ static INPUT_PORTS_START(aristmk4)
PORT_DIPSETTING( 0x07, "7" )
PORT_DIPSETTING( 0x08, "8" )
PORT_DIPSETTING( 0x09, "9" )
/***************** DIP SWITCHES **********************************************************************/
PORT_START("DSW1")
PORT_DIPNAME( 0x01, 0x00, "DSW1 - Maxbet rejection" )
PORT_DIPSETTING( 0x00, DEF_STR( Off ) ) PORT_DIPLOCATION("SW1:1")
@ -1135,13 +1135,13 @@ static PALETTE_INIT( aristmk4 )
static DRIVER_INIT( aristmk4 )
{
mc146818_init(machine, MC146818_IGNORE_CENTURY);
shapeRomPtr = (UINT8 *)memory_region(machine, "tile_gfx");
shapeRomPtr = (UINT8 *)memory_region(machine, "tile_gfx");
memcpy(shapeRom,shapeRomPtr,sizeof(shapeRom)); // back up
}
static MACHINE_START( aristmk4 )
{
samples = devtag_get_device(machine, "samples");
state_save_register_global_pointer(machine, nvram,0x1000); // nvram
}
@ -1204,11 +1204,11 @@ static MACHINE_DRIVER_START( aristmk4 )
MDRV_SOUND_ADD("ay2", AY8910 , MAIN_CLOCK/8)
MDRV_SOUND_CONFIG(ay8910_config2)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.40)
MDRV_SOUND_ADD("samples", SAMPLES, 0)
MDRV_SOUND_CONFIG(meter_samples_interface)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.05)
MACHINE_DRIVER_END

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

@ -360,7 +360,7 @@ static VIDEO_UPDATE(cb2001)
count++;
}
}
count = 0x0000;
@ -731,7 +731,7 @@ ROM_START( scherrym )
ROM_LOAD16_WORD( "f11.bin", 0x000000, 0x40000, CRC(8967f58d) SHA1(eb01a16b7d108f5fbe5de8f611b4f77869aedbf1) )
ROM_REGION( 0x080000, "gfx", ROMREGION_ERASEFF )
// ROM_LOAD( "12a.bin", 0x000000, 0x80000,NO_DUMP ) // missing on PCB - 2 PCBs have been found this way, it probably uploads the GFX.
// ROM_LOAD( "12a.bin", 0x000000, 0x80000,NO_DUMP ) // missing on PCB - 2 PCBs have been found this way, it probably uploads the GFX.
ROM_REGION( 0x400, "proms", 0 )
ROM_LOAD( "n82s135-1.bin", 0x000, 0x100, CRC(66ed363f) SHA1(65bd37842c441c2e712844b07c0cfe37ef16d0ef) )

28
src/mame/drivers/dec8.c
View File

@ -814,14 +814,14 @@ ADDRESS_MAP_END
/******************************************************************************/
/*
Gondomania schematics show the following:
Port P0 - attached to 2 * LS374 at location 4C & 1C
Port P1 - attached to 2 * LS374 at location 3C & 2C
Port P2.2 -> SECIRQ (IRQ to main CPU)
Port P2.3 -> 'COUNT' (Enable coin counter - also wired directly to coinage) [not emulated]
Port P2.4-7 -> Enable latches 4C, 1C, 3C, 2C
Port P3.4-7 -> Directly attached to coinage connector (3 coins & service)
Gondomania schematics show the following:
Port P0 - attached to 2 * LS374 at location 4C & 1C
Port P1 - attached to 2 * LS374 at location 3C & 2C
Port P2.2 -> SECIRQ (IRQ to main CPU)
Port P2.3 -> 'COUNT' (Enable coin counter - also wired directly to coinage) [not emulated]
Port P2.4-7 -> Enable latches 4C, 1C, 3C, 2C
Port P3.4-7 -> Directly attached to coinage connector (3 coins & service)
*/
@ -847,11 +847,11 @@ static READ8_HANDLER( dec8_mcu_from_main_r )
static WRITE8_HANDLER( dec8_mcu_to_main_w )
{
dec8_state *state = (dec8_state *)space->machine->driver_data;
// Outputs P0 and P1 are latched
if (offset==0) state->i8751_port0=data;
else if (offset==1) state->i8751_port1=data;
// P2 - controls latches for main CPU communication
if (offset==2 && (data&0x10)==0)
state->i8751_port0 = state->i8751_value>>8;
@ -861,7 +861,7 @@ static WRITE8_HANDLER( dec8_mcu_to_main_w )
state->i8751_return = (state->i8751_return & 0xff) | (state->i8751_port0 << 8);
if (offset==2 && (data&0x80)==0)
state->i8751_return = (state->i8751_return & 0xff00) | state->i8751_port1;
// P2 - IRQ to main CPU
if (offset==2 && (data&4)==0)
cpu_set_input_line(state->maincpu, M6809_IRQ_LINE, ASSERT_LINE);
@ -1002,7 +1002,7 @@ static INPUT_PORTS_START( ghostb )
PORT_DIPSETTING( 0x80, DEF_STR( Off ) )
PORT_DIPSETTING( 0x00, DEF_STR( On ) )
PORT_START("I8751")
PORT_START("I8751")
/* Low 4 bits not connected on schematics */
PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE1 )
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN1 )
@ -1056,10 +1056,10 @@ static INPUT_PORTS_START( meikyuh )
PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN3 )
PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN2 )
PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_COIN1 )
INPUT_PORTS_END
static INPUT_PORTS_START( srdarwin )
PORT_START("IN0")
PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_8WAY

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

@ -118,11 +118,11 @@ Notes:
FI-1.1A - 82S129 Bipolar PROM
FI-2.3B - 82S135 Bipolar PROM
FI-3.4B - 82S129 Bipolar PROM
6502 - clock 1.500MHz [12/8]
YM3526 - clock 3.000MHz [12/4]
M5205 - clock 375kHz [12/32]. Sample rate: Pin 1 High & Pin 2 Low = 0.375/48 = 7.8125kHz
Measurements
------------
XTAL1 - 11.9911MHz

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

@ -572,7 +572,7 @@ static WRITE16_HANDLER( adsp_rombank_w )
static TIMER_DEVICE_CALLBACK( adsp_autobuffer_irq )
{
cpu_device *adsp = timer.machine->device<cpu_device>("adsp");
/* get the index register */
int reg = adsp->state(ADSP2100_I0 + adsp_ireg);

38
src/mame/drivers/littlerb.c
View File

@ -77,7 +77,7 @@ static int paldac_offset = 0;
WRITE16_HANDLER( region4_w )
{
{
COMBINE_DATA(&littlerb_region4[offset]);
}
@ -93,19 +93,19 @@ WRITE16_HANDLER(palette_offset_w)
WRITE16_HANDLER( palette_data_w )
{
//printf("palette write %04x\n",data);
paldac[paldac_select][paldac_offset] = data;
paldac_select++;
if (paldac_select==3)
{
int r,g,b;
r = paldac[0][paldac_offset];
g = paldac[1][paldac_offset];
b = paldac[2][paldac_offset];
palette_set_color(space->machine,paldac_offset,MAKE_RGB(r,g,b));
paldac_select = 0;
paldac_offset++;
paldac_offset&=0x7f;
@ -114,27 +114,27 @@ WRITE16_HANDLER( palette_data_w )
WRITE16_HANDLER( palette_reset_w )
{
// printf("palette reset write %04x\n",data);
// printf("palette reset write %04x\n",data);
paldac_select = 0;
paldac_offset = 0;
}
/* this map is wrong because our VDP access is wrong! */
static ADDRESS_MAP_START( littlerb_vdp_map8, 0, 16 )
AM_RANGE(0x00000000, 0x0007ffff) AM_RAM_WRITE(region4_w)
/* these are definitely written by a non-incrementing access to the VDP */
AM_RANGE(0x00800000, 0x00800001) AM_WRITE(palette_offset_w)
AM_RANGE(0x00800002 ,0x00800003) AM_WRITE(palette_data_w)
AM_RANGE(0x00800004 ,0x00800005) AM_WRITE(palette_reset_w)
AM_RANGE(0x0ff80000, 0x0fffffff) AM_RAM_WRITE(region4_w)
AM_RANGE(0x1ff80000, 0x1fffffff) AM_RAM_WRITE(region4_w) AM_BASE(&littlerb_region4)
ADDRESS_MAP_END
@ -166,7 +166,7 @@ public:
{
return global_alloc(littlerb_vdp_device_config(mconfig, tag, owner, clock));
}
virtual device_t *alloc_device(running_machine &machine) const
{
return auto_alloc(&machine, littlerb_vdp_device(machine, *this));
@ -177,7 +177,7 @@ protected:
{
return (spacenum == 0) ? &m_space_config : NULL;
}
address_space_config m_space_config;
};
@ -424,7 +424,7 @@ static void draw_sprite(bitmap_t *bitmap, int xsize,int ysize, int offset, int x
UINT16* spritegfx = littlerb_region4;
int x,y;
//int pal = 1;
for (y=0;y<ysize;y++)
{
for (x=0;x<xsize;x++)
@ -434,7 +434,7 @@ static void draw_sprite(bitmap_t *bitmap, int xsize,int ysize, int offset, int x
UINT8 pix2 = (spritegfx[offset]>>8)&0x0f;
drawxpos = xpos+x*2;
drawypos = ypos+y;
pix1+=pal*0x10;
pix2+=pal*0x10;
@ -477,11 +477,11 @@ static VIDEO_UPDATE(littlerb)
// e.g ffc010000
code = (spriteregion[offs+0] & 0xfff0)>>4;
code |= (spriteregion[offs+1] & 0x003f)<<12;
pal = 0;//(spriteregion[offs+4] & 0xf000)>>13; // where is the colour bit?!
//if (code!=0) printf("%04x %04x %04x %04x %04x %04x\n", spriteregion[offs+0], spriteregion[offs+1], spriteregion[offs+2], spriteregion[offs+3], spriteregion[offs+4], spriteregion[offs+5]);
draw_sprite(bitmap,xsize,ysize,code,x-8,y-16, pal);
}

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

@ -809,7 +809,7 @@ ROM_START( looping )
ROM_LOAD( "loop555.bin", 0x4000, 0x1000, CRC(0ef4c922) SHA1(df6db0897a51aa10e106865a643588d866ef8c4e) )
ROM_LOAD( "loop556.bin", 0x5000, 0x1000, CRC(3419a5d5) SHA1(2b0249c54985ab5e12de17c0e3d62caa0c7575e3) )
ROM_LOAD( "loop557.bin", 0x6000, 0x1000, CRC(d430e287) SHA1(b0edd25ef4d2468cc1f8c10ac49c545a89d398d7) )
ROM_REGION( 0x3800, "audiocpu", 0 ) /* TMS9980 code */
ROM_LOAD( "loopc13.bin", 0x0000, 0x1000, CRC(ff9ac4ec) SHA1(9f8df94cd79d86fe4c384df1d5d729b58a7ca7a8) )
ROM_LOAD( "loopa13.bin", 0x0800, 0x1000, CRC(1de29f25) SHA1(535acb132266d6137b0610ee9a9b946459ae44af) )

6
src/mame/drivers/namcos22.c
View File

@ -5288,11 +5288,11 @@ INPUT_PORTS_END /* Time Crisis */
static CUSTOM_INPUT( acedrvr_shift_read )
{
int shift = input_port_read(field->port->machine, "SHIFT");
if (shift > 0 && shift != prev_stick_state)
{
prev_stick_state = shift;
switch (shift)
{
case 0x01:
@ -5306,7 +5306,7 @@ static CUSTOM_INPUT( acedrvr_shift_read )
break;
}
}
return stick_input;
}

12
src/mame/drivers/pinkiri8.c
View File

@ -47,11 +47,11 @@ static ADDRESS_MAP_START( janshi_vdp_map8, 0, 8 )
AM_RANGE(0xfc0000, 0xfc1fff) AM_RAM AM_BASE(&janshi_back_vram) // bg tilemap?
AM_RANGE(0xfc2000, 0xfc2fff) AM_RAM AM_BASE(&janshi_vram1) // xpos, colour, tile number etc.
AM_RANGE(0xfc3700, 0xfc377f) AM_RAM AM_BASE(&janshi_unk1) // ?? height related?
AM_RANGE(0xfc3780, 0xfc37bf) AM_RAM AM_BASE(&janshi_widthflags)
AM_RANGE(0xfc37c0, 0xfc37ff) AM_RAM AM_BASE(&janshi_unk2) // 2x increasing tables 00 10 20 30 etc.
AM_RANGE(0xfc3800, 0xfc3fff) AM_RAM AM_BASE(&janshi_vram2) // y pos + unknown
AM_RANGE(0xff0000, 0xff07ff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_split1_w) AM_BASE_GENERIC(paletteram)
@ -320,7 +320,7 @@ static VIDEO_UPDATE( pinkiri8 )
}
else if (spr_offs<0x580)
{
// height = 2;
// height = 2;
}
else if (spr_offs<0x880)
{
@ -328,11 +328,11 @@ static VIDEO_UPDATE( pinkiri8 )
}
else if (spr_offs<0x1000)
{
// height = 2;
// height = 2;
}
else if (spr_offs<0x1080)
{
// height = 2;
// height = 2;
}
else if (spr_offs<0x1700)
{
@ -340,7 +340,7 @@ static VIDEO_UPDATE( pinkiri8 )
}
else if (spr_offs<0x1730)
{
// height = 2;
// height = 2;
}
else if (spr_offs<0x1930)
{

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

@ -115,7 +115,7 @@ ADDRESS_MAP_END
static UINT8 mux_data;
static ADDRESS_MAP_START( rbmk_mcu_mem, ADDRESS_SPACE_PROGRAM, 8 )
// AM_RANGE(0x0000, 0x0fff) AM_ROM
// AM_RANGE(0x0000, 0x0fff) AM_ROM
ADDRESS_MAP_END
static READ8_HANDLER( rbmk_mcu_io_r )
@ -547,7 +547,7 @@ static MACHINE_DRIVER_START( rbmk )
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.47)
MDRV_SOUND_ADD("ymsnd", YM2151, 22000000 / 8)
// MDRV_SOUND_CONFIG(ym2151_config)
// MDRV_SOUND_CONFIG(ym2151_config)
MDRV_SOUND_ROUTE(0, "lspeaker", 0.60)
MDRV_SOUND_ROUTE(1, "rspeaker", 0.60)
MACHINE_DRIVER_END

10
src/mame/drivers/renegade.c
View File

@ -626,10 +626,10 @@ static CUSTOM_INPUT( mcu_status_r )
if (!main_sent)
res |= 0x01;
if (!mcu_sent)
res |= 0x02;
res |= 0x02;
}
return res;
return res;
}
/********************************************************************************************/
@ -710,8 +710,8 @@ static ADDRESS_MAP_START( renegade_mcu_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x0004, 0x0004) AM_WRITE(renegade_68705_ddr_a_w)
AM_RANGE(0x0005, 0x0005) AM_WRITE(renegade_68705_ddr_b_w)
AM_RANGE(0x0006, 0x0006) AM_WRITE(renegade_68705_ddr_c_w)
// AM_RANGE(0x0008, 0x0008) AM_READWRITE(m68705_tdr_r, m68705_tdr_w)
// AM_RANGE(0x0009, 0x0009) AM_READWRITE(m68705_tcr_r, m68705_tcr_w)
// AM_RANGE(0x0008, 0x0008) AM_READWRITE(m68705_tdr_r, m68705_tdr_w)
// AM_RANGE(0x0009, 0x0009) AM_READWRITE(m68705_tcr_r, m68705_tcr_w)
AM_RANGE(0x0010, 0x007f) AM_RAM
AM_RANGE(0x0080, 0x07ff) AM_ROM
ADDRESS_MAP_END
@ -991,7 +991,7 @@ ROM_START( renegade )
ROM_LOAD( "nc-5.bin", 0x0000, 0x8000, CRC(9adfaa5d) SHA1(7bdb7bd4387b49e0489f9539161e1ed9d8f9f6a0) )
ROM_REGION( 0x30000, "tiles", 0 )
ROM_LOAD( "n1-5.ic1", 0x00000, 0x8000, CRC(4a9f47f3) SHA1(01c94bc4c85314f1e0caa3afe91705875d118c13) )
ROM_LOAD( "n1-5.ic1", 0x00000, 0x8000, CRC(4a9f47f3) SHA1(01c94bc4c85314f1e0caa3afe91705875d118c13) )
ROM_LOAD( "n6-5.ic28", 0x08000, 0x8000, CRC(d62a0aa8) SHA1(a0b55cd3eee352fb91d9bb8c6c4f4f55b2df83e9) )
ROM_LOAD( "n7-5.ic27", 0x10000, 0x8000, CRC(7ca5a532) SHA1(1110aa1c7562805dd4b298ab2860c66a6cc2685b) )
ROM_LOAD( "n2-5.ic14", 0x18000, 0x8000, CRC(8d2e7982) SHA1(72fc85ff7b54be10501a2a24303dadd5f33e5650) )

434
src/mame/drivers/toaplan2.c
View File

@ -1992,11 +1992,11 @@ static READ8_HANDLER( v25s_internal_io_r )
static WRITE8_HANDLER( v25s_internal_io_w )
{
logerror("(PC=%05x) V25S internal I/O write %02x at [%04x]\n",cpu_get_pc(space->cpu),data,offset+0xf00);
switch (offset)
{
/* 0x00 - 0x3f - Ports */
case 0x00:
logerror("write: Port 0 (P0)\n");
break;
@ -2006,9 +2006,9 @@ static WRITE8_HANDLER( v25s_internal_io_w )
case 0x02:
logerror("write: Port 0 Mode Control Register (PMC0)\n");
break;
case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: INVALID_WRITE break;
case 0x08:
logerror("write: Port 1 (P1)\n");
break;
@ -2017,8 +2017,8 @@ static WRITE8_HANDLER( v25s_internal_io_w )
break;
case 0x0A:
logerror("write: Port 1 Mode Control Register (PMC1)\n");
break;
break;
case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: INVALID_WRITE break;
case 0x10:
@ -2030,342 +2030,342 @@ static WRITE8_HANDLER( v25s_internal_io_w )
case 0x12:
logerror("write: Port 2 Mode Control Register (PMC2)\n");
break;
case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C:
case 0x1D: case 0x1E: case 0x1F: case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26:
case 0x27: case 0x28: case 0x29: case 0x2A: case 0x2B: case 0x2C: case 0x2D: case 0x2E: case 0x2F: case 0x30:
case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: INVALID_WRITE break;
case 0x38:
logerror("write: invalid (R/O) Port T (PT)\n");
break;
case 0x39: case 0x3a: INVALID_WRITE break;
case 0x3b:
logerror("write: Port T Mode Register(PMT)\n");
break;
case 0x3c: case 0x3d: case 0x3e: case 0x3f: INVALID_WRITE break;
/* 0x40 - 0x4f - Interrupts */
case 0x40:
logerror("write: External Interrupt Mode Register (INTM)\n");
break;
case 0x41: case 0x42: case 0x43: INVALID_WRITE break;
case 0x44:
logerror("write: External Interrupt Macro Service Control Register 0 (EMS0)\n");
break;
case 0x45:
logerror("write: External Interrupt Macro Service Control Register 1 (EMS1)\n");
break;
case 0x46:
logerror("write: External Interrupt Macro Service Control Register 2 (EMS2)\n");
break;
case 0x47: case 0x48: case 0x49: case 0x4a: case 0x4b: INVALID_WRITE break;
case 0x4c:
logerror("write: External Interrupt Request Control Register 0 (EXIC0)\n");
case 0x38:
logerror("write: invalid (R/O) Port T (PT)\n");
break;
case 0x4d:
logerror("write: External Interrupt Request Control Register 1 (EXIC1)\n");
case 0x39: case 0x3a: INVALID_WRITE break;
case 0x3b:
logerror("write: Port T Mode Register(PMT)\n");
break;
case 0x4e:
case 0x3c: case 0x3d: case 0x3e: case 0x3f: INVALID_WRITE break;
/* 0x40 - 0x4f - Interrupts */
case 0x40:
logerror("write: External Interrupt Mode Register (INTM)\n");
break;
case 0x41: case 0x42: case 0x43: INVALID_WRITE break;
case 0x44:
logerror("write: External Interrupt Macro Service Control Register 0 (EMS0)\n");
break;
case 0x45:
logerror("write: External Interrupt Macro Service Control Register 1 (EMS1)\n");
break;
case 0x46:
logerror("write: External Interrupt Macro Service Control Register 2 (EMS2)\n");
break;
case 0x47: case 0x48: case 0x49: case 0x4a: case 0x4b: INVALID_WRITE break;
case 0x4c:
logerror("write: External Interrupt Request Control Register 0 (EXIC0)\n");
break;
case 0x4d:
logerror("write: External Interrupt Request Control Register 1 (EXIC1)\n");
break;
case 0x4e:
logerror("write: External Interrupt Request Control Register 2 (EXIC2)\n");
break;
case 0x4f: case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: case 0x58:
case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f: INVALID_WRITE break;
/* 0x60 - 0x6f - Serial Port 0 */
case 0x60:
case 0x60:
logerror("write: invalid (R/O) Recieve Buffer Register 0 (RxB0)\n");
break;
case 0x61: INVALID_WRITE break;
case 0x62:
case 0x61: INVALID_WRITE break;
case 0x62:
logerror("write: Transmit Buffer Register 0 (TxB0)\n");
break;
case 0x63: case 0x64: INVALID_WRITE break;
case 0x65:
case 0x65:
logerror("write: Serial Reception Macro Service Control Register 0 (SRMS0)\n");
break;
case 0x66:
break;
case 0x66:
logerror("write: Serial Transmission Macro Service Control Register 0 (STMS0)\n");
break;
break;
case 0x67: INVALID_WRITE break;
case 0x68:
case 0x68:
logerror("write: Serial Mode Register 0 (SCM0)\n");
break;
case 0x69:
break;
case 0x69:
logerror("write: Serial Control Register 0 (SCC0)\n");
break;
case 0x6a:
break;
case 0x6a:
logerror("write: Baud Rate Generator Register 0 (BRG0)\n");
break;
case 0x6b:
break;
case 0x6b:
logerror("write: invalid (R/O) Serial Status Register 0 (SCS0)\n");
break;
case 0x6c:
break;
case 0x6c:
logerror("write: Serial Error Interrupt Request Control Register 0 (SEIC0)\n");
break;
case 0x6d:
break;
case 0x6d:
logerror("write: Serial Reception Interrupt Request Control Register 0 (SRIC0)\n");
break;
case 0x6e:
break;
case 0x6e:
logerror("write: Serial Transmission Interrupt Request Control Register 0 (STIC0)\n");
break;
case 0x6f: INVALID_WRITE break;
case 0x6f: INVALID_WRITE break;
/* 0x70 - 0x7f - Serial Port 1 */
case 0x70:
case 0x70:
logerror("write: invalid (R/O) Recieve Buffer Register 0 (RxB1)\n");
break;
case 0x71: INVALID_WRITE break;
case 0x72:
case 0x71: INVALID_WRITE break;
case 0x72:
logerror("write: Transmit Buffer Register 0 (TxB1)\n");
break;
case 0x73: case 0x74: INVALID_WRITE break;
case 0x75:
case 0x75:
logerror("write: Serial Reception Macro Service Control Register 0 (SRMS1)\n");
break;
case 0x76:
break;
case 0x76:
logerror("write: Serial Transmission Macro Service Control Register 0 (STMS1)\n");
break;
break;
case 0x77: INVALID_WRITE break;
case 0x78:
case 0x78:
logerror("write: Serial Mode Register 0 (SCM1)\n");
break;
case 0x79:
break;
case 0x79:
logerror("write: Serial Control Register 0 (SCC1)\n");
break;
case 0x7a:
break;
case 0x7a:
logerror("write: Baud Rate Generator Register 0 (BRG1)\n");
break;
case 0x7b:
break;
case 0x7b:
logerror("write: invalid (R/O) Serial Status Register 0 (SCS1)\n");
break;
case 0x7c:
break;
case 0x7c:
logerror("write: Serial Error Interrupt Request Control Register 0 (SEIC1)\n");
break;
case 0x7d:
break;
case 0x7d:
logerror("write: Serial Reception Interrupt Request Control Register 0 (SRIC1)\n");
break;
case 0x7e:
break;
case 0x7e:
logerror("write: Serial Transmission Interrupt Request Control Register 0 (STIC1)\n");
break;
case 0x7f: INVALID_WRITE break;
case 0x7f: INVALID_WRITE break;
/* 0x80 - 0x9f - Timers */
case 0x80:
case 0x81:
case 0x81:
logerror("write: Timer Register 0 (16-bit) (TM0)\n");
break;
case 0x82:
case 0x83:
case 0x83:
logerror("write: Modulo/Timer Register 0 (16-bit) (MD0)\n");
break;
case 0x84: case 0x85: case 0x86: case 0x87: INVALID_WRITE break;
case 0x84: case 0x85: case 0x86: case 0x87: INVALID_WRITE break;
case 0x88:
case 0x89:
case 0x89:
logerror("write: Timer Register 1 (16-bit) (TM1)\n");
break;
case 0x8a:
case 0x8b:
case 0x8b:
logerror("write: Modulo/Timer Register 1 (16-bit) (MD1)\n");
break;
case 0x8c: case 0x8d: case 0x8e: case 0x8f: INVALID_WRITE break;
case 0x90:
case 0x8c: case 0x8d: case 0x8e: case 0x8f: INVALID_WRITE break;
case 0x90:
logerror("write: Timer Control Register 0 (TMC0)\n");
break;
case 0x91:
case 0x91:
logerror("write: Timer Control Register 1 (TMC1)\n");
break;
break;
case 0x92: case 0x93: INVALID_WRITE break;
case 0x94:
case 0x94:
logerror("write: Timer Unit Macro Service Control Register 0 (TMMS0)\n");
break;
case 0x95:
break;
case 0x95:
logerror("write: Timer Unit Macro Service Control Register 1 (TMMS1)\n");
break;
case 0x96:
break;
case 0x96:
logerror("write: Timer Unit Macro Service Control Register 2 (TMMS2)\n");
break;
case 0x97: case 0x98: case 0x99: case 0x9a: case 0x9b: INVALID_WRITE break;
case 0x9c:
break;
case 0x97: case 0x98: case 0x99: case 0x9a: case 0x9b: INVALID_WRITE break;
case 0x9c:
logerror("write: Timer Interrupt Request Control Register 0 (TMIC0)\n");
break;
case 0x9d:
break;
case 0x9d:
logerror("write: Timer Interrupt Request Control Register 1 (TMIC1)\n");
break;
case 0x9e:
break;
case 0x9e:
logerror("write: Timer Interrupt Request Control Register 2 (TMIC2)\n");
break;
case 0x9f: INVALID_WRITE break;
break;
case 0x9f: INVALID_WRITE break;
/* 0xa0 - 0xdf - DMA Regs */
case 0xa0:
case 0xa0:
logerror("write: DMA Control Register 0 (DMAC0)\n");
break;
case 0xa1:
break;
case 0xa1:
logerror("write: DMA Mode Register 0 (DMAM0)\n");
break;
case 0xa2:
break;
case 0xa2:
logerror("write: DMA Control Register 1 (DMAC1)\n");
break;
case 0xa3:
break;
case 0xa3:
logerror("write: DMA Mode Register 1 (DMAM1)\n");
break;
break;
case 0xa4: case 0xa5: case 0xa6: case 0xa7: case 0xa8: case 0xa9: case 0xaa: case 0xab: INVALID_WRITE break;
case 0xac:
case 0xac:
logerror("write: DMA Interrupt Request Control Register 0 (DIC0)\n");
break;
case 0xad:
break;
case 0xad:
logerror("write: DMA Interrupt Request Control Register 1 (DIC1)\n");
break;
break;
case 0xae: case 0xaf: case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: INVALID_WRITE break;
case 0xc0:
case 0xc0:
logerror("write: Source Address Pointer 0 (Low) (SAR0L)\n");
break;
case 0xc1:
break;
case 0xc1:
logerror("write: Source Address Pointer 0 (Middle) (SAR0M)\n");
break;
case 0xc2:
break;
case 0xc2:
logerror("write: Source Address Pointer 0 (High) (SAR0H)\n");
break;
break;
case 0xc3: INVALID_WRITE break;
case 0xc4:
case 0xc4:
logerror("write: Destination Address Pointer 0 (Low) (DAR0L)\n");
break;
case 0xc5:
break;
case 0xc5:
logerror("write: Destination Address Pointer 0 (Middle) (DAR0M)\n");
break;
case 0xc6:
break;
case 0xc6:
logerror("write: Destination Address Pointer 0 (High) (DAR0H)\n");
break;
break;
case 0xc7: INVALID_WRITE break;
case 0xc8:
case 0xc8:
logerror("write: Terminal Counter 0 (Low) (TC0L)\n");
break;
case 0xc9:
break;
case 0xc9:
logerror("write: Terminal Counter 0 (High) (TC0H)\n");
break;
break;
case 0xca: case 0xcb: case 0xcc: case 0xcd: case 0xce: case 0xcf: INVALID_WRITE break;
case 0xd0:
case 0xd0:
logerror("write: Source Address Pointer 1 (Low) (SAR1L)\n");
break;
case 0xd1:
break;
case 0xd1:
logerror("write: Source Address Pointer 1 (Middle) (SAR1M)\n");
break;
case 0xd2:
break;
case 0xd2:
logerror("write: Source Address Pointer 1 (High) (SAR1H)\n");
break;
break;
case 0xd3: INVALID_WRITE break;
case 0xd4:
case 0xd4:
logerror("write: Destination Address Pointer 1 (Low) (DAR1L)\n");
break;
case 0xd5:
break;
case 0xd5:
logerror("write: Destination Address Pointer 1 (Middle) (DAR1M)\n");
break;
case 0xd6:
case 0xd6:
logerror("write: Destination Address Pointer 1 (High) (DAR1H)\n");
break;
break;
case 0xd7: INVALID_WRITE break;
case 0xd8:
case 0xd8:
logerror("write: Terminal Counter 1 (Low) (TC1L)\n");
break;
case 0xd9:
break;
case 0xd9:
logerror("write: Terminal Counter 1 (High) (TC1H)\n");
break;
case 0xda: case 0xdb: case 0xdc: case 0xdd: case 0xde: case 0xdf: INVALID_WRITE break;
break;
case 0xda: case 0xdb: case 0xdc: case 0xdd: case 0xde: case 0xdf: INVALID_WRITE break;
/* 0xe0 - 0xff misc */
case 0xe0:
case 0xe0:
logerror("write: Standby Control Register (STBC)\n");
break;
case 0xe1:
break;
case 0xe1:
logerror("write: Refresh Mode Register (RFM)\n");
break;
break;
case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: INVALID_WRITE break;
case 0xe8:
case 0xe9:
case 0xe8:
case 0xe9:
logerror("write: Wait Control Register (16-bit) (WTC)\n");
break;
case 0xea:
case 0xea:
logerror("write: User Flag Register (FLAG)\n");
break;
case 0xeb:
break;
case 0xeb:
logerror("write: Processor Control Register (PRC)\n");
break;
case 0xec:
break;
case 0xec:
logerror("write: Time Base Interrupt Request Control Register (TBIC)\n");
break;
break;
case 0xed: case 0xee: INVALID_WRITE break;
case 0xef:
case 0xef:
logerror("write: invalid (R/O) Interrupt Source Register (IRQS)\n");
break;
case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: case 0xf8: case 0xf9: case 0xfa: case 0xfb: INVALID_WRITE break;
case 0xfc:
case 0xfc:
logerror("write: invalid (R/O) Interrupt Priority Register (ISPR)\n");
break;
case 0xfd: case 0xfe: INVALID_WRITE break;
case 0xff:
case 0xff:
logerror("write: internal data area base register (IDB)\n");
break;
break;
}
}

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

@ -307,9 +307,9 @@ static MACHINE_DRIVER_START( tp84 )
MDRV_QUANTUM_TIME(HZ(6000)) /* 100 CPU slices per frame - an high value to ensure proper */
/* synchronization of the CPUs */
MDRV_MACHINE_START(tp84)
/* video hardware */
MDRV_SCREEN_ADD("screen", RASTER)
MDRV_SCREEN_REFRESH_RATE(60)

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

@ -443,4 +443,4 @@ ROM_END
GAME( 1982, tugboat, 0, tugboat, tugboat, 0, ROT90, "ETM", "Tugboat", GAME_IMPERFECT_GRAPHICS )
GAME( 1983, noahsark, 0, tugboat, noahsark, 0, ROT90, "Enter-Tech", "Noah's Ark", GAME_IMPERFECT_GRAPHICS )
GAME( 1984, berenstn, 0, tugboat, noahsark, 0, ROT90, "Enter-Tech", "The Berenstain Bears in Big Paw's Cave", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_COLORS )
GAME( 1984, berenstn, 0, tugboat, noahsark, 0, ROT90, "Enter-Tech", "The Berenstain Bears in Big Paw's Cave", GAME_IMPERFECT_GRAPHICS | GAME_IMPERFECT_COLORS )

6
src/mame/drivers/xain.c
View File

@ -390,7 +390,7 @@ static CUSTOM_INPUT( mcu_status_r )
return 3;
}
return res;
return res;
}
READ8_HANDLER( mcu_comm_reset_r )
@ -450,8 +450,8 @@ static ADDRESS_MAP_START( mcu_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x0004, 0x0004) AM_WRITE(xain_68705_ddr_a_w)
AM_RANGE(0x0005, 0x0005) AM_WRITE(xain_68705_ddr_b_w)
AM_RANGE(0x0006, 0x0006) AM_WRITE(xain_68705_ddr_c_w)
// AM_RANGE(0x0008, 0x0008) AM_READWRITE(m68705_tdr_r, m68705_tdr_w)
// AM_RANGE(0x0009, 0x0009) AM_READWRITE(m68705_tcr_r, m68705_tcr_w)
// AM_RANGE(0x0008, 0x0008) AM_READWRITE(m68705_tdr_r, m68705_tdr_w)
// AM_RANGE(0x0009, 0x0009) AM_READWRITE(m68705_tcr_r, m68705_tcr_w)
AM_RANGE(0x0010, 0x007f) AM_RAM
AM_RANGE(0x0080, 0x07ff) AM_ROM
ADDRESS_MAP_END

64
src/mame/machine/dec0.c
View File

@ -293,37 +293,37 @@ static WRITE16_HANDLER( hippodrm_68000_share_w )
/******************************************************************************/
/*
Heavy Barrel I8751 connections
P0.0 - P0.7 <-> 4 * LS374 latches 8B,8C,7B,7C
Heavy Barrel I8751 connections
P1.0 -> MIXFLG1
P1.1 -> MIXFLG2
P1.2 -> B0FLG
P1.3 -> B1FLG1
P1.4 -> B1FLG2
P1.5 -> SOUNDFLG1
P1.6 -> SOUNDFLG2
P0.0 - P0.7 <-> 4 * LS374 latches 8B,8C,7B,7C
P2.0 -> B2FLG 0
P2.1 -> B2FLG 1
P2.2 <- SEL2
P2.3 -> acknowledge INT1
P2.4 -> Enable latch 7B
P2.5 -> Enable latch 8B
P2.6 -> Enable latch 8C
P2.7 -> Enable latch 7C
P3.0 -> CRBACK0
P3.1 -> CRBACK1
P3.2 -> CRBACK2
P3.3 <- /INT1
P3.5 <- SEL3
P3.6 <- SEL4
P3.7 <- SEL5
The outputs to the graphics & audio hardware are not directly emulated, but the
values are not known to change after bootup.
P1.0 -> MIXFLG1
P1.1 -> MIXFLG2
P1.2 -> B0FLG
P1.3 -> B1FLG1
P1.4 -> B1FLG2
P1.5 -> SOUNDFLG1
P1.6 -> SOUNDFLG2
P2.0 -> B2FLG 0
P2.1 -> B2FLG 1
P2.2 <- SEL2
P2.3 -> acknowledge INT1
P2.4 -> Enable latch 7B
P2.5 -> Enable latch 8B
P2.6 -> Enable latch 8C
P2.7 -> Enable latch 7C
P3.0 -> CRBACK0
P3.1 -> CRBACK1
P3.2 -> CRBACK2
P3.3 <- /INT1
P3.5 <- SEL3
P3.6 <- SEL4
P3.7 <- SEL5
The outputs to the graphics & audio hardware are not directly emulated, but the
values are not known to change after bootup.
*/
static UINT8 i8751_ports[4];
@ -331,7 +331,7 @@ static UINT8 i8751_ports[4];
READ8_HANDLER(dec0_mcu_port_r )
{
int latchEnable=i8751_ports[2]>>4;
// P0 connected to 4 latches
if (offset==0)
{
@ -344,7 +344,7 @@ READ8_HANDLER(dec0_mcu_port_r )
else if ((latchEnable&8)==0)
return i8751_return&0xff;
}
return 0xff;
}
@ -357,7 +357,7 @@ WRITE8_HANDLER(dec0_mcu_port_w )
if ((data&0x4)==0)
cputag_set_input_line(space->machine, "maincpu", 5, HOLD_LINE);
if ((data&0x8)==0)
cputag_set_input_line(space->machine, "mcu", MCS51_INT1_LINE, CLEAR_LINE);
cputag_set_input_line(space->machine, "mcu", MCS51_INT1_LINE, CLEAR_LINE);
if ((data&0x40)==0)
i8751_return=(i8751_return&0xff00)|(i8751_ports[0]);
if ((data&0x80)==0)

2
src/mame/machine/namcos1.c
View File

@ -602,7 +602,7 @@ WRITE8_HANDLER( namcos1_watchdog_w )
wdog |= 2;
else if (space->cpu == space->machine->device("audiocpu"))
wdog |= 4;
if (wdog == 7 || !namcos1_reset)
{
wdog = 0;

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

@ -560,7 +560,7 @@ static void cclimber_draw_sprites(bitmap_t *bitmap, const rectangle *cliprect, c
{
int x = cclimber_spriteram[offs + 3] + 1;
/* x + 1 is evident in cclimber and ckong. It looks worse,
but it has been confirmed on several PCBs. */
but it has been confirmed on several PCBs. */
int y = 240 - cclimber_spriteram[offs + 2];

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

@ -4027,7 +4027,7 @@ WRITE8_HANDLER( K053247_w )
else
K053247_ram[offs] = (K053247_ram[offs] & 0x00ff) | (data<<8);
}
#endif
#endif
// Mystic Warriors hardware games support a non-OBJCHA based ROM readback
// write the address to the 246 as usual, but there's a completely separate ROM

2
src/mame/video/segaic16.h
View File

@ -329,4 +329,4 @@ static const sega16sp_interface xboard_sega16sp_intf =
extern struct palette_info segaic16_palette;
extern struct rotate_info segaic16_rotate[SEGAIC16_MAX_ROTATE];
extern struct road_info segaic16_road[SEGAIC16_MAX_ROADS];
extern struct road_info segaic16_road[SEGAIC16_MAX_ROADS];

2
src/osd/windows/debugwin.c
View File

@ -2425,7 +2425,7 @@ void console_create_window(running_machine *machine)
// set the view and fetch the width
info->view[0].view->set_source(*source);
dischars = info->view[0].view->total_size().x;
// compute the preferred width
minwidth = EDGE_WIDTH + main_console_regwidth * debug_font_width + vscroll_width + 2 * EDGE_WIDTH + 100 + EDGE_WIDTH;
maxwidth = EDGE_WIDTH + main_console_regwidth * debug_font_width + vscroll_width + 2 * EDGE_WIDTH + MAX(dischars, conchars) * debug_font_width + vscroll_width + EDGE_WIDTH;

98
src/osd/windows/winmain.c
View File

@ -105,12 +105,12 @@ public:
// bool to test if the function is NULL or not
operator bool() const { return (m_function != NULL); }
// dereference to get the underlying pointer
func_ptr operator *() const { return m_function; }
private:
func_ptr m_function;
func_ptr m_function;
};
@ -118,14 +118,14 @@ class stack_walker
{
public:
stack_walker();
FPTR ip() const { return m_stackframe.AddrPC.Offset; }
FPTR sp() const { return m_stackframe.AddrStack.Offset; }
FPTR frame() const { return m_stackframe.AddrFrame.Offset; }
void reset(CONTEXT &context, HANDLE thread);
bool unwind();
private:
HANDLE m_process;
HANDLE m_thread;
@ -138,7 +138,7 @@ private:
dynamic_bind<BOOL (WINAPI *)(HANDLE, LPCTSTR, BOOL)> m_sym_initialize;
dynamic_bind<PVOID (WINAPI *)(HANDLE, DWORD64)> m_sym_function_table_access_64;
dynamic_bind<DWORD64 (WINAPI *)(HANDLE, DWORD64)> m_sym_get_module_base_64;
static bool s_initialized;
};
@ -149,10 +149,10 @@ public:
// construction/destruction
symbol_manager(const char *argv0);
~symbol_manager();
// getters
FPTR last_base() const { return m_last_base; }
// core symbol lookup
const char *symbol_for_address(FPTR address);
const char *symbol_for_address(PVOID address) { return symbol_for_address(reinterpret_cast<FPTR>(address)); }
@ -197,11 +197,11 @@ class sampling_profiler
public:
sampling_profiler(UINT32 max_seconds, UINT8 stack_depth);
~sampling_profiler();
void start();
void stop();
// void reset();
// void reset();
void print_results(symbol_manager &symbols);
private:
@ -210,7 +210,7 @@ private:
static int CLIB_DECL compare_address(const void *item1, const void *item2);
static int CLIB_DECL compare_frequency(const void *item1, const void *item2);
HANDLE m_target_thread;
HANDLE m_thread;
@ -549,7 +549,7 @@ static void osd_exit(running_machine &machine)
profiler->print_results(*symbols);
global_free(profiler);
}
// turn off our multimedia tasks
// if (av_revert_mm_thread_characteristics)
// (*av_revert_mm_thread_characteristics)(mm_task);
@ -790,7 +790,7 @@ void stack_walker::reset(CONTEXT &initial, HANDLE thread)
m_stackframe.AddrPC.Mode = AddrModeFlat;
m_stackframe.AddrFrame.Mode = AddrModeFlat;
m_stackframe.AddrStack.Mode = AddrModeFlat;
// pull architecture-specific fields from the context
#ifdef PTR64
m_stackframe.AddrPC.Offset = m_context.Rip;
@ -855,7 +855,7 @@ symbol_manager::symbol_manager(const char *argv0)
if (extoffs != -1)
m_mapfile.substr(0, extoffs);
m_mapfile.cat(".map");
// and the name of the symfile
extoffs = m_symfile.rchr(0, '.');
if (extoffs != -1)
@ -905,7 +905,7 @@ const char *symbol_manager::symbol_for_address(FPTR address)
// if that fails, scan the cache if we have one
if (m_cache != NULL)
scan_cache_for_address(address);
// or else try to open a sym/map file and find it there
else
scan_file_for_address(address, false);
@ -961,13 +961,13 @@ void symbol_manager::scan_file_for_address(FPTR address, bool create_cache)
{
bool is_symfile = false;
FILE *srcfile = NULL;
#ifdef __GNUC__
// see if we have a symbol file (gcc only)
srcfile = fopen(m_symfile, "r");
is_symfile = (srcfile != NULL);
#endif
// if not, see if we have a map file
if (srcfile == NULL)
srcfile = fopen(m_mapfile, "r");
@ -999,7 +999,7 @@ void symbol_manager::scan_file_for_address(FPTR address, bool create_cache)
best_addr = addr;
best_symbol = symbol;
}
// also create a cache entry if we can
if (create_cache)
{
@ -1008,10 +1008,10 @@ void symbol_manager::scan_file_for_address(FPTR address, bool create_cache)
}
}
}
// close the file
fclose(srcfile);
// format the symbol and remember the last base
format_symbol(best_symbol, address - best_addr);
m_last_base = best_addr;
@ -1028,17 +1028,17 @@ void symbol_manager::scan_cache_for_address(FPTR address)
// reset the best info
astring best_symbol;
FPTR best_addr = 0;
// walk the cache, looking for valid entries
for (cache_entry *entry = m_cache; entry != NULL; entry = entry->m_next)
// if this is the best one so far, remember it
if (entry->m_address <= address && entry->m_address > best_addr)
{
best_addr = entry->m_address;
best_symbol = entry->m_name;
}
// format the symbol and remember the last base
format_symbol(best_symbol, address - best_addr);
m_last_base = best_addr;
@ -1054,13 +1054,13 @@ bool symbol_manager::parse_sym_line(const char *line, FPTR &address, astring &sy
{
#ifdef __GNUC__
/*
32-bit gcc symbol line:
32-bit gcc symbol line:
[271778](sec 1)(fl 0x00)(ty 20)(scl 3) (nx 0) 0x007df675 line_to_symbol(char const*, unsigned int&, bool)
64-bit gcc symbol line:
64-bit gcc symbol line:
[271775](sec 1)(fl 0x00)(ty 20)(scl 3) (nx 0) 0x00000000008dd1e9 line_to_symbol(char const*, unsigned long long&, bool)
*/
// first look for a (ty) entry
const char *type = strstr(line, "(ty 20)");
if (type == NULL)
@ -1075,7 +1075,7 @@ bool symbol_manager::parse_sym_line(const char *line, FPTR &address, astring &sy
in_parens = true;
else if (*chptr == ')')
in_parens = false;
// otherwise, look for an 0x address
else if (!in_parens && *chptr == '0' && chptr[1] == 'x')
{
@ -1084,11 +1084,11 @@ bool symbol_manager::parse_sym_line(const char *line, FPTR &address, astring &sy
if (sscanf(chptr, "0x%p", &temp) != 1)
return false;
address = m_text_base + reinterpret_cast<FPTR>(temp);
// skip forward until we're past the space
while (*chptr != 0 && !isspace(*chptr))
chptr++;
// extract the symbol name
symbol.cpy(chptr).trimspace();
return (symbol.len() > 0);
@ -1123,12 +1123,12 @@ bool symbol_manager::parse_map_line(const char *line, FPTR &address, astring &sy
if (sscanf(&line[16], "0x%p", &temp) != 1)
return false;
address = reinterpret_cast<FPTR>(temp);
// skip forward until we're past the space
const char *chptr = &line[16];
while (*chptr != 0 && !isspace(*chptr))
chptr++;
// extract the symbol name
symbol.cpy(chptr).trimspace();
return (symbol.len() > 0);
@ -1143,7 +1143,7 @@ bool symbol_manager::parse_map_line(const char *line, FPTR &address, astring &sy
//-------------------------------------------------
void symbol_manager::format_symbol(const char *name, UINT32 displacement, const char *filename, int linenumber)
{
{
// start with the address and offset
m_buffer.printf(" (%s", name);
if (displacement != 0)
@ -1156,7 +1156,7 @@ void symbol_manager::format_symbol(const char *name, UINT32 displacement, const
// close up the string
m_buffer.cat(")");
}
//-------------------------------------------------
// get_text_section_base - figure out the base
@ -1171,20 +1171,20 @@ FPTR symbol_manager::get_text_section_base()
// start with the image base
PVOID base = reinterpret_cast<PVOID>(GetModuleHandle(NULL));
assert(base != NULL);
// make sure we have the functions we need
if (image_nt_header != NULL && image_rva_to_section != NULL)
{
// get the NT header
PIMAGE_NT_HEADERS headers = (*image_nt_header)(base);
assert(headers != NULL);
// look ourself up (assuming we are in the .text section)
PIMAGE_SECTION_HEADER section = (*image_rva_to_section)(headers, base, reinterpret_cast<FPTR>(get_text_section_base) - reinterpret_cast<FPTR>(base));
if (section != NULL)
return reinterpret_cast<FPTR>(base) + section->VirtualAddress;
}
// fallback to returning the image base (wrong)
return reinterpret_cast<FPTR>(base);
}
@ -1255,7 +1255,7 @@ void sampling_profiler::stop()
// set the flag and wait a couple of seconds (max)
m_thread_exit = true;
WaitForSingleObject(m_thread, 2000);
// regardless, close the handle
CloseHandle(m_thread);
}
@ -1272,18 +1272,18 @@ int CLIB_DECL sampling_profiler::compare_address(const void *item1, const void *
const FPTR *entry2 = reinterpret_cast<const FPTR *>(item2);
int mincount = MIN(entry1[0], entry2[0]);
// sort in order of: bucket, caller, caller's caller, etc.
// sort in order of: bucket, caller, caller's caller, etc.
for (int index = 1; index <= mincount; index++)
if (entry1[index] != entry2[index])
return entry1[index] - entry2[index];
// if we match to the end, sort by the depth of the stack
return entry1[0] - entry2[0];
}
//-------------------------------------------------
// compare_frequency - compare two entries by
// compare_frequency - compare two entries by
// their frequency of occurrence
//-------------------------------------------------
@ -1312,15 +1312,15 @@ void sampling_profiler::print_results(symbol_manager &symbols)
for (FPTR *current = m_buffer; current < m_buffer_ptr; current += m_entry_stride)
{
assert(current[0] >= 1 && current[0] < m_entry_stride);
// convert the sampled PC to its function base as a bucket
symbols.symbol_for_address(current[1]);
current[1] = symbols.last_base();
}
// step 2: sort the results
qsort(m_buffer, (m_buffer_ptr - m_buffer) / m_entry_stride, m_entry_stride * sizeof(FPTR), compare_address);
// step 3: count and collapse unique entries
UINT32 total_count = 0;
for (FPTR *current = m_buffer; current < m_buffer_ptr; )
@ -1341,7 +1341,7 @@ void sampling_profiler::print_results(symbol_manager &symbols)
// step 4: sort the results again, this time by frequency
qsort(m_buffer, (m_buffer_ptr - m_buffer) / m_entry_stride, m_entry_stride * sizeof(FPTR), compare_frequency);
// step 5: print the results
UINT32 num_printed = 0;
for (FPTR *current = m_buffer; current < m_buffer_ptr && num_printed < 30; current += m_entry_stride)
@ -1349,7 +1349,7 @@ void sampling_profiler::print_results(symbol_manager &symbols)
// once we hit 0 frequency, we're done
if (current[0] == 0)
break;
// output the result
printf("%4.1f%% - %6d : %p%s\n", (double)current[0] * 100.0 / (double)total_count, (UINT32)current[0], reinterpret_cast<void *>(current[1]), symbols.symbol_for_address(current[1]));
for (int index = 2; index < m_entry_stride; index++)
@ -1392,11 +1392,11 @@ void sampling_profiler::thread_run()
SuspendThread(m_target_thread);
context.ContextFlags = CONTEXT_FULL;
GetThreadContext(m_target_thread, &context);
// first entry is a count
FPTR *count = m_buffer_ptr++;
*count = 0;
// iterate over the frames until we run out or hit an error
walker.reset(context, m_target_thread);
int frame;
@ -1405,11 +1405,11 @@ void sampling_profiler::thread_run()
*m_buffer_ptr++ = walker.ip();
*count += 1;
}
// fill in any missing parts with NULLs
for (; frame <= m_stack_depth; frame++)
*m_buffer_ptr++ = 0;
// resume the thread
ResumeThread(m_target_thread);

2
src/version.c
View File

@ -10,4 +10,4 @@
***************************************************************************/
extern const char build_version[];
const char build_version[] = "0.138u2 ("__DATE__")";
const char build_version[] = "0.138u3 ("__DATE__")";