c64asm 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0da94793e9c3a04fdfd00747a09e1fb494c34f67
+  data.tar.gz: e85f96c230799224cee34a7a72d77f8d0c781bd8
+SHA512:
+  metadata.gz: 515a5a8ed205f58676f5ace0c58a2ee1b465f508b2b32f2957f43540c2071d4d651daa55274e9b0635bf11dc125726630b058b1206b1f72c75d879c34bbfb7a2
+  data.tar.gz: 1705421b94cd83b4e8ebe53d3ccf402ea779ec09bd440ad48d27457a94c57381e0c7f2fd5773deabc6d51b9a84a78bdefb89af7224c491af449da94031681ff6

data/.gitignore

@@ -0,0 +1,4 @@
+*.prg
+doc/*
+pkg/*
+.yardoc/*

data/.yardopts

@@ -0,0 +1,4 @@
+--charset utf-8
+--protected
+--private
+lib/

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2012 - 2014, Piotr S. Staszewski
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this 
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, 
+   this list of conditions and the following disclaimer in the documentation 
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,126 @@
+# c64asm [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/c64asm/frames)
+
+A MOS6502 assembler as a Ruby DLS, with focus on the Commodore 64.
+
+Features:
+
+- You write MOS6502 assembly naturally but still have full power of Ruby (it's awesome)
+- Macros with variables as the basic building block
+- C64 BASIC compiler built in
+- Data driven with a generating tool, I *didn't write* data.rb
+- Can output a source code representation (that I believe I've based upon some well known and established assembler)
+- Can output a disassembler-like output, useful for cycle counting
+
+Bugs:
+- No test suite
+- I believe my 'scrape opcodes table' approach missed some edge cases
+
+Todo:
+- More C64 helpers, e.g. bank switching helpers and a hash of named addresses
+- Not far away from adding a basic CPU simulator (note: this is far from an emulator)
+
+*I've written the bulk of it more than two years ago. I got to a rather cosy state of overall functionality, but I believe it misses some edge-cases. Please feel free to go nuts hacking it!*
+
+# Showcase
+
+Got the gem, in the examples folder:
+
+    $ cat hello_world.rb 
+    #!/usr/bin/env ruby
+    # encoding: utf-8
+    # See LICENSE.txt for licensing information.
+    
+    $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+    require 'c64asm'
+    
+    hello_world = C64Asm::Macro.new do
+      block C64Asm::Basic.new('10 sys 49153').code
+    
+      align 0xc000    # 49153
+      jsr 0xe544      # clear
+      ldx.d 0         # string index
+      label :load
+      lda.ax :msg     # load character
+      cmp.d 35        # hash is the end of line
+      beq :finish     # if so we're done
+      jsr 0xffd2      # chrout
+      inx             # increment index
+      jmp :load       # if not load the next character
+      label :finish
+      rts             # back to basic(s)
+      label :msg
+      data "HELLO WORLD#"
+    end
+    
+    code = hello_world.call         # compile the macro
+    puts code.dump                  # print detailed
+    #puts code.to_source            # just the source code
+    code.write!('hello_world.prg')  # save to a standard .prg file
+    
+
+Let's run it:
+
+    $ ./hello_world.rb 
+    $0801                   .block
+    $0801                   .block
+    $0801                   * = $801
+    $0801   .. .. ..        .byte $3,$8,$a,$0,$9e,$20,$34,$39,$31,$35,$33,$0,$0,$0
+    $080f                   .bend
+    $080F                   * = $c000
+    $C000   20 44 E5        jsr $e544
+    $C003   A2 00           ldx #$0
+    $C005              load
+    $C005   BD 14 C0        lda msg,x
+    $C008   C9 23           cmp #$23
+    $C00A   F0 07           beq finish
+    $C00C   20 D2 FF        jsr $ffd2
+    $C00F   E8              inx
+    $C010   4C 05 C0        jmp load
+    $C013              finish
+    $C013   60              rts
+    $C014              msg
+    $C014   .. .. ..        .text "HELLO WORLD#"
+    $c020                   .bend
+
+And run the compiled .prg with VICE:
+
+    $ x64 hello_world.prg
+
+![Hello world](https://raw.github.com/drbig/c64asm/master/examples/hello_world.png)
+
+- - -
+
+And an old demo screenshot, source not distributed 'cause it sucks, but it does compile under this gem:
+
+    $ ruby 04.rb.3
+    $ x64 04.prg
+
+![I guess that's the fourth demo third revision](https://raw.github.com/drbig/c64asm/master/examples/04.png)
+
+And it moves and stuff (no sound though), you can grab the .prg [here](https://raw.github.com/drbig/c64asm/master/examples/04.prg) and see the whole thing. The big ugly numbers are sprites - I assume the point was to make them move and be interesting, oh well.
+
+Also my raster bar code is flawed.
+
+## Additional notes
+
+First compiler. Also I believe that'd be my second/third non-trivial Ruby project. I'm also by no means a C64 hacker, but I appreciate the platform very much. It was fun, even this get-this-public-now work.
+
+This project has been inspired by a blog post of person that did a NES assembler in Common Lisp (kudos to the author!).
+
+## Contributing
+
+Follow the usual GitHub development model:
+
+1. Clone the repository
+2. Make your changes on a separate branch
+4. Make a pull request
+
+See licensing for legalese.
+
+## Licensing
+
+Standard two-clause BSD license, see LICENSE.txt for details.
+
+Any contributions will be licensed under the same conditions.
+
+Copyright (c) 2012 - 2014 Piotr S. Staszewski

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+
+GEMSPEC = eval(File.read('c64asm.gemspec'))
+require 'rubygems/package_task'
+
+task :default => :build

data/c64asm.gemspec

@@ -0,0 +1,19 @@
+require File.expand_path('../lib/c64asm/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'c64asm'
+  s.version       = C64Asm::VERSION
+  s.date          = Time.now
+
+  s.summary       = %q{Data-driven verbose DSL (almost dis-)assembler for MOS6502 with focus on Commoder 64}
+  s.description   = %q{Already two-year-old project inspirated by the NES assembler written in Lisp. The assembly DSL lets you easily unroll loops, create screen maps on the fly and just hack the thing. As you write a plain .prg file you may also dump the code to a very verbose format to ponder the machine code.}
+  s.license       = 'BSD'
+  s.authors       = ['Piotr S. Staszewski']
+  s.email         = 'p.staszewski@gmail.com'
+  s.homepage      = 'https://github.com/drbig/c64asm'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  
+  s.required_ruby_version = '>= 1.8.7' # rather tentative
+end

data/examples/hello_world.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# See LICENSE.txt for licensing information.
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'c64asm'
+
+hello_world = C64Asm::Macro.new do
+  block C64Asm::Basic.new('10 sys 49153').code
+
+  align 0xc000    # 49153
+  jsr 0xe544      # clear
+  ldx.d 0         # string index
+  label :load
+  lda.ax :msg     # load character
+  cmp.d 35        # hash is the end of line
+  beq :finish     # if so we're done
+  jsr 0xffd2      # chrout
+  inx             # increment index
+  jmp :load       # if not load the next character
+  label :finish
+  rts             # back to basic(s)
+  label :msg
+  data "HELLO WORLD#"
+end
+
+code = hello_world.call         # compile the macro
+puts code.dump                  # print detailed
+#puts code.to_source            # just the source code
+code.write!('hello_world.prg')  # save to a standard .prg file