зеркало из https://github.com/github/ruby.git
2000-05-24
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@710 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
Родитель
24b9bdca25
Коммит
8b1de0b1ad
93
ChangeLog
93
ChangeLog
|
@ -1,3 +1,40 @@
|
|||
Wed May 24 13:12:31 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* misc/ruby-mode.el (ruby-parse-region): support `while .. do' etc.
|
||||
|
||||
Tue May 23 23:50:12 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* re.c (rb_reg_initialize_m): wrong kcode value.
|
||||
|
||||
* re.c (rb_reg_s_new): forgot to initialize re->ptr.
|
||||
|
||||
Tue May 23 08:36:24 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* regex.c (re_compile_pattern): forgot to restore old option
|
||||
status by (?ix-ix).
|
||||
|
||||
* regex.c (re_compile_fastmap): anychar may match newline if
|
||||
RE_OPTION_MULTILINE or RE_OPTION_POSIXLINE is set.
|
||||
|
||||
Mon May 22 21:56:43 2000 Nobuyoshi Nakada <nobu.nakada@nifty.ne.jp>
|
||||
|
||||
* struct.c (rb_struct_getmember): should use ID2SYM, not INT2NUM.
|
||||
|
||||
Mon May 22 15:07:37 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* file.c (rb_find_file): should check if the file really exists.
|
||||
|
||||
Mon May 22 09:08:12 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* io.c (rb_io_popen): _exit(0) after processing block under the
|
||||
child process.
|
||||
|
||||
* io.c (rb_io_popen): flush stdout/stderr before subprocess
|
||||
termination.
|
||||
|
||||
* eval.c (rb_check_safe_str): insert rb_secure(4); operation
|
||||
requires untainted string should be prohibited in level 4.
|
||||
|
||||
Sun May 21 21:17:00 2000 WATANABE Hirofumi <eban@os.rim.or.jp>
|
||||
|
||||
* configure.in: add Setup.dj for djgpp cross-compiling.
|
||||
|
@ -6,6 +43,10 @@ Sun May 21 21:17:00 2000 WATANABE Hirofumi <eban@os.rim.or.jp>
|
|||
|
||||
* instruby.rb: copy win32/win32.h to archlibdir on mingw32.
|
||||
|
||||
Sun May 21 20:58:08 2000 Katsuyuki Komatsu <komatsu@sarion.co.jp>
|
||||
|
||||
* pack.c: fix OFF16 and OFF32 definitions for Alpha and IRIX64.
|
||||
|
||||
Sun May 21 17:31:37 2000 WATANABE Hirofumi <eban@os.rim.or.jp>
|
||||
|
||||
* instruby.rb: support "make install" for cross-compiling.
|
||||
|
@ -18,6 +59,53 @@ Sun May 21 14:22:49 2000 WATANABE Hirofumi <eban@os.rim.or.jp>
|
|||
|
||||
* configure.in: ditto.
|
||||
|
||||
Sat May 20 23:29:14 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* dir.c (dir_s_new): does not take block; "open" does.
|
||||
|
||||
* io.c (rb_io_s_new): ditto.
|
||||
|
||||
Fri May 19 07:44:26 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* dir.c (dir_s_open): Dir#open does not returns closed Dir if a
|
||||
block is given to the method.
|
||||
|
||||
* re.c (rb_reg_initialize_m): Regexp::new calls initialize now.
|
||||
|
||||
* string.c (Init_String): String#delete_at removed.
|
||||
|
||||
* string.c (rb_str_aset_m): should have checked argc != 2.
|
||||
|
||||
* eval.c (rb_thread_schedule): select(2) was called too many.
|
||||
|
||||
* regex.c (re_compile_pattern): a bug in (?m) support. Pointed
|
||||
out by Dave Thomas <Dave@thomases.com>.
|
||||
|
||||
Thu May 18 23:55:26 2000 Katsuyuki Komatsu <komatsu@sarion.co.jp>
|
||||
|
||||
* dln.c (search_undef): st_lookup()'s 3rd parameter should be
|
||||
a pointer of the variable which has the same size and alignment
|
||||
as `char *'.
|
||||
|
||||
* marshal.c (w_symbol, w_object): ditto.
|
||||
|
||||
* parse.y (rb_intern): ditto.
|
||||
|
||||
Thu May 18 13:34:57 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* ext/socket/socket.c (ruby_connect): should not have replaced
|
||||
thread_write_select() by rb_thread_fd_writable().
|
||||
|
||||
Wed May 18 09:01:25 2000 Katsuyuki Komatsu <komatsu@sarion.co.jp>
|
||||
|
||||
* configure.in, ext/extmk.rb.in, lib/mkmf.rb: remove BeOS R3 support.
|
||||
Make a shared library (libruby.so) only if the --enable-shared
|
||||
option is specified.
|
||||
|
||||
* instruby.rb: no longer use libruby.so.LIB and import.h.
|
||||
|
||||
* io.c: fix READ_DATA_PENDING definition for BeOS (PowerPC).
|
||||
|
||||
Wed May 17 14:14:23 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* re.c (rb_reg_new_1): use /m instead of /p.
|
||||
|
@ -71,6 +159,11 @@ Mon May 15 15:38:09 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
|||
|
||||
* dir.c (glob): trailing path may be null, e.g. glob("**").
|
||||
|
||||
Mon May 15 14:48:41 2000 Nobuyoshi Nakada <nobu.nakada@nifty.ne.jp>
|
||||
|
||||
* io.c (rb_io_pid): new method; returns nil if no process attached
|
||||
to the IO.
|
||||
|
||||
Mon May 15 01:18:20 2000 Yukihiro Matsumoto <matz@netlab.co.jp>
|
||||
|
||||
* io.c (rb_io_s_popen): _exit after Proc execution.
|
||||
|
|
4
ToDo
4
ToDo
|
@ -63,7 +63,7 @@ Standard Libraries
|
|||
- Struct::new([name,]member,...)
|
||||
- IO#reopen accepts path as well
|
||||
- Kernel#scan
|
||||
- call initialize for builtin classes too (not yet: Regexp, Class, Module)
|
||||
- call initialize for builtin classes too (not yet: Class, Module)
|
||||
- performance tune for String's non-bang methods.
|
||||
- 'w' template for pack/unpack
|
||||
* String#scanf(?)
|
||||
|
@ -107,6 +107,6 @@ Things To Do Before 1.6
|
|||
|
||||
* alternative for $! (exception? in? into? =>?)
|
||||
* alternative for interator?
|
||||
* regex - /p, /m
|
||||
- regex - /p, /m
|
||||
* odd? even?
|
||||
* mkmf.rb - create_makefile("net/socket")
|
||||
|
|
40
array.c
40
array.c
|
@ -584,30 +584,32 @@ rb_ary_aset(argc, argv, ary)
|
|||
VALUE *argv;
|
||||
VALUE ary;
|
||||
{
|
||||
VALUE arg1, arg2, arg3;
|
||||
long offset, beg, len;
|
||||
|
||||
if (rb_scan_args(argc, argv, "21", &arg1, &arg2, &arg3) == 3) {
|
||||
rb_ary_replace(ary, NUM2LONG(arg1), NUM2LONG(arg2), arg3);
|
||||
return arg3;
|
||||
if (argc == 3) {
|
||||
rb_ary_replace(ary, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
|
||||
return argv[2];
|
||||
}
|
||||
else if (FIXNUM_P(arg1)) {
|
||||
offset = FIX2LONG(arg1);
|
||||
if (argc != 2) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)", argc);
|
||||
}
|
||||
if (FIXNUM_P(argv[0])) {
|
||||
offset = FIX2LONG(argv[0]);
|
||||
goto fixnum;
|
||||
}
|
||||
else if (rb_range_beg_len(arg1, &beg, &len, RARRAY(ary)->len, 1)) {
|
||||
else if (rb_range_beg_len(argv[0], &beg, &len, RARRAY(ary)->len, 1)) {
|
||||
/* check if idx is Range */
|
||||
rb_ary_replace(ary, beg, len, arg2);
|
||||
return arg2;
|
||||
rb_ary_replace(ary, beg, len, argv[1]);
|
||||
return argv[1];
|
||||
}
|
||||
if (TYPE(arg1) == T_BIGNUM) {
|
||||
if (TYPE(argv[0]) == T_BIGNUM) {
|
||||
rb_raise(rb_eIndexError, "index too big");
|
||||
}
|
||||
|
||||
offset = NUM2LONG(arg1);
|
||||
offset = NUM2LONG(argv[0]);
|
||||
fixnum:
|
||||
rb_ary_store(ary, offset, arg2);
|
||||
return arg2;
|
||||
rb_ary_store(ary, offset, argv[1]);
|
||||
return argv[1];
|
||||
}
|
||||
|
||||
VALUE
|
||||
|
@ -957,7 +959,7 @@ sort_internal(ary)
|
|||
VALUE ary;
|
||||
{
|
||||
qsort(RARRAY(ary)->ptr, RARRAY(ary)->len, sizeof(VALUE),
|
||||
rb_iterator_p()?sort_1:sort_2);
|
||||
rb_block_given_p()?sort_1:sort_2);
|
||||
return ary;
|
||||
}
|
||||
|
||||
|
@ -997,7 +999,7 @@ rb_ary_collect(ary)
|
|||
long len, i;
|
||||
VALUE collect;
|
||||
|
||||
if (!rb_iterator_p()) {
|
||||
if (!rb_block_given_p()) {
|
||||
return rb_ary_dup(ary);
|
||||
}
|
||||
|
||||
|
@ -1046,7 +1048,7 @@ rb_ary_delete(ary, item)
|
|||
i2++;
|
||||
}
|
||||
if (RARRAY(ary)->len == i2) {
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
return rb_yield(item);
|
||||
}
|
||||
return Qnil;
|
||||
|
@ -1081,7 +1083,7 @@ rb_ary_delete_at(ary, pos)
|
|||
}
|
||||
|
||||
static VALUE
|
||||
rb_ary_delete_at_m(argc, argv, ary)
|
||||
rb_ary_slice_bang(argc, argv, ary)
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE ary;
|
||||
|
@ -1627,7 +1629,7 @@ Init_Array()
|
|||
rb_define_method(rb_cArray, "map!", rb_ary_collect_bang, 0);
|
||||
rb_define_method(rb_cArray, "filter", rb_ary_filter, 0);
|
||||
rb_define_method(rb_cArray, "delete", rb_ary_delete, 1);
|
||||
rb_define_method(rb_cArray, "delete_at", rb_ary_delete_at_m, -1);
|
||||
rb_define_method(rb_cArray, "delete_at", rb_ary_delete_at, -1);
|
||||
rb_define_method(rb_cArray, "delete_if", rb_ary_delete_if, 0);
|
||||
rb_define_method(rb_cArray, "reject!", rb_ary_delete_if, 0);
|
||||
rb_define_method(rb_cArray, "replace", rb_ary_replace_m, 1);
|
||||
|
@ -1637,7 +1639,7 @@ Init_Array()
|
|||
rb_define_method(rb_cArray, "<=>", rb_ary_cmp, 1);
|
||||
|
||||
rb_define_method(rb_cArray, "slice", rb_ary_aref, -1);
|
||||
rb_define_method(rb_cArray, "slice!", rb_ary_delete_at_m, -1);
|
||||
rb_define_method(rb_cArray, "slice!", rb_ary_slice_bang, -1);
|
||||
|
||||
rb_define_method(rb_cArray, "assoc", rb_ary_assoc, 1);
|
||||
rb_define_method(rb_cArray, "rassoc", rb_ary_rassoc, 1);
|
||||
|
|
2
class.c
2
class.c
|
@ -662,7 +662,7 @@ rb_scan_args(argc, argv, fmt, va_alist)
|
|||
|
||||
if (*p == '&') {
|
||||
var = va_arg(vargs, VALUE*);
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
*var = rb_f_lambda();
|
||||
}
|
||||
else {
|
||||
|
|
|
@ -969,10 +969,6 @@ EOF
|
|||
*:Rhapsody:*:*)
|
||||
echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
|
||||
exit 0 ;;
|
||||
*:"Mac OS":*:*)
|
||||
echo `uname -p`-apple-macos${UNAME_RELEASE}
|
||||
exit 0 ;;
|
||||
|
||||
esac
|
||||
|
||||
#echo '(No uname command or uname output not recognized.)' 1>&2
|
||||
|
|
|
@ -910,7 +910,7 @@ case $os in
|
|||
| -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
|
||||
| -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
|
||||
| -mingw32* | -linux* | -uxpv* | -beos* | -mpeix* | -udk* \
|
||||
| -interix* | -uwin* | -rhapsody* | -openstep* | -macos | -oskit*)
|
||||
| -interix* | -uwin* | -rhapsody* | -openstep* | -oskit*)
|
||||
# Remember, each alternative MUST END IN *, to match a version number.
|
||||
;;
|
||||
-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
|
||||
|
|
56
configure.in
56
configure.in
|
@ -44,12 +44,6 @@ AC_ARG_ENABLE(fat-binary,
|
|||
TARGET_ARCHS="ppc i386"
|
||||
fi
|
||||
;;
|
||||
macos*)
|
||||
echo -n "MacOS X : "
|
||||
if test "$TARGET_ARCHS" = "" ; then
|
||||
TARGET_ARCHS="ppc i386"
|
||||
fi
|
||||
;;
|
||||
nextstep*|openstep*)
|
||||
echo -n "NeXTSTEP/OPENSTEP: "
|
||||
if test "$TARGET_ARCHS" = "" ; then
|
||||
|
@ -161,7 +155,6 @@ case "$target_os" in
|
|||
nextstep*) ;;
|
||||
openstep*) ;;
|
||||
rhapsody*) ;;
|
||||
macos*) ;;
|
||||
human*) ac_cv_func_getpgrp_void=yes;;
|
||||
beos*) ;;
|
||||
cygwin*) ;;
|
||||
|
@ -424,9 +417,9 @@ if test "$with_dln_a_out" != yes; then
|
|||
nextstep*) ;;
|
||||
openstep*) ;;
|
||||
rhapsody*) ;;
|
||||
macos*) ;;
|
||||
human*) ;;
|
||||
bsdi*) ;;
|
||||
beos*) ;;
|
||||
cygwin*) ;;
|
||||
mingw*) ;;
|
||||
netbsd*) CCDLFLAGS=-fpic
|
||||
|
@ -504,10 +497,6 @@ if test "$with_dln_a_out" != yes; then
|
|||
LDFLAGS=""
|
||||
DLDFLAGS="$ARCH_FLAG"
|
||||
rb_cv_dlopen=yes ;;
|
||||
macos*) LDSHARED='cc -dynamic -bundle -undefined suppress'
|
||||
LDFLAGS=""
|
||||
DLDFLAGS="$ARCH_FLAG"
|
||||
rb_cv_dlopen=yes ;;
|
||||
aix*) LDSHARED='/usr/ccs/bin/ld'
|
||||
XLDFLAGS='-Wl,-bE:ruby.imp'
|
||||
DLDFLAGS='-eInit_$(TARGET) -bI:$(topdir)/ruby.imp -bM:SRE -T512 -H512 -lc'
|
||||
|
@ -521,14 +510,12 @@ if test "$with_dln_a_out" != yes; then
|
|||
beos*) case "$target_cpu" in
|
||||
powerpc*)
|
||||
LDSHARED="ld -xms"
|
||||
DLDFLAGS="-f ruby.exp -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o"
|
||||
DLDFLAGS='-export Init_$(TARGET) -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'
|
||||
;;
|
||||
i586*)
|
||||
LDSHARED="ld -shared"
|
||||
DLDFLAGS="-L/boot/develop/lib/x86 -lbe -lroot"
|
||||
;;
|
||||
*)
|
||||
DLDFLAGS="ruby.def -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o"
|
||||
esac
|
||||
rb_cv_dlopen=yes ;;
|
||||
cygwin*|mingw*) : ${LDSHARED="${DLLWRAP} --target=${target_os} --as=${AS} --dlltool-name=${DLLTOOL} --driver-name=${CC} --export-all -s"}
|
||||
|
@ -576,8 +563,6 @@ else
|
|||
AC_DEFINE(DLEXT, ".bundle");;
|
||||
rhapsody*) DLEXT=bundle
|
||||
AC_DEFINE(DLEXT, ".bundle");;
|
||||
macos*) DLEXT=bundle
|
||||
AC_DEFINE(DLEXT, ".bundle");;
|
||||
os2_emx*) DLEXT=dll
|
||||
AC_DEFINE(DLEXT, ".dll");;
|
||||
cygwin*|mingw*) DLEXT=so
|
||||
|
@ -605,8 +590,6 @@ case "$target_os" in
|
|||
STRIP='strip -A -n';;
|
||||
rhapsody*)
|
||||
STRIP='strip -A -n';;
|
||||
macos*)
|
||||
STRIP='strip -A -n';;
|
||||
esac
|
||||
|
||||
EXTSTATIC=
|
||||
|
@ -705,28 +688,9 @@ LIBRUBY_A='lib$(RUBY_INSTALL_NAME).a'
|
|||
LIBRUBY='$(LIBRUBY_A)'
|
||||
LIBRUBYARG='$(LIBRUBY_A)'
|
||||
SOLIBS=
|
||||
if test "$target_os" = "beos"; then
|
||||
LIBRUBY='$(LIBRUBY_SO)'
|
||||
LIBRUBYARG='-l$(RUBY_INSTALL_NAME)'
|
||||
SOLIBS='-lnet'
|
||||
echo creating ruby.def
|
||||
case "$target_cpu" in
|
||||
powerpc*)
|
||||
cp beos/ruby.def.in ruby.exp
|
||||
CFLAGS="$CFLAGS -relax_pointers"
|
||||
;;
|
||||
i586*)
|
||||
LDFLAGS="$LDFLAGS -L."
|
||||
;;
|
||||
*)
|
||||
echo EXPORTS > ruby.def
|
||||
cat beos/ruby.def.in >> ruby.def
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
|
||||
case "$target_os" in
|
||||
cygwin*|mingw*|beos*|openstep*|nextstep*|rhapsody*|macos*|os2_emx*)
|
||||
cygwin*|mingw*|beos*|openstep*|nextstep*|rhapsody*|os2_emx*)
|
||||
DLDLIBS=""
|
||||
;;
|
||||
*)
|
||||
|
@ -787,6 +751,13 @@ if test "$enable_shared" = 'yes'; then
|
|||
LIBRUBYARG='-L${prefix}/lib -Wl,lib$(RUBY_INSTALL_NAME).so'
|
||||
SOLIBS='-lm -lc'
|
||||
;;
|
||||
beos*)
|
||||
case "$target_cpu" in
|
||||
powerpc*)
|
||||
LIBRUBY_DLDFLAGS='-f ruby.exp -lnet -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
cygwin*|mingw*)
|
||||
LIBRUBY_SO='lib$(RUBY_INSTALL_NAME).a'
|
||||
LIBRUBY_ALIASES=''
|
||||
|
@ -834,6 +805,13 @@ case "$target_os" in
|
|||
CFLAGS="$CFLAGS -std"
|
||||
fi
|
||||
;;
|
||||
beos*)
|
||||
case "$target_cpu" in
|
||||
powerpc*)
|
||||
CFLAGS="$CFLAGS -relax_pointers"
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
cygwin*)
|
||||
LIBOBJS="$LIBOBJS strftime.o"
|
||||
;;
|
||||
|
|
15
dir.c
15
dir.c
|
@ -241,10 +241,6 @@ dir_s_new(argc, argv, klass)
|
|||
|
||||
rb_obj_call_init(obj, argc, argv);
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
rb_ensure(rb_yield, obj, dir_close, obj);
|
||||
}
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
@ -268,6 +264,7 @@ dir_initialize(dir, dirname)
|
|||
}
|
||||
}
|
||||
DATA_PTR(dir) = dirp;
|
||||
|
||||
return dir;
|
||||
}
|
||||
|
||||
|
@ -275,7 +272,13 @@ static VALUE
|
|||
dir_s_open(klass, dirname)
|
||||
VALUE klass, dirname;
|
||||
{
|
||||
return dir_s_new(1, &dirname, klass);
|
||||
VALUE dir = dir_s_new(1, &dirname, klass);
|
||||
if (rb_block_given_p()) {
|
||||
rb_ensure(rb_yield, dir, dir_close, dir);
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
return dir;
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -760,7 +763,7 @@ dir_s_glob(dir, str)
|
|||
}
|
||||
if (buf != buffer)
|
||||
free(buf);
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
long len = RARRAY(ary)->len;
|
||||
VALUE *ptr = RARRAY(ary)->ptr;
|
||||
|
||||
|
|
2
dln.c
2
dln.c
|
@ -881,7 +881,7 @@ search_undef(key, value, lib_tbl)
|
|||
int value;
|
||||
st_table *lib_tbl;
|
||||
{
|
||||
int offset;
|
||||
long offset;
|
||||
|
||||
if (st_lookup(lib_tbl, key, &offset) == 0) return ST_CONTINUE;
|
||||
target_offset = offset;
|
||||
|
|
8
enum.c
8
enum.c
|
@ -50,7 +50,7 @@ enum_grep(obj, pat)
|
|||
VALUE tmp, arg[2];
|
||||
|
||||
arg[0] = pat; arg[1] = tmp = rb_ary_new();
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
rb_iterate(rb_each, obj, grep_iter_i, (VALUE)arg);
|
||||
}
|
||||
else {
|
||||
|
@ -173,7 +173,7 @@ enum_collect(obj)
|
|||
VALUE tmp;
|
||||
|
||||
tmp = rb_ary_new();
|
||||
rb_iterate(rb_each, obj, rb_iterator_p() ? collect_i : enum_all, tmp);
|
||||
rb_iterate(rb_each, obj, rb_block_given_p() ? collect_i : enum_all, tmp);
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
@ -225,7 +225,7 @@ enum_min(obj)
|
|||
{
|
||||
NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0);
|
||||
|
||||
rb_iterate(rb_each, obj, rb_iterator_p()?min_ii:min_i, (VALUE)memo);
|
||||
rb_iterate(rb_each, obj, rb_block_given_p()?min_ii:min_i, (VALUE)memo);
|
||||
rb_gc_force_recycle((VALUE)memo);
|
||||
return memo->u1.value;
|
||||
}
|
||||
|
@ -270,7 +270,7 @@ enum_max(obj)
|
|||
{
|
||||
NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0);
|
||||
|
||||
rb_iterate(rb_each, obj, rb_iterator_p()?max_ii:max_i, (VALUE)memo);
|
||||
rb_iterate(rb_each, obj, rb_block_given_p()?max_ii:max_i, (VALUE)memo);
|
||||
rb_gc_force_recycle((VALUE)memo);
|
||||
return memo->u1.value;
|
||||
}
|
||||
|
|
96
eval.c
96
eval.c
|
@ -74,7 +74,7 @@ static VALUE rb_cBinding;
|
|||
static VALUE proc_call _((VALUE,VALUE));
|
||||
static VALUE rb_f_binding _((VALUE));
|
||||
static void rb_f_END _((void));
|
||||
static VALUE rb_f_iterator_p _((void));
|
||||
static VALUE rb_f_block_given_p _((void));
|
||||
static VALUE block_pass _((VALUE,NODE*));
|
||||
static VALUE rb_cMethod;
|
||||
static VALUE method_proc _((VALUE));
|
||||
|
@ -125,20 +125,6 @@ safe_setter(val)
|
|||
ruby_safe_level = level;
|
||||
}
|
||||
|
||||
void
|
||||
rb_check_safe_str(x)
|
||||
VALUE x;
|
||||
{
|
||||
if (ruby_safe_level > 0 && OBJ_TAINTED(x)){
|
||||
rb_raise(rb_eSecurityError, "Insecure operation - %s",
|
||||
rb_id2name(ruby_frame->last_func));
|
||||
}
|
||||
if (TYPE(x)!= T_STRING) {
|
||||
rb_raise(rb_eTypeError, "wrong argument type %s (expected String)",
|
||||
rb_class2name(CLASS_OF(x)));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
rb_secure(level)
|
||||
int level;
|
||||
|
@ -149,6 +135,26 @@ rb_secure(level)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
rb_check_safe_str(x)
|
||||
VALUE x;
|
||||
{
|
||||
if (ruby_safe_level > 0 && OBJ_TAINTED(x)){
|
||||
if (ruby_frame->last_func) {
|
||||
rb_raise(rb_eSecurityError, "Insecure operation - %s",
|
||||
rb_id2name(ruby_frame->last_func));
|
||||
}
|
||||
else {
|
||||
rb_raise(rb_eSecurityError, "Insecure operation: -r");
|
||||
}
|
||||
}
|
||||
rb_secure(4);
|
||||
if (TYPE(x)!= T_STRING) {
|
||||
rb_raise(rb_eTypeError, "wrong argument type %s (expected String)",
|
||||
rb_class2name(CLASS_OF(x)));
|
||||
}
|
||||
}
|
||||
|
||||
static void print_undef _((VALUE, ID)) NORETURN;
|
||||
static void
|
||||
print_undef(klass, id)
|
||||
|
@ -1642,7 +1648,7 @@ is_defined(self, node, buf)
|
|||
return "method";
|
||||
|
||||
case NODE_YIELD:
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
return "yield";
|
||||
}
|
||||
break;
|
||||
|
@ -2562,7 +2568,7 @@ rb_eval(self, n)
|
|||
case NODE_BLOCK_ARG:
|
||||
if (ruby_scope->local_vars == 0)
|
||||
rb_bug("unexpected block argument");
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
result = rb_f_lambda();
|
||||
ruby_scope->local_vars[node->nd_cnt] = result;
|
||||
}
|
||||
|
@ -3291,14 +3297,20 @@ rb_jump_tag(tag)
|
|||
}
|
||||
|
||||
int
|
||||
rb_iterator_p()
|
||||
rb_block_given_p()
|
||||
{
|
||||
if (ruby_frame->iter) return Qtrue;
|
||||
return Qfalse;
|
||||
}
|
||||
|
||||
int
|
||||
rb_iterator_p()
|
||||
{
|
||||
return rb_block_given_p();
|
||||
}
|
||||
|
||||
static VALUE
|
||||
rb_f_iterator_p()
|
||||
rb_f_block_given_p()
|
||||
{
|
||||
if (ruby_frame->prev && ruby_frame->prev->iter) return Qtrue;
|
||||
return Qfalse;
|
||||
|
@ -4158,7 +4170,7 @@ rb_call0(klass, recv, id, argc, argv, body, nosuper)
|
|||
rb_raise(rb_eLocalJumpError, "unexpected redo");
|
||||
break;
|
||||
case TAG_RETRY:
|
||||
if (!rb_iterator_p()) {
|
||||
if (!rb_block_given_p()) {
|
||||
rb_raise(rb_eLocalJumpError, "retry outside of rescue clause");
|
||||
}
|
||||
default:
|
||||
|
@ -4247,7 +4259,7 @@ rb_f_send(argc, argv, recv)
|
|||
if (argc == 0) rb_raise(rb_eArgError, "no method name given");
|
||||
|
||||
vid = *argv++; argc--;
|
||||
PUSH_ITER(rb_iterator_p()?ITER_PRE:ITER_NOT);
|
||||
PUSH_ITER(rb_block_given_p()?ITER_PRE:ITER_NOT);
|
||||
vid = rb_call(CLASS_OF(recv), recv, rb_to_id(vid), argc, argv, 1);
|
||||
POP_ITER();
|
||||
|
||||
|
@ -4708,7 +4720,7 @@ specific_eval(argc, argv, klass, self)
|
|||
{
|
||||
char *file = "(eval)";
|
||||
int line = 1;
|
||||
int iter = rb_iterator_p();
|
||||
int iter = rb_block_given_p();
|
||||
|
||||
if (argc > 0) {
|
||||
if (ruby_safe_level >= 4) {
|
||||
|
@ -5207,7 +5219,7 @@ rb_obj_call_init(obj, argc, argv)
|
|||
int argc;
|
||||
VALUE *argv;
|
||||
{
|
||||
PUSH_ITER(rb_iterator_p()?ITER_PRE:ITER_NOT);
|
||||
PUSH_ITER(rb_block_given_p()?ITER_PRE:ITER_NOT);
|
||||
rb_funcall2(obj, init, argc, argv);
|
||||
POP_ITER();
|
||||
}
|
||||
|
@ -5447,7 +5459,8 @@ Init_eval()
|
|||
rb_define_hooked_variable("$!", &ruby_errinfo, 0, errinfo_setter);
|
||||
|
||||
rb_define_global_function("eval", rb_f_eval, -1);
|
||||
rb_define_global_function("iterator?", rb_f_iterator_p, 0);
|
||||
rb_define_global_function("iterator?", rb_f_block_given_p, 0);
|
||||
rb_define_global_function("block_given?", rb_f_block_given_p, 0);
|
||||
rb_define_global_function("method_missing", rb_f_missing, -1);
|
||||
rb_define_global_function("loop", rb_f_loop, 0);
|
||||
|
||||
|
@ -5678,7 +5691,7 @@ rb_f_binding(self)
|
|||
*data = *ruby_block;
|
||||
|
||||
data->orig_thread = rb_thread_current();
|
||||
data->iter = rb_f_iterator_p();
|
||||
data->iter = rb_f_block_given_p();
|
||||
frame_dup(&data->frame);
|
||||
if (ruby_frame->prev) {
|
||||
data->frame.last_func = ruby_frame->prev->last_func;
|
||||
|
@ -5754,7 +5767,7 @@ proc_new(klass)
|
|||
struct BLOCK *data;
|
||||
struct RVarmap *vars;
|
||||
|
||||
if (!rb_iterator_p() && !rb_f_iterator_p()) {
|
||||
if (!rb_block_given_p() && !rb_f_block_given_p()) {
|
||||
rb_raise(rb_eArgError, "tried to create Procedure-Object out of iterator");
|
||||
}
|
||||
|
||||
|
@ -5856,7 +5869,7 @@ proc_call(proc, args)
|
|||
}
|
||||
|
||||
if (orphan) {/* orphan procedure */
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
ruby_block->frame.iter = ITER_CUR;
|
||||
}
|
||||
else {
|
||||
|
@ -6086,7 +6099,7 @@ method_call(argc, argv, method)
|
|||
volatile int safe = ruby_safe_level;
|
||||
|
||||
Data_Get_Struct(method, struct METHOD, data);
|
||||
PUSH_ITER(rb_iterator_p()?ITER_PRE:ITER_NOT);
|
||||
PUSH_ITER(rb_block_given_p()?ITER_PRE:ITER_NOT);
|
||||
PUSH_TAG(PROT_NONE);
|
||||
if (OBJ_TAINTED(data->recv) || OBJ_TAINTED(method)) {
|
||||
OBJ_TAINT(method);
|
||||
|
@ -6612,23 +6625,12 @@ rb_thread_fd_close(fd)
|
|||
static void
|
||||
rb_thread_deadlock()
|
||||
{
|
||||
#if 1
|
||||
curr_thread = main_thread;
|
||||
th_raise_argc = 1;
|
||||
th_raise_argv[0] = rb_exc_new2(rb_eFatal, "Thread: deadlock");
|
||||
th_raise_file = ruby_sourcefile;
|
||||
th_raise_line = ruby_sourceline;
|
||||
rb_thread_restore_context(main_thread, RESTORE_RAISE);
|
||||
#else
|
||||
static int invoked = 0;
|
||||
|
||||
if (invoked) return;
|
||||
invoked = 1;
|
||||
rb_prohibit_interrupt = 1;
|
||||
ruby_errinfo = rb_exc_new2(rb_eFatal, "Thread: deadlock");
|
||||
set_backtrace(ruby_errinfo, make_backtrace());
|
||||
rb_abort();
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -6741,7 +6743,7 @@ rb_thread_schedule()
|
|||
if (!next && (th->status == THREAD_RUNNABLE || th->status == THREAD_TO_KILL)) {
|
||||
found = 1;
|
||||
}
|
||||
if ((th->wait_for&WAIT_JOIN) && rb_thread_dead(th->join)) {
|
||||
if ((th->wait_for & WAIT_JOIN) && rb_thread_dead(th->join)) {
|
||||
th->join = 0;
|
||||
th->wait_for = 0;
|
||||
th->status = THREAD_RUNNABLE;
|
||||
|
@ -6775,7 +6777,7 @@ rb_thread_schedule()
|
|||
END_FOREACH_FROM(curr, th);
|
||||
|
||||
/* Do the select if needed */
|
||||
if (need_select || !found) {
|
||||
if (need_select) {
|
||||
do {
|
||||
/* Convert delay to a timeval */
|
||||
/* If a thread is runnable, just poll */
|
||||
|
@ -6855,6 +6857,7 @@ rb_thread_schedule()
|
|||
END_FOREACH_FROM(curr, th);
|
||||
|
||||
if (!next) {
|
||||
/* raise fatal error to main thread */
|
||||
curr_thread->file = ruby_sourcefile;
|
||||
curr_thread->line = ruby_sourceline;
|
||||
FOREACH_THREAD_FROM(curr, th) {
|
||||
|
@ -6864,7 +6867,6 @@ rb_thread_schedule()
|
|||
th->file, th->line);
|
||||
}
|
||||
END_FOREACH_FROM(curr, th);
|
||||
/* raise fatal error to main thread */
|
||||
rb_thread_deadlock();
|
||||
next = main_thread;
|
||||
rb_thread_ready(next);
|
||||
|
@ -7178,7 +7180,7 @@ rb_thread_stop()
|
|||
{
|
||||
rb_thread_critical = 0;
|
||||
if (curr_thread == curr_thread->next) {
|
||||
rb_raise(rb_eThreadError, "stopping only thread");
|
||||
rb_raise(rb_eThreadError, "stopping only thread\n\tnote: use sleep to stop forever");
|
||||
}
|
||||
curr_thread->status = THREAD_STOPPED;
|
||||
rb_thread_schedule();
|
||||
|
@ -7523,8 +7525,8 @@ static VALUE
|
|||
rb_thread_initialize(thread, args)
|
||||
VALUE thread, args;
|
||||
{
|
||||
if (!rb_iterator_p()) {
|
||||
rb_raise(rb_eThreadError, "must be called as iterator");
|
||||
if (!rb_block_given_p()) {
|
||||
rb_raise(rb_eThreadError, "must be called with a block");
|
||||
}
|
||||
return rb_thread_start_0(rb_thread_yield, args, rb_thread_check(thread));
|
||||
}
|
||||
|
@ -7533,8 +7535,8 @@ static VALUE
|
|||
rb_thread_start(klass, args)
|
||||
VALUE klass, args;
|
||||
{
|
||||
if (!rb_iterator_p()) {
|
||||
rb_raise(rb_eThreadError, "must be called as iterator");
|
||||
if (!rb_block_given_p()) {
|
||||
rb_raise(rb_eThreadError, "must be called with a block");
|
||||
}
|
||||
return rb_thread_start_0(rb_thread_yield, args, rb_thread_alloc(klass));
|
||||
}
|
||||
|
|
|
@ -162,7 +162,7 @@ fdbm_delete(obj, keystr)
|
|||
|
||||
value = dbm_fetch(dbm, key);
|
||||
if (value.dptr == 0) {
|
||||
if (rb_iterator_p()) rb_yield(keystr);
|
||||
if (rb_block_given_p()) rb_yield(keystr);
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
|
|
|
@ -133,7 +133,7 @@ etc_passwd(obj)
|
|||
#ifdef HAVE_GETPWENT
|
||||
struct passwd *pw;
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
setpwent();
|
||||
while (pw = getpwent()) {
|
||||
rb_yield(setup_passwd(pw));
|
||||
|
@ -210,7 +210,7 @@ etc_group(obj)
|
|||
#ifdef HAVE_GETGRENT
|
||||
struct group *grp;
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
setgrent();
|
||||
while (grp = getgrent()) {
|
||||
rb_yield(setup_group(grp));
|
||||
|
|
|
@ -334,11 +334,6 @@ def create_makefile(target)
|
|||
$DLDFLAGS = $DLDFLAGS + " -L" + $topdir
|
||||
end
|
||||
|
||||
if RUBY_PLATFORM =~ /beos/ and not $static
|
||||
$libs = $libs + " @LIBRUBYARG@"
|
||||
$DLDFLAGS = $DLDFLAGS + " -L" + $topdir
|
||||
end
|
||||
|
||||
defflag = ''
|
||||
if RUBY_PLATFORM =~ /cygwin|mingw/ and not $static
|
||||
if File.exist? target + ".def"
|
||||
|
@ -477,19 +472,6 @@ $(DLLIB): $(OBJS)
|
|||
dfile.close
|
||||
end
|
||||
mfile.close
|
||||
|
||||
if RUBY_PLATFORM =~ /beos/
|
||||
if RUBY_PLATFORM =~ /^powerpc/ then
|
||||
deffilename = "ruby.exp"
|
||||
else
|
||||
deffilename = "ruby.def"
|
||||
end
|
||||
print "creating #{deffilename}\n"
|
||||
open(deffilename, "w") do |file|
|
||||
file.print("EXPORTS\n") if RUBY_PLATFORM =~ /^i/
|
||||
file.print("Init_#{target}\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def extmake(target)
|
||||
|
|
|
@ -159,7 +159,7 @@ fgdbm_delete(obj, keystr)
|
|||
|
||||
value = gdbm_fetch(dbm, key);
|
||||
if (value.dptr == 0) {
|
||||
if (rb_iterator_p()) rb_yield(keystr);
|
||||
if (rb_block_given_p()) rb_yield(keystr);
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
MANIFEST
|
||||
depend
|
||||
extconf.rb
|
||||
md5.txt
|
||||
md5.txt.jp
|
||||
md5.h
|
||||
|
|
|
@ -457,7 +457,7 @@ pty_getpty(self, shell)
|
|||
rb_ary_store(res,1,(VALUE)wport);
|
||||
rb_ary_store(res,2,INT2FIX(info.child_pid));
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
rb_yield((VALUE)res);
|
||||
reset_signal_action();
|
||||
return Qnil;
|
||||
|
|
|
@ -156,7 +156,7 @@ fsdbm_delete(obj, keystr)
|
|||
|
||||
value = sdbm_fetch(dbm, key);
|
||||
if (value.dptr == 0) {
|
||||
if (rb_iterator_p()) rb_yield(keystr);
|
||||
if (rb_block_given_p()) rb_yield(keystr);
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
|
|
|
@ -23,6 +23,7 @@ def find_tcl(tcllib)
|
|||
find_library(tcllib, func, *paths)
|
||||
else
|
||||
find_library("tcl", func, *paths) or
|
||||
find_library("tcl8.3", func, *paths) or
|
||||
find_library("tcl8.2", func, *paths) or
|
||||
find_library("tcl8.0", func, *paths) or
|
||||
find_library("tcl7.6", func, *paths)
|
||||
|
@ -36,6 +37,7 @@ def find_tk(tklib)
|
|||
find_library(tklib, func, *paths)
|
||||
else
|
||||
find_library("tk", func, *paths) or
|
||||
find_library("tk8.3", func, *paths) or
|
||||
find_library("tk8.2", func, *paths) or
|
||||
find_library("tk8.0", func, *paths) or
|
||||
find_library("tk4.2", func, *paths)
|
||||
|
|
|
@ -470,7 +470,7 @@ module TkCore
|
|||
end
|
||||
|
||||
def rb_appsend(interp, async, *args)
|
||||
args = args.filter{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
|
||||
args = args.collect!{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
|
||||
args.push(').to_s"')
|
||||
appsend(interp, async, 'ruby "(', *args)
|
||||
end
|
||||
|
@ -485,7 +485,7 @@ module TkCore
|
|||
end
|
||||
|
||||
def rb_appsend_displayof(interp, win, async, *args)
|
||||
args = args.filter{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
|
||||
args = args.collect!{|c| _get_eval_string(c).gsub(/[][$"]/, '\\\\\&')}
|
||||
args.push(').to_s"')
|
||||
appsend_displayof(interp, win, async, 'ruby "(', *args)
|
||||
end
|
||||
|
@ -526,7 +526,7 @@ module TkCore
|
|||
|
||||
def tk_call(*args)
|
||||
print args.join(" "), "\n" if $DEBUG
|
||||
args.filter {|x|_get_eval_string(x)}
|
||||
args.collect! {|x|_get_eval_string(x)}
|
||||
args.compact!
|
||||
args.flatten!
|
||||
begin
|
||||
|
|
|
@ -26,7 +26,7 @@ class TkAfter
|
|||
end
|
||||
|
||||
def TkAfter.info
|
||||
tk_call('after', 'info').split(' ').filter{|id|
|
||||
tk_call('after', 'info').split(' ').collect!{|id|
|
||||
ret = Tk_CBTBL.find{|key,val| val.after_id == id}
|
||||
(ret == nil)? id: ret[1]
|
||||
}
|
||||
|
|
|
@ -216,7 +216,7 @@ class TkCanvas<TkWindow
|
|||
end
|
||||
|
||||
def find(mode, *args)
|
||||
list(tk_send 'find', mode, *args).filter{|id|
|
||||
list(tk_send 'find', mode, *args).collect!{|id|
|
||||
TkcItem.id2obj(id)
|
||||
}
|
||||
end
|
||||
|
@ -368,13 +368,6 @@ class TkCanvas<TkWindow
|
|||
def itemtype(tag)
|
||||
TkcItem.type2class(tk_send 'type', tagid(tag))
|
||||
end
|
||||
|
||||
def xview(*index)
|
||||
tk_send 'xview', *index
|
||||
end
|
||||
def yview(*index)
|
||||
tk_send 'yview', *index
|
||||
end
|
||||
end
|
||||
|
||||
module TkcTagAccess
|
||||
|
@ -725,7 +718,7 @@ class TkImage<TkObject
|
|||
end
|
||||
|
||||
def TkImage.names
|
||||
Tk.tk_call('image', 'names').split.filter{|id|
|
||||
Tk.tk_call('image', 'names').split.collect!{|id|
|
||||
(Tk_IMGTBL[id])? Tk_IMGTBL[id] : id
|
||||
}
|
||||
end
|
||||
|
|
|
@ -245,16 +245,10 @@ class TkText<TkTextWin
|
|||
(inf == "")? [0,0,0,0,0]: inf
|
||||
end
|
||||
|
||||
def yview(*what)
|
||||
tk_send 'yview', *what
|
||||
end
|
||||
def yview_pickplace(*what)
|
||||
tk_send 'yview', '-pickplace', *what
|
||||
end
|
||||
|
||||
def xview(*what)
|
||||
tk_send 'xview', *what
|
||||
end
|
||||
def xview_pickplace(*what)
|
||||
tk_send 'xview', '-pickplace', *what
|
||||
end
|
||||
|
|
|
@ -16,7 +16,7 @@ class TkVirtualEvent<TkObject
|
|||
end
|
||||
|
||||
def TkVirtualEvent.info
|
||||
tk_call('event', 'info').split(/\s+/).filter{|seq|
|
||||
tk_call('event', 'info').split(/\s+/).collect!{|seq|
|
||||
TkVirtualEvent.getobj(seq[1..-2])
|
||||
}
|
||||
end
|
||||
|
@ -49,8 +49,8 @@ class TkVirtualEvent<TkObject
|
|||
end
|
||||
|
||||
def info
|
||||
tk_call('event', 'info', "<#{@id}>").split(/\s+/).filter{|seq|
|
||||
l = seq.scan(/<*[^<>]+>*/).filter{|subseq|
|
||||
tk_call('event', 'info', "<#{@id}>").split(/\s+/).collect!{|seq|
|
||||
l = seq.scan(/<*[^<>]+>*/).collect!{|subseq|
|
||||
case (subseq)
|
||||
when /^<<[^<>]+>>$/
|
||||
TkVirtualEvent.getobj(subseq[1..-2])
|
||||
|
|
|
@ -29,7 +29,7 @@ tk_s_new(argc, argv, klass)
|
|||
{
|
||||
VALUE obj = rb_class_new_instance(argc, argv, klass);
|
||||
|
||||
if (rb_iterator_p()) rb_obj_instance_eval(0, 0, obj);
|
||||
if (rb_block_given_p()) rb_obj_instance_eval(0, 0, obj);
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
|
7
file.c
7
file.c
|
@ -2033,6 +2033,7 @@ rb_find_file(file)
|
|||
volatile VALUE vpath;
|
||||
VALUE fname;
|
||||
char *path;
|
||||
struct stat st;
|
||||
|
||||
#if defined(__MACOS__) || defined(riscos)
|
||||
if (is_macos_native_path(file)) {
|
||||
|
@ -2091,7 +2092,11 @@ rb_find_file(file)
|
|||
path = 0;
|
||||
}
|
||||
|
||||
return dln_find_file(file, path);
|
||||
path = dln_find_file(file, path);
|
||||
if (stat(path, &st) == 0) {
|
||||
return path;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
8
hash.c
8
hash.c
|
@ -334,7 +334,7 @@ rb_hash_fetch(argc, argv, hash)
|
|||
rb_scan_args(argc, argv, "11", &key, &if_none);
|
||||
|
||||
if (!st_lookup(RHASH(hash)->tbl, key, &val)) {
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
if (argc > 1) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments", argc);
|
||||
}
|
||||
|
@ -421,7 +421,7 @@ rb_hash_delete(hash, key)
|
|||
}
|
||||
else if (st_delete(RHASH(hash)->tbl, &key, &val))
|
||||
return val;
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
return rb_yield(key);
|
||||
}
|
||||
return RHASH(hash)->ifnone;
|
||||
|
@ -894,7 +894,7 @@ env_delete_m(obj, name)
|
|||
VALUE obj, name;
|
||||
{
|
||||
VALUE val = env_delete(obj, name);
|
||||
if (rb_iterator_p()) rb_yield(name);
|
||||
if (rb_block_given_p()) rb_yield(name);
|
||||
return val;
|
||||
}
|
||||
|
||||
|
@ -934,7 +934,7 @@ env_fetch(argc, argv)
|
|||
}
|
||||
env = getenv(nam);
|
||||
if (!env) {
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
if (argc > 1) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments", argc);
|
||||
}
|
||||
|
|
|
@ -36,7 +36,7 @@ for dll in Dir['*.dll']
|
|||
File.install dll, "#{bindir}/#{dll}", 0755, true
|
||||
end
|
||||
File.makedirs libdir, true
|
||||
for lib in ["libruby.so.LIB", CONFIG["LIBRUBY_SO"]]
|
||||
for lib in [CONFIG["LIBRUBY_SO"]]
|
||||
if File.exist? lib
|
||||
File.install lib, libdir, 0555, true
|
||||
end
|
||||
|
@ -57,10 +57,6 @@ File.makedirs archlibdir, true
|
|||
File.makedirs sitelibdir, true
|
||||
File.makedirs sitearchlibdir, true
|
||||
|
||||
if RUBY_PLATFORM =~ /cygwin/ and File.exist? "import.h"
|
||||
File.install "import.h", archlibdir, 0644, true
|
||||
end
|
||||
|
||||
if RUBY_PLATFORM =~ /-aix/
|
||||
File.install "ruby.imp", archlibdir, 0644, true
|
||||
end
|
||||
|
|
162
io.c
162
io.c
|
@ -105,7 +105,7 @@ static VALUE lineno;
|
|||
#elif defined(FILE_COUNT)
|
||||
# define READ_DATA_PENDING(fp) ((fp)->FILE_COUNT > 0)
|
||||
#elif defined(__BEOS__)
|
||||
# define ReadDataPending(fp) (fp->_state._eof == 0)
|
||||
# define READ_DATA_PENDING(fp) (fp->_state._eof == 0)
|
||||
#else
|
||||
/* requires systems own version of the ReadDataPending() */
|
||||
extern int ReadDataPending();
|
||||
|
@ -392,6 +392,18 @@ rb_io_fileno(io)
|
|||
return INT2FIX(fd);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
rb_io_pid(io)
|
||||
VALUE io;
|
||||
{
|
||||
OpenFile *fptr;
|
||||
|
||||
GetOpenFile(io, fptr);
|
||||
if (!fptr->pid)
|
||||
return Qnil;
|
||||
return INT2FIX(fptr->pid);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
rb_io_to_io(io)
|
||||
VALUE io;
|
||||
|
@ -1572,10 +1584,11 @@ pipe_open(pname, mode)
|
|||
}
|
||||
|
||||
static VALUE
|
||||
rb_io_s_popen(argc, argv, self)
|
||||
rb_io_popen(str, argc, argv, klass)
|
||||
char *str;
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE self;
|
||||
VALUE klass;
|
||||
{
|
||||
char *mode;
|
||||
VALUE pname, pmode, port, proc;
|
||||
|
@ -1584,66 +1597,42 @@ rb_io_s_popen(argc, argv, self)
|
|||
mode = "r";
|
||||
}
|
||||
else {
|
||||
int len;
|
||||
|
||||
mode = STR2CSTR(pmode);
|
||||
len = strlen(mode);
|
||||
if (len == 0 || len > 3)
|
||||
rb_raise(rb_eArgError, "illegal access mode");
|
||||
}
|
||||
Check_SafeStr(pname);
|
||||
port = pipe_open(RSTRING(pname)->ptr, mode);
|
||||
port = pipe_open(str, mode);
|
||||
if (NIL_P(port)) {
|
||||
/* child */
|
||||
if (!NIL_P(proc)) {
|
||||
rb_eval_cmd(proc, rb_ary_new2(0));
|
||||
_exit(0);
|
||||
}
|
||||
else if (rb_iterator_p()) {
|
||||
else if (rb_block_given_p()) {
|
||||
rb_yield(Qnil);
|
||||
}
|
||||
return Qnil;
|
||||
fflush(stdout);
|
||||
fflush(stderr);
|
||||
_exit(0);
|
||||
}
|
||||
else if (rb_iterator_p()) {
|
||||
return rb_ensure(rb_yield, port, rb_io_close, port);
|
||||
RBASIC(port)->klass = klass;
|
||||
if (rb_block_given_p()) {
|
||||
rb_ensure(rb_yield, port, rb_io_close, port);
|
||||
return Qnil;
|
||||
}
|
||||
return port;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
rb_file_initialize(argc, argv, io)
|
||||
rb_io_s_popen(argc, argv, klass)
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE io;
|
||||
VALUE klass;
|
||||
{
|
||||
VALUE fname, vmode, file, perm;
|
||||
char *path, *mode;
|
||||
char *str = 0;
|
||||
|
||||
rb_scan_args(argc, argv, "12", &fname, &vmode, &perm);
|
||||
Check_SafeStr(fname);
|
||||
path = RSTRING(fname)->ptr;
|
||||
|
||||
if (FIXNUM_P(vmode)) {
|
||||
int flags = NUM2INT(vmode);
|
||||
int fmode = NIL_P(perm) ? 0666 : NUM2INT(perm);
|
||||
|
||||
file = rb_file_sysopen_internal(io, path, flags, fmode);
|
||||
if (argc >= 1) {
|
||||
str = STR2CSTR(argv[0]);
|
||||
}
|
||||
else {
|
||||
if (!NIL_P(vmode)) {
|
||||
mode = STR2CSTR(vmode);
|
||||
}
|
||||
else {
|
||||
mode = "r";
|
||||
}
|
||||
file = rb_file_open_internal(io, RSTRING(fname)->ptr, mode);
|
||||
}
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
return rb_ensure(rb_yield, file, rb_io_close, file);
|
||||
}
|
||||
|
||||
return file;
|
||||
return rb_io_popen(str, argc, argv, klass);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
|
@ -1668,17 +1657,18 @@ rb_file_s_open(argc, argv, klass)
|
|||
file = rb_file_sysopen_internal((VALUE)io, path, flags, fmode);
|
||||
}
|
||||
else {
|
||||
if (!NIL_P(vmode)) {
|
||||
mode = STR2CSTR(vmode);
|
||||
if (NIL_P(vmode)) {
|
||||
mode = "r";
|
||||
}
|
||||
else {
|
||||
mode = "r";
|
||||
mode = STR2CSTR(vmode);
|
||||
}
|
||||
file = rb_file_open_internal((VALUE)io, RSTRING(fname)->ptr, mode);
|
||||
}
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
return rb_ensure(rb_yield, file, rb_io_close, file);
|
||||
if (rb_block_given_p()) {
|
||||
rb_ensure(rb_yield, file, rb_io_close, file);
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
return file;
|
||||
|
@ -1689,41 +1679,14 @@ rb_f_open(argc, argv)
|
|||
int argc;
|
||||
VALUE *argv;
|
||||
{
|
||||
char *mode;
|
||||
VALUE pname, pmode, perm;
|
||||
VALUE port;
|
||||
if (argc >= 1) {
|
||||
char *str = STR2CSTR(argv[0]);
|
||||
|
||||
rb_scan_args(argc, argv, "12", &pname, &pmode, &perm);
|
||||
Check_SafeStr(pname);
|
||||
if (RSTRING(pname)->ptr[0] != '|') /* open file */
|
||||
return rb_file_s_open(argc, argv, rb_cFile);
|
||||
|
||||
/* open pipe */
|
||||
if (NIL_P(pmode)) {
|
||||
mode = "r";
|
||||
if (str[0] == '|') {
|
||||
return rb_io_popen(str+1, argc, argv, rb_cIO);
|
||||
}
|
||||
}
|
||||
else if (FIXNUM_P(pmode)) {
|
||||
mode = rb_io_flags_mode(NUM2INT(pmode));
|
||||
}
|
||||
else {
|
||||
int len;
|
||||
|
||||
mode = STR2CSTR(pmode);
|
||||
len = strlen(mode);
|
||||
if (len == 0 || len > 3)
|
||||
rb_raise(rb_eArgError, "illegal access mode %s", mode);
|
||||
}
|
||||
|
||||
port = pipe_open(RSTRING(pname)->ptr+1, mode);
|
||||
if (!rb_iterator_p()) return port;
|
||||
if (NIL_P(port)) {
|
||||
rb_yield(port);
|
||||
}
|
||||
else if (rb_iterator_p()) {
|
||||
return rb_ensure(rb_yield, port, rb_io_close, port);
|
||||
}
|
||||
|
||||
return port;
|
||||
return rb_file_s_open(argc, argv, rb_cFile);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
|
@ -2280,12 +2243,44 @@ rb_io_initialize(argc, argv, io)
|
|||
fp->f = rb_fdopen(NUM2INT(fnum), m);
|
||||
fp->mode = rb_io_mode_flags(m);
|
||||
|
||||
if (rb_iterator_p()) {
|
||||
return rb_ensure(rb_yield, io, rb_io_close, io);
|
||||
}
|
||||
return io;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
rb_file_initialize(argc, argv, io)
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE io;
|
||||
{
|
||||
VALUE fname, vmode, file, perm;
|
||||
char *path, *mode;
|
||||
|
||||
rb_scan_args(argc, argv, "12", &fname, &vmode, &perm);
|
||||
Check_SafeStr(fname);
|
||||
path = RSTRING(fname)->ptr;
|
||||
|
||||
if (FIXNUM_P(vmode)) {
|
||||
int flags = NUM2INT(vmode);
|
||||
int fmode = NIL_P(perm) ? 0666 : NUM2INT(perm);
|
||||
|
||||
file = rb_file_sysopen_internal(io, path, flags, fmode);
|
||||
}
|
||||
else {
|
||||
if (NIL_P(vmode)) {
|
||||
mode = "r";
|
||||
}
|
||||
else {
|
||||
mode = STR2CSTR(vmode);
|
||||
}
|
||||
file = rb_file_open_internal(io, RSTRING(fname)->ptr, mode);
|
||||
}
|
||||
if (rb_block_given_p()) {
|
||||
rb_warn("File::new() does not take block; use File::open() instead");
|
||||
}
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
static int binmode = 0;
|
||||
|
||||
static VALUE
|
||||
|
@ -3339,6 +3334,7 @@ Init_IO()
|
|||
|
||||
rb_define_method(rb_cIO, "ioctl", rb_io_ioctl, -1);
|
||||
rb_define_method(rb_cIO, "fcntl", rb_io_fcntl, -1);
|
||||
rb_define_method(rb_cIO, "pid", rb_io_pid, 0);
|
||||
|
||||
rb_stdin = orig_stdin = prep_stdio(stdin, FMODE_READABLE, rb_cIO);
|
||||
rb_define_hooked_variable("$stdin", &rb_stdin, 0, set_stdin);
|
||||
|
|
93
lib/date2.rb
93
lib/date2.rb
|
@ -1,5 +1,5 @@
|
|||
# date2.rb: Written by Tadayoshi Funaba 1998-2000
|
||||
# $Id: date2.rb,v 1.18 2000/03/20 16:23:32 tadf Exp $
|
||||
# $Id: date2.rb,v 1.21 2000/05/14 15:47:09 tadf Exp $
|
||||
|
||||
class Date
|
||||
|
||||
|
@ -115,6 +115,8 @@ class Date
|
|||
def ld_to_jd(ld) ld + 2299160 end
|
||||
def jd_to_ld(jd) jd - 2299160 end
|
||||
|
||||
def jd_to_wday(jd) (jd + 1) % 7 end
|
||||
|
||||
def julian_leap? (y) y % 4 == 0 end
|
||||
def gregorian_leap? (y) y % 4 == 0 and y % 100 != 0 or y % 400 == 0 end
|
||||
|
||||
|
@ -127,8 +129,8 @@ class Date
|
|||
m += 13
|
||||
end
|
||||
if d < 0
|
||||
ny, nm = Date.clfloor(y * 12 + m, 12)
|
||||
nm, = Date.clfloor(m + 1, 1)
|
||||
ny, nm = clfloor(y * 12 + m, 12)
|
||||
nm, = clfloor(m + 1, 1)
|
||||
la = nil
|
||||
31.downto 1 do |z|
|
||||
break if la = exist3?(y, m, z, sg)
|
||||
|
@ -199,10 +201,9 @@ class Date
|
|||
def once(*ids)
|
||||
for id in ids
|
||||
module_eval <<-"end;"
|
||||
alias_method :__#{id.to_i}__, #{id.inspect}
|
||||
alias_method :__#{id.to_i}__, :#{id.id2name}
|
||||
def #{id.id2name}(*args, &block)
|
||||
def self.#{id.id2name}(*args, &block); @__#{id.to_i}__ end
|
||||
@__#{id.to_i}__ = __#{id.to_i}__(*args, &block)
|
||||
(@__#{id.to_i}__ ||= [__#{id.to_i}__(*args, &block)])[0]
|
||||
end
|
||||
end;
|
||||
end
|
||||
|
@ -215,79 +216,76 @@ class Date
|
|||
def initialize(rjd=0, sg=ITALY) @rjd, @sg = rjd, sg end
|
||||
|
||||
def rjd() @rjd end
|
||||
def rmjd() Date.jd_to_mjd(@rjd) end
|
||||
def rtjd() Date.jd_to_tjd(@rjd) end
|
||||
def rtjd2() Date.jd_to_tjd2(@rjd) end
|
||||
def rmjd() type.jd_to_mjd(@rjd) end
|
||||
def rtjd() type.jd_to_tjd(@rjd) end
|
||||
def rtjd2() type.jd_to_tjd2(@rjd) end
|
||||
|
||||
once :rmjd, :rtjd, :rtjd2
|
||||
|
||||
def jd() Date.rjd_to_jd(@rjd)[0] end
|
||||
def fr1() Date.rjd_to_jd(@rjd)[1] end
|
||||
def mjd() Date.jd_to_mjd(jd) end
|
||||
def tjd() Date.jd_to_tjd(jd) end
|
||||
def tjd2() Date.jd_to_tjd2(jd) end
|
||||
def ld() Date.jd_to_ld(jd) end
|
||||
def jd() type.rjd_to_jd(@rjd)[0] end
|
||||
def fr1() type.rjd_to_jd(@rjd)[1] end
|
||||
def mjd() type.jd_to_mjd(jd) end
|
||||
def tjd() type.jd_to_tjd(jd) end
|
||||
def tjd2() type.jd_to_tjd2(jd) end
|
||||
def ld() type.jd_to_ld(jd) end
|
||||
|
||||
once :jd, :fr1, :mjd, :tjd, :tjd2, :ld
|
||||
|
||||
def civil() Date.jd_to_civil(jd, @sg) end
|
||||
def ordinal() Date.jd_to_ordinal(jd, @sg) end
|
||||
def commercial() Date.jd_to_commercial(jd, @sg) end
|
||||
def civil() type.jd_to_civil(jd, @sg) end
|
||||
def ordinal() type.jd_to_ordinal(jd, @sg) end
|
||||
def commercial() type.jd_to_commercial(jd, @sg) end
|
||||
|
||||
once :civil, :ordinal, :commercial
|
||||
private :civil, :ordinal, :commercial
|
||||
|
||||
def year() civil[0] end
|
||||
def yday() ordinal[1] end
|
||||
def mon() civil[1] end
|
||||
|
||||
alias_method :month, :mon
|
||||
once :year, :yday, :mon, :month
|
||||
|
||||
def mday() civil[2] end
|
||||
|
||||
alias_method :day, :mday
|
||||
once :mday, :day
|
||||
|
||||
def cwyear() commercial[0] end
|
||||
def cweek() commercial[1] end
|
||||
def cwday() commercial[2] end
|
||||
|
||||
once :cwyear, :cweek, :cwday
|
||||
|
||||
def wday() (jd + 1) % 7 end
|
||||
def wday() type.jd_to_wday(jd) end
|
||||
|
||||
once :wday
|
||||
|
||||
def os? () Date.os?(jd, @sg) end
|
||||
def ns? () Date.ns?(jd, @sg) end
|
||||
def os? () type.os?(jd, @sg) end
|
||||
def ns? () type.ns?(jd, @sg) end
|
||||
|
||||
once :os?, :ns?
|
||||
|
||||
def leap?
|
||||
Date.jd_to_civil(Date.civil_to_jd(year, 3, 1, ns?) - 1,
|
||||
type.jd_to_civil(type.civil_to_jd(year, 3, 1, ns?) - 1,
|
||||
ns?)[-1] == 29
|
||||
end
|
||||
|
||||
once :leap?
|
||||
|
||||
def sg() @sg end
|
||||
def newsg(sg=Date::ITALY) Date.new(@rjd, sg) end
|
||||
def newsg(sg=type::ITALY) type.new(@rjd, sg) end
|
||||
|
||||
def italy() newsg(Date::ITALY) end
|
||||
def england() newsg(Date::ENGLAND) end
|
||||
def julian() newsg(Date::JULIAN) end
|
||||
def gregorian() newsg(Date::GREGORIAN) end
|
||||
def italy() newsg(type::ITALY) end
|
||||
def england() newsg(type::ENGLAND) end
|
||||
def julian() newsg(type::JULIAN) end
|
||||
def gregorian() newsg(type::GREGORIAN) end
|
||||
|
||||
def + (n)
|
||||
case n
|
||||
when Numeric; return Date.new(@rjd + n, @sg)
|
||||
when Numeric; return type.new(@rjd + n, @sg)
|
||||
end
|
||||
fail TypeError, 'expected numeric'
|
||||
end
|
||||
|
||||
def - (x)
|
||||
case x
|
||||
when Numeric; return Date.new(@rjd - x, @sg)
|
||||
when Numeric; return type.new(@rjd - x, @sg)
|
||||
when Date; return @rjd - x.rjd
|
||||
end
|
||||
fail TypeError, 'expected numeric or date'
|
||||
|
@ -310,27 +308,21 @@ class Date
|
|||
end
|
||||
|
||||
def >> (n)
|
||||
y, m = Date.clfloor(year * 12 + (mon - 1) + n, 12)
|
||||
m, = Date.clfloor(m + 1, 1)
|
||||
y, m = type.clfloor(year * 12 + (mon - 1) + n, 12)
|
||||
m, = type.clfloor(m + 1, 1)
|
||||
d = mday
|
||||
d -= 1 until jd2 = Date.exist3?(y, m, d, ns?)
|
||||
d -= 1 until jd2 = type.exist3?(y, m, d, ns?)
|
||||
self + (jd2 - jd)
|
||||
end
|
||||
|
||||
def << (n) self >> -n end
|
||||
|
||||
def step(limit, step)
|
||||
rjd = @rjd
|
||||
if (step > 0)
|
||||
while rjd <= limit.rjd
|
||||
yield Date.new(rjd, @sg)
|
||||
rjd += step
|
||||
end
|
||||
else
|
||||
while rjd >= limit.rjd
|
||||
yield Date.new(rjd, @sg)
|
||||
rjd += step
|
||||
end
|
||||
da = self
|
||||
op = [:-,:<=,:>=][step<=>0]
|
||||
while da.__send__(op, limit)
|
||||
yield da
|
||||
da += step
|
||||
end
|
||||
self
|
||||
end
|
||||
|
@ -343,11 +335,12 @@ class Date
|
|||
alias_method :next, :succ
|
||||
|
||||
def eql? (other) Date === other and self == other end
|
||||
def hash() Date.clfloor(@rjd)[0] end
|
||||
def inspect() format('#<Date: %s,%s>', @rjd, @sg) end
|
||||
def hash() type.clfloor(@rjd)[0] end
|
||||
|
||||
def inspect() format('#<%s: %s,%s>', type, @rjd, @sg) end
|
||||
def to_s() format('%.4d-%02d-%02d', year, mon, mday) end
|
||||
|
||||
def _dump(limit) Marshal.dump([@rjd, @sg], -1) end
|
||||
def Date._load(str) Date.new(*Marshal.load(str)) end
|
||||
def self._load(str) new(*Marshal.load(str)) end
|
||||
|
||||
end
|
||||
|
|
18
lib/mkmf.rb
18
lib/mkmf.rb
|
@ -333,11 +333,6 @@ def create_makefile(target)
|
|||
$DLDFLAGS = $DLDFLAGS + " -L$(topdir)"
|
||||
end
|
||||
|
||||
if RUBY_PLATFORM =~ /beos/
|
||||
$libs = $libs + " " + CONFIG["LIBRUBYARG"]
|
||||
$DLDFLAGS = $DLDFLAGS + " -L" + CONFIG["prefix"] + "/lib"
|
||||
end
|
||||
|
||||
defflag = ''
|
||||
if RUBY_PLATFORM =~ /cygwin|mingw/
|
||||
if File.exist? target + ".def"
|
||||
|
@ -447,19 +442,6 @@ EOMF
|
|||
dfile.close
|
||||
end
|
||||
mfile.close
|
||||
|
||||
if RUBY_PLATFORM =~ /beos/
|
||||
if RUBY_PLATFORM =~ /^powerpc/ then
|
||||
deffilename = "ruby.exp"
|
||||
else
|
||||
deffilename = "ruby.def"
|
||||
end
|
||||
print "creating #{deffilename}\n"
|
||||
open(deffilename, "w") do |file|
|
||||
file.print("EXPORTS\n") if RUBY_PLATFORM =~ /^i/
|
||||
file.print("Init_#{target}\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
$OBJEXT = CONFIG["OBJEXT"]
|
||||
|
|
|
@ -148,7 +148,7 @@ w_symbol(id, arg)
|
|||
struct dump_arg *arg;
|
||||
{
|
||||
char *sym = rb_id2name(id);
|
||||
int num;
|
||||
long num;
|
||||
|
||||
if (st_lookup(arg->symbol, id, &num)) {
|
||||
w_byte(TYPE_SYMLINK, arg);
|
||||
|
@ -258,7 +258,7 @@ w_object(obj, arg, limit)
|
|||
return;
|
||||
}
|
||||
else {
|
||||
int num;
|
||||
long num;
|
||||
|
||||
limit--;
|
||||
c_arg.limit = limit;
|
||||
|
@ -381,7 +381,7 @@ w_object(obj, arg, limit)
|
|||
w_long(len, arg);
|
||||
mem = rb_ivar_get(CLASS_OF(obj), rb_intern("__member__"));
|
||||
if (mem == Qnil) {
|
||||
rb_raise(rb_eTypeError, "non-initialized struct");
|
||||
rb_raise(rb_eTypeError, "uninitialized struct");
|
||||
}
|
||||
for (i=0; i<len; i++) {
|
||||
w_symbol(FIX2LONG(RARRAY(mem)->ptr[i]), arg);
|
||||
|
@ -813,7 +813,7 @@ r_object(arg)
|
|||
klass = rb_path2class(r_unique(arg));
|
||||
mem = rb_ivar_get(klass, rb_intern("__member__"));
|
||||
if (mem == Qnil) {
|
||||
rb_raise(rb_eTypeError, "non-initialized struct");
|
||||
rb_raise(rb_eTypeError, "uninitialized struct");
|
||||
}
|
||||
len = r_long(arg);
|
||||
|
||||
|
|
|
@ -14,7 +14,11 @@
|
|||
(substring ruby-mode-revision (match-beginning 0) (match-end 0))))
|
||||
|
||||
(defconst ruby-block-beg-re
|
||||
"class\\|module\\|def\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin\\|do"
|
||||
"class\\|module\\|def\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin"
|
||||
)
|
||||
|
||||
(defconst ruby-non-block-do-re
|
||||
"while\\|until\\|for\\|rescue"
|
||||
)
|
||||
|
||||
(defconst ruby-indent-beg-re
|
||||
|
@ -372,6 +376,39 @@ The variable ruby-indent-level controls the amount of indentation.
|
|||
(goto-char (match-end 0)))
|
||||
((looking-at ruby-block-beg-re)
|
||||
(and
|
||||
(or (not (looking-at "do\\>[^_]"))
|
||||
(save-excursion
|
||||
(back-to-indentation)
|
||||
(not (looking-at ruby-non-block-do-re))))
|
||||
(or (bolp)
|
||||
(progn
|
||||
(forward-char -1)
|
||||
(setq w (char-after (point)))
|
||||
(not (or (eq ?_ w)
|
||||
(eq ?. w)))))
|
||||
(goto-char pnt)
|
||||
(setq w (char-after (point)))
|
||||
(not (eq ?_ w))
|
||||
(not (eq ?! w))
|
||||
(not (eq ?? w))
|
||||
(skip-chars-forward " \t")
|
||||
(if (not (eolp))
|
||||
(progn
|
||||
(goto-char (match-beginning 0))
|
||||
(if (looking-at ruby-modifier-re)
|
||||
(ruby-expr-beg 'modifier)
|
||||
t))
|
||||
t)
|
||||
(goto-char pnt)
|
||||
(setq nest (cons (cons nil pnt) nest))
|
||||
(setq depth (1+ depth)))
|
||||
(goto-char pnt))
|
||||
((looking-at ruby-block-beg-re)
|
||||
(and
|
||||
(or (not (looking-at "do\\>[^_]"))
|
||||
(save-excursion
|
||||
(back-to-indentation)
|
||||
(not (looking-at ruby-non-block-do-re))))
|
||||
(or (bolp)
|
||||
(progn
|
||||
(forward-char -1)
|
||||
|
@ -462,7 +499,7 @@ The variable ruby-indent-level controls the amount of indentation.
|
|||
(goto-char (cdr (nth 1 state)))
|
||||
(forward-word -1) ; skip back a keyword
|
||||
(cond
|
||||
((looking-at "do") ; iter block is a special case
|
||||
((looking-at "do\\>[^_]") ; iter block is a special case
|
||||
(cond
|
||||
((nth 3 state)
|
||||
(goto-char (nth 3 state))
|
||||
|
|
6
node.h
6
node.h
|
@ -135,15 +135,15 @@ typedef struct RNode {
|
|||
union {
|
||||
struct RNode *node;
|
||||
ID id;
|
||||
int argc;
|
||||
long argc;
|
||||
VALUE value;
|
||||
} u2;
|
||||
union {
|
||||
struct RNode *node;
|
||||
ID id;
|
||||
int state;
|
||||
long state;
|
||||
struct global_entry *entry;
|
||||
int cnt;
|
||||
long cnt;
|
||||
VALUE value;
|
||||
} u3;
|
||||
} NODE;
|
||||
|
|
22
object.c
22
object.c
|
@ -159,9 +159,8 @@ inspect_i(id, value, str)
|
|||
/* need not to show internal data */
|
||||
if (CLASS_OF(value) == 0) return ST_CONTINUE;
|
||||
if (!rb_is_instance_id(id)) return ST_CONTINUE;
|
||||
if (RSTRING(str)->ptr[0] == '-') {
|
||||
if (RSTRING(str)->ptr[0] == '-') { /* first element */
|
||||
RSTRING(str)->ptr[0] = '#';
|
||||
rb_str_cat2(str, ": ");
|
||||
}
|
||||
else {
|
||||
rb_str_cat2(str, ", ");
|
||||
|
@ -195,16 +194,17 @@ rb_obj_inspect(obj)
|
|||
&& ROBJECT(obj)->iv_tbl
|
||||
&& ROBJECT(obj)->iv_tbl->num_entries > 0) {
|
||||
VALUE str;
|
||||
char *b;
|
||||
char *c, *b;
|
||||
|
||||
b = rb_class2name(CLASS_OF(obj));
|
||||
c = rb_class2name(CLASS_OF(obj));
|
||||
if (rb_inspecting_p(obj)) {
|
||||
char *buf = ALLOCA_N(char, strlen(b)+8);
|
||||
sprintf(buf, "#<%s:...>", b);
|
||||
return rb_str_new2(buf);
|
||||
b = ALLOCA_N(char, strlen(c)+8+16+1); /* 8:tags 16:addr 1:eos */
|
||||
sprintf(b, "#<%s:0x%lx ...>", c, obj);
|
||||
return rb_str_new2(b);
|
||||
}
|
||||
str = rb_str_new2("-<");
|
||||
rb_str_cat2(str, b);
|
||||
b = ALLOCA_N(char, strlen(c)+4+16+1); /* 4:tags 16:addr 1:eos */
|
||||
sprintf(b, "-<%s:0x%lx ", c, obj);
|
||||
str = rb_str_new2(b);
|
||||
return rb_protect_inspect(inspect_obj, obj, str);
|
||||
}
|
||||
return rb_funcall(obj, rb_intern("to_s"), 0, 0);
|
||||
|
@ -630,6 +630,7 @@ rb_module_s_new(klass)
|
|||
VALUE mod = rb_module_new();
|
||||
|
||||
RBASIC(mod)->klass = klass;
|
||||
rb_obj_call_init(klass, 0, 0);
|
||||
return mod;
|
||||
}
|
||||
|
||||
|
@ -651,6 +652,7 @@ rb_class_s_new(argc, argv)
|
|||
/* make metaclass */
|
||||
RBASIC(klass)->klass = rb_singleton_class_new(RBASIC(super)->klass);
|
||||
rb_singleton_class_attached(RBASIC(klass)->klass, klass);
|
||||
rb_obj_call_init(klass, argc, argv);
|
||||
rb_funcall(super, rb_intern("inherited"), 1, klass);
|
||||
|
||||
return klass;
|
||||
|
@ -1086,7 +1088,7 @@ Init_Object()
|
|||
rb_define_method(rb_mKernel, "private_methods", rb_obj_private_methods, 0);
|
||||
rb_define_method(rb_mKernel, "instance_variables", rb_obj_instance_variables, 0);
|
||||
rb_define_private_method(rb_mKernel, "remove_instance_variable",
|
||||
rb_obj_remove_instance_variable, 0);
|
||||
rb_obj_remove_instance_variable, 1);
|
||||
|
||||
rb_define_method(rb_mKernel, "instance_of?", rb_obj_is_instance_of, 1);
|
||||
rb_define_method(rb_mKernel, "kind_of?", rb_obj_is_kind_of, 1);
|
||||
|
|
6
pack.c
6
pack.c
|
@ -23,9 +23,9 @@
|
|||
|
||||
#ifdef NATINT_PACK
|
||||
# define NATINT_LEN(type,len) (natint?sizeof(type):(len))
|
||||
# ifndef WORDS_BIGENDIAN
|
||||
# define OFF16(p) ((char*)(p) + (natint?(sizeof(short) - 2):0))
|
||||
# define OFF32(p) ((char*)(p) + (natint?(sizeof(long) - 4):0))
|
||||
# ifdef WORDS_BIGENDIAN
|
||||
# define OFF16(p) ((char*)(p) + (natint?0:(sizeof(short) - 2)))
|
||||
# define OFF32(p) ((char*)(p) + (natint?0:(sizeof(long) - 4)))
|
||||
# endif
|
||||
#else
|
||||
# define NATINT_LEN(type,len) sizeof(type)
|
||||
|
|
2
parse.y
2
parse.y
|
@ -2256,7 +2256,7 @@ parse_regx(term, paren)
|
|||
case 'x':
|
||||
options |= RE_OPTION_EXTENDED;
|
||||
break;
|
||||
case 'p': /* /p is obsolete, works as /m */
|
||||
case 'p': /* /p is obsolete */
|
||||
rb_warn("/p option is obsolete; use /m\n\tnote: /m does not change ^, $ behavior");
|
||||
options |= RE_OPTION_POSIXLINE;
|
||||
break;
|
||||
|
|
|
@ -509,7 +509,7 @@ rb_f_fork(obj)
|
|||
#ifdef linux
|
||||
after_exec();
|
||||
#endif
|
||||
if (rb_iterator_p()) {
|
||||
if (rb_block_given_p()) {
|
||||
rb_yield(Qnil);
|
||||
_exit(0);
|
||||
}
|
||||
|
|
14
re.c
14
re.c
|
@ -1060,22 +1060,20 @@ static int
|
|||
rb_reg_get_kcode(re)
|
||||
VALUE re;
|
||||
{
|
||||
int kcode = 0;
|
||||
int kcode;
|
||||
|
||||
switch (RBASIC(re)->flags & KCODE_MASK) {
|
||||
case KCODE_NONE:
|
||||
kcode |= 16; break;
|
||||
return 16;
|
||||
case KCODE_EUC:
|
||||
kcode |= 32; break;
|
||||
return 32;
|
||||
case KCODE_SJIS:
|
||||
kcode |= 48; break;
|
||||
return 48;
|
||||
case KCODE_UTF8:
|
||||
kcode |= 64; break;
|
||||
return 64;
|
||||
default:
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return kcode;
|
||||
}
|
||||
|
||||
int
|
||||
|
|
197
regex.c
197
regex.c
|
@ -232,27 +232,27 @@ re_set_casetable(table)
|
|||
#endif
|
||||
|
||||
#ifdef isblank
|
||||
# define ISBLANK(c) (ISASCII (c) && isblank (c))
|
||||
# define ISBLANK(c) (ISASCII(c) && isblank(c))
|
||||
#else
|
||||
# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
|
||||
#endif
|
||||
#ifdef isgraph
|
||||
# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
|
||||
# define ISGRAPH(c) (ISASCII(c) && isgraph(c))
|
||||
#else
|
||||
# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
|
||||
# define ISGRAPH(c) (ISASCII(c) && isprint(c) && !isspace(c))
|
||||
#endif
|
||||
|
||||
#undef ISPRINT
|
||||
#define ISPRINT(c) (ISASCII (c) && isprint (c))
|
||||
#define ISDIGIT(c) (ISASCII (c) && isdigit (c))
|
||||
#define ISALNUM(c) (ISASCII (c) && isalnum (c))
|
||||
#define ISALPHA(c) (ISASCII (c) && isalpha (c))
|
||||
#define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
|
||||
#define ISLOWER(c) (ISASCII (c) && islower (c))
|
||||
#define ISPUNCT(c) (ISASCII (c) && ispunct (c))
|
||||
#define ISSPACE(c) (ISASCII (c) && isspace (c))
|
||||
#define ISUPPER(c) (ISASCII (c) && isupper (c))
|
||||
#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
|
||||
#define ISPRINT(c) (ISASCII(c) && isprint(c))
|
||||
#define ISDIGIT(c) (ISASCII(c) && isdigit(c))
|
||||
#define ISALNUM(c) (ISASCII(c) && isalnum(c))
|
||||
#define ISALPHA(c) (ISASCII(c) && isalpha(c))
|
||||
#define ISCNTRL(c) (ISASCII(c) && iscntrl(c))
|
||||
#define ISLOWER(c) (ISASCII(c) && islower(c))
|
||||
#define ISPUNCT(c) (ISASCII(c) && ispunct(c))
|
||||
#define ISSPACE(c) (ISASCII(c) && isspace(c))
|
||||
#define ISUPPER(c) (ISASCII(c) && isupper(c))
|
||||
#define ISXDIGIT(c) (ISASCII(c) && isxdigit(c))
|
||||
|
||||
#ifndef NULL
|
||||
# define NULL (void *)0
|
||||
|
@ -264,10 +264,10 @@ re_set_casetable(table)
|
|||
(Per Bothner suggested the basic approach.) */
|
||||
#undef SIGN_EXTEND_CHAR
|
||||
#if __STDC__
|
||||
# define SIGN_EXTEND_CHAR(c) ((signed char) (c))
|
||||
# define SIGN_EXTEND_CHAR(c) ((signed char)(c))
|
||||
#else /* not __STDC__ */
|
||||
/* As in Harbison and Steele. */
|
||||
# define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
|
||||
# define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
|
||||
#endif
|
||||
|
||||
/* These are the command codes that appear in compiled regular
|
||||
|
@ -350,10 +350,7 @@ enum regexpcode
|
|||
stop_paren, /* Place holder at the end of (?:..). */
|
||||
casefold_on, /* Turn on casefold flag. */
|
||||
casefold_off, /* Turn off casefold flag. */
|
||||
mline_on, /* Turn on multi line match (match with newlines). */
|
||||
mline_off, /* Turn off multi line match. */
|
||||
posix_on, /* Turn on POSIXified line match (match with newlines). */
|
||||
posix_off, /* Turn off POSIXified line match. */
|
||||
option_set, /* Turn on multi line match (match with newlines). */
|
||||
start_nowidth, /* Save string point to the stack. */
|
||||
stop_nowidth, /* Restore string place at the point start_nowidth. */
|
||||
pop_and_fail, /* Fail after popping nowidth entry from stack. */
|
||||
|
@ -395,7 +392,7 @@ enum regexpcode
|
|||
at SOURCE. */
|
||||
#define EXTRACT_NUMBER(destination, source) \
|
||||
do { (destination) = *(source) & 0377; \
|
||||
(destination) += SIGN_EXTEND_CHAR (*(char*)((source) + 1)) << 8; } while (0)
|
||||
(destination) += SIGN_EXTEND_CHAR(*(char*)((source) + 1)) << 8; } while (0)
|
||||
|
||||
/* Same as EXTRACT_NUMBER, except increment the pointer for source to
|
||||
point to second byte of SOURCE. Note that SOURCE has to be a value
|
||||
|
@ -538,7 +535,7 @@ print_mbc(c)
|
|||
if (bufp->allocated == (1L<<16)) goto too_big; \
|
||||
bufp->allocated *= 2; \
|
||||
if (bufp->allocated > (1L<<16)) bufp->allocated = (1L<<16); \
|
||||
bufp->buffer = (char*)xrealloc (bufp->buffer, bufp->allocated); \
|
||||
bufp->buffer = (char*)xrealloc(bufp->buffer, bufp->allocated); \
|
||||
if (bufp->buffer == 0) \
|
||||
goto memory_exhausted; \
|
||||
b = (b - old_buffer) + bufp->buffer; \
|
||||
|
@ -572,7 +569,7 @@ print_mbc(c)
|
|||
} \
|
||||
} while (0)
|
||||
|
||||
#define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
|
||||
#define STREQ(s1, s2) ((strcmp(s1, s2) == 0))
|
||||
|
||||
#define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */
|
||||
|
||||
|
@ -766,22 +763,12 @@ print_partial_compiled_pattern(start, end)
|
|||
printf("/casefold_off");
|
||||
break;
|
||||
|
||||
case mline_on:
|
||||
printf("/mline_on");
|
||||
case option_set:
|
||||
printf("/option_set/%d", *p++);
|
||||
break;
|
||||
|
||||
case mline_off:
|
||||
printf("/mline_off");
|
||||
break;
|
||||
|
||||
case posix_on:
|
||||
printf("/posix_on");
|
||||
|
||||
case posix_off:
|
||||
printf("/posix_off");
|
||||
|
||||
case start_nowidth:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/start_nowidth//%d", mcnt);
|
||||
break;
|
||||
|
||||
|
@ -851,12 +838,12 @@ print_partial_compiled_pattern(start, end)
|
|||
break;
|
||||
|
||||
case on_failure_jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/on_failure_jump//%d", mcnt);
|
||||
break;
|
||||
|
||||
case dummy_failure_jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/dummy_failure_jump//%d", mcnt);
|
||||
break;
|
||||
|
||||
|
@ -865,56 +852,56 @@ print_partial_compiled_pattern(start, end)
|
|||
break;
|
||||
|
||||
case finalize_jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/finalize_jump//%d", mcnt);
|
||||
break;
|
||||
|
||||
case maybe_finalize_jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/maybe_finalize_jump//%d", mcnt);
|
||||
break;
|
||||
|
||||
case jump_past_alt:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/jump_past_alt//%d", mcnt);
|
||||
break;
|
||||
|
||||
case jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/jump//%d", mcnt);
|
||||
break;
|
||||
|
||||
case succeed_n:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt2, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt2, p);
|
||||
printf("/succeed_n//%d//%d", mcnt, mcnt2);
|
||||
break;
|
||||
|
||||
case jump_n:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt2, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt2, p);
|
||||
printf("/jump_n//%d//%d", mcnt, mcnt2);
|
||||
break;
|
||||
|
||||
case set_number_at:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt2, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt2, p);
|
||||
printf("/set_number_at//%d//%d", mcnt, mcnt2);
|
||||
break;
|
||||
|
||||
case try_next:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/try_next//%d", mcnt);
|
||||
break;
|
||||
|
||||
case finalize_push:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
printf("/finalize_push//%d", mcnt);
|
||||
break;
|
||||
|
||||
case finalize_push_n:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt2, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt2, p);
|
||||
printf("/finalize_push_n//%d//%d", mcnt, mcnt2);
|
||||
break;
|
||||
|
||||
|
@ -971,7 +958,7 @@ print_compiled_pattern(bufp)
|
|||
{
|
||||
unsigned char *buffer = (unsigned char*)bufp->buffer;
|
||||
|
||||
print_partial_compiled_pattern (buffer, buffer + bufp->used);
|
||||
print_partial_compiled_pattern(buffer, buffer + bufp->used);
|
||||
}
|
||||
|
||||
static char*
|
||||
|
@ -1033,10 +1020,7 @@ calculate_must_string(start, end)
|
|||
case push_dummy_failure:
|
||||
case start_paren:
|
||||
case stop_paren:
|
||||
case mline_on:
|
||||
case mline_off:
|
||||
case posix_on:
|
||||
case posix_off:
|
||||
case option_set:
|
||||
break;
|
||||
|
||||
case charset:
|
||||
|
@ -1050,11 +1034,11 @@ calculate_must_string(start, end)
|
|||
break;
|
||||
|
||||
case on_failure_jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
if (mcnt > 0) p += mcnt;
|
||||
if ((enum regexpcode)p[-3] == jump) {
|
||||
p -= 3;
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
if (mcnt > 0) p += mcnt;
|
||||
}
|
||||
break;
|
||||
|
@ -1063,7 +1047,7 @@ calculate_must_string(start, end)
|
|||
case succeed_n:
|
||||
case try_next:
|
||||
case jump:
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p);
|
||||
if (mcnt > 0) p += mcnt;
|
||||
break;
|
||||
|
||||
|
@ -1260,6 +1244,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
int had_char_class = 0;
|
||||
|
||||
int options = bufp->options;
|
||||
int old_options = 0;
|
||||
|
||||
bufp->fastmap_accurate = 0;
|
||||
bufp->must = 0;
|
||||
|
@ -1273,7 +1258,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
bufp->allocated = INIT_BUF_SIZE;
|
||||
if (bufp->buffer)
|
||||
/* EXTEND_BUFFER loses when bufp->allocated is 0. */
|
||||
bufp->buffer = (char*)xrealloc (bufp->buffer, INIT_BUF_SIZE);
|
||||
bufp->buffer = (char*)xrealloc(bufp->buffer, INIT_BUF_SIZE);
|
||||
else
|
||||
/* Caller did not allocate a buffer. Do it for them. */
|
||||
bufp->buffer = (char*)xmalloc(INIT_BUF_SIZE);
|
||||
|
@ -1286,7 +1271,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
|
||||
switch (c) {
|
||||
case '$':
|
||||
if (bufp->options & RE_OPTION_POSIXLINE) {
|
||||
if (bufp->options & RE_OPTION_SINGLELINE) {
|
||||
BUFPUSH(endbuf);
|
||||
}
|
||||
else {
|
||||
|
@ -1306,7 +1291,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
break;
|
||||
|
||||
case '^':
|
||||
if (bufp->options & RE_OPTION_POSIXLINE)
|
||||
if (bufp->options & RE_OPTION_SINGLELINE)
|
||||
BUFPUSH(begbuf);
|
||||
else
|
||||
BUFPUSH(begline);
|
||||
|
@ -1576,7 +1561,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
/* Leave room for the null. */
|
||||
char str[CHAR_CLASS_MAX_LENGTH + 1];
|
||||
|
||||
PATFETCH_RAW (c);
|
||||
PATFETCH_RAW(c);
|
||||
c1 = 0;
|
||||
|
||||
/* If pattern is `[[:'. */
|
||||
|
@ -1610,11 +1595,11 @@ re_compile_pattern(pattern, size, bufp)
|
|||
char is_upper = STREQ(str, "upper");
|
||||
char is_xdigit = STREQ(str, "xdigit");
|
||||
|
||||
if (!IS_CHAR_CLASS (str))
|
||||
if (!IS_CHAR_CLASS(str))
|
||||
goto invalid_pattern;
|
||||
|
||||
/* Throw away the ] at the end of the character class. */
|
||||
PATFETCH (c);
|
||||
PATFETCH(c);
|
||||
|
||||
if (p == pend)
|
||||
goto invalid_pattern;
|
||||
|
@ -1632,7 +1617,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
|| (is_space && ISSPACE(ch))
|
||||
|| (is_upper && ISUPPER(ch))
|
||||
|| (is_xdigit && ISXDIGIT(ch)))
|
||||
SET_LIST_BIT (ch);
|
||||
SET_LIST_BIT(ch);
|
||||
}
|
||||
had_char_class = 1;
|
||||
}
|
||||
|
@ -1661,14 +1646,16 @@ re_compile_pattern(pattern, size, bufp)
|
|||
b[-1]--;
|
||||
if (b[-1] != (1 << BYTEWIDTH) / BYTEWIDTH)
|
||||
memmove(&b[b[-1]], &b[(1 << BYTEWIDTH) / BYTEWIDTH],
|
||||
2 + EXTRACT_UNSIGNED (&b[(1 << BYTEWIDTH) / BYTEWIDTH])*8);
|
||||
b += b[-1] + 2 + EXTRACT_UNSIGNED (&b[b[-1]])*8;
|
||||
2 + EXTRACT_UNSIGNED(&b[(1 << BYTEWIDTH) / BYTEWIDTH])*8);
|
||||
b += b[-1] + 2 + EXTRACT_UNSIGNED(&b[b[-1]])*8;
|
||||
break;
|
||||
|
||||
case '(':
|
||||
old_options = options;
|
||||
PATFETCH(c);
|
||||
if (c == '?') {
|
||||
int negative = 0;
|
||||
int push_option = 0;
|
||||
PATFETCH_RAW(c);
|
||||
switch (c) {
|
||||
case 'x': case 'p': case 'm': case 'i': case '-':
|
||||
|
@ -1691,28 +1678,26 @@ re_compile_pattern(pattern, size, bufp)
|
|||
|
||||
case 'p':
|
||||
if (negative) {
|
||||
if (options&RE_OPTION_POSIXLINE) {
|
||||
if ((options&RE_OPTION_POSIXLINE) == RE_OPTION_POSIXLINE) {
|
||||
options &= ~RE_OPTION_POSIXLINE;
|
||||
BUFPUSH(posix_off);
|
||||
}
|
||||
}
|
||||
else if (!(options&RE_OPTION_POSIXLINE)) {
|
||||
else if ((options&RE_OPTION_POSIXLINE) != RE_OPTION_POSIXLINE) {
|
||||
options |= RE_OPTION_POSIXLINE;
|
||||
BUFPUSH(posix_on);
|
||||
}
|
||||
push_option = 1;
|
||||
break;
|
||||
|
||||
case 'm':
|
||||
if (negative) {
|
||||
if (options&RE_OPTION_MULTILINE) {
|
||||
options &= ~RE_OPTION_MULTILINE;
|
||||
BUFPUSH(mline_off);
|
||||
}
|
||||
}
|
||||
else if (!(options&RE_OPTION_MULTILINE)) {
|
||||
options |= RE_OPTION_MULTILINE;
|
||||
BUFPUSH(mline_on);
|
||||
}
|
||||
push_option = 1;
|
||||
break;
|
||||
|
||||
case 'i':
|
||||
|
@ -1757,6 +1742,10 @@ re_compile_pattern(pattern, size, bufp)
|
|||
default:
|
||||
FREE_AND_RETURN(stackb, "undefined (?...) sequence");
|
||||
}
|
||||
if (push_option) {
|
||||
BUFPUSH(option_set);
|
||||
BUFPUSH(options);
|
||||
}
|
||||
}
|
||||
else {
|
||||
PATUNFETCH;
|
||||
|
@ -1813,7 +1802,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
break;
|
||||
}
|
||||
*stackp++ = c;
|
||||
*stackp++ = options;
|
||||
*stackp++ = old_options;
|
||||
fixup_alt_jump = 0;
|
||||
laststart = 0;
|
||||
begalt = b;
|
||||
|
@ -1822,14 +1811,13 @@ re_compile_pattern(pattern, size, bufp)
|
|||
case ')':
|
||||
if (stackp == stackb)
|
||||
FREE_AND_RETURN(stackb, "unmatched )");
|
||||
if ((options ^ stackp[-1]) & RE_OPTION_IGNORECASE) {
|
||||
BUFPUSH((options&RE_OPTION_IGNORECASE)?casefold_off:casefold_on);
|
||||
}
|
||||
if ((options ^ stackp[-1]) & RE_OPTION_POSIXLINE) {
|
||||
BUFPUSH((options&RE_OPTION_MULTILINE)?posix_off:posix_on);
|
||||
}
|
||||
if ((options ^ stackp[-1]) & RE_OPTION_MULTILINE) {
|
||||
BUFPUSH((options&RE_OPTION_MULTILINE)?mline_off:mline_on);
|
||||
|
||||
if (options != stackp[-1]) {
|
||||
if ((options ^ stackp[-1]) & RE_OPTION_IGNORECASE) {
|
||||
BUFPUSH((options&RE_OPTION_IGNORECASE)?casefold_off:casefold_on);
|
||||
}
|
||||
BUFPUSH(option_set);
|
||||
BUFPUSH(stackp[-1]);
|
||||
}
|
||||
pending_exact = 0;
|
||||
if (fixup_alt_jump) {
|
||||
|
@ -2111,7 +2099,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
beg_interval = 0;
|
||||
|
||||
/* normal_char and normal_backslash need `c'. */
|
||||
PATFETCH (c);
|
||||
PATFETCH(c);
|
||||
goto normal_char;
|
||||
|
||||
case '\\':
|
||||
|
@ -2195,7 +2183,7 @@ re_compile_pattern(pattern, size, bufp)
|
|||
break;
|
||||
|
||||
case 'Z':
|
||||
if ((bufp->options & RE_OPTION_POSIXLINE) == 0) {
|
||||
if ((bufp->options & RE_OPTION_SINGLELINE) == 0) {
|
||||
BUFPUSH(endbuf2);
|
||||
break;
|
||||
}
|
||||
|
@ -2789,14 +2777,8 @@ re_compile_fastmap(bufp)
|
|||
options ^= RE_OPTION_IGNORECASE;
|
||||
continue;
|
||||
|
||||
case mline_on:
|
||||
case mline_off:
|
||||
options ^= RE_OPTION_MULTILINE;
|
||||
continue;
|
||||
|
||||
case posix_on:
|
||||
case posix_off:
|
||||
options ^= RE_OPTION_POSIXLINE;
|
||||
case option_set:
|
||||
options = *p++;
|
||||
continue;
|
||||
|
||||
case endline:
|
||||
|
@ -2804,7 +2786,7 @@ re_compile_fastmap(bufp)
|
|||
fastmap[translate['\n']] = 1;
|
||||
else
|
||||
fastmap['\n'] = 1;
|
||||
if ((options & RE_OPTION_POSIXLINE) == 0 && bufp->can_be_null == 0)
|
||||
if ((options & RE_OPTION_SINGLELINE) == 0 && bufp->can_be_null == 0)
|
||||
bufp->can_be_null = 2;
|
||||
break;
|
||||
|
||||
|
@ -2889,7 +2871,7 @@ re_compile_fastmap(bufp)
|
|||
case anychar_repeat:
|
||||
case anychar:
|
||||
for (j = 0; j < (1 << BYTEWIDTH); j++) {
|
||||
if (j != '\n' || (options & RE_OPTION_POSIXLINE))
|
||||
if (j != '\n' || (options & RE_OPTION_MULTILINE))
|
||||
fastmap[j] = 1;
|
||||
}
|
||||
if (bufp->can_be_null) {
|
||||
|
@ -3167,7 +3149,7 @@ re_search(bufp, string, size, startpos, range, regs)
|
|||
}
|
||||
}
|
||||
if (bufp->options & RE_OPTIMIZE_ANCHOR) {
|
||||
if (bufp->options&RE_OPTION_POSIXLINE) {
|
||||
if (bufp->options&RE_OPTION_SINGLELINE) {
|
||||
goto begbuf_match;
|
||||
}
|
||||
anchor = 1;
|
||||
|
@ -3783,9 +3765,8 @@ re_match(bufp, string_arg, size, pos, regs)
|
|||
d += mbclen(*d);
|
||||
break;
|
||||
}
|
||||
if (!(options&RE_OPTION_MULTILINE) &&
|
||||
!(options&RE_OPTION_POSIXLINE) &&
|
||||
(TRANSLATE_P() ? translate[*d] : *d) == '\n')
|
||||
if (!(options&RE_OPTION_MULTILINE)
|
||||
&& (TRANSLATE_P() ? translate[*d] : *d) == '\n')
|
||||
goto fail;
|
||||
SET_REGS_MATCHED;
|
||||
d++;
|
||||
|
@ -4132,20 +4113,8 @@ re_match(bufp, string_arg, size, pos, regs)
|
|||
options &= ~RE_OPTION_IGNORECASE;
|
||||
continue;
|
||||
|
||||
case mline_on:
|
||||
options |= RE_OPTION_MULTILINE;
|
||||
continue;
|
||||
|
||||
case mline_off:
|
||||
options &= ~RE_OPTION_MULTILINE;
|
||||
continue;
|
||||
|
||||
case posix_on:
|
||||
options |= RE_OPTION_POSIXLINE;
|
||||
continue;
|
||||
|
||||
case posix_off:
|
||||
options &= ~RE_OPTION_POSIXLINE;
|
||||
case option_set:
|
||||
options = *p++;
|
||||
continue;
|
||||
|
||||
case wordbound:
|
||||
|
@ -4308,7 +4277,7 @@ re_match(bufp, string_arg, size, pos, regs)
|
|||
case finalize_push:
|
||||
case jump:
|
||||
p1++;
|
||||
EXTRACT_NUMBER_AND_INCR (mcnt, p1);
|
||||
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
|
||||
|
||||
if (mcnt >= 0) break; /* should be backward jump */
|
||||
p1 += mcnt;
|
||||
|
|
10
regex.h
10
regex.h
|
@ -69,12 +69,14 @@
|
|||
#define RE_OPTION_IGNORECASE (1L)
|
||||
/* perl-style extended pattern available */
|
||||
#define RE_OPTION_EXTENDED (RE_OPTION_IGNORECASE<<1)
|
||||
/* newline will be included for ., ^ and $ ignore newline */
|
||||
#define RE_OPTION_POSIXLINE (RE_OPTION_EXTENDED<<1)
|
||||
/* newline will be included for . */
|
||||
#define RE_OPTION_MULTILINE (RE_OPTION_POSIXLINE<<1)
|
||||
#define RE_OPTION_MULTILINE (RE_OPTION_EXTENDED<<1)
|
||||
/* ^ and $ ignore newline */
|
||||
#define RE_OPTION_SINGLELINE (RE_OPTION_MULTILINE<<1)
|
||||
/* works line Perl's /s; it's called POSIX for wrong reason */
|
||||
#define RE_OPTION_POSIXLINE (RE_OPTION_MULTILINE|RE_OPTION_SINGLELINE)
|
||||
/* search for longest match, in accord with POSIX regexp */
|
||||
#define RE_OPTION_LONGEST (RE_OPTION_MULTILINE<<1)
|
||||
#define RE_OPTION_LONGEST (RE_OPTION_POSIXLINE<<1)
|
||||
|
||||
#define RE_MAY_IGNORECASE (RE_OPTION_LONGEST<<1)
|
||||
#define RE_OPTIMIZE_ANCHOR (RE_MAY_IGNORECASE<<1)
|
||||
|
|
4
ruby.1
4
ruby.1
|
@ -6,7 +6,7 @@ ruby - Interpreted object-oriented scripting language
|
|||
.SH SYNOPSIS
|
||||
.B ruby \c
|
||||
[ \c
|
||||
.BI -version \c
|
||||
.BI --version \c
|
||||
] [ \c
|
||||
.BI -c \c
|
||||
] [ \c
|
||||
|
@ -48,7 +48,7 @@ ruby - Interpreted object-oriented scripting language
|
|||
] [ \c
|
||||
.BI -x "[directory]"\c
|
||||
] [ \c
|
||||
.BI -X "directory"\c
|
||||
.BI -C "directory"\c
|
||||
]
|
||||
[ \c
|
||||
.BI -y \c
|
||||
|
|
1
ruby.c
1
ruby.c
|
@ -641,7 +641,6 @@ proc_options(argc, argv)
|
|||
addpath(getenv("RUBYLIB"));
|
||||
}
|
||||
|
||||
|
||||
process_sflag();
|
||||
xflag = 0;
|
||||
}
|
||||
|
|
2
ruby.h
2
ruby.h
|
@ -455,7 +455,7 @@ void rb_warning __((const char*, ...)); /* reports if `-w' specified */
|
|||
|
||||
VALUE rb_each _((VALUE));
|
||||
VALUE rb_yield _((VALUE));
|
||||
int rb_iterator_p _((void));
|
||||
int rb_block_given_p _((void));
|
||||
VALUE rb_iterate _((VALUE(*)(),VALUE,VALUE(*)(),VALUE));
|
||||
VALUE rb_rescue _((VALUE(*)(),VALUE,VALUE(*)(),VALUE));
|
||||
VALUE rb_ensure _((VALUE(*)(),VALUE,VALUE(*)(),VALUE));
|
||||
|
|
149
sample/cal.rb
149
sample/cal.rb
|
@ -1,9 +1,10 @@
|
|||
#! /usr/local/bin/ruby
|
||||
|
||||
# cal.rb: Written by Tadayoshi Funaba 1998, 1999
|
||||
# $Id: cal.rb,v 1.6 1999/09/15 05:35:25 tadf Exp $
|
||||
# cal.rb: Written by Tadayoshi Funaba 1998-2000
|
||||
# $Id: cal.rb,v 1.10 2000/05/20 02:09:47 tadf Exp $
|
||||
|
||||
require 'date2'
|
||||
require 'getopts'
|
||||
|
||||
$tab =
|
||||
{
|
||||
|
@ -31,89 +32,81 @@ $tab =
|
|||
$cc = 'gb'
|
||||
|
||||
def usage
|
||||
$stderr.puts 'usage: cal [-c iso3166] [-jy] [[month] year]'
|
||||
$stderr.puts 'usage: cal [-c iso3166] [-jmty] [[month] year]'
|
||||
exit 1
|
||||
end
|
||||
|
||||
def cal(m, y, sg)
|
||||
for d in 1..31
|
||||
break if jd = Date.exist?(y, m, d, sg)
|
||||
end
|
||||
fst = cur = Date.new1(jd, sg)
|
||||
ti = Date::MONTHNAMES[m]
|
||||
ti << ' ' << y.to_s unless $yr
|
||||
mo = ti.center((($w + 1) * 7) - 1) << "\n"
|
||||
mo << ['S', 'M', 'Tu', 'W', 'Th', 'F', 'S'].
|
||||
collect{|x| x.rjust($w)}.join(' ') << "\n"
|
||||
mo << ' ' * (($w + 1) * fst.wday)
|
||||
while cur.mon == fst.mon
|
||||
mo << (if $jd then cur.yday else cur.mday end).to_s.rjust($w)
|
||||
mo << (if (cur += 1).wday != 0 then "\s" else "\n" end)
|
||||
end
|
||||
mo << "\n" * (6 - ((fst.wday + (cur - fst)) / 7))
|
||||
mo
|
||||
def pict(y, m, sg)
|
||||
d = (1..31).detect{|d| Date.exist?(y, m, d, sg)}
|
||||
fi = Date.new3(y, m, d, sg)
|
||||
fi -= (fi.jd - $k + 1) % 7
|
||||
|
||||
ve = (fi..fi + 6).collect{|cu|
|
||||
%w(S M Tu W Th F S)[cu.wday]
|
||||
}
|
||||
ve += (fi..fi + 41).collect{|cu|
|
||||
if cu.mon == m then cu.send($da) end.to_s
|
||||
}
|
||||
|
||||
ve = ve.collect{|e| e.rjust($dw)}
|
||||
|
||||
gr = group(ve, 7)
|
||||
gr = trans(gr) if $OPT_t
|
||||
ta = gr.collect{|xs| xs.join(' ')}
|
||||
|
||||
ca = %w(January February March April
|
||||
May June July August
|
||||
September October November December)[m - 1]
|
||||
ca = ca + ' ' + y.to_s if not $OPT_y
|
||||
ca = ca.center($mw)
|
||||
|
||||
ta.unshift(ca)
|
||||
end
|
||||
|
||||
def zip(xs)
|
||||
yr = ''
|
||||
until xs.empty?
|
||||
ln = (if $jd then l, r, *xs = xs; [l, r]
|
||||
else l, c, r, *xs = xs; [l, c, r] end).
|
||||
collect{|x| x.split(/\n/no, -1)}
|
||||
8.times do
|
||||
yr << ln.collect{|x|
|
||||
x.shift.ljust((($w + 1) * 7) - 1)}.join(' ') << "\n"
|
||||
end
|
||||
end
|
||||
yr
|
||||
def group(xs, n)
|
||||
(0..xs.size / n - 1).collect{|i| xs[i * n, n]}
|
||||
end
|
||||
|
||||
while /^-([^-].*)$/no =~ $*[0]
|
||||
a = $1
|
||||
if /^c(.+)?$/no =~ a
|
||||
if $1
|
||||
$cc = $1.downcase
|
||||
elsif $*.length >= 2
|
||||
$cc = $*[1].downcase
|
||||
$*.shift
|
||||
else
|
||||
usage
|
||||
end
|
||||
else
|
||||
a.scan(/./no) do |c|
|
||||
case c
|
||||
when 'j'; $jd = true
|
||||
when 'y'; $yr = true
|
||||
else usage
|
||||
end
|
||||
end
|
||||
end
|
||||
$*.shift
|
||||
def trans(xs)
|
||||
(0..xs[0].size - 1).collect{|i| xs.collect{|x| x[i]}}
|
||||
end
|
||||
$*.shift if /^--/no =~ $*[0]
|
||||
usage if (sg = $tab[$cc]).nil?
|
||||
case $*.length
|
||||
when 0
|
||||
td = Date.today
|
||||
m = td.mon
|
||||
y = td.year
|
||||
when 1
|
||||
y = $*[0].to_i
|
||||
$yr = true
|
||||
when 2
|
||||
m = $*[0].to_i
|
||||
y = $*[1].to_i
|
||||
else
|
||||
usage
|
||||
|
||||
def unite(xs)
|
||||
if xs.empty? then [] else xs[0] + unite(xs[1..-1]) end
|
||||
end
|
||||
usage unless m.nil? or (1..12) === m
|
||||
|
||||
def block(xs, n)
|
||||
unite(group(xs, n).collect{|ys| trans(ys).collect{|zs| zs.join(' ')}})
|
||||
end
|
||||
|
||||
def unlines(xs)
|
||||
xs.collect{|x| x + "\n"}.join
|
||||
end
|
||||
|
||||
usage unless getopts('jmty', "c:#{$cc}")
|
||||
|
||||
y, m = ARGV.indexes(1, 0).compact.collect{|x| x.to_i}
|
||||
$OPT_y ||= (y and not m)
|
||||
|
||||
to = Date.today
|
||||
y ||= to.year
|
||||
m ||= to.mon
|
||||
|
||||
usage unless m >= 1 and m <= 12
|
||||
usage unless y >= -4712
|
||||
$w = if $jd then 3 else 2 end
|
||||
unless $yr
|
||||
print cal(m, y, sg)
|
||||
else
|
||||
print y.to_s.center(((($w + 1) * 7) - 1) *
|
||||
(if $jd then 2 else 3 end) +
|
||||
(if $jd then 2 else 4 end)), "\n\n",
|
||||
zip((1..12).collect{|m| cal(m, y, sg)}), "\n"
|
||||
end
|
||||
usage unless sg = $tab[$OPT_c]
|
||||
|
||||
$dw = if $OPT_j then 3 else 2 end
|
||||
$mw = ($dw + 1) * 7 - 1
|
||||
$mn = if $OPT_j then 2 else 3 end
|
||||
$tw = ($mw + 2) * $mn - 2
|
||||
|
||||
$k = if $OPT_m then 1 else 0 end
|
||||
$da = if $OPT_j then :yday else :mday end
|
||||
|
||||
print (if not $OPT_y
|
||||
unlines(pict(y, m, sg))
|
||||
else
|
||||
y.to_s.center($tw) + "\n\n" +
|
||||
unlines(block((1..12).collect{|m| pict(y, m, sg)}, $mn)) + "\n"
|
||||
end)
|
||||
|
|
|
@ -971,7 +971,6 @@ File.unlink "script_tmp.bak" or `/bin/rm -f "script_tmp.bak"`
|
|||
$bad = false
|
||||
for script in Dir["{lib,sample}/**/*.rb"]
|
||||
unless `./miniruby -c #{script}`.chomp == "Syntax OK"
|
||||
p `./miniruby -c #{script}`.chomp
|
||||
$bad = true
|
||||
end
|
||||
end
|
||||
|
|
66
string.c
66
string.c
|
@ -898,12 +898,13 @@ rb_str_aref_m(argc, argv, str)
|
|||
VALUE *argv;
|
||||
VALUE str;
|
||||
{
|
||||
VALUE arg1, arg2;
|
||||
|
||||
if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
|
||||
return rb_str_substr(str, NUM2INT(arg1), NUM2INT(arg2));
|
||||
if (argc == 2) {
|
||||
return rb_str_substr(str, NUM2INT(argv[0]), NUM2INT(argv[1]));
|
||||
}
|
||||
return rb_str_aref(str, arg1);
|
||||
if (argc != 1) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc);
|
||||
}
|
||||
return rb_str_aref(str, argv[0]);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -1029,6 +1030,9 @@ rb_str_aset_m(argc, argv, str)
|
|||
rb_str_replace(str, beg, len, argv[2]);
|
||||
return argv[2];
|
||||
}
|
||||
if (argc != 2) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)", argc);
|
||||
}
|
||||
return rb_str_aset(str, argv[0], argv[1]);
|
||||
}
|
||||
|
||||
|
@ -1038,43 +1042,20 @@ rb_str_slice_bang(argc, argv, str)
|
|||
VALUE *argv;
|
||||
VALUE str;
|
||||
{
|
||||
VALUE arg1, arg2;
|
||||
long pos, len;
|
||||
VALUE result;
|
||||
VALUE buf[3];
|
||||
int i;
|
||||
|
||||
rb_str_modify(str);
|
||||
if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
|
||||
pos = NUM2LONG(arg1);
|
||||
len = NUM2LONG(arg2);
|
||||
delete_pos_len:
|
||||
if (pos < 0) {
|
||||
pos = RSTRING(str)->len + pos;
|
||||
}
|
||||
if (pos < 0 || RSTRING(str)->len <= pos) {
|
||||
rb_raise(rb_eIndexError, "index %d out of string", pos);
|
||||
}
|
||||
arg2 = rb_str_substr(str, pos, len);
|
||||
rb_str_replace(str, pos, len, rb_str_new(0,0));
|
||||
return arg2;
|
||||
if (argc < 1 || 2 < argc) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc);
|
||||
}
|
||||
|
||||
if (!FIXNUM_P(arg1) && rb_range_beg_len(arg1, &pos, &len, RSTRING(str)->len, 0)) {
|
||||
goto delete_pos_len;
|
||||
for (i=0; i<argc; i++) {
|
||||
buf[i] = argv[i];
|
||||
}
|
||||
|
||||
pos = NUM2LONG(arg1);
|
||||
len = RSTRING(str)->len;
|
||||
|
||||
if (pos >= len) return Qnil;
|
||||
if (pos < 0) pos += len;
|
||||
if (pos < 0) return Qnil;
|
||||
|
||||
arg2 = INT2FIX(RSTRING(str)->ptr[pos] & 0xff);
|
||||
memmove(RSTRING(str)->ptr + pos,
|
||||
RSTRING(str)->ptr + pos + 1,
|
||||
RSTRING(str)->len - (pos + 1));
|
||||
RSTRING(str)->len--;
|
||||
|
||||
return arg2;
|
||||
buf[i] = rb_str_new(0,0);
|
||||
result = rb_str_aref_m(2, buf, str);
|
||||
rb_str_aset_m(3, buf, str);
|
||||
return result;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
|
@ -1107,7 +1088,7 @@ rb_str_sub_bang(argc, argv, str)
|
|||
int iter = 0;
|
||||
long plen;
|
||||
|
||||
if (argc == 1 && rb_iterator_p()) {
|
||||
if (argc == 1 && rb_block_given_p()) {
|
||||
iter = 1;
|
||||
}
|
||||
else if (argc == 2) {
|
||||
|
@ -1177,7 +1158,7 @@ str_gsub(argc, argv, str, bang)
|
|||
char *buf, *bp, *cp;
|
||||
int tainted = 0;
|
||||
|
||||
if (argc == 1 && rb_iterator_p()) {
|
||||
if (argc == 1 && rb_block_given_p()) {
|
||||
iter = 1;
|
||||
}
|
||||
else if (argc == 2) {
|
||||
|
@ -2545,7 +2526,7 @@ rb_str_scan(str, pat)
|
|||
VALUE match = Qnil;
|
||||
|
||||
pat = get_pat(pat);
|
||||
if (!rb_iterator_p()) {
|
||||
if (!rb_block_given_p()) {
|
||||
VALUE ary = rb_ary_new();
|
||||
|
||||
while (!NIL_P(result = scan_once(str, pat, &start))) {
|
||||
|
@ -2849,7 +2830,6 @@ Init_String()
|
|||
|
||||
rb_define_method(rb_cString, "slice", rb_str_aref_m, -1);
|
||||
rb_define_method(rb_cString, "slice!", rb_str_slice_bang, -1);
|
||||
rb_define_method(rb_cString, "delete_at", rb_str_slice_bang, -1);
|
||||
|
||||
to_str = rb_intern("to_s");
|
||||
|
||||
|
|
6
struct.c
6
struct.c
|
@ -52,7 +52,7 @@ rb_struct_s_members(obj)
|
|||
|
||||
member = iv_get(obj, "__member__");
|
||||
if (NIL_P(member)) {
|
||||
rb_bug("non-initialized struct");
|
||||
rb_bug("uninitialized struct");
|
||||
}
|
||||
ary = rb_ary_new2(RARRAY(member)->len);
|
||||
p = RARRAY(member)->ptr; pend = p + RARRAY(member)->len;
|
||||
|
@ -81,9 +81,9 @@ rb_struct_getmember(obj, id)
|
|||
|
||||
member = iv_get(class_of(obj), "__member__");
|
||||
if (NIL_P(member)) {
|
||||
rb_bug("non-initialized struct");
|
||||
rb_bug("uninitialized struct");
|
||||
}
|
||||
slot = INT2NUM(id);
|
||||
slot = ID2SYM(id);
|
||||
for (i=0; i<RARRAY(member)->len; i++) {
|
||||
if (RARRAY(member)->ptr[i] == slot) {
|
||||
return RSTRUCT(obj)->ptr[i];
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
#define RUBY_VERSION "1.5.4"
|
||||
#define RUBY_RELEASE_DATE "2000-05-18"
|
||||
#define RUBY_RELEASE_DATE "2000-05-24"
|
||||
#define RUBY_VERSION_CODE 154
|
||||
#define RUBY_RELEASE_CODE 20000518
|
||||
#define RUBY_RELEASE_CODE 20000524
|
||||
|
|
Загрузка…
Ссылка в новой задаче