mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Avoid doing strdup for param name field - most of the strdups elliminated !

Browse Source
This commit is contained in:
Stanislav Shwartsman 2006-05-29 22:33:38 +00:00
parent cabc1d0181
commit fee48d74e0
28 changed files with 205 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
bochs/config.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: config.cc,v 1.104 2006-04-25 15:59:20 mcb30 Exp $
// $Id: config.cc,v 1.105 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -457,7 +457,7 @@ void bx_init_options()
sprintf(name, "%d", i+1);
sprintf(descr, "Pathname of optional ROM image #%d to load", i+1);
sprintf(label, "Optional ROM image #%d", i+1);
bx_list_c *optnum1 = new bx_list_c(optrom, strdup(name), label);
bx_list_c *optnum1 = new bx_list_c(optrom, name, label);
path = new bx_param_filename_c(optnum1,
"path",
"Path",
@ -486,7 +486,7 @@ void bx_init_options()
sprintf(name, "%d", i+1);
sprintf(descr, "Pathname of optional RAM image #%d to load", i+1);
sprintf(label, "Optional RAM image #%d", i+1);
bx_list_c *optnum2 = new bx_list_c(optram, strdup(name), label);
bx_list_c *optnum2 = new bx_list_c(optram, name, label);
path = new bx_param_filename_c(optnum2,
"path",
"Path",
@ -584,7 +584,7 @@ void bx_init_options()
sprintf (descr, "Name of the device connected to PCI slot #%d", i+1);
sprintf (label, "PCI slot #%d device", i+1);
bx_param_string_c *devname = new bx_param_string_c(slot,
strdup(name),
name,
strdup(label),
strdup(descr),
"", BX_PATHNAME_LEN);
@ -837,7 +837,7 @@ void bx_init_options()
sprintf(label, "Boot drive #%d", i+1);
sprintf(descr, "Name of drive #%d in boot sequence (A, C or CD)", i+1);
bx_param_enum_c *bootdrive = new bx_param_enum_c(boot_params,
strdup(name),
name,
strdup(label),
strdup(descr),
&bochs_bootdisk_names[(i==0)?BX_BOOT_FLOPPYA:BX_BOOT_NONE],
@ -1020,7 +1020,7 @@ void bx_init_options()
for (channel=0; channel<BX_MAX_ATA_CHANNEL; channel++) {
sprintf(name, "%d", channel);
ata_menu[channel] = new bx_list_c(ata, strdup(name), s_atachannel[channel]);
ata_menu[channel] = new bx_list_c(ata, name, s_atachannel[channel]);
ata_menu[channel]->get_options()->set(bx_list_c::USE_TAB_WINDOW);
ata_res[channel] = new bx_list_c(ata_menu[channel], "resources", s_atachannel[channel], 8);
ata_res[channel]->get_options()->set(bx_list_c::SERIES_ASK);
@ -1066,9 +1066,8 @@ void bx_init_options()
enabled->set_dependent_list(ata_res[channel]->clone());
for (Bit8u slave=0; slave<2; slave++) {
menu = new bx_list_c(ata_menu[channel],
strdup(s_atadevname[slave]),
s_atadevname[slave],
s_atadevice[channel][slave],
BXP_PARAMS_PER_ATA_DEVICE + 1);
menu->get_options()->set(bx_list_c::SERIES_ASK);
@ -1230,7 +1229,7 @@ void bx_init_options()
for (i=0; i<BX_N_PARALLEL_PORTS; i++) {
sprintf(name, "%d", i+1);
sprintf(label, "Parallel Port %d", i+1);
menu = new bx_list_c(parallel, strdup(name), label);
menu = new bx_list_c(parallel, name, label);
menu->get_options()->set(bx_list_c::SERIES_ASK);
sprintf(label, "Enable parallel port #%d", i+1);
sprintf(descr, "Controls whether parallel port #%d is installed or not", i+1);
@ -1267,7 +1266,7 @@ void bx_init_options()
for (i=0; i<BX_N_SERIAL_PORTS; i++) {
sprintf(name, "%d", i+1);
sprintf(label, "Serial Port %d", i+1);
menu = new bx_list_c(serial, strdup(name), label);
menu = new bx_list_c(serial, name, label);
menu->get_options()->set(bx_list_c::SERIES_ASK);
sprintf(label, "Enable serial port #%d (COM%d)", i+1, i+1);
sprintf(descr, "Controls whether COM%d is installed or not", i+1);
@ -1308,7 +1307,7 @@ void bx_init_options()
sprintf(group, "USB%d", i+1);
sprintf(name, "%d", i+1);
sprintf(label, "USB Hub %d", i+1);
menu = new bx_list_c(usb, strdup(name), label);
menu = new bx_list_c(usb, name, label);
menu->set_enabled(BX_SUPPORT_PCIUSB);
sprintf(label, "Enable usb hub #%d", i+1);
sprintf(descr, "Controls whether %s is installed or not", group);
@ -1902,7 +1901,7 @@ static Bit32s parse_line_unformatted(const char *context, char *line)
params[num_params] = NULL;
}
if (num_params < MAX_PARAMS_LEN) {
params[num_params++] = strdup (string);
params[num_params++] = strdup(string);
} else {
BX_PANIC (("too many parameters, max is %d\n", MAX_PARAMS_LEN));
}

10
bochs/cpu/apic.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: apic.cc,v 1.88 2006-05-28 17:07:57 sshwarts Exp $
// $Id: apic.cc,v 1.89 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -922,9 +922,9 @@ void bx_local_apic_c::register_state(bx_param_c *parent)
bx_list_c *IRR = new bx_list_c(parent, "irr", BX_LOCAL_APIC_MAX_INTS);
for (i=0; i<BX_LOCAL_APIC_MAX_INTS; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(ISR, strdup(name), &isr[i]);
new bx_shadow_num_c(TMR, strdup(name), &tmr[i]);
new bx_shadow_num_c(IRR, strdup(name), &irr[i]);
new bx_shadow_num_c(ISR, name, &isr[i]);
new bx_shadow_num_c(TMR, name, &tmr[i]);
new bx_shadow_num_c(IRR, name, &irr[i]);
}
BXRS_HEX_PARAM_SIMPLE(parent, error_status);
@ -935,7 +935,7 @@ void bx_local_apic_c::register_state(bx_param_c *parent)
bx_list_c *LVT = new bx_list_c(parent, "lvt", APIC_LVT_ENTRIES);
for (i=0; i<APIC_LVT_ENTRIES; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(LVT, strdup(name), &lvt[i], BASE_HEX);
new bx_shadow_num_c(LVT, name, &lvt[i], BASE_HEX);
}
BXRS_HEX_PARAM_SIMPLE(parent, timer_initial);

24
bochs/cpu/init.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: init.cc,v 1.109 2006-05-28 19:18:29 sshwarts Exp $
// $Id: init.cc,v 1.110 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -266,8 +266,9 @@ void BX_CPU_C::initialize(BX_MEM_C *addrspace)
const char *oldfmt = bx_param_num_c::set_default_format(fmt32);
sprintf(cpu_name, "%d", BX_CPU_ID);
sprintf(cpu_title, "CPU %d", BX_CPU_ID);
bx_list_c *list = new bx_list_c(SIM->get_param(BXPN_WX_CPU_STATE), strdup(cpu_name),
cpu_title, 60);
bx_list_c *list = new bx_list_c(SIM->get_param(BXPN_WX_CPU_STATE),
cpu_name, cpu_title, 60);
#define DEFPARAM_NORMAL(name,field) \
new bx_shadow_num_c(list, #name, &(field))
@ -385,8 +386,9 @@ void BX_CPU_C::register_state(void)
sprintf(cpu_name, "%d", BX_CPU_ID);
sprintf(cpu_title, "CPU %d", BX_CPU_ID);
bx_list_c *list = new bx_list_c(SIM->get_param("save_restore.cpu"), strdup(cpu_name),
cpu_title, 60);
bx_list_c *list = new bx_list_c(SIM->get_param("save_restore.cpu"),
cpu_name, cpu_title, 60);
BXRS_PARAM_SPECIAL32(list, cpu_version, param_save_handler, param_restore_handler);
BXRS_PARAM_SPECIAL32(list, cpuid_std, param_save_handler, param_restore_handler);
BXRS_PARAM_SPECIAL32(list, cpuid_ext, param_save_handler, param_restore_handler);
@ -439,7 +441,7 @@ void BX_CPU_C::register_state(void)
for(i=0; i<6; i++) {
bx_segment_reg_t *segment = &BX_CPU_THIS_PTR sregs[i];
bx_list_c *sreg = new bx_list_c(list, strdup(strseg(segment)), 9);
bx_list_c *sreg = new bx_list_c(list, strseg(segment), 9);
BXRS_PARAM_SPECIAL16(sreg, selector,
param_save_handler, param_restore_handler);
BXRS_HEX_PARAM_FIELD(sreg, base, segment->cache.u.segment.base);
@ -515,7 +517,7 @@ void BX_CPU_C::register_state(void)
BXRS_HEX_PARAM_FIELD(fpu, fdp, the_i387.fdp);
for (i=0; i<8; i++) {
sprintf(name, "st%d", i);
bx_list_c *STx = new bx_list_c(fpu, strdup(name), 8);
bx_list_c *STx = new bx_list_c(fpu, name, 8);
BXRS_HEX_PARAM_FIELD(STx, exp, the_i387.st_space[i].exp);
BXRS_HEX_PARAM_FIELD(STx, fraction, the_i387.st_space[i].fraction);
}
@ -527,9 +529,9 @@ void BX_CPU_C::register_state(void)
BXRS_HEX_PARAM_FIELD(sse, mxcsr, mxcsr.mxcsr);
for (i=0; i<BX_XMM_REGISTERS; i++) {
sprintf(name, "xmm%02d_hi", i);
new bx_shadow_num_c(sse, strdup(name), &BX_CPU_THIS_PTR xmm[i].xmm64u(1), BASE_HEX);
new bx_shadow_num_c(sse, name, &BX_CPU_THIS_PTR xmm[i].xmm64u(1), BASE_HEX);
sprintf(name, "xmm%02d_lo", i);
new bx_shadow_num_c(sse, strdup(name), &BX_CPU_THIS_PTR xmm[i].xmm64u(0), BASE_HEX);
new bx_shadow_num_c(sse, name, &BX_CPU_THIS_PTR xmm[i].xmm64u(0), BASE_HEX);
}
#endif
@ -559,7 +561,7 @@ Bit64s BX_CPU_C::param_save(bx_param_c *param, Bit64s val)
#else
UNUSED(devptr);
#endif // !BX_USE_CPU_SMF
char *pname, *segname;
const char *pname, *segname;
bx_segment_reg_t *segment = NULL;
pname = param->get_name();
@ -619,7 +621,7 @@ Bit64s BX_CPU_C::param_restore(bx_param_c *param, Bit64s val)
#else
UNUSED(devptr);
#endif // !BX_USE_CPU_SMF
char *pname, *segname;
const char *pname, *segname;
bx_segment_reg_t *segment = NULL;
pname = param->get_name();

97
bochs/gui/siminterface.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: siminterface.cc,v 1.153 2006-05-29 19:57:12 sshwarts Exp $
// $Id: siminterface.cc,v 1.154 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// See siminterface.h for description of the siminterface concept.
@ -47,7 +47,7 @@ class bx_real_sim_c : public bx_simulator_interface_c {
unsigned param_id;
public:
bx_real_sim_c();
virtual ~bx_real_sim_c();
virtual ~bx_real_sim_c() {}
virtual void set_quit_context(jmp_buf *context) { quit_context = context; }
virtual int get_init_done() { return init_done; }
virtual int set_init_done(int n) { init_done = n; return 0;}
@ -192,8 +192,7 @@ static bx_param_c *find_param(const char *full_pname, const char *rest_of_pname,
return find_param(full_pname, from, child);
}
bx_param_c *
bx_real_sim_c::get_param(const char *pname, bx_param_c *base)
bx_param_c *bx_real_sim_c::get_param(const char *pname, bx_param_c *base)
{
if (base == NULL)
base = root_param;
@ -203,8 +202,8 @@ bx_real_sim_c::get_param(const char *pname, bx_param_c *base)
return find_param(pname, pname, base);
}
bx_param_num_c *
bx_real_sim_c::get_param_num (const char *pname, bx_param_c *base) {
bx_param_num_c *bx_real_sim_c::get_param_num (const char *pname, bx_param_c *base)
{
bx_param_c *generic = get_param(pname, base);
if (generic==NULL) {
BX_PANIC(("get_param_num(%s) could not find a parameter", pname));
@ -217,8 +216,8 @@ bx_real_sim_c::get_param_num (const char *pname, bx_param_c *base) {
return NULL;
}
bx_param_string_c *
bx_real_sim_c::get_param_string(const char *pname, bx_param_c *base) {
bx_param_string_c *bx_real_sim_c::get_param_string(const char *pname, bx_param_c *base)
{
bx_param_c *generic = get_param(pname, base);
if (generic==NULL) {
BX_PANIC (("get_param_string(%s) could not find a parameter", pname));
@ -230,8 +229,8 @@ bx_real_sim_c::get_param_string(const char *pname, bx_param_c *base) {
return NULL;
}
bx_param_bool_c *
bx_real_sim_c::get_param_bool(const char *pname, bx_param_c *base) {
bx_param_bool_c *bx_real_sim_c::get_param_bool(const char *pname, bx_param_c *base)
{
bx_param_c *generic = get_param(pname, base);
if (generic==NULL) {
BX_PANIC(("get_param_bool(%s) could not find a parameter", pname));
@ -243,8 +242,8 @@ bx_real_sim_c::get_param_bool(const char *pname, bx_param_c *base) {
return NULL;
}
bx_param_enum_c *
bx_real_sim_c::get_param_enum(const char *pname, bx_param_c *base) {
bx_param_enum_c *bx_real_sim_c::get_param_enum(const char *pname, bx_param_c *base)
{
bx_param_c *generic = get_param(pname, base);
if (generic==NULL) {
BX_PANIC(("get_param_enum(%s) could not find a parameter", pname));
@ -286,10 +285,6 @@ void bx_init_siminterface()
}
}
bx_simulator_interface_c::bx_simulator_interface_c()
{
}
bx_real_sim_c::bx_real_sim_c()
{
bxevent_callback = NULL;
@ -307,10 +302,6 @@ bx_real_sim_c::bx_real_sim_c()
n_user_options = 0;
}
bx_real_sim_c::~bx_real_sim_c()
{
}
void bx_real_sim_c::reset_all_param()
{
bx_reset_options();
@ -1198,11 +1189,12 @@ void bx_object_c::set_type(bx_objtype type)
const char* bx_param_c::default_text_format = NULL;
bx_param_c::bx_param_c(Bit32u id, char *name, char *description)
bx_param_c::bx_param_c(Bit32u id, const char *param_name, char *description)
: bx_object_c(id)
{
set_type(BXT_PARAM);
this->name = name;
this->name = new char[strlen(param_name)+1];
strcpy(this->name, param_name);
this->description = description;
this->text_format = default_text_format;
this->long_text_format = default_text_format;
@ -1214,6 +1206,11 @@ bx_param_c::bx_param_c(Bit32u id, char *name, char *description)
this->parent = NULL;
}
bx_param_c::~bx_param_c()
{
delete [] name;
}
int bx_param_c::get_param_path(char *path_out, int maxlen)
{
if ((get_parent() == NULL) || (get_parent() == root_param)) {
@ -1238,7 +1235,7 @@ const char* bx_param_c::set_default_format(const char *f)
}
bx_param_num_c::bx_param_num_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
Bit64s min, Bit64s max, Bit64s initial_val,
@ -1384,7 +1381,7 @@ void bx_param_num_c::set_enabled(int en)
// Signed 64 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit64s *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1403,7 +1400,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Unsigned 64 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit64u *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1422,7 +1419,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Signed 32 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit32s *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1441,7 +1438,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Unsigned 32 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit32u *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1460,7 +1457,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Signed 16 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit16s *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1479,7 +1476,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Unsigned 16 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit16u *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1498,7 +1495,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Signed 8 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit8s *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1518,7 +1515,7 @@ bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
// Unsigned 8 bit
bx_shadow_num_c::bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit8u *ptr_to_real_val,
int base,
Bit8u highbit,
@ -1596,7 +1593,7 @@ void bx_shadow_num_c::reset()
}
bx_param_bool_c::bx_param_bool_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
Bit64s initial_val,
@ -1607,7 +1604,7 @@ bx_param_bool_c::bx_param_bool_c(bx_param_c *parent,
}
bx_shadow_bool_c::bx_shadow_bool_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
bx_bool *ptr_to_real_val,
Bit8u bitnum)
@ -1618,7 +1615,7 @@ bx_shadow_bool_c::bx_shadow_bool_c(bx_param_c *parent,
}
bx_shadow_bool_c::bx_shadow_bool_c(bx_param_c *parent,
char *name,
const char *name,
bx_bool *ptr_to_real_val,
Bit8u bitnum)
: bx_param_bool_c(parent, name, NULL, NULL, (Bit64s) *ptr_to_real_val, 1)
@ -1652,7 +1649,7 @@ void bx_shadow_bool_c::set(Bit64s newval)
}
bx_param_enum_c::bx_param_enum_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char **choices,
@ -1691,10 +1688,10 @@ bx_bool bx_param_enum_c::set_by_name(const char *string)
}
bx_param_string_c::bx_param_string_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char *initial_val,
const char *initial_val,
int maxsize)
: bx_param_c(SIM->gen_param_id(), name, description)
{
@ -1720,7 +1717,7 @@ bx_param_string_c::bx_param_string_c(bx_param_c *parent,
}
bx_param_filename_c::bx_param_filename_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char *initial_val,
@ -1734,7 +1731,7 @@ bx_param_string_c::~bx_param_string_c()
{
if (this->val != NULL) delete [] this->val;
if (this->initial_val != NULL) delete [] this->initial_val;
if (this->options != NULL) delete [] this->options;
if (this->options != NULL) delete this->options;
}
void bx_param_string_c::reset()
@ -1799,7 +1796,8 @@ bx_bool bx_param_string_c::equals(const char *buf)
return (strncmp(val, buf, maxsize) == 0);
}
void bx_param_string_c::set_initial_val(char *buf) {
void bx_param_string_c::set_initial_val(const char *buf)
{
if (options->get() & RAW_BYTES)
memcpy(initial_val, buf, maxsize);
else
@ -1809,7 +1807,7 @@ void bx_param_string_c::set_initial_val(char *buf) {
#if BX_SUPPORT_SAVE_RESTORE
bx_shadow_data_c::bx_shadow_data_c(bx_param_c *parent,
char *name,
const char *name,
Bit8u *ptr_to_data,
Bit32u data_size)
: bx_param_c(SIM->gen_param_id(), name, "")
@ -1831,7 +1829,7 @@ bx_list_c::bx_list_c(bx_param_c *parent, int maxsize)
set_type(BXT_LIST);
this->size = 0;
this->maxsize = maxsize;
this->list = new bx_param_c* [maxsize];
this->list = new bx_param_c* [maxsize];
this->parent = NULL;
if (parent) {
BX_ASSERT(parent->get_type() == BXT_LIST);
@ -1841,13 +1839,13 @@ bx_list_c::bx_list_c(bx_param_c *parent, int maxsize)
init("");
}
bx_list_c::bx_list_c(bx_param_c *parent, char *name, int maxsize)
bx_list_c::bx_list_c(bx_param_c *parent, const char *name, int maxsize)
: bx_param_c(SIM->gen_param_id(), name, "")
{
set_type (BXT_LIST);
this->size = 0;
this->maxsize = maxsize;
this->list = new bx_param_c* [maxsize];
this->list = new bx_param_c* [maxsize];
this->parent = NULL;
if (parent) {
BX_ASSERT(parent->get_type() == BXT_LIST);
@ -1857,14 +1855,14 @@ bx_list_c::bx_list_c(bx_param_c *parent, char *name, int maxsize)
init("");
}
bx_list_c::bx_list_c(bx_param_c *parent, char *name, char *title,
bx_list_c::bx_list_c(bx_param_c *parent, const char *name, char *title,
int maxsize)
: bx_param_c(SIM->gen_param_id(), name, "")
{
set_type (BXT_LIST);
this->size = 0;
this->maxsize = maxsize;
this->list = new bx_param_c* [maxsize];
this->list = new bx_param_c* [maxsize];
this->parent = NULL;
if (parent) {
BX_ASSERT(parent->get_type() == BXT_LIST);
@ -1874,7 +1872,7 @@ bx_list_c::bx_list_c(bx_param_c *parent, char *name, char *title,
init(title);
}
bx_list_c::bx_list_c(bx_param_c *parent, char *name, char *title, bx_param_c **init_list)
bx_list_c::bx_list_c(bx_param_c *parent, const char *name, char *title, bx_param_c **init_list)
: bx_param_c(SIM->gen_param_id(), name, "")
{
set_type(BXT_LIST);
@ -1882,7 +1880,7 @@ bx_list_c::bx_list_c(bx_param_c *parent, char *name, char *title, bx_param_c **i
while (init_list[this->size] != NULL)
this->size++;
this->maxsize = this->size;
this->list = new bx_param_c* [maxsize];
this->list = new bx_param_c* [maxsize];
for (int i=0; i<this->size; i++)
this->list[i] = init_list[i];
this->parent = NULL;
@ -1918,7 +1916,8 @@ void bx_list_c::init(const char *list_title)
"list_choice", "", "", 0, BX_MAX_BIT64S, 1);
}
void bx_list_c::set_parent(bx_param_c *newparent) {
void bx_list_c::set_parent(bx_param_c *newparent)
{
if (parent) {
// if this object already had a parent, the correct thing
// to do would be to remove this object from the parent's

64
bochs/gui/siminterface.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: siminterface.h,v 1.192 2006-05-27 14:02:34 sshwarts Exp $
// $Id: siminterface.h,v 1.193 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Intro to siminterface by Bryce Denney:
@ -581,6 +581,7 @@ protected:
void set_type(bx_objtype type);
public:
bx_object_c(Bit32u id);
virtual ~bx_object_c() {}
Bit32u get_id() { return id; }
Bit8u get_type() { return type; }
};
@ -602,13 +603,14 @@ protected:
int runtime_param;
int enabled;
public:
bx_param_c(Bit32u id, char *name, char *description);
bx_param_c(Bit32u id, const char *name, char *description);
virtual ~bx_param_c();
bx_param_c *get_parent() { return (bx_param_c *) parent; }
int get_param_path(char *path_out, int maxlen);
void set_format(const char *format) {text_format = format;}
const char *get_format() {return text_format;}
const char *get_format() const {return text_format;}
void set_long_format(const char *format) {long_text_format = format;}
const char *get_long_format() {return long_text_format;}
const char *get_long_format() const {return long_text_format;}
void set_ask_format(char *format) {ask_format = format; }
char *get_ask_format() {return ask_format;}
void set_label(char *text) {label = text;}
@ -617,12 +619,12 @@ public:
int get_runtime_param() { return runtime_param; }
void set_group(char *group) {group_name = group;}
char *get_group() {return group_name;}
char *get_name() { return name; }
const char *get_name() const { return name; }
char *get_description() { return description; }
int get_enabled() { return enabled; }
int get_enabled() const { return enabled; }
virtual void set_enabled(int enabled) { this->enabled = enabled; }
virtual void reset() {}
int getint() {return -1;}
int getint() const {return -1;}
static const char* set_default_format(const char *f);
static const char *get_default_format() { return default_text_format; }
virtual bx_list_c *get_dependent_list() { return NULL; }
@ -673,7 +675,7 @@ public:
USE_SPIN_CONTROL = (1<<0)
} bx_numopt_bits;
bx_param_num_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
Bit64s min, Bit64s max, Bit64s initial_val,
@ -717,49 +719,49 @@ class BOCHSAPI bx_shadow_num_c : public bx_param_num_c {
Bit64u mask; // mask is ANDed with value before it is returned from get
public:
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit64s *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 63,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit64u *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 63,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit32s *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 31,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit32u *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 31,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit16s *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 15,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit16u *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 15,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit8s *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 7,
Bit8u lowbit = 0);
bx_shadow_num_c(bx_param_c *parent,
char *name,
const char *name,
Bit8u *ptr_to_real_val,
int base = BASE_DEC,
Bit8u highbit = 7,
@ -775,7 +777,7 @@ class BOCHSAPI bx_param_bool_c : public bx_param_num_c {
// other parameters associated with that module.
public:
bx_param_bool_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
Bit64s initial_val,
@ -793,12 +795,12 @@ class BOCHSAPI bx_shadow_bool_c : public bx_param_bool_c {
Bit8u bitnum;
public:
bx_shadow_bool_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
bx_bool *ptr_to_real_val,
Bit8u bitnum = 0);
bx_shadow_bool_c(bx_param_c *parent,
char *name,
const char *name,
bx_bool *ptr_to_real_val,
Bit8u bitnum = 0);
virtual Bit64s get64();
@ -810,7 +812,7 @@ class BOCHSAPI bx_param_enum_c : public bx_param_num_c {
char **choices;
public:
bx_param_enum_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char **choices,
@ -844,10 +846,10 @@ public:
SAVE_FILE_DIALOG = 4 // Use save dialog opposed to open file dialog
} bx_string_opt_bits;
bx_param_string_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char *initial_val,
const char *initial_val,
int maxsize=-1);
virtual ~bx_param_string_c();
virtual void reset();
@ -860,9 +862,9 @@ public:
bx_bool equals(const char *buf);
bx_param_num_c *get_options() { return options; }
void set_separator(char sep) {separator = sep; }
char get_separator() {return separator; }
int get_maxsize() {return maxsize; }
void set_initial_val(char *buf);
char get_separator() const {return separator; }
int get_maxsize() const {return maxsize; }
void set_initial_val(const char *buf);
#if BX_USE_TEXTCONFIG
virtual void text_print(FILE *fp);
virtual int text_ask(FILE *fpin, FILE *fpout);
@ -875,7 +877,7 @@ public:
class BOCHSAPI bx_param_filename_c : public bx_param_string_c {
public:
bx_param_filename_c(bx_param_c *parent,
char *name,
const char *name,
char *label,
char *description,
char *initial_val,
@ -888,7 +890,7 @@ class BOCHSAPI bx_shadow_data_c : public bx_param_c {
Bit8u *data_ptr;
public:
bx_shadow_data_c(bx_param_c *parent,
char *name,
const char *name,
Bit8u *ptr_to_data,
Bit32u data_size);
Bit8u *getptr() {return data_ptr;}
@ -940,9 +942,9 @@ public:
SHOW_GROUP_NAME = (1<<4)
} bx_listopt_bits;
bx_list_c(bx_param_c *parent, int maxsize = BX_DEFAULT_LIST_SIZE);
bx_list_c(bx_param_c *parent, char *name, int maxsize = BX_DEFAULT_LIST_SIZE);
bx_list_c(bx_param_c *parent, char *name, char *title, int maxsize = BX_DEFAULT_LIST_SIZE);
bx_list_c(bx_param_c *parent, char *name, char *title, bx_param_c **init_list);
bx_list_c(bx_param_c *parent, const char *name, int maxsize = BX_DEFAULT_LIST_SIZE);
bx_list_c(bx_param_c *parent, const char *name, char *title, int maxsize = BX_DEFAULT_LIST_SIZE);
bx_list_c(bx_param_c *parent, const char *name, char *title, bx_param_c **init_list);
virtual ~bx_list_c();
bx_list_c *clone();
void add(bx_param_c *param);
@ -1101,7 +1103,7 @@ enum disp_mode_t { DISP_MODE_CONFIG=100, DISP_MODE_SIM };
class BOCHSAPI bx_simulator_interface_c {
public:
bx_simulator_interface_c();
bx_simulator_interface_c() {}
virtual void set_quit_context(jmp_buf *context) {}
virtual int get_init_done() { return -1; }
virtual int set_init_done(int n) {return -1;}

9
bochs/gui/win32dialog.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: win32dialog.cc,v 1.45 2006-05-29 18:52:46 vruppert Exp $
// $Id: win32dialog.cc,v 1.46 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
#include "config.h"
@ -143,7 +143,8 @@ static BOOL CALLBACK LogAskProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lPara
static BOOL CALLBACK StringParamProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static bx_param_string_c *param;
char buffer[512], *title;
char buffer[512];
const char *title;
switch (msg) {
case WM_INITDIALOG:
@ -185,7 +186,7 @@ static BOOL CALLBACK FloppyDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP
char mesg[MAX_PATH];
char path[MAX_PATH];
char pname[80];
char *title;
const char *title;
int i, cap;
switch (msg) {
@ -803,7 +804,7 @@ int AskFilename(HWND hwnd, bx_param_filename_c *param, const char *ext)
int ret;
DWORD errcode;
char filename[MAX_PATH];
char *title;
const char *title;
char errtext[80];
param->get(filename, MAX_PATH);

8
bochs/iodev/cmos.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: cmos.cc,v 1.55 2006-05-28 18:43:01 sshwarts Exp $
// $Id: cmos.cc,v 1.56 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -127,7 +127,7 @@ bx_cmos_c::~bx_cmos_c() {}
void bx_cmos_c::init(void)
{
BX_DEBUG(("Init $Id: cmos.cc,v 1.55 2006-05-28 18:43:01 sshwarts Exp $"));
BX_DEBUG(("Init $Id: cmos.cc,v 1.56 2006-05-29 22:33:38 sshwarts Exp $"));
// CMOS RAM & RTC
DEV_register_ioread_handler(this, read_handler, 0x0070, "CMOS RAM", 1);
@ -234,7 +234,7 @@ void bx_cmos_c::init(void)
}
char *tmptime;
while( (tmptime = strdup(ctime(&(BX_CMOS_THIS s.timeval)))) == NULL) {
while((tmptime = strdup(ctime(&(BX_CMOS_THIS s.timeval)))) == NULL) {
BX_PANIC(("Out of memory."));
}
tmptime[strlen(tmptime)-1]='\0';
@ -292,7 +292,7 @@ void bx_cmos_c::register_state(void)
for (unsigned i=0; i<128; i++) {
char name[6];
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(ram, strdup(name), &BX_CMOS_THIS s.reg[i], BASE_HEX);
new bx_shadow_num_c(ram, name, &BX_CMOS_THIS s.reg[i], BASE_HEX);
}
}

10
bochs/iodev/dma.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: dma.cc,v 1.38 2006-05-28 18:43:01 sshwarts Exp $
// $Id: dma.cc,v 1.39 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -123,7 +123,7 @@ unsigned bx_dma_c::get_TC(void)
void bx_dma_c::init(void)
{
unsigned c, i, j;
BX_DEBUG(("Init $Id: dma.cc,v 1.38 2006-05-28 18:43:01 sshwarts Exp $"));
BX_DEBUG(("Init $Id: dma.cc,v 1.39 2006-05-29 22:33:38 sshwarts Exp $"));
/* 8237 DMA controller */
@ -199,14 +199,14 @@ void bx_dma_c::register_state(void)
bx_list_c *list = new bx_list_c(SIM->get_sr_root(), "dma", "DMA State");
for (i=0; i<2; i++) {
sprintf(name, "%d", i);
bx_list_c *ctrl = new bx_list_c(list, strdup(name), 8);
bx_list_c *ctrl = new bx_list_c(list, name, 8);
BXRS_PARAM_BOOL(ctrl, flip_flop, BX_DMA_THIS s[i].flip_flop);
BXRS_HEX_PARAM_FIELD(ctrl, status_reg, BX_DMA_THIS s[i].status_reg);
BXRS_HEX_PARAM_FIELD(ctrl, command_reg, BX_DMA_THIS s[i].command_reg);
BXRS_PARAM_BOOL(ctrl, ctrl_disabled, BX_DMA_THIS s[i].ctrl_disabled);
for (c=0; c<4; c++) {
sprintf(name, "%d", c);
bx_list_c *chan = new bx_list_c(ctrl, strdup(name), 12);
bx_list_c *chan = new bx_list_c(ctrl, name, 12);
BXRS_PARAM_BOOL(chan, DRQ, BX_DMA_THIS s[i].DRQ[c]);
BXRS_PARAM_BOOL(chan, DACK, BX_DMA_THIS s[i].DACK[c]);
BXRS_PARAM_BOOL(chan, mask, BX_DMA_THIS s[i].mask[c]);
@ -224,7 +224,7 @@ void bx_dma_c::register_state(void)
bx_list_c *extpg = new bx_list_c(list, "ext_page", 16);
for (i=0; i<16; i++) {
sprintf(name, "0x%02x", 0x80+i);
new bx_shadow_num_c(extpg, strdup(name), &BX_DMA_THIS ext_page_reg[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(extpg, name, BX_DMA_THIS ext_page_reg[i]);
}
}
#endif

10
bochs/iodev/floppy.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: floppy.cc,v 1.100 2006-05-27 15:54:48 sshwarts Exp $
// $Id: floppy.cc,v 1.101 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -137,7 +137,7 @@ void bx_floppy_ctrl_c::init(void)
{
Bit8u i;
BX_DEBUG(("Init $Id: floppy.cc,v 1.100 2006-05-27 15:54:48 sshwarts Exp $"));
BX_DEBUG(("Init $Id: floppy.cc,v 1.101 2006-05-29 22:33:38 sshwarts Exp $"));
DEV_dma_register_8bit_channel(2, dma_read, dma_write, "Floppy Drive");
DEV_register_irq(6, "Floppy Drive");
for (unsigned addr=0x03F2; addr<=0x03F7; addr++) {
@ -391,7 +391,7 @@ void bx_floppy_ctrl_c::register_state(void)
bx_list_c *command = new bx_list_c(list, "command", 10);
for (i=0; i<10; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(command, strdup(name), &BX_FD_THIS s.command[i], BASE_HEX);
new bx_shadow_num_c(command, name, &BX_FD_THIS s.command[i], BASE_HEX);
}
new bx_shadow_num_c(list, "command_index", &BX_FD_THIS s.command_index);
new bx_shadow_num_c(list, "command_size", &BX_FD_THIS s.command_size);
@ -405,7 +405,7 @@ void bx_floppy_ctrl_c::register_state(void)
bx_list_c *result = new bx_list_c(list, "result", 10);
for (i=0; i<10; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(result, strdup(name), &BX_FD_THIS s.result[i], BASE_HEX);
new bx_shadow_num_c(result, name, &BX_FD_THIS s.result[i], BASE_HEX);
}
new bx_shadow_num_c(list, "result_index", &BX_FD_THIS s.result_index);
new bx_shadow_num_c(list, "result_size", &BX_FD_THIS s.result_size);
@ -429,7 +429,7 @@ void bx_floppy_ctrl_c::register_state(void)
new bx_shadow_data_c(list, "buffer", BX_FD_THIS s.floppy_buffer, 512);
for (i=0; i<4; i++) {
sprintf(name, "drive%d", i);
drive = new bx_list_c(list, strdup(name));
drive = new bx_list_c(list, name);
new bx_shadow_num_c(drive, "cylinder", &BX_FD_THIS s.cylinder[i]);
new bx_shadow_num_c(drive, "head", &BX_FD_THIS s.head[i]);
new bx_shadow_num_c(drive, "sector", &BX_FD_THIS s.sector[i]);

8
bochs/iodev/harddrv.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: harddrv.cc,v 1.166 2006-05-27 15:54:48 sshwarts Exp $
// $Id: harddrv.cc,v 1.167 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -143,7 +143,7 @@ void bx_hard_drive_c::init(void)
char ata_name[20];
bx_list_c *base;
BX_DEBUG(("Init $Id: harddrv.cc,v 1.166 2006-05-27 15:54:48 sshwarts Exp $"));
BX_DEBUG(("Init $Id: harddrv.cc,v 1.167 2006-05-29 22:33:38 sshwarts Exp $"));
for (channel=0; channel<BX_MAX_ATA_CHANNEL; channel++) {
sprintf(ata_name, "ata.%d.resources", channel);
@ -615,11 +615,11 @@ void bx_hard_drive_c::register_state(void)
bx_list_c *list = new bx_list_c(SIM->get_sr_root(), "hard_drive", "Hard Drive State");
for (i=0; i<BX_MAX_ATA_CHANNEL; i++) {
sprintf(cname, "%d", i);
chan = new bx_list_c(list, strdup(cname));
chan = new bx_list_c(list, cname);
for (j=0; j<2; j++) {
if (BX_DRIVE_IS_PRESENT(i, j)) {
sprintf(dname, "drive%d", i);
drive = new bx_list_c(chan, strdup(dname), 20);
drive = new bx_list_c(chan, dname, 20);
new bx_shadow_data_c(drive, "buffer", BX_CONTROLLER(i, j).buffer, 2352);
status = new bx_list_c(drive, "status", 9);
new bx_shadow_bool_c(status, "busy", &BX_CONTROLLER(i, j).status.busy);

4
bochs/iodev/ioapic.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: ioapic.cc,v 1.30 2006-05-28 17:07:57 sshwarts Exp $
// $Id: ioapic.cc,v 1.31 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -261,7 +261,7 @@ void bx_ioapic_c::register_state(void)
for (unsigned i=0; i<BX_IOAPIC_NUM_PINS; i++) {
char name[6];
sprintf(name, "0x%02x", i);
bx_list_c *entry = new bx_list_c(table, strdup(name), 2);
bx_list_c *entry = new bx_list_c(table, name, 2);
ioredtbl[i].register_state(entry);
}
}

10
bochs/iodev/keyboard.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: keyboard.cc,v 1.116 2006-05-27 15:54:48 sshwarts Exp $
// $Id: keyboard.cc,v 1.117 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -109,7 +109,7 @@ void bx_keyb_c::resetinternals(bx_bool powerup)
void bx_keyb_c::init(void)
{
BX_DEBUG(("Init $Id: keyboard.cc,v 1.116 2006-05-27 15:54:48 sshwarts Exp $"));
BX_DEBUG(("Init $Id: keyboard.cc,v 1.117 2006-05-29 22:33:38 sshwarts Exp $"));
Bit32u i;
DEV_register_irq(1, "8042 Keyboard controller");
@ -302,7 +302,7 @@ void bx_keyb_c::register_state(void)
buffer = new bx_list_c(kbdbuf, "buffer", BX_KBD_ELEMENTS);
for (i=0; i<BX_KBD_ELEMENTS; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(buffer, strdup(name), &BX_KEY_THIS s.kbd_internal_buffer.buffer[i], BASE_HEX);
new bx_shadow_num_c(buffer, name, &BX_KEY_THIS s.kbd_internal_buffer.buffer[i], BASE_HEX);
}
new bx_shadow_num_c(kbdbuf, "head", &BX_KEY_THIS s.kbd_internal_buffer.head);
new bx_shadow_bool_c(kbdbuf, "expecting_typematic", &BX_KEY_THIS s.kbd_internal_buffer.expecting_typematic);
@ -316,13 +316,13 @@ void bx_keyb_c::register_state(void)
buffer = new bx_list_c(mousebuf, "buffer", BX_MOUSE_BUFF_SIZE);
for (i=0; i<BX_MOUSE_BUFF_SIZE; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(buffer, strdup(name), &BX_KEY_THIS s.mouse_internal_buffer.buffer[i], BASE_HEX);
new bx_shadow_num_c(buffer, name, &BX_KEY_THIS s.mouse_internal_buffer.buffer[i], BASE_HEX);
}
new bx_shadow_num_c(mousebuf, "head", &BX_KEY_THIS s.mouse_internal_buffer.head);
buffer = new bx_list_c(list, "controller_Q", BX_KBD_CONTROLLER_QSIZE);
for (i=0; i<BX_KBD_CONTROLLER_QSIZE; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(buffer, strdup(name), &BX_KEY_THIS s.controller_Q[i], BASE_HEX);
new bx_shadow_num_c(buffer, name, &BX_KEY_THIS s.controller_Q[i], BASE_HEX);
}
new bx_shadow_num_c(list, "controller_Qsize", &BX_KEY_THIS s.controller_Qsize);
new bx_shadow_num_c(list, "controller_Qsource", &BX_KEY_THIS s.controller_Qsource);

18
bochs/iodev/ne2k.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: ne2k.cc,v 1.87 2006-05-27 15:54:48 sshwarts Exp $
// $Id: ne2k.cc,v 1.88 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -204,13 +204,13 @@ void bx_ne2k_c::register_state(void)
bx_list_c *paddr = new bx_list_c(list, "physaddr");
for (i=0; i<6; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(paddr, strdup(name), &BX_NE2K_THIS s.physaddr[i], BASE_HEX);
new bx_shadow_num_c(paddr, name, &BX_NE2K_THIS s.physaddr[i], BASE_HEX);
}
new bx_shadow_num_c(list, "curr_page", &BX_NE2K_THIS s.curr_page, BASE_HEX);
bx_list_c *mchash = new bx_list_c(list, "mchash", 8);
for (i=0; i<8; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(mchash, strdup(name), &BX_NE2K_THIS s.mchash[i], BASE_HEX);
new bx_shadow_num_c(mchash, name, &BX_NE2K_THIS s.mchash[i], BASE_HEX);
}
new bx_shadow_num_c(list, "rempkt_ptr", &BX_NE2K_THIS s.rempkt_ptr, BASE_HEX);
new bx_shadow_num_c(list, "localpkt_ptr", &BX_NE2K_THIS s.localpkt_ptr, BASE_HEX);
@ -222,7 +222,7 @@ void bx_ne2k_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_NE2K_THIS s.pci_conf[i], BASE_HEX);
new bx_shadow_num_c(pci_conf, name, &BX_NE2K_THIS s.pci_conf[i], BASE_HEX);
}
}
#endif
@ -488,8 +488,7 @@ bx_ne2k_c::asic_read(Bit32u offset, unsigned int io_len)
return (retval);
}
void
bx_ne2k_c::asic_write(Bit32u offset, Bit32u value, unsigned io_len)
void bx_ne2k_c::asic_write(Bit32u offset, Bit32u value, unsigned io_len)
{
BX_DEBUG(("asic write addr=0x%02x, value=0x%04x", (unsigned) offset, (unsigned) value));
switch (offset) {
@ -536,7 +535,7 @@ bx_ne2k_c::asic_write(Bit32u offset, Bit32u value, unsigned io_len)
default: // this is invalid, but happens under win95 device detection
BX_INFO(("asic write invalid address %04x, ignoring", (unsigned) offset));
break ;
break;
}
}
@ -1005,7 +1004,7 @@ Bit32u bx_ne2k_c::page2_read(Bit32u offset, unsigned int io_len)
}
return (0);
};
}
void bx_ne2k_c::page2_write(Bit32u offset, Bit32u value, unsigned io_len)
{
@ -1103,7 +1102,6 @@ void bx_ne2k_c::page3_write(Bit32u offset, Bit32u value, unsigned io_len)
void bx_ne2k_c::tx_timer_handler(void *this_ptr)
{
bx_ne2k_c *class_ptr = (bx_ne2k_c *) this_ptr;
class_ptr->tx_timer();
}
@ -1403,7 +1401,7 @@ void bx_ne2k_c::init(void)
char devname[16];
bx_list_c *base;
BX_DEBUG(("Init $Id: ne2k.cc,v 1.87 2006-05-27 15:54:48 sshwarts Exp $"));
BX_DEBUG(("Init $Id: ne2k.cc,v 1.88 2006-05-29 22:33:38 sshwarts Exp $"));
// Read in values from config interface
base = (bx_list_c*) SIM->get_param(BXPN_NE2K);

6
bochs/iodev/parallel.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: parallel.cc,v 1.29 2006-05-27 15:54:48 sshwarts Exp $
// $Id: parallel.cc,v 1.30 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -75,7 +75,7 @@ void bx_parallel_c::init(void)
char name[16], pname[20];
bx_list_c *base;
BX_DEBUG(("Init $Id: parallel.cc,v 1.29 2006-05-27 15:54:48 sshwarts Exp $"));
BX_DEBUG(("Init $Id: parallel.cc,v 1.30 2006-05-29 22:33:38 sshwarts Exp $"));
for (unsigned i=0; i<BX_N_PARALLEL_PORTS; i++) {
sprintf(pname, "ports.parallel.%d", i+1);
@ -134,7 +134,7 @@ void bx_parallel_c::register_state(void)
base = (bx_list_c*) SIM->get_param(pname);
if (SIM->get_param_bool("enabled", base)->get()) {
sprintf(name, "%d", i);
port = new bx_list_c(list, strdup(name), 11);
port = new bx_list_c(list, name, 11);
new bx_shadow_num_c(port, "data", &BX_PAR_THIS s[i].data, BASE_HEX);
new bx_shadow_bool_c(port, "slct", &BX_PAR_THIS s[i].STATUS.slct);
new bx_shadow_bool_c(port, "ack", &BX_PAR_THIS s[i].STATUS.ack);

4
bochs/iodev/pci.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pci.cc,v 1.50 2006-05-28 17:07:57 sshwarts Exp $
// $Id: pci.cc,v 1.51 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -158,7 +158,7 @@ void bx_pci_bridge_c::register_state(void)
for (unsigned i=0; i<256; i++) {
char name[6];
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_PCI_THIS s.i440fx.pci_conf[i], BASE_HEX);
new bx_shadow_num_c(pci_conf, name, &BX_PCI_THIS s.i440fx.pci_conf[i], BASE_HEX);
}
}

8
bochs/iodev/pci2isa.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pci2isa.cc,v 1.33 2006-05-28 17:07:57 sshwarts Exp $
// $Id: pci2isa.cc,v 1.34 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -155,7 +155,7 @@ void bx_pci2isa_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_P2I_THIS s.pci_conf[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(pci_conf, name, BX_P2I_THIS s.pci_conf[i]);
}
BXRS_HEX_PARAM_FIELD(list, elcr1, BX_P2I_THIS s.elcr1);
BXRS_HEX_PARAM_FIELD(list, elcr2, BX_P2I_THIS s.elcr2);
@ -166,12 +166,12 @@ void bx_pci2isa_c::register_state(void)
bx_list_c *irqr = new bx_list_c(list, "irq_registry", 16);
for (i=0; i<16; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(irqr, strdup(name), &BX_P2I_THIS s.irq_registry[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(irqr, name, BX_P2I_THIS s.irq_registry[i]);
}
bx_list_c *irql = new bx_list_c(list, "irq_level", 16);
for (i=0; i<16; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(irql, strdup(name), &BX_P2I_THIS s.irq_level[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(irql, name, BX_P2I_THIS s.irq_level[i]);
}
}

6
bochs/iodev/pci_ide.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pci_ide.cc,v 1.24 2006-05-28 18:14:05 sshwarts Exp $
// $Id: pci_ide.cc,v 1.25 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -146,7 +146,7 @@ void bx_pci_ide_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_PIDE_THIS s.pci_conf[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(pci_conf, name, BX_PIDE_THIS s.pci_conf[i]);
}
new bx_shadow_data_c(list, "buffer0", BX_PIDE_THIS s.bmdma[0].buffer, 0x20000);
@ -154,7 +154,7 @@ void bx_pci_ide_c::register_state(void)
for (i=0; i<2; i++) {
sprintf(name, "%d", i);
bx_list_c *ctrl = new bx_list_c(list, strdup(name), 7);
bx_list_c *ctrl = new bx_list_c(list, name, 7);
BXRS_PARAM_BOOL(ctrl, cmd_ssbm, BX_PIDE_THIS s.bmdma[i].cmd_ssbm);
BXRS_PARAM_BOOL(ctrl, cmd_rwcon, BX_PIDE_THIS s.bmdma[i].cmd_rwcon);
BXRS_HEX_PARAM_FIELD(ctrl, status, BX_PIDE_THIS s.bmdma[i].status);

6
bochs/iodev/pcipnic.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pcipnic.cc,v 1.20 2006-05-27 15:54:48 sshwarts Exp $
// $Id: pcipnic.cc,v 1.21 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2003 Fen Systems Ltd.
@ -165,14 +165,14 @@ void bx_pcipnic_c::register_state(void)
bx_list_c *recvRL = new bx_list_c(list, "recvRingLength", PNIC_RECV_RINGS);
for (i=0; i<PNIC_RECV_RINGS; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(recvRL, strdup(name), &BX_PNIC_THIS s.recvRingLength[i]);
new bx_shadow_num_c(recvRL, name, &BX_PNIC_THIS s.recvRingLength[i]);
}
new bx_shadow_data_c(list, "rData", BX_PNIC_THIS s.rData, PNIC_DATA_SIZE);
new bx_shadow_data_c(list, "recvRing", (Bit8u*)BX_PNIC_THIS s.recvRing, PNIC_RECV_RINGS*PNIC_DATA_SIZE);
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_PNIC_THIS s.pci_conf[i], BASE_HEX);
new bx_shadow_num_c(pci_conf, name, &BX_PNIC_THIS s.pci_conf[i], BASE_HEX);
}
}

17
bochs/iodev/pciusb.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pciusb.cc,v 1.38 2006-05-27 15:54:48 sshwarts Exp $
// $Id: pciusb.cc,v 1.39 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2004 MandrakeSoft S.A.
@ -246,7 +246,7 @@ void bx_pciusb_c::register_state(void)
bx_list_c *list = new bx_list_c(SIM->get_sr_root(), "pciusb", "PCI USB Controller State", BX_USB_CONFDEV + 15);
for (i=0; i<BX_USB_CONFDEV; i++) {
sprintf(hubnum, "hub%d", i+1);
hub = new bx_list_c(list, strdup(hubnum), USB_NUM_PORTS + 7);
hub = new bx_list_c(list, hubnum, USB_NUM_PORTS + 7);
usb_cmd = new bx_list_c(hub, "usb_command", 8);
new bx_shadow_bool_c(usb_cmd, "max_packet_size", &BX_USB_THIS hub[i].usb_command.max_packet_size);
new bx_shadow_bool_c(usb_cmd, "configured", &BX_USB_THIS hub[i].usb_command.configured);
@ -273,7 +273,7 @@ void bx_pciusb_c::register_state(void)
new bx_shadow_num_c(hub, "sof_timing", &BX_USB_THIS hub[i].usb_sof.sof_timing, BASE_HEX);
for (j=0; j<USB_NUM_PORTS; j++) {
sprintf(portnum, "port%d", j+1);
port = new bx_list_c(hub, strdup(portnum), 10);
port = new bx_list_c(hub, portnum, 10);
new bx_shadow_bool_c(port, "suspend", &BX_USB_THIS hub[i].usb_port[j].suspend);
new bx_shadow_bool_c(port, "reset", &BX_USB_THIS hub[i].usb_port[j].reset);
new bx_shadow_bool_c(port, "low_speed", &BX_USB_THIS hub[i].usb_port[j].low_speed);
@ -288,7 +288,7 @@ void bx_pciusb_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(hub, "pci_conf", 256);
for (n=0; n<256; n++) {
sprintf(name, "0x%02x", n);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_USB_THIS hub[i].pci_conf[n], BASE_HEX);
new bx_shadow_num_c(pci_conf, name, &BX_USB_THIS hub[i].pci_conf[n], BASE_HEX);
}
}
new bx_shadow_bool_c(list, "busy", &BX_USB_THIS busy);
@ -304,19 +304,19 @@ void bx_pciusb_c::register_state(void)
bx_list_c *svkey = new bx_list_c(list, "saved_key", 8);
for (i=0; i<8; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(svkey, strdup(name), &BX_USB_THIS saved_key[i]);
new bx_shadow_num_c(svkey, name, &BX_USB_THIS saved_key[i]);
}
bx_list_c *kppkt = new bx_list_c(list, "key_pad_packet", 8);
for (i=0; i<8; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(kppkt, strdup(name), &BX_USB_THIS key_pad_packet[i]);
new bx_shadow_num_c(kppkt, name, &BX_USB_THIS key_pad_packet[i]);
}
new bx_shadow_data_c(list, "device_buffer", BX_USB_THIS device_buffer, 65536);
new bx_shadow_num_c(list, "set_address_stk", &BX_USB_THIS set_address_stk);
bx_list_c *setaddr = new bx_list_c(list, "set_address", 128);
for (i=0; i<128; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(setaddr, strdup(name), &BX_USB_THIS set_address[i], BASE_HEX);
new bx_shadow_num_c(setaddr, name, &BX_USB_THIS set_address[i], BASE_HEX);
}
}
@ -325,7 +325,8 @@ void bx_pciusb_c::after_restore_state(void)
if (DEV_pci_set_base_io(BX_USB_THIS_PTR, read_handler, write_handler,
&BX_USB_THIS hub[0].base_ioaddr,
&BX_USB_THIS hub[0].pci_conf[0x20],
32, &usb_iomask[0], "USB Hub #1")) {
32, &usb_iomask[0], "USB Hub #1"))
{
BX_INFO(("new base address: 0x%04x", BX_USB_THIS hub[0].base_ioaddr));
}
}

4
bochs/iodev/pcivga.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pcivga.cc,v 1.10 2006-05-27 15:54:48 sshwarts Exp $
// $Id: pcivga.cc,v 1.11 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002,2003 Mike Nordell
@ -118,7 +118,7 @@ void bx_pcivga_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_PCIVGA_THIS s.pci_conf[i], BASE_HEX);
BXRS_HEX_PARAM_FIELD(pci_conf, name, BX_PCIVGA_THIS s.pci_conf[i]);
}
}
#endif

4
bochs/iodev/pit.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pit.cc,v 1.22 2006-05-27 15:54:48 sshwarts Exp $
// $Id: pit.cc,v 1.23 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -237,7 +237,7 @@ void bx_pit_c::register_state(void)
bx_list_c *list = new bx_list_c(SIM->get_sr_root(), "pit", "8254 PIT State");
for (i=0; i<3; i++) {
sprintf(name, "timer%d", i);
tim = new bx_list_c(list, strdup(name), 13);
tim = new bx_list_c(list, name, 13);
new bx_shadow_num_c(tim, "mode", &BX_PIT_THIS s.timer[i].mode, 16);
new bx_shadow_num_c(tim, "latch_mode", &BX_PIT_THIS s.timer[i].latch_mode, 16);
new bx_shadow_num_c(tim, "input_latch_value", &BX_PIT_THIS s.timer[i].input_latch_value, 16);

4
bochs/iodev/pit82c54.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pit82c54.cc,v 1.27 2006-05-27 15:54:48 sshwarts Exp $
// $Id: pit82c54.cc,v 1.28 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
/*
@ -196,7 +196,7 @@ void pit_82C54::register_state(bx_param_c *parent)
for (i=0; i<3; i++) {
sprintf(name, "%d", i);
tim = new bx_list_c(parent, strdup(name), 22);
tim = new bx_list_c(parent, name, 22);
new bx_shadow_bool_c(tim, "GATE", &counter[i].GATE);
new bx_shadow_bool_c(tim, "OUTpin", &counter[i].OUTpin);
new bx_shadow_num_c(tim, "count", &counter[i].count);

18
bochs/iodev/sb16.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: sb16.cc,v 1.49 2006-05-27 15:54:49 sshwarts Exp $
// $Id: sb16.cc,v 1.50 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -329,7 +329,7 @@ void bx_sb16_c::register_state(void)
bx_list_c *patchtbl = new bx_list_c(mpu, "patchtable", BX_SB16_PATCHTABLESIZE);
for (i=0; i<BX_SB16_PATCHTABLESIZE; i++) {
sprintf(name, "0x%02x", i);
patch = new bx_list_c(patchtbl, strdup(name));
patch = new bx_list_c(patchtbl, name, 3);
new bx_shadow_num_c(patch, "banklsb", &MPU.banklsb[i]);
new bx_shadow_num_c(patch, "bankmsb", &MPU.bankmsb[i]);
new bx_shadow_num_c(patch, "program", &MPU.program[i]);
@ -363,7 +363,7 @@ void bx_sb16_c::register_state(void)
bx_list_c *csp = new bx_list_c(list, "csp_reg", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(csp, strdup(name), &BX_SB16_THIS csp_reg[i], BASE_HEX);
new bx_shadow_num_c(csp, name, &BX_SB16_THIS csp_reg[i], BASE_HEX);
}
bx_list_c *opl = new bx_list_c(list, "opl", 8);
new bx_shadow_num_c(opl, "mode", (Bit8u*)&OPL.mode);
@ -372,7 +372,7 @@ void bx_sb16_c::register_state(void)
new bx_shadow_num_c(opl, "drumchannel", &OPL.drumchannel);
for (i=0; i<2; i++) {
sprintf(name, "chip%d", i+1);
chip = new bx_list_c(opl, strdup(name), 11);
chip = new bx_list_c(opl, name, 11);
new bx_shadow_num_c(chip, "index", &OPL.index[i]);
new bx_shadow_num_c(chip, "wsenable", &OPL.wsenable[i]);
new bx_shadow_num_c(chip, "timer1", &OPL.timer[i*2]);
@ -388,16 +388,16 @@ void bx_sb16_c::register_state(void)
bx_list_c *oper = new bx_list_c(opl, "oper", BX_SB16_FM_NOP);
for (i=0; i<BX_SB16_FM_NOP; i++) {
sprintf(name, "%d", i);
item = new bx_list_c(oper, strdup(name), BX_SB16_FM_OPB);
item = new bx_list_c(oper, name, BX_SB16_FM_OPB);
for (j=0; j<BX_SB16_FM_OPB; j++) {
sprintf(name, "%d", j);
new bx_shadow_num_c(item, strdup(name), &OPL.oper[i][j]);
new bx_shadow_num_c(item, name, &OPL.oper[i][j]);
}
}
bx_list_c *chan = new bx_list_c(opl, "chan", BX_SB16_FM_NCH);
for (i=0; i<BX_SB16_FM_NCH; i++) {
sprintf(name, "%d", i);
item = new bx_list_c(chan, strdup(name), 19);
item = new bx_list_c(chan, name, 19);
new bx_shadow_num_c(item, "nop", &OPL.chan[i].nop);
new bx_shadow_num_c(item, "ncarr", &OPL.chan[i].ncarr);
new bx_shadow_num_c(item, "opnum1", &OPL.chan[i].opnum[0]);
@ -422,14 +422,14 @@ void bx_sb16_c::register_state(void)
bx_list_c *mixer = new bx_list_c(list, "mixer_reg", BX_SB16_MIX_REG);
for (i=0; i<BX_SB16_MIX_REG; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(mixer, strdup(name), &MIXER.reg[i], BASE_HEX);
new bx_shadow_num_c(mixer, name, &MIXER.reg[i], BASE_HEX);
}
bx_list_c *emul = new bx_list_c(list, "emul");
new bx_shadow_num_c(emul, "remaps", &EMUL.remaps);
bx_list_c *remap = new bx_list_c(emul, "remaplist", 256);
for (i=0; i<EMUL.remaps; i++) {
sprintf(name, "0x%02x", i);
ins_map = new bx_list_c(remap, strdup(name));
ins_map = new bx_list_c(remap, name, 6);
new bx_shadow_num_c(ins_map, "oldbankmsb", &EMUL.remaplist[i].oldbankmsb);
new bx_shadow_num_c(ins_map, "oldbanklsb", &EMUL.remaplist[i].oldbanklsb);
new bx_shadow_num_c(ins_map, "oldprogch", &EMUL.remaplist[i].oldprogch);

10
bochs/iodev/serial.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: serial.cc,v 1.70 2006-05-27 15:54:49 sshwarts Exp $
// $Id: serial.cc,v 1.71 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2004 MandrakeSoft S.A.
@ -372,7 +372,7 @@ void bx_serial_c::register_state(void)
bx_list_c *list = new bx_list_c(SIM->get_sr_root(), "serial", "Serial Port State", 9);
for (i=0; i<BX_N_SERIAL_PORTS; i++) {
sprintf(name, "%d", i);
port = new bx_list_c(list, strdup(name), 28);
port = new bx_list_c(list, name, 28);
new bx_shadow_bool_c(port, "ls_interrupt", &BX_SER_THIS s[i].ls_interrupt);
new bx_shadow_bool_c(port, "ms_interrupt", &BX_SER_THIS s[i].ms_interrupt);
new bx_shadow_bool_c(port, "rx_interrupt", &BX_SER_THIS s[i].rx_interrupt);
@ -436,12 +436,12 @@ void bx_serial_c::register_state(void)
bx_list_c *rxfifo = new bx_list_c(port, "rx_fifo", 16);
for (j=0; j<16; j++) {
sprintf(name, "0x%02x", j);
new bx_shadow_num_c(rxfifo, strdup(name), &BX_SER_THIS s[i].rx_fifo[j], BASE_HEX);
new bx_shadow_num_c(rxfifo, name, &BX_SER_THIS s[i].rx_fifo[j], BASE_HEX);
}
bx_list_c *txfifo = new bx_list_c(port, "tx_fifo", 16);
for (j=0; j<16; j++) {
sprintf(name, "0x%02x", j);
new bx_shadow_num_c(txfifo, strdup(name), &BX_SER_THIS s[i].tx_fifo[j], BASE_HEX);
new bx_shadow_num_c(txfifo, name, &BX_SER_THIS s[i].tx_fifo[j], BASE_HEX);
}
new bx_shadow_num_c(port, "divisor_lsb", &BX_SER_THIS s[i].divisor_lsb, BASE_HEX);
new bx_shadow_num_c(port, "divisor_msb", &BX_SER_THIS s[i].divisor_msb, BASE_HEX);
@ -455,7 +455,7 @@ void bx_serial_c::register_state(void)
bx_list_c *buffer = new bx_list_c(mousebuf, "buffer", BX_MOUSE_BUFF_SIZE);
for (i=0; i<BX_MOUSE_BUFF_SIZE; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(buffer, strdup(name), &BX_SER_THIS mouse_internal_buffer.buffer[i], BASE_HEX);
new bx_shadow_num_c(buffer, name, &BX_SER_THIS mouse_internal_buffer.buffer[i], BASE_HEX);
}
new bx_shadow_num_c(mousebuf, "head", &BX_SER_THIS mouse_internal_buffer.head);
}

12
bochs/iodev/svga_cirrus.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: svga_cirrus.cc,v 1.32 2006-05-27 15:54:49 sshwarts Exp $
// $Id: svga_cirrus.cc,v 1.33 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2004 Makoto Suzuki (suzu)
@ -380,21 +380,21 @@ void bx_svga_cirrus_c::register_state(void)
reg = new bx_list_c(crtc, "reg", CIRRUS_CRTC_MAX+1);
for (i=0; i<=CIRRUS_CRTC_MAX; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_CIRRUS_THIS crtc.reg[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_CIRRUS_THIS crtc.reg[i], BASE_HEX);
}
bx_list_c *sequ = new bx_list_c(list, "sequencer");
new bx_shadow_num_c(sequ, "index", &BX_CIRRUS_THIS sequencer.index, BASE_HEX);
reg = new bx_list_c(sequ, "reg", CIRRUS_SEQENCER_MAX+1);
for (i=0; i<=CIRRUS_SEQENCER_MAX; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_CIRRUS_THIS sequencer.reg[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_CIRRUS_THIS sequencer.reg[i], BASE_HEX);
}
bx_list_c *ctrl = new bx_list_c(list, "control");
new bx_shadow_num_c(ctrl, "index", &BX_CIRRUS_THIS control.index, BASE_HEX);
reg = new bx_list_c(ctrl, "reg", CIRRUS_CONTROL_MAX+1);
for (i=0; i<=CIRRUS_CONTROL_MAX; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_CIRRUS_THIS control.reg[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_CIRRUS_THIS control.reg[i], BASE_HEX);
}
new bx_shadow_num_c(ctrl, "shadow_reg0", &BX_CIRRUS_THIS control.shadow_reg0, BASE_HEX);
new bx_shadow_num_c(ctrl, "shadow_reg1", &BX_CIRRUS_THIS control.shadow_reg1, BASE_HEX);
@ -404,7 +404,7 @@ void bx_svga_cirrus_c::register_state(void)
reg = new bx_list_c(hdac, "palette", 48);
for (i=0; i<48; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_CIRRUS_THIS hidden_dac.palette[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_CIRRUS_THIS hidden_dac.palette[i], BASE_HEX);
}
new bx_shadow_bool_c(list, "svga_unlock_special", &BX_CIRRUS_THIS svga_unlock_special);
new bx_shadow_num_c(list, "svga_xres", &BX_CIRRUS_THIS svga_xres);
@ -426,7 +426,7 @@ void bx_svga_cirrus_c::register_state(void)
bx_list_c *pci_conf = new bx_list_c(list, "pci_conf", 256);
for (i=0; i<256; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(pci_conf, strdup(name), &BX_CIRRUS_THIS pci_conf[i], BASE_HEX);
new bx_shadow_num_c(pci_conf, name, &BX_CIRRUS_THIS pci_conf[i], BASE_HEX);
}
}
#endif

6
bochs/iodev/vga.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: vga.cc,v 1.129 2006-05-27 15:54:49 sshwarts Exp $
// $Id: vga.cc,v 1.130 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -421,7 +421,7 @@ void bx_vga_c::register_state(void)
reg = new bx_list_c(crtc, "reg", 0x19);
for (i=0; i<=0x18; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_VGA_THIS s.CRTC.reg[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_VGA_THIS s.CRTC.reg[i], BASE_HEX);
}
new bx_shadow_bool_c(crtc, "write_protect", &BX_VGA_THIS s.CRTC.write_protect);
bx_list_c *actl = new bx_list_c(list, "attribute_ctrl", 9);
@ -431,7 +431,7 @@ void bx_vga_c::register_state(void)
reg = new bx_list_c(actl, "palette_reg", 16);
for (i=0; i<16; i++) {
sprintf(name, "0x%02x", i);
new bx_shadow_num_c(reg, strdup(name), &BX_VGA_THIS s.attribute_ctrl.palette_reg[i], BASE_HEX);
new bx_shadow_num_c(reg, name, &BX_VGA_THIS s.attribute_ctrl.palette_reg[i], BASE_HEX);
}
new bx_shadow_num_c(actl, "overscan_color", &BX_VGA_THIS s.attribute_ctrl.overscan_color, BASE_HEX);
new bx_shadow_num_c(actl, "color_plane_enable", &BX_VGA_THIS s.attribute_ctrl.color_plane_enable, BASE_HEX);

4
bochs/iodev/virt_timer.cc
View File

@ -1,5 +1,5 @@
////////////////////////////////////////////////////////////////////////
// $Id: virt_timer.cc,v 1.30 2006-05-28 20:24:51 sshwarts Exp $
// $Id: virt_timer.cc,v 1.31 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -429,7 +429,7 @@ void bx_virt_timer_c::register_state(void)
for (unsigned i = 0; i < numTimers; i++) {
char name[4];
sprintf(name, "%d", i);
bx_list_c *bxtimer = new bx_list_c(vtimers, strdup(name));
bx_list_c *bxtimer = new bx_list_c(vtimers, name, 5);
BXRS_PARAM_BOOL(bxtimer, inUse, timer[i].inUse);
BXRS_DEC_PARAM_FIELD(bxtimer, period, timer[i].period);
BXRS_DEC_PARAM_FIELD(bxtimer, timeToFire, timer[i].timeToFire);

4
bochs/pc_system.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: pc_system.cc,v 1.61 2006-05-28 20:24:50 sshwarts Exp $
// $Id: pc_system.cc,v 1.62 2006-05-29 22:33:38 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -241,7 +241,7 @@ void bx_pc_system_c::register_state(void)
for (unsigned i = 0; i < numTimers; i++) {
char name[4];
sprintf(name, "%d", i);
bx_list_c *bxtimer = new bx_list_c(timers, strdup(name));
bx_list_c *bxtimer = new bx_list_c(timers, name, 5);
BXRS_PARAM_BOOL(bxtimer, inUse, timer[i].inUse);
BXRS_DEC_PARAM_FIELD(bxtimer, period, timer[i].period);
BXRS_DEC_PARAM_FIELD(bxtimer, timeToFire, timer[i].timeToFire);