badline 0.6.0 → 0.7.0

data/lib/badline/reu.rb

@@ -106,9 +106,8 @@ module Badline
     # From the moment the REC asks for the bus until it hands it back.
     def dma? = @requested || @running
 
-    # Whether the REC held the bus on the last cycle clocked. The CPU keeps
-    # it while the REC waits to start, and has it back from the cycle the
-    # REC lets go.
+    # Whether the REC ran a transfer on the last cycle clocked, which it
+    # goes on doing until the cycle it lets go of the bus.
     def holds_bus? = @running
 
     def reset!
@@ -120,7 +119,7 @@ module Badline
       @length = @length_start = 0xffff
       @interrupt_mask = 0x1f
       @address_control = 0x3f
-      @armed = @requested = @running = false
+      @armed = @requested = @running = @ba_was_low = false
       interrupt(false)
     end
 
@@ -158,16 +157,20 @@ module Badline
       request_bus
     end
 
-    # Clocks the REC for a cycle, given the VIC's BA line and whether the
-    # CPU writes on it. A requested transfer starts on the first cycle the
-    # CPU reads with BA high.
-    def dma_cycle!(ba_low, cpu_writing)
+    # Clocks the REC for a cycle, given the VIC's BA line. A requested
+    # transfer starts on the first cycle with BA high as the REC sees it,
+    # even one the CPU writes on. Pinned by REU/rmw-trigger. A fetch
+    # requested on the cycle before BA falls writes its first byte on the
+    # first BA-low cycle as well, and again when it starts. Pinned by
+    # REU/badoublewrite.
+    def dma_cycle!(ba_low)
+      late = ba_low && @vic.reu_ba_late?
       if @requested
-        return if cpu_writing || ba_low
+        return hold_off if ba_low && !late
 
         start_transfer
       end
-      @dma.cycle!(ba_low)
+      @dma.cycle!(ba_low, late, ba_low && @vic.reu_ba_handed_on?)
       end_transfer unless @dma.holds_bus?
     end
 
@@ -239,9 +242,15 @@ module Badline
 
     def request_bus
       @requested = true
+      @ba_was_low = @vic.ba_low?
       @on_dma&.call
     end
 
+    def hold_off
+      @dma.write_ahead(@command & TRANSFER_TYPE, @c64, @expansion | (@bank << 16)) unless @ba_was_low
+      @ba_was_low = true
+    end
+
     def start_transfer
       @requested = false
       @running = true

data/lib/badline/sdl.rb

@@ -1,67 +1,149 @@
 # frozen_string_literal: true
 
-require "fiddle"
-
 module Badline
-  # The libSDL2 calls the window, the gamepads and the audio sink make,
-  # bound through Fiddle, so nothing has to compile against SDL at install
-  # time. Only the library itself has to be present.
-  #
-  # Each function is a constant named after its C name without the prefix:
-  # SDL::RenderClear.call(renderer) calls SDL_RenderClear. They're built
-  # with need_gvl, which skips releasing Ruby's lock around the call: none
-  # of these block for long, and releasing it costs more than most of them.
+  # libSDL2 through Spinel's FFI DSL, the one binding both builds use. The
+  # native build compiles the declarations, and finds the library's
+  # directory (see NativeBuild.sdl2_flags). badline-ruby loads badline/ffi
+  # first, which implements them over Fiddle, so only the library itself
+  # has to be present.
   module SDL
-    class Error < StandardError; end
+    ffi_lib "SDL2"
 
-    # Where package managers put the shared library. dlopen searches the
-    # system paths for the bare names, but not Homebrew's.
-    LIBRARIES = %w[
-      libSDL2-2.0.so.0 libSDL2.so
-      libSDL2-2.0.0.dylib /opt/homebrew/lib/libSDL2-2.0.0.dylib /usr/local/lib/libSDL2-2.0.0.dylib
-      SDL2.dll
-    ].freeze
+    ffi_func :SDL_Init, [:uint32], :int
+    ffi_func :SDL_Quit, [], :void
+    ffi_func :SDL_GetError, [], :str
+    ffi_func :SDL_SetHint, %i[str str], :int
+    ffi_func :SDL_CreateWindow, %i[str int int int int uint32], :ptr
+    ffi_func :SDL_SetWindowTitle, %i[ptr str], :void
+    ffi_func :SDL_SetWindowSize, %i[ptr int int], :void
+    ffi_func :SDL_DestroyWindow, [:ptr], :void
+    ffi_func :SDL_CreateRenderer, %i[ptr int uint32], :ptr
+    ffi_func :SDL_GetWindowDisplayMode, %i[ptr ptr], :int
+    ffi_func :SDL_DestroyRenderer, [:ptr], :void
+    ffi_func :SDL_RenderSetLogicalSize, %i[ptr int int], :int
+    ffi_func :SDL_CreateTexture, %i[ptr uint32 int int int], :ptr
+    ffi_func :SDL_DestroyTexture, [:ptr], :void
+    ffi_func :SDL_UpdateTexture, %i[ptr ptr int_array int], :int
+    ffi_func :SDL_RenderClear, [:ptr], :int
+    ffi_func :SDL_SetRenderDrawColor, %i[ptr int int int int], :int
+    ffi_func :SDL_RenderFillRect, %i[ptr ptr], :int
+    ffi_func :SDL_RenderDrawLines, %i[ptr int_array int], :int
+    ffi_func :SDL_SetTextureBlendMode, %i[ptr int], :int
+    ffi_func :SDL_SetTextureColorMod, %i[ptr int int int], :int
+    ffi_func :SDL_RenderCopy, %i[ptr ptr ptr ptr], :int
+    ffi_func :SDL_RenderPresent, [:ptr], :void
+    ffi_func :SDL_PollEvent, [:ptr], :int
+    ffi_func :SDL_SetRelativeMouseMode, [:int], :int
+    ffi_func :SDL_Delay, [:uint32], :void
+    ffi_func :SDL_GetRendererOutputSize, %i[ptr ptr ptr], :int
+    ffi_func :SDL_RenderReadPixels, %i[ptr ptr uint32 ptr int], :int
+    ffi_func :SDL_CreateRGBSurfaceWithFormatFrom, %i[ptr int int int int uint32], :ptr
+    ffi_func :SDL_FreeSurface, [:ptr], :void
+    ffi_func :SDL_RWFromFile, %i[str str], :ptr
+    ffi_func :SDL_SaveBMP_RW, %i[ptr ptr int], :int
+    ffi_func :SDL_InitSubSystem, [:uint32], :int
+    ffi_func :SDL_QuitSubSystem, [:uint32], :void
+    ffi_func :SDL_OpenAudioDevice, %i[ptr int ptr ptr int], :uint32
+    ffi_func :SDL_CloseAudioDevice, [:uint32], :void
+    ffi_func :SDL_PauseAudioDevice, %i[uint32 int], :void
+    ffi_func :SDL_QueueAudio, %i[uint32 buffer_in uint32], :int
+    ffi_func :SDL_GetQueuedAudioSize, [:uint32], :uint32
+    ffi_func :SDL_NumJoysticks, [], :int
+    ffi_func :SDL_IsGameController, [:int], :int
+    ffi_func :SDL_GameControllerOpen, [:int], :ptr
+    ffi_func :SDL_GameControllerClose, [:ptr], :void
+    ffi_func :SDL_GameControllerName, [:ptr], :str
+    ffi_func :SDL_GameControllerGetButton, %i[ptr int], :uint8
+    ffi_func :SDL_GameControllerGetAxis, %i[ptr int], :int16
+    ffi_func :SDL_ClearQueuedAudio, [:uint32], :void
+    ffi_func :SDL_PushEvent, [:ptr], :int
+    ffi_func :SDL_GetKeyName, [:int], :str
 
-    def self.open_library
-      LIBRARIES.each do |name|
-        return Fiddle.dlopen(name)
-      rescue Fiddle::DLError
-        next
-      end
-      raise Error, "can't find libSDL2 (tried #{LIBRARIES.join(', ')})"
-    end
+    ffi_buffer :event, 56
+    ffi_read_u32 :event_type, 0
+    ffi_read_u8 :event_repeat, 13
+    ffi_read_i32 :event_scancode, 16
+    ffi_read_i32 :event_sym, 20
+    ffi_read_u16 :event_mod, 24
+    # SDL_MouseMotionEvent's xrel and yrel, and SDL_MouseButtonEvent's
+    # button.
+    ffi_read_i32 :event_xrel, 28
+    ffi_read_i32 :event_yrel, 32
+    ffi_read_u8 :event_button, 16
+    # Where the pointer is, in a motion or button event.
+    ffi_read_i32 :event_x, 20
+    ffi_read_i32 :event_y, 24
+    # SDL_DropEvent's file, which the receiver frees.
+    ffi_read_ptr :event_file, 8
 
-    LIBRARY = open_library
+    ffi_buffer :rect, 16
+    ffi_write_i32 :rect_x, 0
+    ffi_write_i32 :rect_y, 4
+    ffi_write_i32 :rect_w, 8
+    ffi_write_i32 :rect_h, 12
+    # Where the drive LED goes.
+    ffi_buffer :led_rect, 16
+    # A glyph's place in the SID player's font, drawn at SDL.rect.
+    ffi_buffer :glyph_rect, 16
 
-    VOID = Fiddle::TYPE_VOID
-    INT = Fiddle::TYPE_INT
-    UINT8 = Fiddle::TYPE_UINT8_T
-    INT16 = Fiddle::TYPE_INT16_T
-    UINT32 = Fiddle::TYPE_UINT32_T
-    POINTER = Fiddle::TYPE_VOIDP
-    STRING = Fiddle::TYPE_CONST_STRING
+    # SDL_DisplayMode: Uint32 format; int w, h, refresh_rate; then a pointer.
+    ffi_buffer :display_mode, 24
+    ffi_read_i32 :mode_refresh, 12
 
-    def self.function(name, arguments, result)
-      Fiddle::Function.new(LIBRARY[name], arguments, result, name:, need_gvl: true)
-    end
+    ffi_buffer :output_w, 4
+    ffi_buffer :output_h, 4
+    ffi_read_i32 :read_i32, 0
 
-    def self.error = GetError.call
+    # SDL_AudioSpec: int freq; Uint16 format; Uint8 channels, silence;
+    # Uint16 samples, padding; Uint32 size; then two pointers.
+    ffi_buffer :wanted, 32
+    ffi_buffer :obtained, 32
+    ffi_write_i32 :spec_freq, 0
+    ffi_write_u16 :spec_format, 4
+    ffi_write_u8 :spec_channels, 6
+    ffi_write_u16 :spec_samples, 8
 
-    # A negative result from SDL is an error, and SDL_GetError says which.
-    def self.check(result)
-      raise Error, error if result.negative?
+    ffi_const :INIT_AUDIO, 0x10
+    ffi_const :INIT_VIDEO, 0x20
+    ffi_const :INIT_GAMECONTROLLER, 0x2000
+    ffi_const :INIT_EVENTS, 0x4000
+    ffi_const :WINDOWPOS_CENTERED, 0x2fff0000
+    ffi_const :WINDOW_RESIZABLE, 0x20
+    ffi_const :RENDERER_ACCELERATED, 0x02
+    ffi_const :RENDERER_PRESENTVSYNC, 0x04
+    ffi_const :PIXELFORMAT_RGB888, 0x16161804
+    ffi_const :PIXELFORMAT_ARGB8888, 0x16362004
+    ffi_const :BLENDMODE_BLEND, 0x01
+    ffi_const :TEXTUREACCESS_STREAMING, 1
+    ffi_const :QUIT, 0x100
+    ffi_const :KEYDOWN, 0x300
+    ffi_const :KEYUP, 0x301
+    ffi_const :MOUSEMOTION, 0x400
+    ffi_const :MOUSEBUTTONDOWN, 0x401
+    ffi_const :MOUSEBUTTONUP, 0x402
+    ffi_const :KMOD_SHIFT, 0x0003
+    ffi_const :CONTROLLERDEVICEADDED, 0x653
+    ffi_const :CONTROLLERDEVICEREMOVED, 0x654
+    ffi_const :AUDIO_S16LSB, 0x8010
+    ffi_const :ALLOW_FREQUENCY_CHANGE, 0x01
+    ffi_const :KEY_TAB, 0x09
+    ffi_const :KEY_F10, 0x4000_0043
+  end
 
-      result
-    end
+  # The few C library calls the native front end makes.
+  module LibC
+    ffi_func :malloc, [:size_t], :ptr
+    ffi_func :free, [:ptr], :void
+    ffi_func :poll, %i[ptr size_t int], :int
+    # Called with an empty needle, it returns the C string it's given as a
+    # String.
+    ffi_func :strstr, %i[ptr str], :str
 
-    # So is a null handle.
-    def self.check_pointer(pointer)
-      raise Error, error if pointer.null?
+    ffi_const :POLLIN, 0x01
 
-      pointer
-    end
+    # struct pollfd: int fd; short events, revents.
+    ffi_buffer :pollfd, 8
+    ffi_write_i32 :pollfd_fd, 0
+    ffi_write_i16 :pollfd_events, 4
   end
 end
-
-require "badline/sdl/functions"
-require "badline/sdl/events"

data/lib/badline/sid/catch_up.rb

@@ -96,7 +96,17 @@ module Badline
 
       def record_sample(span)
         sample = @decimator.push(current_sample, span)
-        @samples << sample if sample
+        return unless sample
+
+        @samples << sample
+        record_voices if @voice_samples
+      end
+
+      def record_voices
+        voice_samples = @voice_samples
+        voice_samples << (@voice1.output >> 7)
+        voice_samples << (@voice2.output >> 7)
+        voice_samples << (@voice3.output >> 7)
       end
 
       def current_sample

data/lib/badline/sid/filter.rb

@@ -122,6 +122,15 @@ module Badline
         reset
       end
 
+      # The integrators and the registers carry over; the cutoff maps
+      # through the new model's curve.
+      def model=(model)
+        @model = model
+        @w0_table = W0.fetch(model)
+        @mixer_dc = MIXER_DC.fetch(model)
+        @w0 = @w0_table[@cutoff]
+      end
+
       def reset
         @cutoff = 0x000
         @routing = 0x0

data/lib/badline/sid/voice.rb

@@ -33,6 +33,12 @@ module Badline
         @dc_offset = DC_OFFSET.fetch(model)
       end
 
+      def model=(model)
+        @waveform.model = model
+        @wave_zero = WAVE_ZERO.fetch(model)
+        @dc_offset = DC_OFFSET.fetch(model)
+      end
+
       def reset!
         @waveform.reset!
         @envelope = Envelope.new

data/lib/badline/sid/waveform/noise_writeback.rb

@@ -20,11 +20,12 @@ module Badline
         # so they lose a different number of bits. The 8580's pair is the one
         # that reproduces SID/wf12nsr's pulse+noise row (it reads $f8, and the
         # writeback leaves $fc behind), and SID/wb_testsuite's C->9 and C->E
-        # rows need that same $fc written at release. On the 6581 the read is
-        # the $fc of SID/wf12nsr's readme (VICE bug #1037), and the writeback
-        # pulls nothing: wb_testsuite's 8/9/A/B->C rows run pulse+noise and
-        # leave the register alone.
-        PULSE_NOISE_READ = { mos6581: 0xfc0, mos8580: 0xf80 }.freeze
+        # rows need that same $fc written at release. The 6581 reads $00 of a
+        # full register (SID/wf12nsr's pulse+noise row) and pulls nothing
+        # while the register holds: wb_testsuite's 8->C and C->C rows run
+        # pulse+noise and leave the register alone. Its lines only land
+        # part way through a shift (#write_back_shift).
+        PULSE_NOISE_READ = { mos6581: 0x000, mos8580: 0xf80 }.freeze
         PULSE_NOISE_WRITE = { mos6581: 0xff0, mos8580: 0xfc0 }.freeze
 
         # What a 6581 writes back when the test bit falls with only pulse+noise
@@ -40,24 +41,45 @@ module Badline
         # (SID/wf12nsr's noise+triangle and noise+sawtooth rows).
         def write_back(selected, value)
           return value & ((value << 1) | (value >> 1)) unless selected == 0xc
-          return value if value.zero?
+          return 0x000 if @pulse.zero?
 
           noise & @pulse_noise_write
         end
 
+        # What the lines write while the register is part way through a
+        # shift, where the 6581's pulse+noise writes its output as read.
+        def write_back_mid_shift(selected, value)
+          return value if pulse_noise_mid_shift?(selected)
+
+          write_back(selected, value)
+        end
+
+        def pulse_noise_mid_shift?(selected) = @topbit_feedback && selected == 0xc
+
         def write_shift_register(value)
           NOISE_TAPS.each { |bit, line| @shift_register &= ~bit if value.nobits?(line) }
         end
 
-        # Setting the test bit starts the bleed, and writes the output of a
-        # noise combination back first, from the accumulator it had. Only
-        # SID/noiselfsrinit sets the bit onto such a combination from outside
-        # it: its $f8/$80 pairs go from noise alone to all four.
+        # The second phase of a shift writes back by the test bit release
+        # rule with the waveform left alone. The 6581's pulse+noise, which
+        # that rule leaves out, writes its lines too (SID/wf12nsr's
+        # pulse+noise row).
+        def write_back_shift
+          return unless pulse_noise_mid_shift?(@selected) || release_writes_back?(@selected, @selected)
+
+          write_shift_register(write_back_mid_shift(@selected, @output))
+        end
+
+        # Setting the test bit starts the bleed, and stalls the register part
+        # way through a shift, where a noise combination writes its output
+        # back first, from the accumulator it had. SID/noiselfsrinit's
+        # $f8/$80 pairs set the bit onto all four from noise alone, and
+        # SID/wf12nsr's pulse+noise row sets it onto pulse+noise.
         def raise_test
           @shift_register_reset = @shift_register_reset_delay
           return unless @selected.anybits?(0x8) && combined?(@selected) && @shift_pipeline != 1
 
-          write_shift_register(write_back(@selected, shape(@selected)))
+          write_shift_register(write_back_mid_shift(@selected, shape(@selected)))
         end
 
         # Releasing the test bit finishes the shift it interrupted: the old

data/lib/badline/sid/waveform.rb

@@ -54,17 +54,24 @@ module Badline
       attr_reader :accumulator, :shift_register, :frequency, :pulse_width, :pulse
 
       def initialize(model: :mos6581)
-        @topbit_feedback = model != :mos8580
+        use_model(model)
         @tri_saw_delay = model == :mos8580
-        @pulse_noise_read = PULSE_NOISE_READ.fetch(model)
-        @pulse_noise_write = PULSE_NOISE_WRITE.fetch(model)
-        @combined = Combined.tables(model)
-        @shift_register_reset_delay = SHIFT_REGISTER_RESET_DELAY.fetch(model)
         @accumulator = POWER_ON_ACCUMULATOR
         @sync_source = @sync_dest = self
         reset!
       end
 
+      # The running state carries over. A 6581 never delays its shapers, so
+      # the 8580's delayed triangle and sawtooth start from the current phase.
+      def model=(model)
+        use_model(model)
+        if model == :mos8580 && !@tri_saw_delay
+          @delayed_sawtooth = sawtooth
+          @delayed_triangle = triangle
+        end
+        @tri_saw_delay = model == :mos8580
+      end
+
       # The RES line clears the registers and reseeds the LFSR, but leaves
       # the accumulator alone (SID/oscinit).
       def reset!
@@ -190,6 +197,14 @@ module Badline
 
       private
 
+      def use_model(model)
+        @topbit_feedback = model != :mos8580
+        @pulse_noise_read = PULSE_NOISE_READ.fetch(model)
+        @pulse_noise_write = PULSE_NOISE_WRITE.fetch(model)
+        @combined = Combined.tables(model)
+        @shift_register_reset_delay = SHIFT_REGISTER_RESET_DELAY.fetch(model)
+      end
+
       def shape(selected, saw = sawtooth, tri = triangle(selected))
         case selected
         when 0x1 then tri
@@ -256,8 +271,7 @@ module Badline
       # A rise of bit 19 starts a shift that takes two more cycles
       # (SID/noisewriteback's noise_writeback_test2, after libresidfp's shift
       # pipeline). The first phase latches the output, and the second writes
-      # it over the taps, by the test bit release rule with the waveform left
-      # alone, before the register shifts.
+      # it over the taps before the register shifts.
       def advance
         previous = @accumulator
         @accumulator = (previous + @frequency) & 0xffffff
@@ -265,7 +279,7 @@ module Badline
         if @accumulator & ~previous & 0x080000 != 0
           @shift_pipeline = 2
         elsif @shift_pipeline != 0 && (@shift_pipeline -= 1).zero?
-          write_shift_register(write_back(@selected, @output)) if release_writes_back?(@selected, @selected)
+          write_back_shift
           shift_noise
         end
       end

data/lib/badline/sid.rb

@@ -16,7 +16,9 @@ module Badline
   # $D41B-$D41C - Voice 3 oscillator/envelope - read only
   # $D41D-$D41F - Unconnected
   #
-  # The register file mirrors every 32 bytes up to $D7FF.
+  # The register file mirrors every 32 bytes up to $D7FF. A second or
+  # third SID, which only the SID player fits, is built `at` another
+  # address and decodes just the 32 bytes there.
   #
   # Reading a write-only or unconnected register returns the last byte the
   # SID saw on the data bus. That value fades to $00 as the capacitance
@@ -55,8 +57,8 @@ module Badline
     attr_accessor :pots
     attr_reader :model
 
-    def initialize(model: :mos6581, pots: nil, filter_chunk: FILTER_CHUNK)
-      addressable_at(0xd400, length: 2**10)
+    def initialize(model: :mos6581, pots: nil, filter_chunk: FILTER_CHUNK, at: 0xd400)
+      addressable_at(at, length: at == 0xd400 ? 2**10 : 2**5)
       @model = model
       @pots = pots
       @bus_ttl_reset = BUS_TTL.fetch(model)
@@ -67,6 +69,7 @@ module Badline
       @deferred_writes = []
       @decimator = nil
       @samples = []
+      @voice_samples = nil
       @filter_chunk = filter_chunk
       @voices = Voice.linked(VOICES, model:)
       @voice1, @voice2, @voice3 = @voices
@@ -74,6 +77,18 @@ module Badline
       reset!
     end
 
+    # Switches the chip, its filter and its voices to the other model's
+    # values. The cycles already passed run on the old model first, and the
+    # running state carries over.
+    def model=(model)
+      catch_up
+      @model = model
+      @bus_ttl_reset = BUS_TTL.fetch(model)
+      @filter.model = model
+      @voices.each { |voice| voice.model = model }
+      update_span_rules
+    end
+
     # The RES line clears the registers, the data bus, the filter and the
     # voices, all but their accumulators. Recording carries on across it.
     def reset!
@@ -112,6 +127,23 @@ module Badline
       @samples = []
     end
 
+    # Also keeps each voice's own output, before the filter and the volume,
+    # as each recorded sample closes, for #drain_voice_samples.
+    def record_voices!
+      @voice_samples = [] if @voice_samples.nil?
+    end
+
+    # The voices' outputs since the last drain, three to a sample, in voice
+    # order, or nothing unless #record_voices! asked for them.
+    def drain_voice_samples
+      return [] if @voice_samples.nil?
+
+      catch_up
+      samples = @voice_samples
+      @voice_samples = []
+      samples
+    end
+
     # The samples recorded since the last drain.
     def drain_samples
       catch_up

data/lib/badline/snapshot/state.rb

@@ -14,7 +14,7 @@ module Badline
       # The layout the chips write their fields in. It goes up whenever a
       # save_state writes something else, so a State in another layout
       # fails before anything is read into a machine.
-      SCHEMA = 1
+      SCHEMA = 2
 
       attr_reader :values, :strings
 

data/lib/badline/storage/hvsc.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # The layout of an HVSC collection: tunes in directories under its root,
+    # and databases about them in `DOCUMENTS`. A tune's HVSC path is its path
+    # from the root, as `/MUSICIANS/H/Hubbard_Rob/Commando.sid`.
+    module HVSC
+      class << self
+        # The named file in the DOCUMENTS directory of a collection above the
+        # tune, or else of the one `$HVSC_BASE` points at.
+        def document(tune_path, name)
+          candidates(tune_path).map { |dir| File.join(dir, "DOCUMENTS", name) }
+                               .find { |path| File.file?(path) }
+        end
+
+        # The tune's HVSC path in the collection that holds the document, or
+        # nil when the tune lies outside it.
+        def path(tune_path, document)
+          root = File.dirname(File.expand_path(document), 2)
+          tune = File.expand_path(tune_path)
+          tune.start_with?("#{root}/") ? tune[root.length..] : nil
+        end
+
+        private
+
+        def candidates(tune_path)
+          dirs = []
+          dir = File.dirname(File.expand_path(tune_path))
+          until dirs.last == dir
+            dirs << dir
+            dir = File.dirname(dir)
+          end
+          base = ENV.fetch("HVSC_BASE", nil)
+          dirs << base if base
+          dirs
+        end
+      end
+    end
+  end
+end