* sim/ucsim/cmd.src/newcmdposix.cc, sim/ucsim/cmd.src/newcmdposixcl.h,

[fw/sdcc] / sim / ucsim / sim.src / stack.cc

diff --git a/sim/ucsim/sim.src/stack.cc b/sim/ucsim/sim.src/stack.cc
index d27f91be371a59ab77865b27c40a0f5db68e3f71..e40fb4a45942581b94fd6dbdf0abff6d7e3b29ef 100644 (file)
--- a/sim/ucsim/sim.src/stack.cc
+++ b/sim/ucsim/sim.src/stack.cc
@@ -34,9 +34,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "stackcl.h"
 
 
+static class cl_stack_error_registry stack_error_registry;
+
 cl_stack_op::cl_stack_op(enum stack_op op,
-                        t_addr iPC,
-                        t_addr iSP_before, t_addr iSP_after):
+                         t_addr iPC,
+                         t_addr iSP_before, t_addr iSP_after):
   cl_base()
 {
   operation= op;
@@ -60,13 +62,13 @@ cl_stack_op::mk_copy(void)
 }
 
 void
-cl_stack_op::info_head(class cl_console *con)
+cl_stack_op::info_head(class cl_console_base *con)
 {
   con->dd_printf("OP   SP before-after   L DATA/ADDR   INSTRUCTION\n");
 }
 
 void
-cl_stack_op::info(class cl_console *con, class cl_uc *uc)
+cl_stack_op::info(class cl_console_base *con, class cl_uc *uc)
 {
   con->dd_printf("%-4s 0x%06"_A_"x-0x%06"_A_"x %d ",
                 get_op_name(), SP_before, SP_after, abs(SP_before-SP_after));
@@ -83,7 +85,7 @@ cl_stack_op::get_op_name(void)
 }
 
 void
-cl_stack_op::print_info(class cl_console *con)
+cl_stack_op::print_info(class cl_console_base *con)
 {
   con->dd_printf("-");
 }
@@ -162,7 +164,7 @@ cl_stack_call::get_op_name(void)
 }
 
 void
-cl_stack_call::print_info(class cl_console *con)
+cl_stack_call::print_info(class cl_console_base *con)
 {
   con->dd_printf("0x%06"_A_"x", called_addr);
 }
@@ -213,7 +215,7 @@ cl_stack_intr::get_op_name(void)
 }
 
 void
-cl_stack_intr::print_info(class cl_console *con)
+cl_stack_intr::print_info(class cl_console_base *con)
 {
   con->dd_printf("0x%06"_A_"x", called_addr);
 }
@@ -274,7 +276,7 @@ cl_stack_push::get_matching_op(void)
 }
 
 void
-cl_stack_push::print_info(class cl_console *con)
+cl_stack_push::print_info(class cl_console_base *con)
 {
   t_addr d= data;
   con->dd_printf("0x%06"_A_"x", d);
@@ -420,45 +422,42 @@ cl_stack_pop::match(class cl_stack_op *op)
  * Stack Errors
  */
 
-ERROR_CLASS_DEF_PARENT_ON(err_error, stack, "stack",
-                         error_class_base, ERROR_OFF);
+cl_error_stack::cl_error_stack(void)
+{
+  classification = stack_error_registry.find("stack");
+}
 
 /* Stack Tracker Errors */
-ERROR_CLASS_DEF_PARENT(err_error, stack_tracker, "stack_tracker",
-                      error_stack_class);
+
+cl_error_stack_tracker::cl_error_stack_tracker(void)
+{
+  classification = stack_error_registry.find("stack_tracker");
+}
 
 /* Stack Tracker: wrong handle */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      stack_tracker_wrong_handle,
-                      "stack_tracker_wrong_handle",
-                      error_stack_tracker_class);
 
 cl_error_stack_tracker_wrong_handle::cl_error_stack_tracker_wrong_handle(bool write_op):
   cl_error_stack_tracker()
 {
   write_operation= write_op;
-  classification= &error_stack_tracker_wrong_handle_class;
+  classification = stack_error_registry.find("stack_tracker_wrong_handle");
 }
 
 void
-cl_error_stack_tracker_wrong_handle::print(class cl_commander *c)
+cl_error_stack_tracker_wrong_handle::print(class cl_commander_base *c)
 {
   c->dd_printf("%s: wrong stack tracker handle called for %s operation\n",
-              get_type_name(), write_operation?"write":"read");
+               get_type_name(), write_operation?"write":"read");
 }
 
 /* Stack Tracker: operation on empty stack */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      stack_tracker_empty,
-                      "operation_on_empty_stack",
-                      error_stack_tracker_class);
 
 cl_error_stack_tracker_empty::
 cl_error_stack_tracker_empty(class cl_stack_op *op):
   cl_error_stack_tracker()
 {
   operation= op->mk_copy();
-  classification= &error_stack_tracker_empty_class;
+  classification = stack_error_registry.find("operation_on_empty_stack");
 }
 
 cl_error_stack_tracker_empty::~cl_error_stack_tracker_empty(void)
@@ -467,19 +466,15 @@ cl_error_stack_tracker_empty::~cl_error_stack_tracker_empty(void)
 }
 
 void
-cl_error_stack_tracker_empty::print(class cl_commander *c)
+cl_error_stack_tracker_empty::print(class cl_commander_base *c)
 {
   c->dd_printf("%s(0x%06"_A_"x: %s on empty stack, PC="
-              "0x06"_A_"x, SP=0x%06"_A_"x->0x%06"_A_"x\n",
-              get_type_name(), operation->get_pc(), operation->get_op_name(),
-              operation->get_before(), operation->get_after());
+               "0x06"_A_"x, SP=0x%06"_A_"x->0x%06"_A_"x\n",
+               get_type_name(), operation->get_pc(), operation->get_op_name(),
+               operation->get_before(), operation->get_after());
 }
 
 /* Stack Tracker: operation on empty stack */
-ERROR_CLASS_DEF_PARENT(err_warning,
-                      stack_tracker_unmatch,
-                      "stack_operation_unmatched_to_top_of_stack",
-                      error_stack_tracker_class);
 
 cl_error_stack_tracker_unmatch::
 cl_error_stack_tracker_unmatch(class cl_stack_op *Top, class cl_stack_op *op):
@@ -487,7 +482,7 @@ cl_error_stack_tracker_unmatch(class cl_stack_op *Top, class cl_stack_op *op):
 {
   top= Top->mk_copy();
   operation= op->mk_copy();
-  classification= &error_stack_tracker_unmatch_class;
+  classification = stack_error_registry.find("stack_operation_unmatched_to_top_of_stack");
 }
 
 cl_error_stack_tracker_unmatch::~cl_error_stack_tracker_unmatch(void)
@@ -497,20 +492,16 @@ cl_error_stack_tracker_unmatch::~cl_error_stack_tracker_unmatch(void)
 }
 
 void
-cl_error_stack_tracker_unmatch::print(class cl_commander *c)
+cl_error_stack_tracker_unmatch::print(class cl_commander_base *c)
 {
   c->dd_printf("%s(0x%06"_A_"x): %s when %s expected, "
-              "SP=0x%06"_A_"x->0x%06"_A_"x\n",
-              get_type_name(), operation->get_pc(),
-              operation->get_op_name(), top->get_matching_name(),
-              operation->get_before(), operation->get_after());
+               "SP=0x%06"_A_"x->0x%06"_A_"x\n",
+               get_type_name(), operation->get_pc(),
+               operation->get_op_name(), top->get_matching_name(),
+               operation->get_before(), operation->get_after());
 }
 
 /* Stack Tracker: stack is inconsistent */
-ERROR_CLASS_DEF_PARENT(err_warning,
-                      stack_tracker_inconsistent,
-                      "stack_looks_corrupted",
-                      error_stack_tracker_class);
 
 cl_error_stack_tracker_inconsistent::
 cl_error_stack_tracker_inconsistent(class cl_stack_op *op,
@@ -518,7 +509,7 @@ cl_error_stack_tracker_inconsistent(class cl_stack_op *op,
 {
   operation= op->mk_copy();
   unread_data_size= the_unread_data_size;
-  classification= &error_stack_tracker_inconsistent_class;
+  classification = stack_error_registry.find("stack_looks_corrupted");
 }
 
 cl_error_stack_tracker_inconsistent::~cl_error_stack_tracker_inconsistent(void)
@@ -527,11 +518,22 @@ cl_error_stack_tracker_inconsistent::~cl_error_stack_tracker_inconsistent(void)
 }
 
 void
-cl_error_stack_tracker_inconsistent::print(class cl_commander *c)
+cl_error_stack_tracker_inconsistent::print(class cl_commander_base *c)
 {
   c->dd_printf("%s(0x%06"_A_"x): %d byte(s) unread from the stack\n",
-              get_type_name(), operation->get_pc(),
-              unread_data_size);
+               get_type_name(), operation->get_pc(),
+               unread_data_size);
+}
+
+cl_stack_error_registry::cl_stack_error_registry(void)
+{
+  class cl_error_class *prev = stack_error_registry.find("non-classified");
+  prev = register_error(new cl_error_class(err_error, "stack", prev, ERROR_OFF));
+  prev = register_error(new cl_error_class(err_error, "stack_tracker", prev));
+  prev = register_error(new cl_error_class(err_error, "stack_tracker_wrong_handle", prev));
+  prev = register_error(new cl_error_class(err_error, "operation_on_empty_stack", prev));
+  prev = register_error(new cl_error_class(err_warning, "stack_operation_unmatched_to_top_of_stack", prev));
+  prev = register_error(new cl_error_class(err_warning, "stack_looks_corrupted", prev));
 }