853 lines
16 KiB
C++
853 lines
16 KiB
C++
/*
|
|
* Simulator of microcontrollers (option.cc)
|
|
*
|
|
* Copyright (C) 1997,16 Drotos Daniel, Talker Bt.
|
|
*
|
|
* To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
|
|
*
|
|
*/
|
|
|
|
/* This file is part of microcontroller simulator: ucsim.
|
|
|
|
UCSIM is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
UCSIM is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with UCSIM; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA. */
|
|
/*@1@*/
|
|
|
|
#include "ddconfig.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include "i_string.h"
|
|
|
|
// local, prj
|
|
#include "stypes.h"
|
|
#include "optioncl.h"
|
|
#include "globals.h"
|
|
#include "utils.h"
|
|
|
|
// sim.src
|
|
#include "simcl.h"
|
|
|
|
|
|
/*struct id_element option_type_names[]= {
|
|
{ non_opt , "non" },
|
|
{ integer_opt , "integer" },
|
|
{ float_opt , "float" },
|
|
{ bool_opt , "boolean" },
|
|
{ string_opt , "string" },
|
|
{ pointer_opt , "pointer" },
|
|
{ 0, 0 }
|
|
};*/
|
|
|
|
/*
|
|
* Base class for option's objects
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_option::cl_option(class cl_base *the_creator, const char *aname, const char *Ihelp):
|
|
cl_base()
|
|
{
|
|
creator= the_creator;
|
|
set_name(aname);
|
|
help= strdup(Ihelp);
|
|
char *s= (char*)malloc(strlen(aname)+100);
|
|
sprintf(s, "users of option \"%s\"", aname);
|
|
users= new cl_list(2, 2, s);
|
|
free(s);
|
|
memset(&value, 0, sizeof(value));
|
|
show();
|
|
}
|
|
|
|
class cl_option &
|
|
cl_option::operator=(class cl_option &o)
|
|
{
|
|
//memcpy(&value, &(o.value), sizeof(union option_value));
|
|
//fprintf(stderr,"opt%p\"%s\"=%p\"%s\"\nold=%p\n",this,object_name(this),&o,object_name(&o),value.sval);
|
|
value= o.value;
|
|
//fprintf(stderr,"new=%p\n",value.sval);
|
|
inform_users();
|
|
return(*this);
|
|
}
|
|
|
|
cl_option::~cl_option(void)
|
|
{
|
|
users->disconn_all();
|
|
delete users;
|
|
free(help);
|
|
}
|
|
|
|
void
|
|
cl_option::pre_remove(void)
|
|
{
|
|
int i;
|
|
|
|
for (i= 0; i < users->count; i++)
|
|
{
|
|
class cl_optref *user= (class cl_optref *)(users->at(i));
|
|
user->option_removing();
|
|
}
|
|
}
|
|
|
|
void
|
|
cl_option::new_reference(class cl_optref *ref)
|
|
{
|
|
users->add(ref);
|
|
}
|
|
|
|
void
|
|
cl_option::del_reference(class cl_optref *ref)
|
|
{
|
|
users->disconn(ref);
|
|
}
|
|
|
|
void
|
|
cl_option::inform_users(void)
|
|
{
|
|
int i;
|
|
|
|
for (i= 0; i < users->count; i++)
|
|
{
|
|
class cl_optref *user= (class cl_optref *)(users->at(i));
|
|
//fprintf(stderr,"%p\"%s\" informs user %p\"%s\"\n",this,object_name(this),user,object_name(user));
|
|
user->option_changed();
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
cl_option::get_value(bool *val)
|
|
{
|
|
if (val)
|
|
*val= value.bval;
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(bool opt)
|
|
{
|
|
value.bval= opt;
|
|
inform_users();
|
|
}
|
|
|
|
|
|
void
|
|
cl_option::get_value(char **val)
|
|
{
|
|
if (val)
|
|
{
|
|
*val= value.sval;
|
|
}
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(char *opt)
|
|
{
|
|
//fprintf(stderr,"set_string_value (%s) to %p\"%s\"\n",opt,this,object_name(this));
|
|
//fprintf(stderr,"old value=%p\"%s\"\n",value.sval,value.sval);
|
|
if (value.sval)
|
|
free(value.sval);
|
|
if (opt &&
|
|
*opt)
|
|
value.sval= strdup(opt);
|
|
else
|
|
value.sval= strdup("");
|
|
//fprintf(stderr,"new value=%p\"%s\"\n",value.sval,value.sval);
|
|
inform_users();
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(const char *opt)
|
|
{
|
|
set_value(cchars(opt));
|
|
}
|
|
|
|
void
|
|
cl_option::get_value(void **val)
|
|
{
|
|
if (val)
|
|
*val= value.pval;
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(void *opt)
|
|
{
|
|
value.pval= opt;
|
|
inform_users();
|
|
}
|
|
|
|
|
|
void
|
|
cl_option::get_value(long *val)
|
|
{
|
|
if (val)
|
|
*val= value.ival;
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(long opt)
|
|
{
|
|
value.ival= opt;
|
|
inform_users();
|
|
}
|
|
|
|
|
|
void
|
|
cl_option::get_value(double *val)
|
|
{
|
|
if (val)
|
|
*val= value.fval;
|
|
}
|
|
|
|
void
|
|
cl_option::set_value(double opt)
|
|
{
|
|
value.fval= opt;
|
|
inform_users();
|
|
}
|
|
|
|
|
|
/*
|
|
* List of options
|
|
*/
|
|
|
|
void *
|
|
cl_options::key_of(void *item)
|
|
{
|
|
return (void*)(((class cl_base *)item)->get_name());
|
|
}
|
|
|
|
int
|
|
cl_options::compare(void *key1, void *key2)
|
|
{
|
|
//class cl_option *k1, *k2;
|
|
int i;
|
|
char *k1, *k2;
|
|
|
|
k1= /*(class cl_option *)*/(char *)key1;
|
|
k2= /*(class cl_option *)*/(char *)key2;
|
|
if ((i= strcmp(k1, k2)) != 0)
|
|
return(i);
|
|
return(i);
|
|
}
|
|
|
|
void
|
|
cl_options::new_option(class cl_option *opt)
|
|
{
|
|
add(opt);
|
|
}
|
|
|
|
void
|
|
cl_options::del_option(class cl_option *opt)
|
|
{
|
|
opt->pre_remove();
|
|
disconn(opt);
|
|
delete opt;
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::get_option(const char *the_name)
|
|
{
|
|
t_index idx;
|
|
|
|
if (search((void*)the_name, idx))
|
|
return((class cl_option *)(at(idx)));
|
|
return(0);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::get_option(const char *the_name, class cl_base *creator)
|
|
{
|
|
t_index idx;
|
|
class cl_option *o;
|
|
|
|
if (!search((void*)the_name, idx))
|
|
return(0);
|
|
if (idx > 0)
|
|
{
|
|
idx--;
|
|
o= (class cl_option *)(at(idx));
|
|
while (compare((void*)the_name, key_of(o)) == 0 &&
|
|
idx > 0)
|
|
{
|
|
idx--;
|
|
o= (class cl_option *)(at(idx));
|
|
}
|
|
if (compare((void*)the_name, key_of(o)) != 0)
|
|
idx++;
|
|
}
|
|
o= (class cl_option *)(at(idx));
|
|
while (compare((void*)the_name, key_of(o)) == 0 &&
|
|
o->get_creator() != creator &&
|
|
idx < count)
|
|
{
|
|
idx++;
|
|
o= (class cl_option *)(at(idx));
|
|
if (compare((void*)the_name, key_of(o)) == 0 &&
|
|
o->get_creator() == creator)
|
|
return(o);
|
|
}
|
|
if (compare((void*)the_name, key_of(o)) == 0 &&
|
|
o->get_creator() == creator)
|
|
return(o);
|
|
return(0);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::get_option(const char *the_name, char *creator)
|
|
{
|
|
t_index idx;
|
|
class cl_option *o;
|
|
|
|
if (!search((void*)the_name, idx))
|
|
return(0);
|
|
if (idx > 0)
|
|
{
|
|
idx--;
|
|
o= (class cl_option *)(at(idx));
|
|
while (compare((void*)the_name, key_of(o)) == 0 &&
|
|
idx > 0)
|
|
{
|
|
idx--;
|
|
o= (class cl_option *)(at(idx));
|
|
}
|
|
if (compare((void*)the_name, key_of(o)) != 0)
|
|
idx++;
|
|
}
|
|
o= (class cl_option *)(at(idx));
|
|
while (compare((void*)the_name, key_of(o)) == 0 &&
|
|
strcmp(object_name(o->get_creator()), creator) != 0 &&
|
|
idx < count)
|
|
{
|
|
idx++;
|
|
o= (class cl_option *)(at(idx));
|
|
if (compare((void*)the_name, key_of(o)) == 0 &&
|
|
strcmp(object_name(o->get_creator()), creator) == 0)
|
|
return(o);
|
|
}
|
|
if (compare((void*)the_name, key_of(o)) == 0 &&
|
|
strcmp(object_name(o->get_creator()), creator) == 0)
|
|
return(o);
|
|
return(0);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::get_option(int idx)
|
|
{
|
|
if (idx >= count)
|
|
return(0);
|
|
return((class cl_option *)(at(idx)));
|
|
}
|
|
|
|
int
|
|
cl_options::nuof_options(char *the_name)
|
|
{
|
|
int i, n= 0;
|
|
|
|
for (i= 0; i < count; i++)
|
|
{
|
|
class cl_option *o= (class cl_option *)(at(i));
|
|
if (strcmp(the_name, o->get_name()) == 0)
|
|
n++;
|
|
}
|
|
return(n);
|
|
}
|
|
|
|
int
|
|
cl_options::nuof_options(char *the_name, char *creator)
|
|
{
|
|
int i, n= 0;
|
|
|
|
for (i= 0; i < count; i++)
|
|
{
|
|
class cl_option *o= (class cl_option *)(at(i));
|
|
if (strcmp(the_name, o->get_name()) == 0 &&
|
|
strcmp(creator, object_name(o->get_creator())) == 0)
|
|
n++;
|
|
}
|
|
return(n);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::set_value(const char *the_name, cl_base *creator, bool value)
|
|
{
|
|
class cl_option *o= get_option(the_name, creator);
|
|
|
|
if (o)
|
|
o->set_value(value);
|
|
return(o);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::set_value(const char *the_name, cl_base *creator, char *value)
|
|
{
|
|
class cl_option *o= get_option(the_name, creator);
|
|
|
|
if (o)
|
|
o->set_value(value);
|
|
return(o);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::set_value(const char *the_name, cl_base *creator, void *value)
|
|
{
|
|
class cl_option *o= get_option(the_name, creator);
|
|
|
|
if (o)
|
|
o->set_value(value);
|
|
return(o);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::set_value(const char *the_name, cl_base *creator, long value)
|
|
{
|
|
class cl_option *o= get_option(the_name, creator);
|
|
|
|
if (o)
|
|
o->set_value(value);
|
|
return(o);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_options::set_value(const char *the_name, cl_base *creator, double value)
|
|
{
|
|
class cl_option *o= get_option(the_name, creator);
|
|
|
|
if (o)
|
|
o->set_value(value);
|
|
return(o);
|
|
}
|
|
|
|
|
|
/*
|
|
* Reference to an option
|
|
*/
|
|
|
|
cl_optref::cl_optref(class cl_base *the_owner)
|
|
{
|
|
option =0;
|
|
owner= the_owner;
|
|
}
|
|
|
|
cl_optref::cl_optref(class cl_base *the_owner, class cl_option *new_option)
|
|
{
|
|
owner= the_owner;
|
|
option= new_option;
|
|
application->options->new_option(option);
|
|
if (option)
|
|
{
|
|
option->new_reference(this);
|
|
set_name(option->get_name());
|
|
}
|
|
}
|
|
|
|
cl_optref::~cl_optref(void)
|
|
{
|
|
if (option)
|
|
{
|
|
option->del_reference(this);
|
|
if (option->get_creator() == owner)
|
|
application->options->del_option(option);
|
|
}
|
|
}
|
|
|
|
class cl_option *
|
|
cl_optref::create(class cl_base *creator,
|
|
enum option_type type,
|
|
const char *the_name, const char *help)
|
|
{
|
|
if (option)
|
|
option->del_reference(this);
|
|
switch (type)
|
|
{
|
|
case non_opt:
|
|
option= 0;
|
|
break;
|
|
case integer_opt:
|
|
option= new cl_number_option(creator, the_name, help);
|
|
break;
|
|
case float_opt:
|
|
option= new cl_float_option(creator, the_name, help);
|
|
break;
|
|
case bool_opt:
|
|
option= new cl_bool_option(creator, the_name, help);
|
|
break;
|
|
case string_opt:
|
|
option= new cl_string_option(creator, the_name, help);
|
|
break;
|
|
case pointer_opt:
|
|
option= new cl_pointer_option(creator, the_name, help);
|
|
break;
|
|
default:
|
|
option= 0;
|
|
break;
|
|
}
|
|
if (option)
|
|
{
|
|
application->options->new_option(option);
|
|
option->new_reference(this);
|
|
set_name(option->get_name());
|
|
}
|
|
|
|
return(option);
|
|
}
|
|
|
|
void
|
|
cl_optref::default_option(const char *the_name)
|
|
{
|
|
class cl_option *o= application->options->get_option(the_name, application);
|
|
|
|
if (o &&
|
|
option)
|
|
{
|
|
//memcpy(option->get_value(), o->get_value(), sizeof(union option_value));
|
|
*option= *o;
|
|
option->inform_users();
|
|
}
|
|
/*else
|
|
fprintf(stderr,"can not set opt from default, option=%p, o=%p\n",option,o);*/
|
|
}
|
|
|
|
class cl_option *
|
|
cl_optref::use(void)
|
|
{
|
|
if (option)
|
|
{
|
|
option->del_reference(this);
|
|
option->new_reference(this);
|
|
}
|
|
return(option);
|
|
}
|
|
|
|
class cl_option *
|
|
cl_optref::use(const char *the_name)
|
|
{
|
|
if (option)
|
|
option->del_reference(this);
|
|
option= application->options->get_option(the_name);
|
|
if (option)
|
|
{
|
|
option->new_reference(this);
|
|
set_name(option->get_name());
|
|
}
|
|
return(option);
|
|
}
|
|
|
|
void
|
|
cl_optref::option_removing(void)
|
|
{
|
|
option= 0;
|
|
}
|
|
|
|
bool
|
|
cl_optref::get_value(bool)
|
|
{
|
|
if (!option)
|
|
{
|
|
fprintf(stderr, "Warning: \"%s\" is dereferencing a non-existent "
|
|
"bool option: %s\n", object_name(owner), get_name());
|
|
return(false);
|
|
}
|
|
else
|
|
{
|
|
bool v;
|
|
option->get_value(&v);
|
|
return(v);
|
|
}
|
|
}
|
|
|
|
char *
|
|
cl_optref::get_value(const char *)
|
|
{
|
|
if (!option)
|
|
{
|
|
char *o= (char *)object_name(owner);
|
|
char *n= (char *)get_name();
|
|
fprintf(stderr, "Warning: \"%s\" is dereferencing a non-existent "
|
|
"string option: %s\n", o, n?n:"?");
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
char *s= 0;
|
|
option->get_value(&s);
|
|
return(s);
|
|
}
|
|
}
|
|
|
|
void *
|
|
cl_optref::get_value(void *)
|
|
{
|
|
if (!option)
|
|
{
|
|
fprintf(stderr, "Warning: \"%s\" is dereferencing a non-existent "
|
|
"pointer option: %s\n", object_name(owner), get_name());
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
void *p= 0;
|
|
option->get_value(&p);
|
|
return(p);
|
|
}
|
|
}
|
|
|
|
long
|
|
cl_optref::get_value(long)
|
|
{
|
|
if (!option)
|
|
{
|
|
fprintf(stderr, "Warning: \"%s\" is dereferencing a non-existent "
|
|
"number option: %s\n", object_name(owner), get_name());
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
long l= 0;
|
|
option->get_value(&l);
|
|
return(l);
|
|
}
|
|
}
|
|
|
|
double
|
|
cl_optref::get_value(double)
|
|
{
|
|
if (!option)
|
|
{
|
|
fprintf(stderr, "Warning: \"%s\" is dereferencing a non-existent "
|
|
"float option: %s\n", object_name(owner), get_name());
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
double d= 0;
|
|
option->get_value(&d);
|
|
return(d);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL type of option
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_bool_option::cl_bool_option(class cl_base *the_creator,
|
|
const char *aname, const char *Ihelp):
|
|
cl_option(the_creator, aname, Ihelp)
|
|
{}
|
|
|
|
void
|
|
cl_bool_option::print(class cl_console_base *con)
|
|
{
|
|
if (/**(bool *)option*/value.bval)
|
|
con->dd_printf("TRUE");
|
|
else
|
|
con->dd_printf("FALSE");
|
|
}
|
|
|
|
void
|
|
cl_bool_option::set_value(char *s)
|
|
{
|
|
char c;
|
|
|
|
if (s)
|
|
{
|
|
c= toupper(*s);
|
|
if (c == '1' ||
|
|
c == 'T' ||
|
|
c == 'Y')
|
|
/**(bool *)option=*/ value.bval= true;
|
|
else
|
|
/**(bool *)option=*/ value.bval= false;
|
|
}
|
|
inform_users();
|
|
}
|
|
|
|
|
|
/*
|
|
* STRING type of option
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_string_option::cl_string_option(class cl_base *the_creator,
|
|
const char *aname, const char *Ihelp):
|
|
cl_option(the_creator, aname, Ihelp)
|
|
{}
|
|
|
|
class cl_option &
|
|
cl_string_option::operator=(class cl_option &o)
|
|
{
|
|
//fprintf(stderr,"string=otheropt%p\"%s\"\nold=%p\"%s\"\n",&o,object_name(&o),value.sval,value.sval);
|
|
set_value((o.get_value())->sval);
|
|
//fprintf(stderr,"new=%p\"%s\"\n",value.sval,value.sval);
|
|
return(*this);
|
|
}
|
|
|
|
void
|
|
cl_string_option::print(class cl_console_base *con)
|
|
{
|
|
if (/**(bool *)option*/value.sval)
|
|
con->dd_printf("\"%s\"", value.sval);
|
|
else
|
|
con->dd_printf("(null)");
|
|
}
|
|
|
|
|
|
/*
|
|
* PONITER type of option
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_pointer_option::cl_pointer_option(class cl_base *the_creator,
|
|
const char *aname, const char *Ihelp):
|
|
cl_option(the_creator, aname, Ihelp)
|
|
{}
|
|
|
|
class cl_option &
|
|
cl_pointer_option::operator=(class cl_option &o)
|
|
{
|
|
set_value((o.get_value())->pval);
|
|
return(*this);
|
|
}
|
|
|
|
void
|
|
cl_pointer_option::print(class cl_console_base *con)
|
|
{
|
|
if (value.pval)
|
|
con->dd_printf("\"%p\"", value.pval);
|
|
else
|
|
con->dd_printf("(null)");
|
|
}
|
|
|
|
|
|
/*
|
|
* Debug on console
|
|
*/
|
|
/*
|
|
cl_cons_debug_opt::cl_cons_debug_opt(class cl_app *the_app,
|
|
char *Iid,
|
|
const char *Ihelp):
|
|
cl_option(0, Iid, Ihelp)
|
|
{
|
|
app= the_app;
|
|
}
|
|
|
|
void
|
|
cl_cons_debug_opt::print(class cl_console_base *con)
|
|
{
|
|
if (con->flags & CONS_DEBUG)
|
|
con->dd_printf("TRUE");
|
|
else
|
|
con->dd_printf("FALSE");
|
|
}
|
|
|
|
void
|
|
cl_cons_debug_opt::get_value(bool *val)
|
|
{
|
|
if (val)
|
|
*val= app->get_commander()->actual_console?
|
|
(app->get_commander()->actual_console->flags & CONS_DEBUG):0;
|
|
}
|
|
|
|
void
|
|
cl_cons_debug_opt::set_value(bool opt)
|
|
{
|
|
if (app->get_commander()->actual_console)
|
|
{
|
|
if (opt)
|
|
app->get_commander()->actual_console->flags|= CONS_DEBUG;
|
|
else
|
|
app->get_commander()->actual_console->flags&= ~CONS_DEBUG;
|
|
}
|
|
inform_users();
|
|
}
|
|
|
|
void
|
|
cl_cons_debug_opt::set_value(char *s)
|
|
{
|
|
char c;
|
|
|
|
if (s &&
|
|
app->get_commander()->actual_console)
|
|
{
|
|
c= toupper(*s);
|
|
if (c == '1' ||
|
|
c == 'T' ||
|
|
c == 'Y')
|
|
set_value(1);
|
|
else
|
|
set_value(0);
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
* NUMBER type of option
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_number_option::cl_number_option(class cl_base *the_creator,
|
|
const char *aname, const char *Ihelp):
|
|
cl_option(the_creator, aname, Ihelp)
|
|
{}
|
|
|
|
void
|
|
cl_number_option::print(class cl_console_base *con)
|
|
{
|
|
con->dd_printf("%ld", value.ival);
|
|
}
|
|
|
|
void
|
|
cl_number_option::set_value(char *s)
|
|
{
|
|
if (s)
|
|
value.ival= strtol(s, 0, 0);
|
|
inform_users();
|
|
}
|
|
|
|
|
|
/*
|
|
* FLOAT type of option
|
|
*____________________________________________________________________________
|
|
*
|
|
*/
|
|
|
|
cl_float_option::cl_float_option(class cl_base *the_creator,
|
|
const char *aname, const char *Ihelp):
|
|
cl_option(the_creator, aname, Ihelp)
|
|
{}
|
|
|
|
void
|
|
cl_float_option::print(class cl_console_base *con)
|
|
{
|
|
con->dd_printf("%.3f", value.fval);
|
|
}
|
|
|
|
void
|
|
cl_float_option::set_value(char *s)
|
|
{
|
|
if (s)
|
|
value.fval= strtod(s, 0);
|
|
inform_users();
|
|
}
|
|
|
|
|
|
/* End of option.cc */
|