void sns_rom_bsx_device::bsx_base::write(uint32_t offset, uint8_t data)
{
offset &= 0xffff;
if (offset < 0x2188 || offset >= 0x21a0)
{
osd_printf_debug("BS-X Base Unit reg write outside correct range!\n");
return;
}
switch(offset)
{
// no 218d? no 2190? no 2195? no 2196? no 2198? no 219a-219f?
case 0x218f:
regs[6] >>= 1; // 0x218e
regs[6] = regs[7] - regs[6]; // 0x218f - 0x218e
regs[7] >>= 1; // 0x218f
break;
case 0x2191:
regs[offset - 0x2188] = data;
r2192_counter = 0;
break;
case 0x2192:
regs[8] = data; // sets 0x2190
break;
default:
regs[offset - 0x2188] = data;
break;
}
}
uint8_t sns_rom_bsx_device::bsx_base::read(uint32_t offset)
{
offset &= 0xffff;
if (offset < 0x2188 || offset >= 0x21a0)
{
osd_printf_debug("BS-X Base Unit reg read outside correct range!\n");
return 0x00;
}
switch (offset)
{
// no 218b? no 218d? no 2191? no 2195? no 219a-219f?
case 0x2192:
{
uint8_t counter = r2192_counter++;
if (r2192_counter >= 18)
r2192_counter = 0;
if (counter == 0)
{
system_time curtime, *systime = &curtime;
m_machine.current_datetime(curtime);
r2192_hour = systime->local_time.hour;
r2192_minute = systime->local_time.minute;
r2192_second = systime->local_time.second;
}
switch (counter)
{
case 0: return 0x00; //???
case 1: return 0x00; //???
case 2: return 0x00; //???
case 3: return 0x00; //???
case 4: return 0x00; //???
case 5: return 0x01;
case 6: return 0x01;
case 7: return 0x00;
case 8: return 0x00;
case 9: return 0x00;
case 10: return r2192_second;
case 11: return r2192_minute;
case 12: return r2192_hour;
case 13: return 0x00; //???
case 14: return 0x00; //???
case 15: return 0x00; //???
case 16: return 0x00; //???
case 17: return 0x00; //???
}
}
break;
case 0x2193:
return regs[offset - 0x2188] & ~0x0c;
default:
return regs[offset - 0x2188];
}
return 0x00;
}
void gottlieb_sound_r1_device::fake_votrax_data_w(UINT8 data)
{
static const char *const PhonemeTable[0x40] =
{
"EH3", "EH2", "EH1", "PA0", "DT" , "A1" , "A2" , "ZH",
"AH2", "I3" , "I2" , "I1" , "M" , "N" , "B" , "V",
"CH" , "SH" , "Z" , "AW1", "NG" , "AH1", "OO1", "OO",
"L" , "K" , "J" , "H" , "G" , "F" , "D" , "S",
"A" , "AY" , "Y1" , "UH3", "AH" , "P" , "O" , "I",
"U" , "Y" , "T" , "R" , "E" , "W" , "AE" , "AE1",
"AW2", "UH2", "UH1", "UH" , "O2" , "O1" , "IU" , "U1",
"THV", "TH" , "ER" , "EH" , "E1" , "AW" , "PA1", "STOP"
};
data ^= 0xff;
logerror("Votrax: intonation %d, phoneme %02x %s\n",data >> 6,data & 0x3f,PhonemeTable[data & 0x3f]);
m_votrax_queue[m_votrax_queuepos++] = data;
if ((data & 0x3f) == 0x3f)
{
if (m_votrax_queuepos > 1)
{
int last = -1;
int i;
char phonemes[200];
phonemes[0] = 0;
for (i = 0;i < m_votrax_queuepos-1;i++)
{
static const char *const inf[4] = { "[0]", "[1]", "[2]", "[3]" };
int phoneme = m_votrax_queue[i] & 0x3f;
int inflection = m_votrax_queue[i] >> 6;
if (inflection != last) strcat(phonemes, inf[inflection]);
last = inflection;
if (phoneme == 0x03 || phoneme == 0x3e) strcat(phonemes," ");
else strcat(phonemes,PhonemeTable[phoneme]);
}
osd_printf_debug("Votrax played '%s'\n", phonemes);
if (strcmp(phonemes, "[0] HEH3LOOW AH1EH3I3YMTERI2NDAHN") == 0) /* Q-Bert & Tylz - Hello, I am turned on */
m_samples->start(0, 42);
else if (strcmp(phonemes, "[0]BAH1EH1Y") == 0) /* Q-Bert - Bye, bye */
m_samples->start(0, 43);
else if (strcmp(phonemes, "[0]A2YHT LEH2FTTH") == 0) /* Reactor - Eight left */
m_samples->start(0, 0);
else if (strcmp(phonemes, "[0]SI3KS DTYN LEH2FTTH") == 0) /* Reactor - Sixteen left */
m_samples->start(0, 1);
else if (strcmp(phonemes, "[0]WO2RNYNG KO2R UH1NSDTABUH1L") == 0) /* Reactor - Warning core unstable */
m_samples->start(0, 5);
else if (strcmp(phonemes, "[0]CHAMBERR AE1EH2KTI1VA1I3DTEH1DT ") == 0) /* Reactor - Chamber activated */
m_samples->start(0, 7);
}
m_votrax_queuepos = 0;
}
void alpha8201_cpu_device::M_UNDEFINED()
{
logerror("alpha8201: PC = %03x, Unimplemented opcode = %02x\n", m_pc.w.l-1, M_RDMEM(m_pc.w.l-1));
#if SHOW_MESSAGE_CONSOLE
osd_printf_debug("alpha8201: PC = %03x, Unimplemented opcode = %02x\n", m_pc.w.l-1, M_RDMEM(m_pc.w.l-1));
#endif
#if BREAK_ON_UNKNOWN_OPCODE
debugger_break(machine());
#endif
}
void segas18_state::set_vdp_mixing(UINT8 mixing)
{
if (mixing != m_vdp_mixing)
{
m_screen->update_partial(m_screen->vpos());
m_vdp_mixing = mixing;
#if DEBUG_VDP
osd_printf_debug("VDP mixing = %02X\n", mixing);
#endif
}
}
void alpha8201_cpu_device::M_UNDEFINED2()
{
UINT8 op = M_RDOP(m_pc.w.l-1);
UINT8 imm = M_RDMEM_OPCODE();
logerror("alpha8201: PC = %03x, Unimplemented opcode = %02x,%02x\n", m_pc.w.l-2, op,imm);
#if SHOW_MESSAGE_CONSOLE
osd_printf_debug("alpha8201: PC = %03x, Unimplemented opcode = %02x,%02x\n", m_pc.w.l-2, op,imm);
#endif
#if BREAK_ON_UNKNOWN_OPCODE
debugger_break(machine());
#endif
}
static void zr36120_pci_w(device_t* busdevice, device_t* device, int function, int reg, UINT32 data, UINT32 mem_mask)
{
magictg_state* state = busdevice->machine().driver_data<magictg_state>();
switch (reg)
{
case 0x04:
state->m_zr36120.command = data & 0x6;
break;
case 0x10:
state->m_zr36120.base_addr = data & 0xfffff000;
break;
default:
osd_printf_debug("ZR36120 [%x]: %x\n", reg, data);
}
}
static UINT32 voodoo_1_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
{
magictg_state* state = space.machine().driver_data<magictg_state>();
UINT32 val = 0;
switch (reg)
{
case 0:
val = 0x0001121a;
break;
case 0x10:
val = state->m_voodoo_pci_regs[1].base_addr;
break;
case 0x40:
val = state->m_voodoo_pci_regs[1].init_enable;
break;
default:
osd_printf_debug("Voodoo[1] PCI R: %x\n", reg);
}
return val;
}
static uint32_t voodoo_0_pci_r(device_t *busdevice, device_t *device, int function, int reg, uint32_t mem_mask)
{
magictg_state* state = device->machine().driver_data<magictg_state>();
uint32_t val = 0;
switch (reg)
{
case 0:
val = 0x0001121a;
break;
case 0x10:
val = state->m_voodoo_pci_regs[0].base_addr;
break;
case 0x40:
val = state->m_voodoo_pci_regs[0].init_enable;
break;
default:
osd_printf_debug("Voodoo[0] PCI R: %x\n", reg);
}
return val;
}
static void voodoo_1_pci_w(device_t *busdevice, device_t *device, int function, int reg, UINT32 data, UINT32 mem_mask)
{
magictg_state* state = space.machine().driver_data<magictg_state>();
switch (reg)
{
case 0x04:
voodoo_pci_regs[1].command = data & 0x3;
break;
case 0x10:
if (data == 0xffffffff)
state->m_voodoo_pci_regs[1].base_addr = 0xff000000;
else
state->m_voodoo_pci_regs[1].base_addr = data;
break;
case 0x40:
state->m_voodoo_pci_regs[1].init_enable = data;
voodoo_set_init_enable(state->m_voodoo[1], data);
break;
default:
osd_printf_debug("Voodoo [%x]: %x\n", reg, data);
}
}
static UINT32 zr36120_pci_r(device_t* busdevice, device_t* device, int function, int reg, UINT32 mem_mask)
{
magictg_state* state = busdevice->machine().driver_data<magictg_state>();
UINT32 val = 0;
switch (reg)
{
case 0x00:
val = 0x612011de;
break;
case 0x04:
val = state->m_zr36120.command;
break;
case 0x08:
val = 0x04000002;
break;
case 0x10:
val = state->m_zr36120.base_addr;
break;
default:
osd_printf_debug("ZR36120 R[%x]\n", reg);
}
return val;
}
static int config_load_xml(running_machine &machine, emu_file &file, int which_type)
{
xml_data_node *root, *confignode, *systemnode;
config_type *type;
const char *srcfile;
int version, count;
/* read the file */
root = xml_file_read(file, NULL);
if (!root)
goto error;
/* find the config node */
confignode = xml_get_sibling(root->child, "mameconfig");
if (!confignode)
goto error;
/* validate the config data version */
version = xml_get_attribute_int(confignode, "version", 0);
if (version != CONFIG_VERSION)
goto error;
/* strip off all the path crap from the source filename */
srcfile = strrchr(machine.system().source_file, '/');
if (!srcfile)
srcfile = strrchr(machine.system().source_file, '\\');
if (!srcfile)
srcfile = strrchr(machine.system().source_file, ':');
if (!srcfile)
srcfile = machine.system().source_file;
else
srcfile++;
/* loop over all system nodes in the file */
count = 0;
for (systemnode = xml_get_sibling(confignode->child, "system"); systemnode; systemnode = xml_get_sibling(systemnode->next, "system"))
{
/* look up the name of the system here; skip if none */
const char *name = xml_get_attribute_string(systemnode, "name", "");
/* based on the file type, determine whether we have a match */
switch (which_type)
{
case CONFIG_TYPE_GAME:
/* only match on the specific game name */
if (strcmp(name, machine.system().name) != 0)
continue;
break;
case CONFIG_TYPE_DEFAULT:
/* only match on default */
if (strcmp(name, "default") != 0)
continue;
break;
case CONFIG_TYPE_CONTROLLER:
{
int clone_of;
/* match on: default, game name, source file name, parent name, grandparent name */
if (strcmp(name, "default") != 0 &&
strcmp(name, machine.system().name) != 0 &&
strcmp(name, srcfile) != 0 &&
((clone_of = driver_list::clone(machine.system())) == -1 || strcmp(name, driver_list::driver(clone_of).name) != 0) &&
(clone_of == -1 || ((clone_of = driver_list::clone(clone_of)) == -1) || strcmp(name, driver_list::driver(clone_of).name) != 0))
continue;
break;
}
}
/* log that we are processing this entry */
if (DEBUG_CONFIG)
osd_printf_debug("Entry: %s -- processing\n", name);
/* loop over all registrants and call their load function */
for (type = typelist; type; type = type->next)
type->load(which_type, xml_get_sibling(systemnode->child, type->name));
count++;
}
/* error if this isn't a valid game match */
if (count == 0)
goto error;
/* free the parser */
xml_file_free(root);
return 1;
error:
if (root)
xml_file_free(root);
return 0;
}
void hng64_state::draw_sprites(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
gfx_element *gfx;
UINT32 *source = m_spriteram;
UINT32 *finish = m_spriteram + 0xc000/4;
// global offsets in sprite regs
int spriteoffsx = (m_spriteregs[1]>>0)&0xffff;
int spriteoffsy = (m_spriteregs[1]>>16)&0xffff;
#if 0
for (int iii = 0; iii < 0x0f; iii++)
osd_printf_debug("%.8x ", m_videoregs[iii]);
osd_printf_debug("\n");
#endif
while( source<finish )
{
int tileno,chainx,chainy,xflip;
int pal,xinc,yinc,yflip;
UINT16 xpos, ypos;
int xdrw,ydrw;
int chaini;
int zbuf;
UINT32 zoomx,zoomy;
float foomX, foomY;
int blend;
int disable;
ypos = (source[0]&0xffff0000)>>16;
xpos = (source[0]&0x0000ffff)>>0;
xpos += (spriteoffsx);
ypos += (spriteoffsy);
tileno= (source[4]&0x0007ffff);
blend= (source[4]&0x00800000);
yflip= (source[4]&0x01000000)>>24;
xflip= (source[4]&0x02000000)>>25;
disable=(source[4]&0x04000000)>>26; // ss64 rankings?
pal =(source[3]&0x00ff0000)>>16;
chainy=(source[2]&0x0000000f);
chainx=(source[2]&0x000000f0)>>4;
chaini=(source[2]&0x00000100);
zbuf = (source[2]&0x07ff0000)>>16; //?
zoomy = (source[1]&0xffff0000)>>16;
zoomx = (source[1]&0x0000ffff)>>0;
#if 1
if(zbuf == 0x7ff) //temp kludge to avoid garbage on screen
{
source+=8;
continue;
}
#endif
if(disable)
{
source+=8;
continue;
}
#if 0
if (!(source[4] == 0x00000000 || source[4] == 0x000000aa))
osd_printf_debug("unknown : %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x \n", source[0], source[1], source[2], source[3],
source[4], source[5], source[6], source[7]);
#endif
/* Calculate the zoom */
{
int zoom_factor;
/* FIXME: regular zoom mode has precision bugs, can be easily seen in Samurai Shodown 64 intro */
zoom_factor = (m_spriteregs[0] & 0x08000000) ? 0x1000 : 0x100;
if(!zoomx) zoomx=zoom_factor;
if(!zoomy) zoomy=zoom_factor;
/* First, prevent any possible divide by zero errors */
foomX = (float)(zoom_factor) / (float)zoomx;
foomY = (float)(zoom_factor) / (float)zoomy;
zoomx = ((int)foomX) << 16;
zoomy = ((int)foomY) << 16;
zoomx += (int)((foomX - floor(foomX)) * (float)0x10000);
zoomy += (int)((foomY - floor(foomY)) * (float)0x10000);
}
if (m_spriteregs[0] & 0x00800000) //bpp switch
{
gfx= m_gfxdecode->m_gfx[4];
}
else
{
gfx= m_gfxdecode->m_gfx[5];
tileno>>=1;
pal&=0xf;
}
// Accommodate for chaining and flipping
if(xflip)
{
xinc=-(int)(16.0f*foomX);
xpos-=xinc*chainx;
}
else
{
xinc=(int)(16.0f*foomX);
}
if(yflip)
{
yinc=-(int)(16.0f*foomY);
ypos-=yinc*chainy;
}
else
{
yinc=(int)(16.0f*foomY);
}
#if 0
if (((source[2) & 0xffff0000) >> 16) == 0x0001)
{
popmessage("T %.8x %.8x %.8x %.8x %.8x", source[0], source[1], source[2], source[3], source[4]);
//popmessage("T %.8x %.8x %.8x %.8x %.8x", source[0], source[1], source[2], source[3], source[4]);
}
#endif
for(ydrw=0;ydrw<=chainy;ydrw++)
{
for(xdrw=0;xdrw<=chainx;xdrw++)
{
INT16 drawx = xpos+(xinc*xdrw);
INT16 drawy = ypos+(yinc*ydrw);
// 0x3ff (0x200 sign bit) based on sams64_2 char select
drawx &= 0x3ff;
drawy &= 0x3ff;
if (drawx&0x0200)drawx-=0x400;
if (drawy&0x0200)drawy-=0x400;
if (!chaini)
{
if (!blend) gfx->prio_zoom_transpen(bitmap,cliprect,tileno,pal,xflip,yflip,drawx,drawy,zoomx,zoomy/*0x10000*/,screen.priority(), 0,0);
else gfx->prio_zoom_transpen_additive(bitmap,cliprect,tileno,pal,xflip,yflip,drawx,drawy,zoomx,zoomy/*0x10000*/,screen.priority(), 0,0);
tileno++;
}
else // inline chain mode, used by ss64
{
tileno=(source[4]&0x0007ffff);
pal =(source[3]&0x00ff0000)>>16;
if (m_spriteregs[0] & 0x00800000) //bpp switch
{
gfx= m_gfxdecode->m_gfx[4];
}
else
{
gfx= m_gfxdecode->m_gfx[5];
tileno>>=1;
pal&=0xf;
}
if (!blend) gfx->prio_zoom_transpen(bitmap,cliprect,tileno,pal,xflip,yflip,drawx,drawy,zoomx,zoomy/*0x10000*/,screen.priority(), 0,0);
else gfx->prio_zoom_transpen_additive(bitmap,cliprect,tileno,pal,xflip,yflip,drawx,drawy,zoomx,zoomy/*0x10000*/,screen.priority(), 0,0);
source +=8;
}
}
}
if (!chaini) source +=8;
}
}
// The command is written when the CMD pin is low
void okim9810_device::write_command(UINT8 data)
{
const UINT8 cmd = (data & 0xf8) >> 3;
const UINT8 channel = (data & 0x07);
switch(cmd)
{
case 0x00: // START
{
osd_printf_debug("START channel mask %02x\n", m_TMP_register);
UINT8 channelMask = 0x01;
for (int i = 0; i < OKIM9810_VOICES; i++, channelMask <<= 1)
{
if (channelMask & m_TMP_register)
{
m_voice[i].m_playing = true;
osd_printf_debug("\t\tPlaying channel %d: encoder type %d @ %dhz (volume = %d %d). From %08x for %d samples (looping=%d).\n",
i,
m_voice[i].m_playbackAlgo,
m_voice[i].m_samplingFreq,
m_voice[i].volume_scale(m_global_volume, m_voice[i].m_channel_volume, m_voice[i].m_pan_volume_left),
m_voice[i].volume_scale(m_global_volume, m_voice[i].m_channel_volume, m_voice[i].m_pan_volume_right),
m_voice[i].m_base_offset,
m_voice[i].m_count,
m_voice[i].m_looping);
}
}
break;
}
case 0x01: // STOP
{
osd_printf_debug("STOP channel mask %02x\n", m_TMP_register);
UINT8 channelMask = 0x01;
for (int i = 0; i < OKIM9810_VOICES; i++, channelMask <<= 1)
{
if (channelMask & m_TMP_register)
{
m_voice[i].m_playing = false;
osd_printf_debug("\tChannel %d stopping.\n", i);
}
}
break;
}
case 0x02: // LOOP
{
osd_printf_debug("LOOP channel mask %02x\n", m_TMP_register);
UINT8 channelMask = 0x01;
for (int i = 0; i < OKIM9810_VOICES; i++, channelMask <<= 1)
{
if (channelMask & m_TMP_register)
{
m_voice[i].m_looping = true;
osd_printf_debug("\tChannel %d looping.\n", i);
}
else
{
m_voice[i].m_looping = false;
osd_printf_debug("\tChannel %d done looping.\n", i);
}
}
break;
}
case 0x03: // OPT (options)
{
osd_printf_debug("OPT complex data %02x\n", m_TMP_register);
m_global_volume = (m_TMP_register & 0x18) >> 3;
m_filter_type = (m_TMP_register & 0x06) >> 1;
m_output_level = (m_TMP_register & 0x01);
osd_printf_debug("\tOPT setting main volume scale to Vdd/%d\n", m_global_volume+1);
osd_printf_debug("\tOPT setting output filter type to %d\n", m_filter_type);
osd_printf_debug("\tOPT setting output amp level to %d\n", m_output_level);
break;
}
case 0x04: // MUON (silence)
{
osd_printf_warning("MUON channel %d length %02x\n", channel, m_TMP_register);
osd_printf_warning("MSM9810: UNIMPLEMENTED COMMAND!\n");
break;
}
case 0x05: // FADR (phrase address)
{
const offs_t base = m_TMP_register * 8;
offs_t startAddr;
UINT8 startFlags = m_direct->read_raw_byte(base + 0);
startAddr = m_direct->read_raw_byte(base + 1) << 16;
startAddr |= m_direct->read_raw_byte(base + 2) << 8;
startAddr |= m_direct->read_raw_byte(base + 3) << 0;
offs_t endAddr;
UINT8 endFlags = m_direct->read_raw_byte(base + 4);
endAddr = m_direct->read_raw_byte(base + 5) << 16;
endAddr |= m_direct->read_raw_byte(base + 6) << 8;
endAddr |= m_direct->read_raw_byte(base + 7) << 0;
// Sub-table
if (startFlags & 0x80)
{
offs_t subTable = startAddr;
// TODO: New startFlags &= 0x80. Are there further subtables?
startFlags = m_direct->read_raw_byte(subTable + 0);
startAddr = m_direct->read_raw_byte(subTable + 1) << 16;
startAddr |= m_direct->read_raw_byte(subTable + 2) << 8;
startAddr |= m_direct->read_raw_byte(subTable + 3) << 0;
// TODO: What does byte (subTable + 4) refer to?
endAddr = m_direct->read_raw_byte(subTable + 5) << 16;
endAddr |= m_direct->read_raw_byte(subTable + 6) << 8;
endAddr |= m_direct->read_raw_byte(subTable + 7) << 0;
}
m_voice[channel].m_sample = 0;
m_voice[channel].m_interpSampleNum = 0;
m_voice[channel].m_startFlags = startFlags;
m_voice[channel].m_base_offset = startAddr;
m_voice[channel].m_endFlags = endFlags;
m_voice[channel].m_count = (endAddr-startAddr) + 1; // Is there yet another extra byte at the end?
m_voice[channel].m_playbackAlgo = (startFlags & 0x30) >> 4;
m_voice[channel].m_samplingFreq = s_sampling_freq_table[startFlags & 0x0f];
if (m_voice[channel].m_playbackAlgo == OKIM9810_ADPCM_PLAYBACK ||
m_voice[channel].m_playbackAlgo == OKIM9810_ADPCM2_PLAYBACK)
m_voice[channel].m_count *= 2;
else
osd_printf_warning("MSM9810: UNIMPLEMENTED PLAYBACK METHOD %d\n", m_voice[channel].m_playbackAlgo);
osd_printf_debug("FADR channel %d phrase offset %02x => ", channel, m_TMP_register);
osd_printf_debug("startFlags(%02x) startAddr(%06x) endFlags(%02x) endAddr(%06x) bytes(%d)\n", startFlags, startAddr, endFlags, endAddr, endAddr-startAddr);
break;
}
case 0x06: // DADR (direct address playback)
{
osd_printf_warning("DADR channel %d complex data %02x\n", channel, m_TMP_register);
osd_printf_warning("MSM9810: UNIMPLEMENTED COMMAND!\n");
break;
}
case 0x07: // CVOL (channel volume)
{
osd_printf_debug("CVOL channel %d data %02x\n", channel, m_TMP_register);
osd_printf_debug("\tChannel %d -> volume index %d.\n", channel, m_TMP_register & 0x0f);
m_voice[channel].m_channel_volume = m_TMP_register & 0x0f;
break;
}
case 0x08: // PAN
{
const UINT8 leftVolIndex = (m_TMP_register & 0xf0) >> 4;
const UINT8 rightVolIndex = m_TMP_register & 0x0f;
osd_printf_debug("PAN channel %d left index: %02x right index: %02x (%02x)\n", channel, leftVolIndex, rightVolIndex, m_TMP_register);
osd_printf_debug("\tChannel %d left -> %d right -> %d\n", channel, leftVolIndex, rightVolIndex);
m_voice[channel].m_pan_volume_left = leftVolIndex;
m_voice[channel].m_pan_volume_right = rightVolIndex;
break;
}
default:
{
osd_printf_warning("MSM9810: UNKNOWN COMMAND!\n");
break;
}
}
}
int configuration_manager::load_xml(emu_file &file, config_type which_type)
{
/* read the file */
std::unique_ptr<util::xml::data_node, void (*)(util::xml::data_node *)> const root(
util::xml::data_node::file_read(file, nullptr),
[] (util::xml::data_node *node) { node->file_free(); });
if (!root)
return 0;
/* find the config node */
util::xml::data_node const *const confignode = root->get_child("mameconfig");
if (!confignode)
return 0;
/* validate the config data version */
int const version = confignode->get_attribute_int("version", 0);
if (version != CONFIG_VERSION)
return 0;
/* strip off all the path crap from the source filename */
const char *srcfile = strrchr(machine().system().source_file, '/');
if (!srcfile)
srcfile = strrchr(machine().system().source_file, '\\');
if (!srcfile)
srcfile = strrchr(machine().system().source_file, ':');
if (!srcfile)
srcfile = machine().system().source_file;
else
srcfile++;
/* loop over all system nodes in the file */
int count = 0;
for (util::xml::data_node const *systemnode = confignode->get_child("system"); systemnode; systemnode = systemnode->get_next_sibling("system"))
{
/* look up the name of the system here; skip if none */
const char *name = systemnode->get_attribute_string("name", "");
/* based on the file type, determine whether we have a match */
switch (which_type)
{
case config_type::GAME:
/* only match on the specific game name */
if (strcmp(name, machine().system().name) != 0)
continue;
break;
case config_type::DEFAULT:
/* only match on default */
if (strcmp(name, "default") != 0)
continue;
break;
case config_type::CONTROLLER:
{
int clone_of;
/* match on: default, game name, source file name, parent name, grandparent name */
if (strcmp(name, "default") != 0 &&
strcmp(name, machine().system().name) != 0 &&
strcmp(name, srcfile) != 0 &&
((clone_of = driver_list::clone(machine().system())) == -1 || strcmp(name, driver_list::driver(clone_of).name) != 0) &&
(clone_of == -1 || ((clone_of = driver_list::clone(clone_of)) == -1) || strcmp(name, driver_list::driver(clone_of).name) != 0))
continue;
break;
}
default:
break;
}
/* log that we are processing this entry */
if (DEBUG_CONFIG)
osd_printf_debug("Entry: %s -- processing\n", name);
/* loop over all registrants and call their load function */
for (auto type : m_typelist)
type.load(which_type, systemnode->get_child(type.name.c_str()));
count++;
}
/* error if this isn't a valid game match */
if (count == 0)
return 0;
return 1;
}
static offs_t internal_disasm_tms32010(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint32_t flags = 0;
int a, b, d, k, m, n, p, r, s, w; /* these can all be filled in by parsing an instruction */
int i;
int op;
int cnt = 1;
int code;
int bit;
//char *buffertmp;
const char *cp; /* character pointer in OpFormats */
if (!OpInizialized) InitDasm32010();
op = -1; /* no matching opcode */
code = (oprom[0] << 8) | oprom[1];
for ( i = 0; i < MAX_OPS; i++)
{
if ((code & Op[i].mask) == Op[i].bits)
{
if (op != -1)
{
osd_printf_debug("Error: opcode %04Xh matches %d (%s) and %d (%s)\n",
code,i,Op[i].fmt,op,Op[op].fmt);
}
op = i;
}
}
if (op == -1)
{
util::stream_format(stream, "dw %04Xh *(invalid op)", code);
return cnt | DASMFLAG_SUPPORTED;
}
//buffertmp = buffer;
if (Op[op].extcode)
{
bit = 31;
code <<= 16;
code |= (opram[2] << 8) | opram[3];
cnt++;
}
else
{
bit = 15;
}
/* shift out operands */
cp = Op[op].parse;
a = b = d = k = m = n = p = r = s = w = 0;
while (bit >= 0)
{
/* osd_printf_debug("{%c/%d}",*cp,bit); */
switch(*cp)
{
case 'a': a <<=1; a |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'b': b <<=1; b |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'd': d <<=1; d |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'k': k <<=1; k |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'm': m <<=1; m |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'n': n <<=1; n |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'p': p <<=1; p |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'r': r <<=1; r |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 's': s <<=1; s |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'w': w <<=1; w |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case ' ': break;
case '1': case '0': bit--; break;
case '\0': fatalerror("premature end of parse string, opcode %x, bit = %d\n",code,bit);
}
cp++;
}
/* now traverse format string */
cp = Op[op].fmt;
if (!strncmp(cp, "cal", 3))
flags = DASMFLAG_STEP_OVER;
else if (!strncmp(cp, "ret", 3))
flags = DASMFLAG_STEP_OUT;
while (*cp)
{
if (*cp == '%')
{
char num[20];
cp++;
switch (*cp++)
{
case 'A': sprintf(num,"%02Xh",a); break; // was $%02X
case 'B': sprintf(num,"%04Xh",b); break; // was $%04X
case 'D': sprintf(num,"%02Xh",d); break;
case 'K': sprintf(num,"%d",k); break;
case 'N': sprintf(num,"%s",nextar[n]); break;
case 'M': sprintf(num,"%s",arith[m]); break;
case 'P': sprintf(num,"PA%d",p); break;
case 'R': sprintf(num,"AR%d",r); break;
case 'S': sprintf(num,",%d",s); break;
case 'W': sprintf(num,"%04Xh",w); break;
default:
fatalerror("illegal escape character in format '%s'\n",Op[op].fmt);
}
stream << num;
}
else
{
stream << *cp++;
}
}
return cnt | flags | DASMFLAG_SUPPORTED;
}
static UINT32 pci_dev0_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
{
osd_printf_debug("PCI[0] READ: %x\n", reg);
return 0x00000000; // TODO
}
void alpha8201_cpu_device::execute_run()
{
unsigned opcode;
UINT8 pcptr;
if(m_halt)
{
m_icount = 0;
return;
}
/* setup address bank & fall safe */
m_ix0.b.h =
m_ix1.b.h =
m_ix2.b.h = (m_pc.b.h &= 3);
/* reset start hack */
if(m_pc.w.l<0x20)
m_mb |= 0x08;
do
{
if(m_mb & 0x08)
{
pcptr = M_RDMEM(0x001) & 0x1f; /* pointer of entry point */
m_icount -= C1;
/* entry point scan phase */
if( (pcptr&1) == 0)
{
/* EVEN , get PC low */
m_pc.b.l = M_RDMEM(pcptr);
//osd_printf_debug("alpha8201 load PCL ENTRY=%02X PCL=%02X\n",pcptr, m_pc.b.l);
m_icount -= C1;
M_WRMEM(0x001,pcptr+1);
continue;
}
/* ODD , check HALT flag */
m_mb = M_RDMEM(pcptr) & (0x08|0x03);
m_icount -= C1;
/* not entryaddress 000,001 */
if(pcptr<2) m_mb |= 0x08;
if(m_mb & 0x08)
{
/* HALTED current entry point . next one */
pcptr = (pcptr+1)&0x1f;
M_WRMEM(0x001,pcptr);
m_icount -= C1;
continue;
}
/* goto run phase */
M_JMP(m_pc.b.l);
#if SHOW_ENTRY_POINT
logerror("alpha8201 START ENTRY=%02X PC=%03X\n",pcptr,m_pc.w.l);
osd_printf_debug("alpha8201 START ENTRY=%02X PC=%03X\n",pcptr,m_pc.w.l);
#endif
}
/* run */
m_PREVPC = m_pc.w.l;
debugger_instruction_hook(this, m_pc.w.l);
opcode =M_RDOP(m_pc.w.l);
#if TRACE_PC
osd_printf_debug("alpha8201: PC = %03x, opcode = %02x\n", m_pc.w.l, opcode);
#endif
m_pc.b.l++;
m_inst_cycles = m_opmap[opcode].cycles;
(this->*m_opmap[opcode].opcode_func)();
m_icount -= m_inst_cycles;
} while (m_icount>0);
}
offs_t pic16c5x_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms)
{
int a, b, d, f, k; /* these can all be filled in by parsing an instruction */
int i;
int op;
int cnt = 1;
int code;
int bit;
//char *buffertmp;
const char *cp; /* character pointer in OpFormats */
uint32_t flags = 0;
op = -1; /* no matching opcode */
code = opcodes.r16(pc);
for ( i = 0; i < int(Op.size()); i++)
{
if ((code & Op[i].mask) == Op[i].bits)
{
if (op != -1)
{
osd_printf_debug("Error: opcode %04Xh matches %d (%s) and %d (%s)\n",
code,i,Op[i].fmt,op,Op[op].fmt);
}
op = i;
}
}
if (op == -1)
{
util::stream_format(stream, "???? dw %04Xh",code);
return cnt | SUPPORTED;
}
//buffertmp = buffer;
if (Op[op].extcode) /* Actually, theres no double length opcodes */
{
bit = 27;
code <<= 16;
code |= params.r16(pc+cnt);
cnt++;
}
else
{
bit = 11;
}
/* shift out operands */
cp = Op[op].parse;
a = b = d = f = k = 0;
while (bit >= 0)
{
/* osd_printf_debug("{%c/%d}",*cp,bit); */
switch (*cp)
{
case 'a': a <<=1; a |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'b': b <<=1; b |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'd': d <<=1; d |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'f': f <<=1; f |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case 'k': k <<=1; k |= ((code & (1<<bit)) ? 1 : 0); bit--; break;
case ' ': break;
case '1': case '0': bit--; break;
case '\0': throw std::logic_error(util::string_format("premature end of parse string, opcode %x, bit = %d\n",code,bit));
}
cp++;
}
/* now traverse format string */
cp = Op[op].fmt;
if (!strncmp(cp, "call", 4))
flags = STEP_OVER;
else if (!strncmp(cp, "ret", 3))
flags = STEP_OUT;
while (*cp)
{
if (*cp == '%')
{
cp++;
switch (*cp++)
{
case 'A': util::stream_format(stream, "$%03X", a); break;
case 'B': util::stream_format(stream, "%d", b); break;
case 'D': util::stream_format(stream, "%s", dest[d]); break;
case 'F': util::stream_format(stream, "%s", regfile[f]); break;
case 'K': util::stream_format(stream, "%02Xh", k); break;
default:
throw std::logic_error(util::string_format("illegal escape character in format '%s'\n",Op[op].fmt));
}
}
else
{
stream << *cp++;
}
}
return cnt | flags | SUPPORTED;
}