ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/SAM.cpp
Revision: 1.6
Committed: 2009-01-11T11:20:16Z (13 years, 10 months ago) by cebix
Branch: MAIN
CVS Tags: HEAD
Changes since 1.5: +3 -3 lines
Log Message:
const correctness

File Contents

# Content
1 /*
2 * SAM.h - Simple Assembler and Monitor With Integrated System Explorer
3 *
4 * Frodo (C) 1994-1997,2002-2009 Christian Bauer
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "sysdeps.h"
22
23 #include "SAM.h"
24 #include "C64.h"
25 #include "CPUC64.h"
26 #include "CPU1541.h"
27 #include "VIC.h"
28 #include "SID.h"
29 #include "CIA.h"
30
31
32 // Pointers to chips
33 static MOS6510 *TheCPU;
34 static MOS6502_1541 *TheCPU1541;
35 static MOS6569 *TheVIC;
36 static MOS6581 *TheSID;
37 static MOS6526_1 *TheCIA1;
38 static MOS6526_2 *TheCIA2;
39
40 // 6510/6502 registers
41 static MOS6510State R64;
42 static MOS6502State R1541;
43
44 static bool access_1541; // false: accessing C64, true: accessing 1541
45
46 // Access to 6510/6502 address space
47 static inline uint8 SAMReadByte(uint16 adr)
48 {
49 if (access_1541)
50 return TheCPU1541->ExtReadByte(adr);
51 else
52 return TheCPU->ExtReadByte(adr);
53 }
54
55 static inline void SAMWriteByte(uint16 adr, uint8 byte)
56 {
57 if (access_1541)
58 TheCPU1541->ExtWriteByte(adr, byte);
59 else
60 TheCPU->ExtWriteByte(adr, byte);
61 }
62
63
64 // Streams for input, output and error messages
65 static FILE *fin, *fout, *ferr;
66
67 // Input line
68 #define INPUT_LENGTH 80
69 static char input[INPUT_LENGTH];
70 static char *in_ptr;
71
72 static uint16 address, end_address;
73
74
75 // Input tokens
76 enum Token {
77 T_NULL, // Invalid token
78 T_END, // End of line
79 T_NUMBER, // Hexadecimal number
80 T_STRING, // String enclosed in ""
81 T_LPAREN, // '('
82 T_RPAREN, // ')'
83 T_ADD, // '+'
84 T_SUB, // '-'
85 T_MUL, // '*'
86 T_DIV, // '/'
87 T_COMMA, // ','
88 T_IMMED, // '#'
89 T_X, // 'x'
90 T_Y, // 'y'
91 T_PC, // 'pc'
92 T_SP, // 'sp'
93
94 T_A, // 'a' (get_reg_token() only)
95 T_DR, // 'dr' (get_reg_token() only)
96 T_PR // 'pr' (get_reg_token() only)
97 };
98
99 static enum Token the_token; // Last token read
100 static uint16 the_number; // Contains the number if the_token==T_NUMBER
101 static char the_string[INPUT_LENGTH]; // Contains the string if the_token==T_STRING
102
103
104 // Addressing modes
105 enum {
106 A_IMPL,
107 A_ACCU, // A
108 A_IMM, // #zz
109 A_REL, // Branches
110 A_ZERO, // zz
111 A_ZEROX, // zz,x
112 A_ZEROY, // zz,y
113 A_ABS, // zzzz
114 A_ABSX, // zzzz,x
115 A_ABSY, // zzzz,y
116 A_IND, // (zzzz)
117 A_INDX, // (zz,x)
118 A_INDY // (zz),y
119 };
120
121 // Mnemonics
122 enum {
123 M_ADC, M_AND, M_ASL, M_BCC, M_BCS, M_BEQ, M_BIT, M_BMI, M_BNE, M_BPL,
124 M_BRK, M_BVC, M_BVS, M_CLC, M_CLD, M_CLI, M_CLV, M_CMP, M_CPX, M_CPY,
125 M_DEC, M_DEX, M_DEY, M_EOR, M_INC, M_INX, M_INY, M_JMP, M_JSR, M_LDA,
126 M_LDX, M_LDY, M_LSR, M_NOP, M_ORA, M_PHA, M_PHP, M_PLA, M_PLP, M_ROL,
127 M_ROR, M_RTI, M_RTS, M_SBC, M_SEC, M_SED, M_SEI, M_STA, M_STX, M_STY,
128 M_TAX, M_TAY, M_TSX, M_TXA, M_TXS, M_TYA,
129
130 M_ILLEGAL, // Undocumented opcodes start here
131
132 M_IANC, M_IANE, M_IARR, M_IASR, M_IDCP, M_IISB, M_IJAM, M_INOP, M_ILAS,
133 M_ILAX, M_ILXA, M_IRLA, M_IRRA, M_ISAX, M_ISBC, M_ISBX, M_ISHA, M_ISHS,
134 M_ISHX, M_ISHY, M_ISLO, M_ISRE,
135
136 M_MAXIMUM // Highest element
137 };
138
139 // Mnemonic for each opcode
140 static const char mnemonic[256] = {
141 M_BRK , M_ORA , M_IJAM, M_ISLO, M_INOP, M_ORA, M_ASL , M_ISLO, // 00
142 M_PHP , M_ORA , M_ASL , M_IANC, M_INOP, M_ORA, M_ASL , M_ISLO,
143 M_BPL , M_ORA , M_IJAM, M_ISLO, M_INOP, M_ORA, M_ASL , M_ISLO, // 10
144 M_CLC , M_ORA , M_INOP, M_ISLO, M_INOP, M_ORA, M_ASL , M_ISLO,
145 M_JSR , M_AND , M_IJAM, M_IRLA, M_BIT , M_AND, M_ROL , M_IRLA, // 20
146 M_PLP , M_AND , M_ROL , M_IANC, M_BIT , M_AND, M_ROL , M_IRLA,
147 M_BMI , M_AND , M_IJAM, M_IRLA, M_INOP, M_AND, M_ROL , M_IRLA, // 30
148 M_SEC , M_AND , M_INOP, M_IRLA, M_INOP, M_AND, M_ROL , M_IRLA,
149 M_RTI , M_EOR , M_IJAM, M_ISRE, M_INOP, M_EOR, M_LSR , M_ISRE, // 40
150 M_PHA , M_EOR , M_LSR , M_IASR, M_JMP , M_EOR, M_LSR , M_ISRE,
151 M_BVC , M_EOR , M_IJAM, M_ISRE, M_INOP, M_EOR, M_LSR , M_ISRE, // 50
152 M_CLI , M_EOR , M_INOP, M_ISRE, M_INOP, M_EOR, M_LSR , M_ISRE,
153 M_RTS , M_ADC , M_IJAM, M_IRRA, M_INOP, M_ADC, M_ROR , M_IRRA, // 60
154 M_PLA , M_ADC , M_ROR , M_IARR, M_JMP , M_ADC, M_ROR , M_IRRA,
155 M_BVS , M_ADC , M_IJAM, M_IRRA, M_INOP, M_ADC, M_ROR , M_IRRA, // 70
156 M_SEI , M_ADC , M_INOP, M_IRRA, M_INOP, M_ADC, M_ROR , M_IRRA,
157 M_INOP, M_STA , M_INOP, M_ISAX, M_STY , M_STA, M_STX , M_ISAX, // 80
158 M_DEY , M_INOP, M_TXA , M_IANE, M_STY , M_STA, M_STX , M_ISAX,
159 M_BCC , M_STA , M_IJAM, M_ISHA, M_STY , M_STA, M_STX , M_ISAX, // 90
160 M_TYA , M_STA , M_TXS , M_ISHS, M_ISHY, M_STA, M_ISHX, M_ISHA,
161 M_LDY , M_LDA , M_LDX , M_ILAX, M_LDY , M_LDA, M_LDX , M_ILAX, // a0
162 M_TAY , M_LDA , M_TAX , M_ILXA, M_LDY , M_LDA, M_LDX , M_ILAX,
163 M_BCS , M_LDA , M_IJAM, M_ILAX, M_LDY , M_LDA, M_LDX , M_ILAX, // b0
164 M_CLV , M_LDA , M_TSX , M_ILAS, M_LDY , M_LDA, M_LDX , M_ILAX,
165 M_CPY , M_CMP , M_INOP, M_IDCP, M_CPY , M_CMP, M_DEC , M_IDCP, // c0
166 M_INY , M_CMP , M_DEX , M_ISBX, M_CPY , M_CMP, M_DEC , M_IDCP,
167 M_BNE , M_CMP , M_IJAM, M_IDCP, M_INOP, M_CMP, M_DEC , M_IDCP, // d0
168 M_CLD , M_CMP , M_INOP, M_IDCP, M_INOP, M_CMP, M_DEC , M_IDCP,
169 M_CPX , M_SBC , M_INOP, M_IISB, M_CPX , M_SBC, M_INC , M_IISB, // e0
170 M_INX , M_SBC , M_NOP , M_ISBC, M_CPX , M_SBC, M_INC , M_IISB,
171 M_BEQ , M_SBC , M_IJAM, M_IISB, M_INOP, M_SBC, M_INC , M_IISB, // f0
172 M_SED , M_SBC , M_INOP, M_IISB, M_INOP, M_SBC, M_INC , M_IISB
173 };
174
175 // Addressing mode for each opcode
176 static const char adr_mode[256] = {
177 A_IMPL, A_INDX, A_IMPL, A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // 00
178 A_IMPL, A_IMM , A_ACCU, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
179 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // 10
180 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX,
181 A_ABS , A_INDX, A_IMPL, A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // 20
182 A_IMPL, A_IMM , A_ACCU, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
183 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // 30
184 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX,
185 A_IMPL, A_INDX, A_IMPL, A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // 40
186 A_IMPL, A_IMM , A_ACCU, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
187 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // 50
188 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX,
189 A_IMPL, A_INDX, A_IMPL, A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // 60
190 A_IMPL, A_IMM , A_ACCU, A_IMM , A_IND , A_ABS , A_ABS , A_ABS,
191 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // 70
192 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX,
193 A_IMM , A_INDX, A_IMM , A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // 80
194 A_IMPL, A_IMM , A_IMPL, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
195 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROY, A_ZEROY, // 90
196 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSY , A_ABSY,
197 A_IMM , A_INDX, A_IMM , A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // a0
198 A_IMPL, A_IMM , A_IMPL, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
199 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROY, A_ZEROY, // b0
200 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSY , A_ABSY,
201 A_IMM , A_INDX, A_IMM , A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // c0
202 A_IMPL, A_IMM , A_IMPL, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
203 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // d0
204 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX,
205 A_IMM , A_INDX, A_IMM , A_INDX, A_ZERO , A_ZERO , A_ZERO , A_ZERO, // e0
206 A_IMPL, A_IMM , A_IMPL, A_IMM , A_ABS , A_ABS , A_ABS , A_ABS,
207 A_REL , A_INDY, A_IMPL, A_INDY, A_ZEROX, A_ZEROX, A_ZEROX, A_ZEROX, // f0
208 A_IMPL, A_ABSY, A_IMPL, A_ABSY, A_ABSX , A_ABSX , A_ABSX , A_ABSX
209 };
210
211 // Chars for each mnemonic
212 static const char mnem_1[] = "aaabbbbbbbbbbcccccccdddeiiijjllllnopppprrrrssssssstttttt?aaaadijnlllrrsssssssss";
213 static const char mnem_2[] = "dnscceimnprvvllllmppeeeonnnmsdddsorhhlloottbeeetttaasxxy?nnrscsaoaaxlrabbhhhhlr";
214 static const char mnem_3[] = "cdlcsqtielkcscdivpxycxyrcxypraxyrpaapaplrisccdiaxyxyxasa?cerrpbmpsxaaaxcxasxyoe";
215
216 // Instruction length for each addressing mode
217 static const char adr_length[] = {1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2};
218
219
220 // Prototypes
221 static void error(const char *s);
222 static void handle_abort(...);
223 static void init_abort(void);
224 static void exit_abort(void);
225 static bool aborted(void);
226
227 static void read_line(void); // Scanner
228 static char get_char(void);
229 static void put_back(char c);
230 static enum Token get_token(void);
231 static enum Token get_reg_token(void);
232 static uint16 get_number(void);
233 static enum Token get_string(char *str);
234
235 static bool expression(uint16 *number); // Parser
236 static bool term(uint16 *number);
237 static bool factor(uint16 *number);
238 static bool address_args(void);
239 static bool range_args(int def_range);
240 static bool instr_args(uint16 *number, char *mode);
241
242 static void help(void); // Routines for commands
243 static void registers(void);
244 static void display_registers(void);
245 static void memory_dump(void);
246 static void ascii_dump(void);
247 static char conv_from_64(char c);
248 static void screen_dump(void);
249 static char conv_from_scode(char c);
250 static void binary_dump(void);
251 static void sprite_dump(void);
252 static void byte_to_bin(uint8 byte, char *str);
253 static void disassemble(void);
254 static int disass_line(uint16 adr, uint8 op, uint8 lo, uint8 hi);
255 static void assemble(void);
256 static char find_mnemonic(char op1, char op2, char op3);
257 static bool find_opcode(char mnem, char mode, uint8 *opcode);
258 static void mem_config(void);
259 static void fill(void);
260 static void compare(void);
261 static void transfer(void);
262 static void modify(void);
263 static void print_expr(void);
264 static void redir_output(void);
265 static void int_vectors(void);
266 static void view_state(void);
267 static void view_cia_state(void);
268 static void dump_cia_ints(uint8 i);
269 static void view_sid_state(void);
270 static void dump_sid_waveform(uint8 wave);
271 static void view_vic_state(void);
272 static void dump_spr_flags(uint8 f);
273 static void dump_vic_ints(uint8 i);
274 static void view_1541_state(void);
275 static void dump_via_ints(uint8 i);
276 static void load_data(void);
277 static void save_data(void);
278
279
280 /*
281 * Open and handle SAM
282 */
283
284 void SAM(C64 *the_c64)
285 {
286 bool done = false;
287 char c;
288
289 TheCPU = the_c64->TheCPU;
290 TheCPU1541 = the_c64->TheCPU1541;
291 TheVIC = the_c64->TheVIC;
292 TheSID = the_c64->TheSID;
293 TheCIA1 = the_c64->TheCIA1;
294 TheCIA2 = the_c64->TheCIA2;
295
296 // Get CPU registers and current memory configuration
297 TheCPU->GetState(&R64);
298 TheCPU->ExtConfig = (~R64.ddr | R64.pr) & 7;
299 TheCPU1541->GetState(&R1541);
300
301 #ifdef __riscos__
302 Wimp_CommandWindow((int)"SAM");
303 #endif
304
305 #ifdef AMIGA
306 if (!(fin = fout = ferr = fopen("CON:0/0/640/480/SAM", "w+")))
307 return;
308 #else
309 fin = stdin;
310 fout = stdout;
311 ferr = stdout;
312 #endif
313
314 access_1541 = false;
315 address = R64.pc;
316
317 fprintf(ferr, "\n *** SAM - Simple Assembler and Monitor ***\n *** Press 'h' for help ***\n\n");
318 init_abort();
319 display_registers();
320
321 while (!done) {
322 if (access_1541)
323 fprintf(ferr, "1541> ");
324 else
325 fprintf(ferr, "C64> ");
326 fflush(ferr);
327 read_line();
328 while ((c = get_char()) == ' ') ;
329
330 switch (c) {
331 case 'a': // Assemble
332 get_token();
333 assemble();
334 break;
335
336 case 'b': // Binary dump
337 get_token();
338 binary_dump();
339 break;
340
341 case 'c': // Compare
342 get_token();
343 compare();
344 break;
345
346 case 'd': // Disassemble
347 get_token();
348 disassemble();
349 break;
350
351 case 'e': // Interrupt vectors
352 int_vectors();
353 break;
354
355 case 'f': // Fill
356 get_token();
357 fill();
358 break;
359
360 case 'h': // Help
361 help();
362 break;
363
364 case 'i': // ASCII dump
365 get_token();
366 ascii_dump();
367 break;
368
369 case 'k': // Memory configuration
370 get_token();
371 mem_config();
372 break;
373
374 case 'l': // Load data
375 get_token();
376 load_data();
377 break;
378
379 case 'm': // Memory dump
380 get_token();
381 memory_dump();
382 break;
383
384 case 'n': // Screen code dump
385 get_token();
386 screen_dump();
387 break;
388
389 case 'o': // Redirect output
390 get_token();
391 redir_output();
392 break;
393
394 case 'p': // Sprite dump
395 get_token();
396 sprite_dump();
397 break;
398
399 case 'r': // Registers
400 get_reg_token();
401 registers();
402 break;
403
404 case 's': // Save data
405 get_token();
406 save_data();
407 break;
408
409 case 't': // Transfer
410 get_token();
411 transfer();
412 break;
413
414 case 'v': // View machine state
415 view_state();
416 break;
417
418 case 'x': // Exit
419 done = true;
420 break;
421
422 case ':': // Change memory
423 get_token();
424 modify();
425 break;
426
427 case '1': // Switch to 1541 mode
428 access_1541 = true;
429 break;
430
431 case '6': // Switch to C64 mode
432 access_1541 = false;
433 break;
434
435 case '?': // Compute expression
436 get_token();
437 print_expr();
438 break;
439
440 case '\n': // Blank line
441 break;
442
443 default: // Unknown command
444 error("Unknown command");
445 break;
446 }
447 }
448
449 exit_abort();
450
451 #ifdef AMIGA
452 fclose(fin);
453 #endif
454 if (fout != ferr)
455 fclose(fout);
456
457 #ifdef __riscos__
458 Wimp_CommandWindow(-1);
459 #endif
460
461 // Set CPU registers
462 TheCPU->SetState(&R64);
463 TheCPU1541->SetState(&R1541);
464 }
465
466
467 /*
468 * Print error message
469 */
470
471 static void error(const char *s)
472 {
473 fprintf(ferr, "*** %s\n", s);
474 }
475
476
477 /*
478 * CTRL-C pressed?
479 */
480
481 static bool WasAborted;
482
483 #ifdef HAVE_SIGACTION
484 struct sigaction my_sa;
485 #endif
486
487 static void handle_abort(...)
488 {
489 WasAborted = true;
490 #if !defined(HAVE_SIGACTION) && defined(HAVE_SIGNAL)
491 #ifdef __riscos__
492 signal(SIGINT, (Handler*) handle_abort);
493 #else
494 signal(SIGINT, (sighandler_t) handle_abort);
495 #endif
496 #endif
497 }
498
499 static void init_abort(void)
500 {
501 WasAborted = false;
502 #if defined(HAVE_SIGACTION)
503 my_sa.sa_handler = (void (*)(int))handle_abort;
504 my_sa.sa_flags = 0;
505 sigemptyset(&my_sa.sa_mask);
506 sigaction(SIGINT, &my_sa, NULL);
507 #elif defined(HAVE_SIGNAL)
508 #ifdef __riscos__
509 signal(SIGINT, (Handler*) handle_abort);
510 #else
511 signal(SIGINT, (sighandler_t) handle_abort);
512 #endif
513 #endif
514 }
515
516 static void exit_abort(void)
517 {
518 #if defined(HAVE_SIGACTION)
519 my_sa.sa_handler = SIG_DFL;
520 sigaction(SIGINT, &my_sa, NULL);
521 #elif defined(HAVE_SIGNAL)
522 signal(SIGINT, SIG_DFL);
523 #endif
524 }
525
526 static bool aborted(void)
527 {
528 bool ret = WasAborted;
529
530 WasAborted = false;
531 return ret;
532 }
533
534
535 /*
536 * Read a line from the keyboard
537 */
538
539 static void read_line(void)
540 {
541 #ifdef __riscos__
542 OS_ReadLine(in_ptr = input, INPUT_LENGTH, 0, 255, 0);
543 #else
544 fgets(in_ptr = input, INPUT_LENGTH, fin);
545 #endif
546 }
547
548
549 /*
550 * Read a character from the input line
551 */
552
553 static char get_char(void)
554 {
555 return *in_ptr++;
556 }
557
558
559 /*
560 * Stuff back a character into the input line
561 */
562
563 static void put_back(char c)
564 {
565 *(--in_ptr) = c;
566 }
567
568
569 /*
570 * Scanner: Get a token from the input line
571 */
572
573 static enum Token get_token(void)
574 {
575 char c;
576
577 // Skip spaces
578 while ((c = get_char()) == ' ') ;
579
580 switch (c) {
581 case '\n':
582 return the_token = T_END;
583 case '(':
584 return the_token = T_LPAREN;
585 case ')':
586 return the_token = T_RPAREN;
587 case '+':
588 return the_token = T_ADD;
589 case '-':
590 return the_token = T_SUB;
591 case '*':
592 return the_token = T_MUL;
593 case '/':
594 return the_token = T_DIV;
595 case ',':
596 return the_token = T_COMMA;
597 case '#':
598 return the_token = T_IMMED;
599 case 'x':
600 return the_token = T_X;
601 case 'y':
602 return the_token = T_Y;
603 case 'p':
604 if (get_char() == 'c')
605 return the_token = T_PC;
606 else {
607 error("Unrecognized token");
608 return the_token = T_NULL;
609 }
610 case 's':
611 if (get_char() == 'p')
612 return the_token = T_SP;
613 else {
614 error("Unrecognized token");
615 return the_token = T_NULL;
616 }
617 case '0': case '1': case '2': case '3': case '4':
618 case '5': case '6': case '7': case '8': case '9':
619 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
620 put_back(c);
621 the_number = get_number();
622 return the_token = T_NUMBER;
623 case '"':
624 return the_token = get_string(the_string);
625 default:
626 error("Unrecognized token");
627 return the_token = T_NULL;
628 }
629 }
630
631 static enum Token get_reg_token(void)
632 {
633 char c;
634
635 // Skip spaces
636 while ((c = get_char()) == ' ') ;
637
638 switch (c) {
639 case '\n':
640 return the_token = T_END;
641 case 'a':
642 return the_token = T_A;
643 case 'd':
644 if (get_char() == 'r')
645 return the_token = T_DR;
646 else {
647 error("Unrecognized token");
648 return the_token = T_NULL;
649 }
650 case 'p':
651 if ((c = get_char()) == 'c')
652 return the_token = T_PC;
653 else if (c == 'r')
654 return the_token = T_PR;
655 else {
656 error("Unrecognized token");
657 return the_token = T_NULL;
658 }
659 case 's':
660 if (get_char() == 'p')
661 return the_token = T_SP;
662 else {
663 error("Unrecognized token");
664 return the_token = T_NULL;
665 }
666 case 'x':
667 return the_token = T_X;
668 case 'y':
669 return the_token = T_Y;
670 default:
671 error("Unrecognized token");
672 return the_token = T_NULL;
673 }
674 }
675
676 static uint16 get_number(void)
677 {
678 char c;
679 uint16 i = 0;
680
681 while (((c = get_char()) >= '0') && (c <= '9') || (c >= 'a') && (c <= 'f'))
682 if (c < 'a')
683 i = (i << 4) + (c - '0');
684 else
685 i = (i << 4) + (c - 'a' + 10);
686
687 put_back(c);
688 return i;
689 }
690
691 static enum Token get_string(char *str)
692 {
693 char c;
694
695 while ((c = get_char()) != '\n') {
696 if (c == '"') {
697 *str = 0;
698 return T_STRING;
699 }
700 *str++ = c;
701 }
702
703 error("Unterminated string");
704 return T_NULL;
705 }
706
707
708 /*
709 * expression = term {(ADD | SUB) term}
710 * true: OK, false: Error
711 */
712
713 static bool expression(uint16 *number)
714 {
715 uint16 accu, trm;
716
717 if (!term(&accu))
718 return false;
719
720 for (;;)
721 switch (the_token) {
722 case T_ADD:
723 get_token();
724 if (!term(&trm))
725 return false;
726 accu += trm;
727 break;
728
729 case T_SUB:
730 get_token();
731 if (!term(&trm))
732 return false;
733 accu -= trm;
734 break;
735
736 default:
737 *number = accu;
738 return true;
739 }
740 }
741
742
743 /*
744 * term = factor {(MUL | DIV) factor}
745 * true: OK, false: Error
746 */
747
748 static bool term(uint16 *number)
749 {
750 uint16 accu, fact;
751
752 if (!factor(&accu))
753 return false;
754
755 for (;;)
756 switch (the_token) {
757 case T_MUL:
758 get_token();
759 if (!factor(&fact))
760 return false;
761 accu *= fact;
762 break;
763
764 case T_DIV:
765 get_token();
766 if (!factor(&fact))
767 return false;
768 if (fact == 0) {
769 error("Division by 0");
770 return false;
771 }
772 accu /= fact;
773 break;
774
775 default:
776 *number = accu;
777 return true;
778 }
779 }
780
781
782 /*
783 * factor = NUMBER | PC | SP | LPAREN expression RPAREN
784 * true: OK, false: Error
785 */
786
787 static bool factor(uint16 *number)
788 {
789 switch (the_token) {
790 case T_NUMBER:
791 *number = the_number;
792 get_token();
793 return true;
794
795 case T_PC:
796 get_token();
797 *number = access_1541 ? R1541.pc : R64.pc;
798 return true;
799
800 case T_SP:
801 get_token();
802 *number = access_1541 ? R1541.sp : R64.sp;
803 return true;
804
805 case T_LPAREN:
806 get_token();
807 if (expression(number))
808 if (the_token == T_RPAREN) {
809 get_token();
810 return true;
811 } else {
812 error("Missing ')'");
813 return false;
814 }
815 else {
816 error("Error in expression");
817 return false;
818 }
819
820 case T_END:
821 error("Required argument missing");
822 return false;
823
824 default:
825 error("'pc', 'sp', '(' or number expected");
826 return false;
827 }
828 }
829
830
831 /*
832 * address_args = [expression] END
833 *
834 * Read start to "address"
835 *
836 * true: OK, false: Error
837 */
838
839 static bool address_args(void)
840 {
841 if (the_token == T_END)
842 return true;
843 else {
844 if (!expression(&address))
845 return false;
846 return the_token == T_END;
847 }
848 }
849
850
851 /*
852 * range_args = [expression] [[COMMA] expression] END
853 *
854 * Read start address to "address", end address to "end_address"
855 *
856 * true: OK, false: Error
857 */
858
859 static bool range_args(int def_range)
860 {
861 end_address = address + def_range;
862
863 if (the_token == T_END)
864 return true;
865 else {
866 if (!expression(&address))
867 return false;
868 end_address = address + def_range;
869 if (the_token == T_END)
870 return true;
871 else {
872 if (the_token == T_COMMA) get_token();
873 if (!expression(&end_address))
874 return false;
875 return the_token == T_END;
876 }
877 }
878 }
879
880
881 /*
882 * instr_args = END
883 * | IMMED NUMBER END
884 * | NUMBER [COMMA (X | Y)] END
885 * | LPAREN NUMBER (RPAREN [COMMA Y] | COMMA X RPAREN) END
886 *
887 * Read arguments of a 6510 instruction, determine address and addressing mode
888 *
889 * true: OK, false: Error
890 */
891
892 static bool instr_args(uint16 *number, char *mode)
893 {
894 switch (the_token) {
895
896 case T_END:
897 *mode = A_IMPL;
898 return true;
899
900 case T_IMMED:
901 get_token();
902 if (the_token == T_NUMBER) {
903 *number = the_number;
904 *mode = A_IMM;
905 get_token();
906 return the_token == T_END;
907 } else {
908 error("Number expected");
909 return false;
910 }
911
912 case T_NUMBER:
913 *number = the_number;
914 get_token();
915 switch (the_token) {
916
917 case T_END:
918 if (*number < 0x100)
919 *mode = A_ZERO;
920 else
921 *mode = A_ABS;
922 return true;
923
924 case T_COMMA:
925 get_token();
926 switch (the_token) {
927
928 case T_X:
929 get_token();
930 if (*number < 0x100)
931 *mode = A_ZEROX;
932 else
933 *mode = A_ABSX;
934 return the_token == T_END;
935
936 case T_Y:
937 get_token();
938 if (*number < 0x100)
939 *mode = A_ZEROY;
940 else
941 *mode = A_ABSY;
942 return the_token == T_END;
943
944 default:
945 error("Illegal index register");
946 return false;
947 }
948
949 default:
950 return false;
951 }
952
953 case T_LPAREN:
954 get_token();
955 if (the_token == T_NUMBER) {
956 *number = the_number;
957 get_token();
958 switch (the_token) {
959
960 case T_RPAREN:
961 get_token();
962 switch (the_token) {
963
964 case T_END:
965 *mode = A_IND;
966 return true;
967
968 case T_COMMA:
969 get_token();
970 if (the_token == T_Y) {
971 *mode = A_INDY;
972 get_token();
973 return the_token == T_END;
974 } else {
975 error("Only 'y' index register allowed");
976 return false;
977 }
978
979 default:
980 error("Illegal characters after ')'");
981 return false;
982 }
983
984 case T_COMMA:
985 get_token();
986 if (the_token == T_X) {
987 get_token();
988 if (the_token == T_RPAREN) {
989 *mode = A_INDX;
990 get_token();
991 return the_token == T_END;
992 } else {
993 error("')' expected");
994 return false;
995 }
996 } else {
997 error("Only 'x' index register allowed");
998 return false;
999 }
1000
1001 default:
1002 error("')' or ',' expected");
1003 return false;
1004 }
1005 } else {
1006 error("Number expected");
1007 return false;
1008 }
1009
1010 default:
1011 error("'(', '#' or number expected");
1012 return false;
1013 }
1014 }
1015
1016
1017 /*
1018 * Display help
1019 * h
1020 */
1021
1022 static void help(void)
1023 {
1024 fprintf(fout, "a [start] Assemble\n"
1025 "b [start] [end] Binary dump\n"
1026 "c start end dest Compare memory\n"
1027 "d [start] [end] Disassemble\n"
1028 "e Show interrupt vectors\n"
1029 "f start end byte Fill memory\n"
1030 "i [start] [end] ASCII/PETSCII dump\n"
1031 "k [config] Show/set C64 memory configuration\n"
1032 "l start \"file\" Load data\n"
1033 "m [start] [end] Memory dump\n"
1034 "n [start] [end] Screen code dump\n"
1035 "o [\"file\"] Redirect output\n"
1036 "p [start] [end] Sprite dump\n"
1037 "r [reg value] Show/set CPU registers\n"
1038 "s start end \"file\" Save data\n"
1039 "t start end dest Transfer memory\n"
1040 "vc1 View CIA 1 state\n"
1041 "vc2 View CIA 2 state\n"
1042 "vf View 1541 state\n"
1043 "vs View SID state\n"
1044 "vv View VIC state\n"
1045 "x Return to Frodo\n"
1046 ": addr {byte} Modify memory\n"
1047 "1541 Switch to 1541\n"
1048 "64 Switch to C64\n"
1049 "? expression Calculate expression\n");
1050 }
1051
1052
1053 /*
1054 * Display/change 6510 registers
1055 * r [reg value]
1056 */
1057
1058 static void registers(void)
1059 {
1060 enum Token the_reg;
1061 uint16 value;
1062
1063 if (the_token != T_END)
1064 switch (the_reg = the_token) {
1065 case T_A:
1066 case T_X:
1067 case T_Y:
1068 case T_PC:
1069 case T_SP:
1070 case T_DR:
1071 case T_PR:
1072 get_token();
1073 if (!expression(&value))
1074 return;
1075
1076 switch (the_reg) {
1077 case T_A:
1078 if (access_1541)
1079 R1541.a = value;
1080 else
1081 R64.a = value;
1082 break;
1083 case T_X:
1084 if (access_1541)
1085 R1541.x = value;
1086 else
1087 R64.x = value;
1088 break;
1089 case T_Y:
1090 if (access_1541)
1091 R1541.y = value;
1092 else
1093 R64.y = value;
1094 break;
1095 case T_PC:
1096 if (access_1541)
1097 R1541.pc = value;
1098 else
1099 R64.pc = value;
1100 break;
1101 case T_SP:
1102 if (access_1541)
1103 R1541.sp = (value & 0xff) | 0x0100;
1104 else
1105 R64.sp = (value & 0xff) | 0x0100;
1106 break;
1107 case T_DR:
1108 if (!access_1541)
1109 R64.ddr = value;
1110 break;
1111 case T_PR:
1112 if (!access_1541)
1113 R64.pr = value;
1114 break;
1115 default:
1116 break;
1117 }
1118 break;
1119
1120 default:
1121 return;
1122 }
1123
1124 display_registers();
1125 }
1126
1127 static void display_registers(void)
1128 {
1129 if (access_1541) {
1130 fprintf(fout, " PC A X Y SP NVDIZC Instruction\n");
1131 fprintf(fout, "%04lx %02lx %02lx %02lx %04lx %c%c%c%c%c%c ",
1132 R1541.pc, R1541.a, R1541.x, R1541.y, R1541.sp,
1133 R1541.p & 0x80 ? '1' : '0', R1541.p & 0x40 ? '1' : '0', R1541.p & 0x08 ? '1' : '0',
1134 R1541.p & 0x04 ? '1' : '0', R1541.p & 0x02 ? '1' : '0', R1541.p & 0x01 ? '1' : '0');
1135 disass_line(R1541.pc, SAMReadByte(R1541.pc), SAMReadByte(R1541.pc+1), SAMReadByte(R1541.pc+2));
1136 } else {
1137 fprintf(fout, " PC A X Y SP DR PR NVDIZC Instruction\n");
1138 fprintf(fout, "%04lx %02lx %02lx %02lx %04lx %02lx %02lx %c%c%c%c%c%c ",
1139 R64.pc, R64.a, R64.x, R64.y, R64.sp, R64.ddr, R64.pr,
1140 R64.p & 0x80 ? '1' : '0', R64.p & 0x40 ? '1' : '0', R64.p & 0x08 ? '1' : '0',
1141 R64.p & 0x04 ? '1' : '0', R64.p & 0x02 ? '1' : '0', R64.p & 0x01 ? '1' : '0');
1142 disass_line(R64.pc, SAMReadByte(R64.pc), SAMReadByte(R64.pc+1), SAMReadByte(R64.pc+2));
1143 }
1144 }
1145
1146
1147 /*
1148 * Memory dump
1149 * m [start] [end]
1150 */
1151
1152 #define MEMDUMP_BPL 16 // Bytes per line
1153
1154 static void memory_dump(void)
1155 {
1156 bool done = false;
1157 short i;
1158 uint8 mem[MEMDUMP_BPL + 2];
1159 uint8 byte;
1160
1161 mem[MEMDUMP_BPL] = 0;
1162
1163 if (!range_args(16 * MEMDUMP_BPL - 1)) // 16 lines unless end address specified
1164 return;
1165
1166 do {
1167 fprintf(fout, "%04lx:", address);
1168 for (i=0; i<MEMDUMP_BPL; i++, address++) {
1169 if (address == end_address) done = true;
1170
1171 fprintf(fout, " %02lx", byte = SAMReadByte(address));
1172 if ((byte >= ' ') && (byte <= '~'))
1173 mem[i] = conv_from_64(byte);
1174 else
1175 mem[i] = '.';
1176 }
1177 fprintf(fout, " '%s'\n", mem);
1178 } while (!done && !aborted());
1179 }
1180
1181
1182 /*
1183 * ASCII dump
1184 * i [start] [end]
1185 */
1186
1187 #define ASCIIDUMP_BPL 64 // Bytes per line
1188
1189 static void ascii_dump(void)
1190 {
1191 bool done = false;
1192 short i;
1193 uint8 mem[ASCIIDUMP_BPL + 2];
1194 uint8 byte;
1195
1196 mem[ASCIIDUMP_BPL] = 0;
1197
1198 if (!range_args(16 * ASCIIDUMP_BPL - 1)) // 16 lines unless end address specified
1199 return;
1200
1201 do {
1202 fprintf(fout, "%04lx:", address);
1203 for (i=0; i<ASCIIDUMP_BPL; i++, address++) {
1204 if (address == end_address) done = true;
1205
1206 byte = SAMReadByte(address);
1207 if ((byte >= ' ') && (byte <= '~'))
1208 mem[i] = conv_from_64(byte);
1209 else
1210 mem[i] = '.';
1211 }
1212 fprintf(fout, " '%s'\n", mem);
1213 } while (!done && !aborted());
1214 }
1215
1216
1217 /*
1218 * Convert PETSCII->ASCII
1219 */
1220
1221 static char conv_from_64(char c)
1222 {
1223 if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
1224 return c ^ 0x20;
1225 else
1226 return c;
1227 }
1228
1229
1230 /*
1231 * Screen code dump
1232 * n [start] [end]
1233 */
1234
1235 #define SCRDUMP_BPL 64 // Bytes per line
1236
1237 static void screen_dump(void)
1238 {
1239 bool done = false;
1240 short i;
1241 uint8 mem[SCRDUMP_BPL + 2];
1242 uint8 byte;
1243
1244 mem[SCRDUMP_BPL] = 0;
1245
1246 if (!range_args(16 * SCRDUMP_BPL - 1)) // 16 Zeilen unless end address specified
1247 return;
1248
1249 do {
1250 fprintf(fout, "%04lx:", address);
1251 for (i=0; i<SCRDUMP_BPL; i++, address++) {
1252 if (address == end_address) done = true;
1253
1254 byte = SAMReadByte(address);
1255 if (byte < 90)
1256 mem[i] = conv_from_scode(byte);
1257 else
1258 mem[i] = '.';
1259 }
1260 fprintf(fout, " '%s'\n", mem);
1261 } while (!done && !aborted());
1262 }
1263
1264
1265 /*
1266 * Convert screen code->ASCII
1267 */
1268
1269 static char conv_from_scode(char c)
1270 {
1271 c &= 0x7f;
1272
1273 if (c <= 31)
1274 return c + 64;
1275 else
1276 if (c >= 64)
1277 return c + 32;
1278 else
1279 return c;
1280 }
1281
1282
1283 /*
1284 * Binary dump
1285 * b [start] [end]
1286 */
1287
1288 static void binary_dump(void)
1289 {
1290 bool done = false;
1291 char bin[10];
1292
1293 bin[8] = 0;
1294
1295 if (!range_args(7)) // 8 lines unless end address specified
1296 return;
1297
1298 do {
1299 if (address == end_address) done = true;
1300
1301 byte_to_bin(SAMReadByte(address), bin);
1302 fprintf(fout, "%04lx: %s\n", address++, bin);
1303 } while (!done && !aborted());
1304 }
1305
1306
1307 /*
1308 * Sprite data dump
1309 * p [start] [end]
1310 */
1311
1312 static void sprite_dump(void)
1313 {
1314 bool done = false;
1315 short i;
1316 char bin[10];
1317
1318 bin[8] = 0;
1319
1320 if (!range_args(21 * 3 - 1)) // 21 lines unless end address specified
1321 return;
1322
1323 do {
1324 fprintf(fout, "%04lx: ", address);
1325 for (i=0; i<3; i++, address++) {
1326 if (address == end_address) done = true;
1327
1328 byte_to_bin(SAMReadByte(address), bin);
1329 fprintf(fout, "%s", bin);
1330 }
1331 fputc('\n', fout);
1332 } while (!done && !aborted());
1333 }
1334
1335
1336 /*
1337 * Convert byte to binary representation
1338 */
1339
1340 static void byte_to_bin(uint8 byte, char *str)
1341 {
1342 short i;
1343
1344 for (i=0; i<8; i++, byte<<=1)
1345 if (byte & 0x80)
1346 str[i] = '#';
1347 else
1348 str[i] = '.';
1349 }
1350
1351
1352 /*
1353 * Disassemble
1354 * d [start] [end]
1355 */
1356
1357 static void disassemble(void)
1358 {
1359 bool done = false;
1360 short i;
1361 uint8 op[3];
1362 uint16 adr;
1363
1364 if (!range_args(31)) // 32 bytes unless end address specified
1365 return;
1366
1367 do {
1368 fprintf(fout, "%04lx:", adr = address);
1369 for (i=0; i<3; i++, adr++) {
1370 if (adr == end_address) done = true;
1371 op[i] = SAMReadByte(adr);
1372 }
1373 address += disass_line(address, op[0], op[1], op[2]);
1374 } while (!done && !aborted());
1375 }
1376
1377
1378 /*
1379 * Disassemble one instruction, return length
1380 */
1381
1382 static int disass_line(uint16 adr, uint8 op, uint8 lo, uint8 hi)
1383 {
1384 char mode = adr_mode[op], mnem = mnemonic[op];
1385
1386 // Display instruction bytes in hex
1387 switch (adr_length[mode]) {
1388 case 1:
1389 fprintf(fout, " %02lx ", op);
1390 break;
1391
1392 case 2:
1393 fprintf(fout, " %02lx %02lx ", op, lo);
1394 break;
1395
1396 case 3:
1397 fprintf(fout, " %02lx %02lx %02lx ", op, lo, hi);
1398 break;
1399 }
1400
1401 // Tag undocumented opcodes with an asterisk
1402 if (mnem > M_ILLEGAL)
1403 fputc('*', fout);
1404 else
1405 fputc(' ', fout);
1406
1407 // Print mnemonic
1408 fprintf(fout, "%c%c%c ", mnem_1[mnem], mnem_2[mnem], mnem_3[mnem]);
1409
1410 // Pring argument
1411 switch (mode) {
1412 case A_IMPL:
1413 break;
1414
1415 case A_ACCU:
1416 fprintf(fout, "a");
1417 break;
1418
1419 case A_IMM:
1420 fprintf(fout, "#%02lx", lo);
1421 break;
1422
1423 case A_REL:
1424 fprintf(fout, "%04lx", ((adr + 2) + (int8)lo) & 0xffff);
1425 break;
1426
1427 case A_ZERO:
1428 fprintf(fout, "%02lx", lo);
1429 break;
1430
1431 case A_ZEROX:
1432 fprintf(fout, "%02lx,x", lo);
1433 break;
1434
1435 case A_ZEROY:
1436 fprintf(fout, "%02lx,y", lo);
1437 break;
1438
1439 case A_ABS:
1440 fprintf(fout, "%04lx", (hi << 8) | lo);
1441 break;
1442
1443 case A_ABSX:
1444 fprintf(fout, "%04lx,x", (hi << 8) | lo);
1445 break;
1446
1447 case A_ABSY:
1448 fprintf(fout, "%04lx,y", (hi << 8) | lo);
1449 break;
1450
1451 case A_IND:
1452 fprintf(fout, "(%04lx)", (hi << 8) | lo);
1453 break;
1454
1455 case A_INDX:
1456 fprintf(fout, "(%02lx,x)", lo);
1457 break;
1458
1459 case A_INDY:
1460 fprintf(fout, "(%02lx),y", lo);
1461 break;
1462 }
1463
1464 fputc('\n', fout);
1465 return adr_length[mode];
1466 }
1467
1468
1469 /*
1470 * Assemble
1471 * a [start]
1472 */
1473
1474 static void assemble(void)
1475 {
1476 bool done = false;
1477 char c1, c2, c3;
1478 char mnem, mode;
1479 uint8 opcode;
1480 uint16 arg;
1481 int16 rel;
1482
1483 // Read parameters
1484 if (!address_args())
1485 return;
1486
1487 do {
1488 fprintf(fout, "%04lx> ", address);
1489 fflush(ferr);
1490 read_line();
1491
1492 c1 = get_char();
1493 c2 = get_char();
1494 c3 = get_char();
1495
1496 if (c1 != '\n') {
1497
1498 if ((mnem = find_mnemonic(c1, c2, c3)) != M_ILLEGAL) {
1499
1500 get_token();
1501 if (instr_args(&arg, &mode)) {
1502
1503 // Convert A_IMPL -> A_ACCU if necessary
1504 if ((mode == A_IMPL) && find_opcode(mnem, A_ACCU, &opcode))
1505 mode = A_ACCU;
1506
1507 // Handle relative addressing seperately
1508 if (((mode == A_ABS) || (mode == A_ZERO)) && find_opcode(mnem, A_REL, &opcode)) {
1509 mode = A_REL;
1510 rel = arg - (address + 2) & 0xffff;
1511 if ((rel < -128) || (rel > 127)) {
1512 error("Branch too long");
1513 continue;
1514 } else
1515 arg = rel & 0xff;
1516 }
1517
1518 if (find_opcode(mnem, mode, &opcode)) {
1519
1520 // Print disassembled line
1521 fprintf(fout, "\v%04lx:", address);
1522 disass_line(address, opcode, arg & 0xff, arg >> 8);
1523
1524 switch (adr_length[mode]) {
1525 case 1:
1526 SAMWriteByte(address++, opcode);
1527 break;
1528
1529 case 2:
1530 SAMWriteByte(address++, opcode);
1531 SAMWriteByte(address++, arg);
1532 break;
1533
1534 case 3:
1535 SAMWriteByte(address++, opcode);
1536 SAMWriteByte(address++, arg & 0xff);
1537 SAMWriteByte(address++, arg >> 8);
1538 break;
1539
1540 default:
1541 error("Internal error");
1542 break;
1543 }
1544
1545 } else
1546 error("Addressing mode not supported by instruction");
1547
1548 } else
1549 error("Unrecognized addressing mode");
1550
1551 } else
1552 error("Unknown instruction");
1553
1554 } else // Input is terminated with a blank line
1555 done = true;
1556 } while (!done);
1557 }
1558
1559
1560 /*
1561 * Find mnemonic code to three letters
1562 * M_ILLEGAL: No matching mnemonic found
1563 */
1564
1565 static char find_mnemonic(char op1, char op2, char op3)
1566 {
1567 int i;
1568
1569 for (i=0; i<M_MAXIMUM; i++)
1570 if ((mnem_1[i] == op1) && (mnem_2[i] == op2) && (mnem_3[i] == op3))
1571 return i;
1572
1573 return M_ILLEGAL;
1574 }
1575
1576
1577 /*
1578 * Determine opcode of an instruction given mnemonic and addressing mode
1579 * true: OK, false: Mnemonic can't have specified addressing mode
1580 */
1581
1582 static bool find_opcode(char mnem, char mode, uint8 *opcode)
1583 {
1584 int i;
1585
1586 for (i=0; i<256; i++)
1587 if ((mnemonic[i] == mnem) && (adr_mode[i] == mode)) {
1588 *opcode = i;
1589 return true;
1590 }
1591
1592 return false;
1593 }
1594
1595
1596 /*
1597 * Show/set memory configuration
1598 * k [config]
1599 */
1600
1601 static void mem_config(void)
1602 {
1603 uint16 con;
1604
1605 if (the_token != T_END)
1606 if (!expression(&con))
1607 return;
1608 else
1609 TheCPU->ExtConfig = con;
1610 else
1611 con = TheCPU->ExtConfig;
1612
1613 fprintf(fout, "Configuration: %ld\n", con & 7);
1614 fprintf(fout, "A000-BFFF: %s\n", (con & 3) == 3 ? "Basic" : "RAM");
1615 fprintf(fout, "D000-DFFF: %s\n", (con & 3) ? ((con & 4) ? "I/O" : "Char") : "RAM");
1616 fprintf(fout, "E000-FFFF: %s\n", (con & 2) ? "Kernal" : "RAM");
1617 }
1618
1619
1620 /*
1621 * Fill
1622 * f start end byte
1623 */
1624
1625 static void fill(void)
1626 {
1627 bool done = false;
1628 uint16 adr, end_adr, value;
1629
1630 if (!expression(&adr))
1631 return;
1632 if (!expression(&end_adr))
1633 return;
1634 if (!expression(&value))
1635 return;
1636
1637 do {
1638 if (adr == end_adr) done = true;
1639
1640 SAMWriteByte(adr++, value);
1641 } while (!done);
1642 }
1643
1644
1645 /*
1646 * Compare
1647 * c start end dest
1648 */
1649
1650 static void compare(void)
1651 {
1652 bool done = false;
1653 uint16 adr, end_adr, dest;
1654 int num = 0;
1655
1656 if (!expression(&adr))
1657 return;
1658 if (!expression(&end_adr))
1659 return;
1660 if (!expression(&dest))
1661 return;
1662
1663 do {
1664 if (adr == end_adr) done = true;
1665
1666 if (SAMReadByte(adr) != SAMReadByte(dest)) {
1667 fprintf(fout, "%04lx ", adr);
1668 num++;
1669 if (!(num & 7))
1670 fputc('\n', fout);
1671 }
1672 adr++; dest++;
1673 } while (!done && !aborted());
1674
1675 if (num & 7)
1676 fputc('\n', fout);
1677 fprintf(fout, "%ld byte(s) different\n", num);
1678 }
1679
1680
1681 /*
1682 * Transfer memory
1683 * t start end dest
1684 */
1685
1686 static void transfer(void)
1687 {
1688 bool done = false;
1689 uint16 adr, end_adr, dest;
1690
1691 if (!expression(&adr))
1692 return;
1693 if (!expression(&end_adr))
1694 return;
1695 if (!expression(&dest))
1696 return;
1697
1698 if (dest < adr)
1699 do {
1700 if (adr == end_adr) done = true;
1701 SAMWriteByte(dest++, SAMReadByte(adr++));
1702 } while (!done);
1703 else {
1704 dest += end_adr - adr;
1705 do {
1706 if (adr == end_adr) done = true;
1707 SAMWriteByte(dest--, SAMReadByte(end_adr--));
1708 } while (!done);
1709 }
1710 }
1711
1712
1713 /*
1714 * Change memory
1715 * : addr {byte}
1716 */
1717
1718 static void modify(void)
1719 {
1720 uint16 adr, val;
1721
1722 if (!expression(&adr))
1723 return;
1724
1725 while (the_token != T_END)
1726 if (expression(&val))
1727 SAMWriteByte(adr++, val);
1728 else
1729 return;
1730 }
1731
1732
1733 /*
1734 * Compute and display expression
1735 * ? expression
1736 */
1737
1738 static void print_expr(void)
1739 {
1740 uint16 val;
1741
1742 if (!expression(&val))
1743 return;
1744
1745 fprintf(fout, "Hex: %04lx\nDec: %lu\n", val, val);
1746 }
1747
1748
1749 /*
1750 * Redirect output
1751 * o [file]
1752 */
1753
1754 static void redir_output(void)
1755 {
1756 // Close old file
1757 if (fout != ferr) {
1758 fclose(fout);
1759 fout = ferr;
1760 return;
1761 }
1762
1763 // No argument given?
1764 if (the_token == T_END)
1765 return;
1766
1767 // Otherwise open file
1768 if (the_token == T_STRING) {
1769 if (!(fout = fopen(the_string, "w")))
1770 error("Unable to open file");
1771 } else
1772 error("'\"' around file name expected");
1773 }
1774
1775
1776 /*
1777 * Display interrupt vectors
1778 */
1779
1780 static void int_vectors(void)
1781 {
1782 fprintf(fout, " IRQ BRK NMI\n");
1783 fprintf(fout, "%d : %04lx %04lx %04lx\n",
1784 access_1541 ? 6502 : 6510,
1785 SAMReadByte(0xffff) << 8 | SAMReadByte(0xfffe),
1786 SAMReadByte(0xffff) << 8 | SAMReadByte(0xfffe),
1787 SAMReadByte(0xfffb) << 8 | SAMReadByte(0xfffa));
1788
1789 if (!access_1541 && TheCPU->ExtConfig & 2)
1790 fprintf(fout, "Kernal: %04lx %04lx %04lx\n",
1791 SAMReadByte(0x0315) << 8 | SAMReadByte(0x0314),
1792 SAMReadByte(0x0317) << 8 | SAMReadByte(0x0316),
1793 SAMReadByte(0x0319) << 8 | SAMReadByte(0x0318));
1794 }
1795
1796
1797 /*
1798 * Display state of custom chips
1799 */
1800
1801 static void view_state(void)
1802 {
1803 switch (get_char()) {
1804 case 'c': // CIA
1805 view_cia_state();
1806 break;
1807
1808 case 's': // SID
1809 view_sid_state();
1810 break;
1811
1812 case 'v': // VIC
1813 view_vic_state();
1814 break;
1815
1816 case 'f': // Floppy
1817 view_1541_state();
1818 break;
1819
1820 default:
1821 error("Unknown command");
1822 break;
1823 }
1824 }
1825
1826 static void view_cia_state(void)
1827 {
1828 MOS6526State cs;
1829
1830 switch (get_char()) {
1831 case '1':
1832 TheCIA1->GetState(&cs);
1833 break;
1834 case '2':
1835 TheCIA2->GetState(&cs);
1836 break;
1837 default:
1838 error("Unknown command");
1839 return;
1840 }
1841
1842 fprintf(fout, "Timer A : %s\n", cs.cra & 1 ? "On" : "Off");
1843 fprintf(fout, " Counter : %04lx Latch: %04lx\n", (cs.ta_hi << 8) | cs.ta_lo, cs.latcha);
1844 fprintf(fout, " Run mode: %s\n", cs.cra & 8 ? "One-shot" : "Continuous");
1845 fprintf(fout, " Input : %s\n", cs.cra & 0x20 ? "CNT" : "Phi2");
1846 fprintf(fout, " Output : ");
1847 if (cs.cra & 2)
1848 if (cs.cra & 4)
1849 fprintf(fout, "PB6 Toggle\n\n");
1850 else
1851 fprintf(fout, "PB6 Pulse\n\n");
1852 else
1853 fprintf(fout, "None\n\n");
1854
1855 fprintf(fout, "Timer B : %s\n", cs.crb & 1 ? "On" : "Off");
1856 fprintf(fout, " Counter : %04lx Latch: %04lx\n", (cs.tb_hi << 8) | cs.tb_lo, cs.latchb);
1857 fprintf(fout, " Run mode: %s\n", cs.crb & 8 ? "One-shot" : "Continuous");
1858 fprintf(fout, " Input : ");
1859 if (cs.crb & 0x40)
1860 if (cs.crb & 0x20)
1861 fprintf(fout, "Timer A underflow (CNT high)\n");
1862 else
1863 fprintf(fout, "Timer A underflow\n");
1864 else
1865 if (cs.crb & 0x20)
1866 fprintf(fout, "CNT\n");
1867 else
1868 fprintf(fout, "Phi2\n");
1869 fprintf(fout, " Output : ");
1870 if (cs.crb & 2)
1871 if (cs.crb & 4)
1872 fprintf(fout, "PB7 Toggle\n\n");
1873 else
1874 fprintf(fout, "PB7 Pulse\n\n");
1875 else
1876 fprintf(fout, "None\n\n");
1877
1878 fprintf(fout, "TOD : %lx%lx:%lx%lx:%lx%lx.%lx %s\n",
1879 (cs.tod_hr >> 4) & 1, cs.tod_hr & 0x0f,
1880 (cs.tod_min >> 4) & 7, cs.tod_min & 0x0f,
1881 (cs.tod_sec >> 4) & 7, cs.tod_sec & 0x0f,
1882 cs.tod_10ths & 0x0f, cs.tod_hr & 0x80 ? "PM" : "AM");
1883 fprintf(fout, "Alarm : %lx%lx:%lx%lx:%lx%lx.%lx %s\n",
1884 (cs.alm_hr >> 4) & 1, cs.alm_hr & 0x0f,
1885 (cs.alm_min >> 4) & 7, cs.alm_min & 0x0f,
1886 (cs.alm_sec >> 4) & 7, cs.alm_sec & 0x0f,
1887 cs.alm_10ths & 0x0f, cs.alm_hr & 0x80 ? "PM" : "AM");
1888 fprintf(fout, "TOD input : %s\n", cs.cra & 0x80 ? "50Hz" : "60Hz");
1889 fprintf(fout, "Write to : %s registers\n\n", cs.crb & 0x80 ? "Alarm" : "TOD");
1890
1891 fprintf(fout, "Serial data : %02lx\n", cs.sdr);
1892 fprintf(fout, "Serial mode : %s\n\n", cs.cra & 0x40 ? "Output" : "Input");
1893
1894 fprintf(fout, "Pending int.: ");
1895 dump_cia_ints(cs.int_data);
1896 fprintf(fout, "Enabled int.: ");
1897 dump_cia_ints(cs.int_mask);
1898 }
1899
1900 static void dump_cia_ints(uint8 i)
1901 {
1902 if (i & 0x1f) {
1903 if (i & 1) fprintf(fout, "TA ");
1904 if (i & 2) fprintf(fout, "TB ");
1905 if (i & 4) fprintf(fout, "Alarm ");
1906 if (i & 8) fprintf(fout, "Serial ");
1907 if (i & 0x10) fprintf(fout, "Flag");
1908 } else
1909 fprintf(fout, "None");
1910 fputc('\n', fout);
1911 }
1912
1913 static void view_sid_state(void)
1914 {
1915 MOS6581State ss;
1916
1917 TheSID->GetState(&ss);
1918
1919 fprintf(fout, "Voice 1\n");
1920 fprintf(fout, " Frequency : %04lx\n", (ss.freq_hi_1 << 8) | ss.freq_lo_1);
1921 fprintf(fout, " Pulse Width: %04lx\n", ((ss.pw_hi_1 & 0x0f) << 8) | ss.pw_lo_1);
1922 fprintf(fout, " Env. (ADSR): %lx %lx %lx %lx\n", ss.AD_1 >> 4, ss.AD_1 & 0x0f, ss.SR_1 >> 4, ss.SR_1 & 0x0f);
1923 fprintf(fout, " Waveform : ");
1924 dump_sid_waveform(ss.ctrl_1);
1925 fprintf(fout, " Gate : %s Ring mod.: %s\n", ss.ctrl_1 & 0x01 ? "On " : "Off", ss.ctrl_1 & 0x04 ? "On" : "Off");
1926 fprintf(fout, " Test bit : %s Synchron.: %s\n", ss.ctrl_1 & 0x08 ? "On " : "Off", ss.ctrl_1 & 0x02 ? "On" : "Off");
1927 fprintf(fout, " Filter : %s\n", ss.res_filt & 0x01 ? "On" : "Off");
1928
1929 fprintf(fout, "\nVoice 2\n");
1930 fprintf(fout, " Frequency : %04lx\n", (ss.freq_hi_2 << 8) | ss.freq_lo_2);
1931 fprintf(fout, " Pulse Width: %04lx\n", ((ss.pw_hi_2 & 0x0f) << 8) | ss.pw_lo_2);
1932 fprintf(fout, " Env. (ADSR): %lx %lx %lx %lx\n", ss.AD_2 >> 4, ss.AD_2 & 0x0f, ss.SR_2 >> 4, ss.SR_2 & 0x0f);
1933 fprintf(fout, " Waveform : ");
1934 dump_sid_waveform(ss.ctrl_2);
1935 fprintf(fout, " Gate : %s Ring mod.: %s\n", ss.ctrl_2 & 0x01 ? "On " : "Off", ss.ctrl_2 & 0x04 ? "On" : "Off");
1936 fprintf(fout, " Test bit : %s Synchron.: %s\n", ss.ctrl_2 & 0x08 ? "On " : "Off", ss.ctrl_2 & 0x02 ? "On" : "Off");
1937 fprintf(fout, " Filter : %s\n", ss.res_filt & 0x02 ? "On" : "Off");
1938
1939 fprintf(fout, "\nVoice 3\n");
1940 fprintf(fout, " Frequency : %04lx\n", (ss.freq_hi_3 << 8) | ss.freq_lo_3);
1941 fprintf(fout, " Pulse Width: %04lx\n", ((ss.pw_hi_3 & 0x0f) << 8) | ss.pw_lo_3);
1942 fprintf(fout, " Env. (ADSR): %lx %lx %lx %lx\n", ss.AD_3 >> 4, ss.AD_3 & 0x0f, ss.SR_3 >> 4, ss.SR_3 & 0x0f);
1943 fprintf(fout, " Waveform : ");
1944 dump_sid_waveform(ss.ctrl_3);
1945 fprintf(fout, " Gate : %s Ring mod.: %s\n", ss.ctrl_3 & 0x01 ? "On " : "Off", ss.ctrl_3 & 0x04 ? "On" : "Off");
1946 fprintf(fout, " Test bit : %s Synchron.: %s\n", ss.ctrl_3 & 0x08 ? "On " : "Off", ss.ctrl_3 & 0x02 ? "On" : "Off");
1947 fprintf(fout, " Filter : %s Mute : %s\n", ss.res_filt & 0x04 ? "On" : "Off", ss.mode_vol & 0x80 ? "Yes" : "No");
1948
1949 fprintf(fout, "\nFilters/Volume\n");
1950 fprintf(fout, " Frequency: %04lx\n", (ss.fc_hi << 3) | (ss.fc_lo & 0x07));
1951 fprintf(fout, " Resonance: %lx\n", ss.res_filt >> 4);
1952 fprintf(fout, " Mode : ");
1953 if (ss.mode_vol & 0x70) {
1954 if (ss.mode_vol & 0x10) fprintf(fout, "Low-pass ");
1955 if (ss.mode_vol & 0x20) fprintf(fout, "Band-pass ");
1956 if (ss.mode_vol & 0x40) fprintf(fout, "High-pass");
1957 } else
1958 fprintf(fout, "None");
1959 fprintf(fout, "\n Volume : %lx\n", ss.mode_vol & 0x0f);
1960 }
1961
1962 static void dump_sid_waveform(uint8 wave)
1963 {
1964 if (wave & 0xf0) {
1965 if (wave & 0x10) fprintf(fout, "Triangle ");
1966 if (wave & 0x20) fprintf(fout, "Sawtooth ");
1967 if (wave & 0x40) fprintf(fout, "Rectangle ");
1968 if (wave & 0x80) fprintf(fout, "Noise");
1969 } else
1970 fprintf(fout, "None");
1971 fputc('\n', fout);
1972 }
1973
1974 static void view_vic_state(void)
1975 {
1976 MOS6569State vs;
1977 short i;
1978
1979 TheVIC->GetState(&vs);
1980
1981 fprintf(fout, "Raster line : %04lx\n", vs.raster | ((vs.ctrl1 & 0x80) << 1));
1982 fprintf(fout, "IRQ raster line : %04lx\n\n", vs.irq_raster);
1983
1984 fprintf(fout, "X scroll : %ld\n", vs.ctrl2 & 7);
1985 fprintf(fout, "Y scroll : %ld\n", vs.ctrl1 & 7);
1986 fprintf(fout, "Horizontal border : %ld columns\n", vs.ctrl2 & 8 ? 40 : 38);
1987 fprintf(fout, "Vertical border : %ld rows\n\n", vs.ctrl1 & 8 ? 25 : 24);
1988
1989 fprintf(fout, "Display mode : ");
1990 switch (((vs.ctrl1 >> 4) & 6) | ((vs.ctrl2 >> 4) & 1)) {
1991 case 0:
1992 fprintf(fout, "Standard text\n");
1993 break;
1994 case 1:
1995 fprintf(fout, "Multicolor text\n");
1996 break;
1997 case 2:
1998 fprintf(fout, "Standard bitmap\n");
1999 break;
2000 case 3:
2001 fprintf(fout, "Multicolor bitmap\n");
2002 break;
2003 case 4:
2004 fprintf(fout, "ECM text\n");
2005 break;
2006 case 5:
2007 fprintf(fout, "Invalid text (ECM+MCM)\n");
2008 break;
2009 case 6:
2010 fprintf(fout, "Invalid bitmap (ECM+BMM)\n");
2011 break;
2012 case 7:
2013 fprintf(fout, "Invalid bitmap (ECM+BMM+ECM)\n");
2014 break;
2015 }
2016 fprintf(fout, "Sequencer state : %s\n", vs.display_state ? "Display" : "Idle");
2017 fprintf(fout, "Bad line state : %s\n", vs.bad_line ? "Yes" : "No");
2018 fprintf(fout, "Bad lines enabled : %s\n", vs.bad_line_enable ? "Yes" : "No");
2019 fprintf(fout, "Video counter : %04lx\n", vs.vc);
2020 fprintf(fout, "Video counter base: %04lx\n", vs.vc_base);
2021 fprintf(fout, "Row counter : %ld\n\n", vs.rc);
2022
2023 fprintf(fout, "VIC bank : %04lx-%04lx\n", vs.bank_base, vs.bank_base + 0x3fff);
2024 fprintf(fout, "Video matrix base : %04lx\n", vs.matrix_base);
2025 fprintf(fout, "Character base : %04lx\n", vs.char_base);
2026 fprintf(fout, "Bitmap base : %04lx\n\n", vs.bitmap_base);
2027
2028 fprintf(fout, " Spr.0 Spr.1 Spr.2 Spr.3 Spr.4 Spr.5 Spr.6 Spr.7\n");
2029 fprintf(fout, "Enabled: "); dump_spr_flags(vs.me);
2030 fprintf(fout, "Data : %04lx %04lx %04lx %04lx %04lx %04lx %04lx %04lx\n",
2031 vs.sprite_base[0], vs.sprite_base[1], vs.sprite_base[2], vs.sprite_base[3],
2032 vs.sprite_base[4], vs.sprite_base[5], vs.sprite_base[6], vs.sprite_base[7]);
2033 fprintf(fout, "MC : %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx\n",
2034 vs.mc[0], vs.mc[1], vs.mc[2], vs.mc[3], vs.mc[4], vs.mc[5], vs.mc[6], vs.mc[7]);
2035
2036 fprintf(fout, "Mode : ");
2037 for (i=0; i<8; i++)
2038 if (vs.mmc & (1<<i))
2039 fprintf(fout, "Multi ");
2040 else
2041 fprintf(fout, "Std. ");
2042
2043 fprintf(fout, "\nX-Exp. : "); dump_spr_flags(vs.mxe);
2044 fprintf(fout, "Y-Exp. : "); dump_spr_flags(vs.mye);
2045
2046 fprintf(fout, "Prio. : ");
2047 for (i=0; i<8; i++)
2048 if (vs.mdp & (1<<i))
2049 fprintf(fout, "Back ");
2050 else
2051 fprintf(fout, "Fore ");
2052
2053 fprintf(fout, "\nSS Coll: "); dump_spr_flags(vs.mm);
2054 fprintf(fout, "SD Coll: "); dump_spr_flags(vs.md);
2055
2056 fprintf(fout, "\nPending interrupts: ");
2057 dump_vic_ints(vs.irq_flag);
2058 fprintf(fout, "Enabled interrupts: ");
2059 dump_vic_ints(vs.irq_mask);
2060 }
2061
2062 static void dump_spr_flags(uint8 f)
2063 {
2064 short i;
2065
2066 for (i=0; i<8; i++)
2067 if (f & (1<<i))
2068 fprintf(fout, "Yes ");
2069 else
2070 fprintf(fout, "No ");
2071
2072 fputc('\n', fout);
2073 }
2074
2075 static void dump_vic_ints(uint8 i)
2076 {
2077 if (i & 0x1f) {
2078 if (i & 1) fprintf(fout, "Raster ");
2079 if (i & 2) fprintf(fout, "Spr-Data ");
2080 if (i & 4) fprintf(fout, "Spr-Spr ");
2081 if (i & 8) fprintf(fout, "Lightpen");
2082 } else
2083 fprintf(fout, "None");
2084 fputc('\n', fout);
2085 }
2086
2087 static void view_1541_state(void)
2088 {
2089 fprintf(fout, "VIA 1:\n");
2090 fprintf(fout, " Timer 1 Counter: %04x Latch: %04x\n", R1541.via1_t1c, R1541.via1_t1l);
2091 fprintf(fout, " Timer 2 Counter: %04x Latch: %04x\n", R1541.via1_t2c, R1541.via1_t2l);
2092 fprintf(fout, " ACR: %02x\n", R1541.via1_acr);
2093 fprintf(fout, " PCR: %02x\n", R1541.via1_pcr);
2094 fprintf(fout, " Pending interrupts: ");
2095 dump_via_ints(R1541.via1_ifr);
2096 fprintf(fout, " Enabled interrupts: ");
2097 dump_via_ints(R1541.via1_ier);
2098
2099 fprintf(fout, "\nVIA 2:\n");
2100 fprintf(fout, " Timer 1 Counter: %04x Latch: %04x\n", R1541.via2_t1c, R1541.via2_t1l);
2101 fprintf(fout, " Timer 2 Counter: %04x Latch: %04x\n", R1541.via2_t2c, R1541.via2_t2l);
2102 fprintf(fout, " ACR: %02x\n", R1541.via2_acr);
2103 fprintf(fout, " PCR: %02x\n", R1541.via2_pcr);
2104 fprintf(fout, " Pending interrupts: ");
2105 dump_via_ints(R1541.via2_ifr);
2106 fprintf(fout, " Enabled interrupts: ");
2107 dump_via_ints(R1541.via2_ier);
2108 }
2109
2110 static void dump_via_ints(uint8 i)
2111 {
2112 if (i & 0x7f) {
2113 if (i & 0x40) fprintf(fout, "T1 ");
2114 if (i & 0x20) fprintf(fout, "T2 ");
2115 if (i & 2) fprintf(fout, "CA1 ");
2116 if (i & 1) fprintf(fout, "CA2 ");
2117 if (i & 0x10) fprintf(fout, "CB1 ");
2118 if (i & 8) fprintf(fout, "CB2 ");
2119 if (i & 4) fprintf(fout, "Serial ");
2120 } else
2121 fprintf(fout, "None");
2122 fputc('\n', fout);
2123 }
2124
2125
2126 /*
2127 * Load data
2128 * l start "file"
2129 */
2130
2131 static void load_data(void)
2132 {
2133 uint16 adr;
2134 FILE *file;
2135 int fc;
2136
2137 if (!expression(&adr))
2138 return;
2139 if (the_token == T_END) {
2140 error("Missing file name");
2141 return;
2142 }
2143 if (the_token != T_STRING) {
2144 error("'\"' around file name expected");
2145 return;
2146 }
2147
2148 if (!(file = fopen(the_string, "rb")))
2149 error("Unable to open file");
2150 else {
2151 while ((fc = fgetc(file)) != EOF)
2152 SAMWriteByte(adr++, fc);
2153 fclose(file);
2154 }
2155 }
2156
2157
2158 /*
2159 * Save data
2160 * s start end "file"
2161 */
2162
2163 static void save_data(void)
2164 {
2165 bool done = false;
2166 uint16 adr, end_adr;
2167 FILE *file;
2168
2169 if (!expression(&adr))
2170 return;
2171 if (!expression(&end_adr))
2172 return;
2173 if (the_token == T_END) {
2174 error("Missing file name");
2175 return;
2176 }
2177 if (the_token != T_STRING) {
2178 error("'\"' around file name expected");
2179 return;
2180 }
2181
2182 if (!(file = fopen(the_string, "wb")))
2183 error("Unable to create file");
2184 else {
2185 do {
2186 if (adr == end_adr) done = true;
2187
2188 fputc(SAMReadByte(adr++), file);
2189 } while (!done);
2190 fclose(file);
2191 }
2192 }