Flee

2025-10-08 09:49:37 +08:00
commit 284e764345
99 changed files with 21742 additions and 0 deletions
--- a/ExpressionElements/Shift.cs
+++ b/ExpressionElements/Shift.cs
@@ -0,0 +1,136 @@
+using System.Diagnostics;
+using System.Reflection.Emit;
+using Flee.ExpressionElements.Base;
+using Flee.InternalTypes;
+
+
+namespace Flee.ExpressionElements
+{
+    internal class ShiftElement : BinaryExpressionElement
+    {
+        private ShiftOperation _myOperation;
+
+        public ShiftElement()
+        {
+        }
+
+        protected override System.Type GetResultType(System.Type leftType, System.Type rightType)
+        {
+            // Right argument (shift count) must be convertible to int32
+            if (ImplicitConverter.EmitImplicitNumericConvert(rightType, typeof(Int32), null) == false)
+            {
+                return null;
+            }
+
+            // Left argument must be an integer type
+            if (Utility.IsIntegralType(leftType) == false)
+            {
+                return null;
+            }
+
+            TypeCode tc = Type.GetTypeCode(leftType);
+
+            switch (tc)
+            {
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.Int16:
+                case TypeCode.UInt16:
+                case TypeCode.Int32:
+                    return typeof(Int32);
+                case TypeCode.UInt32:
+                    return typeof(UInt32);
+                case TypeCode.Int64:
+                    return typeof(Int64);
+                case TypeCode.UInt64:
+                    return typeof(UInt64);
+                default:
+                    Debug.Assert(false, "unknown left shift operand");
+                    return null;
+            }
+        }
+
+        protected override void GetOperation(object operation)
+        {
+            _myOperation = (ShiftOperation)operation;
+        }
+
+        public override void Emit(FleeILGenerator ilg, IServiceProvider services)
+        {
+            MyLeftChild.Emit(ilg, services);
+            this.EmitShiftCount(ilg, services);
+            this.EmitShift(ilg);
+        }
+
+        // If the shift count is greater than the number of bits in the number, the result is undefined.
+        // So we play it safe and force the shift count to 32/64 bits by ANDing it with the appropriate mask.
+        private void EmitShiftCount(FleeILGenerator ilg, IServiceProvider services)
+        {
+            MyRightChild.Emit(ilg, services);
+            TypeCode tc = Type.GetTypeCode(MyLeftChild.ResultType);
+            switch (tc)
+            {
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.Int16:
+                case TypeCode.UInt16:
+                case TypeCode.Int32:
+                case TypeCode.UInt32:
+                    ilg.Emit(OpCodes.Ldc_I4_S, Convert.ToSByte(0x1f));
+                    break;
+                case TypeCode.Int64:
+                case TypeCode.UInt64:
+                    ilg.Emit(OpCodes.Ldc_I4_S, Convert.ToSByte(0x3f));
+                    break;
+                default:
+                    Debug.Assert(false, "unknown left shift operand");
+                    break;
+            }
+
+            ilg.Emit(OpCodes.And);
+        }
+
+        private void EmitShift(FleeILGenerator ilg)
+        {
+            TypeCode tc = Type.GetTypeCode(MyLeftChild.ResultType);
+            OpCode op = default(OpCode);
+
+            switch (tc)
+            {
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.Int16:
+                case TypeCode.UInt16:
+                case TypeCode.Int32:
+                case TypeCode.Int64:
+                    // Signed operand, emit a left shift or arithmetic right shift
+                    if (_myOperation == ShiftOperation.LeftShift)
+                    {
+                        op = OpCodes.Shl;
+                    }
+                    else
+                    {
+                        op = OpCodes.Shr;
+                    }
+                    break;
+                case TypeCode.UInt32:
+                case TypeCode.UInt64:
+                    // Unsigned operand, emit left shift or logical right shift
+                    if (_myOperation == ShiftOperation.LeftShift)
+                    {
+                        op = OpCodes.Shl;
+                    }
+                    else
+                    {
+                        op = OpCodes.Shr_Un;
+                    }
+                    break;
+                default:
+                    Debug.Assert(false, "unknown left shift operand");
+                    break;
+            }
+
+            ilg.Emit(op);
+        }
+    }
+}