n65 0.5.0

data/utils/midi/source/event.cpp

@@ -0,0 +1,96 @@
+#include "event.h"
+
+namespace Midi {
+
+////
+//  Default constructor
+Event::Event(void) : 
+    m_delta(0), m_size(0), 
+    m_data_size(0), m_status(0),
+    m_meta_type(0), m_parameter1(0),
+    m_parameter2(0), m_data(NULL) { } 
+
+
+////
+//  Constructor to set specific fields
+Event::Event(int delta, int status, int parameter1, int parameter2) :
+    m_delta(delta), m_size(4), 
+    m_data_size(0), m_status(status),
+    m_meta_type(0), m_parameter1(parameter1),
+    m_parameter2(parameter2), m_data(NULL) { } 
+
+
+////
+//  Use a file pointer to initialize 
+void Event::init_from_file(FILE *fp, unsigned char last_status){
+    fpos_t saved_position;
+    unsigned int value_size;
+    //  All types of events are preceeded by a uintvar delta time
+    m_delta = read_variable_length(fp, &value_size);
+    m_size += value_size;
+
+    //  All types then have a status byte, unless they are reusing
+    //  the previous status, get ready to rewind if this is the case.
+    fgetpos(fp, &saved_position);
+    fread(&m_status, sizeof(unsigned char), 1, fp);
+    m_size++;
+
+    if(!is_status_byte(m_status)){
+        //  This is not a status byte, so it must be reusing the previous one, Rewind
+        m_status = last_status;  
+        fsetpos(fp, &saved_position);
+        m_size--;
+    }
+
+    switch(m_status){
+        case 0xFF: // Meta
+            //  This will have a meta sub type
+            fread(&m_meta_type, sizeof(unsigned char), 1, fp);
+            m_size++;
+            //  Now a variable size for data
+            m_data_size = read_variable_length(fp, &value_size);
+            m_size += value_size;
+            //  Finally, read the meta data
+            m_data = malloc(sizeof(unsigned char) * m_data_size);
+            fread(m_data, sizeof(unsigned char), m_data_size, fp);
+            m_size += m_data_size;
+            break;
+        case 0xF0: // Sysex
+        case 0xF7: // Sysex
+            //  Sysex data runs until the next 0xF0 or 0xF7, count how many byte to allocate, and rewind
+            fgetpos(fp, &saved_position);
+            while(m_status != fgetc(fp)){
+                m_data_size++;
+            }
+            fsetpos(fp, &saved_position);
+
+            m_data = malloc(sizeof(unsigned char) * m_data_size);
+            fread(m_data, sizeof(unsigned char), m_data_size, fp);
+            m_size += (m_data_size + 1);
+            fgetc(fp); //  Throw away the end byte, although it counts for size
+            break;
+        default:   // Midi
+            fread(&m_parameter1, sizeof(unsigned char), 1, fp);
+            fread(&m_parameter2, sizeof(unsigned char), 1, fp);
+            m_size += 2;
+            break;
+    }
+}
+
+
+void Event::init_midi(int delta, int status, int parameter1, int parameter2){
+    m_delta = delta;
+    m_status = status;
+    m_parameter1 = parameter1;
+    m_parameter2 = parameter2;
+    m_size = 4;
+}
+
+
+Event::~Event(void){
+    if(m_data){
+        free(m_data);
+    }
+}
+
+}

data/utils/midi/source/file.cpp

@@ -0,0 +1,37 @@
+#include "file.h"
+
+namespace Midi {
+
+File::File(void){
+    m_header.cookie[0] = m_header.cookie[1] = m_header.cookie[2] = m_header.cookie[3] = 0;
+    m_header.size = 0;
+}
+
+
+void File::init_from_file(const char *filename){
+    FILE *fp = fopen(filename, "rb");
+    fread(&m_header, sizeof(midi_header_t), 1, fp);
+    //  Fix up this Big Endian stuff
+    m_header.size = swap_endian_32(m_header.size);
+    m_header.format = swap_endian_16(m_header.format);
+    m_header.track_count = swap_endian_16(m_header.track_count);
+    m_header.ticks_per_quarter_note = swap_endian_16(m_header.ticks_per_quarter_note);
+
+    //  Read each track
+    Track *track;
+    for(int i = 0; i < m_header.track_count; i++){
+        track = new Track();
+        track->init_from_file(fp);
+        m_tracks.push_back(track);
+    }
+}
+
+
+File::~File(void){
+    //  Free all the midi tracks
+    for(unsigned int i = 0; i < m_tracks.size(); i++){
+        delete m_tracks[i];
+    }
+}
+
+}

data/utils/midi/source/helpers.cpp

@@ -0,0 +1,46 @@
+#include "helpers.h"
+
+
+namespace Midi {
+
+////
+//  I have eliminated any doubt that this function works on variable
+//  length uintvars up to 4 bytes.
+unsigned int read_variable_length(FILE *fp, unsigned int *value_size) {
+    unsigned int value;
+    *value_size = 1;
+
+    if((value = fgetc(fp)) & 0x80){
+        unsigned char c;
+        value &= 0x7F;
+        do{
+            (*value_size)++;
+            value = (value << 7) + ((c = fgetc(fp)) & 0x7F);
+        } while (c & 0x80);
+    }
+    return(value);
+}
+
+
+////
+//  Swap 4 bytes
+int swap_endian_32(int big_endian){
+    register int little_endian;
+    little_endian =  (big_endian & 0x000000FF);
+    little_endian = ((big_endian & 0x0000FF00) >> 0x08) | (little_endian << 0x08);
+    little_endian = ((big_endian & 0x00FF0000) >> 0x10) | (little_endian << 0x08);
+    little_endian = ((big_endian & 0xFF000000) >> 0x18) | (little_endian << 0x08);
+    return(little_endian);
+}
+
+
+////
+//  Swap 2 bytes
+short swap_endian_16(short big_endian){
+  register short little_endian;
+  little_endian =  (big_endian & 0x00FF);
+  little_endian = ((big_endian & 0xFF00) >> 0x08) | (little_endian << 0x08);
+  return(little_endian);
+}
+
+}

data/utils/midi/source/track.cpp

@@ -0,0 +1,37 @@
+#include "track.h"
+
+namespace Midi {
+
+Track::Track(void){
+    m_header.cookie[0] = m_header.cookie[1] = m_header.cookie[2] = m_header.cookie[3] = 0;
+    m_header.size = 0;
+    m_total_size = 0;
+}
+
+
+void Track::init_from_file(FILE *fp){
+    Event *track_event;
+    unsigned int bytes_read = 0;
+    unsigned char last_status = 0x0;
+
+    fread(&m_header, sizeof(midi_track_header_t), 1, fp);
+    m_header.size = swap_endian_32(m_header.size);
+    if(m_header.size == 0) return;
+
+    while(bytes_read < m_header.size){
+        track_event = new Event();
+        track_event->init_from_file(fp, last_status);
+        m_events.push_back(track_event);
+        last_status = track_event->status();
+        bytes_read += track_event->bytes_read();
+    }
+}
+
+Track::~Track(void){
+    //  Free all the track events
+    for(unsigned int i = 0; i < m_events.size(); i++){
+        delete m_events[i];
+    }
+}
+
+}

data/utils/opcode_table_to_yaml.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+###############################################################################
+##  http://www.6502.org/tutorials/6502opcodes.html
+##  This web page has information about each and every 6502 instruction
+##  Specifically: 
+##
+##  - Description of what each of the instructions do
+##  - Which modes are supported by which instructions, immediate, zero page
+##    zero page x, and y, absolute, indirect, relative etc.
+##  - The hex codes each instruction assembles to, in each mode.
+##  - The lengths in bytes of each instruction, by mode
+##  - The possibly variable number of cycles each instruction takes.
+##
+##  There are 56 of them, and in my programmer laziness I just wrote this
+##  script to parse the page into the data structure that you see in 
+##  opcodes.yaml.  This really helped in creating the assembler, and
+##  it had basically everything I needed to know, and sped up writing
+##  this by huge factor.  So, yay to this page, and this script!
+
+require 'yaml'
+
+##  Instruction name, and output structure to fill in.
+name = :adc
+output = {name => {}}
+
+##  Copy paste the tables from that website into this heredoc:
+text =<<-TEXT
+Immediate     ADC #$44      $69  2   2
+Zero Page     ADC $44       $65  2   3
+Zero Page,X   ADC $44,X     $75  2   4
+Absolute      ADC $4400     $6D  3   4
+Absolute,X    ADC $4400,X   $7D  3   4+
+Absolute,Y    ADC $4400,Y   $79  3   4+
+Indirect,X    ADC ($44,X)   $61  2   6
+Indirect,Y    ADC ($44),Y   $71  2   5+
+TEXT
+
+
+##  And now iterate over each line to extract the info
+lines = text.split(/\n/)
+lines.each do |line|
+
+  ##  Grab out the values we care about
+  parts = line.split
+  cycles, len, hex = parts[-1], parts[-2], parts[-3]
+  hex = "0x%X" % hex.gsub('$', '').to_i(16)
+
+  match_data = cycles.match(/([0-9]+)(\+?)/)
+  cycles = match_data[1]
+  boundary = match_data[2]
+  hash = {:hex => hex, :len => len, :cycles => cycles, :boundry_add => boundary != ""}
+
+  ##  And now decide which mode the line belongs to, collecting each listed mode
+  hash = case line
+  when /^Accumulator/
+    {:accumulator => hash}
+  when /^Immediate/
+    {:immediate => hash}
+  when /^Zero Page,X/
+    {:zero_page_x => hash}
+  when /^Zero Page,Y/
+    {:zero_page_y => hash}
+  when /^Zero Page/
+    {:zero_page => hash}
+  when /^Absolute,X/
+    {:absolute_x => hash}
+  when /^Absolute,Y/
+    {:absolute_y => hash}
+  when /^Absolute/
+    {:absolute => hash}
+  when /^Indirect,X/
+    {:indirect_x => hash}
+  when /^Indirect,Y/
+    {:indirect_y => hash}
+  when /^Indirect/
+    {:indirect => hash}
+  when /^Implied/
+    {:implied => hash}
+  else 
+    {}
+  end
+  output[name].merge!(hash)
+end
+
+##  Now output some yaml, and I only had to do this about 45 times
+##  instead of laboriously and mistak-pronely doing it by hand.
+puts YAML.dump(output).gsub("'", '')
+
+##  See opcodes.yaml
+

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: n65
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Safiire
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: An NES assembler for the 6502 microprocessor written in Ruby
+email:
+- safiire@irkenkitties.com
+executables:
+- n65
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/n65
+- data/opcodes.yaml
+- examples/beep.asm
+- examples/demo.asm
+- examples/mario2.asm
+- examples/mario2.char
+- examples/music_driver.asm
+- examples/noise.asm
+- examples/pulse_chord.asm
+- images/assembler_demo.png
+- lib/n65.rb
+- lib/n65/directives/ascii.rb
+- lib/n65/directives/bytes.rb
+- lib/n65/directives/dw.rb
+- lib/n65/directives/enter_scope.rb
+- lib/n65/directives/exit_scope.rb
+- lib/n65/directives/inc.rb
+- lib/n65/directives/incbin.rb
+- lib/n65/directives/ines_header.rb
+- lib/n65/directives/label.rb
+- lib/n65/directives/org.rb
+- lib/n65/directives/segment.rb
+- lib/n65/directives/space.rb
+- lib/n65/front_end.rb
+- lib/n65/instruction.rb
+- lib/n65/instruction_base.rb
+- lib/n65/memory_space.rb
+- lib/n65/opcodes.rb
+- lib/n65/parser.rb
+- lib/n65/regexes.rb
+- lib/n65/symbol_table.rb
+- lib/n65/version.rb
+- n65.gemspec
+- nes_lib/nes.sym
+- test/test_memory_space.rb
+- test/test_symbol_table.rb
+- utils/midi/Makefile
+- utils/midi/c_scale.mid
+- utils/midi/convert
+- utils/midi/guitar.mid
+- utils/midi/include/event.h
+- utils/midi/include/file.h
+- utils/midi/include/helpers.h
+- utils/midi/include/track.h
+- utils/midi/lil_melody.mid
+- utils/midi/mi_feabhra.mid
+- utils/midi/midi_to_nes.rb
+- utils/midi/source/convert.cpp
+- utils/midi/source/event.cpp
+- utils/midi/source/file.cpp
+- utils/midi/source/helpers.cpp
+- utils/midi/source/track.cpp
+- utils/opcode_table_to_yaml.rb
+homepage: http://github.com/safiire/n65
+licenses:
+- GPL2
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: An NES assembler for the 6502 microprocessor written in Ruby
+test_files:
+- test/test_memory_space.rb
+- test/test_symbol_table.rb