archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-08-23 21:14:23 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

* io.c (rb_io_reopen): should clear allocated OpenFile. pointed

Browse source 
out by Guy Decoux. [ruby-core:03288]


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@6780 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
matz 2004-08-17 08:31:02 +00:00
parent 5a72ce5cfa
commit ecf157699d
6 changed files with 159 additions and 186 deletions
Download patch file Download diff file Expand all files Collapse all files

5
ChangeLog
View file

@ -1,3 +1,8 @@
Tue Aug 17 17:20:59 2004 Yukihiro Matsumoto <matz@ruby-lang.org>
* io.c (rb_io_reopen): should clear allocated OpenFile. pointed
out by Guy Decoux. [ruby-core:03288]
Tue Aug 17 01:36:32 2004 Dave Thomas <dave@pragprog.com> Tue Aug 17 01:36:32 2004 Dave Thomas <dave@pragprog.com>
* lib/rdoc/usage.rb: Remove extra indent. Tidy 'ri' option * lib/rdoc/usage.rb: Remove extra indent. Tidy 'ri' option

5
error.c
View file

@ -353,10 +353,7 @@ exc_initialize(argc, argv, exc)
{ {
VALUE arg; VALUE arg;
if (rb_scan_args(argc, argv, "01", &arg) == 1) { rb_scan_args(argc, argv, "01", &arg);
VALUE mesg = arg;
StringValue(mesg); /* ensure mesg can be converted to String */
}
rb_iv_set(exc, "mesg", arg); rb_iv_set(exc, "mesg", arg);
rb_iv_set(exc, "bt", Qnil); rb_iv_set(exc, "bt", Qnil);

1
eval.c
View file

@ -4594,7 +4594,6 @@ break_jump(retval)
VALUE retval; VALUE retval;
{ {
struct tag *tt = prot_tag; struct tag *tt = prot_tag;
int yield = Qfalse;
if (retval == Qundef) retval = Qnil; if (retval == Qundef) retval = Qnil;
while (tt) { while (tt) {

2
io.c
View file

@ -3155,6 +3155,7 @@ rb_io_reopen(argc, argv, file)
fptr = RFILE(file)->fptr; fptr = RFILE(file)->fptr;
if (!fptr) { if (!fptr) {
fptr = RFILE(file)->fptr = ALLOC(OpenFile); fptr = RFILE(file)->fptr = ALLOC(OpenFile);
MEMZERO(fptr, OpenFile, 1);
} }
if (!NIL_P(nmode)) { if (!NIL_P(nmode)) {
@ -3178,7 +3179,6 @@ rb_io_reopen(argc, argv, file)
fclose(fptr->f2); fclose(fptr->f2);
fptr->f2 = 0; fptr->f2 = 0;
} }
return file; return file;
} }

91
misc/ruby-mode.el
View file

@ -222,7 +222,7 @@ Also ignores spaces after parenthesis when 'space."
(make-variable-buffer-local 'comment-column) (make-variable-buffer-local 'comment-column)
(setq comment-column ruby-comment-column) (setq comment-column ruby-comment-column)
(make-variable-buffer-local 'comment-start-skip) (make-variable-buffer-local 'comment-start-skip)
(setq comment-start-skip "\\(^\\|\\s-\\);?#+ *") (setq comment-start-skip "#+ *")
(setq indent-tabs-mode ruby-indent-tabs-mode) (setq indent-tabs-mode ruby-indent-tabs-mode)
(make-local-variable 'parse-sexp-ignore-comments) (make-local-variable 'parse-sexp-ignore-comments)
(setq parse-sexp-ignore-comments t) (setq parse-sexp-ignore-comments t)
@ -561,42 +561,12 @@ The variable ruby-indent-level controls the amount of indentation.
(defun ruby-indent-size (pos nest) (defun ruby-indent-size (pos nest)
(+ pos (* (or nest 1) ruby-indent-level))) (+ pos (* (or nest 1) ruby-indent-level)))
(defconst ruby-assign-re "\\s *\\(&&\\|||\\|<<\\|>>\\|[-+*/%&|^]\\)?=\\s *")
(defun ruby-beginning-of-arg (start end)
(save-restriction
(narrow-to-region start (1+ end))
(goto-char start)
(let ((beg t) arg)
(while
(progn
(skip-chars-forward " \t\n")
(and (not (eobp))
(= (ruby-forward-sexp) 0)))
(skip-syntax-forward " ")
(cond ((looking-at ",")
(forward-char)
(setq arg start beg t))
((ruby-expr-beg) t)
((looking-at "=>\\s *")
(goto-char (match-end 0))
(setq arg nil beg nil))
((looking-at ruby-assign-re)
(goto-char (match-end 0))
(if beg (setq beg nil arg (point))))
((looking-at ruby-operator-re)
(goto-char (match-end 0))
(if beg (setq beg nil arg (match-end 0))))
((not (eq (char-syntax (char-after)) ?\())
(setq start (point)))))
(goto-char (or arg start)))))
(defun ruby-calculate-indent (&optional parse-start) (defun ruby-calculate-indent (&optional parse-start)
(save-excursion (save-excursion
(beginning-of-line) (beginning-of-line)
(let ((indent-point (point)) (let ((indent-point (point))
(case-fold-search nil) (case-fold-search nil)
state bol eol begin state bol eol begin op-end
(paren (progn (skip-syntax-forward " ") (paren (progn (skip-syntax-forward " ")
(and (char-after) (matching-paren (char-after))))) (and (char-after) (matching-paren (char-after)))))
(indent 0)) (indent 0))
@ -656,7 +626,6 @@ The variable ruby-indent-level controls the amount of indentation.
(re-search-forward ruby-negative eol t)) (re-search-forward ruby-negative eol t))
(and (not (eq ?_ (char-after (match-end 0)))) (and (not (eq ?_ (char-after (match-end 0))))
(setq indent (- indent ruby-indent-level)))) (setq indent (- indent ruby-indent-level))))
;;operator terminated lines
((and ((and
(save-excursion (save-excursion
(beginning-of-line) (beginning-of-line)
@ -674,20 +643,20 @@ The variable ruby-indent-level controls the amount of indentation.
(setq done t)))) (setq done t))))
(setq bol (point)) (setq bol (point))
(end-of-line) (end-of-line)
;; skip the comment at the end
(skip-chars-backward " \t") (skip-chars-backward " \t")
(let (end (pos (point))) (let (end (pos (point)))
(beginning-of-line) (beginning-of-line)
(while (and (re-search-forward "#" pos t) (while (and (re-search-forward "#" pos t)
(setq end (1- (point))) (setq end (1- (point)))
(ruby-special-char-p end)) (or (ruby-special-char-p end)
(and (setq state (ruby-parse-region parse-start end))
(nth 0 state))))
(setq end nil)) (setq end nil))
(goto-char (or end pos)) (goto-char (or end pos))
(skip-chars-backward " \t") (skip-chars-backward " \t")
(and (setq begin (if (nth 0 state) pos (cdr (nth 1 state))))
(setq state (ruby-parse-region parse-start (point))) (setq state (ruby-parse-region parse-start (point))))
(nth 0 state)
(setq begin (cdr (nth 1 state)))
(goto-char pos)))
(or (bobp) (forward-char -1)) (or (bobp) (forward-char -1))
(and (and
(or (and (looking-at ruby-symbol-re) (or (and (looking-at ruby-symbol-re)
@ -699,16 +668,16 @@ The variable ruby-indent-level controls the amount of indentation.
(not (looking-at "[a-z_]")))) (not (looking-at "[a-z_]"))))
(and (looking-at ruby-operator-re) (and (looking-at ruby-operator-re)
(not (ruby-special-char-p)) (not (ruby-special-char-p))
;; operator at the end of line
(let ((c (char-after (point)))) (let ((c (char-after (point))))
(and (and
(or (not (eq ?, c)) ;; (or (null begin)
(null begin) ;; (save-excursion
(save-excursion ;; (goto-char begin)
(goto-char begin) ;; (skip-chars-forward " \t")
(skip-chars-forward " \t") ;; (not (or (eolp) (looking-at "#")
(not (or (eolp) (looking-at "#") ;; (and (eq (car (nth 1 state)) ?{)
(and (eq (car (nth 1 state)) ?{) ;; (looking-at "|"))))))
(looking-at "|"))))))
(or (not (eq ?/ c)) (or (not (eq ?/ c))
(null (nth 0 (ruby-parse-region (or begin parse-start) (point))))) (null (nth 0 (ruby-parse-region (or begin parse-start) (point)))))
(or (not (eq ?| (char-after (point)))) (or (not (eq ?| (char-after (point))))
@ -724,15 +693,21 @@ The variable ruby-indent-level controls the amount of indentation.
(progn (progn
(forward-word -1) (forward-word -1)
(not (looking-at "do\\>[^_]"))))) (not (looking-at "do\\>[^_]")))))
(t t)))))))) (t t))))
(not (eq ?, c))
(setq op-end t)))))
(setq indent (setq indent
(cond (cond
((and ((and
(null op-end)
(not (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>"))) (not (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>")))
(eq (ruby-deep-indent-paren-p t) 'space) (eq (ruby-deep-indent-paren-p t) 'space)
(not (bobp))) (not (bobp)))
(ruby-beginning-of-arg (or begin parse-start) (point)) (save-excursion
(current-column)) (widen)
(goto-char (or begin parse-start))
(skip-syntax-forward " ")
(current-column)))
(t (t
(+ indent ruby-indent-level)))))))) (+ indent ruby-indent-level))))))))
indent))) indent)))
@ -802,9 +777,9 @@ An end of a defun is found by moving forward from the beginning of one."
((> start pos) ((> start pos)
(setq done t))))) (setq done t)))))
(if done (if done
(progn (save-excursion
(back-to-indentation) (back-to-indentation)
(if (looking-at (concat ("\\<\\(" ruby-block-mid-re "\\)\\>"))) (if (looking-at (concat "\\<\\(" ruby-block-mid-re "\\)\\>"))
(setq done nil)))))) (setq done nil))))))
(back-to-indentation)) (back-to-indentation))
@ -832,7 +807,9 @@ An end of a defun is found by moving forward from the beginning of one."
(skip-chars-forward ",.:;|&^~=!?\\+\\-\\*") (skip-chars-forward ",.:;|&^~=!?\\+\\-\\*")
(looking-at "\\s(")) (looking-at "\\s("))
(goto-char (scan-sexps (point) 1))) (goto-char (scan-sexps (point) 1)))
((looking-at (concat "\\<\\(" ruby-block-beg-re "\\)\\>")) ((and (looking-at (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))
(not (eq (char-before (point)) ?.))
(not (eq (char-before (point)) ?:)))
(ruby-end-of-block) (ruby-end-of-block)
(forward-word 1)) (forward-word 1))
((looking-at "\\(\\$\\|@@?\\)?\\sw") ((looking-at "\\(\\$\\|@@?\\)?\\sw")
@ -1013,10 +990,6 @@ balanced expression is found."
("\\(^\\|[=(,~?:;]\\|\\(^\\|\\s \\)\\(if\\|elsif\\|unless\\|while\\|until\\|when\\|and\\|or\\|&&\\|||\\)\\|g?sub!?\\|scan\\|split!?\\)\\s *\\(/\\)[^/\n\\\\]*\\(\\\\.[^/\n\\\\]*\\)*\\(/\\)" ("\\(^\\|[=(,~?:;]\\|\\(^\\|\\s \\)\\(if\\|elsif\\|unless\\|while\\|until\\|when\\|and\\|or\\|&&\\|||\\)\\|g?sub!?\\|scan\\|split!?\\)\\s *\\(/\\)[^/\n\\\\]*\\(\\\\.[^/\n\\\\]*\\)*\\(/\\)"
(4 (7 . ?/)) (4 (7 . ?/))
(6 (7 . ?/))) (6 (7 . ?/)))
;; %Q!...!
("\\(^\\|[[ \t\n<+(,=]\\)%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\2\\)"
(2 (7 . nil))
(4 (7 . nil)))
("^\\(=\\)begin\\(\\s \\|$\\)" 1 (7 . nil)) ("^\\(=\\)begin\\(\\s \\|$\\)" 1 (7 . nil))
("^\\(=\\)end\\(\\s \\|$\\)" 1 (7 . nil)))) ("^\\(=\\)end\\(\\s \\|$\\)" 1 (7 . nil))))
@ -1098,7 +1071,6 @@ balanced expression is found."
t) t)
nil))) nil)))
(defvar ruby-font-lock-keywords (defvar ruby-font-lock-keywords
(list (list
;; functions ;; functions
@ -1168,6 +1140,9 @@ balanced expression is found."
0 font-lock-string-face t) 0 font-lock-string-face t)
`(,ruby-here-doc-beg-re `(,ruby-here-doc-beg-re
0 font-lock-string-face t) 0 font-lock-string-face t)
;; general delimited string
'("\\(^\\|[[ \t\n<+(,=]\\)\\(%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\3\\)\\)"
(2 font-lock-string-face))
;; constants ;; constants
'("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)" '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
2 font-lock-type-face) 2 font-lock-type-face)

3
string.c
View file

@ -1242,9 +1242,6 @@ static VALUE
rb_str_match(x, y) rb_str_match(x, y)
VALUE x, y; VALUE x, y;
{ {
VALUE reg;
long start;
switch (TYPE(y)) { switch (TYPE(y)) {
case T_STRING: case T_STRING:
rb_raise(rb_eTypeError, "type mismatch: String given"); rb_raise(rb_eTypeError, "type mismatch: String given");