esruby 0.0.0

data/resources/mruby/benchmark/bm_fib.rb

@@ -0,0 +1,7 @@
+
+def fib n
+  return n if n < 2
+  fib(n-2) + fib(n-1)
+end
+
+puts fib(37)

data/resources/mruby/benchmark/bm_so_lists.rb

@@ -0,0 +1,47 @@
+#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+
+NUM = 300
+SIZE = 10000
+
+def test_lists()
+  # create a list of integers (Li1) from 1 to SIZE
+  li1 = (1..SIZE).to_a
+  # copy the list to li2 (not by individual items)
+  li2 = li1.dup
+  # remove each individual item from left side of li2 and
+  # append to right side of li3 (preserving order)
+  li3 = Array.new
+  while (not li2.empty?)
+    li3.push(li2.shift)
+  end
+  # li2 must now be empty
+  # remove each individual item from right side of li3 and
+  # append to right side of li2 (reversing list)
+  until li3.empty?
+    li2.push(li3.pop)
+  end
+  # li3 must now be empty
+  # reverse li1 in place
+  li1.reverse!
+  # check that first item is now SIZE
+  if li1[0] != SIZE
+    p "not SIZE"
+    0
+  else
+    # compare li1 and li2 for equality
+    if li1 != li2
+      return(0)
+    else
+      # return the length of the list
+      li1.length
+    end
+  end
+end
+
+i = 0
+while i<NUM
+  i += 1
+  result = test_lists()
+end
+
+result

data/resources/mruby/benchmark/build_config_boxing.rb

@@ -0,0 +1,28 @@
+MRuby::Build.new do |conf|
+  toolchain :gcc
+end
+
+MRuby::Build.new('no_boxing') do |conf|
+  toolchain :gcc
+
+  conf.gembox 'default'
+end
+
+MRuby::Build.new('word_boxing') do |conf|
+  toolchain :gcc
+
+  conf.gembox 'default'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_WORD_BOXING)
+  end
+end
+
+MRuby::Build.new('nan_boxing') do |conf|
+  toolchain :gcc
+
+  conf.gembox 'default'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_NAN_BOXING)
+  end
+end
+

data/resources/mruby/benchmark/build_config_cc.rb

@@ -0,0 +1,13 @@
+MRuby::Build.new do |conf|
+  toolchain :gcc
+end
+
+MRuby::Build.new('gcc') do |conf|
+  toolchain :gcc
+  conf.gembox 'default'
+end
+
+MRuby::Build.new('clang') do |conf|
+  toolchain :clang
+  conf.gembox 'default'
+end

data/resources/mruby/benchmark/plot.gpl

@@ -0,0 +1,5 @@
+set yrange [0:]
+set terminal pngcairo font 'Sans, 8' lw 1 size 1400,1024
+set xtics rotate by -45
+set style histogram errorbars gap 2 lw 1
+set style fill solid border -1

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/README.md

@@ -0,0 +1,82 @@
+mruby-regexp-pcre
+=================
+
+"mruby-regexp-pcre" is a regular expression module for mruby, based on
+[PCRE](http://pcre.org).
+It provides Regexp and MatchData classes.
+
+
+## Requirements
+
+none (libpcre is bundled).
+
+
+## Example
+
+```Ruby
+line = "#hoge"
+/^#.*/ =~ line
+
+csv = "a, b, c"
+csv.split /,\s*/
+
+kvs = "key: value"
+m = /(\w+)\s*:\s*(\w*)/.match(kvs)
+key, value = m[1], m[2]
+```
+
+## Difference between PCRE and MRI Regexp
+|    | MRI (CRuby) | PCRE |
+|:---|:------------|:-----|
+| \h | A hexdigit character (`[0-9a-fA-F]`) | a horizontal white space character
+
+
+## Test
+If you have mruby source code and imported mruby-regexp-pcre as an mrbgem,
+just run "rake test" to execute test scripts in ``test`` directory:
+```
+% cd mruby
+% rake test
+```
+
+Or run ``run_test.rb`` to check out mruby source code into a temporary directory,
+and run tests on it:
+```
+% cd mruby-regexp-pcre
+% ruby run_test.rb test
+% rm -rf tmp
+```
+
+## Alternatives
+If mruby-regexp-pcre does not meet your requirements, try mruby-onig-regexp.
+It consumes much more memory but has better compatibility with MRI.
+
+- https://github.com/mattn/mruby-onig-regexp (Onigumo/Oniguruma)
+
+Other alternatives:
+
+- https://github.com/mattn/mruby-pcre-regexp (PCRE)
+- https://github.com/masamitsu-murase/mruby-hs-regexp (Henry Spencer's)
+
+
+## License
+
+Copyright (c) 2013 Internet Initiative Japan Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the "Software"), 
+to deal in the Software without restriction, including without limitation 
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrbgem.rake

@@ -0,0 +1,63 @@
+MRuby::Gem::Specification.new('mruby-regexp-pcre') do |spec|
+  spec.license = 'MIT'
+  spec.authors = 'Internet Initiative Japan Inc.'
+
+  spec.add_dependency 'mruby-string-ext', :core => 'mruby-string-ext'
+
+  ## For dynamic link
+  #spec.linker.libraries << ['pcre']
+
+  ## For static link library
+  # How to use:
+  #  * download pcre library
+  #    $ pwd
+  #    $(mruby.rootdir)/mrbgems/mruby-regexp-pcre
+  #    $ wget http://xxxxx/xxxxx/pcre-X.XX.tar.gz
+  #
+  #  * unpack, setup path
+  #    $ tar zxf pcre-X.XX.tar.gz
+  #    $ mv pcre-X.XX pcre
+  #    $ vim ./mrbgem.rake
+  #    (edit pcre_dirname variable)
+  #
+  #  * move the mruby root dir, make
+  #    $ cd $(mruby.rootdir)
+  #    $ make
+
+  pcre_dirname = 'pcre'
+  pcre_src = "#{spec.dir}/#{pcre_dirname}"
+  spec.cc.include_paths << "#{pcre_src}"
+  spec.cc.flags << '-DHAVE_CONFIG_H'
+  spec.cc.flags << '-DPCRE_STATIC' if /mingw|mswin/ =~ RUBY_PLATFORM
+
+  spec.objs += %W(
+    #{pcre_src}/pcre_byte_order.c
+    #{pcre_src}/pcre_compile.c
+    #{pcre_src}/pcre_config.c
+    #{pcre_src}/pcre_dfa_exec.c
+    #{pcre_src}/pcre_exec.c
+    #{pcre_src}/pcre_fullinfo.c
+    #{pcre_src}/pcre_get.c
+    #{pcre_src}/pcre_globals.c
+    #{pcre_src}/pcre_jit_compile.c
+    #{pcre_src}/pcre_maketables.c
+    #{pcre_src}/pcre_newline.c
+    #{pcre_src}/pcre_ord2utf8.c
+    #{pcre_src}/pcre_refcount.c
+    #{pcre_src}/pcre_string_utils.c
+    #{pcre_src}/pcre_study.c
+    #{pcre_src}/pcre_tables.c
+    #{pcre_src}/pcre_ucd.c
+    #{pcre_src}/pcre_valid_utf8.c
+    #{pcre_src}/pcre_version.c
+    #{pcre_src}/pcre_xclass.c
+    #{pcre_src}/pcre_chartables.c
+  ).map { |f| f.relative_path_from(dir).pathmap("#{build_dir}/%X#{spec.exts.object}" ) }
+
+  desc "generate configuration files for mruby-regexp-pcre"
+  task :regexp_pcre_config do
+    FileUtils.cp "#{pcre_src}/config.h.generic", "#{pcre_src}/config.h"
+    FileUtils.cp "#{pcre_src}/pcre.h.generic", "#{pcre_src}/pcre.h"
+    FileUtils.cp "#{pcre_src}/pcre_chartables.c.dist", "#{pcre_src}/pcre_chartables.c"
+  end
+end

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrblib/regexp_pcre.rb

@@ -0,0 +1,232 @@
+class Regexp
+  attr_reader :options
+  attr_reader :source
+  attr_reader :last_match
+
+  def self.quote(str)
+    self.escape(str)
+  end
+
+  def self.compile(*args)
+    self.new(*args)
+  end
+
+  def self.last_match
+    @last_match
+  end
+
+  def =~(str)
+    return nil unless str
+
+    m = self.match(str)
+    if m
+      m.begin(0)
+    else
+      nil
+    end
+  end
+
+  def ===(str)
+    unless str.is_a? String
+      if str.is_a? Symbol
+        str = str.to_s
+      else
+        return false
+      end
+    end
+    self.match(str) != nil
+  end
+
+  def casefold?
+    (@options & IGNORECASE) > 0
+  end
+
+  def to_s
+    s = "(?"
+    s += get_enable_option_string
+
+    if @options & MULTILINE == 0 or @options & IGNORECASE == 0 or @options & EXTENDED == 0
+      s += "-"
+      s += get_disable_option_string
+    end
+
+    s += ":"
+    s += @source
+    s += ")"
+    s
+  end
+
+  def inspect
+    s = "/"
+    s += @source
+    s += "/"
+    s += get_enable_option_string
+    s
+  end
+
+  def get_enable_option_string
+    s = ""
+    s += "m" if @options & MULTILINE > 0
+    s += "i" if @options & IGNORECASE > 0
+    s += "x" if @options & EXTENDED > 0
+    s
+  end
+
+  def get_disable_option_string
+    s = ""
+    s += "m" if @options & MULTILINE == 0
+    s += "i" if @options & IGNORECASE == 0
+    s += "x" if @options & EXTENDED == 0
+    s
+  end
+
+  def self.escape(str)
+    escape_table = {
+      "\ " => '\\ ', # '?\ ' is a space
+      "["  => '\\[',
+      "]"  => '\\]', 
+      "{"  => '\\{', 
+      "}"  => '\\}', 
+      "("  => '\\(', 
+      ")"  => '\\)', 
+      "|"  => '\\|', 
+      "-"  => '\\-', 
+      "*"  => '\\*', 
+      "."  => '\\.', 
+      "\\" => '\\\\',
+      "?"  => '\\?', 
+      "+"  => '\\+', 
+      "^"  => '\\^', 
+      "$"  => '\\$', 
+      "#"  => '\\#', 
+      "\n" => '\\n', 
+      "\r" => '\\r', 
+      "\f" => '\\f', 
+      "\t" => '\\t', 
+      "\v" => '\\v', 
+    }
+
+    s = ""
+    str.each_char do |c|
+      if escape_table[c]
+        s += escape_table[c]
+      else
+        s += c
+      end
+    end
+    s
+  end
+
+  def named_captures
+    h = {}
+    if @names
+      @names.each do |k, v|
+        h[k.to_s] = [v + 1]
+      end
+    end
+    h
+  end
+
+  def names
+    if @names
+      ar = Array.new(@names.size)
+      @names.each do |k, v|
+        ar[v] = k.to_s
+      end
+      ar
+    else
+      []
+    end
+  end
+
+  # private
+  def name_push(name, index)
+    @names ||= {}
+    @names[name.to_sym] = index - 1
+  end
+end
+
+class MatchData
+  attr_reader :regexp
+  attr_reader :string
+
+  def [](n)
+    if n.kind_of?(String) || n.kind_of?(Symbol)
+      indexes = regexp.named_captures[n.to_s]
+      if indexes
+        self[indexes.last]
+      else
+        nil
+      end
+    elsif n.respond_to?(:to_i)
+      # XXX: if n is_a? Range
+      # XXX: when we have 2nd argument...
+      n = n.to_i
+      if n < 0
+        n += self.length
+        return nil if n < 0
+      elsif n >= self.length
+        return nil
+      end
+      b = self.begin(n)
+      e = self.end(n)
+      if b and e
+        @string[b, e-b]
+      else
+        nil
+      end
+    else
+      raise TypeError.new("No implicit converstion of #{n.class} into integer")
+    end
+  end
+
+  def captures
+    self.to_a[1, self.length-1]
+  end
+
+  def inspect
+    if self.length == 1
+      "#<MatchData \"#{self[0]}\">"
+    else
+      idx = 0 
+      capts = self.captures.map! { |s| "#{idx += 1}:#{s.inspect}" }.join(' ')
+      "#<MatchData \"#{self[0]}\" #{capts}>"
+    end 
+  end
+
+  def names
+    self.regexp.names
+  end
+
+  def offset(n)
+    [self.begin(n), self.end(n)]
+  end
+
+  def post_match
+    @string[self.end(0), @string.length]
+  end
+
+  def pre_match
+    @string[0, self.begin(0)]
+  end
+
+  def push(start = nil, finish = nil)
+    @data.push({start: start, finish: finish})
+  end
+
+  def to_a
+    a = []
+    self.length.times { |i| a << self[i] }
+    a
+  end
+
+  def to_s
+    self[0]
+  end
+
+  def values_at(*args)
+    args.map { |i| if i == -self.length then nil else self[i] end }
+  end
+
+  alias size length
+end