From 9c5b1986a36c7a700b4c76817e35aa874ba7907c Mon Sep 17 00:00:00 2001 From: matz Date: Wed, 20 Jan 1999 04:59:32 +0000 Subject: Initial revision git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@370 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ext/Win32API/depend | 1 + ext/mandel/MANIFEST | 3 + ext/mandel/mandel.c | 59 ++++++++ ext/mandel/tkmandel.rb | 172 +++++++++++++++++++++ ext/readline/MANIFEST | 4 + ext/readline/README | 55 +++++++ ext/readline/extconf.rb | 8 + ext/readline/readline.c | 386 ++++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 688 insertions(+) create mode 100644 ext/Win32API/depend create mode 100644 ext/mandel/MANIFEST create mode 100644 ext/mandel/mandel.c create mode 100644 ext/mandel/tkmandel.rb create mode 100644 ext/readline/MANIFEST create mode 100644 ext/readline/README create mode 100644 ext/readline/extconf.rb create mode 100644 ext/readline/readline.c (limited to 'ext') 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 +#include +#include + +#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(); +} -- cgit v1.2.3