@@ -73,7 +73,7 @@ class impl : public filesystem_t {
73
73
74
74
private:
75
75
const impl & m_fs;
76
- fsblk_t ::block_t m_block;
76
+ fsblk_t ::block_t ::ptr m_block;
77
77
std::set<std::tuple<u8, u8>> m_visited_set;
78
78
u8 m_track;
79
79
u8 m_sector;
@@ -124,7 +124,7 @@ class impl : public filesystem_t {
124
124
static const u8 s_data_track_order[MAX_TRACKS - 1 ];
125
125
u8 m_max_track;
126
126
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 ;
128
128
std::optional<cbmdos_dirent> dirent_from_path (const std::vector<std::string> &path) const ;
129
129
void iterate_directory_entries (const std::function<bool (u8 track, u8 sector, u8 file_index, const cbmdos_dirent &dirent)> &callback) const ;
130
130
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)
305
305
meta_data impl::volume_metadata ()
306
306
{
307
307
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 );
309
309
310
310
meta_data results;
311
311
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
397
397
return err;
398
398
auto new_block = read_sector (DIRECTORY_TRACK, new_sector);
399
399
for (int i = 2 ; i < BLOCK_SIZE; i++)
400
- new_block. w8 (i, 0 );
400
+ new_block-> w8 (i, 0 );
401
401
// Find last directory sector
402
402
u8 last_sector = 0 ;
403
403
block_iterator iter (*this , DIRECTORY_TRACK, FIRST_DIRECTORY_SECTOR);
404
404
while (iter.next ())
405
405
last_sector = iter.sector ();
406
406
// Update chain on last directory sector
407
407
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);
410
410
track = DIRECTORY_TRACK;
411
411
sector = new_sector;
412
412
}
@@ -419,11 +419,11 @@ std::error_condition impl::file_create(const std::vector<std::string> &path, con
419
419
auto dirblk = read_sector (track, sector);
420
420
u32 offset = file_index * DIRECTORY_ENTRY_SIZE;
421
421
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);
427
427
// TODO set first side sector block track (rel file)
428
428
// TODO set first side sector block sector (rel file)
429
429
// TODO set rel file record length
@@ -470,18 +470,18 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
470
470
{
471
471
auto datablk = read_sector (data_track, data_sector);
472
472
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);
474
474
offset += SECTOR_DATA_BYTES;
475
475
sector_count++;
476
- if (datablk. r8 (OFFSET_CHAIN_TRACK) == CHAIN_END)
476
+ if (datablk-> r8 (OFFSET_CHAIN_TRACK) == CHAIN_END)
477
477
{
478
478
if (offset < data_length)
479
479
{
480
480
auto [err, next_track, next_sector] = claim_sector ();
481
481
if (err)
482
482
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);
485
485
data_track = next_track;
486
486
data_sector = next_sector;
487
487
}
@@ -490,30 +490,30 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
490
490
{
491
491
if (offset < data_length)
492
492
{
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);
495
495
}
496
496
else
497
497
{
498
498
// 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);
501
501
502
502
while (track_to_free != CHAIN_END)
503
503
{
504
504
std::error_condition const err = free_sector (track_to_free, sector_to_free);
505
505
if (err)
506
506
return err;
507
507
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);
510
510
}
511
511
}
512
512
}
513
513
if (offset >= data_length)
514
514
{
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 );
517
517
}
518
518
}
519
519
@@ -523,17 +523,17 @@ std::error_condition impl::file_write(const std::vector<std::string> &path, cons
523
523
if (file_type == FILE_TYPE_DEL)
524
524
{
525
525
// 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);
528
528
std::error_condition err = free_sector (file_track, file_sector);
529
529
if (err)
530
530
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 );
533
533
sector_count = 0 ;
534
534
}
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);
537
537
538
538
return std::error_condition ();
539
539
}
@@ -568,8 +568,8 @@ std::pair<std::error_condition, u8> impl::claim_track_sector(u8 track) const
568
568
return std::make_pair (error::invalid_block, 0 );
569
569
570
570
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 );
573
573
574
574
for (int s = 0 ; s < MAX_SECTORS; s++)
575
575
{
@@ -578,12 +578,12 @@ std::pair<std::error_condition, u8> impl::claim_track_sector(u8 track) const
578
578
{
579
579
free_bitmap &= ~(1 << sector);
580
580
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);
583
583
// Write chain end marker in new sector
584
584
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 );
587
587
return std::make_pair (std::error_condition (), sector);
588
588
}
589
589
}
@@ -611,12 +611,12 @@ std::error_condition impl::free_sector(u8 track, u8 sector) const
611
611
return error::invalid_block;
612
612
613
613
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 );
616
616
free_bitmap |= (1 << sector);
617
617
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);
620
620
return std::error_condition ();
621
621
}
622
622
@@ -625,7 +625,7 @@ std::error_condition impl::free_sector(u8 track, u8 sector) const
625
625
// impl::read_sector
626
626
// -------------------------------------------------
627
627
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
629
629
{
630
630
// CBM thinks in terms of tracks/sectors, but we have a block device abstraction
631
631
u32 block = 0 ;
@@ -776,8 +776,8 @@ bool impl::block_iterator::next()
776
776
777
777
// with that out of the way, proceed
778
778
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);
781
781
result = true ;
782
782
}
783
783
else
@@ -795,7 +795,7 @@ bool impl::block_iterator::next()
795
795
796
796
const void *impl::block_iterator::data () const
797
797
{
798
- return m_block. rodata () + 2 ;
798
+ return m_block-> rodata () + 2 ;
799
799
}
800
800
801
801
@@ -805,7 +805,7 @@ const void *impl::block_iterator::data() const
805
805
806
806
const std::array<impl::cbmdos_dirent, impl::SECTOR_DIRECTORY_COUNT> &impl::block_iterator::dirent_data () const
807
807
{
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 ());
809
809
}
810
810
811
811
0 commit comments