unify operator weights, add recursive weight method to TreeNode

inc/dyn-pipeline.hpp

@@ -43,7 +43,6 @@ class System
 private:
 	std::vector<Command> *program_memory;
 	std::array<MemCell, DYN_PIPELINE_MEM_SIZE> data_memory;
-	std::array<int, CMD_COUNT> delays;
 	std::array<int, DYN_PIPELINE_LAYERS> layer_cmd {-1};
 	unsigned int pc {0};
 	unsigned int system_time;

inc/expression.hpp

@@ -5,6 +5,8 @@
 #include <memory>
 #include <string>
 
+#include "print.h"
+
 namespace Expression {
 
 class Token {
@@ -28,6 +30,31 @@ public:
 		NOP  // not an operator
 	};
 
+	static int weight_op(Operator o)
+	{
+		switch (o)
+		{
+		case Expression::Token::OPA:
+		case Expression::Token::CPA:
+		case Expression::Token::NOP:
+			pr_warn("Unweightable operator - this is probably a bug!");
+			return 0;
+		case Expression::Token::ADD:
+			return 1;
+		case Expression::Token::SUB:
+			return 1;
+		case Expression::Token::MUL:
+			return 2;
+		case Expression::Token::DIV:
+			return 2;
+		case Expression::Token::POW:
+			return 3;
+		default:
+			pr_warn("Impossible operator - this is a bug!");
+			return 0;
+		}
+	}
+
 	union TokenValue {
 		std::shared_ptr<std::string> s;
 		double d;
@@ -380,6 +407,28 @@ public:
 			delete r;
 		}
 	}
+
+	int weight()
+	{
+		int w = 0;
+
+		if (l != nullptr)
+		{
+			w += l->weight();
+		}
+
+		if (r != nullptr)
+		{
+			w += r->weight();
+		}
+
+		if (o.t == Token::OPERATOR)
+		{
+			Token::weight_op(o.v.o);
+		}
+
+		return w;
+	}
 };
 
 }

inc/syntaxer.hpp

@@ -2,7 +2,6 @@
 
 #include <vector>
 #include "expression.hpp"
-#include "dyn-pipeline.hpp"
 
 namespace Syntax
 {
@@ -11,6 +10,5 @@ int prepare_token_vector(std::vector<Expression::Token>& tv);
 std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv);
 Expression::TreeNode ov_to_tree(const std::vector<Expression::Token>& tv, const std::vector<Expression::Operation>& ov);
 void print_op_tree(const std::vector<Expression::Token>& tv, const std::vector<Expression::Operation>& ov);
-int op_weight(DynamicPipeline::CommandType o);
 
 }

src/dyn-pipeline.cpp

@@ -1,8 +1,14 @@
 #include "dyn-pipeline.hpp"
 #include "print.h"
+#include "expression.hpp"
 
 namespace DynamicPipeline {
 
+int weight_op(DynamicPipeline::CommandType o)
+{
+	return Expression::Token::weight_op(static_cast<Expression::Token::Operator>(o + 2));
+}
+
 void System::init(const std::vector<Command> * const prg, const std::array<double, DYN_PIPELINE_MEM_SIZE>& mem, const int init_mem_size)
 {
 	pr_info("Dynamic Pipeline System initialized with:\n"
@@ -22,13 +28,6 @@ void System::init(const std::vector<Command> * const prg, const std::array<doubl
 		layer_cmd[i] = -1;
 	}
 
-	int d[5] = {1, 1, 2, 2, 3};
-
-	for (int i = 0; i < CMD_COUNT; i++)
-	{
-		delays[i] = d[i];
-	}
-
 	pc = 0;
 	system_time = 0;
 }
@@ -112,7 +111,7 @@ void System::step(void)
 			continue;
 		}
 
-		if (const int d = delays[(*program_memory)[layer_cmd[i]].t]; d > time_taken)
+		if (const int d = weight_op((*program_memory)[layer_cmd[i]].t); d > time_taken)
 		{
 			time_taken = d;
 		}
@@ -156,8 +155,6 @@ void System::run(void)
 	while (next_instruction() || !pipeline_empty())
 	{
 		print_pipeline();
-		pri_info("\n");
-
 		step();
 		pri_info("\n");
 	}

src/syntaxer.cpp

@@ -248,37 +248,6 @@ static int get_max_index(const std::vector<int>& v)
 	return idx;
 }
 
-
-static int op_weight(enum Expression::Token::Operator o)
-{
-	switch (o)
-	{
-	case Expression::Token::OPA:
-	case Expression::Token::CPA:
-	case Expression::Token::NOP:
-		pr_warn("Unweightable operator - this is probably a bug!");
-		return 0;
-	case Expression::Token::ADD:
-		return 1;
-	case Expression::Token::SUB:
-		return 1;
-	case Expression::Token::MUL:
-		return 2;
-	case Expression::Token::DIV:
-		return 2;
-	case Expression::Token::POW:
-		return 3;
-	default:
-		pr_warn("Impossible operator - this is a bug!");
-		return 0;
-	}
-}
-
-int op_weight(DynamicPipeline::CommandType o)
-{
-	return op_weight((enum Expression::Token::Operator) (o + 2));
-}
-
 static int write_operation(
 		std::vector<Expression::Operation>& ov,
 		std::vector<Expression::Token>& cv,
@@ -353,7 +322,7 @@ static int write_operation(
 			return 1;
 		}
 #endif
-		int this_op_weight = get_operator_weight(mv, location) + op_weight(o.v.o);
+		int this_op_weight = get_operator_weight(mv, location) + Expression::Token::weight_op(o.v.o);
 
 		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;