From 3b43f23c5dbf36898e8d316569e1ec3b6193c4c5 Mon Sep 17 00:00:00 2001 From: borutr Date: Sat, 5 Nov 2005 23:56:37 +0000 Subject: [PATCH] * sim/ucsim/error.cc, sim/ucsim/errorcl.h, sim/ucsim/sim.src/stack.cc, sim/ucsim/sim.src/stackcl.h, sim/ucsim/sim.src/uc.cc, sim/ucsim/sim.src/uccl.h, sim/ucsim/sim.src/mem.cc, sim/ucsim/sim.src/memcl.h, sim/ucsim/cmd.src/set.cc, sim/ucsim/cmd.src/show.cc: dynamic construction of cl_error_class and derivates - 2.nd try git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@3934 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- ChangeLog | 9 +++++++ sim/ucsim/cmd.src/set.cc | 1 + sim/ucsim/cmd.src/show.cc | 1 + sim/ucsim/error.cc | 23 ++++++++--------- sim/ucsim/errorcl.h | 40 +++++++++++++++++++++++++---- sim/ucsim/sim.src/mem.cc | 28 ++++++++++---------- sim/ucsim/sim.src/memcl.h | 12 ++++----- sim/ucsim/sim.src/stack.cc | 51 ++++++++++++++----------------------- sim/ucsim/sim.src/stackcl.h | 18 +++++-------- sim/ucsim/sim.src/uc.cc | 13 ++++++---- sim/ucsim/sim.src/uccl.h | 8 ++++-- 11 files changed, 114 insertions(+), 90 deletions(-) diff --git a/ChangeLog b/ChangeLog index 179926eb..b3a8ffe4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,12 @@ +2005-11-06 Borut Razem + + * sim/ucsim/error.cc, sim/ucsim/errorcl.h, + sim/ucsim/sim.src/stack.cc, sim/ucsim/sim.src/stackcl.h, + sim/ucsim/sim.src/uc.cc, sim/ucsim/sim.src/uccl.h, + sim/ucsim/sim.src/mem.cc, sim/ucsim/sim.src/memcl.h, + sim/ucsim/cmd.src/set.cc, sim/ucsim/cmd.src/show.cc: + dynamic construction of cl_error_class and derivates - 2.nd try + 2005-11-05 Borut Razem * sim/ucsim/sim.src/error.cc: fixed uninitialized class member variable diff --git a/sim/ucsim/cmd.src/set.cc b/sim/ucsim/cmd.src/set.cc index 07d0134c..5fd6ceaa 100644 --- a/sim/ucsim/cmd.src/set.cc +++ b/sim/ucsim/cmd.src/set.cc @@ -259,6 +259,7 @@ COMMAND_DO_WORK_APP(cl_set_error_cmd) else con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n"); + class cl_list *registered_errors = cl_error_registry::get_list(); if (error_name && value && registered_errors) diff --git a/sim/ucsim/cmd.src/show.cc b/sim/ucsim/cmd.src/show.cc index 8f6fee13..8cd41186 100644 --- a/sim/ucsim/cmd.src/show.cc +++ b/sim/ucsim/cmd.src/show.cc @@ -174,6 +174,7 @@ COMMAND_DO_WORK_APP(cl_show_error_cmd) else con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n"); */ + class cl_list *registered_errors = cl_error_registry::get_list(); int i; for (i= 0; i < registered_errors->count; i++) { diff --git a/sim/ucsim/error.cc b/sim/ucsim/error.cc index b63a9bf5..5b125a8c 100644 --- a/sim/ucsim/error.cc +++ b/sim/ucsim/error.cc @@ -45,7 +45,9 @@ struct id_element error_on_off_names[]= { { 0 , 0 } }; -class cl_list *registered_errors= NIL; +static class cl_error_registry error_registry; + +class cl_list *cl_error_registry::registered_errors= NIL; /* */ @@ -57,9 +59,6 @@ cl_error_class::cl_error_class(enum error_type typ, char *aname, type= typ; on= be_on; set_name(aname, "not-known"); - if (!registered_errors) - registered_errors= new cl_list(2, 2, "registered errors"); - registered_errors->add(this); } cl_error_class::cl_error_class(enum error_type typ, char *aname, @@ -70,9 +69,6 @@ cl_error_class::cl_error_class(enum error_type typ, char *aname, type= typ; on= be_on; set_name(aname, "not-known"); - if (!registered_errors) - registered_errors= new cl_list(2, 2, "registered errors"); - registered_errors->add(this); if (parent) parent->add_child(this); } @@ -130,15 +126,10 @@ cl_error_class::get_type_name() /* */ -class cl_error_class *cl_error::error_class_base; - cl_error::cl_error(void): cl_base() { - if (NULL == error_class_base) - error_class_base = new cl_error_class(err_error, "non-classified", ERROR_ON); - //type= err_unknown; - classification= error_class_base; + classification= error_registry.find("non-classified"); } cl_error::~cl_error(void) @@ -188,5 +179,11 @@ cl_error::get_type_name() return(get_id_string(error_type_names, type, "untyped")); } +cl_error_registry::cl_error_registry(void) +{ + if (NULL == error_registry.find("non-classified")) + register_error(new cl_error_class(err_error, "non-classified", ERROR_ON)); +} + /* End of sim.src/error.cc */ diff --git a/sim/ucsim/errorcl.h b/sim/ucsim/errorcl.h index a061b3a3..dd7bb8d9 100644 --- a/sim/ucsim/errorcl.h +++ b/sim/ucsim/errorcl.h @@ -30,6 +30,8 @@ #ifndef ERRORCL_HEADER #define ERRORCL_HEADER +#include + // prj #include "pobjcl.h" #include "stypes.h" @@ -44,8 +46,6 @@ enum error_on_off { const int err_stop= (err_unknown|err_error); -extern class cl_list *registered_errors; - class cl_error_class: public cl_base { protected: @@ -67,12 +67,42 @@ public: //char *get_name(void); }; +class cl_error_registry +{ +public: + cl_error_registry(void); + class cl_error_class *find(char *type_name) + { + if (NIL == registered_errors) + return NIL; + return static_cast(registered_errors->first_that(compare, static_cast(type_name))); + } + static class cl_list *get_list(void) + { + return registered_errors; + } + +protected: + class cl_error_class *register_error(class cl_error_class *error_class) + { + if (!registered_errors) + registered_errors= new cl_list(2, 2, "registered errors"); + registered_errors->add(error_class); + return error_class; + } + +private: + static class cl_list *registered_errors; + static int compare(void *obj1, void *obj2) + { + return (static_cast(obj1))->is_named(static_cast(obj2)); + } +}; + class cl_commander; //forward class cl_error: public cl_base { -private: - static class cl_error_class *error_class_base; protected: class cl_error_class *classification; public: @@ -93,7 +123,7 @@ public: virtual char *get_type_name(); }; - #endif + /* End of sim.src/errorcl.h */ diff --git a/sim/ucsim/sim.src/mem.cc b/sim/ucsim/sim.src/mem.cc index 1ac443ee..6be08f64 100644 --- a/sim/ucsim/sim.src/mem.cc +++ b/sim/ucsim/sim.src/mem.cc @@ -48,6 +48,8 @@ #include "hwcl.h" +static class cl_mem_error_registry mem_error_registry; + /* * 3rd version of memory system */ @@ -1378,28 +1380,20 @@ cl_decoder_list::compare(void *key1, void *key2) /* All of memory errors */ -class cl_error_class *cl_error_mem::error_mem_class; - cl_error_mem::cl_error_mem(class cl_memory *amem, t_addr aaddr) { mem= amem; addr= aaddr; - if (NULL == error_mem_class) - error_mem_class= new cl_error_class(err_error, "memory", classification, ERROR_OFF); - classification= error_mem_class; + classification= mem_error_registry.find("memory"); } /* Invalid address in memory access */ -class cl_error_class *cl_error_mem_invalid_address::error_mem_invalid_address_class; - cl_error_mem_invalid_address:: cl_error_mem_invalid_address(class cl_memory *amem, t_addr aaddr): cl_error_mem(amem, aaddr) { - if (NULL == error_mem_invalid_address_class) - error_mem_invalid_address_class= new cl_error_class(err_error, "invalid_address", classification); - classification= error_mem_invalid_address_class; + classification= mem_error_registry.find("invalid_address"); } void @@ -1413,15 +1407,11 @@ cl_error_mem_invalid_address::print(class cl_commander *c) /* Non-decoded address space access */ -class cl_error_class *cl_error_mem_non_decoded::error_mem_non_decoded_class; - cl_error_mem_non_decoded:: cl_error_mem_non_decoded(class cl_memory *amem, t_addr aaddr): cl_error_mem(amem, aaddr) { - if (NULL == error_mem_non_decoded_class) - error_mem_non_decoded_class= new cl_error_class(err_error, "non_decoded", classification); - classification= error_mem_non_decoded_class; + classification= mem_error_registry.find("non_decoded"); } void @@ -1433,5 +1423,13 @@ cl_error_mem_non_decoded::print(class cl_commander *c) cmd_fprintf(f, " in memory %s.\n", mem->get_name()); } +cl_mem_error_registry::cl_mem_error_registry(void) +{ + class cl_error_class *prev = mem_error_registry.find("non-classified"); + prev = register_error(new cl_error_class(err_error, "memory", prev, ERROR_OFF)); + prev = register_error(new cl_error_class(err_error, "invalid_address", prev)); + prev = register_error(new cl_error_class(err_error, "non_decoded", prev)); +} + /* End of mem.cc */ diff --git a/sim/ucsim/sim.src/memcl.h b/sim/ucsim/sim.src/memcl.h index 855028ac..e12819b7 100644 --- a/sim/ucsim/sim.src/memcl.h +++ b/sim/ucsim/sim.src/memcl.h @@ -422,8 +422,6 @@ public: class cl_error_mem: public cl_error { -private: - static class cl_error_class *error_mem_class; protected: class cl_memory *mem; t_addr addr; @@ -433,8 +431,6 @@ public: class cl_error_mem_invalid_address: public cl_error_mem { -private: - static class cl_error_class *error_mem_invalid_address_class; public: cl_error_mem_invalid_address(class cl_memory *amem, t_addr aaddr); @@ -443,15 +439,19 @@ public: class cl_error_mem_non_decoded: public cl_error_mem { -private: - static class cl_error_class *error_mem_non_decoded_class; public: cl_error_mem_non_decoded(class cl_memory *amem, t_addr aaddr); virtual void print(class cl_commander *c); }; +class cl_mem_error_registry: public cl_error_registry +{ +public: + cl_mem_error_registry(void); +}; #endif + /* End of memcl.h */ diff --git a/sim/ucsim/sim.src/stack.cc b/sim/ucsim/sim.src/stack.cc index f10ab8fc..39a8b16f 100644 --- a/sim/ucsim/sim.src/stack.cc +++ b/sim/ucsim/sim.src/stack.cc @@ -34,6 +34,8 @@ 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): @@ -420,39 +422,25 @@ cl_stack_pop::match(class cl_stack_op *op) * Stack Errors */ -class cl_error_class *cl_error_stack::error_stack_class; - cl_error_stack::cl_error_stack(void) { - if (NULL == error_stack_class) - error_stack_class= new cl_error_class(err_error, "stack", classification, ERROR_OFF); - classification= error_stack_class; + classification = stack_error_registry.find("stack"); } /* Stack Tracker Errors */ -class cl_error_class *cl_error_stack_tracker::error_stack_tracker_class; - cl_error_stack_tracker::cl_error_stack_tracker(void) { -// cl_error_class *error_stack_tracker_class = new cl_error_class(err_error, "stack_tracker", error_stack_class, ERROR_OFF); -// classification= &error_stack_tracker_class; - if (NULL == error_stack_tracker_class) - error_stack_tracker_class= new cl_error_class(err_error, "stack_tracker", classification); - classification= error_stack_tracker_class; + classification = stack_error_registry.find("stack_tracker"); } /* Stack Tracker: wrong handle */ -class cl_error_class *cl_error_stack_tracker_wrong_handle::error_stack_tracker_wrong_handle_class; - cl_error_stack_tracker_wrong_handle::cl_error_stack_tracker_wrong_handle(bool write_op): cl_error_stack_tracker() { write_operation= write_op; - if (NULL == error_stack_tracker_wrong_handle_class) - error_stack_tracker_wrong_handle_class= new cl_error_class(err_error, "stack_tracker_wrong_handle", classification); - classification= error_stack_tracker_wrong_handle_class; + classification = stack_error_registry.find("stack_tracker_wrong_handle"); } void @@ -464,16 +452,12 @@ cl_error_stack_tracker_wrong_handle::print(class cl_commander *c) /* Stack Tracker: operation on empty stack */ -class cl_error_class *cl_error_stack_tracker_empty::error_stack_tracker_empty_class; - cl_error_stack_tracker_empty:: cl_error_stack_tracker_empty(class cl_stack_op *op): cl_error_stack_tracker() { operation= op->mk_copy(); - if (NULL == error_stack_tracker_empty_class) - error_stack_tracker_empty_class= new cl_error_class(err_error, "operation_on_empty_stack", classification); - 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) @@ -492,17 +476,13 @@ cl_error_stack_tracker_empty::print(class cl_commander *c) /* Stack Tracker: operation on empty stack */ -class cl_error_class *cl_error_stack_tracker_unmatch::error_stack_tracker_unmatch_class; - cl_error_stack_tracker_unmatch:: cl_error_stack_tracker_unmatch(class cl_stack_op *Top, class cl_stack_op *op): cl_error_stack_tracker() { top= Top->mk_copy(); operation= op->mk_copy(); - if (NULL == error_stack_tracker_unmatch_class) - error_stack_tracker_unmatch_class= new cl_error_class(err_warning, "stack_operation_unmatched_to_top_of_stack", classification); - 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) @@ -523,17 +503,13 @@ cl_error_stack_tracker_unmatch::print(class cl_commander *c) /* Stack Tracker: stack is inconsistent */ -class cl_error_class *cl_error_stack_tracker_inconsistent::error_stack_tracker_inconsistent_class; - cl_error_stack_tracker_inconsistent:: cl_error_stack_tracker_inconsistent(class cl_stack_op *op, int the_unread_data_size) { operation= op->mk_copy(); unread_data_size= the_unread_data_size; - if (NULL == error_stack_tracker_inconsistent_class) - error_stack_tracker_inconsistent_class= new cl_error_class(err_warning, "stack_looks_corrupted", classification); - 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) @@ -549,5 +525,16 @@ cl_error_stack_tracker_inconsistent::print(class cl_commander *c) 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)); +} + /* End of sim.src/stack.cc */ diff --git a/sim/ucsim/sim.src/stackcl.h b/sim/ucsim/sim.src/stackcl.h index e4dd4e4c..15c97dc2 100644 --- a/sim/ucsim/sim.src/stackcl.h +++ b/sim/ucsim/sim.src/stackcl.h @@ -173,8 +173,6 @@ public: /* * All kind of stack errors */ -//extern class cl_error_class error_stack_class; -//class cl_error_stack: public cl_error class cl_error_stack: public cl_error { private: @@ -188,16 +186,12 @@ public: */ class cl_error_stack_tracker: public cl_error_stack { -private: - static class cl_error_class *error_stack_tracker_class; public: cl_error_stack_tracker(void); }; class cl_error_stack_tracker_wrong_handle: public cl_error_stack_tracker { -private: - static class cl_error_class *error_stack_tracker_wrong_handle_class; public: bool write_operation; public: @@ -208,8 +202,6 @@ public: class cl_error_stack_tracker_empty: public cl_error_stack_tracker { -private: - static class cl_error_class *error_stack_tracker_empty_class; protected: class cl_stack_op *operation; public: @@ -221,8 +213,6 @@ public: class cl_error_stack_tracker_unmatch: public cl_error_stack_tracker { -private: - static class cl_error_class *error_stack_tracker_unmatch_class; protected: class cl_stack_op *top, *operation; public: @@ -235,8 +225,6 @@ public: class cl_error_stack_tracker_inconsistent: public cl_error_stack_tracker { -private: - static class cl_error_class *error_stack_tracker_inconsistent_class; protected: class cl_stack_op *operation; int unread_data_size; @@ -248,7 +236,13 @@ public: virtual void print(class cl_commander *c); }; +class cl_stack_error_registry: public cl_error_registry +{ +public: + cl_stack_error_registry(void); +}; #endif + /* End of sim.src/stackcl.h */ diff --git a/sim/ucsim/sim.src/uc.cc b/sim/ucsim/sim.src/uc.cc index 374b3af7..8af862db 100644 --- a/sim/ucsim/sim.src/uc.cc +++ b/sim/ucsim/sim.src/uc.cc @@ -56,6 +56,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "simcl.h" #include "itsrccl.h" +static class cl_uc_error_registry uc_error_registry; /* * Clock counter @@ -1855,14 +1856,10 @@ cl_uc::check_events(void) *---------------------------------------------------------------------------- */ -class cl_error_class *cl_error_unknown_code::error_unknown_code_class; - cl_error_unknown_code::cl_error_unknown_code(class cl_uc *the_uc) { uc= the_uc; - if (NULL == error_unknown_code_class) - error_unknown_code_class= new cl_error_class(err_error, "unknown_code", classification, ERROR_OFF); - classification= error_unknown_code_class; + classification= uc_error_registry.find("unknown_code"); } void @@ -1882,5 +1879,11 @@ cl_error_unknown_code::print(class cl_commander *c) cmd_fprintf(f, "\n"); } +cl_uc_error_registry::cl_uc_error_registry(void) +{ + class cl_error_class *prev = uc_error_registry.find("non-classified"); + prev = register_error(new cl_error_class(err_error, "unknown_code", prev, ERROR_OFF)); +} + /* End of uc.cc */ diff --git a/sim/ucsim/sim.src/uccl.h b/sim/ucsim/sim.src/uccl.h index dada96ec..d26af207 100644 --- a/sim/ucsim/sim.src/uccl.h +++ b/sim/ucsim/sim.src/uccl.h @@ -247,8 +247,6 @@ public: class cl_error_unknown_code: public cl_error { -private: - static class cl_error_class *error_unknown_code_class; protected: class cl_uc *uc; public: @@ -257,7 +255,13 @@ public: virtual void print(class cl_commander *c); }; +class cl_uc_error_registry: public cl_error_registry +{ +public: + cl_uc_error_registry(void); +}; #endif + /* End of uccl.h */ -- 2.30.2