* numeric.c (flo_to_s): get rid of buffer overflow.

* io.c (appendline): clearerr(3) before raising exception, since
  exception may be captured by rescue. [ruby-talk:77794]


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

ChangeLog

@@ -1,3 +1,12 @@
+Sun Aug  3 02:45:06 2003  Koji Arai  <jca02266@nifty.ne.jp>
+
+	* numeric.c (flo_to_s): get rid of buffer overflow.
+
+Sat Aug  2 23:51:52 2003  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* io.c (appendline): clearerr(3) before raising exception, since
+	  exception may be captured by rescue. [ruby-talk:77794]
+
 Sat Aug  2 20:59:38 2003  GOTOU Yuuzou  <gotoyuzo@notwork.org>
 
 	* lib/webrick/https.rb: change an option name.

ext/tk/lib/tk.rb

@@ -1839,10 +1839,17 @@ class TkVariable
     string(value).to_s
   end
 
+<<<<<<< tk.rb
+  def to_symbol
+    value.intern
+  end
+
+=======
   def to_sym
     value.intern
   end
 
+>>>>>>> 1.73
   def inspect
     format "#<TkVariable: %s>", @id
   end
@@ -1853,8 +1860,13 @@ class TkVariable
       self.equal?(other)
     when String
       self.to_s == other
+<<<<<<< tk.rb
+    when Symbol
+      self.to_symbol == other
+=======
     when Symbol
       self.to_sym == other
+>>>>>>> 1.73
     when Integer
       self.to_i == other
     when Float

io.c

@@ -908,9 +908,9 @@ appendline(fptr, delim, strp)
 	TRAP_END;
 	if (c == EOF) {
 	    if (ferror(f)) {
+		clearerr(f);
 		if (!rb_io_wait_readable(fileno(f)))
 		    rb_sys_fail(fptr->path);
-		clearerr(f);
 		continue;
 	    }
 	    return c;

lib/singleton.rb

@@ -11,10 +11,10 @@
 #
 #    a,b  = Klass.instance, Klass.instance
 #    a == b   # => true
-#    a.new     #  NoMethodError - new is private ...
+#    a.new    #  NoMethodError - new is private ...
 #
-# *  ``The instance'' is created at instanciation time, in other words
+# *  ``The instance'' is created at instanciation time, in other
-#    the first call of Klass.instance(), thus
+#    words the first call of Klass.instance(), thus
 #
 #    class OtherKlass
 #        include Singleton
@@ -25,148 +25,157 @@
 # *  This behavior is preserved under inheritance and cloning.
 #
 #
+#
 # This is achieved by marking
 # *  Klass.new and Klass.allocate - as private
-# *  removing #clone and #dup and modifying 
+#
+# Providing (or modifying) the class methods
 # *  Klass.inherited(sub_klass) and Klass.clone()  - 
 #    to ensure that the Singleton pattern is properly
 #    inherited and cloned.
 #
-# In addition Klass is providing the additional class methods
+# *  Klass.instance()  -  returning ``the instance''. After a
-# *  Klass.instance()  -  returning ``the instance''. After a successful
+#    successful self modifying (normally the first) call the
-#    self modifying instanciating first call the method body is a simple
+#    method body is a simple:
-#           def Klass.instance()
+#
-#               return @__instance__
+#       def Klass.instance()
-#           end
+#         return @__instance__
-# *  Klass._load(str)  -  calls instance()
+#       end
-# *  Klass._instanciate?()  -  returning ``the instance'' or nil
+#
-#    This hook method puts a second (or nth) thread calling
+# *  Klass._load(str)  -  calling Klass.instance()
-#    Klass.instance() on a waiting loop. The return value signifies
+#
-#    the successful completion or premature termination of the
+# *  Klass._instanciate?()  -  returning ``the instance'' or
-#    first, or more generally, current instanciating thread.
+#    nil. This hook method puts a second (or nth) thread calling
+#    Klass.instance() on a waiting loop. The return value
+#    signifies the successful completion or premature termination
+#    of the first, or more generally, current "instanciation thread".
+#
+#
+# The instance method of Singleton are
+# * clone and dup - raising TypeErrors to prevent cloning or duping
 #
-# The sole instance method of Singleton is
 # *  _dump(depth) - returning the empty string.  Marshalling strips
-#    by default all state information, e.g. instance variables and taint
+#    by default all state information, e.g. instance variables and
-#    state, from ``the instance''.  Providing custom _load(str) and
+#    taint state, from ``the instance''.  Providing custom _load(str)
-#    _dump(depth) hooks allows the (partially) resurrections of a
+#    and _dump(depth) hooks allows the (partially) resurrections of
-#    previous state of ``the instance''.
+#    a previous state of ``the instance''.
+
+
 
 module Singleton
-    private 
+  #  disable build-in copying methods
-    #  default marshalling strategy
+  def clone
-    def _dump(depth=-1) '' end
+    raise TypeError, "can't clone instance of singleton #{self.class}"
-    
+  end
-    class << self
+  def dup
-        #  extending an object with Singleton is a bad idea
+    raise TypeError, "can't dup instance of singleton #{self.class}"
-        undef_method :extend_object
+  end
-        private
+  
-        def append_features(mod)
+  private 
-            #  This catches ill advisted inclusions of Singleton in
+  #  default marshalling strategy
-            #  singletons types (sounds like an oxymoron) and 
+  def _dump(depth=-1) 
-            #  helps out people counting on transitive mixins
+    ''
-            unless mod.instance_of?(Class)
+  end
-                raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
-            end 
-            unless (class << mod; self end) <= (class << Object; self end)
-                raise TypeError, "Inclusion of the OO-Singleton module in singleton type"
-            end
-            super
-        end
-        def included(klass)
-            #  remove build in copying methods
-            klass.class_eval do 
-	      define_method(:clone) {raise TypeError, "can't clone singleton #{self.class}"}
-            end
-            
-            #  initialize the ``klass instance variable'' @__instance__ to nil
-            klass.instance_eval do @__instance__ = nil end
-            class << klass
-                #  a main point of the whole exercise - make
-                #  new and allocate private
-                private  :new, :allocate
-                
-                #  declare the self modifying klass#instance method
-                define_method(:instance, Singleton::FirstInstanceCall) 
-                 
-                #  simple waiting loop hook - should do in most cases
-                #  note the pre/post-conditions of a thread-critical state
-                private   
-                def _instanciate?()
-                    while false.equal?(@__instance__)
-                        Thread.critical = false
-                        sleep(0.08)  
-                        Thread.critical = true
-                    end
-                    @__instance__
-                end
-                
-                #  default Marshalling strategy
-                def _load(str) instance end    
-                 
-               #  ensure that the Singleton pattern is properly inherited   
-                def inherited(sub_klass)
-                    super
-                    sub_klass.instance_eval do @__instance__ = nil end
-                    class << sub_klass
-                        define_method(:instance, Singleton::FirstInstanceCall) 
-                    end
-                end 
-                
-                public
-                #  properly clone the Singleton pattern. Question - Did
-                #  you know that duping doesn't copy class methods?
-                def clone
-                    res = super
-                    res.instance_eval do @__instance__ = nil end
-                    class << res
-                        define_method(:instance, Singleton::FirstInstanceCall)
-                    end
-                    res
-                end
-            end   #  of << klass
-        end       #  of included
-    end           #  of << Singleton
-    
-    FirstInstanceCall = proc do
-        #  @__instance__ takes on one of the following values
-        #  * nil     -  before and after a failed creation
-        #  * false  -  during creation
-        #  * sub_class instance  -  after a successful creation
-        #  the form makes up for the lack of returns in progs
-        Thread.critical = true
-        if  @__instance__.nil?
-            @__instance__  = false
-            Thread.critical = false
-            begin
-                @__instance__ = new
-            ensure
-                if @__instance__
-		    define_method(:instance) {@__instance__}
-                else
-                    @__instance__ = nil #  failed instance creation
-                end
-            end
-        elsif  _instanciate?()
-            Thread.critical = false    
-        else
-            @__instance__  = false
-            Thread.critical = false
-            begin
-                @__instance__ = new
-            ensure
-                if @__instance__
-		    define_method(:instance) {@__instance__}
-                else
-                    @__instance__ = nil
-                end
-            end
-        end
-        @__instance__ 
-    end
 end
 
 
+class << Singleton
+  #  Method body of first instance call.
+  FirstInstanceCall = proc do
+    #  @__instance__ takes on one of the following values
+    #  * nil     -  before and after a failed creation
+    #  * false  -  during creation
+    #  * sub_class instance  -  after a successful creation
+    #  the form makes up for the lack of returns in progs
+    Thread.critical = true
+    if  @__instance__.nil?
+      @__instance__  = false
+      Thread.critical = false
+      begin
+        @__instance__ = new
+      ensure
+        if @__instance__
+          def self.instance; @__instance__ end
+        else
+          @__instance__ = nil #  failed instance creation
+        end
+      end
+    elsif  _instanciate?()
+      Thread.critical = false    
+    else
+      @__instance__  = false
+      Thread.critical = false
+      begin
+        @__instance__ = new
+      ensure
+        if @__instance__
+          def self.instance; @__instance__ end
+        else
+          @__instance__ = nil
+        end
+      end
+    end
+    @__instance__
+  end
+  
+  module SingletonClassMethods  
+    # properly clone the Singleton pattern - did you know
+    # that duping doesn't copy class methods?  
+    def clone
+      Singleton.__init__(super)
+    end
+    
+    private
+    
+    #  ensure that the Singleton pattern is properly inherited   
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+    
+    def _load(str) 
+      instance 
+    end
+    
+    # waiting-loop hook
+    def _instanciate?()
+      while false.equal?(@__instance__)
+        Thread.critical = false
+        sleep(0.08)   # timeout
+        Thread.critical = true
+      end
+      @__instance__
+    end
+  end
+  
+  def __init__(klass)
+    klass.instance_eval { @__instance__ = nil }
+    class << klass
+      define_method(:instance,FirstInstanceCall)
+    end
+    klass
+  end
+  
+  private
+  #  extending an object with Singleton is a bad idea
+  undef_method :extend_object
+  
+  def append_features(mod)
+    #  help out people counting on transitive mixins
+    unless mod.instance_of?(Class)
+      raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
+    end
+    super
+  end
+  
+  def included(klass)
+    super
+    klass.private_class_method  :new, :allocate
+    klass.extend SingletonClassMethods
+    Singleton.__init__(klass)
+  end
+end
+ 
 
 
 if __FILE__ == $0
@@ -175,11 +184,10 @@ def num_of_instances(klass)
     "#{ObjectSpace.each_object(klass){}} #{klass} instance(s)"
 end 
 
-# The basic and most important example.  The latter examples demonstrate
+# The basic and most important example.
-# advanced features that have no relevance for the general usage
 
 class SomeSingletonClass
-    include Singleton
+  include Singleton
 end
 puts "There are #{num_of_instances(SomeSingletonClass)}" 
 
@@ -188,9 +196,9 @@ b = SomeSingletonClass.instance # a and b are same object
 puts "basic test is #{a == b}"
 
 begin
-    SomeSingletonClass.new
+  SomeSingletonClass.new
 rescue  NoMethodError => mes
-    puts mes
+  puts mes
 end
 
 
@@ -199,83 +207,102 @@ puts "\nThreaded example with exception and customized #_instanciate?() hook"; p
 Thread.abort_on_exception = false
 
 class Ups < SomeSingletonClass
-    def initialize
+  def initialize
-        self.class.__sleep
+    self.class.__sleep
-        puts "initialize called by thread ##{Thread.current[:i]}"
+    puts "initialize called by thread ##{Thread.current[:i]}"
+  end
+end
+  
+class << Ups
+  def _instanciate?
+    @enter.push Thread.current[:i]
+    while false.equal?(@__instance__)
+      Thread.critical = false
+      sleep 0.08 
+      Thread.critical = true
     end
-    class << self
+    @leave.push Thread.current[:i]
-        def _instanciate?
+    @__instance__
-            @enter.push Thread.current[:i]
+  end
-            while false.equal?(@__instance__)
+  
-                Thread.critical = false
+  def __sleep
-                sleep 0.04 
+    sleep(rand(0.08))
-                Thread.critical = true
+  end
-            end
+  
-            @leave.push Thread.current[:i]
+  def new
-            @__instance__
+    begin
-        end
+      __sleep
-        def __sleep
+      raise  "boom - thread ##{Thread.current[:i]} failed to create instance"
-            sleep(rand(0.08))
+    ensure
-        end 
+      # simple flip-flop
-        def allocate
+      class << self
-            __sleep
+        remove_method :new
-            def self.allocate; __sleep; super() end
+      end
-            raise  "boom - allocation in thread ##{Thread.current[:i]} aborted"
-        end
-        def instanciate_all
-            @enter = []
-            @leave = []
-            1.upto(9) do |i|  
-                Thread.new do 
-                    begin
-                        Thread.current[:i] = i
-                        __sleep
-                        instance
-                    rescue RuntimeError => mes
-                        puts mes
-                    end
-                end
-            end
-            puts "Before there were #{num_of_instances(self)}"
-            sleep 5
-            puts "Now there is #{num_of_instances(self)}"
-            puts "#{@enter.join '; '} was the order of threads entering the waiting loop"
-            puts "#{@leave.join '; '} was the order of threads leaving the waiting loop"
-        end
     end
+  end
+  
+  def instanciate_all
+    @enter = []
+    @leave = []
+    1.upto(9) {|i|  
+      Thread.new { 
+        begin
+          Thread.current[:i] = i
+          __sleep
+          instance
+        rescue RuntimeError => mes
+          puts mes
+        end
+      }
+    }
+    puts "Before there were #{num_of_instances(self)}"
+    sleep 3
+    puts "Now there is #{num_of_instances(self)}"
+    puts "#{@enter.join '; '} was the order of threads entering the waiting loop"
+    puts "#{@leave.join '; '} was the order of threads leaving the waiting loop"
+  end
 end
 
+
 Ups.instanciate_all
-#  results in message like
+# results in message like
-#  Before there were 0 Ups instances
+# Before there were 0 Ups instance(s)
-#  boom - allocation in thread #8 aborted
+# boom - thread #6 failed to create instance
-#  initialize called by thread #3
+# initialize called by thread #3
-#  Now there is 1 Ups instance
+# Now there is 1 Ups instance(s)
-#  2; 3; 6; 1; 7; 5; 9; 4 was the order of threads entering the waiting loop
+# 3; 2; 1; 8; 4; 7; 5 was the order of threads entering the waiting loop
-#  3; 2; 1; 7; 6; 5; 4; 9 was the order of threads leaving the waiting loop
+# 3; 2; 1; 7; 4; 8; 5 was the order of threads leaving the waiting loop
+
 
 puts "\nLets see if class level cloning really works"
 Yup = Ups.clone
-def Yup.allocate
+def Yup.new
+  begin
     __sleep
-    def self.allocate; __sleep; super() end
+    raise  "boom - thread ##{Thread.current[:i]} failed to create instance"
-    raise  "boom - allocation in thread ##{Thread.current[:i]} aborted"
+  ensure
+    # simple flip-flop
+    class << self
+      remove_method :new
+    end
+  end
 end
 Yup.instanciate_all
 
 
-puts "\n","Customized marshalling"
+puts "\n\n","Customized marshalling"
 class A
-    include Singleton
+  include Singleton
-    attr_accessor :persist, :die
+  attr_accessor :persist, :die
-    def _dump(depth)
+  def _dump(depth)
-        # this strips the @die information from the instance
+    # this strips the @die information from the instance
-        Marshal.dump(@persist,depth)
+    Marshal.dump(@persist,depth)
-    end
+  end
 end
+
 def A._load(str)
-    instance.persist = Marshal.load(str)
+  instance.persist = Marshal.load(str)
-    instance
+  instance
 end
 
 a = A.instance
@@ -292,45 +319,36 @@ p a == b  #  => true
 p a.persist  #  => ["persist"]
 p a.die      #  => nil
 
+
 puts "\n\nSingleton with overridden default #inherited() hook"
 class Up
-    def Up.inherited(sub_klass)
+end
-        puts "#{sub_klass} subclasses #{self}"
+def Up.inherited(sub_klass)
-    end
+  puts "#{sub_klass} subclasses #{self}"
 end
 
 
 class Middle < Up
-    undef_method :dup
+  include Singleton
-    include Singleton
 end
+
 class Down < Middle; end
 
-puts  "basic test is #{Down.instance == Down.instance}"  
+puts  "and basic \"Down test\" is #{Down.instance == Down.instance}\n
-
+Various exceptions"  
-
-puts "\n","Various exceptions"
 
 begin
-    module AModule
+  module AModule
-        include Singleton
+    include Singleton
-    end
+  end
 rescue TypeError => mes
-    puts mes  #=> Inclusion of the OO-Singleton module in module AModule
+  puts mes  #=> Inclusion of the OO-Singleton module in module AModule
 end
 
 begin
-    class << 'aString'
+  'aString'.extend Singleton
-        include Singleton
-    end
-rescue TypeError => mes
-    puts mes  # => Inclusion of the OO-Singleton module in singleton type
-end
-
-begin
-    'aString'.extend Singleton
 rescue NoMethodError => mes
-    puts mes  #=> undefined method `extend_object' for Singleton:Module
+  puts mes  #=> undefined method `extend_object' for Singleton:Module
 end
 
 end

numeric.c

@@ -289,7 +289,7 @@ static VALUE
 flo_to_s(flt)
     VALUE flt;
 {
-    char buf[24];
+    char buf[25];
     char *fmt = "%.15g";
     double value = RFLOAT(flt)->value;
     double avalue, d1, d2;