// TODO: hack
        public RubyIO(RubyContext/*!*/ context, StreamReader reader, StreamWriter writer, string/*!*/ modeString)
            : this(context) {
            _mode = ParseIOMode(modeString, out _preserveEndOfLines);
            _stream = new DuplexStream(reader, writer);

            ResetLineNumbersForReadOnlyFiles(context);
        }

 /// <summary>
 /// Constructor for a parameter
 /// </summary>
 /// <param name="mode"></param>
 /// <param name="variableType"></param>
 public Parameter(string name,IOMode mode, VariableType variableType,int size)
 {
     this.mode = mode;
     this.variableType = variableType;
     this.name = name;
     this.size = size;
 }

        public static Stream/*!*/ OpenFileStream(RubyContext/*!*/ context, string/*!*/ path, IOMode mode) {
            ContractUtils.RequiresNotNull(path, "path");
            FileAccess access = mode.ToFileAccess();

            FileMode fileMode;
  
            if ((mode & IOMode.CreateIfNotExists) != 0) {
                if ((mode & IOMode.ErrorIfExists) != 0) {
                    access |= FileAccess.Write;
                    fileMode = FileMode.CreateNew;
                } else {
                    fileMode = FileMode.OpenOrCreate;
                }
            } else {
                fileMode = FileMode.Open;
            }

            if ((mode & IOMode.Truncate) != 0 && (access & FileAccess.Write) == 0) {
                throw RubyExceptions.CreateEINVAL("cannot truncate a file opened for reading only");
            }

            if ((mode & IOMode.WriteAppends) != 0 && (access & FileAccess.Write) == 0) {
                throw RubyExceptions.CreateEINVAL("cannot append to a file opened for reading only");
            }

            if (String.IsNullOrEmpty(path)) {
                throw RubyExceptions.CreateEINVAL();
            }

            Stream stream;
            if (path == "NUL") {
                stream = Stream.Null;
            } else {
                try {
                    stream = context.DomainManager.Platform.OpenInputFileStream(path, fileMode, access, FileShare.ReadWrite);
                } catch (FileNotFoundException) {
                    throw RubyExceptions.CreateENOENT(String.Format("No such file or directory - {0}", path));
                } catch (DirectoryNotFoundException e) {
                    throw RubyExceptions.CreateENOENT(e.Message, e);
                } catch (PathTooLongException e) {
                    throw RubyExceptions.CreateENOENT(e.Message, e);
                } catch (IOException) {
                    if ((mode & IOMode.ErrorIfExists) != 0) {
                        throw RubyExceptions.CreateEEXIST(path);
                    } else {
                        throw;
                    }
                } catch (ArgumentException e) {
                    throw RubyExceptions.CreateEINVAL(e.Message, e);
                }
            }

            if ((mode & IOMode.Truncate) != 0) {
                stream.SetLength(0);
            }

            return stream;
        }

 public RubyIO(RubyContext/*!*/ context, Stream/*!*/ stream, int descriptor, IOMode mode)
     : this(context)
 {
     ContractUtils.RequiresNotNull(context, "context");
     ContractUtils.RequiresNotNull(stream, "stream");
     SetStream(stream);
     _mode = mode;
     _fileDescriptor = descriptor;
 }

        private static MutableString/*!*/ CheckContent(MutableString/*!*/ content, IOMode mode) {
            if (content.IsFrozen && mode.CanWrite()) {
                throw Errno.CreateEACCES("Permission denied");
            }

            if ((mode & IOMode.Truncate) != 0) {
                content.Clear();
            }
            return content;
        }

        internal RubyInputProvider(RubyContext/*!*/ context, ICollection<string>/*!*/ arguments, RubyEncoding/*!*/ encoding) {
            Assert.NotNull(context, encoding);
            Assert.NotNullItems(arguments);
            _context = context;

            var args = new RubyArray();
            foreach (var arg in arguments) {
                ExpandArgument(args, arg, encoding);
            }

            _commandLineArguments = args;
            _lastInputLineNumber = 1;
            _currentFileIndex = -1;
            _singleton = new object();
            _defaultMode = IOMode.ReadOnly;
        }

 public RubyFile(RubyContext/*!*/ context, Stream/*!*/ stream, int descriptor, IOMode mode)
     : base(context, stream, descriptor, mode) {
     _path = null;
 }

 public void Reset(Stream/*!*/ stream, IOMode mode) {
     _mode = mode;
     SetStream(stream);
     SetFileDescriptor(Context.AllocateFileDescriptor(stream));
 }

 private List<Parameter> BuildParameterList(List<string> identifierList, TypeRecord variableType,
     IOMode ioMode,List<Parameter> parameterList)
 {
     foreach (string name in identifierList)
     {
         parameterList.Add(new Parameter(name,ioMode, variableType.variableType,1));
     }
     return parameterList;
 }

        public static RubyIO/*!*/ OpenPipe(
            RubyContext/*!*/ context, 
            MutableString/*!*/ command, 
            IOMode mode) {

            bool redirectStandardInput = mode.CanWrite();
            bool redirectStandardOutput = mode.CanRead();

            Process process = RubyProcess.CreateProcess(context, command, redirectStandardInput, redirectStandardOutput, false);

            StreamReader reader = null;
            StreamWriter writer = null;
            if (redirectStandardOutput) {
                reader = process.StandardOutput;
            }

            if (redirectStandardInput) {
                writer = process.StandardInput;
            }

            return new RubyIO(context, reader, writer, mode);
        }

        private static RubyIO CheckOpenPipe(RubyContext/*!*/ context, MutableString path, IOMode mode) {
            string fileName = path.ConvertToString();
            if (fileName.Length > 0 && fileName[0] == '|') {
#if SILVERLIGHT
                throw new NotSupportedException("open cannot create a subprocess");
#else
                if (fileName.Length > 1 && fileName[1] == '-') {
                    throw new NotImplementedError("forking a process is not supported");
                }
                return RubyIOOps.OpenPipe(context, path.GetSlice(1), (IOMode)mode);
#endif
            }
            return null;
        }

 public StringIO(MutableString/*!*/ content, IOMode mode) {
     ContractUtils.RequiresNotNull(content, "content");
     _content = content;
     _mode = mode;
 }

 public static bool IsReadable(IOMode mode) {
     return (mode == IOMode.ReadOnlyFromStart || 
         mode == IOMode.ReadWriteAppend || 
         mode == IOMode.ReadWriteFromStart || 
         mode == IOMode.ReadWriteTruncate);
 }

 public RubyFile(RubyContext/*!*/ context, MutableString/*!*/ path, IOMode mode)
     : this(context, context.DecodePath(path), mode) {
 }

        public override void Write(bool state)
        {
            Mode = IOMode.Output;

            _port.Write(state);
        }

		/**
		 * Sets the configuration of the given IO line of this XBee device.
		 * 
		 * @param ioLine The IO line to configure.
		 * @param ioMode The IO mode to set to the IO line.
		 * 
		 * @throws InterfaceNotOpenException if this device connection is not open.
		 * @throws ArgumentNullException if {@code ioLine == null} or
		 *                              if {@code ioMode == null}.
		 * @throws TimeoutException if there is a timeout sending the set 
		 *                          configuration command.
		 * @throws XBeeException if there is any other XBee related exception.
		 * 
		 * @see #getIOConfiguration(IOLine)
		 * @see com.digi.xbee.api.io.IOLine
		 * @see com.digi.xbee.api.io.IOMode
		 */
		public void setIOConfiguration(IOLine ioLine, IOMode ioMode)/*throws TimeoutException, XBeeException */{
			// Check IO line.
			if (ioLine == null)
				throw new ArgumentNullException("IO line cannot be null.");
			if (ioMode == null)
				throw new ArgumentNullException("IO mode cannot be null.");
			// Check connection.
			if (!connectionInterface.SerialPort.IsOpen)
				throw new InterfaceNotOpenException();

			SetParameter(ioLine.GetConfigurationATCommand(), new byte[] { (byte)ioMode.GetId() });
		}

 public RubyIO(RubyContext/*!*/ context, Stream/*!*/ stream, IOMode mode) 
     : this(context, stream, context.AllocateFileDescriptor(stream), mode) {
 }

 public void ResetIOMode(string/*!*/ modeString) {
     _mode = ParseIOMode(modeString, out _preserveEndOfLines);
 }

        public override bool Read()
        {
            Mode = IOMode.Input;

            return _port.Read();
        }

 private void Close() {
     _mode = _mode.Close();
 }