Reduced header file dependencies (#11)

* Remove unused headers
* Reduce header file dependencies
* Rename header file name

Author: AsaiYusuke

include/assert/assert_memory_read_count.h

@@ -1,28 +1,28 @@
 #pragma once
 
 #include "emulation/emulation_devices.h"
+#include "emulation/memory_device.h"
 #include "condition/condition_memory_count.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_memory_read_count
 {
 public:
-    static bool test(emulation_devices *device, condition_memory_count memory_count_def, test_result *result)
+    static bool test(emulation_devices *device, condition_memory_count *memory_count_def, test_result *result)
     {
         auto actual = device->get_memory()->get_read_count(
-            memory_count_def.get_address());
-        bool total_result = memory_count_def.get_expression()->test(actual);
+            memory_count_def->get_address());
+        bool total_result = memory_count_def->get_expression()->test(actual);
         if (!total_result)
             result->add_error(
                 message::error_memory_data(
                     "Read count",
                     memory_count_def,
-                    to_string(*memory_count_def.get_expression()),
+                    to_string(*memory_count_def->get_expression()),
                     to_string(actual)));
 
         return total_result;

include/assert/assert_memory_value.h

@@ -1,26 +1,26 @@
 #pragma once
 
 #include "emulation/emulation_devices.h"
+#include "emulation/memory_device.h"
 #include "condition/condition_memory_value.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_memory_value
 {
 public:
-    static bool test(emulation_devices *device, condition_memory_value memory_value_def, test_result *result)
+    static bool test(emulation_devices *device, condition_memory_value *memory_value_def, test_result *result)
     {
-        auto expression_sequences = memory_value_def.get_expressions();
+        auto expression_sequences = memory_value_def->get_expressions();
         if (expression_sequences.size() == 0)
             return true;
 
         bool total_result = true;
         auto actuals = device->get_memory()->get_write_sequence(
-            memory_value_def.get_address(),
+            memory_value_def->get_address(),
             expression_sequences.size());
         for (decltype(expression_sequences.size()) offset = 0, size = expression_sequences.size(); offset < size && total_result; offset++)
             if (actuals.size() <= offset)

include/assert/assert_memory_write_count.h

@@ -1,28 +1,28 @@
 #pragma once
 
 #include "emulation/emulation_devices.h"
+#include "emulation/memory_device.h"
 #include "condition/condition_memory_count.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_memory_write_count
 {
 public:
-    static bool test(emulation_devices *device, condition_memory_count memory_count_def, test_result *result)
+    static bool test(emulation_devices *device, condition_memory_count *memory_count_def, test_result *result)
     {
         auto actual = device->get_memory()->get_write_count(
-            memory_count_def.get_address());
-        bool total_result = memory_count_def.get_expression()->test(actual);
+            memory_count_def->get_address());
+        bool total_result = memory_count_def->get_expression()->test(actual);
         if (!total_result)
             result->add_error(
                 message::error_memory_data(
                     "Write count",
                     memory_count_def,
-                    to_string(*memory_count_def.get_expression()),
+                    to_string(*memory_count_def->get_expression()),
                     to_string(actual)));
 
         return total_result;

include/assert/assert_register_read_count.h

@@ -2,21 +2,21 @@
 
 #include "emulation/emulation_devices.h"
 #include "condition/condition_register_a_x_y.h"
+#include "condition/condition_register_a_x_y_count.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_register_read_count
 {
 public:
-    static bool test(emulation_devices *device, condition_register_a_x_y register_def, test_result *result)
+    static bool test(emulation_devices *device, condition_register_a_x_y *register_def, test_result *result)
     {
-        auto actual = device->get_cpu()->get_read_count(register_def.get_type());
+        auto actual = device->get_cpu()->get_read_count(register_def->get_type());
 
-        auto expression = register_def.get_read_count()->get_expression();
+        auto expression = register_def->get_read_count()->get_expression();
         if (!expression)
             return true;
 

include/assert/assert_register_value.h

@@ -1,22 +1,23 @@
 #pragma once
 
 #include "emulation/emulation_devices.h"
+#include "emulation/cpu_device.h"
 #include "condition/condition_register_a_x_y.h"
+#include "condition/condition_register_a_x_y_value.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_register_value
 {
 public:
-    static bool test(emulation_devices *device, condition_register_a_x_y register_def, test_result *result)
+    static bool test(emulation_devices *device, condition_register_a_x_y *register_def, test_result *result)
     {
-        auto actual = device->get_cpu()->get_register8(register_def.get_type());
+        auto actual = device->get_cpu()->get_register8(register_def->get_type());
 
-        auto expression = register_def.get_value()->get_expression();
+        auto expression = register_def->get_value()->get_expression();
         if (!expression)
             return true;
 

include/assert/assert_register_write_count.h

@@ -2,21 +2,21 @@
 
 #include "emulation/emulation_devices.h"
 #include "condition/condition_register_a_x_y.h"
+#include "condition/condition_register_a_x_y_count.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_register_write_count
 {
 public:
-    static bool test(emulation_devices *device, condition_register_a_x_y register_def, test_result *result)
+    static bool test(emulation_devices *device, condition_register_a_x_y *register_def, test_result *result)
     {
-        auto actual = device->get_cpu()->get_write_count(register_def.get_type());
+        auto actual = device->get_cpu()->get_write_count(register_def->get_type());
 
-        auto expression = register_def.get_write_count()->get_expression();
+        auto expression = register_def->get_write_count()->get_expression();
         if (!expression)
             return true;
 

include/assert/assert_runtime_error.h

@@ -1,14 +1,13 @@
 #pragma once
 
-#include "emulation/emulation_devices.h"
+#include "assert/runtime_error_result.h"
 #include "test/test_result.h"
-#include "enum/operator_type.h"
 #include "assert/message.h"
-#include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
+class emulation_devices;
+
 class assert_runtime_error
 {
 public:

include/assert/assert_stack_value.h

@@ -5,7 +5,6 @@
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 

include/assert/assert_status_flag_read_count.h

@@ -2,21 +2,21 @@
 
 #include "emulation/emulation_devices.h"
 #include "condition/condition_register_status_flag.h"
+#include "condition/condition_register_status_flag_count.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_status_flag_read_count
 {
 public:
-    static bool test(emulation_devices *device, condition_register_status_flag status_flag_def, test_result *result)
+    static bool test(emulation_devices *device, condition_register_status_flag *status_flag_def, test_result *result)
     {
-        auto actual = device->get_cpu()->get_read_count(status_flag_def.get_type());
+        auto actual = device->get_cpu()->get_read_count(status_flag_def->get_type());
 
-        auto expression = status_flag_def.get_read_count()->get_expression();
+        auto expression = status_flag_def->get_read_count()->get_expression();
         if (!expression)
             return true;
 

include/assert/assert_status_flag_value.h

@@ -2,22 +2,22 @@
 
 #include "emulation/emulation_devices.h"
 #include "condition/condition_register_status_flag.h"
+#include "condition/condition_register_status_flag_value.h"
 #include "test/test_result.h"
 #include "assert/message.h"
 #include "util/to_string.h"
-#include "util/expression_executer.h"
 
 using namespace std;
 
 class assert_status_flag_value
 {
 public:
-    static bool test(emulation_devices *device, condition_register_status_flag status_flag_def, test_result *result)
+    static bool test(emulation_devices *device, condition_register_status_flag *status_flag_def, test_result *result)
     {
         uint8_t status = device->get_cpu()->get_register8(register_type::P);
-        auto actual = (status & (uint8_t)status_flag_def.get_type()) > 0;
+        auto actual = (status & (uint8_t)status_flag_def->get_type()) > 0;
 
-        auto expression = status_flag_def.get_value()->get_expression();
+        auto expression = status_flag_def->get_value()->get_expression();
         if (!expression)
             return true;