private static void InfixOp(Compiler c, bool allowAssignment)
{
GrammarRule rule = c.GetRule(c._parser.Previous.Type);
// An infix operator cannot end an expression.
c.IgnoreNewlines();
// Compile the right-hand side.
c.ParsePrecedence(false, rule.Precedence + 1);
// Call the operator method on the left-hand side.
Signature signature = new Signature { Type = SignatureType.Method, Arity = 1, Name = rule.Function, Length = rule.Function.Length };
c.CallSignature(Instruction.CALL_0, signature);
}
public static ObjFn Compile(WrenVM vm, ObjModule module, string sourcePath, string source, bool printErrors)
{
Parser parser = new Parser
{
vm = vm,
Module = module,
SourcePath = sourcePath,
Source = source,
TokenStart = 0,
CurrentChar = 0,
CurrentLine = 1,
Current = { Type = TokenType.Error, Start = 0, Length = 0, Line = 0 },
SkipNewlines = true,
PrintErrors = printErrors,
HasError = false,
Raw = ""
};
Compiler compiler = new Compiler(parser, null, true);
// Read the first token.
compiler.NextToken();
compiler.IgnoreNewlines();
while (!compiler.Match(TokenType.Eof))
{
compiler.Definition();
// If there is no newline, it must be the end of the block on the same line.
if (!compiler.MatchLine())
{
compiler.Consume(TokenType.Eof, "Expect end of file.");
break;
}
}
compiler.Emit(Instruction.NULL);
compiler.Emit(Instruction.RETURN);
// See if there are any implicitly declared module-level variables that never
// got an explicit definition.
// TODO: It would be nice if the error was on the line where it was used.
for (int i = 0; i < parser.Module.Variables.Count; i++)
{
ModuleVariable t = parser.Module.Variables[i];
if (t.Container == Obj.Undefined)
{
compiler.Error(string.Format("Variable '{0}' is used but not defined.", t.Name));
}
}
return compiler.EndCompiler("(script)");
}
static void or_(Compiler c, bool allowAssignment)
{
c.IgnoreNewlines();
// Skip the right argument if the left is true.
int jump = c.EmitJump(Instruction.OR);
c.ParsePrecedence(false, Precedence.LogicalOr);
c.PatchJump(jump);
}
private static void Conditional(Compiler c, bool allowAssignment)
{
// Ignore newline after '?'.
c.IgnoreNewlines();
// Jump to the else branch if the condition is false.
int ifJump = c.EmitJump(Instruction.JUMP_IF);
// Compile the then branch.
c.ParsePrecedence(allowAssignment, Precedence.Ternary);
c.Consume(TokenType.Colon, "Expect ':' after then branch of conditional operator.");
c.IgnoreNewlines();
// Jump over the else branch when the if branch is taken.
int elseJump = c.EmitJump(Instruction.JUMP);
// Compile the else branch.
c.PatchJump(ifJump);
c.ParsePrecedence(allowAssignment, Precedence.Assignment);
// Patch the jump over the else.
c.PatchJump(elseJump);
}
// Unary operators like `-foo`.
private static void UnaryOp(Compiler c, bool allowAssignment)
{
GrammarRule rule = c.GetRule(c._parser.Previous.Type);
c.IgnoreNewlines();
// Compile the argument.
c.ParsePrecedence(false, Precedence.Unary + 1);
// Call the operator method on the left-hand side.
c.CallMethod(0, rule.Function);
}
private static void Call(Compiler c, bool allowAssignment)
{
c.IgnoreNewlines();
c.Consume(TokenType.Name, "Expect method name after '.'.");
c.NamedCall(allowAssignment, Instruction.CALL_0);
}
// A map literal.
private static void Map(Compiler c, bool allowAssignment)
{
// Load the Map class.
c.LoadCoreVariable("Map");
// Instantiate a new map.
c.CallMethod(0, "new()");
// Compile the map elements. Each one is compiled to just invoke the
// subscript setter on the map.
if (c.Peek() != TokenType.RightBrace)
{
do
{
c.IgnoreNewlines();
if (c.Peek() == TokenType.RightBrace)
break;
// Push a copy of the map since the subscript call will consume it.
c.Emit(Instruction.DUP);
// The key.
c.ParsePrecedence(false, Precedence.Primary);
c.Consume(TokenType.Colon, "Expect ':' after map key.");
c.IgnoreNewlines();
// The value.
c.Expression();
c.CallMethod(2, "[_]=(_)");
// Discard the result of the setter call.
c.Emit(Instruction.POP);
} while (c.Match(TokenType.Comma));
}
// Allow newlines before the closing '}'.
c.IgnoreNewlines();
c.Consume(TokenType.RightBrace, "Expect '}' after map entries.");
}
// A list literal.
private static void List(Compiler c, bool allowAssignment)
{
// Load the List class.
c.LoadCoreVariable("List");
// Instantiate a new list.
c.CallMethod(0, "new()");
// Compile the list elements. Each one compiles to a ".add()" call.
if (c.Peek() != TokenType.RightBracket)
{
do
{
c.IgnoreNewlines();
if (c.Peek() == TokenType.RightBracket)
break;
// Push a copy of the list since the add() call will consume it.
c.Emit(Instruction.DUP);
// The element.
c.Expression();
c.CallMethod(1, "add(_)");
// Discard the result of the add() call.
c.Emit(Instruction.POP);
} while (c.Match(TokenType.Comma));
}
// Allow newlines before the closing ']'.
c.IgnoreNewlines();
c.Consume(TokenType.RightBracket, "Expect ']' after list elements.");
}
private static void and_(Compiler c, bool allowAssignment)
{
c.IgnoreNewlines();
// Skip the right argument if the left is false.
int jump = c.EmitJump(Instruction.AND);
c.ParsePrecedence(false, Precedence.PREC_LOGICAL_AND);
c.PatchJump(jump);
}
// A map literal.
private static void Map(Compiler c, bool allowAssignment)
{
// Load the Map class.
int mapClassSymbol = c.parser.module.Variables.FindIndex(v => v.Name == "Map");
c.EmitShortArg(Instruction.LOAD_MODULE_VAR, mapClassSymbol);
// Instantiate a new map.
c.CallMethod(0, "<instantiate>");
// Compile the map elements. Each one is compiled to just invoke the
// subscript setter on the map.
if (c.Peek() != TokenType.TOKEN_RIGHT_BRACE)
{
do
{
c.IgnoreNewlines();
// Push a copy of the map since the subscript call will consume it.
c.Emit(Instruction.DUP);
// The key.
c.ParsePrecedence(false, Precedence.PREC_PRIMARY);
c.Consume(TokenType.TOKEN_COLON, "Expect ':' after map key.");
// The value.
c.Expression();
c.CallMethod(2, "[_]=(_)");
// Discard the result of the setter call.
c.Emit(Instruction.POP);
} while (c.Match(TokenType.TOKEN_COMMA));
}
// Allow newlines before the closing '}'.
c.IgnoreNewlines();
c.Consume(TokenType.TOKEN_RIGHT_BRACE, "Expect '}' after map entries.");
}
// A list literal.
private static void List(Compiler c, bool allowAssignment)
{
// Load the List class.
int listClassSymbol = c.parser.module.Variables.FindIndex(v => v.Name == "List");
//ASSERT(listClassSymbol != -1, "Should have already defined 'List' variable.");
c.EmitShortArg(Instruction.LOAD_MODULE_VAR, listClassSymbol);
// Instantiate a new list.
c.CallMethod(0, "<instantiate>");
// Compile the list elements. Each one compiles to a ".add()" call.
if (c.Peek() != TokenType.TOKEN_RIGHT_BRACKET)
{
do
{
c.IgnoreNewlines();
// Push a copy of the list since the add() call will consume it.
c.Emit(Instruction.DUP);
// The element.
c.Expression();
c.CallMethod(1, "add(_)");
// Discard the result of the add() call.
c.Emit(Instruction.POP);
} while (c.Match(TokenType.TOKEN_COMMA));
}
// Allow newlines before the closing ']'.
c.IgnoreNewlines();
c.Consume(TokenType.TOKEN_RIGHT_BRACKET, "Expect ']' after list elements.");
}