745 lines
16 KiB
C++
745 lines
16 KiB
C++
#include "expression.hpp"
|
|
#include "parser.hpp"
|
|
#include "print.h"
|
|
#include "syntaxer.hpp"
|
|
#include <stack>
|
|
#include <vector>
|
|
|
|
namespace Syntax {
|
|
|
|
static void highlight_issue(const std::vector<Expression::Token>& tv, const int location)
|
|
{
|
|
int start = location - 7 < 0 ? 0 : location - 7;
|
|
int finish = location + 7 > tv.size() - 1 ? tv.size() - 1 : location + 7;
|
|
|
|
std::cout << " >>> ";
|
|
|
|
for (int i = start; i <= finish; i++)
|
|
{
|
|
if (i == location)
|
|
{
|
|
std::cout << "\033[31m" << *tv[i].to_math_str() << "\033[0m ";
|
|
}
|
|
else
|
|
{
|
|
std::cout << *tv[i].to_math_str() << " ";
|
|
}
|
|
}
|
|
|
|
std::cout << "\n";
|
|
}
|
|
|
|
int check_syntax(std::vector<Expression::Token>& tv)
|
|
{
|
|
int problem_cnt = 0;
|
|
|
|
// check token type sequence
|
|
{
|
|
for (int i = 0, l = tv.size() - 1, pc; pc = problem_cnt, i < l; i++)
|
|
{
|
|
switch (tv[i].t)
|
|
{
|
|
case Expression::Token::VAR:
|
|
case Expression::Token::CONST:
|
|
switch (tv[i+1].t)
|
|
{
|
|
case Expression::Token::OPERATOR:
|
|
switch (tv[i+1].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
pr_warn("Expected operator at token " << i << ", got opening bracket");
|
|
problem_cnt++;
|
|
break;
|
|
case Expression::Token::CPA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::VAR:
|
|
pr_warn("Expected operator at token " << i << ", got variable");
|
|
problem_cnt++;
|
|
break;
|
|
case Expression::Token::CONST:
|
|
pr_warn("Expected operator at token " << i << ", got constant");
|
|
problem_cnt++;
|
|
break;
|
|
default:
|
|
pr_warn("Impossible token type, this is a bug!");
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::OPERATOR:
|
|
switch (tv[i].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
switch (tv[i+1].t)
|
|
{
|
|
case Expression::Token::OPERATOR:
|
|
switch (tv[i+1].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
break;
|
|
case Expression::Token::CPA:
|
|
pr_warn("Expected value at token " << i << ", got closing bracket");
|
|
problem_cnt++;
|
|
break;
|
|
default:
|
|
pr_warn("Expected value at token " << i << ", got operator");
|
|
problem_cnt++;
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::CONST:
|
|
case Expression::Token::VAR:
|
|
break;
|
|
default:
|
|
pr_warn("Impossible token type, this is a bug!");
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::CPA:
|
|
switch (tv[i+1].t)
|
|
{
|
|
case Expression::Token::OPERATOR:
|
|
switch (tv[i+1].v.o)
|
|
{
|
|
case Expression::Token::CPA:
|
|
break;
|
|
case Expression::Token::OPA:
|
|
pr_warn("Expected operator at token " << i << ", got opening bracket");
|
|
problem_cnt++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::CONST:
|
|
pr_warn("Expected operator at token " << i << ", got constant");
|
|
problem_cnt++;
|
|
break;
|
|
case Expression::Token::VAR:
|
|
pr_warn("Expected operator at token " << i << ", got variable");
|
|
problem_cnt++;
|
|
break;
|
|
default:
|
|
pr_warn("Impossible token type, this is a bug!");
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
switch (tv[i+1].t)
|
|
{
|
|
case Expression::Token::OPERATOR:
|
|
switch (tv[i+1].v.o)
|
|
{
|
|
case Expression::Token::CPA:
|
|
pr_warn("Expected value at token " << i << ", got closing bracket");
|
|
problem_cnt++;
|
|
break;
|
|
case Expression::Token::OPA:
|
|
break;
|
|
default:
|
|
pr_warn("Expected value at token " << i << ", got operator");
|
|
problem_cnt++;
|
|
break;
|
|
}
|
|
break;
|
|
case Expression::Token::CONST:
|
|
break;
|
|
case Expression::Token::VAR:
|
|
break;
|
|
default:
|
|
pr_warn("Impossible token type, this is a bug!");
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
pr_warn("Impossible token type, this is a bug!");
|
|
break;
|
|
}
|
|
|
|
if (pc != problem_cnt)
|
|
{
|
|
highlight_issue(tv, i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// check bracket matching
|
|
{
|
|
std::stack<int> s;
|
|
|
|
for (int i = 0, l = tv.size(); i < l; i++)
|
|
{
|
|
if (tv[i].t == Expression::Token::OPERATOR)
|
|
{
|
|
switch (tv[i].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
s.push(i);
|
|
break;
|
|
case Expression::Token::CPA:
|
|
if (s.size())
|
|
{
|
|
s.pop();
|
|
}
|
|
else
|
|
{
|
|
pr_warn("Missing opening bracket at token " << i);
|
|
problem_cnt++;
|
|
highlight_issue(tv, i);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0, l = s.size(); i < l; i++)
|
|
{
|
|
problem_cnt++;
|
|
pr_warn("Opening bracket at token " << s.top() << " expected a closing bracket, but none found");
|
|
highlight_issue(tv, s.top());
|
|
s.pop();
|
|
}
|
|
}
|
|
|
|
return problem_cnt;
|
|
}
|
|
|
|
// get mop = Math OPerator location (=absolute index in std::vector<Expression::Token>)
|
|
// mapper of 'priority vector index' -> 'token vector index'
|
|
static int get_mop_location(const std::vector<Expression::Token>& v, int position)
|
|
{
|
|
int i = 0, l = v.size(), p = -1;
|
|
for (; p += v[i].t == Expression::Token::OPERATOR
|
|
&& v[i].v.o != Expression::Token::OPA
|
|
&& v[i].v.o != Expression::Token::CPA, p != position; i++);
|
|
return i;
|
|
}
|
|
|
|
static int get_left_location(const std::vector<Expression::Token>& v, int location)
|
|
{
|
|
for (int i = location - 1; i >= 0; i--)
|
|
{
|
|
if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int get_right_location(const std::vector<Expression::Token>& v, int location)
|
|
{
|
|
for (int i = location + 1, l = v.size(); i < l; i++)
|
|
{
|
|
if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int get_operator_weight(const std::vector<Expression::Token>& v, int location)
|
|
{
|
|
int weight = 0;
|
|
|
|
switch (const Expression::Token &p = v[get_left_location(v, location)]; p.t)
|
|
{
|
|
case Expression::Token::VAR:
|
|
case Expression::Token::CONST:
|
|
break;
|
|
case Expression::Token::CV:
|
|
weight += p.v.cv.w;
|
|
break;
|
|
default:
|
|
pr_warn("Invalid token found to the left of operator");
|
|
break;
|
|
}
|
|
|
|
switch (const Expression::Token &p = v[get_right_location(v, location)]; p.t)
|
|
{
|
|
case Expression::Token::VAR:
|
|
case Expression::Token::CONST:
|
|
break;
|
|
case Expression::Token::CV:
|
|
weight += p.v.cv.w;
|
|
break;
|
|
default:
|
|
pr_warn("Invalid token found to the left of operator");
|
|
break;
|
|
}
|
|
|
|
return weight;
|
|
}
|
|
|
|
static int get_min_index(const std::vector<int>& v)
|
|
{
|
|
int idx = 0;
|
|
|
|
for (int i = 1, l = v.size(); i < l; i++)
|
|
{
|
|
if (v[i] < v[idx])
|
|
{
|
|
idx = i;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
static int get_max_index(const std::vector<int>& v)
|
|
{
|
|
int idx = 0;
|
|
|
|
for (int i = 1, l = v.size(); i < l; i++)
|
|
{
|
|
if (v[i] > v[idx])
|
|
{
|
|
idx = i;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
static void write_operation(
|
|
std::vector<Expression::Operation>& ov,
|
|
const std::vector<Expression::Token>& tv,
|
|
std::vector<Expression::Token>& mv,
|
|
std::vector<int>& mp,
|
|
int position)
|
|
{
|
|
int location = get_mop_location(mv, position);
|
|
int left_location = get_left_location(mv, location);
|
|
int right_location = get_right_location(mv, location);
|
|
|
|
Expression::Token &o = mv[location],
|
|
&l = mv[left_location],
|
|
&r = mv[right_location];
|
|
|
|
int this_op_weight = get_operator_weight(mv, location) + 1;
|
|
|
|
int il = l.t == Expression::Token::CV ? l.v.cv.i : left_location;
|
|
int ir = r.t == Expression::Token::CV ? r.v.cv.i : right_location;
|
|
|
|
// write new operation
|
|
int this_ov_index = ov.size();
|
|
ov.emplace_back(o.v.o,
|
|
l.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
|
|
il,
|
|
r.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
|
|
ir,
|
|
this_op_weight);
|
|
|
|
// update mv
|
|
l.t = Expression::Token::NAT;
|
|
r.t = Expression::Token::NAT;
|
|
o.t = Expression::Token::CV;
|
|
o.v.cv.w = this_op_weight;
|
|
o.v.cv.i = this_ov_index;
|
|
|
|
// update mp
|
|
mp.erase(mp.begin() + position, mp.begin() + position + 1);
|
|
}
|
|
|
|
static void add_bracket_to(std::vector<Expression::Token>& tv, const int location, const int direction)
|
|
{
|
|
int i = location + direction, l = tv.size(), lv = 0;
|
|
|
|
if (direction == -1)
|
|
{
|
|
for (; i >= 0; i--)
|
|
{
|
|
if (tv[i].t == Expression::Token::OPERATOR)
|
|
{
|
|
switch (tv[i].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
lv--;
|
|
break;
|
|
case Expression::Token::CPA:
|
|
lv++;
|
|
break;
|
|
default:
|
|
if (!lv)
|
|
{
|
|
tv.insert(tv.begin() + i + 1, Expression::Token(Expression::Token::OPA));
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
tv.insert(tv.begin(), Expression::Token(Expression::Token::OPA));
|
|
}
|
|
else if (direction == 1)
|
|
{
|
|
for (; i < l; i++)
|
|
{
|
|
if (tv[i].t == Expression::Token::OPERATOR)
|
|
{
|
|
switch (tv[i].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
lv++;
|
|
break;
|
|
case Expression::Token::CPA:
|
|
lv--;
|
|
break;
|
|
default:
|
|
if (!lv)
|
|
{
|
|
tv.insert(tv.begin() + i, Expression::Token(Expression::Token::CPA));
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
tv.emplace_back(Expression::Token::CPA);
|
|
}
|
|
}
|
|
|
|
static void create_prios_vector(const std::vector<Expression::Token>& tv, std::vector<int>& pv)
|
|
{
|
|
for (int i = 0, cp = 0, l = tv.size(); i < l; i++)
|
|
{
|
|
if (tv[i].t == Expression::Token::OPERATOR)
|
|
{
|
|
switch (tv[i].v.o)
|
|
{
|
|
case Expression::Token::OPA:
|
|
cp++;
|
|
break;
|
|
case Expression::Token::CPA:
|
|
cp--;
|
|
break;
|
|
case Expression::Token::ADD:
|
|
case Expression::Token::SUB:
|
|
case Expression::Token::MUL:
|
|
case Expression::Token::DIV:
|
|
case Expression::Token::POW:
|
|
pv.emplace_back(cp);
|
|
break;
|
|
default:
|
|
pr_warn("Token vector has broken operator at " << i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void find_top_prio_op_range(const std::vector<int>& mp, int& start, int& finish)
|
|
{
|
|
for (int i = 0, l = mp.size(), prio = -1; i < l; i++)
|
|
{
|
|
if (mp[i] > prio)
|
|
{
|
|
prio = mp[i];
|
|
start = finish = i;
|
|
}
|
|
else if (mp[i] == prio && finish == i - 1)
|
|
{
|
|
finish = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Range
|
|
{
|
|
int start, finish;
|
|
|
|
Range(int start, int finish)
|
|
: start(start), finish(finish)
|
|
{
|
|
}
|
|
};
|
|
|
|
static void find_select_prio_op_ranges(const std::vector<int>& mp, std::vector<Range>& ranges, int target_prio)
|
|
{
|
|
for (int i = 0, l = mp.size(), prio = 0, recording_range = 0; i < l; i++)
|
|
{
|
|
if (mp[i] == target_prio && !recording_range)
|
|
{
|
|
recording_range = 1;
|
|
ranges.emplace_back(i, 0);
|
|
}
|
|
else if (mp[i] == target_prio && recording_range)
|
|
{
|
|
ranges.back().finish = i;
|
|
}
|
|
else if (mp[i] != target_prio && recording_range)
|
|
{
|
|
recording_range = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void rank_inner_ops_raw(std::vector<int>& inner_op_ranks, const std::vector<Expression::Token>& mv, const int start, const int finish)
|
|
{
|
|
for (int i = 0, lvl = 0; i < finish - start + 1; i++)
|
|
{
|
|
int idx = get_mop_location(mv, start + i);
|
|
|
|
switch (mv[idx].v.o)
|
|
{
|
|
case Expression::Token::ADD:
|
|
case Expression::Token::SUB:
|
|
inner_op_ranks.push_back(0);
|
|
break;
|
|
case Expression::Token::MUL:
|
|
case Expression::Token::DIV:
|
|
inner_op_ranks.push_back(1);
|
|
break;
|
|
case Expression::Token::POW:
|
|
inner_op_ranks.push_back(2);
|
|
break;
|
|
default:
|
|
pr_warn("Operator is unrankable");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void rank_inner_ops(std::vector<int>& inner_top_ops, const std::vector<Expression::Token>& mv, const int start, const int finish)
|
|
{
|
|
for (int i = 0, lvl = 0; i < finish - start + 1; i++)
|
|
{
|
|
int idx = get_mop_location(mv, start + i);
|
|
|
|
switch (mv[idx].v.o)
|
|
{
|
|
case Expression::Token::ADD:
|
|
case Expression::Token::SUB:
|
|
if (lvl == 0)
|
|
inner_top_ops.push_back(i);
|
|
|
|
break;
|
|
case Expression::Token::MUL:
|
|
case Expression::Token::DIV:
|
|
if (lvl < 1)
|
|
{
|
|
lvl = 1;
|
|
inner_top_ops.clear();
|
|
}
|
|
|
|
if (lvl == 1)
|
|
inner_top_ops.push_back(i);
|
|
|
|
break;
|
|
case Expression::Token::POW:
|
|
if (lvl < 2)
|
|
{
|
|
lvl = 2;
|
|
inner_top_ops.clear();
|
|
}
|
|
|
|
if (lvl == 2)
|
|
inner_top_ops.push_back(i);
|
|
|
|
break;
|
|
default:
|
|
pr_warn("Operator is unrankable");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void weight_operators(std::vector<int>& operator_weights, const std::vector<Expression::Token>& mv, const std::vector<int>& inner_top_ops, const int start)
|
|
{
|
|
for (int i = 0, l = inner_top_ops.size(); i < l; i++)
|
|
{
|
|
int operator_location = get_mop_location(mv, start + inner_top_ops[i]);
|
|
operator_weights.push_back(get_operator_weight(mv, operator_location));
|
|
}
|
|
}
|
|
|
|
void apply_corrections(std::vector<Expression::Token>& tv)
|
|
{
|
|
pr_debug("Starting with vector:");
|
|
Parser::print_math_vector(tv);
|
|
|
|
// global prio evaluation
|
|
std::vector<int> mp;
|
|
create_prios_vector(tv, mp);
|
|
|
|
if (mp.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int current_prio_level = mp[get_max_index(mp)]; current_prio_level >= 0; current_prio_level--)
|
|
{
|
|
// calculate how many ranges need to be processed at this level
|
|
std::vector<Range> rv;
|
|
find_select_prio_op_ranges(mp, rv, current_prio_level);
|
|
|
|
for (int current_range = rv.size() - 1; current_range >= 0; current_range--)
|
|
{
|
|
Range &outer_range = rv[current_range];
|
|
|
|
std::vector<int> inner_prios;
|
|
rank_inner_ops_raw(inner_prios, tv, outer_range.start, outer_range.finish);
|
|
|
|
for (int inner_prio = inner_prios[get_max_index(inner_prios)]; inner_prio >= 0; inner_prio--)
|
|
{
|
|
std::vector<Range> inner_ranges;
|
|
find_select_prio_op_ranges(inner_prios, inner_ranges, inner_prio);
|
|
|
|
for (int inner_range = inner_ranges.size() - 1; inner_range >= 0; inner_range--)
|
|
{
|
|
int corrections = 1;
|
|
|
|
Range &range = inner_ranges[inner_range];
|
|
while (corrections)
|
|
{
|
|
corrections = 0;
|
|
|
|
int same_op_cnt = -1;
|
|
for (int i = outer_range.start + range.start; i < outer_range.start + range.finish + 1; i++)
|
|
{
|
|
int loc = get_mop_location(tv, i);
|
|
Expression::Token& tok = tv[loc];
|
|
|
|
if (tok.v.o == Expression::Token::SUB || tok.v.o == Expression::Token::DIV)
|
|
{
|
|
same_op_cnt++;
|
|
|
|
if (same_op_cnt == 2)
|
|
{
|
|
same_op_cnt = 0;
|
|
|
|
corrections++;
|
|
|
|
switch (tok.v.o)
|
|
{
|
|
case Expression::Token::SUB:
|
|
tok.v.o = Expression::Token::ADD;
|
|
break;
|
|
case Expression::Token::DIV:
|
|
tok.v.o = Expression::Token::MUL;
|
|
break;
|
|
default:
|
|
pr_warn("Impossible operator in this branch, this is a bug!");
|
|
break;
|
|
}
|
|
|
|
// inverse order to keep location valid between calls
|
|
add_bracket_to(tv, loc, 1);
|
|
add_bracket_to(tv, loc, -1);
|
|
|
|
pr_debug("Updated vector:");
|
|
Parser::print_math_vector(tv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv)
|
|
{
|
|
// define operator precedency
|
|
std::vector<int> g_prios;
|
|
create_prios_vector(tv, g_prios);
|
|
|
|
for (int i = 0, l = g_prios.size(); i < l; i++)
|
|
{
|
|
pr_debug("prio=" << g_prios[i]);
|
|
}
|
|
|
|
// build operation vector
|
|
std::vector<Expression::Operation> ov;
|
|
{
|
|
std::vector<Expression::Token> mv = tv;
|
|
std::vector<int> mp = g_prios;
|
|
|
|
while (mp.size())
|
|
{
|
|
int start, finish;
|
|
find_top_prio_op_range(mp, start, finish);
|
|
|
|
// --- process current range ---
|
|
while (start != finish)
|
|
{
|
|
std::vector<int> inner_top_ops;
|
|
rank_inner_ops(inner_top_ops, mv, start, finish);
|
|
|
|
std::vector<int> operator_weights;
|
|
weight_operators(operator_weights, mv, inner_top_ops, start);
|
|
|
|
write_operation(ov, tv, mv, mp, start + inner_top_ops[get_min_index(operator_weights)]);
|
|
finish--;
|
|
}
|
|
|
|
// process final operation w/out running selection algorithm
|
|
write_operation(ov, tv, mv, mp, start);
|
|
}
|
|
}
|
|
|
|
for (int i = 0, l = ov.size(); i < l; i++)
|
|
{
|
|
const Expression::Operation &o = ov[i];
|
|
|
|
prs_debug("OP: ");
|
|
|
|
if (o.tl == Expression::Operation::NORMAL)
|
|
{
|
|
const Expression::Token &real_value = tv[o.il];
|
|
|
|
if (real_value.t == Expression::Token::VAR)
|
|
{
|
|
pri_debug(*real_value.v.s);
|
|
}
|
|
else
|
|
{
|
|
pri_debug(real_value.v.d);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pri_debug("t" << o.il);
|
|
}
|
|
|
|
pri_debug(" " << o.o.op_math_str() << " ");
|
|
|
|
if (o.tr == Expression::Operation::NORMAL)
|
|
{
|
|
const Expression::Token &real_value = tv[o.ir];
|
|
|
|
if (real_value.t == Expression::Token::VAR)
|
|
{
|
|
pri_debug(*real_value.v.s);
|
|
}
|
|
else
|
|
{
|
|
pri_debug(real_value.v.d);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pri_debug("t" << o.ir);
|
|
}
|
|
|
|
pri_debug(" = t" << i << "\n");
|
|
}
|
|
|
|
return ov;
|
|
}
|
|
|
|
}
|