private static void runFile(string path) // REPL without the loop
{
Object.Environment env = Object.Environment.NewEnvironment();
Object.Environment macroEnv = Object.Environment.NewEnvironment();
string source = readFile(path);
lexer.Lexer l = lexer.Lexer.New(source);
parser.Parser p = parser.Parser.New(l);
ast.Program program = p.ParseProgram();
if (parser.Parser.Errors().Count != 0)
{
repl.printParserErrors(parser.Parser.Errors());
System.Environment.Exit(77);
}
evaluator.macro_expansion.DefineMacros(program, macroEnv);
ast.Node expanded = evaluator.macro_expansion.ExpandMacros(program, macroEnv);
Object.Object evaluated = evaluator.evaluator.Eval(expanded, env);
if (evaluated != null)
{
System.Console.Write(evaluated.Inspect());
System.Console.WriteLine();
}
}
static void _evalRepl()
{
Environment env = Environment.NewEnvironment();
for (;;)
{
System.Console.Write(PROMPT);
string line = System.Console.ReadLine();
Lexer l = Lexer.New(line);
Parser p = Parser.New(l);
ast.Program program = p.ParseProgram();
if (Parser.Errors().Count != 0)
{
printParserErrors(Parser.Errors());
continue;
}
Object evaluated = evaluator.evaluator.Eval(program, env);
if (evaluated != null)
{
System.Console.Write(evaluated.Inspect());
System.Console.WriteLine();
}
}
}
public ast.Program ParseProgram()
{
ast.Program program = new ast.Program {
};
program.Statements = new List <ast.Statement>();
while (!curTokenIs(token.EOF))
{
ast.Statement stmt = parseStatement();
if (stmt != null)
{
program.Statements.Add(stmt);
}
nextToken();
}
return(program);
}
public static void DefineMacros(ast.Program program, Object.Environment env)
{
List <int> defenitions = new List <int>();
for (int i = 0; i < program.Statements.Count; i++)
{
ast.Statement statement = program.Statements[i];
if (isMacroDefenition(statement))
{
addMacro(statement, env);
defenitions.Add(i++);
}
}
for (int i = defenitions.Count - 1; i >= 0; i--)
{
int defenitionIndex = defenitions[i];
program.Statements.RemoveAt(defenitionIndex);
}
}
static Object.Object evalProgram(ast.Program program, Object.Environment env)
{
Object.Object result = null;
foreach (ast.Statement statement in program.Statements)
{
result = Eval(statement, env);
if (result is Object.ReturnValue)
{
return(((Object.ReturnValue)result).Value);
}
if (result is Object.Error)
{
return(result);
}
}
return(result);
}
public static void Start(string path)
{
// Benchmarking variables
System.DateTime start = new System.DateTime();
System.TimeSpan duration = new System.TimeSpan();
Object.Object result = null;
string input = readFile(path);
Lexer l = Lexer.New(input);
Parser p = Parser.New(l);
ast.Program program = p.ParseProgram();
if (Parser.Errors().Count != 0)
{
repl.repl.printParserErrors(Parser.Errors());
System.Console.ReadKey();
System.Environment.Exit(77);
}
if (flag.EngineType == flag.engineType.vm)
{
Compiler_t comp = Compiler.New();
Compiler._SetCompiler(ref comp);
error err = Compiler.Compile(program);
if (err != null)
{
System.Console.WriteLine("Woops! Compilation failed:\n {0}", err);
System.Console.ReadKey();
System.Environment.Exit(78);
}
VM_t machine = VM.New(Compiler.Bytecode());
VM._SetVM(ref machine); // work around
if (flag.EnableBenchmark)
{
start = System.DateTime.Now;
}
err = VM.Run();
if (err != null)
{
System.Console.WriteLine("Woops! Executing bytecode failed:\n {0}", err);
System.Console.ReadKey();
System.Environment.Exit(79);
}
if (flag.EnableBenchmark)
{
duration = System.DateTime.Now.Subtract(start);
}
Object.Object lastPopped = VM.LastPoppedStackElem();
System.Console.Write(lastPopped.Inspect());
System.Console.WriteLine();
if (flag.EnableBenchmark)
{
result = lastPopped;
}
}
else
{
Object.Environment env = Object.Environment.NewEnvironment();
if (flag.EnableBenchmark)
{
start = System.DateTime.Now;
}
Object.Object evaluated = evaluator.evaluator.Eval(program, env);
if (flag.EnableBenchmark)
{
duration = System.DateTime.Now.Subtract(start);
}
if (evaluated != null)
{
System.Console.Write(evaluated.Inspect());
System.Console.WriteLine();
}
if (flag.EnableBenchmark)
{
result = evaluated;
}
}
if (flag.EnableBenchmark)
{
System.Console.WriteLine
(
"\nengine={0}, result={1}, duration={2}s",
flag.EngineType.ToString(),
result.Inspect(),
duration.TotalSeconds.ToString()
);
System.Console.ReadKey();
}
}
public static void Start()
{
if (flag.EngineType == flag.engineType.eval)
{
_evalRepl();
return; // unreachable
}
List <Object> constants = new List <Object>();
List <Object> globals = new List <Object>(new Object[VM.GlobalSize]);
symbol_table.SymbolTable symbolTable = symbol_table.NewSymbolTable();
for (int i = 0; i < builtins.Builtins.Length; i++)
{
_BuiltinDefinition v = builtins.Builtins[i];
symbol_table.DefineBuiltin(ref symbolTable, i, v.Name);
}
for (;;)
{
System.Console.Write(PROMPT);
string line = System.Console.ReadLine();
Lexer l = Lexer.New(line);
Parser p = Parser.New(l);
ast.Program program = p.ParseProgram();
if (Parser.Errors().Count != 0)
{
printParserErrors(Parser.Errors());
continue;
}
Compiler_t comp = Compiler.NewWithState(ref symbolTable, constants);
Compiler._SetCompiler(ref comp); // work around
error err = Compiler.Compile(program);
if (err != null)
{
System.Console.WriteLine("Woops! Compilation failed:\n {0}", err);
continue;
}
Bytecode code = Compiler.Bytecode();
constants = code.Constants;
VM_t machine = VM.NewWithGlobalStore(code, ref globals);
VM._SetVM(ref machine); // work around
err = VM.Run();
if (err != null)
{
System.Console.WriteLine("Woops! Executing bytecode failed:\n {0}", err);
continue;
}
Object lastPopped = VM.LastPoppedStackElem();
System.Console.Write(lastPopped.Inspect());
System.Console.WriteLine();
}
}
public static ast.Node Modify(ast.Node node, MofifierFunc modifier)
{
if (node is ast.Program)
{
ast.Program _node = (ast.Program)node;
for (int i = 0; i < _node.Statements.Count; i++)
{
_node.Statements[i] = (ast.Statement)Modify(_node.Statements[i], modifier);
}
node = _node;
}
if (node is ast.ExpressionStatement)
{
ast.ExpressionStatement _node = (ast.ExpressionStatement)node;
_node.Expression = (ast.Expression)Modify(_node.Expression, modifier);
node = _node;
}
if (node is ast.InfixExpression)
{
ast.InfixExpression _node = (ast.InfixExpression)node;
_node.Left = (ast.Expression)Modify(_node.Left, modifier);
_node.Right = (ast.Expression)Modify(_node.Right, modifier);
node = _node;
}
if (node is ast.PrefixExpression)
{
ast.PrefixExpression _node = (ast.PrefixExpression)node;
_node.Right = (ast.Expression)Modify(_node.Right, modifier);
node = _node;
}
if (node is ast.IndexExpression)
{
ast.IndexExpression _node = (ast.IndexExpression)node;
_node.Left = (ast.Expression)Modify(_node.Left, modifier);
_node.Index = (ast.Expression)Modify(_node.Index, modifier);
node = _node;
}
if (node is ast.IfExpression)
{
ast.IfExpression _node = (ast.IfExpression)node;
_node.Condition = (ast.Expression)Modify(_node.Condition, modifier);
_node.Consequence = (ast.BlockStatement)Modify(_node.Consequence, modifier);
node = _node;
if (_node.Alternative != null)
{
_node.Alternative = (ast.BlockStatement)Modify(_node.Alternative, modifier);
}
}
if (node is ast.BlockStatement)
{
ast.BlockStatement _node = (ast.BlockStatement)node;
for (int i = 0; i < _node.Statements.Count; i++)
{
_node.Statements[i] = (ast.Statement)Modify(_node.Statements[i], modifier);
}
node = _node;
}
if (node is ast.ReturnStatement)
{
ast.ReturnStatement _node = (ast.ReturnStatement)node;
_node.ReturnValue = (ast.Expression)Modify(_node.ReturnValue, modifier);
node = _node;
}
if (node is ast.LetStatement)
{
ast.LetStatement _node = (ast.LetStatement)node;
_node.Value = (ast.Expression)Modify(_node.Value, modifier);
node = _node;
}
if (node is ast.FunctionLiteral)
{
ast.FunctionLiteral _node = (ast.FunctionLiteral)node;
for (int i = 0; i < _node.Parameters.Count; i++)
{
_node.Parameters[i] = (ast.Identifier)Modify(_node.Parameters[i], modifier);
}
_node.Body = (ast.BlockStatement)Modify(_node.Body, modifier);
node = _node;
}
if (node is ast.ArrayLiteral)
{
ast.ArrayLiteral _node = (ast.ArrayLiteral)node;
for (int i = 0; i < _node.Elements.Count; i++)
{
_node.Elements[i] = (ast.Expression)Modify(_node.Elements[i], modifier);
}
node = _node;
}
if (node is ast.HashLiteral)
{
ast.HashLiteral _node = (ast.HashLiteral)node;
Dictionary <ast.Expression, ast.Expression> newPairs = new Dictionary <ast.Expression, ast.Expression>();
foreach (KeyValuePair <ast.Expression, ast.Expression> kv in _node.Pairs)
{
ast.Expression newKey = (ast.Expression)Modify(kv.Key, modifier);
ast.Expression newVal = (ast.Expression)Modify(kv.Value, modifier);
newPairs.Add(newKey, newVal);
}
_node.Pairs = newPairs;
node = _node;
}
return(modifier(node));
}
