d64tools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0124058c11111a068dd31c4535edc1b6f4f168a9
+  data.tar.gz: fa1a24b4e2aad4cd2dea0b7cd683dce907fa2064
+SHA512:
+  metadata.gz: 711722c77f90011c4ba737a9764b816c83f4c2665d9bb5a99415633bdc0769baf9408b1678e47713151f331bfa07419f2f29c2f346be614d80a1ad6b401230c1
+  data.tar.gz: 8fb079f24abff8ce7b268ecfd351614bef9eabf662acdde60b7498fadc5fd949922b61eb66b77c365f59a50b1fc5d3b03b188a64b31fb7347b8d60beff35927e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in d64tools.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Lars Haugseth
+
+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,54 @@
+# D64tools
+
+A Ruby gem with tools for working with D64 images (dumps of Commodore 1541 floppy disks.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'd64tools', github: 'lhz/d64tools'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install d64tools
+
+## Usage
+
+There are several tools installed with this gem:
+
+```
+d64reserve <d64-image>
+```
+This tool will reserve track 35 in the BAM of the given d64 image, to avoid other tools adding files to the image using that track.
+
+```
+d64unreserve <d64-image>
+```
+This tool will free up track 35 in the BAM of the given d64 image, so that other tools may utilize that track again.
+
+```
+d64hide <d64-source-image> <d64-dirart-image> <d64-target-image>
+```
+This tool will move the directory from track 18 on the source image over to track 35, copy the directory from track 18 on the dirart image on to track 18 and store the result in the target image.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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 `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec 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 at https://github.com/[USERNAME]/d64tools.
+
+
+## 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 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "d64tools"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/d64tools.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'd64/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "d64tools"
+  spec.version       = D64::VERSION
+  spec.authors       = ["Lars Haugseth"]
+  spec.email         = ["github@larshaugseth.com"]
+
+  spec.summary       = %q{D64 floppy image tools}
+  spec.description   = %q{Tools to perform various operations on D64 floppy images.}
+  spec.homepage      = "http://github.com/lhz/d64tools"
+  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 "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/exe/d64hide

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'd64tools'
+
+source_file = ARGV[0]
+dirart_file = ARGV[1]
+target_file = ARGV[2]
+
+source_file && dirart_file && target_file or
+  fail "Usage: #{$0} <d64-source> <d64-dirart> <d64-target>"
+
+source_image = D64::Image.read(source_file)
+source_image.name = 'source'
+
+dirart_image = D64::Image.read(dirart_file)
+dirart_image.name = 'dirart'
+
+source_dir = source_image.directory_chain
+dirart_dir = dirart_image.directory_chain
+
+art_size = dirart_dir.size
+src_free = source_image.bam.free_blocks
+
+src_free >= art_size or
+  fail "Only #{src_free} of #{art_size} blocks free for dirart!"
+
+puts "Dir art needs #{art_size} out of #{src_free} free blocks."  if ENV['DEBUG']
+
+prv_sector = nil
+dir_sector = nil
+
+boot_ptr = source_image.sector([18, 1]).bytes[3, 2]
+puts "Boot file at [%02d:%02d]" % boot_ptr if ENV['DEBUG']
+
+target_sectors = [
+  [35,  0], [35,  1], [35,  4], [35,  7], [35, 10],
+  [35, 13], [35, 16], [35,  2], [35,  5], [35,  8],
+  [35, 11], [35, 14], [35,  3], [35,  6], [35,  9],
+  [35, 12], [35, 15]
+]
+
+[dirart_dir.size, source_dir.size].max.times do |i|
+  src_sector = source_dir[i]
+  art_sector = dirart_dir[i]
+
+  if src_sector
+    # Move source sector to track 35 and replace with dirart sector
+    wanted = target_sectors[i]
+    new_sector = source_image.allocate_sector(block: D64::Block.new(*wanted))
+    new_sector.copy_content_from(src_sector)
+
+    if art_sector
+      src_sector.copy_content_from(art_sector, include_link: i == art_size - 1)
+    end
+  else
+    # Just copy the dirart sector since we ran out of files on source
+    new_sector = source_image.allocate_sector(block: art_sector.block)
+    new_sector.copy_content_from(art_sector)
+  end
+
+  if prv_sector
+    prv_sector.link_to new_sector
+  else
+    dir_sector = new_sector
+  end
+  prv_sector = new_sector
+
+  source_image.commit_bam
+end
+
+# if source_dir.size > art_size
+#   prv_sector.link_to(source_dir[art_size])
+# end
+
+# Make first dirart file point to first real file
+sector = source_image.sector([18, 1])
+fnum = (0..7).find { |i| sector.bytes[32 * i + 2] == 0x82 }
+sector.bytes[32 * fnum + 3, 2] = boot_ptr
+sector.commit
+
+source_image.write(target_file)
+
+puts "Finished, hidden directory now at #{dir_sector.pos}." if ENV['DEBUG']

data/exe/d64reserve

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+# Reserve all sectors on track 35 for hidden directory
+
+require 'd64tools'
+
+file = ARGV[0]
+
+file or
+  fail "Usage: #{$0} <d64-file>"
+
+image = D64::Image.read(file)
+
+17.times do |sn|
+  image.bam.mark_as_used 35, sn
+end
+image.bam.commit
+
+image.write file

data/exe/d64unreserve

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+# Unreserve all sectors on track 35 to make room for hidden directory
+
+require 'd64tools'
+
+file = ARGV[0]
+
+file or
+  fail "Usage: #{$0} <d64-file>"
+
+image = D64::Image.read(file)
+
+17.times do |sn|
+  image.bam.mark_as_unused 35, sn
+end
+image.bam.commit
+
+image.write file

data/lib/d64.rb

@@ -0,0 +1,2 @@
+module D64
+end

data/lib/d64/block.rb

@@ -0,0 +1,3 @@
+module D64
+  Block = Struct.new(:track, :sector)
+end

data/lib/d64/block_map.rb

@@ -0,0 +1,73 @@
+require "d64/block"
+require "d64/sector"
+
+module D64
+  class BlockMap < Sector
+
+    def dump_map
+      puts (1..35).map { |tn|
+        ("%2s " % tn) << free_on_track(tn).map { |v| v ? '[ ]' : '[x]' }.join
+      }.join "\n";
+    end
+    
+    def free_on_track(tn)
+      tv = track_value(tn)
+      Image.sectors_per_track(tn).times.map do |sn|
+        tv & (2 ** sn) != 0
+      end
+    end
+
+    def free_blocks
+      35.times.map { |i| bytes[4 * i + 4] }.reduce :+
+    end
+
+    def allocate(opts = {})
+      if opts[:block]
+        tn = opts[:block].track
+        sn = opts[:block].sector
+        free_on_track(tn)[sn] or
+          fail "Can't allocate used sector [%s %02d:%02d]." % [@image.name, tn, sn]
+      else
+        tracks = (1..35).to_a
+        if tn = opts[:trackpref]
+          tracks.delete  opts[:trackpref]
+          tracks.unshift opts[:trackpref]
+        end
+        sn = nil
+        tracks.each do |tn|
+          sn = free_on_track(tn).index(true)
+          break if sn
+        end
+        return nil unless sn
+      end
+      mark_as_used tn, sn
+      free_on_track(tn)[sn] and
+        fail "Failed to mark as used!"
+      puts 'Allocated sector [%s %02d:%02d]' % [@image.name, tn, sn] if ENV['DEBUG']
+      Block.new(tn, sn)
+    end
+
+    def mark_as_used(tn, sn)
+      byte, bit = sn.divmod(8)
+      @bytes[4 * tn + 1 + byte] &= (255 - 2 ** bit)
+      @bytes[4 * tn] -= 1
+    end
+
+    def mark_as_unused(tn, sn)
+      byte, bit = sn.divmod(8)
+      @bytes[4 * tn + 1 + byte] |= (2 ** bit)
+      @bytes[4 * tn] += 1
+    end
+
+    def commit
+      image.commit_bam
+    end
+
+    private
+
+    def track_value(tn)
+      a, b, c = bytes[4 * tn + 1, 3]
+      (c << 16) + (b << 8) + a
+    end
+  end
+end

data/lib/d64/image.rb

@@ -0,0 +1,90 @@
+require "d64/block"
+require "d64/sector"
+require "d64/block_map"
+
+module D64
+  # http://vice-emu.sourceforge.net/vice_15.html#SEC278
+
+  class Image
+    attr_reader :num_tracks, :filename
+    attr_accessor :name
+
+    def self.read(filename)
+      di = new
+      di.read(filename)
+      di
+    end
+
+    def self.offset(block)
+      (@offsets ||= build_offset_table)[block.track - 1][block.sector]
+    end
+
+    def self.build_offset_table
+      ss = -1
+      40.times.map do |i|
+        tn = i + 1
+        sectors_per_track(tn).times.map do
+          ss += 1
+          ss * 256
+        end
+      end
+    end
+
+    def self.sectors_per_track(track)
+      @spt ||= [0] + [21] * 17 + [19] * 7 + [18] * 6 + [17] * 10
+      @spt[track]
+    end
+
+    def initialize
+      @num_tracks = 35
+      @name = ''
+    end
+
+    def to_s
+      "<D64::Image:#{object_id.to_s(16)} @filename=#{filename}>"
+    end
+
+    def read(file)
+      @filename = file
+      @image    = File.binread(filename).bytes
+    end
+
+    def write(file = filename)
+      File.open(file, 'wb') { |f| f.write @image.pack('C*') }
+    end
+
+    def sector(block)
+      block = Block.new(block[0], block[1]) if block.is_a?(Array)
+      Sector.new(self, block, sector_data(block))
+    end
+
+    def bam
+      block = Block.new(18, 0)
+      @bam ||= BlockMap.new(self, block, sector_data(block))
+    end
+
+    def directory_chain
+      sector([18, 0]).chain
+    end
+    
+    def allocate_sector(opts = {})
+      block = bam.allocate(opts) or
+        fail "Failed to allocate sector!"
+      Sector.new(self, block, [0] * 256)
+    end
+
+    def commit_sector(sector)
+      @image[Image.offset(sector.block), 256] = sector.bytes
+    end
+
+    def commit_bam
+      @image[Image.offset(@bam.block) + 4, 140] = @bam.bytes[4, 140]
+    end
+
+    private
+
+    def sector_data(block)
+      @image[Image.offset(block), 256]
+    end
+  end
+end

data/lib/d64/sector.rb

@@ -0,0 +1,78 @@
+module D64
+  class Sector
+    attr_reader :image, :block, :bytes
+
+    def initialize(image, block, bytes)
+      @image = image
+      @block = block
+      @bytes = bytes
+    end
+
+    def to_s
+      "<D64::Sector:#{object_id.to_s(16)} t=#{@block.track} s=#{@block.sector}>"
+    end
+
+    def pos
+      '[%02d:%02d]' % [block.track, block.sector]
+    end
+
+    def name_pos
+      '[%s %02d:%02d]' % [image.name, block.track, block.sector]
+    end
+    
+    def next
+      tn, sn = @bytes[0, 2]
+      image.sector([tn, sn]) if tn > 0
+    end
+
+    def chain
+      list = [self]
+      while list.last.next
+        list << list.last.next
+      end
+      list
+    end
+
+    def copy_content_from(other, opts = {})
+      puts "Copying content from #{other.name_pos} to #{name_pos}." if ENV['DEBUG']
+      first = (opts[:include_link] ? 0 : 2)
+      if block.track == 18 && block.sector == 0 && !opts[:include_bam]
+        @bytes[first..3] = other.bytes[first..3]
+        @bytes[0x90..-1] = other.bytes[0x90..-1]
+      else
+        @bytes[first..-1] = other.bytes[first..-1]
+      end
+      commit
+    end
+
+    def link_to(other, opts = {})
+      puts "Linking #{name_pos} to #{other.name_pos}." if ENV['DEBUG']
+      @bytes[0, 2] = [other.block.track, other.block.sector]
+      commit
+    end
+
+    def commit
+      image.commit_sector(self)
+    end
+
+    def dump
+      puts 8.times.map { |i|
+        ('%05X  %s ' % [Image.offset(block) + 32 * i, pos]) <<
+          (' %02X' * 32 % @bytes[32 * i, 32]) <<
+          (' %32s' % bytes_string(@bytes[32 * i, 32]))
+      }.join("\n")
+    end
+
+    private
+
+    def bytes_string(bytes)
+      bytes.map { |b|
+        case b
+        when 0x20..0x7F then b.chr
+        else
+          '.'
+        end
+      }.join
+    end
+  end
+end

data/lib/d64/version.rb

@@ -0,0 +1,3 @@
+module D64
+  VERSION = "0.1.0"
+end

data/lib/d64tools.rb

@@ -0,0 +1,3 @@
+require "d64"
+require "d64/version"
+require "d64/image"

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: d64tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lars Haugseth
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: Tools to perform various operations on D64 floppy images.
+email:
+- github@larshaugseth.com
+executables:
+- d64hide
+- d64reserve
+- d64unreserve
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- d64tools.gemspec
+- exe/d64hide
+- exe/d64reserve
+- exe/d64unreserve
+- lib/d64.rb
+- lib/d64/block.rb
+- lib/d64/block_map.rb
+- lib/d64/image.rb
+- lib/d64/sector.rb
+- lib/d64/version.rb
+- lib/d64tools.rb
+homepage: http://github.com/lhz/d64tools
+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.5
+signing_key: 
+specification_version: 4
+summary: D64 floppy image tools
+test_files: []
+has_rdoc: