edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/IO/sockets.rb;C448437 File: sockets.rb =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/IO/sockets.rb;C448437 (server) 5/24/2008 11:47 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/IO/sockets.rb;WEBrick @@ -1,9 +1,62 @@ -$: << 'C:\M0\Merlin\Main\Languages\Ruby\Libs' +$: << 'C:\M1\Merlin\Main\Languages\Ruby\Libs' require 'socket' +require 'fcntl' +require 'thread' -s = TCPServer.new("127.0.0.1", 3000) -p s -p svr = IO.select([s], nil, nil)[0][0] -p sock = svr.accept -p addr = sock.peeraddr +class WebServer + def initialize + @tokens = SizedQueue.new(5) + 5.times{ @tokens.push(nil) } + end + + def run + thgroup = ThreadGroup.new + @status = :Running + @listeners = [TCPServer.new("127.0.0.1", 3000)] + while @status == :Running + puts "#{Thread.current.inspect}: waiting" + if svrs = IO.select(@listeners, nil, nil, 2.0) + puts "#{Thread.current.inspect}: selected #{svrs[0]}" + + svrs[0].each{|svr| + @tokens.pop # blocks while no token is there. + if sock = accept_client(svr) + th = start_thread(sock) + th[:WEBrickThread] = true + thgroup.add(th) + else + @tokens.push(nil) + end + } + end + end + end + + def accept_client(svr) + puts "#{Thread.current.inspect}: accept_client #{svr}" + sock = nil + sock = svr.accept + puts "#{Thread.current.inspect}: accepted #{sock}" + sock.sync = true + return sock + end + + + def start_thread(sock, &block) + Thread.start{ + Thread.current[:WEBrickSocket] = sock + addr = sock.peeraddr + puts "#{Thread.current.inspect}: working, peer = #{addr.inspect}" + + @tokens.push(nil) + + Thread.current[:WEBrickSocket] = nil + + puts "#{Thread.current.inspect}: close, peer = #{addr.inspect}" + sock.close + } + end +end + +WebServer.new.run =================================================================== add: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/Numeric/StringToF.rb File: StringToF.rb =================================================================== --- [no source file] +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/Numeric/StringToF.rb;WEBrick @@ -1,0 +1,42 @@ +p "1.".to_f +p ".e1".to_f +p "e+10".to_f +p "1e-_1".to_f +p "1e".to_f +p "1e-".to_f +p "1e-____".to_f + +p "-.1".to_f +p "-.1".to_f + +p "e12".to_f +p "+e12".to_f +p ".".to_f +p " + 12312.4234".to_f +p "+__2".to_f +p "-__2".to_f +p "INF".to_f + +puts '--' + +p "-".to_f +p "+".to_f + +p "+.1".to_f +p ".1".to_f +p "1e12".to_f +p "12312.4234".to_f +p " +12312.4234".to_f +p "_____312".to_f +p "\r\n\t +12_____312.4___234e___21$%$".to_f + +puts '--' + +p "1".to_f +p "1$".to_f +p "1.$".to_f +p "1.0$".to_f +p "1.01$".to_f +p "1.01e$".to_f +p "1.01e+$".to_f +p "1.01e+1$".to_f =================================================================== add: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/Thread/abort.rb File: abort.rb =================================================================== --- [no source file] +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Experimental/Thread/abort.rb;WEBrick @@ -1,0 +1,17 @@ +t = Thread.start { + puts 'start' + while true + puts 'tick' + sleep(0.6) + end +} +sleep(0.3) +p t + +p t.kill +p t.kill +p t.kill +p t.kill +p t.kill +p t.kill + =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C448443 File: Initializers.Generated.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C448443 (server) 5/24/2008 2:19 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;WEBrick @@ -30,14 +30,15 @@ // Skipped primitive: __ClassSingleton // Skipped primitive: __MainSingleton - Ruby.Builtins.RubyModule def25 = DefineGlobalModule("Comparable", typeof(Ruby.Builtins.Comparable), new System.Action(LoadComparable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def16 = DefineGlobalModule("Enumerable", typeof(Ruby.Builtins.Enumerable), new System.Action(LoadEnumerable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def26 = DefineGlobalModule("Comparable", typeof(Ruby.Builtins.Comparable), new System.Action(LoadComparable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def17 = DefineGlobalModule("Enumerable", typeof(Ruby.Builtins.Enumerable), new System.Action(LoadEnumerable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); Ruby.Builtins.RubyModule def3 = DefineGlobalModule("Errno", typeof(Ruby.Builtins.Errno), null, null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def12 = DefineModule("File::Constants", typeof(Ruby.Builtins.RubyFileOps.Constants), new System.Action(LoadFile__Constants_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Kernel DefineGlobalModule("Marshal", typeof(Ruby.Builtins.RubyMarshal), new System.Action(LoadMarshal_Instance), new System.Action(LoadMarshal_Class), Ruby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("Math", typeof(Ruby.Builtins.RubyMath), new System.Action(LoadMath_Instance), new System.Action(LoadMath_Class), Ruby.Builtins.RubyModule.EmptyArray); ExtendClass(typeof(Microsoft.Scripting.Actions.TypeTracker), new System.Action(LoadMicrosoft__Scripting__Actions__TypeTracker_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyModule def21 = DefineGlobalModule("Precision", typeof(Ruby.Builtins.Precision), new System.Action(LoadPrecision_Instance), new System.Action(LoadPrecision_Class), Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def22 = DefineGlobalModule("Precision", typeof(Ruby.Builtins.Precision), new System.Action(LoadPrecision_Instance), new System.Action(LoadPrecision_Class), Ruby.Builtins.RubyModule.EmptyArray); #if !SILVERLIGHT DefineGlobalModule("Process", typeof(Ruby.Builtins.RubyProcess), new System.Action(LoadProcess_Instance), new System.Action(LoadProcess_Class), Ruby.Builtins.RubyModule.EmptyArray); #endif @@ -47,17 +48,17 @@ ExtendClass(typeof(System.Type), new System.Action(LoadSystem__Type_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); // Skipped primitive: __ClassSingletonSingleton #if !SILVERLIGHT - object def1 = DefineSingleton(new System.Action(Load__Singleton_ArgFilesSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }); + object def1 = DefineSingleton(new System.Action(Load__Singleton_ArgFilesSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }); #endif #if !SILVERLIGHT - object def2 = DefineSingleton(new System.Action(Load__Singleton_EnvironmentSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }); + object def2 = DefineSingleton(new System.Action(Load__Singleton_EnvironmentSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }); #endif // Skipped primitive: Object - ExtendModule(typeof(System.Collections.Generic.IDictionary), new System.Action(LoadSystem__Collections__Generic__IDictionary_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }); - Ruby.Builtins.RubyModule def29 = ExtendModule(typeof(System.Collections.IEnumerable), new System.Action(LoadSystem__Collections__IEnumerable_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }); - ExtendModule(typeof(System.Collections.IList), new System.Action(LoadSystem__Collections__IList_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }); - ExtendModule(typeof(System.IComparable), new System.Action(LoadSystem__IComparable_Instance), null, new Ruby.Builtins.RubyModule[] {def25, }); - DefineGlobalClass("Array", typeof(Ruby.Builtins.RubyArray), Context.ObjectClass, new System.Action(LoadArray_Instance), new System.Action(LoadArray_Class), new Ruby.Builtins.RubyModule[] {def16, }, new System.Delegate[] { + ExtendModule(typeof(System.Collections.Generic.IDictionary), new System.Action(LoadSystem__Collections__Generic__IDictionary_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }); + Ruby.Builtins.RubyModule def30 = ExtendModule(typeof(System.Collections.IEnumerable), new System.Action(LoadSystem__Collections__IEnumerable_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }); + ExtendModule(typeof(System.Collections.IList), new System.Action(LoadSystem__Collections__IList_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }); + ExtendModule(typeof(System.IComparable), new System.Action(LoadSystem__IComparable_Instance), null, new Ruby.Builtins.RubyModule[] {def26, }); + DefineGlobalClass("Array", typeof(Ruby.Builtins.RubyArray), Context.ObjectClass, new System.Action(LoadArray_Instance), new System.Action(LoadArray_Class), new Ruby.Builtins.RubyModule[] {def17, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArrayOps.CreateArray), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArrayOps.CreateArray), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArrayOps.CreateArray), @@ -67,23 +68,23 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArrayOps.CreateArray), }); DefineGlobalClass("Binding", typeof(Ruby.Builtins.Binding), Context.ObjectClass, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("ClrString", typeof(System.String), Context.ObjectClass, new System.Action(LoadClrString_Instance), null, new Ruby.Builtins.RubyModule[] {def29, }, null); - DefineGlobalClass("Dir", typeof(Ruby.Builtins.RubyDir), Context.ObjectClass, new System.Action(LoadDir_Instance), new System.Action(LoadDir_Class), new Ruby.Builtins.RubyModule[] {def16, }, null); - Ruby.Builtins.RubyClass def26 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), Context.ObjectClass, new System.Action(LoadException_Instance), new System.Action(LoadException_Class), Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ClrString", typeof(System.String), Context.ObjectClass, new System.Action(LoadClrString_Instance), null, new Ruby.Builtins.RubyModule[] {def30, }, null); + DefineGlobalClass("Dir", typeof(Ruby.Builtins.RubyDir), Context.ObjectClass, new System.Action(LoadDir_Instance), new System.Action(LoadDir_Class), new Ruby.Builtins.RubyModule[] {def17, }, null); + Ruby.Builtins.RubyClass def27 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), Context.ObjectClass, new System.Action(LoadException_Instance), new System.Action(LoadException_Class), Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ExceptionOps.Factory), }); Context.FalseClass = DefineGlobalClass("FalseClass", typeof(Ruby.Builtins.FalseClass), Context.ObjectClass, new System.Action(LoadFalseClass_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def14 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), Context.ObjectClass, new System.Action(LoadFile__Stat_Instance), new System.Action(LoadFile__Stat_Class), new Ruby.Builtins.RubyModule[] {def25, }, new System.Delegate[] { + Ruby.Builtins.RubyClass def15 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), Context.ObjectClass, new System.Action(LoadFile__Stat_Instance), new System.Action(LoadFile__Stat_Class), new Ruby.Builtins.RubyModule[] {def26, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.RubyStatOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.RubyStatOps.Create), }); #endif - DefineGlobalClass("Hash", typeof(Ruby.Builtins.Hash), Context.ObjectClass, new System.Action(LoadHash_Instance), new System.Action(LoadHash_Class), new Ruby.Builtins.RubyModule[] {def16, }, new System.Delegate[] { + DefineGlobalClass("Hash", typeof(Ruby.Builtins.Hash), Context.ObjectClass, new System.Action(LoadHash_Instance), new System.Action(LoadHash_Class), new Ruby.Builtins.RubyModule[] {def17, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.HashOps.Hash), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.HashOps.Hash), }); - Ruby.Builtins.RubyClass def27 = DefineGlobalClass("IO", typeof(Ruby.Builtins.RubyIO), Context.ObjectClass, new System.Action(LoadIO_Instance), new System.Action(LoadIO_Class), Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def28 = DefineGlobalClass("IO", typeof(Ruby.Builtins.RubyIO), Context.ObjectClass, new System.Action(LoadIO_Instance), new System.Action(LoadIO_Class), new Ruby.Builtins.RubyModule[] {def12, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.CreateIO), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.CreateIO), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.CreateIO), @@ -92,15 +93,15 @@ DefineGlobalClass("Method", typeof(Ruby.Builtins.RubyMethod), Context.ObjectClass, new System.Action(LoadMethod_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); // Skipped primitive: Module Context.NilClass = DefineGlobalClass("NilClass", typeof(Microsoft.Scripting.None), Context.ObjectClass, new System.Action(LoadNilClass_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def20 = DefineGlobalClass("Numeric", typeof(Ruby.Builtins.Numeric), Context.ObjectClass, new System.Action(LoadNumeric_Instance), null, new Ruby.Builtins.RubyModule[] {def25, }, null); + Ruby.Builtins.RubyClass def21 = DefineGlobalClass("Numeric", typeof(Ruby.Builtins.Numeric), Context.ObjectClass, new System.Action(LoadNumeric_Instance), null, new Ruby.Builtins.RubyModule[] {def26, }, null); DefineGlobalClass("Proc", typeof(Ruby.Builtins.Proc), Context.ObjectClass, new System.Action(LoadProc_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ProcOps.CreateProc), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ProcOps.CreateProc), }); - DefineGlobalClass("Range", typeof(Ruby.Builtins.Range), Context.ObjectClass, new System.Action(LoadRange_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }, new System.Delegate[] { + DefineGlobalClass("Range", typeof(Ruby.Builtins.Range), Context.ObjectClass, new System.Action(LoadRange_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RangeOps.CreateRange), }); - DefineGlobalClass("Regexp", typeof(Ruby.Builtins.RubyRegex), Context.ObjectClass, new System.Action(LoadRegexp_Instance), new System.Action(LoadRegexp_Class), new Ruby.Builtins.RubyModule[] {def16, }, new System.Delegate[] { + DefineGlobalClass("Regexp", typeof(Ruby.Builtins.RubyRegex), Context.ObjectClass, new System.Action(LoadRegexp_Instance), new System.Action(LoadRegexp_Class), new Ruby.Builtins.RubyModule[] {def17, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), @@ -110,108 +111,109 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), }); - DefineGlobalClass("String", typeof(Ruby.Builtins.MutableString), Context.ObjectClass, new System.Action(LoadString_Instance), null, new Ruby.Builtins.RubyModule[] {def16, def25, }, new System.Delegate[] { + DefineGlobalClass("String", typeof(Ruby.Builtins.MutableString), Context.ObjectClass, new System.Action(LoadString_Instance), null, new Ruby.Builtins.RubyModule[] {def17, def26, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.Create), }); - Ruby.Builtins.RubyClass def11 = DefineGlobalClass("Struct", typeof(Ruby.Builtins.RubyStruct), Context.ObjectClass, new System.Action(LoadStruct_Instance), null, new Ruby.Builtins.RubyModule[] {def16, }, new System.Delegate[] { + Ruby.Builtins.RubyClass def13 = DefineGlobalClass("Struct", typeof(Ruby.Builtins.RubyStruct), Context.ObjectClass, new System.Action(LoadStruct_Instance), null, new Ruby.Builtins.RubyModule[] {def17, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyStructOps.CreateNamed), }); DefineGlobalClass("Symbol", typeof(Microsoft.Scripting.SymbolId), Context.ObjectClass, new System.Action(LoadSymbol_Instance), new System.Action(LoadSymbol_Class), Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("Thread", typeof(System.Threading.Thread), Context.ObjectClass, new System.Action(LoadThread_Instance), new System.Action(LoadThread_Class), Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("ThreadGroup", typeof(Ruby.Builtins.ThreadGroup), Context.ObjectClass, new System.Action(LoadThreadGroup_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("Time", typeof(System.DateTime), Context.ObjectClass, new System.Action(LoadTime_Instance), new System.Action(LoadTime_Class), new Ruby.Builtins.RubyModule[] {def25, }, new System.Delegate[] { + DefineGlobalClass("Time", typeof(System.DateTime), Context.ObjectClass, new System.Action(LoadTime_Instance), new System.Action(LoadTime_Class), new Ruby.Builtins.RubyModule[] {def26, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.TimeOps.Create), }); Context.TrueClass = DefineGlobalClass("TrueClass", typeof(Ruby.Builtins.TrueClass), Context.ObjectClass, new System.Action(LoadTrueClass_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("UnboundMethod", typeof(Ruby.Builtins.UnboundMethod), Context.ObjectClass, new System.Action(LoadUnboundMethod_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); // Skipped primitive: Class - Ruby.Builtins.RubyClass def13 = DefineGlobalClass("File", typeof(Ruby.Builtins.RubyFile), def27, new System.Action(LoadFile_Instance), new System.Action(LoadFile_Class), Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def11 = DefineGlobalClass("File", typeof(Ruby.Builtins.RubyFile), def28, new System.Action(LoadFile_Instance), new System.Action(LoadFile_Class), Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.CreateIO), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.CreateIO), }); - DefineGlobalClass("Float", typeof(System.Double), def20, new System.Action(LoadFloat_Instance), new System.Action(LoadFloat_Class), new Ruby.Builtins.RubyModule[] {def21, }, null); - Ruby.Builtins.RubyClass def15 = DefineGlobalClass("Integer", typeof(Ruby.Builtins.Integer), def20, new System.Action(LoadInteger_Instance), new System.Action(LoadInteger_Class), new Ruby.Builtins.RubyModule[] {def21, }, null); - DefineGlobalClass("NoMemoryError", typeof(Ruby.Builtins.NoMemoryError), def26, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def23 = DefineGlobalClass("ScriptError", typeof(Ruby.Builtins.ScriptError), def26, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("Float", typeof(System.Double), def21, new System.Action(LoadFloat_Instance), new System.Action(LoadFloat_Class), new Ruby.Builtins.RubyModule[] {def22, }, null); + Ruby.Builtins.RubyClass def16 = DefineGlobalClass("Integer", typeof(Ruby.Builtins.Integer), def21, new System.Action(LoadInteger_Instance), new System.Action(LoadInteger_Class), new Ruby.Builtins.RubyModule[] {def22, }, null); + DefineGlobalClass("NoMemoryError", typeof(Ruby.Builtins.NoMemoryError), def27, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def24 = DefineGlobalClass("ScriptError", typeof(Ruby.Builtins.ScriptError), def27, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ScriptErrorOps.Factory), }); - Ruby.Builtins.RubyClass def22 = DefineGlobalClass("SignalException", typeof(Ruby.Builtins.SignalException), def26, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def24 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), def26, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def23 = DefineGlobalClass("SignalException", typeof(Ruby.Builtins.SignalException), def27, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def25 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), def27, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemExceptionOps.Factory), }); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def12 = DefineClass("Struct::Tms", typeof(Ruby.Builtins.RubyStructOps.Tms), def11, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def14 = DefineClass("Struct::Tms", typeof(Ruby.Builtins.RubyStructOps.Tms), def13, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyStructOps.Tms.CreateInstance), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyStructOps.Tms.CreateInstance), }); #endif - DefineGlobalClass("SystemExit", typeof(Ruby.Builtins.SystemExit), def26, new System.Action(LoadSystemExit_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SystemExit", typeof(Ruby.Builtins.SystemExit), def27, new System.Action(LoadSystemExit_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemExitOps.Factory), }); - DefineGlobalClass("SystemStackError", typeof(Ruby.Builtins.SystemStackError), def26, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SystemStackError", typeof(Ruby.Builtins.SystemStackError), def27, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemStackErrorOps.Factory), }); - DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), def24, new System.Action(LoadArgumentError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), def25, new System.Action(LoadArgumentError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArgumentErrorOps.Factory), }); - DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), def15, new System.Action(LoadBignum_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("Fixnum", typeof(System.Int32), def15, new System.Action(LoadFixnum_Instance), new System.Action(LoadFixnum_Class), Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), def16, new System.Action(LoadBignum_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("Fixnum", typeof(System.Int32), def16, new System.Action(LoadFixnum_Instance), new System.Action(LoadFixnum_Class), Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.IndexErrorOps.Factory), }); - DefineGlobalClass("Interrupt", typeof(Ruby.Builtins.Interrupt), def22, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def17 = DefineGlobalClass("IOError", typeof(System.IO.IOException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("Interrupt", typeof(Ruby.Builtins.Interrupt), def23, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def18 = DefineGlobalClass("IOError", typeof(System.IO.IOException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.IOErrorOps.Factory), }); - DefineGlobalClass("LoadError", typeof(Ruby.Builtins.LoadError), def23, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("LoadError", typeof(Ruby.Builtins.LoadError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.LoadErrorOps.Factory), }); - DefineGlobalClass("LocalJumpError", typeof(Ruby.Builtins.LocalJumpError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("LocalJumpError", typeof(Ruby.Builtins.LocalJumpError), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.LocalJumpErrorOps.Factory), }); - Ruby.Builtins.RubyClass def28 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def29 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NameErrorOps.Factory), }); - DefineGlobalClass("NotImplementedError", typeof(Ruby.Builtins.NotImplementedError), def23, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("NotImplementedError", typeof(Ruby.Builtins.NotImplementedError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NotImplementedErrorOps.Factory), }); - Ruby.Builtins.RubyClass def19 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), def24, new System.Action(LoadRangeError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def20 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), def25, new System.Action(LoadRangeError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RangeErrorOps.Factory), }); - DefineGlobalClass("RegexpError", typeof(Ruby.Builtins.RegexpError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("RegexpError", typeof(Ruby.Builtins.RegexpError), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpErrorOps.Factory), }); - DefineGlobalClass("RuntimeError", typeof(Ruby.Builtins.RuntimeError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("RuntimeError", typeof(Ruby.Builtins.RuntimeError), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SecurityErrorOps.Factory), }); - DefineGlobalClass("SyntaxError", typeof(Ruby.Builtins.SyntaxError), def23, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SyntaxError", typeof(Ruby.Builtins.SyntaxError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SyntaxErrorOps.Factory), }); - Ruby.Builtins.RubyClass def18 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def19 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemCallErrorOps.Factory), }); - DefineGlobalClass("ThreadError", typeof(Ruby.Builtins.ThreadError), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ThreadError", typeof(Ruby.Builtins.ThreadError), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.TypeErrorOps.Factory), }); - DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), def24, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), def25, null, null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ZeroDivisionErrorOps.Factory), }); - DefineGlobalClass("EOFError", typeof(Ruby.Builtins.EOFError), def17, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def4 = DefineClass("Errno::EACCES", typeof(Ruby.Builtins.Errno.AccessError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def5 = DefineClass("Errno::EBADF", typeof(Ruby.Builtins.Errno.BadFileDescriptorError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def6 = DefineClass("Errno::EDOM", typeof(Ruby.Builtins.Errno.DomainError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def7 = DefineClass("Errno::EEXIST", typeof(Ruby.Builtins.Errno.ExistError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def8 = DefineClass("Errno::EINVAL", typeof(Ruby.Builtins.Errno.InvalidError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def9 = DefineClass("Errno::ENOENT", typeof(Ruby.Builtins.Errno.NoEntryError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def10 = DefineClass("Errno::ENOTDIR", typeof(Ruby.Builtins.Errno.NotDirectoryError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("FloatDomainError", typeof(Ruby.Builtins.FloatDomainError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), def28, new System.Action(LoadNoMethodError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("EOFError", typeof(Ruby.Builtins.EOFError), def18, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def4 = DefineClass("Errno::EACCES", typeof(Ruby.Builtins.Errno.AccessError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def5 = DefineClass("Errno::EBADF", typeof(Ruby.Builtins.Errno.BadFileDescriptorError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def6 = DefineClass("Errno::EDOM", typeof(Ruby.Builtins.Errno.DomainError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def7 = DefineClass("Errno::EEXIST", typeof(Ruby.Builtins.Errno.ExistError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def8 = DefineClass("Errno::EINVAL", typeof(Ruby.Builtins.Errno.InvalidError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def9 = DefineClass("Errno::ENOENT", typeof(Ruby.Builtins.Errno.NoEntryError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def10 = DefineClass("Errno::ENOTDIR", typeof(Ruby.Builtins.Errno.NotDirectoryError), def19, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("FloatDomainError", typeof(Ruby.Builtins.FloatDomainError), def20, null, null, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), def29, new System.Action(LoadNoMethodError_Instance), null, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NoMethodErrorOps.Factory), }); + def11.SetConstant("Constants", def12); #if !SILVERLIGHT Context.ObjectClass.SetConstant("ARGF", def1); #endif @@ -219,10 +221,10 @@ Context.ObjectClass.SetConstant("ENV", def2); #endif #if !SILVERLIGHT - def13.SetConstant("Stat", def14); + def11.SetConstant("Stat", def15); #endif #if !SILVERLIGHT - def11.SetConstant("Tms", def12); + def13.SetConstant("Tms", def14); #endif def3.SetConstant("EACCES", def4); def3.SetConstant("EBADF", def5); @@ -1045,30 +1047,9 @@ private void LoadFile_Instance(Ruby.Builtins.RubyModule/*!*/ module) { module.SetConstant("ALT_SEPARATOR", Ruby.Builtins.RubyFileOps.ALT_SEPARATOR); - module.SetConstant("APPEND", Ruby.Builtins.RubyFileOps.APPEND); - module.SetConstant("BINARY", Ruby.Builtins.RubyFileOps.BINARY); - module.SetConstant("CREAT", Ruby.Builtins.RubyFileOps.CREAT); - module.SetConstant("EXCL", Ruby.Builtins.RubyFileOps.EXCL); - module.SetConstant("FNM_CASEFOLD", Ruby.Builtins.RubyFileOps.FNM_CASEFOLD); - module.SetConstant("FNM_DOTMATCH", Ruby.Builtins.RubyFileOps.FNM_DOTMATCH); - module.SetConstant("FNM_NOESCAPE", Ruby.Builtins.RubyFileOps.FNM_NOESCAPE); - module.SetConstant("FNM_PATHNAME", Ruby.Builtins.RubyFileOps.FNM_PATHNAME); - module.SetConstant("FNM_SYSCASE", Ruby.Builtins.RubyFileOps.FNM_SYSCASE); - module.SetConstant("LOCK_EX", Ruby.Builtins.RubyFileOps.LOCK_EX); - module.SetConstant("LOCK_NB", Ruby.Builtins.RubyFileOps.LOCK_NB); - module.SetConstant("LOCK_SH", Ruby.Builtins.RubyFileOps.LOCK_SH); - module.SetConstant("LOCK_UN", Ruby.Builtins.RubyFileOps.LOCK_UN); - module.SetConstant("NONBLOCK", Ruby.Builtins.RubyFileOps.NONBLOCK); module.SetConstant("PATH_SEPARATOR", Ruby.Builtins.RubyFileOps.PATH_SEPARATOR); - module.SetConstant("RDONLY", Ruby.Builtins.RubyFileOps.RDONLY); - module.SetConstant("RDWR", Ruby.Builtins.RubyFileOps.RDWR); - module.SetConstant("SEEK_CUR", Ruby.Builtins.RubyFileOps.SEEK_CUR); - module.SetConstant("SEEK_END", Ruby.Builtins.RubyFileOps.SEEK_END); - module.SetConstant("SEEK_SET", Ruby.Builtins.RubyFileOps.SEEK_SET); module.SetConstant("Separator", Ruby.Builtins.RubyFileOps.Separator); module.SetConstant("SEPARATOR", Ruby.Builtins.RubyFileOps.SEPARATOR); - module.SetConstant("TRUNC", Ruby.Builtins.RubyFileOps.TRUNC); - module.SetConstant("WRONLY", Ruby.Builtins.RubyFileOps.WRONLY); module.DefineLibraryMethod("atime", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.AccessTime), @@ -1098,30 +1079,9 @@ private void LoadFile_Class(Ruby.Builtins.RubyModule/*!*/ module) { module.SetConstant("ALT_SEPARATOR", Ruby.Builtins.RubyFileOps.ALT_SEPARATOR); - module.SetConstant("APPEND", Ruby.Builtins.RubyFileOps.APPEND); - module.SetConstant("BINARY", Ruby.Builtins.RubyFileOps.BINARY); - module.SetConstant("CREAT", Ruby.Builtins.RubyFileOps.CREAT); - module.SetConstant("EXCL", Ruby.Builtins.RubyFileOps.EXCL); - module.SetConstant("FNM_CASEFOLD", Ruby.Builtins.RubyFileOps.FNM_CASEFOLD); - module.SetConstant("FNM_DOTMATCH", Ruby.Builtins.RubyFileOps.FNM_DOTMATCH); - module.SetConstant("FNM_NOESCAPE", Ruby.Builtins.RubyFileOps.FNM_NOESCAPE); - module.SetConstant("FNM_PATHNAME", Ruby.Builtins.RubyFileOps.FNM_PATHNAME); - module.SetConstant("FNM_SYSCASE", Ruby.Builtins.RubyFileOps.FNM_SYSCASE); - module.SetConstant("LOCK_EX", Ruby.Builtins.RubyFileOps.LOCK_EX); - module.SetConstant("LOCK_NB", Ruby.Builtins.RubyFileOps.LOCK_NB); - module.SetConstant("LOCK_SH", Ruby.Builtins.RubyFileOps.LOCK_SH); - module.SetConstant("LOCK_UN", Ruby.Builtins.RubyFileOps.LOCK_UN); - module.SetConstant("NONBLOCK", Ruby.Builtins.RubyFileOps.NONBLOCK); module.SetConstant("PATH_SEPARATOR", Ruby.Builtins.RubyFileOps.PATH_SEPARATOR); - module.SetConstant("RDONLY", Ruby.Builtins.RubyFileOps.RDONLY); - module.SetConstant("RDWR", Ruby.Builtins.RubyFileOps.RDWR); - module.SetConstant("SEEK_CUR", Ruby.Builtins.RubyFileOps.SEEK_CUR); - module.SetConstant("SEEK_END", Ruby.Builtins.RubyFileOps.SEEK_END); - module.SetConstant("SEEK_SET", Ruby.Builtins.RubyFileOps.SEEK_SET); module.SetConstant("Separator", Ruby.Builtins.RubyFileOps.Separator); module.SetConstant("SEPARATOR", Ruby.Builtins.RubyFileOps.SEPARATOR); - module.SetConstant("TRUNC", Ruby.Builtins.RubyFileOps.TRUNC); - module.SetConstant("WRONLY", Ruby.Builtins.RubyFileOps.WRONLY); module.DefineLibraryMethod("atime", 0x31, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyFileOps.AccessTime), @@ -1327,6 +1287,31 @@ } + private void LoadFile__Constants_Instance(Ruby.Builtins.RubyModule/*!*/ module) { + module.SetConstant("APPEND", Ruby.Builtins.RubyFileOps.Constants.APPEND); + module.SetConstant("BINARY", Ruby.Builtins.RubyFileOps.Constants.BINARY); + module.SetConstant("CREAT", Ruby.Builtins.RubyFileOps.Constants.CREAT); + module.SetConstant("EXCL", Ruby.Builtins.RubyFileOps.Constants.EXCL); + module.SetConstant("FNM_CASEFOLD", Ruby.Builtins.RubyFileOps.Constants.FNM_CASEFOLD); + module.SetConstant("FNM_DOTMATCH", Ruby.Builtins.RubyFileOps.Constants.FNM_DOTMATCH); + module.SetConstant("FNM_NOESCAPE", Ruby.Builtins.RubyFileOps.Constants.FNM_NOESCAPE); + module.SetConstant("FNM_PATHNAME", Ruby.Builtins.RubyFileOps.Constants.FNM_PATHNAME); + module.SetConstant("FNM_SYSCASE", Ruby.Builtins.RubyFileOps.Constants.FNM_SYSCASE); + module.SetConstant("LOCK_EX", Ruby.Builtins.RubyFileOps.Constants.LOCK_EX); + module.SetConstant("LOCK_NB", Ruby.Builtins.RubyFileOps.Constants.LOCK_NB); + module.SetConstant("LOCK_SH", Ruby.Builtins.RubyFileOps.Constants.LOCK_SH); + module.SetConstant("LOCK_UN", Ruby.Builtins.RubyFileOps.Constants.LOCK_UN); + module.SetConstant("NONBLOCK", Ruby.Builtins.RubyFileOps.Constants.NONBLOCK); + module.SetConstant("RDONLY", Ruby.Builtins.RubyFileOps.Constants.RDONLY); + module.SetConstant("RDWR", Ruby.Builtins.RubyFileOps.Constants.RDWR); + module.SetConstant("SEEK_CUR", Ruby.Builtins.RubyFileOps.Constants.SEEK_CUR); + module.SetConstant("SEEK_END", Ruby.Builtins.RubyFileOps.Constants.SEEK_END); + module.SetConstant("SEEK_SET", Ruby.Builtins.RubyFileOps.Constants.SEEK_SET); + module.SetConstant("TRUNC", Ruby.Builtins.RubyFileOps.Constants.TRUNC); + module.SetConstant("WRONLY", Ruby.Builtins.RubyFileOps.Constants.WRONLY); + + } + #if !SILVERLIGHT private void LoadFile__Stat_Instance(Ruby.Builtins.RubyModule/*!*/ module) { @@ -2020,6 +2005,11 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.Eof), }); + module.DefineLibraryMethod("fcntl", 0x29, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.FileControl), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.FileControl), + }); + module.DefineLibraryMethod("fileno", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.FileNo), }); @@ -2175,6 +2165,12 @@ new Microsoft.Scripting.Utils.Function>(Ruby.Builtins.RubyIOOps.ReadLines), }); + module.DefineLibraryMethod("select", 0x31, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyIOOps.Select), + }); + } private void LoadKernel_Instance(Ruby.Builtins.RubyModule/*!*/ module) { @@ -2442,6 +2438,12 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.RespondTo), }); + module.DefineLibraryMethod("select", 0x2a, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + }); + module.DefineLibraryMethod("send", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.SendMessage), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.SendMessage), @@ -2636,6 +2638,12 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Require), }); + module.DefineLibraryMethod("select", 0x31, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Select), + }); + module.DefineLibraryMethod("sleep", 0x31, new System.Delegate[] { new System.Action(Ruby.Builtins.Kernel.Sleep), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Kernel.Sleep), @@ -3984,6 +3992,10 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.ToClrString), }); + module.DefineLibraryMethod("to_f", 0x29, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.ToDouble), + }); + module.DefineLibraryMethod("to_i", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.ToInteger), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.MutableStringOps.ToInteger), @@ -4681,14 +4693,26 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.IsAlive), }); + module.DefineLibraryMethod("exit", 0x29, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Kill), + }); + module.DefineLibraryMethod("group", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Group), }); + module.DefineLibraryMethod("inspect", 0x29, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Inspect), + }); + module.DefineLibraryMethod("join", 0x29, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Join), }); + module.DefineLibraryMethod("kill", 0x29, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Kill), + }); + } private void LoadThread_Class(Ruby.Builtins.RubyModule/*!*/ module) { @@ -4717,6 +4741,10 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Pass), }); + module.DefineLibraryMethod("start", 0x31, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.CreateThread), + }); + } private void LoadThreadGroup_Instance(Ruby.Builtins.RubyModule/*!*/ module) { =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;C445173 File: Dir.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;C445173 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;WEBrick @@ -439,7 +439,7 @@ return ArrayUtils.EmptyStrings; } - int matchFlags = flags | RubyFileOps.FNM_PATHNAME | RubyFileOps.FNM_CASEFOLD; + int matchFlags = flags | RubyFileOps.Constants.FNM_PATHNAME | RubyFileOps.Constants.FNM_CASEFOLD; List result = new List(); string[] files = Directory.GetFileSystemEntries(baseDirectory); foreach (string file in files) { @@ -451,7 +451,7 @@ result.Add(pathName); } } - if ((flags & RubyFileOps.FNM_DOTMATCH) != 0 || mPattern.GetChar(0) == '.') { + if ((flags & RubyFileOps.Constants.FNM_DOTMATCH) != 0 || mPattern.GetChar(0) == '.') { if (RubyFileOps.FnMatch(null, mPattern, MutableString.Create("."), matchFlags)) { result.Add("."); } @@ -467,7 +467,7 @@ if (pattern.Length == 0) { yield break; } - bool noEscape = ((flags & RubyFileOps.FNM_NOESCAPE) != 0); + bool noEscape = ((flags & RubyFileOps.Constants.FNM_NOESCAPE) != 0); string sPattern = pattern.ConvertToString(); string[] groups = UngroupGlobs(sPattern, noEscape); if (groups.Length == 0) { =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/FileOps.cs;C447029 File: FileOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/FileOps.cs;C447029 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/FileOps.cs;WEBrick @@ -359,14 +359,14 @@ return (path.Length == 0); } - bool pathName = ((flags & FNM_PATHNAME) != 0); - bool noEscape = ((flags & FNM_NOESCAPE) != 0); + bool pathName = ((flags & Constants.FNM_PATHNAME) != 0); + bool noEscape = ((flags & Constants.FNM_NOESCAPE) != 0); string sPath = path.ConvertToString(); string regexPattern = PatternToRegex(pattern.ConvertToString(), pathName, noEscape); if (regexPattern.Length == 0) { return false; } - if (((flags & FNM_DOTMATCH) == 0) && sPath[0] == '.') { + if (((flags & Constants.FNM_DOTMATCH) == 0) && sPath[0] == '.') { // Starting dot requires an explicit dot in the pattern if (regexPattern.Length < 4 || regexPattern[2] != '[' || regexPattern[3] != '.') { return false; @@ -374,7 +374,7 @@ } RegexOptions options = RegexOptions.None; - if ((flags & FNM_CASEFOLD) != 0) { + if ((flags & Constants.FNM_CASEFOLD) != 0) { options |= RegexOptions.IgnoreCase; } Match match = Regex.Match(sPath, regexPattern, options); @@ -770,48 +770,51 @@ [RubyConstant] public readonly static MutableString Separator = INTERNAL_SEPARATOR; - [RubyConstant] - public readonly static int APPEND = 0x08; - [RubyConstant] - public readonly static int BINARY = 0x8000; - [RubyConstant] - public readonly static int CREAT = 0x100; - [RubyConstant] - public readonly static int EXCL = 0x400; - [RubyConstant] - public readonly static int FNM_CASEFOLD = 0x08; - [RubyConstant] - public readonly static int FNM_DOTMATCH = 0x04; - [RubyConstant] - public readonly static int FNM_NOESCAPE = 0x01; - [RubyConstant] - public readonly static int FNM_PATHNAME = 0x02; - [RubyConstant] - public readonly static int FNM_SYSCASE = 0x08; - [RubyConstant] - public readonly static int LOCK_EX = 0x02; - [RubyConstant] - public readonly static int LOCK_NB = 0x04; - [RubyConstant] - public readonly static int LOCK_SH = 0x01; - [RubyConstant] - public readonly static int LOCK_UN = 0x08; - [RubyConstant] - public readonly static int NONBLOCK = 0x01; - [RubyConstant] - public readonly static int RDONLY = 0x00; - [RubyConstant] - public readonly static int RDWR = 0x02; - [RubyConstant] - public readonly static int SEEK_CUR = 0x01; - [RubyConstant] - public readonly static int SEEK_END = 0x02; - [RubyConstant] - public readonly static int SEEK_SET = 0x00; - [RubyConstant] - public readonly static int TRUNC = 0x200; - [RubyConstant] - public readonly static int WRONLY = 0x01; + [RubyModule("Constants")] + public static class Constants { + [RubyConstant] + public readonly static int APPEND = 0x08; + [RubyConstant] + public readonly static int BINARY = 0x8000; + [RubyConstant] + public readonly static int CREAT = 0x100; + [RubyConstant] + public readonly static int EXCL = 0x400; + [RubyConstant] + public readonly static int FNM_CASEFOLD = 0x08; + [RubyConstant] + public readonly static int FNM_DOTMATCH = 0x04; + [RubyConstant] + public readonly static int FNM_NOESCAPE = 0x01; + [RubyConstant] + public readonly static int FNM_PATHNAME = 0x02; + [RubyConstant] + public readonly static int FNM_SYSCASE = 0x08; + [RubyConstant] + public readonly static int LOCK_EX = 0x02; + [RubyConstant] + public readonly static int LOCK_NB = 0x04; + [RubyConstant] + public readonly static int LOCK_SH = 0x01; + [RubyConstant] + public readonly static int LOCK_UN = 0x08; + [RubyConstant] + public readonly static int NONBLOCK = 0x01; + [RubyConstant] + public readonly static int RDONLY = 0x00; + [RubyConstant] + public readonly static int RDWR = 0x02; + [RubyConstant] + public readonly static int SEEK_CUR = 0x01; + [RubyConstant] + public readonly static int SEEK_END = 0x02; + [RubyConstant] + public readonly static int SEEK_SET = 0x00; + [RubyConstant] + public readonly static int TRUNC = 0x200; + [RubyConstant] + public readonly static int WRONLY = 0x01; + } #endregion =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/IoOps.cs;C443395 File: IoOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/IoOps.cs;C443395 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/IoOps.cs;WEBrick @@ -24,13 +24,16 @@ using Microsoft.Scripting.Utils; using Microsoft.Scripting.Ast; using Microsoft.Scripting.Runtime; +using System.Runtime.InteropServices; +using System.Threading; +using System.Diagnostics; namespace Ruby.Builtins { /// /// Implementation of IO builtin class. /// - [RubyClass("IO", Extends = typeof(RubyIO))] + [RubyClass("IO", Extends = typeof(RubyIO)), Includes(typeof(RubyFileOps.Constants))] public class RubyIOOps { // Mixins: File::Constants,Enumerable,Object,Kernel @@ -189,7 +192,116 @@ } } - //select + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, [Optional]RubyArray write, [Optional]RubyArray error) { + return SelectInternal(context, read, write, error, new TimeSpan(0, 0, 0, 0, Timeout.Infinite)); + } + + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, RubyArray write, RubyArray error, int timeoutInSeconds) { + if (timeoutInSeconds < 0) { + throw RubyExceptions.CreateArgumentError("time interval must be positive"); + } + return SelectInternal(context, read, write, error, new TimeSpan(0, 0, timeoutInSeconds)); + } + + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, RubyArray write, RubyArray error, double timeoutInSeconds) { + if (timeoutInSeconds < 0) { + throw RubyExceptions.CreateArgumentError("time interval must be positive"); + } + return SelectInternal(context, read, write, error, TimeSpan.FromSeconds(timeoutInSeconds)); + } + + private static RubyArray SelectInternal(CodeContext/*!*/ context, RubyArray read, RubyArray write, RubyArray error, TimeSpan timeout) { + WaitHandle[] handles = null; + RubyArray result; + + if (read == null && write == null && error == null) { + Thread.Sleep(timeout); + return null; + } + + try { + handles = GetWaitHandles(context, read, write, error); + int index; + try { + index = WaitHandle.WaitAny(handles, timeout, false); + if (index == WaitHandle.WaitTimeout) { + return null; + } + } catch (Exception e) { + throw new Errno.InvalidError(e.Message, e); + } + + result = new RubyArray(); + int handleIndex = 0; + result.Add(MakeResult(handles, ref handleIndex, index, read)); + result.Add(MakeResult(handles, ref handleIndex, index, write)); + result.Add(MakeResult(handles, ref handleIndex, index, error)); + } finally { + // should we close the handles? + //if (handles != null) { + // for (int i = 0; i < handles.Length; i++) { + // if (handles[i] != null) { + // handles[i].Close(); + // } + // } + //} + } + return result; + } + + private static RubyArray/*!*/ MakeResult(WaitHandle/*!*/[]/*!*/ handles, ref int handleIndex, int signaling, RubyArray ioObjects) { + RubyArray result = new RubyArray(); + if (ioObjects != null) { + for (int i = 0; i < ioObjects.Count; i++) { + if (handleIndex == signaling || handles[handleIndex].WaitOne(0, false)) { + result.Add(ioObjects[i]); + } + handleIndex++; + } + } + return result; + } + + private static WaitHandle/*!*/[]/*!*/ GetWaitHandles(CodeContext/*!*/ context, RubyArray read, RubyArray write, RubyArray error) { + WaitHandle[] handles = new WaitHandle[ + (read != null ? read.Count : 0) + + (write != null ? write.Count : 0) + + (error != null ? error.Count : 0) + ]; + + int i = 0; + if (read != null) { + foreach (object obj in read) { + handles[i++] = ToIo(context, obj).CreateReadWaitHandle(); + } + } + + if (write != null) { + foreach (object obj in write) { + handles[i++] = ToIo(context, obj).CreateWriteWaitHandle(); + } + } + + if (error != null) { + foreach (object obj in error) { + handles[i++] = ToIo(context, obj).CreateErrorWaitHandle(); + } + } + + return handles; + } + + private static RubyIO/*!*/ ToIo(CodeContext/*!*/ context, object obj) { + RubyIO io = obj as RubyIO; + if (io == null) { + throw RubyExceptions.CreateTypeConversionError(RubyUtils.GetClassName(context, obj), "IO"); + } + return io; + } + //sysopen #endregion @@ -269,8 +381,17 @@ self.AssertOpenedForReading(); return self.IsEndOfStream(); } - //fcntl + [RubyMethod("fcntl")] + public static int FileControl(RubyIO/*!*/ self, int commandId, [Optional]MutableString arg) { + return self.FileControl(commandId, (arg != null) ? arg.ConvertToBytes() : null); + } + + [RubyMethod("fcntl")] + public static int FileControl(RubyIO/*!*/ self, int commandId, int arg) { + return self.FileControl(commandId, arg); + } + [RubyMethod("fileno")] [RubyMethod("to_i")] public static int FileNo(RubyIO/*!*/ self) { =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Kernel.cs;C448443 File: Kernel.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Kernel.cs;C448443 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Kernel.cs;WEBrick @@ -507,7 +507,25 @@ //readline //readlines //scan - //select + + [RubyMethod("select", RubyMethodAttributes.PrivateInstance)] + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, [Optional]RubyArray write, [Optional]RubyArray error) { + return RubyIOOps.Select(context, null, read, write, error); + } + + [RubyMethod("select", RubyMethodAttributes.PrivateInstance)] + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, [Optional]RubyArray write, [Optional]RubyArray error, int timeoutInSeconds) { + return RubyIOOps.Select(context, null, read, write, error, timeoutInSeconds); + } + + [RubyMethod("select", RubyMethodAttributes.PrivateInstance)] + [RubyMethod("select", RubyMethodAttributes.PublicSingleton)] + public static RubyArray Select(CodeContext/*!*/ context, object self, RubyArray read, [Optional]RubyArray write, [Optional]RubyArray error, double timeoutInSeconds) { + return RubyIOOps.Select(context, null, read, write, error, timeoutInSeconds); + } + //set_trace_func [RubyMethod("sleep", RubyMethodAttributes.PrivateInstance)] =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/MutableStringOps.cs;C447029 File: MutableStringOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/MutableStringOps.cs;C447029 (server) 5/24/2008 2:28 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/MutableStringOps.cs;WEBrick @@ -2802,6 +2802,11 @@ #endregion + [RubyMethod("to_f")] + public static double ToDouble(CodeContext/*!*/ context, MutableString/*!*/ self) { + return Tokenizer.ParseDouble(self.ConvertToString()); + } + [RubyMethod("to_s")] [RubyMethod("to_str")] public static MutableString/*!*/ ToS(CodeContext/*!*/ context, MutableString/*!*/ self) { =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C448258 File: ThreadOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C448258 (server) 5/24/2008 11:21 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;WEBrick @@ -146,15 +146,34 @@ // exit - [RubyMethod("group", RubyMethodAttributes.PublicInstance)] + [RubyMethod("group")] public static ThreadGroup Group(Thread/*!*/ self) { RubyThreadInfo info = RubyThreadInfo.FromThread(self); return info.Group; } - // inspect + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(CodeContext/*!*/ context, Thread/*!*/ self) { + MutableString result = MutableString.CreateMutable(); + result.Append("#<"); + result.Append(RubyUtils.GetClassName(context, self)); + result.Append(':'); + RubyUtils.AppendFormatHexObjectId(result, RubyUtils.GetObjectId(RubyUtils.GetExecutionContext(context), self)); + result.Append(' '); - [RubyMethod("join", RubyMethodAttributes.PublicInstance)] + if ((self.ThreadState & ThreadState.WaitSleepJoin) != 0) { + result.Append("sleep"); + } else if ((self.ThreadState & (ThreadState.Stopped | ThreadState.Aborted | ThreadState.AbortRequested)) != 0) { + result.Append("dead"); + } else { + result.Append("run"); + } + + result.Append('>'); + return result; + } + + [RubyMethod("join")] public static Thread/*!*/ Join(Thread/*!*/ self) { RubyThreadInfo.FromThread(Thread.CurrentThread); @@ -162,6 +181,13 @@ return self; } + [RubyMethod("kill")] + [RubyMethod("exit")] + public static Thread Kill(Thread/*!*/ self) { + self.Abort(); + return self; + } + // key? // keys // kill @@ -202,10 +228,7 @@ } // exclusive -// exit // fork -// kill - [RubyMethod("list", RubyMethodAttributes.PublicSingleton)] public static RubyArray/*!*/ List(object self) { RubyThreadInfo.FromThread(Thread.CurrentThread); @@ -225,6 +248,7 @@ // main [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] + [RubyMethod("start", RubyMethodAttributes.PublicSingleton)] public static Thread/*!*/ CreateThread(CodeContext/*!*/ context, object self, BlockParam startRoutine, [NotNull]params object[]/*!*/ args) { if (startRoutine == null) { throw new ThreadError("must be called with a block"); @@ -255,7 +279,6 @@ return null; } - // start // stop } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/BasicSocket.cs;C448258 File: BasicSocket.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/BasicSocket.cs;C448258 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/BasicSocket.cs;WEBrick @@ -6,6 +6,8 @@ using Microsoft.Scripting.Runtime; using Ruby.Builtins; using Ruby.Runtime; +using System.Threading; +using Ruby.StandardLibrary.FileControl; namespace Ruby.StandardLibrary.Sockets { [RubyClass("BasicSocket", BuildConfig = "!SILVERLIGHT")] @@ -14,15 +16,15 @@ private static readonly MutableString BROADCAST_IP_STRING = MutableString.Create("255.255.255.255"); private static readonly MutableString ANY_IP_STRING = MutableString.Create("0.0.0.0"); + private readonly Socket/*!*/ _socket; + + // TODO: cannot use static data! private static bool _doNotReverseLookup = false; public static bool DoNotReverseLookup { get { return _doNotReverseLookup; } - set { - _doNotReverseLookup = value; } + set { _doNotReverseLookup = value; } } - - private Socket/*!*/ _socket; - + /// /// Create a new RubyBasicSocket from a specified stream and mode /// @@ -31,10 +33,44 @@ _socket = socket; } - protected internal Socket Socket { - get { return this._socket; } + protected internal Socket/*!*/ Socket { + get { return _socket; } } + public override WaitHandle/*!*/ CreateReadWaitHandle() { + return _socket.BeginReceive(Utils.Array.EmptyBytes, 0, 0, SocketFlags.Peek, null, null).AsyncWaitHandle; + } + + public override WaitHandle/*!*/ CreateWriteWaitHandle() { + return _socket.BeginSend(Utils.Array.EmptyBytes, 0, 0, SocketFlags.Peek, null, null).AsyncWaitHandle; + } + + public override WaitHandle/*!*/ CreateErrorWaitHandle() { + // TODO: + throw new NotSupportedException(); + } + + // returns 0 on success, -1 on failure + private int SetFileControlFlags(int flags) { + // TODO: + _socket.Blocking = (flags & RubyFileOps.Constants.NONBLOCK) != 0; + return 0; + } + + public override int FileControl(int commandId, int arg) { + // TODO: + switch (commandId) { + case Fcntl.F_SETFL: + return SetFileControlFlags(arg); + } + throw new NotSupportedException(); + } + + public override int FileControl(int commandId, byte[] arg) { + // TODO: + throw new NotSupportedException(); + } + #region Public Singleton Methods /// /// Returns the value of the global reverse lookup flag. @@ -64,23 +100,28 @@ return (RubyBasicSocket)RubyUtils.GetExecutionContext(context).GetDescriptor((int)Protocols.CastToInteger(context, fileDescriptor)); } #endregion + #region Public Instance Methods + [RubyMethod("close_read")] public static void CloseRead(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self) { CheckSecurity(context, self, "can't close socket"); // TODO: It would be nice to alter the SocketStream to be WriteOnly here self.Socket.Shutdown(SocketShutdown.Receive); } + [RubyMethod("close_write")] public static void CloseWrite(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self) { CheckSecurity(context, self, "can't close socket"); // TODO: It would be nice to alter the SocketStream to be ReadOnly here self.Socket.Shutdown(SocketShutdown.Send); } + [RubyMethod("shutdown")] public static int Shutdown(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self) { return Shutdown(context, self, 2); } + [RubyMethod("shutdown")] public static int Shutdown(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object/*Numeric*/ how) { int iHow = 2; @@ -89,6 +130,7 @@ } return Shutdown(context, self, iHow); } + [RubyMethod("shutdown")] public static int Shutdown(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, int how) { CheckSecurity(context, self, "can't shutdown socket"); @@ -98,6 +140,7 @@ self.Socket.Shutdown((SocketShutdown)how); return 0; } + /// /// Sets a socket option. These are protocol and system specific, see your local sytem documentation for details. /// @@ -111,6 +154,7 @@ int iOptname = Protocols.CastToFixnum(context, optname); self.Socket.SetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, value); } + /// /// Sets a socket option. These are protocol and system specific, see your local sytem documentation for details. /// @@ -124,6 +168,7 @@ int iOptname = Protocols.CastToFixnum(context, optname); self.Socket.SetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, value); } + /// /// Sets a socket option. These are protocol and system specific, see your local sytem documentation for details. /// @@ -188,6 +233,7 @@ byte[] value = self.Socket.GetSocketOption((SocketOptionLevel)iLevel, (SocketOptionName)iOptname, 4); return MutableString.CreateBinary(value); } + [RubyMethod("getsockname")] public static MutableString GetSocketName(RubyBasicSocket/*!*/ self) { SocketAddress addr = self.Socket.LocalEndPoint.Serialize(); @@ -197,6 +243,7 @@ } return MutableString.CreateBinary(bytes); } + [RubyMethod("getpeername")] public static MutableString GetPeerName(RubyBasicSocket/*!*/ self) { SocketAddress addr = self.Socket.RemoteEndPoint.Serialize(); @@ -206,6 +253,7 @@ } return MutableString.CreateBinary(bytes); } + [RubyMethod("send")] public static int Send(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object message, object flags) { Protocols.CheckSafeLevel(context, 4, "send"); @@ -213,6 +261,7 @@ MutableString strMessage = Protocols.CastToString(context, message); return self.Socket.Send(strMessage.ConvertToBytes(), socketFlags); } + [RubyMethod("send")] public static int Send(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object message, object flags, object to) { Protocols.CheckSafeLevel(context, 4, "send"); @@ -234,17 +283,21 @@ public static MutableString/*!*/ Receive(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object length) { return Receive(context, self, length, null); } + [RubyMethod("recv")] public static MutableString Receive(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object length, object flags) { int iLength = Protocols.CastToFixnum(context, length); SocketFlags sFlags = ConvertToSocketFlag(context, flags); + byte[] buffer = new byte[iLength]; - int received = self.Socket.Receive(buffer, sFlags); - MutableString str = MutableString.CreateBinary(); + int received = self.Socket.Receive(buffer, 0, iLength, sFlags); + + MutableString str = MutableString.CreateBinary(received); str.Append(buffer, 0, received); RubyUtils.GetExecutionContext(context).TaintObject(str); return str; } + /// /// Receives up to length bytes from socket using recvfrom after O_NONBLOCK is set for the underlying file descriptor. /// @@ -254,6 +307,7 @@ public static MutableString/*!*/ ReceiveNonBlocking(CodeContext/*!*/ context, RubyBasicSocket/*!*/ self, object length) { return ReceiveNonBlocking(context, self, length, null); } + /// /// Receives up to length bytes from socket using recvfrom after O_NONBLOCK is set for the underlying file descriptor. /// @@ -280,9 +334,11 @@ self.Socket.Blocking = blocking; } } + #endregion #region Internal Helpers + internal static void CheckSecurity(CodeContext/*!*/ context, object self, string message) { RubyExecutionContext ec = RubyUtils.GetExecutionContext(context); if (ec.CurrentSafeLevel >= 4 && ec.IsObjectTainted(self)) { @@ -306,7 +362,7 @@ } internal static RubyArray/*!*/ GetAddressArray(EndPoint endPoint) { - RubyArray result = ArrayOps.CreateArray(4); + RubyArray result = new RubyArray(4); IPEndPoint ep = (IPEndPoint)endPoint; @@ -704,6 +760,7 @@ new ServiceName(10012, "tcp", "qmaster"), new ServiceName(10012, "udp", "qmaster") }); + #endregion } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/Socket.cs;C448258 File: Socket.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/Socket.cs;C448258 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/Socket.cs;WEBrick @@ -16,6 +16,7 @@ public class RubySocket : RubyBasicSocket { #region Construction + public RubySocket(CodeContext/*!*/ context, Socket/*!*/ socket) : base(context, socket) { } @@ -30,14 +31,23 @@ SocketType socketType = (SocketType)RubyUtils.GetConstant(context, rubySocketClass, type.ToSymbol(), true); return new Socket(addressFamily, socketType, protocolType); } + #endregion #region Public Singleton Methods + [RubyMethod("getaddrinfo", RubyMethodAttributes.PublicSingleton)] - public static RubyArray GetAddressInfo(CodeContext/*!*/ context, RubyClass/*!*/ klass, object hostname, object port, [Optional, DefaultParameterValue(null)]object family, [Optional, DefaultParameterValue(0)]object socktype, [Optional, DefaultParameterValue(0)]object protocol, [Optional, DefaultParameterValue(null)]object flags) { + public static RubyArray GetAddressInfo(CodeContext/*!*/ context, RubyClass/*!*/ klass, object hostname, object port, + [DefaultParameterValue(null)]object family, + [DefaultParameterValue(0)]object socktype, + [DefaultParameterValue(0)]object protocol, + [DefaultParameterValue(null)]object flags) { + MutableString strHostname = ConvertToHostString(context, hostname); int iPort = ConvertToPortNum(context, port); - // Sadly the family, socktype, protocol and flags get passed through at best and ignored at worst, since System.Net does not provide for them + + // Sadly the family, socktype, protocol and flags get passed through at best and ignored at worst, + // since System.Net does not provide for them AddressFamily addrFamily = ConvertToAddressFamily(context, family); int socketType = Protocols.CastToFixnum(context, socktype); int protocolType = Protocols.CastToFixnum(context, protocol); @@ -58,10 +68,10 @@ } result.Add(MutableString.Create(address.ToString())); result.Add((int)address.AddressFamily); - result.Add((int)socketType); + result.Add(socketType); // TODO: protocol type: - result.Add(IPPROTO_UDP); + result.Add(protocolType); results.Add(result); } @@ -70,8 +80,8 @@ // TODO: handle other invalid addresses private static IPHostEntry/*!*/ GetHostEntry(IPAddress/*!*/ address) { - if (address.Equals(IPAddress.Any)) { - return MakeAnyEntry(); + if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.Loopback)) { + return MakeEntry(address); } else { return Dns.GetHostEntry(address); } @@ -79,17 +89,19 @@ private static IPHostEntry/*!*/ GetHostEntry(string/*!*/ hostNameOrAddress) { if (hostNameOrAddress == IPAddress.Any.ToString()) { - return MakeAnyEntry(); + return MakeEntry(IPAddress.Any); + } else if (hostNameOrAddress == IPAddress.Loopback.ToString()) { + return MakeEntry(IPAddress.Loopback); } else { return Dns.GetHostEntry(hostNameOrAddress); } } - private static IPHostEntry/*!*/ MakeAnyEntry() { + private static IPHostEntry/*!*/ MakeEntry(IPAddress/*!*/ address) { IPHostEntry entry = new IPHostEntry(); - entry.AddressList = new IPAddress[] { IPAddress.Any }; - entry.Aliases = new string[] { IPAddress.Any.ToString() }; - entry.HostName = IPAddress.Any.ToString(); + entry.AddressList = new IPAddress[] { address }; + entry.Aliases = new string[] { address.ToString() }; + entry.HostName = address.ToString(); return entry; } @@ -242,9 +254,11 @@ IPEndPoint ep = new IPEndPoint(0, 0); return (IPEndPoint)ep.Create(addr); } + #endregion #region Public Instance Methods + [RubyMethod("accept")] public static RubyArray/*!*/ Accept(CodeContext/*!*/ context, RubySocket/*!*/ self) { RubyArray result = new RubyArray(2); @@ -293,7 +307,6 @@ } } - [RubyMethod("listen")] public static int Listen(CodeContext/*!*/ context, RubySocket/*!*/ self, int backlog) { self.Socket.Listen(backlog); @@ -304,6 +317,7 @@ public static RubyArray/*!*/ ReceiveFrom(CodeContext/*!*/ context, RubySocket/*!*/ self, int length) { return ReceiveFrom(context, self, length, null); } + [RubyMethod("recvfrom")] public static RubyArray/*!*/ ReceiveFrom(CodeContext/*!*/ context, RubySocket/*!*/ self, int length, object/*Numeric*/ flags) { SocketFlags sFlags = ConvertToSocketFlag(context, flags); @@ -328,6 +342,7 @@ result.Add(MutableString.Create(addr.ToString())); return result; } + #endregion #region Constants @@ -612,6 +627,7 @@ #endregion #region Private Helpers + private static int ParseInteger(CodeContext/*!*/ context, string/*!*/ str) { bool isNegative = false; if (str[0] == '-') { @@ -634,6 +650,7 @@ throw RubyExceptions.CreateTypeConversionError("String", "Integer"); } } + #endregion } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/TCPServer.cs;C443395 File: TCPServer.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/TCPServer.cs;C443395 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/TCPServer.cs;WEBrick @@ -9,13 +9,42 @@ using Microsoft.Scripting.Utils; using Ruby.Builtins; using Ruby.Runtime; +using System.Threading; +using System.Diagnostics; namespace Ruby.StandardLibrary.Sockets { [RubyClass("TCPServer", BuildConfig = "!SILVERLIGHT")] public class TCPServer : TCPSocket { - public TCPServer(CodeContext/*!*/ context, Socket/*!*/ socket) : base(context, socket) { + private object _mutex = new object(); + private IAsyncResult _acceptResult; + + public TCPServer(CodeContext/*!*/ context, Socket/*!*/ socket) + : base(context, socket) { } + public override WaitHandle/*!*/ CreateReadWaitHandle() { + return GetAcceptResult().AsyncWaitHandle; + } + + private IAsyncResult/*!*/ GetAcceptResult() { + if (_acceptResult == null) { + lock (_mutex) { + if (_acceptResult == null) { + _acceptResult = Socket.BeginAccept(null, null); + } + } + } + return _acceptResult; + } + + private Socket/*!*/ Accept() { + // acquire the result and replace it by null, so that no other thread can acquire it: + IAsyncResult result = Interlocked.Exchange(ref _acceptResult, null); + + // wait until accept finishes: + return Socket.EndAccept(result); + } + [RubyConstructor] public static TCPServer/*!*/ CreateTCPServer(CodeContext/*!*/ context, [Optional]object hostname, object port) { IPAddress listeningInterface = null; @@ -23,8 +52,11 @@ listeningInterface = new IPAddress(0); } else { string hostnameStr = Protocols.CastToString(context, hostname).ConvertToString(); - // try to parse it as an IP address first - if (!IPAddress.TryParse(hostnameStr, out listeningInterface)) { + if (hostnameStr == IPAddress.Any.ToString()) { + listeningInterface = IPAddress.Any; + } else if (hostnameStr == IPAddress.Loopback.ToString()) { + listeningInterface = IPAddress.Loopback; + } else if (!IPAddress.TryParse(hostnameStr, out listeningInterface)) { // look up the host IP from DNS IPHostEntry hostEntry = Dns.GetHostEntry(hostnameStr); @@ -46,12 +78,13 @@ Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Bind(new IPEndPoint(listeningInterface, ConvertToPortNum(context, port))); socket.Listen(10); + return new TCPServer(context, socket); } [RubyMethod("accept")] public static TCPSocket/*!*/ Accept(CodeContext/*!*/ context, TCPServer/*!*/ self) { - return new TCPSocket(context, self.Socket.Accept()); + return new TCPSocket(context, self.Accept()); } [RubyMethod("accept_nonblock")] =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Utils.cs;C440810 File: Utils.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Utils.cs;C440810 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Utils.cs;WEBrick @@ -22,6 +22,8 @@ namespace Ruby { public static class Utils { public static class Array { + public static readonly byte[] EmptyBytes = new byte[0]; + public static int IndexOf(/*this*/ string[]/*!*/ array, string/*!*/ value, StringComparer/*!*/ comparer) { ContractUtils.RequiresNotNull(array, "array"); ContractUtils.RequiresNotNull(value, "value"); =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/File.cs;C436237 File: File.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/File.cs;C436237 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/File.cs;WEBrick @@ -18,10 +18,11 @@ using System.Text; using Ruby.Runtime; using Microsoft.Scripting.Runtime; +using System.Threading; namespace Ruby.Builtins { public class RubyFile : RubyIO { - private string/*!*/ _path; + private readonly string/*!*/ _path; private static Stream OpenFileStream(RubyExecutionContext/*!*/ context, string/*!*/ path, string/*!*/ modeString) { // discard binary flag (if present) @@ -62,6 +63,8 @@ _path = path; } - public string Path { get { return _path; } } + public string/*!*/ Path { + get { return _path; } + } } } \ No newline at end of file =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/IO.cs;C447029 File: IO.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/IO.cs;C447029 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/IO.cs;WEBrick @@ -18,6 +18,7 @@ using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using Ruby.Runtime; +using System.Threading; namespace Ruby.Builtins { public enum IOMode { @@ -127,10 +128,21 @@ return IsConsoleDescriptor(_fileDescriptor); } - public bool Closed { get { return _closed; } set { _closed = value; } } - public int LineCount { get { return _lineCount; } set { _lineCount = value; } } - public bool PreserveEndOfLines { get { return _preserveEndOfLines; } set { _preserveEndOfLines = value; } } + public bool Closed { + get { return _closed; } + set { _closed = value; } + } + public int LineCount { + get { return _lineCount; } + set { _lineCount = value; } + } + + public bool PreserveEndOfLines { + get { return _preserveEndOfLines; } + set { _preserveEndOfLines = value; } + } + private void ParseIOMode(string/*!*/ modeString) { if (modeString.StartsWith("b")) { modeString = modeString.Substring(1); @@ -162,7 +174,8 @@ } // for derivation - protected RubyIO() { } + protected RubyIO() { + } public RubyIO(RubyExecutionContext/*!*/ context) { ContractUtils.RequiresNotNull(context, "context"); @@ -208,6 +221,33 @@ #region Instance methods + private static readonly byte[] EmptyBytes = new byte[0]; + + public virtual WaitHandle/*!*/ CreateReadWaitHandle() { + // TODO: + throw new NotSupportedException(); + } + + public virtual WaitHandle/*!*/ CreateWriteWaitHandle() { + // TODO: + throw new NotSupportedException(); + } + + public virtual WaitHandle/*!*/ CreateErrorWaitHandle() { + // TODO: + throw new NotSupportedException(); + } + + public virtual int FileControl(int commandId, int arg) { + // TODO: + throw new NotSupportedException(); + } + + public virtual int FileControl(int commandId, byte[] arg) { + // TODO: + throw new NotSupportedException(); + } + public void ResetIOMode(string/*!*/ modeString) { ParseIOMode(modeString); } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/MutableString.Content.cs;C448168 File: MutableString.Content.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/MutableString.Content.cs;C448168 (server) 5/24/2008 11:27 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/MutableString.Content.cs;WEBrick @@ -715,7 +715,9 @@ } public BinaryContent/*!*/ DataAppend(byte[]/*!*/ bytes, int start, int count) { - _data.AddRange(bytes); + for (int i = 0; i < count; i++) { + _data.Add(bytes[start + i]); + } return this; } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Parser/Tokenizer.cs;C444052 File: Tokenizer.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Parser/Tokenizer.cs;C444052 (server) 5/24/2008 2:36 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Parser/Tokenizer.cs;WEBrick @@ -3049,7 +3049,6 @@ c = nextc(); } } - private bool TryReadExponentSign(out int sign) { int s = peekc(); if (s == '-') { @@ -3205,21 +3204,24 @@ } } - private Tokens DecodeDouble(int first, int end) { + private static bool TryDecodeDouble(string/*!*/ str, int first, int end, out double result) { StringBuilder sb = new StringBuilder(end - first); sb.Length = end - first; int j = 0; for (int i = first; i < end; i++) { - if (_lineBuffer[i] != '_') { - sb[j++] = _lineBuffer[i]; + if (str[i] != '_') { + sb[j++] = str[i]; } } sb.Length = j; - + return Double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out result); + } + + private Tokens DecodeDouble(int first, int end) { double result; - if (!Double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out result)) { + if (!TryDecodeDouble(_lineBuffer, first, end, out result)) { result = Double.PositiveInfinity; } @@ -3325,6 +3327,71 @@ #endregion + private static int nextc(string/*!*/ str, ref int i) { + i++; + return (i < str.Length) ? str[i] : -1; + } + + // subsequent _ are not considered error + public static double ParseDouble(string/*!*/ str) { + double sign; + int i = -1; + + int c; + do { c = nextc(str, ref i); } while (IsWhiteSpace(c)); + + if (c == '-') { + c = nextc(str, ref i); + if (c == '_') return 0.0; + sign = -1; + } else if (c == '+') { + c = nextc(str, ref i); + if (c == '_') return 0.0; + sign = +1; + } else { + sign = +1; + } + + int start = i; + + while (c == '_' || IsDecimalDigit(c)) { + c = nextc(str, ref i); + } + + if (c == '.') { + c = nextc(str, ref i); + while (c == '_' || IsDecimalDigit(c)) { + c = nextc(str, ref i); + } + } + + // just before the current character: + int end = i; + + if (c == 'e' || c == 'E') { + c = nextc(str, ref i); + if (c == '+' || c == '-') { + c = nextc(str, ref i); + } + + int expEnd = end; + + while (true) { + if (IsDecimalDigit(c)) { + expEnd = i + 1; + } else if (c != '_') { + break; + } + c = nextc(str, ref i); + } + + end = expEnd; + } + + double result; + return TryDecodeDouble(str, start, end, out result) ? result * sign : 0.0; + } + #region Tokenizer Service public override bool SkipToken() { ===================================================================