public override MSAst.Expression Reduce()
        {
            if (_statements.Length == 0)
            {
                return(GlobalParent.AddDebugInfoAndVoid(AstUtils.Empty(), Span));
            }

            ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>();

            int curStart = -1;

            foreach (var statement in _statements)
            {
                // CPython debugging treats multiple statements on the same line as a single step, we
                // match that behavior here.
                int newline = GlobalParent.IndexToLocation(statement.StartIndex).Line;
                if (newline == curStart)
                {
                    statements.Add(new DebugInfoRemovalExpression(statement, curStart));
                }
                else
                {
                    if (statement.CanThrow && newline != -1)
                    {
                        statements.Add(UpdateLineNumber(newline));
                    }

                    statements.Add(statement);
                }
                curStart = newline;
            }

            return(Ast.Block(statements.ToReadOnlyCollection()));
        }
Beispiel #2
0
        private MSAst.Expression ReduceWorker(bool optimizeDynamicConvert)
        {
            MSAst.Expression result;

            if (_else != null)
            {
                result = _else;
            }
            else
            {
                result = AstUtils.Empty();
            }

            // Now build from the inside out
            int i = _tests.Length;

            while (i-- > 0)
            {
                IfStatementTest ist = _tests[i];

                result = GlobalParent.AddDebugInfoAndVoid(
                    Ast.Condition(
                        optimizeDynamicConvert ?
                        TransformAndDynamicConvert(ist.Test, typeof(bool)) :
                        GlobalParent.Convert(typeof(bool), Microsoft.Scripting.Actions.ConversionResultKind.ExplicitCast, ist.Test),
                        TransformMaybeSingleLineSuite(ist.Body, ist.Test.Start),
                        result
                        ),
                    new SourceSpan(ist.Start, ist.Header)
                    );
            }

            return(result);
        }
Beispiel #3
0
        public override Ast Reduce()
        {
            var left  = Left;
            var right = Right;

            Type t   = Type;
            var  tmp = Variable(t, "__all__");

            return(Block(
                       new[] { tmp },
                       Condition(
                           GlobalParent.Convert(
                               typeof(bool),
                               ConversionResultKind.ExplicitCast,
                               Assign(
                                   tmp,
                                   AstUtils.Convert(
                                       left,
                                       t
                                       )
                                   )
                               ),
                           AstUtils.Convert(
                               right,
                               t
                               ),
                           tmp
                           )
                       ));
        }
Beispiel #4
0
        public override MSAst.Expression Reduce()
        {
            Debug.Assert(_variable != null, "Shouldn't be called by lambda expression");

            MSAst.Expression function = MakeFunctionExpression();
            return(GlobalParent.AddDebugInfoAndVoid(AssignValue(Parent.GetVariableExpression(_variable), function), new SourceSpan(Start, Header)));
        }
        public override MSAst.Expression Reduce()
        {
            UnicodeWrapper wrapper;

            if (_value == Ellipsis.Value)
            {
                return(Ast.Property(
                           null,
                           typeof(PythonOps).GetProperty("Ellipsis")
                           ));
            }
            else if (_value is bool)
            {
                if ((bool)_value)
                {
                    return(Ast.Field(null, typeof(ScriptingRuntimeHelpers).GetField("True")));
                }
                else
                {
                    return(Ast.Field(null, typeof(ScriptingRuntimeHelpers).GetField("False")));
                }
            }
            else if ((wrapper = _value as UnicodeWrapper) != null)
            {
                return(GlobalParent.Constant(wrapper.Value));
            }

            return(GlobalParent.Constant(_value));
        }
        public override MSAst.Expression Reduce()
        {
            MSAst.MethodCallExpression call;

            if (_locals == null && _globals == null)
            {
                // exec code
                call = Ast.Call(
                    AstMethods.UnqualifiedExec,
                    Parent.LocalContext,
                    AstUtils.Convert(_code, typeof(object))
                    );
            }
            else
            {
                // exec code in globals [ , locals ]
                // We must have globals now (locals is last and may be absent)
                Debug.Assert(_globals != null);
                call = Ast.Call(
                    AstMethods.QualifiedExec,
                    Parent.LocalContext,
                    AstUtils.Convert(_code, typeof(object)),
                    TransformAndDynamicConvert(_globals, typeof(PythonDictionary)),
                    TransformOrConstantNull(_locals, typeof(object))
                    );
            }

            return(GlobalParent.AddDebugInfo(call, Span));
        }
Beispiel #7
0
        public override MSAst.Expression Reduce()
        {
            UnicodeWrapper wrapper;

            if (_value == Ellipsis.Value)
            {
                return(EllipsisExpr);
            }
            else if (_value is bool)
            {
                if ((bool)_value)
                {
                    return(TrueExpr);
                }
                else
                {
                    return(FalseExpr);
                }
            }
            else if ((wrapper = _value as UnicodeWrapper) != null)
            {
                return(GlobalParent.Constant(wrapper.Value));
            }

            return(GlobalParent.Constant(_value));
        }
 public override MSAst.Expression Reduce()
 {
     return(GlobalParent.Get(
                _name,
                _target
                ));
 }
Beispiel #9
0
        public override MSAst.Expression Reduce()
        {
            ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>();

            for (int i = 0; i < _names.Length; i++)
            {
                statements.Add(
                    // _references[i] = PythonOps.Import(<code context>, _names[i])
                    GlobalParent.AddDebugInfoAndVoid(
                        AssignValue(
                            Parent.GetVariableExpression(_variables[i]),
                            LightExceptions.CheckAndThrow(
                                Expression.Call(
                                    _asNames[i] == null ? AstMethods.ImportTop : AstMethods.ImportBottom,
                                    Parent.LocalContext,                                     // 1st arg - code context
                                    AstUtils.Constant(_names[i].MakeString()),               // 2nd arg - module name
                                    AstUtils.Constant(_forceAbsolute ? 0 : -1)               // 3rd arg - absolute or relative imports
                                    )
                                )
                            ),
                        _names[i].Span
                        )
                    );
            }

            statements.Add(AstUtils.Empty());
            return(GlobalParent.AddDebugInfo(Ast.Block(statements.ToReadOnlyCollection()), Span));
        }
Beispiel #10
0
        public override MSAst.Expression Reduce()
        {
            // If debugging is off, return empty statement
            if (Optimize)
            {
                return(AstUtils.Empty());
            }

            // Transform into:
            // if (_test) {
            // } else {
            //     RaiseAssertionError(_message);
            // }
            return(GlobalParent.AddDebugInfoAndVoid(
                       AstUtils.Unless(                                     // if
                           TransformAndDynamicConvert(_test, typeof(bool)), // _test
                           Ast.Call(                                        // else branch
                               AstMethods.RaiseAssertionError,
                               Parent.LocalContext,
                               TransformOrConstantNull(_message, typeof(object))
                               )
                           ),
                       Span
                       ));
        }
 internal override MSAst.Expression TransformSet(SourceSpan span, MSAst.Expression right, PythonOperationKind op)
 {
     if (op == PythonOperationKind.None)
     {
         return(GlobalParent.AddDebugInfoAndVoid(
                    GlobalParent.Set(
                        _name,
                        _target,
                        right
                        ),
                    span
                    ));
     }
     else
     {
         MSAst.ParameterExpression temp = Ast.Variable(typeof(object), "inplace");
         return(GlobalParent.AddDebugInfo(
                    Ast.Block(
                        new[] { temp },
                        Ast.Assign(temp, _target),
                        SetMemberOperator(right, op, temp),
                        AstUtils.Empty()
                        ),
                    Span.Start,
                    span.End
                    ));
     }
 }
Beispiel #12
0
        public override MSAst.Expression Reduce()
        {
            if (Parent.IsGeneratorMethod)
            {
                if (_expression != null)
                {
                    // Statements can't return null, so return a rethrow.
                    // Callers should detecet the ag.AddError and avoid trying to execute the tree,
                    // but if they accidentally do, use Throw instead of empty so that
                    // we'll get an exception.
                    return(Ast.Throw(
                               Ast.New(
                                   typeof(InvalidOperationException).GetConstructor(Type.EmptyTypes)
                                   )
                               ));
                }

                return(GlobalParent.AddDebugInfo(AstUtils.YieldBreak(GeneratorLabel), Span));
            }

            return(GlobalParent.AddDebugInfo(
                       Ast.Return(
                           FunctionDefinition._returnLabel,
                           TransformOrConstantNull(_expression, typeof(object))
                           ),
                       Span
                       ));
        }
        public override MSAst.Expression Reduce()
        {
            MSAst.Expression raiseExpression;
            if (_type == null && _value == null && _traceback == null)
            {
                raiseExpression = Ast.Call(
                    AstMethods.MakeRethrownException,
                    Parent.LocalContext
                    );

                if (!InFinally)
                {
                    raiseExpression = Ast.Block(
                        UpdateLineUpdated(true),
                        raiseExpression
                        );
                }
            }
            else
            {
                raiseExpression = Ast.Call(
                    AstMethods.MakeException,
                    Parent.LocalContext,
                    TransformOrConstantNull(_type, typeof(object)),
                    TransformOrConstantNull(_value, typeof(object)),
                    TransformOrConstantNull(_traceback, typeof(object))
                    );
            }

            return(GlobalParent.AddDebugInfo(
                       Ast.Throw(raiseExpression),
                       Span
                       ));
        }
Beispiel #14
0
        public override MSAst.Expression Reduce()
        {
            MSAst.Expression left  = _left;
            MSAst.Expression right = _right;

            Type t = Type;

            MSAst.ParameterExpression tmp = Ast.Variable(t, "__all__");

            return(Ast.Block(
                       new[] { tmp },
                       Ast.Condition(
                           GlobalParent.Convert(
                               typeof(bool),
                               ConversionResultKind.ExplicitCast,
                               Ast.Assign(
                                   tmp,
                                   AstUtils.Convert(
                                       left,
                                       t
                                       )
                                   )
                               ),
                           tmp,
                           AstUtils.Convert(
                               right,
                               t
                               )
                           )
                       ));
        }
 public override MSAst.Expression Reduce()
 {
     return(GlobalParent.Operation(
                typeof(object),
                PythonOperatorToOperatorString(_op),
                _expression
                ));
 }
 internal override MSAst.Expression TransformDelete()
 {
     return(GlobalParent.Delete(
                typeof(void),
                _name,
                _target
                ));
 }
Beispiel #17
0
 public override MSAst.Expression Reduce()
 {
     if (IsSlice)
     {
         return(GlobalParent.GetSlice(GetActionArgumentsForGetOrDelete()));
     }
     return(GlobalParent.GetIndex(GetActionArgumentsForGetOrDelete()));
 }
        internal override void RewriteBody(MSAst.ExpressionVisitor visitor)
        {
            _dlrBody = null;    // clear the cached body if we've been reduced

            MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode());
            FuncCodeExpr = funcCode;

            Body = new RewrittenBodyStatement(Body, visitor.Visit(Body));
        }
Beispiel #19
0
 internal override MSAst.Expression Transform(MSAst.Expression body)
 {
     return(GlobalParent.AddDebugInfoAndVoid(
                AstUtils.If(
                    GlobalParent.Convert(typeof(bool), ConversionResultKind.ExplicitCast, _test),
                    body
                    ),
                Span
                ));
 }
 internal override MSAst.Expression TransformDelete()
 {
     MSAst.Expression[] statements = new MSAst.Expression[_items.Length + 1];
     for (int i = 0; i < _items.Length; i++)
     {
         statements[i] = _items[i].TransformDelete();
     }
     statements[_items.Length] = AstUtils.Empty();
     return(GlobalParent.AddDebugInfo(Ast.Block(statements), Span));
 }
Beispiel #21
0
        private MSAst.Expression ReduceWorker(bool optimizeDynamicConvert)
        {
            // Only the body is "in the loop" for the purposes of break/continue
            // The "else" clause is outside

            ConstantExpression constTest = _test as ConstantExpression;

            if (constTest != null && constTest.Value is int)
            {
                // while 0: / while 1:
                int val = (int)constTest.Value;
                if (val == 0)
                {
                    // completely optimize the loop away
                    if (_else == null)
                    {
                        return(MSAst.Expression.Empty());
                    }
                    else
                    {
                        return(_else);
                    }
                }

                MSAst.Expression test = MSAst.Expression.Constant(true);
                MSAst.Expression res  = AstUtils.While(
                    test,
                    _body,
                    _else,
                    _break,
                    _continue
                    );

                if (GlobalParent.IndexToLocation(_test.StartIndex).Line != GlobalParent.IndexToLocation(_body.StartIndex).Line)
                {
                    res = GlobalParent.AddDebugInfoAndVoid(res, _test.Span);
                }

                return(res);
            }

            return(AstUtils.While(
                       GlobalParent.AddDebugInfo(
                           optimizeDynamicConvert ?
                           TransformAndDynamicConvert(_test, typeof(bool)) :
                           GlobalParent.Convert(typeof(bool), Microsoft.Scripting.Actions.ConversionResultKind.ExplicitCast, _test),
                           Header
                           ),
                       _body,
                       _else,
                       _break,
                       _continue
                       ));
        }
        public override MSAst.Expression Reduce()
        {
            MSAst.Expression ifTrue  = AstUtils.Convert(_trueExpr, typeof(object));
            MSAst.Expression ifFalse = AstUtils.Convert(_falseExpr, typeof(object));

            return(Ast.Condition(
                       GlobalParent.Convert(typeof(bool), ConversionResultKind.ExplicitCast, _testExpr),
                       ifTrue,
                       ifFalse
                       ));
        }
Beispiel #23
0
 protected override Ast Body(MSAst.ParameterExpression res)
 {
     return(GlobalParent.AddDebugInfo(
                Ast.Call(
                    AstMethods.SetAddForComprehension,
                    res,
                    AstUtils.Convert(_item, typeof(object))
                    ),
                _item.Span
                ));
 }
Beispiel #24
0
        public override MSAst.Expression Reduce()
        {
            // Transform to series of individual del statements.
            ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>(_expressions.Length + 1);

            for (int i = 0; i < _expressions.Length; i++)
            {
                statements.Add(_expressions[i].TransformDelete());
            }
            statements.Add(AstUtils.Empty());
            return(GlobalParent.AddDebugInfo(MSAst.Expression.Block(statements), Span));
        }
Beispiel #25
0
 protected override Ast Body(MSAst.ParameterExpression res)
 {
     return(GlobalParent.AddDebugInfo(
                Ast.Call(
                    AstMethods.DictAddForComprehension,
                    res,
                    AstUtils.Convert(_key, typeof(object)),
                    AstUtils.Convert(_value, typeof(object))
                    ),
                new SourceSpan(_key.Span.Start, _value.Span.End)
                ));
 }
        public override MSAst.Expression Reduce()
        {
            if (_value == Ellipsis.Value)
            {
                return(EllipsisExpr);
            }
            else if (_value is bool)
            {
                return((bool)_value ? TrueExpr : FalseExpr);
            }

            return(GlobalParent.Constant(_value));
        }
        private MSAst.Expression ReduceWorker(MSAst.Expression expression)
        {
            if (Parent.PrintExpressions)
            {
                expression = Ast.Call(
                    AstMethods.PrintExpressionValue,
                    Parent.LocalContext,
                    ConvertIfNeeded(expression, typeof(object))
                    );
            }

            return(GlobalParent.AddDebugInfoAndVoid(expression, _expression.Span));
        }
Beispiel #28
0
        /// <summary>
        /// Returns an expression which creates the function object.
        /// </summary>
        internal MSAst.Expression MakeFunctionExpression()
        {
            List <MSAst.Expression> defaults = new List <MSAst.Expression>(0);

            foreach (var param in _parameters)
            {
                if (param.DefaultValue != null)
                {
                    defaults.Add(AstUtils.Convert(param.DefaultValue, typeof(object)));
                }
            }

            MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode());
            FuncCodeExpr = funcCode;

            MSAst.Expression ret;
            if (EmitDebugFunction())
            {
                LightLambdaExpression code = CreateFunctionLambda();

                // we need to compile all of the debuggable code together at once otherwise mdbg gets confused.  If we're
                // in tracing mode we'll still compile things one off though just to keep things simple.  The code will still
                // be debuggable but naive debuggers like mdbg will have more issues.
                ret = Ast.Call(
                    AstMethods.MakeFunctionDebug,                                                   // method
                    Parent.LocalContext,                                                            // 1. Emit CodeContext
                    FuncCodeExpr,                                                                   // 2. FunctionCode
                    ((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(),     // 3. module name
                    defaults.Count == 0 ?                                                           // 4. default values
                    AstUtils.Constant(null, typeof(object[])) :
                    (MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults),
                    IsGenerator ?
                    (MSAst.Expression) new PythonGeneratorExpression(code, GlobalParent.PyContext.Options.CompilationThreshold) :
                    (MSAst.Expression)code
                    );
            }
            else
            {
                ret = Ast.Call(
                    AstMethods.MakeFunction,                                                        // method
                    Parent.LocalContext,                                                            // 1. Emit CodeContext
                    FuncCodeExpr,                                                                   // 2. FunctionCode
                    ((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(),     // 3. module name
                    defaults.Count == 0 ?                                                           // 4. default values
                    AstUtils.Constant(null, typeof(object[])) :
                    (MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults)
                    );
            }

            return(AddDecorators(ret, _decorators));
        }
Beispiel #29
0
        internal override MSAst.Expression TransformDelete()
        {
            MSAst.Expression index;
            if (IsSlice)
            {
                index = GlobalParent.DeleteSlice(GetActionArgumentsForGetOrDelete());
            }
            else
            {
                index = GlobalParent.DeleteIndex(GetActionArgumentsForGetOrDelete());
            }

            return(GlobalParent.AddDebugInfoAndVoid(index, Span));
        }
Beispiel #30
0
        private MSAst.Expression MakeBinaryOperation(PythonOperator op, MSAst.Expression left, MSAst.Expression right, SourceSpan span)
        {
            if (op == PythonOperator.NotIn)
            {
                return(AstUtils.Convert(
                           Ast.Not(
                               GlobalParent.Operation(
                                   typeof(bool),
                                   PythonOperationKind.Contains,
                                   left,
                                   right
                                   )
                               ),
                           typeof(object)
                           ));
            }
            else if (op == PythonOperator.In)
            {
                return(AstUtils.Convert(
                           GlobalParent.Operation(
                               typeof(bool),
                               PythonOperationKind.Contains,
                               left,
                               right
                               ),
                           typeof(object)
                           ));
            }

            PythonOperationKind action = PythonOperatorToAction(op);

            if (action != PythonOperationKind.None)
            {
                return(GlobalParent.Operation(
                           typeof(object),
                           action,
                           left,
                           right
                           ));
            }
            else
            {
                // Call helper method
                return(Ast.Call(
                           GetHelperMethod(op),
                           ConvertIfNeeded(left, typeof(object)),
                           ConvertIfNeeded(right, typeof(object))
                           ));
            }
        }