mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
d444859d4a
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2256 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
656 lines
14 KiB
C
656 lines
14 KiB
C
/* vi:set sw=4:
|
|
|
|
strscan.c
|
|
|
|
Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
|
|
|
|
This program is free software.
|
|
You can distribute/modify this program
|
|
under the same terms of the ruby.
|
|
|
|
$Id$
|
|
|
|
*/
|
|
|
|
|
|
#include "ruby.h"
|
|
#include "re.h"
|
|
#include "version.h"
|
|
|
|
#if (RUBY_VERSION_CODE < 150)
|
|
# define rb_eRangeError rb_eArgError
|
|
# define rb_obj_freeze(obj) rb_str_freeze(obj)
|
|
#endif
|
|
|
|
#define STRSCAN_VERSION "0.7.0"
|
|
|
|
struct strscanner
|
|
{
|
|
unsigned long flags;
|
|
VALUE str;
|
|
long end2;
|
|
long beg1;
|
|
long end1;
|
|
long idx;
|
|
struct re_registers regs;
|
|
};
|
|
|
|
#define S_PTR(s) (RSTRING(s->str)->ptr)
|
|
#define S_LEN(s) (RSTRING(s->str)->len)
|
|
#define S_END(s) (S_PTR(s) + S_LEN(s))
|
|
#define CURPTR(s) (S_PTR(s) + s->idx)
|
|
|
|
#define MATCH_FLAG (1UL)
|
|
#define CLEAR_MATCH_STATUS(s) s->flags &= ~MATCH_FLAG
|
|
#define MATCHED(s,i,len) do {\
|
|
s->flags |= MATCH_FLAG; \
|
|
s->end2 = s->idx; \
|
|
s->beg1 = i; \
|
|
s->end1 = i + len; \
|
|
} while (0)
|
|
#define MATCHED_P(s) (s->flags & MATCH_FLAG)
|
|
|
|
#define GET_SCANNER(obj,var) Data_Get_Struct(obj, struct strscanner, var)
|
|
#define SCAN_FINISHED(s) ((s)->idx >= RSTRING(p->str)->len)
|
|
|
|
static VALUE StringScanner;
|
|
static VALUE ScanError;
|
|
|
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
static VALUE
|
|
strscan_s_mustc(self)
|
|
VALUE self;
|
|
{
|
|
return self;
|
|
}
|
|
|
|
|
|
static void
|
|
strscan_mark(p)
|
|
struct strscanner *p;
|
|
{
|
|
rb_gc_mark(p->str);
|
|
}
|
|
|
|
static void
|
|
strscan_free(p)
|
|
struct strscanner *p;
|
|
{
|
|
re_free_registers(&(p->regs));
|
|
memset(p, sizeof(struct strscanner), 0);
|
|
free(p);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_s_new(argc, argv, klass)
|
|
int argc;
|
|
VALUE *argv, klass;
|
|
{
|
|
VALUE str, dup_p;
|
|
struct strscanner *p;
|
|
|
|
if (rb_scan_args(argc, argv, "11", &str, &dup_p) == 1)
|
|
dup_p = Qtrue;
|
|
Check_Type(str, T_STRING);
|
|
|
|
p = ALLOC_N(struct strscanner, 1);
|
|
MEMZERO(p, struct strscanner, 1);
|
|
p->str = RTEST(dup_p) ? rb_str_dup(str) : str;
|
|
rb_obj_freeze(p->str);
|
|
CLEAR_MATCH_STATUS(p);
|
|
MEMZERO(&(p->regs), struct re_registers, 1);
|
|
|
|
return Data_Wrap_Struct(klass, strscan_mark, strscan_free, p);
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_reset(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
p->idx = 0;
|
|
CLEAR_MATCH_STATUS(p);
|
|
return self;
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_terminate(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
p->idx = S_LEN(p);
|
|
CLEAR_MATCH_STATUS(p);
|
|
return self;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_get_string(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
return p->str;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_set_string(self, str)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
Check_Type(str, T_STRING);
|
|
p->str = rb_str_dup(str);
|
|
rb_obj_freeze(p->str);
|
|
p->idx = 0;
|
|
CLEAR_MATCH_STATUS(p);
|
|
return str;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_get_pos(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
return INT2FIX(p->idx);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_set_pos(self, v)
|
|
VALUE self, v;
|
|
{
|
|
struct strscanner *p;
|
|
long i;
|
|
|
|
GET_SCANNER(self, p);
|
|
i = NUM2INT(v);
|
|
if (i < 0) i += S_LEN(p);
|
|
if (i < 0) rb_raise(rb_eRangeError, "index out of range");
|
|
if (i > S_LEN(p)) rb_raise(rb_eRangeError, "index out of range");
|
|
p->idx = i;
|
|
return INT2FIX(i);
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
strscan_do_scan(self, regex, succptr, getstr, headonly)
|
|
VALUE self, regex;
|
|
int succptr, getstr, headonly;
|
|
{
|
|
struct strscanner *p;
|
|
int ret;
|
|
char *pbeg;
|
|
long plen;
|
|
|
|
Check_Type(regex, T_REGEXP);
|
|
GET_SCANNER(self, p);
|
|
|
|
pbeg = CURPTR(p);
|
|
plen = S_LEN(p) - p->idx;
|
|
|
|
CLEAR_MATCH_STATUS(p);
|
|
if (headonly) {
|
|
ret = re_match(RREGEXP(regex)->ptr,
|
|
pbeg, plen,
|
|
0,
|
|
&(p->regs));
|
|
}
|
|
else {
|
|
ret = re_search(RREGEXP(regex)->ptr,
|
|
pbeg, plen,
|
|
0,
|
|
plen,
|
|
&(p->regs));
|
|
}
|
|
|
|
if (ret == -2) {
|
|
rb_raise(ScanError, "regexp buffer overflow");
|
|
return Qnil; /* not reach */
|
|
}
|
|
else if (ret < 0) {
|
|
/* not matched */
|
|
return Qnil;
|
|
}
|
|
else {
|
|
/* matched */
|
|
MATCHED(p, p->idx + p->regs.beg[0],
|
|
p->regs.end[0] - p->regs.beg[0]);
|
|
if (succptr) {
|
|
p->idx += p->regs.end[0];
|
|
}
|
|
if (getstr) {
|
|
return rb_str_new(pbeg, p->regs.end[0]);
|
|
}
|
|
else {
|
|
return INT2FIX(p->regs.end[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
strscan_scan(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 1, 1, 1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_match_p(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 0, 0, 1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_skip(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 1, 0, 1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_check(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 0, 1, 1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_scan_full(self, re, s, f)
|
|
{
|
|
return strscan_do_scan(self, re, RTEST(s), RTEST(f), 1);
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_scan_until(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 1, 1, 0);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_exist_p(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 0, 0, 0);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_skip_until(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 1, 0, 0);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_check_until(self, re)
|
|
VALUE self, re;
|
|
{
|
|
return strscan_do_scan(self, re, 0, 1, 0);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_search_full(self, re, s, f)
|
|
{
|
|
return strscan_do_scan(self, re, RTEST(s), RTEST(f), 0);
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_getch(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
long len;
|
|
|
|
GET_SCANNER(self, p);
|
|
CLEAR_MATCH_STATUS(p);
|
|
if (SCAN_FINISHED(p))
|
|
return Qnil;
|
|
|
|
len = mbclen(*CURPTR(p));
|
|
if (p->idx + len > S_LEN(p))
|
|
len = S_LEN(p) - p->idx;
|
|
MATCHED(p, p->idx, len);
|
|
p->idx += len;
|
|
return rb_str_new(S_PTR(p) + p->beg1, p->end1 - p->beg1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_get_byte(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
CLEAR_MATCH_STATUS(p);
|
|
if (SCAN_FINISHED(p))
|
|
return Qnil;
|
|
|
|
MATCHED(p, p->idx, 1);
|
|
p->idx++;
|
|
return rb_str_new(S_PTR(p) + p->beg1, 1);
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_peek(self, vlen)
|
|
VALUE self, vlen;
|
|
{
|
|
struct strscanner *p;
|
|
long len;
|
|
|
|
GET_SCANNER(self, p);
|
|
|
|
len = NUM2LONG(vlen);
|
|
if (SCAN_FINISHED(p)) {
|
|
return rb_str_new("", 0);
|
|
}
|
|
else {
|
|
if (p->idx + len > S_LEN(p))
|
|
len = S_LEN(p) - p->idx;
|
|
return rb_str_new(CURPTR(p), len);
|
|
}
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_eos_p(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (SCAN_FINISHED(p))
|
|
return Qtrue;
|
|
else
|
|
return Qfalse;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_rest_p(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (SCAN_FINISHED(p))
|
|
return Qfalse;
|
|
else
|
|
return Qtrue;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_rest(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (SCAN_FINISHED(p))
|
|
return rb_str_new("", 0);
|
|
else
|
|
return rb_str_new(CURPTR(p), S_LEN(p) - p->idx);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_rest_size(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (SCAN_FINISHED(p)) {
|
|
return INT2FIX(0);
|
|
}
|
|
else {
|
|
long tmp;
|
|
tmp = S_LEN(p) - p->idx;
|
|
return INT2FIX(tmp);
|
|
}
|
|
}
|
|
|
|
|
|
static VALUE
|
|
strscan_matched_p(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (MATCHED_P(p))
|
|
return Qtrue;
|
|
else
|
|
return Qfalse;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_matched(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p)) return Qnil;
|
|
return rb_str_new(S_PTR(p) + p->beg1, p->end1 - p->beg1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_matched_size(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p)) return Qnil;
|
|
|
|
return INT2NUM(p->end1 - p->beg1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_unscan(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p))
|
|
rb_raise(ScanError, "cannot unscan: prev match had failed");
|
|
|
|
p->idx = p->end2;
|
|
CLEAR_MATCH_STATUS(p);
|
|
return self;
|
|
}
|
|
|
|
static VALUE
|
|
strscan_pre_match(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p)) return Qnil;
|
|
|
|
return rb_str_new(S_PTR(p) + p->end2, p->beg1 - p->end2);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_post_match(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p)) return Qnil;
|
|
|
|
return rb_str_new(S_PTR(p) + p->end1, S_LEN(p) - p->end1);
|
|
}
|
|
|
|
static VALUE
|
|
strscan_aref(self, idx)
|
|
VALUE self, idx;
|
|
{
|
|
struct strscanner *p;
|
|
long i;
|
|
|
|
GET_SCANNER(self, p);
|
|
if (! MATCHED_P(p)) return Qnil;
|
|
|
|
i = NUM2LONG(idx);
|
|
if (i < 0) return Qnil;
|
|
if (i >= p->regs.num_regs) return Qnil;
|
|
if (p->regs.beg[i] == -1) return Qnil;
|
|
|
|
return rb_str_new(S_PTR(p) + p->end2 + p->regs.beg[i],
|
|
p->regs.end[i] - p->regs.beg[i]);
|
|
}
|
|
|
|
|
|
static void
|
|
cat_i_char(ret, c)
|
|
VALUE ret;
|
|
int c;
|
|
{
|
|
char buf[1];
|
|
|
|
buf[0] = c;
|
|
rb_str_cat(ret, buf, 1);
|
|
}
|
|
|
|
#define CLEN 5
|
|
|
|
static VALUE
|
|
strscan_inspect(self)
|
|
VALUE self;
|
|
{
|
|
struct strscanner *p;
|
|
char buf[128];
|
|
VALUE ret;
|
|
long len;
|
|
|
|
GET_SCANNER(self, p);
|
|
len = sprintf(buf, "#<%s %ld/%ld",
|
|
rb_class2name(CLASS_OF(self)),
|
|
p->idx, S_LEN(p));
|
|
ret = rb_str_new(buf, len);
|
|
|
|
if (SCAN_FINISHED(p)) {
|
|
rb_str_cat(ret, " fin>", 4);
|
|
}
|
|
else {
|
|
char *sp;
|
|
|
|
sp = CURPTR(p) - CLEN;
|
|
if (sp < S_PTR(p)) sp = S_PTR(p);
|
|
if (sp != CURPTR(p)) {
|
|
rb_str_cat(ret, " \"", 2);
|
|
if (sp > S_PTR(p))
|
|
rb_str_cat(ret, "...", 3);
|
|
for (; sp < CURPTR(p); sp++) {
|
|
cat_i_char(ret, *sp);
|
|
}
|
|
rb_str_cat(ret, "\"", 1);
|
|
}
|
|
rb_str_cat(ret, " @", 2);
|
|
if (sp != S_END(p)) {
|
|
char *e;
|
|
|
|
e = sp + CLEN;
|
|
if (e > S_END(p)) e = S_END(p);
|
|
rb_str_cat(ret, " \"", 2);
|
|
for (; sp < e; sp++) {
|
|
cat_i_char(ret, *sp);
|
|
}
|
|
if (sp < S_END(p))
|
|
rb_str_cat(ret, "...", 3);
|
|
rb_str_cat(ret, "\"", 1);
|
|
}
|
|
rb_str_cat(ret, ">", 1);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
void
|
|
Init_strscan()
|
|
{
|
|
ID id_scanerr = rb_intern("ScanError");
|
|
VALUE tmp;
|
|
|
|
if (rb_const_defined(rb_cObject, id_scanerr)) {
|
|
ScanError = rb_const_get(rb_cObject, id_scanerr);
|
|
}
|
|
else {
|
|
ScanError = rb_define_class_id(id_scanerr, rb_eStandardError);
|
|
}
|
|
|
|
StringScanner = rb_define_class("StringScanner", rb_cObject);
|
|
tmp = rb_str_new2(STRSCAN_VERSION);
|
|
rb_obj_freeze(tmp);
|
|
rb_const_set(StringScanner, rb_intern("Version"), tmp);
|
|
tmp = rb_str_new2("$Id$");
|
|
rb_obj_freeze(tmp);
|
|
rb_const_set(StringScanner, rb_intern("Id"), tmp);
|
|
|
|
rb_define_singleton_method(StringScanner, "new", strscan_s_new, -1);
|
|
rb_define_singleton_method(StringScanner,
|
|
"must_C_version", strscan_s_mustc, 0);
|
|
rb_define_method(StringScanner, "reset", strscan_reset, 0);
|
|
rb_define_method(StringScanner, "terminate", strscan_terminate, 0);
|
|
rb_define_method(StringScanner, "clear", strscan_terminate, 0);
|
|
rb_define_method(StringScanner, "string", strscan_get_string, 0);
|
|
rb_define_method(StringScanner, "string=", strscan_set_string, 1);
|
|
rb_define_method(StringScanner, "pos", strscan_get_pos, 0);
|
|
rb_define_method(StringScanner, "pos=", strscan_set_pos, 1);
|
|
rb_define_method(StringScanner, "pointer", strscan_get_pos, 0);
|
|
rb_define_method(StringScanner, "pointer=", strscan_set_pos, 1);
|
|
|
|
rb_define_method(StringScanner, "scan", strscan_scan, 1);
|
|
rb_define_method(StringScanner, "skip", strscan_skip, 1);
|
|
rb_define_method(StringScanner, "match?", strscan_match_p, 1);
|
|
rb_define_method(StringScanner, "check", strscan_check, 1);
|
|
rb_define_method(StringScanner, "scan_full", strscan_scan_full, 3);
|
|
|
|
rb_define_method(StringScanner, "scan_until", strscan_scan_until, 1);
|
|
rb_define_method(StringScanner, "skip_until", strscan_skip_until, 1);
|
|
rb_define_method(StringScanner, "exist?", strscan_exist_p, 1);
|
|
rb_define_method(StringScanner, "check_until", strscan_check_until, 1);
|
|
rb_define_method(StringScanner, "search_full", strscan_search_full, 3);
|
|
|
|
rb_define_method(StringScanner, "getch", strscan_getch, 0);
|
|
rb_define_method(StringScanner, "get_byte", strscan_get_byte, 0);
|
|
rb_define_method(StringScanner, "getbyte", strscan_get_byte, 0);
|
|
rb_define_method(StringScanner, "peek", strscan_peek, 1);
|
|
rb_define_method(StringScanner, "peep", strscan_peek, 1);
|
|
|
|
rb_define_method(StringScanner, "eos?", strscan_eos_p, 0);
|
|
rb_define_method(StringScanner, "empty?", strscan_eos_p, 0);
|
|
rb_define_method(StringScanner, "rest?", strscan_rest_p, 0);
|
|
rb_define_method(StringScanner, "rest", strscan_rest, 0);
|
|
rb_define_method(StringScanner, "rest_size", strscan_rest_size, 0);
|
|
rb_define_method(StringScanner, "restsize", strscan_rest_size, 0);
|
|
|
|
rb_define_method(StringScanner, "matched?", strscan_matched_p, 0);
|
|
rb_define_method(StringScanner, "matched", strscan_matched, 0);
|
|
rb_define_method(StringScanner, "matched_size", strscan_matched_size, 0);
|
|
rb_define_method(StringScanner, "matchedsize", strscan_matched_size, 0);
|
|
rb_define_method(StringScanner, "unscan", strscan_unscan, 0);
|
|
rb_define_method(StringScanner, "pre_match", strscan_pre_match, 0);
|
|
rb_define_method(StringScanner, "post_match", strscan_post_match, 0);
|
|
rb_define_method(StringScanner, "[]", strscan_aref, 1);
|
|
|
|
rb_define_method(StringScanner, "inspect", strscan_inspect, 0);
|
|
}
|