Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 9e7ca5d944
Fetching contributors…

Cannot retrieve contributors at this time

2607 lines (2321 sloc) 71.615 kb
/*
** re.c - Regexp class
**
** See Copyright Notice in mruby.h
*/
#include "mruby.h"
#include <string.h>
#include "mruby/string.h"
#include "encoding.h"
#include "re.h"
#include "mruby/array.h"
#include "regint.h"
#include "mruby/class.h"
#include "error.h"
#ifdef ENABLE_REGEXP
#define REGEX_CLASS (mrb_class_obj_get(mrb, "Regexp"))
#define MATCH_CLASS (mrb_class_obj_get(mrb, "MatchData"))
//from opcode.h
#define GETARG_A(i) ((((mrb_code)(i)) >> 24) & 0xff)
#define GETARG_B(i) ((((mrb_code)(i)) >> 16) & 0xff)
#define GETARG_C(i) ((((mrb_code)(i)) >> 8) & 0xff)
#define MKARG_A(c) (((c) & 0xff) << 24)
#define MKARG_B(c) (((c) & 0xff) << 16)
#define MKARG_C(c) (((c) & 0xff) << 8)
#define ARG_REG_OPTION_MASK \
(ONIG_OPTION_IGNORECASE|ONIG_OPTION_MULTILINE|ONIG_OPTION_EXTEND)
#define ARG_ENCODING_FIXED 16
#define ARG_ENCODING_NONE 32
#define REG_LITERAL FL_USER5
#define REG_ENCODING_NONE FL_USER6
typedef char onig_errmsg_buffer[ONIG_MAX_ERROR_MESSAGE_LEN];
#define mrb_bug printf
#define KCODE_FIXED FL_USER4
#define scan_oct(s,l,e) (int)ruby_scan_oct(s,l,e)
unsigned long ruby_scan_oct(const char*, size_t, size_t*);
#define scan_hex(s,l,e) (int)ruby_scan_hex(s,l,e)
unsigned long ruby_scan_hex(const char*, size_t, size_t*);
static mrb_value mrb_match_to_a(mrb_state *mrb, mrb_value match);
static mrb_value mrb_reg_preprocess(mrb_state *mrb, const char *p, const char *end, onig_errmsg_buffer err);
static void mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len);
static char * option_to_str(char str[4], int options);
//static int may_need_recompile;
//static int reg_kcode = DEFAULT_KCODE;
/* ------------------------------------------------------------------------- */
/* RegExp Class */
/* ------------------------------------------------------------------------- */
/* 15.2.15.6.1 */
/*
* call-seq:
* class.new(args, ...) -> obj
*
* Calls <code>allocate</code> to create a new object of
* <i>class</i>'s class, then invokes that object's
* <code>initialize</code> method, passing it <i>args</i>.
* This is the method that ends up getting called whenever
* an object is constructed using .new.
*
*/
mrb_value
mrb_reg_s_new_instance(mrb_state *mrb, /*int argc, mrb_value *argv, */mrb_value self)
{
mrb_value argv[16];
int argc;
struct RRegexp *re;
mrb_get_args(mrb, "*", &argv, &argc);
re = (struct RRegexp*)mrb_obj_alloc(mrb, MRB_TT_REGEX, REGEX_CLASS);
re->ptr = 0;
re->src = 0;
re->usecnt = 0;
return mrb_funcall_argv(mrb, mrb_obj_value(re), mrb->init_sym, argc, argv);
}
mrb_value
mrb_reg_quote(mrb_state *mrb, mrb_value str)
{
char *s, *send, *t;
mrb_value tmp;
int c;
s = RSTRING_PTR(str);
send = s + RSTRING_LEN(str);
while (s < send) {
c = *s;
if (c == -1) {
s += send - s;
continue;
}
switch (c) {
case '[': case ']': case '{': case '}':
case '(': case ')': case '|': case '-':
case '*': case '.': case '\\':
case '?': case '+': case '^': case '$':
case ' ': case '#':
case '\t': case '\f': case '\n': case '\r':
goto meta_found;
}
s++;
}
tmp = mrb_str_new(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
return tmp;
meta_found:
tmp = mrb_str_new(mrb, 0, RSTRING_LEN(str)*2);
t = RSTRING_PTR(tmp);
/* copy upto metacharacter */
memcpy(t, RSTRING_PTR(str), s - RSTRING_PTR(str));
t += s - RSTRING_PTR(str);
while (s < send) {
c = *s;
if (c == -1) {
int n = send - s;
while (n--)
*t++ = *s++;
continue;
}
s++;
switch (c) {
case '[': case ']': case '{': case '}':
case '(': case ')': case '|': case '-':
case '*': case '.': case '\\':
case '?': case '+': case '^': case '$':
case '#':
t += mrb_enc_mbcput('\\', t, enc);
break;
case ' ':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput(' ', t, enc);
continue;
case '\t':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput('t', t, enc);
continue;
case '\n':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput('n', t, enc);
continue;
case '\r':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput('r', t, enc);
continue;
case '\f':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput('f', t, enc);
continue;
case '\v':
t += mrb_enc_mbcput('\\', t, enc);
t += mrb_enc_mbcput('v', t, enc);
continue;
}
t += mrb_enc_mbcput(c, t, enc);
}
mrb_str_resize(mrb, tmp, t - RSTRING_PTR(tmp));
return tmp;
}
static mrb_value
reg_operand(mrb_state *mrb, mrb_value s, int check)
{
if (mrb_type(s) == MRB_TT_SYMBOL) {
//return mrb_sym_to_s(s);
return mrb_obj_inspect(mrb, s);
}
else {
mrb_value tmp = mrb_check_string_type(mrb, s);
if (check && mrb_nil_p(tmp)) {
mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s to String",
mrb_obj_classname(mrb, s));
}
return tmp;
}
}
/* 15.2.15.6.2 */
/* 15.2.15.6.4 */
/*
* call-seq:
* Regexp.escape(str) -> string
* Regexp.quote(str) -> string
*
* Escapes any characters that would have special meaning in a regular
* expression. Returns a new escaped string, or self if no characters are
* escaped. For any string,
* <code>Regexp.new(Regexp.escape(<i>str</i>))=~<i>str</i></code> will be true.
*
* Regexp.escape('\*?{}.') #=> \\\*\?\{\}\.
*
*/
static mrb_value
mrb_reg_s_quote(mrb_state *mrb, mrb_value c/*, mrb_value str*/)
{
mrb_value str;
mrb_get_args(mrb, "o", &str);
return mrb_reg_quote(mrb, reg_operand(mrb, str, 1/*TRUE*/));
}
static void
match_check(mrb_state *mrb, mrb_value match)
{
struct RMatch *m = mrb_match_ptr(match);
if (!m->str) {
mrb_raise(mrb, E_TYPE_ERROR, "uninitialized Match");
}
}
mrb_value
mrb_reg_nth_match(mrb_state *mrb, mrb_int nth, mrb_value match)
{
mrb_value str;
long start, end, len;
struct RMatch *m = mrb_match_ptr(match);
if (mrb_nil_p(match)) return mrb_nil_value();
match_check(mrb, match);
if (nth >= m->rmatch->regs.num_regs) {
return mrb_nil_value();
}
if (nth < 0) {
nth += m->rmatch->regs.num_regs;
if (nth <= 0) return mrb_nil_value();
}
start = m->rmatch->regs.beg[nth];
if (start == -1) return mrb_nil_value();
end = m->rmatch->regs.end[nth];
len = end - start;
str = mrb_str_subseq(mrb, mrb_obj_value(m->str), start, len);
return str;
}
mrb_value
mrb_reg_last_match(mrb_state *mrb, mrb_value match)
{
return mrb_reg_nth_match(mrb, 0, match);
}
static int
match_backref_number(mrb_state *mrb, mrb_value match, mrb_value backref)
{
const char *name;
int num;
struct re_registers *regs = RMATCH_REGS(match);
struct RRegexp *regexp = RMATCH(match)->regexp;
match_check(mrb, match);
switch(mrb_type(backref)) {
default:
return mrb_fixnum(backref);
case MRB_TT_SYMBOL:
name = mrb_sym2name(mrb, SYM2ID(backref));
break;
case MRB_TT_STRING:
//name = StringValueCStr(backref);
name = mrb_string_value_cstr(mrb, &backref);
break;
}
num = onig_name_to_backref_number(regexp->ptr,
(const unsigned char*)name,
(const unsigned char*)name + strlen(name),
regs);
if (num < 1) {
mrb_raise(mrb, E_INDEX_ERROR, "undefined group name reference: %s", name);
}
return num;
}
/* 15.2.15.6.3 */
/*
* call-seq:
* Regexp.last_match -> matchdata
* Regexp.last_match(n) -> str
*
* The first form returns the <code>MatchData</code> object generated by the
* last successful pattern match. Equivalent to reading the global variable
* <code>$~</code>. The second form returns the <i>n</i>th field in this
* <code>MatchData</code> object.
* <em>n</em> can be a string or symbol to reference a named capture.
*
* Note that the <code>last_match</code> is local to the thread and method scope
* of the method that did the pattern match.
*
* /c(.)t/ =~ 'cat' #=> 0
* Regexp.last_match #=> #<MatchData "cat" 1:"a">
* Regexp.last_match(0) #=> "cat"
* Regexp.last_match(1) #=> "a"
* Regexp.last_match(2) #=> nil
*
* /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ "var = val"
* Regexp.last_match #=> #<MatchData "var = val" lhs:"var" rhs:"val">
* Regexp.last_match(:lhs) #=> "var"
* Regexp.last_match(:rhs) #=> "val"
*/
static mrb_value
mrb_reg_s_last_match(mrb_state *mrb, mrb_value self/*int argc, mrb_value *argv*/)
{
//mrb_value nth;
mrb_value argv[16];
int argc;
mrb_value match = mrb_backref_get(mrb);
//if (argc > 0 && mrb_scan_args(argc, argv, "01", &nth) == 1) {
mrb_get_args(mrb, "*", &argv, &argc);
if (argc != 0) {
int n;
if (mrb_nil_p(match)) return mrb_nil_value();
n = match_backref_number(mrb, match, argv[0]);
return mrb_reg_nth_match(mrb, n, match);
}
return match;//match_getter();
}
static void
mrb_reg_check(mrb_state *mrb, mrb_value re)
{
//struct RRegexp *r = mrb_regex_ptr(re);
//if (!(RREGEXP(re)->ptr) || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) {
if (!(RREGEXP(re)->ptr)) {
mrb_raise(mrb, E_TYPE_ERROR, "uninitialized Regexp");
}
if (RREGEXP(re)->src == 0) {
mrb_raise(mrb, E_TYPE_ERROR, "uninitialized Regexp");
}
}
int
mrb_reg_options(mrb_state *mrb, mrb_value re)
{
int options;
mrb_reg_check(mrb, re);
options = RREGEXP(re)->ptr->options & ARG_REG_OPTION_MASK;
if (RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
if (RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
return options;
}
static mrb_value
mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re)
{
mrb_value str = mrb_str_new(mrb, "/", 1);
mrb_reg_expr_str(mrb, str, s, len);
mrb_str_buf_cat(mrb, str, "/", 1);
if (re.tt) {
char opts[4];
mrb_reg_check(mrb, re);
if (*option_to_str(opts, RREGEXP(re)->ptr->options))
mrb_str_buf_cat(mrb, str, opts, strlen(opts));//mrb_str_buf_cat2(str, opts);
if (RBASIC(re)->flags & REG_ENCODING_NONE)
mrb_str_buf_cat(mrb, str, "n", 1);
}
return str;
}
static void
mrb_reg_raise(mrb_state *mrb, const char *s, long len, const char *err, mrb_value re)
{
mrb_value desc = mrb_reg_desc(mrb, s, len, re);
mrb_raise(mrb, E_REGEXP_ERROR, "%s: %s", err, RSTRING_PTR(desc));
}
regex_t *
mrb_reg_prepare_re(mrb_state *mrb, mrb_value re, mrb_value str)
{
regex_t *reg = RREGEXP(re)->ptr;
onig_errmsg_buffer err = "";
int r;
OnigErrorInfo einfo;
const char *pattern;
mrb_value unescaped;
mrb_encoding *enc = mrb_ascii8bit_encoding(mrb);
mrb_reg_check(mrb, re);
reg = RREGEXP(re)->ptr;
pattern = RREGEXP_SRC_PTR(re);
unescaped = mrb_reg_preprocess(mrb,
pattern, pattern + RREGEXP(re)->src->len, err);
if (mrb_nil_p(unescaped)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "regexp preprocess failed: %s", err);
}
r = onig_new(&reg, (UChar* )RSTRING_PTR(unescaped),
(UChar* )(RSTRING_PTR(unescaped) + RSTRING_LEN(unescaped)),
reg->options, enc,
OnigDefaultSyntax, &einfo);
if (r) {
onig_error_code_to_str((UChar*)err, r, &einfo);
mrb_reg_raise(mrb, pattern, RREGEXP_SRC_LEN(re), err, re);
}
//RB_GC_GUARD(unescaped);
return reg;
}
mrb_int
mrb_reg_search(mrb_state *mrb, mrb_value re, mrb_value str, mrb_int pos, mrb_int reverse)
{
long result;
mrb_value match;
struct re_registers regi, *regs = &regi;
char *range = RSTRING_PTR(str);
regex_t *reg;
int tmpreg;
if (pos > RSTRING_LEN(str) || pos < 0) {
mrb_backref_set(mrb, mrb_nil_value());
return -1;
}
reg = mrb_reg_prepare_re(mrb, re, str);
tmpreg = reg != RREGEXP(re)->ptr;
if (!tmpreg) RREGEXP(re)->usecnt++;
match = mrb_backref_get(mrb);
if (!mrb_nil_p(match)) {
/*if (FL_TEST(match, MATCH_BUSY)) {
match = Qnil;
}
else {
regs = RMATCH_REGS(match);
}*/
regs = RMATCH_REGS(match);
}
if (mrb_nil_p(match)) {
memset(regs, 0, sizeof(struct re_registers));
}
//-->
if (!reverse) {
range += RSTRING_LEN(str);
}
result = onig_search(reg,
(UChar*)(RSTRING_PTR(str)),
((UChar*)(RSTRING_PTR(str)) + RSTRING_LEN(str)),
((UChar*)(RSTRING_PTR(str)) + pos),
((UChar*)range),
regs, ONIG_OPTION_NONE);
if (!tmpreg) RREGEXP(re)->usecnt--;
if (tmpreg) {
if (RREGEXP(re)->usecnt) {
onig_free(reg);
}
else {
onig_free(RREGEXP(re)->ptr);
RREGEXP(re)->ptr = reg;
}
}
if (result < 0) {
if (regs == &regi)
onig_region_free(regs, 0);
if (result == ONIG_MISMATCH) {
mrb_backref_set(mrb, mrb_nil_value());
return result;
}
else {
onig_errmsg_buffer err = "";
onig_error_code_to_str((UChar*)err, (int)result);
mrb_reg_raise(mrb, RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), err, re);
}
}
//--<
if (mrb_nil_p(match) ) {
match = match_alloc(mrb);
onig_region_copy(RMATCH_REGS(match), regs);
onig_region_free(regs, 0);
}
RMATCH(match)->str = mrb_str_ptr(str);
RMATCH(match)->regexp = mrb_regex_ptr(re);
RMATCH(match)->rmatch->char_offset_updated = 0;
mrb_backref_set(mrb, match);
return result;
}
mrb_int
mrb_reg_adjust_startpos(mrb_state *mrb, mrb_value re, mrb_value str, mrb_int pos, mrb_int reverse)
{
mrb_int range;
struct RString *s = mrb_str_ptr(str);
struct RRegexp *r = mrb_regex_ptr(re);
mrb_reg_check(mrb, re);
/*if (may_need_recompile) mrb_reg_prepare_re(re);*/
/* if (FL_TEST(re, KCODE_FIXED))
mrb_kcode_set_option(re);
else if (reg_kcode != curr_kcode)
mrb_kcode_reset_option(); */
if (reverse) {
range = -pos;
}
else {
range = s->len - pos;
}
return re_adjust_startpos(r->ptr,
s->buf, s->len,
pos, range);
}
static int
onig_new_with_source(regex_t** reg, const UChar* pattern, const UChar* pattern_end,
OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax,
OnigErrorInfo* einfo, const char *sourcefile, int sourceline)
{
int r;
*reg = (regex_t* )malloc/*xmalloc*/(sizeof(regex_t));
if ((void*)(*reg) == (void*)0) return ONIGERR_MEMORY;
r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
if (r) goto err;
r = onig_compile(*reg, pattern, pattern_end, einfo, sourcefile, sourceline);
if (r) {
err:
onig_free(*reg);
*reg = 0/*NULL*/;
}
return r;
}
static Regexp*
make_regexp(const char *s, long len, mrb_encoding *enc, int flags, onig_errmsg_buffer err,
const char *sourcefile, int sourceline)
{
Regexp *rp;
int r;
OnigErrorInfo einfo;
/* Handle escaped characters first. */
/* Build a copy of the string (in dest) with the
escaped characters translated, and generate the regex
from that.
*/
r = onig_new_with_source(&rp, (UChar*)s, (UChar*)(s + len), flags,
enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline);
if (r) {
onig_error_code_to_str((UChar*)err, r, &einfo);
return 0;
}
return rp;
}
unsigned long
ruby_scan_hex(const char *start, size_t len, size_t *retlen)
{
static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
register const char *s = start;
register unsigned long retval = 0;
const char *tmp;
while (len-- && *s && (tmp = strchr(hexdigit, *s))) {
retval <<= 4;
retval |= (tmp - hexdigit) & 15;
s++;
}
*retlen = (int)(s - start); /* less than len */
return retval;
}
#define BYTEWIDTH 8
int
mrb_uv_to_utf8(mrb_state *mrb, char buf[6], unsigned long uv)
{
if (uv <= 0x7f) {
buf[0] = (char)uv;
return 1;
}
if (uv <= 0x7ff) {
buf[0] = (char)((uv>>6)&0xff)|0xc0;
buf[1] = (char)(uv&0x3f)|0x80;
return 2;
}
if (uv <= 0xffff) {
buf[0] = (char)((uv>>12)&0xff)|0xe0;
buf[1] = (char)((uv>>6)&0x3f)|0x80;
buf[2] = (char)(uv&0x3f)|0x80;
return 3;
}
if (uv <= 0x1fffff) {
buf[0] = (char)((uv>>18)&0xff)|0xf0;
buf[1] = (char)((uv>>12)&0x3f)|0x80;
buf[2] = (char)((uv>>6)&0x3f)|0x80;
buf[3] = (char)(uv&0x3f)|0x80;
return 4;
}
if (uv <= 0x3ffffff) {
buf[0] = (char)((uv>>24)&0xff)|0xf8;
buf[1] = (char)((uv>>18)&0x3f)|0x80;
buf[2] = (char)((uv>>12)&0x3f)|0x80;
buf[3] = (char)((uv>>6)&0x3f)|0x80;
buf[4] = (char)(uv&0x3f)|0x80;
return 5;
}
if (uv <= 0x7fffffff) {
buf[0] = (char)((uv>>30)&0xff)|0xfc;
buf[1] = (char)((uv>>24)&0x3f)|0x80;
buf[2] = (char)((uv>>18)&0x3f)|0x80;
buf[3] = (char)((uv>>12)&0x3f)|0x80;
buf[4] = (char)((uv>>6)&0x3f)|0x80;
buf[5] = (char)(uv&0x3f)|0x80;
return 6;
}
mrb_raise(mrb, E_RANGE_ERROR, "pack(U): value out of range");
return 0;
}
unsigned long
ruby_scan_oct(const char *start, size_t len, size_t *retlen)
{
register const char *s = start;
register unsigned long retval = 0;
while (len-- && *s >= '0' && *s <= '7') {
retval <<= 3;
retval |= *s++ - '0';
}
*retlen = (int)(s - start); /* less than len */
return retval;
}
static mrb_value
mrb_reg_preprocess(mrb_state *mrb, const char *p, const char *end, onig_errmsg_buffer err)
{
return mrb_nil_value();
}
static int
mrb_reg_initialize(mrb_state *mrb, mrb_value obj, const char *s, long len,
int options, onig_errmsg_buffer err,
const char *sourcefile, int sourceline)
{
struct RRegexp *re = RREGEXP(obj);
mrb_value unescaped;
mrb_encoding *enc = mrb_ascii8bit_encoding(mrb);
if (re->ptr)
mrb_raise(mrb, E_TYPE_ERROR, "already initialized regexp");
re->ptr = 0;
unescaped = mrb_reg_preprocess(mrb, s, s+len, err);
if (mrb_nil_p(unescaped))
return -1;
if ((options & ARG_ENCODING_FIXED)) {
//re->basic.flags |= KCODE_FIXED;
re->flags|= KCODE_FIXED;
}
if (options & ARG_ENCODING_NONE) {
re->flags |= REG_ENCODING_NONE;
}
re->ptr = make_regexp(RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
options & ARG_REG_OPTION_MASK, err,
sourcefile, sourceline);
if (!re->ptr) return -1;
re->src = mrb_str_ptr(mrb_str_new(mrb, s, len));
return 0;
}
static int
mrb_reg_initialize_str(mrb_state *mrb, mrb_value obj, mrb_value str, int options, onig_errmsg_buffer err,
const char *sourcefile, int sourceline)
{
int ret;
#if 0
if (options & ARG_ENCODING_NONE) {
mrb_encoding *ascii8bit = mrb_ascii8bit_encoding(mrb);
if (enc != ascii8bit) {
if (mrb_enc_str_coderange(mrb, str) != ENC_CODERANGE_7BIT) {
//errcpy(err, "/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
printf("/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
return -1;
}
enc = ascii8bit;
}
}
#endif
ret = mrb_reg_initialize(mrb, obj, RSTRING_PTR(str), RSTRING_LEN(str),
options, err, sourcefile, sourceline);
return ret;
}
/* 15.2.15.7.1 */
/*
* call-seq:
* Regexp.initialize(string, [options [, lang]]) -> regexp
* Regexp.initialize(regexp) -> regexp
*
* Constructs a new regular expression from <i>pattern</i>, which can be either
* a <code>String</code> or a <code>Regexp</code> (in which case that regexp's
* options are propagated, and new options may not be specified (a change as of
* Ruby 1.8). If <i>options</i> is a <code>Fixnum</code>, it should be one or
* more of the constants <code>Regexp::EXTENDED</code>,
* <code>Regexp::IGNORECASE</code>, and <code>Regexp::MULTILINE</code>,
* <em>or</em>-ed together. Otherwise, if <i>options</i> is not
* <code>nil</code>, the regexp will be case insensitive.
* When the <i>lang</i> parameter is `n' or `N' sets the regexp no encoding.
*
* r1 = Regexp.initialize('^a-z+:\\s+\w+') #=> /^a-z+:\s+\w+/
* r2 = Regexp.initialize('cat', true) #=> /cat/i
* r3 = Regexp.initialize('dog', Regexp::EXTENDED) #=> /dog/x
* r4 = Regexp.initialize(r2) #=> /cat/i
*/
static mrb_value
mrb_reg_initialize_m(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value self)
{
mrb_value argv[16];
int argc;
onig_errmsg_buffer err = "";
int flags = 0;
mrb_value str;
const char *ptr;
long len;
mrb_get_args(mrb, "*", &argv, &argc);
if (argc == 0 || argc > 3) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1..3)", argc);
}
if (mrb_type(argv[0]) == MRB_TT_REGEX) {
mrb_value re = argv[0];
if (argc > 1) {
/* mrb_warn("flags ignored"); */
printf("flags ignored");
}
mrb_reg_check(mrb, re);
flags = mrb_reg_options(mrb, re);
ptr = RREGEXP_SRC_PTR(re);
len = RREGEXP_SRC_LEN(re);
if (mrb_reg_initialize(mrb, self, ptr, len, flags, err, NULL, 0)) {
printf("mrb_reg_raise_str(str, flags, err);");
}
}
else {
if (argc >= 2) {
if (mrb_type(argv[1]) == MRB_TT_FIXNUM) flags = mrb_fixnum(argv[1]);
else if (mrb_test(argv[1])) flags = ONIG_OPTION_IGNORECASE;
}
if (argc == 3 && !mrb_nil_p(argv[2])) {
//char *kcode = StringValuePtr(argv[2]);
char *kcode = mrb_string_value_ptr(mrb, argv[2]);
if (kcode[0] == 'n' || kcode[0] == 'N') {
flags |= ARG_ENCODING_NONE;
}
else {
/*mrb_warn("encoding option is ignored - %s", kcode); */
printf("mrb_warn:encoding option is ignored - %s", kcode);
}
}
str = argv[0];
//ptr = StringValuePtr(str);
ptr = mrb_string_value_ptr(mrb, str);
if (mrb_reg_initialize_str(mrb, self, str, flags, err, NULL, 0)) {
//mrb_reg_raise_str(str, flags, err);
}
}
return self;
}
/* 15.2.15.7.2 */
/* :nodoc: */
static mrb_value
mrb_reg_init_copy(mrb_state *mrb, mrb_value re/*, mrb_value copy*/)
{
mrb_value argv[16];
int argc;
onig_errmsg_buffer err = "";
const char *s;
long len;
mrb_value copy;
mrb_get_args(mrb, "*", &argv, &argc);
copy = argv[0];
if (mrb_obj_equal(mrb, copy, re)) return copy;
/*mrb_check_frozen(copy);*/
/* need better argument type check */
if (!mrb_obj_is_instance_of(mrb, re, mrb_obj_class(mrb, copy))) {
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument type");
}
mrb_reg_check(mrb, copy);
s = RREGEXP_SRC_PTR(copy);
len = RREGEXP_SRC_LEN(copy);
if (mrb_reg_initialize(mrb, re, s, len, mrb_reg_options(mrb, copy),
err, 0/*NULL*/, 0) != 0) {
mrb_reg_raise(mrb, s, len, err, re);
}
return re;
}
static int
reg_equal(mrb_state *mrb, struct RRegexp *re1, struct RRegexp *re2)
{
if (re1->ptr->options != re2->ptr->options) return FALSE;
if (!mrb_equal(mrb, mrb_obj_value(re1->src), mrb_obj_value(re2->src)))
return FALSE;
return TRUE;
}
static int
mrb_reg_equal(mrb_state *mrb, mrb_value re1, mrb_value re2)
{
if (mrb_obj_equal(mrb, re1, re2)) return TRUE;
if (mrb_type(re2) != MRB_TT_REGEX) return FALSE;
mrb_reg_check(mrb, re1);
mrb_reg_check(mrb, re2);
return reg_equal(mrb, RREGEXP(re1), RREGEXP(re2));
}
/* 15.2.15.7.3 */
/*
* call-seq:
* rxp == other_rxp -> true or false
* rxp.eql?(other_rxp) -> true or false
*
* Equality---Two regexps are equal if their patterns are identical, they have
* the same character set code, and their <code>casefold?</code> values are the
* same.
*
* /abc/ == /abc/x #=> false
* /abc/ == /abc/i #=> false
* /abc/ == /abc/n #=> false
* /abc/u == /abc/n #=> false
*/
static mrb_value
mrb_reg_equal_m(mrb_state *mrb, mrb_value re1/*, mrb_value re2*/)
{
mrb_value re2;
mrb_get_args(mrb, "o", &re2);
if (mrb_reg_equal(mrb, re1, re2))
return mrb_true_value();
return mrb_false_value();
}
/* 15.2.15.7.4 */
/*
* call-seq:
* rxp === str -> true or false
*
* Case Equality---Synonym for <code>Regexp#=~</code> used in case statements.
*
* a = "HELLO"
* case a
* when /^[a-z]*$/; print "Lower case\n"
* when /^[A-Z]*$/; print "Upper case\n"
* else; print "Mixed case\n"
* end
*
* <em>produces:</em>
*
* Upper case
*/
mrb_value
mrb_reg_eqq(mrb_state *mrb, mrb_value re/*, mrb_value str*/)
{
long start;
mrb_value str;
mrb_get_args(mrb, "o", &str);
str = reg_operand(mrb, str, 0/*FALSE*/);
if (mrb_nil_p(str)) {
mrb_backref_set(mrb, mrb_nil_value());
return mrb_false_value();
}
start = mrb_reg_search(mrb, re, str, 0, 0);
if (start < 0) {
return mrb_false_value();
}
return mrb_true_value();
}
static long
reg_match_pos(mrb_state *mrb, mrb_value re, mrb_value *strp, long pos)
{
mrb_value str = *strp;
if (mrb_nil_p(str)) {
mrb_backref_set(mrb, mrb_nil_value());
return -1;
}
*strp = str = reg_operand(mrb, str, 1/*TRUE*/);
if (pos != 0) {
if (pos < 0) {
mrb_value l = mrb_str_size(mrb, str);
pos += mrb_fixnum(l);
if (pos < 0) {
return pos;
}
}
pos = mrb_str_offset(mrb, str, pos);
}
return mrb_reg_search(mrb, re, str, pos, 0);
}
mrb_value
mrb_reg_match_str(mrb_state *mrb, mrb_value re, mrb_value str)
{
mrb_int pos = reg_match_pos(mrb, re, &str, 0);
if (pos < 0) return mrb_nil_value();
pos = mrb_str_sublen(mrb, str, pos);
return mrb_fixnum_value(pos);
}
/* 15.2.15.7.5 */
/*
* call-seq:
* rxp =~ str -> integer or nil
*
* Match---Matches <i>rxp</i> against <i>str</i>.
*
* /at/ =~ "input data" #=> 7
* /ax/ =~ "input data" #=> nil
*
* If <code>=~</code> is used with a regexp literal with named captures,
* captured strings (or nil) is assigned to local variables named by
* the capture names.
*
* /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ " x = y "
* p lhs #=> "x"
* p rhs #=> "y"
*
* If it is not matched, nil is assigned for the variables.
*
* /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ " x = "
* p lhs #=> nil
* p rhs #=> nil
*
* This assignment is implemented in the Ruby parser.
* The parser detects 'regexp-literal =~ expression' for the assignment.
* The regexp must be a literal without interpolation and placed at left hand side.
*
* The assignment is not occur if the regexp is not a literal.
*
* re = /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/
* re =~ " x = y "
* p lhs # undefined local variable
* p rhs # undefined local variable
*
* A regexp interpolation, <code>#{}</code>, also disables
* the assignment.
*
* rhs_pat = /(?<rhs>\w+)/
* /(?<lhs>\w+)\s*=\s*#{rhs_pat}/ =~ "x = y"
* p lhs # undefined local variable
*
* The assignment is not occur if the regexp is placed at right hand side.
*
* " x = y " =~ /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/
* p lhs, rhs # undefined local variable
*
*/
mrb_value
mrb_reg_match(mrb_state *mrb, mrb_value re/*, mrb_value str*/)
{
mrb_value str;
mrb_get_args(mrb, "o", &str);
return mrb_reg_match_str(mrb, re, str);
}
/* 15.2.15.7.6 */
/*
* call-seq:
* rxp.casefold? -> true or false
*
* Returns the value of the case-insensitive flag.
*
* /a/.casefold? #=> false
* /a/i.casefold? #=> true
* /(?i:a)/.casefold? #=> false
*/
static mrb_value
mrb_reg_casefold_p(mrb_state *mrb, mrb_value re)
{
mrb_reg_check(mrb, re);
if (RREGEXP(re)->ptr->options & ONIG_OPTION_IGNORECASE) return mrb_true_value();
return mrb_false_value();
}
/* 15.2.15.7.7 */
/*
* call-seq:
* rxp.match(str) -> matchdata or nil
* rxp.match(str,pos) -> matchdata or nil
*
* Returns a <code>MatchData</code> object describing the match, or
* <code>nil</code> if there was no match. This is equivalent to retrieving the
* value of the special variable <code>$~</code> following a normal match.
* If the second parameter is present, it specifies the position in the string
* to begin the search.
*
* /(.)(.)(.)/.match("abc")[2] #=> "b"
* /(.)(.)/.match("abc", 1)[2] #=> "c"
*
* If a block is given, invoke the block with MatchData if match succeed, so
* that you can write
*
* pat.match(str) {|m| ...}
*
* instead of
*
* if m = pat.match(str)
* ...
* end
*
* The return value is a value from block execution in this case.
*/
static mrb_value
mrb_reg_match_m(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value re)
{
mrb_value argv[16];
int argc;
mrb_value result, str, initpos, b;
long pos;
//if (mrb_scan_args(argc, argv, "11", &str, &initpos) == 2) {
mrb_get_args(mrb, "*&", &argv, &argc, &b);
if (argc == 2) {
initpos = argv[1];
pos = mrb_fixnum(initpos);
}
else {
pos = 0;
}
str = argv[0];
pos = reg_match_pos(mrb, re, &str, pos);
if (pos < 0) {
mrb_backref_set(mrb, mrb_nil_value());
return mrb_nil_value();
}
result = mrb_backref_get(mrb);
/*mrb_match_busy(result);*/
if (!mrb_nil_p(result) && mrb_block_given_p()) {
return mrb_yield(mrb, result, b);
}
return result;
}
/* 15.2.15.7.8 */
/*
* call-seq:
* rxp.source -> str
*
* Returns the original string of the pattern.
*
* /ab+c/ix.source #=> "ab+c"
*
* Note that escape sequences are retained as is.
*
* /\x20\+/.source #=> "\\x20\\+"
*
*/
static mrb_value
mrb_reg_source(mrb_state *mrb, mrb_value re)
{
mrb_value str;
mrb_reg_check(mrb, re);
str = mrb_str_new(mrb, RREGEXP_SRC_PTR(re),RREGEXP_SRC_LEN(re));
return str;
}
static int
name_to_backref_number(mrb_state *mrb, struct re_registers *regs, struct RRegexp*regexp, const char* name, const char* name_end)
{
int num;
num = onig_name_to_backref_number(regexp->ptr,
(const unsigned char* )name, (const unsigned char* )name_end, regs);
if (num >= 1) {
return num;
}
else {
mrb_value s = mrb_str_new(mrb, name, (long )(name_end - name));//mrb_str_new(name, (long )(name_end - name));
mrb_raise(mrb, E_INDEX_ERROR, "undefined group name reference: %s",
mrb_string_value_ptr(mrb, s));
return num; /* not reach */
}
}
/*
* Document-class: MatchData
*
* <code>MatchData</code> is the type of the special variable <code>$~</code>,
* and is the type of the object returned by <code>Regexp#match</code> and
* <code>Regexp.last_match</code>. It encapsulates all the results of a pattern
* match, results normally accessed through the special variables
* <code>$&</code>, <code>$'</code>, <code>$`</code>, <code>$1</code>,
* <code>$2</code>, and so on.
*
*/
mrb_value
match_alloc(mrb_state *mrb)
{
struct RMatch* m;
m = (struct RMatch*)mrb_obj_alloc(mrb, MRB_TT_MATCH, MATCH_CLASS);
m->str = 0;
m->rmatch = 0;
m->regexp = 0;
m->rmatch = mrb_malloc(mrb, sizeof(struct rmatch));//ALLOC(struct rmatch);
memset(m->rmatch, 0, sizeof(struct rmatch));
return mrb_obj_value(m);
}
/* ------------------------------------------------------------------------- */
/* MatchData Class */
/* ------------------------------------------------------------------------- */
/* 15.2.16.3.1 */
/*
* call-seq:
* mtch[i] -> str or nil
* mtch[start, length] -> array
* mtch[range] -> array
* mtch[name] -> str or nil
*
* Match Reference---<code>MatchData</code> acts as an array, and may be
* accessed using the normal array indexing techniques. <i>mtch</i>[0] is
* equivalent to the special variable <code>$&</code>, and returns the entire
* matched string. <i>mtch</i>[1], <i>mtch</i>[2], and so on return the values
* of the matched backreferences (portions of the pattern between parentheses).
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m #=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
* m[0] #=> "HX1138"
* m[1, 2] #=> ["H", "X"]
* m[1..3] #=> ["H", "X", "113"]
* m[-3, 2] #=> ["X", "113"]
*
* m = /(?<foo>a+)b/.match("ccaaab")
* m #=> #<MatchData "aaab" foo:"aaa">
* m["foo"] #=> "aaa"
* m[:foo] #=> "aaa"
*/
static mrb_value
mrb_match_aref(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value match)
{
mrb_value argv[16];
int argc;
mrb_value idx;
match_check(mrb, match);
//mrb_scan_args(argc, argv, "11", &idx, &rest);
mrb_get_args(mrb, "*", &argv, &argc);
idx = argv[0];
if (argc<2) {
if (mrb_type(idx) == MRB_TT_FIXNUM) {
if (mrb_fixnum(idx) >= 0) {
return mrb_reg_nth_match(mrb, mrb_fixnum(idx), match);
}
}
else {
const char *p;
int num;
switch (mrb_type(idx)) {
case MRB_TT_SYMBOL:
//p = mrb_id2name(SYM2ID(idx));
p = mrb_sym2name(mrb, SYM2ID(idx));
goto name_to_backref;
break;
case MRB_TT_STRING:
//p = StringValuePtr(idx);
p = mrb_string_value_ptr(mrb, idx);
name_to_backref:
num = name_to_backref_number(mrb, RMATCH_REGS(match),
RMATCH(match)->regexp, p, p + strlen(p));
return mrb_reg_nth_match(mrb, num, match);
break;
default:
break;
}
}
}
return mrb_ary_aget(mrb, /*argc, argv,*/ mrb_match_to_a(mrb, match));
}
typedef struct {
long byte_pos;
long char_pos;
} pair_t;
static void
update_char_offset(mrb_state *mrb, mrb_value match)
{
struct rmatch *rm = RMATCH(match)->rmatch;
struct re_registers *regs;
int i, num_regs;
if (rm->char_offset_updated)
return;
regs = &rm->regs;
num_regs = rm->regs.num_regs;
if (rm->char_offset_num_allocated < num_regs) {
//REALLOC_N(rm->char_offset, struct rmatch_offset, num_regs);
rm->char_offset = mrb_realloc(mrb, rm->char_offset, sizeof(struct rmatch_offset)*num_regs);
rm->char_offset_num_allocated = num_regs;
}
for (i = 0; i < num_regs; i++) {
rm->char_offset[i].beg = BEG(i);
rm->char_offset[i].end = END(i);
}
rm->char_offset_updated = 1;
return;
}
/* 15.2.16.3.2 */
/*
* call-seq:
* mtch.begin(n) -> integer
*
* Returns the offset of the start of the <em>n</em>th element of the match
* array in the string.
* <em>n</em> can be a string or symbol to reference a named capture.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.begin(0) #=> 1
* m.begin(2) #=> 2
*
* m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
* p m.begin(:foo) #=> 0
* p m.begin(:bar) #=> 2
*/
static mrb_value
mrb_match_begin(mrb_state *mrb, mrb_value match/*, mrb_value n*/)
{
mrb_value argv[16];
int argc;
mrb_value n = argv[0];
int i;
struct re_registers *regs;
match_check(mrb, match);
mrb_get_args(mrb, "*", &argv, &argc);
n = argv[0];
i = match_backref_number(mrb, match, n);
regs = RMATCH_REGS(match);
if (i < 0 || regs->num_regs <= i)
mrb_raise(mrb, E_INDEX_ERROR, "index %d out of matches", i);
if (BEG(i) < 0)
return mrb_nil_value();
update_char_offset(mrb, match);
return mrb_fixnum_value(RMATCH(match)->rmatch->char_offset[i].beg);
}
static mrb_value
match_array(mrb_state *mrb, mrb_value match, int start)
{
struct re_registers *regs;
mrb_value ary;
struct RString *target;
int i;
match_check(mrb, match);
regs = RMATCH_REGS(match);
ary = mrb_ary_new_capa(mrb, regs->num_regs);//mrb_ary_new2(regs->num_regs);
target = RMATCH(match)->str;
for (i=start; i<regs->num_regs; i++) {
if (regs->beg[i] == -1) {
mrb_ary_push(mrb, ary, mrb_nil_value());
}
else {
mrb_value str = mrb_str_subseq(mrb, mrb_obj_value(target), regs->beg[i], regs->end[i]-regs->beg[i]);
mrb_ary_push(mrb, ary, str);
}
}
return ary;
}
/* 15.2.16.3.3 */
/*
* call-seq:
* mtch.captures -> array
*
* Returns the array of captures; equivalent to <code>mtch.to_a[1..-1]</code>.
*
* f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures
* f1 #=> "H"
* f2 #=> "X"
* f3 #=> "113"
* f4 #=> "8"
*/
static mrb_value
mrb_match_captures(mrb_state *mrb, mrb_value match)
{
return match_array(mrb, match, 1);
}
/* 15.2.16.3.4 */
/*
* call-seq:
* mtch.end(n) -> integer
*
* Returns the offset of the character immediately following the end of the
* <em>n</em>th element of the match array in the string.
* <em>n</em> can be a string or symbol to reference a named capture.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.end(0) #=> 7
* m.end(2) #=> 3
*
* m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
* p m.end(:foo) #=> 1
* p m.end(:bar) #=> 3
*/
static mrb_value
mrb_match_end(mrb_state *mrb, mrb_value match/*, mrb_value n*/)
{
mrb_value argv[16];
int argc;
mrb_value n;
int i;
struct re_registers *regs;
match_check(mrb, match);
mrb_get_args(mrb, "*", &argv, &argc);
n = argv[0];
i = match_backref_number(mrb, match, n);
regs = RMATCH_REGS(match);
if (i < 0 || regs->num_regs <= i)
mrb_raise(mrb, E_INDEX_ERROR, "index %d out of matches", i);
if (BEG(i) < 0)
return mrb_nil_value();
update_char_offset(mrb, match);
return mrb_fixnum_value(RMATCH(match)->rmatch->char_offset[i].end);
}
/* 15.2.16.3.5 */
/* :nodoc: */
static mrb_value
mrb_match_init_copy(mrb_state *mrb, mrb_value obj/*, mrb_value orig*/)
{
mrb_value argv[16];
int argc;
struct rmatch *rm;
mrb_value orig;
mrb_get_args(mrb, "*", &argv, &argc);
orig = argv[0];
if (mrb_obj_equal(mrb, obj, orig)) return obj;
if (!mrb_obj_is_instance_of(mrb, orig, mrb_obj_class(mrb, obj))) {
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
}
RMATCH(obj)->str = RMATCH(orig)->str;
RMATCH(obj)->regexp = RMATCH(orig)->regexp;
if (RMATCH(obj)->rmatch == 0) {
RMATCH(obj)->rmatch = mrb_malloc(mrb, sizeof(struct rmatch));//ALLOC(struct rmatch);
memset(RMATCH(obj)->rmatch, 0, sizeof(struct rmatch));
}
rm = RMATCH(obj)->rmatch;
onig_region_copy(&rm->regs, RMATCH_REGS(orig));
if (!RMATCH(orig)->rmatch->char_offset_updated) {
rm->char_offset_updated = 0;
}
else {
if (rm->char_offset_num_allocated < rm->regs.num_regs) {
//REALLOC_N(rm->char_offset, struct rmatch_offset, rm->regs.num_regs);
rm->char_offset = mrb_realloc(mrb, rm->char_offset, sizeof(struct rmatch_offset)* rm->regs.num_regs);
rm->char_offset_num_allocated = rm->regs.num_regs;
}
memcpy(rm->char_offset, RMATCH(orig)->rmatch->char_offset,
sizeof(struct rmatch_offset) * rm->regs.num_regs);
rm->char_offset_updated = 1;
}
return obj;
}
/* 15.2.16.3.6 */
/* 15.2.16.3.10 */
/*
* call-seq:
* mtch.length -> integer
* mtch.size -> integer
*
* Returns the number of elements in the match array.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.length #=> 5
* m.size #=> 5
*/
static mrb_value
mrb_match_size(mrb_state *mrb, mrb_value match)
{
match_check(mrb, match);
return mrb_fixnum_value(RMATCH_REGS(match)->num_regs);
}
/* 15.2.16.3.7 */
/*
* call-seq:
* mtch.offset(n) -> array
*
* Returns a two-element array containing the beginning and ending offsets of
* the <em>n</em>th match.
* <em>n</em> can be a string or symbol to reference a named capture.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.offset(0) #=> [1, 7]
* m.offset(4) #=> [6, 7]
*
* m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
* p m.offset(:foo) #=> [0, 1]
* p m.offset(:bar) #=> [2, 3]
*
*/
static mrb_value
mrb_match_offset(mrb_state *mrb, mrb_value match/*, mrb_value n*/)
{
mrb_value n;
struct re_registers *regs = RMATCH_REGS(match);
int i;
match_check(mrb, match);
mrb_get_args(mrb, "o", &n);
i = match_backref_number(mrb, match, n);
if (i < 0 || regs->num_regs <= i)
mrb_raise(mrb, E_INDEX_ERROR, "index %d out of matches", i);
if (BEG(i) < 0)
return mrb_assoc_new(mrb, mrb_nil_value(), mrb_nil_value());
update_char_offset(mrb, match);
return mrb_assoc_new(mrb, mrb_fixnum_value(RMATCH(match)->rmatch->char_offset[i].beg),
mrb_fixnum_value(RMATCH(match)->rmatch->char_offset[i].end));
}
/* 15.2.16.3.8 */
/*
* call-seq:
* mtch.post_match -> str
*
* Returns the portion of the original string after the current match.
* Equivalent to the special variable <code>$'</code>.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
* m.post_match #=> ": The Movie"
*/
mrb_value
mrb_reg_match_post(mrb_state *mrb, mrb_value match)
{
struct RString *str;
long pos;
struct re_registers *regs;
if (mrb_nil_p(match)) return mrb_nil_value();
match_check(mrb, match);
regs = RMATCH_REGS(match);
if (BEG(0) == -1) return mrb_nil_value();
str = RMATCH(match)->str;
pos = END(0);
return mrb_str_subseq(mrb, mrb_obj_value(str), pos, str->len - pos);
}
/* 15.2.16.3.9 */
/*
* call-seq:
* mtch.pre_match -> str
*
* Returns the portion of the original string before the current match.
* Equivalent to the special variable <code>$`</code>.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.pre_match #=> "T"
*/
mrb_value
mrb_reg_match_pre(mrb_state *mrb, mrb_value match)
{
mrb_value str;
struct re_registers *regs;
if (mrb_nil_p(match)) return mrb_nil_value();
match_check(mrb, match);
regs = RMATCH_REGS(match);
if (BEG(0) == -1) return mrb_nil_value();
str = mrb_str_subseq(mrb, mrb_obj_value(RMATCH(match)->str), 0, BEG(0));
return str;
}
/* 15.2.16.3.11 */
/*
* call-seq:
* mtch.string -> str
*
* Returns a frozen copy of the string passed in to <code>match</code>.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.string #=> "THX1138."
*/
static mrb_value
mrb_match_string(mrb_state *mrb, mrb_value match)
{
match_check(mrb, match);
return mrb_obj_value(RMATCH(match)->str);
}
/* 15.2.16.3.12 */
/*
* call-seq:
* mtch.to_a -> anArray
*
* Returns the array of matches.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.to_a #=> ["HX1138", "H", "X", "113", "8"]
*
* Because <code>to_a</code> is called when expanding
* <code>*</code><em>variable</em>, there's a useful assignment
* shortcut for extracting matched fields. This is slightly slower than
* accessing the fields directly (as an intermediate array is
* generated).
*
* all,f1,f2,f3 = *(/(.)(.)(\d+)(\d)/.match("THX1138."))
* all #=> "HX1138"
* f1 #=> "H"
* f2 #=> "X"
* f3 #=> "113"
*/
static mrb_value
mrb_match_to_a(mrb_state *mrb, mrb_value match)
{
return match_array(mrb, match, 0);
}
/* 15.2.16.3.13 */
/*
* call-seq:
* mtch.to_s -> str
*
* Returns the entire matched string.
*
* m = /(.)(.)(\d+)(\d)/.match("THX1138.")
* m.to_s #=> "HX1138"
*/
static mrb_value
mrb_match_to_s(mrb_state *mrb, mrb_value match)
{
mrb_value str = mrb_reg_last_match(mrb, match);
match_check(mrb, match);
if (mrb_nil_p(str)) str = mrb_str_new(mrb, 0, 0);//mrb_str_new(0,0);
return str;
}
static int
char_to_option(int c)
{
int val;
switch (c) {
case 'i':
val = ONIG_OPTION_IGNORECASE;
break;
case 'x':
val = ONIG_OPTION_EXTEND;
break;
case 'm':
val = ONIG_OPTION_MULTILINE;
break;
default:
val = 0;
break;
}
return val;
}
static char *
option_to_str(char str[4], int options)
{
char *p = str;
if (options & ONIG_OPTION_MULTILINE) *p++ = 'm';
if (options & ONIG_OPTION_IGNORECASE) *p++ = 'i';
if (options & ONIG_OPTION_EXTEND) *p++ = 'x';
*p = 0;
return str;
}
#define CHAR_ESC_LEN 13 /* sizeof(\x{ hex of 32bit unsigned int } \0) */
static void
mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len)
{
const char *p, *pend;
int need_escape = 0;
int c;
p = s; pend = p + len;
while (p < pend) {
c = *p;
if (c == -1) {
p += pend - p;
}
else if (c != '/' && ISPRINT(c)) {
p++;
}
else {
need_escape = 1;
break;
}
}
if (!need_escape) {
mrb_str_buf_cat(mrb, str, s, len);
}
else {
p = s;
while (p<pend) {
c = *p;
if (c == '\\' && p+1 < pend) {
int n = 1 + pend - (p+1);
mrb_str_buf_cat(mrb, str, p, n);
p += n;
continue;
}
else if (c == '/') {
char c = '\\';
mrb_str_buf_cat(mrb, str, &c, 1);
mrb_str_buf_cat(mrb, str, p, 1);
}
else if (ISPRINT(c)) {
mrb_str_buf_cat(mrb, str, p, 1);
}
else if (!ISSPACE(c)) {
char b[8];
int n;
n = snprintf(b, sizeof(b), "\\x%02X", c);
mrb_str_buf_cat(mrb, str, b, n);
}
else {
mrb_str_buf_cat(mrb, str, p, 1);
}
p++;
}
}
}
/* 15.2.15.7.9 (x) */
/*
* call-seq:
* rxp.to_s -> str
*
* Returns a string containing the regular expression and its options (using the
* <code>(?opts:source)</code> notation. This string can be fed back in to
* <code>Regexp::new</code> to a regular expression with the same semantics as
* the original. (However, <code>Regexp#==</code> may not return true when
* comparing the two, as the source of the regular expression itself may
* differ, as the example shows). <code>Regexp#inspect</code> produces a
* generally more readable version of <i>rxp</i>.
*
* r1 = /ab+c/ix #=> /ab+c/ix
* s1 = r1.to_s #=> "(?ix-m:ab+c)"
* r2 = Regexp.new(s1) #=> /(?ix-m:ab+c)/
* r1 == r2 #=> false
* r1.source #=> "ab+c"
* r2.source #=> "(?ix-m:ab+c)"
*/
mrb_value
mrb_reg_to_s(mrb_state *mrb, mrb_value re)
{
int options, opt;
const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
long len;
const UChar* ptr;
mrb_value str = mrb_str_new(mrb, "(?", 2);
char optbuf[5];
mrb_encoding *enc = mrb_enc_get(mrb, re);
mrb_reg_check(mrb, re);
memset(optbuf, 0, 5);
options = RREGEXP(re)->ptr->options;
ptr = (UChar*)RREGEXP_SRC_PTR(re);
len = RREGEXP_SRC_LEN(re);
again:
if (len >= 4 && ptr[0] == '(' && ptr[1] == '?') {
int err = 1;
ptr += 2;
if ((len -= 2) > 0) {
do {
opt = char_to_option((int )*ptr);
if (opt != 0) {
options |= opt;
}
else {
break;
}
++ptr;
} while (--len > 0);
}
if (len > 1 && *ptr == '-') {
++ptr;
--len;
do {
opt = char_to_option((int )*ptr);
if (opt != 0) {
options &= ~opt;
}
else {
break;
}
++ptr;
} while (--len > 0);
}
if (*ptr == ')') {
--len;
++ptr;
goto again;
}
if (*ptr == ':' && ptr[len-1] == ')') {
Regexp *rp;
++ptr;
len -= 2;
err = onig_new(&rp, ptr, ptr + len, ONIG_OPTION_DEFAULT,
enc, OnigDefaultSyntax, NULL);
onig_free(rp);
}
if (err) {
options = RREGEXP(re)->ptr->options;
ptr = (UChar*)RREGEXP_SRC_PTR(re);
len = RREGEXP_SRC_LEN(re);
}
}
if (*option_to_str(optbuf, options)) mrb_str_buf_cat(mrb, str, optbuf, strlen(optbuf));
if ((options & embeddable) != embeddable) {
optbuf[0] = '-';
option_to_str(optbuf + 1, ~options);
mrb_str_buf_cat(mrb, str, optbuf, strlen(optbuf));
}
mrb_str_buf_cat(mrb, str, ":", 1);
mrb_reg_expr_str(mrb, str, (char*)ptr, len);
mrb_str_buf_cat(mrb, str, ")", 1);
return str;
}
/* 15.2.15.7.10(x) */
/*
* call-seq:
* rxp.inspect -> string
*
* Produce a nicely formatted string-version of _rxp_. Perhaps surprisingly,
* <code>#inspect</code> actually produces the more natural version of
* the string than <code>#to_s</code>.
*
* /ab+c/ix.inspect #=> "/ab+c/ix"
*
*/
static mrb_value
mrb_reg_inspect(mrb_state *mrb, mrb_value re)
{
if (!RREGEXP(re)->ptr || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) {
return mrb_any_to_s(mrb, re);
}
return mrb_reg_desc(mrb, RREGEXP_SRC_PTR(re), RREGEXP_SRC_LEN(re), re);
}
static mrb_value
mrb_reg_s_alloc(mrb_state *mrb, mrb_value dummy)
{
struct RRegexp* re;
//NEWOBJ(re, struct RRegexp);
//OBJSETUP(re, klass, T_REGEXP);
re = (struct RRegexp*)mrb_obj_alloc(mrb, MRB_TT_REGEX, REGEX_CLASS);
re->ptr = 0;
re->src = 0;
re->usecnt = 0;
return mrb_obj_value(re);
}
mrb_value
mrb_reg_match_last(mrb_state *mrb, mrb_value match)
{
int i;
if (mrb_nil_p(match)) return mrb_nil_value();
match_check(mrb, match);
if (RMATCH(match)->rmatch->char_offset[0].beg == -1) return mrb_nil_value();
for (i=RMATCH(match)->rmatch->regs.num_regs-1; RMATCH(match)->rmatch->char_offset[i].beg == -1 && i > 0; i--)
;
if (i == 0) return mrb_nil_value();
return mrb_reg_nth_match(mrb, i, match);
}
/* 15.2.16.3.14(x) */
/*
* call-seq:
* mtch.inspect -> str
*
* Returns a printable version of <i>mtch</i>.
*
* puts /.$/.match("foo").inspect
* #=> #<MatchData "o">
*
* puts /(.)(.)(.)/.match("foo").inspect
* #=> #<MatchData "foo" 1:"f" 2:"o" 3:"o">
*
* puts /(.)(.)?(.)/.match("fo").inspect
* #=> #<MatchData "fo" 1:"f" 2:nil 3:"o">
*
* puts /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").inspect
* #=> #<MatchData "hog" foo:"h" bar:"o" baz:"g">
*
*/
struct backref_name_tag {
const UChar *name;
long len;
};
static int
match_inspect_name_iter(const OnigUChar *name, const OnigUChar *name_end,
int back_num, int *back_refs, OnigRegex regex, void *arg0)
{
struct backref_name_tag *arg = (struct backref_name_tag*)arg0;
int i;
for (i = 0; i < back_num; i++) {
arg[back_refs[i]].name = name;
arg[back_refs[i]].len = name_end - name;
}
return 0;
}
static mrb_value
mrb_match_inspect(mrb_state *mrb, mrb_value match)
{
const char *cname = mrb_obj_classname(mrb, match);
mrb_value str;
int i;
struct re_registers *regs = RMATCH_REGS(match);
int num_regs = regs->num_regs;
struct backref_name_tag *names;
struct RRegexp *regexp = RMATCH(match)->regexp;
if (!regexp) {
return mrb_sprintf(mrb, "#<%s:%p>", cname, (void*)&match);
}
//names = ALLOCA_N(struct backref_name_tag, num_regs);
//MEMZERO(names, struct backref_name_tag, num_regs);
names = mrb_malloc(mrb, sizeof(struct backref_name_tag)*num_regs);
memset(names, 0, sizeof(struct backref_name_tag)*num_regs);
onig_foreach_name(regexp->ptr,
match_inspect_name_iter, names);
str = mrb_str_new(mrb, "#<", 2);
mrb_str_buf_cat(mrb, str, cname, strlen(cname));
for (i = 0; i < num_regs; i++) {
char buf[sizeof(num_regs)*3+1];
mrb_value v;
mrb_str_buf_cat(mrb, str, " ", 1);
if (0 < i) {
if (names[i].name)
mrb_str_buf_cat(mrb, str, (const char*)names[i].name, names[i].len);
else {
int n = sprintf(buf, "%d", i);
mrb_str_buf_cat(mrb, str, (const char*)buf, n);
}
mrb_str_buf_cat(mrb, str, ":", 1);
}
v = mrb_reg_nth_match(mrb, i, match);
if (mrb_nil_p(v))
mrb_str_buf_cat(mrb, str, "nil", 3);
else
mrb_str_buf_append(mrb, str, mrb_str_inspect(mrb, v));
}
mrb_str_buf_cat(mrb, str, ">", 1);
return str;
}
/* 15.2.16.3.15(x) */
/* 15.2.16.3.16(x) */
/*
* call-seq:
* mtch == mtch2 -> true or false
*
* Equality---Two matchdata are equal if their target strings,
* patterns, and matched positions are identical.
*/
static mrb_value
mrb_match_equal(mrb_state *mrb, mrb_value match1)
{
const struct re_registers *regs1, *regs2;
mrb_value match2;
mrb_get_args(mrb, "o", &match2);
if (mrb_obj_equal(mrb, match1, match2)) return mrb_true_value();
if (mrb_type(match2) != MRB_TT_MATCH) return mrb_false_value();
if (!mrb_str_equal(mrb, mrb_obj_value(RMATCH(match1)->str), mrb_obj_value(RMATCH(match2)->str)))
return mrb_false_value();
if (!reg_equal(mrb, RMATCH(match1)->regexp, RMATCH(match2)->regexp)) return mrb_false_value();
regs1 = RMATCH_REGS(match1);
regs2 = RMATCH_REGS(match2);
if (regs1->num_regs != regs2->num_regs) return mrb_false_value();
if (memcmp(regs1->beg, regs2->beg, regs1->num_regs * sizeof(*regs1->beg))) return mrb_false_value();
if (memcmp(regs1->end, regs2->end, regs1->num_regs * sizeof(*regs1->end))) return mrb_false_value();
return mrb_true_value();
}
/*
* Document-class: RegexpError
*
* Raised when given an invalid regexp expression.
*
* Regexp.new("?")
*
* <em>raises the exception:</em>
*
* RegexpError: target of repeat operator is not specified: /?/
*/
/*
* Document-class: Regexp
*
* A <code>Regexp</code> holds a regular expression, used to match a pattern
* against strings. Regexps are created using the <code>/.../</code> and
* <code>%r{...}</code> literals, and by the <code>Regexp::new</code>
* constructor.
*
* :include: doc/re.rdoc
*/
void
mrb_init_regexp(mrb_state *mrb)
{
struct RClass *s;
s = mrb_define_class(mrb, "Regexp", mrb->object_class);
mrb_define_class_method(mrb, s, "compile", mrb_reg_s_new_instance, ARGS_ANY()); /* 15.2.15.6.1 */
mrb_define_class_method(mrb, s, "escape", mrb_reg_s_quote, ARGS_REQ(1)); /* 15.2.15.6.2 */
mrb_define_class_method(mrb, s, "last_match", mrb_reg_s_last_match, ARGS_ANY()); /* 15.2.15.6.3 */
mrb_define_class_method(mrb, s, "quote", mrb_reg_s_quote, ARGS_REQ(1)); /* 15.2.15.6.4 */
//mrb_define_singleton_method(rb_cRegexp, "union", rb_reg_s_union_m, -2);
//mrb_define_singleton_method(rb_cRegexp, "try_convert", rb_reg_s_try_convert, 1);
mrb_define_method(mrb, s, "initialize", mrb_reg_initialize_m, ARGS_ANY()); /* 15.2.15.7.1 */
mrb_define_method(mrb, s, "initialize_copy", mrb_reg_init_copy, ARGS_REQ(1)); /* 15.2.15.7.2 */
mrb_define_method(mrb, s, "==", mrb_reg_equal_m, ARGS_REQ(1)); /* 15.2.15.7.3 */
mrb_define_method(mrb, s, "===", mrb_reg_eqq, ARGS_REQ(1)); /* 15.2.15.7.4 */
mrb_define_method(mrb, s, "=~", mrb_reg_match, ARGS_REQ(1)); /* 15.2.15.7.5 */
mrb_define_method(mrb, s, "casefold?", mrb_reg_casefold_p, ARGS_NONE()); /* 15.2.15.7.6 */
mrb_define_method(mrb, s, "match", mrb_reg_match_m, ARGS_ANY()); /* 15.2.15.7.7 */
mrb_define_method(mrb, s, "source", mrb_reg_source, ARGS_NONE()); /* 15.2.15.7.8 */
//mrb_define_method(rb_cRegexp, "hash", rb_reg_hash, 0);
//mrb_define_method(rb_cRegexp, "~", rb_reg_match2, 0);
mrb_define_method(mrb, s, "to_s", mrb_reg_to_s, ARGS_NONE()); /* 15.2.15.7.9 (x) */
mrb_define_method(mrb, s, "inspect", mrb_reg_inspect, ARGS_NONE()); /* 15.2.15.7.10(x) */
mrb_define_method(mrb, s, "eql?", mrb_reg_equal_m, ARGS_REQ(1)); /* 15.2.15.7.11(x) */
//mrb_define_method(rb_cRegexp, "options", mrb_reg_options_m, 0);
//mrb_define_method(rb_cRegexp, "encoding", rb_obj_encoding, 0); /* in encoding.c */
//mrb_define_method(rb_cRegexp, "fixed_encoding?", mrb_reg_fixed_encoding_p, 0);
//mrb_define_method(rb_cRegexp, "names", rb_reg_names, 0);
//mrb_define_method(rb_cRegexp, "named_captures", rb_reg_named_captures, 0);
//mrb_define_const(rb_cRegexp, "IGNORECASE", INT2FIX(ONIG_OPTION_IGNORECASE));
//mrb_define_const(rb_cRegexp, "EXTENDED", INT2FIX(ONIG_OPTION_EXTEND));
//mrb_define_const(rb_cRegexp, "MULTILINE", INT2FIX(ONIG_OPTION_MULTILINE));
//mrb_define_const(rb_cRegexp, "FIXEDENCODING", INT2FIX(ARG_ENCODING_FIXED));
mrb_define_const(mrb, s, "IGNORECASE", mrb_fixnum_value(ONIG_OPTION_IGNORECASE));
mrb_define_const(mrb, s, "EXTENDED", mrb_fixnum_value(ONIG_OPTION_EXTEND));
mrb_define_const(mrb, s, "MULTILINE", mrb_fixnum_value(ONIG_OPTION_MULTILINE));
mrb_define_const(mrb, s, "FIXEDENCODING", mrb_fixnum_value(ARG_ENCODING_FIXED));
s = mrb_define_class(mrb, "MatchData", mrb->object_class);
//mrb_undef_class_method(CLASS_OF(rb_cMatch), "new");
mrb_define_method(mrb, s, "[]", mrb_match_aref, ARGS_ANY()); /* 15.2.16.3.1 */
mrb_define_method(mrb, s, "begin", mrb_match_begin, ARGS_REQ(1)); /* 15.2.16.3.2 */
mrb_define_method(mrb, s, "captures", mrb_match_captures, ARGS_NONE()); /* 15.2.16.3.3 */
mrb_define_method(mrb, s, "end", mrb_match_end, ARGS_REQ(1)); /* 15.2.16.3.4 */
mrb_define_method(mrb, s, "initialize_copy", mrb_match_init_copy, ARGS_REQ(1)); /* 15.2.16.3.5 */
mrb_define_method(mrb, s, "length", mrb_match_size, ARGS_NONE()); /* 15.2.16.3.6 */
mrb_define_method(mrb, s, "offset", mrb_match_offset, ARGS_REQ(1)); /* 15.2.16.3.7 */
mrb_define_method(mrb, s, "post_match", mrb_reg_match_post, ARGS_NONE()); /* 15.2.16.3.8 */
mrb_define_method(mrb, s, "pre_match", mrb_reg_match_pre, ARGS_NONE()); /* 15.2.16.3.9 */
mrb_define_method(mrb, s, "size", mrb_match_size, ARGS_NONE()); /* 15.2.16.3.10 */
mrb_define_method(mrb, s, "string", mrb_match_string, ARGS_NONE()); /* 15.2.16.3.11 */
mrb_define_method(mrb, s, "to_a", mrb_match_to_a, ARGS_NONE()); /* 15.2.16.3.12 */
mrb_define_method(mrb, s, "to_s", mrb_match_to_s, ARGS_NONE()); /* 15.2.16.3.13 */
mrb_define_method(mrb, s, "inspect", mrb_match_inspect, ARGS_NONE()); /* 15.2.16.3.14(x) */
mrb_define_method(mrb, s, "==", mrb_match_equal, ARGS_REQ(1)); /* 15.2.16.3.15(x) */
mrb_define_method(mrb, s, "eql?", mrb_match_equal, ARGS_REQ(1)); /* 15.2.16.3.16(x) */
//mrb_define_method(rb_cMatch, "regexp", match_regexp, 0);
//mrb_define_method(rb_cMatch, "names", match_names, 0);
//mrb_define_method(rb_cMatch, "values_at", match_values_at, -1);
//mrb_define_method(rb_cMatch, "hash", match_hash, 0);
//mrb_define_method(rb_cMatch, "==", match_equal, 1);
}
/* ----------------1_8_7---------------------------------------- */
//`mrb_check_type'
//`mrb_reg_regsub'
//`mrb_backref_get'
//`mrb_memsearch'
//`mrb_reg_mbclen2'
//`mrb_reg_regcomp'
//`mrb_yield'
mrb_value
mrb_reg_regsub(mrb_state *mrb, mrb_value str, mrb_value src, struct re_registers *regs, mrb_value regexp)
{
mrb_value val;
char *p, *s, *e;
struct RString *ps = mrb_str_ptr(str);
int no;
val.tt = 0;
p = s = ps->buf;
e = s + ps->len;
while (s < e) {
int c = *s;
char *ss;
if (c == -1) {
s += e - s;
continue;
}
ss = s;
s++;
if (c != '\\' || s == e) continue;
//if (!val) {
if (!val.tt) {
val = mrb_str_buf_new(mrb, ss-p);
}
mrb_str_buf_cat(mrb, val, p, ss-p);
c = *s;
if (c == -1) {
s += e - s;
mrb_str_buf_cat(mrb, val, ss, s-ss);
p = s;
continue;
}
s++;
p = s;
switch (c) {
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (onig_noname_group_capture_is_active(RREGEXP(regexp)->ptr)) {
no = c - '0';
}
else {
continue;
}
break;
case 'k':
if (s < e && *s == '<') {
char *name, *name_end;
name_end = name = s + 1;
while (name_end < e) {
c = *name_end;
if (c == '>') break;
name_end += c == -1 ? e - name_end : 1;
}
if (name_end < e) {
no = name_to_backref_number(mrb, regs, RREGEXP(regexp), name, name_end);
p = s = name_end + 1;
break;
}
else {
mrb_raise(mrb, E_RUNTIME_ERROR, "invalid group name reference format");
}
}
mrb_str_buf_cat(mrb, val, ss, s-ss);
continue;
case '0':
case '&':
no = 0;
break;
case '`':
mrb_str_buf_cat(mrb, val, RSTRING_PTR(src), BEG(0));
continue;
case '\'':
mrb_str_buf_cat(mrb, val, RSTRING_PTR(src)+END(0), RSTRING_LEN(src)-END(0));
continue;
case '+':
no = regs->num_regs-1;
while (BEG(no) == -1 && no > 0) no--;
if (no == 0) continue;
break;
case '\\':
mrb_str_buf_cat(mrb, val, s-1, 1);
continue;
default:
mrb_str_buf_cat(mrb, val, ss, s-ss);
continue;
}
if (no >= 0) {
if (no >= regs->num_regs) continue;
if (BEG(no) == -1) continue;
mrb_str_buf_cat(mrb, val, RSTRING_PTR(src)+BEG(no), END(no)-BEG(no));
}
} /* while (s < e) { */
if (!val.tt) return str;
if (p < e) {
mrb_str_buf_cat(mrb, val, p, e-p);
}
return val;
}
static inline NODE *
lfp_svar_place(mrb_state *mrb, /*mrb_thread_t *th,*/ mrb_value *lfp)
{
NODE *svar;
/*if (lfp && th->local_lfp != lfp) {
svar = &lfp[-1];
}
else {
svar = mrb->&th->local_svar;
}*/
svar = mrb->local_svar;
/*if (mrb_nil_p(*svar)) {
*svar = mrb_obj_value(NEW_IF(0, 0, 0));
}*/
return svar;//(NODE *)((*svar).value.p);
}
static mrb_value
lfp_svar_get(mrb_state *mrb, /*mrb_thread_t *th,*/ mrb_value *lfp, mrb_int key)
{
//mrb_value *regs;
NODE *svar = lfp_svar_place(mrb, /*th,*/ lfp);
//regs = mrb->stack;
switch (key) {
case 0:
return svar->u1.value;
case 1:
return svar->u2.value;
default: {
return svar->u3.value;
/*const mrb_value hash = regs[GETARG_C(*svar)];//svar->u3.value;
if (mrb_nil_p(hash)) {
return mrb_nil_value();
}
else {
return mrb_hash_get(mrb, hash, mrb_fixnum_value(key));//mrb_hash_lookup(hash, key);
}*/
}
}
}
static void
lfp_svar_set(mrb_state *mrb, /*mrb_thread_t *th,*/ mrb_value *lfp, mrb_int key, mrb_value val)
{
//mrb_value *regs;
NODE *svar = lfp_svar_place(mrb, /*th,*/ lfp);
//regs = mrb->stack;
switch (key) {
case 0:
svar->u1.value = val;
return;
case 1:
svar->u2.value = val;
return;
default: {
svar->u3.value = val;
//mrb_value hash = *svar;//svar->u3.value;
//if (mrb_nil_p(hash)) {
// svar->u3.value = hash = mrb_hash_new(mrb, 0);
//}
//mrb_hash_aset(hash, key, val);
//mrb_hash_set(mrb, hash, mrb_fixnum_value(key), val);
}
}
}
static mrb_value
vm_cfp_svar_get(mrb_state *mrb, /*mrb_thread_t *th, mrb_control_frame_t *cfp,*/ mrb_int key)
{
//cfp = vm_normal_frame(th, cfp);
return lfp_svar_get(mrb, /*th, cfp ? cfp->lfp :*/ 0, key);
}
static void
vm_cfp_svar_set(mrb_state *mrb, /*mrb_thread_t *th, mrb_control_frame_t *cfp,*/ mrb_int key, const mrb_value val)
{
//cfp = vm_normal_frame(th, cfp);
lfp_svar_set(mrb, /*th, cfp ? cfp->lfp : */0, key, val);
}
static mrb_value
vm_svar_get(mrb_state *mrb, mrb_int key)
{
//mrb_thread_t *th = GET_THREAD();
return vm_cfp_svar_get(mrb,/*th, th->cfp,*/ key);
}
static void
vm_svar_set(mrb_state *mrb, mrb_int key, mrb_value val)
{
//mrb_thread_t *th = GET_THREAD();
vm_cfp_svar_set(mrb,/*th, th->cfp,*/ key, val);
}
int
mrb_reg_backref_number(mrb_state *mrb, mrb_value match, mrb_value backref)
{
return match_backref_number(mrb, match, backref);
}
mrb_value
mrb_backref_get(mrb_state *mrb)
{
return vm_svar_get(mrb, 1);
}
void
mrb_backref_set(mrb_state *mrb, mrb_value val)
{
vm_svar_set(mrb, 1, val);
}
#endif //ENABLE_REGEXP
#ifdef INCLUDE_ENCODING
static inline long
mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long n)
{
const unsigned char *x = xs, *xe = xs + m;
const unsigned char *y = ys;
int i, qstable[256];
/* Preprocessing */
for (i = 0; i < 256; ++i)
qstable[i] = m + 1;
for (; x < xe; ++x)
qstable[*x] = xe - x;
/* Searching */
for (; y + m <= ys + n; y += *(qstable + y[m])) {
if (*xs == *y && memcmp(xs, y, m) == 0)
return y - ys;
}
return -1;
}
static inline unsigned int
mrb_memsearch_qs_utf8_hash(const unsigned char *x)
{
register const unsigned int mix = 8353;
register unsigned int h = *x;
if (h < 0xC0) {
return h + 256;
}
else if (h < 0xE0) {
h *= mix;
h += x[1];
}
else if (h < 0xF0) {
h *= mix;
h += x[1];
h *= mix;
h += x[2];
}
else if (h < 0xF5) {
h *= mix;
h += x[1];
h *= mix;
h += x[2];
h *= mix;
h += x[3];
}
else {
return h + 256;
}
return (unsigned char)h;
}
static inline long
mrb_memsearch_qs_utf8(const unsigned char *xs, long m, const unsigned char *ys, long n)
{
const unsigned char *x = xs, *xe = xs + m;
const unsigned char *y = ys;
int i, qstable[512];
/* Preprocessing */
for (i = 0; i < 512; ++i) {
qstable[i] = m + 1;
}
for (; x < xe; ++x) {
qstable[mrb_memsearch_qs_utf8_hash(x)] = xe - x;
}
/* Searching */
for (; y + m <= ys + n; y += qstable[mrb_memsearch_qs_utf8_hash(y+m)]) {
if (*xs == *y && memcmp(xs, y, m) == 0)
return y - ys;
}
return -1;
}
int
mrb_memsearch(mrb_state *mrb, const void *x0, int m, const void *y0, int n, mrb_encoding *enc)
{
const unsigned char *x = x0, *y = y0;
if (m > n) return -1;
else if (m == n) {
return memcmp(x0, y0, m) == 0 ? 0 : -1;
}
else if (m < 1) {
return 0;
}
else if (m == 1) {
const unsigned char *ys = y, *ye = ys + n;
for (; y < ye; ++y) {
if (*x == *y)
return y - ys;
}
return -1;
}
else {
return mrb_memsearch_qs(x0, m, y0, n);
}
}
#endif //INCLUDE_ENCODING
#ifdef ENABLE_REGEXP
mrb_value
mrb_reg_init_str(mrb_state *mrb, mrb_value re, mrb_value s, int options)
{
onig_errmsg_buffer err = "";
if (mrb_reg_initialize_str(mrb, re, s, options, err, NULL, 0) != 0) {
//mrb_reg_raise_str(s, options, err);
printf("mrb_reg_raise_str(s, options, err);");
}
return re;
}
mrb_value
mrb_reg_alloc(mrb_state *mrb)
{
mrb_value dummy = mrb_nil_value();
return mrb_reg_s_alloc(mrb, dummy);
}
mrb_value
mrb_reg_new_str(mrb_state *mrb, mrb_value s, int options)
{
return mrb_reg_init_str(mrb, mrb_reg_alloc(mrb), s, options);
}
mrb_value
mrb_reg_regcomp(mrb_state *mrb, mrb_value str)
{
return mrb_reg_new_str(mrb, str, 0);
}
int
re_adjust_startpos(struct re_pattern_buffer *bufp, const char *string, int size, int startpos, int range)
{
/* Update the fastmap now if not correct already. */
/*if (!bufp->fastmap_accurate) {
int ret = re_compile_fastmap0(bufp);
if (ret) return ret;
}*/
/* Adjust startpos for mbc string */
/*if (current_mbctype && startpos>0 && !(bufp->options&RE_OPTIMIZE_BMATCH)) {
startpos = re_mbc_startpos(string, size, startpos, range);
}*/
return startpos;
}
#endif //ENABLE_REGEXP
#ifdef INCLUDE_ENCODING
static const unsigned char mbctab_ascii[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const unsigned char *re_mbctab = mbctab_ascii;
#define is_identchar(p,e,enc) (mrb_enc_isalnum(*p,enc) || (*p) == '_' || !ISASCII(*p))
static int
is_special_global_name(const char *m, const char *e, mrb_encoding *enc)
{
int mb = 0;
if (m >= e) return 0;
switch (*m) {
case '~': case '*': case '$': case '?': case '!': case '@':
case '/': case '\\': case ';': case ',': case '.': case '=':
case ':': case '<': case '>': case '\"':
case '&': case '`': case '\'': case '+':
case '0':
++m;
break;
case '-':
++m;
if (m < e && is_identchar(m, e, enc)) {
if (!ISASCII(*m)) mb = 1;
m += e - m;
}
break;
default:
if (!mrb_enc_isdigit(*m, enc)) return 0;
do {
if (!ISASCII(*m)) mb = 1;
++m;
} while (m < e && mrb_enc_isdigit(*m, enc));
}
return m == e ? mb + 1 : 0;
}
int
mrb_enc_symname2_p(const char *name, long len, mrb_encoding *enc)
{
const char *m = name;
const char *e = m + len;
int localid = FALSE;
if (!m) return FALSE;
switch (*m) {
case '\0':
return FALSE;
case '$':
if (is_special_global_name(++m, e, enc)) return TRUE;
goto id;
case '@':
if (*++m == '@') ++m;
goto id;
case '<':
switch (*++m) {
case '<': ++m; break;
case '=': if (*++m == '>') ++m; break;
default: break;
}
break;
case '>':
switch (*++m) {
case '>': case '=': ++m; break;
}
break;
case '=':
switch (*++m) {
case '~': ++m; break;
case '=': if (*++m == '=') ++m; break;
default: return FALSE;
}
break;
case '*':
if (*++m == '*') ++m;
break;
case '+': case '-':
if (*++m == '@') ++m;
break;
case '|': case '^': case '&': case '/': case '%': case '~': case '`':
++m;
break;
case '[':
if (*++m != ']') return FALSE;
if (*++m == '=') ++m;
break;
case '!':
switch (*++m) {
case '\0': return TRUE;
case '=': case '~': ++m; break;
default: return FALSE;
}
break;
default:
localid = !mrb_enc_isupper(*m, enc);
id:
if (m >= e || (*m != '_' && !mrb_enc_isalpha(*m, enc) && ISASCII(*m)))
return FALSE;
while (m < e && is_identchar(m, e, enc)) m += e - m;
if (localid) {
switch (*m) {
case '!': case '?': case '=': ++m;
}
}
break;
}
return m == e;
}
int
mrb_enc_symname_p(const char *name, mrb_encoding *enc)
{
return mrb_enc_symname2_p(name, strlen(name), enc);
}
#endif //INCLUDE_ENCODING
Jump to Line
Something went wrong with that request. Please try again.