From 264e8d5f662c8b902c0614c4e81235c77d34443d Mon Sep 17 00:00:00 2001 From: "Thomas \"Cakeisalie5\" Touhey" Date: Thu, 13 Apr 2017 00:18:10 +0200 Subject: [PATCH] Namespace, started correcting CAS set managing --- Makefile.vars | 2 +- include/libg1m.h | 126 ++++++++++++++------------- include/libg1m/bcd.h | 53 +++++------ include/libg1m/buffer.h | 82 ++++++++++-------- include/libg1m/eact.h | 16 ++-- include/libg1m/file.h | 9 +- include/libg1m/format.h | 20 ++++- include/libg1m/format/cas.h | 9 +- include/libg1m/format/std.h | 2 +- include/libg1m/handle.h | 66 +++++++++----- include/libg1m/internals.h | 21 +++-- include/libg1m/mcs.h | 88 ++++++++++--------- src/bcd/cas.c | 80 +++++++++-------- src/bcd/double.c | 6 +- src/bcd/mcs.c | 68 ++++++++------- src/bcd/str.c | 2 +- src/core/free.c | 14 +-- src/core/version.c | 4 +- src/decode/cas.c | 164 +++++++++++++---------------------- src/decode/cas/cell.c | 26 +++--- src/decode/cas/program.c | 48 ++-------- src/decode/cas/screenshot.c | 8 +- src/decode/casemul.c | 70 +++++++-------- src/decode/main.c | 11 ++- src/decode/mcs.c | 23 ++--- src/decode/mcs/cells.c | 31 +++---- src/decode/mcs/picture.c | 32 ++++--- src/decode/mcs/program.c | 15 ++-- src/decode/mcs/setup.c | 22 ++--- src/decode/mcs/spreadsheet.c | 21 +++-- src/decode/mcs/string.c | 2 +- src/decode/mcs/var.c | 14 +-- src/decode/std/addin.c | 76 +++++++++------- src/decode/std/eact.c | 59 ++++++------- src/decode/std/fkey.c | 22 ++--- src/decode/std/lang.c | 20 +++-- src/decode/std/mcs.c | 9 +- src/decode/std/picture.c | 4 +- src/encode/addin.c | 15 ++-- src/encode/main.c | 18 ++-- src/encode/mcs.c | 19 ++-- src/encode/mcs/cells.c | 36 ++++---- src/encode/mcs/program.c | 9 +- src/encode/mcs/var.c | 12 +-- src/manage/handle.c | 154 ++++++++++++++++---------------- src/manage/mcs.c | 73 +++++++++------- src/manage/mcsfile.c | 122 ++++++++++++-------------- src/type/cas/app.c | 8 +- src/type/cas/datatype.c | 21 ++--- src/type/mcs.c | 52 +++++------ src/utils/buffer.c | 16 ++-- src/utils/file.c | 8 +- src/utils/skip.c | 5 +- src/utils/version.c | 32 +++++-- 54 files changed, 1005 insertions(+), 940 deletions(-) diff --git a/Makefile.vars b/Makefile.vars index 9bf01da..8d641c8 100755 --- a/Makefile.vars +++ b/Makefile.vars @@ -92,7 +92,7 @@ endif # - Specific linker flags LDFLAGS_Windows := -lws2_32 -Wl,--out-implib,lib$(NAME).dll.a LDFLAGS_Linux := $(if $(STATIC),,-Wl,-soname,$(SONAME) \ - -e __lib$(NAME)_version \ + -e $(NAME)__version \ -Wl,-z,relro -Wl,-z,combreloc -Wl,-z,defs) # - Linker flags LDFLAGS := $(if $(STATIC),,-shared) \ diff --git a/include/libg1m.h b/include/libg1m.h index 2324d6d..2880cf2 100644 --- a/include/libg1m.h +++ b/include/libg1m.h @@ -80,112 +80,118 @@ extern const char *g1m_error_strings[]; /* Main functions */ /* ************************************************************************** */ /* open and free a handle */ -extern int g1m_decode(g1m_handle_t **handle, const char *path, - g1m_buffer_t *buffer, g1m_type_t allowed_types); -extern void g1m_free(g1m_handle_t *handle); +extern int g1m_decode(g1m_handle_t **g1m_arg_handle, const char *g1m_arg_path, + g1m_buffer_t *g1m_arg_buffer, g1m_type_t g1m_arg_allowed_types); +extern void g1m_free(g1m_handle_t *g1m_arg_handle); /* open a handle using FILEs */ #ifndef G1M_DISABLED_FILE -extern int g1m_open(g1m_handle_t **handle, const char *path, - g1m_type_t allowed_types); -extern int g1m_fopen(g1m_handle_t **handle, const char *path, FILE *stream, - g1m_type_t allowed_types); +extern int g1m_open(g1m_handle_t **g1m_arg_handle, const char *g1m_arg_path, + g1m_type_t g1m_arg_allowed_types); +extern int g1m_fopen(g1m_handle_t **g1m_arg_handle, const char *g1m_arg_path, + FILE *g1m_arg_stream, g1m_type_t g1m_arg_allowed_types); #endif /* Make a handle */ -extern int g1m_make_mcs(g1m_handle_t **handle, int count); -extern int g1m_make_fkey(g1m_handle_t **handle, g1m_platform_t platform, - int count); -extern int g1m_make_lang(g1m_handle_t **handle, g1m_platform_t platform, - int count); -extern int g1m_make_picture(g1m_handle_t **handle, - unsigned int width, unsigned int height); -extern int g1m_make_addin(g1m_handle_t **h, g1m_platform_t platform, - size_t size, const char *name, const char *internal_name, - const g1m_version_t *version, const time_t *created); +extern int g1m_make_mcs(g1m_handle_t **g1m_arg_handle, int g1m_arg_count); +extern int g1m_make_fkey(g1m_handle_t **g1m_arg_handle, + g1m_platform_t g1m_arg_platform, int g1m_arg_count); +extern int g1m_make_lang(g1m_handle_t **g1m_arg_handle, + g1m_platform_t g1m_arg_platform, int g1m_arg_count); +extern int g1m_make_picture(g1m_handle_t **g1m_arg_handle, + unsigned int g1m_arg_width, unsigned int g1m_arg_height); +extern int g1m_make_addin(g1m_handle_t **g1m_arg_handle, + g1m_platform_t g1m_arg_platform, size_t g1m_arg_size, + const char *g1m_arg_name, const char *g1m_arg_internal_name, + const g1m_version_t *g1m_arg_version, const time_t *g1m_arg_created); /* encode a handle, get the extension */ -extern int g1m_encode(g1m_handle_t *handle, g1m_buffer_t *buffer); +extern int g1m_encode(g1m_handle_t *g1m_arg_handle, + g1m_buffer_t *g1m_arg_buffer); /* put into a FILE */ #ifndef G1M_DISABLED_FILE -extern int g1m_write(g1m_handle_t *handle, const char *path); -extern int g1m_fwrite(g1m_handle_t *handle, FILE *stream); +extern int g1m_write(g1m_handle_t *g1m_arg_handle, const char *g1m_arg_path); +extern int g1m_fwrite(g1m_handle_t *g1m_arg_handle, FILE *g1m_arg_stream); #endif /* ************************************************************************** */ /* Main MCS functions */ /* ************************************************************************** */ /* make an MCS file out of a head */ -extern int g1m_make_mcsfile(g1m_mcsfile_t **handle, - const g1m_mcshead_t *rawhead); -extern int g1m_prepare_mcsfile_heads(g1m_mcshead_t *head, - g1m_mcshead_t *heads); -extern void g1m_free_mcsfile(g1m_mcsfile_t *handle); +extern int g1m_make_mcsfile(g1m_mcsfile_t **g1m_arg_handle, + const g1m_mcshead_t *g1m_arg_rawhead); +extern void g1m_free_mcsfile(g1m_mcsfile_t *g1m_arg_handle); /* open MCS head for decoding, correct it for encoding */ -extern int g1m_decode_mcsfile_head(g1m_mcshead_t *head, - int raw_type, const unsigned char *groupname, - const unsigned char *dirname, const unsigned char *filename, - uint_fast32_t filesize); -int g1m_correct_mcsfile_head(g1m_mcshead_t *head); +extern int g1m_decode_mcsfile_head(g1m_mcshead_t *g1m_arg_head, + int g1m_arg_raw, const unsigned char *g1m_arg_group, + const unsigned char *g1m_arg_dirname, const unsigned char *g1m_arg_filename, + uint_fast32_t g1m_arg_filesize); +int g1m_correct_mcsfile_head(g1m_mcshead_t *g1m_arg_head); /* open and decode MCS file */ -extern int g1m_decode_mcsfile(g1m_mcsfile_t **handle, - const g1m_mcshead_t *head, g1m_buffer_t *buffer); -extern int g1m_decode_mcsfile_data(g1m_mcsfile_t **handle, - const g1m_mcshead_t *head, const unsigned char *data, size_t size); +extern int g1m_decode_mcsfile(g1m_mcsfile_t **g1m_arg_handle, + const g1m_mcshead_t *g1m_arg_head, g1m_buffer_t *g1m_arg_buffer); +extern int g1m_decode_mcsfile_data(g1m_mcsfile_t **g1m_arg_handle, + const g1m_mcshead_t *g1m_arg_head, const unsigned char *g1m_arg_data, + size_t g1m_arg_size); /* encode an MCS file */ -extern int g1m_encode_mcsfile(g1m_mcsfile_t *handle, g1m_buffer_t *buffer); +extern int g1m_encode_mcsfile(g1m_mcsfile_t *g1m_arg_handle, + g1m_buffer_t *g1m_arg_buffer); # define g1m_announce_mcsfile(handle, size) \ (g1m_encode_mcsfile(handle, (g1m_buffer_t[]){{ \ .cookie = (size_t*)size, .announce = g1m_announce_callback }})) /* open CAS head for decoding, correct it for encoding */ -extern int g1m_decode_casfile_head(g1m_mcshead_t *head, g1m_buffer_t *buffer); -extern int g1m_decode_casfiles_part(g1m_mcshead_t *head, g1m_mcshead_t *heads, - g1m_buffer_t *buffer); -extern int g1m_decode_casfile_part(g1m_mcsfile_t *file, g1m_buffer_t *buffer); -extern int g1m_correct_casfile_head(g1m_mcshead_t *head); +extern int g1m_decode_casfile_head(g1m_mcshead_t *g1m_arg_head, + g1m_buffer_t *g1m_arg_buffer); +extern int g1m_decode_casfile_part(g1m_mcsfile_t *g1m_arg_file, + g1m_buffer_t *g1m_arg_buffer); +extern int g1m_correct_casfile_head(g1m_mcshead_t *g1m_arg_head); /* announce, encode a CAS head */ -extern int g1m_encode_casfile_head(g1m_mcshead_t *head, g1m_buffer_t *buffer); -extern int g1m_encode_casfile_part(g1m_mcsfile_t *file, g1m_buffer_t *buffer); +extern int g1m_encode_casfile_head(g1m_mcshead_t *g1m_arg_head, + g1m_buffer_t *g1m_arg_buffer); +extern int g1m_encode_casfile_part(g1m_mcsfile_t *g1m_arg_file, + g1m_buffer_t *g1m_arg_buffer); /* ************************************************************************** */ /* MCS archive management */ /* ************************************************************************** */ /* create and insert an MCS file into a MCS archive */ -extern int g1m_mcs_insert(g1m_handle_t *handle, g1m_mcsfile_t **tofile, - const g1m_mcshead_t *head); +extern int g1m_mcs_insert(g1m_handle_t *g1m_arg_handle, + g1m_mcsfile_t **g1m_arg_tofile, const g1m_mcshead_t *g1m_arg_head); /* sort an MCS archive for encoding, * compare two MCS files (utility function used by the first) */ -extern int g1m_mcs_sort(g1m_handle_t *handle); -extern int g1m_compare_mcsfiles(const g1m_mcsfile_t *first_file, - const g1m_mcsfile_t *second_file); +extern int g1m_mcs_sort(g1m_handle_t *g1m_arg_handle); +extern int g1m_compare_mcsfiles(const g1m_mcsfile_t *g1m_arg_first_file, + const g1m_mcsfile_t *g1m_arg_second_file); /* ************************************************************************** */ /* Miscallaneous utilities */ /* ************************************************************************** */ /* Picture decoding/encoding */ -extern int g1m_decode_picture(uint32_t **pixels, - g1m_pictureformat_t format, const unsigned char *raw, - unsigned int width, unsigned int height); -extern int g1m_encode_picture(const uint32_t **pixels, - g1m_pictureformat_t format, unsigned char *raw, - unsigned int width, unsigned int height); +extern int g1m_decode_picture(uint32_t **g1m_arg_pixels, + g1m_pictureformat_t g1m_arg_format, const unsigned char *g1m_arg_raw, + unsigned int g1m_arg_width, unsigned int g1m_arg_height); +extern int g1m_encode_picture(const uint32_t **g1m_arg_pixels, + g1m_pictureformat_t g1m_arg_format, unsigned char *g1m_arg_raw, + unsigned int g1m_arg_width, unsigned int g1m_arg_height); /* Version decoding/encoding */ -extern int g1m_check_version(const char *raw); -extern int g1m_decode_version(const char *raw, g1m_version_t *version); -extern int g1m_encode_version(const g1m_version_t *version, char *raw); +extern int g1m_check_version(const char *g1m_arg_raw); +extern int g1m_decode_version(const char *g1m_arg_raw, + g1m_version_t *g1m_arg_version); +extern int g1m_encode_version(const g1m_version_t *g1m_arg_version, + char *g1m_arg_raw); /* Date decoding/encoding */ -extern int g1m_check_date(const char *raw); -extern int g1m_decode_date(const char *raw, time_t *date); -extern int g1m_encode_date(const time_t *date, char *raw); +extern int g1m_check_date(const char *g1m_arg_raw); +extern int g1m_decode_date(const char *g1m_arg_raw, time_t *g1m_arg_date); +extern int g1m_encode_date(const time_t *g1m_arg_date, char *g1m_arg_raw); /* Announce callback that just contributes to a size_t. */ -extern int g1m_announce_callback(void *cookie, size_t size); +extern int g1m_announce_callback(void *g1m_arg_cookie, size_t g1m_arg_size); # ifdef __cplusplus } diff --git a/include/libg1m/bcd.h b/include/libg1m/bcd.h index 14fb413..d9441df 100644 --- a/include/libg1m/bcd.h +++ b/include/libg1m/bcd.h @@ -60,18 +60,18 @@ extern "C" { # define g1m_bcdflag_neg 0x40 # define g1m_bcdmask_pre 0x3F -# define g1m_bcd_has_special(B) ((B)->flags & g1m_bcdflag_spe) -# define g1m_bcd_is_negative(B) ((B)->flags & g1m_bcdflag_neg) -# define g1m_bcd_precision(B) ((B)->flags & g1m_bcdmask_pre) -# define g1m_bcd_exponent(B) ((B)->exp) +# define g1m_bcd_has_special(B) ((B)->g1m_bcd_flags & g1m_bcdflag_spe) +# define g1m_bcd_is_negative(B) ((B)->g1m_bcd_flags & g1m_bcdflag_neg) +# define g1m_bcd_precision(B) ((B)->g1m_bcd_flags & g1m_bcdmask_pre) +# define g1m_bcd_exponent(B) ((B)->g1m_bcd_exp) # define g1m_make_bcdflags(SPE, NEG, PREC) \ (((SPE) << 7) | ((NEG) << 6) | (PREC)) typedef struct g1m_bcd_s { - unsigned char flags; char exp; - char mant[G1M_BCD_MANTISSA_SIZE]; + unsigned char g1m_bcd_flags; + char g1m_bcd_exp; + char g1m_bcd_mant[G1M_BCD_MANTISSA_SIZE]; } g1m_bcd_t; - /* ************************************************************************** */ /* Raw formats */ /* ************************************************************************** */ @@ -85,14 +85,14 @@ typedef struct g1m_bcd_s { * The negative is two bits/flags (I don't know why). * `g1m_casbcd_pow_neg`, if there, means the power is negative. */ -# define g1m_casbcd_special 0x80 -# define g1m_casbcd_negative 0x50 -# define g1m_casbcd_pow_neg 0x01 -typedef struct cas_bcd { - unsigned char mantissa[8]; - unsigned char signinfo; - unsigned char exponent; -} cas_bcd_t; +# define g1m_casbcdflag_special 0x80 +# define g1m_casbcdflag_negative 0x50 +# define g1m_casbcdflag_pow_neg 0x01 +typedef struct g1m_casbcd_s { + unsigned char g1m_casbcd_mant[8]; + unsigned char g1m_casbcd_flags; + unsigned char g1m_casbcd_exp; +} g1m_casbcd_t; /* MCS BCD -- the most recent BCD format. * Only the first 9 bytes are significant. @@ -106,27 +106,28 @@ typedef struct cas_bcd { * The other values (from the fourth nibble) are the packed BCD mantissa. * It starts at 10^0. */ -typedef struct bcd { - unsigned char BCDval[9]; - unsigned char _align[3]; -} mcs_bcd_t; +typedef struct g1m_mcsbcd_s { + unsigned char g1m_mcsbcd_BCDval[9]; + unsigned char g1m_mcsbcd__align[3]; +} g1m_mcsbcd_t; /* ************************************************************************** */ /* Conversion utilities */ /* ************************************************************************** */ /* From and to MCS BCD. */ -int g1m_bcd_frommcs(const mcs_bcd_t *raw, g1m_bcd_t *bcd); -void g1m_bcd_tomcs(const g1m_bcd_t *bcd, mcs_bcd_t *raw); +int g1m_bcd_frommcs(const g1m_mcsbcd_t *g1m_arg_raw, g1m_bcd_t *g1m_arg_bcd); +void g1m_bcd_tomcs(const g1m_bcd_t *g1m_arg_bcd, g1m_mcsbcd_t *g1m_arg_raw); /* From and to CAS BCD. */ -int g1m_bcd_fromcas(const cas_bcd_t *raw, g1m_bcd_t *bcd); -void g1m_bcd_tocas(const g1m_bcd_t *bcd, cas_bcd_t *raw); +int g1m_bcd_fromcas(const g1m_casbcd_t *g1m_arg_raw, g1m_bcd_t *g1m_arg_bcd); +void g1m_bcd_tocas(const g1m_bcd_t *g1m_arg_bcd, g1m_casbcd_t *g1m_arg_raw); /* From and to C-double */ -void g1m_bcd_fromdouble(double dbl, g1m_bcd_t *bcd); -double g1m_bcd_todouble(const g1m_bcd_t *bcd); +void g1m_bcd_fromdouble(double g1m_arg_dbl, g1m_bcd_t *g1m_arg_bcd); +double g1m_bcd_todouble(const g1m_bcd_t *g1m_arg_bcd); /* Make a string out of a BCD */ -size_t g1m_bcdtoa(const g1m_bcd_t *bcd, char *buf, size_t len); +size_t g1m_bcdtoa(const g1m_bcd_t *g1m_arg_bcd, char *g1m_arg_buf, + size_t g1m_arg_len); # ifdef __cplusplus } diff --git a/include/libg1m/buffer.h b/include/libg1m/buffer.h index 1d54f68..64528d4 100644 --- a/include/libg1m/buffer.h +++ b/include/libg1m/buffer.h @@ -17,7 +17,17 @@ * along with libg1m; if not, see . * * This interface is there so you can use a custom buffer for the library - * to read. There are two use cases: + * to read. + * ************************************************************************** */ +#ifndef LIBG1M_BUFFER_H +# define LIBG1M_BUFFER_H +# include +# include + +/* ************************************************************************** */ +/* General definition */ +/* ************************************************************************** */ +/* There are two use cases: * - you want to read data: the `size` of the element to read should be set, * and the `read` callback will be used; * - you want to receive data: if the `announce` callback is set, it will be @@ -28,77 +38,77 @@ * will be called in order to free any allocated buffer. * * In each case, the `cookie` is sent as the first argument to your callbacks. - * ************************************************************************** */ -#ifndef LIBG1M_BUFFER_H -# define LIBG1M_BUFFER_H -# include -# include + * Here are their types: */ -/* ************************************************************************** */ -/* General definition */ -/* ************************************************************************** */ -/* The callbacks types... */ typedef int (*g1m_buffer_read_t)(void*, unsigned char*, size_t); typedef int (*g1m_buffer_write_t)(void*, const unsigned char*, size_t); typedef int (*g1m_buffer_announce_t)(void*, size_t); typedef void (*g1m_buffer_unannounce_t)(void*); -/* ... and the structure of a buffer. */ -typedef struct { - void *cookie; - size_t _offset; +/* ... and the structure of a buffer: */ - g1m_buffer_read_t read; - g1m_buffer_write_t write; - g1m_buffer_announce_t announce; - g1m_buffer_unannounce_t unannounce; +typedef struct { + void *g1m_buffer_cookie; + size_t g1m_buffer_offset; + + /* callbacks */ + g1m_buffer_read_t g1m_buffer_read; + g1m_buffer_write_t g1m_buffer_write; + g1m_buffer_announce_t g1m_buffer_announce; + g1m_buffer_unannounce_t g1m_buffer_unannounce; } g1m_buffer_t; /* ************************************************************************** */ /* File buffer definition */ /* ************************************************************************** */ /* Callbacks (the cookie is the FILE* pointer) */ -extern int g1m_filebuffer_read(void *vcookie, unsigned char *buf, size_t size); -extern int g1m_filebuffer_write(void *cookie, const unsigned char *dest, - size_t size); +extern int g1m_filebuffer_read(void *g1m_arg_cookie, + unsigned char *g1m_arg_buf, size_t g1m_arg_size); +extern int g1m_filebuffer_write(void *g1m_arg_cookie, + const unsigned char *g1m_arg_dest, size_t g1m_arg_size); /* ************************************************************************** */ /* Memory buffer definition */ /* ************************************************************************** */ /* Cookie structure */ -typedef struct { - const unsigned char *p; - size_t left; +typedef struct g1m_cursor_s { + const unsigned char *g1m_cursor_p; + size_t g1m_cursor_left; } g1m_cursor_t; /* Related callbacks and functions */ -extern int g1m_membuffer_read(void *cookie, unsigned char *dest, size_t size); +extern int g1m_membuffer_read(void *g1m_arg_cookie, + unsigned char *g1m_arg_dest, size_t g1m_arg_size); /* ************************************************************************** */ /* Limited buffer definition */ /* ************************************************************************** */ /* Cookie structure */ -typedef struct { - g1m_buffer_t *buffer; - size_t left; +typedef struct g1m_limited_s { + g1m_buffer_t *g1m_limited_buffer; + size_t g1m_limited_left; } g1m_limited_t; /* Related functions and callbacks */ -int g1m_limbuffer_read(void *cookie, unsigned char *dest, size_t size); -int g1m_empty_limbuffer(g1m_buffer_t *limbuffer); +int g1m_limbuffer_read(void *g1m_arg_cookie, + unsigned char *g1m_arg_dest, size_t g1m_arg_size); +int g1m_empty_limbuffer(g1m_buffer_t *g1m_arg_limbuffer); /* ************************************************************************** */ /* Buffer macros */ /* ************************************************************************** */ /* Initialize a file buffer */ # define g1m_filebuffer(F) (g1m_filebuffer_t){ \ - .cookie = (void*)(F), .read = g1m_filebuffer_read, \ - .write = g1m_filebuffer_write} + .g1m_buffer_cookie = (void*)(F), \ + .g1m_buffer_read = g1m_filebuffer_read, \ + .g1m_buffer_write = g1m_filebuffer_write} /* Initialize a memory buffer */ # define g1m_membuffer(P, SZ) (g1m_buffer_t){ \ - .cookie = (g1m_cursor_t[]){{.p = (P), .left = (SZ)}}, \ - .read = g1m_membuffer_read} + .g1m_buffer_cookie = (g1m_cursor_t[]){{ \ + .g1m_cursor_p = (P), .g1m_cursor_left = (SZ)}}, \ + .g1m_buffer_read = g1m_membuffer_read} /* Initialize a limited buffer */ # define g1m_limbuffer(BUFFER, SZ) (g1m_buffer_t){ \ - .cookie = (g1m_limited_t[]){{.buffer = (BUFFER), .left = (SZ)}}, \ - .read = g1m_limbuffer_read} + .g1m_buffer_cookie = (g1m_limited_t[]){{ \ + .g1m_limited_buffer = (BUFFER), .g1m_limited_left = (SZ)}}, \ + .g1m_buffer_read = g1m_limbuffer_read} #endif /* LIBG1M_BUFFER_H */ diff --git a/include/libg1m/eact.h b/include/libg1m/eact.h index 0c6bbc7..924ebff 100644 --- a/include/libg1m/eact.h +++ b/include/libg1m/eact.h @@ -37,18 +37,18 @@ typedef unsigned int g1m_eact_line_type_t; /* E-activities line structure */ /* ************************************************************************** */ typedef struct g1m_line_s { - int type; - - /* for subcontents */ - char name[17]; + int g1m_line_type; /* content */ - char *content; + char *g1m_line_content; /* subcontents */ - int count; - int _size; - struct g1m_line_s **lines; + int g1m_line_count; + int g1m_line__size; + struct g1m_line_s **g1m_line_lines; + + /* for subcontents */ + char g1m_line_name[17]; } g1m_line_t; #endif /* LIBG1M_EACT_H */ diff --git a/include/libg1m/file.h b/include/libg1m/file.h index 5e6c484..ac99a60 100644 --- a/include/libg1m/file.h +++ b/include/libg1m/file.h @@ -30,18 +30,17 @@ typedef unsigned int g1m_filetype_t; # define g1m_filetype_directory 0x01 # define g1m_filetype_generic 0x02 - /* ************************************************************************** */ /* Storage file structure */ /* ************************************************************************** */ typedef struct g1m_file_s { /* meta info */ - unsigned int type; - struct g1m_file_s *parent; - int deleted; + unsigned int g1m_file_type; + struct g1m_file_s *g1m_file_parent; + int g1m_file_deleted; /* content */ - void *content; + void *g1m_file_content; } g1m_file_t; #endif /* LIBG1M_FILE_H */ diff --git a/include/libg1m/format.h b/include/libg1m/format.h index 097c272..28e7a60 100644 --- a/include/libg1m/format.h +++ b/include/libg1m/format.h @@ -39,6 +39,18 @@ # include /* ************************************************************************** */ +/* The GraphCard (GRC) format */ +/* ************************************************************************** */ +/* The GraphCard is an external micro SD card reader for CASIO calculators, + * made by Util Pocket (not sold anymore). + * + * It uses its own format, built above the CAS format/protocol. + * Basically, before headers/parts (colons included), it inserts a 16-bit + * size of the header/part which is following, and a zero 16-bit size in + * the end. + * + * See the description of the CAS format above. */ +/* ************************************************************************** */ /* The FXI format */ /* ************************************************************************** */ /* fx-Interface, an old but well done proprietary interface by CASIO, has its @@ -58,7 +70,7 @@ /* The Casemul format */ /* ************************************************************************** */ /* Casemul is a CASIO emulator for Microsoft Windows. It is an old software - * which was not updated since 2005. It can import and export other files, + * that has not been updated since 2005. It can import and export other files, * but save its files in its own format, which use the .cas extension * (like the CASIOLINK format, but the two formats are completely different). * @@ -86,9 +98,11 @@ /* Since around 2004/2005, CASIO has adopted a single "superformat"; we call it * CASIO's standard format, or the G1M format (it doesn't really have a * *public* name, other than its magics, like 'USBPower' or 'CASIO'). + * Basically, G1M, G2R, G1A, G3A, G3P, C2P, C1A, and others, are formats + * defined under the standard format. * - * It doesn't have a single magic string, but a few. But the standard header - * has the same format, so we consider it as the same format. */ + * It doesn't have one single magic string, but a few, although the standard + * header has the same format, so we consider it as the same format. */ # include #endif /* LIBG1M_FORMAT_H */ diff --git a/include/libg1m/format/cas.h b/include/libg1m/format/cas.h index d5cc16e..d9594bb 100644 --- a/include/libg1m/format/cas.h +++ b/include/libg1m/format/cas.h @@ -30,11 +30,11 @@ * the double-colon ':' (0x3A) -- then it is the beginning of something * that is more than one-byte long. CAS files do not include the one-byte * packets, or repeated headers/parts (because of bad checksum or timeouts, - * for example). + * for example) -- see the libp7 legacy protocol documentation for this. * * Actually, there are three main things that start with a ':'. The main type * is a header, that describes the content that follows. A content can have - * no content part (e.g. END packet), one content part (e.g. programs), or + * no data part (e.g. END packet), one data part (e.g. programs), or * more (e.g. width*height content parts for lists and matrixes, which * represent the individual cells). These content parts have different formats * according to the global content part. @@ -115,11 +115,12 @@ struct _cas50 { uint8_t name[8]; /* variable-related data */ - uint8_t prefix[8]; /* "Variable" for vars, 0xFFs otherwise */ + uint8_t prefix[8]; /* "Variable" for vars, "PROG\x99" "0\xFF\xFF" for progs, + * 0xFFs otherwise */ uint8_t aux[8]; /* variable: "R\x0A"/"C\x0A", editor: password */ /* something else (?) */ - uint8_t nl[2]; /* 'NL'? */ + uint8_t nl[2]; /* 'NL'? "\xFF\xFF" for progs */ uint8_t _reserved[12]; /* end of packet */ diff --git a/include/libg1m/format/std.h b/include/libg1m/format/std.h index 0df24f2..e9a5013 100644 --- a/include/libg1m/format/std.h +++ b/include/libg1m/format/std.h @@ -97,7 +97,7 @@ struct standard_subheader { uint32_t checksum; /* file type: - * - 0x00: picture; + * - 0x00: picture (not used with this header); * - 0x01: add-in; * - 0x02: function keys; * - 0x04: language files; */ diff --git a/include/libg1m/handle.h b/include/libg1m/handle.h index 0896a06..c10200e 100644 --- a/include/libg1m/handle.h +++ b/include/libg1m/handle.h @@ -50,44 +50,68 @@ typedef unsigned int g1m_platform_t; # define g1m_platform_cas 0x0008 # define g1m_platform_casemul 0x0010 /* ************************************************************************** */ -/* Helpers */ +/* Version */ /* ************************************************************************** */ +/* Zone (localization) */ +# define g1m_versionzone_none 0x00 /* (international) */ +# define g1m_versionzone_aus 0x01 /* Australia */ +# define g1m_versionzone_fr 0x02 /* France */ +# define g1m_versionzone_nam 0x03 /* North america */ +# define g1m_versionzone_ch 0x04 /* China */ +# define g1m_versionzone_sing 0x05 /* Singapour */ + +/* Math input/output features */ +# define g1m_versionmath_slim 0x01 /* Slim */ +# define g1m_versionmath_all 0x02 /* All features (e.g. fx-9860GII-2) */ +# define g1m_versionmath_reduced 0x03 /* Reduced features (fx-7400GII) */ +# define g1m_versionmath_none 0x07 /* No math features? */ + +/* Flags */ +# define g1m_versionflag_indev 0x01 /* is an in-development/special version */ +# define g1m_versionflag_spe 0x02 /* special OS builds (SH-4A) */ + /* Version */ typedef struct g1m_version_s { - int major, minor, revision; + int g1m_version_major; + int g1m_version_minor; + unsigned char g1m_version_zone; + unsigned char g1m_version_math; + unsigned char g1m_version_flags; } g1m_version_t; /* ************************************************************************** */ /* Handle structure */ /* ************************************************************************** */ typedef struct { /* file type, the source destination platform */ - g1m_type_t type; - g1m_platform_t platform; + g1m_type_t g1m_handle_type; + g1m_platform_t g1m_handle_platform; /* Add-in related data */ - char title[17]; - char intname[12]; - g1m_version_t version; - time_t creation_date; - unsigned char *content; - size_t size; + char g1m_handle_title[17]; + char g1m_handle_intname[12]; + g1m_version_t g1m_handle_version; + time_t g1m_handle_creation_date; + unsigned char *g1m_handle_content; + size_t g1m_handle_size; /* Lists for various purposes */ - int count, _size; - g1m_mcsfile_t **files; - g1m_file_t **sfiles; - char **messages; - uint32_t ***fkeys; + int g1m_handle_count; + int g1m_handle__size; + g1m_mcsfile_t **g1m_handle_files; + g1m_file_t **g1m_handle_sfiles; + char **g1m_handle_messages; + uint32_t ***g1m_handle_fkeys; /* Picture-related data (also used for add-in icons */ - int width, height; - uint32_t **pixels; /* 0x0RGB */ - uint32_t **icon_unsel; /* 0x0RGB */ - uint32_t **icon_sel; /* 0x0RGB */ + int g1m_handle_width; + int g1m_handle_height; + uint32_t **g1m_handle_pixels; /* 0x0RGB */ + uint32_t **g1m_handle_icon_unsel; /* 0x0RGB */ + uint32_t **g1m_handle_icon_sel; /* 0x0RGB */ /* E-activities related data */ - g1m_line_t *line; - g1m_line_t _linedata; + g1m_line_t *g1m_handle_line; + g1m_line_t g1m_handle__linedata; } g1m_handle_t; #endif /* LIBG1M_HANDLE_H */ diff --git a/include/libg1m/internals.h b/include/libg1m/internals.h index 6bd2156..6a72d80 100644 --- a/include/libg1m/internals.h +++ b/include/libg1m/internals.h @@ -59,16 +59,19 @@ /* ************************************************************************** */ /* read from buffer */ # define READ(TO, SZ) /* normal read */ { \ - int READ_err = (*buffer->read)(buffer->cookie, (void*)(TO), (SZ)); \ - buffer->_offset += SZ; \ + int READ_err = (*buffer->g1m_buffer_read)(buffer->g1m_buffer_cookie, \ + (void*)(TO), (SZ)); \ + buffer->g1m_buffer_offset += SZ; \ if (READ_err) return (READ_err); } # define FREAD(TO, SZ) /* fail-less read */ \ - err = (*buffer->read)(buffer->cookie, (void*)(TO), (SZ)); \ - buffer->_offset += SZ; + err = (*buffer->g1m_buffer_read)(buffer->g1m_buffer_cookie, \ + (void*)(TO), (SZ)); \ + buffer->g1m_buffer_offset += SZ; # define GREAD(TO, SZ) /* read with goto fail */ { \ - if ((err = (*buffer->read)(buffer->cookie, (void*)(TO), (SZ)))) \ + if ((err = (*buffer->g1m_buffer_read)(buffer->g1m_buffer_cookie, \ + (void*)(TO), (SZ)))) \ goto fail; \ - buffer->_offset += SZ; } + buffer->g1m_buffer_offset += SZ; } /* read from buffer, declare var before */ # define DREAD(NAM, STRUCT) /* D read (I don't remember where D comes from) */ \ @@ -93,7 +96,7 @@ /* write */ # define WRITE(BUF, SZ) { \ - int WRITE_err = (*buffer->write)(buffer->cookie, \ + int WRITE_err = (*buffer->g1m_buffer_write)(buffer->g1m_buffer_cookie, \ (unsigned char*)(BUF), (SZ)); \ if (WRITE_err) return (WRITE_err); } # define DWRITE(S) WRITE(&(S), sizeof(S)) @@ -169,13 +172,9 @@ G1M_MCSFUNC(string) # define G1M_CASFUNC(NAME) \ extern int g1m_decode_caspart_##NAME(g1m_mcsfile_t *handle, \ g1m_buffer_t *buffer); -# define G1M_CASHFUNC(NAME) \ -extern int g1m_decode_cashpart_##NAME(g1m_mcshead_t *head, \ - g1m_mcshead_t *heads, g1m_buffer_t *buffer); G1M_CASFUNC(var) G1M_CASFUNC(program) -G1M_CASHFUNC(program) G1M_CASFUNC(matrix) G1M_CASFUNC(capture) /* ************************************************************************** */ diff --git a/include/libg1m/mcs.h b/include/libg1m/mcs.h index 1a07f14..127c6df 100644 --- a/include/libg1m/mcs.h +++ b/include/libg1m/mcs.h @@ -73,10 +73,11 @@ typedef unsigned int g1m_mcsinfo_t; # define g1m_mcsinfo_graph100 g1m_mcsinfo_cas100 /* Macros to check if the type uses the ID, and to interact with it */ -# define g1m_mcshead_uses_id(H) (((H)->type & (\ +# define g1m_mcshead_uses_id(H) (((H)->g1m_mcshead_type & (\ g1m_mcstype_list | g1m_mcstype_mat | g1m_mcstype_vct | \ g1m_mcstype_pict | g1m_mcstype_capt | g1m_mcstype_string) || \ - ((H)->type == g1m_mcstype_var && (H)->count == 1))) + ((H)->g1m_mcshead_type == g1m_mcstype_var && \ + (H)->g1m_mcshead_count == 1))) # define g1m_get_id_major(I) ((I) >> 6) # define g1m_get_id_minor(I) ((I) & 0x3F) /* ************************************************************************** */ @@ -86,9 +87,10 @@ typedef unsigned int g1m_mcsinfo_t; # define g1m_mcscellflag_used 0x0001 /* Main structure */ -typedef struct g1m_mcs_cell_s { - g1m_bcd_t real, imgn; - unsigned int flags; +typedef struct g1m_mcscell_s { + unsigned int g1m_mcscell_flags; + g1m_bcd_t g1m_mcscell_real; + g1m_bcd_t g1m_mcscell_imgn; } g1m_mcscell_t; /* ************************************************************************** */ /* Setup */ @@ -126,12 +128,12 @@ typedef struct g1m_mcs_cell_s { # define g1m_setupmflag_dpemode 0x4000 /* Toggle /E-mode */ /* More complex values */ -# define g1m_setupval_number 0 /* 0 being comp, 2,8,10,16 being the base */ -# define g1m_setupval_function 1 /* -> 0x18 */ -# define g1m_setupval_listfile 2 /* List File 1-6, 0 being none */ -# define g1m_setupval_bg 3 /* Background picture ID, 0 being none */ -# define g1m_setupval_dispid 4 /* Display ID, see dpfix/dpnorm/dpemode */ -# define g1m_setupval_residlist 5 /* Resid List */ +# define g1m_setupval_number 0 /* 0 being comp, 2,8,10,16 being the base */ +# define g1m_setupval_function 1 /* -> 0x18 */ +# define g1m_setupval_listfile 2 /* List File 1-6, 0 being none */ +# define g1m_setupval_bg 3 /* Background picture ID, 0 being none */ +# define g1m_setupval_dispid 4 /* Display ID, see dpfix/dpnorm/dpemode */ +# define g1m_setupval_residlist 5 /* Resid List */ /* Function types */ # define g1m_functype_yequ 0x00 /* Y= */ @@ -144,10 +146,12 @@ typedef struct g1m_mcs_cell_s { # define g1m_functype_yle 0x07 /* Y<= */ /* Main structure */ -# define g1m_setupvals 6 +# define g1m_setup_vals_count 6 typedef struct g1m_setup_s { - unsigned int iflags, wflags, mflags; - unsigned char vals[g1m_setupvals]; + unsigned int g1m_setup_iflags; + unsigned int g1m_setup_wflags; + unsigned int g1m_setup_mflags; + unsigned char g1m_setup_vals[g1m_setup_vals_count]; } g1m_setup_t; /* ************************************************************************** */ /* Main structures */ @@ -163,49 +167,55 @@ typedef struct g1m_setup_s { /* mcs file head */ typedef struct g1m_mcshead_s { /* file main information */ - g1m_mcstype_t type; - g1m_mcsinfo_t info; - char name[13]; int id; - unsigned int flags; + g1m_mcstype_t g1m_mcshead_type; + g1m_mcsinfo_t g1m_mcshead_info; + unsigned int g1m_mcshead_flags; + unsigned int g1m_mcshead_id; /* content size */ - int count; - unsigned int width, height; - uint_fast32_t size; + int g1m_mcshead_count; + unsigned int g1m_mcshead_width; + unsigned int g1m_mcshead_height; + uint_fast32_t g1m_mcshead_size; - /* mcs-related raw data */ - unsigned int _rawtype; - unsigned char _group[17], _dirname[9]; + /* raw data */ + unsigned int g1m_mcshead_rawtype; + g1m_pictureformat_t g1m_mcshead_picformat; - /* cas-related raw data */ - unsigned char _appname[4], _datatype[3]; - g1m_pictureformat_t _picformat; + /* strings */ + char g1m_mcshead_name[13]; + char g1m_mcshead_password[9]; - /* the program password */ - char password[9]; + /* raw string data */ + unsigned char g1m_mcshead_group[17]; + unsigned char g1m_mcshead_dirname[9]; + unsigned char g1m_mcshead_appname[4]; + unsigned char g1m_mcshead_datatype[3]; } g1m_mcshead_t; /* mcs file */ -# define g1m_has_password(F) (F)->head.password[0] -# define g1m_remove_password(F) (F)->head.password[0] = 0 +# define g1m_has_password(F) \ + (F)->g1m_mcsfile_head.g1m_mcshead_password[0] +# define g1m_remove_password(F) \ + (F)->g1m_mcsfile_head.g1m_mcshead_password[0] = 0 typedef struct g1m_mcsfile_s { /* head */ - g1m_mcshead_t head; + g1m_mcshead_t g1m_mcsfile_head; /* content (useful when not read) */ - char *content; + char *g1m_mcsfile_content; /* variables */ - g1m_mcscell_t var; - g1m_mcscell_t *vars; - g1m_mcscell_t **cells; + g1m_mcscell_t g1m_mcsfile_var; + g1m_mcscell_t *g1m_mcsfile_vars; + g1m_mcscell_t **g1m_mcsfile_cells; /* for pictures and captures */ - uint32_t **pic; /* 0x0RGB */ - uint32_t ***pics; + uint32_t **g1m_mcsfile_pic; /* 0x0RGB */ + uint32_t ***g1m_mcsfile_pics; /* for settings */ - g1m_setup_t setup; + g1m_setup_t g1m_mcsfile_setup; } g1m_mcsfile_t; #endif /* LIBG1M_MCS_H */ diff --git a/src/bcd/cas.c b/src/bcd/cas.c index 6cd338b..14224fe 100644 --- a/src/bcd/cas.c +++ b/src/bcd/cas.c @@ -29,35 +29,38 @@ * @return the special bit, for simplicity. */ -int g1m_bcd_fromcas(const cas_bcd_t *raw, g1m_bcd_t *bcd) +int g1m_bcd_fromcas(const g1m_casbcd_t *raw, g1m_bcd_t *bcd) { - const unsigned char *bytes = raw->mantissa; + const unsigned char *bytes = raw->g1m_casbcd_mant; /* get the exponent and sign */ - bcd->exp = (raw->exponent >> 4) * 10 + (raw->exponent & 0x0F); - if (raw->signinfo & g1m_casbcd_pow_neg) - bcd->exp = -bcd->exp; + bcd->g1m_bcd_exp = (raw->g1m_casbcd_exp >> 4) * 10 + + (raw->g1m_casbcd_exp & 0x0F); + if (raw->g1m_casbcd_flags & g1m_casbcdflag_pow_neg) + bcd->g1m_bcd_exp = -bcd->g1m_bcd_exp; /* get the mantissa */ - bcd->mant[0] = lwr(0); - bcd->mant[1] = upr(1); - bcd->mant[2] = lwr(1); - bcd->mant[3] = upr(2); - bcd->mant[4] = lwr(2); - bcd->mant[5] = upr(3); - bcd->mant[6] = lwr(3); - bcd->mant[7] = upr(4); - bcd->mant[8] = lwr(4); - bcd->mant[9] = upr(5); - bcd->mant[10] = lwr(5); - bcd->mant[11] = upr(6); - bcd->mant[12] = lwr(6); - bcd->mant[13] = upr(7); - bcd->mant[14] = lwr(7); + bcd->g1m_bcd_mant[0] = lwr(0); + bcd->g1m_bcd_mant[1] = upr(1); + bcd->g1m_bcd_mant[2] = lwr(1); + bcd->g1m_bcd_mant[3] = upr(2); + bcd->g1m_bcd_mant[4] = lwr(2); + bcd->g1m_bcd_mant[5] = upr(3); + bcd->g1m_bcd_mant[6] = lwr(3); + bcd->g1m_bcd_mant[7] = upr(4); + bcd->g1m_bcd_mant[8] = lwr(4); + bcd->g1m_bcd_mant[9] = upr(5); + bcd->g1m_bcd_mant[10] = lwr(5); + bcd->g1m_bcd_mant[11] = upr(6); + bcd->g1m_bcd_mant[12] = lwr(6); + bcd->g1m_bcd_mant[13] = upr(7); + bcd->g1m_bcd_mant[14] = lwr(7); /* set the special things and return */ - bcd->flags = g1m_make_bcdflags(!!(raw->signinfo & g1m_casbcd_special), - (raw->signinfo & g1m_casbcd_negative) == g1m_casbcd_negative, 15); + bcd->g1m_bcd_flags = g1m_make_bcdflags( + !!(raw->g1m_casbcd_flags & g1m_casbcdflag_special), + (raw->g1m_casbcd_flags & g1m_casbcdflag_negative) + == g1m_casbcdflag_negative, 15); return (g1m_bcd_has_special(bcd)); } @@ -69,28 +72,29 @@ int g1m_bcd_fromcas(const cas_bcd_t *raw, g1m_bcd_t *bcd) * @arg raw the raw BCD. */ -void g1m_bcd_tocas(const g1m_bcd_t *bcd, cas_bcd_t *raw) +# define g1m_bcd_m g1m_bcd_mant +void g1m_bcd_tocas(const g1m_bcd_t *bcd, g1m_casbcd_t *raw) { /* put the exponent */ - div_t d = div(abs(bcd->exp), 10); - raw->exponent = (d.quot << 4) | d.rem; + div_t d = div(abs(bcd->g1m_bcd_exp), 10); + raw->g1m_casbcd_exp = (d.quot << 4) | d.rem; /* put the mantissa */ - raw->mantissa[0] = bcd->mant[0]; - raw->mantissa[1] = (bcd->mant[1] << 4) | bcd->mant[2]; - raw->mantissa[2] = (bcd->mant[3] << 4) | bcd->mant[4]; - raw->mantissa[3] = (bcd->mant[5] << 4) | bcd->mant[6]; - raw->mantissa[4] = (bcd->mant[7] << 4) | bcd->mant[8]; - raw->mantissa[5] = (bcd->mant[9] << 4) | bcd->mant[10]; - raw->mantissa[6] = (bcd->mant[11] << 4) | bcd->mant[12]; - raw->mantissa[7] = (bcd->mant[13] << 4) | bcd->mant[14]; + raw->g1m_casbcd_mant[0] = bcd->g1m_bcd_m[0]; + raw->g1m_casbcd_mant[1] = (bcd->g1m_bcd_m[1] << 4) | bcd->g1m_bcd_m[2]; + raw->g1m_casbcd_mant[2] = (bcd->g1m_bcd_m[3] << 4) | bcd->g1m_bcd_m[4]; + raw->g1m_casbcd_mant[3] = (bcd->g1m_bcd_m[5] << 4) | bcd->g1m_bcd_m[6]; + raw->g1m_casbcd_mant[4] = (bcd->g1m_bcd_m[7] << 4) | bcd->g1m_bcd_m[8]; + raw->g1m_casbcd_mant[5] = (bcd->g1m_bcd_m[9] << 4) | bcd->g1m_bcd_m[10]; + raw->g1m_casbcd_mant[6] = (bcd->g1m_bcd_m[11] << 4) | bcd->g1m_bcd_m[12]; + raw->g1m_casbcd_mant[7] = (bcd->g1m_bcd_m[13] << 4) | bcd->g1m_bcd_m[14]; /* put the flags */ - raw->signinfo = 0; - if (bcd->exp < 0) - raw->signinfo |= g1m_casbcd_pow_neg; + raw->g1m_casbcd_flags = 0; + if (bcd->g1m_bcd_exp < 0) + raw->g1m_casbcd_flags |= g1m_casbcdflag_pow_neg; if (g1m_bcd_is_negative(bcd)) - raw->signinfo |= g1m_casbcd_negative; + raw->g1m_casbcd_flags |= g1m_casbcdflag_negative; if (g1m_bcd_has_special(bcd)) - raw->signinfo |= g1m_casbcd_special; + raw->g1m_casbcd_flags |= g1m_casbcdflag_special; } diff --git a/src/bcd/double.c b/src/bcd/double.c index e651889..51b4205 100644 --- a/src/bcd/double.c +++ b/src/bcd/double.c @@ -50,13 +50,13 @@ void g1m_bcd_fromdouble(double dbl, g1m_bcd_t *bcd) /* get the mantissa */ for (int i = 0; i < 15; i++) { double work = floor(dbl); - bcd->mant[i] = (int)work; + bcd->g1m_bcd_mant[i] = (int)work; dbl = (dbl - work) * 10; } /* set the flags */ - bcd->flags = g1m_make_bcdflags(0, neg, 15); - bcd->exp = exp; + bcd->g1m_bcd_flags = g1m_make_bcdflags(0, neg, 15); + bcd->g1m_bcd_exp = exp; } /** diff --git a/src/bcd/mcs.c b/src/bcd/mcs.c index 51f70f8..749d69d 100644 --- a/src/bcd/mcs.c +++ b/src/bcd/mcs.c @@ -29,34 +29,34 @@ * @return the special bit, for simplicity. */ -int g1m_bcd_frommcs(const mcs_bcd_t *raw, g1m_bcd_t *bcd) +int g1m_bcd_frommcs(const g1m_mcsbcd_t *raw, g1m_bcd_t *bcd) { - const unsigned char *bytes = raw->BCDval; + const unsigned char *bytes = raw->g1m_mcsbcd_BCDval; /* get the exponent and correct it */ int exp = (upr(0) & 7) * 100 + lwr(0) * 10 + upr(1), neg = 0; if (exp >= 500) exp -= 500, neg = 1; - bcd->exp = (char)(exp - 99); + bcd->g1m_bcd_exp = (char)(exp - 99); /* set the flags */ - bcd->flags = g1m_make_bcdflags((bytes[0] & 0x80) >> 7, neg, 15); + bcd->g1m_bcd_flags = g1m_make_bcdflags((bytes[0] & 0x80) >> 7, neg, 15); /* get the mantissa */ - bcd->mant[0] = lwr(1); - bcd->mant[1] = upr(2); - bcd->mant[2] = lwr(2); - bcd->mant[3] = upr(3); - bcd->mant[4] = lwr(3); - bcd->mant[5] = upr(4); - bcd->mant[6] = lwr(4); - bcd->mant[7] = upr(5); - bcd->mant[8] = lwr(5); - bcd->mant[9] = upr(6); - bcd->mant[10] = lwr(6); - bcd->mant[11] = upr(7); - bcd->mant[12] = lwr(7); - bcd->mant[13] = upr(8); - bcd->mant[14] = lwr(8); + bcd->g1m_bcd_mant[0] = lwr(1); + bcd->g1m_bcd_mant[1] = upr(2); + bcd->g1m_bcd_mant[2] = lwr(2); + bcd->g1m_bcd_mant[3] = upr(3); + bcd->g1m_bcd_mant[4] = lwr(3); + bcd->g1m_bcd_mant[5] = upr(4); + bcd->g1m_bcd_mant[6] = lwr(4); + bcd->g1m_bcd_mant[7] = upr(5); + bcd->g1m_bcd_mant[8] = lwr(5); + bcd->g1m_bcd_mant[9] = upr(6); + bcd->g1m_bcd_mant[10] = lwr(6); + bcd->g1m_bcd_mant[11] = upr(7); + bcd->g1m_bcd_mant[12] = lwr(7); + bcd->g1m_bcd_mant[13] = upr(8); + bcd->g1m_bcd_mant[14] = lwr(8); /* return the special bit */ return (g1m_bcd_has_special(bcd)); @@ -70,28 +70,30 @@ int g1m_bcd_frommcs(const mcs_bcd_t *raw, g1m_bcd_t *bcd) * @arg raw the raw BCD. */ -void g1m_bcd_tomcs(const g1m_bcd_t *bcd, mcs_bcd_t *raw) +# define g1m_bcd_m g1m_bcd_mant +void g1m_bcd_tomcs(const g1m_bcd_t *bcd, g1m_mcsbcd_t *raw) { - int exp = bcd->exp + 99; + int exp = bcd->g1m_bcd_exp + 99; if (g1m_bcd_is_negative(bcd)) exp += 500; /* put the exponent (and first digit of the mantissa) */ div_t c = div(exp, 100); div_t d = div(c.rem, 10); - raw->BCDval[0] = (c.quot << 4) | d.quot | (!!g1m_bcd_has_special(bcd) << 7); - raw->BCDval[1] = (d.rem << 4) | bcd->mant[0]; + raw->g1m_mcsbcd_BCDval[0] = (c.quot << 4) | d.quot + | (!!g1m_bcd_has_special(bcd) << 7); + raw->g1m_mcsbcd_BCDval[1] = (d.rem << 4) | bcd->g1m_bcd_mant[0]; /* put the mantissa */ - raw->BCDval[2] = (bcd->mant[1] << 4) | bcd->mant[2]; - raw->BCDval[3] = (bcd->mant[3] << 4) | bcd->mant[4]; - raw->BCDval[4] = (bcd->mant[5] << 4) | bcd->mant[6]; - raw->BCDval[5] = (bcd->mant[7] << 4) | bcd->mant[8]; - raw->BCDval[6] = (bcd->mant[9] << 4) | bcd->mant[10]; - raw->BCDval[7] = (bcd->mant[11] << 4) | bcd->mant[12]; - raw->BCDval[8] = (bcd->mant[13] << 4) | bcd->mant[14]; + raw->g1m_mcsbcd_BCDval[2] = (bcd->g1m_bcd_m[1] << 4) | bcd->g1m_bcd_m[2]; + raw->g1m_mcsbcd_BCDval[3] = (bcd->g1m_bcd_m[3] << 4) | bcd->g1m_bcd_m[4]; + raw->g1m_mcsbcd_BCDval[4] = (bcd->g1m_bcd_m[5] << 4) | bcd->g1m_bcd_m[6]; + raw->g1m_mcsbcd_BCDval[5] = (bcd->g1m_bcd_m[7] << 4) | bcd->g1m_bcd_m[8]; + raw->g1m_mcsbcd_BCDval[6] = (bcd->g1m_bcd_m[9] << 4) | bcd->g1m_bcd_m[10]; + raw->g1m_mcsbcd_BCDval[7] = (bcd->g1m_bcd_m[11] << 4) | bcd->g1m_bcd_m[12]; + raw->g1m_mcsbcd_BCDval[8] = (bcd->g1m_bcd_m[13] << 4) | bcd->g1m_bcd_m[14]; /* set the align zone */ - raw->_align[0] = 0; - raw->_align[1] = 0; - raw->_align[2] = 0; + raw->g1m_mcsbcd__align[0] = 0; + raw->g1m_mcsbcd__align[1] = 0; + raw->g1m_mcsbcd__align[2] = 0; } diff --git a/src/bcd/str.c b/src/bcd/str.c index 15f5edc..5be05ba 100644 --- a/src/bcd/str.c +++ b/src/bcd/str.c @@ -74,7 +74,7 @@ size_t g1m_bcdtoa(const g1m_bcd_t *bcd, char *buf, size_t len) /* get base digit */ int exp = g1m_bcd_exponent(bcd), offset = 0; int leftdigits = g1m_bcd_precision(bcd); - const char *digits = bcd->mant; + const char *digits = bcd->g1m_bcd_mant; for (; leftdigits > 0; leftdigits--) { if (*digits) break; exp--; diff --git a/src/core/free.c b/src/core/free.c index be1c077..a078d55 100644 --- a/src/core/free.c +++ b/src/core/free.c @@ -32,15 +32,15 @@ void g1m_free_line_content(g1m_line_t *line) { int i; - if (line->type & (g1m_linetype_title | g1m_linetype_text + if (line->g1m_line_type & (g1m_linetype_title | g1m_linetype_text | g1m_linetype_picture)) - free(line->content); + free(line->g1m_line_content); - if (line->type & g1m_linetype_eact) { - for (i = 0; i < line->count; i++) { - g1m_free_line_content(line->lines[i]); - free(line->lines[i]); + if (line->g1m_line_type & g1m_linetype_eact) { + for (i = 0; i < line->g1m_line_count; i++) { + g1m_free_line_content(line->g1m_line_lines[i]); + free(line->g1m_line_lines[i]); } - free(line->lines); + free(line->g1m_line_lines); } } diff --git a/src/core/version.c b/src/core/version.c index 5a12b11..09bf2a5 100644 --- a/src/core/version.c +++ b/src/core/version.c @@ -54,9 +54,9 @@ static const char version_message[] = * Display version when the library is executed. */ -extern void __libg1m_version(void) +extern void g1m__version(void) __attribute__((noreturn)); -void __libg1m_version(void) +void g1m__version(void) { puts(version_message); _exit(0); diff --git a/src/decode/cas.c b/src/decode/cas.c index f085060..ca2b01d 100644 --- a/src/decode/cas.c +++ b/src/decode/cas.c @@ -22,17 +22,6 @@ #include #define FUNC(NAME) g1m_decode_caspart_##NAME #define HFUNC(NAME) g1m_decode_cashpart_##NAME -#define READGSIZE() if (grc) { \ - uint16_t size; READ(&size, 2) \ - log_info("GraphCard next buffer size was: 0x%04X", be16toh(size)); } -#define READCOLON() { \ - READGSIZE() \ - uint8_t colon; GREAD(&colon, 1) \ - err = g1m_error_magic; \ - if (colon != ':') { \ - log_error("Expected ':', got '%c' (0x%02X)", colon, colon); \ - goto fail; \ - }} /* ************************************************************************** */ /* Type correspondance list */ @@ -53,7 +42,7 @@ struct cas_corresp { #define TTERM {0, NULL, NULL} static struct cas_corresp cas_types[] = { {g1m_mcstype_var, FUNC(var), NULL}, - {g1m_mcstype_program, FUNC(program), HFUNC(program)}, + {g1m_mcstype_program, FUNC(program), NULL}, {g1m_mcstype_matrix, FUNC(matrix), NULL}, {g1m_mcstype_list, FUNC(matrix), NULL}, {g1m_mcstype_capture, FUNC(capture), NULL}, @@ -100,7 +89,7 @@ static int decode_cas50(g1m_mcshead_t *head, g1m_buffer_t *buffer, uint8_t csum) /* read the raw header */ DREAD(hd, _cas50) log_info("Raw CAS50 (CASPRO) header content (app: '%.3s'):", - head->_appname); + head->g1m_mcshead_appname); logm_info(&hd, sizeof(struct _cas50)); /* check the checksum */ @@ -114,29 +103,32 @@ static int decode_cas50(g1m_mcshead_t *head, g1m_buffer_t *buffer, uint8_t csum) /* copy the basic information */ g1m_maketype_cas(head, (char*)hd.data); - head->size = be16toh(hd.height) - 2 /* checksum, colon */; + head->g1m_mcshead_size = be16toh(hd.height) - 2 /* checksum, colon */; char *end = memchr(hd.name, 0xFF, 8); size_t len = end ? (size_t)(end - (char*)hd.name) : 8; - memcpy(head->name, hd.name, len); head->name[len] = 0; + memcpy(head->g1m_mcshead_name, hd.name, len); + head->g1m_mcshead_name[len] = 0; /* read specific data */ - switch (head->type) { + switch (head->g1m_mcshead_type) { case g1m_mcstype_program:; /* copy password */ - head->flags |= g1m_mcsflag_unfinished; + head->g1m_mcshead_flags |= g1m_mcsflag_unfinished; end = memchr(hd.aux, 0xFF, 8); len = end ? (size_t)(end - (char*)hd.aux) : 8; - memcpy(head->password, hd.aux, len); head->password[len] = 0; - log_info("Is a program of %" PRIuFAST32 " bytes", head->size); + memcpy(head->g1m_mcshead_password, hd.aux, len); + head->g1m_mcshead_password[len] = 0; + log_info("Is a program of %" PRIuFAST32 " bytes", + head->g1m_mcshead_size); break; case g1m_mcstype_variable: case g1m_mcstype_matrix: case g1m_mcstype_list: - head->height = be16toh(hd.height) & 0xFF; - head->width = be16toh(hd.width) & 0xFF; - head->count = head->height; - if (head->width && head->height) - head->flags |= g1m_mcsflag_unfinished; + head->g1m_mcshead_height = be16toh(hd.height) & 0xFF; + head->g1m_mcshead_width = be16toh(hd.width) & 0xFF; + head->g1m_mcshead_count = head->g1m_mcshead_height; + if (head->g1m_mcshead_width && head->g1m_mcshead_height) + head->g1m_mcshead_flags |= g1m_mcsflag_unfinished; break; } @@ -164,11 +156,12 @@ int g1m_decode_casfile_head(g1m_mcshead_t *head, g1m_buffer_t *buffer) uint8_t csum = g1m_checksum8(buf, 4); struct casdyn *dhd = (void*)buf; if (!g1m_maketype_casapp(head, dhd->ext, (char*)dhd->app)) - switch (head->info) { + switch (head->g1m_mcshead_info) { case g1m_mcsinfo_cas50: return (decode_cas50(head, buffer, csum)); //case g1m_mcsinfo_cas100: return (decode_cas100(head, buffer)); default: - log_error("Platform 0x%04X isn't implemented yet.", head->info); + log_error("Platform 0x%04X isn't implemented yet.", + head->g1m_mcshead_info); return (g1m_error_op); } @@ -183,14 +176,15 @@ int g1m_decode_casfile_head(g1m_mcshead_t *head, g1m_buffer_t *buffer) return (g1m_error_checksum); /* fill the handle */ - memset(head, 0, sizeof(struct cas40)); - head->info = g1m_mcsinfo_cas40; - memcpy(head->name, hd->filename, 12); head->name[12] = 0; + memset(head, 0, sizeof(g1m_mcshead_t)); + head->g1m_mcshead_info = g1m_mcsinfo_cas40; + memcpy(head->g1m_mcshead_name, hd->filename, 12); + head->g1m_mcshead_name[12] = 0; /* type specific things */ - if (head->type == g1m_mcstype_program) { + if (head->g1m_mcshead_type == g1m_mcstype_program) { struct cas_spe_program *spe = (void*)hd->misc; - head->size = be16toh(spe->length); + head->g1m_mcshead_size = be16toh(spe->length); /* TODO: store flags? */ } @@ -200,30 +194,6 @@ int g1m_decode_casfile_head(g1m_mcshead_t *head, g1m_buffer_t *buffer) /* ************************************************************************** */ /* Part decoding functions */ /* ************************************************************************** */ -/** - * g1m_decode_casfiles_part: - * Decode the CASIOLINK group parts. - * - * @arg head the general head. - * @arg heads the heads to contribute to. - * @arg buffer the buffer to read from. - * @return the error that occurred (0 if ok). - */ - -int g1m_decode_casfiles_part(g1m_mcshead_t *head, g1m_mcshead_t *heads, - g1m_buffer_t *buffer) -{ - /* look for the decoding function */ - cas_heads_decode_function decode = (void*)lookup_cas_decode(head->type, 1); - if (!decode) { - log_error("No dedicated decoding function was found for this type!"); - return (g1m_error_unknown); - } - - /* decode the part */ - return ((*decode)(head, heads, buffer)); -} - /** * g1m_decode_casfile_part: * Decode a CASIOLINK Protocol content part. @@ -239,7 +209,8 @@ int g1m_decode_casfile_part(g1m_mcsfile_t *file, g1m_buffer_t *buffer) if (!file) return (g1m_error_op); /* look for the decoding function */ - cas_decode_function decode = (void*)lookup_cas_decode(file->head.type, 0); + cas_decode_function decode = (void*)lookup_cas_decode( + file->g1m_mcsfile_head.g1m_mcshead_type, 0); if (!decode) { log_error("No dedicated decoding function was found for this type!"); return (g1m_error_unknown); @@ -248,10 +219,21 @@ int g1m_decode_casfile_part(g1m_mcsfile_t *file, g1m_buffer_t *buffer) /* decode the part */ return ((*decode)(file, buffer)); } - /* ************************************************************************** */ /* Main file decoding function */ /* ************************************************************************** */ +#define READGSIZE() if (grc) { \ + uint16_t size; READ(&size, 2) \ + log_info("GraphCard next buffer size was: 0x%04X", be16toh(size)); } +#define READCOLON() { \ + READGSIZE() \ + uint8_t colon; GREAD(&colon, 1) \ + err = g1m_error_magic; \ + if (colon != ':') { \ + log_error("Expected ':', got '%c' (0x%02X)", colon, colon); \ + goto fail; \ + }} + /** * decode_cas: * Decode a CAS file. @@ -272,58 +254,43 @@ static int decode_cas(g1m_handle_t **h, g1m_buffer_t *buffer, int grc) if (err) return (err); g1m_handle_t *handle = *h; - /* read first colon */ - if (grc) READCOLON() /* FIXME: read this in graphcard magic? */ - /* read each */ - for (handle->count = 0;;) { + for (handle->g1m_handle_count = 0;;) { /* read the head */ log_info("Reading the next head."); g1m_mcshead_t head = {}; if ((err = g1m_decode_casfile_head(&head, buffer))) goto fail; - if (head.type == g1m_mcstype_end) break; + if (head.g1m_mcshead_type == g1m_mcstype_end) break; - /* heads up! */ - int numheads = head.flags & g1m_mcsflag_multiple ? head.count : 1; - g1m_mcshead_t heads[numheads]; - if (head.flags & g1m_mcsflag_multiple) { - log_info("Is a head for multiple files!"); - g1m_prepare_mcsfile_heads(&head, heads); - while (head.flags & g1m_mcsflag_unfinished) { - READCOLON() + /* prepare the file */ + log_info("Preparing the file."); + g1m_mcsfile_t *file; err = g1m_mcs_insert(handle, &file, &head); + if (err) goto fail; - /* decode a general part */ - err = g1m_decode_casfiles_part(&head, heads, buffer); - if (err) goto fail; - } - } else heads[0] = head; - - for (int i = 0; i < numheads; i++) { - /* prepare the file */ - log_info("Preparing the group file #%d", i); - g1m_mcsfile_t *file; err = g1m_mcs_insert(handle, &file, &heads[i]); - if (err) goto fail; - - /* read each part */ + /* read each part */ #if LOGLEVEL <= ll_info - for (int j = 1; file->head.flags & g1m_mcsflag_unfinished; j++) { + for (int j = 1; file->g1m_mcsfile_head.g1m_mcshead_flags + & g1m_mcsflag_unfinished; j++) { #else - while (file->head.flags & g1m_mcsflag_unfinished) { + while (file->g1m_mcsfile_head.g1m_mcshead_flags + & g1m_mcsflag_unfinished) { #endif - /* initialize */ - log_info("Reading part #%d", j); - READCOLON() + /* initialize */ + log_info("Reading part #%d", j); + READCOLON() - /* read the part */ - err = g1m_decode_casfile_part(file, buffer); - if (err) goto fail; - } + /* read the part */ + err = g1m_decode_casfile_part(file, buffer); + if (err) goto fail; } /* read first colon of the next part */ READCOLON() } + /* read last size (check if zero?) */ + READGSIZE() + /* everything went well :) */ return (0); @@ -361,16 +328,5 @@ int g1m_decode_cas(g1m_handle_t **handle, g1m_buffer_t *buffer) int g1m_decode_grc(g1m_handle_t **handle, g1m_buffer_t *buffer) { - /* file decoding */ - int err = decode_cas(handle, buffer, 1); - if (err) return (err); - - /* read final size */ - uint16_t final; GREAD(&final, sizeof(uint16_t)) - if (final != 0) return (g1m_error_magic); - return (0); - -fail: - g1m_free(*handle); *handle = NULL; - return (err); + return (decode_cas(handle, buffer, 1)); } diff --git a/src/decode/cas/cell.c b/src/decode/cas/cell.c index 27745a5..c1fa6d7 100644 --- a/src/decode/cas/cell.c +++ b/src/decode/cas/cell.c @@ -36,7 +36,7 @@ static int decode_cell(g1m_buffer_t *buffer, g1m_mcscell_t *cell, unsigned int *x, unsigned int *y) { uint8_t csum = 0; - cell->flags = g1m_mcscellflag_used; + cell->g1m_mcscell_flags = g1m_mcscellflag_used; /* read position */ uint16_t fx, fy; @@ -46,12 +46,12 @@ static int decode_cell(g1m_buffer_t *buffer, g1m_mcscell_t *cell, csum += g1m_checksum8(&fy, sizeof(uint16_t)); /* read the parts */ - DREAD(wkg, cas_bcd) - csum += g1m_checksum8(&wkg, sizeof(cas_bcd_t)); - if (g1m_bcd_fromcas(&wkg, &cell->real)) { - READ(&wkg, sizeof(cas_bcd_t)) - csum += g1m_checksum8(&wkg, sizeof(cas_bcd_t)); - g1m_bcd_fromcas(&wkg, &cell->imgn); + DREAD(wkg, g1m_casbcd_s) + csum += g1m_checksum8(&wkg, sizeof(g1m_casbcd_t)); + if (g1m_bcd_fromcas(&wkg, &cell->g1m_mcscell_real)) { + READ(&wkg, sizeof(g1m_casbcd_t)) + csum += g1m_checksum8(&wkg, sizeof(g1m_casbcd_t)); + g1m_bcd_fromcas(&wkg, &cell->g1m_mcscell_imgn); } /* read and check the checksum */ @@ -83,12 +83,12 @@ int g1m_decode_caspart_matrix(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) if (err) return (err); /* save the cell (FIXME: secure) */ - handle->cells[y][x] = cell; + handle->g1m_mcsfile_cells[y][x] = cell; /* check if its the last cell */ - if (y == handle->head.height - 1 - && x == handle->head.width - 1) - handle->head.flags &= ~g1m_mcsflag_unfinished; + if (y == handle->g1m_mcsfile_head.g1m_mcshead_height - 1 + && x == handle->g1m_mcsfile_head.g1m_mcshead_width - 1) + handle->g1m_mcsfile_head.g1m_mcshead_flags &= ~g1m_mcsflag_unfinished; /* no error! */ return (0); @@ -107,11 +107,11 @@ int g1m_decode_caspart_var(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { /* read and save the cell */ unsigned int x, y; - int err = decode_cell(buffer, &handle->var, &x, &y); + int err = decode_cell(buffer, &handle->g1m_mcsfile_var, &x, &y); if (err) return (err); if (x != 1 || y != 1) return (g1m_error_magic); /* no error! */ - handle->head.flags &= ~g1m_mcsflag_unfinished; + handle->g1m_mcsfile_head.g1m_mcshead_flags &= ~g1m_mcsflag_unfinished; return (0); } diff --git a/src/decode/cas/program.c b/src/decode/cas/program.c index 8d8f163..6ad6844 100644 --- a/src/decode/cas/program.c +++ b/src/decode/cas/program.c @@ -18,44 +18,6 @@ * ************************************************************************** */ #include -/** - * g1m_decode_cashpart_program: - * Decode a CAS heads program part. - * - * @arg head the general head. - * @arg heads the heads to contribute to. - * @arg buffer the buffer to read from. - * @return the error code (0 if ok). - */ - -int g1m_decode_cashpart_program(g1m_mcshead_t *head, g1m_mcshead_t *heads, - g1m_buffer_t *buffer) -{ - /* get content */ - struct cas_spe_program headers[head->count]; - READ(headers, sizeof(struct cas_spe_program) * head->count) - - /* check the sum */ - uint8_t checksum; READ(&checksum, 1) - uint8_t csum = ~g1m_checksum8(headers, - sizeof(struct cas_spe_program) * head->count) + 1; - if (csum != checksum) { - log_error("Checksum mismatch: expected 0x%02X, got 0x%02X", - csum, checksum); - return (g1m_error_checksum); - } - - /* initialize */ - for (int i = 0; i < head->count; i++) { - heads[i].size = be16toh(headers[i].length); - /* program type? */ - } - - /* everything went well :D */ - head->flags &= ~g1m_mcsflag_unfinished; - return (0); -} - /** * g1m_decode_caspart_program: * Decode a CAS program part. @@ -68,13 +30,15 @@ int g1m_decode_cashpart_program(g1m_mcshead_t *head, g1m_mcshead_t *heads, int g1m_decode_caspart_program(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { /* get content */ - READ(handle->content, handle->head.size) + READ(handle->g1m_mcsfile_content, handle->g1m_mcsfile_head.g1m_mcshead_size) log_info("Program content is:"); - logm_info(handle->content, handle->head.size); + logm_info(handle->g1m_mcsfile_content, + handle->g1m_mcsfile_head.g1m_mcshead_size); /* check the sum */ uint8_t checksum; READ(&checksum, 1) - uint8_t csum = ~g1m_checksum8(handle->content, handle->head.size) + 1; + uint8_t csum = ~g1m_checksum8(handle->g1m_mcsfile_content, + handle->g1m_mcsfile_head.g1m_mcshead_size) + 1; if (csum != checksum) { log_error("Checksum mismatch: expected 0x%02X, got 0x%02X", csum, checksum); @@ -82,6 +46,6 @@ int g1m_decode_caspart_program(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) } /* everything went well :) */ - handle->head.flags &= ~g1m_mcsflag_unfinished; + handle->g1m_mcsfile_head.g1m_mcshead_flags &= ~g1m_mcsflag_unfinished; return (0); } diff --git a/src/decode/cas/screenshot.c b/src/decode/cas/screenshot.c index 1d2cc28..4fdffd6 100644 --- a/src/decode/cas/screenshot.c +++ b/src/decode/cas/screenshot.c @@ -30,16 +30,18 @@ int g1m_decode_caspart_capture(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { /* read the picture data */ - unsigned int width = handle->head.width, height = handle->head.height; + unsigned int width = handle->g1m_mcsfile_head.g1m_mcshead_width; + unsigned int height = handle->g1m_mcsfile_head.g1m_mcshead_height; size_t pic_size = g1m_picturesize_4bit_color(width, height); uint8_t pic_data[pic_size]; READ(pic_data, pic_size) /* decode the picture data */ - int err = g1m_decode_picture(handle->pics[0], handle->head._picformat, + int err = g1m_decode_picture(handle->g1m_mcsfile_pics[0], + handle->g1m_mcsfile_head.g1m_mcshead_picformat, pic_data, width, height); if (err) { g1m_free_mcsfile(handle); return (err); } /* no error */ - handle->head.flags &= ~g1m_mcsflag_unfinished; + handle->g1m_mcsfile_head.g1m_mcshead_flags &= ~g1m_mcsflag_unfinished; return (0); } diff --git a/src/decode/casemul.c b/src/decode/casemul.c index c7dac20..6b7f219 100644 --- a/src/decode/casemul.c +++ b/src/decode/casemul.c @@ -146,16 +146,17 @@ static int read_picture(g1m_mcsfile_t **pfile, g1m_buffer_t *buffer, /* make the head and allocate file */ g1m_mcshead_t head = { - .type = g1m_mcstype_capture, - .width = pct.width, .height = pct.height, + .g1m_mcshead_type = g1m_mcstype_capture, + .g1m_mcshead_width = pct.width, + .g1m_mcshead_height = pct.height, }; - memcpy(head.name, name, strlen(name) + 1); - head.id = name[7] - '0'; + memcpy(head.g1m_mcshead_name, name, strlen(name) + 1); + head.g1m_mcshead_id = name[7] - '0'; err = g1m_make_mcsfile(pfile, &head); if (err) return (err); /* set the pixels */ - uint32_t **img = (*pfile)->pics[0]; + uint32_t **img = (*pfile)->g1m_mcsfile_pics[0]; for (int x = 0; x < pct.width; x++) for (int y = 0; y < pct.height; y++) img[y][x] = colours[*px++]; @@ -195,16 +196,17 @@ static int read_matrix(g1m_mcsfile_t **pfile, g1m_buffer_t *buffer, /* make the head and allocate file */ g1m_mcshead_t head = { - .type = g1m_mcstype_matrix, - .width = width, .height = height, + .g1m_mcshead_type = g1m_mcstype_matrix, + .g1m_mcshead_width = width, + .g1m_mcshead_height = height, }; - memcpy(head.name, name, strlen(name) + 1); - head.id = name[4] - 'A' + 1; + memcpy(head.g1m_mcshead_name, name, strlen(name) + 1); + head.g1m_mcshead_id = name[4] - 'A' + 1; err = g1m_make_mcsfile(pfile, &head); if (err) return (err); /* read the matrix */ - g1m_mcscell_t **cells = (*pfile)->cells; + g1m_mcscell_t **cells = (*pfile)->g1m_mcsfile_cells; for (unsigned int y = 0; y < height; y++) for (unsigned int x = 0; x < width; x++) { /* read the bcd */ @@ -219,9 +221,9 @@ static int read_matrix(g1m_mcsfile_t **pfile, g1m_buffer_t *buffer, /* make the cell */ cells[y][x] = (g1m_mcscell_t){ - .real = bcd, - .imgn = {}, - .flags = g1m_mcscellflag_used + .g1m_mcscell_real = bcd, + .g1m_mcscell_imgn = {}, + .g1m_mcscell_flags = g1m_mcscellflag_used }; } @@ -260,16 +262,17 @@ static int read_list(g1m_mcsfile_t **pfile, g1m_buffer_t *buffer, /* make head */ g1m_mcshead_t head = { - .type = g1m_mcstype_list, - .width = 1, .height = len + .g1m_mcshead_type = g1m_mcstype_list, + .g1m_mcshead_width = 1, + .g1m_mcshead_height = len }; - memcpy(head.name, name, strlen(name) + 1); - head.id = name[5] - '0'; + memcpy(head.g1m_mcshead_name, name, strlen(name) + 1); + head.g1m_mcshead_id = name[5] - '0'; err = g1m_make_mcsfile(pfile, &head); if (err) return (err); /* read the list */ - g1m_mcscell_t **cells = (*pfile)->cells; + g1m_mcscell_t **cells = (*pfile)->g1m_mcsfile_cells; for (int x = 0; x < len; x++) { /* read bcd */ g1m_bcd_t bcd; g1m_bcd_fromdouble(*raw++, &bcd); @@ -283,16 +286,15 @@ static int read_list(g1m_mcsfile_t **pfile, g1m_buffer_t *buffer, /* set the cell */ cells[x][0] = (g1m_mcscell_t){ - .real = bcd, - .imgn = {}, - .flags = g1m_mcscellflag_used + .g1m_mcscell_real = bcd, + .g1m_mcscell_imgn = {}, + .g1m_mcscell_flags = g1m_mcscellflag_used }; } /* no error */ return (0); } - /* ************************************************************************** */ /* Main function */ /* ************************************************************************** */ @@ -362,28 +364,28 @@ int g1m_decode_casemul(g1m_handle_t **h, g1m_buffer_t *buffer, int big_endian) /* read each picture */ for (int i = 0; i < src.pictures; i++) { log_info("Reading picture #%d", i + 1); - if ((err = read_picture(&handle->files[handle->count], buffer, - big_endian))) - goto fail; - handle->count++; + err = read_picture(&handle->g1m_handle_files[handle->g1m_handle_count], + buffer, big_endian); + if (err) goto fail; + handle->g1m_handle_count++; } /* read each matrix */ for (int i = 0; i < src.matrixes; i++) { log_info("Reading matrix #%d", i + 1); - if ((err = read_matrix(&handle->files[handle->count], buffer, - big_endian))) - goto fail; - handle->count++; + err = read_matrix(&handle->g1m_handle_files[handle->g1m_handle_count], + buffer, big_endian); + if (err) goto fail; + handle->g1m_handle_count++; } /* read each list */ for (int i = 0; i < src.lists; i++) { log_info("Reading list #%d", i + 1); - if ((err = read_list(&handle->files[handle->count], buffer, - big_endian))) - goto fail; - handle->count++; + err = read_list(&handle->g1m_handle_files[handle->g1m_handle_count], + buffer, big_endian); + if (err) goto fail; + handle->g1m_handle_count++; } /* TODO: skip compiled part? */ diff --git a/src/decode/main.c b/src/decode/main.c index 6b50dfc..6f41dd0 100644 --- a/src/decode/main.c +++ b/src/decode/main.c @@ -39,7 +39,6 @@ struct corresp { /* Correspondances */ static struct corresp correspondances[] = { // {"g1s", g1m_type_storage, g1m_decode_storage}, - {"grc", g1m_type_mcs, g1m_decode_grc}, /* terminating entry */ {NULL, 0, NULL} @@ -107,8 +106,16 @@ int g1m_decode(g1m_handle_t **handle, const char *path, g1m_buffer_t *buffer, return (g1m_decode_cas(handle, buffer)); } + /* identify a GraphCard file */ + READ(&buf[1], 2) + if (!buf[0] && buf[1] == 0x32 && buf[2] == ':') { + if (expected_types && !(expected_types & g1m_type_mcs)) + return (g1m_error_wrong_type); + return (g1m_decode_grc(handle, buffer)); + } + /* identify a Casemul file */ - READ(&buf[1], 3) + READ(&buf[3], 1) int casemul_be = !memcmp(buf, "CAFS", 4); if (casemul_be || !memcmp(buf, "ACFS", 4)) { if (expected_types && !(expected_types & g1m_type_mcs)) diff --git a/src/decode/mcs.c b/src/decode/mcs.c index f05b48d..819691e 100644 --- a/src/decode/mcs.c +++ b/src/decode/mcs.c @@ -99,19 +99,19 @@ int g1m_decode_mcsfile_head(g1m_mcshead_t *head, /* look for the raw type */ g1m_maketype_mcs(head, (char*)groupname, (char*)dirname, (char*)filename, raw_type); - head->size = filesize; - log_info("libg1m file type is 0x%08" PRIXMCSTYPE, head->type); + head->g1m_mcshead_size = filesize; + log_info("libg1m file type is 0x%08" PRIXMCSTYPE, head->g1m_mcshead_type); #if LOGLEVEL <= ll_info if (g1m_mcshead_uses_id(head)) { - log_info("libg1m file id is (%d, %d)", g1m_get_id_major(head->id), - g1m_get_id_minor(head->id)); + log_info("libg1m file id is (%d, %d)", + g1m_get_id_major(head->g1m_mcshead_id), + g1m_get_id_minor(head->g1m_mcshead_id)); } #endif /* everything went well! */ return (0); } - /* ************************************************************************** */ /* File decoding functions */ /* ************************************************************************** */ @@ -138,18 +138,19 @@ int g1m_decode_mcsfile(g1m_mcsfile_t **handle, const g1m_mcshead_t *head, g1m_mcshead_t h = *head; /* look for the decoding function */ - mcs_decode_func_t decode = lookup_mcsfile_decode(head->type); + mcs_decode_func_t decode = lookup_mcsfile_decode(head->g1m_mcshead_type); if (!decode) { log_error("No dedicated decoding function for this type was found!"); goto notparsing; } /* decode */ - if (!head->size) err = (*decode)(handle, buffer, &h); + if (!head->g1m_mcshead_size) err = (*decode)(handle, buffer, &h); else { - g1m_buffer_t lbuf = LIMBUFFER(buffer, head->size); + g1m_buffer_t lbuf = LIMBUFFER(buffer, head->g1m_mcshead_size); err = (*decode)(handle, &lbuf, &h); - if (lbuf._offset < head->size) SKIP(head->size - lbuf._offset) + if (lbuf.g1m_buffer_offset < head->g1m_mcshead_size) + SKIP(head->g1m_mcshead_size - lbuf.g1m_buffer_offset) } /* oh yeah, and go away. */ @@ -162,11 +163,11 @@ notparsing: return (err); /* read the content */ - GREAD((*handle)->content, h.size) + GREAD((*handle)->g1m_mcsfile_content, h.g1m_mcshead_size) /* log */ log_info("File content:"); - logm_info((*handle)->content, h.size); + logm_info((*handle)->g1m_mcsfile_content, h.g1m_mcshead_size); /* saved normally */ return (0); diff --git a/src/decode/mcs/cells.c b/src/decode/mcs/cells.c index dd4cfeb..a46d0cb 100644 --- a/src/decode/mcs/cells.c +++ b/src/decode/mcs/cells.c @@ -39,36 +39,37 @@ int g1m_decode_mcs_cells(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, /* log info */ uint_fast32_t w = be16toh(hd.width), - h = (head->type & g1m_mcstype_list) ? 1 : be16toh(hd.height); + h = (head->g1m_mcshead_type & g1m_mcstype_list) + ? 1 : be16toh(hd.height); log_info("Matrix size is %" PRIuFAST32 "*%" PRIuFAST32, w, h); /* make final head */ - head->width = w; - head->height = h; + head->g1m_mcshead_width = w; + head->g1m_mcshead_height = h; if ((err = g1m_make_mcsfile(handle, head))) return (err); /* main copying loop */ - g1m_mcscell_t **tab = (*handle)->cells; int one_imgn = 0; + g1m_mcscell_t **tab = (*handle)->g1m_mcsfile_cells; int one_imgn = 0; for (y = 0; y < h; y++) for (x = 0; x < w; x++) { /* read the cell */ - g1m_bcd_t bcd; GDREAD(rawbcd, bcd) + g1m_bcd_t bcd; GDREAD(rawbcd, g1m_mcsbcd_s) one_imgn |= g1m_bcd_frommcs(&rawbcd, &bcd); /* store it */ tab[y][x] = (g1m_mcscell_t){ - .real = bcd, - .imgn = {}, - .flags = g1m_mcscellflag_used + .g1m_mcscell_real = bcd, + .g1m_mcscell_imgn = {}, + .g1m_mcscell_flags = g1m_mcscellflag_used }; } /* check imaginary parts */ if (one_imgn) for (y = 0; y < h; y++) for (x = 0; x < w; x++) { - g1m_bcd_t bcd; GDREAD(rawbcd, bcd) - if (g1m_bcd_has_special(&tab[y][x].real)) { + g1m_bcd_t bcd; GDREAD(rawbcd, g1m_mcsbcd_s) + if (g1m_bcd_has_special(&tab[y][x].g1m_mcscell_real)) { g1m_bcd_frommcs(&rawbcd, &bcd); - tab[y][x].imgn = bcd; + tab[y][x].g1m_mcscell_imgn = bcd; } } @@ -76,12 +77,12 @@ int g1m_decode_mcs_cells(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, /* logging loop */ char rbuf[G1M_BCD_GOODBUFSIZE], ibuf[G1M_BCD_GOODBUFSIZE]; for (y = 0; y < h; y++) for (x = 0; x < w; x++) { - g1m_bcdtoa(&tab[y][x].real, rbuf, G1M_BCD_GOODBUFSIZE); + g1m_bcdtoa(&tab[y][x].g1m_mcscell_real, rbuf, G1M_BCD_GOODBUFSIZE); - if (g1m_bcd_has_special(&tab[y][x].real)) { - g1m_bcd_t ibcd = tab[y][x].imgn; + if (g1m_bcd_has_special(&tab[y][x].g1m_mcscell_real)) { + g1m_bcd_t ibcd = tab[y][x].g1m_mcscell_imgn; int ch = g1m_bcd_is_negative(&ibcd) ? '-' : '+'; - ibcd.flags &= ~g1m_bcdflag_neg; + ibcd.g1m_bcd_flags &= ~g1m_bcdflag_neg; g1m_bcdtoa(&ibcd, ibuf, G1M_BCD_GOODBUFSIZE); log_info("[%" PRIuFAST32 "][%" PRIuFAST32 "] %s %c %si", diff --git a/src/decode/mcs/picture.c b/src/decode/mcs/picture.c index 83d4bb3..d05a39f 100644 --- a/src/decode/mcs/picture.c +++ b/src/decode/mcs/picture.c @@ -37,22 +37,25 @@ int g1m_decode_mcs_capture(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, hd.height = be16toh(hd.height); /* make final head and file */ - head->width = hd.width; - head->height = hd.height; + head->g1m_mcshead_width = hd.width; + head->g1m_mcshead_height = hd.height; int err = g1m_make_mcsfile(handle, head); if (err) return (err); g1m_mcsfile_t *h = *handle; /* print info */ - log_info("capture is %dx%d sized", h->head.width, h->head.height); + log_info("capture is %dx%d sized", h->g1m_mcsfile_head.g1m_mcshead_width, + h->g1m_mcsfile_head.g1m_mcshead_height); /* read raw data */ - size_t pic_size = g1m_picturesize_1bit_packed(head->width, head->height); + size_t pic_size = g1m_picturesize_1bit_packed(head->g1m_mcshead_width, + head->g1m_mcshead_height); uint8_t pic_raw[pic_size]; READ(pic_raw, pic_size) /* get the image and return */ - if ((err = g1m_decode_picture(h->pics[0], g1m_pictureformat_1bit_packed, - pic_raw, head->width, head->height))) { + if ((err = g1m_decode_picture(h->g1m_mcsfile_pics[0], + g1m_pictureformat_1bit_packed, pic_raw, + head->g1m_mcshead_width, head->g1m_mcshead_height))) { g1m_free_mcsfile(*handle); *handle = NULL; return (err); @@ -76,21 +79,24 @@ int g1m_decode_mcs_picture(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, g1m_mcshead_t *head) { /* make final head */ - head->width = 128; - head->height = 64; + head->g1m_mcshead_width = 128; + head->g1m_mcshead_height = 64; int err = g1m_make_mcsfile(handle, head); if (err) return (err); g1m_mcsfile_t *h = *handle; /* get the images */ - size_t pic_size = g1m_picturesize_1bit_packed(head->width, head->height); + size_t pic_size = g1m_picturesize_1bit_packed(head->g1m_mcshead_width, + head->g1m_mcshead_height); uint8_t pics_raw[pic_size * 2]; READ(pics_raw, pic_size * 2) /* decode the images */ - if ((err = g1m_decode_picture(h->pics[0], g1m_pictureformat_1bit_packed, - pics_raw, head->width, head->height)) - || (err = g1m_decode_picture(h->pics[1], g1m_pictureformat_1bit_packed, - &pics_raw[pic_size], head->width, head->height))) { + if ((err = g1m_decode_picture(h->g1m_mcsfile_pics[0], + g1m_pictureformat_1bit_packed, pics_raw, head->g1m_mcshead_width, + head->g1m_mcshead_height)) + || (err = g1m_decode_picture(h->g1m_mcsfile_pics[1], + g1m_pictureformat_1bit_packed, &pics_raw[pic_size], + head->g1m_mcshead_width, head->g1m_mcshead_height))) { g1m_free_mcsfile(*handle); *handle = NULL; return (err); diff --git a/src/decode/mcs/program.c b/src/decode/mcs/program.c index 58499a3..2fb6259 100644 --- a/src/decode/mcs/program.c +++ b/src/decode/mcs/program.c @@ -38,18 +38,19 @@ int g1m_decode_mcs_program(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, log_info("Program password is '%.8s'.", hd.password); /* make final head and file */ - strncpy(head->password, (char*)hd.password, 8); - head->password[8] = 0; - head->size -= sizeof(struct mcs_programheader); - head->size += 1; /* terminating zero - XXX: keep it? */ + strncpy(head->g1m_mcshead_password, (char*)hd.password, 8); + head->g1m_mcshead_password[8] = 0; + head->g1m_mcshead_size -= sizeof(struct mcs_programheader); + head->g1m_mcshead_size += 1; /* terminating zero - XXX: keep it? */ err = g1m_make_mcsfile(handle, head); if (err) return (err); /* get content */ - g1m_mcsfile_t *h = *handle; size_t content_size = head->size - 1; + g1m_mcsfile_t *h = *handle; + size_t content_size = head->g1m_mcshead_size - 1; log_info("Getting program content (%" PRIuSIZE "o)", content_size); - GREAD(h->content, content_size); - h->content[content_size] = 0; + GREAD(h->g1m_mcsfile_content, content_size); + h->g1m_mcsfile_content[content_size] = 0; /* no error */ return (0); diff --git a/src/decode/mcs/setup.c b/src/decode/mcs/setup.c index 9960a2d..f36fd4b 100644 --- a/src/decode/mcs/setup.c +++ b/src/decode/mcs/setup.c @@ -32,26 +32,26 @@ int g1m_decode_mcs_setup(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, g1m_mcshead_t *head) { /* read content */ - uint8_t content[head->size]; - READ(content, head->size) + uint8_t content[head->g1m_mcshead_size]; + READ(content, head->g1m_mcshead_size) /* make final head and file */ int err = g1m_make_mcsfile(handle, head); if (err) return (err); - g1m_setup_t *sp = &(*handle)->setup; + g1m_setup_t *sp = &(*handle)->g1m_mcsfile_setup; /* get input flags */ switch (content[0x14]) { - case 0x84: sp->iflags |= g1m_setupiflag_alpha; - case 0x01: sp->iflags |= g1m_setupiflag_shift; break; - case 0x04: sp->iflags |= g1m_setupiflag_alpha; break; } - if (content[0x15] == 0x02) sp->iflags |= g1m_setupiflag_insert; - if (!content[0x53]) sp->iflags |= g1m_setupiflag_math; + case 0x84: sp->g1m_setup_iflags |= g1m_setupiflag_alpha; + case 0x01: sp->g1m_setup_iflags |= g1m_setupiflag_shift; break; + case 0x04: sp->g1m_setup_iflags |= g1m_setupiflag_alpha; break; } + if (content[0x15] == 0x02) sp->g1m_setup_iflags |= g1m_setupiflag_insert; + if (content[0x53] == 0x00) sp->g1m_setup_iflags |= g1m_setupiflag_math; /* get window flags */ - if (content[0x1C]) sp->wflags |= g1m_setupwflag_grid; - if (content[0x1D]) sp->wflags |= g1m_setupwflag_axes; - if (content[0x19]) sp->wflags |= g1m_setupwflag_plot; + if (content[0x1C]) sp->g1m_setup_wflags |= g1m_setupwflag_grid; + if (content[0x1D]) sp->g1m_setup_wflags |= g1m_setupwflag_axes; + if (content[0x19]) sp->g1m_setup_wflags |= g1m_setupwflag_plot; /* TODO: decode more options! */ /* no error! */ diff --git a/src/decode/mcs/spreadsheet.c b/src/decode/mcs/spreadsheet.c index 358b4cf..cd7f53e 100644 --- a/src/decode/mcs/spreadsheet.c +++ b/src/decode/mcs/spreadsheet.c @@ -77,14 +77,14 @@ int g1m_decode_mcs_spreadsheet(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, if (*rd & bit) { /* get cell */ g1m_bcd_t cell; - DREAD(rawcell, bcd) + DREAD(rawcell, g1m_mcsbcd_s) g1m_bcd_frommcs(&rawcell, &cell); /* store it */ cells[c * 1000 + i] = (g1m_mcscell_t){ - .real = cell, - .imgn = (g1m_bcd_t){}, - .flags = g1m_mcscellflag_used + .g1m_mcscell_real = cell, + .g1m_mcscell_imgn = (g1m_bcd_t){}, + .g1m_mcscell_flags = g1m_mcscellflag_used }; /* check things (max row, max col, cells count) */ @@ -104,15 +104,18 @@ int g1m_decode_mcs_spreadsheet(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, rows++, cols++; /* create final tab */ - head->width = 0; head->height = 0; - if (cells_count) { head->width = cols; head->height = rows; } + head->g1m_mcshead_width = 0; head->g1m_mcshead_height = 0; + if (cells_count) { + head->g1m_mcshead_width = cols; + head->g1m_mcshead_height = rows; + } int err = g1m_make_mcsfile(handle, head); if (err) return (err); /* main copying loop */ - g1m_mcscell_t **tab = (*handle)->cells; - for (uint_fast32_t y = 0; y < head->height; y++) - for (uint_fast32_t x = 0; x < head->width; x++) + g1m_mcscell_t **tab = (*handle)->g1m_mcsfile_cells; + for (uint_fast32_t y = 0; y < head->g1m_mcshead_height; y++) + for (uint_fast32_t x = 0; x < head->g1m_mcshead_width; x++) tab[y][x] = cells[x * 1000 + y]; /* no error */ diff --git a/src/decode/mcs/string.c b/src/decode/mcs/string.c index d1ad909..ecefb5d 100644 --- a/src/decode/mcs/string.c +++ b/src/decode/mcs/string.c @@ -35,7 +35,7 @@ int g1m_decode_mcs_string(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, /* print content */ log_info("String MCS file is not managed yet. Content:"); - uint_fast32_t length = head->size; + uint_fast32_t length = head->g1m_mcshead_size; uint8_t str[length]; READ(str, length); logm_info(str, length); diff --git a/src/decode/mcs/var.c b/src/decode/mcs/var.c index 354c0be..1a0c06d 100644 --- a/src/decode/mcs/var.c +++ b/src/decode/mcs/var.c @@ -31,7 +31,7 @@ int g1m_decode_mcs_var(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, g1m_mcshead_t *head) { - uint_fast32_t length = head->size; + uint_fast32_t length = head->g1m_mcshead_size; uint8_t *buf = alloca(length); int i; @@ -39,17 +39,17 @@ int g1m_decode_mcs_var(g1m_mcsfile_t **handle, g1m_buffer_t *buffer, READ(buf, length) /* complete header */ - head->count = length / (2 * sizeof(mcs_bcd_t)); + head->g1m_mcshead_count = length / (2 * sizeof(g1m_mcsbcd_t)); int err = g1m_make_mcsfile(handle, head); if (err) return (err); g1m_mcsfile_t *h = *handle; /* copy */ - const mcs_bcd_t *b = (void*)buf; - for (i = 0; i < head->count; i++) { - g1m_bcd_frommcs(b++, &h->vars[i].real); - g1m_bcd_frommcs(b++, &h->vars[i].imgn); - h->vars[i].flags = g1m_mcscellflag_used; + const g1m_mcsbcd_t *b = (void*)buf; + for (i = 0; i < head->g1m_mcshead_count; i++) { + g1m_bcd_frommcs(b++, &h->g1m_mcsfile_vars[i].g1m_mcscell_real); + g1m_bcd_frommcs(b++, &h->g1m_mcsfile_vars[i].g1m_mcscell_imgn); + h->g1m_mcsfile_vars[i].g1m_mcscell_flags = g1m_mcscellflag_used; } /* no problem, woop woop */ diff --git a/src/decode/std/addin.c b/src/decode/std/addin.c index 9203a03..5bdfbde 100644 --- a/src/decode/std/addin.c +++ b/src/decode/std/addin.c @@ -52,21 +52,25 @@ int g1m_decode_std_addin(g1m_handle_t **h, g1m_buffer_t *buffer, g1m_handle_t *handle = *h; /* log info about the subheader */ - log_info("title is '%s'", handle->title); - log_info("internal name is '%s'", handle->intname); + log_info("title is '%s'", handle->g1m_handle_title); + log_info("internal name is '%s'", handle->g1m_handle_intname); log_info("estrips count is %" PRIu8, hd.estrips_count); - log_info("version is %02u.%02u.%04u", handle->version.major, - handle->version.minor, handle->version.revision); - log_info("creation date is: %.24s", ctime(&handle->creation_date)); + log_info("version is %02u.%02u", + handle->g1m_handle_version.g1m_version_major, + handle->g1m_handle_version.g1m_version_minor); + log_info("creation date is: %.24s", + ctime(&handle->g1m_handle_creation_date)); /* fill icon */ - g1m_decode_picture(handle->icon_unsel, g1m_pictureformat_1bit, - hd.icon, handle->width, handle->height); - g1m_decode_picture(handle->icon_sel, g1m_pictureformat_1bit_r, - hd.icon, handle->width, handle->height); + g1m_decode_picture(handle->g1m_handle_icon_unsel, + g1m_pictureformat_1bit, hd.icon, + handle->g1m_handle_width, handle->g1m_handle_height); + g1m_decode_picture(handle->g1m_handle_icon_sel, + g1m_pictureformat_1bit_r, hd.icon, + handle->g1m_handle_width, handle->g1m_handle_height); /* read content */ - GREAD(handle->content, handle->size) + GREAD(handle->g1m_handle_content, handle->g1m_handle_size) /* no errors */ return (err); @@ -112,21 +116,25 @@ int g1m_decode_std_cp_addin(g1m_handle_t **h, g1m_buffer_t *buffer, g1m_handle_t *handle = *h; /* decode pictures */ - g1m_decode_picture(handle->icon_unsel, g1m_pictureformat_1bit_packed, - cphd.icon, handle->width, handle->height); - g1m_decode_picture(handle->icon_sel, g1m_pictureformat_1bit_packed_r, - cphd.icon, handle->width, handle->height); + g1m_decode_picture(handle->g1m_handle_icon_unsel, + g1m_pictureformat_1bit_packed, cphd.icon, + handle->g1m_handle_width, handle->g1m_handle_height); + g1m_decode_picture(handle->g1m_handle_icon_sel, + g1m_pictureformat_1bit_packed_r, cphd.icon, + handle->g1m_handle_width, handle->g1m_handle_height); /* log */ - log_info("title is '%s'", handle->title); - log_info("internal name is '%s'", handle->intname); - log_info("version is %02u.%02u.%04u", handle->version.major, - handle->version.minor, handle->version.revision); - log_info("timestamp is %.24s", ctime(&handle->creation_date)); + log_info("title is '%s'", handle->g1m_handle_title); + log_info("internal name is '%s'", handle->g1m_handle_intname); + log_info("version is %02u.%02u", + handle->g1m_handle_version.g1m_version_major, + handle->g1m_handle_version.g1m_version_minor); + log_info("timestamp is %.24s", ctime(&handle->g1m_handle_creation_date)); /* get content */ - GREAD(handle->content, handle->size) - *check = g1m_checksum32(handle->content, handle->size, *check); + GREAD(handle->g1m_handle_content, handle->g1m_handle_size) + *check = g1m_checksum32(handle->g1m_handle_content, + handle->g1m_handle_size, *check); /* no error */ return (0); @@ -177,21 +185,25 @@ int g1m_decode_std_cg_addin(g1m_handle_t **h, g1m_buffer_t *buffer, g1m_handle_t *handle = *h; /* decode pictures */ - g1m_decode_picture(handle->icon_unsel, g1m_pictureformat_16bit, - cghd.unselected_icon_image, handle->width, handle->height); - g1m_decode_picture(handle->icon_sel, g1m_pictureformat_16bit, - cghd.selected_icon_image, handle->width, handle->height); + g1m_decode_picture(handle->g1m_handle_icon_unsel, + g1m_pictureformat_16bit, cghd.unselected_icon_image, + handle->g1m_handle_width, handle->g1m_handle_height); + g1m_decode_picture(handle->g1m_handle_icon_sel, + g1m_pictureformat_16bit, cghd.selected_icon_image, + handle->g1m_handle_width, handle->g1m_handle_height); /* log */ - log_info("title is '%s'", handle->title); - log_info("internal name is '%s'", handle->intname); - log_info("version is %02u.%02u.%04u", handle->version.major, - handle->version.minor, handle->version.revision); - log_info("timestamp is %.24s", ctime(&handle->creation_date)); + log_info("title is '%s'", handle->g1m_handle_title); + log_info("internal name is '%s'", handle->g1m_handle_intname); + log_info("version is %02u.%02u", + handle->g1m_handle_version.g1m_version_major, + handle->g1m_handle_version.g1m_version_minor); + log_info("timestamp is %.24s", ctime(&handle->g1m_handle_creation_date)); /* read content */ - GREAD(handle->content, handle->size) - *check = g1m_checksum32(handle->content, handle->size, *check); + GREAD(handle->g1m_handle_content, handle->g1m_handle_size) + *check = g1m_checksum32(handle->g1m_handle_content, + handle->g1m_handle_size, *check); /* no error */ return (0); diff --git a/src/decode/std/eact.c b/src/decode/std/eact.c index 24f0d15..7ced2d4 100644 --- a/src/decode/std/eact.c +++ b/src/decode/std/eact.c @@ -42,10 +42,10 @@ static int eact_decode_content_eact(g1m_line_t *handle, uint8_t *buf, unsigned long int i; /* initialize the handle */ - handle->type = g1m_linetype_eact; - handle->count = 0; - handle->_size = 0; - handle->lines = NULL; + handle->g1m_line_type = g1m_linetype_eact; + handle->g1m_line_count = 0; + handle->g1m_line__size = 0; + handle->g1m_line_lines = NULL; /* check if the buffer is non-empty */ if (!bufsize) return (0); @@ -67,11 +67,12 @@ static int eact_decode_content_eact(g1m_line_t *handle, uint8_t *buf, struct line_descriptor *lds = (void*)&buf[sizeof(struct eact_eactheader)]; /* prepare the handle */ - handle->count = 0; - handle->_size = ehd.line_count; - handle->lines = malloc(sizeof(g1m_line_t*) * handle->_size); - if (!handle->lines) return (g1m_error_alloc); - bzero(handle->lines, sizeof(g1m_line_t*) * handle->_size); + handle->g1m_line_count = 0; + handle->g1m_line__size = ehd.line_count; + handle->g1m_line_lines = + malloc(sizeof(g1m_line_t*) * handle->g1m_line__size); + if (!handle->g1m_line_lines) return (g1m_error_alloc); + bzero(handle->g1m_line_lines, sizeof(g1m_line_t*) * handle->g1m_line__size); /* browse the lines */ log_info("%" PRIu32 " lines to browse", ehd.line_count); @@ -111,7 +112,7 @@ static int eact_decode_content_eact(g1m_line_t *handle, uint8_t *buf, if (err) goto loop_fail; /* store and continue */ - handle->lines[handle->count++] = line; + handle->g1m_line_lines[handle->g1m_line_count++] = line; continue; loop_fail: @@ -166,13 +167,13 @@ static int eact_decode_line_content(g1m_line_t *handle, uint8_t *buf, memcpy(&hd, buf, could_read); /* store info */ - bzero(handle->name, 17); + bzero(handle->g1m_line_name, 17); size_t namesize = max(could_read - 8, 16); - strncpy(handle->name, (char*)hd.name, namesize); + strncpy(handle->g1m_line_name, (char*)hd.name, namesize); /* log info */ log_info("Type is '%.8s'", hd.type); - log_info("Name is '%s'", handle->name); + log_info("Name is '%s'", handle->g1m_line_name); /* prepare for next */ buf += could_read; @@ -264,9 +265,9 @@ static int eact_decode_line_stdheading(g1m_line_t *handle, uint8_t *buf, logm_info(buf, size); /* set handle info */ - handle->type = g1m_linetype_text; - handle->content = strdup((char*)buf); - if (!handle->content) return (g1m_error_alloc); + handle->g1m_line_type = g1m_linetype_text; + handle->g1m_line_content = strdup((char*)buf); + if (!handle->g1m_line_content) return (g1m_error_alloc); /* no error */ return (0); @@ -301,12 +302,12 @@ static int eact_decode_line_picture(g1m_line_t *handle, uint8_t *buf, if (sz == (size_t)-1) return (g1m_error_magic); /* make the string */ - handle->content = malloc(sizeof(FONTCHARACTER) * (sz + 1)); - if (!handle->content) return (g1m_error_alloc); - g1m_wcstombs(handle->content, s, 0); + handle->g1m_line_content = malloc(sizeof(FONTCHARACTER) * (sz + 1)); + if (!handle->g1m_line_content) return (g1m_error_alloc); + g1m_wcstombs(handle->g1m_line_content, s, 0); /* don't forget to set the handle type! */ - handle->type = g1m_linetype_picture; + handle->g1m_line_type = g1m_linetype_picture; /* no error */ return (0); @@ -331,9 +332,9 @@ static int eact_decode_line_text(g1m_line_t *handle, uint8_t *buf, size_t size) logm_info(buf, size); /* set handle info */ - handle->type = g1m_linetype_text; - handle->content = strdup((char*)buf); - if (!handle->content) return (g1m_error_alloc); + handle->g1m_line_type = g1m_linetype_text; + handle->g1m_line_content = strdup((char*)buf); + if (!handle->g1m_line_content) return (g1m_error_alloc); /* TODO: manage text coloration */ /* no error */ @@ -406,7 +407,7 @@ static int eact_decode_line(g1m_line_t *handle, uint8_t *buf, size_t size, uint_fast8_t type) { /* initialize handle */ - handle->type = 0x00; + handle->g1m_line_type = 0x00; /* look for the line type */ struct eact_line_type_corresp *linetype = eact_line_types; @@ -467,10 +468,10 @@ int g1m_decode_std_eact(g1m_handle_t **h, g1m_buffer_t *buffer, SKIP(hd.setup_area_size) /* prepare the handle */ - handle->type = g1m_type_eact; - handle->platform = g1m_platform_fx; + handle->g1m_handle_type = g1m_type_eact; + handle->g1m_handle_platform = g1m_platform_fx; if (hd.eact_version == EACT_G3E) /* check if fx-CG */ - handle->platform = g1m_platform_cg; + handle->g1m_handle_platform = g1m_platform_cg; /* get content buffer */ size_t bufsize = hd.filesize - sizeof(struct standard_header) @@ -479,8 +480,8 @@ int g1m_decode_std_eact(g1m_handle_t **h, g1m_buffer_t *buffer, GREAD(&buf, bufsize) /* decode content */ - handle->line = &handle->_linedata; - return (eact_decode_line_content(handle->line, buf, bufsize)); + handle->g1m_handle_line = &handle->g1m_handle__linedata; + return (eact_decode_line_content(handle->g1m_handle_line, buf, bufsize)); fail: g1m_free(*h); *h = NULL; return (err); diff --git a/src/decode/std/fkey.c b/src/decode/std/fkey.c index daf7030..a55f2c7 100644 --- a/src/decode/std/fkey.c +++ b/src/decode/std/fkey.c @@ -96,19 +96,20 @@ int g1m_decode_std_fkey(g1m_handle_t **h, g1m_buffer_t *buffer, uint8_t *fkeys = (uint8_t*)(offsets + num); /* read the function keys name */ - handle->title[16] = 0; - strncpy(handle->title, (char*)fkeys, 16); + handle->g1m_handle_title[16] = 0; + strncpy(handle->g1m_handle_title, (char*)fkeys, 16); /* read all */ - for (handle->count = 0; handle->count < (int)num; handle->count++) { - int i = handle->count; + for (handle->g1m_handle_count = 0; handle->g1m_handle_count < (int)num; + handle->g1m_handle_count++) { + int i = handle->g1m_handle_count; if (offsets[i] == (uint16_t)-1) continue ; offsets[i] = be16toh(offsets[i]); /* store */ - handle->fkeys[i] = fkeydup(&fkeys[i]); - if (!handle->fkeys[i]) goto fail; + handle->g1m_handle_fkeys[i] = fkeydup(&fkeys[i]); + if (!handle->g1m_handle_fkeys[i]) goto fail; } /* no error */ @@ -166,8 +167,9 @@ int g1m_decode_std_cg_fkey(g1m_handle_t **h, g1m_buffer_t *buffer, uint8_t *messages = (uint8_t*)&offsets[num + 1]; /* read messages */ - for (handle->count = 0; handle->count < (int)num; handle->count++) { - int i = handle->count; + for (handle->g1m_handle_count = 0; handle->g1m_handle_count < (int)num; + handle->g1m_handle_count++) { + int i = handle->g1m_handle_count; if (offsets[i] == (uint32_t)-1) { log_info("[#%d] -", i); continue; @@ -179,8 +181,8 @@ int g1m_decode_std_cg_fkey(g1m_handle_t **h, g1m_buffer_t *buffer, &messages[offsets[i]], offsets[i]); /* store */ - handle->fkeys[i] = fkeydup3((void*)&messages[offsets[i]]); - if (!handle->fkeys[i]) goto fail; + handle->g1m_handle_fkeys[i] = fkeydup3((void*)&messages[offsets[i]]); + if (!handle->g1m_handle_fkeys[i]) goto fail; } /* done */ diff --git a/src/decode/std/lang.c b/src/decode/std/lang.c index f884a0f..b1375da 100644 --- a/src/decode/std/lang.c +++ b/src/decode/std/lang.c @@ -58,8 +58,9 @@ int g1m_decode_std_lang(g1m_handle_t **h, g1m_buffer_t *buffer, char *messages = (char*)(offsets + num); /* read messages */ - for (handle->count = 0; handle->count < (int)num; handle->count++) { - int i = handle->count; + for (handle->g1m_handle_count = 0; handle->g1m_handle_count < (int)num; + handle->g1m_handle_count++) { + int i = handle->g1m_handle_count; if (offsets[i] == (uint16_t)-1) { log_info("[#%d] -", i); continue; @@ -71,9 +72,9 @@ int g1m_decode_std_lang(g1m_handle_t **h, g1m_buffer_t *buffer, &messages[offsets[i]], offsets[i]); /* store */ - handle->messages[i] = strdup(&messages[offsets[i]]); - if (!handle->messages[i]) goto fail; - handle->count++; + handle->g1m_handle_messages[i] = strdup(&messages[offsets[i]]); + if (!handle->g1m_handle_messages[i]) goto fail; + handle->g1m_handle_count++; } /* no error */ @@ -131,8 +132,9 @@ int g1m_decode_std_cg_lang(g1m_handle_t **h, g1m_buffer_t *buffer, uint8_t *messages = (uint8_t*)&offsets[num + 1]; /* read messages */ - for (handle->count = 0; handle->count < (int)num; handle->count++) { - int i = handle->count; + for (handle->g1m_handle_count = 0; handle->g1m_handle_count < (int)num; + handle->g1m_handle_count++) { + int i = handle->g1m_handle_count; if (offsets[i] == (uint32_t)-1) { log_info("[#%d] -", i); continue; @@ -144,8 +146,8 @@ int g1m_decode_std_cg_lang(g1m_handle_t **h, g1m_buffer_t *buffer, &messages[offsets[i]], offsets[i]); /* store */ - handle->messages[i] = strdup((char*)&messages[offsets[i]]); - if (!handle->messages[i]) goto fail; + handle->g1m_handle_messages[i] = strdup((char*)&messages[offsets[i]]); + if (!handle->g1m_handle_messages[i]) goto fail; } /* done */ diff --git a/src/decode/std/mcs.c b/src/decode/std/mcs.c index 74248ea..6386c03 100644 --- a/src/decode/std/mcs.c +++ b/src/decode/std/mcs.c @@ -44,7 +44,7 @@ int g1m_decode_std_mcs(g1m_handle_t **h, g1m_buffer_t *buffer, /* read all of the parts */ log_info("%" PRIuFAST16 " total mcs files to browse", num); - for (handle->count = 0; handle->count < (int)num;) { + for (handle->g1m_handle_count = 0; handle->g1m_handle_count < (int)num;) { /* get the subheader */ GDREAD(hd, mcs_subheader) @@ -74,11 +74,12 @@ int g1m_decode_std_mcs(g1m_handle_t **h, g1m_buffer_t *buffer, fhd.dirname, fhd.filename, fhd.datalength); /* decode */ - handle->files[handle->count] = NULL; - err = g1m_decode_mcsfile(&handle->files[handle->count], + handle->g1m_handle_files[handle->g1m_handle_count] = NULL; + err = g1m_decode_mcsfile( + &handle->g1m_handle_files[handle->g1m_handle_count], &head, buffer); if (err) goto fail; - handle->count++; + handle->g1m_handle_count++; } } diff --git a/src/decode/std/picture.c b/src/decode/std/picture.c index 150b729..aad2750 100644 --- a/src/decode/std/picture.c +++ b/src/decode/std/picture.c @@ -126,8 +126,8 @@ int g1m_decode_std_g3p(g1m_handle_t **h, g1m_buffer_t *buffer, g1m_handle_t *handle = *h; /* then store it */ - g1m_decode_picture(handle->pixels, picfmt, - infbuf, handle->width, handle->height); + g1m_decode_picture(handle->g1m_handle_pixels, picfmt, + infbuf, handle->g1m_handle_width, handle->g1m_handle_height); free(infbuf); infbuf = NULL; /* TODO: footers? */ diff --git a/src/encode/addin.c b/src/encode/addin.c index a5c7dd9..2413917 100644 --- a/src/encode/addin.c +++ b/src/encode/addin.c @@ -30,7 +30,7 @@ int g1m_announce_addin(g1m_handle_t *handle, size_t *size) { *size += sizeof(struct standard_header) + sizeof(struct g1a_subheader); - *size += handle->size; + *size += handle->g1m_handle_size; return (0); } @@ -67,17 +67,18 @@ int g1m_encode_addin(g1m_handle_t *handle, g1m_buffer_t *buffer) struct g1a_subheader sub = { .estrips_count = 0, .filesize = htobe32(filesize)}; - strncpy((char*)sub.title, handle->title, 8); - strncpy((char*)sub.internal_name, handle->intname, 8); - g1m_encode_version(&handle->version, (char*)sub.version); - g1m_encode_date(&handle->creation_date, (char*)sub.creation_date); - g1m_encode_picture((const uint32_t**)handle->icon_unsel, + strncpy((char*)sub.title, handle->g1m_handle_title, 8); + strncpy((char*)sub.internal_name, handle->g1m_handle_intname, 8); + g1m_encode_version(&handle->g1m_handle_version, (char*)sub.version); + g1m_encode_date(&handle->g1m_handle_creation_date, + (char*)sub.creation_date); + g1m_encode_picture((const uint32_t**)handle->g1m_handle_icon_unsel, g1m_pictureformat_1bit, sub.icon, G1A_ICON_WIDTH, G1A_ICON_HEIGHT); DWRITE(sub) /* output the content */ - WRITE(handle->content, handle->size) + WRITE(handle->g1m_handle_content, handle->g1m_handle_size) /* no error! */ return (0); diff --git a/src/encode/main.c b/src/encode/main.c index 3c3f2a9..69716c8 100644 --- a/src/encode/main.c +++ b/src/encode/main.c @@ -62,28 +62,28 @@ int g1m_encode(g1m_handle_t *handle, g1m_buffer_t *buffer) /* find the announcement and encoding function */ const struct corresp *c = encodings - 1; while ((++c)->encode) { - if (c->types && !(c->types & handle->type)) + if (c->types && !(c->types & handle->g1m_handle_type)) continue; - if (c->platforms && !(c->platforms & handle->platform)) + if (c->platforms && !(c->platforms & handle->g1m_handle_platform)) continue; break; } if (!c->encode) return (g1m_error_op); /* announce, if necessary */ - if (buffer->announce) { + if (buffer->g1m_buffer_announce) { size_t size = 0; if ((err = (*c->announce)(handle, &size)) - || (err = (*buffer->announce)(buffer->cookie, size))) + || (err = (*buffer->g1m_buffer_announce)(buffer->g1m_buffer_cookie, + size))) return (err); } /* encode */ - if (buffer->write) { + if (buffer->g1m_buffer_write) { err = (*c->encode)(handle, buffer); - if (err && buffer->unannounce) { - (*buffer->unannounce)(buffer->cookie); - return (err); - } + if (err && buffer->g1m_buffer_unannounce) + (*buffer->g1m_buffer_unannounce)(buffer->g1m_buffer_cookie); + return (err); } /* everything went well! */ diff --git a/src/encode/mcs.c b/src/encode/mcs.c index fc8a4d4..039a92d 100644 --- a/src/encode/mcs.c +++ b/src/encode/mcs.c @@ -57,7 +57,7 @@ static const struct corresp encodings[] = { static int default_announce(const g1m_mcsfile_t *handle, size_t *sz) { - *sz += handle->head.size; + *sz += handle->g1m_mcsfile_head.g1m_mcshead_size; return (0); } @@ -72,7 +72,8 @@ static int default_announce(const g1m_mcsfile_t *handle, size_t *sz) static int default_encode(const g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { - WRITE(handle->content, handle->head.size) + WRITE(handle->g1m_mcsfile_content, + handle->g1m_mcsfile_head.g1m_mcshead_size) return (0); } @@ -99,25 +100,27 @@ int g1m_encode_mcsfile(g1m_mcsfile_t *handle, g1m_buffer_t *buffer) if (!c->types) c = &default_corresp; else { while ((++c)->encode) { - if (c->types && !(c->types & handle->head.type)) + if (c->types && !(c->types & handle->g1m_mcsfile_head + .g1m_mcshead_type)) continue; break; } if (!c->encode) return (g1m_error_op); } /* announce if necessary */ - if (buffer->announce) { + if (buffer->g1m_buffer_announce) { size_t size = 0; if ((err = (*c->announce)(handle, &size)) - || (err = (*buffer->announce)(buffer->cookie, size))) + || (err = (*buffer->g1m_buffer_announce)(buffer->g1m_buffer_cookie, + size))) return (err); } /* encode */ - if (buffer->write) { + if (buffer->g1m_buffer_write) { err = (*c->encode)(handle, buffer); - if (err && buffer->unannounce) { - (*buffer->unannounce)(buffer->cookie); + if (err && buffer->g1m_buffer_unannounce) { + (*buffer->g1m_buffer_unannounce)(buffer->g1m_buffer_cookie); return (err); } } diff --git a/src/encode/mcs/cells.c b/src/encode/mcs/cells.c index 0d84516..9f9c7ff 100644 --- a/src/encode/mcs/cells.c +++ b/src/encode/mcs/cells.c @@ -30,14 +30,15 @@ int g1m_announce_mcs_cells(const g1m_mcsfile_t *handle, size_t *sz) { unsigned int y, x; - size_t content_size = handle->head.height * handle->head.width - * sizeof(mcs_bcd_t); + size_t content_size = handle->g1m_mcsfile_head.g1m_mcshead_height + * handle->g1m_mcsfile_head.g1m_mcshead_width * sizeof(g1m_mcsbcd_t); *sz += sizeof(struct mcs_cellsheader) + content_size; /* check if there's an imaginary part */ - for (y = 0; y < handle->head.height; y++) - for (x = 0; x < handle->head.width; x++) { - if (g1m_bcd_has_special(&handle->cells[y][x].real)) { + for (y = 0; y < handle->g1m_mcsfile_head.g1m_mcshead_height; y++) + for (x = 0; x < handle->g1m_mcsfile_head.g1m_mcshead_width; x++) { + if (g1m_bcd_has_special(&handle->g1m_mcsfile_cells[y][x] + .g1m_mcscell_real)) { *sz += content_size; return (0); } @@ -60,9 +61,9 @@ int g1m_encode_mcs_cells(const g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { unsigned int y, x; struct mcs_cellsheader hd = { - .height = htobe16(handle->head.height), - .width = (handle->head.type & g1m_mcstype_list) ? 1 - : htobe16(handle->head.width), + .height = htobe16(handle->g1m_mcsfile_head.g1m_mcshead_height), + .width = (handle->g1m_mcsfile_head.g1m_mcshead_type & g1m_mcstype_list) + ? 1 : htobe16(handle->g1m_mcsfile_head.g1m_mcshead_width), ._undocumented = {0}}; /* write the header */ @@ -70,18 +71,23 @@ int g1m_encode_mcs_cells(const g1m_mcsfile_t *handle, g1m_buffer_t *buffer) /* write the real parts */ int one_imgn = 0; - for (y = 0; y < handle->head.height; y++) - for (x = 0; x < handle->head.width; x++) { - mcs_bcd_t rawbcd; g1m_bcd_tomcs(&handle->cells[y][x].real, &rawbcd); + for (y = 0; y < handle->g1m_mcsfile_head.g1m_mcshead_height; y++) + for (x = 0; x < handle->g1m_mcsfile_head.g1m_mcshead_width; x++) { + g1m_mcsbcd_t rawbcd; g1m_bcd_tomcs(&handle->g1m_mcsfile_cells[y][x] + .g1m_mcscell_real, &rawbcd); DWRITE(rawbcd) - one_imgn |= g1m_bcd_has_special(&handle->cells[y][x].real); + one_imgn |= g1m_bcd_has_special(&handle->g1m_mcsfile_cells[y][x] + .g1m_mcscell_real); } /* write the imaginary parts */ - if (one_imgn) for (y = 0; y < handle->head.height; y++) - for (x = 0; x < handle->head.width; x++) { - mcs_bcd_t rawbcd; g1m_bcd_tomcs(&handle->cells[y][x].imgn, &rawbcd); + if (one_imgn) + for (y = 0; y < handle->g1m_mcsfile_head.g1m_mcshead_height; y++) + for (x = 0; x < handle->g1m_mcsfile_head.g1m_mcshead_width; x++) { + g1m_mcsbcd_t rawbcd; + g1m_bcd_tomcs(&handle->g1m_mcsfile_cells[y][x] + .g1m_mcscell_imgn, &rawbcd); DWRITE(rawbcd) } diff --git a/src/encode/mcs/program.c b/src/encode/mcs/program.c index afc451a..6cd81de 100644 --- a/src/encode/mcs/program.c +++ b/src/encode/mcs/program.c @@ -29,7 +29,8 @@ int g1m_announce_mcs_program(const g1m_mcsfile_t *handle, size_t *sz) { - *sz += sizeof(struct mcs_programheader) + handle->head.size; + *sz += sizeof(struct mcs_programheader) + + handle->g1m_mcsfile_head.g1m_mcshead_size; return (0); } @@ -46,11 +47,13 @@ int g1m_encode_mcs_program(const g1m_mcsfile_t *handle, g1m_buffer_t *buffer) { /* write the header */ struct mcs_programheader hd = {}; - memcpy(hd.password, handle->head.password, strlen(handle->head.password)); + memcpy(hd.password, handle->g1m_mcsfile_head.g1m_mcshead_password, + strlen(handle->g1m_mcsfile_head.g1m_mcshead_password)); DWRITE(hd) /* write the program content */ - WRITE(handle->content, handle->head.size) + WRITE(handle->g1m_mcsfile_content, + handle->g1m_mcsfile_head.g1m_mcshead_size) /* no error! */ return (0); diff --git a/src/encode/mcs/var.c b/src/encode/mcs/var.c index fdaade7..7424b7c 100644 --- a/src/encode/mcs/var.c +++ b/src/encode/mcs/var.c @@ -29,7 +29,7 @@ int g1m_announce_mcs_var(const g1m_mcsfile_t *handle, size_t *sz) { - *sz += sizeof(mcs_bcd_t) * handle->head.count; + *sz += sizeof(g1m_mcsbcd_t) * handle->g1m_mcsfile_head.g1m_mcshead_count; return (0); } @@ -47,11 +47,13 @@ int g1m_encode_mcs_var(const g1m_mcsfile_t *handle, g1m_buffer_t *buffer) int i; /* encode each variable */ - for (i = 0; i < handle->head.count; i++) { + for (i = 0; i < handle->g1m_mcsfile_head.g1m_mcshead_count; i++) { /* write real and imaginary part */ - mcs_bcd_t rawbcd; - g1m_bcd_tomcs(&handle->vars[i].real, &rawbcd); DWRITE(rawbcd) - g1m_bcd_tomcs(&handle->vars[i].imgn, &rawbcd); DWRITE(rawbcd) + g1m_mcsbcd_t rawbcd; + g1m_bcd_tomcs(&handle->g1m_mcsfile_vars[i].g1m_mcscell_real, &rawbcd); + DWRITE(rawbcd) + g1m_bcd_tomcs(&handle->g1m_mcsfile_vars[i].g1m_mcscell_imgn, &rawbcd); + DWRITE(rawbcd) } /* no error! */ diff --git a/src/manage/handle.c b/src/manage/handle.c index b8d9e2e..2bdebb4 100644 --- a/src/manage/handle.c +++ b/src/manage/handle.c @@ -39,12 +39,13 @@ int g1m_make_picture(g1m_handle_t **h, unsigned int width, unsigned int height) { /* make the handle */ mkhandle(); - handle->type = g1m_type_picture; - handle->width = width; - handle->height = height; - handle->pixels = alloc_pixels(width, height); - if (!handle->pixels) { free(*h); *h = NULL; return (g1m_error_alloc); } - prepare_pixels(handle->pixels, width, height) + handle->g1m_handle_type = g1m_type_picture; + handle->g1m_handle_width = width; + handle->g1m_handle_height = height; + handle->g1m_handle_pixels = alloc_pixels(width, height); + if (!handle->g1m_handle_pixels) { + free(*h); *h = NULL; return (g1m_error_alloc); } + prepare_pixels(handle->g1m_handle_pixels, width, height) /* everything went well! */ return (0); @@ -63,17 +64,18 @@ int g1m_make_mcs(g1m_handle_t **h, int count) { /* make the handle */ mkhandle(); - handle->type = g1m_type_mcs; - handle->platform = g1m_platform_fx; - handle->count = 0; handle->_size = 0; - handle->files = NULL; + handle->g1m_handle_type = g1m_type_mcs; + handle->g1m_handle_platform = g1m_platform_fx; + handle->g1m_handle_count = 0; + handle->g1m_handle__size = 0; + handle->g1m_handle_files = NULL; /* allocate space */ if (count) { - handle->files = malloc(sizeof(g1m_mcsfile_t*) * count); - if (!handle->files) goto fail; - memset(handle->files, 0, sizeof(g1m_mcsfile_t*) * count); - handle->_size = count; + handle->g1m_handle_files = malloc(sizeof(g1m_mcsfile_t*) * count); + if (!handle->g1m_handle_files) goto fail; + memset(handle->g1m_handle_files, 0, sizeof(g1m_mcsfile_t*) * count); + handle->g1m_handle__size = count; } /* no error */ @@ -97,17 +99,18 @@ int g1m_make_fkey(g1m_handle_t **h, g1m_platform_t pf, int count) { /* make the handle */ mkhandle(); - handle->type = g1m_type_fkey; - handle->platform = pf; - handle->count = 0; handle->_size = 0; - handle->fkeys = NULL; + handle->g1m_handle_type = g1m_type_fkey; + handle->g1m_handle_platform = pf; + handle->g1m_handle_count = 0; + handle->g1m_handle__size = 0; + handle->g1m_handle_fkeys = NULL; /* allocate index */ if (count) { - handle->fkeys = malloc(sizeof(uint32_t**) * count); - if (!handle->fkeys) goto fail; - memset(handle->fkeys, 0, sizeof(uint32_t**) * count); - handle->_size = count; + handle->g1m_handle_fkeys = malloc(sizeof(uint32_t**) * count); + if (!handle->g1m_handle_fkeys) goto fail; + memset(handle->g1m_handle_fkeys, 0, sizeof(uint32_t**) * count); + handle->g1m_handle__size = count; } /* no error */ @@ -131,17 +134,18 @@ int g1m_make_lang(g1m_handle_t **h, g1m_platform_t platform, int count) { /* make the handle */ mkhandle(); - handle->type = g1m_type_lang; - handle->platform = platform; - handle->count = 0; handle->_size = 0; - handle->messages = NULL; + handle->g1m_handle_type = g1m_type_lang; + handle->g1m_handle_platform = platform; + handle->g1m_handle_count = 0; + handle->g1m_handle__size = 0; + handle->g1m_handle_messages = NULL; /* allocate index */ if (count) { - handle->messages = malloc(sizeof(char*) * count); - if (!handle->messages) goto fail; - memset(handle->messages, 0, sizeof(char*) * count); - handle->_size = count; + handle->g1m_handle_messages = malloc(sizeof(char*) * count); + if (!handle->g1m_handle_messages) goto fail; + memset(handle->g1m_handle_messages, 0, sizeof(char*) * count); + handle->g1m_handle__size = count; } /* no error */ @@ -182,15 +186,15 @@ int g1m_make_addin(g1m_handle_t **h, g1m_platform_t platform, size_t size, /* make the handle */ mkhandle(); - handle->type = g1m_type_addin; - handle->platform = platform; - handle->version = *version; - handle->creation_date = *created; - handle->size = size; + handle->g1m_handle_type = g1m_type_addin; + handle->g1m_handle_platform = platform; + handle->g1m_handle_version = *version; + handle->g1m_handle_creation_date = *created; + handle->g1m_handle_size = size; /* allocate the content */ - handle->content = malloc(size); - if (!handle->content) goto fail; + handle->g1m_handle_content = malloc(size); + if (!handle->g1m_handle_content) goto fail; /* check the platform */ unsigned int width, height; @@ -211,28 +215,29 @@ int g1m_make_addin(g1m_handle_t **h, g1m_platform_t platform, size_t size, /* copy the addin title */ int i; for (i = 0; (isupper(name[i]) || isdigit(name[i])) && i < titlesize; i++) - handle->title[i] = name[i]; - handle->title[i] = 0; - if (!handle->title[0]) strcpy(handle->title, "@ADDIN"); + handle->g1m_handle_title[i] = name[i]; + handle->g1m_handle_title[i] = 0; + if (!handle->g1m_handle_title[0]) + strcpy(handle->g1m_handle_title, "@ADDIN"); /* copy the internal name */ - handle->intname[0] = '@'; + handle->g1m_handle_intname[0] = '@'; for (i = 1; (isupper(internal[i]) || isdigit(internal[i])) && i < intsize; i++) - handle->intname[i] = internal[i]; - handle->intname[i] = 0; + handle->g1m_handle_intname[i] = internal[i]; + handle->g1m_handle_intname[i] = 0; /* allocate pictures */ - handle->icon_unsel = alloc_pixels(width, height); - if (!handle->icon_unsel) goto fail; - handle->icon_sel = alloc_pixels(width, height); - if (!handle->icon_sel) goto fail; + handle->g1m_handle_icon_unsel = alloc_pixels(width, height); + if (!handle->g1m_handle_icon_unsel) goto fail; + handle->g1m_handle_icon_sel = alloc_pixels(width, height); + if (!handle->g1m_handle_icon_sel) goto fail; /* prepare pictures */ - handle->width = width; - handle->height = height; - prepare_pixels(handle->icon_unsel, width, height) - prepare_pixels(handle->icon_sel, width, height) + handle->g1m_handle_width = width; + handle->g1m_handle_height = height; + prepare_pixels(handle->g1m_handle_icon_unsel, width, height) + prepare_pixels(handle->g1m_handle_icon_sel, width, height) /* end my suffering */ return (0); @@ -259,51 +264,52 @@ void g1m_free(g1m_handle_t *handle) if (!handle) return ; /* addin time! */ - if (handle->type & g1m_type_addin) { - free(handle->content); - free(handle->icon_unsel); - free(handle->icon_sel); + if (handle->g1m_handle_type & g1m_type_addin) { + free(handle->g1m_handle_content); + free(handle->g1m_handle_icon_unsel); + free(handle->g1m_handle_icon_sel); } /* mcs time! */ - if (handle->type & g1m_type_mcs) { + if (handle->g1m_handle_type & g1m_type_mcs) { /* check if mcs */ - if (!handle->files) + if (!handle->g1m_handle_files) return ; /* foreach file in mcs */ - g1m_mcsfile_t **files = handle->files; - int file_count = handle->count; + g1m_mcsfile_t **files = handle->g1m_handle_files; + int file_count = handle->g1m_handle_count; for (i = 0; i < file_count; i++) { /* free the file if exists */ if (files[i]) g1m_free_mcsfile(files[i]); } - free(handle->files); handle->files = NULL; + free(handle->g1m_handle_files); + handle->g1m_handle_files = NULL; } /* messages time! */ - if (handle->type & g1m_type_lang - && handle->messages) { - for (i = 0; i < handle->count; i++) - free(handle->messages[i]); - free(handle->messages); + if (handle->g1m_handle_type & g1m_type_lang + && handle->g1m_handle_messages) { + for (i = 0; i < handle->g1m_handle_count; i++) + free(handle->g1m_handle_messages[i]); + free(handle->g1m_handle_messages); } /* function keys time! */ - if (handle->type & g1m_type_fkey - && handle->fkeys) { - for (i = 0; i < handle->count; i++) - free(handle->fkeys[i]); - free(handle->fkeys); + if (handle->g1m_handle_type & g1m_type_fkey + && handle->g1m_handle_fkeys) { + for (i = 0; i < handle->g1m_handle_count; i++) + free(handle->g1m_handle_fkeys[i]); + free(handle->g1m_handle_fkeys); } /* picture time! */ - if (handle->type & g1m_type_picture) - free(handle->pixels); + if (handle->g1m_handle_type & g1m_type_picture) + free(handle->g1m_handle_pixels); /* e-activities time! */ - if (handle->type & g1m_type_eact) - g1m_free_line_content(handle->line); + if (handle->g1m_handle_type & g1m_type_eact) + g1m_free_line_content(handle->g1m_handle_line); /* free the handle itself! */ free(handle); diff --git a/src/manage/mcs.c b/src/manage/mcs.c index 291c0f4..43be4ac 100644 --- a/src/manage/mcs.c +++ b/src/manage/mcs.c @@ -37,39 +37,44 @@ int g1m_mcs_insert(g1m_handle_t *handle, g1m_mcsfile_t **tofile, const g1m_mcshead_t *head) { g1m_mcsfile_t **pfile = NULL; *tofile = NULL; - int i, istyp, err; + int i, err; /* look if this file isn't already in the tab */ - istyp = g1m_mcshead_uses_id(head); - for (i = 0; i < handle->count; i++) { - g1m_mcsfile_t *file = handle->files[i]; + int istyp = g1m_mcshead_uses_id(head); + for (i = 0; i < handle->g1m_handle_count; i++) { + g1m_mcsfile_t *file = handle->g1m_handle_files[i]; if (!file) { - pfile = &handle->files[i]; + pfile = &handle->g1m_handle_files[i]; continue; } /* loop assertions */ - if (file->head.type != head->type) + if (file->g1m_mcsfile_head.g1m_mcshead_type != head->g1m_mcshead_type) continue; - if (head->type) { + if (head->g1m_mcshead_type) { if (istyp) { - if (head->id != file->head.id) + if (head->g1m_mcshead_id + != file->g1m_mcsfile_head.g1m_mcshead_id) continue; - } else if (strcmp(file->head.name, head->name)) + } else if (strcmp(file->g1m_mcsfile_head.g1m_mcshead_name, + head->g1m_mcshead_name)) continue; - } else switch (head->info) { + } else switch (head->g1m_mcshead_info) { case g1m_mcsinfo_mcs: - if (strncmp((char*)head->_group, (char*)file->head._group, 16)) + if (strncmp((char*)head->g1m_mcshead_group, + (char*)file->g1m_mcsfile_head.g1m_mcshead_group, 16)) continue; - if (strncmp((char*)head->_dirname, (char*)file->head._dirname, 8)) + if (strncmp((char*)head->g1m_mcshead_dirname, + (char*)file->g1m_mcsfile_head.g1m_mcshead_dirname, 8)) continue; - if (strncmp((char*)head->name, (char*)file->head.name, 8)) + if (strncmp((char*)head->g1m_mcshead_name, + (char*)file->g1m_mcsfile_head.g1m_mcshead_name, 8)) continue; break; case g1m_mcsinfo_cas: case g1m_mcsinfo_caspro: - if (strncmp((char*)head->_datatype, - (char*)file->head._datatype, 2)) + if (strncmp((char*)head->g1m_mcshead_datatype, + (char*)file->g1m_mcsfile_head.g1m_mcshead_datatype, 2)) continue; break; default: continue; @@ -77,30 +82,30 @@ int g1m_mcs_insert(g1m_handle_t *handle, g1m_mcsfile_t **tofile, /* slot was found! */ g1m_free_mcsfile(file); - pfile = &handle->files[i]; + pfile = &handle->g1m_handle_files[i]; goto found; } /* if no empty space was found, take one at the end (allocate if needed) */ if (!pfile) { - if (handle->count >= handle->_size) { + if (handle->g1m_handle_count >= handle->g1m_handle__size) { /* allocate new index */ - int newsize = handle->count + MCS_CHUNK_SIZE; + int newsize = handle->g1m_handle_count + MCS_CHUNK_SIZE; g1m_mcsfile_t **newindex = malloc(newsize * sizeof(g1m_mcsfile_t*)); if (!newindex) return (g1m_error_alloc); /* copy the data from the old index */ - memcpy(newindex, handle->files, - handle->_size * sizeof(g1m_mcsfile_t*)); - memset(&newindex[handle->_size], 0, - (newsize - handle->_size) * sizeof(g1m_mcsfile_t*)); + memcpy(newindex, handle->g1m_handle_files, + handle->g1m_handle__size * sizeof(g1m_mcsfile_t*)); + memset(&newindex[handle->g1m_handle__size], 0, + (newsize - handle->g1m_handle__size) * sizeof(g1m_mcsfile_t*)); /* free old, assign new */ - free(handle->files); - handle->files = newindex; - handle->_size = newsize; + free(handle->g1m_handle_files); + handle->g1m_handle_files = newindex; + handle->g1m_handle__size = newsize; } - pfile = &handle->files[handle->count++]; + pfile = &handle->g1m_handle_files[handle->g1m_handle_count++]; } found:; @@ -112,7 +117,6 @@ found:; *tofile = *pfile; return (0); } - /* ************************************************************************** */ /* Reorganize an MCS handle for encoding */ /* ************************************************************************** */ @@ -130,18 +134,21 @@ int g1m_mcs_sort(g1m_handle_t *handle) int i; /* make checks */ - if (handle->type != g1m_type_mcs) return (g1m_error_op); - if (handle->platform != g1m_platform_fx) return (g1m_error_op); + if (handle->g1m_handle_type != g1m_type_mcs) + return (g1m_error_op); + if (handle->g1m_handle_platform != g1m_platform_fx) + return (g1m_error_op); /* correct each head */ - for (i = 0; i < handle->count; i++) { - int err = g1m_correct_mcsfile_head(&handle->files[i]->head); + for (i = 0; i < handle->g1m_handle_count; i++) { + int err = g1m_correct_mcsfile_head( + &handle->g1m_handle_files[i]->g1m_mcsfile_head); if (err) return (err); } /* sort */ - qsort(handle->files, handle->count, sizeof(g1m_mcsfile_t*), - (g1m_compare_mcsfiles_t)g1m_compare_mcsfiles); + qsort(handle->g1m_handle_files, handle->g1m_handle_count, + sizeof(g1m_mcsfile_t*), (g1m_compare_mcsfiles_t)g1m_compare_mcsfiles); /* TODO: check for duplicates */ return (0); diff --git a/src/manage/mcsfile.c b/src/manage/mcsfile.c index 7d49617..f0d5aa4 100644 --- a/src/manage/mcsfile.c +++ b/src/manage/mcsfile.c @@ -37,67 +37,80 @@ int g1m_make_mcsfile(g1m_mcsfile_t **handle, const g1m_mcshead_t *rawhead) /* allocate the handle */ *handle = malloc(sizeof(g1m_mcsfile_t)); if (!handle) return (g1m_error_alloc); + + /* initialize the handle, copy the head */ g1m_mcsfile_t *h = *handle; memset(h, 0, sizeof(g1m_mcsfile_t)); + memcpy(&h->g1m_mcsfile_head, rawhead, sizeof(g1m_mcshead_t)); + g1m_mcshead_t *head = &h->g1m_mcsfile_head; - /* copy the head */ - memcpy(&h->head, rawhead, sizeof(g1m_mcshead_t)); - g1m_mcshead_t *head = &h->head; - - switch (head->type) { + switch (head->g1m_mcshead_type) { /* allocate the cells */ case g1m_mcstype_list: case g1m_mcstype_mat: case g1m_mcstype_vct: case g1m_mcstype_ssheet: - log_info("Preparing %d*%d matrix", head->width, head->height); - unsigned int wd = head->width, ht = head->height; + log_info("Preparing %d*%d matrix", head->g1m_mcshead_width, + head->g1m_mcshead_height); + unsigned int wd = head->g1m_mcshead_width; + unsigned int ht = head->g1m_mcshead_height; if (wd && ht) { - h->cells = malloc(sizeof(g1m_mcscell_t*) * ht); - if (!h->cells) goto fail; - h->cells[0] = malloc(sizeof(g1m_mcscell_t) * wd * ht); - if (!h->cells[0]) { free(h->cells); goto fail; } + h->g1m_mcsfile_cells = malloc(sizeof(g1m_mcscell_t*) * ht); + if (!h->g1m_mcsfile_cells) goto fail; + h->g1m_mcsfile_cells[0] = malloc(sizeof(g1m_mcscell_t) * wd * ht); + if (!h->g1m_mcsfile_cells[0]) { + free(h->g1m_mcsfile_cells); goto fail; + } for (y = 1; y < ht; y++) - h->cells[y] = &h->cells[0][h->head.width * y]; + h->g1m_mcsfile_cells[y] = &h->g1m_mcsfile_cells + [0][h->g1m_mcsfile_head.g1m_mcshead_width * y]; } break; /* allocate the variables */ case g1m_mcstype_alphamem: - if (head->count <= 1) h->vars = &h->var; + if (head->g1m_mcshead_count <= 1) + h->g1m_mcsfile_vars = &h->g1m_mcsfile_var; else { - h->vars = malloc(sizeof(g1m_mcscell_t) * head->count); - if (!h->vars) goto fail; - memset(h->vars, 0, sizeof(g1m_mcscell_t) * head->count); + h->g1m_mcsfile_vars = malloc(sizeof(g1m_mcscell_t) + * head->g1m_mcshead_count); + if (!h->g1m_mcsfile_vars) goto fail; + memset(h->g1m_mcsfile_vars, 0, sizeof(g1m_mcscell_t) + * head->g1m_mcshead_count); } break; /* allocate the set of pixels */ case g1m_mcstype_pict: case g1m_mcstype_capt: /* set count */ - head->count = (head->type == g1m_mcstype_pict) ? 2 : 1; + head->g1m_mcshead_count = (head->g1m_mcshead_type == g1m_mcstype_pict) + ? 2 : 1; /* allocate directory */ - if (head->count <= 1) h->pics = &h->pic; + if (head->g1m_mcshead_count <= 1) + h->g1m_mcsfile_pics = &h->g1m_mcsfile_pic; else { - h->pics = malloc(sizeof(uint32_t**) * head->count); - if (!h->pics) goto fail; + h->g1m_mcsfile_pics = malloc(sizeof(uint32_t**) + * head->g1m_mcshead_count); + if (!h->g1m_mcsfile_pics) goto fail; } /* allocate */ - for (i = 0; i < head->count; i++) { - h->pics[i] = alloc_pixels(head->width, head->height); - if (!h->pics[i]) { + for (i = 0; i < head->g1m_mcshead_count; i++) { + h->g1m_mcsfile_pics[i] = alloc_pixels(head->g1m_mcshead_width, + head->g1m_mcshead_height); + if (!h->g1m_mcsfile_pics[i]) { for (j = 0; j < i; j++) - free(h->pics[j]); - if (h->pics != &h->pic) - free(h->pics); + free(h->g1m_mcsfile_pics[j]); + if (h->g1m_mcsfile_pics != &h->g1m_mcsfile_pic) + free(h->g1m_mcsfile_pics); goto fail; } } /* prepare */ - for (i = 0; i < head->count; i++) - prepare_pixels(h->pics[i], head->width, head->height) + for (i = 0; i < head->g1m_mcshead_count; i++) + prepare_pixels(h->g1m_mcsfile_pics[i], head->g1m_mcshead_width, + head->g1m_mcshead_height) break; /* allocate nothing */ @@ -108,8 +121,8 @@ int g1m_make_mcsfile(g1m_mcsfile_t **handle, const g1m_mcshead_t *rawhead) /* allocate raw content */ default: - h->content = malloc(head->size); - if (!h->content) goto fail; + h->g1m_mcsfile_content = malloc(head->g1m_mcshead_size); + if (!h->g1m_mcsfile_content) goto fail; break; } @@ -120,32 +133,6 @@ fail: return (g1m_error_alloc); } -/** - * g1m_prepare_mcsfile_heads: - * Prepare the heads from a general head. - * - * @arg head the main head. - * @arg heads the heads to prepare. - * @return the error (if any). - */ - -int g1m_prepare_mcsfile_heads(g1m_mcshead_t *head, g1m_mcshead_t *heads) -{ - int i; - - /* check if the head is a multiple head */ - if (~head->flags & g1m_mcsflag_multiple) return (g1m_error_op); - - /* copy the data in each head */ - for (i = 0; i < head->count; i++) { - heads[i] = *head; - heads[i].flags &= ~g1m_mcsflag_multiple; - } - - /* no error */ - return (0); -} - /** * g1m_free_mcsfile: * Free an MCS file handle content. @@ -160,28 +147,29 @@ void g1m_free_mcsfile(g1m_mcsfile_t *handle) /* check if exists */ if (!handle) return ; - switch (handle->head.type) { + switch (handle->g1m_mcsfile_head.g1m_mcshead_type) { /* free the cells */ case g1m_mcstype_mat: case g1m_mcstype_vct: case g1m_mcstype_list: case g1m_mcstype_ssheet: - if (handle->head.width && handle->head.height) { - free(handle->cells[0]); - free(handle->cells); + if (handle->g1m_mcsfile_head.g1m_mcshead_width + && handle->g1m_mcsfile_head.g1m_mcshead_height) { + free(handle->g1m_mcsfile_cells[0]); + free(handle->g1m_mcsfile_cells); } break; /* free the set of pixels */ case g1m_mcstype_pict: case g1m_mcstype_capt: - for (i = 0; i < handle->head.count; i++) - free(handle->pics[i]); - if (handle->pics != &handle->pic) - free(handle->pics); + for (i = 0; i < handle->g1m_mcsfile_head.g1m_mcshead_count; i++) + free(handle->g1m_mcsfile_pics[i]); + if (handle->g1m_mcsfile_pics != &handle->g1m_mcsfile_pic) + free(handle->g1m_mcsfile_pics); break; /* free the variables */ case g1m_mcstype_alphamem: - if (handle->vars != &handle->var) - free(handle->vars); + if (handle->g1m_mcsfile_vars != &handle->g1m_mcsfile_var) + free(handle->g1m_mcsfile_vars); break; /* free nothing */ @@ -192,7 +180,7 @@ void g1m_free_mcsfile(g1m_mcsfile_t *handle) /* free the raw content */ default: - free(handle->content); + free(handle->g1m_mcsfile_content); } /* free the content */ diff --git a/src/type/cas/app.c b/src/type/cas/app.c index d46d140..6b7ff28 100644 --- a/src/type/cas/app.c +++ b/src/type/cas/app.c @@ -124,10 +124,10 @@ int g1m_maketype_casapp(g1m_mcshead_t *head, /* copy raw information */ memset(head, 0, sizeof(g1m_mcshead_t)); - head->info = e->info; /* FIXME */ + head->g1m_mcshead_info = e->info; /* FIXME */ log_info("Head info is 0x%04X", e->info); - strncpy((char*)head->_appname, app, 3); - head->_appname[3] = 0; + strncpy((char*)head->g1m_mcshead_appname, app, 3); + head->g1m_mcshead_appname[3] = 0; /* fill in info and return */ return (0); @@ -135,6 +135,6 @@ int g1m_maketype_casapp(g1m_mcshead_t *head, notfound: log_error("Type with 0x%02X extension and '%.3s' app name was not " "implemented or recognized", ext, app); - head->type = 0; + head->g1m_mcshead_type = 0; return (1); } diff --git a/src/type/cas/datatype.c b/src/type/cas/datatype.c index e9d0e5d..a82c541 100644 --- a/src/type/cas/datatype.c +++ b/src/type/cas/datatype.c @@ -135,8 +135,8 @@ static int get_number(const char *s, int *num) int g1m_maketype_cas(g1m_mcshead_t *head, const char *datatype) { /* copy information */ - memcpy(head->_datatype, datatype, 2); - head->_datatype[2] = 0; + memcpy(head->g1m_mcshead_datatype, datatype, 2); + head->g1m_mcshead_datatype[2] = 0; /* look for correspondance */ struct type_corresp *c = cas_groups - 1; int id = 0; @@ -146,23 +146,24 @@ int g1m_maketype_cas(g1m_mcshead_t *head, const char *datatype) /* check if pattern is there */ if (strncmp(c->datatype, datatype, pl)) continue; - if ((c->flags & arg) && get_number(&head->name[pl], &id)) + if ((c->flags & arg) && get_number(&head->g1m_mcshead_name[pl], &id)) continue; break; } if (!c->type) goto notfound; /* fill in info and return */ - head->type = c->type; - head->id = id; - head->_picformat = c->picformat; - if (c->flags & mult) head->flags |= g1m_mcsflag_multiple; + head->g1m_mcshead_type = c->type; + head->g1m_mcshead_id = id; + head->g1m_mcshead_picformat = c->picformat; + if (c->flags & mult) + head->g1m_mcshead_flags |= g1m_mcsflag_multiple; return (0); notfound: log_info("Type with '%.2s' data string was not implemented or not " "recognized.", datatype); - head->type = 0; + head->g1m_mcshead_type = 0; return (1); } @@ -179,7 +180,7 @@ int g1m_correct_casfile_head(g1m_mcshead_t *head) /* look for correspondance */ struct type_corresp *c = cas_groups - 1; while ((++c)->type) { - if (head->type == c->type) /* FIXME: picture format? */ + if (head->g1m_mcshead_type == c->type) /* FIXME: picture format? */ goto found; break; } @@ -189,7 +190,7 @@ int g1m_correct_casfile_head(g1m_mcshead_t *head) /* found :) */ found: - memcpy(head->_datatype, c->datatype, 2); + memcpy(head->g1m_mcshead_datatype, c->datatype, 2); /* TODO: things with IDs, etc */ /* TODO: add app? */ return (0); diff --git a/src/type/mcs.c b/src/type/mcs.c index 483220f..2ade5fb 100644 --- a/src/type/mcs.c +++ b/src/type/mcs.c @@ -312,17 +312,17 @@ int g1m_maketype_mcs(g1m_mcshead_t *head, /* copy raw information */ memset(head, 0, sizeof(g1m_mcshead_t)); - head->info = g1m_mcsinfo_mcs; - memcpy(head->name, fname, 8); - head->name[8] = 0; - memcpy(head->_group, gname, 16); - head->_group[16] = 0; - head->_rawtype = rawtype; + head->g1m_mcshead_info = g1m_mcsinfo_mcs; + memcpy(head->g1m_mcshead_name, fname, 8); + head->g1m_mcshead_name[8] = 0; + memcpy(head->g1m_mcshead_group, gname, 16); + head->g1m_mcshead_group[16] = 0; + head->g1m_mcshead_rawtype = rawtype; if (dname) { - memcpy(head->_dirname, dname, 8); - head->_dirname[8] = 0; + memcpy(head->g1m_mcshead_dirname, dname, 8); + head->g1m_mcshead_dirname[8] = 0; } else - memset(head->_dirname, 0, 9); + memset(head->g1m_mcshead_dirname, 0, 9); /* look for group correspondance */ int gid = 0; @@ -366,15 +366,15 @@ int g1m_maketype_mcs(g1m_mcshead_t *head, goto notfound; /* fill in info and return */ - head->type = t->type; - head->id = fid; + head->g1m_mcshead_type = t->type; + head->g1m_mcshead_id = fid; return (0); notfound: log_info("Type with '%s' group, '%s' name and 0x%02x type " "wasn't recognized.", gname, fname, rawtype); - head->type = 0; - head->id = 0; + head->g1m_mcshead_type = 0; + head->g1m_mcshead_id = 0; return (1); } @@ -390,8 +390,8 @@ int g1m_correct_mcsfile_head(g1m_mcshead_t *head) { /* check if there is a type */ if (!head) return (0); - if (!head->type - && (!head->_group[0] || !head->name[0] || !head->_dirname[0])) + if (!head->g1m_mcshead_type && (!head->g1m_mcshead_group[0] + || !head->g1m_mcshead_name[0] || !head->g1m_mcshead_dirname[0])) return (g1m_error_op); /* find the group/type */ @@ -399,10 +399,10 @@ int g1m_correct_mcsfile_head(g1m_mcshead_t *head) struct type_corresp *t; for (g = mcs_groups; g->types; g++) for (t = g->types; t->dirname; t++) { /* check if the libg1m type corresponds */ - if (t->type != head->type) continue; + if (t->type != head->g1m_mcshead_type) continue; /* check if id is weighted by major */ - if (g1m_get_id_major(head->id)) { + if (g1m_get_id_major(head->g1m_mcshead_id)) { if (~t->flags & weight_by_gid) continue; } else @@ -417,11 +417,11 @@ int g1m_correct_mcsfile_head(g1m_mcshead_t *head) found:; /* put the group name */ - char *gr = (char*)head->_group; + char *gr = (char*)head->g1m_mcshead_group; if (g->flags & arg) { - int grid = g1m_get_id_major(head->id); + int grid = g1m_get_id_major(head->g1m_mcshead_id); if ((t->flags & arg) && ~t->flags & weight_by_gid) - grid = g1m_get_id_minor(head->id); + grid = g1m_get_id_minor(head->g1m_mcshead_id); if (grid == g1m_ans) sprintf(gr, "%sAns", g->name); @@ -437,12 +437,12 @@ found:; strcpy(gr, g->name); /* put the directory name */ - strcpy((char*)head->_dirname, t->dirname); + strcpy((char*)head->g1m_mcshead_dirname, t->dirname); /* put the filename */ - char *nm = (char*)head->name; + char *nm = (char*)head->g1m_mcshead_name; if (t->flags & arg) { - int namid = g1m_get_id_minor(head->id); + int namid = g1m_get_id_minor(head->g1m_mcshead_id); if (namid == g1m_ans) sprintf(nm, "%sAns", t->name); @@ -477,14 +477,14 @@ static int find_offset_in_group(struct group_corresp *g, const g1m_mcsfile_t *file) { /* group check */ - if (strcmp((char*)file->head._group, g->name)) + if (strcmp((char*)file->g1m_mcsfile_head.g1m_mcshead_group, g->name)) return (-1); /* file check */ struct type_corresp *f; int i; for (f = g->types, i = 0; f->info; f++, i++) { - if (strcmp((char*)file->head._group, f->name) - || file->head._rawtype != f->rawtype) + if (strcmp((char*)file->g1m_mcsfile_head.g1m_mcshead_group, f->name) + || file->g1m_mcsfile_head.g1m_mcshead_rawtype != f->rawtype) continue; return (i); diff --git a/src/utils/buffer.c b/src/utils/buffer.c index 7deb0df..47871fc 100644 --- a/src/utils/buffer.c +++ b/src/utils/buffer.c @@ -104,10 +104,10 @@ int g1m_membuffer_read(void *vcookie, unsigned char *dest, size_t size) { g1m_cursor_t *cursor = (void*)vcookie; - if (size > cursor->left) + if (size > cursor->g1m_cursor_left) return (g1m_error_eof); - memcpy(dest, cursor->p, size); - cursor->p += size; + memcpy(dest, cursor->g1m_cursor_p, size); + cursor->g1m_cursor_p += size; return (0); } @@ -128,8 +128,8 @@ int g1m_limbuffer_read(void *vcookie, unsigned char *buf, size_t size) { /* check if the size is okay */ g1m_limited_t *lim = (void*)vcookie; - if (size > lim->left) return (g1m_error_eof); - g1m_buffer_t *buffer = lim->buffer; + if (size > lim->g1m_limited_left) return (g1m_error_eof); + g1m_buffer_t *buffer = lim->g1m_limited_buffer; /* read */ READ(buf, size) @@ -147,9 +147,9 @@ int g1m_limbuffer_read(void *vcookie, unsigned char *buf, size_t size) int g1m_empty_limbuffer(g1m_buffer_t *limbuffer) { - g1m_limited_t *lim = (void*)limbuffer->cookie; - g1m_buffer_t *buffer = lim->buffer; - SKIP(lim->left) + g1m_limited_t *lim = (void*)limbuffer->g1m_buffer_cookie; + g1m_buffer_t *buffer = lim->g1m_limited_buffer; + SKIP(lim->g1m_limited_left) return (0); } /* ************************************************************************** */ diff --git a/src/utils/file.c b/src/utils/file.c index 1f578d6..fbb1164 100644 --- a/src/utils/file.c +++ b/src/utils/file.c @@ -69,8 +69,8 @@ int g1m_fopen(g1m_handle_t **handle, const char *path, FILE *stream, /* make the buffer */ g1m_buffer_t buffer = { - .cookie = stream, - .read = g1m_filebuffer_read + .g1m_buffer_cookie = stream, + .g1m_buffer_read = g1m_filebuffer_read }; /* decode opened file */ @@ -118,8 +118,8 @@ int g1m_fwrite(g1m_handle_t *handle, FILE *stream) /* make the buffer */ g1m_buffer_t buffer = { - .cookie = stream, - .write = g1m_filebuffer_write + .g1m_buffer_cookie = stream, + .g1m_buffer_write = g1m_filebuffer_write }; /* encode to file */ diff --git a/src/utils/skip.c b/src/utils/skip.c index d385dc2..473293c 100644 --- a/src/utils/skip.c +++ b/src/utils/skip.c @@ -39,8 +39,9 @@ int g1m_skip(g1m_buffer_t *buffer, size_t size, uint32_t *checksum) /* read that much */ size_t curlen = min(size, 1024); size -= curlen; - buffer->_offset += curlen; - if ((err = (*buffer->read)(buffer->cookie, buf, curlen))) { + buffer->g1m_buffer_offset += curlen; + if ((err = (*buffer->g1m_buffer_read)(buffer->g1m_buffer_cookie, buf, + curlen))) { log_error("Skipping has failed after %" PRIuSIZE " bytes", orig - size); return (err); diff --git a/src/utils/version.c b/src/utils/version.c index e47f43e..5cd6929 100644 --- a/src/utils/version.c +++ b/src/utils/version.c @@ -56,14 +56,22 @@ int g1m_decode_version(const char *raw, g1m_version_t *version) { /* helper values */ const int two = '0' + '0' * 10; - const int four = two + '0' * 100 + '0' * 1000; - /* get the version data */ + /* get the basic version data */ *version = (g1m_version_t){ - .major = raw[0] * 10 + raw[1] - two, - .minor = raw[3] * 10 + raw[4] - two, - .revision = raw[6] * 1000 + raw[7] * 100 + raw[8] * 10 + raw[9] - four - }; + .g1m_version_major = raw[0] * 10 + raw[1] - two, + .g1m_version_minor = raw[3] * 10 + raw[4] - two}; + + /* get normal values */ + version->g1m_version_zone = raw[6] - '0'; + version->g1m_version_math = raw[7] - '0'; + + /* get build flags */ + version->g1m_version_flags = 0; + if (raw[8] != '0') + version->g1m_version_flags |= g1m_versionflag_indev; + if (raw[9] != '0') + version->g1m_version_flags |= g1m_versionflag_spe; /* no error */ return (0); @@ -80,8 +88,16 @@ int g1m_decode_version(const char *raw, g1m_version_t *version) int g1m_encode_version(const g1m_version_t *version, char *raw) { - char buf[11]; sprintf(buf, "%02u.%02u.%04u", - version->major, version->minor, version->revision); + /* make buffer */ + char buf[11]; sprintf(buf, "%02u.%02u.%c%c%c%c", + version->g1m_version_major, + version->g1m_version_minor, + version->g1m_version_zone + '0', + version->g1m_version_math + '0', + version->g1m_version_flags & g1m_versionflag_indev ? '1' : '0', + version->g1m_version_flags & g1m_versionflag_spe ? '1' : '0'); + + /* copy final */ memcpy(raw, buf, 10); return (0); }