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();
}
