Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-21 07:52:35 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

First in a series of updates to remove the use of the global Machine from as many places as possible

Browse Source
This commit is contained in:
Zsolt Vasvari 2008-01-24 09:12:03 +00:00
parent c1af761bef
commit f7c5c67e2e
52 changed files with 370 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
src/emu/cheat.c
View File

@ -780,21 +780,21 @@ static char * CreateStringCopy(char * buf);
static INT32 UserSelectValueMenu(int selection, CheatEntry * entry);
/********** CHEAT MENU **********/
static int EnableDisableCheatMenu(int selection, int firstTime);
static int AddEditCheatMenu(int selection);
static int EditCheatMenu(CheatEntry * entry, int index, int selection);
static int EnableDisableCheatMenu(running_machine *machine, int selection, int firstTime);
static int AddEditCheatMenu(running_machine *machine, int selection);
static int EditCheatMenu(running_machine *machine, CheatEntry * entry, int index, int selection);
static int DoSearchMenuMinimum(int selection); // minimum mode
static int DoSearchMenuClassic(int selection); // classic mode
static int DoSearchMenu(int selection); // advanced mode
static int SelectSearchRegions(int selection, SearchInfo * search);
static int DoSearchMenuMinimum(running_machine *machine, int selection); // minimum mode
static int DoSearchMenuClassic(running_machine *machine, int selection); // classic mode
static int DoSearchMenu(running_machine *machine, int selection); // advanced mode
static int SelectSearchRegions(running_machine *machine, int selection, SearchInfo * search);
static int ViewSearchResults(int selection, int firstTime);
static int ChooseWatch(int selection);
static int EditWatch(WatchInfo * entry, int selection);
static int ChooseWatch(running_machine *machine, int selection);
static int EditWatch(running_machine *machine, WatchInfo * entry, int selection);
static int SelectOptions(int selection);
static int SelectSearch(int selection);
static int SelectOptions(running_machine *machine, int selection);
static int SelectSearch(running_machine *machine, int selection);
/********** ENTRY LIST **********/
static void ResizeCheatList(UINT32 newLength);
@ -849,20 +849,20 @@ static void BackupRegion(SearchRegion * region);
static void RestoreRegionBackup(SearchRegion * region);
static void SetSearchRegionDefaultName(SearchRegion * region);
static void AllocateSearchRegions(SearchInfo * info);
static void BuildSearchRegions(SearchInfo * info);
static void BuildSearchRegions(running_machine *machine, SearchInfo * info);
/********** CODE LOADER **********/
static int ConvertOldCode(int code, int cpu, int * data, int * extendData);
static void HandleLocalCommandCheat(UINT32 type, UINT32 address, UINT32 data, UINT32 extendData, char * name, char * description);
static void HandleLocalCommandCheat(running_machine *machine, UINT32 type, UINT32 address, UINT32 data, UINT32 extendData, char * name, char * description);
static void LoadCheatFile(char * fileName);
static void LoadCheatDatabase(void);
static void LoadCheatFile(running_machine *machine, char * fileName);
static void LoadCheatDatabase(running_machine *machine);
static void DisposeCheatDatabase(void);
static void ReloadCheatDatabase(void);
static void ReloadCheatDatabase(running_machine *machine);
static void SaveCheat(CheatEntry * entry, int selection, int saveCode);
static void DoAutoSaveCheats(void);
static void SaveCheat(running_machine *machine, CheatEntry * entry, int selection, int saveCode);
static void DoAutoSaveCheats(running_machine *machine);
/********** CODE ADDITION **********/
static void AddCheatFromResult(SearchInfo * search, SearchRegion * region, UINT32 address);
@ -920,15 +920,15 @@ static void DeactivateCheat(CheatEntry * entry);
static void TempDeactivateCheat(CheatEntry * entry);
static void cheat_periodicOperation(CheatAction * action);
static void cheat_periodicAction(CheatAction * action);
static void cheat_periodicEntry(CheatEntry * entry);
static void cheat_periodicAction(running_machine *machine, CheatAction * action);
static void cheat_periodicEntry(running_machine *machine, CheatEntry * entry);
static void UpdateAllCheatInfo(void);
static void UpdateCheatInfo(CheatEntry * entry, UINT8 isLoadTime);
static int IsAddressInRange(CheatAction * action, UINT32 length);
static void BuildCPUInfoList(void);
static void BuildCPUInfoList(running_machine *machine);
/*--------------------------------------------------------------
special key handler - check pressing shift, ctrl or alt key
@ -1484,23 +1484,23 @@ void cheat_init(running_machine *machine)
fullMenuPageHeight = floor(1.0f / ui_get_line_height()) - 1;
/* ----- initialize CPU info for cheat system ----- */
BuildCPUInfoList();
BuildCPUInfoList(machine);
/* ----- load cheat database ----- */
LoadCheatDatabase();
LoadCheatDatabase(machine);
ResizeSearchList(1);
ResizeWatchList(20);
/* ----- initialize search regions ----- */
BuildSearchRegions(GetCurrentSearch());
BuildSearchRegions(machine, GetCurrentSearch());
AllocateSearchRegions(GetCurrentSearch());
/* ----- initialize string table ----- */
InitStringTable();
periodic_timer = timer_alloc(cheat_periodic, NULL);
timer_adjust(periodic_timer, attotime_make(0, Machine->screen[0].refresh), 0, attotime_make(0, Machine->screen[0].refresh));
timer_adjust(periodic_timer, attotime_make(0, machine->screen[0].refresh), 0, attotime_make(0, machine->screen[0].refresh));
add_exit_callback(machine, cheat_exit);
}
@ -1515,7 +1515,7 @@ static void cheat_exit(running_machine *machine)
/* ----- save all cheats automatically if needed ----- */
if(TEST_FIELD(cheatOptions, AutoSaveEnabled))
DoAutoSaveCheats();
DoAutoSaveCheats(machine);
/* ----- free database ----- */
DisposeCheatDatabase();
@ -1570,7 +1570,7 @@ static void cheat_exit(running_machine *machine)
cheat_menu - management for the cheat general menu
-----------------------------------------------------*/
int cheat_menu(int selection)
int cheat_menu(running_machine *machine, int selection)
{
enum
{
@ -1607,36 +1607,36 @@ int cheat_menu(int selection)
switch(sel)
{
case kMenu_EnableDisable:
submenu_choice = EnableDisableCheatMenu(submenu_choice, firstEntry);
submenu_choice = EnableDisableCheatMenu(machine, submenu_choice, firstEntry);
break;
case kMenu_AddEdit:
submenu_choice = AddEditCheatMenu(submenu_choice);
submenu_choice = AddEditCheatMenu(machine, submenu_choice);
break;
case kMenu_Search:
switch(EXTRACT_FIELD(cheatOptions, SearchBox))
{
case kSearchBox_Minimum:
submenu_choice = DoSearchMenuMinimum(submenu_choice);
submenu_choice = DoSearchMenuMinimum(machine, submenu_choice);
break;
case kSearchBox_Classic:
submenu_choice = DoSearchMenuClassic(submenu_choice);
submenu_choice = DoSearchMenuClassic(machine, submenu_choice);
break;
case kSearchBox_Advanced:
submenu_choice = DoSearchMenu(submenu_choice);
submenu_choice = DoSearchMenu(machine, submenu_choice);
break;
}
break;
case kMenu_ChooseWatch:
submenu_choice = ChooseWatch(submenu_choice);
submenu_choice = ChooseWatch(machine, submenu_choice);
break;
case kMenu_Options:
submenu_choice = SelectOptions(submenu_choice);
submenu_choice = SelectOptions(machine, submenu_choice);
break;
}
@ -1740,7 +1740,7 @@ int cheat_menu(int selection)
break;
case kMenu_ReloadDatabase:
ReloadCheatDatabase();
ReloadCheatDatabase(machine);
break;
default:
@ -1751,7 +1751,7 @@ int cheat_menu(int selection)
}
if(input_ui_pressed(IPT_UI_RELOAD_CHEAT))
ReloadCheatDatabase();
ReloadCheatDatabase(machine);
if(input_ui_pressed(IPT_UI_CANCEL))
{
@ -2194,7 +2194,7 @@ static INT32 CommentMenu(int selection, CheatEntry * entry)
EnableDisableCheatMenu - management for Enable/Disable menu
--------------------------------------------------------------*/
static int EnableDisableCheatMenu(int selection, int firstTime)
static int EnableDisableCheatMenu(running_machine *machine, int selection, int firstTime)
{
INT32 sel;
static INT32 submenu_choice = 0;
@ -2229,7 +2229,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
break;
case 3:
submenu_choice = EditCheatMenu(&cheatList[sel], sel, submenu_choice);
submenu_choice = EditCheatMenu(machine, &cheatList[sel], sel, submenu_choice);
break;
default:
@ -2582,7 +2582,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
if(input_ui_pressed(IPT_UI_SAVE_CHEAT)) // shift + save = save all codes
{
for(i = 0; i < cheatListLength; i++)
SaveCheat(&cheatList[i], 0, 0);
SaveCheat(machine, &cheatList[i], 0, 0);
ui_popup_time(1, "%d cheats saved", cheatListLength);
}
@ -2601,7 +2601,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
{
if((entry->flags & kCheatFlag_HasActivationKey1) || (entry->flags & kCheatFlag_HasActivationKey2))
{
SaveCheat(entry, sel, 1);
SaveCheat(machine, entry, sel, 1);
ui_popup_time(1, "activation key saved");
}
@ -2612,7 +2612,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
else
{
if(input_ui_pressed(IPT_UI_SAVE_CHEAT))
SaveCheat(entry, 0, 0); // save current entry
SaveCheat(machine, entry, 0, 0); // save current entry
}
}
@ -2623,7 +2623,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
}
if(input_ui_pressed(IPT_UI_RELOAD_CHEAT))
ReloadCheatDatabase();
ReloadCheatDatabase(machine);
if(UIPressedRepeatThrottle(IPT_UI_ZOOM_IN, kVerticalKeyRepeatRate))
/* ----- quick menu switch : enable/disable -> add/edit ----- */
@ -2643,7 +2643,7 @@ static int EnableDisableCheatMenu(int selection, int firstTime)
AddEditCheatMenu - management for Add/Edit cheat menu
--------------------------------------------------------*/
static int AddEditCheatMenu(int selection)
static int AddEditCheatMenu(running_machine *machine, int selection)
{
INT32 sel;
static INT32 submenuChoice = 0;
@ -2662,7 +2662,7 @@ static int AddEditCheatMenu(int selection)
/********** SUB MENU **********/
if(submenuChoice)
{
submenuChoice = EditCheatMenu(&cheatList[submenuCheat], submenuCheat, submenuChoice);
submenuChoice = EditCheatMenu(machine, &cheatList[submenuCheat], submenuCheat, submenuChoice);
/* ----- meaningless ? because no longer return with sel = -1 (pressed UI_CONFIG in submenu) ----- */
// if(submenuChoice == -1)
@ -2741,7 +2741,7 @@ static int AddEditCheatMenu(int selection)
if(ShiftKeyPressed())
{
for(i = 0; i < cheatListLength; i++) // shift + save = save all codes
SaveCheat(&cheatList[i], 0, 0);
SaveCheat(machine, &cheatList[i], 0, 0);
ui_popup_time(1, "%d cheats saved", cheatListLength);
}
@ -2751,7 +2751,7 @@ static int AddEditCheatMenu(int selection)
{
if((entry->flags & kCheatFlag_HasActivationKey1) || (entry->flags & kCheatFlag_HasActivationKey2))
{
SaveCheat(entry, sel, 1); // ctrl + save = save activation key
SaveCheat(machine, entry, sel, 1); // ctrl + save = save activation key
ui_popup_time(1, "activation key saved");
}
@ -2759,7 +2759,7 @@ static int AddEditCheatMenu(int selection)
ui_popup_time(1, "no activation key");
}
else
SaveCheat(entry, 0, 0); // save current entry
SaveCheat(machine, entry, 0, 0); // save current entry
}
}
@ -2799,7 +2799,7 @@ static int AddEditCheatMenu(int selection)
}
if(input_ui_pressed(IPT_UI_RELOAD_CHEAT))
ReloadCheatDatabase();
ReloadCheatDatabase(machine);
if(UIPressedRepeatThrottle(IPT_UI_ZOOM_IN, kVerticalKeyRepeatRate))
/* ----- quick menu switch : add/edit -> search ----- */
@ -2819,7 +2819,7 @@ static int AddEditCheatMenu(int selection)
EditCheatMenu - management for edit code menu
------------------------------------------------*/
static int EditCheatMenu(CheatEntry * entry, int index, int selection)
static int EditCheatMenu(running_machine *machine, CheatEntry * entry, int index, int selection)
{
static const char *const kTypeNames[] =
{
@ -4624,14 +4624,14 @@ static int EditCheatMenu(CheatEntry * entry, int index, int selection)
if(ControlKeyPressed())
if((entry->flags & kCheatFlag_HasActivationKey1) || (entry->flags & kCheatFlag_HasActivationKey2))
{
SaveCheat(entry, index, 1); // save activation key
SaveCheat(machine, entry, index, 1); // save activation key
ui_popup_time(1, "activation key saved");
}
else
ui_popup_time(1, "no activation key");
else
SaveCheat(entry, 0, 0); // save current entry
SaveCheat(machine, entry, 0, 0); // save current entry
}
if(input_ui_pressed(IPT_UI_WATCH_VALUE))
@ -4683,7 +4683,7 @@ static int EditCheatMenu(CheatEntry * entry, int index, int selection)
DoSearchMenuMinimum - management for minimum search menu
-----------------------------------------------------------*/
static int DoSearchMenuMinimum(int selection)
static int DoSearchMenuMinimum(running_machine *machine, int selection)
{
/* main */
enum
@ -4741,7 +4741,7 @@ static int DoSearchMenuMinimum(int selection)
switch(sel)
{
case kMenu_CPU:
submenuChoice = SelectSearchRegions(submenuChoice, GetCurrentSearch());
submenuChoice = SelectSearchRegions(machine, submenuChoice, GetCurrentSearch());
break;
case kMenu_ViewResult:
@ -4980,7 +4980,7 @@ static int DoSearchMenuMinimum(int selection)
{
search->targetIdx--;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneSaveMemory = 0;
@ -5024,7 +5024,7 @@ static int DoSearchMenuMinimum(int selection)
{
search->targetIdx++;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneSaveMemory = 0;
@ -5262,7 +5262,7 @@ static int DoSearchMenuMinimum(int selection)
DoSearchMenuClassic - management for classic search menu
-----------------------------------------------------------*/
static int DoSearchMenuClassic(int selection)
static int DoSearchMenuClassic(running_machine *machine, int selection)
{
static const char *const energyStrings[] =
{
@ -5362,7 +5362,7 @@ static int DoSearchMenuClassic(int selection)
switch(sel)
{
case kMenu_CPU:
submenuChoice = SelectSearchRegions(submenuChoice, GetCurrentSearch());
submenuChoice = SelectSearchRegions(machine, submenuChoice, GetCurrentSearch());
break;
case kMenu_ViewResult:
@ -5530,7 +5530,7 @@ static int DoSearchMenuClassic(int selection)
{
search->targetIdx--;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneSaveMemory = 0;
@ -5584,7 +5584,7 @@ static int DoSearchMenuClassic(int selection)
{
search->targetIdx++;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneSaveMemory = 0;
@ -5791,7 +5791,7 @@ static int DoSearchMenuClassic(int selection)
DoSearchMenu - management for advanced search menu
-----------------------------------------------------*/
static int DoSearchMenu(int selection)
static int DoSearchMenu(running_machine *machine, int selection)
{
/* menu stirngs */
static const char *const kOperandNameTable[] =
@ -5880,7 +5880,7 @@ static int DoSearchMenu(int selection)
switch(sel)
{
case kMenu_CPU:
submenuChoice = SelectSearchRegions(submenuChoice, GetCurrentSearch());
submenuChoice = SelectSearchRegions(machine, submenuChoice, GetCurrentSearch());
break;
case kMenu_ViewResult:
@ -6097,7 +6097,7 @@ static int DoSearchMenu(int selection)
{
search->targetIdx--;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneMemorySave = 0;
@ -6157,7 +6157,7 @@ static int DoSearchMenu(int selection)
{
search->targetIdx++;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
doneMemorySave = 0;
@ -6281,7 +6281,7 @@ static int DoSearchMenu(int selection)
SelectSearchRegions - management for search regions selection menu
---------------------------------------------------------------------*/
static int SelectSearchRegions(int selection, SearchInfo * search)
static int SelectSearchRegions(running_machine *machine, int selection, SearchInfo * search)
{
static const char *const kSearchSpeedList[] =
{
@ -6390,7 +6390,7 @@ static int SelectSearchRegions(int selection, SearchInfo * search)
else
search->searchSpeed = kSearchSpeed_Max;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
}
}
@ -6411,7 +6411,7 @@ static int SelectSearchRegions(int selection, SearchInfo * search)
else
search->searchSpeed = kSearchSpeed_Fast;
BuildSearchRegions(search);
BuildSearchRegions(machine, search);
AllocateSearchRegions(search);
}
}
@ -6817,7 +6817,7 @@ static int ViewSearchResults(int selection, int firstTime)
ChooseWatch - management for watchpoint list menu
----------------------------------------------------*/
static int ChooseWatch(int selection)
static int ChooseWatch(running_machine *machine, int selection)
{
const char ** menuItem;
char ** buf;
@ -6840,7 +6840,7 @@ static int ChooseWatch(int selection)
/********** SUB MENU **********/
if(submenuChoice)
{
submenuChoice = EditWatch(&watchList[submenuWatch], submenuChoice);
submenuChoice = EditWatch(machine, &watchList[submenuWatch], submenuChoice);
/* ----- meaningless ? because no longer return with sel = -1 (pressed UI_CONFIG in submenu) ----- */
// if(submenuChoice == -1)
@ -6933,7 +6933,7 @@ static int ChooseWatch(int selection)
memset(&entry, 0, sizeof(CheatEntry));
SetupCheatFromWatchAsWatch(&entry, watch);
SaveCheat(&entry, 0, 0);
SaveCheat(machine, &entry, 0, 0);
DisposeCheat(&entry);
}
}
@ -7037,7 +7037,7 @@ static int ChooseWatch(int selection)
EditWatch - management for watchpoint edit menu
--------------------------------------------------*/
static int EditWatch(WatchInfo * entry, int selection)
static int EditWatch(running_machine *machine, WatchInfo * entry, int selection)
{
enum
{
@ -7525,7 +7525,7 @@ static int EditWatch(WatchInfo * entry, int selection)
memset(&tempEntry, 0, sizeof(CheatEntry));
SetupCheatFromWatchAsWatch(&tempEntry, entry);
SaveCheat(&tempEntry, 0, 0);
SaveCheat(machine, &tempEntry, 0, 0);
DisposeCheat(&tempEntry);
}
}
@ -7540,7 +7540,7 @@ static int EditWatch(WatchInfo * entry, int selection)
SelectOptions - management for options menu
----------------------------------------------*/
static int SelectOptions(int selection)
static int SelectOptions(running_machine *machine, int selection)
{
enum
{
@ -7570,7 +7570,7 @@ static int SelectOptions(int selection)
switch(sel)
{
case kMenu_SelectSearch:
submenuChoice = SelectSearch(submenuChoice);
submenuChoice = SelectSearch(machine, submenuChoice);
break;
default:
@ -7737,13 +7737,13 @@ static int SelectOptions(int selection)
if(input_ui_pressed(IPT_UI_SAVE_CHEAT))
{
SaveCheat(NULL, 0, 2);
SaveCheat(machine, NULL, 0, 2);
ui_popup_time(1, "command code saved");
}
if(input_ui_pressed(IPT_UI_RELOAD_CHEAT))
ReloadCheatDatabase();
ReloadCheatDatabase(machine);
if(input_ui_pressed(IPT_UI_CANCEL))
sel = -1;
@ -7755,7 +7755,7 @@ static int SelectOptions(int selection)
SelectSearch - management for search selection menu
------------------------------------------------------*/
static int SelectSearch(int selection)
static int SelectSearch(running_machine *machine, int selection)
{
INT32 sel;
const char ** menuItem;
@ -7844,7 +7844,7 @@ static int SelectSearch(int selection)
{
AddSearchBefore(sel);
BuildSearchRegions(&searchList[sel]);
BuildSearchRegions(machine, &searchList[sel]);
AllocateSearchRegions(&searchList[sel]);
}
@ -7910,7 +7910,7 @@ static TIMER_CALLBACK( cheat_periodic )
return;
for(i = 0; i < cheatListLength; i++)
cheat_periodicEntry(&cheatList[i]);
cheat_periodicEntry(machine, &cheatList[i]);
}
/*--------------
@ -8921,7 +8921,7 @@ static void RestoreRegionBackup(SearchRegion * region)
DefaultEnableRegion - get default regions you can search
-----------------------------------------------------------*/
static UINT8 DefaultEnableRegion(SearchRegion * region, SearchInfo * info)
static UINT8 DefaultEnableRegion(running_machine *machine, SearchRegion * region, SearchInfo * info)
{
write8_handler handler = region->writeHandler->write.handler8;
FPTR handlerAddress = (FPTR)handler;
@ -8931,7 +8931,7 @@ static UINT8 DefaultEnableRegion(SearchRegion * region, SearchInfo * info)
case kSearchSpeed_Fast:
#if HAS_SH2
if(Machine->drv->cpu[0].type == CPU_SH2)
if(machine->drv->cpu[0].type == CPU_SH2)
{
if( (info->targetType == kRegionType_CPU) && (info->targetIdx == 0) && (region->address == 0x06000000))
return 1;
@ -8947,7 +8947,7 @@ static UINT8 DefaultEnableRegion(SearchRegion * region, SearchInfo * info)
{
/* ----- for neogeo, search bank one ----- */
if( (!strcmp(Machine->gamedrv->parent, "neogeo")) && (info->targetType == kRegionType_CPU) &&
if( (!strcmp(machine->gamedrv->parent, "neogeo")) && (info->targetType == kRegionType_CPU) &&
(info->targetIdx == 0) && (handler == MWA8_BANK1))
return 1;
}
@ -8957,12 +8957,12 @@ static UINT8 DefaultEnableRegion(SearchRegion * region, SearchInfo * info)
#if HAS_TMS34010
/* ----- for exterminator, search bank one ----- */
if( (Machine->drv->cpu[1].type == CPU_TMS34010) && (info->targetType == kRegionType_CPU) &&
if( (machine->drv->cpu[1].type == CPU_TMS34010) && (info->targetType == kRegionType_CPU) &&
(info->targetIdx == 1) && (handler == MWA8_BANK1))
return 1;
/* ----- for smashtv, search bank two ----- */
if( (Machine->drv->cpu[0].type == CPU_TMS34010) && (info->targetType == kRegionType_CPU) &&
if( (machine->drv->cpu[0].type == CPU_TMS34010) && (info->targetType == kRegionType_CPU) &&
(info->targetIdx == 0) && (handler == MWA8_BANK2))
return 1;
@ -9114,7 +9114,7 @@ static void AllocateSearchRegions(SearchInfo * info)
BuildSearchRegions
---------------------*/
static void BuildSearchRegions(SearchInfo * info)
static void BuildSearchRegions(running_machine *machine, SearchInfo * info)
{
info->comparison = kSearchComparison_EqualTo;
@ -9195,7 +9195,7 @@ static void BuildSearchRegions(SearchInfo * info)
traverse->backupLast = NULL;
traverse->backupStatus = NULL;
traverse->flags = DefaultEnableRegion(traverse, info) ? kRegionFlag_Enabled : 0;
traverse->flags = DefaultEnableRegion(machine, traverse, info) ? kRegionFlag_Enabled : 0;
SetSearchRegionDefaultName(traverse);
@ -9364,7 +9364,7 @@ static int ConvertOldCode(int code, int cpu, int * data, int * extendData)
HandleLocalCommandCheat - get special code which is not added into cheat list
--------------------------------------------------------------------------------*/
static void HandleLocalCommandCheat(UINT32 type, UINT32 address, UINT32 data, UINT32 extendData, char * name, char * description)
static void HandleLocalCommandCheat(running_machine *machine, UINT32 type, UINT32 address, UINT32 data, UINT32 extendData, char * name, char * description)
{
switch(EXTRACT_FIELD(type, LocationType))
{
@ -9415,7 +9415,7 @@ static void HandleLocalCommandCheat(UINT32 type, UINT32 address, UINT32 data, UI
overclock /= 65536.0;
cpunum_set_clockscale(address, overclock);
cpunum_set_clockscale(machine, address, overclock);
}
}
break;
@ -9423,7 +9423,7 @@ static void HandleLocalCommandCheat(UINT32 type, UINT32 address, UINT32 data, UI
/* ----- refresh rate ----- */
case kCustomLocation_RefreshRate:
{
screen_state *state = &Machine->screen[0];
screen_state *state = &machine->screen[0];
double refresh = data;
refresh /= 65536.0;
@ -9440,7 +9440,7 @@ static void HandleLocalCommandCheat(UINT32 type, UINT32 address, UINT32 data, UI
LoadCheatFile - load cheat code from database
------------------------------------------------*/
static void LoadCheatFile(char * fileName)
static void LoadCheatFile(running_machine *machine, char * fileName)
{
mame_file * theFile;
file_error filerr;
@ -9459,11 +9459,11 @@ static void LoadCheatFile(char * fileName)
/* ----- make the format strings ----- */
#ifdef MESS
sprintf(formatString, ":%s:%s", Machine->gamedrv->name, "%x:%x:%x:%x:%x:%[^:\n\r]:%[^:\n\r]");
sprintf(oldFormatString, "%s:%s", Machine->gamedrv->name, "%x:%d:%x:%x:%d:%[^:\n\r]:%[^:\n\r]");
sprintf(formatString, ":%s:%s", machine->gamedrv->name, "%x:%x:%x:%x:%x:%[^:\n\r]:%[^:\n\r]");
sprintf(oldFormatString, "%s:%s", machine->gamedrv->name, "%x:%d:%x:%x:%d:%[^:\n\r]:%[^:\n\r]");
#else
sprintf(formatString, ":%s:%s", Machine->gamedrv->name, "%x:%x:%x:%x:%[^:\n\r]:%[^:\n\r]");
sprintf(oldFormatString, "%s:%s", Machine->gamedrv->name, "%d:%x:%x:%d:%[^:\n\r]:%[^:\n\r]");
sprintf(formatString, ":%s:%s", machine->gamedrv->name, "%x:%x:%x:%x:%[^:\n\r]:%[^:\n\r]");
sprintf(oldFormatString, "%s:%s", machine->gamedrv->name, "%d:%x:%x:%d:%[^:\n\r]:%[^:\n\r]");
#endif
/* ----- get a line from database ----- */
@ -9552,7 +9552,7 @@ static void LoadCheatFile(char * fileName)
{
//logerror("cheat: cheat line removed\n", buf);
HandleLocalCommandCheat(type, address, data, extendData, name, description);
HandleLocalCommandCheat(machine, type, address, data, extendData, name, description);
}
else
{
@ -9634,7 +9634,7 @@ static void LoadCheatFile(char * fileName)
LoadCheatDatabase - get the database name then load it
---------------------------------------------------------*/
static void LoadCheatDatabase(void)
static void LoadCheatDatabase(running_machine *machine)
{
char buf[4096];
const char * inTraverse;
@ -9671,7 +9671,7 @@ static void LoadCheatDatabase(void)
if(buf[0])
{
/* ----- load database based on the name we gotten ----- */
LoadCheatFile(buf);
LoadCheatFile(machine, buf);
outTraverse =buf;
buf[0] = 0;
@ -9722,10 +9722,10 @@ static void DisposeCheatDatabase(void)
ReloadCheatDatabase - reload cheat database directly on the cheat menu
-------------------------------------------------------------------------*/
static void ReloadCheatDatabase(void)
static void ReloadCheatDatabase(running_machine *machine)
{
DisposeCheatDatabase();
LoadCheatDatabase();
LoadCheatDatabase(machine);
ui_popup_time(1, "Cheat Database reloaded");
}
@ -9734,7 +9734,7 @@ static void ReloadCheatDatabase(void)
SaveCheat - save a code (normal code, activation key, option)
---------------------------------------------------------------*/
static void SaveCheat(CheatEntry * entry, int selection, int saveCode)
static void SaveCheat(running_machine *machine, CheatEntry * entry, int selection, int saveCode)
{
enum{
normalCode = 0,
@ -9817,9 +9817,9 @@ static void SaveCheat(CheatEntry * entry, int selection, int saveCode)
break;
}
#ifdef MESS
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:%.8X:%.*X:%.8X:%.8X", Machine->gamedrv->name, thisGameCRC, type, addressLength, action->address, action->originalDataField, action->extendData);
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:%.8X:%.*X:%.8X:%.8X", machine->gamedrv->name, thisGameCRC, type, addressLength, action->address, action->originalDataField, action->extendData);
#else
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:%.*X:%.8X:%.8X", Machine->gamedrv->name, type, addressLength, action->address, action->originalDataField, action->extendData);
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:%.*X:%.8X:%.8X", machine->gamedrv->name, type, addressLength, action->address, action->originalDataField, action->extendData);
#endif
/* ----- set description and comment ----- */
if(name)
@ -9863,14 +9863,14 @@ static void SaveCheat(CheatEntry * entry, int selection, int saveCode)
addressLength = cpuInfoList[EXTRACT_FIELD(entry->actionList[1].type, LocationParameter)].addressCharsNeeded;
#ifdef MESS
if(!i)
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:63004000:%.*X:%.8X:00000000", Machine->gamedrv->name, thisGameCRC, addressLength, selection, entry->activationKey1);
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:63004000:%.*X:%.8X:00000000", machine->gamedrv->name, thisGameCRC, addressLength, selection, entry->activationKey1);
else
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:63004001:%.*X:%.8X:00000000", Machine->gamedrv->name, thisGameCRC, addressLength, selection, entry->activationKey2);
bufTraverse += sprintf(bufTraverse, ":%s:%.8X:63004001:%.*X:%.8X:00000000", machine->gamedrv->name, thisGameCRC, addressLength, selection, entry->activationKey2);
#else
if(!i)
bufTraverse += sprintf(bufTraverse, ":%s:63004000:%.*X:%.8X:00000000", Machine->gamedrv->name, addressLength, selection, entry->activationKey1);
bufTraverse += sprintf(bufTraverse, ":%s:63004000:%.*X:%.8X:00000000", machine->gamedrv->name, addressLength, selection, entry->activationKey1);
else
bufTraverse += sprintf(bufTraverse, ":%s:63004001:%.*X:%.8X:00000000", Machine->gamedrv->name, addressLength, selection, entry->activationKey2);
bufTraverse += sprintf(bufTraverse, ":%s:63004001:%.*X:%.8X:00000000", machine->gamedrv->name, addressLength, selection, entry->activationKey2);
#endif
/* ----- set description and button index ----- */
if(!i)
@ -9922,7 +9922,7 @@ static void SaveCheat(CheatEntry * entry, int selection, int saveCode)
DoAutoSaveCheat - save normal code automatically when exit cheat system
--------------------------------------------------------------------------*/
static void DoAutoSaveCheats(void)
static void DoAutoSaveCheats(running_machine *machine)
{
int i;
@ -9931,7 +9931,7 @@ static void DoAutoSaveCheats(void)
CheatEntry * entry = &cheatList[i];
if(entry->flags & kCheatFlag_Dirty)
SaveCheat(entry, 0, 0);
SaveCheat(machine, entry, 0, 0);
}
}
@ -11359,7 +11359,7 @@ static void cheat_periodicOperation(CheatAction * action)
cheat_periodicAction - management for cheat actions
------------------------------------------------------*/
static void cheat_periodicAction(CheatAction * action)
static void cheat_periodicAction(running_machine *machine, CheatAction * action)
{
UINT8 parameter = EXTRACT_FIELD(action->type, TypeParameter);
@ -11400,7 +11400,7 @@ static void cheat_periodicAction(CheatAction * action)
/* ----- keep if one shot + restore prevous value + delay !=0 ----- */
cheat_periodicOperation(action);
if(action->frameTimer >= (parameter * ATTOSECONDS_TO_HZ(Machine->screen[0].refresh)))
if(action->frameTimer >= (parameter * ATTOSECONDS_TO_HZ(machine->screen[0].refresh)))
{
action->frameTimer = 0;
@ -11412,7 +11412,7 @@ static void cheat_periodicAction(CheatAction * action)
else
{
/* ----- otherwise, delay ----- */
if(action->frameTimer >= (parameter * ATTOSECONDS_TO_HZ(Machine->screen[0].refresh)))
if(action->frameTimer >= (parameter * ATTOSECONDS_TO_HZ(machine->screen[0].refresh)))
{
action->frameTimer = 0;
@ -11451,7 +11451,7 @@ static void cheat_periodicAction(CheatAction * action)
if(currentValue != action->lastValue)
{
action->frameTimer = parameter * ATTOSECONDS_TO_HZ(Machine->screen[0].refresh);
action->frameTimer = parameter * ATTOSECONDS_TO_HZ(machine->screen[0].refresh);
action->flags |= kActionFlag_WasModified;
}
@ -11487,7 +11487,7 @@ static void cheat_periodicAction(CheatAction * action)
cheat_periodicEntry - management for cheat entries
-----------------------------------------------------*/
static void cheat_periodicEntry(CheatEntry * entry)
static void cheat_periodicEntry(running_machine *machine, CheatEntry * entry)
{
int i;
@ -11596,7 +11596,7 @@ static void cheat_periodicEntry(CheatEntry * entry)
do{
if(!(entry->flags & kCheatFlag_OneShot) || (entry->flags & kCheatFlag_DoOneShot))
cheat_periodicAction(&entry->actionList[i]);
cheat_periodicAction(machine, &entry->actionList[i]);
i++;
@ -11659,7 +11659,7 @@ static void cheat_periodicEntry(CheatEntry * entry)
/* ----- update all actions ----- */
for(i = 0; i < entry->actionListLength; i++)
cheat_periodicAction(&entry->actionList[i]);
cheat_periodicAction(machine, &entry->actionList[i]);
/* ----- if all actions are done, deactivate the cheat if oneshot entry ----- */
{
@ -11778,13 +11778,13 @@ static int IsAddressInRange(CheatAction * action, UINT32 length)
BuildCPUInfoList - get CPU info when initialize cheat system
---------------------------------------------------------------*/
static void BuildCPUInfoList(void)
static void BuildCPUInfoList(running_machine *machine)
{
int i;
/* ----- do regions ----- */
{
const rom_entry * traverse = rom_first_region(Machine->gamedrv);
const rom_entry * traverse = rom_first_region(machine->gamedrv);
memset(regionInfoList, 0, sizeof(CPUInfo) * kRegionListLength);
@ -11846,7 +11846,7 @@ static void BuildCPUInfoList(void)
CPUInfo * info = &cpuInfoList[i];
CPUInfo * regionInfo = &regionInfoList[REGION_CPU1 + i - REGION_INVALID];
cpu_type type = Machine->drv->cpu[i].type;
cpu_type type = machine->drv->cpu[i].type;
info->type = type;
info->dataBits = cputype_databus_width(type, ADDRESS_SPACE_PROGRAM);

2
src/emu/cheat.h
View File

@ -18,7 +18,7 @@
void cheat_init(running_machine *machine);
int cheat_menu(int selection);
int cheat_menu(running_machine *machine, int selection);
void cheat_display_watches(void);

42
src/emu/config.c
View File

@ -53,8 +53,8 @@ static config_type *typelist;
FUNCTION PROTOTYPES
***************************************************************************/
static int config_load_xml(mame_file *file, int type);
static int config_save_xml(mame_file *file, int type);
static int config_load_xml(running_machine *machine, mame_file *file, int type);
static int config_save_xml(running_machine *machine, mame_file *file, int type);
@ -111,7 +111,7 @@ void config_register(const char *nodename, config_callback load, config_callback
*
*************************************/
int config_load_settings(void)
int config_load_settings(running_machine *machine)
{
const char *controller = options_get_string(mame_options(), OPTION_CTRLR);
file_error filerr;
@ -136,7 +136,7 @@ int config_load_settings(void)
fatalerror("Could not load controller file %s.cfg", controller);
/* load the XML */
if (!config_load_xml(file, CONFIG_TYPE_CONTROLLER))
if (!config_load_xml(machine, file, CONFIG_TYPE_CONTROLLER))
fatalerror("Could not load controller file %s.cfg", controller);
mame_fclose(file);
}
@ -145,18 +145,18 @@ int config_load_settings(void)
filerr = mame_fopen(SEARCHPATH_CONFIG, "default.cfg", OPEN_FLAG_READ, &file);
if (filerr == FILERR_NONE)
{
config_load_xml(file, CONFIG_TYPE_DEFAULT);
config_load_xml(machine, file, CONFIG_TYPE_DEFAULT);
mame_fclose(file);
}
/* finally, load the game-specific file */
fname = astring_assemble_2(astring_alloc(), Machine->basename, ".cfg");
fname = astring_assemble_2(astring_alloc(), machine->basename, ".cfg");
filerr = mame_fopen(SEARCHPATH_CONFIG, astring_c(fname), OPEN_FLAG_READ, &file);
astring_free(fname);
if (filerr == FILERR_NONE)
{
loaded = config_load_xml(file, CONFIG_TYPE_GAME);
loaded = config_load_xml(machine, file, CONFIG_TYPE_GAME);
mame_fclose(file);
}
@ -170,7 +170,7 @@ int config_load_settings(void)
}
void config_save_settings(void)
void config_save_settings(running_machine *machine)
{
file_error filerr;
config_type *type;
@ -185,18 +185,18 @@ void config_save_settings(void)
filerr = mame_fopen(SEARCHPATH_CONFIG, "default.cfg", OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
if (filerr == FILERR_NONE)
{
config_save_xml(file, CONFIG_TYPE_DEFAULT);
config_save_xml(machine, file, CONFIG_TYPE_DEFAULT);
mame_fclose(file);
}
/* finally, save the game-specific file */
fname = astring_assemble_2(astring_alloc(), Machine->basename, ".cfg");
fname = astring_assemble_2(astring_alloc(), machine->basename, ".cfg");
filerr = mame_fopen(SEARCHPATH_CONFIG, astring_c(fname), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
astring_free(fname);
if (filerr == FILERR_NONE)
{
config_save_xml(file, CONFIG_TYPE_GAME);
config_save_xml(machine, file, CONFIG_TYPE_GAME);
mame_fclose(file);
}
@ -213,7 +213,7 @@ void config_save_settings(void)
*
*************************************/
static int config_load_xml(mame_file *file, int which_type)
static int config_load_xml(running_machine *machine, mame_file *file, int which_type)
{
xml_data_node *root, *confignode, *systemnode;
config_type *type;
@ -236,13 +236,13 @@ static int config_load_xml(mame_file *file, int which_type)
goto error;
/* strip off all the path crap from the source filename */
srcfile = strrchr(Machine->gamedrv->source_file, '/');
srcfile = strrchr(machine->gamedrv->source_file, '/');
if (!srcfile)
srcfile = strrchr(Machine->gamedrv->source_file, '\\');
srcfile = strrchr(machine->gamedrv->source_file, '\\');
if (!srcfile)
srcfile = strrchr(Machine->gamedrv->source_file, ':');
srcfile = strrchr(machine->gamedrv->source_file, ':');
if (!srcfile)
srcfile = Machine->gamedrv->source_file;
srcfile = machine->gamedrv->source_file;
else
srcfile++;
@ -258,7 +258,7 @@ static int config_load_xml(mame_file *file, int which_type)
{
case CONFIG_TYPE_GAME:
/* only match on the specific game name */
if (strcmp(name, Machine->gamedrv->name) != 0)
if (strcmp(name, machine->gamedrv->name) != 0)
continue;
break;
@ -273,9 +273,9 @@ static int config_load_xml(mame_file *file, int which_type)
const game_driver *clone_of;
/* match on: default, game name, source file name, parent name, grandparent name */
if (strcmp(name, "default") != 0 &&
strcmp(name, Machine->gamedrv->name) != 0 &&
strcmp(name, machine->gamedrv->name) != 0 &&
strcmp(name, srcfile) != 0 &&
((clone_of = driver_get_clone(Machine->gamedrv)) == NULL || strcmp(name, clone_of->name) != 0) &&
((clone_of = driver_get_clone(machine->gamedrv)) == NULL || strcmp(name, clone_of->name) != 0) &&
(clone_of == NULL || ((clone_of = driver_get_clone(clone_of)) == NULL) || strcmp(name, clone_of->name) != 0))
continue;
break;
@ -314,7 +314,7 @@ error:
*
*************************************/
static int config_save_xml(mame_file *file, int which_type)
static int config_save_xml(running_machine *machine, mame_file *file, int which_type)
{
xml_data_node *root = xml_file_create();
xml_data_node *confignode, *systemnode;
@ -334,7 +334,7 @@ static int config_save_xml(mame_file *file, int which_type)
systemnode = xml_add_child(confignode, "system", NULL);
if (!systemnode)
goto error;
xml_set_attribute(systemnode, "name", (which_type == CONFIG_TYPE_DEFAULT) ? "default" : Machine->gamedrv->name);
xml_set_attribute(systemnode, "name", (which_type == CONFIG_TYPE_DEFAULT) ? "default" : machine->gamedrv->name);
/* create the input node and write it out */
/* loop over all registrants and call their save function */

4
src/emu/config.h
View File

@ -55,7 +55,7 @@ typedef void (*config_callback)(int config_type, xml_data_node *parentnode);
void config_init(running_machine *machine);
void config_register(const char *nodename, config_callback load, config_callback save);
int config_load_settings(void);
void config_save_settings(void);
int config_load_settings(running_machine *machine);
void config_save_settings(running_machine *machine);
#endif /* __CONFIG_H__ */

2
src/emu/cpu/ccpu/ccpu.c
View File

@ -569,7 +569,7 @@ static int ccpu_execute(int cycles)
/* CST */
case 0xf7:
watchdog_reset();
watchdog_reset(Machine);
/* ADDP */
case 0xe7:
tempval = RDMEM(ccpu.I);

16
src/emu/cpu/m37710/m37710.c
View File

@ -276,7 +276,7 @@ static TIMER_CALLBACK( m37710_timer_a0_cb)
m37710i_cpu.m37710_regs[m37710_irq_levels[12]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERA0, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -289,7 +289,7 @@ static TIMER_CALLBACK( m37710_timer_a1_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[11]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERA1, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -302,7 +302,7 @@ static TIMER_CALLBACK( m37710_timer_a2_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[10]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERA2, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -315,7 +315,7 @@ static TIMER_CALLBACK( m37710_timer_a3_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[9]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERA3, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -328,7 +328,7 @@ static TIMER_CALLBACK( m37710_timer_a4_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[8]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERA4, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -341,7 +341,7 @@ static TIMER_CALLBACK( m37710_timer_b0_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[7]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERB0, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -354,7 +354,7 @@ static TIMER_CALLBACK( m37710_timer_b1_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[6]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERB1, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}
@ -367,7 +367,7 @@ static TIMER_CALLBACK( m37710_timer_b2_cb )
m37710i_cpu.m37710_regs[m37710_irq_levels[5]] |= 0x04;
m37710_set_irq_line(M37710_LINE_TIMERB2, PULSE_LINE);
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
cpuintrf_pop_context();
}

2
src/emu/cpu/tms34010/tms34010.c
View File

@ -804,7 +804,7 @@ static TIMER_CALLBACK( internal_interrupt_callback )
cpuintrf_pop_context();
/* generate triggers so that spin loops can key off them */
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
}

92
src/emu/cpuexec.c
View File

@ -155,12 +155,12 @@ static emu_timer *watchdog_timer;
static void cpuexec_exit(running_machine *machine);
static void cpuexec_reset(running_machine *machine);
static void cpu_inittimers(running_machine *machine);
static void cpu_vblankreset(void);
static void cpu_vblankreset(running_machine *machine);
static TIMER_CALLBACK( cpu_vblankcallback );
static TIMER_CALLBACK( cpu_updatecallback );
static TIMER_CALLBACK( end_interleave_boost );
static void compute_perfect_interleave(void);
static void watchdog_setup(int alloc_new);
static void compute_perfect_interleave(running_machine *machine);
static void watchdog_setup(running_machine *machine, int alloc_new);
@ -200,7 +200,7 @@ void cpuexec_init(running_machine *machine)
/* allocate vblank and refresh timers, and compute the initial timing */
vblank_timer = timer_alloc(cpu_vblankcallback, NULL);
refresh_timer = timer_alloc(NULL, NULL);
cpu_compute_vblank_timing();
cpu_compute_vblank_timing(machine);
/* loop over all our CPUs */
for (cpunum = 0; cpunum < MAX_CPU; cpunum++)
@ -260,7 +260,7 @@ void cpuexec_init(running_machine *machine)
add_exit_callback(machine, cpuexec_exit);
/* compute the perfect interleave factor */
compute_perfect_interleave();
compute_perfect_interleave(machine);
/* save some stuff in the default tag */
state_save_push_tag(0);
@ -286,7 +286,7 @@ static void cpuexec_reset(running_machine *machine)
/* initialize the various timers (suspends all CPUs at startup) */
cpu_inittimers(machine);
watchdog_counter = WATCHDOG_IS_INVALID;
watchdog_setup(TRUE);
watchdog_setup(machine, TRUE);
/* first pass over CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
@ -305,7 +305,7 @@ static void cpuexec_reset(running_machine *machine)
}
/* reset the globals */
cpu_vblankreset();
cpu_vblankreset(machine);
vblank = 0;
current_frame = 0;
}
@ -355,21 +355,21 @@ static TIMER_CALLBACK( watchdog_callback )
*
*************************************/
static void watchdog_setup(int alloc_new)
static void watchdog_setup(running_machine *machine, int alloc_new)
{
if (watchdog_counter != WATCHDOG_IS_DISABLED)
{
if (Machine->drv->watchdog_vblank_count)
if (machine->drv->watchdog_vblank_count)
{
/* Start a vblank based watchdog. */
watchdog_counter = Machine->drv->watchdog_vblank_count;
watchdog_counter = machine->drv->watchdog_vblank_count;
}
else if (attotime_compare(Machine->drv->watchdog_time, attotime_zero) != 0)
else if (attotime_compare(machine->drv->watchdog_time, attotime_zero) != 0)
{
/* Start a time based watchdog. */
if (alloc_new)
watchdog_timer = timer_alloc(watchdog_callback, NULL);
timer_adjust(watchdog_timer, Machine->drv->watchdog_time, 0, attotime_zero);
timer_adjust(watchdog_timer, machine->drv->watchdog_time, 0, attotime_zero);
watchdog_counter = WATCHDOG_IS_TIMER_BASED;
}
else if (watchdog_counter == WATCHDOG_IS_INVALID)
@ -390,7 +390,7 @@ static void watchdog_setup(int alloc_new)
* The 3 seconds delay is targeted at qzshowby, which otherwise
* would reset at the start of a game.
*/
watchdog_counter = 3 * ATTOSECONDS_TO_HZ(Machine->screen[0].refresh);
watchdog_counter = 3 * ATTOSECONDS_TO_HZ(machine->screen[0].refresh);
}
}
}
@ -403,11 +403,11 @@ static void watchdog_setup(int alloc_new)
*
*************************************/
void watchdog_reset(void)
void watchdog_reset(running_machine *machine)
{
if (watchdog_counter == WATCHDOG_IS_TIMER_BASED)
{
timer_reset(watchdog_timer, Machine->drv->watchdog_time);
timer_reset(watchdog_timer, machine->drv->watchdog_time);
}
else
{
@ -417,7 +417,7 @@ void watchdog_reset(void)
logerror("(vblank) watchdog armed by reset\n");
}
watchdog_setup(FALSE);
watchdog_setup(machine, FALSE);
}
}
@ -429,7 +429,7 @@ void watchdog_reset(void)
*
*************************************/
void watchdog_enable(int enable)
void watchdog_enable(running_machine *machine, int enable)
{
if (!enable)
{
@ -442,7 +442,7 @@ void watchdog_enable(int enable)
if (watchdog_counter == WATCHDOG_IS_DISABLED)
{
watchdog_counter = WATCHDOG_IS_BEING_STARTED;
watchdog_setup(FALSE);
watchdog_setup(machine, FALSE);
}
}
@ -460,7 +460,7 @@ void watchdog_enable(int enable)
*
*************************************/
void cpuexec_timeslice(void)
void cpuexec_timeslice(running_machine *machine)
{
attotime target = timer_next_fire_time();
attotime base = timer_get_time();
@ -470,7 +470,7 @@ void cpuexec_timeslice(void)
LOG(("cpu_timeslice: target = %s\n", attotime_string(target, 9)));
/* process any pending suspends */
for (cpunum = 0; Machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
for (cpunum = 0; machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
{
if (cpu[cpunum].suspend != cpu[cpunum].nextsuspend)
LOG(("--> updated CPU%d suspend from %X to %X\n", cpunum, cpu[cpunum].suspend, cpu[cpunum].nextsuspend));
@ -479,7 +479,7 @@ void cpuexec_timeslice(void)
}
/* loop over CPUs */
for (cpunum = 0; Machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
for (cpunum = 0; machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
{
/* only process if we're not suspended */
if (!cpu[cpunum].suspend)
@ -525,7 +525,7 @@ void cpuexec_timeslice(void)
}
/* update the local times of all CPUs */
for (cpunum = 0; Machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
for (cpunum = 0; machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
{
/* if we're suspended and counting, process */
if (cpu[cpunum].suspend && cpu[cpunum].eatcycles && attotime_compare(cpu[cpunum].localtime, target) < 0)
@ -677,7 +677,7 @@ int cpunum_get_clock(int cpunum)
*
*************************************/
void cpunum_set_clock(int cpunum, int clock)
void cpunum_set_clock(running_machine *machine, int cpunum, int clock)
{
VERIFY_CPUNUM(cpunum_set_clock);
@ -686,12 +686,12 @@ void cpunum_set_clock(int cpunum, int clock)
attoseconds_per_cycle[cpunum] = ATTOSECONDS_PER_SECOND / ((double)clock * cpu[cpunum].clockscale);
/* re-compute the perfect interleave factor */
compute_perfect_interleave();
compute_perfect_interleave(machine);
}
void cpunum_set_clock_period(int cpunum, attoseconds_t clock_period)
void cpunum_set_clock_period(running_machine *machine, int cpunum, attoseconds_t clock_period)
{
VERIFY_CPUNUM(cpunum_set_clock);
@ -700,7 +700,7 @@ void cpunum_set_clock_period(int cpunum, attoseconds_t clock_period)
attoseconds_per_cycle[cpunum] = clock_period;
/* re-compute the perfect interleave factor */
compute_perfect_interleave();
compute_perfect_interleave(machine);
}
@ -727,7 +727,7 @@ double cpunum_get_clockscale(int cpunum)
*
*************************************/
void cpunum_set_clockscale(int cpunum, double clockscale)
void cpunum_set_clockscale(running_machine *machine, int cpunum, double clockscale)
{
VERIFY_CPUNUM(cpunum_set_clockscale);
@ -736,7 +736,7 @@ void cpunum_set_clockscale(int cpunum, double clockscale)
attoseconds_per_cycle[cpunum] = ATTOSECONDS_PER_SECOND / ((double)cpu[cpunum].clock * clockscale);
/* re-compute the perfect interleave factor */
compute_perfect_interleave();
compute_perfect_interleave(machine);
}
@ -898,12 +898,12 @@ int cpu_scalebyfcount(int value)
*
*************************************/
void cpu_compute_vblank_timing(void)
void cpu_compute_vblank_timing(running_machine *machine)
{
refresh_period = attotime_make(0, Machine->screen[0].refresh);
refresh_period = attotime_make(0, machine->screen[0].refresh);
/* recompute the vblank period */
vblank_period = attotime_make(0, Machine->screen[0].refresh / (vblank_multiplier ? vblank_multiplier : 1));
vblank_period = attotime_make(0, machine->screen[0].refresh / (vblank_multiplier ? vblank_multiplier : 1));
if (vblank_timer != NULL && timer_enable(vblank_timer, FALSE))
{
attotime remaining = timer_timeleft(vblank_timer);
@ -954,7 +954,7 @@ int cpu_getcurrentframe(void)
*
*************************************/
void cpu_trigger(int trigger)
void cpu_trigger(running_machine *machine, int trigger)
{
int cpunum;
@ -966,7 +966,7 @@ void cpu_trigger(int trigger)
for (cpunum = 0; cpunum < MAX_CPU; cpunum++)
{
/* if this is a dummy, stop looking */
if (Machine->drv->cpu[cpunum].type == CPU_DUMMY)
if (machine->drv->cpu[cpunum].type == CPU_DUMMY)
break;
/* see if this is a matching trigger */
@ -988,7 +988,7 @@ void cpu_trigger(int trigger)
static TIMER_CALLBACK( cpu_triggertime_callback )
{
cpu_trigger(param);
cpu_trigger(machine, param);
}
@ -1005,9 +1005,9 @@ void cpu_triggertime(attotime duration, int trigger)
*
*************************************/
void cpu_triggerint(int cpunum)
void cpu_triggerint(running_machine *machine, int cpunum)
{
cpu_trigger(TRIGGER_INT + cpunum);
cpu_trigger(machine, TRIGGER_INT + cpunum);
}
@ -1143,12 +1143,12 @@ int cpu_getiloops(void)
*
*************************************/
static void cpu_vblankreset(void)
static void cpu_vblankreset(running_machine *machine)
{
int cpunum;
/* notify the video system of a VBLANK start */
video_vblank_start(Machine);
video_vblank_start(machine);
/* read keyboard & update the status of the input ports */
input_port_vblank_start();
@ -1159,7 +1159,7 @@ static void cpu_vblankreset(void)
if (--watchdog_counter == 0)
{
logerror("reset caused by the (vblank) watchdog\n");
mame_schedule_soft_reset(Machine);
mame_schedule_soft_reset(machine);
}
}
@ -1167,7 +1167,7 @@ static void cpu_vblankreset(void)
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
if (!(cpu[cpunum].suspend & SUSPEND_REASON_DISABLE))
cpu[cpunum].iloops = Machine->drv->cpu[cpunum].vblank_interrupts_per_frame - 1;
cpu[cpunum].iloops = machine->drv->cpu[cpunum].vblank_interrupts_per_frame - 1;
else
cpu[cpunum].iloops = -1;
}
@ -1245,13 +1245,13 @@ static TIMER_CALLBACK( cpu_vblankcallback )
{
/* do we update the screen now? */
if (!(machine->drv->video_attributes & VIDEO_UPDATE_AFTER_VBLANK))
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
/* Set the timer to update the screen */
timer_adjust(update_timer, attotime_make(0, machine->screen[0].vblank), 0, attotime_zero);
/* reset the globals */
cpu_vblankreset();
cpu_vblankreset(machine);
/* reset the counter */
vblank_countdown = vblank_multiplier;
@ -1275,7 +1275,7 @@ static TIMER_CALLBACK( cpu_updatecallback )
{
/* update the screen if we didn't before */
if (machine->drv->video_attributes & VIDEO_UPDATE_AFTER_VBLANK)
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
vblank = 0;
/* update IPT_VBLANK input ports */
@ -1318,7 +1318,7 @@ static TIMER_CALLBACK( cpu_timedintcallback )
static TIMER_CALLBACK( cpu_timeslicecallback )
{
cpu_trigger(TRIGGER_TIMESLICE);
cpu_trigger(machine, TRIGGER_TIMESLICE);
}
@ -1345,7 +1345,7 @@ static TIMER_CALLBACK( end_interleave_boost )
*
*************************************/
static void compute_perfect_interleave(void)
static void compute_perfect_interleave(running_machine *machine)
{
attoseconds_t smallest = attoseconds_per_cycle[0];
int cpunum;
@ -1353,7 +1353,7 @@ static void compute_perfect_interleave(void)
/* start with a huge time factor and find the 2nd smallest cycle time */
perfect_interleave = attotime_zero;
perfect_interleave.attoseconds = ATTOSECONDS_PER_SECOND - 1;
for (cpunum = 1; Machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
for (cpunum = 1; machine->drv->cpu[cpunum].type != CPU_DUMMY; cpunum++)
{
/* find the 2nd smallest cycle interval */
if (attoseconds_per_cycle[cpunum] < smallest)

18
src/emu/cpuexec.h
View File

@ -263,7 +263,7 @@ enum
void cpuexec_init(running_machine *machine);
/* Execute for a single timeslice */
void cpuexec_timeslice(void);
void cpuexec_timeslice(running_machine *machine);
@ -274,11 +274,11 @@ void cpuexec_timeslice(void);
*************************************/
/* bang on the watchdog */
void watchdog_reset(void);
void watchdog_reset(running_machine *machine);
/* watchdog enabled when TRUE */
/* timer is set to reset state when going from disable to enable */
void watchdog_enable(int enable);
void watchdog_enable(running_machine *machine, int enable);
@ -320,14 +320,14 @@ attotime cpunum_get_localtime(int cpunum);
int cpunum_get_clock(int cpunum);
/* Sets the current CPU's clock speed and then adjusts for scaling */
void cpunum_set_clock(int cpunum, int clock);
void cpunum_set_clock_period(int cpunum, attoseconds_t clock_period);
void cpunum_set_clock(running_machine *machine, int cpunum, int clock);
void cpunum_set_clock_period(running_machine *machine, int cpunum, attoseconds_t clock_period);
/* Returns the current scaling factor for a CPU's clock speed */
double cpunum_get_clockscale(int cpunum);
/* Sets the current scaling factor for a CPU's clock speed */
void cpunum_set_clockscale(int cpunum, double clockscale);
void cpunum_set_clockscale(running_machine *machine, int cpunum, double clockscale);
/* Temporarily boosts the interleave factor */
void cpu_boost_interleave(attotime timeslice_time, attotime boost_duration);
@ -371,7 +371,7 @@ int cpu_scalebyfcount(int value);
/***** These functions may eventually go away. */
/* Recomputes the VBLANK timing after, e.g., a visible area change */
void cpu_compute_vblank_timing(void);
void cpu_compute_vblank_timing(running_machine *machine);
/* Returns the number of the video frame we are currently playing */
int cpu_getcurrentframe(void);
@ -385,13 +385,13 @@ int cpu_getcurrentframe(void);
*************************************/
/* generate a trigger now */
void cpu_trigger(int trigger);
void cpu_trigger(running_machine *machine, int trigger);
/* generate a trigger after a specific period of time */
void cpu_triggertime(attotime duration, int trigger);
/* generate a trigger corresponding to an interrupt on the given CPU */
void cpu_triggerint(int cpunum);
void cpu_triggerint(running_machine *machine, int cpunum);
/* burn CPU cycles until a timer trigger */
void cpu_spinuntil_trigger(int trigger);

2
src/emu/cpuint.c
View File

@ -250,7 +250,7 @@ static TIMER_CALLBACK( cpunum_empty_event_queue )
/* generate a trigger to unsuspend any CPUs waiting on the interrupt */
if (state != CLEAR_LINE)
cpu_triggerint(cpunum);
cpu_triggerint(machine, cpunum);
}
}

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

@ -528,7 +528,7 @@ void debug_halt_on_next_instruction(void)
void debug_refresh_display(void)
{
video_frame_update(TRUE);
video_frame_update(Machine, TRUE);
}

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

@ -685,24 +685,24 @@ INTERRUPT_GEN( irq7_line_assert ) { irqn_line_set(cpunum, 7, ASSERT_LINE); }
8-bit reset read/write handlers
-------------------------------------------------*/
WRITE8_HANDLER( watchdog_reset_w ) { watchdog_reset(); }
READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(); return 0xff; }
WRITE8_HANDLER( watchdog_reset_w ) { watchdog_reset(Machine); }
READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(Machine); return 0xff; }
/*-------------------------------------------------
16-bit reset read/write handlers
-------------------------------------------------*/
WRITE16_HANDLER( watchdog_reset16_w ) { watchdog_reset(); }
READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(); return 0xffff; }
WRITE16_HANDLER( watchdog_reset16_w ) { watchdog_reset(Machine); }
READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(Machine); return 0xffff; }
/*-------------------------------------------------
32-bit reset read/write handlers
-------------------------------------------------*/
WRITE32_HANDLER( watchdog_reset32_w ) { watchdog_reset(); }
READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(); return 0xffffffff; }
WRITE32_HANDLER( watchdog_reset32_w ) { watchdog_reset(Machine); }
READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(Machine); return 0xffffffff; }

12
src/emu/mame.c
View File

@ -365,11 +365,11 @@ int mame_execute(core_options *options)
init_machine(machine);
/* load the configuration settings and NVRAM */
settingsloaded = config_load_settings();
settingsloaded = config_load_settings(machine);
nvram_load();
/* display the startup screens */
ui_display_startup_screens(firstrun, !settingsloaded);
ui_display_startup_screens(machine, firstrun, !settingsloaded);
firstrun = FALSE;
/* start resource tracking; note that soft_reset assumes it can */
@ -388,11 +388,11 @@ int mame_execute(core_options *options)
/* execute CPUs if not paused */
if (!mame->paused)
cpuexec_timeslice();
cpuexec_timeslice(machine);
/* otherwise, just pump video updates through */
else
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
/* handle save/load */
if (mame->saveload_schedule_callback)
@ -409,7 +409,7 @@ int mame_execute(core_options *options)
/* save the NVRAM and configuration */
nvram_save();
config_save_settings();
config_save_settings(machine);
}
mame->fatal_error_jmpbuf_valid = FALSE;
@ -1552,7 +1552,7 @@ static void init_machine(running_machine *machine)
/* call the game driver's init function */
/* this is where decryption is done and memory maps are altered */
/* so this location in the init order is important */
ui_set_startup_text("Initializing...", TRUE);
ui_set_startup_text(machine, "Initializing...", TRUE);
if (machine->gamedrv->driver_init != NULL)
(*machine->gamedrv->driver_init)(machine);

2
src/emu/romload.c
View File

@ -397,7 +397,7 @@ static void display_loading_rom_message(const char *name, rom_load_data *romdata
else
sprintf(buffer, "Loading Complete");
ui_set_startup_text(buffer, FALSE);
ui_set_startup_text(Machine, buffer, FALSE);
}

117
src/emu/ui.c
View File

@ -73,7 +73,7 @@ struct _slider_state
INT32 defval; /* default value */
INT32 maxval; /* maximum value */
INT32 incval; /* increment value */
INT32 (*update)(INT32 newval, char *buffer, int arg); /* callback */
INT32 (*update)(running_machine *machine, INT32 newval, char *buffer, int arg); /* callback */
int arg; /* argument */
};
@ -87,7 +87,7 @@ struct _slider_state
static render_font *ui_font;
/* current UI handler */
static UINT32 (*ui_handler_callback)(UINT32);
static UINT32 (*ui_handler_callback)(running_machine *, UINT32);
static UINT32 ui_handler_param;
/* flag to track single stepping */
@ -129,35 +129,35 @@ static int sprintf_disclaimer(char *buffer);
static int sprintf_warnings(char *buffer);
/* UI handlers */
static UINT32 handler_messagebox(UINT32 state);
static UINT32 handler_messagebox_ok(UINT32 state);
static UINT32 handler_messagebox_anykey(UINT32 state);
static UINT32 handler_ingame(UINT32 state);
static UINT32 handler_slider(UINT32 state);
static UINT32 handler_load_save(UINT32 state);
static UINT32 handler_messagebox(running_machine *machine, UINT32 state);
static UINT32 handler_messagebox_ok(running_machine *machine, UINT32 state);
static UINT32 handler_messagebox_anykey(running_machine *machine, UINT32 state);
static UINT32 handler_ingame(running_machine *machine, UINT32 state);
static UINT32 handler_slider(running_machine *machine, UINT32 state);
static UINT32 handler_load_save(running_machine *machine, UINT32 state);
/* slider controls */
static void slider_init(void);
static void slider_display(const char *text, int minval, int maxval, int defval, int curval);
static void slider_draw_bar(float leftx, float topy, float width, float height, float percentage, float default_percentage);
static INT32 slider_volume(INT32 newval, char *buffer, int arg);
static INT32 slider_mixervol(INT32 newval, char *buffer, int arg);
static INT32 slider_adjuster(INT32 newval, char *buffer, int arg);
static INT32 slider_overclock(INT32 newval, char *buffer, int arg);
static INT32 slider_refresh(INT32 newval, char *buffer, int arg);
static INT32 slider_brightness(INT32 newval, char *buffer, int arg);
static INT32 slider_contrast(INT32 newval, char *buffer, int arg);
static INT32 slider_gamma(INT32 newval, char *buffer, int arg);
static INT32 slider_xscale(INT32 newval, char *buffer, int arg);
static INT32 slider_yscale(INT32 newval, char *buffer, int arg);
static INT32 slider_xoffset(INT32 newval, char *buffer, int arg);
static INT32 slider_yoffset(INT32 newval, char *buffer, int arg);
static INT32 slider_flicker(INT32 newval, char *buffer, int arg);
static INT32 slider_beam(INT32 newval, char *buffer, int arg);
static INT32 slider_volume(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_mixervol(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_adjuster(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_overclock(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_refresh(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_brightness(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_contrast(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_gamma(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_xscale(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_yscale(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_xoffset(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_yoffset(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_flicker(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_beam(running_machine *machine, INT32 newval, char *buffer, int arg);
static char *slider_get_screen_desc(int arg);
#ifdef MAME_DEBUG
static INT32 slider_crossscale(INT32 newval, char *buffer, int arg);
static INT32 slider_crossoffset(INT32 newval, char *buffer, int arg);
static INT32 slider_crossscale(running_machine *machine, INT32 newval, char *buffer, int arg);
static INT32 slider_crossoffset(running_machine *machine, INT32 newval, char *buffer, int arg);
#endif
@ -170,7 +170,7 @@ static INT32 slider_crossoffset(INT32 newval, char *buffer, int arg);
pair for the current UI handler
-------------------------------------------------*/
INLINE UINT32 ui_set_handler(UINT32 (*callback)(UINT32), UINT32 param)
INLINE UINT32 ui_set_handler(UINT32 (*callback)(running_machine *, UINT32), UINT32 param)
{
ui_handler_callback = callback;
ui_handler_param = param;
@ -182,7 +182,8 @@ INLINE UINT32 ui_set_handler(UINT32 (*callback)(UINT32), UINT32 param)
slider_config - configure a slider entry
-------------------------------------------------*/
INLINE void slider_config(slider_state *state, INT32 minval, INT32 defval, INT32 maxval, INT32 incval, INT32 (*update)(INT32, char *, int), int arg)
INLINE void slider_config(slider_state *state, INT32 minval, INT32 defval, INT32 maxval, INT32 incval,
INT32 (*update)(running_machine *, INT32, char *, int), int arg)
{
state->minval = minval;
state->defval = defval;
@ -304,7 +305,7 @@ static int rescale_notifier(running_machine *machine, int width, int height)
various startup screens
-------------------------------------------------*/
int ui_display_startup_screens(int first_time, int show_disclaimer)
int ui_display_startup_screens(running_machine *machine, int first_time, int show_disclaimer)
{
#ifdef MESS
const int maxstate = 4;
@ -363,11 +364,11 @@ int ui_display_startup_screens(int first_time, int show_disclaimer)
/* loop while we have a handler */
while (ui_handler_callback != handler_ingame && !mame_is_scheduled_event_pending(Machine) && !ui_menu_is_force_game_select())
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
/* clear the handler and force an update */
ui_set_handler(handler_ingame, 0);
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
}
/* if we're the empty driver, force the menus on */
@ -383,7 +384,7 @@ int ui_display_startup_screens(int first_time, int show_disclaimer)
at startup
-------------------------------------------------*/
void ui_set_startup_text(const char *text, int force)
void ui_set_startup_text(running_machine *machine, const char *text, int force)
{
static osd_ticks_t lastupdatetime = 0;
osd_ticks_t curtime = osd_ticks();
@ -396,7 +397,7 @@ void ui_set_startup_text(const char *text, int force)
if (force || (curtime - lastupdatetime) > osd_ticks_per_second() / 4)
{
lastupdatetime = curtime;
video_frame_update(FALSE);
video_frame_update(machine, FALSE);
}
}
@ -406,7 +407,7 @@ void ui_set_startup_text(const char *text, int force)
render it; called by video.c
-------------------------------------------------*/
void ui_update_and_render(void)
void ui_update_and_render(running_machine *machine)
{
/* always start clean */
render_container_empty(render_container_get_ui());
@ -425,7 +426,7 @@ void ui_update_and_render(void)
/* call the current UI handler */
assert(ui_handler_callback != NULL);
ui_handler_param = (*ui_handler_callback)(ui_handler_param);
ui_handler_param = (*ui_handler_callback)(machine, ui_handler_param);
/* cancel takes us back to the ingame handler */
if (ui_handler_param == UI_HANDLER_CANCEL)
@ -1131,7 +1132,7 @@ int sprintf_game_info(char *buffer)
messagebox_text string but handles no input
-------------------------------------------------*/
static UINT32 handler_messagebox(UINT32 state)
static UINT32 handler_messagebox(running_machine *machine, UINT32 state)
{
ui_draw_text_box(messagebox_text, JUSTIFY_LEFT, 0.5f, 0.5f, messagebox_backcolor);
return 0;
@ -1143,7 +1144,7 @@ static UINT32 handler_messagebox(UINT32 state)
messagebox_text string and waits for an OK
-------------------------------------------------*/
static UINT32 handler_messagebox_ok(UINT32 state)
static UINT32 handler_messagebox_ok(running_machine *machine, UINT32 state)
{
/* draw a standard message window */
ui_draw_text_box(messagebox_text, JUSTIFY_LEFT, 0.5f, 0.5f, messagebox_backcolor);
@ -1173,7 +1174,7 @@ static UINT32 handler_messagebox_ok(UINT32 state)
any keypress
-------------------------------------------------*/
static UINT32 handler_messagebox_anykey(UINT32 state)
static UINT32 handler_messagebox_anykey(running_machine *machine, UINT32 state)
{
/* draw a standard message window */
ui_draw_text_box(messagebox_text, JUSTIFY_LEFT, 0.5f, 0.5f, messagebox_backcolor);
@ -1198,7 +1199,7 @@ static UINT32 handler_messagebox_anykey(UINT32 state)
of the standard keypresses
-------------------------------------------------*/
static UINT32 handler_ingame(UINT32 state)
static UINT32 handler_ingame(running_machine *machine, UINT32 state)
{
int is_paused = mame_is_paused(Machine);
@ -1372,7 +1373,7 @@ static UINT32 handler_ingame(UINT32 state)
and calls the slider handler
-------------------------------------------------*/
static UINT32 handler_slider(UINT32 state)
static UINT32 handler_slider(running_machine *machine, UINT32 state)
{
slider_state *cur = &slider_list[slider_current];
INT32 increment = 0, newval;
@ -1396,7 +1397,7 @@ static UINT32 handler_slider(UINT32 state)
}
/* determine the new value */
newval = (*cur->update)(0, NULL, cur->arg) + increment;
newval = (*cur->update)(machine, 0, NULL, cur->arg) + increment;
/* select resets to the default value */
if (input_ui_pressed(IPT_UI_SELECT))
@ -1409,7 +1410,7 @@ static UINT32 handler_slider(UINT32 state)
newval = cur->maxval;
/* update the new data and get the text */
(*cur->update)(newval, textbuf, cur->arg);
(*cur->update)(machine, newval, textbuf, cur->arg);
/* display the UI */
slider_display(textbuf, cur->minval, cur->maxval, cur->defval, newval);
@ -1437,7 +1438,7 @@ static UINT32 handler_slider(UINT32 state)
specifying a game to save or load
-------------------------------------------------*/
static UINT32 handler_load_save(UINT32 state)
static UINT32 handler_load_save(running_machine *machine, UINT32 state)
{
char filename[20];
input_code code;
@ -1651,7 +1652,7 @@ static void slider_draw_bar(float leftx, float topy, float width, float height,
slider_volume - global volume slider callback
-------------------------------------------------*/
static INT32 slider_volume(INT32 newval, char *buffer, int arg)
static INT32 slider_volume(running_machine *machine, INT32 newval, char *buffer, int arg)
{
if (buffer != NULL)
{
@ -1667,7 +1668,7 @@ static INT32 slider_volume(INT32 newval, char *buffer, int arg)
slider callback
-------------------------------------------------*/
static INT32 slider_mixervol(INT32 newval, char *buffer, int arg)
static INT32 slider_mixervol(running_machine *machine, INT32 newval, char *buffer, int arg)
{
if (buffer != NULL)
{
@ -1683,7 +1684,7 @@ static INT32 slider_mixervol(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_adjuster(INT32 newval, char *buffer, int arg)
static INT32 slider_adjuster(running_machine *machine, INT32 newval, char *buffer, int arg)
{
input_port_entry *in = &Machine->input_ports[arg];
if (buffer != NULL)
@ -1700,11 +1701,11 @@ static INT32 slider_adjuster(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_overclock(INT32 newval, char *buffer, int arg)
static INT32 slider_overclock(running_machine *machine, INT32 newval, char *buffer, int arg)
{
if (buffer != NULL)
{
cpunum_set_clockscale(arg, (float)newval * 0.001f);
cpunum_set_clockscale(machine, arg, (float)newval * 0.001f);
sprintf(buffer, "Overclock CPU %d %3.0f%%", arg, floor(cpunum_get_clockscale(arg) * 100.0f + 0.5f));
}
return floor(cpunum_get_clockscale(arg) * 1000.0f + 0.5f);
@ -1715,7 +1716,7 @@ static INT32 slider_overclock(INT32 newval, char *buffer, int arg)
slider_refresh - refresh rate slider callback
-------------------------------------------------*/
static INT32 slider_refresh(INT32 newval, char *buffer, int arg)
static INT32 slider_refresh(running_machine *machine, INT32 newval, char *buffer, int arg)
{
double defrefresh = ATTOSECONDS_TO_HZ(Machine->drv->screen[arg].defstate.refresh);
double refresh;
@ -1736,7 +1737,7 @@ static INT32 slider_refresh(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_brightness(INT32 newval, char *buffer, int arg)
static INT32 slider_brightness(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1753,7 +1754,7 @@ static INT32 slider_brightness(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_contrast(INT32 newval, char *buffer, int arg)
static INT32 slider_contrast(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1769,7 +1770,7 @@ static INT32 slider_contrast(INT32 newval, char *buffer, int arg)
slider_gamma - screen gamma slider callback
-------------------------------------------------*/
static INT32 slider_gamma(INT32 newval, char *buffer, int arg)
static INT32 slider_gamma(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1786,7 +1787,7 @@ static INT32 slider_gamma(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_xscale(INT32 newval, char *buffer, int arg)
static INT32 slider_xscale(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1803,7 +1804,7 @@ static INT32 slider_xscale(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_yscale(INT32 newval, char *buffer, int arg)
static INT32 slider_yscale(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1820,7 +1821,7 @@ static INT32 slider_yscale(INT32 newval, char *buffer, int arg)
slider callback
-------------------------------------------------*/
static INT32 slider_xoffset(INT32 newval, char *buffer, int arg)
static INT32 slider_xoffset(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1837,7 +1838,7 @@ static INT32 slider_xoffset(INT32 newval, char *buffer, int arg)
slider callback
-------------------------------------------------*/
static INT32 slider_yoffset(INT32 newval, char *buffer, int arg)
static INT32 slider_yoffset(running_machine *machine, INT32 newval, char *buffer, int arg)
{
render_container *container = render_container_get_screen(arg);
if (buffer != NULL)
@ -1854,7 +1855,7 @@ static INT32 slider_yoffset(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_flicker(INT32 newval, char *buffer, int arg)
static INT32 slider_flicker(running_machine *machine, INT32 newval, char *buffer, int arg)
{
if (buffer != NULL)
{
@ -1870,7 +1871,7 @@ static INT32 slider_flicker(INT32 newval, char *buffer, int arg)
callback
-------------------------------------------------*/
static INT32 slider_beam(INT32 newval, char *buffer, int arg)
static INT32 slider_beam(running_machine *machine, INT32 newval, char *buffer, int arg)
{
if (buffer != NULL)
{
@ -1911,7 +1912,7 @@ static char *slider_get_screen_desc(int arg)
-------------------------------------------------*/
#ifdef MAME_DEBUG
static INT32 slider_crossscale(INT32 newval, char *buffer, int arg)
static INT32 slider_crossscale(running_machine *machine, INT32 newval, char *buffer, int arg)
{
input_port_entry *in;
@ -1939,7 +1940,7 @@ static INT32 slider_crossscale(INT32 newval, char *buffer, int arg)
-------------------------------------------------*/
#ifdef MAME_DEBUG
static INT32 slider_crossoffset(INT32 newval, char *buffer, int arg)
static INT32 slider_crossoffset(running_machine *machine, INT32 newval, char *buffer, int arg)
{
input_port_entry *in;

6
src/emu/ui.h
View File

@ -86,13 +86,13 @@ enum
int ui_init(running_machine *machine);
/* display the startup screens */
int ui_display_startup_screens(int first_time, int show_disclaimer);
int ui_display_startup_screens(running_machine *machine, int first_time, int show_disclaimer);
/* set the current text to display at startup */
void ui_set_startup_text(const char *text, int force);
void ui_set_startup_text(running_machine *machine, const char *text, int force);
/* once-per-frame update and render */
void ui_update_and_render(void);
void ui_update_and_render(running_machine *machine);
/* returns the current UI font */
render_font *ui_get_font(void);

2
src/emu/uigfx.c
View File

@ -149,7 +149,7 @@ static void ui_gfx_exit(running_machine *machine)
ui_gfx_ui_handler - primary UI handler
-------------------------------------------------*/
UINT32 ui_gfx_ui_handler(UINT32 uistate)
UINT32 ui_gfx_ui_handler(running_machine *machine, UINT32 uistate)
{
ui_gfx_state *state = &ui_gfx;

2
src/emu/uigfx.h
View File

@ -25,7 +25,7 @@
void ui_gfx_init(running_machine *machine);
/* master handler */
UINT32 ui_gfx_ui_handler(UINT32 state);
UINT32 ui_gfx_ui_handler(running_machine *machine, UINT32 state);
#endif /* __UIGFX_H__ */

4
src/emu/uimenu.c
View File

@ -684,7 +684,7 @@ UINT32 ui_menu_stack_pop(void)
and calls the menu handler
-------------------------------------------------*/
UINT32 ui_menu_ui_handler(UINT32 state)
UINT32 ui_menu_ui_handler(running_machine *machine, UINT32 state)
{
UINT32 newstate;
@ -1264,7 +1264,7 @@ static UINT32 menu_game_info(UINT32 state)
static UINT32 menu_cheat(UINT32 state)
{
int result = cheat_menu(state);
int result = cheat_menu(Machine, state);
if (result == 0)
return ui_menu_stack_pop();
return result;

2
src/emu/uimenu.h
View File

@ -66,7 +66,7 @@ void ui_menu_init(running_machine *machine);
int ui_menu_draw(const ui_menu_item *items, int numitems, int selected, const menu_extra *extra);
/* master handler */
UINT32 ui_menu_ui_handler(UINT32 state);
UINT32 ui_menu_ui_handler(running_machine *machine, UINT32 state);
/* menu keyboard handling */
int ui_menu_generic_keys(UINT32 *selected, int num_items, int visible_items);

8
src/emu/video.c
View File

@ -643,7 +643,7 @@ static void decode_graphics(running_machine *machine, const gfx_decode_entry *gf
/* display some startup text */
sprintf(buffer, "Decoding (%d%%)", curgfx * 100 / totalgfx);
ui_set_startup_text(buffer, FALSE);
ui_set_startup_text(machine, buffer, FALSE);
}
}
@ -755,7 +755,7 @@ void video_screen_configure(int scrnum, int width, int height, const rectangle *
}
/* recompute the VBLANK timing */
cpu_compute_vblank_timing();
cpu_compute_vblank_timing(Machine);
/* if we are on scanline 0 already, reset the update timer immediately */
/* otherwise, defer until the next scanline 0 */
@ -1034,7 +1034,7 @@ static TIMER_CALLBACK( scanline0_callback )
operations
-------------------------------------------------*/
void video_frame_update(int debug)
void video_frame_update(running_machine *machine, int debug)
{
attotime current_time = timer_get_time();
int skipped_it = global.skipping_this_frame;
@ -1055,7 +1055,7 @@ void video_frame_update(int debug)
}
/* draw the user interface */
ui_update_and_render();
ui_update_and_render(machine);
/* if we're throttling, synchronize before rendering */
if (!debug && !skipped_it && effective_throttle())

2
src/emu/video.h
View File

@ -117,7 +117,7 @@ int video_screen_exists(int scrnum);
/* ----- global rendering ----- */
/* update the screen, handling frame skipping and rendering */
void video_frame_update(int debug);
void video_frame_update(running_machine *machine, int debug);
/* ----- throttling/frameskipping/performance ----- */

10
src/emu/video/voodoo.c
View File

@ -197,7 +197,7 @@ static void init_fbi(voodoo_state *v, fbi_state *f, void *memory, int fbmem);
static void init_tmu_shared(tmu_shared_state *s);
static void init_tmu(voodoo_state *v, tmu_state *t, int type, voodoo_reg *reg, void *memory, int tmem);
static void soft_reset(voodoo_state *v);
static void check_stalled_cpu(voodoo_state *v, attotime current_time);
static void check_stalled_cpu(running_machine *machine, voodoo_state *v, attotime current_time);
static void flush_fifos(voodoo_state *v, attotime current_time);
static TIMER_CALLBACK( stall_cpu_callback );
static void stall_cpu(voodoo_state *v, int state, attotime current_time);
@ -1019,7 +1019,7 @@ static void swap_buffers(voodoo_state *v)
/* we may be able to unstall now */
if (v->pci.stall_state != NOT_STALLED)
check_stalled_cpu(v, timer_get_time());
check_stalled_cpu(Machine, v, timer_get_time());
/* periodically log rasterizer info */
v->stats.swaps++;
@ -2141,11 +2141,11 @@ static void cmdfifo_w(voodoo_state *v, cmdfifo_info *f, offs_t offset, UINT32 da
static TIMER_CALLBACK( stall_cpu_callback )
{
check_stalled_cpu(ptr, timer_get_time());
check_stalled_cpu(machine, ptr, timer_get_time());
}
static void check_stalled_cpu(voodoo_state *v, attotime current_time)
static void check_stalled_cpu(running_machine *machine, voodoo_state *v, attotime current_time)
{
int resume = FALSE;
@ -2188,7 +2188,7 @@ static void check_stalled_cpu(voodoo_state *v, attotime current_time)
if (v->pci.stall_callback)
(*v->pci.stall_callback)(FALSE);
else
cpu_trigger(v->trigger);
cpu_trigger(machine, v->trigger);
}
/* if not, set a timer for the next one */

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

@ -690,7 +690,7 @@ static DRIVER_INIT( backfire )
deco56_decrypt(REGION_GFX1); /* 141 */
deco56_decrypt(REGION_GFX2); /* 141 */
decrypt156();
cpunum_set_clockscale(0, 4.0f); /* core timings aren't accurate */
cpunum_set_clockscale(machine, 0, 4.0f); /* core timings aren't accurate */
descramble_sound();
memory_install_read32_handler(0, ADDRESS_SPACE_PROGRAM, 0x0170018, 0x017001b, 0, 0, backfire_speedup_r );
}

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

@ -67,7 +67,7 @@ static TIMER_CALLBACK( delayed_sound_w )
{
main_to_sound_data = param;
main_to_sound_ready = 1;
cpu_triggerint(1);
cpu_triggerint(machine, 1);
/* use a timer to make long transfers faster */
timer_set(ATTOTIME_IN_USEC(50), NULL, 0, 0);

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

@ -731,7 +731,7 @@ static DRIVER_INIT( mlc )
/* The timing in the ARM core isn't as accurate as it should be, so bump up the
effective clock rate here to compensate otherwise we have slowdowns in
Skull Fung where there probably shouldn't be. */
cpunum_set_clockscale(0, 2.0f);
cpunum_set_clockscale(machine, 0, 2.0f);
mainCpuIsArm=1;
decrypt156();
descramble_sound();

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

@ -30,7 +30,7 @@ static TIMER_CALLBACK( dragrace_frame_callback )
}
/* watchdog is disabled during service mode */
watchdog_enable(readinputport(0) & 0x20);
watchdog_enable(machine, readinputport(0) & 0x20);
}

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

@ -86,7 +86,7 @@ INTERRUPT_GEN( eolith_speedup )
if (eolith_scanline==eolith_speedup_resume_scanline)
{
cpu_trigger(1000);
cpu_trigger(machine, 1000);
}
if (eolith_scanline==240)

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

@ -39,13 +39,13 @@ static DRIVER_INIT( montecar )
}
static void set_firetrk_service(int enable)
static void set_firetrk_service(running_machine *machine, int enable)
{
/* watchdog is disabled during service mode */
watchdog_enable(!enable);
watchdog_enable(machine, !enable);
/* change CPU clock speed according to service switch change */
cpunum_set_clock(0, enable ? FIRETRK_CPU_CLOCK_750KZ : FIRETRK_CPU_CLOCK_1MHZ);
cpunum_set_clock(machine, 0, enable ? FIRETRK_CPU_CLOCK_750KZ : FIRETRK_CPU_CLOCK_1MHZ);
}
@ -58,7 +58,7 @@ static INTERRUPT_GEN( firetrk_interrupt )
firetrk_service = readinputport(4) & 0x80;
if (firetrk_service != last_service)
{
set_firetrk_service(firetrk_service);
set_firetrk_service(machine, firetrk_service);
last_service = firetrk_service;
}
@ -71,7 +71,7 @@ static INTERRUPT_GEN( firetrk_interrupt )
firetrk_service = readinputport(6) & 0x04;
if (firetrk_service != last_service)
{
set_firetrk_service(firetrk_service);
set_firetrk_service(machine, firetrk_service);
last_service = firetrk_service;
}
@ -232,13 +232,13 @@ static MACHINE_RESET( firetrk )
{
write_output(0);
last_service = readinputport(6) & 0x04;
set_firetrk_service(last_service);
set_firetrk_service(machine, last_service);
}
else
if (GAME_IS_FIRETRUCK)
{
last_service = readinputport(4) & 0x80;
set_firetrk_service(last_service);
set_firetrk_service(machine, last_service);
}
timer_call_after_resynch(NULL, 0, periodic_callback);

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

@ -185,7 +185,7 @@ static WRITE8_HANDLER( cpu0_outputs_w )
break;
case 0x0d: /* OUT13 */
watchdog_reset();
watchdog_reset(Machine);
break;
case 0x0e: /* OUT14 */

16
src/mame/drivers/itech32.c
View File

@ -253,8 +253,8 @@ static UINT32 *tms1_ram, *tms2_ram;
static UINT32 *tms1_boot;
static UINT8 tms_spinning[2];
#define START_TMS_SPINNING(n) do { cpu_spinuntil_trigger(7351 + n); tms_spinning[n] = 1; } while (0)
#define STOP_TMS_SPINNING(n) do { cpu_trigger(7351 + n); tms_spinning[n] = 0; } while (0)
#define START_TMS_SPINNING(n) do { cpu_spinuntil_trigger(7351 + n); tms_spinning[n] = 1; } while (0)
#define STOP_TMS_SPINNING(machine, n) do { cpu_trigger(machine, 7351 + n); tms_spinning[n] = 0; } while (0)
@ -339,8 +339,8 @@ static MACHINE_RESET( drivedge )
cpunum_set_input_line(2, INPUT_LINE_RESET, ASSERT_LINE);
cpunum_set_input_line(3, INPUT_LINE_RESET, ASSERT_LINE);
STOP_TMS_SPINNING(0);
STOP_TMS_SPINNING(1);
STOP_TMS_SPINNING(machine, 0);
STOP_TMS_SPINNING(machine, 1);
}
@ -692,12 +692,12 @@ static WRITE32_HANDLER( tms_reset_clear_w )
if ((tms1_ram[0] & 0xff000000) == 0)
{
cpunum_set_input_line(2, INPUT_LINE_RESET, CLEAR_LINE);
STOP_TMS_SPINNING(0);
STOP_TMS_SPINNING(Machine, 0);
}
if ((tms2_ram[0] & 0xff000000) == 0)
{
cpunum_set_input_line(3, INPUT_LINE_RESET, CLEAR_LINE);
STOP_TMS_SPINNING(1);
STOP_TMS_SPINNING(Machine, 1);
}
}
@ -706,7 +706,7 @@ static WRITE32_HANDLER( tms1_68k_ram_w )
{
COMBINE_DATA(&tms1_ram[offset]);
if (offset == 0) COMBINE_DATA(tms1_boot);
if (offset == 0x382 && tms_spinning[0]) STOP_TMS_SPINNING(0);
if (offset == 0x382 && tms_spinning[0]) STOP_TMS_SPINNING(Machine, 0);
if (!tms_spinning[0])
cpu_boost_interleave(ATTOTIME_IN_HZ(CPU020_CLOCK/256), ATTOTIME_IN_USEC(20));
}
@ -715,7 +715,7 @@ static WRITE32_HANDLER( tms1_68k_ram_w )
static WRITE32_HANDLER( tms2_68k_ram_w )
{
COMBINE_DATA(&tms2_ram[offset]);
if (offset == 0x382 && tms_spinning[1]) STOP_TMS_SPINNING(1);
if (offset == 0x382 && tms_spinning[1]) STOP_TMS_SPINNING(Machine, 1);
if (!tms_spinning[1])
cpu_boost_interleave(ATTOTIME_IN_HZ(CPU020_CLOCK/256), ATTOTIME_IN_USEC(20));
}

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

@ -379,7 +379,7 @@ static WRITE32_HANDLER( kinst_control_w )
static TIMER_CALLBACK( end_spin )
{
cpu_triggerint(0);
cpu_triggerint(machine, 0);
}

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

@ -653,7 +653,7 @@ static WRITE32_HANDLER( ccu_w )
static TIMER_CALLBACK( dmaend_callback )
{
// foul-proof (CPU0 could be deactivated while we wait)
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(resume_trigger); }
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(machine, resume_trigger); }
// DMA busy flag must be cleared before triggering IRQ 3
gx_rdport1_3 &= ~2;
@ -689,7 +689,7 @@ static void dmastart_callback(int data)
static INTERRUPT_GEN(konamigx_vbinterrupt)
{
// lift idle suspension
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(resume_trigger); }
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(machine, resume_trigger); }
// IRQ 1 is the main 60hz vblank interrupt
if (gx_syncen & 0x20)
@ -709,7 +709,7 @@ static INTERRUPT_GEN(konamigx_vbinterrupt)
static INTERRUPT_GEN(konamigx_vbinterrupt_type4)
{
// lift idle suspension
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(resume_trigger); }
if (resume_trigger && suspension_active) { suspension_active = 0; cpu_trigger(machine, resume_trigger); }
// IRQ 1 is the main 60hz vblank interrupt
// the gx_syncen & 0x20 test doesn't work on type 3 or 4 ROM boards, likely because the ROM board

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

@ -4417,8 +4417,8 @@ MACHINE_RESET( megadriv )
timer_adjust(scanline_timer, attotime_zero, 0, attotime_zero);
// set_refresh_rate(megadriv_framerate);
cpunum_set_clockscale(0, 0.9950f); /* Fatal Rewind is very fussy... */
// cpunum_set_clockscale(0, 0.3800f); /* Fatal Rewind is very fussy... */
cpunum_set_clockscale(machine, 0, 0.9950f); /* Fatal Rewind is very fussy... */
// cpunum_set_clockscale(machine, 0, 0.3800f); /* Fatal Rewind is very fussy... */
memset(megadrive_ram,0x00,0x10000);

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

@ -345,9 +345,9 @@ static TIMER_CALLBACK( adjust_cpu_speed )
/* starting at scanline 224, the CPU runs at half speed */
if (curv == 224)
cpunum_set_clock(0, MASTER_CLOCK/16);
cpunum_set_clock(machine, 0, MASTER_CLOCK/16);
else
cpunum_set_clock(0, MASTER_CLOCK/8);
cpunum_set_clock(machine, 0, MASTER_CLOCK/8);
/* scanline for the next run */
curv ^= 224;
@ -610,7 +610,7 @@ static WRITE8_HANDLER( missile_w )
/* watchdog */
else if (offset >= 0x4c00 && offset < 0x4d00)
watchdog_reset();
watchdog_reset(Machine);
/* interrupt ack */
else if (offset >= 0x4d00 && offset < 0x4e00)

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

@ -344,7 +344,7 @@ static WRITE32_HANDLER( arm7_latch_arm_w )
#ifdef PGMARM7SPEEDHACK
// cpu_boost_interleave(attotime_zero, ATTOTIME_IN_USEC(100));
if (data!=0xaa) cpu_spinuntil_trigger(1000);
cpu_trigger(1002);
cpu_trigger(Machine, 1002);
#else
cpu_boost_interleave(attotime_zero, ATTOTIME_IN_USEC(100));
cpu_spinuntil_time(ATTOTIME_IN_CYCLES(100, 0));
@ -375,7 +375,7 @@ static WRITE16_HANDLER( arm7_latch_68k_w )
COMBINE_DATA(&arm7_latch);
#ifdef PGMARM7SPEEDHACK
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
timer_set(ATTOTIME_IN_USEC(50), NULL, 0, arm_irq); // i don't know how long..
cpu_spinuntil_trigger(1002);
#else

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

@ -1376,7 +1376,7 @@ static void voodoo_stall(int stall)
/* resume CPU execution */
if (LOG_DMA) logerror("Resuming CPU on voodoo\n");
cpu_trigger(45678);
cpu_trigger(Machine, 45678);
}
}
}

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

@ -109,7 +109,7 @@ static INTERRUPT_GEN( sprint2 )
/* interrupts and watchdog are disabled during service mode */
watchdog_enable(!service_mode());
watchdog_enable(machine, !service_mode());
if (!service_mode())
{

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

@ -115,7 +115,7 @@ static TIMER_CALLBACK( nmi_callback )
/* NMI and watchdog are disabled during service mode */
watchdog_enable(readinputport(0) & 0x40);
watchdog_enable(machine, readinputport(0) & 0x40);
if (readinputport(0) & 0x40)
{

26
src/mame/drivers/stv.c
View File

@ -533,7 +533,7 @@ static UINT8 stv_SMPC_r8 (int offset)
return return_data;
}
static void stv_SMPC_w8 (int offset, UINT8 data)
static void stv_SMPC_w8 (running_machine *machine, int offset, UINT8 data)
{
mame_system_time systime;
@ -629,7 +629,7 @@ static void stv_SMPC_w8 (int offset, UINT8 data)
if(LOG_SMPC) logerror ("SMPC: Slave OFF\n");
smpc_ram[0x5f]=0x03;
stv_enable_slave_sh2 = 0;
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
cpunum_set_input_line(1, INPUT_LINE_RESET, ASSERT_LINE);
break;
case 0x06:
@ -654,17 +654,17 @@ static void stv_SMPC_w8 (int offset, UINT8 data)
case 0x0e:
if(LOG_SMPC) logerror ("SMPC: Change Clock to 352\n");
smpc_ram[0x5f]=0x0e;
cpunum_set_clock(0, MASTER_CLOCK_352/2);
cpunum_set_clock(1, MASTER_CLOCK_352/2);
cpunum_set_clock(2, MASTER_CLOCK_352/5);
cpunum_set_clock(machine, 0, MASTER_CLOCK_352/2);
cpunum_set_clock(machine, 1, MASTER_CLOCK_352/2);
cpunum_set_clock(machine, 2, MASTER_CLOCK_352/5);
cpunum_set_input_line(0, INPUT_LINE_NMI, PULSE_LINE); // ff said this causes nmi, should we set a timer then nmi?
break;
case 0x0f:
if(LOG_SMPC) logerror ("SMPC: Change Clock to 320\n");
smpc_ram[0x5f]=0x0f;
cpunum_set_clock(0, MASTER_CLOCK_320/2);
cpunum_set_clock(1, MASTER_CLOCK_320/2);
cpunum_set_clock(2, MASTER_CLOCK_320/5);
cpunum_set_clock(machine, 0, MASTER_CLOCK_320/2);
cpunum_set_clock(machine, 1, MASTER_CLOCK_320/2);
cpunum_set_clock(machine, 2, MASTER_CLOCK_320/5);
cpunum_set_input_line(0, INPUT_LINE_NMI, PULSE_LINE); // ff said this causes nmi, should we set a timer then nmi?
break;
/*"Interrupt Back"*/
@ -793,7 +793,7 @@ static WRITE32_HANDLER ( stv_SMPC_w32 )
offset += byte;
stv_SMPC_w8(offset,writedata);
stv_SMPC_w8(Machine, offset,writedata);
}
@ -2051,7 +2051,7 @@ static WRITE32_HANDLER( minit_w )
{
logerror("cpu #%d (PC=%08X) MINIT write = %08x\n",cpu_getactivecpu(), activecpu_get_pc(),data);
cpu_boost_interleave(minit_boost_timeslice, ATTOTIME_IN_USEC(minit_boost));
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
cpunum_set_info_int(1, CPUINFO_INT_SH2_FRT_INPUT, PULSE_LINE);
}
@ -2722,9 +2722,9 @@ static MACHINE_RESET( stv )
NMI_reset = 1;
smpc_ram[0x21] = (0x80) | ((NMI_reset & 1) << 6);
cpunum_set_clock(0, MASTER_CLOCK_320/2);
cpunum_set_clock(1, MASTER_CLOCK_320/2);
cpunum_set_clock(2, MASTER_CLOCK_320/5);
cpunum_set_clock(machine, 0, MASTER_CLOCK_320/2);
cpunum_set_clock(machine, 1, MASTER_CLOCK_320/2);
cpunum_set_clock(machine, 2, MASTER_CLOCK_320/5);
stvcd_reset();
}

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

@ -463,7 +463,7 @@ static WRITE32_HANDLER(dnmtdeka_cmd_write)
if ( data != 0 ) dnmtdeka_pending_commands++;
//logerror( "CMD: Written by cpu=%d, at = %08X, offset = %08X, data = %08X, commands = %d\n", cpu_getactivecpu(), activecpu_get_pc(), offset, data, dnmtdeka_pending_commands );
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
}
static READ32_HANDLER(dnmtdeka_cmd_read)
@ -513,7 +513,7 @@ static WRITE32_HANDLER(diehard_cmd_write)
if ( data != 0 ) diehard_pending_commands++;
//logerror( "CMD: Written by cpu=%d, at = %08X, offset = %08X, data = %08X, commands = %d\n", cpu_getactivecpu(), activecpu_get_pc(), offset, data, diehard_pending_commands );
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
}
static READ32_HANDLER(diehard_cmd_read)
@ -537,7 +537,7 @@ static READ32_HANDLER(diehard_cmd_ack_read)
if ( (stv_workram_h[0x000e0dd8/4] & 0xff000000) == 0 &&
diehard_pending_commands == 0 )
{
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
}
return stv_workram_h[0x000e0dd8/4];
}
@ -556,7 +556,7 @@ static WRITE32_HANDLER(diehard_cmd_ack_write_cpu0)
{
//logerror( "CMDACK: Write by cpu=%d, at = %08X, offset = %08X, data = %08X, commands = %d\n", cpu_getactivecpu(), activecpu_get_pc(), offset, data, diehard_pending_commands );
COMBINE_DATA(&stv_workram_h[0x000e0dd8/4]);
cpu_trigger(1000);
cpu_trigger(Machine, 1000);
}
DRIVER_INIT(diehard)

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

@ -304,7 +304,7 @@ static UINT8 tempest_player_select;
static WRITE8_HANDLER( wdclr_w )
{
cpunum_set_input_line(0, 0, CLEAR_LINE);
watchdog_reset();
watchdog_reset(Machine);
}
/*************************************

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

@ -54,7 +54,7 @@ static TIMER_CALLBACK( nmi_callback )
/* NMI and watchdog are disabled during service mode */
watchdog_enable(readinputport(0) & 0x40);
watchdog_enable(machine, readinputport(0) & 0x40);
if (readinputport(0) & 0x40)
{

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

@ -304,7 +304,7 @@ static TIMER_CALLBACK( dmaend_callback )
if (cur_control2 & 0x0040)
{
// foul-proof (CPU0 could be deactivated while we wait)
if (suspension_active) { suspension_active = 0; cpu_trigger(resume_trigger); }
if (suspension_active) { suspension_active = 0; cpu_trigger(machine, resume_trigger); }
// IRQ 5 is the "object DMA end interrupt" and shouldn't be triggered
// if object data isn't ready for DMA within the frame.
@ -314,7 +314,7 @@ static TIMER_CALLBACK( dmaend_callback )
static INTERRUPT_GEN( xexex_interrupt )
{
if (suspension_active) { suspension_active = 0; cpu_trigger(resume_trigger); }
if (suspension_active) { suspension_active = 0; cpu_trigger(machine, resume_trigger); }
switch (cpu_getiloops())
{

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

@ -673,7 +673,7 @@ static void cps2_decrypt(const UINT32 *master_key, UINT32 upper_limit)
{
char loadingMessage[256]; // for displaying with UI
sprintf(loadingMessage, "Decrypting %d%%", i*100/0x10000);
ui_set_startup_text(loadingMessage,FALSE);
ui_set_startup_text(Machine, loadingMessage,FALSE);
}

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

@ -56,7 +56,7 @@ WRITE8_HANDLER( docastle_shared0_w )
if (offset == 8)
/* awake the master CPU */
cpu_trigger(500);
cpu_trigger(Machine, 500);
}

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

@ -772,7 +772,7 @@ static TIMER_CALLBACK( stmsp_sync_update )
offs_t offset = (param >> 16) & 0xfff;
UINT16 data = param;
stmsp_sync[which][offset] = data;
cpu_triggerint(hdcpu_msp);
cpu_triggerint(machine, hdcpu_msp);
}
@ -872,7 +872,7 @@ WRITE16_HANDLER( hd68k_adsp_data_w )
{
logerror("%06X:ADSP sync address written (%04X)\n", activecpu_get_previouspc(), data);
timer_call_after_resynch(NULL, 0, 0);
cpu_triggerint(hdcpu_adsp);
cpu_triggerint(Machine, hdcpu_adsp);
}
else
logerror("%06X:ADSP W@%04X (%04X)\n", activecpu_get_previouspc(), offset, data);
@ -1264,7 +1264,7 @@ WRITE16_HANDLER( hd68k_ds3_gdata_w )
COMBINE_DATA(&ds3_g68data);
ds3_g68flag = 1;
ds3_gcmd = offset & 1;
cpu_triggerint(hdcpu_adsp);
cpu_triggerint(Machine, hdcpu_adsp);
update_ds3_irq();
}
@ -1342,7 +1342,7 @@ WRITE16_HANDLER( hdds3_special_w )
update_ds3_irq();
/* once we've written data, trigger the main CPU to wake up again */
cpu_trigger(DS3_TRIGGER);
cpu_trigger(Machine, DS3_TRIGGER);
break;
case 1:
@ -1797,7 +1797,7 @@ WRITE16_HANDLER( hdgsp_speedup1_w )
/* if $ffff is written, send an "interrupt" trigger to break us out of the spin loop */
if (hdgsp_speedup_addr[0][offset] == 0xffff)
cpu_triggerint(hdcpu_gsp);
cpu_triggerint(Machine, hdcpu_gsp);
}
@ -1807,7 +1807,7 @@ WRITE16_HANDLER( hdgsp_speedup2_w )
/* if $ffff is written, send an "interrupt" trigger to break us out of the spin loop */
if (hdgsp_speedup_addr[1][offset] == 0xffff)
cpu_triggerint(hdcpu_gsp);
cpu_triggerint(Machine, hdcpu_gsp);
}
@ -1840,7 +1840,7 @@ WRITE16_HANDLER( rdgsp_speedup1_w )
{
COMBINE_DATA(&hdgsp_speedup_addr[0][offset]);
if (cpu_getactivecpu() != hdcpu_gsp)
cpu_triggerint(hdcpu_gsp);
cpu_triggerint(Machine, hdcpu_gsp);
}
@ -1874,7 +1874,7 @@ WRITE16_HANDLER( hdmsp_speedup_w )
{
COMBINE_DATA(&hdmsp_speedup_addr[offset]);
if (offset == 0 && hdmsp_speedup_addr[offset] != 0)
cpu_triggerint(hdcpu_msp);
cpu_triggerint(Machine, hdcpu_msp);
}

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

@ -196,7 +196,7 @@ WRITE32_HANDLER( cgboard_dsp_shared_w_ppc )
{
if (cgboard_id < MAX_CG_BOARDS)
{
cpu_trigger(10000); // Remove the timeout (a part of the GTI Club FIFO test workaround)
cpu_trigger(Machine, 10000); // Remove the timeout (a part of the GTI Club FIFO test workaround)
COMBINE_DATA(dsp_shared_ram[cgboard_id] + (offset + (dsp_shared_ram_bank[cgboard_id] * DSP_BANK_SIZE_WORD)));
}
}

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

@ -214,7 +214,7 @@ static void sp_set_status(UINT32 status)
{
if (status & 0x1)
{
//cpu_trigger(6789);
//cpu_trigger(Machine, 6789);
cpunum_set_input_line(1, INPUT_LINE_HALT, ASSERT_LINE);
cpunum_set_info_int(1, CPUINFO_INT_REGISTER + RSP_SR, cpunum_get_info_int(1, CPUINFO_INT_REGISTER + RSP_SR) | RSP_STATUS_HALT);

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

@ -1452,7 +1452,7 @@ WRITE8_HANDLER( snes_w_io )
case MEMSEL: /* Access cycle designation in memory (2) area */
/* FIXME: Need to adjust the speed only during access of banks 0x80+
* Currently we are just increasing it no matter what */
// cpunum_set_clockscale( 0, (data & 0x1) ? 1.335820896 : 1.0 );
// cpunum_set_clockscale(Machine, 0, (data & 0x1) ? 1.335820896 : 1.0 );
#ifdef SNES_DBG_REG_W
if( (data & 0x1) != (snes_ram[MEMSEL] & 0x1) )
mame_printf_debug( "CPU speed: %f Mhz\n", (data & 0x1) ? 3.58 : 2.68 );

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

@ -1142,13 +1142,13 @@ static TIMER_CALLBACK( antic_line_done )
{
LOG((" @cycle #%3d release WSYNC\n", cycle()));
/* release the CPU if it was actually waiting for HSYNC */
cpu_trigger(TRIGGER_HSYNC);
cpu_trigger(machine, TRIGGER_HSYNC);
/* and turn off the 'wait for hsync' flag */
antic.w.wsync = 0;
}
LOG((" @cycle #%3d release CPU\n", cycle()));
/* release the CPU (held for emulating cycles stolen by ANTIC DMA) */
cpu_trigger(TRIGGER_STEAL);
cpu_trigger(machine, TRIGGER_STEAL);
/* refresh the display (translate color clocks to pixels) */
antic_linerefresh();

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

@ -91,7 +91,7 @@ VIDEO_UPDATE( canyon )
draw_bombs(bitmap, cliprect);
/* watchdog is disabled during service mode */
watchdog_enable(!(readinputport(2) & 0x10));
watchdog_enable(machine, !(readinputport(2) & 0x10));
return 0;
}