115 lines
5.2 KiB
C++
115 lines
5.2 KiB
C++
/*
|
|
* Parsodus - A language agnostic parser generator
|
|
* Copyright © 2016-2017 Thomas Avé, Robin Jadoul, Kobe Wullaert
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "parser.h"
|
|
#include "instruction.h"
|
|
|
|
#include <iostream>
|
|
|
|
namespace bf {
|
|
|
|
Parser::Parser(BfLexer lex) :
|
|
bfParser<std::unique_ptr<std::deque<Instruction>>>(), m_lex(lex) {
|
|
}
|
|
|
|
Parser::Token Parser::lex() {
|
|
try {
|
|
|
|
BfLexer::Token orig = m_lex.nextToken();
|
|
std::deque<Instruction> pm;
|
|
switch(orig.type) {
|
|
case BfLexer::PLUS: {
|
|
pm.push_back(Instruction::PLUS);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found PLUS " << (int)Instruction::PLUS << std::endl;
|
|
return Token{ bfParser_Symbol::T_PLUS, std::move(p) };
|
|
} case BfLexer::MINUS: {
|
|
pm.push_back(Instruction::MINUS);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found MINUS" << (int)Instruction::MINUS << std::endl;
|
|
return Token{ bfParser_Symbol::T_MINUS, std::move(p) };
|
|
} case BfLexer::GREATER: {
|
|
pm.push_back(Instruction::GREATER);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found GREATER" << (int)Instruction::GREATER << std::endl;
|
|
return Token{ bfParser_Symbol::T_GREATER, std::move(p) };
|
|
} case BfLexer::LESS: {
|
|
pm.push_back(Instruction::LESS);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found LESS" << (int)Instruction::LESS << std::endl;
|
|
return Token{ bfParser_Symbol::T_LESS, std::move(p) };
|
|
} case BfLexer::POINT: {
|
|
pm.push_back(Instruction::POINT);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found POINT" << (int)Instruction::POINT << std::endl;
|
|
return Token{ bfParser_Symbol::T_POINT, std::move(p) };
|
|
} case BfLexer::COMMA: {
|
|
pm.push_back(Instruction::COMMA);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found COMMA" << (int)Instruction::COMMA << std::endl;
|
|
return Token{ bfParser_Symbol::T_COMMA, std::move(p) };
|
|
} case BfLexer::LBRACKET: {
|
|
pm.push_back(Instruction::LBRACKET);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found LBRACKET" << (int)Instruction::LBRACKET << std::endl;
|
|
return Token{ bfParser_Symbol::T_LBRACKET, std::move(p) };
|
|
} case BfLexer::RBRACKET: {
|
|
pm.push_back(Instruction::RBRACKET);
|
|
std::unique_ptr<std::deque<Instruction>> p = std::make_unique<std::deque<Instruction>>(pm);
|
|
//std::cout << "PARSING: found RBRACKET" << (int)Instruction::RBRACKET << std::endl;
|
|
return Token{ bfParser_Symbol::T_RBRACKET, std::move(p) };
|
|
}
|
|
}
|
|
} catch(BfLexer::NoMoreTokens) {
|
|
return Token{ bfParser_Symbol::T_EOF, nullptr };
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<std::deque<Instruction>> Parser::reduce_PROGRAM(std::deque<Token> subparts) {
|
|
// <program> ::= <instruction> <program>
|
|
if (subparts[1].value == nullptr)
|
|
return std::move(subparts[0].value);
|
|
for(auto& instr : *(subparts[1].value))
|
|
subparts[0].value->push_back(instr);
|
|
return std::move(subparts[0].value);
|
|
}
|
|
std::unique_ptr<std::deque<Instruction>> Parser::reduce_EMPTY(std::deque<Token> subparts) {
|
|
// <program> ::=
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<std::deque<Instruction>> Parser::reduce_OPERATION(std::deque<Token> subparts) {
|
|
// <instruction> ::= "PLUS" | "MINUS" | ... | "COMMA"
|
|
return std::move(subparts[0].value);
|
|
}
|
|
std::unique_ptr<std::deque<Instruction>> Parser::reduce_LOOP(std::deque<Token> subparts) {
|
|
// <instruction> ::= "LBRACKET" <program> "RBRACKET"
|
|
subparts[1].value->push_front(Instruction::LBRACKET);
|
|
subparts[1].value->push_back(Instruction::RBRACKET);
|
|
//std::cout << "PARSING: found LOOP" << std::endl;
|
|
//for(auto& s : *(subparts[1].value)) std::cout << "LOOP: " << (int)s << std::endl;
|
|
return std::move(subparts[1].value);
|
|
}
|
|
|
|
|
|
} // namespace bf
|