Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-25 01:40:16 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1456 from npwoods/imgtool_image_cplusplus

Browse Source 
Made imgtool_image (now imgtool::image) a "real" C++ class
This commit is contained in:
R. Belmont 2016-10-08 14:45:10 -04:00 committed by GitHub
commit 6595eae179
28 changed files with 834 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/tools/imgtool/iflopimg.cpp
View File

@ -102,19 +102,19 @@ struct imgtool_floppy_image
static imgtoolerr_t imgtool_floppy_open_internal(imgtool_image *image, imgtool_stream *f, int noclose)
static imgtoolerr_t imgtool_floppy_open_internal(imgtool::image *image, imgtool_stream *f, int noclose)
{
floperr_t ferr;
imgtoolerr_t err;
struct imgtool_floppy_image *fimg;
const imgtool_class *imgclass;
const struct FloppyFormat *format;
imgtoolerr_t (*open)(imgtool_image *image, imgtool_stream *f);
imgtoolerr_t (*open)(imgtool::image *image, imgtool_stream *f);
fimg = (struct imgtool_floppy_image *) imgtool_image_extra_bytes(image);
imgclass = &imgtool_image_module(image)->imgclass;
fimg = (struct imgtool_floppy_image *) image->extra_bytes();
imgclass = &image->module().imgclass;
format = (const struct FloppyFormat *) imgclass->derived_param;
open = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_OPEN);
open = (imgtoolerr_t (*)(imgtool::image *, imgtool_stream *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_OPEN);
/* open up the floppy */
ferr = floppy_open(f, noclose ? &imgtool_noclose_ioprocs : &imgtool_ioprocs,
@ -137,28 +137,28 @@ static imgtoolerr_t imgtool_floppy_open_internal(imgtool_image *image, imgtool_s
static imgtoolerr_t imgtool_floppy_open(imgtool_image *image, imgtool_stream *f)
static imgtoolerr_t imgtool_floppy_open(imgtool::image *image, imgtool_stream *f)
{
return imgtool_floppy_open_internal(image, f, FALSE);
}
static imgtoolerr_t imgtool_floppy_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *opts)
static imgtoolerr_t imgtool_floppy_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *opts)
{
floperr_t ferr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
struct imgtool_floppy_image *fimg;
const imgtool_class *imgclass;
const struct FloppyFormat *format;
imgtoolerr_t (*create)(imgtool_image *, imgtool_stream *, util::option_resolution *);
imgtoolerr_t (*open)(imgtool_image *image, imgtool_stream *f);
imgtoolerr_t (*create)(imgtool::image *, imgtool_stream *, util::option_resolution *);
imgtoolerr_t (*open)(imgtool::image *image, imgtool_stream *f);
fimg = (struct imgtool_floppy_image *) imgtool_image_extra_bytes(image);
imgclass = &imgtool_image_module(image)->imgclass;
fimg = (struct imgtool_floppy_image *) image->extra_bytes();
imgclass = &image->module().imgclass;
format = (const struct FloppyFormat *) imgclass->derived_param;
create = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *, util::option_resolution *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_CREATE);
open = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_OPEN);
create = (imgtoolerr_t (*)(imgtool::image *, imgtool_stream *, util::option_resolution *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_CREATE);
open = (imgtoolerr_t (*)(imgtool::image *, imgtool_stream *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_OPEN);
/* open up the floppy */
ferr = floppy_create(f, &imgtool_ioprocs, format, opts, &fimg->floppy);
@ -190,14 +190,14 @@ done:
static void imgtool_floppy_close(imgtool_image *img)
static void imgtool_floppy_close(imgtool::image *img)
{
floppy_close(imgtool_floppy(img));
}
static imgtoolerr_t imgtool_floppy_read_sector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
static imgtoolerr_t imgtool_floppy_read_sector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
{
floperr_t ferr;
UINT32 sector_size;
@ -221,7 +221,7 @@ static imgtoolerr_t imgtool_floppy_read_sector(imgtool_image *image, UINT32 trac
static imgtoolerr_t imgtool_floppy_write_sector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam)
static imgtoolerr_t imgtool_floppy_write_sector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam)
{
floperr_t ferr;
@ -296,16 +296,16 @@ int imgtool_floppy_make_class(int index, imgtool_class *imgclass)
floppy_image_legacy *imgtool_floppy(imgtool_image *img)
floppy_image_legacy *imgtool_floppy(imgtool::image *img)
{
struct imgtool_floppy_image *fimg;
fimg = (struct imgtool_floppy_image *) imgtool_image_extra_bytes(img);
fimg = (struct imgtool_floppy_image *) img->extra_bytes();
return fimg->floppy;
}
static imgtoolerr_t imgtool_floppy_transfer_sector_tofrom_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f, int direction)
static imgtoolerr_t imgtool_floppy_transfer_sector_tofrom_stream(imgtool::image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f, int direction)
{
floperr_t err;
floppy_image_legacy *floppy;
@ -338,23 +338,23 @@ done:
imgtoolerr_t imgtool_floppy_read_sector_to_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f)
imgtoolerr_t imgtool_floppy_read_sector_to_stream(imgtool::image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f)
{
return imgtool_floppy_transfer_sector_tofrom_stream(img, head, track, sector, offset, length, f, 1);
}
imgtoolerr_t imgtool_floppy_write_sector_from_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f)
imgtoolerr_t imgtool_floppy_write_sector_from_stream(imgtool::image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f)
{
return imgtool_floppy_transfer_sector_tofrom_stream(img, head, track, sector, offset, length, f, 0);
}
void *imgtool_floppy_extrabytes(imgtool_image *img)
void *imgtool_floppy_extrabytes(imgtool::image *img)
{
struct imgtool_floppy_image *fimg;
fimg = (struct imgtool_floppy_image *) imgtool_image_extra_bytes(img);
fimg = (struct imgtool_floppy_image *) img->extra_bytes();
return fimg + 1;
}

8
src/tools/imgtool/iflopimg.h
View File

@ -29,13 +29,13 @@ enum
int imgtool_floppy_make_class(int index, imgtool_class *imgclass);
floppy_image_legacy *imgtool_floppy(imgtool_image *img);
floppy_image_legacy *imgtool_floppy(imgtool::image *img);
imgtoolerr_t imgtool_floppy_error(floperr_t err);
imgtoolerr_t imgtool_floppy_read_sector_to_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f);
imgtoolerr_t imgtool_floppy_write_sector_from_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f);
imgtoolerr_t imgtool_floppy_read_sector_to_stream(imgtool::image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f);
imgtoolerr_t imgtool_floppy_write_sector_from_stream(imgtool::image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f);
void *imgtool_floppy_extrabytes(imgtool_image *img);
void *imgtool_floppy_extrabytes(imgtool::image *img);
#endif /* IFLOPIMG_H */

4
src/tools/imgtool/imghd.cpp
View File

@ -215,7 +215,7 @@ const hard_disk_info *imghd_get_header(struct mess_hard_disk_file *disk)
}
static imgtoolerr_t mess_hd_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions);
static imgtoolerr_t mess_hd_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions);
enum
{
@ -254,7 +254,7 @@ void hd_get_info(const imgtool_class *imgclass, UINT32 state, union imgtoolinfo
static imgtoolerr_t mess_hd_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions)
static imgtoolerr_t mess_hd_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions)
{
UINT32 blocksize, cylinders, heads, sectors, seclen;

510
src/tools/imgtool/imgtool.cpp
View File

@ -22,15 +22,9 @@
TYPE DEFINITIONS
***************************************************************************/
struct imgtool_image
{
const imgtool_module *module;
object_pool *pool;
};
struct imgtool_partition
{
imgtool_image *image;
imgtool::image *image;
object_pool *pool;
int partition_index;
UINT64 base_block;
@ -138,9 +132,9 @@ char *strncatz(char *dest, const char *source, size_t len)
return strncpyz(dest, source, len);
}
/*-------------------------------------------------
markerrorsource - marks where an error source
-------------------------------------------------*/
//-------------------------------------------------
// markerrorsource - marks where an error source
//-------------------------------------------------
static imgtoolerr_t markerrorsource(imgtoolerr_t err)
{
@ -164,10 +158,10 @@ static imgtoolerr_t markerrorsource(imgtoolerr_t err)
return err;
}
/*-------------------------------------------------
internal_error - debug function for raising
internal errors
-------------------------------------------------*/
//-------------------------------------------------
// internal_error - debug function for raising
// internal errors
//-------------------------------------------------
static void internal_error(const imgtool_module *module, const char *message)
{
@ -177,10 +171,10 @@ static void internal_error(const imgtool_module *module, const char *message)
}
/*-------------------------------------------------
normalize_filename - convert a filename to the
native format used by the module
-------------------------------------------------*/
//-------------------------------------------------
// normalize_filename - convert a filename to the
// native format used by the module
//-------------------------------------------------
static char *normalize_filename(imgtool_partition *partition, const char *src)
{
@ -195,9 +189,9 @@ static char *normalize_filename(imgtool_partition *partition, const char *src)
/*-------------------------------------------------
imgtool_init - initializes the imgtool core
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_init - initializes the imgtool core
//-------------------------------------------------
void imgtool_init(bool omit_untested, void (*warn)(const char *message))
{
@ -214,9 +208,9 @@ void imgtool_init(bool omit_untested, void (*warn)(const char *message))
/*-------------------------------------------------
imgtool_exit - closes out the imgtool core
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_exit - closes out the imgtool core
//-------------------------------------------------
void imgtool_exit(void)
{
@ -228,19 +222,19 @@ void imgtool_exit(void)
/*-------------------------------------------------
imgtool_find_module - looks up a module
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_find_module - looks up a module
//-------------------------------------------------
const imgtool_module *imgtool_find_module(const char *modulename)
const imgtool_module *imgtool_find_module(const std::string &modulename)
{
return global_imgtool_library->findmodule(modulename);
}
/*-------------------------------------------------
imgtool_find_module - looks up a module
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_find_module - looks up a module
//-------------------------------------------------
const imgtool::library::modulelist &imgtool_get_modules()
{
@ -248,11 +242,11 @@ const imgtool::library::modulelist &imgtool_get_modules()
}
/*-------------------------------------------------
imgtool_get_module_features - retrieves a
structure identifying this module's features
associated with an image
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_get_module_features - retrieves a
// structure identifying this module's features
// associated with an image
//-------------------------------------------------
imgtool_module_features imgtool_get_module_features(const imgtool_module *module)
{
@ -272,9 +266,9 @@ imgtool_module_features imgtool_get_module_features(const imgtool_module *module
/*-------------------------------------------------
imgtool_warn - issues a warning
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_warn - issues a warning
//-------------------------------------------------
void imgtool_warn(const char *format, ...)
{
@ -292,16 +286,16 @@ void imgtool_warn(const char *format, ...)
/*-------------------------------------------------
evaluate_module - evaluates a single file to
determine what module can best handle a file
-------------------------------------------------*/
//-------------------------------------------------
// evaluate_module - evaluates a single file to
// determine what module can best handle a file
//-------------------------------------------------
static imgtoolerr_t evaluate_module(const char *fname,
const imgtool_module *module, float *result)
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
imgtool::image::ptr image;
imgtool_partition *partition = nullptr;
imgtool_directory *imageenum = nullptr;
imgtool_dirent ent;
@ -309,7 +303,7 @@ static imgtoolerr_t evaluate_module(const char *fname,
*result = 0.0;
err = imgtool_image_open(module, fname, OSD_FOPEN_READ, &image);
err = imgtool::image::open(module, fname, OSD_FOPEN_READ, image);
if (err)
goto done;
@ -317,7 +311,7 @@ static imgtoolerr_t evaluate_module(const char *fname,
{
current_result = module->open_is_strict ? 0.9 : 0.5;
err = imgtool_partition_open(image, 0, &partition);
err = imgtool_partition_open(image.get(), 0, &partition);
if (err)
goto done;
@ -349,31 +343,29 @@ done:
imgtool_directory_close(imageenum);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
return err;
}
/*-------------------------------------------------
imgtool_partition_image - retrieves the image
associated with this partition
-------------------------------------------------*/
//-------------------------------------------------
// imgtool_partition_image - retrieves the image
// associated with this partition
//-------------------------------------------------
imgtool_image *imgtool_partition_image(imgtool_partition *partition)
imgtool::image *imgtool_partition_image(imgtool_partition *partition)
{
return partition->image;
}
/*-------------------------------------------------
imgtool_identify_file - attempts to determine the module
for any given image
-------------------------------------------------*/
//-------------------------------------------------
// identify_file - attempts to determine the module
// for any given image
//-------------------------------------------------
imgtoolerr_t imgtool_identify_file(const char *fname, imgtool_module **modules, size_t count)
imgtoolerr_t imgtool::image::identify_file(const char *fname, imgtool_module **modules, size_t count)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
imgtool::library &library = *global_imgtool_library.get();
@ -381,25 +373,19 @@ imgtoolerr_t imgtool_identify_file(const char *fname, imgtool_module **modules,
imgtool_module *temp_module;
size_t i = 0;
const char *extension;
float val, temp_val, *values = nullptr;
float val, temp_val;
std::unique_ptr<float[]> values;
if (count <= 0)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
return IMGTOOLERR_UNEXPECTED;
for (i = 0; i < count; i++)
modules[i] = nullptr;
if (count > 1)
count--; /* null terminate */
values = (float *) malloc(count * sizeof(*values));
if (!values)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto done;
}
try { values = std::make_unique<float[]>(count); }
catch (std::bad_alloc const &) { return IMGTOOLERR_OUTOFMEMORY; }
for (i = 0; i < count; i++)
values[i] = 0.0;
@ -415,7 +401,7 @@ imgtoolerr_t imgtool_identify_file(const char *fname, imgtool_module **modules,
{
err = evaluate_module(fname, module.get(), &val);
if (err)
goto done;
return err;
insert_module = module.get();
for (i = 0; (val > 0.0f) && (i < count); i++)
@ -434,24 +420,21 @@ imgtoolerr_t imgtool_identify_file(const char *fname, imgtool_module **modules,
}
if (!modules[0])
err = (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_IMAGEFILE);
return (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_IMAGEFILE);
done:
if (values)
free(values);
return err;
return IMGTOOLERR_SUCCESS;
}
/*-------------------------------------------------
imgtool_image_get_geometry - gets the geometry
of an image; note that this may disagree with
particular sectors; this is a common copy
protection scheme
-------------------------------------------------*/
//-------------------------------------------------
// get_geometry - gets the geometry
// of an image; note that this may disagree with
// particular sectors; this is a common copy
// protection scheme
//-------------------------------------------------
imgtoolerr_t imgtool_image_get_geometry(imgtool_image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
imgtoolerr_t imgtool::image::get_geometry(UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
{
UINT32 dummy;
@ -467,107 +450,101 @@ imgtoolerr_t imgtool_image_get_geometry(imgtool_image *image, UINT32 *tracks, UI
*sectors = 0;
/* implemented? */
if (!image->module->get_geometry)
if (!module().get_geometry)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
return image->module->get_geometry(image, tracks, heads, sectors);
return module().get_geometry(this, tracks, heads, sectors);
}
/*-------------------------------------------------
imgtool_image_read_sector - reads a sector on an image
-------------------------------------------------*/
//-------------------------------------------------
// read_sector - reads a sector on an image
//-------------------------------------------------
imgtoolerr_t imgtool_image_read_sector(imgtool_image *image, UINT32 track, UINT32 head,
imgtoolerr_t imgtool::image::read_sector(UINT32 track, UINT32 head,
UINT32 sector, std::vector<UINT8> &buffer)
{
/* implemented? */
if (!image->module->read_sector)
// implemented?
if (!module().read_sector)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
return image->module->read_sector(image, track, head, sector, buffer);
return module().read_sector(this, track, head, sector, buffer);
}
/*-------------------------------------------------
imgtool_image_write_sector - writes a sector on an image
-------------------------------------------------*/
//-------------------------------------------------
// write_sector - writes a sector on an image
//-------------------------------------------------
imgtoolerr_t imgtool_image_write_sector(imgtool_image *image, UINT32 track, UINT32 head,
imgtoolerr_t imgtool::image::write_sector(UINT32 track, UINT32 head,
UINT32 sector, const void *buffer, size_t len)
{
/* implemented? */
if (!image->module->write_sector)
// implemented?
if (!module().write_sector)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
return image->module->write_sector(image, track, head, sector, buffer, len);
return module().write_sector(this, track, head, sector, buffer, len);
}
/*-------------------------------------------------
imgtool_image_get_block_size - gets the size of
a standard block on an image
-------------------------------------------------*/
//-------------------------------------------------
// get_block_size - gets the size of a standard
// block on an image
//-------------------------------------------------
imgtoolerr_t imgtool_image_get_block_size(imgtool_image *image, UINT32 *length)
imgtoolerr_t imgtool::image::get_block_size(UINT32 &length)
{
/* implemented? */
if (image->module->block_size == 0)
// implemented?
if (module().block_size == 0)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
*length = image->module->block_size;
length = module().block_size;
return IMGTOOLERR_SUCCESS;
}
//-------------------------------------------------
// read_block - reads a standard block on an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_read_block - reads a standard
block on an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_read_block(imgtool_image *image, UINT64 block, void *buffer)
imgtoolerr_t imgtool::image::read_block(UINT64 block, void *buffer)
{
/* implemented? */
if (!image->module->read_block)
// implemented?
if (!module().read_block)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
return image->module->read_block(image, buffer, block);
return module().read_block(this, buffer, block);
}
//-------------------------------------------------
// write_block - writes a standard block on an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_write_block - writes a standard
block on an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_write_block(imgtool_image *image, UINT64 block, const void *buffer)
imgtoolerr_t imgtool::image::write_block(UINT64 block, const void *buffer)
{
/* implemented? */
if (!image->module->write_block)
// implemented?
if (!module().write_block)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
return image->module->write_block(image, buffer, block);
return module().write_block(this, buffer, block);
}
//-------------------------------------------------
// clear_block - clears a standard block on an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_clear_block - clears a standard
block on an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_clear_block(imgtool_image *image, UINT64 block, UINT8 data)
imgtoolerr_t imgtool::image::clear_block(UINT64 block, UINT8 data)
{
imgtoolerr_t err;
UINT8 *block_data = nullptr;
UINT32 length;
err = imgtool_image_get_block_size(image, &length);
err = get_block_size(length);
if (err)
goto done;
@ -579,7 +556,7 @@ imgtoolerr_t imgtool_image_clear_block(imgtool_image *image, UINT64 block, UINT8
}
memset(block_data, data, length);
err = imgtool_image_write_block(image, block, block_data);
err = write_block(block, block_data);
if (err)
goto done;
@ -590,75 +567,43 @@ done:
}
//-------------------------------------------------
// list_partitions - lists the partitions on an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_list_partitions - lists the
partitions on an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_list_partitions(imgtool_image *image, imgtool_partition_info *partitions, size_t len)
imgtoolerr_t imgtool::image::list_partitions(imgtool_partition_info *partitions, size_t len)
{
/* implemented? */
if (!image->module->list_partitions)
if (!module().list_partitions)
return (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
memset(partitions, '\0', sizeof(*partitions) * len);
return image->module->list_partitions(image, partitions, len);
return module().list_partitions(this, partitions, len);
}
//-------------------------------------------------
// malloc - allocates memory associated with an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_malloc - allocates memory associated with an
image
-------------------------------------------------*/
void *imgtool_image_malloc(imgtool_image *image, size_t size)
void *imgtool::image::malloc(size_t size)
{
return pool_malloc_lib(image->pool, size);
return pool_malloc_lib(m_pool, size);
}
//-------------------------------------------------
// imgtool::image::rand - returns a random number
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_module - returns the module associated with
this image
-------------------------------------------------*/
const imgtool_module *imgtool_image_module(imgtool_image *img)
UINT64 imgtool::image::rand()
{
return img->module;
}
/*-------------------------------------------------
imgtool_image_extra_bytes - returns extra bytes on an image
-------------------------------------------------*/
void *imgtool_image_extra_bytes(imgtool_image *image)
{
void *ptr = nullptr;
if (image->module->image_extra_bytes > 0)
ptr = ((UINT8 *) image) + sizeof(*image);
assert(ptr);
return ptr;
}
/*-------------------------------------------------
imgtool_image_rand - returns a random number
-------------------------------------------------*/
UINT64 imgtool_image_rand(imgtool_image *image)
{
/* we can't use mame_rand() here */
// we can't use mame_rand() here
#ifdef rand
#undef rand
#endif
return ((UINT64) rand()) << 32
| ((UINT64) rand()) << 0;
return ((UINT64) std::rand()) << 32
| ((UINT64)std::rand()) << 0;
}
@ -676,7 +621,7 @@ static char *pool_strdup_allow_null(object_pool *pool, char *s)
imgtoolerr_t imgtool_partition_open(imgtool_image *image, int partition_index, imgtool_partition **partition)
imgtoolerr_t imgtool_partition_open(imgtool::image *image, int partition_index, imgtool_partition **partition)
{
imgtoolerr_t err = (imgtoolerr_t)IMGTOOLERR_SUCCESS;
imgtool_partition *p = nullptr;
@ -687,7 +632,7 @@ imgtoolerr_t imgtool_partition_open(imgtool_image *image, int partition_index, i
object_pool *pool;
imgtoolerr_t (*open_partition)(imgtool_partition *partition, UINT64 first_block, UINT64 block_count);
if (image->module->list_partitions)
if (image->module().list_partitions)
{
/* this image supports partitions */
if ((partition_index < 0) || (partition_index >= ARRAY_LENGTH(partition_info)))
@ -695,7 +640,7 @@ imgtoolerr_t imgtool_partition_open(imgtool_image *image, int partition_index, i
/* retrieve the info on the partitions */
memset(partition_info, '\0', sizeof(partition_info));
err = image->module->list_partitions(image, partition_info, ARRAY_LENGTH(partition_info));
err = image->module().list_partitions(image, partition_info, ARRAY_LENGTH(partition_info));
if (err)
return err;
@ -716,7 +661,7 @@ imgtoolerr_t imgtool_partition_open(imgtool_image *image, int partition_index, i
return IMGTOOLERR_INVALIDPARTITION;
/* identify the image class */
imgclass = imgtool_image_module(image)->imgclass;
imgclass = image->module().imgclass;
base_block = 0;
block_count = ~0;
}
@ -1012,26 +957,25 @@ char *imgtool_temp_str(void)
***************************************************************************/
static imgtoolerr_t internal_open(const imgtool_module *module, const char *fname,
int read_or_write, util::option_resolution *createopts, imgtool_image **outimg)
imgtoolerr_t imgtool::image::internal_open(const imgtool_module *module, const char *fname,
int read_or_write, util::option_resolution *createopts, imgtool::image::ptr &outimg)
{
imgtoolerr_t err;
imgtool_stream *f = nullptr;
imgtool_image *image = nullptr;
imgtool::image::ptr image;
object_pool *pool = nullptr;
size_t size;
void *extra_bytes = nullptr;
if (outimg)
*outimg = nullptr;
outimg.reset();
/* is the requested functionality implemented? */
// is the requested functionality implemented?
if ((read_or_write == OSD_FOPEN_RW_CREATE) ? !module->create : !module->open)
{
err = (imgtoolerr_t)(IMGTOOLERR_UNIMPLEMENTED | IMGTOOLERR_SRC_FUNCTIONALITY);
goto done;
}
/* create a memory pool */
// create a memory pool
pool = pool_alloc_lib(nullptr);
if (!pool)
{
@ -1039,7 +983,7 @@ static imgtoolerr_t internal_open(const imgtool_module *module, const char *fnam
goto done;
}
/* open the stream */
// open the stream
f = stream_open(fname, read_or_write);
if (!f)
{
@ -1047,65 +991,68 @@ static imgtoolerr_t internal_open(const imgtool_module *module, const char *fnam
goto done;
}
/* setup the image structure */
size = sizeof(imgtool_image) + module->image_extra_bytes;
image = (imgtool_image *) pool_malloc_lib(pool, size);
if (!image)
// allocate extra
if (module->image_extra_bytes > 0)
{
err = (imgtoolerr_t)IMGTOOLERR_OUTOFMEMORY;
extra_bytes = pool_malloc_lib(pool, module->image_extra_bytes);
if (!extra_bytes)
{
err = (imgtoolerr_t)(IMGTOOLERR_OUTOFMEMORY);
goto done;
}
memset(extra_bytes, 0, module->image_extra_bytes);
}
// setup the image structure
try { image = std::make_unique<imgtool::image>(*module, pool, extra_bytes); }
catch (std::bad_alloc const &)
{
err = (imgtoolerr_t)(IMGTOOLERR_OUTOFMEMORY);
goto done;
}
memset(image, '\0', size);
image->pool = pool;
image->module = module;
/* actually call create or open */
if (read_or_write == OSD_FOPEN_RW_CREATE)
err = module->create(image, f, createopts);
else
err = module->open(image, f);
// the pool is no longer owned by this function
pool = nullptr;
// actually call create or open
err = (read_or_write == OSD_FOPEN_RW_CREATE)
? module->create(image.get(), f, createopts)
: module->open(image.get(), f);
if (err)
{
err = markerrorsource(err);
goto done;
}
done:
if (err)
{
if (f)
stream_close(f);
if (pool)
pool_free_lib(pool);
image = nullptr;
}
// we've succeeded - set the output image
outimg = std::move(image);
if (outimg)
*outimg = image;
else if (image)
imgtool_image_close(image);
done:
if (err && f)
stream_close(f);
if (pool)
pool_free_lib(pool);
return err;
}
//-------------------------------------------------
// open - open an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_open - open an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_open(const imgtool_module *module, const char *fname, int read_or_write, imgtool_image **outimg)
imgtoolerr_t imgtool::image::open(const imgtool_module *module, const char *filename, int read_or_write, ptr &outimg)
{
read_or_write = read_or_write ? OSD_FOPEN_RW : OSD_FOPEN_READ;
return internal_open(module, fname, read_or_write, nullptr, outimg);
return internal_open(module, filename, read_or_write, nullptr, outimg);
}
//-------------------------------------------------
// imgtool::image::open_byname - open an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_open_byname - open an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_open_byname(const char *modulename, const char *fname, int read_or_write, imgtool_image **outimg)
imgtoolerr_t imgtool::image::open(const std::string &modulename, const char *filename, int read_or_write, ptr &outimg)
{
const imgtool_module *module;
@ -1113,30 +1060,40 @@ imgtoolerr_t imgtool_image_open_byname(const char *modulename, const char *fname
if (!module)
return (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_MODULE);
return imgtool_image_open(module, fname, read_or_write, outimg);
return open(module, filename, read_or_write, outimg);
}
//-------------------------------------------------
// imgtool::image::image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_close - close an image
-------------------------------------------------*/
void imgtool_image_close(imgtool_image *image)
imgtool::image::image(const imgtool_module &module, object_pool *pool, void *extra_bytes)
: m_module(module)
, m_pool(pool)
, m_extra_bytes(extra_bytes)
{
if (image->module->close)
image->module->close(image);
pool_free_lib(image->pool);
}
//-------------------------------------------------
// imgtool::image::~image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_create - creates an image
-------------------------------------------------*/
imgtool::image::~image()
{
if (module().close)
module().close(this);
pool_free_lib(m_pool);
}
imgtoolerr_t imgtool_image_create(const imgtool_module *module, const char *fname,
util::option_resolution *opts, imgtool_image **image)
//-------------------------------------------------
// create - creates an image
//-------------------------------------------------
imgtoolerr_t imgtool::image::create(const imgtool_module *module, const char *fname,
util::option_resolution *opts, ptr &image)
{
std::unique_ptr<util::option_resolution> alloc_resolution;
@ -1156,13 +1113,11 @@ imgtoolerr_t imgtool_image_create(const imgtool_module *module, const char *fnam
}
//-------------------------------------------------
// create - creates an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_create_byname - creates an image
-------------------------------------------------*/
imgtoolerr_t imgtool_image_create_byname(const char *modulename, const char *fname,
util::option_resolution *opts, imgtool_image **image)
imgtoolerr_t imgtool::image::create(const std::string &modulename, const char *fname, util::option_resolution *opts, ptr &image)
{
const imgtool_module *module;
@ -1170,23 +1125,44 @@ imgtoolerr_t imgtool_image_create_byname(const char *modulename, const char *fna
if (!module)
return (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_MODULE);
return imgtool_image_create(module, fname, opts, image);
return create(module, fname, opts, image);
}
//-------------------------------------------------
// create - creates an image
//-------------------------------------------------
/*-------------------------------------------------
imgtool_image_info - returns format specific information
about an image
-------------------------------------------------*/
imgtoolerr_t imgtool::image::create(const imgtool_module *module, const char *fname,
util::option_resolution *opts)
{
std::unique_ptr<image> image;
return create(module, fname, opts, image);
}
imgtoolerr_t imgtool_image_info(imgtool_image *image, char *string, size_t len)
//-------------------------------------------------
// create - creates an image
//-------------------------------------------------
imgtoolerr_t imgtool::image::create(const std::string &modulename, const char *fname, util::option_resolution *opts)
{
std::unique_ptr<image> image;
return create(modulename, fname, opts, image);
}
//-------------------------------------------------
// info - returns format specific information about an image
//-------------------------------------------------
imgtoolerr_t imgtool::image::info(char *string, size_t len)
{
if (len > 0)
{
string[0] = '\0';
if (image->module->info)
image->module->info(image, string, len);
if (module().info)
module().info(this, string, len);
}
return IMGTOOLERR_SUCCESS;
}
@ -2285,9 +2261,9 @@ done:
size of a standard block on a partition
-------------------------------------------------*/
imgtoolerr_t imgtool_partition_get_block_size(imgtool_partition *partition, UINT32 *length)
imgtoolerr_t imgtool_partition_get_block_size(imgtool_partition *partition, UINT32 &length)
{
return imgtool_image_get_block_size(partition->image, length);
return partition->image->get_block_size(length);
}
@ -2301,7 +2277,7 @@ imgtoolerr_t imgtool_partition_read_block(imgtool_partition *partition, UINT64 b
{
if (block >= partition->block_count)
return IMGTOOLERR_SEEKERROR;
return imgtool_image_read_block(partition->image, block + partition->base_block, buffer);
return partition->image->read_block(block + partition->base_block, buffer);
}
@ -2315,7 +2291,7 @@ imgtoolerr_t imgtool_partition_write_block(imgtool_partition *partition, UINT64
{
if (block >= partition->block_count)
return IMGTOOLERR_SEEKERROR;
return imgtool_image_write_block(partition->image, block + partition->base_block, buffer);
return partition->image->write_block(block + partition->base_block, buffer);
}
@ -2414,7 +2390,7 @@ void *imgtool_partition_extra_bytes(imgtool_partition *partition)
UINT64 imgtool_partition_rand(imgtool_partition *partition)
{
return imgtool_image_rand(partition->image);
return imgtool::image::rand();
}
@ -2673,7 +2649,7 @@ imgtoolerr_t imgtool_directory_get_next(imgtool_directory *directory, imgtool_di
const imgtool_module *imgtool_directory_module(imgtool_directory *directory)
{
return directory->partition->image->module;
return &directory->partition->image->module();
}
@ -2708,7 +2684,7 @@ imgtool_partition *imgtool_directory_partition(imgtool_directory *directory)
associated with this directory
-------------------------------------------------*/
imgtool_image *imgtool_directory_image(imgtool_directory *directory)
imgtool::image *imgtool_directory_image(imgtool_directory *directory)
{
return directory->partition->image;
}

72
src/tools/imgtool/imgtool.h
View File

@ -80,36 +80,58 @@ struct imgtool_partition_features
/* ----- initialization and basics ----- */
void imgtool_init(bool omit_untested, void (*warning)(const char *message));
void imgtool_exit(void);
const imgtool_module *imgtool_find_module(const char *modulename);
const imgtool_module *imgtool_find_module(const std::string &modulename);
const imgtool::library::modulelist &imgtool_get_modules();
imgtool_module_features imgtool_get_module_features(const imgtool_module *module);
void imgtool_warn(const char *format, ...) ATTR_PRINTF(1,2);
/* ----- image management ----- */
imgtoolerr_t imgtool_identify_file(const char *filename, imgtool_module **modules, size_t count);
imgtoolerr_t imgtool_image_open(const imgtool_module *module, const char *filename, int read_or_write, imgtool_image **outimg);
imgtoolerr_t imgtool_image_open_byname(const char *modulename, const char *filename, int read_or_write, imgtool_image **outimg);
imgtoolerr_t imgtool_image_create(const imgtool_module *module, const char *fname, util::option_resolution *opts, imgtool_image **image);
imgtoolerr_t imgtool_image_create_byname(const char *modulename, const char *fname, util::option_resolution *opts, imgtool_image **image);
void imgtool_image_close(imgtool_image *image);
imgtoolerr_t imgtool_image_info(imgtool_image *image, char *string, size_t len);
imgtoolerr_t imgtool_image_get_geometry(imgtool_image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t imgtool_image_read_sector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t imgtool_image_write_sector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len);
imgtoolerr_t imgtool_image_get_block_size(imgtool_image *image, UINT32 *length);
imgtoolerr_t imgtool_image_read_block(imgtool_image *image, UINT64 block, void *buffer);
imgtoolerr_t imgtool_image_write_block(imgtool_image *image, UINT64 block, const void *buffer);
imgtoolerr_t imgtool_image_clear_block(imgtool_image *image, UINT64 block, UINT8 data);
imgtoolerr_t imgtool_image_list_partitions(imgtool_image *image, imgtool_partition_info *partitions, size_t len);
void *imgtool_image_malloc(imgtool_image *image, size_t size);
const imgtool_module *imgtool_image_module(imgtool_image *image);
void *imgtool_image_extra_bytes(imgtool_image *image);
UINT64 imgtool_image_rand(imgtool_image *image);
// ----- image management -----
namespace imgtool
{
class image
{
public:
typedef std::unique_ptr<image> ptr;
image(const imgtool_module &module, object_pool *pool, void *extra_bytes);
~image();
static imgtoolerr_t identify_file(const char *filename, imgtool_module **modules, size_t count);
static imgtoolerr_t open(const imgtool_module *module, const char *filename, int read_or_write, ptr &outimg);
static imgtoolerr_t open(const std::string &modulename, const char *filename, int read_or_write, ptr &outimg);
static imgtoolerr_t create(const imgtool_module *module, const char *fname, util::option_resolution *opts, ptr &image);
static imgtoolerr_t create(const std::string &modulename, const char *fname, util::option_resolution *opts, ptr &image);
static imgtoolerr_t create(const imgtool_module *module, const char *fname, util::option_resolution *opts);
static imgtoolerr_t create(const std::string &modulename, const char *fname, util::option_resolution *opts);
static UINT64 rand();
imgtoolerr_t info(char *string, size_t len);
imgtoolerr_t get_geometry(UINT32 *tracks, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t read_sector(UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t write_sector(UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len);
imgtoolerr_t get_block_size(UINT32 &length);
imgtoolerr_t read_block(UINT64 block, void *buffer);
imgtoolerr_t write_block(UINT64 block, const void *buffer);
imgtoolerr_t clear_block(UINT64 block, UINT8 data);
imgtoolerr_t list_partitions(imgtool_partition_info *partitions, size_t len);
void *malloc(size_t size);
const imgtool_module &module() { return m_module; }
void *extra_bytes() { return m_extra_bytes; }
private:
const imgtool_module &m_module;
object_pool *m_pool;
void *m_extra_bytes;
static imgtoolerr_t internal_open(const imgtool_module *module, const char *fname,
int read_or_write, util::option_resolution *createopts, imgtool::image::ptr &outimg);
};
}
/* ----- partition management ----- */
imgtoolerr_t imgtool_partition_open(imgtool_image *image, int partition_index, imgtool_partition **partition);
imgtoolerr_t imgtool_partition_open(imgtool::image *image, int partition_index, imgtool_partition **partition);
void imgtool_partition_close(imgtool_partition *partition);
imgtool_image *imgtool_partition_image(imgtool_partition *partition);
imgtool::image *imgtool_partition_image(imgtool_partition *partition);
/* ----- partition operations ----- */
imgtoolerr_t imgtool_partition_get_directory_entry(imgtool_partition *partition, const char *path, int index, imgtool_dirent *ent);
@ -131,7 +153,7 @@ imgtoolerr_t imgtool_partition_put_file_attribute(imgtool_partition *partition,
void imgtool_partition_get_attribute_name(imgtool_partition *partition, UINT32 attribute, const imgtool_attribute *attr_value, char *buffer, size_t buffer_len);
imgtoolerr_t imgtool_partition_get_icon_info(imgtool_partition *partition, const char *path, imgtool_iconinfo *iconinfo);
imgtoolerr_t imgtool_partition_suggest_file_filters(imgtool_partition *partition, const char *path, imgtool_stream *stream, imgtool_transfer_suggestion *suggestions, size_t suggestions_length);
imgtoolerr_t imgtool_partition_get_block_size(imgtool_partition *partition, UINT32 *length);
imgtoolerr_t imgtool_partition_get_block_size(imgtool_partition *partition, UINT32 &length);
imgtoolerr_t imgtool_partition_read_block(imgtool_partition *partition, UINT64 block, void *buffer);
imgtoolerr_t imgtool_partition_write_block(imgtool_partition *partition, UINT64 block, const void *buffer);
imgtoolerr_t imgtool_partition_get_chain(imgtool_partition *partition, const char *path, imgtool_chainent *chain, size_t chain_size);
@ -155,7 +177,7 @@ imgtoolerr_t imgtool_directory_get_next(imgtool_directory *enumeration, imgtool_
const imgtool_module *imgtool_directory_module(imgtool_directory *enumeration);
void *imgtool_directory_extrabytes(imgtool_directory *enumeration);
imgtool_partition *imgtool_directory_partition(imgtool_directory *directory);
imgtool_image *imgtool_directory_image(imgtool_directory *enumeration);
imgtool::image *imgtool_directory_image(imgtool_directory *enumeration);
/* ----- special ----- */
int imgtool_validitychecks(void);

28
src/tools/imgtool/library.cpp
View File

@ -69,16 +69,16 @@ void library::add_class(const imgtool_class *imgclass)
module->tracks_are_called_cylinders = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_TRACKS_ARE_CALLED_CYLINDERS) ? 1 : 0;
module->writing_untested = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_WRITING_UNTESTED) ? 1 : 0;
module->creation_untested = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_CREATION_UNTESTED) ? 1 : 0;
module->open = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_OPEN);
module->create = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *, util::option_resolution *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CREATE);
module->close = (void (*)(imgtool_image *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CLOSE);
module->info = (void (*)(imgtool_image *, char *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_INFO);
module->read_sector = (imgtoolerr_t (*)(imgtool_image *, UINT32, UINT32, UINT32, std::vector<UINT8> &)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_SECTOR);
module->write_sector = (imgtoolerr_t (*)(imgtool_image *, UINT32, UINT32, UINT32, const void *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_SECTOR);
module->get_geometry = (imgtoolerr_t (*)(imgtool_image *, UINT32 *, UINT32 *, UINT32 *))imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_GET_GEOMETRY);
module->read_block = (imgtoolerr_t (*)(imgtool_image *, void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_BLOCK);
module->write_block = (imgtoolerr_t (*)(imgtool_image *, const void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_BLOCK);
module->list_partitions = (imgtoolerr_t (*)(imgtool_image *, imgtool_partition_info *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_LIST_PARTITIONS);
module->open = (imgtoolerr_t (*)(imgtool::image *, imgtool_stream *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_OPEN);
module->create = (imgtoolerr_t (*)(imgtool::image *, imgtool_stream *, util::option_resolution *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CREATE);
module->close = (void (*)(imgtool::image *)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_CLOSE);
module->info = (void (*)(imgtool::image *, char *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_INFO);
module->read_sector = (imgtoolerr_t (*)(imgtool::image *, UINT32, UINT32, UINT32, std::vector<UINT8> &)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_SECTOR);
module->write_sector = (imgtoolerr_t (*)(imgtool::image *, UINT32, UINT32, UINT32, const void *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_SECTOR);
module->get_geometry = (imgtoolerr_t (*)(imgtool::image *, UINT32 *, UINT32 *, UINT32 *))imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_GET_GEOMETRY);
module->read_block = (imgtoolerr_t (*)(imgtool::image *, void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_READ_BLOCK);
module->write_block = (imgtoolerr_t (*)(imgtool::image *, const void *, UINT64)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_WRITE_BLOCK);
module->list_partitions = (imgtoolerr_t (*)(imgtool::image *, imgtool_partition_info *, size_t)) imgtool_get_info_fct(imgclass, IMGTOOLINFO_PTR_LIST_PARTITIONS);
module->block_size = imgtool_get_info_int(imgclass, IMGTOOLINFO_INT_BLOCK_SIZE);
module->createimage_optguide = (const util::option_guide *) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_CREATEIMAGE_OPTGUIDE);
module->createimage_optspec = imgtool_library_strdup_allow_null((const char*)imgtool_get_info_ptr(imgclass, IMGTOOLINFO_STR_CREATEIMAGE_OPTSPEC));
@ -131,7 +131,7 @@ void library::add(imgtool_get_info get_info)
// unlink
//-------------------------------------------------
void library::unlink(const char *module_name)
void library::unlink(const std::string &module_name)
{
const modulelist::iterator iter = find(module_name);
if (iter != m_modules.end())
@ -177,12 +177,12 @@ void library::sort(sort_type sort)
// find
//-------------------------------------------------
library::modulelist::iterator library::find(const char *module_name)
library::modulelist::iterator library::find(const std::string &module_name)
{
return std::find_if(
m_modules.begin(),
m_modules.end(),
[this, module_name](std::unique_ptr<imgtool_module> &module) { return !strcmp(module->name, module_name); });
[this, module_name](std::unique_ptr<imgtool_module> &module) { return !module_name.compare(module->name); });
}
@ -190,7 +190,7 @@ library::modulelist::iterator library::find(const char *module_name)
// findmodule
//-------------------------------------------------
const imgtool_module *library::findmodule(const char *module_name)
const imgtool_module *library::findmodule(const std::string &module_name)
{
modulelist::iterator iter = find(module_name);
return iter != m_modules.end()

53
src/tools/imgtool/library.h
View File

@ -27,8 +27,11 @@
#include "charconv.h"
#include "pool.h"
namespace imgtool
{
class image;
};
struct imgtool_image;
struct imgtool_partition;
struct imgtool_directory;
@ -252,11 +255,11 @@ union imgtoolinfo
void * f; /* generic function pointers */
char * s; /* generic strings */
imgtoolerr_t (*open) (imgtool_image *image, imgtool_stream *stream);
void (*close) (imgtool_image *image);
imgtoolerr_t (*create) (imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts);
imgtoolerr_t (*create_partition) (imgtool_image *image, UINT64 first_block, UINT64 block_count);
void (*info) (imgtool_image *image, char *string, size_t len);
imgtoolerr_t (*open) (imgtool::image *image, imgtool_stream *stream);
void (*close) (imgtool::image *image);
imgtoolerr_t (*create) (imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts);
imgtoolerr_t (*create_partition) (imgtool::image *image, UINT64 first_block, UINT64 block_count);
void (*info) (imgtool::image *image, char *string, size_t len);
imgtoolerr_t (*begin_enum) (imgtool_directory *enumeration, const char *path);
imgtoolerr_t (*next_enum) (imgtool_directory *enumeration, imgtool_dirent *ent);
void (*close_enum) (imgtool_directory *enumeration);
@ -275,12 +278,12 @@ union imgtoolinfo
imgtoolerr_t (*get_iconinfo) (imgtool_partition *partition, const char *path, imgtool_iconinfo *iconinfo);
imgtoolerr_t (*suggest_transfer) (imgtool_partition *partition, const char *path, imgtool_transfer_suggestion *suggestions, size_t suggestions_length);
imgtoolerr_t (*get_chain) (imgtool_partition *partition, const char *path, imgtool_chainent *chain, size_t chain_size);
imgtoolerr_t (*get_geometry) (imgtool_image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t (*read_sector) (imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t (*write_sector) (imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam);
imgtoolerr_t (*read_block) (imgtool_image *image, void *buffer, UINT64 block);
imgtoolerr_t (*write_block) (imgtool_image *image, const void *buffer, UINT64 block);
imgtoolerr_t (*list_partitions) (imgtool_image *image, imgtool_partition_info *partitions, size_t len);
imgtoolerr_t (*get_geometry) (imgtool::image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t (*read_sector) (imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t (*write_sector) (imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam);
imgtoolerr_t (*read_block) (imgtool::image *image, void *buffer, UINT64 block);
imgtoolerr_t (*write_block) (imgtool::image *image, const void *buffer, UINT64 block);
imgtoolerr_t (*list_partitions) (imgtool::image *image, imgtool_partition_info *partitions, size_t len);
int (*approve_filename_char)(unicode_char ch);
int (*make_class)(int index, imgtool_class *imgclass);
@ -345,16 +348,16 @@ struct imgtool_module
unsigned int writing_untested : 1; /* used when we support writing, but not in main build */
unsigned int creation_untested : 1; /* used when we support creation, but not in main build */
imgtoolerr_t (*open) (imgtool_image *image, imgtool_stream *f);
void (*close) (imgtool_image *image);
void (*info) (imgtool_image *image, char *string, size_t len);
imgtoolerr_t (*create) (imgtool_image *image, imgtool_stream *f, util::option_resolution *opts);
imgtoolerr_t (*get_geometry) (imgtool_image *image, UINT32 *track, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t (*read_sector) (imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t (*write_sector) (imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len);
imgtoolerr_t (*read_block) (imgtool_image *image, void *buffer, UINT64 block);
imgtoolerr_t (*write_block) (imgtool_image *image, const void *buffer, UINT64 block);
imgtoolerr_t (*list_partitions)(imgtool_image *image, imgtool_partition_info *partitions, size_t len);
imgtoolerr_t (*open) (imgtool::image *image, imgtool_stream *f);
void (*close) (imgtool::image *image);
void (*info) (imgtool::image *image, char *string, size_t len);
imgtoolerr_t (*create) (imgtool::image *image, imgtool_stream *f, util::option_resolution *opts);
imgtoolerr_t (*get_geometry) (imgtool::image *image, UINT32 *track, UINT32 *heads, UINT32 *sectors);
imgtoolerr_t (*read_sector) (imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
imgtoolerr_t (*write_sector) (imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len);
imgtoolerr_t (*read_block) (imgtool::image *image, void *buffer, UINT64 block);
imgtoolerr_t (*write_block) (imgtool::image *image, const void *buffer, UINT64 block);
imgtoolerr_t (*list_partitions)(imgtool::image *image, imgtool_partition_info *partitions, size_t len);
UINT32 block_size;
@ -389,13 +392,13 @@ public:
void add(imgtool_get_info get_info);
// seeks out and removes a module from an imgtool library
void unlink(const char *module_name);
void unlink(const std::string &module_name);
// sorts an imgtool library
void sort(sort_type sort);
// finds a module
const imgtool_module *findmodule(const char *module_name);
const imgtool_module *findmodule(const std::string &module_name);
// module iteration
const modulelist &modules() { return m_modules; }
@ -405,7 +408,7 @@ private:
modulelist m_modules;
// internal lookup and iteration
modulelist::iterator find(const char *module_name);
modulelist::iterator find(const std::string &module_name);
// helpers
void add_class(const imgtool_class *imgclass);

80
src/tools/imgtool/main.cpp
View File

@ -173,7 +173,7 @@ static int cmd_dir(const struct command *c, int argc, char *argv[])
imgtoolerr_t err;
int total_count, total_size, freespace_err;
UINT64 freespace;
imgtool_image *image = nullptr;
imgtool::image::ptr image;
imgtool_partition *partition = nullptr;
imgtool_directory *imgenum = nullptr;
imgtool_dirent ent;
@ -182,13 +182,13 @@ static int cmd_dir(const struct command *c, int argc, char *argv[])
const char *path;
int partition_index = 0;
/* attempt to open image */
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
// attempt to open image
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_READ, image);
if (err)
goto done;
/* attempt to open partition */
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -205,7 +205,7 @@ static int cmd_dir(const struct command *c, int argc, char *argv[])
fprintf(stdout, "Contents of %s:%s\n", argv[1], path ? path : "");
imgtool_image_info(image, buf, sizeof(buf));
image->info(buf, sizeof(buf));
if (buf[0])
fprintf(stdout, "%s\n", buf);
fprintf(stdout, "------------------------------ -------- --------------- ------------------\n");
@ -253,8 +253,6 @@ done:
imgtool_directory_close(imgenum);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], nullptr, nullptr, nullptr);
return err ? -1 : 0;
@ -265,7 +263,7 @@ done:
static int cmd_get(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
const char *filename;
char *new_filename;
@ -274,11 +272,11 @@ static int cmd_get(const struct command *c, int argc, char *argv[])
const char *fork;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_READ, image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -301,8 +299,6 @@ done:
reporterror(err, c, argv[0], argv[1], argv[2], argv[3], nullptr);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
return (err || (unnamedargs < 0)) ? -1 : 0;
}
@ -312,7 +308,7 @@ static int cmd_put(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
int i;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
const char *filename = nullptr;
int unnamedargs;
@ -340,12 +336,12 @@ static int cmd_put(const struct command *c, int argc, char *argv[])
if (argc >= 2)
{
/* open up the image */
err = imgtool_image_open(module, argv[1], OSD_FOPEN_RW, &image);
err = imgtool::image::open(module, argv[1], OSD_FOPEN_RW, image);
if (err)
goto done;
/* open up the partition */
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -386,8 +382,6 @@ static int cmd_put(const struct command *c, int argc, char *argv[])
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], filename, nullptr, resolution.get());
return err ? -1 : 0;
@ -398,7 +392,7 @@ done:
static int cmd_getall(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
imgtool_directory *imgenum = nullptr;
imgtool_dirent ent;
@ -408,11 +402,11 @@ static int cmd_getall(const struct command *c, int argc, char *argv[])
int arg;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_READ, image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -446,8 +440,6 @@ done:
imgtool_directory_close(imgenum);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], nullptr, nullptr, nullptr);
return err ? -1 : 0;
@ -458,15 +450,15 @@ done:
static int cmd_del(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_RW, &image);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_RW, image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -477,8 +469,6 @@ static int cmd_del(const struct command *c, int argc, char *argv[])
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], argv[2], nullptr, nullptr);
return err ? -1 : 0;
@ -489,15 +479,15 @@ done:
static int cmd_mkdir(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_RW, &image);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_RW, image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -508,8 +498,6 @@ static int cmd_mkdir(const struct command *c, int argc, char *argv[])
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], argv[2], nullptr, nullptr);
return err ? -1 : 0;
@ -520,15 +508,15 @@ done:
static int cmd_rmdir(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = nullptr;
std::unique_ptr<imgtool::image> image;
imgtool_partition *partition = nullptr;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_RW, &image);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_RW, image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
err = imgtool_partition_open(image.get(), partition_index, &partition);
if (err)
goto done;
@ -539,8 +527,6 @@ static int cmd_rmdir(const struct command *c, int argc, char *argv[])
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], argv[2], nullptr, nullptr);
return err ? -1 : 0;
@ -554,7 +540,7 @@ static int cmd_identify(const struct command *c, int argc, char *argv[])
imgtoolerr_t err;
int i;
err = imgtool_identify_file(argv[0], modules, ARRAY_LENGTH(modules));
err = imgtool::image::identify_file(argv[0], modules, ARRAY_LENGTH(modules));
if (err)
{
reporterror(err, c, nullptr, argv[0], nullptr, nullptr, nullptr);
@ -579,7 +565,7 @@ static int cmd_create(const struct command *c, int argc, char *argv[])
int unnamedargs;
const imgtool_module *module;
std::unique_ptr<util::option_resolution> resolution;
module = imgtool_find_module(argv[0]);
if (!module)
{
@ -602,7 +588,7 @@ static int cmd_create(const struct command *c, int argc, char *argv[])
if (unnamedargs < 0)
return -1;
err = imgtool_image_create(module, argv[1], resolution.get(), nullptr);
err = imgtool::image::create(module, argv[1], resolution.get());
if (err)
goto error;
@ -618,13 +604,13 @@ error:
static int cmd_readsector(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *img;
std::unique_ptr<imgtool::image> img;
imgtool_stream *stream = nullptr;
std::vector<UINT8> buffer;
UINT32 track, head, sector;
/* attempt to open image */
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &img);
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_READ, img);
if (err)
goto done;
@ -632,7 +618,7 @@ static int cmd_readsector(const struct command *c, int argc, char *argv[])
head = atoi(argv[3]);
sector = atoi(argv[4]);
err = imgtool_image_read_sector(img, track, head, sector, buffer);
err = img->read_sector(track, head, sector, buffer);
if (err)
goto done;
@ -658,13 +644,13 @@ done:
static int cmd_writesector(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *img;
std::unique_ptr<imgtool::image> img;
imgtool_stream *stream = nullptr;
dynamic_buffer buffer;
UINT32 size, track, head, sector;
/* attempt to open image */
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_RW, &img);
// attempt to open image
err = imgtool::image::open(argv[0], argv[1], OSD_FOPEN_RW, img);
if (err)
goto done;
@ -685,7 +671,7 @@ static int cmd_writesector(const struct command *c, int argc, char *argv[])
stream_read(stream, &buffer[0], size);
err = imgtool_image_write_sector(img, track, head, sector, &buffer[0], size);
err = img->write_sector(track, head, sector, &buffer[0], size);
if (err)
goto done;

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

@ -230,11 +230,11 @@ struct amiga_iterator
*****************************************************************************/
static imgtoolerr_t amiga_image_read_sector(imgtool_image* img,
static imgtoolerr_t amiga_image_read_sector(imgtool::image* img,
UINT32 track, UINT32 head, UINT32 sector, void *buf, size_t len);
static imgtoolerr_t amiga_image_read_sector(imgtool_image* img,
static imgtoolerr_t amiga_image_read_sector(imgtool::image* img,
UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer);
static imgtoolerr_t amiga_image_write_sector(imgtool_image* img,
static imgtoolerr_t amiga_image_write_sector(imgtool::image* img,
UINT32 track, UINT32 head, UINT32 sector, const void *buf, size_t len, int ddam);
@ -399,9 +399,9 @@ static UINT32 block_checksum(UINT8 *buffer, int length)
/* Returns the total number of blocks in the image */
static int get_total_blocks(imgtool_image *img)
static int get_total_blocks(imgtool::image *img)
{
amiga_floppy *f = (amiga_floppy *)imgtool_image_extra_bytes(img);
amiga_floppy *f = (amiga_floppy *)img->extra_bytes();
return 2 * 80 * f->sectors;
}
@ -418,12 +418,12 @@ static void find_block(amiga_floppy *f, int block, int *track,
/* Generic read block */
static imgtoolerr_t read_block(imgtool_image *img, int block, UINT8 *buffer)
static imgtoolerr_t read_block(imgtool::image *img, int block, UINT8 *buffer)
{
imgtoolerr_t ret;
int track, head, sector;
find_block((amiga_floppy *) imgtool_image_extra_bytes(img), block, &track, &head, &sector);
find_block((amiga_floppy *) img->extra_bytes(), block, &track, &head, &sector);
/* get block from image */
ret = amiga_image_read_sector(img, track, head, sector, buffer, BSIZE);
@ -434,12 +434,12 @@ static imgtoolerr_t read_block(imgtool_image *img, int block, UINT8 *buffer)
/* Generic write block */
static imgtoolerr_t write_block(imgtool_image *img, int block, const UINT8 *buffer)
static imgtoolerr_t write_block(imgtool::image *img, int block, const UINT8 *buffer)
{
imgtoolerr_t ret;
int track, head, sector;
find_block((amiga_floppy *) imgtool_image_extra_bytes(img), block, &track, &head, &sector);
find_block((amiga_floppy *)img->extra_bytes(), block, &track, &head, &sector);
/* write block to image */
ret = amiga_image_write_sector(img, track, head, sector, buffer, BSIZE, 0);
@ -450,7 +450,7 @@ static imgtoolerr_t write_block(imgtool_image *img, int block, const UINT8 *buff
/* Return the type a block */
static sec_type get_block_type(imgtool_image *img, int block)
static sec_type get_block_type(imgtool::image *img, int block)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -474,7 +474,7 @@ static sec_type get_block_type(imgtool_image *img, int block)
/* Read a bitmap block */
static imgtoolerr_t read_bitmap_block(imgtool_image *img, int block, bitmap_block *bm)
static imgtoolerr_t read_bitmap_block(imgtool::image *img, int block, bitmap_block *bm)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -492,7 +492,7 @@ static imgtoolerr_t read_bitmap_block(imgtool_image *img, int block, bitmap_bloc
/* Write a bitmap block */
static imgtoolerr_t write_bitmap_block(imgtool_image *img, int block, const bitmap_block *bm)
static imgtoolerr_t write_bitmap_block(imgtool::image *img, int block, const bitmap_block *bm)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -511,7 +511,7 @@ static imgtoolerr_t write_bitmap_block(imgtool_image *img, int block, const bitm
#ifdef UNUSED_FUNCTION
/* Read a bitmap extended block */
static imgtoolerr_t read_bitmap_ext_block(imgtool_image *img, int block, bitmap_ext_block *bm)
static imgtoolerr_t read_bitmap_ext_block(imgtool::image *img, int block, bitmap_ext_block *bm)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -530,7 +530,7 @@ static imgtoolerr_t read_bitmap_ext_block(imgtool_image *img, int block, bitmap_
/* Read the root block */
static imgtoolerr_t read_root_block(imgtool_image *img, root_block *root)
static imgtoolerr_t read_root_block(imgtool::image *img, root_block *root)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -558,7 +558,7 @@ static imgtoolerr_t read_root_block(imgtool_image *img, root_block *root)
}
static imgtoolerr_t write_root_block(imgtool_image *img, const root_block *root)
static imgtoolerr_t write_root_block(imgtool::image *img, const root_block *root)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -595,7 +595,7 @@ static imgtoolerr_t write_root_block(imgtool_image *img, const root_block *root)
/* Read a file block */
static imgtoolerr_t read_file_block(imgtool_image *img, int block, file_block *fb)
static imgtoolerr_t read_file_block(imgtool::image *img, int block, file_block *fb)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -629,7 +629,7 @@ static imgtoolerr_t read_file_block(imgtool_image *img, int block, file_block *f
}
static imgtoolerr_t read_file_ext_block(imgtool_image *img, int block, file_ext_block *fe)
static imgtoolerr_t read_file_ext_block(imgtool::image *img, int block, file_ext_block *fe)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -650,7 +650,7 @@ static imgtoolerr_t read_file_ext_block(imgtool_image *img, int block, file_ext_
}
static imgtoolerr_t read_data_block(imgtool_image *img, int block, data_block *d)
static imgtoolerr_t read_data_block(imgtool::image *img, int block, data_block *d)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -672,7 +672,7 @@ static imgtoolerr_t read_data_block(imgtool_image *img, int block, data_block *d
/* Read a directory block */
static imgtoolerr_t read_dir_block(imgtool_image *img, int block, dir_block *db)
static imgtoolerr_t read_dir_block(imgtool::image *img, int block, dir_block *db)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -702,7 +702,7 @@ static imgtoolerr_t read_dir_block(imgtool_image *img, int block, dir_block *db)
}
static imgtoolerr_t write_dir_block(imgtool_image *img, int block, const dir_block *db)
static imgtoolerr_t write_dir_block(imgtool::image *img, int block, const dir_block *db)
{
UINT8 buffer[BSIZE];
@ -735,7 +735,7 @@ static imgtoolerr_t write_dir_block(imgtool_image *img, int block, const dir_blo
}
static imgtoolerr_t read_hardlink_block(imgtool_image *img, int block, hardlink_block *hl)
static imgtoolerr_t read_hardlink_block(imgtool::image *img, int block, hardlink_block *hl)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -763,7 +763,7 @@ static imgtoolerr_t read_hardlink_block(imgtool_image *img, int block, hardlink_
}
static imgtoolerr_t read_softlink_block(imgtool_image *img, int block, softlink_block *sl)
static imgtoolerr_t read_softlink_block(imgtool::image *img, int block, softlink_block *sl)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -790,7 +790,7 @@ static imgtoolerr_t read_softlink_block(imgtool_image *img, int block, softlink_
/* Returns the disk type */
static disk_type get_disk_type(imgtool_image *img)
static disk_type get_disk_type(imgtool::image *img)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -812,7 +812,7 @@ static disk_type get_disk_type(imgtool_image *img)
/* Returns TRUE if the disk is formatted with the FastFileSystem */
static int is_ffs(imgtool_image *img)
static int is_ffs(imgtool::image *img)
{
disk_type t = get_disk_type(img);
@ -823,7 +823,7 @@ static int is_ffs(imgtool_image *img)
/* Returns TRUE if the disk uses the international mode */
static int is_intl(imgtool_image *img)
static int is_intl(imgtool::image *img)
{
disk_type t = get_disk_type(img);
@ -835,7 +835,7 @@ static int is_intl(imgtool_image *img)
#ifdef UNUSED_FUNCTION
/* Returns TRUE if the disk uses the directory cache mode */
static int is_dirc(imgtool_image *img)
static int is_dirc(imgtool::image *img)
{
disk_type t = get_disk_type(img);
@ -844,7 +844,7 @@ static int is_dirc(imgtool_image *img)
}
#endif
static imgtoolerr_t get_hash_table(imgtool_image *img, int block, UINT32 *ht)
static imgtoolerr_t get_hash_table(imgtool::image *img, int block, UINT32 *ht)
{
imgtoolerr_t ret;
@ -884,7 +884,7 @@ static imgtoolerr_t get_hash_table(imgtool_image *img, int block, UINT32 *ht)
}
static imgtoolerr_t set_hash_table(imgtool_image *img, int block, const UINT32 *ht)
static imgtoolerr_t set_hash_table(imgtool::image *img, int block, const UINT32 *ht)
{
UINT8 buffer[BSIZE];
imgtoolerr_t ret;
@ -904,13 +904,13 @@ static imgtoolerr_t set_hash_table(imgtool_image *img, int block, const UINT32 *
}
#ifdef UNUSED_FUNCTION
static imgtoolerr_t get_root_hash_table(imgtool_image *img, UINT32 *ht)
static imgtoolerr_t get_root_hash_table(imgtool::image *img, UINT32 *ht)
{
return get_hash_table(img, get_total_blocks(img)/2, ht);
}
#endif
static imgtoolerr_t get_blockname(imgtool_image *img, int block, char *dest)
static imgtoolerr_t get_blockname(imgtool::image *img, int block, char *dest)
{
UINT8 buffer[BSIZE];
imgtoolerr_t ret;
@ -927,7 +927,7 @@ static imgtoolerr_t get_blockname(imgtool_image *img, int block, char *dest)
}
static imgtoolerr_t get_hash_chain(imgtool_image *img, int block, UINT32 *chain)
static imgtoolerr_t get_hash_chain(imgtool::image *img, int block, UINT32 *chain)
{
UINT8 buffer[BSIZE];
imgtoolerr_t ret;
@ -943,7 +943,7 @@ static imgtoolerr_t get_hash_chain(imgtool_image *img, int block, UINT32 *chain)
}
static imgtoolerr_t set_hash_chain(imgtool_image *img, int block, UINT32 chain)
static imgtoolerr_t set_hash_chain(imgtool::image *img, int block, UINT32 chain)
{
UINT8 buffer[BSIZE];
imgtoolerr_t ret;
@ -963,7 +963,7 @@ static imgtoolerr_t set_hash_chain(imgtool_image *img, int block, UINT32 chain)
}
static imgtoolerr_t walk_hash_chain(imgtool_image *img, const char *path, int start_block, int *prev_block, int *block)
static imgtoolerr_t walk_hash_chain(imgtool::image *img, const char *path, int start_block, int *prev_block, int *block)
{
imgtoolerr_t err;
UINT32 hash_chain;
@ -1065,7 +1065,7 @@ static imgtoolerr_t walk_hash_chain(imgtool_image *img, const char *path, int st
/* Returns the block number for a dir/file/link entry given as NUL delimited
* list of path parts, for example "dir1\0dir2\0dir3" returns the block number
* for directory "dir3" */
static imgtoolerr_t find_entry(imgtool_image *img, const char *path, int start_block, int *block)
static imgtoolerr_t find_entry(imgtool::image *img, const char *path, int start_block, int *block)
{
imgtoolerr_t ret;
const char *next_path;
@ -1127,7 +1127,7 @@ static imgtoolerr_t find_entry(imgtool_image *img, const char *path, int start_b
}
static imgtoolerr_t get_block_chksum(imgtool_image *img, int block, UINT32 *chksum, int bitmap)
static imgtoolerr_t get_block_chksum(imgtool::image *img, int block, UINT32 *chksum, int bitmap)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -1153,7 +1153,7 @@ static imgtoolerr_t get_block_chksum(imgtool_image *img, int block, UINT32 *chks
}
static imgtoolerr_t fix_chksum(imgtool_image *img, int block, int bitmap)
static imgtoolerr_t fix_chksum(imgtool::image *img, int block, int bitmap)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -1185,20 +1185,20 @@ static imgtoolerr_t fix_chksum(imgtool_image *img, int block, int bitmap)
}
static imgtoolerr_t fix_block_chksum(imgtool_image *img, int block)
static imgtoolerr_t fix_block_chksum(imgtool::image *img, int block)
{
return fix_chksum(img, block, FALSE);
}
static imgtoolerr_t fix_bitmap_chksum(imgtool_image *img, int block)
static imgtoolerr_t fix_bitmap_chksum(imgtool::image *img, int block)
{
return fix_chksum(img, block, TRUE);
}
/* Set a block as used */
static imgtoolerr_t bitmap_mark(imgtool_image *img, int block, int used)
static imgtoolerr_t bitmap_mark(imgtool::image *img, int block, int used)
{
imgtoolerr_t ret;
bitmap_block bm;
@ -1242,19 +1242,19 @@ static imgtoolerr_t bitmap_mark(imgtool_image *img, int block, int used)
}
static imgtoolerr_t bitmap_mark_used(imgtool_image *img, int block)
static imgtoolerr_t bitmap_mark_used(imgtool::image *img, int block)
{
return bitmap_mark(img, block, TRUE);
}
static imgtoolerr_t bitmap_mark_free(imgtool_image *img, int block)
static imgtoolerr_t bitmap_mark_free(imgtool::image *img, int block)
{
return bitmap_mark(img, block, FALSE);
}
static imgtoolerr_t update_block_modified_date(imgtool_image *img, int block)
static imgtoolerr_t update_block_modified_date(imgtool::image *img, int block)
{
UINT8 buffer[BSIZE];
imgtoolerr_t ret;
@ -1281,7 +1281,7 @@ static imgtoolerr_t update_block_modified_date(imgtool_image *img, int block)
}
static imgtoolerr_t clear_hash_table_entry(imgtool_image *img, int parent, char *filename)
static imgtoolerr_t clear_hash_table_entry(imgtool::image *img, int parent, char *filename)
{
imgtoolerr_t ret;
UINT32 ht[TSIZE], chain;
@ -1364,7 +1364,7 @@ static int get_first_bit(UINT32 *array, int size)
#ifdef UNUSED_FUNCTION
static imgtoolerr_t walk_bitmap_ext_blocks(imgtool_image *img, int start, int *block)
static imgtoolerr_t walk_bitmap_ext_blocks(imgtool::image *img, int start, int *block)
{
imgtoolerr_t ret;
bitmap_ext_block bm_ext;
@ -1401,7 +1401,7 @@ static imgtoolerr_t walk_bitmap_ext_blocks(imgtool_image *img, int start, int *b
/* Searches for a block marked as free
* TODO: bm_ext support for HDs */
static imgtoolerr_t find_free_block(imgtool_image *img, int *block)
static imgtoolerr_t find_free_block(imgtool::image *img, int *block)
{
imgtoolerr_t ret;
root_block root;
@ -1434,7 +1434,7 @@ static imgtoolerr_t find_free_block(imgtool_image *img, int *block)
}
static imgtoolerr_t add_entry(imgtool_image *img, int parent, int block)
static imgtoolerr_t add_entry(imgtool::image *img, int parent, int block)
{
imgtoolerr_t ret;
UINT32 ht[TSIZE];
@ -1469,7 +1469,7 @@ static imgtoolerr_t add_entry(imgtool_image *img, int parent, int block)
/* Recursively create new directory entries */
static imgtoolerr_t makedir(imgtool_image *img, const char *path, int parent)
static imgtoolerr_t makedir(imgtool::image *img, const char *path, int parent)
{
imgtoolerr_t ret;
dir_block dir;
@ -1523,7 +1523,7 @@ static imgtoolerr_t makedir(imgtool_image *img, const char *path, int parent)
/* Recursively checks the path parts and creates directories for them */
static imgtoolerr_t checkdir(imgtool_image *img, const char *path, int parent)
static imgtoolerr_t checkdir(imgtool::image *img, const char *path, int parent)
{
imgtoolerr_t ret;
int block;
@ -1567,7 +1567,7 @@ static imgtoolerr_t checkdir(imgtool_image *img, const char *path, int parent)
/* Writes the file data from the specified block into the stream */
static imgtoolerr_t write_file_block_data(imgtool_image *img, int block, int size, imgtool_stream *destf)
static imgtoolerr_t write_file_block_data(imgtool::image *img, int block, int size, imgtool_stream *destf)
{
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -1615,7 +1615,7 @@ static imgtoolerr_t write_file_block_data(imgtool_image *img, int block, int siz
}
static imgtoolerr_t walk_data_block_ptr(imgtool_image *img, UINT32 *ptr, int *filesize, imgtool_stream *destf, int write)
static imgtoolerr_t walk_data_block_ptr(imgtool::image *img, UINT32 *ptr, int *filesize, imgtool_stream *destf, int write)
{
int i, blocksize = is_ffs(img) ? BSIZE : BSIZE-24;
imgtoolerr_t ret;
@ -1646,20 +1646,20 @@ static imgtoolerr_t walk_data_block_ptr(imgtool_image *img, UINT32 *ptr, int *fi
}
static imgtoolerr_t write_data_block_ptr(imgtool_image *img, UINT32 *ptr, int *filesize, imgtool_stream *destf)
static imgtoolerr_t write_data_block_ptr(imgtool::image *img, UINT32 *ptr, int *filesize, imgtool_stream *destf)
{
return walk_data_block_ptr(img, ptr, filesize, destf, TRUE);
}
/* Marks all blocks pointed to by the data block pointers as free */
static imgtoolerr_t clear_data_block_ptr(imgtool_image *img, UINT32 *ptr, int *filesize)
static imgtoolerr_t clear_data_block_ptr(imgtool::image *img, UINT32 *ptr, int *filesize)
{
return walk_data_block_ptr(img, ptr, filesize, NULL, FALSE);
}
static imgtoolerr_t walk_file_ext_data(imgtool_image *img, int block, int *filesize, imgtool_stream *destf, int write)
static imgtoolerr_t walk_file_ext_data(imgtool::image *img, int block, int *filesize, imgtool_stream *destf, int write)
{
file_ext_block file_ext;
imgtoolerr_t ret;
@ -1698,20 +1698,20 @@ static imgtoolerr_t walk_file_ext_data(imgtool_image *img, int block, int *files
}
static imgtoolerr_t write_file_ext_data(imgtool_image *img, int block, int *filesize, imgtool_stream *destf)
static imgtoolerr_t write_file_ext_data(imgtool::image *img, int block, int *filesize, imgtool_stream *destf)
{
return walk_file_ext_data(img, block, filesize, destf, TRUE);
}
static imgtoolerr_t clear_file_ext_data(imgtool_image *img, int block, int *filesize)
static imgtoolerr_t clear_file_ext_data(imgtool::image *img, int block, int *filesize)
{
return walk_file_ext_data(img, block, filesize, NULL, FALSE);
}
/* Updates the disk alteration date stored in the root block */
static imgtoolerr_t update_disk_alteration_date(imgtool_image *img)
static imgtoolerr_t update_disk_alteration_date(imgtool::image *img)
{
imgtoolerr_t ret;
root_block root;
@ -1742,9 +1742,9 @@ static imgtoolerr_t update_disk_alteration_date(imgtool_image *img)
*****************************************************************************/
static imgtoolerr_t amiga_image_open(imgtool_image *img, imgtool_stream *stream)
static imgtoolerr_t amiga_image_open(imgtool::image *img, imgtool_stream *stream)
{
amiga_floppy *f = (amiga_floppy *) imgtool_image_extra_bytes(img);
amiga_floppy *f = (amiga_floppy *) img->extra_bytes();
UINT64 size = stream_size(stream);
f->stream = stream;
@ -1759,12 +1759,12 @@ static imgtoolerr_t amiga_image_open(imgtool_image *img, imgtool_stream *stream)
}
static void amiga_image_exit(imgtool_image *img)
static void amiga_image_exit(imgtool::image *img)
{
}
static void amiga_image_info(imgtool_image *img, char *string, size_t len)
static void amiga_image_info(imgtool::image *img, char *string, size_t len)
{
imgtoolerr_t ret;
root_block root;
@ -1796,9 +1796,9 @@ static void amiga_image_info(imgtool_image *img, char *string, size_t len)
}
static imgtoolerr_t amiga_image_read_sector(imgtool_image* img, UINT32 track, UINT32 head, UINT32 sector, void *buf, size_t len)
static imgtoolerr_t amiga_image_read_sector(imgtool::image* img, UINT32 track, UINT32 head, UINT32 sector, void *buf, size_t len)
{
amiga_floppy *f = (amiga_floppy *) imgtool_image_extra_bytes(img);
amiga_floppy *f = (amiga_floppy *) img->extra_bytes();
/* skip ahead to the area we want to read */
stream_seek(f->stream, track * (head+1) * f->sectors * BSIZE + sector * BSIZE, SEEK_CUR);
@ -1815,7 +1815,7 @@ static imgtoolerr_t amiga_image_read_sector(imgtool_image* img, UINT32 track, UI
}
static imgtoolerr_t amiga_image_read_sector(imgtool_image* img,
static imgtoolerr_t amiga_image_read_sector(imgtool::image* img,
UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
{
try { buffer.resize(BSIZE); }
@ -1825,9 +1825,9 @@ static imgtoolerr_t amiga_image_read_sector(imgtool_image* img,
}
static imgtoolerr_t amiga_image_write_sector(imgtool_image* img, UINT32 track, UINT32 head, UINT32 sector, const void *buf, size_t len, int ddam)
static imgtoolerr_t amiga_image_write_sector(imgtool::image* img, UINT32 track, UINT32 head, UINT32 sector, const void *buf, size_t len, int ddam)
{
amiga_floppy *f = (amiga_floppy *) imgtool_image_extra_bytes(img);
amiga_floppy *f = (amiga_floppy *) img->extra_bytes();
/* skip ahead to the area we want to write */
stream_seek(f->stream, track * (head+1) * f->sectors * BSIZE + sector * BSIZE, SEEK_CUR);
@ -2028,7 +2028,7 @@ static void amiga_image_closeenum(imgtool_directory *enumeration)
static imgtoolerr_t amiga_image_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtoolerr_t ret;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
const int data_size = is_ffs(image) ? BSIZE : BSIZE-24;
root_block root;
bitmap_block bm;
@ -2081,7 +2081,7 @@ static imgtoolerr_t amiga_image_freespace(imgtool_partition *partition, UINT64 *
static imgtoolerr_t amiga_image_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
imgtoolerr_t ret;
file_block file;
int filesize, block;
@ -2118,7 +2118,7 @@ static imgtoolerr_t amiga_image_readfile(imgtool_partition *partition, const cha
* cleared, but the bitmap blocks are updated. */
static imgtoolerr_t amiga_image_deletefile(imgtool_partition *partition, const char *fname)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
imgtoolerr_t ret;
int parent, block;
char filename[31];
@ -2195,9 +2195,9 @@ static imgtoolerr_t amiga_image_writefile(imgtool_partition *partition, const ch
}
static imgtoolerr_t amiga_image_create(imgtool_image *img, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t amiga_image_create(imgtool::image *img, imgtool_stream *stream, util::option_resolution *opts)
{
amiga_floppy *f = (amiga_floppy *) imgtool_image_extra_bytes(img);
amiga_floppy *f = (amiga_floppy *) img->extra_bytes();
const std::string &dskname = opts->lookup_string('N');
imgtoolerr_t ret;
UINT8 buffer[BSIZE];
@ -2302,7 +2302,7 @@ static imgtoolerr_t amiga_image_create(imgtool_image *img, imgtool_stream *strea
static imgtoolerr_t amiga_image_createdir(imgtool_partition *partition, const char *path)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
imgtoolerr_t ret;
/* Create directories */

52
src/tools/imgtool/modules/bml3.cpp
View File

@ -76,14 +76,14 @@ static imgtoolerr_t bml3_diskimage_deletefile(imgtool_partition *partition, cons
Imgtool module code
*********************************************************************/
static bml3_diskinfo *bml3_get_diskinfo(imgtool_image *image)
static bml3_diskinfo *bml3_get_diskinfo(imgtool::image *image)
{
return (bml3_diskinfo *) imgtool_floppy_extrabytes(image);
}
static int max_dirents(imgtool_image *image)
static int max_dirents(imgtool::image *image)
{
bml3_diskinfo *info = bml3_get_diskinfo(image);
return (16 * info->heads + 1 - info->dirent_start_sector)*(info->sector_size/32);
@ -91,7 +91,7 @@ static int max_dirents(imgtool_image *image)
static void dirent_location(imgtool_image *image, int index_loc, UINT8 *head, UINT8 *track, UINT8 *sector, UINT8 *offset)
static void dirent_location(imgtool::image *image, int index_loc, UINT8 *head, UINT8 *track, UINT8 *sector, UINT8 *offset)
{
bml3_diskinfo *info = bml3_get_diskinfo(image);
*track = 20;
@ -107,7 +107,7 @@ static void dirent_location(imgtool_image *image, int index_loc, UINT8 *head, UI
static floperr_t get_bml3_dirent(imgtool_image *f, int index_loc, struct bml3_dirent *ent)
static floperr_t get_bml3_dirent(imgtool::image *f, int index_loc, struct bml3_dirent *ent)
{
floperr_t err;
UINT8 head, track, sector, offset;
@ -139,7 +139,7 @@ static floperr_t get_bml3_dirent(imgtool_image *f, int index_loc, struct bml3_di
static floperr_t put_bml3_dirent(imgtool_image *f, int index_loc, const struct bml3_dirent *ent)
static floperr_t put_bml3_dirent(imgtool::image *f, int index_loc, const struct bml3_dirent *ent)
{
floperr_t err;
UINT8 head, track, sector, offset;
@ -194,7 +194,7 @@ static void get_dirent_fname(char *fnamebuf, const struct bml3_dirent *ent)
static imgtoolerr_t lookup_bml3_file(imgtool_image *f, const char *fname, struct bml3_dirent *ent, int *position)
static imgtoolerr_t lookup_bml3_file(imgtool::image *f, const char *fname, struct bml3_dirent *ent, int *position)
{
int i;
floperr_t ferr;
@ -229,7 +229,7 @@ static imgtoolerr_t lookup_bml3_file(imgtool_image *f, const char *fname, struct
static UINT8 get_granule_count(imgtool_image *img)
static UINT8 get_granule_count(imgtool::image *img)
{
// UINT16 tracks;
UINT16 disk_granules;
@ -245,7 +245,7 @@ static UINT8 get_granule_count(imgtool_image *img)
}
/* granule_map must be an array of MAX_GRANULEMAP_SIZE bytes */
static floperr_t get_granule_map(imgtool_image *img, UINT8 *granule_map, UINT8 *granule_count)
static floperr_t get_granule_map(imgtool::image *img, UINT8 *granule_map, UINT8 *granule_count)
{
bml3_diskinfo *info = bml3_get_diskinfo(img);
UINT8 count;
@ -260,7 +260,7 @@ static floperr_t get_granule_map(imgtool_image *img, UINT8 *granule_map, UINT8 *
static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, UINT8 granule_count)
static floperr_t put_granule_map(imgtool::image *img, const UINT8 *granule_map, UINT8 granule_count)
{
bml3_diskinfo *info = bml3_get_diskinfo(img);
return floppy_write_sector(imgtool_floppy(img), 0, 20, info->fat_start_sector, info->fat_start_offset, granule_map, granule_count, 0); /* TODO: pass ddam argument from imgtool */
@ -269,7 +269,7 @@ static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, U
static void granule_location(imgtool_image *image, UINT8 granule, UINT8 *head, UINT8 *track, UINT8 *sector)
static void granule_location(imgtool::image *image, UINT8 granule, UINT8 *head, UINT8 *track, UINT8 *sector)
{
bml3_diskinfo *info = bml3_get_diskinfo(image);
UINT16 abs_track = granule * info->granule_sectors / 16;
@ -283,7 +283,7 @@ static void granule_location(imgtool_image *image, UINT8 granule, UINT8 *head, U
static imgtoolerr_t transfer_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *f, imgtoolerr_t (*proc)(imgtool_image *, int, int, int, int, size_t, imgtool_stream *))
static imgtoolerr_t transfer_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *f, imgtoolerr_t (*proc)(imgtool::image *, int, int, int, int, size_t, imgtool_stream *))
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
UINT8 head, track, sector;
@ -294,21 +294,21 @@ static imgtoolerr_t transfer_granule(imgtool_image *img, UINT8 granule, int leng
}
static imgtoolerr_t transfer_from_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *destf)
static imgtoolerr_t transfer_from_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *destf)
{
return transfer_granule(img, granule, length, destf, imgtool_floppy_read_sector_to_stream);
}
static imgtoolerr_t transfer_to_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *sourcef)
static imgtoolerr_t transfer_to_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *sourcef)
{
return transfer_granule(img, granule, length, sourcef, imgtool_floppy_write_sector_from_stream);
}
static floperr_t read_granule(imgtool_image *img, UINT8 granule, int offset, int length, UINT8 *buf)
static floperr_t read_granule(imgtool::image *img, UINT8 granule, int offset, int length, UINT8 *buf)
{
UINT8 head, track, sector;
granule_location(img, granule, &head, &track, &sector);
@ -317,7 +317,7 @@ static floperr_t read_granule(imgtool_image *img, UINT8 granule, int offset, int
static floperr_t write_granule(imgtool_image *img, UINT8 granule, int offset, int length, const UINT8 *buf)
static floperr_t write_granule(imgtool::image *img, UINT8 granule, int offset, int length, const UINT8 *buf)
{
UINT8 head, track, sector;
granule_location(img, granule, &head, &track, &sector);
@ -326,7 +326,7 @@ static floperr_t write_granule(imgtool_image *img, UINT8 granule, int offset, in
static imgtoolerr_t list_granules(struct bml3_dirent *ent, imgtool_image *img, struct granule_list_t *granule_list)
static imgtoolerr_t list_granules(struct bml3_dirent *ent, imgtool::image *img, struct granule_list_t *granule_list)
{
floperr_t ferr;
UINT8 max_granules;
@ -368,7 +368,7 @@ static imgtoolerr_t list_granules(struct bml3_dirent *ent, imgtool_image *img, s
static imgtoolerr_t get_file_size(struct bml3_dirent *ent, imgtool_image *img, const struct granule_list_t *granule_list, size_t *size)
static imgtoolerr_t get_file_size(struct bml3_dirent *ent, imgtool::image *img, const struct granule_list_t *granule_list, size_t *size)
{
floperr_t ferr;
size_t last_sector_bytes = 0;
@ -422,7 +422,7 @@ static imgtoolerr_t get_file_size(struct bml3_dirent *ent, imgtool_image *img, c
static imgtoolerr_t process_bml3_file(struct bml3_dirent *ent, imgtool_image *img, imgtool_stream *destf, size_t *size)
static imgtoolerr_t process_bml3_file(struct bml3_dirent *ent, imgtool::image *img, imgtool_stream *destf, size_t *size)
{
imgtoolerr_t err;
size_t remaining_size, granule_size;
@ -498,7 +498,7 @@ static imgtoolerr_t prepare_dirent(UINT8 variant, struct bml3_dirent *ent, const
static imgtoolerr_t bml3_diskimage_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t bml3_diskimage_open(imgtool::image *image, imgtool_stream *stream)
{
// imgtoolerr_t err;
floperr_t ferr;
@ -556,7 +556,7 @@ static imgtoolerr_t bml3_diskimage_nextenum(imgtool_directory *enumeration, imgt
struct bml3_direnum *rsenum;
struct bml3_dirent rsent;
char fname[13];
imgtool_image *image;
imgtool::image *image;
image = imgtool_directory_image(enumeration);
rsenum = (struct bml3_direnum *) imgtool_directory_extrabytes(enumeration);
@ -620,7 +620,7 @@ static imgtoolerr_t bml3_diskimage_freespace(imgtool_partition *partition, UINT6
size_t s = 0;
UINT8 granule_count;
UINT8 granule_map[MAX_GRANULEMAP_SIZE];
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
bml3_diskinfo *info = bml3_get_diskinfo(image);
ferr = get_granule_map(image, granule_map, &granule_count);
@ -638,7 +638,7 @@ static imgtoolerr_t bml3_diskimage_freespace(imgtool_partition *partition, UINT6
static imgtoolerr_t delete_entry(imgtool_image *img, struct bml3_dirent *ent, int pos)
static imgtoolerr_t delete_entry(imgtool::image *img, struct bml3_dirent *ent, int pos)
{
floperr_t ferr;
unsigned char g, i;
@ -678,7 +678,7 @@ static imgtoolerr_t bml3_diskimage_readfile(imgtool_partition *partition, const
imgtoolerr_t err;
struct bml3_dirent ent;
size_t size;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
err = lookup_bml3_file(img, fname, &ent, NULL);
if (err)
@ -700,7 +700,7 @@ static imgtoolerr_t bml3_diskimage_writefile(imgtool_partition *partition, const
{
floperr_t ferr;
imgtoolerr_t err;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
bml3_diskinfo *info = bml3_get_diskinfo(img);
struct bml3_dirent ent, ent2;
size_t i;
@ -820,7 +820,7 @@ static imgtoolerr_t bml3_diskimage_writefile(imgtool_partition *partition, const
static imgtoolerr_t bml3_diskimage_deletefile(imgtool_partition *partition, const char *fname)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
int pos = 0;
struct bml3_dirent ent;
@ -836,7 +836,7 @@ static imgtoolerr_t bml3_diskimage_deletefile(imgtool_partition *partition, cons
static imgtoolerr_t bml3_diskimage_suggesttransfer(imgtool_partition *partition, const char *fname, imgtool_transfer_suggestion *suggestions, size_t suggestions_length)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
struct bml3_dirent ent;
int pos;

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

@ -126,9 +126,9 @@ struct concept_iterator
};
static imgtoolerr_t concept_image_init(imgtool_image *img, imgtool_stream *f);
static void concept_image_exit(imgtool_image *img);
static void concept_image_info(imgtool_image *img, char *string, size_t len);
static imgtoolerr_t concept_image_init(imgtool::image *img, imgtool_stream *f);
static void concept_image_exit(imgtool::image *img);
static void concept_image_info(imgtool::image *img, char *string, size_t len);
static imgtoolerr_t concept_image_beginenum(imgtool_directory *enumeration, const char *path);
static imgtoolerr_t concept_image_nextenum(imgtool_directory *enumeration, imgtool_dirent *ent);
static void concept_image_closeenum(imgtool_directory *enumeration);
@ -260,9 +260,9 @@ static int get_catalog_entry(concept_image *image, const unsigned char *filename
/*
Open a file as a concept_image.
*/
static imgtoolerr_t concept_image_init(imgtool_image *img, imgtool_stream *f)
static imgtoolerr_t concept_image_init(imgtool::image *img, imgtool_stream *f)
{
concept_image *image = (concept_image *) imgtool_image_extra_bytes(img);
concept_image *image = (concept_image *) img->extra_bytes();
int reply;
int i;
unsigned totphysrecs;
@ -295,9 +295,9 @@ static imgtoolerr_t concept_image_init(imgtool_image *img, imgtool_stream *f)
/*
close a concept_image
*/
static void concept_image_exit(imgtool_image *img)
static void concept_image_exit(imgtool::image *img)
{
/*concept_image *image = (concept_image *) imgtool_image_extra_bytes(img);*/
/*concept_image *image = (concept_image *) img->extra_bytes();*/
}
/*
@ -305,9 +305,9 @@ static void concept_image_exit(imgtool_image *img)
Currently returns the volume name
*/
static void concept_image_info(imgtool_image *img, char *string, size_t len)
static void concept_image_info(imgtool::image *img, char *string, size_t len)
{
concept_image *image = (concept_image *) imgtool_image_extra_bytes(img);
concept_image *image = (concept_image *) img->extra_bytes();
char vol_name[8];
memcpy(vol_name, image->dev_dir.vol_hdr.volname + 1, image->dev_dir.vol_hdr.volname[0]);
@ -324,7 +324,7 @@ static imgtoolerr_t concept_image_beginenum(imgtool_directory *enumeration, cons
concept_iterator *iter;
iter = (concept_iterator *) imgtool_directory_extrabytes(enumeration);
iter->image = (concept_image *) imgtool_image_extra_bytes(imgtool_directory_image(enumeration));
iter->image = (concept_image *) imgtool_directory_image(enumeration)->extra_bytes();
iter->index = 0;
return IMGTOOLERR_SUCCESS;
}
@ -402,7 +402,7 @@ static void concept_image_closeenum(imgtool_directory *enumeration)
*/
static imgtoolerr_t concept_image_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
concept_image *image = (concept_image*) img;
int free_blocks;
int i;
@ -428,8 +428,8 @@ static imgtoolerr_t concept_image_freespace(imgtool_partition *partition, UINT64
*/
static imgtoolerr_t concept_image_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtool_image *img = imgtool_partition_image(partition);
concept_image *image = (concept_image *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
concept_image *image = (concept_image *) img->extra_bytes();
size_t filename_len = strlen(filename);
unsigned char concept_fname[16];
int catalog_index;

32
src/tools/imgtool/modules/cybiko.cpp
View File

@ -345,9 +345,9 @@ static int flash_option_to_flash_type( int option)
}
}
static imgtoolerr_t cybiko_image_open( imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t cybiko_image_open( imgtool::image *image, imgtool_stream *stream)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
int flash_type;
// init
flash_type = flash_size_to_flash_type( stream_size( stream));
@ -358,15 +358,15 @@ static imgtoolerr_t cybiko_image_open( imgtool_image *image, imgtool_stream *str
return IMGTOOLERR_SUCCESS;
}
static void cybiko_image_close( imgtool_image *image)
static void cybiko_image_close( imgtool::image *image)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
stream_close( cfs->stream);
}
static imgtoolerr_t cybiko_image_create( imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t cybiko_image_create( imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
int flash_type;
// init
flash_type = flash_option_to_flash_type(opts->lookup_int('F'));
@ -386,8 +386,8 @@ static imgtoolerr_t cybiko_image_begin_enum( imgtool_directory *enumeration, con
static imgtoolerr_t cybiko_image_next_enum( imgtool_directory *enumeration, imgtool_dirent *ent)
{
imgtool_image *image = imgtool_directory_image( enumeration);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_directory_image( enumeration);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
cybiko_iter *iter = (cybiko_iter*)imgtool_directory_extrabytes( enumeration);
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id = INVALID_FILE_ID;
@ -425,16 +425,16 @@ static void cybiko_image_close_enum( imgtool_directory *enumeration)
static imgtoolerr_t cybiko_image_free_space( imgtool_partition *partition, UINT64 *size)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
if (size) *size = cfs_calc_free_space( cfs, cfs_calc_free_blocks( cfs));
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t cybiko_image_read_file( imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id, part_id = 0, old_part_id;
int i;
@ -460,8 +460,8 @@ static imgtoolerr_t cybiko_image_read_file( imgtool_partition *partition, const
static imgtoolerr_t cybiko_image_write_file( imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, util::option_resolution *opts)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id, part_id = 0, free_blocks;
UINT64 bytes_left;
@ -520,8 +520,8 @@ static imgtoolerr_t cybiko_image_write_file( imgtool_partition *partition, const
static imgtoolerr_t cybiko_image_delete_file( imgtool_partition *partition, const char *filename)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT16 file_id;
// find file
if (!cfs_file_find( cfs, filename, &file_id)) return IMGTOOLERR_FILENOTFOUND;

32
src/tools/imgtool/modules/cybikoxt.cpp
View File

@ -319,9 +319,9 @@ static UINT32 cfs_calc_free_space( cybiko_file_system *cfs, UINT16 blocks)
return free_space;
}
static imgtoolerr_t cybiko_image_open( imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t cybiko_image_open( imgtool::image *image, imgtool_stream *stream)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
// init
if (!cfs_init( cfs, stream)) return IMGTOOLERR_CORRUPTIMAGE;
// verify
@ -330,15 +330,15 @@ static imgtoolerr_t cybiko_image_open( imgtool_image *image, imgtool_stream *str
return IMGTOOLERR_SUCCESS;
}
static void cybiko_image_close( imgtool_image *image)
static void cybiko_image_close( imgtool::image *image)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
stream_close( cfs->stream);
}
static imgtoolerr_t cybiko_image_create( imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t cybiko_image_create( imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
// init
if (!cfs_init( cfs, stream)) return IMGTOOLERR_CORRUPTIMAGE;
// format
@ -356,8 +356,8 @@ static imgtoolerr_t cybiko_image_begin_enum( imgtool_directory *enumeration, con
static imgtoolerr_t cybiko_image_next_enum( imgtool_directory *enumeration, imgtool_dirent *ent)
{
imgtool_image *image = imgtool_directory_image( enumeration);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_directory_image( enumeration);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
cybiko_iter *iter = (cybiko_iter*)imgtool_directory_extrabytes( enumeration);
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id = INVALID_FILE_ID;
@ -395,16 +395,16 @@ static void cybiko_image_close_enum( imgtool_directory *enumeration)
static imgtoolerr_t cybiko_image_free_space( imgtool_partition *partition, UINT64 *size)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
if (size) *size = cfs_calc_free_space( cfs, cfs_calc_free_blocks( cfs));
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t cybiko_image_read_file( imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id, part_id = 0, old_part_id;
int i;
@ -432,8 +432,8 @@ static imgtoolerr_t cybiko_image_read_file( imgtool_partition *partition, const
static imgtoolerr_t cybiko_image_write_file( imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, util::option_resolution *opts)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT8 buffer[MAX_PAGE_SIZE];
UINT16 file_id, part_id = 0, free_blocks;
UINT64 bytes_left;
@ -495,8 +495,8 @@ static imgtoolerr_t cybiko_image_write_file( imgtool_partition *partition, const
static imgtoolerr_t cybiko_image_delete_file( imgtool_partition *partition, const char *filename)
{
imgtool_image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)imgtool_image_extra_bytes( image);
imgtool::image *image = imgtool_partition_image( partition);
cybiko_file_system *cfs = (cybiko_file_system*)image->extra_bytes();
UINT16 file_id;
// check filename
if (strlen( filename) > 58) return IMGTOOLERR_BADFILENAME;

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

@ -294,7 +294,7 @@ static imgtoolerr_t fat_read_sector(imgtool_partition *partition, UINT32 sector_
//disk_info = fat_get_partition_info(partition);
/* sanity check */
err = imgtool_partition_get_block_size(partition, &block_size);
err = imgtool_partition_get_block_size(partition, block_size);
if (err)
return err;
assert(block_size == sizeof(data));
@ -330,7 +330,7 @@ static imgtoolerr_t fat_write_sector(imgtool_partition *partition, UINT32 sector
//disk_info = fat_get_partition_info(partition);
/* sanity check */
err = imgtool_partition_get_block_size(partition, &block_size);
err = imgtool_partition_get_block_size(partition, block_size);
if (err)
return err;
assert(block_size == sizeof(data));
@ -447,7 +447,7 @@ static imgtoolerr_t fat_partition_open(imgtool_partition *partition, UINT64 firs
static imgtoolerr_t fat_partition_create(imgtool_image *image, UINT64 first_block, UINT64 block_count)
static imgtoolerr_t fat_partition_create(imgtool::image *image, UINT64 first_block, UINT64 block_count)
{
imgtoolerr_t err;
UINT32 heads, tracks, sectors_per_track;
@ -469,7 +469,7 @@ static imgtoolerr_t fat_partition_create(imgtool_image *image, UINT64 first_bloc
return IMGTOOLERR_PARAMTOOLARGE;
/* get the geometry */
err = imgtool_image_get_geometry(image, &tracks, &heads, &sectors_per_track);
err = image->get_geometry(&tracks, &heads, &sectors_per_track);
if (err)
return err;
@ -534,7 +534,7 @@ static imgtoolerr_t fat_partition_create(imgtool_image *image, UINT64 first_bloc
place_integer_le(header, 32, 4, (UINT32) (block_count >> 16));
place_integer_le(header, 36, 1, 0xFF);
place_integer_le(header, 38, 1, 0x28);
place_integer_le(header, 39, 4, imgtool_image_rand(image));
place_integer_le(header, 39, 4, imgtool::image::rand());
memcpy(&header[43], " ", 11);
memcpy(&header[54], fat_bits_string, 8);
@ -560,14 +560,14 @@ static imgtoolerr_t fat_partition_create(imgtool_image *image, UINT64 first_bloc
header[2] = (UINT8) ((boot_sector_offset - 2) >> 8); /* (offset) */
}
err = imgtool_image_write_block(image, first_block, header);
err = image->write_block(first_block, header);
if (err)
return err;
/* clear out file allocation table */
for (i = reserved_sectors; i < (reserved_sectors + sectors_per_fat * fat_count + root_dir_sectors); i++)
{
err = imgtool_image_clear_block(image, first_block + i, 0);
err = image->clear_block(first_block + i, 0);
if (err)
return err;
}
@ -582,7 +582,7 @@ static imgtoolerr_t fat_partition_create(imgtool_image *image, UINT64 first_bloc
for (i = 0; i < fat_count; i++)
{
err = imgtool_image_write_block(image, first_block + 1 + (i * sectors_per_fat), &first_fat_entries);
err = image->write_block(first_block + 1 + (i * sectors_per_fat), &first_fat_entries);
if (err)
return err;
}

40
src/tools/imgtool/modules/hp48.cpp
View File

@ -327,9 +327,9 @@ static UINT16 crc(UINT8* data, int len)
*****************************************************************************/
static imgtoolerr_t hp48_open(imgtool_image *img, imgtool_stream *stream)
static imgtoolerr_t hp48_open(imgtool::image *img, imgtool_stream *stream)
{
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
hp48_card* c = (hp48_card*) img->extra_bytes();
int size = stream_size( stream );
/* check that size is a power of 2 between 32 KB and 4 MG */
@ -363,11 +363,11 @@ static imgtoolerr_t hp48_open(imgtool_image *img, imgtool_stream *stream)
static imgtoolerr_t hp48_create(imgtool_image* img,
static imgtoolerr_t hp48_create(imgtool::image* img,
imgtool_stream *stream,
util::option_resolution *opts)
{
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
hp48_card* c = (hp48_card*) img->extra_bytes();
int size;
size = opts->lookup_int('S');
@ -389,9 +389,9 @@ static imgtoolerr_t hp48_create(imgtool_image* img,
static void hp48_close(imgtool_image *img)
static void hp48_close(imgtool::image *img)
{
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
hp48_card* c = (hp48_card*) img->extra_bytes();
if ( c->modified )
{
@ -413,11 +413,11 @@ static void hp48_close(imgtool_image *img)
void hp48_partition_get_info(const imgtool_class *imgclass, UINT32 state, union imgtoolinfo *info);
static imgtoolerr_t hp48_list_partitions(imgtool_image *img,
static imgtoolerr_t hp48_list_partitions(imgtool::image *img,
imgtool_partition_info *partitions,
size_t len)
{
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
hp48_card* c = (hp48_card*) img->extra_bytes();
int i;
for ( i = 0; i < len && i * MAX_PORT_SIZE < c->size ; i++ )
@ -439,8 +439,8 @@ static imgtoolerr_t hp48_list_partitions(imgtool_image *img,
static imgtoolerr_t hp48_open_partition(imgtool_partition *part,
UINT64 first_block, UINT64 block_count)
{
imgtool_image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
if ( first_block + block_count > c->size )
@ -471,8 +471,8 @@ static imgtoolerr_t hp48_nextenum(imgtool_directory *enumeration,
imgtool_dirent *ent)
{
imgtool_partition *part = imgtool_directory_partition( enumeration );
//imgtool_image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
//imgtool::image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
hp48_directory* d = (hp48_directory*) imgtool_directory_extrabytes( enumeration );
@ -528,8 +528,8 @@ static imgtoolerr_t hp48_nextenum(imgtool_directory *enumeration,
static imgtoolerr_t hp48_freespace(imgtool_partition *part, UINT64 *size)
{
//imgtool_image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
//imgtool::image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
*size = p->size - (find_end(p)+1)/2;
@ -544,8 +544,8 @@ static imgtoolerr_t hp48_readfile(imgtool_partition *part,
const char *fork,
imgtool_stream *destf)
{
//imgtool_image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
//imgtool::image* img = imgtool_partition_image( part );
//hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
/* find entry */
@ -587,8 +587,8 @@ static imgtoolerr_t hp48_readfile(imgtool_partition *part,
static imgtoolerr_t hp48_deletefile(imgtool_partition *part,
const char *filename)
{
imgtool_image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
/* find entry */
@ -616,8 +616,8 @@ static imgtoolerr_t hp48_writefile(imgtool_partition *part,
imgtool_stream *sourcef,
util::option_resolution *opts)
{
imgtool_image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
hp48_card* c = (hp48_card*) img->extra_bytes();
hp48_partition* p = (hp48_partition*) imgtool_partition_extra_bytes( part );
/* check header */

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

@ -1023,9 +1023,9 @@ bool tape_image_t::decode_dir(void)
return true;
}
static tape_state_t& get_tape_state(imgtool_image *img)
static tape_state_t& get_tape_state(imgtool::image *img)
{
tape_state_t *ts = (tape_state_t*)imgtool_image_extra_bytes(img);
tape_state_t *ts = (tape_state_t*)img->extra_bytes();
return *ts;
}
@ -1042,7 +1042,7 @@ static tape_image_t& get_tape_image(tape_state_t& ts)
/********************************************************************************
* Imgtool functions
********************************************************************************/
static imgtoolerr_t hp9845_tape_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t hp9845_tape_open(imgtool::image *image, imgtool_stream *stream)
{
tape_state_t& state = get_tape_state(image);
@ -1053,7 +1053,7 @@ static imgtoolerr_t hp9845_tape_open(imgtool_image *image, imgtool_stream *strea
return tape_image.load_from_file(stream);
}
static imgtoolerr_t hp9845_tape_create(imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t hp9845_tape_create(imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
tape_state_t& state = get_tape_state(image);
@ -1066,7 +1066,7 @@ static imgtoolerr_t hp9845_tape_create(imgtool_image *image, imgtool_stream *str
return IMGTOOLERR_SUCCESS;
}
static void hp9845_tape_close(imgtool_image *image)
static void hp9845_tape_close(imgtool::image *image)
{
tape_state_t& state = get_tape_state(image);
tape_image_t& tape_image = get_tape_image(state);

32
src/tools/imgtool/modules/mac.cpp
View File

@ -615,7 +615,7 @@ static void mac_strncpy(UINT8 *dest, int n, const UINT8 *src)
*/
struct mac_l1_imgref
{
imgtool_image *image;
imgtool::image *image;
UINT32 heads;
};
@ -1069,7 +1069,7 @@ static imgtoolerr_t hfs_file_open(struct mac_l2_imgref *l2_img, UINT32 parID, co
static imgtoolerr_t mfs_file_setABeof(struct mac_fileref *fileref, UINT32 newABeof);
static imgtoolerr_t mfs_dir_update(struct mac_fileref *fileref);
static struct mac_l2_imgref *get_imgref(imgtool_image *img)
static struct mac_l2_imgref *get_imgref(imgtool::image *img)
{
return (struct mac_l2_imgref *) imgtool_floppy_extrabytes(img);
}
@ -1542,7 +1542,7 @@ struct mfs_dirref
static imgtoolerr_t mfs_image_create(imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t mfs_image_create(imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
imgtoolerr_t err;
UINT8 buffer[512];
@ -1606,7 +1606,7 @@ static imgtoolerr_t mfs_image_create(imgtool_image *image, imgtool_stream *strea
Return imgtool error code
*/
static imgtoolerr_t mfs_image_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t mfs_image_open(imgtool::image *image, imgtool_stream *stream)
{
imgtoolerr_t err;
struct mac_l2_imgref *l2_img;
@ -3033,7 +3033,7 @@ static int hfs_catKey_compare(const void *p1, const void *p2)
Return imgtool error code
*/
static imgtoolerr_t hfs_image_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t hfs_image_open(imgtool::image *image, imgtool_stream *stream)
{
imgtoolerr_t err;
struct mac_l2_imgref *l2_img;
@ -5271,9 +5271,9 @@ static imgtoolerr_t get_comment(struct mac_l2_imgref *l2_img, UINT16 id, mac_str
#endif
#ifdef UNUSED_FUNCTION
static void mac_image_exit(imgtool_image *img);
static void mac_image_exit(imgtool::image *img);
#endif
static void mac_image_info(imgtool_image *img, char *string, size_t len);
static void mac_image_info(imgtool::image *img, char *string, size_t len);
static imgtoolerr_t mac_image_beginenum(imgtool_directory *enumeration, const char *path);
static imgtoolerr_t mac_image_nextenum(imgtool_directory *enumeration, imgtool_dirent *ent);
static imgtoolerr_t mac_image_freespace(imgtool_partition *partition, UINT64 *size);
@ -5284,7 +5284,7 @@ static imgtoolerr_t mac_image_writefile(imgtool_partition *partition, const char
/*
close a mfs/hfs image
*/
static void mac_image_exit(imgtool_image *img)
static void mac_image_exit(imgtool::image *img)
{
struct mac_l2_imgref *image = get_imgref(img);
@ -5297,7 +5297,7 @@ static void mac_image_exit(imgtool_image *img)
Currently returns the volume name
*/
static void mac_image_info(imgtool_image *img, char *string, size_t len)
static void mac_image_info(imgtool::image *img, char *string, size_t len)
{
struct mac_l2_imgref *image = get_imgref(img);
@ -5573,7 +5573,7 @@ static imgtoolerr_t mac_image_nextenum(imgtool_directory *enumeration, imgtool_d
*/
static imgtoolerr_t mac_image_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
*size = ((UINT64) get_imgref(image)->freeABs) * 512;
return IMGTOOLERR_SUCCESS;
}
@ -5613,7 +5613,7 @@ static imgtoolerr_t mac_get_comment(struct mac_l2_imgref *image, mac_str255 file
static imgtoolerr_t mac_image_readfile(imgtool_partition *partition, const char *fpath, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t err;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct mac_l2_imgref *image = get_imgref(img);
UINT32 parID;
mac_str255 filename;
@ -5663,7 +5663,7 @@ static imgtoolerr_t mac_image_readfile(imgtool_partition *partition, const char
*/
static imgtoolerr_t mac_image_writefile(imgtool_partition *partition, const char *fpath, const char *fork, imgtool_stream *sourcef, util::option_resolution *writeoptions)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct mac_l2_imgref *image = get_imgref(img);
UINT32 parID;
mac_str255 filename;
@ -5745,7 +5745,7 @@ static imgtoolerr_t mac_image_listforks(imgtool_partition *partition, const char
mac_str255 filename;
mac_dirent cat_info;
int fork_num = 0;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct mac_l2_imgref *image = get_imgref(img);
/* resolve path and fetch file info from directory/catalog */
@ -5779,7 +5779,7 @@ static imgtoolerr_t mac_image_listforks(imgtool_partition *partition, const char
static imgtoolerr_t mac_image_getattrs(imgtool_partition *partition, const char *path, const UINT32 *attrs, imgtool_attribute *values)
{
imgtoolerr_t err;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
UINT32 parID;
mac_str255 filename;
mac_dirent cat_info;
@ -5850,7 +5850,7 @@ static imgtoolerr_t mac_image_setattrs(imgtool_partition *partition, const char
UINT32 parID;
mac_str255 filename;
mac_dirent cat_info;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct mac_l2_imgref *image = get_imgref(img);
int i;
@ -6323,7 +6323,7 @@ static imgtoolerr_t mac_image_suggesttransfer(imgtool_partition *partition, cons
UINT32 parID;
mac_str255 filename;
mac_dirent cat_info;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct mac_l2_imgref *image = get_imgref(img);
mac_filecategory_t file_category = MAC_FILECATEGORY_DATA;

2
src/tools/imgtool/modules/macbin.cpp
View File

@ -233,7 +233,7 @@ static imgtoolerr_t macbinary_writefile(imgtool_partition *partition, const char
0
};
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
UINT8 header[128];
UINT32 datafork_size;
UINT32 resourcefork_size;

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

@ -118,7 +118,7 @@ static void place_string(void *ptr, size_t offset, size_t length, const char *s)
static os9_diskinfo *os9_get_diskinfo(imgtool_image *image)
static os9_diskinfo *os9_get_diskinfo(imgtool::image *image)
{
return (os9_diskinfo *) imgtool_floppy_extrabytes(image);
}
@ -132,7 +132,7 @@ static struct os9_direnum *os9_get_dirinfo(imgtool_directory *directory)
static imgtoolerr_t os9_locate_lsn(imgtool_image *image, UINT32 lsn, UINT32 *head, UINT32 *track, UINT32 *sector)
static imgtoolerr_t os9_locate_lsn(imgtool::image *image, UINT32 lsn, UINT32 *head, UINT32 *track, UINT32 *sector)
{
const os9_diskinfo *disk_info;
@ -148,7 +148,7 @@ static imgtoolerr_t os9_locate_lsn(imgtool_image *image, UINT32 lsn, UINT32 *hea
static imgtoolerr_t os9_read_lsn(imgtool_image *img, UINT32 lsn, int offset, void *buffer, size_t buffer_len)
static imgtoolerr_t os9_read_lsn(imgtool::image *img, UINT32 lsn, int offset, void *buffer, size_t buffer_len)
{
imgtoolerr_t err;
floperr_t ferr;
@ -167,7 +167,7 @@ static imgtoolerr_t os9_read_lsn(imgtool_image *img, UINT32 lsn, int offset, voi
static imgtoolerr_t os9_write_lsn(imgtool_image *img, UINT32 lsn, int offset, const void *buffer, size_t buffer_len)
static imgtoolerr_t os9_write_lsn(imgtool::image *img, UINT32 lsn, int offset, const void *buffer, size_t buffer_len)
{
imgtoolerr_t err;
floperr_t ferr;
@ -186,7 +186,7 @@ static imgtoolerr_t os9_write_lsn(imgtool_image *img, UINT32 lsn, int offset, co
static UINT32 os9_lookup_lsn(imgtool_image *img,
static UINT32 os9_lookup_lsn(imgtool::image *img,
const struct os9_fileinfo *file_info, UINT32 *index)
{
int i;
@ -241,7 +241,7 @@ static int os9_interpret_dirent(void *entry, char **filename, UINT32 *lsn, int *
entry from an LSN, and decodes it
-------------------------------------------------*/
static imgtoolerr_t os9_decode_file_header(imgtool_image *image,
static imgtoolerr_t os9_decode_file_header(imgtool::image *image,
int lsn, struct os9_fileinfo *info)
{
imgtoolerr_t err;
@ -293,7 +293,7 @@ static imgtoolerr_t os9_decode_file_header(imgtool_image *image,
static imgtoolerr_t os9_allocate_lsn(imgtool_image *image, UINT32 *lsn)
static imgtoolerr_t os9_allocate_lsn(imgtool::image *image, UINT32 *lsn)
{
UINT32 i;
os9_diskinfo *disk_info;
@ -318,7 +318,7 @@ static imgtoolerr_t os9_allocate_lsn(imgtool_image *image, UINT32 *lsn)
static imgtoolerr_t os9_deallocate_lsn(imgtool_image *image, UINT32 lsn)
static imgtoolerr_t os9_deallocate_lsn(imgtool::image *image, UINT32 lsn)
{
UINT8 mask;
os9_diskinfo *disk_info;
@ -331,7 +331,7 @@ static imgtoolerr_t os9_deallocate_lsn(imgtool_image *image, UINT32 lsn)
static UINT32 os9_get_free_lsns(imgtool_image *image)
static UINT32 os9_get_free_lsns(imgtool::image *image)
{
const os9_diskinfo *disk_info;
UINT32 i, free_lsns;
@ -364,7 +364,7 @@ static imgtoolerr_t os9_corrupt_file_error(const struct os9_fileinfo *file_info)
static imgtoolerr_t os9_set_file_size(imgtool_image *image,
static imgtoolerr_t os9_set_file_size(imgtool::image *image,
struct os9_fileinfo *file_info, UINT32 new_size)
{
imgtoolerr_t err;
@ -483,7 +483,7 @@ static imgtoolerr_t os9_set_file_size(imgtool_image *image,
a file
-------------------------------------------------*/
static imgtoolerr_t os9_lookup_path(imgtool_image *img, const char *path,
static imgtoolerr_t os9_lookup_path(imgtool::image *img, const char *path,
creation_policy_t create, struct os9_fileinfo *file_info,
UINT32 *parent_lsn, UINT32 *dirent_lsn, UINT32 *dirent_index)
{
@ -622,7 +622,7 @@ done:
static imgtoolerr_t os9_diskimage_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t os9_diskimage_open(imgtool::image *image, imgtool_stream *stream)
{
imgtoolerr_t err;
floperr_t ferr;
@ -670,7 +670,7 @@ static imgtoolerr_t os9_diskimage_open(imgtool_image *image, imgtool_stream *str
return IMGTOOLERR_CORRUPTIMAGE;
/* is the allocation bitmap too big? */
info->allocation_bitmap = (UINT8*)imgtool_image_malloc(image, info->allocation_bitmap_bytes);
info->allocation_bitmap = (UINT8*)image->malloc(info->allocation_bitmap_bytes);
if (!info->allocation_bitmap)
return IMGTOOLERR_OUTOFMEMORY;
memset(info->allocation_bitmap, 0, info->allocation_bitmap_bytes);
@ -710,7 +710,7 @@ static imgtoolerr_t os9_diskimage_open(imgtool_image *image, imgtool_stream *str
static imgtoolerr_t os9_diskimage_create(imgtool_image *img, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t os9_diskimage_create(imgtool::image *img, imgtool_stream *stream, util::option_resolution *opts)
{
imgtoolerr_t err;
dynamic_buffer header;
@ -851,7 +851,7 @@ static imgtoolerr_t os9_diskimage_beginenum(imgtool_directory *enumeration, cons
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
struct os9_direnum *os9enum;
imgtool_image *image;
imgtool::image *image;
image = imgtool_directory_image(enumeration);
os9enum = os9_get_dirinfo(enumeration);
@ -881,7 +881,7 @@ static imgtoolerr_t os9_diskimage_nextenum(imgtool_directory *enumeration, imgto
UINT8 dir_entry[32];
char filename[29];
struct os9_fileinfo file_info;
imgtool_image *image;
imgtool::image *image;
image = imgtool_directory_image(enumeration);
os9enum = os9_get_dirinfo(enumeration);
@ -975,7 +975,7 @@ static imgtoolerr_t os9_diskimage_nextenum(imgtool_directory *enumeration, imgto
static imgtoolerr_t os9_diskimage_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
const os9_diskinfo *disk_info;
UINT32 free_lsns;
@ -991,7 +991,7 @@ static imgtoolerr_t os9_diskimage_freespace(imgtool_partition *partition, UINT64
static imgtoolerr_t os9_diskimage_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t err;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
const os9_diskinfo *disk_info;
struct os9_fileinfo file_info;
UINT8 buffer[256];
@ -1029,7 +1029,7 @@ static imgtoolerr_t os9_diskimage_readfile(imgtool_partition *partition, const c
static imgtoolerr_t os9_diskimage_writefile(imgtool_partition *partition, const char *path, const char *fork, imgtool_stream *sourcef, util::option_resolution *opts)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
struct os9_fileinfo file_info;
size_t write_size;
dynamic_buffer buf;
@ -1085,7 +1085,7 @@ static imgtoolerr_t os9_diskimage_delete(imgtool_partition *partition, const cha
unsigned int delete_directory)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
//const os9_diskinfo *disk_info;
struct os9_fileinfo file_info;
UINT32 dirent_lsn, dirent_index;
@ -1173,7 +1173,7 @@ static imgtoolerr_t os9_diskimage_deletefile(imgtool_partition *partition, const
static imgtoolerr_t os9_diskimage_createdir(imgtool_partition *partition, const char *path)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
struct os9_fileinfo file_info;
UINT8 dir_data[64];
UINT32 parent_lsn;

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

@ -17,13 +17,13 @@
#define FAT_SECLEN 512
static imgtoolerr_t fat_image_create(imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t fat_image_create(imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
imgtoolerr_t err;
UINT32 tracks, heads, sectors;
UINT8 buffer[FAT_SECLEN];
imgtool_class imgclass = { fat_get_info };
imgtoolerr_t (*fat_partition_create)(imgtool_image *image, UINT64 first_block, UINT64 block_count);
imgtoolerr_t (*fat_partition_create)(imgtool::image *image, UINT64 first_block, UINT64 block_count);
tracks = opts->lookup_int('T');
heads = opts->lookup_int('H');
@ -35,12 +35,12 @@ static imgtoolerr_t fat_image_create(imgtool_image *image, imgtool_stream *strea
place_integer_le(buffer, 26, 2, heads);
place_integer_le(buffer, 19, 2, (UINT16) (((UINT64) tracks * heads * sectors) >> 0));
place_integer_le(buffer, 32, 4, (UINT16) (((UINT64) tracks * heads * sectors) >> 16));
err = imgtool_image_write_block(image, 0, buffer);
err = image->write_block(0, buffer);
if (err)
goto done;
/* load fat_partition_create */
fat_partition_create = (imgtoolerr_t (*)(imgtool_image *, UINT64, UINT64))
fat_partition_create = (imgtoolerr_t (*)(imgtool::image *, UINT64, UINT64))
imgtool_get_info_fct(&imgclass, IMGTOOLINFO_PTR_CREATE_PARTITION);
/* actually create the partition */
@ -54,13 +54,13 @@ done:
static imgtoolerr_t fat_image_get_geometry(imgtool_image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
static imgtoolerr_t fat_image_get_geometry(imgtool::image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
{
imgtoolerr_t err;
UINT64 total_sectors;
UINT8 buffer[FAT_SECLEN];
err = imgtool_image_read_block(image, 0, buffer);
err = image->read_block(0, buffer);
if (err)
return err;
@ -75,7 +75,7 @@ static imgtoolerr_t fat_image_get_geometry(imgtool_image *image, UINT32 *tracks,
static imgtoolerr_t fat_get_sector_position(imgtool_image *image, UINT32 sector_index,
static imgtoolerr_t fat_get_sector_position(imgtool::image *image, UINT32 sector_index,
UINT32 *track, UINT32 *head, UINT32 *sector)
{
imgtoolerr_t err;
@ -90,7 +90,7 @@ static imgtoolerr_t fat_get_sector_position(imgtool_image *image, UINT32 sector_
}
else
{
err = imgtool_image_get_geometry(image, &tracks, &heads, &sectors);
err = image->get_geometry(&tracks, &heads, &sectors);
if (err)
return err;
@ -103,14 +103,14 @@ static imgtoolerr_t fat_get_sector_position(imgtool_image *image, UINT32 sector_
static imgtoolerr_t fat_image_readblock(imgtool_image *image, void *buffer, UINT64 block)
static imgtoolerr_t fat_image_readblock(imgtool::image *image, void *buffer, UINT64 block)
{
imgtoolerr_t err;
floperr_t ferr;
UINT32 track, head, sector;
UINT32 block_size;
err = imgtool_image_get_block_size(image, &block_size);
err = image->get_block_size(block_size);
if (err)
return err;
@ -126,14 +126,14 @@ static imgtoolerr_t fat_image_readblock(imgtool_image *image, void *buffer, UINT
static imgtoolerr_t fat_image_writeblock(imgtool_image *image, const void *buffer, UINT64 block)
static imgtoolerr_t fat_image_writeblock(imgtool::image *image, const void *buffer, UINT64 block)
{
imgtoolerr_t err;
floperr_t ferr;
UINT32 track, head, sector;
UINT32 block_size;
err = imgtool_image_get_block_size(image, &block_size);
err = image->get_block_size(block_size);
if (err)
return err;

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

@ -94,14 +94,14 @@ struct pc_chd_image_info
static pc_chd_image_info *pc_chd_get_image_info(imgtool_image *image)
static pc_chd_image_info *pc_chd_get_image_info(imgtool::image *image)
{
return (pc_chd_image_info *) imgtool_image_extra_bytes(image);
return (pc_chd_image_info *) image->extra_bytes();
}
static void pc_chd_locate_block(imgtool_image *image, UINT64 block, UINT32 *cylinder, UINT32 *head, UINT32 *sector)
static void pc_chd_locate_block(imgtool::image *image, UINT64 block, UINT32 *cylinder, UINT32 *head, UINT32 *sector)
{
pc_chd_image_info *info;
const hard_disk_info *hd_info;
@ -116,7 +116,7 @@ static void pc_chd_locate_block(imgtool_image *image, UINT64 block, UINT32 *cyli
static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_index, UINT64 first_block, UINT64 block_count)
static imgtoolerr_t pc_chd_partition_create(imgtool::image *image, int partition_index, UINT64 first_block, UINT64 block_count)
{
imgtoolerr_t err;
UINT8 header_block[FAT_SECLEN];
@ -127,7 +127,7 @@ static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_
UINT32 first_cylinder, first_head, first_sector;
UINT32 last_cylinder, last_head, last_sector;
imgtool_class imgclass = { fat_get_info };
imgtoolerr_t (*fat_partition_create)(imgtool_image *image, UINT64 first_block, UINT64 block_count);
imgtoolerr_t (*fat_partition_create)(imgtool::image *image, UINT64 first_block, UINT64 block_count);
/* sanity checks */
assert((partition_index >= 0) && (partition_index <= 3));
@ -137,7 +137,7 @@ static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_
pc_chd_locate_block(image, first_block + block_count - 1, &last_cylinder, &last_head, &last_sector);
/* load fat_partition_create */
fat_partition_create = (imgtoolerr_t (*)(imgtool_image *, UINT64, UINT64))
fat_partition_create = (imgtoolerr_t (*)(imgtool::image *, UINT64, UINT64))
imgtool_get_info_fct(&imgclass, IMGTOOLINFO_PTR_CREATE_PARTITION);
/* first create the actual partition */
@ -146,7 +146,7 @@ static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_
goto done;
/* read the first block of the partition, to determine the type of FAT */
err = imgtool_image_read_block(image, first_block, partition_block);
err = image->read_block(first_block, partition_block);
if (err)
goto done;
fat_type = &partition_block[54];
@ -162,7 +162,7 @@ static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_
partition_type = 0x0B;
/* read the partition header */
err = imgtool_image_read_block(image, 0, header_block);
err = image->read_block(0, header_block);
if (err)
goto done;
@ -180,7 +180,7 @@ static imgtoolerr_t pc_chd_partition_create(imgtool_image *image, int partition_
place_integer_le(partition_entry, 12, 4, block_count);
/* write the partition header */
err = imgtool_image_write_block(image, 0, header_block);
err = image->write_block(0, header_block);
if (err)
goto done;
@ -190,7 +190,7 @@ done:
static imgtoolerr_t pc_chd_read_partition_header(imgtool_image *image)
static imgtoolerr_t pc_chd_read_partition_header(imgtool::image *image)
{
imgtoolerr_t err;
int i;
@ -201,7 +201,7 @@ static imgtoolerr_t pc_chd_read_partition_header(imgtool_image *image)
info = pc_chd_get_image_info(image);
/* read the initial block */
err = imgtool_image_read_block(image, 0, buffer);
err = image->read_block(0, buffer);
if (err)
return err;
@ -232,7 +232,7 @@ static imgtoolerr_t pc_chd_read_partition_header(imgtool_image *image)
static imgtoolerr_t pc_chd_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *opts)
static imgtoolerr_t pc_chd_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *opts)
{
imgtoolerr_t err;
UINT32 cylinders, heads, sectors;
@ -258,7 +258,7 @@ static imgtoolerr_t pc_chd_image_create(imgtool_image *image, imgtool_stream *f,
memset(header_block, 0, sizeof(header_block));
header_block[510] = 0x55;
header_block[511] = 0xAA;
err = imgtool_image_write_block(image, 0, header_block);
err = image->write_block(0, header_block);
if (err)
goto done;
@ -278,7 +278,7 @@ done:
static imgtoolerr_t pc_chd_image_open(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t pc_chd_image_open(imgtool::image *image, imgtool_stream *stream)
{
imgtoolerr_t err;
pc_chd_image_info *info;
@ -299,7 +299,7 @@ static imgtoolerr_t pc_chd_image_open(imgtool_image *image, imgtool_stream *stre
static void pc_chd_image_close(imgtool_image *image)
static void pc_chd_image_close(imgtool::image *image)
{
pc_chd_image_info *info;
info = pc_chd_get_image_info(image);
@ -308,7 +308,7 @@ static void pc_chd_image_close(imgtool_image *image)
static imgtoolerr_t pc_chd_image_get_geometry(imgtool_image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
static imgtoolerr_t pc_chd_image_get_geometry(imgtool::image *image, UINT32 *tracks, UINT32 *heads, UINT32 *sectors)
{
pc_chd_image_info *info;
const hard_disk_info *hd_info;
@ -340,7 +340,7 @@ static UINT32 pc_chd_calc_lbasector(pc_chd_image_info *info, UINT32 track, UINT3
static imgtoolerr_t pc_chd_image_readsector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
static imgtoolerr_t pc_chd_image_readsector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
{
pc_chd_image_info *info = pc_chd_get_image_info(image);
@ -357,7 +357,7 @@ static imgtoolerr_t pc_chd_image_readsector(imgtool_image *image, UINT32 track,
static imgtoolerr_t pc_chd_image_writesector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam)
static imgtoolerr_t pc_chd_image_writesector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam)
{
pc_chd_image_info *info;
info = pc_chd_get_image_info(image);
@ -368,7 +368,7 @@ static imgtoolerr_t pc_chd_image_writesector(imgtool_image *image, UINT32 track,
static imgtoolerr_t pc_chd_image_readblock(imgtool_image *image, void *buffer, UINT64 block)
static imgtoolerr_t pc_chd_image_readblock(imgtool::image *image, void *buffer, UINT64 block)
{
pc_chd_image_info *info;
info = pc_chd_get_image_info(image);
@ -377,7 +377,7 @@ static imgtoolerr_t pc_chd_image_readblock(imgtool_image *image, void *buffer, U
static imgtoolerr_t pc_chd_image_writeblock(imgtool_image *image, const void *buffer, UINT64 block)
static imgtoolerr_t pc_chd_image_writeblock(imgtool::image *image, const void *buffer, UINT64 block)
{
pc_chd_image_info *info;
info = pc_chd_get_image_info(image);
@ -386,7 +386,7 @@ static imgtoolerr_t pc_chd_image_writeblock(imgtool_image *image, const void *bu
static imgtoolerr_t pc_chd_list_partitions(imgtool_image *image, imgtool_partition_info *partitions, size_t len)
static imgtoolerr_t pc_chd_list_partitions(imgtool::image *image, imgtool_partition_info *partitions, size_t len)
{
pc_chd_image_info *info;
size_t i;

96
src/tools/imgtool/modules/prodos.cpp
View File

@ -135,8 +135,8 @@
struct prodos_diskinfo
{
imgtoolerr_t (*load_block)(imgtool_image *image, int block, void *buffer);
imgtoolerr_t (*save_block)(imgtool_image *image, int block, const void *buffer);
imgtoolerr_t (*load_block)(imgtool::image *image, int block, void *buffer);
imgtoolerr_t (*save_block)(imgtool::image *image, int block, const void *buffer);
UINT8 dirent_size;
UINT8 dirents_per_block;
UINT16 volume_bitmap_block;
@ -265,7 +265,7 @@ static int is_dir_storagetype(UINT8 storage_type)
static prodos_diskinfo *get_prodos_info(imgtool_image *image)
static prodos_diskinfo *get_prodos_info(imgtool::image *image)
{
prodos_diskinfo *info;
info = (prodos_diskinfo *) imgtool_floppy_extrabytes(image);
@ -276,7 +276,7 @@ static prodos_diskinfo *get_prodos_info(imgtool_image *image)
/* ----------------------------------------------------------------------- */
static void prodos_find_block_525(imgtool_image *image, int block,
static void prodos_find_block_525(imgtool::image *image, int block,
UINT32 *track, UINT32 *head, UINT32 *sector1, UINT32 *sector2)
{
static const UINT8 skewing[] =
@ -295,7 +295,7 @@ static void prodos_find_block_525(imgtool_image *image, int block,
static imgtoolerr_t prodos_load_block_525(imgtool_image *image,
static imgtoolerr_t prodos_load_block_525(imgtool::image *image,
int block, void *buffer)
{
floperr_t ferr;
@ -320,7 +320,7 @@ static imgtoolerr_t prodos_load_block_525(imgtool_image *image,
static imgtoolerr_t prodos_save_block_525(imgtool_image *image,
static imgtoolerr_t prodos_save_block_525(imgtool::image *image,
int block, const void *buffer)
{
floperr_t ferr;
@ -345,7 +345,7 @@ static imgtoolerr_t prodos_save_block_525(imgtool_image *image,
static void prodos_setprocs_525(imgtool_image *image)
static void prodos_setprocs_525(imgtool::image *image)
{
prodos_diskinfo *info;
info = get_prodos_info(image);
@ -357,7 +357,7 @@ static void prodos_setprocs_525(imgtool_image *image)
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_find_block_35(imgtool_image *image, int block,
static imgtoolerr_t prodos_find_block_35(imgtool::image *image, int block,
UINT32 *track, UINT32 *head, UINT32 *sector)
{
int sides = 2;
@ -377,7 +377,7 @@ static imgtoolerr_t prodos_find_block_35(imgtool_image *image, int block,
static imgtoolerr_t prodos_load_block_35(imgtool_image *image,
static imgtoolerr_t prodos_load_block_35(imgtool::image *image,
int block, void *buffer)
{
imgtoolerr_t err;
@ -397,7 +397,7 @@ static imgtoolerr_t prodos_load_block_35(imgtool_image *image,
static imgtoolerr_t prodos_save_block_35(imgtool_image *image,
static imgtoolerr_t prodos_save_block_35(imgtool::image *image,
int block, const void *buffer)
{
imgtoolerr_t err;
@ -417,7 +417,7 @@ static imgtoolerr_t prodos_save_block_35(imgtool_image *image,
static void prodos_setprocs_35(imgtool_image *image)
static void prodos_setprocs_35(imgtool::image *image)
{
prodos_diskinfo *info;
info = get_prodos_info(image);
@ -429,7 +429,7 @@ static void prodos_setprocs_35(imgtool_image *image)
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_load_block(imgtool_image *image,
static imgtoolerr_t prodos_load_block(imgtool::image *image,
int block, void *buffer)
{
prodos_diskinfo *diskinfo;
@ -439,7 +439,7 @@ static imgtoolerr_t prodos_load_block(imgtool_image *image,
static imgtoolerr_t prodos_save_block(imgtool_image *image,
static imgtoolerr_t prodos_save_block(imgtool::image *image,
int block, const void *buffer)
{
prodos_diskinfo *diskinfo;
@ -449,7 +449,7 @@ static imgtoolerr_t prodos_save_block(imgtool_image *image,
static imgtoolerr_t prodos_clear_block(imgtool_image *image, int block)
static imgtoolerr_t prodos_clear_block(imgtool::image *image, int block)
{
UINT8 buffer[BLOCK_SIZE];
memset(buffer, 0, sizeof(buffer));
@ -460,7 +460,7 @@ static imgtoolerr_t prodos_clear_block(imgtool_image *image, int block)
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_diskimage_open(imgtool_image *image)
static imgtoolerr_t prodos_diskimage_open(imgtool::image *image)
{
imgtoolerr_t err;
UINT8 buffer[BLOCK_SIZE];
@ -502,7 +502,7 @@ static imgtoolerr_t prodos_diskimage_open(imgtool_image *image)
static imgtoolerr_t prodos_diskimage_open_525(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t prodos_diskimage_open_525(imgtool::image *image, imgtool_stream *stream)
{
prodos_setprocs_525(image);
return prodos_diskimage_open(image);
@ -510,7 +510,7 @@ static imgtoolerr_t prodos_diskimage_open_525(imgtool_image *image, imgtool_stre
static imgtoolerr_t prodos_diskimage_open_35(imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t prodos_diskimage_open_35(imgtool::image *image, imgtool_stream *stream)
{
prodos_setprocs_35(image);
return prodos_diskimage_open(image);
@ -520,7 +520,7 @@ static imgtoolerr_t prodos_diskimage_open_35(imgtool_image *image, imgtool_strea
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_load_volume_bitmap(imgtool_image *image, UINT8 **bitmap)
static imgtoolerr_t prodos_load_volume_bitmap(imgtool::image *image, UINT8 **bitmap)
{
imgtoolerr_t err;
prodos_diskinfo *di;
@ -559,7 +559,7 @@ done:
static imgtoolerr_t prodos_save_volume_bitmap(imgtool_image *image, const UINT8 *bitmap)
static imgtoolerr_t prodos_save_volume_bitmap(imgtool::image *image, const UINT8 *bitmap)
{
imgtoolerr_t err;
prodos_diskinfo *di;
@ -604,7 +604,7 @@ static int prodos_get_volume_bitmap_bit(const UINT8 *buffer, UINT16 block)
static imgtoolerr_t prodos_alloc_block(imgtool_image *image, UINT8 *bitmap,
static imgtoolerr_t prodos_alloc_block(imgtool::image *image, UINT8 *bitmap,
UINT16 *block)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
@ -660,7 +660,7 @@ done:
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_diskimage_create(imgtool_image *image, util::option_resolution *opts)
static imgtoolerr_t prodos_diskimage_create(imgtool::image *image, util::option_resolution *opts)
{
imgtoolerr_t err;
UINT32 heads, tracks, sectors, sector_bytes;
@ -702,7 +702,7 @@ static imgtoolerr_t prodos_diskimage_create(imgtool_image *image, util::option_r
static imgtoolerr_t prodos_diskimage_create_525(imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t prodos_diskimage_create_525(imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
prodos_setprocs_525(image);
return prodos_diskimage_create(image, opts);
@ -710,7 +710,7 @@ static imgtoolerr_t prodos_diskimage_create_525(imgtool_image *image, imgtool_st
static imgtoolerr_t prodos_diskimage_create_35(imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t prodos_diskimage_create_35(imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
prodos_setprocs_35(image);
return prodos_diskimage_create(image, opts);
@ -720,7 +720,7 @@ static imgtoolerr_t prodos_diskimage_create_35(imgtool_image *image, imgtool_str
/* ----------------------------------------------------------------------- */
static imgtoolerr_t prodos_enum_seek(imgtool_image *image,
static imgtoolerr_t prodos_enum_seek(imgtool::image *image,
prodos_direnum *appleenum, UINT32 block, UINT32 index)
{
imgtoolerr_t err;
@ -798,7 +798,7 @@ static UINT8 *alloc_info_block(UINT8 *buffer, size_t block_size, UINT8 block_typ
static imgtoolerr_t prodos_get_next_dirent(imgtool_image *image,
static imgtoolerr_t prodos_get_next_dirent(imgtool::image *image,
prodos_direnum *appleenum, prodos_dirent *ent)
{
imgtoolerr_t err;
@ -908,7 +908,7 @@ static imgtoolerr_t prodos_get_next_dirent(imgtool_image *image,
/* changes a normal file to a ProDOS extended file */
static imgtoolerr_t prodos_promote_file(imgtool_image *image, UINT8 *bitmap, prodos_dirent *ent)
static imgtoolerr_t prodos_promote_file(imgtool::image *image, UINT8 *bitmap, prodos_dirent *ent)
{
imgtoolerr_t err;
UINT16 new_block;
@ -933,7 +933,7 @@ static imgtoolerr_t prodos_promote_file(imgtool_image *image, UINT8 *bitmap, pro
static imgtoolerr_t prodos_put_dirent(imgtool_image *image,
static imgtoolerr_t prodos_put_dirent(imgtool::image *image,
prodos_direnum *appleenum, prodos_dirent *ent)
{
imgtoolerr_t err;
@ -1066,7 +1066,7 @@ static imgtoolerr_t prodos_put_dirent(imgtool_image *image,
static imgtoolerr_t prodos_lookup_path(imgtool_image *image, const char *path,
static imgtoolerr_t prodos_lookup_path(imgtool::image *image, const char *path,
creation_policy_t create, prodos_direnum *direnum, prodos_dirent *ent)
{
imgtoolerr_t err;
@ -1214,7 +1214,7 @@ done:
static imgtoolerr_t prodos_fill_file(imgtool_image *image, UINT8 *bitmap,
static imgtoolerr_t prodos_fill_file(imgtool::image *image, UINT8 *bitmap,
UINT16 key_block, int key_block_allocated,
int depth, UINT32 blockcount, UINT32 block_index)
{
@ -1299,7 +1299,7 @@ static imgtoolerr_t prodos_fill_file(imgtool_image *image, UINT8 *bitmap,
static imgtoolerr_t prodos_set_file_block_count(imgtool_image *image, prodos_direnum *direnum,
static imgtoolerr_t prodos_set_file_block_count(imgtool::image *image, prodos_direnum *direnum,
prodos_dirent *ent, UINT8 *bitmap, int fork_num, UINT32 new_blockcount)
{
imgtoolerr_t err;
@ -1423,7 +1423,7 @@ static imgtoolerr_t prodos_set_file_block_count(imgtool_image *image, prodos_dir
static imgtoolerr_t prodos_set_file_size(imgtool_image *image, prodos_direnum *direnum,
static imgtoolerr_t prodos_set_file_size(imgtool::image *image, prodos_direnum *direnum,
prodos_dirent *ent, int fork_num, UINT32 new_size)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
@ -1489,7 +1489,7 @@ static UINT32 prodos_get_storagetype_maxfilesize(UINT8 storage_type)
static imgtoolerr_t prodos_diskimage_beginenum(imgtool_directory *enumeration, const char *path)
{
imgtoolerr_t err;
imgtool_image *image;
imgtool::image *image;
prodos_direnum *appleenum;
prodos_dirent ent;
UINT16 block = ROOTDIR_BLOCK;
@ -1524,7 +1524,7 @@ static imgtoolerr_t prodos_diskimage_beginenum(imgtool_directory *enumeration, c
static imgtoolerr_t prodos_diskimage_nextenum(imgtool_directory *enumeration, imgtool_dirent *ent)
{
imgtoolerr_t err;
imgtool_image *image;
imgtool::image *image;
prodos_direnum *appleenum;
prodos_dirent pd_ent;
UINT32 max_filesize;
@ -1570,7 +1570,7 @@ static imgtoolerr_t prodos_diskimage_nextenum(imgtool_directory *enumeration, im
static imgtoolerr_t prodos_read_file_tree(imgtool_image *image, UINT32 *filesize,
static imgtoolerr_t prodos_read_file_tree(imgtool::image *image, UINT32 *filesize,
UINT32 block, int nest_level, imgtool_stream *destf)
{
imgtoolerr_t err;
@ -1620,7 +1620,7 @@ static imgtoolerr_t prodos_read_file_tree(imgtool_image *image, UINT32 *filesize
static imgtoolerr_t prodos_write_file_tree(imgtool_image *image, UINT32 *filesize,
static imgtoolerr_t prodos_write_file_tree(imgtool::image *image, UINT32 *filesize,
UINT32 block, int nest_level, imgtool_stream *sourcef)
{
imgtoolerr_t err;
@ -1678,7 +1678,7 @@ static imgtoolerr_t prodos_write_file_tree(imgtool_image *image, UINT32 *filesiz
static imgtoolerr_t prodos_diskimage_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_diskinfo *di;
UINT8 *bitmap = NULL;
UINT16 i;
@ -1707,7 +1707,7 @@ done:
static imgtoolerr_t prodos_diskimage_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
UINT16 key_pointer;
int nest_level;
@ -1747,7 +1747,7 @@ static imgtoolerr_t prodos_diskimage_readfile(imgtool_partition *partition, cons
static imgtoolerr_t prodos_diskimage_writefile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, util::option_resolution *opts)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
UINT64 file_size;
@ -1785,7 +1785,7 @@ static imgtoolerr_t prodos_diskimage_writefile(imgtool_partition *partition, con
static imgtoolerr_t prodos_diskimage_deletefile(imgtool_partition *partition, const char *path)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
@ -1818,7 +1818,7 @@ static imgtoolerr_t prodos_diskimage_deletefile(imgtool_partition *partition, co
static imgtoolerr_t prodos_diskimage_listforks(imgtool_partition *partition, const char *path, imgtool_forkent *ents, size_t len)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
int fork_num = 0;
@ -1854,7 +1854,7 @@ static imgtoolerr_t prodos_diskimage_listforks(imgtool_partition *partition, con
static imgtoolerr_t prodos_diskimage_createdir(imgtool_partition *partition, const char *path)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
@ -1871,7 +1871,7 @@ static imgtoolerr_t prodos_diskimage_createdir(imgtool_partition *partition, con
static imgtoolerr_t prodos_free_directory(imgtool_image *image, UINT8 *volume_bitmap, UINT16 key_pointer)
static imgtoolerr_t prodos_free_directory(imgtool::image *image, UINT8 *volume_bitmap, UINT16 key_pointer)
{
imgtoolerr_t err;
prodos_diskinfo *di;
@ -1912,7 +1912,7 @@ static imgtoolerr_t prodos_free_directory(imgtool_image *image, UINT8 *volume_bi
static imgtoolerr_t prodos_diskimage_deletedir(imgtool_partition *partition, const char *path)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
UINT8 *volume_bitmap = NULL;
@ -1953,7 +1953,7 @@ done:
static imgtoolerr_t prodos_get_file_tree(imgtool_image *image, imgtool_chainent *chain, size_t chain_size,
static imgtoolerr_t prodos_get_file_tree(imgtool::image *image, imgtool_chainent *chain, size_t chain_size,
size_t *chain_pos, UINT16 block, UINT8 total_depth, UINT8 cur_depth)
{
imgtoolerr_t err;
@ -2002,7 +2002,7 @@ static imgtoolerr_t prodos_get_file_tree(imgtool_image *image, imgtool_chainent
static imgtoolerr_t prodos_diskimage_getattrs(imgtool_partition *partition, const char *path, const UINT32 *attrs, imgtool_attribute *values)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
int i;
@ -2065,7 +2065,7 @@ static imgtoolerr_t prodos_diskimage_getattrs(imgtool_partition *partition, cons
static imgtoolerr_t prodos_diskimage_setattrs(imgtool_partition *partition, const char *path, const UINT32 *attrs, const imgtool_attribute *values)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
prodos_direnum direnum;
int i;
@ -2133,7 +2133,7 @@ static imgtoolerr_t prodos_diskimage_setattrs(imgtool_partition *partition, cons
static imgtoolerr_t prodos_diskimage_suggesttransfer(imgtool_partition *partition, const char *path, imgtool_transfer_suggestion *suggestions, size_t suggestions_length)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
mac_filecategory_t file_category = MAC_FILECATEGORY_DATA;
@ -2156,7 +2156,7 @@ static imgtoolerr_t prodos_diskimage_suggesttransfer(imgtool_partition *partitio
static imgtoolerr_t prodos_diskimage_getchain(imgtool_partition *partition, const char *path, imgtool_chainent *chain, size_t chain_size)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
prodos_dirent ent;
size_t chain_pos = 0;
int fork_num;

32
src/tools/imgtool/modules/psion.cpp
View File

@ -385,9 +385,9 @@ UINT16 get_ob3(imgtool_stream *instream, imgtool_stream *outstream, UINT8 type,
return size;
}
static imgtoolerr_t datapack_open( imgtool_image *image, imgtool_stream *stream)
static imgtoolerr_t datapack_open( imgtool::image *image, imgtool_stream *stream)
{
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
psion_pack *pack = (psion_pack*)image->extra_bytes();
char opk_magic[4];
stream_read(stream, opk_magic, 4);
@ -403,9 +403,9 @@ static imgtoolerr_t datapack_open( imgtool_image *image, imgtool_stream *stream)
return IMGTOOLERR_CORRUPTIMAGE;
}
static imgtoolerr_t datapack_create( imgtool_image *image, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t datapack_create( imgtool::image *image, imgtool_stream *stream, util::option_resolution *opts)
{
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
psion_pack *pack = (psion_pack*)image->extra_bytes();
static const UINT8 opk_magic[4] = {'O', 'P', 'K', 0x00};
UINT8 pack_head[8] = {0x40, 0x00, 0x59, 0x01, 0x01, 0x01, 0x00, 0x00};
UINT16 checksum;
@ -440,9 +440,9 @@ static imgtoolerr_t datapack_create( imgtool_image *image, imgtool_stream *strea
return IMGTOOLERR_CORRUPTIMAGE;
}
static void datapack_close( imgtool_image *image)
static void datapack_close( imgtool::image *image)
{
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
psion_pack *pack = (psion_pack*)image->extra_bytes();
stream_close( pack->stream );
}
@ -457,8 +457,8 @@ static imgtoolerr_t datapack_begin_enum(imgtool_directory *enumeration, const ch
static imgtoolerr_t datapack_next_enum(imgtool_directory *enumeration, imgtool_dirent *ent)
{
imgtool_image *image = imgtool_directory_image(enumeration);
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
imgtool::image *image = imgtool_directory_image(enumeration);
psion_pack *pack = (psion_pack*)image->extra_bytes();
psion_iter *iter = (psion_iter*)imgtool_directory_extrabytes(enumeration);
UINT8 data = 0;
@ -498,8 +498,8 @@ static void datapack_close_enum( imgtool_directory *enumeration)
static imgtoolerr_t datapack_free_space( imgtool_partition *partition, UINT64 *size)
{
imgtool_image *image = imgtool_partition_image( partition);
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
imgtool::image *image = imgtool_partition_image( partition);
psion_pack *pack = (psion_pack*)image->extra_bytes();
UINT32 pack_size = 0;
stream_seek(pack->stream, 0x07, SEEK_SET);
@ -513,8 +513,8 @@ static imgtoolerr_t datapack_free_space( imgtool_partition *partition, UINT64 *s
static imgtoolerr_t datapack_read_file(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtool_image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
imgtool::image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)image->extra_bytes();
int index = seek_file_name(pack, filename);
if (index >= 0)
@ -545,8 +545,8 @@ static imgtoolerr_t datapack_read_file(imgtool_partition *partition, const char
static imgtoolerr_t datapack_write_file( imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, util::option_resolution *opts)
{
imgtool_image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
imgtool::image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)image->extra_bytes();
static const UINT8 data_head[4] = {0x02, 0x80, 0x00, 0x00};
UINT8 head[3];
UINT16 size = 0;
@ -607,8 +607,8 @@ static imgtoolerr_t datapack_write_file( imgtool_partition *partition, const cha
static imgtoolerr_t datapack_delete_file( imgtool_partition *partition, const char *filename)
{
imgtool_image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)imgtool_image_extra_bytes(image);
imgtool::image *image = imgtool_partition_image(partition);
psion_pack *pack = (psion_pack*)image->extra_bytes();
int index = seek_file_name(pack, filename);
if (index >= 0)

34
src/tools/imgtool/modules/rsdos.cpp
View File

@ -44,14 +44,14 @@ struct rsdos_direnum
*********************************************************************/
#define MAX_DIRENTS ((18-2)*(256/32))
static floperr_t get_rsdos_dirent(imgtool_image *f, int index_loc, struct rsdos_dirent *ent)
static floperr_t get_rsdos_dirent(imgtool::image *f, int index_loc, struct rsdos_dirent *ent)
{
return floppy_read_sector(imgtool_floppy(f), 0, 17, 3, index_loc * 32, (void *) ent, sizeof(*ent));
}
static floperr_t put_rsdos_dirent(imgtool_image *f, int index_loc, const struct rsdos_dirent *ent)
static floperr_t put_rsdos_dirent(imgtool::image *f, int index_loc, const struct rsdos_dirent *ent)
{
if (index_loc >= MAX_DIRENTS)
return (floperr_t)IMGTOOLERR_FILENOTFOUND;
@ -80,7 +80,7 @@ static void get_dirent_fname(char *fnamebuf, const struct rsdos_dirent *ent)
static imgtoolerr_t lookup_rsdos_file(imgtool_image *f, const char *fname, struct rsdos_dirent *ent, int *position)
static imgtoolerr_t lookup_rsdos_file(imgtool::image *f, const char *fname, struct rsdos_dirent *ent, int *position)
{
int i;
floperr_t ferr;
@ -115,7 +115,7 @@ static imgtoolerr_t lookup_rsdos_file(imgtool_image *f, const char *fname, struc
static UINT8 get_granule_count(imgtool_image *img)
static UINT8 get_granule_count(imgtool::image *img)
{
UINT16 tracks;
UINT16 granules;
@ -128,7 +128,7 @@ static UINT8 get_granule_count(imgtool_image *img)
#define MAX_GRANULEMAP_SIZE 256
/* granule_map must be an array of MAX_GRANULEMAP_SIZE bytes */
static floperr_t get_granule_map(imgtool_image *img, UINT8 *granule_map, UINT8 *granule_count)
static floperr_t get_granule_map(imgtool::image *img, UINT8 *granule_map, UINT8 *granule_count)
{
UINT8 count;
@ -141,7 +141,7 @@ static floperr_t get_granule_map(imgtool_image *img, UINT8 *granule_map, UINT8 *
static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, UINT8 granule_count)
static floperr_t put_granule_map(imgtool::image *img, const UINT8 *granule_map, UINT8 granule_count)
{
return floppy_write_sector(imgtool_floppy(img), 0, 17, 2, 0, granule_map, granule_count, 0); /* TODO: pass ddam argument from imgtool */
}
@ -149,7 +149,7 @@ static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, U
static imgtoolerr_t transfer_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *f, imgtoolerr_t (*proc)(imgtool_image *, int, int, int, int, size_t, imgtool_stream *))
static imgtoolerr_t transfer_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *f, imgtoolerr_t (*proc)(imgtool::image *, int, int, int, int, size_t, imgtool_stream *))
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
UINT8 track, sector;
@ -167,21 +167,21 @@ static imgtoolerr_t transfer_granule(imgtool_image *img, UINT8 granule, int leng
static imgtoolerr_t transfer_from_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *destf)
static imgtoolerr_t transfer_from_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *destf)
{
return transfer_granule(img, granule, length, destf, imgtool_floppy_read_sector_to_stream);
}
static imgtoolerr_t transfer_to_granule(imgtool_image *img, UINT8 granule, int length, imgtool_stream *sourcef)
static imgtoolerr_t transfer_to_granule(imgtool::image *img, UINT8 granule, int length, imgtool_stream *sourcef)
{
return transfer_granule(img, granule, length, sourcef, imgtool_floppy_write_sector_from_stream);
}
static imgtoolerr_t process_rsdos_file(struct rsdos_dirent *ent, imgtool_image *img, imgtool_stream *destf, size_t *size)
static imgtoolerr_t process_rsdos_file(struct rsdos_dirent *ent, imgtool::image *img, imgtool_stream *destf, size_t *size)
{
floperr_t ferr;
size_t s, lastgransize;
@ -270,7 +270,7 @@ static imgtoolerr_t rsdos_diskimage_nextenum(imgtool_directory *enumeration, img
struct rsdos_direnum *rsenum;
struct rsdos_dirent rsent;
char fname[13];
imgtool_image *image;
imgtool::image *image;
image = imgtool_directory_image(enumeration);
rsenum = (struct rsdos_direnum *) imgtool_directory_extrabytes(enumeration);
@ -334,7 +334,7 @@ static imgtoolerr_t rsdos_diskimage_freespace(imgtool_partition *partition, UINT
size_t s = 0;
UINT8 granule_count;
UINT8 granule_map[MAX_GRANULEMAP_SIZE];
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
ferr = get_granule_map(image, granule_map, &granule_count);
if (ferr)
@ -351,7 +351,7 @@ static imgtoolerr_t rsdos_diskimage_freespace(imgtool_partition *partition, UINT
static imgtoolerr_t delete_entry(imgtool_image *img, struct rsdos_dirent *ent, int pos)
static imgtoolerr_t delete_entry(imgtool::image *img, struct rsdos_dirent *ent, int pos)
{
floperr_t ferr;
unsigned char g, i;
@ -391,7 +391,7 @@ static imgtoolerr_t rsdos_diskimage_readfile(imgtool_partition *partition, const
imgtoolerr_t err;
struct rsdos_dirent ent;
size_t size;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
err = lookup_rsdos_file(img, fname, &ent, NULL);
if (err)
@ -413,7 +413,7 @@ static imgtoolerr_t rsdos_diskimage_writefile(imgtool_partition *partition, cons
{
floperr_t ferr;
imgtoolerr_t err;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
struct rsdos_dirent ent, ent2;
size_t i;
UINT64 sz;
@ -517,7 +517,7 @@ static imgtoolerr_t rsdos_diskimage_writefile(imgtool_partition *partition, cons
static imgtoolerr_t rsdos_diskimage_deletefile(imgtool_partition *partition, const char *fname)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
int pos;
struct rsdos_dirent ent;
@ -533,7 +533,7 @@ static imgtoolerr_t rsdos_diskimage_deletefile(imgtool_partition *partition, con
static imgtoolerr_t rsdos_diskimage_suggesttransfer(imgtool_partition *partition, const char *fname, imgtool_transfer_suggestion *suggestions, size_t suggestions_length)
{
imgtoolerr_t err;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
struct rsdos_dirent ent;
int pos;

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

@ -177,9 +177,9 @@ static UINT8* thom_get_sector(thom_floppy* f, unsigned head,
(.fd have 40 or 80 tracks, .qd have 25 tracks) and the file size.
*/
static imgtoolerr_t thom_open_fd_qd(imgtool_image *img, imgtool_stream *stream)
static imgtoolerr_t thom_open_fd_qd(imgtool::image *img, imgtool_stream *stream)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
int size = stream_size( stream );
f->stream = stream;
@ -245,9 +245,9 @@ static imgtoolerr_t thom_open_fd_qd(imgtool_image *img, imgtool_stream *stream)
return IMGTOOLERR_SUCCESS;
}
static void thom_close_fd_qd(imgtool_image *img)
static void thom_close_fd_qd(imgtool::image *img)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
/* save image */
if ( f->modified ) {
@ -308,9 +308,9 @@ static UINT16 thom_sap_crc( UINT8* data, int size )
return crc;
}
static imgtoolerr_t thom_open_sap(imgtool_image *img, imgtool_stream *stream)
static imgtoolerr_t thom_open_sap(imgtool::image *img, imgtool_stream *stream)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
UINT8 buf[262];
f->stream = stream;
@ -371,9 +371,9 @@ static imgtoolerr_t thom_open_sap(imgtool_image *img, imgtool_stream *stream)
return IMGTOOLERR_SUCCESS;
}
static void thom_close_sap(imgtool_image *img)
static void thom_close_sap(imgtool::image *img)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( f->modified ) {
int i, sector, track;
@ -793,20 +793,20 @@ static void thom_put_file(thom_floppy* f, unsigned head,
/********************** module functions ***********************/
static imgtoolerr_t thom_get_geometry(imgtool_image* img, UINT32* tracks,
static imgtoolerr_t thom_get_geometry(imgtool::image* img, UINT32* tracks,
UINT32* heads, UINT32* sectors)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( tracks ) *tracks = f->tracks;
if ( heads ) *heads = f->heads;
if ( sectors ) *sectors = 16;
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t thom_read_sector(imgtool_image* img, UINT32 track,
static imgtoolerr_t thom_read_sector(imgtool::image* img, UINT32 track,
UINT32 head, UINT32 sector, std::vector<UINT8> &buffer)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( head >= f->heads || sector < 1 || sector > 16 || track >= f->tracks )
return IMGTOOLERR_SEEKERROR;
@ -818,11 +818,11 @@ static imgtoolerr_t thom_read_sector(imgtool_image* img, UINT32 track,
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t thom_write_sector(imgtool_image *img, UINT32 track,
static imgtoolerr_t thom_write_sector(imgtool::image *img, UINT32 track,
UINT32 head, UINT32 sector,
const void *buf, size_t len, int ddam)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( stream_isreadonly( f->stream ) ) return IMGTOOLERR_WRITEERROR;
if ( head >= f->heads || sector < 1 || sector > 16 || track >= f->tracks )
return IMGTOOLERR_SEEKERROR;
@ -835,9 +835,9 @@ static imgtoolerr_t thom_write_sector(imgtool_image *img, UINT32 track,
/* returns floopy name */
/* actually, each side has its own name, but we only return the one on side 0.
*/
static void thom_info(imgtool_image *img, char *string, size_t len)
static void thom_info(imgtool::image *img, char *string, size_t len)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
UINT8* base = thom_get_sector( f, 0, 20, 1 );
char buf[9];
memcpy( buf, base, 8 );
@ -848,11 +848,11 @@ static void thom_info(imgtool_image *img, char *string, size_t len)
/* each side of a floppy has its own filesystem, we treat them as'partitions'
*/
static imgtoolerr_t thom_list_partitions(imgtool_image *img,
static imgtoolerr_t thom_list_partitions(imgtool::image *img,
imgtool_partition_info *partitions,
size_t len)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( len >= 1 ) {
partitions[0].get_info = thom_basic_get_info;
partitions[0].base_block = 0;
@ -869,8 +869,8 @@ static imgtoolerr_t thom_list_partitions(imgtool_image *img,
static imgtoolerr_t thom_open_partition(imgtool_partition *part,
UINT64 first_block, UINT64 block_count)
{
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
if ( first_block >= f->heads )
return IMGTOOLERR_INVALIDPARTITION;
* ( (int*) imgtool_partition_extra_bytes( part ) ) = first_block;
@ -891,8 +891,8 @@ static imgtoolerr_t thom_next_enum(imgtool_directory *enumeration,
{
imgtool_partition *part = imgtool_directory_partition( enumeration);
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
int* n = (int*) imgtool_directory_extrabytes( enumeration );
thom_dirent d;
@ -927,8 +927,8 @@ static imgtoolerr_t thom_next_enum(imgtool_directory *enumeration,
static imgtoolerr_t thom_free_space(imgtool_partition *part, UINT64 *size)
{
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
int nb = thom_get_free_blocks( f, head );
(*size) = nb * f->sectuse_size * 8;
return IMGTOOLERR_SUCCESS;
@ -940,8 +940,8 @@ static imgtoolerr_t thom_read_file(imgtool_partition *part,
imgtool_stream *destf)
{
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
thom_dirent d;
char name[9], ext[4], fname[14];
int size;
@ -962,8 +962,8 @@ static imgtoolerr_t thom_delete_file(imgtool_partition *part,
const char *filename)
{
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
thom_dirent d;
char name[9], ext[4], fname[14];
@ -986,8 +986,8 @@ static imgtoolerr_t thom_write_file(imgtool_partition *part,
util::option_resolution *opts)
{
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
thom_dirent d;
int size = stream_size( sourcef );
int blocks = thom_get_free_blocks( f, head );
@ -1069,8 +1069,8 @@ static imgtoolerr_t thom_suggest_transfer(imgtool_partition *part,
size_t suggestions_length)
{
int head = *( (int*) imgtool_partition_extra_bytes( part ) );
imgtool_image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
imgtool::image* img = imgtool_partition_image( part );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
thom_dirent d;
int is_basic = 0;
@ -1106,11 +1106,11 @@ static imgtoolerr_t thom_suggest_transfer(imgtool_partition *part,
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t thom_create(imgtool_image* img,
static imgtoolerr_t thom_create(imgtool::image* img,
imgtool_stream *stream,
util::option_resolution *opts)
{
thom_floppy* f = (thom_floppy*) imgtool_image_extra_bytes( img );
thom_floppy* f = (thom_floppy*) img->extra_bytes();
int i;
UINT8* buf;
const char* name;

74
src/tools/imgtool/modules/ti99.cpp
View File

@ -3848,13 +3848,13 @@ struct win_iterator
};
static imgtoolerr_t dsk_image_init_mess(imgtool_image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_v9t9(imgtool_image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_pc99_fm(imgtool_image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_pc99_mfm(imgtool_image *image, imgtool_stream *f);
static imgtoolerr_t win_image_init(imgtool_image *image, imgtool_stream *f);
static void ti99_image_exit(imgtool_image *img);
static void ti99_image_info(imgtool_image *img, char *string, size_t len);
static imgtoolerr_t dsk_image_init_mess(imgtool::image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_v9t9(imgtool::image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_pc99_fm(imgtool::image *image, imgtool_stream *f);
static imgtoolerr_t dsk_image_init_pc99_mfm(imgtool::image *image, imgtool_stream *f);
static imgtoolerr_t win_image_init(imgtool::image *image, imgtool_stream *f);
static void ti99_image_exit(imgtool::image *img);
static void ti99_image_info(imgtool::image *img, char *string, size_t len);
static imgtoolerr_t dsk_image_beginenum(imgtool_directory *enumeration, const char *path);
static imgtoolerr_t dsk_image_nextenum(imgtool_directory *enumeration, imgtool_dirent *ent);
static imgtoolerr_t win_image_beginenum(imgtool_directory *enumeration, const char *path);
@ -3864,8 +3864,8 @@ static imgtoolerr_t ti99_image_readfile(imgtool_partition *partition, const char
static imgtoolerr_t ti99_image_writefile(imgtool_partition *partition, const char *fpath, const char *fork, imgtool_stream *sourcef, util::option_resolution *writeoptions);
static imgtoolerr_t dsk_image_deletefile(imgtool_partition *partition, const char *fpath);
static imgtoolerr_t win_image_deletefile(imgtool_partition *partition, const char *fpath);
static imgtoolerr_t dsk_image_create_mess(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions);
static imgtoolerr_t dsk_image_create_v9t9(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions);
static imgtoolerr_t dsk_image_create_mess(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions);
static imgtoolerr_t dsk_image_create_v9t9(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions);
enum
{
@ -3995,9 +3995,9 @@ void ti99_ti99hd_get_info(const imgtool_class *imgclass, UINT32 state, union img
/*
Open a file as a ti99_image (common code).
*/
static int dsk_image_init(imgtool_image *img, imgtool_stream *f, ti99_img_format img_format)
static int dsk_image_init(imgtool::image *img, imgtool_stream *f, ti99_img_format img_format)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
dsk_vib vib;
int reply;
int totphysrecs;
@ -4096,7 +4096,7 @@ static int dsk_image_init(imgtool_image *img, imgtool_stream *f, ti99_img_format
/*
Open a file as a ti99_image (MESS format).
*/
static imgtoolerr_t dsk_image_init_mess(imgtool_image *image, imgtool_stream *f)
static imgtoolerr_t dsk_image_init_mess(imgtool::image *image, imgtool_stream *f)
{
return (imgtoolerr_t)dsk_image_init(image, f, if_mess);
}
@ -4104,7 +4104,7 @@ static imgtoolerr_t dsk_image_init_mess(imgtool_image *image, imgtool_stream *f)
/*
Open a file as a ti99_image (V9T9 format).
*/
static imgtoolerr_t dsk_image_init_v9t9(imgtool_image *image, imgtool_stream *f)
static imgtoolerr_t dsk_image_init_v9t9(imgtool::image *image, imgtool_stream *f)
{
return (imgtoolerr_t)dsk_image_init(image, f, if_v9t9);
}
@ -4112,7 +4112,7 @@ static imgtoolerr_t dsk_image_init_v9t9(imgtool_image *image, imgtool_stream *f)
/*
Open a file as a ti99_image (PC99 FM format).
*/
static imgtoolerr_t dsk_image_init_pc99_fm(imgtool_image *image, imgtool_stream *f)
static imgtoolerr_t dsk_image_init_pc99_fm(imgtool::image *image, imgtool_stream *f)
{
return (imgtoolerr_t)dsk_image_init(image, f, if_pc99_fm);
}
@ -4120,7 +4120,7 @@ static imgtoolerr_t dsk_image_init_pc99_fm(imgtool_image *image, imgtool_stream
/*
Open a file as a ti99_image (PC99 MFM format).
*/
static imgtoolerr_t dsk_image_init_pc99_mfm(imgtool_image *image, imgtool_stream *f)
static imgtoolerr_t dsk_image_init_pc99_mfm(imgtool::image *image, imgtool_stream *f)
{
return (imgtoolerr_t)dsk_image_init(image, f, if_pc99_mfm);
}
@ -4128,9 +4128,9 @@ static imgtoolerr_t dsk_image_init_pc99_mfm(imgtool_image *image, imgtool_stream
/*
Open a file as a ti99_image (harddisk format).
*/
static imgtoolerr_t win_image_init(imgtool_image *img, imgtool_stream *f)
static imgtoolerr_t win_image_init(imgtool::image *img, imgtool_stream *f)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
win_vib_ddr vib;
int reply;
int i;
@ -4184,9 +4184,9 @@ static imgtoolerr_t win_image_init(imgtool_image *img, imgtool_stream *f)
/*
close a ti99_image
*/
static void ti99_image_exit(imgtool_image *img)
static void ti99_image_exit(imgtool::image *img)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
close_image_lvl1(&image->l1_img);
}
@ -4196,9 +4196,9 @@ static void ti99_image_exit(imgtool_image *img)
Currently returns the volume name
*/
static void ti99_image_info(imgtool_image *img, char *string, size_t len)
static void ti99_image_info(imgtool::image *img, char *string, size_t len)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
char vol_name[11];
fname_to_str(vol_name, image->vol_name, 11);
@ -4211,7 +4211,7 @@ static void ti99_image_info(imgtool_image *img, char *string, size_t len)
*/
static imgtoolerr_t dsk_image_beginenum(imgtool_directory *enumeration, const char *path)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(imgtool_directory_image(enumeration));
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_directory_image(enumeration)->extra_bytes();
dsk_iterator *iter = (dsk_iterator *) imgtool_directory_extrabytes(enumeration);
iter->image = image;
@ -4336,7 +4336,7 @@ static imgtoolerr_t dsk_image_nextenum(imgtool_directory *enumeration, imgtool_d
*/
static imgtoolerr_t win_image_beginenum(imgtool_directory *enumeration, const char *path)
{
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(imgtool_directory_image(enumeration));
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_directory_image(enumeration)->extra_bytes();
win_iterator *iter = (win_iterator *) imgtool_directory_extrabytes(enumeration);
imgtoolerr_t errorcode;
@ -4480,8 +4480,8 @@ static imgtoolerr_t win_image_nextenum(imgtool_directory *enumeration, imgtool_d
*/
static imgtoolerr_t ti99_image_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtool_image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
size_t freeAUs;
int i;
@ -4504,11 +4504,11 @@ static imgtoolerr_t ti99_image_freespace(imgtool_partition *partition, UINT64 *s
*/
static imgtoolerr_t ti99_image_readfile(imgtool_partition *partition, const char *fpath, const char *fork, imgtool_stream *destf)
{
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
#if 1
/* extract data as TIFILES */
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
ti99_lvl2_fileref src_file;
ti99_lvl2_fileref dst_file;
ti99_date_time date_time;
@ -4595,7 +4595,7 @@ static imgtoolerr_t ti99_image_readfile(imgtool_partition *partition, const char
#else
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
ti99_lvl3_fileref src_file;
UINT8 buf[256];
int reclen;
@ -4646,8 +4646,8 @@ static imgtoolerr_t ti99_image_readfile(imgtool_partition *partition, const char
*/
static imgtoolerr_t ti99_image_writefile(imgtool_partition *partition, const char *fpath, const char *fork, imgtool_stream *sourcef, util::option_resolution *writeoptions)
{
imgtool_image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
const char *filename;
char ti_fname[10];
ti99_lvl2_fileref src_file;
@ -4872,8 +4872,8 @@ static imgtoolerr_t ti99_image_writefile(imgtool_partition *partition, const cha
*/
static imgtoolerr_t dsk_image_deletefile(imgtool_partition *partition, const char *fpath)
{
imgtool_image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
dsk_fdr fdr;
int i, cluster_index;
unsigned cur_AU, cluster_lastfphysrec;
@ -5014,8 +5014,8 @@ static imgtoolerr_t dsk_image_deletefile(imgtool_partition *partition, const cha
static imgtoolerr_t win_image_deletefile(imgtool_partition *partition, const char *fpath)
{
imgtool_image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
struct ti99_lvl2_imgref *image = (struct ti99_lvl2_imgref *) img->extra_bytes();
int parent_ddr_AU, is_dir, catalog_index;
win_fdr fdr;
int i;
@ -5226,7 +5226,7 @@ static imgtoolerr_t win_image_deletefile(imgtool_partition *partition, const cha
Supports MESS and V9T9 formats only
*/
static imgtoolerr_t dsk_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions, ti99_img_format img_format)
static imgtoolerr_t dsk_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions, ti99_img_format img_format)
{
const char *volname;
int density;
@ -5346,7 +5346,7 @@ static imgtoolerr_t dsk_image_create(imgtool_image *image, imgtool_stream *f, ut
/*
Create a blank ti99_image (MESS format).
*/
static imgtoolerr_t dsk_image_create_mess(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions)
static imgtoolerr_t dsk_image_create_mess(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions)
{
return dsk_image_create(image, f, createoptions, if_mess);
}
@ -5354,7 +5354,7 @@ static imgtoolerr_t dsk_image_create_mess(imgtool_image *image, imgtool_stream *
/*
Create a blank ti99_image (V9T9 format).
*/
static imgtoolerr_t dsk_image_create_v9t9(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions)
static imgtoolerr_t dsk_image_create_v9t9(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions)
{
return dsk_image_create(image, f, createoptions, if_v9t9);
}

40
src/tools/imgtool/modules/ti990hd.cpp
View File

@ -386,9 +386,9 @@ struct ti990_iterator
};
static imgtoolerr_t ti990_image_init(imgtool_image *img, imgtool_stream *f);
static void ti990_image_exit(imgtool_image *img);
static void ti990_image_info(imgtool_image *img, char *string, size_t len);
static imgtoolerr_t ti990_image_init(imgtool::image *img, imgtool_stream *f);
static void ti990_image_exit(imgtool::image *img);
static void ti990_image_info(imgtool::image *img, char *string, size_t len);
static imgtoolerr_t ti990_image_beginenum(imgtool_directory *enumeration, const char *path);
static imgtoolerr_t ti990_image_nextenum(imgtool_directory *enumeration, imgtool_dirent *ent);
static void ti990_image_closeenum(imgtool_directory *enumeration);
@ -398,7 +398,7 @@ static imgtoolerr_t ti990_image_readfile(imgtool_partition *partition, const cha
static imgtoolerr_t ti990_image_writefile(imgtool_partition *partition, const char *fpath, imgtool_stream *sourcef, util::option_resolution *writeoptions);
static imgtoolerr_t ti990_image_deletefile(imgtool_partition *partition, const char *fpath);
#endif
static imgtoolerr_t ti990_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions);
static imgtoolerr_t ti990_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions);
enum
{
@ -1106,9 +1106,9 @@ static int qsort_catalog_compare(const void *p1, const void *p2)
/*
Open a file as a ti990_image.
*/
static imgtoolerr_t ti990_image_init(imgtool_image *img, imgtool_stream *f)
static imgtoolerr_t ti990_image_init(imgtool::image *img, imgtool_stream *f)
{
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
ti990_image *image = (ti990_image *) img->extra_bytes();
disk_image_header header;
int reply;
unsigned totsecs;
@ -1162,9 +1162,9 @@ static imgtoolerr_t ti990_image_init(imgtool_image *img, imgtool_stream *f)
/*
close a ti990_image
*/
static void ti990_image_exit(imgtool_image *img)
static void ti990_image_exit(imgtool::image *img)
{
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
ti990_image *image = (ti990_image *) img->extra_bytes();
stream_close(image->file_handle);
}
@ -1173,9 +1173,9 @@ static void ti990_image_exit(imgtool_image *img)
Currently returns the volume name
*/
static void ti990_image_info(imgtool_image *img, char *string, size_t len)
static void ti990_image_info(imgtool::image *img, char *string, size_t len)
{
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
ti990_image *image = (ti990_image *) img->extra_bytes();
char vol_name[9];
fname_to_str(vol_name, image->sec0.vnm, 9);
@ -1188,7 +1188,7 @@ static void ti990_image_info(imgtool_image *img, char *string, size_t len)
*/
static imgtoolerr_t ti990_image_beginenum(imgtool_directory *enumeration, const char *path)
{
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(imgtool_directory_image(enumeration));
ti990_image *image = (ti990_image *) imgtool_directory_image(enumeration)->extra_bytes();
ti990_iterator *iter = (ti990_iterator *) imgtool_directory_extrabytes(enumeration);
ti990_dor dor;
int reply;
@ -1415,8 +1415,8 @@ static void ti990_image_closeenum(imgtool_directory *enumeration)
*/
static imgtoolerr_t ti990_image_freespace(imgtool_partition *partition, UINT64 *size)
{
imgtool_image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) img->extra_bytes();
int totadus = get_UINT16BE(image->sec0.tna);
int adu, record, sub_adu;
char buf[256];
@ -1455,8 +1455,8 @@ static imgtoolerr_t ti990_image_freespace(imgtool_partition *partition, UINT64 *
*/
static imgtoolerr_t ti990_image_readfile(imgtool_partition *partition, const char *fpath, imgtool_stream *destf)
{
imgtool_image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) img->extra_bytes();
int catalog_index, fdr_secnum, parent_fdr_secnum;
imgtoolerr_t reply;
@ -1552,8 +1552,8 @@ static imgtoolerr_t ti990_image_readfile(imgtool_partition *partition, const cha
*/
static imgtoolerr_t ti990_image_writefile(imgtool_partition *partition, const char *fpath, imgtool_stream *sourcef, util::option_resolution *writeoptions)
{
imgtool_image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) img->extra_bytes();
int catalog_index, fdr_secnum, parent_fdr_secnum;
imgtoolerr_t reply;
@ -1676,8 +1676,8 @@ static imgtoolerr_t ti990_image_writefile(imgtool_partition *partition, const ch
*/
static imgtoolerr_t ti990_image_deletefile(imgtool_partition *partition, const char *fpath)
{
imgtool_image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) imgtool_image_extra_bytes(img);
imgtool::image *img = imgtool_partition_image(partition);
ti990_image *image = (ti990_image *) img->extra_bytes();
int catalog_index, fdr_secnum, parent_fdr_secnum;
imgtoolerr_t reply;
@ -1764,7 +1764,7 @@ static imgtoolerr_t ti990_image_deletefile(imgtool_partition *partition, const c
/*
Create a blank ti990_image.
*/
static imgtoolerr_t ti990_image_create(imgtool_image *image, imgtool_stream *f, util::option_resolution *createoptions)
static imgtoolerr_t ti990_image_create(imgtool::image *image, imgtool_stream *f, util::option_resolution *createoptions)
{
//const char *volname;
ti990_geometry geometry;

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

@ -93,7 +93,7 @@ static UINT16 chksum16(UINT8 *buffer, int len)
}
/* returns the offset where the actual sector data starts */
static imgtoolerr_t vzdos_get_data_start(imgtool_image *img, int track, int sector, int *start)
static imgtoolerr_t vzdos_get_data_start(imgtool::image *img, int track, int sector, int *start)
{
imgtoolerr_t ret;
UINT8 buffer[25]; /* enough to read the sector header */
@ -115,7 +115,7 @@ static imgtoolerr_t vzdos_get_data_start(imgtool_image *img, int track, int sect
}
/* return the actual data of a sector */
static imgtoolerr_t vzdos_read_sector_data(imgtool_image *img, int track, int sector, UINT8 *data)
static imgtoolerr_t vzdos_read_sector_data(imgtool::image *img, int track, int sector, UINT8 *data)
{
int ret, data_start;
UINT8 buffer[DATA_SIZE + 4]; /* data + checksum */
@ -136,7 +136,7 @@ static imgtoolerr_t vzdos_read_sector_data(imgtool_image *img, int track, int se
}
/* write data to sector */
static imgtoolerr_t vzdos_write_sector_data(imgtool_image *img, int track, int sector, UINT8 *data)
static imgtoolerr_t vzdos_write_sector_data(imgtool::image *img, int track, int sector, UINT8 *data)
{
int ret, data_start;
UINT8 buffer[DATA_SIZE + 4]; /* data + checksum */
@ -154,7 +154,7 @@ static imgtoolerr_t vzdos_write_sector_data(imgtool_image *img, int track, int s
}
/* write formatted empty sector */
static imgtoolerr_t vzdos_clear_sector(imgtool_image *img, int track, int sector)
static imgtoolerr_t vzdos_clear_sector(imgtool::image *img, int track, int sector)
{
UINT8 data[DATA_SIZE + 2];
@ -164,7 +164,7 @@ static imgtoolerr_t vzdos_clear_sector(imgtool_image *img, int track, int sector
}
/* return a directory entry for an index */
static imgtoolerr_t vzdos_get_dirent(imgtool_image *img, int index, vzdos_dirent *ent)
static imgtoolerr_t vzdos_get_dirent(imgtool::image *img, int index, vzdos_dirent *ent)
{
int ret, entry;
UINT8 buffer[DATA_SIZE + 2];
@ -194,7 +194,7 @@ static imgtoolerr_t vzdos_get_dirent(imgtool_image *img, int index, vzdos_dirent
}
/* save a directory entry to disk */
static imgtoolerr_t vzdos_set_dirent(imgtool_image *img, int index, vzdos_dirent ent)
static imgtoolerr_t vzdos_set_dirent(imgtool::image *img, int index, vzdos_dirent ent)
{
int ret, entry;
UINT8 buffer[DATA_SIZE + 2];
@ -219,7 +219,7 @@ static imgtoolerr_t vzdos_set_dirent(imgtool_image *img, int index, vzdos_dirent
}
/* clear a directory entry */
static imgtoolerr_t vzdos_clear_dirent(imgtool_image *img, int index)
static imgtoolerr_t vzdos_clear_dirent(imgtool::image *img, int index)
{
int ret;
vzdos_dirent entry;
@ -233,7 +233,7 @@ static imgtoolerr_t vzdos_clear_dirent(imgtool_image *img, int index)
}
/* search the index for a directory entry */
static imgtoolerr_t vzdos_searchentry(imgtool_image *image, const char *fname, int *entry) {
static imgtoolerr_t vzdos_searchentry(imgtool::image *image, const char *fname, int *entry) {
int i, len, ret;
vzdos_dirent ent;
char filename[9];
@ -272,7 +272,7 @@ static imgtoolerr_t vzdos_searchentry(imgtool_image *image, const char *fname, i
}
/* return a directory entry for a filename */
static imgtoolerr_t vzdos_get_dirent_fname(imgtool_image *img, const char *fname, vzdos_dirent *ent)
static imgtoolerr_t vzdos_get_dirent_fname(imgtool::image *img, const char *fname, vzdos_dirent *ent)
{
int ret, index;
@ -285,7 +285,7 @@ static imgtoolerr_t vzdos_get_dirent_fname(imgtool_image *img, const char *fname
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t vzdos_toggle_trackmap(imgtool_image *img, int track, int sector, int clear)
static imgtoolerr_t vzdos_toggle_trackmap(imgtool::image *img, int track, int sector, int clear)
{
int ret, value, bit;
UINT8 buffer[DATA_SIZE + 2];
@ -309,19 +309,19 @@ static imgtoolerr_t vzdos_toggle_trackmap(imgtool_image *img, int track, int sec
}
/* clear a trackmap entry */
static imgtoolerr_t vzdos_clear_trackmap(imgtool_image *img, int track, int sector)
static imgtoolerr_t vzdos_clear_trackmap(imgtool::image *img, int track, int sector)
{
return vzdos_toggle_trackmap(img, track, sector, 1);
}
/* enable a trackmap entry */
static imgtoolerr_t vzdos_set_trackmap(imgtool_image *img, int track, int sector)
static imgtoolerr_t vzdos_set_trackmap(imgtool::image *img, int track, int sector)
{
return vzdos_toggle_trackmap(img, track, sector, 0);
}
/* return the status of a trackmap entry */
static imgtoolerr_t vzdos_get_trackmap(imgtool_image *img, int track, int sector, int *used)
static imgtoolerr_t vzdos_get_trackmap(imgtool::image *img, int track, int sector, int *used)
{
int ret, value, bit;
UINT8 buffer[DATA_SIZE + 2];
@ -342,7 +342,7 @@ static imgtoolerr_t vzdos_get_trackmap(imgtool_image *img, int track, int sector
}
/* return the next free sector */
static imgtoolerr_t vzdos_free_trackmap(imgtool_image *img, int *track, int *sector)
static imgtoolerr_t vzdos_free_trackmap(imgtool::image *img, int *track, int *sector)
{
int ret, used = 0;
@ -357,7 +357,7 @@ static imgtoolerr_t vzdos_free_trackmap(imgtool_image *img, int *track, int *sec
return IMGTOOLERR_NOSPACE;
}
static imgtoolerr_t vzdos_write_formatted_sector(imgtool_image *img, int track, int sector)
static imgtoolerr_t vzdos_write_formatted_sector(imgtool::image *img, int track, int sector)
{
int ret;
UINT8 sector_data[DATA_SIZE + 4 + 24];
@ -459,7 +459,7 @@ static imgtoolerr_t vzdos_diskimage_freespace(imgtool_partition *partition, UINT
{
imgtoolerr_t ret;
int i;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
UINT8 c, v, buffer[DATA_SIZE + 2];
*size = 0;
@ -481,7 +481,7 @@ static imgtoolerr_t vzdos_diskimage_freespace(imgtool_partition *partition, UINT
static imgtoolerr_t vzdos_diskimage_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t ret;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
int filesize, track, sector;
vzdos_dirent ent;
UINT8 buffer[DATA_SIZE + 2];
@ -527,7 +527,7 @@ static imgtoolerr_t vzdos_diskimage_readfile(imgtool_partition *partition, const
static imgtoolerr_t vzdos_diskimage_deletefile(imgtool_partition *partition, const char *fname)
{
imgtoolerr_t ret;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
int index, filesize, track, sector, next_track, next_sector;
vzdos_dirent entry, next_entry;
UINT8 buffer[DATA_SIZE + 2];
@ -605,7 +605,7 @@ static imgtoolerr_t vzdos_diskimage_deletefile(imgtool_partition *partition, con
static imgtoolerr_t vzdos_writefile(imgtool_partition *partition, int offset, imgtool_stream *sourcef, vzdos_dirent *entry)
{
imgtoolerr_t ret;
imgtool_image *img = imgtool_partition_image(partition);
imgtool::image *img = imgtool_partition_image(partition);
int index, track, sector, toread, next_track, next_sector;
vzdos_dirent temp_entry;
UINT64 filesize = 0, freespace = 0;
@ -744,7 +744,7 @@ static imgtoolerr_t vzdos_diskimage_writefile(imgtool_partition *partition, cons
static imgtoolerr_t vzdos_diskimage_suggesttransfer(imgtool_partition *partition, const char *fname, imgtool_transfer_suggestion *suggestions, size_t suggestions_length)
{
imgtoolerr_t ret;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
vzdos_dirent entry;
if (fname) {
@ -789,7 +789,7 @@ static imgtoolerr_t vzdos_diskimage_suggesttransfer(imgtool_partition *partition
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t vzdos_diskimage_create(imgtool_image *img, imgtool_stream *stream, util::option_resolution *opts)
static imgtoolerr_t vzdos_diskimage_create(imgtool::image *img, imgtool_stream *stream, util::option_resolution *opts)
{
imgtoolerr_t ret;
int track, sector;
@ -811,7 +811,7 @@ static imgtoolerr_t vzdos_diskimage_create(imgtool_image *img, imgtool_stream *s
static imgtoolerr_t vzsnapshot_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t ret;
imgtool_image *image = imgtool_partition_image(partition);
imgtool::image *image = imgtool_partition_image(partition);
vzdos_dirent entry;
UINT8 header[24];