eparser.cpp

Go to the documentation of this file.

 
#include "eparser.h"
emthp::Lexer::Lexer(const std::string& input) noexcept : _input(this->clean(input)), _pos(0) {}
emthp::Lexer& emthp::Lexer::operator =(const emthp::Lexer& ogn) noexcept {
    this->_input = ogn._input;
    this->_pos = ogn._pos;
    return *this;
};
emthp::Token emthp::Lexer::next() noexcept {
    if (this->_pos >= this->_input.size()) {return {emthp::TokenType::T_EOF, {0}};} //Returs EOL on end of _input
    switch (this->_input[this->_pos]) {
        case '+': this->_pos++; return {emthp::TokenType::T_PLUS, {0}};
        case '-': this->_pos++; return {emthp::TokenType::T_MINUS, {0}};
        case '^': this->_pos++; return {emthp::TokenType::T_EXPONENT, {0}};
        case 'x': this->_pos++; return {emthp::TokenType::T_VARIABLE, {0}};
        case '*': case '/': this->_pos++; return next();
        default:
            double number = this->read_number();
            while(true) {
                switch (this->_input[this->_pos]) {
                    case '*': this->_pos++; number *= this->read_number(); break;
                    case '/': this->_pos++; number /= this->read_number(); break;
                    case '^': this->_pos++; number = std::pow(number, this->read_number()); break;
                    default: return {emthp::TokenType::T_NUMBER, {number}};
                }
            }
    }
}
void emthp::Lexer::back() noexcept {
    if (this->_pos <= 0) {return;} 
    if (emthp::Lexer::is_digit(this->_input[this->_pos-1])) {while (emthp::Lexer::is_digit(this->_input[this->_pos-1])) {this->_pos--;} return;}
    this->_pos--; return;
}
std::string emthp::Lexer::clean(const std::string& input) noexcept {
    long unsigned int pos = 0; std::string string;
    while (pos < input.size()) {
        switch (input[pos]) {
            case '+': string += '+'; break;
            case '-': string += '-'; break;
            case '*': string += '*'; break;
            case '/': string += '/'; break;
            case '^': string += '^'; break;
            case 'x': string += 'x'; break;
            default: if (emthp::Lexer::is_digit(input[pos])) {string += input[pos];} break;
        } pos++;
    }
    return string;
}
double emthp::Lexer::read_number() noexcept {
    std::string snum;
    while (this->_pos < this->_input.size() && emthp::Lexer::is_digit(this->_input[this->_pos])) {
        snum += this->_input[this->_pos];
        this->_pos++;
    }
    if (snum.empty()) {return 1;}
    return std::stod(snum);
}
emthp::Parser::Parser(const std::string& input) noexcept : _lexer(input) {};
emthp::Parser& emthp::Parser::operator =(const emthp::Parser& ogn) noexcept {this->_lexer = ogn._lexer; return *this;};
emth::Polynomial emthp::Parser::parse_polynomial() noexcept {
    emth::Polynomial polynomial;
    while (true) {if(!polynomial.push_monomial(std::move(this->parse_monomial()))) {return polynomial;}}
}
emth::Monomial emthp::Parser::parse_monomial() noexcept {
    emth::Monomial monomial(0, 0);
    monomial.set_coeff(this->parse_number());
    bool v = false; bool e = false;
    while (!v || !e) {
        emthp::Token token = this->_lexer.next();
        switch (token.type) {
            case emthp::TokenType::T_VARIABLE: v = true; break;
            case emthp::TokenType::T_EXPONENT: if (v) {e = true;} break;
            case emthp::TokenType::T_PLUS: case emthp::TokenType::T_MINUS: case emthp::TokenType::T_NUMBER: if (v) {monomial.set_degree(1); this->_lexer.back();} return monomial;
            case emthp::TokenType::T_EOF: if (v) {monomial.set_degree(1);} return monomial;
        }
    }
    monomial.set_degree((int) this->parse_number());
    return monomial;
}
double emthp::Parser::parse_number() noexcept {
    bool positive = true;
    while(true) {
        emthp::Token token = this->_lexer.next();
        switch(token.type) {
            case emthp::TokenType::T_MINUS: positive = !positive; break;
            case emthp::TokenType::T_NUMBER: return positive ? token.value : -token.value;
            case emthp::TokenType::T_VARIABLE: this->_lexer.back(); return positive ? 1 : -1;
            case emthp::TokenType::T_EOF: return 0;
        }
    }
}