src/MacOSX/main_macosx.mm

/*
 *  $Id: main_macosx.mm,v 1.6 2003/03/25 01:44:16 nigel Exp $
 *
 *  main_macosx.mm -    Startup code for MacOS X
 *                                              Based (in a small way) on the default main.m,
                                                and on Basilisk's main_unix.cpp
 *
 *  Basilisk II (C) 1997-2002 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#define PTHREADS
#include "sysdeps.h"

#ifdef HAVE_PTHREADS
# include <pthread.h>
#endif

#if REAL_ADDRESSING || DIRECT_ADDRESSING
# include <sys/mman.h>
#endif

#include "cpu_emulation.h"
#include "macos_util_macosx.h"
#include "main.h"
#include "prefs.h"
#include "prefs_editor.h"
#include "rom_patches.h"
#include "sys.h"
#include "timer.h"
#include "user_strings.h"
#include "version.h"
#include "video.h"
#include "vm_alloc.h"
#include "xpram.h"

#ifdef ENABLE_MON
# include "mon.h"
#endif

#define DEBUG 0
#include "debug.h"


#import <AppKit/AppKit.h>

#include "main_macosx.h"                // To bridge between main() and misc. classes


// Constants
const char ROM_FILE_NAME[] = "ROM";
const int SIG_STACK_SIZE = SIGSTKSZ;    // Size of signal stack
const int SCRATCH_MEM_SIZE = 0x10000;   // Size of scratch memory area


// CPU and FPU type, addressing mode
int CPUType;
bool CPUIs68060;
int FPUType;
bool TwentyFourBitAddressing;


// Global variables

#ifdef HAVE_PTHREADS

static pthread_mutex_t intflag_lock = PTHREAD_MUTEX_INITIALIZER;        // Mutex to protect InterruptFlags
#define LOCK_INTFLAGS pthread_mutex_lock(&intflag_lock)
#define UNLOCK_INTFLAGS pthread_mutex_unlock(&intflag_lock)

#else

#define LOCK_INTFLAGS
#define UNLOCK_INTFLAGS

#endif

#if USE_SCRATCHMEM_SUBTERFUGE
uint8 *ScratchMem = NULL;                       // Scratch memory for Mac ROM writes
#endif

#if defined(HAVE_TIMER_CREATE) && defined(_POSIX_REALTIME_SIGNALS)
#define SIG_TIMER SIGRTMIN
static timer_t timer;                           // 60Hz timer
#endif

#ifdef ENABLE_MON
static struct sigaction sigint_sa;      // sigaction for SIGINT handler
static void sigint_handler(...);
#endif

#if REAL_ADDRESSING
static bool lm_area_mapped = false;     // Flag: Low Memory area mmap()ped
#endif


/*
 *  Main program
 */

static void usage(const char *prg_name)
{
        printf("Usage: %s [OPTION...]\n", prg_name);
        printf("\nUnix options:\n");
        printf("  --help\n    display this usage message\n");
        printf("  --break ADDRESS\n    set ROM breakpoint\n");
        printf("  --rominfo\n    dump ROM information\n");
        PrefsPrintUsage();
        exit(0);
}

int main(int argc, char **argv)
{
        // Initialize variables
        RAMBaseHost = NULL;
        ROMBaseHost = NULL;
        srand(time(NULL));
        tzset();

        // Print some info
        printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
        printf(" %s\n", GetString(STR_ABOUT_TEXT2));

        // Read preferences
        PrefsInit(argc, argv);

        // Parse command line arguments
        for (int i=1; i<argc; i++) {
                if (strcmp(argv[i], "--help") == 0) {
                        usage(argv[0]);
                } else if (strncmp(argv[i], "-psn_", 5) == 0) {// OS X process identifier
                        i++;
                } else if (strcmp(argv[i], "--break") == 0) {
                        i++;
                        if (i < argc)
                                ROMBreakpoint = strtol(argv[i], NULL, 0);
                } else if (strcmp(argv[i], "--rominfo") == 0) {
                        PrintROMInfo = true;
                } else if (argv[i][0] == '-') {
                        fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
                        usage(argv[0]);
                }
        }

        // Init system routines
        SysInit();

        // Open display, attach to window server,
        // load pre-instantiated classes from MainMenu.nib, start run loop
        int i = NSApplicationMain(argc, (const char **)argv);
        // We currently never get past here, because QuitEmulator() does an exit()

        // Exit system routines
        SysExit();

        // Exit preferences
        PrefsExit();

        return i;
}

#define QuitEmulator()  { QuitEmuNoExit() ; return NO; }

bool InitEmulator (void)
{
        char str[256];


        // Read RAM size
        RAMSize = PrefsFindInt32("ramsize") & 0xfff00000;       // Round down to 1MB boundary
        if (RAMSize < 1024*1024) {
                WarningAlert(GetString(STR_SMALL_RAM_WARN));
                RAMSize = 1024*1024;
        }

#if REAL_ADDRESSING || DIRECT_ADDRESSING
        RAMSize = RAMSize & -getpagesize();                                     // Round down to page boundary
#endif
        
        // Initialize VM system
        vm_init();

#if REAL_ADDRESSING
        // Flag: RAM and ROM are contigously allocated from address 0
        bool memory_mapped_from_zero = false;
        
        // Under Solaris/SPARC and NetBSD/m68k, Basilisk II is known to crash
        // when trying to map a too big chunk of memory starting at address 0
#if defined(OS_solaris) || defined(OS_netbsd)
        const bool can_map_all_memory = false;
#else
        const bool can_map_all_memory = true;
#endif
        
        // Try to allocate all memory from 0x0000, if it is not known to crash
        if (can_map_all_memory && (vm_acquire_fixed(0, RAMSize + 0x100000) == 0)) {
                D(bug("Could allocate RAM and ROM from 0x0000\n"));
                memory_mapped_from_zero = true;
        }
        
        // Otherwise, just create the Low Memory area (0x0000..0x2000)
        else if (vm_acquire_fixed(0, 0x2000) == 0) {
                D(bug("Could allocate the Low Memory globals\n"));
                lm_area_mapped = true;
        }
        
        // Exit on failure
        else {
                sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
                ErrorAlert(str);
                QuitEmulator();
        }
#else
        *str = 0;               // Eliminate unused variable warning
#endif

        // Create areas for Mac RAM and ROM
#if REAL_ADDRESSING
        if (memory_mapped_from_zero) {
                RAMBaseHost = (uint8 *)0;
                ROMBaseHost = RAMBaseHost + RAMSize;
        }
        else
#endif
        {
                RAMBaseHost = (uint8 *)vm_acquire(RAMSize);
                ROMBaseHost = (uint8 *)vm_acquire(0x100000);
                if (RAMBaseHost == VM_MAP_FAILED || ROMBaseHost == VM_MAP_FAILED) {
                        ErrorAlert(STR_NO_MEM_ERR);
                        QuitEmulator();
                }
        }

#if USE_SCRATCHMEM_SUBTERFUGE
        // Allocate scratch memory
        ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
        if (ScratchMem == VM_MAP_FAILED) {
                ErrorAlert(STR_NO_MEM_ERR);
                QuitEmulator();
        }
        ScratchMem += SCRATCH_MEM_SIZE/2;       // ScratchMem points to middle of block
#endif

#if DIRECT_ADDRESSING
        // RAMBaseMac shall always be zero
        MEMBaseDiff = (uintptr)RAMBaseHost;
        RAMBaseMac = 0;
        ROMBaseMac = Host2MacAddr(ROMBaseHost);
#endif
#if REAL_ADDRESSING
        RAMBaseMac = (uint32)RAMBaseHost;
        ROMBaseMac = (uint32)ROMBaseHost;
#endif
        D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
        D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
        
        // Get rom file path from preferences
        const char *rom_path = PrefsFindString("rom");
        if ( ! rom_path )
                WarningAlert("No rom pathname set. Trying ./ROM");

        // Load Mac ROM
        int rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
        if (rom_fd < 0) {
                ErrorAlert(STR_NO_ROM_FILE_ERR);
                QuitEmulator();
        }
        printf(GetString(STR_READING_ROM_FILE));
        ROMSize = lseek(rom_fd, 0, SEEK_END);
        if (ROMSize != 64*1024 && ROMSize != 128*1024 && ROMSize != 256*1024 && ROMSize != 512*1024 && ROMSize != 1024*1024) {
                ErrorAlert(STR_ROM_SIZE_ERR);
                close(rom_fd);
                QuitEmulator();
        }
        lseek(rom_fd, 0, SEEK_SET);
        if (read(rom_fd, ROMBaseHost, ROMSize) != (ssize_t)ROMSize) {
                ErrorAlert(STR_ROM_FILE_READ_ERR);
                close(rom_fd);
                QuitEmulator();
        }


        // Initialize everything
        if (!InitAll())
                QuitEmulator();
        D(bug("Initialization complete\n"));


#ifdef ENABLE_MON
        // Setup SIGINT handler to enter mon
        sigemptyset(&sigint_sa.sa_mask);
        sigint_sa.sa_handler = (void (*)(int))sigint_handler;
        sigint_sa.sa_flags = 0;
        sigaction(SIGINT, &sigint_sa, NULL);
#endif


        return YES;
}

#undef QuitEmulator()


/*
 *  Quit emulator
 */

void QuitEmuNoExit()
{
        D(bug("QuitEmulator\n"));

        // Exit 680x0 emulation
        Exit680x0();

        // Deinitialize everything
        ExitAll();

        // Free ROM/RAM areas
        if (RAMBaseHost != VM_MAP_FAILED) {
                vm_release(RAMBaseHost, RAMSize);
                RAMBaseHost = NULL;
        }
        if (ROMBaseHost != VM_MAP_FAILED) {
                vm_release(ROMBaseHost, 0x100000);
                ROMBaseHost = NULL;
        }

#if USE_SCRATCHMEM_SUBTERFUGE
        // Delete scratch memory area
        if (ScratchMem != (uint8 *)VM_MAP_FAILED) {
                vm_release((void *)(ScratchMem - SCRATCH_MEM_SIZE/2), SCRATCH_MEM_SIZE);
                ScratchMem = NULL;
        }
#endif

#if REAL_ADDRESSING
        // Delete Low Memory area
        if (lm_area_mapped)
                vm_release(0, 0x2000);
#endif
        
        // Exit VM wrappers
        vm_exit();

        // Exit system routines
        SysExit();

        // Exit preferences
        PrefsExit();
}

void QuitEmulator(void)
{
        extern  NSApplication *NSApp;


        QuitEmuNoExit();

        // Stop run loop?
        [NSApp terminate: nil];

        exit(0);
}


/*
 *  Code was patched, flush caches if neccessary (i.e. when using a real 680x0
 *  or a dynamically recompiling emulator)
 */

void FlushCodeCache(void *start, uint32 size)
{
}


/*
 *  SIGINT handler, enters mon
 */

#ifdef ENABLE_MON
static void sigint_handler(...)
{
        uaecptr nextpc;
        extern void m68k_dumpstate(uaecptr *nextpc);
        m68k_dumpstate(&nextpc);
        VideoQuitFullScreen();
        char *arg[4] = {"mon", "-m", "-r", NULL};
        mon(3, arg);
        QuitEmulator();
}
#endif


/*
 *  Mutexes
 */

#ifdef HAVE_PTHREADS

struct B2_mutex {
        B2_mutex() { pthread_mutex_init(&m, NULL); }
        ~B2_mutex() { pthread_mutex_unlock(&m); pthread_mutex_destroy(&m); }
        pthread_mutex_t m;
};

B2_mutex *B2_create_mutex(void)
{
        return new B2_mutex;
}

void B2_lock_mutex(B2_mutex *mutex)
{
        pthread_mutex_lock(&mutex->m);
}

void B2_unlock_mutex(B2_mutex *mutex)
{
        pthread_mutex_unlock(&mutex->m);
}

void B2_delete_mutex(B2_mutex *mutex)
{
        delete mutex;
}

#else

struct B2_mutex {
        int dummy;
};

B2_mutex *B2_create_mutex(void)
{
        return new B2_mutex;
}

void B2_lock_mutex(B2_mutex *mutex)
{
}

void B2_unlock_mutex(B2_mutex *mutex)
{
}

void B2_delete_mutex(B2_mutex *mutex)
{
        delete mutex;
}

#endif


/*
 *  Interrupt flags (must be handled atomically!)
 */

uint32 InterruptFlags = 0;

void SetInterruptFlag(uint32 flag)
{
        LOCK_INTFLAGS;
        InterruptFlags |= flag;
        UNLOCK_INTFLAGS;
}

void ClearInterruptFlag(uint32 flag)
{
        LOCK_INTFLAGS;
        InterruptFlags &= ~flag;
        UNLOCK_INTFLAGS;
}


/*
 *  Display error alert
 */

void ErrorAlert(const char *text)
{
        NSString *title  = [NSString stringWithCString:
                                                GetString(STR_ERROR_ALERT_TITLE) ];
        NSString *error  = [NSString stringWithCString: text];
        NSString *button = [NSString stringWithCString: GetString(STR_QUIT_BUTTON) ];

//      If we have a full screen mode, quit it here?

        NSLog(error);
        NSRunCriticalAlertPanel(title, error, button, nil, nil);
}


/*
 *  Display warning alert
 */

void WarningAlert(const char *text)
{
        NSString *title   = [NSString stringWithCString:
                                                        GetString(STR_WARNING_ALERT_TITLE) ];
        NSString *warning = [NSString stringWithCString: text];
        NSString *button  = [NSString stringWithCString: GetString(STR_OK_BUTTON) ];

        NSLog(warning);
        NSRunAlertPanel(title, warning, button, nil, nil);
}


/*
 *  Display choice alert
 */

bool ChoiceAlert(const char *text, const char *pos, const char *neg)
{
        NSString *title   = [NSString stringWithCString:
                                                        GetString(STR_WARNING_ALERT_TITLE) ];
        NSString *warning = [NSString stringWithCString: text];
        NSString *yes     = [NSString stringWithCString: pos];
        NSString *no      = [NSString stringWithCString: neg];

        NSLog(warning);
        return NSRunInformationalAlertPanel(title, warning, yes, no, nil);
}
Revision:	1.7
Committed:	2003-03-26T00:26:38Z (21 years, 2 months ago) by nigel
Branch:	MAIN
CVS Tags:	nigel-build-13
Changes since 1.6:	+2 -2 lines
Log Message:	Repair QuitEmulator replacement macro. (we was incorrectly returning after the call to InitAll() )
#	Content
1	/*
2	* $Id: main_macosx.mm,v 1.6 2003/03/25 01:44:16 nigel Exp $
3	*
4	* main_macosx.mm - Startup code for MacOS X
5	* Based (in a small way) on the default main.m,
6	and on Basilisk's main_unix.cpp
7	*
8	* Basilisk II (C) 1997-2002 Christian Bauer
9	*
10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23	*/
24	#define PTHREADS
25	#include "sysdeps.h"
26
27	#ifdef HAVE_PTHREADS
28	# include <pthread.h>
29	#endif
30
31	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
32	# include <sys/mman.h>
33	#endif
34
35	#include "cpu_emulation.h"
36	#include "macos_util_macosx.h"
37	#include "main.h"
38	#include "prefs.h"
39	#include "prefs_editor.h"
40	#include "rom_patches.h"
41	#include "sys.h"
42	#include "timer.h"
43	#include "user_strings.h"
44	#include "version.h"
45	#include "video.h"
46	#include "vm_alloc.h"
47	#include "xpram.h"
48
49	#ifdef ENABLE_MON
50	# include "mon.h"
51	#endif
52
53	#define DEBUG 0
54	#include "debug.h"
55
56
57	#import <AppKit/AppKit.h>
58
59	#include "main_macosx.h" // To bridge between main() and misc. classes
60
61
62	// Constants
63	const char ROM_FILE_NAME[] = "ROM";
64	const int SIG_STACK_SIZE = SIGSTKSZ; // Size of signal stack
65	const int SCRATCH_MEM_SIZE = 0x10000; // Size of scratch memory area
66
67
68	// CPU and FPU type, addressing mode
69	int CPUType;
70	bool CPUIs68060;
71	int FPUType;
72	bool TwentyFourBitAddressing;
73
74
75	// Global variables
76
77	#ifdef HAVE_PTHREADS
78
79	static pthread_mutex_t intflag_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect InterruptFlags
80	#define LOCK_INTFLAGS pthread_mutex_lock(&intflag_lock)
81	#define UNLOCK_INTFLAGS pthread_mutex_unlock(&intflag_lock)
82
83	#else
84
85	#define LOCK_INTFLAGS
86	#define UNLOCK_INTFLAGS
87
88	#endif
89
90	#if USE_SCRATCHMEM_SUBTERFUGE
91	uint8 *ScratchMem = NULL; // Scratch memory for Mac ROM writes
92	#endif
93
94	#if defined(HAVE_TIMER_CREATE) && defined(_POSIX_REALTIME_SIGNALS)
95	#define SIG_TIMER SIGRTMIN
96	static timer_t timer; // 60Hz timer
97	#endif
98
99	#ifdef ENABLE_MON
100	static struct sigaction sigint_sa; // sigaction for SIGINT handler
101	static void sigint_handler(...);
102	#endif
103
104	#if REAL_ADDRESSING
105	static bool lm_area_mapped = false; // Flag: Low Memory area mmap()ped
106	#endif
107
108
109
110	/*
111	* Main program
112	*/
113
114	static void usage(const char *prg_name)
115	{
116	printf("Usage: %s [OPTION...]\n", prg_name);
117	printf("\nUnix options:\n");
118	printf(" --help\n display this usage message\n");
119	printf(" --break ADDRESS\n set ROM breakpoint\n");
120	printf(" --rominfo\n dump ROM information\n");
121	PrefsPrintUsage();
122	exit(0);
123	}
124
125	int main(int argc, char **argv)
126	{
127	// Initialize variables
128	RAMBaseHost = NULL;
129	ROMBaseHost = NULL;
130	srand(time(NULL));
131	tzset();
132
133	// Print some info
134	printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
135	printf(" %s\n", GetString(STR_ABOUT_TEXT2));
136
137	// Read preferences
138	PrefsInit(argc, argv);
139
140	// Parse command line arguments
141	for (int i=1; i<argc; i++) {
142	if (strcmp(argv[i], "--help") == 0) {
143	usage(argv[0]);
144	} else if (strncmp(argv[i], "-psn_", 5) == 0) {// OS X process identifier
145	i++;
146	} else if (strcmp(argv[i], "--break") == 0) {
147	i++;
148	if (i < argc)
149	ROMBreakpoint = strtol(argv[i], NULL, 0);
150	} else if (strcmp(argv[i], "--rominfo") == 0) {
151	PrintROMInfo = true;
152	} else if (argv[i][0] == '-') {
153	fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
154	usage(argv[0]);
155	}
156	}
157
158	// Init system routines
159	SysInit();
160
161	// Open display, attach to window server,
162	// load pre-instantiated classes from MainMenu.nib, start run loop
163	int i = NSApplicationMain(argc, (const char **)argv);
164	// We currently never get past here, because QuitEmulator() does an exit()
165
166	// Exit system routines
167	SysExit();
168
169	// Exit preferences
170	PrefsExit();
171
172	return i;
173	}
174
175	#define QuitEmulator() { QuitEmuNoExit() ; return NO; }
176
177	bool InitEmulator (void)
178	{
179	char str[256];
180
181
182	// Read RAM size
183	RAMSize = PrefsFindInt32("ramsize") & 0xfff00000; // Round down to 1MB boundary
184	if (RAMSize < 1024*1024) {
185	WarningAlert(GetString(STR_SMALL_RAM_WARN));
186	RAMSize = 1024*1024;
187	}
188
189	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
190	RAMSize = RAMSize & -getpagesize(); // Round down to page boundary
191	#endif
192
193	// Initialize VM system
194	vm_init();
195
196	#if REAL_ADDRESSING
197	// Flag: RAM and ROM are contigously allocated from address 0
198	bool memory_mapped_from_zero = false;
199
200	// Under Solaris/SPARC and NetBSD/m68k, Basilisk II is known to crash
201	// when trying to map a too big chunk of memory starting at address 0
202	#if defined(OS_solaris) \|\| defined(OS_netbsd)
203	const bool can_map_all_memory = false;
204	#else
205	const bool can_map_all_memory = true;
206	#endif
207
208	// Try to allocate all memory from 0x0000, if it is not known to crash
209	if (can_map_all_memory && (vm_acquire_fixed(0, RAMSize + 0x100000) == 0)) {
210	D(bug("Could allocate RAM and ROM from 0x0000\n"));
211	memory_mapped_from_zero = true;
212	}
213
214	// Otherwise, just create the Low Memory area (0x0000..0x2000)
215	else if (vm_acquire_fixed(0, 0x2000) == 0) {
216	D(bug("Could allocate the Low Memory globals\n"));
217	lm_area_mapped = true;
218	}
219
220	// Exit on failure
221	else {
222	sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
223	ErrorAlert(str);
224	QuitEmulator();
225	}
226	#else
227	*str = 0; // Eliminate unused variable warning
228	#endif
229
230	// Create areas for Mac RAM and ROM
231	#if REAL_ADDRESSING
232	if (memory_mapped_from_zero) {
233	RAMBaseHost = (uint8 *)0;
234	ROMBaseHost = RAMBaseHost + RAMSize;
235	}
236	else
237	#endif
238	{
239	RAMBaseHost = (uint8 *)vm_acquire(RAMSize);
240	ROMBaseHost = (uint8 *)vm_acquire(0x100000);
241	if (RAMBaseHost == VM_MAP_FAILED \|\| ROMBaseHost == VM_MAP_FAILED) {
242	ErrorAlert(STR_NO_MEM_ERR);
243	QuitEmulator();
244	}
245	}
246
247	#if USE_SCRATCHMEM_SUBTERFUGE
248	// Allocate scratch memory
249	ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
250	if (ScratchMem == VM_MAP_FAILED) {
251	ErrorAlert(STR_NO_MEM_ERR);
252	QuitEmulator();
253	}
254	ScratchMem += SCRATCH_MEM_SIZE/2; // ScratchMem points to middle of block
255	#endif
256
257	#if DIRECT_ADDRESSING
258	// RAMBaseMac shall always be zero
259	MEMBaseDiff = (uintptr)RAMBaseHost;
260	RAMBaseMac = 0;
261	ROMBaseMac = Host2MacAddr(ROMBaseHost);
262	#endif
263	#if REAL_ADDRESSING
264	RAMBaseMac = (uint32)RAMBaseHost;
265	ROMBaseMac = (uint32)ROMBaseHost;
266	#endif
267	D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
268	D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
269
270	// Get rom file path from preferences
271	const char *rom_path = PrefsFindString("rom");
272	if ( ! rom_path )
273	WarningAlert("No rom pathname set. Trying ./ROM");
274
275	// Load Mac ROM
276	int rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
277	if (rom_fd < 0) {
278	ErrorAlert(STR_NO_ROM_FILE_ERR);
279	QuitEmulator();
280	}
281	printf(GetString(STR_READING_ROM_FILE));
282	ROMSize = lseek(rom_fd, 0, SEEK_END);
283	if (ROMSize != 641024 && ROMSize != 1281024 && ROMSize != 2561024 && ROMSize != 5121024 && ROMSize != 1024*1024) {
284	ErrorAlert(STR_ROM_SIZE_ERR);
285	close(rom_fd);
286	QuitEmulator();
287	}
288	lseek(rom_fd, 0, SEEK_SET);
289	if (read(rom_fd, ROMBaseHost, ROMSize) != (ssize_t)ROMSize) {
290	ErrorAlert(STR_ROM_FILE_READ_ERR);
291	close(rom_fd);
292	QuitEmulator();
293	}
294
295
296	// Initialize everything
297	if (!InitAll())
298	QuitEmulator();
299	D(bug("Initialization complete\n"));
300
301
302	#ifdef ENABLE_MON
303	// Setup SIGINT handler to enter mon
304	sigemptyset(&sigint_sa.sa_mask);
305	sigint_sa.sa_handler = (void (*)(int))sigint_handler;
306	sigint_sa.sa_flags = 0;
307	sigaction(SIGINT, &sigint_sa, NULL);
308	#endif
309
310
311	return YES;
312	}
313
314	#undef QuitEmulator()
315
316
317	/*
318	* Quit emulator
319	*/
320
321	void QuitEmuNoExit()
322	{
323	D(bug("QuitEmulator\n"));
324
325	// Exit 680x0 emulation
326	Exit680x0();
327
328	// Deinitialize everything
329	ExitAll();
330
331	// Free ROM/RAM areas
332	if (RAMBaseHost != VM_MAP_FAILED) {
333	vm_release(RAMBaseHost, RAMSize);
334	RAMBaseHost = NULL;
335	}
336	if (ROMBaseHost != VM_MAP_FAILED) {
337	vm_release(ROMBaseHost, 0x100000);
338	ROMBaseHost = NULL;
339	}
340
341	#if USE_SCRATCHMEM_SUBTERFUGE
342	// Delete scratch memory area
343	if (ScratchMem != (uint8 *)VM_MAP_FAILED) {
344	vm_release((void *)(ScratchMem - SCRATCH_MEM_SIZE/2), SCRATCH_MEM_SIZE);
345	ScratchMem = NULL;
346	}
347	#endif
348
349	#if REAL_ADDRESSING
350	// Delete Low Memory area
351	if (lm_area_mapped)
352	vm_release(0, 0x2000);
353	#endif
354
355	// Exit VM wrappers
356	vm_exit();
357
358	// Exit system routines
359	SysExit();
360
361	// Exit preferences
362	PrefsExit();
363	}
364
365	void QuitEmulator(void)
366	{
367	extern NSApplication *NSApp;
368
369
370	QuitEmuNoExit();
371
372	// Stop run loop?
373	[NSApp terminate: nil];
374
375	exit(0);
376	}
377
378
379	/*
380	* Code was patched, flush caches if neccessary (i.e. when using a real 680x0
381	* or a dynamically recompiling emulator)
382	*/
383
384	void FlushCodeCache(void *start, uint32 size)
385	{
386	}
387
388
389	/*
390	* SIGINT handler, enters mon
391	*/
392
393	#ifdef ENABLE_MON
394	static void sigint_handler(...)
395	{
396	uaecptr nextpc;
397	extern void m68k_dumpstate(uaecptr *nextpc);
398	m68k_dumpstate(&nextpc);
399	VideoQuitFullScreen();
400	char *arg[4] = {"mon", "-m", "-r", NULL};
401	mon(3, arg);
402	QuitEmulator();
403	}
404	#endif
405
406
407	/*
408	* Mutexes
409	*/
410
411	#ifdef HAVE_PTHREADS
412
413	struct B2_mutex {
414	B2_mutex() { pthread_mutex_init(&m, NULL); }
415	~B2_mutex() { pthread_mutex_unlock(&m); pthread_mutex_destroy(&m); }
416	pthread_mutex_t m;
417	};
418
419	B2_mutex *B2_create_mutex(void)
420	{
421	return new B2_mutex;
422	}
423
424	void B2_lock_mutex(B2_mutex *mutex)
425	{
426	pthread_mutex_lock(&mutex->m);
427	}
428
429	void B2_unlock_mutex(B2_mutex *mutex)
430	{
431	pthread_mutex_unlock(&mutex->m);
432	}
433
434	void B2_delete_mutex(B2_mutex *mutex)
435	{
436	delete mutex;
437	}
438
439	#else
440
441	struct B2_mutex {
442	int dummy;
443	};
444
445	B2_mutex *B2_create_mutex(void)
446	{
447	return new B2_mutex;
448	}
449
450	void B2_lock_mutex(B2_mutex *mutex)
451	{
452	}
453
454	void B2_unlock_mutex(B2_mutex *mutex)
455	{
456	}
457
458	void B2_delete_mutex(B2_mutex *mutex)
459	{
460	delete mutex;
461	}
462
463	#endif
464
465
466	/*
467	* Interrupt flags (must be handled atomically!)
468	*/
469
470	uint32 InterruptFlags = 0;
471
472	void SetInterruptFlag(uint32 flag)
473	{
474	LOCK_INTFLAGS;
475	InterruptFlags \|= flag;
476	UNLOCK_INTFLAGS;
477	}
478
479	void ClearInterruptFlag(uint32 flag)
480	{
481	LOCK_INTFLAGS;
482	InterruptFlags &= ~flag;
483	UNLOCK_INTFLAGS;
484	}
485
486
487	/*
488	* Display error alert
489	*/
490
491	void ErrorAlert(const char *text)
492	{
493	NSString *title = [NSString stringWithCString:
494	GetString(STR_ERROR_ALERT_TITLE) ];
495	NSString *error = [NSString stringWithCString: text];
496	NSString *button = [NSString stringWithCString: GetString(STR_QUIT_BUTTON) ];
497
498	// If we have a full screen mode, quit it here?
499
500	NSLog(error);
501	NSRunCriticalAlertPanel(title, error, button, nil, nil);
502	}
503
504
505	/*
506	* Display warning alert
507	*/
508
509	void WarningAlert(const char *text)
510	{
511	NSString *title = [NSString stringWithCString:
512	GetString(STR_WARNING_ALERT_TITLE) ];
513	NSString *warning = [NSString stringWithCString: text];
514	NSString *button = [NSString stringWithCString: GetString(STR_OK_BUTTON) ];
515
516	NSLog(warning);
517	NSRunAlertPanel(title, warning, button, nil, nil);
518	}
519
520
521	/*
522	* Display choice alert
523	*/
524
525	bool ChoiceAlert(const char text, const char pos, const char *neg)
526	{
527	NSString *title = [NSString stringWithCString:
528	GetString(STR_WARNING_ALERT_TITLE) ];
529	NSString *warning = [NSString stringWithCString: text];
530	NSString *yes = [NSString stringWithCString: pos];
531	NSString *no = [NSString stringWithCString: neg];
532
533	NSLog(warning);
534	return NSRunInformationalAlertPanel(title, warning, yes, no, nil);
535	}