* sim/ucsim/cmd.src/error.cc, sim/ucsim/cmd.src/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/cmdconf.cc: dynamic construction of cl_error_class
  and derivates to resolve the initialization problem on OSX

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@3932 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/ChangeLog b/ChangeLog
index afabacbc89f4e98d14371c51931338f0ff2183b7..3561b5542f9c586336c8015607f4eaa30b54f9f8 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2005-11-04 Borut Razem <borut.razem AT siol.net>
+
+       * sim/ucsim/cmd.src/error.cc, sim/ucsim/cmd.src/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/cmdconf.cc: dynamic construction of cl_error_class
+         and derivates to resolve the initialization problem on OSX
+
 2005-11-02 Borut Razem <borut.razem AT siol.net>
 
        * sim/ucsim/cmd.src/cmdutil.cc, sim/ucsim/cmd.src/newcmd.cc:

diff --git a/sim/ucsim/cmd.src/cmdconf.cc b/sim/ucsim/cmd.src/cmdconf.cc
index 6cd15ff6c724e2fdde758f8da4910810e33d3ff9..f521e8900abb986e1fccb47df4714213937caa7a 100644 (file)
--- a/sim/ucsim/cmd.src/cmdconf.cc
+++ b/sim/ucsim/cmd.src/cmdconf.cc
@@ -94,7 +94,9 @@ COMMAND_DO_WORK_APP(cl_conf_objects_cmd)
                                 cmdline->param(1),
                                 cmdline->param(2),
                                 cmdline->param(3) };*/
-  conf_objects_cmd_print_node(con, 0, /*application*/&error_class_base);
+  class cl_error *cl_error_base = new cl_error();
+  conf_objects_cmd_print_node(con, 0, /*application*/cl_error_base->get_class());
+  delete cl_error_base;
   return(DD_FALSE);
 }
 

diff --git a/sim/ucsim/error.cc b/sim/ucsim/error.cc
index a8c533bbc7f5d40bce7ca99ad00fbe83631be4ec..b63a9bf5183cdbedfc619491c1c577c28d547834 100644 (file)
--- a/sim/ucsim/error.cc
+++ b/sim/ucsim/error.cc
@@ -45,26 +45,13 @@ struct id_element error_on_off_names[]= {
   { 0          , 0 }
 };
 
-class cl_error_class error_class_base(err_error, "non-classified", ERROR_ON);
-
 class cl_list *registered_errors= NIL;
 
 /*
  */
 
-cl_error_class::cl_error_class(enum error_type typ, char *aname):
-  cl_base()
-{
-  type= typ;
-  on= ERROR_PARENT;
-  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,
-                              enum error_on_off be_on):
+                              enum error_on_off be_on/* = ERROR_PARENT*/):
   cl_base()
 {
   type= typ;
@@ -75,23 +62,9 @@ cl_error_class::cl_error_class(enum error_type typ, char *aname,
   registered_errors->add(this);
 }
 
-cl_error_class::cl_error_class(enum error_type typ, char *aname,
-                              class cl_error_class *parent):
-  cl_base()
-{
-  type= typ;
-  on= ERROR_PARENT;
-  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);
-}
-
 cl_error_class::cl_error_class(enum error_type typ, char *aname,
                               class cl_error_class *parent,
-                              enum error_on_off be_on):
+                              enum error_on_off be_on/* = ERROR_PARENT*/):
   cl_base()
 {
   type= typ;
@@ -157,11 +130,15 @@ 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= 0;
+  classification= error_class_base;
 }
 
 cl_error::~cl_error(void)

diff --git a/sim/ucsim/errorcl.h b/sim/ucsim/errorcl.h
index c4075bd4a6433bc465dd46415e9eceeb949d70f4..a061b3a311e6d0c07de6704fff515bc8637ae04c 100644 (file)
--- a/sim/ucsim/errorcl.h
+++ b/sim/ucsim/errorcl.h
@@ -44,17 +44,6 @@ enum error_on_off {
 
 const int err_stop= (err_unknown|err_error);
 
-#define ERROR_CLASS_DECL(NAME) \
-extern class cl_error_class error_##NAME##_class;\
-class cl_error_##NAME
-
-#define ERROR_CLASS_DEF_PARENT(TYPE,NAME,CLASS_NAME,PARENT) \
-class cl_error_class error_##NAME##_class(TYPE, CLASS_NAME, &(PARENT))
-
-#define ERROR_CLASS_DEF_PARENT_ON(TYPE,NAME,CLASS_NAME,PARENT,ON) \
-class cl_error_class error_##NAME##_class(TYPE, CLASS_NAME, &(PARENT), ON)
-
-
 extern class cl_list *registered_errors;
 
 class cl_error_class: public cl_base
@@ -64,14 +53,11 @@ protected:
   //char *name;
   enum error_on_off on;
 public:
-  cl_error_class(enum error_type typ, char *aname);
   cl_error_class(enum error_type typ, char *aname,
-                enum error_on_off be_on);
-  cl_error_class(enum error_type typ, char *aname,
-                class cl_error_class *parent);
+                enum error_on_off be_on= ERROR_PARENT);
   cl_error_class(enum error_type typ, char *aname,
                 class cl_error_class *parent,
-                enum error_on_off be_on);
+                enum error_on_off be_on= ERROR_PARENT);
   
   enum error_on_off get_on(void) { return(on); }
   void set_on(enum error_on_off val);
@@ -81,13 +67,12 @@ public:
   //char *get_name(void);
 };
 
-extern class cl_error_class error_class_base;
-
-
 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:
@@ -97,7 +82,7 @@ public:
   cl_error(void);
   virtual ~cl_error(void);
   virtual int init(void);
- 
+
 public:
   virtual enum error_type get_type(void);
   virtual enum error_on_off get_on(void);

diff --git a/sim/ucsim/sim.src/mem.cc b/sim/ucsim/sim.src/mem.cc
index e5a32c93ced7b0fb5597b39bb78d421d5e3d52ef..de49f02e679d4d4d3a874f11f24433863d75ded1 100644 (file)
--- a/sim/ucsim/sim.src/mem.cc
+++ b/sim/ucsim/sim.src/mem.cc
@@ -1376,27 +1376,29 @@ cl_decoder_list::compare(void *key1, void *key2)
  */
 
 /* All of memory errors */
-ERROR_CLASS_DEF_PARENT_ON(err_error, mem, "memory",
-                         error_class_base, ERROR_ON);
+
+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;
-  classification= &error_mem_class;
+  if (NULL == error_mem_class)
+    error_mem_class= new cl_error_class(err_error, "memory", classification, ERROR_OFF);
+  classification= error_mem_class;
 }
 
 /* Invalid address in memory access */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      mem_invalid_address,
-                      "invalid_address",
-                      error_mem_class);
+
+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)
 {
-  classification= &error_mem_invalid_address_class;
+  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;
 }
 
 void
@@ -1409,16 +1411,16 @@ cl_error_mem_invalid_address::print(class cl_commander *c)
 }
 
 /* Non-decoded address space access */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      mem_non_decoded,
-                      "non_decoded",
-                      error_mem_class);
+
+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)
 {
-  classification= &error_mem_non_decoded_class;
+  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;
 }
 
 void

diff --git a/sim/ucsim/sim.src/memcl.h b/sim/ucsim/sim.src/memcl.h
index 223fa443406d939c5726efabf7f556288fd9fe7b..855028acb82f2cedafc0473857ddb76a0251aeff 100644 (file)
--- a/sim/ucsim/sim.src/memcl.h
+++ b/sim/ucsim/sim.src/memcl.h
@@ -420,8 +420,10 @@ public:
 
 #include "errorcl.h"
 
-ERROR_CLASS_DECL(mem): public cl_error
+class cl_error_mem: public cl_error
 {
+private:
+  static class cl_error_class *error_mem_class;
 protected:
   class cl_memory *mem;
   t_addr addr;
@@ -429,16 +431,20 @@ public:
   cl_error_mem(class cl_memory *amem, t_addr aaddr);
 };
 
-ERROR_CLASS_DECL(mem_invalid_address): public cl_error_mem
+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);
 
   virtual void print(class cl_commander *c);
 };
 
-ERROR_CLASS_DECL(mem_non_decoded): public cl_error_mem
+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);
 

diff --git a/sim/ucsim/sim.src/stack.cc b/sim/ucsim/sim.src/stack.cc
index d27f91be371a59ab77865b27c40a0f5db68e3f71..f10ab8fc077b273db6fcaaa1eb71e9a77ffb116c 100644 (file)
--- a/sim/ucsim/sim.src/stack.cc
+++ b/sim/ucsim/sim.src/stack.cc
@@ -420,24 +420,39 @@ 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);
+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;
+}
 
 /* Stack Tracker Errors */
-ERROR_CLASS_DEF_PARENT(err_error, stack_tracker, "stack_tracker",
-                      error_stack_class);
+
+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;
+}
 
 /* Stack Tracker: wrong handle */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      stack_tracker_wrong_handle,
-                      "stack_tracker_wrong_handle",
-                      error_stack_tracker_class);
+
+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;
-  classification= &error_stack_tracker_wrong_handle_class;
+  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;
 }
 
 void
@@ -448,17 +463,17 @@ cl_error_stack_tracker_wrong_handle::print(class cl_commander *c)
 }
 
 /* Stack Tracker: operation on empty stack */
-ERROR_CLASS_DEF_PARENT(err_error,
-                      stack_tracker_empty,
-                      "operation_on_empty_stack",
-                      error_stack_tracker_class);
+
+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();
-  classification= &error_stack_tracker_empty_class;
+  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;
 }
 
 cl_error_stack_tracker_empty::~cl_error_stack_tracker_empty(void)
@@ -476,10 +491,8 @@ cl_error_stack_tracker_empty::print(class cl_commander *c)
 }
 
 /* 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);
+
+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):
@@ -487,7 +500,9 @@ 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;
+  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;
 }
 
 cl_error_stack_tracker_unmatch::~cl_error_stack_tracker_unmatch(void)
@@ -507,10 +522,8 @@ cl_error_stack_tracker_unmatch::print(class cl_commander *c)
 }
 
 /* Stack Tracker: stack is inconsistent */
-ERROR_CLASS_DEF_PARENT(err_warning,
-                      stack_tracker_inconsistent,
-                      "stack_looks_corrupted",
-                      error_stack_tracker_class);
+
+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,
@@ -518,7 +531,9 @@ 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;
+  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;
 }
 
 cl_error_stack_tracker_inconsistent::~cl_error_stack_tracker_inconsistent(void)

diff --git a/sim/ucsim/sim.src/stackcl.h b/sim/ucsim/sim.src/stackcl.h
index 06e522bc2ecba597a36425df7f96b9590a4a5f12..e4dd4e4c4c265fca58decb6f0f2fd9003b27fa5e 100644 (file)
--- a/sim/ucsim/sim.src/stackcl.h
+++ b/sim/ucsim/sim.src/stackcl.h
@@ -175,23 +175,29 @@ public:
  */
 //extern class cl_error_class error_stack_class;
 //class cl_error_stack: public cl_error
-ERROR_CLASS_DECL(stack): public cl_error
+class cl_error_stack: public cl_error
 {
+private:
+  static class cl_error_class *error_stack_class;
 public:
-  cl_error_stack(void) { classification= &error_stack_class; }
+  cl_error_stack(void);
 };
 
 /*
  * All kind of stack tracker errors
  */
-ERROR_CLASS_DECL(stack_tracker): public cl_error_stack
+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) { classification= &error_stack_tracker_class; }
+  cl_error_stack_tracker(void);
 };
 
-ERROR_CLASS_DECL(stack_tracker_wrong_handle): public cl_error_stack_tracker
+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:
@@ -200,8 +206,10 @@ public:
   virtual void print(class cl_commander *c);
 };
 
-ERROR_CLASS_DECL(stack_tracker_empty): public cl_error_stack_tracker
+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:
@@ -211,8 +219,10 @@ public:
   virtual void print(class cl_commander *c);
 };
 
-ERROR_CLASS_DECL(stack_tracker_unmatch): public cl_error_stack_tracker
+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:
@@ -223,8 +233,10 @@ public:
   virtual void print(class cl_commander *c);
 };
 
-ERROR_CLASS_DECL(stack_tracker_inconsistent): public cl_error_stack_tracker
+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;

diff --git a/sim/ucsim/sim.src/uc.cc b/sim/ucsim/sim.src/uc.cc
index caef99df040913f9c616c8ed3992328fde4fc27f..374b3af701af3313fa9cc45e6d5b17982c566985 100644 (file)
--- a/sim/ucsim/sim.src/uc.cc
+++ b/sim/ucsim/sim.src/uc.cc
@@ -1855,13 +1855,14 @@ cl_uc::check_events(void)
  *----------------------------------------------------------------------------
  */
 
-ERROR_CLASS_DEF_PARENT_ON(err_error, unknown_code, "unknown_code",
-                         error_class_base, ERROR_ON);
+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;
-  classification= &error_unknown_code_class;
+  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;
 }
 
 void

diff --git a/sim/ucsim/sim.src/uccl.h b/sim/ucsim/sim.src/uccl.h
index 41327401b5f2d6b7c7c898694e549457bd2cf1d3..dada96ec233ca2820c570a5d344e19dc41eb3b1a 100644 (file)
--- a/sim/ucsim/sim.src/uccl.h
+++ b/sim/ucsim/sim.src/uccl.h
@@ -245,11 +245,13 @@ public:
 
 #include "errorcl.h"
 
-ERROR_CLASS_DECL(unknown_code): public cl_error
+class cl_error_unknown_code: public cl_error
 {
- protected:
+private:
+  static class cl_error_class *error_unknown_code_class;
+protected:
   class cl_uc *uc;
- public:
+public:
   cl_error_unknown_code(class cl_uc *the_uc);
 
   virtual void print(class cl_commander *c);