source: EcnlProtoTool/trunk/webapp/webmrbc/Emscripten.cs@ 270

using System;
using Bridge;
using Bridge.Html5;

[External]
public class FileSystem
{
        /// <summary>
        /// Converts a major and minor number into a single unique integer.
        /// This is used as an id to represent the device.
        /// </summary>
        /// <param name="ma">Major number.</param>
        /// <param name="mi">Minor number.</param>
        internal int makedev(int ma, int mi)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Registers the specified device driver with a set of callbacks.
        /// </summary>
        /// <param name="dev">The specific device driver id, created using makedev().</param>
        /// <param name="ops">The set of callbacks required by the device.
        /// For an example, see the NODEFS default callbacks
        /// https://github.com/kripken/emscripten/blob/1.29.12/src/library_nodefs.js#L213</param>
        internal void registerDevice(int dev, object ops)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Sets up standard I/O devices for stdin, stdout, and stderr.
        /// The devices are set up using the following (optional) callbacks.
        /// If any of the callbacks throw an exception,
        /// it will be caught and handled as if the device malfunctioned.
        /// </summary>
        /// <param name="input">Input callback. This will be called with
        /// no parameters whenever the program attempts to read from stdin.
        /// It should return an ASCII character code when data is available,
        /// or null when it isn’t.</param>
        /// <param name="output">Output callback. This will be called with
        /// an ASCII character code whenever the program writes to stdout.
        /// It may also be called with null to flush the output.</param>
        /// <param name="error">Error callback. This is similar to output,
        /// except it is called when data is written to stderr.</param>
        /// <returns></returns>
        internal object init(Delegate input, Delegate output, Delegate error)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Mounts the FS object specified by type to the directory 
        /// specified by mountpoint. The opts object is specific
        /// to each file system type.
        /// </summary>
        /// <param name="type">The file system type: MEMFS, NODEFS, IDBFS or WORKERFS.</param>
        /// <param name="opts">A generic settings object used by the underlying file system.</param>
        /// <param name="mountpoint">A path to an existing local Emscripten directory
        /// where the file system is to be mounted. It can be either an absolute path,
        /// or something relative to the current directory.</param>
        internal void mount(object type, object opts, string mountpoint)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Unmounts the specified mountpoint.
        /// </summary>
        /// <param name="mountpoint">The directory to unmount.</param>
        internal void unmount(string mountpoint)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Responsible for iterating and synchronizing all mounted file systems
        /// in an asynchronous fashion.
        /// </summary>
        /// <param name="populate">true to initialize Emscripten’s file system data
        /// with the data from the file system’s persistent source,
        /// and false to save Emscripten`s file system data
        /// to the file system’s persistent source.</param>
        /// <param name="callback">A notification callback function
        /// that is invoked on completion of the synchronization.
        /// If an error occurred, it will be provided as a parameter to this function.</param>
        internal void syncfs(bool populate, Delegate callback)
        {

        }

        /// <summary>
        /// Creates a new directory node in the file system.
        /// </summary>
        /// <param name="path">The path name for the new directory node.</param>
        /// <param name="mode">File permissions for the new node.
        /// The default setting (in octal numeric notation) is 0777.</param>
        internal void mkdir(string path, int mode)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Creates a new device node in the file system referencing
        /// the registered device driver (FS.registerDevice()) for dev.
        /// </summary>
        /// <param name="path">The path name for the new device node.</param>
        /// <param name="mode">File permissions for the new node.
        /// The default setting (in octal numeric notation) is 0777.</param>
        /// <param name="dev">The registered device driver.</param>
        internal void mkdev(string path, int mode, int dev)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Creates a symlink node at newpath linking to oldpath.
        /// </summary>
        /// <param name="oldpath">The path name of the file to link to.</param>
        /// <param name="newpath">The path to the new symlink node, that points to oldpath.</param>
        internal void symlink(string oldpath, string newpath)
        {
                throw new NotImplementedException();
        }

        internal Stat stat(string path)
        {
                return new Stat();
        }

        internal File open(string path, string flag)
        {
                return new File();
        }

        internal void close(File stream)
        {
        }

        internal void read(File stream, Uint8Array buffer, int offset, int length, int position)
        {
        }

        /// <summary>
        /// Writes the entire contents of data to the file at path.
        /// The value of opts determines whether data is treated
        /// either as a string (encoding = utf8), or as an ArrayBufferView(encoding = binary).
        /// </summary>
        /// <param name="path">The file to which to write data.</param>
        /// <param name="data">The data to write.</param>
        /// <param name="opts">
        /// encoding(string)
        ///     binary | utf8.The default is utf8
        /// flags(string)
        ///     Write flags, as defined in FS.open(). The default is ‘w’.
        /// </param>
        internal void writeFile(string path, object data, object opts = null)
        {
                throw new NotImplementedException();
        }

        /// <summary>
        /// Preloads a file asynchronously, and uses preload plugins to prepare its content.
        /// You should call this in preRun, run() will be delayed until all preloaded files are ready.
        /// This is how the preload-file option works in emcc
        /// when --use-preload-plugins has been specified (if you use this method by itself,
        /// you will need to build the program with that option).
        /// </summary>
        /// <param name="parent">The parent folder, either as a path (e.g. ‘/usr/lib’) or
        /// an object previously returned from a FS.createFolder() or FS.createPath() call.</param>
        /// <param name="name">The name of the new file.</param>
        /// <param name="url">In the browser, this is the URL whose contents will be returned
        /// when the file is accessed. In a command line engine,
        /// this will be the local (real) file system path the contents
        /// will be loaded from. Note that writes to this file are virtual.</param>
        /// <param name="canRead">Whether the file should have read permissions set
        /// from the program’s point of view.</param>
        /// <param name="canWrite">Whether the file should have write permissions set
        /// from the program’s point of view.</param>
        internal void createPreloadedFile(string parent, string name, string url, bool canRead, bool canWrite)
        {
                throw new NotImplementedException();
        }

        internal void createFolder(string parent, string name, bool canRead, bool canWrite)
        {
                throw new NotImplementedException();
        }
}

[External]
class Stat
{
        internal int size = 0;
}

[External]
class File
{

}