Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-29 15:38:53 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

imageutl.h: Retire pick_integer_[bl]e and place_integer_[bl]e in favor of the simpler functions in multibyte.h

Browse Source 
* multibyte.h: Add constexpr for getters and noexcept for all functions
This commit is contained in:
AJR 2023-09-17 09:41:35 -04:00
parent 2f7b1f05c7
commit 676e44ca95
30 changed files with 417 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/lib/formats/apridisk.cpp
View File

@ -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(&sector_header, 0, 4);
uint16_t compression = pick_integer_le(&sector_header, 4, 2);
uint16_t header_size = pick_integer_le(&sector_header, 6, 2);
uint32_t data_size = pick_integer_le(&sector_header, 8, 4);
uint32_t type = get_u32le(&sector_header[0]);
uint16_t compression = get_u16le(&sector_header[4]);
uint16_t header_size = get_u16le(&sector_header[6]);
uint32_t data_size = get_u32le(&sector_header[8]);
file_offset += header_size;
switch (type)
{
case APR_SECTOR:
uint8_t head = pick_integer_le(&sector_header, 12, 1);
uint8_t sector = pick_integer_le(&sector_header, 13, 1);
uint8_t track = (uint8_t) pick_integer_le(&sector_header, 14, 2);
uint8_t head = sector_header[12];
uint8_t sector = sector_header[13];
uint8_t track = (uint8_t) get_u16le(&sector_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)
{

15
src/lib/formats/cbm_crt.cpp
View File

@ -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)

6
src/lib/formats/cbm_crt.h
View File

@ -12,10 +12,12 @@
#pragma once
#include "formats/imageutl.h"
#include "utilfwd.h"
#include <cstddef>
#include <cstdint>
#include <string>
//**************************************************************************
// MACROS/CONSTANTS

5
src/lib/formats/dsk_dsk.cpp
View File

@ -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 {

3
src/lib/formats/dvk_mx_dsk.cpp
View File

@ -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(&sectdata[0724]) == 6)
return FIFID_SIGN|FIFID_SIZE;
else
return FIFID_SIZE;

1
src/lib/formats/dvk_mx_dsk.h
View File

@ -11,7 +11,6 @@
#pragma once
#include "flopimg.h"
#include "imageutl.h"
class dvk_mx_format : public floppy_image_format_t
{

4
src/lib/formats/fdi_dsk.cpp
View File

@ -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)

14
src/lib/formats/g64_dsk.cpp
View File

@ -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);

1
src/lib/formats/g64_dsk.h
View File

@ -13,7 +13,6 @@
#pragma once
#include "flopimg.h"
#include "imageutl.h"
class g64_format : public floppy_image_format_t
{

21
src/lib/formats/hti_tape.cpp
View File

@ -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;
}

140
src/lib/formats/imageutl.h
View File

@ -24,146 +24,6 @@
unsigned short ccitt_crc16(unsigned short crc, const unsigned char *buffer, size_t buffer_len);
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
* ----------------------------------------------------------------------- */

11
src/lib/formats/os9_dsk.cpp
View File

@ -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);

19
src/lib/formats/uniflex_dsk.cpp
View File

@ -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++) {

64
src/lib/util/multibyte.h
View File

@ -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);
}

9
src/mame/acorn/atom.cpp
View File

@ -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)
{

11
src/mame/comx/comx35.cpp
View File

@ -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);

8
src/mame/memotech/mtx_m.cpp
View File

@ -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");

10
src/mame/sega/mdconsole.cpp
View File

@ -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());
}

4
src/mame/vtech/vtech1.cpp
View File

@ -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;

27
src/tools/imgtool/filtbas.cpp
View File

@ -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);

216
src/tools/imgtool/modules/amiga.cpp
View File

@ -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);

81
src/tools/imgtool/modules/fat.cpp
View File

@ -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)

17
src/tools/imgtool/modules/hp85_tape.cpp
View File

@ -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) {

18
src/tools/imgtool/modules/hp9845_tape.cpp
View File

@ -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) {

122
src/tools/imgtool/modules/os9.cpp
View File

@ -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)

18
src/tools/imgtool/modules/pc_flop.cpp
View File

@ -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;
}

26
src/tools/imgtool/modules/pc_hard.cpp
View File

@ -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;

27
src/tools/imgtool/modules/rt11.cpp
View File

@ -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;
}

12
src/tools/imgtool/modules/thomson.cpp
View File

@ -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);

36
src/tools/imgtool/modules/vzdos.cpp
View File

@ -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');