Retro/pcem
Watch
1
0
Fork
You've already forked pcem
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove C99 declarations in for loops from MiniVHD. Patch from Greatpsycho.

Browse source
This commit is contained in:
SarahW 2020-11-26 08:39:54 +00:00
commit 0ec9c6e728
6 changed files with 35 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/minivhd/minivhd_convert.c
View file

@ -64,8 +64,8 @@ MVHDMeta* mvhd_convert_to_vhd_sparse(const char* utf8_raw_path, const char* utf8
uint8_t buff[4096] = {0}; // 8 sectors
uint8_t empty_buff[4096] = {0};
int total_sectors = mvhd_calc_size_sectors(&geom);
int copy_sect = 0;
for (int i = 0; i < total_sectors; i += 8) {
int copy_sect = 0, i;
for (i = 0; i < total_sectors; i += 8) {
copy_sect = 8;
if ((i + 8) >= total_sectors) {
copy_sect = total_sectors - i;
@ -93,8 +93,8 @@ FILE* mvhd_convert_to_raw(const char* utf8_vhd_path, const char* utf8_raw_path,
}
uint8_t buff[4096] = {0}; // 8 sectors
int total_sectors = mvhd_calc_size_sectors((MVHDGeom*)&vhdm->footer.geom);
int copy_sect = 0;
for (int i = 0; i < total_sectors; i += 8) {
int copy_sect = 0, i;
for (i = 0; i < total_sectors; i += 8) {
copy_sect = 8;
if ((i + 8) >= total_sectors) {
copy_sect = total_sectors - i;

9
src/minivhd/minivhd_create.c
View file

@ -356,7 +356,8 @@ static MVHDMeta* mvhd_create_sparse_diff(const char* path, const char* par_path,
mvhd_header_to_buffer(&vhdm->sparse, sparse_buff);
fwrite(sparse_buff, sizeof sparse_buff, 1, f);
/* The BAT sectors need to be filled with 0xffffffff */
for (uint32_t i = 0; i < num_bat_sect; i++) {
uint32_t i;
for (i = 0; i < num_bat_sect; i++) {
fwrite(bat_sect, sizeof bat_sect, 1, f);
}
mvhd_write_empty_sectors(f, 5);
@ -370,8 +371,10 @@ static MVHDMeta* mvhd_create_sparse_diff(const char* path, const char* par_path,
assert(curr_pos == par_loc_offset);
/* Fill the space required for location data with zero */
uint8_t empty_sect[MVHD_SECTOR_SIZE] = {0};
for (int i = 0; i < 2; i++) {
for (uint32_t j = 0; j < (vhdm->sparse.par_loc_entry[i].plat_data_space / MVHD_SECTOR_SIZE); j++) {
int i;
uint32_t j;
for (i = 0; i < 2; i++) {
for (j = 0; j < (vhdm->sparse.par_loc_entry[i].plat_data_space / MVHD_SECTOR_SIZE); j++) {
fwrite(empty_sect, sizeof empty_sect, 1, f);
}
}

6
src/minivhd/minivhd_io.c
View file

@ -45,7 +45,8 @@ static inline void mvhd_check_sectors(uint32_t offset, int num_sectors, uint32_t
void mvhd_write_empty_sectors(FILE* f, int sector_count) {
uint8_t zero_bytes[MVHD_SECTOR_SIZE] = {0};
for (int i = 0; i < sector_count; i++) {
int i;
for (i = 0; i < sector_count; i++) {
fwrite(zero_bytes, sizeof zero_bytes, 1, f);
}
}
@ -126,7 +127,8 @@ static void mvhd_create_block(MVHDMeta* vhdm, int blk) {
/* Yikes! We're supposed to be on a sector boundary. Add some padding */
int64_t padding_amount = (int64_t)MVHD_SECTOR_SIZE - (abs_offset % MVHD_SECTOR_SIZE);
uint8_t zero_byte = 0;
for (int i = 0; i < padding_amount; i++) {
int i;
for (i = 0; i < padding_amount; i++) {
fwrite(&zero_byte, sizeof zero_byte, 1, vhdm->f);
}
abs_offset += padding_amount;

9
src/minivhd/minivhd_manage.c
View file

@ -103,7 +103,8 @@ static int mvhd_read_bat(MVHDMeta *vhdm, MVHDError* err) {
return -1;
}
mvhd_fseeko64(vhdm->f, vhdm->sparse.bat_offset, SEEK_SET);
for (uint32_t i = 0; i < vhdm->sparse.max_bat_ent; i++) {
uint32_t i;
for (i = 0; i < vhdm->sparse.max_bat_ent; i++) {
fread(&vhdm->block_offset[i], sizeof *vhdm->block_offset, 1, vhdm->f);
vhdm->block_offset[i] = mvhd_from_be32(vhdm->block_offset[i]);
}
@ -239,7 +240,8 @@ static char* mvhd_get_diff_parent_path(MVHDMeta* vhdm, int* err) {
}
/* Now read the parent locator entries, both relative and absolute, if they exist */
unsigned char* loc_path;
for (int i = 0; i < 8; i++) {
int i;
for (i = 0; i < 8; i++) {
utf_outlen = MVHD_MAX_PATH_BYTES - 1;
if (vhdm->sparse.par_loc_entry[i].plat_code == MVHD_DIF_LOC_W2RU) {
loc_path = (unsigned char*)paths->w2ru_path;
@ -526,7 +528,8 @@ int mvhd_write_sectors(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* i
int mvhd_format_sectors(MVHDMeta* vhdm, uint32_t offset, int num_sectors) {
int num_full = num_sectors / vhdm->format_buffer.sector_count;
int remain = num_sectors % vhdm->format_buffer.sector_count;
for (int i = 0; i < num_full; i++) {
int i;
for (i = 0; i < num_full; i++) {
vhdm->write_sectors(vhdm, offset, vhdm->format_buffer.sector_count, vhdm->format_buffer.zero_data);
offset += vhdm->format_buffer.sector_count;
}

6
src/minivhd/minivhd_struct_rw.c
View file

@ -133,7 +133,8 @@ void mvhd_buffer_to_header(MVHDSparseHeader* header, uint8_t* buffer) {
mvhd_next_buffer_to_struct(&header->par_timestamp, sizeof header->par_timestamp, true, &buff_ptr);
mvhd_next_buffer_to_struct(&header->reserved_1, sizeof header->reserved_1, true, &buff_ptr);
mvhd_next_buffer_to_struct(&header->par_utf16_name, sizeof header->par_utf16_name, false, &buff_ptr);
for (int i = 0; i < 8; i++) {
int i;
for (i = 0; i < 8; i++) {
mvhd_next_buffer_to_struct(&header->par_loc_entry[i].plat_code, sizeof header->par_loc_entry[i].plat_code, true, &buff_ptr);
mvhd_next_buffer_to_struct(&header->par_loc_entry[i].plat_data_space, sizeof header->par_loc_entry[i].plat_data_space, true, &buff_ptr);
mvhd_next_buffer_to_struct(&header->par_loc_entry[i].plat_data_len, sizeof header->par_loc_entry[i].plat_data_len, true, &buff_ptr);
@ -156,7 +157,8 @@ void mvhd_header_to_buffer(MVHDSparseHeader* header, uint8_t* buffer) {
mvhd_next_struct_to_buffer(&header->par_timestamp, sizeof header->par_timestamp, true, &buff_ptr);
mvhd_next_struct_to_buffer(&header->reserved_1, sizeof header->reserved_1, true, &buff_ptr);
mvhd_next_struct_to_buffer(&header->par_utf16_name, sizeof header->par_utf16_name, false, &buff_ptr);
for (int i = 0; i < 8; i++) {
int i;
for (i = 0; i < 8; i++) {
mvhd_next_struct_to_buffer(&header->par_loc_entry[i].plat_code, sizeof header->par_loc_entry[i].plat_code, true, &buff_ptr);
mvhd_next_struct_to_buffer(&header->par_loc_entry[i].plat_data_space, sizeof header->par_loc_entry[i].plat_data_space, true, &buff_ptr);
mvhd_next_struct_to_buffer(&header->par_loc_entry[i].plat_data_len, sizeof header->par_loc_entry[i].plat_data_len, true, &buff_ptr);

17
src/minivhd/minivhd_util.c
View file

@ -94,7 +94,8 @@ void mvhd_generate_uuid(uint8_t* uuid)
{
/* We aren't doing crypto here, so using system time as seed should be good enough */
srand((unsigned int)time(0));
for (int n = 0; n < 16; n++) {
int n;
for (n = 0; n < 16; n++) {
uuid[n] = rand();
}
uuid[6] &= 0x0F;
@ -196,7 +197,8 @@ uint32_t mvhd_gen_footer_checksum(MVHDFooter* footer) {
uint32_t orig_chk = footer->checksum;
footer->checksum = 0;
uint8_t* footer_bytes = (uint8_t*)footer;
for (size_t i = 0; i < sizeof *footer; i++) {
size_t i;
for (i = 0; i < sizeof *footer; i++) {
new_chk += footer_bytes[i];
}
footer->checksum = orig_chk;
@ -208,7 +210,8 @@ uint32_t mvhd_gen_sparse_checksum(MVHDSparseHeader* header) {
uint32_t orig_chk = header->checksum;
header->checksum = 0;
uint8_t* sparse_bytes = (uint8_t*)header;
for (size_t i = 0; i < sizeof *header; i++) {
size_t i;
for (i = 0; i < sizeof *header; i++) {
new_chk += sparse_bytes[i];
}
header->checksum = orig_chk;
@ -279,19 +282,21 @@ int mvhd_fseeko64(FILE* stream, int64_t offset, int origin)
}
uint32_t mvhd_crc32_for_byte(uint32_t r) {
for (int j = 0; j < 8; ++j)
int j;
for (j = 0; j < 8; ++j)
r = (r & 1 ? 0 : (uint32_t)0xEDB88320L) ^ r >> 1;
return r ^ (uint32_t)0xFF000000L;
}
uint32_t mvhd_crc32(const void* data, size_t n_bytes) {
static uint32_t table[0x100];
size_t i;
if (!*table)
for (size_t i = 0; i < 0x100; ++i)
for (i = 0; i < 0x100; ++i)
table[i] = mvhd_crc32_for_byte(i);
uint32_t crc = 0;
for (size_t i = 0; i < n_bytes; ++i)
for (i = 0; i < n_bytes; ++i)
crc = table[(uint8_t)crc ^ ((uint8_t*)data)[i]] ^ crc >> 8;
return crc;