public LoxFunction(Stmt.Function declaration, Environment closure, bool isInitializer) { IsInitializer = isInitializer; Declaration = declaration; Closure = closure; }
public LoxVoid VisitFunctionStmt(Stmt.Function stmt) { LoxFunction function = new LoxFunction(stmt, _environment, false); _environment.Define(stmt.Name.Lexeme, function); return(null); }
private Stmt Function(string kind) { Lexeme name = Consume(LexemeType.IDENTIFIER, Peek()); Consume(LexemeType.LEFT_PAREN, Peek()); var typeMap = new List <TypeParameterMap>(); if (!Check(LexemeType.RIGHT_PAREN)) { do { var parameterType = ConsumeKeyword(); var varName = Expr(); if (parameterType.IsKeyWord) { typeMap.Add(new TypeParameterMap(parameterType, varName)); } }while (Match(LexemeType.COMMA)); } Consume(LexemeType.RIGHT_PAREN, Peek()); Consume(LexemeType.EQUAL, Peek()); Consume(LexemeType.LEFT_BRACE, Peek()); List <Stmt> statements = Block(); var stmt = new Stmt.Function(name, typeMap, statements); return(stmt); }
public object VisitFunctionStmt(Stmt.Function stmt) { var function = new LoxFunction(stmt.name, stmt.function, _environment, false); _environment.Define(stmt.name.Lexeme, function); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt) { LoxFunction function = new LoxFunction(stmt, Environment, false); Environment.Define(stmt.Name.Lexeme, function); return(null); }
public object visitFunctionStmt(Stmt.Function stmt) { LoxFunction function = new LoxFunction(stmt, environment, false); environment.define(stmt.name.lexeme(), function); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.Name); Define(stmt.Name); ResolveFunction(stmt, FunctionType.FUNCTION); return(null); }
Stmt Stmt.Visitor <Stmt> .VisitFunctionStmt(Stmt.Function stmt) { JukaFunction functionCallable = new JukaFunction(stmt, null, false); environment.Define(stmt.name.ToString(), functionCallable); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt) { Function function = new Function(stmt); environment.Define(stmt.Name.Lexeme, function); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt, object options) { StringBuilder builder = new(); string typestr; if (stmt.returnType != null) { typestr = (string)stmt.returnType.Accept(this, null); } else { typestr = "void"; } builder.Append($"({typestr} {stmt.token.lexeme}("); foreach (var param in stmt.input) { if (param != stmt.input[0]) { builder.Append(", "); } builder.Append(param.Accept(this, null)); } builder.Append(") "); foreach (Stmt body in stmt.body) { builder.Append(body.Accept(this, null)); } builder.Append(')'); return(builder.ToString()); }
public Unit VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.Name); Define(stmt.Name); ResolveFunction(stmt); return(new Unit()); }
public string VisitFunctionStmt(Stmt.Function stmt) { StringBuilder builder = new(); builder.Append("(fun " + stmt.Name.Lexeme + "("); foreach (Parameter param in stmt.Parameters) { if (param != stmt.Parameters[0]) { builder.Append(' '); } builder.Append(param.Name.Lexeme); } builder.Append(") "); foreach (Stmt body in stmt.Body) { builder.Append(body.Accept(this)); } builder.Append(')'); return(builder.ToString()); }
public LoxFunction(Stmt.Function declaration, Environment closure, bool isInitializer) { this.declaration = declaration; this.closure = closure; this.isInitializer = isInitializer; }
public object visitFunctionStmt(Stmt.Function stmt) { declare(stmt.name); define(stmt.name); resolveFunction(stmt, FunctionType.TYPE_FUNCTION); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.name); Define(stmt.name); ResolveFunction(stmt, FunctionType.FUNCTION); return(new Stmt.DefaultStatement()); }
void function(Stmt.Function funStmt, FunctionType type) { /* clox: funDeclaration */ byte global = 0; if (type == FunctionType.TYPE_FUNCTION) { global = parseVariable(funStmt.name, "Expect function name."); markInitialized(); } /* clox: function */ Compiler_t compiler = new Compiler_t(); initCompiler(ref compiler, type, funStmt.name); captureToken(funStmt.name); beginScope(); // Compile parameter list. if (funStmt.params_.Count > 255) { errorAtCurrent("Cannot have more than 255 parameters."); } foreach (Token param in funStmt.params_) { byte paramConstant = parseVariable(param, "Expect parameter name."); defineVariable(paramConstant); } current.function.arity = funStmt.params_.Count; // Compile the function body. foreach (Stmt stmt in funStmt.body) { compile(stmt); } // Create the function object. ObjFunction function = endCompiler(); emitBytes((byte)OpCode.OP_CLOSURE, makeConstant(Value.OBJ_VAL(function))); for (int i = 0; i < function.upvalueCount; i++) { emitByte((byte)(compiler.upvalues[i].isLocal ? 1 : 0)); emitByte(compiler.upvalues[i].index); } /* clox: funDeclaration */ if (type == FunctionType.TYPE_FUNCTION) { defineVariable(global); } }
/// <summary> /// Resolve a function declaration /// </summary> /// <param name="stmt">The statement</param> public object Visit(Stmt.Function stmt) { // Declare and define the function name Declare(stmt.Name); Define(stmt.Name); ResolveFunction(stmt, FunctionType.FUNCTION); return(null); }
public LoxVoid VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.Name); Define(stmt.Name); ResolveFunction(stmt.Parameter, stmt.Body, FunctionType.Function); return(null); }
public object VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.name); Define(stmt.name); Resolve(stmt.function); return(null); }
public VoidObject VisitFunctionStmt(Stmt.Function stmt) { Declare(stmt.Name); DefineFunction(stmt.Name, stmt.ReturnTypeReference, stmt); ResolveFunction(stmt, FunctionType.FUNCTION); return(VoidObject.Void); }
private void ResolveFunction(Stmt.Function function) { BeginScope(); foreach (var param in function.Params) { Declare(param); Define(param); } Resolve(function.Body); EndScope(); }
public Unit VisitFunctionStmt(Stmt.Function stmt) { // Function names are variable types, to be decalared and defined in the same step. // THis allows recursion to handle self name resoluion. // nb: the funciton name and, arguments are all in the same scope. // the body not. Declare(stmt.Name); Define(stmt.Name); ResolveFunction(stmt, FunctionType.FUNCTION); return(new Unit()); }
public FunctionBinding(Stmt.Function function, ITypeReference typeReference, int distance, Expr referringExpr) : base(typeReference, referringExpr) { // Likewise, the Function property is permitted to be null for variable bindings (but not for Call // bindings) if (referringExpr is Expr.Call) { Function = function ?? throw new PerlangInterpreterException( "When referringExpr is an Expr.Call instance, function cannot be null"); } Distance = distance; }
public IEnumerable <string> VisitFunctionStmt(Stmt.Function stmt) { string parameters = string.Join(", ", stmt.Parameter.Select(p => p.Lexeme)); string[] body = stmt.Body.SelectMany(s => PrintStmt(s)).ToArray(); yield return($"fun {stmt.Name}({parameters}) {{"); foreach (string bodyStmt in body) { yield return($" {bodyStmt}"); } yield return("}"); }
private void ResolveFunction(Stmt.Function function, FunctionType type) { FunctionType enclosingFunction = CurrentFunction; CurrentFunction = type; BeginScope(); foreach (Token param in function.Params) { Declare(param); Define(param); } Resolve(function.Body); EndScope(); CurrentFunction = enclosingFunction; }
private void resolveFunction(Stmt.Function function, FunctionType type) { FunctionType enclosingFunction = currentFunction; currentFunction = type; beginScope(); foreach (Token param in function.params_) { declare(param); define(param); } resolve(function.body); endScope(); currentFunction = enclosingFunction; }
private void ResolveFunction(Stmt.Function function, FunctionType type) { var enclosingFunction = currentFunction; currentFunction = type; BeginScope(); foreach (var param in function.Parameters) { Declare(param); Define(param); } Resolve(function.Body); EndScope(); currentFunction = enclosingFunction; }
/// <summary> /// Resolve a function, creating a scope and its parameters /// </summary> /// <param name="function">The function</param> private void ResolveFunction(Stmt.Function function, FunctionType type) { // Keep track of functions FunctionType enclosing_function = _current_function; _current_function = type; BeginScope(); foreach (Token param in function.Parameters) { Declare(param); Define(param); } Resolve(function.Body); EndScope(); _current_function = enclosing_function; }
private void ResolveFunction(Stmt.Function function, FunctionType type) { FunctionType enclosingFunction = currentFunction; currentFunction = type; BeginScope(); foreach (Parameter param in function.Parameters) { Declare(param.Name); Define(param.Name, new TypeReference(param.TypeSpecifier)); } Resolve(function.Body); EndScope(); currentFunction = enclosingFunction; }
private void DefineFunction(Token name, ITypeReference typeReference, Stmt.Function function) { if (typeReference == null) { throw new ArgumentException("typeReference cannot be null"); } if (IsEmpty(scopes)) { globals[name.Lexeme] = new FunctionBindingFactory(typeReference, function); return; } // We set the variable’s value in the scope map to mark it as fully initialized and available for // use. It’s alive! As an extra bonus, we store the type reference of the initializer (if present), or the // function return type and function statement (in case of a function being defined). These details are // useful later on, in the static type analysis. scopes.Last()[name.Lexeme] = new FunctionBindingFactory(typeReference, function); }