D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/ScriptManager.cs

Go to the documentation of this file.

//BSD License  
//DXGfx® - http://www.eteractions.com
//Copyright (c) 2005
//by Guillaume Randon
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software
//and associated documentation files (the "Software"), to deal in the Software without restriction,
//including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
//and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions:
//The above copyright notice and this permission notice shall be included in all copies or substantial
//portions of the Software.
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
//INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
//AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
//DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;
using Microsoft.CSharp;
using System.CodeDom.Compiler;

namespace DXGfxLib
{
    public class ScriptManager
    {
        private Hashtable scripts = null;

        private string[] referencedAssemblies = null;

        private static ScriptManager globalInstance = null;

        private Assembly scriptsAssembly = null;

        public bool scriptsAreReady = false;

        public string lastCompilationErrorMessage = "";

        public ScriptManager()
        {
            if (globalInstance != null)
            {
                throw new Exception("There is already one scriptManager we don't expect to have several active at the same time!");
            }
            else
            {
                globalInstance = this;
            }
            scripts = new Hashtable();
            BuildReferences();
        }

        public void Dispose()
        {
            globalInstance = null;
        }

        public static ScriptManager GetGlobalInstance()
        {
            if (globalInstance == null)
            {
                throw new Exception("There is no scriptManager!");
            }
            return globalInstance;
        }

        public void RegisterScript(Script script)
        {
            if (!scripts.Contains(script.name))
            {
                scripts.Add(script.name, script);
            }
        }

        public void ScriptUpdated(Script script)
        {
            RegisterScript(script);
            scriptsAreReady = false;
        }

        public void UnRegisterScript(Script script)
        {
            scripts.Remove(script.name);
        }

        public void GetReady()
        {
            if (!scriptsAreReady)
            {
                if (scriptsAssembly != null)
                {
                    // It is still not possible to unload an assembly.
                    // Putting the assembly in a different appdomain to unload it requires a lot of additional work.
                    // We do nothing here for now.
                }
                lastCompilationErrorMessage = "";
                scriptsAssembly = Compile(ref lastCompilationErrorMessage);
            }
        }

        public Assembly Compile(ref string errors)
        {
            // Obtains in-memory running instance of the C# compiler
            CSharpCodeProvider csc = new CSharpCodeProvider();
            ICodeCompiler icc = csc.CreateCompiler();

            // Set input params for the compiler
            CompilerParameters co = new CompilerParameters();


            foreach (string referencedAssembly in referencedAssemblies)
            {
                co.ReferencedAssemblies.Add(referencedAssembly);
            }

            IDictionaryEnumerator scriptEnum = scripts.GetEnumerator();
            string[] sources = new string[scripts.Count];
            int count = 0;

            string tempScriptsFolderName = "tmpScripts";
            while (scriptEnum.MoveNext())
            {
                Script script = scriptEnum.Value as Script;
                if (script != null)
                {
                    if (!Directory.Exists(tempScriptsFolderName))
                    {
                        Directory.CreateDirectory(tempScriptsFolderName);
                    }
                    string csFileName = tempScriptsFolderName + "\\" + StringUtil.GetName(script.fileName);
                    File.WriteAllText(csFileName, script.GetSrcForCompilation());
                    sources[count] = csFileName;
                    // We do recompile our script assembly so we need to reset all scripts
                    // as references to current instances of derived class are going to be invalid.
                    script.Reset();
                    count++;
                }
                else
                {
                    throw new Exception("Scripts Hashtable is corrupted!");
                }
            }

            co.GenerateInMemory = true;

            // Run the compiling process
            CompilerResults results = icc.CompileAssemblyFromFileBatch(co, sources);

            if (results.Errors.HasErrors)
            {
                scriptsAreReady = false;

                foreach (CompilerError error in results.Errors)
                {
                    errors = errors + error.ErrorNumber + " " + error.ErrorText + " " + error.FileName + " " + error.Line + "\n";
                }

                return null;
            }
            else
            {
                errors = "Compilation Ok";
                scriptsAreReady = true;
            }

            return results.CompiledAssembly;
        }

        public void BuildReferences()
        {
            string managedDirect3DXPath = Environment.GetEnvironmentVariable("windir") + @"\Microsoft.NET\DirectX for Managed Code\1.0.2911.0\";
            string managedDirect3DPath = Environment.GetEnvironmentVariable("windir") + @"\Microsoft.NET\DirectX for Managed Code\1.0.2902.0\";

            string binFolder = AppDomain.CurrentDomain.BaseDirectory;

            referencedAssemblies = new string[] {"system.dll", "system.data.dll", "system.drawing.dll", 
                "system.windows.forms.dll", "system.xml.dll", 
                binFolder + "DXCommon.dll",
                binFolder + "DXGfxLib.dll", 
                managedDirect3DPath + "Microsoft.DirectX.dll", 
                managedDirect3DPath + "Microsoft.DirectX.Direct3D.dll", 
                managedDirect3DXPath + "Microsoft.DirectX.Direct3DX.dll", 
                managedDirect3DPath + "Microsoft.DirectX.DirectInput.dll"};
        }

        public string[] GetReferences()
        {
            return referencedAssemblies;
        }

        public void SetReferences(string[] references)
        {
            referencedAssemblies = references;
        }

        public ExecutableBlock GetNewExecutableBlock(string name)
        {
            Type desiredType = scriptsAssembly.GetType("DXGfxLib." + name);
            ConstructorInfo ctor = desiredType.GetConstructor(new Type[] { });
            Object[] args = new Object[] { };
            Object obj = ctor.Invoke(args);

            ExecutableBlock newExecutableBlock = obj as ExecutableBlock;

            if (newExecutableBlock == null)
            {
                throw new Exception("Type doesn't derive from ExecutableBlock this is terribly wrong!!");
            }

            return newExecutableBlock;
        }
    }
}

---