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

Changed bx_bool to bool type in the harddrv, cdrom, hdimage and sound code.

Browse Source
This commit is contained in:
Volker Ruppert 2021-01-31 15:44:39 +00:00
parent 1765a06d01
commit 45e03f9572
39 changed files with 264 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
bochs/iodev/harddrv.cc
View File

@ -730,7 +730,7 @@ void bx_hard_drive_c::runtime_config(void)
{
char pname[16];
int handle;
bx_bool status;
bool status;
for (Bit8u channel=0; channel<BX_MAX_ATA_CHANNEL; channel++) {
for (Bit8u device=0; device<2; device++) {
@ -1055,7 +1055,7 @@ Bit32u bx_hard_drive_c::read(Bit32u address, unsigned io_len)
// b4: DRV
// b3..0 HD3..HD0
value8 = (1 << 7) |
(controller->lba_mode << 6) |
((Bit8u)controller->lba_mode << 6) |
(1 << 5) | // 01b = 512 sector size
(BX_HD_THIS channels[channel].drive_select << 4) |
(controller->head_no << 0);
@ -1068,14 +1068,14 @@ Bit32u bx_hard_drive_c::read(Bit32u address, unsigned io_len)
value8 = 0;
} else {
value8 = (
(controller->status.busy << 7) |
(controller->status.drive_ready << 6) |
(controller->status.write_fault << 5) |
(controller->status.seek_complete << 4) |
(controller->status.drq << 3) |
(controller->status.corrected_data << 2) |
(controller->status.index_pulse << 1) |
(controller->status.err));
((Bit8u)controller->status.busy << 7) |
((Bit8u)controller->status.drive_ready << 6) |
((Bit8u)controller->status.write_fault << 5) |
((Bit8u)controller->status.seek_complete << 4) |
((Bit8u)controller->status.drq << 3) |
((Bit8u)controller->status.corrected_data << 2) |
((Bit8u)controller->status.index_pulse << 1) |
((Bit8u)controller->status.err));
controller->status.index_pulse_count++;
controller->status.index_pulse = 0;
if (controller->status.index_pulse_count >= INDEX_PULSE_CYCLE) {
@ -1137,8 +1137,8 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
UNUSED(this_ptr);
#endif // !BX_USE_HD_SMF
Bit64s logical_sector;
bx_bool prev_control_reset;
bx_bool lba48 = 0;
bool prev_control_reset;
bool lba48 = 0;
Bit8u channel = BX_MAX_ATA_CHANNEL;
Bit32u port = 0xff; // undefined
@ -1335,9 +1335,9 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
case 0x1b: // start stop unit
{
char ata_name[20];
//bx_bool Immed = (controller->buffer[1] >> 0) & 1;
bx_bool LoEj = (controller->buffer[4] >> 1) & 1;
bx_bool Start = (controller->buffer[4] >> 0) & 1;
//bool Immed = (controller->buffer[1] >> 0) & 1;
bool LoEj = (controller->buffer[4] >> 1) & 1;
bool Start = (controller->buffer[4] >> 0) & 1;
if (!LoEj && !Start) { // stop the disc
BX_ERROR(("FIXME: Stop disc not implemented"));
@ -1428,7 +1428,7 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
controller->buffer[12] = 0x71;
controller->buffer[13] = (3 << 5);
controller->buffer[14] = (unsigned char) (1 |
(BX_SELECTED_DRIVE(channel).cdrom.locked ? (1 << 1) : 0) |
((Bit8u)BX_SELECTED_DRIVE(channel).cdrom.locked ? (1 << 1) : 0) |
(1 << 3) |
(1 << 5));
controller->buffer[15] = 0x00;
@ -1505,7 +1505,7 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
controller->buffer[12] = 0x71;
controller->buffer[13] = (3 << 5);
controller->buffer[14] = (unsigned char) (1 |
(BX_SELECTED_DRIVE(channel).cdrom.locked ? (1 << 1) : 0) |
((Bit8u)BX_SELECTED_DRIVE(channel).cdrom.locked ? (1 << 1) : 0) |
(1 << 3) |
(1 << 5));
controller->buffer[15] = 0x00;
@ -1658,7 +1658,7 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
case 0x43: // read toc
if (BX_SELECTED_DRIVE(channel).cdrom.ready) {
bx_bool msf = (controller->buffer[1] >> 1) & 1;
bool msf = (controller->buffer[1] >> 1) & 1;
Bit8u starting_track = controller->buffer[6];
int toc_length = 0;
Bit16u alloc_length = read_16bit(controller->buffer + 7);
@ -1800,8 +1800,8 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
case 0x42: // read sub-channel
{
bx_bool msf = get_packet_field(controller,1, 1, 1);
bx_bool sub_q = get_packet_field(controller,2, 6, 1);
bool msf = get_packet_field(controller,1, 1, 1);
bool sub_q = get_packet_field(controller,2, 6, 1);
Bit8u data_format = get_packet_byte(controller, 3);
Bit8u track_number = get_packet_byte(controller, 6);
Bit16u alloc_length = get_packet_word(controller, 7);
@ -1848,10 +1848,10 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
case 0x4a: // get event status notification
{
bx_bool polled = (controller->buffer[1] & (1<<0)) > 0;
bool polled = (controller->buffer[1] & (1<<0)) > 0;
int event_length, request = controller->buffer[4];
Bit16u alloc_length = read_16bit(controller->buffer + 7);
bx_bool inserted = BX_SELECTED_DRIVE(channel).cdrom.ready;
bool inserted = BX_SELECTED_DRIVE(channel).cdrom.ready;
if (polled) {
// we currently only support the MEDIA event (bit 4)
if (request == (1<<4)) {
@ -2643,7 +2643,7 @@ void bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len)
}
}
bx_bool BX_CPP_AttrRegparmN(2)
bool BX_CPP_AttrRegparmN(2)
bx_hard_drive_c::calculate_logical_address(Bit8u channel, Bit64s *sector)
{
Bit64s logical_sector;
@ -3143,7 +3143,7 @@ void bx_hard_drive_c::identify_drive(Bit8u channel)
BX_SELECTED_DRIVE(channel).identify_set = 1;
}
void bx_hard_drive_c::init_send_atapi_command(Bit8u channel, Bit8u command, int req_length, int alloc_length, bx_bool lazy)
void bx_hard_drive_c::init_send_atapi_command(Bit8u channel, Bit8u command, int req_length, int alloc_length, bool lazy)
{
controller_t *controller = &BX_SELECTED_CONTROLLER(channel);
@ -3194,7 +3194,7 @@ void bx_hard_drive_c::init_send_atapi_command(Bit8u channel, Bit8u command, int
BX_SELECTED_DRIVE(channel).atapi.total_bytes_remaining = (req_length < alloc_length) ? req_length : alloc_length;
}
void bx_hard_drive_c::atapi_cmd_error(Bit8u channel, sense_t sense_key, asc_t asc, bx_bool show)
void bx_hard_drive_c::atapi_cmd_error(Bit8u channel, sense_t sense_key, asc_t asc, bool show)
{
if (show) {
BX_ERROR(("ata%d-%d: atapi_cmd_error: key=%02x asc=%02x", channel, BX_SLAVE_SELECTED(channel), sense_key, asc));
@ -3303,7 +3303,7 @@ void bx_hard_drive_c::command_aborted(Bit8u channel, unsigned value)
raise_interrupt(channel);
}
bx_bool bx_hard_drive_c::set_cd_media_status(Bit32u handle, bx_bool status)
bool bx_hard_drive_c::set_cd_media_status(Bit32u handle, bool status)
{
char ata_name[22];
@ -3484,7 +3484,7 @@ void bx_hard_drive_c::set_signature(Bit8u channel, Bit8u id)
}
}
bx_bool bx_hard_drive_c::ide_read_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size)
bool bx_hard_drive_c::ide_read_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size)
{
controller_t *controller = &BX_SELECTED_CONTROLLER(channel);
@ -3521,7 +3521,7 @@ bx_bool bx_hard_drive_c::ide_read_sector(Bit8u channel, Bit8u *buffer, Bit32u bu
return 1;
}
bx_bool bx_hard_drive_c::ide_write_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size)
bool bx_hard_drive_c::ide_write_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size)
{
controller_t *controller = &BX_SELECTED_CONTROLLER(channel);
@ -3558,7 +3558,7 @@ bx_bool bx_hard_drive_c::ide_write_sector(Bit8u channel, Bit8u *buffer, Bit32u b
return 1;
}
void bx_hard_drive_c::lba48_transform(controller_t *controller, bx_bool lba48)
void bx_hard_drive_c::lba48_transform(controller_t *controller, bool lba48)
{
controller->lba48 = lba48;
@ -3641,7 +3641,7 @@ Bit64s bx_hard_drive_c::cdrom_status_handler(bx_param_c *param, int set, Bit64s
int handle = get_device_handle_from_param(param);
if (handle >= 0) {
if (!strcmp(param->get_name(), "status")) {
bx_bool locked = BX_HD_THIS channels[handle/2].drives[handle%2].cdrom.locked;
bool locked = BX_HD_THIS channels[handle/2].drives[handle%2].cdrom.locked;
if ((val == 1) || !locked) {
BX_HD_THIS channels[handle/2].drives[handle%2].status_changed = 1;
} else if (locked) {

50
bochs/iodev/harddrv.h
View File

@ -42,15 +42,15 @@ class cdrom_base_c;
typedef struct {
struct {
bx_bool busy;
bx_bool drive_ready;
bx_bool write_fault;
bx_bool seek_complete;
bx_bool drq;
bx_bool corrected_data;
bx_bool index_pulse;
bool busy;
bool drive_ready;
bool write_fault;
bool seek_complete;
bool drq;
bool corrected_data;
bool index_pulse;
unsigned index_pulse_count;
bx_bool err;
bool err;
} status;
Bit8u error_register;
Bit8u head_no;
@ -82,13 +82,13 @@ typedef struct {
Bit32u drq_index;
Bit8u current_command;
Bit8u multiple_sectors;
bx_bool lba_mode;
bx_bool packet_dma;
bool lba_mode;
bool packet_dma;
Bit8u mdma_mode;
Bit8u udma_mode;
struct {
bx_bool reset; // 0=normal, 1=reset controller
bx_bool disable_irq; // 0=allow irq, 1=disable irq
bool reset; // 0=normal, 1=reset controller
bool disable_irq; // 0=allow irq, 1=disable irq
} control;
Bit8u reset_in_progress;
Bit8u features;
@ -100,7 +100,7 @@ typedef struct {
Bit8u hcyl;
} hob;
Bit32u num_sectors;
bx_bool lba48;
bool lba48;
} controller_t;
struct sense_info_t {
@ -130,8 +130,8 @@ Bit32u read_32bit(const Bit8u* buf) BX_CPP_AttrRegparmN(1);
struct cdrom_t
{
bx_bool ready;
bx_bool locked;
bool ready;
bool locked;
cdrom_base_c *cd;
Bit32u max_lba;
Bit32u curr_lba;
@ -201,26 +201,26 @@ public:
private:
BX_HD_SMF bx_bool calculate_logical_address(Bit8u channel, Bit64s *sector) BX_CPP_AttrRegparmN(2);
BX_HD_SMF bool calculate_logical_address(Bit8u channel, Bit64s *sector) BX_CPP_AttrRegparmN(2);
BX_HD_SMF void increment_address(Bit8u channel, Bit64s *sector) BX_CPP_AttrRegparmN(2);
BX_HD_SMF void identify_drive(Bit8u channel);
BX_HD_SMF void identify_ATAPI_drive(Bit8u channel);
BX_HD_SMF void command_aborted(Bit8u channel, unsigned command);
BX_HD_SMF void init_send_atapi_command(Bit8u channel, Bit8u command, int req_length, int alloc_length, bx_bool lazy = 0);
BX_HD_SMF void init_send_atapi_command(Bit8u channel, Bit8u command, int req_length, int alloc_length, bool lazy = 0);
BX_HD_SMF void ready_to_send_atapi(Bit8u channel) BX_CPP_AttrRegparmN(1);
BX_HD_SMF void raise_interrupt(Bit8u channel) BX_CPP_AttrRegparmN(1);
BX_HD_SMF void atapi_cmd_error(Bit8u channel, sense_t sense_key, asc_t asc, bx_bool show);
BX_HD_SMF void atapi_cmd_error(Bit8u channel, sense_t sense_key, asc_t asc, bool show);
BX_HD_SMF void init_mode_sense_single(Bit8u channel, const void* src, int size);
BX_HD_SMF void atapi_cmd_nop(controller_t *controller) BX_CPP_AttrRegparmN(1);
BX_HD_SMF bool bmdma_present(void);
BX_HD_SMF void set_signature(Bit8u channel, Bit8u id);
BX_HD_SMF bx_bool ide_read_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size);
BX_HD_SMF bx_bool ide_write_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size);
BX_HD_SMF void lba48_transform(controller_t *controller, bx_bool lba48);
BX_HD_SMF bool ide_read_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size);
BX_HD_SMF bool ide_write_sector(Bit8u channel, Bit8u *buffer, Bit32u buffer_size);
BX_HD_SMF void lba48_transform(controller_t *controller, bool lba48);
BX_HD_SMF void start_seek(Bit8u channel);
BX_HD_SMF bx_bool set_cd_media_status(Bit32u handle, bx_bool status);
BX_HD_SMF bool set_cd_media_status(Bit32u handle, bool status);
static Bit64s cdrom_status_handler(bx_param_c *param, int set, Bit64s val);
static const char* cdrom_path_handler(bx_param_string_c *param, int set,
@ -237,7 +237,7 @@ private:
// they are fetched and returned via a return(), so
// there's no need to keep them in x86 endian format.
Bit16u id_drive[256];
bx_bool identify_set;
bool identify_set;
controller_t controller;
cdrom_t cdrom;
@ -252,7 +252,7 @@ private:
Bit8u model_no[41];
int statusbar_id;
Bit8u device_num; // for ATAPI identify & inquiry
bx_bool status_changed;
bool status_changed;
int seek_timer_index;
} drives[2];
unsigned drive_select;
@ -265,7 +265,7 @@ private:
int rt_conf_id;
Bit8u cdrom_count;
bx_bool pci_enabled;
bool pci_enabled;
};
#endif

12
bochs/iodev/hdimage/cdrom.cc
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2020 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -57,7 +57,7 @@ cdrom_base_c::~cdrom_base_c(void)
BX_DEBUG(("Exit"));
}
bx_bool cdrom_base_c::insert_cdrom(const char *dev)
bool cdrom_base_c::insert_cdrom(const char *dev)
{
unsigned char buffer[BX_CD_FRAMESIZE];
ssize_t ret;
@ -105,7 +105,7 @@ void cdrom_base_c::eject_cdrom()
}
}
bx_bool cdrom_base_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
bool cdrom_base_c::read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format)
{
unsigned i;
Bit32u blocks;
@ -231,7 +231,7 @@ bx_bool cdrom_base_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_t
return 1;
}
bx_bool BX_CPP_AttrRegparmN(3) cdrom_base_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
bool BX_CPP_AttrRegparmN(3) cdrom_base_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
{
// Read a single block from the CD
@ -286,7 +286,7 @@ Bit32u cdrom_base_c::capacity()
}
}
bx_bool cdrom_base_c::start_cdrom()
bool cdrom_base_c::start_cdrom()
{
// Spin up the cdrom drive.
@ -297,7 +297,7 @@ bx_bool cdrom_base_c::start_cdrom()
return 0;
}
bx_bool cdrom_base_c::seek(Bit32u lba)
bool cdrom_base_c::seek(Bit32u lba)
{
unsigned char buffer[BX_CD_FRAMESIZE];

14
bochs/iodev/hdimage/cdrom.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2013 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -31,28 +31,28 @@ public:
virtual ~cdrom_base_c(void);
// Load CD-ROM. Returns 0 if CD is not ready.
virtual bx_bool insert_cdrom(const char *dev = NULL);
virtual bool insert_cdrom(const char *dev = NULL);
// Logically eject the CD.
virtual void eject_cdrom();
// Read CD TOC. Returns 0 if start track is out of bounds.
virtual bx_bool read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format);
virtual bool read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format);
// Return CD-ROM capacity (in 2048 byte frames)
virtual Bit32u capacity();
// Read a single block from the CD. Returns 0 on failure.
virtual bx_bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
virtual bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
// Start (spin up) the CD.
virtual bx_bool start_cdrom();
virtual bool start_cdrom();
// Seek for new block address.
virtual bx_bool seek(Bit32u lba);
virtual bool seek(Bit32u lba);
protected:
int fd;
char *path;
bx_bool using_file;
bool using_file;
};

8
bochs/iodev/hdimage/cdrom_amigaos.cc
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2000-2013 The Bochs Project
// Copyright (C) 2000-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -147,7 +147,7 @@ cdrom_amigaos_c::~cdrom_amigaos_c(void)
}
}
bx_bool cdrom_amigaos_c::insert_cdrom(const char *dev)
bool cdrom_amigaos_c::insert_cdrom(const char *dev)
{
Bit8u cdb[6];
Bit8u buf[2*BX_CD_FRAMESIZE];
@ -218,7 +218,7 @@ void cdrom_amigaos_c::eject_cdrom()
}
bx_bool cdrom_amigaos_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
bool cdrom_amigaos_c::read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format)
{
Bit8u cdb[10];
TOC *toc;
@ -288,7 +288,7 @@ Bit32u cdrom_amigaos_c::capacity()
}
}
bx_bool cdrom_amigaos_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
bool cdrom_amigaos_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
{
int n;
Bit8u try_count = 3;

8
bochs/iodev/hdimage/cdrom_amigaos.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2013 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -29,11 +29,11 @@ class cdrom_amigaos_c : public cdrom_base_c {
public:
cdrom_amigaos_c(const char *dev);
virtual ~cdrom_amigaos_c(void);
bx_bool insert_cdrom(const char *dev = NULL);
bool insert_cdrom(const char *dev = NULL);
void eject_cdrom();
bx_bool read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format);
bool read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format);
Bit32u capacity();
bx_bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
private:
#if BX_WITH_AMIGAOS
BPTR fda;

6
bochs/iodev/hdimage/cdrom_misc.cc
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2020 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -107,7 +107,7 @@ extern "C" {
#include <stdio.h>
bx_bool cdrom_misc_c::start_cdrom()
bool cdrom_misc_c::start_cdrom()
{
// Spin up the cdrom drive.
@ -146,7 +146,7 @@ void cdrom_misc_c::eject_cdrom()
}
}
bx_bool cdrom_misc_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
bool cdrom_misc_c::read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format)
{
// Read CD TOC. Returns 0 if start track is out of bounds.

6
bochs/iodev/hdimage/cdrom_misc.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2013 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -24,8 +24,8 @@
class cdrom_misc_c : public cdrom_base_c {
public:
cdrom_misc_c(const char *dev) : cdrom_base_c(dev) {}
bx_bool start_cdrom();
bool start_cdrom();
void eject_cdrom();
bx_bool read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format);
bool read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format);
Bit32u capacity();
};

8
bochs/iodev/hdimage/cdrom_osx.cc
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2020 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -274,7 +274,7 @@ Exit:
}
bx_bool cdrom_osx_c::insert_cdrom(const char *dev)
bool cdrom_osx_c::insert_cdrom(const char *dev)
{
unsigned char buffer[BX_CD_FRAMESIZE];
ssize_t ret;
@ -332,7 +332,7 @@ bx_bool cdrom_osx_c::insert_cdrom(const char *dev)
return read_block(buffer, 0, 2048);
}
bx_bool cdrom_osx_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
bool cdrom_osx_c::read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format)
{
// Read CD TOC. Returns 0 if start track is out of bounds.
@ -483,7 +483,7 @@ Bit32u cdrom_osx_c::capacity()
}
}
bx_bool BX_CPP_AttrRegparmN(3) cdrom_osx_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
bool BX_CPP_AttrRegparmN(3) cdrom_osx_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
{
// Read a single block from the CD

8
bochs/iodev/hdimage/cdrom_osx.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2013 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -24,8 +24,8 @@
class cdrom_osx_c : public cdrom_base_c {
public:
cdrom_osx_c(const char *dev) : cdrom_base_c(dev) {}
bx_bool insert_cdrom(const char *dev = NULL);
bx_bool read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format);
bool insert_cdrom(const char *dev = NULL);
bool read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format);
Bit32u capacity();
bx_bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
};

8
bochs/iodev/hdimage/cdrom_win32.cc
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2020 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -150,7 +150,7 @@ cdrom_win32_c::~cdrom_win32_c(void)
}
}
bx_bool cdrom_win32_c::insert_cdrom(const char *dev)
bool cdrom_win32_c::insert_cdrom(const char *dev)
{
unsigned char buffer[BX_CD_FRAMESIZE];
@ -215,7 +215,7 @@ void cdrom_win32_c::eject_cdrom()
}
}
bx_bool cdrom_win32_c::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
bool cdrom_win32_c::read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format)
{
// Read CD TOC. Returns 0 if start track is out of bounds.
@ -271,7 +271,7 @@ Bit32u cdrom_win32_c::capacity()
}
}
bx_bool BX_CPP_AttrRegparmN(3) cdrom_win32_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
bool BX_CPP_AttrRegparmN(3) cdrom_win32_c::read_block(Bit8u* buf, Bit32u lba, int blocksize)
{
// Read a single block from the CD

8
bochs/iodev/hdimage/cdrom_win32.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2013 The Bochs Project
// Copyright (C) 2002-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -25,11 +25,11 @@ class cdrom_win32_c : public cdrom_base_c {
public:
cdrom_win32_c(const char *dev);
virtual ~cdrom_win32_c(void);
bx_bool insert_cdrom(const char *dev = NULL);
bool insert_cdrom(const char *dev = NULL);
void eject_cdrom();
bx_bool read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format);
bool read_toc(Bit8u* buf, int* length, bool msf, int start_track, int format);
Bit32u capacity();
bx_bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
bool read_block(Bit8u* buf, Bit32u lba, int blocksize) BX_CPP_AttrRegparmN(3);
private:
#ifdef WIN32
HANDLE hFile;

42
bochs/iodev/hdimage/hdimage.cc
View File

@ -533,12 +533,12 @@ void hdimage_restore_handler(void *class_ptr, bx_param_c *param, Bit64s value)
}
}
bx_bool hdimage_backup_file(int fd, const char *backup_fname)
bool hdimage_backup_file(int fd, const char *backup_fname)
{
char *buf;
off_t offset;
int nread, size;
bx_bool ret = 1;
bool ret = 1;
int backup_fd = ::open(backup_fname, O_RDWR | O_CREAT | O_TRUNC
#ifdef O_BINARY
@ -574,10 +574,10 @@ bx_bool hdimage_backup_file(int fd, const char *backup_fname)
}
#endif
bx_bool hdimage_copy_file(const char *src, const char *dst)
bool hdimage_copy_file(const char *src, const char *dst)
{
#ifdef WIN32
return (bx_bool)CopyFile(src, dst, FALSE);
return (bool)CopyFile(src, dst, FALSE);
#elif defined(linux)
pid_t pid, ws;
@ -599,7 +599,7 @@ bx_bool hdimage_copy_file(const char *src, const char *dst)
char *buf;
off_t offset;
int nread, size;
bx_bool ret = 1;
bool ret = 1;
fd1 = ::open(src, O_RDONLY
#ifdef O_BINARY
@ -727,7 +727,7 @@ int flat_image_t::check_format(int fd, Bit64u imgsize)
}
#ifndef BXIMAGE
bx_bool flat_image_t::save_state(const char *backup_fname)
bool flat_image_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(fd, backup_fname);
}
@ -942,9 +942,9 @@ ssize_t concat_image_t::write(const void* buf, size_t count)
}
#ifndef BXIMAGE
bx_bool concat_image_t::save_state(const char *backup_fname)
bool concat_image_t::save_state(const char *backup_fname)
{
bx_bool ret = 1;
bool ret = 1;
char tempfn[BX_PATHNAME_LEN];
for (int index = 0; index < maxfd; index++) {
@ -1033,7 +1033,7 @@ int sparse_image_t::read_header()
data_start = 0;
while ((size_t)data_start < preamble_size) data_start += pagesize;
bx_bool did_mmap = 0;
bool did_mmap = 0;
#ifdef _POSIX_MAPPED_FILES
// Try to memory map from the beginning of the file (0 is trivially a page multiple)
@ -1419,7 +1419,7 @@ ssize_t sparse_image_t::write(const void* buf, size_t count)
if (update_pagetable_count != 0)
{
bx_bool done = 0;
bool done = 0;
off_t pagetable_write_from = sizeof(header) + (sizeof(Bit32u) * update_pagetable_start);
size_t write_bytecount = update_pagetable_count * sizeof(Bit32u);
@ -1539,7 +1539,7 @@ int sparse_image_t::create_image(const char *pathname, Bit64u size)
return 0;
}
#else
bx_bool sparse_image_t::save_state(const char *backup_fname)
bool sparse_image_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(fd, backup_fname);
}
@ -1928,7 +1928,7 @@ Bit32u redolog_t::get_timestamp()
return dtoh32(header.specific.timestamp);
}
bx_bool redolog_t::set_timestamp(Bit32u timestamp)
bool redolog_t::set_timestamp(Bit32u timestamp)
{
header.specific.timestamp = htod32(timestamp);
// Update header
@ -2017,7 +2017,7 @@ ssize_t redolog_t::write(const void* buf, size_t count)
Bit32u i;
Bit64s block_offset, bitmap_offset, catalog_offset;
ssize_t written;
bx_bool update_catalog = 0;
bool update_catalog = 0;
if (count != 512) {
BX_PANIC(("redolog : write() with count not 512"));
@ -2188,7 +2188,7 @@ int redolog_t::commit(device_image_t *base_image)
#endif
#ifndef BXIMAGE
bx_bool redolog_t::save_state(const char *backup_fname)
bool redolog_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(fd, backup_fname);
}
@ -2276,7 +2276,7 @@ int growing_image_t::create_image(const char *pathname, Bit64u size)
return 0;
}
#else
bx_bool growing_image_t::save_state(const char *backup_fname)
bool growing_image_t::save_state(const char *backup_fname)
{
return redolog->save_state(backup_fname);
}
@ -2289,7 +2289,7 @@ void growing_image_t::restore_state(const char *backup_fname)
BX_PANIC(("Can't open growing image backup '%s'", backup_fname));
return;
} else {
bx_bool okay = (temp_redolog->get_size() == redolog->get_size());
bool okay = (temp_redolog->get_size() == redolog->get_size());
temp_redolog->close();
delete temp_redolog;
if (!okay) {
@ -2310,7 +2310,7 @@ void growing_image_t::restore_state(const char *backup_fname)
// compare hd_size and modification time of r/o disk and journal
bx_bool coherency_check(device_image_t *ro_disk, redolog_t *redolog)
bool coherency_check(device_image_t *ro_disk, redolog_t *redolog)
{
Bit32u timestamp1, timestamp2;
char buffer[24];
@ -2458,7 +2458,7 @@ ssize_t undoable_image_t::write(const void* buf, size_t count)
}
#ifndef BXIMAGE
bx_bool undoable_image_t::save_state(const char *backup_fname)
bool undoable_image_t::save_state(const char *backup_fname)
{
return redolog->save_state(backup_fname);
}
@ -2471,7 +2471,7 @@ void undoable_image_t::restore_state(const char *backup_fname)
BX_PANIC(("Can't open undoable redolog backup '%s'", backup_fname));
return;
} else {
bx_bool okay = coherency_check(ro_disk, temp_redolog);
bool okay = coherency_check(ro_disk, temp_redolog);
temp_redolog->close();
delete temp_redolog;
if (!okay) return;
@ -2632,7 +2632,7 @@ ssize_t volatile_image_t::write(const void* buf, size_t count)
}
#ifndef BXIMAGE
bx_bool volatile_image_t::save_state(const char *backup_fname)
bool volatile_image_t::save_state(const char *backup_fname)
{
return redolog->save_state(backup_fname);
}
@ -2645,7 +2645,7 @@ void volatile_image_t::restore_state(const char *backup_fname)
BX_PANIC(("Can't open volatile redolog backup '%s'", backup_fname));
return;
} else {
bx_bool okay = coherency_check(ro_disk, temp_redolog);
bool okay = coherency_check(ro_disk, temp_redolog);
temp_redolog->close();
delete temp_redolog;
if (!okay) return;

26
bochs/iodev/hdimage/hdimage.h
View File

@ -153,9 +153,9 @@ int hdimage_open_file(const char *pathname, int flags, Bit64u *fsize, time_t *mt
BOCHSAPI_MSVCONLY int hdimage_open_file(const char *pathname, int flags, Bit64u *fsize, FILETIME *mtime);
#endif
bool hdimage_detect_image_mode(const char *pathname, const char **image_mode);
BOCHSAPI_MSVCONLY bx_bool hdimage_backup_file(int fd, const char *backup_fname);
BOCHSAPI_MSVCONLY bx_bool hdimage_copy_file(const char *src, const char *dst);
bx_bool coherency_check(device_image_t *ro_disk, redolog_t *redolog);
BOCHSAPI_MSVCONLY bool hdimage_backup_file(int fd, const char *backup_fname);
BOCHSAPI_MSVCONLY bool hdimage_copy_file(const char *src, const char *dst);
bool coherency_check(device_image_t *ro_disk, redolog_t *redolog);
#ifndef WIN32
Bit16u fat_datetime(time_t time, int return_time);
#else
@ -206,7 +206,7 @@ class BOCHSAPI_MSVCONLY device_image_t
#else
// Save/restore support
virtual void register_state(bx_list_c *parent);
virtual bx_bool save_state(const char *backup_fname) {return 0;}
virtual bool save_state(const char *backup_fname) {return 0;}
virtual void restore_state(const char *backup_fname) {}
#endif
@ -250,7 +250,7 @@ class flat_image_t : public device_image_t
#ifndef BXIMAGE
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -286,7 +286,7 @@ class concat_image_t : public device_image_t
#ifndef BXIMAGE
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -352,7 +352,7 @@ class sparse_image_t : public device_image_t
int create_image(const char *pathname, Bit64u size);
#else
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -443,7 +443,7 @@ class BOCHSAPI_MSVCONLY redolog_t
void close();
Bit64u get_size();
Bit32u get_timestamp();
bx_bool set_timestamp(Bit32u timestamp);
bool set_timestamp(Bit32u timestamp);
Bit64s lseek(Bit64s offset, int whence);
ssize_t read(void* buf, size_t count);
@ -454,7 +454,7 @@ class BOCHSAPI_MSVCONLY redolog_t
#ifdef BXIMAGE
int commit(device_image_t *base_image);
#else
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
#endif
private:
@ -464,7 +464,7 @@ class BOCHSAPI_MSVCONLY redolog_t
redolog_header_t header; // Header is kept in x86 (little) endianness
Bit32u *catalog;
Bit8u *bitmap;
bx_bool bitmap_update;
bool bitmap_update;
Bit32u extent_index;
Bit32u extent_offset;
Bit32u extent_next;
@ -512,7 +512,7 @@ class growing_image_t : public device_image_t
int create_image(const char *pathname, Bit64u size);
#else
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -552,7 +552,7 @@ class undoable_image_t : public device_image_t
#ifndef BXIMAGE
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -595,7 +595,7 @@ class volatile_image_t : public device_image_t
#ifndef BXIMAGE
// Save/restore support
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif

6
bochs/iodev/hdimage/vbox.cc
View File

@ -288,12 +288,12 @@ int vbox_image_t::check_format(int fd, Bit64u imgsize)
return HDIMAGE_FORMAT_OK;
}
bx_bool vbox_image_t::is_open() const
bool vbox_image_t::is_open() const
{
return (file_descriptor != -1);
}
bx_bool vbox_image_t::read_header()
bool vbox_image_t::read_header()
{
int ret;
@ -422,7 +422,7 @@ Bit32u vbox_image_t::get_capabilities(void)
}
#ifndef BXIMAGE
bx_bool vbox_image_t::save_state(const char *backup_fname)
bool vbox_image_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(file_descriptor, backup_fname);
}

14
bochs/iodev/hdimage/vbox.h
View File

@ -10,7 +10,7 @@
* Contact: fys [at] fysnet [dot] net
*
* Copyright (C) 2015 Benjamin D Lunt.
* Copyright (C) 2006-2015 The Bochs Project
* Copyright (C) 2006-2021 The Bochs Project
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -90,7 +90,7 @@ class vbox_image_t : public device_image_t
static int check_format(int fd, Bit64u imgsize);
#ifndef BXIMAGE
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -98,9 +98,9 @@ class vbox_image_t : public device_image_t
static const off_t INVALID_OFFSET;
static const int SECTOR_SIZE;
bx_bool is_open() const;
bool is_open() const;
bx_bool read_header();
bool read_header();
off_t perform_seek();
void flush();
void read_block(const Bit32u index);
@ -112,9 +112,9 @@ class vbox_image_t : public device_image_t
Bit8u *block_data;
off_t current_offset;
Bit32u mtlb_sector;
bx_bool is_dirty;
bx_bool mtlb_dirty;
bx_bool header_dirty;
bool is_dirty;
bool mtlb_dirty;
bool header_dirty;
const char *pathname;
};

8
bochs/iodev/hdimage/vmware3.cc
View File

@ -99,7 +99,7 @@ int vmware3_image_t::check_format(int fd, Bit64u imgsize)
return HDIMAGE_FORMAT_OK;
}
bx_bool vmware3_image_t::read_header(int fd, COW_Header & header)
bool vmware3_image_t::read_header(int fd, COW_Header & header)
{
int ret;
@ -558,9 +558,9 @@ Bit32u vmware3_image_t::get_capabilities(void)
}
#ifndef BXIMAGE
bx_bool vmware3_image_t::save_state(const char *backup_fname)
bool vmware3_image_t::save_state(const char *backup_fname)
{
bx_bool ret = 1;
bool ret = 1;
char tempfn[BX_PATHNAME_LEN];
unsigned count = current->header.number_of_chains;
@ -577,7 +577,7 @@ void vmware3_image_t::restore_state(const char *backup_fname)
{
int temp_fd;
Bit64u imgsize;
bx_bool ret = 1;
bool ret = 1;
char tempfn[BX_PATHNAME_LEN];
if ((temp_fd = hdimage_open_file(backup_fname, O_RDONLY, &imgsize, NULL)) < 0) {

4
bochs/iodev/hdimage/vmware3.h
View File

@ -44,7 +44,7 @@ class vmware3_image_t : public device_image_t
static int check_format(int fd, Bit64u imgsize);
#ifndef BXIMAGE
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -112,7 +112,7 @@ class vmware3_image_t : public device_image_t
bool synced;
} * images, * current;
bx_bool read_header(int fd, COW_Header & header);
bool read_header(int fd, COW_Header & header);
int write_header(int fd, COW_Header & header);
int read_ints(int fd, Bit32u *buffer, size_t count);

6
bochs/iodev/hdimage/vmware4.cc
View File

@ -232,12 +232,12 @@ int vmware4_image_t::check_format(int fd, Bit64u imgsize)
return HDIMAGE_FORMAT_OK;
}
bx_bool vmware4_image_t::is_open() const
bool vmware4_image_t::is_open() const
{
return (file_descriptor != -1);
}
bx_bool vmware4_image_t::read_header()
bool vmware4_image_t::read_header()
{
int ret;
@ -497,7 +497,7 @@ int vmware4_image_t::create_image(const char *pathname, Bit64u size)
return 0;
}
#else
bx_bool vmware4_image_t::save_state(const char *backup_fname)
bool vmware4_image_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(file_descriptor, backup_fname);
}

8
bochs/iodev/hdimage/vmware4.h
View File

@ -80,7 +80,7 @@ class vmware4_image_t : public device_image_t
#ifdef BXIMAGE
int create_image(const char *pathname, Bit64u size);
#else
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif
@ -88,9 +88,9 @@ class vmware4_image_t : public device_image_t
static const off_t INVALID_OFFSET;
static const int SECTOR_SIZE;
bx_bool is_open() const;
bool is_open() const;
bx_bool read_header();
bool read_header();
off_t perform_seek();
void flush();
Bit32u read_block_index(Bit64u sector, Bit32u index);
@ -101,7 +101,7 @@ class vmware4_image_t : public device_image_t
Bit8u* tlb;
off_t tlb_offset;
off_t current_offset;
bx_bool is_dirty;
bool is_dirty;
const char *pathname;
};

2
bochs/iodev/hdimage/vpc.cc
View File

@ -407,7 +407,7 @@ int vpc_image_t::create_image(const char *pathname, Bit64u size)
return 0;
}
#else
bx_bool vpc_image_t::save_state(const char *backup_fname)
bool vpc_image_t::save_state(const char *backup_fname)
{
return hdimage_backup_file(fd, backup_fname);
}

2
bochs/iodev/hdimage/vpc.h
View File

@ -168,7 +168,7 @@ class vpc_image_t : public device_image_t
#ifdef BXIMAGE
int create_image(const char *pathname, Bit64u size);
#else
bx_bool save_state(const char *backup_fname);
bool save_state(const char *backup_fname);
void restore_state(const char *backup_fname);
#endif

36
bochs/iodev/hdimage/vvfat.cc
View File

@ -386,7 +386,7 @@ vvfat_image_t::~vvfat_image_t()
delete redolog;
}
bx_bool vvfat_image_t::sector2CHS(Bit32u spos, mbr_chs_t *chs)
bool vvfat_image_t::sector2CHS(Bit32u spos, mbr_chs_t *chs)
{
Bit32u head, sector;
@ -413,7 +413,7 @@ void vvfat_image_t::init_mbr(void)
{
mbr_t* real_mbr = (mbr_t*)first_sectors;
partition_t* partition = &(real_mbr->partition[0]);
bx_bool lba;
bool lba;
// Win NT Disk Signature
real_mbr->nt_id = htod32(0xbe1afdfa);
@ -690,8 +690,8 @@ int vvfat_image_t::read_directory(int mapping_index)
char* buffer;
direntry_t* direntry;
struct stat st;
bx_bool is_dot = !strcmp(entry->d_name, ".");
bx_bool is_dotdot = !strcmp(entry->d_name, "..");
bool is_dot = !strcmp(entry->d_name, ".");
bool is_dotdot = !strcmp(entry->d_name, "..");
if ((first_cluster == first_cluster_of_root_dir) && (is_dotdot || is_dot))
continue;
@ -703,9 +703,9 @@ int vvfat_image_t::read_directory(int mapping_index)
continue;
}
bx_bool is_mbr_file = !strcmp(entry->d_name, VVFAT_MBR);
bx_bool is_boot_file = !strcmp(entry->d_name, VVFAT_BOOT);
bx_bool is_attr_file = !strcmp(entry->d_name, VVFAT_ATTR);
bool is_mbr_file = !strcmp(entry->d_name, VVFAT_MBR);
bool is_boot_file = !strcmp(entry->d_name, VVFAT_BOOT);
bool is_attr_file = !strcmp(entry->d_name, VVFAT_ATTR);
if (first_cluster == first_cluster_of_root_dir) {
if (is_attr_file || ((is_mbr_file || is_boot_file) && (st.st_size == 512))) {
free(buffer);
@ -802,13 +802,13 @@ int vvfat_image_t::read_directory(int mapping_index)
unsigned int length = lstrlen(dirname) + 2 + lstrlen(finddata.cFileName);
char* buffer;
direntry_t* direntry;
bx_bool is_dot = !lstrcmp(finddata.cFileName, ".");
bx_bool is_dotdot = !lstrcmp(finddata.cFileName, "..");
bool is_dot = !lstrcmp(finddata.cFileName, ".");
bool is_dotdot = !lstrcmp(finddata.cFileName, "..");
if ((first_cluster == first_cluster_of_root_dir) && (is_dotdot || is_dot))
continue;
bx_bool is_mbr_file = !lstrcmp(finddata.cFileName, VVFAT_MBR);
bx_bool is_boot_file = !lstrcmp(finddata.cFileName, VVFAT_BOOT);
bx_bool is_attr_file = !lstrcmp(finddata.cFileName, VVFAT_ATTR);
bool is_mbr_file = !lstrcmp(finddata.cFileName, VVFAT_MBR);
bool is_boot_file = !lstrcmp(finddata.cFileName, VVFAT_BOOT);
bool is_attr_file = !lstrcmp(finddata.cFileName, VVFAT_ATTR);
if (first_cluster == first_cluster_of_root_dir) {
if (is_attr_file || ((is_mbr_file || is_boot_file) && (finddata.nFileSizeLow == 512)))
continue;
@ -1102,7 +1102,7 @@ int vvfat_image_t::init_directories(const char* dirname)
return 0;
}
bx_bool vvfat_image_t::read_sector_from_file(const char *path, Bit8u *buffer, Bit32u sector)
bool vvfat_image_t::read_sector_from_file(const char *path, Bit8u *buffer, Bit32u sector)
{
int fd = ::open(path, O_RDONLY
#ifdef O_BINARY
@ -1121,7 +1121,7 @@ bx_bool vvfat_image_t::read_sector_from_file(const char *path, Bit8u *buffer, Bi
}
int result = ::read(fd, buffer, 0x200);
::close(fd);
bx_bool bootsig = ((buffer[0x1fe] == 0x55) && (buffer[0x1ff] == 0xaa));
bool bootsig = ((buffer[0x1fe] == 0x55) && (buffer[0x1ff] == 0xaa));
return (result == 0x200) && bootsig;
}
@ -1195,7 +1195,7 @@ int vvfat_image_t::open(const char* dirname, int flags)
int filedes;
const char *logname = NULL;
char ftype[10];
bx_bool ftype_ok;
bool ftype_ok;
UNUSED(flags);
use_mbr_file = 0;
@ -1396,7 +1396,7 @@ direntry_t* vvfat_image_t::read_direntry(Bit8u *buffer, char *filename)
{
const Bit8u lfn_map[13] = {1, 3, 5, 7, 9, 14, 16, 18, 20, 22, 24, 28, 30};
direntry_t *entry;
bx_bool entry_ok = 0, has_lfn = 0;
bool entry_ok = 0, has_lfn = 0;
char lfn_tmp[BX_PATHNAME_LEN];
int i;
@ -1465,7 +1465,7 @@ Bit32u vvfat_image_t::fat_get_next(Bit32u current)
}
}
bx_bool vvfat_image_t::write_file(const char *path, direntry_t *entry, bx_bool create)
bool vvfat_image_t::write_file(const char *path, direntry_t *entry, bool create)
{
int fd;
Bit32u csize, fsize, fstart, cur, next, rsvd_clusters, bad_cluster;
@ -1967,7 +1967,7 @@ ssize_t vvfat_image_t::write(const void* buf, size_t count)
ssize_t ret = 0;
char *cbuf = (char*)buf;
Bit32u scount = (Bit32u)(count / 512);
bx_bool update_imagepos;
bool update_imagepos;
while (scount-- > 0) {
update_imagepos = 1;

14
bochs/iodev/hdimage/vvfat.h
View File

@ -6,7 +6,7 @@
// ported from QEMU block driver with some additions (see vvfat.cc)
//
// Copyright (c) 2004,2005 Johannes E. Schindelin
// Copyright (C) 2010-2020 The Bochs Project
// Copyright (C) 2010-2021 The Bochs Project
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@ -127,7 +127,7 @@ class vvfat_image_t : public device_image_t
Bit32u get_capabilities();
private:
bx_bool sector2CHS(Bit32u spos, mbr_chs_t *chs);
bool sector2CHS(Bit32u spos, mbr_chs_t *chs);
void init_mbr();
direntry_t* create_long_filename(const char* filename);
void fat_set(unsigned int cluster, Bit32u value);
@ -138,10 +138,10 @@ class vvfat_image_t : public device_image_t
Bit32u sector2cluster(off_t sector_num);
off_t cluster2sector(Bit32u cluster_num);
int init_directories(const char* dirname);
bx_bool read_sector_from_file(const char *path, Bit8u *buffer, Bit32u sector);
bool read_sector_from_file(const char *path, Bit8u *buffer, Bit32u sector);
void set_file_attributes(void);
Bit32u fat_get_next(Bit32u current);
bx_bool write_file(const char *path, direntry_t *entry, bx_bool create);
bool write_file(const char *path, direntry_t *entry, bool create);
direntry_t* read_direntry(Bit8u *buffer, char *filename);
void parse_directory(const char *path, Bit32u start_cluster);
void commit_changes(void);
@ -180,11 +180,11 @@ class vvfat_image_t : public device_image_t
const char *vvfat_path;
Bit32u sector_num;
bx_bool use_mbr_file;
bx_bool use_boot_file;
bool use_mbr_file;
bool use_boot_file;
FILE *vvfat_attr_fd;
bx_bool vvfat_modified;
bool vvfat_modified;
void *fat2;
redolog_t *redolog; // Redolog instance
char *redolog_name; // Redolog name

12
bochs/iodev/sound/es1370.cc
View File

@ -595,7 +595,7 @@ void bx_es1370_c::write(Bit32u address, Bit32u value, unsigned io_len)
Bit16u offset;
Bit32u shift, mask;
Bit8u index;
bx_bool set_wave_vol = 0;
bool set_wave_vol = 0;
chan_t *d = &BX_ES1370_THIS s.chan[0];
unsigned i;
@ -722,7 +722,7 @@ void bx_es1370_c::write(Bit32u address, Bit32u value, unsigned io_len)
}
}
Bit16u bx_es1370_c::calc_output_volume(Bit8u reg1, Bit8u reg2, bx_bool shift)
Bit16u bx_es1370_c::calc_output_volume(Bit8u reg1, Bit8u reg2, bool shift)
{
Bit8u vol1, vol2;
float fvol1, fvol2;
@ -764,7 +764,7 @@ Bit32u bx_es1370_c::run_channel(unsigned chan, int timer_id, Bit32u buflen)
Bit32u new_status = BX_ES1370_THIS s.status;
Bit32u addr, sc, csc_bytes, cnt, size, left, transfered, temp;
Bit8u tmpbuf[BX_SOUNDLOW_WAVEPACKETSIZE];
bx_bool irq = 0;
bool irq = 0;
chan_t *d = &BX_ES1370_THIS s.chan[chan];
@ -839,7 +839,7 @@ Bit32u bx_es1370_c::es1370_adc_handler(void *this_ptr, Bit32u buflen)
return 0;
}
void bx_es1370_c::set_irq_level(bx_bool level)
void bx_es1370_c::set_irq_level(bool level)
{
DEV_pci_set_irq(BX_ES1370_THIS s.devfunc, BX_ES1370_THIS pci_conf[0x3d], level);
}
@ -874,7 +874,7 @@ void bx_es1370_c::check_lower_irq(Bit32u sctl)
}
}
void bx_es1370_c::update_voices(Bit32u ctl, Bit32u sctl, bx_bool force)
void bx_es1370_c::update_voices(Bit32u ctl, Bit32u sctl, bool force)
{
unsigned i;
Bit32u old_freq, new_freq, old_fmt, new_fmt;
@ -913,7 +913,7 @@ void bx_es1370_c::update_voices(Bit32u ctl, Bit32u sctl, bx_bool force)
}
if (((ctl ^ BX_ES1370_THIS s.ctl) & ctl_ch_en[i]) ||
((sctl ^ BX_ES1370_THIS s.sctl) & sctl_ch_pause[i]) || force) {
bx_bool on = ((ctl & ctl_ch_en[i]) && !(sctl & sctl_ch_pause[i]));
bool on = ((ctl & ctl_ch_en[i]) && !(sctl & sctl_ch_pause[i]));
if (i == DAC1_CHANNEL) {
timer_id = BX_ES1370_THIS s.dac1_timer_index;

10
bochs/iodev/sound/es1370.h
View File

@ -5,7 +5,7 @@
// ES1370 soundcard support (ported from QEMU)
//
// Copyright (c) 2005 Vassili Karpov (malc)
// Copyright (C) 2011-2017 The Bochs Project
// Copyright (C) 2011-2021 The Bochs Project
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@ -63,7 +63,7 @@ typedef struct {
int dac1_timer_index;
int dac2_timer_index;
Bit8u dac_outputinit;
bx_bool adc_inputinit;
bool adc_inputinit;
int dac_nr_active;
Bit16u dac_packet_size[2];
Bit32u dac_timer_val[2];
@ -104,14 +104,14 @@ public:
private:
bx_es1370_t s;
BX_ES1370_SMF void set_irq_level(bx_bool level);
BX_ES1370_SMF void set_irq_level(bool level);
BX_ES1370_SMF void update_status(Bit32u new_status);
BX_ES1370_SMF void check_lower_irq(Bit32u sctl);
BX_ES1370_SMF void update_voices(Bit32u ctl, Bit32u sctl, bx_bool force);
BX_ES1370_SMF void update_voices(Bit32u ctl, Bit32u sctl, bool force);
BX_ES1370_SMF Bit32u run_channel(unsigned channel, int timer_id, Bit32u buflen);
BX_ES1370_SMF void sendwavepacket(unsigned channel, Bit32u buflen, Bit8u *buffer);
BX_ES1370_SMF void closewaveoutput();
BX_ES1370_SMF Bit16u calc_output_volume(Bit8u reg1, Bit8u reg2, bx_bool shift);
BX_ES1370_SMF Bit16u calc_output_volume(Bit8u reg1, Bit8u reg2, bool shift);
BX_ES1370_SMF int currentdeltatime();
BX_ES1370_SMF void writemidicommand(int command, int length, Bit8u data[]);

4
bochs/iodev/sound/opl.cc
View File

@ -996,12 +996,12 @@ static void OPL_INLINE clipit16(Bit32s ival, Bit16s* outval, Bit8u vol)
opl_active = 1;
#endif
bx_bool adlib_getsample(Bit16u rate, Bit16s* sndptr, Bits numsamples, Bit16u volume)
bool adlib_getsample(Bit16u rate, Bit16s* sndptr, Bits numsamples, Bit16u volume)
{
Bit8u lvol, rvol;
Bits i, endsamples;
op_type* cptr;
bx_bool opl_active = 0;
bool opl_active = 0;
Bit32s outbufl[BLOCKBUF_SIZE];
#if defined(OPLTYPE_IS_OPL3)

10
bochs/iodev/sound/opl.h
View File

@ -3,7 +3,7 @@
/////////////////////////////////////////////////////////////////////////
/*
* Copyright (C) 2002-2013 The DOSBox Team
* Copyright (C) 2015 The Bochs Project
* Copyright (C) 2015-2021 The Bochs Project
* OPL2/OPL3 emulation library
*
* This library is free software; you can redistribute it and/or
@ -136,8 +136,8 @@ typedef struct operator_struct {
Bit16s* cur_wform; // start of selected waveform
Bit32u cur_wmask; // mask for selected waveform
Bit32u act_state; // activity state (regular, percussion)
bx_bool sus_keep; // keep sustain level when decay finished
bx_bool vibrato,tremolo; // vibrato/tremolo enable bits
bool sus_keep; // keep sustain level when decay finished
bool vibrato,tremolo; // vibrato/tremolo enable bits
// variables used to provide non-continuous envelopes
Bit32u generator_pos; // for non-standard sample rates we need to determine how many samples have passed
@ -147,7 +147,7 @@ typedef struct operator_struct {
Bits env_step_skip_a; // bitmask that determines if a step is skipped (respective bit is zero then)
#if defined(OPLTYPE_IS_OPL3)
bx_bool is_4op,is_4op_attached; // base of a 4op channel/part of a 4op channel
bool is_4op,is_4op_attached; // base of a 4op channel/part of a 4op channel
Bit32s left_pan,right_pan; // opl3 stereo panning amount
#endif
} op_type;
@ -196,7 +196,7 @@ static Bit32u generator_add; // should be a chip parameter
// general functions
void adlib_init(Bit32u samplerate);
void adlib_write(Bitu idx, Bit8u val);
bx_bool adlib_getsample(Bit16u rate, Bit16s* sndptr, Bits numsamples, Bit16u volume);
bool adlib_getsample(Bit16u rate, Bit16s* sndptr, Bits numsamples, Bit16u volume);
Bitu adlib_reg_read(Bitu port);
void adlib_write_index(Bitu port, Bit8u val);

32
bochs/iodev/sound/sb16.cc
View File

@ -1251,7 +1251,7 @@ void bx_sb16_c::dsp_dma(Bit8u command, Bit8u mode, Bit16u length, Bit8u comp)
{
int ret;
bx_list_c *base;
bx_bool issigned;
bool issigned;
// command: 8bit, 16bit, in/out, single/auto, fifo
// mode: mono/stereo, signed/unsigned
@ -1645,7 +1645,7 @@ Bit16u bx_sb16_c::dma_write16(Bit16u *buffer, Bit16u maxlen)
return len;
}
Bit16u bx_sb16_c::calc_output_volume(Bit8u reg1, Bit8u reg2, bx_bool shift)
Bit16u bx_sb16_c::calc_output_volume(Bit8u reg1, Bit8u reg2, bool shift)
{
Bit8u vol1, vol2;
float fvol1, fvol2;
@ -1842,7 +1842,7 @@ void bx_sb16_c::mixer_writeregister(Bit32u value)
void bx_sb16_c::set_irq_dma()
{
static bx_bool isInitialized=0;
static bool isInitialized=0;
int newirq;
int oldDMA8, oldDMA16;
@ -2110,7 +2110,7 @@ void bx_sb16_c::mpu_datawrite(Bit32u value)
void bx_sb16_c::mpu_mididata(Bit32u value)
{
// first, find out if it is a midi command or midi data
bx_bool ismidicommand = 0;
bool ismidicommand = 0;
if (value >= 0x80)
{ // bit 8 usually denotes a midi command...
ismidicommand = 1;
@ -2427,7 +2427,7 @@ void bx_sb16_c::opl_settimermask(int value, int chipid)
Bit32u bx_sb16_c::fmopl_generator(Bit16u rate, Bit8u *buffer, Bit32u len)
{
bx_bool ret = adlib_getsample(rate, (Bit16s*)buffer, len / 4, BX_SB16_THIS fm_volume);
bool ret = adlib_getsample(rate, (Bit16s*)buffer, len / 4, BX_SB16_THIS fm_volume);
return ret ? len : 0;
}
@ -2500,11 +2500,11 @@ int bx_sb16_c::currentdeltatime()
// process the midi command stored in MPU_B.midicmd.to the midi driver
void bx_sb16_c::processmidicommand(bx_bool force)
void bx_sb16_c::processmidicommand(bool force)
{
int i, channel;
Bit8u value;
bx_bool needremap = 0;
bool needremap = 0;
channel = MPU_B.midicmd.currentcommand() & 0xf;
@ -2964,7 +2964,7 @@ int bx_sb16_buffer::bytes(void)
}
// This puts one byte into the buffer
bx_bool bx_sb16_buffer::put(Bit8u data)
bool bx_sb16_buffer::put(Bit8u data)
{
if (full() != 0)
return 0; // buffer full
@ -2976,7 +2976,7 @@ bx_bool bx_sb16_buffer::put(Bit8u data)
}
// This writes a formatted string to the buffer
bx_bool bx_sb16_buffer::puts(const char *data, ...)
bool bx_sb16_buffer::puts(const char *data, ...)
{
if (data == NULL)
return 0; // invalid string
@ -3009,7 +3009,7 @@ bx_bool bx_sb16_buffer::puts(const char *data, ...)
}
// This returns if the buffer is full, i.e. if a put will fail
bx_bool bx_sb16_buffer::full(void)
bool bx_sb16_buffer::full(void)
{
if (length == 0)
return 1; // not initialized
@ -3021,7 +3021,7 @@ bx_bool bx_sb16_buffer::full(void)
}
// This reads the next available byte from the buffer
bx_bool bx_sb16_buffer::get(Bit8u *data)
bool bx_sb16_buffer::get(Bit8u *data)
{
if (empty() != 0)
{
@ -3039,7 +3039,7 @@ bx_bool bx_sb16_buffer::get(Bit8u *data)
}
// Read a word in lo/hi order
bx_bool bx_sb16_buffer::getw(Bit16u *data)
bool bx_sb16_buffer::getw(Bit16u *data)
{
Bit8u dummy;
if (bytes() < 2)
@ -3061,7 +3061,7 @@ bx_bool bx_sb16_buffer::getw(Bit16u *data)
}
// Read a word in hi/lo order
bx_bool bx_sb16_buffer::getw1(Bit16u *data)
bool bx_sb16_buffer::getw1(Bit16u *data)
{
Bit8u dummy;
if (bytes() < 2)
@ -3083,7 +3083,7 @@ bx_bool bx_sb16_buffer::getw1(Bit16u *data)
}
// This returns if the buffer is empty, i.e. if a get will fail
bx_bool bx_sb16_buffer::empty(void)
bool bx_sb16_buffer::empty(void)
{
if (length == 0)
return 1; // not inialized
@ -3131,7 +3131,7 @@ void bx_sb16_buffer::clearcommand(void)
}
// return if the command has received all necessary bytes
bx_bool bx_sb16_buffer::commanddone(void)
bool bx_sb16_buffer::commanddone(void)
{
if (hascommand() == 0)
return 0; // no command pending - not done then
@ -3143,7 +3143,7 @@ bx_bool bx_sb16_buffer::commanddone(void)
}
// return if there is a command pending
bx_bool bx_sb16_buffer::hascommand(void)
bool bx_sb16_buffer::hascommand(void)
{
return havecommand;
}

44
bochs/iodev/sound/sb16.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001-2020 The Bochs Project
// Copyright (C) 2001-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -91,24 +91,24 @@ public:
BX_SB16_BUFINL void reset();
/* These functions return 1 on success and 0 on error */
BX_SB16_BUFINL bx_bool put(Bit8u data); // write one byte in the buffer
BX_SB16_BUFINL bx_bool puts(const char *data, ...); // write a formatted string to the buffer
BX_SB16_BUFINL bx_bool get(Bit8u *data); // read the next available byte
BX_SB16_BUFINL bx_bool getw(Bit16u *data); // get word, in order lo/hi
BX_SB16_BUFINL bx_bool getw1(Bit16u *data);// get word, in order hi/lo
BX_SB16_BUFINL bx_bool full(void); // is the buffer full?
BX_SB16_BUFINL bx_bool empty(void); // is it empty?
BX_SB16_BUFINL bool put(Bit8u data); // write one byte in the buffer
BX_SB16_BUFINL bool puts(const char *data, ...); // write a formatted string to the buffer
BX_SB16_BUFINL bool get(Bit8u *data); // read the next available byte
BX_SB16_BUFINL bool getw(Bit16u *data); // get word, in order lo/hi
BX_SB16_BUFINL bool getw1(Bit16u *data);// get word, in order hi/lo
BX_SB16_BUFINL bool full(void); // is the buffer full?
BX_SB16_BUFINL bool empty(void); // is it empty?
BX_SB16_BUFINL void flush(void); // empty the buffer
BX_SB16_BUFINL int bytes(void); // return number of bytes in the buffer
BX_SB16_BUFINL Bit8u peek(int ahead); // peek ahead number of bytes
BX_SB16_BUFINL void flush(void); // empty the buffer
BX_SB16_BUFINL int bytes(void); // return number of bytes in the buffer
BX_SB16_BUFINL Bit8u peek(int ahead); // peek ahead number of bytes
/* These are for caching the command number */
BX_SB16_BUFINL void newcommand(Bit8u newcmd, int bytes); // start a new command with length bytes
BX_SB16_BUFINL Bit8u currentcommand(void); // return the current command
BX_SB16_BUFINL void clearcommand(void); // clear the command
BX_SB16_BUFINL bx_bool commanddone(void); // return if all bytes have arrived
BX_SB16_BUFINL bx_bool hascommand(void); // return if there is a pending command
BX_SB16_BUFINL bool commanddone(void); // return if all bytes have arrived
BX_SB16_BUFINL bool hascommand(void); // return if there is a pending command
BX_SB16_BUFINL int commandbytes(void); // return the length of the command
@ -116,7 +116,7 @@ private:
Bit8u *buffer;
int head,tail,length;
Bit8u command;
bx_bool havecommand;
bool havecommand;
int bytesneeded;
};
@ -168,7 +168,7 @@ private:
bx_sb16_buffer datain, dataout, cmd, midicmd;
} b;
struct {
bx_bool uartmode, irqpending, forceuartmode, singlecommand;
bool uartmode, irqpending, forceuartmode, singlecommand;
int banklsb[16];
int bankmsb[16]; // current patch lists
@ -188,9 +188,9 @@ private:
struct {
Bit8u resetport; // last value written to the reset port
Bit8u speaker,prostereo; // properties of the sound input/output
bx_bool irqpending; // Is an IRQ pending (not ack'd)
bx_bool midiuartmode; // Is the DSP in MIDI UART mode
bx_bool nondma_mode; // Set if DSP command 0x10 active
bool irqpending; // Is an IRQ pending (not ack'd)
bool midiuartmode; // Is the DSP in MIDI UART mode
bool nondma_mode; // Set if DSP command 0x10 active
Bit32u nondma_count; // Number of samples sent in non-DMA mode
Bit8u samplebyte; // Current data byte in non-DMA mode
Bit8u testreg;
@ -206,7 +206,7 @@ private:
// highspeed= 0: normal mode, 1: highspeed mode (only SBPro)
// timer= so many us between data bytes
int mode, bps, timer;
bx_bool fifo, output, highspeed;
bool fifo, output, highspeed;
bx_pcm_param_t param;
Bit16u count; // bytes remaining in this transfer
Bit8u *chunk; // buffers up to BX_SOUNDLOW_WAVEPACKETSIZE bytes
@ -217,7 +217,7 @@ private:
} dma;
int timer_handle; // handle for the DMA timer
Bit8u outputinit; // have the lowlevel output been initialized
bx_bool inputinit; // have the lowlevel input been initialized
bool inputinit; // have the lowlevel input been initialized
} d;
} dsp;
@ -287,7 +287,7 @@ private:
BX_SB16_SMF Bit32u mixer_readdata(void);
BX_SB16_SMF void mixer_writedata(Bit32u value);
BX_SB16_SMF void mixer_writeregister(Bit32u value);
BX_SB16_SMF Bit16u calc_output_volume(Bit8u reg1, Bit8u reg2, bx_bool shift);
BX_SB16_SMF Bit16u calc_output_volume(Bit8u reg1, Bit8u reg2, bool shift);
BX_SB16_SMF void set_irq_dma();
/* The emulator ports to change emulator properties */
@ -303,7 +303,7 @@ private:
/* several high level sound handlers */
BX_SB16_SMF int currentdeltatime();
BX_SB16_SMF void processmidicommand(bx_bool force);
BX_SB16_SMF void processmidicommand(bool force);
BX_SB16_SMF void midiremapprogram(int channel); // remap program change
BX_SB16_SMF void writemidicommand(int command, int length, Bit8u data[]);

2
bochs/iodev/sound/soundalsa.cc
View File

@ -45,7 +45,7 @@ PLUGIN_ENTRY_FOR_SND_MODULE(alsa)
// helper function for wavein / waveout
int alsa_pcm_open(bx_bool mode, alsa_pcm_t *alsa_pcm, bx_pcm_param_t *param, logfunctions *log)
int alsa_pcm_open(bool mode, alsa_pcm_t *alsa_pcm, bx_pcm_param_t *param, logfunctions *log)
{
snd_pcm_format_t fmt;
snd_pcm_hw_params_t *hwparams;

8
bochs/iodev/sound/soundlow.cc
View File

@ -95,8 +95,8 @@ static void convert_to_float(Bit8u *src, unsigned srcsize, audio_buffer_t *audio
{
unsigned i, j;
bx_pcm_param_t *param = &audiobuf->param;
bx_bool issigned = (param->format & 1);
bx_bool setvol = (param->volume != BX_MAX_BIT16U);
bool issigned = (param->format & 1);
bool setvol = (param->volume != BX_MAX_BIT16U);
Bit16s val16s;
Bit16u val16u;
float volume[2];
@ -355,7 +355,7 @@ void bx_soundlow_waveout_c::unregister_wave_callback(int callback_id)
BX_UNLOCK(mixer_mutex);
}
bx_bool bx_soundlow_waveout_c::mixer_common(Bit8u *buffer, int len)
bool bx_soundlow_waveout_c::mixer_common(Bit8u *buffer, int len)
{
Bit32u count, len2 = 0, len3 = 0;
Bit16s src1, src2, dst_val;
@ -642,7 +642,7 @@ bx_sound_lowlevel_c::~bx_sound_lowlevel_c()
}
}
bx_bool bx_sound_lowlevel_c::module_present(const char *type)
bool bx_sound_lowlevel_c::module_present(const char *type)
{
bx_sound_lowlevel_c *ptr = 0;

14
bochs/iodev/sound/soundlow.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011-2017 The Bochs Project
// Copyright (C) 2011-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -108,10 +108,10 @@ public:
virtual void resampler(audio_buffer_t *inbuffer, audio_buffer_t *outbuffer);
virtual bx_bool mixer_common(Bit8u *buffer, int len);
virtual bool mixer_common(Bit8u *buffer, int len);
bx_bool resampler_running() {return res_thread_start;}
bx_bool mixer_running() {return mix_thread_start;}
bool resampler_running() {return res_thread_start;}
bool mixer_running() {return mix_thread_start;}
protected:
void start_resampler_thread(void);
@ -119,8 +119,8 @@ protected:
Bit32u resampler_common(audio_buffer_t *inbuffer, float **fbuffer);
bx_pcm_param_t real_pcm_param;
bx_bool res_thread_start;
bx_bool mix_thread_start;
bool res_thread_start;
bool mix_thread_start;
BX_THREAD_VAR(res_thread_var);
BX_THREAD_VAR(mix_thread_var);
#if BX_HAVE_LIBSAMPLERATE || BX_HAVE_SOXR_LSR
@ -173,7 +173,7 @@ public:
class BOCHSAPI_MSVCONLY bx_sound_lowlevel_c : public logfunctions {
public:
static bx_bool module_present(const char *type);
static bool module_present(const char *type);
static bx_sound_lowlevel_c* get_module(const char *type);
static void cleanup();

4
bochs/iodev/sound/soundmod.cc
View File

@ -79,7 +79,7 @@ bx_sound_lowlevel_c* bx_soundmod_ctl_c::get_driver(int driver_id)
return bx_sound_lowlevel_c::get_module(modname);
}
bx_soundlow_waveout_c* bx_soundmod_ctl_c::get_waveout(bx_bool using_file)
bx_soundlow_waveout_c* bx_soundmod_ctl_c::get_waveout(bool using_file)
{
bx_sound_lowlevel_c *module = NULL;
@ -116,7 +116,7 @@ bx_soundlow_wavein_c* bx_soundmod_ctl_c::get_wavein()
return wavein;
}
bx_soundlow_midiout_c* bx_soundmod_ctl_c::get_midiout(bx_bool using_file)
bx_soundlow_midiout_c* bx_soundmod_ctl_c::get_midiout(bool using_file)
{
bx_sound_lowlevel_c *module = NULL;
bx_soundlow_midiout_c *midiout = NULL;

8
bochs/iodev/sound/soundmod.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011-2017 The Bochs Project
// Copyright (C) 2011-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -32,10 +32,10 @@ public:
~bx_soundmod_ctl_c() {}
void init(void);
void exit(void);
bx_bool register_driver(bx_sound_lowlevel_c *module, int driver_id);
bx_soundlow_waveout_c* get_waveout(bx_bool using_file);
bool register_driver(bx_sound_lowlevel_c *module, int driver_id);
bx_soundlow_waveout_c* get_waveout(bool using_file);
bx_soundlow_wavein_c* get_wavein();
bx_soundlow_midiout_c* get_midiout(bx_bool using_file);
bx_soundlow_midiout_c* get_midiout(bool using_file);
private:
bx_sound_lowlevel_c* get_driver(int driver_id);

2
bochs/iodev/sound/soundsdl.cc
View File

@ -148,7 +148,7 @@ void bx_soundlow_waveout_sdl_c::resampler(audio_buffer_t *inbuffer, audio_buffer
}
}
bx_bool bx_soundlow_waveout_sdl_c::mixer_common(Bit8u *buffer, int len)
bool bx_soundlow_waveout_sdl_c::mixer_common(Bit8u *buffer, int len)
{
Bit32u len2 = 0;

8
bochs/iodev/sound/soundsdl.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2012-2017 The Bochs Project
// Copyright (C) 2012-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -39,10 +39,10 @@ public:
virtual void unregister_wave_callback(int callback_id);
virtual void resampler(audio_buffer_t *inbuffer, audio_buffer_t *outbuffer);
virtual bx_bool mixer_common(Bit8u *buffer, int len);
virtual bool mixer_common(Bit8u *buffer, int len);
private:
bx_bool WaveOutOpen;
bool WaveOutOpen;
SDL_AudioSpec fmt;
};
@ -60,7 +60,7 @@ public:
static void record_timer_handler(void *);
void record_timer(void);
private:
bx_bool WaveInOpen;
bool WaveInOpen;
SDL_AudioSpec fmt;
SDL_AudioDeviceID devID;
};

2
bochs/iodev/sound/soundwin.cc
View File

@ -118,7 +118,7 @@ int bx_soundlow_waveout_win_c::set_pcm_params(bx_pcm_param_t *param)
// try three times to find a suitable format
for (int tries = 0; tries < 3; tries++) {
int frequency = real_pcm_param.samplerate;
bx_bool stereo = real_pcm_param.channels == 2;
bool stereo = real_pcm_param.channels == 2;
int bits = real_pcm_param.bits;
int bps = (bits / 8) * (stereo + 1);

4
bochs/iodev/sound/soundwin.h
View File

@ -2,7 +2,7 @@
// $Id$
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001-2015 The Bochs Project
// Copyright (C) 2001-2021 The Bochs Project
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -196,7 +196,7 @@ private:
LPWAVEHDR WaveInHdr;
LPSTR WaveInData;
bx_bool recording;
bool recording;
int recordnextpacket();
};