public static RubyTopLevelScope/*!*/ CreateMainTopLevelScope(LocalsDictionary/*!*/ locals, Scope/*!*/ globalScope, LanguageContext/*!*/ language,
            out object self, out RuntimeFlowControl/*!*/ rfc, string dataPath, int dataOffset) {
            Assert.NotNull(locals, globalScope, language);

            GlobalScopeExtension rubyGlobalScope = (GlobalScopeExtension)language.EnsureScopeExtension(globalScope);

            RubyTopLevelScope scope = new RubyTopLevelScope(rubyGlobalScope, null, locals);
            scope.Initialize(new RuntimeFlowControl(), RubyMethodAttributes.PrivateInstance, rubyGlobalScope.MainObject);
            scope.SetDebugName(rubyGlobalScope.IsHosted ? "top-primary-hosted" : "top-primary");

            // define TOPLEVEL_BINDING constant:
            if (!rubyGlobalScope.IsHosted) {
                var objectClass = rubyGlobalScope.Context.ObjectClass;
                    
                objectClass.SetConstant("TOPLEVEL_BINDING", new Binding(scope));
                if (dataOffset >= 0) {
                    RubyFile dataFile;
                    if (File.Exists(dataPath)) {
                        dataFile = new RubyFile(rubyGlobalScope.Context, dataPath, RubyFileMode.RDONLY);
                        dataFile.Seek(dataOffset, SeekOrigin.Begin);
                    } else {
                        dataFile = null;
                    }

                    objectClass.SetConstant("DATA", dataFile);
                }
            }

            self = scope.SelfObject;
            rfc = scope.RuntimeFlowControl;

            return scope;
        }

        public static RubyTopLevelScope/*!*/ CreateMainTopLevelScope(LocalsDictionary/*!*/ locals, Scope/*!*/ globalScope, LanguageContext/*!*/ language,
            out object self, out RuntimeFlowControl/*!*/ rfc, string dataPath, int dataOffset) {
            Assert.NotNull(locals, globalScope, language);

            RubyContext context = (RubyContext)language;
            RubyGlobalScope rubyGlobalScope = context.InitializeGlobalScope(globalScope, false);

            RubyTopLevelScope scope = new RubyTopLevelScope(rubyGlobalScope, null, locals);
            scope.Initialize(new RuntimeFlowControl(), RubyMethodAttributes.PrivateInstance, rubyGlobalScope.MainObject);
            scope.SetDebugName("top-main");

            var objectClass = context.ObjectClass;
            objectClass.SetConstant("TOPLEVEL_BINDING", new Binding(scope));
            if (dataOffset >= 0) {
                RubyFile dataFile;
                if (context.DomainManager.Platform.FileExists(dataPath)) {
                    dataFile = new RubyFile(context, dataPath, RubyFileMode.RDONLY);
                    dataFile.Seek(dataOffset, SeekOrigin.Begin);
                } else {
                    dataFile = null;
                }

                objectClass.SetConstant("DATA", dataFile);
            }

            self = scope.SelfObject;
            rfc = scope.RuntimeFlowControl;

            return scope;
        }

        public static void SetDataConstant(RubyScope/*!*/ scope, string/*!*/ dataPath, int dataOffset) {
            Debug.Assert(dataOffset >= 0);
            RubyFile dataFile;
            RubyContext context = scope.RubyContext;
            if (context.DomainManager.Platform.FileExists(dataPath)) {
                dataFile = new RubyFile(context, dataPath, RubyFileMode.RDONLY);
                dataFile.Seek(dataOffset, SeekOrigin.Begin);
            } else {
                dataFile = null;
            }

            context.ObjectClass.SetConstant("DATA", dataFile);
        }

        public static RubyFile/*!*/ Reinitialize(
            ConversionStorage<int?>/*!*/ toInt,
            ConversionStorage<IDictionary<object, object>>/*!*/ toHash,
            ConversionStorage<MutableString>/*!*/ toPath,
            ConversionStorage<MutableString>/*!*/ toStr,
            RubyFile/*!*/ self,
            object descriptorOrPath, 
            [Optional]object optionsOrMode, 
            [Optional]object optionsOrPermissions,
            [DefaultParameterValue(null), DefaultProtocol]IDictionary<object, object> options) {

            var context = self.Context;
            
            Protocols.TryConvertToOptions(toHash, ref options, ref optionsOrMode, ref optionsOrPermissions);
            var toIntSite = toInt.GetSite(TryConvertToFixnumAction.Make(toInt.Context));

            IOInfo info = new IOInfo();
            if (optionsOrMode != Missing.Value) {
                int? m = toIntSite.Target(toIntSite, optionsOrMode);
                info = m.HasValue ? new IOInfo((IOMode)m) : IOInfo.Parse(context, Protocols.CastToString(toStr, optionsOrMode));
            }

            int permissions = 0;
            if (optionsOrPermissions != Missing.Value) {
                int? p = toIntSite.Target(toIntSite, optionsOrPermissions);
                if (!p.HasValue) {
                    throw RubyExceptions.CreateTypeConversionError(context.GetClassName(optionsOrPermissions), "Integer");
                }
                permissions = p.Value;
            }

            if (options != null) {
                info = info.AddOptions(toStr, options);
            }

            // TODO: permissions
            
            // descriptor or path:
            int? descriptor = toIntSite.Target(toIntSite, descriptorOrPath);
            if (descriptor.HasValue) {
                RubyIOOps.Reinitialize(self, descriptor.Value, info);
            } else {
                Reinitialize(self, Protocols.CastToPath(toPath, descriptorOrPath), info, permissions);
            }

            return self;
        }

        public static RubyFile/*!*/ Reinitialize(RubyFile/*!*/ self,
            [DefaultProtocol, NotNull]Union<int, MutableString> descriptorOrPath, int mode, [Optional]int permission) {

            // TODO: remove duplicity (constructors vs initializers)

            if (descriptorOrPath.IsFixnum()) {
                RubyIOOps.Reinitialize(self, descriptorOrPath.Fixnum(), mode);
            } else {
                var path = self.Context.DecodePath(descriptorOrPath.Second);
                var stream = RubyFile.OpenFileStream(self.Context, path, (IOMode)mode);

                self.Path = path;
                self.Mode = (IOMode)mode;
                self.SetStream(stream);
                self.SetFileDescriptor(self.Context.AllocateFileDescriptor(stream));
            }
            // TODO: permission
            return self;
        }

 public static int SysOpen(RubyClass/*!*/ self, [NotNull]MutableString path, [Optional]MutableString mode, [Optional]int perm) {
     if (FileTest.DirectoryExists(self.Context, path)) {
         // TODO: What file descriptor should be returned for a directory?
         return -1;
     }
     RubyIO io = new RubyFile(self.Context, path.ToString(), IOModeEnum.Parse(mode));
     int fileDesc = io.GetFileDescriptor();
     io.Close();
     return fileDesc;
 }

        public static MutableString/*!*/ Binread(RubyClass/*!*/ self,
            [DefaultProtocol, NotNull]MutableString/*!*/ path,
            [DefaultProtocol, Optional]int? length,
            [DefaultProtocol, Optional]int? offset)
        {
            if (offset.HasValue && offset.Value < 0) {
                throw RubyExceptions.CreateEINVAL();
            }

            if (length.HasValue && length.Value < 0) {
                throw RubyExceptions.CreateArgumentError("negative length {0} given", length);
            }

            using (RubyIO io = new RubyFile(self.Context, path.ToString(), IOMode.ReadOnly)) {
                if (offset.HasValue && offset.Value > 0) {
                    io.Seek(offset.Value, SeekOrigin.Begin);
                }

                return (length.HasValue) ? Read(io, length.Value, null) : Read(io);
            }
        }

 public static object Open(BlockParam block, RubyClass/*!*/ self,
     [DefaultProtocol, NotNull]MutableString/*!*/ path,
     [DefaultParameterValue(0)]int level,
     [DefaultParameterValue(DEFAULT_STRATEGY)]int strategy)
 {
     var strPath = self.Context.DecodePath(path);
     var file = new RubyFile(self.Context, strPath, IOMode.WriteOnly | IOMode.Truncate | IOMode.CreateIfNotExists);
     var gzipWriter = Create(self, file, level, strategy);
     return gzipWriter.Do(block);
 }

 // TODO: should work for IO and files w/o paths:
 internal static FileSystemInfo/*!*/ Create(RubyFile/*!*/ file) {
     file.RequireInitialized();
     if (file.Path == null) {
         throw new NotSupportedException("TODO: cannot get file info for files without path");
     }
     return Create(file.Context, file.Path);
 }

 public static MutableString/*!*/ Inspect(RubyFile/*!*/ self) {
     return MutableString.CreateMutable(self.Context.GetPathEncoding()).
         Append("#<").
         Append(self.Context.GetClassOf(self).GetName(self.Context)).
         Append(':').
         Append(self.Path).
         Append(self.Closed ? " (closed)" : "").
         Append('>');
 }

 public static RubyTime ModifiedTime(RubyContext/*!*/ context, RubyFile/*!*/ self) {
     return RubyStatOps.ModifiedTime(RubyStatOps.Create(self));
 }

 public static object LoadFile(RubyScope/*!*/ scope, RubyModule/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ path) {
     using (RubyFile file = new RubyFile(self.Context, path.ConvertToString(), IOMode.Default)) {
         foreach (object obj in MakeConstructor(scope.GlobalScope, file.GetReadableStream())) {
             return obj;
         }
     }
     return null;
 }

 public static MutableString GetPath(RubyFile/*!*/ self) {
     return self.Path != null ? self.Context.EncodePath(self.Path) : null;
 }

 public static MutableString/*!*/ Inspect(RubyContext/*!*/ context, RubyFile/*!*/ self) {
     return MutableString.CreateMutable(context.GetPathEncoding()).
         Append("#<File:").
         Append(self.Path).
         Append(self.Closed ? " (closed)" : "").
         Append('>');
 }

 public static FileSystemInfo Stat(RubyContext/*!*/ context, RubyFile/*!*/ self) {
     return RubyStatOps.Create(context, self.Path);
 }

 public static RubyTime CreateTime(RubyContext/*!*/ context, RubyFile/*!*/ self) {
     return RubyStatOps.CreateTime(RubyStatOps.Create(context, self.Path));
 }

 public static RubyTime AccessTime(RubyContext/*!*/ context, RubyFile/*!*/ self) {
     return RubyStatOps.AccessTime(RubyStatOps.Create(self));
 }

 public static object ParseFile(RubyModule/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ path) {
     using (Stream stream = new RubyFile(self.Context, path.ConvertToString(), IOMode.Default).GetReadableStream()) {
         foreach (Node obj in MakeComposer(self.Context, stream)) {
             return obj;
         }
     }
     return ScriptingRuntimeHelpers.False;
 }

 public static FileSystemInfo Stat(RubyFile/*!*/ self) {
     return RubyStatOps.Create(self);
 }

 public static MutableString GetPath(RubyFile/*!*/ self) {
     self.RequireInitialized();
     return self.Path != null ? self.Context.EncodePath(self.Path) : null;
 }