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

@@ -22,6 +22,7 @@
 using Mono.Cecil.Cil;
 
 using IL2C.Translators;
+using IL2C.Metadata;
 
 namespace IL2C.ILConverters
 {
@@ -78,7 +79,7 @@ public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeCo
                     extractContext.GetSymbolName(si1)) };
             }
 
-            // Double = (Float) % (Float)
+            // Double = (Float) op (Float)
             if (si0.TargetType.IsFloatStackFriendlyType && si1.TargetType.IsFloatStackFriendlyType &&
                 (binaryOperator == BinaryOperators.Rem))
             {
@@ -105,7 +106,7 @@ public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeCo
             }
 
             // ByRef = (Int32) + (ByRef)
-            if (si0.TargetType.IsInt32StackFriendlyType && si1.TargetType.IsByReference &&
+            if (si0.TargetType.IsInt32StackFriendlyType && (si1.TargetType.IsByReference) &&
                 (binaryOperator == BinaryOperators.Add))
             {
                 var result = decodeContext.PushStack(si1.TargetType);
@@ -118,7 +119,7 @@ public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeCo
             }
 
             // ByRef = (IntPtr) + (ByRef)
-            if (si0.TargetType.IsIntPtrStackFriendlyType && si1.TargetType.IsByReference &&
+            if (si0.TargetType.IsIntPtrStackFriendlyType && (si1.TargetType.IsByReference) &&
                 (binaryOperator == BinaryOperators.Add))
             {
                 var result = decodeContext.PushStack(si1.TargetType);
@@ -131,7 +132,7 @@ public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeCo
             }
 
             // ByRef = (ByRef) +/- (Int32|IntPtr)
-            if (si0.TargetType.IsByReference &&
+            if ((si0.TargetType.IsByReference || si0.TargetType.IsArray) &&
                 (si1.TargetType.IsInt32StackFriendlyType || si1.TargetType.IsIntPtrStackFriendlyType) &&
                 ((binaryOperator == BinaryOperators.Add) || (binaryOperator == BinaryOperators.Sub)))
             {
@@ -234,4 +235,150 @@ 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 ExpressionEmitter Prepare(DecodeContext decodeContext, Func<ILocalVariableInformation, string> cast)
+        {
+            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);
+
+            if (cast == null)
+            {
+                return (extractContext, _) => new[] { string.Format(
+                    "{0} = {1} {2} {3}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0),
+                    Direction == ShiftDirection.Left ? "<<" : ">>",
+                    extractContext.GetSymbolName(si1)) };
+            }
+            else
+            {
+                return (extractContext, _) => new[] { string.Format(
+                    "{0} = ({4}){1} {2} {3}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0),
+                    Direction == ShiftDirection.Left ? "<<" : ">>",
+                    extractContext.GetSymbolName(si1),
+                    cast(si0)) };
+            }
+        }
+    }
+
+    internal sealed class ShiftRightConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shr;
+
+        public override ShiftDirection Direction => ShiftDirection.Right;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            return Prepare(decodeContext, si => si.TargetType.IsInt32StackFriendlyType ? "int32_t" : "int64_t");
+        }
+    }
+
+    internal sealed class ShiftLeftConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shl;
+
+        public override ShiftDirection Direction => ShiftDirection.Left;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            return Prepare(decodeContext, null);
+        }
+    }
+
+    internal sealed class ShiftRightUnConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shr_Un;
+
+        public override ShiftDirection Direction => ShiftDirection.Right;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            return Prepare(decodeContext, si => si.TargetType.IsInt32StackFriendlyType ? "uint32_t" : "uint64_t");
+        }
+    }
+
+    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/BranchConverters.cs

@@ -241,6 +241,28 @@ public override ExpressionEmitter Prepare(
         }
     }
 
+    internal sealed class Bgt_UnConverter : ShortInlineBrTargetConverter
+    {
+        public override OpCode OpCode => OpCodes.Bgt_Un;
+
+        public override ExpressionEmitter Prepare(
+            ICodeInformation operand, DecodeContext decodeContext)
+        {
+            return BranchExpressionUtilities.ApplyBinary(operand, ">", decodeContext);
+        }
+    }
+
+    internal sealed class Bgt_Un_sConverter : ShortInlineBrTargetConverter
+    {
+        public override OpCode OpCode => OpCodes.Bgt_Un_S;
+
+        public override ExpressionEmitter Prepare(
+            ICodeInformation operand, DecodeContext decodeContext)
+        {
+            return BranchExpressionUtilities.ApplyBinary(operand, ">", decodeContext);
+        }
+    }
+
     internal sealed class BleConverter : ShortInlineBrTargetConverter
     {
         public override OpCode OpCode => OpCodes.Ble;

IL2C.Core/ILConveters/ConditionalConverters.cs

@@ -77,6 +77,18 @@ public static ExpressionEmitter Prepare(
                     extractContext.GetSymbolName(si1)) };
             }
 
+            if (si0.TargetType.IsFloatStackFriendlyType &&
+                si1.TargetType.IsFloatStackFriendlyType)
+            {
+                var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type);
+                return (extractContext, _) => new[] { string.Format(
+                    "{0} = (double){1} {2} (double){3}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0),
+                    oper,
+                    extractContext.GetSymbolName(si1)) };
+            }
+
             if ((si0.TargetType.IsIntPtrStackFriendlyType || !si0.TargetType.IsValueType || si0.TargetType.IsByReference || si0.TargetType.IsUntypedReferenceType) &&
                 (si1.TargetType.IsIntPtrStackFriendlyType || !si1.TargetType.IsValueType || si1.TargetType.IsByReference || si0.TargetType.IsUntypedReferenceType))
             {

IL2C.Core/ILConveters/LdindConverters.cs

@@ -31,8 +31,8 @@ public static ExpressionEmitter Prepare(DecodeContext decodeContext)
         {
             var siFrom = decodeContext.PopStack();
 
-            // Requre only managed refs
-            if (!siFrom.TargetType.IsByReference)
+            // Require only managed refs
+            if (!(siFrom.TargetType.IsByReference || siFrom.TargetType.IsArray))
             {
                 throw new InvalidProgramSequenceException(
                     "Invalid managed reference: Location={0}, StackType={1}",
@@ -43,10 +43,22 @@ public static ExpressionEmitter Prepare(DecodeContext decodeContext)
             var targetType = siFrom.TargetType.ElementType;
             var symbol = decodeContext.PushStack(targetType);
 
-            return (extractContext, _) => new[] { string.Format(
-                "{0} = *{1}",
-                extractContext.GetSymbolName(symbol),
-                extractContext.GetSymbolName(siFrom)) };
+            if (siFrom.TargetType.IsArray)
+            {
+                return (extractContext, _) => new[] { string.Format(
+                    "{0} = *(({2}*){1})",
+                    extractContext.GetSymbolName(symbol),
+                    extractContext.GetSymbolName(siFrom),
+                    targetType.CLanguageTypeName
+                    ) };
+            }
+            else
+            {
+                return (extractContext, _) => new[] { string.Format(
+                    "{0} = *{1}",
+                    extractContext.GetSymbolName(symbol),
+                    extractContext.GetSymbolName(siFrom)) };
+            }
         }
     }
 
@@ -159,4 +171,16 @@ public override ExpressionEmitter Prepare(DecodeContext decodeContext)
             return LdindConverterUtilities.Prepare(decodeContext);
         }
     }
+
+    // It is just a generalized Ldind. C compiler handles struct copy
+    internal sealed class LdobjConverter : InlineTypeConverter
+    {
+        public override OpCode OpCode => OpCodes.Ldobj;
+
+        public override ExpressionEmitter Prepare(Metadata.ITypeInformation operand, DecodeContext decodeContext)
+        {
+            // Note: note really need the operand in this case, since IL2C knows the type already
+            return LdindConverterUtilities.Prepare(decodeContext);
+        }
+    }
 }

IL2C.Core/ILConveters/LdtokenConverters.cs

@@ -33,7 +33,7 @@ internal sealed class LdtokenConverters : InlineMemberConverter
         public override ExpressionEmitter Prepare(
             IMemberInformation member, DecodeContext decodeContext)
         {
-            // ECMA-335 III.4.17 ldtoken - load the runt ime representat ion of a metadata
+            // ECMA-335 III.4.17 ldtoken - load the runtime representation of a metadata
 
             var field = member as IFieldInformation;
             if (field != null)

IL2C.Core/ILConveters/StargConverters .cs

@@ -0,0 +1,69 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// 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 si = decodeContext.PopStack();
+            var parameter = decodeContext.Method.Parameters[parameterIndex];
+            var targetType = isReference ? parameter.TargetType.MakeByReference() : parameter.TargetType;
+
+            // TODO: check target and source type
+
+            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(si)) };
+        }
+    }
+
+    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);
+        }
+    }
+}