I wrote this little subroutine package for the Commodore 64 in 2002. You can likely still find a cached Usenet post to comp.sys.cbm referring to it.

I thought that I would add in an open-source license header and would present it here.

The source code below is for two machine language library routines which can be called from BASIC. The first routine will save a section of the C64’s memory to disk. The second will load a file from disk into a specific spot in memory. These functions are akin to Applesoft BASIC’s BSAVE and BLOAD binary I/O commands.

I did not wedge the CHRGET routine to add any new command verbs to BASIC; one must use the SYS command to invoke each subroutine. A jump-table at the beginning of the module controls which of the two functions you’ll execute. Address 49152 is the BSAVE routine. Address 49152+3 is the BLOAD routine.

Please note that the filename parameter must always be in a variable. I didn’t have the routine that would parse a literal properly readily available … and still don’t remember how to do it off the top of my head.

; BSaVe and bLoaD extentsions for the Commodore 64
;
;  License: MIT / X11
;  Copyright (c) 2009 by James K. Lawless
;  jimbo@radiks.net http://www.radiks.net/~jimbo
;  http://www.mailsend-online.com
;
;  Permission is hereby granted, free of charge, to any person
;  obtaining a copy of this software and associated documentation
;  files (the "Software"), to deal in the Software without
;  restriction, including without limitation the rights to use,
;  copy, modify, merge, publish, distribute, sublicense, and/or sell
;  copies of the Software, and to permit persons to whom the
;  Software is furnished to do so, subject to the following
;  conditions:
;
;  The above copyright notice and this permission notice shall be
;  included in all copies or substantial portions of the Software.
;
;  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
;  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
;  OTHER DEALINGS IN THE SOFTWARE.
;
; To use in C64 BASIC:
;   sys 49152,a$,start-addr,end-addr
;      The above will save to file named in a$
;   sys 49152+3,a$,start-addr
;      The above will load a file named in a$
;      to the specified location
;
; To save the default BASIC screen:
;   a$="screen,s,w"
;   sys 49152,a$,1024,1024+999
;
; To reload the default BASIC screen
;   a$="screen,s,r"
;   sys 49152+3,a$,1024

   *=$c000
; jump table for functions
   jmp save
   jmp load
flag  .BYTE 00
save = *
   lda #$00
   sta flag
   jmp main
load = *
   lda #$01
   sta flag
   jmp main

main = *
   jsr $aefd    ; skip comma
   jsr $b08b    ; search for variable
   jsr $b185    ; find address
   sta $fb
   tya
   sta $fc
   lda #$00
   tay
   lda ($fb),y
   pha
   iny
   lda ($fb),y
   pha
   iny
   lda ($fb),y
   tay
   pla
   tax
   pla
   jsr $ffbd ; SETNAM
   lda #$02
   ldx #$08
   ldy #$00
   jsr $ffba ; SETLFS

   lda flag
   cmp #$00
   beq dosave
   jmp doload

dosave = *
   jsr $aefd ; skip comma
   jsr $ad8a ; eval expr
   jsr $b7f7 ; get uint in a,y
   sta $fc
   tya
   sta $fb

   jsr $aefd ; skip comma
   jsr $ad8a ; eval expr
   jsr $b7f7 ; get uint in a,y
   sta $fd
   tya
   tax
   ldy $fd
   lda #$fb

   jsr $ffd8 ; save ram
   rts

doload = *
   jsr $aefd ; skip comma
   jsr $ad8a ; eval expr
   jsr $b7f7 ; get uint in a,y
   sta $fd
   tya
   tax
   ldy $fd
   lda #$00
   jsr $ffd5 ; load ram
   rts

Save to del.icio.us
Digg it
Save to Reddit
Share on Facebook
Share on Twitter
More bookmarks

Unless otherwise noted, all code and text entries are Copyright © 2009 by James K. Lawless

Jeff is using in most of his VIC games following makro to set a sprie on screen:

(assuming here $0c,$0d pointing to VRAM)

jsr calc_vram_vector ;$0c,$0d

ldy #collum
sta  ($0c),y

lda $0d
pha
clc
adc #$78 ;now pointing to color ram
sta $0d
lda #$02 ;f.e. in Gridrunner red is the “default color”
sta ($0c),y
pla
sta ($0c),y
…

Basicly there are only 4 sound fx in Gridrunner. Before I am trying to implement them and mimic them. first tries with vic2pokey translation tables were not as good as thought. VBL scanning of $900x sound registers not perfect either.

As they are only 4 of the sounds I will try to replicate them directly with own small pokey routines…

f.e. here you can have a look for the player shoot sound f.e.

$1422 ff. Player shot sound

I got the Gridrunner sound fx recreated in RMT by Miker. Let’s see how they fit and how I can implement them into the VBL system for playback.

Gridrunner itself only uses 4 sound fx in total.

La nostra storia ha inizio più o meno a metà degli anni ‘80, quando un gruppo di baldi ingegneri di stanza presso Hudson Soft (popolarissima software house dotata di un reparto di ricerca e sviluppo dedicato all’hardware) si ritrovarono per le mani, grazie ai loro immani sforzi, il progetto di una nuova console dalle caratteristiche quantomeno invitanti. Tale progetto, però, necessitava di ingenti finanziamenti per essere tradotto in realtà…

Leggi tutto »

At a computer far far away, I taught myself machine language on the 6502 processor (which at that time was the heart of the Apple ][e, the BBC and a number of other computers).

The book that I referred to was called “Machine Language for Beginners”, and if you are incredibly interested (and/or incredibly bored), you can now access a copy online here:

Machine Language for Beginners

Guess I was always doomed to work in IT, given this is (one of the things) I did for fun at 14.

I still have the original copy, and even sadder, there is still a fully functional Apple ][e in my office.

Apple 2

Um genau zu sein, mein erstes Programmier-Buch war:

Das war Anfang der 80er und die einzige Möglichkeit auf meinem VZ200 Computer Spiele zu spielen war, ich musste sie selber programmieren.

Schnell wurde mir klar, dass ich mit dem eingebauten Basic nicht weit kam, also kaufte ich mir besagtes Buch, in der Ausgabe mit gelbem Cover und programmierte mein erstes Spiel.

Spiel war vielleicht zu viel gesagt, es handelte sich dabei um den 100m Lauf aus Decathlon. Aber immerhin wurde die Zeit gemessen und so konnte man zumindest versuchen seinen Rekord zu verbessern.

Als ich dann auf den C64 umstieg, begleitete mich auch dort das 6502 Buch von Rodnay Zaks und half mir dabei einen der ersten Floppy-Beschleuniger zu schreiben. Auch bei der meiner Meinung nach schnellsten Line-Routine auf dem C64 zog ich dieses Buch zur Optimierung (Taktzyklen zählen) des Algorithmus heran. Abgeleitet war er vom Bresenham-Algorithums den ich jedoch so vereinfachte, dass er ohne Abfragen und mit einfacher Integer Addition funktionierte.

Rodnay Zaks hat mich in die Geheimnisse der Maschinensprache eingeführt, und dafür bin ich ihm sehr dankbar. Ich kann somit durchaus behaupten, dass mein erstes Buch ein wirklich gutes Buch war

Natürlich würde mich auch interessieren, welches euer erstes Buch war und welche Lehren ihr daraus gezogen habt. Also nicht genieren und hier antworten

Mostly to support my own development on multiple computers, I’ve moved my Common Lisp port of COMFY-6502 to github. I chose the name cl-comfy-6502 for the repository, although the “cl” prefix is a bit ugly.

The current snapshot of COMFY-6502.

Der Nascom I Computer war mein erster Einstieg in dem Bereich Personal Computer, soweit man von einem Einplatinen Computer schon von einem Personal Computer sprechen kann. Er kam als Bausatz und man musste schon wissen, wie man mit einem Lötkolben umgeht. Ziemlich schnell schon stieß ich mit meinen Wünschen, bzgl. der Möglichkeiten, die sich mir boten, an die Grenzen. Also musste ein besserer Computer her.

1978 wurde sehr stark für drei Fertigcomputer in der Fachpresse geworben, dem PET 2001 von Commodore, dem TRS-80 von Tandy und dem Apple II. PET und Apple benutzten als Mikroprozessor den 6502 von MOS Technology und der TRS-80 den Z80 von Zilog.

Da ich durch den Nascom I mit der Z80 CPU vorbelastet war, entschied ich mich für den TRS-80. Mittlerweile war ich mit der Maschinen- Programmierung des Z80 so vertraut – alle 920 OP-Codes kannte ich auswendig -, dass mir kaum eine andere Wahl blieb.

Der TRS-80 bot mir in meiner Leidenschaft zum Amateurfunk neue Möglichkeiten. Eine meiner beliebtesten Betriebsarten war RTTY (Radio Teletype), für die Nicht- Eingeweihten: Funkfernschreiben (Telex) für den Heimgebrauch. Auf einer Telex-Maschine empfing man Rundschreiben oder man unterhielt sich per Tastatur mit einem Partner, den heutigen Chats vergleichbar, nur mit wesentlich mehr Aufwand und nur für den kleinen Kreis der Amateurfunker. Da die Telex-Maschinen doch sehr klobig und unförmig waren, es handelte sich hier um ausgemusterte Geräte der Deutschen Bundespost, kam schnell die Idee, den RTTY Betrieb mit einem Computer zu realisieren. Erste Programme waren schnell geschrieben und man konnte den empfangenen Text auf dem Bildschirm als Klarschrift lesen. Ich selbst entwickelte ein Programm, mit dem man den empfangenen Text lesen und gleichzeitig eine Antwort schreiben konnte, die ebenfalls auf dem Bildschirm sichtbar war (Split-Screen) und nach dem Empfang sofort versendet werden konnte. Ein erstes und echtes Multitasking. Als nächstes Programm folgte ein CW (Morse) Dekodierprogramm. Die Töne der Morsezeichen wurden als lesbare Klarschrift auf dem Bildschirm angezeigt und auch das Vorschreiben war wie beim RTTY Programm möglich.

Durch die Popularität des TRS-80 wurden auch kommerzielle Programme angeboten. Als passionierter Schachspieler ist mir das SARGON Schachspiel noch in Erinnerung. Als Betriebssystem hatte sich CP/M etabliert. Es kam mit wenig Speicher aus und WORDSTAR hieß meine erste Textverarbeitung.

Auch die Firma Tandy war nicht untätig. Auf Grund des Erfolges Ihres ersten Computers TRS-80 Model I kam gut zwei Jahre später ein Nachfolger auf den Markt, der TRS-80 Model III. Das Model II war ein Portable Computer. War man zur Datenspeicherung beim Model I noch auf einen Kassettenrecorder angewiesen, so war das Model III ein Kompaktmodell und die Speichermedien, 51/4″ Diskettenlaufwerke mit einer Kapazität von 156 KB (Singlesided) waren im Gehäuse eingebaut. Der Verkaufserfolg des Modells war nicht mehr so gewaltig, weil immer mehr Firmen auf den Zug des Personal Computers aufgesprungen waren.

Even though it is hardly a finished product, I’ve posted a snapshot of my current CL conversion of COMFY-6502 Not that I expect a huge pent-up demand for the code, but it might be slightly more interesting than the output examples. Thanks to Henry Baker for allowing the release.

The page also contains a link to the TODO file describing my next steps. (Most immediately, my attempt to include JMP elision was messy enough to convince me I need a different class to represent opcodes+arguments as a unit.)

Hello World! I love those words, and at the same time, I loathe them. Why is that?

In the programming world, “Hello World” is usually the name of the first program you make in a given language that you’re starting to learn. For those that aren’t familiar, here’s a quick run down. You learn some basic coding for said new language, and implement a program to spit out two lovely words — Hello, and World. For the most part, this just lets you know that you’re on the right track. Nothing fancy or anything. When it’s a new language that you’re learning, and this happens, it’s pretty exciting! How I love those words!

Now let’s say you’ve gone to a year of community college where you started to learn how to program. You had to drop out after that year for one reason or another. Okay, fine, but you learned how to study for programming at least. Nice! Now you have the ability to pick up just about any programming language and apply yourself to it!

Okay, I was just talking about myself there obviously. If you couldn’t tell… damn. ANYWAY, here’s where the loathing of “Hello World” comes in. I’m pretty darned lazy when it comes to programming. Well, I’m not sure if I’m actually lazy, or if I have problems understanding the more advanced stuff. I can always get the basics down it seems, but then my brain just won’t soak in things, and it gets SO aggravating haha Now that I think about it, I must just be lazy. I know how to study for this!

I’ve dabbled in a few different languages now; C++, VB.NET, PHP, and most recently 6502 assembly. I haven’t excelled in any per se, but I’ve been able to do some minor things and be proud of them. This is why I love and hate the words, “Hello World.”

My name is Rob Bryant. Hi!

After all the work to write a post showing off COMFY-6502’s ability to reproduce the Red Book tone routine, I made a slight mistake in translation. The code I presented differed ever-so-slightly from the Red Book routine in the case where the Y-register reached zero.

In the original, when the Y-register reaches zero, the DEX is still executed. In the code I posted, the expiring “duration tick” skips a count on the pitch. A minor error, but one I should own up to.

Here’s a better effort. COMPILE-SYMBOLIC contains a MACROLET defining MODULE as a call to COMFY-6502:COMPILE.

(compile-symbolic
  (equ speaker #xc030)
  (equ duration 1)
  (equ pitch 0)
  (module
   (comfy-6502:loop
      ;; repeat until some clause loses: actually, only exit is
      ;; through return, so each clause should be ensured of winning.
    (LDX pitch)
    (LDA speaker)
    (not
     (comfy-6502:loop  ;; repeat until whap time
     DEY
     (not (seq zero? (DEC duration) zero? return))
     (seq DEX (not zero?)))))))

resulting in

(; reload-pitch
 (LDX :ZERO-PAGE) (:ZERO-PAGE 0)
 (LDA :ABSOLUTE) (:ABSOLUTE 49200)
 ; spin
 (DEY)
 (BNE) (:BRANCH 6) ; not-duration-tick
 (DEC :ZERO-PAGE) (:ZERO-PAGE 1)
 (BNE) (:BRANCH 2)
 (RTS)
 ; not-duration-tick
 (DEX)
 (BEQ) (:BRANCH 4) ; goto-reload-pitch
 (JMP :ABSOLUTE) (:LONG-BRANCH -12) ; spin
 ; goto-reload-pitch
 (JMP :ABSOLUTE) (:LONG-BRANCH -20) ; reload-pitch
)

For fun, I tried to get the code to emit the RTS at the very end, as in the original.

(compile-symbolic
  (equ speaker #xc030)
  (equ duration 1)
  (equ pitch 0)
  (module
    (alt (loop (seq (LDX pitch) (LDA speaker))
            (not (while
                    (seq DEY (not (seq zero? (seq (DEC duration) zero?)))
                    (seq DEX (not zero?)))))
          RTS)))

(; reload
  (LDX :ZERO-PAGE) (:ZERO-PAGE 0)
  (LDA :ABSOLUTE) (:ABSOLUTE 49200)
  ; spin
  (DEY)
  (BNE) (:BRANCH 5) ; not-duration
  ; duration-tick
  (DEC :ZERO-PAGE) (:ZERO-PAGE 1)
  (BEQ) (:BRANCH 10) ; exit
  ; not-duration
  (DEX)
  (BEQ) (:BRANCH 4) ; goto-reload
  ; goto-spin
  (JMP :ABSOLUTE) (:LONG-BRANCH -11)
  ; goto-reload
  (JMP :ABSOLUTE) (:LONG-BRANCH -19) ; reload
 ; exit
  (RTS))

“Loop tightening” could change (BEQ) (:BRANCH 4) to (BEQ) (:BRANCH -14); the (JMP :ABSOLUTE) (:LONG-BRANCH -19) is then never used, and could be omitted, changing (BEQ) (:BRANCH 10) to (BEQ) (:BRANCH 7).

“Loop compaction” could potentially recognize (BEQ) (:BRANCH -14) (JMP :ABSOLUTE) (:LONG-BRANCH -11), where no other instruction references the JMP, could be converted to (BEQ) (:BRANCH -14) (BNE) (:BRANCH -11), shortening the (BEQ) (:BRANCH 7) one byte more to (BNE) (:BRANCH 6).

Note some interesting equivalents I should probably implement as COMFY macros.

(if A B C) where C is do-nothing-but-win is (not (seq A (not B)). If A wins, B is executed to determine the result of the form. If A loses, the if wins. I will probably call this (when A B).

(if A B C) where B is a do-nothing-but-win is (alt A C), where alt is the “dual” of seq. (alt A B C …) == (not (seq (not A) (not B) (not C) …). For the two-argument case, I would call this (unless A B).

The one twist I can think of is to add an “implied SEQ” to these forms. (when A B C …) would be (when A (seq B C …)). (unless A B C …) would be (unless A (seq B C …)).

As I’ve mentioned before, I’ve become intrigued by Baker’s COMFY assembler, and have been working on porting it to Common Lisp, and making it a bit more powerful in the link stage.

One metric to judge the success of this kind of “medium-level” language is how well it compiles compared to hand-written assembler code. For the 6502, there are a few examples of code created by wizards like Steve Wozniak, which you can find copies of around the web, the largest being the Apple II monitor, the Integer Basic interpreter, and some medium-sized ones like the Apple II 6502 step/trace, the mini-assembler, the floating-point “Wozpack,” and the Sweet-16 virtual machine.

This kind of code has a lot of quirks that make it hard to straight-forwardly translate: lots of shared “tail code”, branches known by the programmer to always be taken (to save a precious extra byte consumed by an unconditional JMP), and the classic “fake RTS trick”, pushing a return address picked from a table onto the stack, then using an RTS instead of a zero-page indirect JMP. Common in Woz’s code is a further shortening of the code by arranging the destination addresses to all be in the same 256-byte page, so the high-order byte is a constant. Some of these ideas will likely be possible with intelligent macros, combined with address labels and computation on those labels. I’m puzzling a bit over how to optimize the “same page” condition: whether to include a “link-time assert”, which will issue an error if the code is emitted so as to cross a page, or an even more intelligent “link-time computation” which, given the current available memory space, can choose a location that meets the constraints.

That’s all still in development. The first test case I used was the classic “Red Book” tone routine.

;; the original
;; location 00: pitch
;; location 01: duration
0002-  AD 30 C0   LDA  $C030 ; whap speaker
0005-  88         DEY
0006-  D0 04      BNE  $000C
0008-  C6 01      DEC  $01   ; y reaches 0: a duration tick
000A-  F0 08      BEQ  $0014 ; duration exhausted when reaches 0
000C-  CA         DEX        ; x counts time to "whap"
000D-  D0 F6      BNE  $0005
000F-  A6 00      LDX  $00   ; x reached 0, reload pitch
0011-  4C 02 00   JMP  $0002 ; and whap
0014-  60         RTS

A few comments:

1. Locating the code in zero-page needlessly wastes valuable zero-page locations. The code is easily relocatable to other locations.
2. X counts from the “pitch value” down to 0 at a fixed rate, “whapping” the speaker each time it reaches zero.
3. Y cycles around continuously at basically the same rate; each time it reaches zero, one tick is subtracted from the duration value. When duration reaches zero, the routine returns.
4. This classic tone routine has the important feature that duration is absolute, and not dependent on pitch
5. Y is uninitialized, which presumably causes a slight jitter in the duration, unless BASIC ensures Y=0. Likewise, X in the first pitch countdown is uninitialized.
6. duration is destroyed by the routine, but pitch is not.

Here is my transcription to COMFY-6502. I have translated the “I”, “J”, and abbreviated “L”, “LI”, etc. opcodes for this example, but not yet changed Baker’s code to accept them.

(let ((comfy-6502::*symbol-table* (make-hash-table)))
  (equ speaker #xc030)
  (equ duration 1)
  (equ pitch 0)
  (comfy-6502-tests::compile-code
     (comfy-6502:loop
       ;; repeat until some clause loses: actually, only exit is
       ;; through return, so each clause should be ensured of winning.
        (LDX pitch)
        (LDA speaker)
        (not (comfy-6502:loop  ;; repeat until whap time; "whap" time is when a clause loses; NOT wins, outer loop continues
                 DEY
                 (if =0? ; has Y reached zero?
                     (not (seq (DEC duration) ; Y has reached zero, duration ticks down
                               =0?       ; if duration has not reached zero, SEQ fails, NOT wins, IF wins, inner loop continues
                               RTS)) ; duration reached zero, return
                     (seq DEX ~=0?))))))) ; Y not zero, count down pitch. If X has reached zero, SEQ loses, IF loses, inner loop exits

To understand the code, the basic COMFY principles must be understood.

1. Conditional tests (such as “=0?”, corresponding to a BEQ or BNE), “win” if they are true, “lose” if they are false.
2. Ordinary machine operations (such as LDA, DEX, RTS) always “win”
3. SEQ sequentially each enclosed form, until one “loses”, in which case SEQ “loses”, or until they all “win”, in which case SEQ “wins.”
4. LOOP executes each enclosed form, until one “loses”, in which case LOOP “loses”, continuing at the top of the loop if every form “wins.” (I have introduced an “implied” seq to Baker’s ELisp implementation.) It is SEQ stuck on potentially endless repeat.
5. NOT executes the single enclosed form, but changes “win” into “lose” and vice-versa. This is useful to keep a nested “loss” from terminating all the enclosing forms.
6. (IF test win-form lose-form) executes TEST. If TEST “wins”, WIN-FORM is executed, and its win/lose result is passed out as the result of the IF. If TEST “loses”, LOSE-FORM is executed, and its win/lose result is passed out as the result of the IF.

Note that I have chosen to initialize X on the first pass through the loop. That makes the code somewhat clearer, and I think is better style.

So what code does COMFY (as of today) generate for this? Behold.

(; reload-pitch
 (LDX :ZERO-PAGE) (:ZERO-PAGE 0)
 (LDA :ABSOLUTE) (:ABSOLUTE 49200)
; spin
 (DEY)
 (BEQ) (:BRANCH 6) ; duration-tick
 (DEX)
 (BNE) (:BRANCH 8 ) ; goto spin
 (BEQ) (:BRANCH 9) ; goto reload-pitch
; duration-tick
 (DEC :ZERO-PAGE) (:ZERO-PAGE 1)
 (BNE) (:BRANCH 2) ; goto-spin
 (RTS)
; goto spin
 (JMP :ABSOLUTE) (:LONG-BRANCH -14)
; goto reload-pitch
 (JMP :ABSOLUTE) (:LONG-BRANCH -22))

This is a symbolic “intermediate” form, not yet relocated and linked. Some keys for interpretation.

1. (BEQ), (JMP :ABSOLUTE) etc. represent one-byte opcodes, with the specified addressing mode (redundant in the case of branch instructions, which have only the branch-relative mode).
2. (:ZERO-PAGE 0) is a single-byte, value 0, tagged to indicate that it represents a reference to zero-page location 0, and is not just a immediate argument of value zero.
3. (:ABSOLUTE 49200) is a two-byte reference to the address #xC030, which will be emitted in the usual 6502 low-byte first as #x30 and #xC0.
4. (:BRANCH n) represents a short branch. It is one byte long. Note that the destination counts relative to the BRANCH byte, not relative to the next instruction, as the 6502 branch values do. (The relocater corrects for this when converting to 6502 code bytes.)
5. (:LONG-BRANCH n) is a long branch. It is two bytes long. JMP is absolute in the 6502; the relocated will deposit the absolute address by adding this value to the location of the first byte of this pair.

I have added this intermediate form because Baker’s Elisp goes directly to bytes in a fixed memory area, starting from high addresses. My goal is for a high level “COMFY module” macro to result in an intermediate form that knows its length in bytes, what zero page locations it uses, and what internal entry points it exports. Otherwise, it is relocatable by the linker. I would also like the feature that the zero-page references are symbolic (e.g. (:ZERO-PAGE duration)), in which case the linker would allocate a byte in zero-page, and all modules referring to “duration” would refer to that address. Even nicer would be the ability to do math, for instance (:ZERO-PAGE (+ duration 1)), or to emit (:ABSOLUTE (- tone-entry 1)) to encode the module entry point in the “off-by-one” method used by the “fake RTS” trick. Similarly, one could have elements such as (:BYTE (HIGH tone-entry)), representing the high-order byte of the tone-entry address, and allowing arbitrary link-time math.

As for the code itself, it has the same similar semantics as the Red book routine.[UPDATE: but not quite. See more recent post for correction.] It has a somewhat minor change in that the DEY is followed by a BNE in the original code (taken 255 out of 256 times), and by a BEQ in the COMFY version (taken only 1 out of 256 times). Any difference in the execution time will, of course, change the pitch emitted. More serious is the fact that COMFY, as coded, is biased toward forward conditional branches. The two JMP instructions after the RTS are reached only through branches that could reach their destination directly. COMFY compiles, as I mentioned, from the last instruction toward the first. Forward branches are trivially resolved, but backward branches don’t know their destination, in particular, whether the destination is a short branch away or not. The backward JMPs are created by the code for LOOP, which first emits a “placeholder” absolute jump, compiles the loop forms, including branches that might land on that jump, then patches the JMP destination to point to the first form of the LOOP.

That suggests that LOOP might be enhanced to include a “loop-tightening” phase which examines the body of the loop for forward branches (:BRANCH x) to jumps (:LONG-BRANCH y), and if x+y+1 is within range of a short branch, replaces it. (The +1 is for the JMP opcode itself.) The result would be

(; reload pitch
 (LDX :ZERO-PAGE) (:ZERO-PAGE 0)
 (LDA :ABSOLUTE) (:ABSOLUTE #XC030)
; spin
 (DEY)
 (BEQ) (:BRANCH 6) ; duration-tick
 (DEX)
 (BNE) (:BRANCH -5) ; spin
 (BEQ) (:BRANCH -12) ; reload-pitch
; duration-tick
 (DEC :ZERO-PAGE) (:ZERO-PAGE 1)
 (BNE) (:BRANCH -11) ; spin
 (RTS)
 (JMP :ABSOLUTE) (:LONG-BRANCH -14)
 (JMP :ABSOLUTE) (:LONG-BRANCH -22))

The two JMPs are now unused. This is a special case, because RTS is itself a jump. Because LOOP knows that it freshly emitted the JMP, no external code can properly reference it. If all the branches to it have been patched, and the last instruction cannot reach it, the JMP itself can be omitted.Assuming I can convince COMFY to be smart enough to omit the (proven) redundant JMPs, we are ready for comparison. Let’s re-write the original code to match the explicit X initialization, and use COMFY’s discovery that moving the LDX to the front of the loop means the absolute JMP $0002 in the original can be replaced by a BEQ.

reload-pitch LDX PITCH
             LDA $CO30
spin         DEY
             BNE not-tick ; actually, takes branch more often
; duration-tick
             DEC duration
             BEQ return
not-tick     DEX
             BNE spin
             BEQ reload-pitch ; save a byte compared to original JMP
return       RTS

COMFY, with the yet-to-be-implemented loop tightening has made the code one byte shorter, and relocatable.As mentioned before, COMFY has luckily or unluckily chosen the branch after DEY to be taken infrequently, while the author of the tone routine chose it to be taken frequently. We cannot know whether the author de-optimized to reach a lower pitch range. If so, to match the timing more closely, I can reverse the sense of the IF, causing it to emit a BNE. In this case, the hypothetical loop-tightening can eliminate one JMP, but not the other.

(; reload-pitch
 (LDX :ZERO-PAGE) (:ZERO-PAGE 0)
 (LDA :ABSOLUTE) (:ABSOLUTE 49200)
; spin
 (DEY)
 (BNE) (:BRANCH 6) ; not-duration
 (DEC :ZERO-PAGE) (:ZERO-PAGE 1)
 (BNE) (:BRANCH -6) ; spin
 (RTS)
; not-duration
 (DEX)
 (BEQ) (:BRANCH -15) ; reload-pitch
; goto-spin
 (JMP :ABSOLUTE) (:LONG-BRANCH -12)

We see this simple change affected the DEY test, but also affected the DEX test, biasing it to be taken less frequently. Perhaps an annotation could added to the COMFY language to indicate “please prefer (or expect?) this test to win/lose.” This would disrupt the tight recursive elegance of the GENBRC routine, but it might prove handy in modern architectures with their branch-prediction tendencies. It is also not so simple to change the test after DEC (:ZERO-PAGE 1) to BEQ to the RTS. That would require moving the RTS to be emitted at the end, i.e. compiled by COMFY first. I’m more interested in implementing the loop-tightening logic than attacking that brain-teaser right now.The moral may be that COMFY (plus yet-to-be-implemented optimization passes) can emit code very much in the ballpark of humans, at least for these toy examples. For cycle-level timing, however, I might follow the lead of Sassy and allow for the human to code branches and jumps explicitly. (Sassy’s example “boot sector” code actually avoids pretty much all the COMFY primitives; however, the documentation also seems to suggest that loop tightening and similar optimizations have been implemented there.) And I have yet to successfully translate Woz’s code into COMFY, probably because I have to understand it first.(Note to self: AVOID the tempting WordPress “code” button. Use the sourcecode tag, although it supports neither assembler nor Lisp.)

While I’m still digesting COMFY in my “ample spare time,” a post on comp.sys.apple2 mentioned some assemblers from “Ron” having a similar flavor: SPL for the 6502 and PIC0 for PIC 10F2xx microcontrollers. They are apparently implemented in Python, and inspired by Forth. They emit assembler.

The following is a copy of my post from the cedega forum (abridged):

Like everyone here I think we are dedicated to the cause (*nix+dx=gaming – cause we have to) and are willing to put our money where our mouth is.  We just want Cedega to put our money where the development is.  It’s like a union, we pay our dues now go sock it to the man(M$)!  It just occured to me that (M)arket ($)hare and (M)icro(S)oft… well you get it.

-Mike

I’ve been working a bit with Baker’s COMFY-6502 code; a few notes of what I have learned so far.

First, a couple of tiny bugs in the genbrc; the code miscounts the size of the branch instructions, meaning that (- l 2) should be a (+ l 2) and so on. I found it handy to enumerate each clause of the cond. Each clause handles a particular case, such as when the “lose” continuation can be reached by a short branch instruction, while the “win” continuation is far enough away to require an absolute jump.

Second, genbrc, genbr, and compile all provide the address of the resulting “continuation” as the return value. This is perhaps clear when one traces out all the recursion, but it isn’t explicitly mentioned. One interesting case is genbrc when the “win” and “lose” branch destinations are the same: one could simply emit an unconditional branch to that destination, and return the address of that branch but actually returning the destination works just as well. (In the emit routine, if the continuation does not happen to be the next instruction, the unconditional branch is, after all, emitted, moving the continuation to the front of the instruction stream, ready for the non-branching instruction to be emitted just in front of it.)

As for “upgrades” to the package, I have been focused up to this point on moving the knowledge of 6502 opcodes and addressing modes from magic decimal numbers to symbolic processing. Instead of simply emitting a decimal opcode, I have been changing the code to emit symbolic opcodes, such as (ADC ABSOLUTE), with routines to reduce these symbolic forms to the appropriate opcode, including checking for invalid opcodes. Baker’s original code will happily emit opcodes with addressing modes not supported by the chip. Currently, the compiler emits these symbolic codes into the code vector, awaiting a processing step to convert them to the decimal equivalent. Ideally, one would detect invalid addressing modes in the compilation stage, not the post-processing stage.

Some other changes I am contemplating are allowing for symbolic jump destinations, so that object code can be relocated and external labels could be used to relax the restrictions of the current scheme, which requires manually sequencing compilation and storing of addresses.

Artículo en formato hipertexto de la fabricación de un prototipo de ordenador con micro 6502. El artículo apareció en la revista “The Computer Journal”, ahora desaparecida.

http://www.hytherion.com/beattidp/comput/x65tools/diy6502/diy6502.htm 

Interesados en ejemplos de prototipos de ordenadores con micro 6502, en la línea DIY (Do It Yourself):

http://www.6502.org/homebuilt/