#include "bdb1.h"

static ID id_cmp;

static VALUE
bdb1_recnum_init(int argc, VALUE *argv, VALUE obj)
{
    VALUE *nargv;
    VALUE array = rb_str_new2("array_base");
    VALUE sarray = rb_str_new2("set_array_base");

    if (!argc || TYPE(argv[argc - 1]) != T_HASH) {
	nargv = ALLOCA_N(VALUE, argc + 1);
	MEMCPY(nargv, argv, VALUE, argc);
	nargv[argc] = rb_hash_new();
	argv = nargv;
	argc++;
    }
    rb_hash_aset(argv[argc - 1], array, INT2FIX(0));
    if (rb_hash_aref(argv[argc - 1], sarray) != RHASH(argv[argc - 1])->ifnone) {
	rb_hash_aset(argv[argc - 1], sarray, INT2FIX(0));
    }
    return bdb1_init(argc, argv, obj);
}

static VALUE
bdb1_sary_subseq(VALUE obj, long beg, long len)
{
    VALUE ary2, a;
    bdb1_DB *dbst;
    long i;

    GetDB(obj, dbst);
    if (beg > dbst->len) return Qnil;
    if (beg < 0 || len < 0) return Qnil;

    if (beg + len > dbst->len) {
	len = dbst->len - beg;
    }
    if (len <= 0) return rb_ary_new2(0);

    ary2 = rb_ary_new2(len);
    for (i = 0; i < len; i++) {
	a = INT2NUM(i + beg);
	rb_ary_push(ary2, bdb1_get(1, &a, obj));
    }
    return ary2;
}

static VALUE
bdb1_sary_entry(VALUE obj, VALUE position)
{
    bdb1_DB *dbst;
    long offset;

    GetDB(obj, dbst);
    if (dbst->len == 0) return Qnil;
    offset = NUM2LONG(position);
    if (offset < 0) {
	offset += dbst->len;
    }
    if (offset < 0 || dbst->len <= offset) return Qnil;
    position = INT2NUM(offset);
    return bdb1_get(1, &position, obj);
}

/*
 * call-seq:
 *   db[nth]
 *   db[start..end]
 *   db[start, length]
 *
 * Element reference - with the following syntax:
 *
 * * db[nth]
 *   Retrieves the +nth+ item from an array.  Index starts from zero.
 *   If index is the negative, counts backward from the end of the
 *   array.  The index of the last element is -1. Returns +nil+, if
 *   the +nth+ element does not exist in the array.
 *
 * * db[start..end]
 *   Returns an array containing the objects from +start+ to +end+,
 *   including both ends. if end is larger than the length of the
 *   array, it will be rounded to the length.  If +start+ is out of an
 *   array range , returns +nil+.  And if +start+ is larger than end
 *   with in array range, returns empty array ([]).
 *
 * * db[start, length]
 *   Returns an array containing +length+ items from +start+.  Returns
 *   +nil+ if +length+ is negative.
 */
static VALUE
bdb1_sary_aref(int argc, VALUE *argv, VALUE obj)
{
    VALUE arg1, arg2;
    long beg, len;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
	beg = NUM2LONG(arg1);
	len = NUM2LONG(arg2);
	if (beg < 0) {
	    beg = dbst->len + beg;
	}
	return bdb1_sary_subseq(obj, beg, len);
    }

    if (FIXNUM_P(arg1)) {
	return bdb1_sary_entry(obj, arg1);
    }
    else if (TYPE(arg1) == T_BIGNUM) {
	rb_raise(rb_eIndexError, "index too big");
    }
    else {
	switch (rb_range_beg_len(arg1, &beg, &len, dbst->len, 0)) {
	  case Qfalse:
	    break;
	  case Qnil:
	    return Qnil;
	  default:
	    return bdb1_sary_subseq(obj, beg, len);
	}
    }
    return bdb1_sary_entry(obj, arg1);
}

static VALUE
bdb1_intern_shift_pop(VALUE obj, int depart, int len)
{
    bdb1_DB *dbst;
    DBT key, data;
    int ret, i;
    db_recno_t recno;
    VALUE res;

    rb_secure(4);
    GetDB(obj, dbst);
    INIT_RECNO(dbst, key, recno);
    DATA_ZERO(data);
    res = rb_ary_new2(len);
    for (i = 0; i < len; i++) {
	ret = bdb1_test_error(dbst->dbp->seq(dbst->dbp, &key, &data, depart));
	if (ret == DB_NOTFOUND) break;
	rb_ary_push(res, bdb1_test_load(obj, &data, FILTER_VALUE));
	bdb1_test_error(dbst->dbp->del(dbst->dbp, 0, R_CURSOR));
	if (dbst->len > 0) dbst->len--;
    }
    if (RARRAY_LEN(res) == 0) return Qnil;
    else if (RARRAY_LEN(res) == 1) return RARRAY_PTR(res)[0];
    else return res;
}

static void
bdb1_sary_replace(VALUE obj, long beg, long len, VALUE rpl)
{
    long i, j, rlen;
    VALUE tmp[2];
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (len < 0) rb_raise(rb_eIndexError, "negative length %d", len);
    if (beg < 0) {
	beg += dbst->len;
    }
    if (beg < 0) {
	beg -= dbst->len;
	rb_raise(rb_eIndexError, "index %d out of array", beg);
    }
    if (beg + len > dbst->len) {
	len = dbst->len - beg;
    }

    if (NIL_P(rpl)) {
	rpl = rb_ary_new2(0);
    }
    else if (TYPE(rpl) != T_ARRAY) {
	rpl = rb_ary_new3(1, rpl);
    }
    rlen = RARRAY_LEN(rpl);

    tmp[1] = Qnil;
    if (beg >= dbst->len) {
	for (i = dbst->len; i < beg; i++) {
	    tmp[0] = INT2NUM(i);
	    bdb1_put(2, tmp, obj);
	    dbst->len++;
	}
	for (i = beg, j = 0; j < RARRAY_LEN(rpl); i++, j++) {
	    tmp[0] = INT2NUM(i);
	    tmp[1] = RARRAY_PTR(rpl)[j];
	    bdb1_put(2, tmp, obj);
	    dbst->len++;
	}
    }
    else {
	if (len < rlen) {
	    tmp[1] = Qnil;
	    for (i = dbst->len - 1; i >= (beg + len); i--) {
		tmp[0] = INT2NUM(i);
		tmp[1] = bdb1_get(1, tmp, obj);
		tmp[0] = INT2NUM(i + rlen - len);
		bdb1_put(2, tmp, obj);
	    }
	    dbst->len += rlen - len;
	}
	for (i = beg, j = 0; j < rlen; i++, j++) {
	    tmp[0] = INT2NUM(i);
	    tmp[1] = RARRAY_PTR(rpl)[j];
	    bdb1_put(2, tmp, obj);
	}
	if (len > rlen) {
	    for (i = beg + len; i < dbst->len; i++) {
		tmp[0] = INT2NUM(i);
		tmp[1] = bdb1_get(1, tmp, obj);
		tmp[0] = INT2NUM(i + rlen - len);
		bdb1_put(2, tmp, obj);
	    }
	    bdb1_intern_shift_pop(obj, DB_LAST, len - rlen);
	}
    }
}

/*
 * call-seq:
 *   db[nth] = val
 *   db[start..end] = val
 *   db[start, length] = val
 *
 * Element assignment - with the following syntax:
 *
 * * db[nth] = val
 *   Changes the +nth+ element of the array into +val+.  If +nth+ is
 *   larger than array length, the array shall be extended
 *   automatically.  Extended region shall be initialized by +nil+.
 *
 * * db[start..end] = val
 *   Replaces the items from +start+ to +end+ with +val+.  If +val+ is
 *   not an array, the type of +val+ will be converted into the Array
 *   using +to_a+ method.
 *
 * * db[start, length] = val
 *   Replaces the +length+ items from +start+ with +val+.  If +val+ is
 *   not an array, the type of +val+ will be converted into the Array
 *   using +to_a+.
 */
static VALUE
bdb1_sary_aset(int argc, VALUE *argv, VALUE obj)
{
    long  beg, len;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (argc == 3) {
	bdb1_sary_replace(obj, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
	return argv[2];
    }
    if (argc != 2) {
	rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)", argc);
    }
    if (FIXNUM_P(argv[0])) {
	beg = FIX2LONG(argv[0]);
	goto fixnum;
    }
    else if (rb_range_beg_len(argv[0], &beg, &len, dbst->len, 1)) {
	bdb1_sary_replace(obj, beg, len, argv[1]);
	return argv[1];
    }
    if (TYPE(argv[0]) == T_BIGNUM) {
	rb_raise(rb_eIndexError, "index too big");
    }

    beg = NUM2LONG(argv[0]);
  fixnum:
    if (beg < 0) {
	beg += dbst->len;
	if (beg < 0) {
	    rb_raise(rb_eIndexError, "index %d out of array",
		     beg - dbst->len);
	}
    }
    if (beg > dbst->len) {
	VALUE nargv[2];
	int i;

	nargv[1] = Qnil;
	for (i = dbst->len; i < beg; i++) {
	    nargv[0] = INT2NUM(i);
	    bdb1_put(2, nargv, obj);
	    dbst->len++;
	}
    }
    argv[0] = INT2NUM(beg);
    bdb1_put(2, argv, obj);
    dbst->len++;
    return argv[1];
}

static VALUE
bdb1_sary_insert(int argc, VALUE *argv, VALUE obj)
{
    long pos;

    if (argc < 2) {
	rb_raise(rb_eArgError, "wrong number of arguments(at least 2)");
    }
    pos = NUM2LONG(argv[0]);
    if (pos == -1) {
	bdb1_DB *dbst;

	GetDB(obj, dbst);
 	pos = dbst->len;
    }
    else if (pos < 0) {
	pos++;
    }

    bdb1_sary_replace(obj, pos, 0, rb_ary_new4(argc-1, argv+1));
    return obj;
}

static VALUE
bdb1_sary_at(VALUE obj, VALUE pos)
{
    return bdb1_sary_entry(obj, pos);
}

static VALUE
bdb1_sary_first(VALUE obj)
{
    bdb1_DB *dbst;
    VALUE tmp;

    GetDB(obj, dbst);
    tmp = INT2NUM(0);
    return bdb1_get(1, &tmp, obj);
}

static VALUE
bdb1_sary_last(VALUE obj)
{
    bdb1_DB *dbst;
    VALUE tmp;

    GetDB(obj, dbst);
    if (!dbst->len) return Qnil;
    tmp = INT2NUM(dbst->len - 1);
    return bdb1_get(1, &tmp, obj);
}

static VALUE
bdb1_sary_fetch(int argc, VALUE *argv, VALUE obj)
{
    VALUE pos, ifnone;
    bdb1_DB *dbst;
    long idx;

    GetDB(obj, dbst);
    rb_scan_args(argc, argv, "11", &pos, &ifnone);
    idx = NUM2LONG(pos);

    if (idx < 0) {
	idx +=  dbst->len;
    }
    if (idx < 0 || dbst->len <= idx) {
	return ifnone;
    }
    pos = INT2NUM(idx);
    return bdb1_get(1, &pos, obj);
}


static VALUE
bdb1_sary_concat(VALUE obj, VALUE y)
{
    bdb1_DB *dbst;
    long i;
    VALUE tmp[2];

    y = rb_convert_type(y, T_ARRAY, "Array", "to_ary");
    GetDB(obj, dbst);
    for (i = 0; i < RARRAY_LEN(y); i++) {
	tmp[0] = INT2NUM(dbst->len);
	tmp[1] = RARRAY_PTR(y)[i];
	bdb1_put(2, tmp, obj);
	dbst->len++;
    }
    return obj;
}

static VALUE
bdb1_sary_push(VALUE obj, VALUE y)
{
    bdb1_DB *dbst;
    VALUE tmp[2];

    GetDB(obj, dbst);
    tmp[0] = INT2NUM(dbst->len);
    tmp[1] = y;
    bdb1_put(2, tmp, obj);
    dbst->len++;
    return obj;
}

static VALUE
bdb1_sary_push_m(int argc, VALUE *argv, VALUE obj)
{
    bdb1_DB *dbst;
    long i;
    VALUE tmp[2];

    if (argc == 0) {
	rb_raise(rb_eArgError, "wrong # of arguments(at least 1)");
    }
    if (argc > 0) {
	GetDB(obj, dbst);
	for (i = 0; i < argc; i++) {
	    tmp[0] = INT2NUM(dbst->len);
	    tmp[1] = argv[i];
	    bdb1_put(2, tmp, obj);
	    dbst->len++;
	}
    }
    return obj;
}

static VALUE
bdb1_sary_s_create(int argc, VALUE *argv, VALUE obj)
{
    VALUE res;
    int i;

    res = rb_funcall2(obj, rb_intern("new"), 0, 0);
    if (argc < 0) {
        rb_raise(rb_eArgError, "negative number of arguments");
    }
    if (argc > 0) {
	bdb1_sary_push_m(argc, argv, res);
    }
    return res;
}

static VALUE
bdb1_sary_shift(VALUE obj)
{
    VALUE res;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (dbst->len == 0) return Qnil;
    res = bdb1_intern_shift_pop(obj, DB_FIRST, 1);
    return res;
}

static VALUE
bdb1_sary_pop(VALUE obj)
{
    VALUE res;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (dbst->len == 0) return Qnil;
    res = bdb1_intern_shift_pop(obj, DB_LAST, 1);
    return res;
}

static VALUE
bdb1_sary_unshift_m(int argc, VALUE *argv, VALUE obj)
{
    bdb1_DB *dbst;
    VALUE tmp[3];
    long i;

    if (argc == 0) {
	rb_raise(rb_eArgError, "wrong # of arguments(at least 1)");
    }
    if (argc > 0) {
	GetDB(obj, dbst);
	tmp[0] = INT2NUM(0);
	tmp[2] = INT2NUM(R_IBEFORE);
	for (i = argc - 1; i >= 0; i--) {
	    tmp[1] = argv[i];
	    bdb1_put(3, tmp, obj);
	    dbst->len++;
	}
    }
    return obj;
}

static VALUE
bdb1_sary_length(VALUE obj)
{
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (dbst->len < 0) rb_raise(bdb1_eFatal, "Invalid BDB::Recnum");
    return INT2NUM(dbst->len);
}

static VALUE
bdb1_sary_empty_p(VALUE obj)
{
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (dbst->len < 0) rb_raise(bdb1_eFatal, "Invalid BDB::Recnum");
    return dbst->len == 0 ? Qtrue : Qfalse;
}

static VALUE
bdb1_sary_rindex(VALUE obj, VALUE a)
{
    return bdb1_internal_value(obj, a, Qtrue, DB_PREV);
}

static VALUE
bdb1_sary_to_a(VALUE obj)
{
    return bdb1_to_type(obj, rb_ary_new(), Qfalse);
}

static VALUE
bdb1_sary_reverse_m(VALUE obj)
{
    return bdb1_to_type(obj, rb_ary_new(), Qnil);
}

static VALUE
bdb1_sary_reverse_bang(VALUE obj)
{
    long i, j;
    bdb1_DB *dbst;
    VALUE tmp[2], interm;

    GetDB(obj, dbst);
    if (dbst->len <= 1) return obj;
    i = 0;
    j = dbst->len - 1;
    while (i < j) {
	tmp[0] = INT2NUM(i);
	interm = bdb1_get(1, tmp, obj);
	tmp[0] = INT2NUM(j);
	tmp[1] = bdb1_get(1, tmp, obj);
	tmp[0] = INT2NUM(i);
	bdb1_put(2, tmp, obj);
	tmp[0] = INT2NUM(j);
	tmp[1] = interm;
	bdb1_put(2, tmp, obj);
	i++; j--;
    }
    return obj;
}

static VALUE
bdb1_sary_collect_bang(VALUE obj)
{
    return bdb1_each_vc(obj, Qtrue, Qfalse);
}

static VALUE
bdb1_sary_collect(VALUE obj)
{
    if (!rb_block_given_p()) {
	return bdb1_sary_to_a(obj);
    }
    return bdb1_each_vc(obj, Qfalse, Qfalse);
}

static VALUE
bdb1_sary_values_at(int argc, VALUE *argv, VALUE obj)
{
    VALUE result;
    long i;

    result = rb_ary_new();
    for (i = 0; i < argc; i++) {
	rb_ary_push(result, bdb1_sary_fetch(1, argv + i, obj));
    }
    return result;
}

static VALUE
bdb1_sary_select(VALUE obj)
{
    if (rb_block_given_p()) {
	return bdb1_each_vc(obj, Qfalse, Qtrue);
    }
    rb_raise(rb_eArgError, "block is not given");
}

static VALUE
bdb1_sary_filter(VALUE obj)
{
    rb_warn("BDB1::Recnum#filter is deprecated; use BDB1::Recnum#collect!");
    return bdb1_sary_collect_bang(obj);
}

static VALUE
bdb1_sary_delete(VALUE obj, VALUE item)
{
    bdb1_DB *dbst;
    long i1, i2;
    VALUE tmp, a;

    GetDB(obj, dbst);
    i2 = dbst->len;
    for (i1 = 0; i1 < dbst->len;) {
	tmp = INT2NUM(i1);
	a = bdb1_get(1, &tmp, obj);
	if (rb_equal(a, item)) {
	    bdb1_del(obj, INT2NUM(i1));
	    dbst->len--;
	}
	else {
	    i1++;
	}
    }
    if (dbst->len == i2) {
	if (rb_block_given_p()) {
	    return rb_yield(item);
	}
	return Qnil;
    }
    return item;
}

static VALUE
bdb1_sary_delete_at_m(VALUE obj, VALUE a)
{
    bdb1_DB *dbst;
    long pos;
    VALUE tmp;
    VALUE del = Qnil;

    GetDB(obj, dbst);
    pos = NUM2INT(a);
    if (pos >= dbst->len) return Qnil;
    if (pos < 0) pos += dbst->len;
    if (pos < 0) return Qnil;

    tmp = INT2NUM(pos);
    del = bdb1_get(1, &tmp, obj);
    bdb1_del(obj, tmp);
    dbst->len--;
    return del;
}

static VALUE
bdb1_sary_reject_bang(VALUE obj)
{
    bdb1_DB *dbst;
    long i1, i2;
    VALUE tmp, a;

    GetDB(obj, dbst);
    i2 = dbst->len;
    for (i1 = 0; i1 < dbst->len;) {
	tmp = INT2NUM(i1);
	a = bdb1_get(1, &tmp, obj);
	if (!RTEST(rb_yield(a))) {
	    i1++;
	    continue;
	}
	bdb1_del(obj, tmp);
	dbst->len--;
    }
    if (dbst->len == i2) return Qnil;
    return obj;
}

static VALUE
bdb1_sary_delete_if(VALUE obj)
{
    bdb1_sary_reject_bang(obj);
    return obj;
}

static VALUE
bdb1_sary_replace_m(VALUE obj, VALUE obj2)
{
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    obj2 = rb_convert_type(obj2, T_ARRAY, "Array", "to_ary");
    bdb1_sary_replace(obj, 0, dbst->len, obj2);
    return obj;
}

static VALUE
bdb1_sary_clear(VALUE obj)
{
    bdb1_DB *dbst;
    bdb1_clear(obj);
    GetDB(obj, dbst);
    dbst->len = 0;
    return obj;
}

static VALUE
bdb1_sary_fill(int argc, VALUE *argv, VALUE obj)
{
    VALUE item, arg1, arg2, tmp[2];
    long beg, len, i;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    rb_scan_args(argc, argv, "12", &item, &arg1, &arg2);
    switch (argc) {
      case 1:
	  len = dbst->len;
	  beg = 0;
	  break;
      case 2:
	if (rb_range_beg_len(arg1, &beg, &len, dbst->len, 1)) {
	    break;
	}
	/* fall through */
      case 3:
	beg = NIL_P(arg1)?0:NUM2LONG(arg1);
	if (beg < 0) {
	    beg += dbst->len;
	    if (beg < 0) beg = 0;
	}
	len = NIL_P(arg2)?dbst->len - beg:NUM2LONG(arg2);
	break;
    }
    tmp[1] = item;
    for (i = 0; i < len; i++) {
	tmp[0] = INT2NUM(i + beg);
	bdb1_put(2, tmp, obj);
	if ((i + beg) >= dbst->len) dbst->len++;
    }
    return obj;
}

static VALUE
bdb1_sary_cmp(VALUE obj, VALUE obj2)
{
    bdb1_DB *dbst, *dbst2;
    VALUE a, a2, tmp;
    int ary;
    long i, len;

    if (obj == obj2) return INT2FIX(0);
    GetDB(obj, dbst);
    len = dbst->len;
    if (!rb_obj_is_kind_of(obj2, bdb1_cRecnum)) {
	obj2 = rb_convert_type(obj2, T_ARRAY, "Array", "to_ary");
	if (len > RARRAY_LEN(obj2)) {
	    len = RARRAY_LEN(obj2);
	}
	ary = 1;
    }
    else {
	GetDB(obj2, dbst2);
	if (len > dbst2->len) {
	    len = dbst2->len;
	}
	ary = 0;
    }
    for (i = 0; i < len; i++) {
	tmp = INT2NUM(i);
	a = bdb1_get(1, &tmp, obj);
	if (ary) {
	    a2 = RARRAY_PTR(obj2)[i];
	}
	else {
	    a2 = bdb1_get(1, &tmp, obj2);
	}
	tmp = rb_funcall(a, id_cmp, 1, a2);
	if (tmp != INT2FIX(0)) {
	    return tmp;
	}
    }
    len = dbst->len - (ary ? RARRAY_LEN(obj2) : dbst2->len);
    if (len == 0) return INT2FIX(0);
    if (len > 0) return INT2FIX(1);
    return INT2FIX(-1);
}

static VALUE
bdb1_sary_slice_bang(int argc, VALUE *argv, VALUE obj)
{
    VALUE arg1, arg2;
    long pos, len;
    bdb1_DB *dbst;

    GetDB(obj, dbst);
    if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
	pos = NUM2LONG(arg1);
	len = NUM2LONG(arg2);
      delete_pos_len:
	if (pos < 0) {
	    pos = dbst->len + pos;
	}
	arg2 = bdb1_sary_subseq(obj, pos, len);
	bdb1_sary_replace(obj, pos, len, Qnil);
	return arg2;
    }

    if (!FIXNUM_P(arg1) && rb_range_beg_len(arg1, &pos, &len, dbst->len, 1)) {
	goto delete_pos_len;
    }

    pos = NUM2LONG(arg1);
    if (pos >= dbst->len) return Qnil;
    if (pos < 0) pos += dbst->len;
    if (pos < 0) return Qnil;

    arg1 = INT2NUM(pos);
    arg2 = bdb1_sary_at(obj, arg1);
    if (bdb1_del(obj, arg1) != Qnil) dbst->len--;
    return arg2;
}

static VALUE
bdb1_sary_plus(VALUE obj, VALUE y)
{
    return rb_ary_plus(bdb1_sary_to_a(obj), y);
}

static VALUE
bdb1_sary_times(VALUE obj, VALUE y)
{
    return rb_funcall(bdb1_sary_to_a(obj), rb_intern("*"), 1, y);
}

static VALUE
bdb1_sary_diff(VALUE obj, VALUE y)
{
    return rb_funcall(bdb1_sary_to_a(obj), rb_intern("-"), 1, y);
}

static VALUE
bdb1_sary_and(VALUE obj, VALUE y)
{
    return rb_funcall(bdb1_sary_to_a(obj), rb_intern("&"), 1, y);
}

static VALUE
bdb1_sary_or(VALUE obj, VALUE y)
{
    return rb_funcall(bdb1_sary_to_a(obj), rb_intern("|"), 1, y);
}

static VALUE
bdb1_sary_compact(VALUE obj)
{
    return rb_funcall(bdb1_sary_to_a(obj), rb_intern("compact"), 0, 0);
}

static VALUE
bdb1_sary_compact_bang(VALUE obj)
{
    bdb1_DB *dbst;
    long i, j;
    VALUE tmp;

    GetDB(obj, dbst);
    j = dbst->len;
    for (i = 0; i < dbst->len; ) {
	tmp = INT2NUM(i);
	tmp = bdb1_get(1, &tmp, obj);
	if (NIL_P(tmp)) {
	    bdb1_del(obj, INT2NUM(i));
	    dbst->len--;
	}
	else {
	    i++;
	}
    }
    if (dbst->len == j) return Qnil;
    return obj;
}

static VALUE
bdb1_sary_nitems(VALUE obj)
{
    bdb1_DB *dbst;
    long i, j;
    VALUE tmp;

    GetDB(obj, dbst);
    j = 0;
    for (i = 0; i < dbst->len; i++) {
	tmp = INT2NUM(i);
	tmp = bdb1_get(1, &tmp, obj);
	if (!NIL_P(tmp)) j++;
    }
    return INT2NUM(j);
}

static VALUE
bdb1_sary_each_index(VALUE obj)
{
    bdb1_DB *dbst;
    long i;

    GetDB(obj, dbst);
    for (i = 0; i< dbst->len; i++) {
	rb_yield(INT2NUM(i));
    }
    return obj;
}

void
bdb1_init_recnum(void)
{
    id_cmp = rb_intern("<=>");
    bdb1_cRecnum = rb_define_class_under(bdb1_mDb, "Recnum", bdb1_cCommon);
    rb_define_singleton_method(bdb1_cRecnum, "[]", bdb1_sary_s_create, -1);
    rb_const_set(bdb1_mDb, rb_intern("Recno"), bdb1_cRecnum);
    rb_define_private_method(bdb1_cRecnum, "initialize", bdb1_recnum_init, -1);
    rb_define_method(bdb1_cRecnum, "[]", bdb1_sary_aref, -1);
    rb_define_method(bdb1_cRecnum, "[]=", bdb1_sary_aset, -1);
    rb_define_method(bdb1_cRecnum, "at", bdb1_sary_at, 1);
    rb_define_method(bdb1_cRecnum, "fetch", bdb1_sary_fetch, -1);
    rb_define_method(bdb1_cRecnum, "first", bdb1_sary_first, 0);
    rb_define_method(bdb1_cRecnum, "last", bdb1_sary_last, 0);
    rb_define_method(bdb1_cRecnum, "concat", bdb1_sary_concat, 1);
    rb_define_method(bdb1_cRecnum, "<<", bdb1_sary_push, 1);
    rb_define_method(bdb1_cRecnum, "push", bdb1_sary_push_m, -1);
    rb_define_method(bdb1_cRecnum, "pop", bdb1_sary_pop, 0);
    rb_define_method(bdb1_cRecnum, "shift", bdb1_sary_shift, 0);
    rb_define_method(bdb1_cRecnum, "unshift", bdb1_sary_unshift_m, -1);
    rb_define_method(bdb1_cRecnum, "insert", bdb1_sary_insert, -1);
    rb_define_method(bdb1_cRecnum, "each", bdb1_each_value, 0);
    rb_define_method(bdb1_cRecnum, "each_index", bdb1_sary_each_index, 0);
    rb_define_method(bdb1_cRecnum, "reverse_each", bdb1_each_eulav, 0);
    rb_define_method(bdb1_cRecnum, "length", bdb1_sary_length, 0);
    rb_define_alias(bdb1_cRecnum,  "size", "length");
    rb_define_method(bdb1_cRecnum, "empty?", bdb1_sary_empty_p, 0);
    rb_define_method(bdb1_cRecnum, "key", bdb1_key, 1);
    rb_define_method(bdb1_cRecnum, "index", bdb1_key, 1);
    rb_define_method(bdb1_cRecnum, "rindex", bdb1_sary_rindex, 1);
    rb_define_method(bdb1_cRecnum, "reverse", bdb1_sary_reverse_m, 0);
    rb_define_method(bdb1_cRecnum, "reverse!", bdb1_sary_reverse_bang, 0);
    rb_define_method(bdb1_cRecnum, "collect", bdb1_sary_collect, 0);
    rb_define_method(bdb1_cRecnum, "collect!", bdb1_sary_collect_bang, 0);
    rb_define_method(bdb1_cRecnum, "map", bdb1_sary_collect, 0);
    rb_define_method(bdb1_cRecnum, "values_at", bdb1_sary_values_at, -1);
    rb_define_method(bdb1_cRecnum, "select", bdb1_sary_select, 0);
    rb_define_method(bdb1_cRecnum, "map!", bdb1_sary_collect_bang, 0);
    rb_define_method(bdb1_cRecnum, "filter", bdb1_sary_filter, 0);
    rb_define_method(bdb1_cRecnum, "delete", bdb1_sary_delete, 1);
    rb_define_method(bdb1_cRecnum, "delete_at", bdb1_sary_delete_at_m, 1);
    rb_define_method(bdb1_cRecnum, "delete_if", bdb1_sary_delete_if, 0);
    rb_define_method(bdb1_cRecnum, "reject!", bdb1_sary_reject_bang, 0);
    rb_define_method(bdb1_cRecnum, "replace", bdb1_sary_replace_m, 1);
    rb_define_method(bdb1_cRecnum, "clear", bdb1_sary_clear, 0);
    rb_define_method(bdb1_cRecnum, "fill", bdb1_sary_fill, -1);
    rb_define_method(bdb1_cRecnum, "include?", bdb1_has_value, 1);
    rb_define_method(bdb1_cRecnum, "<=>", bdb1_sary_cmp, 1);
    rb_define_method(bdb1_cRecnum, "slice", bdb1_sary_aref, -1);
    rb_define_method(bdb1_cRecnum, "slice!", bdb1_sary_slice_bang, -1);
/*
    rb_define_method(bdb1_cRecnum, "assoc", bdb1_sary_assoc, 1);
    rb_define_method(bdb1_cRecnum, "rassoc", bdb1_sary_rassoc, 1);
*/
    rb_define_method(bdb1_cRecnum, "+", bdb1_sary_plus, 1);
    rb_define_method(bdb1_cRecnum, "*", bdb1_sary_times, 1);

    rb_define_method(bdb1_cRecnum, "-", bdb1_sary_diff, 1);
    rb_define_method(bdb1_cRecnum, "&", bdb1_sary_and, 1);
    rb_define_method(bdb1_cRecnum, "|", bdb1_sary_or, 1);

/*
    rb_define_method(bdb1_cRecnum, "uniq", bdb1_sary_uniq, 0);
    rb_define_method(bdb1_cRecnum, "uniq!", bdb1_sary_uniq_bang, 0);
*/
    rb_define_method(bdb1_cRecnum, "compact", bdb1_sary_compact, 0);
    rb_define_method(bdb1_cRecnum, "compact!", bdb1_sary_compact_bang, 0);
/*
    rb_define_method(bdb1_cRecnum, "flatten", bdb1_sary_flatten, 0);
    rb_define_method(bdb1_cRecnum, "flatten!", bdb1_sary_flatten_bang, 0);
*/
    rb_define_method(bdb1_cRecnum, "nitems", bdb1_sary_nitems, 0);
    rb_define_method(bdb1_cRecnum, "to_a", bdb1_sary_to_a, 0);
    rb_define_method(bdb1_cRecnum, "to_ary", bdb1_sary_to_a, 0);
}