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; }