byteboozer2 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ff05a3ba454e03b5bb263f96bae094a8f1dbeb11
+  data.tar.gz: ed570a340f698b625493d14dbdf90c452352565d
+SHA512:
+  metadata.gz: 5a026071154ecd1351fe99a05fe100baa9e27e96d2680b03d20f73dea17c2569a87135911d20d75edcff8b7f3ab06d8bf3e331066078fa6409de6f258773ca6a
+  data.tar.gz: c6345de354bf6e928e91cfad8b76a1a5ac51a3b1a4a0359af370c49182b13a167fb8f6ee5cea9ce7fae09ca5bf9fcfa635605aa5d4e0032705ad2c7601c71f15

data/.gitignore

@@ -0,0 +1,2 @@
+/byteboozer2.log
+/pkg/

data/.rubocop.yml

@@ -0,0 +1,16 @@
+Metrics/AbcSize:
+  Max: 174.1
+Metrics/BlockNesting:
+  Max: 8
+Metrics/ClassLength:
+  Max: 472
+Metrics/CyclomaticComplexity:
+  Max: 46
+Metrics/LineLength:
+  Max: 120
+Metrics/MethodLength:
+  Max: 116
+Metrics/PerceivedComplexity:
+  Max: 48
+Style/ZeroLengthPredicate:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    byteboozer2 (0.0.1)
+      activemodel (~> 4.2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ast (2.2.0)
+    awesome_print (1.6.1)
+    builder (3.2.2)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.8.4)
+    parser (2.3.0.7)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rainbow (2.1.0)
+    rake (11.1.1)
+    rubocop (0.38.0)
+      parser (>= 2.3.0.6, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.7.5)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print (~> 1.6.1)
+  bundler (~> 1.11.2)
+  byteboozer2!
+  json (~> 1.8.3)
+  minitest (~> 5.8.4)
+  rake (~> 11.1.1)
+  rubocop (~> 0.38.0)
+
+BUNDLED WITH
+   1.11.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2016 Pawel Krol
+
+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.

data/README.md

@@ -0,0 +1,57 @@
+# ByteBoozer2
+
+`ByteBoozer2` package provides a native Ruby port of David Malmborg's [ByteBoozer 2.0](http://csdb.dk/release/?id=145031), a data cruncher for Commodore files written in C.
+
+## Version
+
+Version 0.01 (2016-03-28)
+
+## Description
+
+`ByteBoozer 2.0` is very much the same as `ByteBoozer 1.0`, but it generates smaller files and decrunches at about 2x the speed. An additional effort was put into keeping the encoder at about the same speed as before. Obviously it is incompatible with the version 1.0.
+
+Compressed data is by default written into a file named with `.b2` suffix. Target file must not exist. If you want an executable, use `ecrunch`. If you want to decrunch yourself, use `crunch` or `rcrunch`. The decruncher should be called with `X` and `Y` registers loaded with a hi- and lo-byte address of the crunched file in a memory.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'byteboozer2', '~> 0.0.1'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install byteboozer2
+
+## Usage
+
+The following operations are supported: crunching files, crunching files and making an executable with start address `$xxxx`, crunching files and relocating data to hex address `$xxxx`.
+
+    require 'byteboozer2'
+    include ByteBoozer2
+
+    # Crunch file:
+    crunch(file_name)
+
+    # Crunch file and make executable with start address $xxxx:
+    ecrunch(file_name, address)
+
+    # Crunch file and relocate data to hex address $xxxx:
+    rcrunch(file_name, address)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `rake install`. To release a new version, update the version number in `version.rb`, and then run `rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/pawelkrol/) at [https://github.com/pawelkrol/byteboozer2_ruby](https://github.com/pawelkrol/byteboozer2_ruby).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require 'rubygems/package_task'
+spec = Gem::Specification.load(File.expand_path('../byteboozer2.gemspec', __FILE__))
+Gem::PackageTask.new(spec).define
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :test]

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'byteboozer2'
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/byteboozer2.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'byteboozer2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'byteboozer2'
+  spec.version       = ByteBoozer2::VERSION
+  spec.authors       = ['Pawel Krol']
+  spec.email         = ['djgruby@gmail.com']
+
+  spec.summary       = 'A data cruncher for Commodore files written in pure Ruby'
+  spec.description   = 'This is a native Ruby port of David Malmborg\'s ByteBoozer 2.0.'
+  spec.homepage      = 'https://github.com/pawelkrol/byteboozer2_ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'awesome_print', '~> 1.6.1'
+  spec.add_development_dependency 'bundler',       '~> 1.11.2'
+  spec.add_development_dependency 'json',          '~> 1.8.3'
+  spec.add_development_dependency 'minitest',      '~> 5.8.4'
+  spec.add_development_dependency 'rake',          '~> 11.1.1'
+  spec.add_development_dependency 'rubocop',       '~> 0.38.0'
+
+  spec.add_runtime_dependency 'activemodel', '~> 4.2.6'
+end

data/lib/byteboozer2/cruncher.rb

@@ -0,0 +1,650 @@
+require 'active_model'
+require 'ostruct'
+
+module ByteBoozer2
+  # This class implements ByteBoozer's 2.0 crunching algorithm.
+  class Cruncher
+    include ActiveModel::Validations
+
+    attr_reader :address, :result
+
+    validates_numericality_of :address, only_integer: true,
+                                        allow_nil: true,
+                                        greater_than_or_equal_to: 0x0000,
+                                        less_than_or_equal_to: 0xffff
+
+    def self.crunch(*args)
+      new(*args).crunch
+    end
+
+    def initialize(data, options = {})
+      @data       = data
+      @executable = options[:executable] || false
+      @relocated  = options[:relocated]  || false
+      @address    = options[:address]    || 0x0000
+
+      raise ArgumentError unless valid?
+    end
+
+    def crunch!
+      @ibuf_size = @data.length - 2
+
+      # Load ibuf and clear context
+      @ibuf     = @data[2..-1]
+      @context  = Array.new(@ibuf_size) { new_node }
+      @link     = Array.new(@ibuf_size) { 0 }
+      @rle_info = Array.new(@ibuf_size) { OpenStruct.new(value: 0, value_after: 0, length: 0) }
+
+      setup_help_structures
+      find_matches
+      @obuf = Array.new(MEM_SIZE) { 0 }
+      margin = write_output
+
+      pack_len = @put
+      file_len = @put
+      decr_len = 0
+      if @executable
+        decr_len = DECRUNCHER_LENGTH
+        file_len += decr_len + 2
+      else
+        file_len += 4
+      end
+
+      @result = Array.new(file_len) { 0 }
+
+      if @executable
+        start_address  = 0x10000 - pack_len
+        transf_address = file_len + 0x6ff
+
+        decr_code[0x1f] = transf_address & 0xff # Transfer from...
+        decr_code[0x20] = transf_address >> 8
+        decr_code[0xbc] = start_address & 0xff # Depack from...
+        decr_code[0xbd] = start_address >> 8
+        decr_code[0x85] = @data[0] # Depack to...
+        decr_code[0x86] = @data[1]
+        decr_code[0xca] = @address & 0xff # Jump to...
+        decr_code[0xcb] = @address >> 8
+
+        @result[0] = 0x01
+        @result[1] = 0x08
+
+        @result[2, decr_len] = decr_code
+
+        @result[2 + decr_len, @put] = @obuf[0, @put]
+      else # Not executable...
+        # Experimantal decision of start address
+        # start_address = 0xfffa - pack_len - 2
+        start_address = (@data[1] << 8) | @data[0]
+        start_address += (@ibuf_size - pack_len - 2 + margin)
+
+        start_address = @address - pack_len - 2 if @relocated
+
+        @result[0] = start_address & 0xff # Load address
+        @result[1] = start_address >> 8
+        @result[2] = @data[0] # Depack to address
+        @result[3] = @data[1]
+
+        @result[4, @put] = @obuf[0, @put]
+      end
+
+      true
+    end
+
+    def crunch
+      @result if crunch!
+    end
+
+    private
+
+    DECRUNCHER = [
+      0x0b, 0x08, 0x00, 0x00, 0x9e, 0x32, 0x30, 0x36, 0x31, 0x00, 0x00, 0x00, 0x78, 0xa9, 0x34, 0x85,
+      0x01, 0xa2, 0xb7, 0xbd, 0x1e, 0x08, 0x95, 0x0f, 0xca, 0xd0, 0xf8, 0x4c, 0x10, 0x00, 0xbd, 0xd6,
+      0x07, 0x9d, 0x00, 0xff, 0xe8, 0xd0, 0xf7, 0xc6, 0x12, 0xc6, 0x15, 0xa5, 0x12, 0xc9, 0x07, 0xb0,
+      0xed, 0x20, 0xa0, 0x00, 0xb0, 0x17, 0x20, 0x8e, 0x00, 0x85, 0x36, 0xa0, 0x00, 0x20, 0xad, 0x00,
+      0x91, 0x77, 0xc8, 0xc0, 0x00, 0xd0, 0xf6, 0x20, 0x83, 0x00, 0xc8, 0xf0, 0xe4, 0x20, 0x8e, 0x00,
+      0xaa, 0xe8, 0xf0, 0x71, 0x86, 0x7b, 0xa9, 0x00, 0xe0, 0x03, 0x2a, 0x20, 0x9b, 0x00, 0x20, 0x9b,
+      0x00, 0xaa, 0xb5, 0xbf, 0xf0, 0x07, 0x20, 0x9b, 0x00, 0xb0, 0xfb, 0x30, 0x07, 0x49, 0xff, 0xa8,
+      0x20, 0xad, 0x00, 0xae, 0xa0, 0xff, 0x65, 0x77, 0x85, 0x74, 0x98, 0x65, 0x78, 0x85, 0x75, 0xa0,
+      0x00, 0xb9, 0xad, 0xde, 0x99, 0x00, 0x00, 0xc8, 0xc0, 0x00, 0xd0, 0xf5, 0x20, 0x83, 0x00, 0xd0,
+      0xa0, 0x18, 0x98, 0x65, 0x77, 0x85, 0x77, 0x90, 0x02, 0xe6, 0x78, 0x60, 0xa9, 0x01, 0x20, 0xa0,
+      0x00, 0x90, 0x05, 0x20, 0x9b, 0x00, 0x10, 0xf6, 0x60, 0x20, 0xa0, 0x00, 0x2a, 0x60, 0x06, 0xbe,
+      0xd0, 0x08, 0x48, 0x20, 0xad, 0x00, 0x2a, 0x85, 0xbe, 0x68, 0x60, 0xad, 0xed, 0xfe, 0xe6, 0xae,
+      0xd0, 0x02, 0xe6, 0xaf, 0x60, 0xa9, 0x37, 0x85, 0x01, 0x4c, 0x00, 0x00, 0x80, 0xdf, 0xfb, 0x00,
+      0x80, 0xef, 0xfd, 0x80, 0xf0
+    ].freeze
+
+    DECRUNCHER_LENGTH = DECRUNCHER.length
+    MEM_SIZE = 0x10000
+
+    NUM_BITS_SHORT_0 = 3
+    NUM_BITS_SHORT_1 = 6
+    NUM_BITS_SHORT_2 = 8
+    NUM_BITS_SHORT_3 = 10
+    NUM_BITS_LONG_0 = 4
+    NUM_BITS_LONG_1 = 7
+    NUM_BITS_LONG_2 = 10
+    NUM_BITS_LONG_3 = 13
+
+    LEN_SHORT_0 = 1 << NUM_BITS_SHORT_0
+    LEN_SHORT_1 = 1 << NUM_BITS_SHORT_1
+    LEN_SHORT_2 = 1 << NUM_BITS_SHORT_2
+    LEN_SHORT_3 = 1 << NUM_BITS_SHORT_3
+    LEN_LONG_0 = 1 << NUM_BITS_LONG_0
+    LEN_LONG_1 = 1 << NUM_BITS_LONG_1
+    LEN_LONG_2 = 1 << NUM_BITS_LONG_2
+    LEN_LONG_3 = 1 << NUM_BITS_LONG_3
+
+    MAX_OFFSET = LEN_LONG_3
+    MAX_OFFSET_SHORT = LEN_SHORT_3
+
+    def cost_of_length(len)
+      if len == 1
+        1
+      elsif len >= 2 && len <= 3
+        3
+      elsif len >= 4 && len <= 7
+        5
+      elsif len >= 8 && len <= 15
+        7
+      elsif len >= 16 && len <= 31
+        9
+      elsif len >= 32 && len <= 63
+        11
+      elsif len >= 64 && len <= 127
+        13
+      elsif len >= 128 && len <= 255
+        14
+      else
+        ByteBoozer2.logger.warn 'cost_of_length got wrong value: #{len}'
+        10_000
+      end
+    end
+
+    def calculate_cost_of_literal(old_cost, lit_len)
+      new_cost = old_cost + 8
+
+      # FIXME, what if lit_len > 255?
+      #
+      # FIXME, cost model for literals does not work
+      # Quick wins on short matches are prioritized before a longer
+      # literal run, which in the end results in a worse result
+      # Most obvious on files hard to crunch
+      case lit_len
+      when 1 then new_cost += 1
+      when 128 then new_cost += 1
+      when 2 then new_cost += 2
+      when 4 then new_cost += 2
+      when 8 then new_cost += 2
+      when 16 then new_cost += 2
+      when 32 then new_cost += 2
+      when 64 then new_cost += 2
+      end
+
+      new_cost
+    end
+
+    def calculate_cost_of_match(len, offset)
+      cost = 1 # Copy-bit
+      cost += cost_of_length(len - 1)
+      cost += 2 # num offset bits
+      cost += cost_of_offset(offset - 1, len - 1)
+      cost
+    end
+
+    def cost_of_offset(offset, len)
+      if len == 1
+        return NUM_BITS_SHORT_0 if cond_short_0(offset)
+        return NUM_BITS_SHORT_1 if cond_short_1(offset)
+        return NUM_BITS_SHORT_2 if cond_short_2(offset)
+        return NUM_BITS_SHORT_3 if cond_short_3(offset)
+      else
+        return NUM_BITS_LONG_0 if cond_long_0(offset)
+        return NUM_BITS_LONG_1 if cond_long_1(offset)
+        return NUM_BITS_LONG_2 if cond_long_2(offset)
+        return NUM_BITS_LONG_3 if cond_long_3(offset)
+      end
+
+      ByteBoozer2.logger.warn 'cost_of_offset got wrong offset: #{offset}'
+      10_000
+    end
+
+    def cond_short_0(o)
+      o >= 0 && o < LEN_SHORT_0
+    end
+
+    def cond_short_1(o)
+      o >= LEN_SHORT_0 && o < LEN_SHORT_1
+    end
+
+    def cond_short_2(o)
+      o >= LEN_SHORT_1 && o < LEN_SHORT_2
+    end
+
+    def cond_short_3(o)
+      o >= LEN_SHORT_2 && o < LEN_SHORT_3
+    end
+
+    def cond_long_0(o)
+      o >= 0 && o < LEN_LONG_0
+    end
+
+    def cond_long_1(o)
+      o >= LEN_LONG_0 && o < LEN_LONG_1
+    end
+
+    def cond_long_2(o)
+      o >= LEN_LONG_1 && o < LEN_LONG_2
+    end
+
+    def cond_long_3(o)
+      o >= LEN_LONG_2 && o < LEN_LONG_3
+    end
+
+    def decr_code
+      @decr_code ||= DECRUNCHER.dup
+    end
+
+    def find_matches
+      matches = Array.new(256) { OpenStruct.new(length: 0, offset: 0) }
+
+      last_node = new_node
+
+      get = @ibuf_size - 1
+      cur = @ibuf[get]
+
+      while get >= 0
+        # Clear matches for current position
+        matches.each do |match|
+          match.length = 0
+          match.offset = 0
+        end
+
+        cur = (cur << 8) & 0xffff # Table 65536 lookup
+        cur |= @ibuf[get - 1] if get > 0
+        scn = @first[cur]
+        scn = @link[scn]
+
+        longest_match = 0
+
+        if @rle_info[get].length == 0 # No RLE-match here...
+          # Scan until start of file, or max offset
+          while get - scn <= MAX_OFFSET && scn > 0 && longest_match < 255
+            # OK, we have a match of length 2 or longer, but max 255 or file start
+            len = 2
+            while len < 255 && scn >= len && @ibuf[scn - len] == @ibuf[get - len]
+              len += 1
+            end
+
+            # Calc offset
+            offset = get - scn
+
+            # Store match only if it's the longest so far
+            if len > longest_match
+              longest_match = len
+
+              # Store the match only if first (= best) of this length
+              while len >= 2 && matches[len].length == 0
+                # If len == 2, check against short offset!
+                if len > 2 || (len == 2 && offset <= MAX_OFFSET_SHORT)
+                  matches[len].length = len
+                  matches[len].offset = get - scn
+                end
+
+                len -= 1
+              end
+            end
+
+            scn = @link[scn] # Table 65535 lookup
+          end
+
+          @first[cur] = @link[@first[cur]] # Waste first entry
+        else # if RLE-match...
+          rle_len = @rle_info[get].length
+          rle_val_after = @rle_info[get].value_after
+
+          # First match with self-RLE, which is always one byte shorter than the RLE itself
+          len = rle_len - 1
+          if len > 1
+            len = 255 if len > 255
+            longest_match = len
+
+            # Store the match
+            while len >= 2
+              matches[len].length = len
+              matches[len].offset = 1
+
+              len -= 1
+            end
+          end
+
+          # Search for more RLE-matches, scan until start of file, or max offset...
+          while get - scn <= MAX_OFFSET && scn > 0 && longest_match < 255
+
+            # Check for longer matches with same value and after...
+            # FIXME: That is not what it does, is it?!
+            if @rle_info[scn].length > longest_match && rle_len > longest_match
+              offset = get - scn
+              len = @rle_info[scn].length
+
+              len = rle_len if len > rle_len
+
+              if len > 2 || (len == 2 && offset <= MAX_OFFSET_SHORT)
+                matches[len].length = len
+                matches[len].offset = offset
+
+                longest_match = len
+              end
+            end
+
+            # Check for matches beyond the RLE...
+            if @rle_info[scn].length >= rle_len && @rle_info[scn].value_after == rle_val_after
+
+              # Here is a match that goes beyond the RLE...
+              # Find out correct offset to use value_after, then search further to see if more bytes equal
+              len = rle_len
+              offset = get - scn + @rle_info[scn].length - rle_len
+
+              if offset <= MAX_OFFSET
+                while len < 255 && get >= offset + len && @ibuf[get - offset - len] == @ibuf[get - len]
+                  len += 1
+                end
+
+                if len > longest_match
+                  longest_match = len
+
+                  # Store the match only if first (= best) of this length
+                  while len >= 2 && matches[len].length == 0
+                    # If len == 2, check against short offset!
+                    if len > 2 || (len == 2 && offset <= MAX_OFFSET_SHORT)
+                      matches[len].length = len
+                      matches[len].offset = offset
+                    end
+
+                    len -= 1
+                  end
+                end
+              end
+            end
+
+            scn = @link[scn] # Table 65535 lookup
+          end
+
+          if @rle_info[get].length > 2
+            # Expand RLE to next position
+            @rle_info[get - 1].length = @rle_info[get].length - 1
+            @rle_info[get - 1].value = @rle_info[get].value
+            @rle_info[get - 1].value_after = @rle_info[get].value_after
+          else
+            # End of RLE, advance link
+            @first[cur] = @link[@first[cur]] # Waste first entry
+          end
+        end
+
+        # Now that we have all matches from this position, visit all nodes reached by the matches
+        255.downto(1).to_a.each do |i|
+          # Find all matches we stored
+          len = matches[i].length
+          offset = matches[i].offset
+
+          next if len == 0
+          target_i = get - len + 1
+          target = @context[target_i]
+
+          # Calculate cost for this jump
+          current_cost = last_node.cost
+          current_cost += calculate_cost_of_match(len, offset)
+
+          # If this match is first or cheapest way to get here, then update node
+          next if target.cost != 0 && target.cost <= current_cost
+          target.cost = current_cost
+          target.next = get + 1
+          target.lit_len = 0
+          target.offset = offset
+        end
+
+        # Calc the cost for this node if using one more literal
+        lit_len = last_node.lit_len + 1
+        lit_cost = calculate_cost_of_literal(last_node.cost, lit_len)
+
+        # If literal run is first or cheapest way to get here, then update node
+        this = @context[get]
+        if this.cost == 0 || this.cost >= lit_cost
+          this.cost = lit_cost
+          this.next = get + 1
+          this.lit_len = lit_len
+        end
+
+        last_node.cost = this.cost
+        last_node.next = this.next
+        last_node.lit_len = this.lit_len
+
+        # Loop to the next position
+        get -= 1
+      end
+    end
+
+    def new_node
+      OpenStruct.new(cost: 0, next: 0, lit_len: 0, offset: 0)
+    end
+
+    def setup_help_structures
+      # Setup RLE-info
+      get = @ibuf_size - 1
+      while get > 0
+
+        cur = @ibuf[get]
+        if cur == @ibuf[get - 1]
+
+          len = 2
+          len += 1 while get >= len && cur == @ibuf[get - len]
+
+          @rle_info[get].length = len
+          @rle_info[get].value_after = get >= len ? @ibuf[get - len] : cur # Avoid accessing @ibuf[-1]
+
+          get -= len
+        else
+          get -= 1
+        end
+      end
+
+      # Setup linked list
+      @first = Array.new(MEM_SIZE) { 0 }
+      @last = Array.new(MEM_SIZE) { 0 }
+
+      get = @ibuf_size - 1
+      cur = @ibuf[get]
+
+      while get > 0
+        cur = ((cur << 8) | @ibuf[get - 1]) & 0xffff
+
+        if @first[cur] == 0
+          @first[cur] = @last[cur] = get
+        else
+          @link[@last[cur]] = get
+          @last[cur] = get
+        end
+
+        get -= @rle_info[get].length == 0 ? 1 : @rle_info[get].length - 1 # if RLE-match...
+      end
+    end
+
+    def wbit(bit)
+      if @cur_cnt == 0
+        @obuf[@cur_index] = @cur_byte
+        @cur_index = @put
+        @cur_cnt = 8
+        @cur_byte = 0
+        @put += 1
+      end
+
+      @cur_byte <<= 1
+      @cur_byte |= bit & 1
+      @cur_cnt -= 1
+    end
+
+    def wbyte(b)
+      @obuf[@put] = b
+      @put += 1
+    end
+
+    def wbytes(get, len)
+      (0..len - 1).each do
+        wbyte(@ibuf[get])
+        get += 1
+      end
+    end
+
+    def wflush
+      while @cur_cnt != 0
+        @cur_byte <<= 1
+        @cur_cnt -= 1
+      end
+      @obuf[@cur_index] = @cur_byte
+    end
+
+    def wlength(len)
+      # return if len == 0 # Should never happen
+
+      bit = 0x80
+      bit >>= 1 while len & bit == 0
+
+      while bit > 1
+        wbit(1)
+        bit >>= 1
+        wbit(len & bit == 0 ? 0 : 1)
+      end
+
+      wbit(0) if len < 0x80
+    end
+
+    def woffset(offset, len)
+      i = 0
+      n = 0
+
+      if len == 1
+        if cond_short_0(offset)
+          i = 0
+          n = NUM_BITS_SHORT_0
+        end
+        if cond_short_1(offset)
+          i = 1
+          n = NUM_BITS_SHORT_1
+        end
+        if cond_short_2(offset)
+          i = 2
+          n = NUM_BITS_SHORT_2
+        end
+        if cond_short_3(offset)
+          i = 3
+          n = NUM_BITS_SHORT_3
+        end
+      else
+        if cond_long_0(offset)
+          i = 0
+          n = NUM_BITS_LONG_0
+        end
+        if cond_long_1(offset)
+          i = 1
+          n = NUM_BITS_LONG_1
+        end
+        if cond_long_2(offset)
+          i = 2
+          n = NUM_BITS_LONG_2
+        end
+        if cond_long_3(offset)
+          i = 3
+          n = NUM_BITS_LONG_3
+        end
+      end
+
+      # First write number of bits
+      wbit(i & 2 == 0 ? 0 : 1)
+      wbit(i & 1 == 0 ? 0 : 1)
+
+      if n >= 8 # Offset is 2 bytes
+
+        # Then write the bits less than 8
+        b = 1 << n
+        while b > 0x100
+          b >>= 1
+          wbit(b & offset == 0 ? 0 : 1)
+        end
+
+        # Finally write a whole byte, if necessary
+        wbyte(offset & 255 ^ 255) # Inverted (!)
+        offset >>= 8
+
+      else # Offset is 1 byte
+
+        # Then write the bits less than 8
+        b = 1 << n
+        while b > 1
+          b >>= 1
+          wbit(b & offset == 0 ? 1 : 0) # Inverted (!)
+        end
+      end
+    end
+
+    def write_output
+      @put = 0
+
+      @cur_byte = 0
+      @cur_cnt = 8
+      @cur_index = @put
+      @put += 1
+
+      max_diff = 0
+
+      need_copy_bit = true
+
+      i = 0
+      while i < @ibuf_size
+        link = @context[i].next
+        # cost = @context[i].cost
+        lit_len = @context[i].lit_len
+        offset = @context[i].offset
+
+        if lit_len == 0
+          # Put match
+          len = link - i
+
+          ByteBoozer2.logger.debug format('$%04x: Mat(%i, %i)', i, len, offset)
+
+          wbit(1) if need_copy_bit
+          wlength(len - 1)
+          woffset(offset - 1, len - 1)
+
+          i = link
+
+          need_copy_bit = true
+        else
+          # Put literal
+          need_copy_bit = false
+
+          while lit_len > 0
+            len = lit_len < 255 ? lit_len : 255
+
+            ByteBoozer2.logger.debug format('$%04x: Lit(%i)', i, len)
+
+            wbit(0)
+            wlength(len)
+            wbytes(i, len)
+
+            need_copy_bit = true if lit_len == 255
+
+            lit_len -= len
+            i += len
+          end
+        end
+
+        max_diff = i - @put if i - @put > max_diff
+      end
+
+      wbit(1)
+      wlength(0xff)
+      wflush
+
+      max_diff - i + @put
+    end
+  end
+end

data/lib/byteboozer2/file.rb

@@ -0,0 +1,29 @@
+module ByteBoozer2
+  # This class implements file handling related helper methods.
+  class File
+    attr_accessor :data, :name
+
+    def self.load(*args)
+      new(*args).tap(&:read)
+    end
+
+    def self.save(*args)
+      new(*args).tap(&:write)
+    end
+
+    def initialize(name, data = nil)
+      @name = name
+      @data = data
+    end
+
+    def read
+      @data = IO.binread(@name).unpack('C*')
+    end
+
+    def write
+      ::File.open(@name, ::File::WRONLY | ::File::CREAT | ::File::EXCL, binmode: true, encoding: 'ASCII-8BIT') do |file|
+        file.write @data.pack('C*')
+      end
+    end
+  end
+end

data/lib/byteboozer2/version.rb

@@ -0,0 +1,3 @@
+module ByteBoozer2
+  VERSION = '0.0.1'.freeze
+end

data/lib/byteboozer2.rb

@@ -0,0 +1,38 @@
+require 'byteboozer2/cruncher'
+require 'byteboozer2/file'
+require 'byteboozer2/version'
+require 'logger'
+
+# This module provides compression methods available in ByteBoozer 2.0.
+module ByteBoozer2
+  def crunch(file_name)
+    compress(file_name)
+  end
+
+  def ecrunch(file_name, address)
+    compress(file_name, address: address, executable: true)
+  end
+
+  def self.logger
+    @logger ||= Logger.new('byteboozer2.log').tap do |log|
+      log.level = Logger::DEBUG
+      log.progname = 'ByteBoozer2'
+    end
+  end
+
+  def self.log_level=(level)
+    logger.level = level
+  end
+
+  def rcrunch(file_name, address)
+    compress(file_name, address: address, relocated: true)
+  end
+
+  private
+
+  def compress(file_name, *options)
+    file = ByteBoozer2::File.load(file_name)
+    result = ByteBoozer2::Cruncher.crunch(file.data, *options)
+    ByteBoozer2::File.save(file_name + '.b2', result)
+  end
+end

data/src/decruncher.inc

@@ -0,0 +1,160 @@
+; ByteBoozer 2.0 Decruncher (C) 2014 David Malmborg
+
+; call: Y = AddrLo
+;       X = AddrHi
+
+;Variables..        #Bytes
+zp_base	= $02       ; -
+bits	= zp_base   ;1
+put	= zp_base+2 ;2
+
+#macro	GetNextBit() {.(
+	asl bits
+	bne DgEnd
+	jsr GetNewBits
+DgEnd
+.)}
+
+#macro	GetLen() {.(
+	lda #1
+GlLoop
+	.GetNextBit()
+	bcc GlEnd
+	.GetNextBit()
+	rol
+	bpl GlLoop
+GlEnd
+.)}
+
+Decrunch
+	sty Get1+1
+	sty Get2+1
+	sty Get3+1
+	stx Get1+2
+	stx Get2+2
+	stx Get3+2
+
+	ldx #0
+	jsr GetNewBits
+	sty put-1,x
+	cpx #2
+	bcc *-7
+	lda #$80
+	sta bits
+DLoop
+	.GetNextBit()
+	bcs Match
+Literal
+	; Literal run.. get length.
+	.GetLen()
+	sta LLen+1
+
+	ldy #0
+LLoop
+Get3	lda $feed,x
+	inx
+	bne *+5
+	jsr GnbInc
+L1	sta (put),y
+	iny
+LLen	cpy #0
+	bne LLoop
+
+	clc
+	tya
+	adc put
+	sta put
+	bcc *+4
+	inc put+1
+
+	iny
+	beq DLoop
+
+	; Has to continue with a match..
+
+Match
+	; Match.. get length.
+	.GetLen()
+	sta MLen+1
+
+	; Length 255 -> EOF
+	cmp #$ff
+	beq End
+
+	; Get num bits
+	cmp #2
+	lda #0
+	rol
+	.GetNextBit()
+	rol
+	.GetNextBit()
+	rol
+	tay
+	lda Tab,y
+	beq M8
+
+	; Get bits < 8
+M_1	.GetNextBit()
+	rol
+	bcs M_1
+	bmi MShort
+M8
+	; Get byte
+	eor #$ff
+	tay
+Get2	lda $feed,x
+	inx
+	bne *+5
+	jsr GnbInc
+	jmp Mdone
+MShort
+	ldy #$ff
+Mdone
+	;clc
+	adc put
+	sta MLda+1
+	tya
+	adc put+1
+	sta MLda+2
+
+	ldy #$ff
+MLoop	iny
+MLda	lda $beef,y
+	sta (put),y
+MLen	cpy #0
+	bne MLoop
+
+	;sec
+	tya
+	adc put
+	sta put
+	bcc *+4
+	inc put+1
+
+	jmp DLoop
+
+End	rts
+
+GetNewBits
+Get1	ldy $feed,x
+	sty bits
+	rol bits
+	inx
+	bne GnbEnd
+GnbInc	inc Get1+2
+	inc Get2+2
+	inc Get3+2
+GnbEnd
+	rts
+
+Tab
+	; Short offsets
+	.byte %11011111 ; 3
+	.byte %11111011 ; 6
+	.byte %00000000 ; 8
+	.byte %10000000 ; 10
+	; Long offsets
+	.byte %11101111 ; 4
+	.byte %11111101 ; 7
+	.byte %10000000 ; 10
+	.byte %11110000 ; 13

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: byteboozer2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Pawel Krol
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 11.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 11.1.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.38.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.38.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+description: This is a native Ruby port of David Malmborg's ByteBoozer 2.0.
+email:
+- djgruby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- byteboozer2.gemspec
+- lib/byteboozer2.rb
+- lib/byteboozer2/cruncher.rb
+- lib/byteboozer2/file.rb
+- lib/byteboozer2/version.rb
+- src/decruncher.inc
+homepage: https://github.com/pawelkrol/byteboozer2_ruby
+licenses:
+- MIT
+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.8
+signing_key: 
+specification_version: 4
+summary: A data cruncher for Commodore files written in pure Ruby
+test_files: []