ramekin 0.0.5b

data/lib/ramekin/macros.rb

@@ -0,0 +1,101 @@
+module Ramekin
+  class MacroDefinition < Element
+    attr_reader :token, :elements
+    def initialize(token, elements=[])
+      @token = token
+      @elements = elements
+    end
+
+    def name
+      @token.value
+    end
+
+    def inspect
+      "macro:#{name}=[#{@elements.map(&:first).map(&:repr_basic).join(',')}]"
+    end
+  end
+
+  class MacroExpander < Processor
+    def initialize
+      @definitions = Hash.new { |h, k| h[k] = [] }
+      @defines = {}
+      @ifdef_depth = 0
+      @skip_depth = nil
+    end
+
+    def call(&b)
+      @level = 0
+      parse_chunk(nil) do |el, stack|
+        el.macro_stack = stack
+        yield el
+      end
+    end
+
+    def parse_chunk(expected_end=nil, &b)
+      @level += 1
+
+      each do |el|
+        if @skip_depth && @ifdef_depth >= @skip_depth
+          if Token === el && el.type == :endif
+            @ifdef_depth -= 1
+
+            if @ifdef_depth < @ifdef_depth
+              @skip_depth = nil
+            end
+          end
+
+          next
+        end
+
+        el.macro_stack = @stack.dup
+        next yield el, [] unless Token === el
+
+        if el.type == expected_end
+          break
+        end
+
+        case el.type
+        when :macro
+          definition = MacroDefinition.new(el)
+          @definitions[el.value] = definition
+          parse_chunk :endmacro do |sub, stack|
+            definition.elements << [sub, stack + [el]]
+          end
+
+          # yield definition, []
+        when :macrocall
+          @definitions[el.value].elements.each do |sub, stack|
+            yield sub.dup, stack
+          end
+        when :endmacro
+          error! 'endmacro token outside of a macro definition'
+        when :define
+          # TODO: value defines (needs lexer support)
+          @defines[el.value] = 1
+        when :ifdef
+          @ifdef_depth += 1
+          unless @defines.key?(el.value)
+            @skip_depth = @ifdef_depth
+          end
+        when :ifndef
+          @ifdef_depth += 1
+          if @defines.key?(el.value)
+            @skip_depth = @ifdef_depth
+          end
+        when :endif
+          @ifdef_depth -= 1
+        else
+          yield el, []
+        end
+      end
+    rescue StopIteration
+      if @level > 1
+        error! "unclosed replacement: missing double quote" if @level > 1
+      end
+      # pass
+    ensure
+      @level -= 1
+    end
+  end
+end
+

data/lib/ramekin/meta.rb

@@ -0,0 +1,227 @@
+module Ramekin
+  class Meta
+    include Error::Helpers
+
+    attr_reader :title
+    attr_reader :game
+    attr_reader :author
+    attr_reader :comment
+    attr_reader :readme
+    attr_reader :amk
+    attr_reader :instruments
+    attr_reader :sample_groups
+    attr_reader :options
+    attr_reader :volume
+    attr_reader :tempo
+    attr_reader :echo
+    def initialize(elements)
+      @elements = elements
+      @instruments = []
+      @sample_groups = []
+      @options = {}
+    end
+
+    def parse
+      loop do
+        break if @elements.empty?
+        next!
+
+        case @current.type
+        when :directive then parse_directive
+        when :amk then @amk = @current
+        when :option then @options[@current.value] = true
+        when :w then @volume = @current
+        when :t, :bpm then @tempo = @current
+        else
+          error! 'invalid token in header'
+        end
+      end
+
+      @sample_groups << 'default' if @sample_groups.empty?
+    end
+
+    def parse_directive
+      @current_directive = @current
+      case @current.value
+      when 'title' then @title = expect_arg(:string)
+      when 'game' then @game = expect_arg(:string)
+      when 'author' then @author = expect_arg(:string)
+      when 'comment' then @comment = expect_arg(:string)
+      when 'readme' then @readme = expect_arg(:string)
+      when 'pack' then
+        pack_name = expect_arg(:string)
+        @current_pack = SamplePack.find(pack_name.value) \
+          or error!("can't find sample pack #{pack_name.value.inspect}, try running `ramekin package update`")
+      when 'instrument'
+        name, path = expect_args(:instrument, :string)
+        extensions = []
+        while (el = check_arg(:adsr, :tuning, :o))
+          extensions << el
+        end
+
+        return unless @current_pack
+        @instruments << Instrument.new(@current_pack, @current, name, path, extensions)
+      when 'default', 'optimized' then @sample_groups << @current
+
+      # TODO: real echo syntax
+      when 'echo' then @echo = expect_args(*([:hex] * 8))
+      else
+        error! 'invalid directive in header'
+      end
+    end
+
+    def expect_args(*types)
+      types.map do |type|
+        next!
+        unless @current.type == type
+          error! "expected #{type} in ##{@current_directive.value} directive"
+        end
+
+        @current
+      end
+    end
+
+    def expect_arg(type)
+      expect_args(type).first
+    end
+
+    def check_arg(*types)
+      if peek && types.include?(peek.type)
+        next!
+        @current
+      else
+        nil
+      end
+    end
+
+    def next!
+      if @peek
+        @current = @peek
+        @peek = nil
+        return @current
+      end
+
+      @current = @elements.shift
+    end
+
+    def peek
+      @peek ||= @elements.shift
+    end
+  end
+
+  # TODO: customization options for instrument
+  class Instrument < Element
+    attr_reader :pack, :directive, :name, :path
+    def initialize(pack, directive, name, path, extensions)
+      @pack = pack
+      @directive = directive
+      @name = name
+      @path = path
+      @extensions = extensions
+    end
+
+    include Error::Helpers
+    # @override
+    def default_error_location
+      @directive
+    end
+
+    def inspect
+      "inst:@#{name.value} #{@extensions.inspect}"
+    end
+
+    def sample_name
+      @sample_name ||= File.basename(sample_path)
+    end
+
+    def sample_path
+      @pack.find(@path.value)
+    end
+
+    def pack_adsr
+      return if pack_hexes.nil?
+
+      hex1, hex2, _ = pack_hexes
+      h1 = hex1.to_i(16)
+      h2 = hex2.to_i(16)
+
+      # unset the first bit, as it is unused
+      h1 &= ~0x80
+
+      decay = (7 - (h1 >> 4))
+      attack = (15 - (h1 & 0b1111))
+      sustain = h2 >> 5
+      release = (31 - (h2 & 0b11111))
+
+      [attack, decay, sustain, release]
+    end
+
+    def ext_adsr
+      adsr = @extensions.select { |e| e.type == :adsr }.last
+      adsr && adsr.value.split(',').map(&:to_i)
+    end
+
+    def adsr
+      @adsr ||= ext_adsr || pack_adsr \
+        or error! "no adsr configured for #{name}"
+    end
+
+    def tuning
+      @tuning ||= ext_tuning || pack_tuning \
+        or error! "no tuning configured for #{name}"
+    end
+
+    def pack_tuning
+      _, _, _, d, e = pack_hexes
+      [d, e]
+    end
+
+    def ext_tuning
+      tuning = @extensions.select { |e| e.type == :tuning }.last
+      tuning && tuning.value.scan(/../)
+    end
+
+    def pack_hexes
+      # TODO: alts
+      @pack_hexes ||= @pack.tunings_for(sample_name).first
+    end
+
+    def pack_gain
+      _, _, g, _, _ = pack_hexes
+      return g
+    end
+
+    def ext_gain
+      gain = @extensions.select { |e| e.type == :gain }.last
+      gain && gain.value
+    end
+
+    def gain
+      @gain ||= ext_gain || pack_gain \
+        or error! "no gain configured for #{name}"
+    end
+
+    def hexes
+      a, d, s, r = self.adsr
+      t1, t2 = self.tuning
+      g = self.gain
+
+      adsr1 = ((7 - d)*16 | 0x80) + (15 - a)
+      adsr2 = (s*32 + (31-r))
+
+      [adsr1.to_s(16), adsr2.to_s(16), g, t1, t2]
+    end
+
+    def to_amk
+      "#{File.basename(sample_name).inspect} #{hexes.map { |h| "$#{h}" }.join(' ')}"
+    end
+
+    def octave
+      @extensions.reverse_each do |ext|
+        return ext.value.to_i if Token === ext && ext.type == :o
+      end
+
+      4
+    end
+  end
+end

data/lib/ramekin/note_aggregator.rb

@@ -0,0 +1,252 @@
+module Ramekin
+  class NoteEvent < Element
+    include Error::Helpers
+    def default_error_location
+      self
+    end
+
+    attr_reader :note, :extensions, :octave
+    def initialize(note, octave, triplets, extensions=[])
+      @note = note
+      @octave = octave
+      @triplets = triplets
+      @extensions = extensions
+    end
+
+    def start
+      @note.start
+    end
+
+    def fin
+      (@extensions.last || @note).fin
+    end
+
+    def octave_num
+      case @octave
+      when Token then @octave.value.to_i
+      else @octave.to_i
+      end
+    end
+
+    def note_name
+      return 'r' if rest?
+      return '^' if tie?
+      @note.value
+    end
+
+    def rest?
+      @note.type == :r
+    end
+
+    def tie?
+      @note.type == :native_tie
+    end
+
+    KNOWN_LENGTHS = {}.tap do |out|
+      ticks = 192
+      length = 1
+
+      loop do
+        out[ticks] = length.to_s
+
+        break unless ticks % 2 == 0
+
+        out[ticks * 3 / 2] = "#{length}."
+        length *= 2
+        ticks /= 2
+      end
+    end
+
+    def length_amk
+      # we use l16
+      return '' if ticks == 12
+      KNOWN_LENGTHS.fetch(ticks) { "=#{ticks}" }
+    end
+
+    def octave_amk(current_octave=nil)
+      return '' if rest? || tie?
+
+      return "o#{octave_num}" if current_octave.nil?
+
+      case octave_num
+      when current_octave
+        ""
+      when current_octave + 1
+        ">"
+      when current_octave - 1
+        "<"
+      else
+        "o#{octave_num}"
+      end
+    end
+
+    def to_amk(current_octave=nil)
+      return "#{octave_amk(current_octave)}#{note_name}#{length_amk}"
+    end
+
+    def repr
+      "note:#{to_amk}"
+    end
+
+    def default_length
+      @note.meta[:l]
+    end
+
+    def ticks
+      if @extensions.empty? && default_length.nil?
+        error! "no length and no default specified with l", el: @note
+      end
+
+      exts = @extensions
+      exts = [default_length] if exts.empty?
+
+      base = exts.map do |ext|
+        ext = ext.value if Token === ext
+
+        case ext
+        when /\A=(\d+)\z/ then $1.to_i
+        when '0' then 192 * 2
+        when /\A(\d+)\z/ then 192 / $1.to_i
+        when /\A(\d+)[.]\z/ then 192 * 3 / ($1.to_i * 2)
+        else
+          error! "unknown length specifier #{ext}", el: ext
+        end
+      end.sum
+
+      base = (base * 2) / 3 if @triplets
+
+      base
+    end
+
+    def inspect
+      repr
+    end
+  end
+
+  class CombinedRestEvent < NoteEvent
+    def initialize(rests)
+      @rests = rests
+      error! "empty CombinedRestEvent" if rests.empty?
+    end
+
+    def start
+      rests.first.start
+    end
+
+    def fin
+      rests.last.fin
+    end
+
+    def rest?
+      true
+    end
+
+    def ticks
+      @rests.map(&:ticks).sum
+    end
+  end
+
+  class ScanForL < Processor
+    def call(&b)
+      @current_l = nil
+
+      each do |el|
+        case el.type
+        when :l
+          @current_l = el
+        when :note, :r, :native_tie
+          el.meta[:l] = @current_l
+          yield el
+        else
+          yield el
+        end
+      end
+    end
+  end
+
+  class NoteAggregator < Processor
+    def initialize
+      @current_note = nil
+    end
+
+    def flush!(&b)
+      if @current_note
+        yield @current_note
+        @current_note = nil
+      end
+
+      buffer.each(&b)
+      buffer.clear
+    end
+
+    def call(&b)
+      return enum_for(:call) unless block_given?
+
+      current_l = nil
+      current_octave = 4
+      @triplets = false
+
+      each do |el|
+        next yield el unless Token === el
+
+        case el.type
+        when :lbrace
+          @triplets = true
+          yield el
+        when :rbrace
+          @triplets = false
+          yield el
+        when :instrument
+          inst = el.meta[:inst]
+
+          current_octave = inst ? inst.octave : 4
+          buffer << el
+        when :l
+          current_l = el
+        when :note, :r, :native_tie
+          flush!(&b)
+          @current_note = NoteEvent.new(el, current_octave, @triplets)
+        when :o
+          current_octave = el.value.to_i
+        when :octave
+          current_octave += (el.value == '<' ? -1 : 1)
+        when :tie
+          # handle, for example, r^8
+          if @current_note.extensions.empty?
+            @current_note.extensions << @current_note.default_length
+          end
+
+          next
+        when :length
+          @current_note.extensions << el
+        else
+          buffer << el
+        end
+      end
+
+      flush!(&b)
+    end
+  end
+
+  class RestAggregator < Processor
+    def flush!(&b)
+      return if buffer.empty?
+      yield CombinedRestEvent.new(buffer)
+      @buffer = []
+    end
+
+    def call(&b)
+      each do |evt|
+        if NoteEvent === evt && evt.rest?
+          buffer << evt
+          next
+        end
+
+        flush!(&b)
+        yield evt
+      end
+
+      flush!(&b)
+    end
+  end
+end

data/lib/ramekin/processor.rb

@@ -0,0 +1,78 @@
+module Ramekin
+  class Processor
+    attr_accessor :stream
+
+    include Error::Helpers
+
+    def buffer
+      @buffer ||= []
+    end
+
+    def flush!(&b)
+      return if buffer.empty?
+      buffer.each(&b)
+      buffer.clear
+    end
+
+    def self.call(enum, *a, &b)
+      return enum_for(:call, enum, *a) unless block_given?
+
+      enum = enum.each if enum.is_a?(Array)
+
+      inst = new(*a)
+      inst.stream = enum
+      inst.call(&b)
+    end
+
+    def each
+      loop do
+        next! or break
+        yield @current
+      end
+    end
+
+    def next!
+      if @peek
+        @current, @peek = @peek, nil
+        return @current
+      end
+
+      @current = @stream.next
+    end
+
+    def peek
+      @peek ||= @stream.next
+    rescue StopIteration
+      nil
+    end
+
+    def self.compose(*processors)
+      Chain.new(processors)
+    end
+  end
+
+  class Chain < Processor
+    def initialize(processors)
+      @processors = processors
+    end
+
+    def call(stream, &b)
+      out = stream
+
+      @processors.each do |p|
+        out = p.call(out)
+      end
+
+      out
+    end
+  end
+
+  class Inspector < Processor
+    def call(&b)
+      each do |el|
+        # p el
+        yield el
+      end
+    end
+  end
+end