Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/io/shared/tty_probe.rb Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/kernel/fixtures/comspec.cmd Merlin/Main/Languages/Ruby/1 Merlin/Main/Languages/Ruby/Experimental/Interop/win32api.rb Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Win32API/Win32API.cs Merlin/Main/Languages/Ruby/Libs/Win32API.rb @@ -1,8 +1,8 @@ @echo off -if "%1" == "4" ( - set DIR=%MERLIN_ROOT%\Bin\Debug -) else ( +if "%1" == "-4" ( set DIR=%MERLIN_ROOT%\Bin\V4 Debug +) else ( + set DIR=%MERLIN_ROOT%\Bin\Debug ) "%DIR%\ClassInitGenerator" "%DIR%\IronRuby.Libraries.Yaml.dll" /libraries:IronRuby.StandardLibrary.Yaml /out:%~dp0\Initializer.Generated.cs Merlin/External.LCA_RESTRICTED/Languages/IronRuby/Yaml/IronRuby.Libraries.Yaml/GenerateInitializers.cmd @@ -87,19 +87,18 @@ class Object when :install_name bin = Config::CONFIG["RUBY_INSTALL_NAME"] || Config::CONFIG["ruby_install_name"] bin << (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '') - File.join(Config::CONFIG['bindir'], bin) + File.join(File.expand_path(Config::CONFIG['bindir']), bin) end end def resolve_ruby_exe [:env, :engine, :name, :install_name].each do |option| next unless cmd = ruby_exe_options(option) - exe = cmd.split.first # It has been reported that File.executable is not reliable # on Windows platforms (see commit 56bc555c). So, we check the # platform. - if File.exists?(exe) and (SpecGuard.windows? or File.executable?(exe)) + if File.exists?(cmd) and (SpecGuard.windows? or File.executable?(cmd)) return cmd end end @@ -111,7 +110,7 @@ class Object working_dir = opts[:dir] || "." Dir.chdir(working_dir) do body = "-e #{code.inspect}" if code and not File.exists?(code) - cmd = [RUBY_EXE, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]] + cmd = [RUBY_EXE.inspect, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]] `#{cmd.compact.join(' ')}` end end Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/mspec/lib/mspec/helpers/ruby_exe.rb @@ -13,6 +13,26 @@ describe :io_tty, :shared => true do File.open('NUL') {|f| f.send @method }.should == true end end + + it "return false when called on a standard stream redirected to a file or a pipe" do + sin, sout, serr = 1, 2, 4 + + # standard output is redirected by %x{} + %x{"#{RUBY_EXE}" "#{File.dirname(__FILE__)}/tty_probe.rb"} + $?.exitstatus.should == sin | serr + + # redirect error output to std output: + %x{"#{RUBY_EXE}" "#{File.dirname(__FILE__)}/tty_probe.rb" 2>&1} + $?.exitstatus.should == sin + + # redirect input: + %x{"#{RUBY_EXE}" "#{File.dirname(__FILE__)}/tty_probe.rb" < "#{File.dirname(__FILE__)}/tty_probe.rb"} + $?.exitstatus.should == serr + + # redirect both input and error output: + %x{"#{RUBY_EXE}" "#{File.dirname(__FILE__)}/tty_probe.rb" 2>1 < "#{File.dirname(__FILE__)}/tty_probe.rb"} + $?.exitstatus.should == 0 + end end it "returns false if this stream is not a terminal device (TTY)" do Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/io/shared/tty.rb @@ -50,7 +50,81 @@ describe "Kernel#`" do $?.exitstatus.should == 99 $?.success?.should == false end - end + + def test_comspec(commands) + comspec_mock = File.dirname(__FILE__) + '/fixtures/comspec.cmd' + + query = "ENV['COMSPEC'] = '#{comspec_mock}'; puts " + query += commands.collect { |cmd| "`#{cmd}`" }.join(', ') + + result = ruby_exe(query) + + # The comspec mock prints all its command arguments and we check if it gets exactly two: /c "COMMAND". + i = 0 + result.each_line do |line| + line.strip.should == %Q{/c "#{commands[i]}"} + i += 1 + end + end + + it "special cases Windows shell commands" do + test_comspec [ + "ASSOC", + "BREAK", + "CALL", + "CD", + "CHDIR", + "CLS", + "COLOR", + "COPY", + "DATE", + "DEL", + "DIR", + "ECHO", + "ENDLOCAL", + "ERASE", + "EXIT", + "FOR", + "FTYPE", + "GOTO", + "IF", + "MD", + "MKDIR", + "MOVE", + "PATH", + "PAUSE", + "POPD", + "PROMPT", + "PUSHD", + "RD", + "REM", + "REN", + "RENAME", + "RMDIR", + "SET", + "SETLOCAL", + "SHIFT", + "START", + "TIME", + "TITLE", + "TYPE", + "VER", + "VERIFY", + "VOL", + ] + end + + ruby_bug "", "1.9" do + ruby_bug "", "1.8" do + it "special cases Windows Vista+ shell commands" do + test_comspec [ + "MKLINK", + ] + end + end + end + end + end describe "Kernel.`" do Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/kernel/backtick_spec.rb @@ -62,10 +62,11 @@ describe "Kernel#system" do Kernel.should have_private_instance_method(:system) end - - it "expands shell variables when given a single string argument" do - result = system("ruby #{@helper_script} #{@shell_var} foo") - result.should be_true + ruby_version_is "1.9" do + it "expands shell variables when given a single string argument" do + result = system("ruby #{@helper_script} #{@shell_var} foo") + result.should be_true + end end it "does not expand shell variables when given multiples arguments" do Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/kernel/system_spec.rb @@ -1,16 +1,18 @@ require File.dirname(__FILE__) + '/../../spec_helper' describe "Process.uid" do - it "returns the correct uid for the user executing this process" do - current_uid_according_to_unix = `id -ur`.to_i - Process.uid.should == current_uid_according_to_unix - end - - it "also goes by Process::UID.rid" do - Process::UID.rid.should == Process.uid - end + platform_is_not :windows do + it "returns the correct uid for the user executing this process" do + current_uid_according_to_unix = `id -ur`.to_i + Process.uid.should == current_uid_according_to_unix + end + + it "also goes by Process::UID.rid" do + Process::UID.rid.should == Process.uid + end - it "also goes by Process::Sys.getuid" do - Process::Sys.getuid.should == Process.uid + it "also goes by Process::Sys.getuid" do + Process::Sys.getuid.should == Process.uid + end end end Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/process/uid_spec.rb @@ -1,15 +1,12 @@ require File.dirname(__FILE__) + '/../../spec_helper' process_is_foreground do + require 'readline' + describe "Readline.completion_append_character" do + it "needs to be reviewed for spec completeness" + end - not_supported_on :ironruby do - require 'readline' - describe "Readline.completion_append_character" do - it "needs to be reviewed for spec completeness" - end - - describe "Readline.completion_append_character=" do - it "needs to be reviewed for spec completeness" - end + describe "Readline.completion_append_character=" do + it "needs to be reviewed for spec completeness" end end Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/library/readline/completion_append_character_spec.rb @@ -26,127 +26,127 @@ namespace IronPython.Modules { public static void PerformModuleReload(PythonContext/*!*/ context, PythonDictionary/*!*/ dict) { PythonDictionary errorcode = new PythonDictionary(); - errorcode["E2BIG"] = E2BIG; - errorcode["EACCES"] = EACCES; - errorcode["EADDRINUSE"] = EADDRINUSE; - errorcode["EADDRNOTAVAIL"] = EADDRNOTAVAIL; - errorcode["EAFNOSUPPORT"] = EAFNOSUPPORT; - errorcode["EAGAIN"] = EAGAIN; - errorcode["EALREADY"] = EALREADY; - errorcode["EBADF"] = EBADF; - errorcode["EBUSY"] = EBUSY; - errorcode["ECHILD"] = ECHILD; - errorcode["ECONNABORTED"] = ECONNABORTED; - errorcode["ECONNREFUSED"] = ECONNREFUSED; - errorcode["ECONNRESET"] = ECONNRESET; - errorcode["EDEADLK"] = EDEADLK; - errorcode["EDEADLOCK"] = EDEADLOCK; - errorcode["EDESTADDRREQ"] = EDESTADDRREQ; - errorcode["EDOM"] = EDOM; - errorcode["EDQUOT"] = EDQUOT; - errorcode["EEXIST"] = EEXIST; - errorcode["EFAULT"] = EFAULT; - errorcode["EFBIG"] = EFBIG; - errorcode["EHOSTDOWN"] = EHOSTDOWN; - errorcode["EHOSTUNREACH"] = EHOSTUNREACH; - errorcode["EILSEQ"] = EILSEQ; - errorcode["EINPROGRESS"] = EINPROGRESS; - errorcode["EINTR"] = EINTR; - errorcode["EINVAL"] = EINVAL; - errorcode["EIO"] = EIO; - errorcode["EISCONN"] = EISCONN; - errorcode["EISDIR"] = EISDIR; - errorcode["ELOOP"] = ELOOP; - errorcode["EMFILE"] = EMFILE; - errorcode["EMLINK"] = EMLINK; - errorcode["EMSGSIZE"] = EMSGSIZE; - errorcode["ENAMETOOLONG"] = ENAMETOOLONG; - errorcode["ENETDOWN"] = ENETDOWN; - errorcode["ENETRESET"] = ENETRESET; - errorcode["ENETUNREACH"] = ENETUNREACH; - errorcode["ENFILE"] = ENFILE; - errorcode["ENOBUFS"] = ENOBUFS; - errorcode["ENODEV"] = ENODEV; - errorcode["ENOENT"] = ENOENT; - errorcode["ENOEXEC"] = ENOEXEC; - errorcode["ENOLCK"] = ENOLCK; - errorcode["ENOMEM"] = ENOMEM; - errorcode["ENOPROTOOPT"] = ENOPROTOOPT; - errorcode["ENOSPC"] = ENOSPC; - errorcode["ENOSYS"] = ENOSYS; - errorcode["ENOTCONN"] = ENOTCONN; - errorcode["ENOTDIR"] = ENOTDIR; - errorcode["ENOTEMPTY"] = ENOTEMPTY; - errorcode["ENOTSOCK"] = ENOTSOCK; - errorcode["ENOTTY"] = ENOTTY; - errorcode["ENXIO"] = ENXIO; - errorcode["EOPNOTSUPP"] = EOPNOTSUPP; - errorcode["EPERM"] = EPERM; - errorcode["EPFNOSUPPORT"] = EPFNOSUPPORT; - errorcode["EPIPE"] = EPIPE; - errorcode["EPROTONOSUPPORT"] = EPROTONOSUPPORT; - errorcode["EPROTOTYPE"] = EPROTOTYPE; - errorcode["ERANGE"] = ERANGE; - errorcode["EREMOTE"] = EREMOTE; - errorcode["EROFS"] = EROFS; - errorcode["ESHUTDOWN"] = ESHUTDOWN; - errorcode["ESOCKTNOSUPPORT"] = ESOCKTNOSUPPORT; - errorcode["ESPIPE"] = ESPIPE; - errorcode["ESRCH"] = ESRCH; - errorcode["ESTALE"] = ESTALE; - errorcode["ETIMEDOUT"] = ETIMEDOUT; - errorcode["ETOOMANYREFS"] = ETOOMANYREFS; - errorcode["EUSERS"] = EUSERS; - errorcode["EWOULDBLOCK"] = EWOULDBLOCK; - errorcode["EXDEV"] = EXDEV; - errorcode["WSABASEERR"] = WSABASEERR; - errorcode["WSAEACCES"] = WSAEACCES; - errorcode["WSAEADDRINUSE"] = WSAEADDRINUSE; - errorcode["WSAEADDRNOTAVAIL"] = WSAEADDRNOTAVAIL; - errorcode["WSAEAFNOSUPPORT"] = WSAEAFNOSUPPORT; - errorcode["WSAEALREADY"] = WSAEALREADY; - errorcode["WSAEBADF"] = WSAEBADF; - errorcode["WSAECONNABORTED"] = WSAECONNABORTED; - errorcode["WSAECONNREFUSED"] = WSAECONNREFUSED; - errorcode["WSAECONNRESET"] = WSAECONNRESET; - errorcode["WSAEDESTADDRREQ"] = WSAEDESTADDRREQ; - errorcode["WSAEDISCON"] = WSAEDISCON; - errorcode["WSAEDQUOT"] = WSAEDQUOT; - errorcode["WSAEFAULT"] = WSAEFAULT; - errorcode["WSAEHOSTDOWN"] = WSAEHOSTDOWN; - errorcode["WSAEHOSTUNREACH"] = WSAEHOSTUNREACH; - errorcode["WSAEINPROGRESS"] = WSAEINPROGRESS; - errorcode["WSAEINTR"] = WSAEINTR; - errorcode["WSAEINVAL"] = WSAEINVAL; - errorcode["WSAEISCONN"] = WSAEISCONN; - errorcode["WSAELOOP"] = WSAELOOP; - errorcode["WSAEMFILE"] = WSAEMFILE; - errorcode["WSAEMSGSIZE"] = WSAEMSGSIZE; - errorcode["WSAENAMETOOLONG"] = WSAENAMETOOLONG; - errorcode["WSAENETDOWN"] = WSAENETDOWN; - errorcode["WSAENETRESET"] = WSAENETRESET; - errorcode["WSAENETUNREACH"] = WSAENETUNREACH; - errorcode["WSAENOBUFS"] = WSAENOBUFS; - errorcode["WSAENOPROTOOPT"] = WSAENOPROTOOPT; - errorcode["WSAENOTCONN"] = WSAENOTCONN; - errorcode["WSAENOTEMPTY"] = WSAENOTEMPTY; - errorcode["WSAENOTSOCK"] = WSAENOTSOCK; - errorcode["WSAEOPNOTSUPP"] = WSAEOPNOTSUPP; - errorcode["WSAEPFNOSUPPORT"] = WSAEPFNOSUPPORT; - errorcode["WSAEPROCLIM"] = WSAEPROCLIM; - errorcode["WSAEPROTONOSUPPORT"] = WSAEPROTONOSUPPORT; - errorcode["WSAEPROTOTYPE"] = WSAEPROTOTYPE; - errorcode["WSAEREMOTE"] = WSAEREMOTE; - errorcode["WSAESHUTDOWN"] = WSAESHUTDOWN; - errorcode["WSAESOCKTNOSUPPORT"] = WSAESOCKTNOSUPPORT; - errorcode["WSAESTALE"] = WSAESTALE; - errorcode["WSAETIMEDOUT"] = WSAETIMEDOUT; - errorcode["WSAETOOMANYREFS"] = WSAETOOMANYREFS; - errorcode["WSAEUSERS"] = WSAEUSERS; - errorcode["WSAEWOULDBLOCK"] = WSAEWOULDBLOCK; - errorcode["WSANOTINITIALISED"] = WSANOTINITIALISED; - errorcode["WSASYSNOTREADY"] = WSASYSNOTREADY; - errorcode["WSAVERNOTSUPPORTED"] = WSAVERNOTSUPPORTED; + errorcode[E2BIG] = "E2BIG"; + errorcode[EACCES] = "EACCES"; + errorcode[EADDRINUSE] = "EADDRINUSE"; + errorcode[EADDRNOTAVAIL] = "EADDRNOTAVAIL"; + errorcode[EAFNOSUPPORT] = "EAFNOSUPPORT"; + errorcode[EAGAIN] = "EAGAIN"; + errorcode[EALREADY] = "EALREADY"; + errorcode[EBADF] = "EBADF"; + errorcode[EBUSY] = "EBUSY"; + errorcode[ECHILD] = "ECHILD"; + errorcode[ECONNABORTED] = "ECONNABORTED"; + errorcode[ECONNREFUSED] = "ECONNREFUSED"; + errorcode[ECONNRESET] = "ECONNRESET"; + errorcode[EDEADLK] = "EDEADLK"; + errorcode[EDEADLOCK] = "EDEADLOCK"; + errorcode[EDESTADDRREQ] = "EDESTADDRREQ"; + errorcode[EDOM] = "EDOM"; + errorcode[EDQUOT] = "EDQUOT"; + errorcode[EEXIST] = "EEXIST"; + errorcode[EFAULT] = "EFAULT"; + errorcode[EFBIG] = "EFBIG"; + errorcode[EHOSTDOWN] = "EHOSTDOWN"; + errorcode[EHOSTUNREACH] = "EHOSTUNREACH"; + errorcode[EILSEQ] = "EILSEQ"; + errorcode[EINPROGRESS] = "EINPROGRESS"; + errorcode[EINTR] = "EINTR"; + errorcode[EINVAL] = "EINVAL"; + errorcode[EIO] = "EIO"; + errorcode[EISCONN] = "EISCONN"; + errorcode[EISDIR] = "EISDIR"; + errorcode[ELOOP] = "ELOOP"; + errorcode[EMFILE] = "EMFILE"; + errorcode[EMLINK] = "EMLINK"; + errorcode[EMSGSIZE] = "EMSGSIZE"; + errorcode[ENAMETOOLONG] = "ENAMETOOLONG"; + errorcode[ENETDOWN] = "ENETDOWN"; + errorcode[ENETRESET] = "ENETRESET"; + errorcode[ENETUNREACH] = "ENETUNREACH"; + errorcode[ENFILE] = "ENFILE"; + errorcode[ENOBUFS] = "ENOBUFS"; + errorcode[ENODEV] = "ENODEV"; + errorcode[ENOENT] = "ENOENT"; + errorcode[ENOEXEC] = "ENOEXEC"; + errorcode[ENOLCK] = "ENOLCK"; + errorcode[ENOMEM] = "ENOMEM"; + errorcode[ENOPROTOOPT] = "ENOPROTOOPT"; + errorcode[ENOSPC] = "ENOSPC"; + errorcode[ENOSYS] = "ENOSYS"; + errorcode[ENOTCONN] = "ENOTCONN"; + errorcode[ENOTDIR] = "ENOTDIR"; + errorcode[ENOTEMPTY] = "ENOTEMPTY"; + errorcode[ENOTSOCK] = "ENOTSOCK"; + errorcode[ENOTTY] = "ENOTTY"; + errorcode[ENXIO] = "ENXIO"; + errorcode[EOPNOTSUPP] = "EOPNOTSUPP"; + errorcode[EPERM] = "EPERM"; + errorcode[EPFNOSUPPORT] = "EPFNOSUPPORT"; + errorcode[EPIPE] = "EPIPE"; + errorcode[EPROTONOSUPPORT] = "EPROTONOSUPPORT"; + errorcode[EPROTOTYPE] = "EPROTOTYPE"; + errorcode[ERANGE] = "ERANGE"; + errorcode[EREMOTE] = "EREMOTE"; + errorcode[EROFS] = "EROFS"; + errorcode[ESHUTDOWN] = "ESHUTDOWN"; + errorcode[ESOCKTNOSUPPORT] = "ESOCKTNOSUPPORT"; + errorcode[ESPIPE] = "ESPIPE"; + errorcode[ESRCH] = "ESRCH"; + errorcode[ESTALE] = "ESTALE"; + errorcode[ETIMEDOUT] = "ETIMEDOUT"; + errorcode[ETOOMANYREFS] = "ETOOMANYREFS"; + errorcode[EUSERS] = "EUSERS"; + errorcode[EWOULDBLOCK] = "EWOULDBLOCK"; + errorcode[EXDEV] = "EXDEV"; + errorcode[WSABASEERR] = "WSABASEERR"; + errorcode[WSAEACCES] = "WSAEACCES"; + errorcode[WSAEADDRINUSE] = "WSAEADDRINUSE"; + errorcode[WSAEADDRNOTAVAIL] = "WSAEADDRNOTAVAIL"; + errorcode[WSAEAFNOSUPPORT] = "WSAEAFNOSUPPORT"; + errorcode[WSAEALREADY] = "WSAEALREADY"; + errorcode[WSAEBADF] = "WSAEBADF"; + errorcode[WSAECONNABORTED] = "WSAECONNABORTED"; + errorcode[WSAECONNREFUSED] = "WSAECONNREFUSED"; + errorcode[WSAECONNRESET] = "WSAECONNRESET"; + errorcode[WSAEDESTADDRREQ] = "WSAEDESTADDRREQ"; + errorcode[WSAEDISCON] = "WSAEDISCON"; + errorcode[WSAEDQUOT] = "WSAEDQUOT"; + errorcode[WSAEFAULT] = "WSAEFAULT"; + errorcode[WSAEHOSTDOWN] = "WSAEHOSTDOWN"; + errorcode[WSAEHOSTUNREACH] = "WSAEHOSTUNREACH"; + errorcode[WSAEINPROGRESS] = "WSAEINPROGRESS"; + errorcode[WSAEINTR] = "WSAEINTR"; + errorcode[WSAEINVAL] = "WSAEINVAL"; + errorcode[WSAEISCONN] = "WSAEISCONN"; + errorcode[WSAELOOP] = "WSAELOOP"; + errorcode[WSAEMFILE] = "WSAEMFILE"; + errorcode[WSAEMSGSIZE] = "WSAEMSGSIZE"; + errorcode[WSAENAMETOOLONG] = "WSAENAMETOOLONG"; + errorcode[WSAENETDOWN] = "WSAENETDOWN"; + errorcode[WSAENETRESET] = "WSAENETRESET"; + errorcode[WSAENETUNREACH] = "WSAENETUNREACH"; + errorcode[WSAENOBUFS] = "WSAENOBUFS"; + errorcode[WSAENOPROTOOPT] = "WSAENOPROTOOPT"; + errorcode[WSAENOTCONN] = "WSAENOTCONN"; + errorcode[WSAENOTEMPTY] = "WSAENOTEMPTY"; + errorcode[WSAENOTSOCK] = "WSAENOTSOCK"; + errorcode[WSAEOPNOTSUPP] = "WSAEOPNOTSUPP"; + errorcode[WSAEPFNOSUPPORT] = "WSAEPFNOSUPPORT"; + errorcode[WSAEPROCLIM] = "WSAEPROCLIM"; + errorcode[WSAEPROTONOSUPPORT] = "WSAEPROTONOSUPPORT"; + errorcode[WSAEPROTOTYPE] = "WSAEPROTOTYPE"; + errorcode[WSAEREMOTE] = "WSAEREMOTE"; + errorcode[WSAESHUTDOWN] = "WSAESHUTDOWN"; + errorcode[WSAESOCKTNOSUPPORT] = "WSAESOCKTNOSUPPORT"; + errorcode[WSAESTALE] = "WSAESTALE"; + errorcode[WSAETIMEDOUT] = "WSAETIMEDOUT"; + errorcode[WSAETOOMANYREFS] = "WSAETOOMANYREFS"; + errorcode[WSAEUSERS] = "WSAEUSERS"; + errorcode[WSAEWOULDBLOCK] = "WSAEWOULDBLOCK"; + errorcode[WSANOTINITIALISED] = "WSANOTINITIALISED"; + errorcode[WSASYSNOTREADY] = "WSASYSNOTREADY"; + errorcode[WSAVERNOTSUPPORTED] = "WSAVERNOTSUPPORTED"; dict["errorcode"] = errorcode; } Merlin/Main/Languages/IronPython/IronPython.Modules/errno.cs @@ -172,10 +172,32 @@ namespace IronPython.Modules { // their original value. string newdir = dir; + if (IsWindows()) { + if (newdir.Length >= 2 && newdir[1] == ':' && + (newdir[0] < 'a' || newdir[0] > 'z') && (newdir[0] < 'A' || newdir[0] > 'Z')) { + // invalid drive, .NET will reject this + if (newdir.Length == 2) { + return newdir + Path.DirectorySeparatorChar; + } else if (newdir[2] == Path.DirectorySeparatorChar) { + return newdir; + } else { + return newdir.Substring(0, 2) + Path.DirectorySeparatorChar + newdir.Substring(2); + } + } + if (newdir.Length > 2 && newdir.IndexOf(':', 2) != -1) { + // : is an invalid char if it's not in the 2nd position + newdir = newdir.Substring(0, 2) + newdir.Substring(2).Replace(':', Char.MaxValue); + } + + if (newdir.Length > 0 && newdir[0] == ':') { + newdir = Char.MaxValue + newdir.Substring(1); + } + } + foreach (char c in Path.GetInvalidPathChars()) { newdir = newdir.Replace(c, Char.MaxValue); } - + // walk backwards through the path replacing the same characters. We should have // only updated the directory leaving the filename which we're fixing. string res = context.LanguageContext.DomainManager.Platform.GetFullPath(newdir); @@ -195,6 +217,12 @@ namespace IronPython.Modules { } } + private static bool IsWindows() { + return Environment.OSVersion.Platform == PlatformID.Win32NT || + Environment.OSVersion.Platform == PlatformID.Win32S || + Environment.OSVersion.Platform == PlatformID.Win32Windows; + } + #if !SILVERLIGHT public static int getpid() { return System.Diagnostics.Process.GetCurrentProcess().Id; @@ -1359,12 +1387,15 @@ namespace IronPython.Modules { return ToPythonException(e, null); } + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Interoperability", "CA1404:CallGetLastErrorImmediatelyAfterPInvoke")] private static Exception ToPythonException(Exception e, string filename) { if (e is ArgumentException || e is ArgumentNullException || e is ArgumentTypeException) { // rethrow reasonable exceptions return ExceptionHelpers.UpdateForRethrow(e); } - +#if !SILVERLIGHT + int error = Marshal.GetLastWin32Error(); +#endif string message = e.Message; int errorCode; @@ -1386,6 +1417,20 @@ namespace IronPython.Modules { } } +#if !SILVERLIGHT + IOException ioe = e as IOException; + if (ioe != null) { + switch (error) { + case PythonExceptions._WindowsError.ERROR_DIR_NOT_EMPTY: + throw PythonExceptions.CreateThrowable(WindowsError, error, "The directory is not empty"); + case PythonExceptions._WindowsError.ERROR_ACCESS_DENIED: + throw PythonExceptions.CreateThrowable(WindowsError, error, "Access is denied"); + case PythonExceptions._WindowsError.ERROR_SHARING_VIOLATION: + throw PythonExceptions.CreateThrowable(WindowsError, error, "The process cannot access the file because it is being used by another process"); + } + } +#endif + errorCode = System.Runtime.InteropServices.Marshal.GetHRForException(e); if ((errorCode & ~0xfff) == (unchecked((int)0x80070000))) { // Win32 HR, translate HR to Python error code if possible, otherwise Merlin/Main/Languages/IronPython/IronPython.Modules/nt.cs @@ -165,8 +165,12 @@ namespace IronPython.Hosting { InitializePath(ref pathIndex); InitializeModules(); InitializeExtensionDLLs(); + ImportSite(); + PythonContext.InsertIntoPath(0, "."); + PythonContext.InsertIntoPath(++pathIndex, PythonContext.DomainManager.Platform.CurrentDirectory); + if (Options.Command == null && Options.FileName != null) { if (Options.FileName == "-") { Options.FileName = "<stdin>"; @@ -202,9 +206,6 @@ namespace IronPython.Hosting { } private void InitializePath(ref int pathIndex) { - - PythonContext.InsertIntoPath(pathIndex++, PythonContext.DomainManager.Platform.CurrentDirectory); - #if !SILVERLIGHT // paths, environment vars if (!Options.IgnoreEnvironmentVariables) { string path = Environment.GetEnvironmentVariable("IRONPYTHONPATH"); Merlin/Main/Languages/IronPython/IronPython/Hosting/PythonCommandLine.cs @@ -261,7 +261,7 @@ namespace IronPython.Modules { if (o == null) { pyContext.UnregisterTracebackHandler(); - pyContext.TracebackListener.SetTrace(null, null); + PythonTracebackListener.SetTrace(null, null); } else { // We're following CPython behavior here. // If CurrentPythonFrame is not null then we're currently inside a traceback, and @@ -270,7 +270,7 @@ namespace IronPython.Modules { if (pyThread == null || !pyThread.InTraceback) { pyContext.PushTracebackHandler(new PythonTracebackListener((PythonContext)context.LanguageContext)); pyContext.RegisterTracebackHandler(); - pyContext.TracebackListener.SetTrace(o, (TracebackDelegate)Converter.ConvertToDelegate(o, typeof(TracebackDelegate))); + PythonTracebackListener.SetTrace(o, (TracebackDelegate)Converter.ConvertToDelegate(o, typeof(TracebackDelegate))); } } } @@ -291,12 +291,7 @@ namespace IronPython.Modules { } public static object gettrace(CodeContext/*!*/ context) { - var listener = PythonContext.GetContext(context).TracebackListener; - - if (listener != null) { - return listener.GetTraceObject(); - } - return null; + return PythonTracebackListener.GetTraceObject(); } public static void setrecursionlimit(CodeContext/*!*/ context, int limit) { Merlin/Main/Languages/IronPython/IronPython/Modules/sys.cs @@ -38,6 +38,7 @@ namespace IronPython.Runtime.Operations { if (o is string) return __new__(null, (string)o, 10); if (o is double) return DoubleOps.__int__((double)o); if (o is int) return o; + if (o is bool) return ((bool)o) ? 1 : 0; if (o is BigInteger) { BigInteger bi = o as BigInteger; int res; Merlin/Main/Languages/IronPython/IronPython/Runtime/Operations/IntOps.cs @@ -4166,17 +4166,15 @@ namespace IronPython.Runtime.Operations { return buffer.ToString().MakeByteArray(); } - public static bool ModuleGetMember(PythonModule module, string name, out object res) { - return module.__dict__.TryGetValue(name, out res) && res != Uninitialized.Instance; - } - - public static object ModuleSetMember(PythonModule module, string name, object value) { - Debug.Assert(value != Uninitialized.Instance); - return module.__dict__[name] = value; - } + public static bool ModuleTryGetMember(CodeContext context, PythonModule module, string name, out object res) { + object value = module.GetAttributeNoThrow(context, name); + if (value != OperationFailed.Value) { + res = value; + return true; + } - public static bool ModuleDeleteMember(PythonModule module, string name) { - return module.__dict__.Remove(name); + res = null; + return false; } internal static void ScopeSetMember(CodeContext context, Scope scope, string name, object value) { Merlin/Main/Languages/IronPython/IronPython/Runtime/Operations/PythonOps.cs @@ -185,12 +185,17 @@ namespace IronPython.Runtime { // tracing / in-proc debugging support private Debugging.CompilerServices.DebugContext _debugContext; private Debugging.ITracePipeline _tracePipeline; - private Stack<PythonTracebackListener> _tracebackListeners; + + [ThreadStatic] + private static Stack<PythonTracebackListener> _tracebackListeners; + private static int _tracingThreads; + internal FunctionCode.CodeList _allCodes; internal readonly object _codeCleanupLock = new object(), _codeUpdateLock = new object(); internal int _codeCount, _nextCodeCleanup = 200; private int _recursionLimit; - private bool _enableTracing; + [ThreadStatic] + private static bool _enableTracing; /// <summary> /// Creates a new PythonContext not bound to Engine. @@ -317,14 +322,24 @@ namespace IronPython.Runtime { internal bool EnableTracing { get { - return _enableTracing || PythonOptions.Tracing; + return _tracingThreads > 0 || PythonOptions.Tracing; } set { lock (_codeUpdateLock) { bool oldEnableTracing = _enableTracing; _enableTracing = value; - if (oldEnableTracing != _enableTracing) { + bool flip = false; + if (value && !oldEnableTracing) { + flip = _tracingThreads++ == 0; + }else if(!value && oldEnableTracing) { + flip = _tracingThreads++ != 0; + if (flip) { + _tracePipeline.TraceCallback = null; + } + } + + if (flip) { // recursion setting has changed, we need to update all of our // function codes to enforce or un-enforce recursion. FunctionCode.UpdateAllCode(this); @@ -332,7 +347,7 @@ namespace IronPython.Runtime { } } } - + internal TopNamespaceTracker TopNamespace { get { return _topNamespace; @@ -1840,8 +1855,8 @@ namespace IronPython.Runtime { #region Object Operations - public override ConvertBinder/*!*/ CreateConvertBinder(Type/*!*/ toType, bool explicitCast) { - return CompatConvert(toType, explicitCast); + public override ConvertBinder/*!*/ CreateConvertBinder(Type/*!*/ toType, bool? explicitCast) { + return CompatConvert(toType, explicitCast ?? false); } public override DeleteMemberBinder/*!*/ CreateDeleteMemberBinder(string/*!*/ name, bool ignoreCase) { @@ -3681,7 +3696,7 @@ namespace IronPython.Runtime { #region Tracing - internal PythonTracebackListener TracebackListener { + internal static PythonTracebackListener TracebackListener { get { if (_tracebackListeners == null) { return null; @@ -3700,17 +3715,20 @@ namespace IronPython.Runtime { } internal void EnsureDebugContext() { - if (_debugContext == null || _tracePipeline == null || _tracebackListeners == null) { + if (_debugContext == null || _tracePipeline == null) { lock(this) { if (_debugContext == null) { _debugContext = Debugging.CompilerServices.DebugContext.CreateInstance(); _tracePipeline = Debugging.TracePipeline.CreateInstance(_debugContext); - _tracebackListeners = new Stack<PythonTracebackListener>(); - // push the default listener - _tracebackListeners.Push(new PythonTracebackListener(this)); } } } + + if (_tracebackListeners == null) { + _tracebackListeners = new Stack<PythonTracebackListener>(); + // push the default listener + _tracebackListeners.Push(new PythonTracebackListener(this)); + } } internal Debugging.ITracePipeline TracePipeline { @@ -3729,7 +3747,6 @@ namespace IronPython.Runtime { internal void UnregisterTracebackHandler() { Debug.Assert(_tracePipeline != null); // ensure debug context should have been called - _tracePipeline.TraceCallback = null; EnableTracing = false; } Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonContext.cs @@ -21,6 +21,7 @@ using System; using System.Collections.Generic; using System.Diagnostics; using System.Dynamic; +using System.Runtime.CompilerServices; using System.Threading; using Microsoft.Scripting; @@ -45,6 +46,10 @@ namespace IronPython.Runtime { public PythonModule() { _dict = new PythonDictionary(); + if (GetType() != typeof(PythonModule) && this is IPythonObject) { + // we should share the user dict w/ our dict. + ((IPythonObject)this).ReplaceDict(_dict); + } } /// <summary> @@ -96,20 +101,24 @@ namespace IronPython.Runtime { public void __init__(string name, string documentation) { _dict["__name__"] = name; - - if (documentation != null) { - _dict["__doc__"] = documentation; - } + _dict["__doc__"] = documentation; } public object __getattribute__(CodeContext/*!*/ context, string name) { + PythonTypeSlot slot; + object res; + if (GetType() != typeof(PythonModule) && + DynamicHelpers.GetPythonType(this).TryResolveMixedSlot(context, name, out slot) && + slot.TryGetValue(context, this, DynamicHelpers.GetPythonType(this), out res)) { + return res; + } + switch (name) { // never look in the dict for these... case "__dict__": return __dict__; case "__class__": return DynamicHelpers.GetPythonType(this); } - object res; if (_dict.TryGetValue(name, out res)) { return res; } @@ -119,32 +128,55 @@ namespace IronPython.Runtime { } internal object GetAttributeNoThrow(CodeContext/*!*/ context, string name) { + PythonTypeSlot slot; + object res; + if (GetType() != typeof(PythonModule) && + DynamicHelpers.GetPythonType(this).TryResolveMixedSlot(context, name, out slot) && + slot.TryGetValue(context, this, DynamicHelpers.GetPythonType(this), out res)) { + return res; + } + switch (name) { // never look in the dict for these... case "__dict__": return __dict__; case "__class__": return DynamicHelpers.GetPythonType(this); } - object res; if (_dict.TryGetValue(name, out res)) { return res; + } else if (DynamicHelpers.GetPythonType(this).TryGetNonCustomMember(context, this, name, out res)) { + return res; } - // fall back to object to provide all of our other attributes (e.g. __setattr__, etc...) - try { - return ObjectOps.__getattribute__(context, this, name); - } catch (MissingMemberException) { - return OperationFailed.Value; - } + return OperationFailed.Value; } - public void __setattr__(string name, object value) { + public void __setattr__(CodeContext/*!*/ context, string name, object value) { + PythonTypeSlot slot; + if (GetType() != typeof(PythonModule) && + DynamicHelpers.GetPythonType(this).TryResolveMixedSlot(context, name, out slot) && + slot.TrySetValue(context, this, DynamicHelpers.GetPythonType(this), value)) { + return; + } + + switch (name) { + case "__dict__": throw PythonOps.TypeError("readonly attribute"); + case "__class__": throw PythonOps.TypeError("__class__ assignment: only for heap types"); + } + Debug.Assert(value != Uninitialized.Instance); _dict[name] = value; } - public void __delattr__(string name) { + public void __delattr__(CodeContext/*!*/ context, string name) { + PythonTypeSlot slot; + if (GetType() != typeof(PythonModule) && + DynamicHelpers.GetPythonType(this).TryResolveMixedSlot(context, name, out slot) && + slot.TryDeleteValue(context, this, DynamicHelpers.GetPythonType(this))) { + return; + } + switch (name) { case "__dict__": throw PythonOps.TypeError("readonly attribute"); case "__class__": throw PythonOps.TypeError("can't delete __class__ attribute"); @@ -178,12 +210,29 @@ namespace IronPython.Runtime { return String.Format("<module '{0}' from '{1}'>", name, file); } - public PythonDictionary __dict__ { + internal PythonDictionary __dict__ { get { return _dict; } } + [SpecialName, PropertyMethod] + public PythonDictionary Get__dict__() { + return _dict; + } + + [SpecialName, PropertyMethod] + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")] + public void Set__dict__(object value) { + throw PythonOps.TypeError("readonly attribute"); + } + + [SpecialName, PropertyMethod] + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")] + public void Delete__dict__() { + throw PythonOps.TypeError("readonly attribute"); + } + internal Scope Scope { get { if (_scope == null) { @@ -222,26 +271,15 @@ namespace IronPython.Runtime { private DynamicMetaObject GetMemberWorker(DynamicMetaObjectBinder binder, DynamicMetaObject codeContext) { string name = GetGetMemberName(binder); - - if (name == "__dict__") { - return new DynamicMetaObject( - Expression.Property( - Utils.Convert(Expression, typeof(PythonModule)), - typeof(PythonModule).GetProperty("__dict__") - ), - BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) - ); - - } - - var tmp = Expression.Variable(typeof(object), "res"); + var tmp = Expression.Variable(typeof(object), "res"); return new DynamicMetaObject( Expression.Block( new[] { tmp }, Expression.Condition( Expression.Call( - typeof(PythonOps).GetMethod("ModuleGetMember"), + typeof(PythonOps).GetMethod("ModuleTryGetMember"), + PythonContext.GetCodeContext(binder), Utils.Convert(Expression, typeof(PythonModule)), Expression.Constant(name), tmp @@ -258,38 +296,15 @@ namespace IronPython.Runtime { public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) { Debug.Assert(value.Value != Uninitialized.Instance); - switch (binder.Name) { - case "__dict__": - return new DynamicMetaObject( - Expression.Throw( - Expression.Call( - typeof(PythonOps).GetMethod("TypeError"), - Expression.Constant("readonly attribute"), - Expression.NewArrayInit(typeof(object)) - ), - typeof(object) - ), - BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) - ); - case "__class__": - return new DynamicMetaObject( - Expression.Throw( - Expression.Call( - typeof(PythonOps).GetMethod("TypeError"), - Expression.Constant("__class__ assignment: only for heap types"), - Expression.NewArrayInit(typeof(object)) - ), - typeof(object) - ), - BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) - ); - } - return new DynamicMetaObject( - Expression.Call( - typeof(PythonOps).GetMethod("ModuleSetMember"), - Utils.Convert(Expression, typeof(PythonModule)), - Expression.Constant(binder.Name), + Expression.Block( + Expression.Call( + Utils.Convert(Expression, typeof(PythonModule)), + typeof(PythonModule).GetMethod("__setattr__"), + PythonContext.GetCodeContext(binder), + Expression.Constant(binder.Name), + Expression.Convert(value.Expression, typeof(object)) + ), Expression.Convert(value.Expression, typeof(object)) ), BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) @@ -297,40 +312,12 @@ namespace IronPython.Runtime { } public override DynamicMetaObject BindDeleteMember(DeleteMemberBinder binder) { - switch (binder.Name) { - case "__dict__": - return new DynamicMetaObject( - Expression.Throw( - Expression.Call( - typeof(PythonOps).GetMethod("TypeError"), - Expression.Constant("can't set attributes of built-in/extension type 'module'"), - Expression.NewArrayInit(typeof(object)) - ) - ), - BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) - ); - case "__class__": - return new DynamicMetaObject( - Expression.Throw( - Expression.Call( - typeof(PythonOps).GetMethod("TypeError"), - Expression.Constant("can't delete __class__ attribute"), - Expression.NewArrayInit(typeof(object)) - ) - ), - BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) - ); - } - return new DynamicMetaObject( - Expression.Condition( - Expression.Call( - typeof(PythonOps).GetMethod("ModuleDeleteMember"), - Utils.Convert(Expression, typeof(PythonModule)), - Expression.Constant(binder.Name) - ), - Expression.Default(binder.ReturnType), - binder.FallbackDeleteMember(this).Expression + Expression.Call( + Utils.Convert(Expression, typeof(PythonModule)), + typeof(PythonModule).GetMethod("__delattr__"), + PythonContext.GetCodeContext(binder), + Expression.Constant(binder.Name) ), BindingRestrictions.GetTypeRestriction(Expression, Value.GetType()) ); Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonModule.cs @@ -35,8 +35,8 @@ namespace IronPython.Runtime { internal sealed class PythonTracebackListener : Debugging.ITraceCallback { private readonly PythonContext _pythonContext; [ThreadStatic] private static TraceThread _threads; - [ThreadStatic] private TracebackDelegate _globalTraceDispatch; - [ThreadStatic] private object _globalTraceObject; + [ThreadStatic] private static TracebackDelegate _globalTraceDispatch; + [ThreadStatic] private static object _globalTraceObject; private bool _exceptionThrown; #if PROFILE_SUPPORT @@ -59,12 +59,12 @@ namespace IronPython.Runtime { } } - internal void SetTrace(object function, TracebackDelegate traceDispatch) { + internal static void SetTrace(object function, TracebackDelegate traceDispatch) { _globalTraceDispatch = traceDispatch; _globalTraceObject = function; } - internal object GetTraceObject() { + internal static object GetTraceObject() { return _globalTraceObject; } @@ -178,14 +178,14 @@ namespace IronPython.Runtime { } bool traceDispatchThrew = true; - _pythonContext.TracePipeline.TraceCallback = null; + PythonContext.TracePipeline.TraceCallback = null; thread.InTraceback = true; try { traceDispatch = traceDispatch(pyFrame, traceEvent, args); traceDispatchThrew = false; } finally { thread.InTraceback = false; - _pythonContext.TracePipeline.TraceCallback = this; + PythonContext.TracePipeline.TraceCallback = this; if (traceDispatchThrew) { // We're matching CPython's behavior here. If the trace dispatch throws any exceptions Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonTracebackListener.cs @@ -1965,7 +1965,19 @@ type(name, bases, dict) -> creates a new type instance with the given name, base if (CheckForSlotWithDefault(context, bases, slots, "__dict__")) { _attrs |= PythonTypeAttributes.HasDictionary; - AddSlot("__dict__", new PythonTypeDictSlot(this)); + PythonTypeSlot pts; + bool inheritsDict = false; + for(int i = 1; i<_resolutionOrder.Count; i++) { + PythonType pt = _resolutionOrder[i]; + if (pt.TryResolveSlot(context, "__dict__", out pts)) { + inheritsDict = true; + break; + } + } + + if (!inheritsDict) { + AddSlot("__dict__", new PythonTypeDictSlot(this)); + } } object modName; Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/PythonType.cs @@ -921,12 +921,7 @@ namespace IronPython.Runtime.Types { class DocumentationDescriptor : PythonTypeSlot { internal override bool TryGetValue(CodeContext context, object instance, PythonType owner, out object value) { if (owner.IsSystemType) { - if (instance is IDynamicMetaObjectProvider && !(instance is IPythonObject) && !DynamicHelpers.GetPythonType(instance).IsPythonType) { - // ask the foreign IDO for it's documentation - value = PythonContext.GetContext(context).GetDocumentation(instance); - } else { - value = PythonTypeOps.GetDocumentation(owner.UnderlyingSystemType); - } + value = PythonTypeOps.GetDocumentation(owner.UnderlyingSystemType); return true; } Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/TypeInfo.cs @@ -281,7 +281,6 @@ namespace IronPython.Runtime { #region IDisposable Members public void Dispose() { - GC.SuppressFinalize(this); } #endregion Merlin/Main/Languages/IronPython/IronPython/Runtime/XRange.cs @@ -138,15 +138,5 @@ <Name>IronPython %28Languages\IronPython\IronPython%29</Name> </ProjectReference> </ItemGroup> - <ItemGroup> - <COMReference Include="Shell32"> - <Guid>{50A7E9B0-70EF-11D1-B75A-00A0C90564FE}</Guid> - <VersionMajor>1</VersionMajor> - <VersionMinor>0</VersionMinor> - <Lcid>0</Lcid> - <WrapperTool>tlbimp</WrapperTool> - <Isolated>False</Isolated> - </COMReference> - </ItemGroup> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" Condition=" '$(SilverlightTreeBuild)' != 'true' " /> </Project> \ No newline at end of file Merlin/Main/Languages/IronPython/IronPythonTest/IronPythonTest.csproj @@ -141,6 +141,16 @@ namespace IronRuby.Builtins { } } + [RubyClass("ENOEXEC", Extends = typeof(ExecFormatError), Inherits = typeof(ExternalException))] + public class ExecFormatErrorOps { + [RubyConstructor] + public static BadFileDescriptorError/*!*/ Create(RubyClass/*!*/ self, [DefaultProtocol, DefaultParameterValue(null)]MutableString message) { + var result = new BadFileDescriptorError(RubyExceptions.MakeMessage(ref message, "Exec format error")); + RubyExceptionData.InitializeException(result, message); + return result; + } + } + [RubyClass("EPIPE"), Serializable] public class PipeError : ExternalException { private const string/*!*/ M = "Broken pipe"; Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Errno.cs @@ -20,6 +20,7 @@ using Microsoft.Scripting.Ast; #endif using System; +using System.ComponentModel; using System.Diagnostics; using System.IO; using System.Runtime.InteropServices; @@ -34,6 +35,7 @@ using Microsoft.Scripting.Utils; namespace IronRuby.Builtins { using Ast = Expression; + using Utils = IronRuby.Runtime.Utils; /// <summary> /// Implementation of IO builtin class. @@ -218,13 +220,10 @@ namespace IronRuby.Builtins { IOMode mode = IOModeEnum.Parse(modeString); - ProcessStartInfo startInfo = KernelOps.GetShell(context, command); - startInfo.UseShellExecute = false; - bool redirectStandardInput = mode.CanWrite(); bool redirectStandardOutput = mode.CanRead(); - Process process = OpenPipe(context, command, redirectStandardInput, redirectStandardOutput, false); + Process process = RubyProcess.CreateProcess(context, command, redirectStandardInput, redirectStandardOutput, false); StreamReader reader = null; StreamWriter writer = null; @@ -239,28 +238,6 @@ namespace IronRuby.Builtins { return new RubyIO(context, reader, writer, mode); } - internal static Process/*!*/ OpenPipe(RubyContext/*!*/ context, MutableString/*!*/ command, - bool redirectStandardInput, bool redirectStandardOutput, bool redirectStandardError) { - - ProcessStartInfo startInfo = KernelOps.GetShell(context, command); - startInfo.UseShellExecute = false; - - startInfo.RedirectStandardInput = redirectStandardInput; - startInfo.RedirectStandardOutput = redirectStandardOutput; - startInfo.RedirectStandardError = redirectStandardError; - - Process process; - try { - process = Process.Start(startInfo); - } catch (Exception e) { - throw RubyExceptions.CreateENOENT(startInfo.FileName, e); - } - - context.ChildProcessExitStatus = new RubyProcess.Status(process); - - return process; - } - #endif #endregion @@ -473,12 +450,49 @@ namespace IronRuby.Builtins { self.Flush(); } - [RubyMethod("isatty")] - [RubyMethod("tty?")] + #region isatty + +#if !SILVERLIGHT + [RubyMethod("isatty", BuildConfig = "!SILVERLIGHT")] + [RubyMethod("tty?", BuildConfig = "!SILVERLIGHT")] public static bool IsAtty(RubyIO/*!*/ self) { - return self.IsConsole; + ConsoleStreamType? console = self.ConsoleStreamType; + if (console == null) { + return self.GetStream().BaseStream == Stream.Null; + } + + IntPtr handle = GetStdHandle(GetStdHandleId(console.Value)); + if (handle == IntPtr.Zero) { + throw new Win32Exception(); + } + + return GetFileType(handle) == FILE_TYPE_CHAR; } + private static int GetStdHandleId(ConsoleStreamType streamType) { + switch (streamType) { + case ConsoleStreamType.Input: return STD_INPUT_HANDLE; + case ConsoleStreamType.Output: return STD_OUTPUT_HANDLE; + case ConsoleStreamType.ErrorOutput: return STD_ERROR_HANDLE; + default: throw Assert.Unreachable; + } + } + + private const int FILE_TYPE_CHAR = 0x0002; + + private const int STD_INPUT_HANDLE = -10; + private const int STD_OUTPUT_HANDLE = -11; + private const int STD_ERROR_HANDLE = -12; + + [DllImport("kernel32")] + private extern static IntPtr GetStdHandle(int nStdHandle); + + [DllImport("kernel32")] + private extern static int GetFileType(IntPtr hFile); +#endif + + #endregion + [RubyMethod("sync")] public static bool Sync(RubyIO/*!*/ self) { self.RequireOpen(); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/IoOps.cs @@ -17,6 +17,7 @@ using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; +using System.IO; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; @@ -998,81 +999,16 @@ namespace IronRuby.Builtins { #region `, exec, system, fork, 1.9: spawn #if !SILVERLIGHT - // Looks for RUBYSHELL and then COMSPEC under Windows - internal static ProcessStartInfo/*!*/ GetShell(RubyContext/*!*/ context, MutableString/*!*/ command) { - PlatformAdaptationLayer pal = context.DomainManager.Platform; - string shell = pal.GetEnvironmentVariable("RUBYSHELL"); - if (shell == null) { - shell = pal.GetEnvironmentVariable("COMSPEC"); - } - - if (shell == null) { - string[] commandParts = command.ConvertToString().Split(new char[] { ' ' }, 2); - return new ProcessStartInfo(commandParts[0], commandParts.Length == 2 ? commandParts[1] : null); - } else { - return new ProcessStartInfo(shell, String.Format("/C \"{0}\"", command.ConvertToString())); - } - } - - private static MutableString/*!*/ JoinArguments(MutableString/*!*/[]/*!*/ args) { - MutableString result = MutableString.CreateMutable(RubyEncoding.Binary); - - for (int i = 0; i < args.Length; i++) { - result.Append(args[i]); - if (args.Length > 1 && i < args.Length - 1) { - result.Append(' '); - } - } - - return result; - } - - private static Process/*!*/ ExecuteProcessAndWait(ProcessStartInfo/*!*/ psi) { - psi.UseShellExecute = false; - psi.RedirectStandardError = true; - try { - Process p = Process.Start(psi); - p.WaitForExit(); - return p; - } catch (Exception e) { - throw RubyExceptions.CreateENOENT(psi.FileName, e); - } - } - - internal static Process/*!*/ ExecuteProcessCapturingStandardOutput(ProcessStartInfo/*!*/ psi) { - psi.UseShellExecute = false; - psi.RedirectStandardError = true; - psi.RedirectStandardOutput = true; - - try { - return Process.Start(psi); - } catch (Exception e) { - throw RubyExceptions.CreateENOENT(psi.FileName, e); - } - } - - // Executes a command in a shell child process - private static Process/*!*/ ExecuteCommandInShell(RubyContext/*!*/ context, MutableString/*!*/ command) { - return ExecuteProcessAndWait(GetShell(context, command)); - } - - // Executes a command directly in a child process - command is the name of the executable - private static Process/*!*/ ExecuteCommand(MutableString/*!*/ command, MutableString[]/*!*/ args) { - return ExecuteProcessAndWait(new ProcessStartInfo(command.ToString(), JoinArguments(args).ToString())); - } - - // Backtick always executes the command in a shell child process - [RubyMethod("`", RubyMethodAttributes.PrivateInstance, BuildConfig = "!SILVERLIGHT")] [RubyMethod("`", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static MutableString/*!*/ ExecuteCommand(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]MutableString/*!*/ command) { - Process p = ExecuteProcessCapturingStandardOutput(GetShell(context, command)); + Process p = RubyProcess.CreateProcess(context, command, true); + string output = p.StandardOutput.ReadToEnd(); if (Environment.NewLine != "\n") { output = output.Replace(Environment.NewLine, "\n"); } MutableString result = MutableString.Create(output, RubyEncoding.GetRubyEncoding(p.StandardOutput.CurrentEncoding)); - context.ChildProcessExitStatus = new RubyProcess.Status(p); return result; } @@ -1082,8 +1018,8 @@ namespace IronRuby.Builtins { [RubyMethod("exec", RubyMethodAttributes.PrivateInstance, BuildConfig = "!SILVERLIGHT")] [RubyMethod("exec", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static void Execute(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]MutableString/*!*/ command) { - Process p = ExecuteCommandInShell(context, command); - context.ChildProcessExitStatus = new RubyProcess.Status(p); + Process p = RubyProcess.CreateProcess(context, command, false); + p.WaitForExit(); Exit(self, p.ExitCode); } @@ -1091,26 +1027,32 @@ namespace IronRuby.Builtins { [RubyMethod("exec", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static void Execute(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]MutableString/*!*/ command, [DefaultProtocol, NotNull, NotNullItems]params MutableString[]/*!*/ args) { - Process p = ExecuteCommand(command, args); - context.ChildProcessExitStatus = new RubyProcess.Status(p); + Process p = RubyProcess.CreateProcess(context, command, args); Exit(self, p.ExitCode); } [RubyMethod("system", RubyMethodAttributes.PrivateInstance, BuildConfig = "!SILVERLIGHT")] [RubyMethod("system", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static bool System(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]MutableString/*!*/ command) { - Process p = ExecuteCommandInShell(context, command); - context.ChildProcessExitStatus = new RubyProcess.Status(p); - return p.ExitCode == 0; + try { + Process p = RubyProcess.CreateProcess(context, command, false); + p.WaitForExit(); + return p.ExitCode == 0; + } catch (FileNotFoundException) { + return false; + } } [RubyMethod("system", RubyMethodAttributes.PrivateInstance, BuildConfig = "!SILVERLIGHT")] [RubyMethod("system", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static bool System(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]MutableString/*!*/ command, [DefaultProtocol, NotNull, NotNullItems]params MutableString/*!*/[]/*!*/ args) { - Process p = ExecuteCommand(command, args); - context.ChildProcessExitStatus = new RubyProcess.Status(p); - return p.ExitCode == 0; + try { + Process p = RubyProcess.CreateProcess(context, command, args); + return p.ExitCode == 0; + } catch (FileNotFoundException) { + return false; + } } //fork Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs @@ -21,6 +21,8 @@ using Microsoft.Scripting; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using IronRuby.Runtime; +using System.Collections.Generic; +using System.IO; namespace IronRuby.Builtins { @@ -29,12 +31,287 @@ namespace IronRuby.Builtins { /// </summary> [RubyModule("Process", BuildConfig = "!SILVERLIGHT")] public static class RubyProcess { - + #region Utils + + internal static Process/*!*/ CreateProcess(RubyContext/*!*/ context, MutableString/*!*/ command, MutableString[]/*!*/ args) { + var psi = new ProcessStartInfo(command.ToString(), JoinArguments(args).ToString()); + psi.UseShellExecute = false; + psi.RedirectStandardError = true; + try { + Utils.Log(String.Format("Starting: '{0}' with args: '{1}'", psi.FileName, psi.Arguments), "PROCESS"); + Process p = Process.Start(psi); + p.WaitForExit(); + context.ChildProcessExitStatus = new RubyProcess.Status(p); + return p; + } catch (Exception e) { + throw RubyExceptions.CreateENOENT(psi.FileName, e); + } + } + + internal static Process/*!*/ CreateProcess(RubyContext/*!*/ context, MutableString/*!*/ command, bool redirectOutput) { + return CreateProcess(context, command, false, redirectOutput, false); + } + + internal static Process/*!*/ CreateProcess(RubyContext/*!*/ context, MutableString/*!*/ command, + bool redirectInput, bool redirectOutput, bool redirectErrorOutput) { + + string fileName, arguments; + RubyProcess.GetExecutable(context.DomainManager.Platform, command.ToString(), out fileName, out arguments); + Utils.Log(String.Format("Starting: '{0}' with args: '{1}'", fileName, arguments), "PROCESS"); + + var p = new Process(); + p.StartInfo.FileName = fileName; + p.StartInfo.Arguments = arguments; + p.StartInfo.UseShellExecute = false; + p.StartInfo.RedirectStandardInput = redirectInput; + p.StartInfo.RedirectStandardOutput = redirectOutput; + p.StartInfo.RedirectStandardError = redirectErrorOutput; + try { + p.Start(); + } catch (Exception e) { + throw RubyExceptions.CreateENOENT(fileName, e); + } + + context.ChildProcessExitStatus = new RubyProcess.Status(p); + return p; + } + + private static void GetExecutable(PlatformAdaptationLayer/*!*/ pal, string/*!*/ command, out string executable, out string arguments) { + command = command.Trim(' '); + if (command.Length == 0) { + throw RubyExceptions.CreateEINVAL(command); + } + + // This seems to be quite complicated: + // 1) If the first part of the command is a shell command (DIR, ECHO, ...) or + // if the command contains unquoted <, > or | then + // it uses ENV['COMSPEC'] to execute the command: %COMSPEC% /c "COMMAND" + // 2) It looks for the shortest prefix of command that is separated by space from the rest of the command that is either + // a) An absolute path to an executable file. + // b) Try prepend paths from ENV['PATH'] + // c) Try Environment.SpecialFolder.System. + // d) Try SHGetFolderPath(CSIDL_WINDOWS) - we can't get this from Environment.SpecialFolder, so we need to use + // ENV["SystemRoot"] environment variable. + // In each step it tries to append ".exe" or ".com" extension if the path doesn't exist. + // + // For example, if the command is `x/a b/x` and the directory structure is + // x\a b\x.exe + // x\a.exe + // it executes a.exe. + // + // MRI probably calls CreateProcess Win32 API with lpApplicationName it resolves as described above and + // lpCommandLine == command. System.Diagnostics.Process also uses this API with lpApplicationName == NULL and + // lpCommandLine == '"{ProcessStartInfo.FileName}" {ProcessStartInfo.Arguments}'. + // + // Although CreateProcess does all the searching for an executable if passed no lpApplicationName, + // we need to do it ourselves because it is slightly different in MRI (is that a bug?) and also because System.Diagnostics.Process + // quotes the FileName :( + // + + string comspec = pal.GetEnvironmentVariable("COMSPEC"); + if (!pal.FileExists(comspec)) { + comspec = null; + } + + if (comspec != null && IndexOfUnquotedSpecialCharacter(command) >= 0) { + executable = comspec; + arguments = "/c \"" + command + "\""; + return; + } + + int start = 0; + while (true) { + int next = command.IndexOf(' ', start); + + executable = (next >= 0) ? command.Substring(0, next) : command; + arguments = (next >= 0) ? command.Substring(next + 1) : ""; + + if (start == 0 && comspec != null && IsShellCommand(executable)) { + executable = comspec; + arguments = "/c \"" + command + "\""; + return; + } + + try { + foreach (var path in GetExecutableFiles(pal, executable)) { + if (pal.FileExists(path)) { + // We need to set the path we found as executable. Althought makes command line of the target process + // different from when called by MRI it will execute the right process. If we passed the original executable name + // CreateProcess might resolve it to a different executable. + executable = path; + return; + } + } + } catch (Exception e) { + if (next < 0) { + throw RubyExceptions.CreateENOENT(command, e); + } + } + + if (next < 0) { + throw RubyExceptions.CreateENOENT(command); + } + + start = next + 1; + while (start < command.Length && command[start] == ' ') { + start++; + } + } + } + + private static int IndexOfUnquotedSpecialCharacter(string/*!*/ str) { + bool inDoubleQuote = false; + bool inSingleQuote = false; + for (int i = 0; i < str.Length; i++) { + char c = str[i]; + if (c == '"') { + inDoubleQuote = !inDoubleQuote; + } else if (c == '\'') { + inSingleQuote = !inSingleQuote; + } else if (c == '>' || c == '<' || c == '|') { + if (!inSingleQuote && !inDoubleQuote) { + return i; + } + } + } + return -1; + } + + private static string[] _ExecutableExtensions = new[] { ".exe", ".com" }; + + private static IEnumerable<string>/*!*/ GetExecutableFiles(PlatformAdaptationLayer/*!*/ pal, string/*!*/ path) { + if (path[0] == '"' || path[path.Length - 1] == '"') { + if (path.Length >= 3 && path[0] == '"' && path[path.Length - 1] == '"') { + path = path.Substring(1, path.Length - 2); + } else { + yield break; + } + } + + string extension = Path.GetExtension(path); + bool hasExtension = !String.IsNullOrEmpty(extension); + bool isExecutable = hasExtension && Array.IndexOf(_ExecutableExtensions, extension.ToLowerInvariant()) >= 0; + + if (!hasExtension || isExecutable) { + foreach (var fullPath in GetAbsolutePaths(pal, path)) { + if (hasExtension) { + yield return fullPath; + } else { + foreach (var ext in _ExecutableExtensions) { + yield return fullPath + ext; + } + } + } + } + } + + private static IEnumerable<string>/*!*/ GetAbsolutePaths(PlatformAdaptationLayer/*!*/ pal, string/*!*/ path) { + if (pal.IsAbsolutePath(path)) { + yield return path; + } else { + yield return pal.GetFullPath(path); + + string var = pal.GetEnvironmentVariable("PATH"); + if (!String.IsNullOrEmpty(var)) { + foreach (var prefix in var.Split(Path.PathSeparator)) { + if (prefix.Length > 0) { + yield return Path.Combine(prefix, path); + } + } + } + + var = Environment.GetFolderPath(Environment.SpecialFolder.System); + if (!String.IsNullOrEmpty(var)) { + yield return Path.Combine(var, path); + } + + var = pal.GetEnvironmentVariable("SystemRoot"); + if (!String.IsNullOrEmpty(var)) { + yield return Path.Combine(var, path); + } + } + } + + private static bool IsShellCommand(string/*!*/ str) { + if (Environment.OSVersion.Platform != PlatformID.Win32NT && + Environment.OSVersion.Platform != PlatformID.Win32Windows) { + return false; + } + + switch (str.ToUpperInvariant()) { + case "ASSOC": + case "BREAK": + case "CALL": + case "CD": + case "CHDIR": + case "CLS": + case "COLOR": + case "COPY": + case "DATE": + case "DEL": + case "DIR": + case "ECHO": + case "ENDLOCAL": + case "ERASE": + case "EXIT": + case "FOR": + case "FTYPE": + case "GOTO": + case "IF": + case "MD": + case "MKDIR": + case "MOVE": + case "PATH": + case "PAUSE": + case "POPD": + case "PROMPT": + case "PUSHD": + case "RD": + case "REM": + case "REN": + case "RENAME": + case "RMDIR": + case "SET": + case "SETLOCAL": + case "SHIFT": + case "START": + case "TIME": + case "TITLE": + case "TYPE": + case "VER": + case "VERIFY": + case "VOL": + return true; + + case "MKLINK": + return Environment.OSVersion.Version.Major >= 6; // Vista and later + }; + return false; + } + + private static MutableString/*!*/ JoinArguments(MutableString/*!*/[]/*!*/ args) { + MutableString result = MutableString.CreateMutable(RubyEncoding.Binary); + + for (int i = 0; i < args.Length; i++) { + result.Append(args[i]); + if (args.Length > 1 && i < args.Length - 1) { + result.Append(' '); + } + } + + return result; + } + + #endregion + + #region Status + [RubyClass("Status", BuildConfig = "!SILVERLIGHT")] - public class Status { + [HideMethod("new", IsStatic = true)] + public sealed class Status { private readonly Process/*!*/ _process; - public Status(Process/*!*/ process) { + internal Status(Process/*!*/ process) { _process = process; } @@ -81,8 +358,19 @@ namespace IronRuby.Builtins { // Always nil on Windows return null; } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(Status/*!*/ self) { + return MutableString.CreateAscii(String.Format("#<Process::Status: pid={0},{1}({2})>", + Pid(self), + Exited(self) ? "exited" : "running", + ExitStatus(self) + )); + } } + #endregion + // abort // detach // egid @@ -183,6 +471,8 @@ namespace IronRuby.Builtins { // waitpid2 } + #region Struct::Tms + public static partial class RubyStructOps { #region Tms @@ -235,5 +525,7 @@ namespace IronRuby.Builtins { #endregion } + + #endregion } #endif Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RubyProcess.cs @@ -5,4 +5,4 @@ if "%1" == "-4" ( set DIR=%MERLIN_ROOT%\Bin\Debug ) -"%DIR%\ClassInitGenerator" "%DIR%\IronRuby.Libraries.dll" /libraries:IronRuby.Builtins;IronRuby.StandardLibrary.Threading;IronRuby.StandardLibrary.Sockets;IronRuby.StandardLibrary.OpenSsl;IronRuby.StandardLibrary.Digest;IronRuby.StandardLibrary.Zlib;IronRuby.StandardLibrary.StringIO;IronRuby.StandardLibrary.StringScanner;IronRuby.StandardLibrary.Enumerator;IronRuby.StandardLibrary.FunctionControl;IronRuby.StandardLibrary.FileControl;IronRuby.StandardLibrary.BigDecimal;IronRuby.StandardLibrary.Iconv;IronRuby.StandardLibrary.ParseTree;IronRuby.StandardLibrary.Open3 /out:%~dp0\Initializers.Generated.cs +"%DIR%\ClassInitGenerator" "%DIR%\IronRuby.Libraries.dll" /libraries:IronRuby.Builtins;IronRuby.StandardLibrary.Threading;IronRuby.StandardLibrary.Sockets;IronRuby.StandardLibrary.OpenSsl;IronRuby.StandardLibrary.Digest;IronRuby.StandardLibrary.Zlib;IronRuby.StandardLibrary.StringIO;IronRuby.StandardLibrary.StringScanner;IronRuby.StandardLibrary.Enumerator;IronRuby.StandardLibrary.FunctionControl;IronRuby.StandardLibrary.FileControl;IronRuby.StandardLibrary.BigDecimal;IronRuby.StandardLibrary.Iconv;IronRuby.StandardLibrary.ParseTree;IronRuby.StandardLibrary.Open3;IronRuby.StandardLibrary.Win32API /out:%~dp0\Initializers.Generated.cs Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/GenerateInitializers.cmd @@ -28,6 +28,7 @@ [assembly: IronRuby.Runtime.RubyLibraryAttribute(typeof(IronRuby.StandardLibrary.Iconv.IconvLibraryInitializer))] [assembly: IronRuby.Runtime.RubyLibraryAttribute(typeof(IronRuby.StandardLibrary.ParseTree.ParseTreeLibraryInitializer))] [assembly: IronRuby.Runtime.RubyLibraryAttribute(typeof(IronRuby.StandardLibrary.Open3.Open3LibraryInitializer))] +[assembly: IronRuby.Runtime.RubyLibraryAttribute(typeof(IronRuby.StandardLibrary.Win32API.Win32APILibraryInitializer))] namespace IronRuby.Builtins { using System; @@ -48,29 +49,29 @@ namespace IronRuby.Builtins { // Skipped primitive: __ClassSingleton // Skipped primitive: __MainSingleton - IronRuby.Builtins.RubyModule def44 = DefineGlobalModule("Comparable", typeof(IronRuby.Builtins.Comparable), 0x00000107, LoadComparable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def35 = DefineGlobalModule("Enumerable", typeof(IronRuby.Builtins.Enumerable), 0x00000107, LoadEnumerable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def45 = DefineGlobalModule("Comparable", typeof(IronRuby.Builtins.Comparable), 0x00000107, LoadComparable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def36 = DefineGlobalModule("Enumerable", typeof(IronRuby.Builtins.Enumerable), 0x00000107, LoadEnumerable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def2 = DefineGlobalModule("Errno", typeof(IronRuby.Builtins.Errno), 0x00000107, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def26 = DefineModule("File::Constants", typeof(IronRuby.Builtins.RubyFileOps.Constants), 0x00000107, null, null, LoadFile__Constants_Constants, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def27 = DefineModule("File::Constants", typeof(IronRuby.Builtins.RubyFileOps.Constants), 0x00000107, null, null, LoadFile__Constants_Constants, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("FileTest", typeof(IronRuby.Builtins.FileTest), 0x00000107, null, LoadFileTest_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("GC", typeof(IronRuby.Builtins.RubyGC), 0x00000107, LoadGC_Instance, LoadGC_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def22 = DefineGlobalModule("IronRuby", typeof(IronRuby.Ruby), 0x00000004, null, LoadIronRuby_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def23 = DefineGlobalModule("IronRuby", typeof(IronRuby.Ruby), 0x00000004, null, LoadIronRuby_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def4 = DefineModule("IronRuby::Clr", typeof(IronRuby.Builtins.IronRubyOps.ClrOps), 0x00000100, null, LoadIronRuby__Clr_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def5 = DefineModule("IronRuby::Clr::BigInteger", typeof(IronRuby.Builtins.ClrBigInteger), 0x00000107, LoadIronRuby__Clr__BigInteger_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def20 = DefineModule("IronRuby::Clr::FlagEnumeration", typeof(IronRuby.Builtins.FlagEnumeration), 0x00000000, LoadIronRuby__Clr__FlagEnumeration_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def21 = DefineModule("IronRuby::Clr::FlagEnumeration", typeof(IronRuby.Builtins.FlagEnumeration), 0x00000000, LoadIronRuby__Clr__FlagEnumeration_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def6 = DefineModule("IronRuby::Clr::Float", typeof(IronRuby.Builtins.ClrFloat), 0x00000107, LoadIronRuby__Clr__Float_Instance, LoadIronRuby__Clr__Float_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def7 = DefineModule("IronRuby::Clr::Integer", typeof(IronRuby.Builtins.ClrInteger), 0x00000107, LoadIronRuby__Clr__Integer_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def23 = DefineModule("IronRuby::Clr::MultiDimensionalArray", typeof(IronRuby.Builtins.MultiDimensionalArray), 0x00000000, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def24 = DefineModule("IronRuby::Clr::MultiDimensionalArray", typeof(IronRuby.Builtins.MultiDimensionalArray), 0x00000000, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def8 = DefineModule("IronRuby::Clr::String", typeof(IronRuby.Builtins.ClrString), 0x00000107, LoadIronRuby__Clr__String_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def24 = DefineModule("IronRuby::Print", typeof(IronRuby.Builtins.PrintOps), 0x00000107, LoadIronRuby__Print_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def25 = DefineModule("IronRuby::Print", typeof(IronRuby.Builtins.PrintOps), 0x00000107, LoadIronRuby__Print_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Kernel DefineGlobalModule("Marshal", typeof(IronRuby.Builtins.RubyMarshal), 0x00000107, null, LoadMarshal_Class, LoadMarshal_Constants, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("Math", typeof(IronRuby.Builtins.RubyMath), 0x00000107, LoadMath_Instance, LoadMath_Class, LoadMath_Constants, IronRuby.Builtins.RubyModule.EmptyArray); ExtendClass(typeof(Microsoft.Scripting.Actions.TypeTracker), null, LoadMicrosoft__Scripting__Actions__TypeTracker_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("ObjectSpace", typeof(IronRuby.Builtins.ObjectSpace), 0x00000107, null, LoadObjectSpace_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def41 = DefineGlobalModule("Precision", typeof(IronRuby.Builtins.Precision), 0x00000107, LoadPrecision_Instance, LoadPrecision_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def42 = DefineGlobalModule("Precision", typeof(IronRuby.Builtins.Precision), 0x00000107, LoadPrecision_Instance, LoadPrecision_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); #if !SILVERLIGHT - IronRuby.Builtins.RubyModule def27 = DefineGlobalModule("Process", typeof(IronRuby.Builtins.RubyProcess), 0x00000107, LoadProcess_Instance, LoadProcess_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def28 = DefineGlobalModule("Process", typeof(IronRuby.Builtins.RubyProcess), 0x00000107, LoadProcess_Instance, LoadProcess_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); #endif #if !SILVERLIGHT DefineGlobalModule("Signal", typeof(IronRuby.Builtins.Signal), 0x00000107, null, LoadSignal_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); @@ -78,258 +79,261 @@ namespace IronRuby.Builtins { ExtendClass(typeof(System.Type), null, LoadSystem__Type_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: __ClassSingletonSingleton #if !SILVERLIGHT - object def1 = DefineSingleton(Load__Singleton_ArgFilesSingletonOps_Instance, null, null, def35); + object def1 = DefineSingleton(Load__Singleton_ArgFilesSingletonOps_Instance, null, null, def36); #endif - object def9 = DefineSingleton(Load__Singleton_EnvironmentSingletonOps_Instance, null, null, def35); - ExtendClass(typeof(Microsoft.Scripting.Actions.TypeGroup), null, LoadMicrosoft__Scripting__Actions__TypeGroup_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def35}); + object def9 = DefineSingleton(Load__Singleton_EnvironmentSingletonOps_Instance, null, null, def36); + ExtendClass(typeof(Microsoft.Scripting.Actions.TypeGroup), null, LoadMicrosoft__Scripting__Actions__TypeGroup_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def36}); // Skipped primitive: Object - ExtendClass(typeof(System.Char), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def8, def35, def44}, + ExtendClass(typeof(System.Char), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def8, def36, def45}, new Func<IronRuby.Builtins.RubyClass, System.Char, System.Char>(IronRuby.Builtins.CharOps.Create), new Func<IronRuby.Builtins.RubyClass, System.Char[], System.Char>(IronRuby.Builtins.CharOps.Create), new Func<IronRuby.Builtins.RubyClass, System.String, System.Char>(IronRuby.Builtins.CharOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Char>(IronRuby.Builtins.CharOps.Create) ); - ExtendModule(typeof(System.Collections.Generic.IDictionary<System.Object, System.Object>), LoadSystem__Collections__Generic__IDictionary_Instance, null, null, def35); - ExtendModule(typeof(System.Collections.IEnumerable), LoadSystem__Collections__IEnumerable_Instance, null, null, def35); - ExtendModule(typeof(System.Collections.IList), LoadSystem__Collections__IList_Instance, null, null, def35); - ExtendModule(typeof(System.IComparable), LoadSystem__IComparable_Instance, null, null, def44); - ExtendClass(typeof(System.String), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def8, def35, def44}, + ExtendModule(typeof(System.Collections.Generic.IDictionary<System.Object, System.Object>), LoadSystem__Collections__Generic__IDictionary_Instance, null, null, def36); + ExtendModule(typeof(System.Collections.IEnumerable), LoadSystem__Collections__IEnumerable_Instance, null, null, def36); + ExtendModule(typeof(System.Collections.IList), LoadSystem__Collections__IList_Instance, null, null, def36); + ExtendModule(typeof(System.IComparable), LoadSystem__IComparable_Instance, null, null, def45); + ExtendClass(typeof(System.String), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def8, def36, def45}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.String>(IronRuby.Builtins.ClrStringOps.Create), new Func<IronRuby.Builtins.RubyClass, System.Char, System.Int32, System.String>(IronRuby.Builtins.ClrStringOps.Create), new Func<IronRuby.Builtins.RubyClass, System.Char[], System.String>(IronRuby.Builtins.ClrStringOps.Create), new Func<IronRuby.Builtins.RubyClass, System.Char[], System.Int32, System.Int32, System.String>(IronRuby.Builtins.ClrStringOps.Create) ); - DefineGlobalClass("Array", typeof(IronRuby.Builtins.RubyArray), 0x00000007, Context.ObjectClass, LoadArray_Instance, LoadArray_Class, null, new IronRuby.Builtins.RubyModule[] {def35}, + DefineGlobalClass("Array", typeof(IronRuby.Builtins.RubyArray), 0x00000007, Context.ObjectClass, LoadArray_Instance, LoadArray_Class, null, new IronRuby.Builtins.RubyModule[] {def36}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray), new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.Union<System.Collections.IList, System.Int32>>, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Object, System.Object>(IronRuby.Builtins.ArrayOps.CreateArray), new Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray), new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray) ); DefineGlobalClass("Binding", typeof(IronRuby.Builtins.Binding), 0x00000007, Context.ObjectClass, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("Dir", typeof(IronRuby.Builtins.RubyDir), 0x00000107, Context.ObjectClass, LoadDir_Instance, LoadDir_Class, null, new IronRuby.Builtins.RubyModule[] {def35}); + DefineGlobalClass("Dir", typeof(IronRuby.Builtins.RubyDir), 0x00000107, Context.ObjectClass, LoadDir_Instance, LoadDir_Class, null, new IronRuby.Builtins.RubyModule[] {def36}); #if !SILVERLIGHT if (Context.RubyOptions.Compatibility >= RubyCompatibility.Ruby19) { DefineGlobalClass("Encoding", typeof(IronRuby.Builtins.RubyEncoding), 0x00000007, Context.ObjectClass, LoadEncoding_Instance, LoadEncoding_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); } #endif - IronRuby.Builtins.RubyClass def45 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), 0x00000007, Context.ObjectClass, LoadException_Instance, LoadException_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def46 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), 0x00000007, Context.ObjectClass, LoadException_Instance, LoadException_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__Exception)); Context.FalseClass = DefineGlobalClass("FalseClass", typeof(IronRuby.Builtins.FalseClass), 0x00000107, Context.ObjectClass, LoadFalseClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); #if !SILVERLIGHT - IronRuby.Builtins.RubyClass def33 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), 0x00000007, Context.ObjectClass, LoadFile__Stat_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def44}, + IronRuby.Builtins.RubyClass def34 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), 0x00000007, Context.ObjectClass, LoadFile__Stat_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def45}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.FileSystemInfo>(IronRuby.Builtins.RubyFileOps.RubyStatOps.Create) ); #endif - DefineGlobalClass("Hash", typeof(IronRuby.Builtins.Hash), 0x00000007, Context.ObjectClass, LoadHash_Instance, LoadHash_Class, null, new IronRuby.Builtins.RubyModule[] {def35}, + DefineGlobalClass("Hash", typeof(IronRuby.Builtins.Hash), 0x00000007, Context.ObjectClass, LoadHash_Instance, LoadHash_Class, null, new IronRuby.Builtins.RubyModule[] {def36}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash), new Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Object, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash), new Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash) ); - IronRuby.Builtins.RubyClass def46 = DefineGlobalClass("IO", typeof(IronRuby.Builtins.RubyIO), 0x00000007, Context.ObjectClass, LoadIO_Instance, LoadIO_Class, LoadIO_Constants, new IronRuby.Builtins.RubyModule[] {def26, def35}, + IronRuby.Builtins.RubyClass def47 = DefineGlobalClass("IO", typeof(IronRuby.Builtins.RubyIO), 0x00000007, Context.ObjectClass, LoadIO_Instance, LoadIO_Class, LoadIO_Constants, new IronRuby.Builtins.RubyModule[] {def27, def36}, new Func<IronRuby.Builtins.RubyClass, System.Int32, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyIO>(IronRuby.Builtins.RubyIOOps.Create), new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Int32, IronRuby.Builtins.RubyIO>(IronRuby.Builtins.RubyIOOps.Create) ); - IronRuby.Builtins.RubyClass def29 = DefineClass("IronRuby::Clr::Name", typeof(IronRuby.Runtime.ClrName), 0x00000007, Context.ObjectClass, LoadIronRuby__Clr__Name_Instance, LoadIronRuby__Clr__Name_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def30 = DefineClass("IronRuby::Clr::Scope", typeof(Microsoft.Scripting.Runtime.Scope), 0x00000007, Context.ObjectClass, LoadIronRuby__Clr__Scope_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def30 = DefineClass("IronRuby::Clr::Name", typeof(IronRuby.Runtime.ClrName), 0x00000007, Context.ObjectClass, LoadIronRuby__Clr__Name_Instance, LoadIronRuby__Clr__Name_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def31 = DefineClass("IronRuby::Clr::Scope", typeof(Microsoft.Scripting.Runtime.Scope), 0x00000007, Context.ObjectClass, LoadIronRuby__Clr__Scope_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("MatchData", typeof(IronRuby.Builtins.MatchData), 0x00000007, Context.ObjectClass, LoadMatchData_Instance, LoadMatchData_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("Method", typeof(IronRuby.Builtins.RubyMethod), 0x00000007, Context.ObjectClass, LoadMethod_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Module Context.NilClass = DefineGlobalClass("NilClass", typeof(Microsoft.Scripting.Runtime.DynamicNull), 0x00000007, Context.ObjectClass, LoadNilClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def40 = DefineGlobalClass("Numeric", typeof(IronRuby.Builtins.Numeric), 0x00000107, Context.ObjectClass, LoadNumeric_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def44}); + IronRuby.Builtins.RubyClass def41 = DefineGlobalClass("Numeric", typeof(IronRuby.Builtins.Numeric), 0x00000107, Context.ObjectClass, LoadNumeric_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def45}); DefineGlobalClass("Proc", typeof(IronRuby.Builtins.Proc), 0x00000007, Context.ObjectClass, LoadProc_Instance, LoadProc_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Action<IronRuby.Builtins.RubyClass, System.Object[]>(IronRuby.Builtins.ProcOps.Error) ); #if !SILVERLIGHT && !SILVERLIGHT - IronRuby.Builtins.RubyClass def28 = DefineClass("Process::Status", typeof(IronRuby.Builtins.RubyProcess.Status), 0x00000107, Context.ObjectClass, LoadProcess__Status_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def29 = DefineClass("Process::Status", typeof(IronRuby.Builtins.RubyProcess.Status), 0x00000107, Context.ObjectClass, LoadProcess__Status_Instance, LoadProcess__Status_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); #endif - DefineGlobalClass("Range", typeof(IronRuby.Builtins.Range), 0x00000007, Context.ObjectClass, LoadRange_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def35}, + DefineGlobalClass("Range", typeof(IronRuby.Builtins.Range), 0x00000007, Context.ObjectClass, LoadRange_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def36}, new Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Builtins.RubyClass, System.Object, System.Object, System.Boolean, IronRuby.Builtins.Range>(IronRuby.Builtins.RangeOps.CreateRange) ); - DefineGlobalClass("Regexp", typeof(IronRuby.Builtins.RubyRegex), 0x00000007, Context.ObjectClass, LoadRegexp_Instance, LoadRegexp_Class, LoadRegexp_Constants, new IronRuby.Builtins.RubyModule[] {def35}, + DefineGlobalClass("Regexp", typeof(IronRuby.Builtins.RubyRegex), 0x00000007, Context.ObjectClass, LoadRegexp_Instance, LoadRegexp_Class, LoadRegexp_Constants, new IronRuby.Builtins.RubyModule[] {def36}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, System.Int32, System.Object, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, System.Object, System.Object, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Boolean, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create) ); - DefineGlobalClass("String", typeof(IronRuby.Builtins.MutableString), 0x00000007, Context.ObjectClass, LoadString_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def35, def44}, + DefineGlobalClass("String", typeof(IronRuby.Builtins.MutableString), 0x00000007, Context.ObjectClass, LoadString_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def36, def45}, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString>(IronRuby.Builtins.MutableStringOps.Create), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString>(IronRuby.Builtins.MutableStringOps.Create) ); - DefineGlobalClass("Struct", typeof(IronRuby.Builtins.RubyStruct), 0x00000007, Context.ObjectClass, LoadStruct_Instance, LoadStruct_Class, LoadStruct_Constants, new IronRuby.Builtins.RubyModule[] {def35}, + DefineGlobalClass("Struct", typeof(IronRuby.Builtins.RubyStruct), 0x00000007, Context.ObjectClass, LoadStruct_Instance, LoadStruct_Class, LoadStruct_Constants, new IronRuby.Builtins.RubyModule[] {def36}, new Action<IronRuby.Builtins.RubyClass, System.Object[]>(IronRuby.Builtins.RubyStructOps.AllocatorUndefined) ); DefineGlobalClass("Symbol", typeof(Microsoft.Scripting.SymbolId), 0x00000007, Context.ObjectClass, LoadSymbol_Instance, LoadSymbol_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("Thread", typeof(System.Threading.Thread), 0x00000007, Context.ObjectClass, LoadThread_Instance, LoadThread_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("ThreadGroup", typeof(IronRuby.Builtins.ThreadGroup), 0x00000107, Context.ObjectClass, LoadThreadGroup_Instance, null, LoadThreadGroup_Constants, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("Time", typeof(System.DateTime), 0x00000007, Context.ObjectClass, LoadTime_Instance, LoadTime_Class, null, new IronRuby.Builtins.RubyModule[] {def44}, + DefineGlobalClass("Time", typeof(System.DateTime), 0x00000007, Context.ObjectClass, LoadTime_Instance, LoadTime_Class, null, new IronRuby.Builtins.RubyModule[] {def45}, new Func<IronRuby.Builtins.RubyClass, System.DateTime>(IronRuby.Builtins.TimeOps.Create) ); Context.TrueClass = DefineGlobalClass("TrueClass", typeof(IronRuby.Builtins.TrueClass), 0x00000107, Context.ObjectClass, LoadTrueClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("UnboundMethod", typeof(IronRuby.Builtins.UnboundMethod), 0x00000107, Context.ObjectClass, LoadUnboundMethod_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Class - IronRuby.Builtins.RubyClass def25 = DefineGlobalClass("File", typeof(IronRuby.Builtins.RubyFile), 0x00000007, def46, LoadFile_Instance, LoadFile_Class, LoadFile_Constants, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def26 = DefineGlobalClass("File", typeof(IronRuby.Builtins.RubyFile), 0x00000007, def47, LoadFile_Instance, LoadFile_Class, LoadFile_Constants, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Runtime.Union<System.Int32, IronRuby.Builtins.MutableString>, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new Func<IronRuby.Builtins.RubyClass, IronRuby.Runtime.Union<System.Int32, IronRuby.Builtins.MutableString>, System.Int32, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile) ); - DefineGlobalClass("Float", typeof(System.Double), 0x00000007, def40, LoadFloat_Instance, LoadFloat_Class, LoadFloat_Constants, new IronRuby.Builtins.RubyModule[] {def41}); - IronRuby.Builtins.RubyClass def47 = DefineGlobalClass("Integer", typeof(IronRuby.Builtins.Integer), 0x00000107, def40, LoadInteger_Instance, LoadInteger_Class, null, new IronRuby.Builtins.RubyModule[] {def41}); - DefineGlobalClass("NoMemoryError", typeof(IronRuby.Builtins.NoMemoryError), 0x00000107, def45, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Float", typeof(System.Double), 0x00000007, def41, LoadFloat_Instance, LoadFloat_Class, LoadFloat_Constants, new IronRuby.Builtins.RubyModule[] {def42}); + IronRuby.Builtins.RubyClass def48 = DefineGlobalClass("Integer", typeof(IronRuby.Builtins.Integer), 0x00000107, def41, LoadInteger_Instance, LoadInteger_Class, null, new IronRuby.Builtins.RubyModule[] {def42}); + DefineGlobalClass("NoMemoryError", typeof(IronRuby.Builtins.NoMemoryError), 0x00000107, def46, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NoMemoryError)); - IronRuby.Builtins.RubyClass def43 = DefineGlobalClass("ScriptError", typeof(IronRuby.Builtins.ScriptError), 0x00000007, def45, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def44 = DefineGlobalClass("ScriptError", typeof(IronRuby.Builtins.ScriptError), 0x00000007, def46, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ScriptError)); - IronRuby.Builtins.RubyClass def42 = DefineGlobalClass("SignalException", typeof(IronRuby.Builtins.SignalException), 0x00000107, def45, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def43 = DefineGlobalClass("SignalException", typeof(IronRuby.Builtins.SignalException), 0x00000107, def46, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SignalException)); - IronRuby.Builtins.RubyClass def37 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), 0x00000007, def45, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def38 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), 0x00000007, def46, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__StandardError)); - ExtendClass(typeof(System.Single), def40, LoadSystem__Single_Instance, LoadSystem__Single_Class, null, new IronRuby.Builtins.RubyModule[] {def41}, + ExtendClass(typeof(System.Single), def41, LoadSystem__Single_Instance, LoadSystem__Single_Class, null, new IronRuby.Builtins.RubyModule[] {def42}, new Func<IronRuby.Builtins.RubyClass, System.Double, System.Single>(IronRuby.Builtins.SingleOps.Create) ); - DefineGlobalClass("SystemExit", typeof(IronRuby.Builtins.SystemExit), 0x00000007, def45, LoadSystemExit_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SystemExit", typeof(IronRuby.Builtins.SystemExit), 0x00000007, def46, LoadSystemExit_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, IronRuby.Builtins.SystemExit>(IronRuby.Builtins.SystemExitOps.Factory), new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.SystemExit>(IronRuby.Builtins.SystemExitOps.Factory) ); - DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), 0x00000007, def37, LoadArgumentError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), 0x00000007, def38, LoadArgumentError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ArgumentError)); - DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), 0x00000007, def47, LoadBignum_Instance, LoadBignum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("EncodingError", typeof(IronRuby.Builtins.EncodingError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), 0x00000007, def48, LoadBignum_Instance, LoadBignum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("EncodingError", typeof(IronRuby.Builtins.EncodingError), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__EncodingError)); - DefineGlobalClass("Fixnum", typeof(System.Int32), 0x00000007, def47, LoadFixnum_Instance, LoadFixnum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Fixnum", typeof(System.Int32), 0x00000007, def48, LoadFixnum_Instance, LoadFixnum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__IndexError)); - DefineGlobalClass("Interrupt", typeof(IronRuby.Builtins.Interrupt), 0x00000107, def42, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Interrupt", typeof(IronRuby.Builtins.Interrupt), 0x00000107, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__Interrupt)); - IronRuby.Builtins.RubyClass def38 = DefineGlobalClass("IOError", typeof(System.IO.IOException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def39 = DefineGlobalClass("IOError", typeof(System.IO.IOException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__IOError)); - DefineGlobalClass("LoadError", typeof(IronRuby.Builtins.LoadError), 0x00000007, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("LoadError", typeof(IronRuby.Builtins.LoadError), 0x00000007, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__LoadError)); - DefineGlobalClass("LocalJumpError", typeof(IronRuby.Builtins.LocalJumpError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("LocalJumpError", typeof(IronRuby.Builtins.LocalJumpError), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__LocalJumpError)); - IronRuby.Builtins.RubyClass def48 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def49 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NameError)); - DefineGlobalClass("NotImplementedError", typeof(IronRuby.Builtins.NotImplementedError), 0x00000007, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("NotImplementedError", typeof(IronRuby.Builtins.NotImplementedError), 0x00000007, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NotImplementedError)); - IronRuby.Builtins.RubyClass def39 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), 0x00000007, def37, LoadRangeError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def40 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), 0x00000007, def38, LoadRangeError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RangeError)); - DefineGlobalClass("RegexpError", typeof(IronRuby.Builtins.RegexpError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("RegexpError", typeof(IronRuby.Builtins.RegexpError), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RegexpError)); - DefineGlobalClass("RuntimeError", typeof(IronRuby.Builtins.RuntimeError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("RuntimeError", typeof(IronRuby.Builtins.RuntimeError), 0x00000107, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RuntimeError)); - DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SecurityError)); - DefineGlobalClass("SyntaxError", typeof(IronRuby.Builtins.SyntaxError), 0x00000007, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SyntaxError", typeof(IronRuby.Builtins.SyntaxError), 0x00000007, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SyntaxError)); - ExtendClass(typeof(System.Byte), def47, LoadSystem__Byte_Instance, LoadSystem__Byte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Byte), def48, LoadSystem__Byte_Instance, LoadSystem__Byte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom) ); - ExtendClass(typeof(System.Decimal), def47, LoadSystem__Decimal_Instance, LoadSystem__Decimal_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Decimal), def48, LoadSystem__Decimal_Instance, LoadSystem__Decimal_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Decimal>(IronRuby.Builtins.DecimalOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Decimal>(IronRuby.Builtins.DecimalOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.Decimal>(IronRuby.Builtins.DecimalOps.InducedFrom) ); - ExtendClass(typeof(System.Int16), def47, LoadSystem__Int16_Instance, LoadSystem__Int16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Int16), def48, LoadSystem__Int16_Instance, LoadSystem__Int16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom) ); - ExtendClass(typeof(System.Int64), def47, LoadSystem__Int64_Instance, LoadSystem__Int64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Int64), def48, LoadSystem__Int64_Instance, LoadSystem__Int64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom) ); - ExtendClass(typeof(System.SByte), def47, LoadSystem__SByte_Instance, LoadSystem__SByte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.SByte), def48, LoadSystem__SByte_Instance, LoadSystem__SByte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom) ); - ExtendClass(typeof(System.UInt16), def47, LoadSystem__UInt16_Instance, LoadSystem__UInt16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt16), def48, LoadSystem__UInt16_Instance, LoadSystem__UInt16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom) ); - ExtendClass(typeof(System.UInt32), def47, LoadSystem__UInt32_Instance, LoadSystem__UInt32_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt32), def48, LoadSystem__UInt32_Instance, LoadSystem__UInt32_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom) ); - ExtendClass(typeof(System.UInt64), def47, LoadSystem__UInt64_Instance, LoadSystem__UInt64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt64), def48, LoadSystem__UInt64_Instance, LoadSystem__UInt64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom), new Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom) ); - IronRuby.Builtins.RubyClass def36 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def37 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Runtime.InteropServices.ExternalException>(IronRuby.Builtins.SystemCallErrorOps.Factory), new Func<IronRuby.Builtins.RubyClass, System.Int32, System.Runtime.InteropServices.ExternalException>(IronRuby.Builtins.SystemCallErrorOps.Factory) ); - DefineGlobalClass("SystemStackError", typeof(IronRuby.Builtins.SystemStackError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SystemStackError", typeof(IronRuby.Builtins.SystemStackError), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SystemStackError)); - DefineGlobalClass("ThreadError", typeof(IronRuby.Builtins.ThreadError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ThreadError", typeof(IronRuby.Builtins.ThreadError), 0x00000107, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ThreadError)); - DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__TypeError)); - DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), 0x00000007, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ZeroDivisionError)); - DefineGlobalClass("EOFError", typeof(IronRuby.Builtins.EOFError), 0x00000107, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("EOFError", typeof(IronRuby.Builtins.EOFError), 0x00000107, def39, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__EOFError)); - IronRuby.Builtins.RubyClass def34 = DefineClass("Errno::EACCES", typeof(System.UnauthorizedAccessException), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def35 = DefineClass("Errno::EACCES", typeof(System.UnauthorizedAccessException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.UnauthorizedAccessException>(IronRuby.Builtins.Errno.UnauthorizedAccessExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def10 = DefineClass("Errno::EADDRINUSE", typeof(IronRuby.Builtins.Errno.AddressInUseError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def3 = DefineClass("Errno::EBADF", typeof(IronRuby.Builtins.BadFileDescriptorError), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def10 = DefineClass("Errno::EADDRINUSE", typeof(IronRuby.Builtins.Errno.AddressInUseError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def3 = DefineClass("Errno::EBADF", typeof(IronRuby.Builtins.BadFileDescriptorError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.BadFileDescriptorError>(IronRuby.Builtins.Errno.BadFileDescriptorErrorOps.Create) ); - IronRuby.Builtins.RubyClass def11 = DefineClass("Errno::ECHILD", typeof(IronRuby.Builtins.Errno.ChildError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def12 = DefineClass("Errno::ECONNABORTED", typeof(IronRuby.Builtins.Errno.ConnectionAbortError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def13 = DefineClass("Errno::ECONNREFUSED", typeof(IronRuby.Builtins.Errno.ConnectionRefusedError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def14 = DefineClass("Errno::ECONNRESET", typeof(IronRuby.Builtins.Errno.ConnectionResetError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def15 = DefineClass("Errno::EDOM", typeof(IronRuby.Builtins.Errno.DomainError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def19 = DefineClass("Errno::EEXIST", typeof(IronRuby.Builtins.ExistError), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def11 = DefineClass("Errno::ECHILD", typeof(IronRuby.Builtins.Errno.ChildError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def12 = DefineClass("Errno::ECONNABORTED", typeof(IronRuby.Builtins.Errno.ConnectionAbortError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def13 = DefineClass("Errno::ECONNREFUSED", typeof(IronRuby.Builtins.Errno.ConnectionRefusedError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def14 = DefineClass("Errno::ECONNRESET", typeof(IronRuby.Builtins.Errno.ConnectionResetError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def15 = DefineClass("Errno::EDOM", typeof(IronRuby.Builtins.Errno.DomainError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def20 = DefineClass("Errno::EEXIST", typeof(IronRuby.Builtins.ExistError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.ExistError>(IronRuby.Builtins.Errno.ExistErrorOps.Create) ); - IronRuby.Builtins.RubyClass def21 = DefineClass("Errno::EINVAL", typeof(IronRuby.Builtins.InvalidError), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def22 = DefineClass("Errno::EINVAL", typeof(IronRuby.Builtins.InvalidError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.InvalidError>(IronRuby.Builtins.Errno.InvalidErrorOps.Create) ); - IronRuby.Builtins.RubyClass def32 = DefineClass("Errno::ENOENT", typeof(System.IO.FileNotFoundException), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def33 = DefineClass("Errno::ENOENT", typeof(System.IO.FileNotFoundException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.FileNotFoundException>(IronRuby.Builtins.Errno.FileNotFoundExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def17 = DefineClass("Errno::ENOTCONN", typeof(IronRuby.Builtins.Errno.NotConnectedError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def31 = DefineClass("Errno::ENOTDIR", typeof(System.IO.DirectoryNotFoundException), 0x00000007, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def19 = DefineClass("Errno::ENOEXEC", typeof(IronRuby.Builtins.ExecFormatError), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.BadFileDescriptorError>(IronRuby.Builtins.Errno.ExecFormatErrorOps.Create) + ); + IronRuby.Builtins.RubyClass def17 = DefineClass("Errno::ENOTCONN", typeof(IronRuby.Builtins.Errno.NotConnectedError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def32 = DefineClass("Errno::ENOTDIR", typeof(System.IO.DirectoryNotFoundException), 0x00000007, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.DirectoryNotFoundException>(IronRuby.Builtins.Errno.DirectoryNotFoundExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def18 = DefineClass("Errno::EPIPE", typeof(IronRuby.Builtins.Errno.PipeError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def16 = DefineClass("Errno::EXDEV", typeof(IronRuby.Builtins.Errno.ImproperLinkError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("ESPIPE", typeof(IronRuby.Builtins.InvalidSeekError), 0x00000107, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("FloatDomainError", typeof(IronRuby.Builtins.FloatDomainError), 0x00000107, def39, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def18 = DefineClass("Errno::EPIPE", typeof(IronRuby.Builtins.Errno.PipeError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def16 = DefineClass("Errno::EXDEV", typeof(IronRuby.Builtins.Errno.ImproperLinkError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("ESPIPE", typeof(IronRuby.Builtins.InvalidSeekError), 0x00000107, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("FloatDomainError", typeof(IronRuby.Builtins.FloatDomainError), 0x00000107, def40, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__FloatDomainError)); - DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), 0x00000007, def48, LoadNoMethodError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), 0x00000007, def49, LoadNoMethodError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NoMethodError)); - def25.SetBuiltinConstant("Constants", def26); - def22.SetBuiltinConstant("Clr", def4); + def26.SetBuiltinConstant("Constants", def27); + def23.SetBuiltinConstant("Clr", def4); def4.SetBuiltinConstant("BigInteger", def5); - def4.SetBuiltinConstant("FlagEnumeration", def20); + def4.SetBuiltinConstant("FlagEnumeration", def21); def4.SetBuiltinConstant("Float", def6); def4.SetBuiltinConstant("Integer", def7); - def4.SetBuiltinConstant("MultiDimensionalArray", def23); + def4.SetBuiltinConstant("MultiDimensionalArray", def24); def4.SetBuiltinConstant("String", def8); - def22.SetBuiltinConstant("Print", def24); + def23.SetBuiltinConstant("Print", def25); #if !SILVERLIGHT Context.ObjectClass.SetBuiltinConstant("ARGF", def1); #endif Context.ObjectClass.SetBuiltinConstant("ENV", def9); #if !SILVERLIGHT - def25.SetBuiltinConstant("Stat", def33); + def26.SetBuiltinConstant("Stat", def34); #endif - def4.SetBuiltinConstant("Name", def29); - def4.SetBuiltinConstant("Scope", def30); + def4.SetBuiltinConstant("Name", def30); + def4.SetBuiltinConstant("Scope", def31); #if !SILVERLIGHT && !SILVERLIGHT - def27.SetBuiltinConstant("Status", def28); + def28.SetBuiltinConstant("Status", def29); #endif - def2.SetBuiltinConstant("EACCES", def34); + def2.SetBuiltinConstant("EACCES", def35); def2.SetBuiltinConstant("EADDRINUSE", def10); def2.SetBuiltinConstant("EBADF", def3); def2.SetBuiltinConstant("ECHILD", def11); @@ -337,11 +341,12 @@ namespace IronRuby.Builtins { def2.SetBuiltinConstant("ECONNREFUSED", def13); def2.SetBuiltinConstant("ECONNRESET", def14); def2.SetBuiltinConstant("EDOM", def15); - def2.SetBuiltinConstant("EEXIST", def19); - def2.SetBuiltinConstant("EINVAL", def21); - def2.SetBuiltinConstant("ENOENT", def32); + def2.SetBuiltinConstant("EEXIST", def20); + def2.SetBuiltinConstant("EINVAL", def22); + def2.SetBuiltinConstant("ENOENT", def33); + def2.SetBuiltinConstant("ENOEXEC", def19); def2.SetBuiltinConstant("ENOTCONN", def17); - def2.SetBuiltinConstant("ENOTDIR", def31); + def2.SetBuiltinConstant("ENOTDIR", def32); def2.SetBuiltinConstant("EPIPE", def18); def2.SetBuiltinConstant("EXDEV", def16); } @@ -1747,10 +1752,12 @@ namespace IronRuby.Builtins { new Func<IronRuby.Builtins.RubyIO, System.Int32, System.Int32, System.Int32>(IronRuby.Builtins.RubyIOOps.FileControl) ); + #if !SILVERLIGHT module.DefineLibraryMethod("isatty", 0x51, new Func<IronRuby.Builtins.RubyIO, System.Boolean>(IronRuby.Builtins.RubyIOOps.IsAtty) ); + #endif module.DefineLibraryMethod("lineno", 0x51, new Func<IronRuby.Builtins.RubyIO, System.Int32>(IronRuby.Builtins.RubyIOOps.GetLineNumber) ); @@ -1842,10 +1849,12 @@ namespace IronRuby.Builtins { new Func<IronRuby.Builtins.RubyIO, IronRuby.Builtins.RubyIO>(IronRuby.Builtins.RubyIOOps.ToIO) ); + #if !SILVERLIGHT module.DefineLibraryMethod("tty?", 0x51, new Func<IronRuby.Builtins.RubyIO, System.Boolean>(IronRuby.Builtins.RubyIOOps.IsAtty) ); + #endif module.DefineLibraryMethod("ungetc", 0x51, new Action<IronRuby.Builtins.RubyIO, System.Int32>(IronRuby.Builtins.RubyIOOps.SetPreviousByte) ); @@ -2925,8 +2934,8 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("printf", 0x52, - new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted), - new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted) + new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted), + new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted) ); module.DefineLibraryMethod("private_methods", 0x51, @@ -2951,10 +2960,10 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("puts", 0x52, + new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PutString), new Action<IronRuby.Runtime.BinaryOpStorage, System.Object>(IronRuby.Builtins.KernelOps.PutsEmptyLine), new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object>(IronRuby.Builtins.KernelOps.PutString), - new Action<IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.KernelOps.PutString), - new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PutString) + new Action<IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.KernelOps.PutString) ); module.DefineLibraryMethod("raise", 0x52, @@ -3239,8 +3248,8 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("printf", 0x61, - new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted), - new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted) + new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted), + new Action<IronRuby.Builtins.StringFormatterSiteStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PrintFormatted) ); module.DefineLibraryMethod("proc", 0x61, @@ -3253,10 +3262,10 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("puts", 0x61, + new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PutString), new Action<IronRuby.Runtime.BinaryOpStorage, System.Object>(IronRuby.Builtins.KernelOps.PutsEmptyLine), new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object>(IronRuby.Builtins.KernelOps.PutString), - new Action<IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.KernelOps.PutString), - new Action<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Object, System.Object[]>(IronRuby.Builtins.KernelOps.PutString) + new Action<IronRuby.Runtime.BinaryOpStorage, System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.KernelOps.PutString) ); module.DefineLibraryMethod("raise", 0x61, @@ -4350,6 +4359,10 @@ namespace IronRuby.Builtins { new Func<IronRuby.Builtins.RubyProcess.Status, System.Int32>(IronRuby.Builtins.RubyProcess.Status.ExitStatus) ); + module.DefineLibraryMethod("inspect", 0x51, + new Func<IronRuby.Builtins.RubyProcess.Status, IronRuby.Builtins.MutableString>(IronRuby.Builtins.RubyProcess.Status.Inspect) + ); + module.DefineLibraryMethod("pid", 0x51, new Func<IronRuby.Builtins.RubyProcess.Status, System.Int32>(IronRuby.Builtins.RubyProcess.Status.Pid) ); @@ -4373,6 +4386,12 @@ namespace IronRuby.Builtins { } #endif + #if !SILVERLIGHT && !SILVERLIGHT + private static void LoadProcess__Status_Class(IronRuby.Builtins.RubyModule/*!*/ module) { + module.HideMethod("new"); + } + #endif + private static void LoadRange_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("==", 0x51, new Func<IronRuby.Builtins.Range, System.Object, System.Boolean>(IronRuby.Builtins.RangeOps.Equals), @@ -8667,3 +8686,37 @@ namespace IronRuby.StandardLibrary.Open3 { } } +namespace IronRuby.StandardLibrary.Win32API { + using System; + using Microsoft.Scripting.Utils; + + public sealed class Win32APILibraryInitializer : IronRuby.Builtins.LibraryInitializer { + protected override void LoadModules() { + IronRuby.Builtins.RubyClass classRef0 = GetClass(typeof(System.Object)); + + + #if !SILVERLIGHT + DefineGlobalClass("Win32API", typeof(IronRuby.StandardLibrary.Win32API.Win32API), 0x00000100, classRef0, LoadWin32API_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + new Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.StandardLibrary.Win32API.Win32API>(IronRuby.StandardLibrary.Win32API.Win32API.Create), + new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, System.Collections.IList, IronRuby.Builtins.MutableString, IronRuby.StandardLibrary.Win32API.Win32API>(IronRuby.StandardLibrary.Win32API.Win32API.Create) + ); + #endif + } + + #if !SILVERLIGHT + private static void LoadWin32API_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { + module.DefineRuleGenerator("call", 0x11, IronRuby.StandardLibrary.Win32API.Win32API.Call()); + + module.DefineRuleGenerator("Call", 0x11, IronRuby.StandardLibrary.Win32API.Win32API.Call()); + + module.DefineLibraryMethod("initialize", 0x12, + new Func<IronRuby.StandardLibrary.Win32API.Win32API, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.StandardLibrary.Win32API.Win32API>(IronRuby.StandardLibrary.Win32API.Win32API.Reinitialize), + new Func<IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>, IronRuby.StandardLibrary.Win32API.Win32API, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, System.Collections.IList, IronRuby.Builtins.MutableString, IronRuby.StandardLibrary.Win32API.Win32API>(IronRuby.StandardLibrary.Win32API.Win32API.Reinitialize) + ); + + } + #endif + + } +} + Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.Build.csproj @@ -189,6 +189,7 @@ <Compile Include="Thread\RubyMutex.cs" /> <Compile Include="Thread\RubyQueue.cs" /> <Compile Include="Thread\SizedQueue.cs" /> + <Compile Include="Win32API\Win32API.cs" /> <Compile Include="Zlib\zlib.cs" /> </ItemGroup> <ItemGroup> Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj @@ -29,7 +29,7 @@ namespace IronRuby.StandardLibrary.Open3 { object self, [DefaultProtocol, NotNull]MutableString/*!*/ command) { - Process process = RubyIOOps.OpenPipe(context, command, true, true, true); + Process process = RubyProcess.CreateProcess(context, command, true, true, true); RubyArray result = new RubyArray(); result.Add(new RubyIO(context, null, process.StandardInput, IOMode.WriteOnly)); result.Add(new RubyIO(context, process.StandardOutput, null, IOMode.ReadOnly)); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Open3/Open3.cs @@ -13,6 +13,10 @@ * * ***************************************************************************/ +#if !SILVERLIGHT +using System.IO.Compression; +#endif + using System; using System.Collections.Generic; using System.IO; @@ -21,9 +25,6 @@ using IronRuby.Builtins; using IronRuby.Runtime; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Generation; -#if !SILVERLIGHT - using System.IO.Compression; -#endif using System.Diagnostics; using System.Text; using System.Runtime.InteropServices; Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Zlib/zlib.cs @@ -154,8 +154,8 @@ Global {2AE75F5A-CD1F-4925-9647-AF4D1C282FB4}.V4 Release|Any CPU.Build.0 = Release|Any CPU {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.Debug|Any CPU.Build.0 = Debug|Any CPU - {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.FxCop|Any CPU.ActiveCfg = Release|Any CPU - {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.FxCop|Any CPU.Build.0 = Release|Any CPU + {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.FxCop|Any CPU.ActiveCfg = FxCop|Any CPU + {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.FxCop|Any CPU.Build.0 = FxCop|Any CPU {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.Release|Any CPU.ActiveCfg = Release|Any CPU {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.Release|Any CPU.Build.0 = Release|Any CPU {77323B06-15A2-4CF4-8A7A-86EAA2B66498}.Silverlight Debug|Any CPU.ActiveCfg = Silverlight Debug|Any CPU Merlin/Main/Languages/Ruby/Ruby.sln @@ -25,7 +25,7 @@ namespace IronRuby.Builtins { /// <summary> /// A custom Stream class that forwards calls to Console In/Out/Error based on ConsoleType /// </summary> - internal class ConsoleStream : Stream { + internal sealed class ConsoleStream : Stream { private ConsoleStreamType _consoleType; private readonly SharedIO _io; @@ -35,6 +35,10 @@ namespace IronRuby.Builtins { _io = io; } + public ConsoleStreamType StreamType { + get { return _consoleType; } + } + public override bool CanRead { get { return _consoleType == ConsoleStreamType.Input ? true : false; } } Merlin/Main/Languages/Ruby/Ruby/Builtins/ConsoleStream.cs @@ -238,6 +238,21 @@ namespace IronRuby.Builtins { } [Serializable] + public class ExecFormatError : ExternalException { + private const string/*!*/ M = "Exec format error"; + + public ExecFormatError() : this(null, null) { } + public ExecFormatError(string message) : this(message, null) { } + public ExecFormatError(string message, Exception inner) : base(RubyExceptions.MakeMessage(message, M), inner) { } + public ExecFormatError(MutableString message) : base(RubyExceptions.MakeMessage(ref message, M)) { RubyExceptionData.InitializeException(this, message); } + +#if !SILVERLIGHT + protected ExecFormatError(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) + : base(info, context) { } +#endif + } + + [Serializable] public class InvalidError : ExternalException { private const string/*!*/ M = "Invalid argument"; Merlin/Main/Languages/Ruby/Ruby/Builtins/Exceptions.cs @@ -122,10 +122,14 @@ namespace IronRuby.Builtins { _fileDescriptor = value; } - public bool IsConsole { + /// <summary> + /// Returns true if the IO object represents stdin/stdout/stderr (no matter whether or not the actual streams are redirected). + /// </summary> + public ConsoleStreamType? ConsoleStreamType { get { var stream = GetStream(); - return stream.BaseStream is ConsoleStream || stream.BaseStream == Stream.Null; + var console = stream.BaseStream as ConsoleStream; + return console != null ? console.StreamType : (ConsoleStreamType?)null; } } Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyIO.cs @@ -248,6 +248,8 @@ namespace IronRuby.Compiler { private static MethodInfo _GetMethodUnwinderReturnValue; public static MethodInfo/*!*/ GetMissingConstant { get { return _GetMissingConstant ?? (_GetMissingConstant = GetMethod(typeof(RubyOps), "GetMissingConstant")); } } private static MethodInfo _GetMissingConstant; + public static MethodInfo/*!*/ GetMutableStringBytes { get { return _GetMutableStringBytes ?? (_GetMutableStringBytes = GetMethod(typeof(RubyOps), "GetMutableStringBytes")); } } + private static MethodInfo _GetMutableStringBytes; public static MethodInfo/*!*/ GetParentLocals { get { return _GetParentLocals ?? (_GetParentLocals = GetMethod(typeof(RubyOps), "GetParentLocals")); } } private static MethodInfo _GetParentLocals; public static MethodInfo/*!*/ GetParentScope { get { return _GetParentScope ?? (_GetParentScope = GetMethod(typeof(RubyOps), "GetParentScope")); } } @@ -300,8 +302,6 @@ namespace IronRuby.Compiler { private static MethodInfo _IsClrSingletonRuleValid; public static MethodInfo/*!*/ IsDefinedClassVariable { get { return _IsDefinedClassVariable ?? (_IsDefinedClassVariable = GetMethod(typeof(RubyOps), "IsDefinedClassVariable")); } } private static MethodInfo _IsDefinedClassVariable; - public static MethodInfo/*!*/ IsDefinedExpressionConstant { get { return _IsDefinedExpressionConstant ?? (_IsDefinedExpressionConstant = GetMethod(typeof(RubyOps), "IsDefinedExpressionConstant")); } } - private static MethodInfo _IsDefinedExpressionConstant; public static MethodInfo/*!*/ IsDefinedExpressionQualifiedConstant { get { return _IsDefinedExpressionQualifiedConstant ?? (_IsDefinedExpressionQualifiedConstant = GetMethod(typeof(RubyOps), "IsDefinedExpressionQualifiedConstant")); } } private static MethodInfo _IsDefinedExpressionQualifiedConstant; public static MethodInfo/*!*/ IsDefinedGlobalConstant { get { return _IsDefinedGlobalConstant ?? (_IsDefinedGlobalConstant = GetMethod(typeof(RubyOps), "IsDefinedGlobalConstant")); } } Merlin/Main/Languages/Ruby/Ruby/Compiler/ReflectionCache.Generated.cs @@ -17,6 +17,7 @@ using System; using IronRuby.Builtins; using IronRuby.Runtime; using Microsoft.Scripting; +using Microsoft.Scripting.Hosting; using Microsoft.Scripting.Hosting.Shell; using Microsoft.Scripting.Runtime; using System.Reflection; @@ -65,13 +66,21 @@ namespace IronRuby.Hosting { return RunFile(Engine.CreateScriptSourceFromFile(RubyUtils.CanonicalizePath(fileName), (((RubyContext)Language).RubyOptions.KCode ?? RubyEncoding.Binary).Encoding)); } - protected override void ExecuteCommand(string command) { + protected override void ExecuteCommand(string/*!*/ command) { + ExecuteCommand(CreateCommandSource(command, SourceCodeKind.InteractiveCode)); + } + + protected override int RunCommand(string/*!*/ command) { + return RunFile(CreateCommandSource(command, SourceCodeKind.Statements)); + } + + private ScriptSource/*!*/ CreateCommandSource(string/*!*/ command, SourceCodeKind kind) { #if SILVERLIGHT - base.ExecuteCommand(command); + return Engine.CreateScriptSourceFromString(command, kind); #else var kcode = ((RubyContext)Language).RubyOptions.KCode; var encoding = kcode != null ? kcode.Encoding : System.Console.InputEncoding; - ExecuteCommand(Engine.CreateScriptSource(new BinaryContentProvider(encoding.GetBytes(command)), null, encoding, SourceCodeKind.InteractiveCode)); + return Engine.CreateScriptSource(new BinaryContentProvider(encoding.GetBytes(command)), null, encoding, kind); #endif } Merlin/Main/Languages/Ruby/Ruby/Hosting/RubyCommandLine.cs @@ -38,7 +38,7 @@ using AstUtils = Microsoft.Scripting.Ast.Utils; namespace IronRuby.Runtime.Calls { using Ast = Expression; - internal sealed class RubyOverloadResolver : OverloadResolver { + public sealed class RubyOverloadResolver : OverloadResolver { private readonly CallArguments/*!*/ _args; private readonly MetaObjectBuilder/*!*/ _metaBuilder; private readonly SelfCallConvention _callConvention; @@ -58,19 +58,19 @@ namespace IronRuby.Runtime.Calls { private ParameterExpression _listVariable; private IList _list; - public RubyContext/*!*/ Context { + internal RubyContext/*!*/ Context { get { return _args.RubyContext; } } - public Expression/*!*/ ScopeExpression { + internal Expression/*!*/ ScopeExpression { get { return _args.MetaScope.Expression; } } - public Expression/*!*/ ContextExpression { + internal Expression/*!*/ ContextExpression { get { return _args.MetaContext.Expression; } } - public RubyOverloadResolver(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, SelfCallConvention callConvention, + internal RubyOverloadResolver(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, SelfCallConvention callConvention, bool implicitProtocolConversions) : base(args.RubyContext.Binder) { _args = args; Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyOverloadResolver.cs @@ -2475,8 +2475,8 @@ namespace IronRuby.Runtime { return new InteropBinder.CreateInstance(this, callInfo); } - public override ConvertBinder/*!*/ CreateConvertBinder(Type toType, bool explicitCast) { - return new InteropBinder.Convert(this, toType, explicitCast); + public override ConvertBinder/*!*/ CreateConvertBinder(Type toType, bool? explicitCast) { + return new InteropBinder.Convert(this, toType, explicitCast ?? true); } // TODO: override GetMemberNames? Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs @@ -1572,11 +1572,22 @@ namespace IronRuby.Runtime { #endregion + #region Strings, Encodings + [Emitted] public static RubyEncoding/*!*/ CreateEncoding(int codepage) { return RubyEncoding.GetRubyEncoding(codepage); } + [Emitted, Obsolete("Internal only")] + public static byte[]/*!*/ GetMutableStringBytes(MutableString/*!*/ str) { + return str.GetByteArray(); + } + + #endregion + + #region Booleans + [Emitted] public static bool IsTrue(object obj) { return (obj is bool) ? (bool)obj == true : obj != null; @@ -1597,6 +1608,8 @@ namespace IronRuby.Runtime { return (obj is bool && !(bool)obj || obj == null) ? DefaultArgument : null; } + #endregion + #region Exceptions // @@ -1828,6 +1841,8 @@ namespace IronRuby.Runtime { return module == _currentDeclaringModule && methodName == _currentMethodName; } + #region Ranges + [Emitted] public static Range/*!*/ CreateInclusiveRange(object begin, object end, RubyScope/*!*/ scope, BinaryOpStorage/*!*/ comparisonStorage) { return new Range(comparisonStorage, scope.RubyContext, begin, end, false); @@ -1848,11 +1863,7 @@ namespace IronRuby.Runtime { return new Range(begin, end, true); } - [Emitted] - public static object CreateDefaultInstance() { - // nop (stub) - return null; - } + #endregion #region Dynamic Operations @@ -2358,5 +2369,11 @@ namespace IronRuby.Runtime { [Emitted] public static void X(string marker) { } + + [Emitted] + public static object CreateDefaultInstance() { + // nop (stub) + return null; + } } } Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs @@ -57,7 +57,7 @@ namespace IronRuby.Runtime { } else { codeLine = null; } - encoding = RubyEncoding.GetRubyEncoding(reader.Encoding); + encoding = reader.Encoding != null ? RubyEncoding.GetRubyEncoding(reader.Encoding) : RubyEncoding.UTF8; } } else { path = null; Merlin/Main/Languages/Ruby/Ruby/Runtime/RuntimeErrorSink.cs @@ -203,14 +203,16 @@ namespace Microsoft.Scripting.Hosting { } /// <summary> - /// Convers the object obj to the type T. + /// Converts the object obj to the type T. The conversion will be explicit or implicit depending on + /// what the langauge prefers. /// </summary> public T ConvertTo<T>(object obj) { return _ops.ConvertTo<T>(obj); } /// <summary> - /// Converts the object obj to the type type. + /// Converts the object obj to the type type. The conversion will be explicit or implicit depending on + /// what the langauge prefers. /// </summary> public object ConvertTo(object obj, Type type) { ContractUtils.RequiresNotNull(type, "type"); @@ -220,6 +222,8 @@ namespace Microsoft.Scripting.Hosting { /// <summary> /// Converts the object obj to the type T. Returns true if the value can be converted, false if it cannot. + /// + /// The conversion will be explicit or implicit depending on what the langauge prefers. /// </summary> public bool TryConvertTo<T>(object obj, out T result) { return _ops.TryConvertTo<T>(obj, out result); @@ -227,6 +231,8 @@ namespace Microsoft.Scripting.Hosting { /// <summary> /// Converts the object obj to the type type. Returns true if the value can be converted, false if it cannot. + /// + /// The conversion will be explicit or implicit depending on what the langauge prefers. /// </summary> public bool TryConvertTo(object obj, Type type, out object result) { return _ops.TryConvertTo(obj, type, out result); @@ -268,6 +274,40 @@ namespace Microsoft.Scripting.Hosting { /// <summary> + /// Converts the object obj to the type T including implicit conversions. + /// </summary> + public T ImplicitConvertTo<T>(object obj) { + return _ops.ImplicitConvertTo<T>(obj); + } + + /// <summary> + /// Converts the object obj to the type type including implicit conversions. + /// </summary> + public object ImplicitConvertTo(object obj, Type type) { + ContractUtils.RequiresNotNull(type, "type"); + + return _ops.ImplicitConvertTo(obj, type); + } + + /// <summary> + /// Converts the object obj to the type T including implicit conversions. + /// + /// Returns true if the value can be converted, false if it cannot. + /// </summary> + public bool TryImplicitConvertTo<T>(object obj, out T result) { + return _ops.TryImplicitConvertTo<T>(obj, out result); + } + + /// <summary> + /// Converts the object obj to the type type including implicit conversions. + /// + /// Returns true if the value can be converted, false if it cannot. + /// </summary> + public bool TryImplicitConvertTo(object obj, Type type, out object result) { + return _ops.TryImplicitConvertTo(obj, type, out result); + } + + /// <summary> /// Performs a generic unary operation on the specified target and returns the result. /// </summary> public dynamic DoOperation(ExpressionType operation, object target) { Merlin/Main/Runtime/Microsoft.Scripting/Hosting/ObjectOperations.cs @@ -82,7 +82,7 @@ namespace Microsoft.Scripting { _showClrExceptions = GetOption(options, "ShowClrExceptions", false); _perfStats = GetOption(options, "PerfStats", false); _noAdaptiveCompilation = GetOption(options, "NoAdaptiveCompilation", false); - _searchPaths = GetSearchPathsOption(options) ?? new ReadOnlyCollection<string>(new[] { "." }); + _searchPaths = GetSearchPathsOption(options) ?? new ReadOnlyCollection<string>(new string[0]); } public static T GetOption<T>(IDictionary<string, object> options, string name, T defaultValue) { Merlin/Main/Runtime/Microsoft.Scripting/LanguageOptions.cs @@ -227,21 +227,23 @@ namespace Microsoft.Scripting.Runtime { } /// <summary> - /// Convers the object obj to the type T. + /// Converts the object obj to the type T. The conversion will be explicit or implicit + /// depending on what the langauge prefers. /// </summary> public T ConvertTo<T>(object obj) { CallSite<Func<CallSite, object, T>> site; - site = GetOrCreateSite<object, T>(_lc.CreateConvertBinder(typeof(T), false)); + site = GetOrCreateSite<object, T>(_lc.CreateConvertBinder(typeof(T), null)); return site.Target(site, obj); } - /// <summary> - /// Converts the object obj to the type type. + /// <summary> + /// Converts the object obj to the type type. The conversion will be explicit or implicit + /// depending on what the langauge prefers. /// </summary> public object ConvertTo(object obj, Type type) { if (type.IsInterface || type.IsClass) { CallSite<Func<CallSite, object, object>> site; - site = GetOrCreateSite<object, object>(_lc.CreateConvertBinder(type, false)); + site = GetOrCreateSite<object, object>(_lc.CreateConvertBinder(type, null)); return site.Target(site, obj); } @@ -261,6 +263,8 @@ namespace Microsoft.Scripting.Runtime { /// <summary> /// Converts the object obj to the type T. Returns true if the value can be converted, false if it cannot. + /// + /// The conversion will be explicit or implicit depending on what the langauge prefers. /// </summary> public bool TryConvertTo<T>(object obj, out T result) { try { @@ -277,6 +281,8 @@ namespace Microsoft.Scripting.Runtime { /// <summary> /// Converts the object obj to the type type. Returns true if the value can be converted, false if it cannot. + /// + /// The conversion will be explicit or implicit depending on what the langauge prefers. /// </summary> public bool TryConvertTo(object obj, Type type, out object result) { try { @@ -344,6 +350,58 @@ namespace Microsoft.Scripting.Runtime { } /// <summary> + /// Convers the object obj to the type T including implicit conversions. + /// </summary> + public T ImplicitConvertTo<T>(object obj) { + CallSite<Func<CallSite, object, T>> site; + site = GetOrCreateSite<object, T>(_lc.CreateConvertBinder(typeof(T), false)); + return site.Target(site, obj); + } + + /// <summary> + /// Converts the object obj to the type type including implicit conversions. + /// </summary> + public object ImplicitConvertTo(object obj, Type type) { + CallSite<Func<CallSite, object, object>> site; + site = GetOrCreateSite<object, object>(_lc.CreateConvertBinder(type, false)); + return site.Target(site, obj); + } + + /// <summary> + /// Converts the object obj to the type type including implicit conversions. + /// + /// Returns true if the value can be converted, false if it cannot. + /// </summary> + public bool TryImplicitConvertTo(object obj, Type type, out object result) { + try { + result = ImplicitConvertTo(obj, type); + return true; + } catch (ArgumentTypeException) { + result = null; + return false; + } catch (InvalidCastException) { + result = null; + return false; + } + } + + /// <summary> + /// Converts the object obj to the type T. Returns true if the value can be converted, false if it cannot. + /// </summary> + public bool TryImplicitConvertTo<T>(object obj, out T result) { + try { + result = ImplicitConvertTo<T>(obj); + return true; + } catch (ArgumentTypeException) { + result = default(T); + return false; + } catch (InvalidCastException) { + result = default(T); + return false; + } + } + + /// <summary> /// Performs a generic unary operation on the strongly typed target and returns the value as the specified type /// </summary> public TResult DoOperation<TTarget, TResult>(ExpressionType operation, TTarget target) { Merlin/Main/Runtime/Microsoft.Scripting/Runtime/DynamicOperations.cs @@ -344,8 +344,17 @@ namespace Microsoft.Scripting.Runtime { } } - public virtual ConvertBinder CreateConvertBinder(Type toType, bool explicitCast) { - return new DefaultConvertAction(toType, explicitCast); + /// <summary> + /// Creates a conversion binder. + /// + /// If explicitCast is true then the binder should do explicit conversions. + /// If explicitCast is false then the binder should do implicit conversions. + /// + /// If explicitCast is null it is up to the language to select the conversions + /// which closest match their normal behavior. + /// </summary> + public virtual ConvertBinder CreateConvertBinder(Type toType, bool? explicitCast) { + return new DefaultConvertAction(toType, explicitCast ?? false); } private class DefaultGetMemberAction : GetMemberBinder { Merlin/Main/Runtime/Microsoft.Scripting/Runtime/LanguageContext.cs @@ -203,7 +203,7 @@ namespace Microsoft.Scripting { new[] { tmp }, Expression.Condition( Expression.Call( - Expression.Constant(variable), + Variable(variable), variable.GetType().GetMethod("TryGetValue"), tmp ), @@ -215,6 +215,17 @@ namespace Microsoft.Scripting { ); } + private static Expression Variable(IScopeVariable variable) { + + return Expression.Convert( + Expression.Property( + Expression.Constant(((IWeakReferencable)variable).WeakReference), + typeof(WeakReference).GetProperty("Target") + ), + variable.GetType() + ); + } + public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value) { IScopeVariable variable = Value.GetVariable(binder.Name, binder.IgnoreCase); @@ -222,7 +233,7 @@ namespace Microsoft.Scripting { return new DynamicMetaObject( Expression.Block( Expression.Call( - Expression.Constant(variable), + Variable(variable), variable.GetType().GetMethod("SetValue"), objExpression ), @@ -237,7 +248,7 @@ namespace Microsoft.Scripting { return new DynamicMetaObject( Expression.Condition( Expression.Call( - Expression.Constant(variable), + Variable(variable), variable.GetType().GetMethod("DeleteValue") ), Expression.Default(binder.ReturnType), @@ -291,6 +302,12 @@ namespace Microsoft.Scripting { bool DeleteValue(); } + internal interface IWeakReferencable { + WeakReference WeakReference { + get; + } + } + /// <summary> /// Boxes the value for storage in a scope. Languages or consumers of the scope /// can save this value and use it to get/set the current value in the scope for @@ -298,8 +315,9 @@ namespace Microsoft.Scripting { /// /// ScopeVariables are case sensitive and will only refer to a single value. /// </summary> - public sealed class ScopeVariable : IScopeVariable { + public sealed class ScopeVariable : IScopeVariable, IWeakReferencable { private object _value; + private WeakReference _weakref; private static readonly object _novalue = new object(); internal ScopeVariable() { @@ -345,6 +363,20 @@ namespace Microsoft.Scripting { } #endregion + + #region IWeakReferencable Members + + public WeakReference WeakReference { + get { + if (_weakref == null) { + _weakref = new WeakReference(this); + } + + return _weakref; + } + } + + #endregion } /// <summary> @@ -355,9 +387,10 @@ namespace Microsoft.Scripting { /// ScopeVariablesIgnoreCase are case insensitive and may access different casings /// depending on how other gets/sets occur in the scope. /// </summary> - public sealed class ScopeVariableIgnoreCase : IScopeVariable { + public sealed class ScopeVariableIgnoreCase : IScopeVariable, IWeakReferencable { private readonly string _firstCasing; private readonly ScopeVariable _firstVariable; + private WeakReference _weakref; private Dictionary<string, ScopeVariable> _overflow; internal ScopeVariableIgnoreCase(string casing) { @@ -496,5 +529,19 @@ namespace Microsoft.Scripting { } #endregion + + #region IWeakReferencable Members + + public WeakReference WeakReference { + get { + if (_weakref == null) { + _weakref = new WeakReference(this); + } + + return _weakref; + } + } + + #endregion } } Merlin/Main/Runtime/Microsoft.Scripting/Runtime/ScopeStorage.cs @@ -361,11 +361,11 @@ namespace Microsoft.Scripting { } /// <summary> - /// A string like "pecified path is invalid." + /// A string like "Specified path is invalid." /// </summary> internal static string InvalidPath { get { - return "pecified path is invalid."; + return "Specified path is invalid."; } } @@ -790,7 +790,7 @@ namespace Microsoft.Scripting { } /// <summary> - /// ArgumentException with message like "pecified path is invalid." + /// ArgumentException with message like "Specified path is invalid." /// </summary> internal static Exception InvalidPath() { return new ArgumentException(Strings.InvalidPath); Merlin/Main/Runtime/Microsoft.Scripting/Utils/ExceptionFactory.Generated.cs Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/language/execution_tags.txt 03054a5be81928afaacd16b5ef5d4067f7ecc69a Jim Deville jdeville@microsoft.com http://github.com/shri/ironruby/commit/7d9391319aa533fe3be3cee1462452dd093e9bef 7d9391319aa533fe3be3cee1462452dd093e9bef 2009-09-30T22:07:46-07:00 2009-09-30T22:07:46-07:00 syncing to head of tfs 29e748e91aedfb67d12e277ad4653c085a1ebdae Jim Deville jdeville@microsoft.com