initial commit

inc/expression.hpp

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+namespace Expression {
+
+#if 0
+namespace TokenType {
+
+enum TokenType {
+	VAR,
+	CONST,
+	OPERATOR
+};
+
+}
+#endif
+
+class Token {
+public:
+	enum TokenType {
+		VAR,
+		CONST,
+		OPERATOR
+	} t;
+
+	enum Operator {
+		OPA, // opening parentheses
+		CPA, // closing parentheses
+		ADD,
+		SUB,
+		MUL,
+		DIV,
+		POW
+	};
+
+	union TokenValue {
+		std::shared_ptr<std::string> s;
+		double d;
+		Operator o;
+
+		explicit TokenValue(std::string& s)
+			: s(std::make_shared<std::string>(s))
+		{
+		}
+
+		explicit TokenValue(double d)
+			: d(d)
+		{
+		}
+
+		explicit TokenValue(enum Operator o)
+			: o(o)
+		{
+		}
+
+		explicit TokenValue(void)
+		{
+		}
+
+		~TokenValue(void)
+		{
+		}
+	} v;
+
+	Token(std::string s)
+		: v(s)
+	{
+		t = VAR;
+	}
+
+	Token(double d)
+		: v(d)
+	{
+		t = CONST;
+	}
+
+	Token(enum Operator o)
+		: v(o)
+	{
+		t = OPERATOR;
+	}
+
+	Token(Expression::Token&& other)
+	{
+		t = other.t;
+
+		switch (t)
+		{
+		case VAR:
+			v.s = other.v.s;
+			break;
+		case CONST:
+			v.d = other.v.d;
+			break;
+		case OPERATOR:
+			v.o = other.v.o;
+			break;
+		default:
+			std::cout << "Warning: token type is invalid\n";
+			break;
+		}
+	}
+
+	const char *type_str(void)
+	{
+		switch (t)
+		{
+		case VAR:
+			return "VAR";
+		case CONST:
+			return "CONST";
+		case OPERATOR:
+			return "OPERATOR";
+		default:
+			return "Not a valid type";
+		}
+	}
+
+	const char *op_str(void)
+	{
+		if (t != OPERATOR)
+		{
+			return "Token is not an operator!";
+		}
+
+		switch (v.o)
+		{
+		case OPA:
+			return "OPA";
+		case CPA:
+			return "CPA";
+		case ADD:
+			return "ADD";
+		case SUB:
+			return "SUB";
+		case MUL:
+			return "MUL";
+		case DIV:
+			return "DIV";
+		case POW:
+			return "POW";
+		default:
+			return "Invalid operator";
+		}
+	}
+};
+
+class TreeNode {
+	std::shared_ptr<Token> l; // left hand
+	std::shared_ptr<Token> o; // operation
+	std::shared_ptr<Token> r; // right hand
+};
+
+}

inc/parser.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <vector>
+#include "expression.hpp"
+
+namespace Parser {
+
+std::shared_ptr<std::vector<Expression::Token>> tokenize_input(char *input_string);
+int assert_same(std::vector<Expression::Token>& a, std::vector<Expression::Token>& b);
+
+}

inc/print.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <iostream>
+#include "config.h"
+
+#if DEBUG == 1
+#define pr_debug(...) std::cout << "[" << __func__ << ":" << __LINE__ << "] debug: " << __VA_ARGS__ << "\n"
+#else
+#define pr_debug(...) do {} while (0)
+#endif
+
+#define pr_warn(...) std::cout << "[" << __func__ << ":" << __LINE__ << "] warning: " << __VA_ARGS__ << "\n"

inc/test-tools.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <iostream>
+#include <vector>
+
+typedef int (*TestFunc)(void);
+
+extern std::vector<TestFunc> test_funcs;
+
+#define CHECK(a) do { \
+	if (a) { \
+		std::cout << "Failed check in " << __func__ << ":" << __LINE__ << "\n" \
+			  << #a << " does not hold\n"; \
+		return 1; \
+	} \
+} while (0)
+
+#define TEST(name) static int name(void)
+#define REGISTER(name) test_funcs.push_back(name)