internal override Node Bind(Binder b) { if (Token.Type == TokenType.LPARAMETERS || Token.Type == TokenType.PARAMETERS) { for (int i = 0; i < VarDecls.Length; i++) { var argIdx = b.Options.ArrayBase + i; var paramArray = IdExpr.Bound((b.Entity as Script).ParamArray); VarDecls[i].Initializer = IifExpr.Bound( BinaryExpr.Bound(ArrayLengthExpr.Bound(paramArray), Token, LiteralExpr.Bound(Constant.Create(i)), BinaryOperatorKind.GreaterThan, b.Options.Binding), ArrayAccessExpr.Bound(paramArray, ArgList.Bound(LiteralExpr.Bound(Constant.Create(argIdx))), b), DefaultExpr.Bound(b, b.ObjectType), b.Options.Binding); } } // TODO: Handle STATIC if (Token.Type == TokenType.STATIC) { throw Error(ErrorCode.NotSupported, "STATIC"); } for (int i = 0; i < VarDecls.Length; i++) { b.Bind(ref VarDecls[i]); } return(null); }
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) { if (Expr != null) { b.Bind(ref Expr); Expr.RequireGetAccess(); } else { if (b.Options.Dialect == XSharpDialect.FoxPro) { Expr = LiteralExpr.Bound(Constant.Create(false)); } else { Expr = LiteralExpr.Bound(Constant.CreateDefault(Compilation.Get(NativeType.Usual))); } } var t = IdExpr.Bound(Compilation.Get(WellKnownTypes.XSharp_Internal_WrappedException)); var args = ArgList.Bound(Expr); Expr = CtorCallExpr.Bound(b, t, args); b.Convert(ref Expr, Compilation.Get(NativeType.Object)); return(null); }
internal static VarDecl Bound(LocalSymbol loc, Expr initializer, BindOptions opt) { return(new VarDecl(null, null, null, null, AssignExpr.Bound(IdExpr.Bound(loc), initializer, opt)) { Symbol = loc }); }
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))); }
static internal IdExpr Bound(Symbol sym) { var e = new IdExpr(Token.None); e.Symbol = sym; e.Datatype = sym.Type(); return(e); }
static internal IdExpr Bound(LocalSymbol loc) { var e = new IdExpr(Token.None); e.Symbol = loc; e.Datatype = loc.Type; return(e); }
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) { if (Affinity != BindAffinity.Type) { Expr e = new IdExpr(Token); b.Bind(ref e, Affinity); return(e); } Symbol = Binder.GetNativeTypeFromToken(Kind) ?? ThrowError(ErrorCode.NotSupported, Kind); return(null); }
internal override Node Bind(Binder b) { b.CreatesAutoVars = true; Symbol = b.AddMemvar(Name); if (Initializer != null) { b.Bind(ref Initializer); Initializer.RequireGetAccess(); b.Convert(ref Initializer, Var.Type); Initializer = AssignExpr.Bound(IdExpr.Bound(Var), Initializer, b.Options.Binding); } 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 static MethodCallExpr Bound(Binder b, Expr e, string name, ArgList args) { Expr m = new IdExpr(name); Expr self; Expr writeBack; var ms = b.BindMemberAccess(ref e, ref m, BindAffinity.Invoke); if (!(ms is MethodSymbol)) { throw e.Error(ErrorCode.Internal); } var expr = new MemberAccessExpr(e, e.Token, m) { Symbol = ms }; var sym = b.BindMethodCall(expr, ms, ArgList.Empty, out self, out writeBack); return(Bound(e, sym, self, ArgList.Empty, writeBack)); }
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)); }
internal override Node Bind(Binder b) { b.OpenScope(); b.Bind(ref Expr); Expr.RequireGetAccess(); var s = b.FindOuter <SwitchStmt>() ?? throw Error(ErrorCode.Internal); Cond = BinaryExpr.Bound(Expr, Expr.Token, IdExpr.Bound(s.SwitchValue), BinaryOperatorKind.ExactEqual, b.Options.Binding); b.Convert(ref Cond, Compilation.Get(NativeType.Boolean)); if (When != null) { b.Bind(ref When); When.RequireGetAccess(); b.Convert(ref When, Compilation.Get(NativeType.Boolean)); } if (Stmt != null) { b.Bind(ref Stmt); } b.CloseScope(); return(null); }
internal override Node Bind(Binder b) { b.Bind(ref Initializer); Initializer.RequireGetAccess(); if (IsConst && Initializer is LiteralExpr c) { Symbol = b.AddConstant(Name, (Constant)c.Symbol) ?? throw Error(ErrorCode.LocalSameName, Name); } else { Symbol = b.AddLocal(Name, Initializer.Datatype) ?? throw Error(ErrorCode.LocalSameName, Name); if (IsConst) { if (Initializer?.IsConstant != true) { throw Error(ErrorCode.ValueNotConst); } Var.SetConst(); } Initializer = InitExpr.Bound(IdExpr.Bound(Var), Initializer, b.Options.Binding); } return(null); }
internal override Node Bind(Binder b) { b.OpenScope(); b.Bind(ref Type, BindAffinity.Type); Type.RequireType(); var v = b.AddLocal(Type.Symbol as TypeSymbol); var s = b.FindOuter <SwitchStmt>() ?? throw Error(ErrorCode.Internal); Cond = IsVarExpr.Bound(IdExpr.Bound(s.SwitchValue), Type, v); b.Convert(ref Cond, Compilation.Get(NativeType.Boolean)); if (When != null) { b.Bind(ref When); When.RequireGetAccess(); b.Convert(ref When, Compilation.Get(NativeType.Boolean)); } if (Stmt != null) { b.Bind(ref Stmt); } b.CloseScope(); return(null); }
internal IntrinsicCallExpr(IdExpr e, ArgList a, IntrinsicCallType t) : base(e, a) { Kind = t; }
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); }