Esempio n. 1
0
        // Get length of file
        private uint swiFlen()
        {
            // Params:  file handle
            // Result:  r0 = length of file, -1 if error
            if (!fetchParams(1))
            {
                return(errorCode(Errno.EFAULT));
            }
            ARMSimStream astream = getStream(paramBlock[0]);

            if (astream == null)
            {
                return(uint.MaxValue);
            }
            try {
                long r = astream.Length();
                if (r >= 0)
                {
                    return((uint)r);
                }
            } catch (Exception) {
            }
            if (astream is ARMSimConsoleStream) // another kludge for Angel RDI
            {
                return(0);
            }
            return(errorCode(Errno.ENOTSUP));
        }
Esempio n. 2
0
        // Seek to an absolute file position
        private uint swiSeek()
        {
            // Params:  file handle, absolute file position in bytes
            // Result:  r0 = -1 if error, 0 otherwise
            if (!fetchParams(2))
            {
                return(errorCode(Errno.EFAULT));
            }
            ARMSimStream astream = getStream(paramBlock[0]);

            if (astream == null)
            {
                return(uint.MaxValue);
            }
            InputARMSimFileStream iastream = astream as InputARMSimFileStream;

            if (iastream != null)
            {
                try {
                    Stream s = iastream.Stream.BaseStream;
                    if (s.CanSeek)
                    {
                        s.Position = (long)paramBlock[1];
                        return(0);
                    }
                } catch (Exception) {
                    return(errorCode(Errno.EIO));
                }
            }
            return(errorCode(Errno.ENOTSUP));
        }
Esempio n. 3
0
        private ARMSimStream getStream(uint fileHandle)
        {
            ARMSimStream result = null;

            if (fileHandle < mFiles.Count)
            {
                result = mFiles[(int)fileHandle];
            }
            mErrno = (result == null)? Errno.EBADF : Errno.NONE;
            return(result);
        }
Esempio n. 4
0
        }//SetupStreams

        public void closeAllStreams()
        {
            //close all streams except standard I/O console streams
            for (int i = 0; i < mFiles.Count; i++)
            {
                ARMSimStream astream = mFiles[i];
                if (astream == null || astream is ARMSimConsoleStream)
                {
                    continue;
                }
                astream.Close();
            }
            mFiles.RemoveAll(x => true);
        }
Esempio n. 5
0
        // Read from a file
        private uint swiRead()
        {
            // Params:  file handle, address of buffer, # of bytes to read
            // Result:  r0 = # of bytes NOT read
            if (!fetchParams(3))
            {
                return(uint.MaxValue);
            }
            uint         addr     = paramBlock[1];
            uint         nbytes   = paramBlock[2];
            ARMSimStream acstream = getStream(paramBlock[0]);

            if (!(acstream is ARMSimConsoleStream) && !(acstream is InputARMSimFileStream))
            {
                mErrno = Errno.EBADF;
                return(nbytes);
            }

            while (nbytes != 0)
            {
                int ch;
                try {
                    ch = acstream.Read();
                    if (ch < 0)
                    {
                        mErrno = Errno.EIO;  break;
                    }
                } catch (Exception) {
                    mErrno = Errno.EIO;  break;
                }
                try {
                    mIhost.SetMemory(addr, ARMPluginInterfaces.MemorySize.Byte, (uint)ch);
                }
                catch (MemoryAccessException)
                {
                    mErrno = Errno.EFAULT; break;
                }
                addr++;
                if ((ch == 13) && (acstream is ARMSimConsoleStream))
                {
                    nbytes = 0;
                }
                else
                {
                    nbytes--;
                }
            }
            return(nbytes);
        }
Esempio n. 6
0
        private uint swiIsTTy()
        {
            // Params:  file handle
            // Result:  r0 = 1 if handle refers to a tty, 0 otherwise
            if (!fetchParams(1))
            {
                return(errorCode(Errno.EFAULT));
            }
            ARMSimStream astream = getStream(paramBlock[0]);

            if (astream == null)
            {
                return(uint.MaxValue);
            }
            return((uint)((astream is ARMSimConsoleStream)? 1 : 0));
        }
Esempio n. 7
0
        static private ARMSimStream CreateOutputStream(string filename, bool overwrite)
        {
            if (String.IsNullOrEmpty(filename))
            {
                return(null);
            }
            ARMSimStream armSimStream = null;

            if (overwrite)
            {
                armSimStream = new OutputARMSimFileStream(File.CreateText(filename));
            }
            else
            {
                armSimStream = new OutputARMSimFileStream(File.AppendText(filename));
            }
            return(armSimStream);
        }
Esempio n. 8
0
        // Write to a file
        private uint swiWrite()
        {
            // Params:  file handle, address of buffer, # of bytes to write
            // Result:  r0 = # of bytes NOT written
            if (!fetchParams(3))
            {
                return(errorCode(Errno.EFAULT));
            }
            //uint fileHandle = paramBlock[0];
            uint         addr     = paramBlock[1];
            uint         nbytes   = paramBlock[2];
            ARMSimStream acstream = getStream(paramBlock[0]);

            if (!(acstream is ARMSimConsoleStream) && !(acstream is OutputARMSimFileStream))
            {
                mErrno = Errno.EBADF;
                return(nbytes);
            }
            while (nbytes != 0)
            {
                uint ch;
                try {
                    ch = mIhost.GetMemory(addr, ARMPluginInterfaces.MemorySize.Byte);
                } catch (Exception) {
                    mErrno = Errno.EFAULT;  break;
                }
                try {
                    acstream.Write((char)ch);
                } catch (Exception) {
                    mErrno = Errno.EIO;  break;
                }
                addr++;
                nbytes--;
            }
            return(nbytes);
        }
        private void SetupStreams()
        {
            closeAllStreams();
            mIhost.CloseStandardConsole(mStdioConsole);

            mStdioConsole = mIhost.CreateStandardConsole("stdin/stdout/stderr");

            ARMPluginInterfaces.Preferences.IGeneralPreferences prefs = mIhost.ARMPreferences.IGeneralPreferences;
            IARMSimArguments args = mIhost.ARMSimArguments;

            ARMSimStream armSimStream = CreateInputStream(args.StdinFileName);

            if (armSimStream == null)
            {
                armSimStream = CreateInputStream(prefs.StdinFileName);
            }
            if (armSimStream == null)
            {
                armSimStream = new ARMSimConsoleStream(mStdioConsole, mIhost);
            }

            mFiles.Add(armSimStream);  // index = 0

            bool   overwrite = true;
            string filename  = null;

            if (args.StdoutFileName != null)
            {
                overwrite = true;
                filename  = args.StdoutFileName;
            }
            else if (args.StdoutAppendMode != null)
            {
                overwrite = false;
                filename  = args.StdoutAppendMode;
            }
            armSimStream = CreateOutputStream(filename, overwrite);
            if (armSimStream == null)
            {
                armSimStream = CreateOutputStream(prefs.StdoutFileName, prefs.StdoutOverwrite);
            }
            if (armSimStream == null)
            {
                armSimStream = new ARMSimConsoleStream(mStdioConsole, mIhost);
            }

            mFiles.Add(armSimStream);  // index = 1

            if (args.StderrFileName != null)
            {
                overwrite = true;
                filename  = args.StderrFileName;
            }
            else if (args.StderrAppendMode != null)
            {
                overwrite = false;
                filename  = args.StderrAppendMode;
            }
            armSimStream = CreateOutputStream(filename, overwrite);
            if (armSimStream == null)
            {
                armSimStream = CreateOutputStream(prefs.StderrFileName, prefs.StderrOverwrite);
            }
            if (armSimStream == null)
            {
                armSimStream = new ARMSimConsoleStream(mStdioConsole, mIhost);
            }

            mFiles.Add(armSimStream);  // index = 2
            mNextFileHandle = 3;
        }//SetupStreams
        }//onRestart

        //Execute an SWI instruction.
        /// <summary>
        /// Called when an swi 0x0000   to   swi 0x00ff is executed
        /// </summary>
        /// <param name="op_code">opcode being executed</param>
        /// <returns>number of cycles executed. 0 if none</returns>
        public uint Execute(uint op_code)
        {
            //extract the bottom 8 bits to get swi code.
            uint swi_code = op_code & 0x000000ff;

            try
            {
                //and execute based on the swi code.
                switch (swi_code)
                {
                //write a character to Outputview
                //r0: character to output
                case 0x00:
                {
                    char c = (char)mIhost.getReg(0);
                    mIhost.OutputConsoleString(new string(c, 1));
                } break;

                //write a character string to Outputview
                //r0: address of (null terminated) string to display
                case 0x02:
                {
                    string s = ARMPluginInterfaces.Utils.loadStringFromMemory(mIhost, mIhost.getReg(0), 256);
                    mIhost.OutputConsoleString(s);
                } break;

                //SWI_Exit
                case 0x11:
                    mIhost.HaltSimulation();
                    mIhost.GPR[15] -= 4;    //todo thumb mode?
                    this.closeAllStreams();
                    break;

                //SWI_HeapMalloc
                //r0: size of block in bytes
                //Output: C set on error
                //r0: address of allocated block (or 0 if error)
                case 0x12:
                    mIhost.setReg(0, mIhost.Malloc(mIhost.getReg(0)));
                    mIhost.cf = (mIhost.getReg(0) == 0);
                    break;

                //SWI_HeapClear
                case 0x13:
                    mIhost.HeapClear();
                    break;

                //write a character to an open file
                //r0: file handle (value 1 == screen)
                //r1: character to output
                //Output: C flag set on error
                case 0x60:
                {
                    string text       = ARMPluginInterfaces.Utils.loadStringFromMemory(mIhost, mIhost.getReg(1), 1);
                    uint   fileHandle = mIhost.getReg(0);
                    if (fileHandle < mFiles.Count)
                    {
                        mFiles[(int)fileHandle].Write(text);
                        mIhost.cf = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                //read one byte (an ASCII character?) from an open file
                //r0: file handle (value 0 == keyboard)
                //Output: C flag set on error
                //r0: the byte read from the file, or -1 if at EOF
                case 0x61:
                {
                    uint fileHandle = mIhost.getReg(0);
                    bool error      = fileHandle >= mFiles.Count;
                    if (!error)
                    {
                        int ch = (char)mFiles[(int)fileHandle].Read();
                        mIhost.setReg(0, (uint)ch);
                    }
                    mIhost.cf = error;
                } break;

                //read bytes from an open file
                //r0: file handle
                //r1: input buffer address
                //r2: buffer size (number of bytes to read)
                case 0x62:
                {
                    uint fileHandle = mIhost.getReg(0);
                    uint address    = mIhost.getReg(1);
                    uint maxbytes   = mIhost.getReg(2);

                    bool error = fileHandle >= mFiles.Count;

                    //special case if maxbytes is 0. Just return a success.
                    if (maxbytes == 0 || error)
                    {
                        mIhost.cf = error;
                        mIhost.setReg(0, 0);
                        break;
                    }

                    uint storedBytes = 0;
                    while (storedBytes < maxbytes)
                    {
                        int ch = (int)mFiles[(int)fileHandle].Read();
                        if (ch < 0)
                        {
                            break;
                        }
                        mIhost.SetMemory(address++, ARMPluginInterfaces.MemorySize.Byte, (uint)ch);
                        storedBytes++;
                    }
                    mIhost.cf = false;
                    mIhost.setReg(0, storedBytes);
                } break;

                //write bytes to an open file
                //r0: file handle
                //r1: output buffer address
                //r2: buffer size (number of bytes to write)
                //Output: C flag set on error
                //r0: the number of bytes successfully written to the file
                case 0x63:
                {
                    uint fileHandle = mIhost.getReg(0);
                    uint address    = mIhost.getReg(1);
                    uint maxbytes   = mIhost.getReg(2);

                    bool error = fileHandle >= mFiles.Count;

                    //special case if maxbytes is 0. Just return a success.
                    if (maxbytes == 0 || error)
                    {
                        mIhost.cf = error;
                        mIhost.setReg(0, 0);
                        break;
                    }

                    uint copiedBytes = 0;
                    while (copiedBytes < maxbytes)
                    {
                        uint ch = mIhost.GetMemory(address++, ARMPluginInterfaces.MemorySize.Byte);
                        mFiles[(int)fileHandle].Write((char)ch);
                        copiedBytes++;
                    }
                    mIhost.cf = false;
                    mIhost.setReg(0, copiedBytes);
                }
                break;

                //open text file for input or output
                //r0: pointer to filename to open, null terminated
                //r1: mode -- 0 means input, 1 means output, 2 means append, 0x100 - stdconsole(filename used as title).
                //Output: C flag set on error
                //r0: file handle(-1 on error)
                case 0x66:
                {
                    bool   bError = true;
                    string str    = ARMPluginInterfaces.Utils.loadStringFromMemory(mIhost, mIhost.getReg(0), 256);

                    string currDir = Directory.GetCurrentDirectory();
                    if (!string.IsNullOrEmpty(mIhost.UserDirectory))
                    {
                        Directory.SetCurrentDirectory(mIhost.UserDirectory);
                    }

                    ARMSimStream astream = null;
                    try
                    {
                        switch (mIhost.getReg(1))
                        {
                        case 0:
                            astream = new InputARMSimFileStream(new StreamReader(File.OpenRead(str)));
                            break;

                        case 1:
                            astream = new OutputARMSimFileStream(new StreamWriter(File.Open(str, FileMode.Create)));
                            break;

                        case 2:
                            astream = new OutputARMSimFileStream(new StreamWriter(File.Open(str, FileMode.Append)));
                            break;

                        case 0x100:
                        {                //create a new standardConsole
                            uint stdHandle = mIhost.CreateStandardConsole(str);
                            astream = new ARMSimConsoleStream(stdHandle, mIhost);
                        }
                        break;

                        default:
                            break;
                        }        //switch

                        uint fileHandle = uint.MaxValue;
                        if (astream != null)
                        {
                            fileHandle = mNextFileHandle++;
                            mFiles.Add(astream);
                            bError = false;
                        }
                        mIhost.setReg(0, fileHandle);
                    }        //try
                    catch (Exception)
                    {
                        mIhost.setReg(0, uint.MaxValue);
                    }
                    Directory.SetCurrentDirectory(currDir);
                    mIhost.cf = bError;
                } break;         //case 0x66

                //close an open file
                //r0: file handle
                //Output: C flag set on error
                case 0x68:
                {
                    uint handle = mIhost.getReg(0);
                    if (handle < mFiles.Count)
                    {
                        mFiles[(int)handle].Close();
                        mFiles[(int)handle] = null;
                        mIhost.cf           = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                //write null-terminated string to screen or to open file
                //r0: file handle (value 1 == screen)
                //r1: address of string to read from memory
                //Output: C flag set on error
                case 0x69:
                {
                    uint   addr       = mIhost.getReg(1);
                    string text       = ARMPluginInterfaces.Utils.loadStringFromMemory(mIhost, addr, 256);
                    uint   fileHandle = mIhost.getReg(0);
                    if (fileHandle < mFiles.Count)
                    {
                        mFiles[(int)fileHandle].Write(text);
                        mIhost.cf = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                //read line of text from open file
                //r0: file handle
                //r1: location to put read data
                //r2: max number of bytes to read (including added null terminator)
                //Output: C flag set on error
                //r0: number of bytes stored (including added null terminator)
                case 0x6a:
                {
                    uint fileHandle = mIhost.getReg(0);
                    uint maxbytes   = mIhost.getReg(2);

                    bool error = fileHandle >= mFiles.Count;

                    //special case if maxbytes is 0. Just return a success.
                    if (maxbytes == 0)
                    {
                        mIhost.cf = error;
                        mIhost.setReg(0, 0);
                        break;
                    }

                    uint   storedBytes = 0;
                    string text        = null;
                    if (!error)
                    {
                        text  = mFiles[(int)fileHandle].ReadLine();
                        error = text == null;
                    }

                    if (!error)
                    {
                        storedBytes = (uint)(text.Length + 1);
                        if (maxbytes < text.Length)
                        {
                            storedBytes = maxbytes;
                        }

                        uint address = mIhost.getReg(1);
                        for (uint i = 0; i < storedBytes - 1; i++)
                        {
                            uint data = (uint)(text[(int)i]);
                            mIhost.SetMemory(address++, ARMPluginInterfaces.MemorySize.Byte, data);
                        }
                        mIhost.SetMemory(address++, ARMPluginInterfaces.MemorySize.Byte, 0);
                    }

                    mIhost.setReg(0, storedBytes);
                    mIhost.cf = error;
                } break;

                //write signed integer to screen or to open file
                //r0: file handle (value 1 == screen)
                //r1: integer value to write
                //Output: C flag set on error
                case 0x6b:
                {
                    uint   fileHandle = mIhost.getReg(0);
                    string text       = ((int)mIhost.getReg(1)).ToString();
                    if (fileHandle < mFiles.Count)
                    {
                        mFiles[(int)fileHandle].Write(text);
                        mIhost.cf = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                //read signed integer from open file
                //r0: file handle
                //Output: C flag set on error
                //r0: value of the integer read from file
                case 0x6c:
                {
                    int  number     = 0;
                    uint fileHandle = mIhost.getReg(0);

                    ARMSimStream sr = null;
                    if (fileHandle < mFiles.Count)
                    {
                        sr = mFiles[(int)fileHandle];
                    }

                    bool error = true;
                    if (sr != null)
                    {
                        error = sr.GetInteger(ref number);
                    }
                    if (!error)
                    {
                        mIhost.setReg(0, (uint)number);
                    }
                    mIhost.cf = error;
                } break;

                case 0x6d:
                    //return milliseconds in r0
                    mIhost.setReg(0, (uint)(DateTime.Now.Ticks / 10000));
                    break;

                //output a double FP number to the console
                //r0:register to output (0-15)
                //outputs in the same format as the registers view, uses the formatstring "0.###E+0"
                case 0x6e:
                {
                    uint reg = mIhost.getReg(0);
                    if (reg > 15)
                    {
                        reportBadRegister(reg, 0x6e);
                        return(0);
                    }
                    double value = mIhost.getFPDoubleReg(reg);
                    string str   = ARMSim.Simulator.VFP.FloatingPointProcessor.DoubleToString(value);
                    mIhost.OutputConsoleString(str);
                } break;

                //output a float FP number to the console
                //r0:register to output (0-31)
                //outputs in the same format as the registers view, uses the formatstring "0.###E+0"
                case 0x6f:
                {
                    uint reg = mIhost.getReg(0);
                    if (reg > 31)
                    {
                        reportBadRegister(reg, 0x6f);
                        return(0);
                    }
                    float  value = mIhost.getFPSingleReg(reg);
                    string str   = ARMSim.Simulator.VFP.FloatingPointProcessor.FloatToString(value);
                    mIhost.OutputConsoleString(str);
                } break;

                //read double value from open file
                //r0: file handle
                //r1: register to read value into (0-15)
                case 0x7b:
                {
                    double number     = 0.0;
                    uint   fileHandle = mIhost.getReg(0);
                    uint   reg        = mIhost.getReg(1);
                    if (reg > 15)
                    {
                        reportBadRegister(reg, swi_code);
                        return(0);
                    }
                    ARMSimStream sr = null;
                    if (fileHandle < mFiles.Count)
                    {
                        sr = mFiles[(int)fileHandle];
                    }

                    bool error = true;
                    if (sr != null)
                    {
                        error = sr.GetDouble(ref number);
                    }
                    if (!error)
                    {
                        mIhost.setFPDoubleReg(0, number);
                    }
                    mIhost.cf = error;
                } break;

                //read float value from open file
                //r0: file handle
                //r1: register to read value into (0-31)
                case 0x7c:
                {
                    double number     = 0.0;
                    uint   fileHandle = mIhost.getReg(0);
                    uint   reg        = mIhost.getReg(1);
                    if (reg > 31)
                    {
                        reportBadRegister(reg, swi_code);
                        return(0);
                    }
                    ARMSimStream sr = null;
                    if (fileHandle < mFiles.Count)
                    {
                        sr = mFiles[(int)fileHandle];
                    }        //else

                    bool error = true;
                    if (sr != null)
                    {
                        error = sr.GetDouble(ref number);
                    }
                    if (!error)
                    {
                        mIhost.setFPSingleReg(0, (float)number);
                    }
                    else
                    {
                        mIhost.cf = error;
                    }
                } break;

                //output a double FP number to screen or to open file
                //r0: file handle (value 1 == screen)
                //r1:register to output (0-15)
                //outputs in the same format as the registers view, uses the formatstring "0.###E+0"
                case 0x7e:
                {
                    uint reg = mIhost.getReg(1);
                    if (reg > 15)
                    {
                        reportBadRegister(reg, swi_code);
                        return(0);
                    }
                    double value = mIhost.getFPDoubleReg(reg);
                    string text  = ARMSim.Simulator.VFP.FloatingPointProcessor.DoubleToString(value);

                    uint fileHandle = mIhost.getReg(0);
                    if (fileHandle < mFiles.Count)
                    {
                        mFiles[(int)fileHandle].Write(text);
                        mIhost.cf = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                //output a float FP number to screen or to open file
                //r0: file handle (value 1 == screen)
                //r1:register to output (0-31)
                //outputs in the same format as the registers view, uses the formatstring "0.###E+0"
                case 0x7f:
                {
                    uint reg = mIhost.getReg(1);
                    if (reg > 31)
                    {
                        reportBadRegister(reg, swi_code);
                        return(0);
                    }
                    float  value = mIhost.getFPSingleReg(reg);
                    string text  = ARMSim.Simulator.VFP.FloatingPointProcessor.FloatToString(value);

                    uint fileHandle = mIhost.getReg(0);
                    if (fileHandle < mFiles.Count)
                    {
                        mFiles[(int)fileHandle].Write(text);
                        mIhost.cf = false;
                    }
                    else
                    {
                        mIhost.cf = true;
                    }
                } break;

                default:
                    //if it is an unknown swi code then return 3 clock cycles executed but
                    //do no actual work. This prevents the swi exception from being raised
                    //for swi codes not handled here
                    break;
                } //switch
            }     //try
            catch (Exception ex)
            {
                ARMPluginInterfaces.Utils.OutputDebugString(
                    "Exception caught while processing SWI call: 0x" +
                    swi_code.ToString("X2") + " Message: " + ex.Message);
                return(0);
            }
            return(3);
        }//Execute
Esempio n. 11
0
        }//Execute

        // Open a file
        private uint swiOpen()
        {
            // Params:  filename, length of filename, mode
            // Result:  r0 = file handle
            if (!fetchParams(3))
            {
                return(errorCode(Errno.EFAULT));
            }

            try {
                string str    = ARMPluginInterfaces.Utils.loadStringFromMemory(mIhost, paramBlock[0], paramBlock[1]);
                uint   mode   = paramBlock[2];
                bool   binary = false;
                if ((mode & 1) != 0)
                {
                    binary = true;
                    mode  &= 0xffffffe;
                }
                if (binary)
                {
                    ARMPluginInterfaces.Utils.OutputDebugString("binary mode files unsupported");
                }

                mErrno = Errno.NONE;
                ARMSimStream astream = null;
                if (String.IsNullOrEmpty(str) || str == ":tt")
                {
                    // First three uses of this filename map to the standard streams
                    // stdin, stdout, & stderr which have already been opened
                    if (stdFileNum <= 2)
                    {
                        return(stdFileNum++);
                    }
                    // We want additional console windowss??
                    uint stdHandle = mIhost.CreateStandardConsole(str);
                    astream = new ARMSimConsoleStream(stdHandle, mIhost);
                }
                else
                {
                    string currDir = null;
                    if (mIhost.UserDirectory != null)
                    {
                        currDir = Directory.GetCurrentDirectory();
                        Directory.SetCurrentDirectory(mIhost.UserDirectory);
                    }
                    switch (mode)
                    {
                    case 0:      // read
                        astream = new InputARMSimFileStream(new StreamReader(File.OpenRead(str)));
                        break;

                    case 2:                     // read-write mode
                        mErrno = Errno.ENOTSUP; // unsupported mode
                        break;

                    case 4:      // write (with create or truncate)
                        astream = new OutputARMSimFileStream(new StreamWriter(File.Open(str, FileMode.OpenOrCreate)));
                        break;

                    case 8:      // write in append mode
                        astream = new OutputARMSimFileStream(new StreamWriter(File.Open(str, FileMode.Append)));
                        break;

                    default:
                        mErrno = Errno.EINVAL;      // invalid mode
                        break;
                    }
                    if (currDir != null)
                    {
                        Directory.SetCurrentDirectory(currDir);
                    }
                    if (mErrno != Errno.NONE)
                    {
                        return(uint.MaxValue);
                    }
                }
                int fileHandle = 0;
                // search for the first available handle
                while (fileHandle < mFiles.Count)
                {
                    if (mFiles[fileHandle] == null)
                    {
                        mFiles[fileHandle] = astream;
                        return((uint)fileHandle);
                    }
                    fileHandle++;
                }
                mFiles.Add(astream);
                return((uint)fileHandle);
            } catch (Exception) {
                return(errorCode(Errno.EIO));
            }
        }