rdoba 0.1 → 0.9

data/lib/rdoba/a.rb

@@ -2,6 +2,55 @@
 #<Encoding:UTF-8>
 
 require 'rdoba/debug'
+require 'rdoba/common'
+
+class Object
+  def seta(index, value, options = {}) #TODO => [] + class Index
+    raise "Invalid class #{self.class} to set a value" unless
+	self.class == Hash or self.class == Array
+    dbp11 "[seta] <<< index: #{index.inspect}, value: #{value.inspect}, options: #{options.inspect}"
+    options[:сокр] ||= @сокр
+
+    return self[index] = value if index.class != Array # TODO spec index
+
+    back = 0
+    index = index.reverse.map do |x|
+      if x.empty?
+        back += 1
+        nil
+      elsif back > 0
+        back -= 1
+        nil
+      else
+        x
+      end
+    end.compact.reverse
+    dbp12 "[seta]> result index: #{index.inspect}"
+
+    par = self
+    par_idx = index.shift
+    index.each do |idx|
+      dbp14 "[seta]>> parent #{par.class} with idx: #{par_idx.inspect}"
+      obj = par[par_idx]
+      if not obj
+        obj = idx.to_s =~ /^\d+$/ && [] || {}
+        par[par_idx] = obj
+        dbp14 "[seta]>> new object #{obj.class}"
+      elsif obj.class != Hash and obj.class != Array
+	raise "Invalid class #{obj.class} for indexing"
+      end
+
+      par = obj
+      par_idx = idx
+    end
+
+    dbp14 "[seta]>> object #{par.class} with idx: #{par_idx.inspect}"
+
+    par[par_idx] = value
+    dbp11 "[seta] >>> #{self.inspect}"
+    self
+  end
+end
 
 class Array
   def geta(index, options = {}) #TODO => [] + class Index
@@ -11,13 +60,12 @@ class Array
     if index.class == Array
       return self if index == [] or index == ['']
       index = index.clone
-      value = self[index.shift]
+      value = self[index.shift.to_i]
       (value.class == Hash or value.class == Array) ? value.geta(index, options) : value
     else
       geta_value(index, options)
     end
   end
-
 end
 
 
@@ -59,56 +107,5 @@ public
       geta_value(index, options)
     end
   end
-
-  def seta(index, value, options = {}) #TODO => [] + class Index
-    dbp11 "[seta] <<< index: #{index.inspect}, value: #{value.inspect}, options: #{options.inspect}"
-    options[:сокр] ||= @сокр
-
-    return self[index] = value if index.class != Array # TODO spec index
-
-    back = 0
-    index = index.reverse.map do |x|
-      if x.empty?
-        back += 1
-        nil
-      elsif back > 0
-        back -= 1
-        nil
-      else
-        x
-      end
-    end.compact.reverse
-    dbp12 "[seta]> result index: #{index.inspect}"
-
-    obj = nil
-    o = self
-    dbp14 "[seta]>> self: #{o.inspect}"
-    set_idx = index.pop
-    par_class = set_idx =~ /^\d+$/ ? Array : Hash
-    par_idx = nil
-    index.each do |idx|
-      unless o
-        dbp14 "[seta]>> parent idx: #{par_idx.inspect}, idx: #{idx.inspect}, parent obj: #{o.inspect}"
-        o = idx =~ /^\d+$/ && [] || {}
-        obj[par_idx] = o
-      end
-      obj = o
-      o = (obj.class == Hash) ? obj.geta_value(idx, options) : obj[idx]
-      dbp14 "[seta]>> cur idx: #{idx.inspect}, parent obj: #{obj.inspect}, obj: #{o.inspect}"
-      unless o
-        if idx == index.last
-          o = par_class.new
-          obj[idx] = o
-        else
-          par_idx = idx =~ /^\d+$/ && idx.to_i || idx
-        end
-      end
-    end
-
-    raise "Invalid path" unless o # TODO special exception
-
-    o[set_idx] = value
-  end
-
 end
 

data/lib/rdoba/bcd.rb

@@ -0,0 +1,61 @@
+#encoding: utf-8
+#
+
+module BCD
+  class ParseError < Exception
+    def initialize msg = "Invalid positive integer value"; end; end
+
+  class ConvertError < Exception
+    def initialize msg = "Invalid number has given"; end; end
+
+  def to_i
+    res = 0
+    mul = 1
+    self.each_byte do |c|
+      def pow value, mul
+        if value >= 10
+          raise ConvertError; end
+        value * mul
+      end
+      res += pow( c.ord & 0xF,  mul )
+      mul *= 10
+      res += pow( c.ord >> 4, mul )
+      mul *= 10
+    end
+    res; end
+
+  def self.parse value
+    if value < 0
+      raise ParseError; end
+    res = BCDString.new
+    if res.respond_to? :force_encoding
+      res.force_encoding( 'ASCII-8BIT' ); end
+    if value > 0
+      part = nil
+      while value > 0
+        ( value, mod ) = value.divmod 10
+        if part
+          res << ( ( mod << 4 ) | part ).chr
+          part = nil
+        else
+          part = mod; end; end
+      if part
+        res << part.chr; end
+    else
+      res << 0.chr; end
+    res; end; end
+
+class BCDString < String
+  include BCD
+
+  def initialize value = nil
+    if value.is_a? Numeric
+      self.replace BCD.parse( value )
+    else
+      super value.to_s; end; end; end
+
+class Numeric
+  def to_bcd
+    # NOTE: return as plain LSB string
+    BCD.parse value; end; end
+

data/lib/rdoba/common.rb

@@ -38,17 +38,15 @@ class Object
 end
 
 module Kernel
-  def wait_if(timeout = 30)
-    require 'timeout'
+  require 'timeout'
 
-    begin
-      Timeout::timeout(timeout) do
-        while yield(); end
-      end
-      true
-    rescue Timeout::Error
-      false
+  def if_wait(timeout = 30)
+    Timeout::timeout(timeout) do
+      while yield(); end
     end
+    true
+  rescue Timeout::Error
+    false
   end
 end
 
@@ -104,6 +102,17 @@ class Array
     return __set__(index.to_i, value, *args) if index.class == String and index =~ /^\d+$/
     __set__(index, value, *args)
   end
+
+  def glue!(inval)
+    self.each_index do |i|
+      begin
+	self[i] |= inval[i]
+      rescue
+	self[i] = inval[i]
+      end if inval[i]
+    end
+    self
+  end
 end
 
 class String
@@ -148,14 +157,36 @@ class String
 end
 
 class Hash
+  def glue!(inval)
+    self.replace self.glue(inval)
+  end
+
+  def glue(inval)
+    res = self.dup
+    inval.each_pair do |key, val|
+      if val.class == res[key].class
+        if val.class == Hash
+          res[key].glue! val
+        elsif val.class == Array
+          res[key].glue! val
+        else
+          res[key] = val
+        end
+      else
+        res[key] = val
+      end
+    end
+    res
+  end
+
   def |(inval)
     res = self.dup
     inval.each_pair do |key, val|
       if val.class == res[key].class
         if val.class == Hash
-          res[key] |= inval[key]
+          res[key] |= val
         elsif val.class == Array
-          res[key].concat val
+          res[key] |= val
         else
           res[key] = val
         end

data/lib/rdoba/debug.rb

@@ -1,48 +1,6 @@
-#!/usr/bin/ruby
+# encoding: utf-8
 
-class Object
-  attr_reader :debug
-
-  @debug = nil
-  eval "$debug_#{self.class} = 0"
-
-public
-
-  def debug=(level)
-    @debug = level
-  end
-
-  def dbc(level)
-    level = level.to_i
-    if level > 0
-      clevel = @debug || begin; eval "$debug_#{self.class}"; rescue; nil; end
-      clevel ? (clevel.to_i & level) == level : false
-    else
-      false
-    end
-  end
-
-  def dbp(level, text)
-    Kernel.puts text if dbc(level)
-  end
-
-  def dbg(level, code, vars = {})
-    if dbc(level)
-      if vars
-        vars.each_pair do |var, value|
-          instance_variable_set(var, value)
-        end
-      end
-      eval code
-    end
-  end
-
-  (1..0xF).each do |x|
-    (1..0xF).each do |y|
-      idx = sprintf "%x%x", x, y
-      eval "def dbp#{idx}(text); dbp(0x#{idx},text); end"
-      eval "def dbg#{idx}(text); dbg(0x#{idx},text); end"
-    end
-  end
-end
+STDERR.puts "Warning: the module has kept only for backward compatibility\n" +
+"Please use 'rdoba :log' form instead"
+require 'rdoba/log'
 

data/lib/rdoba/{fenc.rb → fe.rb}

@@ -1,7 +1,7 @@
 #!/usr/bin/ruby -KU
 
 class String
-  def fenc
+  def fe
     if RUBY_VERSION < '1.9'
       self
     else
@@ -13,5 +13,6 @@ class String
       end
     end
   end
+  alias :fenc :fe
 end
 

data/lib/rdoba/io.rb

@@ -1,5 +1,5 @@
-#!/usr/bin/ruby -KU
-#<Encoding:UTF-8>
+#!/usr/bin/env ruby
+# encoding: utf-8
 
 require 'strscan'
 require 'rdoba/re'
@@ -11,6 +11,7 @@ module Kernel
   def sprintf(format, *args)
     nargs = []
     nformat = ''
+    oargs = args.dup
 
     fmt = format.split('%')
     nformat = fmt.shift
@@ -18,23 +19,46 @@ module Kernel
     while (not fmt.empty?)
       part = fmt.shift
       part = '%' + fmt.shift unless part
-      if part =~ /([0-9 #+\-*.]*)([bcdEefGgiopsuXxP])(.*)/ and $2 == 'P'
+      if part =~ /([0-9 #+\-*.]*)([csXx])(.*)/ # other keys bdEefGgiopu
         keys = $1 || ''
-        str = $3 || ''
-        if keys =~ /(-)?([0-9*]*)\.?([0-9\*]*)(\+?)/
+        rest = $3 || ''
+        char = $2
+        if keys =~ /(?:([0-9*]*)\.([0-9*]+)([+-])?|(-)?)/
+          indent = ( $1 == '*' && args.shift || $1 ).to_i
+          padding_size = $2 == '*' && args.shift.to_i || $2
           value = args.shift
-          indent = ' ' * ($2 == '*' ? args.shift : $2).to_i
-          plain = value && value.to_p(
-	      :padding => ($3 == '*' ? args.shift : $3.empty? ? 1 : $3).to_i,
-	      :be => $4.empty? ? nil : true) || ''
-          nformat += ($1 ? plain + indent : indent + plain) + str
+          def convert( value, char, *args )
+            case char
+            when 'c'
+              endian = args[ 1 ] == '+' && Fixnum::BigEndian ||
+                  args[ 1 ] == '-' && Fixnum::LittleEndian ||
+                  Fixnum::NativeEndian
+              value.to_i.to_p( :padding => ( args[ 0 ] && args[ 0 ].to_i || 1 ),
+              :endian => endian )
+            when 's'
+              rs = value.to_s
+              pad = args[ 0 ] && args[ 0 ].to_i || 0
+              padl = rs.size >= pad && '' || ( "\0" * ( pad - rs.size ) )
+              args[ 1 ] && ( padl + rs ) || ( rs + padl )
+            when /(x|X)/
+              rs = value.ord.to_s( 16 )
+              rs = rs.upcase if $1 == 'X'
+              pad = args[ 0 ] && args[ 0 ].to_i || 0
+              ( rs.size >= pad && '' || ( '0' * ( pad - rs.size ) ) ) + rs
+            end.gsub( Regexp.new( '%', Regexp::EXTENDED | Regexp::MULTILINE ),
+                '%%' )
+          end
+          plain = value && convert( value, char, padding_size, $3 ) || ''
+          indent = indent > plain.size && ( indent - plain.size ) || 0
+          nformat += ( $4 && ( plain + ' ' * indent ) ||
+              ( ' ' * indent + plain ) ) + rest
         else
-          nformat += '%' + keys + 'c' + str
+          nformat += '%' + keys + char + rest
           nargs.push args.shift
         end
       else
         nformat += '%' + part
-        l = $1 =~ /\*/ ? 2 : 1
+        l = $1 =~ /\*/ && 2 || 1
         while l > 0
           nargs.push args.shift
           l -= 1
@@ -42,8 +66,11 @@ module Kernel
       end
     end
     __sprintf__(nformat, *nargs).to_p
+  rescue ArgumentError
+    Kernel.puts "[sprintf] #{$!.class}: #{$!}\n\t" + $@.join("\n\t") +
+        "\n\tNew format string = #{nformat.inspect}, params = #{nargs.inspect}" +
+        "\n\tOld format string = #{format.inspect}, params = #{oargs.inspect}"
   end
-
 end
 
 class String
@@ -53,7 +80,7 @@ class String
 
     pos = 0
     argfs = []
-    while fss.scan_until(/%([0-9 #+\-*]*)(?:\.([0-9]+)(\+)?)?([bcdefgiosuxr])/)
+    while fss.scan_until(/%([0-9 #+\-*]*)(?:\.([0-9]+)([-+])?)?([bcdefgiosuxr])/)
       argfs << [ fss[1], fss[2], fss[3], fss[4] ]
       # TODO add performing the special case in fss[1]
       nformat += fss.pre_match[pos..-1].to_res + case fss[4]
@@ -70,7 +97,7 @@ class String
       when 'g'
         '([+\-]?[0-9]+(?:[eE][+\-]?[0-9]+|\.[0-9]*))'
       when 'c'
-        fss[2] ? "(.{1,#{fss[2]}})" : "(.)"
+        fss[2] ? "(.{#{fss[2]},#{fss[2]}})" : "(.)"
       when 'b'
         '([01]+)b?'
       when 'o'
@@ -88,7 +115,7 @@ class String
 
     nformat += fss.rest
 
-    [ /#{nformat}/, argfs ]
+    [ r3 = Regexp.new(nformat, Regexp::EXTENDED | Regexp::MULTILINE), argfs ]
   end
 
   (alias :__scanf__ :scanf) if self.instance_methods(false).include?(:scanf)
@@ -110,7 +137,10 @@ class String
         when /[efg]/
           value.to_f
         when 'c'
-	  argf[2] ? value.to_i(:be) : value.to_i
+          endian = argf[2] == '+' && Fixnum::BigEndian ||
+              argf[2] == '-' && Fixnum::LittleEndian ||
+              Fixnum::NativeEndian
+          value.to_i( endian )
         when 'b'
           value.to_i(2)
         when 'o'