Beispiel #1
0
        private static void EmitTerminals(ShortCircuitInfo info, FleeIlGenerator ilg, Label endLabel)
        {
            var flag = info.Branches.HasLabel(RuntimeHelpers.GetObjectValue(ourFalseTerminalKey));

            if (flag)
            {
                var falseLabel = info.Branches.FindLabel(RuntimeHelpers.GetObjectValue(ourFalseTerminalKey));
                ilg.MarkLabel(falseLabel);
                MarkBranchTarget(info, falseLabel, ilg);
                ilg.Emit(OpCodes.Ldc_I4_0);
                var flag2 = info.Branches.HasLabel(RuntimeHelpers.GetObjectValue(ourTrueTerminalKey));
                if (flag2)
                {
                    ilg.Emit(OpCodes.Br_S, endLabel);
                }
            }
            var flag3 = info.Branches.HasLabel(RuntimeHelpers.GetObjectValue(ourTrueTerminalKey));

            if (flag3)
            {
                var trueLabel = info.Branches.FindLabel(RuntimeHelpers.GetObjectValue(ourTrueTerminalKey));
                ilg.MarkLabel(trueLabel);
                MarkBranchTarget(info, trueLabel, ilg);
                ilg.Emit(OpCodes.Ldc_I4_1);
            }
        }
Beispiel #2
0
        private void EmitListIn(FleeIlGenerator ilg, IServiceProvider services, BranchManager bm)
        {
            var ce           = new CompareElement();
            var endLabel     = bm.FindLabel("endLabel");
            var trueTerminal = bm.FindLabel("trueTerminal");
            var lb           = ilg.DeclareLocal(this.myOperand.ResultType);
            var targetIndex  = lb.LocalIndex;

            this.myOperand.Emit(ilg, services);
            Utility.EmitStoreLocal(ilg, targetIndex);
            var targetShim = new LocalBasedElement(this.myOperand, targetIndex);

            this.myArguments.ForEach(argumentElement =>
            {
                ce.Initialize(targetShim, argumentElement, LogicalCompareOperation.Equal);
                ce.Emit(ilg, services);
                EmitBranchToTrueTerminal(ilg, trueTerminal, bm);
            });
            //try
            //{
            //    var enumerator = this.myArguments.GetEnumerator();
            //    while (enumerator.MoveNext())
            //    {
            //        var argumentElement = enumerator.Current;
            //        ce.Initialize(targetShim, argumentElement, LogicalCompareOperation.Equal);
            //        ce.Emit(ilg, services);
            //        EmitBranchToTrueTerminal(ilg, trueTerminal, bm);
            //    }
            //}
            //finally
            //{
            //    List<ExpressionElement>.Enumerator enumerator;
            //    ((IDisposable)enumerator).Dispose();
            //}

            ilg.Emit(OpCodes.Ldc_I4_0);
            ilg.Emit(OpCodes.Br_S, endLabel);
            bm.MarkLabel(ilg, trueTerminal);
            ilg.MarkLabel(trueTerminal);
            ilg.Emit(OpCodes.Ldc_I4_1);
            bm.MarkLabel(ilg, endLabel);
            ilg.MarkLabel(endLabel);
        }
Beispiel #3
0
        private static void EmitOperand(ExpressionElement operand, ShortCircuitInfo info, FleeIlGenerator ilg,
                                        IServiceProvider services)
        {
            var flag = info.Branches.HasLabel(operand);

            if (flag)
            {
                var leftLabel = info.Branches.FindLabel(operand);
                ilg.MarkLabel(leftLabel);
                MarkBranchTarget(info, leftLabel, ilg);
            }
            operand.Emit(ilg, services);
        }
Beispiel #4
0
        private void EmitConditional(FleeIlGenerator ilg, IServiceProvider services, BranchManager bm)
        {
            var falseLabel = bm.FindLabel("falseLabel");
            var endLabel   = bm.FindLabel("endLabel");

            this.myCondition.Emit(ilg, services);
            var isTemp = ilg.IsTemp;

            if (isTemp)
            {
                bm.AddBranch(ilg, falseLabel);
                ilg.Emit(OpCodes.Brfalse_S, falseLabel);
            }
            else
            {
                var flag = !bm.IsLongBranch(ilg, falseLabel);
                ilg.Emit(flag ? OpCodes.Brfalse_S : OpCodes.Brfalse, falseLabel);
            }
            this.myWhenTrue.Emit(ilg, services);
            ImplicitConverter.EmitImplicitConvert(this.myWhenTrue.ResultType, this.myResultType, ilg);
            var isTemp2 = ilg.IsTemp;

            if (isTemp2)
            {
                bm.AddBranch(ilg, endLabel);
                ilg.Emit(OpCodes.Br_S, endLabel);
            }
            else
            {
                var flag2 = !bm.IsLongBranch(ilg, endLabel);
                ilg.Emit(flag2 ? OpCodes.Br_S : OpCodes.Br, endLabel);
            }
            bm.MarkLabel(ilg, falseLabel);
            ilg.MarkLabel(falseLabel);
            this.myWhenFalse.Emit(ilg, services);
            ImplicitConverter.EmitImplicitConvert(this.myWhenFalse.ResultType, this.myResultType, ilg);
            bm.MarkLabel(ilg, endLabel);
            ilg.MarkLabel(endLabel);
        }
Beispiel #5
0
        private void EmitLogical(FleeIlGenerator ilg, ShortCircuitInfo info, IServiceProvider services)
        {
            info.Branches.GetLabel(RuntimeHelpers.GetObjectValue(ourEndLabelKey), ilg);
            this.PopulateData(info);
            EmitLogicalShortCircuit(ilg, info, services);
            var terminalOperand = (ExpressionElement)info.Operands.Pop();

            EmitOperand(terminalOperand, info, ilg, services);
            var endLabel = info.Branches.FindLabel(RuntimeHelpers.GetObjectValue(ourEndLabelKey));

            ilg.Emit(OpCodes.Br_S, endLabel);
            EmitTerminals(info, ilg, endLabel);
            ilg.MarkLabel(endLabel);
        }