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
+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:
2005-11-02 Borut Razem <borut.razem AT siol.net>
* sim/ucsim/cmd.src/cmdutil.cc, sim/ucsim/cmd.src/newcmd.cc:
cmdline->param(1),
cmdline->param(2),
cmdline->param(3) };*/
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;
-class cl_error_class error_class_base(err_error, "non-classified", ERROR_ON);
-
class cl_list *registered_errors= NIL;
/*
*/
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,
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*/):
registered_errors->add(this);
}
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,
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*/):
+class cl_error_class *cl_error::error_class_base;
+
cl_error::cl_error(void):
cl_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);
+ classification= error_class_base;
}
cl_error::~cl_error(void)
}
cl_error::~cl_error(void)
const int err_stop= (err_unknown|err_error);
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
extern class cl_list *registered_errors;
class cl_error_class: public cl_base
//char *name;
enum error_on_off on;
public:
//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,
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,
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);
enum error_on_off get_on(void) { return(on); }
void set_on(enum error_on_off val);
//char *get_name(void);
};
//char *get_name(void);
};
-extern class cl_error_class error_class_base;
-
-
class cl_commander; //forward
class cl_error: public cl_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:
protected:
class cl_error_class *classification;
public:
cl_error(void);
virtual ~cl_error(void);
virtual int init(void);
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);
public:
virtual enum error_type get_type(void);
virtual enum error_on_off get_on(void);
*/
/* All of memory errors */
*/
/* 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;
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 */
}
/* 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)
{
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;
}
/* Non-decoded address space access */
}
/* 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)
{
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;
-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;
protected:
class cl_memory *mem;
t_addr addr;
cl_error_mem(class cl_memory *amem, t_addr aaddr);
};
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);
};
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);
public:
cl_error_mem_non_decoded(class cl_memory *amem, t_addr aaddr);
-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 */
/* 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 */
/* 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;
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;
}
/* Stack Tracker: operation on empty stack */
}
/* 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();
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)
}
cl_error_stack_tracker_empty::~cl_error_stack_tracker_empty(void)
}
/* Stack Tracker: operation on empty stack */
}
/* 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):
cl_error_stack_tracker_unmatch::
cl_error_stack_tracker_unmatch(class cl_stack_op *Top, class cl_stack_op *op):
{
top= Top->mk_copy();
operation= op->mk_copy();
{
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)
}
cl_error_stack_tracker_unmatch::~cl_error_stack_tracker_unmatch(void)
}
/* Stack Tracker: stack is inconsistent */
}
/* 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,
cl_error_stack_tracker_inconsistent::
cl_error_stack_tracker_inconsistent(class cl_stack_op *op,
{
operation= op->mk_copy();
unread_data_size= the_unread_data_size;
{
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)
}
cl_error_stack_tracker_inconsistent::~cl_error_stack_tracker_inconsistent(void)
*/
//extern class cl_error_class error_stack_class;
//class cl_error_stack: public cl_error
*/
//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;
- cl_error_stack(void) { classification= &error_stack_class; }
};
/*
* All kind of stack tracker errors
*/
};
/*
* 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;
- 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:
public:
bool write_operation;
public:
virtual void print(class cl_commander *c);
};
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:
protected:
class cl_stack_op *operation;
public:
virtual void print(class cl_commander *c);
};
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:
protected:
class cl_stack_op *top, *operation;
public:
virtual void print(class cl_commander *c);
};
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;
protected:
class cl_stack_op *operation;
int unread_data_size;
*----------------------------------------------------------------------------
*/
*----------------------------------------------------------------------------
*/
-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;
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;
-ERROR_CLASS_DECL(unknown_code): public cl_error
+class cl_error_unknown_code: public cl_error
+private:
+ static class cl_error_class *error_unknown_code_class;
+protected:
cl_error_unknown_code(class cl_uc *the_uc);
virtual void print(class cl_commander *c);
cl_error_unknown_code(class cl_uc *the_uc);
virtual void print(class cl_commander *c);