]> Shamusworld >> Repos - apple2/blob - src/apple2.cpp
Fixed misc. bugs preventing certain games from working, added pause mode.
[apple2] / src / apple2.cpp
1 //
2 // Apple 2 SDL Portable Apple Emulator
3 //
4 // by James L. Hammons
5 // (C) 2005 Underground Software
6 //
7 // Loosely based on AppleWin by Tom Charlesworth which was based on AppleWin by
8 // Oliver Schmidt which was based on AppleWin by Michael O'Brien. :-) Parts are
9 // also derived from ApplePC. Too bad it was closed source--it could have been
10 // *the* premier Apple II emulator out there.
11 //
12 // JLH = James L. Hammons <jlhamm@acm.org>
13 //
14 // WHO  WHEN        WHAT
15 // ---  ----------  ------------------------------------------------------------
16 // JLH  11/12/2005  Initial port to SDL
17 // JLH  11/18/2005  Wired up graphic soft switches
18 // JLH  12/02/2005  Setup timer subsystem for more accurate time keeping
19 // JLH  12/12/2005  Added preliminary state saving support
20 //
21
22 // STILL TO DO:
23 //
24 // - Port to SDL [DONE]
25 // - GUI goodies
26 // - Weed out unneeded functions [DONE]
27 // - Disk I/O [DONE]
28 // - 128K IIe related stuff
29 // - State loading/saving
30 //
31
32 #include "apple2.h"
33
34 #include <SDL2/SDL.h>
35 #include <fstream>
36 #include <string>
37 #include <iomanip>
38 #include <iostream>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <time.h>
42 #include "log.h"
43 #include "video.h"
44 #include "sound.h"
45 #include "settings.h"
46 #include "v65c02.h"
47 #include "applevideo.h"
48 #include "timing.h"
49 #include "floppy.h"
50 #include "firmware.h"
51
52 #include "gui/gui.h"
53 #include "gui/window.h"
54 #include "gui/draggablewindow2.h"
55 #include "gui/textedit.h"
56
57 // Debug and misc. defines
58
59 #define THREADED_65C02
60 #define CPU_THREAD_OVERFLOW_COMPENSATION
61 #define DEBUG_LC
62 //#define CPU_CLOCK_CHECKING
63 //#define THREAD_DEBUGGING
64 #define SOFT_SWITCH_DEBUGGING
65
66 // Global variables
67
68 uint8_t ram[0x10000], rom[0x10000];                             // RAM & ROM spaces
69 uint8_t ram2[0x10000];                                                  // Auxillary RAM
70 uint8_t diskRom[0x100];                                                 // Disk ROM space
71 V65C02REGS mainCPU;                                                             // v65C02 execution context
72 uint8_t appleType = APPLE_TYPE_IIE;
73 FloppyDrive floppyDrive;
74
75 // Local variables
76
77 static uint8_t lastKeyPressed = 0;
78 static bool keyDown = false;
79 static bool openAppleDown = false;
80 static bool closedAppleDown = false;
81 static bool store80Mode = false;
82 static bool vbl = false;
83 static bool slotCXROM = false;
84 static bool slotC3ROM = false;
85 static bool ramrd = false;
86 static bool ramwrt = false;
87 static bool altzp = false;
88 static bool ioudis = true;
89 bool dhires = false;
90
91 //static FloppyDrive floppyDrive;
92
93 enum { LC_BANK_1, LC_BANK_2 };
94
95 static uint8_t visibleBank = LC_BANK_1;
96 static bool readRAM = false;
97 static bool writeRAM = false;
98
99 static bool running = true;                                             // Machine running state flag...
100 static uint32_t startTicks;
101 static bool pauseMode = false;
102
103 static GUI * gui = NULL;
104
105 // Local functions (technically, they're global...)
106
107 bool LoadImg(char * filename, uint8_t * ram, int size);
108 uint8_t RdMem(uint16_t addr);
109 void WrMem(uint16_t addr, uint8_t b);
110 static void SaveApple2State(const char * filename);
111 static bool LoadApple2State(const char * filename);
112
113 // Local timer callback functions
114
115 static void FrameCallback(void);
116 static void BlinkTimer(void);
117
118 #ifdef THREADED_65C02
119 // Test of threaded execution of 6502
120 static SDL_Thread * cpuThread = NULL;
121 //static SDL_mutex * cpuMutex = NULL;
122 static SDL_cond * cpuCond = NULL;
123 static SDL_sem * mainSem = NULL;
124 static bool cpuFinished = false;
125 static bool cpuSleep = false;
126
127
128 // NB: Apple //e Manual sez 6502 is running @ 1,022,727 Hz
129
130 // Let's try a thread...
131 /*
132 Here's how it works: Execute 1 frame's worth, then sleep.
133 Other stuff wakes it up
134 */
135 int CPUThreadFunc(void * data)
136 {
137         // Mutex must be locked for conditional to work...
138         // Also, must be created in the thread that uses it...
139         SDL_mutex * cpuMutex = SDL_CreateMutex();
140
141 // decrement mainSem...
142 //SDL_SemWait(mainSem);
143 #ifdef CPU_THREAD_OVERFLOW_COMPENSATION
144         float overflow = 0.0;
145 #endif
146
147         do
148         {
149                 if (cpuSleep)
150                         SDL_CondWait(cpuCond, cpuMutex);
151
152 // decrement mainSem...
153 #ifdef THREAD_DEBUGGING
154 WriteLog("CPU: SDL_SemWait(mainSem);\n");
155 #endif
156 SDL_SemWait(mainSem);
157
158 // There are exactly 800 slices of 21.333 cycles per frame, so it works out
159 // evenly.
160 #if 0
161                 uint32_t cycles = 17066;
162 #ifdef CPU_THREAD_OVERFLOW_COMPENSATION
163 // ODD! It's closer *without* this overflow compensation. ??? WHY ???
164                 overflow += 0.666666667;
165
166                 if (overflow > 1.0)
167                 {
168                         overflow -= 1.0;
169                         cycles++;
170                 }
171 #endif
172
173 #ifdef THREAD_DEBUGGING
174 WriteLog("CPU: Execute65C02(&mainCPU, cycles);\n");
175 #endif
176                 Execute65C02(&mainCPU, cycles); // how much? 1 frame (after 1 s, off by 40 cycles) not any more--it's off by as much as 240 now!
177
178                 // Adjust the sound routine's last cycle toggled time base
179                 // Also, since we're finished executing, .clock is now valid
180 #ifdef THREAD_DEBUGGING
181 WriteLog("CPU: AdjustLastToggleCycles(mainCPU.clock);\n");
182 #endif
183                 AdjustLastToggleCycles(mainCPU.clock);
184 #else
185 #ifdef THREAD_DEBUGGING
186 WriteLog("CPU: Execute65C02(&mainCPU, cycles);\n");
187 #endif
188                 for(int i=0; i<800; i++)
189                 {
190                         uint32_t cycles = 21;
191                         overflow += 0.333333334;
192
193                         if (overflow > 1.0)
194                         {
195                                 cycles++;
196                                 overflow -= 1.0;
197                         }
198
199                         Execute65C02(&mainCPU, cycles);
200                         WriteSampleToBuffer();
201                 }
202 #endif
203
204 //WriteLog("CPUThread: Supposedly end of frame...\n");
205
206 #ifdef THREAD_DEBUGGING
207 WriteLog("CPU: SDL_mutexP(cpuMutex);\n");
208 #endif
209                 SDL_mutexP(cpuMutex);
210 #if 0
211                 if (SDL_CondWait(cpuCond, cpuMutex) != 0)
212                 {
213                         printf("SDL_CondWait != 0! (Error: '%s')\n", SDL_GetError());
214                         exit(-1);
215                 }
216 #else
217 // increment mainSem...
218 #ifdef THREAD_DEBUGGING
219 WriteLog("CPU: SDL_SemPost(mainSem);\n");
220 #endif
221 SDL_SemPost(mainSem);
222 //              SDL_CondSignal(mainCond);       // In case something is waiting on us...
223
224 #ifdef THREAD_DEBUGGING
225 WriteLog("CPU: SDL_CondWait(cpuCond, cpuMutex);\n");
226 #endif
227                 SDL_CondWait(cpuCond, cpuMutex);
228
229 #endif
230 #ifdef THREAD_DEBUGGING
231 WriteLog("CPU: SDL_mutexV(cpuMutex);\n");
232 #endif
233                 SDL_mutexV(cpuMutex);
234         }
235         while (!cpuFinished);
236
237         SDL_DestroyMutex(cpuMutex);
238
239         return 0;
240 }
241 #endif
242
243
244 // Test GUI function
245
246 Element * TestWindow(void)
247 {
248         Element * win = new DraggableWindow2(10, 10, 128, 128);
249 //      ((DraggableWindow *)win)->AddElement(new TextEdit(4, 16, 92, 0, "u2prog.dsk", win));
250
251         return win;
252 }
253
254
255 Element * QuitEmulator(void)
256 {
257         gui->Stop();
258         running = false;
259
260         return NULL;
261 }
262
263
264 /*
265  Small Apple II memory map:
266
267 $C010 - Clear bit 7 of keyboard data ($C000)
268 $C030 - Toggle speaker diaphragm
269 $C051 - Display text
270 $C054 - Select page 1
271 $C056 - Select lo-res
272 $C058 - Set annuciator-0 output to 0
273 $C05A - Set annuciator-0 output to 0
274 $C05D - Set annuciator-0 output to 1
275 $C05F - Set annuciator-0 output to 1
276 $C0E0 - Disk control stepper ($C0E0-7)
277 $C0E9 - Disk control motor (on)
278 $C0EA - Disk enable (drive 1)
279 $C0EC - Disk R/W
280 $C0EE - Disk set read mode
281 */
282
283 //
284 // V65C02 read/write memory functions
285 //
286
287 uint8_t RdMem(uint16_t addr)
288 {
289         uint8_t b;
290
291 #if 0
292 if (addr >= 0xC000 && addr <= 0xC0FF)
293         WriteLog("\n*** Read at I/O address %04X\n", addr);
294 #endif
295 #if 0
296 if (addr >= 0xC080 && addr <= 0xC08F)
297         WriteLog("\n*** Read at I/O address %04X\n", addr);
298 #endif
299
300         if ((addr & 0xFFF0) == 0xC000)                  // Read $C000-$C00F
301         {
302                 return lastKeyPressed | (keyDown ? 0x80 : 0x00);
303         }
304 //      else if ((addr & 0xFFF8) == 0xC010)             // Read $C010-$C01F
305         else if (addr == 0xC010)
306         {
307 //This is bogus: keyDown is set to false, so return val NEVER is set...
308 //Fixed...
309 //Also, this is IIe/IIc only...!
310                 uint8_t retVal = lastKeyPressed | (keyDown ? 0x80 : 0x00);
311                 keyDown = false;
312                 return retVal;
313         }
314         // These are //e locations
315         else if (addr == 0xC011)
316         {
317 #ifdef SOFT_SWITCH_DEBUGGING
318 WriteLog("RDBANK2 (read)\n");
319 #endif
320                 return (visibleBank == LC_BANK_2 ? 0x80 : 0x00);
321         }
322         else if (addr == 0xC012)
323         {
324 #ifdef SOFT_SWITCH_DEBUGGING
325 WriteLog("RDLCRAM (read)\n");
326 #endif
327                 return (readRAM ? 0x80 : 0x00);
328         }
329         else if (addr == 0xC013)
330         {
331 #ifdef SOFT_SWITCH_DEBUGGING
332 WriteLog("RAMRD (read)\n");
333 #endif
334                 return (ramrd ? 0x80 : 0x00);
335         }
336         else if (addr == 0xC014)
337         {
338 #ifdef SOFT_SWITCH_DEBUGGING
339 WriteLog("RAMWRT (read)\n");
340 #endif
341                 return (ramwrt ? 0x80 : 0x00);
342         }
343         else if (addr == 0xC015)
344         {
345 #ifdef SOFT_SWITCH_DEBUGGING
346 WriteLog("SLOTCXROM (read)\n");
347 #endif
348                 return (slotCXROM ? 0x80 : 0x00);
349         }
350         else if (addr == 0xC016)
351         {
352 #ifdef SOFT_SWITCH_DEBUGGING
353 WriteLog("ALTZP (read)\n");
354 #endif
355                 return (altzp ? 0x80 : 0x00);
356         }
357         else if (addr == 0xC017)
358         {
359 #ifdef SOFT_SWITCH_DEBUGGING
360 WriteLog("SLOTC3ROM (read)\n");
361 #endif
362                 return (slotC3ROM ? 0x80 : 0x00);
363         }
364         else if (addr == 0xC018)
365         {
366 #ifdef SOFT_SWITCH_DEBUGGING
367 WriteLog("80STORE (read)\n");
368 #endif
369                 return (store80Mode ? 0x80 : 0x00);
370         }
371         else if (addr == 0xC019)
372         {
373 #ifdef SOFT_SWITCH_DEBUGGING
374 WriteLog("VBL (read)\n");
375 #endif
376 // NB: The doco suggests that this signal goes LOW when in the VBI.
377 // Which means that we need to control this by counting lines somewhere.
378                 return (vbl ? 0x80 : 0x00);
379         }
380         else if (addr == 0xC01A)
381         {
382 #ifdef SOFT_SWITCH_DEBUGGING
383 WriteLog("TEXT (read)\n");
384 #endif
385                 return (textMode ? 0x80 : 0x00);
386         }
387         else if (addr == 0xC01B)
388         {
389 #ifdef SOFT_SWITCH_DEBUGGING
390 WriteLog("MIXED (read)\n");
391 #endif
392                 return (mixedMode ? 0x80 : 0x00);
393         }
394         else if (addr == 0xC01C)
395         {
396 #ifdef SOFT_SWITCH_DEBUGGING
397 WriteLog("PAGE2 (read)\n");
398 #endif
399                 return (displayPage2 ? 0x80 : 0x00);
400         }
401         else if (addr == 0xC01D)
402         {
403 #ifdef SOFT_SWITCH_DEBUGGING
404 WriteLog("HIRES (read)\n");
405 #endif
406                 return (hiRes ? 0x80 : 0x00);
407         }
408         else if (addr == 0xC01E)
409         {
410 #ifdef SOFT_SWITCH_DEBUGGING
411 WriteLog("ALTCHARSET (read)\n");
412 #endif
413                 return (alternateCharset ? 0x80 : 0x00);
414         }
415         else if (addr == 0xC01F)
416         {
417 #ifdef SOFT_SWITCH_DEBUGGING
418 WriteLog("80COL (read)\n");
419 #endif
420                 return (col80Mode ? 0x80 : 0x00);
421         }
422         else if ((addr & 0xFFF0) == 0xC030)             // Read $C030-$C03F
423         {
424 /*
425 This is problematic, mainly because the v65C02 removes actual cycles run after each call.
426 Therefore, we don't really have a reliable method of sending a timestamp to the sound routine.
427 How to fix?
428
429 What we need to send is a delta T value but related to the IRQ buffer routine. E.g., if the buffer
430 hasn't had any changes in it then we just fill it with the last sample value and are done. Then
431 we need to adjust our delta T accordingly. What we could do is keep a running total of time since the
432 last change and adjust it accordingly, i.e., whenever a sound IRQ happens.
433 How to keep track?
434
435 Have deltaT somewhere. Then, whenever there's a toggle, backfill buffer with last spkr state and reset
436 deltaT to zero. In the sound IRQ, if deltaT > buffer size, then subtract buffer size from deltaT. (?)
437
438
439
440 */
441                 ToggleSpeaker(GetCurrentV65C02Clock());
442 //should it return something else here???
443                 return 0x00;
444         }
445         else if (addr == 0xC050)                                // Read $C050
446         {
447 #ifdef SOFT_SWITCH_DEBUGGING
448 WriteLog("TEXT off (read)\n");
449 #endif
450                 textMode = false;
451         }
452         else if (addr == 0xC051)                                // Read $C051
453         {
454 #ifdef SOFT_SWITCH_DEBUGGING
455 WriteLog("TEXT on (read)\n");
456 #endif
457                 textMode = true;
458         }
459         else if (addr == 0xC052)                                // Read $C052
460         {
461 #ifdef SOFT_SWITCH_DEBUGGING
462 WriteLog("MIXED off (read)\n");
463 #endif
464                 mixedMode = false;
465         }
466         else if (addr == 0xC053)                                // Read $C053
467         {
468 #ifdef SOFT_SWITCH_DEBUGGING
469 WriteLog("MIXED on (read)\n");
470 #endif
471                 mixedMode = true;
472         }
473         else if (addr == 0xC054)                                // Read $C054
474         {
475 #ifdef SOFT_SWITCH_DEBUGGING
476 WriteLog("PAGE2 off (read)\n");
477 #endif
478                 displayPage2 = false;
479         }
480         else if (addr == 0xC055)                                // Read $C055
481         {
482 #ifdef SOFT_SWITCH_DEBUGGING
483 WriteLog("PAGE2 on (read)\n");
484 #endif
485                 displayPage2 = true;
486         }
487         else if (addr == 0xC056)                                // Read $C056
488         {
489 #ifdef SOFT_SWITCH_DEBUGGING
490 WriteLog("HIRES off (read)\n");
491 #endif
492                 hiRes = false;
493         }
494         else if (addr == 0xC057)                                // Read $C057
495         {
496 #ifdef SOFT_SWITCH_DEBUGGING
497 WriteLog("HIRES on (read)\n");
498 #endif
499                 hiRes = true;
500         }
501         else if (addr == 0xC05E)
502         {
503 #ifdef SOFT_SWITCH_DEBUGGING
504 WriteLog("DHIRES on (read)\n");
505 #endif
506                 if (ioudis)
507                         dhires = true;
508         }
509         else if (addr == 0xC05F)
510         {
511 #ifdef SOFT_SWITCH_DEBUGGING
512 WriteLog("DHIRES off (read)\n");
513 #endif
514                 if (ioudis)
515                         dhires = false;
516         }
517         else if (addr == 0xC061)                                // Read $C061
518         {
519                 // Open Apple key (or push button 0)
520                 return (openAppleDown ? 0x80 : 0x00);
521         }
522         else if (addr == 0xC062)                                // Read $C062
523         {
524                 // Open Apple key (or push button 0)
525                 return (closedAppleDown ? 0x80 : 0x00);
526         }
527         // The way the paddles work is that a strobe is written (or read) to $C070,
528         // then software counts down the time that it takes for the paddle outputs
529         // to have bit 7 return to 0. If there are no paddles connected, bit 7
530         // stays at 1.
531         else if (addr == 0xC064)        // Paddles 0-3
532         {
533                 return 0xFF;
534         }
535         else if (addr == 0xC065)
536         {
537                 return 0xFF;
538         }
539         else if (addr == 0xC066)
540         {
541                 return 0xFF;
542         }
543         else if (addr == 0xC067)
544         {
545                 return 0xFF;
546         }
547         else if (addr == 0xC07E)
548         {
549 #ifdef SOFT_SWITCH_DEBUGGING
550 WriteLog("IOUDIS (read)\n");
551 #endif
552                 return (ioudis ? 0x80 : 0x00);
553         }
554         else if (addr == 0xC07F)
555         {
556 #ifdef SOFT_SWITCH_DEBUGGING
557 WriteLog("DHIRES (read)\n");
558 #endif
559                 return (dhires ? 0x80 : 0x00);
560         }
561
562 //Note that this is a kludge: The $D000-$DFFF 4K space is shared (since $C000-$CFFF is
563 //memory mapped) between TWO banks, and that that $E000-$FFFF RAM space is a single bank.
564 //[SHOULD BE FIXED NOW]
565 //OK! This switch selects bank 2 of the 4K bank at $D000-$DFFF. One access makes it
566 //visible, two makes it R/W.
567
568 /*
569 301  LDA $E000
570 304  PHA
571 305  LDA $C081
572 308  PLA
573 309  PHA
574 30A  CMP $E000
575 30D  BNE $332
576 30F  LDA $C083
577 312  LDA $C083
578 315  LDA #$A5
579 317  STA $D000
580 31A  CMP $D000
581 31D  BNE $332
582 31F  LSR A
583 320  STA $D000
584 323  CMP $D000
585 326  BNE $332
586 328  LDA $C081
587 32B  LDA $C081
588 32E  LDA #$01
589 330  BNE $334
590 332  LDA #$00
591 334  STA $300
592 337  PLA
593 338  CMP $E000
594 33B  BEQ $340
595 33D  LDA $C080
596 340  RTS
597
598 A = PEEK($C082)
599 */
600
601         else if ((addr & 0xFFFB) == 0xC080)
602         {
603 #ifdef DEBUG_LC
604 WriteLog("LC(R): $C080 49280 OECG R Read RAM bank 2; no write\n");
605 #endif
606 //$C080 49280              OECG  R   Read RAM bank 2; no write
607                 visibleBank = LC_BANK_2;
608                 readRAM = true;
609                 writeRAM = false;
610         }
611         else if ((addr & 0xFFFB) == 0xC081)
612         {
613 #ifdef DEBUG_LC
614 WriteLog("LC(R): $C081 49281 OECG RR Read ROM; write RAM bank 2\n");
615 #endif
616 //$C081 49281 ROMIN        OECG  RR  Read ROM; write RAM bank 2
617                 visibleBank = LC_BANK_2;
618                 readRAM = false;
619                 writeRAM = true;
620         }
621         else if ((addr & 0xFFFB) == 0xC082)
622         {
623 #ifdef DEBUG_LC
624 WriteLog("LC(R): $C082 49282 OECG R Read ROM; no write\n");
625 #endif
626 //$C082 49282              OECG  R   Read ROM; no write
627                 visibleBank = LC_BANK_2;
628                 readRAM = false;
629                 writeRAM = false;
630         }
631         else if ((addr & 0xFFFB) == 0xC083)
632         {
633 #ifdef DEBUG_LC
634 WriteLog("LC(R): $C083 49283 OECG RR Read/Write RAM bank 2\n");
635 #endif
636 //$C083 49283 LCBANK2      OECG  RR  Read/write RAM bank 2
637                 visibleBank = LC_BANK_2;
638                 readRAM = true;
639                 writeRAM = true;
640         }
641         else if ((addr & 0xFFFB) == 0xC088)
642         {
643 #ifdef DEBUG_LC
644 WriteLog("LC(R): $%04X 49288 OECG R Read RAM bank 1; no write\n", addr);
645 #endif
646 //$C088 49288              OECG  R   Read RAM bank 1; no write
647                 visibleBank = LC_BANK_1;
648                 readRAM = true;
649                 writeRAM = false;
650 //Hm. Some stuff seems to want this.
651 //nope, was looking at $C0E8... return 0xFF;
652         }
653         else if ((addr & 0xFFFB) == 0xC089)
654         {
655 #ifdef DEBUG_LC
656 WriteLog("LC(R): $C089 49289 OECG RR Read ROM; write RAM bank 1\n");
657 #endif
658 //$C089 49289              OECG  RR  Read ROM; write RAM bank 1
659                 visibleBank = LC_BANK_1;
660                 readRAM = false;
661                 writeRAM = true;
662         }
663         else if ((addr & 0xFFFB) == 0xC08A)
664         {
665 #ifdef DEBUG_LC
666 WriteLog("LC(R): $C08A 49290 OECG R Read ROM; no write\n");
667 #endif
668 //$C08A 49290              OECG  R   Read ROM; no write
669                 visibleBank = LC_BANK_1;
670                 readRAM = false;
671                 writeRAM = false;
672         }
673         else if ((addr & 0xFFFB) == 0xC08B)
674         {
675 #ifdef DEBUG_LC
676 WriteLog("LC(R): $C08B 49291 OECG RR Read/Write RAM bank 1\n");
677 #endif
678 //$C08B 49291              OECG  RR  Read/write RAM bank 1
679                 visibleBank = LC_BANK_1;
680                 readRAM = true;
681                 writeRAM = true;
682         }
683         else if ((addr & 0xFFF8) == 0xC0E0)
684         {
685                 floppyDrive.ControlStepper(addr & 0x07);
686         }
687         else if ((addr & 0xFFFE) == 0xC0E8)
688         {
689                 floppyDrive.ControlMotor(addr & 0x01);
690         }
691         else if ((addr & 0xFFFE) == 0xC0EA)
692         {
693                 floppyDrive.DriveEnable(addr & 0x01);
694         }
695         else if (addr == 0xC0EC)
696         {
697                 return floppyDrive.ReadWrite();
698         }
699         else if (addr == 0xC0ED)
700         {
701                 return floppyDrive.GetLatchValue();
702         }
703         else if (addr == 0xC0EE)
704         {
705                 floppyDrive.SetReadMode();
706         }
707         else if (addr == 0xC0EF)
708         {
709                 floppyDrive.SetWriteMode();
710         }
711
712 //#define LC_DEBUGGING
713 #ifdef LC_DEBUGGING
714 bool showpath = false;
715 if (addr >= 0xD000 && addr <= 0xD00F)
716         showpath = true;
717 #endif
718 //This sux...
719         if (addr >= 0xC100 && addr <= 0xC7FF)   // The $C000-$CFFF block is *never* RAM
720         {
721 // Looks like the ][e ref manual got this one wrong: slotCXROM set should mean
722 // use internal ROM, NOT slot ROM. :-/
723 // (fixed now, by setting the switch correctly in the write mem section :-P)
724                 if (!slotCXROM)
725 //              if (slotCXROM)
726                         b = rom[addr];
727                 else
728                 {
729                         if (addr >= 0xC100 && addr <= 0xC1FF)
730                                 b = parallelROM[addr & 0xFF];
731                         else if (addr >= 0xC600 && addr <= 0xC6FF)
732                                 b = diskROM[addr & 0xFF];
733                         else if (addr >= 0xC300 && addr <= 0xC3FF && !slotC3ROM)
734                                 b = rom[addr];
735                         else
736                                 b = 0xFF;
737 //                              b = rom[addr];
738                 }
739 #ifdef LC_DEBUGGING
740 if (showpath)
741         WriteLog("b is from $C100-$CFFF block...\n");
742 #endif
743         }
744         else if (addr >= 0xC800 && addr <= 0xCFFF)      // 2K peripheral or OS ROM
745         {
746                 b = rom[addr];
747         }
748         else if (addr >= 0xD000)
749         {
750                 if (readRAM)
751                 {
752                         if (addr <= 0xDFFF && visibleBank == LC_BANK_1)
753 #ifdef LC_DEBUGGING
754                         {
755 #endif
756 //                              b = ram[addr - 0x1000];
757                                 b = (altzp ? ram2[addr - 0x1000] : ram[addr - 0x1000]);
758 #ifdef LC_DEBUGGING
759 if (showpath)
760         WriteLog("b is from LC bank #1 (ram[addr - 0x1000])...\n");
761                         }
762 #endif
763                         else
764 #ifdef LC_DEBUGGING
765                         {
766 #endif
767 //                              b = ram[addr];
768                                 b = (altzp ? ram2[addr] : ram[addr]);
769 #ifdef LC_DEBUGGING
770 if (showpath)
771         WriteLog("b is from LC bank #2 (ram[addr])...\n");
772                         }
773 #endif
774                 }
775                 else
776 #ifdef LC_DEBUGGING
777                 {
778 #endif
779                         b = rom[addr];
780 #ifdef LC_DEBUGGING
781 if (showpath)
782         WriteLog("b is from LC ROM (rom[addr])...\n");
783                 }
784 #endif
785         }
786         else
787         {
788 // 80STORE only works for WRITING, not READING!
789 #if 0
790                 // Check for 80STORE mode (STORE80 takes precedence over RAMRD/WRT)...
791                 if ((((addr >= 0x0400) && (addr <= 0x07FF)) || ((addr >= 0x2000) && (addr <= 0x3FFF))) && store80Mode)
792                 {
793                         if (displayPage2)
794                                 b = ram2[addr];
795                         else
796                                 b = ram[addr];
797
798                         return b;
799                 }
800 #endif
801
802                 // Finally, check for auxillary/altzp write switches
803                 if (addr < 0x0200)
804                         b = (altzp ? ram2[addr] : ram[addr]);
805                 else
806                         b = (ramrd ? ram2[addr] : ram[addr]);
807 #ifdef LC_DEBUGGING
808 if (showpath)
809         WriteLog("b is from ram[addr]...\n");
810 #endif
811         }
812
813 #ifdef LC_DEBUGGING
814 if (addr >= 0xD000 && addr <= 0xD00F)
815 {
816         WriteLog("*** Read from $%04X: $%02X (readRAM=%s, PC=%04X, ram$D000=%02X)\n", addr, b, (readRAM ? "T" : "F"), mainCPU.pc, ram[0xC000]);
817 }
818 #endif
819
820         return b;
821 }
822
823 /*
824 A-9 (Mockingboard)
825 APPENDIX F Assembly Language Program Listings
826
827         1       *PRIMARY ROUTINES
828         2       *FOR SLOT 4
829         3       *
830         4                       ORG     $9000
831         5       *                               ;ADDRESSES FOR FIRST 6522
832         6       ORB             EQU     $C400           ;PORT B
833         7       ORA             EQU     $C401           ;PORT A
834         8       DDRB            EQU     $C402           ;DATA DIRECTION REGISTER (A)
835         9       DDRA            EQU     $C403           ;DATA DIRECTION REGISTER (B)
836         10      *                                       ;ADDRESSES FOR SECOND 6522
837         11      ORB2            EQU     $C480           ;PORT B
838         12      ORA2            EQU     $C481           ;PORT A
839         13      DDRB2   EQU     $C482           ;DATA DIRECTION REGISTER (B)
840         14      DDRA2   EQU     $C483           ;DATA DIRECTION REGISTER (A)
841 */
842 void WrMem(uint16_t addr, uint8_t b)
843 {
844 //temp...
845 //extern V6809REGS regs;
846 //if (addr >= 0xC800 && addr <= 0xCBFE)
847 //if (addr == 0xC80F || addr == 0xC80D)
848 //      WriteLog("WrMem: Writing address %04X with %02X [PC=%04X, $CB00=%02X]\n", addr, b, regs.pc, gram[0xCB00]);//*/
849
850 #if 0
851 if (addr >= 0xC000 && addr <= 0xC0FF)
852         WriteLog("\n*** Write at I/O address %04X\n", addr);
853 #endif
854 /*
855 Check the BIKO version on Asimov to see if it's been cracked or not...
856
857 7F3D: 29 07          AND   #$07       [PC=7F3F, SP=01EA, CC=---B-I--, A=01, X=4B, Y=00]
858 7F3F: C9 06          CMP   #$06       [PC=7F41, SP=01EA, CC=N--B-I--, A=01, X=4B, Y=00]
859 7F41: 90 03          BCC   $7F46      [PC=7F46, SP=01EA, CC=N--B-I--, A=01, X=4B, Y=00]
860 [7F43: 4C 83 7E      JMP   $7E83] <- Skipped over... (Prints "THANK YOU VERY MUCH!")
861 7F46: AA             TAX              [PC=7F47, SP=01EA, CC=---B-I--, A=01, X=01, Y=00]
862
863 ; INX here *ensures* 1 - 6!!! BUG!!!
864 ; Or is it? Could this be part of a braindead copy protection scheme? It's
865 ; awfully close to NOP ($EA)...
866 ; Nothing else touches it once it's been written... Hmm...
867
868 7F47: E8             INX              [PC=7F48, SP=01EA, CC=---B-I--, A=01, X=02, Y=00]
869 7F48: F8             SED              [PC=7F49, SP=01EA, CC=---BDI--, A=01, X=02, Y=00]
870 7F49: 18             CLC              [PC=7F4A, SP=01EA, CC=---BDI--, A=01, X=02, Y=00]
871 7F4A: BD 15 4E       LDA   $4E15,X    [PC=7F4D, SP=01EA, CC=---BDI--, A=15, X=02, Y=00]
872
873 ; 4E13: 03 00
874 ; 4E15: 25 25 15 15 10 20
875 ; 4E1B: 03 41 99 99 01 00 12
876 ; 4E22: 99 70
877
878 7F4D: 65 FC          ADC   $FC        [PC=7F4F, SP=01EA, CC=---BDI--, A=16, X=02, Y=00]
879 7F4F: 65 FC          ADC   $FC        [PC=7F51, SP=01EA, CC=---BDI--, A=17, X=02, Y=00]
880 7F51: 65 FC          ADC   $FC        [PC=7F53, SP=01EA, CC=---BDI--, A=18, X=02, Y=00]
881 7F53: 65 FC          ADC   $FC        [PC=7F55, SP=01EA, CC=---BDI--, A=19, X=02, Y=00]
882
883 ; NO checking is done on the raised stat! Aarrrgggghhhhh!
884
885 7F55: 9D 15 4E       STA   $4E15,X    [PC=7F58, SP=01EA, CC=---BDI--, A=19, X=02, Y=00]
886 7F58: D8             CLD              [PC=7F59, SP=01EA, CC=---B-I--, A=19, X=02, Y=00]
887
888 ; Print "ALAKAZAM!" and so on...
889
890 7F59: 20 2C 40       JSR   $402C      [PC=402C, SP=01E8, CC=---B-I--, A=19, X=02, Y=00]
891 */
892 #if 0
893 if (addr == 0x7F47)
894         WriteLog("\n*** Byte %02X written at address %04X\n", b, addr);
895 #endif
896 /*
897 I think this is IIc/IIe only...
898
899 CLR80STORE=$C000 ;80STORE Off- disable 80-column memory mapping (Write)
900 SET80STORE=$C001 ;80STORE On- enable 80-column memory mapping (WR-only)
901
902 CLRAUXRD = $C002 ;read from main 48K (WR-only)
903 SETAUXRD = $C003 ;read from aux/alt 48K (WR-only)
904
905 CLRAUXWR = $C004 ;write to main 48K (WR-only)
906 SETAUXWR = $C005 ;write to aux/alt 48K (WR-only)
907
908 CLRCXROM = $C006 ;use ROM on cards (WR-only)
909 SETCXROM = $C007 ;use internal ROM (WR-only)
910
911 CLRAUXZP = $C008 ;use main zero page, stack, & LC (WR-only)
912 SETAUXZP = $C009 ;use alt zero page, stack, & LC (WR-only)
913
914 CLRC3ROM = $C00A ;use internal Slot 3 ROM (WR-only)
915 SETC3ROM = $C00B ;use external Slot 3 ROM (WR-only)
916
917 CLR80VID = $C00C ;disable 80-column display mode (WR-only)
918 SET80VID = $C00D ;enable 80-column display mode (WR-only)
919
920 CLRALTCH = $C00E ;use main char set- norm LC, Flash UC (WR-only)
921 SETALTCH = $C00F ;use alt char set- norm inverse, LC; no Flash (WR-only)
922 */
923         if (addr == 0xC000)
924         {
925 #ifdef SOFT_SWITCH_DEBUGGING
926 WriteLog("80STORE off (write)\n");
927 #endif
928                 store80Mode = false;
929         }
930         else if (addr == 0xC001)
931         {
932 #ifdef SOFT_SWITCH_DEBUGGING
933 WriteLog("80STORE on (write)\n");
934 #endif
935                 store80Mode = true;
936         }
937         else if (addr == 0xC002)
938         {
939 #ifdef SOFT_SWITCH_DEBUGGING
940 WriteLog("RAMRD off (write)\n");
941 #endif
942                 ramrd = false;
943         }
944         else if (addr == 0xC003)
945         {
946 #ifdef SOFT_SWITCH_DEBUGGING
947 WriteLog("RAMRD on (write)\n");
948 #endif
949                 ramrd = true;
950         }
951         else if (addr == 0xC004)
952         {
953 #ifdef SOFT_SWITCH_DEBUGGING
954 WriteLog("RAMWRT off (write)\n");
955 #endif
956                 ramwrt = false;
957         }
958         else if (addr == 0xC005)
959         {
960 #ifdef SOFT_SWITCH_DEBUGGING
961 WriteLog("RAMWRT on (write)\n");
962 #endif
963                 ramwrt = true;
964         }
965         else if (addr == 0xC006)
966         {
967                 // This is the only soft switch that breaks the usual convention.
968 #ifdef SOFT_SWITCH_DEBUGGING
969 WriteLog("SLOTCXROM on (write)\n");
970 #endif
971                 slotCXROM = true;
972         }
973         else if (addr == 0xC007)
974         {
975 #ifdef SOFT_SWITCH_DEBUGGING
976 WriteLog("SLOTCXROM off (write)\n");
977 #endif
978                 slotCXROM = false;
979         }
980         else if (addr == 0xC008)
981         {
982 #ifdef SOFT_SWITCH_DEBUGGING
983 WriteLog("ALTZP off (write)\n");
984 #endif
985                 altzp = false;
986         }
987         else if (addr == 0xC009)
988         {
989 #ifdef SOFT_SWITCH_DEBUGGING
990 WriteLog("ALTZP on (write)\n");
991 #endif
992                 altzp = true;
993         }
994         else if (addr == 0xC00A)
995         {
996 #ifdef SOFT_SWITCH_DEBUGGING
997 WriteLog("SLOTC3ROM off (write)\n");
998 #endif
999                 slotC3ROM = false;
1000         }
1001         else if (addr == 0xC00B)
1002         {
1003 #ifdef SOFT_SWITCH_DEBUGGING
1004 WriteLog("SLOTC3ROM on (write)\n");
1005 #endif
1006                 slotC3ROM = true;
1007         }
1008         else if (addr == 0xC00C)
1009         {
1010 #ifdef SOFT_SWITCH_DEBUGGING
1011 WriteLog("80COL off (write)\n");
1012 #endif
1013                 col80Mode = false;
1014         }
1015         else if (addr == 0xC00D)
1016         {
1017 #ifdef SOFT_SWITCH_DEBUGGING
1018 WriteLog("80COL on (write)\n");
1019 #endif
1020                 col80Mode = true;
1021         }
1022         else if (addr == 0xC00E)
1023         {
1024 #ifdef SOFT_SWITCH_DEBUGGING
1025 WriteLog("ALTCHARSET off (write)\n");
1026 #endif
1027                 alternateCharset = false;
1028         }
1029         else if (addr == 0xC00F)
1030         {
1031 #ifdef SOFT_SWITCH_DEBUGGING
1032 WriteLog("ALTCHARSET on (write)\n");
1033 #endif
1034                 alternateCharset = true;
1035         }
1036         else if ((addr & 0xFFF0) == 0xC010)             // Keyboard strobe
1037         {
1038 //Actually, according to the A2 ref, this should do nothing since a write
1039 //is immediately preceded by a read leaving it in the same state it was...
1040 //But leaving this out seems to fuck up the key handling of some games...
1041                 keyDown = false;
1042         }
1043         else if (addr == 0xC050)
1044         {
1045 #ifdef SOFT_SWITCH_DEBUGGING
1046 WriteLog("TEXT off (write)\n");
1047 #endif
1048                 textMode = false;
1049         }
1050         else if (addr == 0xC051)
1051         {
1052 #ifdef SOFT_SWITCH_DEBUGGING
1053 WriteLog("TEXT on (write)\n");
1054 #endif
1055                 textMode = true;
1056         }
1057         else if (addr == 0xC052)
1058         {
1059 #ifdef SOFT_SWITCH_DEBUGGING
1060 WriteLog("MIXED off (write)\n");
1061 #endif
1062                 mixedMode = false;
1063         }
1064         else if (addr == 0xC053)
1065         {
1066 #ifdef SOFT_SWITCH_DEBUGGING
1067 WriteLog("MIXED on (write)\n");
1068 #endif
1069                 mixedMode = true;
1070         }
1071         else if (addr == 0xC054)
1072         {
1073 #ifdef SOFT_SWITCH_DEBUGGING
1074 WriteLog("PAGE2 off (write)\n");
1075 #endif
1076                 displayPage2 = false;
1077         }
1078         else if (addr == 0xC055)
1079         {
1080 #ifdef SOFT_SWITCH_DEBUGGING
1081 WriteLog("PAGE2 on (write)\n");
1082 #endif
1083                 displayPage2 = true;
1084         }
1085         else if (addr == 0xC056)
1086         {
1087 #ifdef SOFT_SWITCH_DEBUGGING
1088 WriteLog("HIRES off (write)\n");
1089 #endif
1090                 hiRes = false;
1091         }
1092         else if (addr == 0xC057)
1093         {
1094 #ifdef SOFT_SWITCH_DEBUGGING
1095 WriteLog("HIRES on (write)\n");
1096 #endif
1097                 hiRes = true;
1098         }
1099         else if (addr == 0xC05E)
1100         {
1101 #ifdef SOFT_SWITCH_DEBUGGING
1102 WriteLog("DHIRES on (write)\n");
1103 #endif
1104                 if (ioudis)
1105                         dhires = true;
1106
1107 //static int goDumpDis = 0;
1108 //goDumpDis++;
1109 //if (goDumpDis == 2)
1110 //      dumpDis = true;
1111         }
1112         else if (addr == 0xC05F)
1113         {
1114 #ifdef SOFT_SWITCH_DEBUGGING
1115 WriteLog("DHIRES off (write)\n");
1116 #endif
1117                 if (ioudis)
1118                         dhires = false;
1119         }
1120         else if (addr == 0xC07E)
1121         {
1122 #ifdef SOFT_SWITCH_DEBUGGING
1123 WriteLog("IOUDIS on (write)\n");
1124 #endif
1125                 ioudis = true;
1126         }
1127         else if (addr == 0xC07F)
1128         {
1129 #ifdef SOFT_SWITCH_DEBUGGING
1130 WriteLog("IOUDIS off (write)\n");
1131 #endif
1132                 ioudis = false;
1133         }
1134         else if ((addr & 0xFFFB) == 0xC080)
1135         {
1136 #ifdef DEBUG_LC
1137 WriteLog("LC(R): $C080 49280 OECG R Read RAM bank 2; no write\n");
1138 #endif
1139 //$C080 49280              OECG  R   Read RAM bank 2; no write
1140                 visibleBank = LC_BANK_2;
1141                 readRAM = true;
1142                 writeRAM = false;
1143         }
1144         else if ((addr & 0xFFFB) == 0xC081)
1145         {
1146 #ifdef DEBUG_LC
1147 WriteLog("LC(R): $C081 49281 OECG RR Read ROM; write RAM bank 2\n");
1148 #endif
1149 //$C081 49281 ROMIN        OECG  RR  Read ROM; write RAM bank 2
1150                 visibleBank = LC_BANK_2;
1151                 readRAM = false;
1152                 writeRAM = true;
1153         }
1154         else if ((addr & 0xFFFB) == 0xC082)
1155         {
1156 #ifdef DEBUG_LC
1157 WriteLog("LC(R): $C082 49282 OECG R Read ROM; no write\n");
1158 #endif
1159 //$C082 49282              OECG  R   Read ROM; no write
1160                 visibleBank = LC_BANK_2;
1161                 readRAM = false;
1162                 writeRAM = false;
1163         }
1164         else if ((addr & 0xFFFB) == 0xC083)
1165         {
1166 #ifdef DEBUG_LC
1167 WriteLog("LC(R): $C083 49283 OECG RR Read/Write RAM bank 2\n");
1168 #endif
1169 //$C083 49283 LCBANK2      OECG  RR  Read/write RAM bank 2
1170                 visibleBank = LC_BANK_2;
1171                 readRAM = true;
1172                 writeRAM = true;
1173         }
1174         else if ((addr & 0xFFFB) == 0xC088)
1175         {
1176 #ifdef DEBUG_LC
1177 WriteLog("LC(R): $C088 49288 OECG R Read RAM bank 1; no write\n");
1178 #endif
1179 //$C088 49288              OECG  R   Read RAM bank 1; no write
1180                 visibleBank = LC_BANK_1;
1181                 readRAM = true;
1182                 writeRAM = false;
1183         }
1184         else if ((addr & 0xFFFB) == 0xC089)
1185         {
1186 #ifdef DEBUG_LC
1187 WriteLog("LC(R): $C089 49289 OECG RR Read ROM; write RAM bank 1\n");
1188 #endif
1189 //$C089 49289              OECG  RR  Read ROM; write RAM bank 1
1190                 visibleBank = LC_BANK_1;
1191                 readRAM = false;
1192                 writeRAM = true;
1193         }
1194         else if ((addr & 0xFFFB) == 0xC08A)
1195         {
1196 #ifdef DEBUG_LC
1197 WriteLog("LC(R): $C08A 49290 OECG R Read ROM; no write\n");
1198 #endif
1199 //$C08A 49290              OECG  R   Read ROM; no write
1200                 visibleBank = LC_BANK_1;
1201                 readRAM = false;
1202                 writeRAM = false;
1203         }
1204         else if ((addr & 0xFFFB) == 0xC08B)
1205         {
1206 #ifdef DEBUG_LC
1207 WriteLog("LC(R): $C08B 49291 OECG RR Read/Write RAM bank 1\n");
1208 #endif
1209 //$C08B 49291              OECG  RR  Read/write RAM bank 1
1210                 visibleBank = LC_BANK_1;
1211                 readRAM = true;
1212                 writeRAM = true;
1213         }
1214 //This is determined by which slot it is in--this assumes slot 6. !!! FIX !!!
1215         else if ((addr & 0xFFF8) == 0xC0E0)
1216         {
1217                 floppyDrive.ControlStepper(addr & 0x07);
1218         }
1219         else if ((addr & 0xFFFE) == 0xC0E8)
1220         {
1221                 floppyDrive.ControlMotor(addr & 0x01);
1222         }
1223         else if ((addr & 0xFFFE) == 0xC0EA)
1224         {
1225                 floppyDrive.DriveEnable(addr & 0x01);
1226         }
1227         else if (addr == 0xC0EC)
1228         {
1229 //change this to Write()? (and the other to Read()?) Dunno. Seems to work OK, but still...
1230 //or DoIO
1231                 floppyDrive.ReadWrite();
1232         }
1233         else if (addr == 0xC0ED)
1234         {
1235                 floppyDrive.SetLatchValue(b);
1236         }
1237         else if (addr == 0xC0EE)
1238         {
1239                 floppyDrive.SetReadMode();
1240         }
1241         else if (addr == 0xC0EF)
1242         {
1243                 floppyDrive.SetWriteMode();
1244         }
1245 //Still need to add missing I/O switches here...
1246
1247 //DEEE: BD 10 BF       LDA   $BF10,X    [PC=DEF1, SP=01F4, CC=--.B-IZ-, A=00, X=0C, Y=07]
1248 #if 0
1249 if (addr >= 0xD000 && addr <= 0xD00F)
1250 {
1251         WriteLog("*** Write to $%04X: $%02X (writeRAM=%s, PC=%04X, ram$D000=%02X)\n", addr, b, (writeRAM ? "T" : "F"), mainCPU.pc, ram[0xC000]);
1252 }
1253 #endif
1254         if (addr >= 0xC000 && addr <= 0xCFFF)
1255                 return; // Protect LC bank #1 from being written to!
1256
1257         if (addr >= 0xD000)
1258         {
1259                 if (writeRAM)
1260                 {
1261 #if 0
1262                         if (addr <= 0xDFFF && visibleBank == LC_BANK_1)
1263                                 ram[addr - 0x1000] = b;
1264                         else
1265                                 ram[addr] = b;
1266 #else
1267                         if (addr <= 0xDFFF && visibleBank == LC_BANK_1)
1268                         {
1269                                 if (altzp)
1270                                         ram2[addr - 0x1000] = b;
1271                                 else
1272                                         ram[addr - 0x1000] = b;
1273                         }
1274                         else
1275                         {
1276                                 if (altzp)
1277                                         ram2[addr] = b;
1278                                 else
1279                                         ram[addr] = b;
1280                         }
1281 #endif
1282                 }
1283
1284                 return;
1285         }
1286
1287         // Check for 80STORE mode (STORE80 takes precedence over RAMRD/WRT)...
1288         if ((((addr >= 0x0400) && (addr <= 0x07FF)) || ((addr >= 0x2000) && (addr <= 0x3FFF))) && store80Mode)
1289         {
1290                 if (displayPage2)
1291                         ram2[addr] = b;
1292                 else
1293                         ram[addr] = b;
1294
1295                 return;
1296         }
1297
1298         // Finally, check for auxillary/altzp write switches
1299 #if 0
1300         if (ramwrt)
1301                 ram2[addr] = b;
1302         else
1303         {
1304                 if (altzp)
1305                         ram2[addr] = b;
1306                 else
1307                         ram[addr] = b;
1308         }
1309 #else
1310         if (addr < 0x0200)
1311 //      if (addr < 0x0200 || addr >= 0xD000)
1312         {
1313 #if 0
1314 if (addr == 0x38)
1315         WriteLog("Write $38: $%02X\n", b);
1316 else if (addr == 0x39)
1317         WriteLog("Write $39: $%02X\n", b);
1318 #endif
1319                 if (altzp)
1320                         ram2[addr] = b;
1321                 else
1322                         ram[addr] = b;
1323         }
1324         else
1325         {
1326                 if (ramwrt)
1327                         ram2[addr] = b;
1328                 else
1329                         ram[addr] = b;
1330         }
1331 #endif
1332 }
1333
1334
1335 //
1336 // Load a file into RAM/ROM image space
1337 //
1338 bool LoadImg(char * filename, uint8_t * ram, int size)
1339 {
1340         FILE * fp = fopen(filename, "rb");
1341
1342         if (fp == NULL)
1343                 return false;
1344
1345         fread(ram, 1, size, fp);
1346         fclose(fp);
1347
1348         return true;
1349 }
1350
1351
1352 static void SaveApple2State(const char * filename)
1353 {
1354 }
1355
1356
1357 static bool LoadApple2State(const char * filename)
1358 {
1359         return false;
1360 }
1361
1362
1363 #ifdef CPU_CLOCK_CHECKING
1364 uint8_t counter = 0;
1365 uint32_t totalCPU = 0;
1366 uint64_t lastClock = 0;
1367 #endif
1368 //
1369 // Main loop
1370 //
1371 int main(int /*argc*/, char * /*argv*/[])
1372 {
1373         InitLog("./apple2.log");
1374         LoadSettings();
1375         srand(time(NULL));                                                                      // Initialize RNG
1376
1377         // Zero out memory
1378         memset(ram, 0, 0x10000);
1379         memset(rom, 0, 0x10000);
1380         memset(ram2, 0, 0x10000);
1381
1382         // Set up V65C02 execution context
1383         memset(&mainCPU, 0, sizeof(V65C02REGS));
1384         mainCPU.RdMem = RdMem;
1385         mainCPU.WrMem = WrMem;
1386         mainCPU.cpuFlags |= V65C02_ASSERT_LINE_RESET;
1387
1388 //      alternateCharset = true;
1389 //      if (!LoadImg(settings.BIOSPath, rom + 0xD000, 0x3000))
1390         if (!LoadImg(settings.BIOSPath, rom + 0xC000, 0x4000))
1391         {
1392                 WriteLog("Could not open file '%s'!\n", settings.BIOSPath);
1393                 return -1;
1394         }
1395
1396 //This is now included...
1397 /*      if (!LoadImg(settings.diskPath, diskRom, 0x100))
1398         {
1399                 WriteLog("Could not open file '%s'!\nDisk II will be unavailable!\n", settings.diskPath);
1400 //              return -1;
1401         }//*/
1402
1403 //Load up disk image from config file (for now)...
1404         floppyDrive.LoadImage(settings.diskImagePath1, 0);
1405         floppyDrive.LoadImage(settings.diskImagePath2, 1);
1406 //      floppyDrive.LoadImage("./disks/temp.nib", 1);   // Load temp .nib file into second drive...
1407
1408 //Kill the DOS ROM in slot 6 for now...
1409 //not
1410 //      memcpy(rom + 0xC600, diskROM, 0x100);
1411 //      memcpy(rom + 0xC700, diskROM, 0x100);   // Slot 7???
1412
1413         WriteLog("About to initialize video...\n");
1414
1415         if (!InitVideo())
1416         {
1417                 std::cout << "Aborting!" << std::endl;
1418                 return -1;
1419         }
1420
1421         // Have to do this *after* video init but *before* sound init...!
1422 //Shouldn't be necessary since we're not doing emulation in the ISR...
1423         if (settings.autoStateSaving)
1424         {
1425                 // Load last state from file...
1426                 if (!LoadApple2State(settings.autoStatePath))
1427                         WriteLog("Unable to use Apple2 state file \"%s\"!\n", settings.autoStatePath);
1428         }
1429
1430
1431 #if 0
1432 // State loading!
1433 if (!LoadImg("./BT1_6502_RAM_SPACE.bin", ram, 0x10000))
1434 {
1435         cout << "Couldn't load state file!" << endl;
1436         cout << "Aborting!!" << endl;
1437         return -1;
1438 }
1439
1440 //A  P  Y  X  S     PC
1441 //-- -- -- -- ----- -----
1442 //00 75 3B 53 FD 01 41 44
1443
1444 mainCPU.cpuFlags = 0;
1445 mainCPU.a = 0x00;
1446 mainCPU.x = 0x53;
1447 mainCPU.y = 0x3B;
1448 mainCPU.cc = 0x75;
1449 mainCPU.sp = 0xFD;
1450 mainCPU.pc = 0x4441;
1451
1452 textMode = false;
1453 mixedMode = false;
1454 displayPage2 = false;
1455 hiRes = true;
1456
1457 //kludge...
1458 readHiRam = true;
1459 //dumpDis=true;
1460 //kludge II...
1461 memcpy(ram + 0xD000, ram + 0xC000, 0x1000);
1462 #endif
1463
1464         WriteLog("About to initialize audio...\n");
1465         SoundInit();
1466 //nope  SDL_EnableUNICODE(1);                                           // Needed to do key translation shit
1467
1468 //      gui = new GUI(surface);                                         // Set up the GUI system object...
1469 //      gui = new GUI(mainSurface);                                     // Set up the GUI system object...
1470 // SDL 2... this will likely cause Apple 2 to crash
1471 //      gui = new GUI(NULL);                                    // Set up the GUI system object...
1472 #if 0
1473         gui->AddMenuTitle("Apple2");
1474         gui->AddMenuItem("Test!", TestWindow/*, hotkey*/);
1475         gui->AddMenuItem("");
1476         gui->AddMenuItem("Quit", QuitEmulator, SDLK_q);
1477         gui->CommitItemsToMenu();
1478 #endif
1479
1480         SetupBlurTable();                                                       // Set up the color TV emulation blur table
1481         running = true;                                                         // Set running status...
1482
1483         InitializeEventList();                                          // Clear the event list before we use it...
1484         SetCallbackTime(FrameCallback, 16666.66666667); // Set frame to fire at 1/60 s interval
1485         SetCallbackTime(BlinkTimer, 250000);            // Set up blinking at 1/4 s intervals
1486         startTicks = SDL_GetTicks();
1487
1488 #ifdef THREADED_65C02
1489         cpuCond = SDL_CreateCond();
1490         mainSem = SDL_CreateSemaphore(1);
1491         cpuThread = SDL_CreateThread(CPUThreadFunc, NULL, NULL);
1492 //Hmm... CPU does POST (+1), wait, then WAIT (-1)
1493 //      SDL_sem * mainMutex = SDL_CreateMutex();
1494 #endif
1495
1496         WriteLog("Entering main loop...\n");
1497         while (running)
1498         {
1499                 double timeToNextEvent = GetTimeToNextEvent();
1500 #ifndef THREADED_65C02
1501                 Execute65C02(&mainCPU, USEC_TO_M6502_CYCLES(timeToNextEvent));
1502 #endif
1503 //We MUST remove a frame's worth of time in order for the CPU to function... !!! FIX !!!
1504 //(Fix so that this is not a requirement!)
1505 //Fixed, but mainCPU.clock is destroyed in the bargain. Oh well.
1506 //              mainCPU.clock -= USEC_TO_M6502_CYCLES(timeToNextEvent);
1507
1508 #ifdef CPU_CLOCK_CHECKING
1509 #ifndef THREADED_65C02
1510 totalCPU += USEC_TO_M6502_CYCLES(timeToNextEvent);
1511 #endif
1512 #endif
1513                 // Handle CPU time delta for sound...
1514 //Don't need this anymore now that we use absolute time...
1515 //              AddToSoundTimeBase(USEC_TO_M6502_CYCLES(timeToNextEvent));
1516                 HandleNextEvent();
1517         }
1518
1519 #ifdef THREADED_65C02
1520 WriteLog("Main: cpuFinished = true;\n");
1521 cpuFinished = true;
1522 //#warning "If sound thread is behind, CPU thread will never wake up... !!! FIX !!!" [DONE]
1523 //What to do? How do you know when the CPU is sleeping???
1524 //USE A CONDITIONAL!!! OF COURSE!!!!!!11!11!11!!!1!
1525 #if 0
1526 SDL_mutexP(mainMutex);
1527 SDL_CondWait(mainCond, mainMutex);      // Wait for CPU thread to get to signal point...
1528 SDL_mutexV(mainMutex);
1529 #else
1530 //Nope, use a semaphore...
1531 WriteLog("Main: SDL_SemWait(mainSem);\n");
1532 SDL_SemWait(mainSem);//should lock until CPU thread is waiting...
1533 #endif
1534
1535 WriteLog("Main: SDL_CondSignal(cpuCond);//thread is probably asleep, wake it up\n");
1536 SDL_CondSignal(cpuCond);//thread is probably asleep, wake it up
1537 WriteLog("Main: SDL_WaitThread(cpuThread, NULL);\n");
1538 SDL_WaitThread(cpuThread, NULL);
1539 //nowok:SDL_WaitThread(CPUThreadFunc, NULL);
1540 WriteLog("Main: SDL_DestroyCond(cpuCond);\n");
1541 SDL_DestroyCond(cpuCond);
1542
1543 //SDL_DestroyMutex(mainMutex);
1544 SDL_DestroySemaphore(mainSem);
1545 #endif
1546
1547         if (settings.autoStateSaving)
1548         {
1549                 // Save state here...
1550                 SaveApple2State(settings.autoStatePath);
1551         }
1552 floppyDrive.SaveImage();
1553
1554         SoundDone();
1555         VideoDone();
1556         SaveSettings();
1557         LogDone();
1558
1559         return 0;
1560 }
1561
1562
1563 /*
1564 Apple II keycodes
1565 -----------------
1566
1567 Key     Aln CTL SHF BTH
1568 -----------------------
1569 space   $A0     $A0     $A0 $A0         No xlation
1570 RETURN  $8D     $8D     $8D     $8D             No xlation
1571 0               $B0     $B0     $B0     $B0             Need to screen shift+0 (?)
1572 1!              $B1 $B1 $A1 $A1         No xlation
1573 2"              $B2     $B2     $A2     $A2             No xlation
1574 3#              $B3     $B3     $A3     $A3             No xlation
1575 4$              $B4     $B4     $A4     $A4             No xlation
1576 5%              $B5     $B5     $A5     $A5             No xlation
1577 6&              $B6     $B6     $A6     $A6             No xlation
1578 7'              $B7     $B7     $A7     $A7             No xlation
1579 8(              $B8     $B8     $A8     $A8             No xlation
1580 9)              $B9     $B9     $A9     $A9             No xlation
1581 :*              $BA     $BA     $AA     $AA             No xlation
1582 ;+              $BB     $BB     $AB     $AB             No xlation
1583 ,<              $AC     $AC     $BC     $BC             No xlation
1584 -=              $AD     $AD     $BD     $BD             No xlation
1585 .>              $AE     $AE     $BE     $BE             No xlation
1586 /?              $AF     $AF     $BF     $BF             No xlation
1587 A               $C1     $81     $C1     $81
1588 B               $C2     $82     $C2     $82
1589 C               $C3     $83     $C3     $83
1590 D               $C4     $84     $C4     $84
1591 E               $C5     $85     $C5     $85
1592 F               $C6     $86     $C6     $86
1593 G               $C7     $87     $C7     $87
1594 H               $C8     $88     $C8     $88
1595 I               $C9     $89     $C9     $89
1596 J               $CA     $8A     $CA     $8A
1597 K               $CB     $8B     $CB     $8B
1598 L               $CC     $8C     $CC     $8C
1599 M               $CD     $8D     $DD     $9D             -> ODD
1600 N^              $CE     $8E     $DE     $9E             -> ODD
1601 O               $CF     $8F     $CF     $8F
1602 P@              $D0     $90     $C0     $80             Need to xlate CTL+SHFT+P & SHFT+P (?)
1603 Q               $D1     $91     $D1     $91
1604 R               $D2     $92     $D2     $92
1605 S               $D3     $93     $D3     $93
1606 T               $D4     $94     $D4     $94
1607 U               $D5     $95     $D5     $95
1608 V               $D6     $96     $D6     $96
1609 W               $D7     $97     $D7     $97
1610 X               $D8     $98     $D8     $98
1611 Y               $D9     $99     $D9     $99
1612 Z               $DA     $9A     $DA     $9A
1613 <-              $88     $88     $88     $88
1614 ->              $95     $95     $95     $95
1615 ESC             $9B     $9B     $9B     $9B             No xlation
1616
1617 */
1618 //static uint64_t lastCPUCycles = 0;
1619 static uint32_t frameCount = 0;
1620 static void FrameCallback(void)
1621 {
1622         SDL_Event event;
1623
1624         while (SDL_PollEvent(&event))
1625         {
1626                 switch (event.type)
1627                 {
1628                 case SDL_TEXTINPUT:
1629 //Need to do some key translation here, and screen out non-apple keys as well...
1630 //(really, could do it all in SDL_KEYDOWN, would just have to get symbols &
1631 // everything else done separately. this is slightly easier. :-P)
1632 //                      if (event.key.keysym.sym == SDLK_TAB)   // Prelim key screening...
1633                         if (event.edit.text[0] == '\t') // Prelim key screening...
1634                                 break;
1635
1636                         lastKeyPressed = event.edit.text[0];
1637                         keyDown = true;
1638
1639                         //kludge: should have a caps lock thingy here...
1640                         //or all uppercase for ][+...
1641 //                      if (lastKeyPressed >= 'a' && lastKeyPressed <='z')
1642 //                              lastKeyPressed &= 0xDF;         // Convert to upper case...
1643
1644                         break;
1645                 case SDL_KEYDOWN:
1646                         // CTRL+RESET key emulation (mapped to CTRL+`)
1647 // This doesn't work...
1648 //                      if (event.key.keysym.sym == SDLK_BREAK && (event.key.keysym.mod & KMOD_CTRL))
1649 //                      if (event.key.keysym.sym == SDLK_PAUSE && (event.key.keysym.mod & KMOD_CTRL))
1650                         if (event.key.keysym.sym == SDLK_BACKQUOTE && (event.key.keysym.mod & KMOD_CTRL))
1651 //NOTE that this shouldn't take place until the key is lifted... !!! FIX !!!
1652 //ALSO it seems to leave the machine in an inconsistent state vis-a-vis the language card...
1653                                 mainCPU.cpuFlags |= V65C02_ASSERT_LINE_RESET;
1654
1655                         if (event.key.keysym.sym == SDLK_RIGHT)
1656                                 lastKeyPressed = 0x15, keyDown = true;
1657                         else if (event.key.keysym.sym == SDLK_LEFT)
1658                                 lastKeyPressed = 0x08, keyDown = true;
1659                         else if (event.key.keysym.sym == SDLK_UP)
1660                                 lastKeyPressed = 0x0B, keyDown = true;
1661                         else if (event.key.keysym.sym == SDLK_DOWN)
1662                                 lastKeyPressed = 0x0A, keyDown = true;
1663                         else if (event.key.keysym.sym == SDLK_RETURN)
1664                                 lastKeyPressed = 0x0D, keyDown = true;
1665                         else if (event.key.keysym.sym == SDLK_ESCAPE)
1666                                 lastKeyPressed = 0x1B, keyDown = true;
1667                         else if (event.key.keysym.sym == SDLK_BACKSPACE)
1668                                 lastKeyPressed = 0x7F, keyDown = true;
1669
1670                         // Fix CTRL+key combo...
1671                         if (event.key.keysym.mod & KMOD_CTRL)
1672                         {
1673                                 if (event.key.keysym.sym >= SDLK_a && event.key.keysym.sym <= SDLK_z)
1674                                 {
1675                                         lastKeyPressed = (event.key.keysym.sym - SDLK_a) + 1;
1676                                         keyDown = true;
1677 //printf("Key combo pressed: CTRL+%c\n", lastKeyPressed + 0x40);
1678                                 }
1679                         }
1680
1681                         // Use ALT+Q to exit, as well as the usual window decoration method
1682                         if (event.key.keysym.sym == SDLK_q && (event.key.keysym.mod & KMOD_ALT))
1683                                 running = false;
1684
1685                         if (event.key.keysym.sym == SDLK_PAUSE)
1686                         {
1687                                 pauseMode = !pauseMode;
1688
1689                                 if (pauseMode)
1690                                 {
1691                                         SoundPause();
1692                                         SpawnMessage("*** PAUSED ***");
1693                                 }
1694                                 else
1695                                 {
1696                                         SoundResume();
1697                                         SpawnMessage("*** RESUME ***");
1698                                 }
1699                         }
1700
1701                         // Paddle buttons 0 & 1
1702                         if (event.key.keysym.sym == SDLK_INSERT)
1703                                 openAppleDown = true;
1704                         if (event.key.keysym.sym == SDLK_PAGEUP)
1705                                 closedAppleDown = true;
1706
1707                         if (event.key.keysym.sym == SDLK_F11)
1708                                 dumpDis = !dumpDis;                             // Toggle the disassembly process
1709 //                      else if (event.key.keysym.sym == SDLK_F11)
1710 //                              floppyDrive.LoadImage("./disks/bt1_char.dsk");//Kludge to load char disk...
1711 else if (event.key.keysym.sym == SDLK_F9)
1712 {
1713         floppyDrive.CreateBlankImage();
1714 //      SpawnMessage("Image cleared...");
1715 }//*/
1716 else if (event.key.keysym.sym == SDLK_F10)
1717 {
1718         floppyDrive.SwapImages();
1719 //      SpawnMessage("Image swapped...");
1720 }//*/
1721
1722                         if (event.key.keysym.sym == SDLK_F2)// Toggle the palette
1723                                 TogglePalette();
1724                         else if (event.key.keysym.sym == SDLK_F3)// Cycle through screen types
1725                                 CycleScreenTypes();
1726
1727 //                      if (event.key.keysym.sym == SDLK_F5)    // Temp GUI launch key
1728                         if (event.key.keysym.sym == SDLK_F1)    // GUI launch key
1729 //NOTE: Should parse the output to determine whether or not the user requested
1730 //      to quit completely... !!! FIX !!!
1731                                 gui->Run();
1732
1733                         if (event.key.keysym.sym == SDLK_F5)
1734                         {
1735                                 VolumeDown();
1736                                 char volStr[19] = "[****************]";
1737 //                              volStr[GetVolume()] = 0;
1738                                 for(int i=GetVolume(); i<16; i++)
1739                                         volStr[1 + i] = '-';
1740                                 SpawnMessage("Volume: %s", volStr);
1741                         }
1742                         else if (event.key.keysym.sym == SDLK_F6)
1743                         {
1744                                 VolumeUp();
1745                                 char volStr[19] = "[****************]";
1746 //                              volStr[GetVolume()] = 0;
1747                                 for(int i=GetVolume(); i<16; i++)
1748                                         volStr[1 + i] = '-';
1749                                 SpawnMessage("Volume: %s", volStr);
1750                         }
1751
1752                         static bool fullscreenDebounce = false;
1753
1754                         if (event.key.keysym.sym == SDLK_F12)
1755                         {
1756                                 if (!fullscreenDebounce)
1757                                 {
1758                                         ToggleFullScreen();
1759                                         fullscreenDebounce = true;
1760                                 }
1761                         }
1762 //                      else
1763
1764                         break;
1765                 case SDL_KEYUP:
1766                         if (event.key.keysym.sym == SDLK_F12)
1767                                 fullscreenDebounce = false;
1768
1769                         // Paddle buttons 0 & 1
1770                         if (event.key.keysym.sym == SDLK_INSERT)
1771                                 openAppleDown = false;
1772                         if (event.key.keysym.sym == SDLK_PAGEUP)
1773                                 closedAppleDown = false;
1774
1775 //                      if (event.key.keysym.sym >= SDLK_a && event.key.keysym.sym <= SDLK_z)
1776 //                              keyDown = false;
1777
1778                         break;
1779                 case SDL_QUIT:
1780                         running = false;
1781                 }
1782         }
1783
1784 //#warning "!!! Taking MAJOR time hit with the video frame rendering !!!"
1785         RenderVideoFrame();
1786         SetCallbackTime(FrameCallback, 16666.66666667);
1787
1788 #ifdef CPU_CLOCK_CHECKING
1789 //We know it's stopped, so we can get away with this...
1790 counter++;
1791 if (counter == 60)
1792 {
1793         uint64_t clock = GetCurrentV65C02Clock();
1794 //totalCPU += (uint32_t)(clock - lastClock);
1795
1796         printf("Executed %u cycles...\n", (uint32_t)(clock - lastClock));
1797         lastClock = clock;
1798 //      totalCPU = 0;
1799         counter = 0;
1800 }
1801 #endif
1802 //Instead of this, we should yield remaining time to other processes... !!! FIX !!! [DONE]
1803 //lessee...
1804 //nope.
1805 //Actually, slows things down too much...
1806 //SDL_Delay(10);
1807 //      while (SDL_GetTicks() - startTicks < 16);       // Wait for next frame...
1808
1809 // This is the problem: If you set the interval to 16, it runs faster than
1810 // 1/60s per frame. If you set it to 17, it runs slower. What we need is to
1811 // have it do 16 for one frame, then 17 for two others. Then it should average
1812 // out to 1/60s per frame every 3 frames.
1813         frameCount = (frameCount + 1) % 3;
1814
1815         uint32_t waitFrameTime = 17 - (frameCount == 0 ? 1 : 0);
1816
1817         while (SDL_GetTicks() - startTicks < waitFrameTime)
1818                 SDL_Delay(1);                                                   // Wait for next frame...
1819
1820         startTicks = SDL_GetTicks();
1821 #if 0
1822         uint64_t cpuCycles = GetCurrentV65C02Clock();
1823         uint32_t cyclesBurned = (uint32_t)(cpuCycles - lastCPUCycles);
1824         WriteLog("FrameCallback: used %i cycles\n", cyclesBurned);
1825         lastCPUCycles = cpuCycles;
1826 #endif
1827
1828 //let's wait, then signal...
1829 //works longer, but then still falls behind...
1830 #ifdef THREADED_65C02
1831         if (!pauseMode)
1832                 SDL_CondSignal(cpuCond);//OK, let the CPU go another frame...
1833 #endif
1834 }
1835
1836
1837 static void BlinkTimer(void)
1838 {
1839         flash = !flash;
1840         SetCallbackTime(BlinkTimer, 250000);            // Set up blinking at 1/4 sec intervals
1841 }
1842
1843
1844 /*
1845 Next problem is this: How to have events occur and synchronize with the rest
1846 of the threads?
1847
1848   o Have the CPU thread manage the timer mechanism? (need to have a method of carrying
1849     remainder CPU cycles over...)
1850
1851 One way would be to use a fractional accumulator, then subtract 1 every
1852 time it overflows. Like so:
1853
1854 double overflow = 0;
1855 uint32_t time = 20;
1856 while (!done)
1857 {
1858         Execute6808(&soundCPU, time);
1859         overflow += 0.289115646;
1860         if (overflow > 1.0)
1861         {
1862                 overflow -= 1.0;
1863                 time = 21;
1864         }
1865         else
1866                 time = 20;
1867 }
1868 */