diff --git a/src/tools/imgtool/iflopimg.cpp b/src/tools/imgtool/iflopimg.cpp index f8a85b17f81..fc0ca620a6e 100644 --- a/src/tools/imgtool/iflopimg.cpp +++ b/src/tools/imgtool/iflopimg.cpp @@ -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 &buffer) +static imgtoolerr_t imgtool_floppy_read_sector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector &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; } diff --git a/src/tools/imgtool/iflopimg.h b/src/tools/imgtool/iflopimg.h index 8e298330845..ba916dccf6e 100644 --- a/src/tools/imgtool/iflopimg.h +++ b/src/tools/imgtool/iflopimg.h @@ -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 */ diff --git a/src/tools/imgtool/imghd.cpp b/src/tools/imgtool/imghd.cpp index 89f543d8185..685774f7107 100644 --- a/src/tools/imgtool/imghd.cpp +++ b/src/tools/imgtool/imghd.cpp @@ -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; diff --git a/src/tools/imgtool/imgtool.cpp b/src/tools/imgtool/imgtool.cpp index a85aa983882..5c7f3996e21 100644 --- a/src/tools/imgtool/imgtool.cpp +++ b/src/tools/imgtool/imgtool.cpp @@ -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 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(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 &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(*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 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; + 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; + 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; } diff --git a/src/tools/imgtool/imgtool.h b/src/tools/imgtool/imgtool.h index 094e4e84e93..ab4d28ab44b 100644 --- a/src/tools/imgtool/imgtool.h +++ b/src/tools/imgtool/imgtool.h @@ -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 &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 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 &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); diff --git a/src/tools/imgtool/library.cpp b/src/tools/imgtool/library.cpp index 2100a26109f..30e84fefb08 100644 --- a/src/tools/imgtool/library.cpp +++ b/src/tools/imgtool/library.cpp @@ -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 &)) 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 &)) 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 &module) { return !strcmp(module->name, module_name); }); + [this, module_name](std::unique_ptr &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() diff --git a/src/tools/imgtool/library.h b/src/tools/imgtool/library.h index 4325d051233..bc8f0753e57 100644 --- a/src/tools/imgtool/library.h +++ b/src/tools/imgtool/library.h @@ -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 &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 &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 &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 &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); diff --git a/src/tools/imgtool/main.cpp b/src/tools/imgtool/main.cpp index 532bdb1230e..1307b389001 100644 --- a/src/tools/imgtool/main.cpp +++ b/src/tools/imgtool/main.cpp @@ -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 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 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 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 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 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 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 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 img; imgtool_stream *stream = nullptr; std::vector 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 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; diff --git a/src/tools/imgtool/modules/amiga.cpp b/src/tools/imgtool/modules/amiga.cpp index 9b6a3697c91..cdccbd36c79 100644 --- a/src/tools/imgtool/modules/amiga.cpp +++ b/src/tools/imgtool/modules/amiga.cpp @@ -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 &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, §or); + find_block((amiga_floppy *) img->extra_bytes(), block, &track, &head, §or); /* 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, §or); + find_block((amiga_floppy *)img->extra_bytes(), block, &track, &head, §or); /* 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 &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 */ diff --git a/src/tools/imgtool/modules/bml3.cpp b/src/tools/imgtool/modules/bml3.cpp index 80048fc340f..62c090eb6a2 100644 --- a/src/tools/imgtool/modules/bml3.cpp +++ b/src/tools/imgtool/modules/bml3.cpp @@ -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, §or); @@ -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, §or); @@ -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; diff --git a/src/tools/imgtool/modules/concept.cpp b/src/tools/imgtool/modules/concept.cpp index debbb631196..857cbf075ed 100644 --- a/src/tools/imgtool/modules/concept.cpp +++ b/src/tools/imgtool/modules/concept.cpp @@ -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; diff --git a/src/tools/imgtool/modules/cybiko.cpp b/src/tools/imgtool/modules/cybiko.cpp index a90f9daa745..b71f8f16014 100644 --- a/src/tools/imgtool/modules/cybiko.cpp +++ b/src/tools/imgtool/modules/cybiko.cpp @@ -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; diff --git a/src/tools/imgtool/modules/cybikoxt.cpp b/src/tools/imgtool/modules/cybikoxt.cpp index 661a9e651cf..c4d9899c31c 100644 --- a/src/tools/imgtool/modules/cybikoxt.cpp +++ b/src/tools/imgtool/modules/cybikoxt.cpp @@ -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; diff --git a/src/tools/imgtool/modules/fat.cpp b/src/tools/imgtool/modules/fat.cpp index ad75a206193..55641a02ba1 100644 --- a/src/tools/imgtool/modules/fat.cpp +++ b/src/tools/imgtool/modules/fat.cpp @@ -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, §ors_per_track); + err = image->get_geometry(&tracks, &heads, §ors_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; } diff --git a/src/tools/imgtool/modules/hp48.cpp b/src/tools/imgtool/modules/hp48.cpp index f73459c3bfd..a7790497897 100644 --- a/src/tools/imgtool/modules/hp48.cpp +++ b/src/tools/imgtool/modules/hp48.cpp @@ -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 */ diff --git a/src/tools/imgtool/modules/hp9845_tape.cpp b/src/tools/imgtool/modules/hp9845_tape.cpp index 3f4dc7d9429..858d8e8ae88 100644 --- a/src/tools/imgtool/modules/hp9845_tape.cpp +++ b/src/tools/imgtool/modules/hp9845_tape.cpp @@ -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); diff --git a/src/tools/imgtool/modules/mac.cpp b/src/tools/imgtool/modules/mac.cpp index c249127c753..a8a90e133a4 100644 --- a/src/tools/imgtool/modules/mac.cpp +++ b/src/tools/imgtool/modules/mac.cpp @@ -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; diff --git a/src/tools/imgtool/modules/macbin.cpp b/src/tools/imgtool/modules/macbin.cpp index 5f6f362d030..849f9a98aa0 100644 --- a/src/tools/imgtool/modules/macbin.cpp +++ b/src/tools/imgtool/modules/macbin.cpp @@ -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; diff --git a/src/tools/imgtool/modules/os9.cpp b/src/tools/imgtool/modules/os9.cpp index 0e165f6d881..393feccf915 100644 --- a/src/tools/imgtool/modules/os9.cpp +++ b/src/tools/imgtool/modules/os9.cpp @@ -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; diff --git a/src/tools/imgtool/modules/pc_flop.cpp b/src/tools/imgtool/modules/pc_flop.cpp index a958151c5db..9a00e393c22 100644 --- a/src/tools/imgtool/modules/pc_flop.cpp +++ b/src/tools/imgtool/modules/pc_flop.cpp @@ -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, §ors); + err = image->get_geometry(&tracks, &heads, §ors); 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; diff --git a/src/tools/imgtool/modules/pc_hard.cpp b/src/tools/imgtool/modules/pc_hard.cpp index 8f83902158b..9c7eaafea33 100644 --- a/src/tools/imgtool/modules/pc_hard.cpp +++ b/src/tools/imgtool/modules/pc_hard.cpp @@ -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 &buffer) +static imgtoolerr_t pc_chd_image_readsector(imgtool::image *image, UINT32 track, UINT32 head, UINT32 sector, std::vector &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; diff --git a/src/tools/imgtool/modules/prodos.cpp b/src/tools/imgtool/modules/prodos.cpp index ffd2b377819..5ce8159f251 100644 --- a/src/tools/imgtool/modules/prodos.cpp +++ b/src/tools/imgtool/modules/prodos.cpp @@ -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; diff --git a/src/tools/imgtool/modules/psion.cpp b/src/tools/imgtool/modules/psion.cpp index 3fcd398d30e..05687e4aca5 100644 --- a/src/tools/imgtool/modules/psion.cpp +++ b/src/tools/imgtool/modules/psion.cpp @@ -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) diff --git a/src/tools/imgtool/modules/rsdos.cpp b/src/tools/imgtool/modules/rsdos.cpp index 823e3d98339..cc08e1da682 100644 --- a/src/tools/imgtool/modules/rsdos.cpp +++ b/src/tools/imgtool/modules/rsdos.cpp @@ -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; diff --git a/src/tools/imgtool/modules/thomson.cpp b/src/tools/imgtool/modules/thomson.cpp index 0b8875408bf..50b56507bca 100644 --- a/src/tools/imgtool/modules/thomson.cpp +++ b/src/tools/imgtool/modules/thomson.cpp @@ -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 &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; diff --git a/src/tools/imgtool/modules/ti99.cpp b/src/tools/imgtool/modules/ti99.cpp index 57b58ea75b1..d50826e6c7f 100644 --- a/src/tools/imgtool/modules/ti99.cpp +++ b/src/tools/imgtool/modules/ti99.cpp @@ -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); } diff --git a/src/tools/imgtool/modules/ti990hd.cpp b/src/tools/imgtool/modules/ti990hd.cpp index 195606e720a..bd8bc2063fb 100644 --- a/src/tools/imgtool/modules/ti990hd.cpp +++ b/src/tools/imgtool/modules/ti990hd.cpp @@ -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; diff --git a/src/tools/imgtool/modules/vzdos.cpp b/src/tools/imgtool/modules/vzdos.cpp index db0d056e10d..7f7eae8ab9b 100644 --- a/src/tools/imgtool/modules/vzdos.cpp +++ b/src/tools/imgtool/modules/vzdos.cpp @@ -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];