Add support for 64-bit scripts;

Author: onepiecefreak3

XtractQuery/Logic.Business.Level5ScriptManagement/Logic.Business.Level5ScriptManagement/InternalContract/ILevel5ScriptSyntaxTreeConverter.cs

@@ -13,6 +13,6 @@ namespace Logic.Business.Level5ScriptManagement.InternalContract
     [MapException(typeof(Level5SyntaxTreeConverterException))]
     public interface ILevel5CodeUnitConverter
     {
-        ScriptFile CreateScriptFile(CodeUnitSyntax tree, ScriptType type);
+        ScriptFile CreateScriptFile(CodeUnitSyntax tree);
     }
 }

XtractQuery/Logic.Business.Level5ScriptManagement/Logic.Business.Level5ScriptManagement/Level5CodeUnitConverter.cs

@@ -17,7 +17,7 @@ public Level5CodeUnitConverter(IMethodNameMapper methodNameMapper)
             _methodNameMapper = methodNameMapper;
         }
 
-        public ScriptFile CreateScriptFile(CodeUnitSyntax tree, ScriptType type)
+        public ScriptFile CreateScriptFile(CodeUnitSyntax tree)
         {
             var result = new ScriptFile
             {
@@ -121,7 +121,7 @@ private void AddPostfixUnaryStatement(ScriptFile result, PostfixUnaryStatementSy
                 default:
                     throw CreateException($"Invalid operation {(SyntaxTokenKind)postfixUnaryStatement.Expression.Operation.RawKind} in postfix unary expression.", postfixUnaryStatement.Expression.Location);
             }
-            
+
             if (postfixUnaryStatement.Expression.Value is ValueExpressionSyntax { Value: VariableExpressionSyntax variable })
             {
                 int variableSlot = GetVariable(variable);

XtractQuery/Logic.Business.Level5ScriptManagement/Logic.Business.Level5ScriptManagement/Level5ScriptManagementConfigurationValidator.cs

@@ -17,6 +17,7 @@ public void Validate(Level5ScriptManagementConfiguration config)
 
             ValidateOperation(config);
             ValidateFilePath(config);
+            ValidatePointerLength(config);
             ValidateQueryType(config);
         }
 
@@ -38,6 +39,18 @@ private void ValidateFilePath(Level5ScriptManagementConfiguration config)
                 throw new Level5ScriptManagementConfigurationValidationException($"File or directory '{Path.GetFullPath(config.FilePath)}' was not found.");
         }
 
+        private void ValidatePointerLength(Level5ScriptManagementConfiguration config)
+        {
+            if (config.Operation != "c")
+                return;
+
+            if (string.IsNullOrWhiteSpace(config.Length))
+                throw new Level5ScriptManagementConfigurationValidationException("No pointer length was given. Specify a pointer length by using the -l argument.");
+
+            if (config.Length != "int" && config.Length != "long")
+                throw new Level5ScriptManagementConfigurationValidationException($"The pointer length '{config.Length}' is not valid. Use -h to see a list of valid pointer lengths.");
+        }
+
         private void ValidateQueryType(Level5ScriptManagementConfiguration config)
         {
             if (config.Operation != "c")

XtractQuery/Logic.Business.Level5ScriptManagement/Logic.Business.Level5ScriptManagement/Level5ScriptManagementWorkflow.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Logic.Business.Level5ScriptManagement.Contract;
+using Logic.Business.Level5ScriptManagement.Contract;
 using Logic.Business.Level5ScriptManagement.InternalContract;
 using Logic.Domain.CodeAnalysis.Contract.Level5;
 using Logic.Domain.CodeAnalysis.Contract.Level5.DataClasses;
@@ -168,15 +162,16 @@ private void CreateScript(string filePath)
             // Convert to script data
             CodeUnitSyntax codeUnit = _scriptParser.ParseCodeUnit(readableScript);
 
-            ScriptType type = DetermineScriptType(_config.QueryType);
-            ScriptFile script = _treeConverter.CreateScriptFile(codeUnit, type);
+            ScriptFile script = _treeConverter.CreateScriptFile(codeUnit);
+            script.Length = DeterminePointerLength(_config.Length);
 
             // Write script data
+            ScriptType type = DetermineScriptType(_config.QueryType);
             IScriptWriter scriptWriter = _writerFactory.Create(type);
 
             using Stream newFileStream = File.Create(filePath + ".xq");
 
-            scriptWriter.Write(script, newFileStream);
+            scriptWriter.Write(script, newFileStream, !_config.WithoutCompression);
         }
 
         private void DecompressScripts()
@@ -209,15 +204,15 @@ private void DecompressScripts()
         private void DecompressScript(string filePath)
         {
             // Decompress script data
-            using Stream fileStream = File.OpenRead(_config.FilePath);
+            using Stream fileStream = File.OpenRead(filePath);
 
             ScriptType type = _typeReader.Peek(fileStream);
             IScriptDecompressor decompressor = _decompressorFactory.Create(type);
 
             ScriptContainer container = decompressor.Decompress(fileStream);
 
             // Write script data
-            using Stream newFileStream = File.Create(_config.FilePath + ".dec");
+            using Stream newFileStream = File.Create(filePath + ".dec");
 
             IScriptCompressor compressor = _compressorFactory.Create(type);
 
@@ -264,20 +259,43 @@ private ScriptType DetermineScriptType(string type)
             }
         }
 
+        private PointerLength DeterminePointerLength(string type)
+        {
+            switch (type)
+            {
+                case "int":
+                    return PointerLength.Int;
+
+                case "long":
+                    return PointerLength.Long;
+
+                default:
+                    throw new InvalidOperationException($"Unsupported pointer length {type}");
+            }
+        }
+
         private void PrintHelp()
         {
             Console.WriteLine("Following commands exist:");
             Console.WriteLine("  -h, --help\t\tShows this help message.");
             Console.WriteLine("  -o, --operation\tThe operation to take on the file");
-            Console.WriteLine("    Valid operations are: e for extraction, c for creation, d for decompression");
             Console.WriteLine("  -t, --type\t\tThe type of file given");
             Console.WriteLine("    Valid types are: xq32, xseq");
             Console.WriteLine("    The type is automatically detected when extracting; This argument will not have any effect on operation 'e'");
+            Console.WriteLine("    Valid operations are: e for extraction, c for creation, d for decompression");
             Console.WriteLine("  -f, --file\t\tThe file to process");
+            Console.WriteLine("  -n, --no-compression\t[Optional] If the file uses a compression layer");
+            Console.WriteLine("    This option is automatically detected when extracting; This argument will not have any effect on operation 'e'");
+            Console.WriteLine("  -l, --length\t\t[Optional]The pointer length given");
+            Console.WriteLine("    Valid lengths are: int, long");
+            Console.WriteLine("    Default value is 'int'");
+            Console.WriteLine("    The length is automatically detected when extracting; This argument will not have any effect on operation 'e'");
             Console.WriteLine();
             Console.WriteLine("Examples:");
             Console.WriteLine($"\tExtract any script to human readable text: {Environment.ProcessPath} -o e -f Path/To/File.xq");
             Console.WriteLine($"\tCreate a xq32 script from human readable text: {Environment.ProcessPath} -o c -t xq32 -f Path/To/File.txt");
+            Console.WriteLine($"\tCreate a xq32 script with long pointers from human readable text: {Environment.ProcessPath} -o c -t xq32 -l long -f Path/To/File.txt");
+            Console.WriteLine($"\tCreate a xq32 script without a compression layer from human readable text: {Environment.ProcessPath} -o c -t xq32 -n -f Path/To/File.txt");
         }
 
         private Exception GetInnermostException(Exception e)

XtractQuery/Logic.Business.Level5ScriptManagement/Logic.Business.Level5ScriptManagement/_Configuration.cs

@@ -1,9 +1,4 @@
 using CrossCutting.Core.Contract.Configuration.DataClasses;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Logic.Business.Level5ScriptManagement
 {
@@ -18,6 +13,12 @@ public class Level5ScriptManagementConfiguration
         [ConfigMap("CommandLine", new[] { "t", "type" })]
         public virtual string QueryType { get; set; }
 
+        [ConfigMap("CommandLine", new[] { "l", "length" })]
+        public virtual string Length { get; set; } = "int";
+
+        [ConfigMap("CommandLine", new[] { "n", "no-compression" })]
+        public virtual bool WithoutCompression { get; set; } = false;
+
         [ConfigMap("CommandLine", new[] { "f", "file" })]
         public virtual string FilePath { get; set; }
 

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/DataClasses/PointerLength.cs

@@ -0,0 +1,8 @@
+namespace Logic.Domain.Level5.Contract.Script.DataClasses
+{
+    public enum PointerLength
+    {
+        Int,
+        Long
+    }
+}

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/DataClasses/ScriptFile.cs

@@ -12,5 +12,7 @@ public class ScriptFile
         public IList<ScriptJump> Jumps { get; set; }
         public IList<ScriptInstruction> Instructions { get; set; }
         public IList<ScriptArgument> Arguments { get; set; }
+
+        public PointerLength Length { get; set; }
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/DataClasses/ScriptHeader.cs

@@ -9,7 +9,7 @@ namespace Logic.Domain.Level5.Contract.Script.DataClasses
 {
     public class ScriptStringTable
     {
-        public CompressionType CompressionType { get; set; }
+        public CompressionType? CompressionType { get; set; }
         public Stream Stream { get; set; }
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/DataClasses/ScriptStringTable.cs

@@ -10,7 +10,7 @@ namespace Logic.Domain.Level5.Contract.Script.DataClasses
     public class ScriptTable
     {
         public int EntryCount { get; set; }
-        public CompressionType CompressionType { get; set; }
+        public CompressionType? CompressionType { get; set; }
         public Stream Stream { get; set; }
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/DataClasses/ScriptTable.cs

@@ -13,7 +13,7 @@ namespace Logic.Domain.Level5.Contract.Script
     [MapException(typeof(ScriptCompressorException))]
     public interface IScriptCompressor
     {
-        void Compress(ScriptContainer container, Stream output);
+        void Compress(ScriptContainer container, Stream output, bool hasCompression);
         void Compress(ScriptContainer container, Stream output, CompressionType compressionType);
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/IScriptCompressor.cs

@@ -0,0 +1,12 @@
+using Logic.Domain.Level5.Contract.Script.DataClasses;
+
+namespace Logic.Domain.Level5.Contract.Script
+{
+    public interface IScriptEntrySizeProvider
+    {
+        int GetFunctionEntrySize(PointerLength length);
+        int GetJumpEntrySize(PointerLength length);
+        int GetInstructionEntrySize(PointerLength length);
+        int GetArgumentEntrySize(PointerLength length);
+    }
+}

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/IScriptEntrySizeProvider.cs

@@ -0,0 +1,14 @@
+using Logic.Domain.Level5.Contract.Script.DataClasses;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Logic.Domain.Level5.Contract.Script
+{
+    public interface IScriptEntrySizeProviderFactory
+    {
+        IScriptEntrySizeProvider Create(ScriptType type);
+    }
+}

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/IScriptEntrySizeProviderFactory.cs

@@ -1,9 +1,4 @@
 using CrossCutting.Core.Contract.Aspects;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Logic.Domain.Level5.Contract.Script.Exceptions;
 using Logic.Domain.Level5.Contract.Script.DataClasses;
 

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/IScriptReader.cs

@@ -13,9 +13,9 @@ namespace Logic.Domain.Level5.Contract.Script
     [MapException(typeof(ScriptWriterException))]
     public interface IScriptWriter
     {
-        void Write(ScriptFile script, Stream output);
+        void Write(ScriptFile script, Stream output, bool hasCompression);
         void Write(ScriptFile script, Stream output, CompressionType compressionType);
-        void Write(ScriptContainer container, Stream output);
+        void Write(ScriptContainer container, Stream output, bool hasCompression);
         void Write(ScriptContainer container, Stream output, CompressionType compressionType);
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/IScriptWriter.cs

@@ -2,7 +2,7 @@
 {
     public struct Xq32Function
     {
-        public int nameOffset;
+        public long nameOffset;
         public uint crc32;
         public short instructionOffset;
         public short instructionEndOffset;

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xq32/DataClasses/Xq32Function.cs

@@ -2,7 +2,7 @@
 {
     public struct Xq32Jump
     {
-        public int nameOffset;
+        public long nameOffset;
         public uint crc32;
         public int instructionIndex;
     }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xq32/DataClasses/Xq32Jump.cs

@@ -8,10 +8,10 @@ namespace Logic.Domain.Level5.Contract.Script.Xq32
     [MapException(typeof(Xq32ScriptReaderException))]
     public interface IXq32ScriptReader : IScriptReader
     {
-        IReadOnlyList<Xq32Function> ReadFunctions(Stream functionStream, int entryCount);
-        IReadOnlyList<Xq32Jump> ReadJumps(Stream jumpStream, int entryCount);
-        IReadOnlyList<Xq32Instruction> ReadInstructions(Stream instructionStream, int entryCount);
-        IReadOnlyList<Xq32Argument> ReadArguments(Stream argumentStream, int entryCount);
+        IReadOnlyList<Xq32Function> ReadFunctions(Stream functionStream, int entryCount, PointerLength length);
+        IReadOnlyList<Xq32Jump> ReadJumps(Stream jumpStream, int entryCount, PointerLength length);
+        IReadOnlyList<Xq32Instruction> ReadInstructions(Stream instructionStream, int entryCount, PointerLength length);
+        IReadOnlyList<Xq32Argument> ReadArguments(Stream argumentStream, int entryCount, PointerLength length);
 
         IList<ScriptFunction> CreateFunctions(IReadOnlyList<Xq32Function> functions, ScriptStringTable? stringTable = null);
         IList<ScriptJump> CreateJumps(IReadOnlyList<Xq32Jump> jumps, ScriptStringTable? stringTable = null);

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xq32/IXq32ScriptReader.cs

@@ -1,4 +1,5 @@
 using CrossCutting.Core.Contract.Aspects;
+using Logic.Domain.Level5.Contract.Script.DataClasses;
 using Logic.Domain.Level5.Contract.Script.Xq32.DataClasses;
 using Logic.Domain.Level5.Contract.Script.Xq32.Exceptions;
 
@@ -7,9 +8,9 @@ namespace Logic.Domain.Level5.Contract.Script.Xq32
     [MapException(typeof(Xq32ScriptWriterException))]
     public interface IXq32ScriptWriter : IScriptWriter
     {
-        void WriteFunctions(IReadOnlyList<Xq32Function> functions, Stream output);
-        void WriteJumps(IReadOnlyList<Xq32Jump> jumps, Stream output);
-        void WriteInstructions(IReadOnlyList<Xq32Instruction> instructions, Stream output);
-        void WriteArguments(IReadOnlyList<Xq32Argument> arguments, Stream output);
+        void WriteFunctions(IReadOnlyList<Xq32Function> functions, Stream output, PointerLength length);
+        void WriteJumps(IReadOnlyList<Xq32Jump> jumps, Stream output, PointerLength length);
+        void WriteInstructions(IReadOnlyList<Xq32Instruction> instructions, Stream output, PointerLength length);
+        void WriteArguments(IReadOnlyList<Xq32Argument> arguments, Stream output, PointerLength length);
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xq32/IXq32ScriptWriter.cs

@@ -2,7 +2,7 @@
 {
     public struct XseqFunction
     {
-        public int nameOffset;
+        public long nameOffset;
         public ushort crc16;
         public short instructionOffset;
         public short instructionEndOffset;

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xseq/DataClasses/XseqFunction.cs

@@ -2,7 +2,7 @@
 {
     public struct XseqJump
     {
-        public int nameOffset;
+        public long nameOffset;
         public ushort crc16;
         public short instructionIndex;
     }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xseq/DataClasses/XseqJump.cs

@@ -8,14 +8,14 @@ namespace Logic.Domain.Level5.Contract.Script.Xseq
     [MapException(typeof(XseqScriptReaderException))]
     public interface IXseqScriptReader : IScriptReader
     {
-        IReadOnlyList<XseqFunction> ReadFunctions(Stream functionStream, int entryCount);
-        IReadOnlyList<XseqJump> ReadJumps(Stream jumpStream, int entryCount);
-        IReadOnlyList<XseqInstruction> ReadInstructions(Stream instructionStream, int entryCount);
-        IReadOnlyList<XseqArgument> ReadArguments(Stream argumentStream, int entryCount);
+        IReadOnlyList<XseqFunction> ReadFunctions(Stream functionStream, int entryCount, PointerLength length);
+        IReadOnlyList<XseqJump> ReadJumps(Stream jumpStream, int entryCount, PointerLength length);
+        IReadOnlyList<XseqInstruction> ReadInstructions(Stream instructionStream, int entryCount, PointerLength length);
+        IReadOnlyList<XseqArgument> ReadArguments(Stream argumentStream, int entryCount, PointerLength length);
 
         IList<ScriptFunction> CreateFunctions(IReadOnlyList<XseqFunction> functions, ScriptStringTable? stringTable = null);
-        IList<ScriptJump> ReadJumps(IReadOnlyList<XseqJump> jumps, ScriptStringTable? stringTable = null);
-        IList<ScriptInstruction> ReadInstructions(IReadOnlyList<XseqInstruction> instructions);
-        IList<ScriptArgument> ReadArguments(IReadOnlyList<XseqArgument> arguments, ScriptStringTable? stringTable = null);
+        IList<ScriptJump> CreateJumps(IReadOnlyList<XseqJump> jumps, ScriptStringTable? stringTable = null);
+        IList<ScriptInstruction> CreateInstructions(IReadOnlyList<XseqInstruction> instructions);
+        IList<ScriptArgument> CreateArguments(IReadOnlyList<XseqArgument> arguments, ScriptStringTable? stringTable = null);
     }
 }

XtractQuery/Logic.Domain.Level5/Logic.Domain.Level5.Contract/Script/Xseq/IXseqScriptReader.cs

@@ -1,4 +1,5 @@
 using CrossCutting.Core.Contract.Aspects;
+using Logic.Domain.Level5.Contract.Script.DataClasses;
 using Logic.Domain.Level5.Contract.Script.Xseq.DataClasses;
 using Logic.Domain.Level5.Contract.Script.Xseq.Exceptions;
 
@@ -7,9 +8,9 @@ namespace Logic.Domain.Level5.Contract.Script.Xseq
     [MapException(typeof(XseqScriptWriterException))]
     public interface IXseqScriptWriter : IScriptWriter
     {
-        void WriteFunctions(IReadOnlyList<XseqFunction> functions, Stream output);
-        void WriteJumps(IReadOnlyList<XseqJump> jumps, Stream output);
-        void WriteInstructions(IReadOnlyList<XseqInstruction> instructions, Stream output);
-        void WriteArguments(IReadOnlyList<XseqArgument> arguments, Stream output);
+        void WriteFunctions(IReadOnlyList<XseqFunction> functions, Stream output, PointerLength length);
+        void WriteJumps(IReadOnlyList<XseqJump> jumps, Stream output, PointerLength length);
+        void WriteInstructions(IReadOnlyList<XseqInstruction> instructions, Stream output, PointerLength length);
+        void WriteArguments(IReadOnlyList<XseqArgument> arguments, Stream output, PointerLength length);
     }
 }