summaryrefslogtreecommitdiffstats
path: root/src/tools/imgtool/modules/fat.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/tools/imgtool/modules/fat.cpp')
-rw-r--r--src/tools/imgtool/modules/fat.cpp294
1 files changed, 147 insertions, 147 deletions
diff --git a/src/tools/imgtool/modules/fat.cpp b/src/tools/imgtool/modules/fat.cpp
index 715b3486e61..f0e6b8c7ab1 100644
--- a/src/tools/imgtool/modules/fat.cpp
+++ b/src/tools/imgtool/modules/fat.cpp
@@ -148,15 +148,15 @@
struct fat_partition_info
{
- UINT32 fat_bits;
- UINT32 sectors_per_cluster;
- UINT32 cluster_size;
- UINT32 reserved_sectors;
- UINT32 fat_count;
- UINT32 root_entries;
- UINT32 sectors_per_fat;
- UINT64 total_sectors;
- UINT32 total_clusters;
+ uint32_t fat_bits;
+ uint32_t sectors_per_cluster;
+ uint32_t cluster_size;
+ uint32_t reserved_sectors;
+ uint32_t fat_count;
+ uint32_t root_entries;
+ uint32_t sectors_per_fat;
+ uint64_t total_sectors;
+ uint32_t total_clusters;
};
struct fat_file
@@ -164,14 +164,14 @@ struct fat_file
unsigned int root : 1;
unsigned int directory : 1;
unsigned int eof : 1;
- UINT32 index;
- UINT32 filesize;
- UINT32 first_cluster;
- UINT32 parent_first_cluster;
- UINT32 cluster;
- UINT32 cluster_index;
- UINT32 dirent_sector_index;
- UINT32 dirent_sector_offset;
+ uint32_t index;
+ uint32_t filesize;
+ uint32_t first_cluster;
+ uint32_t parent_first_cluster;
+ uint32_t cluster;
+ uint32_t cluster_index;
+ uint32_t dirent_sector_index;
+ uint32_t dirent_sector_offset;
};
struct fat_dirent
@@ -180,27 +180,27 @@ struct fat_dirent
char short_filename[13];
unsigned int directory : 1;
unsigned int eof : 1;
- UINT32 filesize;
- UINT32 first_cluster;
- UINT32 dirent_sector_index;
- UINT32 dirent_sector_offset;
+ uint32_t filesize;
+ uint32_t first_cluster;
+ uint32_t dirent_sector_index;
+ uint32_t dirent_sector_offset;
time_t creation_time;
time_t lastmodified_time;
};
struct fat_freeentry_info
{
- UINT32 required_size;
- UINT32 candidate_position;
- UINT32 position;
+ uint32_t required_size;
+ uint32_t candidate_position;
+ uint32_t position;
};
struct fat_mediatype
{
- UINT8 media_descriptor;
- UINT8 heads;
- UINT8 tracks;
- UINT8 sectors;
+ uint8_t media_descriptor;
+ uint8_t heads;
+ uint8_t tracks;
+ uint8_t sectors;
};
enum creation_policy_t
@@ -226,7 +226,7 @@ static const fat_mediatype known_media[] =
};
/* boot sector code taken from FreeDOS */
-static const UINT8 boot_sector_code[] =
+static const uint8_t boot_sector_code[] =
{
0xfa, 0xfc, 0x31, 0xc0, 0x8e, 0xd8, 0xbd, 0x00, 0x7c, 0xb8, 0xe0, 0x1f,
0x8e, 0xc0, 0x89, 0xee, 0x89, 0xef, 0xb9, 0x00, 0x01, 0xf3, 0xa5, 0xea,
@@ -282,13 +282,13 @@ static fat_partition_info *fat_get_partition_info(imgtool::partition &partition)
-static imgtoolerr_t fat_read_sector(imgtool::partition &partition, UINT32 sector_index,
+static imgtoolerr_t fat_read_sector(imgtool::partition &partition, uint32_t sector_index,
int offset, void *buffer, size_t buffer_len)
{
//const fat_partition_info *disk_info;
imgtoolerr_t err;
- UINT8 data[FAT_SECLEN];
- UINT32 block_size;
+ uint8_t data[FAT_SECLEN];
+ uint32_t block_size;
size_t len;
//disk_info = fat_get_partition_info(partition);
@@ -308,7 +308,7 @@ static imgtoolerr_t fat_read_sector(imgtool::partition &partition, UINT32 sector
len = std::min(buffer_len, sizeof(data) - offset);
memcpy(buffer, data + offset, len);
- buffer = ((UINT8 *) buffer) + len;
+ buffer = ((uint8_t *) buffer) + len;
buffer_len -= len;
offset = 0;
}
@@ -317,14 +317,14 @@ static imgtoolerr_t fat_read_sector(imgtool::partition &partition, UINT32 sector
-static imgtoolerr_t fat_write_sector(imgtool::partition &partition, UINT32 sector_index,
+static imgtoolerr_t fat_write_sector(imgtool::partition &partition, uint32_t sector_index,
int offset, const void *buffer, size_t buffer_len)
{
//const fat_partition_info *disk_info;
imgtoolerr_t err;
- UINT8 data[FAT_SECLEN];
+ uint8_t data[FAT_SECLEN];
const void *write_data;
- UINT32 block_size;
+ uint32_t block_size;
size_t len;
//disk_info = fat_get_partition_info(partition);
@@ -356,7 +356,7 @@ static imgtoolerr_t fat_write_sector(imgtool::partition &partition, UINT32 secto
if (err)
return err;
- buffer = ((UINT8 *) buffer) + len;
+ buffer = ((uint8_t *) buffer) + len;
buffer_len -= len;
offset = 0;
}
@@ -365,7 +365,7 @@ static imgtoolerr_t fat_write_sector(imgtool::partition &partition, UINT32 secto
#ifdef UNUSED_FUNCTION
-static imgtoolerr_t fat_clear_sector(imgtool::partition &partition, UINT32 sector_index, UINT8 data)
+static imgtoolerr_t fat_clear_sector(imgtool::partition &partition, uint32_t sector_index, uint8_t data)
{
char buf[FAT_SECLEN];
memset(buf, data, sizeof(buf));
@@ -374,13 +374,13 @@ static imgtoolerr_t fat_clear_sector(imgtool::partition &partition, UINT32 secto
#endif
-static imgtoolerr_t fat_partition_open(imgtool::partition &partition, UINT64 first_block, UINT64 block_count)
+static imgtoolerr_t fat_partition_open(imgtool::partition &partition, uint64_t first_block, uint64_t block_count)
{
- UINT8 header[FAT_SECLEN];
+ uint8_t header[FAT_SECLEN];
imgtoolerr_t err;
fat_partition_info *info;
- UINT32 fat_bits, total_sectors_l, total_sectors_h, sector_size;
- UINT64 available_sectors;
+ uint32_t fat_bits, total_sectors_l, total_sectors_h, sector_size;
+ uint64_t available_sectors;
//int has_extended_bios_param_block = TRUE;
info = fat_get_partition_info(partition);
@@ -422,7 +422,7 @@ static imgtoolerr_t fat_partition_open(imgtool::partition &partition, UINT64 fir
if (info->sectors_per_cluster == 0)
return IMGTOOLERR_CORRUPTIMAGE;
- info->total_sectors = total_sectors_l + (((UINT64) total_sectors_h) << 16);
+ info->total_sectors = total_sectors_l + (((uint64_t) total_sectors_h) << 16);
available_sectors = info->total_sectors - info->reserved_sectors
- (info->sectors_per_fat * info->fat_count)
- (info->root_entries * FAT_DIRENT_SIZE + FAT_SECLEN - 1) / FAT_SECLEN;
@@ -447,21 +447,21 @@ static imgtoolerr_t fat_partition_open(imgtool::partition &partition, UINT64 fir
-static imgtoolerr_t fat_partition_create(imgtool::image &image, UINT64 first_block, UINT64 block_count)
+static imgtoolerr_t fat_partition_create(imgtool::image &image, uint64_t first_block, uint64_t block_count)
{
imgtoolerr_t err;
- UINT32 heads, tracks, sectors_per_track;
- UINT32 fat_bits, sectors_per_cluster, reserved_sectors, hidden_sectors;
- UINT32 root_dir_count, root_dir_sectors;
- UINT32 sectors_per_fat, fat_count, i;
- UINT32 boot_sector_offset;
- UINT64 total_clusters;
- UINT8 media_descriptor;
+ uint32_t heads, tracks, sectors_per_track;
+ uint32_t fat_bits, sectors_per_cluster, reserved_sectors, hidden_sectors;
+ uint32_t root_dir_count, root_dir_sectors;
+ uint32_t sectors_per_fat, fat_count, i;
+ uint32_t boot_sector_offset;
+ uint64_t total_clusters;
+ uint8_t media_descriptor;
//const char *title;
const char *fat_bits_string;
- UINT8 header[FAT_SECLEN];
+ uint8_t header[FAT_SECLEN];
#if 0
- UINT64 first_fat_entries;
+ uint64_t first_fat_entries;
#endif
/* check for limits */
@@ -525,13 +525,13 @@ static imgtoolerr_t fat_partition_create(imgtool::image &image, UINT64 first_blo
place_integer_le(header, 14, 1, reserved_sectors);
place_integer_le(header, 16, 1, fat_count);
place_integer_le(header, 17, 2, root_dir_count);
- place_integer_le(header, 19, 2, (UINT16) (block_count >> 0));
+ place_integer_le(header, 19, 2, (uint16_t) (block_count >> 0));
place_integer_le(header, 21, 1, media_descriptor);
place_integer_le(header, 22, 2, sectors_per_fat);
place_integer_le(header, 24, 2, sectors_per_track);
place_integer_le(header, 26, 2, heads);
place_integer_le(header, 28, 4, hidden_sectors);
- place_integer_le(header, 32, 4, (UINT32) (block_count >> 16));
+ place_integer_le(header, 32, 4, (uint32_t) (block_count >> 16));
place_integer_le(header, 36, 1, 0xFF);
place_integer_le(header, 38, 1, 0x28);
place_integer_le(header, 39, 4, imgtool::image::rand());
@@ -550,14 +550,14 @@ static imgtoolerr_t fat_partition_create(imgtool::image &image, UINT64 first_blo
if (boot_sector_offset <= 129)
{
header[0] = 0xEB; /* JMP rel8 */
- header[1] = (UINT8) (boot_sector_offset - 2); /* (offset) */
+ header[1] = (uint8_t) (boot_sector_offset - 2); /* (offset) */
header[2] = 0x90; /* NOP */
}
else
{
header[0] = 0xE9; /* JMP rel16 */
- header[1] = (UINT8) ((boot_sector_offset - 2) >> 0); /* (offset) */
- header[2] = (UINT8) ((boot_sector_offset - 2) >> 8); /* (offset) */
+ header[1] = (uint8_t) ((boot_sector_offset - 2) >> 0); /* (offset) */
+ header[2] = (uint8_t) ((boot_sector_offset - 2) >> 8); /* (offset) */
}
err = image.write_block(first_block, header);
@@ -575,9 +575,9 @@ static imgtoolerr_t fat_partition_create(imgtool::image &image, UINT64 first_blo
// FIXME: this causes a corrupt PC floppy image since it doubles the FAT partition header - works without it though
#if 0
/* set first two FAT entries */
- first_fat_entries = ((UINT64) media_descriptor) | 0xFFFFFF00;
- first_fat_entries &= (((UINT64) 1) << fat_bits) - 1;
- first_fat_entries |= ((((UINT64) 1) << fat_bits) - 1) << fat_bits;
+ first_fat_entries = ((uint64_t) media_descriptor) | 0xFFFFFF00;
+ first_fat_entries &= (((uint64_t) 1) << fat_bits) - 1;
+ first_fat_entries |= ((((uint64_t) 1) << fat_bits) - 1) << fat_bits;
first_fat_entries = little_endianize_int64(first_fat_entries);
for (i = 0; i < fat_count; i++)
@@ -593,34 +593,34 @@ static imgtoolerr_t fat_partition_create(imgtool::image &image, UINT64 first_blo
-static imgtoolerr_t fat_load_fat(imgtool::partition &partition, UINT8 **fat_table)
+static imgtoolerr_t fat_load_fat(imgtool::partition &partition, uint8_t **fat_table)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
const fat_partition_info *disk_info;
- UINT8 *table;
- UINT32 table_size;
- UINT32 pos, len;
- UINT32 sector_index;
+ uint8_t *table;
+ uint32_t table_size;
+ uint32_t pos, len;
+ uint32_t sector_index;
disk_info = fat_get_partition_info(partition);
table_size = disk_info->sectors_per_fat * disk_info->fat_count * FAT_SECLEN;
/* allocate the table with extra bytes, in case we "overextend" our reads */
- table = (UINT8*)malloc(table_size + sizeof(UINT64));
+ table = (uint8_t*)malloc(table_size + sizeof(uint64_t));
if (!table)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto done;
}
- memset(table, 0, table_size + sizeof(UINT64));
+ memset(table, 0, table_size + sizeof(uint64_t));
pos = 0;
sector_index = disk_info->reserved_sectors;
while(pos < table_size)
{
- len = std::min(table_size - pos, UINT32(FAT_SECLEN));
+ len = std::min(table_size - pos, uint32_t(FAT_SECLEN));
err = fat_read_sector(partition, sector_index++, 0, &table[pos], len);
if (err)
@@ -641,13 +641,13 @@ done:
-static imgtoolerr_t fat_save_fat(imgtool::partition &partition, const UINT8 *fat_table)
+static imgtoolerr_t fat_save_fat(imgtool::partition &partition, const uint8_t *fat_table)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
const fat_partition_info *disk_info;
- UINT32 table_size;
- UINT32 pos, len;
- UINT32 sector_index;
+ uint32_t table_size;
+ uint32_t pos, len;
+ uint32_t sector_index;
disk_info = fat_get_partition_info(partition);
@@ -658,7 +658,7 @@ static imgtoolerr_t fat_save_fat(imgtool::partition &partition, const UINT8 *fat
while(pos < table_size)
{
- len = std::min(table_size - pos, UINT32(FAT_SECLEN));
+ len = std::min(table_size - pos, uint32_t(FAT_SECLEN));
err = fat_write_sector(partition, sector_index++, 0, &fat_table[pos], len);
if (err)
@@ -673,13 +673,13 @@ done:
-static UINT32 fat_get_fat_entry(imgtool::partition &partition, const UINT8 *fat_table, UINT32 fat_entry)
+static uint32_t fat_get_fat_entry(imgtool::partition &partition, const uint8_t *fat_table, uint32_t fat_entry)
{
const fat_partition_info *disk_info;
- UINT64 entry;
- UINT32 bit_index, i;
- UINT32 last_entry = 0;
- UINT32 bit_mask;
+ uint64_t entry;
+ uint32_t bit_index, i;
+ uint32_t last_entry = 0;
+ uint32_t bit_mask;
disk_info = fat_get_partition_info(partition);
bit_index = fat_entry * disk_info->fat_bits;
@@ -703,8 +703,8 @@ static UINT32 fat_get_fat_entry(imgtool::partition &partition, const UINT8 *fat_
entry &= bit_mask;
if (i == 0)
- last_entry = (UINT32) entry;
- else if (last_entry != (UINT32) entry)
+ last_entry = (uint32_t) entry;
+ else if (last_entry != (uint32_t) entry)
return 1; /* if the FATs disagree; mark this as reserved */
}
@@ -720,11 +720,11 @@ static UINT32 fat_get_fat_entry(imgtool::partition &partition, const UINT8 *fat_
-static void fat_set_fat_entry(imgtool::partition &partition, UINT8 *fat_table, UINT32 fat_entry, UINT32 value)
+static void fat_set_fat_entry(imgtool::partition &partition, uint8_t *fat_table, uint32_t fat_entry, uint32_t value)
{
const fat_partition_info *disk_info;
- UINT64 entry;
- UINT32 bit_index, i;
+ uint64_t entry;
+ uint32_t bit_index, i;
disk_info = fat_get_partition_info(partition);
bit_index = fat_entry * disk_info->fat_bits;
@@ -736,8 +736,8 @@ static void fat_set_fat_entry(imgtool::partition &partition, UINT8 *fat_table, U
* disk_info->sectors_per_fat) + (bit_index / 8), sizeof(entry));
entry = little_endianize_int64(entry);
- entry &= (~((UINT64) 0xFFFFFFFF >> (32 - disk_info->fat_bits)) << (bit_index % 8)) | ((1 << (bit_index % 8)) - 1);
- entry |= ((UINT64) value) << (bit_index % 8);
+ entry &= (~((uint64_t) 0xFFFFFFFF >> (32 - disk_info->fat_bits)) << (bit_index % 8)) | ((1 << (bit_index % 8)) - 1);
+ entry |= ((uint64_t) value) << (bit_index % 8);
entry = little_endianize_int64(entry);
memcpy(fat_table + (i * FAT_SECLEN
@@ -747,11 +747,11 @@ static void fat_set_fat_entry(imgtool::partition &partition, UINT8 *fat_table, U
-static void fat_debug_integrity_check(imgtool::partition &partition, const UINT8 *fat_table, const fat_file *file)
+static void fat_debug_integrity_check(imgtool::partition &partition, const uint8_t *fat_table, const fat_file *file)
{
#ifdef MAME_DEBUG
/* debug function to test the integrity of a file */
- UINT32 cluster;
+ uint32_t cluster;
const fat_partition_info *disk_info;
disk_info = fat_get_partition_info(partition);
@@ -770,12 +770,12 @@ static void fat_debug_integrity_check(imgtool::partition &partition, const UINT8
-static imgtoolerr_t fat_seek_file(imgtool::partition &partition, fat_file *file, UINT32 pos)
+static imgtoolerr_t fat_seek_file(imgtool::partition &partition, fat_file *file, uint32_t pos)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
const fat_partition_info *disk_info;
- UINT32 new_cluster;
- UINT8 *fat_table = NULL;
+ uint32_t new_cluster;
+ uint8_t *fat_table = NULL;
disk_info = fat_get_partition_info(partition);
@@ -831,9 +831,9 @@ done:
-static UINT32 fat_get_filepos_sector_index(imgtool::partition &partition, fat_file *file)
+static uint32_t fat_get_filepos_sector_index(imgtool::partition &partition, fat_file *file)
{
- UINT32 sector_index;
+ uint32_t sector_index;
const fat_partition_info *disk_info;
disk_info = fat_get_partition_info(partition);
@@ -878,7 +878,7 @@ static imgtoolerr_t fat_readwrite_file(imgtool::partition &partition, fat_file *
{
imgtoolerr_t err;
// const fat_partition_info *disk_info;
- UINT32 sector_index;
+ uint32_t sector_index;
int offset;
size_t len;
@@ -911,7 +911,7 @@ static imgtoolerr_t fat_readwrite_file(imgtool::partition &partition, fat_file *
if (err)
return err;
- buffer = ((UINT8 *) buffer) + len;
+ buffer = ((uint8_t *) buffer) + len;
buffer_len -= len;
if (bytes_read)
*bytes_read += len;
@@ -937,10 +937,10 @@ static imgtoolerr_t fat_write_file(imgtool::partition &partition, fat_file *file
-static UINT32 fat_allocate_cluster(imgtool::partition &partition, UINT8 *fat_table)
+static uint32_t fat_allocate_cluster(imgtool::partition &partition, uint8_t *fat_table)
{
const fat_partition_info *disk_info;
- UINT32 i, val;
+ uint32_t i, val;
disk_info = fat_get_partition_info(partition);
@@ -960,15 +960,15 @@ static UINT32 fat_allocate_cluster(imgtool::partition &partition, UINT8 *fat_tab
/* sets the size of a file; ~0 means 'delete' */
static imgtoolerr_t fat_set_file_size(imgtool::partition &partition, fat_file *file,
- UINT32 new_size)
+ uint32_t new_size)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
const fat_partition_info *disk_info;
- UINT32 new_cluster_count;
- UINT32 old_cluster_count;
- UINT32 cluster, write_cluster, last_cluster, new_pos, i;
- UINT8 *fat_table = NULL;
- UINT8 dirent[32];
+ uint32_t new_cluster_count;
+ uint32_t old_cluster_count;
+ uint32_t cluster, write_cluster, last_cluster, new_pos, i;
+ uint8_t *fat_table = NULL;
+ uint8_t dirent[32];
size_t clear_size;
void *clear_buffer = NULL;
int delete_file = FALSE;
@@ -1110,7 +1110,7 @@ static imgtoolerr_t fat_set_file_size(imgtool::partition &partition, fat_file *f
if (file->directory && !delete_file)
{
if (file->root)
- clear_size = std::min(file->filesize - new_size, UINT32(FAT_DIRENT_SIZE));
+ clear_size = std::min(file->filesize - new_size, uint32_t(FAT_DIRENT_SIZE));
else
clear_size = (disk_info->cluster_size - (new_size % disk_info->cluster_size)) % disk_info->cluster_size;
@@ -1153,9 +1153,9 @@ done:
static void prepend_lfn_bytes(char16_t *lfn_buf, size_t lfn_buflen, size_t *lfn_len,
- const UINT8 *entry, int offset, int chars)
+ const uint8_t *entry, int offset, int chars)
{
- UINT16 w;
+ uint16_t w;
int i;
size_t move_len;
@@ -1176,9 +1176,9 @@ static void prepend_lfn_bytes(char16_t *lfn_buf, size_t lfn_buflen, size_t *lfn_
-static UINT8 fat_calc_filename_checksum(const UINT8 *short_filename)
+static uint8_t fat_calc_filename_checksum(const uint8_t *short_filename)
{
- UINT8 checksum;
+ uint8_t checksum;
int i, j;
checksum = 0;
@@ -1195,9 +1195,9 @@ static UINT8 fat_calc_filename_checksum(const UINT8 *short_filename)
-static void fat_calc_dirent_lfnchecksum(UINT8 *entry, size_t entry_len)
+static void fat_calc_dirent_lfnchecksum(uint8_t *entry, size_t entry_len)
{
- UINT8 checksum;
+ uint8_t checksum;
int i;
checksum = fat_calc_filename_checksum(entry + entry_len - FAT_DIRENT_SIZE);
@@ -1216,7 +1216,7 @@ static char fat_cannonicalize_sfn_char(char ch)
-static void fat_cannonicalize_sfn(char *sfn, const UINT8 *sfn_bytes)
+static void fat_cannonicalize_sfn(char *sfn, const uint8_t *sfn_bytes)
{
/* return the display version of this short file name */
int i;
@@ -1238,7 +1238,7 @@ static void fat_cannonicalize_sfn(char *sfn, const UINT8 *sfn_bytes)
-static time_t fat_crack_time(UINT32 fat_time)
+static time_t fat_crack_time(uint32_t fat_time)
{
struct tm t;
time_t now;
@@ -1258,19 +1258,19 @@ static time_t fat_crack_time(UINT32 fat_time)
-static UINT32 fat_setup_time(time_t ansi_time)
+static uint32_t fat_setup_time(time_t ansi_time)
{
struct tm t;
- UINT32 result = 0;
+ uint32_t result = 0;
t = *localtime(&ansi_time);
- result |= (((UINT32) (t.tm_sec / 2)) & 0x001F) << 0;
- result |= (((UINT32) t.tm_min) & 0x003F) << 5;
- result |= (((UINT32) t.tm_hour) & 0x001F) << 11;
- result |= (((UINT32) t.tm_mday) & 0x001F) << 16;
- result |= (((UINT32) t.tm_mon) & 0x000F) << 21;
- result |= (((UINT32) (t.tm_year + 1900 - 1980)) & 0x007F) << 25;
+ result |= (((uint32_t) (t.tm_sec / 2)) & 0x001F) << 0;
+ result |= (((uint32_t) t.tm_min) & 0x003F) << 5;
+ result |= (((uint32_t) t.tm_hour) & 0x001F) << 11;
+ result |= (((uint32_t) t.tm_mday) & 0x001F) << 16;
+ result |= (((uint32_t) t.tm_mon) & 0x000F) << 21;
+ result |= (((uint32_t) (t.tm_year + 1900 - 1980)) & 0x007F) << 25;
return result;
}
@@ -1282,15 +1282,15 @@ static imgtoolerr_t fat_read_dirent(imgtool::partition &partition, fat_file *fil
{
imgtoolerr_t err;
//const fat_partition_info *disk_info;
- UINT8 entry[FAT_DIRENT_SIZE];
+ uint8_t entry[FAT_DIRENT_SIZE];
size_t bytes_read;
int i, j;
char32_t ch;
char16_t lfn_buf[512];
size_t lfn_len = 0;
int lfn_lastentry = 0;
- UINT8 lfn_checksum = 0;
- UINT32 entry_index, entry_sector_index, entry_sector_offset;
+ uint8_t lfn_checksum = 0;
+ uint32_t entry_index, entry_sector_index, entry_sector_offset;
assert(file->directory);
lfn_buf[0] = '\0';
@@ -1405,12 +1405,12 @@ enum sfn_disposition_t
};
static imgtoolerr_t fat_construct_dirent(const char *filename, creation_policy_t create,
- UINT8 **entry, size_t *entry_len)
+ uint8_t **entry, size_t *entry_len)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
- UINT8 *created_entry = NULL;
- UINT8 *new_created_entry;
- UINT32 now;
+ uint8_t *created_entry = NULL;
+ uint8_t *new_created_entry;
+ uint32_t now;
size_t created_entry_len = FAT_DIRENT_SIZE;
size_t created_entry_pos = 0;
char32_t ch;
@@ -1431,7 +1431,7 @@ static imgtoolerr_t fat_construct_dirent(const char *filename, creation_policy_t
}
/* construct intial entry */
- created_entry = (UINT8 *) malloc(FAT_DIRENT_SIZE);
+ created_entry = (uint8_t *) malloc(FAT_DIRENT_SIZE);
if (!created_entry)
{
err = IMGTOOLERR_OUTOFMEMORY;
@@ -1507,7 +1507,7 @@ static imgtoolerr_t fat_construct_dirent(const char *filename, creation_policy_t
case 0:
case 32:
/* need to grow */
- new_created_entry = (UINT8 *) malloc(created_entry_len + FAT_DIRENT_SIZE);
+ new_created_entry = (uint8_t *) malloc(created_entry_len + FAT_DIRENT_SIZE);
if (!new_created_entry)
{
err = IMGTOOLERR_OUTOFMEMORY;
@@ -1562,7 +1562,7 @@ static imgtoolerr_t fat_construct_dirent(const char *filename, creation_policy_t
memcpy(created_entry, created_entry + created_entry_len - FAT_DIRENT_SIZE, FAT_DIRENT_SIZE);
created_entry_len = FAT_DIRENT_SIZE;
free(created_entry);
- new_created_entry = (UINT8 *) malloc(created_entry_len);
+ new_created_entry = (uint8_t *) malloc(created_entry_len);
if (!new_created_entry)
{
err = IMGTOOLERR_OUTOFMEMORY;
@@ -1600,11 +1600,11 @@ done:
-static void fat_bump_dirent(imgtool::partition &partition, UINT8 *entry, size_t entry_len)
+static void fat_bump_dirent(imgtool::partition &partition, uint8_t *entry, size_t entry_len)
{
- UINT8 *sfn_entry;
+ uint8_t *sfn_entry;
int pos, digit_count, i;
- UINT32 digit_place, val = 0;
+ uint32_t digit_place, val = 0;
sfn_entry = &entry[entry_len - FAT_DIRENT_SIZE];
@@ -1669,10 +1669,10 @@ static imgtoolerr_t fat_lookup_path(imgtool::partition &partition, const char *p
fat_dirent ent;
fat_freeentry_info freeent = { 0, };
const char *next_path_part;
- UINT8 *created_entry = NULL;
+ uint8_t *created_entry = NULL;
size_t created_entry_len = 0;
- UINT32 entry_sector_index, entry_sector_offset;
- UINT32 parent_first_cluster;
+ uint32_t entry_sector_index, entry_sector_offset;
+ uint32_t parent_first_cluster;
int bumped_sfn;
char sfn[13];
@@ -1758,7 +1758,7 @@ static imgtoolerr_t fat_lookup_path(imgtool::partition &partition, const char *p
LOG(("fat_lookup_path(): creating entry; pos=%u length=%u\n", freeent.position, freeent.required_size));
- err = fat_set_file_size(partition, file, std::max(file->filesize, UINT32(freeent.position + created_entry_len)));
+ err = fat_set_file_size(partition, file, std::max(file->filesize, uint32_t(freeent.position + created_entry_len)));
if (err)
goto done;
@@ -1853,7 +1853,7 @@ static imgtoolerr_t fat_partition_nextenum(imgtool::directory &enumeration, imgt
static imgtoolerr_t fat_read_bootblock(imgtool::partition &partition, imgtool::stream &stream)
{
imgtoolerr_t err;
- UINT8 block[FAT_SECLEN];
+ uint8_t block[FAT_SECLEN];
err = fat_read_sector(partition, 0, 0, block, sizeof(block));
if (err)
@@ -1868,8 +1868,8 @@ static imgtoolerr_t fat_read_bootblock(imgtool::partition &partition, imgtool::s
static imgtoolerr_t fat_write_bootblock(imgtool::partition &partition, imgtool::stream &stream)
{
imgtoolerr_t err;
- UINT8 block[FAT_SECLEN];
- UINT8 new_block[FAT_SECLEN];
+ uint8_t block[FAT_SECLEN];
+ uint8_t new_block[FAT_SECLEN];
if (stream.size() != sizeof(new_block))
return IMGTOOLERR_UNEXPECTED;
@@ -1935,7 +1935,7 @@ static imgtoolerr_t fat_partition_writefile(imgtool::partition &partition, const
{
imgtoolerr_t err;
fat_file file;
- UINT32 bytes_left, len;
+ uint32_t bytes_left, len;
char buffer[1024];
/* special case for bootblock */
@@ -1949,7 +1949,7 @@ static imgtoolerr_t fat_partition_writefile(imgtool::partition &partition, const
if (file.directory)
return IMGTOOLERR_FILENOTFOUND;
- bytes_left = (UINT32) sourcef.size();
+ bytes_left = (uint32_t) sourcef.size();
err = fat_set_file_size(partition, &file, bytes_left);
if (err)
@@ -2008,12 +2008,12 @@ static imgtoolerr_t fat_partition_deletefile(imgtool::partition &partition, cons
-static imgtoolerr_t fat_partition_freespace(imgtool::partition &partition, UINT64 *size)
+static imgtoolerr_t fat_partition_freespace(imgtool::partition &partition, uint64_t *size)
{
imgtoolerr_t err;
const fat_partition_info *disk_info;
- UINT8 *fat_table;
- UINT32 i;
+ uint8_t *fat_table;
+ uint32_t i;
disk_info = fat_get_partition_info(partition);
@@ -2040,7 +2040,7 @@ static imgtoolerr_t fat_partition_createdir(imgtool::partition &partition, const
{
imgtoolerr_t err;
fat_file file;
- UINT8 initial_data[64];
+ uint8_t initial_data[64];
err = fat_lookup_path(partition, path, CREATE_DIR, &file);
if (err)
@@ -2077,7 +2077,7 @@ static imgtoolerr_t fat_partition_deletedir(imgtool::partition &partition, const
-void fat_get_info(const imgtool_class *imgclass, UINT32 state, union imgtoolinfo *info)
+void fat_get_info(const imgtool_class *imgclass, uint32_t state, union imgtoolinfo *info)
{
switch(state)
{