2022-10-17 22:26:36 -03:00
|
|
|
#include "ast/call_expression_ast.h"
|
|
|
|
#include "ast/number_expression_ast.h"
|
|
|
|
#include "ast/variable_expression_ast.h"
|
|
|
|
#include "parser.h"
|
|
|
|
|
2022-11-04 11:19:53 -03:00
|
|
|
#include <memory>
|
2022-11-08 22:27:26 -03:00
|
|
|
#include <stack>
|
2022-11-22 11:34:07 -03:00
|
|
|
#include <string>
|
2022-11-08 22:27:26 -03:00
|
|
|
#include <vector>
|
|
|
|
|
2022-10-17 22:26:36 -03:00
|
|
|
obelisk::Parser::Parser()
|
|
|
|
{
|
2022-11-04 11:19:53 -03:00
|
|
|
lexer_ = std::unique_ptr<obelisk::Lexer> {new obelisk::Lexer()};
|
2022-10-17 22:26:36 -03:00
|
|
|
}
|
|
|
|
|
2022-11-04 11:19:53 -03:00
|
|
|
std::unique_ptr<obelisk::Lexer>& obelisk::Parser::getLexer()
|
2022-10-17 22:26:36 -03:00
|
|
|
{
|
|
|
|
return lexer_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int obelisk::Parser::getNextToken()
|
|
|
|
{
|
|
|
|
setCurrentToken(getLexer()->getToken());
|
|
|
|
return getCurrentToken();
|
|
|
|
}
|
|
|
|
|
|
|
|
int obelisk::Parser::getCurrentToken()
|
|
|
|
{
|
|
|
|
return currentToken_;
|
|
|
|
}
|
|
|
|
|
|
|
|
void obelisk::Parser::setCurrentToken(int currentToken)
|
|
|
|
{
|
|
|
|
currentToken_ = currentToken;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::logError(
|
|
|
|
const char* str)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Error: %s\n", str);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::PrototypeAST> obelisk::Parser::logErrorPrototype(
|
|
|
|
const char* str)
|
|
|
|
{
|
|
|
|
logError(str);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parseExpression()
|
|
|
|
{
|
|
|
|
auto LHS = parsePrimary();
|
|
|
|
if (!LHS)
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return LHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parsePrimary()
|
|
|
|
{
|
|
|
|
switch (getCurrentToken())
|
|
|
|
{
|
|
|
|
case obelisk::Lexer::kTokenIdentifier :
|
|
|
|
return parseIdentifierExpression();
|
|
|
|
case obelisk::Lexer::kTokenNumber :
|
|
|
|
return parseNumberExpression();
|
|
|
|
case '(' :
|
|
|
|
return parseParenthesisExpression();
|
|
|
|
default :
|
|
|
|
return logError("unknown token when expecting and expression");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parseNumberExpression()
|
|
|
|
{
|
|
|
|
auto result = std::make_unique<obelisk::NumberExpressionAST>(
|
|
|
|
getLexer()->getNumberValue());
|
|
|
|
getNextToken();
|
2022-11-04 11:19:53 -03:00
|
|
|
return result;
|
2022-10-17 22:26:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST>
|
|
|
|
obelisk::Parser::parseParenthesisExpression()
|
|
|
|
{
|
|
|
|
getNextToken();
|
|
|
|
auto v = parseExpression();
|
|
|
|
if (!v)
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getCurrentToken() != ')')
|
|
|
|
{
|
|
|
|
return logError("expected ')'");
|
|
|
|
}
|
|
|
|
getNextToken();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST>
|
|
|
|
obelisk::Parser::parseIdentifierExpression()
|
|
|
|
{
|
|
|
|
std::string idName = getLexer()->getIdentifier();
|
|
|
|
getNextToken();
|
|
|
|
if (getCurrentToken() != '(')
|
|
|
|
{
|
|
|
|
return std::make_unique<obelisk::VariableExpressionAST>(idName);
|
|
|
|
}
|
|
|
|
|
|
|
|
getNextToken();
|
|
|
|
std::vector<std::unique_ptr<obelisk::ExpressionAST>> args;
|
|
|
|
if (getCurrentToken() != ')')
|
|
|
|
{
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
if (auto arg = parseExpression())
|
|
|
|
{
|
|
|
|
args.push_back(std::move(arg));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getCurrentToken() == ')')
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getCurrentToken() != ',')
|
|
|
|
{
|
|
|
|
return logError("Expected ')' or ',' in argument list");
|
|
|
|
}
|
|
|
|
|
|
|
|
getNextToken();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
getNextToken();
|
|
|
|
return std::make_unique<CallExpressionAST>(idName, std::move(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::PrototypeAST> obelisk::Parser::parsePrototype()
|
|
|
|
{
|
|
|
|
if (getCurrentToken() != obelisk::Lexer::kTokenIdentifier)
|
|
|
|
{
|
|
|
|
return logErrorPrototype("Expected function name in prototype");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string functionName = getLexer()->getIdentifier();
|
|
|
|
getNextToken();
|
|
|
|
|
|
|
|
if (getCurrentToken() != '(')
|
|
|
|
{
|
|
|
|
return logErrorPrototype("Expected '(' in prototype");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> argNames;
|
|
|
|
while (getNextToken() == obelisk::Lexer::kTokenIdentifier)
|
|
|
|
{
|
|
|
|
argNames.push_back(getLexer()->getIdentifier());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getCurrentToken() != ')')
|
|
|
|
{
|
|
|
|
return logErrorPrototype("Expected ')' in prototype");
|
|
|
|
}
|
|
|
|
|
|
|
|
getNextToken();
|
|
|
|
|
|
|
|
return std::make_unique<obelisk::PrototypeAST>(functionName,
|
|
|
|
std::move(argNames));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::FunctionAST> obelisk::Parser::parseDefinition()
|
|
|
|
{
|
|
|
|
getNextToken();
|
|
|
|
auto prototype = parsePrototype();
|
|
|
|
if (!prototype)
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (auto expression = parseExpression())
|
|
|
|
{
|
|
|
|
return std::make_unique<FunctionAST>(std::move(prototype),
|
|
|
|
std::move(expression));
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::FunctionAST> obelisk::Parser::parseTopLevelExpression()
|
|
|
|
{
|
|
|
|
if (auto expression = parseExpression())
|
|
|
|
{
|
|
|
|
// Make an anonymous prototype
|
|
|
|
auto prototype = std::make_unique<obelisk::PrototypeAST>("__anon_expr",
|
|
|
|
std::vector<std::string>());
|
|
|
|
return std::make_unique<obelisk::FunctionAST>(std::move(prototype),
|
|
|
|
std::move(expression));
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::PrototypeAST> obelisk::Parser::parseExtern()
|
|
|
|
{
|
|
|
|
getNextToken();
|
|
|
|
return parsePrototype();
|
|
|
|
}
|
2022-11-08 22:27:26 -03:00
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parseAction()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parseRule()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// fact("chris cromer" and "martin" and "Isabella" can "program" and "speak english");
|
|
|
|
// fact("" and "martin")
|
|
|
|
std::unique_ptr<obelisk::ExpressionAST> obelisk::Parser::parseFact()
|
|
|
|
{
|
|
|
|
std::stack<char> syntax;
|
|
|
|
|
|
|
|
getNextToken();
|
|
|
|
if (getCurrentToken() != '(')
|
|
|
|
{
|
2022-11-22 11:34:07 -03:00
|
|
|
throw obelisk::ParserException(
|
|
|
|
"expected '(' but got '" + std::to_string(getCurrentToken()) + "'");
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
syntax.push('(');
|
|
|
|
|
|
|
|
// ("
|
|
|
|
|
|
|
|
bool getEntity {true};
|
|
|
|
std::vector<std::string> leftEntities;
|
2022-11-09 16:49:58 -03:00
|
|
|
std::vector<std::string> rightEntities;
|
2022-11-08 22:27:26 -03:00
|
|
|
std::string entityName {""};
|
2022-11-09 16:49:58 -03:00
|
|
|
std::string verb {""};
|
2022-11-08 22:27:26 -03:00
|
|
|
getNextToken();
|
|
|
|
while (true) //left side of fact
|
|
|
|
{
|
|
|
|
if (getEntity)
|
|
|
|
{
|
|
|
|
if (getCurrentToken() == '"')
|
|
|
|
{
|
|
|
|
if (syntax.top() != '"')
|
|
|
|
{
|
|
|
|
// open a double quote
|
|
|
|
syntax.push('"');
|
2022-11-09 16:49:58 -03:00
|
|
|
getNextToken();
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|
|
|
|
else if (syntax.top() == '"')
|
|
|
|
{
|
|
|
|
// close a double quote
|
|
|
|
syntax.pop();
|
2022-11-09 16:49:58 -03:00
|
|
|
if (verb == "")
|
|
|
|
{
|
|
|
|
leftEntities.push_back(entityName);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
rightEntities.push_back(entityName);
|
|
|
|
}
|
2022-11-08 22:27:26 -03:00
|
|
|
entityName = "";
|
2022-11-09 16:49:58 -03:00
|
|
|
getEntity = false;
|
|
|
|
getNextToken();
|
|
|
|
continue;
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (syntax.top() == '"')
|
|
|
|
{
|
|
|
|
if (entityName != "")
|
|
|
|
{
|
|
|
|
entityName += " ";
|
|
|
|
}
|
|
|
|
entityName += getLexer()->getIdentifier();
|
|
|
|
}
|
|
|
|
getNextToken();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-11-09 16:49:58 -03:00
|
|
|
if (getCurrentToken() == ')')
|
|
|
|
{
|
2022-11-22 11:34:07 -03:00
|
|
|
// closing parenthesis found, make sure we have everything needed
|
|
|
|
if (verb == "")
|
|
|
|
{
|
|
|
|
throw obelisk::ParserException("verb is empty");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (leftEntities.size() == 0)
|
|
|
|
{
|
|
|
|
throw obelisk::ParserException(
|
|
|
|
"missing left side entities");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rightEntities.size() == 0)
|
|
|
|
{
|
|
|
|
throw obelisk::ParserException(
|
|
|
|
"missing right side entities");
|
|
|
|
}
|
2022-11-09 16:49:58 -03:00
|
|
|
break;
|
|
|
|
}
|
2022-11-08 22:27:26 -03:00
|
|
|
|
2022-11-09 16:49:58 -03:00
|
|
|
if (getCurrentToken() == '"')
|
|
|
|
{
|
2022-11-22 11:34:07 -03:00
|
|
|
throw obelisk::ParserException("unexpected '\"'");
|
2022-11-09 16:49:58 -03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getLexer()->getIdentifier() == "and")
|
|
|
|
{
|
|
|
|
getNextToken();
|
|
|
|
getEntity = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
verb = getLexer()->getIdentifier();
|
|
|
|
getEntity = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|
2022-11-09 16:49:58 -03:00
|
|
|
|
|
|
|
return nullptr;
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|
|
|
|
|
2022-11-09 16:49:58 -03:00
|
|
|
void obelisk::Parser::handleAction()
|
2022-11-08 22:27:26 -03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-11-09 16:49:58 -03:00
|
|
|
void obelisk::Parser::handleRule()
|
2022-11-08 22:27:26 -03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-11-09 16:49:58 -03:00
|
|
|
void obelisk::Parser::handleFact()
|
2022-11-08 22:27:26 -03:00
|
|
|
{
|
2022-11-09 16:49:58 -03:00
|
|
|
parseFact();
|
2022-11-08 22:27:26 -03:00
|
|
|
}
|