public Expr Function(FunctionExpr functionExpr) { return Context.GetFunction(functionExpr.FunctionName) .ConvertAs<ISupportDiff>().Return( x => x.Diff(this, functionExpr.Args), () => { throw new InvalidOperationException(); }); //TODO exception and message }
private void InitializeFunctionCall(FunctionExpr expr) { // Keep track of total times this function was executed. // Keep tract of total times this function caused an error if (expr.ExecutionCount == long.MaxValue) { expr.ExecutionCount = 0; } else { expr.ExecutionCount++; } if (expr.ErrorCount == long.MaxValue) { expr.ErrorCount = 0; } expr.ContinueRunning = true; expr.ReturnValue = null; expr.HasReturnValue = false; PushParametersInScope(expr); }
public object VisitFunction(FunctionExpr expr) { return(null); }
public Value(FunctionExpr func) { _value = func; _type = ValueType.Function; }
Expr HandleFunction() { var funcLocation = _parser.PrevNonCommentLocation; string name = _parser.ReadIdentifier(); AccessorLetExpr funcName = null; if( name != null ) { funcName = new AccessorLetExpr( _parser.PrevNonCommentLocation, name ); Expr eRegName = _scope.Declare( name, funcName ); if( eRegName is SyntaxErrorExpr ) return eRegName; } IReadOnlyList<AccessorLetExpr> parameters, closures; Expr body = HandleFuncParametersAndBody( out parameters, out closures, false ); var f = new FunctionExpr( funcLocation, parameters, body, closures, funcName ); if( funcName == null ) return f; return new AssignExpr( funcLocation, funcName, f ); }
private void PushParametersInScope(FunctionExpr expr) { // 1. Validate : any arguments. if (expr.ArgumentValues == null || expr.ArgumentValues.Count == 0) { return; } if (expr.Meta.Arguments == null || expr.Meta.Arguments.Count == 0) { return; } // 2. Check if there is an parameter named "arguments" var hasParameterNamedArguments = false; if (expr.Meta.Arguments != null && expr.Meta.Arguments.Count > 0) { if (expr.Meta.ArgumentsLookup.ContainsKey("arguments")) { hasParameterNamedArguments = true; } } // 3. Get the symbolscope of the inside of the function and see if any statements. ISymbols symscope = null; var hasStatements = expr.Statements != null && expr.Statements.Count > 0; if (hasStatements) { symscope = expr.Statements[0].SymScope; } // 3. Add function arguments to scope for (var ndx = 0; ndx < expr.Meta.Arguments.Count; ndx++) { var val = expr.ArgumentValues[ndx] as LObject; var arg = expr.Meta.Arguments[ndx]; // 4. Clone primitive datatypes. if (val.Type.IsPrimitiveType()) { var copied = val.Clone(); expr.ArgumentValues[ndx] = copied; } // 5. Now, set the memory value of the parameter. this.Ctx.Memory.SetValue(arg.Name, val); // 6. Finally, update the symbol type if (hasStatements) { var sym = symscope.GetSymbol(arg.Name); if (sym != null && val.Type.TypeVal == TypeConstants.Function && sym.Category != SymbolCategory.Func) { SymbolHelper.ResetSymbolAsFunction(symscope, arg.Name, val); } } } // Finally add the arguments. // NOTE: Any extra arguments will be part of the implicit "arguments" array. if (!hasParameterNamedArguments) { var argArray = new LArray(expr.ArgumentValues); expr.Ctx.Memory.SetValue("arguments", argArray); } }
internal JSEvalFunction( FunctionExpr e, IReadOnlyList<Closure> closures ) { if( e == null ) throw new ArgumentNullException(); _expr = e; _closures = closures; }
public override string Visit(FunctionExpr e) { var pStr = ST.Symbols.DictFuncsStr[e.TypeExpr] + ParenthesizedVisit(true, e.Argument); return(pStr); }
/// <summary> /// Registers a custom function callback. /// </summary> /// <param name="pattern"></param> /// <param name="stmt">The function</param> public void Register(string pattern, FunctionExpr stmt) { _functions[pattern] = stmt; _lcaseToFormaNameMap[pattern.ToLower()] = pattern; }
protected abstract object MatchFunctionExpr(FunctionExpr functionExpr);
public virtual void Visit(FunctionExpr expr) { }
protected override object MatchFunctionExpr(FunctionExpr expr) { FunctionExpr(expr, FunctionType.FUNCTION); return(null); }
public Value(FunctionExpr func) { _value = func; _type = ValueType.Function; }
public virtual T Visit(FunctionExpr e) => default(T);
public Number Function(FunctionExpr functionExpr) { var func = Context.GetFunction(functionExpr.FunctionName); if(func != null) { return func.Evaluate(this, functionExpr.Args); } throw new NotImplementedException(); //TODO correct exception }