lydown 0.7.2 → 0.9.0

data/lib/lydown/rendering.rb

@@ -38,15 +38,6 @@ module Lydown::Rendering
       end
     end
   end
-  
-  class Base
-    def initialize(event, work, stream, idx)
-      @event = event
-      @work = work
-      @stream = stream
-      @idx = idx
-    end
-  end
 end
 
 LY_LIB_DIR = File.join(File.dirname(__FILE__), 'rendering')

data/lib/lydown/rendering/base.rb

@@ -1,8 +1,8 @@
 module Lydown::Rendering
   class Base
-    def initialize(event, work, stream, idx)
+    def initialize(event, context, stream, idx)
       @event = event
-      @work = work
+      @context = context
       @stream = stream
       @idx = idx
     end

data/lib/lydown/rendering/command.rb

@@ -3,12 +3,12 @@ module Lydown::Rendering
     include Notes
     
     def translate
-      if @work['process/duration_macro']
+      if @context['process/duration_macro']
         add_macro_event(@event[:raw] || cmd_to_lydown(@event))
       else
         once = @event[:once] ? '\once ' : ''
         cmd = "#{once}\\#{@event[:key]} #{(@event[:arguments] || []).join(' ')} "
-        @work.emit(:music, cmd)
+        @context.emit(:music, cmd)
       end
     end
     

data/lib/lydown/rendering/comments.rb

@@ -1,7 +1,7 @@
 module Lydown::Rendering
   class Comment < Base
     def translate
-      @work.emit(:music, "\n%{#{@event[:content]}%}\n")
+      @context.emit(:music, "\n%{#{@event[:content]}%}\n")
     end
   end
 end

data/lib/lydown/rendering/figures.rb

@@ -1,37 +1,37 @@
 module Lydown::Rendering
   module Figures
     def add_figures(figures, value)
-      if @work['process/running_values']
-        @work['process/running_values'].each do |v|
+      if @context['process/running_values']
+        @context['process/running_values'].each do |v|
           silence = "s"
-          if v != @work['process/last_figures_value']
+          if v != @context['process/last_figures_value']
             silence << v
-            @work['process/last_figures_value'] = v
+            @context['process/last_figures_value'] = v
           end
-          @work.emit(:figures, "#{silence} ")
+          @context.emit(:figures, "#{silence} ")
         end
-        @work['process/running_values'] = []
+        @context['process/running_values'] = []
       end
 
       figures = lilypond_figures(figures)
-      if value != @work['process/last_figures_value']
+      if value != @context['process/last_figures_value']
         figures << value
-        @work['process/last_figures_value'] = value
+        @context['process/last_figures_value'] = value
       end
 
-      @work.emit(:figures, "#{figures} ")
-      @work.emit(:figures, EXTENDERS_ON) if @event[:figure_extenders_on]
-      @work.emit(:figures, EXTENDERS_OFF) if @event[:figure_extenders_off]
+      @context.emit(:figures, "#{figures} ")
+      @context.emit(:figures, EXTENDERS_ON) if @event[:figure_extenders_on]
+      @context.emit(:figures, EXTENDERS_OFF) if @event[:figure_extenders_off]
     end
 
     def add_stand_alone_figures(figures)
-      if @work['process/running_values']
+      if @context['process/running_values']
         # for stand alone figures, we regard the stand alone figure as being
         # aligned to the last note. Therefore we pop its value from
         # running_values array.
-        @work['process/running_values'].pop
+        @context['process/running_values'].pop
       end
-      value =  @work['process/figures_duration_value'] || @work['process/last_value']
+      value =  @context['process/figures_duration_value'] || @context['process/last_value']
       add_figures(figures, value)
     end
 

data/lib/lydown/rendering/lib.ly

@@ -1,3 +1,18 @@
+\header {
+  tagline = \markup {
+    Engraved using \bold {
+      \with-url #"http://github.com/ciconia/lydown" {
+        Lydown
+      }
+    }
+    and \bold {
+      \with-url #"http://lilypond.org/" {
+        Lilypond
+      }
+    }
+  }
+}
+
 segno = {
   \once \override Score.RehearsalMark #'font-size = #-2
   \mark \markup { \musicglyph #"scripts.segno" }
@@ -48,6 +63,13 @@ ficta = {
   \once \set suggestAccidentals = ##t
 }
 
+prallupbefore = {
+  \mark\markup {
+    \musicglyph #"scripts.prallup"
+    \hspace #1 
+  }
+}
+
 %{
   http://www.lilypond.org/doc/v2.18/Documentation/snippets/editorial-annotations#editorial-annotations-adding-links-to-objects
 %}

data/lib/lydown/rendering/lyrics.rb

@@ -4,9 +4,9 @@ module Lydown::Rendering
       value = lilypond_lyrics(@event[:content])
       
       lyrics_idx = @event[:stream_index] || 1
-      voice = @work['process/voice_selector'] || 'voice1'
+      voice = @context['process/voice_selector'] || 'voice1'
       
-      @work.emit("lyrics/#{voice}/#{lyrics_idx}", value, ' ')
+      @context.emit("lyrics/#{voice}/#{lyrics_idx}", value, ' ')
     end
 
     def lilypond_lyrics(lyrics)

data/lib/lydown/rendering/movement.rb

@@ -1,6 +1,6 @@
 module Lydown::Rendering
   module Movement
-    def self.movement_title(work, name)
+    def self.movement_title(context, name)
       return nil if name.nil? || name.empty?
       
       if name =~ /^(?:([0-9]+)([a-z]*))\-(.+)$/
@@ -9,7 +9,7 @@ module Lydown::Rendering
         title = name
       end
       
-      if work["movements/#{name}/parts"].empty?
+      if context["movements/#{name}/parts"].empty?
         title += " - tacet"
       end
       

data/lib/lydown/rendering/music.rb

@@ -9,80 +9,80 @@ module Lydown::Rendering
 
   class Duration < Base
     def translate
-      Notes.cleanup_duration_macro(@work)
+      Notes.cleanup_duration_macro(@context)
 
       # close tuplet braces
-      if @work['process/tuplet_mode']
-        TupletDuration.emit_tuplet_end(@work)
-        @work['process/tuplet_mode'] = nil
+      if @context['process/tuplet_mode']
+        TupletDuration.emit_tuplet_end(@context)
+        @context['process/tuplet_mode'] = nil
       end
 
-      if @work['process/grace_mode']
-        Grace.emit_grace_end(@work)
-        @work['process/grace_mode'] = nil
+      if @context['process/grace_mode']
+        Grace.emit_grace_end(@context)
+        @context['process/grace_mode'] = nil
       end
 
       value = @event[:value].sub(/^[0-9]+/) {|m| LILYPOND_DURATIONS[m] || m}
 
       if next_event && next_event[:type] == :stand_alone_figures
-        @work['process/figures_duration_value'] = value
+        @context['process/figures_duration_value'] = value
       else
-        @work['process/duration_values'] = [value]
-        @work['process/tuplet_mode'] = nil
-        @work['process/duration_macro'] = nil unless @work['process/macro_group']
+        @context['process/duration_values'] = [value]
+        @context['process/tuplet_mode'] = nil
+        @context['process/duration_macro'] = nil unless @context['process/macro_group']
       end
     end
 
   end
 
   class TupletDuration < Base
-    def self.emit_tuplet_end(work)
-      work.emit(:music, '} ')
+    def self.emit_tuplet_end(context)
+      context.emit(:music, '} ')
     end
 
     def translate
-      Notes.cleanup_duration_macro(@work)
+      Notes.cleanup_duration_macro(@context)
 
       # close tuplet braces
-      if @work['process/tuplet_mode']
-        TupletDuration.emit_tuplet_end(@work)
-        @work['process/tuplet_mode'] = nil
+      if @context['process/tuplet_mode']
+        TupletDuration.emit_tuplet_end(@context)
+        @context['process/tuplet_mode'] = nil
       end
 
       if next_event && next_event[:type] == :stand_alone_figures
-        @work['process/figures_duration_value'] = "#{@event[:value]}*#{@event[:fraction]}"
+        @context['process/figures_duration_value'] = "#{@event[:value]}*#{@event[:fraction]}"
       else
         value = LILYPOND_DURATIONS[@event[:value]] || @event[:value]
 
-        @work['process/duration_values'] = [value]
-        @work['process/last_value'] = nil
-        @work['process/tuplet_mode'] = true
+        @context['process/duration_values'] = [value]
+        @context['process/last_value'] = nil
+        @context['process/tuplet_mode'] = true
         
         group_value = value.to_i / @event[:group_length].to_i
-        @work.emit(:music, "\\tuplet #{@event[:fraction]} #{group_value} { ")
+        @context.emit(:music, "\\tuplet #{@event[:fraction]} #{group_value} { ")
       end
     end
   end
   
   class Grace < Base
-    def self.emit_grace_end(work)
-      work.emit(:music, '} ')
+    def self.emit_grace_end(context)
+      context.emit(:music, '} ')
     end
     
     def translate
       # close tuplet braces
-      if @work['process/grace_mode']
-        Grace.emit_grace_end(@work)
-        @work['process/grace_mode'] = nil
+      if @context['process/grace_mode']
+        Grace.emit_grace_end(@context)
+        @context['process/grace_mode'] = nil
       end
 
       value = LILYPOND_DURATIONS[@event[:value]] || @event[:value]
 
-      @work['process/duration_values'] = [value]
-      @work['process/last_value'] = nil
-      @work['process/grace_mode'] = true
+      @context['process/duration_values'] = [value]
+      @context['process/last_value'] = nil
+      @context['process/grace_mode'] = true
       
-      @work.emit(:music, "\\#{@event[:kind]} { ")
+      @context.emit(:music, "\\#{@event[:kind]} { ")
     end
   end
 
@@ -141,7 +141,7 @@ module Lydown::Rendering
 
   class BeamOpen < Base
     def translate
-      @work['process/open_beam'] = true
+      @context['process/open_beam'] = true
     end
   end
 
@@ -152,7 +152,7 @@ module Lydown::Rendering
 
   class SlurOpen < Base
     def translate
-      @work['process/open_slur'] = true
+      @context['process/open_slur'] = true
     end
   end
 
@@ -161,7 +161,7 @@ module Lydown::Rendering
 
   class Tie < Base
     def translate
-      @work.emit(:music, '~ ')
+      @context.emit(:music, '~ ')
     end
   end
 
@@ -169,8 +169,8 @@ module Lydown::Rendering
     include Notes
 
     def translate
-      note_head = @work['process/last_note_head']
-      @work.emit(:music, '~ ')
+      note_head = @context['process/last_note_head']
+      @context.emit(:music, '~ ')
       add_note({head: note_head})
     end
   end
@@ -194,17 +194,17 @@ module Lydown::Rendering
       translate_expressions
 
       if @event[:multiplier]
-        value = full_bar_value(@work[:time])
-        @work['process/duration_macro'] = nil unless @work['process/macro_group']
+        value = full_bar_value(@context[:time])
+        @context['process/duration_macro'] = nil unless @context['process/macro_group']
         if value
           @event[:rest_value] = "#{value}*#{@event[:multiplier]}"
           @event[:head] = "#{@event[:head]}#{@event[:rest_value]}"
         else
-          @event[:head] = "#{@event[:head]}#{@event[:multiplier]}*#{@work[:time]}"
+          @event[:head] = "#{@event[:head]}#{@event[:multiplier]}*#{@context[:time]}"
         end
         # reset the last value so the next note will be rendered with its value
-        @work['process/last_value'] = nil
-        @work['process/duration_values'] = []
+        @context['process/last_value'] = nil
+        @context['process/duration_values'] = []
       end
 
       add_note(@event)
@@ -230,22 +230,22 @@ module Lydown::Rendering
 
   class DurationMacro < Base
     def translate
-      Notes.cleanup_duration_macro(@work)
+      Notes.cleanup_duration_macro(@context)
       
       if @event[:macro] =~ /^[a-zA-Z_]/
-        macro = @work['macros'][@event[:macro]]
+        macro = @context['macros'][@event[:macro]]
         if macro
           if macro =~ /^\{(.+)\}$/
             macro = $1
           end
           # replace the repeating note placeholder with another sign in order to
           # avoid mixing up with repeating notes from outside the macro
-          @work['process/duration_macro'] = macro.gsub('@', '∞')
+          @context['process/duration_macro'] = macro.gsub('@', '∞')
         else
           raise LydownError, "Unknown macro #{@event[:macro]}"
         end
       else
-        @work['process/duration_macro'] = @event[:macro]
+        @context['process/duration_macro'] = @event[:macro]
       end
     end
   end
@@ -254,7 +254,7 @@ module Lydown::Rendering
     def translate
       barline = @event[:barline]
       barline = '' if barline == '?|'
-      @work.emit(:music, "\\bar \"#{barline}\" ")
+      @context.emit(:music, "\\bar \"#{barline}\" ")
     end
   end
 end

data/lib/lydown/rendering/notes.rb

@@ -59,85 +59,156 @@ module Lydown::Rendering
 
       note + (value >= 0 ? 'is' * value : 'es' * -value)
     end
+    
+    def self.chromatic_to_diatonic(note, key_signature = 'c major')
+      note =~ /([a-g])([\+\-]*)/
+      diatonic_note = $1
+      chromatic_value = $2.count('+') - $2.count('-')
+      
+      key_accidentals = accidentals_for_key_signature(key_signature)
+      diatonic_value = key_accidentals[diatonic_note] || 0
+      value = chromatic_value - diatonic_value
+      
+      "#{diatonic_note}#{value >= 0 ? '+' * value : '-' * -value}"
+    end
 
     # Takes into account the accidentals mode
-    def self.translate_note_name(work, note)
-      if work[:accidentals] == 'manual'
+    def self.translate_note_name(context, note)
+      if context[:accidentals] == 'manual'
         key = 'c major'
       else
-        key = work[:key]
+        key = context[:key]
       end
       lilypond_note_name(note, key)
     end
   end
+  
+  module Octaves
+    DIATONICS = %w{a b c d e f g}
+
+    # calculates the octave markers needed to put a first note in the right 
+    # octave. In lydown, octaves are relative (i.e. lilypond's relative mode).
+    # But the first note gives the octave to start on, rather than a relative 
+    # note to c (or any other reference note).
+    #
+    # In that manner, d' is d above middle c, g'' is g an octave and fifth 
+    # above middle c, a is a a below middle c, and eß, is great e flat.
+    # 
+    # The return value is a string with octave markers for relative mode,
+    # based on the refence note
+    def self.relative_octave(note, ref_note = 'c')
+      note_diatonic, ref_diatonic = note[0], ref_note[0]
+      raise LydownError, "Invalid note #{note}" unless DIATONICS.index(note_diatonic)
+      raise LydownError, "Invalid reference note #{ref_note}" unless DIATONICS.index(ref_diatonic)
+      
+      # calculate diatonic interval
+      note_array = DIATONICS.rotate(DIATONICS.index(ref_diatonic))
+      interval = note_array.index(note_diatonic)
+
+      # calculate octave interval and 
+      octave_value = note.count("'") - note.count(',')
+      ref_value = ref_note.count("'") - ref_note.count(',')
+      octave_interval = octave_value - ref_value
+      octave_interval += 1 if interval >= 4
+      
+      # generate octave markers
+      octave_interval >= 0 ? "'" * octave_interval : "," * -octave_interval
+    end
+
+    def self.absolute_octave(note, ref_note = 'c')
+      note_diatonic, ref_diatonic = note[0], ref_note[0]
+      raise LydownError, "Invalid note #{note}" unless DIATONICS.index(note_diatonic)
+      raise LydownError, "Invalid reference note #{ref_note}" unless DIATONICS.index(ref_diatonic)
+      
+      # calculate diatonic interval
+      note_array = DIATONICS.rotate(DIATONICS.index(ref_diatonic))
+      interval = note_array.index(note_diatonic)
+
+      # calculate octave interval and 
+      note_value = note.count("'") - note.count(',')
+      ref_value = ref_note.count("'") - ref_note.count(',')
+      octave_interval = ref_value + note_value
+      octave_interval -= 1 if interval >= 4
+      
+      # generate octave markers
+      octave_interval >= 0 ? "'" * octave_interval : "," * -octave_interval
+    end
+  end
 
   module Notes
     include Lydown::Rendering::Figures
 
     def add_note(event, options = {})
-      return add_macro_note(event) if @work['process/duration_macro']
+      return add_macro_note(event) if @context['process/duration_macro']
+      
+      # calculate relative octave markers for first note
+      unless @context['process/first_note'] || event[:head] =~ /^[rsR]/
+        note = event[:head] + (event[:octave] || '')
+        event[:octave] = Lydown::Rendering::Octaves.relative_octave(note)
+        @context['process/first_note'] = note
+      end
       
-      if @event[:head] == '@'
+      if event[:head] == '@'
         # replace repeating note head
-        @event[:head] = @work['process/last_note_head'] 
+        event[:head] = @context['process/last_note_head'] 
       else
-        @work['process/last_note_head'] = event[:head]
+        @context['process/last_note_head'] = event[:head]
       end
 
-      value = @work['process/duration_values'].first
-      @work['process/duration_values'].rotate!
+      value = @context['process/duration_values'].first
+      @context['process/duration_values'].rotate!
 
       add_figures(event[:figures], value) if event[:figures]
 
       # push value into running values accumulator. This is used to synthesize
       # the bass figures durations.
       unless event[:figures]
-        @work['process/running_values'] ||= []
+        @context['process/running_values'] ||= []
         if event[:rest_value]
-          @work['process/running_values'] << event[:rest_value]
+          @context['process/running_values'] << event[:rest_value]
         else
-          @work['process/running_values'] << value
+          @context['process/running_values'] << value
         end
       end
 
       # only add the value if different than the last used
-      if options[:no_value] || (value == @work['process/last_value'])
+      if options[:no_value] || (value == @context['process/last_value'])
         value = ''
       else
-        @work['process/last_value'] = value
+        @context['process/last_value'] = value
       end
-      
-      if event[:line] && @work['options/proof_mode']
-        @work.emit(event[:stream] || :music, note_event_url_link(event))
-        # @work.emit(event[:stream] || :music, "%{#{event[:line]}:#{event[:column]}%}")
+
+      if event[:line] && @context['options/proof_mode']
+        @context.emit(event[:stream] || :music, note_event_url_link(event))
+        # @context.emit(event[:stream] || :music, "%{#{event[:line]}:#{event[:column]}%}")
       end
 
       code = lilypond_note(event, options.merge(value: value))
-      @work.emit(event[:stream] || :music, code)
+      @context.emit(event[:stream] || :music, code)
     end
     
     def add_chord(event, options = {})
-      value = @work['process/duration_values'].first
-      @work['process/duration_values'].rotate!
+      value = @context['process/duration_values'].first
+      @context['process/duration_values'].rotate!
 
       add_figures(event[:figures], value) if event[:figures]
 
       # push value into running values accumulator. This is used to synthesize
       # the bass figures durations.
       unless event[:figures]
-        @work['process/running_values'] ||= []
+        @context['process/running_values'] ||= []
         if event[:rest_value]
-          @work['process/running_values'] << event[:rest_value]
+          @context['process/running_values'] << event[:rest_value]
         else
-          @work['process/running_values'] << value
+          @context['process/running_values'] << value
         end
       end
 
       # only add the value if different than the last used
-      if value == @work['process/last_value']
+      if value == @context['process/last_value']
         value = ''
       else
-        @work['process/last_value'] = value
+        @context['process/last_value'] = value
       end
       
       notes = event[:notes].map do |note|
@@ -145,11 +216,11 @@ module Lydown::Rendering
       end
       
       options = options.merge(value: value)
-      @work.emit(event[:stream] || :music, lilypond_chord(event, notes, options))
+      @context.emit(event[:stream] || :music, lilypond_chord(event, notes, options))
     end
     
     def lilypond_note(event, options = {})
-      head = Accidentals.translate_note_name(@work, event[:head])
+      head = Accidentals.translate_note_name(@context, event[:head])
       if options[:head_only]
         head
       else
@@ -187,13 +258,13 @@ module Lydown::Rendering
 
     def lilypond_phrasing(event)
       phrasing = ''
-      if @work['process/open_beam']
+      if @context['process/open_beam']
         phrasing << '['
-        @work['process/open_beam'] = nil
+        @context['process/open_beam'] = nil
       end
-      if @work['process/open_slur']
+      if @context['process/open_slur']
         phrasing << '('
-        @work['process/open_slur'] = nil
+        @context['process/open_slur'] = nil
       end
       phrasing << ']' if event[:beam_close]
       phrasing << ')' if event[:slur_close]
@@ -202,13 +273,13 @@ module Lydown::Rendering
 
     def lydown_phrasing_open(event)
       phrasing = ''
-      if @work['process/open_beam']
+      if @context['process/open_beam']
         phrasing << '['
-        @work['process/open_beam'] = nil
+        @context['process/open_beam'] = nil
       end
-      if @work['process/open_slur']
+      if @context['process/open_slur']
         phrasing << '('
-        @work['process/open_slur'] = nil
+        @context['process/open_slur'] = nil
       end
       phrasing
     end
@@ -221,7 +292,7 @@ module Lydown::Rendering
     end
 
     def add_macro_note(event)
-      @work['process/macro_group'] ||= @work['process/duration_macro'].clone
+      @context['process/macro_group'] ||= @context['process/duration_macro'].clone
       underscore_count = 0
 
       lydown_note = "{%d:%d}%s%s%s%s%s%s%s" % [
@@ -233,9 +304,9 @@ module Lydown::Rendering
         event[:figures] ? "<#{event[:figures].join}>" : '',
         event[:expressions] ? event[:expressions].join + ' ' : ''
       ]
-
+      
       # replace place holder and repeaters in macro group with actual note
-      @work['process/macro_group'].gsub!(/[_∞]/) do |match|
+      @context['process/macro_group'].gsub!(/[_∞]/) do |match|
         case match
         when '_'
           underscore_count += 1
@@ -245,52 +316,60 @@ module Lydown::Rendering
         end
       end
 
-      # if group is complete, compile it just like regular code
-      unless @work['process/macro_group'].include?('_')
-        code = LydownParser.parse(@work['process/macro_group'], {
-          filename: event[:filename],
-          source:   event[:source]
-        })
-
-        # stash macro
-        macro = @work['process/duration_macro']
-        @work['process/duration_macro'] = nil
-        @work['process/macro_group'] = nil
-
-        @work.process(code, no_reset: true)
+      # keep filename and source in order to ensure source references are kept
+      # correct
+      @context['process/macro_filename'] = event[:filename]
+      @context['process/macro_source'] = event[:source]
+      
+      # increment group note count
+      @context['process/macro_group_note_count'] ||= 0
+      @context['process/macro_group_note_count'] += 1
 
-        # restore macro
-        @work['process/duration_macro'] = macro
+      # if group is complete, compile it just like regular code
+      unless @context['process/macro_group'].include?('_')
+        Notes.add_duration_macro_group(@context, @context['process/macro_group'])
       end
     end
     
     # emits the current macro group up to the first placeholder character.
     # this method is called 
-    def self.cleanup_duration_macro(work)
-      return unless work['process/macro_group']
+    def self.cleanup_duration_macro(context)
+      return unless context['process/macro_group_note_count'] &&
+        context['process/macro_group_note_count'] > 0
       
       # truncate macro group up until first placeholder
-      group = work['process/macro_group'].sub(/_.*$/, '')
-      
-      # stash macro, in order to compile macro group
-      macro = work['process/duration_macro']
-      work['process/duration_macro'] = nil
-      work['process/macro_group'] = nil
-
-      code = LydownParser.parse(group)
-      work.process(code, no_reset: true)
+      group = context['process/macro_group'].sub(/_.*$/, '')
 
+      # Refrain from adding 
+      add_duration_macro_group(context, group)
+    end
+    
+    def self.add_duration_macro_group(context, group)
+      opts = (context[:options] || {}).merge({
+        filename: context['process/macro_filename'],
+        source:   context['process/macro_source']
+      }).deep!
+      code = LydownParser.parse_macro_group(group, opts)
+
+      # stash macro
+      macro = context['process/duration_macro']
+      context['process/duration_macro'] = nil
+      context['process/macro_group'] = nil
+      context['process/macro_group_note_count'] = nil
+
+      context.translate(code, macro_group: true)
+    ensure
       # restore macro
-      work['process/duration_macro'] = macro
+      context['process/duration_macro'] = macro
     end
     
     def add_macro_event(code)
-      case @work['process/macro_group']
+      case @context['process/macro_group']
       when nil
-        @work['process/macro_group'] = @work['process/duration_macro'].clone
-        @work['process/macro_group'].insert(0, " #{code} ")
+        @context['process/macro_group'] = @context['process/duration_macro'].clone
+        @context['process/macro_group'].insert(0, " #{code} ")
       when /_/
-        @work['process/macro_group'].sub!(/([_∞])/, " #{code} \\0")
+        @context['process/macro_group'].sub!(/([_∞])/, " #{code} \\0")
       end
     end