diff --git a/doc/a2blink.map b/doc/a2blink.map new file mode 100644 index 0000000..72a00d5 Binary files /dev/null and b/doc/a2blink.map differ diff --git a/doc/a2inverse.map b/doc/a2inverse.map new file mode 100644 index 0000000..70ad9ed Binary files /dev/null and b/doc/a2inverse.map differ diff --git a/doc/a2normal.map b/doc/a2normal.map new file mode 100644 index 0000000..b383772 Binary files /dev/null and b/doc/a2normal.map differ diff --git a/doc/c64-1.oph b/doc/c64-1.oph new file mode 100644 index 0000000..04166dd --- /dev/null +++ b/doc/c64-1.oph @@ -0,0 +1,12 @@ +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance 2064 + +.require "kernal.oph" \ No newline at end of file diff --git a/doc/c64-2.oph b/doc/c64-2.oph new file mode 100644 index 0000000..720ef21 --- /dev/null +++ b/doc/c64-2.oph @@ -0,0 +1,40 @@ +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance $0810 + +.require "kernal.oph" + +.data zp +.org $0002 + +.text + +.scope + ; Cache BASIC's zero page at top of available RAM. + ldx #$7E +* lda $01, x + sta $CF81, x + dex + bne - + + jsr _main + + ; Restore BASIC's zero page and return control. + + ldx #$7E +* lda $CF81, x + sta $01, x + dex + bne - + rts + +_main: + ; Program follows... +.scend \ No newline at end of file diff --git a/doc/docbook/cmdref.sgm b/doc/docbook/cmdref.sgm new file mode 100644 index 0000000..5c3d557 --- /dev/null +++ b/doc/docbook/cmdref.sgm @@ -0,0 +1,478 @@ + + Ophis Command Reference +
+ Command Modes + + These mostly follow the MOS Technology 6500 + Microprocessor Family Programming Manual, except + for the Accumulator mode. Accumulator instructions are written + and interpreted identically to Implied mode instructions. + + + Implied: RTS + Accumulator: LSR + Immediate: LDA #$06 + Zero Page: LDA $7C + Zero Page, X: LDA $7C,X + Zero Page, Y: LDA $7C,Y + Absolute: LDA $D020 + Absolute, X: LDA $D000,X + Absolute, Y: LDA $D000,Y + (Zero Page Indirect, X): LDA ($80, X) + (Zero Page Indirect), Y: LDA ($80), Y + (Absolute Indirect): JMP ($A000) + Relative: BNE loop + (Absolute Indirect, X): JMP ($A000, X) — Only available with 65C02 extensions + (Zero Page Indirect): LDX ($80) — Only available with 65C02 extensions + +
+
+ Basic arguments + + Most arguments are just a number or label. The formats for + these are below. + +
+ Numeric types + + Hex: $41 (Prefixed with $) + Decimal: 65 (No markings) + Octal: 0101 (Prefixed with zero) + Binary: %01000001 (Prefixed with %) + Character: 'A (Prefixed with single quote) + +
+
+ Label types + + Normal labels are simply referred to by name. Anonymous + labels may be referenced with strings of - or + signs (the + label - refers to the immediate + previous anonymous label, -- the + one before that, etc., while + + refers to the next anonymous label), and the special + label ^ refers to the program + counter at the start of the current instruction or directive. + + + Normal labels are defined by + prefixing a line with the label name and then a colon + (e.g., label:). Anonymous labels + are defined by prefixing a line with an asterisk + (e.g., *). + + + Temporary labels are only reachable from inside the + innermost enclosing .scope + statement. They are identical to normal labels in every + way, except that they start with an underscore. + +
+
+ String types + + Strings are enclosed in double quotation marks. Backslashed + characters (including backslashes and double quotes) are + treated literally, so the string "The man said, + \"The \\ character is the backslash.\"" produces + the ASCII sequence for The man said, "The \ + character is the backslash." + + + Strings are generally only used as arguments to assembler + directives—usually for filenames + (e.g., .include) but also for string + data (in association with .byte). + + + It is legal, though unusual, to attempt to pass a string to + the other data statements. This will produces a series of + words/dwords where all bytes that aren't least-significant + are zero. Endianness and size will match what the directive + itself indicated. + +
+
+
+ Compound Arguments + + Compound arguments may be built up from simple ones, using the + standard +, -, *, and / operators, which carry the usual + precedence. Also, the unary operators > and <, which + bind more tightly than anything else, provide the high and low + bytes of 16-bit values, respectively. + + + Use brackets [ ] instead of parentheses ( ) when grouping + arithmetic operations, as the parentheses are needed for the + indirect addressing modes. + + + Examples: + + + $D000 evaluates to $D000 + $D000+32 evaluates to $D020 + $D000+$20 also evaluates to $D020 + <$D000+32 evaluates to $20 + >$D000+32 evaluates to $F0 + >[$D000+32] evaluates to $D0 + >$D000-275 evaluates to $CE + +
+
+ Memory Model + + In order to properly compute the locations of labels and the + like, Ophis must keep track of where assembled code will + actually be sitting in memory, and it strives to do this in a + way that is independent both of the target file and of the + target machine. + +
+ Basic PC tracking + + The primary technique Ophis uses is program counter + tracking. As it assembles the code, it keeps + track of a virtual program counter, and uses that to + determine where the labels should go. + + + In the absence of an .org directive, it + assumes a starting PC of zero. .org + is a simple directive, setting the PC to the value + that .org specifies. In the simplest + case, one .org directive appears at the + beginning of the code and sets the location for the rest of + the code, which is one contiguous block. + +
+
+ Basic Segmentation simulation + + However, this isn't always practical. Often one wishes to + have a region of memory reserved for data without actually + mapping that memory to the file. On some systems (typically + cartridge-based systems where ROM and RAM are seperate, and + the target file only specifies the ROM image) this is + mandatory. In order to access these variables symbolically, + it's necessary to put the values into the label lookup + table. + + + It is possible, but inconvenient, to do this + with .alias, assigning a specific + memory location to each variable. This requires careful + coordination through your code, and makes creating reusable + libraries all but impossible. + + + A better approach is to reserve a section at the beginning + or end of your program, put an .org + directive in, then use the .space + directive to divide up the data area. This is still a bit + inconvenient, though, because all variables must be + assigned all at once. What we'd really like is to keep + multiple PC counters, one for data and one for code. + + + The .text + and .data directives do this. Each + has its own PC that starts at zero, and you can switch + between the two at any point without corrupting the other's + counter. In this way each function can have + a .data section (filled + with .space commands) and + a .text section (that contains the + actual code). This lets our library routines be almost + completely self-contained - we can have one source file + that could be .included by multiple + projects without getting in anything's way. + + + However, any given program may have its own ideas about + where data and code go, and it's good to ensure with + a .checkpc at the end of your code + that you haven't accidentally overwritten code with data or + vice versa. If your .data + segment did start at zero, it's + probably wise to make sure you aren't smashing the stack, + too (which is sitting in the region from $0100 to + $01FF). + + + If you write code with no segment-defining statements in + it, the default segment + is text. + + + The data segment is designed only + for organizing labels. As such, errors will be flagged if + you attempt to actually output information into + a data segment. + +
+
+ General Segmentation Simulation + + One text and data segment each is usually sufficient, but + for the cases where it is not, Ophis allows for user-defined + segments. Putting a label + after .text + or .data produces a new segment with + the specified name. + + + Say, for example, that we have access to the RAM at the low + end of the address space, but want to reserve the zero page + for truly critical variables, and use the rest of RAM for + everything else. Let's also assume that this is a 6510 + chip, and locations $00 and $01 are reserved for the I/O + port. We could start our program off with: + + +.data +.org $200 +.data zp +.org $2 +.text +.org $800 + + + And, to be safe, we would probably want to end our code + with checks to make sure we aren't overwriting anything: + + +.data +.checkpc $800 +.data zp +.checkpc $100 + +
+
+
+ Macros + + Assembly language is a powerful tool—however, there are + many tasks that need to be done repeatedly, and with + mind-numbing minor modifications. Ophis includes a facility + for macros to allow this. Ophis macros + are very similar in form to function calls in higher level + languages. + +
+ Defining Macros + + Macros are defined with the .macro + and .macend commands. Here's a + simple one that will clear the screen on a Commodore + 64: + + +.macro clr'screen + lda #147 + jsr $FFD2 +.macend + +
+
+ Invoking Macros + + To invoke a macro, either use + the .invoke command or backquote the + name of the routine. The previous macro may be expanded + out in either of two ways, at any point in the + source: + + .invoke clr'screen + or + `clr'screen + will work equally well. +
+
+ Passing Arguments to Macros + + Macros may take arguments. The arguments to a macro are + all of the word type, though byte values may + be passed and used as bytes as well. The first argument in + an invocation is bound to the label + _1, the second + to _2, and so on. Here's a macro + for storing a 16-bit value into a word pointer: + + +.macro store16 ; `store16 dest, src + lda #<_2 + sta _1 + lda #>_2 + sta _1+1 +.macend + + + Macro arguments behave, for the most part, as if they were + defined by .alias + commands in the calling context. + (They differ in that they will not produce duplicate-label + errors if those names already exist in the calling scope, + and in that they disappear after the call is + completed.) + +
+
+ Features and Restrictions of the Ophis Macro Model + + Unlike most macro systems (which do textual replacement), + Ophis macros evaluate their arguments and bind them into the + symbol table as temporary labels. This produces some + benefits, but it also puts some restrictions on what kinds of + macros may be defined. + + + The primary benefit of this expand-via-binding + discipline is that there are no surprises in the semantics. + The expression _1+1 in the macro above + will always evaluate to one more than the value that was + passed as the first argument, even if that first argument is + some immensely complex expression that an + expand-via-substitution method may accidentally + mangle. + + + The primary disadvantage of the expand-via-binding + discipline is that only fixed numbers of words and bytes + may be passed. A substitution-based system could define a + macro including the line LDA _1 and + accept as arguments both $C000 + (which would put the value of memory location $C000 into + the accumulator) and #$40 (which + would put the immediate value $40 into the accumulator). + If you really need this kind of + behavior, a run a C preprocessor over your Ophis source, + and use #define to your heart's + content. + +
+
+
+ Assembler directives + + Assembler directives are all instructions to the assembler + that are not actual instructions. Ophis's set of directives + follow. + + + .advance address: + Forces the program counter to + be address. Unlike + the .org + directive, .advance outputs zeroes until the + program counter reaches a specified address. Attempting + to .advance to a point behind the current + program counter is an assemble-time error. + .alias label value: The + .alias directive assigns an arbitrary value to a label. This + value may be an arbitrary argument, but cannot reference any + label that has not already been defined (this prevents + recursive label dependencies). + .byte arg [ , arg, ... ]: + Specifies a series of arguments, which are evaluated, and + strings, which are included as raw ASCII data. The final + results of these arguments must be one byte in size. Seperate + constants are seperated by comments. + .checkpc address: Ensures that the + program counter is less than or equal to the address + specified, and emits an assemble-time error if it is not. + This produces no code in the final binary - it is there to + ensure that linking a large amount of data together does not + overstep memory boundaries. + .data [label]: Sets the segment to + the segment name specified and disallows output. If no label + is given, switches to the default data segment. + .incbin filename: Inserts the + contents of the file specified as binary data. Use it to + include graphics information, precompiled code, or other + non-assembler data. + .include filename: Includes the + entirety of the file specified at that point in the program. + Use this to order your final sources. + .org address: Sets the program + counter to the address specified. This does not emit any + code in and of itself, nor does it overwrite anything that + previously existed. If you wish to jump ahead in memory, + use .advance. + .require filename: Includes the entirety + of the file specified at that point in the program. Unlike .include, + however, code included with .require will only be inserted once. + The .require directive is useful for ensuring that certain code libraries + are somewhere in the final binary. They are also very useful for guaranteeing that + macro libraries are available. + .space label size: This + directive is used to organize global variables. It defines the + label specified to be at the current location of the program + counter, and then advances the program counter size + steps ahead. No actual code is produced. This is equivalent + to label: .org ^+size. + .text [label]: Sets the segment to + the segment name specified and allows output. If no label is + given, switches to the default text segment. + .word arg [ , arg, ... ]: + Like .byte, but values are all treated as two-byte + values and stored low-end first (as is the 6502's wont). Use + this to create jump tables (an unadorned label will evaluate + to that label's location) or otherwise store 16-bit + data. + .dword arg [ , arg, ...]: + Like .word, but for 32-bit values. + .wordbe arg [ , arg, ...]: + Like .word, but stores the value in a big-endian format (high byte first). + .dwordbe arg [ , arg, ...]: + Like .dword, but stores the value high byte first. + .scope: Starts a new scope block. Labels + that begin with an underscore are only reachable from within + their innermost enclosing .scope statement. + .scend: Ends a scope block. Makes the + temporary labels defined since the last .scope + statement unreachable, and permits them to be redefined in a + new scope. + .macro name: Begins a macro + definition block. This is a scope block that can be inlined + at arbitrary points with .invoke. Arguments to the + macro will be bound to temporary labels with names like + _1, _2, etc. + .macend: Ends a macro definition + block. + .invoke label [argument [, + argument ...]]: invokes (inlines) the specified + macro, binding the values of the arguments to the ones the + macro definition intends to read. A shorthand for .invoke + is the name of the macro to invoke, backquoted. + + + The following directives are deprecated, added for + compatibility with the old Perl + assembler P65. Use + the -d option to Ophis to enable + them. + + + .ascii: Equivalent to .byte, + which didn't used to be able to handle strings. + .code: Equivalent to .text. + .segment: Equivalent to .text, + from when there was no distinction between .text and + .data segments. + .address: Equivalent to + .word. + .link filename address: Assembles + the file specified as if it began at the address specified. + This is generally for use in top-level files, where there + is not necessarily a one-to-one correspondence between file + position and memory position. This is equivalent to an + .org directive followed by an .include. + With the introduction of the .org directive this one is + less useful (and in most cases, any .org statement + you use will actually be at the top of the .included + file). + +
+ diff --git a/doc/docbook/ophismanual.sgm b/doc/docbook/ophismanual.sgm new file mode 100644 index 0000000..cb324bb --- /dev/null +++ b/doc/docbook/ophismanual.sgm @@ -0,0 +1,29 @@ + + + + + + + + + + +]> + + + Programming with Ophis + MichaelMartin + 2006-7Michael Martin + + &pre1; + &part1; + &part2; + &part3; + &part4; + &part5; + &part6; + &part7; + &samplecode; + &cmdref; + diff --git a/doc/docbook/preface.sgm b/doc/docbook/preface.sgm new file mode 100644 index 0000000..2be1279 --- /dev/null +++ b/doc/docbook/preface.sgm @@ -0,0 +1,74 @@ + + Preface + + + The Ophis project started on a lark back in 2001. My graduate + studies required me to learn Perl and Python, and I'd been playing + around with Commodore 64 emulators in my spare time, so I decided + to learn both languages by writing a simple cross-assembler for + the 6502 chip the C-64 used in both. + + + + The Perl version was quickly abandoned, but the Python one slowly + grew in scope and power over the years, and by 2005 was a very + powerful, flexible macro assembler that saw more use than I'd + expect. In 2007 I finally got around to implementing the last few + features I really wanted and polishing it up for general release. + + + + Part of that process has been formatting the various little + tutorials and references I'd created into a single, unified + document—the one you are now reading. + + +
+ Why <quote>Ophis</quote>? + + It's actually a kind of a horrific pun. See, I was using Python + at the time, and one of the things I had been hoping to do with + the assembler was to produce working Apple II + programs. Ophis is Greek + for snake, and a number of traditions also use it + as the actual name of the serpent in the + Garden of Eden. So, Pythons, snakes, and stories involving + really old Apples all combined to name the assembler. + +
+ +
+ Getting a copy of Ophis + + If you're reading this as part of the Ophis install, you clearly + already have it. If not, as of this writing the homepage for + the Ophis assembler + is . If + this is out-of-date, a Web search on Ophis 6502 + assembler (without the quotation marks) should yield its + page. + + + Ophis is written entirely in Python and packaged using the + distutils. The default installation script on Unix and Mac OS X + systems should put the files where they need to go. If you are + running it locally, you will need to install + the Ophis package somewhere in your Python + package path, and then put the ophis script + somewhere in your path. + + + Windows users that have Python installed can use the same source + distributions that the other operating systems + use; ophis.bat will arrange the environment + variables accordingly and invoke the main script. + + + If you are on Windows and do not have Python installed, a + prepackaged system made with py2exe is also + available. The default Windows installer will use this. In + this case, all you need to do is + have ophis.exe in your path. + +
+ diff --git a/doc/docbook/samplecode.sgm b/doc/docbook/samplecode.sgm new file mode 100644 index 0000000..6d65b07 --- /dev/null +++ b/doc/docbook/samplecode.sgm @@ -0,0 +1,749 @@ + + Example Programs + + This Appendix collects all the programs referred to in the course + of this manual. + +
+ <filename>tutor1.oph</filename> + +.word $0801 +.org $0801 + + .word next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +next: .word 0 ; End of program + +.advance 2064 + + ldx #0 +loop: lda hello, x + beq done + jsr $ffd2 + inx + bne loop +done: rts + +hello: .byte "HELLO, WORLD!", 0 + +
+
+ <filename>tutor2.oph</filename> + +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance 2064 + +.alias chrout $ffd2 + + ldx #0 +* lda hello, x + beq + + jsr chrout + inx + bne - +* rts + +hello: .byte "HELLO, WORLD!", 0 + +
+
+ <filename>c64-1.oph</filename> + +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance 2064 + +.require "kernal.oph" + +
+
+ <filename>kernal.oph</filename> + +; KERNAL routine aliases (C64) + +.alias acptr $ffa5 +.alias chkin $ffc6 +.alias chkout $ffc9 +.alias chrin $ffcf +.alias chrout $ffd2 +.alias ciout $ffa8 +.alias cint $ff81 +.alias clall $ffe7 +.alias close $ffc3 +.alias clrchn $ffcc +.alias getin $ffe4 +.alias iobase $fff3 +.alias ioinit $ff84 +.alias listen $ffb1 +.alias load $ffd5 +.alias membot $ff9c +.alias memtop $ff99 +.alias open $ffc0 +.alias plot $fff0 +.alias ramtas $ff87 +.alias rdtim $ffde +.alias readst $ffb7 +.alias restor $ff8a +.alias save $ffd8 +.alias scnkey $ff9f +.alias screen $ffed +.alias second $ff93 +.alias setlfs $ffba +.alias setmsg $ff90 +.alias setnam $ffbd +.alias settim $ffdb +.alias settmo $ffa2 +.alias stop $ffe1 +.alias talk $ffb4 +.alias tksa $ff96 +.alias udtim $ffea +.alias unlsn $ffae +.alias untlk $ffab +.alias vector $ff8d + +; Character codes for the colors. +.alias color'0 144 +.alias color'1 5 +.alias color'2 28 +.alias color'3 159 +.alias color'4 156 +.alias color'5 30 +.alias color'6 31 +.alias color'7 158 +.alias color'8 129 +.alias color'9 149 +.alias color'10 150 +.alias color'11 151 +.alias color'12 152 +.alias color'13 153 +.alias color'14 154 +.alias color'15 155 + +; ...and reverse video +.alias reverse'on 18 +.alias reverse'off 146 + +; ...and character set +.alias upper'case 142 +.alias lower'case 14 + +
+
+ <filename>tutor3.oph</filename> + +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +
+
+ <filename>tutor4a.oph</filename> + +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + rts + +
+
+ <filename>tutor4b.oph</filename> + +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + lda #lower'case + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "Hello, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "programmer", 0 +target2: .byte "room", 0 +target3: .byte "building", 0 +target4: .byte "neighborhood", 0 +target5: .byte "city", 0 +target6: .byte "nation", 0 +target7: .byte "world", 0 +target8: .byte "Solar System", 0 +target9: .byte "Galaxy", 0 +target10: .byte "Universe", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + rts + +
+
+ <filename>tutor4c.oph</filename> + +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + lda #lower'case + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +.charmap 'A, "abcdefghijklmnopqrstuvwxyz" +.charmap 'a, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + +hello1: .byte "Hello, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "programmer", 0 +target2: .byte "room", 0 +target3: .byte "building", 0 +target4: .byte "neighborhood", 0 +target5: .byte "city", 0 +target6: .byte "nation", 0 +target7: .byte "world", 0 +target8: .byte "Solar System", 0 +target9: .byte "Galaxy", 0 +target10: .byte "Universe", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + rts + +
+
+ <filename>tutor5.oph</filename> + +.include "c64-1.oph" + +.data +.org $C000 +.text + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +.checkpc $A000 +.data +.checkpc $D000 + +
+
+ <filename>tutor6.oph</filename> + +.include "c64-1.oph" + +.data +.org $C000 +.space cache 2 +.text + +.macro print + lda #<_1 + ldx #>_1 + jsr printstr +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + ; Save the zero page locations that PRINTSTR uses. + lda $10 + sta cache + lda $11 + sta cache+1 + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + + ; Restore the zero page values printstr uses. + lda cache + sta $10 + lda cache+1 + sta $11 + + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +printstr: + sta $10 + stx $11 + ldy #$00 +_lp: lda ($10),y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + +.checkpc $A000 +.data +.checkpc $D000 + +
+
+ <filename>c64-2.oph</filename> + +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance $0810 + +.require "kernal.oph" + +.data zp +.org $0002 + +.text + +.scope + ; Cache BASIC's zero page at top of available RAM. + ldx #$7E +* lda $01, x + sta $CF81, x + dex + bne - + + jsr _main + + ; Restore BASIC's zero page and return control. + + ldx #$7E +* lda $CF81, x + sta $01, x + dex + bne - + rts + +_main: + ; Program follows... +.scend + +
+
+ <filename>tutor7.oph</filename> + +.include "c64-2.oph" + +.data +.org $C000 +.text + +.macro print + lda #<_1 + ldx #>_1 + jsr printstr +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +.data zp +.space _ptr 2 +.text +printstr: + sta _ptr + stx _ptr+1 + ldy #$00 +_lp: lda (_ptr),y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + +.checkpc $A000 + +.data +.checkpc $D000 + +.data zp +.checkpc $80 + +
+ diff --git a/doc/docbook/tutor1.sgm b/doc/docbook/tutor1.sgm new file mode 100644 index 0000000..6a754b9 --- /dev/null +++ b/doc/docbook/tutor1.sgm @@ -0,0 +1,315 @@ + + The basics + + + In this first part of the tutorial we will create a + simple Hello World program to run on the Commodore + 64. This will cover: + + + How to make programs run on a Commodore 64 + Writing simple code with labels + Numeric and string data + Invoking the assembler + + + +
+ A note on numeric notation + + + Throughout these tutorials, I will be using a lot of both + decimal and hexadecimal notation. Hex numbers will have a + dollar sign in front of them. Thus, 100 = $64, and $100 = 256. + +
+ +
+ Producing Commodore 64 programs + + + Commodore 64 programs are stored in + the PRG format on disk. Some emulators + (such as CCS64 or VICE) can run PRG + programs directly; others need them to be transferred to + a D64 image first. + + + + The PRG format is ludicrously simple. It + has two bytes of header data: This is a little-endian number + indicating the starting address. The rest of the file is a + single continuous chunk of data loaded into memory, starting at + that address. BASIC memory starts at memory location 2048, and + that's probably where we'll want to start. + + + + Well, not quite. We want our program to be callable from BASIC, + so we should have a BASIC program at the start. We guess the + size of a simple one line BASIC program to be about 16 bytes. + Thus, we start our program at memory location 2064 ($0810), and + the BASIC program looks like this: + + + +10 SYS 2064 + + + + We SAVE this program to a file, then + study it in a debugger. It's 15 bytes long: + + + +1070:0100 01 08 0C 08 0A 00 9E 20-32 30 36 34 00 00 00 + + + + The first two bytes are the memory location: $0801. The rest of + the data breaks down as follows: + + + + BASIC program breakdown + + + + Memory Locations + Value + + + + $0801-$08022-byte pointer to the next line of BASIC code ($080C). + $0803-$08042-byte line number ($000A = 10). + $0805Byte code for the SYS command. + $0806-$080AThe rest of the line, which is just the string 2064. + $080BNull byte, terminating the line. + $080C-$080D2-byte pointer to the next line of BASIC code ($0000 = end of program). + + +
+ + + That's 13 bytes. We started at 2049, so we need 2 more bytes of + filler to make our code actually start at location 2064. These + 17 bytes will give us the file format and the BASIC code we need + to have our machine language program run. + + + + These are just bytes—indistinguishable from any other sort of + data. In Ophis, bytes of data are specified with + the .byte command. We'll also have to tell + Ophis what the program counter should be, so that it knows what + values to assign to our labels. The .org + (origin) command tells Ophis this. Thus, the Ophis code for our + header and linking info is: + + + +.byte $01, $08, $0C, $08, $0A, $00, $9E, $20 +.byte $32, $30, $36, $34, $00, $00, $00, $00 +.byte $00, $00 +.org $0810 + + + + This gets the job done, but it's completely incomprehensible, + and it only uses two directives—not very good for a + tutorial. Here's a more complicated, but much clearer, way of + saying the same thing. + + + +.word $0801 +.org $0801 + + .word next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +next: .word 0 ; End of program + +.advance 2064 + + + + This code has many advantages over the first. + + + It describes better what is actually + happening. The .word directive at the + beginning indicates a 16-bit value stored in the typical + 65xx way (small byte first). This is followed by + an .org statement, so we let the + assembler know right away where everything is supposed to + be. + + Instead of hardcoding in the value $080C, we + instead use a label to identify the location it's pointing + to. Ophis will compute the address + of next and put that value in as data. + We also describe the line number in decimal since BASIC + line numbers generally are in decimal. + Labels are defined by putting their name, then a colon, as + seen in the definition of next. + + + Instead of putting in the hex codes for the string part of + the BASIC code, we included the string directly. Each + character in the string becomes one byte. + + + Instead of adding the buffer ourselves, we + used .advance, which outputs zeros until + the specified address is reached. Attempting + to .advance backwards produces an + assemble-time error. + + + It has comments that explain what the data are for. The + semicolon is the comment marker; everything from a semicolon + to the end of the line is ignored. + + + +
+ +
+ Related commands and options + + + This code includes constants that are both in decimal and in + hex. It is also possible to specify constants in octal, binary, + or with an ASCII character. + + + To specify decimal constants, simply write the number. + To specify hexadecimal constants, put a $ in front. + To specify octal constants, put a 0 (zero) in front. + To specify binary constants, put a % in front. + To specify ASCII constants, put an apostrophe in front. + + + Example: 65 = $41 = 0101 = %1000001 = 'A + + + There are other commands besides .byte + and .word to specify data. In particular, + the .dword command specifies four-byte values + which some applications will find useful. Also, some linking + formats (such as the SID format) have + header data in big-endian (high byte first) format. + The .wordbe and .dwordbe + directives provide a way to specify multibyte constants in + big-endian formats cleanly. + +
+ +
+ Writing the actual code + + + Now that we have our header information, let's actually write + the Hello world program. It's pretty + short—a simple loop that steps through a hardcoded array + until it reaches a 0 or outputs 256 characters. It then returns + control to BASIC with an RTS statement. + + + + Each character in the array is passed as an argument to a + subroutine at memory location $FFD2. This is part of the + Commodore 64's BIOS software, which its development + documentation calls the KERNAL. Location $FFD2 prints out the + character corresponding to the character code in the + accumulator. + + + + ldx #0 +loop: lda hello, x + beq done + jsr $ffd2 + inx + bne loop +done: rts + +hello: .byte "HELLO, WORLD!", 0 + + + + The complete, final source is available in + the file. + +
+
+ Assembling the code + + + The Ophis assembler is a collection of Python modules, + controlled by a master script. On Windows, this should all + have been combined into an executable + file ophis.exe; on other platforms, the + Ophis modules should be in the library and + the ophis script should be in your path. + Typing ophis with no arguments should give a + summary of available command line options. + + + + Ophis Options + + + + Option + Effect + + + + Allows the 6510 undocumented opcodes as listed in the VICE documentation. + Allows opcodes and addressing modes added by the 65C02. + Quiet operation. Only reports errors. + Default operation. Reports files as they are loaded, and gives statistics on the final output. + Verbose operation. Names each assembler pass as it runs. + Debug operation: Dumps the entire IR after each pass. + Full debug operation: Dumps the entire IR and symbol table after each pass. + + +
+ + + The only options Ophis demands are an input file and an output + file. Here's a sample session, assembling the tutorial file + here: + + +localhost$ ophis tutor1.oph tutor1.prg -v 2 +Loading tutor1.oph +Running: Macro definition pass +Running: Macro expansion pass +Running: Label initialization pass +Fixpoint failed, looping back +Running: Label initialization pass +Running: Circularity check pass +Running: Expression checking pass +Running: Easy addressing modes pass +Running: Label Update Pass +Fixpoint failed, looping back +Running: Label Update Pass +Running: Instruction Collapse Pass +Running: Mode Normalization pass +Running: Label Update Pass +Running: Assembler +Assembly complete: 45 bytes output (14 code, 29 data, 2 filler) + + + If your emulator can run PRG files + directly, this file will now run (and + print HELLO, WORLD!) as many + times as you type RUN. Otherwise, use + a D64 management utility to put + the PRG on a D64, then + load and run the file off that. + +
+ diff --git a/doc/docbook/tutor2.sgm b/doc/docbook/tutor2.sgm new file mode 100644 index 0000000..c0128ef --- /dev/null +++ b/doc/docbook/tutor2.sgm @@ -0,0 +1,107 @@ + + Labels and aliases + + Labels are an important part of your code. However, since each + label must normally be unique, this can lead to namespace + pollution, and you'll find yourself going through ever + more contorted constructions to generate unique label names. + Ophis offers two solutions to this: anonymous + labels and temporary labels. This + tutorial will cover both of these facilities, and also introduce + the aliasing mechanism. + + +
+ Temporary labels + + + Temporary labels are the easiest to use. If a label begins with + an underscore, it will only be reachable from inside the + innermost enclosing scope. Scopes begin when + a .scope statement is encountered. This + produces a new, inner scope if there is another scope in use. + The .scend command ends the innermost + currently active scope. + + + + We can thus rewrite our header data using temporary labels, thus + allowing the main program to have a label + named next if it wants. + + + +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance 2064 + + +
+
+ Anonymous labels + + Anonymous labels are a way to handle short-ranged branches + without having to come up with names for the then and else + branches, for brief loops, and other such purposes. To define + an anonymous label, use an asterisk. To refer to an anonymous + label, use a series of + + or - signs. + refers to + the next anonymous label, ++ the label + after that, etc. Likewise, - is the most + recently defined label, -- the one before + that, and so on. The main body of the Hello World program + with anonymous labels would be: + + + + ldx #0 +* lda hello, x + beq + + jsr $ffd2 + inx + bne - +* rts + + + + It is worth noting that anonymous labels are globally available. + They are not temporary labels, and they ignore scoping + restrictions. + +
+
+ Aliasing + + + Rather the reverse of anonymous labels, aliases are names + given to specific memory locations. These make it easier to + keep track of important constants or locations. The KERNAL + routines are a good example of constants that deserve names. + To assign the traditional name chrout to + the routine at $FFD2, simply give the directive: + + + +.alias chrout $ffd2 + + + And change the jsr command + to: + + + jsr chrout + + + + The final version of the code is in . It should + assemble to exactly the same program as . + +
+ diff --git a/doc/docbook/tutor3.sgm b/doc/docbook/tutor3.sgm new file mode 100644 index 0000000..975e443 --- /dev/null +++ b/doc/docbook/tutor3.sgm @@ -0,0 +1,160 @@ + + Headers, Libraries, and Macros + + + In this chapter we will split away parts of our Hello + World program into reusable header files and libraries. + We will also abstract away our string printing technique into a + macro which may be invoked at will, on arbitrary strings. We will + then multiply the output of our program tenfold. + + +
+ Header files and libraries + + + The prelude to our program—the PRG + information and the BASIC program—are going to be the same + in many, many programs. Thus, we should put them into a header + file to be included later. The .include + directive will load a file and insert it as source at the + designated point. + + + + A related directive, .require, will include + the file as long as it hasn't been included yet elsewhere. It + is useful for ensuring a library is linked in. + + + + For pre-assembled code or raw binary data, + the .incbin directive lets you include the + contents of a binary file directly in the output. This is handy + for linking in pre-created graphics or sound data. + + + + As a sample library, we will expand the definition of + the chrout routine to include the standard + names for every KERNAL routine. Our header file will + then .require it. + + + + We'll also add some convenience aliases for things like reverse + video, color changes, and shifting between upper case/graphics + and mixed case text. We'd feed those to + the chrout routine to get their effects. + + + + Since there have been no interesting changes to the prelude, and + the KERNAL values are standard, we do not reproduce them here. + (The files in question are and .) + +
+
+ Macros + + + A macro is a way of expressing a lot of code or data with a + simple shorthand. It's also usually configurable. Traditional + macro systems such as C's #define mechanic + use textual replacement: a macro is + expanded before any evaluation or even parsing occurs. + + + + In contrast, Ophis's macro system uses a call by + value approach where the arguments to macros are + evaluated to bytes or words before being inserted into the macro + body. This produces effects much closer to those of a + traditional function call. A more detailed discussion of the + tradeoffs may be found in . + + +
+ Macro definitions + + + A macro definition is a set of statements between + a .macro statement and + a .macend statement. + The .macro statement also names the macro + being defined. + + + + No global or anonymous labels may be defined inside a macro: + temporary labels only persist in the macro expansion itself. + (Each macro body has its own scope.) + + + + Arguments to macros are referred to by number: the first is + _1, the second _2, and so on. + + + + Here's a macro that encapsulates the printing routine in our + Hello World program, with an argument being the + address of the string to print: + + + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + + +
+
+ Macro invocations + + + Macros may be invoked in two ways: one that looks like a + directive, and one that looks like an instruction. + + + + The most common way to invoke a macro is to backquote the name + of the macro. It is also possible to use + the .invoke command. These commands look + like this: + + + +`print msg +.invoke print msg + + + + Arguments are passed to the macro as a comma-separated list. + They must all be expressions that evaluate to byte or word + values—a mechanism similar to .alias + is used to assign their values to the _n + names. + +
+
+
+ Example code + + + expands our + running example, including the code above and also defining a + new macro greet that takes a string argument + and prints a greeting to it. It then greets far too many + targets. + +
+ diff --git a/doc/docbook/tutor4.sgm b/doc/docbook/tutor4.sgm new file mode 100644 index 0000000..ba25e39 --- /dev/null +++ b/doc/docbook/tutor4.sgm @@ -0,0 +1,110 @@ + + Character maps + + + Now we will close the gap between the Commodore's + version of ASCII and the real one. We'll also add a time-delay + routine to slow down the output. This routine isn't really of + interest to us right now, so we'll add a subroutine + called delay that executes 2,560*(accumulator) + NOPs. By the time the program is finished, + we'll have executed 768,000 no-ops. + + + + There actually are better ways of getting a time-delay on the + Commodore 64; we'll deal with those in . + As a result, there isn't really a lot to discuss here. The later + tutorials will be building off of , so you may want to get familiar with + that. Note also the change to the body of + the greet macro. + + + + On to the topic at hand. Let's change the code to use mixed case. + We defined the upper'case + and lower'case aliases back + in as part of the + standard + header, so we can add this before our invocations of + the greet macro: + + + + lda #lower'case + jsr chrout + + + + And that will put us into mixed case mode. So, now we just need + to redefine the data so that it uses the mixed-case: + + + +hello1: .byte "Hello, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "programmer", 0 +target2: .byte "room", 0 +target3: .byte "building", 0 +target4: .byte "neighborhood", 0 +target5: .byte "city", 0 +target6: .byte "nation", 0 +target7: .byte "world", 0 +target8: .byte "Solar System", 0 +target9: .byte "Galaxy", 0 +target10: .byte "Universe", 0 + + + + The code that does this is in . If you assemble and run it, you will + notice that the output is not what we want. In particular, upper + and lowercase are reversed, so we have messages + like hELLO, sOLAR sYSTEM!. For + the specific case of PETSCII, we can just fix our strings, but + that's less of an option if we're writing for the Apple II's + character set, or targeting a game console that puts its letters + in arbitrary locations. We need to remap how strings are turned + into byte values. The .charmap + and .charmapbin directives do what we need. + + + + The .charmap directive usually takes two + arguments; a byte (usually in character form) indicating the ASCII + value to start remapping from, and then a string giving the new + values. To do our case-swapping, we write two directives before + defining any string constants: + + + +.charmap 'A, "abcdefghijklmnopqrstuvwxyz" +.charmap 'a, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + + + + Note that the 'a constant in the second + directive refers to the a character in the source, + not in the current map. + + + + The fixed code is in , and will produce the expected results + when run. + + + + An alternative is to use a .charmapbin + directive to replace the entire character map directly. This + specifies an external file, 256 bytes long, that is loaded in at + that point. A binary character map for the Commodore 64 is + provided with the sample programs + as petscii.map. There are also three + files, a2normal.map, a2inverse.map, + and a2blink.map that handle the Apple II's + very nonstandard character encodings. + + diff --git a/doc/docbook/tutor5.sgm b/doc/docbook/tutor5.sgm new file mode 100644 index 0000000..735033e --- /dev/null +++ b/doc/docbook/tutor5.sgm @@ -0,0 +1,157 @@ + + Local variables and memory segments + + + As mentioned in , there are better ways + to handle waiting than just executing vast numbers of NOPs. The + Commodore 64 KERNAL library includes a rdtim + routine that returns the uptime of the machine, in + 60ths of a second, as a 24-bit integer. + The Commodore 64 programmer's guide available online actually has + a bug in it, reversing the significance of the A and Y registers. + The accumulator holds the least significant + byte, not the most. + + + + Here's a first shot at a better delay routine: + + + +.scope + ; data used by the delay routine + _tmp: .byte 0 + _target: .byte 0 + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + + + + This works, but it eats up two bytes of file space that don't + really need to be specified. Also, it's modifying data inside a + program text area, which isn't good if you're assembling to a ROM + chip. (Since the Commodore 64 stores its programs in RAM, it's + not an issue for us here.) A slightly better solution is to + use .alias to assign the names to chunks of RAM + somewhere. There's a 4K chunk of RAM from $C000 through $CFFF + between the BASIC ROM and the I/O ROM that should serve our + purposes nicely. We can replace the definitions + of _tmp and _target with: + + + + ; data used by the delay routine + .alias _tmp $C000 + .alias _target $C001 + + + + This works better, but now we've just added a major bookkeeping + burden upon ourselves—we must ensure that no routines step on + each other. What we'd really like are two separate program + counters—one for the program text, and one for our variable + space. + + + + Ophis lets us do this with the .text + and .data commands. + The .text command switches to the program-text + counter, and the .data command switches to the + variable-data counter. When Ophis first starts assembling a file, + it starts in .text mode. + + + + To reserve space for a variable, use the .space command. This + takes the form: + + +.space varname size + + + which assigns the name varname to the current + program counter, then advances the program counter by the amount + specified in size. Nothing is output to the + final binary as a result of the .space command. + + + + You may not put in any commands that produce output into + a .data segment. Generally, all you will be + using are .org and .space + commands. Ophis will not complain if you + use .space inside a .text + segment, but this is nearly always wrong. + + + + The final version of delay looks like this: + + + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + + + + We're not quite done yet, however, because we have to tell the + data segment where to begin. (If we don't, it starts at 0, which + is usually wrong.) We add a very brief data segment to the top of + our code: + + + +.data +.org $C000 +.text + + + + This will run. However, we also ought to make sure that we aren't + overstepping any boundaries. Our program text shouldn't run into + the BASIC chip at $A000, and our data shouldn't run into the I/O + region at $D000. The .checkpc command lets us + assert that the program counter hasn't reached a specific point + yet. We put, at the end of our code: + + + +.checkpc $A000 +.data +.checkpc $D000 + + + + The final program is available as . Note that we based this on the + all-uppercase version from the last section, not any of the + charmapped versions. + + diff --git a/doc/docbook/tutor6.sgm b/doc/docbook/tutor6.sgm new file mode 100644 index 0000000..df527c3 --- /dev/null +++ b/doc/docbook/tutor6.sgm @@ -0,0 +1,118 @@ + + Expressions + + + Ophis permits a reasonably rich set of arithmetic operations to be + done at assemble time. So far, all of our arguments and values + have either been constants or label names. In this chapter, we + will modify the print macro so that it calls a + subroutine to do the actual printing. This will shrink the final + code size a fair bit. + + + + Here's our printing routine. It's fairly straightforward. + + + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +printstr: + sta $10 + stx $11 + ldy #$00 +_lp: lda ($10), y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + + + + However, now we are faced with the problem of what to do with + the print macro. We need to take a 16-bit + value and store it in two 8-bit registers. We can use + the < and > operators + to take the low or high byte of a word, respectively. + The print macro becomes: + + + +.macro print + lda #<_1 + ldx #>_1 + jsr printstr +.macend + + + + Also, since BASIC uses the locations $10 and $11, we should really + cache them at the start of the program and restore them at the + end: + + + +.data +.org $C000 +.space cache 2 +.text + + ; Save the zero page locations that printstr uses. + lda $10 + sta cache + lda $11 + sta cache+1 + + ; ... main program goes here ... + + ; Restore the zero page values printstr uses. + lda cache + sta $10 + lda cache+1 + sta $11 + + + + Note that we only have to name cache once, but + can use addition to refer to any offset from it. + + + + Ophis supports following operations, with the following precedence + levels (higher entries bind more tightly): + + + + Ophis Operators + + + + Operators + Description + + + + [ ]Parenthesized expressions + < >Byte selection (low, high) + * /Multiply, divide + + -Add, subtract + | & ^Bitwise OR, AND, XOR + + +
+ + Note that brackets, not parentheses, are used to group arithmetic + operations. This is because parentheses are used for the indirect + addressing modes, and it makes parsing much easier. + + + + The code for this version of the code is + in . + + diff --git a/doc/docbook/tutor7.sgm b/doc/docbook/tutor7.sgm new file mode 100644 index 0000000..04d694c --- /dev/null +++ b/doc/docbook/tutor7.sgm @@ -0,0 +1,143 @@ + + Advanced Memory Segments + + + This is the last section of the Ophis tutorial. By now we've + covered the basics of every command in the assembler; in this + final installment we show the full capabilities of + the .text and .data commands + as we produce a final set of Commodore 64 header files. + + +
+ The Problem + + + Our print'str routine + in accesses + memory locations $10 and $11 directly. We'd prefer to have + symbolic names for them. This reprises our concerns back in + when we concluded that we wanted two + separate program counters. Now we realize that we really need + three; one for the text, one for the data, and one for the zero + page data. And if we're going to allow three, we really should + allow any number. + +
+
+ The Solution + + + The .data and .text + commands can take a label name after them—this names a new + segment. We'll define a new segment + called zp (for zero page) and + have our zero-page variables be placed there. We can't actually + use the default origin of $0000 here either, though, because the + Commodore 64 reserves memory locations 0 and 1 to control its + memory mappers: + + + +.data zp +.org $0002 + + + + Now, actually, the rest of the zero page is reserved too: + locations $02-$7F are used by the BASIC interpreter, and + locations $80-$FF are used by the KERNAL. We don't need the + BASIC interpreter, though, so we can back up all of $02-$7F at + the start of our program and restore it all when we're done: + + + +.scope + ; Cache BASIC's zero page at top of available RAM. + ldx #$7E +* lda $01, x + sta $CF81, x + dex + bne - + + jsr _main + + ; Restore BASIC's zero page and return control. + + ldx #$7E +* lda $CF81, x + sta $01, x + dex + bne - + rts + +_main: + ; _main points at the start of the real program, + ; which is actually outside of this scope +.scend + + + + The new, improved header file is . + + + + Our print'str routine is then rewritten to + declare and use a zero-page variable, like so: + + + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +.data zp +.space _ptr 2 +.text +printstr: + sta _ptr + stx _ptr+1 + ldy #$00 +_lp: lda (_ptr),y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + + + + Also, we ought to put in an extra check to make sure our + zero-page allocations don't overflow, either: + + + +.data zp +.checkpc $80 + + + + That concludes our tour. The final source file + is . + +
+
+ Where to go from here + + This tutorial has touched on everything that the assembler can + do, but it's not really well organized as a + reference. is a better place to look + up matters of syntax or consult lists of available commands. + + + If you're looking for projects to undertake, the Commodore 64 + and Atari 2600 development communities are both very strong, and + the Apple II and NES development communities are still alive and + well as well. There's an annual Minigame Competition that's + always looking for new entries. + +
+ diff --git a/doc/kernal.oph b/doc/kernal.oph new file mode 100644 index 0000000..ea13fad --- /dev/null +++ b/doc/kernal.oph @@ -0,0 +1,67 @@ +; KERNAL routine aliases (C64) + +.alias acptr $ffa5 +.alias chkin $ffc6 +.alias chkout $ffc9 +.alias chrin $ffcf +.alias chrout $ffd2 +.alias ciout $ffa8 +.alias cint $ff81 +.alias clall $ffe7 +.alias close $ffc3 +.alias clrchn $ffcc +.alias getin $ffe4 +.alias iobase $fff3 +.alias ioinit $ff84 +.alias listen $ffb1 +.alias load $ffd5 +.alias membot $ff9c +.alias memtop $ff99 +.alias open $ffc0 +.alias plot $fff0 +.alias ramtas $ff87 +.alias rdtim $ffde +.alias readst $ffb7 +.alias restor $ff8a +.alias save $ffd8 +.alias scnkey $ff9f +.alias screen $ffed +.alias second $ff93 +.alias setlfs $ffba +.alias setmsg $ff90 +.alias setnam $ffbd +.alias settim $ffdb +.alias settmo $ffa2 +.alias stop $ffe1 +.alias talk $ffb4 +.alias tksa $ff96 +.alias udtim $ffea +.alias unlsn $ffae +.alias untlk $ffab +.alias vector $ff8d + +; Character codes for the colors. +.alias color'0 144 +.alias color'1 5 +.alias color'2 28 +.alias color'3 159 +.alias color'4 156 +.alias color'5 30 +.alias color'6 31 +.alias color'7 158 +.alias color'8 129 +.alias color'9 149 +.alias color'10 150 +.alias color'11 151 +.alias color'12 152 +.alias color'13 153 +.alias color'14 154 +.alias color'15 155 + +; ...and reverse video +.alias reverse'on 18 +.alias reverse'off 146 + +; ...and character set +.alias upper'case 142 +.alias lower'case 14 \ No newline at end of file diff --git a/doc/ophismanual.pdf b/doc/ophismanual.pdf new file mode 100644 index 0000000..a399c66 Binary files /dev/null and b/doc/ophismanual.pdf differ diff --git a/doc/petscii.map b/doc/petscii.map new file mode 100644 index 0000000..e4ae062 Binary files /dev/null and b/doc/petscii.map differ diff --git a/doc/tutor1.oph b/doc/tutor1.oph new file mode 100644 index 0000000..6789ce7 --- /dev/null +++ b/doc/tutor1.oph @@ -0,0 +1,18 @@ +.word $0801 +.org $0801 + + .word next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +next: .word 0 ; End of program + +.advance 2064 + + ldx #0 +loop: lda hello, x + beq done + jsr $ffd2 + inx + bne loop +done: rts + +hello: .byte "HELLO, WORLD!", 0 \ No newline at end of file diff --git a/doc/tutor2.oph b/doc/tutor2.oph new file mode 100644 index 0000000..27c6682 --- /dev/null +++ b/doc/tutor2.oph @@ -0,0 +1,22 @@ +.word $0801 +.org $0801 + +.scope + .word _next, 10 ; Next line and current line number + .byte $9e," 2064",0 ; SYS 2064 +_next: .word 0 ; End of program +.scend + +.advance 2064 + +.alias chrout $ffd2 + + ldx #0 +* lda hello, x + beq + + jsr chrout + inx + bne - +* rts + +hello: .byte "HELLO, WORLD!", 0 \ No newline at end of file diff --git a/doc/tutor3.oph b/doc/tutor3.oph new file mode 100644 index 0000000..112e2bf --- /dev/null +++ b/doc/tutor3.oph @@ -0,0 +1,45 @@ +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 \ No newline at end of file diff --git a/doc/tutor4a.oph b/doc/tutor4a.oph new file mode 100644 index 0000000..d218a5f --- /dev/null +++ b/doc/tutor4a.oph @@ -0,0 +1,69 @@ +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + + + rts + diff --git a/doc/tutor4b.oph b/doc/tutor4b.oph new file mode 100644 index 0000000..3926965 --- /dev/null +++ b/doc/tutor4b.oph @@ -0,0 +1,71 @@ +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + lda #lower'case + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "Hello, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "programmer", 0 +target2: .byte "room", 0 +target3: .byte "building", 0 +target4: .byte "neighborhood", 0 +target5: .byte "city", 0 +target6: .byte "nation", 0 +target7: .byte "world", 0 +target8: .byte "Solar System", 0 +target9: .byte "Galaxy", 0 +target10: .byte "Universe", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + + + rts + diff --git a/doc/tutor4c.oph b/doc/tutor4c.oph new file mode 100644 index 0000000..f05d023 --- /dev/null +++ b/doc/tutor4c.oph @@ -0,0 +1,73 @@ +.include "c64-1.oph" + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + lda #lower'case + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +.charmap 'A, "abcdefghijklmnopqrstuvwxyz" +.charmap 'a, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + +hello1: .byte "Hello, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "programmer", 0 +target2: .byte "room", 0 +target3: .byte "building", 0 +target4: .byte "neighborhood", 0 +target5: .byte "city", 0 +target6: .byte "nation", 0 +target7: .byte "world", 0 +target8: .byte "Solar System", 0 +target9: .byte "Galaxy", 0 +target10: .byte "Universe", 0 + +; DELAY routine. Executes 2,560*(A) NOP statements. +delay: tax + ldy #00 +* nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + iny + bne - + dex + bne - + + + rts \ No newline at end of file diff --git a/doc/tutor5.oph b/doc/tutor5.oph new file mode 100644 index 0000000..8caf839 --- /dev/null +++ b/doc/tutor5.oph @@ -0,0 +1,75 @@ +.include "c64-1.oph" + +.data +.org $C000 +.text + +.macro print + ldx #0 +_loop: lda _1, x + beq _done + jsr chrout + inx + bne _loop +_done: +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +.checkpc $A000 +.data +.checkpc $D000 \ No newline at end of file diff --git a/doc/tutor6.oph b/doc/tutor6.oph new file mode 100644 index 0000000..60ad8e9 --- /dev/null +++ b/doc/tutor6.oph @@ -0,0 +1,102 @@ +.include "c64-1.oph" + +.data +.org $C000 +.space cache 2 +.text + +.macro print + lda #<_1 + ldx #>_1 + jsr printstr +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + ; Save the zero page locations that PRINTSTR uses. + lda $10 + sta cache + lda $11 + sta cache+1 + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + + ; Restore the zero page values printstr uses. + lda cache + sta $10 + lda cache+1 + sta $11 + + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +printstr: + sta $10 + stx $11 + ldy #$00 +_lp: lda ($10),y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + +.checkpc $A000 +.data +.checkpc $D000 \ No newline at end of file diff --git a/doc/tutor7.oph b/doc/tutor7.oph new file mode 100644 index 0000000..88ba5bf --- /dev/null +++ b/doc/tutor7.oph @@ -0,0 +1,96 @@ +.include "c64-2.oph" + +.data +.org $C000 +.text + +.macro print + lda #<_1 + ldx #>_1 + jsr printstr +.macend + +.macro greet + lda #30 + jsr delay + `print hello1 + `print _1 + `print hello2 +.macend + + lda #147 + jsr chrout + `greet target1 + `greet target2 + `greet target3 + `greet target4 + `greet target5 + `greet target6 + `greet target7 + `greet target8 + `greet target9 + `greet target10 + + rts + +hello1: .byte "HELLO, ",0 +hello2: .byte "!", 13, 0 + +target1: .byte "PROGRAMMER", 0 +target2: .byte "ROOM", 0 +target3: .byte "BUILDING", 0 +target4: .byte "NEIGHBORHOOD", 0 +target5: .byte "CITY", 0 +target6: .byte "NATION", 0 +target7: .byte "WORLD", 0 +target8: .byte "SOLAR SYSTEM", 0 +target9: .byte "GALAXY", 0 +target10: .byte "UNIVERSE", 0 + +; DELAY routine. Takes values from the Accumulator and pauses +; for that many jiffies (1/60th of a second). +.scope +.data +.space _tmp 1 +.space _target 1 + +.text + +delay: sta _tmp ; save argument (rdtim destroys it) + jsr rdtim + clc + adc _tmp ; add current time to get target + sta _target +* jsr rdtim + cmp _target + bmi - ; Buzz until target reached + rts +.scend + +; PRINTSTR routine. Accumulator stores the low byte of the address, +; X register stores the high byte. Destroys the values of $10 and +; $11. + +.scope +.data zp +.space _ptr 2 +.text +printstr: + sta _ptr + stx _ptr+1 + ldy #$00 +_lp: lda (_ptr),y + beq _done + jsr chrout + iny + bne _lp +_done: rts +.scend + +.checkpc $A000 + +.data +.checkpc $D000 + +.data zp +.checkpc $80 \ No newline at end of file diff --git a/site/index.html b/site/index.html new file mode 100644 index 0000000..6c47757 --- /dev/null +++ b/site/index.html @@ -0,0 +1,32 @@ + + + +The Ophis Assembler + +

The Ophis Assembler

+ +

Ophis is a cross-assembler for the 65xx series of chips. It supports the stock 6502 opcodes, the 65c02 extensions, and syntax for the "undocumented opcodes" in the 6510 chip used on the Commodore 64. (Syntax for these opcodes matches those given in the VICE team's documentation.)

+ +

Ophis is written in pure Python and should be highly portable.

+ +

If you have questions or comments, email me at mcmartin AT gmail DOT com.

+ +

Downloads

+ + +

Documentation

+ +

The manual Programming with Ophis is distributed with each download. You can also get it alone.

+ + + + + diff --git a/site/manual/a454.html b/site/manual/a454.html new file mode 100644 index 0000000..0d16f71 --- /dev/null +++ b/site/manual/a454.html @@ -0,0 +1,184 @@ + +Example Programs
Programming with Ophis
<<< PreviousNext >>>

Example Programs

This Appendix collects all the programs referred to in the course + of this manual. +

tutor1.oph

.word $0801
+.org  $0801
+
+        .word next, 10          ; Next line and current line number
+        .byte $9e," 2064",0     ; SYS 2064
+next:   .word 0                 ; End of program
+
+.advance 2064
+
+        ldx #0
+loop:   lda hello, x
+        beq done
+        jsr $ffd2
+        inx
+        bne loop
+done:   rts
+
+hello:  .byte "HELLO, WORLD!", 0
<<< PreviousHomeNext >>>
Where to go from here tutor2.oph
\ No newline at end of file diff --git a/site/manual/a505.html b/site/manual/a505.html new file mode 100644 index 0000000..08cd6ca --- /dev/null +++ b/site/manual/a505.html @@ -0,0 +1,311 @@ + +Ophis Command Reference
Programming with Ophis
<<< PreviousNext >>>

Ophis Command Reference

Command Modes

These mostly follow the MOS Technology 6500 + Microprocessor Family Programming Manual, except + for the Accumulator mode. Accumulator instructions are written + and interpreted identically to Implied mode instructions. +

<<< PreviousHomeNext >>>
tutor7.oph Basic arguments
\ No newline at end of file diff --git a/site/manual/book1.html b/site/manual/book1.html new file mode 100644 index 0000000..d7499af --- /dev/null +++ b/site/manual/book1.html @@ -0,0 +1,467 @@ + +Programming with Ophis

Programming with Ophis

Michael Martin

Copyright © 2006-7 Michael Martin

Table of Contents
Preface
Why "Ophis"?
Getting a copy of Ophis
The basics
A note on numeric notation
Producing Commodore 64 programs
Related commands and options
Writing the actual code
Assembling the code
Labels and aliases
Temporary labels
Anonymous labels
Aliasing
Headers, Libraries, and Macros
Header files and libraries
Macros
Macro definitions
Macro invocations
Example code
Character maps
Local variables and memory segments
Expressions
Advanced Memory Segments
The Problem
The Solution
Where to go from here
Example Programs
tutor1.oph
tutor2.oph
c64-1.oph
kernal.oph
tutor3.oph
tutor4a.oph
tutor4b.oph
tutor4c.oph
tutor5.oph
tutor6.oph
c64-2.oph
tutor7.oph
Ophis Command Reference
Command Modes
Basic arguments
Numeric types
Label types
String types
Compound Arguments
Memory Model
Basic PC tracking
Basic Segmentation simulation
General Segmentation Simulation
Macros
Defining Macros
Invoking Macros
Passing Arguments to Macros
Features and Restrictions of the Ophis Macro Model
Assembler directives
  Next >>>
  Preface
\ No newline at end of file diff --git a/site/manual/c200.html b/site/manual/c200.html new file mode 100644 index 0000000..d5f036d --- /dev/null +++ b/site/manual/c200.html @@ -0,0 +1,208 @@ + +Labels and aliases
Programming with Ophis
<<< PreviousNext >>>

Labels and aliases

Labels are an important part of your code. However, since each + label must normally be unique, this can lead to "namespace + pollution," and you'll find yourself going through ever + more contorted constructions to generate unique label names. + Ophis offers two solutions to this: anonymous + labels and temporary labels. This + tutorial will cover both of these facilities, and also introduce + the aliasing mechanism. +

Temporary labels

Temporary labels are the easiest to use. If a label begins with + an underscore, it will only be reachable from inside the + innermost enclosing scope. Scopes begin when + a .scope statement is encountered. This + produces a new, inner scope if there is another scope in use. + The .scend command ends the innermost + currently active scope. +

We can thus rewrite our header data using temporary labels, thus + allowing the main program to have a label + named next if it wants. + 

.word $0801
+.org  $0801
+
+.scope
+        .word _next, 10      ; Next line and current line number
+        .byte $9e," 2064",0  ; SYS 2064
+_next:  .word 0              ; End of program
+.scend
+
+.advance 2064
<<< PreviousHomeNext >>>
Assembling the code Anonymous labels
\ No newline at end of file diff --git a/site/manual/c236.html b/site/manual/c236.html new file mode 100644 index 0000000..99e4546 --- /dev/null +++ b/site/manual/c236.html @@ -0,0 +1,226 @@ + +Headers, Libraries, and Macros
Programming with Ophis
<<< PreviousNext >>>

Headers, Libraries, and Macros

In this chapter we will split away parts of our "Hello + World" program into reusable header files and libraries. + We will also abstract away our string printing technique into a + macro which may be invoked at will, on arbitrary strings. We will + then multiply the output of our program tenfold. +

Header files and libraries

The prelude to our program—the PRG + information and the BASIC program—are going to be the same + in many, many programs. Thus, we should put them into a header + file to be included later. The .include + directive will load a file and insert it as source at the + designated point. +

A related directive, .require, will include + the file as long as it hasn't been included yet elsewhere. It + is useful for ensuring a library is linked in. +

For pre-assembled code or raw binary data, + the .incbin directive lets you include the + contents of a binary file directly in the output. This is handy + for linking in pre-created graphics or sound data. +

As a sample library, we will expand the definition of + the chrout routine to include the standard + names for every KERNAL routine. Our header file will + then .require it. +

We'll also add some convenience aliases for things like reverse + video, color changes, and shifting between upper case/graphics + and mixed case text. We'd feed those to + the chrout routine to get their effects. +

Since there have been no interesting changes to the prelude, and + the KERNAL values are standard, we do not reproduce them here. + (The files in question are c64-1.oph and kernal.oph.) +

<<< PreviousHomeNext >>>
Aliasing Macros
\ No newline at end of file diff --git a/site/manual/c292.html b/site/manual/c292.html new file mode 100644 index 0000000..b883874 --- /dev/null +++ b/site/manual/c292.html @@ -0,0 +1,344 @@ + +Character maps
Programming with Ophis
<<< PreviousNext >>>

Character maps

Now we will close the gap between the Commodore's + version of ASCII and the real one. We'll also add a time-delay + routine to slow down the output. This routine isn't really of + interest to us right now, so we'll add a subroutine + called delay that executes 2,560*(accumulator) + NOPs. By the time the program is finished, + we'll have executed 768,000 no-ops. +

There actually are better ways of getting a time-delay on the + Commodore 64; we'll deal with those in the Chapter called Local variables and memory segments. + As a result, there isn't really a lot to discuss here. The later + tutorials will be building off of tutor4a.oph, so you may want to get familiar with + that. Note also the change to the body of + the greet macro. +

On to the topic at hand. Let's change the code to use mixed case. + We defined the upper'case + and lower'case aliases back + in the Chapter called Headers, Libraries, and Macros as part of the + standard kernal.oph + header, so we can add this before our invocations of + the greet macro: + 

          lda #lower'case
+          jsr chrout

And that will put us into mixed case mode. So, now we just need + to redefine the data so that it uses the mixed-case: + 

hello1:   .byte "Hello, ",0
+hello2:   .byte "!", 13, 0
+
+target1:  .byte "programmer", 0
+target2:  .byte "room", 0
+target3:  .byte "building", 0
+target4:  .byte "neighborhood", 0
+target5:  .byte "city", 0
+target6:  .byte "nation", 0
+target7:  .byte "world", 0
+target8:  .byte "Solar System", 0
+target9:  .byte "Galaxy", 0
+target10: .byte "Universe", 0

The code that does this is in tutor4b.oph. If you assemble and run it, you will + notice that the output is not what we want. In particular, upper + and lowercase are reversed, so we have messages + like hELLO, sOLAR sYSTEM!. For + the specific case of PETSCII, we can just fix our strings, but + that's less of an option if we're writing for the Apple II's + character set, or targeting a game console that puts its letters + in arbitrary locations. We need to remap how strings are turned + into byte values. The .charmap + and .charmapbin directives do what we need. +

The .charmap directive usually takes two + arguments; a byte (usually in character form) indicating the ASCII + value to start remapping from, and then a string giving the new + values. To do our case-swapping, we write two directives before + defining any string constants: + 

.charmap 'A, "abcdefghijklmnopqrstuvwxyz"
+.charmap 'a, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Note that the 'a constant in the second + directive refers to the "a" character in the source, + not in the current map. +

The fixed code is in tutor4c.oph, and will produce the expected results + when run. +

An alternative is to use a .charmapbin + directive to replace the entire character map directly. This + specifies an external file, 256 bytes long, that is loaded in at + that point. A binary character map for the Commodore 64 is + provided with the sample programs + as petscii.map. There are also three + files, a2normal.map, a2inverse.map, + and a2blink.map that handle the Apple II's + very nonstandard character encodings. +

<<< PreviousHomeNext >>>
Example code Local variables and memory segments
\ No newline at end of file diff --git a/site/manual/c329.html b/site/manual/c329.html new file mode 100644 index 0000000..784c66c --- /dev/null +++ b/site/manual/c329.html @@ -0,0 +1,402 @@ + +Local variables and memory segments
Programming with Ophis
<<< PreviousNext >>>

Local variables and memory segments

As mentioned in the Chapter called Character maps, there are better ways + to handle waiting than just executing vast numbers of NOPs. The + Commodore 64 KERNAL library includes a rdtim + routine that returns the uptime of the machine, in + 60ths of a second, as a 24-bit integer. + The Commodore 64 programmer's guide available online actually has + a bug in it, reversing the significance of the A and Y registers. + The accumulator holds the least significant + byte, not the most. +

Here's a first shot at a better delay routine: + 

.scope
+        ; data used by the delay routine
+        _tmp:    .byte 0
+        _target: .byte 0
+
+delay:  sta _tmp        ; save argument (rdtim destroys it)
+        jsr rdtim
+        clc
+        adc _tmp        ; add current time to get target
+        sta _target
+*       jsr rdtim
+        cmp _target
+        bmi -           ; Buzz until target reached
+        rts
+.scend

This works, but it eats up two bytes of file space that don't + really need to be specified. Also, it's modifying data inside a + program text area, which isn't good if you're assembling to a ROM + chip. (Since the Commodore 64 stores its programs in RAM, it's + not an issue for us here.) A slightly better solution is to + use .alias to assign the names to chunks of RAM + somewhere. There's a 4K chunk of RAM from $C000 through $CFFF + between the BASIC ROM and the I/O ROM that should serve our + purposes nicely. We can replace the definitions + of _tmp and _target with: + 

        ; data used by the delay routine
+        .alias _tmp    $C000
+        .alias _target $C001

This works better, but now we've just added a major bookkeeping + burden upon ourselves—we must ensure that no routines step on + each other. What we'd really like are two separate program + counters—one for the program text, and one for our variable + space. +

Ophis lets us do this with the .text + and .data commands. + The .text command switches to the program-text + counter, and the .data command switches to the + variable-data counter. When Ophis first starts assembling a file, + it starts in .text mode. +

To reserve space for a variable, use the .space command. This + takes the form: + +
.space varname size
+ + which assigns the name varname to the current + program counter, then advances the program counter by the amount + specified in size. Nothing is output to the + final binary as a result of the .space command. +

You may not put in any commands that produce output into + a .data segment. Generally, all you will be + using are .org and .space + commands. Ophis will not complain if you + use .space inside a .text + segment, but this is nearly always wrong. +

The final version of delay looks like this: + 

; DELAY routine.  Takes values from the Accumulator and pauses
+; for that many jiffies (1/60th of a second).
+.scope
+.data
+.space _tmp 1
+.space _target 1
+
+.text
+
+delay:  sta _tmp        ; save argument (rdtim destroys it)
+        jsr rdtim
+        clc
+        adc _tmp        ; add current time to get target
+        sta _target
+*       jsr rdtim
+        cmp _target
+        bmi -                ; Buzz until target reached
+        rts
+.scend

We're not quite done yet, however, because we have to tell the + data segment where to begin. (If we don't, it starts at 0, which + is usually wrong.) We add a very brief data segment to the top of + our code: + 

.data
+.org $C000
+.text

This will run. However, we also ought to make sure that we aren't + overstepping any boundaries. Our program text shouldn't run into + the BASIC chip at $A000, and our data shouldn't run into the I/O + region at $D000. The .checkpc command lets us + assert that the program counter hasn't reached a specific point + yet. We put, at the end of our code: + 

.checkpc $A000
+.data
+.checkpc $D000

The final program is available as tutor5.oph. Note that we based this on the + all-uppercase version from the last section, not any of the + charmapped versions. +

<<< PreviousHomeNext >>>
Character maps Expressions
\ No newline at end of file diff --git a/site/manual/c35.html b/site/manual/c35.html new file mode 100644 index 0000000..cd82799 --- /dev/null +++ b/site/manual/c35.html @@ -0,0 +1,180 @@ + +The basics
Programming with Ophis
<<< PreviousNext >>>

The basics

In this first part of the tutorial we will create a + simple "Hello World" program to run on the Commodore + 64. This will cover: + +

+

A note on numeric notation

Throughout these tutorials, I will be using a lot of both + decimal and hexadecimal notation. Hex numbers will have a + dollar sign in front of them. Thus, 100 = $64, and $100 = 256. +

<<< PreviousHomeNext >>>
Getting a copy of Ophis Producing Commodore 64 programs
\ No newline at end of file diff --git a/site/manual/c371.html b/site/manual/c371.html new file mode 100644 index 0000000..05a57be --- /dev/null +++ b/site/manual/c371.html @@ -0,0 +1,348 @@ + +Expressions
Programming with Ophis
<<< PreviousNext >>>

Expressions

Ophis permits a reasonably rich set of arithmetic operations to be + done at assemble time. So far, all of our arguments and values + have either been constants or label names. In this chapter, we + will modify the print macro so that it calls a + subroutine to do the actual printing. This will shrink the final + code size a fair bit. +

Here's our printing routine. It's fairly straightforward. + 

; PRINTSTR routine.  Accumulator stores the low byte of the address,
+; X register stores the high byte.  Destroys the values of $10 and
+; $11.
+
+.scope
+printstr:
+        sta $10
+        stx $11
+        ldy #$00
+_lp:    lda ($10), y
+        beq _done
+        jsr chrout
+        iny
+        bne _lp
+_done:  rts
+.scend

However, now we are faced with the problem of what to do with + the print macro. We need to take a 16-bit + value and store it in two 8-bit registers. We can use + the < and > operators + to take the low or high byte of a word, respectively. + The print macro becomes: + 

.macro print
+        lda #<_1
+        ldx #>_1
+        jsr printstr
+.macend

Also, since BASIC uses the locations $10 and $11, we should really + cache them at the start of the program and restore them at the + end: + 

.data
+.org $C000
+.space cache 2
+.text
+
+        ; Save the zero page locations that printstr uses.
+        lda $10
+        sta cache
+        lda $11
+        sta cache+1
+
+        ; ... main program goes here ...
+
+        ; Restore the zero page values printstr uses.
+        lda cache
+        sta $10
+        lda cache+1
+        sta $11

Note that we only have to name cache once, but + can use addition to refer to any offset from it. +

Ophis supports following operations, with the following precedence + levels (higher entries bind more tightly): +

Table 1. Ophis Operators

OperatorsDescription
[ ]Parenthesized expressions
< >Byte selection (low, high)
* /Multiply, divide
+ -Add, subtract
| & ^Bitwise OR, AND, XOR

Note that brackets, not parentheses, are used to group arithmetic + operations. This is because parentheses are used for the indirect + addressing modes, and it makes parsing much easier. +

The code for this version of the code is + in tutor6.oph. +

<<< PreviousHomeNext >>>
Local variables and memory segments Advanced Memory Segments
\ No newline at end of file diff --git a/site/manual/c419.html b/site/manual/c419.html new file mode 100644 index 0000000..674310a --- /dev/null +++ b/site/manual/c419.html @@ -0,0 +1,184 @@ + +Advanced Memory Segments
Programming with Ophis
<<< PreviousNext >>>

Advanced Memory Segments

This is the last section of the Ophis tutorial. By now we've + covered the basics of every command in the assembler; in this + final installment we show the full capabilities of + the .text and .data commands + as we produce a final set of Commodore 64 header files. +

The Problem

Our print'str routine + in tutor6.oph accesses + memory locations $10 and $11 directly. We'd prefer to have + symbolic names for them. This reprises our concerns back in + the Chapter called Local variables and memory segments when we concluded that we wanted two + separate program counters. Now we realize that we really need + three; one for the text, one for the data, and one for the zero + page data. And if we're going to allow three, we really should + allow any number. +

<<< PreviousHomeNext >>>
Expressions The Solution
\ No newline at end of file diff --git a/site/manual/f10.html b/site/manual/f10.html new file mode 100644 index 0000000..71c7cd2 --- /dev/null +++ b/site/manual/f10.html @@ -0,0 +1,186 @@ + +Preface
Programming with Ophis
<<< PreviousNext >>>

Preface

The Ophis project started on a lark back in 2001. My graduate + studies required me to learn Perl and Python, and I'd been playing + around with Commodore 64 emulators in my spare time, so I decided + to learn both languages by writing a simple cross-assembler for + the 6502 chip the C-64 used in both. +

The Perl version was quickly abandoned, but the Python one slowly + grew in scope and power over the years, and by 2005 was a very + powerful, flexible macro assembler that saw more use than I'd + expect. In 2007 I finally got around to implementing the last few + features I really wanted and polishing it up for general release. +

Part of that process has been formatting the various little + tutorials and references I'd created into a single, unified + document—the one you are now reading. +

Why "Ophis"?

It's actually a kind of a horrific pun. See, I was using Python + at the time, and one of the things I had been hoping to do with + the assembler was to produce working Apple II + programs. "Ophis" is Greek + for "snake", and a number of traditions also use it + as the actual name of the serpent in the + Garden of Eden. So, Pythons, snakes, and stories involving + really old Apples all combined to name the assembler. +

<<< PreviousHomeNext >>>
Programming with Ophis Getting a copy of Ophis
\ No newline at end of file diff --git a/site/manual/x119.html b/site/manual/x119.html new file mode 100644 index 0000000..a9b00ed --- /dev/null +++ b/site/manual/x119.html @@ -0,0 +1,206 @@ + +Related commands and options
Programming with Ophis
<<< PreviousThe basicsNext >>>

Related commands and options

This code includes constants that are both in decimal and in + hex. It is also possible to specify constants in octal, binary, + or with an ASCII character. + +

+ + Example: 65 = $41 = 0101 = %1000001 = 'A +

There are other commands besides .byte + and .word to specify data. In particular, + the .dword command specifies four-byte values + which some applications will find useful. Also, some linking + formats (such as the SID format) have + header data in big-endian (high byte first) format. + The .wordbe and .dwordbe + directives provide a way to specify multibyte constants in + big-endian formats cleanly. +

<<< PreviousHomeNext >>>
Producing Commodore 64 programsUpWriting the actual code
\ No newline at end of file diff --git a/site/manual/x140.html b/site/manual/x140.html new file mode 100644 index 0000000..e6413c9 --- /dev/null +++ b/site/manual/x140.html @@ -0,0 +1,197 @@ + +Writing the actual code
Programming with Ophis
<<< PreviousThe basicsNext >>>

Writing the actual code

Now that we have our header information, let's actually write + the "Hello world" program. It's pretty + short—a simple loop that steps through a hardcoded array + until it reaches a 0 or outputs 256 characters. It then returns + control to BASIC with an RTS statement. +

Each character in the array is passed as an argument to a + subroutine at memory location $FFD2. This is part of the + Commodore 64's BIOS software, which its development + documentation calls the KERNAL. Location $FFD2 prints out the + character corresponding to the character code in the + accumulator. + 

        ldx #0
+loop:   lda hello, x
+        beq done
+        jsr $ffd2
+        inx
+        bne loop
+done:   rts
+
+hello:  .byte "HELLO, WORLD!", 0
+

The complete, final source is available in + the tutor1.oph file. +

<<< PreviousHomeNext >>>
Related commands and optionsUpAssembling the code
\ No newline at end of file diff --git a/site/manual/x149.html b/site/manual/x149.html new file mode 100644 index 0000000..656e0c0 --- /dev/null +++ b/site/manual/x149.html @@ -0,0 +1,317 @@ + +Assembling the code
Programming with Ophis
<<< PreviousThe basicsNext >>>

Assembling the code

The Ophis assembler is a collection of Python modules, + controlled by a master script. On Windows, this should all + have been combined into an executable + file ophis.exe; on other platforms, the + Ophis modules should be in the library and + the ophis script should be in your path. + Typing ophis with no arguments should give a + summary of available command line options. +

Table 2. Ophis Options

OptionEffect
-6510Allows the 6510 undocumented opcodes as listed in the VICE documentation.
-65c02Allows opcodes and addressing modes added by the 65C02.
-v 0Quiet operation. Only reports errors.
-v 1Default operation. Reports files as they are loaded, and gives statistics on the final output.
-v 2Verbose operation. Names each assembler pass as it runs.
-v 3Debug operation: Dumps the entire IR after each pass.
-v 4Full debug operation: Dumps the entire IR and symbol table after each pass.

The only options Ophis demands are an input file and an output + file. Here's a sample session, assembling the tutorial file + here: + 

localhost$ ophis tutor1.oph tutor1.prg -v 2
+Loading tutor1.oph
+Running: Macro definition pass
+Running: Macro expansion pass
+Running: Label initialization pass
+Fixpoint failed, looping back
+Running: Label initialization pass
+Running: Circularity check pass
+Running: Expression checking pass
+Running: Easy addressing modes pass
+Running: Label Update Pass
+Fixpoint failed, looping back
+Running: Label Update Pass
+Running: Instruction Collapse Pass
+Running: Mode Normalization pass
+Running: Label Update Pass
+Running: Assembler
+Assembly complete: 45 bytes output (14 code, 29 data, 2 filler)
+

If your emulator can run PRG files + directly, this file will now run (and + print HELLO, WORLD!) as many + times as you type RUN. Otherwise, use + a D64 management utility to put + the PRG on a D64, then + load and run the file off that. +

<<< PreviousHomeNext >>>
Writing the actual codeUpLabels and aliases
\ No newline at end of file diff --git a/site/manual/x214.html b/site/manual/x214.html new file mode 100644 index 0000000..ac408d2 --- /dev/null +++ b/site/manual/x214.html @@ -0,0 +1,198 @@ + +Anonymous labels
Programming with Ophis
<<< PreviousLabels and aliasesNext >>>

Anonymous labels

Anonymous labels are a way to handle short-ranged branches + without having to come up with names for the then and else + branches, for brief loops, and other such purposes. To define + an anonymous label, use an asterisk. To refer to an anonymous + label, use a series of + + or - signs. + refers to + the next anonymous label, ++ the label + after that, etc. Likewise, - is the most + recently defined label, -- the one before + that, and so on. The main body of the Hello World program + with anonymous labels would be: + 

        ldx #0
+*       lda hello, x
+        beq +
+        jsr $ffd2
+        inx
+        bne -
+*       rts

It is worth noting that anonymous labels are globally available. + They are not temporary labels, and they ignore scoping + restrictions. +

<<< PreviousHomeNext >>>
Labels and aliasesUpAliasing
\ No newline at end of file diff --git a/site/manual/x22.html b/site/manual/x22.html new file mode 100644 index 0000000..1439651 --- /dev/null +++ b/site/manual/x22.html @@ -0,0 +1,197 @@ + +Getting a copy of Ophis
Programming with Ophis
<<< PreviousPrefaceNext >>>

Getting a copy of Ophis

If you're reading this as part of the Ophis install, you clearly + already have it. If not, as of this writing the homepage for + the Ophis assembler + is http://hkn.eecs.berkeley.edu/~mcmartin/ophis/. If + this is out-of-date, a Web search on "Ophis 6502 + assembler" (without the quotation marks) should yield its + page. +

Ophis is written entirely in Python and packaged using the + distutils. The default installation script on Unix and Mac OS X + systems should put the files where they need to go. If you are + running it locally, you will need to install + the Ophis package somewhere in your Python + package path, and then put the ophis script + somewhere in your path. +

Windows users that have Python installed can use the same source + distributions that the other operating systems + use; ophis.bat will arrange the environment + variables accordingly and invoke the main script. +

If you are on Windows and do not have Python installed, a + prepackaged system made with py2exe is also + available. The default Windows installer will use this. In + this case, all you need to do is + have ophis.exe in your path. +

<<< PreviousHomeNext >>>
PrefaceUpThe basics
\ No newline at end of file diff --git a/site/manual/x225.html b/site/manual/x225.html new file mode 100644 index 0000000..2809307 --- /dev/null +++ b/site/manual/x225.html @@ -0,0 +1,203 @@ + +Aliasing
Programming with Ophis
<<< PreviousLabels and aliasesNext >>>

Aliasing

Rather the reverse of anonymous labels, aliases are names + given to specific memory locations. These make it easier to + keep track of important constants or locations. The KERNAL + routines are a good example of constants that deserve names. + To assign the traditional name chrout to + the routine at $FFD2, simply give the directive: + 

.alias chrout $ffd2

And change the jsr command + to:

        jsr chrout

The final version of the code is in tutor2.oph. It should + assemble to exactly the same program as tutor1.oph. +

<<< PreviousHomeNext >>>
Anonymous labelsUpHeaders, Libraries, and Macros
\ No newline at end of file diff --git a/site/manual/x257.html b/site/manual/x257.html new file mode 100644 index 0000000..1e6128a --- /dev/null +++ b/site/manual/x257.html @@ -0,0 +1,289 @@ + +Macros
Programming with Ophis
<<< PreviousHeaders, Libraries, and MacrosNext >>>

Macros

A macro is a way of expressing a lot of code or data with a + simple shorthand. It's also usually configurable. Traditional + macro systems such as C's #define mechanic + use textual replacement: a macro is + expanded before any evaluation or even parsing occurs. +

In contrast, Ophis's macro system uses a call by + value approach where the arguments to macros are + evaluated to bytes or words before being inserted into the macro + body. This produces effects much closer to those of a + traditional function call. A more detailed discussion of the + tradeoffs may be found in the Appendix called Ophis Command Reference. +

Macro definitions

A macro definition is a set of statements between + a .macro statement and + a .macend statement. + The .macro statement also names the macro + being defined. +

No global or anonymous labels may be defined inside a macro: + temporary labels only persist in the macro expansion itself. + (Each macro body has its own scope.) +

Arguments to macros are referred to by number: the first is + _1, the second _2, and so on. +

Here's a macro that encapsulates the printing routine in our + "Hello World" program, with an argument being the + address of the string to print: + 

.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend

Macro invocations

Macros may be invoked in two ways: one that looks like a + directive, and one that looks like an instruction. +

The most common way to invoke a macro is to backquote the name + of the macro. It is also possible to use + the .invoke command. These commands look + like this: + 

`print msg
+.invoke print msg

Arguments are passed to the macro as a comma-separated list. + They must all be expressions that evaluate to byte or word + values—a mechanism similar to .alias + is used to assign their values to the _n + names. +

<<< PreviousHomeNext >>>
Headers, Libraries, and MacrosUpExample code
\ No newline at end of file diff --git a/site/manual/x287.html b/site/manual/x287.html new file mode 100644 index 0000000..e4c9395 --- /dev/null +++ b/site/manual/x287.html @@ -0,0 +1,161 @@ + +Example code
Programming with Ophis
<<< PreviousHeaders, Libraries, and MacrosNext >>>

Example code

tutor3.oph expands our + running example, including the code above and also defining a + new macro greet that takes a string argument + and prints a greeting to it. It then greets far too many + targets. +

<<< PreviousHomeNext >>>
MacrosUpCharacter maps
\ No newline at end of file diff --git a/site/manual/x430.html b/site/manual/x430.html new file mode 100644 index 0000000..8d0cb6a --- /dev/null +++ b/site/manual/x430.html @@ -0,0 +1,295 @@ + +The Solution
Programming with Ophis
<<< PreviousAdvanced Memory SegmentsNext >>>

The Solution

The .data and .text + commands can take a label name after them—this names a new + segment. We'll define a new segment + called zp (for "zero page") and + have our zero-page variables be placed there. We can't actually + use the default origin of $0000 here either, though, because the + Commodore 64 reserves memory locations 0 and 1 to control its + memory mappers: + 

.data zp
+.org $0002

Now, actually, the rest of the zero page is reserved too: + locations $02-$7F are used by the BASIC interpreter, and + locations $80-$FF are used by the KERNAL. We don't need the + BASIC interpreter, though, so we can back up all of $02-$7F at + the start of our program and restore it all when we're done: + 

.scope
+        ; Cache BASIC's zero page at top of available RAM.
+        ldx #$7E
+*       lda $01, x
+        sta $CF81, x
+        dex
+        bne -
+
+        jsr _main
+
+        ; Restore BASIC's zero page and return control.
+
+        ldx #$7E
+*       lda $CF81, x
+        sta $01, x
+        dex
+        bne -
+        rts
+
+_main:
+        ; _main points at the start of the real program,
+        ; which is actually outside of this scope
+.scend

The new, improved header file is c64-2.oph. +

Our print'str routine is then rewritten to + declare and use a zero-page variable, like so: + 

; PRINTSTR routine.  Accumulator stores the low byte of the address,
+; X register stores the high byte.  Destroys the values of $10 and
+; $11.
+
+.scope
+.data zp
+.space _ptr 2
+.text
+printstr:
+        sta _ptr
+        stx _ptr+1
+        ldy #$00
+_lp:    lda (_ptr),y
+        beq _done
+        jsr chrout
+        iny
+        bne _lp
+_done:  rts
+.scend

Also, we ought to put in an extra check to make sure our + zero-page allocations don't overflow, either: + 

.data zp
+.checkpc $80

That concludes our tour. The final source file + is tutor7.oph. +

<<< PreviousHomeNext >>>
Advanced Memory SegmentsUpWhere to go from here
\ No newline at end of file diff --git a/site/manual/x449.html b/site/manual/x449.html new file mode 100644 index 0000000..51ac5c9 --- /dev/null +++ b/site/manual/x449.html @@ -0,0 +1,162 @@ + +Where to go from here
Programming with Ophis
<<< PreviousAdvanced Memory SegmentsNext >>>

Where to go from here

This tutorial has touched on everything that the assembler can + do, but it's not really well organized as a + reference. the Appendix called Ophis Command Reference is a better place to look + up matters of syntax or consult lists of available commands. +

If you're looking for projects to undertake, the Commodore 64 + and Atari 2600 development communities are both very strong, and + the Apple II and NES development communities are still alive and + well as well. There's an annual Minigame Competition that's + always looking for new entries. +

<<< PreviousHomeNext >>>
The SolutionUpExample Programs
\ No newline at end of file diff --git a/site/manual/x461.html b/site/manual/x461.html new file mode 100644 index 0000000..f709075 --- /dev/null +++ b/site/manual/x461.html @@ -0,0 +1,183 @@ + +tutor2.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor2.oph

.word $0801
+.org  $0801
+
+.scope
+        .word _next, 10         ; Next line and current line number
+        .byte $9e," 2064",0     ; SYS 2064
+_next:  .word 0                 ; End of program
+.scend
+
+.advance 2064
+
+.alias chrout $ffd2
+
+        ldx #0
+*       lda hello, x
+        beq +
+        jsr chrout
+        inx
+        bne -
+*       rts
+
+hello:  .byte "HELLO, WORLD!", 0
<<< PreviousHomeNext >>>
Example ProgramsUpc64-1.oph
\ No newline at end of file diff --git a/site/manual/x465.html b/site/manual/x465.html new file mode 100644 index 0000000..72ecc11 --- /dev/null +++ b/site/manual/x465.html @@ -0,0 +1,176 @@ + +c64-1.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

c64-1.oph

.word $0801
+.org  $0801
+
+.scope
+        .word _next, 10         ; Next line and current line number
+        .byte $9e," 2064",0     ; SYS 2064
+_next:  .word 0                 ; End of program
+.scend
+
+.advance 2064
+
+.require "kernal.oph"
<<< PreviousHomeNext >>>
tutor2.ophUpkernal.oph
\ No newline at end of file diff --git a/site/manual/x469.html b/site/manual/x469.html new file mode 100644 index 0000000..526cb88 --- /dev/null +++ b/site/manual/x469.html @@ -0,0 +1,231 @@ + +kernal.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

kernal.oph

; KERNAL routine aliases (C64)
+
+.alias acptr  $ffa5
+.alias chkin  $ffc6
+.alias chkout $ffc9
+.alias chrin  $ffcf
+.alias chrout $ffd2
+.alias ciout  $ffa8
+.alias cint   $ff81
+.alias clall  $ffe7
+.alias close  $ffc3
+.alias clrchn $ffcc
+.alias getin  $ffe4
+.alias iobase $fff3
+.alias ioinit $ff84
+.alias listen $ffb1
+.alias load   $ffd5
+.alias membot $ff9c
+.alias memtop $ff99
+.alias open   $ffc0
+.alias plot   $fff0
+.alias ramtas $ff87
+.alias rdtim  $ffde
+.alias readst $ffb7
+.alias restor $ff8a
+.alias save   $ffd8
+.alias scnkey $ff9f
+.alias screen $ffed
+.alias second $ff93
+.alias setlfs $ffba
+.alias setmsg $ff90
+.alias setnam $ffbd
+.alias settim $ffdb
+.alias settmo $ffa2
+.alias stop   $ffe1
+.alias talk   $ffb4
+.alias tksa   $ff96
+.alias udtim  $ffea
+.alias unlsn  $ffae
+.alias untlk  $ffab
+.alias vector $ff8d
+
+; Character codes for the colors.
+.alias color'0 144
+.alias color'1 5
+.alias color'2 28
+.alias color'3 159
+.alias color'4 156
+.alias color'5 30
+.alias color'6 31
+.alias color'7 158
+.alias color'8 129
+.alias color'9 149
+.alias color'10 150
+.alias color'11 151
+.alias color'12 152
+.alias color'13 153
+.alias color'14 154
+.alias color'15 155
+
+; ...and reverse video
+.alias reverse'on 18
+.alias reverse'off 146
+
+; ...and character set
+.alias upper'case 142
+.alias lower'case 14
<<< PreviousHomeNext >>>
c64-1.ophUptutor3.oph
\ No newline at end of file diff --git a/site/manual/x473.html b/site/manual/x473.html new file mode 100644 index 0000000..f349b39 --- /dev/null +++ b/site/manual/x473.html @@ -0,0 +1,209 @@ + +tutor3.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor3.oph

.include "c64-1.oph"
+
+.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend
+
+.macro greet
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+        rts
+
+hello1: .byte "HELLO, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "PROGRAMMER", 0
+target2:  .byte "ROOM", 0
+target3:  .byte "BUILDING", 0
+target4:  .byte "NEIGHBORHOOD", 0
+target5:  .byte "CITY", 0
+target6:  .byte "NATION", 0
+target7:  .byte "WORLD", 0
+target8:  .byte "SOLAR SYSTEM", 0
+target9:  .byte "GALAXY", 0
+target10: .byte "UNIVERSE", 0
<<< PreviousHomeNext >>>
kernal.ophUptutor4a.oph
\ No newline at end of file diff --git a/site/manual/x477.html b/site/manual/x477.html new file mode 100644 index 0000000..8110a3a --- /dev/null +++ b/site/manual/x477.html @@ -0,0 +1,230 @@ + +tutor4a.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor4a.oph

.include "c64-1.oph"
+
+.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+        rts
+
+hello1: .byte "HELLO, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "PROGRAMMER", 0
+target2:  .byte "ROOM", 0
+target3:  .byte "BUILDING", 0
+target4:  .byte "NEIGHBORHOOD", 0
+target5:  .byte "CITY", 0
+target6:  .byte "NATION", 0
+target7:  .byte "WORLD", 0
+target8:  .byte "SOLAR SYSTEM", 0
+target9:  .byte "GALAXY", 0
+target10: .byte "UNIVERSE", 0
+
+; DELAY routine.  Executes 2,560*(A) NOP statements.
+delay:  tax
+        ldy #00
+*       nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        iny
+        bne -
+        dex
+        bne -
+        rts
<<< PreviousHomeNext >>>
tutor3.ophUptutor4b.oph
\ No newline at end of file diff --git a/site/manual/x481.html b/site/manual/x481.html new file mode 100644 index 0000000..2fa5d2a --- /dev/null +++ b/site/manual/x481.html @@ -0,0 +1,232 @@ + +tutor4b.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor4b.oph

.include "c64-1.oph"
+
+.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        lda #lower'case
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+        rts
+
+hello1: .byte "Hello, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "programmer", 0
+target2:  .byte "room", 0
+target3:  .byte "building", 0
+target4:  .byte "neighborhood", 0
+target5:  .byte "city", 0
+target6:  .byte "nation", 0
+target7:  .byte "world", 0
+target8:  .byte "Solar System", 0
+target9:  .byte "Galaxy", 0
+target10: .byte "Universe", 0
+
+; DELAY routine.  Executes 2,560*(A) NOP statements.
+delay:  tax
+        ldy #00
+*       nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        iny
+        bne -
+        dex
+        bne -   
+        rts
<<< PreviousHomeNext >>>
tutor4a.ophUptutor4c.oph
\ No newline at end of file diff --git a/site/manual/x485.html b/site/manual/x485.html new file mode 100644 index 0000000..fa90f3e --- /dev/null +++ b/site/manual/x485.html @@ -0,0 +1,235 @@ + +tutor4c.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor4c.oph

.include "c64-1.oph"
+
+.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        lda #lower'case
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+        rts
+
+.charmap 'A, "abcdefghijklmnopqrstuvwxyz"
+.charmap 'a, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+hello1: .byte "Hello, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "programmer", 0
+target2:  .byte "room", 0
+target3:  .byte "building", 0
+target4:  .byte "neighborhood", 0
+target5:  .byte "city", 0
+target6:  .byte "nation", 0
+target7:  .byte "world", 0
+target8:  .byte "Solar System", 0
+target9:  .byte "Galaxy", 0
+target10: .byte "Universe", 0
+
+; DELAY routine.  Executes 2,560*(A) NOP statements.
+delay:  tax
+        ldy #00
+*       nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        iny
+        bne -
+        dex
+        bne -
+        rts
<<< PreviousHomeNext >>>
tutor4b.ophUptutor5.oph
\ No newline at end of file diff --git a/site/manual/x489.html b/site/manual/x489.html new file mode 100644 index 0000000..7ca3855 --- /dev/null +++ b/site/manual/x489.html @@ -0,0 +1,239 @@ + +tutor5.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor5.oph

.include "c64-1.oph"
+
+.data
+.org $C000
+.text
+
+.macro print
+        ldx #0
+_loop:  lda _1, x
+        beq _done
+        jsr chrout
+        inx
+        bne _loop
+_done:
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+        rts
+
+hello1: .byte "HELLO, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "PROGRAMMER", 0
+target2:  .byte "ROOM", 0
+target3:  .byte "BUILDING", 0
+target4:  .byte "NEIGHBORHOOD", 0
+target5:  .byte "CITY", 0
+target6:  .byte "NATION", 0
+target7:  .byte "WORLD", 0
+target8:  .byte "SOLAR SYSTEM", 0
+target9:  .byte "GALAXY", 0
+target10: .byte "UNIVERSE", 0
+
+; DELAY routine.  Takes values from the Accumulator and pauses
+; for that many jiffies (1/60th of a second).
+.scope
+.data
+.space _tmp 1
+.space _target 1
+
+.text
+
+delay:  sta _tmp        ; save argument (rdtim destroys it)
+        jsr rdtim
+        clc
+        adc _tmp        ; add current time to get target
+        sta _target
+*       jsr rdtim
+        cmp _target
+        bmi -           ; Buzz until target reached
+        rts
+.scend
+
+.checkpc $A000
+.data
+.checkpc $D000
<<< PreviousHomeNext >>>
tutor4c.ophUptutor6.oph
\ No newline at end of file diff --git a/site/manual/x493.html b/site/manual/x493.html new file mode 100644 index 0000000..28b3f1b --- /dev/null +++ b/site/manual/x493.html @@ -0,0 +1,266 @@ + +tutor6.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor6.oph

.include "c64-1.oph"
+
+.data
+.org $C000
+.space cache 2
+.text
+
+.macro print
+        lda #<_1
+        ldx #>_1
+        jsr printstr
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        ; Save the zero page locations that PRINTSTR uses.
+        lda $10
+        sta cache
+        lda $11
+        sta cache+1
+
+        lda #147
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+
+        ; Restore the zero page values printstr uses.
+        lda cache
+        sta $10
+        lda cache+1
+        sta $11
+
+        rts
+
+hello1: .byte "HELLO, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "PROGRAMMER", 0
+target2:  .byte "ROOM", 0
+target3:  .byte "BUILDING", 0
+target4:  .byte "NEIGHBORHOOD", 0
+target5:  .byte "CITY", 0
+target6:  .byte "NATION", 0
+target7:  .byte "WORLD", 0
+target8:  .byte "SOLAR SYSTEM", 0
+target9:  .byte "GALAXY", 0
+target10: .byte "UNIVERSE", 0
+
+; DELAY routine.  Takes values from the Accumulator and pauses
+; for that many jiffies (1/60th of a second).
+.scope
+.data
+.space _tmp 1
+.space _target 1
+
+.text
+
+delay:  sta _tmp        ; save argument (rdtim destroys it)
+        jsr rdtim
+        clc
+        adc _tmp        ; add current time to get target
+        sta _target
+*       jsr rdtim
+        cmp _target
+        bmi -           ; Buzz until target reached
+        rts
+.scend
+
+; PRINTSTR routine.  Accumulator stores the low byte of the address,
+; X register stores the high byte.  Destroys the values of $10 and
+; $11.
+
+.scope
+printstr:
+        sta $10
+        stx $11
+        ldy #$00
+_lp:    lda ($10),y
+        beq _done
+        jsr chrout
+        iny
+        bne _lp
+_done:  rts
+.scend
+
+.checkpc $A000
+.data
+.checkpc $D000
<<< PreviousHomeNext >>>
tutor5.ophUpc64-2.oph
\ No newline at end of file diff --git a/site/manual/x497.html b/site/manual/x497.html new file mode 100644 index 0000000..c07873f --- /dev/null +++ b/site/manual/x497.html @@ -0,0 +1,204 @@ + +c64-2.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

c64-2.oph

.word $0801
+.org  $0801
+
+.scope
+        .word _next, 10         ; Next line and current line number
+        .byte $9e," 2064",0     ; SYS 2064
+_next:  .word 0                 ; End of program
+.scend
+
+.advance $0810
+
+.require "kernal.oph"
+
+.data zp
+.org $0002
+
+.text
+
+.scope
+        ; Cache BASIC's zero page at top of available RAM.
+        ldx #$7E
+*       lda $01, x
+        sta $CF81, x
+        dex
+        bne -
+
+        jsr _main
+
+        ; Restore BASIC's zero page and return control.
+
+        ldx #$7E
+*       lda $CF81, x
+        sta $01, x
+        dex
+        bne -
+        rts
+
+_main:
+        ; Program follows...
+.scend
<<< PreviousHomeNext >>>
tutor6.ophUptutor7.oph
\ No newline at end of file diff --git a/site/manual/x501.html b/site/manual/x501.html new file mode 100644 index 0000000..2d51914 --- /dev/null +++ b/site/manual/x501.html @@ -0,0 +1,257 @@ + +tutor7.oph
Programming with Ophis
<<< PreviousExample ProgramsNext >>>

tutor7.oph

.include "c64-2.oph"
+
+.data
+.org $C000
+.text
+
+.macro print
+        lda #<_1
+        ldx #>_1
+        jsr printstr
+.macend
+
+.macro greet
+        lda #30
+        jsr delay
+        `print hello1
+        `print _1
+        `print hello2
+.macend
+
+        lda #147
+        jsr chrout
+        `greet target1
+        `greet target2
+        `greet target3
+        `greet target4
+        `greet target5
+        `greet target6
+        `greet target7
+        `greet target8
+        `greet target9
+        `greet target10
+
+        rts
+
+hello1: .byte "HELLO, ",0
+hello2: .byte "!", 13, 0
+
+target1:  .byte "PROGRAMMER", 0
+target2:  .byte "ROOM", 0
+target3:  .byte "BUILDING", 0
+target4:  .byte "NEIGHBORHOOD", 0
+target5:  .byte "CITY", 0
+target6:  .byte "NATION", 0
+target7:  .byte "WORLD", 0
+target8:  .byte "SOLAR SYSTEM", 0
+target9:  .byte "GALAXY", 0
+target10: .byte "UNIVERSE", 0
+
+; DELAY routine.  Takes values from the Accumulator and pauses
+; for that many jiffies (1/60th of a second).
+.scope
+.data
+.space _tmp 1
+.space _target 1
+
+.text
+
+delay:  sta _tmp        ; save argument (rdtim destroys it)
+        jsr rdtim
+        clc
+        adc _tmp        ; add current time to get target
+        sta _target
+*       jsr rdtim
+        cmp _target
+        bmi -           ; Buzz until target reached
+        rts
+.scend
+
+; PRINTSTR routine.  Accumulator stores the low byte of the address,
+; X register stores the high byte.  Destroys the values of $10 and
+; $11.
+
+.scope
+.data zp
+.space _ptr 2
+.text
+printstr:
+        sta _ptr
+        stx _ptr+1
+        ldy #$00
+_lp:    lda (_ptr),y
+        beq _done
+        jsr chrout
+        iny
+        bne _lp
+_done:  rts
+.scend
+
+.checkpc $A000
+
+.data
+.checkpc $D000
+
+.data zp
+.checkpc $80
<<< PreviousHomeNext >>>
c64-2.ophUpOphis Command Reference
\ No newline at end of file diff --git a/site/manual/x51.html b/site/manual/x51.html new file mode 100644 index 0000000..c45fb2d --- /dev/null +++ b/site/manual/x51.html @@ -0,0 +1,428 @@ + +Producing Commodore 64 programs
Programming with Ophis
<<< PreviousThe basicsNext >>>

Producing Commodore 64 programs

Commodore 64 programs are stored in + the PRG format on disk. Some emulators + (such as CCS64 or VICE) can run PRG + programs directly; others need them to be transferred to + a D64 image first. +

The PRG format is ludicrously simple. It + has two bytes of header data: This is a little-endian number + indicating the starting address. The rest of the file is a + single continuous chunk of data loaded into memory, starting at + that address. BASIC memory starts at memory location 2048, and + that's probably where we'll want to start. +

Well, not quite. We want our program to be callable from BASIC, + so we should have a BASIC program at the start. We guess the + size of a simple one line BASIC program to be about 16 bytes. + Thus, we start our program at memory location 2064 ($0810), and + the BASIC program looks like this: + 

10 SYS 2064
+

We SAVE this program to a file, then + study it in a debugger. It's 15 bytes long: + 

1070:0100  01 08 0C 08 0A 00 9E 20-32 30 36 34 00 00 00
+

The first two bytes are the memory location: $0801. The rest of + the data breaks down as follows: +

Table 1. BASIC program breakdown

Memory LocationsValue
$0801-$08022-byte pointer to the next line of BASIC code ($080C).
$0803-$08042-byte line number ($000A = 10).
$0805Byte code for the SYS command.
$0806-$080AThe rest of the line, which is just the string " 2064".
$080BNull byte, terminating the line.
$080C-$080D2-byte pointer to the next line of BASIC code ($0000 = end of program).

That's 13 bytes. We started at 2049, so we need 2 more bytes of + filler to make our code actually start at location 2064. These + 17 bytes will give us the file format and the BASIC code we need + to have our machine language program run. +

These are just bytes—indistinguishable from any other sort of + data. In Ophis, bytes of data are specified with + the .byte command. We'll also have to tell + Ophis what the program counter should be, so that it knows what + values to assign to our labels. The .org + (origin) command tells Ophis this. Thus, the Ophis code for our + header and linking info is: + 

.byte $01, $08, $0C, $08, $0A, $00, $9E, $20
+.byte $32, $30, $36, $34, $00, $00, $00, $00
+.byte $00, $00
+.org $0810
+

This gets the job done, but it's completely incomprehensible, + and it only uses two directives—not very good for a + tutorial. Here's a more complicated, but much clearer, way of + saying the same thing. + 

.word $0801
+.org  $0801
+
+        .word next, 10       ; Next line and current line number
+        .byte $9e," 2064",0  ; SYS 2064
+next:   .word 0              ; End of program
+
+.advance 2064
+

This code has many advantages over the first. + +

+

<<< PreviousHomeNext >>>
The basicsUpRelated commands and options
\ No newline at end of file diff --git a/site/manual/x572.html b/site/manual/x572.html new file mode 100644 index 0000000..796dbc2 --- /dev/null +++ b/site/manual/x572.html @@ -0,0 +1,309 @@ + +Basic arguments
Programming with Ophis
<<< PreviousOphis Command ReferenceNext >>>

Basic arguments

Most arguments are just a number or label. The formats for + these are below. +

Numeric types

Label types

Normal labels are simply referred to by name. Anonymous + labels may be referenced with strings of - or + signs (the + label - refers to the immediate + previous anonymous label, -- the + one before that, etc., while + + refers to the next anonymous label), and the special + label ^ refers to the program + counter at the start of the current instruction or directive. +

Normal labels are defined by + prefixing a line with the label name and then a colon + (e.g., label:). Anonymous labels + are defined by prefixing a line with an asterisk + (e.g., *). +

Temporary labels are only reachable from inside the + innermost enclosing .scope + statement. They are identical to normal labels in every + way, except that they start with an underscore. +

String types

Strings are enclosed in double quotation marks. Backslashed + characters (including backslashes and double quotes) are + treated literally, so the string "The man said, + \"The \\ character is the backslash.\"" produces + the ASCII sequence for The man said, "The \ + character is the backslash." +

Strings are generally only used as arguments to assembler + directives—usually for filenames + (e.g., .include) but also for string + data (in association with .byte). +

It is legal, though unusual, to attempt to pass a string to + the other data statements. This will produces a series of + words/dwords where all bytes that aren't least-significant + are zero. Endianness and size will match what the directive + itself indicated. +

<<< PreviousHomeNext >>>
Ophis Command ReferenceUpCompound Arguments
\ No newline at end of file diff --git a/site/manual/x620.html b/site/manual/x620.html new file mode 100644 index 0000000..753c8a4 --- /dev/null +++ b/site/manual/x620.html @@ -0,0 +1,212 @@ + +Compound Arguments
Programming with Ophis
<<< PreviousOphis Command ReferenceNext >>>

Compound Arguments

Compound arguments may be built up from simple ones, using the + standard +, -, *, and / operators, which carry the usual + precedence. Also, the unary operators > and <, which + bind more tightly than anything else, provide the high and low + bytes of 16-bit values, respectively. +

Use brackets [ ] instead of parentheses ( ) when grouping + arithmetic operations, as the parentheses are needed for the + indirect addressing modes. +

Examples: +

<<< PreviousHomeNext >>>
Basic argumentsUpMemory Model
\ No newline at end of file diff --git a/site/manual/x647.html b/site/manual/x647.html new file mode 100644 index 0000000..61ac742 --- /dev/null +++ b/site/manual/x647.html @@ -0,0 +1,373 @@ + +Memory Model
Programming with Ophis
<<< PreviousOphis Command ReferenceNext >>>

Memory Model

In order to properly compute the locations of labels and the + like, Ophis must keep track of where assembled code will + actually be sitting in memory, and it strives to do this in a + way that is independent both of the target file and of the + target machine. +

Basic PC tracking

The primary technique Ophis uses is program counter + tracking. As it assembles the code, it keeps + track of a virtual program counter, and uses that to + determine where the labels should go. +

In the absence of an .org directive, it + assumes a starting PC of zero. .org + is a simple directive, setting the PC to the value + that .org specifies. In the simplest + case, one .org directive appears at the + beginning of the code and sets the location for the rest of + the code, which is one contiguous block. +

Basic Segmentation simulation

However, this isn't always practical. Often one wishes to + have a region of memory reserved for data without actually + mapping that memory to the file. On some systems (typically + cartridge-based systems where ROM and RAM are seperate, and + the target file only specifies the ROM image) this is + mandatory. In order to access these variables symbolically, + it's necessary to put the values into the label lookup + table. +

It is possible, but inconvenient, to do this + with .alias, assigning a specific + memory location to each variable. This requires careful + coordination through your code, and makes creating reusable + libraries all but impossible. +

A better approach is to reserve a section at the beginning + or end of your program, put an .org + directive in, then use the .space + directive to divide up the data area. This is still a bit + inconvenient, though, because all variables must be + assigned all at once. What we'd really like is to keep + multiple PC counters, one for data and one for code. +

The .text + and .data directives do this. Each + has its own PC that starts at zero, and you can switch + between the two at any point without corrupting the other's + counter. In this way each function can have + a .data section (filled + with .space commands) and + a .text section (that contains the + actual code). This lets our library routines be almost + completely self-contained - we can have one source file + that could be .included by multiple + projects without getting in anything's way. +

However, any given program may have its own ideas about + where data and code go, and it's good to ensure with + a .checkpc at the end of your code + that you haven't accidentally overwritten code with data or + vice versa. If your .data + segment did start at zero, it's + probably wise to make sure you aren't smashing the stack, + too (which is sitting in the region from $0100 to + $01FF). +

If you write code with no segment-defining statements in + it, the default segment + is text. +

The data segment is designed only + for organizing labels. As such, errors will be flagged if + you attempt to actually output information into + a data segment. +

General Segmentation Simulation

One text and data segment each is usually sufficient, but + for the cases where it is not, Ophis allows for user-defined + segments. Putting a label + after .text + or .data produces a new segment with + the specified name. +

Say, for example, that we have access to the RAM at the low + end of the address space, but want to reserve the zero page + for truly critical variables, and use the rest of RAM for + everything else. Let's also assume that this is a 6510 + chip, and locations $00 and $01 are reserved for the I/O + port. We could start our program off with: + 

.data
+.org $200
+.data zp
+.org $2
+.text
+.org $800

And, to be safe, we would probably want to end our code + with checks to make sure we aren't overwriting anything: + 

.data
+.checkpc $800
+.data zp
+.checkpc $100
<<< PreviousHomeNext >>>
Compound ArgumentsUpMacros
\ No newline at end of file diff --git a/site/manual/x692.html b/site/manual/x692.html new file mode 100644 index 0000000..263921a --- /dev/null +++ b/site/manual/x692.html @@ -0,0 +1,358 @@ + +Macros
Programming with Ophis
<<< PreviousOphis Command ReferenceNext >>>

Macros

Assembly language is a powerful tool—however, there are + many tasks that need to be done repeatedly, and with + mind-numbing minor modifications. Ophis includes a facility + for macros to allow this. Ophis macros + are very similar in form to function calls in higher level + languages. +

Defining Macros

Macros are defined with the .macro + and .macend commands. Here's a + simple one that will clear the screen on a Commodore + 64: + 

.macro clr'screen
+    lda #147
+    jsr $FFD2
+.macend

Invoking Macros

To invoke a macro, either use + the .invoke command or backquote the + name of the routine. The previous macro may be expanded + out in either of two ways, at any point in the + source: + 

.invoke clr'screen

or

`clr'screen

will work equally well.

Passing Arguments to Macros

Macros may take arguments. The arguments to a macro are + all of the "word" type, though byte values may + be passed and used as bytes as well. The first argument in + an invocation is bound to the label + _1, the second + to _2, and so on. Here's a macro + for storing a 16-bit value into a word pointer: + 

.macro store16   ; `store16 dest, src
+	lda #<_2
+	sta _1
+	lda #>_2
+	sta _1+1
+.macend

Macro arguments behave, for the most part, as if they were + defined by .alias + commands in the calling context. + (They differ in that they will not produce duplicate-label + errors if those names already exist in the calling scope, + and in that they disappear after the call is + completed.) +

Features and Restrictions of the Ophis Macro Model

Unlike most macro systems (which do textual replacement), + Ophis macros evaluate their arguments and bind them into the + symbol table as temporary labels. This produces some + benefits, but it also puts some restrictions on what kinds of + macros may be defined. +

The primary benefit of this "expand-via-binding" + discipline is that there are no surprises in the semantics. + The expression _1+1 in the macro above + will always evaluate to one more than the value that was + passed as the first argument, even if that first argument is + some immensely complex expression that an + expand-via-substitution method may accidentally + mangle. +

The primary disadvantage of the expand-via-binding + discipline is that only fixed numbers of words and bytes + may be passed. A substitution-based system could define a + macro including the line LDA _1 and + accept as arguments both $C000 + (which would put the value of memory location $C000 into + the accumulator) and #$40 (which + would put the immediate value $40 into the accumulator). + If you really need this kind of + behavior, a run a C preprocessor over your Ophis source, + and use #define to your heart's + content. +

<<< PreviousHomeNext >>>
Memory ModelUpAssembler directives
\ No newline at end of file diff --git a/site/manual/x732.html b/site/manual/x732.html new file mode 100644 index 0000000..513e1fa --- /dev/null +++ b/site/manual/x732.html @@ -0,0 +1,595 @@ + +Assembler directives
Programming with Ophis
<<< PreviousOphis Command Reference 

Assembler directives

Assembler directives are all instructions to the assembler + that are not actual instructions. Ophis's set of directives + follow. +

The following directives are deprecated, added for + compatibility with the old Perl + assembler P65. Use + the -d option to Ophis to enable + them. +

<<< PreviousHome 
MacrosUp 
\ No newline at end of file diff --git a/site/ophismanual.pdf b/site/ophismanual.pdf new file mode 100644 index 0000000..a399c66 Binary files /dev/null and b/site/ophismanual.pdf differ diff --git a/src/Ophis/CmdLine.py b/src/Ophis/CmdLine.py new file mode 100644 index 0000000..b3e3a54 --- /dev/null +++ b/src/Ophis/CmdLine.py @@ -0,0 +1,17 @@ +"""Command line options data. + + verbose: + 0: Only report errors + 1: Announce each file as it is read, and data count (default) + 2: As above, but also announce each pass. + 3: As above, but print the IR after each pass. + 4: As above, but print the labels after each pass. + + 6510 compatibility and deprecation are handled in Ophis.Main.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +verbose = 1; + diff --git a/src/Ophis/CorePragmas.py b/src/Ophis/CorePragmas.py new file mode 100644 index 0000000..f4737f5 --- /dev/null +++ b/src/Ophis/CorePragmas.py @@ -0,0 +1,202 @@ +"""Core pragmas + + Provides the core assembler directives. It does not guarantee + compatibility with older versions of P65-Perl.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +from __future__ import nested_scopes + +import Ophis.IR as IR +import Ophis.Frontend as FE +import Ophis.Errors as Err + +loadedfiles={} +basecharmap = "".join([chr(x) for x in range(256)]) +currentcharmap = basecharmap + +def reset(): + global loadedfiles, currentcharmap, basecharmap + loadedfiles={} + currentcharmap = basecharmap + +def pragmaInclude(ppt, line, result): + "Includes a source file" + filename = line.expect("STRING").value + line.expect("EOL") + if type(filename)==str: result.append(FE.parse_file(ppt, filename)) + +def pragmaRequire(ppt, line, result): + "Includes a source file at most one time" + filename = line.expect("STRING").value + line.expect("EOL") + if type(filename)==str: + global loadedfiles + if filename not in loadedfiles: + loadedfiles[filename]=1 + result.append(FE.parse_file(ppt, filename)) + +def pragmaIncbin(ppt, line, result): + "Includes a binary file" + filename = line.expect("STRING").value + line.expect("EOL") + if type(filename)==str: + f = file(filename, "rb") + bytes = f.read() + f.close() + bytes = [IR.ConstantExpr(ord(x)) for x in bytes] + result.append(IR.Node(ppt, "Byte", *bytes)) + +def pragmaCharmap(ppt, line, result): + "Modify the character map." + global currentcharmap, basecharmap + bytes = readData(line) + if len(bytes) == 0: + currentcharmap = basecharmap + else: + try: + base = bytes[0].data + newsubstr = "".join([chr(x.data) for x in bytes[1:]]) + currentcharmap = currentcharmap[:base] + newsubstr + currentcharmap[base+len(newsubstr):] + if len(currentcharmap) != 256 or base < 0 or base > 255: + Err.log("Charmap replacement out of range") + currentcharmap = currentcharmap[:256] + except ValueError: + Err.log("Illegal character in .charmap directive") + +def pragmaCharmapbin(ppt, line, result): + "Load a new character map from a file" + global currentcharmap + filename = line.expect("STRING").value + line.expect("EOL") + if type(filename)==str: + f = file(filename, "rb") + bytes = f.read() + f.close() + if len(bytes)==256: + currentcharmap = bytes + else: + Err.log("Character map "+filename+" not 256 bytes long") + +def pragmaOrg(ppt, line, result): + "Relocates the PC with no output" + newPC = FE.parse_expr(line) + line.expect("EOL") + result.append(IR.Node(ppt, "SetPC", newPC)) + +def pragmaAdvance(ppt, line, result): + "Outputs filler until reaching the target PC" + newPC = FE.parse_expr(line) + line.expect("EOL") + result.append(IR.Node(ppt, "Advance", newPC)) + +def pragmaCheckpc(ppt, line, result): + "Enforces that the PC has not exceeded a certain point" + target = FE.parse_expr(line) + line.expect("EOL") + result.append(IR.Node(ppt, "CheckPC", target)) + +def pragmaAlias(ppt, line, result): + "Assigns an arbitrary label" + lbl = line.expect("LABEL").value + target = FE.parse_expr(line) + result.append(IR.Node(ppt, "Label", lbl, target)) + +def pragmaSpace(ppt, line, result): + "Reserves space in a data segment for a variable" + lbl = line.expect("LABEL").value + size = line.expect("NUM").value + line.expect("EOL") + result.append(IR.Node(ppt, "Label", lbl, IR.PCExpr())) + result.append(IR.Node(ppt, "SetPC", IR.SequenceExpr([IR.PCExpr(), "+", IR.ConstantExpr(size)]))) + +def pragmaText(ppt, line, result): + "Switches to a text segment" + next = line.expect("LABEL", "EOL") + if next.type == "LABEL": + line.expect("EOL") + segment = next.value + else: + segment = "*text-default*" + result.append(IR.Node(ppt, "TextSegment", segment)) + +def pragmaData(ppt, line, result): + "Switches to a data segment (no output allowed)" + next = line.expect("LABEL", "EOL") + if next.type == "LABEL": + line.expect("EOL") + segment = next.value + else: + segment = "*data-default*" + result.append(IR.Node(ppt, "DataSegment", segment)) + +def readData(line): + "Read raw data from a comma-separated list" + if line.lookahead(0).type == "STRING": + data = [IR.ConstantExpr(ord(x)) for x in line.expect("STRING").value.translate(currentcharmap)] + else: + data = [FE.parse_expr(line)] + next = line.expect(',', 'EOL').type + while next == ',': + if line.lookahead(0).type == "STRING": + data.extend([IR.ConstantExpr(ord(x)) for x in line.expect("STRING").value]) + else: + data.append(FE.parse_expr(line)) + next = line.expect(',', 'EOL').type + return data + +def pragmaByte(ppt, line, result): + "Raw data, a byte at a time" + bytes = readData(line) + result.append(IR.Node(ppt, "Byte", *bytes)) + +def pragmaWord(ppt, line, result): + "Raw data, a word at a time, little-endian" + words = readData(line) + result.append(IR.Node(ppt, "Word", *words)) + +def pragmaDword(ppt, line, result): + "Raw data, a double-word at a time, little-endian" + dwords = readData(line) + result.append(IR.Node(ppt, "Dword", *dwords)) + +def pragmaWordbe(ppt, line, result): + "Raw data, a word at a time, big-endian" + words = readData(line) + result.append(IR.Node(ppt, "WordBE", *words)) + +def pragmaDwordbe(ppt, line, result): + "Raw data, a dword at a time, big-endian" + dwords = readData(line) + result.append(IR.Node(ppt, "DwordBE", *dwords)) + +def pragmaScope(ppt, line, result): + "Create a new lexical scoping block" + line.expect("EOL") + result.append(IR.Node(ppt, "ScopeBegin")) + +def pragmaScend(ppt, line, result): + "End the innermost lexical scoping block" + line.expect("EOL") + result.append(IR.Node(ppt, "ScopeEnd")) + +def pragmaMacro(ppt, line, result): + "Begin a macro definition" + lbl = line.expect("LABEL").value + line.expect("EOL") + result.append(IR.Node(ppt, "MacroBegin", lbl)) + +def pragmaMacend(ppt, line, result): + "End a macro definition" + line.expect("EOL") + result.append(IR.Node(ppt, "MacroEnd")) + +def pragmaInvoke(ppt, line, result): + macro = line.expect("LABEL").value + if line.lookahead(0).type == "EOL": + args = [] + else: + args = readData(line) + result.append(IR.Node(ppt, "MacroInvoke", macro, *args)) diff --git a/src/Ophis/Environment.py b/src/Ophis/Environment.py new file mode 100644 index 0000000..1308b3e --- /dev/null +++ b/src/Ophis/Environment.py @@ -0,0 +1,75 @@ +"""Symbol tables and environments for P65. + + Implements the symbol lookup, through nested environments - + any non-temporary variable is stored at the top level.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +from __future__ import nested_scopes +import Ophis.Errors as Err + +class Environment: + """Environment class. + Controls the various scopes and global abstract execution variables.""" + def __init__(self): + self.dicts = [{}] + self.stack = [0] + self.pc = 0 + self.segmentdict = {} + self.segment = "*text-default*" + self.scopecount = 0 + def __contains__(self, item): + if item[0] == '_': + for dict in [self.dicts[i] for i in self.stack]: + if item in dict: return 1 + return 0 + return item in self.dicts[0] + def __getitem__(self, item): + if item[0] == '_': + for dict in [self.dicts[i] for i in self.stack]: + if item in dict: return dict[item] + else: + if item in self.dicts[0]: return self.dicts[0][item] + Err.log("Unknown label '%s'" % item) + return 0 + def __setitem__(self, item, value): + if item[0] == '_': + self.dicts[self.stack[0]][item] = value + else: + self.dicts[0][item] = value + def __str__(self): + return str(self.dicts) + def getPC(self): + return self.pc + def setPC(self, value): + self.pc = value + def incPC(self, amount): + self.pc += amount + def getsegment(self): + return self.segment + def setsegment(self, segment): + self.segmentdict[self.segment] = self.pc + self.segment = segment + self.pc = self.segmentdict.get(segment, 0) + def reset(self): + "Clears out program counter, segment, and scoping information" + self.pc = 0 + self.segmentdict = {} + self.segment = "*text-default*" + self.scopecount = 0 + if len(self.stack) > 1: + Err.log("Unmatched .scope") + self.stack = [0] + def newscope(self): + "Enters a new scope for temporary labels." + self.scopecount += 1 + self.stack.insert(0, self.scopecount) + if len(self.dicts) <= self.scopecount: self.dicts.append({}) + def endscope(self): + "Leaves a scope." + if len(self.stack) == 1: + Err.log("Unmatched .scend") + self.stack.pop(0) + diff --git a/src/Ophis/Errors.py b/src/Ophis/Errors.py new file mode 100644 index 0000000..024d0f9 --- /dev/null +++ b/src/Ophis/Errors.py @@ -0,0 +1,24 @@ +"""Error logging + + Keeps track of the number of errors inflicted so far, and + where in the assembly the errors are occurring.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +count = 0 +currentpoint = "" + +def log(err): + """Reports an error at the current program point, and increases +the global error count.""" + global count + count = count+1 + print currentpoint+": "+err + +def report(): + "Print out the number of errors." + if count == 0: print "No errors" + elif count == 1: print "1 error" + else: print str(count)+" errors" \ No newline at end of file diff --git a/src/Ophis/Frontend.py b/src/Ophis/Frontend.py new file mode 100644 index 0000000..48e319b --- /dev/null +++ b/src/Ophis/Frontend.py @@ -0,0 +1,333 @@ +"""Lexer and Parser + + Constructs a list of IR nodes from a list of input strings.""" + +from __future__ import nested_scopes +import Ophis.Errors as Err +import Ophis.Opcodes as Ops +import Ophis.IR as IR +import Ophis.CmdLine as Cmd +import os + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + + +class Lexeme: + "Class for lexer tokens. Used by lexer and parser." + def __init__(self, type="UNKNOWN", value=None): + self.type = type.upper() + self.value = value + def __str__(self): + if self.value == None: + return self.type + else: + return self.type+":"+str(self.value) + def __repr__(self): + return "Lexeme("+`self.type`+", "+`self.value`+")" + def matches(self, other): + "1 if Lexemes a and b have the same type." + return self.type == other.type + +bases = {"$":("hexadecimal", 16), + "%":("binary", 2), + "0":("octal", 8)} + +punctuation = "#,`<>():.+-*/&|^[]" + +def lex(point, line): + """Turns a line of source into a sequence of lexemes.""" + Err.currentpoint = point + result = [] + def is_opcode(op): + "Tests whether a string is an opcode or an identifier" + return op in Ops.opcodes + def add_token(token): + "Converts a substring into a single lexeme" + if token == "": + return + if token == "0": + result.append(Lexeme("NUM", 0)) + return + firstchar = token[0] + rest = token[1:] + if firstchar == '"': + result.append(Lexeme("STRING", rest)) + return + elif firstchar in bases: + try: + result.append(Lexeme("NUM", long(rest, bases[firstchar][1]))) + return + except ValueError: + Err.log('Invalid '+bases[firstchar][0]+' constant: '+rest) + result.append(Lexeme("NUM", 0)) + return + elif firstchar.isdigit(): + try: + result.append(Lexeme("NUM", long(token))) + except ValueError: + Err.log('Identifiers may not begin with a number') + result.append(Lexeme("LABEL", "ERROR")) + return + elif firstchar == "'": + if len(rest) == 1: + result.append(Lexeme("NUM", ord(rest))) + else: + Err.log("Invalid character constant '"+rest+"'") + result.append(Lexeme("NUM", 0)) + return + elif firstchar in punctuation: + if rest != "": + Err.log("Internal lexer error! '"+token+"' can't happen!") + result.append(Lexeme(firstchar)) + return + else: # Label, opcode, or index register + id = token.lower() + if is_opcode(id): + result.append(Lexeme("OPCODE", id)) + elif id == "x": + result.append(Lexeme("X")) + elif id == "y": + result.append(Lexeme("Y")) + else: + result.append(Lexeme("LABEL", id)) + return + # should never reach here + Err.log("Internal lexer error: add_token fall-through") + def add_EOL(): + "Adds an end-of-line lexeme" + result.append(Lexeme("EOL")) + # Actual routine begins here + value = "" + quotemode = 0 + backslashmode = 0 + for c in line.strip(): + if backslashmode: + backslashmode = 0 + value = value + c + elif c == "\\": + backslashmode = 1 + elif quotemode: + if c == '"': + quotemode = 0 + else: + value = value + c + elif c == ';': + add_token(value) + value = "" + break + elif c.isspace(): + add_token(value) + value = "" + elif c in punctuation: + add_token(value) + add_token(c) + value = "" + elif c == '"': + add_token(value) + value = '"' + quotemode = 1 + else: + value = value + c + if backslashmode: + Err.log("Backslashed newline") + if quotemode: + Err.log("Unterminated string constant") + add_token(value) + add_EOL() + return result + +class ParseLine: + "Maintains the parse state of a line of code. Enables arbitrary lookahead." + def __init__(self, lexemes): + self.lexemes = lexemes + self.location = 0 + def lookahead(self, i): + """Returns the token i units ahead in the parse. + lookahead(0) returns the next token; trying to read off the end of + the sequence returns the last token in the sequence (usually EOL).""" + target = self.location+i + if target >= len(self.lexemes): target = -1 + return self.lexemes[target] + def pop(self): + "Returns and removes the next element in the line." + old = self.location + if self.location < len(self.lexemes)-1: self.location += 1 + return self.lexemes[old] + def expect(self, *tokens): + """Reads a token from the ParseLine line and returns it if it's of a type + in the sequence tokens. Otherwise, it logs an error.""" + token = self.pop() + if token.type not in tokens: + Err.log('Expected: "'+'", "'.join(tokens)+'"') + return token + +pragma_modules = [] + +def parse_expr(line): + "Parses an Ophis arithmetic expression." + def atom(): + "Parses lowest-priority expression components." + next = line.lookahead(0).type + if next == "NUM": + return IR.ConstantExpr(line.expect("NUM").value) + elif next == "LABEL": + return IR.LabelExpr(line.expect("LABEL").value) + elif next == "^": + line.expect("^") + return IR.PCExpr() + elif next == "[": + line.expect("[") + result = parse_expr(line) + line.expect("]") + return result + elif next == "+": + offset = 0 + while next == "+": + offset += 1 + line.expect("+") + next = line.lookahead(0).type + return IR.LabelExpr("*"+str(templabelcount+offset)) + elif next == "-": + offset = 1 + while next == "-": + offset -= 1 + line.expect("-") + next = line.lookahead(0).type + return IR.LabelExpr("*"+str(templabelcount+offset)) + elif next == ">": + line.expect(">") + return IR.HighByteExpr(atom()) + elif next == "<": + line.expect("<") + return IR.LowByteExpr(atom()) + else: + Err.log('Expected: expression') + def precedence_read(constructor, reader, separators): + """Handles precedence. The reader argument is a function that returns + expressions that bind more tightly than these; separators is a list + of strings naming the operators at this precedence level. The + constructor argument is a class, indicating what node type holds + objects of this precedence level. + + Returns a list of Expr objects with separator strings between them.""" + result = [reader()] # first object + nextop = line.lookahead(0).type + while (nextop in separators): + line.expect(nextop) + result.append(nextop) + result.append(reader()) + nextop = line.lookahead(0).type + if len(result) == 1: return result[0] + return constructor(result) + def term(): + "Parses * and /" + return precedence_read(IR.SequenceExpr, atom, ["*", "/"]) + def arith(): + "Parses + and -" + return precedence_read(IR.SequenceExpr, term, ["+", "-"]) + def bits(): + "Parses &, |, and ^" + return precedence_read(IR.SequenceExpr, arith, ["&", "|", "^"]) + return bits() + +def parse_line(ppt, lexemelist): + "Turn a line of source into an IR Node." + Err.currentpoint = ppt + result = [] + line = ParseLine(lexemelist) + def aux(): + "Accumulates all IR nodes defined by this line." + if line.lookahead(0).type == "EOL": + pass + elif line.lookahead(1).type == ":": + newlabel=line.expect("LABEL").value + line.expect(":") + result.append(IR.Node(ppt, "Label", newlabel, IR.PCExpr())) + aux() + elif line.lookahead(0).type == "*": + global templabelcount + templabelcount = templabelcount + 1 + result.append(IR.Node(ppt, "Label", "*"+str(templabelcount), IR.PCExpr())) + line.expect("*") + aux() + elif line.lookahead(0).type == "." or line.lookahead(0).type == "`": + which = line.expect(".", "`").type + if (which == "."): pragma = line.expect("LABEL").value + else: pragma = "invoke" + pragmaFunction = "pragma"+pragma.title() + for mod in pragma_modules: + if hasattr(mod, pragmaFunction): + getattr(mod, pragmaFunction)(ppt, line, result) + break + else: + Err.log("Unknown pragma "+pragma) + + else: # Instruction + opcode = line.expect("OPCODE").value + if line.lookahead(0).type == "#": + mode = "Immediate" + line.expect("#") + arg = parse_expr(line) + line.expect("EOL") + elif line.lookahead(0).type == "(": + line.expect("(") + arg = parse_expr(line) + if line.lookahead(0).type == ",": + mode = "PointerX" + line.expect(",") + line.expect("X") + line.expect(")") + line.expect("EOL") + else: + line.expect(")") + tok = line.expect(",", "EOL").type + if tok == "EOL": + mode = "Pointer" + else: + mode = "PointerY" + line.expect("Y") + line.expect("EOL") + elif line.lookahead(0).type == "EOL": + mode = "Implied" + arg = None + else: + arg = parse_expr(line) + tok = line.expect("EOL", ",").type + if tok == ",": + tok = line.expect("X", "Y").type + if tok == "X": mode = "MemoryX" + else: mode = "MemoryY" + line.expect("EOL") + else: mode = "Memory" + result.append(IR.Node(ppt, mode, opcode, arg)) + aux() + result = [node for node in result if node is not IR.NullNode] + if len(result) == 0: return IR.NullNode + if len(result) == 1: return result[0] + return IR.SequenceNode(ppt, result) + +def parse_file(ppt, filename): + "Loads a .P65 source file, and returns an IR list." + Err.currentpoint = ppt + if Cmd.verbose > 0: print "Loading "+filename + try: + f = file(filename) + linelist = f.readlines() + f.close() + pptlist = ["%s:%d" % (filename, i+1) for i in range(len(linelist))] + lexlist = map(lex, pptlist, linelist) + IRlist = map(parse_line, pptlist, lexlist) + IRlist = [node for node in IRlist if node is not IR.NullNode] + return IR.SequenceNode(ppt, IRlist) + except IOError: + Err.log ("Could not read "+filename) + return IR.NullNode + +def parse(filename): + "Top level parsing routine, taking a source file name and returning an IR list." + global templabelcount + templabelcount = 0 + return parse_file("", filename) + diff --git a/src/Ophis/IR.py b/src/Ophis/IR.py new file mode 100644 index 0000000..a0164d1 --- /dev/null +++ b/src/Ophis/IR.py @@ -0,0 +1,161 @@ +"""P65 Intermediate Representation + + Classes for representing the Intermediate nodes upon which the + assembler passes operate.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +from __future__ import nested_scopes +import Ophis.Errors as Err + +class Node: + """The default IR Node + Instances of Node always have the three fields ppt(Program Point), + nodetype(a string), and data (a list).""" + def __init__(self, ppt, nodetype, *data): + self.ppt = ppt + self.nodetype = nodetype + self.data = list(data) + def accept(self, asmpass, env=None): + """Implements the Visitor pattern for an assembler pass. + Calls the routine 'asmpass.visitTYPE(self, env)' where + TYPE is the value of self.nodetype.""" + Err.currentpoint = self.ppt + routine = getattr(asmpass, "visit"+self.nodetype, asmpass.visitUnknown) + routine(self, env) + def __str__(self): + if self.nodetype != "SEQUENCE": + return str(self.ppt)+": "+self.nodetype+" - "+" ".join(map(str, self.data)) + else: + return "\n".join(map(str, self.data)) + def __repr__(self): + args = [self.ppt, self.nodetype] + self.data + return "Node(" + ", ".join(map(repr, args)) + ")" + +NullNode = Node("", "None") + +def SequenceNode(ppt, nodelist): + return Node(ppt, "SEQUENCE", *nodelist) + +class Expr: + """Base class for P65 expressions + All expressions have a field called "data" and a boolean field + called "hardcoded". An expression is hardcoded if it has no + symbolic values in it.""" + def __init__(self, data): + self.data = data + self.hardcoded = 0 + def __str__(self): + return "" + def valid(self, env=None, PCvalid=0): + """Returns true if the the expression can be successfully + evaluated in the specified environment.""" + return 0 + def value(self, env=None): + "Evaluates this expression in the given environment." + return None + +class ConstantExpr(Expr): + "Represents a numeric constant" + def __init__(self, data): + self.data = data + self.hardcoded = 1 + def __str__(self): + return str(self.data) + def valid(self, env=None, PCvalid=0): + return 1 + def value(self, env=None): + return self.data + +class LabelExpr(Expr): + "Represents a symbolic constant" + def __init__(self, data): + self.data = data + self.hardcoded = 0 + def __str__(self): + return self.data + def valid(self, env=None, PCvalid=0): + return (env is not None) and self.data in env + def value(self, env=None): + return env[self.data] + +class PCExpr(Expr): + "Represents the current program counter: ^" + def __init__(self): + self.hardcoded = 0 + def __str__(self): + return "^" + def valid(self, env=None, PCvalid=0): + return env is not None and PCvalid + def value(self, env=None): + return env.getPC() + +class HighByteExpr(Expr): + "Represents the expression >{data}" + def __init__(self, data): + self.data = data + self.hardcoded = data.hardcoded + def __str__(self): + return ">"+str(self.data) + def valid(self, env=None, PCvalid=0): + return self.data.valid(env, PCvalid) + def value(self, env=None): + val = self.data.value(env) + return (val >> 8) & 0xff + +class LowByteExpr(Expr): + "Represents the expression <{data}" + def __init__(self, data): + self.data = data + self.hardcoded = data.hardcoded + def __str__(self): + return "<"+str(self.data) + def valid(self, env=None, PCvalid=0): + return self.data.valid(env, PCvalid) + def value(self, env=None): + val = self.data.value(env) + return val & 0xff + +class SequenceExpr(Expr): + """Represents an interleaving of operands (of type Expr) and + operators (of type String). Subclasses must provide a routine + operate(self, firstarg, op, secondarg) that evaluates the + operator.""" + def __init__(self, data): + """Constructor for Sequence Expressions. Results will be + screwy if the data inpot isn't a list with types + [Expr, str, Expr, str, Expr, str, ... Expr, str, Expr].""" + self.data = data + self.operands = [x for x in data if isinstance(x, Expr)] + self.operators = [x for x in data if type(x)==str] + for i in self.operands: + if not i.hardcoded: + self.hardcoded = 0 + break + else: + self.hardcoded = 1 + def __str__(self): + return "["+" ".join(map(str, self.data))+"]" + def valid(self, env=None, PCvalid=0): + for i in self.operands: + if not i.valid(env, PCvalid): + return 0 + return 1 + def value(self, env=None): + subs = map((lambda x: x.value(env)), self.operands) + result = subs[0] + index = 1 + for op in self.operators: + result = self.operate(result, op, subs[index]) + index += 1 + return result + def operate(self, start, op, other): + if op=="*": return start * other + if op=="/": return start // other + if op=="+": return start + other + if op=="-": return start - other + if op=="&": return start & other + if op=="|": return start | other + if op=="^": return start ^ other diff --git a/src/Ophis/Macro.py b/src/Ophis/Macro.py new file mode 100644 index 0000000..384f47c --- /dev/null +++ b/src/Ophis/Macro.py @@ -0,0 +1,62 @@ +"""Macro support for P65. + + P65 Macros are cached SequenceNodes with arguments + set via .alias commands and prevented from escaping + with .scope and .scend commands.""" + +import sys + +import Ophis.IR as IR +import Ophis.CmdLine as Cmd +import Ophis.Errors as Err + +macros = {} +currentname = None +currentbody = None + +def newMacro(name): + "Start creating a new macro with the specified name." + global currentname + global currentbody + global macros + if currentname is not None: + Err.log("Internal error! Nested macro attempt!") + else: + if name in macros: + Err.log("Duplicate macro definition '%s'" % name) + currentname = name + currentbody = [] + +def registerNode(node): + global currentbody + currentbody.append(IR.Node(node.ppt, node.nodetype, *node.data)) + +def endMacro(): + global currentname + global currentbody + global macros + if currentname is None: + Err.log("Internal error! Ended a non-existent macro!") + else: + macros[currentname] = currentbody + currentname = None + currentbody = None + +def expandMacro(ppt, name, arglist): + global macros + if name not in macros: + Err.log("Undefined macro '%s'" % name) + return IR.NullNode + argexprs = [IR.Node(ppt, "Label", "_*%d" % i, arg) for (i, arg) in zip(xrange(1, sys.maxint), arglist)] + bindexprs = [IR.Node(ppt, "Label", "_%d" % i, IR.LabelExpr("_*%d" % i)) for i in range(1, len(arglist)+1)] + body = [IR.Node("%s->%s" % (ppt, node.ppt), node.nodetype, *node.data) for node in macros[name]] + invocation = [IR.Node(ppt, "ScopeBegin")] + argexprs + [IR.Node(ppt, "ScopeBegin")] + bindexprs + body + [IR.Node(ppt, "ScopeEnd"), IR.Node(ppt, "ScopeEnd")] + return IR.SequenceNode(ppt, invocation) + +def dump(): + global macros + for mac in macros: + body = macros[mac] + print "Macro: "+mac + for node in body: print node + print "" diff --git a/src/Ophis/Main.py b/src/Ophis/Main.py new file mode 100644 index 0000000..281c4a8 --- /dev/null +++ b/src/Ophis/Main.py @@ -0,0 +1,124 @@ +"""Main controller routines for the P65 assembler. + + When invoked as main, interprets its command line and goes from there. + Otherwise, use run_all to interpret a file set.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +from __future__ import nested_scopes +import sys +import Ophis.Frontend +import Ophis.IR +import Ophis.CorePragmas +import Ophis.OldPragmas +import Ophis.Passes +import Ophis.Errors as Err +import Ophis.Environment +import Ophis.CmdLine +import Ophis.Opcodes + + +def usage(): + "Prints a usage message and quits." + print "Usage:" + print "\tOphis [options] infile outfile" + print "" + print "Options:" + print "\t-6510 Allow 6510 undocumented opcodes" + print "\t-65c02 Enable 65c02 extensions" + print "\t-d Allow deprecated pragmas" + print "\t-v n Set verbosity to n (0-4, 1=default)" + sys.exit(1) + +def run_all(infile, outfile): + "Transforms the source infile to a binary outfile." + Err.count = 0 + z = Ophis.Frontend.parse(infile) + env = Ophis.Environment.Environment() + + m = Ophis.Passes.ExpandMacros() + i = Ophis.Passes.InitLabels() + l_basic = Ophis.Passes.UpdateLabels() + l = Ophis.Passes.FixPoint("label update", [l_basic], lambda: l_basic.changed == 0) + c = Ophis.Passes.Collapse() + a = Ophis.Passes.Assembler() + + passes = [] + passes.append(Ophis.Passes.DefineMacros()) + passes.append(Ophis.Passes.FixPoint("macro expansion", [m], lambda: m.changed == 0)) + passes.append(Ophis.Passes.FixPoint("label initialization", [i], lambda: i.changed == 0)) + passes.extend([Ophis.Passes.CircularityCheck(), Ophis.Passes.CheckExprs(), Ophis.Passes.EasyModes()]) + passes.append(Ophis.Passes.FixPoint("instruction selection", [l, c], lambda: c.collapsed == 0)) + passes.extend([Ophis.Passes.NormalizeModes(), Ophis.Passes.UpdateLabels(), a]) + + for p in passes: p.go(z, env) + + if Err.count == 0: + try: + output = file(outfile, 'wb') + output.write("".join(map(chr, a.output))) + except IOError: + print "Could not write to "+outfile + else: + Err.report() + +def run_ophis(): + infile = None + outfile = None + + p65_compatibility_mode = 0 + chip_extension = None + + reading_arg = 0 + + for x in sys.argv[1:]: + if reading_arg: + try: + Ophis.CmdLine.verbose = int(x) + reading_arg = 0 + except ValueError: + print "FATAL: Non-integer passed as argument to -v" + usage() + elif x[0] == '-': + if x == '-v': + reading_arg = 1 + elif x == '-6510': + chip_extension = Ophis.Opcodes.undocops + elif x == '-65c02': + chip_extension = Ophis.Opcodes.c02extensions + elif x == '-d': + p65_compatibility_mode = 1 + else: + print "FATAL: Unknown option "+x + usage() + elif infile == None: + infile = x + elif outfile == None: + outfile = x + else: + print "FATAL: Too many files specified" + usage() + + if infile is None: + print "FATAL: No files specified" + usage() + + if outfile is None: + print "FATAL: No output file specified" + usage() + + Ophis.Frontend.pragma_modules.append(Ophis.CorePragmas) + + if p65_compatibility_mode: + Ophis.Frontend.pragma_modules.append(Ophis.OldPragmas) + + if chip_extension is not None: + Ophis.Opcodes.opcodes.update(chip_extension) + + Ophis.CorePragmas.reset() + run_all(infile, outfile) + +if __name__ == '__main__': + run_ophis() diff --git a/src/Ophis/OldPragmas.py b/src/Ophis/OldPragmas.py new file mode 100644 index 0000000..9f110db --- /dev/null +++ b/src/Ophis/OldPragmas.py @@ -0,0 +1,28 @@ +"""P65-Perl compatibility pragmas + + Additional assembler directives to permit assembly of + old P65-Perl sources. This is not, in itself, sufficient, + as the precedence of < and > vs. + and - has changed + between P65-Perl and P65-Ophis. + + Supported pragmas are: .ascii (byte), .address (word), + .segment (text), .code (text), and .link.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +import Ophis.CorePragmas as core + +pragmaAscii = core.pragmaByte +pragmaAddress = core.pragmaWord +pragmaSegment = core.pragmaText +pragmaCode = core.pragmaText + +def pragmaLink(ppt, line, result): + "Load a file in a precise memory location." + filename = line.expect("STRING").value + newPC = FE.parse_expr(line) + line.expect("EOL") + result.append(IR.Node(ppt, "SetPC", newPC)) + if type(filename)==str: result.append(FE.parse_file(ppt, filename)) diff --git a/src/Ophis/Opcodes.py b/src/Ophis/Opcodes.py new file mode 100644 index 0000000..fd3bbfc --- /dev/null +++ b/src/Ophis/Opcodes.py @@ -0,0 +1,168 @@ +"""Opcodes file. + + Tables for the assembly of 6502-family instructions, mapping + opcodes and addressing modes to binary instructions.""" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +# Names of addressing modes +modes = ["Implied", # 0 + "Immediate", # 1 + "Zero Page", # 2 + "Zero Page, X", # 3 + "Zero Page, Y", # 4 + "Absolute", # 5 + "Absolute, X", # 6 + "Absolute, Y", # 7 + "(Absolute)", # 8 + "(Absolute, X)", # 9 + "(Absolute), Y", # 10 + "(Zero Page)", # 11 + "(Zero Page, X)", # 12 + "(Zero Page), Y", # 13 + "Relative"] # 14 + +# Lengths of the argument +lengths = [0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1] + +opcodes = { + 'adc': [None, 0x69, 0x65, 0x75, None, 0x6D, 0x7D, 0x79, None, None, None, None, 0x61, 0x71, None], + 'and': [None, 0x29, 0x25, 0x35, None, 0x2D, 0x3D, 0x39, None, None, None, None, 0x21, 0x31, None], + 'asl': [0x0A, None, 0x06, 0x16, None, 0x0E, 0x1E, None, None, None, None, None, None, None, None], + 'bcc': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x90], + 'bcs': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xB0], + 'beq': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xF0], + 'bit': [None, None, 0x24, None, None, 0x2C, None, None, None, None, None, None, None, None, None], + 'bmi': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x30], + 'bne': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xD0], + 'bpl': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x10], + 'brk': [0x00, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'bvc': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x50], + 'bvs': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x70], + 'clc': [0x18, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'cld': [0xD8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'cli': [0x58, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'clv': [0xB8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'cmp': [None, 0xC9, 0xC5, 0xD5, None, 0xCD, 0xDD, 0xD9, None, None, None, None, 0xC1, 0xD1, None], + 'cpx': [None, 0xE0, 0xE4, None, None, 0xEC, None, None, None, None, None, None, None, None, None], + 'cpy': [None, 0xC0, 0xC4, None, None, 0xCC, None, None, None, None, None, None, None, None, None], + 'dec': [None, None, 0xC6, 0xD6, None, 0xCE, 0xDE, None, None, None, None, None, None, None, None], + 'dex': [0xCA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'dey': [0x88, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'eor': [None, 0x49, 0x45, 0x55, None, 0x4D, 0x5D, 0x59, None, None, None, None, 0x41, 0x51, None], + 'inc': [None, None, 0xE6, 0xF6, None, 0xEE, 0xFE, None, None, None, None, None, None, None, None], + 'inx': [0xE8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'iny': [0xC8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'jmp': [None, None, None, None, None, 0x4C, None, None, 0x6C, None, None, None, None, None, None], + 'jsr': [None, None, None, None, None, 0x20, None, None, None, None, None, None, None, None, None], + 'lda': [None, 0xA9, 0xA5, 0xB5, None, 0xAD, 0xBD, 0xB9, None, None, None, None, 0xA1, 0xB1, None], + 'ldx': [None, 0xA2, 0xA6, None, 0xB6, 0xAE, None, 0xBE, None, None, None, None, None, None, None], + 'ldy': [None, 0xA0, 0xA4, 0xB4, None, 0xAC, 0xBC, None, None, None, None, None, None, None, None], + 'lsr': [0x4A, None, 0x46, 0x56, None, 0x4E, 0x5E, None, None, None, None, None, None, None, None], + 'nop': [0xEA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'ora': [None, 0x09, 0x05, 0x15, None, 0x0D, 0x1D, 0x19, None, None, None, None, 0x01, 0x11, None], + 'pha': [0x48, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'php': [0x08, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'pla': [0x68, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'plp': [0x28, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'rol': [0x2A, None, 0x26, 0x36, None, 0x2E, 0x3E, None, None, None, None, None, None, None, None], + 'ror': [0x6A, None, 0x66, 0x76, None, 0x6E, 0x7E, None, None, None, None, None, None, None, None], + 'rti': [0x40, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'rts': [0x60, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'sbc': [None, 0xE9, 0xE5, 0xF5, None, 0xED, 0xFD, 0xF9, None, None, None, None, 0xE1, 0xF1, None], + 'sec': [0x38, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'sed': [0xF8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'sei': [0x78, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'sta': [None, None, 0x85, 0x95, None, 0x8D, 0x9D, 0x99, None, None, None, None, 0x81, 0x91, None], + 'stx': [None, None, 0x86, None, 0x96, 0x8E, None, None, None, None, None, None, None, None, None], + 'sty': [None, None, 0x84, 0x94, None, 0x8C, None, None, None, None, None, None, None, None, None], + 'tax': [0xAA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'tay': [0xA8, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'tsx': [0xBA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'txa': [0x8A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'txs': [0x9A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'tya': [0x98, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + } + +undocops = { + 'anc': [None, 0x0B, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'ane': [None, 0x8B, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'arr': [None, 0x6B, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'asr': [None, 0x4B, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'dcp': [None, None, 0xC7, 0xD7, None, 0xCF, 0xDF, 0xDB, None, None, None, None, 0xC3, 0xD3, None], + 'isb': [None, None, 0xE7, 0xF7, None, 0xEF, 0xFF, 0xFB, None, None, None, None, 0xE3, 0xF3, None], + 'las': [None, None, None, None, None, None, None, 0xBB, None, None, None, None, None, None, None], + 'lax': [None, None, 0xA7, None, 0xB7, 0xAF, None, 0xBF, None, None, None, None, 0xA3, 0xB3, None], + 'lxa': [None, 0xAB, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'rla': [None, None, 0x27, 0x37, None, 0x2F, 0x3F, 0x3B, None, None, None, None, 0x23, 0x33, None], + 'rra': [None, None, 0x67, 0x77, None, 0x6F, 0x7F, 0x7B, None, None, None, None, 0x63, 0x73, None], + 'sax': [None, None, 0x87, None, 0x97, 0x8F, None, None, None, None, None, None, 0x83, None, None], + 'sbx': [None, 0xCB, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'sha': [None, None, None, None, None, None, None, 0x9F, None, None, None, None, None, 0x93, None], + 'shs': [None, None, None, None, None, None, None, 0x9B, None, None, None, None, None, None, None], + 'shx': [None, None, None, None, None, None, None, 0x9E, None, None, None, None, None, None, None], + 'slo': [None, None, 0x07, 0x17, None, 0x0F, 0x1F, 0x1B, None, None, None, None, 0x03, 0x13, None], + 'sre': [None, None, 0x47, 0x57, None, 0x4F, 0x5F, 0x5B, None, None, None, None, 0x43, 0x53, None], + } + +c02extensions = { + 'adc': [None, 0x69, 0x65, 0x75, None, 0x6D, 0x7D, 0x79, None, None, None, 0x72, 0x61, 0x71, None], + 'and': [None, 0x29, 0x25, 0x35, None, 0x2D, 0x3D, 0x39, None, None, None, 0x32, 0x21, 0x31, None], + 'bbr0': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x0F], + 'bbr1': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x1F], + 'bbr2': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x2F], + 'bbr3': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x3F], + 'bbr4': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x4F], + 'bbr5': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x5F], + 'bbr6': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x6F], + 'bbr7': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x7F], + 'bbs0': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x8F], + 'bbs1': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x9F], + 'bbs2': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xAF], + 'bbs3': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xBF], + 'bbs4': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xCF], + 'bbs5': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xDF], + 'bbs6': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xEF], + 'bbs7': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0xFF], + 'bit': [None, 0x89, 0x24, 0x34, None, 0x2C, 0x3C, None, None, None, None, None, None, None, None], + 'bra': [None, None, None, None, None, None, None, None, None, None, None, None, None, None, 0x80], + 'cmp': [None, 0xC9, 0xC5, 0xD5, None, 0xCD, 0xDD, 0xD9, None, None, None, 0xD2, 0xC1, 0xD1, None], + 'dea': [0x3A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'dec': [0x3A, None, 0xC6, 0xD6, None, 0xCE, 0xDE, None, None, None, None, None, None, None, None], + 'eor': [None, 0x49, 0x45, 0x55, None, 0x4D, 0x5D, 0x59, None, None, None, 0x52, 0x41, 0x51, None], + 'ina': [0x1A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'inc': [0x1A, None, 0xE6, 0xF6, None, 0xEE, 0xFE, None, None, None, None, None, None, None, None], + 'jmp': [None, None, None, None, None, 0x4C, None, None, 0x6C, 0x7C, None, None, None, None, None], + 'lda': [None, 0xA9, 0xA5, 0xB5, None, 0xAD, 0xBD, 0xB9, None, None, None, 0xB2, 0xA1, 0xB1, None], + 'ora': [None, 0x09, 0x05, 0x15, None, 0x0D, 0x1D, 0x19, None, None, None, 0x12, 0x01, 0x11, None], + 'phx': [0xDA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'phy': [0x5A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'plx': [0xFA, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'ply': [0x7A, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb0': [None, None, 0x07, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb1': [None, None, 0x17, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb2': [None, None, 0x27, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb3': [None, None, 0x37, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb4': [None, None, 0x47, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb5': [None, None, 0x57, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb6': [None, None, 0x67, None, None, None, None, None, None, None, None, None, None, None, None], + 'rmb7': [None, None, 0x77, None, None, None, None, None, None, None, None, None, None, None, None], + 'sbc': [None, 0xE9, 0xE5, 0xF5, None, 0xED, 0xFD, 0xF9, None, None, None, 0xF2, 0xE1, 0xF1, None], + 'smb0': [None, None, 0x87, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb1': [None, None, 0x97, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb2': [None, None, 0xA7, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb3': [None, None, 0xB7, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb4': [None, None, 0xC7, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb5': [None, None, 0xD7, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb6': [None, None, 0xE7, None, None, None, None, None, None, None, None, None, None, None, None], + 'smb7': [None, None, 0xF7, None, None, None, None, None, None, None, None, None, None, None, None], + 'sta': [None, None, 0x85, 0x95, None, 0x8D, 0x9D, 0x99, None, None, None, 0x92, 0x81, 0x91, None], + 'stp': [0xDB, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + 'stz': [None, None, 0x64, 0x74, None, 0x9C, 0x9E, None, None, None, None, None, None, None, None], + 'trb': [None, None, 0x14, None, None, 0x1C, None, None, None, None, None, None, None, None, None], + 'tsb': [None, None, 0x04, None, None, 0x0C, None, None, None, None, None, None, None, None, None], + 'wai': [0xCB, None, None, None, None, None, None, None, None, None, None, None, None, None, None], + } + diff --git a/src/Ophis/Passes.py b/src/Ophis/Passes.py new file mode 100644 index 0000000..5901843 --- /dev/null +++ b/src/Ophis/Passes.py @@ -0,0 +1,518 @@ +"""The P65 Assembler passes + + P65's design philosophy is to build the IR once, then run a great + many assembler passes over the result. Thus, each pass does a + single, specialized job. When strung together, the full + translation occurs. This structure also makes the assembler + very extensible; additional analyses or optimizations may be + added as new subclasses of Pass.""" + + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +from __future__ import nested_scopes +import Ophis.Errors as Err +import Ophis.IR as IR +import Ophis.Opcodes as Ops +import Ophis.CmdLine as Cmd +import Ophis.Macro as Macro + +# The passes themselves + +class Pass: + """Superclass for all assembler passes. Automatically handles IR + types that modify the environent's structure, and by default + raises an error on anything else. Override visitUnknown in your + extension pass to produce a pass that accepts everything.""" + name = "Default Pass" + def __init__(self): + self.writeOK = 1 + def visitNone(self, node, env): + pass + def visitSEQUENCE(self, node, env): + Err.currentpoint = node.ppt + for n in node.data: + n.accept(self, env) + def visitDataSegment(self, node, env): + self.writeOK = 0 + env.setsegment(node.data[0]) + def visitTextSegment(self, node, env): + self.writeOK = 1 + env.setsegment(node.data[0]) + def visitScopeBegin(self, node, env): + env.newscope() + def visitScopeEnd(self, node, env): + env.endscope() + def visitUnknown(self, node, env): + Err.log("Internal error! "+self.name+" cannot understand node type "+node.nodetype) + def prePass(self): + pass + def postPass(self): + pass + def go(self, node, env): + """Prepares the environment and runs this pass, possibly + printing debugging information.""" + if Err.count == 0: + if Cmd.verbose > 1: print "Running: "+self.name + env.reset() + self.prePass() + node.accept(self, env) + self.postPass() + env.reset() + if Cmd.verbose > 3: + print "Current labels:" + print env + if Cmd.verbose > 2: + print "Current IR:" + print node + +class FixPoint: + """A specialized class that is not a pass but can be run like one. + This class takes a list of passes and a "fixpoint" function.""" + def __init__(self, name, passes, fixpoint): + self.name = name + self.passes = passes + self.fixpoint = fixpoint + def go(self, node, env): + """Runs this FixPoint's passes, in order, until the fixpoint + is true. Always runs the passes at least once.""" + for i in xrange(100): + if Err.count != 0: break + for p in self.passes: + p.go(node, env) + if Err.count != 0: break + if self.fixpoint(): break + if Cmd.verbose > 1: print "Fixpoint failed, looping back" + else: + Err.log("Can't make %s converge! Maybe there's a recursive dependency somewhere?" % self.name) + +class DefineMacros(Pass): + "Extract macro definitions and remove them from the IR" + name = "Macro definition pass" + def prePass(self): + self.inDef = 0 + self.nestedError = 0 + def postPass(self): + if self.inDef: + Err.log("Unmatched .macro") + elif Cmd.verbose > 2: + print "Macro definitions:" + Macro.dump() + def visitMacroBegin(self, node, env): + if self.inDef: + Err.log("Nested macro definition") + self.nestedError = 1 + else: + Macro.newMacro(node.data[0]) + node.nodetype = "None" + node.data = [] + self.inDef = 1 + def visitMacroEnd(self, node, env): + if self.inDef: + Macro.endMacro() + node.nodetype = "None" + node.data = [] + self.inDef = 0 + elif not self.nestedError: + Err.log("Unmatched .macend") + def visitUnknown(self, node, env): + if self.inDef: + Macro.registerNode(node) + node.nodetype = "None" + node.data = [] + + +class ExpandMacros(Pass): + "Replace macro invocations with the appropriate text" + name = "Macro expansion pass" + def prePass(self): + self.changed = 0 + def visitMacroInvoke(self, node, env): + replacement = Macro.expandMacro(node.ppt, node.data[0], node.data[1:]) + node.nodetype = replacement.nodetype + node.data = replacement.data + self.changed = 1 + def visitUnknown(self, node, env): + pass + +class InitLabels(Pass): + "Finds all reachable labels" + name = "Label initialization pass" + def __init__(self): + Pass.__init__(self) + self.labelmap = {} + def prePass(self): + self.changed = 0 + self.PCvalid = 1 + def visitAdvance(self, node, env): + self.PCvalid=node.data[0].valid(env, self.PCvalid) + def visitSetPC(self, node, env): + self.PCvalid=node.data[0].valid(env, self.PCvalid) + def visitLabel(self, node, env): + (label, val) = node.data + fulllabel = "%d:%s" % (env.stack[0], label) + if fulllabel in self.labelmap and self.labelmap[fulllabel] is not node: + Err.log("Duplicate label definition '%s'" % label) + if fulllabel not in self.labelmap: + self.labelmap[fulllabel] = node + if val.valid(env, self.PCvalid) and label not in env: + env[label]=0 + self.changed=1 + def visitUnknown(self, node, env): + pass + +class CircularityCheck(Pass): + "Checks for circular label dependencies" + name = "Circularity check pass" + def prePass(self): + self.changed=0 + self.PCvalid=1 + def visitAdvance(self, node, env): + PCvalid = self.PCvalid + self.PCvalid=node.data[0].valid(env, self.PCvalid) + if not node.data[0].valid(env, PCvalid): + Err.log("Undefined or circular reference on .advance") + def visitSetPC(self, node, env): + PCvalid = self.PCvalid + self.PCvalid=node.data[0].valid(env, self.PCvalid) + if not node.data[0].valid(env, PCvalid): + Err.log("Undefined or circular reference on program counter set") + def visitCheckPC(self, node, env): + if not node.data[0].valid(env, self.PCvalid): + Err.log("Undefined or circular reference on program counter check") + def visitLabel(self, node, env): + (label, val) = node.data + if not val.valid(env, self.PCvalid): + Err.log("Undefined or circular dependency for label '%s'" % label) + def visitUnknown(self, node, env): + pass + +class CheckExprs(Pass): + "Ensures all expressions can resolve" + name = "Expression checking pass" + def visitUnknown(self, node, env): + for i in [x for x in node.data if isinstance(x, IR.Expr)]: + i.value(env) # Throw away result, just confirm validity of all expressions + +class EasyModes(Pass): + "Assigns address modes to hardcoded and branch instructions" + name = "Easy addressing modes pass" + def visitMemory(self, node, env): + if Ops.opcodes[node.data[0]][14] is not None: + node.nodetype = "Relative" + return + if node.data[1].hardcoded: + if not collapse_no_index(node, env): + node.nodetype = "Absolute" + def visitMemoryX(self, node, env): + if node.data[1].hardcoded: + if not collapse_x(node, env): + node.nodetype = "AbsoluteX" + def visitMemoryY(self, node, env): + if node.data[1].hardcoded: + if not collapse_y(node, env): + node.nodetype = "AbsoluteY" + def visitPointer(self, node, env): + if node.data[1].hardcoded: + if not collapse_no_index_ind(node, env): + node.nodetype = "Indirect" + def visitPointerX(self, node, env): + if node.data[1].hardcoded: + if not collapse_x_ind(node, env): + node.nodetype = "AbsIndX" + def visitPointerY(self, node, env): + if node.data[1].hardcoded: + if not collapse_y_ind(node, env): + node.nodetype = "AbsIndY" + def visitUnknown(self, node, env): + pass + +class UpdateLabels(Pass): + "Computes the new values for all entries in the symbol table" + name = "Label Update Pass" + def prePass(self): + self.changed = 0 + def visitSetPC(self, node, env): env.setPC(node.data[0].value(env)) + def visitAdvance(self, node, env): env.setPC(node.data[0].value(env)) + def visitImplied(self, node, env): env.incPC(1) + def visitImmediate(self, node, env): env.incPC(2) + def visitIndirectX(self, node, env): env.incPC(2) + def visitIndirectY(self, node, env): env.incPC(2) + def visitZPIndirect(self, node, env): env.incPC(2) + def visitZeroPage(self, node, env): env.incPC(2) + def visitZeroPageX(self, node, env): env.incPC(2) + def visitZeroPageY(self, node, env): env.incPC(2) + def visitRelative(self, node, env): env.incPC(2) + def visitIndirect(self, node, env): env.incPC(3) + def visitAbsolute(self, node, env): env.incPC(3) + def visitAbsoluteX(self, node, env): env.incPC(3) + def visitAbsoluteY(self, node, env): env.incPC(3) + def visitAbsIndX(self, node, env): env.incPC(3) + def visitAbsIndY(self, node, env): env.incPC(3) + def visitMemory(self, node, env): env.incPC(3) + def visitMemoryX(self, node, env): env.incPC(3) + def visitMemoryY(self, node, env): env.incPC(3) + def visitPointer(self, node, env): env.incPC(3) + def visitPointerX(self, node, env): env.incPC(3) + def visitPointerY(self, node, env): env.incPC(3) + def visitCheckPC(self, node, env): pass + def visitLabel(self, node, env): + (label, val) = node.data + old = env[label] + env[label] = val.value(env) + if old != env[label]: + self.changed = 1 + def visitByte(self, node, env): env.incPC(len(node.data)) + def visitWord(self, node, env): env.incPC(len(node.data)*2) + def visitDword(self, node, env): env.incPC(len(node.data)*4) + def visitWordBE(self, node, env): env.incPC(len(node.data)*2) + def visitDwordBE(self, node, env): env.incPC(len(node.data)*4) + +class Collapse(Pass): + """Selects as many zero-page instructions to convert as + possible, and tracks how many instructions have been + converted this pass.""" + name = "Instruction Collapse Pass" + def prePass(self): + self.collapsed = 0 + def visitMemory(self, node, env): + if collapse_no_index(node, env): self.collapsed += 1 + def visitMemoryX(self, node, env): + if collapse_x(node, env): self.collapsed += 1 + def visitMemoryY(self, node, env): + if collapse_y(node, env): self.collapsed += 1 + def visitPointer(self, node, env): + if collapse_no_index_ind(node, env): self.collapsed += 1 + def visitPointerX(self, node, env): + if collapse_x_ind(node, env): self.collapsed += 1 + def visitPointerY(self, node, env): + if collapse_y_ind(node, env): self.collapsed += 1 + def visitUnknown(self, node, env): + pass + +def collapse_no_index(node, env): + """Transforms a Memory node into a ZeroPage one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][2] is not None: + node.nodetype = "ZeroPage" + return 1 + else: + return 0 + +def collapse_x(node, env): + """Transforms a MemoryX node into a ZeroPageX one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][3] is not None: + node.nodetype = "ZeroPageX" + return 1 + else: + return 0 + +def collapse_y(node, env): + """Transforms a MemoryY node into a ZeroPageY one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][4] is not None: + node.nodetype = "ZeroPageY" + return 1 + else: + return 0 + +def collapse_no_index_ind(node, env): + """Transforms a Pointer node into a ZPIndirect one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][11] is not None: + node.nodetype = "ZPIndirect" + return 1 + else: + return 0 + +def collapse_x_ind(node, env): + """Transforms a PointerX node into an IndirectX one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][12] is not None: + node.nodetype = "IndirectX" + return 1 + else: + return 0 + +def collapse_y_ind(node, env): + """Transforms a PointerY node into an IndirectY one if possible. + Returns 1 if it made the collapse, false otherwise.""" + if node.data[1].value(env) < 0x100 and Ops.opcodes[node.data[0]][13] is not None: + node.nodetype = "IndirectY" + return 1 + else: + return 0 + + +class NormalizeModes(Pass): + """Eliminates the intermediate "Memory" and "Pointer" nodes, + converting them to "Absolute".""" + name = "Mode Normalization pass" + def visitMemory(self, node, env): node.nodetype = "Absolute" + def visitMemoryX(self, node, env): node.nodetype = "AbsoluteX" + def visitMemoryY(self, node, env): node.nodetype = "AbsoluteY" + def visitPointer(self, node, env): node.nodetype = "Indirect" + def visitPointerX(self, node, env): node.nodetype = "AbsIndX" + # If we ever hit a PointerY by this point, we have a bug. + def visitPointerY(self, node, env): node.nodetype = "AbsIndY" + def visitUnknown(self, node, env): pass + +class Assembler(Pass): + """Converts the IR into a list of bytes, suitable for writing to + a file.""" + name = "Assembler" + + def prePass(self): + self.output = [] + self.code = 0 + self.data = 0 + self.filler = 0 + + def postPass(self): + if Cmd.verbose > 0 and Err.count == 0: + print "Assembly complete: %s bytes output (%s code, %s data, %s filler)" \ + % (len(self.output), self.code, self.data, self.filler) + + def outputbyte(self, expr, env): + 'Outputs a byte, with range checking' + if self.writeOK: + val = expr.value(env) + if val < 0x00 or val > 0xff: + Err.log("Byte constant "+str(expr)+" out of range") + val = 0 + self.output.append(int(val)) + else: + Err.log("Attempt to write to data segment") + def outputword(self, expr, env): + 'Outputs a little-endian word, with range checking' + if self.writeOK: + val = expr.value(env) + if val < 0x0000 or val > 0xFFFF: + Err.log("Word constant "+str(expr)+" out of range") + val = 0 + self.output.append(int(val & 0xFF)) + self.output.append(int((val >> 8) & 0xFF)) + else: + Err.log("Attempt to write to data segment") + def outputdword(self, expr, env): + 'Outputs a little-endian dword, with range checking' + if self.writeOK: + val = expr.value(env) + if val < 0x00000000 or val > 0xFFFFFFFFL: + Err.log("DWord constant "+str(expr)+" out of range") + val = 0 + self.output.append(int(val & 0xFF)) + self.output.append(int((val >> 8) & 0xFF)) + self.output.append(int((val >> 16) & 0xFF)) + self.output.append(int((val >> 24) & 0xFF)) + else: + Err.log("Attempt to write to data segment") + + def outputword_be(self, expr, env): + 'Outputs a big-endian word, with range checking' + if self.writeOK: + val = expr.value(env) + if val < 0x0000 or val > 0xFFFF: + Err.log("Word constant "+str(expr)+" out of range") + val = 0 + self.output.append(int((val >> 8) & 0xFF)) + self.output.append(int(val & 0xFF)) + else: + Err.log("Attempt to write to data segment") + def outputdword_be(self, expr, env): + 'Outputs a big-endian dword, with range checking' + if self.writeOK: + val = expr.value(env) + if val < 0x00000000 or val > 0xFFFFFFFFL: + Err.log("DWord constant "+str(expr)+" out of range") + val = 0 + self.output.append(int((val >> 24) & 0xFF)) + self.output.append(int((val >> 16) & 0xFF)) + self.output.append(int((val >> 8) & 0xFF)) + self.output.append(int(val & 0xFF)) + else: + Err.log("Attempt to write to data segment") + + def assemble(self, node, mode, env): + "A generic instruction called by the visitor methods themselves" + (opcode, expr) = node.data + bin_op = Ops.opcodes[opcode][mode] + if bin_op is None: + Err.log('%s does not have mode "%s"' % (opcode.upper(), Ops.modes[mode])) + return + self.outputbyte(IR.ConstantExpr(bin_op), env) + arglen = Ops.lengths[mode] + if mode == 14: # Special handling for relative mode + arg = expr.value(env) + arg = arg-(env.getPC()+2) + if arg < -128 or arg > 127: + Err.log("Branch target out of bounds") + arg = 0 + if arg < 0: arg += 256 + expr = IR.ConstantExpr(arg) + if arglen == 1: self.outputbyte(expr, env) + if arglen == 2: self.outputword(expr, env) + env.incPC(1+arglen) + self.code += 1+arglen + + def visitImplied(self, node, env): self.assemble(node, 0, env) + def visitImmediate(self, node, env): self.assemble(node, 1, env) + def visitZeroPage(self, node, env): self.assemble(node, 2, env) + def visitZeroPageX(self, node, env): self.assemble(node, 3, env) + def visitZeroPageY(self, node, env): self.assemble(node, 4, env) + def visitAbsolute(self, node, env): self.assemble(node, 5, env) + def visitAbsoluteX(self, node, env): self.assemble(node, 6, env) + def visitAbsoluteY(self, node, env): self.assemble(node, 7, env) + def visitIndirect(self, node, env): self.assemble(node, 8, env) + def visitAbsIndX(self, node, env): self.assemble(node, 9, env) + def visitAbsIndY(self, node, env): self.assemble(node, 10, env) + def visitZPIndirect(self, node, env): self.assemble(node, 11, env) + def visitIndirectX(self, node, env): self.assemble(node, 12, env) + def visitIndirectY(self, node, env): self.assemble(node, 13, env) + def visitRelative(self, node, env): self.assemble(node, 14, env) + def visitLabel(self, node, env): pass + def visitByte(self, node, env): + for expr in node.data: + self.outputbyte(expr, env) + env.incPC(len(node.data)) + self.data += len(node.data) + def visitWord(self, node, env): + for expr in node.data: + self.outputword(expr, env) + env.incPC(len(node.data)*2) + self.data += len(node.data)*2 + def visitDword(self, node, env): + for expr in node.data: + self.outputdword(expr, env) + env.incPC(len(node.data)*4) + self.data += len(node.data)*4 + def visitWordBE(self, node, env): + for expr in node.data: + self.outputword_be(expr, env) + env.incPC(len(node.data)*2) + self.data += len(node.data)*2 + def visitDwordBE(self, node, env): + for expr in node.data: + self.outputdword_be(expr, env) + env.incPC(len(node.data)*4) + self.data += len(node.data)*4 + def visitSetPC(self, node, env): + env.setPC(node.data[0].value(env)) + def visitCheckPC(self, node, env): + pc = env.getPC() + target = node.data[0].value(env) + if (pc > target): + Err.log(".checkpc assertion failed: $%x > $%x" % (pc, target)) + def visitAdvance(self, node, env): + pc = env.getPC() + target = node.data[0].value(env) + if (pc > target): + Err.log("Attempted to .advance backwards: $%x to $%x" % (pc, target)) + else: + zero = IR.ConstantExpr(0) + for i in xrange(target-pc): self.outputbyte(zero, env) + self.filler += target-pc + env.setPC(target) diff --git a/src/Ophis/__init__.py b/src/Ophis/__init__.py new file mode 100644 index 0000000..0f35954 --- /dev/null +++ b/src/Ophis/__init__.py @@ -0,0 +1,5 @@ +"P65 - a cross-assembler for the 6502 series of chips" + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. diff --git a/src/ophismain.py b/src/ophismain.py new file mode 100644 index 0000000..5ddbf88 --- /dev/null +++ b/src/ophismain.py @@ -0,0 +1,4 @@ +#!/usr/local/bin/python +import Ophis.Main + +Ophis.Main.run_ophis() diff --git a/tests/test6510.bin b/tests/test6510.bin new file mode 100644 index 0000000..bdc3d91 Binary files /dev/null and b/tests/test6510.bin differ diff --git a/tests/test6510.oph b/tests/test6510.oph new file mode 100644 index 0000000..a22e3f6 --- /dev/null +++ b/tests/test6510.oph @@ -0,0 +1,78 @@ +; Test file for base 6510 undocumented opcode compliance +; This odd little source file uses every addressing mode +; of every opcode, and uses the opcode itself as the argument +; to each instruction that takes one. The resulting binary's +; bytes are thus in strictly increasing numerical order. + +; Many mnemonics have multiple opcodes with identical +; effects; Ophis chooses one of them and the arguments +; herein assume that any assembler will choose as Ophis +; does. + +; This file also doesn't include the 6502's *documented* +; opcodes - see testbase.oph for those. + + SLO ($03, X) + SLO $07 + ANC #$0B + SLO $0F0F + SLO ($13), Y + SLO $17, X + SLO $1B1B, Y + SLO $1F1F, X + RLA ($23, X) + RLA $27 + RLA $2F2F + RLA ($33), Y + RLA $37, X + RLA $3B3B, Y + RLA $3F3F, X + SRE ($43, X) + SRE $47 + ASR #$4B + SRE $4F4F + SRE ($53), Y + SRE $57, X + SRE $5B5B, Y + SRE $5F5F, X + RRA ($63, X) + RRA $67 + ARR #$6B + RRA $6F6F + RRA ($73), Y + RRA $77, X + RRA $7B7B, Y + RRA $7F7F, X + SAX ($83, X) + SAX $87 + ANE #$8B + SAX $8F8F + SHA ($93), Y + SAX $97, Y + SHS $9B9B, Y + SHX $9E9E, Y + SHA $9F9F, Y + LAX ($A3, X) + LAX $A7 + LXA #$AB + LAX $AFAF + LAX ($B3), Y + LAX $B7, Y + LAS $BBBB, Y + LAX $BFBF, Y + DCP ($C3, X) + DCP $C7 + SBX #$CB + DCP $CFCF + DCP ($D3), Y + DCP $D7, X + DCP $DBDB, Y + DCP $DFDF, X + ISB ($E3, X) + ISB $E7 + ISB $EFEF + ISB ($F3), Y + ISB $F7, X + ISB $FBFB, Y + ISB $FFFF, X + \ No newline at end of file diff --git a/tests/test65c02.bin b/tests/test65c02.bin new file mode 100644 index 0000000..90f1e85 Binary files /dev/null and b/tests/test65c02.bin differ diff --git a/tests/test65c02.oph b/tests/test65c02.oph new file mode 100644 index 0000000..84604c2 --- /dev/null +++ b/tests/test65c02.oph @@ -0,0 +1,74 @@ +; Test file for 65C02 extended opcode compliance +; This odd little source file uses every addressing mode +; of every opcode, and uses the opcode itself as the argument +; to each instruction that takes one. The resulting binary's +; bytes are thus in strictly increasing numerical order. + +; Some opcodes have multiple mnemonics; we provide both. + +; This file also doesn't include the 65C02's opcodes that +; are also available in stock 6502s - see testbase.oph for +; those. + TSB $04 ; 04: TSB - Zero Page + RMB0 $07 ; 07: RMB0 - Zero Page + TSB $0C0C ; 0C: TSB - Absolute + BBR0 ^+$11 ; 0F: BBR0 - Relative + ORA ($12) ; 12: ORA - (Zero Page) + TRB $14 ; 14: TRB - Zero Page + RMB1 $17 ; 17: RMB1 - Zero Page + INA ; 1A: INA - Implied + INC ; INC - Implied + TRB $1C1C ; 1C: TRB - Absolute + BBR1 ^+$21 ; 1F: BBR1 - Relative + RMB2 $27 ; 27: RMB2 - Zero Page + BBR2 ^+$31 ; 2F: BBR2 - Relative + AND ($32) ; 32: AND - (Zero Page) + BIT $34, X ; 34: BIT - Zero Page, X + RMB3 $37 ; 37: RMB3 - Zero Page + DEA ; 3A: DEA - Implied + DEC ; 3A: DEC - Implied + BIT $3C3C,X ; 3C: BIT - Absolute, X + BBR3 ^+$41 ; 3F: BBR3 - Relative + RMB4 $47 ; 47: RMB4 - Zero Page + BBR4 ^+$51 ; 4F: BBR4 - Relative + EOR ($52) ; 52: EOR - (Zero Page) + RMB5 $57 ; 57: RMB5 - Zero Page + PHY ; 5A: PHY - Implied + BBR5 ^+$61 ; 5F: BBR5 - Relative + STZ $64 ; 64: STZ - Zero Page + RMB6 $67 ; 67: RMB6 - Zero Page + BBR6 ^+$71 ; 6F: BBR6 - Relative + ADC ($72) ; 72: ADC - (Zero Page) + STZ $74, X ; 74: STZ - Zero Page, X + RMB7 $77 ; 77: RMB7 - Zero Page + PLY ; 7A: PLY - Implied + JMP ($7C7C, X) ; 7C: JMP - (Absolute, X) + BBR7 ^+$81 ; 7F: BBR7 - Relative + BRA ^-$7E ; 80: BRA - Relative + SMB0 $87 ; 87: SMB0 - Zero Page + BIT #$89 ; 89: BIT - Immediate + BBS0 ^-$6F ; 8F: BBS0 - Relative + STA ($92) ; 92: STA - (Zero Page) + SMB1 $97 ; 97: SMB1 - Zero Page + STZ $9C9C ; 9C: STZ - Absolute + STZ $9E9E, X ; 9E: STZ - Absolute, X + BBS1 ^-$5F ; 9F: BBS1 - Relative + SMB2 $A7 ; A7: SMB2 - Zero Page + BBS2 ^-$4F ; AF: BBS2 - Relative + LDA ($B2) ; B2: LDA - (Zero Page) + SMB3 $B7 ; B7: SMB3 - Zero Page + BBS3 ^-$3F ; BF: BBS3 - Relative + SMB4 $C7 ; C7: SMB4 - Zero Page + WAI ; CB: WAI - Implied + BBS4 ^-$2F ; CF: BBS4 - Relative + CMP ($D2) ; D2: CMP - (Zero Page) + SMB5 $D7 ; D7: SMB5 - Zero Page + PHX ; DA: PHX - Implied + STP ; DB: STP - Implied + BBS5 ^-$1F ; DF: BBS5 - Relative + SMB6 $E7 ; E7: SMB6 - Zero Page + BBS6 ^-$0F ; EF: BBS6 - Relative + SBC ($F2) ; F2: SBC - (Zero Page) + SMB7 $F7 ; F7: SMB7 - Zero Page + PLX ; FA: PLX - Implied + BBS7 ^+$01 ; FF: BBS7 - Relative diff --git a/tests/testbase.bin b/tests/testbase.bin new file mode 100644 index 0000000..43de754 Binary files /dev/null and b/tests/testbase.bin differ diff --git a/tests/testbase.oph b/tests/testbase.oph new file mode 100644 index 0000000..44b636d --- /dev/null +++ b/tests/testbase.oph @@ -0,0 +1,157 @@ +; Test file for base 6502 opcode compliance +; This odd little source file uses every addressing mode +; of every opcode, and uses the opcode itself as the argument +; to each instruction that takes one. The resulting binary's +; bytes are thus in strictly increasing numerical order. + + BRK + ORA ($01, X) + ORA $05 + ASL $06 + PHP + ORA #$09 + ASL + ORA $0D0D + ASL $0E0E + BPL ^+$12 + ORA ($11), Y + ORA $15, X + ASL $16, X + CLC + ORA $1919, Y + ORA $1D1D, X + ASL $1E1E, X + JSR $2020 + AND ($21, X) + BIT $24 + AND $25 + ROL $26 + PLP + AND #$29 + ROL + BIT $2C2C + AND $2D2D + ROL $2E2E + BMI ^+$32 + AND ($31), Y + AND $35, X + ROL $36, X + SEC + AND $3939, Y + AND $3D3D, X + ROL $3E3E, X + RTI + EOR ($41, X) + EOR $45 + LSR $46 + PHA + EOR #$49 + LSR + JMP $4C4C + EOR $4D4D + LSR $4E4E + BVC ^+$52 + EOR ($51), Y + EOR $55, X + LSR $56, X + CLI + EOR $5959, Y + EOR $5D5D, X + LSR $5E5E, X + RTS + ADC ($61, X) + ADC $65 + ROR $66 + PLA + ADC #$69 + ROR + JMP ($6C6C) + ADC $6D6D + ROR $6E6E + BVS ^+$72 + ADC ($71), Y + ADC $75, X + ROR $76, X + SEI + ADC $7979, Y + ADC $7D7D, X + ROR $7E7E, X + STA ($81, X) + STY $84 + STA $85 + STX $86 + DEY + TXA + STY $8C8C + STA $8D8D + STX $8E8E + BCC ^-$6E + STA ($91), Y + STY $94, X + STA $95, X + STX $96, Y + TYA + STA $9999, Y + TXS + STA $9D9D, X + LDY #$A0 + LDA ($A1, X) + LDX #$A2 + LDY $A4 + LDA $A5 + LDX $A6 + TAY + LDA #$A9 + TAX + LDY $ACAC + LDA $ADAD + LDX $AEAE + BCS ^-$4e + LDA ($B1), Y + LDY $B4, X + LDA $B5, X + LDX $B6, Y + CLV + LDA $B9B9,Y + TSX + LDY $BCBC, X + LDA $BDBD, X + LDX $BEBE, Y + CPY #$C0 + CMP ($C1, X) + CPY $C4 + CMP $C5 + DEC $C6 + INY + CMP #$C9 + DEX + CPY $CCCC + CMP $CDCD + DEC $CECE + BNE ^-$2E + CMP ($D1), Y + CMP $D5, X + DEC $D6, X + CLD + CMP $D9D9, Y + CMP $DDDD, X + DEC $DEDE, X + CPX #$E0 + SBC ($E1, X) + CPX $E4 + SBC $E5 + INC $E6 + INX + SBC #$E9 + NOP + CPX $ECEC + SBC $EDED + INC $EEEE + BEQ ^-$0E + SBC ($F1), Y + SBC $F5, X + INC $F6, X + SED + SBC $F9F9, Y + SBC $FDFD, X + INC $FEFE, X diff --git a/tests/testdata.bin b/tests/testdata.bin new file mode 100644 index 0000000..8169f7c Binary files /dev/null and b/tests/testdata.bin differ diff --git a/tests/testdata.oph b/tests/testdata.oph new file mode 100644 index 0000000..f860bb7 --- /dev/null +++ b/tests/testdata.oph @@ -0,0 +1,7 @@ +; This data file just dumps out $00-$0F repeatedly with different forms. + +.byte 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 +.word 256, $0302, $0504, $0706, $0908, $0b0a, $0d0c, $0f0e +.dword $03020100, $07060504, $0b0a0908, $0f0e0d0c +.wordbe 1, $0203, $0405, $0607, $0809, $0a0b, $0c0d, $0e0f +.dwordbe $010203, $04050607, $08090a0b, $0c0d0e0f diff --git a/tools/charmaps/a2blink.map b/tools/charmaps/a2blink.map new file mode 100644 index 0000000..72a00d5 Binary files /dev/null and b/tools/charmaps/a2blink.map differ diff --git a/tools/charmaps/a2inverse.map b/tools/charmaps/a2inverse.map new file mode 100644 index 0000000..70ad9ed Binary files /dev/null and b/tools/charmaps/a2inverse.map differ diff --git a/tools/charmaps/a2normal.map b/tools/charmaps/a2normal.map new file mode 100644 index 0000000..b383772 Binary files /dev/null and b/tools/charmaps/a2normal.map differ diff --git a/tools/charmaps/makea2maps.py b/tools/charmaps/makea2maps.py new file mode 100644 index 0000000..40dac91 --- /dev/null +++ b/tools/charmaps/makea2maps.py @@ -0,0 +1,20 @@ +#!/usr/bin/python +import struct + +x = ''.join([chr(x) for x in range(256)]) +bits = struct.unpack("32s32s32s32s32s32s32s32s", x) +norm = [4, 5, 6, 7, 0, 1, 2, 3] +ivrs = [4, 1, 0, 7, 6, 5, 2, 3] +blnk = [4, 3, 2, 7, 0, 1, 6, 5] +normmap = ''.join([bits[x] for x in norm]) +ivrsmap = ''.join([bits[x] for x in ivrs]) +blnkmap = ''.join([bits[x] for x in blnk]) + +def dumpfile(n, m): + f = file(n, 'wb') + f.write(m) + f.close() + +dumpfile('a2normal.map', normmap) +dumpfile('a2inverse.map', ivrsmap) +dumpfile('a2blink.map', blnkmap) diff --git a/tools/charmaps/petscii.map b/tools/charmaps/petscii.map new file mode 100644 index 0000000..e4ae062 Binary files /dev/null and b/tools/charmaps/petscii.map differ diff --git a/tools/opcodes/chipsets.txt b/tools/opcodes/chipsets.txt new file mode 100644 index 0000000..4d19139 --- /dev/null +++ b/tools/opcodes/chipsets.txt @@ -0,0 +1,3 @@ +opcodes: op6502.txt +undocops: op6510.txt +c02extensions: op65c02.txt diff --git a/tools/opcodes/gensets.py b/tools/opcodes/gensets.py new file mode 100644 index 0000000..76eff0d --- /dev/null +++ b/tools/opcodes/gensets.py @@ -0,0 +1,153 @@ +#!/usr/bin/python +import sys + +verbose = 0 + +prologue = '"""' + """Opcodes file. + + Tables for the assembly of 6502-family instructions, mapping + opcodes and addressing modes to binary instructions.""" + '"""' + """ + +# Copyright 2002 Michael C. Martin. +# You may use, modify, and distribute this file under the BSD +# license: See LICENSE.txt for details. + +# Names of addressing modes +modes = ["Implied", # 0 + "Immediate", # 1 + "Zero Page", # 2 + "Zero Page, X", # 3 + "Zero Page, Y", # 4 + "Absolute", # 5 + "Absolute, X", # 6 + "Absolute, Y", # 7 + "(Absolute)", # 8 + "(Absolute, X)", # 9 + "(Absolute), Y", # 10 + "(Zero Page)", # 11 + "(Zero Page, X)", # 12 + "(Zero Page), Y", # 13 + "Relative"] # 14 + +# Lengths of the argument +lengths = [0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1] +""" + +# These values should match the ones in the prologue string. +modes = ["Implied", # 0 + "Immediate", # 1 + "Zero Page", # 2 + "Zero Page, X", # 3 + "Zero Page, Y", # 4 + "Absolute", # 5 + "Absolute, X", # 6 + "Absolute, Y", # 7 + "(Absolute)", # 8 + "(Absolute, X)", # 9 + "(Absolute), Y", # 10 + "(Zero Page)", # 11 + "(Zero Page, X)", # 12 + "(Zero Page), Y", # 13 + "Relative"] # 14 + +flatmodes = [x.lower() for x in modes] + +# WARNING: This decommenter assumes that # never appears anywhere else +# in a line. +def decomment (l): + if '#' in l: + l = l[:l.index('#')] + return l.strip() + +def decomment_readlines (fname): + result = [decomment(x) for x in file(fname).readlines()] + return [x for x in result if len(x) > 0] + +def parse_chipset_file (fname): + result = [None] * 256 + ls = [[x.strip() for x in y] for y in [z.split(':', 1) for z in decomment_readlines (fname)]] + for l in ls: + if len(l) == 2: + try: + op = int (l[0], 16) + syns = l[1].split(';') + for s in syns: + s_p = s.split('-') + if len(s_p) == 2: + mnem = s_p[0].lower().strip() + mode = s_p[1].lower().strip() + if mode in flatmodes: + if result[op] == None: + result[op] = [] + result[op].append((mnem, flatmodes.index(mode))) + else: + print "Unknown mode '%s'" % s_p[1] + except ValueError: + print "Illegal opcode '%s'" % l[0] + return result + +def collate_chipset_map (cs_list, base): + result = {} + for (opcode, insts) in zip (range(256), cs_list): + if insts != None: + for inst in insts: + (mnem, mode) = inst + if mnem not in result: + result[mnem] = [None] * len(modes) + if result[mnem][mode] is not None: + print "Warning: Reassigning %s - %s" % (mnem, modes[mode]) + result[mnem][mode] = opcode + if base is not None: + todel = [] + for x in result: + if x in base: + if result[x] == base[x]: + todel.append(x) + elif verbose != 0: + print "# Opcode %s changed" % x + elif verbose != 0: + print "# Opcode %s added" % x + for x in todel: + del result[x] + return result + +def mapval(x): + if x is None: + return "None" + else: + return "0x%02X" % x + +def dump_map (m, prologue = ''): + mnems = m.keys() + mnems.sort() + for mnem in mnems: + print "%s'%s': [%s]," % (prologue, mnem, ', '.join([mapval(x) for x in m[mnem]])) + +if __name__=='__main__': + if len(sys.argv) > 1: + chipsets = argv[1:] + else: + chipsets = ['chipsets.txt'] + archs = [] + for x in chipsets: + try: + ls = [[x.strip() for x in y] for y in [z.split(':', 1) for z in decomment_readlines (x)]] + for l in ls: + if len(l) != 2: + print "Could not parse the chipset line '%s'" % ":".join(l) + else: + archs.append((l[0], l[1])) + except IOError: + print "Could not read file %s" % x + print prologue + baseset = None + for (field, fname) in archs: + chipset_list = parse_chipset_file(fname) + instruction_map = collate_chipset_map (chipset_list, baseset) + if baseset == None: + baseset = instruction_map + print "%s = {" % field + dump_map (instruction_map, ' ' * (len(field) + 4)) + print "%s}" % (' ' * (len(field) + 3)) + print "" + diff --git a/tools/opcodes/op6502.txt b/tools/opcodes/op6502.txt new file mode 100644 index 0000000..5f9c2a5 --- /dev/null +++ b/tools/opcodes/op6502.txt @@ -0,0 +1,256 @@ + 00: BRK - Implied + 01: ORA - (Zero Page, X) + 02: + 03: + 04: + 05: ORA - Zero Page + 06: ASL - Zero Page + 07: + 08: PHP - Implied + 09: ORA - Immediate + 0A: ASL - Implied + 0B: + 0C: + 0D: ORA - Absolute + 0E: ASL - Absolute + 0F: + 10: BPL - Relative + 11: ORA - (Zero Page), Y + 12: + 13: + 14: + 15: ORA - Zero Page, X + 16: ASL - Zero Page, X + 17: + 18: CLC - Implied + 19: ORA - Absolute, Y + 1A: + 1B: + 1C: + 1D: ORA - Absolute, X + 1E: ASL - Absolute, X + 1F: + 20: JSR - Absolute + 21: AND - (Zero Page, X) + 22: + 23: + 24: BIT - Zero Page + 25: AND - Zero Page + 26: ROL - Zero Page + 27: + 28: PLP - Implied + 29: AND - Immediate + 2A: ROL - Implied + 2B: + 2C: BIT - Absolute + 2D: AND - Absolute + 2E: ROL - Absolute + 2F: + 30: BMI - Relative + 31: AND - (Zero Page), Y + 32: + 33: + 34: + 35: AND - Zero Page, X + 36: ROL - Zero Page, X + 37: + 38: SEC - Implied + 39: AND - Absolute, Y + 3A: + 3B: + 3C: + 3D: AND - Absolute, X + 3E: ROL - Absolute, X + 3F: + 40: RTI - Implied + 41: EOR - (Zero Page, X) + 42: + 43: + 44: + 45: EOR - Zero Page + 46: LSR - Zero Page + 47: + 48: PHA - Implied + 49: EOR - Immediate + 4A: LSR - Implied + 4B: + 4C: JMP - Absolute + 4D: EOR - Absolute + 4E: LSR - Absolute + 4F: + 50: BVC - Relative + 51: EOR - (Zero Page), Y + 52: + 53: + 54: + 55: EOR - Zero Page, X + 56: LSR - Zero Page, X + 57: + 58: CLI - Implied + 59: EOR - Absolute, Y + 5A: + 5B: + 5C: + 5D: EOR - Absolute, X + 5E: LSR - Absolute, X + 5F: + 60: RTS - Implied + 61: ADC - (Zero Page, X) + 62: + 63: + 64: + 65: ADC - Zero Page + 66: ROR - Zero Page + 67: + 68: PLA - Implied + 69: ADC - Immediate + 6A: ROR - Implied + 6B: + 6C: JMP - (Absolute) + 6D: ADC - Absolute + 6E: ROR - Absolute + 6F: + 70: BVS - Relative + 71: ADC - (Zero Page), Y + 72: + 73: + 74: + 75: ADC - Zero Page, X + 76: ROR - Zero Page, X + 77: + 78: SEI - Implied + 79: ADC - Absolute, Y + 7A: + 7B: + 7C: + 7D: ADC - Absolute, X + 7E: ROR - Absolute, X + 7F: + 80: + 81: STA - (Zero Page, X) + 82: + 83: + 84: STY - Zero Page + 85: STA - Zero Page + 86: STX - Zero Page + 87: + 88: DEY - Implied + 89: + 8A: TXA - Implied + 8B: + 8C: STY - Absolute + 8D: STA - Absolute + 8E: STX - Absolute + 8F: + 90: BCC - Relative + 91: STA - (Zero Page), Y + 92: + 93: + 94: STY - Zero Page, X + 95: STA - Zero Page, X + 96: STX - Zero Page, Y + 97: + 98: TYA - Implied + 99: STA - Absolute, Y + 9A: TXS - Implied + 9B: + 9C: + 9D: STA - Absolute, X + 9E: + 9F: + A0: LDY - Immediate + A1: LDA - (Zero Page, X) + A2: LDX - Immediate + A3: + A4: LDY - Zero Page + A5: LDA - Zero Page + A6: LDX - Zero Page + A7: + A8: TAY - Implied + A9: LDA - Immediate + AA: TAX - Implied + AB: + AC: LDY - Absolute + AD: LDA - Absolute + AE: LDX - Absolute + AF: + B0: BCS - Relative + B1: LDA - (Zero Page), Y + B2: + B3: + B4: LDY - Zero Page, X + B5: LDA - Zero Page, X + B6: LDX - Zero Page, Y + B7: + B8: CLV - Implied + B9: LDA - Absolute, Y + BA: TSX - Implied + BB: + BC: LDY - Absolute, X + BD: LDA - Absolute, X + BE: LDX - Absolute, Y + BF: + C0: CPY - Immediate + C1: CMP - (Zero Page, X) + C2: + C3: + C4: CPY - Zero Page + C5: CMP - Zero Page + C6: DEC - Zero Page + C7: + C8: INY - Implied + C9: CMP - Immediate + CA: DEX - Implied + CB: + CC: CPY - Absolute + CD: CMP - Absolute + CE: DEC - Absolute + CF: + D0: BNE - Relative + D1: CMP - (Zero Page), Y + D2: + D3: + D4: + D5: CMP - Zero Page, X + D6: DEC - Zero Page, X + D7: + D8: CLD - Implied + D9: CMP - Absolute, Y + DA: + DB: + DC: + DD: CMP - Absolute, X + DE: DEC - Absolute, X + DF: + E0: CPX - Immediate + E1: SBC - (Zero Page, X) + E2: + E3: + E4: CPX - Zero Page + E5: SBC - Zero Page + E6: INC - Zero Page + E7: + E8: INX - Implied + E9: SBC - Immediate + EA: NOP - Implied + EB: + EC: CPX - Absolute + ED: SBC - Absolute + EE: INC - Absolute + EF: + F0: BEQ - Relative + F1: SBC - (Zero Page), Y + F2: + F3: + F4: + F5: SBC - Zero Page, X + F6: INC - Zero Page, X + F7: + F8: SED - Implied + F9: SBC - Absolute, Y + FA: + FB: + FC: + FD: SBC - Absolute, X + FE: INC - Absolute, X + FF: diff --git a/tools/opcodes/op6510.txt b/tools/opcodes/op6510.txt new file mode 100644 index 0000000..84ee575 --- /dev/null +++ b/tools/opcodes/op6510.txt @@ -0,0 +1,256 @@ + 00: BRK - Implied + 01: ORA - (Zero Page, X) + 02: + 03: SLO - (Zero Page, X) + 04: + 05: ORA - Zero Page + 06: ASL - Zero Page + 07: SLO - Zero Page + 08: PHP - Implied + 09: ORA - Immediate + 0A: ASL - Implied + 0B: ANC - Immediate + 0C: + 0D: ORA - Absolute + 0E: ASL - Absolute + 0F: SLO - Absolute + 10: BPL - Relative + 11: ORA - (Zero Page), Y + 12: + 13: SLO - (Zero Page), Y + 14: + 15: ORA - Zero Page, X + 16: ASL - Zero Page, X + 17: SLO - Zero Page, X + 18: CLC - Implied + 19: ORA - Absolute, Y + 1A: + 1B: SLO - Absolute, Y + 1C: + 1D: ORA - Absolute, X + 1E: ASL - Absolute, X + 1F: SLO - Absolute, X + 20: JSR - Absolute + 21: AND - (Zero Page, X) + 22: + 23: RLA - (Zero Page, X) + 24: BIT - Zero Page + 25: AND - Zero Page + 26: ROL - Zero Page + 27: RLA - Zero Page + 28: PLP - Implied + 29: AND - Immediate + 2A: ROL - Implied + 2B: + 2C: BIT - Absolute + 2D: AND - Absolute + 2E: ROL - Absolute + 2F: RLA - Absolute + 30: BMI - Relative + 31: AND - (Zero Page), Y + 32: + 33: RLA - (Zero Page), Y + 34: + 35: AND - Zero Page, X + 36: ROL - Zero Page, X + 37: RLA - Zero Page, X + 38: SEC - Implied + 39: AND - Absolute, Y + 3A: + 3B: RLA - Absolute, Y + 3C: + 3D: AND - Absolute, X + 3E: ROL - Absolute, X + 3F: RLA - Absolute, X + 40: RTI - Implied + 41: EOR - (Zero Page, X) + 42: + 43: SRE - (Zero Page, X) + 44: + 45: EOR - Zero Page + 46: LSR - Zero Page + 47: SRE - Zero Page + 48: PHA - Implied + 49: EOR - Immediate + 4A: LSR - Implied + 4B: ASR - Immediate + 4C: JMP - Absolute + 4D: EOR - Absolute + 4E: LSR - Absolute + 4F: SRE - Absolute + 50: BVC - Relative + 51: EOR - (Zero Page), Y + 52: + 53: SRE - (Zero Page), Y + 54: + 55: EOR - Zero Page, X + 56: LSR - Zero Page, X + 57: SRE - Zero Page, X + 58: CLI - Implied + 59: EOR - Absolute, Y + 5A: + 5B: SRE - Absolute, Y + 5C: + 5D: EOR - Absolute, X + 5E: LSR - Absolute, X + 5F: SRE - Absolute, X + 60: RTS - Implied + 61: ADC - (Zero Page, X) + 62: + 63: RRA - (Zero Page, X) + 64: + 65: ADC - Zero Page + 66: ROR - Zero Page + 67: RRA - Zero Page + 68: PLA - Implied + 69: ADC - Immediate + 6A: ROR - Implied + 6B: ARR - Immediate + 6C: JMP - (Absolute) + 6D: ADC - Absolute + 6E: ROR - Absolute + 6F: RRA - Absolute + 70: BVS - Relative + 71: ADC - (Zero Page), Y + 72: + 73: RRA - (Zero Page), Y + 74: + 75: ADC - Zero Page, X + 76: ROR - Zero Page, X + 77: RRA - Zero Page, X + 78: SEI - Implied + 79: ADC - Absolute, Y + 7A: + 7B: RRA - Absolute, Y + 7C: + 7D: ADC - Absolute, X + 7E: ROR - Absolute, X + 7F: RRA - Absolute, X + 80: + 81: STA - (Zero Page, X) + 82: + 83: SAX - (Zero Page, X) + 84: STY - Zero Page + 85: STA - Zero Page + 86: STX - Zero Page + 87: SAX - Zero Page + 88: DEY - Implied + 89: + 8A: TXA - Implied + 8B: ANE - Immediate + 8C: STY - Absolute + 8D: STA - Absolute + 8E: STX - Absolute + 8F: SAX - Absolute + 90: BCC - Relative + 91: STA - (Zero Page), Y + 92: + 93: SHA - (Zero Page), Y + 94: STY - Zero Page, X + 95: STA - Zero Page, X + 96: STX - Zero Page, Y + 97: SAX - Zero Page, Y + 98: TYA - Implied + 99: STA - Absolute, Y + 9A: TXS - Implied + 9B: SHS - Absolute, Y + 9C: + 9D: STA - Absolute, X + 9E: SHX - Absolute, Y + 9F: SHA - Absolute, Y + A0: LDY - Immediate + A1: LDA - (Zero Page, X) + A2: LDX - Immediate + A3: LAX - (Zero Page, X) + A4: LDY - Zero Page + A5: LDA - Zero Page + A6: LDX - Zero Page + A7: LAX - Zero Page + A8: TAY - Implied + A9: LDA - Immediate + AA: TAX - Implied + AB: LXA - Immediate + AC: LDY - Absolute + AD: LDA - Absolute + AE: LDX - Absolute + AF: LAX - Absolute + B0: BCS - Relative + B1: LDA - (Zero Page), Y + B2: + B3: LAX - (Zero Page), Y + B4: LDY - Zero Page, X + B5: LDA - Zero Page, X + B6: LDX - Zero Page, Y + B7: LAX - Zero Page, Y + B8: CLV - Implied + B9: LDA - Absolute, Y + BA: TSX - Implied + BB: LAS - Absolute, Y + BC: LDY - Absolute, X + BD: LDA - Absolute, X + BE: LDX - Absolute, Y + BF: LAX - Absolute, Y + C0: CPY - Immediate + C1: CMP - (Zero Page, X) + C2: + C3: DCP - (Zero Page, X) + C4: CPY - Zero Page + C5: CMP - Zero Page + C6: DEC - Zero Page + C7: DCP - Zero Page + C8: INY - Implied + C9: CMP - Immediate + CA: DEX - Implied + CB: SBX - Immediate + CC: CPY - Absolute + CD: CMP - Absolute + CE: DEC - Absolute + CF: DCP - Absolute + D0: BNE - Relative + D1: CMP - (Zero Page), Y + D2: + D3: DCP - (Zero Page), Y + D4: + D5: CMP - Zero Page, X + D6: DEC - Zero Page, X + D7: DCP - Zero Page, X + D8: CLD - Implied + D9: CMP - Absolute, Y + DA: + DB: DCP - Absolute, Y + DC: + DD: CMP - Absolute, X + DE: DEC - Absolute, X + DF: DCP - Absolute, X + E0: CPX - Immediate + E1: SBC - (Zero Page, X) + E2: + E3: ISB - (Zero Page, X) + E4: CPX - Zero Page + E5: SBC - Zero Page + E6: INC - Zero Page + E7: ISB - Zero Page + E8: INX - Implied + E9: SBC - Immediate + EA: NOP - Implied + EB: + EC: CPX - Absolute + ED: SBC - Absolute + EE: INC - Absolute + EF: ISB - Absolute + F0: BEQ - Relative + F1: SBC - (Zero Page), Y + F2: + F3: ISB - (Zero Page), Y + F4: + F5: SBC - Zero Page, X + F6: INC - Zero Page, X + F7: ISB - Zero Page, X + F8: SED - Implied + F9: SBC - Absolute, Y + FA: + FB: ISB - Absolute, Y + FC: + FD: SBC - Absolute, X + FE: INC - Absolute, X + FF: ISB - Absolute, X diff --git a/tools/opcodes/op65c02.txt b/tools/opcodes/op65c02.txt new file mode 100644 index 0000000..a672a2e --- /dev/null +++ b/tools/opcodes/op65c02.txt @@ -0,0 +1,256 @@ + 00: BRK - Implied + 01: ORA - (Zero Page, X) + 02: + 03: + 04: TSB - Zero Page + 05: ORA - Zero Page + 06: ASL - Zero Page + 07: RMB0 - Zero Page + 08: PHP - Implied + 09: ORA - Immediate + 0A: ASL - Implied + 0B: + 0C: TSB - Absolute + 0D: ORA - Absolute + 0E: ASL - Absolute + 0F: BBR0 - Relative + 10: BPL - Relative + 11: ORA - (Zero Page), Y + 12: ORA - (Zero Page) + 13: + 14: TRB - Zero Page + 15: ORA - Zero Page, X + 16: ASL - Zero Page, X + 17: RMB1 - Zero Page + 18: CLC - Implied + 19: ORA - Absolute, Y + 1A: INA - Implied; INC - Implied + 1B: + 1C: TRB - Absolute + 1D: ORA - Absolute, X + 1E: ASL - Absolute, X + 1F: BBR1 - Relative + 20: JSR - Absolute + 21: AND - (Zero Page, X) + 22: + 23: + 24: BIT - Zero Page + 25: AND - Zero Page + 26: ROL - Zero Page + 27: RMB2 - Zero Page + 28: PLP - Implied + 29: AND - Immediate + 2A: ROL - Implied + 2B: + 2C: BIT - Absolute + 2D: AND - Absolute + 2E: ROL - Absolute + 2F: BBR2 - Relative + 30: BMI - Relative + 31: AND - (Zero Page), Y + 32: AND - (Zero Page) + 33: + 34: BIT - Zero Page, X + 35: AND - Zero Page, X + 36: ROL - Zero Page, X + 37: RMB3 - Zero Page + 38: SEC - Implied + 39: AND - Absolute, Y + 3A: DEA - Implied; DEC - Implied + 3B: + 3C: BIT - Absolute, X + 3D: AND - Absolute, X + 3E: ROL - Absolute, X + 3F: BBR3 - Relative + 40: RTI - Implied + 41: EOR - (Zero Page, X) + 42: + 43: + 44: + 45: EOR - Zero Page + 46: LSR - Zero Page + 47: RMB4 - Zero Page + 48: PHA - Implied + 49: EOR - Immediate + 4A: LSR - Implied + 4B: + 4C: JMP - Absolute + 4D: EOR - Absolute + 4E: LSR - Absolute + 4F: BBR4 - Relative + 50: BVC - Relative + 51: EOR - (Zero Page), Y + 52: EOR - (Zero Page) + 53: + 54: + 55: EOR - Zero Page, X + 56: LSR - Zero Page, X + 57: RMB5 - Zero Page + 58: CLI - Implied + 59: EOR - Absolute, Y + 5A: PHY - Implied + 5B: + 5C: + 5D: EOR - Absolute, X + 5E: LSR - Absolute, X + 5F: BBR5 - Relative + 60: RTS - Implied + 61: ADC - (Zero Page, X) + 62: + 63: + 64: STZ - Zero Page + 65: ADC - Zero Page + 66: ROR - Zero Page + 67: RMB6 - Zero Page + 68: PLA - Implied + 69: ADC - Immediate + 6A: ROR - Implied + 6B: + 6C: JMP - (Absolute) + 6D: ADC - Absolute + 6E: ROR - Absolute + 6F: BBR6 - Relative + 70: BVS - Relative + 71: ADC - (Zero Page), Y + 72: ADC - (Zero Page) + 73: + 74: STZ - Zero Page, X + 75: ADC - Zero Page, X + 76: ROR - Zero Page, X + 77: RMB7 - Zero Page + 78: SEI - Implied + 79: ADC - Absolute, Y + 7A: PLY - Implied + 7B: + 7C: JMP - (Absolute, X) + 7D: ADC - Absolute, X + 7E: ROR - Absolute, X + 7F: BBR7 - Relative + 80: BRA - Relative + 81: STA - (Zero Page, X) + 82: + 83: + 84: STY - Zero Page + 85: STA - Zero Page + 86: STX - Zero Page + 87: SMB0 - Zero Page + 88: DEY - Implied + 89: BIT - Immediate + 8A: TXA - Implied + 8B: + 8C: STY - Absolute + 8D: STA - Absolute + 8E: STX - Absolute + 8F: BBS0 - Relative + 90: BCC - Relative + 91: STA - (Zero Page), Y + 92: STA - (Zero Page) + 93: + 94: STY - Zero Page, X + 95: STA - Zero Page, X + 96: STX - Zero Page, Y + 97: SMB1 - Zero Page + 98: TYA - Implied + 99: STA - Absolute, Y + 9A: TXS - Implied + 9B: + 9C: STZ - Absolute + 9D: STA - Absolute, X + 9E: STZ - Absolute, X + 9F: BBS1 - Relative + A0: LDY - Immediate + A1: LDA - (Zero Page, X) + A2: LDX - Immediate + A3: + A4: LDY - Zero Page + A5: LDA - Zero Page + A6: LDX - Zero Page + A7: SMB2 - Zero Page + A8: TAY - Implied + A9: LDA - Immediate + AA: TAX - Implied + AB: + AC: LDY - Absolute + AD: LDA - Absolute + AE: LDX - Absolute + AF: BBS2 - Relative + B0: BCS - Relative + B1: LDA - (Zero Page), Y + B2: LDA - (Zero Page) + B3: + B4: LDY - Zero Page, X + B5: LDA - Zero Page, X + B6: LDX - Zero Page, Y + B7: SMB3 - Zero Page + B8: CLV - Implied + B9: LDA - Absolute, Y + BA: TSX - Implied + BB: + BC: LDY - Absolute, X + BD: LDA - Absolute, X + BE: LDX - Absolute, Y + BF: BBS3 - Relative + C0: CPY - Immediate + C1: CMP - (Zero Page, X) + C2: + C3: + C4: CPY - Zero Page + C5: CMP - Zero Page + C6: DEC - Zero Page + C7: SMB4 - Zero Page + C8: INY - Implied + C9: CMP - Immediate + CA: DEX - Implied + CB: WAI - Implied + CC: CPY - Absolute + CD: CMP - Absolute + CE: DEC - Absolute + CF: BBS4 - Relative + D0: BNE - Relative + D1: CMP - (Zero Page), Y + D2: CMP - (Zero Page) + D3: + D4: + D5: CMP - Zero Page, X + D6: DEC - Zero Page, X + D7: SMB5 - Zero Page + D8: CLD - Implied + D9: CMP - Absolute, Y + DA: PHX - Implied + DB: STP - Implied + DC: + DD: CMP - Absolute, X + DE: DEC - Absolute, X + DF: BBS5 - Relative + E0: CPX - Immediate + E1: SBC - (Zero Page, X) + E2: + E3: + E4: CPX - Zero Page + E5: SBC - Zero Page + E6: INC - Zero Page + E7: SMB6 - Zero Page + E8: INX - Implied + E9: SBC - Immediate + EA: NOP - Implied + EB: + EC: CPX - Absolute + ED: SBC - Absolute + EE: INC - Absolute + EF: BBS6 - Relative + F0: BEQ - Relative + F1: SBC - (Zero Page), Y + F2: SBC - (Zero Page) + F3: + F4: + F5: SBC - Zero Page, X + F6: INC - Zero Page, X + F7: SMB7 - Zero Page + F8: SED - Implied + F9: SBC - Absolute, Y + FA: PLX - Implied + FB: + FC: + FD: SBC - Absolute, X + FE: INC - Absolute, X + FF: BBS7 - Relative