public ClassDeclaration(SourceLocation location, string name, string doc) : base(location) { Name = name; Documentation = doc; /* * Create an empty constructor that will call the class's super constructor */ var emptyCtor = new FunctionDeclaration( location, name, true, false, false, false, new List <FunctionParameter> (), doc ); /* * This is important for insuring that the super class is properly initialized */ var callToSuper = new SuperCallStatement(location, this, new ArgumentList(location)); emptyCtor.Body.AddStatement(callToSuper); Constructor = emptyCtor; }
public ClassDeclaration (SourceLocation location, string name, List<string> baseClass) : base (location) { Name = name; Base = baseClass; FunctionDeclaration dummyCtor = new FunctionDeclaration (location, name, true, false, false, new List<string> ()); dummyCtor.Add (new Statement (location)); Add (dummyCtor); }
public ClassDeclaration(SourceLocation location, string name, List <string> baseClass) : base(location) { Name = name; Base = baseClass; FunctionDeclaration dummyCtor = new FunctionDeclaration(location, name, true, false, false, new List <string> ()); dummyCtor.Add(new Statement(location)); Add(dummyCtor); }
public override void Accept (FunctionDeclaration funcDecl) { symbolTable.AddSymbol (funcDecl.Name); FunctionAnalyser visitor = new FunctionAnalyser (errorLog, symbolTable); symbolTable.BeginScope (); foreach (string param in funcDecl.Parameters) { symbolTable.AddSymbol (param); } funcDecl.Children [0].Visit (visitor); symbolTable.EndScope (); }
public ClassDeclaration(SourceLocation location, string name, string doc, List <FunctionParameter> parameters) : base(location) { Name = name; Documentation = doc; var recordCtor = new FunctionDeclaration( location, name, true, false, false, true, parameters, doc ); recordCtor.Body.AddStatement(new SuperCallStatement(location, this, new ArgumentList(location))); foreach (NamedParameter parameter in parameters) { recordCtor.Body.AddStatement( new Expression( location, new BinaryExpression(location, BinaryOperation.Assign, new MemberExpression(location, new SelfExpression(location), parameter.Name ), new NameExpression(location, parameter.Name) ) ) ); } Constructor = recordCtor; }
private static AstNode ParseFunction(TokenStream stream, bool prototype = false, ClassDeclaration cdecl = null) { if (stream.Accept (TokenClass.Operator, "@")) { /* * Function decorators in the form of * @myDecorator * func foo () { * } * are merely syntatic sugar for * func foo () { * } * foo = myDecorator (foo) */ AstNode expr = ParseExpression (stream); // Decorator expression /* This is the original function which is to be decorated */ FunctionDeclaration idecl = ParseFunction (stream, prototype, cdecl) as FunctionDeclaration; /* We must construct an arglist which will be passed to the decorator */ ArgumentList args = new ArgumentList (stream.Location); args.Add (new NameExpression (stream.Location, idecl.Name)); /* * Since two values can not be returned, we must return a single node containing both * the function declaration and call to the decorator */ AstRoot nodes = new AstRoot (stream.Location); nodes.Add (idecl); nodes.Add (new Expression (stream.Location, new BinaryExpression (stream.Location, BinaryOperation.Assign, new NameExpression (stream.Location, idecl.Name), new CallExpression (stream.Location, expr, args)))); return nodes; } stream.Expect (TokenClass.Keyword, "func"); bool isInstanceMethod; bool isVariadic; bool hasKeywordArgs; Token ident = stream.Expect (TokenClass.Identifier); List<string> parameters = ParseFuncParameters (stream, out isInstanceMethod, out isVariadic, out hasKeywordArgs); FunctionDeclaration decl = new FunctionDeclaration (stream.Location, ident != null ? ident.Value : "", isInstanceMethod, isVariadic, hasKeywordArgs, parameters); if (!prototype) { if (stream.Accept (TokenClass.Operator, "=>")) { decl.Add (new ReturnStatement (stream.Location, ParseExpression (stream))); } else { stream.Expect (TokenClass.OpenBrace); CodeBlock scope = new CodeBlock (stream.Location); if (stream.Match (TokenClass.Keyword, "super")) { scope.Add (ParseSuperCall (stream, cdecl)); } while (!stream.Match (TokenClass.CloseBrace)) { scope.Add (ParseStatement (stream)); } decl.Add (scope); stream.Expect (TokenClass.CloseBrace); } } return decl; }
public override void Accept (FunctionDeclaration funcDecl) { symbolTable.NextScope (); IodineMethod anonMethod = new IodineMethod (methodBuilder, methodBuilder.Module, null, funcDecl.InstanceMethod, funcDecl.Parameters.Count, methodBuilder.LocalCount); FunctionCompiler compiler = new FunctionCompiler (symbolTable, anonMethod); for (int i = 0; i < funcDecl.Parameters.Count; i++) { anonMethod.Parameters [funcDecl.Parameters [i]] = symbolTable.GetSymbol (funcDecl.Parameters [i]).Index; } funcDecl.Children [0].Visit (compiler); anonMethod.EmitInstruction (funcDecl.Location, Opcode.LoadNull); anonMethod.Variadic = funcDecl.Variadic; anonMethod.AcceptsKeywordArgs = funcDecl.AcceptsKeywordArgs; anonMethod.FinalizeLabels (); methodBuilder.EmitInstruction (funcDecl.Location, Opcode.LoadConst, methodBuilder.Module.DefineConstant (anonMethod)); methodBuilder.EmitInstruction (funcDecl.Location, Opcode.BuildClosure); methodBuilder.EmitInstruction (funcDecl.Location, Opcode.StoreLocal, symbolTable.GetSymbol (funcDecl.Name).Index); symbolTable.LeaveScope (); }
private IodineMethod compileMethod(FunctionDeclaration funcDecl) { symbolTable.NextScope (); IodineMethod methodBuilder = new IodineMethod (module, funcDecl.Name, funcDecl.InstanceMethod, funcDecl.Parameters.Count, symbolTable.CurrentScope.SymbolCount); FunctionCompiler compiler = new FunctionCompiler (errorLog, symbolTable, methodBuilder); methodBuilder.Variadic = funcDecl.Variadic; methodBuilder.AcceptsKeywordArgs = funcDecl.AcceptsKeywordArgs; for (int i = 0; i < funcDecl.Parameters.Count; i++) { methodBuilder.Parameters [funcDecl.Parameters [i]] = symbolTable.GetSymbol (funcDecl.Parameters [i]).Index; } funcDecl.Children [0].Visit (compiler); methodBuilder.EmitInstruction (Opcode.LoadNull); methodBuilder.FinalizeLabels (); symbolTable.LeaveScope (); return methodBuilder; }
public void Accept(FunctionDeclaration funcDecl) { module.AddMethod (compileMethod (funcDecl)); }
public override void Accept (FunctionDeclaration funcDecl) { errorLog.AddError (ErrorType.ParserError, funcDecl.Location, "statement can not exist inside pattern!"); }
public virtual void Accept(FunctionDeclaration funcDecl) { }
public override void Accept (FunctionDeclaration funcDecl) { module.AddMethod (CompileMethod (funcDecl)); }
public DecoratedFunction(SourceLocation location, AstNode decorator, FunctionDeclaration decl) : base(location) { Decorator = decorator; Function = decl; }