diff options
30 files changed, 417 insertions, 550 deletions
diff --git a/src/lib/formats/apridisk.cpp b/src/lib/formats/apridisk.cpp index 529b98ec2e8..03a7cb81bdd 100644 --- a/src/lib/formats/apridisk.cpp +++ b/src/lib/formats/apridisk.cpp @@ -10,9 +10,10 @@ #include "apridisk.h" -#include "imageutl.h" - #include "ioprocs.h" +#include "multibyte.h" + +#include "osdcore.h" // osd_printf_error apridisk_format::apridisk_format() @@ -69,19 +70,19 @@ bool apridisk_format::load(util::random_read &io, uint32_t form_factor, const st uint8_t sector_header[16]; io.read_at(file_offset, sector_header, 16, actual); - uint32_t type = pick_integer_le(§or_header, 0, 4); - uint16_t compression = pick_integer_le(§or_header, 4, 2); - uint16_t header_size = pick_integer_le(§or_header, 6, 2); - uint32_t data_size = pick_integer_le(§or_header, 8, 4); + uint32_t type = get_u32le(§or_header[0]); + uint16_t compression = get_u16le(§or_header[4]); + uint16_t header_size = get_u16le(§or_header[6]); + uint32_t data_size = get_u32le(§or_header[8]); file_offset += header_size; switch (type) { case APR_SECTOR: - uint8_t head = pick_integer_le(§or_header, 12, 1); - uint8_t sector = pick_integer_le(§or_header, 13, 1); - uint8_t track = (uint8_t) pick_integer_le(§or_header, 14, 2); + uint8_t head = sector_header[12]; + uint8_t sector = sector_header[13]; + uint8_t track = (uint8_t) get_u16le(§or_header[14]); track_count = std::max(track_count, int(unsigned(track))); head_count = std::max(head_count, int(unsigned(head))); @@ -103,7 +104,7 @@ bool apridisk_format::load(util::random_read &io, uint32_t form_factor, const st { uint8_t comp[3]; io.read_at(file_offset, comp, 3, actual); - uint16_t length = pick_integer_le(comp, 0, 2); + uint16_t length = get_u16le(&comp[0]); if (length != SECTOR_SIZE) { diff --git a/src/lib/formats/cbm_crt.cpp b/src/lib/formats/cbm_crt.cpp index 2aca7688711..b088507208f 100644 --- a/src/lib/formats/cbm_crt.cpp +++ b/src/lib/formats/cbm_crt.cpp @@ -42,6 +42,7 @@ #include "cbm_crt.h" #include "corefile.h" +#include "multibyte.h" #include "osdcore.h" // osd_printf_* @@ -141,7 +142,7 @@ std::string cbm_crt_get_card(util::core_file &file) if (!err && (CRT_HEADER_LENGTH == actual) && !memcmp(header.signature, CRT_SIGNATURE, 16)) { - uint16_t hardware = pick_integer_be(header.hardware, 0, 2); + uint16_t hardware = get_u16be(header.hardware); return std::string(CRT_C64_SLOT_NAMES[hardware]); } @@ -166,7 +167,7 @@ bool cbm_crt_read_header(util::core_file &file, size_t *roml_size, size_t *romh_ if ((CRT_HEADER_LENGTH != actual) || (memcmp(header.signature, CRT_SIGNATURE, 16) != 0)) return false; - uint16_t hardware = pick_integer_be(header.hardware, 0, 2); + uint16_t hardware = get_u16be(header.hardware); *exrom = header.exrom; *game = header.game; @@ -186,9 +187,9 @@ bool cbm_crt_read_header(util::core_file &file, size_t *roml_size, size_t *romh_ if (file.read(&chip, CRT_CHIP_LENGTH, actual) || (CRT_CHIP_LENGTH != actual)) return false; - const uint16_t address = pick_integer_be(chip.start_address, 0, 2); - const uint16_t size = pick_integer_be(chip.image_size, 0, 2); - const uint16_t type = pick_integer_be(chip.chip_type, 0, 2); + const uint16_t address = get_u16be(chip.start_address); + const uint16_t size = get_u16be(chip.image_size); + const uint16_t type = get_u16be(chip.chip_type); if (LOG) { @@ -233,8 +234,8 @@ bool cbm_crt_read_data(util::core_file &file, uint8_t *roml, uint8_t *romh) if (file.read(&chip, CRT_CHIP_LENGTH, actual) || (CRT_CHIP_LENGTH != actual)) return false; - const uint16_t address = pick_integer_be(chip.start_address, 0, 2); - const uint16_t size = pick_integer_be(chip.image_size, 0, 2); + const uint16_t address = get_u16be(chip.start_address); + const uint16_t size = get_u16be(chip.image_size); std::error_condition err; switch (address) diff --git a/src/lib/formats/cbm_crt.h b/src/lib/formats/cbm_crt.h index 7696dcc276e..5b447de226c 100644 --- a/src/lib/formats/cbm_crt.h +++ b/src/lib/formats/cbm_crt.h @@ -12,10 +12,12 @@ #pragma once -#include "formats/imageutl.h" - #include "utilfwd.h" +#include <cstddef> +#include <cstdint> +#include <string> + //************************************************************************** // MACROS/CONSTANTS diff --git a/src/lib/formats/dsk_dsk.cpp b/src/lib/formats/dsk_dsk.cpp index e6f4cfd7b97..9f5b2240761 100644 --- a/src/lib/formats/dsk_dsk.cpp +++ b/src/lib/formats/dsk_dsk.cpp @@ -13,6 +13,7 @@ #include "imageutl.h" #include "ioprocs.h" +#include "multibyte.h" #include "osdcore.h" // osd_printf_* @@ -251,7 +252,7 @@ FLOPPY_CONSTRUCT( dsk_dsk_construct ) for (i=0; i<tag->tracks * tag->heads; i++) { tag->track_offsets[cnt] = tmp; - tmp += pick_integer_le(header, 0x32, 2); + tmp += get_u16le(&header[0x32]); cnt += skip; } } else { @@ -403,7 +404,7 @@ bool dsk_format::load(util::random_read &io, uint32_t form_factor, const std::ve for (int i=0; i<tracks * heads; i++) { track_offsets[cnt] = tmp; - tmp += pick_integer_le(header, 0x32, 2); + tmp += get_u16le(&header[0x32]); cnt += skip; } } else { diff --git a/src/lib/formats/dvk_mx_dsk.cpp b/src/lib/formats/dvk_mx_dsk.cpp index ab42fc93f4f..3437f16c09b 100644 --- a/src/lib/formats/dvk_mx_dsk.cpp +++ b/src/lib/formats/dvk_mx_dsk.cpp @@ -21,6 +21,7 @@ #include "formats/dvk_mx_dsk.h" #include "ioprocs.h" +#include "multibyte.h" const floppy_image_format_t::desc_e dvk_mx_format::dvk_mx_new_desc[] = { @@ -125,7 +126,7 @@ int dvk_mx_format::identify(util::random_read &io, uint32_t form_factor, const s size_t actual; io.read_at(512, sectdata, 512, actual); // check value in RT-11 home block. see src/tools/imgtool/modules/rt11.cpp - if (pick_integer_le(sectdata, 0724, 2) == 6) + if (get_u16le(§data[0724]) == 6) return FIFID_SIGN|FIFID_SIZE; else return FIFID_SIZE; diff --git a/src/lib/formats/dvk_mx_dsk.h b/src/lib/formats/dvk_mx_dsk.h index 9c9a068989c..583329e9f82 100644 --- a/src/lib/formats/dvk_mx_dsk.h +++ b/src/lib/formats/dvk_mx_dsk.h @@ -11,7 +11,6 @@ #pragma once #include "flopimg.h" -#include "imageutl.h" class dvk_mx_format : public floppy_image_format_t { diff --git a/src/lib/formats/fdi_dsk.cpp b/src/lib/formats/fdi_dsk.cpp index 71805508ab2..edeeeea65ad 100644 --- a/src/lib/formats/fdi_dsk.cpp +++ b/src/lib/formats/fdi_dsk.cpp @@ -19,6 +19,8 @@ #include "imageutl.h" #include "flopimg_legacy.h" +#include "multibyte.h" + /*************************************************************************** PARAMETERS ***************************************************************************/ @@ -237,7 +239,7 @@ FLOPPY_CONSTRUCT( fdi_dsk_construct ) floppy_image_read(floppy, &header, 0, sizeof(header)); tag->version = header.version[0]; - tag->tracks = pick_integer_be(header.ltrack, 0, 2) + 1; + tag->tracks = get_u16be(header.ltrack) + 1; tag->heads = header.lhead + 1; if (LOG) diff --git a/src/lib/formats/g64_dsk.cpp b/src/lib/formats/g64_dsk.cpp index 690706b3939..bd7f0a15ca5 100644 --- a/src/lib/formats/g64_dsk.cpp +++ b/src/lib/formats/g64_dsk.cpp @@ -11,8 +11,10 @@ *********************************************************************/ #include "formats/g64_dsk.h" +#include "imageutl.h" #include "ioprocs.h" +#include "multibyte.h" #include "osdcore.h" // osd_printf_* @@ -71,7 +73,7 @@ bool g64_format::load(util::random_read &io, uint32_t form_factor, const std::ve uint32_t tpos = POS_TRACK_OFFSET + (track * 4); uint32_t spos = tpos + (track_count * 4); - uint32_t dpos = pick_integer_le(&img[0], tpos, 4); + uint32_t dpos = get_u32le(&img[tpos]); if (!dpos) continue; @@ -82,7 +84,7 @@ bool g64_format::load(util::random_read &io, uint32_t form_factor, const std::ve return false; } - uint32_t speed_zone = pick_integer_le(&img[0], spos, 4); + uint32_t speed_zone = get_u32le(&img[spos]); if (speed_zone > 3) { @@ -90,7 +92,7 @@ bool g64_format::load(util::random_read &io, uint32_t form_factor, const std::ve return false; } - uint16_t track_bytes = pick_integer_le(&img[0], dpos, 2); + uint16_t track_bytes = get_u16le(&img[dpos]); int track_size = track_bytes * 8; LOG_FORMATS("head %u track %u offs %u size %u cell %ld\n", head, cylinder, dpos, track_bytes, 200000000L/track_size); @@ -172,9 +174,9 @@ bool g64_format::save(util::random_read_write &io, const std::vector<uint32_t> & uint8_t speed_offset[4]; uint8_t track_length[2]; - place_integer_le(track_offset, 0, 4, dpos); - place_integer_le(speed_offset, 0, 4, speed_zone); - place_integer_le(track_length, 0, 2, packed.size()); + put_u32le(track_offset, dpos); + put_u32le(speed_offset, speed_zone); + put_u16le(track_length, packed.size()); io.write_at(tpos, track_offset, 4, actual); io.write_at(spos, speed_offset, 4, actual); diff --git a/src/lib/formats/g64_dsk.h b/src/lib/formats/g64_dsk.h index ab99e170c71..fbce6941399 100644 --- a/src/lib/formats/g64_dsk.h +++ b/src/lib/formats/g64_dsk.h @@ -13,7 +13,6 @@ #pragma once #include "flopimg.h" -#include "imageutl.h" class g64_format : public floppy_image_format_t { diff --git a/src/lib/formats/hti_tape.cpp b/src/lib/formats/hti_tape.cpp index 8fbaeef91cc..1dc0613ce8d 100644 --- a/src/lib/formats/hti_tape.cpp +++ b/src/lib/formats/hti_tape.cpp @@ -8,9 +8,8 @@ #include "hti_tape.h" -#include "imageutl.h" - #include "ioprocs.h" +#include "multibyte.h" static constexpr uint32_t OLD_FILE_MAGIC = 0x5441434f; // Magic value at start of old-format image file: "TACO" @@ -59,7 +58,7 @@ bool hti_format_t::load_tape(util::random_read &io) uint8_t tmp[ 4 ]; io.read(tmp, 4, actual); - auto magic = pick_integer_be(tmp , 0 , 4); + auto magic = get_u32le(tmp); if (((m_img_format == HTI_DELTA_MOD_16_BITS || m_img_format == HTI_DELTA_MOD_17_BITS) && magic != FILE_MAGIC_DELTA && magic != OLD_FILE_MAGIC) || (m_img_format == HTI_MANCHESTER_MOD && magic != FILE_MAGIC_MANCHESTER)) { return false; @@ -83,7 +82,7 @@ void hti_format_t::save_tape(util::random_read_write &io) size_t actual; uint8_t tmp[ 4 ]; - place_integer_be(tmp, 0, 4, m_img_format == HTI_MANCHESTER_MOD ? FILE_MAGIC_MANCHESTER : FILE_MAGIC_DELTA); + put_u32be(tmp, m_img_format == HTI_MANCHESTER_MOD ? FILE_MAGIC_MANCHESTER : FILE_MAGIC_DELTA); io.write(tmp, 4, actual); for (unsigned i = 0; i < no_of_tracks(); i++) { @@ -102,7 +101,7 @@ void hti_format_t::save_tape(util::random_read_write &io) } dump_sequence(io, it_start, n_words); // End of track - place_integer_le(tmp, 0, 4, (uint32_t)-1); + put_u32le(tmp, (uint32_t)-1); io.write(tmp, 4, actual); } } @@ -393,7 +392,7 @@ bool hti_format_t::load_track(util::random_read &io , tape_track_t& track , bool // Read no. of words to follow io.read(tmp, 4, actual); - tmp32 = pick_integer_le(tmp, 0, 4); + tmp32 = get_u32le(tmp); // Track ends if (tmp32 == (uint32_t)-1) { @@ -405,7 +404,7 @@ bool hti_format_t::load_track(util::random_read &io , tape_track_t& track , bool // Read tape position of block io.read(tmp, 4, actual); - tmp32 = pick_integer_le(tmp, 0, 4); + tmp32 = get_u32le(tmp); tape_pos_t pos = (tape_pos_t)tmp32 + delta_pos; @@ -416,7 +415,7 @@ bool hti_format_t::load_track(util::random_read &io , tape_track_t& track , bool uint16_t tmp16; io.read(tmp, 2, actual); - tmp16 = pick_integer_le(tmp, 0, 2); + tmp16 = get_u16le(tmp); if (!old_format) { track.insert(std::make_pair(pos , tmp16)); @@ -477,12 +476,12 @@ void hti_format_t::dump_sequence(util::random_read_write &io , tape_track_t::con if (n_words) { size_t actual; uint8_t tmp[ 8 ]; - place_integer_le(tmp, 0, 4, n_words); - place_integer_le(tmp, 4, 4, it_start->first); + put_u32le(&tmp[ 0 ], n_words); + put_u32le(&tmp[ 4 ], it_start->first); io.write(tmp, 8, actual); for (unsigned i = 0; i < n_words; i++) { - place_integer_le(tmp, 0, 2, it_start->second); + put_u16le(tmp, it_start->second); io.write(tmp, 2, actual); ++it_start; } diff --git a/src/lib/formats/imageutl.h b/src/lib/formats/imageutl.h index 09213dc20af..53b7170fc65 100644 --- a/src/lib/formats/imageutl.h +++ b/src/lib/formats/imageutl.h @@ -25,146 +25,6 @@ unsigned short ccitt_crc16(unsigned short crc, const unsigned char *buffer, size unsigned short ccitt_crc16_one( unsigned short crc, const unsigned char data ); /* ----------------------------------------------------------------------- - * Alignment-friendly integer placement - * ----------------------------------------------------------------------- */ - -inline void place_integer_be(void *ptr, size_t offset, size_t size, uint64_t value) -{ - uint8_t *byte_ptr = ((uint8_t *) ptr) + offset; - uint16_t val16; - uint32_t val32; - - switch (size) - { - case 2: - val16 = big_endianize_int16((uint16_t) value); - memcpy(byte_ptr, &val16, sizeof(val16)); - break; - - case 4: - val32 = big_endianize_int32((uint32_t) value); - memcpy(byte_ptr, &val32, sizeof(val32)); - break; - - default: - if (size >= 1) byte_ptr[0] = (uint8_t) (value >> ((size - 1) * 8)); - if (size >= 2) byte_ptr[1] = (uint8_t) (value >> ((size - 2) * 8)); - if (size >= 3) byte_ptr[2] = (uint8_t) (value >> ((size - 3) * 8)); - if (size >= 4) byte_ptr[3] = (uint8_t) (value >> ((size - 4) * 8)); - if (size >= 5) byte_ptr[4] = (uint8_t) (value >> ((size - 5) * 8)); - if (size >= 6) byte_ptr[5] = (uint8_t) (value >> ((size - 6) * 8)); - if (size >= 7) byte_ptr[6] = (uint8_t) (value >> ((size - 7) * 8)); - if (size >= 8) byte_ptr[7] = (uint8_t) (value >> ((size - 8) * 8)); - break; - } -} - -inline uint64_t pick_integer_be(const void *ptr, size_t offset, size_t size) -{ - uint64_t result = 0; - const uint8_t *byte_ptr = ((const uint8_t *) ptr) + offset; - uint16_t val16; - uint32_t val32; - - switch (size) - { - case 1: - result = *byte_ptr; - break; - - case 2: - memcpy(&val16, byte_ptr, sizeof(val16)); - result = big_endianize_int16(val16); - break; - - case 4: - memcpy(&val32, byte_ptr, sizeof(val32)); - result = big_endianize_int32(val32); - break; - - default: - if (size >= 1) result |= ((uint64_t) byte_ptr[0]) << ((size - 1) * 8); - if (size >= 2) result |= ((uint64_t) byte_ptr[1]) << ((size - 2) * 8); - if (size >= 3) result |= ((uint64_t) byte_ptr[2]) << ((size - 3) * 8); - if (size >= 4) result |= ((uint64_t) byte_ptr[3]) << ((size - 4) * 8); - if (size >= 5) result |= ((uint64_t) byte_ptr[4]) << ((size - 5) * 8); - if (size >= 6) result |= ((uint64_t) byte_ptr[5]) << ((size - 6) * 8); - if (size >= 7) result |= ((uint64_t) byte_ptr[6]) << ((size - 7) * 8); - if (size >= 8) result |= ((uint64_t) byte_ptr[7]) << ((size - 8) * 8); - break; - } - return result; -} - -inline void place_integer_le(void *ptr, size_t offset, size_t size, uint64_t value) -{ - uint8_t *byte_ptr = ((uint8_t *) ptr) + offset; - uint16_t val16; - uint32_t val32; - - switch (size) - { - case 2: - val16 = little_endianize_int16((uint16_t) value); - memcpy(byte_ptr, &val16, sizeof(val16)); - break; - - case 4: - val32 = little_endianize_int32((uint32_t) value); - memcpy(byte_ptr, &val32, sizeof(val32)); - break; - - default: - if (size >= 1) byte_ptr[0] = (uint8_t) (value >> (0 * 8)); - if (size >= 2) byte_ptr[1] = (uint8_t) (value >> (1 * 8)); - if (size >= 3) byte_ptr[2] = (uint8_t) (value >> (2 * 8)); - if (size >= 4) byte_ptr[3] = (uint8_t) (value >> (3 * 8)); - if (size >= 5) byte_ptr[4] = (uint8_t) (value >> (4 * 8)); - if (size >= 6) byte_ptr[5] = (uint8_t) (value >> (5 * 8)); - if (size >= 7) byte_ptr[6] = (uint8_t) (value >> (6 * 8)); - if (size >= 8) byte_ptr[7] = (uint8_t) (value >> (7 * 8)); - break; - } -} - -static inline uint64_t pick_integer_le(const void *ptr, size_t offset, size_t size) -{ - uint64_t result = 0; - const uint8_t *byte_ptr = ((const uint8_t *) ptr) + offset; - uint16_t val16; - uint32_t val32; - - switch (size) - { - case 1: - result = *byte_ptr; - break; - - case 2: - memcpy(&val16, byte_ptr, sizeof(val16)); - result = little_endianize_int16(val16); - break; - - case 4: - memcpy(&val32, byte_ptr, sizeof(val32)); - result = little_endianize_int32(val32); - break; - - default: - if (size >= 1) result |= ((uint64_t) byte_ptr[0]) << (0 * 8); - if (size >= 2) result |= ((uint64_t) byte_ptr[1]) << (1 * 8); - if (size >= 3) result |= ((uint64_t) byte_ptr[2]) << (2 * 8); - if (size >= 4) result |= ((uint64_t) byte_ptr[3]) << (3 * 8); - if (size >= 5) result |= ((uint64_t) byte_ptr[4]) << (4 * 8); - if (size >= 6) result |= ((uint64_t) byte_ptr[5]) << (5 * 8); - if (size >= 7) result |= ((uint64_t) byte_ptr[6]) << (6 * 8); - if (size >= 8) result |= ((uint64_t) byte_ptr[7]) << (7 * 8); - break; - } - return result; -} - -/* ----------------------------------------------------------------------- * Miscellaneous * ----------------------------------------------------------------------- */ diff --git a/src/lib/formats/os9_dsk.cpp b/src/lib/formats/os9_dsk.cpp index 67ae74e5884..232f40e89f0 100644 --- a/src/lib/formats/os9_dsk.cpp +++ b/src/lib/formats/os9_dsk.cpp @@ -49,6 +49,7 @@ #include "coretmpl.h" // BIT #include "ioprocs.h" +#include "multibyte.h" os9_format::os9_format() : wd177x_format(formats) @@ -90,9 +91,9 @@ int os9_format::find_size(util::random_read &io, uint32_t form_factor, const std size_t actual; io.read_at(0, os9_header, sizeof(os9_header), actual); - int os9_total_sectors = pick_integer_be(os9_header, 0x00, 3); + int os9_total_sectors = get_u24be(&os9_header[0x00]); int os9_heads = util::BIT(os9_header[0x10], 0) ? 2 : 1; - int os9_sectors = pick_integer_be(os9_header, 0x11, 2); + int os9_sectors = get_u16be(&os9_header[0x11]); if (os9_total_sectors <= 0 || os9_heads <= 0 || os9_sectors <= 0) return -1; @@ -103,10 +104,10 @@ int os9_format::find_size(util::random_read &io, uint32_t form_factor, const std int opt_dtype = os9_header[0x3f + 0]; int opt_type = os9_header[0x3f + 3]; int opt_density = os9_header[0x3f + 4]; - int opt_cylinders = pick_integer_be(os9_header, 0x3f + 5, 2); + int opt_cylinders = get_u16be(&os9_header[0x3f + 5]); int opt_sides = os9_header[0x3f + 7]; - int opt_sectors_per_track = pick_integer_be(os9_header, 0x3f + 9, 2); - int opt_track0_sectors = pick_integer_be(os9_header, 0x3f + 11, 2); + int opt_sectors_per_track = get_u16be(&os9_header[0x3f + 9]); + int opt_track0_sectors = get_u16be(&os9_header[0x3f + 11]); int opt_interleave = os9_header[0x3f + 13]; int opt_mfm = util::BIT(opt_density, 0); diff --git a/src/lib/formats/uniflex_dsk.cpp b/src/lib/formats/uniflex_dsk.cpp index fe682417b09..59c243531dd 100644 --- a/src/lib/formats/uniflex_dsk.cpp +++ b/src/lib/formats/uniflex_dsk.cpp @@ -13,6 +13,7 @@ #include "imageutl.h" #include "ioprocs.h" +#include "multibyte.h" uniflex_format::uniflex_format() : wd177x_format(formats) @@ -55,20 +56,20 @@ int uniflex_format::find_size(util::random_read &io, uint32_t form_factor, const size_t actual; io.read_at(1 * 512, sir, sizeof(sir), actual); - uint16_t fdn_block_count = pick_integer_be(sir, 0x10, 2); - uint32_t last_block_number = pick_integer_be(sir, 0x12, 3); - uint32_t free_block_count = pick_integer_be(sir, 0x15, 3); - uint16_t fdn_free_count = pick_integer_be(sir, 0x15, 2); + uint16_t fdn_block_count = get_u16be(&sir[0x10]); + uint32_t last_block_number = get_u24be(&sir[0x12]); + uint32_t free_block_count = get_u24be(&sir[0x15]); + uint16_t fdn_free_count = get_u16be(&sir[0x15]); // FIXME: offset should be different from previous? - uint16_t volume_number = pick_integer_be(sir, 0x36, 2); + uint16_t volume_number = get_u16be(&sir[0x36]); uint8_t disk_density = sir[0x3a]; uint8_t disk_side_info = sir[0x3b]; - uint32_t volbc_start_addr = pick_integer_be(sir, 0x3c, 3); - uint16_t swap_size = pick_integer_be(sir, 0x3f, 2); + uint32_t volbc_start_addr = get_u24be(&sir[0x3c]); + uint16_t swap_size = get_u16be(&sir[0x3f]); LOG_FORMATS("UniFLEX floppy dsk size %d\n", (uint32_t)size); - LOG_FORMATS(" time = %u %u\n", (uint32_t) pick_integer_be(sir, 0x08, 4), (uint32_t) pick_integer_be(sir, 0x0c, 4)); + LOG_FORMATS(" time = %u %u\n", get_u32be(&sir[0x08]), get_u32be(&sir[0x0c])); LOG_FORMATS(" fdn_block_count: %d\n", fdn_block_count); LOG_FORMATS(" file system name: "); @@ -90,7 +91,7 @@ int uniflex_format::find_size(util::random_read &io, uint32_t form_factor, const LOG_FORMATS(" swap_size: %d\n", swap_size); // The first eight bytes appear to be zeros. - if (pick_integer_be(sir, 0x00, 8) != 0) + if (get_u64be(&sir[0x00]) != 0) return -1; for(int i=0; formats[i].form_factor; i++) { diff --git a/src/lib/util/multibyte.h b/src/lib/util/multibyte.h index 07510e64678..6664c089506 100644 --- a/src/lib/util/multibyte.h +++ b/src/lib/util/multibyte.h @@ -22,20 +22,20 @@ using osd::s64; // unsigned big-endian -inline const u16 get_u16be(const u8 *const buf) +inline constexpr u16 get_u16be(const u8 *const buf) noexcept { return ((const u16)buf[0] << 8) | ((const u16)buf[1] << 0); } -inline const u32 get_u24be(const u8 *const buf) +inline constexpr u32 get_u24be(const u8 *const buf) noexcept { return ((const u32)buf[0] << 16) | ((const u32)buf[1] << 8) | ((const u32)buf[2] << 0); } -inline const u32 get_u32be(const u8 *const buf) +inline constexpr u32 get_u32be(const u8 *const buf) noexcept { return ((const u32)buf[0] << 24) | ((const u32)buf[1] << 16) @@ -43,7 +43,7 @@ inline const u32 get_u32be(const u8 *const buf) | ((const u32)buf[3] << 0); } -inline const u64 get_u64be(const u8 *const buf) +inline constexpr u64 get_u64be(const u8 *const buf) noexcept { return ((const u64)buf[0] << 56) | ((const u64)buf[1] << 48) @@ -55,20 +55,20 @@ inline const u64 get_u64be(const u8 *const buf) | ((const u64)buf[7] << 0); } -inline void put_u16be(u8 *buf, const u16 data) +inline void put_u16be(u8 *buf, const u16 data) noexcept { buf[0] = data >> 8; buf[1] = data >> 0; } -inline void put_u24be(u8 *buf, const u32 data) +inline void put_u24be(u8 *buf, const u32 data) noexcept { buf[0] = data >> 16; buf[1] = data >> 8; buf[2] = data >> 0; } -inline void put_u32be(u8 *buf, const u32 data) +inline void put_u32be(u8 *buf, const u32 data) noexcept { buf[0] = data >> 24; buf[1] = data >> 16; @@ -76,7 +76,7 @@ inline void put_u32be(u8 *buf, const u32 data) buf[3] = data >> 0; } -inline void put_u64be(u8 *buf, const u64 data) +inline void put_u64be(u8 *buf, const u64 data) noexcept { buf[0] = data >> 56; buf[1] = data >> 48; @@ -92,42 +92,42 @@ inline void put_u64be(u8 *buf, const u64 data) // signed big-endian -inline const s16 get_s16be(const u8 *const buf) +inline constexpr s16 get_s16be(const u8 *const buf) noexcept { return get_u16be(buf); } -inline const s32 get_s24be(const u8 *const buf) +inline constexpr s32 get_s24be(const u8 *const buf) noexcept { return util::sext(get_u24be(buf), 24); } -inline const s32 get_s32be(const u8 *const buf) +inline constexpr s32 get_s32be(const u8 *const buf) noexcept { return get_u32be(buf); } -inline const s64 get_s64be(const u8 *const buf) +inline constexpr s64 get_s64be(const u8 *const buf) noexcept { return get_u64be(buf); } -inline void put_s16be(u8 *buf, const s16 data) +inline void put_s16be(u8 *buf, const s16 data) noexcept { put_u16be(buf, data); } -inline void put_s24be(u8 *buf, const s32 data) +inline void put_s24be(u8 *buf, const s32 data) noexcept { put_u24be(buf, data); } -inline void put_s32be(u8 *buf, const s32 data) +inline void put_s32be(u8 *buf, const s32 data) noexcept { put_u32be(buf, data); } -inline void put_s64be(u8 *buf, const s64 data) +inline void put_s64be(u8 *buf, const s64 data) noexcept { put_u64be(buf, data); } @@ -136,20 +136,20 @@ inline void put_s64be(u8 *buf, const s64 data) // unsigned little-endian -inline const u16 get_u16le(const u8 *const buf) +inline constexpr u16 get_u16le(const u8 *const buf) noexcept { return ((const u16)buf[0] << 0) | ((const u16)buf[1] << 8); } -inline const u32 get_u24le(const u8 *const buf) +inline constexpr u32 get_u24le(const u8 *const buf) noexcept { return ((const u32)buf[0] << 0) | ((const u32)buf[1] << 8) | ((const u32)buf[2] << 16); } -inline const u32 get_u32le(const u8 *const buf) +inline constexpr u32 get_u32le(const u8 *const buf) noexcept { return ((const u32)buf[0] << 0) | ((const u32)buf[1] << 8) @@ -157,7 +157,7 @@ inline const u32 get_u32le(const u8 *const buf) | ((const u32)buf[3] << 24); } -inline const u64 get_u64le(const u8 *const buf) +inline constexpr u64 get_u64le(const u8 *const buf) noexcept { return ((const u64)buf[0] << 0) | ((const u64)buf[1] << 8) @@ -169,20 +169,20 @@ inline const u64 get_u64le(const u8 *const buf) | ((const u64)buf[7] << 56); } -inline void put_u16le(u8 *buf, const u16 data) +inline void put_u16le(u8 *buf, const u16 data) noexcept { buf[0] = data >> 0; buf[1] = data >> 8; } -inline void put_u24le(u8 *buf, const u32 data) +inline void put_u24le(u8 *buf, const u32 data) noexcept { buf[0] = data >> 0; buf[1] = data >> 8; buf[2] = data >> 16; } -inline void put_u32le(u8 *buf, const u32 data) +inline void put_u32le(u8 *buf, const u32 data) noexcept { buf[0] = data >> 0; buf[1] = data >> 8; @@ -190,7 +190,7 @@ inline void put_u32le(u8 *buf, const u32 data) buf[3] = data >> 24; } -inline void put_u64le(u8 *buf, const u64 data) +inline void put_u64le(u8 *buf, const u64 data) noexcept { buf[0] = data >> 0; buf[1] = data >> 8; @@ -206,42 +206,42 @@ inline void put_u64le(u8 *buf, const u64 data) // signed little-endian -inline const s16 get_s16le(const u8 *const buf) +inline constexpr s16 get_s16le(const u8 *const buf) noexcept { return get_u16le(buf); } -inline const s32 get_s24le(const u8 *const buf) +inline constexpr s32 get_s24le(const u8 *const buf) noexcept { return util::sext(get_u24le(buf), 24); } -inline const s32 get_s32le(const u8 *const buf) +inline constexpr s32 get_s32le(const u8 *const buf) noexcept { return get_u32le(buf); } -inline const s64 get_s64le(const u8 *const buf) +inline constexpr s64 get_s64le(const u8 *const buf) noexcept { return get_u64le(buf); } -inline void put_s16le(u8 *buf, const s16 data) +inline void put_s16le(u8 *buf, const s16 data) noexcept { put_u16le(buf, data); } -inline void put_s24le(u8 *buf, const s32 data) +inline void put_s24le(u8 *buf, const s32 data) noexcept { put_u24le(buf, data); } -inline void put_s32le(u8 *buf, const s32 data) +inline void put_s32le(u8 *buf, const s32 data) noexcept { put_u32le(buf, data); } -inline void put_s64le(u8 *buf, const s64 data) +inline void put_s64le(u8 *buf, const s64 data) noexcept { put_u64le(buf, data); } diff --git a/src/mame/acorn/atom.cpp b/src/mame/acorn/atom.cpp index d271b7d13f8..9a298a67a20 100644 --- a/src/mame/acorn/atom.cpp +++ b/src/mame/acorn/atom.cpp @@ -118,10 +118,11 @@ Hardware: PPIA 8255 #include "emu.h" #include "atom.h" #include "machine/clock.h" -#include "formats/imageutl.h" #include "screen.h" #include "softlist_dev.h" #include "speaker.h" + +#include "multibyte.h" #include "utf8.h" /*************************************************************************** @@ -158,9 +159,9 @@ QUICKLOAD_LOAD_MEMBER(atom_state::quickload_cb) image.fread(header, 0x16); - uint16_t start_address = pick_integer_le(header, 0x10, 2); - uint16_t run_address = pick_integer_le(header, 0x12, 2); - uint16_t size = pick_integer_le(header, 0x14, 2); + uint16_t start_address = get_u16le(&header[0x10]); + uint16_t run_address = get_u16le(&header[0x12]); + uint16_t size = get_u16le(&header[0x14]); if (LOG) { diff --git a/src/mame/comx/comx35.cpp b/src/mame/comx/comx35.cpp index b4cdabddca6..6702b9f9619 100644 --- a/src/mame/comx/comx35.cpp +++ b/src/mame/comx/comx35.cpp @@ -18,9 +18,10 @@ #include "emu.h" #include "comx35.h" -#include "formats/imageutl.h" #include "screen.h" #include "softlist_dev.h" + +#include "multibyte.h" #include "utf8.h" /*************************************************************************** @@ -93,9 +94,9 @@ QUICKLOAD_LOAD_MEMBER(comx35_state::quickload_cb) image.fread(header, 6); - start_address = pick_integer_be(header, 0, 2); - end_address = pick_integer_be(header, 2, 2); - run_address = pick_integer_be(header, 4, 2); + start_address = get_u16be(&header[0]); + end_address = get_u16be(&header[2]); + run_address = get_u16be(&header[4]); image_fread_memory(image, start_address, end_address - start_address); @@ -179,7 +180,7 @@ QUICKLOAD_LOAD_MEMBER(comx35_state::quickload_cb) image.fread(header, 2); - array_length = pick_integer_be(header, 0, 2); + array_length = get_u16be(&header[0]); start_array = (program.read_byte(0x4295) << 8) | program.read_byte(0x4296); end_array = start_array + (size - 7); diff --git a/src/mame/memotech/mtx_m.cpp b/src/mame/memotech/mtx_m.cpp index fd76a773d69..3f5763a096d 100644 --- a/src/mame/memotech/mtx_m.cpp +++ b/src/mame/memotech/mtx_m.cpp @@ -9,7 +9,7 @@ #include "emu.h" #include "mtx.h" -#include "formats/imageutl.h" +#include "multibyte.h" /*************************************************************************** READ/WRITE HANDLERS @@ -446,7 +446,7 @@ SNAPSHOT_LOAD_MEMBER(mtx_state::snapshot_cb) bankswitch(0); // start of system variables area - uint16_t system_variables_base = pick_integer_le(data.get(), 16, 2); + uint16_t system_variables_base = get_u16le(&data[16]); // write system variables uint16_t system_variables_size = 0; @@ -485,8 +485,8 @@ QUICKLOAD_LOAD_MEMBER(mtx_state::quickload_cb) if (image.fread(data.get(), length) != length) return std::make_pair(image_error::UNSPECIFIED, "Error reading file"); - uint16_t const code_base = pick_integer_le(data.get(), 0, 2); - uint16_t const code_length = pick_integer_le(data.get(), 2, 2); + uint16_t const code_base = get_u16le(&data[0]); + uint16_t const code_length = get_u16le(&data[2]); if (length < (code_length + 4)) return std::make_pair(image_error::INVALIDIMAGE, "File too short for code length in header"); diff --git a/src/mame/sega/mdconsole.cpp b/src/mame/sega/mdconsole.cpp index 40a9bf81189..cb991ff3360 100644 --- a/src/mame/sega/mdconsole.cpp +++ b/src/mame/sega/mdconsole.cpp @@ -12,7 +12,7 @@ #include "softlist.h" -#include "formats/imageutl.h" +#include "multibyte.h" /************************************* @@ -410,18 +410,18 @@ DEVICE_IMAGE_LOAD_MEMBER( md_cons_state::_32x_cart ) } // Copy the cart image in the locations the driver expects - // Notice that, by using pick_integer, we are sure the code works on both LE and BE machines + // Notice that, by using get_uXXbe, we are sure the code works on both LE and BE machines ROM16 = (uint16_t *) memregion("gamecart")->base(); for (int i = 0; i < length; i += 2) - ROM16[i / 2] = pick_integer_be(&temp_copy[0], i, 2); + ROM16[i / 2] = get_u16be(&temp_copy[i]); ROM32 = (uint32_t *) memregion("gamecart_sh2")->base(); for (int i = 0; i < length; i += 4) - ROM32[i / 4] = pick_integer_be(&temp_copy[0], i, 4); + ROM32[i / 4] = get_u32be(&temp_copy[i]); ROM16 = (uint16_t *) memregion("maincpu")->base(); for (int i = 0x00; i < length; i += 2) - ROM16[i / 2] = pick_integer_be(&temp_copy[0], i, 2); + ROM16[i / 2] = get_u16be(&temp_copy[i]); return std::make_pair(std::error_condition(), std::string()); } diff --git a/src/mame/vtech/vtech1.cpp b/src/mame/vtech/vtech1.cpp index ed560daf137..7f705c91acb 100644 --- a/src/mame/vtech/vtech1.cpp +++ b/src/mame/vtech/vtech1.cpp @@ -43,8 +43,8 @@ Todo: #include "softlist_dev.h" #include "speaker.h" -#include "formats/imageutl.h" #include "formats/vt_cas.h" +#include "multibyte.h" #define LOG_VTECH1_LATCH (1U << 1) @@ -176,7 +176,7 @@ SNAPSHOT_LOAD_MEMBER(vtech1_base_state::snapshot_cb) pgmname[16] = '\0'; // get start and end addresses - uint16_t const start = pick_integer_le(header, 22, 2); + uint16_t const start = get_u16le(&header[22]); uint16_t const end = start + image.length() - sizeof(header); uint16_t const size = end - start; diff --git a/src/tools/imgtool/filtbas.cpp b/src/tools/imgtool/filtbas.cpp index acd11a77d3a..8a84811540d 100644 --- a/src/tools/imgtool/filtbas.cpp +++ b/src/tools/imgtool/filtbas.cpp @@ -25,7 +25,7 @@ #include "imgtool.h" #include "filter.h" -#include "formats/imageutl.h" +#include "multibyte.h" /*************************************************************************** @@ -79,7 +79,8 @@ static imgtoolerr_t basic_readfile(const basictokens *tokens, imgtoolerr_t err; imgtool::stream::ptr mem_stream; uint8_t line_header[4]; - uint16_t line_number; //, address; + [[maybe_unused]] uint16_t address; + uint16_t line_number; uint8_t b, shift; int i; int in_string = false; @@ -105,15 +106,13 @@ static imgtoolerr_t basic_readfile(const basictokens *tokens, /* pluck the address and line number out */ if (tokens->be) { - //address = (uint16_t) - pick_integer_be(line_header, 0, 2); - line_number = (uint16_t) pick_integer_be(line_header, 2, 2); + address = get_u16be(&line_header[0]); + line_number = get_u16be(&line_header[2]); } else { - //address = (uint16_t) - pick_integer_le(line_header, 0, 2); - line_number = (uint16_t) pick_integer_le(line_header, 2, 2); + address = get_u16le(&line_header[0]); + line_number = get_u16le(&line_header[2]); } /* write the line number */ @@ -245,13 +244,13 @@ static imgtoolerr_t basic_writefile(const basictokens *tokens, memset(&line_header, 0, sizeof(line_header)); if (tokens->be) { - place_integer_be(line_header, 0, 2, address); - place_integer_be(line_header, 2, 2, line_number); + put_u16be(&line_header[0], address); + put_u16be(&line_header[2], line_number); } else { - place_integer_le(line_header, 0, 2, address); - place_integer_le(line_header, 2, 2, line_number); + put_u16le(&line_header[0], address); + put_u16le(&line_header[2], line_number); } /* emit line header */ @@ -330,11 +329,11 @@ static imgtoolerr_t basic_writefile(const basictokens *tokens, { if (tokens->be) { - place_integer_be(file_size, 0, 2, mem_stream->size()); + put_u16be(file_size, mem_stream->size()); } else { - place_integer_le(file_size, 0, 2, mem_stream->size()); + put_u16le(file_size, mem_stream->size()); } mem_stream->write(file_size, 2); mem_stream->seek(0, SEEK_SET); diff --git a/src/tools/imgtool/modules/amiga.cpp b/src/tools/imgtool/modules/amiga.cpp index 40c80901749..2d9a793c54d 100644 --- a/src/tools/imgtool/modules/amiga.cpp +++ b/src/tools/imgtool/modules/amiga.cpp @@ -17,8 +17,8 @@ #include "charconv.h" #include "iflopimg.h" -#include "formats/imageutl.h" #include "corestr.h" +#include "multibyte.h" #include "opresolv.h" #include <cctype> @@ -398,7 +398,7 @@ static uint32_t block_checksum(uint8_t *buffer, int length) for (i = 0; i < length/4; i++) { - chksum += pick_integer_be(buffer, i*4, 4); + chksum += get_u32be(&buffer[i*4]); } return -chksum; @@ -474,7 +474,7 @@ static sec_type get_block_type(imgtool::image &img, int block) if (ret) return ST_INVALID; /* return type */ - switch ((int32_t) pick_integer_be(buffer, BSIZE-4, 4)) + switch (get_s32be(&buffer[BSIZE-4])) { case 1: return ST_ROOT; case 2: return ST_USERDIR; @@ -498,7 +498,7 @@ static imgtoolerr_t read_bitmap_block(imgtool::image &img, int block, bitmap_blo if (ret) return ret; /* fill in data */ - bm->chksum = pick_integer_be(buffer, 0, 4); + bm->chksum = get_u32be(&buffer[0]); copy_integer_array_be(bm->map, (uint32_t *) &buffer[4], MSIZE); return IMGTOOLERR_SUCCESS; @@ -512,7 +512,7 @@ static imgtoolerr_t write_bitmap_block(imgtool::image &img, int block, const bit uint8_t buffer[BSIZE]; /* Setup buffer */ - place_integer_be(buffer, 0, 4, bm->chksum); + put_u32be(&buffer[0], bm->chksum); copy_integer_array_be((uint32_t *) &buffer[4], bm->map, MSIZE); /* write block */ @@ -535,7 +535,7 @@ static imgtoolerr_t write_bitmap_block(imgtool::image &img, int block, const bit /* fill in data */ copy_integer_array_be(bm->map, (uint32_t *) &buffer, MSIZE); - bm->next = pick_integer_be(buffer, BSIZE-4, 4); + bm->next = get_u32be(&buffer[BSIZE-4]); return IMGTOOLERR_SUCCESS; } @@ -554,17 +554,17 @@ static imgtoolerr_t read_root_block(imgtool::image &img, root_block *root) /* copy data to root_block */ memset(root, 0, sizeof(root_block)); - root->ht_size = pick_integer_be(buffer, 12, 4); - root->chksum = pick_integer_be(buffer, 20, 4); + root->ht_size = get_u32be(&buffer[12]); + root->chksum = get_u32be(&buffer[20]); copy_integer_array_be(root->ht, (uint32_t *) &buffer[24], TSIZE); - root->bm_flag = pick_integer_be(buffer, BSIZE-200, 4); + root->bm_flag = get_u32be(&buffer[BSIZE-200]); copy_integer_array_be(root->bm_pages, (uint32_t *) &buffer[BSIZE-196], 25); copy_date_be(&root->r, (uint32_t *) &buffer[BSIZE-92]); - root->name_len = pick_integer_be(buffer, BSIZE-80, 1); + root->name_len = buffer[BSIZE-80]; memcpy(root->diskname, &buffer[BSIZE-79], 30); copy_date_be(&root->v, (uint32_t *) &buffer[BSIZE-40]); copy_date_be(&root->c, (uint32_t *) &buffer[BSIZE-28]); - root->extension = pick_integer_be(buffer, BSIZE-8, 4); + root->extension = get_u32be(&buffer[BSIZE-8]); return IMGTOOLERR_SUCCESS; } @@ -578,25 +578,25 @@ static imgtoolerr_t write_root_block(imgtool::image &img, const root_block *root /* Setup buffer */ memset(buffer, 0, BSIZE); - place_integer_be(buffer, 0, 4, T_HEADER); - place_integer_be(buffer, 12, 4, root->ht_size); - place_integer_be(buffer, 20, 4, root->chksum); + put_u32be(&buffer[0], T_HEADER); + put_u32be(&buffer[12], root->ht_size); + put_u32be(&buffer[20], root->chksum); copy_integer_array_be((uint32_t *) &buffer[24], root->ht, TSIZE); - place_integer_be(buffer, BSIZE-200, 4, root->bm_flag); + put_u32be(&buffer[BSIZE-200], root->bm_flag); copy_integer_array_be((uint32_t *) &buffer[BSIZE-196], root->bm_pages, 25); - place_integer_be(buffer, BSIZE-92, 4, root->r.days); - place_integer_be(buffer, BSIZE-88, 4, root->r.mins); - place_integer_be(buffer, BSIZE-84, 4, root->r.ticks); - place_integer_be(buffer, BSIZE-80, 1, root->name_len); + put_u32be(&buffer[BSIZE-92], root->r.days); + put_u32be(&buffer[BSIZE-88], root->r.mins); + put_u32be(&buffer[BSIZE-84], root->r.ticks); + buffer[BSIZE-80] = root->name_len; memcpy(&buffer[BSIZE-79], root->diskname, root->name_len); - place_integer_be(buffer, BSIZE-40, 4, root->v.days); - place_integer_be(buffer, BSIZE-36, 4, root->v.mins); - place_integer_be(buffer, BSIZE-32, 4, root->v.ticks); - place_integer_be(buffer, BSIZE-28, 4, root->c.days); - place_integer_be(buffer, BSIZE-24, 4, root->c.mins); - place_integer_be(buffer, BSIZE-20, 4, root->c.ticks); - place_integer_be(buffer, BSIZE-8, 4, root->extension); - place_integer_be(buffer, BSIZE-4, 4, ST_ROOT); + put_u32be(&buffer[BSIZE-40], root->v.days); + put_u32be(&buffer[BSIZE-36], root->v.mins); + put_u32be(&buffer[BSIZE-32], root->v.ticks); + put_u32be(&buffer[BSIZE-28], root->c.days); + put_u32be(&buffer[BSIZE-24], root->c.mins); + put_u32be(&buffer[BSIZE-20], root->c.ticks); + put_u32be(&buffer[BSIZE-8], root->extension); + put_u32be(&buffer[BSIZE-4], ST_ROOT); /* write root block to image */ ret = write_block(img, get_total_blocks(img)/2, buffer); @@ -617,25 +617,25 @@ static imgtoolerr_t read_file_block(imgtool::image &img, int block, file_block * if (ret) return ret; /* fill in data */ - fb->header_key = pick_integer_be(buffer, 4, 4); - fb->high_seq = pick_integer_be(buffer, 8, 4); - fb->first_data = pick_integer_be(buffer, 16, 4); - fb->chksum = pick_integer_be(buffer, 20, 4); + fb->header_key = get_u32be(&buffer[4]); + fb->high_seq = get_u32be(&buffer[8]); + fb->first_data = get_u32be(&buffer[16]); + fb->chksum = get_u32be(&buffer[20]); copy_integer_array_be(fb->data_blocks, (uint32_t *) &buffer[24], TSIZE); - fb->uid = pick_integer_be(buffer, BSIZE-196, 2); - fb->gid = pick_integer_be(buffer, BSIZE-194, 2); - fb->protect = pick_integer_be(buffer, BSIZE-192, 4); - fb->byte_size = pick_integer_be(buffer, BSIZE-188, 4); - fb->comm_len = pick_integer_be(buffer, BSIZE-184, 1); + fb->uid = get_u16be(&buffer[BSIZE-196]); + fb->gid = get_u16be(&buffer[BSIZE-194]); + fb->protect = get_u32be(&buffer[BSIZE-192]); + fb->byte_size = get_u32be(&buffer[BSIZE-188]); + fb->comm_len = buffer[BSIZE-184]; memcpy(fb->comment, &buffer[BSIZE-183], 79); copy_date_be(&fb->date, (uint32_t *) &buffer[BSIZE-92]); - fb->name_len = pick_integer_be(buffer, BSIZE-80, 1); - memcpy(fb->filename, (uint32_t *) &buffer[BSIZE-79], 30); - fb->real_entry = pick_integer_be(buffer, BSIZE-44, 4); - fb->next_link = pick_integer_be(buffer, BSIZE-40, 4); - fb->hash_chain = pick_integer_be(buffer, BSIZE-16, 4); - fb->parent = pick_integer_be(buffer, BSIZE-12, 4); - fb->extension = pick_integer_be(buffer, BSIZE-8, 4); + fb->name_len = buffer[BSIZE-80]; + memcpy(fb->filename, &buffer[BSIZE-79], 30); + fb->real_entry = get_u32be(&buffer[BSIZE-44]); + fb->next_link = get_u32be(&buffer[BSIZE-40]); + fb->hash_chain = get_u32be(&buffer[BSIZE-16]); + fb->parent = get_u32be(&buffer[BSIZE-12]); + fb->extension = get_u32be(&buffer[BSIZE-8]); return IMGTOOLERR_SUCCESS; } @@ -651,12 +651,12 @@ static imgtoolerr_t read_file_ext_block(imgtool::image &img, int block, file_ext if (ret) return ret; /* fill in data */ - fe->header_key = pick_integer_be(buffer, 4, 4); - fe->high_seq = pick_integer_be(buffer, 8, 4); - fe->chksum = pick_integer_be(buffer, 20, 4); + fe->header_key = get_u32be(&buffer[4]); + fe->high_seq = get_u32be(&buffer[8]); + fe->chksum = get_u32be(&buffer[20]); copy_integer_array_be(fe->data_blocks, (uint32_t *) &buffer[24], TSIZE); - fe->parent = pick_integer_be(buffer, BSIZE-12, 4); - fe->extension = pick_integer_be(buffer, BSIZE-8, 4); + fe->parent = get_u32be(&buffer[BSIZE-12]); + fe->extension = get_u32be(&buffer[BSIZE-8]); return IMGTOOLERR_SUCCESS; } @@ -672,11 +672,11 @@ static imgtoolerr_t read_data_block(imgtool::image &img, int block, data_block * if (ret) return ret; /* fill in data */ - d->header_key = pick_integer_be(buffer, 4, 4); - d->seq_num = pick_integer_be(buffer, 8, 4); - d->data_size = pick_integer_be(buffer, 12, 4); - d->next_data = pick_integer_be(buffer, 16, 4); - d->chksum = pick_integer_be(buffer, 20, 4); + d->header_key = get_u32be(&buffer[4]); + d->seq_num = get_u32be(&buffer[8]); + d->data_size = get_u32be(&buffer[12]); + d->next_data = get_u32be(&buffer[16]); + d->chksum = get_u32be(&buffer[20]); memcpy(d->data, &buffer[24], BSIZE-24); return IMGTOOLERR_SUCCESS; @@ -694,21 +694,21 @@ static imgtoolerr_t read_dir_block(imgtool::image &img, int block, dir_block *db if (ret) return ret; /* fill in data */ - db->header_key = pick_integer_be(buffer, 4, 4); - db->chksum = pick_integer_be(buffer, 20, 4); + db->header_key = get_u32be(&buffer[4]); + db->chksum = get_u32be(&buffer[20]); copy_integer_array_be(db->ht, (uint32_t *) &buffer[24], TSIZE); - db->uid = pick_integer_be(buffer, BSIZE-196, 2); - db->gid = pick_integer_be(buffer, BSIZE-194, 2); - db->protect = pick_integer_be(buffer, BSIZE-192, 4); - db->comm_len = pick_integer_be(buffer, BSIZE-184, 1); + db->uid = get_u16be(&buffer[BSIZE-196]); + db->gid = get_u16be(&buffer[BSIZE-194]); + db->protect = get_u32be(&buffer[BSIZE-192]); + db->comm_len = buffer[BSIZE-184]; memcpy(db->comment, &buffer[BSIZE-183], 79); copy_date_be(&db->date, (uint32_t *) &buffer[BSIZE-92]); - db->name_len = pick_integer_be(buffer, BSIZE-80, 1); + db->name_len = buffer[BSIZE-80]; memcpy(db->dirname, (uint32_t *) &buffer[BSIZE-79], 30); - db->next_link = pick_integer_be(buffer, BSIZE-40, 4); - db->hash_chain = pick_integer_be(buffer, BSIZE-16, 4); - db->parent = pick_integer_be(buffer, BSIZE-12, 4); - db->extension = pick_integer_be(buffer, BSIZE-8, 4); + db->next_link = get_u32be(&buffer[BSIZE-40]); + db->hash_chain = get_u32be(&buffer[BSIZE-16]); + db->parent = get_u32be(&buffer[BSIZE-12]); + db->extension = get_u32be(&buffer[BSIZE-8]); return IMGTOOLERR_SUCCESS; } @@ -722,25 +722,25 @@ static imgtoolerr_t write_dir_block(imgtool::image &img, int block, const dir_bl memset(buffer, 0, BSIZE); /* Copy data */ - place_integer_be(buffer, 0, 4, T_HEADER); - place_integer_be(buffer, 4, 4, db->header_key); - place_integer_be(buffer, 20, 4, db->chksum); + put_u32be(&buffer[0], T_HEADER); + put_u32be(&buffer[4], db->header_key); + put_u32be(&buffer[20], db->chksum); copy_integer_array_be((uint32_t *) &buffer[24], db->ht, TSIZE); - place_integer_be(buffer, BSIZE-196, 2, db->uid); - place_integer_be(buffer, BSIZE-194, 2, db->gid); - place_integer_be(buffer, BSIZE-192, 4, db->protect); - place_integer_be(buffer, BSIZE-184, 1, db->comm_len); - memcpy((uint32_t *) &buffer[BSIZE-183], db->comment, db->comm_len); - place_integer_be(buffer, BSIZE-92, 4, db->date.days); - place_integer_be(buffer, BSIZE-88, 4, db->date.mins); - place_integer_be(buffer, BSIZE-84, 4, db->date.ticks); - place_integer_be(buffer, BSIZE-80, 1, db->name_len); - memcpy((uint32_t *) &buffer[BSIZE-79], db->dirname, db->name_len); - place_integer_be(buffer, BSIZE-40, 4, db->next_link); - place_integer_be(buffer, BSIZE-16, 4, db->hash_chain); - place_integer_be(buffer, BSIZE-12, 4, db->parent); - place_integer_be(buffer, BSIZE-8, 4, db->extension); - place_integer_be(buffer, BSIZE-4, 4, ST_USERDIR); + put_u16be(&buffer[BSIZE-196], db->uid); + put_u16be(&buffer[BSIZE-194], db->gid); + put_u32be(&buffer[BSIZE-192], db->protect); + buffer[BSIZE-184] = db->comm_len; + memcpy(&buffer[BSIZE-183], db->comment, db->comm_len); + put_u32be(&buffer[BSIZE-92], db->date.days); + put_u32be(&buffer[BSIZE-88], db->date.mins); + put_u32be(&buffer[BSIZE-84], db->date.ticks); + buffer[BSIZE-80] = db->name_len; + memcpy(&buffer[BSIZE-79], db->dirname, db->name_len); + put_u32be(&buffer[BSIZE-40], db->next_link); + put_u32be(&buffer[BSIZE-16], db->hash_chain); + put_u32be(&buffer[BSIZE-12], db->parent); + put_u32be(&buffer[BSIZE-8], db->extension); + put_u32be(&buffer[BSIZE-4], ST_USERDIR); /* Write block to disk */ return write_block(img, block, buffer); @@ -757,19 +757,19 @@ static imgtoolerr_t read_hardlink_block(imgtool::image &img, int block, hardlink if (ret) return ret; /* fill in data */ - hl->header_key = pick_integer_be(buffer, 4, 4); - hl->chksum = pick_integer_be(buffer, 20, 4); - hl->protect = pick_integer_be(buffer, BSIZE-192, 4); - hl->comm_len = pick_integer_be(buffer, BSIZE-184, 1); + hl->header_key = get_u32be(&buffer[4]); + hl->chksum = get_u32be(&buffer[20]); + hl->protect = get_u32be(&buffer[BSIZE-192]); + hl->comm_len = buffer[BSIZE-184]; memcpy(hl->comment, &buffer[BSIZE-183], 79); copy_date_be(&hl->date, (uint32_t *) &buffer[BSIZE-92]); - hl->name_len = pick_integer_be(buffer, BSIZE-80, 1); - memcpy(hl->hlname, (uint32_t *) &buffer[BSIZE-79], 30); - hl->real_entry = pick_integer_be(buffer, BSIZE-44, 4); - hl->next_link = pick_integer_be(buffer, BSIZE-40, 4); - hl->hash_chain = pick_integer_be(buffer, BSIZE-16, 4); - hl->parent = pick_integer_be(buffer, BSIZE-12, 4); - hl->sec_type = pick_integer_be(buffer, BSIZE-4, 4); + hl->name_len = buffer[BSIZE-80]; + memcpy(hl->hlname, &buffer[BSIZE-79], 30); + hl->real_entry = get_u32be(&buffer[BSIZE-44]); + hl->next_link = get_u32be(&buffer[BSIZE-40]); + hl->hash_chain = get_u32be(&buffer[BSIZE-16]); + hl->parent = get_u32be(&buffer[BSIZE-12]); + hl->sec_type = get_u32be(&buffer[BSIZE-4]); return IMGTOOLERR_SUCCESS; } @@ -785,17 +785,17 @@ static imgtoolerr_t read_softlink_block(imgtool::image &img, int block, softlink if (ret) return ret; /* fill in data */ - sl->header_key = pick_integer_be(buffer, 4, 4); - sl->chksum = pick_integer_be(buffer, 20, 4); + sl->header_key = get_u32be(&buffer[4]); + sl->chksum = get_u32be(&buffer[20]); memcpy(sl->symbolic_name, &buffer[24], BSIZE-224); - sl->protect = pick_integer_be(buffer, BSIZE-192, 4); - sl->comm_len = pick_integer_be(buffer, BSIZE-184, 1); + sl->protect = get_u32be(&buffer[BSIZE-192]); + sl->comm_len = buffer[BSIZE-184]; memcpy(sl->comment, &buffer[BSIZE-183], 79); copy_date_be(&sl->date, (uint32_t *) &buffer[BSIZE-92]); - sl->name_len = pick_integer_be(buffer, BSIZE-80, 1); - memcpy(sl->slname, (uint32_t *) &buffer[BSIZE-79], 30); - sl->hash_chain = pick_integer_be(buffer, BSIZE-16, 4); - sl->parent = pick_integer_be(buffer, BSIZE-12, 4); + sl->name_len = buffer[BSIZE-80]; + memcpy(sl->slname, &buffer[BSIZE-79], 30); + sl->hash_chain = get_u32be(&buffer[BSIZE-16]); + sl->parent = get_u32be(&buffer[BSIZE-12]); return IMGTOOLERR_SUCCESS; } @@ -945,7 +945,7 @@ static imgtoolerr_t get_hash_chain(imgtool::image &img, int block, uint32_t *cha if (ret) return ret; /* Get chain value */ - *chain = pick_integer_be(buffer, BSIZE-16, 4); + *chain = get_u32be(&buffer[BSIZE-16]); return IMGTOOLERR_SUCCESS; } @@ -961,7 +961,7 @@ static imgtoolerr_t set_hash_chain(imgtool::image &img, int block, uint32_t chai if (ret) return ret; /* Copy new hash chain value into it */ - place_integer_be(buffer, BSIZE-16, 4, chain); + put_u32be(&buffer[BSIZE-16], chain); /* Write it back again */ ret = write_block(img, block, buffer); @@ -1178,11 +1178,11 @@ static imgtoolerr_t fix_chksum(imgtool::image &img, int block, int bitmap) /* update checksum */ if (bitmap) { - place_integer_be(buffer, 0, 4, chksum); + put_u32be(&buffer[0], chksum); } else { - place_integer_be(buffer, 20, 4, chksum); + put_u32be(&buffer[20], chksum); } /* write back new block data */ @@ -1277,9 +1277,9 @@ static imgtoolerr_t update_block_modified_date(imgtool::image &img, int block) amiga_setup_time(now, &date); /* Write new time into block */ - place_integer_be(buffer, BSIZE-92, 4, date.days); - place_integer_be(buffer, BSIZE-88, 4, date.mins); - place_integer_be(buffer, BSIZE-84, 4, date.ticks); + put_u32be(&buffer[BSIZE-92], date.days); + put_u32be(&buffer[BSIZE-88], date.mins); + put_u32be(&buffer[BSIZE-84], date.ticks); /* Write block back to disk */ ret = write_block(img, block, buffer); diff --git a/src/tools/imgtool/modules/fat.cpp b/src/tools/imgtool/modules/fat.cpp index ff9e2d6015e..ca7c8291a74 100644 --- a/src/tools/imgtool/modules/fat.cpp +++ b/src/tools/imgtool/modules/fat.cpp @@ -136,9 +136,8 @@ #include "fat.h" -#include "formats/imageutl.h" - #include "corestr.h" +#include "multibyte.h" #include "unicode.h" #include <cctype> @@ -412,14 +411,14 @@ static imgtoolerr_t fat_partition_open(imgtool::partition &partition, uint64_t f } info->fat_bits = fat_bits; - sector_size = pick_integer_le(header, 11, 2); - info->sectors_per_cluster = pick_integer_le(header, 13, 1); - info->reserved_sectors = pick_integer_le(header, 14, 2); - info->fat_count = pick_integer_le(header, 16, 1); - info->root_entries = pick_integer_le(header, 17, 2); - total_sectors_l = pick_integer_le(header, 19, 2); - info->sectors_per_fat = pick_integer_le(header, 22, 2); - total_sectors_h = pick_integer_le(header, 32, 4); + sector_size = get_u16le(&header[11]); + info->sectors_per_cluster = header[13]; + info->reserved_sectors = get_u16le(&header[14]); + info->fat_count = header[16]; + info->root_entries = get_u16le(&header[17]); + total_sectors_l = get_u16le(&header[19]); + info->sectors_per_fat = get_u16le(&header[22]); + total_sectors_h = get_u32le(&header[32]); if (info->sectors_per_cluster == 0) return IMGTOOLERR_CORRUPTIMAGE; @@ -522,24 +521,24 @@ static imgtoolerr_t fat_partition_create(imgtool::image &image, uint64_t first_b /* prepare the header */ memset(header, 0, sizeof(header)); memcpy(&header[3], "IMGTOOL ", 8); - place_integer_le(header, 11, 2, FAT_SECLEN); - place_integer_le(header, 13, 1, sectors_per_cluster); - 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_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_t) (block_count >> 16)); - place_integer_le(header, 36, 1, 0xFF); - place_integer_le(header, 38, 1, 0x28); - place_integer_le(header, 39, 1, std::rand()); - place_integer_le(header, 40, 1, std::rand()); - place_integer_le(header, 41, 1, std::rand()); - place_integer_le(header, 42, 1, std::rand()); + put_u16le(&header[11], FAT_SECLEN); + header[13] = sectors_per_cluster; + header[14] = reserved_sectors; + header[16] = fat_count; + put_u16le(&header[17], root_dir_count); + put_u16le(&header[19], (uint16_t) (block_count >> 0)); + header[21] = media_descriptor; + put_u16le(&header[22], sectors_per_fat); + put_u16le(&header[24], sectors_per_track); + put_u16le(&header[26], heads); + put_u32le(&header[28], hidden_sectors); + put_u32le(&header[32], (uint32_t) (block_count >> 16)); + header[36] = 0xFF; + header[38] = 0x28; + header[39] = std::rand(); + header[40] = std::rand(); + header[41] = std::rand(); + header[42] = std::rand(); memcpy(&header[43], " ", 11); memcpy(&header[54], fat_bits_string, 8); @@ -1082,8 +1081,8 @@ static imgtoolerr_t fat_set_file_size(imgtool::partition &partition, fat_file *f } /* record the new file size */ - place_integer_le(dirent, 26, 2, file->first_cluster); - place_integer_le(dirent, 28, 4, new_size); + put_u16le(&dirent[26], file->first_cluster); + put_u32le(&dirent[28], new_size); /* delete the file, if appropriate */ if (delete_file) @@ -1382,13 +1381,13 @@ static imgtoolerr_t fat_read_dirent(imgtool::partition &partition, fat_file *fil } /* other attributes */ - ent.filesize = pick_integer_le(entry, 28, 4); + ent.filesize = get_u32le(&entry[28]); ent.directory = (entry[11] & 0x10) ? 1 : 0; - ent.first_cluster = pick_integer_le(entry, 26, 2); + ent.first_cluster = get_u16le(&entry[26]); ent.dirent_sector_index = entry_sector_index; ent.dirent_sector_offset = entry_sector_offset; - ent.creation_time = fat_crack_time(pick_integer_le(entry, 14, 4)); - ent.lastmodified_time = fat_crack_time(pick_integer_le(entry, 22, 4)); + ent.creation_time = fat_crack_time(get_u32le(&entry[14])); + ent.lastmodified_time = fat_crack_time(get_u32le(&entry[22])); return IMGTOOLERR_SUCCESS; } @@ -1442,9 +1441,9 @@ static imgtoolerr_t fat_construct_dirent(const char *filename, creation_policy_t /* set up file dates in the new dirent */ now = fat_setup_time(time(NULL)); - place_integer_le(created_entry, 14, 4, now); - place_integer_le(created_entry, 18, 2, now); - place_integer_le(created_entry, 22, 4, now); + put_u32le(&created_entry[14], now); + put_u16le(&created_entry[18], now); + put_u32le(&created_entry[22], now); while(*filename) { @@ -2053,11 +2052,11 @@ static imgtoolerr_t fat_partition_createdir(imgtool::partition &partition, const /* set up the two directory entries in all directories */ memset(initial_data, 0, sizeof(initial_data)); memcpy(&initial_data[0], ". ", 11); - place_integer_le(initial_data, 11, 1, 0x10); - place_integer_le(initial_data, 26, 2, file.first_cluster); + initial_data[11] = 0x10; + put_u16le(&initial_data[26], file.first_cluster); memcpy(&initial_data[32], ". ", 11); - place_integer_le(initial_data, 43, 1, 0x10); - place_integer_le(initial_data, 58, 2, file.parent_first_cluster); + initial_data[43] = 0x10; + put_u16le(&initial_data[58], file.parent_first_cluster); err = fat_write_file(partition, &file, initial_data, sizeof(initial_data), NULL); if (err) diff --git a/src/tools/imgtool/modules/hp85_tape.cpp b/src/tools/imgtool/modules/hp85_tape.cpp index 09590f81973..319f1e3f10c 100644 --- a/src/tools/imgtool/modules/hp85_tape.cpp +++ b/src/tools/imgtool/modules/hp85_tape.cpp @@ -10,10 +10,11 @@ #include "imgtool.h" #include "formats/hti_tape.h" -#include "formats/imageutl.h" #include "ioprocs.h" +#include "multibyte.h" #include "opresolv.h" +#include "strformat.h" #include <cstdio> #include <iostream> @@ -633,7 +634,7 @@ bool tape_image_85::decode_dir(const sif_file_t& file_0) // Get FL1TK1 file_track_1 = file_0[ 0xfd ]; - record_track_1 = pick_integer_le(file_0.data() , 0xfe , 2); + record_track_1 = get_u16le(&file_0[ 0xfe ]); file_no_t file_no = 1; @@ -664,10 +665,10 @@ bool tape_image_85::decode_dir(const sif_file_t& file_0) new_entry.file_no = file_no++; // Physical records - new_entry.n_recs = pick_integer_le(p , 8 , 2); + new_entry.n_recs = get_u16le(&p[ 8 ]); // Bytes per logical record - new_entry.record_len = pick_integer_le(p , 10 , 2); + new_entry.record_len = get_u16le(&p[ 10 ]); if (new_entry.record_len < 4 || new_entry.record_len >= 32768) { return false; } @@ -688,8 +689,8 @@ void tape_image_85::encode_dir(sif_file_t& file_0) const file_0[ 0x1fc ] = 1; // Set FL1TK1 file_0[ 0xfd ] = file_0[ 0x1fd ] = file_track_1; - place_integer_le(file_0.data() , 0xfe , 2 , record_track_1); - place_integer_le(file_0.data() , 0x1fe , 2 , record_track_1); + put_u16le(&file_0[ 0xfe ] , record_track_1); + put_u16le(&file_0[ 0x1fe ] , record_track_1); unsigned i = 0; file_no_t file_no = 1; @@ -702,8 +703,8 @@ void tape_image_85::encode_dir(sif_file_t& file_0) const memcpy(&p_entry[ 0 ] , &entry->filename[ 0 ] , CHARS_PER_FNAME); p_entry[ 6 ] = file_no; p_entry[ 7 ] = entry->filetype; - place_integer_le(p_entry , 8 , 2 , entry->n_recs); - place_integer_le(p_entry , 10 , 2 , entry->record_len); + put_u16le(&p_entry[ 8 ] , entry->n_recs); + put_u16le(&p_entry[ 10 ] , entry->record_len); } if (file_no <= MAX_FILE_NO) { diff --git a/src/tools/imgtool/modules/hp9845_tape.cpp b/src/tools/imgtool/modules/hp9845_tape.cpp index 5254c26b9d4..8398f63bdce 100644 --- a/src/tools/imgtool/modules/hp9845_tape.cpp +++ b/src/tools/imgtool/modules/hp9845_tape.cpp @@ -112,10 +112,10 @@ #include "filter.h" #include "formats/hti_tape.h" -#include "formats/imageutl.h" #include "corefile.h" #include "ioprocs.h" +#include "multibyte.h" #include "opresolv.h" #include <bitset> @@ -1344,7 +1344,7 @@ static imgtoolerr_t hp9845data_read_file(imgtool::partition &partition, const ch if (!get_record_part(*inp_data , tmp , 2)) { return IMGTOOLERR_READERROR; } - rec_type = (uint16_t)pick_integer_be(tmp , 0 , 2); + rec_type = get_u16be(&tmp[ 0 ]); switch (rec_type) { case REC_TYPE_EOR: // End of record: just skip it @@ -1367,7 +1367,7 @@ static imgtoolerr_t hp9845data_read_file(imgtool::partition &partition, const ch if (!get_record_part(*inp_data , tmp , 2)) { return IMGTOOLERR_READERROR; } - tmp_len = (unsigned)pick_integer_be(tmp , 0 , 2); + tmp_len = get_u16be(&tmp [ 0 ]); if (rec_type == REC_TYPE_FULLSTR || rec_type == REC_TYPE_1STSTR) { accum_len = tmp_len; @@ -1415,7 +1415,7 @@ static bool split_string_n_dump(const char *s , imgtool::stream &dest) unsigned free_len = len_to_eor(dest); if (free_len <= 4) { // Not enough free space at end of current record: fill with EORs - place_integer_be(tmp , 0 , 2 , REC_TYPE_EOR); + put_u16be(&tmp[ 0 ] , REC_TYPE_EOR); while (free_len) { if (dest.write(tmp , 2) != 2) { return false; @@ -1428,8 +1428,8 @@ static bool split_string_n_dump(const char *s , imgtool::stream &dest) // Free space to EOR enough for what's left of string break; } - place_integer_be(tmp , 0 , 2 , rec_type); - place_integer_be(tmp , 2 , 2 , s_len); + put_u16be(&tmp[ 0 ] , rec_type); + put_u16be(&tmp[ 2 ] , s_len); if (dest.write(tmp , 4) != 4 || dest.write(s, s_part_len) != s_part_len) { return false; @@ -1441,8 +1441,8 @@ static bool split_string_n_dump(const char *s , imgtool::stream &dest) } } - place_integer_be(tmp , 0 , 2 , at_least_one ? REC_TYPE_ENDSTR : REC_TYPE_FULLSTR); - place_integer_be(tmp , 2 , 2 , s_len); + put_u16be(&tmp[ 0 ] , at_least_one ? REC_TYPE_ENDSTR : REC_TYPE_FULLSTR); + put_u16be(&tmp[ 2 ] , s_len); if (dest.write(tmp , 4) != 4 || dest.write(s , s_len) != s_len) { return false; @@ -1498,7 +1498,7 @@ static imgtoolerr_t hp9845data_write_file(imgtool::partition &partition, const c // Fill free space of last record with EOFs unsigned free_len = len_to_eor(*out_data); uint8_t tmp[ 2 ]; - place_integer_be(tmp , 0 , 2 , REC_TYPE_EOF); + put_u16be(&tmp[ 0 ] , REC_TYPE_EOF); while (free_len) { if (out_data->write(tmp , 2 ) != 2) { diff --git a/src/tools/imgtool/modules/os9.cpp b/src/tools/imgtool/modules/os9.cpp index 104e48bd0f0..33c4210b18a 100644 --- a/src/tools/imgtool/modules/os9.cpp +++ b/src/tools/imgtool/modules/os9.cpp @@ -11,8 +11,8 @@ #include "imgtool.h" #include "iflopimg.h" -#include "formats/imageutl.h" #include "formats/coco_dsk.h" +#include "multibyte.h" #include "opresolv.h" #include <cstdio> @@ -99,14 +99,11 @@ static void pick_string(const void *ptr, size_t offset, size_t length, char *des -static void place_string(void *ptr, size_t offset, size_t length, const char *s) +static void place_string(void *ptr, size_t length, const char *s) { size_t i; uint8_t b; - uint8_t *bptr; - - bptr = (uint8_t *) ptr; - bptr += offset; + uint8_t *bptr = (uint8_t *) ptr; bptr[0] = 0x80; @@ -231,7 +228,7 @@ static int os9_interpret_dirent(void *entry, char **filename, uint32_t *lsn, int entry_b[i] &= 0x7F; entry_b[i+1] = '\0'; - *lsn = pick_integer_be(entry, 29, 3); + *lsn = get_u24be((uint8_t *) &entry_b[29]); if (strcmp(entry_b, ".") && strcmp(entry_b, "..")) *filename = entry_b; return *filename != NULL; @@ -260,10 +257,10 @@ static imgtoolerr_t os9_decode_file_header(imgtool::image &image, return err; info->lsn = lsn; - attributes = pick_integer_be(header, 0, 1); - info->owner_id = pick_integer_be(header, 1, 2); - info->link_count = pick_integer_be(header, 8, 1); - info->file_size = pick_integer_be(header, 9, 4); + attributes = header[0]; + info->owner_id = get_u16be(&header[1]); + info->link_count = header[8]; + info->file_size = get_u32be(&header[9]); info->directory = (attributes & 0x80) ? 1 : 0; info->non_sharable = (attributes & 0x40) ? 1 : 0; info->public_execute = (attributes & 0x20) ? 1 : 0; @@ -281,8 +278,8 @@ static imgtoolerr_t os9_decode_file_header(imgtool::image &image, max_entries = (std::min<std::size_t>)(max_entries, std::size(info->sector_map) - 1); for (i = 0; i < max_entries; i++) { - lsn = pick_integer_be(header, 16 + (i * 5) + 0, 3); - count = pick_integer_be(header, 16 + (i * 5) + 3, 2); + lsn = get_u24be(&header[16 + (i * 5) + 0]); + count = get_u16be(&header[16 + (i * 5) + 3]); if (count <= 0) break; @@ -459,15 +456,15 @@ static imgtoolerr_t os9_set_file_size(imgtool::image &image, return err; file_info->file_size = new_size; - place_integer_be(header, 9, 4, file_info->file_size); + put_u32be(&header[9], file_info->file_size); /* do we have to write the sector map? */ if (sector_map_length >= 0) { for (i = 0; i < (std::min<std::size_t>)(sector_map_length + 1, std::size(file_info->sector_map)); i++) { - place_integer_be(header, 16 + (i * 5) + 0, 3, file_info->sector_map[i].lsn); - place_integer_be(header, 16 + (i * 5) + 3, 2, file_info->sector_map[i].count); + put_u24be(&header[16 + (i * 5) + 0], file_info->sector_map[i].lsn); + put_u16be(&header[16 + (i * 5) + 3], file_info->sector_map[i].count); } } @@ -570,7 +567,7 @@ static imgtoolerr_t os9_lookup_path(imgtool::image &img, const char *path, /* write the file */ memset(block, 0, sizeof(block)); - place_integer_be(block, 0, 1, 0x1B | ((create == CREATE_DIR) ? 0x80 : 0x00)); + block[0] = 0x1B | ((create == CREATE_DIR) ? 0x80 : 0x00); err = os9_write_lsn(img, allocated_lsn, 0, block, sizeof(block)); if (err) goto done; @@ -588,8 +585,8 @@ static imgtoolerr_t os9_lookup_path(imgtool::image &img, const char *path, /* now prepare the directory entry */ memset(entry, 0, sizeof(entry)); - place_string(entry, 0, 28, path); - place_integer_be(entry, 29, 3, allocated_lsn); + place_string(&entry[0], 28, path); + put_u24be(&entry[29], allocated_lsn); /* now write the directory entry */ entry_index = dir_size; @@ -641,20 +638,19 @@ static imgtoolerr_t os9_diskimage_open(imgtool::image &image, imgtool::stream::p if (ferr) return imgtool_floppy_error(ferr); - info->total_sectors = pick_integer_be(header, 0, 3); - track_size_in_sectors = pick_integer_be(header, 3, 1); - info->allocation_bitmap_bytes = pick_integer_be(header, 4, 2); - info->cluster_size = pick_integer_be(header, 6, 2); - info->root_dir_lsn = pick_integer_be(header, 8, 3); - info->owner_id = pick_integer_be(header, 11, 2); -// attributes = - pick_integer_be(header, 13, 1); - info->disk_id = pick_integer_be(header, 14, 2); - info->format_flags = pick_integer_be(header, 16, 1); - info->sectors_per_track = pick_integer_be(header, 17, 2); - info->bootstrap_lsn = pick_integer_be(header, 21, 3); - info->bootstrap_size = pick_integer_be(header, 24, 2); - info->sector_size = pick_integer_be(header, 104, 2); + info->total_sectors = get_u24be(&header[ 0]); + track_size_in_sectors = header[ 3]; + info->allocation_bitmap_bytes = get_u16be(&header[ 4]); + info->cluster_size = get_u16be(&header[ 6]); + info->root_dir_lsn = get_u24be(&header[ 8]); + info->owner_id = get_u16be(&header[ 11]); +// attributes = header[ 13]; + info->disk_id = get_u16be(&header[ 14]); + info->format_flags = header[ 16]; + info->sectors_per_track = get_u16be(&header[ 17]); + info->bootstrap_lsn = get_u24be(&header[ 21]); + info->bootstrap_size = get_u16be(&header[ 24]); + info->sector_size = get_u16be(&header[104]); info->sides = (info->format_flags & 0x01) ? 2 : 1; info->double_density = (info->format_flags & 0x02) ? 1 : 0; @@ -747,30 +743,30 @@ static imgtoolerr_t os9_diskimage_create(imgtool::image &img, imgtool::stream::p format_flags = ((heads > 1) ? 0x01 : 0x00) | ((tracks > 40) ? 0x02 : 0x00); memset(&header[0], 0, sector_bytes); - place_integer_be(&header[0], 0, 3, heads * tracks * sectors); - place_integer_be(&header[0], 3, 1, sectors); - place_integer_be(&header[0], 4, 2, (allocation_bitmap_bits + 7) / 8); - place_integer_be(&header[0], 6, 2, cluster_size); - place_integer_be(&header[0], 8, 3, 1 + allocation_bitmap_lsns); - place_integer_be(&header[0], 11, 2, owner_id); - place_integer_be(&header[0], 13, 1, attributes); - place_integer_be(&header[0], 14, 2, disk_id); - place_integer_be(&header[0], 16, 1, format_flags); - place_integer_be(&header[0], 17, 2, sectors); - place_string(&header[0], 31, 32, title); - place_integer_be(&header[0], 103, 2, sector_bytes / 256); + put_u24be(&header[ 0], heads * tracks * sectors); + header[ 3] = sectors; + put_u16be(&header[ 4], (allocation_bitmap_bits + 7) / 8); + put_u16be(&header[ 6], cluster_size); + put_u24be(&header[ 8], 1 + allocation_bitmap_lsns); + put_u16be(&header[ 11], owner_id); + header[ 13] = attributes; + put_u16be(&header[ 14], disk_id); + header[ 16] = format_flags; + put_u16be(&header[ 17], sectors); + place_string(&header[ 31], 32, title); + put_u16be(&header[103], sector_bytes / 256); /* path descriptor options */ - place_integer_be(&header[0], 0x3f+0x00, 1, 1); /* device class */ - place_integer_be(&header[0], 0x3f+0x01, 1, 1); /* drive number */ - place_integer_be(&header[0], 0x3f+0x03, 1, 0x20); /* device type */ - place_integer_be(&header[0], 0x3f+0x04, 1, 1); /* density capability */ - place_integer_be(&header[0], 0x3f+0x05, 2, tracks); /* number of tracks */ - place_integer_be(&header[0], 0x3f+0x07, 1, heads); /* number of sides */ - place_integer_be(&header[0], 0x3f+0x09, 2, sectors); /* sectors per track */ - place_integer_be(&header[0], 0x3f+0x0b, 2, sectors); /* sectors on track zero */ - place_integer_be(&header[0], 0x3f+0x0d, 1, 3); /* sector interleave factor */ - place_integer_be(&header[0], 0x3f+0x0e, 1, 8); /* default sectors per allocation */ + header[0x3f+0x00] = 1; /* device class */ + header[0x3f+0x01] = 1; /* drive number */ + header[0x3f+0x03] = 0x20; /* device type */ + header[0x3f+0x04] = 1; /* density capability */ + put_u16be(&header[0x3f+0x05], tracks); /* number of tracks */ + header[0x3f+0x07] = heads; /* number of sides */ + put_u16be(&header[0x3f+0x09], sectors); /* sectors per track */ + put_u16be(&header[0x3f+0x0b], sectors); /* sectors on track zero */ + header[0x3f+0x0d] = 3; /* sector interleave factor */ + header[0x3f+0x0e] = 8; /* default sectors per allocation */ err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id, 0, &header[0], sector_bytes, 0); /* TODO: pass ddam argument from imgtool */ if (err) @@ -824,8 +820,8 @@ static imgtoolerr_t os9_diskimage_create(imgtool::image &img, imgtool::stream::p header[0x0D] = (uint8_t) (ltime->tm_year % 100); header[0x0E] = (uint8_t) ltime->tm_mon; header[0x0F] = (uint8_t) ltime->tm_mday; - place_integer_be(&header[0], 0x10, 3, 1 + allocation_bitmap_lsns + 1); - place_integer_be(&header[0], 0x13, 2, 8); + put_u24be(&header[0x10], 1 + allocation_bitmap_lsns + 1); + put_u16be(&header[0x13], 8); err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id + 1 + allocation_bitmap_lsns, 0, &header[0], sector_bytes, 0); /* TODO: pass ddam argument from imgtool */ if (err) @@ -929,7 +925,7 @@ static imgtoolerr_t os9_diskimage_nextenum(imgtool::directory &enumeration, imgt } /* if the filename is ".", the file should point to the current directory */ - if (!strcmp(filename, ".") && (pick_integer_be(dir_entry, 29, 3) != os9enum->dir_info.lsn)) + if (!strcmp(filename, ".") && (get_u24be(&dir_entry[29]) != os9enum->dir_info.lsn)) { imgtool_warn("Directory \".\" does not point back to same directory"); } @@ -946,7 +942,7 @@ static imgtoolerr_t os9_diskimage_nextenum(imgtool::directory &enumeration, imgt while(!filename[0] || !strcmp(filename, ".") || !strcmp(filename, "..")); /* read file attributes */ - lsn = pick_integer_be(dir_entry, 29, 3); + lsn = get_u24be(&dir_entry[29]); err = os9_decode_file_header(enumeration.image(), lsn, &file_info); if (err) return err; @@ -1185,10 +1181,10 @@ static imgtoolerr_t os9_diskimage_createdir(imgtool::partition &partition, const /* create intial directories */ memset(dir_data, 0, sizeof(dir_data)); - place_string(dir_data, 0, 32, ".."); - place_integer_be(dir_data, 29, 3, parent_lsn); - place_string(dir_data, 32, 32, "."); - place_integer_be(dir_data, 61, 3, file_info.lsn); + place_string(&dir_data[ 0], 32, ".."); + put_u24be(&dir_data[29], parent_lsn); + place_string(&dir_data[32], 32, "."); + put_u24be(&dir_data[61], file_info.lsn); err = os9_write_lsn(image, file_info.sector_map[0].lsn, 0, dir_data, sizeof(dir_data)); if (err) diff --git a/src/tools/imgtool/modules/pc_flop.cpp b/src/tools/imgtool/modules/pc_flop.cpp index fd08b8ed3c7..423336c6744 100644 --- a/src/tools/imgtool/modules/pc_flop.cpp +++ b/src/tools/imgtool/modules/pc_flop.cpp @@ -12,9 +12,9 @@ #include "fat.h" #include "iflopimg.h" -#include "formats/imageutl.h" #include "formats/pc_dsk_legacy.h" +#include "multibyte.h" #include "opresolv.h" #define FAT_SECLEN 512 @@ -34,10 +34,10 @@ static imgtoolerr_t fat_image_create(imgtool::image &image, imgtool::stream::ptr /* set up just enough of a boot sector to specify geometry */ memset(buffer, 0, sizeof(buffer)); - place_integer_le(buffer, 24, 2, sectors); - place_integer_le(buffer, 26, 2, heads); - place_integer_le(buffer, 19, 2, (uint16_t) (((uint64_t) tracks * heads * sectors) >> 0)); - place_integer_le(buffer, 32, 4, (uint16_t) (((uint64_t) tracks * heads * sectors) >> 16)); + put_u16le(&buffer[24], sectors); + put_u16le(&buffer[26], heads); + put_u16le(&buffer[19], (uint16_t) (((uint64_t) tracks * heads * sectors) >> 0)); + put_u32le(&buffer[32], (uint16_t) (((uint64_t) tracks * heads * sectors) >> 16)); err = image.write_block(0, buffer); if (err) goto done; @@ -67,11 +67,11 @@ static imgtoolerr_t fat_image_get_geometry(imgtool::image &image, uint32_t *trac if (err) return err; - total_sectors = pick_integer_le(buffer, 19, 2) - | (pick_integer_le(buffer, 32, 4) << 16); + total_sectors = get_u16le(&buffer[19]) + | (uint64_t)(get_u32le(&buffer[32]) << 16); - *sectors = pick_integer_le(buffer, 24, 2); - *heads = pick_integer_le(buffer, 26, 2); + *sectors = get_u16le(&buffer[24]); + *heads = get_u16le(&buffer[26]); *tracks = total_sectors / *heads / *sectors; return IMGTOOLERR_SUCCESS; } diff --git a/src/tools/imgtool/modules/pc_hard.cpp b/src/tools/imgtool/modules/pc_hard.cpp index d6e1f6fd2b7..353a6b5dac5 100644 --- a/src/tools/imgtool/modules/pc_hard.cpp +++ b/src/tools/imgtool/modules/pc_hard.cpp @@ -50,9 +50,9 @@ ****************************************************************************/ #include "imgtool.h" -#include "formats/imageutl.h" #include "imghd.h" +#include "multibyte.h" #include "opresolv.h" #define FAT_SECLEN 512 @@ -167,16 +167,16 @@ static imgtoolerr_t pc_chd_partition_create(imgtool::image &image, int partition /* fill out the partition entry */ partition_entry = &header_block[446 + (partition_index * 16)]; - place_integer_le(partition_entry, 0, 1, 0x80); - place_integer_le(partition_entry, 1, 1, first_head); - place_integer_le(partition_entry, 2, 1, ((first_sector & 0x3F) | (first_cylinder >> 8 << 2))); - place_integer_le(partition_entry, 3, 1, first_cylinder); - place_integer_le(partition_entry, 4, 1, partition_type); - place_integer_le(partition_entry, 5, 1, last_head); - place_integer_le(partition_entry, 6, 1, ((last_sector & 0x3F) | (last_cylinder >> 8 << 2))); - place_integer_le(partition_entry, 7, 1, last_cylinder); - place_integer_le(partition_entry, 8, 4, first_block); - place_integer_le(partition_entry, 12, 4, block_count); + partition_entry[0] = 0x80; + partition_entry[1] = first_head; + partition_entry[2] = ((first_sector & 0x3F) | (first_cylinder >> 8 << 2)); + partition_entry[3] = first_cylinder; + partition_entry[4] = partition_type; + partition_entry[5] = last_head; + partition_entry[6] = ((last_sector & 0x3F) | (last_cylinder >> 8 << 2)); + partition_entry[7] = last_cylinder; + put_u32le(&partition_entry[ 8], first_block); + put_u32le(&partition_entry[12], block_count); /* write the partition header */ err = image.write_block(0, header_block); @@ -219,8 +219,8 @@ static imgtoolerr_t pc_chd_read_partition_header(imgtool::image &image) info->partitions[i].ending_track = ((partition_info[6] << 2) & 0xFF00) | partition_info[7]; info->partitions[i].ending_sector = partition_info[6] & 0x3F; - info->partitions[i].sector_index = pick_integer_le(partition_info, 8, 4); - info->partitions[i].total_sectors = pick_integer_le(partition_info, 12, 4); + info->partitions[i].sector_index = get_u32le(&partition_info[ 8]); + info->partitions[i].total_sectors = get_u32le(&partition_info[12]); if (info->partitions[i].starting_track > info->partitions[i].ending_track) return IMGTOOLERR_CORRUPTIMAGE; diff --git a/src/tools/imgtool/modules/rt11.cpp b/src/tools/imgtool/modules/rt11.cpp index be6535550bb..cc425adbdb6 100644 --- a/src/tools/imgtool/modules/rt11.cpp +++ b/src/tools/imgtool/modules/rt11.cpp @@ -72,9 +72,10 @@ ****************************************************************************/ #include "imgtool.h" -#include "formats/imageutl.h" #include "iflopimg.h" +#include "multibyte.h" + #include <cstdio> #include <cstdlib> #include <cstring> @@ -384,17 +385,17 @@ static imgtoolerr_t rt11_image_open(imgtool::image &image, imgtool::stream::ptr if (err) return err; - di->directory_start = pick_integer_le(buffer, 0724, 2); + di->directory_start = get_u16le(&buffer[0724]); // real-world images seem to never have a valid checksum, but directory_start is always 6 #if 0 uint16_t tmp, cksum; tmp = 0; - cksum = pick_integer_le(buffer, 0776, 2); + cksum = get_u16le(&buffer[0776]); for (int i = 0; i < 510; i+=2) { - tmp += pick_integer_le(buffer, i, 2); + tmp += get_u16le(&buffer[i]); } /* sanity check these values */ @@ -414,9 +415,9 @@ static imgtoolerr_t rt11_image_open(imgtool::image &image, imgtool::stream::ptr if (err) return err; - di->total_segments = pick_integer_le(buffer, 0, 2); - di->last_segment = pick_integer_le(buffer, 4, 2); - di->dirent_size = (pick_integer_le(buffer, 6, 2) + 7) * 2; + di->total_segments = get_u16le(&buffer[0]); + di->last_segment = get_u16le(&buffer[4]); + di->dirent_size = (get_u16le(&buffer[6]) + 7) * 2; di->dirents_per_block = (2 * BLOCK_SIZE - 10) / di->dirent_size; return IMGTOOLERR_SUCCESS; @@ -465,7 +466,7 @@ static imgtoolerr_t rt11_enum_seek(imgtool::image &image, return err; memcpy(&rt11enum->segment_data[BLOCK_SIZE], buffer, sizeof(buffer)); - rt11enum->data = pick_integer_le(rt11enum->segment_data, 8, 2); + rt11enum->data = get_u16le(&rt11enum->segment_data[8]); } rt11enum->segment = segment; } @@ -490,19 +491,19 @@ static imgtoolerr_t rt11_get_next_dirent(imgtool::image &image, /* populate the resulting dirent */ offset = (rt11enum->index * di->dirent_size) + 10; - rt_ent.status = pick_integer_le(rt11enum->segment_data, offset, 2); + rt_ent.status = get_u16le(&rt11enum->segment_data[offset]); memcpy(rt_ent.filename, &rt11enum->segment_data[offset + 2], 6); - rt_ent.filesize = pick_integer_le(rt11enum->segment_data, offset + 8, 2) * BLOCK_SIZE; + rt_ent.filesize = get_u16le(&rt11enum->segment_data[offset + 8]) * BLOCK_SIZE; rt_ent.data = rt11enum->data; - rt_ent.time = pick_integer_le(rt11enum->segment_data, offset + 12, 2); - rt11enum->data += pick_integer_le(rt11enum->segment_data, offset + 8, 2); + rt_ent.time = get_u16le(&rt11enum->segment_data[offset + 12]); + rt11enum->data += get_u16le(&rt11enum->segment_data[offset + 8]); /* identify next entry */ next_segment = rt11enum->segment; next_index = rt11enum->index + 1; if (next_index >= di->dirents_per_block || (rt_ent.status & E_EOS)) { - next_segment = pick_integer_le(rt11enum->segment_data, 2, 2); + next_segment = get_u16le(&rt11enum->segment_data[2]); next_index = 0; } diff --git a/src/tools/imgtool/modules/thomson.cpp b/src/tools/imgtool/modules/thomson.cpp index d5281542c60..495436dbebb 100644 --- a/src/tools/imgtool/modules/thomson.cpp +++ b/src/tools/imgtool/modules/thomson.cpp @@ -115,8 +115,8 @@ #include "filter.h" #include "iflopimg.h" -#include "formats/imageutl.h" #include "corestr.h" +#include "multibyte.h" #include "opresolv.h" #include <cstdio> @@ -1770,8 +1770,8 @@ static imgtoolerr_t thom_basic_write_file(imgtool::partition &partition, /* set up line header */ memset(&line_header, 0, sizeof(line_header)); /* linelength or offset (2-bytes) will be rewritten */ - place_integer_be(line_header, 0, 2, 0xffff); - place_integer_be(line_header, 2, 2, line_number); + put_u16be(&line_header[0], 0xffff); + put_u16be(&line_header[2], line_number); /* emit line header */ line_header_loc = mem_stream->tell(); @@ -1846,7 +1846,7 @@ static imgtoolerr_t thom_basic_write_file(imgtool::partition &partition, /* rewrite the line length */ end_line_loc = mem_stream->tell(); mem_stream->seek(line_header_loc, SEEK_SET); - place_integer_be(line_header, 0, 2, end_line_loc - line_header_loc); + put_u16be(&line_header[0], end_line_loc - line_header_loc); mem_stream->write(line_header, sizeof(line_header)); mem_stream->seek(end_line_loc, SEEK_SET); } @@ -1859,8 +1859,8 @@ static imgtoolerr_t thom_basic_write_file(imgtool::partition &partition, mem_stream->seek(0, SEEK_SET); /* Write file header */ - place_integer_be(file_header, 0, 1, 0xFF); - place_integer_be(file_header, 1, 2, mem_stream->size()); + file_header[0] = 0xFF; + put_u16be(&file_header[1], mem_stream->size()); mem_stream->write(file_header, 3); mem_stream->seek(0, SEEK_SET); diff --git a/src/tools/imgtool/modules/vzdos.cpp b/src/tools/imgtool/modules/vzdos.cpp index 5a4c7f2f122..139aa86efce 100644 --- a/src/tools/imgtool/modules/vzdos.cpp +++ b/src/tools/imgtool/modules/vzdos.cpp @@ -14,8 +14,8 @@ #include "formats/vt_dsk_legacy.h" -#include "formats/imageutl.h" #include "corestr.h" +#include "multibyte.h" #include "opresolv.h" #include <cmath> @@ -141,7 +141,7 @@ static imgtoolerr_t vzdos_read_sector_data(imgtool::image &img, int track, int s if (ret) return (imgtoolerr_t)ret; /* verify sector checksums */ - if (pick_integer_le(buffer, DATA_SIZE + 2, 2) != chksum16(buffer, DATA_SIZE + 2)) + if (get_u16le(&buffer[DATA_SIZE + 2]) != chksum16(buffer, DATA_SIZE + 2)) return IMGTOOLERR_CORRUPTFILE; memcpy(data, &buffer, DATA_SIZE + 2); @@ -159,7 +159,7 @@ static imgtoolerr_t vzdos_write_sector_data(imgtool::image &img, int track, int if (ret) return (imgtoolerr_t)ret; memcpy(buffer, data, DATA_SIZE + 2); - place_integer_le(buffer, DATA_SIZE + 2, 2, chksum16(data, DATA_SIZE + 2)); + put_u16le(&buffer[DATA_SIZE + 2], chksum16(data, DATA_SIZE + 2)); ret = floppy_write_sector(imgtool_floppy(img), 0, track, sector_order[sector], data_start, buffer, sizeof(buffer), 0); /* TODO: pass ddam argument from imgtool */ if (ret) return (imgtoolerr_t)ret; @@ -189,10 +189,10 @@ static imgtoolerr_t vzdos_get_dirent(imgtool::image &img, int index, vzdos_diren entry = ((index % 8) * sizeof(vzdos_dirent)); memcpy(ent, &buffer[entry], 10); - ent->start_track = pick_integer_le(&buffer[entry], 10, 1); - ent->start_sector = pick_integer_le(&buffer[entry], 11, 1); - ent->start_address = pick_integer_le(&buffer[entry], 12, 2); - ent->end_address = pick_integer_le(&buffer[entry], 14, 2); + ent->start_track = buffer[entry + 10]; + ent->start_sector = buffer[entry + 11]; + ent->start_address = get_u16le(&buffer[entry + 12]); + ent->end_address = get_u16le(&buffer[entry + 14]); if (ent->ftype == 0x00) return IMGTOOLERR_FILENOTFOUND; @@ -220,10 +220,10 @@ static imgtoolerr_t vzdos_set_dirent(imgtool::image &img, int index, vzdos_diren entry = ((index % 8) * sizeof(vzdos_dirent)); memcpy(&buffer[entry], &ent, 10); - place_integer_le(buffer, entry + 10, 1, ent.start_track); - place_integer_le(buffer, entry + 11, 1, ent.start_sector); - place_integer_le(buffer, entry + 12, 2, ent.start_address); - place_integer_le(buffer, entry + 14, 2, ent.end_address); + buffer[entry + 10] = ent.start_track; + buffer[entry + 11] = ent.start_sector; + put_u16le(&buffer[entry + 12], ent.start_address); + put_u16le(&buffer[entry + 14], ent.end_address); /* save new sector */ ret = vzdos_write_sector_data(img, 0, (int) index / 8, buffer); @@ -514,12 +514,12 @@ static imgtoolerr_t vzdos_diskimage_readfile(imgtool::partition &partition, cons if (ret) return ret; /* detect sectors pointing to themselfs */ - if ((track == (int)pick_integer_le(buffer, DATA_SIZE, 1)) && (sector == (int)pick_integer_le(buffer, DATA_SIZE + 1, 1))) + if ((track == (int)buffer[DATA_SIZE]) && (sector == (int)buffer[DATA_SIZE + 1])) return IMGTOOLERR_CORRUPTIMAGE; /* load next track and sector values */ - track = pick_integer_le(buffer, DATA_SIZE, 1); - sector = pick_integer_le(buffer, DATA_SIZE + 1, 1); + track = buffer[DATA_SIZE]; + sector = buffer[DATA_SIZE + 1]; /* track 0 is invalid */ if ((track == 0) && (filesize > DATA_SIZE)) @@ -595,8 +595,8 @@ static imgtoolerr_t vzdos_diskimage_deletefile(imgtool::partition &partition, co if (ret) return ret; /* load next track and sector values */ - next_track = pick_integer_le(buffer, DATA_SIZE, 1); - next_sector = pick_integer_le(buffer, DATA_SIZE + 1, 1); + next_track = buffer[DATA_SIZE]; + next_sector = buffer[DATA_SIZE + 1]; /* overwrite sector with default values */ ret = vzdos_clear_sector(img, track, sector); @@ -854,7 +854,7 @@ static imgtoolerr_t vzsnapshot_readfile(imgtool::partition &partition, const cha memset(header + 4, 0x00, 17); memcpy(header + 4, entry.fname, vzdos_get_fname_len(entry.fname) + 1); - place_integer_le(header, 22, 2, entry.start_address); + put_u16le(&header[22], entry.start_address); /* write header to file */ destf.write(header, sizeof(header)); @@ -879,7 +879,7 @@ static imgtoolerr_t vzsnapshot_writefile(imgtool::partition &partition, const ch /* prepare directory entry */ entry.ftype = header[21] == 0xF1 ? 'B' : 'T'; entry.delimitor = ':'; - entry.start_address = pick_integer_le(header, 22, 2); + entry.start_address = get_u16le(&header[22]); /* filename from header or directly? */ fnameopt = opts->lookup_int('F'); |