uae41 fix sound,gfx and add hdd+68020 support

MCUME_teensy/teensyuae41/README

@@ -0,0 +1,653 @@
+This is version 0.6.9 of UAE, the Un*x Amiga Emulator.
+
+#include <drivel.h>
+
+Copyright 1995, 1996, 1997 Bernd Schmidt & contributors (see below). This
+program is free software. You may do whatever you want with it for personal
+use.
+Permission is granted to redistribute this program free of charge, provided it 
+is distributed in the full archive with unmodified contents and no profit 
+beyond the price of the media on which it is distributed is made. Exception to
+the last rule: It may be included on freeware/shareware collections on
+CD-ROM, as well as on magazine cover CD-ROMs.
+There are no warranties of any kind for this program. If you use this program,
+you do so at your own risk. The authors are not responsible for any damages 
+that might result from using this program.
+"Amiga" is a registered trademark of Amiga International. Other trademarks
+mentioned in this document and in other files in the UAE distribution are
+property of their owners.
+
+
+Overview
+========
+
+An emulator is a program which enables you to run software for a machine
+which has non-native hardware and a non-native operating system, on your
+computer.  UAE allows you to run most of the available Amiga software. It is a
+software emulation, meaning that no extra or special hardware is needed to do
+this. The hardware of an Amiga is emulated accurately, so that Amiga software
+is tricked into thinking it is running on the real thing, with your computer's
+display, keyboard, harddisk and mouse taking the parts of their emulated
+counterparts.
+
+UAE was developed for Unixoid systems. Meanwhile, it has been ported to the
+Mac, DOS, the BeBox, NextStep, the XFree86/OS2 environment and the Amigas (it
+can run itself by now). You should have received several other files along
+with this document with details on how to install and use the version for your
+operating system.
+
+This section is just what it says: an overview. Please read _all_ of this
+file, especially if you have problems. UAE has many, many features and
+equally many configuration options. If you don't know about them, it's likely
+that UAE doesn't work for you, or doesn't work as good as it could.
+
+Please read also the file "FAQ" which contains some Frequently Asked
+Questions (and even the answers!) System-specific documents like "README.UNIX"
+and "README.DOS" also exist, you should read the appropriate one, too.
+
+People have complained that the UAE documentation contains only "weird jargon".
+Sorry about this. Despite what MessySoft and Tomato tell you, computer
+programs aren't always easy to use. UAE does require some assistance from you,
+and therefore you should at least understand a bit about computers. After all,
+you are an Amiga fan, so you should know what a Workbench is, don't you think?
+
+
+Features
+========
+
+This version of UAE emulates:
+
+- An Amiga 500 Computer, with 68000 or 68020 CPU (68020 includes 68881 FPU)
+- OCS Graphics Chipset, plus big blits from the ECS Chipset
+- Up to 2MB Chip RAM
+- Up to 8MB Fast RAM
+- Up to 1MB Slow RAM, for extended compatability with problem software
+- 4 x 3.5" floppy disk drives (DF0:, DF1:, DF2: and DF3:)
+- Hard-disk emulation
+- Joystick support (with option of mapping joystick to numeric keypad)
+- Mouse support
+- Ability to run in various screen modes (for better display quality or
+  better speed)
+- Full sound support, consisting of 4 x 8bit channels (mixed into one, so
+  output is mono for now).
+- Beta parallel port support
+- some other things which don't work well enough to mention them here...
+
+  
+Requirements (IMPORTANT! READ THIS!)/Limitations
+================================================
+
+Not emulated:
+- Sprite to playfield collisions (sprite to sprite collisions work)
+- An MMU (part of 68030/040 CPUs except those that Commodore used). This means
+  you can't use virtual memory systems or real operating systems like Linux
+  or BSD.
+- The AGA chipset (A4000/A1200). This chipset has enhanced capabilites for
+  up to 256 colors in all resolutions.
+- Serial port emulation exists but doesn't work too well.
+
+Since the PC floppy controller can't read Amiga disks (yes, that's a fact), 
+floppy access has to be emulated differently: Floppies are emulated by means 
+of disk files that contain a raw image of the floppy disk you want to emulate.
+A disk file is an image of the raw data on an Amiga floppy disk, it contains
+901120 bytes (880K), which is the standard capacity of an Amiga disk.
+
+To actually run the program, you'll need to install the ROM image from your
+Amiga. You can't run UAE if you don't have this image. It is not included
+because it is copyrighted software. Don't ask me to send you one. I won't.
+If you don't have an Amiga and still want to use UAE, you'll have to buy an
+Amiga or at least the system software (ROM + Workbench) first.
+The Kickstart image can have a size of either 256K or 512K. It must be named
+"kick.rom" by default.
+
+Read the section "tools" below for information how to create ROM images and
+disk files.
+
+If you don't have a Kickstart file, you may still be able to boot some games
+and demos. The emulator includes some primitive bootstrap code that will try
+to read and execute the bootblock of the diskfile you are using, and if that
+bootblock only uses the one or two Kickstart functions that are supported by 
+the "replacement Kickstart", your program will boot. Don't expect too much, 
+though.
+
+You'll also need some other software to run - why else would you want to
+emulate an Amiga? There are several ways to make the software accessible to
+UAE, either with disk image files or with a harddisk emulation.You should make
+an image of your Amiga's Workbench disk and install it as "df0.adf" (adf =
+Amiga Disk File) when you use UAE for the first time. More about how to create
+these files in the chapter "Transferring software"
+
+
+Invoking UAE
+============
+
+First, read the system-specific documents for information how to set up UAE.
+You should have an executable program called "uae". You can simply execute it,
+but you can also optionally give it one of the following
+parameters:
+
+General options:
+ -h      : Give help on the options.
+ -A n    : Set emulator accuracy to n. The default is n = 2, which means the
+           emulator will try to be as accurate as possible. This no longer
+	   does much in this version, and I'll probably remove it.
+ -f n    : Sets the frame rate to 1/n. Only every nth screen will be drawn.
+ -a      : Add no expansion devices. This will disable fastmem and harddisk
+           emulation, but some extremely badly-written games may need this.
+	   (Kickstart 1.2 apparently needs it, too)
+ -l lang : Set the keyboard language. Currently, the following values can be 
+	   used for lang: "us" for U.S. keyboard (default), "se" for swedish, 
+	   "fr" for french, "it" for italian, "es" for spanish, or "de" for
+	   german keyboard.
+	   This setting only affects the X11 version.
+ -0 file : Try to use file as diskfile for drive 0 instead of df0.adf.
+           -1 file, -2 file and -3 also exist for the other drives.
+ -r file : Use file instead of kick.rom as Kickstart image.
+ -J xy   : Specify how to emulate joystick port 0 (x) and 1 (y). Both x and y
+           can be one of the following characters: 0 = joystick 0, 1 =
+           joystick 1, M for mouse, and a, b or c stand for various keyboard
+	   replacements (a is the numeric pad with '0' as fire button, b the
+	   cursor keys with right control as fire button and c is T/F/H/B with
+	   Alt as fire button.
+	   The default is "-J M0" (mouse and joystick as usual)
+ -o      : Allow UAE to overwrite ~/.uaerc with the selected options. This is
+           only used by the text-based user interface in the SVGAlib and DOS
+	   versions.
+ -G      : Disable the user interface (if present).
+ -n specs: Set blitter emulation. "specs" is a string of characters. If it
+           contains a "3", the blitter will use 32 bit operations where that
+	   seems profitable (note that this will cause bus errors on most
+	   RISC machines). If you specify "i", all blits will finish 
+	   immediately, which can be nice for speed. To enable both options,
+	   say "-n 3i"
+
+Emulating external devices (harddisk, CD-ROM, printer, serial port):
+ -M VOLUME:path
+ -m VOLUME:path
+           mount the unix file system at path as an Amiga filesystem with
+	   volume name "VOLUME:". For example, "-M sound:/usr/amiga/modules"
+	   If you use -M instead of -m, the volume will be read only. Use this
+	   for mounting CD-ROMs.
+	   See below.
+ -p cmd  : Enable printing. See below.
+ -I dev  : Use "dev" as serial device (e.g. /dev/ttyS1 on Linux). Doesn't
+           really work yet, at least not for me.
+
+Sound options:
+ -S n    : If your version of UAE supports sound, set the sound support level
+           with this option.
+	   n = 0: No proper sound emulation at all. May be incompatible 
+	          (unlikely). This is the default.
+	   n = 1: Emulate the sound hardware, but don't output sound. May be
+	          needed for compatibility, but can be much slower
+	   n = 2: Emulate the sound hardware and output sound. Recommended.
+	   n = 3: Emulate the sound hardware _exactly_. I don't think you'll
+	          hear a difference. SIDmon modules will be emulated 
+		  correctly, but painfully slow with this setting.
+		  Unfortunately, this may also be needed to get some programs
+		  to work (AIBB, for example).
+ -b n    : Use n bits for sound output (8 or 16)
+ -R n    : Use n Hz to output sound. Common values are 22050 Hz or 44100 Hz.
+ -B n:m  : Specify the sound buffer size. Use at least n bytes and no more
+           than m bytes. On most machines the minimum value is in fact
+           ignored. Use small values on fast machines.
+           The default buffer size is 8192 bytes. The larger this is, the 
+	   longer will sound output appear to be delayed, but the emulator
+	   will run faster if this is large.
+
+Memory options:
+ -s n    : Emulate n*256K slow memory at 0xC00000. Some demos/games need this.
+ -F n    : Emulate n megabytes of fast memory as an expansion board.
+ -c n    : Emulate n*512K chip memory. The default is 2MB chipram. Some very
+           broken programs need "-c 1" to work properly. The largest legal
+	   value is "-c 16", which means 8MB chip memory.
+ -4      : If the emulator is configured for 68020 emulation, this option
+           enables a 32 bit address space. Note that this is incompatible with
+	   some Kickstarts.
+
+Debugging options (not interesting for most users):
+ -D      : Don't start the emulator at once, use the built-in debugger.
+ -i      : Print illegal memory accesses
+
+Display options:
+ -H mode : Select a color mode to use.
+ -O specs: Select a display mode, see below how the specs parameter is
+           interpreted.
+Color modes: 0 (256 colors, default); 1 (32768 colors); 2 (65536 colors)
+             3 (256 colors, with dithering to improve color quality)
+	     4 (16 colors, dithered); 5 (16 million colors)
+
+About the "-O" display specs. These consist of the width and height of the
+mode, plus optional modifiers. One valid option to pass to UAE would be
+"-O 640:300:" which means use a display 640 pixels wide and 300 pixels high,
+with no modifiers (nothing after the second ":"). You may specify the
+following modifiers:
+ l: Tell UAE to omit drawing every second pixel horizontally (for "lores"
+    modes). Example: "-O 320:200:l"
+ x: Tell UAE to try to fit the image horizontally into the displayed
+    window. For example, if you have a mode that is 640 pixels wide, and the
+    displayed image is also 640 pixels wide, the picture may still be
+    partially invisible because it is displayed too wide to the left or to
+    the right. With the "x" modifier, UAE tries to prevent this.
+    You can also specify a capital "X", in that case, UAE tries to be
+    extremely clever when doing this.
+ y: The same thing in green, for fitting the image vertically into the
+    window. (Y also exists)
+ d: Draw every line twice. This allows interlace mode to be emulated nicely,
+    but of course you also need a display that is twice as high
+ c: Correct the aspect. This will omit certain lines of the display to make
+    it fit better into the screen.
+
+Whew. You'll probably have to experiment a little to get a feeling for it.
+To make things easier, here are mode specs that are equivalent to the old
+"-d" and "-C" options, which are obsolete now.
+-d 0: Lores, 320x200, X centered: "-O 320:200:lx"
+-d 1: Lores, 320x240, X centered: "-O 320:240:lx"
+-d 2: Lores, 320x400, X centered: "-O 320:400:lx"
+-d 3: Hires, 640x300, X centered: "-O 640:300:x"
+-d 4: 800x300, centering not needed: "-O 800:300:"
+-d 3 -C: "-O 640:600:xd"
+-d 4 -C: "-O 800:600:d"
+(This table is accurate for the X11 version of UAE 0.6.6 and below. Other
+versions, e.g. SVGAlib and DOS behave differently, which was one of the
+reasons to get rid of the old method of specifying display modes.)
+
+UAE may choose to ignore and/or refuse some combinations of these two
+parameters. Some of these modes may also fail to work on your system.
+
+You can also put these options into a configuration file in your home
+directory. Simply create ~/.uaerc and put some of these options in it. On
+non-Unix systems, the file is called uae.rc and should be located in the
+current directory.
+
+
+Choosing color and screen modes
+===============================
+
+As described in the previous paragraph, UAE can run in many different 
+resolutions and color modes. However, few of the color mode options are
+available if you use the X11 version of UAE, since the X server determines
+how many colors are available. If you are running a 256 color X server, you
+can use "-H3" to tell UAE to dither the colors for better results.
+
+You will have to experiment which mode gives the best results for you at a
+satisfying speed. Note that the dithering process consumes time, so even if
+256 colors with dithering look better than 256 colors without, remember that
+UAE will be slower in that mode.
+
+The recommended resolution is 800x600. In the lower resolution modes, some
+overscan pictures the Amiga tries to display may not fit entirely on the
+screen, others may be off-center and some graphical effects may look weird.
+For best results, use 800x600 with at least 32768 colors.
+
+
+Harddisk emulation
+==================
+
+Using diskfiles is awkward. There are two ways how you can use larger amounts 
+of data with UAE. UAE can emulate more than one harddisk at one time, the
+volumes will be named UAE0:, UAE1:, etc. UAE will boot from UAE0: if no
+diskfile is found for floppy drive 0.
+
+a) Harddisk files (not recommended)
+
+You can create a (unformatted) harddisk file with
+
+  dd if=/dev/zero of=hardfile bs=512 count=16384
+
+That will create an 8MB file. Other sizes ought to work, too, as long as they
+are powers of two.
+
+The harddisk file is accessed by a resident ROM module that is built into the
+emulator, called "hardfile.device". If it is present, this is always the first
+harddisk device the emulator finds and will be named UAE0:
+
+If you are using Kickstart 1.3 or earlier, this can't currently be mounted at 
+boot time, and therefore you can't boot from it either. You will have to boot
+either from a floppy disk image or from a filesystem (see below), and mount
+the hardfile.device later. To do this, add the following to "DEVS:mountlist":
+
+UAE0:	   Device = hardfile.device
+	   Unit   = 0
+	   Flags  = 0
+	   Surfaces  = 1
+	   BlocksPerTrack = 32
+	   Reserved = 1
+	   Interleave = 0
+	   LowCyl = 0  ;  HighCyl = 511
+	   Buffers = 5
+	   DosType = 0x444F5300
+	   BufMemType = 1
+#
+
+Then, type "mount UAE0:" (or put that command in your startup-sequence), and
+you should be able to access it. Don't forget to format it with the AmigaDOS
+format command:
+
+  format drive uae0: name Mister_Willwink
+
+b) Accessing native filesystems from the emulator
+
+This has some major advantages:
+ - It has no problems with Kickstart 1.3
+ - It is more convenient.
+ - It is much faster. In fact, it can be dramatically faster even than a real
+   Amiga when reading directories.
+
+If you specify the -M or -m command line arguments, you your native filesystem 
+from the emulator. If you start UAE with
+
+  uae -m sound:/usr/amiga/modules
+
+you can access all the files in /usr/amiga/modules by reading from the
+AmigaDOS volume "SOUND:".
+(DOS users: try "uae -m dh0:C:\" to mount your drive C:\ as DH0:)
+
+You can mount up to 20 devices by giving this option multiple times. You can
+also use this to mount Amiga CD-ROMs.
+
+
+Tools / Transferring files
+==========================
+
+As you should know by now, you need to transfer files between your Amiga and
+the machine you run UAE on. There are several ways how to do this.
+
+- Using a null modem cable, and a terminal package running on each machine,
+  you can transfer the file(s) via Zmodem upload/download. 68000 equipped
+  Amigas can normally attain around 3000cps through the null modem cable,
+  using the standard Commodore serial.device.  However, by using the device
+  replacement BaudBandit.device, anything up to 5500cps can be attained.
+  BaudBandit can be obtained from Aminet.  A second alternative is to use
+  the BASIC program adfi.bas (included with UAE) to transfer a file from the
+  Amiga to the PC via the null modem cable.
+  
+- If you're using CrossDOS on your Amiga, you can compress the disk or
+  kickstart image using LhA or similar PC compatible archiver and copy it to
+  a 720KB floppy disk.  You can now take the disk over to the PC, copy the
+  compressed file to the UAE directory and uncompress it.
+  If you don't have CrossDOS on the Amiga, there is a similar freeware tool
+  called Msh, which can be found on Aminet or on Fish disk 382 or 327.
+
+In either case, you ought to read the documentation for the programs that
+you use for the transfer. These programs can't be explained here.
+
+In the "amiga" subdirectory you'll find two small Amiga programs that will
+help you to generate the necessary image files. These are called transrom 
+and transdisk. Copy them to your Amiga and make them executable (by typing
+"protect transrom rwed" and "protect transdisk rwed" in the Amiga shell
+window).
+transrom will dump the contents of your Kickstart ROM, and transdisk will 
+dump an image of a floppy in one of the drives. Both programs write to the
+standard output (read: the screen), so you'll want to redirect that. Do
+
+   transrom >ram:kick.rom
+   
+to create a file called "kick.rom" in the RAM disk, and
+
+   transdisk >ram:df0.adf
+   
+to create a file called "df0.adf" in the RAM disk. These files are pretty
+big, 262144 or 524288 bytes for the ROM image and 901120 bytes for a disk 
+image.
+transdisk understands the following arguments:
+
+    -d device unit: Use this device instead of DF0:
+    -s n:           Begin transfer at track n (default: 0)
+    -e n:           End transfer at track n (default: 79)
+    -w file:        don't read from the floppy, instead write the contents
+                    of "file" to the floppy
+    -h:             Treat the disk as high-density disk. HD images aren't
+                    supported by UAE yet, though. Note that the resulting
+		    file will be twice as big.
+
+So, to transfer the disk in drive DF1:, you'd give the command:
+
+  transdisk >ram:df1.adf -d trackdisk 1
+
+If you don't have much RAM and can't fit all of a disk image in the RAM disk,
+you can split up the transfer into multiple parts with the "-s" and "-e"
+parameters. To transfer the disk in four parts, you'd use the following 
+commands:
+  
+  transdisk >ram:df0_1.adf -s 0 -e 19
+  transdisk >ram:df0_2.adf -s 20 -e 39
+  transdisk >ram:df0_3.adf -s 40 -e 59
+  transdisk >ram:df0_4.adf -s 60 -e 79
+
+Of course, you should save each of the four files to another place before
+transferring the next one with transdisk to make space in your RAM disk. 
+If you have all the files on your PC, you can do the following under Unix:
+  cat df0_1.adf df0_2.adf df0_3.adf df0_4.adf >df0.adf
+or, under DOS:
+  COPY /B df0_1.adf+df0_2.adf+df0_3.adf+df0_4.adf df0.adf
+I've been told there are the following tools for the Mac to join binaries:
+"ChunkJoiner 2.1.2" found under Info-Mac's <disk> directory or 
+"JoinFiles 1.0.1" under Info-Mac's <text>.
+
+The current transdisk can only read the standard AmigaDOS format. This means
+that most games that rely on some form of copy-protection cannot be
+transferred (more about disk formats in the file "FAQ")
+
+****************************************************************************
+If you transfer commercial software, you must not distribute the resulting
+image files, since that would be a violation of copyright law. The Kickstart
+ROM has to be considered commercial software. You may only use the Kickstart
+from your own Amiga, and you may not distribute Kickstart ROM files.
+Please read the license that came with your software for details.
+****************************************************************************
+
+
+Retrieving files from a disk image
+==================================
+
+If you have a disk image file, and you want to retrieve the files from it, you
+can use the "readdisk" tool. It is automatically built by "make". If you have
+a disk image of a disk called "Workbench1.3D" as df0.adf, and you do
+   readdisk df0.adf
+the whole directory structure of the disk image will be stored in a newly
+created subdirectory called "Workbench1.3D". You can optionally give a second
+parameter to specify a directory where to create the output other than the
+current directory.
+readdisk only understands about the OFS right now. FFS disks will cheerfully
+be regarded as being unreadable. Use the unixfs.device from within the
+emulator if you want to transfer files from FFS disks.
+
+
+The UAE_CONTROL program
+=======================
+
+In the "amiga" subdirectory, you will find two programs, uae_control and
+uaectrl that provide the same functionality as the X11 GUI. uaectrl is
+shell-based and works with any Kickstart, while uae_control needs the
+gadtools.library and a recent version of reqtools.library, so it only works
+with Kick 2.0 and upwards. Copy these two programs to the directory that you
+use for harddisk emulation. They should be self-explanatory.
+
+
+Quick overview of the debugger commands
+=======================================
+
+Some (window-system based) ports of UAE have a built-in debugger. You can
+press ^C at any time to enter this debugger.
+Each debugger command consists of a single letter and occasionally some
+parameters.
+
+g:                    Start execution at the current address. 
+c:                    Dump state of the CIA and custom chips.
+r:                    Dump state of the CPU
+m <address> <lines>:  Memory dump starting at <address>
+d <address> <lines>:  Disassembly starting at <address>
+t:                    Step one instruction
+z:                    Step through one instruction - useful for JSR, DBRA etc.
+f <address>:          Step forward until PC == <address>
+q:                    Quit the emulator. You don't want to use this command.
+
+
+Sound
+=====
+
+If your version of UAE supports sound, you can pass parameters like frequency
+or number of bits to use on the commandline; if you don't specify any, sane
+defaults will be used. If graphics output is enabled while sound is output,
+the emulator will be much too slow on most systems. The sound will not be
+continuous. Therefore, a hack to turn off screen updates is provided: Press
+ScrollLock to disable graphics, press it again to enable them.
+
+The quality of the emulation depends on the setting of the "-S" commandline
+option. With "-S 3", all of the sound hardware is emulated; and some programs
+(e.g. AIBB) won't run with other settings. "-S 2" should sound just as good as
+"-S 3" and will be much faster for some programs. "-S 1" tries to emulate most
+of the sound hardware, but doesn't actually output sound. "-S 0" completely
+turns off sound.
+
+
+Pointers
+========
+
+There are a few sites in the Internet that contain helpful information about
+UAE.
+
+The new "official" UAE page is located at
+
+http://www.schokola.de/~stepan/uae
+
+thanks to Stefan Reinauer who is now maintaining it.
+
+There, you will find links to other UAE pages. One which is especially useful
+is the "UAE Discussion Board" set up by Gustavo Goedert, the address is
+
+http://www.netrunner.com.br/dosuae/uaeboard/index.html
+
+Not quite as good as a newsgroup due to braindamaged reader software
+(Ratscope), but still a blessing.
+
+I post announcements of new versions of UAE to the newsgroup 
+comp.emulators.misc. From time to time, I also upload new versions to the ftp
+server sunsite.unc.edu. You will find them either in pub/Linux/Incoming or in
+pub/Linux/system/Emulators. There are many sunsite mirrors throughout the
+world, you should be able to find one near you.
+
+
+Thanks & Acknowledgements
+=========================
+
+Thanks to all who have written me so far with bugreports and success/failure
+reports when trying to run the emulator on various hardware with different
+Kickstart versions. A list of everyone who has contributed to the source code
+can be found in the CREDITS file (this was getting too big to keep it here).
+
+Special thanks to:
+  - Jay Miner, Dale Luck, R.J. Mical and all the others who built the Amiga.
+  - Felix Bardos, whose HRM I "borrowed".
+  - Hetz Ben Hamo mailed Peter Kittel from Commodore asking for permission to
+    give Kick 1.3 away. Unfortunately, the response was negative :-(
+  - Bruno Coste, Ed Hanway, Alessandro Soldo and Marko Nippula provided 
+    documentation
+  - Fabio Ciucci gets the "Best bug reports" award for his help with the
+    blitter line emulation and other problem areas.
+  - Michael C. Battilana of Cloanto Software, for being so kind to send me two
+    CD-ROMs with lots of Amiga software.
+  - Julian Eggebrecht of Factor 5, for providing several F5 games.
+
+
+Authors/Maintainers
+===================
+
+My address is:
+
+crux@pool.informatik.rwth-aachen.de
+
+or, via snailmail
+
+Bernd Schmidt
+Schlossweiherstrasse 14
+52072 Aachen
+Germany
+
+Email is more likely to be answered, and will definitely be answered much
+faster. Please avoid phonecalls if you can.
+I won't distribute software, neither PD or commercial. Don't send me floppy
+disks without at least asking first, you will not get them back.
+
+The following people have ported UAE to different platforms; you should
+direct system-specific questions to them:
+
+DOS port:
+  Gustavo Goedert <ggoedert@netrunner.com.br>
+  Available: http://www.netrunner.com.br/dosuae
+  Sourecode: available on the above Web page, most of it included in the
+             main source (with some delay)
+
+Mac port:
+  Ernesto Corvi <macsupport@overnet.com.ar>
+  Available: info-mac ("every Mac user knows where that is"). A link to the 
+  archive containing both PPC and 68k binaries is on my Web page. (info-mac
+  is mirrored by sunsite.informatik.rwth-aachen.de)
+  Sourcecode: extra package available. Bits and pieces in the main source,
+              but nothing you could get to compile. Badly out of date.
+
+BeBox port:
+  Christian Bauer <bauec002@goofy.zdv.uni-mainz.de>
+  Available: The main UAE web page (use the Unix sources)
+  Sourcecode: Included in the main source (this version won't compile)
+
+NextStep port:
+  Ian Stephenson <ians@cam-ani.co.uk>
+  Available: The main UAE web page (use the Unix sources)
+  Sourcecode: Included in the main source (this version won't compile)
+
+Amiga port:
+  Originally: Olaf 'Olsen' Barthel <olsen@sourcery.han.de>
+  Currently: Samuel Devulder <devulder@info.unicaen.fr>
+  Available: Not quite sure yet. Paul Liss' Web page has binaries.
+  Sourcecode: Included in the main source. Should compile OK.
+
+XFree86/OS2 port:
+  Krister Bergman <bellman@kuai.se>
+  Available: http://www.kuai.se/~bellman/html/xfreeapps.html
+  Sourcecode: nothing special, apparently the Unix stuff compiles cleanly (?)
+
+Win32 port:
+  Mathias Ortmann <ortmann@informatik.tu-muenchen.de>
+  Available: http://www.informatik.tu-muenchen.de/~ortmann
+  Sourcecode: we're working on it
+
+Acorn RISC PC port:
+  Peter Teichmann <sol@Space.WH1.TU-Dresden.De>
+  Available: http://www.wh1.tu-dresden.de/~sol/acorn.shtml
+             http://www.wh1.tu-dresden.de/~sol/acorne.shtml
+  Sourcecode: Some of it is included in the main source, but since Acorn's OS
+              apparently doesn't have decent file handling, you can't even
+	      use the same source layout. Also needs lots of additional files.
+	      
+Since I generally don't have the possibility to test or improve these ports,
+it is a good idea to contact their respective authors if you have questions.
+
+
+Before you email...
+===================
+
+Before you contact me with a problem that you have, make sure you have read
+_all_ of the above. Please read also the file "FAQ", which contains a lot of
+helpful information, and the README file for your specific system. 
+
+I can't answer _every_ question. If you have trouble understanding this
+README, either because you don't speak English very well or because you have
+no clue at all about computers, please try to find some friend of yours who 
+does understand this file and who can translate/explain it for you. I simply
+can't explain (for example) how to use terminal programs or CrossDOS because
+I don't use either, and it would be much too time-consuming anyway. This file
+and the file FAQ contains about every piece of information I can give you. I 
+try to help people who have questions, but sometimes it takes too much time.
+
+Please don't ask for Kickstart ROM files or other copyrighted software. Don't
+_send_ me stuff like this either. If you want to send me something else which
+is big (>= 50K), ask me before or put it somewhere in Webspace.
+If I get 3MB of screen shots or a core dump ("it doesn't work, it generates
+this file"), I'm very likely to get extremely angry, I might complain to your
+sysadmin, and you might lose your account. Think twice.
+
+Oh, and another thing: If I promise to do things (like implement new
+features), and forget about them, pester me. That happens occasionally, it's
+a known bug in my brain. I'll have it replaced.

MCUME_teensy/teensyuae41/_68000/cpu6.c

@@ -0,0 +1,456 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_6000)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6001)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_60ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6100)(uae_u32 opcode) /* BSR */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_6101)(uae_u32 opcode) /* BSR */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_61ff)(uae_u32 opcode) /* BSR */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_6200)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6201)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_62ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6300)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6301)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_63ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6400)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6401)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_64ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6500)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6501)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_65ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6600)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6601)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_66ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6700)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6701)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_67ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6800)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6801)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_68ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6900)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6901)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_69ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6aff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6bff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6cff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6dff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6eff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6fff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+#endif

MCUME_teensy/teensyuae41/_68000/cpu7.c

@@ -0,0 +1,21 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_7000)(uae_u32 opcode) /* MOVE */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+	uae_u32 dstreg = (opcode >> 9) & 7;
+{{	uae_u32 src = srcreg;
+{	VFLG = CFLG = 0;
+	ZFLG = ((uae_s32)(src)) == 0;
+	NFLG = ((uae_s32)(src)) < 0;
+	m68k_dreg(regs, dstreg) = (src);
+}}}}
+#endif

MCUME_teensy/teensyuae41/_68000/cpuA.c

@@ -0,0 +1,11 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/_68000/cpuF.c

@@ -0,0 +1,11 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/_68000/newcpu.c

@@ -0,0 +1,661 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * MC68000 emulation
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+#include "shared.h"
+
+#include "gensound.h"
+#include "sounddep/sound.h"
+#include "events.h"
+#include "uae.h"
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "autoconf.h"
+#ifdef HAS_ERSATZ  
+#include "ersatz.h"
+#endif
+//#include "debug.h"
+#include "compiler.h"
+#include "arduinoproto.h"
+
+int areg_byteinc[] = { 1,1,1,1,1,1,1,2 };
+int imm8_table[] = { 8,1,2,3,4,5,6,7 };
+
+int movem_index1[256];
+int movem_index2[256];
+int movem_next[256];
+
+int fpp_movem_index1[256];
+int fpp_movem_index2[256];
+int fpp_movem_next[256];
+
+
+#ifdef GENTABLE
+cpuop_func *cpufunctbl[65536];
+#else
+#include "cputbl.h"
+#include "cpugentbl.h"
+#endif
+
+
+#ifndef NO_PREFETCH_BUFFER
+/* Oh boy does this suck... */
+void fill_prefetch(void)
+{
+    /* We can't use clever code on all machines. */
+    memcpy (regs.prefetch, regs.pc_p, sizeof regs.prefetch);
+    regs.prefetch_pos = regs.prefetch;
+}
+
+uae_u32 nextibyte(void)
+{
+    uae_u32 v = do_get_mem_byte (regs.prefetch_pos + 1);
+    *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+    regs.pc_p += 2;
+    regs.prefetch_pos += 2;
+    if (regs.prefetch_pos == regs.prefetch + 16)
+	regs.prefetch_pos = regs.prefetch;
+    return v;
+}
+
+uae_u32 nextiword(void)
+{
+    uae_u32 v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
+    *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+    regs.pc_p += 2;
+    regs.prefetch_pos += 2;
+    if (regs.prefetch_pos == regs.prefetch + 16)
+	regs.prefetch_pos = regs.prefetch;
+    return v;
+}
+
+uae_u32 nextilong(void)
+{
+    uae_u32 v;
+    if (regs.prefetch_pos == regs.prefetch + 14) {
+	v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
+	v <<= 16;
+	v |= do_get_mem_word ((uae_u16 *)regs.prefetch);
+	*(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+	*(uae_u16 *)regs.prefetch = *(uae_u16 *)(regs.pc_p + 18);
+	regs.pc_p += 4;
+	regs.prefetch_pos = regs.prefetch + 2;
+    } else {
+	v = do_get_mem_long ((uae_u32 *)regs.prefetch_pos);
+	*(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+	*(uae_u16 *)(regs.prefetch_pos+2) = *(uae_u16 *)(regs.pc_p + 18);	
+	regs.pc_p += 4;
+	regs.prefetch_pos += 4;
+	if (regs.prefetch_pos == regs.prefetch + 16)
+	    regs.prefetch_pos = regs.prefetch;
+    }
+    return v;
+}
+#endif
+
+uaecptr m68k_currentpc(void)
+{
+    return m68k_getpc();
+}
+
+
+
+
+
+
+#ifdef GENTABLE
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int search(void * code)
+{
+	int k;
+	for (k = 0; op_smalltbl[k].handler != NULL; k++) {
+		if ((void*)op_smalltbl[k].handler == code)
+			return op_smalltbl[k].opcode;
+	}	
+	return -1;
+		
+}
+#endif
+
+
+void init_m68k (void)
+{
+    int i,j;
+    
+    for (i = 0 ; i < 256 ; i++) {
+		for (j = 0 ; j < 8 ; j++) {
+			if (i & (1 << j)) break;
+		}
+		movem_index1[i] = j;
+		movem_index2[i] = 7-j;
+		movem_next[i] = i & (~(1 << j));
+    }
+
+    for (i = 0 ; i < 256 ; i++) {
+		for (j = 7 ; j >= 0 ; j--) {
+			if (i & (1 << j)) break;
+		}
+		fpp_movem_index1[i] = j;
+		fpp_movem_index2[i] = 7-j;
+		fpp_movem_next[i] = i & (~(1 << j));
+    }
+
+#ifdef GENTABLE
+    long int opcode;
+    write_log("Building CPU table...\n");
+    read_table68k ();
+    do_merges ();
+    for (opcode = 0; opcode < 65536; opcode++)
+	cpufunctbl[opcode] = op_illg;
+    for (i = 0; op_smalltbl[i].handler != NULL; i++) {
+	if (!op_smalltbl[i].specific)
+	    cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
+    }
+    for (opcode = 0; opcode < 65536; opcode++) {
+	cpuop_func *f;
+	
+	if (table68k[opcode].mnemo == i_ILLG)
+	    continue;
+	
+	if (table68k[opcode].handler != -1) {
+	    f = cpufunctbl[table68k[opcode].handler];
+	    if (f == op_illg)
+		abort();
+	    cpufunctbl[opcode] = f;
+	}
+    }	
+    for (i = 0; op_smalltbl[i].handler != NULL; i++) {
+	if (op_smalltbl[i].specific)
+	    cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
+    }
+
+
+	FILE *fp_wr = stdout;
+	if ((fp_wr = fopen ("cpugentbl.h", "wb")) == NULL)
+	{
+		exit;
+	}
+
+	int cnt=0;
+	int size = 65536;
+	fprintf(fp_wr, "const cpuop_func * cpufunctbl[%d] = {\n", size);
+
+	cnt = 0;
+	for (int i = 0; i < size; i++) {
+	cnt++;
+	int code = search((void *)cpufunctbl[i]);
+	if (cnt == 16) {
+	  if (code == -1) fprintf(fp_wr, "op_illg,\n");
+	  else if (code < 0x10) fprintf(fp_wr, "op_%01x,\n",code);
+	  else if (code < 0x100) fprintf(fp_wr, "op_%02x,\n",code);
+	  else if (code < 0x1000) fprintf(fp_wr, "op_%03x,\n",code);
+	  else fprintf(fp_wr, "op_%04X,\n",code);
+	}  
+	else {
+	  if (code == -1) fprintf(fp_wr, "op_illg,\n");
+	  else if (code < 0x10) fprintf(fp_wr, "op_%01x,",code);
+	  else if (code < 0x100) fprintf(fp_wr, "op_%02x,",code);
+	  else if (code < 0x1000) fprintf(fp_wr, "op_%03x,",code);
+	  else fprintf(fp_wr, "op_%04x,",code);
+	}  
+	cnt &= 15;
+	}  
+	fprintf(fp_wr, "};\n");
+	fclose (fp_wr);
+#endif
+}
+
+
+struct flag_struct regflags;
+struct regstruct regs, lastint_regs;
+int lastint_no;
+int broken_in;
+
+
+
+void MakeSR(void)
+{
+    regs.sr = ((regs.t1 << 15) | (regs.t0 << 14)
+	       | (regs.s << 13) | (regs.m << 12) | (regs.intmask << 8)
+	       | (XFLG << 4) | (NFLG << 3) | (ZFLG << 2) | (VFLG << 1) 
+	       |  CFLG);
+}
+
+void MakeFromSR(void)
+{
+    int oldm = regs.m;
+    int olds = regs.s;
+
+    regs.t1 = (regs.sr >> 15) & 1;
+    regs.t0 = (regs.sr >> 14) & 1;
+    regs.s = (regs.sr >> 13) & 1;
+    regs.m = (regs.sr >> 12) & 1;
+    regs.intmask = (regs.sr >> 8) & 7;
+    XFLG = (regs.sr >> 4) & 1;
+    NFLG = (regs.sr >> 3) & 1;
+    ZFLG = (regs.sr >> 2) & 1;
+    VFLG = (regs.sr >> 1) & 1;
+    CFLG = regs.sr & 1;
+    if (CPU_LEVEL >= 2) {
+	if (olds != regs.s) {
+ 	    if (olds) {
+ 	        if (oldm)
+ 		    regs.msp = m68k_areg(regs, 7);
+ 	        else
+ 		    regs.isp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.usp;
+ 	    } else {
+ 	        regs.usp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
+ 	    }
+	} else if (olds && oldm != regs.m) {
+	    if (oldm) {
+		regs.msp = m68k_areg(regs, 7);
+		m68k_areg(regs, 7) = regs.isp;
+	    } else {
+		regs.isp = m68k_areg(regs, 7);
+		m68k_areg(regs, 7) = regs.msp;
+	    }
+	}
+    } else {
+	if (olds != regs.s) {
+ 	    if (olds) {
+ 		regs.isp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.usp;
+ 	    } else {
+ 	        regs.usp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.isp;
+ 	    }
+ 	}
+    }
+    
+    regs.spcflags |= SPCFLAG_INT;
+    if (regs.t1 || regs.t0)
+    	regs.spcflags |= SPCFLAG_TRACE;
+    else
+    	regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
+}
+/* Opcode of faulting instruction */
+uae_u16 last_op_for_exception_3;
+/* PC at fault time */
+uaecptr last_addr_for_exception_3;
+/* Address that generated the exception */
+uaecptr last_fault_for_exception_3;
+
+void Exception(int nr, uaecptr oldpc)
+{
+    compiler_flush_jsr_stack();
+    MakeSR();
+    if (!regs.s) {
+	regs.usp = m68k_areg(regs, 7);
+	if (CPU_LEVEL >= 2)
+ 	    m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
+ 	else
+ 	    m68k_areg(regs, 7) = regs.isp;
+	regs.s = 1;
+    }
+    if (CPU_LEVEL > 0) {
+	if (nr == 2 || nr == 3) {
+	    int i;
+	    /* @@@ this is probably wrong (?) */
+	    for (i = 0 ; i < 12 ; i++) {
+		m68k_areg(regs, 7) -= 2;
+		put_word (m68k_areg(regs, 7), 0);
+	    }
+	    m68k_areg(regs, 7) -= 2;
+	    put_word (m68k_areg(regs, 7), 0xa000 + nr * 4);
+	} else if (nr ==5 || nr == 6 || nr == 7 || nr == 9) {
+ 	    m68k_areg(regs, 7) -= 4;
+ 	    put_long (m68k_areg(regs, 7), oldpc);
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), 0x2000 + nr * 4);
+ 	} else if (regs.m && nr >= 24 && nr < 32) {
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), nr * 4);
+ 	    m68k_areg(regs, 7) -= 4;
+ 	    put_long (m68k_areg(regs, 7), m68k_getpc ());
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), regs.sr);
+ 	    regs.sr |= (1 << 13);
+ 	    regs.msp = m68k_areg(regs, 7);
+ 	    m68k_areg(regs, 7) = regs.isp;
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), 0x1000 + nr * 4);
+ 	} else {
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), nr * 4);
+ 	}
+    } else {
+	if (nr == 2 || nr == 3) {
+	    m68k_areg(regs, 7) -= 12;
+	    /* ??????? */
+	    if (nr == 3) {
+		put_long (m68k_areg(regs, 7), last_fault_for_exception_3);
+		put_word (m68k_areg(regs, 7)+4, last_op_for_exception_3);
+		put_long (m68k_areg(regs, 7)+8, last_addr_for_exception_3);
+	    }
+	    write_log ("Exception!\n");
+	    goto kludge_me_do;
+	}
+    }
+    m68k_areg(regs, 7) -= 4;
+    put_long (m68k_areg(regs, 7), m68k_getpc ());
+kludge_me_do:
+    m68k_areg(regs, 7) -= 2;
+    put_word (m68k_areg(regs, 7), regs.sr);
+    m68k_setpc(get_long(regs.vbr + 4*nr));
+    regs.t1 = regs.t0 = regs.m = 0;
+    regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
+}
+
+static void Interrupt(int nr)
+{
+    //assert(nr < 8 && nr >= 0);
+    lastint_regs = regs;
+    lastint_no = nr;
+    Exception(nr+24, 0);
+    
+    regs.intmask = nr;
+    regs.spcflags |= SPCFLAG_INT;
+}
+
+
+
+static __inline__ void
+mul_unsigned(uae_u32 src1, uae_u32 src2, uae_u32 *dst_hi, uae_u32 *dst_lo)
+{
+        uae_u32 r0 = (src1 & 0xffff) * (src2 & 0xffff);
+        uae_u32 r1 = ((src1 >> 16) & 0xffff) * (src2 & 0xffff);
+        uae_u32 r2 = (src1 & 0xffff) * ((src2 >> 16) & 0xffff);
+        uae_u32 r3 = ((src1 >> 16) & 0xffff) * ((src2 >> 16) & 0xffff);
+	uae_u32 lo;
+
+        lo = r0 + ((r1 << 16) & 0xffff0000ul);
+        if (lo < r0) r3++;
+        r0 = lo;
+        lo = r0 + ((r2 << 16) & 0xffff0000ul);
+        if (lo < r0) r3++;
+        r3 += ((r1 >> 16) & 0xffff) + ((r2 >> 16) & 0xffff);
+	*dst_lo = lo;
+	*dst_hi = r3;
+}
+
+void m68k_mull (uae_u32 opcode, uae_u32 src, uae_u16 extra)
+{
+
+    if (extra & 0x800) {
+	/* signed variant */
+	uae_s32 src1,src2;
+	uae_u32 dst_lo,dst_hi;
+	uae_u32 sign;
+
+	src1 = (uae_s32)src;
+	src2 = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
+	sign = (src1 ^ src2);
+	if (src1 < 0) src1 = -src1;
+	if (src2 < 0) src2 = -src2;
+	mul_unsigned((uae_u32)src1,(uae_u32)src2,&dst_hi,&dst_lo);
+	if (sign & 0x80000000) {
+		dst_hi = ~dst_hi;
+		dst_lo = -dst_lo;
+		if (dst_lo == 0) dst_hi++;
+	}
+	VFLG = CFLG = 0;
+	ZFLG = dst_hi == 0 && dst_lo == 0;
+	NFLG = ((uae_s32)dst_hi) < 0;
+	if (extra & 0x400)
+	    m68k_dreg(regs, extra & 7) = dst_hi;
+	else if ((dst_hi != 0 || (dst_lo & 0x80000000) != 0)
+		 && ((dst_hi & 0xffffffff) != 0xffffffff
+		     || (dst_lo & 0x80000000) != 0x80000000)) 
+	{
+	    VFLG = 1;
+	}
+	m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
+    } else {
+	/* unsigned */
+	uae_u32 dst_lo,dst_hi;
+
+	mul_unsigned(src,(uae_u32)m68k_dreg(regs, (extra >> 12) & 7),&dst_hi,&dst_lo);
+	
+	VFLG = CFLG = 0;
+	ZFLG = dst_hi == 0 && dst_lo == 0;
+	NFLG = ((uae_s32)dst_hi) < 0;
+	if (extra & 0x400)
+	    m68k_dreg(regs, extra & 7) = dst_hi;
+	else if (dst_hi != 0) {
+	    VFLG = 1;
+	}
+	m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
+    }
+
+}
+
+void m68k_reset(void)
+{
+    m68k_areg(regs, 7) = get_long(0x00f80000);
+    m68k_setpc(get_long(0x00f80004));
+    regs.kick_mask = 0xF80000;
+    regs.s = 1;
+    regs.m = 0;
+    regs.stopped = 0;
+    regs.t1 = 0;
+    regs.t0 = 0;
+    ZFLG = CFLG = NFLG = VFLG = 0;
+    regs.spcflags = 0;
+    regs.intmask = 7;
+    regs.vbr = regs.sfc = regs.dfc = 0;
+    regs.fpcr = regs.fpsr = regs.fpiar = 0;
+    customreset();
+}
+
+void REGPARAM2 op_illg(uae_u32 opcode)
+{
+    compiler_flush_jsr_stack();
+    if (opcode == 0x4E7B && get_long(0x10) == 0 
+	&& (m68k_getpc() & 0xF80000) == 0xF80000) 
+    {
+	write_log("Your Kickstart requires a 68020 CPU. Giving up.\n");
+	broken_in = 1; 
+	regs.spcflags |= SPCFLAG_BRK;
+	quit_program = 1;
+    }
+    if (opcode == 0xFF0D) {
+	if ((m68k_getpc() & 0xF80000) == 0xF80000) {
+	    /* This is from the dummy Kickstart replacement */
+#ifdef HAS_ERSATZ  	    
+	    ersatz_perform (nextiword ());
+#endif	    
+	    return;
+	} else if ((m68k_getpc() & 0xF80000) == 0xF00000) {
+	    /* User-mode STOP replacement */
+	    m68k_setstopped(1);
+	    return;
+	}
+    }
+#ifdef USE_POINTER
+    regs.pc_p -= 2;
+#else
+    regs.pc -= 2;
+#endif
+    fill_prefetch();
+    if ((opcode & 0xF000) == 0xF000) {
+	Exception(0xB,0);
+	return;
+    }
+    if ((opcode & 0xF000) == 0xA000) {
+    	Exception(0xA,0);
+	return;
+    }
+    sprintf (warning_buffer, "Illegal instruction: %04x at %08lx\n", opcode, m68k_getpc());
+    write_log (warning_buffer);
+    Exception(4,0);
+}
+
+void mmu_op(uae_u32 opcode, uae_u16 extra)
+{
+    if ((extra & 0xB000) == 0) { /* PMOVE instruction */
+
+    } else if ((extra & 0xF000) == 0x2000) { /* PLOAD instruction */
+    } else if ((extra & 0xF000) == 0x8000) { /* PTEST instruction */
+    } else
+	op_illg(opcode);
+}
+
+static int n_insns=0, n_spcinsns=0;
+
+static uaecptr last_trace_ad = 0;
+
+static __inline__ void do_trace(void)
+{
+    if (regs.spcflags & SPCFLAG_TRACE) {		/* 6 */
+	if (regs.t0) {
+	    uae_u16 opcode;
+	    /* should also include TRAP, CHK, SR modification FPcc */
+	    /* probably never used so why bother */
+	    /* We can afford this to be inefficient... */
+	    m68k_setpc(m68k_getpc());
+	    opcode = get_word(regs.pc);
+	    if (opcode == 0x4e72 		/* RTE */
+		|| opcode == 0x4e74 		/* RTD */
+		|| opcode == 0x4e75 		/* RTS */
+		|| opcode == 0x4e77 		/* RTR */
+		|| opcode == 0x4e76 		/* TRAPV */
+		|| (opcode & 0xffc0) == 0x4e80 	/* JSR */
+		|| (opcode & 0xffc0) == 0x4ec0 	/* JMP */
+		|| (opcode & 0xff00) == 0x6100  /* BSR */
+		|| ((opcode & 0xf000) == 0x6000	/* Bcc */
+		    && cctrue((opcode >> 8) & 0xf)) 
+		|| ((opcode & 0xf0f0) == 0x5050 /* DBcc */
+		    && !cctrue((opcode >> 8) & 0xf) 
+		    && (uae_s16)m68k_dreg(regs, opcode & 7) != 0)) 
+	    {
+		last_trace_ad = m68k_getpc();
+		regs.spcflags &= ~SPCFLAG_TRACE;
+		regs.spcflags |= SPCFLAG_DOTRACE;
+	    }
+	} else if (regs.t1) {
+	    last_trace_ad = m68k_getpc();
+	    regs.spcflags &= ~SPCFLAG_TRACE;
+	    regs.spcflags |= SPCFLAG_DOTRACE;
+	}
+    }
+}
+
+static void m68k_run_1(void)
+{
+    for(;;) {
+	if (quit_program > 0) {
+	    if (quit_program == 1)
+		break;
+	    //quit_program = 0;
+	    //m68k_reset();
+	}    	
+	uae_u32 opcode = nextiword();
+	/* assert (!regs.stopped && !(regs.spcflags & SPCFLAG_STOP)); */
+/*	regs_backup[backup_pointer = (backup_pointer + 1) % 16] = regs;*/
+	(*cpufunctbl[opcode])(opcode);
+#ifndef NO_EXCEPTION_3
+	if (buserr) {
+	    last_op_for_exception_3 = opcode;
+	    Exception(3,0);
+	    buserr = 0;
+	}
+#endif
+	/*n_insns++;*/
+	do_cycles();
+	if (regs.spcflags) {
+	    /*n_spcinsns++;*/
+	    while (regs.spcflags & SPCFLAG_BLTNASTY) {
+		do_cycles();
+		if (regs.spcflags & SPCFLAG_DISK)
+		    do_disk();
+	    }
+	    run_compiled_code();
+	    if (regs.spcflags & SPCFLAG_DOTRACE) {
+		Exception(9,last_trace_ad);
+	    }
+	    while (regs.spcflags & SPCFLAG_STOP) {
+		do_cycles();
+		if (regs.spcflags & SPCFLAG_DISK)
+		    do_disk();
+		if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)){
+		    int intr = intlev();
+		    regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT);
+		    if (intr != -1 && intr > regs.intmask) {
+			Interrupt(intr);
+			regs.stopped = 0;
+			regs.spcflags &= ~SPCFLAG_STOP;
+		    }
+		}
+	    }
+	    do_trace();
+#ifdef WANT_SLOW_MULTIPLY
+	    /* Kludge for Hardwired demo. The guys who wrote it should be
+	     * mutilated. */
+	    if (regs.spcflags & SPCFLAG_EXTRA_CYCLES) {
+		do_cycles (); do_cycles (); do_cycles (); do_cycles ();
+		regs.spcflags &= ~SPCFLAG_EXTRA_CYCLES;
+	    }
+#endif
+	    if (regs.spcflags & SPCFLAG_DISK)
+		do_disk();
+
+	    if (regs.spcflags & SPCFLAG_DOINT) {
+		int intr = intlev();
+		regs.spcflags &= ~SPCFLAG_DOINT;
+		if (intr != -1 && intr > regs.intmask) {
+		    Interrupt(intr);
+		    regs.stopped = 0;
+		}	    
+	    }
+	    if (regs.spcflags & SPCFLAG_INT) {
+		regs.spcflags &= ~SPCFLAG_INT;
+		regs.spcflags |= SPCFLAG_DOINT;
+	    }
+	    if (regs.spcflags & (SPCFLAG_BRK|SPCFLAG_MODE_CHANGE)) {
+		regs.spcflags &= ~(SPCFLAG_BRK|SPCFLAG_MODE_CHANGE);
+		return;
+	    }
+	}
+    }
+}
+
+
+
+
+#define m68k_run1 m68k_run_1
+
+int in_m68k_go = 0;
+
+void m68k_go(int may_quit)
+{
+    if (in_m68k_go || !may_quit) {
+	write_log("Bug! m68k_go is not reentrant.\n");
+	abort();
+    }
+
+    in_m68k_go++;
+    for(;;) {   
+		if (quit_program > 0) {
+		    if (quit_program == 1)
+			break;
+		    quit_program = 0;   
+		    m68k_reset();    
+		}    
+	    m68k_run1();
+    }
+    in_m68k_go--;
+}
+
+

MCUME_teensy/teensyuae41/_68020/cpu6.c

@@ -0,0 +1,456 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_6000)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6001)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_60ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6100)(uae_u32 opcode) /* BSR */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_6101)(uae_u32 opcode) /* BSR */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_61ff)(uae_u32 opcode) /* BSR */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
+}}}
+void REGPARAM2 CPU_OP_NAME(_6200)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6201)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_62ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6300)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6301)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_63ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6400)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6401)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_64ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6500)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6501)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_65ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6600)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6601)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_66ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6700)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6701)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_67ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6800)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6801)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_68ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6900)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6901)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_69ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6aff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6bff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6cff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6dff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6eff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6fff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+#endif

MCUME_teensy/teensyuae41/_68020/cpu7.c

@@ -0,0 +1,21 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_7000)(uae_u32 opcode) /* MOVE */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+	uae_u32 dstreg = (opcode >> 9) & 7;
+{{	uae_u32 src = srcreg;
+{	VFLG = CFLG = 0;
+	ZFLG = ((uae_s32)(src)) == 0;
+	NFLG = ((uae_s32)(src)) < 0;
+	m68k_dreg(regs, dstreg) = (src);
+}}}}
+#endif

MCUME_teensy/teensyuae41/_68020/cpuA.c

@@ -0,0 +1,11 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/_68020/cpuF.c

@@ -0,0 +1,11 @@
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "compiler.h"
+#include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/_68020/newcpu.c

@@ -0,0 +1,846 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * MC68000 emulation
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+#include "shared.h"
+
+#include "gensound.h"
+#include "sounddep/sound.h"
+#include "events.h"
+#include "uae.h"
+#include "machdep/m68k.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "autoconf.h"
+#ifdef HAS_ERSATZ  
+#include "ersatz.h"
+#endif
+//#include "debug.h"
+#include "compiler.h"
+#include "arduinoproto.h"
+
+int areg_byteinc[] = { 1,1,1,1,1,1,1,2 };
+int imm8_table[] = { 8,1,2,3,4,5,6,7 };
+
+int movem_index1[256];
+int movem_index2[256];
+int movem_next[256];
+
+int fpp_movem_index1[256];
+int fpp_movem_index2[256];
+int fpp_movem_next[256];
+
+//#define GENTABLE
+
+#ifdef GENTABLE
+cpuop_func *cpufunctbl[65536];
+#else
+#include "cputbl.h"
+#include "cpugentbl.h"
+#endif
+
+
+#ifndef NO_PREFETCH_BUFFER
+/* Oh boy does this suck... */
+void fill_prefetch(void)
+{
+    /* We can't use clever code on all machines. */
+    memcpy (regs.prefetch, regs.pc_p, sizeof regs.prefetch);
+    regs.prefetch_pos = regs.prefetch;
+}
+
+uae_u32 nextibyte(void)
+{
+    uae_u32 v = do_get_mem_byte (regs.prefetch_pos + 1);
+    *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+    regs.pc_p += 2;
+    regs.prefetch_pos += 2;
+    if (regs.prefetch_pos == regs.prefetch + 16)
+	regs.prefetch_pos = regs.prefetch;
+    return v;
+}
+
+uae_u32 nextiword(void)
+{
+    uae_u32 v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
+    *(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+    regs.pc_p += 2;
+    regs.prefetch_pos += 2;
+    if (regs.prefetch_pos == regs.prefetch + 16)
+	regs.prefetch_pos = regs.prefetch;
+    return v;
+}
+
+uae_u32 nextilong(void)
+{
+    uae_u32 v;
+    if (regs.prefetch_pos == regs.prefetch + 14) {
+	v = do_get_mem_word ((uae_u16 *)regs.prefetch_pos);
+	v <<= 16;
+	v |= do_get_mem_word ((uae_u16 *)regs.prefetch);
+	*(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+	*(uae_u16 *)regs.prefetch = *(uae_u16 *)(regs.pc_p + 18);
+	regs.pc_p += 4;
+	regs.prefetch_pos = regs.prefetch + 2;
+    } else {
+	v = do_get_mem_long ((uae_u32 *)regs.prefetch_pos);
+	*(uae_u16 *)regs.prefetch_pos = *(uae_u16 *)(regs.pc_p + 16);
+	*(uae_u16 *)(regs.prefetch_pos+2) = *(uae_u16 *)(regs.pc_p + 18);	
+	regs.pc_p += 4;
+	regs.prefetch_pos += 4;
+	if (regs.prefetch_pos == regs.prefetch + 16)
+	    regs.prefetch_pos = regs.prefetch;
+    }
+    return v;
+}
+#endif
+
+uaecptr m68k_currentpc(void)
+{
+    return m68k_getpc();
+}
+
+
+
+#ifdef GENTABLE
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int search(void * code)
+{
+	int k;
+	for (k = 0; op_smalltbl[k].handler != NULL; k++) {
+		if ((void*)op_smalltbl[k].handler == code)
+			return op_smalltbl[k].opcode;
+	}	
+	return -1;
+		
+}
+#endif
+
+
+void init_m68k (void)
+{
+    int i,j;
+    
+    for (i = 0 ; i < 256 ; i++) {
+		for (j = 0 ; j < 8 ; j++) {
+			if (i & (1 << j)) break;
+		}
+		movem_index1[i] = j;
+		movem_index2[i] = 7-j;
+		movem_next[i] = i & (~(1 << j));
+    }
+
+    for (i = 0 ; i < 256 ; i++) {
+		for (j = 7 ; j >= 0 ; j--) {
+			if (i & (1 << j)) break;
+		}
+		fpp_movem_index1[i] = j;
+		fpp_movem_index2[i] = 7-j;
+		fpp_movem_next[i] = i & (~(1 << j));
+    }
+
+#ifdef GENTABLE
+    long int opcode;
+    write_log("Building CPU table...\n");
+    read_table68k ();
+    do_merges ();
+    for (opcode = 0; opcode < 65536; opcode++)
+	cpufunctbl[opcode] = op_illg;
+    for (i = 0; op_smalltbl[i].handler != NULL; i++) {
+	if (!op_smalltbl[i].specific)
+	    cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
+    }
+    for (opcode = 0; opcode < 65536; opcode++) {
+	cpuop_func *f;
+	
+	if (table68k[opcode].mnemo == i_ILLG)
+	    continue;
+	
+	if (table68k[opcode].handler != -1) {
+	    f = cpufunctbl[table68k[opcode].handler];
+	    if (f == op_illg)
+		abort();
+	    cpufunctbl[opcode] = f;
+	}
+    }	
+    for (i = 0; op_smalltbl[i].handler != NULL; i++) {
+	if (op_smalltbl[i].specific)
+	    cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
+    }
+
+
+	FILE *fp_wr = stdout;
+	if ((fp_wr = fopen ("cpugentbl.h", "wb")) == NULL)
+	{
+		exit;
+	}
+
+	int cnt=0;
+	int size = 65536;
+	fprintf(fp_wr, "const cpuop_func * cpufunctbl[%d] = {\n", size);
+
+	cnt = 0;
+	for (int i = 0; i < size; i++) {
+	cnt++;
+	int code = search((void *)cpufunctbl[i]);
+	if (cnt == 16) {
+	  if (code == -1) fprintf(fp_wr, "op_illg,\n");
+	  else if (code < 0x10) fprintf(fp_wr, "op_%01x,\n",code);
+	  else if (code < 0x100) fprintf(fp_wr, "op_%02x,\n",code);
+	  else if (code < 0x1000) fprintf(fp_wr, "op_%03x,\n",code);
+	  else fprintf(fp_wr, "op_%04X,\n",code);
+	}  
+	else {
+	  if (code == -1) fprintf(fp_wr, "op_illg,\n");
+	  else if (code < 0x10) fprintf(fp_wr, "op_%01x,",code);
+	  else if (code < 0x100) fprintf(fp_wr, "op_%02x,",code);
+	  else if (code < 0x1000) fprintf(fp_wr, "op_%03x,",code);
+	  else fprintf(fp_wr, "op_%04x,",code);
+	}  
+	cnt &= 15;
+	}  
+	fprintf(fp_wr, "};\n");
+	fclose (fp_wr);
+#endif
+}
+
+
+struct flag_struct regflags;
+struct regstruct regs, lastint_regs;
+int lastint_no;
+int broken_in;
+
+
+
+void MakeSR(void)
+{
+    regs.sr = ((regs.t1 << 15) | (regs.t0 << 14)
+	       | (regs.s << 13) | (regs.m << 12) | (regs.intmask << 8)
+	       | (XFLG << 4) | (NFLG << 3) | (ZFLG << 2) | (VFLG << 1) 
+	       |  CFLG);
+}
+
+void MakeFromSR(void)
+{
+    int oldm = regs.m;
+    int olds = regs.s;
+
+    regs.t1 = (regs.sr >> 15) & 1;
+    regs.t0 = (regs.sr >> 14) & 1;
+    regs.s = (regs.sr >> 13) & 1;
+    regs.m = (regs.sr >> 12) & 1;
+    regs.intmask = (regs.sr >> 8) & 7;
+    XFLG = (regs.sr >> 4) & 1;
+    NFLG = (regs.sr >> 3) & 1;
+    ZFLG = (regs.sr >> 2) & 1;
+    VFLG = (regs.sr >> 1) & 1;
+    CFLG = regs.sr & 1;
+    if (CPU_LEVEL >= 2) {
+	if (olds != regs.s) {
+ 	    if (olds) {
+ 	        if (oldm)
+ 		    regs.msp = m68k_areg(regs, 7);
+ 	        else
+ 		    regs.isp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.usp;
+ 	    } else {
+ 	        regs.usp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
+ 	    }
+	} else if (olds && oldm != regs.m) {
+	    if (oldm) {
+		regs.msp = m68k_areg(regs, 7);
+		m68k_areg(regs, 7) = regs.isp;
+	    } else {
+		regs.isp = m68k_areg(regs, 7);
+		m68k_areg(regs, 7) = regs.msp;
+	    }
+	}
+    } else {
+	if (olds != regs.s) {
+ 	    if (olds) {
+ 		regs.isp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.usp;
+ 	    } else {
+ 	        regs.usp = m68k_areg(regs, 7);
+ 	        m68k_areg(regs, 7) = regs.isp;
+ 	    }
+ 	}
+    }
+    
+    regs.spcflags |= SPCFLAG_INT;
+    if (regs.t1 || regs.t0)
+    	regs.spcflags |= SPCFLAG_TRACE;
+    else
+    	regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
+}
+/* Opcode of faulting instruction */
+uae_u16 last_op_for_exception_3;
+/* PC at fault time */
+uaecptr last_addr_for_exception_3;
+/* Address that generated the exception */
+uaecptr last_fault_for_exception_3;
+
+void Exception(int nr, uaecptr oldpc)
+{
+    compiler_flush_jsr_stack();
+    MakeSR();
+    if (!regs.s) {
+	regs.usp = m68k_areg(regs, 7);
+	if (CPU_LEVEL >= 2)
+ 	    m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
+ 	else
+ 	    m68k_areg(regs, 7) = regs.isp;
+	regs.s = 1;
+    }
+    if (CPU_LEVEL > 0) {
+	if (nr == 2 || nr == 3) {
+	    int i;
+	    /* @@@ this is probably wrong (?) */
+	    for (i = 0 ; i < 12 ; i++) {
+		m68k_areg(regs, 7) -= 2;
+		put_word (m68k_areg(regs, 7), 0);
+	    }
+	    m68k_areg(regs, 7) -= 2;
+	    put_word (m68k_areg(regs, 7), 0xa000 + nr * 4);
+	} else if (nr ==5 || nr == 6 || nr == 7 || nr == 9) {
+ 	    m68k_areg(regs, 7) -= 4;
+ 	    put_long (m68k_areg(regs, 7), oldpc);
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), 0x2000 + nr * 4);
+ 	} else if (regs.m && nr >= 24 && nr < 32) {
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), nr * 4);
+ 	    m68k_areg(regs, 7) -= 4;
+ 	    put_long (m68k_areg(regs, 7), m68k_getpc ());
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), regs.sr);
+ 	    regs.sr |= (1 << 13);
+ 	    regs.msp = m68k_areg(regs, 7);
+ 	    m68k_areg(regs, 7) = regs.isp;
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), 0x1000 + nr * 4);
+ 	} else {
+ 	    m68k_areg(regs, 7) -= 2;
+ 	    put_word (m68k_areg(regs, 7), nr * 4);
+ 	}
+    } else {
+	if (nr == 2 || nr == 3) {
+	    m68k_areg(regs, 7) -= 12;
+	    /* ??????? */
+	    if (nr == 3) {
+		put_long (m68k_areg(regs, 7), last_fault_for_exception_3);
+		put_word (m68k_areg(regs, 7)+4, last_op_for_exception_3);
+		put_long (m68k_areg(regs, 7)+8, last_addr_for_exception_3);
+	    }
+	    write_log ("Exception!\n");
+	    goto kludge_me_do;
+	}
+    }
+    m68k_areg(regs, 7) -= 4;
+    put_long (m68k_areg(regs, 7), m68k_getpc ());
+kludge_me_do:
+    m68k_areg(regs, 7) -= 2;
+    put_word (m68k_areg(regs, 7), regs.sr);
+    m68k_setpc(get_long(regs.vbr + 4*nr));
+    regs.t1 = regs.t0 = regs.m = 0;
+    regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
+}
+
+static void Interrupt(int nr)
+{
+    //assert(nr < 8 && nr >= 0);
+    lastint_regs = regs;
+    lastint_no = nr;
+    Exception(nr+24, 0);
+    
+    regs.intmask = nr;
+    regs.spcflags |= SPCFLAG_INT;
+}
+
+
+
+static __inline__ void
+mul_unsigned(uae_u32 src1, uae_u32 src2, uae_u32 *dst_hi, uae_u32 *dst_lo)
+{
+        uae_u32 r0 = (src1 & 0xffff) * (src2 & 0xffff);
+        uae_u32 r1 = ((src1 >> 16) & 0xffff) * (src2 & 0xffff);
+        uae_u32 r2 = (src1 & 0xffff) * ((src2 >> 16) & 0xffff);
+        uae_u32 r3 = ((src1 >> 16) & 0xffff) * ((src2 >> 16) & 0xffff);
+	uae_u32 lo;
+
+        lo = r0 + ((r1 << 16) & 0xffff0000ul);
+        if (lo < r0) r3++;
+        r0 = lo;
+        lo = r0 + ((r2 << 16) & 0xffff0000ul);
+        if (lo < r0) r3++;
+        r3 += ((r1 >> 16) & 0xffff) + ((r2 >> 16) & 0xffff);
+	*dst_lo = lo;
+	*dst_hi = r3;
+}
+
+void m68k_mull (uae_u32 opcode, uae_u32 src, uae_u16 extra)
+{
+
+    if (extra & 0x800) {
+	/* signed variant */
+	uae_s32 src1,src2;
+	uae_u32 dst_lo,dst_hi;
+	uae_u32 sign;
+
+	src1 = (uae_s32)src;
+	src2 = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
+	sign = (src1 ^ src2);
+	if (src1 < 0) src1 = -src1;
+	if (src2 < 0) src2 = -src2;
+	mul_unsigned((uae_u32)src1,(uae_u32)src2,&dst_hi,&dst_lo);
+	if (sign & 0x80000000) {
+		dst_hi = ~dst_hi;
+		dst_lo = -dst_lo;
+		if (dst_lo == 0) dst_hi++;
+	}
+	VFLG = CFLG = 0;
+	ZFLG = dst_hi == 0 && dst_lo == 0;
+	NFLG = ((uae_s32)dst_hi) < 0;
+	if (extra & 0x400)
+	    m68k_dreg(regs, extra & 7) = dst_hi;
+	else if ((dst_hi != 0 || (dst_lo & 0x80000000) != 0)
+		 && ((dst_hi & 0xffffffff) != 0xffffffff
+		     || (dst_lo & 0x80000000) != 0x80000000)) 
+	{
+	    VFLG = 1;
+	}
+	m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
+    } else {
+	/* unsigned */
+	uae_u32 dst_lo,dst_hi;
+
+	mul_unsigned(src,(uae_u32)m68k_dreg(regs, (extra >> 12) & 7),&dst_hi,&dst_lo);
+	
+	VFLG = CFLG = 0;
+	ZFLG = dst_hi == 0 && dst_lo == 0;
+	NFLG = ((uae_s32)dst_hi) < 0;
+	if (extra & 0x400)
+	    m68k_dreg(regs, extra & 7) = dst_hi;
+	else if (dst_hi != 0) {
+	    VFLG = 1;
+	}
+	m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
+    }
+
+}
+
+void m68k_reset(void)
+{
+    m68k_areg(regs, 7) = get_long(0x00f80000);
+    m68k_setpc(get_long(0x00f80004));
+    regs.kick_mask = 0xF80000;
+    regs.s = 1;
+    regs.m = 0;
+    regs.stopped = 0;
+    regs.t1 = 0;
+    regs.t0 = 0;
+    ZFLG = CFLG = NFLG = VFLG = 0;
+    regs.spcflags = 0;
+    regs.intmask = 7;
+    regs.vbr = regs.sfc = regs.dfc = 0;
+    regs.fpcr = regs.fpsr = regs.fpiar = 0;
+    customreset();
+}
+
+void REGPARAM2 op_illg(uae_u32 opcode)
+{
+    compiler_flush_jsr_stack();
+    if (opcode == 0x4E7B && get_long(0x10) == 0 
+	&& (m68k_getpc() & 0xF80000) == 0xF80000) 
+    {
+	write_log("Your Kickstart requires a 68020 CPU. Giving up.\n");
+	broken_in = 1; 
+	regs.spcflags |= SPCFLAG_BRK;
+	quit_program = 1;
+    }
+    if (opcode == 0xFF0D) {
+	if ((m68k_getpc() & 0xF80000) == 0xF80000) {
+	    /* This is from the dummy Kickstart replacement */
+#ifdef HAS_ERSATZ  	    
+	    ersatz_perform (nextiword ());
+#endif	    
+	    return;
+	} else if ((m68k_getpc() & 0xF80000) == 0xF00000) {
+	    /* User-mode STOP replacement */
+	    m68k_setstopped(1);
+	    return;
+	}
+    }
+#ifdef USE_POINTER
+    regs.pc_p -= 2;
+#else
+    regs.pc -= 2;
+#endif
+    fill_prefetch();
+    if ((opcode & 0xF000) == 0xF000) {
+	Exception(0xB,0);
+	return;
+    }
+    if ((opcode & 0xF000) == 0xA000) {
+    	Exception(0xA,0);
+	return;
+    }
+    sprintf (warning_buffer, "Illegal instruction: %04x at %08lx\n", opcode, m68k_getpc());
+    write_log (warning_buffer);
+    Exception(4,0);
+}
+
+void mmu_op(uae_u32 opcode, uae_u16 extra)
+{
+    if ((extra & 0xB000) == 0) { /* PMOVE instruction */
+
+    } else if ((extra & 0xF000) == 0x2000) { /* PLOAD instruction */
+    } else if ((extra & 0xF000) == 0x8000) { /* PTEST instruction */
+    } else
+	op_illg(opcode);
+}
+
+
+static int caar, cacr;
+
+void m68k_move2c (int regno, uae_u32 *regp)
+{
+    if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
+	op_illg (0x4E7B);
+    else
+	switch (regno) {
+	 case 0: regs.sfc = *regp & 7; break;
+	 case 1: regs.dfc = *regp & 7; break;
+	 case 2: cacr = *regp & 0x3; break;	/* ignore C and CE */
+	 case 0x800: regs.usp = *regp; break;
+	 case 0x801: regs.vbr = *regp; break;
+	 case 0x802: caar = *regp &0xfc; break;
+	 case 0x803: regs.msp = *regp; if (regs.m == 1) m68k_areg(regs, 7) = regs.msp; break;
+	 case 0x804: regs.isp = *regp; if (regs.m == 0) m68k_areg(regs, 7) = regs.isp; break;
+	 default:
+	    op_illg (0x4E7B);
+	    break;
+	}
+}
+
+void m68k_movec2 (int regno, uae_u32 *regp)
+{
+    if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
+	op_illg (0x4E7A);
+    else
+	switch (regno) {
+	 case 0: *regp = regs.sfc; break;
+	 case 1: *regp = regs.dfc; break;
+	 case 2: *regp = cacr; break;
+	 case 0x800: *regp = regs.usp; break;
+	 case 0x801: *regp = regs.vbr; break;
+	 case 0x802: *regp = caar; break;
+	 case 0x803: *regp = regs.m == 1 ? m68k_areg(regs, 7) : regs.msp; break;
+	 case 0x804: *regp = regs.m == 0 ? m68k_areg(regs, 7) : regs.isp; break;
+	 default:
+	    op_illg (0x4E7A);
+	    break;
+	}
+}
+
+static __inline__ int
+div_unsigned(uae_u32 src_hi, uae_u32 src_lo, uae_u32 div, uae_u32 *quot, uae_u32 *rem)
+{
+	uae_u32 q = 0, cbit = 0;
+	int i;
+
+	if (div <= src_hi) {
+	    return(1);
+	}
+	for (i = 0 ; i < 32 ; i++) {
+		cbit = src_hi & 0x80000000ul;
+		src_hi <<= 1;
+		if (src_lo & 0x80000000ul) src_hi++;
+		src_lo <<= 1;
+		q = q << 1;
+		if (cbit || div <= src_hi) {
+			q |= 1;
+			src_hi -= div;
+		}
+	}
+	*quot = q;
+	*rem = src_hi;
+	return(0);
+}
+
+void m68k_divl (uae_u32 opcode, uae_u32 src, uae_u16 extra, uaecptr oldpc)
+{
+#if defined(uae_s64)
+    if (src == 0) {
+	Exception(5,oldpc-2);
+	return;
+    }
+    if (extra & 0x800) {
+	/* signed variant */
+	uae_s64 a = (uae_s64)(uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
+	uae_s64 quot, rem;
+	
+	if (extra & 0x400) {
+	    a &= 0xffffffffu;
+	    a |= (uae_s64)m68k_dreg(regs, extra & 7) << 32;
+	}
+	rem = a % (uae_s64)(uae_s32)src;
+	quot = a / (uae_s64)(uae_s32)src;
+	if ((quot & UVAL64(0xffffffff80000000)) != 0
+	    && (quot & UVAL64(0xffffffff80000000)) != UVAL64(0xffffffff80000000))
+	{
+	    VFLG = NFLG = 1;
+	    CFLG = 0;
+	}
+	else {
+	    if (((uae_s32)rem < 0) != ((uae_s64)a < 0)) rem = -rem;
+	    VFLG = CFLG = 0;
+	    ZFLG = ((uae_s32)quot) == 0;
+	    NFLG = ((uae_s32)quot) < 0;
+	    m68k_dreg(regs, extra & 7) = rem;
+	    m68k_dreg(regs, (extra >> 12) & 7) = quot;
+	}
+    } else {
+	/* unsigned */
+	uae_u64 a = (uae_u64)(uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
+	uae_u64 quot, rem;
+	
+	if (extra & 0x400) {
+	    a &= 0xffffffffu;
+	    a |= (uae_u64)m68k_dreg(regs, extra & 7) << 32;
+	}
+	rem = a % (uae_u64)src;
+	quot = a / (uae_u64)src;
+	if (quot > 0xffffffffu) {
+	    VFLG = NFLG = 1;
+	    CFLG = 0;
+	}
+	else {
+	    VFLG = CFLG = 0;
+	    ZFLG = ((uae_s32)quot) == 0;
+	    NFLG = ((uae_s32)quot) < 0;
+	    m68k_dreg(regs, extra & 7) = rem;
+	    m68k_dreg(regs, (extra >> 12) & 7) = quot;
+	}
+    }
+#else
+    if (src == 0) {
+	Exception(5,oldpc-2);
+	return;
+    }
+    if (extra & 0x800) {
+	/* signed variant */
+	uae_s32 lo = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
+	uae_s32 hi = lo < 0 ? -1 : 0;
+	uae_s32 save_high;
+	uae_u32 quot, rem;
+	uae_u32 sign;
+	
+	if (extra & 0x400) {
+	    hi = (uae_s32)m68k_dreg(regs, extra & 7);
+	}
+	save_high = hi;
+	sign = (hi ^ src);
+	if (hi < 0) {
+		hi = ~hi;
+		lo = -lo;
+		if (lo == 0) hi++;
+	}
+	if ((uae_s32)src < 0) src = -src;
+	if (div_unsigned(hi, lo, src, &quot, &rem) ||
+	    (sign & 0x80000000) ? quot > 0x80000000 : quot > 0x7fffffff) {
+	    VFLG = NFLG = 1;
+	    CFLG = 0;
+	}
+	else {
+	    if (sign & 0x80000000) quot = -quot;
+	    if (((uae_s32)rem < 0) != (save_high < 0)) rem = -rem;
+	    VFLG = CFLG = 0;
+	    ZFLG = ((uae_s32)quot) == 0;
+	    NFLG = ((uae_s32)quot) < 0;
+	    m68k_dreg(regs, extra & 7) = rem;
+	    m68k_dreg(regs, (extra >> 12) & 7) = quot;
+	}
+    } else {
+	/* unsigned */
+	uae_u32 lo = (uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
+	uae_u32 hi = 0;
+	uae_u32 quot, rem;
+	
+	if (extra & 0x400) {
+	    hi = (uae_u32)m68k_dreg(regs, extra & 7);
+	}
+	if (div_unsigned(hi, lo, src, &quot, &rem)) {
+	    VFLG = NFLG = 1;
+	    CFLG = 0;
+	}
+	else {
+	    VFLG = CFLG = 0;
+	    ZFLG = ((uae_s32)quot) == 0;
+	    NFLG = ((uae_s32)quot) < 0;
+	    m68k_dreg(regs, extra & 7) = rem;
+	    m68k_dreg(regs, (extra >> 12) & 7) = quot;
+	}
+    }
+#endif
+}
+
+
+static int n_insns=0, n_spcinsns=0;
+
+static uaecptr last_trace_ad = 0;
+
+static __inline__ void do_trace(void)
+{
+    if (regs.spcflags & SPCFLAG_TRACE) {		/* 6 */
+	if (regs.t0) {
+	    uae_u16 opcode;
+	    /* should also include TRAP, CHK, SR modification FPcc */
+	    /* probably never used so why bother */
+	    /* We can afford this to be inefficient... */
+	    m68k_setpc(m68k_getpc());
+	    opcode = get_word(regs.pc);
+	    if (opcode == 0x4e72 		/* RTE */
+		|| opcode == 0x4e74 		/* RTD */
+		|| opcode == 0x4e75 		/* RTS */
+		|| opcode == 0x4e77 		/* RTR */
+		|| opcode == 0x4e76 		/* TRAPV */
+		|| (opcode & 0xffc0) == 0x4e80 	/* JSR */
+		|| (opcode & 0xffc0) == 0x4ec0 	/* JMP */
+		|| (opcode & 0xff00) == 0x6100  /* BSR */
+		|| ((opcode & 0xf000) == 0x6000	/* Bcc */
+		    && cctrue((opcode >> 8) & 0xf)) 
+		|| ((opcode & 0xf0f0) == 0x5050 /* DBcc */
+		    && !cctrue((opcode >> 8) & 0xf) 
+		    && (uae_s16)m68k_dreg(regs, opcode & 7) != 0)) 
+	    {
+		last_trace_ad = m68k_getpc();
+		regs.spcflags &= ~SPCFLAG_TRACE;
+		regs.spcflags |= SPCFLAG_DOTRACE;
+	    }
+	} else if (regs.t1) {
+	    last_trace_ad = m68k_getpc();
+	    regs.spcflags &= ~SPCFLAG_TRACE;
+	    regs.spcflags |= SPCFLAG_DOTRACE;
+	}
+    }
+}
+
+static void m68k_run_1(void)
+{
+    for(;;) {
+	if (quit_program > 0) {
+	    if (quit_program == 1)
+		break;
+	    //quit_program = 0;
+	    //m68k_reset();
+	}    	
+	uae_u32 opcode = nextiword();
+
+	/* assert (!regs.stopped && !(regs.spcflags & SPCFLAG_STOP)); */
+/*	regs_backup[backup_pointer = (backup_pointer + 1) % 16] = regs;*/
+	(*cpufunctbl[opcode])(opcode);
+#ifndef NO_EXCEPTION_3
+	if (buserr) {
+	    last_op_for_exception_3 = opcode;
+	    Exception(3,0);
+	    buserr = 0;
+	}
+#endif
+	/*n_insns++;*/
+	do_cycles();
+	if (regs.spcflags) {
+	    /*n_spcinsns++;*/
+	    while (regs.spcflags & SPCFLAG_BLTNASTY) {
+		do_cycles();
+		if (regs.spcflags & SPCFLAG_DISK)
+		    do_disk();
+	    }
+	    run_compiled_code();
+	    if (regs.spcflags & SPCFLAG_DOTRACE) {
+		Exception(9,last_trace_ad);
+	    }
+	    while (regs.spcflags & SPCFLAG_STOP) {
+		do_cycles();
+		if (regs.spcflags & SPCFLAG_DISK)
+		    do_disk();
+		if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)){
+		    int intr = intlev();
+		    regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT);
+		    if (intr != -1 && intr > regs.intmask) {
+			Interrupt(intr);
+			regs.stopped = 0;
+			regs.spcflags &= ~SPCFLAG_STOP;
+		    }
+		}
+	    }
+	    do_trace();
+#ifdef WANT_SLOW_MULTIPLY
+	    /* Kludge for Hardwired demo. The guys who wrote it should be
+	     * mutilated. */
+	    if (regs.spcflags & SPCFLAG_EXTRA_CYCLES) {
+		do_cycles (); do_cycles (); do_cycles (); do_cycles ();
+		regs.spcflags &= ~SPCFLAG_EXTRA_CYCLES;
+	    }
+#endif
+	    if (regs.spcflags & SPCFLAG_DISK)
+		do_disk();
+
+	    if (regs.spcflags & SPCFLAG_DOINT) {
+		int intr = intlev();
+		regs.spcflags &= ~SPCFLAG_DOINT;
+		if (intr != -1 && intr > regs.intmask) {
+		    Interrupt(intr);
+		    regs.stopped = 0;
+		}	    
+	    }
+	    if (regs.spcflags & SPCFLAG_INT) {
+		regs.spcflags &= ~SPCFLAG_INT;
+		regs.spcflags |= SPCFLAG_DOINT;
+	    }
+	    if (regs.spcflags & (SPCFLAG_BRK|SPCFLAG_MODE_CHANGE)) {
+		regs.spcflags &= ~(SPCFLAG_BRK|SPCFLAG_MODE_CHANGE);
+		return;
+	    }
+	}
+    }
+}
+
+
+
+
+#define m68k_run1 m68k_run_1
+
+int in_m68k_go = 0;
+
+void m68k_go(int may_quit)
+{
+    if (in_m68k_go || !may_quit) {
+	write_log("Bug! m68k_go is not reentrant.\n");
+	abort();
+    }
+
+    in_m68k_go++;
+    for(;;) {
+		if (quit_program > 0) {
+		    if (quit_program == 1)
+			break;
+		    quit_program = 0;
+		    m68k_reset();
+		}
+	    m68k_run1();
+    }
+    in_m68k_go--;
+}
+
+

MCUME_teensy/teensyuae41/audio.c

@@ -0,0 +1,324 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * OS specific functions
+  * 
+  * Copyright 1995, 1996, 1997 Bernd Schmidt
+  * Copyright 1996 Marcus Sundberg
+  * Copyright 1996 Manfred Thole
+  */
+
+#include "shared.h"
+
+#include "memory.h"
+#include "custom.h"
+#include "gensound.h"
+#include "sounddep/sound.h"
+#include "events.h"
+#include "audio.h"
+
+int sound_available = 0;
+
+struct audio_channel_data audio_channel[4];
+#ifdef HAS_TABLE
+static short sound_table[256][64];
+#endif
+unsigned long int sample_evtime;
+
+void init_sound_table16(void)
+{
+#ifdef HAS_TABLE
+    int i,j;
+    
+    for (i = 0; i < 256; i++)
+	for (j = 0; j < 64; j++)
+	    sound_table[i][j] = j * (uae_s8)i;
+#endif
+}
+
+void init_sound_table8 (void)
+{
+#ifdef HAS_TABLE
+    int i,j;
+    
+    for (i = 0; i < 256; i++)
+	for (j = 0; j < 64; j++)
+	    sound_table[i][j] = (j * (uae_s8)i) / 256;
+#endif
+}
+
+void AUDxDAT(int nr, uae_u16 v) 
+{
+#ifndef DONT_WANT_SOUND
+    struct audio_channel_data *cdp = audio_channel + nr;
+    cdp->dat = v;
+    if (cdp->state == 0 && !(INTREQR() & (0x80 << nr))) {
+	cdp->state = 2;
+	INTREQ(0x8000 | (0x80 << nr));
+	/* data_written = 2 ???? */
+	eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
+	eventtab[ev_aud0 + nr].oldcycles = cycles;
+	eventtab[ev_aud0 + nr].active = 1;
+	events_schedule();
+    }
+#endif
+}
+
+/* Templates! I want templates! */
+void sample16_handler(void)
+{
+#ifndef DONT_WANT_SOUND
+    int nr, adk;
+    uae_u32 data = SOUND16_BASE_VAL;
+
+    eventtab[ev_sample].evtime = cycles + sample_evtime;
+    eventtab[ev_sample].oldcycles = cycles;
+
+    adk = adkcon;
+
+#ifdef HAS_TABLE
+    if (!(adk & 0x11))
+		data += sound_table[audio_channel[0].current_sample][audio_channel[0].vol];
+    if (!(adk & 0x22))
+		data += sound_table[audio_channel[1].current_sample][audio_channel[1].vol];
+    if (!(adk & 0x44))
+		data += sound_table[audio_channel[2].current_sample][audio_channel[2].vol];
+    if (!(adk & 0x88))
+		data += sound_table[audio_channel[3].current_sample][audio_channel[3].vol];
+#else	
+    if (!(adk & 0x11))
+		data += (uae_s8)audio_channel[0].current_sample*audio_channel[0].vol;
+    if (!(adk & 0x22))
+		data += (uae_s8)audio_channel[1].current_sample*audio_channel[1].vol;
+    if (!(adk & 0x44))
+		data += (uae_s8)audio_channel[2].current_sample*audio_channel[2].vol;
+    if (!(adk & 0x88))
+		data += (uae_s8)audio_channel[3].current_sample*audio_channel[3].vol;
+#endif
+    PUT_SOUND_WORD (data);
+    check_sound_buffers ();
+#endif
+}
+
+void sample8_handler(void)
+{
+#ifndef DONT_WANT_SOUND
+    int nr, adk;
+    uae_u32 data = SOUND8_BASE_VAL;
+    
+    eventtab[ev_sample].evtime = cycles + sample_evtime;
+    eventtab[ev_sample].oldcycles = cycles;
+    
+    adk = adkcon;
+    
+#ifdef HAS_TABLE
+   if (!(adk & 0x11))
+	data += sound_table[audio_channel[0].current_sample][audio_channel[0].vol];
+    if (!(adk & 0x22))
+	data += sound_table[audio_channel[1].current_sample][audio_channel[1].vol];
+    if (!(adk & 0x44))
+	data += sound_table[audio_channel[2].current_sample][audio_channel[2].vol];
+    if (!(adk & 0x88))
+	data += sound_table[audio_channel[3].current_sample][audio_channel[3].vol];
+#endif
+
+    PUT_SOUND_BYTE (data);
+    check_sound_buffers ();
+#endif
+}
+
+#ifdef HAS_ULAW
+static uae_u8 int2ulaw(int ch)
+{
+    int mask;
+
+    if (ch < 0) {
+      ch = -ch;
+      mask = 0x7f;
+    }
+    else {
+      mask = 0xff;
+    }
+
+    if (ch < 32) {
+	ch = 0xF0 | ( 15 - (ch/2) );
+    } else if (ch < 96) {
+        ch = 0xE0 | ( 15 - (ch-32)/4 );
+    } else if (ch < 224) {
+	ch = 0xD0 | ( 15 - (ch-96)/8 );
+    } else if (ch < 480) {
+	ch = 0xC0 | ( 15 - (ch-224)/16 );
+    } else if (ch < 992 ) {
+	ch = 0xB0 | ( 15 - (ch-480)/32 );
+    } else if (ch < 2016) {
+	ch = 0xA0 | ( 15 - (ch-992)/64 );
+    } else if (ch < 4064) {
+	ch = 0x90 | ( 15 - (ch-2016)/128 );
+    } else if (ch < 8160) {
+	ch = 0x80 | ( 15 - (ch-4064)/256 );
+    } else {
+	ch = 0x80;
+    }
+    return (uae_u8)(mask & ch);
+}
+
+void sample_ulaw_handler(void)
+{
+#ifndef DONT_WANT_SOUND
+    int nr;
+    uae_u32 data = 0;
+    char *bp = (char *)sndbufpt;
+
+    eventtab[ev_sample].evtime += cycles - eventtab[ev_sample].oldcycles;
+    eventtab[ev_sample].oldcycles = cycles;
+
+    for (nr = 0; nr < 4; nr++) {
+#ifdef HAS_TABLE
+	if (!(adkcon & (0x11 << nr)))
+	    data += sound_table[audio_channel[nr].current_sample][audio_channel[nr].vol];
+#endif
+    }
+    PUT_SOUND_BYTE (int2ulaw (data));
+    check_sound_buffers ();
+#endif
+}
+#endif
+
+#ifndef DONT_WANT_SOUND
+static void audio_handler(int nr) 
+{
+    struct audio_channel_data *cdp = audio_channel + nr;
+
+    switch (cdp->state) {
+    case 0:
+	//fprintf(stderr, "Bug in sound code\n");
+	break;
+
+     case 1:
+	/* We come here at the first hsync after DMA was turned on. */
+	eventtab[ev_aud0 + nr].evtime += maxhpos;
+	eventtab[ev_aud0 + nr].oldcycles += maxhpos;
+	
+	cdp->state = 5;
+	INTREQ(0x8000 | (0x80 << nr));
+	if (cdp->wlen != 1)
+	    cdp->wlen--;
+	cdp->nextdat = chipmem_bank.wget(cdp->pt);
+
+	cdp->pt += 2;
+	break;
+
+     case 5:
+	/* We come here at the second hsync after DMA was turned on. */
+	if (currprefs.produce_sound == 0)
+	    cdp->per = 65535;
+
+	eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
+	eventtab[ev_aud0 + nr].oldcycles = cycles;
+	cdp->dat = cdp->nextdat;
+	cdp->current_sample = (uae_u8)(cdp->dat >> 8);
+
+	cdp->state = 2;
+	{
+	    int audav = adkcon & (1 << nr);
+	    int audap = adkcon & (16 << nr);
+	    int napnav = (!audav && !audap) || audav;
+	    if (napnav)
+		cdp->data_written = 2;
+	}
+	break;
+	
+     case 2:
+	/* We come here when a 2->3 transition occurs */
+	if (currprefs.produce_sound == 0)
+	    cdp->per = 65535;
+
+	cdp->current_sample = (uae_u8)(cdp->dat & 0xFF);
+	eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
+	eventtab[ev_aud0 + nr].oldcycles = cycles;
+
+	cdp->state = 3;
+
+	/* Period attachment? */
+	if (adkcon & (0x10 << nr)) {
+	    if (cdp->intreq2 && cdp->dmaen)
+		INTREQ(0x8000 | (0x80 << nr));
+	    cdp->intreq2 = 0;
+
+	    cdp->dat = cdp->nextdat;
+	    if (cdp->dmaen)
+		cdp->data_written = 2;
+	    if (nr < 3) {
+		if (cdp->dat == 0)
+		    (cdp+1)->per = 65535;
+
+		else if (cdp->dat < maxhpos/2 && currprefs.produce_sound < 3)
+		    (cdp+1)->per = maxhpos/2;
+		else
+		    (cdp+1)->per = cdp->dat;
+	    }
+	}
+	break;
+	
+     case 3:
+	/* We come here when a 3->2 transition occurs */
+	if (currprefs.produce_sound == 0)
+	    cdp->per = 65535;
+
+	eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
+	eventtab[ev_aud0 + nr].oldcycles = cycles;
+	
+	if ((INTREQR() & (0x80 << nr)) && !cdp->dmaen) {
+	    cdp->state = 0;
+	    cdp->current_sample = 0;
+	    eventtab[ev_aud0 + nr].active = 0;
+	    break;
+	} else {
+	    int audav = adkcon & (1 << nr);
+	    int audap = adkcon & (16 << nr);
+	    int napnav = (!audav && !audap) || audav;
+	    cdp->state = 2;
+	    
+	    if ((cdp->intreq2 && cdp->dmaen && napnav)
+		|| (napnav && !cdp->dmaen))
+		INTREQ(0x8000 | (0x80 << nr));
+	    cdp->intreq2 = 0;
+	    
+	    cdp->dat = cdp->nextdat;
+	    cdp->current_sample = (uae_u8)(cdp->dat >> 8);
+
+	    if (cdp->dmaen && napnav)
+		cdp->data_written = 2;
+	    
+	    /* Volume attachment? */
+	    if (audav) {
+		if (nr < 3)
+		    (cdp+1)->vol = cdp->dat;
+	    }
+	}
+	break;
+	    
+     default:
+	cdp->state = 0;
+	eventtab[ev_aud0 + nr].active = 0;
+	break;
+    }
+}
+
+void aud0_handler(void)
+{
+    audio_handler(0);
+}
+void aud1_handler(void)
+{
+    audio_handler(1);
+}
+void aud2_handler(void)
+{
+    audio_handler(2);
+}
+void aud3_handler(void)
+{
+    audio_handler(3);
+}
+#endif

MCUME_teensy/teensyuae41/audio.h

@@ -0,0 +1,24 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  *
+  * Sound emulation stuff
+  *
+  * Copyright 1995, 1996, 1997 Bernd Schmidt
+  */
+
+extern struct audio_channel_data {
+    uaecptr lc, pt, dmaen;
+    int data_written, snum, state, intreq2, wper, wlen;
+    uae_u16 dat, nextdat, vol, per, len;
+    int current_sample;
+} audio_channel[4];
+
+#ifndef DONT_WANT_SOUND
+extern void aud0_handler(void);
+extern void aud1_handler(void);
+extern void aud2_handler(void);
+extern void aud3_handler(void);
+#endif
+
+extern void AUDxDAT(int nr, uae_u16 value);
+

MCUME_teensy/teensyuae41/autoconf.c

@@ -0,0 +1,263 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * AutoConfig devices
+  *
+  * Copyright 1995, 1996 Bernd Schmidt
+  * Copyright 1996 Ed Hanway
+  */
+
+#include "shared.h"
+
+#include "machdep/m68k.h"
+#include "uae.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "disk.h"
+#include "xwin.h"
+#include "autoconf.h"
+
+/* We'll need a lot of these. */
+#define MAX_TRAPS 32 //4096
+static TrapFunction traps[MAX_TRAPS];
+static uae_u8 trapmode[MAX_TRAPS];
+static uaecptr trapoldfunc[MAX_TRAPS];
+
+static int max_trap = 0;
+
+
+static uae_u32 m68k_mode_return(void)
+{
+    return 0;
+}
+
+
+/* Commonly used autoconfig strings */
+
+uaecptr EXPANSION_explibname, EXPANSION_doslibname, EXPANSION_uaeversion;
+uaecptr EXPANSION_uaedevname, EXPANSION_explibbase = 0, EXPANSION_haveV36;
+uaecptr EXPANSION_bootcode, EXPANSION_nullfunc;
+
+static int current_deviceno = 0;
+
+int get_new_device(char **devname, uaecptr *devname_amiga)
+{
+    char buffer[80];
+    strcpy(buffer,"UAE1");
+    //buffer[0]=0;
+    
+    sprintf(buffer,"UAE%d", current_deviceno);
+    emu_printf("get new device");
+    emu_printf(buffer);
+
+    *devname_amiga = ds(*devname = my_strdup(buffer));
+    return current_deviceno++;
+}
+
+/* ROM tag area memory access */
+static uae_u8 rtarea[65536];
+//static uae_u8 * rtarea;
+
+static uae_u32 rtarea_lget(uaecptr) REGPARAM;
+static uae_u32 rtarea_wget(uaecptr) REGPARAM;
+static uae_u32 rtarea_bget(uaecptr) REGPARAM;
+static void  rtarea_lput(uaecptr, uae_u32) REGPARAM;
+static void  rtarea_wput(uaecptr, uae_u32) REGPARAM;
+static void  rtarea_bput(uaecptr, uae_u32) REGPARAM;
+static uae_u8 *rtarea_xlate(uaecptr) REGPARAM;
+
+addrbank rtarea_bank = {
+    rtarea_lget, rtarea_wget, rtarea_bget,
+    rtarea_lput, rtarea_wput, rtarea_bput,
+    rtarea_xlate, default_check
+};
+
+uae_u8 REGPARAM2 *rtarea_xlate(uaecptr addr) 
+{
+    addr &= 0xFFFF;
+    return rtarea + addr;
+}
+
+uae_u32 REGPARAM2 rtarea_lget(uaecptr addr)
+{
+    addr &= 0xFFFF;
+    return (uae_u32)(rtarea_wget(addr) << 16) + rtarea_wget(addr+2);
+}
+
+uae_u32 REGPARAM2 rtarea_wget(uaecptr addr)
+{
+    addr &= 0xFFFF;
+    return (rtarea[addr]<<8) + rtarea[addr+1];
+}
+
+uae_u32 REGPARAM2 rtarea_bget(uaecptr addr)
+{
+    uae_u16 data;
+    addr &= 0xFFFF;
+    return rtarea[addr];
+}
+
+void REGPARAM2 rtarea_lput(uaecptr addr, uae_u32 value) { }
+void REGPARAM2 rtarea_bput(uaecptr addr, uae_u32 value) { }
+
+/* Don't start at 0 -- can get bogus writes there. */
+static uae_u32 trap_base_addr = 0x00F00180;
+
+
+void REGPARAM2 rtarea_wput(uaecptr addr, uae_u32 value)
+{
+    uae_u32 retval = 0;
+    uae_u32 func = ((addr  - trap_base_addr) & 0xFFFF) >> 1;
+    int has_retval = (trapmode[func] & TRAPFLAG_NO_RETVAL) == 0;
+    
+    /* For monitoring only? */
+    if (traps[func] == NULL) {
+	   m68k_setpc(trapoldfunc[func]);
+	   return;
+    }
+    if (func < max_trap) {
+	   if (trapmode[func] & TRAPFLAG_EXTRA_STACK) {
+	       //execute_fn_on_extra_stack(traps[func], has_retval);
+	       return;
+	   }
+	   retval = (*traps[func])();
+    }
+
+
+    if (has_retval)
+	   m68k_dreg(regs, 0) = retval;
+}
+
+
+
+/* some quick & dirty code to fill in the rt area and save me a lot of
+ * scratch paper
+ */
+
+static int rt_addr = 0;
+static int rt_straddr = 0xFF00 - 2;
+
+uae_u32 addr(int ptr)
+{
+    return (uae_u32)ptr + 0x00F00000;
+}
+
+void db(uae_u8 data)
+{
+    rtarea[rt_addr++] = data;
+}
+
+void dw(uae_u16 data)
+{
+    rtarea[rt_addr++] = data >> 8;
+    rtarea[rt_addr++] = data;
+}
+
+void dl(uae_u32 data)
+{
+    rtarea[rt_addr++] = data >> 24;
+    rtarea[rt_addr++] = data >> 16;
+    rtarea[rt_addr++] = data >> 8;
+    rtarea[rt_addr++] = data;
+}
+
+/* store strings starting at the end of the rt area and working
+ * backward.  store pointer at current address
+ */
+
+uae_u32 ds(char *str)
+{
+    int len = strlen(str) + 1;
+
+    rt_straddr -= len;
+    strcpy((char *)rtarea + rt_straddr, str);
+    
+    return addr(rt_straddr);
+}
+
+void calltrap(uae_u32 n)
+{
+    dw(0x33C0);	/* MOVE.W D0,abs32 */
+    dl(n*2 + trap_base_addr);
+}
+
+void org(uae_u32 a)
+{
+    rt_addr = a - 0x00F00000;
+}
+
+uae_u32 here(void)
+{
+    return addr(rt_addr);
+}
+
+int deftrap2(TrapFunction func, int mode, const char *str)
+{
+    int num = max_trap++;
+    traps[num] = func;
+    trapmode[num] = mode;
+    return num;
+}
+
+int deftrap(TrapFunction func)
+{
+    return deftrap2(func, 0, "");
+}
+
+void align(int b)
+{
+    rt_addr = (rt_addr + (b-1)) & ~(b-1);
+}
+
+static uae_u32 nullfunc(void)
+{
+    fprintf(stderr, "Null function called\n");
+    return 0;
+}
+
+static uae_u32 getchipmemsize (void)
+{
+    return chipmem_size;
+}
+
+void rtarea_init()
+{
+    uae_u32 a;
+    char uaever[100];
+    sprintf(uaever, "uae-%d.%d.%d", (version / 100) % 10, (version / 10) % 10, (version / 1) % 10);
+
+    //rtarea = emu_Malloc(65536);
+
+    EXPANSION_uaeversion = ds(uaever);
+    EXPANSION_explibname = ds("expansion.library");
+    EXPANSION_doslibname = ds("dos.library");
+    EXPANSION_uaedevname = ds("uae.device");
+
+    deftrap(NULL); /* Generic emulator trap */
+
+    EXPANSION_nullfunc = here();
+    calltrap(deftrap(nullfunc));
+    dw(RTS);
+    
+    a = here();
+    /* Standard "return from 68k mode" trap */
+    org(0xF0FF00);
+    calltrap (deftrap2(m68k_mode_return, TRAPFLAG_NO_RETVAL, ""));
+
+    org (0xF0FF80);
+    calltrap (deftrap (getchipmemsize));
+    dw (RTS);
+    org(a);
+    
+    filesys_install_code ();
+}
+
+volatile int uae_int_requested = 0;
+
+void set_uae_int_flag (void)
+{
+    rtarea[0xFFFB] = uae_int_requested;
+}
+

MCUME_teensy/teensyuae41/autoconf.h

@@ -6,19 +6,63 @@
   * (c) 1996 Ed Hanway
   */
 
-typedef ULONG (*TrapFunction)(void);
+typedef uae_u32 (*TrapFunction)(void);
 
-extern ULONG addr(int);
+extern int lasttrap;
-extern void dw(UWORD);
+extern void do_emultrap(int nr);
-extern void dl(ULONG);
+
-extern ULONG ds(char *);
+extern uae_u32 addr(int);
-extern void calltrap(ULONG);
+extern void db(uae_u8);
-extern void org(ULONG);
+extern void dw(uae_u16);
-extern ULONG here(void);
+extern void dl(uae_u32);
+extern uae_u32 ds(char *);
+extern void calltrap(uae_u32);
+extern void org(uae_u32);
+extern uae_u32 here(void);
+extern int deftrap2(TrapFunction func, int mode, const char *str);
 extern int deftrap(TrapFunction);
 extern void align(int);
-extern ULONG CallLib(CPTR base, WORD offset);
+extern uae_u32 CallLib(uaecptr base, uae_s16 offset);
+extern uae_u32 Call68k(uaecptr address, int saveregs);
+extern uae_u32 Call68k_retaddr(uaecptr address, int saveregs, uaecptr);
 
-#define RTS (0x4e75)
+extern volatile int uae_int_requested;
+extern void set_uae_int_flag (void);
 
-extern ULONG explibname;
+#define RTS 0x4e75
+#define RTE 0x4e73
+
+extern uaecptr EXPANSION_explibname, EXPANSION_doslibname, EXPANSION_uaeversion;
+extern uaecptr EXPANSION_explibbase, EXPANSION_uaedevname, EXPANSION_haveV36;
+extern uaecptr EXPANSION_bootcode, EXPANSION_nullfunc;
+
+extern uaecptr ROM_filesys_resname, ROM_filesys_resid;
+extern uaecptr ROM_filesys_diagentry;
+extern uaecptr ROM_hardfile_resname, ROM_hardfile_resid;
+extern uaecptr ROM_hardfile_init;
+extern uaecptr filesys_initcode;
+
+extern void add_filesys_unit(char *volname, char *rootdir, int readonly);
+extern int kill_filesys_unit(char *volname);
+extern int sprintf_filesys_unit(char *buffer, int num);
+extern void write_filesys_config(FILE *f);
+extern void filesys_reset (void);
+extern void filesys_prepare_reset (void);
+extern void filesys_start_threads (void);
+extern int get_new_device(char **devname, uaecptr *devname_amiga);
+
+extern void filesys_install(void);
+extern void filesys_install_code(void);
+extern void filesys_store_devinfo(uae_u8 *);
+extern uae_u32 hardfile_init_late(void);
+extern void hardfile_install(void);
+extern void emulib_install(void);
+extern void trackdisk_install(void);
+extern void expansion_init(void);
+
+#define TRAPFLAG_NO_REGSAVE 1
+#define TRAPFLAG_NO_RETVAL 2
+#define TRAPFLAG_EXTRA_STACK 4
+
+extern uaecptr libemu_InstallFunction(TrapFunction, uaecptr, int, const char *);
+extern uaecptr libemu_InstallFunctionFlags(TrapFunction, uaecptr, int, int, const char *);

MCUME_teensy/teensyuae41/blit.h

@@ -1,518 +1,518 @@
-static __inline__ ULONG blit_func(ULONG srca, ULONG srcb, ULONG srcc, UBYTE mt)
+static __inline__ uae_u32 blit_func(uae_u32 srca, uae_u32 srcb, uae_u32 srcc, uae_u8 mt)
 {
 switch(mt){
 case 0x0:
 	return 0;
 case 0x1:
-	return (~srcc & ~srcb & ~srca);
+	return ~(srcc | srcb | srca);
 case 0x2:
-	return (srcc & ~srcb & ~srca);
+	return (srcc & ~(srcb | srca));
 case 0x3:
-	return (~srcb & ~srca);
+	return ~(srcb | srca);
 case 0x4:
-	return (~srcc & srcb & ~srca);
+	return (srcb & ~(srcc | srca));
 case 0x5:
-	return (~srcc & ~srca);
+	return ~(srcc | srca);
 case 0x6:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb & ~srca);
+	return (~srca & (srcb ^ srcc));
 case 0x7:
-	return (~srcb & ~srca) | (~srcc & ~srca);
+	return ~(srca | (srcc & srcb));
 case 0x8:
 	return (srcc & srcb & ~srca);
 case 0x9:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb & ~srca);
+	return ~(srca | (srcb ^ srcc));
 case 0xa:
 	return (srcc & ~srca);
 case 0xb:
-	return (~srcb & ~srca) | (srcc & ~srca);
+	return ~(srca | (~srcc & srcb));
 case 0xc:
 	return (srcb & ~srca);
 case 0xd:
-	return (~srcc & ~srca) | (srcb & ~srca);
+	return ~(srca | (~srcb & srcc));
 case 0xe:
-	return (srcc & ~srca) | (srcb & ~srca);
+	return (~srca & (srcb | srcc));
 case 0xf:
-	return (~srca);
+	return ~srca;
 case 0x10:
-	return (~srcc & ~srcb & srca);
+	return (srca & ~(srcc | srcb));
 case 0x11:
-	return (~srcc & ~srcb);
+	return ~(srcc | srcb);
 case 0x12:
-	return (srcc & ~srcb & ~srca) | (~srcc & ~srcb & srca);
+	return (~srcb & (srca ^ srcc));
 case 0x13:
-	return (~srcb & ~srca) | (~srcc & ~srcb);
+	return ~(srcb | (srcc & srca));
 case 0x14:
-	return (~srcc & srcb & ~srca) | (~srcc & ~srcb & srca);
+	return (~srcc & (srca ^ srcb));
 case 0x15:
-	return (~srcc & ~srca) | (~srcc & ~srcb);
+	return ~(srcc | (srcb & srca));
 case 0x16:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb & ~srca) | (~srcc & ~srcb & srca);
+	return ((~srca & (srcb ^ srcc)) | ~(srcc | srcb | ~srca));
 case 0x17:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (~srcc & ~srcb);
+	return ~((srcb | srca) & (srcc | (srcb & srca)));
 case 0x18:
-	return (srcc & srcb & ~srca) | (~srcc & ~srcb & srca);
+	return ((srcc & srcb & ~srca) | ~(srcc | srcb | ~srca));
 case 0x19:
-	return (~srcc & ~srcb) | (srcc & srcb & ~srca);
+	return ~((srcc | srcb) & (srca | ~(srcc & srcb)));
 case 0x1a:
-	return (srcc & ~srca) | (~srcc & ~srcb & srca);
+	return ((srcc & ~srca) | ~(srcc | srcb | ~srca));
 case 0x1b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (~srcc & ~srcb);
+	return ~((srcb | (srcc & srca)) & (~srcc | srca));
 case 0x1c:
-	return (srcb & ~srca) | (~srcc & ~srcb & srca);
+	return ((srcb & ~srca) | ~(srcc | srcb | ~srca));
 case 0x1d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (~srcc & ~srcb);
+	return ~((srcc | (srcb & srca)) & (~srcb | srca));
 case 0x1e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcc & ~srcb & srca);
+	return (srca ^ (srcb | srcc));
 case 0x1f:
-	return (~srca) | (~srcc & ~srcb);
+	return ~(srca & (srcc | srcb));
 case 0x20:
 	return (srcc & ~srcb & srca);
 case 0x21:
-	return (~srcc & ~srcb & ~srca) | (srcc & ~srcb & srca);
+	return ~(srcb | (srca ^ srcc));
 case 0x22:
 	return (srcc & ~srcb);
 case 0x23:
-	return (~srcb & ~srca) | (srcc & ~srcb);
+	return ~(srcb | (~srcc & srca));
 case 0x24:
-	return (~srcc & srcb & ~srca) | (srcc & ~srcb & srca);
+	return (~(srcc | ~srcb | srca) | (srcc & ~srcb & srca));
 case 0x25:
-	return (~srcc & ~srca) | (srcc & ~srcb & srca);
+	return ~((srcc | srca) & (srcb | ~(srcc & srca)));
 case 0x26:
-	return (srcc & ~srcb) | (~srcc & srcb & ~srca);
+	return ((srcc & ~srcb) | ~(srcc | ~srcb | srca));
 case 0x27:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcc & ~srcb);
+	return ~((srcb | (~srcc & srca)) & (srcc | srca));
 case 0x28:
-	return (srcc & srcb & ~srca) | (srcc & ~srcb & srca);
+	return (srcc & (srca ^ srcb));
 case 0x29:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb & ~srca) | (srcc & ~srcb & srca);
+	return (~(srcc | srcb | srca) | (srcc & (srca ^ srcb)));
 case 0x2a:
-	return (srcc & ~srca) | (srcc & ~srcb);
+	return (srcc & ~(srcb & srca));
 case 0x2b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (srcc & ~srcb);
+	return (~(srcb | srca) | (srcc & ~(srcb & srca)));
 case 0x2c:
-	return (srcb & ~srca) | (srcc & ~srcb & srca);
+	return ((srcb & ~srca) | (srcc & ~(srcb | ~srca)));
 case 0x2d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (srcc & ~srcb & srca);
+	return (srca ^ (srcb | ~srcc));
 case 0x2e:
-	return (srcc & ~srca) | (srcb & ~srca) | (srcc & ~srcb);
+	return ((srcc & ~(srcb & srca)) | (srcb & ~srca));
 case 0x2f:
-	return (~srca) | (srcc & ~srcb);
+	return ~(srca & (~srcc | srcb));
 case 0x30:
 	return (~srcb & srca);
 case 0x31:
-	return (~srcc & ~srcb) | (~srcb & srca);
+	return ~(srcb | (~srca & srcc));
 case 0x32:
-	return (srcc & ~srcb) | (~srcb & srca);
+	return (~srcb & (srca | srcc));
 case 0x33:
-	return (~srcb);
+	return ~srcb;
 case 0x34:
-	return (~srcc & srcb & ~srca) | (~srcb & srca);
+	return (~(srcc | ~srcb | srca) | (~srcb & srca));
 case 0x35:
-	return (~srcc & ~srca) | (~srcb & srca);
+	return ~((srcc | srca) & (srcb | ~srca));
 case 0x36:
-	return (srcc & ~srcb) | (~srcc & srcb & ~srca) | (~srcb & srca);
+	return (srcb ^ (srca | srcc));
 case 0x37:
-	return (~srcb) | (~srcc & ~srca);
+	return ~(srcb & (srcc | srca));
 case 0x38:
-	return (srcc & srcb & ~srca) | (~srcb & srca);
+	return ((srcc & srcb & ~srca) | ~(srcb | ~srca));
 case 0x39:
-	return (~srcc & ~srcb) | (srcc & srcb & ~srca) | (~srcb & srca);
+	return (srcb ^ (srca | ~srcc));
 case 0x3a:
-	return (srcc & ~srca) | (~srcb & srca);
+	return ((srcc & ~srca) | ~(srcb | ~srca));
 case 0x3b:
-	return (~srcb) | (srcc & ~srca);
+	return ~(srcb & (~srcc | srca));
 case 0x3c:
-	return (srcb & ~srca) | (~srcb & srca);
+	return (srcb ^ srca);
 case 0x3d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (~srcb & srca);
+	return (~(srcc | srca) | (srcb ^ srca));
 case 0x3e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcb & srca);
+	return ((srcc & ~srca) | (srcb ^ srca));
 case 0x3f:
-	return (~srca) | (~srcb);
+	return ~(srca & srcb);
 case 0x40:
 	return (~srcc & srcb & srca);
 case 0x41:
-	return (~srcc & ~srcb & ~srca) | (~srcc & srcb & srca);
+	return ~(srcc | (srca ^ srcb));
 case 0x42:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb & srca);
+	return (~(~srcc | srcb | srca) | (~srcc & srcb & srca));
 case 0x43:
-	return (~srcb & ~srca) | (~srcc & srcb & srca);
+	return ~((srcb | srca) & (srcc | ~(srcb & srca)));
 case 0x44:
 	return (~srcc & srcb);
 case 0x45:
-	return (~srcc & ~srca) | (~srcc & srcb);
+	return ~(srcc | (~srcb & srca));
 case 0x46:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb);
+	return (~(~srcc | srcb | srca) | (~srcc & srcb));
 case 0x47:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (~srcc & srcb);
+	return ~((srcb | srca) & (srcc | (~srcb & srca)));
 case 0x48:
-	return (srcc & srcb & ~srca) | (~srcc & srcb & srca);
+	return (srcb & (srca ^ srcc));
 case 0x49:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb & ~srca) | (~srcc & srcb & srca);
+	return (~(srcc | srcb | srca) | (srcb & (srca ^ srcc)));
 case 0x4a:
-	return (srcc & ~srca) | (~srcc & srcb & srca);
+	return (~(~srcc | srca) | (~srcc & srcb & srca));
 case 0x4b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (~srcc & srcb & srca);
+	return (srca ^ (srcc | ~srcb));
 case 0x4c:
-	return (srcb & ~srca) | (~srcc & srcb);
+	return (srcb & ~(srcc & srca));
 case 0x4d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (~srcc & srcb);
+	return (~(srcc | srca) | (srcb & ~(srcc & srca)));
 case 0x4e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcc & srcb);
+	return ((srcc & ~srca) | (srcb & ~(srcc & srca)));
 case 0x4f:
-	return (~srca) | (~srcc & srcb);
+	return ~(srca & (srcc | ~srcb));
 case 0x50:
 	return (~srcc & srca);
 case 0x51:
-	return (~srcc & ~srcb) | (~srcc & srca);
+	return ~(srcc | (~srca & srcb));
 case 0x52:
-	return (srcc & ~srcb & ~srca) | (~srcc & srca);
+	return (~(~srcc | srcb | srca) | (~srcc & srca));
 case 0x53:
-	return (~srcb & ~srca) | (~srcc & srca);
+	return ~((srcb | srca) & (srcc | ~srca));
 case 0x54:
-	return (~srcc & srcb) | (~srcc & srca);
+	return (~srcc & (srca | srcb));
 case 0x55:
-	return (~srcc);
+	return ~srcc;
 case 0x56:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb) | (~srcc & srca);
+	return (srcc ^ (srcb | srca));
 case 0x57:
-	return (~srcb & ~srca) | (~srcc);
+	return ~((srcb | srca) & srcc);
 case 0x58:
-	return (srcc & srcb & ~srca) | (~srcc & srca);
+	return ((srcc & srcb & ~srca) | ~(srcc | ~srca));
 case 0x59:
-	return (~srcc & ~srcb) | (srcc & srcb & ~srca) | (~srcc & srca);
+	return (srcc ^ (srca | ~srcb));
 case 0x5a:
-	return (srcc & ~srca) | (~srcc & srca);
+	return (srcc ^ srca);
 case 0x5b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (~srcc & srca);
+	return (~(srcb | srca) | (srcc ^ srca));
 case 0x5c:
-	return (srcb & ~srca) | (~srcc & srca);
+	return ((srcb & ~srca) | ~(srcc | ~srca));
 case 0x5d:
-	return (~srcc) | (srcb & ~srca);
+	return ~(srcc & (~srcb | srca));
 case 0x5e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcc & srca);
+	return ((srcb & ~srca) | (srcc ^ srca));
 case 0x5f:
-	return (~srca) | (~srcc);
+	return ~(srca & srcc);
 case 0x60:
-	return (srcc & ~srcb & srca) | (~srcc & srcb & srca);
+	return (srca & (srcb ^ srcc));
 case 0x61:
-	return (~srcc & ~srcb & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb & srca);
+	return (~(srcc | srcb | srca) | (srca & (srcb ^ srcc)));
 case 0x62:
-	return (srcc & ~srcb) | (~srcc & srcb & srca);
+	return (~(~srcc | srcb) | (~srcc & srcb & srca));
 case 0x63:
-	return (~srcb & ~srca) | (srcc & ~srcb) | (~srcc & srcb & srca);
+	return (srcb ^ (srcc | ~srca));
 case 0x64:
-	return (~srcc & srcb) | (srcc & ~srcb & srca);
+	return (~(srcc | ~srcb) | (srcc & ~srcb & srca));
 case 0x65:
-	return (~srcc & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb);
+	return (srcc ^ (srcb | ~srca));
 case 0x66:
-	return (srcc & ~srcb) | (~srcc & srcb);
+	return (srcc ^ srcb);
 case 0x67:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcc & ~srcb) | (~srcc & srcb);
+	return (~(srca | (srcc & srcb)) | (srcc ^ srcb));
 case 0x68:
-	return (srcc & srcb & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb & srca);
+	return ((srcc & (srca ^ srcb)) | (~srcc & srcb & srca));
 case 0x69:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb & srca);
+	return ~(srcc ^ srca ^ srcb);
 case 0x6a:
-	return (srcc & ~srca) | (srcc & ~srcb) | (~srcc & srcb & srca);
+	return (srcc ^ (srca & srcb));
 case 0x6b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (srcc & ~srcb) | (~srcc & srcb & srca);
+	return (~(srcb | srca) | (srcc ^ (srca & srcb)));
 case 0x6c:
-	return (srcb & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb);
+	return (srcb ^ (srca & srcc));
 case 0x6d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (srcc & ~srcb & srca) | (~srcc & srcb);
+	return (~(srcc | srca) | (srcb ^ (srca & srcc)));
 case 0x6e:
-	return (srcc & ~srca) | (srcb & ~srca) | (srcc & ~srcb) | (~srcc & srcb);
+	return ((~srca & (srcb | srcc)) | (srcc ^ srcb));
 case 0x6f:
-	return (~srca) | (srcc & ~srcb) | (~srcc & srcb);
+	return (~srca | (srcc ^ srcb));
 case 0x70:
-	return (~srcb & srca) | (~srcc & srca);
+	return (srca & ~(srcc & srcb));
 case 0x71:
-	return (~srcc & ~srcb) | (~srcb & srca) | (~srcc & srca);
+	return (~(srcc | srcb) | (srca & ~(srcc & srcb)));
 case 0x72:
-	return (srcc & ~srcb) | (~srcb & srca) | (~srcc & srca);
+	return ((srcc & ~srcb) | (srca & ~(srcc & srcb)));
 case 0x73:
-	return (~srcb) | (~srcc & srca);
+	return ~(srcb & (srcc | ~srca));
 case 0x74:
-	return (~srcc & srcb) | (~srcb & srca);
+	return (~(srcc | ~srcb) | (~srcb & srca));
 case 0x75:
-	return (~srcc) | (~srcb & srca);
+	return ~(srcc & (srcb | ~srca));
 case 0x76:
-	return (srcc & ~srcb) | (~srcc & srcb) | (~srcb & srca);
+	return ((~srcb & srca) | (srcc ^ srcb));
 case 0x77:
-	return (~srcb) | (~srcc);
+	return ~(srcb & srcc);
 case 0x78:
-	return (srcc & srcb & ~srca) | (~srcb & srca) | (~srcc & srca);
+	return (srca ^ (srcb & srcc));
 case 0x79:
-	return (~srcc & ~srcb) | (srcc & srcb & ~srca) | (~srcb & srca) | (~srcc & srca);
+	return (~(srcc | srcb) | (srca ^ (srcb & srcc)));
 case 0x7a:
-	return (srcc & ~srca) | (~srcb & srca) | (~srcc & srca);
+	return ((~srcb & srca) | (srcc ^ srca));
 case 0x7b:
-	return (~srcb) | (srcc & ~srca) | (~srcc & srca);
+	return (~srcb | (srcc ^ srca));
 case 0x7c:
-	return (srcb & ~srca) | (~srcb & srca) | (~srcc & srca);
+	return ((~srcc & srca) | (srcb ^ srca));
 case 0x7d:
-	return (~srcc) | (srcb & ~srca) | (~srcb & srca);
+	return (~srcc | (srcb ^ srca));
 case 0x7e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcb & srca) | (~srcc & srca);
+	return ((~srca & (srcb | srcc)) | ~(~srca | (srcc & srcb)));
 case 0x7f:
-	return (~srca) | (~srcb) | (~srcc);
+	return ~(srca & srcb & srcc);
 case 0x80:
 	return (srcc & srcb & srca);
 case 0x81:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb & srca);
+	return (~(srcc | srcb | srca) | (srcc & srcb & srca));
 case 0x82:
-	return (srcc & ~srcb & ~srca) | (srcc & srcb & srca);
+	return (srcc & ~(srca ^ srcb));
 case 0x83:
-	return (~srcb & ~srca) | (srcc & srcb & srca);
+	return (~(srcb | srca) | (srcc & srcb & srca));
 case 0x84:
-	return (~srcc & srcb & ~srca) | (srcc & srcb & srca);
+	return (srcb & ~(srca ^ srcc));
 case 0x85:
-	return (~srcc & ~srca) | (srcc & srcb & srca);
+	return (~(srcc | srca) | (srcc & srcb & srca));
 case 0x86:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb & ~srca) | (srcc & srcb & srca);
+	return ((~srca & (srcb ^ srcc)) | (srcc & srcb & srca));
 case 0x87:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcc & srcb & srca);
+	return ~(srca ^ (srcb & srcc));
 case 0x88:
 	return (srcc & srcb);
 case 0x89:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb);
+	return (~(srcc | srcb | srca) | (srcc & srcb));
 case 0x8a:
-	return (srcc & ~srca) | (srcc & srcb);
+	return (srcc & (srcb | ~srca));
 case 0x8b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (srcc & srcb);
+	return (~(srca | (~srcc & srcb)) | (srcc & srcb));
 case 0x8c:
-	return (srcb & ~srca) | (srcc & srcb);
+	return (srcb & (srcc | ~srca));
 case 0x8d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (srcc & srcb);
+	return (~(srca | (~srcb & srcc)) | (srcc & srcb));
 case 0x8e:
-	return (srcc & ~srca) | (srcb & ~srca) | (srcc & srcb);
+	return ((srcc & ~srca) | (srcb & (srcc | ~srca)));
 case 0x8f:
-	return (~srca) | (srcc & srcb);
+	return (~srca | (srcc & srcb));
 case 0x90:
-	return (~srcc & ~srcb & srca) | (srcc & srcb & srca);
+	return (srca & ~(srcb ^ srcc));
 case 0x91:
-	return (~srcc & ~srcb) | (srcc & srcb & srca);
+	return (~(srcc | srcb) | (srcc & srcb & srca));
 case 0x92:
-	return (srcc & ~srcb & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb & srca);
+	return ((~srcb & (srca ^ srcc)) | (srcc & srcb & srca));
 case 0x93:
-	return (~srcb & ~srca) | (~srcc & ~srcb) | (srcc & srcb & srca);
+	return ~(srcb ^ (srca & srcc));
 case 0x94:
-	return (~srcc & srcb & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb & srca);
+	return ((~srcc & (srca ^ srcb)) | (srcc & srcb & srca));
 case 0x95:
-	return (~srcc & ~srca) | (~srcc & ~srcb) | (srcc & srcb & srca);
+	return ~(srcc ^ (srca & srcb));
 case 0x96:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb & srca);
+	return (srcc ^ srca ^ srcb);
 case 0x97:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (~srcc & ~srcb) | (srcc & srcb & srca);
+	return ~((srcb | srca) & (srcc ^ (srca & srcb)));
 case 0x98:
-	return (srcc & srcb) | (~srcc & ~srcb & srca);
+	return ((srcc & srcb) | (srca & ~(srcc | srcb)));
 case 0x99:
-	return (~srcc & ~srcb) | (srcc & srcb);
+	return ~(srcc ^ srcb);
 case 0x9a:
-	return (srcc & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb);
+	return (srcc ^ (srca & ~srcb));
 case 0x9b:
-	return (~srcb & ~srca) | (srcc & ~srca) | (~srcc & ~srcb) | (srcc & srcb);
+	return ~((srca | (~srcc & srcb)) & (srcc ^ srcb));
 case 0x9c:
-	return (srcb & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb);
+	return (srcb ^ (srca & ~srcc));
 case 0x9d:
-	return (~srcc & ~srca) | (srcb & ~srca) | (~srcc & ~srcb) | (srcc & srcb);
+	return ~((srca | (~srcb & srcc)) & (srcc ^ srcb));
 case 0x9e:
-	return (srcc & ~srca) | (srcb & ~srca) | (~srcc & ~srcb & srca) | (srcc & srcb);
+	return ((srcc & srcb) | (srca ^ (srcb | srcc)));
 case 0x9f:
-	return (~srca) | (~srcc & ~srcb) | (srcc & srcb);
+	return ~(srca & (srcc ^ srcb));
 case 0xa0:
 	return (srcc & srca);
 case 0xa1:
-	return (~srcc & ~srcb & ~srca) | (srcc & srca);
+	return (~(srcc | srcb | srca) | (srcc & srca));
 case 0xa2:
-	return (srcc & ~srcb) | (srcc & srca);
+	return (srcc & (srca | ~srcb));
 case 0xa3:
-	return (~srcb & ~srca) | (srcc & srca);
+	return (~(srcb | srca) | (srcc & srca));
 case 0xa4:
-	return (~srcc & srcb & ~srca) | (srcc & srca);
+	return ((srcb & ~(srcc | srca)) | (srcc & srca));
 case 0xa5:
-	return (~srcc & ~srca) | (srcc & srca);
+	return ~(srcc ^ srca);
 case 0xa6:
-	return (srcc & ~srcb) | (~srcc & srcb & ~srca) | (srcc & srca);
+	return (srcc ^ (srcb & ~srca));
 case 0xa7:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcc & srca);
+	return ~((srcb | srca) & (srcc ^ srca));
 case 0xa8:
-	return (srcc & srcb) | (srcc & srca);
+	return (srcc & (srca | srcb));
 case 0xa9:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb) | (srcc & srca);
+	return ~(srcc ^ (srcb | srca));
 case 0xaa:
-	return (srcc);
+	return srcc;
 case 0xab:
-	return (~srcb & ~srca) | (srcc);
+	return (~(srcb | srca) | srcc);
 case 0xac:
-	return (srcb & ~srca) | (srcc & srca);
+	return ((srcb & ~srca) | (srcc & srca));
 case 0xad:
-	return (~srcc & ~srca) | (srcb & ~srca) | (srcc & srca);
+	return ((srcb & ~srca) | (srcc ^ ~srca));
 case 0xae:
-	return (srcc) | (srcb & ~srca);
+	return (srcc | (srcb & ~srca));
 case 0xaf:
-	return (~srca) | (srcc);
+	return (~srca | srcc);
 case 0xb0:
-	return (~srcb & srca) | (srcc & srca);
+	return (srca & (srcc | ~srcb));
 case 0xb1:
-	return (~srcc & ~srcb) | (~srcb & srca) | (srcc & srca);
+	return (~(srcb | (~srca & srcc)) | (srcc & srca));
 case 0xb2:
-	return (srcc & ~srcb) | (~srcb & srca) | (srcc & srca);
+	return ((srcc & ~srcb) | (srca & (srcc | ~srcb)));
 case 0xb3:
-	return (~srcb) | (srcc & srca);
+	return (~srcb | (srcc & srca));
 case 0xb4:
-	return (~srcc & srcb & ~srca) | (~srcb & srca) | (srcc & srca);
+	return (srca ^ (srcb & ~srcc));
 case 0xb5:
-	return (~srcc & ~srca) | (~srcb & srca) | (srcc & srca);
+	return ~((srcb | ~srca) & (srcc ^ srca));
 case 0xb6:
-	return (srcc & ~srcb) | (~srcc & srcb & ~srca) | (~srcb & srca) | (srcc & srca);
+	return ((srcc & srca) | (srcb ^ (srca | srcc)));
 case 0xb7:
-	return (~srcb) | (~srcc & ~srca) | (srcc & srca);
+	return ~(srcb & (srcc ^ srca));
 case 0xb8:
-	return (srcc & srcb) | (~srcb & srca);
+	return ((srcc & srcb) | (~srcb & srca));
 case 0xb9:
-	return (~srcc & ~srcb) | (srcc & srcb) | (~srcb & srca);
+	return ((~srcb & srca) | (srcc ^ ~srcb));
 case 0xba:
-	return (srcc) | (~srcb & srca);
+	return (srcc | (~srcb & srca));
 case 0xbb:
-	return (~srcb) | (srcc);
+	return (~srcb | srcc);
 case 0xbc:
-	return (srcb & ~srca) | (~srcb & srca) | (srcc & srca);
+	return ((srcc & srca) | (srcb ^ srca));
 case 0xbd:
-	return (~srcc & ~srca) | (srcb & ~srca) | (~srcb & srca) | (srcc & srca);
+	return (~(srcc | srca) | (srcc & srca) | (srcb ^ srca));
 case 0xbe:
-	return (srcc) | (srcb & ~srca) | (~srcb & srca);
+	return (srcc | (srcb ^ srca));
 case 0xbf:
-	return (~srca) | (~srcb) | (srcc);
+	return (srcc | ~(srca & srcb));
 case 0xc0:
 	return (srcb & srca);
 case 0xc1:
-	return (~srcc & ~srcb & ~srca) | (srcb & srca);
+	return (~(srcc | srcb | srca) | (srcb & srca));
 case 0xc2:
-	return (srcc & ~srcb & ~srca) | (srcb & srca);
+	return ((srcc & ~(srcb | srca)) | (srcb & srca));
 case 0xc3:
-	return (~srcb & ~srca) | (srcb & srca);
+	return ~(srcb ^ srca);
 case 0xc4:
-	return (~srcc & srcb) | (srcb & srca);
+	return (srcb & (srca | ~srcc));
 case 0xc5:
-	return (~srcc & ~srca) | (srcb & srca);
+	return (~(srcc | srca) | (srcb & srca));
 case 0xc6:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb) | (srcb & srca);
+	return (srcb ^ (~srca & srcc));
 case 0xc7:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcb & srca);
+	return ~((srcc | srca) & (srcb ^ srca));
 case 0xc8:
-	return (srcc & srcb) | (srcb & srca);
+	return (srcb & (srca | srcc));
 case 0xc9:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb) | (srcb & srca);
+	return ~(srcb ^ (srcc | srca));
 case 0xca:
-	return (srcc & ~srca) | (srcb & srca);
+	return ((srcc & ~srca) | (srcb & srca));
 case 0xcb:
-	return (~srcb & ~srca) | (srcc & ~srca) | (srcb & srca);
+	return ((srcc & ~srca) | (srcb ^ ~srca));
 case 0xcc:
-	return (srcb);
+	return srcb;
 case 0xcd:
-	return (~srcc & ~srca) | (srcb);
+	return (~(srcc | srca) | srcb);
 case 0xce:
-	return (srcc & ~srca) | (srcb);
+	return ((srcc & ~srca) | srcb);
 case 0xcf:
-	return (~srca) | (srcb);
+	return (~srca | srcb);
 case 0xd0:
-	return (~srcc & srca) | (srcb & srca);
+	return (srca & (srcb | ~srcc));
 case 0xd1:
-	return (~srcc & ~srcb) | (srcb & srca);
+	return (~(srcc | srcb) | (srcb & srca));
 case 0xd2:
-	return (srcc & ~srcb & ~srca) | (~srcc & srca) | (srcb & srca);
+	return (srca ^ (~srcb & srcc));
 case 0xd3:
-	return (~srcb & ~srca) | (~srcc & srca) | (srcb & srca);
+	return ~((srcc | ~srca) & (srcb ^ srca));
 case 0xd4:
-	return (~srcc & srcb) | (~srcc & srca) | (srcb & srca);
+	return ((~srcc & srcb) | (srca & (srcb | ~srcc)));
 case 0xd5:
-	return (~srcc) | (srcb & srca);
+	return (~srcc | (srcb & srca));
 case 0xd6:
-	return (srcc & ~srcb & ~srca) | (~srcc & srcb) | (~srcc & srca) | (srcb & srca);
+	return ((srcb & srca) | (srcc ^ (srcb | srca)));
 case 0xd7:
-	return (~srcb & ~srca) | (~srcc) | (srcb & srca);
+	return ~(srcc & (srcb ^ srca));
 case 0xd8:
-	return (srcc & srcb) | (~srcc & srca);
+	return ((srcc & srcb) | (~srcc & srca));
 case 0xd9:
-	return (~srcc & ~srcb) | (srcc & srcb) | (srcb & srca);
+	return ((srcb & srca) | ~(srcc ^ srcb));
 case 0xda:
-	return (srcc & ~srca) | (~srcc & srca) | (srcb & srca);
+	return ((srcb & srca) | (srcc ^ srca));
 case 0xdb:
-	return (~srcb & ~srca) | (srcc & ~srca) | (~srcc & srca) | (srcb & srca);
+	return (~(srcb | srca) | (srcb & srca) | (srcc ^ srca));
 case 0xdc:
-	return (srcb) | (~srcc & srca);
+	return (srcb | (~srcc & srca));
 case 0xdd:
-	return (~srcc) | (srcb);
+	return (~srcc | srcb);
 case 0xde:
-	return (srcc & ~srca) | (srcb) | (~srcc & srca);
+	return (srcb | (srcc ^ srca));
 case 0xdf:
-	return (~srca) | (~srcc) | (srcb);
+	return (srcb | ~(srca & srcc));
 case 0xe0:
-	return (srcc & srca) | (srcb & srca);
+	return (srca & (srcb | srcc));
 case 0xe1:
-	return (~srcc & ~srcb & ~srca) | (srcc & srca) | (srcb & srca);
+	return ~(srca ^ (srcc | srcb));
 case 0xe2:
-	return (srcc & ~srcb) | (srcb & srca);
+	return ((srcc & ~srcb) | (srcb & srca));
 case 0xe3:
-	return (~srcb & ~srca) | (srcc & srca) | (srcb & srca);
+	return ((srcc & srca) | ~(srcb ^ srca));
 case 0xe4:
-	return (~srcc & srcb) | (srcc & srca);
+	return ((~srcc & srcb) | (srcc & srca));
 case 0xe5:
-	return (~srcc & ~srca) | (srcc & srca) | (srcb & srca);
+	return ((srcb & srca) | ~(srcc ^ srca));
 case 0xe6:
-	return (srcc & ~srcb) | (~srcc & srcb) | (srcb & srca);
+	return ((srcb & srca) | (srcc ^ srcb));
 case 0xe7:
-	return (~srcb & ~srca) | (~srcc & ~srca) | (srcc & srca) | (srcb & srca);
+	return (~(srca | (srcc & srcb)) | (srca & (srcb | srcc)));
 case 0xe8:
-	return (srcc & srcb) | (srcc & srca) | (srcb & srca);
+	return ((srcc & srcb) | (srca & (srcb | srcc)));
 case 0xe9:
-	return (~srcc & ~srcb & ~srca) | (srcc & srcb) | (srcc & srca) | (srcb & srca);
+	return ((srcc & srcb) | ~(srca ^ (srcc | srcb)));
 case 0xea:
-	return (srcc) | (srcb & srca);
+	return (srcc | (srcb & srca));
 case 0xeb:
-	return (~srcb & ~srca) | (srcc) | (srcb & srca);
+	return (srcc | ~(srcb ^ srca));
 case 0xec:
-	return (srcb) | (srcc & srca);
+	return (srcb | (srcc & srca));
 case 0xed:
-	return (~srcc & ~srca) | (srcb) | (srcc & srca);
+	return (srcb | ~(srcc ^ srca));
 case 0xee:
-	return (srcc) | (srcb);
+	return (srcc | srcb);
 case 0xef:
-	return (~srca) | (srcc) | (srcb);
+	return (~srca | srcc | srcb);
 case 0xf0:
-	return (srca);
+	return srca;
 case 0xf1:
-	return (~srcc & ~srcb) | (srca);
+	return (~(srcc | srcb) | srca);
 case 0xf2:
-	return (srcc & ~srcb) | (srca);
+	return ((srcc & ~srcb) | srca);
 case 0xf3:
-	return (~srcb) | (srca);
+	return (~srcb | srca);
 case 0xf4:
-	return (~srcc & srcb) | (srca);
+	return ((~srcc & srcb) | srca);
 case 0xf5:
-	return (~srcc) | (srca);
+	return (~srcc | srca);
 case 0xf6:
-	return (srcc & ~srcb) | (~srcc & srcb) | (srca);
+	return (srca | (srcc ^ srcb));
 case 0xf7:
-	return (~srcb) | (~srcc) | (srca);
+	return (srca | ~(srcb & srcc));
 case 0xf8:
-	return (srcc & srcb) | (srca);
+	return ((srcc & srcb) | srca);
 case 0xf9:
-	return (~srcc & ~srcb) | (srcc & srcb) | (srca);
+	return (srca | ~(srcc ^ srcb));
 case 0xfa:
-	return (srcc) | (srca);
+	return (srcc | srca);
 case 0xfb:
-	return (~srcb) | (srcc) | (srca);
+	return (~srcb | srcc | srca);
 case 0xfc:
-	return (srcb) | (srca);
+	return (srcb | srca);
 case 0xfd:
-	return (~srcc) | (srcb) | (srca);
+	return (~srcc | srcb | srca);
 case 0xfe:
-	return (srcc) | (srcb) | (srca);
+	return (srcc | srcb | srca);
 case 0xff:
-	return 0xFFFF;
+	return 0xFFFFFFFF;
 }
 return 0;
 }

MCUME_teensy/teensyuae41/blittable.c

@@ -1,6 +1,8 @@
 #include "shared.h"
 
 #include "custom.h"
+#include "memory.h"
+#include "blitter.h"
 #include "blitfunc.h"
 
 #include "arduinoproto.h"

MCUME_teensy/teensyuae41/blitter.c

@@ -0,0 +1,464 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * Custom chip emulation
+  * 
+  * (c) 1995 Bernd Schmidt, Alessandro Bissacco
+  */
+
+#include "shared.h"
+
+#include "gensound.h"
+#include "sounddep/sound.h"
+#include "events.h"
+#include "uae.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "blitter.h"
+#include "blit.h"
+
+uae_u16 bltsize, oldvblts;
+uae_u16 bltcon0,bltcon1;
+uae_u32 bltapt,bltbpt,bltcpt,bltdpt;
+
+int blinea_shift;
+static uae_u16 blitlpos, blinea, blineb;
+static uaecptr bltcnxlpt,bltdnxlpt;
+static int blitline,blitfc,blitfill,blitife,blitdesc,blitsing;
+static int blitonedot,blitsign;
+static long int bltwait;
+
+struct bltinfo blt_info;
+
+static uae_u8 blit_filltable[256][4][2];
+uae_u32 blit_masktable[BLITTER_MAX_WORDS];
+static uae_u16 blit_trashtable[BLITTER_MAX_WORDS];
+enum blitter_states bltstate;
+
+void build_blitfilltable(void)
+{
+    unsigned int d, fillmask;
+    int i;
+    
+    for (i = 0; i < BLITTER_MAX_WORDS; i++)
+	blit_masktable[i] = 0xFFFF;
+    
+    for (d = 0; d < 256; d++) {
+	for (i = 0; i < 4; i++) {
+	    int fc = i & 1;
+	    uae_u8 data = d;
+	    for (fillmask = 1; fillmask != 0x100; fillmask <<= 1) {
+		uae_u16 tmp = data;
+		if (fc) {
+		    if (i & 2)
+			data |= fillmask;
+		    else
+			data ^= fillmask;
+		}
+		if (tmp & fillmask) fc = !fc;
+	    }
+	    blit_filltable[d][i][0] = data;
+	    blit_filltable[d][i][1] = fc;
+	}
+    }
+}
+
+static __inline__ uae_u8 *blit_xlateptr(uaecptr bltpt, int bytecount)
+{
+    if (!chipmem_bank.check(bltpt,bytecount)) return NULL;
+    return chipmem_bank.xlateaddr(bltpt);
+}
+
+static __inline__ uae_u8 *blit_xlateptr_desc(uaecptr bltpt, int bytecount)
+{
+    if (!chipmem_bank.check(bltpt-bytecount, bytecount)) return NULL;
+    return chipmem_bank.xlateaddr(bltpt);
+}
+
+static void blitter_dofast(void) 
+{
+    int i,j;
+    uae_u8 *bltadatpt = 0, *bltbdatpt = 0, *bltcdatpt = 0, *bltddatpt = 0;
+    uae_u8 mt = bltcon0 & 0xFF;
+    
+    blit_masktable[0] = blt_info.bltafwm;
+    blit_masktable[blt_info.hblitsize - 1] &= blt_info.bltalwm;
+    
+    if (bltcon0 & 0x800) {
+	bltadatpt = blit_xlateptr(bltapt, (blt_info.hblitsize*2+blt_info.bltamod)*blt_info.vblitsize);
+	bltapt += (blt_info.hblitsize*2+blt_info.bltamod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x400) {
+	bltbdatpt = blit_xlateptr(bltbpt, (blt_info.hblitsize*2+blt_info.bltbmod)*blt_info.vblitsize);
+	bltbpt += (blt_info.hblitsize*2+blt_info.bltbmod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x200) {
+	bltcdatpt = blit_xlateptr(bltcpt, (blt_info.hblitsize*2+blt_info.bltcmod)*blt_info.vblitsize);
+	bltcpt += (blt_info.hblitsize*2+blt_info.bltcmod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x100) {
+	bltddatpt = blit_xlateptr(bltdpt, (blt_info.hblitsize*2+blt_info.bltdmod)*blt_info.vblitsize);
+	bltdpt += (blt_info.hblitsize*2+blt_info.bltdmod)*blt_info.vblitsize;
+    }
+    
+    if (blitfunc_dofast[mt] && !blitfill) 
+        (*blitfunc_dofast[mt])(bltadatpt,bltbdatpt,bltcdatpt,bltddatpt,&blt_info);
+    else {
+	uae_u32 blitbhold = blt_info.bltbhold;
+	uae_u32 preva = 0, prevb = 0;
+
+	/*if (!blitfill) fprintf(stderr, "minterm %x not present\n",mt); */
+        for (j = 0; j < blt_info.vblitsize; j++) {
+	    blitfc = !!(bltcon1 & 0x4);
+	    for (i = 0; i < blt_info.hblitsize; i++) {
+		uae_u32 bltadat, blitahold;
+	        if (bltadatpt) {
+		    bltadat = do_get_mem_word((uae_u16 *)bltadatpt); bltadatpt += 2;
+		} else
+		    bltadat = blt_info.bltadat;
+		bltadat &= blit_masktable[i];
+		blitahold = (((uae_u32)preva << 16) | bltadat) >> blt_info.blitashift;
+		preva = bltadat;
+
+	        if (bltbdatpt) {
+		    uae_u16 bltbdat = do_get_mem_word((uae_u16 *)bltbdatpt); bltbdatpt += 2;
+		    blitbhold = (((uae_u32)prevb << 16) | bltbdat) >> blt_info.blitbshift;
+		    prevb = bltbdat;
+		}
+		if (bltcdatpt) {
+		    blt_info.bltcdat = do_get_mem_word((uae_u16 *)bltcdatpt); bltcdatpt += 2; 
+		}
+	        blt_info.bltddat = blit_func(blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
+	        if (blitfill) {
+		    uae_u16 d = blt_info.bltddat;
+		    int ifemode = blitife ? 2 : 0;
+		    int fc1 = blit_filltable[d & 255][ifemode + blitfc][1];
+		    blt_info.bltddat = (blit_filltable[d & 255][ifemode + blitfc][0] 
+					+ (blit_filltable[d >> 8][ifemode + fc1][0] << 8));
+		    blitfc = blit_filltable[d >> 8][ifemode + fc1][1];
+		}
+	        if (blt_info.bltddat) blt_info.blitzero = 0;
+	        if (bltddatpt) {
+		    do_put_mem_word((uae_u16 *)bltddatpt, blt_info.bltddat);
+		    bltddatpt += 2;
+		}
+	    }
+	    if (bltadatpt) bltadatpt += blt_info.bltamod;
+	    if (bltbdatpt) bltbdatpt += blt_info.bltbmod;
+	    if (bltcdatpt) bltcdatpt += blt_info.bltcmod;
+	    if (bltddatpt) bltddatpt += blt_info.bltdmod;
+        }
+	blt_info.bltbhold = blitbhold;
+    }
+    blit_masktable[0] = 0xFFFF;
+    blit_masktable[blt_info.hblitsize - 1] = 0xFFFF;
+    
+    bltstate = BLT_done;
+}
+
+static void blitter_dofast_desc(void) 
+{
+    int i,j;
+    uae_u8 *bltadatpt = 0, *bltbdatpt = 0, *bltcdatpt = 0, *bltddatpt = 0;
+    uae_u8 mt = bltcon0 & 0xFF;
+    
+    blit_masktable[0] = blt_info.bltafwm;
+    blit_masktable[blt_info.hblitsize - 1] &= blt_info.bltalwm;
+    
+    if (bltcon0 & 0x800) {
+	bltadatpt = blit_xlateptr_desc(bltapt, (blt_info.hblitsize*2+blt_info.bltamod)*blt_info.vblitsize);
+	bltapt -= (blt_info.hblitsize*2+blt_info.bltamod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x400) {
+	bltbdatpt = blit_xlateptr_desc(bltbpt, (blt_info.hblitsize*2+blt_info.bltbmod)*blt_info.vblitsize);
+	bltbpt -= (blt_info.hblitsize*2+blt_info.bltbmod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x200) {
+	bltcdatpt = blit_xlateptr_desc(bltcpt, (blt_info.hblitsize*2+blt_info.bltcmod)*blt_info.vblitsize);
+	bltcpt -= (blt_info.hblitsize*2+blt_info.bltcmod)*blt_info.vblitsize;
+    }
+    if (bltcon0 & 0x100) {
+	bltddatpt = blit_xlateptr_desc(bltdpt, (blt_info.hblitsize*2+blt_info.bltdmod)*blt_info.vblitsize);
+	bltdpt -= (blt_info.hblitsize*2+blt_info.bltdmod)*blt_info.vblitsize;
+    }
+    if (blitfunc_dofast_desc[mt] && !blitfill) 
+	(*blitfunc_dofast_desc[mt])(bltadatpt,bltbdatpt,bltcdatpt,bltddatpt,&blt_info);
+    else {
+	uae_u32 blitbhold = blt_info.bltbhold;
+	uae_u32 preva = 0, prevb = 0;
+
+/*	if (!blitfill) fprintf(stderr, "minterm %x not present\n",mt);*/
+        for (j = 0; j < blt_info.vblitsize; j++) {
+	    blitfc = !!(bltcon1 & 0x4);
+	    for (i = 0; i < blt_info.hblitsize; i++) {
+		uae_u32 bltadat, blitahold;
+	        if (bltadatpt) {
+		    bltadat = do_get_mem_word((uae_u16 *)bltadatpt); bltadatpt -= 2;
+		} else
+		    bltadat = blt_info.bltadat;
+		bltadat &= blit_masktable[i];
+		blitahold = (((uae_u32)bltadat << 16) | preva) >> blt_info.blitdownashift;
+		preva = bltadat;
+	        if (bltbdatpt) {
+		    uae_u16 bltbdat = do_get_mem_word((uae_u16 *)bltbdatpt); bltbdatpt -= 2;
+		    blitbhold = (((uae_u32)bltbdat << 16) | prevb) >> blt_info.blitdownbshift;
+		    prevb = bltbdat;
+		}
+		if (bltcdatpt) {
+		    blt_info.bltcdat = do_get_mem_word((uae_u16 *)bltcdatpt); bltcdatpt -= 2; 
+		}
+	        blt_info.bltddat = blit_func(blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
+	        if (blitfill) {
+		    uae_u16 d = blt_info.bltddat;
+		    int ifemode = blitife ? 2 : 0;
+		    int fc1 = blit_filltable[d & 255][ifemode + blitfc][1];
+		    blt_info.bltddat = (blit_filltable[d & 255][ifemode + blitfc][0]
+					+ (blit_filltable[d >> 8][ifemode + fc1][0] << 8));
+		    blitfc = blit_filltable[d >> 8][ifemode + fc1][1];
+		}
+	        if (blt_info.bltddat) blt_info.blitzero = 0;
+	        if (bltddatpt) {
+		    do_put_mem_word((uae_u16 *)bltddatpt, blt_info.bltddat);
+		    bltddatpt -= 2;
+		}
+	    }
+	    if (bltadatpt) bltadatpt -= blt_info.bltamod;
+	    if (bltbdatpt) bltbdatpt -= blt_info.bltbmod;
+	    if (bltcdatpt) bltcdatpt -= blt_info.bltcmod;
+	    if (bltddatpt) bltddatpt -= blt_info.bltdmod;
+        }
+	blt_info.bltbhold = blitbhold;
+    }
+    blit_masktable[0] = 0xFFFF;
+    blit_masktable[blt_info.hblitsize - 1] = 0xFFFF;
+
+    bltstate = BLT_done;
+}
+
+static __inline__ int blitter_read(void)
+{
+    if (bltcon0 & 0xe00){
+	if (!dmaen(DMA_BLITTER)) return 1; /* blitter stopped */
+	if (bltcon0 & 0x200) blt_info.bltcdat = chipmem_bank.wget(bltcpt);
+    }
+    bltstate = BLT_work;
+    return (bltcon0 & 0xE00) != 0;
+}
+
+static __inline__ int blitter_write(void)
+{
+    if (blt_info.bltddat) blt_info.blitzero = 0;
+    if ((bltcon0 & 0x100) || blitline){
+	if (!dmaen(DMA_BLITTER)) return 1;
+	chipmem_bank.wput(bltdpt, blt_info.bltddat);
+    }
+    bltstate = BLT_next;
+    return (bltcon0 & 0x100) != 0;
+}
+
+static __inline__ void blitter_line_incx(void)
+{
+    if (++blinea_shift == 16) {
+	blinea_shift = 0;
+	bltcnxlpt += 2;
+	bltdnxlpt += 2;
+    }
+}
+
+static __inline__ void blitter_line_decx(void)
+{
+    if (blinea_shift-- == 0) {
+	blinea_shift = 15;
+	bltcnxlpt -= 2;
+	bltdnxlpt -= 2;
+    }
+}
+
+static __inline__ void blitter_line_decy(void)
+{
+    bltcnxlpt -= blt_info.bltcmod;
+    bltdnxlpt -= blt_info.bltcmod; /* ??? am I wrong or doesn't KS1.3 set bltdmod? */
+    blitonedot = 0;
+}
+
+static __inline__ void blitter_line_incy(void)
+{
+    bltcnxlpt += blt_info.bltcmod;
+    bltdnxlpt += blt_info.bltcmod; /* ??? */
+    blitonedot = 0;
+}
+
+static void blitter_line(void)
+{
+    uae_u16 blitahold = blinea >> blinea_shift, blitbhold = blineb & 1 ? 0xFFFF : 0, blitchold = blt_info.bltcdat;
+    blt_info.bltddat = 0;
+    
+    if (blitsing && blitonedot) blitahold = 0;
+    blitonedot = 1;
+    blt_info.bltddat = blit_func(blitahold, blitbhold, blitchold, bltcon0 & 0xFF);
+    if (!blitsign){
+	bltapt += (uae_s16)blt_info.bltamod;
+	if (bltcon1 & 0x10){
+	    if (bltcon1 & 0x8)
+	    	blitter_line_decy();
+	    else
+	    	blitter_line_incy();
+	} else {
+	    if (bltcon1 & 0x8)
+	    	blitter_line_decx();
+	    else 
+	    	blitter_line_incx();
+	}
+    } else {
+	bltapt += (uae_s16)blt_info.bltbmod;
+    }
+    if (bltcon1 & 0x10){
+	if (bltcon1 & 0x4)
+	    blitter_line_decx();
+	else
+	    blitter_line_incx();
+    } else {
+	if (bltcon1 & 0x4)
+	    blitter_line_decy();
+	else
+	    blitter_line_incy();
+    }
+    blitsign = 0 > (uae_s16)bltapt;
+    bltstate = BLT_write;
+}
+
+static __inline__ void blitter_nxline(void)
+{
+    bltcpt = bltcnxlpt;
+    bltdpt = bltdnxlpt;
+    blineb = (blineb << 1) | (blineb >> 15);
+    if (--blt_info.vblitsize == 0) {
+	bltstate = BLT_done;
+    } else {
+	bltstate = BLT_read;
+    }
+}
+
+static void blit_init(void)
+{
+    blitlpos = 0;
+    blt_info.blitzero = 1; 
+    blitline = bltcon1 & 1;
+    blt_info.blitashift = bltcon0 >> 12; 
+    blt_info.blitdownashift = 16 - blt_info.blitashift;
+    blt_info.blitbshift = bltcon1 >> 12;
+    blt_info.blitdownbshift = 16 - blt_info.blitbshift;
+    
+    if (blitline) {
+	if (blt_info.hblitsize != 2) {
+	    //sprintf (warning_buffer, "weird hblitsize in linemode: %d\n", blt_info.hblitsize);
+	    //write_log (warning_buffer);
+	}
+	bltcnxlpt = bltcpt;
+	bltdnxlpt = bltdpt;
+	blitsing = bltcon1 & 0x2;
+	blinea = blt_info.bltadat;
+	blineb = (blt_info.bltbdat >> blt_info.blitbshift) | (blt_info.bltbdat << (16-blt_info.blitbshift));
+#if 0
+	if (blineb != 0xFFFF && blineb != 0)
+	    fprintf(stderr, "%x %x %d %x\n", blineb, blt_info.bltbdat, blt_info.blitbshift, bltcon1);
+#endif
+	blitsign = bltcon1 & 0x40; 
+	blitonedot = 0;
+    } else {
+	blitfc = !!(bltcon1 & 0x4);
+	blitife = bltcon1 & 0x8;
+	blitfill = bltcon1 & 0x18;
+	if ((bltcon1 & 0x18) == 0x18) {
+	    /* Digital "Trash" demo does this; others too. Apparently, no
+	     * negative effects. */
+	    static int warn = 1;
+	    if (warn)
+	    	write_log ("warning: weird fill mode (further messages suppressed)\n");
+	    warn = 0;
+	}
+	blitdesc = bltcon1 & 0x2;
+	if (blitfill && !blitdesc)
+	    write_log ("warning: blitter fill without desc\n");
+    }
+}
+
+static void actually_do_blit(void)
+{
+    if (blitline) {
+	do {
+	    blitter_read();
+	    blitter_line();
+	    blitter_write();
+	    blitter_nxline();
+	} while (bltstate != BLT_done);
+    } else {
+	/*blitcount[bltcon0 & 0xff]++;  blitter debug */
+	if (blitdesc) blitter_dofast_desc();
+	else blitter_dofast();
+    }
+    blitter_done_notify ();
+}
+
+void blitter_handler(void)
+{
+    if (!dmaen(DMA_BLITTER)) {
+	eventtab[ev_blitter].active = 1;
+	eventtab[ev_blitter].oldcycles = cycles;
+	eventtab[ev_blitter].evtime = 10 + cycles; /* wait a little */
+	return; /* gotta come back later. */
+    }
+    actually_do_blit();
+    
+    INTREQ(0x8040);
+    eventtab[ev_blitter].active = 0;
+    regs.spcflags &= ~SPCFLAG_BLTNASTY;
+}
+
+void do_blitter(void)
+{
+    long int blit_cycles;
+    if (!currprefs.immediate_blits) {
+	
+	blit_cycles = 2;
+
+	if (!blitline) {
+	    if (bltcon0 & 0x400)
+		blit_cycles++;
+	    if ((bltcon0 & 0x300) == 0x300)
+		blit_cycles++;
+	    blit_cycles *= blt_info.vblitsize * blt_info.hblitsize;
+	}
+    } else	
+	blit_cycles = 1;
+
+    blit_init();
+	
+    eventtab[ev_blitter].active = 1;
+    eventtab[ev_blitter].oldcycles = cycles;
+    eventtab[ev_blitter].evtime = blit_cycles + cycles;
+    events_schedule();
+
+    if (dmaen(DMA_BLITPRI))
+	regs.spcflags |= SPCFLAG_BLTNASTY;
+}
+
+void maybe_blit(void)
+{
+    static int warned = 0;
+    if (bltstate == BLT_done)
+	return;
+    
+    if (!warned) {
+		warned = 1;
+		write_log ("warning: Program does not wait for blitter\n");
+    }
+    if (!eventtab[ev_blitter].active) {
+		emu_printf("FOO!!?\n");
+	}
+    actually_do_blit();
+    eventtab[ev_blitter].active = 0;
+    regs.spcflags &= ~SPCFLAG_BLTNASTY;
+}

MCUME_teensy/teensyuae41/blitter.h

@@ -0,0 +1,48 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * Blitter emulation
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+#if 0
+struct bltinfo {
+    int blitzero;
+    int blitashift,blitbshift,blitdownashift,blitdownbshift;
+    uae_u32 bltadat, bltbdat, bltcdat,bltddat,bltahold,bltbhold,bltafwm,bltalwm;
+    int vblitsize,hblitsize;
+    int bltamod,bltbmod,bltcmod,bltdmod;
+};
+#else
+struct bltinfo {
+    int blitzero;
+    int blitashift,blitbshift,blitdownashift,blitdownbshift;
+    uae_u16 bltadat, bltbdat, bltcdat,bltddat,bltahold,bltbhold,bltafwm,bltalwm;
+    int vblitsize,hblitsize;
+    int bltamod,bltbmod,bltcmod,bltdmod;
+};
+#endif
+extern enum blitter_states {
+    BLT_done, BLT_init, BLT_read, BLT_work, BLT_write, BLT_next
+} bltstate;
+
+extern struct bltinfo blt_info;
+
+extern uae_u16 bltsize, oldvblts;
+extern uae_u16 bltcon0,bltcon1;
+extern int blinea_shift;
+extern uae_u32 bltapt,bltbpt,bltcpt,bltdpt;
+
+extern void maybe_blit (void);
+extern void blitter_handler (void);
+extern void build_blitfilltable (void);
+extern void do_blitter (void);
+extern void blitter_done_notify (void);
+typedef void blitter_func(uae_u8 *, uae_u8 *, uae_u8 *, uae_u8 *, struct bltinfo *);
+
+#define BLITTER_MAX_WORDS 2048
+
+extern blitter_func *blitfunc_dofast[256];
+extern blitter_func *blitfunc_dofast_desc[256];
+extern uae_u32 blit_masktable[BLITTER_MAX_WORDS];

MCUME_teensy/teensyuae41/cia.c

@@ -4,15 +4,19 @@
   * CIA chip support
   *
   * Copyright 1995 Bernd Schmidt, Alessandro Bissacco
-  * Copyright 1996 Stefan Reinauer
+  * Copyright 1996, 1997 Stefan Reinauer, Christian Schmitt
   */
 
 #include "shared.h"
 
+#include <assert.h>
+#include "gensound.h"
+#include "sounddep/sound.h"
 #include "events.h"
 #include "memory.h"
 #include "custom.h"
 #include "cia.h"
+#include "serial.h"
 #include "disk.h"
 #include "xwin.h"
 #include "keybuf.h"
@@ -34,28 +38,27 @@
 #define RTC_F_STOP     2
 #define RTC_F_RSET     1
 
-static UBYTE clock_control_d = RTC_D_ADJ + RTC_D_HOLD;
+static unsigned int clock_control_d = RTC_D_ADJ + RTC_D_HOLD;
-static UBYTE clock_control_e = 0;
+static unsigned int clock_control_e = 0;
-static UBYTE clock_control_f = RTC_F_24_12;
+static unsigned int clock_control_f = RTC_F_24_12;
 
-static UBYTE ciaaicr,ciaaimask,ciabicr,ciabimask;
+unsigned int ciaaicr,ciaaimask,ciabicr,ciabimask;
-static UBYTE ciaacra,ciaacrb,ciabcra,ciabcrb;
+unsigned int ciaacra,ciaacrb,ciabcra,ciabcrb;
-static ULONG ciaata,ciaatb,ciabta,ciabtb;
+unsigned long ciaata,ciaatb,ciabta,ciabtb;
-static UWORD ciaala,ciaalb,ciabla,ciablb;
+unsigned long ciaatod,ciabtod,ciaatol,ciabtol,ciaaalarm,ciabalarm;
-static ULONG ciaatod,ciabtod,ciaatol,ciabtol,ciaaalarm,ciabalarm;
+int ciaatlatch,ciabtlatch;
+
+static unsigned long ciaala,ciaalb,ciabla,ciablb;
 static int ciaatodon, ciabtodon;
-static int ciaatlatch,ciabtlatch;
+static unsigned int ciaapra,ciaaprb,ciaadra,ciaadrb,ciaasdr;
-static UBYTE ciaapra,ciaaprb,ciaadra,ciaadrb,ciaasdr;
+static unsigned int ciabpra,ciabprb,ciabdra,ciabdrb,ciabsdr; 
-static UBYTE ciabpra,ciabprb,ciabdra,ciabdrb,ciabsdr; 
 static int div10;
-static int kbstate, kback;
+static int kbstate, kback, ciaasdr_unread = 0;
 
-#ifdef HAS_PRT	
+//static int prtopen;
-static int prtopen;
+//static FILE *prttmp;
-static FILE *prttmp;
-#endif
 
-static void setclr(UBYTE *p, UBYTE val)
+static void setclr(unsigned int *p, unsigned int val)
 {
     if (val & 0x80) {
 	*p |= val & 0x7F;
@@ -67,25 +70,27 @@ static void setclr(UBYTE *p, UBYTE val)
 static void RethinkICRA(void)
 {
     if (ciaaimask & ciaaicr) {
-	ciaaicr |= 0x80;
+		ciaaicr |= 0x80;
-	custom_bank.wput(0xDFF09C,0x8008);
+		custom_bank.wput(0xDFF09C,0x8008);
     } else {
-	ciaaicr &= 0x7F;
+		ciaaicr &= 0x7F;
-/*	custom_bank.wput(0xDFF09C,0x0008);*/
+	/*	custom_bank.wput(0xDFF09C,0x0008);*/
     }
 }
 
 static void RethinkICRB(void)
 {
+#if 0 /* ??? What's this then? */
     if (ciabicr & 0x10) {
 	custom_bank.wput(0xDFF09C,0x9000);
     }
+#endif
     if (ciabimask & ciabicr) {
-	ciabicr |= 0x80;
+		ciabicr |= 0x80;
-	custom_bank.wput(0xDFF09C,0xA000);
+		custom_bank.wput(0xDFF09C,0xA000);
     } else {
-	ciabicr &= 0x7F;
+		ciabicr &= 0x7F;
-/*	custom_bank.wput(0xDFF09C,0x2000);*/
+	/*	custom_bank.wput(0xDFF09C,0x2000);*/
     }
 }
 
@@ -103,7 +108,7 @@ static void CIA_update(void)
     
     /* CIA A timers */
     if ((ciaacra & 0x21) == 0x01) {
-	//assert((ciaata+1) >= ciaclocks);
+	assert((ciaata+1) >= ciaclocks);
 	if ((ciaata+1) == ciaclocks) {
 	    aovfla = 1;
 	    if ((ciaacrb & 0x61) == 0x41) {
@@ -113,14 +118,14 @@ static void CIA_update(void)
 	ciaata -= ciaclocks;
     }
     if ((ciaacrb & 0x61) == 0x01) {
-	//assert((ciaatb+1) >= ciaclocks);
+	assert((ciaatb+1) >= ciaclocks);
 	if ((ciaatb+1) == ciaclocks) aovflb = 1;
 	ciaatb -= ciaclocks;
     }
     
     /* CIA B timers */
     if ((ciabcra & 0x21) == 0x01) {
-	//assert((ciabta+1) >= ciaclocks);
+	assert((ciabta+1) >= ciaclocks);
 	if ((ciabta+1) == ciaclocks) {
 	    bovfla = 1;
 	    if ((ciabcrb & 0x61) == 0x41) {
@@ -130,7 +135,7 @@ static void CIA_update(void)
 	ciabta -= ciaclocks;
     }
     if ((ciabcrb & 0x61) == 0x01) {
-	//assert ((ciabtb+1) >= ciaclocks);
+	assert ((ciabtb+1) >= ciaclocks);
 	if ((ciabtb+1) == ciaclocks) bovflb = 1;
 	ciabtb -= ciaclocks;
     }
@@ -205,7 +210,7 @@ static void CIA_calctimers(void)
 	if (ciaatimeb != -1 && ciaatimeb < ciatime) ciatime = ciaatimeb;
 	if (ciabtimea != -1 && ciabtimea < ciatime) ciatime = ciabtimea;
 	if (ciabtimeb != -1 && ciabtimeb < ciatime) ciatime = ciabtimeb;
-	eventtab[ev_cia].evtime = ciatime;
+	eventtab[ev_cia].evtime = ciatime + cycles;
     }
     events_schedule();
 }
@@ -216,42 +221,64 @@ void CIA_handler(void)
     CIA_calctimers();
 }
 
+void diskindex_handler(void)
+{
+	//emu_printf("diskhand");
+    eventtab[ev_diskindex].evtime += cycles - eventtab[ev_diskindex].oldcycles;
+    eventtab[ev_diskindex].oldcycles = cycles;
+    ciabicr |= 0x10;
+    RethinkICRB();
+}
+
 void CIA_hsync_handler(void)
 {
-    static int keytime = 0;
+    static unsigned int keytime = 0, sleepyhead = 0;
 
     if (ciabtodon)
 	ciabtod++;
     ciabtod &= 0xFFFFFF;
-#if 1
+
-    if (indexpulse == 0){
-	ciabicr |= 0x10;
-	RethinkICRB();
-/*	if (dskdmaen != 2)
-	    DISK_Index();*/
-	indexpulse = 30; /* whatever */
-    } else {
-	indexpulse--;
-    }
-#endif
     if (ciabtod == ciabalarm) {
 	ciabicr |= 4; RethinkICRB();
     }
+
+    SERDATS();    /*  check if the serial Port gets some data  */
+
     if (keys_available() && kback && (++keytime & 15) == 0) {
-	switch(kbstate) {
+        /*
-	 case 0:
+	 * This hack lets one possible ciaaicr cycle go by without any key
-	    ciaasdr = (BYTE)~0xFB; /* aaarghh... stupid compiler */
+	 * being read, for every cycle in which a key is pulled out of the
-	    kbstate++;
+	 * queue.  If no hack is used, a lot of key events just get lost
-	    break;
+	 * when you type fast.  With a simple hack that waits for ciaasdr
-	 case 1:
+	 * to be read before feeding it another, it will keep up until the
-	    kbstate++;
+	 * queue gets about 14 characters ahead and then lose events, and
-	    ciaasdr = (BYTE)~0xFD;
+	 * the mouse pointer will freeze while typing is being taken in.
-	    break;
+	 * With this hack, you can type 30 or 40 characters ahead with little
-	 case 2:
+	 * or no lossage, and the mouse doesn't get stuck.  The tradeoff is
-	    ciaasdr = ~get_next_key();
+	 * that the total slowness of typing appearing on screen is worse.
-	    break;
+	 */
-	}
+        if (ciaasdr_unread == 2)
-	ciaaicr |= 8; RethinkICRA();
+            ciaasdr_unread = 0;
+        else if (ciaasdr_unread == 0) {
+            switch (kbstate) {
+	     case 0:
+	        ciaasdr = (uae_s8)~0xFB; /* aaarghh... stupid compiler */
+	        kbstate++;
+	        break;
+	     case 1:
+	        kbstate++;
+	        ciaasdr = (uae_s8)~0xFD;
+	        break;
+	     case 2:
+	        ciaasdr = ~get_next_key();
+	        ciaasdr_unread = 1;      /* interlock to prevent lost keystrokes */
+	        break;
+	    }
+	    ciaaicr |= 8;
+	    RethinkICRA();
+	    sleepyhead = 0;
+        } else if (!(++sleepyhead & 15))
+            ciaasdr_unread = 0;          /* give up on this key event after unread for a long time */
     }
 }
 
@@ -265,15 +292,18 @@ void CIA_vsync_handler()
     }
 }
 
-static UBYTE ReadCIAA(UWORD addr)
+static uae_u8 ReadCIAA(unsigned int addr)
 {
-    UBYTE tmp;
+    unsigned int tmp;
     
     switch(addr & 0xf){
      case 0: 
 	tmp = (DISK_status() & 0x3C);
-	if (!buttonstate[0]) tmp |= 0x40;
+	if ((JSEM_ISMOUSE (0, currprefs.fake_joystick) && !buttonstate[0])
-	if (!joy0button) tmp |= 0x80;
+	    || (!JSEM_ISMOUSE (0, currprefs.fake_joystick) && !(joy0button & 1)))
+	    tmp |= 0x40;
+	if (!(joy1button & 1))
+	    tmp |= 0x80;
 	return tmp;
      case 1:
 	return ciaaprb;
@@ -293,14 +323,19 @@ static UBYTE ReadCIAA(UWORD addr)
 	if (ciaatlatch) {
 	    ciaatlatch = 0;
 	    return ciaatol & 0xff;
-	} else return ciaatod & 0xff;
+	} else
+	    return ciaatod & 0xff;
      case 9:
-	if (ciaatlatch) return (ciaatol >> 8) & 0xff;
+	if (ciaatlatch)
-	else return (ciaatod >> 8) & 0xff;
+	    return (ciaatol >> 8) & 0xff;
+	else
+	    return (ciaatod >> 8) & 0xff;
      case 10:
-	ciaatlatch = 1; ciaatol = ciaatod; /* ??? only if not already latched? */
+	ciaatlatch = 1;
+	ciaatol = ciaatod; /* ??? only if not already latched? */
 	return (ciaatol >> 16) & 0xff;
      case 12:
+        if (ciaasdr == 1) ciaasdr_unread = 2;
 	return ciaasdr;
      case 13:
 	tmp = ciaaicr; ciaaicr = 0; RethinkICRA(); return tmp;
@@ -312,9 +347,9 @@ static UBYTE ReadCIAA(UWORD addr)
     return 0;
 }
 
-static UBYTE ReadCIAB(UWORD addr)
+static uae_u8 ReadCIAB(unsigned int addr)
 {
-    UBYTE tmp;
+    unsigned int tmp;
     
     switch(addr & 0xf){
      case 0: 
@@ -337,12 +372,16 @@ static UBYTE ReadCIAB(UWORD addr)
 	if (ciabtlatch) {
 	    ciabtlatch = 0;
 	    return ciabtol & 0xff;
-	} else return ciabtod & 0xff;
+	} else
+	    return ciabtod & 0xff;
      case 9:
-	if (ciabtlatch) return (ciabtol >> 8) & 0xff;
+	if (ciabtlatch)
-	else return (ciabtod >> 8) & 0xff;
+	    return (ciabtol >> 8) & 0xff;
+	else
+	    return (ciabtod >> 8) & 0xff;
      case 10:
-	ciabtlatch = 1; ciabtol = ciabtod;
+	ciabtlatch = 1;
+	ciabtol = ciabtod;
 	return (ciabtol >> 16) & 0xff;
      case 12:
 	return ciabsdr;
@@ -357,140 +396,164 @@ static UBYTE ReadCIAB(UWORD addr)
     return 0;
 }
 
-static void WriteCIAA(UWORD addr,UBYTE val)
+static void WriteCIAA(uae_u16 addr,uae_u8 val)
 {
-    int oldled;
+    int oldled, oldovl;
     switch(addr & 0xf){
-     case 0:
+    	case 0:
-	oldled = ciaapra & 2;
+			oldovl = ciaapra & 1;
-	ciaapra = (ciaapra & ~0x3) | (val & 0x3); LED(ciaapra & 0x2);
+			oldled = ciaapra & 2;
-	if ((ciaapra & 2) != oldled)
+			ciaapra = (ciaapra & ~0x3) | (val & 0x3); LED(ciaapra & 0x2);
-	    gui_led (0, !(ciaapra & 2));
+			if ((ciaapra & 2) != oldled)
-	break;
+			    gui_led (0, !(ciaapra & 2));
-     case 1:
+			if ((ciaapra & 1) != oldovl) {
-	ciaaprb = val;
+			    map_banks(oldovl ? &chipmem_bank : &kickmem_bank, 0, 32);
-#ifdef HAS_PRT	
+			}
-	if (prtopen==1) 
+			break;
-	{
+    	case 1:
-	    fprintf (prttmp,"%c",val);
+			ciaaprb = val;
-	    if (val==0x04) {
+/*
-#if defined(__unix) && !defined(__bebox__) && !defined(__DOS__)
+			if (prtopen==1) {
-			pclose (prttmp);
+#ifndef __DOS__
+	    		fprintf (prttmp,"%c",val);
 #else
-			fclose (prttmp);
+	    		fputc (val, prttmp);
+	    		fflush (prttmp);
 #endif
-			prtopen = 0;
+	    		if (val==0x04) {
-	    }
+#if defined(__unix) && !defined(__BEOS__) && !defined(__DOS__)
-    } 
+					pclose (prttmp);
-    else 
-    {
-#if defined(__unix) && !defined(__bebox__) && !defined(__DOS__)
-        prttmp=(FILE *)popen ((char *)prtname,"w");
 #else
-      prttmp=(FILE *)fopen ((char *)prtname,"wb");
+					fclose (prttmp);
 #endif
-	    if (prttmp != NULL) 
+					prtopen = 0;
-	    {
+	    		}
-			prtopen = 1;
+        	} else {       		
-			fprintf (prttmp,"%c",val);
+#if defined(__unix) && !defined(__BEOS__) && !defined(__DOS__)
-	    }
+            	prttmp=(FILE *)popen ((char *)prtname,"w");
-    }
+#else
+            	prttmp=(FILE *)fopen ((char *)prtname,"wb");
 #endif
-	ciaaicr |= 0x10;
+	    		if (prttmp != NULL) {
-	break;
+					prtopen = 1;
-     case 2:
+#ifndef __DOS__
-	ciaadra = val; break;
+					fprintf (prttmp,"%c",val);
-     case 3:
+#else
-	ciaadrb = val; break;
+					fputc (val, prttmp);
-     case 4:
+					fflush (prttmp);
-	CIA_update();
+#endif
-	ciaala = (ciaala & 0xff00) | val;
+	    		}
-	CIA_calctimers();
+        	}
-	break;
+*/        	
-     case 5:
+			ciaaicr |= 0x10;
-	CIA_update();
+			break;
-	ciaala = (ciaala & 0xff) | (val << 8);
+    	case 2:
-	if ((ciaacra & 1) == 0)
+			ciaadra = val; break;
-	    ciaata = ciaala;
+    	case 3:
-	if (ciaacra & 8) { 
+			ciaadrb = val; break;
-	    ciaata = ciaala; 
+    	case 4:
-	    ciaacra |= 1; 
+			CIA_update();
-	}
+			ciaala = (ciaala & 0xff00) | val;
-	CIA_calctimers();
+			CIA_calctimers();
-	break;
+			break;
-     case 6:
+    	case 5:
-	CIA_update();
+			CIA_update();
-	ciaalb = (ciaalb & 0xff00) | val;
+			ciaala = (ciaala & 0xff) | (val << 8);
-	CIA_calctimers();
+			if ((ciaacra & 1) == 0)
-	break;
+			    ciaata = ciaala;
-     case 7:
+			if (ciaacra & 8) { 
-	CIA_update();
+			    ciaata = ciaala; 
-	ciaalb = (ciaalb & 0xff) | (val << 8);
+			    ciaacra |= 1; 
-	if ((ciaacrb & 1) == 0)
+			}
-	    ciaatb = ciaalb;
+			CIA_calctimers();
-	if (ciaacrb & 8) { 
+			break;
-	    ciaatb = ciaalb;
+    	case 6:
-	    ciaacrb |= 1; 
+			CIA_update();
-	}
+			ciaalb = (ciaalb & 0xff00) | val;
-	CIA_calctimers();
+			CIA_calctimers();
-	break;
+			break;
-     case 8:
+		     case 7:
-	if (ciaacrb & 0x80){
+			CIA_update();
-	    ciaaalarm = (ciaaalarm & ~0xff) | val;
+			ciaalb = (ciaalb & 0xff) | (val << 8);
-	} else {
+			if ((ciaacrb & 1) == 0)
-	    ciaatod = (ciaatod & ~0xff) | val;
+			    ciaatb = ciaalb;
-	    ciaatodon = 1;
+			if (ciaacrb & 8) { 
-	}
+			    ciaatb = ciaalb;
-	break;
+			    ciaacrb |= 1; 
-     case 9:
+			}
-	if (ciaacrb & 0x80){
+			CIA_calctimers();
-	    ciaaalarm = (ciaaalarm & ~0xff00) | (val << 8);
+			break;
-	} else {
+    	case 8:
-	    ciaatod = (ciaatod & ~0xff00) | (val << 8);
+			if (ciaacrb & 0x80){
-	    ciaatodon = 0;
+			    ciaaalarm = (ciaaalarm & ~0xff) | val;
-	}
+			} else {
-	break;
+			    ciaatod = (ciaatod & ~0xff) | val;
-     case 10:
+			    ciaatodon = 1;
-	if (ciaacrb & 0x80){
+			}
-	    ciaaalarm = (ciaaalarm & ~0xff0000) | (val << 16);
+			break;
-	} else {
+    	case 9:
-	    ciaatod = (ciaatod & ~0xff0000) | (val << 16);
+			if (ciaacrb & 0x80){
-	    ciaatodon = 0;
+			    ciaaalarm = (ciaaalarm & ~0xff00) | (val << 8);
-	}
+			} else {
-	break;
+			    ciaatod = (ciaatod & ~0xff00) | (val << 8);
-     case 12:
+			    ciaatodon = 0;
-	ciaasdr = val; break;
+			}
-     case 13:
+			break;
-	setclr(&ciaaimask,val); break; /* ??? call RethinkICR() ? */
+    	case 10:
-     case 14:
+			if (ciaacrb & 0x80){
-	CIA_update();
+			    ciaaalarm = (ciaaalarm & ~0xff0000) | (val << 16);
-	ciaacra = val;
+			} else {
-	if (ciaacra & 0x10){
+			    ciaatod = (ciaatod & ~0xff0000) | (val << 16);
-	    ciaacra &= ~0x10;
+			    ciaatodon = 0;
-	    ciaata = ciaala;
+			}
-	}
+			break;
-	if (ciaacra & 0x40) {
+    	case 12:
-	    kback = 1;
+			ciaasdr = val; break;
-	}
+    	case 13:
-	CIA_calctimers();
+			setclr(&ciaaimask,val); break; /* ??? call RethinkICR() ? */
-	break;
+    	case 14:
-     case 15:
+			CIA_update();
-	CIA_update();
+			ciaacra = val;
-	ciaacrb = val; 
+			if (ciaacra & 0x10){
-	if (ciaacrb & 0x10){
+			    ciaacra &= ~0x10;
-	    ciaacrb &= ~0x10;
+			    ciaata = ciaala;
-	    ciaatb = ciaalb;
+			}
-	}
+			if (ciaacra & 0x40) {
-	CIA_calctimers();
+			    kback = 1;
-	break;
+			}
+			CIA_calctimers();
+			break;
+    	case 15:
+			CIA_update();
+			ciaacrb = val; 
+			if (ciaacrb & 0x10){
+			    ciaacrb &= ~0x10;
+			    ciaatb = ciaalb;
+			}
+			CIA_calctimers();
+			break;
     }
 }
 
-static void WriteCIAB(UWORD addr,UBYTE val)
+static void WriteCIAB(uae_u16 addr,uae_u8 val)
 {
+    int remember;
     switch(addr & 0xf){
-     case 0:
+    	case 0:
-	ciabpra = (ciabpra & ~0x3) | (val & 0x3); break;
+	        remember=ciabpra;
+			ciabpra  = val;
+	        ciabpra |= 0x80;
+
+	        if (((remember&0x40)==0x40) && ((ciabpra&0x40)==0x00)) 
+	          emu_printf ("RTS cleared.\n");
+	        if (((remember&0x40)==0x00) && ((ciabpra&0x40)==0x40))
+	          emu_printf ("RTS set.\n");
+	        if (((remember&0x10)==0x10) && ((ciabpra&0x10)==0x00))
+	          emu_printf ("CTS cleared.\n");
+	        if (((remember&0x10)==0x00) && ((ciabpra&0x10)==0x10))
+	          emu_printf ("CTS set.\n");
+
+			break;
      case 1:
 	ciabprb = val; DISK_select(val); break;
      case 2:
@@ -580,40 +643,46 @@ static void WriteCIAB(UWORD addr,UBYTE val)
     }
 }
 
+uae_u8 CIA_shakehands_get(void)
+{
+   return ciabpra;
+}
+void CIA_shakehands_set(uae_u8 mask)
+{
+   ciabpra |= mask;
+}
+void CIA_shakehands_clear(uae_u8 mask)
+{
+   ciabpra &= ~mask;
+}
+
 void CIA_reset(void)
 {
     kback = 1;
     kbstate = 0;
     
     ciaatlatch = ciabtlatch = 0;
+    ciaapra = 2;
     ciaatod = ciabtod = 0; ciaatodon = ciabtodon = 0;
     ciaaicr = ciabicr = ciaaimask = ciabimask = 0;
     ciaacra = ciaacrb = ciabcra = ciabcrb = 0x4; /* outmode = toggle; */
+    ciaala = ciaalb = ciabla = ciablb = ciaata = ciaatb = ciabta = ciabtb = 0xFFFF;
     div10 = 0;
     lastdiv10 = 0;
     CIA_calctimers();
-
+    ciabpra = 0x8C;
-    ciabpra = 0x04;
+    /*fprintf (stderr," CIA-Reset\n ");*/
 }
 
-void dumpcia(void)
-{
-    printf("A: CRA: %02x, CRB: %02x, IMASK: %02x, TOD: %08lx %7s TA: %04lx, TB: %04lx\n",
-	   (int)ciaacra, (int)ciaacrb, (int)ciaaimask, ciaatod, 
-	   ciaatlatch ? " latched" : "", ciaata, ciaatb);
-    printf("B: CRA: %02x, CRB: %02x, IMASK: %02x, TOD: %08lx %7s TA: %04lx, TB: %04lx\n",
-	   (int)ciabcra, (int)ciabcrb, (int)ciabimask, ciabtod, 
-	   ciabtlatch ? " latched" : "", ciabta, ciabtb);
-}
 
 /* CIA memory access */
 
-static ULONG cia_lget(CPTR) REGPARAM;
+static uae_u32 cia_lget(uaecptr) REGPARAM;
-static UWORD cia_wget(CPTR) REGPARAM;
+static uae_u32 cia_wget(uaecptr) REGPARAM;
-static UBYTE cia_bget(CPTR) REGPARAM;
+static uae_u32 cia_bget(uaecptr) REGPARAM;
-static void  cia_lput(CPTR, ULONG) REGPARAM;
+static void  cia_lput(uaecptr, uae_u32) REGPARAM;
-static void  cia_wput(CPTR, UWORD) REGPARAM;
+static void  cia_wput(uaecptr, uae_u32) REGPARAM;
-static void  cia_bput(CPTR, UBYTE) REGPARAM;
+static void  cia_bput(uaecptr, uae_u32) REGPARAM;
 
 addrbank cia_bank = {
     cia_lget, cia_wget, cia_bget,
@@ -621,17 +690,17 @@ addrbank cia_bank = {
     default_xlate, default_check
 };
 
-ULONG cia_lget(CPTR addr)
+uae_u32 REGPARAM2 cia_lget(uaecptr addr)
 {
     return cia_bget(addr+3);
 }
 
-UWORD cia_wget(CPTR addr)
+uae_u32 REGPARAM2 cia_wget(uaecptr addr)
 {
     return cia_bget(addr+1);
 }
 
-UBYTE cia_bget(CPTR addr)
+uae_u32 REGPARAM2 cia_bget(uaecptr addr)
 {
     if ((addr & 0x3001) == 0x2001)
     	return ReadCIAA((addr & 0xF00) >> 8);
@@ -640,17 +709,17 @@ UBYTE cia_bget(CPTR addr)
     return 0;
 }
 
-void cia_lput(CPTR addr, ULONG value)
+void REGPARAM2 cia_lput(uaecptr addr, uae_u32 value)
 {
     cia_bput(addr+3,value); /* FIXME ? */
 }
 
-void cia_wput(CPTR addr, UWORD value)
+void REGPARAM2 cia_wput(uaecptr addr, uae_u32 value)
 {
     cia_bput(addr+1,value);
 }
 
-void cia_bput(CPTR addr, UBYTE value)
+void REGPARAM2 cia_bput(uaecptr addr, uae_u32 value)
 {
     if ((addr & 0x3001) == 0x2001)
     	WriteCIAA((addr & 0xF00) >> 8,value);
@@ -660,12 +729,12 @@ void cia_bput(CPTR addr, UBYTE value)
 
 /* battclock memory access */
 
-static ULONG clock_lget(CPTR) REGPARAM;
+static uae_u32 clock_lget(uaecptr) REGPARAM;
-static UWORD clock_wget(CPTR) REGPARAM;
+static uae_u32 clock_wget(uaecptr) REGPARAM;
-static UBYTE clock_bget(CPTR) REGPARAM;
+static uae_u32 clock_bget(uaecptr) REGPARAM;
-static void  clock_lput(CPTR, ULONG) REGPARAM;
+static void  clock_lput(uaecptr, uae_u32) REGPARAM;
-static void  clock_wput(CPTR, UWORD) REGPARAM;
+static void  clock_wput(uaecptr, uae_u32) REGPARAM;
-static void  clock_bput(CPTR, UBYTE) REGPARAM;
+static void  clock_bput(uaecptr, uae_u32) REGPARAM;
 
 addrbank clock_bank = {
     clock_lget, clock_wget, clock_bget,
@@ -673,17 +742,17 @@ addrbank clock_bank = {
     default_xlate, default_check
 };
 
-ULONG clock_lget(CPTR addr)
+uae_u32 REGPARAM2 clock_lget(uaecptr addr)
 {
     return clock_bget(addr+3);
 }
 
-UWORD clock_wget(CPTR addr)
+uae_u32 REGPARAM2 clock_wget(uaecptr addr)
 {
     return clock_bget(addr+1);
 }
 
-UBYTE clock_bget(CPTR addr)
+uae_u32 REGPARAM2 clock_bget(uaecptr addr)
 {
     time_t t=time(0);
     struct tm *ct;
@@ -711,17 +780,17 @@ UBYTE clock_bget(CPTR addr)
     return 0;
 }
 
-void clock_lput(CPTR addr, ULONG value)
+void REGPARAM2 clock_lput(uaecptr addr, uae_u32 value)
 {
     /* No way */
 }
 
-void clock_wput(CPTR addr, UWORD value)
+void REGPARAM2 clock_wput(uaecptr addr, uae_u32 value)
 {
     /* No way */
 }
 
-void clock_bput(CPTR addr, UBYTE value)
+void REGPARAM2 clock_bput(uaecptr addr, uae_u32 value)
 {
     switch (addr & 0x3f)
     {

MCUME_teensy/teensyuae41/cia.h

@@ -6,9 +6,21 @@
   * (c) 1995 Bernd Schmidt
   */
 
-void CIA_reset(void);
+extern void CIA_reset(void);
-void CIA_vsync_handler(void);
+extern void CIA_vsync_handler(void);
-void CIA_hsync_handler(void);
+extern void CIA_hsync_handler(void);
-void CIA_handler(void);
+extern void CIA_handler(void);
+extern void CIA_shakehands_set(uae_u8 mask);
+extern void CIA_shakehands_clear(uae_u8 mask);
 
-void dumpcia(void);
+extern uae_u8 CIA_shakehands_get (void);
+
+extern void diskindex_handler(void);
+
+extern void dumpcia(void);
+
+extern unsigned int ciaaicr,ciaaimask,ciabicr,ciabimask;
+extern unsigned int ciaacra,ciaacrb,ciabcra,ciabcrb;
+extern unsigned long ciaata,ciaatb,ciabta,ciabtb;
+extern unsigned long ciaatod,ciabtod,ciaatol,ciabtol,ciaaalarm,ciabalarm;
+extern int ciaatlatch,ciabtlatch;

MCUME_teensy/teensyuae41/compiler.h

@@ -0,0 +1,120 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * m68k -> i386 compiler
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+typedef uaecptr (*code_execfunc)(void);
+
+struct code_page {
+    struct code_page *next;
+    uae_u32 allocmask;
+};
+
+struct hash_block {
+    struct hash_block *lru_next, *lru_prev;
+    struct hash_entry *he_first;
+
+    struct code_page *cpage;
+    int alloclen;
+    uae_u32 page_allocmask;
+    char *compile_start;
+    
+    int nrefs;
+
+    int translated:1;
+    int untranslatable:1;
+    int allocfailed:1;
+};
+
+struct hash_entry {
+    code_execfunc execute; /* For the sake of the stubs in X86.S */
+    struct hash_entry *next,*prev;
+    struct hash_entry *next_same_block, *lru_next, *lru_prev;
+    struct hash_block *block;
+    
+    uaecptr addr;
+    uae_u32 matchword;
+    int ncalls:8;
+    int locked:1;
+    int cacheflush:1;
+};
+
+extern int nr_bbs_start;
+extern uae_u8 nr_bbs_to_run;
+extern code_execfunc exec_me;
+
+#ifdef USE_COMPILER
+static __inline__ void run_compiled_code(void)
+{
+    if (regs.spcflags == SPCFLAG_EXEC && may_run_compiled) {
+	while (regs.spcflags == SPCFLAG_EXEC) {
+	    uaecptr newpc;
+	    regs.spcflags = 0;
+	    /*		newpc = (*exec_me)();*/
+	    __asm__ __volatile__ ("pushl %%ebp; call *%1; popl %%ebp" : "=a" (newpc) : "r" (exec_me) :
+				  "%eax", "%edx", "%ecx", "%ebx",
+				  "%edi", "%esi", "memory", "cc");
+	    if (nr_bbs_to_run == 0) {
+		struct hash_entry *h = (struct hash_entry *)newpc;
+		regs.spcflags = SPCFLAG_EXEC;
+		exec_me = h->execute;
+		regs.pc = h->addr;
+		regs.pc_p = regs.pc_oldp = get_real_address(h->addr);
+		nr_bbs_to_run = nr_bbs_start;
+	    } else
+		m68k_setpc_fast(newpc);
+	    do_cycles();
+	}
+    } else 
+	regs.spcflags &= ~SPCFLAG_EXEC;
+}
+
+extern void compiler_init(void);
+extern void possible_loadseg(void);
+
+extern void m68k_do_rts(void);
+extern void m68k_do_bsr(uae_s32);
+extern void m68k_do_jsr(uaecptr);
+extern void compiler_flush_jsr_stack(void);
+
+#else
+
+#define run_compiled_code() do { } while (0)
+#define compiler_init() do { } while (0)
+#define possible_loadseg() do { } while (0)
+#define compiler_flush_jsr_stack() do { } while (0)
+
+static __inline__ void m68k_do_rts(void)
+{
+    m68k_setpc(get_long(m68k_areg(regs, 7)));
+    m68k_areg(regs, 7) += 4;
+}
+
+static __inline__ void m68k_do_bsr(uae_s32 offset)
+{
+#if defined(USE_POINTER)
+    char *oldpcp = (char *)regs.pc_p;    
+#endif
+    uae_u32 oldpc = m68k_getpc();
+    m68k_areg(regs, 7) -= 4;
+    put_long(m68k_areg(regs, 7), oldpc);
+    
+#if defined(USE_POINTER)
+    regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)offset);
+#else
+    regs.pc = oldpc + (uae_s32)offset;
+#endif
+}
+
+static __inline__ void m68k_do_jsr(uaecptr dest)
+{
+    uae_u32 oldpc = m68k_getpc();
+    m68k_areg(regs, 7) -= 4;
+    put_long(m68k_areg(regs, 7), oldpc);
+    m68k_setpc(dest);
+}
+
+#endif

MCUME_teensy/teensyuae41/cpu6.c

@@ -1,220 +1,456 @@
 #include "shared.h"
 
+#include "machdep/m68k.h"
 #include "memory.h"
 #include "custom.h"
+#include "readcpu.h"
 #include "newcpu.h"
+#include "compiler.h"
 #include "cputbl.h"
-void op_6000(ULONG opcode)
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_6000)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(0)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6001(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6001)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(0)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(0)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6100(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_60ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-{	regs.a[7] -= 4;
+	if (cctrue(0)) {
-{	CPTR spa = regs.a[7];
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
-	put_long(spa,m68k_getpc());
+	fill_prefetch();
-	regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	}
-}}}}}
-void op_6101(ULONG opcode)
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-{	regs.a[7] -= 4;
-{	CPTR spa = regs.a[7];
-	put_long(spa,m68k_getpc());
-	regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}}}
-void op_6200(ULONG opcode)
-{
-{	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
-	if (cctrue(2)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
 }}}
-void op_6201(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6100)(uae_u32 opcode) /* BSR */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(2)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6300(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(3)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
 }}}
-void op_6301(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6101)(uae_u32 opcode) /* BSR */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(3)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
 }}}
-void op_6400(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_61ff)(uae_u32 opcode) /* BSR */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(4)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	uae_s32 s = (uae_s32)src - (((char *)regs.pc_p) - oldpcp);
+	m68k_do_bsr(s);
+	fill_prefetch();
 }}}
-void op_6401(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6200)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(4)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6500(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(5)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6501(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6201)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(5)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6600(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_62ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(6)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(2)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6601(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6300)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(6)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6700(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(7)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6701(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6301)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(7)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6800(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_63ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(8)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(3)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6801(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6400)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(8)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6900(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(9)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6901(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6401)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(9)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6a00(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_64ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(10)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(4)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6a01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6500)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(10)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6b00(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(11)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6b01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6501)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(11)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6c00(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_65ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(12)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(5)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6c01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6600)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(12)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6d00(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(13)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6d01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6601)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(13)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6e00(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_66ff)(uae_u32 opcode) /* Bcc */
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s32 src = nextilong();
-	if (cctrue(14)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(6)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6e01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6700)(uae_u32 opcode) /* Bcc */
-{
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
-{	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
-	if (cctrue(14)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
-}}}
-void op_6f00(ULONG opcode)
 {
 {	char *oldpcp = (char *)regs.pc_p;
-{	WORD src = nextiword();
+{	uae_s16 src = nextiword();
-	if (cctrue(15)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
-void op_6f01(ULONG opcode)
+void REGPARAM2 CPU_OP_NAME(_6701)(uae_u32 opcode) /* Bcc */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
 {	char *oldpcp = (char *)regs.pc_p;
-{	ULONG src = srcreg;
+{	uae_u32 src = srcreg;
-	if (cctrue(15)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
 }}}
+void REGPARAM2 CPU_OP_NAME(_67ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(7)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6800)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6801)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_68ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(8)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6900)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6901)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_69ff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(9)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6a01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6aff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(10)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6b01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6bff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(11)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6c01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6cff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(12)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6d01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6dff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(13)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6e01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6eff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(14)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f00)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s16 src = nextiword();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6f01)(uae_u32 opcode) /* Bcc */
+{
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_u32 src = srcreg;
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+void REGPARAM2 CPU_OP_NAME(_6fff)(uae_u32 opcode) /* Bcc */
+{
+{	char *oldpcp = (char *)regs.pc_p;
+{	uae_s32 src = nextilong();
+	if (cctrue(15)) {
+	regs.pc_p = (uae_u8 *)(oldpcp + (uae_s32)src);
+	fill_prefetch();
+	}
+}}}
+#endif

MCUME_teensy/teensyuae41/cpu7.c

@@ -1,16 +1,21 @@
 #include "shared.h"
 
+#include "machdep/m68k.h"
 #include "memory.h"
 #include "custom.h"
+#include "readcpu.h"
 #include "newcpu.h"
+#include "compiler.h"
 #include "cputbl.h"
-void op_7000(ULONG opcode)
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+void REGPARAM2 CPU_OP_NAME(_7000)(uae_u32 opcode) /* MOVE */
 {
-	ULONG srcreg = (LONG)(BYTE)((opcode & 255) >> 0);
+	uae_u32 srcreg = (uae_s32)(uae_s8)(opcode & 255);
-	ULONG dstreg = (opcode & 3584) >> 9;
+	uae_u32 dstreg = (opcode >> 9) & 7;
-{{	ULONG src = srcreg;
+{{	uae_u32 src = srcreg;
 {	VFLG = CFLG = 0;
-	ZFLG = ((LONG)(src)) == 0;
+	ZFLG = ((uae_s32)(src)) == 0;
-	NFLG = ((LONG)(src)) < 0;
+	NFLG = ((uae_s32)(src)) < 0;
-	regs.d[dstreg] = (src);
+	m68k_dreg(regs, dstreg) = (src);
 }}}}
+#endif

MCUME_teensy/teensyuae41/cpuA.c

@@ -1,6 +1,11 @@
 #include "shared.h"
 
+#include "machdep/m68k.h"
 #include "memory.h"
 #include "custom.h"
+#include "readcpu.h"
 #include "newcpu.h"
+#include "compiler.h"
 #include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/cpuF.c

@@ -1,6 +1,11 @@
 #include "shared.h"
 
+#include "machdep/m68k.h"
 #include "memory.h"
 #include "custom.h"
+#include "readcpu.h"
 #include "newcpu.h"
+#include "compiler.h"
 #include "cputbl.h"
+#if !defined (MEMFUNCS_DIRECT_REQUESTED) || defined (DIRECT_MEMFUNCS_SUCCESSFUL)
+#endif

MCUME_teensy/teensyuae41/custom.h

@@ -9,18 +9,27 @@
 extern void custom_init(void);
 extern void customreset(void);
 extern int intlev(void);
-extern int dmaen(UWORD dmamask);
 extern void dumpcustom(void);
 
 extern void do_disk(void);
-extern void do_blitter(void);
+
+extern void notice_new_xcolors (void);
+extern void notice_screen_contents_lost (void);
 
 extern int inhibit_frame;
 extern int bogusframe;
 
-extern unsigned long specialflags;
+extern uae_u16 dmacon;
+extern uae_u16 intena,intreq;
+
+extern int current_hpos (void);
+extern int vpos;
+
+static __inline__ int dmaen(unsigned int dmamask)
+{
+    return (dmamask & dmacon) && (dmacon & 0x200);
+}
 
-#define SPCFLAG_BLIT 1
 #define SPCFLAG_STOP 2
 #define SPCFLAG_DISK 4
 #define SPCFLAG_INT  8
@@ -30,33 +39,39 @@ extern unsigned long specialflags;
 #define SPCFLAG_DOTRACE 128
 #define SPCFLAG_DOINT 256
 #define SPCFLAG_BLTNASTY 512
+#define SPCFLAG_EXEC 1024
+#define SPCFLAG_MODE_CHANGE 8192
 
 extern int dskdmaen;
-extern UWORD adkcon;
+extern uae_u16 adkcon;
 
-extern int max_diwstop, prev_max_diwstop;
+extern unsigned int joy0dir, joy1dir;
+extern int joy0button, joy1button;
+extern uae_u32 mousehack_helper (void);
 
-extern UWORD joy0dir;
+extern void INTREQ(uae_u16);
-extern int joy0button;
+extern uae_u16 INTREQR(void);
-
+extern uae_u16 DMACONR(void);
-extern void pfield_sprite_l (int, int, UWORD, UWORD);
-extern void pfield_sprite_h (int, int, UWORD, UWORD);
-
-struct bltinfo {
-    int blitzero;
-    UWORD blitpreva,blitprevb,blitashift,blitbshift;
-    UWORD bltadat,bltbdat,bltcdat,bltddat,bltafwm,bltalwm;
-    UWORD vblitsize,hblitsize;
-    WORD  bltamod,bltbmod,bltcmod,bltdmod;
-};
-
-typedef void blitter_func(UWORD *, UWORD *, UWORD *, UWORD *, struct bltinfo *);
-
-extern blitter_func *blitfunc_dofast[256];
-extern blitter_func *blitfunc_dofast_desc[256];
 
 #define maxhpos 227
 #define maxvpos 312
-#define minfirstline 29
+/* The HRM says: The vertical blanking area (PAL) ranges from line 0 to line 29,
+ * and no data can be displayed there. Nevertheless, we lose some overscan data
+ * if this is set to 29. */
+#define minfirstline 21
+#define vblank_endline 29
 #define numscrlines (maxvpos+1-minfirstline+1)
 
+#define DMA_AUD0      0x0001
+#define DMA_AUD1      0x0002
+#define DMA_AUD2      0x0004
+#define DMA_AUD3      0x0008
+#define DMA_DISK      0x0010
+#define DMA_SPRITE    0x0020
+#define DMA_BLITTER   0x0040
+#define DMA_COPPER    0x0080
+#define DMA_BITPLANE  0x0100
+#define DMA_BLITPRI   0x0400
+
+extern unsigned long frametime, timeframes;
+

MCUME_teensy/teensyuae41/disk.h

@@ -6,21 +6,19 @@
   * (c) 1995 Bernd Schmidt
   */
 
-#define FLOPPY_SIZE 0x100000
 
-extern void DISK_init(void);
+extern void DISK_init (void);
-extern void DISK_select(UBYTE data);
+extern void DISK_select (uae_u8 data);
-extern UBYTE DISK_status(void);
+extern uae_u8 DISK_status (void);
-extern void DISK_GetData(UWORD *mfm,UWORD *byt);
+extern int DISK_GetData (uae_u16 *mfm,uae_u16 *byt);
-extern void DISK_Index(void);
+extern void DISK_InitWrite (void);
-extern void DISK_InitWrite(void);
+extern void DISK_WriteData (int);
-extern void DISK_WriteData(void);
+extern void disk_eject (int num);
-extern void disk_eject(int num);
+extern int disk_empty (int num);
-extern int disk_empty(int num);
+extern void disk_insert (int num, const char *name);
-extern void disk_insert(int num, char *name);
+extern void disk_swap(const char * disk0, const char * disk1);
-extern void disk_swap();
+extern int DISK_ReadMFM (uaecptr);
+extern int DISK_PrepareReadMFM (int, uae_u16, int);
+extern void DISK_check_change (void);
 
-void disk_memWrite(int pos, unsigned char val);
+// JMH: extern uae_u16* mfmwrite;
-
-extern int indexpulse;
-extern UWORD* mfmwrite;

MCUME_teensy/teensyuae41/dtypes.h

@@ -10,10 +10,33 @@ typedef unsigned int ULONG;
 typedef signed int LONG;
 typedef ULONG CPTR;
 
+typedef unsigned char uae_u8;
+typedef signed char uae_s8;
+typedef unsigned short uae_u16;
+typedef signed short uae_s16;
+typedef unsigned int uae_u32;
+typedef signed int uae_s32;
+typedef ULONG uaecptr;
+
+
 #undef REGPARAM
 #ifndef REGPARAM
 #define REGPARAM
 #endif
 
+#undef REGPARAM2
+#ifndef REGPARAM2
+#define REGPARAM2
+#endif
+
+
+#define SOUND_PRESENT 1
+#define M68K_SPEED 4
+//#define HAS_BOGOMEM 1
+//#define HAS_MEMDISK  1
+#define HAS_EXPANMEM 1
+#define HAS_HARDFILE 1  
+#define HAS_FILESYS 1  
+
 #endif /* _DTYPES_H_ */
 

MCUME_teensy/teensyuae41/ersatz.h

@@ -0,0 +1,11 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * A "replacement" for a missing Kickstart
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+extern void init_ersatz_rom (uae_u8 *data);
+extern void ersatz_perform (uae_u16);
+extern void DISK_ersatz_read (int,int, uaecptr);

MCUME_teensy/teensyuae41/events.h

@@ -3,22 +3,14 @@
   *
   * Events
   * 
-  * (c) 1995 Bernd Schmidt
+  * Note that this file must be included after sound.h and sounddep/sound.h,
+  * since DONT_WANT_SOUND can get overridden in those.
+  * 
+  * Copyright 1995, 1996, 1997 Bernd Schmidt
   */
 
-/* This is tunable. 4 gives good results. */
+extern unsigned long int cycles, nextevent, is_lastline;
-#ifdef LINUX_SOUND_SLOW_MACHINE
+extern unsigned long int sample_evtime;
-#define cycles_per_instruction 8
-#else
-#define cycles_per_instruction 4
-#endif
-
-#undef DEFFERED_INT
-#if !defined(NO_FAST_BLITTER)
-#define DEFERRED_INT
-#endif
-
-extern unsigned long int cycles, nextevent, nextev_count;
 typedef void (*evfunc)(void);
 
 struct ev
@@ -30,8 +22,10 @@ struct ev
 
 enum { 
     ev_hsync, ev_copper, ev_cia,
-#ifdef DEFERRED_INT
+    ev_blitter, ev_diskblk, ev_diskindex,
-    ev_deferint,
+#ifndef DONT_WANT_SOUND
+    ev_aud0, ev_aud1, ev_aud2, ev_aud3,
+    ev_sample,
 #endif
     ev_max
 };
@@ -43,36 +37,65 @@ static __inline__ void events_schedule(void)
     int i;
     
     unsigned long int mintime = ~0L;
-    nextevent = cycles + mintime;
     for(i = 0; i < ev_max; i++) {
-	unsigned long int eventtime = eventtab[i].evtime + eventtab[i].oldcycles - cycles;
+	if (eventtab[i].active) {	    
-	if (eventtab[i].active && eventtime < mintime) {	    
+	    unsigned long int eventtime = eventtab[i].evtime - cycles;
-	    mintime = eventtime;
+	    if (eventtime < mintime)
-	    nextevent = cycles + mintime;
+	        mintime = eventtime;
 	}
     }
-    nextev_count = nextevent - cycles;
+    nextevent = cycles + mintime;
 }
 
-static __inline__ void do_cycles(void)
+static __inline__ void do_cycles_slow(void)
 {
-    if (nextev_count <= cycles_per_instruction) {
+#ifdef FRAME_RATE_HACK
+    if (is_lastline && eventtab[ev_hsync].evtime-cycles <= M68K_SPEED
+	&& (long int)(read_processor_time () - vsyncmintime) < 0)
+	return;
+#endif
+    if ((nextevent - cycles) <= M68K_SPEED) {
 	int j;
-	for(j = 0; j < cycles_per_instruction; j++) {
+	for(j = 0; j < M68K_SPEED; j++) {
 	    if (++cycles == nextevent) {
-		unsigned long int old_nextevent = nextevent;
 		int i;
 		
 		for(i = 0; i < ev_max; i++) {
-		    if (eventtab[i].active && (eventtab[i].evtime + eventtab[i].oldcycles) == old_nextevent) {
+		    if (eventtab[i].active && eventtab[i].evtime == cycles) {
 			(*eventtab[i].handler)();
 		    }
 		}
 		events_schedule();
-	    } else nextev_count--;
+	    }
 	}
     } else {
-    	nextev_count -= cycles_per_instruction;
+	cycles += M68K_SPEED;
-	cycles += cycles_per_instruction;
     }
 }
+
+static __inline__ void do_cycles_fast(void)
+{
+#ifdef FRAME_RATE_HACK
+    if (is_lastline && eventtab[ev_hsync].evtime-cycles <= 1
+	&& (long int)(read_processor_time () - vsyncmintime) < 0)
+	return;
+#endif
+    cycles++;
+    if (nextevent == cycles) {
+	int i;
+		
+	for(i = 0; i < ev_max; i++) {
+	    if (eventtab[i].active && eventtab[i].evtime == cycles) {
+		(*eventtab[i].handler)();
+	    }
+	}
+	events_schedule();
+    }
+
+}
+
+#if M68K_SPEED == 1
+#define do_cycles do_cycles_fast
+#else
+#define do_cycles do_cycles_slow
+#endif

MCUME_teensy/teensyuae41/execlib.h

@@ -0,0 +1,38 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  *
+  * Miscellaneous bits for exec emulation
+  *
+  * Copyright 1996 Bernd Schmidt
+  */
+
+#define CMD_INVALID 0
+#define CMD_RESET   1
+#define CMD_READ    2
+#define CMD_WRITE   3
+#define CMD_UPDATE  4
+#define CMD_CLEAR   5
+#define CMD_STOP    6
+#define CMD_START   7
+#define CMD_FLUSH   8
+#define CMD_NONSTD  9
+
+#define NT_TASK     1
+#define NT_DEVICE   3
+#define NT_MSGPORT  4
+#define NT_MESSAGE  5
+#define NT_FREEMSG  6
+#define NT_REPLYMSG 7
+#define NT_RESOURCE 8
+#define NT_LIBRARY  9
+#define NT_SIGNALSEM 15
+
+#define MEMF_PUBLIC 1
+#define MEMF_CHIP 2
+#define MEMF_FAST 4
+#define MEMF_LOCAL 256
+#define MEMF_24BITDMA 512
+#define MEMF_CLEAR (1<<16)
+#define MEMF_LARGEST (1<<17)
+#define MEMF_REVERSE (1<<18)
+#define MEMF_TOTAL (1<<19)

MCUME_teensy/teensyuae41/expansion.c

@@ -1,18 +1,21 @@
-#include "shared.h"
-
-#ifdef HAS_EXPANMEM
  /* 
   * UAE - The Un*x Amiga Emulator
   * 
   *  Expansion Slots
   *
-  * (c) 1996 Stefan Reinauer
+  * Copyright 1996 Stefan Reinauer <stepan@matrix.kommune.schokola.de>
   */
 
+#include "shared.h"
 
+#include "uae.h"
 #include "memory.h"
 #include "custom.h"
+#include "readcpu.h"
 #include "newcpu.h"
+#include "autoconf.h"
+
+#define MAX_EXPANSION_BOARDS 5
 
 /* 00 / 02 */
 
@@ -36,12 +39,13 @@
 
 /* ********************************************************** */
 
-/* Card Data - Where can I get a complete List of these ????  */
+/* Card Data */
 
 /* 04 - 06 & 10-16 */
 #define commodore_g   513  /* Commodore Braunschweig (Germany) */
 #define commodore     514  /* Commodore West Chester           */
 #define gvp	     2017  /* GVP */
+#define hackers_id   2011
 
 #define   commodore_a2091         3  /* A2091 / A590 Card from C=   */
 #define   commodore_a2091_ram    10  /* A2091 / A590 Ram on HD-Card */
@@ -78,51 +82,108 @@
 #define rom_install (0x01<<12) /* run code at install time  */
 #define rom_binddrv (0x02<<12) /* run code with binddrivers */
 
+uaecptr ROM_filesys_resname = 0, ROM_filesys_resid = 0;
+uaecptr ROM_filesys_diagentry = 0;
+uaecptr ROM_hardfile_resname = 0, ROM_hardfile_resid = 0;
+uaecptr ROM_hardfile_init = 0;
+
 /* ********************************************************** */
 
 static void expamem_init_clear(void);
-static void expamem_init_fastcard(void);
 static void expamem_map_clear(void);
+static void expamem_init_fastcard(void);
 static void expamem_map_fastcard(void);
+static void expamem_init_filesys(void);
+static void expamem_map_filesys(void);
 
-void (*card_init[5])(void) = {
+void (*card_init[MAX_EXPANSION_BOARDS])(void);
- expamem_init_fastcard,
+void (*card_map[MAX_EXPANSION_BOARDS])(void);
- expamem_init_clear,
- expamem_init_clear,
- expamem_init_clear,
- expamem_init_clear
-};
 
-void (*card_map[5])(void) = {
+int ecard = 0;
- expamem_map_fastcard,
- expamem_map_clear,
- expamem_map_clear,
- expamem_map_clear,
- expamem_map_clear
-};
 
-int card = 0;
+/*
-
-/* **********************************************************
  *  Fast Memory
- * ********************************************************** */
+ */
+
+static uae_u32 fastmem_mask;
+
+static uae_u32 fastmem_lget(uaecptr) REGPARAM;
+static uae_u32 fastmem_wget(uaecptr) REGPARAM;
+static uae_u32 fastmem_bget(uaecptr) REGPARAM;
+static void  fastmem_lput(uaecptr, uae_u32) REGPARAM;
+static void  fastmem_wput(uaecptr, uae_u32) REGPARAM;
+static void  fastmem_bput(uaecptr, uae_u32) REGPARAM;
+static int   fastmem_check(uaecptr addr, uae_u32 size) REGPARAM;
+static uae_u8 *fastmem_xlate(uaecptr addr) REGPARAM;
 
 #include "arduinoproto.h"
 
-static ULONG fastmem_start; /* Determined by the OS */
+static uae_u32 fastmem_start; /* Determined by the OS */
-//static UWORD *fastmemory = NULL;
+EXTMEM static uae_u8 fastmemory[fastmem_size];
-EXTMEM static UWORD fastmemory[fastmem_size/2];
 
+uae_u32 REGPARAM2 fastmem_lget(uaecptr addr)
+{
+    uae_u8 *m;
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    m = fastmemory + addr;
+    return do_get_mem_long ((uae_u32 *)m);
+}
 
+uae_u32 REGPARAM2 fastmem_wget(uaecptr addr)
+{
+    uae_u8 *m;
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    m = fastmemory + addr;
+    return do_get_mem_word ((uae_u16 *)m);
+}
 
-static ULONG fastmem_lget(CPTR) REGPARAM;
+uae_u32 REGPARAM2 fastmem_bget(uaecptr addr)
-static UWORD fastmem_wget(CPTR) REGPARAM;
+{
-static UBYTE fastmem_bget(CPTR) REGPARAM;
+    addr -= fastmem_start & fastmem_mask;
-static void  fastmem_lput(CPTR, ULONG) REGPARAM;
+    addr &= fastmem_mask;
-static void  fastmem_wput(CPTR, UWORD) REGPARAM;
+    return fastmemory[addr];
-static void  fastmem_bput(CPTR, UBYTE) REGPARAM;
+}
-static int   fastmem_check(CPTR addr, ULONG size) REGPARAM;
+
-static UWORD *fastmem_xlate(CPTR addr) REGPARAM;
+void REGPARAM2 fastmem_lput(uaecptr addr, uae_u32 l)
+{
+    uae_u8 *m;
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    m = fastmemory + addr;
+    do_put_mem_long ((uae_u32 *)m, l);
+}
+
+void REGPARAM2 fastmem_wput(uaecptr addr, uae_u32 w)
+{
+    uae_u8 *m;
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    m = fastmemory + addr;
+    do_put_mem_word ((uae_u16 *)m, w);
+}
+
+void REGPARAM2 fastmem_bput(uaecptr addr, uae_u32 b)
+{
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    fastmemory[addr] = b;
+}
+
+static int REGPARAM2 fastmem_check(uaecptr addr, uae_u32 size)
+{
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    return (addr + size) < fastmem_size;
+}
+
+static uae_u8 REGPARAM2 *fastmem_xlate(uaecptr addr)
+{
+    addr -= fastmem_start & fastmem_mask;
+    addr &= fastmem_mask;
+    return fastmemory + addr;
+}
 
 addrbank fastmem_bank = {
     fastmem_lget, fastmem_wget, fastmem_bget,
@@ -130,92 +191,90 @@ addrbank fastmem_bank = {
     fastmem_xlate, fastmem_check
 };
 
-static ULONG fastmem_lget(CPTR addr)
+
+#ifdef HAS_FILESYS
+/*
+ * Filesystem device ROM
+ * This is very simple, the Amiga shouldn't be doing things with it. 
+ */
+
+static uae_u32 filesys_lget(uaecptr) REGPARAM;
+static uae_u32 filesys_wget(uaecptr) REGPARAM;
+static uae_u32 filesys_bget(uaecptr) REGPARAM;
+static void  filesys_lput(uaecptr, uae_u32) REGPARAM;
+static void  filesys_wput(uaecptr, uae_u32) REGPARAM;
+static void  filesys_bput(uaecptr, uae_u32) REGPARAM;
+
+static uae_u32 filesys_start; /* Determined by the OS */
+
+#include "arduinoproto.h"
+
+EXTMEM uae_u8 filesysory[65536];
+
+uae_u32 REGPARAM2 filesys_lget(uaecptr addr)
 {
-    addr -= fastmem_start & (fastmem_size-1);
+    uae_u8 *m;
-    addr &= fastmem_size-1;
+    addr -= filesys_start & 65535;
-    return ((ULONG)fastmemory[addr >> 1] << 16) | fastmemory[(addr >> 1)+1];
+    addr &= 65535;
+    m = filesysory + addr;
+    return do_get_mem_long ((uae_u32 *)m);
 }
 
-static UWORD fastmem_wget(CPTR addr)
+uae_u32 REGPARAM2 filesys_wget(uaecptr addr)
 {
-    addr -= fastmem_start & (fastmem_size-1);
+    uae_u8 *m;
-    addr &= fastmem_size-1;
+    addr -= filesys_start & 65535;
-    return fastmemory[addr >> 1];
+    addr &= 65535;
+    m = filesysory + addr;
+    return do_get_mem_word ((uae_u16 *)m);
 }
 
-static UBYTE fastmem_bget(CPTR addr)
+uae_u32 REGPARAM2 filesys_bget(uaecptr addr)
 {
-    UWORD data;
+    addr -= filesys_start & 65535;
-    addr -= fastmem_start & (fastmem_size-1);
+    addr &= 65535;
-
+    return filesysory[addr];
-    addr &= fastmem_size-1;
-    data = fastmemory[addr >> 1];
-    return addr & 1 ? data : data >> 8;
 }
 
-static void fastmem_lput(CPTR addr, ULONG l)
+static void REGPARAM2 filesys_lput(uaecptr addr, uae_u32 l)
 {
-    addr -= fastmem_start & (fastmem_size-1);
+    write_log ("filesys_lput called\n");
-    addr &= fastmem_size-1;
-    fastmemory[addr >> 1] = l >> 16;
-    fastmemory[(addr >> 1)+1] = (UWORD)l;
 }
 
-static void fastmem_wput(CPTR addr, UWORD w)
+static void REGPARAM2 filesys_wput(uaecptr addr, uae_u32 w)
 {
-    addr -= fastmem_start & (fastmem_size-1);
+    write_log ("filesys_wput called\n");
-    addr &= fastmem_size-1;
-    fastmemory[addr >> 1] = w;
-
 }
 
-static void fastmem_bput(CPTR addr, UBYTE b)
+static void REGPARAM2 filesys_bput(uaecptr addr, uae_u32 b)
 {
-    addr -= fastmem_start & (fastmem_size-1);
+    fprintf (stderr, "filesys_bput called. This usually means that you are using\n");
-    addr &= fastmem_size-1;
+    fprintf (stderr, "Kickstart 1.2. Please give UAE the \"-a\" option next time\n");
-    if (!(addr & 1)) {
+    fprintf (stderr, "you start it. If you are _not_ using Kickstart 1.2, then\n");
-        fastmemory[addr>>1] = (fastmemory[addr>>1] & 0xff) | (((UWORD)b) << 8);
+    fprintf (stderr, "there's a bug somewhere.\n");
-    } else {
+    fprintf (stderr, "Exiting...\n");
-        fastmemory[addr>>1] = (fastmemory[addr>>1] & 0xff00) | b;
+    //uae_quit ();
-    }
-
 }
 
-static int fastmem_check(CPTR addr, ULONG size)
+addrbank filesys_bank = {
-{
+    filesys_lget, filesys_wget, filesys_bget,
-    addr -= fastmem_start & (fastmem_size-1);
+    filesys_lput, filesys_wput, filesys_bput,
-    addr &= fastmem_size-1;
+    default_xlate, default_check
-    return (addr + size) < fastmem_size;
+};
-}
+#endif
-
-static UWORD *fastmem_xlate(CPTR addr)
-{
-    addr -= fastmem_start & (fastmem_size-1);
-    addr &= fastmem_size-1;
-    return fastmemory + (addr >> 1);
-}
-/* ******************************************************* */
 
 /* Autoconfig address space at 0xE80000 */
-static UWORD expamem[0x8000];
+EXTMEM static uae_u8 expamem[65536];
 
-static UBYTE expamem_lo;
+static uae_u8 expamem_lo;
-static UBYTE expamem_hi;
+static uae_u8 expamem_hi;
 
-static ULONG expamem_lget(CPTR) REGPARAM;
+static uae_u32 expamem_lget(uaecptr) REGPARAM;
-static UWORD expamem_wget(CPTR) REGPARAM;
+static uae_u32 expamem_wget(uaecptr) REGPARAM;
-static UBYTE expamem_bget(CPTR) REGPARAM;
+static uae_u32 expamem_bget(uaecptr) REGPARAM;
-static void  expamem_lput(CPTR, ULONG) REGPARAM;
+static void  expamem_lput(uaecptr, uae_u32) REGPARAM;
-static void  expamem_wput(CPTR, UWORD) REGPARAM;
+static void  expamem_wput(uaecptr, uae_u32) REGPARAM;
-static void  expamem_bput(CPTR, UBYTE) REGPARAM;
+static void  expamem_bput(uaecptr, uae_u32) REGPARAM;
-
-static void  expamem_write(CPTR addr, UBYTE value)
-{
-    addr &= 0xffff;
-    expamem[(addr >> 1)] = (value & 0xf0) << 8;
-    expamem[(addr >> 1)+1] = (value & 0x0f) << 12;
-}
 
 addrbank expamem_bank = {
     expamem_lget, expamem_wget, expamem_bget,
@@ -223,40 +282,52 @@ addrbank expamem_bank = {
     default_xlate, default_check
 };
 
-static ULONG expamem_lget(CPTR addr)
+static uae_u32 REGPARAM2 expamem_lget(uaecptr addr)
 {
-    fprintf(stderr,"warning: READ.L from address $%lx \n",addr);
+    sprintf (warning_buffer, "warning: READ.L from address $%lx \n", addr);
-    return 0xffffffff;
+    write_log (warning_buffer);
+    return 0xfffffffful;
 }
 
-static UWORD expamem_wget(CPTR addr)
+static uae_u32 REGPARAM2 expamem_wget(uaecptr addr)
 {
-    fprintf(stderr,"warning: READ.W from address $%lx \n",addr);
+    sprintf (warning_buffer, "warning: READ.W from address $%lx \n", addr);
+    write_log (warning_buffer);
     return 0xffff;
 }
 
-static UBYTE expamem_bget(CPTR addr)
+static uae_u32 REGPARAM2 expamem_bget(uaecptr addr)
 {
-    UBYTE value;
+    uae_u8 value;
     addr &= 0xFFFF;
-    value = (expamem[addr >> 1] >> (addr & 1 ? 0 : 8));
+    return expamem[addr];
-    if (addr==00 || addr==02 || addr==0x40 || addr==0x42)
-	return value;
-    return ~value;
 }
 
-static void expamem_lput(CPTR addr, ULONG value)
+static void  REGPARAM2 expamem_write(uaecptr addr, uae_u32 value)
 {
-  fprintf(stderr,"warning: WRITE.L to address $%lx : value $%lx\n",addr,value);
+    addr &= 0xffff;
+    if (addr==00 || addr==02 || addr==0x40 || addr==0x42) {
+	expamem[addr] = (value & 0xf0);
+	expamem[addr+2] = (value & 0x0f) << 4;
+    } else {
+	expamem[addr] = ~(value & 0xf0);
+	expamem[addr+2] = ~((value & 0x0f) << 4);
+    }
 }
 
-static void expamem_wput(CPTR addr, UWORD value)
+static void REGPARAM2 expamem_lput(uaecptr addr, uae_u32 value)
 {
-  fprintf(stderr,"warning: WRITE.W to address $%lx : value $%x\n",addr,value);
+    fprintf(stderr,"warning: WRITE.L to address $%lx : value $%lx\n",addr,value);
 }
 
-static void expamem_bput(CPTR addr, UBYTE value)
+static void REGPARAM2 expamem_wput(uaecptr addr, uae_u32 value)
 {
+    fprintf(stderr,"warning: WRITE.W to address $%lx : value $%x\n",addr,value);
+}
+
+static void REGPARAM2 expamem_bput(uaecptr addr, uae_u32 value)
+{
+    static char buffer[80];
     switch (addr&0xff) {
      case 0x30:
      case 0x32:
@@ -267,11 +338,14 @@ static void expamem_bput(CPTR addr, UBYTE value)
 
      case 0x48:
 	expamem_hi = value;
-        (*card_map[card])();
+        (*card_map[ecard])();
-        fprintf (stderr,"   Card %d done.\n",card+1);
+        sprintf (buffer, "   Card %d done.\n",ecard+1);
-        ++card;
+	write_log (buffer);
-        if (card<=5) (*card_init[card])();
+        ++ecard;
-           else      expamem_init_clear();
+        if (ecard <= MAX_EXPANSION_BOARDS)
+	    (*card_init[ecard])();
+	else
+	    expamem_init_clear();
        	break;
     
      case 0x4a:	
@@ -279,80 +353,196 @@ static void expamem_bput(CPTR addr, UBYTE value)
 	break;
 	
      case 0x4c:
-        fprintf (stderr,"   Card %d had no success.\n",card+1);
+        sprintf (buffer,"   Card %d had no success.\n",ecard+1);
-        ++card;
+	write_log (buffer);
-        if (card<=5) (*card_init[card])();
+        ++ecard;
-           else      expamem_init_clear();
+        if (ecard <= MAX_EXPANSION_BOARDS) 
+	    (*card_init[ecard])();
+	else  
+	    expamem_init_clear();
         break;
     }
 }
 
 void expamem_reset()
 {
-    card = 0;
+    int cardno = 0;
-    (*card_init[card])();
+
+    ecard = 0;
+    
+    if (fastmemory != NULL) {
+	card_init[cardno] = expamem_init_fastcard;
+	card_map[cardno++] = expamem_map_fastcard;
+    }
+
+
+#ifdef HAS_FILESYS
+    if (currprefs.automount_uaedev) {
+ #ifdef HAS_ERSATZ         
+       if (!ersatzkickfile)
+ #endif       
+       { 
+	       card_init[cardno] = expamem_init_filesys;
+	       card_map[cardno++] = expamem_map_filesys;
+       }
+    }
+#endif    
+
+    while (cardno < MAX_EXPANSION_BOARDS) {
+	card_init[cardno] = expamem_init_clear;
+	card_map[cardno++] = expamem_map_clear;
+    }
+    
+    (*card_init[0])();
 }
 
-/* ***************************************************************
+
+
+
+void expansion_init(void)
+{
+    if (fastmem_size > 0) {
+	   fastmem_mask = fastmem_size - 1;
+	   //fastmemory = (uae_u8 *)calloc(fastmem_size,1);
+	   //if (fastmemory == NULL) {
+	   //    write_log ("Out of memory for fastmem card.\n");
+	   //}
+    }
+}
+
+/*
  *     Expansion Card (ZORRO II) for 1/2/4/8 MB of Fast Memory
- * *************************************************************** */
+ */
 
 void expamem_map_fastcard()
 {
-  //if (fastmemory == NULL)
+    char buffer[80];
-  //    fastmemory = (UWORD *)malloc(fastmem_size);
+    fastmem_start = ((expamem_hi|(expamem_lo>>4)) << 16);
-  fastmem_start=((expamem_hi|(expamem_lo>>4))<<16);
+    map_banks (&fastmem_bank, fastmem_start >> 16, fastmem_size >> 16);
-  map_banks(fastmem_bank,fastmem_start>>16,fastmem_size>>16);
+    sprintf (buffer, "Fastcard: mapped @$%lx: %dMB fast memory\n",fastmem_start, fastmem_size >>20);
-  fprintf (stderr,"Fastcard: mapped @$%lx: %dMB fast memory\n",fastmem_start, fastmem_size >>20);
+    write_log (buffer);
 }
 
 void expamem_init_fastcard()
 {
-  if (fastmem_size == 0) {
+    expamem_init_clear();
-     ++card;
+    if (fastmem_size==0x100000)
-     if (card<=5) (*card_init[card])();
+	expamem_write (0x00, MEM_1MB+add_memory+generic);
-        else      expamem_init_clear();
+    else if (fastmem_size==0x200000)
-     return;
+	expamem_write (0x00, MEM_2MB+add_memory+generic);
-  }
+    else if (fastmem_size==0x400000)
-  expamem_init_clear();
+	expamem_write (0x00, MEM_4MB+add_memory+generic);
-  if (fastmem_size==0x100000)
+    else if (fastmem_size==0x800000)
-    expamem_write (0x00, MEM_1MB+add_memory+generic);
+	expamem_write (0x00, MEM_8MB+add_memory+generic);
-  else if (fastmem_size==0x200000)
-    expamem_write (0x00, MEM_2MB+add_memory+generic);
-  else if (fastmem_size==0x400000)
-    expamem_write (0x00, MEM_4MB+add_memory+generic);
-  else if (fastmem_size==0x800000)
-    expamem_write (0x00, MEM_8MB+add_memory+generic);
 
-  expamem_write (0x08, care_addr);
+    expamem_write (0x08, care_addr);
 
-  expamem_write (0x04, commodore_a2091_ram);
+    expamem_write (0x04, 1);
-  expamem_write (0x10, commodore>>8);
+    expamem_write (0x10, hackers_id >> 8);
-  expamem_write (0x14, commodore & 0x0f);
+    expamem_write (0x14, hackers_id & 0x0f);
 
-  expamem_write (0x18, 0x00); /* ser.no. Byte 0 */
+    expamem_write (0x18, 0x00); /* ser.no. Byte 0 */
-  expamem_write (0x1c, 0x00); /* ser.no. Byte 1 */
+    expamem_write (0x1c, 0x00); /* ser.no. Byte 1 */
-  expamem_write (0x20, 0x00); /* ser.no. Byte 2 */
+    expamem_write (0x20, 0x00); /* ser.no. Byte 2 */
-  expamem_write (0x24, 0x01); /* ser.no. Byte 3 */
+    expamem_write (0x24, 0x01); /* ser.no. Byte 3 */
 
-  expamem_write (0x28, 0x00); /* Rom-Offset hi  */
+    expamem_write (0x28, 0x00); /* Rom-Offset hi  */
-  expamem_write (0x2c, 0x00); /* ROM-Offset lo  */
+    expamem_write (0x2c, 0x00); /* ROM-Offset lo  */
 
-  expamem_write (0x40, 0x00); /* Ctrl/Statusreg.*/
+    expamem_write (0x40, 0x00); /* Ctrl/Statusreg.*/
 }
 
-/* *********************************************************
+
+#ifdef HAS_FILESYS
+/* 
+ * Filesystem device
+ */
+
+void expamem_map_filesys()
+{
+    uaecptr a;
+    
+    filesys_start = ((expamem_hi | (expamem_lo >> 4)) << 16);
+    map_banks(&filesys_bank, filesys_start >> 16, 1);
+    /* 68k code needs to know this. */
+    a = here ();
+    org (0xF0FFFC);
+    dl (filesys_start + 0x2000);
+    org (a);
+}
+
+void expamem_init_filesys()
+{
+    uae_u8 diagarea[] = { 0x90, 0x00, 0x01, 0x0C, 0x01, 0x00, 0x01, 0x06 };
+
+    expamem_init_clear();
+    expamem_write (0x00, MEM_64KB | rom_card | generic);
+
+    expamem_write (0x08, care_addr | no_shutup);
+
+    expamem_write (0x04, 2);
+    expamem_write (0x10, hackers_id >> 8);
+    expamem_write (0x14, hackers_id & 0x0f);
+
+    expamem_write (0x18, 0x00); /* ser.no. Byte 0 */
+    expamem_write (0x1c, 0x00); /* ser.no. Byte 1 */
+    expamem_write (0x20, 0x00); /* ser.no. Byte 2 */
+    expamem_write (0x24, 0x01); /* ser.no. Byte 3 */
+
+    expamem_write (0x28, 0x10); /* Rom-Offset hi  */
+    expamem_write (0x2c, 0x00); /* ROM-Offset lo  */
+
+    expamem_write (0x40, 0x00); /* Ctrl/Statusreg.*/
+
+    /* Build a DiagArea */
+    memcpy(expamem + 0x1000, diagarea, sizeof diagarea);
+    
+    /* Call DiagEntry */
+    do_put_mem_word ((uae_u16 *)(expamem + 0x1100), 0x4EF9); /* JMP */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x1102), ROM_filesys_diagentry);
+
+    /* What comes next is a plain bootblock */
+    do_put_mem_word ((uae_u16 *)(expamem + 0x1106), 0x4EF9); /* JMP */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x1108), EXPANSION_bootcode);
+    
+    /* Build a DOS param packet template */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 12), 0); /* Device flags */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 16), 16); /* Env. size */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 20), 128); /* 512 bytes/block */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 24), 0); /* unused */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 28), 1); /* heads */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 32), 1); /* unused */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 36), 32); /* secs per track */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 40), 1); /* reserved blocks */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 44), 0); /* unused */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 48), 0); /* interleave */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 52), 0); /* lowCyl */
+    {
+    extern int numtracks;
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 56), numtracks-1); /* upperCyl */
+    }
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 60), 0); /* Number of buffers */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 64), 0); /* Buffer mem type */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 68), 0x7FFFFFFF); /* largest transfer */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 72), ~1); /* addMask (?) */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 76), (uae_u32)-1); /* bootPri */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 80), 0x444f5300); /* DOS\0 */
+    do_put_mem_long ((uae_u32 *)(expamem + 0x2000 + 84), 0); /* pad */
+    
+    memcpy(filesysory, expamem, 0x3000);
+}
+#endif
+
+/*
  *  Dummy Entries to show that there's no card in a slot
- * ********************************************************* */
+ */
 
 void expamem_map_clear()
 {
-  /* nothing to do here */
+    fprintf(stderr, "expamem_map_clear() got called. Shouldn't happen.\n");
 }
 
 void expamem_init_clear()
 {
-  memset (expamem,0,sizeof expamem);
+    memset (expamem,0xff,sizeof expamem);
 }
-
-#endif

MCUME_teensy/teensyuae41/filesys.c

@@ -0,0 +1,327 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  *
+  * Unix file system handler for AmigaDOS
+  *
+  * Copyright 1996 Ed Hanway
+  * Copyright 1996, 1997 Bernd Schmidt
+  *
+  * Version 0.4: 970308
+  *
+  * Based on example code (c) 1988 The Software Distillery
+  * and published in Transactor for the Amiga, Volume 2, Issues 2-5.
+  * (May - August 1989)
+  *
+  * Known limitations:
+  * Does not support ACTION_INHIBIT (big deal).
+  * Does not support any 2.0+ packet types (except ACTION_SAME_LOCK)
+  * Does not support removable volumes.
+  * May not return the correct error code in some cases.
+  * Does not check for sane values passed by AmigaDOS.  May crash the emulation
+  * if passed garbage values.
+  * Could do tighter checks on malloc return values.
+  * Will probably fail spectacularly in some cases if the filesystem is
+  * modified at the same time by another process while UAE is running.
+  */
+
+#include "shared.h"
+
+#ifdef HAS_FILESYS
+
+#include "uae.h"
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "xwin.h"
+#include "filesys.h"
+#include "autoconf.h"
+#include "compiler.h"
+
+extern uae_u8 filesysory[65536];
+
+typedef struct {
+    char *devname; /* device name, e.g. UAE0: */
+    uaecptr devname_amiga;
+    uaecptr startup;
+    char *volname; /* volume name, e.g. CDROM, WORK, etc. */
+    char *rootdir; /* root unix directory */
+    int readonly; /* disallow write access? */
+    int devno;
+} UnitInfo;
+
+#define MAX_UNITS 20
+static int num_units = 0, num_filesys_units = 0;
+static UnitInfo ui[MAX_UNITS];
+uaecptr filesys_initcode;
+static uae_u32 fsdevname, filesys_configdev;
+
+void add_filesys_unit(char *volname, char *rootdir, int readonly)
+{
+    if (num_units >= MAX_UNITS) {
+	write_log ("Maximum number of file systems mounted.\n");
+	return;
+    }
+
+    if (volname != 0) {
+	    num_filesys_units++;
+	    ui[num_units].volname = my_strdup(volname);	
+    } else
+	    ui[num_units].volname = 0;
+    //ui[num_units].rootdir = my_strdup(rootdir);
+    ui[num_units].readonly = readonly;
+
+    num_units++;
+}
+
+void filesys_store_devinfo (uae_u8 *where)
+{
+    int i;
+
+    do_put_mem_long ((uae_u32 *)where, EXPANSION_explibname);
+    do_put_mem_long ((uae_u32 *)(where + 4), filesys_configdev);
+    do_put_mem_long ((uae_u32 *)(where + 8), EXPANSION_doslibname);
+    do_put_mem_long ((uae_u32 *)(where + 12), num_units);
+
+    where += 16;
+
+    for (i = 0; i < num_units; i++) {
+	int is_hardfile = ui[i].volname == 0;
+	uae_u32 *thisdev = (uae_u32 *)where;
+  emu_printf("what is filesys:");
+	if (is_hardfile)
+    emu_printf("filesys is hdd");
+	do_put_mem_long (thisdev, ui[i].devname_amiga);	
+	do_put_mem_long (thisdev + 1, is_hardfile ? ROM_hardfile_resname : fsdevname);
+	do_put_mem_long (thisdev + 2, ui[i].devno);
+	do_put_mem_long (thisdev + 3, is_hardfile);
+
+	where += 16;
+    }
+}
+
+
+static uae_u32 startup_handler (void)
+{
+    return 0;
+}
+
+static uae_u32 exter_int_helper (void)
+{
+    return 0;
+}
+
+
+static uae_u32 filesys_handler(void)
+{
+    return 0;
+}
+
+void filesys_reset (void)
+{
+}
+
+void filesys_prepare_reset (void)
+{
+}
+
+static uae_u32 filesys_diagentry(void)
+{
+  
+    uaecptr resaddr = m68k_areg(regs, 2) + 0x10;
+    
+    filesys_configdev = m68k_areg(regs, 3);
+    
+    filesys_store_devinfo (filesysory + 0x2100);
+
+    if (ROM_hardfile_resid != 0) {
+	/* Build a struct Resident. This will set up and initialize
+	 * the uae.device */
+	put_word(resaddr + 0x0, 0x4AFC);
+	put_long(resaddr + 0x2, resaddr);
+	put_long(resaddr + 0x6, resaddr + 0x1A); /* Continue scan here */
+	put_word(resaddr + 0xA, 0x8101); /* RTF_AUTOINIT|RTF_COLDSTART; Version 1 */
+	put_word(resaddr + 0xC, 0x0305); /* NT_DEVICE; pri 05 */
+	put_long(resaddr + 0xE, ROM_hardfile_resname);
+	put_long(resaddr + 0x12, ROM_hardfile_resid);
+	put_long(resaddr + 0x16, ROM_hardfile_init); /* calls filesys_init */
+    }
+    resaddr += 0x1A;
+
+    filesys_reset ();
+    /* The good thing about this function is that it always gets called
+     * when we boot. So we could put all sorts of stuff that wants to be done
+     * here. */
+ 
+    return 1;
+}
+
+static uae_u32 filesys_dev_remember(void)
+{
+    /* In: a3: devicenode, d6: unit_no */
+
+    ui[m68k_dreg (regs, 6)].startup = get_long(m68k_areg (regs, 3) + 28);
+    return m68k_areg (regs, 3);
+}
+
+
+
+void filesys_install (void)
+{
+    int i;
+    uaecptr loop;
+
+    ROM_filesys_resname = ds("UAEunixfs.resource");
+    ROM_filesys_resid = ds("UAE unixfs 0.4");
+
+    fsdevname = ds("uae.device"); /* does not really exist */
+
+    for(i = 0; i < num_units; i++) {
+	   ui[i].devno = get_new_device(&ui[i].devname, &ui[i].devname_amiga);
+    }
+
+    ROM_filesys_diagentry = here();
+    calltrap (deftrap(filesys_diagentry)); dw(RTS);
+    
+    loop = here ();
+    /* Special trap for the assembly make_dev routine */
+    org(0xF0FF20);
+    calltrap (deftrap (filesys_dev_remember));
+    dw(RTS);
+
+    org(0xF0FF30);
+    calltrap (deftrap (filesys_handler));
+    dw(RTS);
+
+    org(0xF0FF40);
+    calltrap (deftrap (startup_handler));
+    dw(RTS);
+
+    org(0xF0FF50);
+    calltrap (deftrap (exter_int_helper));
+    dw(RTS);
+
+    org(0xF0FF70);
+    calltrap (deftrap (mousehack_helper));
+    dw(RTS);
+
+    org (loop);    
+}
+
+void filesys_install_code (void)
+{
+    align(4);
+
+    /* The last offset comes from the code itself, look for it near the top. */
+    filesys_initcode = here() + 8 + 0x6c;
+    EXPANSION_bootcode = here () + 8 + 0x14;
+    /* Ouch. Make sure this is _always_ a multiple of two bytes. */
+ db(0x00); db(0x00); db(0x00); db(0x10); db(0x00); db(0x00); db(0x00); db(0x00);
+ db(0x60); db(0x00); db(0x01); db(0xda); db(0x00); db(0x00); db(0x01); db(0x2c);
+ db(0x00); db(0x00); db(0x00); db(0x6c); db(0x00); db(0x00); db(0x00); db(0x28);
+ db(0x00); db(0x00); db(0x00); db(0x14); db(0x43); db(0xfa); db(0x03); db(0x13);
+ db(0x4e); db(0xae); db(0xff); db(0xa0); db(0x20); db(0x40); db(0x20); db(0x28);
+ db(0x00); db(0x16); db(0x20); db(0x40); db(0x4e); db(0x90); db(0x4e); db(0x75);
+ db(0x48); db(0xe7); db(0x00); db(0x20); db(0x70); db(0x00); db(0x4e); db(0xb9);
+ db(0x00); db(0xf0); db(0xff); db(0x50); db(0x4a); db(0x80); db(0x67); db(0x2e);
+ db(0x2c); db(0x78); db(0x00); db(0x04); db(0x70); db(0x02); db(0x4e); db(0xb9);
+ db(0x00); db(0xf0); db(0xff); db(0x50); db(0x4a); db(0x80); db(0x67); db(0x14);
+ db(0x24); db(0x40); db(0x70); db(0x03); db(0x4e); db(0xb9); db(0x00); db(0xf0);
+ db(0xff); db(0x50); db(0x20); db(0x4a); db(0x22); db(0x40); db(0x4e); db(0xae);
+ db(0xfe); db(0x92); db(0x60); db(0xe0); db(0x70); db(0x04); db(0x4e); db(0xb9);
+ db(0x00); db(0xf0); db(0xff); db(0x50); db(0x70); db(0x01); db(0x4c); db(0xdf);
+ db(0x04); db(0x00); db(0x4e); db(0x75); db(0x48); db(0xe7); db(0xff); db(0xfe);
+ db(0x2c); db(0x78); db(0x00); db(0x04); db(0x2a); db(0x79); db(0x00); db(0xf0);
+ db(0xff); db(0xfc); db(0x43); db(0xfa); db(0x02); db(0xb9); db(0x70); db(0x24);
+ db(0x7a); db(0x00); db(0x4e); db(0xae); db(0xfd); db(0xd8); db(0x4a); db(0x80);
+ db(0x66); db(0x0c); db(0x43); db(0xfa); db(0x02); db(0xa9); db(0x70); db(0x00);
+ db(0x7a); db(0x01); db(0x4e); db(0xae); db(0xfd); db(0xd8); db(0x28); db(0x40);
+ db(0x70); db(0x58); db(0x72); db(0x01); db(0x4e); db(0xae); db(0xff); db(0x3a);
+ db(0x26); db(0x40); db(0x7e); db(0x54); db(0x27); db(0xb5); db(0x78); db(0x00);
+ db(0x78); db(0x00); db(0x59); db(0x87); db(0x64); db(0xf6); db(0x7c); db(0x00);
+ db(0xbc); db(0xad); db(0x01); db(0x0c); db(0x64); db(0x12); db(0x20); db(0x4b);
+ db(0x48); db(0xe7); db(0x02); db(0x10); db(0x7e); db(0x01); db(0x61); db(0x6c);
+ db(0x4c); db(0xdf); db(0x08); db(0x40); db(0x52); db(0x86); db(0x60); db(0xe8);
+ db(0x2c); db(0x78); db(0x00); db(0x04); db(0x22); db(0x4c); db(0x4e); db(0xae);
+ db(0xfe); db(0x62); db(0x61); db(0x28); db(0x2c); db(0x78); db(0x00); db(0x04);
+ db(0x4e); db(0xb9); db(0x00); db(0xf0); db(0xff); db(0x80); db(0x72); db(0x03);
+ db(0x74); db(0xf6); db(0x20); db(0x7c); db(0x00); db(0x20); db(0x00); db(0x00);
+ db(0x90); db(0x88); db(0x65); db(0x0a); db(0x67); db(0x08); db(0x78); db(0x00);
+ db(0x22); db(0x44); db(0x4e); db(0xae); db(0xfd); db(0x96); db(0x4c); db(0xdf);
+ db(0x7f); db(0xff); db(0x4e); db(0x75); db(0x2c); db(0x78); db(0x00); db(0x04);
+ db(0x70); db(0x1a); db(0x22); db(0x3c); db(0x00); db(0x01); db(0x00); db(0x01);
+ db(0x4e); db(0xae); db(0xff); db(0x3a); db(0x22); db(0x40); db(0x41); db(0xfa);
+ db(0x02); db(0x0a); db(0x23); db(0x48); db(0x00); db(0x0a); db(0x41); db(0xfa);
+ db(0xff); db(0x10); db(0x23); db(0x48); db(0x00); db(0x0e); db(0x41); db(0xfa);
+ db(0xff); db(0x08); db(0x23); db(0x48); db(0x00); db(0x12); db(0x70); db(0x0d);
+ db(0x4e); db(0xee); db(0xff); db(0x58); db(0x2a); db(0x79); db(0x00); db(0xf0);
+ db(0xff); db(0xfc); db(0x26); db(0x06); db(0xe9); db(0x8b); db(0xd6); db(0xbc);
+ db(0x00); db(0x00); db(0x01); db(0x10); db(0x20); db(0x35); db(0x38); db(0x0c);
+ db(0xc0); db(0x85); db(0x66); db(0xb6); db(0x20); db(0xb5); db(0x38); db(0x00);
+ db(0x21); db(0x75); db(0x38); db(0x04); db(0x00); db(0x04); db(0x21); db(0x75);
+ db(0x38); db(0x08); db(0x00); db(0x08); db(0x2c); db(0x4c); db(0x4e); db(0xae);
+ db(0xff); db(0x70); db(0x26); db(0x40); db(0x4e); db(0xb9); db(0x00); db(0xf0);
+ db(0xff); db(0x20); db(0x70); db(0x00); db(0x27); db(0x40); db(0x00); db(0x08);
+ db(0x27); db(0x40); db(0x00); db(0x10); db(0x27); db(0x40); db(0x00); db(0x20);
+ db(0x20); db(0x35); db(0x38); db(0x0c); db(0x4a); db(0x80); db(0x66); db(0x1c);
+ db(0x27); db(0x7c); db(0x00); db(0x00); db(0x0f); db(0xa0); db(0x00); db(0x14);
+ db(0x43); db(0xfa); db(0xfe); db(0x7a); db(0x20); db(0x09); db(0xe4); db(0x88);
+ db(0x27); db(0x40); db(0x00); db(0x20); db(0x27); db(0x7c); db(0xff); db(0xff);
+ db(0xff); db(0xff); db(0x00); db(0x24); db(0x4a); db(0x87); db(0x67); db(0x36);
+ db(0x2c); db(0x78); db(0x00); db(0x04); db(0x70); db(0x14); db(0x72); db(0x00);
+ db(0x4e); db(0xae); db(0xff); db(0x3a); db(0x22); db(0x40); db(0x70); db(0x00);
+ db(0x22); db(0x80); db(0x23); db(0x40); db(0x00); db(0x04); db(0x33); db(0x40);
+ db(0x00); db(0x0e); db(0x30); db(0x3c); db(0x10); db(0xff); db(0x90); db(0x06);
+ db(0x33); db(0x40); db(0x00); db(0x08); db(0x23); db(0x6d); db(0x01); db(0x04);
+ db(0x00); db(0x0a); db(0x23); db(0x4b); db(0x00); db(0x10); db(0x41); db(0xec);
+ db(0x00); db(0x4a); db(0x4e); db(0xee); db(0xfe); db(0xf2); db(0x20); db(0x4b);
+ db(0x72); db(0x00); db(0x22); db(0x41); db(0x70); db(0xff); db(0x2c); db(0x4c);
+ db(0x4e); db(0xee); db(0xff); db(0x6a); db(0x2c); db(0x78); db(0x00); db(0x04);
+ db(0x70); db(0x00); db(0x22); db(0x40); db(0x4e); db(0xae); db(0xfe); db(0xda);
+ db(0x20); db(0x40); db(0x4b); db(0xe8); db(0x00); db(0x5c); db(0x43); db(0xfa);
+ db(0x01); db(0x39); db(0x70); db(0x00); db(0x4e); db(0xae); db(0xfd); db(0xd8);
+ db(0x24); db(0x40); db(0x20); db(0x3c); db(0x00); db(0x00); db(0x00); db(0x9d);
+ db(0x22); db(0x3c); db(0x00); db(0x01); db(0x00); db(0x01); db(0x4e); db(0xae);
+ db(0xff); db(0x3a); db(0x26); db(0x40); db(0x7c); db(0x00); db(0x26); db(0x86);
+ db(0x27); db(0x46); db(0x00); db(0x04); db(0x27); db(0x46); db(0x00); db(0x08);
+ db(0x7a); db(0x00); db(0x20); db(0x4d); db(0x4e); db(0xae); db(0xfe); db(0x80);
+ db(0x20); db(0x4d); db(0x4e); db(0xae); db(0xfe); db(0x8c); db(0x28); db(0x40);
+ db(0x26); db(0x2c); db(0x00); db(0x0a); db(0x70); db(0x00); db(0x4e); db(0xb9);
+ db(0x00); db(0xf0); db(0xff); db(0x40); db(0x60); db(0x74); db(0x20); db(0x4d);
+ db(0x4e); db(0xae); db(0xfe); db(0x80); db(0x20); db(0x4d); db(0x4e); db(0xae);
+ db(0xfe); db(0x8c); db(0x28); db(0x40); db(0x26); db(0x2c); db(0x00); db(0x0a);
+ db(0x66); db(0x38); db(0x70); db(0x01); db(0x4e); db(0xb9); db(0x00); db(0xf0);
+ db(0xff); db(0x50); db(0x45); db(0xeb); db(0x00); db(0x04); db(0x20); db(0x52);
+ db(0x20); db(0x08); db(0x67); db(0xda); db(0x22); db(0x50); db(0x20); db(0x40);
+ db(0x20); db(0x28); db(0x00); db(0x04); db(0x6a); db(0x16); db(0x48); db(0xe7);
+ db(0x00); db(0xc0); db(0x28); db(0x68); db(0x00); db(0x0a); db(0x61); db(0x40);
+ db(0x53); db(0x85); db(0x4c); db(0xdf); db(0x03); db(0x00); db(0x24); db(0x89);
+ db(0x20); db(0x49); db(0x60); db(0xdc); db(0x24); db(0x48); db(0x20); db(0x49);
+ db(0x60); db(0xd6); db(0xba); db(0xbc); db(0x00); db(0x00); db(0x00); db(0x14);
+ db(0x65); db(0x08); db(0x70); db(0x01); db(0x29); db(0x40); db(0x00); db(0x04);
+ db(0x60); db(0x0e); db(0x61); db(0x2a); db(0x4e); db(0xb9); db(0x00); db(0xf0);
+ db(0xff); db(0x30); db(0x4a); db(0x80); db(0x67); db(0x0c); db(0x52); db(0x85);
+ db(0x28); db(0xab); db(0x00); db(0x04); db(0x27); db(0x4c); db(0x00); db(0x04);
+ db(0x60); db(0x8c); db(0x28); db(0x43); db(0x61); db(0x02); db(0x60); db(0x86);
+ db(0x22); db(0x54); db(0x20); db(0x6c); db(0x00); db(0x04); db(0x29); db(0x4d);
+ db(0x00); db(0x04); db(0x4e); db(0xee); db(0xfe); db(0x92); db(0x2f); db(0x05);
+ db(0x7a); db(0xfc); db(0x24); db(0x53); db(0x2e); db(0x0a); db(0x22); db(0x0a);
+ db(0x67); db(0x0a); db(0x52); db(0x85); db(0x67); db(0x1e); db(0x22); db(0x4a);
+ db(0x24); db(0x52); db(0x60); db(0xf2); db(0x52); db(0x85); db(0x67); db(0x3c);
+ db(0x24); db(0x47); db(0x70); db(0x18); db(0x72); db(0x01); db(0x4e); db(0xae);
+ db(0xff); db(0x3a); db(0x52); db(0x46); db(0x24); db(0x40); db(0x24); db(0x87);
+ db(0x2e); db(0x0a); db(0x60); db(0xe8); db(0x20); db(0x12); db(0x67); db(0x24);
+ db(0x20); db(0x40); db(0x20); db(0x10); db(0x67); db(0x1e); db(0x20); db(0x40);
+ db(0x20); db(0x10); db(0x67); db(0x18); db(0x70); db(0x00); db(0x22); db(0x80);
+ db(0x22); db(0x4a); db(0x24); db(0x51); db(0x70); db(0x18); db(0x4e); db(0xae);
+ db(0xff); db(0x2e); db(0xdc); db(0xbc); db(0x00); db(0x01); db(0x00); db(0x00);
+ db(0x20); db(0x0a); db(0x66); db(0xec); db(0x26); db(0x87); db(0x2a); db(0x1f);
+ db(0x4e); db(0x75); db(0x55); db(0x41); db(0x45); db(0x20); db(0x66); db(0x69);
+ db(0x6c); db(0x65); db(0x73); db(0x79); db(0x73); db(0x74); db(0x65); db(0x6d);
+ db(0x00); db(0x64); db(0x6f); db(0x73); db(0x2e); db(0x6c); db(0x69); db(0x62);
+ db(0x72); db(0x61); db(0x72); db(0x79); db(0x00); db(0x65); db(0x78); db(0x70);
+ db(0x61); db(0x6e); db(0x73); db(0x69); db(0x6f); db(0x6e); db(0x2e); db(0x6c);
+ db(0x69); db(0x62); db(0x72); db(0x61); db(0x72); db(0x79); db(0x00); db(0x00);
+}
+
+#endif

MCUME_teensy/teensyuae41/filesys.h

@@ -0,0 +1,15 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  *
+  * Unix file system handler for AmigaDOS
+  *
+  * Copyright 1997 Bernd Schmidt
+  */
+
+#define A_FIBF_SCRIPT  (1<<6)
+#define A_FIBF_PURE    (1<<5)
+#define A_FIBF_ARCHIVE (1<<4)
+#define A_FIBF_READ    (1<<3)
+#define A_FIBF_WRITE   (1<<2)
+#define A_FIBF_EXECUTE (1<<1)
+#define A_FIBF_DELETE  (1<<0)

MCUME_teensy/teensyuae41/gensound.h

@@ -0,0 +1,23 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  *
+  * Prototypes for general sound related functions
+  * This use to be called sound.h, but that causes confusion
+  *
+  * Copyright 1997 Bernd Schmidt
+  */
+
+extern int sound_available;
+
+/* Determine if we can produce any sound at all. */
+extern int setup_sound (void);
+
+extern int init_sound (void);
+extern void close_sound (void);
+
+extern void sample16_handler (void);
+extern void sample8_handler (void);
+extern void sample_ulaw_handler (void);
+extern void init_sound_table16(void);
+extern void init_sound_table8(void);
+

MCUME_teensy/teensyuae41/gui.h

@@ -7,10 +7,9 @@
   */
 
 extern int gui_init(void);
+extern int gui_update(void);
 extern void gui_exit(void);
 extern void gui_led(int, int);
 extern void gui_handle_events(void);
-extern void gui_filename(int, char *);
+extern void gui_filename(int, const char *);
-
+extern void gui_changesettings(void);
-extern int quit_program;
-

MCUME_teensy/teensyuae41/hardfile.c

@@ -0,0 +1,274 @@
+ /*
+  * UAE - The Un*x Amiga Emulator
+  *
+  * AutoConfig devices
+  *
+  * (c) 1995 Bernd Schmidt
+  */
+
+#include "shared.h"
+
+#ifdef HAS_HARDFILE
+
+#include "memory.h"
+#include "custom.h"
+#include "readcpu.h"
+#include "newcpu.h"
+#include "disk.h"
+#include "xwin.h"
+#include "autoconf.h"
+#include "execlib.h"
+
+static int opencount = 0;
+static long hardfile_size = 0;
+int numtracks = 512;
+
+static uae_u32 hardfile_open(void)
+{
+    uaecptr tmp1 = m68k_areg(regs, 1); /* IOReq */
+
+    /* Check unit number */
+    if (m68k_dreg(regs, 0) == 0) {
+	opencount++;
+	put_word (m68k_areg(regs, 6)+32, get_word (m68k_areg(regs, 6)+32) + 1);
+	put_long (tmp1+24, 0); /* io_Unit */
+	put_byte (tmp1+31, 0); /* io_Error */
+	put_byte (tmp1+8, 7); /* ln_type = NT_REPLYMSG */
+	return 0;
+    }
+
+    put_long (tmp1+20, (uae_u32)-1);
+    put_byte (tmp1+31, (uae_u8)-1);
+    return (uae_u32)-1;
+}
+
+static uae_u32 hardfile_close(void)
+{
+    opencount--;
+    put_word (m68k_areg(regs, 6)+32, get_word (m68k_areg(regs, 6)+32) - 1);
+
+    return 0;
+}
+
+static uae_u32 hardfile_expunge(void)
+{
+    return 0; /* Simply ignore this one... */
+}
+
+static uae_u32 hardfile_beginio(void)
+{
+    uae_u32 tmp1, tmp2, dataptr, offset;
+    uae_u32 retval = m68k_dreg(regs, 0);
+
+    tmp1 = m68k_areg(regs, 1);
+#define DEBUGME
+#ifdef DEBUGME
+    printf ("hardfile: tmp1 = %08lx\n", (unsigned long)tmp1);
+    printf ("hardfile: cmd  = %d\n", (int)get_word(tmp1+28));
+#endif
+    
+    put_byte (tmp1+8, NT_MESSAGE);
+    put_byte (tmp1+31, 0); /* no error yet */
+    tmp2 = get_word (tmp1+28); /* io_Command */
+/*    put_byte (tmp1 + 30, get_byte (tmp1 + 30) & ~1);*/
+    switch (tmp2) {
+     case CMD_READ:
+	dataptr = get_long (tmp1 + 40);
+	if (dataptr & 1)
+	    goto bad_command;
+	offset = get_long (tmp1 + 44);
+	if (offset & 511)
+	    goto bad_command;
+	tmp2 = get_long (tmp1 + 36); /* io_Length */
+	if (tmp2 & 511)
+	    goto bad_command;
+	if (tmp2 + offset > (uae_u32)numtracks * 32 * 512)
+	    goto bad_command;
+
+	put_long (tmp1 + 32, tmp2); /* set io_Actual */
+	emu_FileSeek (offset, SEEK_SET);
+	while (tmp2) {
+	    int i;
+	    char buffer[512];
+	    emu_FileRead (buffer, 512);
+	    for (i = 0; i < 512; i++, dataptr++)
+		put_byte(dataptr, buffer[i]);
+	    tmp2 -= 512;
+	}
+	break;
+
+     case CMD_WRITE:
+     case 11: /* Format */
+	dataptr = get_long (tmp1 + 40);
+	if (dataptr & 1)
+	    goto bad_command;
+	offset = get_long (tmp1 + 44);
+	if (offset & 511)
+	    goto bad_command;
+	tmp2 = get_long (tmp1 + 36); /* io_Length */
+	if (tmp2 & 511)
+	    goto bad_command;
+	if (tmp2 + offset > (uae_u32)numtracks * 32 * 512)
+	    goto bad_command;
+
+	put_long (tmp1 + 32, tmp2); /* set io_Actual */
+	emu_FileSeek (offset, SEEK_SET);
+	while (tmp2) {
+	    char buffer[512];
+	    int i;
+	    for (i=0; i < 512; i++, dataptr++)
+		buffer[i] = get_byte(dataptr);
+	    // JMH not supported : write (uaedevfd, buffer, 512);
+	    tmp2 -= 512;
+	}
+	break;
+
+	bad_command:
+	break;
+
+     case 18: /* GetDriveType */
+	put_long (tmp1 + 32, 1); /* not exactly a 3.5" drive, but... */
+	break;
+
+     case 19: /* GetNumTracks */
+	put_long (tmp1 + 32, numtracks);
+	break;
+
+	/* Some commands that just do nothing and return zero */
+     case CMD_UPDATE:
+     case CMD_CLEAR:
+     case 9: /* Motor */
+     case 10: /* Seek */
+     case 12: /* Remove */
+     case 13: /* ChangeNum */
+     case 14: /* ChangeStatus */
+     case 15: /* ProtStatus */
+     case 20: /* AddChangeInt */
+     case 21: /* RemChangeInt */
+	put_long (tmp1+32, 0); /* io_Actual */
+	retval = 0;
+	break;
+
+     default:
+	/* Command not understood. */
+	put_byte (tmp1+31, (uae_u8)-3); /* io_Error */
+	retval = 0;
+	break;
+    }
+#if 0
+    if ((get_byte (tmp1+30) & 1) == 0) {
+	/* Not IOF_QUICK -- need to ReplyMsg */
+	m68k_areg(regs, 1) = tmp1;
+	CallLib (get_long(4), -378);
+    }
+#endif
+    return retval;
+}
+
+static uae_u32 hardfile_abortio(void)
+{
+    return (uae_u32)-3;
+}
+
+
+void hardfile_install(void)
+{
+    uae_u32 functable, datatable, inittable;
+    uae_u32 initcode, openfunc, closefunc, expungefunc;
+    uae_u32 beginiofunc, abortiofunc;
+
+    emu_printf("looking hdd");
+    hardfile_size = emu_FileSize(currprefs.hf0);
+    //if (hardfile_size == 0) return;
+    emu_FileOpen(currprefs.hf0);
+
+    emu_printi(hardfile_size);
+    
+
+    ROM_hardfile_resname = ds("hardfile.device");
+    ROM_hardfile_resid = ds("UAE hardfile.device 0.2");
+
+    numtracks = hardfile_size / 16384;
+
+    /* initcode */
+#if 0
+    initcode = here();
+    calltrap(deftrap(hardfile_init)); dw(RTS);
+#else
+    initcode = filesys_initcode;
+#endif
+    /* Open */
+    openfunc = here();
+    calltrap(deftrap(hardfile_open)); dw(RTS);
+
+    /* Close */
+    closefunc = here();
+    calltrap(deftrap(hardfile_close)); dw(RTS);
+
+    /* Expunge */
+    expungefunc = here();
+    calltrap(deftrap(hardfile_expunge)); dw(RTS);
+
+    /* BeginIO */
+    beginiofunc = here();
+    calltrap(deftrap(hardfile_beginio));
+    dw (0x48E7); dw (0x8002); /* movem.l d0/a6,-(a7) */
+    dw (0x0829); dw (0); dw (30); /* btst #0,30(a1) */
+    dw (0x6608); /* bne.b +8 */
+    dw (0x2C78); dw (0x0004); /* move.l 4,a6 */
+    dw (0x4EAE); dw (-378); /* jsr ReplyMsg(a6) */
+    dw (0x4CDF); dw (0x4001); /* movem.l (a7)+,d0/a6 */
+    dw(RTS);
+
+    /* AbortIO */
+    abortiofunc = here();
+    calltrap(deftrap(hardfile_abortio)); dw(RTS);
+
+    /* FuncTable */
+    functable = here();
+    dl(openfunc); /* Open */
+    dl(closefunc); /* Close */
+    dl(expungefunc); /* Expunge */
+    dl(EXPANSION_nullfunc); /* Null */
+    dl(beginiofunc); /* BeginIO */
+    dl(abortiofunc); /* AbortIO */
+    dl(0xFFFFFFFFul); /* end of table */
+
+    /* DataTable */
+    datatable = here();
+    dw(0xE000); /* INITuae_s8 */
+    dw(0x0008); /* LN_TYPE */
+    dw(0x0300); /* NT_DEVICE */
+    dw(0xC000); /* INITuae_s32 */
+    dw(0x000A); /* LN_NAME */
+    dl(ROM_hardfile_resname);
+    dw(0xE000); /* INITuae_s8 */
+    dw(0x000E); /* LIB_FLAGS */
+    dw(0x0600); /* LIBF_SUMUSED | LIBF_CHANGED */
+    dw(0xD000); /* INITuae_s16 */
+    dw(0x0014); /* LIB_VERSION */
+    dw(0x0004); /* 0.4 */
+    dw(0xD000);
+    dw(0x0016); /* LIB_REVISION */
+    dw(0x0000);
+    dw(0xC000);
+    dw(0x0018); /* LIB_IDSTRING */
+    dl(ROM_hardfile_resid);
+    dw(0x0000); /* end of table */
+
+    ROM_hardfile_init = here();
+    dl(0x00000100); /* ??? */
+    dl(functable);
+    dl(datatable);
+    dl(initcode);
+
+    if (hardfile_size > 0) {
+	   uaecptr initfunc;
+	   add_filesys_unit(NULL, "hardfile", 1);
+     emu_printf("HDD installed");
+    }
+}
+
+
+
+#endif

MCUME_teensy/teensyuae41/joystick.h

@@ -26,7 +26,7 @@
 #define _LINUX_JOYSTICK_H
 
 
-
+#ifdef unused
 
 /*
  * Version
@@ -130,5 +130,6 @@ struct JS_DATA_SAVE_TYPE_64 {
 	struct JS_DATA_TYPE JS_CORR;
 };
 
+#endif
 
 #endif /* _LINUX_JOYSTICK_H */

MCUME_teensy/teensyuae41/keyboard.h

@@ -9,6 +9,8 @@
 /* First, two dummies */
 #define AK_mousestuff 0x100
 #define AK_inhibit 0x101
+/* This mutates into AK_CTRL in keybuf.c. */
+#define AK_RCTRL 0x103
 
 #define AK_A 0x20
 #define AK_B 0x35
@@ -116,4 +118,3 @@
 #define AK_BACKQUOTE 0x00
 #define AK_MINUS 0x0B
 #define AK_EQUAL 0x0C
-

MCUME_teensy/teensyuae41/keybuf.c

@@ -4,46 +4,69 @@
   * Keyboard buffer. Not really needed for X, but for SVGAlib and possibly
   * Mac and DOS ports.
   * 
-  * (c) 1995 Bernd Schmidt
+  * Note: it's possible to have two threads in UAE, one reading keystrokes
+  * and the other one writing them. Despite this, no synchronization effort
+  * is needed. This code should be perfectly thread safe. At least if you
+  * assume that integer store instructions are atomic.
+  * 
+  * Copyright 1995, 1997 Bernd Schmidt
   */
 
 #include "shared.h"
 
-//#include <assert.h>
+#include <assert.h>
-
 #include "keybuf.h"
 #include "keyboard.h"
+#include "joystick.h"
 
-/* This is cryptic, but hey, it works! */
+static int fakestate[3][5] = { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } };
-int fakestate[5] = { 0, 0, 0, 0, 0 };
 
-void getjoystate(UWORD *st, int *button)
+static int *fs_np;
+static int *fs_ck;
+static int *fs_se;
+
+void getjoystate(int nr, unsigned int *st, int *button)
 {
-    if (fake_joystick) {
+    int *fake = 0;
-	int top = fakestate[0];
+    
-	int bot = fakestate[3];
+    if (JSEM_ISJOY0 (nr, currprefs.fake_joystick))
-	if (fakestate[1]) top = !top;
+	nr = 0;
-	if (fakestate[2]) bot = !bot;
+    else if (JSEM_ISJOY1 (nr, currprefs.fake_joystick))
-	*st = bot | (fakestate[2] << 1) | (top << 8) | (fakestate[1] << 9);
+	nr = 1;
-	*button = fakestate[4];
+    else if (JSEM_ISMOUSE (nr, currprefs.fake_joystick)) {
+	*st = 0;
+	*button = 0;
+	return;
     } else
-	read_joystick(st, button);
+	fake = fakestate[nr];
+
+    if (fake) {
+	int top = fake[0];
+	int bot = fake[3];
+	if (fake[1]) top = !top;
+	if (fake[2]) bot = !bot;
+	*st = bot | (fake[2] << 1) | (top << 8) | (fake[1] << 9);
+	*button = fake[4];
+    } else
+	read_joystick (nr, st, button);
 }
 
-static int kpb_first, kpb_last;
+/* Not static so the DOS code can mess with them */
+int kpb_first, kpb_last;
 
-static int keybuf[256];
+int keybuf[256];
 
 int keys_available (void)
 {
-    return kpb_first != kpb_last;
+    int val;
+    val = kpb_first != kpb_last;
+    return val;
 }
 
 int get_next_key (void)
 {
     int key;
-    
+    assert (kpb_first != kpb_last);
-    //assert (kpb_first != kpb_last);
     
     key = keybuf[kpb_last];
     if (++kpb_last == 256) 
@@ -58,23 +81,65 @@ void record_key (int kc)
     if (kpb_next == 256)
 	kpb_next = 0;
     if (kpb_next == kpb_last) {
-	emu_printf("Keyboard buffer overrun. Congratulations.\n");
+	write_log ("Keyboard buffer overrun. Congratulations.\n");
 	return;
     }
-    if (fake_joystick) {
+    if (fs_np != 0) {
 	switch (kc >> 1) {
-	 case AK_NP8: fakestate[0] = !(kc & 1); return;
+	 case AK_NP8: fs_np[0] = !(kc & 1); return;
-	 case AK_NP4: fakestate[1] = !(kc & 1); return;
+	 case AK_NP4: fs_np[1] = !(kc & 1); return;
-	 case AK_NP6: fakestate[2] = !(kc & 1); return;
+	 case AK_NP6: fs_np[2] = !(kc & 1); return;
-	 case AK_NP2: fakestate[3] = !(kc & 1); return;
+	 case AK_NP2: fs_np[3] = !(kc & 1); return;
-	 case AK_NP0: case AK_NP5: fakestate[4] = !(kc & 1); return;
+	 case AK_NP0: case AK_NP5: fs_np[4] = !(kc & 1); return;
 	}
     }
+    if (fs_ck != 0) {
+	switch (kc >> 1) {
+	 case AK_UP: fs_ck[0] = !(kc & 1); return;
+	 case AK_LF: fs_ck[1] = !(kc & 1); return;
+	 case AK_RT: fs_ck[2] = !(kc & 1); return;
+	 case AK_DN: fs_ck[3] = !(kc & 1); return;
+	 case AK_RCTRL: fs_ck[4] = !(kc & 1); return;
+	}
+    }
+    if (fs_se != 0) {
+	switch (kc >> 1) {
+	 case AK_T: fs_se[0] = !(kc & 1); return;
+	 case AK_F: fs_se[1] = !(kc & 1); return;
+	 case AK_H: fs_se[2] = !(kc & 1); return;
+	 case AK_B: fs_se[3] = !(kc & 1); return;
+	 case AK_LALT: fs_se[4] = !(kc & 1); return;
+	}
+    }
+    if (kc == AK_RCTRL)
+	kc = AK_CTRL;
     keybuf[kpb_first] = kc;
     kpb_first = kpb_next;
 }
 
+void joystick_setting_changed (void)
+{
+    fs_np = fs_ck = fs_se = 0;
+
+    if (JSEM_ISNUMPAD (0, currprefs.fake_joystick))
+	fs_np = fakestate[0];
+    else if (JSEM_ISNUMPAD (1, currprefs.fake_joystick))
+	fs_np = fakestate[1];
+    
+    if (JSEM_ISCURSOR (0, currprefs.fake_joystick))
+	fs_ck = fakestate[0];
+    else if (JSEM_ISCURSOR (1, currprefs.fake_joystick))
+	fs_ck = fakestate[1];
+
+    if (JSEM_ISSOMEWHEREELSE (0, currprefs.fake_joystick))
+	fs_se = fakestate[0];
+    else if (JSEM_ISSOMEWHEREELSE (1, currprefs.fake_joystick))
+	fs_se = fakestate[1];
+    
+}
+
 void keybuf_init (void)
 {
     kpb_first = kpb_last = 0;
+    joystick_setting_changed ();
 }

MCUME_teensy/teensyuae41/keybuf.h

@@ -11,4 +11,5 @@ extern int get_next_key (void);
 extern int keys_available (void);
 extern void record_key (int);
 extern void keybuf_init (void);
-extern void getjoystate(UWORD *dir, int *button);
+extern void getjoystate (int nr, unsigned int *dir, int *button);
+extern void joystick_setting_changed (void);

MCUME_teensy/teensyuae41/machdep/m68k.h

@@ -0,0 +1,49 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * MC68000 emulation - machine dependent bits
+  *
+  * Copyright 1996 Bernd Schmidt
+  */
+
+ 
+struct flag_struct {
+    unsigned int c;
+    unsigned int z;
+    unsigned int n;
+    unsigned int v; 
+    unsigned int x;
+};
+
+extern struct flag_struct regflags;
+
+#define ZFLG (regflags.z)
+#define NFLG (regflags.n)
+#define CFLG (regflags.c)
+#define VFLG (regflags.v)
+#define XFLG (regflags.x)
+
+static __inline__ int cctrue(const int cc)
+{
+    switch(cc){
+     case 0: return 1;                       /* T */
+     case 1: return 0;                       /* F */
+     case 2: return !CFLG && !ZFLG;          /* HI */
+     case 3: return CFLG || ZFLG;            /* LS */
+     case 4: return !CFLG;                   /* CC */
+     case 5: return CFLG;                    /* CS */
+     case 6: return !ZFLG;                   /* NE */
+     case 7: return ZFLG;                    /* EQ */
+     case 8: return !VFLG;                   /* VC */
+     case 9: return VFLG;                    /* VS */
+     case 10:return !NFLG;                   /* PL */
+     case 11:return NFLG;                    /* MI */
+     case 12:return NFLG == VFLG;            /* GE */
+     case 13:return NFLG != VFLG;            /* LT */
+     case 14:return !ZFLG && (NFLG == VFLG); /* GT */
+     case 15:return ZFLG || (NFLG != VFLG);  /* LE */
+    }
+    abort();
+    return 0;
+}
+

MCUME_teensy/teensyuae41/machdep/memory.h

@@ -0,0 +1,58 @@
+ /* 
+  * UAE - The Un*x Amiga Emulator
+  * 
+  * Memory access functions
+  *
+  * Copyright 1996 Bernd Schmidt
+  */
+
+static __inline__ ULONG do_get_mem_long(ULONG *a)
+{
+    UBYTE *b = (UBYTE *)a;
+    
+    return (*b << 24) | (*(b+1) << 16) | (*(b+2) << 8) | (*(b+3));
+}
+
+static __inline__ UWORD do_get_mem_word(UWORD *a)
+{
+    UBYTE *b = (UBYTE *)a;
+    
+    return (*b << 8) | (*(b+1));
+}
+
+static __inline__ UBYTE do_get_mem_byte(UBYTE *a)
+{
+    return *a;
+}
+
+static __inline__ void do_put_mem_long(ULONG *a, ULONG v)
+{
+    UBYTE *b = (UBYTE *)a;
+    
+    *b = v >> 24;
+    *(b+1) = v >> 16;    
+    *(b+2) = v >> 8;
+    *(b+3) = v;
+}
+
+static __inline__ void do_put_mem_word(UWORD *a, UWORD v)
+{
+    UBYTE *b = (UBYTE *)a;
+    
+    *b = v >> 8;
+    *(b+1) = v;
+}
+
+static __inline__ void do_put_mem_byte(UBYTE *a, UBYTE v)
+{
+    *a = v;
+}
+
+#define call_mem_get_func(func, addr) ((*func)(addr))
+#define call_mem_put_func(func, addr, v) ((*func)(addr, v))
+
+#undef USE_MAPPED_MEMORY
+#undef CAN_MAP_MEMORY
+#undef NO_INLINE_MEMORY_ACCESS
+#undef MD_HAVE_MEM_1_FUNCS
+

MCUME_teensy/teensyuae41/memory.c

@@ -8,375 +8,445 @@
 
 #include "shared.h"
 
+#include "uae.h"
+#include "osdep/memory.h"
 #include "memory.h"
-#include "custom.h"
-#include "cia.h"
 #ifdef HAS_ERSATZ  
 #include "ersatz.h"
-int ersatzkickfile = 0;
 #endif
+#include "zfile.h"
 
+//#define HALF_KICKIMAGE 1
+//#define HAS_KICKFILE 1
 //#define HALF_CHIPMEM   1
 
-#define HALF_KICKIMAGE 1
+#ifdef HAS_ERSATZ  
-
+int ersatzkickfile = 0;
+#endif
 int buserr;
-addrbank membanks[256];
+
+addrbank *mem_banks[MEM_BANK_SIZE];
 
 
-/* Default memory access functions */
+#ifdef NO_INLINE_MEMORY_ACCESS
-
+__inline__ uae_u32 longget(uaecptr addr)
-int default_check(CPTR a, ULONG b)
 {
-    return 0;
+    return call_mem_get_func(get_mem_bank(addr).lget, addr);
 }
-
+__inline__ uae_u32 wordget(uaecptr addr)
-UWORD *default_xlate(CPTR a)
 {
-    emu_printf("Your Amiga program just did something terribly stupid\n");
+    return call_mem_get_func(get_mem_bank(addr).wget, addr);
-    return 0;
 }
+__inline__ uae_u32 byteget(uaecptr addr) 
+{
+    return call_mem_get_func(get_mem_bank(addr).bget, addr);
+}
+__inline__ void longput(uaecptr addr, uae_u32 l)
+{
+    call_mem_put_func(get_mem_bank(addr).lput, addr, l);
+}
+__inline__ void wordput(uaecptr addr, uae_u32 w)
+{
+    call_mem_put_func(get_mem_bank(addr).wput, addr, w);
+}
+__inline__ void byteput(uaecptr addr, uae_u32 b)
+{
+    call_mem_put_func(get_mem_bank(addr).bput, addr, b);
+}
+#endif
 
 /* A dummy bank that only contains zeros */
 
-ULONG dummy_lget(CPTR addr)
+static uae_u32 dummy_lget(uaecptr) REGPARAM;
+static uae_u32 dummy_wget(uaecptr) REGPARAM;
+static uae_u32 dummy_bget(uaecptr) REGPARAM;
+static void  dummy_lput(uaecptr, uae_u32) REGPARAM;
+static void  dummy_wput(uaecptr, uae_u32) REGPARAM;
+static void  dummy_bput(uaecptr, uae_u32) REGPARAM;
+static int   dummy_check(uaecptr addr, uae_u32 size) REGPARAM;
+
+uae_u32 REGPARAM2 dummy_lget(uaecptr addr)
 {
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal lget at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
     return 0;
 }
 
-UWORD dummy_wget(CPTR addr)
+uae_u32 REGPARAM2 dummy_wget(uaecptr addr)
 {
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal wget at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
     return 0;
 }
 
-UBYTE dummy_bget(CPTR addr)
+uae_u32 REGPARAM2 dummy_bget(uaecptr addr)
 {
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal bget at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
     return 0;
 }
 
-void dummy_lput(CPTR addr, ULONG l)
+void REGPARAM2 dummy_lput(uaecptr addr, uae_u32 l)
 {
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal lput at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
+}
+void REGPARAM2 dummy_wput(uaecptr addr, uae_u32 w)
+{
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal wput at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
+}
+void REGPARAM2 dummy_bput(uaecptr addr, uae_u32 b)
+{
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal bput at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
 }
 
-void dummy_wput(CPTR addr, UWORD w)
+int REGPARAM2 dummy_check(uaecptr addr, uae_u32 size)
-{
-}
-
-void dummy_bput(CPTR addr, UBYTE b)
-{
-}
-
-int dummy_check(CPTR addr, ULONG size)
 {
+    if (currprefs.illegal_mem) {
+	sprintf (warning_buffer, "Illegal check at %08lx\n", addr);
+	write_log (warning_buffer);
+    }
     return 0;
 }
 
-UWORD *dummy_xlate(CPTR addr)
-{
-    return NULL;
-}
-
 /* Chip memory */
 
+uae_u32 chipmem_mask,kickmem_mask,bogomem_mask;
+
+
 #include "arduinoproto.h"
 
 #ifdef HALF_CHIPMEM
-static UWORD *chipmemory=NULL;
+static uae_u8 *chipmemory=NULL;
-static UBYTE chipmemextra[chipmem_size/2];
+static uae_u8 chipmemextra[chipmem_size/2];
-UWORD *chipmemory2=(UWORD*)&chipmemextra[0];
+uae_u8 *chipmemory2=(UWORD*)&chipmemextra[0];
 #else
-EXTMEM static UWORD chipmemory[chipmem_size/2];
+EXTMEM static uae_u8 chipmemory[chipmem_size];
-UWORD *chipmemory2=NULL;
+uae_u8 *chipmemory2=NULL;
 #endif
 
 
-ULONG chipmem_lget(CPTR addr)
+static uae_u32 chipmem_lget(uaecptr) REGPARAM;
+static uae_u32 chipmem_wget(uaecptr) REGPARAM;
+static uae_u32 chipmem_bget(uaecptr) REGPARAM;
+static void  chipmem_lput(uaecptr, uae_u32) REGPARAM;
+static void  chipmem_wput(uaecptr, uae_u32) REGPARAM;
+static void  chipmem_bput(uaecptr, uae_u32) REGPARAM;
+
+static int   chipmem_check(uaecptr addr, uae_u32 size) REGPARAM;
+static uae_u8 *chipmem_xlate(uaecptr addr) REGPARAM;
+
+uae_u32 REGPARAM2 chipmem_lget(uaecptr addr)
 {
-    addr -= chipmem_start;
+    uae_u32 *m;
-    addr &= chipmem_size-1;
+    addr -= chipmem_start & chipmem_mask;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        return ((ULONG)chipmemory2[addr >> 1] << 16) | chipmemory2[(addr >> 1)+1];
+        m = (uae_u32 *)(chipmemory2 + addr);
+        return do_get_mem_long(m);
     }
 #endif      
-    return ((ULONG)chipmemory[addr >> 1] << 16) | chipmemory[(addr >> 1)+1];
+    m = (uae_u32 *)(chipmemory + addr);
+    return do_get_mem_long(m);
 }
 
-UWORD chipmem_wget(CPTR addr)
+uae_u32 REGPARAM2 chipmem_wget(uaecptr addr)
 {
-    addr -= chipmem_start;
+    uae_u16 *m;
-    addr &= chipmem_size-1;
+    addr -= chipmem_start & chipmem_mask;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        return chipmemory2[addr >> 1];
+        m = (uae_u16 *)(chipmemory2 + addr);
+        return do_get_mem_word(m);
     }
 #endif      
-    return chipmemory[addr >> 1];
+    m = (uae_u16 *)(chipmemory + addr);
+    return do_get_mem_word(m);
 }
 
-UBYTE chipmem_bget(CPTR addr)
+uae_u32 REGPARAM2 chipmem_bget(uaecptr addr)
 {
-    addr -= chipmem_start;
+    addr -= chipmem_start & chipmem_mask;
-    addr &= chipmem_size-1;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        if (addr & 1) 
+        return chipmemory2[addr];
-           return chipmemory2[addr >> 1];
-        else
-           return chipmemory2[addr >> 1] >> 8;
     }
 #endif      
-    if (addr & 1) 
+    return chipmemory[addr];
-	   return chipmemory[addr >> 1];
-    else
-	   return chipmemory[addr >> 1] >> 8;
 }
 
-void chipmem_lput(CPTR addr, ULONG l)
+void REGPARAM2 chipmem_lput(uaecptr addr, uae_u32 l)
 {
-    addr -= chipmem_start;
+    uae_u32 *m;
-    addr &= chipmem_size-1;
+    addr -= chipmem_start & chipmem_mask;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        chipmemory2[addr >> 1] = l >> 16;
+        m = (uae_u32 *)(chipmemory2 + addr);
-        chipmemory2[(addr >> 1)+1] = (UWORD)l;
+        do_put_mem_long(m, l);
         return;
     }
 #endif        
-    chipmemory[addr >> 1] = l >> 16;
+    m = (uae_u32 *)(chipmemory + addr);
-    chipmemory[(addr >> 1)+1] = (UWORD)l;
+    do_put_mem_long(m, l);
 }
 
-void chipmem_wput(CPTR addr, UWORD w)
+void REGPARAM2 chipmem_wput(uaecptr addr, uae_u32 w)
 {
-    addr -= chipmem_start;
+    uae_u16 *m;
-    addr &= chipmem_size-1;
+    addr -= chipmem_start & chipmem_mask;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        chipmemory2[addr >> 1] = w;
+        m = (uae_u16 *)(chipmemory2 + addr);
+        do_put_mem_word(m, w);
         return;
     }
 #endif      
-    chipmemory[addr >> 1] = w;
+    m = (uae_u16 *)(chipmemory + addr);
+    do_put_mem_word(m, w);
 }
 
-void chipmem_bput(CPTR addr, UBYTE b)
+void REGPARAM2 chipmem_bput(uaecptr addr, uae_u32 b)
 {
-    addr -= chipmem_start;
+    addr -= chipmem_start & chipmem_mask;
-    addr &= chipmem_size-1;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        if (!(addr & 1)) {
+        chipmemory2[addr] = b;
-          chipmemory2[addr>>1] = (chipmemory2[addr>>1] & 0xff) | (((UWORD)b) << 8);
-        } else {
-          chipmemory2[addr>>1] = (chipmemory2[addr>>1] & 0xff00) | b;
-        }    
         return;
     }
 #endif  
-    if (!(addr & 1)) {
+    chipmemory[addr] = b;
-      chipmemory[addr>>1] = (chipmemory[addr>>1] & 0xff) | (((UWORD)b) << 8);
-    } else {
-      chipmemory[addr>>1] = (chipmemory[addr>>1] & 0xff00) | b;
-    }    
 }
 
-int chipmem_check(CPTR addr, ULONG size)
+int REGPARAM2 chipmem_check(uaecptr addr, uae_u32 size)
 {
-    addr -= chipmem_start;
+    addr -= chipmem_start & chipmem_mask;
-    addr &= chipmem_size-1;
+    addr &= chipmem_mask;
     return (addr + size) < chipmem_size;
 }
 
-UWORD *chipmem_xlate(CPTR addr)
+uae_u8 REGPARAM2 *chipmem_xlate(uaecptr addr)
 {
-    addr -= chipmem_start;
+    addr -= chipmem_start & chipmem_mask;
-    addr &= chipmem_size-1;
+    addr &= chipmem_mask;
 #ifdef HALF_CHIPMEM
     if (addr >= 0x040000) {
         addr -= 0x040000;
-        return chipmemory2 + (addr >> 1);
+        return chipmemory2 + addr;
     }
 #endif    
-    return chipmemory + (addr >> 1);
+    return chipmemory + addr;
 }
 
-
-/* Kick memory */
-
-static int zkickfile = 0;
-
-#ifdef HAS_KICKFILE   
-static UWORD kick[kickmem_size/2];
-#else
-#ifdef HALF_KICKIMAGE
-#include "kick13_swapped.h"
-#else
-#include "kickfull_swapped.h"
-#endif
-#endif
-static UWORD *kickmemory=(UWORD*)&kick[0];
-
-
-static ULONG kickmem_lget(CPTR) REGPARAM;
-static UWORD kickmem_wget(CPTR) REGPARAM;
-static UBYTE kickmem_bget(CPTR) REGPARAM;
-static void  kickmem_lput(CPTR, ULONG) REGPARAM;
-static void  kickmem_wput(CPTR, UWORD) REGPARAM;
-static void  kickmem_bput(CPTR, UBYTE) REGPARAM;
-static int  kickmem_check(CPTR addr, ULONG size) REGPARAM;
-static UWORD *kickmem_xlate(CPTR addr) REGPARAM;
-
-
-ULONG kickmem_lget(CPTR addr)
-{
-    addr -= kickmem_start;
-    addr &= kickmem_size-1;
-#ifdef HALF_KICKIMAGE
-    if (addr >= 0x040000) {addr -= 0x040000;}
-#endif    
-    return ((ULONG)kickmemory[addr >> 1] << 16) | kickmemory[(addr >> 1)+1];
-}
-
-UWORD kickmem_wget(CPTR addr)
-{
-    addr -= kickmem_start;
-    addr &= kickmem_size-1;
-#ifdef HALF_KICKIMAGE
-    if (addr >= 0x040000) {addr -= 0x040000;}
-#endif    
-    return kickmemory[addr >> 1];
-}
-
-UBYTE kickmem_bget(CPTR addr)
-{
-    addr -= kickmem_start;
-    addr &= kickmem_size-1;
-#ifdef HALF_KICKIMAGE
-    if (addr >= 0x040000) {addr -= 0x040000;}
-#endif    
-    return kickmemory[addr >> 1] >> (addr & 1 ? 0 : 8);
-}
-
-void kickmem_lput(CPTR a, ULONG b)
-{
-}
-
-void kickmem_wput(CPTR a, UWORD b)
-{
-}
-
-void kickmem_bput(CPTR a, UBYTE b)
-{
-}
-
-int kickmem_check(CPTR addr, ULONG size)
-{
-    addr -= kickmem_start;
-    addr &= kickmem_size-1;
-    return (addr + size) < kickmem_size;
-}
-
-UWORD *kickmem_xlate(CPTR addr)
-{
-    addr -= kickmem_start;
-    addr &= kickmem_size-1;
- #ifdef HALF_KICKIMAGE
-    if (addr >= 0x040000) {addr -= 0x040000;}
-#endif    
-    return kickmemory + (addr >> 1);
-}
-
-
-
 #ifdef HAS_BOGOMEM 
 
 /* Slow memory */
 
-static UWORD *bogomemory;
+static uae_u8 *bogomemory;
 
-static ULONG bogomem_lget(CPTR) REGPARAM;
+static uae_u32 bogomem_lget(uaecptr) REGPARAM;
-static UWORD bogomem_wget(CPTR) REGPARAM;
+static uae_u32 bogomem_wget(uaecptr) REGPARAM;
-static UBYTE bogomem_bget(CPTR) REGPARAM;
+static uae_u32 bogomem_bget(uaecptr) REGPARAM;
-static void  bogomem_lput(CPTR, ULONG) REGPARAM;
+static void  bogomem_lput(uaecptr, uae_u32) REGPARAM;
-static void  bogomem_wput(CPTR, UWORD) REGPARAM;
+static void  bogomem_wput(uaecptr, uae_u32) REGPARAM;
-static void  bogomem_bput(CPTR, UBYTE) REGPARAM;
+static void  bogomem_bput(uaecptr, uae_u32) REGPARAM;
-static int  bogomem_check(CPTR addr, ULONG size) REGPARAM;
+static int  bogomem_check(uaecptr addr, uae_u32 size) REGPARAM;
-static UWORD *bogomem_xlate(CPTR addr) REGPARAM;
+static uae_u8 *bogomem_xlate(uaecptr addr) REGPARAM;
 
-ULONG bogomem_lget(CPTR addr)
+uae_u32 REGPARAM2 bogomem_lget(uaecptr addr)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    uae_u32 *m;
-    addr &= bogomem_size-1;
+    addr -= bogomem_start & bogomem_mask;
-    return ((ULONG)bogomemory[addr >> 1] << 16) | bogomemory[(addr >> 1)+1];
+    addr &= bogomem_mask;
+    m = (uae_u32 *)(bogomemory + addr);
+    return do_get_mem_long(m);
 }
 
-UWORD bogomem_wget(CPTR addr)
+uae_u32 REGPARAM2 bogomem_wget(uaecptr addr)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    uae_u16 *m;
-    addr &= bogomem_size-1;
+    addr -= bogomem_start & bogomem_mask;
-    return bogomemory[addr >> 1];
+    addr &= bogomem_mask;
+    m = (uae_u16 *)(bogomemory + addr);
+    return do_get_mem_word(m);
 }
 
-UBYTE bogomem_bget(CPTR addr)
+uae_u32 REGPARAM2 bogomem_bget(uaecptr addr)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    addr -= bogomem_start & bogomem_mask;
-    addr &= bogomem_size-1;
+    addr &= bogomem_mask;
-    if (addr & 1)
+    return bogomemory[addr];
-    return bogomemory[addr >> 1];
-    else
-    return bogomemory[addr >> 1] >> 8;
 }
 
-void bogomem_lput(CPTR addr, ULONG l)
+void REGPARAM2 bogomem_lput(uaecptr addr, uae_u32 l)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    uae_u32 *m;
-    addr &= bogomem_size-1;
+    addr -= bogomem_start & bogomem_mask;
-    bogomemory[addr >> 1] = l >> 16;
+    addr &= bogomem_mask;
-    bogomemory[(addr >> 1)+1] = (UWORD)l;
+    m = (uae_u32 *)(bogomemory + addr);
+    do_put_mem_long(m, l);
 }
 
-void bogomem_wput(CPTR addr, UWORD w)
+void REGPARAM2 bogomem_wput(uaecptr addr, uae_u32 w)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    uae_u16 *m;
-    addr &= bogomem_size-1;
+    addr -= bogomem_start & bogomem_mask;
-    bogomemory[addr >> 1] = w;
+    addr &= bogomem_mask;
+    m = (uae_u16 *)(bogomemory + addr);
+    do_put_mem_word(m, w);
 }
 
-void bogomem_bput(CPTR addr, UBYTE b)
+void REGPARAM2 bogomem_bput(uaecptr addr, uae_u32 b)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    addr -= bogomem_start & bogomem_mask;
-    addr &= bogomem_size-1;
+    addr &= bogomem_mask;
-    if (!(addr & 1)) {
+    bogomemory[addr] = b;
-    bogomemory[addr>>1] = (bogomemory[addr>>1] & 0xff) | (((UWORD)b) << 8);
-    } else {
-    bogomemory[addr>>1] = (bogomemory[addr>>1] & 0xff00) | b;
-    }
 }
 
-int bogomem_check(CPTR addr, ULONG size)
+int REGPARAM2 bogomem_check(uaecptr addr, uae_u32 size)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    addr -= bogomem_start & bogomem_mask;
-    addr &= bogomem_size-1;
+    addr &= bogomem_mask;
     return (addr + size) < bogomem_size;
 }
 
-UWORD *bogomem_xlate(CPTR addr)
+uae_u8 REGPARAM2 *bogomem_xlate(uaecptr addr)
 {
-    addr -= bogomem_start & (bogomem_size-1);
+    addr -= bogomem_start & bogomem_mask;
-    addr &= bogomem_size-1;
+    addr &= bogomem_mask;
-    return bogomemory + (addr >> 1);
+    return bogomemory + addr;
 }
 #endif
 
+/* Kick memory */
+
+static int zkickfile = 0;
 #ifdef HAS_KICKFILE   
-int processFileInMem(char * infile, char * outfile, char * arrname, unsigned char * data, int size) {
+static uae_u8 kick[kickmem_size];
+#else
+#ifdef HALF_KICKIMAGE
+#include "kick13.h"
+#else
+#include "kickfull.h"
+#endif
+#endif
+//static UWORD *kickmemory=(UWORD*)&kick[0];
+uae_u8 *kickmemory=(uae_u8*)&kick[0];;
+
+static uae_u32 kickmem_lget(uaecptr) REGPARAM;
+static uae_u32 kickmem_wget(uaecptr) REGPARAM;
+static uae_u32 kickmem_bget(uaecptr) REGPARAM;
+static void  kickmem_lput(uaecptr, uae_u32) REGPARAM;
+static void  kickmem_wput(uaecptr, uae_u32) REGPARAM;
+static void  kickmem_bput(uaecptr, uae_u32) REGPARAM;
+static int  kickmem_check(uaecptr addr, uae_u32 size) REGPARAM;
+static uae_u8 *kickmem_xlate(uaecptr addr) REGPARAM;
+
+uae_u32 REGPARAM2 kickmem_lget(uaecptr addr)
+{
+    uae_u32 *m;
+    addr -= kickmem_start & kickmem_mask;
+    addr &= kickmem_mask;
+#ifdef HALF_KICKIMAGE
+    if (addr >= 0x040000) {addr -= 0x040000;}
+#endif       
+    m = (uae_u32 *)(kickmemory + addr);
+    return do_get_mem_long(m); 
+}
+
+uae_u32 REGPARAM2 kickmem_wget(uaecptr addr)
+{
+    uae_u16 *m;
+    addr -= kickmem_start & kickmem_mask;
+    addr &= kickmem_mask;
+#ifdef HALF_KICKIMAGE
+    if (addr >= 0x040000) {addr -= 0x040000;}
+#endif       
+    m = (uae_u16 *)(kickmemory + addr);
+    return do_get_mem_word(m); 
+}
+
+uae_u32 REGPARAM2 kickmem_bget(uaecptr addr)
+{
+    addr -= kickmem_start & kickmem_mask;
+    addr &= kickmem_mask;
+#ifdef HALF_KICKIMAGE
+    if (addr >= 0x040000) {addr -= 0x040000;}
+#endif       
+    return kickmemory[addr];
+}
+
+void REGPARAM2 kickmem_lput(uaecptr addr, uae_u32 b)
+{
+    if (currprefs.illegal_mem) sprintf (warning_buffer, "Illegal kickmem lput at %08lx\n", addr);
+}
+
+void REGPARAM2 kickmem_wput(uaecptr addr, uae_u32 b)
+{
+    if (currprefs.illegal_mem) sprintf (warning_buffer, "Illegal kickmem wput at %08lx\n", addr);
+}
+
+void REGPARAM2 kickmem_bput(uaecptr addr, uae_u32 b)
+{
+    if (currprefs.illegal_mem) sprintf (warning_buffer, "Illegal kickmem lput at %08lx\n", addr);
+}
+
+int REGPARAM2 kickmem_check(uaecptr addr, uae_u32 size)
+{
+    addr -= kickmem_start & kickmem_mask;
+    addr &= kickmem_mask;
+    return (addr + size) < kickmem_size;
+}
+
+uae_u8 REGPARAM2 *kickmem_xlate(uaecptr addr)
+{
+    addr -= kickmem_start & kickmem_mask;
+    addr &= kickmem_mask;
+    return kickmemory + addr;
+}
+
+/* Default memory access functions */
+
+int REGPARAM2 default_check(uaecptr a, uae_u32 b)
+{
+    return 0;
+}
+
+uae_u8 REGPARAM2 *default_xlate(uaecptr a)
+{
+    write_log ("Your Amiga program just did something terribly stupid\n");
+    uae_reset();
+    return chipmem_xlate(0); /* So we don't crash. */
+}
+
+
+#ifdef HAS_KICKFILE
+int processFileInMem(char * outfile, char * arrname, unsigned char * data, int size) {
 
   FILE *fp_wr = stdout;
   if ((fp_wr = fopen (outfile, "wb")) == NULL)
@@ -407,62 +477,55 @@ int processFileInMem(char * infile, char * outfile, char * arrname, unsigned cha
 static int load_kickstart(void)
 {
     int i;
-    ULONG cksum = 0, prevck = 0;
+    uae_u32 cksum = 0, prevck = 0;
     unsigned char buffer[8];
     
-    FILE *f = fopen(romfile, "rb");
+    FILE *f = zfile_open(romfile, "rb");
     
     if (f == NULL) {	
-        emu_printf("No Kickstart ROM found.\n");
+        write_log ("No Kickstart ROM found.\n");
         return 0;
     }
     
     fread(buffer, 1, 8, f);
     if (buffer[4] == 0 && buffer[5] == 8 && buffer[6] == 0 && buffer[7] == 0) {
-	   emu_printf("You seem to have a ZKick file there... You probably lose.\n");
+	   fprintf (stderr, "You seem to have a ZKick file there... You probably lose.\n");
 	   zkickfile = 1;
     } else 
-	fseek(f, 0, SEEK_SET);
+	   fseek(f, 0, SEEK_SET);
     
-    i = fread(kick, 1, kickmem_size, f);
+    i = fread(kickmemory, 1, kickmem_size, f);
     if (i == kickmem_size/2) {
-	   emu_printf("Warning: Kickstart is only 256K.\n");
+/*	fprintf (stderr, "Warning: Kickstart is only 256K.\n"); */
-	   memcpy (kick + kickmem_size/4, kick, kickmem_size/2);
+	   memcpy (kickmemory + kickmem_size/2, kickmemory, kickmem_size/2);
-    } else if (i != kickmem_size) {
+    } 
-	   emu_printf("Error while reading Kickstart.\n");
+    else if (i != kickmem_size) {
+	   write_log ("Error while reading Kickstart.\n");
 	   return 0;
     }
-    fclose (f);
+    zfile_close (f);
-    
-    for (i = 0; i < kickmem_size/2; i++) {
-	   UWORD *p = kick + i;
-	   UBYTE *bp = (UBYTE *)p;
-	   *p = (*bp << 8) | *(bp+1);
-    }
     
 
-    for (i = 0; i < kickmem_size/4; i++) {
+    for (i = 0; i < kickmem_size; i+=4) {
-	   ULONG data = kick[i*2]*65536 + kick[i*2+1];
+	   uae_u32 data = kickmemory[i]*65536*256 + kickmemory[i+1]*65536 + kickmemory[i+2]*256 + kickmemory[i+3];
 	   cksum += data;
 	   if (cksum < prevck)
 	       cksum++;
 	   prevck = cksum;
     }
-    if (cksum != 0xFFFFFFFF) {
+    if (cksum != 0xFFFFFFFFul) {
-	   emu_printf("Warning: Kickstart checksum incorrect. You probably have a corrupted ROM image.\n");
+	   write_log("Kickstart checksum incorrect. You probably have a corrupted ROM image.\n");
     }
-
     return 1;
 }
 #endif
 
-
 /* Address banks */
 
 addrbank dummy_bank = {
     dummy_lget, dummy_wget, dummy_bget,
     dummy_lput, dummy_wput, dummy_bput,
-    dummy_xlate, dummy_check
+    default_xlate, dummy_check
 };
 
 addrbank chipmem_bank = {
@@ -471,12 +534,6 @@ addrbank chipmem_bank = {
     chipmem_xlate, chipmem_check
 };
 
-addrbank kickmem_bank = {
-    kickmem_lget, kickmem_wget, kickmem_bget,
-    kickmem_lput, kickmem_wput, kickmem_bput,
-    kickmem_xlate, kickmem_check
-};
-
 #ifdef HAS_BOGOMEM 
 addrbank bogomem_bank = {
     bogomem_lget, bogomem_wget, bogomem_bget,
@@ -485,11 +542,27 @@ addrbank bogomem_bank = {
 };
 #endif
 
+addrbank kickmem_bank = {
+    kickmem_lget, kickmem_wget, kickmem_bget,
+    kickmem_lput, kickmem_wput, kickmem_bput,
+    kickmem_xlate, kickmem_check
+};
+
+char *address_space, *good_address_map;
+int good_address_fd;
+#define MAKE_USER_PROGRAMS_BEHAVE 1
 void memory_init(void)
 {
     int i;
+    int custom_start;
+
     buserr = 0;
 
+    chipmem_mask = chipmem_size - 1;
+    kickmem_mask = kickmem_size - 1;
+    bogomem_mask = bogomem_size - 1;
+    
+
 #ifdef HALF_CHIPMEM
     chipmemory = (WORD*)emu_Malloc(chipmem_size/2);
     memset(chipmemory, 0, chipmem_size/2);
@@ -500,59 +573,78 @@ void memory_init(void)
     emu_printf("init done !!");
 #endif
 
-    for(i = 0; i < 256; i++)
+    if(!chipmemory) {
-	   membanks[i] = dummy_bank;
+	   write_log ("Virtual memory exhausted.\n");
+	   abort();
+    }
+
+/*
+    for(i = 0; i < MEM_BANK_SIZE; i++)
+	   put_mem_bank (i<<16, &dummy_bank);
+*/
 
     /* Map the chipmem into all of the lower 16MB */
-    map_banks(chipmem_bank, 0x00, 256); //chipmem_size>>16??
+    map_banks(&chipmem_bank, 0x00, 256); //chipmem_size>>16
-    map_banks(custom_bank, 0xC0, 0x20);
-    map_banks(cia_bank, 0xA0, 0x20);
 
-    //0x000000 - 0x080000 
+    /* ??? my A500 has expansion memory, someone care to find out what
-    //0xA00000 - 0xBFFFFF
+       * really is supposed to be at 0x200000 on an Amiga without? */
-    //0xC00000 - 0xDFFFFF
+    custom_start = chipmem_size >> 16;
-    //0xF80000 - 0xFFFFFF
+    if (custom_start < 0x20)
+	   custom_start = 0x20;
 
+    map_banks(&custom_bank, custom_start, 0xE0-custom_start);
+    map_banks(&cia_bank, 0xA0, 32);
 
-    //map_banks(clock_bank, 0xDC, 1);
+    //map_banks(&clock_bank, 0xDC, 1);
-    //map_banks(rtarea_bank, 0xF0, 1); 
+
-    //rtarea_init ();
+#ifdef HAS_BOGOMEM
+    if (bogomem_size > 0) {
+        bogomemory = (uae_u8 *)malloc(bogomem_size);
+        if(!bogomemory) {
+	       write_log ("Virtual memory exhausted.\n");
+	       abort();
+        }
+        map_banks(&bogomem_bank, 0xC0, bogomem_size >> 16);
+    }
+#endif
+
+#ifdef HAS_HARDFILE
+    map_banks(&rtarea_bank, 0xF0, 1); 
+#endif
     
 #ifdef HAS_KICKFILE       
     if (!load_kickstart()) {
 #ifdef HAS_ERSATZ          
-	   init_ersatz_rom(kickmemory);
+       init_ersatz_rom(kickmemory);
-	   ersatzkickfile = 1;
+       ersatzkickfile = 1;
 #endif       
     }
-    //processFileInMem("kick13.rom","kickbig.h","kick",kick,kickmem_size);    
+    processFileInMem("kickbig.h","kick",kickmemory,kickmem_size);    
 #endif
 
     if (zkickfile)
-	   map_banks(kickmem_bank, 0x20, 8);
+	   map_banks(&kickmem_bank, 0x20, 8);
     
-    map_banks(kickmem_bank, 0xF8, 8);
+    map_banks(&kickmem_bank, 0xF8, 8);
-
-#ifdef HAS_BOGOMEM   
-    if (bogomem_size > 0) {
-        bogomemory = (UWORD *)emu_malloc (bogomem_size);
-        map_banks(bogomem_bank, 0xC0, bogomem_size >> 16);
-    }
-#endif
 
 #ifdef HAS_EXPANMEM
     if (!zkickfile)
-	   map_banks(expamem_bank, 0xE8, 1);
+	   map_banks(&expamem_bank, 0xE8, 1);
 #endif    
 }
 
-void map_banks(addrbank bank, int start, int size)
+void map_banks(addrbank *bank, int start, int size)
 {  
+    //int bnr;
+    //int hioffs = 0, endhioffs = 1;
+    /* Some '020 Kickstarts apparently require a 24 bit address space... */
+    //if (CPU_LEVEL >= 2 && !address_space_24)
+	//   endhioffs = 256;
+    //for (hioffs = 0; hioffs < endhioffs; hioffs++)
+	//   for (bnr = start; bnr < start+size; bnr++)
+	//       put_mem_bank((bnr + hioffs * 256) << 16, bank);   
     int bnr;
-//    int hioffs = 0;
+    for (bnr = start; bnr < start+size; bnr++) 
-//#if CPU_LEVEL < 2
+        //put_mem_bank(bnr, bank);
-//    for (hioffs = 0; hioffs < 256; hioffs++)
+        mem_banks[bnr] = bank;             
-//#endif
-	for (bnr = start; bnr < start+size; bnr++) 
-	    membanks[bnr /*+ hioffs * 256*/] = bank;
 }

MCUME_teensy/teensyuae41/memory.h

@@ -3,42 +3,62 @@
   * 
   * memory management
   * 
-  * (c) 1995 Bernd Schmidt
+  * Copyright 1995 Bernd Schmidt
   */
 
-#define chipmem_size 0x200000 
+/* Enabling this adds one additional native memory reference per 68k memory
-//#define bogomem_size 0x100000 /* C00000 crap mem */
+ * access, but saves one shift (on the x86). Enabling this is probably
-#define kickmem_size 0x080000
+ * better for the cache. My favourite benchmark (PP2) doesn't show a
+ * difference, so I leave this enabled. */
+
 #define fastmem_size 0x400000
+#define chipmem_size 0x200000 //0x080000
+#define bogomem_size 0x000000
+#define kickmem_size 0x080000
 
 #define chipmem_start 0x000000
-//#define bogomem_start 0xC00000 
+#define bogomem_start 0xC00000 
 #define kickmem_start 0xF80000
 
-extern UWORD *chipmemory2;
+
+typedef uae_u32 (*mem_get_func)(uaecptr) REGPARAM;
+typedef void (*mem_put_func)(uaecptr, uae_u32) REGPARAM;
+typedef uae_u8 *(*xlate_func)(uaecptr) REGPARAM;
+typedef int (*check_func)(uaecptr, uae_u32) REGPARAM;
+
+extern char *address_space, *good_address_map;
+
+#undef DIRECT_MEMFUNCS_SUCCESSFUL
+#include "machdep/memory.h"
+
+#ifndef CAN_MAP_MEMORY
+#undef USE_COMPILER
+#endif
+
+#if defined(USE_COMPILER) && !defined(USE_MAPPED_MEMORY)
+#define USE_MAPPED_MEMORY
+#endif
+
 
 extern int ersatzkickfile;
 
-typedef ULONG (*lget_func)(CPTR) REGPARAM;
-typedef UWORD (*wget_func)(CPTR) REGPARAM;
-typedef UBYTE (*bget_func)(CPTR) REGPARAM;
-typedef void (*lput_func)(CPTR,ULONG) REGPARAM;
-typedef void (*wput_func)(CPTR,UWORD) REGPARAM;
-typedef void (*bput_func)(CPTR,UBYTE) REGPARAM;
-typedef UWORD *(*xlate_func)(CPTR) REGPARAM;
-typedef int (*check_func)(CPTR, ULONG) REGPARAM;
-
 typedef struct {
-    lget_func lget;
+    /* These ones should be self-explanatory... */
-    wget_func wget;
+    mem_get_func lget, wget, bget;
-    bget_func bget;
+    mem_put_func lput, wput, bput;
-    lput_func lput;
+    /* Use xlateaddr to translate an Amiga address to a uae_u8 * that can
-    wput_func wput;
+     * be used to address memory without calling the wget/wput functions. 
-    bput_func bput;
+     * This doesn't work for all memory banks, so this function may call
+     * abort(). */
     xlate_func xlateaddr;
+    /* To prevent calls to abort(), use check before calling xlateaddr.
+     * It checks not only that the memory bank can do xlateaddr, but also
+     * that the pointer points to an area of at least the specified size. 
+     * This is used for example to translate bitplane pointers in custom.c */
     check_func check;
 } addrbank;
 
+
 extern addrbank chipmem_bank;
 extern addrbank kickmem_bank;
 extern addrbank custom_bank;
@@ -49,108 +69,133 @@ extern addrbank expamem_bank;
 extern addrbank fastmem_bank;
 
 extern void rtarea_init (void);
+extern void rtarea_setup (void);
 extern void expamem_init (void);
 extern void expamem_reset (void);
 
+#define MEM_BANK_SIZE 256 //65536
+
+extern int address_space_24;
 
 /* Default memory access functions */
 
-extern int default_check(CPTR addr, ULONG size) REGPARAM;
+extern int default_check(uaecptr addr, uae_u32 size) REGPARAM;
-extern UWORD *default_xlate(CPTR addr) REGPARAM;
+extern uae_u8 *default_xlate(uaecptr addr) REGPARAM;
 
-extern addrbank membanks[256];
+//#define bankindex(addr) (((uaecptr)(addr)) >> 16)
 static __inline__ unsigned int bankindex(CPTR a)
 {
     if ( (a>>16) > 0xFF) return 0xE0;
-    return a>>16;
+    return (a>>16);
 }
 
-static __inline__ ULONG longget(CPTR addr)
-{
-    return membanks[bankindex(addr)].lget(addr);
-}
-static __inline__ UWORD wordget(CPTR addr)
-{
-    return membanks[bankindex(addr)].wget(addr);
-}
-static __inline__ UBYTE byteget(CPTR addr) 
-{
-    return membanks[bankindex(addr)].bget(addr);
-}
-static __inline__ void longput(CPTR addr, ULONG l)
-{
-    membanks[bankindex(addr)].lput(addr, l);
-}
-static __inline__ void wordput(CPTR addr, UWORD w)
-{
-    membanks[bankindex(addr)].wput(addr, w);
-}
-static __inline__ void byteput(CPTR addr, UBYTE b)
-{
-    membanks[bankindex(addr)].bput(addr, b);
-}
 
-static __inline__ int check_addr(CPTR a)
+extern addrbank *mem_banks[MEM_BANK_SIZE];
-{
+#define get_mem_bank(addr) (*mem_banks[bankindex(addr)])
-    return 1;
+#define put_mem_bank(addr, b) (mem_banks[bankindex(addr)] = (b))
-#ifdef NO_EXCEPTION_3
+
-    return 1;
+
+#if defined(NO_EXCEPTION_3) || CPU_LEVEL > 1
+#define check_addr(a) 1
 #else
-    return (a & 1) == 0;
+#define check_addr(a) (((a) & 1) == 0)
 #endif
-}
+
 extern int buserr;
+extern uae_u16 last_op_for_exception_3;
+extern uaecptr last_addr_for_exception_3;
+extern uaecptr last_fault_for_exception_3;
+extern uaecptr m68k_currentpc(void);
 
 extern void memory_init(void);    
-extern void map_banks(addrbank bank, int first, int count);
+extern void map_banks(addrbank *bank, int first, int count);
 
-static __inline__ ULONG get_long(CPTR addr) 
+#ifndef NO_INLINE_MEMORY_ACCESS
+
+#define longget(addr) (call_mem_get_func(get_mem_bank(addr).lget, addr))
+#define wordget(addr) (call_mem_get_func(get_mem_bank(addr).wget, addr))
+#define byteget(addr) (call_mem_get_func(get_mem_bank(addr).bget, addr))
+#define longput(addr,l) (call_mem_put_func(get_mem_bank(addr).lput, addr, l))
+#define wordput(addr,w) (call_mem_put_func(get_mem_bank(addr).wput, addr, w))
+#define byteput(addr,b) (call_mem_put_func(get_mem_bank(addr).bput, addr, b))
+
+#else
+
+extern uae_u32 alongget(uaecptr addr);
+extern uae_u32 awordget(uaecptr addr);
+extern uae_u32 longget(uaecptr addr);
+extern uae_u32 wordget(uaecptr addr);
+extern uae_u32 byteget(uaecptr addr);
+extern void longput(uaecptr addr, uae_u32 l);
+extern void wordput(uaecptr addr, uae_u32 w);
+extern void byteput(uaecptr addr, uae_u32 b);
+
+#endif
+
+#ifndef MD_HAVE_MEM_1_FUNCS
+
+#define longget_1 longget
+#define wordget_1 wordget
+#define byteget_1 byteget
+#define longput_1 longput
+#define wordput_1 wordput
+#define byteput_1 byteput
+
+#endif
+
+static __inline__ uae_u32 get_long(uaecptr addr) 
 {
     if (check_addr(addr))
-	    return longget(addr);
+	return longget_1(addr);
     buserr = 1;
+    last_fault_for_exception_3 = addr;
+    last_addr_for_exception_3 = m68k_currentpc();
     return 0;
 }
-static __inline__ UWORD get_word(CPTR addr) 
+static __inline__ uae_u32 get_word(uaecptr addr) 
 {
     if (check_addr(addr))
-	    return wordget(addr);
+	return wordget_1(addr);
     buserr = 1;
+    last_fault_for_exception_3 = addr;
+    last_addr_for_exception_3 = m68k_currentpc();
     return 0;
 }
-static __inline__ UBYTE get_byte(CPTR addr) 
+static __inline__ uae_u32 get_byte(uaecptr addr) 
 {
-    return byteget(addr); 
+    return byteget_1(addr); 
 }
-static __inline__ void put_long(CPTR addr, ULONG l) 
+static __inline__ void put_long(uaecptr addr, uae_u32 l) 
 {
-    if (!check_addr(addr))
+    if (!check_addr(addr)) {
-	    buserr = 1;
+	buserr = 1;
-    longput(addr, l);
+	last_fault_for_exception_3 = addr;
+        last_addr_for_exception_3 = m68k_currentpc();
+	return;
+    }
+    longput_1(addr, l);
 }
-static __inline__ void put_word(CPTR addr, UWORD w) 
+static __inline__ void put_word(uaecptr addr, uae_u32 w)
 {
-    if (!check_addr(addr))
+    if (!check_addr(addr)) {
-	    buserr = 1;
+	buserr = 1;
-    wordput(addr, w);
+	last_fault_for_exception_3 = addr;
+	last_addr_for_exception_3 = m68k_currentpc();
+	return;
+    }
+    wordput_1(addr, w);
 }
-static __inline__ void put_byte(CPTR addr, UBYTE b) 
+static __inline__ void put_byte(uaecptr addr, uae_u32 b) 
 {
-    byteput(addr, b);
+    byteput_1(addr, b);
 }
 
-static __inline__ UWORD *get_real_address(CPTR addr)
+static __inline__ uae_u8 *get_real_address(uaecptr addr)
 {
-    if (!check_addr(addr))
+    return get_mem_bank(addr).xlateaddr(addr);
-	buserr = 1;
-    //emu_printf("ra");
-    //emu_printi(addr);
-    return membanks[bankindex(addr)].xlateaddr(addr);
 }
 
-static __inline__ int valid_address(CPTR addr, ULONG size)
+static __inline__ int valid_address(uaecptr addr, uae_u32 size)
 {
-    if (!check_addr(addr))
+    return get_mem_bank(addr).check(addr, size);
-	buserr = 1;
-    return membanks[bankindex(addr)].check(addr, size);
 }