ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/Unix/main_unix.cpp
(Generate patch)

Comparing SheepShaver/src/Unix/main_unix.cpp (file contents):
Revision 1.69 by gbeauche, 2005-07-04T05:34:33Z vs.
Revision 1.98 by asvitkine, 2011-12-30T17:38:39Z

# Line 1 | Line 1
1   /*
2   *  main_unix.cpp - Emulation core, Unix implementation
3   *
4 < *  SheepShaver (C) 1997-2005 Christian Bauer and Marc Hellwig
4 > *  SheepShaver (C) Christian Bauer and Marc Hellwig
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 89 | Line 89
89   #include <sys/mman.h>
90   #include <sys/ipc.h>
91   #include <sys/shm.h>
92 + #include <sys/stat.h>
93   #include <signal.h>
94  
95   #include "sysdeps.h"
# Line 110 | Line 111
111   #include "vm_alloc.h"
112   #include "sigsegv.h"
113   #include "sigregs.h"
114 + #include "rpc.h"
115  
116   #define DEBUG 0
117   #include "debug.h"
# Line 134 | Line 136
136   #ifdef ENABLE_XF86_DGA
137   #include <X11/Xlib.h>
138   #include <X11/Xutil.h>
139 < #include <X11/extensions/xf86dga.h>
139 > #include <X11/extensions/Xxf86dga.h>
140   #endif
141  
142   #ifdef ENABLE_MON
# Line 159 | Line 161
161   const char ROM_FILE_NAME[] = "ROM";
162   const char ROM_FILE_NAME2[] = "Mac OS ROM";
163  
164 < #if REAL_ADDRESSING
163 < const uintptr RAM_BASE = 0x20000000;            // Base address of RAM
164 < #else
164 > #if !REAL_ADDRESSING
165   // FIXME: needs to be >= 0x04000000
166   const uintptr RAM_BASE = 0x10000000;            // Base address of RAM
167   #endif
168 + const uintptr ROM_BASE = 0x40800000;            // Base address of ROM
169 + #if REAL_ADDRESSING
170 + const uint32 ROM_ALIGNMENT = 0x100000;          // ROM must be aligned to a 1MB boundary
171 + #endif
172   const uint32 SIG_STACK_SIZE = 0x10000;          // Size of signal stack
173  
174  
# Line 175 | Line 179 | void *R13 = NULL;              // Pointer to .sdata
179   #endif
180   uint32 RAMBase;                 // Base address of Mac RAM
181   uint32 RAMSize;                 // Size of Mac RAM
182 + uint32 ROMBase;                 // Base address of Mac ROM
183   uint32 KernelDataAddr;  // Address of Kernel Data
184   uint32 BootGlobsAddr;   // Address of BootGlobs structure at top of Mac RAM
185   uint32 DRCacheAddr;             // Address of DR Cache
# Line 224 | Line 229 | static uintptr sig_stack = 0;                          // Stac
229   #else
230   static struct sigaction sigsegv_action;         // Data access exception signal (of emulator thread)
231   static struct sigaction sigill_action;          // Illegal instruction signal (of emulator thread)
232 < static struct sigaltstack sig_stack;            // Stack for signal handlers
233 < static struct sigaltstack extra_stack;          // Stack for SIGSEGV inside interrupt handler
232 > static stack_t sig_stack;                                       // Stack for signal handlers
233 > static stack_t extra_stack;                                     // Stack for SIGSEGV inside interrupt handler
234   static bool emul_thread_fatal = false;          // Flag: MacOS thread crashed, tick thread shall dump debug output
235   static sigregs sigsegv_regs;                            // Register dump when crashed
236   static const char *crash_reason = NULL;         // Reason of the crash (SIGSEGV, SIGBUS, SIGILL)
237   #endif
238  
239 + static rpc_connection_t *gui_connection = NULL; // RPC connection to the GUI
240 + static const char *gui_connection_path = NULL;  // GUI connection identifier
241 +
242   uint32  SheepMem::page_size;                            // Size of a native page
243   uintptr SheepMem::zero_page = 0;                        // Address of ro page filled in with zeros
244   uintptr SheepMem::base = 0x60000000;            // Address of SheepShaver data
# Line 249 | Line 257 | static void *tick_func(void *arg);
257   extern void emul_ppc(uint32 start);
258   extern void init_emul_ppc(void);
259   extern void exit_emul_ppc(void);
260 < sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t);
260 > sigsegv_return_t sigsegv_handler(sigsegv_info_t *sip);
261   #else
262   extern "C" void sigusr2_handler_init(int sig, siginfo_t *sip, void *scp);
263   extern "C" void sigusr2_handler(int sig, siginfo_t *sip, void *scp);
# Line 332 | Line 340 | int atomic_or(int *var, int v)
340   *  Memory management helpers
341   */
342  
343 < static inline int vm_mac_acquire(uint32 addr, uint32 size)
343 > static inline uint8 *vm_mac_acquire(uint32 size)
344 > {
345 >        return (uint8 *)vm_acquire(size);
346 > }
347 >
348 > static inline int vm_mac_acquire_fixed(uint32 addr, uint32 size)
349   {
350          return vm_acquire_fixed(Mac2HostAddr(addr), size);
351   }
# Line 356 | Line 369 | static void usage(const char *prg_name)
369          exit(0);
370   }
371  
372 < int main(int argc, char **argv)
372 > static bool valid_vmdir(const char *path)
373   {
374 <        char str[256];
375 <        int rom_fd;
376 <        FILE *proc_file;
377 <        const char *rom_path;
378 <        uint32 rom_size, actual;
379 <        uint8 *rom_tmp;
380 <        time_t now, expire;
381 <
369 <        // Initialize variables
370 <        RAMBase = 0;
371 <        tzset();
372 <
373 <        // Print some info
374 <        printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
375 <        printf(" %s\n", GetString(STR_ABOUT_TEXT2));
376 <
377 < #if !EMULATED_PPC
378 < #ifdef SYSTEM_CLOBBERS_R2
379 <        // Get TOC pointer
380 <        TOC = get_r2();
381 < #endif
382 < #ifdef SYSTEM_CLOBBERS_R13
383 <        // Get r13 register
384 <        R13 = get_r13();
385 < #endif
386 < #endif
387 <
388 < #ifdef ENABLE_GTK
389 <        // Init GTK
390 <        gtk_set_locale();
391 <        gtk_init(&argc, &argv);
392 < #endif
393 <
394 <        // Read preferences
395 <        PrefsInit(argc, argv);
396 <
397 <        // Parse command line arguments
398 <        for (int i=1; i<argc; i++) {
399 <                if (strcmp(argv[i], "--help") == 0) {
400 <                        usage(argv[0]);
401 < #ifndef USE_SDL_VIDEO
402 <                } else if (strcmp(argv[i], "--display") == 0) {
403 <                        i++;
404 <                        if (i < argc)
405 <                                x_display_name = strdup(argv[i]);
406 < #endif
407 <                } else if (argv[i][0] == '-') {
408 <                        fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
409 <                        usage(argv[0]);
374 >        const int suffix_len = sizeof(".sheepvm") - 1;
375 >        int len = strlen(path);
376 >        if (len && path[len - 1] == '/') // to support both ".sheepvm" and ".sheepvm/"
377 >                len--;
378 >        if (len > suffix_len && !strncmp(path + len - suffix_len, ".sheepvm", suffix_len)) {
379 >                struct stat d;
380 >                if (!stat(path, &d) && S_ISDIR(d.st_mode)) {
381 >                        return true;
382                  }
383          }
384 +        return false;
385 + }
386  
387 < #ifdef USE_SDL
388 <        // Initialize SDL system
415 <        int sdl_flags = 0;
416 < #ifdef USE_SDL_VIDEO
417 <        sdl_flags |= SDL_INIT_VIDEO;
418 < #endif
419 < #ifdef USE_SDL_AUDIO
420 <        sdl_flags |= SDL_INIT_AUDIO;
421 < #endif
422 <        assert(sdl_flags != 0);
423 <        if (SDL_Init(sdl_flags) == -1) {
424 <                char str[256];
425 <                sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
426 <                ErrorAlert(str);
427 <                goto quit;
428 <        }
429 <        atexit(SDL_Quit);
430 < #endif
431 <
432 < #ifndef USE_SDL_VIDEO
433 <        // Open display
434 <        x_display = XOpenDisplay(x_display_name);
435 <        if (x_display == NULL) {
436 <                char str[256];
437 <                sprintf(str, GetString(STR_NO_XSERVER_ERR), XDisplayName(x_display_name));
438 <                ErrorAlert(str);
439 <                goto quit;
440 <        }
441 <
442 < #if defined(ENABLE_XF86_DGA) && !defined(ENABLE_MON)
443 <        // Fork out, so we can return from fullscreen mode when things get ugly
444 <        XF86DGAForkApp(DefaultScreen(x_display));
445 < #endif
446 < #endif
447 <
448 < #ifdef ENABLE_MON
449 <        // Initialize mon
450 <        mon_init();
451 < #endif
452 <
453 < #if !EMULATED_PPC
454 <        // Create and install stacks for signal handlers
455 <        sig_stack.ss_sp = malloc(SIG_STACK_SIZE);
456 <        D(bug("Signal stack at %p\n", sig_stack.ss_sp));
457 <        if (sig_stack.ss_sp == NULL) {
458 <                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
459 <                goto quit;
460 <        }
461 <        sig_stack.ss_flags = 0;
462 <        sig_stack.ss_size = SIG_STACK_SIZE;
463 <        if (sigaltstack(&sig_stack, NULL) < 0) {
464 <                sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
465 <                ErrorAlert(str);
466 <                goto quit;
467 <        }
468 <        extra_stack.ss_sp = malloc(SIG_STACK_SIZE);
469 <        D(bug("Extra stack at %p\n", extra_stack.ss_sp));
470 <        if (extra_stack.ss_sp == NULL) {
471 <                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
472 <                goto quit;
473 <        }
474 <        extra_stack.ss_flags = 0;
475 <        extra_stack.ss_size = SIG_STACK_SIZE;
476 < #endif
477 <
387 > static void get_system_info(void)
388 > {
389   #if !EMULATED_PPC
390 <        // Install SIGSEGV and SIGBUS handlers
480 <        sigemptyset(&sigsegv_action.sa_mask);   // Block interrupts during SEGV handling
481 <        sigaddset(&sigsegv_action.sa_mask, SIGUSR2);
482 <        sigsegv_action.sa_sigaction = sigsegv_handler;
483 <        sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
484 < #ifdef HAVE_SIGNAL_SA_RESTORER
485 <        sigsegv_action.sa_restorer = NULL;
486 < #endif
487 <        if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) {
488 <                sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
489 <                ErrorAlert(str);
490 <                goto quit;
491 <        }
492 <        if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) {
493 <                sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
494 <                ErrorAlert(str);
495 <                goto quit;
496 <        }
497 < #else
498 <        // Install SIGSEGV handler for CPU emulator
499 <        if (!sigsegv_install_handler(sigsegv_handler)) {
500 <                sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
501 <                ErrorAlert(str);
502 <                goto quit;
503 <        }
390 >        FILE *proc_file;
391   #endif
392  
506        // Initialize VM system
507        vm_init();
508
509        // Get system info
393          PVR = 0x00040000;                       // Default: 604
394          CPUClockSpeed = 100000000;      // Default: 100MHz
395          BusClockSpeed = 100000000;      // Default: 100MHz
396          TimebaseSpeed =  25000000;      // Default:  25MHz
397 +
398   #if EMULATED_PPC
399          PVR = 0x000c0000;                       // Default: 7400 (with AltiVec)
400   #elif defined(__APPLE__) && defined(__MACH__)
# Line 545 | Line 429 | int main(int argc, char **argv)
429                  }
430                  fclose(proc_file);
431          } else {
432 +                char str[256];
433                  sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno));
434                  WarningAlert(str);
435          }
# Line 589 | Line 474 | int main(int argc, char **argv)
474                          { 0xffff0000, 0x80010000, "7455" },
475                          { 0xffff0000, 0x80020000, "7457" },
476                          { 0xffff0000, 0x80030000, "7447A" },
477 +                        { 0xffff0000, 0x80040000, "7448" },
478                          { 0x7fff0000, 0x00810000, "82xx" },
479                          { 0x7fff0000, 0x00820000, "8280" },
480                          { 0xffff0000, 0x00400000, "Power3 (630)" },
# Line 597 | Line 483 | int main(int argc, char **argv)
483                          { 0xffff0000, 0x00370000, "S-star" },
484                          { 0xffff0000, 0x00350000, "Power4" },
485                          { 0xffff0000, 0x00390000, "PPC970" },
486 <                        { 0xffff0000, 0x003a0000, "POWER5" },
486 >                        { 0xffff0000, 0x003c0000, "PPC970FX" },
487 >                        { 0xffff0000, 0x00440000, "PPC970MP" },
488 >                        { 0xffff0000, 0x003a0000, "POWER5 (gr)" },
489 >                        { 0xffff0000, 0x003b0000, "POWER5+ (gs)" },
490 >                        { 0xffff0000, 0x003e0000, "POWER6" },
491 >                        { 0xffff0000, 0x00700000, "Cell Broadband Engine" },
492 >                        { 0x7fff0000, 0x00900000, "PA6T" },
493                          { 0, 0, 0 }
494                  };
495  
# Line 611 | Line 503 | int main(int argc, char **argv)
503  
504                          // Parse line
505                          int i;
506 +                        float f;
507                          char value[256];
508 <                        if (sscanf(line, "cpu : %[0-9A-Za-a]", value) == 1) {
508 >                        if (sscanf(line, "cpu : %[^,]", value) == 1) {
509                                  // Search by name
510                                  const char *cpu_name = NULL;
511                                  for (int i = 0; cpu_specs[i].pvr_mask != 0; i++) {
# Line 627 | Line 520 | int main(int argc, char **argv)
520                                  else
521                                          printf("Found a PowerPC %s processor\n", cpu_name);
522                          }
523 <                        if (sscanf(line, "clock : %dMHz", &i) == 1)
523 >                        if (sscanf(line, "clock : %fMHz", &f) == 1)
524 >                                CPUClockSpeed = BusClockSpeed = ((int64)f) * 1000000;
525 >                        else if (sscanf(line, "clock : %dMHz", &i) == 1)
526                                  CPUClockSpeed = BusClockSpeed = i * 1000000;
527                  }
528                  fclose(proc_file);
# Line 666 | Line 561 | int main(int argc, char **argv)
561                  closedir(cpus_dir);
562          }
563   #endif
564 +
565          // Remap any newer G4/G5 processor to plain G4 for compatibility
566          switch (PVR >> 16) {
567          case 0x8000:                            // 7450
568          case 0x8001:                            // 7455
569          case 0x8002:                            // 7457
570 +        case 0x8003:                            // 7447A
571 +        case 0x8004:                            // 7448
572          case 0x0039:                            //  970
573 +        case 0x003c:                            //  970FX
574 +        case 0x0044:                            //  970MP
575                  PVR = 0x000c0000;               // 7400
576                  break;
577          }
578          D(bug("PVR: %08x (assumed)\n", PVR));
579 + }
580 +
581 + static bool load_mac_rom(void)
582 + {
583 +        uint32 rom_size, actual;
584 +        uint8 *rom_tmp;
585 +        const char *rom_path = PrefsFindString("rom");
586 +        int rom_fd = open(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
587 +        if (rom_fd < 0) {
588 +                rom_fd = open(ROM_FILE_NAME2, O_RDONLY);
589 +                if (rom_fd < 0) {
590 +                        ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
591 +                        return false;
592 +                }
593 +        }
594 +        printf("%s", GetString(STR_READING_ROM_FILE));
595 +        rom_size = lseek(rom_fd, 0, SEEK_END);
596 +        lseek(rom_fd, 0, SEEK_SET);
597 +        rom_tmp = new uint8[ROM_SIZE];
598 +        actual = read(rom_fd, (void *)rom_tmp, ROM_SIZE);
599 +        close(rom_fd);
600 +        
601 +        // Decode Mac ROM
602 +        if (!DecodeROM(rom_tmp, actual)) {
603 +                if (rom_size != 4*1024*1024) {
604 +                        ErrorAlert(GetString(STR_ROM_SIZE_ERR));
605 +                        return false;
606 +                } else {
607 +                        ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
608 +                        return false;
609 +                }
610 +        }
611 +        delete[] rom_tmp;
612 +        return true;
613 + }
614 +
615 + static bool install_signal_handlers(void)
616 + {
617 +        char str[256];
618 + #if !EMULATED_PPC
619 +        // Create and install stacks for signal handlers
620 +        sig_stack.ss_sp = malloc(SIG_STACK_SIZE);
621 +        D(bug("Signal stack at %p\n", sig_stack.ss_sp));
622 +        if (sig_stack.ss_sp == NULL) {
623 +                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
624 +                return false;
625 +        }
626 +        sig_stack.ss_flags = 0;
627 +        sig_stack.ss_size = SIG_STACK_SIZE;
628 +        if (sigaltstack(&sig_stack, NULL) < 0) {
629 +                sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
630 +                ErrorAlert(str);
631 +                return false;
632 +        }
633 +        extra_stack.ss_sp = malloc(SIG_STACK_SIZE);
634 +        D(bug("Extra stack at %p\n", extra_stack.ss_sp));
635 +        if (extra_stack.ss_sp == NULL) {
636 +                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
637 +                return false;
638 +        }
639 +        extra_stack.ss_flags = 0;
640 +        extra_stack.ss_size = SIG_STACK_SIZE;
641 +
642 +        // Install SIGSEGV and SIGBUS handlers
643 +        sigemptyset(&sigsegv_action.sa_mask);   // Block interrupts during SEGV handling
644 +        sigaddset(&sigsegv_action.sa_mask, SIGUSR2);
645 +        sigsegv_action.sa_sigaction = sigsegv_handler;
646 +        sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
647 + #ifdef HAVE_SIGNAL_SA_RESTORER
648 +        sigsegv_action.sa_restorer = NULL;
649 + #endif
650 +        if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) {
651 +                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
652 +                ErrorAlert(str);
653 +                return false;
654 +        }
655 +        if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) {
656 +                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGBUS", strerror(errno));
657 +                ErrorAlert(str);
658 +                return false;
659 +        }
660 + #else
661 +        // Install SIGSEGV handler for CPU emulator
662 +        if (!sigsegv_install_handler(sigsegv_handler)) {
663 +                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
664 +                ErrorAlert(str);
665 +                return false;
666 +        }
667 + #endif
668 +        return true;
669 + }
670 +
671 + static bool init_sdl()
672 + {
673 +        int sdl_flags = 0;
674 + #ifdef USE_SDL_VIDEO
675 +        sdl_flags |= SDL_INIT_VIDEO;
676 + #endif
677 + #ifdef USE_SDL_AUDIO
678 +        sdl_flags |= SDL_INIT_AUDIO;
679 + #endif
680 +        assert(sdl_flags != 0);
681 +
682 + #ifdef USE_SDL_VIDEO
683 +        // Don't let SDL block the screensaver
684 +        setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", TRUE);
685 +
686 +        // Make SDL pass through command-clicks and option-clicks unaltered
687 +        setenv("SDL_HAS3BUTTONMOUSE", "1", TRUE);
688 + #endif
689 +
690 +        if (SDL_Init(sdl_flags) == -1) {
691 +                char str[256];
692 +                sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
693 +                ErrorAlert(str);
694 +                return false;
695 +        }
696 +        atexit(SDL_Quit);
697 +
698 +        // Don't let SDL catch SIGINT and SIGTERM signals
699 +        signal(SIGINT, SIG_DFL);
700 +        signal(SIGTERM, SIG_DFL);
701 +        return true;
702 + }
703 +
704 + int main(int argc, char **argv)
705 + {
706 +        char str[256];
707 +        bool memory_mapped_from_zero, ram_rom_areas_contiguous;
708 +        const char *vmdir = NULL;
709 +
710 +        // Initialize variables
711 +        RAMBase = 0;
712 +        tzset();
713 +
714 +        // Print some info
715 +        printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
716 +        printf(" %s\n", GetString(STR_ABOUT_TEXT2));
717 +
718 + #if !EMULATED_PPC
719 + #ifdef SYSTEM_CLOBBERS_R2
720 +        // Get TOC pointer
721 +        TOC = get_r2();
722 + #endif
723 + #ifdef SYSTEM_CLOBBERS_R13
724 +        // Get r13 register
725 +        R13 = get_r13();
726 + #endif
727 + #endif
728 +
729 +        // Parse command line arguments
730 +        for (int i=1; i<argc; i++) {
731 +                if (strcmp(argv[i], "--help") == 0) {
732 +                        usage(argv[0]);
733 + #ifndef USE_SDL_VIDEO
734 +                } else if (strcmp(argv[i], "--display") == 0) {
735 +                        i++;
736 +                        if (i < argc)
737 +                                x_display_name = strdup(argv[i]);
738 + #endif
739 +                } else if (strcmp(argv[i], "--gui-connection") == 0) {
740 +                        argv[i++] = NULL;
741 +                        if (i < argc) {
742 +                                gui_connection_path = argv[i];
743 +                                argv[i] = NULL;
744 +                        }
745 +                } else if (valid_vmdir(argv[i])) {
746 +                        vmdir = argv[i];
747 +                        argv[i] = NULL;
748 +                        printf("Using %s as vmdir.\n", vmdir);
749 +                        if (chdir(vmdir)) {
750 +                                printf("Failed to chdir to %s. Good bye.", vmdir);
751 +                                exit(1);
752 +                        }
753 +                        break;
754 +                }
755 +        }
756 +
757 +        // Remove processed arguments
758 +        for (int i=1; i<argc; i++) {
759 +                int k;
760 +                for (k=i; k<argc; k++)
761 +                        if (argv[k] != NULL)
762 +                                break;
763 +                if (k > i) {
764 +                        k -= i;
765 +                        for (int j=i+k; j<argc; j++)
766 +                                argv[j-k] = argv[j];
767 +                        argc -= k;
768 +                }
769 +        }
770 +
771 +        // Connect to the external GUI
772 +        if (gui_connection_path) {
773 +                if ((gui_connection = rpc_init_client(gui_connection_path)) == NULL) {
774 +                        fprintf(stderr, "Failed to initialize RPC client connection to the GUI\n");
775 +                        return 1;
776 +                }
777 +        }
778 +
779 + #ifdef ENABLE_GTK
780 +        if (!gui_connection) {
781 +                // Init GTK
782 +                gtk_set_locale();
783 +                gtk_init(&argc, &argv);
784 +        }
785 + #endif
786 +
787 +        // Read preferences
788 +        PrefsInit(vmdir, argc, argv);
789 +
790 +        // Any command line arguments left?
791 +        for (int i=1; i<argc; i++) {
792 +                if (argv[i][0] == '-') {
793 +                        fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
794 +                        usage(argv[0]);
795 +                }
796 +        }
797 +
798 + #ifdef USE_SDL
799 +        // Initialize SDL system
800 +        if (!init_sdl())
801 +                goto quit;
802 + #endif
803 +
804 + #ifndef USE_SDL_VIDEO
805 +        // Open display
806 +        x_display = XOpenDisplay(x_display_name);
807 +        if (x_display == NULL) {
808 +                char str[256];
809 +                sprintf(str, GetString(STR_NO_XSERVER_ERR), XDisplayName(x_display_name));
810 +                ErrorAlert(str);
811 +                goto quit;
812 +        }
813 +
814 + #if defined(ENABLE_XF86_DGA) && !defined(ENABLE_MON)
815 +        // Fork out, so we can return from fullscreen mode when things get ugly
816 +        XF86DGAForkApp(DefaultScreen(x_display));
817 + #endif
818 + #endif
819 +
820 + #ifdef ENABLE_MON
821 +        // Initialize mon
822 +        mon_init();
823 + #endif
824 +
825 +  // Install signal handlers
826 +        if (!install_signal_handlers())
827 +                goto quit;
828 +
829 +        // Initialize VM system
830 +        vm_init();
831 +
832 +        // Get system info
833 +        get_system_info();
834  
835          // Init system routines
836          SysInit();
# Line 698 | Line 853 | int main(int argc, char **argv)
853                  goto quit;
854          }
855  
701 #ifndef PAGEZERO_HACK
702        // Create Low Memory area (0x0000..0x3000)
703        if (vm_mac_acquire(0, 0x3000) < 0) {
704                sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
705                ErrorAlert(str);
706                goto quit;
707        }
708        lm_area_mapped = true;
709 #endif
710
856          // Create areas for Kernel Data
857          if (!kernel_data_init())
858                  goto quit;
# Line 718 | Line 863 | int main(int argc, char **argv)
863          D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
864  
865          // Create area for DR Cache
866 <        if (vm_mac_acquire(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
866 >        if (vm_mac_acquire_fixed(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
867                  sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
868                  ErrorAlert(str);
869                  goto quit;
870          }
871          dr_emulator_area_mapped = true;
872 <        if (vm_mac_acquire(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
872 >        if (vm_mac_acquire_fixed(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
873                  sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
874                  ErrorAlert(str);
875                  goto quit;
# Line 746 | Line 891 | int main(int argc, char **argv)
891                  ErrorAlert(str);
892                  goto quit;
893          }
894 <
750 <        // Create area for Mac ROM
751 <        if (vm_mac_acquire(ROM_BASE, ROM_AREA_SIZE) < 0) {
752 <                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
753 <                ErrorAlert(str);
754 <                goto quit;
755 <        }
756 <        ROMBaseHost = Mac2HostAddr(ROM_BASE);
757 < #if !EMULATED_PPC
758 <        if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
759 <                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
760 <                ErrorAlert(str);
761 <                goto quit;
762 <        }
763 < #endif
764 <        rom_area_mapped = true;
765 <        D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROM_BASE));
766 <
894 >        
895          // Create area for Mac RAM
896          RAMSize = PrefsFindInt32("ramsize");
897          if (RAMSize < 8*1024*1024) {
898                  WarningAlert(GetString(STR_SMALL_RAM_WARN));
899                  RAMSize = 8*1024*1024;
900          }
901 <
902 <        if (vm_mac_acquire(RAM_BASE, RAMSize) < 0) {
903 <                sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
904 <                ErrorAlert(str);
905 <                goto quit;
901 >        memory_mapped_from_zero = false;
902 >        ram_rom_areas_contiguous = false;
903 > #if REAL_ADDRESSING && HAVE_LINKER_SCRIPT
904 >        if (vm_mac_acquire_fixed(0, RAMSize) == 0) {
905 >                D(bug("Could allocate RAM from 0x0000\n"));
906 >                RAMBase = 0;
907 >                RAMBaseHost = Mac2HostAddr(RAMBase);
908 >                memory_mapped_from_zero = true;
909 >        }
910 > #endif
911 >        if (!memory_mapped_from_zero) {
912 > #ifndef PAGEZERO_HACK
913 >                // Create Low Memory area (0x0000..0x3000)
914 >                if (vm_mac_acquire_fixed(0, 0x3000) < 0) {
915 >                        sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
916 >                        ErrorAlert(str);
917 >                        goto quit;
918 >                }
919 >                lm_area_mapped = true;
920 > #endif
921 > #if REAL_ADDRESSING
922 >                // Allocate RAM at any address. Since ROM must be higher than RAM, allocate the RAM
923 >                // and ROM areas contiguously, plus a little extra to allow for ROM address alignment.
924 >                RAMBaseHost = vm_mac_acquire(RAMSize + ROM_AREA_SIZE + ROM_ALIGNMENT);
925 >                if (RAMBaseHost == VM_MAP_FAILED) {
926 >                        sprintf(str, GetString(STR_RAM_ROM_MMAP_ERR), strerror(errno));
927 >                        ErrorAlert(str);
928 >                        goto quit;
929 >                }
930 >                RAMBase = Host2MacAddr(RAMBaseHost);
931 >                ROMBase = (RAMBase + RAMSize + ROM_ALIGNMENT -1) & -ROM_ALIGNMENT;
932 >                ROMBaseHost = Mac2HostAddr(ROMBase);
933 >                ram_rom_areas_contiguous = true;
934 > #else
935 >                if (vm_mac_acquire_fixed(RAM_BASE, RAMSize) < 0) {
936 >                        sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
937 >                        ErrorAlert(str);
938 >                        goto quit;
939 >                }
940 >                RAMBase = RAM_BASE;
941 >                RAMBaseHost = Mac2HostAddr(RAMBase);
942 > #endif
943          }
779        RAMBaseHost = Mac2HostAddr(RAM_BASE);
944   #if !EMULATED_PPC
945          if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
946                  sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
# Line 784 | Line 948 | int main(int argc, char **argv)
948                  goto quit;
949          }
950   #endif
787        RAMBase = RAM_BASE;
951          ram_area_mapped = true;
952          D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
953  
954 <        if (RAMBase > ROM_BASE) {
955 <                ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
954 >        if (RAMBase > KernelDataAddr) {
955 >                ErrorAlert(GetString(STR_RAM_AREA_TOO_HIGH_ERR));
956                  goto quit;
957          }
795
796        // Load Mac ROM
797        rom_path = PrefsFindString("rom");
798        rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
799        if (rom_fd < 0) {
800                rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME2, O_RDONLY);
801                if (rom_fd < 0) {
802                        ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
803                        goto quit;
804                }
805        }
806        printf(GetString(STR_READING_ROM_FILE));
807        rom_size = lseek(rom_fd, 0, SEEK_END);
808        lseek(rom_fd, 0, SEEK_SET);
809        rom_tmp = new uint8[ROM_SIZE];
810        actual = read(rom_fd, (void *)rom_tmp, ROM_SIZE);
811        close(rom_fd);
958          
959 <        // Decode Mac ROM
960 <        if (!DecodeROM(rom_tmp, actual)) {
961 <                if (rom_size != 4*1024*1024) {
962 <                        ErrorAlert(GetString(STR_ROM_SIZE_ERR));
963 <                        goto quit;
818 <                } else {
819 <                        ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
959 >        // Create area for Mac ROM
960 >        if (!ram_rom_areas_contiguous) {
961 >                if (vm_mac_acquire_fixed(ROM_BASE, ROM_AREA_SIZE) < 0) {
962 >                        sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
963 >                        ErrorAlert(str);
964                          goto quit;
965                  }
966 +                ROMBase = ROM_BASE;
967 +                ROMBaseHost = Mac2HostAddr(ROMBase);
968          }
969 <        delete[] rom_tmp;
969 > #if !EMULATED_PPC
970 >        if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
971 >                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
972 >                ErrorAlert(str);
973 >                goto quit;
974 >        }
975 > #endif
976 >        rom_area_mapped = true;
977 >        D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase));
978 >
979 >        if (RAMBase > ROMBase) {
980 >                ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
981 >                goto quit;
982 >        }
983 >
984 >        // Load Mac ROM
985 >        if (!load_mac_rom())
986 >                goto quit;
987  
988          // Initialize everything
989 <        if (!InitAll())
989 >        if (!InitAll(vmdir))
990                  goto quit;
991          D(bug("Initialization complete\n"));
992  
993          // Clear caches (as we loaded and patched code) and write protect ROM
994   #if !EMULATED_PPC
995 <        flush_icache_range(ROM_BASE, ROM_BASE + ROM_AREA_SIZE);
995 >        flush_icache_range(ROMBase, ROMBase + ROM_AREA_SIZE);
996   #endif
997          vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
998  
# Line 854 | Line 1017 | int main(int argc, char **argv)
1017          sigill_action.sa_restorer = NULL;
1018   #endif
1019          if (sigaction(SIGILL, &sigill_action, NULL) < 0) {
1020 <                sprintf(str, GetString(STR_SIGILL_INSTALL_ERR), strerror(errno));
1020 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGILL", strerror(errno));
1021                  ErrorAlert(str);
1022                  goto quit;
1023          }
# Line 869 | Line 1032 | int main(int argc, char **argv)
1032          sigusr2_action.sa_restorer = NULL;
1033   #endif
1034          if (sigaction(SIGUSR2, &sigusr2_action, NULL) < 0) {
1035 <                sprintf(str, GetString(STR_SIGUSR2_INSTALL_ERR), strerror(errno));
1035 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGUSR2", strerror(errno));
1036                  ErrorAlert(str);
1037                  goto quit;
1038          }
# Line 940 | Line 1103 | static void Quit(void)
1103  
1104          // Delete RAM area
1105          if (ram_area_mapped)
1106 <                vm_mac_release(RAM_BASE, RAMSize);
1106 >                vm_mac_release(RAMBase, RAMSize);
1107  
1108          // Delete ROM area
1109          if (rom_area_mapped)
1110 <                vm_mac_release(ROM_BASE, ROM_AREA_SIZE);
1110 >                vm_mac_release(ROMBase, ROM_AREA_SIZE);
1111  
1112          // Delete DR cache areas
1113          if (dr_emulator_area_mapped)
# Line 980 | Line 1143 | static void Quit(void)
1143                  XCloseDisplay(x_display);
1144   #endif
1145  
1146 +        // Notify GUI we are about to leave
1147 +        if (gui_connection) {
1148 +                if (rpc_method_invoke(gui_connection, RPC_METHOD_EXIT, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
1149 +                        rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID);
1150 +        }
1151 +
1152          exit(0);
1153   }
1154  
# Line 988 | Line 1157 | static void Quit(void)
1157   *  Initialize Kernel Data segments
1158   */
1159  
991 #if defined(__CYGWIN__)
992 #define WIN32_LEAN_AND_MEAN
993 #include <windows.h>
994
995 static HANDLE kernel_handle;                            // Shared memory handle for Kernel Data
996 static DWORD allocation_granule;                        // Minimum size of allocateable are (64K)
997 static DWORD kernel_area_size;                          // Size of Kernel Data area
998 #endif
999
1160   static bool kernel_data_init(void)
1161   {
1162          char str[256];
1163 < #ifdef _WIN32
1164 <        SYSTEM_INFO si;
1165 <        GetSystemInfo(&si);
1006 <        allocation_granule = si.dwAllocationGranularity;
1007 <        kernel_area_size = (KERNEL_AREA_SIZE + allocation_granule - 1) & -allocation_granule;
1008 <
1009 <        char rcs[10];
1010 <        LPVOID kernel_addr;
1011 <        kernel_handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, kernel_area_size, NULL);
1012 <        if (kernel_handle == NULL) {
1013 <                sprintf(rcs, "%d", GetLastError());
1014 <                sprintf(str, GetString(STR_KD_SHMGET_ERR), rcs);
1015 <                ErrorAlert(str);
1016 <                return false;
1017 <        }
1018 <        kernel_addr = (LPVOID)Mac2HostAddr(KERNEL_DATA_BASE & -allocation_granule);
1019 <        if (MapViewOfFileEx(kernel_handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, kernel_area_size, kernel_addr) != kernel_addr) {
1020 <                sprintf(rcs, "%d", GetLastError());
1021 <                sprintf(str, GetString(STR_KD_SHMAT_ERR), rcs);
1022 <                ErrorAlert(str);
1023 <                return false;
1024 <        }
1025 <        kernel_addr = (LPVOID)Mac2HostAddr(KERNEL_DATA2_BASE & -allocation_granule);
1026 <        if (MapViewOfFileEx(kernel_handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, kernel_area_size, kernel_addr) != kernel_addr) {
1027 <                sprintf(rcs, "%d", GetLastError());
1028 <                sprintf(str, GetString(STR_KD2_SHMAT_ERR), rcs);
1029 <                ErrorAlert(str);
1030 <                return false;
1031 <        }
1032 < #else
1033 <        kernel_area = shmget(IPC_PRIVATE, KERNEL_AREA_SIZE, 0600);
1163 >        uint32 kernel_area_size = (KERNEL_AREA_SIZE + SHMLBA - 1) & -SHMLBA;
1164 >
1165 >        kernel_area = shmget(IPC_PRIVATE, kernel_area_size, 0600);
1166          if (kernel_area == -1) {
1167                  sprintf(str, GetString(STR_KD_SHMGET_ERR), strerror(errno));
1168                  ErrorAlert(str);
1169                  return false;
1170          }
1171 <        if (shmat(kernel_area, Mac2HostAddr(KERNEL_DATA_BASE), 0) < 0) {
1171 >        void *kernel_addr = Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA);
1172 >        if (shmat(kernel_area, kernel_addr, 0) != kernel_addr) {
1173                  sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
1174                  ErrorAlert(str);
1175                  return false;
1176          }
1177 <        if (shmat(kernel_area, Mac2HostAddr(KERNEL_DATA2_BASE), 0) < 0) {
1177 >        kernel_addr = Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA);
1178 >        if (shmat(kernel_area, kernel_addr, 0) != kernel_addr) {
1179                  sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
1180                  ErrorAlert(str);
1181                  return false;
1182          }
1049 #endif
1183          return true;
1184   }
1185  
# Line 1057 | Line 1190 | static bool kernel_data_init(void)
1190  
1191   static void kernel_data_exit(void)
1192   {
1060 #ifdef _WIN32
1061        if (kernel_handle) {
1062                UnmapViewOfFile(Mac2HostAddr(KERNEL_DATA_BASE & -allocation_granule));
1063                UnmapViewOfFile(Mac2HostAddr(KERNEL_DATA2_BASE & -allocation_granule));
1064                CloseHandle(kernel_handle);
1065        }
1066 #else
1193          if (kernel_area >= 0) {
1194 <                shmdt(Mac2HostAddr(KERNEL_DATA_BASE));
1195 <                shmdt(Mac2HostAddr(KERNEL_DATA2_BASE));
1194 >                shmdt(Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA));
1195 >                shmdt(Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA));
1196                  shmctl(kernel_area, IPC_RMID, NULL);
1197          }
1072 #endif
1198   }
1199  
1200  
# Line 1101 | Line 1226 | static void *emul_func(void *arg)
1226          // Jump to ROM boot routine
1227          D(bug("Jumping to ROM\n"));
1228   #if EMULATED_PPC
1229 <        jump_to_rom(ROM_BASE + 0x310000);
1229 >        jump_to_rom(ROMBase + 0x310000);
1230   #else
1231 <        jump_to_rom(ROM_BASE + 0x310000, (uint32)emulator_data);
1231 >        jump_to_rom(ROMBase + 0x310000, (uint32)emulator_data);
1232   #endif
1233          D(bug("Returned from ROM\n"));
1234  
# Line 1189 | Line 1314 | void Dump68kRegs(M68kRegisters *r)
1314  
1315   void MakeExecutable(int dummy, uint32 start, uint32 length)
1316   {
1317 <        if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE)))
1317 >        if ((start >= ROMBase) && (start < (ROMBase + ROM_SIZE)))
1318                  return;
1319   #if EMULATED_PPC
1320          FlushCodeCache(start, start + length);
# Line 1532 | Line 1657 | void sigusr2_handler(int sig, siginfo_t
1657                                  // Execute nanokernel interrupt routine (this will activate the 68k emulator)
1658                                  DisableInterrupt();
1659                                  if (ROMType == ROMTYPE_NEWWORLD)
1660 <                                        ppc_interrupt(ROM_BASE + 0x312b1c, KernelDataAddr);
1660 >                                        ppc_interrupt(ROMBase + 0x312b1c, KernelDataAddr);
1661                                  else
1662 <                                        ppc_interrupt(ROM_BASE + 0x312a3c, KernelDataAddr);
1662 >                                        ppc_interrupt(ROMBase + 0x312a3c, KernelDataAddr);
1663  
1664                                  // Reset normal stack
1665                                  sigaltstack(&sig_stack, NULL);
# Line 1606 | Line 1731 | static void sigsegv_handler(int sig, sig
1731   #endif
1732  
1733   #if ENABLE_VOSF
1734 <        // Handle screen fault.
1735 <        extern bool Screen_fault_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction);
1736 <        if (Screen_fault_handler((sigsegv_address_t)addr, (sigsegv_address_t)r->pc()))
1734 >        // Handle screen fault
1735 > #if SIGSEGV_CHECK_VERSION(1,0,0)
1736 >        sigsegv_info_t si;
1737 >        si.addr = (sigsegv_address_t)addr;
1738 >        si.pc = (sigsegv_address_t)r->pc();
1739 > #endif
1740 >        extern bool Screen_fault_handler(sigsegv_info_t *sip);
1741 >        if (Screen_fault_handler(&si))
1742                  return;
1743   #endif
1744  
1745          num_segv++;
1746  
1747          // Fault in Mac ROM or RAM or DR Cache?
1748 <        bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize)) || (r->pc() >= DR_CACHE_BASE && r->pc() < (DR_CACHE_BASE + DR_CACHE_SIZE));
1748 >        bool mac_fault = (r->pc() >= ROMBase) && (r->pc() < (ROMBase + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize)) || (r->pc() >= DR_CACHE_BASE && r->pc() < (DR_CACHE_BASE + DR_CACHE_SIZE));
1749          if (mac_fault) {
1750  
1751                  // "VM settings" during MacOS 8 installation
1752 <                if (r->pc() == ROM_BASE + 0x488160 && r->gpr(20) == 0xf8000000) {
1752 >                if (r->pc() == ROMBase + 0x488160 && r->gpr(20) == 0xf8000000) {
1753                          r->pc() += 4;
1754                          r->gpr(8) = 0;
1755                          return;
1756          
1757                  // MacOS 8.5 installation
1758 <                } else if (r->pc() == ROM_BASE + 0x488140 && r->gpr(16) == 0xf8000000) {
1758 >                } else if (r->pc() == ROMBase + 0x488140 && r->gpr(16) == 0xf8000000) {
1759                          r->pc() += 4;
1760                          r->gpr(8) = 0;
1761                          return;
1762          
1763                  // MacOS 8 serial drivers on startup
1764 <                } else if (r->pc() == ROM_BASE + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) {
1764 >                } else if (r->pc() == ROMBase + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) {
1765                          r->pc() += 4;
1766                          r->gpr(8) = 0;
1767                          return;
1768          
1769                  // MacOS 8.1 serial drivers on startup
1770 <                } else if (r->pc() == ROM_BASE + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1770 >                } else if (r->pc() == ROMBase + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1771                          r->pc() += 4;
1772                          return;
1773 <                } else if (r->pc() == ROM_BASE + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1773 >                } else if (r->pc() == ROMBase + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1774                          r->pc() += 4;
1775                          return;
1776          
# Line 1773 | Line 1903 | static void sigsegv_handler(int sig, sig
1903          
1904                  // Ignore ROM writes (including to the zero page, which is read-only)
1905                  if (transfer_type == TYPE_STORE &&
1906 <                        ((addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) ||
1906 >                        ((addr >= ROMBase && addr < ROMBase + ROM_SIZE) ||
1907                           (addr >= SheepMem::ZeroPage() && addr < SheepMem::ZeroPage() + SheepMem::PageSize()))) {
1908   //                      D(bug("WARNING: %s write access to ROM at %08lx, pc %08lx\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->pc()));
1909                          if (addr_mode == MODE_U || addr_mode == MODE_UX)
# Line 1864 | Line 1994 | static void sigill_handler(int sig, sigi
1994   #endif
1995  
1996          // Fault in Mac ROM or RAM?
1997 <        bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
1997 >        bool mac_fault = (r->pc() >= ROMBase) && (r->pc() < (ROMBase + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
1998          if (mac_fault) {
1999  
2000                  // Get opcode and divide into fields
# Line 2032 | Line 2162 | bool SheepMem::Init(void)
2162  
2163          // Allocate SheepShaver globals
2164          proc = base;
2165 <        if (vm_mac_acquire(base, size) < 0)
2165 >        if (vm_mac_acquire_fixed(base, size) < 0)
2166                  return false;
2167  
2168          // Allocate page with all bits set to 0, right in the middle
# Line 2045 | Line 2175 | bool SheepMem::Init(void)
2175   #if EMULATED_PPC
2176          // Allocate alternate stack for PowerPC interrupt routine
2177          sig_stack = base + size;
2178 <        if (vm_mac_acquire(sig_stack, SIG_STACK_SIZE) < 0)
2178 >        if (vm_mac_acquire_fixed(sig_stack, SIG_STACK_SIZE) < 0)
2179                  return false;
2180   #endif
2181  
# Line 2116 | Line 2246 | void display_alert(int title_id, int pre
2246  
2247   void ErrorAlert(const char *text)
2248   {
2249 +        if (gui_connection) {
2250 +                if (rpc_method_invoke(gui_connection, RPC_METHOD_ERROR_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2251 +                        rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2252 +                        return;
2253 +        }
2254   #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2255          if (PrefsFindBool("nogui") || x_display == NULL) {
2256                  printf(GetString(STR_SHELL_ERROR_PREFIX), text);
# Line 2135 | Line 2270 | void ErrorAlert(const char *text)
2270  
2271   void WarningAlert(const char *text)
2272   {
2273 +        if (gui_connection) {
2274 +                if (rpc_method_invoke(gui_connection, RPC_METHOD_WARNING_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2275 +                        rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2276 +                        return;
2277 +        }
2278   #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2279          if (PrefsFindBool("nogui") || x_display == NULL) {
2280                  printf(GetString(STR_SHELL_WARNING_PREFIX), text);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines