diff --git a/lib/zip.h b/lib/zip.h
index ae9173f..04a391d 100644
--- a/lib/zip.h
+++ b/lib/zip.h
@@ -284,102 +284,101 @@
 
 typedef zip_uint32_t zip_flags_t;    
 
-typedef zip_int64_t (*zip_source_callback)(void *, void *, zip_uint64_t,
-					   enum zip_source_cmd);
+typedef zip_int64_t (*zip_source_callback)(void *, void *, zip_uint64_t, zip_source_cmd_t);
 
 
 #ifndef ZIP_DISABLE_DEPRECATED
-ZIP_EXTERN zip_int64_t zip_add(struct zip *, const char *, zip_source_t *); /* use zip_file_add */
-ZIP_EXTERN zip_int64_t zip_add_dir(struct zip *, const char *); /* use zip_dir_add */
-ZIP_EXTERN const char *zip_get_file_comment(struct zip *, zip_uint64_t, int *, int); /* use zip_file_get_comment */
-ZIP_EXTERN int zip_get_num_files(struct zip *);  /* use zip_get_num_entries instead */
-ZIP_EXTERN int zip_rename(struct zip *, zip_uint64_t, const char *); /* use zip_file_rename */
-ZIP_EXTERN int zip_replace(struct zip *, zip_uint64_t, zip_source_t *); /* use zip_file_replace */
-ZIP_EXTERN int zip_set_file_comment(struct zip *, zip_uint64_t, const char *, int); /* use zip_file_set_comment */
+ZIP_EXTERN zip_int64_t zip_add(zip_t *, const char *, zip_source_t *); /* use zip_file_add */
+ZIP_EXTERN zip_int64_t zip_add_dir(zip_t *, const char *); /* use zip_dir_add */
+ZIP_EXTERN const char *zip_get_file_comment(zip_t *, zip_uint64_t, int *, int); /* use zip_file_get_comment */
+ZIP_EXTERN int zip_get_num_files(zip_t *);  /* use zip_get_num_entries instead */
+ZIP_EXTERN int zip_rename(zip_t *, zip_uint64_t, const char *); /* use zip_file_rename */
+ZIP_EXTERN int zip_replace(zip_t *, zip_uint64_t, zip_source_t *); /* use zip_file_replace */
+ZIP_EXTERN int zip_set_file_comment(zip_t *, zip_uint64_t, const char *, int); /* use zip_file_set_comment */
 ZIP_EXTERN int zip_error_get_sys_type(int); /* use zip_error_system_type */
-ZIP_EXTERN void zip_error_get(struct zip *, int *, int *); /* use zip_get_error, zip_error_code_zip / zip_error_code_system */
-ZIP_EXTERN void zip_file_error_get(struct zip_file *, int *, int *); /* use zip_file_get_error, zip_error_code_zip / zip_error_code_system */
+ZIP_EXTERN void zip_error_get(zip_t *, int *, int *); /* use zip_get_error, zip_error_code_zip / zip_error_code_system */
+ZIP_EXTERN void zip_file_error_get(zip_file_t *, int *, int *); /* use zip_file_get_error, zip_error_code_zip / zip_error_code_system */
 #endif
 
-ZIP_EXTERN int zip_archive_set_tempdir(struct zip *, const char *);
-ZIP_EXTERN int zip_close(struct zip *);
-ZIP_EXTERN int zip_delete(struct zip *, zip_uint64_t);
-ZIP_EXTERN zip_int64_t zip_dir_add(struct zip *, const char *, zip_flags_t);
-ZIP_EXTERN void zip_discard(struct zip *);
+ZIP_EXTERN int zip_archive_set_tempdir(zip_t *, const char *);
+ZIP_EXTERN int zip_close(zip_t *);
+ZIP_EXTERN int zip_delete(zip_t *, zip_uint64_t);
+ZIP_EXTERN zip_int64_t zip_dir_add(zip_t *, const char *, zip_flags_t);
+ZIP_EXTERN void zip_discard(zip_t *);
 
-ZIP_EXTERN struct zip_error *zip_get_error(struct zip *);
-ZIP_EXTERN void zip_error_clear(struct zip *);
-ZIP_EXTERN int zip_error_code_zip(const struct zip_error *);
-ZIP_EXTERN int zip_error_code_system(const struct zip_error *);
-ZIP_EXTERN void zip_error_fini(struct zip_error *);
-ZIP_EXTERN void zip_error_init(struct zip_error *);
+ZIP_EXTERN zip_error_t *zip_get_error(zip_t *);
+ZIP_EXTERN void zip_error_clear(zip_t *);
+ZIP_EXTERN int zip_error_code_zip(const zip_error_t *);
+ZIP_EXTERN int zip_error_code_system(const zip_error_t *);
+ZIP_EXTERN void zip_error_fini(zip_error_t *);
+ZIP_EXTERN void zip_error_init(zip_error_t *);
 ZIP_EXTERN void zip_error_set(zip_error_t *, int, int);
-ZIP_EXTERN const char *zip_error_strerror(struct zip_error *);
-ZIP_EXTERN int zip_error_system_type(const struct zip_error *);
+ZIP_EXTERN const char *zip_error_strerror(zip_error_t *);
+ZIP_EXTERN int zip_error_system_type(const zip_error_t *);
 ZIP_EXTERN zip_int64_t zip_error_to_data(const zip_error_t *, void *, zip_uint64_t);
 ZIP_EXTERN int zip_error_to_str(char *, zip_uint64_t, int, int);
 
-ZIP_EXTERN int zip_fclose(struct zip_file *);
-ZIP_EXTERN struct zip *zip_fdopen(int, int, int *);
-ZIP_EXTERN zip_int64_t zip_file_add(struct zip *, const char *, zip_source_t *, zip_flags_t);
-ZIP_EXTERN void zip_file_error_clear(struct zip_file *);
-ZIP_EXTERN int zip_file_extra_field_delete(struct zip *, zip_uint64_t, zip_uint16_t, zip_flags_t);
-ZIP_EXTERN int zip_file_extra_field_delete_by_id(struct zip *, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t);
-ZIP_EXTERN int zip_file_extra_field_set(struct zip *, zip_uint64_t, zip_uint16_t, zip_uint16_t, const zip_uint8_t *, zip_uint16_t, zip_flags_t);
-ZIP_EXTERN zip_int16_t zip_file_extra_fields_count(struct zip *, zip_uint64_t, zip_flags_t);
-ZIP_EXTERN zip_int16_t zip_file_extra_fields_count_by_id(struct zip *, zip_uint64_t, zip_uint16_t, zip_flags_t);
-ZIP_EXTERN const zip_uint8_t *zip_file_extra_field_get(struct zip *, zip_uint64_t, zip_uint16_t, zip_uint16_t *, zip_uint16_t *, zip_flags_t);
-ZIP_EXTERN const zip_uint8_t *zip_file_extra_field_get_by_id(struct zip *, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_uint16_t *, zip_flags_t);
-ZIP_EXTERN const char *zip_file_get_comment(struct zip *, zip_uint64_t, zip_uint32_t *, zip_flags_t);
-ZIP_EXTERN struct zip_error *zip_file_get_error(struct zip_file *);
-ZIP_EXTERN int zip_file_get_external_attributes(struct zip *, zip_uint64_t, zip_flags_t, zip_uint8_t *, zip_uint32_t *);
-ZIP_EXTERN int zip_file_rename(struct zip *, zip_uint64_t, const char *, zip_flags_t);
-ZIP_EXTERN int zip_file_replace(struct zip *, zip_uint64_t, zip_source_t *, zip_flags_t);
-ZIP_EXTERN int zip_file_set_comment(struct zip *, zip_uint64_t, const char *, zip_uint16_t, zip_flags_t);
-ZIP_EXTERN int zip_file_set_external_attributes(struct zip *, zip_uint64_t, zip_flags_t, zip_uint8_t, zip_uint32_t);
-ZIP_EXTERN int zip_file_set_mtime(struct zip *, zip_uint64_t, time_t, zip_flags_t);
-ZIP_EXTERN const char *zip_file_strerror(struct zip_file *);
-ZIP_EXTERN struct zip_file *zip_fopen(struct zip *, const char *, zip_flags_t);
-ZIP_EXTERN struct zip_file *zip_fopen_encrypted(struct zip *, const char *, zip_flags_t, const char *);
-ZIP_EXTERN struct zip_file *zip_fopen_index(struct zip *, zip_uint64_t, zip_flags_t);
-ZIP_EXTERN struct zip_file *zip_fopen_index_encrypted(struct zip *, zip_uint64_t, zip_flags_t, const char *);
-ZIP_EXTERN zip_int64_t zip_fread(struct zip_file *, void *, zip_uint64_t);
-ZIP_EXTERN const char *zip_get_archive_comment(struct zip *, int *, zip_flags_t);
-ZIP_EXTERN int zip_get_archive_flag(struct zip *, zip_flags_t, zip_flags_t);
-ZIP_EXTERN const char *zip_get_name(struct zip *, zip_uint64_t, zip_flags_t);
-ZIP_EXTERN zip_int64_t zip_get_num_entries(struct zip *, zip_flags_t);
-ZIP_EXTERN zip_int64_t zip_name_locate(struct zip *, const char *, zip_flags_t);
-ZIP_EXTERN struct zip *zip_open(const char *, int, int *);
-ZIP_EXTERN struct zip *zip_open_from_source(zip_source_t *, int, struct zip_error *);
-ZIP_EXTERN int zip_set_archive_comment(struct zip *, const char *, zip_uint16_t);
-ZIP_EXTERN int zip_set_archive_flag(struct zip *, zip_flags_t, int);
-ZIP_EXTERN int zip_set_default_password(struct zip *, const char *);
-ZIP_EXTERN int zip_set_file_compression(struct zip *, zip_uint64_t, zip_int32_t, zip_uint32_t);
-ZIP_EXTERN zip_source_t *zip_source_buffer(struct zip *, const void *, zip_uint64_t, int);
+ZIP_EXTERN int zip_fclose(zip_file_t *);
+ZIP_EXTERN zip_t *zip_fdopen(int, int, int *);
+ZIP_EXTERN zip_int64_t zip_file_add(zip_t *, const char *, zip_source_t *, zip_flags_t);
+ZIP_EXTERN void zip_file_error_clear(zip_file_t *);
+ZIP_EXTERN int zip_file_extra_field_delete(zip_t *, zip_uint64_t, zip_uint16_t, zip_flags_t);
+ZIP_EXTERN int zip_file_extra_field_delete_by_id(zip_t *, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t);
+ZIP_EXTERN int zip_file_extra_field_set(zip_t *, zip_uint64_t, zip_uint16_t, zip_uint16_t, const zip_uint8_t *, zip_uint16_t, zip_flags_t);
+ZIP_EXTERN zip_int16_t zip_file_extra_fields_count(zip_t *, zip_uint64_t, zip_flags_t);
+ZIP_EXTERN zip_int16_t zip_file_extra_fields_count_by_id(zip_t *, zip_uint64_t, zip_uint16_t, zip_flags_t);
+ZIP_EXTERN const zip_uint8_t *zip_file_extra_field_get(zip_t *, zip_uint64_t, zip_uint16_t, zip_uint16_t *, zip_uint16_t *, zip_flags_t);
+ZIP_EXTERN const zip_uint8_t *zip_file_extra_field_get_by_id(zip_t *, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_uint16_t *, zip_flags_t);
+ZIP_EXTERN const char *zip_file_get_comment(zip_t *, zip_uint64_t, zip_uint32_t *, zip_flags_t);
+ZIP_EXTERN zip_error_t *zip_file_get_error(zip_file_t *);
+ZIP_EXTERN int zip_file_get_external_attributes(zip_t *, zip_uint64_t, zip_flags_t, zip_uint8_t *, zip_uint32_t *);
+ZIP_EXTERN int zip_file_rename(zip_t *, zip_uint64_t, const char *, zip_flags_t);
+ZIP_EXTERN int zip_file_replace(zip_t *, zip_uint64_t, zip_source_t *, zip_flags_t);
+ZIP_EXTERN int zip_file_set_comment(zip_t *, zip_uint64_t, const char *, zip_uint16_t, zip_flags_t);
+ZIP_EXTERN int zip_file_set_external_attributes(zip_t *, zip_uint64_t, zip_flags_t, zip_uint8_t, zip_uint32_t);
+ZIP_EXTERN int zip_file_set_mtime(zip_t *, zip_uint64_t, time_t, zip_flags_t);
+ZIP_EXTERN const char *zip_file_strerror(zip_file_t *);
+ZIP_EXTERN zip_file_t *zip_fopen(zip_t *, const char *, zip_flags_t);
+ZIP_EXTERN zip_file_t *zip_fopen_encrypted(zip_t *, const char *, zip_flags_t, const char *);
+ZIP_EXTERN zip_file_t *zip_fopen_index(zip_t *, zip_uint64_t, zip_flags_t);
+ZIP_EXTERN zip_file_t *zip_fopen_index_encrypted(zip_t *, zip_uint64_t, zip_flags_t, const char *);
+ZIP_EXTERN zip_int64_t zip_fread(zip_file_t *, void *, zip_uint64_t);
+ZIP_EXTERN const char *zip_get_archive_comment(zip_t *, int *, zip_flags_t);
+ZIP_EXTERN int zip_get_archive_flag(zip_t *, zip_flags_t, zip_flags_t);
+ZIP_EXTERN const char *zip_get_name(zip_t *, zip_uint64_t, zip_flags_t);
+ZIP_EXTERN zip_int64_t zip_get_num_entries(zip_t *, zip_flags_t);
+ZIP_EXTERN zip_int64_t zip_name_locate(zip_t *, const char *, zip_flags_t);
+ZIP_EXTERN zip_t *zip_open(const char *, int, int *);
+ZIP_EXTERN zip_t *zip_open_from_source(zip_source_t *, int, zip_error_t *);
+ZIP_EXTERN int zip_set_archive_comment(zip_t *, const char *, zip_uint16_t);
+ZIP_EXTERN int zip_set_archive_flag(zip_t *, zip_flags_t, int);
+ZIP_EXTERN int zip_set_default_password(zip_t *, const char *);
+ZIP_EXTERN int zip_set_file_compression(zip_t *, zip_uint64_t, zip_int32_t, zip_uint32_t);
+ZIP_EXTERN zip_source_t *zip_source_buffer(zip_t *, const void *, zip_uint64_t, int);
 ZIP_EXTERN zip_source_t *zip_source_buffer_create(const void *, zip_uint64_t, int, zip_error_t *);
 ZIP_EXTERN int zip_source_close(zip_source_t *);
 ZIP_EXTERN zip_error_t *zip_source_error(zip_source_t *src);
-ZIP_EXTERN zip_source_t *zip_source_file(struct zip *, const char *, zip_uint64_t, zip_int64_t);
-ZIP_EXTERN zip_source_t *zip_source_file_create(const char *, zip_uint64_t, zip_int64_t, struct zip_error *);
-ZIP_EXTERN zip_source_t *zip_source_filep(struct zip *, FILE *, zip_uint64_t, zip_int64_t);
-ZIP_EXTERN zip_source_t *zip_source_filep_create(FILE *, zip_uint64_t, zip_int64_t, struct zip_error *);
+ZIP_EXTERN zip_source_t *zip_source_file(zip_t *, const char *, zip_uint64_t, zip_int64_t);
+ZIP_EXTERN zip_source_t *zip_source_file_create(const char *, zip_uint64_t, zip_int64_t, zip_error_t *);
+ZIP_EXTERN zip_source_t *zip_source_filep(zip_t *, FILE *, zip_uint64_t, zip_int64_t);
+ZIP_EXTERN zip_source_t *zip_source_filep_create(FILE *, zip_uint64_t, zip_int64_t, zip_error_t *);
 ZIP_EXTERN void zip_source_free(zip_source_t *);
-ZIP_EXTERN zip_source_t *zip_source_function(struct zip *, zip_source_callback, void *);
+ZIP_EXTERN zip_source_t *zip_source_function(zip_t *, zip_source_callback, void *);
 ZIP_EXTERN zip_source_t *zip_source_function_create(zip_source_callback, void *, zip_error_t *);
 ZIP_EXTERN int zip_source_is_deleted(zip_source_t *);
 ZIP_EXTERN void zip_source_keep(zip_source_t *);
-ZIP_EXTERN zip_int64_t zip_source_make_command_bitmap(enum zip_source_cmd, ...);
+ZIP_EXTERN zip_int64_t zip_source_make_command_bitmap(zip_source_cmd_t, ...);
 ZIP_EXTERN int zip_source_open(zip_source_t *);
 ZIP_EXTERN zip_int64_t zip_source_read(zip_source_t *, void *, zip_uint64_t);
-ZIP_EXTERN int zip_source_stat(zip_source_t *, struct zip_stat *);
-ZIP_EXTERN zip_source_t *zip_source_zip(struct zip *, struct zip *, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t);
-ZIP_EXTERN int zip_stat(struct zip *, const char *, zip_flags_t, struct zip_stat *);
-ZIP_EXTERN int zip_stat_index(struct zip *, zip_uint64_t, zip_flags_t, struct zip_stat *);
-ZIP_EXTERN void zip_stat_init(struct zip_stat *);
-ZIP_EXTERN const char *zip_strerror(struct zip *);
-ZIP_EXTERN int zip_unchange(struct zip *, zip_uint64_t);
-ZIP_EXTERN int zip_unchange_all(struct zip *);
-ZIP_EXTERN int zip_unchange_archive(struct zip *);
+ZIP_EXTERN int zip_source_stat(zip_source_t *, zip_stat_t *);
+ZIP_EXTERN zip_source_t *zip_source_zip(zip_t *, zip_t *, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t);
+ZIP_EXTERN int zip_stat(zip_t *, const char *, zip_flags_t, zip_stat_t *);
+ZIP_EXTERN int zip_stat_index(zip_t *, zip_uint64_t, zip_flags_t, zip_stat_t *);
+ZIP_EXTERN void zip_stat_init(zip_stat_t *);
+ZIP_EXTERN const char *zip_strerror(zip_t *);
+ZIP_EXTERN int zip_unchange(zip_t *, zip_uint64_t);
+ZIP_EXTERN int zip_unchange_all(zip_t *);
+ZIP_EXTERN int zip_unchange_archive(zip_t *);
 
 #ifdef __cplusplus
 }
diff --git a/lib/zip_add.c b/lib/zip_add.c
index 7574762..d1be133 100644
--- a/lib/zip_add.c
+++ b/lib/zip_add.c
@@ -44,7 +44,7 @@
 */
 
 ZIP_EXTERN zip_int64_t
-zip_add(struct zip *za, const char *name, struct zip_source *source)
+zip_add(zip_t *za, const char *name, zip_source_t *source)
 {
     return zip_file_add(za, name, source, 0);
 }
diff --git a/lib/zip_add_dir.c b/lib/zip_add_dir.c
index 65abceb..14bdeda 100644
--- a/lib/zip_add_dir.c
+++ b/lib/zip_add_dir.c
@@ -39,7 +39,7 @@
 /* NOTE: Signed due to -1 on error.  See zip_add.c for more details. */
 
 ZIP_EXTERN zip_int64_t
-zip_add_dir(struct zip *za, const char *name)
+zip_add_dir(zip_t *za, const char *name)
 {
     return zip_dir_add(za, name, 0);
 }
diff --git a/lib/zip_add_entry.c b/lib/zip_add_entry.c
index 4ead9be..24dbdaf 100644
--- a/lib/zip_add_entry.c
+++ b/lib/zip_add_entry.c
@@ -40,12 +40,12 @@
 /* NOTE: Signed due to -1 on error.  See zip_add.c for more details. */
 
 zip_int64_t
-_zip_add_entry(struct zip *za)
+_zip_add_entry(zip_t *za)
 {
     zip_uint64_t idx;
 
     if (za->nentry+1 >= za->nentry_alloc) {
-	struct zip_entry *rentries;
+	zip_entry_t *rentries;
 	zip_uint64_t nalloc = za->nentry_alloc + 16;
 	zip_uint64_t realloc_size = sizeof(struct zip_entry) * (size_t)nalloc;
 
@@ -53,7 +53,7 @@
 	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
 	    return -1;
 	}
-	rentries = (struct zip_entry *)realloc(za->entry, sizeof(struct zip_entry) * (size_t)nalloc);
+	rentries = (zip_entry_t *)realloc(za->entry, sizeof(struct zip_entry) * (size_t)nalloc);
 	if (!rentries) {
 	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
 	    return -1;
diff --git a/lib/zip_close.c b/lib/zip_close.c
index 9502273..bd1a502 100644
--- a/lib/zip_close.c
+++ b/lib/zip_close.c
@@ -55,20 +55,20 @@
 /* max deflate size increase: size + ceil(size/16k)*5+6 */
 #define MAX_DEFLATE_SIZE_32	4293656963u
 
-static int add_data(struct zip *, struct zip_source *, struct zip_dirent *);
-static int copy_data(struct zip *, zip_uint64_t);
-static int copy_source(struct zip *, struct zip_source *);
-static int write_cdir(struct zip *, const struct zip_filelist *, zip_uint64_t);
+static int add_data(zip_t *, zip_source_t *, zip_dirent_t *);
+static int copy_data(zip_t *, zip_uint64_t);
+static int copy_source(zip_t *, zip_source_t *);
+static int write_cdir(zip_t *, const zip_filelist_t *, zip_uint64_t);
 static int _zip_torrentzip_cmp(const void *, const void *);
 
 
 ZIP_EXTERN int
-zip_close(struct zip *za)
+zip_close(zip_t *za)
 {
     zip_uint64_t i, j, survivors;
     zip_int64_t off;
     int error;
-    struct zip_filelist *filelist;
+    zip_filelist_t *filelist;
     int new_torrentzip;
     int changed;
 
@@ -99,7 +99,7 @@
         return -1;
     }
     
-    if ((filelist=(struct zip_filelist *)malloc(sizeof(filelist[0])*(size_t)survivors)) == NULL)
+    if ((filelist=(zip_filelist_t *)malloc(sizeof(filelist[0])*(size_t)survivors)) == NULL)
 	return -1;
 
     /* archive comment is special for torrentzip */
@@ -150,8 +150,8 @@
     error = 0;
     for (j=0; j<survivors; j++) {
 	int new_data;
-	struct zip_entry *entry;
-	struct zip_dirent *de;
+	zip_entry_t *entry;
+	zip_dirent_t *de;
 
 	i = filelist[j].idx;
 	entry = za->entry+i;
@@ -183,7 +183,7 @@
         de->offset = (zip_uint64_t)off;
 
 	if (new_data) {
-	    struct zip_source *zs;
+	    zip_source_t *zs;
 
 	    zs = NULL;
 	    if (!ZIP_ENTRY_DATA_CHANGED(entry)) {
@@ -254,11 +254,11 @@
 
 
 static int
-add_data(struct zip *za, struct zip_source *src, struct zip_dirent *de)
+add_data(zip_t *za, zip_source_t *src, zip_dirent_t *de)
 {
     zip_int64_t offstart, offdata, offend;
     struct zip_stat st;
-    struct zip_source *s2;
+    zip_source_t *s2;
     int ret;
     int is_zip64;
     zip_flags_t flags;
@@ -312,7 +312,7 @@
 
 
     if (st.comp_method == ZIP_CM_STORE || (ZIP_CM_IS_DEFAULT(de->comp_method) && st.comp_method != de->comp_method)) {
-	struct zip_source *s_store, *s_crc;
+	zip_source_t *s_store, *s_crc;
 	zip_compression_implementation comp_impl;
 	
 	if (st.comp_method != ZIP_CM_STORE) {
@@ -427,7 +427,7 @@
 
 
 static int
-copy_data(struct zip *za, zip_uint64_t len)
+copy_data(zip_t *za, zip_uint64_t len)
 {
     zip_uint8_t buf[BUFSIZE];
     size_t n;
@@ -450,7 +450,7 @@
 
 
 static int
-copy_source(struct zip *za, struct zip_source *src)
+copy_source(zip_t *za, zip_source_t *src)
 {
     zip_uint8_t buf[BUFSIZE];
     zip_int64_t n;
@@ -481,7 +481,7 @@
 
 
 static int
-write_cdir(struct zip *za, const struct zip_filelist *filelist, zip_uint64_t survivors)
+write_cdir(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors)
 {
     zip_int64_t cd_start, end, size;
     uLong crc;
@@ -522,7 +522,7 @@
 
 
 int
-_zip_changed(const struct zip *za, zip_uint64_t *survivorsp)
+_zip_changed(const zip_t *za, zip_uint64_t *survivorsp)
 {
     int changed;
     zip_uint64_t i, survivors;
@@ -551,8 +551,8 @@
 static int
 _zip_torrentzip_cmp(const void *a, const void *b)
 {
-    const char *aname = ((const struct zip_filelist *)a)->name;
-    const char *bname = ((const struct zip_filelist *)b)->name;
+    const char *aname = ((const zip_filelist_t *)a)->name;
+    const char *bname = ((const zip_filelist_t *)b)->name;
 
     if (aname == NULL)
 	return (bname != NULL) * -1;
diff --git a/lib/zip_delete.c b/lib/zip_delete.c
index 668e8b9..b3e7abb 100644
--- a/lib/zip_delete.c
+++ b/lib/zip_delete.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN int
-zip_delete(struct zip *za, zip_uint64_t idx)
+zip_delete(zip_t *za, zip_uint64_t idx)
 {
     if (idx >= za->nentry) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_dir_add.c b/lib/zip_dir_add.c
index a68337c..f535b21 100644
--- a/lib/zip_dir_add.c
+++ b/lib/zip_dir_add.c
@@ -41,12 +41,12 @@
 /* NOTE: Signed due to -1 on error.  See zip_add.c for more details. */
 
 ZIP_EXTERN zip_int64_t
-zip_dir_add(struct zip *za, const char *name, zip_flags_t flags)
+zip_dir_add(zip_t *za, const char *name, zip_flags_t flags)
 {
     size_t len;
     zip_int64_t idx;
     char *s;
-    struct zip_source *source;
+    zip_source_t *source;
 
     if (ZIP_IS_RDONLY(za)) {
 	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
diff --git a/lib/zip_dirent.c b/lib/zip_dirent.c
index 83c6e09..10ec853 100644
--- a/lib/zip_dirent.c
+++ b/lib/zip_dirent.c
@@ -42,12 +42,12 @@
 #include "zipint.h"
 
 static time_t _zip_d2u_time(zip_uint16_t, zip_uint16_t);
-static struct zip_string *_zip_dirent_process_ef_utf_8(const struct zip_dirent *de, zip_uint16_t id, struct zip_string *str);
-static struct zip_extra_field *_zip_ef_utf8(zip_uint16_t, struct zip_string *, struct zip_error *);
+static zip_string_t *_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str);
+static zip_extra_field_t *_zip_ef_utf8(zip_uint16_t, zip_string_t *, zip_error_t *);
 
 
 void
-_zip_cdir_free(struct zip_cdir *cd)
+_zip_cdir_free(zip_cdir_t *cd)
 {
     zip_uint64_t i;
 
@@ -63,9 +63,9 @@
 
 
 int
-_zip_cdir_grow(struct zip_cdir *cd, zip_uint64_t nentry, struct zip_error *error)
+_zip_cdir_grow(zip_cdir_t *cd, zip_uint64_t nentry, zip_error_t *error)
 {
-    struct zip_entry *entry;
+    zip_entry_t *entry;
     zip_uint64_t i;
 
     if (nentry < cd->nentry_alloc) {
@@ -76,7 +76,7 @@
     if (nentry == cd->nentry_alloc)
 	return 0;
 
-    if ((entry=((struct zip_entry *)
+    if ((entry=((zip_entry_t *)
 		realloc(cd->entry, sizeof(*(cd->entry))*(size_t)nentry))) == NULL) {
 	zip_error_set(error, ZIP_ER_MEMORY, 0);
 	return -1;
@@ -92,20 +92,20 @@
 }
 
 
-struct zip_cdir *
-_zip_cdir_new(zip_uint64_t nentry, struct zip_error *error)
+zip_cdir_t *
+_zip_cdir_new(zip_uint64_t nentry, zip_error_t *error)
 {
-    struct zip_cdir *cd;
+    zip_cdir_t *cd;
     zip_uint64_t i;
     
-    if ((cd=(struct zip_cdir *)malloc(sizeof(*cd))) == NULL) {
+    if ((cd=(zip_cdir_t *)malloc(sizeof(*cd))) == NULL) {
 	zip_error_set(error, ZIP_ER_MEMORY, 0);
 	return NULL;
     }
 
     if (nentry == 0)
 	cd->entry = NULL;
-    else if ((cd->entry=(struct zip_entry *)malloc(sizeof(*(cd->entry))*(size_t)nentry)) == NULL) {
+    else if ((cd->entry=(zip_entry_t *)malloc(sizeof(*(cd->entry))*(size_t)nentry)) == NULL) {
 	zip_error_set(error, ZIP_ER_MEMORY, 0);
 	free(cd);
 	return NULL;
@@ -123,10 +123,10 @@
 
 
 zip_int64_t
-_zip_cdir_write(struct zip *za, const struct zip_filelist *filelist, zip_uint64_t survivors)
+_zip_cdir_write(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors)
 {
     zip_uint64_t offset, size;
-    struct zip_string *comment;
+    zip_string_t *comment;
     zip_uint8_t buf[EOCDLEN + EOCD64LEN], *p;
     zip_int64_t off;
     zip_uint64_t i;
@@ -142,7 +142,7 @@
     is_zip64 = 0;
 
     for (i=0; i<survivors; i++) {
-	struct zip_entry *entry = za->entry+filelist[i].idx;
+	zip_entry_t *entry = za->entry+filelist[i].idx;
 
 	if ((ret=_zip_dirent_write(za, entry->changes ? entry->changes : entry->orig, ZIP_FL_CENTRAL)) < 0)
 	    return -1;
@@ -202,12 +202,12 @@
 }
 
 
-struct zip_dirent *
-_zip_dirent_clone(const struct zip_dirent *sde)
+zip_dirent_t *
+_zip_dirent_clone(const zip_dirent_t *sde)
 {
-    struct zip_dirent *tde;
+    zip_dirent_t *tde;
 
-    if ((tde=(struct zip_dirent *)malloc(sizeof(*tde))) == NULL)
+    if ((tde=(zip_dirent_t *)malloc(sizeof(*tde))) == NULL)
 	return NULL;
 
     if (sde)
@@ -223,7 +223,7 @@
 
 
 void
-_zip_dirent_finalize(struct zip_dirent *zde)
+_zip_dirent_finalize(zip_dirent_t *zde)
 {
     if (!zde->cloned || zde->changed & ZIP_DIRENT_FILENAME)
 	_zip_string_free(zde->filename);
@@ -235,7 +235,7 @@
 
 
 void
-_zip_dirent_free(struct zip_dirent *zde)
+_zip_dirent_free(zip_dirent_t *zde)
 {
     if (zde == NULL)
 	return;
@@ -246,7 +246,7 @@
 
 
 void
-_zip_dirent_init(struct zip_dirent *de)
+_zip_dirent_init(zip_dirent_t *de)
 {
     de->changed = 0;
     de->local_extra_fields_read = 0;
@@ -271,7 +271,7 @@
 
 
 int
-_zip_dirent_needs_zip64(const struct zip_dirent *de, zip_flags_t flags)
+_zip_dirent_needs_zip64(const zip_dirent_t *de, zip_flags_t flags)
 {
     if (de->uncomp_size >= ZIP_UINT32_MAX || de->comp_size >= ZIP_UINT32_MAX
 	|| ((flags & ZIP_FL_CENTRAL) && de->offset >= ZIP_UINT32_MAX))
@@ -281,12 +281,12 @@
 }
 
 
-struct zip_dirent *
+zip_dirent_t *
 _zip_dirent_new(void)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
-    if ((de=(struct zip_dirent *)malloc(sizeof(*de))) == NULL)
+    if ((de=(zip_dirent_t *)malloc(sizeof(*de))) == NULL)
 	return NULL;
 
     _zip_dirent_init(de);
@@ -313,9 +313,9 @@
 */
 
 int
-_zip_dirent_read(struct zip_dirent *zde, struct zip_source *src,
+_zip_dirent_read(zip_dirent_t *zde, zip_source_t *src,
 		 const unsigned char **bufp, zip_uint64_t *leftp, int local,
-		 struct zip_error *error)
+		 zip_error_t *error)
 {
     unsigned char buf[CDENTRYSIZE];
     const unsigned char *cur;
@@ -514,8 +514,8 @@
 }
 
 
-static struct zip_string *
-_zip_dirent_process_ef_utf_8(const struct zip_dirent *de, zip_uint16_t id, struct zip_string *str)
+static zip_string_t *
+_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str)
 {
     zip_uint16_t ef_len;
     zip_uint32_t ef_crc;
@@ -529,7 +529,7 @@
     ef_crc = _zip_get_32(&ef);
 
     if (_zip_string_crc32(str) == ef_crc) {
-	struct zip_string *ef_str = _zip_string_new(ef, (zip_uint16_t)(ef_len-5), ZIP_FL_ENC_UTF_8, NULL);
+	zip_string_t *ef_str = _zip_string_new(ef, (zip_uint16_t)(ef_len-5), ZIP_FL_ENC_UTF_8, NULL);
 
 	if (ef_str != NULL) {
 	    _zip_string_free(str);
@@ -575,7 +575,7 @@
 */
 
 void
-_zip_dirent_torrent_normalize(struct zip_dirent *de)
+_zip_dirent_torrent_normalize(zip_dirent_t *de)
 {
     static struct tm torrenttime;
     static time_t last_mod = 0;
@@ -634,11 +634,11 @@
 */
 
 int
-_zip_dirent_write(struct zip *za, struct zip_dirent *de, zip_flags_t flags)
+_zip_dirent_write(zip_t *za, zip_dirent_t *de, zip_flags_t flags)
 {
     zip_uint16_t dostime, dosdate;
-    enum zip_encoding_type com_enc, name_enc;
-    struct zip_extra_field *ef;
+    zip_encoding_type_t com_enc, name_enc;
+    zip_extra_field_t *ef;
     zip_uint8_t ef_zip64[24], *ef_zip64_p;
     int is_zip64;
     int is_really_zip64;
@@ -667,7 +667,7 @@
 		return -1;
 	}
 	if ((flags & ZIP_FL_LOCAL) == 0 && com_enc == ZIP_ENCODING_UTF8_KNOWN){
-	    struct zip_extra_field *ef2 = _zip_ef_utf8(ZIP_EF_UTF_8_COMMENT, de->comment, &za->error);
+	    zip_extra_field_t *ef2 = _zip_ef_utf8(ZIP_EF_UTF_8_COMMENT, de->comment, &za->error);
 	    if (ef2 == NULL) {
 		_zip_ef_free(ef);
 		return -1;
@@ -696,7 +696,7 @@
     }
 
     if (ef_zip64_p != ef_zip64) {
-	struct zip_extra_field *ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(ef_zip64_p-ef_zip64), ef_zip64, ZIP_EF_BOTH);
+	zip_extra_field_t *ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(ef_zip64_p-ef_zip64), ef_zip64, ZIP_EF_BOTH);
 	ef64->next = ef;
 	ef = ef64;
 	is_zip64 = 1;
@@ -798,13 +798,13 @@
 }
 
 
-static struct zip_extra_field *
-_zip_ef_utf8(zip_uint16_t id, struct zip_string *str, struct zip_error *error)
+static zip_extra_field_t *
+_zip_ef_utf8(zip_uint16_t id, zip_string_t *str, zip_error_t *error)
 {
     const zip_uint8_t *raw;
     zip_uint8_t *data, *p;
     zip_uint32_t len;
-    struct zip_extra_field *ef;
+    zip_extra_field_t *ef;
 
     raw = _zip_string_get(str, &len, ZIP_FL_ENC_RAW, NULL);
 
@@ -829,8 +829,8 @@
 }
 
 
-struct zip_dirent *
-_zip_get_dirent(struct zip *za, zip_uint64_t idx, zip_flags_t flags, struct zip_error *error)
+zip_dirent_t *
+_zip_get_dirent(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_error_t *error)
 {
     if (error == NULL)
 	error = &za->error;
diff --git a/lib/zip_discard.c b/lib/zip_discard.c
index 2ca11df..db22370 100644
--- a/lib/zip_discard.c
+++ b/lib/zip_discard.c
@@ -42,7 +42,7 @@
    corresponding file. */
 
 void
-zip_discard(struct zip *za)
+zip_discard(zip_t *za)
 {
     zip_uint64_t i;
 
diff --git a/lib/zip_entry.c b/lib/zip_entry.c
index 73a1f50..6f89006 100644
--- a/lib/zip_entry.c
+++ b/lib/zip_entry.c
@@ -35,7 +35,7 @@
 #include "zipint.h"
 
 void
-_zip_entry_finalize(struct zip_entry *e)
+_zip_entry_finalize(zip_entry_t *e)
 {
     _zip_unchange_data(e);
     _zip_dirent_free(e->orig);
@@ -44,7 +44,7 @@
 
 
 void
-_zip_entry_init(struct zip_entry *e)
+_zip_entry_init(zip_entry_t *e)
 {
     e->orig = NULL;
     e->changes = NULL;
diff --git a/lib/zip_error.c b/lib/zip_error.c
index 90c24a8..9c6c831 100644
--- a/lib/zip_error.c
+++ b/lib/zip_error.c
@@ -119,7 +119,7 @@
 
 
 void
-_zip_error_set_from_source(zip_error_t *err, struct zip_source *src)
+_zip_error_set_from_source(zip_error_t *err, zip_source_t *src)
 {
     _zip_error_copy(err, zip_source_error(src));
 }
diff --git a/lib/zip_error_clear.c b/lib/zip_error_clear.c
index 3e6e482..ec45e68 100644
--- a/lib/zip_error_clear.c
+++ b/lib/zip_error_clear.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN void
-zip_error_clear(struct zip *za)
+zip_error_clear(zip_t *za)
 {
     if (za == NULL)
 	return;
diff --git a/lib/zip_error_get.c b/lib/zip_error_get.c
index ef98b0a..f84d3ab 100644
--- a/lib/zip_error_get.c
+++ b/lib/zip_error_get.c
@@ -37,7 +37,7 @@
 
 
 ZIP_EXTERN void
-zip_error_get(struct zip *za, int *zep, int *sep)
+zip_error_get(zip_t *za, int *zep, int *sep)
 {
     _zip_error_get(&za->error, zep, sep);
 }
diff --git a/lib/zip_error_strerror.c b/lib/zip_error_strerror.c
index a4e603d..2f124cc 100644
--- a/lib/zip_error_strerror.c
+++ b/lib/zip_error_strerror.c
@@ -41,7 +41,7 @@
 
 
 ZIP_EXTERN const char *
-zip_error_strerror(struct zip_error *err)
+zip_error_strerror(zip_error_t *err)
 {
     const char *zs, *ss;
     char buf[128], *s;
diff --git a/lib/zip_extra_field.c b/lib/zip_extra_field.c
index 74cf2be..482703e 100644
--- a/lib/zip_extra_field.c
+++ b/lib/zip_extra_field.c
@@ -39,10 +39,10 @@
 #include <string.h>
 
 
-struct zip_extra_field *
-_zip_ef_clone(const struct zip_extra_field *ef, struct zip_error *error)
+zip_extra_field_t *
+_zip_ef_clone(const zip_extra_field_t *ef, zip_error_t *error)
 {
-    struct zip_extra_field *head, *prev, *def;
+    zip_extra_field_t *head, *prev, *def;
     
     head = prev = NULL;
     
@@ -66,10 +66,10 @@
 }
 
 
-struct zip_extra_field *
-_zip_ef_delete_by_id(struct zip_extra_field *ef, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags)
+zip_extra_field_t *
+_zip_ef_delete_by_id(zip_extra_field_t *ef, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags)
 {
-    struct zip_extra_field *head, *prev;
+    zip_extra_field_t *head, *prev;
     int i;
 
     i = 0;
@@ -105,9 +105,9 @@
 
 
 void
-_zip_ef_free(struct zip_extra_field *ef)
+_zip_ef_free(zip_extra_field_t *ef)
 {
-    struct zip_extra_field *ef2;
+    zip_extra_field_t *ef2;
 
     while (ef) {
 	ef2 = ef->next;
@@ -119,7 +119,7 @@
 
 
 const zip_uint8_t *
-_zip_ef_get_by_id(const struct zip_extra_field *ef, zip_uint16_t *lenp, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags, struct zip_error *error)
+_zip_ef_get_by_id(const zip_extra_field_t *ef, zip_uint16_t *lenp, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags, zip_error_t *error)
 {
     static const zip_uint8_t empty[1] = { '\0' };
     
@@ -147,10 +147,10 @@
 }
 
 
-struct zip_extra_field *
-_zip_ef_merge(struct zip_extra_field *to, struct zip_extra_field *from)
+zip_extra_field_t *
+_zip_ef_merge(zip_extra_field_t *to, zip_extra_field_t *from)
 {
-    struct zip_extra_field *ef2, *tt, *tail;
+    zip_extra_field_t *ef2, *tt, *tail;
     int duplicate;
 
     if (to == NULL)
@@ -182,12 +182,12 @@
 }
 
 
-struct zip_extra_field *
+zip_extra_field_t *
 _zip_ef_new(zip_uint16_t id, zip_uint16_t size, const zip_uint8_t *data, zip_flags_t flags)
 {
-    struct zip_extra_field *ef;
+    zip_extra_field_t *ef;
 
-    if ((ef=(struct zip_extra_field *)malloc(sizeof(*ef))) == NULL)
+    if ((ef=(zip_extra_field_t *)malloc(sizeof(*ef))) == NULL)
 	return NULL;
 
     ef->next = NULL;
@@ -207,10 +207,10 @@
 }
 
 
-struct zip_extra_field *
-_zip_ef_parse(const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags, struct zip_error *error)
+zip_extra_field_t *
+_zip_ef_parse(const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags, zip_error_t *error)
 {
-    struct zip_extra_field *ef, *ef2, *ef_head;
+    zip_extra_field_t *ef, *ef2, *ef_head;
     const zip_uint8_t *p;
     zip_uint16_t fid, flen;
 
@@ -249,11 +249,11 @@
 }
 
 
-struct zip_extra_field *
-_zip_ef_remove_internal(struct zip_extra_field *ef)
+zip_extra_field_t *
+_zip_ef_remove_internal(zip_extra_field_t *ef)
 {
-    struct zip_extra_field *ef_head;
-    struct zip_extra_field *prev, *next;
+    zip_extra_field_t *ef_head;
+    zip_extra_field_t *prev, *next;
     
     ef_head = ef;
     prev = NULL;
@@ -280,7 +280,7 @@
 
 
 zip_uint16_t
-_zip_ef_size(const struct zip_extra_field *ef, zip_flags_t flags)
+_zip_ef_size(const zip_extra_field_t *ef, zip_flags_t flags)
 {
     zip_uint16_t size;
 
@@ -295,7 +295,7 @@
 
 
 int
-_zip_ef_write(struct zip *za, const struct zip_extra_field *ef, zip_flags_t flags)
+_zip_ef_write(zip_t *za, const zip_extra_field_t *ef, zip_flags_t flags)
 {
     zip_uint8_t b[4], *p;
 
@@ -319,9 +319,9 @@
 
 
 int
-_zip_read_local_ef(struct zip *za, zip_uint64_t idx)
+_zip_read_local_ef(zip_t *za, zip_uint64_t idx)
 {
-    struct zip_entry *e;
+    zip_entry_t *e;
     unsigned char b[4];
     const unsigned char *p;
     zip_uint16_t fname_len, ef_len;
@@ -355,7 +355,7 @@
     ef_len = _zip_get_16(&p);
 
     if (ef_len > 0) {
-	struct zip_extra_field *ef;
+	zip_extra_field_t *ef;
 	zip_uint8_t *ef_raw;
 
 	if (zip_source_seek(za->src, fname_len, SEEK_CUR) < 0) {
diff --git a/lib/zip_extra_field_api.c b/lib/zip_extra_field_api.c
index f567c28..ed93944 100644
--- a/lib/zip_extra_field_api.c
+++ b/lib/zip_extra_field_api.c
@@ -36,9 +36,9 @@
 
 
 ZIP_EXTERN int
-zip_file_extra_field_delete(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_flags_t flags)
+zip_file_extra_field_delete(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_flags_t flags)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -69,9 +69,9 @@
 
 
 ZIP_EXTERN int
-zip_file_extra_field_delete_by_id(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_flags_t flags)
+zip_file_extra_field_delete_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_flags_t flags)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -102,12 +102,12 @@
 
 
 ZIP_EXTERN const zip_uint8_t *
-zip_file_extra_field_get(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_uint16_t *idp, zip_uint16_t *lenp, zip_flags_t flags)
+zip_file_extra_field_get(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_uint16_t *idp, zip_uint16_t *lenp, zip_flags_t flags)
 {
     static const zip_uint8_t empty[1] = { '\0' };
 
-    struct zip_dirent *de;
-    struct zip_extra_field *ef;
+    zip_dirent_t *de;
+    zip_extra_field_t *ef;
     int i;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
@@ -148,9 +148,9 @@
 
 
 ZIP_EXTERN const zip_uint8_t *
-zip_file_extra_field_get_by_id(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_uint16_t *lenp, zip_flags_t flags)
+zip_file_extra_field_get_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_uint16_t *lenp, zip_flags_t flags)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -169,10 +169,10 @@
 
 
 ZIP_EXTERN zip_int16_t
-zip_file_extra_fields_count(struct zip *za, zip_uint64_t idx, zip_flags_t flags)
+zip_file_extra_fields_count(zip_t *za, zip_uint64_t idx, zip_flags_t flags)
 {
-    struct zip_dirent *de;
-    struct zip_extra_field *ef;
+    zip_dirent_t *de;
+    zip_extra_field_t *ef;
     zip_uint16_t n;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
@@ -197,10 +197,10 @@
 
 
 ZIP_EXTERN zip_int16_t
-zip_file_extra_fields_count_by_id(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_flags_t flags)
+zip_file_extra_fields_count_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_flags_t flags)
 {
-    struct zip_dirent *de;
-    struct zip_extra_field *ef;
+    zip_dirent_t *de;
+    zip_extra_field_t *ef;
     zip_uint16_t n;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
@@ -225,11 +225,11 @@
 
 
 ZIP_EXTERN int
-zip_file_extra_field_set(struct zip *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags)
+zip_file_extra_field_set(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
     zip_uint16_t ls, cs;
-    struct zip_extra_field *ef, *ef_prev, *ef_new;
+    zip_extra_field_t *ef, *ef_prev, *ef_new;
     int i, found, new_len;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
@@ -329,9 +329,9 @@
 
 
 int
-_zip_file_extra_field_prepare_for_change(struct zip *za, zip_uint64_t idx)
+_zip_file_extra_field_prepare_for_change(zip_t *za, zip_uint64_t idx)
 {
-    struct zip_entry *e;
+    zip_entry_t *e;
     
     if (idx >= za->nentry) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_fclose.c b/lib/zip_fclose.c
index d5148c7..25a201b 100644
--- a/lib/zip_fclose.c
+++ b/lib/zip_fclose.c
@@ -38,7 +38,7 @@
 
 
 ZIP_EXTERN int
-zip_fclose(struct zip_file *zf)
+zip_fclose(zip_file_t *zf)
 {
     int ret;
     
diff --git a/lib/zip_fdopen.c b/lib/zip_fdopen.c
index ac11316..c5b5531 100644
--- a/lib/zip_fdopen.c
+++ b/lib/zip_fdopen.c
@@ -35,13 +35,13 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip *
+ZIP_EXTERN zip_t *
 zip_fdopen(int fd_orig, int _flags, int *zep)
 {
     int fd;
     FILE *fp;
-    struct zip *za;
-    struct zip_source *src;
+    zip_t *za;
+    zip_source_t *src;
     struct zip_error error;
 
     if (_flags < 0 || (_flags & ZIP_TRUNCATE)) {
diff --git a/lib/zip_file_add.c b/lib/zip_file_add.c
index fe95287..9944c0f 100644
--- a/lib/zip_file_add.c
+++ b/lib/zip_file_add.c
@@ -42,7 +42,7 @@
 */
 
 ZIP_EXTERN zip_int64_t
-zip_file_add(struct zip *za, const char *name, struct zip_source *source, zip_flags_t flags)
+zip_file_add(zip_t *za, const char *name, zip_source_t *source, zip_flags_t flags)
 {
     if (name == NULL || source == NULL) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_file_error_clear.c b/lib/zip_file_error_clear.c
index 927bad9..be45498 100644
--- a/lib/zip_file_error_clear.c
+++ b/lib/zip_file_error_clear.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN void
-zip_file_error_clear(struct zip_file *zf)
+zip_file_error_clear(zip_file_t *zf)
 {
     if (zf == NULL)
 	return;
diff --git a/lib/zip_file_error_get.c b/lib/zip_file_error_get.c
index 1ef56bc..be764fd 100644
--- a/lib/zip_file_error_get.c
+++ b/lib/zip_file_error_get.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN void
-zip_file_error_get(struct zip_file *zf, int *zep, int *sep)
+zip_file_error_get(zip_file_t *zf, int *zep, int *sep)
 {
     _zip_error_get(&zf->error, zep, sep);
 }
diff --git a/lib/zip_file_get_comment.c b/lib/zip_file_get_comment.c
index 4473aa0..55e7dc2 100644
--- a/lib/zip_file_get_comment.c
+++ b/lib/zip_file_get_comment.c
@@ -37,9 +37,9 @@
 /* lenp is 32 bit because converted comment can be longer than ZIP_UINT16_MAX */
 
 ZIP_EXTERN const char *
-zip_file_get_comment(struct zip *za, zip_uint64_t idx, zip_uint32_t *lenp, zip_flags_t flags)
+zip_file_get_comment(zip_t *za, zip_uint64_t idx, zip_uint32_t *lenp, zip_flags_t flags)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
     zip_uint32_t len;
     const zip_uint8_t *str;
 
diff --git a/lib/zip_file_get_external_attributes.c b/lib/zip_file_get_external_attributes.c
index a7c6455..b6526cf 100644
--- a/lib/zip_file_get_external_attributes.c
+++ b/lib/zip_file_get_external_attributes.c
@@ -34,9 +34,9 @@
 #include "zipint.h"
 
 int
-zip_file_get_external_attributes(struct zip *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t *opsys, zip_uint32_t *attributes)
+zip_file_get_external_attributes(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t *opsys, zip_uint32_t *attributes)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
     if ((de=_zip_get_dirent(za, idx, flags, NULL)) == NULL)
 	return -1;
diff --git a/lib/zip_file_get_offset.c b/lib/zip_file_get_offset.c
index 28e3ad9..1aaca71 100644
--- a/lib/zip_file_get_offset.c
+++ b/lib/zip_file_get_offset.c
@@ -49,7 +49,7 @@
 */
 
 zip_uint64_t
-_zip_file_get_offset(const struct zip *za, zip_uint64_t idx, struct zip_error *error)
+_zip_file_get_offset(const zip_t *za, zip_uint64_t idx, zip_error_t *error)
 {
     zip_uint64_t offset;
     zip_int32_t size;
diff --git a/lib/zip_file_rename.c b/lib/zip_file_rename.c
index 17d8ff8..4400938 100644
--- a/lib/zip_file_rename.c
+++ b/lib/zip_file_rename.c
@@ -38,7 +38,7 @@
 
 
 ZIP_EXTERN int
-zip_file_rename(struct zip *za, zip_uint64_t idx, const char *name, zip_flags_t flags)
+zip_file_rename(zip_t *za, zip_uint64_t idx, const char *name, zip_flags_t flags)
 {
     const char *old_name;
     int old_is_dir, new_is_dir;
diff --git a/lib/zip_file_replace.c b/lib/zip_file_replace.c
index 01a0916..e430efa 100644
--- a/lib/zip_file_replace.c
+++ b/lib/zip_file_replace.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN int
-zip_file_replace(struct zip *za, zip_uint64_t idx, struct zip_source *source, zip_flags_t flags)
+zip_file_replace(zip_t *za, zip_uint64_t idx, zip_source_t *source, zip_flags_t flags)
 {
     if (idx >= za->nentry || source == NULL) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -54,7 +54,7 @@
 /* NOTE: Signed due to -1 on error.  See zip_add.c for more details. */
 
 zip_int64_t
-_zip_file_replace(struct zip *za, zip_uint64_t idx, const char *name, struct zip_source *source, zip_flags_t flags)
+_zip_file_replace(zip_t *za, zip_uint64_t idx, const char *name, zip_source_t *source, zip_flags_t flags)
 {
     zip_uint64_t za_nentry_prev;
     
diff --git a/lib/zip_file_set_comment.c b/lib/zip_file_set_comment.c
index cdc3a35..e455fbd 100644
--- a/lib/zip_file_set_comment.c
+++ b/lib/zip_file_set_comment.c
@@ -38,11 +38,11 @@
 
 
 ZIP_EXTERN int
-zip_file_set_comment(struct zip *za, zip_uint64_t idx,
+zip_file_set_comment(zip_t *za, zip_uint64_t idx,
 		     const char *comment, zip_uint16_t len, zip_flags_t flags)
 {
-    struct zip_entry *e;
-    struct zip_string *cstr;
+    zip_entry_t *e;
+    zip_string_t *cstr;
     int changed;
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
diff --git a/lib/zip_file_set_external_attributes.c b/lib/zip_file_set_external_attributes.c
index 1de59dc..d8f580e 100644
--- a/lib/zip_file_set_external_attributes.c
+++ b/lib/zip_file_set_external_attributes.c
@@ -34,9 +34,9 @@
 #include "zipint.h"
 
 int
-zip_file_set_external_attributes(struct zip *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t opsys, zip_uint32_t attributes)
+zip_file_set_external_attributes(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t opsys, zip_uint32_t attributes)
 {
-    struct zip_entry *e;
+    zip_entry_t *e;
     int changed;
     zip_uint8_t unchanged_opsys;
     zip_uint32_t unchanged_attributes;
diff --git a/lib/zip_file_set_mtime.c b/lib/zip_file_set_mtime.c
index 59c3aff..3acc7f2 100644
--- a/lib/zip_file_set_mtime.c
+++ b/lib/zip_file_set_mtime.c
@@ -33,9 +33,9 @@
 
 #include "zipint.h"
 
-ZIP_EXTERN int zip_file_set_mtime(struct zip *za, zip_uint64_t idx, time_t mtime, zip_flags_t flags)
+ZIP_EXTERN int zip_file_set_mtime(zip_t *za, zip_uint64_t idx, time_t mtime, zip_flags_t flags)
 {
-    struct zip_entry *e;
+    zip_entry_t *e;
     int changed;
     
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
diff --git a/lib/zip_file_strerror.c b/lib/zip_file_strerror.c
index 95c5923..8366f1e 100644
--- a/lib/zip_file_strerror.c
+++ b/lib/zip_file_strerror.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN const char *
-zip_file_strerror(struct zip_file *zf)
+zip_file_strerror(zip_file_t *zf)
 {
     return zip_error_strerror(&zf->error);
 }
diff --git a/lib/zip_fopen.c b/lib/zip_fopen.c
index ad7c416..3adb5de 100644
--- a/lib/zip_fopen.c
+++ b/lib/zip_fopen.c
@@ -35,8 +35,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_file *
-zip_fopen(struct zip *za, const char *fname, zip_flags_t flags)
+ZIP_EXTERN zip_file_t *
+zip_fopen(zip_t *za, const char *fname, zip_flags_t flags)
 {
     zip_int64_t idx;
 
diff --git a/lib/zip_fopen_encrypted.c b/lib/zip_fopen_encrypted.c
index 8b2d05e..5eaf2b0 100644
--- a/lib/zip_fopen_encrypted.c
+++ b/lib/zip_fopen_encrypted.c
@@ -35,8 +35,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_file *
-zip_fopen_encrypted(struct zip *za, const char *fname, zip_flags_t flags, const char *password)
+ZIP_EXTERN zip_file_t *
+zip_fopen_encrypted(zip_t *za, const char *fname, zip_flags_t flags, const char *password)
 {
     zip_int64_t idx;
 
diff --git a/lib/zip_fopen_index.c b/lib/zip_fopen_index.c
index 7887eef..e9a169a 100644
--- a/lib/zip_fopen_index.c
+++ b/lib/zip_fopen_index.c
@@ -39,8 +39,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_file *
-zip_fopen_index(struct zip *za, zip_uint64_t index, zip_flags_t flags)
+ZIP_EXTERN zip_file_t *
+zip_fopen_index(zip_t *za, zip_uint64_t index, zip_flags_t flags)
 {
     return zip_fopen_index_encrypted(za, index, flags, za->default_password);
 }
diff --git a/lib/zip_fopen_index_encrypted.c b/lib/zip_fopen_index_encrypted.c
index fe407cb..21cc433 100644
--- a/lib/zip_fopen_index_encrypted.c
+++ b/lib/zip_fopen_index_encrypted.c
@@ -38,15 +38,15 @@
 
 #include "zipint.h"
 
-static struct zip_file *_zip_file_new(struct zip *za);
+static zip_file_t *_zip_file_new(zip_t *za);
 
 
-ZIP_EXTERN struct zip_file *
-zip_fopen_index_encrypted(struct zip *za, zip_uint64_t index, zip_flags_t flags,
+ZIP_EXTERN zip_file_t *
+zip_fopen_index_encrypted(zip_t *za, zip_uint64_t index, zip_flags_t flags,
 			  const char *password)
 {
-    struct zip_file *zf;
-    struct zip_source *src;
+    zip_file_t *zf;
+    zip_source_t *src;
 
     if ((src=_zip_source_zip_new(za, za, index, flags, 0, 0, password)) == NULL)
 	return NULL;
@@ -68,12 +68,12 @@
 }
 
 
-static struct zip_file *
-_zip_file_new(struct zip *za)
+static zip_file_t *
+_zip_file_new(zip_t *za)
 {
-    struct zip_file *zf;
+    zip_file_t *zf;
 
-    if ((zf=(struct zip_file *)malloc(sizeof(struct zip_file))) == NULL) {
+    if ((zf=(zip_file_t *)malloc(sizeof(struct zip_file))) == NULL) {
 	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
 	return NULL;
     }
diff --git a/lib/zip_fread.c b/lib/zip_fread.c
index 32fe00f..9c1cbe0 100644
--- a/lib/zip_fread.c
+++ b/lib/zip_fread.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN zip_int64_t
-zip_fread(struct zip_file *zf, void *outbuf, zip_uint64_t toread)
+zip_fread(zip_file_t *zf, void *outbuf, zip_uint64_t toread)
 {
     zip_int64_t n;
 
diff --git a/lib/zip_get_archive_comment.c b/lib/zip_get_archive_comment.c
index 971883f..78f8ca0 100644
--- a/lib/zip_get_archive_comment.c
+++ b/lib/zip_get_archive_comment.c
@@ -38,9 +38,9 @@
 
 
 ZIP_EXTERN const char *
-zip_get_archive_comment(struct zip *za, int *lenp, zip_flags_t flags)
+zip_get_archive_comment(zip_t *za, int *lenp, zip_flags_t flags)
 {
-    struct zip_string *comment;
+    zip_string_t *comment;
     zip_uint32_t len;
     const zip_uint8_t *str;
 
diff --git a/lib/zip_get_archive_flag.c b/lib/zip_get_archive_flag.c
index 6e87126..bffe10c 100644
--- a/lib/zip_get_archive_flag.c
+++ b/lib/zip_get_archive_flag.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN int
-zip_get_archive_flag(struct zip *za, zip_flags_t flag, zip_flags_t flags)
+zip_get_archive_flag(zip_t *za, zip_flags_t flag, zip_flags_t flags)
 {
     unsigned int fl;
 
diff --git a/lib/zip_get_file_comment.c b/lib/zip_get_file_comment.c
index 20bbf99..d5f50bf 100644
--- a/lib/zip_get_file_comment.c
+++ b/lib/zip_get_file_comment.c
@@ -37,7 +37,7 @@
 
 
 ZIP_EXTERN const char *
-zip_get_file_comment(struct zip *za, zip_uint64_t idx, int *lenp, int flags)
+zip_get_file_comment(zip_t *za, zip_uint64_t idx, int *lenp, int flags)
 {
     zip_uint32_t len;
     const char *s;
diff --git a/lib/zip_get_name.c b/lib/zip_get_name.c
index 0ae78de..d29e636 100644
--- a/lib/zip_get_name.c
+++ b/lib/zip_get_name.c
@@ -38,16 +38,16 @@
 
 
 ZIP_EXTERN const char *
-zip_get_name(struct zip *za, zip_uint64_t idx, zip_flags_t flags)
+zip_get_name(zip_t *za, zip_uint64_t idx, zip_flags_t flags)
 {
     return _zip_get_name(za, idx, flags, &za->error);
 }
 
 
 const char *
-_zip_get_name(struct zip *za, zip_uint64_t idx, zip_flags_t flags, struct zip_error *error)
+_zip_get_name(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_error_t *error)
 {
-    struct zip_dirent *de;
+    zip_dirent_t *de;
     const zip_uint8_t *str;
 
     if ((de=_zip_get_dirent(za, idx, flags, error)) == NULL)
diff --git a/lib/zip_get_num_entries.c b/lib/zip_get_num_entries.c
index 9a70375..c8644a4 100644
--- a/lib/zip_get_num_entries.c
+++ b/lib/zip_get_num_entries.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN zip_int64_t
-zip_get_num_entries(struct zip *za, zip_flags_t flags)
+zip_get_num_entries(zip_t *za, zip_flags_t flags)
 {
     zip_uint64_t n;
 
diff --git a/lib/zip_get_num_files.c b/lib/zip_get_num_files.c
index 224b975..cf96353 100644
--- a/lib/zip_get_num_files.c
+++ b/lib/zip_get_num_files.c
@@ -38,7 +38,7 @@
 
 
 ZIP_EXTERN int
-zip_get_num_files(struct zip *za)
+zip_get_num_files(zip_t *za)
 {
     if (za == NULL)
 	return -1;
diff --git a/lib/zip_io_util.c b/lib/zip_io_util.c
index 6664ecd..1e9178e 100644
--- a/lib/zip_io_util.c
+++ b/lib/zip_io_util.c
@@ -75,7 +75,7 @@
 }
 
 int
-_zip_read(struct zip_source *src, zip_uint8_t *b, zip_uint64_t length, struct zip_error *error)
+_zip_read(zip_source_t *src, zip_uint8_t *b, zip_uint64_t length, zip_error_t *error)
 {
     zip_int64_t n;
 
@@ -99,7 +99,7 @@
 
 
 zip_uint8_t *
-_zip_read_data(const zip_uint8_t **buf, struct zip_source *src, size_t len, int nulp, struct zip_error *error)
+_zip_read_data(const zip_uint8_t **buf, zip_source_t *src, size_t len, int nulp, zip_error_t *error)
 {
     zip_uint8_t *r;
 
@@ -136,11 +136,11 @@
 }
 
 
-struct zip_string *
-_zip_read_string(const zip_uint8_t **buf, struct zip_source *src, zip_uint16_t len, int nulp, struct zip_error *error)
+zip_string_t *
+_zip_read_string(const zip_uint8_t **buf, zip_source_t *src, zip_uint16_t len, int nulp, zip_error_t *error)
 {
     zip_uint8_t *raw;
-    struct zip_string *s;
+    zip_string_t *s;
 
     if ((raw=_zip_read_data(buf, src, len, nulp, error)) == NULL)
 	return NULL;
@@ -194,7 +194,7 @@
 
 
 int
-_zip_write(struct zip *za, const void *data, zip_uint64_t length)
+_zip_write(zip_t *za, const void *data, zip_uint64_t length)
 {
     zip_int64_t n;
     
diff --git a/lib/zip_memdup.c b/lib/zip_memdup.c
index 758b946..cc6d767 100644
--- a/lib/zip_memdup.c
+++ b/lib/zip_memdup.c
@@ -38,7 +38,7 @@
 
 
 void *
-_zip_memdup(const void *mem, size_t len, struct zip_error *error)
+_zip_memdup(const void *mem, size_t len, zip_error_t *error)
 {
     void *ret;
 
diff --git a/lib/zip_name_locate.c b/lib/zip_name_locate.c
index 3435e14..820ea0c 100644
--- a/lib/zip_name_locate.c
+++ b/lib/zip_name_locate.c
@@ -41,14 +41,14 @@
 
 
 ZIP_EXTERN zip_int64_t
-zip_name_locate(struct zip *za, const char *fname, zip_flags_t flags)
+zip_name_locate(zip_t *za, const char *fname, zip_flags_t flags)
 {
     return _zip_name_locate(za, fname, flags, &za->error);
 }
 
 
 zip_int64_t
-_zip_name_locate(struct zip *za, const char *fname, zip_flags_t flags, struct zip_error *error)
+_zip_name_locate(zip_t *za, const char *fname, zip_flags_t flags, zip_error_t *error)
 {
     int (*cmp)(const char *, const char *);
     const char *fn, *p;
diff --git a/lib/zip_new.c b/lib/zip_new.c
index 484ee75..d54a247 100644
--- a/lib/zip_new.c
+++ b/lib/zip_new.c
@@ -41,12 +41,12 @@
    creates a new zipfile struct, and sets the contents to zero; returns
    the new struct. */
 
-struct zip *
-_zip_new(struct zip_error *error)
+zip_t *
+_zip_new(zip_error_t *error)
 {
-    struct zip *za;
+    zip_t *za;
 
-    za = (struct zip *)malloc(sizeof(struct zip));
+    za = (zip_t *)malloc(sizeof(struct zip));
     if (!za) {
 	zip_error_set(error, ZIP_ER_MEMORY, 0);
 	return NULL;
diff --git a/lib/zip_open.c b/lib/zip_open.c
index 0b4ec4d..d6899b3 100644
--- a/lib/zip_open.c
+++ b/lib/zip_open.c
@@ -47,26 +47,26 @@
     EXISTS_EMPTY,
     EXISTS_NONEMPTY,
 } exists_t;
-static struct zip *_zip_allocate_new(struct zip_source *src, unsigned int flags, struct zip_error *error);
-static zip_int64_t _zip_checkcons(struct zip *za, struct zip_cdir *cdir, struct zip_error *error);
-static void _zip_check_torrentzip(struct zip *za, const struct zip_cdir *cdir);
-static struct zip_cdir *_zip_find_central_dir(struct zip *za, zip_uint64_t len);
-static exists_t _zip_file_exists(struct zip_source *src, struct zip_error *error);
-static int _zip_headercomp(const struct zip_dirent *, const struct zip_dirent *);
+static zip_t *_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error);
+static zip_int64_t _zip_checkcons(zip_t *za, zip_cdir_t *cdir, zip_error_t *error);
+static void _zip_check_torrentzip(zip_t *za, const zip_cdir_t *cdir);
+static zip_cdir_t *_zip_find_central_dir(zip_t *za, zip_uint64_t len);
+static exists_t _zip_file_exists(zip_source_t *src, zip_error_t *error);
+static int _zip_headercomp(const zip_dirent_t *, const zip_dirent_t *);
 static unsigned char *_zip_memmem(const unsigned char *, size_t,
 				  const unsigned char *, size_t);
-static struct zip_cdir *_zip_read_cdir(zip_t *za, zip_uint64_t buf_offset, zip_uint8_t *buf, const zip_uint8_t *eocd, size_t buflen, struct zip_error *error);
-static struct zip_cdir *_zip_read_eocd(const unsigned char *, const unsigned char *, zip_uint64_t,
-				       size_t, unsigned int, struct zip_error *);
-static struct zip_cdir *_zip_read_eocd64(struct zip_source *, const zip_uint8_t *, const zip_uint8_t *,
-                                         zip_uint64_t, size_t, unsigned int, struct zip_error *);
+static zip_cdir_t *_zip_read_cdir(zip_t *za, zip_uint64_t buf_offset, zip_uint8_t *buf, const zip_uint8_t *eocd, size_t buflen, zip_error_t *error);
+static zip_cdir_t *_zip_read_eocd(const unsigned char *, const unsigned char *, zip_uint64_t,
+				       size_t, unsigned int, zip_error_t *);
+static zip_cdir_t *_zip_read_eocd64(zip_source_t *, const zip_uint8_t *, const zip_uint8_t *,
+                                         zip_uint64_t, size_t, unsigned int, zip_error_t *);
 
 
-ZIP_EXTERN struct zip *
+ZIP_EXTERN zip_t *
 zip_open(const char *fn, int _flags, int *zep)
 {
-    struct zip *za;
-    struct zip_source *src;
+    zip_t *za;
+    zip_source_t *src;
     struct zip_error error;
 
     zip_error_init(&error);
@@ -87,8 +87,8 @@
 }
 
 
-ZIP_EXTERN struct zip *
-zip_open_from_source(struct zip_source *src, int _flags, struct zip_error *error)
+ZIP_EXTERN zip_t *
+zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error)
 {
     static zip_int64_t needed_support_read = -1;
     static zip_int64_t needed_support_write = -1;
@@ -162,7 +162,7 @@
 }
 
 ZIP_EXTERN int
-zip_archive_set_tempdir(struct zip *za, const char *tempdir)
+zip_archive_set_tempdir(zip_t *za, const char *tempdir)
 {
     char *new_tempdir;
     
@@ -181,11 +181,11 @@
     return 0;
 }
 
-struct zip *
-_zip_open(struct zip_source *src, unsigned int flags, struct zip_error *error)
+zip_t *
+_zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error)
 {
-    struct zip *za;
-    struct zip_cdir *cdir;
+    zip_t *za;
+    zip_cdir_t *cdir;
     struct zip_stat st;
     zip_uint64_t len;
 
@@ -235,7 +235,7 @@
 
 
 void
-_zip_set_open_error(int *zep, const struct zip_error *err, int ze)
+_zip_set_open_error(int *zep, const zip_error_t *err, int ze)
 {
     if (err) {
 	ze = zip_error_code_zip(err);
@@ -255,10 +255,10 @@
    Returns a struct zip_cdir which contains the central directory 
    entries, or NULL if unsuccessful. */
 
-static struct zip_cdir *
-_zip_read_cdir(zip_t *za, zip_uint64_t buf_offset, zip_uint8_t *buf, const zip_uint8_t *eocd, size_t buflen, struct zip_error *error)
+static zip_cdir_t *
+_zip_read_cdir(zip_t *za, zip_uint64_t buf_offset, zip_uint8_t *buf, const zip_uint8_t *eocd, size_t buflen, zip_error_t *error)
 {
-    struct zip_cdir *cd;
+    zip_cdir_t *cd;
     const unsigned char *cdp;
     const unsigned char **bufp;
     zip_int64_t tail_len, comment_len;
@@ -363,7 +363,7 @@
    difference between the lowest and the highest fileposition reached */
 
 static zip_int64_t
-_zip_checkcons(struct zip *za, struct zip_cdir *cd, struct zip_error *error)
+_zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error)
 {
     zip_uint64_t i;
     zip_uint64_t min, max, j;
@@ -422,7 +422,7 @@
    check whether ZA has a valid TORRENTZIP comment, i.e. is torrentzipped */
 
 static void
-_zip_check_torrentzip(struct zip *za, const struct zip_cdir *cdir)
+_zip_check_torrentzip(zip_t *za, const zip_cdir_t *cdir)
 {
     uLong crc_got, crc_should;
     char buf[8+1];
@@ -456,7 +456,7 @@
    Return 0 if they are consistent, -1 if not. */
 
 static int
-_zip_headercomp(const struct zip_dirent *central, const struct zip_dirent *local)
+_zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local)
 {
     if ((central->version_needed != local->version_needed)
 #if 0
@@ -483,10 +483,10 @@
 }
 
 
-static struct zip *
-_zip_allocate_new(struct zip_source *src, unsigned int flags, struct zip_error *error)
+static zip_t *
+_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error)
 {
-    struct zip *za;
+    zip_t *za;
 
     if ((za = _zip_new(error)) == NULL) {
 	return NULL;
@@ -506,7 +506,7 @@
  * tests for file existence
  */
 static exists_t
-_zip_file_exists(struct zip_source *src, struct zip_error *error)
+_zip_file_exists(zip_source_t *src, zip_error_t *error)
 {
     struct zip_stat st;
 
@@ -524,10 +524,10 @@
 }
 
 
-static struct zip_cdir *
-_zip_find_central_dir(struct zip *za, zip_uint64_t len)
+static zip_cdir_t *
+_zip_find_central_dir(zip_t *za, zip_uint64_t len)
 {
-    struct zip_cdir *cdir, *cdirnew;
+    zip_cdir_t *cdir, *cdirnew;
     unsigned char *buf, *match;
     zip_int64_t buf_offset;
     zip_uint64_t buflen;
@@ -542,7 +542,7 @@
 
     buflen = (len < CDBUFSIZE ? len : CDBUFSIZE);
     if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) {
-	struct zip_error *src_error = zip_source_error(za->src);
+	zip_error_t *src_error = zip_source_error(za->src);
 	if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
 	    /* seek before start of file on my machine */
 	    _zip_error_copy(&za->error, src_error);
@@ -629,11 +629,11 @@
 }
 
 
-static struct zip_cdir *
+static zip_cdir_t *
 _zip_read_eocd(const unsigned char *eocd, const unsigned char *buf, zip_uint64_t buf_offset, size_t buflen,
-	       unsigned int flags, struct zip_error *error)
+	       unsigned int flags, zip_error_t *error)
 {
-    struct zip_cdir *cd;
+    zip_cdir_t *cd;
     const unsigned char *cdp;
     zip_uint64_t i, nentry, size, offset;
 
@@ -683,11 +683,11 @@
 }
 
 
-static struct zip_cdir *
-_zip_read_eocd64(struct zip_source *src, const zip_uint8_t *eocd64loc, const zip_uint8_t *buf,
-		 zip_uint64_t buf_offset, size_t buflen, unsigned int flags, struct zip_error *error)
+static zip_cdir_t *
+_zip_read_eocd64(zip_source_t *src, const zip_uint8_t *eocd64loc, const zip_uint8_t *buf,
+		 zip_uint64_t buf_offset, size_t buflen, unsigned int flags, zip_error_t *error)
 {
-    struct zip_cdir *cd;
+    zip_cdir_t *cd;
     zip_uint64_t offset;
     const zip_uint8_t *cdp;
     zip_uint8_t eocd[EOCD64LEN];
diff --git a/lib/zip_rename.c b/lib/zip_rename.c
index ecc7705..14e101d 100644
--- a/lib/zip_rename.c
+++ b/lib/zip_rename.c
@@ -39,7 +39,7 @@
 
 
 ZIP_EXTERN int
-zip_rename(struct zip *za, zip_uint64_t idx, const char *name)
+zip_rename(zip_t *za, zip_uint64_t idx, const char *name)
 {
     return zip_file_rename(za, idx, name, 0);
 }
diff --git a/lib/zip_replace.c b/lib/zip_replace.c
index 5838252..eed019a 100644
--- a/lib/zip_replace.c
+++ b/lib/zip_replace.c
@@ -37,7 +37,7 @@
 
 
 ZIP_EXTERN int
-zip_replace(struct zip *za, zip_uint64_t idx, struct zip_source *source)
+zip_replace(zip_t *za, zip_uint64_t idx, zip_source_t *source)
 {
     return zip_file_replace(za, idx, source, 0);
 }
diff --git a/lib/zip_set_archive_comment.c b/lib/zip_set_archive_comment.c
index 2153138..9090eec 100644
--- a/lib/zip_set_archive_comment.c
+++ b/lib/zip_set_archive_comment.c
@@ -38,9 +38,9 @@
 
 
 ZIP_EXTERN int
-zip_set_archive_comment(struct zip *za, const char *comment, zip_uint16_t len)
+zip_set_archive_comment(zip_t *za, const char *comment, zip_uint16_t len)
 {
-    struct zip_string *cstr;
+    zip_string_t *cstr;
 
     if (ZIP_IS_RDONLY(za)) {
 	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
diff --git a/lib/zip_set_archive_flag.c b/lib/zip_set_archive_flag.c
index 7f555c3..2625b2e 100644
--- a/lib/zip_set_archive_flag.c
+++ b/lib/zip_set_archive_flag.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN int
-zip_set_archive_flag(struct zip *za, zip_flags_t flag, int value)
+zip_set_archive_flag(zip_t *za, zip_flags_t flag, int value)
 {
     unsigned int new_flags;
     
diff --git a/lib/zip_set_default_password.c b/lib/zip_set_default_password.c
index f45d580..ac098dc 100644
--- a/lib/zip_set_default_password.c
+++ b/lib/zip_set_default_password.c
@@ -39,7 +39,7 @@
 
 
 ZIP_EXTERN int
-zip_set_default_password(struct zip *za, const char *passwd)
+zip_set_default_password(zip_t *za, const char *passwd)
 {
     if (za == NULL)
 	return -1;
diff --git a/lib/zip_set_file_comment.c b/lib/zip_set_file_comment.c
index fffff46..d356693 100644
--- a/lib/zip_set_file_comment.c
+++ b/lib/zip_set_file_comment.c
@@ -39,7 +39,7 @@
 
 
 ZIP_EXTERN int
-zip_set_file_comment(struct zip *za, zip_uint64_t idx, const char *comment, int len)
+zip_set_file_comment(zip_t *za, zip_uint64_t idx, const char *comment, int len)
 {
     if (len < 0 || len > ZIP_UINT16_MAX) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_set_file_compression.c b/lib/zip_set_file_compression.c
index 41aaa67..1e45f24 100644
--- a/lib/zip_set_file_compression.c
+++ b/lib/zip_set_file_compression.c
@@ -36,10 +36,10 @@
 
 
 ZIP_EXTERN int
-zip_set_file_compression(struct zip *za, zip_uint64_t idx,
+zip_set_file_compression(zip_t *za, zip_uint64_t idx,
 			 zip_int32_t method, zip_uint32_t flags)
 {
-    struct zip_entry *e;
+    zip_entry_t *e;
     zip_int32_t old_method;
 
     if (idx >= za->nentry) {
diff --git a/lib/zip_set_name.c b/lib/zip_set_name.c
index 87d372f..5a10381 100644
--- a/lib/zip_set_name.c
+++ b/lib/zip_set_name.c
@@ -39,10 +39,10 @@
 
 
 int
-_zip_set_name(struct zip *za, zip_uint64_t idx, const char *name, zip_flags_t flags)
+_zip_set_name(zip_t *za, zip_uint64_t idx, const char *name, zip_flags_t flags)
 {
-    struct zip_entry *e;
-    struct zip_string *str;
+    zip_entry_t *e;
+    zip_string_t *str;
     int changed;
     zip_int64_t i;
 
diff --git a/lib/zip_source_begin_write.c b/lib/zip_source_begin_write.c
index a6a8563..b3675d2 100644
--- a/lib/zip_source_begin_write.c
+++ b/lib/zip_source_begin_write.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_begin_write(struct zip_source *src)
+zip_source_begin_write(zip_source_t *src)
 {
     if (ZIP_SOURCE_IS_OPEN_WRITING(src)) {
         zip_error_set(&src->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_source_buffer.c b/lib/zip_source_buffer.c
index 0d61141..3914733 100644
--- a/lib/zip_source_buffer.c
+++ b/lib/zip_source_buffer.c
@@ -69,11 +69,11 @@
 static int buffer_seek(buffer_t *buffer, void *data, zip_uint64_t len, zip_error_t *error);
 static zip_int64_t buffer_write(buffer_t *buffer, const zip_uint8_t *data, zip_uint64_t length, zip_error_t *);
 
-static zip_int64_t read_data(void *, void *, zip_uint64_t, enum zip_source_cmd);
+static zip_int64_t read_data(void *, void *, zip_uint64_t, zip_source_cmd_t);
 
 
-ZIP_EXTERN struct zip_source *
-zip_source_buffer(struct zip *za, const void *data, zip_uint64_t len, int freep)
+ZIP_EXTERN zip_source_t *
+zip_source_buffer(zip_t *za, const void *data, zip_uint64_t len, int freep)
 {
     if (za == NULL)
 	return NULL;
@@ -82,11 +82,11 @@
 }
 
 
-ZIP_EXTERN struct zip_source *
+ZIP_EXTERN zip_source_t *
 zip_source_buffer_create(const void *data, zip_uint64_t len, int freep, zip_error_t *error)
 {
     struct read_data *ctx;
-    struct zip_source *zs;
+    zip_source_t *zs;
 
     if (data == NULL && len > 0) {
 	zip_error_set(error, ZIP_ER_INVAL, 0);
@@ -119,7 +119,7 @@
 
 
 static zip_int64_t
-read_data(void *state, void *data, zip_uint64_t len, enum zip_source_cmd cmd)
+read_data(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct read_data *ctx = (struct read_data *)state;
 
@@ -186,14 +186,14 @@
        
         case ZIP_SOURCE_STAT:
         {
-            struct zip_stat *st;
+            zip_stat_t *st;
 	    
 	    if (len < sizeof(*st)) {
                 zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
 		return -1;
 	    }
 
-	    st = (struct zip_stat *)data;
+	    st = (zip_stat_t *)data;
 
 	    zip_stat_init(st);
 	    st->mtime = ctx->mtime;
diff --git a/lib/zip_source_call.c b/lib/zip_source_call.c
index e0a1a63..ab14c76 100644
--- a/lib/zip_source_call.c
+++ b/lib/zip_source_call.c
@@ -36,7 +36,7 @@
 
 
 zip_int64_t
-_zip_source_call(zip_source_t *src, void *data, zip_uint64_t length, enum zip_source_cmd command)
+_zip_source_call(zip_source_t *src, void *data, zip_uint64_t length, zip_source_cmd_t command)
 {
     zip_int64_t ret;
 
diff --git a/lib/zip_source_close.c b/lib/zip_source_close.c
index cbc69c4..b5d443b 100644
--- a/lib/zip_source_close.c
+++ b/lib/zip_source_close.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_close(struct zip_source *src)
+zip_source_close(zip_source_t *src)
 {
     if (!ZIP_SOURCE_IS_OPEN_READING(src)) {
         zip_error_set(&src->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_source_commit_write.c b/lib/zip_source_commit_write.c
index 09fe3da..e8e4ddc 100644
--- a/lib/zip_source_commit_write.c
+++ b/lib/zip_source_commit_write.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_commit_write(struct zip_source *src)
+zip_source_commit_write(zip_source_t *src)
 {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src)) {
         zip_error_set(&src->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_source_crc.c b/lib/zip_source_crc.c
index 8e2edc2..eed7266 100644
--- a/lib/zip_source_crc.c
+++ b/lib/zip_source_crc.c
@@ -46,11 +46,11 @@
     zip_uint32_t crc;
 };
 
-static zip_int64_t crc_read(struct zip_source *, void *, void *, zip_uint64_t, enum zip_source_cmd);
+static zip_int64_t crc_read(zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t);
 
 
-struct zip_source *
-zip_source_crc(struct zip *za, struct zip_source *src, int validate)
+zip_source_t *
+zip_source_crc(zip_t *za, zip_source_t *src, int validate)
 {
     struct crc_context *ctx;
 
@@ -75,7 +75,7 @@
 
 
 static zip_int64_t
-crc_read(struct zip_source *src, void *_ctx, void *data, zip_uint64_t len, enum zip_source_cmd cmd)
+crc_read(zip_source_t *src, void *_ctx, void *data, zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct crc_context *ctx;
     zip_int64_t n;
@@ -136,9 +136,9 @@
 
         case ZIP_SOURCE_STAT:
         {
-            struct zip_stat *st;
+            zip_stat_t *st;
 
-	    st = (struct zip_stat *)data;
+	    st = (zip_stat_t *)data;
 
 	    if (ctx->eof) {
 		/* TODO: Set comp_size, comp_method, encryption_method?
diff --git a/lib/zip_source_deflate.c b/lib/zip_source_deflate.c
index 42d0155..bebdd9d 100644
--- a/lib/zip_source_deflate.c
+++ b/lib/zip_source_deflate.c
@@ -48,18 +48,18 @@
     z_stream zstr;
 };
 
-static zip_int64_t compress_read(struct zip_source *, struct deflate *, void *, zip_uint64_t);
-static zip_int64_t decompress_read(struct zip_source *, struct deflate *, void *, zip_uint64_t);
-static zip_int64_t deflate_compress(struct zip_source *, void *, void *, zip_uint64_t, enum zip_source_cmd);
-static zip_int64_t deflate_decompress(struct zip_source *, void *, void *, zip_uint64_t, enum zip_source_cmd);
+static zip_int64_t compress_read(zip_source_t *, struct deflate *, void *, zip_uint64_t);
+static zip_int64_t decompress_read(zip_source_t *, struct deflate *, void *, zip_uint64_t);
+static zip_int64_t deflate_compress(zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t);
+static zip_int64_t deflate_decompress(zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t);
 static void deflate_free(struct deflate *);
 
 
-struct zip_source *
-zip_source_deflate(struct zip *za, struct zip_source *src, zip_int32_t cm, int flags)
+zip_source_t *
+zip_source_deflate(zip_t *za, zip_source_t *src, zip_int32_t cm, int flags)
 {
     struct deflate *ctx;
-    struct zip_source *s2;
+    zip_source_t *s2;
 
     if (src == NULL || (cm != ZIP_CM_DEFLATE && !ZIP_CM_IS_DEFAULT(cm))) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -93,7 +93,7 @@
 
 
 static zip_int64_t
-compress_read(struct zip_source *src, struct deflate *ctx, void *data, zip_uint64_t len)
+compress_read(zip_source_t *src, struct deflate *ctx, void *data, zip_uint64_t len)
 {
     int end, ret;
     zip_int64_t n;
@@ -178,7 +178,7 @@
 
 
 static zip_int64_t
-decompress_read(struct zip_source *src, struct deflate *ctx, void *data, zip_uint64_t len)
+decompress_read(zip_source_t *src, struct deflate *ctx, void *data, zip_uint64_t len)
 {
     int end, ret;
     zip_int64_t n;
@@ -259,7 +259,7 @@
 
 
 static zip_int64_t
-deflate_compress(struct zip_source *src, void *ud, void *data, zip_uint64_t len, enum zip_source_cmd cmd)
+deflate_compress(zip_source_t *src, void *ud, void *data, zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct deflate *ctx;
     int ret;
@@ -293,9 +293,9 @@
 
     case ZIP_SOURCE_STAT:
     	{
-	    struct zip_stat *st;
+	    zip_stat_t *st;
 
-	    st = (struct zip_stat *)data;
+	    st = (zip_stat_t *)data;
 
 	    st->comp_method = ZIP_CM_DEFLATE;
 	    st->valid |= ZIP_STAT_COMP_METHOD;
@@ -323,8 +323,8 @@
 
 
 static zip_int64_t
-deflate_decompress(struct zip_source *src, void *ud, void *data,
-		   zip_uint64_t len, enum zip_source_cmd cmd)
+deflate_decompress(zip_source_t *src, void *ud, void *data,
+		   zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct deflate *ctx;
     zip_int64_t n;
@@ -361,9 +361,9 @@
 
         case ZIP_SOURCE_STAT:
         {
-            struct zip_stat *st;
+            zip_stat_t *st;
             
-            st = (struct zip_stat *)data;
+            st = (zip_stat_t *)data;
             
             st->comp_method = ZIP_CM_STORE;
             if (st->comp_size > 0 && st->size > 0)
diff --git a/lib/zip_source_error.c b/lib/zip_source_error.c
index 401a32e..e09199b 100644
--- a/lib/zip_source_error.c
+++ b/lib/zip_source_error.c
@@ -35,8 +35,8 @@
 #include "zipint.h"
 
 
-struct zip_error *
-zip_source_error(struct zip_source *src)
+zip_error_t *
+zip_source_error(zip_source_t *src)
 {
     return &src->error;
 }
diff --git a/lib/zip_source_file.c b/lib/zip_source_file.c
index 0fddfbd..cefc2b4 100644
--- a/lib/zip_source_file.c
+++ b/lib/zip_source_file.c
@@ -38,8 +38,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_source *
-zip_source_file(struct zip *za, const char *fname, zip_uint64_t start, zip_int64_t len)
+ZIP_EXTERN zip_source_t *
+zip_source_file(zip_t *za, const char *fname, zip_uint64_t start, zip_int64_t len)
 {
     if (za == NULL)
 	return NULL;
diff --git a/lib/zip_source_filep.c b/lib/zip_source_filep.c
index 9fabf81..6a613f1 100644
--- a/lib/zip_source_filep.c
+++ b/lib/zip_source_filep.c
@@ -58,12 +58,12 @@
     FILE *fout;
 };
 
-static zip_int64_t read_file(void *state, void *data, zip_uint64_t len, enum zip_source_cmd cmd);
+static zip_int64_t read_file(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd);
 static int create_temp_output(struct read_file *ctx);
 
 
-ZIP_EXTERN struct zip_source *
-zip_source_filep(struct zip *za, FILE *file, zip_uint64_t start, zip_int64_t len)
+ZIP_EXTERN zip_source_t *
+zip_source_filep(zip_t *za, FILE *file, zip_uint64_t start, zip_int64_t len)
 {
     if (za == NULL)
 	return NULL;
@@ -84,11 +84,11 @@
 }
 
 
-struct zip_source *
+zip_source_t *
 _zip_source_file_or_p(const char *fname, FILE *file, zip_uint64_t start, zip_int64_t len, int closep, const zip_stat_t *st, zip_error_t *error)
 {
     struct read_file *ctx;
-    struct zip_source *zs;
+    zip_source_t *zs;
     
     if (file == NULL && fname == NULL) {
 	zip_error_set(error, ZIP_ER_INVAL, 0);
@@ -387,7 +387,7 @@
 	    if (ctx->st.valid != 0)
 		memcpy(data, &ctx->st, sizeof(ctx->st));
 	    else {
-		struct zip_stat *st;
+		zip_stat_t *st;
 		struct stat fst;
 		int err;
 	    
@@ -401,7 +401,7 @@
 		    return -1;
 		}
 
-		st = (struct zip_stat *)data;
+		st = (zip_stat_t *)data;
 		
 		zip_stat_init(st);
 		st->mtime = fst.st_mtime;
diff --git a/lib/zip_source_function.c b/lib/zip_source_function.c
index 884d5ad..d7e598c 100644
--- a/lib/zip_source_function.c
+++ b/lib/zip_source_function.c
@@ -37,8 +37,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_source *
-zip_source_function(struct zip *za, zip_source_callback zcb, void *ud)
+ZIP_EXTERN zip_source_t *
+zip_source_function(zip_t *za, zip_source_callback zcb, void *ud)
 {
     if (za == NULL) {
         return NULL;
@@ -51,7 +51,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_function_create(zip_source_callback zcb, void *ud, zip_error_t *error)
 {
-    struct zip_source *zs;
+    zip_source_t *zs;
 
     if ((zs=_zip_source_new(error)) == NULL)
 	return NULL;
@@ -70,12 +70,12 @@
 }
 
 
-struct zip_source *
+zip_source_t *
 _zip_source_new(zip_error_t *error)
 {
-    struct zip_source *src;
+    zip_source_t *src;
 
-    if ((src=(struct zip_source *)malloc(sizeof(*src))) == NULL) {
+    if ((src=(zip_source_t *)malloc(sizeof(*src))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
 	return NULL;
     }
diff --git a/lib/zip_source_layered.c b/lib/zip_source_layered.c
index 3cf1f71..1f58148 100644
--- a/lib/zip_source_layered.c
+++ b/lib/zip_source_layered.c
@@ -37,8 +37,8 @@
 #include "zipint.h"
 
 
-struct zip_source *
-zip_source_layered(struct zip *za, struct zip_source *src, zip_source_layered_callback cb, void *ud)
+zip_source_t *
+zip_source_layered(zip_t *za, zip_source_t *src, zip_source_layered_callback cb, void *ud)
 {
     if (za == NULL)
         return NULL;
@@ -48,9 +48,9 @@
 
 
 zip_source_t *
-zip_source_layered_create(struct zip_source *src, zip_source_layered_callback cb, void *ud, zip_error_t *error)
+zip_source_layered_create(zip_source_t *src, zip_source_layered_callback cb, void *ud, zip_error_t *error)
 {
-    struct zip_source *zs;
+    zip_source_t *zs;
     
     if ((zs=_zip_source_new(error)) == NULL)
         return NULL;
diff --git a/lib/zip_source_open.c b/lib/zip_source_open.c
index 1fb3c33..31f22bc 100644
--- a/lib/zip_source_open.c
+++ b/lib/zip_source_open.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_open(struct zip_source *src)
+zip_source_open(zip_source_t *src)
 {
     if (src->source_closed) {
         return -1;
diff --git a/lib/zip_source_pkware.c b/lib/zip_source_pkware.c
index 21a826e..ce281ac 100644
--- a/lib/zip_source_pkware.c
+++ b/lib/zip_source_pkware.c
@@ -50,18 +50,18 @@
 
 static void decrypt(struct trad_pkware *, zip_uint8_t *,
 		    const zip_uint8_t *, zip_uint64_t, int);
-static int decrypt_header(struct zip_source *, struct trad_pkware *);
-static zip_int64_t pkware_decrypt(struct zip_source *, void *, void *,
-				  zip_uint64_t, enum zip_source_cmd);
+static int decrypt_header(zip_source_t *, struct trad_pkware *);
+static zip_int64_t pkware_decrypt(zip_source_t *, void *, void *,
+				  zip_uint64_t, zip_source_cmd_t);
 static void pkware_free(struct trad_pkware *);
 
 
-struct zip_source *
-zip_source_pkware(struct zip *za, struct zip_source *src,
+zip_source_t *
+zip_source_pkware(zip_t *za, zip_source_t *src,
 		  zip_uint16_t em, int flags, const char *password)
 {
     struct trad_pkware *ctx;
-    struct zip_source *s2;
+    zip_source_t *s2;
 
     if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {
 	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
@@ -125,7 +125,7 @@
 
 
 static int
-decrypt_header(struct zip_source *src, struct trad_pkware *ctx)
+decrypt_header(zip_source_t *src, struct trad_pkware *ctx)
 {
     zip_uint8_t header[HEADERLEN];
     struct zip_stat st;
@@ -161,8 +161,8 @@
 
 
 static zip_int64_t
-pkware_decrypt(struct zip_source *src, void *ud, void *data,
-	       zip_uint64_t len, enum zip_source_cmd cmd)
+pkware_decrypt(zip_source_t *src, void *ud, void *data,
+	       zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct trad_pkware *ctx;
     zip_int64_t n;
@@ -189,9 +189,9 @@
 
         case ZIP_SOURCE_STAT:
         {
-	    struct zip_stat *st;
+	    zip_stat_t *st;
 
-	    st = (struct zip_stat *)data;
+	    st = (zip_stat_t *)data;
 
 	    st->encryption_method = ZIP_EM_NONE;
 	    st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
diff --git a/lib/zip_source_pop.c b/lib/zip_source_pop.c
index 78c7ce1..ec73954 100644
--- a/lib/zip_source_pop.c
+++ b/lib/zip_source_pop.c
@@ -37,10 +37,10 @@
 #include "zipint.h"
 
 
-struct zip_source *
-zip_source_pop(struct zip_source *src)
+zip_source_t *
+zip_source_pop(zip_source_t *src)
 {
-    struct zip_source *lower;
+    zip_source_t *lower;
 
     if (src == NULL)
 	return NULL;
diff --git a/lib/zip_source_read.c b/lib/zip_source_read.c
index 8249b82..061a6f9 100644
--- a/lib/zip_source_read.c
+++ b/lib/zip_source_read.c
@@ -36,7 +36,7 @@
 
 
 zip_int64_t
-zip_source_read(struct zip_source *src, void *data, zip_uint64_t len)
+zip_source_read(zip_source_t *src, void *data, zip_uint64_t len)
 {
     if (src->source_closed) {
         return -1;
diff --git a/lib/zip_source_seek.c b/lib/zip_source_seek.c
index 25886f7..24fc05c 100644
--- a/lib/zip_source_seek.c
+++ b/lib/zip_source_seek.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_seek(struct zip_source *src, zip_int64_t offset, int whence)
+zip_source_seek(zip_source_t *src, zip_int64_t offset, int whence)
 {
     zip_source_args_seek_t args;
     
diff --git a/lib/zip_source_seek_write.c b/lib/zip_source_seek_write.c
index 6f4e351..cd4c938 100644
--- a/lib/zip_source_seek_write.c
+++ b/lib/zip_source_seek_write.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_seek_write(struct zip_source *src, zip_int64_t offset, int whence)
+zip_source_seek_write(zip_source_t *src, zip_int64_t offset, int whence)
 {
     zip_source_args_seek_t args;
         
diff --git a/lib/zip_source_stat.c b/lib/zip_source_stat.c
index 5a53fa4..c946993 100644
--- a/lib/zip_source_stat.c
+++ b/lib/zip_source_stat.c
@@ -36,7 +36,7 @@
 
 
 int
-zip_source_stat(struct zip_source *src, struct zip_stat *st)
+zip_source_stat(zip_source_t *src, zip_stat_t *st)
 {
     if (src->source_closed) {
         return -1;
diff --git a/lib/zip_source_supports.c b/lib/zip_source_supports.c
index 6f8d26c..13f4caf 100644
--- a/lib/zip_source_supports.c
+++ b/lib/zip_source_supports.c
@@ -38,7 +38,7 @@
 
 
 zip_int64_t
-zip_source_supports(struct zip_source *src)
+zip_source_supports(zip_source_t *src)
 {
     zip_int64_t ret;
     
@@ -53,7 +53,7 @@
 
 
 zip_int64_t
-zip_source_make_command_bitmap(enum zip_source_cmd cmd0, ...)
+zip_source_make_command_bitmap(zip_source_cmd_t cmd0, ...)
 {
     zip_int64_t bitmap;
     va_list ap;
diff --git a/lib/zip_source_tell.c b/lib/zip_source_tell.c
index fdf2e77..cbbfdfa 100644
--- a/lib/zip_source_tell.c
+++ b/lib/zip_source_tell.c
@@ -36,7 +36,7 @@
 
 
 zip_int64_t
-zip_source_tell(struct zip_source *src)
+zip_source_tell(zip_source_t *src)
 {
     if (src->source_closed) {
         return -1;
diff --git a/lib/zip_source_tell_write.c b/lib/zip_source_tell_write.c
index 558fa0d..18c0855 100644
--- a/lib/zip_source_tell_write.c
+++ b/lib/zip_source_tell_write.c
@@ -36,7 +36,7 @@
 
 
 zip_int64_t
-zip_source_tell_write(struct zip_source *src)
+zip_source_tell_write(zip_source_t *src)
 {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src)) {
         zip_error_set(&src->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_source_window.c b/lib/zip_source_window.c
index e23a7ca..ef9c099 100644
--- a/lib/zip_source_window.c
+++ b/lib/zip_source_window.c
@@ -47,11 +47,11 @@
     int needs_seek;
 };
 
-static zip_int64_t window_read(struct zip_source *, void *, void *, zip_uint64_t, enum zip_source_cmd);
+static zip_int64_t window_read(zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t);
 
 
-struct zip_source *
-zip_source_window(struct zip *za, struct zip_source *src, zip_uint64_t start, zip_uint64_t len)
+zip_source_t *
+zip_source_window(zip_t *za, zip_source_t *src, zip_uint64_t start, zip_uint64_t len)
 {
     return _zip_source_window_new(src, start, len, NULL, &za->error);
 }
@@ -91,7 +91,7 @@
 
 
 int
-_zip_source_set_source_archive(struct zip_source *src, struct zip *za)
+_zip_source_set_source_archive(zip_source_t *src, zip_t *za)
 {
     src->source_archive = za;
     return _zip_register_source(za, src);
@@ -100,7 +100,7 @@
 
 /* called by zip_discard to avoid operating on file from closed archive */
 void
-_zip_source_invalidate(struct zip_source *src)
+_zip_source_invalidate(zip_source_t *src)
 {
     src->source_closed = 1;
 
@@ -111,7 +111,7 @@
 
 
 static zip_int64_t
-window_read(struct zip_source *src, void *_ctx, void *data, zip_uint64_t len, enum zip_source_cmd cmd)
+window_read(zip_source_t *src, void *_ctx, void *data, zip_uint64_t len, zip_source_cmd_t cmd)
 {
     struct window *ctx;
     zip_int64_t ret;
@@ -215,9 +215,9 @@
 
        case ZIP_SOURCE_STAT:
         {
-            struct zip_stat *st;
+            zip_stat_t *st;
             
-	    st = (struct zip_stat *)data;
+	    st = (zip_stat_t *)data;
             
             if (_zip_stat_merge(st, &ctx->stat, &ctx->error) < 0) {
                 return -1;
@@ -239,7 +239,7 @@
 
 
 void
-_zip_deregister_source(struct zip *za, zip_source_t *src)
+_zip_deregister_source(zip_t *za, zip_source_t *src)
 {
     unsigned int i;
     
@@ -261,7 +261,7 @@
     if (za->nopen_source+1 >= za->nopen_source_alloc) {
         unsigned int n;
         n = za->nopen_source_alloc + 10;
-        open_source = (struct zip_source **)realloc(za->open_source, n*sizeof(struct zip_source *));
+        open_source = (zip_source_t **)realloc(za->open_source, n*sizeof(zip_source_t *));
         if (open_source == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             return -1;
diff --git a/lib/zip_source_write.c b/lib/zip_source_write.c
index bbf5d0b..541a936 100644
--- a/lib/zip_source_write.c
+++ b/lib/zip_source_write.c
@@ -36,7 +36,7 @@
 
 
 zip_int64_t
-zip_source_write(struct zip_source *src, const void *data, zip_uint64_t length)
+zip_source_write(zip_source_t *src, const void *data, zip_uint64_t length)
 {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src) || length > ZIP_INT64_MAX) {
         zip_error_set(&src->error, ZIP_ER_INVAL, 0);
diff --git a/lib/zip_source_zip.c b/lib/zip_source_zip.c
index 8f85200..e172ca2 100644
--- a/lib/zip_source_zip.c
+++ b/lib/zip_source_zip.c
@@ -38,8 +38,8 @@
 #include "zipint.h"
 
 
-ZIP_EXTERN struct zip_source *
-zip_source_zip(struct zip *za, struct zip *srcza, zip_uint64_t srcidx,
+ZIP_EXTERN zip_source_t *
+zip_source_zip(zip_t *za, zip_t *srcza, zip_uint64_t srcidx,
 	       zip_flags_t flags, zip_uint64_t start, zip_int64_t len)
 {
     if (len < -1) {
diff --git a/lib/zip_source_zip_new.c b/lib/zip_source_zip_new.c
index f8af9ad..6638a78 100644
--- a/lib/zip_source_zip_new.c
+++ b/lib/zip_source_zip_new.c
@@ -37,13 +37,13 @@
 #include "zipint.h"
 
 
-struct zip_source *
-_zip_source_zip_new(struct zip *za, struct zip *srcza, zip_uint64_t srcidx, zip_flags_t flags,
+zip_source_t *
+_zip_source_zip_new(zip_t *za, zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags,
 		    zip_uint64_t start, zip_uint64_t len, const char *password)
 {
     zip_compression_implementation comp_impl;
     zip_encryption_implementation enc_impl;
-    struct zip_source *src, *s2;
+    zip_source_t *src, *s2;
     zip_uint64_t offset;
     struct zip_stat st;
 
diff --git a/lib/zip_stat.c b/lib/zip_stat.c
index b87182b..cf8e566 100644
--- a/lib/zip_stat.c
+++ b/lib/zip_stat.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN int
-zip_stat(struct zip *za, const char *fname, zip_flags_t flags, struct zip_stat *st)
+zip_stat(zip_t *za, const char *fname, zip_flags_t flags, zip_stat_t *st)
 {
     zip_int64_t idx;
 
diff --git a/lib/zip_stat_index.c b/lib/zip_stat_index.c
index a58345b..601e3f7 100644
--- a/lib/zip_stat_index.c
+++ b/lib/zip_stat_index.c
@@ -36,11 +36,11 @@
 
 
 ZIP_EXTERN int
-zip_stat_index(struct zip *za, zip_uint64_t index, zip_flags_t flags,
-	       struct zip_stat *st)
+zip_stat_index(zip_t *za, zip_uint64_t index, zip_flags_t flags,
+	       zip_stat_t *st)
 {
     const char *name;
-    struct zip_dirent *de;
+    zip_dirent_t *de;
 
     if ((de=_zip_get_dirent(za, index, flags, NULL)) == NULL)
 	return -1;
diff --git a/lib/zip_stat_init.c b/lib/zip_stat_init.c
index 0a8bf5a..6b7d633 100644
--- a/lib/zip_stat_init.c
+++ b/lib/zip_stat_init.c
@@ -37,7 +37,7 @@
 
 
 ZIP_EXTERN void
-zip_stat_init(struct zip_stat *st)
+zip_stat_init(zip_stat_t *st)
 {
     st->valid = 0;
     st->name = NULL;
diff --git a/lib/zip_strerror.c b/lib/zip_strerror.c
index 548c021..98c4f6b 100644
--- a/lib/zip_strerror.c
+++ b/lib/zip_strerror.c
@@ -36,7 +36,7 @@
 
 
 ZIP_EXTERN const char *
-zip_strerror(struct zip *za)
+zip_strerror(zip_t *za)
 {
     return zip_error_strerror(&za->error);
 }
diff --git a/lib/zip_string.c b/lib/zip_string.c
index d00e3aa..307a425 100644
--- a/lib/zip_string.c
+++ b/lib/zip_string.c
@@ -39,7 +39,7 @@
 
 
 zip_uint32_t
-_zip_string_crc32(const struct zip_string *s)
+_zip_string_crc32(const zip_string_t *s)
 {
     zip_uint32_t crc;
     
@@ -53,7 +53,7 @@
 
 
 int
-_zip_string_equal(const struct zip_string *a, const struct zip_string *b)
+_zip_string_equal(const zip_string_t *a, const zip_string_t *b)
 {
     if (a == NULL || b == NULL)
 	return a == b;
@@ -68,7 +68,7 @@
 
 
 void
-_zip_string_free(struct zip_string *s)
+_zip_string_free(zip_string_t *s)
 {
     if (s == NULL)
 	return;
@@ -80,7 +80,7 @@
 
 
 const zip_uint8_t *
-_zip_string_get(struct zip_string *string, zip_uint32_t *lenp, zip_flags_t flags, struct zip_error *error)
+_zip_string_get(zip_string_t *string, zip_uint32_t *lenp, zip_flags_t flags, zip_error_t *error)
 {
     static const zip_uint8_t empty[1] = "";
 
@@ -116,7 +116,7 @@
 
 
 zip_uint16_t
-_zip_string_length(const struct zip_string *s)
+_zip_string_length(const zip_string_t *s)
 {
     if (s == NULL)
 	return 0;
@@ -125,11 +125,11 @@
 }
 
 
-struct zip_string *
-_zip_string_new(const zip_uint8_t *raw, zip_uint16_t length, zip_flags_t flags, struct zip_error *error)
+zip_string_t *
+_zip_string_new(const zip_uint8_t *raw, zip_uint16_t length, zip_flags_t flags, zip_error_t *error)
 {
-    struct zip_string *s;
-    enum zip_encoding_type expected_encoding;
+    zip_string_t *s;
+    zip_encoding_type_t expected_encoding;
     
     if (length == 0)
 	return NULL;
@@ -149,7 +149,7 @@
 	return NULL;
     }
 	
-    if ((s=(struct zip_string *)malloc(sizeof(*s))) == NULL) {
+    if ((s=(zip_string_t *)malloc(sizeof(*s))) == NULL) {
 	zip_error_set(error, ZIP_ER_MEMORY, 0);
 	return NULL;
     }
diff --git a/lib/zip_unchange.c b/lib/zip_unchange.c
index aa840d0..6c8a495 100644
--- a/lib/zip_unchange.c
+++ b/lib/zip_unchange.c
@@ -38,14 +38,14 @@
 
 
 ZIP_EXTERN int
-zip_unchange(struct zip *za, zip_uint64_t idx)
+zip_unchange(zip_t *za, zip_uint64_t idx)
 {
     return _zip_unchange(za, idx, 0);
 }
 
 
 int
-_zip_unchange(struct zip *za, zip_uint64_t idx, int allow_duplicates)
+_zip_unchange(zip_t *za, zip_uint64_t idx, int allow_duplicates)
 {
     zip_int64_t i;
     
diff --git a/lib/zip_unchange_all.c b/lib/zip_unchange_all.c
index c57cdf8..6007683 100644
--- a/lib/zip_unchange_all.c
+++ b/lib/zip_unchange_all.c
@@ -38,7 +38,7 @@
 
 
 ZIP_EXTERN int
-zip_unchange_all(struct zip *za)
+zip_unchange_all(zip_t *za)
 {
     int ret;
     zip_uint64_t i;
diff --git a/lib/zip_unchange_archive.c b/lib/zip_unchange_archive.c
index 291b826..920255c 100644
--- a/lib/zip_unchange_archive.c
+++ b/lib/zip_unchange_archive.c
@@ -38,7 +38,7 @@
 
 
 ZIP_EXTERN int
-zip_unchange_archive(struct zip *za)
+zip_unchange_archive(zip_t *za)
 {
     if (za->comment_changed) {
 	_zip_string_free(za->comment_changes);
diff --git a/lib/zip_unchange_data.c b/lib/zip_unchange_data.c
index a95a81c..839d9a3 100644
--- a/lib/zip_unchange_data.c
+++ b/lib/zip_unchange_data.c
@@ -35,7 +35,7 @@
 #include "zipint.h"
 
 void
-_zip_unchange_data(struct zip_entry *ze)
+_zip_unchange_data(zip_entry_t *ze)
 {
     if (ze->source) {
 	zip_source_free(ze->source);
diff --git a/lib/zip_utf-8.c b/lib/zip_utf-8.c
index 4321412..f38eea0 100644
--- a/lib/zip_utf-8.c
+++ b/lib/zip_utf-8.c
@@ -113,10 +113,10 @@
 #define UTF_8_CONTINUE_MATCH 0x80
 
 
-enum zip_encoding_type
-_zip_guess_encoding(struct zip_string *str, enum zip_encoding_type expected_encoding)
+zip_encoding_type_t
+_zip_guess_encoding(zip_string_t *str, zip_encoding_type_t expected_encoding)
 {
-    enum zip_encoding_type enc;
+    zip_encoding_type_t enc;
     const zip_uint8_t *name;
     zip_uint32_t i, j, ulen;
 
@@ -216,7 +216,7 @@
 
 zip_uint8_t *
 _zip_cp437_to_utf8(const zip_uint8_t * const _cp437buf, zip_uint32_t len,
-		   zip_uint32_t *utf8_lenp, struct zip_error *error)
+		   zip_uint32_t *utf8_lenp, zip_error_t *error)
 {
     zip_uint8_t *cp437buf = (zip_uint8_t *)_cp437buf;
     zip_uint8_t *utf8buf;
diff --git a/lib/zipint.h b/lib/zipint.h
index b157d62..1c89b9e 100644
--- a/lib/zipint.h
+++ b/lib/zipint.h
@@ -171,13 +171,8 @@
 /* This section contains API that won't materialize like this.  It's
    placed in the internal section, pending cleanup. */
 
-typedef zip_source_t *(*zip_compression_implementation)(struct zip *,
-						     zip_source_t *,
-						     zip_int32_t, int);
-typedef zip_source_t *(*zip_encryption_implementation)(struct zip *,
-						    zip_source_t *,
-						    zip_uint16_t, int,
-						    const char *);
+typedef zip_source_t *(*zip_compression_implementation)(zip_t *, zip_source_t *, zip_int32_t, int);
+typedef zip_source_t *(*zip_encryption_implementation)(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
 
 zip_compression_implementation _zip_get_compression_implementation(zip_int32_t);
 zip_encryption_implementation _zip_get_encryption_implementation(zip_uint16_t);
@@ -186,7 +181,7 @@
 
 /* This API is not final yet, but we need it internally, so it's private for now. */
 
-const zip_uint8_t *zip_get_extra_field_by_id(struct zip *, int, int, zip_uint16_t, int, zip_uint16_t *);
+const zip_uint8_t *zip_get_extra_field_by_id(zip_t *, int, int, zip_uint16_t, int, zip_uint16_t *);
 
 /* This section contains API that is of limited use until support for
    user-supplied compression/encryption implementation is finished.
@@ -195,11 +190,11 @@
 typedef zip_int64_t (*zip_source_layered_callback)(zip_source_t *, void *, void *, zip_uint64_t, enum zip_source_cmd);
 int zip_source_begin_write(zip_source_t *);
 int zip_source_commit_write(zip_source_t *);
-zip_source_t *zip_source_crc(struct zip *, zip_source_t *, int);
-zip_source_t *zip_source_deflate(struct zip *, zip_source_t *, zip_int32_t, int);
-zip_source_t *zip_source_layered(struct zip *, zip_source_t *, zip_source_layered_callback, void *);
+zip_source_t *zip_source_crc(zip_t *, zip_source_t *, int);
+zip_source_t *zip_source_deflate(zip_t *, zip_source_t *, zip_int32_t, int);
+zip_source_t *zip_source_layered(zip_t *, zip_source_t *, zip_source_layered_callback, void *);
 zip_source_t *zip_source_layered_create(zip_source_t *src, zip_source_layered_callback cb, void *ud, zip_error_t *error);
-zip_source_t *zip_source_pkware(struct zip *, zip_source_t *, zip_uint16_t, int, const char *);
+zip_source_t *zip_source_pkware(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
 int zip_source_remove(zip_source_t *);
 void zip_source_rollback_write(zip_source_t *);
 int zip_source_seek(zip_source_t *, zip_int64_t, int);
@@ -207,7 +202,7 @@
 zip_int64_t zip_source_supports(zip_source_t *src);
 zip_int64_t zip_source_tell(zip_source_t *);
 zip_int64_t zip_source_tell_write(zip_source_t *);
-zip_source_t *zip_source_window(struct zip *, zip_source_t *, zip_uint64_t, zip_uint64_t);
+zip_source_t *zip_source_window(zip_t *, zip_source_t *, zip_uint64_t, zip_uint64_t);
 zip_int64_t zip_source_write(zip_source_t *, const void *, zip_uint64_t);
 
 
@@ -417,109 +412,109 @@
 #define ZIP_IS_RDONLY(za)	((za)->ch_flags & ZIP_AFL_RDONLY)
 
 
-zip_int64_t _zip_add_entry(struct zip *);
+zip_int64_t _zip_add_entry(zip_t *);
 
-int _zip_cdir_compute_crc(struct zip *, uLong *);
-void _zip_cdir_free(struct zip_cdir *);
-int _zip_cdir_grow(struct zip_cdir *, zip_uint64_t, struct zip_error *);
-struct zip_cdir *_zip_cdir_new(zip_uint64_t, struct zip_error *);
-zip_int64_t _zip_cdir_write(struct zip *za, const struct zip_filelist *filelist, zip_uint64_t survivors);
+int _zip_cdir_compute_crc(zip_t *, uLong *);
+void _zip_cdir_free(zip_cdir_t *);
+int _zip_cdir_grow(zip_cdir_t *, zip_uint64_t, zip_error_t *);
+zip_cdir_t *_zip_cdir_new(zip_uint64_t, zip_error_t *);
+zip_int64_t _zip_cdir_write(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors);
 void _zip_deregister_source(zip_t *za, zip_source_t *src);
 
-struct zip_dirent *_zip_dirent_clone(const struct zip_dirent *);
-void _zip_dirent_free(struct zip_dirent *);
-void _zip_dirent_finalize(struct zip_dirent *);
-void _zip_dirent_init(struct zip_dirent *);
-int _zip_dirent_needs_zip64(const struct zip_dirent *, zip_flags_t);
-struct zip_dirent *_zip_dirent_new(void);
-int _zip_dirent_read(struct zip_dirent *zde, zip_source_t *src, 
+zip_dirent_t *_zip_dirent_clone(const zip_dirent_t *);
+void _zip_dirent_free(zip_dirent_t *);
+void _zip_dirent_finalize(zip_dirent_t *);
+void _zip_dirent_init(zip_dirent_t *);
+int _zip_dirent_needs_zip64(const zip_dirent_t *, zip_flags_t);
+zip_dirent_t *_zip_dirent_new(void);
+int _zip_dirent_read(zip_dirent_t *zde, zip_source_t *src, 
 		 const unsigned char **bufp, zip_uint64_t *leftp, int local,
 		 zip_error_t *error);
-zip_int32_t _zip_dirent_size(zip_source_t *src, zip_uint16_t, struct zip_error *);
-void _zip_dirent_torrent_normalize(struct zip_dirent *);
-int _zip_dirent_write(struct zip *za, struct zip_dirent *dirent, zip_flags_t flags);
+zip_int32_t _zip_dirent_size(zip_source_t *src, zip_uint16_t, zip_error_t *);
+void _zip_dirent_torrent_normalize(zip_dirent_t *);
+int _zip_dirent_write(zip_t *za, zip_dirent_t *dirent, zip_flags_t flags);
 
-struct zip_extra_field *_zip_ef_clone(const struct zip_extra_field *, struct zip_error *);
-struct zip_extra_field *_zip_ef_delete_by_id(struct zip_extra_field *, zip_uint16_t, zip_uint16_t, zip_flags_t);
-void _zip_ef_free(struct zip_extra_field *);
-const zip_uint8_t *_zip_ef_get_by_id(const struct zip_extra_field *, zip_uint16_t *, zip_uint16_t, zip_uint16_t, zip_flags_t, struct zip_error *);
-struct zip_extra_field *_zip_ef_merge(struct zip_extra_field *, struct zip_extra_field *);
-struct zip_extra_field *_zip_ef_new(zip_uint16_t, zip_uint16_t, const zip_uint8_t *, zip_flags_t);
-struct zip_extra_field *_zip_ef_parse(const zip_uint8_t *, zip_uint16_t, zip_flags_t, struct zip_error *);
-struct zip_extra_field *_zip_ef_remove_internal(struct zip_extra_field *);
-zip_uint16_t _zip_ef_size(const struct zip_extra_field *, zip_flags_t);
-int _zip_ef_write(struct zip *za, const struct zip_extra_field *ef, zip_flags_t flags);
+zip_extra_field_t *_zip_ef_clone(const zip_extra_field_t *, zip_error_t *);
+zip_extra_field_t *_zip_ef_delete_by_id(zip_extra_field_t *, zip_uint16_t, zip_uint16_t, zip_flags_t);
+void _zip_ef_free(zip_extra_field_t *);
+const zip_uint8_t *_zip_ef_get_by_id(const zip_extra_field_t *, zip_uint16_t *, zip_uint16_t, zip_uint16_t, zip_flags_t, zip_error_t *);
+zip_extra_field_t *_zip_ef_merge(zip_extra_field_t *, zip_extra_field_t *);
+zip_extra_field_t *_zip_ef_new(zip_uint16_t, zip_uint16_t, const zip_uint8_t *, zip_flags_t);
+zip_extra_field_t *_zip_ef_parse(const zip_uint8_t *, zip_uint16_t, zip_flags_t, zip_error_t *);
+zip_extra_field_t *_zip_ef_remove_internal(zip_extra_field_t *);
+zip_uint16_t _zip_ef_size(const zip_extra_field_t *, zip_flags_t);
+int _zip_ef_write(zip_t *za, const zip_extra_field_t *ef, zip_flags_t flags);
 
-void _zip_entry_finalize(struct zip_entry *);
-void _zip_entry_init(struct zip_entry *);
+void _zip_entry_finalize(zip_entry_t *);
+void _zip_entry_init(zip_entry_t *);
 
-void _zip_error_clear(struct zip_error *);
-void _zip_error_get(const struct zip_error *, int *, int *);
+void _zip_error_clear(zip_error_t *);
+void _zip_error_get(const zip_error_t *, int *, int *);
 
-void _zip_error_copy(zip_error_t *dst, const struct zip_error *src);
+void _zip_error_copy(zip_error_t *dst, const zip_error_t *src);
 void _zip_error_set_from_source(zip_error_t *, zip_source_t *);
 
-const zip_uint8_t *_zip_extract_extra_field_by_id(struct zip_error *, zip_uint16_t, int, const zip_uint8_t *, zip_uint16_t, zip_uint16_t *);
+const zip_uint8_t *_zip_extract_extra_field_by_id(zip_error_t *, zip_uint16_t, int, const zip_uint8_t *, zip_uint16_t, zip_uint16_t *);
 
-int _zip_file_extra_field_prepare_for_change(struct zip *, zip_uint64_t);
-int _zip_file_fillbuf(void *, size_t, struct zip_file *);
-zip_uint64_t _zip_file_get_offset(const struct zip *, zip_uint64_t, struct zip_error *);
+int _zip_file_extra_field_prepare_for_change(zip_t *, zip_uint64_t);
+int _zip_file_fillbuf(void *, size_t, zip_file_t *);
+zip_uint64_t _zip_file_get_offset(const zip_t *, zip_uint64_t, zip_error_t *);
 
-int _zip_filerange_crc(zip_source_t *src, zip_uint64_t offset, zip_uint64_t length, uLong *crcp, struct zip_error *error);
+int _zip_filerange_crc(zip_source_t *src, zip_uint64_t offset, zip_uint64_t length, uLong *crcp, zip_error_t *error);
 
-struct zip_dirent *_zip_get_dirent(struct zip *, zip_uint64_t, zip_flags_t, struct zip_error *);
+zip_dirent_t *_zip_get_dirent(zip_t *, zip_uint64_t, zip_flags_t, zip_error_t *);
 
-enum zip_encoding_type _zip_guess_encoding(struct zip_string *, enum zip_encoding_type);
-zip_uint8_t *_zip_cp437_to_utf8(const zip_uint8_t * const, zip_uint32_t, zip_uint32_t *, struct zip_error *);
+enum zip_encoding_type _zip_guess_encoding(zip_string_t *, enum zip_encoding_type);
+zip_uint8_t *_zip_cp437_to_utf8(const zip_uint8_t * const, zip_uint32_t, zip_uint32_t *, zip_error_t *);
 
-struct zip *_zip_open(zip_source_t *, unsigned int, struct zip_error *);
+zip_t *_zip_open(zip_source_t *, unsigned int, zip_error_t *);
 
 void _zip_put_16(zip_uint8_t **p, zip_uint16_t i);
 void _zip_put_32(zip_uint8_t **p, zip_uint32_t i);
 void _zip_put_64(zip_uint8_t **p, zip_uint64_t i);
 void _zip_put_data(zip_uint8_t **p, const char *s, size_t len);
 
-int _zip_read(zip_source_t *src, zip_uint8_t *data, zip_uint64_t length, struct zip_error *error);
-int _zip_read_at_offset(zip_source_t *src, zip_uint64_t offset, unsigned char *b, size_t length, struct zip_error *error);
-int _zip_read_local_ef(struct zip *, zip_uint64_t);
-struct zip_string *_zip_read_string(const zip_uint8_t **buf, zip_source_t *src, zip_uint16_t len, int nulp, struct zip_error *error);
+int _zip_read(zip_source_t *src, zip_uint8_t *data, zip_uint64_t length, zip_error_t *error);
+int _zip_read_at_offset(zip_source_t *src, zip_uint64_t offset, unsigned char *b, size_t length, zip_error_t *error);
+int _zip_read_local_ef(zip_t *, zip_uint64_t);
+zip_string_t *_zip_read_string(const zip_uint8_t **buf, zip_source_t *src, zip_uint16_t len, int nulp, zip_error_t *error);
 int _zip_register_source(zip_t *za, zip_source_t *src);
 
-void _zip_set_open_error(int *zep, const struct zip_error *err, int ze);
+void _zip_set_open_error(int *zep, const zip_error_t *err, int ze);
 
-zip_int64_t _zip_source_call(zip_source_t *src, void *data, zip_uint64_t length, enum zip_source_cmd command);
-zip_source_t *_zip_source_file_or_p(const char *, FILE *, zip_uint64_t, zip_int64_t, int, const struct zip_stat *, zip_error_t *error);
+zip_int64_t _zip_source_call(zip_source_t *src, void *data, zip_uint64_t length, zip_source_cmd_t command);
+zip_source_t *_zip_source_file_or_p(const char *, FILE *, zip_uint64_t, zip_int64_t, int, const zip_stat_t *, zip_error_t *error);
 void _zip_source_invalidate(zip_source_t *src);
 void _zip_source_free_or_pop(zip_source_t *src, int recurse);
 zip_source_t *_zip_source_new(zip_error_t *error);
-int _zip_source_set_source_archive(zip_source_t *, struct zip *);
+int _zip_source_set_source_archive(zip_source_t *, zip_t *);
 zip_source_t *_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_uint64_t length, zip_stat_t *st, zip_error_t *error);
-zip_source_t *_zip_source_zip_new(struct zip *, struct zip *, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_uint64_t, const char *);
+zip_source_t *_zip_source_zip_new(zip_t *, zip_t *, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_uint64_t, const char *);
 
 int _zip_stat_merge(zip_stat_t *dst, const zip_stat_t *src, zip_error_t *error);
-int _zip_string_equal(const struct zip_string *, const struct zip_string *);
-void _zip_string_free(struct zip_string *);
-zip_uint32_t _zip_string_crc32(const struct zip_string *);
-const zip_uint8_t *_zip_string_get(struct zip_string *, zip_uint32_t *, zip_flags_t, struct zip_error *);
-zip_uint16_t _zip_string_length(const struct zip_string *);
-struct zip_string *_zip_string_new(const zip_uint8_t *, zip_uint16_t, zip_flags_t, struct zip_error *);
-int _zip_string_write(struct zip *za, const struct zip_string *string);
+int _zip_string_equal(const zip_string_t *, const zip_string_t *);
+void _zip_string_free(zip_string_t *);
+zip_uint32_t _zip_string_crc32(const zip_string_t *);
+const zip_uint8_t *_zip_string_get(zip_string_t *, zip_uint32_t *, zip_flags_t, zip_error_t *);
+zip_uint16_t _zip_string_length(const zip_string_t *);
+zip_string_t *_zip_string_new(const zip_uint8_t *, zip_uint16_t, zip_flags_t, zip_error_t *);
+int _zip_string_write(zip_t *za, const zip_string_t *string);
 
-int _zip_changed(const struct zip *, zip_uint64_t *);
-const char *_zip_get_name(struct zip *, zip_uint64_t, zip_flags_t, struct zip_error *);
-int _zip_local_header_read(struct zip *, int);
-void *_zip_memdup(const void *, size_t, struct zip_error *);
-zip_int64_t _zip_name_locate(struct zip *, const char *, zip_flags_t, struct zip_error *);
-struct zip *_zip_new(struct zip_error *);
+int _zip_changed(const zip_t *, zip_uint64_t *);
+const char *_zip_get_name(zip_t *, zip_uint64_t, zip_flags_t, zip_error_t *);
+int _zip_local_header_read(zip_t *, int);
+void *_zip_memdup(const void *, size_t, zip_error_t *);
+zip_int64_t _zip_name_locate(zip_t *, const char *, zip_flags_t, zip_error_t *);
+zip_t *_zip_new(zip_error_t *);
 zip_uint16_t _zip_get_16(const zip_uint8_t **);
 zip_uint32_t _zip_get_32(const zip_uint8_t **);
 zip_uint64_t _zip_get_64(const zip_uint8_t **);
-zip_uint8_t *_zip_read_data(const zip_uint8_t **bufferp, zip_source_t *src, size_t length, int nulp, struct zip_error *error);
-zip_int64_t _zip_file_replace(struct zip *, zip_uint64_t, const char *, zip_source_t *, zip_flags_t);
-int _zip_set_name(struct zip *, zip_uint64_t, const char *, zip_flags_t);
+zip_uint8_t *_zip_read_data(const zip_uint8_t **bufferp, zip_source_t *src, size_t length, int nulp, zip_error_t *error);
+zip_int64_t _zip_file_replace(zip_t *, zip_uint64_t, const char *, zip_source_t *, zip_flags_t);
+int _zip_set_name(zip_t *, zip_uint64_t, const char *, zip_flags_t);
 void _zip_u2d_time(time_t, zip_uint16_t *, zip_uint16_t *);
-int _zip_unchange(struct zip *, zip_uint64_t, int);
-void _zip_unchange_data(struct zip_entry *);
-int _zip_write(struct zip *za, const void *data, zip_uint64_t length);
+int _zip_unchange(zip_t *, zip_uint64_t, int);
+void _zip_unchange_data(zip_entry_t *);
+int _zip_write(zip_t *za, const void *data, zip_uint64_t length);
 
 #endif /* zipint.h */