This commit was manufactured by cvs2svn to create branch 'RUBY'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/RUBY@371 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

8 files changed, 688 insertions, 0 deletions

diff --git a/ext/Win32API/depend b/ext/Win32API/depend
new file mode 100644
index 0000000000..517b546de3
--- /dev/null
+++ b/ext/Win32API/depend
@@ -0,0 +1 @@
+Win32API.o : Win32API.c $(hdrdir)/ruby.h $(hdrdir)/config.h $(hdrdir)/defines.h
diff --git a/ext/mandel/MANIFEST b/ext/mandel/MANIFEST
new file mode 100644
index 0000000000..8a72d2c3a9
--- /dev/null
+++ b/ext/mandel/MANIFEST
@@ -0,0 +1,3 @@
+MANIFEST
+mandel.c
+tkmandel.rb
diff --git a/ext/mandel/mandel.c b/ext/mandel/mandel.c
new file mode 100644
index 0000000000..359c0756da
--- /dev/null
+++ b/ext/mandel/mandel.c
@@ -0,0 +1,59 @@
+/************************************************
+
+  mandel.c -
+
+  $Author$
+
+************************************************/
+
+#include "ruby.h"
+#include "math.h"
+
+static VALUE
+mandel(self, re, im, max)
+    VALUE self;
+    VALUE re;
+    VALUE im;
+    VALUE max;
+{
+    double real, image;
+    double z_real, z_image;
+    double tmp_real;
+    int maximum;
+    int i;
+	
+    Check_Type(re, T_FLOAT);
+    Check_Type(im, T_FLOAT);
+    Check_Type(max, T_FIXNUM);
+
+    real = RFLOAT(re)->value;
+    image = RFLOAT(im)->value;
+    maximum = FIX2INT(max);
+
+    /***
+    z = c = Complex(re, im)
+    for i in 0 .. $max_deapth
+      z = (z * z) + c
+      break if z.abs > 2
+    end
+    return i
+    ***/
+
+    z_real = real;
+    z_image = image;
+    for (i = 0; i < maximum; i++) {
+	tmp_real = ((z_real * z_real) - (z_image * z_image)) + real;
+	z_image = ((z_real * z_image) + (z_image * z_real)) + image;
+	z_real = tmp_real;
+	if ( ((z_real * z_real) + (z_image * z_image)) > 4.0 ) {
+	    break;
+	}
+    }
+    return INT2FIX(i);
+}
+
+Init_mandel()
+{
+    VALUE mMandel = rb_define_module("Mandel");
+    rb_define_module_function(mMandel, "mandel", mandel, 3);
+}
diff --git a/ext/mandel/tkmandel.rb b/ext/mandel/tkmandel.rb
new file mode 100644
index 0000000000..5ebe90fb80
--- /dev/null
+++ b/ext/mandel/tkmandel.rb
@@ -0,0 +1,172 @@
+# require "complex"
+require "mandel"
+require "tkclass"
+
+DefaultMaxDepth = 30
+DefaultSX = -2.25
+DefaultSY = 1.75
+DefaultEX = 1.25
+DefaultEY = -1.75
+
+def reset
+  $max_depth = DefaultMaxDepth
+  $s_re = DefaultSX
+  $s_im = DefaultSY
+  $e_re = DefaultEX
+  $e_im = DefaultEY
+  $dx = ($e_re - $s_re).abs / Width
+  $dy = ($e_im - $s_im).abs / Height
+  $photo.blank
+end
+
+
+Width = 400
+Height = 400
+
+$c = Canvas.new {
+       width Width
+       height Height
+     }
+$c.pack
+
+$c_rect = Rectangle.new($c, 0, 0, Width+1, Height+1)
+$c_rect.fill "white"
+
+$colors = []
+
+def colors_init
+  $colors = []
+  for i in 0 .. 125
+    $colors.push(format("#%02x%02x%02x", 250 - (i*2), i*2, 0))
+  end
+  for i in 0 .. 125
+    $colors.push(format("#%02x%02x%02x", 0, 250 - (i*2), i*2)) 
+  end
+  $color_max = $colors.size - 1
+end
+
+def zoom(a, b, c, d)
+  center_x = (a + c) / 2
+  center_y = (b + d) / 2
+  size = (c - a).abs
+  size = (d - b).abs if (size < (d - b).abs)
+  size = 1 if (size < 1)
+  zoom_rate = ((Width + Height) / 2).to_f / size
+  $max_depth = ($max_depth.to_f * Math.sqrt(Math.sqrt(Math.sqrt(zoom_rate)))).to_i
+
+  move_x_rate = (center_x - (Width / 2)).to_f / (Width / 2)
+  move_y_rate = (center_y - (Height / 2)).to_f / (Height / 2)
+
+  center_re = ($s_re + $e_re) / 2
+  center_im = ($s_im + $e_im) / 2
+  c_size_re = ($e_re - $s_re).abs
+  c_size_im = ($e_im - $s_im).abs
+
+  center_re = center_re + (move_x_rate * (c_size_re / 2))
+  center_im = center_im - (move_y_rate * (c_size_im / 2))
+
+  $s_re = center_re - ((c_size_re / 2) / zoom_rate)
+  $s_im = center_im + ((c_size_im / 2) / zoom_rate)
+  $e_re = center_re + ((c_size_re / 2) / zoom_rate)
+  $e_im = center_im - ((c_size_im / 2) / zoom_rate)
+
+  $dx = ($e_re - $s_re).abs / Width
+  $dy = ($e_im - $s_im).abs / Height
+  p [$s_re, $dx, $s_im, $dy]
+end
+
+
+def mandel(x, y)
+  re = $s_re + ($dx * x)
+  im = $s_im - ($dy * y)
+#   z = c = Complex(re, im)
+#   for i in 0 .. $max_depth
+#     z = (z * z) + c
+#     break if z.abs > 2
+#   end
+#   return i
+  return Mandel.mandel(re, im, $max_depth)
+end
+
+$buf = "{"+"        "*Width+"}"
+def calc
+  $c.update
+  return if $current_rect
+  depth = 0
+
+  for x in 0 .. Width - 1
+    depth = mandel(x, $calc_y)
+    if depth >= $max_depth
+      $buf[x*8+1,7] = "#000000"
+    else
+      $buf[x*8+1,7] = $colors[$color_max * depth / $max_depth]
+    end
+  end
+  $photo.put($buf, 0, $calc_y)
+
+  $calc_y += 1
+  if (($calc_y % 20) == 0)
+    print "#{($calc_y * 100 / Height)}% done. -- depth #{$max_depth}\n"
+#    $mandel.image $photo
+  end
+
+  if ($calc_y > Height - 1)
+    $calc_y = StartCalcY
+    $calc_on = false
+#    exit
+  end
+
+  if $calc_on
+    Tk.after(1) { calc() }
+  end
+end
+
+$photo = TkPhotoImage.new({'width'=>Width, 'height'=>Height})
+$mandel = TkcImage.new($c, Width/2, Height/2) { image $photo }
+reset()
+colors_init()
+$calc_y = StartCalcY = 0
+$calc_on = true
+calc()
+
+def clear
+#  $mandel.destroy if $mandel
+  $calc_y = StartCalcY
+end
+
+$start_x = $start_y = 0
+$current_rect = nil
+
+def do_press(x, y)
+  $start_x = x
+  $start_y = y
+  $current_rect = Rectangle.new($c, x, y, x, y) { outline "white" }
+end
+
+def do_motion(x, y)
+  if $current_rect
+    $current_rect.coords $start_x, $start_y, x, y
+  end
+end
+
+def do_release(x, y)
+  if $current_rect
+    $current_rect.coords $start_x, $start_y, x, y
+    $current_rect.destroy
+    $current_rect = nil
+    clear()
+    $calc_on = true
+    zoom($start_x, $start_y, x, y)
+    calc()
+  end
+end
+
+$c.bind("1", proc{|e| do_press e.x, e.y})
+$c.bind("B1-Motion", proc{|x, y| do_motion x, y}, "%x %y")
+$c.bind("ButtonRelease-1", proc{|x, y| do_release x, y}, "%x %y")
+
+begin
+  Tk.mainloop
+ensure
+#  File.delete("#tmpmandel#.gif")
+end
diff --git a/ext/readline/MANIFEST b/ext/readline/MANIFEST
new file mode 100644
index 0000000000..f73a899abb
--- /dev/null
+++ b/ext/readline/MANIFEST
@@ -0,0 +1,4 @@
+MANIFEST
+README
+extconf.rb
+readline.c
diff --git a/ext/readline/README b/ext/readline/README
new file mode 100644
index 0000000000..8a5fe9120f
--- /dev/null
+++ b/ext/readline/README
@@ -0,0 +1,55 @@
+GNU Readline Libraryを利用するための拡張モジュールです。
+
+require "readline"
+include Readline
+
+line = readline("Prompt> ", TRUE)
+
+のように使用してください。
+
+[Readline]
+
+<モジュール関数>
+
+readline(prompt, add=nil)
+
+  一行入力を読み込みます。
+  addがTRUEの場合、ヒストリに読み込んだ文字列を追加します。
+
+<クラスメソッド>
+
+completion_proc = proc
+
+  補完時の動作を決定するProcオブジェクトを指定します。
+  procは引数に入力文字列を取り、候補文字列の配列を返すように
+  してください。
+
+completion_proc
+
+  補完時の動作を決定するProcオブジェクトを返します。
+
+completion_case_fold = case_fold
+
+  補完時に大文字小文字を区別しない場合、TRUEを指定します。
+
+completion_case_fold
+
+  補完時に大文字小文字を区別しない場合、TRUEを返します。
+
+vi_editing_mode
+
+  VIモードになります。
+
+emacs_editing_mode
+
+  Emacsモードになります。
+
+<クラス定数>
+
+HISTORY
+
+ヒストリに対する操作はこの定数を通して行ってください。
+配列と同じように扱えるようになっています。
+
+
+	
\ No newline at end of file
diff --git a/ext/readline/extconf.rb b/ext/readline/extconf.rb
new file mode 100644
index 0000000000..e55233eb20
--- /dev/null
+++ b/ext/readline/extconf.rb
@@ -0,0 +1,8 @@
+require "mkmf"
+
+have_library("termcap", "tgetnum")
+if have_header("readline/readline.h") and
+    have_header("readline/history.h") and
+    have_library("readline", "readline")
+  create_makefile("readline")
+end
diff --git a/ext/readline/readline.c b/ext/readline/readline.c
new file mode 100644
index 0000000000..9e471195e6
--- /dev/null
+++ b/ext/readline/readline.c
@@ -0,0 +1,386 @@
+/* readline.c -- GNU Readline module
+   Copyright (C) 1997-1998  Shugo Maeda */
+
+#include <stdio.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include "ruby.h"
+#include "rubysig.h"
+
+static VALUE mReadline;
+
+#define TOLOWER(c) (isupper(c) ? tolower(c) : c)
+
+#define COMPLETION_PROC "completion_proc"
+#define COMPLETION_CASE_FOLD "completion_case_fold"
+
+static int
+readline_event()
+{
+    CHECK_INTS;
+#ifdef USE_THREAD
+    rb_thread_schedule();
+#endif
+}
+
+static VALUE
+readline_readline(int argc, VALUE *argv, VALUE self)
+{
+    VALUE tmp, add_hist, result;
+    char *prompt = NULL;
+    char *buff;
+
+    if (rb_scan_args(argc, argv, "02", &tmp, &add_hist) > 0) {
+	prompt = STR2CSTR(tmp);
+    }
+    buff = readline(prompt);
+    if (RTEST(add_hist) && buff) {
+	add_history(buff);
+    }
+    if (buff)
+	result = rb_str_new2(buff);
+    else
+	result = Qnil;
+    if (buff) free(buff);
+    return result;
+}
+
+static VALUE
+readline_s_set_completion_proc(VALUE self, VALUE proc)
+{
+    if (!rb_respond_to(proc, rb_intern("call")))
+	rb_raise(rb_eArgError, "argument have to respond to `call'");
+    return rb_iv_set(mReadline, COMPLETION_PROC, proc);
+}
+
+static VALUE
+readline_s_get_completion_proc(VALUE self)
+{
+    return rb_iv_get(mReadline, COMPLETION_PROC);
+}
+
+static VALUE
+readline_s_set_completion_case_fold(VALUE self, VALUE val)
+{
+    return rb_iv_set(mReadline, COMPLETION_CASE_FOLD, val);
+}
+
+static VALUE
+readline_s_get_completion_case_fold(VALUE self)
+{
+    return rb_iv_get(mReadline, COMPLETION_CASE_FOLD);
+}
+
+static char **
+readline_attempted_completion_function(char *text, int start, int end)
+{
+    VALUE proc, ary, temp;
+    char **result;
+    int case_fold;
+    int i, matches;
+
+    proc = rb_iv_get(mReadline, COMPLETION_PROC);
+    rl_attempted_completion_over = 1;
+    case_fold = RTEST(rb_iv_get(mReadline, COMPLETION_CASE_FOLD));
+    ary = rb_funcall(proc, rb_intern("call"), 1, rb_str_new2(text));
+    if (TYPE(ary) != T_ARRAY)
+	ary = rb_Array(ary);
+    matches = RARRAY(ary)->len;
+    if (matches == 0)
+	return NULL;
+    result = ALLOC_N(char *, matches + 2);
+    for (i = 0; i < matches; i++) {
+	temp = rb_obj_as_string(RARRAY(ary)->ptr[i]);
+	result[i + 1] = ALLOC_N(char, RSTRING(temp)->len + 1);
+	strcpy(result[i + 1], RSTRING(temp)->ptr);
+    }
+    result[matches + 1] = NULL;
+
+    if (matches == 1) {
+	result[0] = result[1];
+	result[1] = NULL;
+    } else {
+	register int i = 1;
+	int low = 100000;
+
+	while (i < matches) {
+	    register int c1, c2, si;
+
+	    if (case_fold) {
+		for (si = 0;
+		     (c1 = TOLOWER(result[i][si])) &&
+			 (c2 = TOLOWER(result[i + 1][si]));
+		     si++)
+		    if (c1 != c2) break;
+	    } else {
+		for (si = 0;
+		     (c1 = result[i][si]) &&
+			 (c2 = result[i + 1][si]);
+		     si++)
+		    if (c1 != c2) break;
+	    }
+
+	    if (low > si) low = si;
+	    i++;
+	}
+	result[0] = ALLOC_N(char, low + 1);
+	strncpy(result[0], result[1], low);
+	result[0][low] = '\0';
+    }
+
+    return result;
+}
+
+static VALUE
+readline_s_vi_editing_mode(VALUE self)
+{
+    rl_vi_editing_mode();
+    return Qnil;
+}
+
+static VALUE
+readline_s_emacs_editing_mode(VALUE self)
+{
+    rl_emacs_editing_mode();
+    return Qnil;
+}
+
+static VALUE
+hist_to_s(VALUE self)
+{
+    return rb_str_new2("HISTORY");
+}
+
+static VALUE
+hist_get(VALUE self, VALUE index)
+{
+    HISTORY_STATE *state;
+    int i;
+
+    state = history_get_history_state();
+    i = NUM2INT(index);
+    if (i < 0 || i > state->length - 1) {
+	rb_raise(rb_eIndexError, "Invalid index");
+    }
+    return rb_str_new2(state->entries[i]->line);
+}
+
+static VALUE
+hist_set(VALUE self, VALUE index, VALUE str)
+{
+    HISTORY_STATE *state;
+    int i;
+
+    state = history_get_history_state();
+    i = NUM2INT(index);
+    if (i < 0 || i > state->length - 1) {
+	rb_raise(rb_eIndexError, "Invalid index");
+    }
+    replace_history_entry(i, STR2CSTR(str), NULL);
+    return str;
+}
+
+static VALUE
+hist_push(VALUE self, VALUE str)
+{
+    add_history(STR2CSTR(str));
+    return self;
+}
+
+static VALUE
+hist_push_method(int argc, VALUE *argv,
+			      VALUE self)
+{
+    VALUE str;
+    
+    while (argc--) {
+	str = *argv++;
+	add_history(STR2CSTR(str));
+    }
+    return self;
+}
+
+static VALUE
+hist_pop(VALUE self)
+{
+    HISTORY_STATE *state;
+    HIST_ENTRY *entry;
+
+    state = history_get_history_state();
+    if (state->length > 0) {
+	entry = remove_history(state->length - 1);
+	return rb_str_new2(entry->line);
+    } else {
+	return Qnil;
+    }
+}
+
+static VALUE
+hist_shift(VALUE self)
+{
+    HISTORY_STATE *state;
+    HIST_ENTRY *entry;
+
+    state = history_get_history_state();
+    if (state->length > 0) {
+	entry = remove_history(0);
+	return rb_str_new2(entry->line);
+    } else {
+	return Qnil;
+    }
+}
+
+static VALUE
+hist_each(VALUE self)
+{
+    HISTORY_STATE *state;
+    int i;
+
+    state = history_get_history_state();
+    for (i = 0; i < state->length; i++) {
+	rb_yield(rb_str_new2(state->entries[i]->line));
+    }
+    return Qnil;
+}
+
+static VALUE
+hist_length(VALUE self)
+{
+    HISTORY_STATE *state;
+
+    state = history_get_history_state();
+    return INT2NUM(state->length);
+}
+
+static VALUE
+hist_empty_p(VALUE self)
+{
+    HISTORY_STATE *state;
+
+    state = history_get_history_state();
+    if (state->length == 0)
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+static VALUE
+hist_delete_at(VALUE self, VALUE index)
+{
+    HISTORY_STATE *state;
+    HIST_ENTRY *entry;
+    int i;
+
+    state = history_get_history_state();
+    i = NUM2INT(index);
+    if (i < 0 || i > state->length - 1) {
+	rb_raise(rb_eIndexError, "Invalid index");
+    }
+    entry = remove_history(NUM2INT(index));
+    return rb_str_new2(entry->line);
+}
+
+static VALUE
+filename_completion_proc_call(VALUE self, VALUE str)
+{
+    VALUE result;
+    char **matches;
+    int i;
+
+    matches = completion_matches(STR2CSTR(str),
+				 filename_completion_function);
+    if (matches) {
+	result = rb_ary_new();
+	for (i = 0; matches[i]; i++) {
+	    rb_ary_push(result, rb_str_new2(matches[i]));
+	    free(matches[i]);
+	}
+	free(matches);
+	if (RARRAY(result)->len >= 2)
+	    rb_ary_shift(result);
+    }
+    else {
+	result = Qnil;
+    }
+    return result;
+}
+
+static VALUE
+username_completion_proc_call(VALUE self, VALUE str)
+{
+    VALUE result;
+    char **matches;
+    int i;
+
+    matches = completion_matches(STR2CSTR(str),
+				 username_completion_function);
+    if (matches) {
+	result = rb_ary_new();
+	for (i = 0; matches[i]; i++) {
+	    rb_ary_push(result, rb_str_new2(matches[i]));
+	    free(matches[i]);
+	}
+	free(matches);
+	if (RARRAY(result)->len >= 2)
+	    rb_ary_shift(result);
+    }
+    else {
+	result = Qnil;
+    }
+    return result;
+}
+
+void
+Init_readline(void)
+{
+    VALUE histary, fcomp, ucomp;
+
+    using_history();
+
+    mReadline = rb_define_module("Readline");
+    rb_define_module_function(mReadline, "readline",
+			      readline_readline, -1);
+    rb_define_singleton_method(mReadline, "completion_proc=",
+			       readline_s_set_completion_proc, 1);
+    rb_define_singleton_method(mReadline, "completion_proc",
+			       readline_s_get_completion_proc, 0);
+    rb_define_singleton_method(mReadline, "completion_case_fold=",
+			       readline_s_set_completion_case_fold, 1);
+    rb_define_singleton_method(mReadline, "completion_case_fold",
+			       readline_s_get_completion_case_fold, 0);
+    rb_define_singleton_method(mReadline, "vi_editing_mode",
+			       readline_s_vi_editing_mode, 0);
+    rb_define_singleton_method(mReadline, "emacs_editing_mode",
+			       readline_s_emacs_editing_mode, 0);
+
+    histary = rb_obj_alloc(rb_cObject);
+    rb_extend_object(histary, rb_mEnumerable);
+    rb_define_singleton_method(histary,"to_s", hist_to_s, 0);
+    rb_define_singleton_method(histary,"[]", hist_get, 1);
+    rb_define_singleton_method(histary,"[]=", hist_set, 2);
+    rb_define_singleton_method(histary,"<<", hist_push, 1);
+    rb_define_singleton_method(histary,"push", hist_push_method, -1);
+    rb_define_singleton_method(histary,"pop", hist_pop, 0);
+    rb_define_singleton_method(histary,"shift", hist_shift, 0);
+    rb_define_singleton_method(histary,"each", hist_each, 0);
+    rb_define_singleton_method(histary,"length", hist_length, 0);
+    rb_define_singleton_method(histary,"empty?", hist_empty_p, 0);
+    rb_define_singleton_method(histary,"delete_at", hist_delete_at, 1);
+    rb_define_const(mReadline, "HISTORY", histary);
+
+    fcomp = rb_obj_alloc(rb_cObject);
+    rb_define_singleton_method(fcomp, "call",
+			       filename_completion_proc_call, 1);
+    rb_define_const(mReadline, "FILENAME_COMPLETION_PROC", fcomp);
+
+    ucomp = rb_obj_alloc(rb_cObject);
+    rb_define_singleton_method(ucomp, "call",
+			       username_completion_proc_call, 1);
+    rb_define_const(mReadline, "USERNAME_COMPLETION_PROC", ucomp);
+
+    rl_attempted_completion_function
+	= (CPPFunction *) readline_attempted_completion_function;
+    rl_event_hook = readline_event;
+    rl_clear_signals();
+}