hasslesstech/pzks-labs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
hasslesstech
2026-10-02 20:31:24 +03:00
commit 2999c295af
9 changed files with 641 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/parser.cpp
+312
View File
@@ -0,0 +1,312 @@
#include <iostream>
#include <cctype>
#include <cstring>
#include <memory>
#include <vector>
#include "expression.hpp"
#include "print.h"
namespace Parser {
class Parser
{
enum State {
I, // idle
RC, // read constant
RV, // read variable
OP, // read operator
} s;
const char *state_str(enum State e)
{
switch (e)
{
case I:
return "I";
case RC:
return "RC";
case RV:
return "RV";
case OP:
return "OP";
default:
return "Not a valid state!";
}
}
void switch_state(enum State e)
{
pr_debug("Leaving " << state_str(s) << ", entering " << state_str(e));
switch (s)
{
case I:
leave_i();
break;
case RC:
leave_rc();
break;
case RV:
leave_rv();
break;
case OP:
leave_op();
break;
default:
pr_warn("Warning: broken state machine on leave");
break;
}
switch (e)
{
case I:
enter_i();
break;
case RC:
enter_rc();
break;
case RV:
enter_rv();
break;
case OP:
enter_op();
break;
default:
pr_warn("Warning: broken state machine on enter");
break;
}
s = e;
}
public:
char buffer[256];
std::shared_ptr<std::vector<Expression::Token>>& pv;
Parser(std::shared_ptr<std::vector<Expression::Token>>& pv)
: s(I), pv(pv)
{
buf_clear();
}
void buf_clear(void)
{
memset(buffer, 0, 256);
}
void buf_push(char c)
{
buffer[strlen(buffer)] = c;
}
int dispatch_to_current(char c)
{
switch (s)
{
case I:
return parse_i(c);
case RC:
return parse_rc(c);
case RV:
return parse_rv(c);
case OP:
return parse_op(c);
default:
pr_warn("State machine is broken, unable to dispatch character " << c << ", returning 0");
return 0;
}
}
void enter_i(void) {}
int parse_i(char c)
{
if (isdigit(c) || c == '.')
{
switch_state(RC);
return 1;
}
else if (isalpha(c))
{
switch_state(RV);
return 1;
}
else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
{
switch_state(OP);
return 1;
}
else
{
pr_warn("Unknown character skipped (" << c << "), still in idle");
return 0;
}
}
void leave_i(void) {}
void enter_rc(void)
{
buf_clear();
}
int parse_rc(char c)
{
if (!(isdigit(c) || c == '.'))
{
switch_state(I);
return 1;
}
else
{
buf_push(c);
return 0;
}
}
void leave_rc(void)
{
double value;
if (!sscanf(buffer, "%lf", &value))
{
pr_warn("Invalid CONST: " << buffer);
}
else
{
pv->push_back(Expression::Token(value));
}
}
void enter_rv(void)
{
buf_clear();
}
int parse_rv(char c)
{
if (!isalpha(c))
{
switch_state(I);
return 1;
}
else
{
buf_push(c);
return 0;
}
}
void leave_rv(void)
{
pv->push_back(Expression::Token(buffer));
}
void enter_op(void)
{
buf_clear();
}
int parse_op(char c)
{
if (!(c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')'))
{
switch_state(I);
return 1;
}
else
{
buf_push(c);
return 0;
}
}
void leave_op(void)
{
if (!strcmp(buffer, "("))
{
pv->push_back(Expression::Token(Expression::Token::OPA));
}
else if (!strcmp(buffer, ")"))
{
pv->push_back(Expression::Token(Expression::Token::CPA));
}
else if (!strcmp(buffer, "+"))
{
pv->push_back(Expression::Token(Expression::Token::ADD));
}
else if (!strcmp(buffer, "-"))
{
pv->push_back(Expression::Token(Expression::Token::SUB));
}
else if (!strcmp(buffer, "*"))
{
pv->push_back(Expression::Token(Expression::Token::MUL));
}
else if (!strcmp(buffer, "/"))
{
pv->push_back(Expression::Token(Expression::Token::DIV));
}
else if (!strcmp(buffer, "**"))
{
pv->push_back(Expression::Token(Expression::Token::POW));
}
else
{
pr_warn("Skip unknown operator: " << buffer);
}
}
};
std::shared_ptr<std::vector<Expression::Token>> tokenize_input(char *input_string)
{
std::shared_ptr<std::vector<Expression::Token>> pv = std::make_shared<std::vector<Expression::Token>>();
Parser p(pv);
for (int i = 0, l = strlen(input_string); i < l; i++)
{
i -= p.dispatch_to_current(input_string[i]);
}
(void) p.dispatch_to_current('\0');
return pv;
}
int assert_same(std::vector<Expression::Token>& a, std::vector<Expression::Token>& b)
{
if (a.size() != b.size())
{
std::cout << "Vectors are of different lengths: " << a.size() << " != " << b.size() << "\n";
return 1;
}
for (int i = 0, l = a.size(); i < l; i++)
{
if (a[i].t != b[i].t)
{
std::cout << "Token " << i << " types differ: " << a[i].type_str() << " != " << b[i].type_str() << "\n";
return 1;
}
switch (a[i].t)
{
case Expression::Token::VAR:
if (strcmp((*(a[i].v.s)).c_str(),
(*(b[i].v.s)).c_str()))
{
std::cout << "Variable names at " << i << " differ: " << (*(a[i].v.s)).c_str() << " != " << (*(b[i].v.s)).c_str() << "\n";
return 1;
}
break;
case Expression::Token::CONST:
if (a[i].v.d != b[i].v.d)
{
std::cout << "Constants at " << i << " differ: " << a[i].v.d << " != " << b[i].v.d << "\n";
return 1;
}
break;
case Expression::Token::OPERATOR:
if (a[i].v.o != b[i].v.o)
{
std::cout << "Operators at " << i << " differ: " << a[i].op_str() << " != " << b[i].op_str() << "\n";
return 1;
}
break;
}
}
return 0;
}
}
src/test-cases.cpp
+55
View File
@@ -0,0 +1,55 @@
#include "test-tools.hpp"
#include "parser.hpp"
#include "expression.hpp"
TEST(parser_proper_test_1)
{
auto o = Parser::tokenize_input((char *) "(1+2-c)");
std::vector<Expression::Token> r;
r.push_back(Expression::Token(Expression::Token::OPA));
r.push_back(Expression::Token(1));
r.push_back(Expression::Token(Expression::Token::ADD));
r.push_back(Expression::Token(2));
r.push_back(Expression::Token(Expression::Token::SUB));
r.push_back(Expression::Token("c"));
r.push_back(Expression::Token(Expression::Token::CPA));
CHECK(Parser::assert_same(*o, r));
return 0;
}
TEST(parser_proper_test_2)
{
auto o = Parser::tokenize_input((char *) "(1**5,-snake+marble*34*(35 / 63.2))");
std::vector<Expression::Token> r;
r.push_back(Expression::Token(Expression::Token::OPA));
r.push_back(Expression::Token(1));
r.push_back(Expression::Token(Expression::Token::POW));
r.push_back(Expression::Token(5));
r.push_back(Expression::Token(Expression::Token::SUB));
r.push_back(Expression::Token("snake"));
r.push_back(Expression::Token(Expression::Token::ADD));
r.push_back(Expression::Token("marble"));
r.push_back(Expression::Token(Expression::Token::MUL));
r.push_back(Expression::Token(34));
r.push_back(Expression::Token(Expression::Token::MUL));
r.push_back(Expression::Token(Expression::Token::OPA));
r.push_back(Expression::Token(35));
r.push_back(Expression::Token(Expression::Token::DIV));
r.push_back(Expression::Token(63.2));
r.push_back(Expression::Token(Expression::Token::CPA));
r.push_back(Expression::Token(Expression::Token::CPA));
CHECK(Parser::assert_same(*o, r));
return 0;
}
void register_tests(void)
{
REGISTER(parser_proper_test_1);
REGISTER(parser_proper_test_2);
}
src/test.cpp
+35
View File
@@ -0,0 +1,35 @@
#include <iostream>
#include <vector>
#include "test-cases.cpp"
typedef int (*TestFunc)(void);
void register_tests(void);
std::vector<TestFunc> test_funcs;
int main(void)
{
static unsigned long fails = 0,
successes = 0;
register_tests();
for (int i = 0, l = test_funcs.size(); i < l; i++) {
std::cout << "--- Running test " << i + 1 << "/" << l << "\n";
if (test_funcs[i]())
{
std::cout << "Test failed.\n";
fails++;
}
else
{
successes++;
}
}
std::cout << "--- Finished testing: " << successes << " passed, " << fails << " failed\n";
return !!fails;
}