internal override Node Bind(Binder b)
        {
            b.OpenScope();
            if (Expr != null)
            {
                b.Bind(ref Expr);
                Expr.RequireGetAccess();
            }
            else
            {
                b.Bind(ref Decl);
            }
            b.Bind(ref Stmt);
            b.CloseScope();

            var u     = Decl != null ? Decl.VarDecls[0].Var : b.AddLocal(Expr.Datatype);
            var udecl = Decl ?? DeclStmt.Bound(VarDecl.Bound(u, Expr, b.Options.Binding));

            Expr du = AsTypeExpr.Bound(IdExpr.Bound(u), IdExpr.Bound(Compilation.Get(WellKnownTypes.System_IDisposable)));

            b.Cache(ref du);
            var cond = BinaryExpr.Bound(du, Expr.Token, LiteralExpr.Bound(Constant.Null), BinaryOperatorKind.NotEqual, b.Options.Binding);
            var exit = IfStmt.Bound(cond,
                                    ExprStmt.Bound(MethodCallExpr.Bound(b, null, Compilation.Get(WellKnownMembers.System_IDisposable_Dispose), du, ArgList.Empty)),
                                    null);

            return(StmtBlock.Bound(udecl,
                                   TryStmt.Bound(b,
                                                 Stmt,
                                                 exit)));
        }
        internal override Node Bind(Binder b)
        {
            b.OpenScope();
            b.Bind(ref Key);
            Key.RequireGetAccess();
            if (Key.Datatype.IsValueType)
            {
                throw Error(ErrorCode.RequireReferenceType);
            }
            b.Bind(ref Stmt);
            b.CloseScope();

            var k = b.AddLocal(Compilation.Get(NativeType.Object));

            b.Convert(ref Key, Compilation.Get(NativeType.Object));
            var kdecl = DeclStmt.Bound(VarDecl.Bound(k, Key, b.Options.Binding));

            var l     = b.AddLocal(Compilation.Get(NativeType.Boolean));
            var ldecl = DeclStmt.Bound(VarDecl.Bound(l, LiteralExpr.Bound(Constant.Create(false)), b.Options.Binding));

            var enter = ExprStmt.Bound(MethodCallExpr.Bound(b, null, Compilation.Get(WellKnownMembers.System_Threading_Monitor_Enter), null, ArgList.Bound(IdExpr.Bound(k), IdExpr.Bound(l))));
            var exit  = IfStmt.Bound(IdExpr.Bound(l),
                                     ExprStmt.Bound(MethodCallExpr.Bound(b, null, Compilation.Get(WellKnownMembers.System_Threading_Monitor_Exit), null, ArgList.Bound(IdExpr.Bound(k)))),
                                     null);

            return(StmtBlock.Bound(kdecl, ldecl,
                                   TryStmt.Bound(b,
                                                 StmtBlock.Bound(enter, Stmt),
                                                 exit)));
        }
        internal override Node Bind(Binder b)
        {
            b.OpenScope();

            b.Bind(ref Expr);
            Expr.RequireGetAccess();

            if (Expr.Datatype.IsArray && Expr.Datatype.ArrayRank == 1)
            {
                var array = b.Cache(ref Expr);
                var iter  = b.AddLocal(Compilation.Get(NativeType.Int32));
                IterDecl  = VarDecl.Bound(iter, LiteralExpr.Bound(Constant.Create(b.Options.ArrayBase)), b.Options.Binding);
                WhileExpr = BinaryExpr.Bound(IdExpr.Bound(iter), Token,
                                             MethodCallExpr.Bound(array, Compilation.Get(WellKnownMembers.System_Array_get_Length), array, ArgList.Empty),
                                             b.Options.ArrayZero ? BinaryOperatorKind.LessThan : BinaryOperatorKind.LessThanOrEqual, b.Options.Binding);
                IncrExpr            = AssignOpExpr.Bound(IdExpr.Bound(iter), LiteralExpr.Bound(Constant.Create(1)), BinaryOperatorKind.Addition, b);
                ForDecl.Initializer = ArrayAccessExpr.Bound(array, new ArgList(new List <Arg>(1)
                {
                    new Arg(IdExpr.Bound(iter))
                }), b);
            }
            else
            {
                if (Expr.Datatype.IsUsualOrObject() && b.Options.Binding.HasFlag(BindOptions.AllowDynamic))
                {
                    b.Convert(ref Expr, Compilation.Get(NativeType.Array));
                }
                Expr e          = b.Cache(ref Expr);
                var  getIterSym = e.Datatype.GetEnumeratorGetter() ?? throw Error(ErrorCode.NoSuitableEnumerator);
                var  getIter    = MethodCallExpr.Bound(e, getIterSym, e, ArgList.Empty);
                var  iter       = b.AddLocal(getIter.Datatype);
                IterDecl  = VarDecl.Bound(iter, getIter, b.Options.Binding);
                WhileExpr = MethodCallExpr.Bound(b, IdExpr.Bound(iter), SystemNames.MoveNext, ArgList.Empty);
                b.Convert(ref WhileExpr, Compilation.Get(NativeType.Boolean));
                ForDecl.Initializer = MethodCallExpr.Bound(b, IdExpr.Bound(iter), SystemNames.CurrentGetter, ArgList.Empty);
                Dispose             = Compilation.Get(WellKnownTypes.System_IDisposable).IsAssignableFrom(getIter.Datatype);
                if (Dispose)
                {
                    RequireExceptionHandling = true;
                }
            }

            b.Bind(ref ForDecl);
            InnerDecl = ForDecl;

            Expr Iter;

            Iter = (ForDecl.Initializer as AssignExpr).Left;
            Iter.RequireGetAccess();

            b.Bind(ref Stmt);

            b.CloseScope();
            return(null);
        }
        internal override Node Bind(Binder b)
        {
            var funcs = Compilation.Get(WellKnownTypes.XSharp_RT_Functions);
            var expr  = IdExpr.Bound(b.Lookup(funcs, QOutName));
            var args  = new ArgList(new List <Arg>(Exprs.Select(x => new Arg(x))));

            b.Bind(ref args);
            Expr self, writeBack;
            var  sym = b.BindMethodCall(expr, expr.Symbol, args, out self, out writeBack);

            if (self != null || writeBack != null)
            {
                throw Error(ErrorCode.Internal);
            }
            QOutCall = MethodCallExpr.Bound(expr, sym, null, args);
            return(null);
        }
 internal override Node Bind(Binder b)
 {
     b.OpenScope();
     b.Bind(ref Stmt);
     Stmt = TryStmt.Bound(b,
                          StmtBlock.Bound(
                              ExprStmt.Bound(MethodCallExpr.Bound(null, Compilation.Get(WellKnownMembers.XSharp_Internal_CompilerServices_EnterBeginSequence), null, ArgList.Empty)),
                              Stmt),
                          ExprStmt.Bound(MethodCallExpr.Bound(null, Compilation.Get(WellKnownMembers.XSharp_Internal_CompilerServices_ExitBeginSequence), null, ArgList.Empty))
                          );
     b.CloseScope();
     if (Recover != null)
     {
         b.OpenScope();
         var rv = b.AddLocal(Name.Value, b.ObjectType);
         b.Bind(ref Recover);
         ExVar = b.AddLocal(Compilation.Get(WellKnownTypes.System_Exception));
         Expr rvxw   = MethodCallExpr.Bound(b, TypeCast.Bound(b, IdExpr.Bound(ExVar), Compilation.Get(WellKnownTypes.XSharp_Internal_WrappedException)), "get_Value", ArgList.Empty);
         Expr rvxe   = TypeCast.Bound(b, IdExpr.Bound(ExVar), Compilation.Get(WellKnownTypes.XSharp_Error));
         Expr rvx    = MethodCallExpr.Bound(null, Compilation.Get(WellKnownMembers.XSharp_Error_WrapRawException), null, ArgList.Bound(TypeCast.Bound(b, IdExpr.Bound(ExVar), Compilation.Get(WellKnownTypes.System_Exception))));
         var  rvInit =
             IifExpr.Bound(IsExpr.Bound(IdExpr.Bound(ExVar), IdExpr.Bound(Compilation.Get(WellKnownTypes.XSharp_Internal_WrappedException))), TypeConversion.Bound(b, rvxw, Compilation.Get(NativeType.Usual)),
                           IifExpr.Bound(IsExpr.Bound(IdExpr.Bound(ExVar), IdExpr.Bound(Compilation.Get(WellKnownTypes.XSharp_Error))), TypeConversion.Bound(b, rvxe, Compilation.Get(NativeType.Usual)),
                                         rvx,
                                         b.Options.Binding),
                           b.Options.Binding);
         var rvdecl = DeclStmt.Bound(VarDecl.Bound(rv, rvInit, b.Options.Binding));
         Recover = StmtBlock.Bound(rvdecl, Recover);
         b.CloseScope();
     }
     if (Finally != null)
     {
         bool ar = SaveAllowReturn(b);
         b.OpenScope();
         b.Bind(ref Finally);
         b.CloseScope();
         RestoreAllowReturn(b, ar);
     }
     return(TryStmt.Bound(b, Stmt, CatchBlock.Bound(ExVar, Recover), Finally));
 }
示例#6
0
 internal override Node Bind(Binder b)
 {
     if (b.Options.FoxParenArrayAccess && Expr is IdExpr id && (Args.Args.Count == 1 || Args.Args.Count == 2))
     {
         // Todo:
         // Validate also if the array indexes are or could be numeric
         // So valid are:
         // LONG, USUAL, OBJECT
         // When not, then we call the function always
         if (Affinity == BindAffinity.Assign)
         {
             // transform to array access
             var a = new ArrayAccessExpr(Expr, Args);
             b.Bind(ref a, Affinity);
             return(a);
         }
         else
         {
             Expr e = new IdExpr(id.Name);
             b.Bind(ref e, BindAffinity.Invoke);
             if (e.Symbol?.IsMethodOrMethodGroup() == true)
             {
                 if (b.Options.UndeclaredVariableResolution == VariableResolution.TreatAsFieldOrMemvar)
                 {
                     // transform to call to __FoxArrayAccess()
                     var m = (Args.Args.Count == 1) ? WellKnownMembers.XSharp_VFP_Functions___FoxArrayAccess_1 : WellKnownMembers.XSharp_VFP_Functions___FoxArrayAccess_2;
                     Args.Args.Insert(0, new Arg(LiteralExpr.Bound(Constant.Create(id.Name))));
                     Args.Args.Insert(1, new Arg(new IdExpr(id.Name)));
                     b.Bind(ref Args);
                     if (Args.Args[1].Expr is AutoVarExpr av)
                     {
                         av.Safe = true;
                     }
                     return(MethodCallExpr.Bound(b, null, Compilation.Get(m), null, Args));
                 }
             }
             else
             {
                 // transform to array access
                 var a = new ArrayAccessExpr(Expr, Args);
                 b.Bind(ref a, Affinity);
                 return(a);
             }
         }
     }
     b.Bind(ref Expr, BindAffinity.Invoke);
     b.Bind(ref Args);
     Symbol   = b.BindMethodCall(Expr, Expr.Symbol, Args, out Self, out WriteBack);
     Datatype = Symbol.Type();
     if (Self?.Datatype.IsValueType == true)
     {
         if ((Symbol as MethodSymbol).DeclaringType.IsValueType)
         {
             if (!Symbol.HasRefAccess)
             {
                 b.Cache(ref Self);
             }
             b.Convert(ref Self, Binder.ByRefOf(Self.Datatype));
         }
         else
         {
             b.Convert(ref Self, Compilation.Get(NativeType.Object));
         }
     }
     return(null);
 }
        internal override Node Bind(Binder b)
        {
            // TODO: Handle IS
            if (IsIsType)
            {
                throw Type.Error(ErrorCode.NotSupported, "IS");
            }

            // TODO: Handle DIM, array sub peroperly (according to full compiler)
            if (IsDim && ArraySub == null)
            {
                throw Error(ErrorCode.Expected, "array specifier");
            }
            bool isDim   = IsDim && ArraySub != null;
            bool isArray = !IsDim && ArraySub != null;

            if (ArraySub != null)
            {
                for (int i = 0; i < ArraySub.Length; i++)
                {
                    b.Bind(ref ArraySub[i]);
                }
            }

            TypeSymbol t = b.ObjectType;

            if (Type != null)
            {
                b.Bind(ref Type, BindAffinity.Type);
                Type.RequireType();
                t = Type.Symbol as TypeSymbol;
            }
            if (isDim)
            {
                t = Binder.ArrayOf(t, ArraySub.Length);
            }
            else if (isArray && Type == null)
            {
                t = Compilation.Get(NativeType.Array);
            }
            Symbol = b.AddLocal(Name, t) ?? throw Error(ErrorCode.LocalSameName, Name);
            if (Initializer != null)
            {
                b.Bind(ref Initializer);
                Initializer.RequireGetAccess();
                if (IsConst)
                {
                    if (!Initializer.IsConstant)
                    {
                        throw Error(ErrorCode.ValueNotConst);
                    }
                    Var.SetConst();
                }
                b.Convert(ref Initializer, Var.Type);
                Initializer = InitExpr.Bound(IdExpr.Bound(Var), Initializer, b.Options.Binding);
            }
            else if (IsConst)
            {
                throw Error(ErrorCode.ConstWithoutInitializer);
            }
            else if (isDim)
            {
                Initializer = InitExpr.Bound(IdExpr.Bound(Var), CtorCallExpr.Bound(b, IdExpr.Bound(t), ArgList.Bound(ArraySub)), b.Options.Binding);
            }
            else if (isArray)
            {
                Initializer = InitExpr.Bound(IdExpr.Bound(Var), MethodCallExpr.Bound(b, null, Compilation.Get(WellKnownMembers.XSharp___Array___ArrayNew), null, ArgList.Bound(ArraySub)), b.Options.Binding);
            }
            return(null);
        }