asm6502 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b930f2636eba5307b21d5b2c4ae91da53900323ba7014b79e654ca788d16983c
+  data.tar.gz: c51fe89160ee92824ad11da37bc79abeeb0bb03a6edcae861a004a07780b89aa
+SHA512:
+  metadata.gz: aacc404e4bb1eead3d9388f4b25db223e44276c1abd8f1cd2beb7b10e684025617c2c64085c52ca7b6c0114f617d45fa26a5455c1b3b46a29cf609bba2f05a6e
+  data.tar.gz: cdef1cfea165a0c96b07ea4ca8f337d0b81ed459cb38a5a8f87ed0c20517093dda8241c044348cd24c9f0bf6456be3fd688c8c40cce02ed3ed81b60983fec13e

data/.gitignore

@@ -0,0 +1,7 @@
+*.bin
+*.asm
+*.h
+\#*\#
+build.sh
+main.rb
+*.gem

data/README.md

@@ -0,0 +1,176 @@
+# asm6502
+
+Write 6502 assembly with Ruby code.
+
+This gem was specifically built to write Atari2600 games and comes packages with some the Ruby equivalent of the `vcs.h` and `macro.h` files. It is also in a very early stage of development and should be considered as a proof of concept. I also tried to make it less than 100 lines of code.
+
+## Installation
+
+```
+gem install asm6502
+```
+
+## Usage
+
+Ruby is quite a powerful language when it comes to building DSL like configuration files... or 6502 assembly. Let's take an example from https://8bitworkshop.com:
+
+```
+; https://8bitworkshop.com/v3.7.0/?file=examples%2Fplayfield.a&platform=vcs
+
+  processor 6502
+	include "vcs.h"
+	include "macro.h"
+
+	org  $f000
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;	
+; We're going to mess with the playfield registers, PF0, PF1 and PF2.
+; Between them, they represent 20 bits of bitmap information
+; which are replicated over 40 wide pixels for each scanline.
+; By changing the registers before each scanline, we can draw bitmaps.
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+Counter	equ $81
+
+Start	CLEAN_START
+
+NextFrame
+; This macro efficiently gives us 1 + 3 lines of VSYNC
+	VERTICAL_SYNC
+	
+; 36 lines of VBLANK
+	ldx #36
+LVBlank	sta WSYNC
+	dex
+	bne LVBlank
+; Disable VBLANK
+        stx VBLANK
+; Set foreground color
+	lda #$82
+        sta COLUPF
+; Draw the 192 scanlines
+	ldx #192
+	lda #0		; changes every scanline
+        ;lda Counter    ; uncomment to scroll!
+ScanLoop
+	sta WSYNC	; wait for next scanline
+	sta PF0		; set the PF1 playfield pattern register
+	sta PF1		; set the PF1 playfield pattern register
+	sta PF2		; set the PF2 playfield pattern register
+	stx COLUBK	; set the background color
+	adc #1		; increment A
+	dex
+	bne ScanLoop
+
+; Reenable VBLANK for bottom (and top of next frame)
+	lda #2
+        sta VBLANK
+; 30 lines of overscan
+	ldx #30
+LVOver	sta WSYNC
+	dex
+	bne LVOver
+	
+; Go back and do another frame
+	inc Counter
+	jmp NextFrame
+	
+	org $fffc
+	.word Start
+	.word Start
+```
+
+The same code written using asm6502 will be something like:
+
+```ruby
+require "asm6502"
+include Asm6502
+
+require 'asm6502/vcs'
+
+# We're going to mess with the playfield registers, PF0, PF1 and PF2.
+# Between them, they represent 20 bits of bitmap information
+# which are replicated over 40 wide pixels for each scanline.
+# By changing the registers before each scanline, we can draw bitmaps.
+
+Org[0x0080]
+Label[:counter, 1]
+
+Output[ARGV[0]] do
+  Org[0xf000]
+  Label[:reset]
+
+    clean_start
+
+  Label[:next_frame]
+    # This macro efficiently gives us 1 + 3 lines of VSYNC
+    vertical_sync
+
+    # 36 lines of VBLANK
+    ldx 36
+
+  Label[:lv_blank]
+
+    sta :WSYNC
+    dex
+    bne :lv_blank
+    
+    # Disable VBLANK
+    stx :VBLANK
+
+    # Set foreground color
+    lda 0x82
+    sta :COLUPF
+
+    # Draw the 192 scanline
+    ldx 192
+    lda 0 # changes every scanline
+
+  Label[:scan_loop]
+
+    sta :WSYNC  # wait for next scanline
+    sta :PF0    # set the PF0 playfield pattern register
+    sta :PF1    # set the PF1 playfield pattern register
+    sta :PF2    # set the PF1 playfield pattern register
+    stx :COLUBK # set the background color
+    adc 1       # increment A
+    dex
+    bne :scan_loop
+
+    # Reenable VBLANK for bottom (and top of next fram
+    lda 2
+    sta :VBLANK
+
+    #  30 lines of overscan
+    ldx 30
+
+  Label[:lv_over]
+    sta :WSYNC
+    dex
+    bne :lv_over
+
+    # Go back and do another frame
+    inc :counter
+    jmp :next_frame
+
+  Org[0xfffa]
+
+  Mem[2] = :reset
+  Mem[2] = :reset
+  Mem[2] = :reset
+end
+```
+
+As you can see, even though it looks like assembly, it it actually Ruby code: each operator is a Ruby fonction and there's also a few control stuff:
+
+* `Org[addr]`: set the current memory index.
+* `Label[name, size = 0]`: Give a name to the current memory index and increase it by `size`.
+* `Output[path] { actual code to output }`: Everything in the block will be written in the final file `path`.
+* `Mem[size] = value`: set the memory at the current memory index to value and increases it by `size`.
+
+## Disclaimer
+
+This is just a proof and concept, I'm not sure everything works properly, I'm not sure about the way it works and I'm pretty certain it doesn't handle every use case. I'll try later to build an actual game from scratch with it.
+

data/asm6502.gemspec

@@ -0,0 +1,9 @@
+Gem::Specification.new do |s|
+  s.name = "asm6502"
+  s.version = "0.1.1"
+  s.author = "Gallimimus"
+  s.date = %q{2020-12-31}
+  s.summary = %q{Write 6502 assembly from Ruby code}
+  s.files = `git ls-files -z`.split("\x0")
+  s.require_paths = ["lib"]
+end

data/lib/asm6502.rb

@@ -0,0 +1,97 @@
+module Asm6502
+  X, Y = [ 'x', 'y' ]
+  @@org = 0
+  @@labels = {}
+  @@mem = []
+
+  class Label
+    def self.[](value, size = 0)
+      @@labels[value] = @@org
+      @@org += size
+    end
+  end
+
+  class Org
+    def self.[](value) @@org = value; end
+  end
+
+  class Output
+    def self.[](path, &block)
+      File.open(path, 'w+') do |f|
+        @@mem = []
+        block.call
+        f.write(@@mem.drop_while(&:nil?).reverse.drop_while(&:nil?).reverse.map(&:to_i).pack("c*"))
+      end
+    end
+  end
+
+  class Mem < Struct.new(:length, :value)
+    def self.[]=(length, value)
+      value = value.kind_of?(Symbol) ? @@labels[value] : value
+      sprintf("%0#{value.size * 8 + 2}b", value)[2..-1].scan(/.{8}/).last(length).map { |i| i.to_i(2) }.reverse.each_with_index do |digit, index|
+        @@mem[@@org + index] = digit
+      end
+      @@org += length
+    end
+  end
+
+  {
+    adc: { im: 0x69, zp: 0x65, zx: 0x75, ab: 0x6d, ax: 0x7d, ay: 0x79, ix: 0x61, iy: 0x71 },
+    and: { im: 0x29, zp: 0x25, zx: 0x35, ab: 0x2d, ax: 0x3d, ay: 0x39, ix: 0x21, iy: 0x31 },
+    sbc: { im: 0xe9, zp: 0xe5, zx: 0xf5, ab: 0xed, ax: 0xfd, ay: 0xf9, ix: 0xe1, iy: 0xf1 },
+    asl: { ac: 0x0a, zp: 0x06, zx: 0x16, ab: 0x0e, ax: 0x1e }, bit: { zp: 0x24, ab: 0x2c },
+    cmp: { im: 0xc9, zp: 0xc5, zx: 0xd5, ab: 0xcd, ax: 0xdd, ay: 0xd9, ix: 0xc1, iy: 0xd1 },
+    cpx: { im: 0xe0, zp: 0xe4, ab: 0xec }, cpy: { im: 0xc0, zp: 0xc4, ab: 0xcc },
+    dec: { zp: 0xc6, zx: 0xd6, ab: 0xce, ax: 0xde },
+    ldx: { im: 0xa2, zp: 0xa6, zy: 0xb6, ab: 0xae, ay: 0xbe },
+    ldy: { im: 0xa0, zp: 0xa4, zx: 0xb4, ab: 0xac, ax: 0xbc },
+    eor: { im: 0x49, zp: 0x45, zx: 0x55, ab: 0x4d, ax: 0x5d, ay: 0x59, ix: 0x41, iy: 0x51 },
+    inc: { zp: 0xe6, zx: 0xf6, ab: 0xee, ax: 0xfe },
+    jmp: { ab: 0x4c, in: 0x6c }, sr:  { ab: 0x20 }, lsr: { ac: 0x4a, zx: 0x46, ab: 0x4e, ax: 0x5e },
+    lda: { im: 0xa9, zp: 0xa5, zx: 0xb5, ab: 0xad, ax: 0xbd, ay: 0xb9, ix: 0xa1, iy: 0xb1 },
+    ora: { im: 0x09, zp: 0x05, zx: 0x15, ab: 0x0d, ax: 0x1d, ay: 0x19, ix: 0x01, iy: 0x11 },
+    rol: { ac: 0x2a, zp: 0x26, zx: 0x36, ab: 0x2e, ax: 0x3e },
+    ror: { ac: 0x6a, zp: 0x66, zx: 0x76, ab: 0x6e, ax: 0x7e },
+    sty: { zp: 0x84, zx: 0x94, ab: 0x8c }, stx: { zp: 0x86, zy: 0x96, ab: 0x8e },
+    sta: { zp: 0x85, zx: 0x95, ab: 0x8d, ax: 0x9d, ay: 0x99, ix: 0x81, iy: 0x91 },
+    bpl: { rl: 0x10 }, bmi: { rl: 0x30 }, bvc: { rl: 0x50 }, bne: { rl: 0xd0 },
+    bvs: { rl: 0x70 }, bcc: { rl: 0x90 }, bcs: { rl: 0xb0 }, beq: { rl: 0xf0 },
+    brk: 0x00, nop: 0xea, rti: 0x40, clc: 0x18, sec: 0x38, cli: 0x58, sei: 0x78, clv: 0xb8,
+    cld: 0xd8, sed: 0xf8, txs: 0x9a, tsx: 0xba, pha: 0x48, rts: 0x60, pla: 0x68, php: 0x08,
+    plp: 0x28, tax: 0xaa, txa: 0x8a, dex: 0xca, inx: 0xe8, tay: 0xa8, tya: 0x98, dey: 0x88, iny: 0xc8
+  }.each do |opcode, modes|
+    define_method(opcode) do |*args|
+      if args[0].nil? && modes.kind_of?(Integer)
+        [ modes ]
+      elsif modes[:ac] && args[0].nil?
+        [ modes[:ac] ]
+      elsif modes[:rl] && args[0].kind_of?(Symbol)
+        [ modes[:rl], @@labels[args[0]] - @@org - 2 ]
+      elsif modes[:im] && args[0].kind_of?(Integer) && args[0] < 0xff
+        [ modes[:im], args[0] ]
+      elsif modes[:zp] && args[0].kind_of?(Symbol) && @@labels[args[0]] < 0xff && args[1].nil?
+        [ modes[:zp], @@labels[args[0]] ]
+      elsif modes[:zx] && args[0].kind_of?(Symbol) && @@labels[args[0]] < 0xff && args[1].eql?(X)
+        [ modes[:zx], @@labels[args[0]] ]
+      elsif modes[:ab] && args[0].kind_of?(Symbol) && args[1].nil?
+        [ modes[:ab], @@labels[args[0]] & 0xff, @@labels[args[0]] >> 8 & 0xff ]
+      elsif modes[:ax] && args[0].kind_of?(Symbol) && args[1].eql?(X)
+        [ modes[:ax], @@labels[args[0]] & 0xff, @@labels[args[0]] >> 8 & 0xff ]
+      elsif modes[:ay] && args[0].kind_of?(Symbol) && args[1].eql?(Y)
+        [ modes[:ay], @@labels[args[0]] & 0xff, @@labels[args[0]] >> 8 & 0xff ]
+      elsif modes[:ix] && args[0].kind_of?(Array) && args[0].length == 2 && args[0][0].kind_of?(Symbol) && args[0][1].eql?(X) && args[1].nil?
+        [ modes[:ix], @@labels[args[0][0]] & 0xff ]
+      elsif modes[:iy] && args[0].kind_of?(Array) && args[0].length == 1 && args[0][0].kind_of?(Symbol) && args[1].eql?(Y)
+        [ modes[:iy], @@labels[args[0][0]] & 0xff ]
+      elsif modes[:in] && args[0].kind_of?(Array) && args[0].length == 1 && args[0][0].kind_of?(Symbol)
+        [ modes[:in], @@labels[args[0][0]] & 0xff, @@labels[args[0][0]] >> 8 & 0xff ]
+      else
+        raise ArgumentError.new("No suitable mode found for '#{opcode} #{args.join(" ")}'")
+      end.each do |opi|
+        Mem[1] = opi
+      end
+    rescue => error
+      raise ArgumentError.new("Unexpected error on '#{opcode} #{args.join(" ")}': #{error}")
+    end
+  end
+end

data/lib/asm6502/vcs.rb

@@ -0,0 +1,2 @@
+require 'asm6502/vcs/vcs'
+require 'asm6502/vcs/macro'

data/lib/asm6502/vcs/macro.rb

@@ -0,0 +1,157 @@
+# MACRO.H
+# Version 1.06, 3/SEPTEMBER/2004
+
+VERSION_MACRO         = 106
+
+#
+# THIS FILE IS EXPLICITLY SUPPORTED AS A DASM-PREFERRED COMPANION FILE
+# PLEASE DO *NOT* REDISTRIBUTE MODIFIED VERSIONS OF THIS FILE!
+#
+# This file defines DASM macros useful for development for the Atari 2600.
+# It is distributed as a companion machine-specific support package
+# for the DASM compiler. Updates to this file, DASM, and associated tools are
+# available at at http://www.atari2600.org/dasm
+#
+# Many thanks to the people who have contributed.  If you take issue with the
+# contents, or would like to add something, please write to me
+# (atari2600@taswegian.com) with your contribution.
+#
+# Latest Revisions...
+#
+# 1.06  03/SEP/2004     - nice revision of VERTICAL_BLANK (Edwin Blink)
+# 1.05  14/NOV/2003     - Added VERSION_MACRO equate (which will reflect 100x version #)
+#                         This will allow conditional code to verify MACRO.H being
+#                         used for code assembly.
+# 1.04  13/NOV/2003     - SET_POINTER macro added (16-bit address load)
+#
+# 1.03  23/JUN/2003     - CLEAN_START macro added - clears TIA, RAM, registers
+#
+# 1.02  14/JUN/2003     - VERTICAL_SYNC macro added
+#                         (standardised macro for vertical synch code)
+# 1.01  22/MAR/2003     - SLEEP macro added. 
+#                       - NO_ILLEGAL_OPCODES switch implemented
+# 1.0 22/MAR/2003   Initial release
+
+# Note: These macros use illegal opcodes.  To disable illegal opcode usage, 
+#   define the symbol NO_ILLEGAL_OPCODES (-DNO_ILLEGAL_OPCODES=1 on command-line).
+#   If you do not allow illegal opcode usage, you must include this file 
+#   *after* including VCS.H (as the non-illegal opcodes access hardware
+#   registers and require them to be defined first).
+
+# Available macros...
+#   SLEEP n             - sleep for n cycles
+#   VERTICAL_SYNC       - correct 3 scanline vertical synch code
+#   CLEAN_START         - set machine to known state on startup
+#   SET_POINTER         - load a 16-bit absolute to a 16-bit variable
+
+#-------------------------------------------------------------------------------
+# SLEEP duration
+# Original author: Thomas Jentzsch
+# Inserts code which takes the specified number of cycles to execute.  This is
+# useful for code where precise timing is required.
+# ILLEGAL-OPCODE VERSION DOES NOT AFFECT FLAGS OR REGISTERS.
+# LEGAL OPCODE VERSION MAY AFFECT FLAGS
+# Uses illegal opcode (DASM 2.20.01 onwards).
+
+def sleep(cycles)  #usage: sleep n (n>1)
+    if cycles < 2
+        puts "MACRO ERROR: 'SLEEP': Duration must be > 1"
+        exit 1
+    end
+
+    if cycles & 1
+        bit :VSYNC
+    end
+
+    cycles -= 3
+
+    (cycles / 2).times do
+        nop
+    end
+end
+
+#-------------------------------------------------------------------------------
+# VERTICAL_SYNC
+# revised version by Edwin Blink -- saves bytes!
+# Inserts the code required for a proper 3 scanline vertical sync sequence
+# Note: Alters the accumulator
+
+# OUT: A = 0
+
+def vertical_sync
+                lda 0b1110         #%1110          # each '1' bits generate a VSYNC ON line (bits 1..3)
+Label[:VSLP1]
+                sta :WSYNC   # 1st '0' bit resets Vsync, 2nd '0' bit exit loop
+                sta :VSYNC
+                lsr
+                bne :VSLP1          # branch until VYSNC has been reset
+
+end
+
+#-------------------------------------------------------------------------------
+# CLEAN_START
+# Original author: Andrew Davie
+# Standardised start-up code, clears stack, all TIA registers and RAM to 0
+# Sets stack pointer to $FF, and all registers to 0
+# Sets decimal mode off, sets interrupt flag (kind of un-necessary)
+# Use as very first section of code on boot (ie: at reset)
+# Code written to minimise total ROM usage - uses weird 6502 knowledge :)
+
+def clean_start
+                sei
+                cld
+
+                ldx 0
+                txa
+                tay
+Label[:CLEAR_STACK]
+                dex
+                txs
+                pha
+                bne :CLEAR_STACK     # SP=$FF, X = A = Y = 0
+
+end
+
+#-------------------------------------------------------
+# SET_POINTER
+# Original author: Manuel Rotschkar
+#
+# Sets a 2 byte RAM pointer to an absolute address.
+#
+# Usage: SET_POINTER pointer, address
+# Example: SET_POINTER SpritePTR, SpriteData
+#
+# Note: Alters the accumulator, NZ flags
+# IN 1: 2 byte RAM location reserved for pointer
+# IN 2: absolute address
+
+def set_pointer(pointer, address)
+    LDA #<.ADDRESS  # Get Lowbyte of Address
+    STA .POINTER    # Store in pointer
+    LDA #>.ADDRESS  # Get Hibyte of Address
+    STA .POINTER+1  # Store in pointer+1
+end
+
+#-------------------------------------------------------
+# BOUNDARY byte#
+# Original author: Denis Debro (borrowed from Bob Smith / Thomas)
+#
+# Push data to a certain position inside a page and keep count of how
+# many free bytes the programmer will have.
+#
+# eg: BOUNDARY 5    # position at byte #5 in page
+
+# .FREE_BYTES SET 0
+#    MAC BOUNDARY
+#       REPEAT 256
+#          IF <. % {1} = 0
+#             MEXIT
+#          ELSE
+# .FREE_BYTES SET .FREE_BYTES + 1
+#             .byte $00
+#          ENDIF
+#       REPEND
+#    ENDM
+
+
+# EOF

data/lib/asm6502/vcs/vcs.rb

@@ -0,0 +1,91 @@
+require "asm6502"
+include Asm6502
+
+TIA_BASE_ADDRESS = 0
+TIA_BASE_READ_ADDRESS = TIA_BASE_ADDRESS
+TIA_BASE_WRITE_ADDRESS = TIA_BASE_ADDRESS
+
+Org[TIA_BASE_WRITE_ADDRESS]
+
+Label[:VSYNC, 1]    # $00   0000 00x0   Vertical Sync Set-Clear
+Label[:VBLANK, 1]   # $01   xx00 00x0   Vertical Blank Set-Clear
+Label[:WSYNC, 1]    # $02   ---- ----   Wait for Horizontal Blank
+Label[:RSYNC, 1]    # $03   ---- ----   Reset Horizontal Sync Counter
+Label[:NUSIZ0, 1]   # $04   00xx 0xxx   Number-Size player/missle 0
+Label[:NUSIZ1, 1]   # $05   00xx 0xxx   Number-Size player/missle 1
+Label[:COLUP0, 1]   # $06   xxxx xxx0   Color-Luminance Player 0
+Label[:COLUP1, 1]   # $07   xxxx xxx0   Color-Luminance Player 1
+Label[:COLUPF, 1]   # $08   xxxx xxx0   Color-Luminance Playfield
+Label[:COLUBK, 1]   # $09   xxxx xxx0   Color-Luminance Background
+Label[:CTRLPF, 1]   # $0A   00xx 0xxx   Control Playfield, Ball, Collisions
+Label[:REFP0, 1]    # $0B   0000 x000   Reflection Player 0
+Label[:REFP1, 1]    # $0C   0000 x000   Reflection Player 1
+Label[:PF0, 1]      # $0D   xxxx 0000   Playfield Register Byte 0
+Label[:PF1, 1]      # $0E   xxxx xxxx   Playfield Register Byte 1
+Label[:PF2, 1]      # $0F   xxxx xxxx   Playfield Register Byte 2
+Label[:RESP0, 1]    # $10   ---- ----   Reset Player 0
+Label[:RESP1, 1]    # $11   ---- ----   Reset Player 1
+Label[:RESM0, 1]    # $12   ---- ----   Reset Missle 0
+Label[:RESM1, 1]    # $13   ---- ----   Reset Missle 1
+Label[:RESBL, 1]    # $14   ---- ----   Reset Ball
+Label[:AUDC0, 1]    # $15   0000 xxxx   Audio Control 0
+Label[:AUDC1, 1]    # $16   0000 xxxx   Audio Control 1
+Label[:AUDF0, 1]    # $17   000x xxxx   Audio Frequency 0
+Label[:AUDF1, 1]    # $18   000x xxxx   Audio Frequency 1
+Label[:AUDV0, 1]    # $19   0000 xxxx   Audio Volume 0
+Label[:AUDV1, 1]    # $1A   0000 xxxx   Audio Volume 1
+Label[:GRP0, 1]     # $1B   xxxx xxxx   Graphics Register Player 0
+Label[:GRP1, 1]     # $1C   xxxx xxxx   Graphics Register Player 1
+Label[:ENAM0, 1]    # $1D   0000 00x0   Graphics Enable Missle 0
+Label[:ENAM1, 1]    # $1E   0000 00x0   Graphics Enable Missle 1
+Label[:ENABL, 1]    # $1F   0000 00x0   Graphics Enable Ball
+Label[:HMP0, 1]     # $20   xxxx 0000   Horizontal Motion Player 0
+Label[:HMP1, 1]     # $21   xxxx 0000   Horizontal Motion Player 1
+Label[:HMM0, 1]     # $22   xxxx 0000   Horizontal Motion Missle 0
+Label[:HMM1, 1]     # $23   xxxx 0000   Horizontal Motion Missle 1
+Label[:HMBL, 1]     # $24   xxxx 0000   Horizontal Motion Ball
+Label[:VDELP0, 1]   # $25   0000 000x   Vertical Delay Player 0
+Label[:VDELP1, 1]   # $26   0000 000x   Vertical Delay Player 1
+Label[:VDELBL, 1]   # $27   0000 000x   Vertical Delay Ball
+Label[:RESMP0, 1]   # $28   0000 00x0   Reset Missle 0 to Player 0
+Label[:RESMP1, 1]   # $29   0000 00x0   Reset Missle 1 to Player 1
+Label[:HMOVE, 1]    # $2A   ---- ----   Apply Horizontal Motion
+Label[:HMCLR, 1]    # $2B   ---- ----   Clear Horizontal Move Registers
+Label[:CXCLR, 1]    # $2C   ---- ----   Clear Collision Latches
+
+Org[TIA_BASE_READ_ADDRESS]
+
+Label[:CXM0P, 1]    # $00       xx00 0000       Read Collision  M0-P1   M0-P0
+Label[:CXM1P, 1]    # $01       xx00 0000                       M1-P0   M1-P1
+Label[:CXP0FB, 1]   # $02       xx00 0000                       P0-PF   P0-BL
+Label[:CXP1FB, 1]   # $03       xx00 0000                       P1-PF   P1-BL
+Label[:CXM0FB, 1]   # $04       xx00 0000                       M0-PF   M0-BL
+Label[:CXM1FB, 1]   # $05       xx00 0000                       M1-PF   M1-BL
+Label[:CXBLPF, 1]   # $06       x000 0000                       BL-PF   -----
+Label[:CXPPMM, 1]   # $07       xx00 0000                       P0-P1   M0-M1
+Label[:INPT0, 1]    # $08       x000 0000       Read Pot Port 0
+Label[:INPT1, 1]    # $09       x000 0000       Read Pot Port 1
+Label[:INPT2, 1]    # $0A       x000 0000       Read Pot Port 2
+Label[:INPT3, 1]    # $0B       x000 0000       Read Pot Port 3
+Label[:INPT4, 1]    # $0C       x000 0000       Read Input (Trigger) 0
+Label[:INPT5, 1]    # $0D       x000 0000       Read Input (Trigger) 1
+
+Org[0x280]
+
+Label[:SWCHA, 1]    # $280      Port A data register for joysticks:
+                    #           Bits 4-7 for player 1.  Bits 0-3 for player 2.
+
+Label[:SWACNT, 1]   # $281      Port A data direction register (DDR)
+Label[:SWCHB, 1]    # $282      Port B data (console switches)
+Label[:SWBCNT, 1]   # $283      Port B DDR
+Label[:INTIM, 1]    # $284      Timer output
+
+Label[:TIMINT, 1]   # $285
+
+# Unused/undefined registers ($285-$294)
+Label[nil, 14]
+
+Label[:TIM1T, 1]    # $294      set 1 clock interval
+Label[:TIM8T, 1]    # $295      set 8 clock interval
+Label[:TIM64T, 1]   # $296      set 64 clock interval
+Label[:T1024T, 1]   # $297      set 1024 clock interval

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: asm6502
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Gallimimus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-31 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- asm6502.gemspec
+- lib/asm6502.rb
+- lib/asm6502/vcs.rb
+- lib/asm6502/vcs/macro.rb
+- lib/asm6502/vcs/vcs.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Write 6502 assembly from Ruby code
+test_files: []