ifpscc: initial commit

libifpscc: initial commit
readme: document ifpscc/libifpscc
license: add credits for ifpscc/libifpscc (derived from code also MIT licensed)
libifps: make additional fields/types public for libifpscc
libifps: fix field documentation for some opcodes
libifps: fix loading functions that are not exported
libifps: allow saving a nonexistant primitive type if the same primitive type was added already
libifps: fix parsing Extended constants
libifps: fix ushort/short being mapped to the wrong types in one table
csproj: set Prefer32Bit=false for release builds

Author: Wack0

IFPSLib/Emit/BytecodeOperandType.cs

@@ -7,7 +7,7 @@ namespace IFPSLib.Emit
     /// <summary>
     /// Type of a PascalScript operand at the bytecode level.
     /// </summary>
-    internal enum BytecodeOperandType : byte
+    public enum BytecodeOperandType : byte
     {
         /// <summary>
         /// Operand refers to a local or global variable, or an argument.

IFPSLib/Emit/ExternalFunction.cs

@@ -147,8 +147,8 @@ public override string ToString()
                     "dll(\"{0}\",\"{1}\"{2}{3}) {4}",
                     DllName.Replace("\"", "\\\""),
                     ProcedureName.Replace("\"", "\\\""),
-                    DelayLoad ? "delayload, " : "",
-                    LoadWithAlteredSearchPath ? "alteredsearchpath" : "",
+                    DelayLoad ? ", delayload" : "",
+                    LoadWithAlteredSearchPath ? ", alteredsearchpath" : "",
                     base.ToString()
                 );
             }

IFPSLib/Emit/Instruction.cs

@@ -85,6 +85,7 @@ internal Instruction(OpCode opcode)
         /// <param name="operands">Operands</param>
         internal Instruction(OpCode opcode, List<Operand> operands) : this(opcode)
         {
+            if (operands.Any((op) => op == null)) throw new ArgumentNullException("operand");
             m_Operands = operands;
         }
 
@@ -180,6 +181,16 @@ public static Instruction Create(OpCode opcode, IVariable op0, IVariable op1)
         public static Instruction Create<TType>(OpCode opcode, IVariable op0, TType val)
             => Create(opcode, Operand.Create(op0), Operand.Create(val));
 
+        /// <summary>
+        /// Creates a new instruction with two variable operands
+        /// </summary>
+        /// <param name="opcode">Opcode</param>
+        /// <param name="op0">First operand</param>
+        /// <param name="op1">Second operand</param>
+        /// <returns>New instruction</returns>
+        public static Instruction Create(OpCode opcode, IVariable op0, Operand op1)
+            => Create(opcode, Operand.Create(op0), op1);
+
         /// <summary>
         /// Creates a new branch instruction with an operand
         /// </summary>

IFPSLib/Emit/OpCodes.cs

@@ -80,15 +80,15 @@ private static void FillTable(OpCode[] table, OpCode op)
         /// </summary>
         public static readonly OpCode Mod = new OpCode("mod", Code.Mod, OperandType.InlineValueValue, FlowControl.Next, OpCodeType.Macro);
         /// <summary>
-        /// Shifts the first value left by the second value; <c>op0 <<= op1</c>
+        /// Shifts the first value left by the second value; <c>op0 &lt;&lt;= op1</c>
         /// </summary>
         public static readonly OpCode Shl = new OpCode("shl", Code.Shl, OperandType.InlineValueValue, FlowControl.Next, OpCodeType.Macro);
         /// <summary>
         /// Shifts the first value right by the second value; <c>op0 >>= op1</c>
         /// </summary>
         public static readonly OpCode Shr = new OpCode("shr", Code.Shr, OperandType.InlineValueValue, FlowControl.Next, OpCodeType.Macro);
         /// <summary>
-        /// Bitwise ANDs the first value by the second value; <c>op0 &= op1</c>
+        /// Bitwise ANDs the first value by the second value; <c>op0 &amp;= op1</c>
         /// </summary>
         public static readonly OpCode And = new OpCode("and", Code.And, OperandType.InlineValueValue, FlowControl.Next, OpCodeType.Macro);
         /// <summary>
@@ -194,7 +194,7 @@ private static void FillTable(OpCode[] table, OpCode op)
         /// </summary>
         public static readonly OpCode CallVar = new OpCode("callvar", Code.CallVar, OperandType.InlineValue, FlowControl.Call, OpCodeType.Primitive, StackBehaviour.Push1);
         /// <summary>
-        /// op0 must be a pointer.<br/>
+        /// op0 must be a pointer, which may be a null pointer.<br/>
         /// If op1 is not a pointer, loads the equivalent address of op1 into op0; <c>op0 = &amp;op1</c><br/>
         /// If op1 is a pointer, loads op1 into op0; <c>op0 = op1</c>
         /// </summary>
@@ -253,7 +253,11 @@ private static void FillTable(OpCode[] table, OpCode op)
         /// </summary>
         public static readonly OpCode Not = new OpCode("not", Code.Not, OperandType.InlineValue, FlowControl.Next, OpCodeType.Primitive);
         /// <summary>
-        /// <c>*op0 = *op1</c>
+        /// Copy constructor.<br/>
+        /// Operand 0 must be a pointer, which may be a null pointer.<br/>
+        /// First, <c>op0</c> is set to newly constructed pointer of <c>op1</c>'s type (if <c>op1</c> is a pointer, then <c>*op1</c>'s type).<br/>
+        /// If Operand 1 is a pointer, <c>*op0 = *op1</c><br/>
+        /// Otherwise, <c>*op0 = op1</c>
         /// </summary>
         public static readonly OpCode Cpval = new OpCode("cpval", Code.Cpval, OperandType.InlineValueValue, FlowControl.Next, OpCodeType.Primitive);
         /// <summary>

IFPSLib/Emit/Operand.cs

@@ -41,6 +41,8 @@ private struct Value
         internal BytecodeOperandType m_Type;
         private Value m_Value;
 
+        public BytecodeOperandType Type => m_Type;
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private T EnsureType<T>(ref T value, BytecodeOperandType type)
         {
@@ -75,45 +77,66 @@ public Operand(TypedData imm)
 
         public Operand(IVariable var)
         {
+            if (var == null) throw new ArgumentNullException(nameof(var));
             m_Type = BytecodeOperandType.Variable;
             m_Value.Variable = var;
         }
 
         public Operand(IVariable arr, uint immIdx)
         {
+            if (arr == null) throw new ArgumentNullException(nameof(arr));
             m_Type = BytecodeOperandType.IndexedImmediate;
             m_Value.Indexed.Variable = arr;
             m_Value.Indexed.Index.m_Immediate = new StrongBox<uint>(immIdx);
         }
 
         public Operand(IVariable arr, IVariable varIdx)
         {
+            if (arr == null) throw new ArgumentNullException(nameof(arr));
+            if (varIdx == null) throw new ArgumentNullException(nameof(varIdx));
             m_Type = BytecodeOperandType.IndexedVariable;
             m_Value.Indexed.Variable = arr;
             m_Value.Indexed.Index.Variable = varIdx;
         }
 
+        public Operand(Operand op)
+        {
+            m_Type = op.m_Type;
+            m_Value = op.m_Value;
+        }
+
         public static Operand Create<TType>(Types.PrimitiveType type, TType value)
         {
             return new Operand(TypedData.Create(type, value));
         }
 
         public static Operand Create<TType>(TType value)
         {
+            // this is supposed to be for only primitives, but derived interfaces can also lead here.
+            // check for those derived interfaces.
+            switch (value)
+            {
+                case Types.IType type:
+                    return Create(type);
+                case IFunction fn:
+                    return Create(fn);
+                case IVariable var:
+                    return Create(var);
+            }
             return new Operand(TypedData.Create(value));
         }
 
-        internal static Operand Create(Types.IType value)
+        public static Operand Create(Types.IType value)
         {
             return new Operand(TypedData.Create(value));
         }
 
-        internal static Operand Create(Instruction value)
+        public static Operand Create(Instruction value)
         {
             return new Operand(TypedData.Create(value));
         }
 
-        internal static Operand Create(IFunction value)
+        public static Operand Create(IFunction value)
         {
             return new Operand(TypedData.Create(value));
         }

IFPSLib/Emit/ScriptFunction.cs

@@ -48,7 +48,8 @@ internal static ScriptFunction Load(BinaryReader br, Script script, bool exporte
 
                 // Next are arguments. First char is the argument type ('@' means in, otherwise '!'), followed by the type index
                 ret.Arguments = new List<FunctionArgument>(decl.Length - 1);
-                for (int i = 1; i < decl.Length; i++) {
+                for (int i = 1; i < decl.Length; i++)
+                {
                     var arg = new FunctionArgument();
                     arg.ArgumentType = (decl[i][0] == ARGUMENT_TYPE_IN ? FunctionArgumentType.In : FunctionArgumentType.Out);
                     if (!int.TryParse(decl[i].Substring(1), out var idxType) || idxType < 0) arg.Type = null;
@@ -57,6 +58,11 @@ internal static ScriptFunction Load(BinaryReader br, Script script, bool exporte
                     ret.Arguments.Add(arg);
                 }
             }
+            else
+            {
+                ret.Name = string.Format("func_{0:x}", ret.CodeOffset);
+                ret.Arguments = new List<FunctionArgument>();
+            }
 
             return ret;
         }

IFPSLib/Script.cs

@@ -160,6 +160,7 @@ public static async Task<Script> LoadAsync(Stream stream)
         internal class SaveContext
         {
             internal readonly Dictionary<IType, int> tblTypes;
+            internal readonly Dictionary<PascalTypeCode, int> tblPrimitiveTypes;
             internal readonly Dictionary<IFunction, int> tblFunctions;
             internal readonly Dictionary<GlobalVariable, int> tblGlobals;
             internal readonly Dictionary<IFunction, long> tblFunctionOffsets;
@@ -168,13 +169,19 @@ internal class SaveContext
             internal SaveContext(Script script)
             {
                 tblTypes = new Dictionary<IType, int>();
+                tblPrimitiveTypes = new Dictionary<PascalTypeCode, int>();
                 tblFunctions = new Dictionary<IFunction, int>();
                 tblGlobals = new Dictionary<GlobalVariable, int>();
                 tblFunctionOffsets = new Dictionary<IFunction, long>();
 
                 FileVersion = script.FileVersion;
 
-                for (int i = 0; i < script.Types.Count; i++) tblTypes.Add(script.Types[i], i);
+                for (int i = 0; i < script.Types.Count; i++)
+                {
+                    var type = script.Types[i];
+                    tblTypes.Add(type, i);
+                    if (type is PrimitiveType && !tblPrimitiveTypes.ContainsKey(type.BaseType)) tblPrimitiveTypes.Add(type.BaseType, i);
+                }
                 for (int i = 0; i < script.Functions.Count; i++) tblFunctions.Add(script.Functions[i], i);
                 for (int i = 0; i < script.GlobalVariables.Count; i++) tblGlobals.Add(script.GlobalVariables[i], i);
             }
@@ -185,11 +192,15 @@ internal int GetTypeIndex(IType type)
                 {
                     throw new ArgumentOutOfRangeException(string.Format("Used an unknown type"));
                 }
-                if (!tblTypes.TryGetValue(type, out var idx))
+                if (tblTypes.TryGetValue(type, out var idx)) return idx;
+
+                // For a primitive type, check the primitives table too.
+                if (type is PrimitiveType)
                 {
-                    throw new KeyNotFoundException(string.Format("Used unreferenced type {0}, make sure it's added to the Types list.", type.Name));
+                    if (tblPrimitiveTypes.TryGetValue(type.BaseType, out idx)) return idx;
                 }
-                return idx;
+
+                throw new KeyNotFoundException(string.Format("Used unreferenced type {0}, make sure it's added to the Types list.", type.Name));
             }
 
             internal int GetFunctionIndex(IFunction function)

IFPSLib/TypedData.cs

@@ -64,6 +64,35 @@ public TType ValueAs<TType>()
             return (TType)Value;
         }
 
+        private static void TrimDecimalString(StringBuilder sb)
+        {
+            // find the "e" looking from the end
+            int idx = sb.Length;
+            for (int i = sb.Length - 1; i >= 0; i--)
+            {
+                if (sb[i] == 'e')
+                {
+                    idx = i - 1;
+                    break;
+                }
+            }
+
+            // remove while character is '0'
+            int length = 0;
+            while (idx >= 0 && sb[idx] == '0')
+            {
+                length++;
+                idx--;
+            }
+            if (sb[idx] == '.') // need at least one zero
+            {
+                length--;
+                idx++;
+            }
+            if (length == 0) return;
+            sb.Remove(idx + 1, length);
+        }
+
         internal static TypedData Load(BinaryReader br, Script script)
         {
             var idxType = br.Read<uint>();
@@ -98,8 +127,13 @@ internal static TypedData Load(BinaryReader br, Script script)
                 case PascalTypeCode.Double:
                     return new TypedData(type, br.Read<double>());
                 case PascalTypeCode.Extended:
-                    // BUGBUG: there must be something beter than this... but for now, it'll do
-                    return new TypedData(type, decimal.Parse(br.Read<ExtF80>().ToString()));
+                    {
+                        // BUGBUG: there must be something beter than this... but for now, it'll do
+                        var sb = new StringBuilder();
+                        ExtF80.PrintFloat80(sb, br.Read<ExtF80>(), PrintFloatFormat.ScientificFormat, 19);
+                        TrimDecimalString(sb);
+                        return new TypedData(type, decimal.Parse(sb.ToString(), System.Globalization.NumberStyles.Float));
+                    }
 
                 case PascalTypeCode.Currency:
                     return new TypedData(type, new CurrencyWrapper(decimal.FromOACurrency(br.Read<long>())));

IFPSLib/Types/PascalTypeCode.cs

@@ -60,8 +60,8 @@ public static partial class EnumHelpers
         {
             { typeof(byte), PascalTypeCode.U8 },
             { typeof(sbyte), PascalTypeCode.S8 },
-            { typeof(ushort), PascalTypeCode.S16 },
-            { typeof(short), PascalTypeCode.U16 },
+            { typeof(ushort), PascalTypeCode.U16 },
+            { typeof(short), PascalTypeCode.S16 },
             { typeof(uint), PascalTypeCode.U32 },
             { typeof(int), PascalTypeCode.S32 },
             { typeof(long), PascalTypeCode.S64 },

IFPSTools.NET.sln

@@ -11,12 +11,16 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ifpsdasm", "ifpsdasm\ifpsda
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ifpsasm", "ifpsasm\ifpsasm.csproj", "{8C1A1532-1A40-46DB-BBDF-B4489BD0F966}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IFPSAsmLib", "IFPSAsmLib\IFPSAsmLib.csproj", "{63B7741E-D712-4277-B345-F5B77AC80EB1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IFPSAsmLib", "IFPSAsmLib\IFPSAsmLib.csproj", "{63B7741E-D712-4277-B345-F5B77AC80EB1}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "uninno", "uninno\uninno.csproj", "{5092701D-8D7E-4AB4-9877-DADCE1266B3D}"
 EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "LoadSaveExtensions", "LoadSaveExtensions\LoadSaveExtensions.shproj", "{AF654578-B67D-4E5E-9CA6-E8AED9D0051A}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibIFPSCC", "LibIFPSCC\LibIFPSCC.csproj", "{B56F2451-B1FF-4103-A2BC-0C61463D6971}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ifpscc", "ifpscc\ifpscc.csproj", "{8B953068-8B67-4D9A-802C-7657A7CAFC78}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -47,6 +51,14 @@ Global
 		{5092701D-8D7E-4AB4-9877-DADCE1266B3D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5092701D-8D7E-4AB4-9877-DADCE1266B3D}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5092701D-8D7E-4AB4-9877-DADCE1266B3D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B56F2451-B1FF-4103-A2BC-0C61463D6971}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B56F2451-B1FF-4103-A2BC-0C61463D6971}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B56F2451-B1FF-4103-A2BC-0C61463D6971}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B56F2451-B1FF-4103-A2BC-0C61463D6971}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8B953068-8B67-4D9A-802C-7657A7CAFC78}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8B953068-8B67-4D9A-802C-7657A7CAFC78}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8B953068-8B67-4D9A-802C-7657A7CAFC78}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8B953068-8B67-4D9A-802C-7657A7CAFC78}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE