-/*
- * Parser.cpp
- *
- * Created on: Aug 26, 2012
- * Author: holy
- */
-
#include "Parser.h"
+#include "utility.h"
+
#include <auto_ptr.h>
#include <fstream>
using std::string;
using std::vector;
+typedef loader::Tokenizer::Token Token;
+
namespace loader {
+Parser::Parser(const string &file, ParsedSource &product)
+: file(file)
+, dirname(Dirname(file))
+, in(this->file.c_str())
+, tok(in)
+, product(product) {
+ if (!in) {
+ throw Error(file, 0, "unable to read file");
+ }
+}
+
void Parser::Parse() {
while (tok.HasMore()) {
ParseStatement();
}
void Parser::ParseStatement() {
- Tokenizer::Token t(tok.GetNext());
+ Token t(GetToken());
switch (t.type) {
- case Tokenizer::Token::KEYWORD_EXPORT:
+ case Token::KEYWORD_EXPORT:
ParseExportDirective();
break;
- case Tokenizer::Token::KEYWORD_INCLUDE:
+ case Token::KEYWORD_INCLUDE:
ParseIncludeDirective();
break;
- case Tokenizer::Token::TYPE_NAME:
+ case Token::TYPE_NAME:
tok.Putback(t);
{
Declaration *decl(ProbeDefinition());
}
break;
default:
- throw ParseError(string("unexpected token ") + TokenTypeToString(t.type));
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type));
}
}
+Token Parser::GetToken() try {
+ return tok.GetNext();
+} catch (Tokenizer::LexerError &e) {
+ throw Error(file, e.Line(), e.what());
+}
+
void Parser::ParseExportDirective() {
- Tokenizer::Token t(tok.GetNext());
- if (t.type != Tokenizer::Token::IDENTIFIER) {
+ Token t(GetToken());
+ if (t.type != Token::IDENTIFIER) {
tok.Putback(t);
Declaration *decl(ProbeDefinition());
product.ExportDeclaration(decl);
}
void Parser::ParseIncludeDirective() {
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::STRING);
- ifstream file(t.str.c_str()); // TODO: resolve path name
- Parser sub(file, product);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::STRING);
+ Parser sub(CatPath(dirname, t.str), product);
sub.Parse();
}
string typeName(ParseTypeName());
string identifier(ParseIdentifier());
- Tokenizer::Token t(tok.GetNext());
- tok.Putback(t);
- if (BeginOfPropertyList(t)) {
- PropertyList *propertyList(ParsePropertyList());
- Definition *dfn(new Definition(typeName, identifier));
- dfn->SetValue(propertyList);
- return dfn;
- } else if (BeginningOfLiteral(t)) {
- Literal *literal(ParseLiteral());
- Definition *dfn(new Definition(typeName, identifier));
- dfn->SetValue(literal);
- return dfn;
- } else {
- return new Declaration(typeName, identifier);
+ if (tok.HasMore()) {
+ Token t(GetToken());
+ tok.Putback(t);
+ if (BeginOfPropertyList(t)) {
+ auto_ptr<PropertyList> propertyList(ParsePropertyList());
+ auto_ptr<Definition> dfn(new Definition(typeName, identifier));
+ dfn->SetValue(propertyList.release());
+ product.AddDefinition(dfn.get());
+ return dfn.release();
+ } else if (BeginningOfPrimitiveLiteral(t)) {
+ auto_ptr<Literal> literal(ParseLiteral());
+ auto_ptr<Definition> dfn(new Definition(typeName, identifier));
+ dfn->SetValue(literal.release());
+ product.AddDefinition(dfn.get());
+ return dfn.release();
+ }
+ }
+ return new Declaration(typeName, identifier);
+}
+
+bool Parser::BeginningOfLiteral(const Token &t) const {
+ switch (t.type) {
+ case Token::CHEVRON_OPEN:
+ case Token::COLON:
+ case Token::BRACKET_OPEN:
+ case Token::PARENTHESIS_OPEN:
+ case Token::NUMBER:
+ case Token::SCRIPT_BEGIN:
+ case Token::STRING:
+ case Token::KEYWORD_FALSE:
+ case Token::KEYWORD_TRUE:
+ case Token::TYPE_NAME:
+ return true;
+ default:
+ return false;
}
}
-bool Parser::BeginningOfLiteral(const Tokenizer::Token &t) const {
+bool Parser::BeginningOfPrimitiveLiteral(const Token &t) const {
switch (t.type) {
- case Tokenizer::Token::CHEVRON_OPEN:
- case Tokenizer::Token::BRACKET_OPEN:
- case Tokenizer::Token::PARENTHESIS_OPEN:
- case Tokenizer::Token::NUMBER:
- case Tokenizer::Token::STRING:
- case Tokenizer::Token::KEYWORD_FALSE:
- case Tokenizer::Token::KEYWORD_TRUE:
- case Tokenizer::Token::TYPE_NAME:
+ case Token::CHEVRON_OPEN:
+ case Token::COLON:
+ case Token::BRACKET_OPEN:
+ case Token::PARENTHESIS_OPEN:
+ case Token::NUMBER:
+ case Token::STRING:
+ case Token::KEYWORD_FALSE:
+ case Token::KEYWORD_TRUE:
return true;
default:
return false;
}
}
-bool Parser::BeginOfPropertyList(const Tokenizer::Token &t) const {
- return t.type == Tokenizer::Token::ANGLE_BRACKET_OPEN;
+bool Parser::BeginOfPropertyList(const Token &t) const {
+ return t.type == Token::ANGLE_BRACKET_OPEN;
+}
+
+bool Parser::BeginningOfScriptLiteral(const Token &t) const {
+ return t.type == Token::SCRIPT_BEGIN;
}
Definition *Parser::ParseDefinition() {
string typeName(ParseTypeName());
string identifier(ParseIdentifier());
- Tokenizer::Token t(tok.GetNext());
+ Token t(GetToken());
tok.Putback(t);
if (BeginOfPropertyList(t)) {
PropertyList *propertyList(ParsePropertyList());
dfn->SetValue(literal);
return dfn;
} else {
- throw ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected property-list or literal");
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected property-list or literal");
}
}
string Parser::ParseIdentifier() {
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::IDENTIFIER);
return t.str;
}
string Parser::ParseTypeName() {
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::TYPE_NAME);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::TYPE_NAME);
return t.str;
}
PropertyList *Parser::ParsePropertyList() {
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::ANGLE_BRACKET_OPEN);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::ANGLE_BRACKET_OPEN);
auto_ptr<PropertyList> props(new PropertyList);
- while (t.type != Tokenizer::Token::ANGLE_BRACKET_CLOSE) {
- Tokenizer::Token name(tok.GetNext());
- AssertTokenType(name.type, Tokenizer::Token::IDENTIFIER);
+ while (t.type != Token::ANGLE_BRACKET_CLOSE) {
+ Token name(GetToken());
+ AssertTokenType(name.type, Token::IDENTIFIER);
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::COLON);
+ t = GetToken();
+ AssertTokenType(t.type, Token::COLON);
Value *value(ParseValue());
props->SetProperty(name.str, value);
- t = tok.GetNext();
- if (t.type != Tokenizer::Token::ANGLE_BRACKET_CLOSE && t.type != Tokenizer::Token::COMMA) {
- throw ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or }");
+ t = GetToken();
+ if (t.type != Token::ANGLE_BRACKET_CLOSE && t.type != Token::COMMA) {
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or }");
}
}
}
Value *Parser::ParseValue() {
- Tokenizer::Token t(tok.GetNext());
- if (t.type == Tokenizer::Token::IDENTIFIER) {
+ Token t(GetToken());
+ if (t.type == Token::IDENTIFIER) {
return new Value(t.str);
} else if (BeginningOfLiteral(t)) {
tok.Putback(t);
Literal *literal(ParseLiteral());
return new Value(literal);
} else {
- throw new ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected literal or identifier");
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected literal or identifier");
}
}
Literal *Parser::ParseLiteral() {
- Tokenizer::Token t(tok.GetNext());
- if (t.type == Tokenizer::Token::TYPE_NAME) {
+ Token t(GetToken());
+ if (t.type == Token::TYPE_NAME) {
PropertyList *props(ParsePropertyList());
return new Literal(t.str, props);
- } else if (BeginningOfLiteral(t)) {
+ } else if (BeginningOfScriptLiteral(t)) {
+ tok.Putback(t);
+ return ParseScript();
+ } else if (BeginningOfPrimitiveLiteral(t)) {
switch (t.type) {
- case Tokenizer::Token::CHEVRON_OPEN:
+ case Token::CHEVRON_OPEN:
tok.Putback(t);
return ParseVector();
- case Tokenizer::Token::BRACKET_OPEN:
+ case Token::COLON:
+ t = GetToken();
+ AssertTokenType(t.type, Token::STRING);
+ return new Literal(dirname, t.str);
+ case Token::BRACKET_OPEN:
tok.Putback(t);
return ParseArray();
- case Tokenizer::Token::PARENTHESIS_OPEN:
+ case Token::PARENTHESIS_OPEN:
tok.Putback(t);
return ParseColor();
- case Tokenizer::Token::NUMBER:
+ case Token::NUMBER:
return new Literal(t.number);
- case Tokenizer::Token::STRING:
+ case Token::STRING:
return new Literal(t.str);
- case Tokenizer::Token::KEYWORD_FALSE:
+ case Token::KEYWORD_FALSE:
return new Literal(false);
- case Tokenizer::Token::KEYWORD_TRUE:
+ case Token::KEYWORD_TRUE:
return new Literal(true);
default:
throw std::logic_error("literal switch reached impossible default branch oO");
}
} else {
- throw new ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected type-name or primitive");
+ throw new Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected type-name or primitive");
}
}
Literal *Parser::ParseArray() {
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::BRACKET_OPEN);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::BRACKET_OPEN);
- vector<Value *> values;
+ Token probe(GetToken());
- while (t.type != Tokenizer::Token::ANGLE_BRACKET_CLOSE) {
- Value *value(ParseValue());
- values.push_back(value);
+ if (probe.type == Token::TYPE_NAME) {
+ vector<PropertyList *> values;
+ while (t.type != Token::BRACKET_CLOSE) {
+ PropertyList *value(ParsePropertyList());
+ values.push_back(value);
- t = tok.GetNext();
- if (t.type != Tokenizer::Token::BRACKET_CLOSE && t.type != Tokenizer::Token::COMMA) {
- throw ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+ t = GetToken();
+ if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+ }
}
- }
+ return new Literal(probe.str, values);
+ } else {
+ tok.Putback(probe);
+
+ vector<Value *> values;
+ while (t.type != Token::BRACKET_CLOSE) {
+ Value *value(ParseValue());
+ values.push_back(value);
- return new Literal(values);
+ t = GetToken();
+ if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+ }
+ }
+ return new Literal(values);
+ }
}
Literal *Parser::ParseColor() {
string msg("error parsing color");
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::PARENTHESIS_OPEN, msg);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::PARENTHESIS_OPEN, msg);
- Tokenizer::Token red(tok.GetNext());
- AssertTokenType(red.type, Tokenizer::Token::NUMBER, "error parsing red component of color");
+ Token red(GetToken());
+ AssertTokenType(red.type, Token::NUMBER, "error parsing red component of color");
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+ t = GetToken();
+ AssertTokenType(t.type, Token::COMMA, msg);
- Tokenizer::Token green(tok.GetNext());
- AssertTokenType(green.type, Tokenizer::Token::NUMBER, "error parsing green component of color");
+ Token green(GetToken());
+ AssertTokenType(green.type, Token::NUMBER, "error parsing green component of color");
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+ t = GetToken();
+ AssertTokenType(t.type, Token::COMMA, msg);
- Tokenizer::Token blue(tok.GetNext());
- AssertTokenType(blue.type, Tokenizer::Token::NUMBER, "error parsing blue component of color");
+ Token blue(GetToken());
+ AssertTokenType(blue.type, Token::NUMBER, "error parsing blue component of color");
- t = tok.GetNext();
- if (t.type == Tokenizer::Token::BRACKET_CLOSE) {
+ t = GetToken();
+ if (t.type == Token::PARENTHESIS_CLOSE) {
return new Literal(red.number, green.number, blue.number);
- } else if (t.type != Tokenizer::Token::COMMA) {
- Tokenizer::Token alpha(tok.GetNext());
- AssertTokenType(alpha.type, Tokenizer::Token::NUMBER, "error parsing alpha component of color");
+ } else if (t.type != Token::COMMA) {
+ Token alpha(GetToken());
+ AssertTokenType(alpha.type, Token::NUMBER, "error parsing alpha component of color");
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::PARENTHESIS_CLOSE, msg);
+ t = GetToken();
+ AssertTokenType(t.type, Token::PARENTHESIS_CLOSE, msg);
return new Literal(red.number, green.number, blue.number, alpha.number);
} else {
- throw ParseError(string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
}
}
Literal *Parser::ParseVector() {
std::string msg("error parsing vector");
- Tokenizer::Token t(tok.GetNext());
- AssertTokenType(t.type, Tokenizer::Token::CHEVRON_OPEN, msg);
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::CHEVRON_OPEN, msg);
- Tokenizer::Token x(tok.GetNext());
- AssertTokenType(x.type, Tokenizer::Token::NUMBER, "error parsing x component of vector");
+ Token x(GetToken());
+ AssertTokenType(x.type, Token::NUMBER, "error parsing x component of vector");
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+ t = GetToken();
+ AssertTokenType(t.type, Token::COMMA, msg);
- Tokenizer::Token y(tok.GetNext());
- AssertTokenType(y.type, Tokenizer::Token::NUMBER, "error parsing y component of vector");
+ Token y(GetToken());
+ AssertTokenType(y.type, Token::NUMBER, "error parsing y component of vector");
- t = tok.GetNext();
- AssertTokenType(t.type, Tokenizer::Token::CHEVRON_CLOSE, msg);
+ t = GetToken();
+ AssertTokenType(t.type, Token::CHEVRON_CLOSE, msg);
return new Literal(x.number, y.number);
}
-void Parser::AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected) {
+Literal *Parser::ParseScript() {
+ std::string msg("error parsing script");
+ Token t(GetToken());
+ AssertTokenType(t.type, Token::SCRIPT_BEGIN, msg);
+
+ t = GetToken();
+ vector<ScriptToken *> script;
+ try {
+ while (t.type != Token::SCRIPT_END) {
+ if (BeginningOfPrimitiveLiteral(t)) {
+ tok.Putback(t);
+ script.push_back(new ScriptToken(ParseLiteral()));
+ } else {
+ switch (t.type) {
+ case Token::COMMAND: {
+ Token t2(GetToken());
+ AssertTokenType(t2.type, Token::IDENTIFIER, msg);
+ script.push_back(new ScriptToken(t2.str, ScriptToken::COMMAND));
+ break;
+ }
+ case Token::IDENTIFIER: {
+ Token t2(GetToken());
+ if (t2.type == Token::COLON) {
+ script.push_back(new ScriptToken(t.str, ScriptToken::LABEL));
+ } else {
+ tok.Putback(t2);
+ script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+ }
+ break;
+ }
+ case Token::REGISTER: {
+ Token t2(GetToken());
+ AssertTokenType(t2.type, Token::IDENTIFIER, msg);
+ script.push_back(new ScriptToken(t2.str, ScriptToken::REGISTER));
+ break;
+ }
+ default:
+ throw Error(file, tok.Line(), string("unexpected token in script: ") + TokenTypeToString(t.type));
+ }
+ }
+ t = GetToken();
+ }
+ } catch (...) {
+ for (vector<ScriptToken *>::const_iterator i(script.begin()), end(script.end()); i != end; ++i) {
+ delete *i;
+ }
+ throw;
+ }
+ return new Literal(script);
+}
+
+
+void Parser::AssertTokenType(Token::Type actual, Token::Type expected) {
if (expected != actual) {
- throw ParseError(string("unexpected token ") + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
+ throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
}
}
-void Parser::AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected, const string &msg) {
+void Parser::AssertTokenType(Token::Type actual, Token::Type expected, const string &msg) {
if (expected != actual) {
- throw ParseError(msg + ": unexpected token " + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
+ throw Error(file, tok.Line(), msg + ": unexpected token " + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
}
}
projects / l2e.git / blobdiff