Skip to content

Commit 15c1b3d

Browse files
RobbbertRobbbert
committed
Merge remote-tracking branch 'upstream/master'
2 parents c38680b + a5aaa3e commit 15c1b3d

31 files changed

+1768
-980
lines changed

‎src/devices/imagedev/floppy.cpp

+4-1
Original file line numberDiff line numberDiff line change
@@ -610,7 +610,10 @@ std::pair<std::error_condition, const floppy_image_format_t *> floppy_image_devi
610610
}
611611
}
612612

613-
return{ std::error_condition(), best_format };
613+
if(best_format)
614+
return{ std::error_condition(), best_format };
615+
else
616+
return{ image_error::INVALIDIMAGE, nullptr };
614617
}
615618

616619
void floppy_image_device::init_floppy_load(bool write_supported)

‎src/lib/formats/fs_cbmdos.cpp

+44-44
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ class impl : public filesystem_t {
7373

7474
private:
7575
const impl & m_fs;
76-
fsblk_t::block_t m_block;
76+
fsblk_t::block_t::ptr m_block;
7777
std::set<std::tuple<u8, u8>> m_visited_set;
7878
u8 m_track;
7979
u8 m_sector;
@@ -124,7 +124,7 @@ class impl : public filesystem_t {
124124
static const u8 s_data_track_order[MAX_TRACKS - 1];
125125
u8 m_max_track;
126126

127-
fsblk_t::block_t read_sector(int track, int sector) const;
127+
fsblk_t::block_t::ptr read_sector(int track, int sector) const;
128128
std::optional<cbmdos_dirent> dirent_from_path(const std::vector<std::string> &path) const;
129129
void iterate_directory_entries(const std::function<bool(u8 track, u8 sector, u8 file_index, const cbmdos_dirent &dirent)> &callback) const;
130130
void iterate_all_directory_entries(const std::function<bool(u8 track, u8 sector, u8 file_index, const cbmdos_dirent &dirent)> &callback) const;
@@ -305,7 +305,7 @@ impl::impl(fsblk_t &blockdev)
305305
meta_data impl::volume_metadata()
306306
{
307307
auto bam_block = read_sector(DIRECTORY_TRACK, BAM_SECTOR);
308-
std::string_view disk_name = std::string_view((const char *) bam_block.rodata() + 0x90, 16);
308+
std::string_view disk_name = bam_block->rstr(0x90, 16);
309309

310310
meta_data results;
311311
results.set(meta_name::name, strtrimright_cbm(disk_name));
@@ -397,16 +397,16 @@ std::error_condition impl::file_create(const std::vector<std::string> &path, con
397397
return err;
398398
auto new_block = read_sector(DIRECTORY_TRACK, new_sector);
399399
for (int i = 2; i < BLOCK_SIZE; i++)
400-
new_block.w8(i, 0);
400+
new_block->w8(i, 0);
401401
// Find last directory sector
402402
u8 last_sector = 0;
403403
block_iterator iter(*this, DIRECTORY_TRACK, FIRST_DIRECTORY_SECTOR);
404404
while (iter.next())
405405
last_sector = iter.sector();
406406
// Update chain on last directory sector
407407
auto last_dir_block = read_sector(DIRECTORY_TRACK, last_sector);
408-
last_dir_block.w8(OFFSET_CHAIN_TRACK, DIRECTORY_TRACK);
409-
last_dir_block.w8(OFFSET_CHAIN_SECTOR, new_sector);
408+
last_dir_block->w8(OFFSET_CHAIN_TRACK, DIRECTORY_TRACK);
409+
last_dir_block->w8(OFFSET_CHAIN_SECTOR, new_sector);
410410
track = DIRECTORY_TRACK;
411411
sector = new_sector;
412412
}
@@ -419,11 +419,11 @@ std::error_condition impl::file_create(const std::vector<std::string> &path, con
419419
auto dirblk = read_sector(track, sector);
420420
u32 offset = file_index * DIRECTORY_ENTRY_SIZE;
421421
for (int i = 0; i < DIRECTORY_ENTRY_SIZE; i++)
422-
dirblk.w8(offset + i, (i >= 5 && i < 5 + 16) ? 0xa0 : 0x00);
423-
dirblk.w8(offset + OFFSET_FILE_TYPE, FILE_TYPE_PRG);
424-
dirblk.w8(offset + OFFSET_FILE_FIRST_TRACK, file_track);
425-
dirblk.w8(offset + OFFSET_FILE_FIRST_SECTOR, file_sector);
426-
dirblk.wstr(offset + OFFSET_FILE_NAME, filename);
422+
dirblk->w8(offset + i, (i >= 5 && i < 5 + 16) ? 0xa0 : 0x00);
423+
dirblk->w8(offset + OFFSET_FILE_TYPE, FILE_TYPE_PRG);
424+
dirblk->w8(offset + OFFSET_FILE_FIRST_TRACK, file_track);
425+
dirblk->w8(offset + OFFSET_FILE_FIRST_SECTOR, file_sector);
426+
dirblk->wstr(offset + OFFSET_FILE_NAME, filename);
427427
// TODO set first side sector block track (rel file)
428428
// TODO set first side sector block sector (rel file)
429429
// TODO set rel file record length
@@ -470,18 +470,18 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
470470
{
471471
auto datablk = read_sector(data_track, data_sector);
472472
u8 bytes = (data_length - offset) > SECTOR_DATA_BYTES ? SECTOR_DATA_BYTES : data_length - offset;
473-
memcpy(datablk.data() + 2, data.data() + offset, bytes);
473+
datablk->write(2, data.data() + offset, bytes);
474474
offset += SECTOR_DATA_BYTES;
475475
sector_count++;
476-
if (datablk.r8(OFFSET_CHAIN_TRACK) == CHAIN_END)
476+
if (datablk->r8(OFFSET_CHAIN_TRACK) == CHAIN_END)
477477
{
478478
if (offset < data_length)
479479
{
480480
auto [err, next_track, next_sector] = claim_sector();
481481
if (err)
482482
return err;
483-
datablk.w8(OFFSET_CHAIN_TRACK, next_track);
484-
datablk.w8(OFFSET_CHAIN_SECTOR, next_sector);
483+
datablk->w8(OFFSET_CHAIN_TRACK, next_track);
484+
datablk->w8(OFFSET_CHAIN_SECTOR, next_sector);
485485
data_track = next_track;
486486
data_sector = next_sector;
487487
}
@@ -490,30 +490,30 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
490490
{
491491
if (offset < data_length)
492492
{
493-
data_track = datablk.r8(OFFSET_CHAIN_TRACK);
494-
data_sector = datablk.r8(OFFSET_CHAIN_SECTOR);
493+
data_track = datablk->r8(OFFSET_CHAIN_TRACK);
494+
data_sector = datablk->r8(OFFSET_CHAIN_SECTOR);
495495
}
496496
else
497497
{
498498
// Free the rest of the chain
499-
u8 track_to_free = datablk.r8(OFFSET_CHAIN_TRACK);
500-
u8 sector_to_free = datablk.r8(OFFSET_CHAIN_SECTOR);
499+
u8 track_to_free = datablk->r8(OFFSET_CHAIN_TRACK);
500+
u8 sector_to_free = datablk->r8(OFFSET_CHAIN_SECTOR);
501501

502502
while (track_to_free != CHAIN_END)
503503
{
504504
std::error_condition const err = free_sector(track_to_free, sector_to_free);
505505
if (err)
506506
return err;
507507
datablk = read_sector(track_to_free, sector_to_free);
508-
track_to_free = datablk.r8(OFFSET_CHAIN_TRACK);
509-
sector_to_free = datablk.r8(OFFSET_CHAIN_SECTOR);
508+
track_to_free = datablk->r8(OFFSET_CHAIN_TRACK);
509+
sector_to_free = datablk->r8(OFFSET_CHAIN_SECTOR);
510510
}
511511
}
512512
}
513513
if (offset >= data_length)
514514
{
515-
datablk.w8(OFFSET_CHAIN_TRACK, CHAIN_END);
516-
datablk.w8(OFFSET_CHAIN_SECTOR, bytes + 1);
515+
datablk->w8(OFFSET_CHAIN_TRACK, CHAIN_END);
516+
datablk->w8(OFFSET_CHAIN_SECTOR, bytes + 1);
517517
}
518518
}
519519

@@ -523,17 +523,17 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
523523
if (file_type == FILE_TYPE_DEL)
524524
{
525525
// Free sector, update first file sector to 00
526-
u8 file_track = dirblk.r8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_TRACK);
527-
u8 file_sector = dirblk.r8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_SECTOR);
526+
u8 file_track = dirblk->r8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_TRACK);
527+
u8 file_sector = dirblk->r8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_SECTOR);
528528
std::error_condition err = free_sector(file_track, file_sector);
529529
if (err)
530530
return err;
531-
dirblk.w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_TRACK, 0);
532-
dirblk.w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_SECTOR, 0);
531+
dirblk->w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_TRACK, 0);
532+
dirblk->w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_FIRST_SECTOR, 0);
533533
sector_count = 0;
534534
}
535-
dirblk.w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_TYPE, file_type);
536-
dirblk.w16l(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_SECTOR_COUNT, sector_count);
535+
dirblk->w8(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_FILE_TYPE, file_type);
536+
dirblk->w16l(DIRECTORY_ENTRY_SIZE * dir_file_index + OFFSET_SECTOR_COUNT, sector_count);
537537

538538
return std::error_condition();
539539
}
@@ -568,8 +568,8 @@ std::pair<std::error_condition, u8> impl::claim_track_sector(u8 track) const
568568
return std::make_pair(error::invalid_block, 0);
569569

570570
auto bamblk = read_sector(DIRECTORY_TRACK, BAM_SECTOR);
571-
u8 free_count = bamblk.r8(4 * track);
572-
u32 free_bitmap = bamblk.r24l(4 * track + 1);
571+
u8 free_count = bamblk->r8(4 * track);
572+
u32 free_bitmap = bamblk->r24l(4 * track + 1);
573573

574574
for (int s = 0; s < MAX_SECTORS; s++)
575575
{
@@ -578,12 +578,12 @@ std::pair<std::error_condition, u8> impl::claim_track_sector(u8 track) const
578578
{
579579
free_bitmap &= ~(1 << sector);
580580
free_count--;
581-
bamblk.w8(4 * track, free_count);
582-
bamblk.w24l(4 * track + 1, free_bitmap);
581+
bamblk->w8(4 * track, free_count);
582+
bamblk->w24l(4 * track + 1, free_bitmap);
583583
// Write chain end marker in new sector
584584
auto claimedlk = read_sector(track, sector);
585-
claimedlk.w8(OFFSET_CHAIN_TRACK, CHAIN_END);
586-
claimedlk.w8(OFFSET_CHAIN_SECTOR, 0xff);
585+
claimedlk->w8(OFFSET_CHAIN_TRACK, CHAIN_END);
586+
claimedlk->w8(OFFSET_CHAIN_SECTOR, 0xff);
587587
return std::make_pair(std::error_condition(), sector);
588588
}
589589
}
@@ -611,12 +611,12 @@ std::error_condition impl::free_sector(u8 track, u8 sector) const
611611
return error::invalid_block;
612612

613613
auto bamblk = read_sector(DIRECTORY_TRACK, BAM_SECTOR);
614-
u8 free_count = bamblk.r8(4 * track);
615-
u32 free_bitmap = bamblk.r24l(4 * track + 1);
614+
u8 free_count = bamblk->r8(4 * track);
615+
u32 free_bitmap = bamblk->r24l(4 * track + 1);
616616
free_bitmap |= (1 << sector);
617617
free_count++;
618-
bamblk.w8(4 * track, free_count);
619-
bamblk.w24l(4 * track + 1, free_bitmap);
618+
bamblk->w8(4 * track, free_count);
619+
bamblk->w24l(4 * track + 1, free_bitmap);
620620
return std::error_condition();
621621
}
622622

@@ -625,7 +625,7 @@ std::error_condition impl::free_sector(u8 track, u8 sector) const
625625
// impl::read_sector
626626
//-------------------------------------------------
627627

628-
fsblk_t::block_t impl::read_sector(int track, int sector) const
628+
fsblk_t::block_t::ptr impl::read_sector(int track, int sector) const
629629
{
630630
// CBM thinks in terms of tracks/sectors, but we have a block device abstraction
631631
u32 block = 0;
@@ -776,8 +776,8 @@ bool impl::block_iterator::next()
776776

777777
// with that out of the way, proceed
778778
m_block = m_fs.read_sector(m_next_track, m_next_sector);
779-
m_next_track = m_block.r8(OFFSET_CHAIN_TRACK);
780-
m_next_sector = m_block.r8(OFFSET_CHAIN_SECTOR);
779+
m_next_track = m_block->r8(OFFSET_CHAIN_TRACK);
780+
m_next_sector = m_block->r8(OFFSET_CHAIN_SECTOR);
781781
result = true;
782782
}
783783
else
@@ -795,7 +795,7 @@ bool impl::block_iterator::next()
795795

796796
const void *impl::block_iterator::data() const
797797
{
798-
return m_block.rodata() + 2;
798+
return m_block->rodata() + 2;
799799
}
800800

801801

@@ -805,7 +805,7 @@ const void *impl::block_iterator::data() const
805805

806806
const std::array<impl::cbmdos_dirent, impl::SECTOR_DIRECTORY_COUNT> &impl::block_iterator::dirent_data() const
807807
{
808-
return *reinterpret_cast<const std::array<impl::cbmdos_dirent, SECTOR_DIRECTORY_COUNT> *>(m_block.rodata());
808+
return *reinterpret_cast<const std::array<impl::cbmdos_dirent, SECTOR_DIRECTORY_COUNT> *>(m_block->rodata());
809809
}
810810

811811

0 commit comments

Comments
 (0)