version 0.50v0_50

http://cache.ruby-lang.org/pub/ruby/1.0/ruby-0.50.tar.gz

Wed Aug 10 15:54:46 1994  Yukihiro Matsumoto  (matz@ix-02)

	* variable.c: -vオプションが指定されている時は初期化されていない,
	  大域変数, インスタンス変数, ローカル変数を参照した時点でwarning
	  を出すようにした.

Tue Aug  9 11:50:48 1994  Yukihiro Matsumoto  (matz@ix-02)

	* bignum.c: 冪乗に関しても多倍長演算を行なうように. 特に浮動小数点
	  数の範囲を越えた時の処理を的確に行なうように.

	* eval.c: メソッド定義後は構文木から, メソッド定義部分を外す. 無駄
	  な再定義が起こらないようにするためと2重にfree()されないため.

	* array.c(Fary_aref): 引数が1つでFixnumの時, Range checkを行なわな
	  いように修正.

	* eval.c: 引数の数をコンパイル時に計算して若干の高速化.

Mon Aug  8 13:06:24 1994  Yukihiro Matsumoto  (matz@ix-02)

	* object.c: nilによる比較連鎖をなくした.

	* parse.y: bit演算子の優先順位を比較演算子よりも強くした.  Cとは異
	  なることになるが, 直観には合致する.

	* gc.c: クラスを解放する時, 個々のメソッド毎にキャッシュをクリアす
	  るのではなく, クラス単位でクリアするように.

Thu Aug  4 18:45:09 1994  Yukihiro Matsumoto  (matz@ix-02)

	* methods.c(method_free): 解放されたメソッドに関してキャッシュをク
	  リアしておく必要があった.

	* gc.c: Dataクラスのデータ部分をfree()し忘れていた.

Wed Aug  3 09:58:14 1994  Yukihiro Matsumoto  (matz@ix-02)

	* parse.y: def func .. end形式による関数メソッドの定義はなくなった.

	* methods.c: func形式のメソッドをなくした. あっても, あまり意味が
	  ないので.

	* eval.c: $0への代入でps(1)の出力が変化するように.

	* io.c(Fsyscall): syscall()を実現.

Mon Aug  1 13:41:11 1994  Yukihiro Matsumoto  (matz@ix-02)

	* parse.y: ダブルクォートで囲まれた文字列や正規表現中で"#{変数名}"
	  または"#変数名"という形式で変数の内容を埋め込むことができるよう
	  になった.

	* io.c: 関数メソッドsystem2()はなくなった. 今はバッククォートがあ
	  るからね.

	* parse.y: `cmd`によってコマンドを文字列に展開することができるよう
	  になった.

	* parse.y: __FILE__, __LINE__を追加. それぞれファイル名(文字列),
	  行番号(整数)を値とする疑似変数.

Fri Jul 29 13:16:07 1994  Yukihiro Matsumoto  (matz@ix-02)

	* methods.h: メソッドをオブジェクトとして扱うのをやめる. メソッド
	  のメモリ管理にはリファレンスカウントを使うことにした. これでオブ
	  ジェクトの数が減ってほんの少しだけGCが速くなる(かな).

	* purifyによってメモリ関係のバグを検査した(見つかる,見つかる…).

	* gc.c: GCをプログラマが変数をマークする形式から, スタックとレジス
	  タからマークする方法に変更. 移植性が下がるような気もするが, siod
	  やscmでも採用されているから多分大丈夫だろう. Linux on i486でも動
	  作を確認した.

Wed Jul 27 16:13:13 1994  Yukihiro Matsumoto  (matz@ix-02)

	* eval.c(Eval): トップレベルでは構造木をfreeしないように. どうせ解
	  放されるから時間の無駄である.

	* array.c, dict.c: "=="を構造一致に変更.

Fri Jul 22 10:14:09 1994  Yukihiro Matsumoto  (matz@ix-02)

	* error.c: 組み込みタイプの名前を登録し忘れていた.

Thu Jul 21 14:06:48 1994  Yukihiro Matsumoto  (matz@ix-02)

	* parse.y(freenode),eval.c(Eval): 解析木を解放し忘れていた.

Mon Jul 18 10:19:15 1994  Yukihiro Matsumoto  (matz@ix-02)

	* parse.y: 多重代入を処理するルールにバグがあって, 3要素以上の多重
	  代入に失敗していた.

	* eval.c(rb_eval): 多重代入で, 右辺が配列でない時には`to_a'メソッ
	  ドで配列に変換して代入するようにした. 今までの仕様だと右辺値が第
	  1要素にそのまま代入されていたが, structなど配列に変換できるもの
	  は変換した方が嬉しい気がする.

	* dbm.c,dict.c(delete_if): メソッド追加.

	* process.c(wait,waitpid): システムコールwaitpidまたはwait4がある
	  時はそちらを使うように. configureもそれらをチェックするように変更.

	* dbm.c, dict.c(clear): メソッド追加.

12 files changed, 334 insertions, 29 deletions

diff --git a/sample/cbreak.rb b/sample/cbreak.rb
index 4b4cb1d3e6..5befd5066a 100644
--- a/sample/cbreak.rb
+++ b/sample/cbreak.rb
@@ -27,8 +27,8 @@ def set_cbreak (on)
 end
 cbreak();
 
-print("this is echo line: ");
+print("this is no-echo line: ");
 readline().print
 cooked();
-print("this is non echo line: ");
-readline().print
+print("this is echo line: ");
+readline()
diff --git a/sample/fullpath.rb b/sample/fullpath.rb
index b1d4b9c332..6c528f6f96 100644
--- a/sample/fullpath.rb
+++ b/sample/fullpath.rb
@@ -9,7 +9,6 @@ end
 if path == nil
   path = ""
 elsif path !~ /\/$/
-  print(path, "/\n")
   path += "/"
 end
 
diff --git a/sample/gctest.rb b/sample/gctest.rb
index 6067393bbb..23476d2b78 100644
--- a/sample/gctest.rb
+++ b/sample/gctest.rb
@@ -40,10 +40,7 @@ def print_int_list(x)
   end
 end
 
-GC.threshold = 1000000
-
 print("start\n")
-print("threshold: ", GC.threshold, "\n");
 
 a = ints(1, 100)
 print_int_list(a)
diff --git a/sample/getopts.test b/sample/getopts.test
index 16f1bb06c7..cdb818d390 100755
--- a/sample/getopts.test
+++ b/sample/getopts.test
@@ -11,10 +11,10 @@ $USAGE = 'usage'
 parseArgs(0, !nil, "d", "x:", "y:", "version", "geometry:")
 if ($OPT_d)
   if ($OPT_x)
-    printf("x = %d\n", $OPT_x.atoi)
+    printf("x = %d\n", $OPT_x.to_i)
   end
   if ($OPT_y)
-    printf("y = %d\n", $OPT_y.atoi)
+    printf("y = %d\n", $OPT_y.to_i)
   end
   if ($OPT_geometry)
     printf("geometry = %s\n", $OPT_geometry)
diff --git a/sample/newver.rb b/sample/newver.rb
deleted file mode 100644
index bbf03aebc2..0000000000
--- a/sample/newver.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-#! /usr/local/bin/ruby
-
-f = open("version.h", "r")
-f.gets()
-f.close
-
-if $_ =~ /"(\d)\.(\d+)"/;
-  f = open("version.h", "w")
-  i = $2.to_i + 1
-  printf("ruby version %d.%0d\n", $1, i)
-  printf(f, "#define RUBY_VERSION \"%d.%0d\"\n", $1, i)
-  f.close
-end
diff --git a/sample/opt_s.rb b/sample/opt_s.rb
index 4981119012..5402be7482 100644
--- a/sample/opt_s.rb
+++ b/sample/opt_s.rb
@@ -5,4 +5,6 @@ end
 if ($zzz)
   print("zzz = ", $zzz, "\n")
 end
-print($ARGV.join(", "), "\n")
+if ($ARGV.length > 0)
+  print($ARGV.join(", "), "\n")
+end
diff --git a/sample/rcs.rb b/sample/rcs.rb
index b14742981d..6d7f10c6bc 100644
--- a/sample/rcs.rb
+++ b/sample/rcs.rb
@@ -14,7 +14,7 @@ while gets()
   while xr < hdw
     x = xr * (1 + y) - y * w / 2
     i = (x / (1 + h) + sw /2)
-    c = if (0 < i < $_.length); $_[i, 1].to_i else 0 end
+    c = if (1 < i && i < $_.length); $_[i, 1].to_i else 0 end
     y = h - d * c
     xl = xr - w * y / (1 + y);
     if xl < -hdw || xl >= hdw || xl <= maxxl
diff --git a/sample/ruby-mode.el b/sample/ruby-mode.el
new file mode 100644
index 0000000000..96915bdc5a
--- /dev/null
+++ b/sample/ruby-mode.el
@@ -0,0 +1,296 @@
+;;;
+;;;  ruby-mode.el -
+;;;
+;;;  $Author$
+;;;  $Revision$
+;;;  $Date$
+;;;  created at: Fri Feb  4 14:49:13 JST 1994
+;;;
+
+(defconst ruby-block-beg-re
+  "class\\|module\\|def\\|if\\|case\\|while\\|do\\|for\\|protect"
+  )
+
+(defconst ruby-block-mid-re
+  "else\\|elsif\\|when\\|using\\|resque\\|ensure"
+  )
+
+(defconst ruby-block-end-re
+  (concat "\\(end\\([ \t]+\\(" ruby-block-beg-re "\\)\\)?\\)")
+  )
+
+(defconst ruby-delimiter
+  (concat "(\\|)\\|\\{\\|\\}\\|\"\\|\'\\|\\b\\(" ruby-block-beg-re "\\|" ruby-block-end-re "\\)\\b\\|#")
+  )
+(defconst ruby-negative
+  (concat "^[ \t]*\\b\\(\\(" ruby-block-mid-re "\\)\\|\\(" ruby-block-end-re "\\)\\)\\b")
+  )
+
+(defvar ruby-mode-abbrev-table nil
+  "Abbrev table in use in ruby-mode buffers.")
+
+(define-abbrev-table 'ruby-mode-abbrev-table ())
+
+(defvar ruby-mode-map nil "Keymap used in ruby mode.")
+
+(if ruby-mode-map
+    nil
+  (setq ruby-mode-map (make-sparse-keymap))
+  (define-key ruby-mode-map "\e\C-a" 'ruby-beginning-of-defun)
+  (define-key ruby-mode-map "\e\C-e" 'ruby-end-of-defun)
+  (define-key ruby-mode-map "\t" 'ruby-indent-command)
+  (define-key ruby-mode-map "\t" 'ruby-indent-command)
+  (define-key ruby-mode-map "\C-m" 'ruby-reindent-then-newline-and-indent)
+  (define-key ruby-mode-map "\C-j" 'newline))
+
+(defvar ruby-mode-syntax-table nil
+  "Syntax table in use in ruby-mode buffers.")
+
+(if ruby-mode-syntax-table
+    ()
+  (setq ruby-mode-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?\' "\"" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\" "\"" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\n ">   " ruby-mode-syntax-table)
+  (modify-syntax-entry ?\f ">   " ruby-mode-syntax-table)
+  (modify-syntax-entry ?# "<   " ruby-mode-syntax-table)
+  (modify-syntax-entry ?_ "w" ruby-mode-syntax-table)
+  (modify-syntax-entry ?< "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?> "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?& "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?| "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?$ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?% "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?= "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?/ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?+ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?* "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?- "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?\; "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?\( "()" ruby-mode-syntax-table)
+  (modify-syntax-entry ?) ")(" ruby-mode-syntax-table)
+  (modify-syntax-entry ?{ "(}" ruby-mode-syntax-table)
+  (modify-syntax-entry ?} "){" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\[ "(]" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\] ")[" ruby-mode-syntax-table)
+  )
+
+(defvar ruby-indent-level 2
+  "*Indentation of ruby statements.")
+
+(defun ruby-mode-variables ()
+  (setq local-abbrev-table ruby-mode-abbrev-table)
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'ruby-indent-line)
+  (make-local-variable 'require-final-newline)
+  (setq require-final-newline t)
+  (make-variable-buffer-local 'comment-start)
+  (setq comment-start "# ")
+  (make-variable-buffer-local 'comment-end)
+  (setq comment-end "")
+  (make-variable-buffer-local 'comment-column)
+  (setq comment-column 32)
+  (make-variable-buffer-local 'comment-start-skip)
+  (setq comment-start-skip "#+ *")
+  (make-local-variable 'parse-sexp-ignore-comments)
+  (setq parse-sexp-ignore-comments t))
+
+(defun ruby-mode ()
+  "Major mode for editing ruby scripts.
+\\[ruby-indent-command] properly indents subexpressions of multi-line
+class, module, def, if, while, for, do, and case statements, taking
+nesting into account.
+
+The variable ruby-indent-level controls the amount of indentation.
+\\{ruby-mode-map}"
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map ruby-mode-map)
+  (setq mode-name "ruby")
+  (setq major-mode 'ruby-mode)
+  (set-syntax-table ruby-mode-syntax-table)
+  (ruby-mode-variables)
+  (run-hooks 'ruby-mode-hook))
+
+(defun ruby-current-indentation ()
+  (save-excursion
+    (beginning-of-line)
+    (back-to-indentation)
+    (current-column)))
+
+(defun ruby-delete-indentation ()
+  (let
+      ((b nil)
+       (m nil))
+    (save-excursion
+      (beginning-of-line)
+      (setq b (point))
+      (back-to-indentation)
+      (setq m (point)))
+    (delete-region b m)))
+
+(defun ruby-indent-line (&optional flag)
+  "Correct indentation of the current ruby line."
+  (let
+      ((x (ruby-calculate-indent)))
+    (ruby-indent-to x)))
+  
+(defun ruby-indent-command ()
+  (interactive)
+  (ruby-indent-line t))
+
+(defun ruby-indent-to (x)
+  (let ((p nil) beg end)
+    (if (null x)
+	nil
+      (setq p (- (current-column) (ruby-current-indentation)))
+      (ruby-delete-indentation)
+      (beginning-of-line)
+      (save-excursion
+	(setq beg (point))
+	(forward-line 1)
+	(setq end (point)))
+      (indent-to x)
+      (if (> p 0) (forward-char p)))))
+
+(defun ruby-parse-region (start end)
+  (let ((indent-point end)
+	(indent 0)
+	(in-string nil)
+	(in-paren nil)
+	(depth 0)
+	(nest nil))
+    (save-excursion
+      (if start
+	  (goto-char start)
+	(ruby-beginning-of-defun))
+      (while (and (> indent-point (point))
+		  (re-search-forward ruby-delimiter indent-point t))
+	(let ((w (buffer-substring (match-beginning 0) (match-end 0))))
+	  (cond
+	   ((or (string= "\"" w)	;skip string
+		(string= "\'" w))
+	    (if (search-forward w indent-point t)
+		nil
+	      (goto-char indent-point)
+	      (setq in-string t)))
+	   ((string= "#" w)		;skip comment
+	    (forward-line 1))
+	   ((string= "(" w)		;skip to matching paren
+	    (let ((orig depth))
+	      (setq nest (cons (point) nest))
+	      (setq depth (1+ depth))
+	      (while (and (/= depth orig)
+			  (re-search-forward "[()]" indent-point t))
+		(cond
+		 ((= (char-after (match-beginning 0)) ?\( )
+		  (setq nest (cons (point) nest))
+		  (setq depth (1+ depth)))
+		 (t
+		  (setq nest (cdr nest))
+		  (setq depth (1- depth)))))
+	      (if (> depth orig) (setq in-paren t))))
+	   ((string= "{" w)		;skip to matching paren
+	    (let ((orig depth))
+	      (setq nest (cons (point) nest))
+	      (setq depth (1+ depth))
+	      (while (and (/= depth orig)
+			  (re-search-forward "[{}]" indent-point t))
+		(cond
+		 ((= (char-after (match-beginning 0)) ?\{ )
+		  (setq nest (cons (point) nest))
+		  (setq depth (1+ depth)))
+		 (t
+		  (setq nest (cdr nest))
+		  (setq depth (1- depth)))))
+	      (if (> depth orig) (setq in-paren t))))
+	   ((string-match "^end" w)
+	    (setq nest (cdr nest))
+	    (setq depth (1- depth)))
+	   ((string-match ruby-block-beg-re w)
+	    (setq nest (cons (point) nest))
+	    (setq depth (1+ depth)))
+	   (t
+	    (error (format "bad string %s" w)))))))
+    (if in-paren (message "in-paren"))
+    (list in-string in-paren (car nest) depth)))
+
+(defun ruby-calculate-indent (&optional parse-start)
+  (save-excursion
+    (beginning-of-line)
+    (let ((indent-point (point))
+	  (case-fold-search nil)
+	  state eol
+	  (indent 0))
+      (if parse-start
+	  (goto-char parse-start)
+	(beginning-of-defun)
+	(setq parse-start (point)))
+      (setq state (ruby-parse-region parse-start indent-point))
+      (cond
+       ((nth 0 state)			; within string
+	(setq indent nil))		;  do nothing
+
+       ((nth 1 state)			; in paren
+	(goto-char (nth 2 state))
+	(setq indent
+	      (if (looking-at "$")
+		  (+ (current-indentation) ruby-indent-level)
+		(current-column))))
+
+       ((> (nth 3 state) 0)		; in nest
+	(goto-char (nth 2 state))
+	(forward-word -1)		; skip back a keyword
+	(setq indent (+ (current-column) ruby-indent-level)))
+
+       (t				; toplevel
+	(setq indent 0)))
+      (goto-char indent-point)
+      (end-of-line)
+      (setq eol (point))
+      (beginning-of-line)
+      (if (re-search-forward ruby-negative eol t)
+	  (setq indent (- indent ruby-indent-level)))
+      indent)))
+
+(defun ruby-beginning-of-defun (&optional arg)
+    "Move backward to next beginning-of-defun.
+With argument, do this that many times.
+Returns t unless search stops due to end of buffer."
+  (interactive "p")
+  (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)")
+			   nil 'move (or arg 1))
+       (progn (beginning-of-line) t)))
+
+(defun ruby-end-of-defun (&optional arg)
+  "Move forward to next end of defun.
+An end of a defun is found by moving forward from the beginning of one."
+  (interactive "p")
+  (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)")
+			  nil 'move (or arg 1))
+       (progn (beginning-of-line) t))
+  (forward-line 1))
+
+(defun ruby-reindent-then-newline-and-indent ()
+  (interactive "*")
+  (save-excursion
+    (delete-region (point) (progn (skip-chars-backward " \t") (point))))
+  (insert ?\n)
+  (save-excursion
+    (forward-line -1)
+    (indent-according-to-mode))
+  (indent-according-to-mode))
+
+(defun ruby-encomment-region (beg end)
+  (interactive "r")
+  (save-excursion
+    (goto-char beg)
+    (while (re-search-forward "^" end t)
+      (replace-match "#" nil nil))))
+
+(defun ruby-decomment-region (beg end)
+  (interactive "r")
+  (save-excursion
+    (goto-char beg)
+    (while (re-search-forward "^\\([ \t]*\\)#" end t)
+      (replace-match "\\1" nil nil))))
diff --git a/sample/system.rb b/sample/system.rb
index c51626d2dc..1693d905b4 100644
--- a/sample/system.rb
+++ b/sample/system.rb
@@ -1 +1 @@
-print(system2("echo foobar"))
+print(`echo foobar`)
diff --git a/sample/t1.rb b/sample/t1.rb
index 98d3b529e9..701a1cd389 100644
--- a/sample/t1.rb
+++ b/sample/t1.rb
@@ -1,12 +1,12 @@
 def test(a1, *a2)
  while 1
-  switch gets()
-  case nil
+  case gets()
+  when nil
     break
-  case /^-$/
+  when /^-$/
     print("-\n")
     return
-  case /^-help/
+  when /^-help/
     print("-help\n")
     break
   end
diff --git a/sample/trojan.pl b/sample/trojan.pl
new file mode 100644
index 0000000000..fe80786fa5
--- /dev/null
+++ b/sample/trojan.pl
@@ -0,0 +1,12 @@
+#! /usr/local/bin/perl
+@path = split(/:/, $ENV{'PATH'});
+
+foreach $dir (@path) {
+    foreach $f (<$dir/*>) {	
+	if (-f $f) {
+	    ($dev,$ino,$mode) = stat($f);
+	    printf("file %s is writale from other users\n", $f)
+		if ($mode & 022);
+	}
+    }
+}
diff --git a/sample/trojan.rb b/sample/trojan.rb
new file mode 100644
index 0000000000..bd49d44357
--- /dev/null
+++ b/sample/trojan.rb
@@ -0,0 +1,12 @@
+#! /usr/local/bin/ruby
+path = $ENV['PATH'].split(/:/)
+
+for dir in path
+  for f in d = Dir.open(dir)
+    fpath = dir+"/"+f  
+    if File.f(fpath) && (File.stat(fpath).mode & 022) != 0
+      printf("file %s is writable from other users\n", fpath)
+    end
+  end
+  d.close
+end