Rationale

• Who doesn’t want a compiler for a 1 MHz 8-bit computer with 16 colours and a max resolution of 320x200?
• A 6502 assembler in R will allow for preparing/calculating data in R and then incorporating directly into the assembly code. e.g.
  • creating character sets
  • computing animation paths

Features

General features

• Basic syntax only. Similar to TASS64 syntax.
• Settable program counter
  • e.g. * = $0801
• Defined variables
  • e.g. border = $d020
• Low/High byte extraction from symbol (similar to TASS)
  • e.g. lda #<routine will store the low byte of the address of symbol routine in the A register

For integration with R

• .rtext directive to include an R string as text data
• .rbyte directive to include an R integer vector as bytes
• {...} to delimit code to be evaluated at run time to manipulate labels and variables e.g. lda {border + 1}

Installation

r64 depends on a lot of tidyverse packages as well as the minilexer package (for splitting the c64 asm code into tokens).

devtools::install_github('coolbutuseless/minilexer') # for lexing the 6502 assembly into tokens
devtools::install_github('coolbutuseless/r64')

A simple 6502 program

The following c64/6502 ASM code will clear the screen and then write Hello #rstats! at the top

asm <- '
*=$0801
  .byte $0c, $08, $0a, $00, $9e, $20  ; 10 SYS 2080
  .byte $32, $30, $38, $30, $00, $00
  .byte $00

*=$0820
      lda #$93        ; Clear the screen
      jsr $ffd2

      ldx #$00        ; initialise the offset pointer into our message
loop  lda message,x   ; load a character and write it to screen 
      and #$3f        ; Manually place chars on screen
      sta $0400,x
      inx
      cpx #$0e
      bne loop

      rts

message
    .text "Hello #rstats!"
'

Compile the program and run it using VICE

prg_df       <- r64::compile(asm)
prg_filename <- tempfile()
r64::save_prg(prg_df, prg_filename)
# system(paste("/usr/local/opt/vice/x64.app/Contents/MacOS/x64", prg_filename), wait=FALSE)

helloworld output

Output from animation using a custom character set

custom charset

Breakdown of assembly process

The compiler makes a few passes through the data to resolve symbol values.

The r64::compile() function is just a wrapper which calls the following 4 functions

1. line_tokens <- r64::create_line_tokens(asm)
   • For each line in the input break it into tokens.
   • Filter any rows that contain no instructions
2. prg_df <- r64::create_prg_df(line_tokens)
   • Create a data.frame from line_tokens
   • This is the key data structure for the compilation process
   • The compilation process is just a matter of manipulating this data.frame and merging with information about the instructions
3. prg_df <- r64::process_symbols(prg_df)
   • Resolve labels to their actual addresses
   • Replace any defined variables with their values
4. prg_df <- r64::process_zero_padding(prg_df)
   • If there are gaps between blocks of code, insert zero bytes

An example of the final form of the prg_df data.frame is show below. The actual contents of the c64 prg file is just the sequence of values in the hexbytes column.

prg_df %>%
  select(addr, label, line, opcommand, op, ophex, nbytes, hexbytes) %>%
  knitr::kable()