Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-08 03:12:37 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanups and version bump

Browse Source
This commit is contained in:
Angelo Salese 2011-06-05 22:35:20 +00:00
parent 910fff0955
commit a449c766a2
89 changed files with 387 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/build/makelist.c
View File

@ -63,7 +63,7 @@ int sort_callback(const void *elem1, const void *elem2)
//-------------------------------------------------
// parse_file - parse a single file, may be
// parse_file - parse a single file, may be
// called recursively
//-------------------------------------------------
@ -143,7 +143,7 @@ int parse_file(const char *srcfile)
parse_file(filename);
continue;
}
// otherwise treat as a driver name
char drivname[32];
drivname[0] = 0;

2
src/emu/attotime.c
View File

@ -148,7 +148,7 @@ const char *attotime::as_string(int precision) const
static char buffers[8][30];
static int nextbuf;
char *buffer = &buffers[nextbuf++ % 8][0];
// special case: never
if (*this == never)
sprintf(buffer, "%-*s", precision, "(never)");

4
src/emu/cpu/am29000/am29ops.h
View File

@ -1059,7 +1059,7 @@ static void LOADM(am29000_state *am29000)
static void STORE(am29000_state *am29000)
{
UINT32 addr = INST_M_BIT ? I8: GET_RB_VAL;
// UINT32 r;
// UINT32 r;
if (INST_UA_BIT)
fatalerror("Am29000: UA bit set on LOAD\n");
@ -1067,7 +1067,7 @@ static void STORE(am29000_state *am29000)
if (INST_CE_BIT)
{
logerror("Am29000: Attempting a co-processor LOAD!\n");
// r = 0;
// r = 0;
}
else
{

4
src/emu/cpu/i386/i386ops.c
View File

@ -1018,7 +1018,7 @@ static void I386OP(repeat)(i386_state *cpustate, int invert_flag)
UINT32 repeated_eip = cpustate->eip;
UINT32 repeated_pc = cpustate->pc;
UINT8 opcode; // = FETCH(cpustate);
// UINT32 eas, ead;
// UINT32 eas, ead;
UINT32 count;
INT32 cycle_base = 0, cycle_adjustment = 0;
UINT8 prefix_flag=1;
@ -1070,7 +1070,7 @@ static void I386OP(repeat)(i386_state *cpustate, int invert_flag)
// FIXME: the following does not work if both address override and segment override are used
i386_translate(cpustate, cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI) );
} else {
//eas =
//eas =
i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI) );
}
i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI) );

2
src/emu/cpu/i86/instr286.c
View File

@ -841,7 +841,7 @@ static void PREFIX286(_escape_7)(i8086_state *cpustate) /* Opcode 0xdf */
if ((cpustate->msw&8) || (cpustate->msw&4)) throw TRAP(FPU_UNAVAILABLE,-1);
unsigned ModRM = FETCH;
ICOUNT -= timing.nop;
GetRMByte(ModRM);
GetRMByte(ModRM);
if (ModRM == 0xe0) cpustate->regs.w[AX] = 0xffff; // FPU not present
}

4
src/emu/cpu/i86/instr86.c
View File

@ -1177,8 +1177,8 @@ static void PREFIX86(_cmp_axd16)(i8086_state *cpustate) /* Opcode 0x3d */
static void PREFIX86(_aas)(i8086_state *cpustate) /* Opcode 0x3f */
{
// UINT8 ALcarry=1;
// if (cpustate->regs.b[AL]>0xf9) ALcarry=2;
// UINT8 ALcarry=1;
// if (cpustate->regs.b[AL]>0xf9) ALcarry=2;
if (AF || ((cpustate->regs.b[AL] & 0xf) > 9))
{

16
src/emu/cpu/i86/table286.h
View File

@ -221,14 +221,14 @@ static void (*const PREFIX286(_instruction)[256])(i8086_state *cpustate) =
PREFIX86(_aad), /* 0xd5 */
PREFIX286(_invalid),
PREFIX86(_xlat), /* 0xd7 */
PREFIX286(_escape), /* 0xd8 */
PREFIX286(_escape), /* 0xd9 */
PREFIX286(_escape), /* 0xda */
PREFIX286(_escape), /* 0xdb */
PREFIX286(_escape), /* 0xdc */
PREFIX286(_escape), /* 0xdd */
PREFIX286(_escape), /* 0xde */
PREFIX286(_escape_7), /* 0xdf */
PREFIX286(_escape), /* 0xd8 */
PREFIX286(_escape), /* 0xd9 */
PREFIX286(_escape), /* 0xda */
PREFIX286(_escape), /* 0xdb */
PREFIX286(_escape), /* 0xdc */
PREFIX286(_escape), /* 0xdd */
PREFIX286(_escape), /* 0xde */
PREFIX286(_escape_7), /* 0xdf */
PREFIX86(_loopne), /* 0xe0 */
PREFIX86(_loope), /* 0xe1 */
PREFIX86(_loop), /* 0xe2 */

2
src/emu/cpu/konami/konamops.c
View File

@ -300,7 +300,7 @@ INLINE void bra( konami_state *cpustate )
}
/* $21 BRN relative ----- */
static UINT8 konami_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
static UINT8 konami_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
INLINE void brn( konami_state *cpustate )
{
IMMBYTE(cpustate, konami_brn_t);

2
src/emu/cpu/m6800/6800ops.c
View File

@ -233,7 +233,7 @@ OP_HANDLER( bra )
}
/* $21 BRN relative ----- */
static UINT8 m6800_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
static UINT8 m6800_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
OP_HANDLER( brn )
{
IMMBYTE(m6800_brn_t);

6
src/emu/cpu/m68000/m68kfpu.c
View File

@ -257,9 +257,9 @@ INLINE void store_pack_float80(m68ki_cpu_core *m68k, UINT32 ea, int k, floatx80
INLINE void SET_CONDITION_CODES(m68ki_cpu_core *m68k, floatx80 reg)
{
// UINT64 *regi;
// UINT64 *regi;
// regi = (UINT64 *)®
// regi = (UINT64 *)®
REG_FPSR &= ~(FPCC_N|FPCC_Z|FPCC_I|FPCC_NAN);
@ -1341,7 +1341,7 @@ static void fpgen_rm_reg(m68ki_cpu_core *m68k, UINT16 w2)
}
case 0x1e: // FGETEXP
{
// floatx80 temp = source;
// floatx80 temp = source;
INT16 temp2;
temp2 = source.high; // get the exponent

2
src/emu/cpu/m6805/6805ops.c
View File

@ -77,7 +77,7 @@ OP_HANDLER( bra )
}
/* $21 BRN relative ---- */
static UINT8 m6805_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
static UINT8 m6805_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
OP_HANDLER( brn )
{
IMMBYTE(m6805_brn_t);

2
src/emu/cpu/m6809/6809ops.c
View File

@ -371,7 +371,7 @@ OP_HANDLER( bra )
}
/* $21 BRN relative ----- */
static UINT8 m6809_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
static UINT8 m6809_brn_t; // hack around GCC 4.6 error because we need the side effects of IMMBYTE
OP_HANDLER( brn )
{
IMMBYTE(m6809_brn_t);

4
src/emu/cpu/minx/minx.c
View File

@ -169,14 +169,14 @@ INLINE UINT16 rdop16( minx_state *minx )
static CPU_EXECUTE( minx )
{
// UINT32 oldpc;
// UINT32 oldpc;
UINT8 op;
minx_state *minx = get_safe_token(device);
do
{
debugger_instruction_hook(device, GET_MINX_PC);
// oldpc = GET_MINX_PC;
// oldpc = GET_MINX_PC;
if ( minx->interrupt_pending )
{

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

@ -312,7 +312,7 @@ void mips3com_tlbwr(mips3_state *mips)
void mips3com_tlbp(mips3_state *mips)
{
UINT32 tlbindex;
// UINT64 vpn;
// UINT64 vpn;
/* iterate over TLB entries */
for (tlbindex = 0; tlbindex < mips->tlbentries; tlbindex++)
@ -329,7 +329,7 @@ void mips3com_tlbp(mips3_state *mips)
}
/* validate that our tlb_table was in sync */
// vpn = ((mips->cpr[0][COP0_EntryHi] >> 13) & 0x07ffffff) << 1;
// vpn = ((mips->cpr[0][COP0_EntryHi] >> 13) & 0x07ffffff) << 1;
if (tlbindex != mips->tlbentries)
mips->cpr[0][COP0_Index] = tlbindex;
else

6
src/emu/hashfile.c
View File

@ -178,7 +178,7 @@ static void start_handler(void *data, const char *tagname, const char **attribut
hash_collection hashes;
astring all_functions;
char functions;
// iodevice_t device;
// iodevice_t device;
int i;
switch(state->pos)
@ -198,7 +198,7 @@ static void start_handler(void *data, const char *tagname, const char **attribut
{
// we are now examining a hash tag
name = NULL;
// device = IO_COUNT;
// device = IO_COUNT;
while(attributes[0])
{
@ -231,7 +231,7 @@ static void start_handler(void *data, const char *tagname, const char **attribut
unknown_attribute_value(state, attributes[0], attributes[1]);
else
{
// device = (iodevice_t) i;
// device = (iodevice_t) i;
}
}
else

2
src/emu/inptport.c
View File

@ -2886,7 +2886,7 @@ input_field_config::input_field_config(input_port_config &port, int _type, input
memset(&condition, 0, sizeof(condition));
for (int seqtype = 0; seqtype < ARRAY_LENGTH(seq); seqtype++)
seq[seqtype].set_default();
chars[0] = chars[1] = chars[2] = (unicode_char) 0;
chars[0] = chars[1] = chars[2] = (unicode_char) 0;
}

2
src/emu/inptport.h
View File

@ -727,7 +727,7 @@ private:
class input_type_entry
{
friend class simple_list<input_type_entry>;
public:
input_type_entry(UINT32 type, ioport_group group, int player, const char *token, const char *name, input_seq standard);
input_type_entry(UINT32 type, ioport_group group, int player, const char *token, const char *name, input_seq standard, input_seq decrement, input_seq increment);

76
src/emu/input.c
View File

@ -131,12 +131,12 @@ class input_device_switch_item : public input_device_item
public:
// construction/destruction
input_device_switch_item(input_device &device, const char *name, void *internal, input_item_id itemid, item_get_state_func getstate);
// readers
virtual INT32 read_as_switch(input_item_modifier modifier);
virtual INT32 read_as_relative(input_item_modifier modifier);
virtual INT32 read_as_absolute(input_item_modifier modifier);
// steadykey helper
bool steadykey_changed();
void steadykey_update_to_current() { m_steadykey = m_current; }
@ -156,7 +156,7 @@ class input_device_relative_item : public input_device_item
public:
// construction/destruction
input_device_relative_item(input_device &device, const char *name, void *internal, input_item_id itemid, item_get_state_func getstate);
// readers
virtual INT32 read_as_switch(input_item_modifier modifier);
virtual INT32 read_as_relative(input_item_modifier modifier);
@ -172,7 +172,7 @@ class input_device_absolute_item : public input_device_item
public:
// construction/destruction
input_device_absolute_item(input_device &device, const char *name, void *internal, input_item_id itemid, item_get_state_func getstate);
// readers
virtual INT32 read_as_switch(input_item_modifier modifier);
virtual INT32 read_as_relative(input_item_modifier modifier);
@ -192,7 +192,7 @@ struct code_string_table
return current->m_code;
return ~0;
}
const char *operator[](UINT32 code) const
{
for (const code_string_table *current = this; current->m_code != ~0; current++)
@ -650,7 +650,7 @@ UINT8 joystick_map::update(INT32 xaxisval, INT32 yaxisval)
//**************************************************************************
//-------------------------------------------------
// input_code - construct an input code from a
// input_code - construct an input code from a
// device/item pair
//-------------------------------------------------
@ -669,7 +669,7 @@ input_code::input_code(input_device &device, input_item_id itemid)
//**************************************************************************
//-------------------------------------------------
// operator+= - append a code to the end of an
// operator+= - append a code to the end of an
// input sequence
//-------------------------------------------------
@ -687,8 +687,8 @@ input_seq &input_seq::operator+=(input_code code)
//-------------------------------------------------
// operator|= - append a code to a sequence; if
// the sequence is non-empty, insert an OR
// operator|= - append a code to a sequence; if
// the sequence is non-empty, insert an OR
// before the new code
//-------------------------------------------------
@ -697,7 +697,7 @@ input_seq &input_seq::operator|=(input_code code)
// overwrite end/default with the new code
if (m_code[0] == end_code || m_code[0] == default_code)
m_code[0] = code;
// otherwise, append an OR token and then the new code
else
{
@ -723,7 +723,7 @@ int input_seq::length() const
//-------------------------------------------------
// is_valid - return true if a given sequence is
// is_valid - return true if a given sequence is
// valid
//-------------------------------------------------
@ -817,7 +817,7 @@ void input_seq::set(input_code code0, input_code code1, input_code code2, input_
//-------------------------------------------------
// backspace - "backspace" over the last entry in
// backspace - "backspace" over the last entry in
// a sequence
//-------------------------------------------------
@ -908,7 +908,7 @@ input_item_id input_device::add_item(const char *name, input_item_id itemid, ite
// make sure we don't have any overlap
assert(m_item[itemid] == NULL);
// determine the class and create the appropriate item class
input_device_item *item = NULL;
switch (m_class.standard_item_class(originalid))
@ -924,7 +924,7 @@ input_item_id input_device::add_item(const char *name, input_item_id itemid, ite
case ITEM_CLASS_ABSOLUTE:
item = auto_alloc(machine(), input_device_absolute_item(*this, name, internal, itemid, getstate));
break;
default:
assert(false);
}
@ -983,7 +983,7 @@ void input_device::apply_steadykey() const
// ignore if not enabled
if (!m_steadykey_enabled)
return;
// update the state of all the keys and see if any changed state
bool anything_changed = false;
for (input_item_id itemid = ITEM_ID_FIRST_VALID; itemid <= m_maxitem; itemid++)
@ -1040,7 +1040,7 @@ input_device *input_class::add_device(const char *name, void *internal)
for (devindex = 0; devindex < DEVICE_INDEX_MAXIMUM; devindex++)
if (m_device[devindex] == NULL)
break;
// call through
return add_device(devindex, name, internal);
}
@ -1064,7 +1064,7 @@ input_device *input_class::add_device(int devindex, const char *name, void *inte
//-------------------------------------------------
// standard_item_class - return the class of a
// standard_item_class - return the class of a
// standard item
//-------------------------------------------------
@ -1129,7 +1129,7 @@ input_manager::input_manager(running_machine &machine)
//-------------------------------------------------
// code_value - return the value of a given
// code_value - return the value of a given
// input code
//-------------------------------------------------
@ -1145,7 +1145,7 @@ INT32 input_manager::code_value(input_code code)
input_device *device = device_from_code(code);
if (device == NULL)
break;
// also return 0 if the device class is disabled
input_class &devclass = *m_class[code.device_class()];
if (!devclass.enabled())
@ -1200,8 +1200,8 @@ INT32 input_manager::code_value(input_code code)
//-------------------------------------------------
// code_pressed_once - return non-zero if a given
// input code has transitioned from off to on
// code_pressed_once - return non-zero if a given
// input code has transitioned from off to on
// since the last call
//-------------------------------------------------
@ -1352,7 +1352,7 @@ input_code input_manager::poll_switches()
//-------------------------------------------------
// poll_keyboard_switches - poll for any
// poll_keyboard_switches - poll for any
// keyboard-specific input
//-------------------------------------------------
@ -1385,7 +1385,7 @@ input_code input_manager::poll_keyboard_switches()
//-------------------------------------------------
// code_check_axis - see if axis has moved far
// code_check_axis - see if axis has moved far
// enough to trigger a read when polling
//-------------------------------------------------
@ -1398,7 +1398,7 @@ bool input_manager::code_check_axis(input_device_item &item, input_code code)
// ignore min/max for lightguns
// so the selection will not be affected by a gun going out of range
INT32 curval = code_value(code);
if (code.device_class() == DEVICE_CLASS_LIGHTGUN &&
if (code.device_class() == DEVICE_CLASS_LIGHTGUN &&
(code.item_id() == ITEM_ID_XAXIS || code.item_id() == ITEM_ID_YAXIS) &&
(curval == INPUT_ABSOLUTE_MAX || curval == INPUT_ABSOLUTE_MIN))
return false;
@ -1486,14 +1486,14 @@ input_device_item *input_manager::item_from_code(input_code code) const
input_device *device = device_from_code(code);
if (device == NULL)
return NULL;
// then return the device's item
return device->item(code.item_id());
}
//-------------------------------------------------
// reset_memory - reset the array of memory for
// reset_memory - reset the array of memory for
// pressed switches
//-------------------------------------------------
@ -1506,7 +1506,7 @@ void input_manager::reset_memory()
//-------------------------------------------------
// code_from_itemid - translates an input_item_id
// code_from_itemid - translates an input_item_id
// to an input_code
//-------------------------------------------------
@ -1625,7 +1625,7 @@ const char *input_manager::code_to_token(astring &string, input_code code) const
//-------------------------------------------------
// code_from_token - extract an input code from a
// code_from_token - extract an input code from a
// token
//-------------------------------------------------
@ -1729,7 +1729,7 @@ input_code input_manager::code_from_token(const char *_token)
//-------------------------------------------------
// seq_pressed - return true if the given sequence
// seq_pressed - return true if the given sequence
// of switch inputs is "pressed"
//-------------------------------------------------
@ -1781,7 +1781,7 @@ bool input_manager::seq_pressed(const input_seq &seq)
//-------------------------------------------------
// seq_axis_value - return the value of an axis
// seq_axis_value - return the value of an axis
// defined in an input sequence
//-------------------------------------------------
@ -1866,7 +1866,7 @@ INT32 input_manager::seq_axis_value(const input_seq &seq, input_item_class &item
//-------------------------------------------------
// seq_poll_start - begin polling for a new
// seq_poll_start - begin polling for a new
// sequence of the given itemclass
//-------------------------------------------------
@ -1990,7 +1990,7 @@ bool input_manager::seq_poll()
//-------------------------------------------------
// seq_name - generate the friendly name of a
// seq_name - generate the friendly name of a
// sequence
//-------------------------------------------------
@ -2043,7 +2043,7 @@ const char *input_manager::seq_name(astring &string, const input_seq &seq) const
//-------------------------------------------------
// seq_to_tokens - generate the tokenized form of
// seq_to_tokens - generate the tokenized form of
// a sequence
//-------------------------------------------------
@ -2078,7 +2078,7 @@ const char *input_manager::seq_to_tokens(astring &string, const input_seq &seq)
//-------------------------------------------------
// seq_from_tokens - generate the tokenized form
// seq_from_tokens - generate the tokenized form
// of a sequence
//-------------------------------------------------
@ -2130,7 +2130,7 @@ void input_manager::seq_from_tokens(input_seq &seq, const char *string)
//-------------------------------------------------
// set_global_joystick_map - set the joystick map
// set_global_joystick_map - set the joystick map
// for all devices
//-------------------------------------------------
@ -2360,7 +2360,7 @@ INT32 input_device_absolute_item::read_as_switch(input_item_modifier modifier)
// start with the current value
INT32 result = m_device.apply_deadzone_and_saturation(update_value());
assert(result >= INPUT_ABSOLUTE_MIN && result <= INPUT_ABSOLUTE_MAX);
// left/right/up/down: if this is a joystick, fetch the paired X/Y axis values and convert
if (m_device.devclass() == DEVICE_CLASS_JOYSTICK && modifier >= ITEM_MODIFIER_LEFT && modifier <= ITEM_MODIFIER_DOWN)
{
@ -2392,7 +2392,7 @@ INT32 input_device_absolute_item::read_as_switch(input_item_modifier modifier)
//-------------------------------------------------
// read_as_relative - return the absolute input
// read_as_relative - return the absolute input
// as a relative axis value
//-------------------------------------------------
@ -2414,7 +2414,7 @@ INT32 input_device_absolute_item::read_as_absolute(input_item_modifier modifier)
// start with the current value
INT32 result = m_device.apply_deadzone_and_saturation(update_value());
assert(result >= INPUT_ABSOLUTE_MIN && result <= INPUT_ABSOLUTE_MAX);
// if we're doing a lightgun reload hack, override the value
if (m_device.devclass() == DEVICE_CLASS_LIGHTGUN && m_device.lightgun_reload_button())
{

42
src/emu/input.h
View File

@ -332,7 +332,7 @@ enum input_item_id
ITEM_ID_OTHER_AXIS_ABSOLUTE,
ITEM_ID_OTHER_AXIS_RELATIVE,
ITEM_ID_MAXIMUM,
// internal codes for sequences
ITEM_ID_SEQ_END,
ITEM_ID_SEQ_DEFAULT,
@ -370,14 +370,14 @@ public:
// construction/destruction
joystick_map();
joystick_map(const joystick_map &src) { copy(src); }
// operators
joystick_map &operator=(const joystick_map &src) { if (this != &src) copy(src); return *this; }
// parse from a string
bool parse(const char *mapstring);
// create a friendly string
// create a friendly string
const char *to_string(astring &string) const;
// update the state of a live map
@ -426,11 +426,11 @@ public:
input_code(const input_code &src)
: m_internal(src.m_internal) { }
input_code(input_device &device, input_item_id itemid);
// operators
bool operator==(const input_code &rhs) const { return m_internal == rhs.m_internal; }
bool operator!=(const input_code &rhs) const { return m_internal != rhs.m_internal; }
// getters
bool internal() const { return device_class() == DEVICE_CLASS_INTERNAL; }
input_device_class device_class() const { return input_device_class((m_internal >> 28) & 0xf); }
@ -438,14 +438,14 @@ public:
input_item_class item_class() const { return input_item_class((m_internal >> 16) & 0xf); }
input_item_modifier item_modifier() const { return input_item_modifier((m_internal >> 12) & 0xf); }
input_item_id item_id() const { return input_item_id(m_internal & 0xfff); }
// setters
void set_device_class(input_device_class devclass) { assert(devclass >= 0 && devclass <= 0xf); m_internal = (m_internal & ~(0xf << 28)) | ((devclass & 0xf) << 28); }
void set_device_index(int devindex) { assert(devindex >= 0 && devindex <= 0xff); m_internal = (m_internal & ~(0xff << 20)) | ((devindex & 0xff) << 20); }
void set_item_class(input_item_class itemclass) { assert(itemclass >= 0 && itemclass <= 0xf); m_internal = (m_internal & ~(0xf << 16)) | ((itemclass & 0xf) << 16); }
void set_item_modifier(input_item_modifier modifier) { assert(modifier >= 0 && modifier <= 0xf); m_internal = (m_internal & ~(0xf << 12)) | ((modifier & 0xf) << 12); }
void set_item_id(input_item_id itemid) { assert(itemid >= 0 && itemid <= 0xfff); m_internal = (m_internal & ~0xfff) | (itemid & 0xfff); }
private:
// internal state
UINT32 m_internal;
@ -481,7 +481,7 @@ public:
void set_default() { set(default_code); }
void backspace();
void replace(input_code oldcode, input_code newcode);
// constant codes used in sequences
static const input_code end_code;
static const input_code default_code;
@ -494,7 +494,7 @@ public:
private:
// internal state
input_code m_code[16];
input_code m_code[16];
};
@ -502,7 +502,7 @@ private:
// a logical device of a given class that can provide input
class input_device
{
{
friend class input_class;
// construction/destruction
@ -557,7 +557,7 @@ class input_class
public:
// construction/destruction
input_class(input_manager &manager, input_device_class devclass, bool enabled = false, bool multi = false);
// getters
input_manager &manager() const { return m_manager; }
running_machine &machine() const;
@ -566,7 +566,7 @@ public:
int maxindex() const { return m_maxindex; }
bool enabled() const { return m_enabled; }
bool multi() const { return m_multi; }
// setters
void enable(bool state = true) { m_enabled = state; }
void set_multi(bool multi = true) { m_multi = multi; }
@ -584,7 +584,7 @@ private:
// internal state
input_manager & m_manager; // reference to our manager
input_device * m_device[DEVICE_INDEX_MAXIMUM]; // array of devices in this class
input_device * m_device[DEVICE_INDEX_MAXIMUM]; // array of devices in this class
input_device_class m_devclass; // our device class
int m_maxindex; // maximum populated index
bool m_enabled; // is this class enabled?
@ -600,22 +600,22 @@ class input_manager
public:
// construction/destruction
input_manager(running_machine &machine);
// getters
running_machine &machine() const { return m_machine; }
input_class &device_class(input_device_class devclass) { assert(devclass < ARRAY_LENGTH(m_class)); assert(m_class[devclass] != NULL); return *m_class[devclass]; }
// input code readers
INT32 code_value(input_code code);
bool code_pressed(input_code code) { return code_value(code) != 0; }
bool code_pressed_once(input_code code);
// input code polling
void reset_polling();
input_code poll_axes();
input_code poll_switches();
input_code poll_keyboard_switches();
// input code helpers
input_device *device_from_code(input_code code) const;
input_device_item *item_from_code(input_code code) const;
@ -623,16 +623,16 @@ public:
const char *code_name(astring &string, input_code code) const;
const char *code_to_token(astring &string, input_code code) const;
input_code code_from_token(const char *_token);
// input sequence readers
bool seq_pressed(const input_seq &seq);
INT32 seq_axis_value(const input_seq &seq, input_item_class &itemclass);
// input sequence polling
void seq_poll_start(input_item_class itemclass, const input_seq *startseq = NULL);
bool seq_poll();
const input_seq &seq_poll_final() const { return m_poll_seq; }
// input sequence helpers
const char *seq_name(astring &string, const input_seq &seq) const;
const char *seq_to_tokens(astring &string, const input_seq &seq) const;
@ -656,7 +656,7 @@ private:
input_class m_joystick_class;
input_class m_lightgun_class;
input_class * m_class[DEVICE_CLASS_MAXIMUM];
// sequence polling state
input_seq m_poll_seq;
osd_ticks_t m_poll_seq_last_ticks;

18
src/emu/machine/53c810.c
View File

@ -148,9 +148,9 @@ static OPCODE_HANDLER( dmaop_block_move )
static OPCODE_HANDLER( dmaop_select )
{
// UINT32 operand;
// UINT32 operand;
// operand = FETCH(machine);
// operand = FETCH(machine);
if (lsi810.scntl0 & 0x01)
{
@ -173,9 +173,9 @@ static OPCODE_HANDLER( dmaop_select )
static OPCODE_HANDLER( dmaop_wait_disconnect )
{
// UINT32 operand;
// UINT32 operand;
// operand = FETCH(machine);
// operand = FETCH(machine);
if (lsi810.scntl0 & 0x01)
{
@ -193,7 +193,7 @@ static OPCODE_HANDLER( dmaop_wait_reselect )
{
// UINT32 operand;
// operand = FETCH(machine);
// operand = FETCH(machine);
if (lsi810.scntl0 & 0x01)
{
@ -209,9 +209,9 @@ static OPCODE_HANDLER( dmaop_wait_reselect )
static OPCODE_HANDLER( dmaop_set )
{
// UINT32 operand;
// UINT32 operand;
// operand = FETCH(machine);
// operand = FETCH(machine);
/* initiator mode */
if (lsi810.dcmd & 0x8)
@ -238,9 +238,9 @@ static OPCODE_HANDLER( dmaop_set )
static OPCODE_HANDLER( dmaop_clear )
{
// UINT32 operand;
// UINT32 operand;
// operand = FETCH(machine);
// operand = FETCH(machine);
/* initiator mode */
if (lsi810.dcmd & 0x8)

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

@ -507,7 +507,7 @@ WRITE8_MEMBER( mc146818_device::write )
// fixme: allow different time base
data &= 0x0f;
if (m_data[0x0b] & 0x40) {
if (data > 2)
if (data > 2)
m_period = attotime::from_hz(32768 >> (data - 1));
else if (data > 0)
m_period = attotime::from_hz(32768 >> (data + 6));

4
src/emu/machine/mc146818.h
View File

@ -26,7 +26,7 @@
#define MCFG_MC146818_ADD(_tag, _type) \
MCFG_DEVICE_ADD(_tag, MC146818, 0) \
mc146818_device::static_set_type(*device, mc146818_device::_type);
mc146818_device::static_set_type(*device, mc146818_device::_type);
//**************************************************************************
// TYPE DEFINITIONS
@ -100,7 +100,7 @@ protected:
attotime m_last_refresh;
attotime m_period;
static const device_timer_id TIMER_CLOCK = 0;
static const device_timer_id TIMER_PERIODIC = 1;

4
src/emu/machine/smc91c9x.c
View File

@ -388,7 +388,7 @@ READ16_DEVICE_HANDLER( smc91c9x_r )
WRITE16_DEVICE_HANDLER( smc91c9x_w )
{
smc91c9x_state *smc = get_safe_token(device);
// UINT16 olddata;
// UINT16 olddata;
/* determine the effective register */
offset %= 8;
@ -396,7 +396,7 @@ WRITE16_DEVICE_HANDLER( smc91c9x_w )
offset += 8 * (smc->reg[EREG_BANK] & 7);
/* update the data generically */
// olddata = smc->reg[offset];
// olddata = smc->reg[offset];
mem_mask &= smc->regmask[offset];
COMBINE_DATA(&smc->reg[offset]);

2
src/emu/mconfig.c
View File

@ -75,7 +75,7 @@ machine_config::machine_config(const game_driver &gamedrv, emu_options &options)
if (intf != NULL)
{
device_t &owner = slot->device();
const char *selval = options.value(owner.tag());
const char *selval = options.value(owner.tag());
if (options.seqid(owner.tag()) == 0)
selval = slot->get_default_card();

14
src/emu/memory.c
View File

@ -553,7 +553,7 @@ public:
read32_delegate r32;
read64_delegate r64;
};
// construction/destruction
handler_entry_read(UINT8 width, endianness_t endianness, UINT8 **rambaseptr)
: handler_entry(width, endianness, rambaseptr)
@ -769,7 +769,7 @@ private:
std::list<_HandlerEntry *> handlers;
UINT64 mask;
};
// ======================> address_table
@ -3282,7 +3282,7 @@ void address_table::map_range(offs_t addrstart, offs_t addrend, offs_t addrmask,
// recompute any direct access on this space if it is a read modification
m_space.m_direct.force_update(entry);
// verify_reference_counts();
// verify_reference_counts();
}
UINT8 address_table::get_free_handler()
@ -3326,7 +3326,7 @@ void address_table::setup_range(offs_t addrstart, offs_t addrend, offs_t addrmas
// Scan the memory to see what has to be done
std::list<subrange> range_override;
std::map<UINT8, std::list<subrange> > range_partial;
offs_t base_mirror = 0;
do
{
@ -3418,7 +3418,7 @@ void address_table::setup_range(offs_t addrstart, offs_t addrend, offs_t addrmas
}
}
// verify_reference_counts();
// verify_reference_counts();
}
@ -3464,7 +3464,7 @@ void address_table::verify_reference_counts()
for(int i = STATIC_COUNT; i != SUBTABLE_BASE; i++)
logerror("%02x: %4x .. %4x\n", i, handler_refcount[i-STATIC_COUNT], actual_refcounts[i-STATIC_COUNT]);
throw emu_fatalerror("memory.c: refcounts are fucked.\n");
}
}
}
@ -4949,7 +4949,7 @@ void handler_entry_read::set_delegate(read8_delegate delegate, UINT64 mask, cons
m_read.r8 = delegate;
if (info)
m_legacy_info = *info;
}
}
}

4
src/emu/schedule.h
View File

@ -117,7 +117,7 @@ public:
attotime remaining() const;
attotime start() const { return m_start; }
attotime expire() const { return m_expire; }
private:
// internal helpers
void register_save();
@ -184,7 +184,7 @@ public:
// debugging
void dump_timers() const;
// for emergencies only!
void eat_all_cycles();

2
src/emu/screen.c
View File

@ -1026,7 +1026,7 @@ void screen_device::finalize_burnin()
if (filerr == FILERR_NONE)
{
png_info pnginfo = { 0 };
// png_error pngerr;
// png_error pngerr;
char text[256];
// add two text entries describing the image

10
src/emu/sound/okim6376.c
View File

@ -303,7 +303,7 @@ static void oki_process(device_t *device, int channel, int command)
{
okim6376_state *info = get_safe_token(device);
/* if a command is pending, process the second half */
/* if a command is pending, process the second half */
if ((command != -1) && (command != 0)) //process silence separately
{
int start;
@ -488,7 +488,7 @@ WRITE_LINE_DEVICE_HANDLER( okim6376_ch2_w )
{
okim6376_state *info = get_safe_token(device);
if (info->ch2 != state)
if (info->ch2 != state)
{
info->ch2 = state;
info->ch2_update = 1;
@ -516,7 +516,7 @@ WRITE_LINE_DEVICE_HANDLER( okim6376_st_w )
okim6376_state *info = get_safe_token(device);
if (info->st != state)
if (info->st != state)
{
info->st = state;
@ -525,8 +525,8 @@ WRITE_LINE_DEVICE_HANDLER( okim6376_st_w )
if ((info->channel == 1) & !info->st)//ST acts as attenuation for Channel 2 when low, and stays at that level until the channel is reset
{
struct ADPCMVoice *voice = &info->voice[info->channel];
{
{
info->st_pulses ++;
if (info->st_pulses > 3)
{

2
src/emu/sound/rf5c400.c
View File

@ -133,7 +133,7 @@ static STREAM_UPDATE( rf5c400_update )
stream_sample_t *buf0 = outputs[0];
stream_sample_t *buf1 = outputs[1];
// start = ((channel->startH & 0xFF00) << 8) | channel->startL;
// start = ((channel->startH & 0xFF00) << 8) | channel->startL;
end = ((channel->endHloopH & 0xFF) << 16) | channel->endL;
loop = ((channel->endHloopH & 0xFF00) << 8) | channel->loopL;
pos = channel->pos;

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

@ -561,8 +561,8 @@ static void update_pcm(YMF271Chip *chip, int slotnum, INT32 *mixp, int length)
ch0_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch0_level]) >> 16;
ch1_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch1_level]) >> 16;
// ch2_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch2_level]) >> 16;
// ch3_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch3_level]) >> 16;
// ch2_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch2_level]) >> 16;
// ch3_vol = ((UINT64)final_volume * (UINT64)channel_attenuation[slot->ch3_level]) >> 16;
if (ch0_vol > 65536) ch0_vol = 65536;
if (ch1_vol > 65536) ch1_vol = 65536;

8
src/emu/video/hd63484.c
View File

@ -688,10 +688,10 @@ static void ptn( device_t *device, int opcode, int src_x, int src_y, INT16 _ax,
ax_neg = -1;
else
ax_neg = 1;
/* if (ay < 0)
ay_neg = -1;
else
ay_neg = 1;*/
/* if (ay < 0)
ay_neg = -1;
else
ay_neg = 1;*/
if (opcode & 0x0800)
switch (opcode & 0x0700)

4
src/emu/video/tlc34076.c
View File

@ -163,11 +163,11 @@ READ8_DEVICE_HANDLER( tlc34076_r )
WRITE8_DEVICE_HANDLER( tlc34076_w )
{
tlc34076_state *state = get_safe_token(device);
// UINT8 oldval;
// UINT8 oldval;
/* keep in range */
offset &= 0x0f;
// oldval = state->regs[offset];
// oldval = state->regs[offset];
state->regs[offset] = data;
/* switch off the offset */

2
src/emu/video/vooddefs.h
View File

@ -2079,7 +2079,7 @@ INLINE UINT32 compute_raster_hash(const raster_info *info)
const UINT8 *dither4 = NULL; \
const UINT8 *dither = NULL \
#define DECLARE_DITHER_POINTERS_NO_DITHER_VAR \
#define DECLARE_DITHER_POINTERS_NO_DITHER_VAR \
const UINT8 *dither_lookup = NULL; \
#define COMPUTE_DITHER_POINTERS(FBZMODE, YY) \

4
src/lib/formats/wavfile.c
View File

@ -70,7 +70,7 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
UINT16 format_type = 0;
UINT32 bytes_per_second = 0;
// UINT16 block_align = 0;
// UINT16 block_align = 0;
int waveform_flags = 0;
/* read header */
@ -108,7 +108,7 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
opts->channels = get_leuint16(&format_tag[2]);
opts->sample_frequency = get_leuint32(&format_tag[4]);
bytes_per_second = get_leuint32(&format_tag[8]);
// block_align = get_leuint16(&format_tag[12]);
// block_align = get_leuint16(&format_tag[12]);
opts->bits_per_sample = get_leuint16(&format_tag[14]);
if (format_type != WAV_FORMAT_PCM)

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

@ -1530,7 +1530,7 @@ static avi_error parse_indx_chunk(avi_file *file, avi_stream *stream, avi_chunk
//subtype = chunkdata[2];
type = chunkdata[3];
entries = fetch_32bits(&chunkdata[4]);
//id = fetch_32bits(&chunkdata[8]);
//id = fetch_32bits(&chunkdata[8]);
baseoffset = fetch_64bits(&chunkdata[12]);
/* if this is a superindex, loop over entries and call ourselves recursively */

2
src/mame/audio/beezer.c
View File

@ -310,7 +310,7 @@ static STREAM_UPDATE( beezer_stream_update )
/* skip if nothing enabled */
if ((sh6840_timer[0].cr & 0x01) == 0) // if we're not in reset...
{
// int noise_clocks_this_sample = 0;
// int noise_clocks_this_sample = 0;
UINT32 chan1_clocks;
/* generate noise if configured to do so */

4
src/mame/audio/dcs.c
View File

@ -753,7 +753,7 @@ MACHINE_CONFIG_END
static void dcs_boot(running_machine &machine)
{
UINT8 buffer[0x1000];
// UINT32 max_banks;
// UINT32 max_banks;
UINT16 *base;
int i;
@ -763,7 +763,7 @@ static void dcs_boot(running_machine &machine)
case 1:
/* determine the base */
// max_banks = dcs.bootrom_words / 0x1000;
// max_banks = dcs.bootrom_words / 0x1000;
base = dcs.bootrom + ((dcs.sounddata_bank * 0x1000) % dcs.bootrom_words);
/* convert from 16-bit data to 8-bit data and boot */

12
src/mame/audio/taito_en.c
View File

@ -61,16 +61,16 @@ static WRITE16_HANDLER( f3_es5505_bank_w )
static WRITE16_HANDLER( f3_volume_w )
{
// static UINT16 channel[8],last_l,last_r;
// static int latch;
// static UINT16 channel[8],last_l,last_r;
// static int latch;
// if (offset==0) latch=(data>>8)&0x7;
// if (offset==1) channel[latch]=data>>8;
// if (offset==0) latch=(data>>8)&0x7;
// if (offset==1) channel[latch]=data>>8;
// if (channel[7]!=last_l) mixer_set_volume(0, (int)((float)channel[7]*1.58)); /* Left master volume */
// if (channel[6]!=last_r) mixer_set_volume(1, (int)((float)channel[6]*1.58)); /* Right master volume */
// last_l=channel[7];
// last_r=channel[6];
// last_l=channel[7];
// last_r=channel[6];
/* Channel 5 - Left Aux? Always set to volume, but never used for panning */
/* Channel 4 - Right Aux? Always set to volume, but never used for panning */

2
src/mame/drivers/4roses.c
View File

@ -404,7 +404,7 @@ static MACHINE_CONFIG_START( 4roses, _4roses_state )
MCFG_PALETTE_INIT(funworld)
MCFG_VIDEO_START(funworld)
// MCFG_MC6845_ADD("crtc", MC6845, MASTER_CLOCK/8, mc6845_intf) /* 2MHz, guess */
// MCFG_MC6845_ADD("crtc", MC6845, MASTER_CLOCK/8, mc6845_intf) /* 2MHz, guess */
/* sound hardware */
MCFG_SPEAKER_STANDARD_MONO("mono")

8
src/mame/drivers/champbwl.c
View File

@ -231,7 +231,7 @@ static WRITE8_HANDLER( doraemon_outputs_w )
memory_set_bank(space->machine(), "bank1", (data & 0x30) >> 4);
// popmessage("%02x", data);
// popmessage("%02x", data);
}
static ADDRESS_MAP_START( doraemon, AS_PROGRAM, 8 )
@ -363,9 +363,9 @@ static INPUT_PORTS_START( doraemon )
PORT_DIPSETTING( 0x06, "40 %" )
PORT_DIPSETTING( 0x05, "60 %" )
PORT_DIPSETTING( 0x04, "80 %" )
// PORT_DIPSETTING( 0x03, "100 %" )
// PORT_DIPSETTING( 0x02, "100 %" )
// PORT_DIPSETTING( 0x01, "100 %" )
// PORT_DIPSETTING( 0x03, "100 %" )
// PORT_DIPSETTING( 0x02, "100 %" )
// PORT_DIPSETTING( 0x01, "100 %" )
PORT_DIPSETTING( 0x00, "100 %" )
PORT_DIPNAME( 0x10, 0x10, "Games For 100 Yen" )
PORT_DIPSETTING( 0x10, "1" )

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

@ -365,7 +365,7 @@ static void jamtable_disasm(running_machine &machine, address_space *space,UINT3
char sop1[16];
char sop2[16];
char pcrel[16];
// int prefix;
// int prefix;
addr=address;
while (1)
@ -385,14 +385,14 @@ static void jamtable_disasm(running_machine &machine, address_space *space,UINT3
sprintf(sop2,"%08X",op2);
sprintf(sop1,"ACC");
sprintf(pcrel,"PC+ACC");
// prefix=1;
// prefix=1;
}
else
{
sprintf(sop2,"%08X",op2);
sprintf(sop1,"%08X",op1);
sprintf(pcrel,"%08X",base+9+op1);
// prefix=0;
// prefix=0;
}
debug_console_printf(machine,"%08X ",base);
// dl=instr ebx=par1 eax=par2

8
src/mame/drivers/cps2.c
View File

@ -4240,15 +4240,15 @@ Marvel Vs. Capcom: Clash of Super Heroes (Euro 980123):
The originally dumped ROM4 contains garbage instructions that cause the game to crash during the ending staff roll.
The ROM has been repaired so that the code matches the other sets after decryption:
offset dumped repaired decrypted
0x40/2 001a 189a EB11 -> 4EF9
0x60/2 800b c00b 0843 -> 227C
offset dumped repaired decrypted
0x40/2 001a 189a EB11 -> 4EF9
0x60/2 800b c00b 0843 -> 227C
*/
ROM_START( mvsc )
ROM_REGION( CODE_SIZE, "maincpu", 0 ) /* 68000 code */
ROM_LOAD16_WORD_SWAP( "mvce.03a", 0x000000, 0x80000, CRC(824e4a90) SHA1(5c79c166d988d8a75d9941f4ee6fa4d6476e55e1) )
// ROM_LOAD16_WORD_SWAP( "mvce.04a", 0x080000, 0x80000, BAD_DUMP CRC(cac02153) SHA1(ee9f9da6fda53f21ba7b74367612c90281269690) )
// ROM_LOAD16_WORD_SWAP( "mvce.04a", 0x080000, 0x80000, BAD_DUMP CRC(cac02153) SHA1(ee9f9da6fda53f21ba7b74367612c90281269690) )
ROM_LOAD16_WORD_SWAP( "mvce.04a", 0x080000, 0x80000, CRC(436c5a4e) SHA1(82f4586e888f2550c53bfdc93a53791a595e05bd) )
ROM_LOAD16_WORD_SWAP( "mvc.05a", 0x100000, 0x80000, CRC(2d8c8e86) SHA1(b07d640a734c5d336054ed05195786224c9a6cd4) )
ROM_LOAD16_WORD_SWAP( "mvc.06a", 0x180000, 0x80000, CRC(8528e1f5) SHA1(cd065c05268ab581b05676da544baf6af642acac) )

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

@ -1076,9 +1076,9 @@ static SCREEN_UPDATE(cps3)
//int endline;
//int height = (value3 & 0x7f000000)>>24;
int uu;
// UINT32* tmapregs[4] = { state->m_tilemap20_regs_base, state->m_tilemap30_regs_base, state->m_tilemap40_regs_base, state->m_tilemap50_regs_base };
// UINT32* regs;
// regs = tmapregs[tilemapnum];
// UINT32* tmapregs[4] = { state->m_tilemap20_regs_base, state->m_tilemap30_regs_base, state->m_tilemap40_regs_base, state->m_tilemap50_regs_base };
// UINT32* regs;
// regs = tmapregs[tilemapnum];
//endline = value2;
//startline = endline - height;

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

@ -3,11 +3,11 @@
Note: this hardware is a copy of Psikyo's 68020 based hardware,
the Strikers 1945 bootleg has the same unknown rom!
It isn't quite as flexible as the original Psikyo hardware
by the looks of it, there are various subtle changes to how
things work, for example the tilemap sizes and missing
transparent pen modification. This makes it rather hard to
merge with psikyo.c and it should probably be left separate.
It isn't quite as flexible as the original Psikyo hardware
by the looks of it, there are various subtle changes to how
things work, for example the tilemap sizes and missing
transparent pen modification. This makes it rather hard to
merge with psikyo.c and it should probably be left separate.
Dream World
SemiCom, 2000
@ -93,25 +93,25 @@ Stephh's notes (based on the game M68EC020 code and some tests) :
Baryon has some annoying sound looping clicks / cutouts, these need to
be verified against the HW (it's a very cheap sound system, so it might
be accurate)
be accurate)
Baryon has playfield background which fade in with very rough / visible
edges. In this case the tilemap size registers from the original
psikyo hardware are set to be the alternate tilemap size, however that
doesn't make sense in the context of the data in RAM, which doesn't
appear to wrap properly anyway, again, it's likely this is just how the
game is. Furthermore the BG test in the test menu indicates that it
tests alternate tilemap sizes, but doesn't even write to the register,
probably a leftover from hardware development as the test menu is mostly
incomplete.
psikyo hardware are set to be the alternate tilemap size, however that
doesn't make sense in the context of the data in RAM, which doesn't
appear to wrap properly anyway, again, it's likely this is just how the
game is. Furthermore the BG test in the test menu indicates that it
tests alternate tilemap sizes, but doesn't even write to the register,
probably a leftover from hardware development as the test menu is mostly
incomplete.
All: sprite priority, the original psikyo.c HW has sprite<->tilemap
priority but we don't support it here, does the clone HW support it?
All: sprite zooming, again the original psikyo.c HW supports this, but we
don't support it here. The Strikers 1945 bootleg in psikyo.c doesn't
appear to support it properly either, so it might be missing on these
clone boards.
appear to support it properly either, so it might be missing on these
clone boards.
*/
@ -140,7 +140,7 @@ public:
tilemap_t *m_bg2_tilemap;
int m_tilebank[2];
int m_tilebankold[2];
UINT32* m_spritebuf1;
UINT32* m_spritebuf2;
@ -283,7 +283,7 @@ SCREEN_EOF( dreamwld )
static SCREEN_UPDATE( dreamwld )
{
dreamwld_state *state = screen->machine().driver_data<dreamwld_state>();
// int tm0size, tm1size;
// int tm0size, tm1size;
tilemap_t *tmptilemap0, *tmptilemap1;
@ -424,7 +424,7 @@ static WRITE32_HANDLER( dreamwld_6295_1_bank_w )
logerror("OKI1: unk bank write %x mem_mask %8x\n", data, mem_mask);
}
// why doesn't using paletteram16_xRRRRRGGGGGBBBBB_word_w with a 16-bit handler work? colours are
// why doesn't using paletteram16_xRRRRRGGGGGBBBBB_word_w with a 16-bit handler work? colours are
// severely corrupt on dream world's semicom screen + many sprites, seems palette values get duplicated.
static WRITE32_HANDLER( dreamwld_palette_w )
{
@ -448,7 +448,7 @@ static ADDRESS_MAP_START( baryon_map, AS_PROGRAM, 32 )
AM_RANGE(0x000000, 0x0fffff) AM_ROM AM_WRITENOP
AM_RANGE(0x400000, 0x401fff) AM_RAM AM_BASE_MEMBER(dreamwld_state, m_spriteram)
AM_RANGE(0x600000, 0x601fff) AM_RAM AM_WRITE(dreamwld_palette_w) AM_BASE_MEMBER(dreamwld_state, m_paletteram)
AM_RANGE(0x600000, 0x601fff) AM_RAM AM_WRITE(dreamwld_palette_w) AM_BASE_MEMBER(dreamwld_state, m_paletteram)
AM_RANGE(0x800000, 0x801fff) AM_RAM_WRITE(dreamwld_bg_videoram_w ) AM_BASE_MEMBER(dreamwld_state, m_bg_videoram)
AM_RANGE(0x802000, 0x803fff) AM_RAM_WRITE(dreamwld_bg2_videoram_w ) AM_BASE_MEMBER(dreamwld_state, m_bg2_videoram)
AM_RANGE(0x804000, 0x805fff) AM_RAM AM_BASE_MEMBER(dreamwld_state, m_vregs) // scroll regs etc.

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

@ -238,7 +238,7 @@ static WRITE16_HANDLER( tv_vcf_bankselect_w )
static WRITE16_DEVICE_HANDLER( tv_oki6376_w )
{
static int okidata;
if (ACCESSING_BITS_0_7 && okidata != data)
if (ACCESSING_BITS_0_7 && okidata != data)
{
okidata = data;
okim6376_w(device, 0, data & ~0x80);
@ -248,7 +248,7 @@ static WRITE16_DEVICE_HANDLER( tv_oki6376_w )
static READ16_DEVICE_HANDLER( tv_oki6376_r )
{
if (ACCESSING_BITS_0_7)
if (ACCESSING_BITS_0_7)
{
return okim6376_busy_r(device);
}
@ -319,7 +319,7 @@ static WRITE16_DEVICE_HANDLER( tv_ncf_oki6376_w )
static WRITE16_DEVICE_HANDLER( tv_ncf_oki6376_st_w )
{
if (ACCESSING_BITS_0_7)
if (ACCESSING_BITS_0_7)
{
okim6376_st_w(device, (data & 0x80) );
}

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

@ -1161,8 +1161,8 @@ static void jamma_jvs_cmd_exec(running_machine &machine)
int rdata_ptr;
int sum;
// sync = state->m_jvs_sdata[0];
// node = state->m_jvs_sdata[1];
// sync = state->m_jvs_sdata[0];
// node = state->m_jvs_sdata[1];
byte_num = state->m_jvs_sdata[2];
#if 0

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

@ -614,7 +614,7 @@ static ADDRESS_MAP_START( tms_program_map, AS_PROGRAM, 16 )
AM_RANGE(0x00000000, 0x003fffff) AM_MIRROR(0xf8000000) AM_RAM AM_BASE_MEMBER(jpmimpct_state, m_vram)
AM_RANGE(0x00800000, 0x00ffffff) AM_MIRROR(0xf8000000) AM_ROM AM_REGION("user1", 0x100000)
AM_RANGE(0x02000000, 0x027fffff) AM_MIRROR(0xf8000000) AM_ROM AM_REGION("user1", 0)
// AM_RANGE(0x01000000, 0x0100003f) AM_MIRROR(0xf87fffc0) AM_READWRITE(jpmimpct_bt477_r, jpmimpct_bt477_w)
// AM_RANGE(0x01000000, 0x0100003f) AM_MIRROR(0xf87fffc0) AM_READWRITE(jpmimpct_bt477_r, jpmimpct_bt477_w)
AM_RANGE(0x01000000, 0x017fffff) AM_MIRROR(0xf8000000) AM_MASK(0x1f) AM_READWRITE(jpmimpct_bt477_r, jpmimpct_bt477_w)
AM_RANGE(0x07800000, 0x07bfffff) AM_MIRROR(0xf8400000) AM_RAM
ADDRESS_MAP_END

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

@ -343,7 +343,7 @@ static SCREEN_UPDATE( maygayv1 )
// printf("Blinking\n");
/* Resolution: either 4bpp or 2bpp */
// res = (w0 >> 9) & 3;
// res = (w0 >> 9) & 3;
/* Expand 2bpp to 3bpp */

8
src/mame/drivers/mazerbla.c
View File

@ -273,13 +273,13 @@ SCREEN_UPDATE( test_vcu )
static SCREEN_UPDATE( mazerbla )
{
mazerbla_state *state = screen->machine().driver_data<mazerbla_state>();
// UINT32 color_base = 0;
// UINT32 color_base = 0;
if (state->m_game_id == MAZERBLA)
// color_base = 0x80; /* 0x80 constant: matches Mazer Blazer movie */
// color_base = 0x80; /* 0x80 constant: matches Mazer Blazer movie */
// if (state->m_game_id == GREATGUN)
// color_base = 0x00;
// if (state->m_game_id == GREATGUN)
// color_base = 0x00;
// bitmap_fill(bitmap, NULL, 0);

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

@ -3320,7 +3320,7 @@ ROM_START( stcc ) /* Sega Touring Car Championship, Model 2C - Defaults to Japan
ROM_LOAD("mpr-19265.60s", 0x600000, 0x200000, CRC(7d98700a) SHA1(bedd37314ecab424b5b27030e1e7dc1b596303f3))
ROM_REGION( 0x10000, "drive", 0 ) // drive board CPU (code is Z80 compatible)
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_END
ROM_START( stcca ) /* Sega Touring Car Championship Revision A, Model 2C - Defaults to Japan, Twin & no "Default View" option */
@ -3379,7 +3379,7 @@ ROM_START( stcca ) /* Sega Touring Car Championship Revision A, Model 2C - Defau
ROM_LOAD("mpr-19265.60s", 0x600000, 0x200000, CRC(7d98700a) SHA1(bedd37314ecab424b5b27030e1e7dc1b596303f3))
ROM_REGION( 0x10000, "drive", 0 ) // drive board CPU (code is Z80 compatible)
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_END
ROM_START( stccb ) /* Sega Touring Car Championship Revision unknown, Model 2C - Defaults to Japan, Twin & Default View set to Driver's */
@ -3438,7 +3438,7 @@ ROM_START( stccb ) /* Sega Touring Car Championship Revision unknown, Model 2C -
ROM_LOAD("mpr-19265.60s", 0x600000, 0x200000, CRC(7d98700a) SHA1(bedd37314ecab424b5b27030e1e7dc1b596303f3))
ROM_REGION( 0x10000, "drive", 0 ) // drive board CPU (code is Z80 compatible)
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_LOAD( "epr-18261.ic9", 0x000000, 0x010000, CRC(0c7fac58) SHA1(68c1724c41401e28a5123022981c8919fd22656e) )
ROM_END
ROM_START( skisuprg ) /* Sega Ski Super G, Model 2C */

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

@ -219,8 +219,8 @@ TODO: - Distinguish door switches using manual
- Flo's move in Great Escape gives spin alarms - need a different opto setting for reverse spin reels?
- Fix BwB characteriser, need to be able to calculate stabiliser bytes. Anyone fancy reading 6809 source?
- Fix MSM6376 - We need all features of the chip, including dynamic sample rate adjustment and BEEP.
- OKI sound chip rate - need to confirm independently (3MHz sounds good, but that could be because
of the old driver - BwB manual claims 64KHz to 128KHz).
- OKI sound chip rate - need to confirm independently (3MHz sounds good, but that could be because
of the old driver - BwB manual claims 64KHz to 128KHz).
***********************************************************************************************************/
#include "emu.h"
#include "machine/6821pia.h"

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

@ -822,7 +822,7 @@ ROM_START( nam1975 ) /* MVS AND AES VERSION */
ROM_REGION( 0x080000, "ymsnd", 0 )
ROM_LOAD( "001-v11.v11", 0x000000, 0x080000, CRC(a7c3d5e5) SHA1(e3efc86940f91c53b7724c4566cfc21ea1a7a465) ) /* MB834200 */
// AES has different label, data is the same: 001-v1.v1
ROM_REGION( 0x180000, "ymsnd.deltat", 0 )
ROM_LOAD( "001-v21.v21", 0x000000, 0x080000, CRC(55e670b3) SHA1(a047049646a90b6db2d1882264df9256aa5a85e5) ) /* MB834200 */
// AES has different label, data is the same: 001-v2.v21

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

@ -1361,7 +1361,7 @@ static MACHINE_CONFIG_DERIVED( newhilop, noraut_base )
/* basic machine hardware */
MCFG_CPU_MODIFY("maincpu")
MCFG_CPU_PROGRAM_MAP(newhilop_map)
// MCFG_CPU_IO_MAP(newhilop_portmap)
// MCFG_CPU_IO_MAP(newhilop_portmap)
MCFG_CPU_VBLANK_INT("screen", irq0_line_hold)
MACHINE_CONFIG_END

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

@ -269,7 +269,7 @@ static SCREEN_UPDATE( pinkiri8 )
x &= 0xff;
x *= 2;
// unk2 = state->m_janshi_vram2[(i*2)+1];
// unk2 = state->m_janshi_vram2[(i*2)+1];
y = (state->m_janshi_vram2[(i*2)+0]);
y = 0x100-y;

30
src/mame/drivers/rltennis.c
View File

@ -2,9 +2,9 @@
Reality Tennis - (c) 1993 TCH
driver by Tomasz Slanina
based on informations provided by Antonio 'Peluko' Carrillo
based on informations provided by Antonio 'Peluko' Carrillo
Game Credits:
Antonio 'Peluko' Carrillo: programmer and game designer
David Sandoval: hardware designer
@ -39,7 +39,7 @@ Two Actel FPGA chips (marked as JOAQUIN and JUANA).
Juana can read data from ROMs. JOAQUIN - write to VRAM.
Both can access 256x256 pixel pages.
Size and direction of data read/write, as well as active page is
selectable for each of the chips.
selectable for each of the chips.
Sound hardware (verify):
------------------------
@ -48,8 +48,8 @@ Two custom DACs are conencted directly to data lines of sound ROMs.
A0-A10 address lines are controlled by a counter, clocked by scaline
clock ( not verified, just guessed ). Top lines are controlled by cpu,
and select 2k sample to play. There's probably no way to stop the sample
player - when there's nothing to play - first, empty 2k of ROMs are selected.
player - when there's nothing to play - first, empty 2k of ROMs are selected.
TODO:
- proper timing and interrupts (remove extra hacky blitter int generation @ vblank)
- fix various gfx glitches here and there, mostly related to wrong size of data
@ -71,7 +71,7 @@ player - when there's nothing to play - first, empty 2k of ROMs are selected.
static READ16_HANDLER( rlt_io_r )
{
rltennis_state *state = space->machine().driver_data<rltennis_state>();
return (input_port_read(space->machine(), "P1" )&0x1fff) | (state->m_unk_counter<<13); /* top 3 bits controls smaple address update */
}
@ -97,7 +97,7 @@ static ADDRESS_MAP_START( rltennis_main, AS_PROGRAM, 16 )
AM_RANGE(0x720006, 0x720007) AM_WRITE(rlt_ramdac_address_rm_w)
AM_RANGE(0x740000, 0x740001) AM_WRITE(rlt_snd1_w)
AM_RANGE(0x760000, 0x760001) AM_WRITE(rlt_snd2_w)
AM_RANGE(0x780000, 0x780001) AM_WRITENOP /* sound control, unknown, usually = 0x0044 */
AM_RANGE(0x780000, 0x780001) AM_WRITENOP /* sound control, unknown, usually = 0x0044 */
AM_RANGE(0x7a0000, 0x7a0003) AM_READNOP /* unknown, read only at boot time*/
AM_RANGE(0x7e0000, 0x7e0001) AM_READ(rlt_io_r)
AM_RANGE(0x7e0002, 0x7e0003) AM_READ_PORT("P2")
@ -120,7 +120,7 @@ static INPUT_PORTS_START( rltennis )
PORT_BIT( 0x1000, IP_ACTIVE_LOW, IPT_SERVICE )
PORT_BIT( 0xe000, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_START("P2")
PORT_BIT( 0x0001, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_8WAY PORT_PLAYER(2)
PORT_BIT( 0x0002, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_8WAY PORT_PLAYER(2)
@ -135,7 +135,7 @@ INPUT_PORTS_END
static TIMER_CALLBACK( sample_player )
{
rltennis_state *state = machine.driver_data<rltennis_state>();
if((state->m_dac_counter&0x7ff) == 0x7ff) /* reload top address bits */
{
state->m_sample_rom_offset_1=(( state->m_data740000 >> state->m_offset_shift ) & 0xff )<<11;
@ -143,7 +143,7 @@ static TIMER_CALLBACK( sample_player )
state->m_offset_shift^=8; /* switch between MSB and LSB */
}
++state->m_dac_counter; /* update low address bits */
dac_signed_data_w(state->m_dac_1, state->m_samples_1[state->m_sample_rom_offset_1 + ( state->m_dac_counter&0x7ff )]);
dac_data_w(state->m_dac_2, state->m_samples_2[state->m_sample_rom_offset_2 + ( state->m_dac_counter&0x7ff )]);
state->m_timer->adjust(attotime::from_hz( RLT_TIMER_FREQ ));
@ -182,13 +182,13 @@ static MACHINE_CONFIG_START( rltennis, rltennis_state )
MCFG_CPU_ADD("maincpu", M68000, RLT_XTAL/2) /* 68000P8 ??? */
MCFG_CPU_PROGRAM_MAP(rltennis_main)
MCFG_CPU_VBLANK_INT("screen", rltennis_interrupt)
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_REFRESH_RATE( RLT_REFRESH_RATE )
MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
MCFG_SCREEN_SIZE(320, 240)
MCFG_SCREEN_VISIBLE_AREA(0,319, 0, 239)
MCFG_SCREEN_UPDATE(rltennis)
MCFG_PALETTE_LENGTH(256)
@ -223,10 +223,10 @@ ROM_START( rltennis )
ROM_LOAD( "tennis_12.u40",0x380000, 0x80000, CRC(b9677887) SHA1(84b79864555d3d6e9c443913910a055e27d30d08) )
ROM_LOAD( "tennis_13.u41",0x400000, 0x80000, CRC(3d4fbcac) SHA1(e01f479d7d516ff83cbbd82d83617146d7a242d3) )
ROM_LOAD( "tennis_14.u42",0x480000, 0x80000, CRC(37fe0f5d) SHA1(7593f1ea07bc0a741c952e6850bed1bf0a824510) )
ROM_REGION( 0x080000, "samples1", 0 )
ROM_LOAD( "tennis_4.u59", 0x00000, 0x80000, CRC(f56462ea) SHA1(638777e12f2649a5b4366f034f0ba721fc4580a8) )
ROM_REGION( 0x080000, "samples2", 0 )
ROM_LOAD( "tennis_3.u52", 0x00000, 0x80000, CRC(517dcd0e) SHA1(b2703e185ee8cf7e115ea07151e7bee8be34948b) )
ROM_END

42
src/mame/drivers/saturn.c
View File

@ -731,20 +731,20 @@ static READ8_HANDLER( saturn_SMPC_r8 )
if (offset == 0x75)//PDR1 read
{
/*
PORT_START("JOY1")
PORT_BIT( 0x8000, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_PLAYER(1)
PORT_BIT( 0x4000, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_PLAYER(1)
PORT_BIT( 0x2000, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_PLAYER(1)
PORT_BIT( 0x1000, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_PLAYER(1)
PORT_BIT( 0x0800, IP_ACTIVE_LOW, IPT_START ) PORT_PLAYER(1) // START
PORT_BIT( 0x0400, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_NAME("P1 A") PORT_PLAYER(1) // A
PORT_BIT( 0x0200, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_NAME("P1 B") PORT_PLAYER(1) // B
PORT_BIT( 0x0100, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_NAME("P1 C") PORT_PLAYER(1) // C
PORT_BIT( 0x0080, IP_ACTIVE_LOW, IPT_BUTTON8 ) PORT_NAME("P1 R") PORT_PLAYER(1) // R
PORT_BIT( 0x0040, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_NAME("P1 X") PORT_PLAYER(1) // X
PORT_BIT( 0x0020, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_NAME("P1 Y") PORT_PLAYER(1) // Y
PORT_BIT( 0x0010, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_NAME("P1 Z") PORT_PLAYER(1) // Z
PORT_BIT( 0x0008, IP_ACTIVE_LOW, IPT_BUTTON7 ) PORT_NAME("P1 L") PORT_PLAYER(1) // L
PORT_START("JOY1")
PORT_BIT( 0x8000, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_PLAYER(1)
PORT_BIT( 0x4000, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT ) PORT_PLAYER(1)
PORT_BIT( 0x2000, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN ) PORT_PLAYER(1)
PORT_BIT( 0x1000, IP_ACTIVE_LOW, IPT_JOYSTICK_UP ) PORT_PLAYER(1)
PORT_BIT( 0x0800, IP_ACTIVE_LOW, IPT_START ) PORT_PLAYER(1) // START
PORT_BIT( 0x0400, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_NAME("P1 A") PORT_PLAYER(1) // A
PORT_BIT( 0x0200, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_NAME("P1 B") PORT_PLAYER(1) // B
PORT_BIT( 0x0100, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_NAME("P1 C") PORT_PLAYER(1) // C
PORT_BIT( 0x0080, IP_ACTIVE_LOW, IPT_BUTTON8 ) PORT_NAME("P1 R") PORT_PLAYER(1) // R
PORT_BIT( 0x0040, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_NAME("P1 X") PORT_PLAYER(1) // X
PORT_BIT( 0x0020, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_NAME("P1 Y") PORT_PLAYER(1) // Y
PORT_BIT( 0x0010, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_NAME("P1 Z") PORT_PLAYER(1) // Z
PORT_BIT( 0x0008, IP_ACTIVE_LOW, IPT_BUTTON7 ) PORT_NAME("P1 L") PORT_PLAYER(1) // L
*/
if (state->m_smpc.IOSEL1)
{
@ -1741,12 +1741,12 @@ static ADDRESS_MAP_START( saturn_mem, AS_PROGRAM, 32 )
AM_RANGE(0x00100000, 0x0010007f) AM_READWRITE8(saturn_SMPC_r8, saturn_SMPC_w8,0xffffffff)
AM_RANGE(0x00180000, 0x0018ffff) AM_READWRITE(saturn_backupram_r, saturn_backupram_w) AM_SHARE("share1") AM_BASE_MEMBER(saturn_state,m_backupram)
AM_RANGE(0x00200000, 0x002fffff) AM_RAM AM_MIRROR(0x100000) AM_SHARE("share2") AM_BASE_MEMBER(saturn_state,m_workram_l)
// AM_RANGE(0x01000000, 0x01000003) AM_MIRROR(0x7ffffc) AM_WRITE(minit_w)
// AM_RANGE(0x01000000, 0x01000003) AM_MIRROR(0x7ffffc) AM_WRITE(minit_w)
AM_RANGE(0x01000000, 0x017fffff) AM_WRITE(minit_w)
// AM_RANGE(0x01800000, 0x01800003) AM_MIRROR(0x7ffffc) AM_WRITE(sinit_w)
// AM_RANGE(0x01800000, 0x01800003) AM_MIRROR(0x7ffffc) AM_WRITE(sinit_w)
AM_RANGE(0x01800000, 0x01ffffff) AM_WRITE(sinit_w)
AM_RANGE(0x02000000, 0x023fffff) AM_ROM AM_SHARE("share7") AM_REGION("maincpu", 0x80000) // cartridge space
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
AM_RANGE(0x04fffffc, 0x04ffffff) AM_READ8(saturn_cart_type_r,0x000000ff)
AM_RANGE(0x05800000, 0x0589ffff) AM_READWRITE(stvcd_r, stvcd_w)
/* Sound */
@ -1771,9 +1771,9 @@ static ADDRESS_MAP_START( stv_mem, AS_PROGRAM, 32 )
AM_RANGE(0x00180000, 0x0018ffff) AM_READWRITE(saturn_backupram_r,saturn_backupram_w) AM_SHARE("share1") AM_BASE_MEMBER(saturn_state,m_backupram)
AM_RANGE(0x00200000, 0x002fffff) AM_RAM AM_MIRROR(0x100000) AM_SHARE("share2") AM_BASE_MEMBER(saturn_state,m_workram_l)
AM_RANGE(0x00400000, 0x0040001f) AM_READWRITE(stv_io_r32, stv_io_w32) AM_BASE_MEMBER(saturn_state,m_ioga) AM_SHARE("share4") AM_MIRROR(0x20)
// AM_RANGE(0x01000000, 0x01000003) AM_MIRROR(0x7ffffc) AM_WRITE(minit_w)
// AM_RANGE(0x01000000, 0x01000003) AM_MIRROR(0x7ffffc) AM_WRITE(minit_w)
AM_RANGE(0x01000000, 0x017fffff) AM_WRITE(minit_w)
// AM_RANGE(0x01800000, 0x01800003) AM_MIRROR(0x7ffffc) AM_WRITE(sinit_w)
// AM_RANGE(0x01800000, 0x01800003) AM_MIRROR(0x7ffffc) AM_WRITE(sinit_w)
AM_RANGE(0x01800000, 0x01ffffff) AM_WRITE(sinit_w)
AM_RANGE(0x02000000, 0x04ffffff) AM_ROM AM_SHARE("share7") AM_REGION("abus", 0) // cartridge
AM_RANGE(0x05800000, 0x0589ffff) AM_READWRITE(stvcd_r, stvcd_w)
@ -2676,7 +2676,7 @@ static MACHINE_RESET( saturn )
if(state->m_cart_type == 1)
{
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02400000, 0x0247ffff, FUNC(saturn_cart_dram0_r), FUNC(saturn_cart_dram0_w));
machine.device("slave")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02400000, 0x0247ffff, FUNC(saturn_cart_dram0_r), FUNC(saturn_cart_dram0_w));
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02600000, 0x0267ffff, FUNC(saturn_cart_dram1_r), FUNC(saturn_cart_dram1_w));
@ -2685,7 +2685,7 @@ static MACHINE_RESET( saturn )
if(state->m_cart_type == 2)
{
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
// AM_RANGE(0x02400000, 0x027fffff) AM_RAM //cart RAM area, dynamically allocated
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02400000, 0x025fffff, FUNC(saturn_cart_dram0_r), FUNC(saturn_cart_dram0_w));
machine.device("slave")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02400000, 0x025fffff, FUNC(saturn_cart_dram0_r), FUNC(saturn_cart_dram0_w));
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x02600000, 0x027fffff, FUNC(saturn_cart_dram1_r), FUNC(saturn_cart_dram1_w));

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

@ -356,11 +356,11 @@ static WRITE16_HANDLER( io_chip_w )
{
segac2_state *state = space->machine().driver_data<segac2_state>();
UINT8 newbank;
// UINT8 old;
// UINT8 old;
/* generic implementation */
offset &= 0x1f/2;
// old = state->m_misc_io_data[offset];
// old = state->m_misc_io_data[offset];
state->m_misc_io_data[offset] = data;
switch (offset)

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

@ -642,7 +642,7 @@ static UINT16 common_io_chip_r(address_space *space, int which, offs_t offset, U
static void common_io_chip_w(address_space *space, int which, offs_t offset, UINT16 data, UINT16 mem_mask)
{
segas32_state *state = space->machine().driver_data<segas32_state>();
// UINT8 old;
// UINT8 old;
/* only LSB matters */
if (!ACCESSING_BITS_0_7)
@ -650,7 +650,7 @@ static void common_io_chip_w(address_space *space, int which, offs_t offset, UIN
/* generic implementation */
offset &= 0x1f/2;
// old = state->m_misc_io_data[which][offset];
// old = state->m_misc_io_data[which][offset];
state->m_misc_io_data[which][offset] = data;
switch (offset)

14
src/mame/drivers/viper.c
View File

@ -191,14 +191,14 @@ An additional control PCB is used for Mocap Golf for the golf club sensor. It co
Driver by Ville Linde
DASM code snippets:
DASM code snippets:
00FE0B8C: addi r31,r3,0x0000
00FE0B90: lwz r3,0x0040(r1)
00FE0B94: cmpi r31,0x0000 ;offending check, understand where r3 comes from!
00FE0B98: lwz r4,0x0044(r1)
00FE0B9C: addic r5,r1,0x0058
00FE0BA0: bne 0x00FE0C00
00FE0B8C: addi r31,r3,0x0000
00FE0B90: lwz r3,0x0040(r1)
00FE0B94: cmpi r31,0x0000 ;offending check, understand where r3 comes from!
00FE0B98: lwz r4,0x0044(r1)
00FE0B9C: addic r5,r1,0x0058
00FE0BA0: bne 0x00FE0C00
*/

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

@ -675,13 +675,13 @@ static WRITE8_HANDLER( hotchase_sound_control_w )
{
device_t *sound[3];
// int reg[8];
// int reg[8];
sound[0] = space->machine().device("konami1");
sound[1] = space->machine().device("konami2");
sound[2] = space->machine().device("konami3");
// reg[offset] = data;
// reg[offset] = data;
switch (offset)
{

14
src/mame/includes/rltennis.h
View File

@ -17,29 +17,29 @@ public:
UINT8 *m_palette;
INT32 m_palpos_r;
INT32 m_palpos_w;
INT32 m_data760000;
INT32 m_data740000;
INT32 m_dac_counter;
INT32 m_dac_counter;
INT32 m_sample_rom_offset_1;
INT32 m_sample_rom_offset_2;
INT32 m_offset_shift;
INT32 m_unk_counter;
bitmap_t *m_tmp_bitmap[RLT_NUM_BITMAPS];
device_t *m_dac_1;
device_t *m_dac_2;
UINT8 *m_samples_1;
UINT8 *m_samples_2;
UINT8 *m_gfx;
emu_timer *m_timer;
};

10
src/mame/machine/archimds.c
View File

@ -167,15 +167,15 @@ static TIMER_CALLBACK( vidc_audio_tick )
5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
876, 844, 812, 780, 748, 716, 684, 652,
876, 844, 812, 780, 748, 716, 684, 652,
620, 588, 556, 524, 492, 460, 428, 396,
372, 356, 340, 324, 308, 292, 276, 260,
372, 356, 340, 324, 308, 292, 276, 260,
244, 228, 212, 196, 180, 164, 148, 132,
120, 112, 104, 96, 88, 80, 72, 64,
56, 48, 40, 32, 24, 16, 8, 0
};
};
for(ch=0;ch<8;ch++)
{
@ -1004,7 +1004,7 @@ WRITE32_HANDLER(archimedes_memc_page_w)
{
UINT32 log, phys, memc;
// perms = (data & 0x300)>>8;
// perms = (data & 0x300)>>8;
log = phys = memc = 0;
switch (memc_pagesize)

22
src/mame/machine/cdicdic.c
View File

@ -779,7 +779,7 @@ void cdicdic_device::process_delayed_command()
UINT32 next_msf = increment_cdda_frame_bcd((m_time & 0xffff7f00) >> 8);
UINT32 rounded_next_msf = increment_cdda_sector_bcd((m_time & 0xffff0000) >> 8);
UINT32 lba = 0;
// UINT32 next_lba = 0;
// UINT32 next_lba = 0;
UINT8 nybbles[6] =
{
msf & 0x0000000f,
@ -789,15 +789,15 @@ void cdicdic_device::process_delayed_command()
(msf & 0x000f0000) >> 16,
(msf & 0x00f00000) >> 20
};
/* UINT8 next_nybbles[6] =
{
rounded_next_msf & 0x0000000f,
(rounded_next_msf & 0x000000f0) >> 4,
(rounded_next_msf & 0x00000f00) >> 8,
(rounded_next_msf & 0x0000f000) >> 12,
(rounded_next_msf & 0x000f0000) >> 16,
(rounded_next_msf & 0x00f00000) >> 20
};*/
/* UINT8 next_nybbles[6] =
{
rounded_next_msf & 0x0000000f,
(rounded_next_msf & 0x000000f0) >> 4,
(rounded_next_msf & 0x00000f00) >> 8,
(rounded_next_msf & 0x0000f000) >> 12,
(rounded_next_msf & 0x000f0000) >> 16,
(rounded_next_msf & 0x00f00000) >> 20
};*/
lba = nybbles[0] + nybbles[1]*10 + ((nybbles[2] + nybbles[3]*10)*75) + ((nybbles[4] + nybbles[5]*10)*75*60);
@ -808,7 +808,7 @@ void cdicdic_device::process_delayed_command()
if(!(msf & 0x0000ff))
{
// next_lba = next_nybbles[0] + next_nybbles[1]*10 + ((next_nybbles[2] + next_nybbles[3]*10)*75) + ((next_nybbles[4] + next_nybbles[5]*10)*75*60);
// next_lba = next_nybbles[0] + next_nybbles[1]*10 + ((next_nybbles[2] + next_nybbles[3]*10)*75) + ((next_nybbles[4] + next_nybbles[5]*10)*75*60);
verboselog(machine(), 0, "Playing CDDA sector from MSF location %06x\n", m_time | 2 );
cdda_start_audio(machine().device("cdda"), lba, rounded_next_msf);

16
src/mame/machine/megadriv.c
View File

@ -7536,12 +7536,12 @@ static void genesis_render_videoline_to_videobuffer(int scanline)
UINT16 hsize = 64;
UINT16 vsize = 64;
UINT16 window_right;
// UINT16 window_hpos;
// UINT16 window_hpos;
UINT16 window_down;
// UINT16 window_vpos;
// UINT16 window_vpos;
UINT16 hscroll_base;
// UINT8 vscroll_mode;
// UINT8 hscroll_mode;
// UINT8 vscroll_mode;
// UINT8 hscroll_mode;
int window_firstline;
int window_lastline;
int window_firstcol;
@ -7586,9 +7586,9 @@ static void genesis_render_videoline_to_videobuffer(int scanline)
base_b = MEGADRIVE_REG04_PATTERN_ADDR_B << 13;
size = MEGADRIVE_REG10_HSCROLL_SIZE | (MEGADRIVE_REG10_VSCROLL_SIZE<<4);
window_right = MEGADRIVE_REG11_WINDOW_RIGHT;
// window_hpos = MEGADRIVE_REG11_WINDOW_HPOS;
// window_hpos = MEGADRIVE_REG11_WINDOW_HPOS;
window_down = MEGADRIVE_REG12_WINDOW_DOWN;
// window_vpos = MEGADRIVE_REG12_WINDOW_VPOS;
// window_vpos = MEGADRIVE_REG12_WINDOW_VPOS;
screenwidth = MEGADRIVE_REG0C_RS0 | (MEGADRIVE_REG0C_RS1 << 1);
@ -9487,10 +9487,10 @@ int megadrive_z80irq_hpos = 320;
if (0)
{
//int xxx;
// UINT64 frametime;
// UINT64 frametime;
// /* reference */
// frametime = ATTOSECONDS_PER_SECOND/megadriv_framerate;
// frametime = ATTOSECONDS_PER_SECOND/megadriv_framerate;
//time_elapsed_since_crap = frame_timer->time_elapsed();
//xxx = machine.device<cpudevice>("maincpu")->attotime_to_cycles(time_elapsed_since_crap);

4
src/mame/machine/model1.c
View File

@ -1059,7 +1059,7 @@ static TGP_FUNCTION( track_lookup )
dist = -1;
// behaviour = 0;
// behaviour = 0;
height = 0.0;
entry = 0;
@ -1080,7 +1080,7 @@ static TGP_FUNCTION( track_lookup )
float d = (a-z)*(a-z);
if(dist == -1 || d<dist) {
dist = d;
// behaviour = tgp_data[posd+15];
// behaviour = tgp_data[posd+15];
height = z;
entry = bpos+i;
}

4
src/mame/machine/n64.c
View File

@ -1654,7 +1654,7 @@ static int pif_channel_handle_command(running_machine &machine, int channel, int
mame_printf_debug("\n");*/
address = (sdata[1] << 8) | (sdata[2]);
// checksum = address & 0x1f;
// checksum = address & 0x1f;
address &= ~0x1f;
if (address == 0x400)
@ -1691,7 +1691,7 @@ static int pif_channel_handle_command(running_machine &machine, int channel, int
mame_printf_debug("\n");*/
address = (sdata[1] << 8) | (sdata[2]);
// checksum = address & 0x1f;
// checksum = address & 0x1f;
address &= ~0x1f;
if (address == 0x8000)

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

@ -1223,7 +1223,7 @@ WRITE64_DEVICE_HANDLER( naomibd_w )
static void load_rom_gdrom(running_machine& machine, naomibd_state *v)
{
// UINT32 result;
// UINT32 result;
cdrom_file *gdromfile;
UINT8 buffer[2048];
UINT8 *ptr;

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

@ -109,7 +109,7 @@ INTERRUPT_GEN( psx_vblank )
{
psxgpu_device *gpu = downcast<psxgpu_device *>( device->machine().device("gpu") );
psx_state *p_psx = device->machine().driver_data<psx_state>();
if(p_psx->b_need_sianniv_vblank_hack)
{
UINT32 pc = cpu_get_pc(device);

4
src/mame/machine/seicop.c
View File

@ -2416,14 +2416,14 @@ static WRITE16_HANDLER( generic_cop_w )
{
UINT8 offs;
int div;
// INT16 offs_val;
// INT16 offs_val;
//printf("%08x %08x %08x %08x %08x %08x %08x\n",cop_register[0],cop_register[1],cop_register[2],cop_register[3],cop_register[4],cop_register[5],cop_register[6]);
offs = (offset & 3) * 4;
div = space->read_word(cop_register[4] + offs) + 1;
// offs_val = space->read_word(cop_register[3] + offs);
// offs_val = space->read_word(cop_register[3] + offs);
//420 / 180 = 500 : 400 = 30 / 50 = 98 / 18
if(div == 0) { div = 1; }

4
src/mame/machine/stvcd.c
View File

@ -577,7 +577,7 @@ static void cd_writeWord(running_machine &machine, UINT32 addr, UINT16 data)
// CDROM_LOG(("WW CR4: %04x\n", data))
cr4 = data;
if(cr1 != 0 && 0)
printf("CD: command exec %02x %02x %02x %02x %02x (stat %04x)\n", hirqreg, cr1, cr2, cr3, cr4, cd_stat);
printf("CD: command exec %02x %02x %02x %02x %02x (stat %04x)\n", hirqreg, cr1, cr2, cr3, cr4, cd_stat);
if (!cdrom)
{
@ -1891,7 +1891,7 @@ static void cd_playdata(void)
{
if (fadstoplay)
{
logerror("STVCD: Reading FAD %d\n", cd_curfad);
logerror("STVCD: Reading FAD %d\n", cd_curfad);
if (cdrom)
{

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

@ -683,7 +683,7 @@ void amiga_render_scanline(running_machine &machine, bitmap_t *bitmap, int scanl
hires = CUSTOM_REG(REG_BPLCON0) & BPLCON0_HIRES;
ham = CUSTOM_REG(REG_BPLCON0) & BPLCON0_HOMOD;
dualpf = CUSTOM_REG(REG_BPLCON0) & BPLCON0_DBLPF;
// lace = CUSTOM_REG(REG_BPLCON0) & BPLCON0_LACE;
// lace = CUSTOM_REG(REG_BPLCON0) & BPLCON0_LACE;
/* compute the pixel fetch parameters */
ddf_start_pixel = ( CUSTOM_REG(REG_DDFSTRT) & 0xfc ) * 2 + (hires ? 9 : 17);

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

@ -512,7 +512,7 @@ void amiga_aga_render_scanline(running_machine &machine, bitmap_t *bitmap, int s
hires = CUSTOM_REG(REG_BPLCON0) & BPLCON0_HIRES;
ham = CUSTOM_REG(REG_BPLCON0) & BPLCON0_HOMOD;
dualpf = CUSTOM_REG(REG_BPLCON0) & BPLCON0_DBLPF;
// lace = CUSTOM_REG(REG_BPLCON0) & BPLCON0_LACE;
// lace = CUSTOM_REG(REG_BPLCON0) & BPLCON0_LACE;
/* get default bitoffset */
switch(CUSTOM_REG(REG_FMODE) & 0x3)

10
src/mame/video/dc.c
View File

@ -1632,12 +1632,12 @@ WRITE64_HANDLER( ta_fifo_poly_w )
WRITE64_HANDLER( ta_fifo_yuv_w )
{
// int reg;
// UINT64 shift;
// UINT32 dat;
// int reg;
// UINT64 shift;
// UINT32 dat;
// reg = decode_reg_64(offset, mem_mask, &shift);
// dat = (UINT32)(data >> shift);
// reg = decode_reg_64(offset, mem_mask, &shift);
// dat = (UINT32)(data >> shift);
// printf("YUV FIFO: [%08x=%x] write %" I64FMT "x to %x, mask %" I64FMT "x %08x\n", 0x10800000+reg*4, dat, data, offset, mem_mask,test);
}

8
src/mame/video/gtia.c
View File

@ -387,12 +387,12 @@ static void recalc_m3(void)
WRITE8_HANDLER( atari_gtia_w )
{
/* used for mixing hue/lum of different colors */
// static UINT8 lumpm0=0,lumpm1=0,lumpm2=0,lumpm3=0,lumpm4=0;
// static UINT8 lumpm0=0,lumpm1=0,lumpm2=0,lumpm3=0,lumpm4=0;
static UINT8 lumpf1=0;
// static UINT8 lumpf2=0;
// static UINT8 lumbk= 0;
// static UINT8 lumpf2=0;
// static UINT8 lumbk= 0;
static UINT8 huepm0=0,huepm1=0,huepm2=0,huepm3=0,huepm4=0;
// static UINT8 huepf1=0;
// static UINT8 huepf1=0;
static UINT8 huepf2=0,huebk= 0;
switch (offset & 31)

4
src/mame/video/konamigx.c
View File

@ -510,8 +510,8 @@ INLINE void zdrawgfxzoom32GP(
// adjust insertion points and pre-entry constants
eax = (dst_y - dst_miny) * GX_ZBUFW + (dst_x - dst_minx) + dst_w;
// db0 = z8 = (UINT8)zcode;
// db1 = p8 = (UINT8)pri;
// db0 = z8 = (UINT8)zcode;
// db1 = p8 = (UINT8)pri;
ozbuf_ptr += eax;
szbuf_ptr += eax << 1;
dst_ptr += dst_y * dst_pitch + dst_x + dst_w;

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

@ -9013,7 +9013,7 @@ static void k001005_render_polygons( device_t *device )
if (k001005->_3d_fifo[i] == 0x80000003)
{
poly_extra_data *extra = (poly_extra_data *)poly_get_extra_data(k001005->poly);
// poly_vertex v[4];
// poly_vertex v[4];
int r, g, b, a;
UINT32 color;
int index = i;

6
src/mame/video/model1.c
View File

@ -950,8 +950,8 @@ static UINT16 *push_direct(model1_state *state, UINT16 *list)
struct quad_m1 cquad;
tex_adr = readi(list);
// v1 = readi(list+2);
// v2 = readi(list+10);
// v1 = readi(list+2);
// v2 = readi(list+10);
old_p0 = state->m_pointpt++;
old_p1 = state->m_pointpt++;
@ -999,7 +999,7 @@ static UINT16 *push_direct(model1_state *state, UINT16 *list)
p1 = state->m_pointpt++;
lum = readi(list+2);
// v1 = readi(list+4);
// v1 = readi(list+4);
if(type == 2) {
p0->x = readf(list+6);

10
src/mame/video/model2.c
View File

@ -2501,11 +2501,11 @@ static UINT32 * geo_end( geo_state *geo, UINT32 opcode, UINT32 *input )
/* Command 10: Dummy */
static UINT32 * geo_dummy( geo_state *geo, UINT32 opcode, UINT32 *input )
{
// UINT32 data;
// UINT32 data;
(void)opcode;
/* do the dummy read cycle */
// data = *input++;
// data = *input++;
input++;
return input;
@ -2571,7 +2571,7 @@ static UINT32 * geo_code_upload( geo_state *geo, UINT32 opcode, UINT32 *input )
(void)opcode;
/* read in the flags */
// flags = *input++;
// flags = *input++;
input++;
/* read in the count */
@ -2606,7 +2606,7 @@ static UINT32 * geo_code_upload( geo_state *geo, UINT32 opcode, UINT32 *input )
/* Command 1E: Code Jump (undocumented, unsupported) */
static UINT32 * geo_code_jump( geo_state *geo, UINT32 opcode, UINT32 *input )
{
// UINT32 address;
// UINT32 address;
/*
This command jumps to a specified address in program
@ -2620,7 +2620,7 @@ static UINT32 * geo_code_jump( geo_state *geo, UINT32 opcode, UINT32 *input )
(void)opcode;
// address = *input++ & 0x3FF;
// address = *input++ & 0x3FF;
input++;
/*

24
src/mame/video/n64.c
View File

@ -349,7 +349,7 @@ void Processor::TCDiv(INT32 ss, INT32 st, INT32 sw, INT32* sss, INT32* sst)
}
//compute clamp flags
int under_s = 0;
// int under_t = 0;
// int under_t = 0;
int over_s = 0;
int over_t = 0;
@ -369,7 +369,7 @@ void Processor::TCDiv(INT32 ss, INT32 st, INT32 sw, INT32* sss, INT32* sst)
{
if (tprod & (1 << 29))
{
// under_t = 1;
// under_t = 1;
}
else
{
@ -2784,16 +2784,16 @@ void N64::RDP::Processor::CmdLoadTile(UINT32 w1, UINT32 w2)
INT32 width = (sh - sl) + 1;
INT32 height = (th - tl) + 1;
/*
int topad;
if (m_misc_state.m_ti_size < 3)
{
topad = (width * m_misc_state.m_ti_size) & 0x7;
}
else
{
topad = (width << 2) & 0x7;
}
topad = 0; // ????
int topad;
if (m_misc_state.m_ti_size < 3)
{
topad = (width * m_misc_state.m_ti_size) & 0x7;
}
else
{
topad = (width << 2) & 0x7;
}
topad = 0; // ????
*/
switch (m_misc_state.m_ti_size)
{

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

@ -1780,7 +1780,7 @@ static void
BlitQuads( running_machine &machine, bitmap_t *bitmap, INT32 addr, float m[4][4], INT32 base )
{
namcos22_state *state = machine.driver_data<namcos22_state>();
// int numAdditionalNormals = 0;
// int numAdditionalNormals = 0;
int chunkLength = GetPolyData(state, addr++);
int finish = addr + chunkLength;
@ -1857,7 +1857,7 @@ BlitQuads( running_machine &machine, bitmap_t *bitmap, INT32 addr, float m[4][4]
000000 000000 007fff // normal vector
000000 000000 007fff // normal vector
*/
// numAdditionalNormals = GetPolyData(state, addr+2);
// numAdditionalNormals = GetPolyData(state, addr+2);
state->m_mSurfaceNormalFormat = GetPolyData(state, addr+3);
state->m_mLitSurfaceCount = 0;
state->m_mLitSurfaceIndex = 0;
@ -2127,7 +2127,7 @@ SimulateSlaveDSP( running_machine &machine, bitmap_t *bitmap )
/* hackery! commands should be streamed, not parsed here */
pSource += len;
// marker = (INT16)*pSource++; /* always 0xffff */
// marker = (INT16)*pSource++; /* always 0xffff */
pSource++;
next = (INT16)*pSource++; /* link to next command */
if( (next&0x7fff) != (pSource - (INT32 *)state->m_polygonram) )

84
src/mame/video/rltennis.c
View File

@ -1,73 +1,73 @@
/****************************************************************************************
Reality Tennis - (c) 1993 TCH
Blitter registers description (reg/bit names selected arbitrary ) :
700000 - BLT_X_START
JOANA JOAQUIN
fedcba98 76543210
JOANA JOAQUIN
fedcba98 76543210
-------- xxxxxxxx dst x start
xxxxxxxx -------- src x start
700002 - BLT_X_END
JOANA JOAQUIN
JOANA JOAQUIN
fedcba98 76543210
-------- xxxxxxxx dst x end
xxxxxxxx -------- src x end
700004 - BLT_Y_START
JOANA JOAQUIN
fedcba98 76543210 x start
JOANA JOAQUIN
fedcba98 76543210 x start
-------- xxxxxxxx
xxxxxxxx --------
700006 - BLT_Y_END
JOANA JOAQUIN
fedcba98 76543210 x start
JOANA JOAQUIN
fedcba98 76543210 x start
-------- xxxxxxxx
xxxxxxxx --------
700008 - BLT_FLAGS
JOANA JOAQUIN
fedcba98 76543210
-------- -------x BLTFLAG_DST_X_DIR x dst direction (step inc or dec)
-------- ------x- BLTFLAG_DST_Y_DIR y dst direction
-------- -----x-- BLTFLAG_DST_LR LR and UD controlls the quarter of framebuffer to use
-------- -----x-- BLTFLAG_DST_LR LR and UD controlls the quarter of framebuffer to use
-------- ----x--- BLTFLAG_DST_UD /
-------- ---?---- unknown
-------- --x----- BLTFLAG_DISPLAY_UD display buffer select
-------- --x----- BLTFLAG_DISPLAY_UD display buffer select
-------- ??------ unknown
-------x -------- BLTFLAG_SRC_X_DIR x src direction
------x- -------- BLTFLAG_SRC_Y_DIR y src direction
-----x-- -------- BLTFLAG_SRC_LR LR and UD controlls the quarter of src buffer to use
-----x-- -------- BLTFLAG_SRC_LR LR and UD controlls the quarter of src buffer to use
----x--- -------- BLTFLAG_SRC_UD /
xxxx---- -------- src ROM num
xxxx---- -------- src ROM num
70000a - BLT_UNK
JOANA JOAQUIN
fedcba98 76543210
???????? ???????? unknown (used during gameplay ... zoom factors ?)
70000c - BLT_START
fedcba98 76543210
--?????- ???????? unknown
-------x -------- BLTSTRT_ROM_MSB src ROM MSB
-x------ -------- BLTSTRT_TRIGGER blit start
-x------ -------- BLTSTRT_TRIGGER blit start
x------- -------- BLTSTRT_LAYER FG or BG layer of framebuffer
70000e - BLT_UNK2
JOANA JOAQUIN
fedcba98 76543210
???????? ???????? unknown (set to 0 @ boot)
???????? ???????? unknown (set to 0 @ boot)
****************************************************************************************/
#include "emu.h"
#include "includes/rltennis.h"
@ -117,7 +117,7 @@ WRITE16_HANDLER(rlt_blitter_w)
int old_data=state->m_blitter[offset];
COMBINE_DATA(&state->m_blitter[offset]);
int new_data=state->m_blitter[offset];
if(offset==BLT_FLAGS && ((new_data^old_data) & BLTFLAG_DISPLAY_UD) ) /* visible page flip and clear */
{
if(new_data & BLTFLAG_DISPLAY_UD)
@ -144,7 +144,7 @@ WRITE16_HANDLER(rlt_blitter_w)
int dst_x1=(state->m_blitter[BLT_X_END]&0xff);
int dst_y1=(state->m_blitter[BLT_Y_END]&0xff);
int src_x1=((state->m_blitter[BLT_X_END]>>SRC_SHIFT)&0xff)+((state->m_blitter[BLT_FLAGS] & BLTFLAG_SRC_LR)?256:0);
int src_y1=((state->m_blitter[BLT_Y_END]>>SRC_SHIFT)&0xff)+((state->m_blitter[BLT_FLAGS]>>3)&0xff00)+(((state->m_blitter[BLT_START]) & BLTSTRT_ROM_MSB)?(1<<0xd):0);
@ -155,39 +155,39 @@ WRITE16_HANDLER(rlt_blitter_w)
int y_src_step=(state->m_blitter[BLT_FLAGS] & BLTFLAG_SRC_Y_DIR)?1:-1;
int x,y;
int idx_x,idx_y;
int blit_w=src_x1-src_x0;
int blit_h=src_y1-src_y0;
int blit_w1=dst_x1-dst_x0;
int blit_h1=dst_y1-dst_y0;
if(blit_w1<0) blit_w1=(-blit_w1)^0xff; /* is it correct ? game does that when flips images */
if(blit_h1<0) blit_h1=-blit_h1;
if(blit_w<0) blit_w=-blit_w;
if(blit_h<0) blit_h=-blit_h;
{
/* wrong, causes gfx glitches (wrong size , but gives (so far) the best results */
if(blit_w1<blit_w) blit_w1=blit_w;
/* wrong, causes gfx glitches (wrong size , but gives (so far) the best results */
if(blit_w1<blit_w) blit_w1=blit_w;
if(blit_h1<blit_h) blit_h1=blit_h;
}
int layer=(state->m_blitter[BLT_START] & BLTSTRT_LAYER )?BITMAP_BG:BITMAP_FG_1;
if(layer==BITMAP_FG_1)
{
if(state->m_blitter[BLT_FLAGS] & BLTFLAG_DST_UD )
if(state->m_blitter[BLT_FLAGS] & BLTFLAG_DST_UD )
{
layer=BITMAP_FG_2;
}
}
bool force_blit=false;
if(blit_w==1 && blit_h==1) /* seems to be bg layer color fill */
{
force_blit=true;
@ -200,7 +200,7 @@ WRITE16_HANDLER(rlt_blitter_w)
int xx=src_x0+(x_src_step*idx_x);
int yy=src_y0+(y_src_step*idx_y);
if(force_blit)
{
xx=src_x0;
@ -255,7 +255,7 @@ READ16_HANDLER( rlt_ramdac_data_r )
rltennis_state *state = space->machine().driver_data<rltennis_state>();
int data=state->m_palette[state->m_palpos_r];
++state->m_palpos_r;
state->m_palpos_r %=256*3;
state->m_palpos_r %=256*3;
return data;
}
@ -274,4 +274,4 @@ SCREEN_UPDATE( rltennis )
copybitmap(bitmap, state->m_tmp_bitmap[BITMAP_BG], 0, 0, 0, 0, cliprect);
copybitmap_trans(bitmap, state->m_tmp_bitmap[BITMAP_FG_DISPLAY], 0, 0, 0, 0, cliprect, 0);
return 0;
}
}

8
src/mame/video/stvvdp2.c
View File

@ -3859,14 +3859,14 @@ static void stv_vdp2_check_tilemap_with_linescroll(running_machine &machine, bit
int scroll_values_equal;
int lines;
INT16 scrollx, scrolly;
// INT32 incx;
// INT32 incx;
int linescroll_enable, vertical_linescroll_enable, linezoom_enable;
int vertical_linescroll_index = -1;
// read original scroll values
scrollx = stv2_current_tilemap.scrollx;
scrolly = stv2_current_tilemap.scrolly;
// incx = stv2_current_tilemap.incx;
// incx = stv2_current_tilemap.incx;
// prepare linescroll flags
linescroll_enable = stv2_current_tilemap.linescroll_enable;
@ -3965,11 +3965,11 @@ static void stv_vdp2_check_tilemap_with_linescroll(running_machine &machine, bit
{
prev_scroll_values[i] &= 0x0007ff00;
if ( prev_scroll_values[i] & 0x00040000 ) prev_scroll_values[i] |= 0xfff80000;
// incx = prev_scroll_values[i];
// incx = prev_scroll_values[i];
i++;
}
// if ( LOG_VDP2 ) logerror( "Linescroll: y < %d, %d >, scrollx = %d, scrolly = %d, incx = %f\n", mycliprect.min_y, mycliprect.max_y, stv2_current_tilemap.scrollx, stv2_current_tilemap.scrolly, (float)stv2_current_tilemap.incx/65536.0 );
// if ( LOG_VDP2 ) logerror( "Linescroll: y < %d, %d >, scrollx = %d, scrolly = %d, incx = %f\n", mycliprect.min_y, mycliprect.max_y, stv2_current_tilemap.scrollx, stv2_current_tilemap.scrolly, (float)stv2_current_tilemap.incx/65536.0 );
// render current tilemap portion
stv_vdp2_check_tilemap(machine, bitmap, &mycliprect );

8
src/mame/video/tx1.c
View File

@ -1570,7 +1570,7 @@ static void buggyboy_draw_road(running_machine &machine, UINT8 *bitmap)
UINT32 bnkcs = 1;
UINT32 bnkrs = 1;
// UINT32 x_offs;
// UINT32 x_offs;
UINT8 sf;
/* Vertical positions shift register */
@ -1634,7 +1634,7 @@ static void buggyboy_draw_road(running_machine &machine, UINT8 *bitmap)
sld = (vprom[rva0_6] + vregs.slin_val) & 0x38;
/* Determine the x-offset */
// x_offs = ls161 & 7;
// x_offs = ls161 & 7;
/* Fill vertical position shift register with bits for this line */
/* TODO; cheated slightly to shift stuff up one pixel*/
@ -2200,7 +2200,7 @@ static void buggybjr_draw_road(running_machine &machine, UINT8 *bitmap, int wide
UINT32 rcmd;
UINT32 bnkcs = 1;
// UINT32 x_offs;
// UINT32 x_offs;
UINT8 sf;
/* Vertical positions shift register */
@ -2259,7 +2259,7 @@ static void buggybjr_draw_road(running_machine &machine, UINT8 *bitmap, int wide
sld = (vprom[rva0_6] + vregs.slin_val) & 0x38;
/* Determine the x-offset */
// x_offs = ls161 & 7;
// x_offs = ls161 & 7;
/* Fill vertical position shift register with bits for this line */
/* TODO; cheated slightly to shift stuff up one pixel*/

10
src/mame/video/wgp.c
View File

@ -355,7 +355,7 @@ static void draw_sprites( running_machine &machine, bitmap_t *bitmap, const rect
int zx, zy, zoomx, zoomy, priority = 0;
UINT8 small_sprite, col, flipx, flipy;
UINT16 code, bigsprite, map_index;
// UINT16 rotate = 0;
// UINT16 rotate = 0;
UINT16 tile_mask = (machine.gfx[0]->total_elements) - 1;
static const int primasks[2] = {0x0, 0xfffc}; /* fff0 => under rhs of road only */
@ -378,10 +378,10 @@ static void draw_sprites( running_machine &machine, bitmap_t *bitmap, const rect
if ((spriteram[i + 4] == 0xfff6) && (spriteram[i + 5] == 0))
continue;
// if (((spriteram[i + 4] != 0xf800) && (spriteram[i + 4] != 0xfff6))
// || ((spriteram[i + 5] != 0xf800) && (spriteram[i + 5] != 0))
// || spriteram[i + 7] != 0)
// rotate = i << 1;
// if (((spriteram[i + 4] != 0xf800) && (spriteram[i + 4] != 0xfff6))
// || ((spriteram[i + 5] != 0xf800) && (spriteram[i + 5] != 0))
// || spriteram[i + 7] != 0)
// rotate = i << 1;
/***** Begin zoom kludge ******/

4
src/osd/sdl/debugwin.c
View File

@ -781,7 +781,7 @@ static void memorywin_new(running_machine &machine)
downcast<debug_view_memory *>(mem->views[0]->view)->set_expression("0");
// populate the combobox
// cursel = 0;
// cursel = 0;
item = 0;
for (const debug_view_source *source = mem->views[0]->view->source_list().head(); source != NULL; source = source->next())
@ -878,7 +878,7 @@ static void disasmwin_new(running_machine &machine)
downcast<debug_view_disasm *>(dis->views[0]->view)->set_expression("curpc");
// populate the combobox
// cursel = 0;
// cursel = 0;
item = 0;
for (const debug_view_source *source = dis->views[0]->view->source_list().head(); source != NULL; source = source->next())
{

2
src/osd/sdl/drawsdl.c
View File

@ -677,7 +677,7 @@ static int drawsdl_window_draw(sdl_window_info *window, UINT32 dc, int update)
rmask = sdl->sdlsurf->format->Rmask;
gmask = sdl->sdlsurf->format->Gmask;
bmask = sdl->sdlsurf->format->Bmask;
// amask = sdl->sdlsurf->format->Amask;
// amask = sdl->sdlsurf->format->Amask;
if (window->blitwidth != sdl->old_blitwidth || window->blitheight != sdl->old_blitheight)
{

2
src/osd/windows/d3dhlsl.h
View File

@ -151,7 +151,7 @@ private:
void end_avi_recording();
void begin_avi_recording(const char *name);
bool screen_encountered[9]; // whether a given screen was encountered this frame
bool screen_encountered[9]; // whether a given screen was encountered this frame
d3d * d3dintf; // D3D interface
win_window_info * window; // D3D window info

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

@ -333,8 +333,8 @@ const options_entry windows_options::s_option_entries[] =
{ WINOPTION_HLSL_PRESCALE_SIZE, "3", OPTION_INTEGER, "HLSL scaling pre-pass factor (usually 2 or 3)" },
{ WINOPTION_HLSL_PRESET";(-1-5)", "-1", OPTION_INTEGER, "HLSL preset to use (0-5)" },
{ WINOPTION_HLSL_WRITE, NULL, OPTION_STRING, "enable HLSL AVI writing (huge disk bandwidth suggested)" },
{ WINOPTION_HLSL_SNAP_WIDTH, "2048", OPTION_STRING, "HLSL upscaled-snapshot width" },
{ WINOPTION_HLSL_SNAP_HEIGHT, "1536", OPTION_STRING, "HLSL upscaled-snapshot height" },
{ WINOPTION_HLSL_SNAP_WIDTH, "2048", OPTION_STRING, "HLSL upscaled-snapshot width" },
{ WINOPTION_HLSL_SNAP_HEIGHT, "1536", OPTION_STRING, "HLSL upscaled-snapshot height" },
{ WINOPTION_SHADOW_MASK_ALPHA";fs_shadwa(0.0-1.0)", "0.0", OPTION_FLOAT, "shadow mask alpha-blend value (1.0 is fully blended, 0.0 is no mask)" },
{ WINOPTION_SHADOW_MASK_TEXTURE";fs_shadwt(0.0-1.0)", "aperture.png", OPTION_STRING, "shadow mask texture name" },
{ WINOPTION_SHADOW_MASK_COUNT_X";fs_shadww", "640", OPTION_INTEGER, "shadow mask width, in phosphor dots" },

2
src/version.c
View File

@ -38,4 +38,4 @@
***************************************************************************/
extern const char build_version[];
const char build_version[] = "0.142u4 ("__DATE__")";
const char build_version[] = "0.142u5 ("__DATE__")";