esruby 0.0.0

data/resources/mruby/mrblib/init_mrblib.c

@@ -0,0 +1,11 @@
+#include <mruby.h>
+#include <mruby/irep.h>
+
+extern const uint8_t mrblib_irep[];
+
+void
+mrb_init_mrblib(mrb_state *mrb)
+{
+  mrb_load_irep(mrb, mrblib_irep);
+}
+

data/resources/mruby/mrblib/kernel.rb

@@ -0,0 +1,50 @@
+##
+# Kernel
+#
+# ISO 15.3.1
+module Kernel
+
+  # 15.3.1.2.1 Kernel.`
+  # provided by Kernel#`
+  # 15.3.1.3.5
+  def `(s)
+    raise NotImplementedError.new("backquotes not implemented")
+  end
+
+  ##
+  # 15.3.1.2.3  Kernel.eval
+  # 15.3.1.3.12 Kernel#eval
+  # NotImplemented by mruby core; use mruby-eval gem
+
+  ##
+  # ISO 15.3.1.2.8 Kernel.loop
+  # provided by Kernel#loop
+
+  ##
+  # Calls the given block repetitively.
+  #
+  # ISO 15.3.1.3.29
+  def loop(&block)
+    return to_enum :loop unless block
+
+    while true
+      yield
+    end
+  rescue StopIteration => e
+    e.result
+  end
+
+  # 11.4.4 Step c)
+  def !~(y)
+    !(self =~ y)
+  end
+
+  # internal method for inspect
+  def _inspect
+    self.inspect
+  end
+
+  def to_enum(*a)
+    raise NotImplementedError.new("fiber required for enumerator")
+  end
+end

data/resources/mruby/mrblib/mrblib.rake

@@ -0,0 +1,21 @@
+MRuby.each_target do
+  current_dir = File.dirname(__FILE__)
+  relative_from_root = File.dirname(__FILE__).relative_path_from(MRUBY_ROOT)
+  current_build_dir = "#{build_dir}/#{relative_from_root}"
+
+  self.libmruby << objfile("#{current_build_dir}/mrblib")
+
+  file objfile("#{current_build_dir}/mrblib") => "#{current_build_dir}/mrblib.c"
+  file "#{current_build_dir}/mrblib.c" => [mrbcfile, __FILE__] + Dir.glob("#{current_dir}/*.rb").sort do |t|
+    _, _, *rbfiles = t.prerequisites
+    if self.cc.defines.flatten.include?("MRB_WITHOUT_FLOAT")
+      rbfiles.delete("#{current_dir}/float.rb")
+    end
+    FileUtils.mkdir_p File.dirname(t.name)
+    open(t.name, 'w') do |f|
+      _pp "GEN", "*.rb", "#{t.name.relative_path}"
+      f.puts File.read("#{current_dir}/init_mrblib.c")
+      mrbc.run f, rbfiles, 'mrblib_irep'
+    end
+  end
+end

data/resources/mruby/mrblib/numeric.rb

@@ -0,0 +1,163 @@
+##
+# Numeric
+#
+# ISO 15.2.7
+class Numeric
+  include Comparable
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.7.4.1
+  def +@
+    self
+  end
+
+  ##
+  # Returns the receiver's value, negated.
+  #
+  # ISO 15.2.7.4.2
+  def -@
+    0 - self
+  end
+
+  ##
+  # Returns the absolute value of the receiver.
+  #
+  # ISO 15.2.7.4.3
+  def abs
+    if self < 0
+      -self
+    else
+      self
+    end
+  end
+end
+
+##
+# Integral
+#
+# mruby special - module to share methods between Floats and Integers
+#                 to make them compatible
+module Integral
+  ##
+  # Calls the given block once for each Integer
+  # from +self+ downto +num+.
+  #
+  # ISO 15.2.8.3.15
+  def downto(num, &block)
+    return to_enum(:downto, num) unless block
+
+    i = self.to_i
+    while i >= num
+      block.call(i)
+      i -= 1
+    end
+    self
+  end
+
+  ##
+  # Returns self + 1
+  #
+  # ISO 15.2.8.3.19
+  def next
+    self + 1
+  end
+  # ISO 15.2.8.3.21
+  alias succ next
+
+  ##
+  # Calls the given block +self+ times.
+  #
+  # ISO 15.2.8.3.22
+  def times &block
+    return to_enum :times unless block
+
+    i = 0
+    while i < self
+      block.call i
+      i += 1
+    end
+    self
+  end
+
+  ##
+  # Calls the given block once for each Integer
+  # from +self+ upto +num+.
+  #
+  # ISO 15.2.8.3.27
+  def upto(num, &block)
+    return to_enum(:upto, num) unless block
+
+    i = self.to_i
+    while i <= num
+      block.call(i)
+      i += 1
+    end
+    self
+  end
+
+  ##
+  # Calls the given block from +self+ to +num+
+  # incremented by +step+ (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = if class_defined?("Float") && num.kind_of?(Float) then self.to_f else self end
+    if num == nil
+      while true
+        block.call(i)
+        i+=step
+      end
+      return self
+    end
+    if step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end
+
+##
+# Integer
+#
+# ISO 15.2.8
+class Integer
+  include Integral
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.14
+  def ceil
+    self
+  end
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.17
+  def floor
+    self
+  end
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.24
+  alias round floor
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.26
+  alias truncate floor
+end

data/resources/mruby/mrblib/range.rb

@@ -0,0 +1,67 @@
+##
+# Range
+#
+# ISO 15.2.14
+class Range
+
+  ##
+  # Calls the given block for each element of +self+
+  # and pass the respective element.
+  #
+  # ISO 15.2.14.4.4
+  def each(&block)
+    return to_enum :each unless block
+
+    val = self.first
+    last = self.last
+
+    if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special
+      lim = last
+      lim += 1 unless exclude_end?
+      i = val
+      while i < lim
+        block.call(i)
+        i += 1
+      end
+      return self
+    end
+
+    if val.kind_of?(String) && last.kind_of?(String) # fixnums are special
+      if val.respond_to? :upto
+        return val.upto(last, exclude_end?, &block)
+      else
+        str_each = true
+      end
+    end
+
+    raise TypeError, "can't iterate" unless val.respond_to? :succ
+
+    return self if (val <=> last) > 0
+
+    while (val <=> last) < 0
+      block.call(val)
+      val = val.succ
+      if str_each
+        break if val.size > last.size
+      end
+    end
+
+    block.call(val) if !exclude_end? && (val <=> last) == 0
+    self
+  end
+
+  # redefine #hash 15.3.1.3.15
+  def hash
+    h = first.hash ^ last.hash
+    h += 1 if self.exclude_end?
+    h
+  end
+end
+
+##
+# Range is enumerable
+#
+# ISO 15.2.14.3
+class Range
+  include Enumerable
+end

data/resources/mruby/mrblib/string.rb

@@ -0,0 +1,275 @@
+##
+# String
+#
+# ISO 15.2.10
+class String
+  include Comparable
+  ##
+  # Calls the given block for each line
+  # and pass the respective line.
+  #
+  # ISO 15.2.10.5.15
+  def each_line(rs = "\n", &block)
+    return to_enum(:each_line, rs, &block) unless block
+    return block.call(self) if rs.nil?
+    rs = rs.to_str
+    offset = 0
+    rs_len = rs.length
+    this = dup
+    while pos = this.index(rs, offset)
+      block.call(this[offset, pos + rs_len - offset])
+      offset = pos + rs_len
+    end
+    block.call(this[offset, this.size - offset]) if this.size > offset
+    self
+  end
+
+  # private method for gsub/sub
+  def __sub_replace(pre, m, post)
+    s = ""
+    i = 0
+    while j = index("\\", i)
+      break if j == length-1
+      t = case self[j+1]
+          when "\\"
+            "\\"
+          when "`"
+            pre
+          when "&", "0"
+            m
+          when "'"
+            post
+          when "1", "2", "3", "4", "5", "6", "7", "8", "9"
+            ""
+          else
+            self[j, 2]
+          end
+      s += self[i, j-i] + t
+      i = j + 2
+    end
+    s + self[i, length-i]
+  end
+
+  ##
+  # Replace all matches of +pattern+ with +replacement+.
+  # Call block (if given) for each match and replace
+  # +pattern+ with the value of the block. Return the
+  # final value.
+  #
+  # ISO 15.2.10.5.18
+  def gsub(*args, &block)
+    return to_enum(:gsub, *args) if args.length == 1 && !block
+    raise ArgumentError, "wrong number of arguments" unless (1..2).include?(args.length)
+
+    pattern, replace = *args
+    plen = pattern.length
+    if args.length == 2 && block
+      block = nil
+    end
+    if !replace.nil? || !block
+      replace = replace.to_str
+    end
+    offset = 0
+    result = []
+    while found = index(pattern, offset)
+      result << self[offset, found - offset]
+      offset = found + plen
+      result << if block
+        block.call(pattern).to_s
+      else
+        replace.__sub_replace(self[0, found], pattern, self[offset..-1] || "")
+      end
+      if plen == 0
+        result << self[offset, 1]
+        offset += 1
+      end
+    end
+    result << self[offset..-1] if offset < length
+    result.join
+  end
+
+  ##
+  # Replace all matches of +pattern+ with +replacement+.
+  # Call block (if given) for each match and replace
+  # +pattern+ with the value of the block. Modify
+  # +self+ with the final value.
+  #
+  # ISO 15.2.10.5.19
+  def gsub!(*args, &block)
+    raise FrozenError, "can't modify frozen String" if frozen?
+    return to_enum(:gsub!, *args) if args.length == 1 && !block
+    str = self.gsub(*args, &block)
+    return nil if str == self
+    self.replace(str)
+  end
+
+  ##
+  # Calls the given block for each match of +pattern+
+  # If no block is given return an array with all
+  # matches of +pattern+.
+  #
+  # ISO 15.2.10.5.32
+  def scan(reg, &block)
+    ### *** TODO *** ###
+    unless Object.const_defined?(:Regexp)
+      raise NotImplementedError, "scan not available (yet)"
+    end
+  end
+
+  ##
+  # Replace only the first match of +pattern+ with
+  # +replacement+. Call block (if given) for each
+  # match and replace +pattern+ with the value of the
+  # block. Return the final value.
+  #
+  # ISO 15.2.10.5.36
+  def sub(*args, &block)
+    unless (1..2).include?(args.length)
+      raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 2)"
+    end
+
+    pattern, replace = *args
+    pattern = pattern.to_str
+    if args.length == 2 && block
+      block = nil
+    end
+    unless block
+      replace = replace.to_str
+    end
+    result = []
+    this = dup
+    found = index(pattern)
+    return this unless found
+    result << this[0, found]
+    offset = found + pattern.length
+    result << if block
+      block.call(pattern).to_s
+    else
+      replace.__sub_replace(this[0, found], pattern, this[offset..-1] || "")
+    end
+    result << this[offset..-1] if offset < length
+    result.join
+  end
+
+  ##
+  # Replace only the first match of +pattern+ with
+  # +replacement+. Call block (if given) for each
+  # match and replace +pattern+ with the value of the
+  # block. Modify +self+ with the final value.
+  #
+  # ISO 15.2.10.5.37
+  def sub!(*args, &block)
+    raise FrozenError, "can't modify frozen String" if frozen?
+    str = self.sub(*args, &block)
+    return nil if str == self
+    self.replace(str)
+  end
+
+  ##
+  # Call the given block for each character of
+  # +self+.
+  def each_char(&block)
+    pos = 0
+    while pos < self.size
+      block.call(self[pos])
+      pos += 1
+    end
+    self
+  end
+
+  ##
+  # Call the given block for each byte of +self+.
+  def each_byte(&block)
+    bytes = self.bytes
+    pos = 0
+    while pos < bytes.size
+      block.call(bytes[pos])
+      pos += 1
+    end
+    self
+  end
+
+  ##
+  # Modify +self+ by replacing the content of +self+.
+  # The portion of the string affected is determined using the same criteria as +String#[]+.
+  def []=(*args)
+    anum = args.size
+    if anum == 2
+      pos, value = args
+      case pos
+      when String
+        posnum = self.index(pos)
+        if posnum
+          b = self[0, posnum.to_i]
+          a = self[(posnum + pos.length)..-1]
+          self.replace([b, value, a].join(''))
+        else
+          raise IndexError, "string not matched"
+        end
+      when Range
+        head = pos.begin
+        tail = pos.end
+        tail += self.length if tail < 0
+        unless pos.exclude_end?
+          tail += 1
+        end
+        return self[head, tail-head]=value
+      else
+        pos += self.length if pos < 0
+        if pos < 0 || pos > self.length
+          raise IndexError, "index #{args[0]} out of string"
+        end
+        b = self[0, pos.to_i]
+        a = self[pos + 1..-1]
+        self.replace([b, value, a].join(''))
+      end
+      return value
+    elsif anum == 3
+      pos, len, value = args
+      pos += self.length if pos < 0
+      if pos < 0 || pos > self.length
+        raise IndexError, "index #{args[0]} out of string"
+      end
+      if len < 0
+        raise IndexError, "negative length #{len}"
+      end
+      b = self[0, pos.to_i]
+      a = self[pos + len..-1]
+      self.replace([b, value, a].join(''))
+      return value
+    else
+      raise ArgumentError, "wrong number of arguments (#{anum} for 2..3)"
+    end
+  end
+
+  ##
+  # ISO 15.2.10.5.3
+  def =~(re)
+    raise TypeError, "type mismatch: String given" if re.respond_to? :to_str
+    re =~ self
+  end
+
+  ##
+  # ISO 15.2.10.5.27
+  def match(re, &block)
+    if re.respond_to? :to_str
+      if Object.const_defined?(:Regexp)
+        r = Regexp.new(re)
+        r.match(self, &block)
+      else
+        raise NotImplementedError, "String#match needs Regexp class"
+      end
+    else
+      re.match(self, &block)
+    end
+  end
+end
+
+##
+# String is comparable
+#
+# ISO 15.2.10.3
+module Comparable; end
+class String
+  include Comparable
+end