* Applied patch from Melanie, mantis issue #1581 - "Refactor LSL language, api and compiler out of XEngine"

"First stage in a major Script Engine refactor, that will result in the LSL implementaions ebing reconverged. Not there yet, but one major part is done."
Thank you, Melanie!

1 files changed, 515 insertions, 0 deletions

diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
new file mode 100644
index 0000000..2edcee0
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Microsoft.CSharp;
+using Microsoft.JScript;
+using Microsoft.VisualBasic;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.ScriptEngine.Interfaces;
+
+namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
+{
+    public class Compiler
+    {
+        private static readonly log4net.ILog m_log
+            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        // * Uses "LSL2Converter" to convert LSL to C# if necessary.
+        // * Compiles C#-code into an assembly
+        // * Returns assembly name ready for AppDomain load.
+        //
+        // Assembly is compiled using LSL_BaseClass as base. Look at debug C# code file created when LSL script is compiled for full details.
+        //
+
+        internal enum enumCompileType
+        {
+            lsl = 0,
+            cs = 1,
+            vb = 2,
+            js = 3
+        }
+
+        /// <summary>
+        /// This contains number of lines WE use for header when compiling script. User will get error in line x-LinesToRemoveOnError when error occurs.
+        /// </summary>
+        public int LinesToRemoveOnError = 3;
+        private enumCompileType DefaultCompileLanguage;
+        private bool WriteScriptSourceToDebugFile;
+        private bool CompileWithDebugInformation;
+        private Dictionary<string, bool> AllowedCompilers = new Dictionary<string, bool>(StringComparer.CurrentCultureIgnoreCase);
+        private Dictionary<string, enumCompileType> LanguageMapping = new Dictionary<string, enumCompileType>(StringComparer.CurrentCultureIgnoreCase);
+
+        private string FilePrefix;
+        private string ScriptEnginesPath = "ScriptEngines";
+
+        private static LSL2CSConverter LSL_Converter = new LSL2CSConverter();
+        private static CSharpCodeProvider CScodeProvider = new CSharpCodeProvider();
+        private static VBCodeProvider VBcodeProvider = new VBCodeProvider();
+        private static JScriptCodeProvider JScodeProvider = new JScriptCodeProvider();
+
+        private static int instanceID = new Random().Next(0, int.MaxValue);                 // Unique number to use on our compiled files
+        private static UInt64 scriptCompileCounter = 0;                                     // And a counter
+
+        public IScriptEngine m_scriptEngine;
+        public Compiler(IScriptEngine scriptEngine)
+        {
+            m_scriptEngine = scriptEngine;
+            ReadConfig();
+        }
+        public bool in_startup = true;
+        public void ReadConfig()
+        {
+
+            // Get some config
+            WriteScriptSourceToDebugFile = m_scriptEngine.Config.GetBoolean("WriteScriptSourceToDebugFile", true);
+            CompileWithDebugInformation = m_scriptEngine.Config.GetBoolean("CompileWithDebugInformation", true);
+
+            // Get file prefix from scriptengine name and make it file system safe:
+            FilePrefix = "CommonCompiler";
+            foreach (char c in Path.GetInvalidFileNameChars())
+            {
+                FilePrefix = FilePrefix.Replace(c, '_');
+            }
+
+            // First time we start? Delete old files
+            if (in_startup)
+            {
+                in_startup = false;
+                DeleteOldFiles();
+            }
+
+            // Map name and enum type of our supported languages
+            LanguageMapping.Add(enumCompileType.cs.ToString(), enumCompileType.cs);
+            LanguageMapping.Add(enumCompileType.vb.ToString(), enumCompileType.vb);
+            LanguageMapping.Add(enumCompileType.lsl.ToString(), enumCompileType.lsl);
+            LanguageMapping.Add(enumCompileType.js.ToString(), enumCompileType.js);
+
+            // Allowed compilers
+            string allowComp = m_scriptEngine.Config.GetString("AllowedCompilers", "lsl,cs,vb,js");
+            AllowedCompilers.Clear();
+
+#if DEBUG
+            m_scriptEngine.Log.Debug("[Compiler]: Allowed languages: " + allowComp);
+#endif
+
+
+            foreach (string strl in allowComp.Split(','))
+            {
+                string strlan = strl.Trim(" \t".ToCharArray()).ToLower();
+                if (!LanguageMapping.ContainsKey(strlan))
+                {
+                    m_scriptEngine.Log.Error("[Compiler]: Config error. Compiler is unable to recognize language type \"" + strlan + "\" specified in \"AllowedCompilers\".");
+                }
+                else
+                {
+#if DEBUG
+                    //m_scriptEngine.Log.Debug("[Compiler]: Config OK. Compiler recognized language type \"" + strlan + "\" specified in \"AllowedCompilers\".");
+#endif
+                }
+                AllowedCompilers.Add(strlan, true);
+            }
+            if (AllowedCompilers.Count == 0)
+                m_scriptEngine.Log.Error("[Compiler]: Config error. Compiler could not recognize any language in \"AllowedCompilers\". Scripts will not be executed!");
+
+            // Default language
+            string defaultCompileLanguage = m_scriptEngine.Config.GetString("DefaultCompileLanguage", "lsl").ToLower();
+
+            // Is this language recognized at all?
+            if (!LanguageMapping.ContainsKey(defaultCompileLanguage))
+            {
+                m_scriptEngine.Log.Error("[Compiler]: " +
+                                            "Config error. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is not recognized as a valid language. Changing default to: \"lsl\".");
+                defaultCompileLanguage = "lsl";
+            }
+
+            // Is this language in allow-list?
+            if (!AllowedCompilers.ContainsKey(defaultCompileLanguage))
+            {
+                m_scriptEngine.Log.Error("[Compiler]: " +
+                                            "Config error. Default language \"" + defaultCompileLanguage + "\"specified in \"DefaultCompileLanguage\" is not in list of \"AllowedCompilers\". Scripts may not be executed!");
+            }
+            else
+            {
+#if DEBUG
+//                m_scriptEngine.Log.Debug("[Compiler]: " +
+//                                            "Config OK. Default language \"" + defaultCompileLanguage + "\" specified in \"DefaultCompileLanguage\" is recognized as a valid language.");
+#endif
+                // LANGUAGE IS IN ALLOW-LIST
+                DefaultCompileLanguage = LanguageMapping[defaultCompileLanguage];
+            }
+
+            // We now have an allow-list, a mapping list, and a default language
+
+        }
+
+        /// <summary>
+        /// Delete old script files
+        /// </summary>
+        private void DeleteOldFiles()
+        {
+
+            // CREATE FOLDER IF IT DOESNT EXIST
+            if (!Directory.Exists(ScriptEnginesPath))
+            {
+                try
+                {
+                    Directory.CreateDirectory(ScriptEnginesPath);
+                }
+                catch (Exception ex)
+                {
+                    m_scriptEngine.Log.Error("[Compiler]: Exception trying to create ScriptEngine directory \"" + ScriptEnginesPath + "\": " + ex.ToString());
+                }
+            }
+
+            if (!Directory.Exists(Path.Combine(ScriptEnginesPath,
+                    m_scriptEngine.World.RegionInfo.RegionID.ToString())))
+            {
+                try
+                {
+                    Directory.CreateDirectory(Path.Combine(ScriptEnginesPath,
+                        m_scriptEngine.World.RegionInfo.RegionID.ToString()));
+                }
+                catch (Exception ex)
+                {
+                    m_scriptEngine.Log.Error("[Compiler]: Exception trying to create ScriptEngine directory \"" + Path.Combine(ScriptEnginesPath,
+                                            m_scriptEngine.World.RegionInfo.RegionID.ToString())+ "\": " + ex.ToString());
+                }
+            }
+
+            foreach (string file in Directory.GetFiles(Path.Combine(ScriptEnginesPath,
+                                m_scriptEngine.World.RegionInfo.RegionID.ToString())))
+            {
+                //m_scriptEngine.Log.Error("[Compiler]: FILE FOUND: " + file);
+
+                if (file.ToLower().StartsWith(FilePrefix + "_compiled_") ||
+                    file.ToLower().StartsWith(FilePrefix + "_source_"))
+                {
+                    try
+                    {
+                        File.Delete(file);
+                    }
+                    catch (Exception ex)
+                    {
+                        m_scriptEngine.Log.Error("[Compiler]: Exception trying delete old script file \"" + file + "\": " + ex.ToString());
+                    }
+
+                }
+            }
+
+        }
+
+        ////private ICodeCompiler icc = codeProvider.CreateCompiler();
+        //public string CompileFromFile(string LSOFileName)
+        //{
+        //    switch (Path.GetExtension(LSOFileName).ToLower())
+        //    {
+        //        case ".txt":
+        //        case ".lsl":
+        //            Common.ScriptEngineBase.Shared.SendToDebug("Source code is LSL, converting to CS");
+        //            return CompileFromLSLText(File.ReadAllText(LSOFileName));
+        //        case ".cs":
+        //            Common.ScriptEngineBase.Shared.SendToDebug("Source code is CS");
+        //            return CompileFromCSText(File.ReadAllText(LSOFileName));
+        //        default:
+        //            throw new Exception("Unknown script type.");
+        //    }
+        //}
+
+        /// <summary>
+        /// Converts script from LSL to CS and calls CompileFromCSText
+        /// </summary>
+        /// <param name="Script">LSL script</param>
+        /// <returns>Filename to .dll assembly</returns>
+        public string PerformScriptCompile(string Script, string asset)
+        {
+            string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine(
+                    m_scriptEngine.World.RegionInfo.RegionID.ToString(),
+                    FilePrefix + "_compiled_" + asset + ".dll"));
+//            string OutFile = Path.Combine(ScriptEnginesPath,
+//                    FilePrefix + "_compiled_" + asset + ".dll");
+
+            if (File.Exists(OutFile))
+            {
+                m_scriptEngine.Log.DebugFormat("[Compiler] Returning existing assembly for {0}", asset);
+                return OutFile;
+            }
+
+            if (!Directory.Exists(ScriptEnginesPath))
+            {
+                try
+                {
+                    Directory.CreateDirectory(ScriptEnginesPath);
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+
+            if (!Directory.Exists(Path.Combine(ScriptEnginesPath,
+                                               m_scriptEngine.World.RegionInfo.RegionID.ToString())))
+            {
+                try
+                {
+                    Directory.CreateDirectory(ScriptEnginesPath);
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+
+            enumCompileType l = DefaultCompileLanguage;
+
+            if (Script.StartsWith("//c#", true, CultureInfo.InvariantCulture))
+                l = enumCompileType.cs;
+            if (Script.StartsWith("//vb", true, CultureInfo.InvariantCulture))
+            {
+                l = enumCompileType.vb;
+                // We need to remove //vb, it won't compile with that
+
+                Script = Script.Substring(4, Script.Length - 4);
+            }
+            if (Script.StartsWith("//lsl", true, CultureInfo.InvariantCulture))
+                l = enumCompileType.lsl;
+
+            if (Script.StartsWith("//js", true, CultureInfo.InvariantCulture))
+                l = enumCompileType.js;
+
+            if (!AllowedCompilers.ContainsKey(l.ToString()))
+            {
+                // Not allowed to compile to this language!
+                string errtext = String.Empty;
+                errtext += "The compiler for language \"" + l.ToString() + "\" is not in list of allowed compilers. Script will not be executed!";
+                throw new Exception(errtext);
+            }
+
+            string compileScript = Script;
+
+            if (l == enumCompileType.lsl)
+            {
+                // Its LSL, convert it to C#
+                compileScript = LSL_Converter.Convert(Script);
+                l = enumCompileType.cs;
+            }
+
+            // Insert additional assemblies here
+
+            //ADAM: Disabled for the moment until it's working right.
+            bool enableCommanderLSL = false;
+
+            if (enableCommanderLSL == true && l == enumCompileType.cs)
+            {
+                foreach (KeyValuePair<string,
+                    ICommander> com
+                    in m_scriptEngine.World.GetCommanders())
+                {
+                    compileScript = com.Value.GenerateRuntimeAPI() + compileScript;
+                }
+            }
+
+            // End of insert
+
+            switch (l)
+            {
+                case enumCompileType.cs:
+                    compileScript = CreateCSCompilerScript(compileScript);
+                    break;
+                case enumCompileType.vb:
+                    compileScript = CreateVBCompilerScript(compileScript);
+                    break;
+                case enumCompileType.js:
+                    compileScript = CreateJSCompilerScript(compileScript);
+                    break;
+            }
+
+//            m_log.Debug("[ScriptEngine.DotNetEngine]: Preparing to compile the following LSL to C# translated code");
+//            m_log.Debug("");
+//            m_log.Debug(compileScript);
+
+            return CompileFromDotNetText(compileScript, l, asset);
+        }
+
+        private static string CreateJSCompilerScript(string compileScript)
+        {
+            compileScript = String.Empty +
+                "import OpenSim.Region.ScriptEngine.Shared; import System.Collections.Generic;\r\n" +
+                "package SecondLife {\r\n" +
+                "class Script extends OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" +
+                compileScript +
+                "} }\r\n";
+            return compileScript;
+        }
+
+        private static string CreateCSCompilerScript(string compileScript)
+        {
+            compileScript = String.Empty +
+                "using OpenSim.Region.ScriptEngine.Shared; using System.Collections.Generic;\r\n" +
+                String.Empty + "namespace SecondLife { " +
+                String.Empty + "public class Script : OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" +
+                @"public Script() { } " +
+                compileScript +
+                "} }\r\n";
+            return compileScript;
+        }
+
+        private static string CreateVBCompilerScript(string compileScript)
+        {
+            compileScript = String.Empty +
+                "Imports OpenSim.Region.ScriptEngine.Shared: Imports System.Collections.Generic: " +
+                String.Empty + "NameSpace SecondLife:" +
+                String.Empty + "Public Class Script: Inherits OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass: " +
+                "\r\nPublic Sub New()\r\nEnd Sub: " +
+                compileScript +
+                ":End Class :End Namespace\r\n";
+            return compileScript;
+        }
+
+        /// <summary>
+        /// Compile .NET script to .Net assembly (.dll)
+        /// </summary>
+        /// <param name="Script">CS script</param>
+        /// <returns>Filename to .dll assembly</returns>
+        internal string CompileFromDotNetText(string Script, enumCompileType lang, string asset)
+        {
+            string ext = "." + lang.ToString();
+
+            // Output assembly name
+            scriptCompileCounter++;
+            string OutFile = Path.Combine(ScriptEnginesPath, Path.Combine(
+                                              m_scriptEngine.World.RegionInfo.RegionID.ToString(),
+                                              FilePrefix + "_compiled_" + asset + ".dll"));
+#if DEBUG
+//            m_scriptEngine.Log.Debug("[Compiler]: Starting compile of \"" + OutFile + "\".");
+#endif
+            try
+            {
+                File.Delete(OutFile);
+            }
+            catch (Exception e) // NOTLEGIT - Should be just catching FileIOException
+            {
+                //m_scriptEngine.Log.Error("[Compiler]: Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString());
+                throw new Exception("Unable to delete old existring script-file before writing new. Compile aborted: " + e.ToString());
+            }
+            //string OutFile = Path.Combine("ScriptEngines", "SecondLife.Script.dll");
+
+            // DEBUG - write source to disk
+            if (WriteScriptSourceToDebugFile)
+            {
+                string srcFileName = FilePrefix + "_source_" + Path.GetFileNameWithoutExtension(OutFile) + ext;
+                try
+                {
+                    File.WriteAllText(Path.Combine(Path.Combine(
+                        ScriptEnginesPath,
+                        m_scriptEngine.World.RegionInfo.RegionID.ToString()),
+                        srcFileName), Script);
+                }
+                catch (Exception ex) // NOTLEGIT - Should be just catching FileIOException
+                {
+                    m_scriptEngine.Log.Error("[Compiler]: Exception while trying to write script source to file \"" + srcFileName + "\": " + ex.ToString());
+                }
+            }
+
+            // Do actual compile
+            CompilerParameters parameters = new CompilerParameters();
+
+            parameters.IncludeDebugInformation = true;
+
+            // Add all available assemblies
+//             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
+//             {
+//                 Console.WriteLine("Adding assembly: " + asm.Location);
+//                 parameters.ReferencedAssemblies.Add(asm.Location);
+//             }
+
+            string rootPath = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);
+            string rootPathSE = Path.GetDirectoryName(GetType().Assembly.Location);
+            //Console.WriteLine("Assembly location: " + rootPath);
+            parameters.ReferencedAssemblies.Add(Path.Combine(rootPath, "OpenSim.Region.ScriptEngine.Shared.dll"));
+            parameters.ReferencedAssemblies.Add(Path.Combine(rootPath, "OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll"));
+
+            parameters.GenerateExecutable = false;
+            parameters.OutputAssembly = OutFile;
+            parameters.IncludeDebugInformation = CompileWithDebugInformation;
+            //parameters.WarningLevel = 1; // Should be 4?
+            parameters.TreatWarningsAsErrors = false;
+
+//Console.WriteLine(Script);
+            CompilerResults results;
+            switch (lang)
+            {
+                case enumCompileType.vb:
+                    results = VBcodeProvider.CompileAssemblyFromSource(parameters, Script);
+                    break;
+                case enumCompileType.cs:
+                    results = CScodeProvider.CompileAssemblyFromSource(parameters, Script);
+                    break;
+                case enumCompileType.js:
+                    results = JScodeProvider.CompileAssemblyFromSource(parameters, Script);
+                    break;
+                default:
+                    throw new Exception("Compiler is not able to recongnize language type \"" + lang.ToString() + "\"");
+            }
+
+            // Check result
+            // Go through errors
+
+            //
+            // WARNINGS AND ERRORS
+            //
+            if (results.Errors.Count > 0)
+            {
+                string errtext = String.Empty;
+                foreach (CompilerError CompErr in results.Errors)
+                {
+                    errtext += "Line number " + (CompErr.Line - LinesToRemoveOnError) +
+                        ", Error Number: " + CompErr.ErrorNumber +
+                        ", '" + CompErr.ErrorText + "'\r\n";
+                }
+                if (!File.Exists(OutFile))
+                {
+                    throw new Exception(errtext);
+                }
+            }
+
+            //
+            // NO ERRORS, BUT NO COMPILED FILE
+            //
+            if (!File.Exists(OutFile))
+            {
+                string errtext = String.Empty;
+                errtext += "No compile error. But not able to locate compiled file.";
+                throw new Exception(errtext);
+            }
+            m_scriptEngine.Log.DebugFormat("[Compiler] Compiled new assembly for {0}", asset);
+            return OutFile;
+        }
+    }
+}