Implement IL codes for #91, #93, fix #105

IL2C.Core/AssemblyPreparer.cs

@@ -322,7 +322,7 @@ public static PreparedInformations Prepare(TranslateContext translateContext)
                 // All types
                 type => true,
                 // The methods except type initializer.
-                method => !(method.IsConstructor && method.IsStatic));
+                method => true);
         }
     }
 }

IL2C.Core/ILConveters/ArithmeticalConverters.cs

@@ -234,4 +234,122 @@ public override ExpressionEmitter Prepare(DecodeContext decodeContext)
                 ArithmeticalConverterUtilities.BinaryOperators.Rem, decodeContext);
         }
     }
+
+    internal sealed class NotConverter : InlineNoneConverter
+    {
+        public override OpCode OpCode => OpCodes.Not;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            var si0 = decodeContext.PopStack();
+            Metadata.ILocalVariableInformation result;
+
+            if (si0.TargetType.IsFloatStackFriendlyType || si0.TargetType.IsByReference)
+                throw new InvalidProgramSequenceException(
+                    "Invalid arithmetical NOT operation: Location={0}, Type0={1}",
+                    decodeContext.CurrentCode.RawLocation,
+                    si0.TargetType.FriendlyName);
+
+            if (si0.TargetType.IsInt32StackFriendlyType)
+            {
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type);
+            }
+            else
+            {   // Int64 = ~(Int64)
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int64Type);
+            }
+
+            return (extractContext, _) => new[] { string.Format(
+                    "{0} = ~{1}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0)) };
+        }
+    }
+
+    internal enum ShiftDirection
+    {
+        Left, Right
+    }
+
+    internal abstract class ShiftConverter : InlineNoneConverter
+    {
+        public abstract ShiftDirection Direction { get; }
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            var si1 = decodeContext.PopStack();
+            var si0 = decodeContext.PopStack();
+
+            if (si0.TargetType.IsFloatStackFriendlyType || si0.TargetType.IsByReference || !si1.TargetType.IsInt32Type)
+                throw new InvalidProgramSequenceException(
+                    "Invalid arithmetical NOT operation: Location={0}, Type0={1}",
+                    decodeContext.CurrentCode.RawLocation,
+                    si0.TargetType.FriendlyName);
+
+            var result = decodeContext.PushStack(si0.TargetType);
+
+            return (extractContext, _) => new[] { string.Format(
+                    "{0} = {1} {2} {3}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0),
+                    Direction == ShiftDirection.Left ? "<<" : ">>",
+                    extractContext.GetSymbolName(si1)) };
+        }
+    }
+
+    internal sealed class ShiftRightConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shr;
+
+        public override ShiftDirection Direction => ShiftDirection.Right;
+    }
+
+    internal sealed class ShiftLeftConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shl;
+
+        public override ShiftDirection Direction => ShiftDirection.Left;
+    }
+
+    internal sealed class ShiftRightUnConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shr_Un;
+
+        public override ShiftDirection Direction => ShiftDirection.Right;
+    }
+
+    internal sealed class NegConverter : InlineNoneConverter
+    {
+        public override OpCode OpCode => OpCodes.Neg;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            var si0 = decodeContext.PopStack();
+            Metadata.ILocalVariableInformation result;
+
+            if (si0.TargetType.IsByReference)
+                throw new InvalidProgramSequenceException(
+                    "Invalid arithmetical NEG operation: Location={0}, Type0={1}",
+                    decodeContext.CurrentCode.RawLocation,
+                    si0.TargetType.FriendlyName);
+
+            if (si0.TargetType.IsInt32StackFriendlyType)
+            {
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type);
+            }
+            else if (si0.TargetType.IsInt64StackFriendlyType)
+            {   // Int64 = -(Int64)
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int64Type);
+            }
+            else
+            {   // double = -(double)
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.DoubleType);
+            }
+
+            return (extractContext, _) => new[] { string.Format(
+                    "{0} = -{1}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0)) };
+        }
+    }
 }

IL2C.Core/ILConveters/StargConverters .cs

@@ -0,0 +1,67 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// IL2C - A translator for ECMA-335 CIL/MSIL to C language.
+// Copyright (c) 2016-2019 Kouji Matsui (@kozy_kekyo, @kekyo2)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+using System;
+
+using Mono.Cecil.Cil;
+
+using IL2C.Translators;
+using IL2C.Metadata;
+
+namespace IL2C.ILConverters
+{
+    internal static class StargConverterUtilities
+    {
+        public static ExpressionEmitter Prepare(
+            int parameterIndex, DecodeContext decodeContext, bool isReference)
+        {
+            var parameter = decodeContext.Method.Parameters[parameterIndex];
+            var targetType = isReference ? parameter.TargetType.MakeByReference() : parameter.TargetType;
+            var symbol = decodeContext.PushStack(targetType);
+
+            return (extractContext, _) => new[] { string.Format(
+                "{0} = {1}{2}",
+                parameter.ParameterName,
+                // NOTE: Don't check "targetType.IsByReference" instead "isReference."
+                //   Because it's maybe double encoded byref type.
+                isReference ? "&" : string.Empty,
+                extractContext.GetSymbolName(symbol)) };
+        }
+    }
+
+    internal sealed class StargSConverter : ShortInlineParamConverter
+    {
+        public override OpCode OpCode => OpCodes.Starg_S;
+
+        public override ExpressionEmitter Prepare(VariableInformation operand, DecodeContext decodeContext)
+        {
+            return StargConverterUtilities.Prepare(operand.Index, decodeContext, false);
+        }
+    }
+
+    internal sealed class StargConverter : InlineParamConverter
+    {
+        public override OpCode OpCode => OpCodes.Starg;
+
+        public override ExpressionEmitter Prepare(VariableInformation operand, DecodeContext decodeContext)
+        {
+            return StargConverterUtilities.Prepare(operand.Index, decodeContext, false);
+        }
+    }
+}

IL2C.Core/Metadata/MetadataContext.cs

@@ -112,9 +112,12 @@ internal MetadataContext(string assemblyPath, bool readSymbols)
 
             this.MainAssembly = mainAssemblyInformation;
             assemblies.Add(mainAssembly, mainAssemblyInformation);
-            assemblies.Add(resolvedCoreAssembly, resolvedCoreAssemblyInformation);
-            modules.Add(resolvedCoreModule, resolvedCoreModuleInformation);
-            assemblyByModule.Add(resolvedCoreModule, resolvedCoreAssembly);
+            if (!assemblies.ContainsKey(resolvedCoreAssembly))
+            {
+                assemblies.Add(resolvedCoreAssembly, resolvedCoreAssemblyInformation);
+                modules.Add(resolvedCoreModule, resolvedCoreModuleInformation);
+                assemblyByModule.Add(resolvedCoreModule, resolvedCoreAssembly);
+            }
 
             this.VoidType = this.GetOrAddType(resolvedCoreModule.TypeSystem.Void);
             this.ObjectType = this.GetOrAddType(resolvedCoreModule.TypeSystem.Object);

IL2C.Core/Metadata/MetadataUtilities.cs

@@ -424,10 +424,27 @@ public MethodSignatureComparerImpl(bool isVirtual)
 
             public int Compare(IMethodInformation x, IMethodInformation y)
             {
-                var rn = x.Name.CompareTo(y.Name);
+                var xname = x.Name;
+                var yname = y.Name;
+
+                var rn = xname.CompareTo(yname);
                 if (rn != 0)
                 {
-                    return rn;
+                    // If it is an explicit interface implementation, we need to compare with it's full name
+                    if (x.DeclaringType.IsInterface)
+                    {
+                        xname = $"{x.DeclaringType.FriendlyName}.{xname}";
+                    }
+                    if (y.DeclaringType.IsInterface)
+                    {
+                        yname = $"{y.DeclaringType.FriendlyName}.{yname}";
+                    }
+
+                    rn = xname.CompareTo(yname);
+                    if (rn != 0)
+                    {
+                        return rn;
+                    }
                 }
 
                 var xps = x.Parameters;
@@ -449,9 +466,25 @@ public int Compare(IMethodInformation x, IMethodInformation y)
 
             public bool Equals(IMethodInformation x, IMethodInformation y)
             {
-                if (x.Name != y.Name)
+                var xname = x.Name;
+                var yname = y.Name;
+
+                if (xname != yname)
                 {
-                    return false;
+                    // If it is an explicit interface implementation, we need to compare with it's full name
+                    if (x.DeclaringType.IsInterface)
+                    {
+                        xname = $"{x.DeclaringType.FriendlyName}.{xname}";
+                    }
+                    if (y.DeclaringType.IsInterface)
+                    {
+                        yname = $"{y.DeclaringType.FriendlyName}.{yname}";
+                    }
+
+                    if (xname != yname)
+                    {
+                        return false;
+                    }
                 }
 
                 var xps = x.Parameters;

IL2C.Core/Metadata/TypeInformation.cs

@@ -363,7 +363,7 @@ public bool IsReferenceType
         public bool IsRequiredTraverse =>
             (this.Member.IsValueType &&
              !this.Member.IsPrimitive && !this.Member.IsPointer && !this.IsByReference && !this.IsEnum &&
-             this.Fields.Any(f => f.FieldType.IsRequiredTraverse)) ||
+             this.Fields.Where(f => f.FieldType.FriendlyName != this.Member.FullName).Any(f => f.FieldType.IsRequiredTraverse)) ||
             this.IsReferenceType;
 
         private static int InternalGetStaticSizeOfValue(ITypeInformation type) =>