public string VisitFunctionStatement(FunctionStatement statement) { var builder = new StringBuilder(); builder.Append($"(procedure {statement.Name.Lexeme} ("); foreach (var param in statement.Parameters) { if (param != statement.Parameters[0]) { builder.Append(' '); } builder.Append(param.Lexeme); } builder.Append(") "); foreach (var body in statement.Body) { builder.Append(body.Accept(this)); } builder.Append(')'); return(builder.ToString()); }
public override void VisitFunctionStatement(FunctionStatement node) { // TODO: check that all function code paths return a value InFunction = true; DefaultVisit(node); InFunction = false; }
public override bool Smaller(LangObject other) { if (other.objectType != ObjectType.CLASS) { throw new InterpreterException("Invalid operation 'class' < '" + Convert.ToString(other.objectType) + "'"); } LangClass right = (LangClass)other; if (right.name != this.name) { throw new InterpreterException("Invalid Operation '" + this.name + "' < '" + right.name + "'"); } if (this.methods.Value.ContainsKey("__operator_smaller")) { FunctionStatement stat = (FunctionStatement)(((ArrayList)this.methods.Value["__operator_smaller"])[0]); LangObject obj = handler.RunClassOperator(stat, this, right); if (obj.objectType == ObjectType.NUMBER) { return(((LangNumber)obj).numberValue.Value == 1); } else { return(true); } } else { throw new InterpreterException("No overloaded function for '" + this.name + "' < '" + right.name + "'"); } }
public Unit VisitFunctionStatement(FunctionStatement statement) { Declare(statement.Token); Define(statement.Token); ResolveFunction(statement, FunctionType.Function); return(Unit.Value); }
public override void VisitFunctionStatement(FunctionStatement node) { var funcSymbol = Symbols.Lookup(node.Name) as DefinedFunctionSymbol; Debug.Assert(funcSymbol != null); VisitFunc(funcSymbol, node.Parameters, node.Block); }
public AstNode HoistFunction(FunctionStatement fn) { if (FunctionScope.DefineFunction(fn.Name, new Function(fn, this)) == null) { fn.Error("Duble declaration of variable"); } return(new VoidStatement()); }
public object VisitFunctionStatement(FunctionStatement statement) { scope.Initialize(statement.Name); ResolveFunction(statement, Scope.FunctionType.Function); return(null); }
public Function(FunctionStatement fn, Function parent) { FnType = FunctionType.STATEMENT; Name = fn.Name; Body = fn.Body; FunctionScope = new Scope(parent.FunctionScope, fn.Arguments); Visitor = new NodeVisitor(Body); }
public object VisitFunctionStatement(FunctionStatement statement) { var function = new LoxFunction(statement, environment); environment.Define(statement.Name, function); return(null); }
private void ResolveFunction(FunctionStatement function, Scope.FunctionType type) { scope.EnterFunction(type); foreach (var param in function.Parameters) { scope.Initialize(param); } Resolve(function.Body); scope.ExitFunction(); }
protected override void VisitFunctionStatement(FunctionStatement tree) { _TrySetResult(tree); if (_result != null) { return; } VisitAnySyntaxTree(tree.func_name); VisitAnySyntaxTree(tree.func_body); }
public static bool CheckVoidReturn(Context context, Scope scope, FunctionStatement functionStatement) { var anyNonVoidReturn = functionStatement.TreeAny(stt => { if (stt is ReturnStatement returnStatement) { if (returnStatement.Result != null) { return(true); } } return(false); }); return(!anyNonVoidReturn); }
private void ResolveFunction(FunctionStatement function, FunctionType type) { var enclosingFunc = _currentFunction; _currentFunction = type; BeginScope(); foreach (var param in function.Params) { Declare(param); Define(param); } Resolve(function.Body); EndScope(); _currentFunction = enclosingFunc; }
public override LangObject Mod(LangObject other) { if (other.objectType != ObjectType.CLASS) { throw new InterpreterException("Invalid operation 'class' % '" + Convert.ToString(other.objectType) + "'"); } LangClass right = (LangClass)other; if (right.name != this.name) { throw new InterpreterException("Invalid Operation '" + this.name + "' % '" + right.name + "'"); } if (this.methods.Value.ContainsKey("__operator_plus")) { FunctionStatement stat = (FunctionStatement)((ArrayList)this.methods.Value["__operator_mod"])[0]; return(handler.RunClassOperator(stat, this, right)); } else { throw new InterpreterException("No overloaded function for '" + this.name + "' % '" + right.name + "'"); } }
private FunctionStatement ParseFunctionStatement() { FunctionStatement ret = NewNode <FunctionStatement>(); NextToken(); ExpectToken(TokenType.IDENTIFIER); ret.Name = StrVal; NextToken(); ExpectToken(TokenType.LPAREN); NextToken(); bool first = true; while (Token != TokenType.RPAREN) { if (first) { first = false; } else { ExpectToken(TokenType.COMMA); NextToken(); } ExpectToken(TokenType.IDENTIFIER); ret.Arguments.Add(StrVal); NextToken(); } NextToken(); ExpectToken(TokenType.LBRACE); NextToken(); while (Token != TokenType.RBRACE) { ret.Body.Statements.Add(ParseStatement()); } NextToken(); return(ret); }
public LoxFunction(FunctionStatement declaration, Environment closure, bool isInitializer = false) { this.declaration = declaration; this.closure = closure; this.isInitializer = isInitializer; }
Statement ParseStatement(Scope scope) { int startP = reader.p; int startLine = reader.Peek().Line; Statement stat = null; // print(tok.Peek().Print()) if (reader.ConsumeKeyword("if")) { //setup IfStmt _if = new IfStmt(); //clauses do { int sP = reader.p; Expression nodeCond = ParseExpr(scope); if (!reader.ConsumeKeyword("then")) { error("'then' expected"); } List <Statement> nodeBody = ParseStatementList(scope); List <Token> range = new List <Token>(); range.Add(reader.tokens[sP - 1]); range.AddRange(reader.Range(sP, reader.p)); _if.Clauses.Add(new ElseIfStmt(scope) { Condition = nodeCond, Body = nodeBody, ScannedTokens = range }); }while (reader.ConsumeKeyword("elseif")); // else clause if (reader.ConsumeKeyword("else")) { int sP = reader.p; List <Statement> nodeBody = ParseStatementList(scope); List <Token> range = new List <Token>(); range.Add(reader.tokens[sP - 1]); range.AddRange(reader.Range(sP, reader.p)); _if.Clauses.Add(new ElseStmt(scope) { Body = nodeBody, ScannedTokens = range }); } // end if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } stat = _if; } else if (reader.ConsumeKeyword("while")) { WhileStatement w = new WhileStatement(scope); // condition Expression nodeCond = ParseExpr(scope); // do if (!reader.ConsumeKeyword("do")) { error("'do' expected"); } // body List <Statement> body = ParseStatementList(scope); //end if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } // return w.Condition = nodeCond; w.Body = body; stat = w; } else if (reader.ConsumeKeyword("do")) { // do block List <Statement> b = ParseStatementList(scope); if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } stat = new DoStatement(scope) { Body = b }; } else if (reader.ConsumeKeyword("for")) { //for block if (!reader.Is(TokenType.Ident)) { error("<ident> expected"); } Token baseVarName = reader.Get(); if (reader.ConsumeSymbol('=')) { //numeric for NumericForStatement forL = new NumericForStatement(scope); Variable forVar = new Variable() { Name = baseVarName.Data }; forL.Scope.AddLocal(forVar); Expression startEx = ParseExpr(scope); if (!reader.ConsumeSymbol(',')) { error("',' expected"); } Expression endEx = ParseExpr(scope); Expression stepEx = null; if (reader.ConsumeSymbol(',')) { stepEx = ParseExpr(scope); } if (!reader.ConsumeKeyword("do")) { error("'do' expected"); } List <Statement> body = ParseStatementList(forL.Scope); if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } forL.Variable = forVar; forL.Start = startEx; forL.End = endEx; forL.Step = stepEx; forL.Body = body; stat = forL; } else { // generic for GenericForStatement forL = new GenericForStatement(scope); List <Variable> varList = new List <Variable> { forL.Scope.CreateLocal(baseVarName.Data) }; while (reader.ConsumeSymbol(',')) { if (!reader.Is(TokenType.Ident)) { error("for variable expected"); } varList.Add(forL.Scope.CreateLocal(reader.Get().Data)); } if (!reader.ConsumeKeyword("in")) { error("'in' expected"); } List <Expression> generators = new List <Expression>(); Expression first = ParseExpr(scope); generators.Add(first); while (reader.ConsumeSymbol(',')) { Expression gen = ParseExpr(scope); generators.Add(gen); } if (!reader.ConsumeKeyword("do")) { error("'do' expected"); } List <Statement> body = ParseStatementList(forL.Scope); if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } forL.VariableList = varList; forL.Generators = generators; forL.Body = body; stat = forL; } } else if (reader.ConsumeKeyword("repeat")) { List <Statement> body = ParseStatementList(scope); if (!reader.ConsumeKeyword("until")) { error("'until' expected"); } Expression cond = ParseExpr(scope); RepeatStatement r = new RepeatStatement(scope); r.Condition = cond; r.Body = body; stat = r; } else if (reader.ConsumeKeyword("function")) { if (!reader.Is(TokenType.Ident)) { error("function name expected"); } Expression name = ParseSuffixedExpr(scope, true); // true: only dots and colons FunctionStatement func = ParseFunctionArgsAndBody(scope); func.IsLocal = false; func.Name = name; stat = func; } else if (reader.ConsumeKeyword("local")) { if (reader.Is(TokenType.Ident)) { List <string> varList = new List <string> { reader.Get().Data }; while (reader.ConsumeSymbol(',')) { if (!reader.Is(TokenType.Ident)) { error("local variable name expected"); } varList.Add(reader.Get().Data); } List <Expression> initList = new List <Expression>(); if (reader.ConsumeSymbol('=')) { do { Expression ex = ParseExpr(scope); initList.Add(ex); } while (reader.ConsumeSymbol(',')); } //now patch var list //we can't do this before getting the init list, because the init list does not //have the locals themselves in scope. List <Expression> newVarList = new List <Expression>(); for (int i = 0; i < varList.Count; i++) { Variable x = scope.CreateLocal(varList[i]); newVarList.Add(new VariableExpression { Var = x }); } AssignmentStatement l = new AssignmentStatement(); l.Lhs = newVarList; l.Rhs = initList; l.IsLocal = true; stat = l; } else if (reader.ConsumeKeyword("function")) { if (!reader.Is(TokenType.Ident)) { error("Function name expected"); } string name = reader.Get().Data; Variable localVar = scope.CreateLocal(name); FunctionStatement func = ParseFunctionArgsAndBody(scope); func.Name = new VariableExpression { Var = localVar }; func.IsLocal = true; stat = func; } else { error("local variable or function definition expected"); } } #if !VANILLA_LUA else if (reader.ConsumeSymbol("::")) { if (!reader.Is(TokenType.Ident)) { error("label name expected"); } string label = reader.Get().Data; if (!reader.ConsumeSymbol("::")) { error("'::' expected"); } LabelStatement l = new LabelStatement(); l.Label = label; stat = l; } #endif else if (reader.ConsumeKeyword("return")) { List <Expression> exprList = new List <Expression>(); if (!reader.IsKeyword("end") && !reader.IsEof()) { Expression firstEx = ParseExpr(scope); exprList.Add(firstEx); while (reader.ConsumeSymbol(',')) { Expression ex = ParseExpr(scope); exprList.Add(ex); } } ReturnStatement r = new ReturnStatement(); r.Arguments = exprList; stat = r; } else if (reader.ConsumeKeyword("break")) { stat = new BreakStatement(); } else if (reader.ConsumeKeyword("continue")) { stat = new ContinueStatement(); } #if !VANILLA_LUA else if (reader.ConsumeKeyword("goto")) { if (!reader.Is(TokenType.Ident)) { error("label expected"); } string label = reader.Get().Data; GotoStatement g = new GotoStatement(); g.Label = label; stat = g; } else if (reader.ConsumeKeyword("using")) { // using <a, b = 1, x()> do <statements> end UsingStatement us = new UsingStatement(scope); us.Scope = new Scope(scope); List <Expression> lhs = new List <Expression> { ParseExpr(us.Scope) }; while (reader.ConsumeSymbol(',')) { lhs.Add(ParseSuffixedExpr(us.Scope, true)); } // equals if (!reader.ConsumeSymbol('=')) { error("'=' expected"); } //rhs List <Expression> rhs = new List <Expression>(); rhs.Add(ParseExpr(us.Scope)); while (reader.ConsumeSymbol(',')) { rhs.Add(ParseExpr(scope)); } AssignmentStatement a = new AssignmentStatement(); a.Lhs = lhs; a.Rhs = rhs; a.IsLocal = true; if (!reader.ConsumeKeyword("do")) { error("'do' expected"); } List <Statement> block = ParseStatementList(us.Scope); if (!reader.ConsumeKeyword("end")) { error("'end' expected"); } us.Vars = a; us.Body = block; stat = us; } #endif else { // statementParseExpr Expression suffixed = ParseSuffixedExpr(scope); // assignment or call? if (reader.IsSymbol(',') || reader.IsSymbol('=')) { // check that it was not parenthesized, making it not an lvalue if (suffixed.ParenCount > 0) { error("Can not assign to parenthesized expression, it is not an lvalue"); } // more processing needed List <Expression> lhs = new List <Expression> { suffixed }; while (reader.ConsumeSymbol(',')) { lhs.Add(ParseSuffixedExpr(scope)); } // equals if (!reader.ConsumeSymbol('=')) { error("'=' expected"); } //rhs List <Expression> rhs = new List <Expression>(); rhs.Add(ParseExpr(scope)); while (reader.ConsumeSymbol(',')) { rhs.Add(ParseExpr(scope)); } AssignmentStatement a = new AssignmentStatement(); a.Lhs = lhs; a.Rhs = rhs; stat = a; } #if !VANILLA_LUA else if (isAugmentedAssignment(reader.Peek())) { AugmentedAssignmentStatement aas = new AugmentedAssignmentStatement(); Expression left = suffixed; Expression right = null; string augmentedOp = reader.Get().Data; right = ParseExpr(scope); BinOpExpr nRight = new BinOpExpr(); nRight.Lhs = left; nRight.Op = augmentedOp.Substring(0, augmentedOp.Length - 1); // strip the '=' nRight.Rhs = right; aas.Lhs = new List <Expression> { left }; aas.Rhs = new List <Expression> { nRight }; stat = aas; } #endif else if (suffixed is CallExpr || suffixed is TableCallExpr || suffixed is StringCallExpr) { //it's a call statement CallStatement c = new CallStatement(); c.Expression = suffixed; stat = c; } else { error("assignment statement expected"); } } stat.ScannedTokens = reader.Range(startP, reader.p); if (reader.Peek().Data == ";" && reader.Peek().Type == TokenType.Symbol) { stat.HasSemicolon = true; stat.SemicolonToken = reader.Get(); } if (stat.Scope == null) { stat.Scope = scope; } stat.LineNumber = startLine; return(stat); }
Expression ParseSimpleExpr(Scope scope) { if (reader.Is(TokenType.Number)) { return new NumberExpr { Value = reader.Get().Data } } ; else if (reader.Is(TokenType.DoubleQuoteString) || reader.Is(TokenType.SingleQuoteString) || reader.Is(TokenType.LongString)) { StringExpr s = new StringExpr { Value = reader.Peek().Data, StringType = reader.Peek().Type }; reader.Get(); return(s); } else if (reader.ConsumeKeyword("nil")) { return(new NilExpr()); } else if (reader.IsKeyword("false") || reader.IsKeyword("true")) { return new BoolExpr { Value = reader.Get().Data == "true" } } ; else if (reader.ConsumeSymbol("...")) { return(new VarargExpr()); } else if (reader.ConsumeSymbol('{')) { TableConstructorExpr v = new TableConstructorExpr(); while (true) { if (reader.IsSymbol('[')) { // key reader.Get(); // eat '[' Expression key = ParseExpr(scope); if (!reader.ConsumeSymbol(']')) { error("']' expected"); break; } if (!reader.ConsumeSymbol('=')) { error("'=' Expected"); break; } Expression value = ParseExpr(scope); v.EntryList.Add(new TableConstructorKeyExpr { Key = key, Value = value, }); } else if (reader.Is(TokenType.Ident)) { // value or key Token lookahead = reader.Peek(1); if (lookahead.Type == TokenType.Symbol && lookahead.Data == "=") { // we are a key Token key = reader.Get(); if (!reader.ConsumeSymbol('=')) { error("'=' Expected"); } Expression value = ParseExpr(scope); v.EntryList.Add(new TableConstructorStringKeyExpr { Key = key.Data, Value = value, }); } else { // we are a value Expression val = ParseExpr(scope); v.EntryList.Add(new TableConstructorValueExpr { Value = val }); } } #if !VANILLA_LUA else if (reader.ConsumeKeyword("function")) { if (reader.Peek().Type != TokenType.Ident) { error("function name expected"); } string name = reader.Get().Data; FunctionStatement fs = ParseFunctionArgsAndBody(scope); fs.IsLocal = false; fs.Name = new StringExpr(name); v.EntryList.Add(new TableConstructorNamedFunctionExpr { Value = fs }); } #endif else if (reader.ConsumeSymbol('}')) { break; } else { //value Expression value = ParseExpr(scope); v.EntryList.Add(new TableConstructorValueExpr { Value = value }); } if (reader.ConsumeSymbol(';') || reader.ConsumeSymbol(',')) { // I could have used just an empty statement (';') here, instead of { } // but that leaves a warning, which clutters up the output // other than that, all is good } else if (reader.ConsumeSymbol('}')) { break; } else { error("'}' or table entry Expected"); break; } } return(v); } else if (reader.ConsumeKeyword("function")) { AnonymousFunctionExpr func = ParseExprFunctionArgsAndBody(scope); //func.IsLocal = true; return(func); } #if !VANILLA_LUA else if (reader.ConsumeSymbol('|')) { // inline function... |<arg list>| -> <expr>, <expr> InlineFunctionExpression func = new InlineFunctionExpression(); func.Scope = new Scope(scope); // arg list List <Variable> arglist = new List <Variable>(); bool isVarArg = false; while (reader.ConsumeSymbol('|') == false) { if (reader.Is(TokenType.Ident)) { Variable arg = new Variable(); arg.Name = reader.Get().Data; func.Scope.AddLocal(arg); arglist.Add(arg); if (!reader.ConsumeSymbol(',')) { if (reader.ConsumeSymbol('|')) { break; } else { error("'|' expected"); break; } } } else if (reader.ConsumeSymbol("...")) { isVarArg = true; if (!reader.ConsumeSymbol('|')) { error("'...' must be the last argument of a function"); } break; } else { error("Argument name or '...' expected"); break; } } if (!reader.ConsumeSymbol("->")) { error("'->' expected"); } // body List <Expression> body = new List <Expression> { ParseExpr(func.Scope) }; while (reader.ConsumeSymbol(',')) { body.Add(ParseExpr(func.Scope)); } // end //nodeFunc.AstType = AstType.Function; func.Arguments = arglist; func.Expressions = body; func.IsVararg = isVarArg; return(func); } #endif else { return(ParseSuffixedExpr(scope)); } }
FunctionStatement ParseFunctionArgsAndBody(Scope scope) { FunctionStatement func = new FunctionStatement(scope); if (reader.ConsumeSymbol('(') == false) { error("'(' expected"); } // arg list List <Variable> arglist = new List <Variable>(); bool isVarArg = false; while (reader.ConsumeSymbol(')') == false) { if (reader.Is(TokenType.Ident)) { Variable arg = new Variable(); arg.Name = reader.Get().Data; func.Scope.AddLocal(arg); arglist.Add(arg); if (!reader.ConsumeSymbol(',')) { if (reader.ConsumeSymbol(')')) { break; } else { error("')' expected"); } break; } } else if (reader.ConsumeSymbol("...")) { isVarArg = true; if (!reader.ConsumeSymbol(')')) { error("'...' must be the last argument of a function"); } break; } else { error("Argument name or '...' expected"); break; } } // body List <Statement> body = ParseStatementList(func.Scope); // end if (!reader.ConsumeKeyword("end")) { error("'end' expected after function body"); } //nodeFunc.AstType = AstType.Function; func.Arguments = arglist; func.Body = body; func.IsVararg = isVarArg; return(func); }
public void Visit(FunctionStatement s) { s._function.Accept(this); }
protected abstract void VisitFunctionStatement(FunctionStatement tree);
public virtual void VisitFunctionStatement(FunctionStatement node) => DefaultVisit(node);
static List <CompletionItem> DoStatement(Statement s) { List <CompletionItem> ret = new List <CompletionItem>(); if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement)) { AssignmentStatement a = s as AssignmentStatement; foreach (Expression e in a.Lhs) { ret.AddRange(DoExpr(e)); } foreach (Expression e in a.Rhs) { ret.AddRange(DoExpr(e)); } } else if (s is AugmentedAssignmentStatement) { AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement; foreach (Expression e in a.Lhs) { ret.AddRange(DoExpr(e)); } foreach (Expression e in a.Rhs) { ret.AddRange(DoExpr(e)); } } else if (s is BreakStatement) { } else if (s is CallStatement) { // Also incredibly simple... CallStatement c = s as CallStatement; return(DoExpr(c.Expression)); } else if (s is DoStatement) { DoStatement d = s as DoStatement; return(DoChunk(d.Body)); } else if (s is GenericForStatement) { GenericForStatement g = s as GenericForStatement; foreach (Variable v in g.VariableList) { ret.Add(new CompletionItem(v.Name)); } ret.AddRange(DoChunk(g.Body)); } else if (s is NumericForStatement) { NumericForStatement n = s as NumericForStatement; ret.Add(new CompletionItem(n.Variable.Name)); ret.AddRange(DoChunk(n.Body)); } else if (s is FunctionStatement) { FunctionStatement f = s as FunctionStatement; ret.AddRange(DoExpr(f.Name)); foreach (Variable v in f.Arguments) { ret.Add(new CompletionItem(v.Name)); } ret.AddRange(DoChunk(f.Body)); } else if (s is GotoStatement) { } else if (s is IfStmt) { IfStmt i = s as IfStmt; for (int x = 0; x < i.Clauses.Count; x++) { ret.AddRange(DoStatement(i.Clauses[x])); } } else if (s is LabelStatement) { } else if (s is RepeatStatement) { RepeatStatement r = s as RepeatStatement; ret.AddRange(DoChunk(r.Body)); ret.AddRange(DoExpr(r.Condition)); } else if (s is ReturnStatement) { // no variable defined here. hopefully. } else if (s is UsingStatement) { UsingStatement u = s as UsingStatement; ret.AddRange(DoStatement(u.Vars)); ret.AddRange(DoChunk(u.Body)); } else if (s is WhileStatement) { WhileStatement w = s as WhileStatement; ret.AddRange(DoExpr(w.Condition)); ret.AddRange(DoChunk(w.Body)); } else if (s is ElseIfStmt) { ElseIfStmt e = s as ElseIfStmt; return(DoChunk(e.Body)); } else if (s is ElseStmt) { return(DoChunk(((ElseStmt)s).Body)); } return(ret); }
internal string DoStatement(Statement s) { if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement)) { AssignmentStatement a = s as AssignmentStatement; StringBuilder sb = new StringBuilder(); if (a.IsLocal) { sb.Append("local "); } for (int i = 0; i < a.Lhs.Count; i++) { sb.Append(DoExpr(a.Lhs[i])); if (i != a.Lhs.Count - 1) { sb.Append(","); } } if (a.Rhs.Count > 0) { sb.Append("="); for (int i = 0; i < a.Rhs.Count; i++) { sb.Append(DoExpr(a.Rhs[i])); if (i != a.Rhs.Count - 1) { sb.Append(","); } } } return(sb.ToString()); } else if (s is AugmentedAssignmentStatement) { AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement; StringBuilder sb = new StringBuilder(); //sb.Append(DoExpr(a.Lhs[0])); if (a.IsLocal) { sb.Append("local "); } Expression assignment = ((BinOpExpr)a.Rhs[0]).Rhs; sb.Append(DoExpr((((BinOpExpr)a.Rhs[0]).Lhs))); sb.Append("" + ((BinOpExpr)a.Rhs[0]).Op + "="); sb.Append(DoExpr(assignment)); return(sb.ToString()); } else if (s is BreakStatement) { // HAHAHA this is incredibly simple... return("break"); } else if (s is CallStatement) { // Also incredibly simple... CallStatement c = s as CallStatement; return(DoExpr(c.Expression)); } else if (s is DoStatement) { DoStatement d = s as DoStatement; StringBuilder sb = new StringBuilder(); sb.Append("do "); sb.Append(DoChunk(d.Body)); sb.Append(" end"); return(sb.ToString()); } else if (s is GenericForStatement) { GenericForStatement g = s as GenericForStatement; StringBuilder sb = new StringBuilder(); sb.Append("for "); for (int i = 0; i < g.VariableList.Count; i++) { sb.Append(g.VariableList[i].Name); if (i != g.VariableList.Count - 1) { sb.Append(","); } } sb.Append(" in "); for (int i = 0; i < g.Generators.Count; i++) { sb.Append(DoExpr(g.Generators[i])); if (i != g.Generators.Count - 1) { sb.Append(","); } } sb.Append(" do "); sb.Append(DoChunk(g.Body)); sb.Append(" end"); return(sb.ToString()); } else if (s is NumericForStatement) { NumericForStatement n = s as NumericForStatement; StringBuilder sb = new StringBuilder(); sb.Append("for "); sb.Append(n.Variable.Name); sb.Append("="); sb.Append(DoExpr(n.Start)); sb.Append(","); sb.Append(DoExpr(n.End)); if (n.Step != null) { sb.Append(","); sb.Append(DoExpr(n.Step)); } sb.Append(" do "); sb.Append(DoChunk(n.Body)); sb.Append(" end"); return(sb.ToString()); } else if (s is FunctionStatement) { FunctionStatement f = s as FunctionStatement; StringBuilder sb = new StringBuilder(); sb.Append("function " + DoExpr(f.Name) + "("); for (int i = 0; i < f.Arguments.Count; i++) { sb.Append(f.Arguments[i].Name); if (i != f.Arguments.Count - 1 || f.IsVararg) { sb.Append(","); } } if (f.IsVararg) { sb.Append("..."); } sb.Append(")"); sb.Append(" " + DoStatement(f.Body[0])); sb.Append(" end"); return(sb.ToString()); } else if (s is GotoStatement) { GotoStatement g = s as GotoStatement; return("goto " + g.Label); } else if (s is IfStmt) { IfStmt i = s as IfStmt; StringBuilder sb = new StringBuilder(); for (int x = 0; x < i.Clauses.Count; x++) { string ss = DoStatement(i.Clauses[x]); if (x == 0) { sb.Append("if "); sb.Append(ss); } else if (i.Clauses[x] is ElseStmt) { sb.Append(" else "); sb.Append(ss); } else { sb.Append("elseif " + ss); } } sb.Append(" end"); return(sb.ToString()); } else if (s is LabelStatement) { LabelStatement l = s as LabelStatement; return("::" + l.Label + "::"); } else if (s is RepeatStatement) { RepeatStatement r = s as RepeatStatement; StringBuilder sb = new StringBuilder(); sb.Append("repeat "); sb.Append(DoChunk(r.Body)); sb.Append(" until " + DoExpr(r.Condition)); return(sb.ToString()); } else if (s is ReturnStatement) { ReturnStatement r = s as ReturnStatement; StringBuilder sb = new StringBuilder(); sb.Append("return "); for (int i = 0; i < r.Arguments.Count; i++) { sb.Append(DoExpr(r.Arguments[i])); if (i != r.Arguments.Count - 1) { sb.Append(","); } } return(sb.ToString()); } else if (s is UsingStatement) { UsingStatement u = s as UsingStatement; StringBuilder sb = new StringBuilder(); sb.Append("using "); sb.Append(DoStatement(u.Vars)); sb.Append(" do "); sb.Append(DoChunk(u.Body)); sb.Append(" end"); return(sb.ToString()); } else if (s is WhileStatement) { WhileStatement w = s as WhileStatement; StringBuilder sb = new StringBuilder(); sb.Append("while "); sb.Append(DoExpr(w.Condition)); sb.Append(" do "); sb.Append(DoChunk(w.Body)); sb.Append(" end"); return(sb.ToString()); } else if (s is ElseIfStmt) { ElseIfStmt e = s as ElseIfStmt; string s2 = DoExpr(e.Condition) + " then "; s2 += DoChunk(e.Body); return(s2); } else if (s is ElseStmt) { return(DoChunk(((ElseStmt)s).Body)); } throw new NotImplementedException(s.GetType().Name + " is not implemented"); }
public void SetUp(List <string> args) { if (verbose) { Console.WriteLine("import path:"); foreach (string directory in pathResolver.Directories) { Console.WriteLine(" " + directory); } } AppDomain domain = Thread.GetDomain(); rootModule = new Module(null, null); foreach (Assembly assembly in domain.GetAssemblies()) { AssemblyLoaded(assembly); } domain.AssemblyLoad += OnDomainAssemblyLoad; rootModule.SetName("null", null); rootModule.SetName("true", true); rootModule.SetName("false", false); rootModule.SetName("args", args); DefaultWhitespace.SetUp(rootModule, grammar); LineComment.SetUp(rootModule, grammar); BlockComment.SetUp(rootModule, grammar); Whitespace.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Number.SetUp(rootModule, grammar); Base.String.SetUp(rootModule, grammar); Expression.SetUp(rootModule, grammar); ValueExpression.SetUp(rootModule, grammar); NameExpression.SetUp(rootModule, grammar); ParenExpression.SetUp(rootModule, grammar); MemberExpression.SetUp(rootModule, grammar); CallExpression.SetUp(rootModule, grammar); CallInParentScopeExpression.SetUp(rootModule, grammar); NewExpression.SetUp(rootModule, grammar); TypeExpression.SetUp(rootModule, grammar); IsExpression.SetUp(rootModule, grammar); AsExpression.SetUp(rootModule, grammar); UnaryExpression.SetUp(rootModule, grammar); NotExpression.SetUp(rootModule, grammar); MultiplicativeExpression.SetUp(rootModule, grammar); MultiplyExpression.SetUp(rootModule, grammar); DivideExpression.SetUp(rootModule, grammar); AdditiveExpression.SetUp(rootModule, grammar); AddExpression.SetUp(rootModule, grammar); SubtractExpression.SetUp(rootModule, grammar); ComparisonExpression.SetUp(rootModule, grammar); LessExpression.SetUp(rootModule, grammar); LessOrEqualExpression.SetUp(rootModule, grammar); EqualityExpression.SetUp(rootModule, grammar); InequalityExpression.SetUp(rootModule, grammar); GreaterExpression.SetUp(rootModule, grammar); GreaterOrEqualExpression.SetUp(rootModule, grammar); JunctionExpression.SetUp(rootModule, grammar); AndExpression.SetUp(rootModule, grammar); AssignmentExpression.SetUp(rootModule, grammar); AssignExpression.SetUp(rootModule, grammar); /* * NameExpression = ValueExpression * ParenExpression = ValueExpression * * CallExpression < ValueExpression * CallInParentScopeExpression = CallExpression * MemberExpression = CallExpression * * NewExpression < CallExpression * TypeExpression < NewExpression * UnaryExpression < TypeExpression * MultiplicativeExpression < UnaryExpression * AdditiveExpression < MultiplicativeExpression * ComparisonExpression < AdditiveExpression * JunctionExpression < ComparisonExpression * AssignmentExpression < JunctionExpression */ Precedence.SetPrecedence(NameExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(CallExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(MemberExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(NewExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(TypeExpression.pattern.Precedence, NewExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(UnaryExpression.pattern.Precedence, TypeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence, UnaryExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence, MultiplicativeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence, AdditiveExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(JunctionExpression.pattern.Precedence, ComparisonExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence, JunctionExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ValueExpression.pattern, NameExpression.pattern, ParenExpression.pattern, MemberExpression.pattern, CallExpression.pattern, NewExpression.pattern, TypeExpression.pattern, UnaryExpression.pattern, MultiplicativeExpression.pattern, AdditiveExpression.pattern, ComparisonExpression.pattern, JunctionExpression.pattern, AssignmentExpression.pattern); PatternExpression.SetUp(rootModule, grammar); ReferencePatternExpression.SetUp(rootModule, grammar); AnyPatternExpression.SetUp(rootModule, grammar); TextPatternExpression.SetUp(rootModule, grammar); Option.SetUp(rootModule, grammar); BlockPatternExpression.SetUp(rootModule, grammar); ParenPatternExpression.SetUp(rootModule, grammar); TokenPatternExpression.SetUp(rootModule, grammar); RangePatternExpression.SetUp(rootModule, grammar); RepeatPatternExpression.SetUp(rootModule, grammar); AndPatternExpression.SetUp(rootModule, grammar); NotPatternExpression.SetUp(rootModule, grammar); LabelPatternExpression.SetUp(rootModule, grammar); SequencePatternExpression.SetUp(rootModule, grammar); AltPatternExpression.SetUp(rootModule, grammar); /* * EndPatternExpression = ReferencePatternExpression * AnyPatternExpression = ReferencePatternExpression * TextPatternExpression = ReferencePatternExpression * BlockPatternExpression = ReferencePatternExpression * ParenPatternExpression = ReferencePatternExpression * TokenPatternExpression = ReferencePatternExpression * * RangePatternExpression < ReferencePatternExpression * * AndPatternExpression < RangePatternExpression * NotPatternExpression = AndPatternExpression * RepeatPatternExpression = AndPatternExpression * * LabelPatternExpression < AndPatternExpression * SequencePatternExpression < LabelPatternExpression * AltPatternExpression < SequencePatternExpression */ Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence, RangePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence, LabelPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence, SequencePatternExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ReferencePatternExpression.pattern, AnyPatternExpression.pattern, TextPatternExpression.pattern, BlockPatternExpression.pattern, ParenPatternExpression.pattern, TokenPatternExpression.pattern, RangePatternExpression.pattern, RepeatPatternExpression.pattern, AndPatternExpression.pattern, NotPatternExpression.pattern, LabelPatternExpression.pattern, SequencePatternExpression.pattern, AltPatternExpression.pattern); Statement.SetUp(rootModule, grammar); ExpressionStatement.SetUp(rootModule, grammar); CompoundStatement.SetUp(rootModule, grammar); PrintStatement.SetUp(rootModule, grammar); IfStatement.SetUp(rootModule, grammar); WhileStatement.SetUp(rootModule, grammar); ReturnStatement.SetUp(rootModule, grammar); ThrowStatement.SetUp(rootModule, grammar); TryStatement.SetUp(rootModule, grammar); ModuleStatement.SetUp(rootModule, grammar); FunctionStatement.SetUp(rootModule, grammar); Member.SetUp(rootModule, grammar); PatternMember.SetUp(rootModule, grammar); FieldMember.SetUp(rootModule, grammar); ConstructorMember.SetUp(rootModule, grammar); MethodMember.SetUp(rootModule, grammar); ClassStatement.SetUp(rootModule, grammar); SetPrecedenceStatement.SetUp(rootModule, grammar); UsingStatement.SetUp(rootModule, grammar); ImportStatement.SetUp(rootModule, grammar); TopLevelStatement.SetUp(rootModule, grammar); Program.SetUp(rootModule, grammar); Grammar.PatternChanged(Member.pattern, Statement.pattern); grammar.RootPattern = Program.pattern; hasBeenSetUp = true; }
internal string DoStatement(Statement s, ref int i) { // If the statement contains a body, we cant just fromTokens it, as it's body might not be // fully tokenized input. Therefore, we run DoChunk on Body's if (s.ScannedTokens != null && s.ScannedTokens.Count > 0) { if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement)) { AssignmentStatement a = s as AssignmentStatement; StringBuilder sb = new StringBuilder(); if (a.IsLocal) { sb.Append(fromToken(a.ScannedTokens[i++], a.Scope)); sb.Append(" "); } for (int i2 = 0; i2 < a.Lhs.Count; i2++) { sb.Append(DoExpr(a.Lhs[i2], s.ScannedTokens, ref i, s.Scope)); if (i2 != a.Lhs.Count - 1) { sb.Append(fromToken(a.ScannedTokens[i++], a.Scope)); sb.Append(" "); } } if (a.Rhs.Count > 0) { sb.Append(" "); sb.Append(fromToken(a.ScannedTokens[i++], a.Scope)); sb.Append(" "); for (int i2 = 0; i2 < a.Rhs.Count; i2++) { sb.Append(DoExpr(a.Rhs[i2], s.ScannedTokens, ref i, s.Scope)); if (i2 != a.Rhs.Count - 1) { sb.Append(fromToken(a.ScannedTokens[i++], s.Scope)); sb.Append(" "); } } } return(sb.ToString()); } else if (s is AugmentedAssignmentStatement) { AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement; StringBuilder sb = new StringBuilder(); //sb.Append(DoExpr(a.Lhs[0])); if (a.IsLocal) { sb.Append(fromToken(a.ScannedTokens[i++], a.Scope)); sb.Append(" "); } Expression assignment = ((BinOpExpr)a.Rhs[0]).Rhs; Expression tmp = ((BinOpExpr)a.Rhs[0]).Lhs; sb.Append(DoExpr(tmp, s.ScannedTokens, ref i, s.Scope)); sb.Append(" "); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); sb.Append(" "); sb.Append(DoExpr(assignment, s.ScannedTokens, ref i, s.Scope)); return(sb.ToString()); } else if (s is BreakStatement) { // HAHAHA this is incredibly simple... return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is ContinueStatement) { return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is CallStatement) { // Also incredibly simple... return(DoExpr(((CallStatement)s).Expression, s.ScannedTokens, ref i, s.Scope)); } else if (s is DoStatement) { DoStatement d = s as DoStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(d.ScannedTokens[0], s.Scope)); // 'do' sb.Append(options.EOL); indent++; sb.Append(DoChunk(d.Body, ref i)); sb.Append(nldedent()); sb.Append(fromToken(d.ScannedTokens[d.ScannedTokens.Count - 1], s.Scope)); // end return(sb.ToString()); } else if (s is GenericForStatement) { GenericForStatement g = s as GenericForStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(g.ScannedTokens[i++], s.Scope)); // 'for' sb.Append(" "); for (int x = 0; x < g.VariableList.Count; x++) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); if (x != g.VariableList.Count - 1) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // ',' sb.Append(" "); } } sb.Append(" "); sb.Append(fromToken(g.ScannedTokens[i++], s.Scope)); // 'in' sb.Append(" "); for (int x = 0; x < g.Generators.Count; x++) { //sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); DoExpr(g.Generators[x], g.ScannedTokens, ref i, s.Scope); if (x != g.VariableList.Count - 1) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // ',' sb.Append(" "); } } sb.Append(" "); sb.Append(fromToken(g.ScannedTokens[i++], s.Scope)); // 'do' sb.Append(options.EOL); indent++; sb.Append(DoChunk(g.Body)); sb.Append(nldedent()); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); // <end> return(sb.ToString()); } else if (s is NumericForStatement) { NumericForStatement n = s as NumericForStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // 'for' sb.Append(" "); sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // <var> sb.Append(" "); sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // '=' sb.Append(" "); sb.Append(DoExpr(n.Start, n.ScannedTokens, ref i, s.Scope)); // <start> //sb.Append(" "); sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // ',' sb.Append(" "); sb.Append(DoExpr(n.End, n.ScannedTokens, ref i, s.Scope)); // <end> if (n.Step != null) { sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // ',' sb.Append(" "); sb.Append(DoExpr(n.Step, n.ScannedTokens, ref i, s.Scope)); // <step> sb.Append(" "); } else { sb.Append(" "); } sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); // 'do' sb.Append(options.EOL); indent++; sb.Append(DoChunk(n.Body)); sb.Append(nldedent()); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); // <end> return(sb.ToString()); } else if (s is FunctionStatement) { FunctionStatement f = s as FunctionStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'function' sb.Append(" "); sb.Append(DoExpr(f.Name, s.ScannedTokens, ref i, s.Scope)); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // '(' for (int i2 = 0; i2 < f.Arguments.Count; i2++) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); if (i2 != f.Arguments.Count - 1)// || f.IsVararg) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); sb.Append(" "); } } if (f.IsVararg) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); sb.Append(" "); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // ')' sb.Append(options.EOL); indent++; sb.Append(DoChunk(f.Body)); indent--; sb.Append(options.EOL); sb.Append(writeIndent()); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); // <end> sb.Append(options.EOL); return(sb.ToString()); } else if (s is GotoStatement) { // goto <string label>, so no expr //GotoStatement g = s as GotoStatement; return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is IfStmt) { IfStmt ifs = s as IfStmt; StringBuilder sb = new StringBuilder(); foreach (SubIfStmt clause in ifs.Clauses) { int i3 = 0; if (clause is ElseIfStmt) { ElseIfStmt c = clause as ElseIfStmt; sb.Append(fromToken(c.ScannedTokens[i3++], s.Scope)); // if/elseif sb.Append(" "); sb.Append(DoExpr(c.Condition, c.ScannedTokens, ref i3, c.Scope)); sb.Append(" "); sb.Append(fromToken(c.ScannedTokens[i3++], s.Scope)); // 'then' sb.Append(options.EOL); indent++; sb.Append(DoChunk(clause.Body)); sb.Append(nldedent()); } else if (clause is ElseStmt) { sb.Append(fromToken(clause.ScannedTokens[i3++], s.Scope)); // if/elseif sb.Append(options.EOL); indent++; sb.Append(DoChunk(clause.Body)); sb.Append(nldedent()); } else { throw new NotImplementedException(clause.GetType().Name); } } sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); // 'end' return(sb.ToString()); } else if (s is LabelStatement) { // ::<string label>::, so no expr return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is RepeatStatement) { RepeatStatement r = s as RepeatStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(r.ScannedTokens[0], s.Scope)); i = 1; sb.Append(options.EOL); indent++; sb.Append(DoChunk(r.Body, ref i)); sb.Append(nldedent()); sb.Append(fromToken(r.ScannedTokens[i++], r.Scope)); sb.Append(" "); sb.Append(DoExpr(r.Condition, r.ScannedTokens, ref i, r.Scope)); return(sb.ToString()); } else if (s is ReturnStatement) { ReturnStatement rs = s as ReturnStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'return' sb.Append(" "); for (int x = 0; x < rs.Arguments.Count; x++) { sb.Append(DoExpr(rs.Arguments[x], rs.ScannedTokens, ref i, s.Scope)); if (x != rs.Arguments.Count - 1) { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // ',' sb.Append(" "); } } return(sb.ToString()); } else if (s is UsingStatement) { UsingStatement u = s as UsingStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'using' sb.Append(" "); AssignmentStatement a = u.Vars; for (int i2 = 0; i2 < a.Lhs.Count; i2++) { sb.Append(DoExpr(a.Lhs[i2], u.ScannedTokens, ref i, s.Scope)); if (i2 != a.Lhs.Count - 1) { sb.Append(fromToken(u.ScannedTokens[i++], a.Scope)); sb.Append(" "); } } if (a.Rhs.Count > 0) { sb.Append(" "); sb.Append(fromToken(u.ScannedTokens[i++], a.Scope)); // '=' sb.Append(" "); for (int i2 = 0; i2 < a.Rhs.Count; i2++) { sb.Append(DoExpr(a.Rhs[i2], u.ScannedTokens, ref i, s.Scope)); if (i2 != a.Rhs.Count - 1) { sb.Append(fromToken(u.ScannedTokens[i++], s.Scope)); sb.Append(" "); } } } sb.Append(" "); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'do' sb.Append(options.EOL); indent++; sb.Append(DoChunk(u.Body)); sb.Append(nldedent()); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); // 'end' return(sb.ToString()); } else if (s is WhileStatement) { WhileStatement w = s as WhileStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'while' sb.Append(" "); sb.Append(DoExpr(w.Condition, w.ScannedTokens, ref i, s.Scope)); sb.Append(" "); sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); // 'do' sb.Append(options.EOL); indent++; sb.Append(DoChunk(w.Body)); sb.Append(nldedent()); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } } else // No token stream, beautify { return(beautifier.DoStatement(s)); } throw new NotImplementedException(s.GetType().Name + " is not implemented"); }
public override void VisitFunctionStatement(FunctionStatement node) => VisitFunc(node.Name, node.Block);
public EnkelFunction(FunctionStatement declaration, IEnkelEnvironment closure, bool isConstructor) { _declaration = declaration; _closure = closure; _isConstructor = isConstructor; }
public static bool TryGetInlinedStatement(Context context, Scope scope, FunctionStatement function, out IStatement inlinedStatement) { if (!context.Flags.UseInlining) { inlinedStatement = null; return(false); } IStatement stt; if (function.Statement is BlockStatement blockStatement) { if (blockStatement.Statements.Length != 1) { inlinedStatement = null; return(false); } stt = blockStatement.Statements.First(); } else { stt = function.Statement; } switch (stt) { case FunctionCallStatement functionCallStatement: { if (!context.Flags.InlineCascadingFunctionCalls) { inlinedStatement = null; return(false); } if (!scope.TryGetFunctionInfo(functionCallStatement, out var functionInfo)) { inlinedStatement = functionInfo.InlinedStatement; return(inlinedStatement != null); } inlinedStatement = functionCallStatement; return(true); } case EvaluationStatement evaluationStatement: { inlinedStatement = evaluationStatement; return(true); } case ReturnStatement returnStatement: { inlinedStatement = returnStatement; return(true); } default: { if (!context.Flags.InlineNonEvaluations) { inlinedStatement = null; return(false); } inlinedStatement = stt; return(true); } } }
internal string DoStatement(Statement s) { // If the statement contains a body, we cant just fromTokens it, as it's body might not be // fully tokenized input. Therefore, we run DoChunk on Body's if (s.ScannedTokens != null && s.ScannedTokens.Count > 0) { if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement)) { return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is AugmentedAssignmentStatement) { return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is BreakStatement) { // HAHAHA this is incredibly simple... return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is CallStatement) { // Also incredibly simple... return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is DoStatement) { DoStatement d = s as DoStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(d.ScannedTokens[0], s.Scope)); // 'do' sb.Append(DoChunk(d.Body)); sb.Append(fromToken(d.ScannedTokens[d.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } else if (s is GenericForStatement) { GenericForStatement g = s as GenericForStatement; StringBuilder sb = new StringBuilder(); int i = 0; while (g.ScannedTokens[i].Data != "do") { sb.Append(fromToken(g.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(g.ScannedTokens[i++], s.Scope)); sb.Append(DoChunk(g.Body)); sb.Append(fromToken(g.ScannedTokens[g.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } else if (s is NumericForStatement) { NumericForStatement n = s as NumericForStatement; StringBuilder sb = new StringBuilder(); int i = 0; while (n.ScannedTokens[i].Data != "do") { sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(n.ScannedTokens[i++], s.Scope)); sb.Append(DoChunk(n.Body)); sb.Append(fromToken(n.ScannedTokens[n.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } else if (s is FunctionStatement) { FunctionStatement f = s as FunctionStatement; StringBuilder sb = new StringBuilder(); int i = 0; while (f.ScannedTokens[i].Data != ")") { sb.Append(fromToken(f.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(f.ScannedTokens[i++], s.Scope)); sb.Append(DoChunk(f.Body)); sb.Append(fromToken(f.ScannedTokens[f.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } else if (s is GotoStatement) { GotoStatement g = s as GotoStatement; return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is IfStmt) { IfStmt i = s as IfStmt; StringBuilder sb = new StringBuilder(); foreach (SubIfStmt clause in i.Clauses) { int i2 = 0; while (clause.ScannedTokens[i2].Data != "then") { sb.Append(fromToken(clause.ScannedTokens[i2++], clause.Scope)); } sb.Append(DoChunk(clause.Body)); sb.Append(fromToken(clause.ScannedTokens[i2++], clause.Scope)); } return(sb.ToString()); } else if (s is LabelStatement) { return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is RepeatStatement) { RepeatStatement r = s as RepeatStatement; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(r.ScannedTokens[0], s.Scope)); sb.Append(DoChunk(r.Body)); int i = 0; for (int i2 = 0; i2 < r.ScannedTokens.Count; i2++) { if (r.ScannedTokens[i2].Data == "until") { i = i2; } } for (int i2 = i; i2 < r.ScannedTokens.Count; i2++) { sb.Append(fromToken(r.ScannedTokens[i2], s.Scope)); } return(sb.ToString()); } else if (s is ReturnStatement) { return(fromTokens(s.ScannedTokens, s.Scope)); } else if (s is UsingStatement) { UsingStatement u = s as UsingStatement; StringBuilder sb = new StringBuilder(); int i = 0; while (s.ScannedTokens[i].Data != "do") { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); sb.Append(DoChunk(u.Body)); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } else if (s is WhileStatement) { WhileStatement w = s as WhileStatement; StringBuilder sb = new StringBuilder(); int i = 0; while (s.ScannedTokens[i].Data != "do") { sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); } sb.Append(fromToken(s.ScannedTokens[i++], s.Scope)); sb.Append(DoChunk(w.Body)); sb.Append(fromToken(s.ScannedTokens[s.ScannedTokens.Count - 1], s.Scope)); return(sb.ToString()); } /* * else if (s is ElseIfStmt) * { * ElseIfStmt e = s as ElseIfStmt; * string s2 = DoExpr(e.Condition) + " then" + EOL; * s2 += DoChunk(e.Body); * return s2; * } * else if (s is ElseStmt) * { * return DoChunk(((ElseStmt)s).Body); * } */ } else // No token stream, beautify { return(beautifier.DoStatement(s)); } throw new NotImplementedException(s.GetType().Name + " is not implemented"); }
public virtual object Visit(FunctionStatement that, object value) { throw new System.NotImplementedException(); }