From fde7e7ab7afd319675ebc68235ab7aaf7f937025 Mon Sep 17 00:00:00 2001
From: Ivan Mogilko <ikm_spb@yahoo.com>
Date: Thu, 31 Oct 2024 00:24:03 +0300
Subject: [PATCH 1/2] AGS.Native: added IScriptCompiler interface, and a
 standard impl

IScriptCompiler is a compiler interface that lets to address any available compiler.
Implementation AGS3ScriptCompiler, which basically wrap calls to the native compiler lib.

NOTE: There's already IScriptCompiler in AGS.CScript.Compiler managed library. But it appears to be complicated to use at the moment, because it has number of ties with existing code, including separate message (error) types.
I left big TODO comments about merging these interfaces, would someone be willing to improve this situation.
This probably will have to be done anyway would Editor work with standalone compilers.
---
 Common/script/cc_common.h                     |  24 +-
 Compiler/script/cs_compiler.cpp               |  13 +-
 Compiler/script/cs_compiler.h                 |   3 +
 .../AGS.CScript.Compiler/IScriptCompiler.cs   |  25 +-
 Editor/AGS.Editor/AGSEditor.cs                |  93 ++++--
 Editor/AGS.Editor/NativeProxy.cs              |   4 +-
 Editor/AGS.Native/CompiledScript.h            | 123 ++++++++
 Editor/AGS.Native/IScriptCompiler.h           |  73 +++++
 Editor/AGS.Native/NativeDLL.vcxproj           |   3 +-
 Editor/AGS.Native/NativeMethods.h             |   4 +-
 Editor/AGS.Native/ScriptCompiler.cpp          | 264 ++++++++++--------
 Editor/AGS.Native/Scripting.h                 | 119 --------
 Editor/AGS.Native/agsnative.cpp               |   2 +-
 13 files changed, 483 insertions(+), 267 deletions(-)
 create mode 100644 Editor/AGS.Native/CompiledScript.h
 create mode 100644 Editor/AGS.Native/IScriptCompiler.h
 delete mode 100644 Editor/AGS.Native/Scripting.h

diff --git a/Common/script/cc_common.h b/Common/script/cc_common.h
index 703f21e4c2..407fa8914e 100644
--- a/Common/script/cc_common.h
+++ b/Common/script/cc_common.h
@@ -20,15 +20,21 @@
 
 #include "util/string.h"
 
-#define SCOPT_EXPORTALL      1   // export all functions automatically
-#define SCOPT_SHOWWARNINGS   2   // printf warnings to console
-#define SCOPT_LINENUMBERS    4   // include line numbers in compiled code
-#define SCOPT_AUTOIMPORT     8   // when creating instance, export funcs to other scripts
-#define SCOPT_DEBUGRUN    0x10   // write instructions as they are procssed to log file
-#define SCOPT_NOIMPORTOVERRIDE 0x20 // do not allow an import to be re-declared
-#define SCOPT_LEFTTORIGHT 0x40   // left-to-right operator precedance
-#define SCOPT_OLDSTRINGS  0x80   // allow old-style strings
-#define SCOPT_UTF8        0x100  // UTF-8 text mode
+// FIXME: SCOPT_AUTOIMPORT and SCOPT_DEBUGRUN are runtime only options
+// remove them from this list of flags, and use a different way of assigning,
+// not using ccSetOption.
+
+#define SCOPT_EXPORTALL     0x0001   // export all functions automatically
+// 0x0002 [UNUSED]
+#define SCOPT_LINENUMBERS   0x0004   // include line numbers in compiled code
+#define SCOPT_AUTOIMPORT    0x0008   // when creating instance, export funcs to other scripts
+#define SCOPT_DEBUGRUN      0x0010   // write instructions as they are procssed to log file
+// TODO: this flag might have to be removed as it makes inconsistent rules for distinct scripts
+#define SCOPT_NOIMPORTOVERRIDE 0x0020 // do not allow an import to be re-declared
+#define SCOPT_LEFTTORIGHT   0x0040   // left-to-right operator precedance
+#define SCOPT_OLDSTRINGS    0x0080   // allow old-style strings
+#define SCOPT_UTF8          0x0100   // UTF-8 text mode
+#define SCOPT_HIGHEST       SCOPT_UTF8
 
 extern void ccSetOption(int, int);
 extern int ccGetOption(int);
diff --git a/Compiler/script/cs_compiler.cpp b/Compiler/script/cs_compiler.cpp
index 6952472a0c..c357713dd2 100644
--- a/Compiler/script/cs_compiler.cpp
+++ b/Compiler/script/cs_compiler.cpp
@@ -27,6 +27,12 @@ const char *ccCurScriptName = "";
 std::vector<const char*> defaultheaders;
 std::vector<const char*> defaultHeaderNames;
 
+void ccGetExtensions(std::vector<std::string> &exts)
+{
+    // Add extensions here as necessary
+    return;
+}
+
 int ccAddDefaultHeader(const char* nhead, const char *nName)
 {
     defaultheaders.push_back(nhead);
@@ -100,10 +106,9 @@ ccScript* ccCompileText(const char *texo, const char *scriptName) {
             (sym.get_type(t) != SYM_LOCALVAR)) continue;
 
         if (sym.entries[t].flags & SFLG_IMPORTED) continue;
-        if (ccGetOption(SCOPT_SHOWWARNINGS)==0) ;
-        else if ((sym.entries[t].flags & SFLG_ACCESSED)==0) {
-            printf("warning: variable '%s' is never used\n",sym.get_friendly_name(t).c_str());
-        }
+        //if ((sym.entries[t].flags & SFLG_ACCESSED)==0) {
+        //    printf("warning: variable '%s' is never used\n",sym.get_friendly_name(t).c_str());
+        //}
     }
 
     if (ccGetOption(SCOPT_EXPORTALL)) {
diff --git a/Compiler/script/cs_compiler.h b/Compiler/script/cs_compiler.h
index 8a2939dcc4..a2510b5336 100644
--- a/Compiler/script/cs_compiler.h
+++ b/Compiler/script/cs_compiler.h
@@ -21,6 +21,9 @@
 #include "script/cc_script.h"  // ccScript
 
 // ********* SCRIPT COMPILATION FUNCTIONS **************
+// Get a list of compiler extensions.
+extern void ccGetExtensions(std::vector<std::string> &exts);
+
 // add a script that will be compiled as a header into every compilation
 // 'name' is the name of the header, used in error reports
 // (only the pointer is stored so don't free the memory)
diff --git a/Editor/AGS.CScript.Compiler/IScriptCompiler.cs b/Editor/AGS.CScript.Compiler/IScriptCompiler.cs
index d199f4b3c8..084bf37e36 100644
--- a/Editor/AGS.CScript.Compiler/IScriptCompiler.cs
+++ b/Editor/AGS.CScript.Compiler/IScriptCompiler.cs
@@ -4,7 +4,30 @@
 
 namespace AGS.CScript.Compiler
 {
-	public interface IScriptCompiler
+    // TODO: merge this with AGS.Native.IScriptCompiler!
+    // I wrote a new variant of IScriptCompiler inside AGS.Native lib, because
+    // this one has certain ties within CScript.Compiler classes.
+    // The only implementation of IScriptCompiler in here is not completed and
+    // was never used in AGS Editor (apparently, not sure if possible to test).
+    //
+    // Proposal: rework CompileResults, make it contain CompiledScript and
+    // CompileMessages collection. Merge or substitute CompilerMessage with
+    // AGS.Types.CompileMessage. But note that CompilerMessage also has
+    // Error Codes! Need to figure out how to make that shareable without strict
+    // bind to the Compiler lib.
+    // Re CompiledScript, see if possible to merge with AGS.Native.CompiledScript,
+    // which has data stored as native ccScript (?). Need to think this through.
+    //
+    // Important: IScriptCompiler implementation does not necessarily has actual
+    // compiler code inside. It may instead be a wrapper over a code that starts
+    // **EXTERNAL** compiler, i.e. runs a standalone executable, passing all
+    // parameters through command line.
+    // Need to think through how to receive results in that case. Maybe CompileResults
+    // could contain optionally an object that has compiled data in memory **AND**
+    // optionally a path to compiled file. And interface user would test which one
+    // is valid. That's just an idea for now.
+
+    public interface IScriptCompiler
 	{
 		CompileResults CompileScript(string script);
 	}
diff --git a/Editor/AGS.Editor/AGSEditor.cs b/Editor/AGS.Editor/AGSEditor.cs
index 542a76e642..5a015b8e34 100644
--- a/Editor/AGS.Editor/AGSEditor.cs
+++ b/Editor/AGS.Editor/AGSEditor.cs
@@ -17,6 +17,8 @@
 
 namespace AGS.Editor
 {
+    using ScriptCompilerOptions = AGS.Native.ScriptCompilerOptions;
+
     public class AGSEditor
     {
         public event GetScriptHeaderListHandler GetScriptHeaderList;
@@ -858,15 +860,53 @@ private void DefineMacrosAccordingToGameSettings(IPreprocessor preprocessor)
             }
         }
 
-		/// <summary>
-		/// Preprocesses and then compiles the script using the supplied headers.
-		/// </summary>
-		public void CompileScript(Script script, List<Script> headers, CompileMessages errors)
+        private void DefineMacrosFromCompiler(IPreprocessor preprocessor, AGS.Native.IScriptCompiler compiler)
+        {
+            var exts = compiler.GetExtensions();
+            foreach (var ext in exts)
+            {
+                preprocessor.DefineMacro("SCRIPT_EXT_" + ext, "1");
+            }
+        }
+
+        private ScriptCompilerOptions GetScriptCompileOptions(Game game)
+        {
+            // Set up compiler options
+            ScriptCompilerOptions options =
+                ScriptCompilerOptions.AutoExportFunctions |
+                ScriptCompilerOptions.LineNumbers;
+
+            if (game.Settings.LeftToRightPrecedence)
+                options = options | ScriptCompilerOptions.LeftToRightPrecendence;
+            if ((!game.Settings.EnforceNewStrings))
+                options = options | ScriptCompilerOptions.OldStrings;
+            if (game.UnicodeMode)
+                options = options | ScriptCompilerOptions.UTF8;
+
+            return options;
+        }
+
+        /// <summary>
+        /// Preprocesses and then compiles the script prepended with the supplied headers.
+        /// Warnings and errors are collected in 'messages'.
+        /// Will _not_ throw whenever compiling results in an error.
+        /// </summary>
+        public void CompileScript(AGS.Native.IScriptCompiler compiler, Script script, List<Script> headers, CompileMessages messages)
 		{
-			IPreprocessor preprocessor = CompilerFactory.CreatePreprocessor(AGS.Types.Version.AGS_EDITOR_VERSION);
+            // Clear up previous data, if present
+            if (script.CompiledData != null)
+            {
+                script.CompiledData.Dispose();
+                script.CompiledData = null;
+            }
+
+            messages = messages ?? new CompileMessages();
+
+            IPreprocessor preprocessor = CompilerFactory.CreatePreprocessor(AGS.Types.Version.AGS_EDITOR_VERSION);
 			DefineMacrosAccordingToGameSettings(preprocessor);
+            DefineMacrosFromCompiler(preprocessor, compiler);
 
-			List<string> preProcessedCode = new List<string>();
+            List<string> preProcessedCode = new List<string>();
 			foreach (Script header in headers)
 			{
 				preProcessedCode.Add(preprocessor.Preprocess(header.Text, header.FileName));
@@ -878,19 +918,36 @@ public void CompileScript(Script script, List<Script> headers, CompileMessages e
 			{
 				foreach (AGS.CScript.Compiler.Error error in preprocessor.Results)
 				{
-					CompileError newError = new CompileError(error.Message, error.ScriptName, error.LineNumber);
-					if (errors == null)
-					{
-						throw newError;
-					}
-					errors.Add(newError);
+                    messages.Add(new CompileError(error.Message, error.ScriptName, error.LineNumber));
 				}
-			}
-			else
-			{
-				Factory.NativeProxy.CompileScript(script, preProcessedCode.ToArray(), _game);
-			}
-		}
+
+                // If the preprocessor has found any errors then don't attempt compiling proper
+                if (messages.HasErrors)
+                    return;
+            }
+
+            script.CompiledData =
+                compiler.CompileScript(script.FileName, preProcessedCode.ToArray(), GetScriptCompileOptions(_game), messages);
+        }
+
+        /// <summary>
+        /// Preprocesses and then compiles the script prepended the supplied headers.
+        /// Retrieves script compiler from AGS.Native. If compiler is not found,
+        /// reports error and bails out early.
+        /// Warnings and errors are collected in 'messages'.
+        /// Will _not_ throw whenever compiling results in an error.
+        /// </summary>
+        public void CompileScript(Script script, List<Script> headers, CompileMessages messages)
+        {
+            var compiler = Factory.NativeProxy.GetEmbeddedScriptCompilers().FirstOrDefault();
+            if (compiler == null)
+            {
+                messages.Add(new CompileError($"Script compiler is not available. Incomplete AGS Editor installation?"));
+                return;
+            }
+
+            CompileScript(compiler, script, headers, messages);
+        }
 
         private Script CompileDialogs(CompileMessages errors, bool rebuildAll)
         {
diff --git a/Editor/AGS.Editor/NativeProxy.cs b/Editor/AGS.Editor/NativeProxy.cs
index afc9776d76..216fa06c6e 100644
--- a/Editor/AGS.Editor/NativeProxy.cs
+++ b/Editor/AGS.Editor/NativeProxy.cs
@@ -436,9 +436,9 @@ public string LoadRoomScript(string roomFileName)
             return _native.LoadRoomScript(roomFileName);
         }
 
-        public void CompileScript(Script script, string[] preProcessedData, Game game)
+        public List<IScriptCompiler> GetEmbeddedScriptCompilers()
         {
-            _native.CompileScript(script, preProcessedData, game);
+            return _native.GetEmbeddedScriptCompilers();
         }
 
         public void CreateDebugMiniEXE(string[] fileList, string exeFileName)
diff --git a/Editor/AGS.Native/CompiledScript.h b/Editor/AGS.Native/CompiledScript.h
new file mode 100644
index 0000000000..bbae85512d
--- /dev/null
+++ b/Editor/AGS.Native/CompiledScript.h
@@ -0,0 +1,123 @@
+//=============================================================================
+//
+// Adventure Game Studio (AGS)
+//
+// Copyright (C) 1999-2011 Chris Jones and 2011-2024 various contributors
+// The full list of copyright holders can be found in the Copyright.txt
+// file, which is part of this source code distribution.
+//
+// The AGS source code is provided under the Artistic License 2.0.
+// A copy of this license can be found in the file License.txt and at
+// https://opensource.org/license/artistic-2-0/
+//
+//=============================================================================
+#pragma once
+#include "script/cc_script.h"
+#include "script/cc_internal.h"
+
+namespace AGS
+{
+namespace Native 
+{
+using namespace System;
+using namespace AGS::Types;
+
+public ref class CompiledScript : ICompiledScript
+{
+private:
+	PScript* _compiledScript;
+
+    void WriteCStr(System::IO::BinaryWriter ^writer, const std::string &str)
+    {
+        for (auto c : str)
+        {
+            writer->Write((System::Byte)c);
+        }
+        writer->Write((System::Byte)0);
+    }
+
+public:
+	CompiledScript(PScript script) 
+	{
+		_compiledScript = new PScript();
+		*_compiledScript = script;
+	}
+
+	property PScript Data
+	{
+		PScript get() { return *_compiledScript; }
+		void set(PScript newScript) { *_compiledScript = newScript; }
+	}
+
+	~CompiledScript() 
+	{
+		this->!CompiledScript();
+	}
+
+	!CompiledScript()
+	{
+		_compiledScript->reset();
+		delete _compiledScript;
+		_compiledScript = NULL;
+	}
+
+    virtual void __clrcall Write(System::IO::FileStream ^ostream, System::String ^scriptFileName)
+    {
+        if (*_compiledScript == NULL)
+        {
+            throw gcnew AGS::Types::CompileError(gcnew System::String("Script has not been compiled: ") + scriptFileName);
+        }
+        System::IO::BinaryWriter ^writer = gcnew System::IO::BinaryWriter(ostream);
+        for (int i = 0; i < 4; ++i)
+        {
+            // the BinaryWriter seems to be treating CHAR as a 4-byte type here?
+            writer->Write((System::Byte)scfilesig[i]);
+        }
+        const ccScript *cs = _compiledScript->get();
+        writer->Write((unsigned)SCOM_VERSION_CURRENT);
+        writer->Write((unsigned)cs->globaldata.size());
+        writer->Write((unsigned)cs->code.size());
+        writer->Write((unsigned)cs->strings.size());
+        for (size_t i = 0; i < cs->globaldata.size(); ++i)
+        {
+            writer->Write((System::Byte)cs->globaldata[i]);
+        }
+        for (size_t i = 0; i < cs->code.size(); ++i)
+        {
+            writer->Write((int)cs->code[i]);
+        }
+        for (size_t i = 0; i < cs->strings.size(); ++i)
+        {
+            writer->Write((System::Byte)cs->strings[i]);
+        }
+        writer->Write((unsigned)cs->fixups.size());
+        for (size_t i = 0; i < cs->fixups.size(); ++i)
+        {
+            writer->Write((System::Byte)cs->fixuptypes[i]);
+        }
+        for (size_t i = 0; i < cs->fixups.size(); ++i)
+        {
+            writer->Write(cs->fixups[i]);
+        }
+        writer->Write((unsigned)cs->imports.size());
+        for (size_t i = 0; i < cs->imports.size(); ++i)
+        {
+            WriteCStr(writer, cs->imports[i]);
+        }
+        writer->Write((unsigned)cs->exports.size());
+        for (size_t i = 0; i < cs->exports.size(); ++i)
+        {
+            WriteCStr(writer, cs->exports[i]);
+            writer->Write(cs->export_addr[i]);
+        }
+        writer->Write((unsigned)cs->sectionNames.size());
+        for (size_t i = 0; i < cs->sectionNames.size(); ++i)
+        {
+            WriteCStr(writer, cs->sectionNames[i]);
+            writer->Write(cs->sectionOffsets[i]);
+        }
+        writer->Write((unsigned)ENDFILESIG);
+    }
+};
+} // namespace Native
+} // namespace AGS
diff --git a/Editor/AGS.Native/IScriptCompiler.h b/Editor/AGS.Native/IScriptCompiler.h
new file mode 100644
index 0000000000..9e6e27c2bd
--- /dev/null
+++ b/Editor/AGS.Native/IScriptCompiler.h
@@ -0,0 +1,73 @@
+//=============================================================================
+//
+// Adventure Game Studio (AGS)
+//
+// Copyright (C) 1999-2011 Chris Jones and 2011-2024 various contributors
+// The full list of copyright holders can be found in the Copyright.txt
+// file, which is part of this source code distribution.
+//
+// The AGS source code is provided under the Artistic License 2.0.
+// A copy of this license can be found in the file License.txt and at
+// https://opensource.org/license/artistic-2-0/
+//
+//=============================================================================
+#pragma once
+#include "CompiledScript.h"
+
+namespace AGS
+{
+namespace Native 
+{
+
+using namespace System;
+using namespace System::Collections::Generic;
+using namespace AGS::Types;
+
+// TODO: move IScriptCompiler interface out of AGS.Native into one of the C# libs.
+// There's an existing IScriptCompiler in AGS.CScript.Compiler, but modifying it
+// will affect many other things, so I decided to keep this one separated for now.
+
+[Flags]
+public enum class ScriptCompilerOptions
+{
+    AutoExportFunctions = 0x0001,   // export all functions automatically
+    // 0x0002, // [UNUSED] was "show warnings in console", but never implemented properly
+    LineNumbers         = 0x0004,   // generate line numbers in compiled code
+    // 0x0008, // [UNUSED] was runtime only option
+    // 0x0010, // [UNUSED] was runtime only option
+    // TODO: this flag might have to be deprecated as it makes inconsistent rules for distinct scripts
+    NoImportOverride    = 0x0020,   // do not allow an import to be re-declared
+    LeftToRightPrecendence = 0x0040, // left-to-right operator precedence 
+    OldStrings          = 0x0080,   // allow old-style strings
+    UTF8                = 0x0100,   // UTF-8 text mode
+};
+
+public interface class IScriptCompiler
+{
+public:
+    // Gets this compiler's identifying name
+    virtual String^ GetName() = 0;
+    // Gets this compiler's human-readable name
+    virtual String^ GetDescription() = 0;
+    // Gets this compiler's list of supported extensions
+    virtual List<String^>^ GetExtensions() = 0;
+    // Gets if this compiler supports building several scripts in parallel
+    virtual bool DoesSupportParallelBuilds() = 0;
+    // Compiles the given script.
+    // The caller must guarantee that the text does not contain any preprocessor commands,
+    // and have only pure AGS script.
+    // Returns a CompiledScript object, fills collection of compilation messages.
+    virtual CompiledScript^ CompileScript(String^ scriptName, String^ scriptText, ScriptCompilerOptions options, CompileMessages^ messages) = 0;
+    // Compiles the given script text array, treating it as split parts of the same script.
+    // scriptTexts represents headers and a script body, they are supposed to be merged
+    // by the compiler itself prior to compilation.
+    // The caller must guarantee that the text does not contain any preprocessor commands,
+    // and have only pure AGS script.
+    // NOTE: this variant is required for the legacy compiler only, as normally compiler
+    // should detect new sections using a predefined string literal in text.
+    // Returns a CompiledScript object, fills collection of compilation messages.
+    virtual CompiledScript^ CompileScript(String^ scriptName, cli::array<String^>^ scriptTexts, ScriptCompilerOptions options, CompileMessages^ messages) = 0;
+};
+
+} // namespace Native 
+} // namespace AGS
diff --git a/Editor/AGS.Native/NativeDLL.vcxproj b/Editor/AGS.Native/NativeDLL.vcxproj
index 9c820fa311..9063dc2486 100644
--- a/Editor/AGS.Native/NativeDLL.vcxproj
+++ b/Editor/AGS.Native/NativeDLL.vcxproj
@@ -388,9 +388,10 @@ copy "$(TargetPath)" "$(SolutionDir)..\Editor\References\x64"</Command>
     <ClInclude Include="..\Native\ac\actiontype.h" />
     <ClInclude Include="..\Native\ac\scriptmodule.h" />
     <ClInclude Include="agsnative.h" />
+    <ClInclude Include="IScriptCompiler.h" />
     <ClInclude Include="NativeMethods.h" />
     <ClInclude Include="NativeUtils.h" />
-    <ClInclude Include="Scripting.h" />
+    <ClInclude Include="CompiledScript.h" />
     <ClInclude Include="SpriteFileReader_NET.h" />
     <ClInclude Include="SpriteFileWriter_NET.h" />
   </ItemGroup>
diff --git a/Editor/AGS.Native/NativeMethods.h b/Editor/AGS.Native/NativeMethods.h
index e5c0b6969d..69e59929db 100644
--- a/Editor/AGS.Native/NativeMethods.h
+++ b/Editor/AGS.Native/NativeMethods.h
@@ -14,6 +14,7 @@
 #pragma once
 #include <string.h>
 #include "NativeUtils.h"
+#include "IScriptCompiler.h"
 
 using namespace AGS::Types;
 using namespace System;
@@ -107,7 +108,8 @@ namespace AGS
 			void DrawSpriteToBuffer(int sprNum, int x, int y, float scale) ;
 			void RenderBufferToHDC(int hDC) ;
 			String ^LoadRoomScript(String ^roomFileName);
-			void CompileScript(Script ^script, cli::array<String^> ^preProcessedScripts, Game ^game);
+            // Returns a list of IScriptCompiler implementations embedded in AGS.Native
+            List<IScriptCompiler^>^ GetEmbeddedScriptCompilers();
 			GameTemplate^ LoadTemplateFile(String ^fileName);
       RoomTemplate^ LoadRoomTemplateFile(String ^fileName);
 			void ExtractTemplateFiles(String ^templateFileName);
diff --git a/Editor/AGS.Native/ScriptCompiler.cpp b/Editor/AGS.Native/ScriptCompiler.cpp
index 2231a5075d..5a0d9370b3 100644
--- a/Editor/AGS.Native/ScriptCompiler.cpp
+++ b/Editor/AGS.Native/ScriptCompiler.cpp
@@ -22,7 +22,6 @@
 #include <vector>
 #include "NativeMethods.h"
 #include "NativeUtils.h"
-#include "scripting.h"
 #include "script/cs_compiler.h"
 #include "script/cc_common.h"
 #include "util/path.h"
@@ -36,136 +35,179 @@ using namespace System::IO;
 
 namespace AGS
 {
-	namespace Native
-	{
-		void NativeMethods::CompileScript(Script ^script, cli::array<String^> ^preProcessedScripts, Game ^game)
-		{
-			TextConverter^ tcv = NativeMethods::GetGameTextConverter();
-
-			if (script->CompiledData != nullptr)
-			{
-				//script->CompiledData->Dispose();
-				script->CompiledData = nullptr;
-			}
-
-      ccRemoveDefaultHeaders();
-
-			  CompileMessage ^exceptionToThrow = nullptr;
-
-			  std::vector<AGSString> scriptHeaders;
-			  scriptHeaders.resize(preProcessedScripts->Length - 1);
-			  AGSString mainScript;
-			  AGSString mainScriptName;
-        ccScript *scrpt = NULL;
-			  int headerCount = 0;
-
-			  for each (String^ header in preProcessedScripts) 
-			  {
-          if (headerCount < preProcessedScripts->Length - 1)
-          {
-				    scriptHeaders[headerCount] = tcv->Convert(header);
-
-            if (ccAddDefaultHeader(scriptHeaders[headerCount].GetCStr(), "Header")) 
+namespace Native
+{
+
+//
+// IScriptCompiler implementation for legacy AGS3 compiler
+//
+public ref class AGS3ScriptCompiler : public IScriptCompiler
+{
+public:
+    AGS3ScriptCompiler()
+    {
+    }
+
+    // Gets this compiler's identifying name
+    virtual String^ GetName()
+    {
+        return "AGS SCOM 3 EXT";
+    }
+    // Gets this compiler's human-readable name
+    virtual String^ GetDescription()
+    {
+        return "AGS v3 Script Compiler";
+    }
+    // Gets this compiler's list of supported extensions
+    virtual List<String^>^ GetExtensions()
+    {
+        std::vector<std::string> cc_exts;
+        ccGetExtensions(cc_exts);
+        List<String^>^ exts = gcnew List<String^>();
+        for (const auto &s : cc_exts)
+            exts->Add(gcnew String(s.c_str()));
+        return exts;
+    }
+    // Gets if this compiler supports building several scripts in parallel
+    virtual bool DoesSupportParallelBuilds()
+    {
+        return false; // still relies on global data, so - no
+    }
+    // Compiles the given script.
+    // Returns a CompiledScript object, fills collection of compilation messages.
+    virtual CompiledScript^ CompileScript(String^ scriptName, String^ scriptText, ScriptCompilerOptions options, CompileMessages^ messages)
+    {
+        cli::array<String^>^ scriptTexts = gcnew cli::array<String^>(1);
+        scriptTexts[0] = scriptText;
+        return CompileScript(scriptName, scriptTexts, options, messages);
+    }
+    // Compile the given script texts.
+    // Returns a CompiledScript object, fills collection of compilation messages.
+    virtual CompiledScript^ CompileScript(String^ scriptName, cli::array<String^>^ scriptTexts, ScriptCompilerOptions options, CompileMessages^ messages)
+    {
+        // Prepare to convert script texts to native strings, in UTF-8 format
+        TextConverter^ tcv = NativeMethods::GetGameTextConverter();
+        // Set up compiler options
+        uint64_t const cc_options = (UInt64)options;
+
+        ccRemoveDefaultHeaders();
+
+        std::vector<AGSString> scriptHeaders;
+        scriptHeaders.resize(scriptTexts->Length - 1);
+        AGSString mainScript;
+        AGSString mainScriptName;
+        int headerCount = 0;
+
+        // FIXME: compiler should scan for NEW_SCRIPT_MARKER in a merged script text instead,
+        // then we won't have to receive an array of texts, but a single merged text
+        for each (String^ header in scriptTexts)
+        {
+            if (headerCount < scriptTexts->Length - 1)
             {
-              exceptionToThrow = gcnew CompileError("Too many scripts in game");
+                scriptHeaders[headerCount] = tcv->Convert(header);
+
+                if (ccAddDefaultHeader(scriptHeaders[headerCount].GetCStr(), "Header")) 
+                {
+                    messages->Add(gcnew CompileError("Too many scripts in game"));
+                    return nullptr;
+                }
+                headerCount++;
             }
-				    headerCount++;
-          }
-			  }
-			  mainScript = tcv->Convert(preProcessedScripts[preProcessedScripts->Length - 1]);
-			  mainScriptName = TextHelper::ConvertASCII(script->FileName);
-
-			  ccSetSoftwareVersion(editorVersionNumber.GetCStr());
+        }
 
-			  ccSetOption(SCOPT_EXPORTALL, 1);
-			  ccSetOption(SCOPT_LINENUMBERS, 1);
-			  ccSetOption(SCOPT_LEFTTORIGHT, game->Settings->LeftToRightPrecedence);
-			  ccSetOption(SCOPT_OLDSTRINGS, !game->Settings->EnforceNewStrings);
-			  ccSetOption(SCOPT_UTF8, game->UnicodeMode);
+        ccSetSoftwareVersion(editorVersionNumber.GetCStr());
+        for (uint64_t opt_bit = 1; opt_bit <= SCOPT_HIGHEST; opt_bit <<= 1)
+            ccSetOption(opt_bit, (cc_options & opt_bit) != 0);
 
-        if (exceptionToThrow == nullptr)
+        mainScript = tcv->Convert(scriptTexts[scriptTexts->Length - 1]);
+        mainScriptName = TextHelper::ConvertASCII(scriptName);
+        std::unique_ptr<ccScript> cc_script(
+            ccCompileText(mainScript.GetCStr(), mainScriptName.GetCStr()));
+        if (!cc_script || cc_has_error())
         {
-			    scrpt = ccCompileText(mainScript.GetCStr(), mainScriptName.GetCStr());
- 			    if ((scrpt == NULL) || (cc_has_error()))
-			    {
-                    auto &error = cc_get_error();
-                    exceptionToThrow = gcnew CompileError(tcv->Convert(error.ErrorString), TextHelper::ConvertASCII(ccCurScriptName), error.Line);
-			    }
+            auto &error = cc_get_error();
+            messages->Add(gcnew CompileError(tcv->Convert(error.ErrorString), TextHelper::ConvertASCII(ccCurScriptName), error.Line));
+            return nullptr;
         }
 
-			  if (exceptionToThrow != nullptr) 
-			  {
-				  delete scrpt;
-				  throw exceptionToThrow;
-			  }
+        // Success, create new CompiledData
+        return gcnew CompiledScript(PScript(cc_script.release()));
+    }
+};
+
 
-			  script->CompiledData = gcnew CompiledScript(PScript(scrpt));
-		}
+List<IScriptCompiler^>^ NativeMethods::GetEmbeddedScriptCompilers()
+{
+    // Gather compilers in order of priority
+    List<IScriptCompiler^>^ compilers = gcnew List<IScriptCompiler^>();
+    compilers->Add(gcnew AGS3ScriptCompiler());
+    return compilers;
+}
 
-		void NativeMethods::UpdateFileIcon(String ^fileToUpdate, String ^iconName)
-		{
-			if (System::Environment::OSVersion->Platform == System::PlatformID::Win32NT) 
-			{
-				ReplaceIconFromFile(TextHelper::ConvertUTF8(iconName), TextHelper::ConvertUTF8(fileToUpdate));
-			}
-		}
+void NativeMethods::UpdateFileIcon(String ^fileToUpdate, String ^iconName)
+{
+	if (System::Environment::OSVersion->Platform == System::PlatformID::Win32NT) 
+	{
+		ReplaceIconFromFile(TextHelper::ConvertUTF8(iconName), TextHelper::ConvertUTF8(fileToUpdate));
+	}
+}
 
-    void NativeMethods::FindAndUpdateMemory(unsigned char *data, int dataLen, const unsigned char *searchFor, int searchForLen, const unsigned char *replaceWith)
+void NativeMethods::FindAndUpdateMemory(unsigned char *data, int dataLen, const unsigned char *searchFor, int searchForLen, const unsigned char *replaceWith)
+{
+    for (int i = 0; i < dataLen - searchForLen; i++)
     {
-      for (int i = 0; i < dataLen - searchForLen; i++)
-      {
         if (memcmp(&data[i], searchFor, searchForLen) == 0)
         {
-          memcpy(&data[i], replaceWith, searchForLen);
-          return;
+            memcpy(&data[i], replaceWith, searchForLen);
+            return;
         }
-      }
-
-      throw gcnew AGSEditorException("Unable to find source string for replacement");
     }
 
-    void NativeMethods::ReplaceStringInMemory(unsigned char *memory, int memorySize, const char *searchFor, const unsigned char *replaceWithData)
-    {
-      WCHAR searchForUnicode[100];
-      MultiByteToWideChar(CP_ACP, 0, searchFor, (int)strlen(searchFor) + 1, searchForUnicode, sizeof(searchForUnicode));
-      FindAndUpdateMemory(memory, memorySize, (unsigned char*)searchForUnicode, (int)strlen(searchFor) * 2, replaceWithData);
-    }
+    throw gcnew AGSEditorException("Unable to find source string for replacement");
+}
+
+void NativeMethods::ReplaceStringInMemory(unsigned char *memory, int memorySize, const char *searchFor, const unsigned char *replaceWithData)
+{
+    WCHAR searchForUnicode[100];
+    MultiByteToWideChar(CP_ACP, 0, searchFor, (int)strlen(searchFor) + 1, searchForUnicode, sizeof(searchForUnicode));
+    FindAndUpdateMemory(memory, memorySize, (unsigned char*)searchForUnicode, (int)strlen(searchFor) * 2, replaceWithData);
+}
 
-    void NativeMethods::UpdateFileVersionInfo(String ^fileToUpdate, cli::array<System::Byte> ^authorNameUnicode, cli::array<System::Byte> ^gameNameUnicode)
+void NativeMethods::UpdateFileVersionInfo(String ^fileToUpdate, cli::array<System::Byte> ^authorNameUnicode, cli::array<System::Byte> ^gameNameUnicode)
+{
+    AGSString abs_path = AGS::Common::Path::MakeAbsolutePath(TextHelper::ConvertUTF8(fileToUpdate));
+    WCHAR wpath[MAX_PATH_SZ];
+    MultiByteToWideChar(CP_UTF8, 0, abs_path.GetCStr(), -1, wpath, MAX_PATH_SZ);
+    HMODULE module = LoadLibraryExW(wpath, NULL, LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE);
+    if (module == NULL)
     {
-      AGSString abs_path = AGS::Common::Path::MakeAbsolutePath(TextHelper::ConvertUTF8(fileToUpdate));
-      WCHAR wpath[MAX_PATH_SZ];
-      MultiByteToWideChar(CP_UTF8, 0, abs_path.GetCStr(), -1, wpath, MAX_PATH_SZ);
-      HMODULE module = LoadLibraryExW(wpath, NULL, LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE);
-      if (module == NULL)
-      {
         throw gcnew AGSEditorException(WinAPIHelper::MakeErrorManaged("LoadLibrary failed."));
-      }
-      HRSRC handle = FindResource(module, MAKEINTRESOURCE(1), RT_VERSION);
-      if (handle == NULL)
-      {
+    }
+    HRSRC handle = FindResource(module, MAKEINTRESOURCE(1), RT_VERSION);
+    if (handle == NULL)
+    {
         FreeLibrary(module);
         throw gcnew AGSEditorException(WinAPIHelper::MakeErrorManaged("FindResource failed."));
-      }
-      HGLOBAL hglobal = LoadResource(module, handle);
-      int dataSize = SizeofResource(module, handle);
-      unsigned char *dataCopy = (unsigned char*)malloc(dataSize);
-      unsigned char *versionData = (unsigned char*)LockResource(hglobal);
-      memcpy(dataCopy, versionData, dataSize);
-      UnlockResource(versionData);
-      FreeLibrary(module);
-
-      const char *searchFor = "AGS Engine by Chris Jones et al.        ";
-      pin_ptr<Byte> authorNameData = &authorNameUnicode[0];
-      ReplaceStringInMemory(dataCopy, dataSize, searchFor, authorNameData);
-
-      searchFor = "Adventure Game Studio run-time engine   ";
-      pin_ptr<Byte> descriptionData = &gameNameUnicode[0];
-      ReplaceStringInMemory(dataCopy, dataSize, searchFor, descriptionData);
-
-      ReplaceResourceInEXE(abs_path, MAKEINTRESOURCE(1), dataCopy, dataSize, MAKEINTRESOURCE(RT_VERSION));
-      free(dataCopy);
     }
-
-    } // namespace Native
+    HGLOBAL hglobal = LoadResource(module, handle);
+    int dataSize = SizeofResource(module, handle);
+    unsigned char *dataCopy = (unsigned char*)malloc(dataSize);
+    unsigned char *versionData = (unsigned char*)LockResource(hglobal);
+    memcpy(dataCopy, versionData, dataSize);
+    UnlockResource(versionData);
+    FreeLibrary(module);
+
+    const char *searchFor = "AGS Engine by Chris Jones et al.        ";
+    pin_ptr<Byte> authorNameData = &authorNameUnicode[0];
+    ReplaceStringInMemory(dataCopy, dataSize, searchFor, authorNameData);
+
+    searchFor = "Adventure Game Studio run-time engine   ";
+    pin_ptr<Byte> descriptionData = &gameNameUnicode[0];
+    ReplaceStringInMemory(dataCopy, dataSize, searchFor, descriptionData);
+
+    ReplaceResourceInEXE(abs_path, MAKEINTRESOURCE(1), dataCopy, dataSize, MAKEINTRESOURCE(RT_VERSION));
+    free(dataCopy);
+}
+
+} // namespace Native
 } // namespace AGS
diff --git a/Editor/AGS.Native/Scripting.h b/Editor/AGS.Native/Scripting.h
deleted file mode 100644
index 9b92188842..0000000000
--- a/Editor/AGS.Native/Scripting.h
+++ /dev/null
@@ -1,119 +0,0 @@
-//=============================================================================
-//
-// Adventure Game Studio (AGS)
-//
-// Copyright (C) 1999-2011 Chris Jones and 2011-2024 various contributors
-// The full list of copyright holders can be found in the Copyright.txt
-// file, which is part of this source code distribution.
-//
-// The AGS source code is provided under the Artistic License 2.0.
-// A copy of this license can be found in the file License.txt and at
-// https://opensource.org/license/artistic-2-0/
-//
-//=============================================================================
-#include "script/cc_script.h"
-#include "script/cc_internal.h"
-
-namespace AGS
-{
-	namespace Native 
-	{
-		public ref class CompiledScript : ICompiledScript
-		{
-		private:
-			PScript* _compiledScript;
-
-            void WriteCStr(System::IO::BinaryWriter ^writer, const std::string &str)
-            {
-                for (auto c : str)
-                {
-                    writer->Write((System::Byte)c);
-                }
-                writer->Write((System::Byte)0);
-            }
-
-		public:
-			CompiledScript(PScript script) 
-			{
-				_compiledScript = new PScript();
-				*_compiledScript = script;
-			}
-
-			property PScript Data
-			{
-				PScript get() { return *_compiledScript; }
-				void set(PScript newScript) { *_compiledScript = newScript; }
-			}
-
-			~CompiledScript() 
-			{
-				this->!CompiledScript();
-			}
-
-			!CompiledScript()
-			{
-				_compiledScript->reset();
-				delete _compiledScript;
-				_compiledScript = NULL;
-			}
-
-            virtual void __clrcall Write(System::IO::FileStream ^ostream, System::String ^scriptFileName)
-            {
-                if (*_compiledScript == NULL)
-                {
-                    throw gcnew AGS::Types::CompileError(gcnew System::String("Script has not been compiled: ") + scriptFileName);
-                }
-                System::IO::BinaryWriter ^writer = gcnew System::IO::BinaryWriter(ostream);
-                for (int i = 0; i < 4; ++i)
-                {
-                    // the BinaryWriter seems to be treating CHAR as a 4-byte type here?
-                    writer->Write((System::Byte)scfilesig[i]);
-                }
-                const ccScript *cs = _compiledScript->get();
-                writer->Write((unsigned)SCOM_VERSION_CURRENT);
-                writer->Write((unsigned)cs->globaldata.size());
-                writer->Write((unsigned)cs->code.size());
-                writer->Write((unsigned)cs->strings.size());
-                for (size_t i = 0; i < cs->globaldata.size(); ++i)
-                {
-                    writer->Write((System::Byte)cs->globaldata[i]);
-                }
-                for (size_t i = 0; i < cs->code.size(); ++i)
-                {
-                    writer->Write((int)cs->code[i]);
-                }
-                for (size_t i = 0; i < cs->strings.size(); ++i)
-                {
-                    writer->Write((System::Byte)cs->strings[i]);
-                }
-                writer->Write((unsigned)cs->fixups.size());
-                for (size_t i = 0; i < cs->fixups.size(); ++i)
-                {
-                    writer->Write((System::Byte)cs->fixuptypes[i]);
-                }
-                for (size_t i = 0; i < cs->fixups.size(); ++i)
-                {
-                    writer->Write(cs->fixups[i]);
-                }
-                writer->Write((unsigned)cs->imports.size());
-                for (size_t i = 0; i < cs->imports.size(); ++i)
-                {
-                    WriteCStr(writer, cs->imports[i]);
-                }
-                writer->Write((unsigned)cs->exports.size());
-                for (size_t i = 0; i < cs->exports.size(); ++i)
-                {
-                    WriteCStr(writer, cs->exports[i]);
-                    writer->Write(cs->export_addr[i]);
-                }
-                writer->Write((unsigned)cs->sectionNames.size());
-                for (size_t i = 0; i < cs->sectionNames.size(); ++i)
-                {
-                    WriteCStr(writer, cs->sectionNames[i]);
-                    writer->Write(cs->sectionOffsets[i]);
-                }
-                writer->Write((unsigned)ENDFILESIG);
-            }
-        };
-	}
-}
\ No newline at end of file
diff --git a/Editor/AGS.Native/agsnative.cpp b/Editor/AGS.Native/agsnative.cpp
index 7884aad459..9fb451501c 100644
--- a/Editor/AGS.Native/agsnative.cpp
+++ b/Editor/AGS.Native/agsnative.cpp
@@ -1714,7 +1714,7 @@ using namespace System::Collections::Generic;
 using namespace System::Drawing;
 using namespace System::Drawing::Imaging;
 using namespace System::Runtime::InteropServices;
-#include "scripting.h"
+#include "CompiledScript.h"
 
 void ThrowManagedException(const char *message) 
 {

From 41090c6767c9f9c1097114d3425116893e9d39dd Mon Sep 17 00:00:00 2001
From: Ivan Mogilko <ikm_spb@yahoo.com>
Date: Thu, 31 Oct 2024 00:25:13 +0300
Subject: [PATCH 2/2] agscc: hotfix deprecated SCOPT_SHOWWARNINGS

---
 Compiler/compiler.cpp | 4 +---
 Compiler/compiler.h   | 2 +-
 Compiler/main.cpp     | 3 ++-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Compiler/compiler.cpp b/Compiler/compiler.cpp
index 0878a4efaf..3238effb89 100644
--- a/Compiler/compiler.cpp
+++ b/Compiler/compiler.cpp
@@ -88,7 +88,7 @@ void CompilerOptions::PrintToStdout() const {
     printf("ScriptCompatLevel: %s\n", ScriptAPI.ScriptCompatLevel.c_str());
     printf("Flags: ");
     if (Flags.ExportAll) printf("ExportAll; ");
-    if (Flags.ShowWarnings) printf("ShowWarnings; ");
+    //if (Flags.ShowWarnings) printf("ShowWarnings; ");
     if (Flags.LineNumbers) printf("LineNumbers; ");
     if (Flags.AutoImport) printf("AutoImport; ");
     if (Flags.DebugRun) printf("DebugRun; ");
@@ -173,8 +173,6 @@ int Compile(const CompilerOptions& comp_opts)
     //-----------------------------------------------------------------------//
     ccSetSoftwareVersion(comp_opts.Version.c_str());
 
-    ccSetOption(SCOPT_SHOWWARNINGS, comp_opts.Flags.ShowWarnings);
-
     ccSetOption(SCOPT_EXPORTALL, comp_opts.Flags.ExportAll);
     ccSetOption(SCOPT_LINENUMBERS, comp_opts.Flags.LineNumbers);
     // now deprecated, was used to prevent override imports in the room script
diff --git a/Compiler/compiler.h b/Compiler/compiler.h
index d5039b6fed..6a5c199356 100644
--- a/Compiler/compiler.h
+++ b/Compiler/compiler.h
@@ -28,7 +28,7 @@
 class CompilerOptions{
     struct Flags {
         bool ExportAll = true;               // export all functions automatically
-        bool ShowWarnings = true;             // printf warnings to console
+        //bool ShowWarnings = true;          // printf warnings to console; [DEPRECATED], impl proper output verbosity instead?
         bool LineNumbers = true;             // include line numbers in compiled code
         bool AutoImport = false;              // when creating instance, export funcs to other scripts
         bool DebugRun = false;                // write instructions as they are processed to log file
diff --git a/Compiler/main.cpp b/Compiler/main.cpp
index 35892b84c7..66dc26a499 100644
--- a/Compiler/main.cpp
+++ b/Compiler/main.cpp
@@ -192,10 +192,11 @@ ParsedOptions parser_to_compiler_opts(const ParseResult& parseResult)
                 flag_value = !(flag_val_str == "0");
             }
 
+            /* [DEPRECATED], impl proper output verbosity instead?
             if(flag_name == "showwarnings") {
                 compilerOptions.Flags.ShowWarnings = flag_value;
                 continue;
-            }
+            } */
             if(flag_name == "exportall") {
                 compilerOptions.Flags.ExportAll = flag_value;
                 continue;