edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializer.Generated.cs;C440810 File: Initializer.Generated.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializer.Generated.cs;C440810 (server) 5/16/2008 6:55 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializer.Generated.cs;RubyLibTweaks1 @@ -22,36 +22,37 @@ // Skipped primitive: __ClassSingleton // Skipped primitive: __MainSingleton - Ruby.Builtins.RubyModule def38 = DefineGlobalModule("Comparable", typeof(Ruby.Builtins.Comparable), new System.Action(LoadComparable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def11 = DefineGlobalModule("Digest", typeof(Ruby.StandardLibrary.Digest), null, new System.Action(LoadDigest_Class), Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def14 = DefineModule("Digest::Instance", typeof(Ruby.StandardLibrary.Digest.Instance), new System.Action(LoadDigest__Instance_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def28 = 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 def39 = DefineGlobalModule("Comparable", typeof(Ruby.Builtins.Comparable), new System.Action(LoadComparable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def13 = DefineGlobalModule("Digest", typeof(Ruby.StandardLibrary.Digest), null, new System.Action(LoadDigest_Class), Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def16 = DefineModule("Digest::Instance", typeof(Ruby.StandardLibrary.Digest.Instance), new System.Action(LoadDigest__Instance_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def2 = DefineGlobalModule("Enumerable", typeof(Ruby.Builtins.Enumerable), new System.Action(LoadEnumerable_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def5 = DefineGlobalModule("Errno", typeof(Ruby.Builtins.Errno), null, null, Ruby.Builtins.RubyModule.EmptyArray); + DefineGlobalModule("Fcntl", typeof(Ruby.Builtins.Fcntl), new System.Action(LoadFcntl_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.Math), new System.Action(LoadMath_Instance), new System.Action(LoadMath_Class), Ruby.Builtins.RubyModule.EmptyArray); DefineClass("Microsoft::Scripting::Actions::TypeTracker", typeof(Microsoft.Scripting.Actions.TypeTracker), typeof(Ruby.Runtime.TypeTrackerOps), new System.Action(LoadMicrosoft__Scripting__Actions__TypeTracker_Instance), null, classRef0, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyModule def16 = DefineGlobalModule("OpenSSL", typeof(Ruby.StandardLibrary.OpenSSL), null, null, Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def17 = DefineModule("OpenSSL::Digest", typeof(Ruby.StandardLibrary.OpenSSL.DigestFactory), null, null, Ruby.Builtins.RubyModule.EmptyArray); - Ruby.Builtins.RubyModule def35 = DefineGlobalModule("Precision", typeof(Ruby.Builtins.Precision), new System.Action(LoadPrecision_Instance), new System.Action(LoadPrecision_Class), Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def18 = DefineGlobalModule("OpenSSL", typeof(Ruby.StandardLibrary.OpenSSL), null, null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def19 = DefineModule("OpenSSL::Digest", typeof(Ruby.StandardLibrary.OpenSSL.DigestFactory), null, null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def36 = DefineGlobalModule("Precision", typeof(Ruby.Builtins.Precision), new System.Action(LoadPrecision_Instance), new System.Action(LoadPrecision_Class), Ruby.Builtins.RubyModule.EmptyArray); DefineClass("System::Type", typeof(System.Type), typeof(Ruby.Runtime.TypeOps), new System.Action(LoadSystem__Type_Instance), null, classRef2, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyModule def20 = DefineGlobalModule("Zlib", typeof(Ruby.StandardLibrary.Zlib), new System.Action(LoadZlib_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); + Ruby.Builtins.RubyModule def22 = DefineGlobalModule("Zlib", typeof(Ruby.StandardLibrary.Zlib), new System.Action(LoadZlib_Instance), null, Ruby.Builtins.RubyModule.EmptyArray); // Skipped primitive: __ClassSingletonSingleton #if !SILVERLIGHT - object def1 = DefineSingleton(new System.Action(Load__Singleton_ArgFilesSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def28, }); + object def1 = DefineSingleton(new System.Action(Load__Singleton_ArgFilesSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def2, }); #endif #if !SILVERLIGHT - object def2 = DefineSingleton(new System.Action(Load__Singleton_EnvironmentSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def28, }); + object def4 = DefineSingleton(new System.Action(Load__Singleton_EnvironmentSingletonOps_Instance), null, new Ruby.Builtins.RubyModule[] {def2, }); #endif // Skipped primitive: Object - Ruby.Builtins.RubyModule def33 = DefineModule("System::Collections::Generic::IDictionary", typeof(System.Collections.Generic.IDictionary), new System.Action(LoadSystem__Collections__Generic__IDictionary_Instance), null, new Ruby.Builtins.RubyModule[] {def28, }); - Ruby.Builtins.RubyModule def47 = DefineModule("System::Collections::IEnumerable", typeof(System.Collections.IEnumerable), new System.Action(LoadSystem__Collections__IEnumerable_Instance), null, new Ruby.Builtins.RubyModule[] {def28, }); - Ruby.Builtins.RubyModule def40 = DefineModule("System::Collections::IList", typeof(System.Collections.IList), new System.Action(LoadSystem__Collections__IList_Instance), null, new Ruby.Builtins.RubyModule[] {def28, }); - DefineModule("System::IComparable", typeof(System.IComparable), new System.Action(LoadSystem__IComparable_Instance), null, new Ruby.Builtins.RubyModule[] {def38, }); - DefineGlobalClass("Time", typeof(System.DateTime), typeof(Ruby.Builtins.TimeOps), new System.Action(LoadTime_Instance), new System.Action(LoadTime_Class), classRef1, new Ruby.Builtins.RubyModule[] {def38, }, new System.Delegate[] { + Ruby.Builtins.RubyModule def34 = DefineModule("System::Collections::Generic::IDictionary", typeof(System.Collections.Generic.IDictionary), new System.Action(LoadSystem__Collections__Generic__IDictionary_Instance), null, new Ruby.Builtins.RubyModule[] {def2, }); + DefineModule("System::Collections::IEnumerable", typeof(System.Collections.IEnumerable), new System.Action(LoadSystem__Collections__IEnumerable_Instance), null, new Ruby.Builtins.RubyModule[] {def2, }); + Ruby.Builtins.RubyModule def41 = DefineModule("System::Collections::IList", typeof(System.Collections.IList), new System.Action(LoadSystem__Collections__IList_Instance), null, new Ruby.Builtins.RubyModule[] {def2, }); + Ruby.Builtins.RubyModule def48 = DefineModule("System::IComparable", typeof(System.IComparable), new System.Action(LoadSystem__IComparable_Instance), null, new Ruby.Builtins.RubyModule[] {def39, }); + DefineGlobalClass("Time", typeof(System.DateTime), typeof(Ruby.Builtins.TimeOps), new System.Action(LoadTime_Instance), new System.Action(LoadTime_Class), classRef1, new Ruby.Builtins.RubyModule[] {def39, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.TimeOps.Create), }); - DefineGlobalClass("Array", typeof(Ruby.Builtins.RubyArray), typeof(Ruby.Builtins.ArrayOps), new System.Action(LoadArray_Instance), new System.Action(LoadArray_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, new System.Delegate[] { + DefineGlobalClass("Array", typeof(Ruby.Builtins.RubyArray), typeof(Ruby.Builtins.ArrayOps), new System.Action(LoadArray_Instance), new System.Action(LoadArray_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, 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), @@ -61,18 +62,23 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArrayOps.CreateArray), }); DefineGlobalClass("Binding", typeof(Ruby.Builtins.Binding), typeof(Ruby.Builtins.BindingOps), null, null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("ClrString", typeof(System.String), typeof(Ruby.Builtins.StringOps), new System.Action(LoadClrString_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def47, }, null); - Ruby.Builtins.RubyClass def13 = DefineClass("Digest::Class", typeof(Ruby.StandardLibrary.Digest.Class), null, null, new System.Action(LoadDigest__Class_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def14, }, null); - DefineGlobalClass("Dir", typeof(Ruby.Builtins.RubyDir), null, new System.Action(LoadDir_Instance), new System.Action(LoadDir_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, null); - Ruby.Builtins.RubyClass def39 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), typeof(Ruby.Builtins.ExceptionOps), new System.Action(LoadException_Instance), new System.Action(LoadException_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ClrString", typeof(System.String), typeof(Ruby.Builtins.StringOps), new System.Action(LoadClrString_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def48, }, null); + Ruby.Builtins.RubyClass def15 = DefineClass("Digest::Class", typeof(Ruby.StandardLibrary.Digest.Class), null, null, new System.Action(LoadDigest__Class_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def16, }, null); + DefineGlobalClass("Dir", typeof(Ruby.Builtins.RubyDir), null, new System.Action(LoadDir_Instance), new System.Action(LoadDir_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, null); + Ruby.Builtins.RubyClass def3 = DefineClass("Enumerable::Enumerator", typeof(Ruby.Builtins.Enumerable.Enumerator), null, null, null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Enumerable.Enumerator.CreateForEach), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Enumerable.Enumerator.Create), + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.Enumerable.Enumerator.Create), + }); + Ruby.Builtins.RubyClass def40 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), typeof(Ruby.Builtins.ExceptionOps), new System.Action(LoadException_Instance), new System.Action(LoadException_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ExceptionOps.Factory), }); Context.FalseClass = DefineGlobalClass("FalseClass", typeof(Ruby.Builtins.FalseClass), null, new System.Action(LoadFalseClass_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("Hash", typeof(Ruby.Builtins.Hash), typeof(Ruby.Builtins.HashOps), new System.Action(LoadHash_Instance), new System.Action(LoadHash_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, new System.Delegate[] { + DefineGlobalClass("Hash", typeof(Ruby.Builtins.Hash), typeof(Ruby.Builtins.HashOps), new System.Action(LoadHash_Instance), new System.Action(LoadHash_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.HashOps.Hash), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.HashOps.Hash), }); - Ruby.Builtins.RubyClass def41 = DefineGlobalClass("IO", typeof(Ruby.Builtins.RubyIO), typeof(Ruby.Builtins.RubyIOOps), new System.Action(LoadIO_Instance), new System.Action(LoadIO_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def42 = DefineGlobalClass("IO", typeof(Ruby.Builtins.RubyIO), typeof(Ruby.Builtins.RubyIOOps), new System.Action(LoadIO_Instance), new System.Action(LoadIO_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, 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), @@ -81,17 +87,17 @@ DefineGlobalClass("Method", typeof(Ruby.Builtins.RubyMethod), typeof(Ruby.Builtins.MethodOps), new System.Action(LoadMethod_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); // Skipped primitive: Module Context.NilClass = DefineGlobalClass("NilClass", typeof(Microsoft.Scripting.None), typeof(Ruby.Builtins.NilClassOps), new System.Action(LoadNilClass_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def34 = DefineGlobalClass("Numeric", typeof(Ruby.Builtins.Numeric), null, new System.Action(LoadNumeric_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def38, }, null); - Ruby.Builtins.RubyClass def18 = DefineClass("OpenSSL::Digest::Digest", typeof(Ruby.StandardLibrary.OpenSSL.DigestFactory.Digest), null, new System.Action(LoadOpenSSL__Digest__Digest_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def19 = DefineClass("OpenSSL::HMAC", typeof(Ruby.StandardLibrary.OpenSSL.HMAC), null, null, new System.Action(LoadOpenSSL__HMAC_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def35 = DefineGlobalClass("Numeric", typeof(Ruby.Builtins.Numeric), null, new System.Action(LoadNumeric_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def39, }, null); + Ruby.Builtins.RubyClass def20 = DefineClass("OpenSSL::Digest::Digest", typeof(Ruby.StandardLibrary.OpenSSL.DigestFactory.Digest), null, new System.Action(LoadOpenSSL__Digest__Digest_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def21 = DefineClass("OpenSSL::HMAC", typeof(Ruby.StandardLibrary.OpenSSL.HMAC), null, null, new System.Action(LoadOpenSSL__HMAC_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("Proc", typeof(Ruby.Builtins.Proc), typeof(Ruby.Builtins.ProcOps), new System.Action(LoadProc_Instance), null, Context.ObjectClass, 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), typeof(Ruby.Builtins.RangeOps), new System.Action(LoadRange_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, new System.Delegate[] { + DefineGlobalClass("Range", typeof(Ruby.Builtins.Range), typeof(Ruby.Builtins.RangeOps), new System.Action(LoadRange_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RangeOps.CreateRange), }); - DefineGlobalClass("Regexp", typeof(Ruby.Builtins.RubyRegex), typeof(Ruby.Builtins.RegexpOps), new System.Action(LoadRegexp_Instance), new System.Action(LoadRegexp_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, new System.Delegate[] { + DefineGlobalClass("Regexp", typeof(Ruby.Builtins.RubyRegex), typeof(Ruby.Builtins.RegexpOps), new System.Action(LoadRegexp_Instance), new System.Action(LoadRegexp_Class), Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, 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), @@ -100,173 +106,174 @@ new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpOps.Create), }); - DefineGlobalClass("String", typeof(Ruby.Builtins.MutableString), typeof(Ruby.Builtins.MutableStringOps), new System.Action(LoadString_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, def38, }, new System.Delegate[] { + DefineGlobalClass("String", typeof(Ruby.Builtins.MutableString), typeof(Ruby.Builtins.MutableStringOps), new System.Action(LoadString_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, def39, }, 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), }); DefineGlobalClass("StringScanner", typeof(Ruby.Builtins.StringScanner), null, new System.Action(LoadStringScanner_Instance), new System.Action(LoadStringScanner_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("Struct", typeof(Ruby.Builtins.RubyStruct), typeof(Ruby.Builtins.RubyStructOps), new System.Action(LoadStruct_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def28, }, new System.Delegate[] { + DefineGlobalClass("Struct", typeof(Ruby.Builtins.RubyStruct), typeof(Ruby.Builtins.RubyStructOps), new System.Action(LoadStruct_Instance), null, Context.ObjectClass, new Ruby.Builtins.RubyModule[] {def2, }, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RubyStructOps.CreateNamed), }); DefineGlobalClass("Symbol", typeof(Microsoft.Scripting.SymbolId), typeof(Ruby.Builtins.SymbolOps), new System.Action(LoadSymbol_Instance), new System.Action(LoadSymbol_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("Thread", typeof(System.Threading.Thread), typeof(Ruby.Builtins.ThreadOps), new System.Action(LoadThread_Instance), new System.Action(LoadThread_Class), Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); Context.TrueClass = DefineGlobalClass("TrueClass", typeof(Ruby.Builtins.TrueClass), null, new System.Action(LoadTrueClass_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); DefineGlobalClass("UnboundMethod", typeof(Ruby.Builtins.UnboundMethod), null, new System.Action(LoadUnboundMethod_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def22 = DefineClass("Zlib::GzipFile", typeof(Ruby.StandardLibrary.Zlib.GZipFile), null, null, null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def26 = DefineClass("Zlib::ZStream", typeof(Ruby.StandardLibrary.Zlib.ZStream), null, new System.Action(LoadZlib__ZStream_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def24 = DefineClass("Zlib::GzipFile", typeof(Ruby.StandardLibrary.Zlib.GZipFile), null, null, null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def28 = DefineClass("Zlib::ZStream", typeof(Ruby.StandardLibrary.Zlib.ZStream), null, new System.Action(LoadZlib__ZStream_Instance), null, Context.ObjectClass, Ruby.Builtins.RubyModule.EmptyArray, null); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def42 = DefineGlobalClass("BasicSocket", typeof(Ruby.StandardLibrary.RubyBasicSocket), null, new System.Action(LoadBasicSocket_Instance), new System.Action(LoadBasicSocket_Class), def41, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def43 = DefineGlobalClass("BasicSocket", typeof(Ruby.StandardLibrary.RubyBasicSocket), null, new System.Action(LoadBasicSocket_Instance), new System.Action(LoadBasicSocket_Class), def42, Ruby.Builtins.RubyModule.EmptyArray, null); #endif // Skipped primitive: Class - Ruby.Builtins.RubyClass def12 = DefineClass("Digest::Base", typeof(Ruby.StandardLibrary.Digest.Base), null, new System.Action(LoadDigest__Base_Instance), null, def13, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("File", typeof(Ruby.Builtins.RubyFile), typeof(Ruby.Builtins.RubyFileOps), new System.Action(LoadFile_Instance), new System.Action(LoadFile_Class), def41, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def14 = DefineClass("Digest::Base", typeof(Ruby.StandardLibrary.Digest.Base), null, new System.Action(LoadDigest__Base_Instance), null, def15, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("File", typeof(Ruby.Builtins.RubyFile), typeof(Ruby.Builtins.RubyFileOps), new System.Action(LoadFile_Instance), new System.Action(LoadFile_Class), def42, 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), typeof(Ruby.Builtins.FloatOps), new System.Action(LoadFloat_Instance), new System.Action(LoadFloat_Class), def34, new Ruby.Builtins.RubyModule[] {def35, }, null); - Ruby.Builtins.RubyClass def27 = DefineGlobalClass("Integer", typeof(Ruby.Builtins.Integer), null, new System.Action(LoadInteger_Instance), new System.Action(LoadInteger_Class), def34, new Ruby.Builtins.RubyModule[] {def35, }, null); - DefineGlobalClass("NoMemoryError", typeof(Ruby.Builtins.NoMemoryError), null, null, null, def39, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def36 = DefineGlobalClass("ScriptError", typeof(Ruby.Builtins.ScriptError), typeof(Ruby.Builtins.ScriptErrorOps), null, null, def39, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("Float", typeof(System.Double), typeof(Ruby.Builtins.FloatOps), new System.Action(LoadFloat_Instance), new System.Action(LoadFloat_Class), def35, new Ruby.Builtins.RubyModule[] {def36, }, null); + Ruby.Builtins.RubyClass def29 = DefineGlobalClass("Integer", typeof(Ruby.Builtins.Integer), null, new System.Action(LoadInteger_Instance), new System.Action(LoadInteger_Class), def35, new Ruby.Builtins.RubyModule[] {def36, }, null); + DefineGlobalClass("NoMemoryError", typeof(Ruby.Builtins.NoMemoryError), null, null, null, def40, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def37 = DefineGlobalClass("ScriptError", typeof(Ruby.Builtins.ScriptError), typeof(Ruby.Builtins.ScriptErrorOps), null, null, def40, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ScriptErrorOps.Factory), }); - Ruby.Builtins.RubyClass def37 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), typeof(Ruby.Builtins.SystemExceptionOps), null, null, def39, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def38 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), typeof(Ruby.Builtins.SystemExceptionOps), null, null, def40, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemExceptionOps.Factory), }); - DefineGlobalClass("StringIO", typeof(Ruby.Builtins.StringIO), null, new System.Action(LoadStringIO_Instance), new System.Action(LoadStringIO_Class), def41, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("StringIO", typeof(Ruby.Builtins.StringIO), null, new System.Action(LoadStringIO_Instance), new System.Action(LoadStringIO_Class), def42, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.StringIO.CreateIO), }); - DefineGlobalClass("SystemExit", typeof(Ruby.Builtins.SystemExit), typeof(Ruby.Builtins.SystemExitOps), new System.Action(LoadSystemExit_Instance), null, def39, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SystemExit", typeof(Ruby.Builtins.SystemExit), typeof(Ruby.Builtins.SystemExitOps), new System.Action(LoadSystemExit_Instance), null, def40, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemExitOps.Factory), }); - DefineGlobalClass("SystemStackError", typeof(Ruby.Builtins.SystemStackError), typeof(Ruby.Builtins.SystemStackErrorOps), null, null, def39, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SystemStackError", typeof(Ruby.Builtins.SystemStackError), typeof(Ruby.Builtins.SystemStackErrorOps), null, null, def40, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemStackErrorOps.Factory), }); - Ruby.Builtins.RubyClass def24 = DefineClass("Zlib::GzipReader", typeof(Ruby.StandardLibrary.Zlib.GZipReader), null, new System.Action(LoadZlib__GzipReader_Instance), new System.Action(LoadZlib__GzipReader_Class), def22, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def26 = DefineClass("Zlib::GzipReader", typeof(Ruby.StandardLibrary.Zlib.GZipReader), null, new System.Action(LoadZlib__GzipReader_Instance), new System.Action(LoadZlib__GzipReader_Class), def24, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.Zlib.GZipReader.Initialize), }); - Ruby.Builtins.RubyClass def25 = DefineClass("Zlib::Inflate", typeof(Ruby.StandardLibrary.Zlib.Inflate), null, new System.Action(LoadZlib__Inflate_Instance), new System.Action(LoadZlib__Inflate_Class), def26, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def27 = DefineClass("Zlib::Inflate", typeof(Ruby.StandardLibrary.Zlib.Inflate), null, new System.Action(LoadZlib__Inflate_Instance), new System.Action(LoadZlib__Inflate_Class), def28, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.Zlib.Inflate.Initialize), new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.Zlib.Inflate.Initialize), }); - DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), typeof(Ruby.Builtins.ArgumentErrorOps), new System.Action(LoadArgumentError_Instance), null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), typeof(Ruby.Builtins.ArgumentErrorOps), new System.Action(LoadArgumentError_Instance), null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ArgumentErrorOps.Factory), }); - DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), typeof(Ruby.Builtins.BignumOps), new System.Action(LoadBignum_Instance), null, def27, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), typeof(Ruby.Builtins.BignumOps), new System.Action(LoadBignum_Instance), null, def29, Ruby.Builtins.RubyModule.EmptyArray, null); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def15 = DefineClass("Digest::MD5", typeof(Ruby.StandardLibrary.Digest.MD5), null, null, null, def12, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def17 = DefineClass("Digest::MD5", typeof(Ruby.StandardLibrary.Digest.MD5), null, null, null, def14, Ruby.Builtins.RubyModule.EmptyArray, null); #endif - DefineGlobalClass("Fixnum", typeof(System.Int32), typeof(Ruby.Builtins.FixnumOps), new System.Action(LoadFixnum_Instance), new System.Action(LoadFixnum_Class), def27, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), typeof(Ruby.Builtins.IndexErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("Fixnum", typeof(System.Int32), typeof(Ruby.Builtins.FixnumOps), new System.Action(LoadFixnum_Instance), new System.Action(LoadFixnum_Class), def29, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), typeof(Ruby.Builtins.IndexErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.IndexErrorOps.Factory), }); - Ruby.Builtins.RubyClass def30 = DefineGlobalClass("IOError", typeof(System.IO.IOException), typeof(Ruby.Builtins.IOErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def31 = DefineGlobalClass("IOError", typeof(System.IO.IOException), typeof(Ruby.Builtins.IOErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.IOErrorOps.Factory), }); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def44 = DefineGlobalClass("IPSocket", typeof(Ruby.StandardLibrary.IPSocket), null, new System.Action(LoadIPSocket_Instance), new System.Action(LoadIPSocket_Class), def42, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def45 = DefineGlobalClass("IPSocket", typeof(Ruby.StandardLibrary.IPSocket), null, new System.Action(LoadIPSocket_Instance), new System.Action(LoadIPSocket_Class), def43, Ruby.Builtins.RubyModule.EmptyArray, null); #endif - DefineGlobalClass("LoadError", typeof(Ruby.Builtins.LoadError), typeof(Ruby.Builtins.LoadErrorOps), null, null, def36, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("LoadError", typeof(Ruby.Builtins.LoadError), typeof(Ruby.Builtins.LoadErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.LoadErrorOps.Factory), }); - DefineGlobalClass("LocalJumpError", typeof(Ruby.Builtins.LocalJumpError), typeof(Ruby.Builtins.LocalJumpErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("LocalJumpError", typeof(Ruby.Builtins.LocalJumpError), typeof(Ruby.Builtins.LocalJumpErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.LocalJumpErrorOps.Factory), }); - Ruby.Builtins.RubyClass def46 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), typeof(Ruby.Builtins.NameErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def47 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), typeof(Ruby.Builtins.NameErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NameErrorOps.Factory), }); - DefineGlobalClass("NotImplementedError", typeof(Ruby.Builtins.NotImplementedError), typeof(Ruby.Builtins.NotImplementedErrorOps), null, null, def36, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("NotImplementedError", typeof(Ruby.Builtins.NotImplementedError), typeof(Ruby.Builtins.NotImplementedErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NotImplementedErrorOps.Factory), }); - Ruby.Builtins.RubyClass def32 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), typeof(Ruby.Builtins.RangeErrorOps), new System.Action(LoadRangeError_Instance), null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def33 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), typeof(Ruby.Builtins.RangeErrorOps), new System.Action(LoadRangeError_Instance), null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RangeErrorOps.Factory), }); - DefineGlobalClass("RegexpError", typeof(Ruby.Builtins.RegexpError), typeof(Ruby.Builtins.RegexpErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("RegexpError", typeof(Ruby.Builtins.RegexpError), typeof(Ruby.Builtins.RegexpErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.RegexpErrorOps.Factory), }); - Ruby.Builtins.RubyClass def45 = DefineGlobalClass("RuntimeError", typeof(Ruby.Builtins.RuntimeError), null, null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), typeof(Ruby.Builtins.SecurityErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def46 = DefineGlobalClass("RuntimeError", typeof(Ruby.Builtins.RuntimeError), null, null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), typeof(Ruby.Builtins.SecurityErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SecurityErrorOps.Factory), }); #if !SILVERLIGHT - DefineGlobalClass("Socket", typeof(Ruby.StandardLibrary.RubySocket), null, new System.Action(LoadSocket_Instance), new System.Action(LoadSocket_Class), def42, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("Socket", typeof(Ruby.StandardLibrary.RubySocket), null, new System.Action(LoadSocket_Instance), new System.Action(LoadSocket_Class), def43, Ruby.Builtins.RubyModule.EmptyArray, null); #endif #if !SILVERLIGHT - DefineGlobalClass("SocketError", typeof(System.Net.Sockets.SocketException), typeof(Ruby.StandardLibrary.SocketErrorOps), new System.Action(LoadSocketError_Instance), null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SocketError", typeof(System.Net.Sockets.SocketException), typeof(Ruby.StandardLibrary.SocketErrorOps), new System.Action(LoadSocketError_Instance), null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.SocketErrorOps.Factory), }); #endif - DefineGlobalClass("SyntaxError", typeof(Ruby.Builtins.SyntaxError), typeof(Ruby.Builtins.SyntaxErrorOps), null, null, def36, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("SyntaxError", typeof(Ruby.Builtins.SyntaxError), typeof(Ruby.Builtins.SyntaxErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SyntaxErrorOps.Factory), }); - Ruby.Builtins.RubyClass def31 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), typeof(Ruby.Builtins.SystemCallErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def32 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), typeof(Ruby.Builtins.SystemCallErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.SystemCallErrorOps.Factory), }); - DefineGlobalClass("ThreadError", typeof(Ruby.Builtins.ThreadError), null, null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), typeof(Ruby.Builtins.TypeErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ThreadError", typeof(Ruby.Builtins.ThreadError), null, null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), typeof(Ruby.Builtins.TypeErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.TypeErrorOps.Factory), }); - DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), typeof(Ruby.Builtins.ZeroDivisionErrorOps), null, null, def37, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), typeof(Ruby.Builtins.ZeroDivisionErrorOps), null, null, def38, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ZeroDivisionErrorOps.Factory), }); - DefineGlobalClass("EOFError", typeof(Ruby.Builtins.EOFError), null, null, null, def30, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def4 = DefineClass("Errno::EACCES", typeof(Ruby.Builtins.Errno.AccessError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def5 = DefineClass("Errno::EBADF", typeof(Ruby.Builtins.Errno.BadFileDescriptorError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def6 = DefineClass("Errno::EDOM", typeof(Ruby.Builtins.Errno.DomainError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def7 = DefineClass("Errno::EEXIST", typeof(Ruby.Builtins.Errno.ExistError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def8 = DefineClass("Errno::EINVAL", typeof(Ruby.Builtins.Errno.InvalidError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def9 = DefineClass("Errno::ENOENT", typeof(Ruby.Builtins.Errno.NoEntryError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def10 = DefineClass("Errno::ENOTDIR", typeof(Ruby.Builtins.Errno.NotDirectoryError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("FloatDomainError", typeof(Ruby.Builtins.FloatDomainError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); - DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), typeof(Ruby.Builtins.NoMethodErrorOps), new System.Action(LoadNoMethodError_Instance), null, def46, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("EOFError", typeof(Ruby.Builtins.EOFError), null, null, null, def31, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def6 = DefineClass("Errno::EACCES", typeof(Ruby.Builtins.Errno.AccessError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def7 = DefineClass("Errno::EBADF", typeof(Ruby.Builtins.Errno.BadFileDescriptorError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def8 = DefineClass("Errno::EDOM", typeof(Ruby.Builtins.Errno.DomainError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def9 = DefineClass("Errno::EEXIST", typeof(Ruby.Builtins.Errno.ExistError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def10 = DefineClass("Errno::EINVAL", typeof(Ruby.Builtins.Errno.InvalidError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def11 = DefineClass("Errno::ENOENT", typeof(Ruby.Builtins.Errno.NoEntryError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def12 = DefineClass("Errno::ENOTDIR", typeof(Ruby.Builtins.Errno.NotDirectoryError), null, null, null, def32, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("FloatDomainError", typeof(Ruby.Builtins.FloatDomainError), null, null, null, def33, Ruby.Builtins.RubyModule.EmptyArray, null); + DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), typeof(Ruby.Builtins.NoMethodErrorOps), new System.Action(LoadNoMethodError_Instance), null, def47, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.NoMethodErrorOps.Factory), }); #if !SILVERLIGHT - Ruby.Builtins.RubyClass def43 = DefineGlobalClass("TCPSocket", typeof(Ruby.StandardLibrary.TCPSocket), null, null, new System.Action(LoadTCPSocket_Class), def44, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + Ruby.Builtins.RubyClass def44 = DefineGlobalClass("TCPSocket", typeof(Ruby.StandardLibrary.TCPSocket), null, null, new System.Action(LoadTCPSocket_Class), def45, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.TCPSocket.CreateTCPSocket), }); #endif #if !SILVERLIGHT - DefineGlobalClass("UDPSocket", typeof(Ruby.StandardLibrary.UDPSocket), null, new System.Action(LoadUDPSocket_Instance), null, def44, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("UDPSocket", typeof(Ruby.StandardLibrary.UDPSocket), null, new System.Action(LoadUDPSocket_Instance), null, def45, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.UDPSocket.CreateUDPSocket), new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.UDPSocket.CreateUDPSocket), }); #endif - Ruby.Builtins.RubyClass def21 = DefineClass("Zlib::DataError", typeof(Ruby.StandardLibrary.Zlib.DataError), null, null, null, def45, Ruby.Builtins.RubyModule.EmptyArray, null); - Ruby.Builtins.RubyClass def23 = DefineClass("Zlib::GzipFile::Error", typeof(Ruby.StandardLibrary.Zlib.GZipFile.Error), null, null, null, def45, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def23 = DefineClass("Zlib::DataError", typeof(Ruby.StandardLibrary.Zlib.DataError), null, null, null, def46, Ruby.Builtins.RubyModule.EmptyArray, null); + Ruby.Builtins.RubyClass def25 = DefineClass("Zlib::GzipFile::Error", typeof(Ruby.StandardLibrary.Zlib.GZipFile.Error), null, null, null, def46, Ruby.Builtins.RubyModule.EmptyArray, null); #if !SILVERLIGHT - DefineGlobalClass("TCPServer", typeof(Ruby.StandardLibrary.TCPServer), null, new System.Action(LoadTCPServer_Instance), null, def43, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { + DefineGlobalClass("TCPServer", typeof(Ruby.StandardLibrary.TCPServer), null, new System.Action(LoadTCPServer_Instance), null, def44, Ruby.Builtins.RubyModule.EmptyArray, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.StandardLibrary.TCPServer.CreateTCPServer), }); #endif - def11.SetConstant("Instance", def14); - def16.SetConstant("Digest", def17); + def13.SetConstant("Instance", def16); + def18.SetConstant("Digest", def19); #if !SILVERLIGHT Context.ObjectClass.SetConstant("ARGF", def1); #endif #if !SILVERLIGHT - Context.ObjectClass.SetConstant("ENV", def2); + Context.ObjectClass.SetConstant("ENV", def4); #endif - def11.SetConstant("Class", def13); - def17.SetConstant("Digest", def18); - def16.SetConstant("HMAC", def19); - def20.SetConstant("GzipFile", def22); - def20.SetConstant("ZStream", def26); - def11.SetConstant("Base", def12); - def20.SetConstant("GzipReader", def24); - def20.SetConstant("Inflate", def25); + def13.SetConstant("Class", def15); + def2.SetConstant("Enumerator", def3); + def19.SetConstant("Digest", def20); + def18.SetConstant("HMAC", def21); + def22.SetConstant("GzipFile", def24); + def22.SetConstant("ZStream", def28); + def13.SetConstant("Base", def14); + def22.SetConstant("GzipReader", def26); + def22.SetConstant("Inflate", def27); #if !SILVERLIGHT - def11.SetConstant("MD5", def15); + def13.SetConstant("MD5", def17); #endif - def3.SetConstant("EACCES", def4); - def3.SetConstant("EBADF", def5); - def3.SetConstant("EDOM", def6); - def3.SetConstant("EEXIST", def7); - def3.SetConstant("EINVAL", def8); - def3.SetConstant("ENOENT", def9); - def3.SetConstant("ENOTDIR", def10); - def20.SetConstant("DataError", def21); - def22.SetConstant("Error", def23); + def5.SetConstant("EACCES", def6); + def5.SetConstant("EBADF", def7); + def5.SetConstant("EDOM", def8); + def5.SetConstant("EEXIST", def9); + def5.SetConstant("EINVAL", def10); + def5.SetConstant("ENOENT", def11); + def5.SetConstant("ENOTDIR", def12); + def22.SetConstant("DataError", def23); + def24.SetConstant("Error", def25); } private void Load__ClassSingleton_Instance(Ruby.Builtins.RubyModule/*!*/ module) { @@ -1057,6 +1064,20 @@ } + private void LoadFcntl_Instance(Ruby.Builtins.RubyModule/*!*/ module) { + module.SetConstant("F_SETFL", Ruby.Builtins.Fcntl.F_SETFL); + module.SetConstant("O_ACCMODE", Ruby.Builtins.Fcntl.O_ACCMODE); + module.SetConstant("O_APPEND", Ruby.Builtins.Fcntl.O_APPEND); + module.SetConstant("O_CREAT", Ruby.Builtins.Fcntl.O_CREAT); + module.SetConstant("O_EXCL", Ruby.Builtins.Fcntl.O_EXCL); + module.SetConstant("O_NONBLOCK", Ruby.Builtins.Fcntl.O_NONBLOCK); + module.SetConstant("O_RDONLY", Ruby.Builtins.Fcntl.O_RDONLY); + module.SetConstant("O_RDWR", Ruby.Builtins.Fcntl.O_RDWR); + module.SetConstant("O_TRUNC", Ruby.Builtins.Fcntl.O_TRUNC); + module.SetConstant("O_WRONLY", Ruby.Builtins.Fcntl.O_WRONLY); + + } + private void LoadFile_Instance(Ruby.Builtins.RubyModule/*!*/ module) { module.SetConstant("ALT_SEPARATOR", Ruby.Builtins.RubyFileOps.ALT_SEPARATOR); module.SetConstant("APPEND", Ruby.Builtins.RubyFileOps.APPEND); @@ -4735,6 +4756,10 @@ private void LoadThread_Class(Ruby.Builtins.RubyModule/*!*/ module) { + module.DefineMethod("current", 0x11, new System.Delegate[] { + new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.Current), + }); + module.DefineMethod("new", 0x11, new System.Delegate[] { new Microsoft.Scripting.Utils.Function(Ruby.Builtins.ThreadOps.CreateThread), }); =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj;C440068 File: IronRuby.Libraries.csproj =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj;C440068 (server) 5/9/2008 9:35 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj;RubyLibTweaks1 @@ -86,6 +86,7 @@ + =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj.vspscc;C390406 edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;C438696 File: Dir.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;C438696 (server) 5/7/2008 3:32 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs;RubyLibTweaks1 @@ -14,9 +14,11 @@ * ***************************************************************************/ using System; +using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Runtime.InteropServices; +using System.Text; using Microsoft.Scripting.Actions; using Microsoft.Scripting.Runtime; @@ -174,32 +176,313 @@ return MutableString.Create(NormalizePathSeparators(Directory.GetCurrentDirectory())); } - // TODO: ruby specific pattern matching... - // TODO: (example of above) deal with forward slash vs. back slash in path names. Ruby glob does not recognize backslashes + #region glob + + private class GlobUngrouper { + internal abstract class GlobNode { + internal GlobNode parent; + protected GlobNode(GlobNode parentNode) { + parent = parentNode; + } + abstract internal GlobNode AddChar(char c); + abstract internal GlobNode StartLevel(); + abstract internal GlobNode AddGroup(); + abstract internal GlobNode FinishLevel(); + abstract internal List Flatten(); + } + + internal class TextNode : GlobNode { + StringBuilder builder; + + internal TextNode(GlobNode parentNode) + : base(parentNode) { + builder = new StringBuilder(); + } + internal override GlobNode AddChar(char c) { + if (c != 0) + builder.Append(c); + return this; + } + internal override GlobNode StartLevel() { + return parent.StartLevel(); + } + internal override GlobNode AddGroup() { + return parent.AddGroup(); + } + internal override GlobNode FinishLevel() { + return parent.FinishLevel(); + } + internal override List Flatten() { + List result = new List(1); + result.Add(builder); + return result; + } + } + + internal class ChoiceNode : GlobNode { + List nodes; + + internal ChoiceNode(GlobNode parentNode) + : base(parentNode) { + nodes = new List(); + } + internal override GlobNode AddChar(char c) { + SequenceNode node = new SequenceNode(this); + nodes.Add(node); + return node.AddChar(c); + } + internal override GlobNode StartLevel() { + SequenceNode node = new SequenceNode(this); + nodes.Add(node); + return node.StartLevel(); + } + internal override GlobNode AddGroup() { + AddChar((char)0); + return this; + } + internal override GlobNode FinishLevel() { + AddChar((char)0); + return parent; + } + internal override List Flatten() { + List result = new List(); + foreach (GlobNode node in nodes) { + foreach (StringBuilder builder in node.Flatten()) { + result.Add(builder); + } + } + return result; + } + } + + internal class SequenceNode : GlobNode { + List nodes; + + internal SequenceNode(GlobNode parentNode) + : base(parentNode) { + nodes = new List(); + } + internal override GlobNode AddChar(char c) { + TextNode node = new TextNode(this); + nodes.Add(node); + return node.AddChar(c); + } + internal override GlobNode StartLevel() { + ChoiceNode node = new ChoiceNode(this); + nodes.Add(node); + return node; + } + internal override GlobNode AddGroup() { + return parent; + } + internal override GlobNode FinishLevel() { + return parent.parent; // FinishLevel(); + } + internal override List Flatten() { + List result = new List(); + result.Add(new StringBuilder()); + foreach (GlobNode node in nodes) { + List tmp = new List(); + foreach (StringBuilder builder in node.Flatten()) { + foreach (StringBuilder sb in result) { + StringBuilder newsb = new StringBuilder(sb.ToString()); + newsb.Append(builder.ToString()); + tmp.Add(newsb); + } + } + result = tmp; + } + return result; + } + } + + SequenceNode rootNode; + GlobNode currentNode; + int level; + + internal GlobUngrouper(int patternLength) { + rootNode = new SequenceNode(null); + currentNode = rootNode; + level = 0; + } + + internal void AddChar(char c) { + currentNode = currentNode.AddChar(c); + } + + internal void StartLevel() { + currentNode = currentNode.StartLevel(); + level++; + } + + internal void AddGroup() { + currentNode = currentNode.AddGroup(); + } + + internal void FinishLevel() { + currentNode = currentNode.FinishLevel(); + level--; + } + internal int Level { + get { return level; } + } + internal string[] Flatten() { + if (level != 0) + return new string[0]; + List list = rootNode.Flatten(); + string[] result = new string[list.Count]; + for (int i = 0; i < list.Count; i++) + result[i] = list[i].ToString(); + return result; + } + } + + private static string[] UngroupGlobs(string/*!*/ pattern, bool noEscape) { + if (pattern.IndexOf('{') < 0) { + if (pattern.IndexOf('}') < 0) + return new string[1] { pattern }; + else + return new string[0]; + } + + GlobUngrouper ungrouper = new GlobUngrouper(pattern.Length); + + bool inEscape = false; + foreach (char c in pattern) { + if (c == '\\' && !inEscape && !noEscape) { + inEscape = true; + continue; + } + if (inEscape) { + if (c != ',' && c != '{' && c != '{') + ungrouper.AddChar('\\'); + ungrouper.AddChar(c); + inEscape = false; + continue; + } + switch (c) { + case '{': + ungrouper.StartLevel(); + break; + + case ',': + if (ungrouper.Level < 1) + ungrouper.AddChar(c); + else + ungrouper.AddGroup(); + break; + + case '}': + if (ungrouper.Level < 1) { + // Unbalanced closing bracket matches nothing + return new string[0]; + } + ungrouper.FinishLevel(); + break; + + default: + ungrouper.AddChar(c); + break; + } + } + return ungrouper.Flatten(); + } + + public static int FixedPathIndex(string path) { + int lastSlash = 0; + bool inEscape = false; + for (int i = 0; i < path.Length; i++) { + if (inEscape) { + inEscape = false; + continue; + } + if (path[i] == '\\') { + inEscape = true; + continue; + } else if (path[i] == '*' || path[i] == '?' || path[i] == '[') { + return lastSlash; + } else if (path[i] == '/') { + lastSlash = i; + } + } + return -1; + } + + public static IList DoGlob(string pattern, int flags) { + int pos = FixedPathIndex(pattern); + if (pos < 0) { + if (File.Exists(pattern) || Directory.Exists(pattern)) { + return new string[1] { pattern }; + } else { + return new string[0]; + } + } + + string baseDirectory; + MutableString mPattern; + if (pos == 0) { + baseDirectory = "."; + mPattern = MutableString.Create(pattern); + } else { + baseDirectory = pattern.Substring(0, pos); + mPattern = MutableString.Create(pattern.Substring(pos + 1)); + } + + List result = new List(); + string[] files = Directory.GetFileSystemEntries(baseDirectory); + foreach (string file in files) { + String pathName; + if (pos == 0) { + pathName = file.Substring(2); + } else { + pathName = file.Replace('\\', '/'); + } + if (RubyFileOps.FnMatch(null, mPattern, MutableString.Create(pathName), flags & RubyFileOps.FNM_PATHNAME)) { + result.Add(pathName); + } + } + return result; + } + + private static IEnumerable GlobResults(MutableString/*!*/ pattern, int flags) { + if (pattern.Length == 0) { + yield break; + } + bool noEscape = ((flags & RubyFileOps.FNM_NOESCAPE) != 0); + string sPattern = pattern.ConvertToString(); + string[] groups = UngroupGlobs(sPattern, noEscape); + if (groups.Length == 0) { + yield break; + } + + foreach (string group in groups) { + foreach (string filename in DoGlob(sPattern, flags)) { + if ((flags & RubyFileOps.FNM_DOTMATCH) != 0 || filename[0] != '.') { + yield return MutableString.Create(filename); + } + } + } + } + [RubyMethod("glob", RubyMethodAttributes.PublicSingleton)] public static void Glob(CodeContext/*!*/ context, object self, BlockParam block, [NotNull]MutableString/*!*/ pattern, [Optional]int flags) { - - foreach (string entry in Directory.GetFileSystemEntries(Directory.GetCurrentDirectory(), pattern.ConvertToString())) { - if (block.BlockJumped(_GlobSite.Invoke(context, block, MutableString.Create(Path.GetFileName(entry))))) return; + foreach (MutableString fileName in GlobResults(pattern, flags)) { + if (block.BlockJumped(_GlobSite.Invoke(context, block, fileName))) return; } } [RubyMethod("glob", RubyMethodAttributes.PublicSingleton)] [RubyMethod("[]", RubyMethodAttributes.PublicSingleton)] public static RubyArray/*!*/ Glob(object self, [NotNull]MutableString/*!*/ pattern, [Optional]int flags) { - // HACK: get pattern based on current dir + directory of pattern - string patternString = pattern.ConvertToString(); - string relativePatternDir = Path.GetDirectoryName(patternString); - string patternDir = Path.Combine(Directory.GetCurrentDirectory(), relativePatternDir); - string patternFilename = Path.GetFileName(pattern.ConvertToString()); - string[] rawEntries = Directory.GetFileSystemEntries(patternDir, patternFilename); - RubyArray ret = new RubyArray(rawEntries.Length); - foreach (string entry in rawEntries) { - ret.Add(MutableString.Create(Path.Combine(relativePatternDir, Path.GetFileName(entry)))); + RubyArray ret = new RubyArray(); + foreach (MutableString fileName in GlobResults(pattern, flags)) { + ret.Add(fileName); } return ret; } + #endregion + [RubyMethod("mkdir", RubyMethodAttributes.PublicSingleton)] public static int MakeDirectory(object self, [NotNull]MutableString/*!*/ dirname, [Optional]object permissions) { string strDir = dirname.ConvertToString(); @@ -373,4 +656,4 @@ } #endregion } -} \ No newline at end of file +} =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Enumerable.cs;C440810 File: Enumerable.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Enumerable.cs;C440810 (server) 5/15/2008 11:18 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Enumerable.cs;RubyLibTweaks1 @@ -17,7 +17,9 @@ using System.Collections.Generic; using System.Reflection; using System.Runtime.InteropServices; +using Microsoft.Scripting; using Microsoft.Scripting.Actions; +using Microsoft.Scripting.Ast; using Microsoft.Scripting.Runtime; using Ruby.Runtime; @@ -49,9 +51,17 @@ private static DynamicSite/*!*/ _EachWithIndexSite = CallSiteFactory.CreateSimpleCallSite(RubyContext.RubyBinder); - - #endregion + #endregion + + private static object Each(CodeContext/*!*/ context, object self, Proc/*!*/ block) { + if (self is Enumerator) { + return ((Enumerator)self).Each(context, block); + } else { + return RubySites.Each(context, self, block); + } + } + #region Public Instance Methods #region all?, any? @@ -68,7 +78,7 @@ private static bool TrueForItems(CodeContext/*!*/ context, object self, BlockParam predicate, bool expected) { bool result = expected; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (predicate != null) { item = _AllAnySite.Invoke(context, predicate, item); if (predicate.BlockJumped(result)) return item; @@ -93,7 +103,7 @@ [RubyMethod("map")] public static RubyArray Map(CodeContext/*!*/ context, object self, BlockParam collector) { RubyArray result = new RubyArray(); - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (collector != null) { item = _CollectMapSite.Invoke(context, collector, item); if (collector.BlockJumped(item)) return item; @@ -113,12 +123,12 @@ public static object Find(CodeContext/*!*/ context, object self, BlockParam predicate, [Optional]object ifNone) { object result = Missing.Value; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (predicate == null) throw new LocalJumpError("no block given"); object blockResult = _DetectFindSite.Invoke(context, predicate, item); if (predicate.BlockJumped(blockResult)) return blockResult; - + if (Protocols.IsTrue(blockResult)) { result = item; return RuntimeFlowControl.BlockBreak(selfBlock, result); @@ -147,7 +157,7 @@ int index = 0; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { object blockResult = _EachWithIndexSite.Invoke(context, block, item, index); if (block.BlockJumped(blockResult)) return blockResult; index += 1; @@ -166,7 +176,7 @@ public static RubyArray/*!*/ ToArray(CodeContext/*!*/ context, object self) { RubyArray data = new RubyArray(); - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { data.Add(item); return null; })); @@ -192,7 +202,7 @@ private static RubyArray/*!*/ Filter(CodeContext/*!*/ context, object self, BlockParam predicate, bool acceptingValue) { RubyArray result = new RubyArray(); - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (predicate == null) throw new LocalJumpError("no block given"); object blockResult = _SelectRejectSite.Invoke(context, predicate, item); @@ -216,7 +226,7 @@ public static RubyArray Grep(CodeContext/*!*/ context, object self, BlockParam action, object pattern) { RubyArray result = new RubyArray(); - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (RubySites.CaseEqual(context, pattern, item)) { if (action != null) { item = _GrepSite.Invoke(context, action, item); @@ -239,10 +249,10 @@ public static bool Contains(CodeContext/*!*/ context, object self, object value) { bool result = false; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (Protocols.IsEqual(context, item, value)) { result = true; - return RuntimeFlowControl.BlockBreak(selfBlock, result); + return RuntimeFlowControl.BlockBreak(selfBlock, result); } return null; })); @@ -258,7 +268,7 @@ public static object Inject(CodeContext/*!*/ context, object self, BlockParam operation, [Optional]object initial) { object result = initial; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (result == Missing.Value) { result = item; return null; @@ -292,7 +302,7 @@ bool firstItem = true; object result = null; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { // Check for first element if (firstItem) { result = item; @@ -331,7 +341,7 @@ RubyArray trueSet = new RubyArray(); RubyArray falseSet = new RubyArray(); - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (predicate == null) throw new LocalJumpError("no block given"); object result = _PartitionSite.Invoke(context, predicate, item); @@ -366,12 +376,12 @@ List> keyValuePairs = new List>(); // Collect the key, value pairs - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { if (keySelector == null) throw new LocalJumpError("no block given"); object key = _SortBySite.Invoke(context, keySelector, item); if (keySelector.BlockJumped(key)) return key; - + keyValuePairs.Add(new KeyValuePair(key, item)); return null; })); @@ -405,7 +415,7 @@ } int index = 0; - RubySites.Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { + Each(context, self, Proc.Create(context, delegate(BlockParam/*!*/ selfBlock, object item) { // Collect items RubyArray array = new RubyArray(otherArrays.Length + 1); array.Add(item); @@ -434,5 +444,74 @@ #endregion #endregion + + [RubyClass("Enumerator"), Includes(typeof(Enumerable))] + public abstract class Enumerator { + + private static readonly Dictionary> _siteCache = + new Dictionary>(); + private readonly object/*!*/ _obj; + + protected Enumerator(object/*!*/ obj) { + _obj = obj; + } + + protected DynamicSite GetSite(SymbolId name) { + DynamicSite result; + lock (_siteCache) { + if (!_siteCache.TryGetValue(name, out result)) { + result = DynamicSite.Create(RubySites.InstanceCallAction(name, ArgumentKind.Block)); + _siteCache[name] = result; + } + } + return result; + } + + internal abstract DynamicSite GetSite(); + + internal object Each(CodeContext/*!*/ context, Proc/*!*/ block) { + return GetSite().Invoke(context, _obj, block); + } + + [RubyConstructor] + public static Enumerator CreateForEach(CodeContext/*!*/ context, object/*!*/ obj) { + return new EnumeratorWithSymbolName(context, obj, SymbolTable.StringToId("each")); + } + + [RubyConstructor] + public static Enumerator Create(CodeContext/*!*/ context, object/*!*/ obj, SymbolId enumerator) { + return new EnumeratorWithSymbolName(context, obj, enumerator); + } + + [RubyConstructor] + public static Enumerator Create(CodeContext/*!*/ context, object/*!*/ obj, [NotNull]MutableString/*!*/ enumerator) { + return new EnumeratorWithStringName(context, obj, enumerator); + } + } + + internal class EnumeratorWithStringName : Enumerator { + private readonly MutableString/*!*/ _name; + + internal override DynamicSite GetSite() { + return GetSite(_name.ToSymbol()); + } + + internal EnumeratorWithStringName(CodeContext/*!*/ context, object/*!*/ obj, MutableString/*!*/ name) + : base(obj) { + _name = name; + } + } + internal class EnumeratorWithSymbolName : Enumerator { + private readonly SymbolId _name; + + internal override DynamicSite GetSite() { + return GetSite(_name); + } + + internal EnumeratorWithSymbolName(CodeContext/*!*/ context, object/*!*/ obj, SymbolId name) + : base(obj) { + _name = name; + } + } } -} \ No newline at end of file +} =================================================================== add: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Fcntl.cs File: Fcntl.cs =================================================================== --- [no source file] +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Fcntl.cs;RubyLibTweaks1 @@ -1,0 +1,50 @@ +?/* **************************************************************************** + * + * Copyright (c) Microsoft Corporation. + * + * This source code is subject to terms and conditions of the Microsoft Public License. A + * copy of the license can be found in the License.html file at the root of this distribution. If + * you cannot locate the Microsoft Public License, please send an email to + * ironruby@microsoft.com. By using this source code in any fashion, you are agreeing to be bound + * by the terms of the Microsoft Public License. + * + * You must not remove this notice, or any other, from this software. + * + * + * ***************************************************************************/ + +namespace Ruby.Builtins { + [RubyModule("Fcntl")] + public class Fcntl { + + [RubyConstant] + public const int F_SETFL = 0x01; + + [RubyConstant] + public const int O_CREAT = 0x0100; + + [RubyConstant] + public const int O_EXCL = 0x0400; + + [RubyConstant] + public const int O_TRUNC = 0x0200; + + [RubyConstant] + public const int O_APPEND = 0x0008; + + [RubyConstant] + public const int O_NONBLOCK = 0x01; + + [RubyConstant] + public const int O_RDONLY = 0x0000; + + [RubyConstant] + public const int O_RDWR = 0x0002; + + [RubyConstant] + public const int O_WRONLY = 0x0001; + + [RubyConstant] + public const int O_ACCMODE = O_RDONLY | O_WRONLY | O_RDWR; + } +} =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C415805 File: ThreadOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C415805 (server) 5/15/2008 9:58 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;RubyLibTweaks1 @@ -64,7 +64,12 @@ // abort_on_exception= // critical // critical= -// current + + [RubyMethod("current", RubyMethodAttributes.PublicSingleton)] + public static Thread/*!*/ Current(object self) { + return Thread.CurrentThread; + } + // exclusive // exit // fork =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;C440810 File: Loader.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;C440810 (server) 5/15/2008 9:38 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;RubyLibTweaks1 @@ -93,6 +93,20 @@ _unfinishedFiles = new Stack(); } + static string[] preloaded_modules = new string[] { + "enumerator", + "enumerator.so", + "fcntl", + "fcntl.so", + "socket", + "socket.so", + "stringio", + "stringio.so", + "strscan", + "strscan.so", + "thread.so" + }; + /// /// Returns true if a Ruby file is successfully loaded, false if it is already loaded. /// @@ -102,6 +116,9 @@ string assemblyName, typeName; string strPath = path.ConvertToString(); + if (Array.IndexOf(preloaded_modules, strPath) >= 0) { + return false; + } if (TryParseAssemblyName(strPath, out typeName, out assemblyName)) { ===================================================================