esruby 0.0.0 → 0.0.2

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/run_test.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-#
-# mrbgems test runner
-#
-
-if __FILE__ == $0
-  repository, dir = 'https://github.com/mruby/mruby.git', 'tmp/mruby'
-  build_args = ARGV
-
-  Dir.mkdir 'tmp'  unless File.exist?('tmp')
-  unless File.exist?(dir)
-    system "git clone #{repository} #{dir}"
-  end
-
-  exit system(%Q[cd #{dir}; MRUBY_CONFIG=#{File.expand_path __FILE__} ruby minirake #{build_args.join(' ')}])
-end
-
-MRuby::Build.new do |conf|
-  toolchain :gcc
-  conf.gembox 'default'
-
-  conf.gem File.expand_path(File.dirname(__FILE__))
-end

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/src/mruby_regexp_pcre.c

@@ -1,364 +0,0 @@
-#include <mruby.h>
-#include <mruby/class.h>
-#include <mruby/array.h>
-#include <mruby/string.h>
-#include <mruby/data.h>
-#include <mruby/variable.h>
-
-#include <stdio.h>
-#include <string.h>
-#include <pcre.h>
-
-#define MRUBY_REGEXP_IGNORECASE         0x01
-#define MRUBY_REGEXP_EXTENDED           0x02
-#define MRUBY_REGEXP_MULTILINE          0x04
-
-struct mrb_regexp_pcre {
-  pcre *re;
-};
-
-struct mrb_matchdata {
-  mrb_int length;
-  int *ovector;
-};
-
-void
-mrb_regexp_free(mrb_state *mrb, void *ptr)
-{
-  struct mrb_regexp_pcre *mrb_re = ptr;
-
-  if (mrb_re != NULL) {
-    if (mrb_re->re != NULL) {
-      pcre_free(mrb_re->re);
-    }
-    mrb_free(mrb, mrb_re);
-  }
-}
-
-static void
-mrb_matchdata_free(mrb_state *mrb, void *ptr)
-{
-  struct mrb_matchdata *mrb_md = ptr;
-
-  if (mrb_md != NULL) {
-    if (mrb_md->ovector != NULL) {
-      mrb_free(mrb, mrb_md->ovector);
-    }
-    mrb_free(mrb, mrb_md);
-  }
-}
-
-static struct mrb_data_type mrb_regexp_type = { "Regexp", mrb_regexp_free };
-static struct mrb_data_type mrb_matchdata_type = { "MatchData", mrb_matchdata_free };
-
-
-static int
-mrb_mruby_to_pcre_options(mrb_value options)
-{
-  int coptions = PCRE_DOTALL;
-
-  if (mrb_nil_p(options)) {
-    coptions = 0;
-  } else if (mrb_fixnum_p(options)) {
-    int nopt;
-    nopt = mrb_fixnum(options);
-    if (nopt & MRUBY_REGEXP_IGNORECASE) coptions |= PCRE_CASELESS;
-    if (nopt & MRUBY_REGEXP_EXTENDED)   coptions |= PCRE_EXTENDED;
-    if (nopt & MRUBY_REGEXP_MULTILINE)  coptions |= PCRE_MULTILINE;
-  } else if (mrb_string_p(options)) {
-    if (strchr(RSTRING_PTR(options), 'i')) coptions |= PCRE_CASELESS;
-    if (strchr(RSTRING_PTR(options), 'x')) coptions |= PCRE_EXTENDED;
-    if (strchr(RSTRING_PTR(options), 'm')) coptions |= PCRE_MULTILINE;
-  } else if (mrb_type(options) == MRB_TT_TRUE) {
-    coptions |= PCRE_CASELESS;
-  }
-
-  return coptions;
-}
-
-static int
-mrb_pcre_to_mruby_options(int coptions)
-{
-  int options = 0;
-
-  if (coptions & PCRE_CASELESS)  options |= MRUBY_REGEXP_IGNORECASE;
-  if (coptions & PCRE_EXTENDED)  options |= MRUBY_REGEXP_EXTENDED;
-  if (coptions & PCRE_MULTILINE) options |= MRUBY_REGEXP_MULTILINE;
-
-  return options;
-}
-
-mrb_value
-regexp_pcre_initialize(mrb_state *mrb, mrb_value self)
-{
-  int erroff = 0, coptions;
-  const char *errstr = NULL;
-  struct mrb_regexp_pcre *reg = NULL;
-  mrb_value source, opt = mrb_nil_value();
-  unsigned char *name_table, *tabptr;
-  int i, namecount, name_entry_size;
-
-  reg = (struct mrb_regexp_pcre *)DATA_PTR(self);
-  if (reg) {
-    mrb_regexp_free(mrb, reg);
-  }
-  DATA_TYPE(self) = &mrb_regexp_type;
-  DATA_PTR(self) = NULL;
-
-  mrb_get_args(mrb, "S|o", &source, &opt);
-
-  reg = mrb_malloc(mrb, sizeof(struct mrb_regexp_pcre));
-  reg->re = NULL;
-  DATA_PTR(self) = reg;
-
-  coptions = mrb_mruby_to_pcre_options(opt);
-  source = mrb_str_new(mrb, RSTRING_PTR(source), RSTRING_LEN(source));
-  reg->re = pcre_compile(RSTRING_PTR(source), coptions, &errstr, &erroff, NULL);
-  if (reg->re == NULL) {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid regular expression");
-  }
-  mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@source"), source);
-  mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@options"), mrb_fixnum_value(mrb_pcre_to_mruby_options(coptions)));
-
-  pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMECOUNT, &namecount);
-  if (namecount > 0) {
-    pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMETABLE, &name_table);
-    pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size);
-    tabptr = name_table;
-    for (i = 0; i < namecount; i++) {
-      int n = (tabptr[0] << 8) | tabptr[1];
-      mrb_funcall(mrb, self, "name_push", 2, mrb_str_new(mrb, (const char *)(tabptr + 2), strlen((const char *)tabptr + 2)), mrb_fixnum_value(n));
-      tabptr += name_entry_size;
-    }
-  } 
-
-  return self;
-}
-
-mrb_value
-regexp_pcre_match(mrb_state *mrb, mrb_value self)
-{
-  struct mrb_matchdata *mrb_md;
-  int rc;
-  int ccount, matchlen;
-  int *match;
-  struct RClass *c;
-  mrb_value md, str;
-  mrb_int i, pos;
-  pcre_extra extra;
-  struct mrb_regexp_pcre *reg;
-
-  reg = (struct mrb_regexp_pcre *)mrb_get_datatype(mrb, self, &mrb_regexp_type);
-  if (!reg)
-    return mrb_nil_value();
-
-  pos = 0;
-  mrb_get_args(mrb, "S|i", &str, &pos);
-
-  // XXX: RSTRING_LEN(str) >= pos ...
-
-  rc = pcre_fullinfo(reg->re, NULL, PCRE_INFO_CAPTURECOUNT, &ccount);
-  if (rc < 0) {
-    /* fullinfo error */
-    return mrb_nil_value();
-  }
-  matchlen = ccount + 1;
-  match = mrb_malloc(mrb, sizeof(int) * matchlen * 3);
-
-  extra.flags = PCRE_EXTRA_MATCH_LIMIT_RECURSION;
-  extra.match_limit_recursion = 1000;
-  rc = pcre_exec(reg->re, &extra, RSTRING_PTR(str), RSTRING_LEN(str), pos, 0, match, matchlen * 3);
-  if (rc < 0) {
-    mrb_free(mrb, match);
-    return mrb_nil_value();
-  }
-
-  /* XXX: need current scope */
-  mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), mrb_nil_value());
-
-  c = mrb_class_get(mrb, "MatchData");
-  md = mrb_funcall(mrb, mrb_obj_value(c), "new", 0);
-
-  mrb_md = (struct mrb_matchdata *)mrb_get_datatype(mrb, md, &mrb_matchdata_type);
-  mrb_md->ovector = match;
-  mrb_md->length = matchlen;
-
-  mrb_iv_set(mrb, md, mrb_intern_lit(mrb, "@regexp"), self);
-  mrb_iv_set(mrb, md, mrb_intern_lit(mrb, "@string"), mrb_str_dup(mrb, str));
-  /* XXX: need current scope */
-  mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), md);
-
-  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$~"), md);
-  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$&"), mrb_funcall(mrb, md, "to_s", 0));
-  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$`"), mrb_funcall(mrb, md, "pre_match", 0));
-  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$'"), mrb_funcall(mrb, md, "post_match", 0));
-
-  for (i = 1; i < 10; i++) {
-    char sym[8];
-    snprintf(sym, sizeof(sym), "$%d", i);
-    mrb_gv_set(mrb, mrb_intern_cstr(mrb, sym), mrb_funcall(mrb, md, "[]", 1, mrb_fixnum_value(i)));
-  }
-
-  return md;
-}
-
-static mrb_value
-regexp_equal(mrb_state *mrb, mrb_value self)
-{
-  mrb_value other;
-  struct mrb_regexp_pcre *self_reg, *other_reg;
-
-  mrb_get_args(mrb, "o", &other);
-  if (mrb_obj_equal(mrb, self, other)) {
-    return mrb_true_value();
-  }
-
-  if (mrb_type(other) != MRB_TT_DATA || DATA_TYPE(other) != &mrb_regexp_type) {
-    return mrb_false_value();
-  }
-
-  self_reg = (struct mrb_regexp_pcre *)DATA_PTR(self);
-  other_reg = (struct mrb_regexp_pcre *)DATA_PTR(other);
-  if (!self_reg || !other_reg) {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid Regexp");
-  }
-
-  if (mrb_str_equal(mrb, mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@source")),
-                         mrb_iv_get(mrb, other, mrb_intern_lit(mrb, "@source")))) {
-    return mrb_true_value();
-  }
-
-  return mrb_false_value();
-}
-
-mrb_value
-mrb_matchdata_init(mrb_state *mrb, mrb_value self)
-{
-  struct mrb_matchdata *mrb_md;
-
-  mrb_md = (struct mrb_matchdata *)DATA_PTR(self);
-  if (mrb_md) {
-    mrb_matchdata_free(mrb, mrb_md);
-  }
-  DATA_TYPE(self) = &mrb_matchdata_type;
-  DATA_PTR(self) = NULL;
-
-  mrb_md = (struct mrb_matchdata *)mrb_malloc(mrb, sizeof(*mrb_md));
-  mrb_md->ovector = NULL;
-  mrb_md->length = -1;
-  DATA_PTR(self) = mrb_md;
-
-  return self;
-}
-
-mrb_value
-mrb_matchdata_init_copy(mrb_state *mrb, mrb_value copy)
-{
-  mrb_value src;
-  struct mrb_matchdata *mrb_md_copy, *mrb_md_src;
-  int vecsize;
-
-  mrb_get_args(mrb, "o", &src);
-
-  if (mrb_obj_equal(mrb, copy, src)) return copy;
-  if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
-    mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
-  }
-
-  mrb_md_copy = (struct mrb_matchdata *)mrb_malloc(mrb, sizeof(*mrb_md_copy));
-  mrb_md_src  = DATA_PTR(src);
-
-  if (mrb_md_src->ovector == NULL) {
-    mrb_md_copy->ovector = NULL;
-    mrb_md_copy->length = -1;
-  } else {
-    vecsize = sizeof(int) * mrb_md_src->length * 3;
-    mrb_md_copy->ovector = mrb_malloc(mrb, vecsize);
-    memcpy(mrb_md_copy->ovector, mrb_md_src->ovector, vecsize);
-    mrb_md_copy->length = mrb_md_src->length;
-  }
-
-  if (DATA_PTR(copy) != NULL) {
-    mrb_matchdata_free(mrb, DATA_PTR(copy));
-  }
-  DATA_PTR(copy) = mrb_md_copy;
-
-  mrb_iv_set(mrb, copy, mrb_intern_lit(mrb, "@regexp"), mrb_iv_get(mrb, src, mrb_intern_lit(mrb, "@regexp")));
-  mrb_iv_set(mrb, copy, mrb_intern_lit(mrb, "@string"), mrb_iv_get(mrb, src, mrb_intern_lit(mrb, "@string")));
-
-  return copy;
-}
-
-static mrb_value
-matchdata_beginend(mrb_state *mrb, mrb_value self, int beginend)
-{
-  struct mrb_matchdata *mrb_md;
-  mrb_int i, offs;
-
-  mrb_md = (struct mrb_matchdata *)mrb_get_datatype(mrb, self, &mrb_matchdata_type);
-  if (!mrb_md) return mrb_nil_value();
-
-  mrb_get_args(mrb, "i", &i);
-  if (i < 0 || i >= mrb_md->length)
-    mrb_raisef(mrb, E_INDEX_ERROR, "index %d out of matches", i);
-
-  offs = mrb_md->ovector[i*2 + beginend];
-  if (offs != -1)
-    return mrb_fixnum_value(offs);
-  else
-    return mrb_nil_value();
-}
-
-mrb_value
-mrb_matchdata_begin(mrb_state *mrb, mrb_value self)
-{
-  return matchdata_beginend(mrb, self, 0);
-}
-
-mrb_value
-mrb_matchdata_end(mrb_state *mrb, mrb_value self)
-{
-  return matchdata_beginend(mrb, self, 1);
-}
-
-mrb_value
-mrb_matchdata_length(mrb_state *mrb, mrb_value self)
-{
-  struct mrb_matchdata *mrb_md;
-
-  mrb_md = (struct mrb_matchdata *)mrb_get_datatype(mrb, self, &mrb_matchdata_type);
-  if (!mrb_md) return mrb_nil_value();
-
-  return mrb_fixnum_value(mrb_md->length);
-}
-
-void
-mrb_mruby_regexp_pcre_gem_init(mrb_state *mrb)
-{
-  struct RClass *re, *md;
-
-  re = mrb_define_class(mrb, "Regexp", mrb->object_class);
-  MRB_SET_INSTANCE_TT(re, MRB_TT_DATA);
-
-  mrb_define_method(mrb, re, "initialize", regexp_pcre_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
-  mrb_define_method(mrb, re, "match", regexp_pcre_match, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, re, "==", regexp_equal, MRB_ARGS_REQ(1));
-
-  mrb_define_const(mrb, re, "IGNORECASE", mrb_fixnum_value(MRUBY_REGEXP_IGNORECASE));
-  mrb_define_const(mrb, re, "EXTENDED", mrb_fixnum_value(MRUBY_REGEXP_EXTENDED));
-  mrb_define_const(mrb, re, "MULTILINE", mrb_fixnum_value(MRUBY_REGEXP_MULTILINE));
-
-  md = mrb_define_class(mrb, "MatchData", mrb->object_class);
-  MRB_SET_INSTANCE_TT(md, MRB_TT_DATA);
-
-  mrb_define_method(mrb, md, "initialize", mrb_matchdata_init, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, md, "initialize_copy", mrb_matchdata_init_copy, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, md, "begin", mrb_matchdata_begin, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, md, "end", mrb_matchdata_end, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, md, "length", mrb_matchdata_length, MRB_ARGS_NONE());
-}
-
-void
-mrb_mruby_regexp_pcre_gem_final(mrb_state *mrb)
-{
-}

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/test/matchdata.rb

@@ -1,94 +0,0 @@
-assert('MatchData', '15.2.16.2') do
-  MatchData.class == Class and
-  MatchData.superclass == Object
-end
-
-assert('MatchData#[]', '15.2.16.3.1') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m[0] == "foobar" and m[1] == "foo" and m[2] == "bar" and m[3] == nil and
-  m[4] == nil and m[-2] == "bar"
-end
-
-# named captures
-assert('MatchData#[]') do
-  m = /(?<test>a)(b)(?:c)(?<test2>d)/.match('abcd')
-  assert_equal 'a', m['test']
-  assert_equal 'd', m[:test2]
-end
-
-assert('MatchData#begin', '15.2.16.3.2') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.begin(0) == 0 and m.begin(1) == 0 and m.begin(2) == 3 and m.begin(3) == nil
-end
-
-assert('MatchData#captures', '15.2.16.3.3') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.captures == ["foo", "bar", nil]
-end
-
-assert('MatchData#end', '15.2.16.3.4') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.end(0) == 6 and m.end(1) == 3 and m.end(2) == 6 and m.end(3) == nil
-end
-
-assert('MatchData#initialize_copy', '15.2.16.3.5') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  n = /a/.match("a").initialize_copy(m)
-  m.to_a == n.to_a and m.regexp == n.regexp and m.string == n.string
-end
-
-assert('MatchData#length', '15.2.16.3.6') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.length == 4
-end
-
-assert('MatchData#offset', '15.2.16.3.7') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.offset(1) == [0, 3] and m.offset(2) == [3, 6] and m.offset(3) == [nil, nil]
-end
-
-assert('MatchData#post_match', '15.2.16.3.8') do
-  m = /(bar)(BAZ)?/.match("foobarbaz")
-  m.post_match == "baz"
-end
-
-assert('MatchData#pre_match', '15.2.16.3.9') do
-  m = /(bar)(BAZ)?/.match("foobarbaz")
-  m.pre_match == "foo"
-end
-
-assert('MatchData#size', '15.2.16.3.10') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.size == m.length
-end
-
-assert('MatchData#string', '15.2.16.3.11') do
-  m = /b/.match("abc", 1)
-  m.string == "abc"
-end
-
-assert('MatchData#to_a', '15.2.16.3.12') do
-  m = /(foo)(bar)(BAZ)?/.match("foobarbaz")
-  m.to_a == ["foobar", "foo", "bar", nil]
-end
-
-assert('MatchData#to_a', '15.2.16.3.13') do
-  m = /bar/.match("foobarbaz")
-  m.to_s == "bar"
-end
-
-assert('MatchData#names') do
-  m = /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge")
-  m.names == ["foo", "bar", "baz"]
-end
-
-assert('MatchData#regexp') do
-  m = /a.*b/.match("abc")
-  m.regexp == /a.*b/
-end
-
-assert('MatchData#values_at') do
-  m = /(foo)(bar)(baz)/.match("foobarbaz")
-  m.values_at(0, 1, 2, 3, 4) == ["foobarbaz", "foo", "bar", "baz", nil] and
-  m.values_at(-1, -2, -3, -4, -5) == ["baz", "bar", "foo", nil, nil]
-end