root/lang/csharp/JSDokan/Program.cs

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;
using Dokan;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.JScript;

namespace JSDokan
{
    class JSDokan : DokanOperations
    {
        #region DokanOperations �����o

        private object instance;
        private Type type;

        public JSDokan(object instance, Type t)
        {
            this.instance = instance;
            this.type = t;
        }

        public int Cleanup(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("Cleanup") != null ?
                (int)type.InvokeMember("Cleanup",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                0);
        }

        public int CloseFile(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("CloseFile") != null ?
                (int)type.InvokeMember("CloseFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                0);
        }

        public int CreateDirectory(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("CreateDirectory") != null ?
                (int)type.InvokeMember("CreateDirectory",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                -1);
        }

        public int CreateFile(
            string filename,
            System.IO.FileAccess access,
            System.IO.FileShare share,
            System.IO.FileMode mode,
            System.IO.FileOptions options,
            DokanFileInfo info)
        {
            return (type.GetMethod("CreateFile") != null ?
                (int)type.InvokeMember("CreateFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, access, share, mode, options, info }) :
                0);
        }

        public int DeleteDirectory(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("DeleteDirectory") != null ?
                (int)type.InvokeMember("DeleteDirectory",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                -1);
        }

        public int DeleteFile(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("DeleteFile") != null ?
                (int)type.InvokeMember("DeleteFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                -1);
        }


        public int FlushFileBuffers(
            string filename,
            DokanFileInfo info)
        {
            return (type.GetMethod("FlushFileBuffers") != null ?
                (int)type.InvokeMember("FlushFileBuffers",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                -1);
        }

        public int FindFiles(
            string filename,
            System.Collections.ArrayList files,
            DokanFileInfo info)
        {
            return (type.GetMethod("FindFiles") != null ?
                (int)type.InvokeMember("FindFiles",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] {filename, files, info }) : 
                -1);
        }


        public int GetFileInformation(
            string filename,
            FileInformation fileinfo,
            DokanFileInfo info)
        {
            return (type.GetMethod("GetFileInformation") != null ?
                (int)type.InvokeMember("GetFileInformation",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, fileinfo, info }) :
                -1);
        }

        public int LockFile(
            string filename,
            long offset,
            long length,
            DokanFileInfo info)
        {
            return (type.GetMethod("LockFile") != null ?
                (int)type.InvokeMember("LockFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, offset, length, info }) :
                0);
        }

        public int MoveFile(
            string filename,
            string newname,
            bool replace,
            DokanFileInfo info)
        {
            return (type.GetMethod("MoveFile") != null ?
                (int)type.InvokeMember("MoveFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, newname, replace, info }) :
                -1);
        }

        public int OpenDirectory(string filename, DokanFileInfo info)
        {
            return (type.GetMethod("OpenDirectory") != null ?
                (int)type.InvokeMember("OpenDirectory",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, info }) :
                0);
        }

        public int ReadFile(
            string filename,
            byte[] buffer,
            ref uint readBytes,
            long offset,
            DokanFileInfo info)
        {
            uint[] refReadBytes = new uint[] { readBytes };
            int ret = (type.GetMethod("ReadFile") != null ?
                (int)type.InvokeMember("ReadFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, buffer, refReadBytes, offset, info }) : //, offset, info }) :
                -1);
            readBytes = refReadBytes[0];
            return ret;
        }

        public int SetEndOfFile(string filename, long length, DokanFileInfo info)
        {
            return (type.GetMethod("SetEndOfFile") != null ?
                (int)type.InvokeMember("SetEndOfFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, length, info }) :
                -1);
        }

        public int SetFileAttributes(
            string filename,
            System.IO.FileAttributes attr,
            DokanFileInfo info)
        {
            return (type.GetMethod("SetFileAttributes") != null ?
                (int)type.InvokeMember("SetFileAttributes",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, attr, info }) :
                -1);
        }

        public int SetFileTime(
            string filename,
            DateTime ctime,
            DateTime atime,
            DateTime mtime,
            DokanFileInfo info)
        {
            return (type.GetMethod("SetFileTime") != null ?
                (int)type.InvokeMember("SetFileTime",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, ctime, atime, mtime, info }) :
                -1);
        }

        public int UnlockFile(string filename, long offset, long length, DokanFileInfo info)
        {
            return (type.GetMethod("UnlockFile") != null ?
                (int)type.InvokeMember("UnlockFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, offset, length, info }) :
                0);
        }

        public int Unmount(DokanFileInfo info)
        {
            return (type.GetMethod("Unmount") != null ?
                (int)type.InvokeMember("Unmount",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { info }) :
                0);
        }

        public int GetDiskFreeSpace(
           ref ulong freeBytesAvailable,
           ref ulong totalBytes,
           ref ulong totalFreeBytes,
           DokanFileInfo info)
        {
            ulong[] refBytes = new ulong[] { freeBytesAvailable, totalBytes, totalFreeBytes };

            int ret = (type.GetMethod("GetDiskFreeSpace") != null ?
                (int)type.InvokeMember("GetDiskFreeSpace",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { refBytes, info }) :
                -1);

            freeBytesAvailable = refBytes[0];
            totalBytes = refBytes[1];
            totalFreeBytes = refBytes[2];
            return ret;
        }

        public int WriteFile(
            string filename,
            byte[] buffer,
            ref uint writtenBytes,
            long offset,
            DokanFileInfo info)
        {
            uint[] refWrittenBytes = new uint[] { writtenBytes };

            int ret = (type.GetMethod("WriteFile") != null ?
                (int)type.InvokeMember("WriteFile",
                    BindingFlags.InvokeMethod,
                    null,
                    instance,
                    new object[] { filename, buffer, refWrittenBytes, offset, info }) :
                -1);

            writtenBytes = refWrittenBytes[0];
            return ret;
        }

        #endregion
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Program(args);
        }

        Program(string[] args)
        {
            if (args.Length != 2)
            {
                Usage();
                return;
            }

            Type t = CompileJS(args[0]);
            if (t == null) return;

            object instance = Activator.CreateInstance(t);

            DokanOptions opt = new DokanOptions();
            opt.DriveLetter = args[1][0];
            opt.DebugMode = false;// true;
            opt.UseStdErr = false;// true;
            opt.VolumeLabel = "JSDokan";
            DokanNet.DokanMain(opt, new JSDokan(instance, t));
        }

        void Usage()
        {
            Console.WriteLine("JSDokan.exe [script path] [drive letter]");
            Console.WriteLine("  (ex) JSDokan.exe sample.js J");
        }

        Type CompileJS(String filename)
        {
            //�R���p�C�����邽�߂̏���           CodeDomProvider cp = new Microsoft.JScript.JScriptCodeProvider();
            ICodeCompiler icc = cp.CreateCompiler();
            CompilerParameters cps = new CompilerParameters();
            cps.GenerateInMemory = true;//���������o�͂𐶐�����            cps.ReferencedAssemblies.Add("DokanNet.dll");

            CompilerResults cres;
            
            //�R���p�C������            cres = icc.CompileAssemblyFromFile(cps, filename);
            if (cres.NativeCompilerReturnValue != 0)
            {
                foreach (String s in cres.Output)
                {
                    Console.WriteLine(s);
                }
                return null;
            }

            //�R���p�C�������A�Z���u�����
            Assembly asm = cres.CompiledAssembly;
            Type t = asm.GetType(Path.GetFileNameWithoutExtension(filename));
            if (t == null)
            {
                Console.WriteLine("Class {0} not found", Path.GetFileNameWithoutExtension(filename));
            }
            return t;
        }
    }
}