Le Roi est mort, vive le Roi!

The run-together words are dead! Long live the underscores!

The postscript inspired naming convention of using all run-together
words has served us well, but it is now time for more readable code.

In this commit I have also added the sed script, rename.sed, that I used
to convert the source. Use it on your patches and application code.

36 files changed, 2224 insertions, 2275 deletions

diff --git a/fitz/base_error.c b/fitz/base_error.c
index 7b21d691..a0efa290 100644
--- a/fitz/base_error.c
+++ b/fitz/base_error.c
@@ -1,159 +1,159 @@
 #include "fitz.h"
 
-enum { LINELEN = 160, LINECOUNT = 25 };
+enum { LINE_LEN = 160, LINE_COUNT = 25 };
 
-static char warnmessage[LINELEN] = "";
-static int warncount = 0;
+static char warn_message[LINE_LEN] = "";
+static int warn_count = 0;
 
-void fz_flushwarnings(void)
+void fz_flush_warnings(void)
 {
-	if (warncount > 1)
-		fprintf(stderr, "warning: ... repeated %d times ...\n", warncount);
-	warnmessage[0] = 0;
-	warncount = 0;
+	if (warn_count > 1)
+		fprintf(stderr, "warning: ... repeated %d times ...\n", warn_count);
+	warn_message[0] = 0;
+	warn_count = 0;
 }
 
 void fz_warn(char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINELEN];
+	char buf[LINE_LEN];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
 	va_end(ap);
 
-	if (!strcmp(buf, warnmessage))
+	if (!strcmp(buf, warn_message))
 	{
-		warncount++;
+		warn_count++;
 	}
 	else
 	{
-		fz_flushwarnings();
+		fz_flush_warnings();
 		fprintf(stderr, "warning: %s\n", buf);
-		fz_strlcpy(warnmessage, buf, sizeof warnmessage);
-		warncount = 1;
+		fz_strlcpy(warn_message, buf, sizeof warn_message);
+		warn_count = 1;
 	}
 }
 
-static char errormessage[LINECOUNT][LINELEN];
-static int errorcount = 0;
+static char error_message[LINE_COUNT][LINE_LEN];
+static int error_count = 0;
 
 static void
-fz_emiterror(char what, char *location, char *message)
+fz_emit_error(char what, char *location, char *message)
 {
-	fz_flushwarnings();
+	fz_flush_warnings();
 
 	fprintf(stderr, "%c %s%s\n", what, location, message);
 
-	if (errorcount < LINECOUNT)
+	if (error_count < LINE_COUNT)
 	{
-		fz_strlcpy(errormessage[errorcount], location, LINELEN);
-		fz_strlcat(errormessage[errorcount], message, LINELEN);
-		errorcount++;
+		fz_strlcpy(error_message[error_count], location, LINE_LEN);
+		fz_strlcat(error_message[error_count], message, LINE_LEN);
+		error_count++;
 	}
 }
 
 int
-fz_geterrorcount(void)
+fz_get_error_count(void)
 {
-	return errorcount;
+	return error_count;
 }
 
 char *
-fz_geterrorline(int n)
+fz_get_error_line(int n)
 {
-	return errormessage[n];
+	return error_message[n];
 }
 
 fz_error
-fz_throwimp(const char *file, int line, const char *func, char *fmt, ...)
+fz_throw_imp(const char *file, int line, const char *func, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINELEN], two[LINELEN];
+	char one[LINE_LEN], two[LINE_LEN];
 
-	errorcount = 0;
+	error_count = 0;
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
 	vsnprintf(two, sizeof two, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('+', one, two);
+	fz_emit_error('+', one, two);
 
 	return -1;
 }
 
 fz_error
-fz_rethrowimp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
+fz_rethrow_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINELEN], two[LINELEN];
+	char one[LINE_LEN], two[LINE_LEN];
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
 	vsnprintf(two, sizeof two, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('|', one, two);
+	fz_emit_error('|', one, two);
 
 	return cause;
 }
 
 void
-fz_catchimp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
+fz_catch_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char one[LINELEN], two[LINELEN];
+	char one[LINE_LEN], two[LINE_LEN];
 
 	snprintf(one, sizeof one, "%s:%d: %s(): ", file, line, func);
 	va_start(ap, fmt);
 	vsnprintf(two, sizeof two, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('\\', one, two);
+	fz_emit_error('\\', one, two);
 }
 
 fz_error
-fz_throwimpx(char *fmt, ...)
+fz_throw_impx(char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINELEN];
+	char buf[LINE_LEN];
 
-	errorcount = 0;
+	error_count = 0;
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('+', "", buf);
+	fz_emit_error('+', "", buf);
 
 	return -1;
 }
 
 fz_error
-fz_rethrowimpx(fz_error cause, char *fmt, ...)
+fz_rethrow_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINELEN];
+	char buf[LINE_LEN];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('|', "", buf);
+	fz_emit_error('|', "", buf);
 
 	return cause;
 }
 
 void
-fz_catchimpx(fz_error cause, char *fmt, ...)
+fz_catch_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
-	char buf[LINELEN];
+	char buf[LINE_LEN];
 
 	va_start(ap, fmt);
 	vsnprintf(buf, sizeof buf, fmt, ap);
 	va_end(ap);
 
-	fz_emiterror('\\', "", buf);
+	fz_emit_error('\\', "", buf);
 }
diff --git a/fitz/base_geometry.c b/fitz/base_geometry.c
index 311221e0..bd333dfa 100644
--- a/fitz/base_geometry.c
+++ b/fitz/base_geometry.c
@@ -85,7 +85,7 @@ fz_translate(float tx, float ty)
 }
 
 fz_matrix
-fz_invertmatrix(fz_matrix src)
+fz_invert_matrix(fz_matrix src)
 {
 	fz_matrix dst;
 	float rdet = 1 / (src.a * src.d - src.b * src.c);
@@ -99,20 +99,20 @@ fz_invertmatrix(fz_matrix src)
 }
 
 int
-fz_isrectilinear(fz_matrix m)
+fz_is_rectilinear(fz_matrix m)
 {
 	return (fabsf(m.b) < FLT_EPSILON && fabsf(m.c) < FLT_EPSILON) ||
 		(fabsf(m.a) < FLT_EPSILON && fabsf(m.d) < FLT_EPSILON);
 }
 
 float
-fz_matrixexpansion(fz_matrix m)
+fz_matrix_expansion(fz_matrix m)
 {
 	return sqrtf(fabsf(m.a * m.d - m.b * m.c));
 }
 
 fz_point
-fz_transformpoint(fz_matrix m, fz_point p)
+fz_transform_point(fz_matrix m, fz_point p)
 {
 	fz_point t;
 	t.x = p.x * m.a + p.y * m.c + m.e;
@@ -121,7 +121,7 @@ fz_transformpoint(fz_matrix m, fz_point p)
 }
 
 fz_point
-fz_transformvector(fz_matrix m, fz_point p)
+fz_transform_vector(fz_matrix m, fz_point p)
 {
 	fz_point t;
 	t.x = p.x * m.a + p.y * m.c;
@@ -131,16 +131,16 @@ fz_transformvector(fz_matrix m, fz_point p)
 
 /* Rectangles and bounding boxes */
 
-const fz_rect fz_infiniterect = { 1, 1, -1, -1 };
-const fz_rect fz_emptyrect = { 0, 0, 0, 0 };
-const fz_rect fz_unitrect = { 0, 0, 1, 1 };
+const fz_rect fz_infinite_rect = { 1, 1, -1, -1 };
+const fz_rect fz_empty_rect = { 0, 0, 0, 0 };
+const fz_rect fz_unit_rect = { 0, 0, 1, 1 };
 
-const fz_bbox fz_infinitebbox = { 1, 1, -1, -1 };
-const fz_bbox fz_emptybbox = { 0, 0, 0, 0 };
-const fz_bbox fz_unitbbox = { 0, 0, 1, 1 };
+const fz_bbox fz_infinite_bbox = { 1, 1, -1, -1 };
+const fz_bbox fz_empty_bbox = { 0, 0, 0, 0 };
+const fz_bbox fz_unit_bbox = { 0, 0, 1, 1 };
 
 fz_bbox
-fz_roundrect(fz_rect f)
+fz_round_rect(fz_rect f)
 {
 	fz_bbox i;
 	i.x0 = floorf(f.x0 + 0.001f); /* adjust by 0.001 to compensate for precision errors */
@@ -151,28 +151,28 @@ fz_roundrect(fz_rect f)
 }
 
 fz_bbox
-fz_intersectbbox(fz_bbox a, fz_bbox b)
+fz_intersect_bbox(fz_bbox a, fz_bbox b)
 {
 	fz_bbox r;
-	if (fz_isinfiniterect(a)) return b;
-	if (fz_isinfiniterect(b)) return a;
-	if (fz_isemptyrect(a)) return fz_emptybbox;
-	if (fz_isemptyrect(b)) return fz_emptybbox;
+	if (fz_is_infinite_rect(a)) return b;
+	if (fz_is_infinite_rect(b)) return a;
+	if (fz_is_empty_rect(a)) return fz_empty_bbox;
+	if (fz_is_empty_rect(b)) return fz_empty_bbox;
 	r.x0 = MAX(a.x0, b.x0);
 	r.y0 = MAX(a.y0, b.y0);
 	r.x1 = MIN(a.x1, b.x1);
 	r.y1 = MIN(a.y1, b.y1);
-	return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_emptybbox : r;
+	return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_bbox : r;
 }
 
 fz_bbox
-fz_unionbbox(fz_bbox a, fz_bbox b)
+fz_union_bbox(fz_bbox a, fz_bbox b)
 {
 	fz_bbox r;
-	if (fz_isinfiniterect(a)) return a;
-	if (fz_isinfiniterect(b)) return b;
-	if (fz_isemptyrect(a)) return b;
-	if (fz_isemptyrect(b)) return a;
+	if (fz_is_infinite_rect(a)) return a;
+	if (fz_is_infinite_rect(b)) return b;
+	if (fz_is_empty_rect(a)) return b;
+	if (fz_is_empty_rect(b)) return a;
 	r.x0 = MIN(a.x0, b.x0);
 	r.y0 = MIN(a.y0, b.y0);
 	r.x1 = MAX(a.x1, b.x1);
@@ -181,21 +181,21 @@ fz_unionbbox(fz_bbox a, fz_bbox b)
 }
 
 fz_rect
-fz_transformrect(fz_matrix m, fz_rect r)
+fz_transform_rect(fz_matrix m, fz_rect r)
 {
 	fz_point s, t, u, v;
 
-	if (fz_isinfiniterect(r))
+	if (fz_is_infinite_rect(r))
 		return r;
 
 	s.x = r.x0; s.y = r.y0;
 	t.x = r.x0; t.y = r.y1;
 	u.x = r.x1; u.y = r.y1;
 	v.x = r.x1; v.y = r.y0;
-	s = fz_transformpoint(m, s);
-	t = fz_transformpoint(m, t);
-	u = fz_transformpoint(m, u);
-	v = fz_transformpoint(m, v);
+	s = fz_transform_point(m, s);
+	t = fz_transform_point(m, t);
+	u = fz_transform_point(m, u);
+	v = fz_transform_point(m, v);
 	r.x0 = MIN4(s.x, t.x, u.x, v.x);
 	r.y0 = MIN4(s.y, t.y, u.y, v.y);
 	r.x1 = MAX4(s.x, t.x, u.x, v.x);
@@ -204,21 +204,21 @@ fz_transformrect(fz_matrix m, fz_rect r)
 }
 
 fz_bbox
-fz_transformbbox(fz_matrix m, fz_bbox b)
+fz_transform_bbox(fz_matrix m, fz_bbox b)
 {
 	fz_point s, t, u, v;
 
-	if (fz_isinfinitebbox(b))
+	if (fz_is_infinite_bbox(b))
 		return b;
 
 	s.x = b.x0; s.y = b.y0;
 	t.x = b.x0; t.y = b.y1;
 	u.x = b.x1; u.y = b.y1;
 	v.x = b.x1; v.y = b.y0;
-	s = fz_transformpoint(m, s);
-	t = fz_transformpoint(m, t);
-	u = fz_transformpoint(m, u);
-	v = fz_transformpoint(m, v);
+	s = fz_transform_point(m, s);
+	t = fz_transform_point(m, t);
+	u = fz_transform_point(m, u);
+	v = fz_transform_point(m, v);
 	b.x0 = MIN4(s.x, t.x, u.x, v.x);
 	b.y0 = MIN4(s.y, t.y, u.y, v.y);
 	b.x1 = MAX4(s.x, t.x, u.x, v.x);
diff --git a/fitz/base_hash.c b/fitz/base_hash.c
index e2bf6b04..fcfc1f61 100644
--- a/fitz/base_hash.c
+++ b/fitz/base_hash.c
@@ -8,21 +8,21 @@ exhibiting bad behaviour if entries are inserted
 and removed frequently.
 */
 
-enum { MAXKEYLEN = 48 };
-typedef struct fz_hashentry_s fz_hashentry;
+enum { MAX_KEY_LEN = 48 };
+typedef struct fz_hash_entry_s fz_hash_entry;
 
-struct fz_hashentry_s
+struct fz_hash_entry_s
 {
-	unsigned char key[MAXKEYLEN];
+	unsigned char key[MAX_KEY_LEN];
 	void *val;
 };
 
-struct fz_hashtable_s
+struct fz_hash_table_s
 {
 	int keylen;
 	int size;
 	int load;
-	fz_hashentry *ents;
+	fz_hash_entry *ents;
 };
 
 static unsigned hash(unsigned char *s, int len)
@@ -41,59 +41,59 @@ static unsigned hash(unsigned char *s, int len)
 	return val;
 }
 
-fz_hashtable *
-fz_newhash(int initialsize, int keylen)
+fz_hash_table *
+fz_new_hash_table(int initialsize, int keylen)
 {
-	fz_hashtable *table;
+	fz_hash_table *table;
 
-	assert(keylen <= MAXKEYLEN);
+	assert(keylen <= MAX_KEY_LEN);
 
-	table = fz_malloc(sizeof(fz_hashtable));
+	table = fz_malloc(sizeof(fz_hash_table));
 	table->keylen = keylen;
 	table->size = initialsize;
 	table->load = 0;
-	table->ents = fz_calloc(table->size, sizeof(fz_hashentry));
-	memset(table->ents, 0, sizeof(fz_hashentry) * table->size);
+	table->ents = fz_calloc(table->size, sizeof(fz_hash_entry));
+	memset(table->ents, 0, sizeof(fz_hash_entry) * table->size);
 
 	return table;
 }
 
 void
-fz_emptyhash(fz_hashtable *table)
+fz_empty_hash(fz_hash_table *table)
 {
 	table->load = 0;
-	memset(table->ents, 0, sizeof(fz_hashentry) * table->size);
+	memset(table->ents, 0, sizeof(fz_hash_entry) * table->size);
 }
 
 int
-fz_hashlen(fz_hashtable *table)
+fz_hash_len(fz_hash_table *table)
 {
 	return table->size;
 }
 
 void *
-fz_hashgetkey(fz_hashtable *table, int idx)
+fz_hash_get_key(fz_hash_table *table, int idx)
 {
 	return table->ents[idx].key;
 }
 
 void *
-fz_hashgetval(fz_hashtable *table, int idx)
+fz_hash_get_val(fz_hash_table *table, int idx)
 {
 	return table->ents[idx].val;
 }
 
 void
-fz_freehash(fz_hashtable *table)
+fz_free_hash(fz_hash_table *table)
 {
 	fz_free(table->ents);
 	fz_free(table);
 }
 
 static void
-fz_resizehash(fz_hashtable *table, int newsize)
+fz_resize_hash(fz_hash_table *table, int newsize)
 {
-	fz_hashentry *oldents = table->ents;
+	fz_hash_entry *oldents = table->ents;
 	int oldsize = table->size;
 	int oldload = table->load;
 	int i;
@@ -104,8 +104,8 @@ fz_resizehash(fz_hashtable *table, int newsize)
 		return;
 	}
 
-	table->ents = fz_calloc(newsize, sizeof(fz_hashentry));
-	memset(table->ents, 0, sizeof(fz_hashentry) * newsize);
+	table->ents = fz_calloc(newsize, sizeof(fz_hash_entry));
+	memset(table->ents, 0, sizeof(fz_hash_entry) * newsize);
 	table->size = newsize;
 	table->load = 0;
 
@@ -113,7 +113,7 @@ fz_resizehash(fz_hashtable *table, int newsize)
 	{
 		if (oldents[i].val)
 		{
-			fz_hashinsert(table, oldents[i].key, oldents[i].val);
+			fz_hash_insert(table, oldents[i].key, oldents[i].val);
 		}
 	}
 
@@ -121,16 +121,16 @@ fz_resizehash(fz_hashtable *table, int newsize)
 }
 
 void *
-fz_hashfind(fz_hashtable *table, void *key)
+fz_hash_find(fz_hash_table *table, void *key)
 {
-	fz_hashentry *ents = table->ents;
+	fz_hash_entry *ents = table->ents;
 	unsigned size = table->size;
 	unsigned pos = hash(key, table->keylen) % size;
 
 	while (1)
 	{
 		if (!ents[pos].val)
-			return nil;
+			return NULL;
 
 		if (memcmp(key, ents[pos].key, table->keylen) == 0)
 			return ents[pos].val;
@@ -140,15 +140,15 @@ fz_hashfind(fz_hashtable *table, void *key)
 }
 
 void
-fz_hashinsert(fz_hashtable *table, void *key, void *val)
+fz_hash_insert(fz_hash_table *table, void *key, void *val)
 {
-	fz_hashentry *ents;
+	fz_hash_entry *ents;
 	unsigned size;
 	unsigned pos;
 
 	if (table->load > table->size * 8 / 10)
 	{
-		fz_resizehash(table, table->size * 2);
+		fz_resize_hash(table, table->size * 2);
 	}
 
 	ents = table->ents;
@@ -173,9 +173,9 @@ fz_hashinsert(fz_hashtable *table, void *key, void *val)
 }
 
 void
-fz_hashremove(fz_hashtable *table, void *key)
+fz_hash_remove(fz_hash_table *table, void *key)
 {
-	fz_hashentry *ents = table->ents;
+	fz_hash_entry *ents = table->ents;
 	unsigned size = table->size;
 	unsigned pos = hash(key, table->keylen) % size;
 	unsigned hole, look, code;
@@ -190,7 +190,7 @@ fz_hashremove(fz_hashtable *table, void *key)
 
 		if (memcmp(key, ents[pos].key, table->keylen) == 0)
 		{
-			ents[pos].val = nil;
+			ents[pos].val = NULL;
 
 			hole = pos;
 			look = (hole + 1) % size;
@@ -203,7 +203,7 @@ fz_hashremove(fz_hashtable *table, void *key)
 					(hole < look && look < code))
 				{
 					ents[hole] = ents[look];
-					ents[look].val = nil;
+					ents[look].val = NULL;
 					hole = look;
 				}
 
@@ -220,7 +220,7 @@ fz_hashremove(fz_hashtable *table, void *key)
 }
 
 void
-fz_debughash(fz_hashtable *table)
+fz_debug_hash(fz_hash_table *table)
 {
 	int i, k;
 
@@ -233,7 +233,7 @@ fz_debughash(fz_hashtable *table)
 		else
 		{
 			printf("table % 4d: key=", i);
-			for (k = 0; k < MAXKEYLEN; k++)
+			for (k = 0; k < MAX_KEY_LEN; k++)
 				printf("%02x", ((char*)table->ents[i].key)[k]);
 			printf(" val=$%p\n", table->ents[i].val);
 		}
diff --git a/fitz/base_memory.c b/fitz/base_memory.c
index caeee451..f1b668eb 100644
--- a/fitz/base_memory.c
+++ b/fitz/base_memory.c
@@ -53,7 +53,7 @@ fz_realloc(void *p, int count, int size)
 	}
 
 	np = realloc(p, count * size);
-	if (np == nil)
+	if (np == NULL)
 	{
 		fprintf(stderr, "fatal error: out of memory\n");
 		abort();
diff --git a/fitz/base_string.c b/fitz/base_string.c
index 30d544d5..72a7a556 100644
--- a/fitz/base_string.c
+++ b/fitz/base_string.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 
 int
-fz_isbigendian(void)
+fz_is_big_endian(void)
 {
 	static const int one = 1;
 	return *(char*)&one == 0;
@@ -11,8 +11,8 @@ char *
 fz_strsep(char **stringp, const char *delim)
 {
 	char *ret = *stringp;
-	if (ret == nil) return nil;
-	if ((*stringp = strpbrk(*stringp, delim)) != nil)
+	if (ret == NULL) return NULL;
+	if ((*stringp = strpbrk(*stringp, delim)) != NULL)
 		*((*stringp)++) = '\0';
 	return ret;
 }
diff --git a/fitz/crypt_arc4.c b/fitz/crypt_arc4.c
index 1db8a132..72871386 100644
--- a/fitz/crypt_arc4.c
+++ b/fitz/crypt_arc4.c
@@ -24,7 +24,7 @@
 #include "fitz.h"
 
 void
-fz_arc4init(fz_arc4 *arc4, const unsigned char *key, const unsigned keylen)
+fz_arc4_init(fz_arc4 *arc4, const unsigned char *key, const unsigned keylen)
 {
 	unsigned int t, u;
 	unsigned int keyindex;
@@ -62,7 +62,7 @@ fz_arc4init(fz_arc4 *arc4, const unsigned char *key, const unsigned keylen)
 }
 
 static unsigned char
-fz_arc4next(fz_arc4 *arc4)
+fz_arc4_next(fz_arc4 *arc4)
 {
 	unsigned int x;
 	unsigned int y;
@@ -86,13 +86,13 @@ fz_arc4next(fz_arc4 *arc4)
 }
 
 void
-fz_arc4encrypt(fz_arc4 *arc4, unsigned char *dest, const unsigned char *src, const unsigned len)
+fz_arc4_encrypt(fz_arc4 *arc4, unsigned char *dest, const unsigned char *src, const unsigned len)
 {
 	unsigned int i;
 	for (i = 0; i < len; i++)
 	{
 		unsigned char x;
-		x = fz_arc4next(arc4);
+		x = fz_arc4_next(arc4);
 		dest[i] = src[i] ^ x;
 	}
 }
diff --git a/fitz/crypt_md5.c b/fitz/crypt_md5.c
index 6e38f416..ba2571c4 100644
--- a/fitz/crypt_md5.c
+++ b/fitz/crypt_md5.c
@@ -196,7 +196,7 @@ static void transform(unsigned int state[4], const unsigned char block[64])
 }
 
 /* MD5 initialization. Begins an MD5 operation, writing a new context. */
-void fz_md5init(fz_md5 *context)
+void fz_md5_init(fz_md5 *context)
 {
 	context->count[0] = context->count[1] = 0;
 
@@ -210,7 +210,7 @@ void fz_md5init(fz_md5 *context)
 /* MD5 block update operation. Continues an MD5 message-digest operation,
  * processing another message block, and updating the context.
  */
-void fz_md5update(fz_md5 *context, const unsigned char *input, const unsigned inlen)
+void fz_md5_update(fz_md5 *context, const unsigned char *input, const unsigned inlen)
 {
 	unsigned i, index, partlen;
 
@@ -248,7 +248,7 @@ void fz_md5update(fz_md5 *context, const unsigned char *input, const unsigned in
 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
  * the message digest and zeroizing the context.
  */
-void fz_md5final(fz_md5 *context, unsigned char digest[16])
+void fz_md5_final(fz_md5 *context, unsigned char digest[16])
 {
 	unsigned char bits[8];
 	unsigned index, padlen;
@@ -259,10 +259,10 @@ void fz_md5final(fz_md5 *context, unsigned char digest[16])
 	/* Pad out to 56 mod 64 */
 	index = (unsigned)((context->count[0] >> 3) & 0x3f);
 	padlen = index < 56 ? 56 - index : 120 - index;
-	fz_md5update(context, padding, padlen);
+	fz_md5_update(context, padding, padlen);
 
 	/* Append length (before padding) */
-	fz_md5update(context, bits, 8);
+	fz_md5_update(context, bits, 8);
 
 	/* Store state in digest */
 	encode(digest, context->state, 16);
diff --git a/fitz/crypt_sha2.c b/fitz/crypt_sha2.c
index 6796c5ab..f17146c6 100644
--- a/fitz/crypt_sha2.c
+++ b/fitz/crypt_sha2.c
@@ -110,7 +110,7 @@ transform(unsigned int state[8], const unsigned int data_xe[16])
 	state[7] += h(0);
 }
 
-void fz_sha256init(fz_sha256 *context)
+void fz_sha256_init(fz_sha256 *context)
 {
 	context->count[0] = context->count[1] = 0;
 
@@ -124,7 +124,7 @@ void fz_sha256init(fz_sha256 *context)
 	context->state[7] = 0x5BE0CD19;
 }
 
-void fz_sha256update(fz_sha256 *context, const unsigned char *input, unsigned int inlen)
+void fz_sha256_update(fz_sha256 *context, const unsigned char *input, unsigned int inlen)
 {
 	/* Copy the input data into a properly aligned temporary buffer.
 	 * This way we can be called with arbitrarily sized buffers
@@ -151,7 +151,7 @@ void fz_sha256update(fz_sha256 *context, const unsigned char *input, unsigned in
 	}
 }
 
-void fz_sha256final(fz_sha256 *context, unsigned char digest[32])
+void fz_sha256_final(fz_sha256 *context, unsigned char digest[32])
 {
 	/* Add padding as described in RFC 3174 (it describes SHA-1 but
 	 * the same padding style is used for SHA-256 too). */
diff --git a/fitz/dev_bbox.c b/fitz/dev_bbox.c
index f6028f44..0f2f3cfe 100644
--- a/fitz/dev_bbox.c
+++ b/fitz/dev_bbox.c
@@ -2,95 +2,95 @@
 
 /* TODO: add clip stack and use to intersect bboxes */
 
-typedef struct fz_bboxdevice_s fz_bboxdevice;
+typedef struct fz_bbox_device_s fz_bbox_device;
 
-struct fz_bboxdevice_s
+struct fz_bbox_device_s
 {
 	fz_bbox *bbox;
 };
 
 static void
-fz_bboxfillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm,
+fz_bbox_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_boundpath(path, nil, ctm));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_bound_path(path, NULL, ctm));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm,
+fz_bbox_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_boundpath(path, stroke, ctm));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_bound_path(path, stroke, ctm));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxfilltext(void *user, fz_text *text, fz_matrix ctm,
+fz_bbox_fill_text(void *user, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_boundtext(text, ctm));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_bound_text(text, ctm));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm,
+fz_bbox_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_boundtext(text, ctm));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_bound_text(text, ctm));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_bbox_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_boundshade(shade, ctm));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_bound_shade(shade, ctm));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
+fz_bbox_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 {
-	fz_bboxdevice *bdev = user;
-	fz_bbox bbox = fz_roundrect(fz_transformrect(ctm, fz_unitrect));
-	*bdev->bbox = fz_unionbbox(*bdev->bbox, bbox);
+	fz_bbox_device *bdev = user;
+	fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, fz_unit_rect));
+	*bdev->bbox = fz_union_bbox(*bdev->bbox, bbox);
 }
 
 static void
-fz_bboxfillimagemask(void *user, fz_pixmap *image, fz_matrix ctm,
+fz_bbox_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_bboxfillimage(user, image, ctm, alpha);
+	fz_bbox_fill_image(user, image, ctm, alpha);
 }
 
 static void
-fz_bboxfreeuser(void *user)
+fz_bbox_free_user(void *user)
 {
-	fz_bboxdevice *bdev = user;
+	fz_bbox_device *bdev = user;
 	fz_free(bdev);
 }
 
 fz_device *
-fz_newbboxdevice(fz_bbox *bboxp)
+fz_new_bbox_device(fz_bbox *bboxp)
 {
 	fz_device *dev;
-	fz_bboxdevice *bdev = fz_malloc(sizeof(fz_bboxdevice));
+	fz_bbox_device *bdev = fz_malloc(sizeof(fz_bbox_device));
 	bdev->bbox = bboxp;
-	*bdev->bbox = fz_emptybbox;
+	*bdev->bbox = fz_empty_bbox;
 
-	dev = fz_newdevice(bdev);
-	dev->freeuser = fz_bboxfreeuser;
-	dev->fillpath = fz_bboxfillpath;
-	dev->strokepath = fz_bboxstrokepath;
-	dev->filltext = fz_bboxfilltext;
-	dev->stroketext = fz_bboxstroketext;
-	dev->fillshade = fz_bboxfillshade;
-	dev->fillimage = fz_bboxfillimage;
-	dev->fillimagemask = fz_bboxfillimagemask;
+	dev = fz_new_device(bdev);
+	dev->free_user = fz_bbox_free_user;
+	dev->fill_path = fz_bbox_fill_path;
+	dev->stroke_path = fz_bbox_stroke_path;
+	dev->fill_text = fz_bbox_fill_text;
+	dev->stroke_text = fz_bbox_stroke_text;
+	dev->fill_shade = fz_bbox_fill_shade;
+	dev->fill_image = fz_bbox_fill_image;
+	dev->fill_image_mask = fz_bbox_fill_image_mask;
 	return dev;
 }
diff --git a/fitz/dev_draw.c b/fitz/dev_draw.c
index ee74033d..e5078f49 100644
--- a/fitz/dev_draw.c
+++ b/fitz/dev_draw.c
@@ -4,13 +4,13 @@
 #define HSUBPIX 5.0
 #define VSUBPIX 5.0
 
-#define STACKSIZE 96
+#define STACK_SIZE 96
 
-typedef struct fz_drawdevice_s fz_drawdevice;
+typedef struct fz_draw_device_s fz_draw_device;
 
-struct fz_drawdevice_s
+struct fz_draw_device_s
 {
-	fz_glyphcache *cache;
+	fz_glyph_cache *cache;
 	fz_gel *gel;
 	fz_ael *ael;
 
@@ -28,118 +28,118 @@ struct fz_drawdevice_s
 		fz_matrix ctm;
 		float xstep, ystep;
 		fz_rect area;
-	} stack[STACKSIZE];
+	} stack[STACK_SIZE];
 };
 
 static void
-fz_drawfillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm,
+fz_draw_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	float expansion = fz_matrixexpansion(ctm);
+	float expansion = fz_matrix_expansion(ctm);
 	float flatness = 0.3f / expansion;
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
-	float colorfv[FZ_MAXCOLORS];
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
 	fz_bbox bbox;
 	int i;
 
-	fz_resetgel(dev->gel, dev->scissor);
-	fz_fillpath(dev->gel, path, ctm, flatness);
-	fz_sortgel(dev->gel);
+	fz_reset_gel(dev->gel, dev->scissor);
+	fz_fill_path(dev->gel, path, ctm, flatness);
+	fz_sort_gel(dev->gel);
 
-	bbox = fz_boundgel(dev->gel);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_bound_gel(dev->gel);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	if (fz_isemptyrect(bbox))
+	if (fz_is_empty_rect(bbox))
 		return;
 
-	fz_convertcolor(colorspace, color, model, colorfv);
+	fz_convert_color(colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
 
-	fz_scanconvert(dev->gel, dev->ael, evenodd, bbox, dev->dest, colorbv);
+	fz_scan_convert(dev->gel, dev->ael, even_odd, bbox, dev->dest, colorbv);
 }
 
 static void
-fz_drawstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm,
+fz_draw_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	float expansion = fz_matrixexpansion(ctm);
+	float expansion = fz_matrix_expansion(ctm);
 	float flatness = 0.3f / expansion;
 	float linewidth = stroke->linewidth;
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
-	float colorfv[FZ_MAXCOLORS];
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
 	fz_bbox bbox;
 	int i;
 
 	if (linewidth * expansion < 0.1f)
 		linewidth = 1 / expansion;
 
-	fz_resetgel(dev->gel, dev->scissor);
-	if (stroke->dashlen > 0)
-		fz_dashpath(dev->gel, path, stroke, ctm, flatness, linewidth);
+	fz_reset_gel(dev->gel, dev->scissor);
+	if (stroke->dash_len > 0)
+		fz_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 	else
-		fz_strokepath(dev->gel, path, stroke, ctm, flatness, linewidth);
-	fz_sortgel(dev->gel);
+		fz_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
+	fz_sort_gel(dev->gel);
 
-	bbox = fz_boundgel(dev->gel);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_bound_gel(dev->gel);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	if (fz_isemptyrect(bbox))
+	if (fz_is_empty_rect(bbox))
 		return;
 
-	fz_convertcolor(colorspace, color, model, colorfv);
+	fz_convert_color(colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
 
-	fz_scanconvert(dev->gel, dev->ael, 0, bbox, dev->dest, colorbv);
+	fz_scan_convert(dev->gel, dev->ael, 0, bbox, dev->dest, colorbv);
 }
 
 static void
-fz_drawclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm)
+fz_draw_clip_path(void *user, fz_path *path, int even_odd, fz_matrix ctm)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	float expansion = fz_matrixexpansion(ctm);
+	float expansion = fz_matrix_expansion(ctm);
 	float flatness = 0.3f / expansion;
 	fz_pixmap *mask, *dest;
 	fz_bbox bbox;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
 	}
 
-	fz_resetgel(dev->gel, dev->scissor);
-	fz_fillpath(dev->gel, path, ctm, flatness);
-	fz_sortgel(dev->gel);
+	fz_reset_gel(dev->gel, dev->scissor);
+	fz_fill_path(dev->gel, path, ctm, flatness);
+	fz_sort_gel(dev->gel);
 
-	bbox = fz_boundgel(dev->gel);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_bound_gel(dev->gel);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	if (fz_isemptyrect(bbox) || fz_isrectgel(dev->gel))
+	if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
 	{
 		dev->stack[dev->top].scissor = dev->scissor;
-		dev->stack[dev->top].mask = nil;
-		dev->stack[dev->top].dest = nil;
+		dev->stack[dev->top].mask = NULL;
+		dev->stack[dev->top].dest = NULL;
 		dev->scissor = bbox;
 		dev->top++;
 		return;
 	}
 
-	mask = fz_newpixmapwithrect(nil, bbox);
-	dest = fz_newpixmapwithrect(model, bbox);
+	mask = fz_new_pixmap_with_rect(NULL, bbox);
+	dest = fz_new_pixmap_with_rect(model, bbox);
 
-	fz_clearpixmap(mask);
-	fz_clearpixmap(dest);
+	fz_clear_pixmap(mask);
+	fz_clear_pixmap(dest);
 
-	fz_scanconvert(dev->gel, dev->ael, evenodd, bbox, mask, nil);
+	fz_scan_convert(dev->gel, dev->ael, even_odd, bbox, mask, NULL);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].mask = mask;
@@ -150,17 +150,17 @@ fz_drawclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm)
 }
 
 static void
-fz_drawclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
+fz_draw_clip_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	float expansion = fz_matrixexpansion(ctm);
+	float expansion = fz_matrix_expansion(ctm);
 	float flatness = 0.3f / expansion;
 	float linewidth = stroke->linewidth;
 	fz_pixmap *mask, *dest;
 	fz_bbox bbox;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
@@ -169,24 +169,24 @@ fz_drawclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matr
 	if (linewidth * expansion < 0.1f)
 		linewidth = 1 / expansion;
 
-	fz_resetgel(dev->gel, dev->scissor);
-	if (stroke->dashlen > 0)
-		fz_dashpath(dev->gel, path, stroke, ctm, flatness, linewidth);
+	fz_reset_gel(dev->gel, dev->scissor);
+	if (stroke->dash_len > 0)
+		fz_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
 	else
-		fz_strokepath(dev->gel, path, stroke, ctm, flatness, linewidth);
-	fz_sortgel(dev->gel);
+		fz_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
+	fz_sort_gel(dev->gel);
 
-	bbox = fz_boundgel(dev->gel);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_bound_gel(dev->gel);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	mask = fz_newpixmapwithrect(nil, bbox);
-	dest = fz_newpixmapwithrect(model, bbox);
+	mask = fz_new_pixmap_with_rect(NULL, bbox);
+	dest = fz_new_pixmap_with_rect(model, bbox);
 
-	fz_clearpixmap(mask);
-	fz_clearpixmap(dest);
+	fz_clear_pixmap(mask);
+	fz_clear_pixmap(dest);
 
-	if (!fz_isemptyrect(bbox))
-		fz_scanconvert(dev->gel, dev->ael, 0, bbox, mask, nil);
+	if (!fz_is_empty_rect(bbox))
+		fz_scan_convert(dev->gel, dev->ael, 0, bbox, mask, NULL);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].mask = mask;
@@ -197,20 +197,20 @@ fz_drawclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matr
 }
 
 static void
-drawglyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
+draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
 	int xorig, int yorig, fz_bbox scissor)
 {
 	unsigned char *dp, *mp;
 	fz_bbox bbox;
 	int x, y, w, h;
 
-	bbox = fz_boundpixmap(msk);
+	bbox = fz_bound_pixmap(msk);
 	bbox.x0 += xorig;
 	bbox.y0 += yorig;
 	bbox.x1 += xorig;
 	bbox.y1 += yorig;
 
-	bbox = fz_intersectbbox(bbox, scissor); /* scissor < dst */
+	bbox = fz_intersect_bbox(bbox, scissor); /* scissor < dst */
 	x = bbox.x0;
 	y = bbox.y0;
 	w = bbox.x1 - bbox.x0;
@@ -224,27 +224,27 @@ drawglyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
 	while (h--)
 	{
 		if (dst->colorspace)
-			fz_paintspancolor(dp, mp, dst->n, w, colorbv);
+			fz_paint_span_with_color(dp, mp, dst->n, w, colorbv);
 		else
-			fz_paintspan(dp, mp, 1, w, 255);
+			fz_paint_span(dp, mp, 1, w, 255);
 		dp += dst->w * dst->n;
 		mp += msk->w;
 	}
 }
 
 static void
-fz_drawfilltext(void *user, fz_text *text, fz_matrix ctm,
+fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
-	float colorfv[FZ_MAXCOLORS];
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
 	fz_matrix tm, trm;
 	fz_pixmap *glyph;
 	int i, x, y, gid;
 
-	fz_convertcolor(colorspace, color, model, colorfv);
+	fz_convert_color(colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -253,40 +253,40 @@ fz_drawfilltext(void *user, fz_text *text, fz_matrix ctm,
 
 	for (i = 0; i < text->len; i++)
 	{
-		gid = text->els[i].gid;
+		gid = text->items[i].gid;
 		if (gid < 0)
 			continue;
 
-		tm.e = text->els[i].x;
-		tm.f = text->els[i].y;
+		tm.e = text->items[i].x;
+		tm.f = text->items[i].y;
 		trm = fz_concat(tm, ctm);
 		x = floorf(trm.e);
 		y = floorf(trm.f);
 		trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 		trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-		glyph = fz_renderglyph(dev->cache, text->font, gid, trm);
+		glyph = fz_render_glyph(dev->cache, text->font, gid, trm);
 		if (glyph)
 		{
-			drawglyph(colorbv, dev->dest, glyph, x, y, dev->scissor);
-			fz_droppixmap(glyph);
+			draw_glyph(colorbv, dev->dest, glyph, x, y, dev->scissor);
+			fz_drop_pixmap(glyph);
 		}
 	}
 }
 
 static void
-fz_drawstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm,
+fz_draw_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
-	float colorfv[FZ_MAXCOLORS];
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
 	fz_matrix tm, trm;
 	fz_pixmap *glyph;
 	int i, x, y, gid;
 
-	fz_convertcolor(colorspace, color, model, colorfv);
+	fz_convert_color(colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
@@ -295,31 +295,31 @@ fz_drawstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix c
 
 	for (i = 0; i < text->len; i++)
 	{
-		gid = text->els[i].gid;
+		gid = text->items[i].gid;
 		if (gid < 0)
 			continue;
 
-		tm.e = text->els[i].x;
-		tm.f = text->els[i].y;
+		tm.e = text->items[i].x;
+		tm.f = text->items[i].y;
 		trm = fz_concat(tm, ctm);
 		x = floorf(trm.e);
 		y = floorf(trm.f);
 		trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 		trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-		glyph = fz_renderstrokedglyph(dev->cache, text->font, gid, trm, ctm, stroke);
+		glyph = fz_render_stroked_glyph(dev->cache, text->font, gid, trm, ctm, stroke);
 		if (glyph)
 		{
-			drawglyph(colorbv, dev->dest, glyph, x, y, dev->scissor);
-			fz_droppixmap(glyph);
+			draw_glyph(colorbv, dev->dest, glyph, x, y, dev->scissor);
+			fz_drop_pixmap(glyph);
 		}
 	}
 }
 
 static void
-fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
+fz_draw_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_bbox bbox;
 	fz_pixmap *mask, *dest;
@@ -331,7 +331,7 @@ fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 	/* If accumulate == 1 then this text object is the first (or only) in a sequence */
 	/* If accumulate == 2 then this text object is a continuation */
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
@@ -340,8 +340,8 @@ fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 	if (accumulate == 0)
 	{
 		/* make the mask the exact size needed */
-		bbox = fz_roundrect(fz_boundtext(text, ctm));
-		bbox = fz_intersectbbox(bbox, dev->scissor);
+		bbox = fz_round_rect(fz_bound_text(text, ctm));
+		bbox = fz_intersect_bbox(bbox, dev->scissor);
 	}
 	else
 	{
@@ -351,11 +351,11 @@ fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 
 	if (accumulate == 0 || accumulate == 1)
 	{
-		mask = fz_newpixmapwithrect(nil, bbox);
-		dest = fz_newpixmapwithrect(model, bbox);
+		mask = fz_new_pixmap_with_rect(NULL, bbox);
+		dest = fz_new_pixmap_with_rect(model, bbox);
 
-		fz_clearpixmap(mask);
-		fz_clearpixmap(dest);
+		fz_clear_pixmap(mask);
+		fz_clear_pixmap(dest);
 
 		dev->stack[dev->top].scissor = dev->scissor;
 		dev->stack[dev->top].mask = mask;
@@ -369,38 +369,38 @@ fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 		mask = dev->stack[dev->top-1].mask;
 	}
 
-	if (!fz_isemptyrect(bbox))
+	if (!fz_is_empty_rect(bbox))
 	{
 		tm = text->trm;
 
 		for (i = 0; i < text->len; i++)
 		{
-			gid = text->els[i].gid;
+			gid = text->items[i].gid;
 			if (gid < 0)
 				continue;
 
-			tm.e = text->els[i].x;
-			tm.f = text->els[i].y;
+			tm.e = text->items[i].x;
+			tm.f = text->items[i].y;
 			trm = fz_concat(tm, ctm);
 			x = floorf(trm.e);
 			y = floorf(trm.f);
 			trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 			trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-			glyph = fz_renderglyph(dev->cache, text->font, gid, trm);
+			glyph = fz_render_glyph(dev->cache, text->font, gid, trm);
 			if (glyph)
 			{
-				drawglyph(nil, mask, glyph, x, y, bbox);
-				fz_droppixmap(glyph);
+				draw_glyph(NULL, mask, glyph, x, y, bbox);
+				fz_drop_pixmap(glyph);
 			}
 		}
 	}
 }
 
 static void
-fz_drawclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm)
+fz_draw_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_bbox bbox;
 	fz_pixmap *mask, *dest;
@@ -408,21 +408,21 @@ fz_drawclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matr
 	fz_pixmap *glyph;
 	int i, x, y, gid;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
 	}
 
 	/* make the mask the exact size needed */
-	bbox = fz_roundrect(fz_boundtext(text, ctm));
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_round_rect(fz_bound_text(text, ctm));
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	mask = fz_newpixmapwithrect(nil, bbox);
-	dest = fz_newpixmapwithrect(model, bbox);
+	mask = fz_new_pixmap_with_rect(NULL, bbox);
+	dest = fz_new_pixmap_with_rect(model, bbox);
 
-	fz_clearpixmap(mask);
-	fz_clearpixmap(dest);
+	fz_clear_pixmap(mask);
+	fz_clear_pixmap(dest);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].mask = mask;
@@ -431,57 +431,57 @@ fz_drawclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matr
 	dev->dest = dest;
 	dev->top++;
 
-	if (!fz_isemptyrect(bbox))
+	if (!fz_is_empty_rect(bbox))
 	{
 		tm = text->trm;
 
 		for (i = 0; i < text->len; i++)
 		{
-			gid = text->els[i].gid;
+			gid = text->items[i].gid;
 			if (gid < 0)
 				continue;
 
-			tm.e = text->els[i].x;
-			tm.f = text->els[i].y;
+			tm.e = text->items[i].x;
+			tm.f = text->items[i].y;
 			trm = fz_concat(tm, ctm);
 			x = floorf(trm.e);
 			y = floorf(trm.f);
 			trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
 			trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
 
-			glyph = fz_renderstrokedglyph(dev->cache, text->font, gid, trm, ctm, stroke);
+			glyph = fz_render_stroked_glyph(dev->cache, text->font, gid, trm, ctm, stroke);
 			if (glyph)
 			{
-				drawglyph(nil, mask, glyph, x, y, bbox);
-				fz_droppixmap(glyph);
+				draw_glyph(NULL, mask, glyph, x, y, bbox);
+				fz_drop_pixmap(glyph);
 			}
 		}
 	}
 }
 
 static void
-fz_drawignoretext(void *user, fz_text *text, fz_matrix ctm)
+fz_draw_ignore_text(void *user, fz_text *text, fz_matrix ctm)
 {
 }
 
 static void
-fz_drawfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_pixmap *dest = dev->dest;
 	fz_rect bounds;
 	fz_bbox bbox, scissor;
-	float colorfv[FZ_MAXCOLORS];
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
 
-	bounds = fz_boundshade(shade, ctm);
-	bbox = fz_intersectbbox(fz_roundrect(bounds), dev->scissor);
+	bounds = fz_bound_shade(shade, ctm);
+	bbox = fz_intersect_bbox(fz_round_rect(bounds), dev->scissor);
 	scissor = dev->scissor;
 
 	// TODO: proper clip by shade->bbox
 
-	if (fz_isemptyrect(bbox))
+	if (fz_is_empty_rect(bbox))
 		return;
 
 	if (!model)
@@ -492,15 +492,15 @@ fz_drawfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 
 	if (alpha < 1)
 	{
-		dest = fz_newpixmapwithrect(dev->dest->colorspace, bbox);
-		fz_clearpixmap(dest);
+		dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox);
+		fz_clear_pixmap(dest);
 	}
 
-	if (shade->usebackground)
+	if (shade->use_background)
 	{
 		unsigned char *s;
 		int x, y, n, i;
-		fz_convertcolor(shade->colorspace, shade->background, model, colorfv);
+		fz_convert_color(shade->colorspace, shade->background, model, colorfv);
 		for (i = 0; i < model->n; i++)
 			colorbv[i] = colorfv[i] * 255;
 		colorbv[i] = 255;
@@ -517,26 +517,26 @@ fz_drawfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 		}
 	}
 
-	fz_paintshade(shade, ctm, dest, bbox);
+	fz_paint_shade(shade, ctm, dest, bbox);
 
 	if (alpha < 1)
 	{
-		fz_paintpixmap(dev->dest, dest, alpha * 255);
-		fz_droppixmap(dest);
+		fz_paint_pixmap(dev->dest, dest, alpha * 255);
+		fz_drop_pixmap(dest);
 	}
 }
 
 static fz_pixmap *
-fz_transformpixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy)
+fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy)
 {
 	fz_pixmap *scaled;
 
 	if ((ctm->a != 0) && (ctm->b == 0) && (ctm->c == 0) && (ctm->d != 0))
 	{
 		/* Unrotated or X flip or Yflip or XYflip */
-		scaled = fz_scalepixmap(image, ctm->e, ctm->f, ctm->a, ctm->d);
-		if (scaled == nil)
-			return nil;
+		scaled = fz_scale_pixmap(image, ctm->e, ctm->f, ctm->a, ctm->d);
+		if (scaled == NULL)
+			return NULL;
 		ctm->a = scaled->w;
 		ctm->d = scaled->h;
 		ctm->e = scaled->x;
@@ -546,9 +546,9 @@ fz_transformpixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int d
 	if ((ctm->a == 0) && (ctm->b != 0) && (ctm->c != 0) && (ctm->d == 0))
 	{
 		/* Other orthogonal flip/rotation cases */
-		scaled = fz_scalepixmap(image, ctm->f, ctm->e, ctm->b, ctm->c);
-		if (scaled == nil)
-			return nil;
+		scaled = fz_scale_pixmap(image, ctm->f, ctm->e, ctm->b, ctm->c);
+		if (scaled == NULL)
+			return NULL;
 		ctm->b = scaled->w;
 		ctm->c = scaled->h;
 		ctm->f = scaled->x;
@@ -558,19 +558,19 @@ fz_transformpixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int d
 	/* Downscale, non rectilinear case */
 	if ((dx > 0) && (dy > 0))
 	{
-		scaled = fz_scalepixmap(image, 0, 0, (float)dx, (float)dy);
+		scaled = fz_scale_pixmap(image, 0, 0, (float)dx, (float)dy);
 		return scaled;
 	}
-	return nil;
+	return NULL;
 }
 
 static void
-fz_drawfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
+fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	fz_pixmap *converted = nil;
-	fz_pixmap *scaled = nil;
+	fz_pixmap *converted = NULL;
+	fz_pixmap *scaled = NULL;
 	int after;
 	int dx, dy;
 
@@ -588,13 +588,13 @@ fz_drawfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 	/* convert images with expensive colorspace transforms after scaling */
 
 	after = 0;
-	if (image->colorspace == fz_devicegray)
+	if (image->colorspace == fz_device_gray)
 		after = 1;
 
 	if (image->colorspace != model && !after)
 	{
-		converted = fz_newpixmap(model, image->x, image->y, image->w, image->h);
-		fz_convertpixmap(image, converted);
+		converted = fz_new_pixmap(model, image->x, image->y, image->w, image->h);
+		fz_convert_pixmap(image, converted);
 		image = converted;
 	}
 
@@ -602,43 +602,43 @@ fz_drawfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
 	if (dx < image->w && dy < image->h)
 	{
-		scaled = fz_transformpixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
-		if (scaled == nil)
+		scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
+		if (scaled == NULL)
 		{
 			if (dx < 1)
 				dx = 1;
 			if (dy < 1)
 				dy = 1;
-			scaled = fz_scalepixmap(image, image->x, image->y, dx, dy);
+			scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy);
 		}
-		if (scaled != nil)
+		if (scaled != NULL)
 			image = scaled;
 	}
 
 	if (image->colorspace != model && after)
 	{
-		converted = fz_newpixmap(model, image->x, image->y, image->w, image->h);
-		fz_convertpixmap(image, converted);
+		converted = fz_new_pixmap(model, image->x, image->y, image->w, image->h);
+		fz_convert_pixmap(image, converted);
 		image = converted;
 	}
 
-	fz_paintimage(dev->dest, dev->scissor, image, ctm, alpha * 255);
+	fz_paint_image(dev->dest, dev->scissor, image, ctm, alpha * 255);
 
 	if (scaled)
-		fz_droppixmap(scaled);
+		fz_drop_pixmap(scaled);
 	if (converted)
-		fz_droppixmap(converted);
+		fz_drop_pixmap(converted);
 }
 
 static void
-fz_drawfillimagemask(void *user, fz_pixmap *image, fz_matrix ctm,
+fz_draw_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
-	unsigned char colorbv[FZ_MAXCOLORS + 1];
-	float colorfv[FZ_MAXCOLORS];
-	fz_pixmap *scaled = nil;
+	unsigned char colorbv[FZ_MAX_COLORS + 1];
+	float colorfv[FZ_MAX_COLORS];
+	fz_pixmap *scaled = NULL;
 	int dx, dy;
 	int i;
 
@@ -649,41 +649,41 @@ fz_drawfillimagemask(void *user, fz_pixmap *image, fz_matrix ctm,
 	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
 	if (dx < image->w && dy < image->h)
 	{
-		scaled = fz_transformpixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
-		if (scaled == nil)
+		scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
+		if (scaled == NULL)
 		{
 			if (dx < 1)
 				dx = 1;
 			if (dy < 1)
 				dy = 1;
-			scaled = fz_scalepixmap(image, image->x, image->y, dx, dy);
+			scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy);
 		}
-		if (scaled != nil)
+		if (scaled != NULL)
 			image = scaled;
 	}
 
-	fz_convertcolor(colorspace, color, model, colorfv);
+	fz_convert_color(colorspace, color, model, colorfv);
 	for (i = 0; i < model->n; i++)
 		colorbv[i] = colorfv[i] * 255;
 	colorbv[i] = alpha * 255;
 
-	fz_paintimagecolor(dev->dest, dev->scissor, image, ctm, colorbv);
+	fz_paint_image_with_color(dev->dest, dev->scissor, image, ctm, colorbv);
 
 	if (scaled)
-		fz_droppixmap(scaled);
+		fz_drop_pixmap(scaled);
 }
 
 static void
-fz_drawclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
+fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_matrix ctm)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_bbox bbox;
 	fz_pixmap *mask, *dest;
-	fz_pixmap *scaled = nil;
+	fz_pixmap *scaled = NULL;
 	int dx, dy;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
@@ -692,43 +692,43 @@ fz_drawclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
 	if (image->w == 0 || image->h == 0)
 	{
 		dev->stack[dev->top].scissor = dev->scissor;
-		dev->stack[dev->top].mask = nil;
-		dev->stack[dev->top].dest = nil;
-		dev->scissor = fz_emptybbox;
+		dev->stack[dev->top].mask = NULL;
+		dev->stack[dev->top].dest = NULL;
+		dev->scissor = fz_empty_bbox;
 		dev->top++;
 		return;
 	}
 
-	bbox = fz_roundrect(fz_transformrect(ctm, fz_unitrect));
-	bbox = fz_intersectbbox(bbox, dev->scissor);
+	bbox = fz_round_rect(fz_transform_rect(ctm, fz_unit_rect));
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
 
-	mask = fz_newpixmapwithrect(nil, bbox);
-	dest = fz_newpixmapwithrect(model, bbox);
+	mask = fz_new_pixmap_with_rect(NULL, bbox);
+	dest = fz_new_pixmap_with_rect(model, bbox);
 
-	fz_clearpixmap(mask);
-	fz_clearpixmap(dest);
+	fz_clear_pixmap(mask);
+	fz_clear_pixmap(dest);
 
 	dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
 	dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
 	if (dx < image->w && dy < image->h)
 	{
-		scaled = fz_transformpixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
-		if (scaled == nil)
+		scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
+		if (scaled == NULL)
 		{
 			if (dx < 1)
 				dx = 1;
 			if (dy < 1)
 				dy = 1;
-			scaled = fz_scalepixmap(image, image->x, image->y, dx, dy);
+			scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy);
 		}
-		if (scaled != nil)
+		if (scaled != NULL)
 			image = scaled;
 	}
 
-	fz_paintimage(mask, bbox, image, ctm, 255);
+	fz_paint_image(mask, bbox, image, ctm, 255);
 
 	if (scaled)
-		fz_droppixmap(scaled);
+		fz_drop_pixmap(scaled);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].mask = mask;
@@ -739,9 +739,9 @@ fz_drawclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
 }
 
 static void
-fz_drawpopclip(void *user)
+fz_draw_pop_clip(void *user)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_pixmap *mask, *dest;
 	if (dev->top > 0)
 	{
@@ -752,41 +752,41 @@ fz_drawpopclip(void *user)
 		if (mask && dest)
 		{
 			fz_pixmap *scratch = dev->dest;
-			fz_paintpixmapmask(dest, scratch, mask);
-			fz_droppixmap(mask);
-			fz_droppixmap(scratch);
+			fz_paint_pixmap_with_mask(dest, scratch, mask);
+			fz_drop_pixmap(mask);
+			fz_drop_pixmap(scratch);
 			dev->dest = dest;
 		}
 	}
 }
 
 static void
-fz_drawbeginmask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
+fz_draw_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_pixmap *dest;
 	fz_bbox bbox;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
 	}
 
-	bbox = fz_roundrect(rect);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
-	dest = fz_newpixmapwithrect(fz_devicegray, bbox);
+	bbox = fz_round_rect(rect);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
+	dest = fz_new_pixmap_with_rect(fz_device_gray, bbox);
 
 	if (luminosity)
 	{
 		float bc;
 		if (!colorspace)
-			colorspace = fz_devicegray;
-		fz_convertcolor(colorspace, colorfv, fz_devicegray, &bc);
-		fz_clearpixmapwithcolor(dest, bc * 255);
+			colorspace = fz_device_gray;
+		fz_convert_color(colorspace, colorfv, fz_device_gray, &bc);
+		fz_clear_pixmap_with_color(dest, bc * 255);
 	}
 	else
-		fz_clearpixmap(dest);
+		fz_clear_pixmap(dest);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].dest = dev->dest;
@@ -798,15 +798,15 @@ fz_drawbeginmask(void *user, fz_rect rect, int luminosity, fz_colorspace *colors
 }
 
 static void
-fz_drawendmask(void *user)
+fz_draw_end_mask(void *user)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_pixmap *mask = dev->dest;
 	fz_pixmap *temp, *dest;
 	fz_bbox bbox;
 	int luminosity;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
@@ -821,13 +821,13 @@ fz_drawendmask(void *user)
 		dev->dest = dev->stack[dev->top].dest;
 
 		/* convert to alpha mask */
-		temp = fz_alphafromgray(mask, luminosity);
-		fz_droppixmap(mask);
+		temp = fz_alpha_from_gray(mask, luminosity);
+		fz_drop_pixmap(mask);
 
 		/* create new dest scratch buffer */
-		bbox = fz_boundpixmap(temp);
-		dest = fz_newpixmapwithrect(dev->dest->colorspace, bbox);
-		fz_clearpixmap(dest);
+		bbox = fz_bound_pixmap(temp);
+		dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox);
+		fz_clear_pixmap(dest);
 
 		/* push soft mask as clip mask */
 		dev->stack[dev->top].scissor = dev->scissor;
@@ -840,24 +840,24 @@ fz_drawendmask(void *user)
 }
 
 static void
-fz_drawbegingroup(void *user, fz_rect rect, int isolated, int knockout, fz_blendmode blendmode, float alpha)
+fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, fz_blendmode blendmode, float alpha)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_bbox bbox;
 	fz_pixmap *dest;
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
 	}
 
-	bbox = fz_roundrect(rect);
-	bbox = fz_intersectbbox(bbox, dev->scissor);
-	dest = fz_newpixmapwithrect(model, bbox);
+	bbox = fz_round_rect(rect);
+	bbox = fz_intersect_bbox(bbox, dev->scissor);
+	dest = fz_new_pixmap_with_rect(model, bbox);
 
-	fz_clearpixmap(dest);
+	fz_clear_pixmap(dest);
 
 	dev->stack[dev->top].alpha = alpha;
 	dev->stack[dev->top].blendmode = blendmode;
@@ -870,9 +870,9 @@ fz_drawbegingroup(void *user, fz_rect rect, int isolated, int knockout, fz_blend
 }
 
 static void
-fz_drawendgroup(void *user)
+fz_draw_end_group(void *user)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_pixmap *group = dev->dest;
 	fz_blendmode blendmode;
 	float alpha;
@@ -885,19 +885,19 @@ fz_drawendgroup(void *user)
 		dev->dest = dev->stack[dev->top].dest;
 		dev->scissor = dev->stack[dev->top].scissor;
 
-		if (blendmode == FZ_BNORMAL)
-			fz_paintpixmap(dev->dest, group, alpha * 255);
+		if (blendmode == FZ_BLEND_NORMAL)
+			fz_paint_pixmap(dev->dest, group, alpha * 255);
 		else
-			fz_blendpixmap(dev->dest, group, alpha * 255, blendmode);
+			fz_blend_pixmap(dev->dest, group, alpha * 255, blendmode);
 
-		fz_droppixmap(group);
+		fz_drop_pixmap(group);
 	}
 }
 
 static void
-fz_drawbegintile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_draw_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_colorspace *model = dev->dest->colorspace;
 	fz_pixmap *dest;
 	fz_bbox bbox;
@@ -905,15 +905,15 @@ fz_drawbegintile(void *user, fz_rect area, fz_rect view, float xstep, float yste
 	/* area, view, xstep, ystep are in pattern space */
 	/* ctm maps from pattern space to device space */
 
-	if (dev->top == STACKSIZE)
+	if (dev->top == STACK_SIZE)
 	{
 		fz_warn("assert: too many buffers on stack");
 		return;
 	}
 
-	bbox = fz_roundrect(fz_transformrect(ctm, view));
-	dest = fz_newpixmapwithrect(model, bbox);
-	fz_clearpixmap(dest);
+	bbox = fz_round_rect(fz_transform_rect(ctm, view));
+	dest = fz_new_pixmap_with_rect(model, bbox);
+	fz_clear_pixmap(dest);
 
 	dev->stack[dev->top].scissor = dev->scissor;
 	dev->stack[dev->top].dest = dev->dest;
@@ -928,9 +928,9 @@ fz_drawbegintile(void *user, fz_rect area, fz_rect view, float xstep, float yste
 }
 
 static void
-fz_drawendtile(void *user)
+fz_draw_end_tile(void *user)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	fz_pixmap *tile = dev->dest;
 	float xstep, ystep;
 	fz_matrix ctm, ttm;
@@ -962,32 +962,32 @@ fz_drawendtile(void *user)
 				ttm = fz_concat(fz_translate(x * xstep, y * ystep), ctm);
 				tile->x = ttm.e;
 				tile->y = ttm.f;
-				fz_paintpixmapbbox(dev->dest, tile, 255, dev->scissor);
+				fz_paint_pixmap_with_rect(dev->dest, tile, 255, dev->scissor);
 			}
 		}
 
-		fz_droppixmap(tile);
+		fz_drop_pixmap(tile);
 	}
 }
 
 static void
-fz_drawfreeuser(void *user)
+fz_draw_free_user(void *user)
 {
-	fz_drawdevice *dev = user;
+	fz_draw_device *dev = user;
 	/* TODO: pop and free the stacks */
-	fz_freegel(dev->gel);
-	fz_freeael(dev->ael);
+	fz_free_gel(dev->gel);
+	fz_free_ael(dev->ael);
 	fz_free(dev);
 }
 
 fz_device *
-fz_newdrawdevice(fz_glyphcache *cache, fz_pixmap *dest)
+fz_new_draw_device(fz_glyph_cache *cache, fz_pixmap *dest)
 {
 	fz_device *dev;
-	fz_drawdevice *ddev = fz_malloc(sizeof(fz_drawdevice));
+	fz_draw_device *ddev = fz_malloc(sizeof(fz_draw_device));
 	ddev->cache = cache;
-	ddev->gel = fz_newgel();
-	ddev->ael = fz_newael();
+	ddev->gel = fz_new_gel();
+	ddev->ael = fz_new_ael();
 	ddev->dest = dest;
 	ddev->top = 0;
 
@@ -996,34 +996,34 @@ fz_newdrawdevice(fz_glyphcache *cache, fz_pixmap *dest)
 	ddev->scissor.x1 = dest->x + dest->w;
 	ddev->scissor.y1 = dest->y + dest->h;
 
-	dev = fz_newdevice(ddev);
-	dev->freeuser = fz_drawfreeuser;
+	dev = fz_new_device(ddev);
+	dev->free_user = fz_draw_free_user;
 
-	dev->fillpath = fz_drawfillpath;
-	dev->strokepath = fz_drawstrokepath;
-	dev->clippath = fz_drawclippath;
-	dev->clipstrokepath = fz_drawclipstrokepath;
+	dev->fill_path = fz_draw_fill_path;
+	dev->stroke_path = fz_draw_stroke_path;
+	dev->clip_path = fz_draw_clip_path;
+	dev->clip_stroke_path = fz_draw_clip_stroke_path;
 
-	dev->filltext = fz_drawfilltext;
-	dev->stroketext = fz_drawstroketext;
-	dev->cliptext = fz_drawcliptext;
-	dev->clipstroketext = fz_drawclipstroketext;
-	dev->ignoretext = fz_drawignoretext;
+	dev->fill_text = fz_draw_fill_text;
+	dev->stroke_text = fz_draw_stroke_text;
+	dev->clip_text = fz_draw_clip_text;
+	dev->clip_stroke_text = fz_draw_clip_stroke_text;
+	dev->ignore_text = fz_draw_ignore_text;
 
-	dev->fillimagemask = fz_drawfillimagemask;
-	dev->clipimagemask = fz_drawclipimagemask;
-	dev->fillimage = fz_drawfillimage;
-	dev->fillshade = fz_drawfillshade;
+	dev->fill_image_mask = fz_draw_fill_image_mask;
+	dev->clip_image_mask = fz_draw_clip_image_mask;
+	dev->fill_image = fz_draw_fill_image;
+	dev->fill_shade = fz_draw_fill_shade;
 
-	dev->popclip = fz_drawpopclip;
+	dev->pop_clip = fz_draw_pop_clip;
 
-	dev->beginmask = fz_drawbeginmask;
-	dev->endmask = fz_drawendmask;
-	dev->begingroup = fz_drawbegingroup;
-	dev->endgroup = fz_drawendgroup;
+	dev->begin_mask = fz_draw_begin_mask;
+	dev->end_mask = fz_draw_end_mask;
+	dev->begin_group = fz_draw_begin_group;
+	dev->end_group = fz_draw_end_group;
 
-	dev->begintile = fz_drawbegintile;
-	dev->endtile = fz_drawendtile;
+	dev->begin_tile = fz_draw_begin_tile;
+	dev->end_tile = fz_draw_end_tile;
 
 	return dev;
 }
diff --git a/fitz/dev_list.c b/fitz/dev_list.c
index 2bba6ed3..d9293dc4 100644
--- a/fitz/dev_list.c
+++ b/fitz/dev_list.c
@@ -3,24 +3,24 @@
 #define ISOLATED 1
 #define KNOCKOUT 2
 
-static fz_displaynode *
-fz_newdisplaynode(fz_displaycommand cmd, fz_matrix ctm,
+static fz_display_node *
+fz_new_display_node(fz_display_command cmd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
+	fz_display_node *node;
 	int i;
 
-	node = fz_malloc(sizeof(fz_displaynode));
+	node = fz_malloc(sizeof(fz_display_node));
 	node->cmd = cmd;
-	node->next = nil;
-	node->rect = fz_emptyrect;
-	node->item.path = nil;
-	node->stroke = nil;
+	node->next = NULL;
+	node->rect = fz_empty_rect;
+	node->item.path = NULL;
+	node->stroke = NULL;
 	node->flag = 0;
 	node->ctm = ctm;
 	if (colorspace)
 	{
-		node->colorspace = fz_keepcolorspace(colorspace);
+		node->colorspace = fz_keep_colorspace(colorspace);
 		if (color)
 		{
 			for (i = 0; i < node->colorspace->n; i++)
@@ -29,23 +29,23 @@ fz_newdisplaynode(fz_displaycommand cmd, fz_matrix ctm,
 	}
 	else
 	{
-		node->colorspace = nil;
+		node->colorspace = NULL;
 	}
 	node->alpha = alpha;
 
 	return node;
 }
 
-static fz_strokestate *
-fz_clonestrokestate(fz_strokestate *stroke)
+static fz_stroke_state *
+fz_clone_stroke_state(fz_stroke_state *stroke)
 {
-	fz_strokestate *newstroke = fz_malloc(sizeof(fz_strokestate));
+	fz_stroke_state *newstroke = fz_malloc(sizeof(fz_stroke_state));
 	*newstroke = *stroke;
 	return newstroke;
 }
 
 static void
-fz_appenddisplaynode(fz_displaylist *list, fz_displaynode *node)
+fz_append_display_node(fz_display_list *list, fz_display_node *node)
 {
 	if (!list->first)
 	{
@@ -60,244 +60,244 @@ fz_appenddisplaynode(fz_displaylist *list, fz_displaynode *node)
 }
 
 static void
-fz_freedisplaynode(fz_displaynode *node)
+fz_free_display_node(fz_display_node *node)
 {
 	switch (node->cmd)
 	{
-	case FZ_CMDFILLPATH:
-	case FZ_CMDSTROKEPATH:
-	case FZ_CMDCLIPPATH:
-	case FZ_CMDCLIPSTROKEPATH:
-		fz_freepath(node->item.path);
+	case FZ_CMD_FILL_PATH:
+	case FZ_CMD_STROKE_PATH:
+	case FZ_CMD_CLIP_PATH:
+	case FZ_CMD_CLIP_STROKE_PATH:
+		fz_free_path(node->item.path);
 		break;
-	case FZ_CMDFILLTEXT:
-	case FZ_CMDSTROKETEXT:
-	case FZ_CMDCLIPTEXT:
-	case FZ_CMDCLIPSTROKETEXT:
-	case FZ_CMDIGNORETEXT:
-		fz_freetext(node->item.text);
+	case FZ_CMD_FILL_TEXT:
+	case FZ_CMD_STROKE_TEXT:
+	case FZ_CMD_CLIP_TEXT:
+	case FZ_CMD_CLIP_STROKE_TEXT:
+	case FZ_CMD_IGNORE_TEXT:
+		fz_free_text(node->item.text);
 		break;
-	case FZ_CMDFILLSHADE:
-		fz_dropshade(node->item.shade);
+	case FZ_CMD_FILL_SHADE:
+		fz_drop_shade(node->item.shade);
 		break;
-	case FZ_CMDFILLIMAGE:
-	case FZ_CMDFILLIMAGEMASK:
-	case FZ_CMDCLIPIMAGEMASK:
-		fz_droppixmap(node->item.image);
+	case FZ_CMD_FILL_IMAGE:
+	case FZ_CMD_FILL_IMAGE_MASK:
+	case FZ_CMD_CLIP_IMAGE_MASK:
+		fz_drop_pixmap(node->item.image);
 		break;
-	case FZ_CMDPOPCLIP:
-	case FZ_CMDBEGINMASK:
-	case FZ_CMDENDMASK:
-	case FZ_CMDBEGINGROUP:
-	case FZ_CMDENDGROUP:
-	case FZ_CMDBEGINTILE:
-	case FZ_CMDENDTILE:
+	case FZ_CMD_POP_CLIP:
+	case FZ_CMD_BEGIN_MASK:
+	case FZ_CMD_END_MASK:
+	case FZ_CMD_BEGIN_GROUP:
+	case FZ_CMD_END_GROUP:
+	case FZ_CMD_BEGIN_TILE:
+	case FZ_CMD_END_TILE:
 		break;
 	}
 	if (node->stroke)
 		fz_free(node->stroke);
 	if (node->colorspace)
-		fz_dropcolorspace(node->colorspace);
+		fz_drop_colorspace(node->colorspace);
 	fz_free(node);
 }
 
 static void
-fz_listfillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm,
+fz_list_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDFILLPATH, ctm, colorspace, color, alpha);
-	node->rect = fz_boundpath(path, nil, ctm);
-	node->item.path = fz_clonepath(path);
-	node->flag = evenodd;
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_FILL_PATH, ctm, colorspace, color, alpha);
+	node->rect = fz_bound_path(path, NULL, ctm);
+	node->item.path = fz_clone_path(path);
+	node->flag = even_odd;
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_liststrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm,
+fz_list_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDSTROKEPATH, ctm, colorspace, color, alpha);
-	node->rect = fz_boundpath(path, stroke, ctm);
-	node->item.path = fz_clonepath(path);
-	node->stroke = fz_clonestrokestate(stroke);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_STROKE_PATH, ctm, colorspace, color, alpha);
+	node->rect = fz_bound_path(path, stroke, ctm);
+	node->item.path = fz_clone_path(path);
+	node->stroke = fz_clone_stroke_state(stroke);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm)
+fz_list_clip_path(void *user, fz_path *path, int even_odd, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDCLIPPATH, ctm, nil, nil, 0);
-	node->rect = fz_boundpath(path, nil, ctm);
-	node->item.path = fz_clonepath(path);
-	node->flag = evenodd;
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_CLIP_PATH, ctm, NULL, NULL, 0);
+	node->rect = fz_bound_path(path, NULL, ctm);
+	node->item.path = fz_clone_path(path);
+	node->flag = even_odd;
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
+fz_list_clip_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDCLIPSTROKEPATH, ctm, nil, nil, 0);
-	node->rect = fz_boundpath(path, stroke, ctm);
-	node->item.path = fz_clonepath(path);
-	node->stroke = fz_clonestrokestate(stroke);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_CLIP_STROKE_PATH, ctm, NULL, NULL, 0);
+	node->rect = fz_bound_path(path, stroke, ctm);
+	node->item.path = fz_clone_path(path);
+	node->stroke = fz_clone_stroke_state(stroke);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listfilltext(void *user, fz_text *text, fz_matrix ctm,
+fz_list_fill_text(void *user, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDFILLTEXT, ctm, colorspace, color, alpha);
-	node->rect = fz_boundtext(text, ctm);
-	node->item.text = fz_clonetext(text);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_FILL_TEXT, ctm, colorspace, color, alpha);
+	node->rect = fz_bound_text(text, ctm);
+	node->item.text = fz_clone_text(text);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_liststroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm,
+fz_list_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDSTROKETEXT, ctm, colorspace, color, alpha);
-	node->rect = fz_boundtext(text, ctm);
-	node->item.text = fz_clonetext(text);
-	node->stroke = fz_clonestrokestate(stroke);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_STROKE_TEXT, ctm, colorspace, color, alpha);
+	node->rect = fz_bound_text(text, ctm);
+	node->item.text = fz_clone_text(text);
+	node->stroke = fz_clone_stroke_state(stroke);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
+fz_list_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDCLIPTEXT, ctm, nil, nil, 0);
-	node->rect = fz_boundtext(text, ctm);
-	node->item.text = fz_clonetext(text);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_CLIP_TEXT, ctm, NULL, NULL, 0);
+	node->rect = fz_bound_text(text, ctm);
+	node->item.text = fz_clone_text(text);
 	node->flag = accumulate;
 	/* when accumulating, be conservative about culling */
 	if (accumulate)
-		node->rect = fz_infiniterect;
-	fz_appenddisplaynode(user, node);
+		node->rect = fz_infinite_rect;
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm)
+fz_list_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDCLIPSTROKETEXT, ctm, nil, nil, 0);
-	node->rect = fz_boundtext(text, ctm);
-	node->item.text = fz_clonetext(text);
-	node->stroke = fz_clonestrokestate(stroke);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_CLIP_STROKE_TEXT, ctm, NULL, NULL, 0);
+	node->rect = fz_bound_text(text, ctm);
+	node->item.text = fz_clone_text(text);
+	node->stroke = fz_clone_stroke_state(stroke);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listignoretext(void *user, fz_text *text, fz_matrix ctm)
+fz_list_ignore_text(void *user, fz_text *text, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDIGNORETEXT, ctm, nil, nil, 0);
-	node->rect = fz_boundtext(text, ctm);
-	node->item.text = fz_clonetext(text);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_IGNORE_TEXT, ctm, NULL, NULL, 0);
+	node->rect = fz_bound_text(text, ctm);
+	node->item.text = fz_clone_text(text);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listpopclip(void *user)
+fz_list_pop_clip(void *user)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDPOPCLIP, fz_identity, nil, nil, 0);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_POP_CLIP, fz_identity, NULL, NULL, 0);
 	/* TODO: scan back for matching pushclip and calculate bbox of contents */
-	fz_appenddisplaynode(user, node);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_list_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDFILLSHADE, ctm, nil, nil, alpha);
-	node->rect = fz_boundshade(shade, ctm);
-	node->item.shade = fz_keepshade(shade);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha);
+	node->rect = fz_bound_shade(shade, ctm);
+	node->item.shade = fz_keep_shade(shade);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
+fz_list_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDFILLIMAGE, ctm, nil, nil, alpha);
-	node->rect = fz_transformrect(ctm, fz_unitrect);
-	node->item.image = fz_keeppixmap(image);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha);
+	node->rect = fz_transform_rect(ctm, fz_unit_rect);
+	node->item.image = fz_keep_pixmap(image);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listfillimagemask(void *user, fz_pixmap *image, fz_matrix ctm,
+fz_list_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDFILLIMAGEMASK, ctm, colorspace, color, alpha);
-	node->rect = fz_transformrect(ctm, fz_unitrect);
-	node->item.image = fz_keeppixmap(image);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha);
+	node->rect = fz_transform_rect(ctm, fz_unit_rect);
+	node->item.image = fz_keep_pixmap(image);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
+fz_list_clip_image_mask(void *user, fz_pixmap *image, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDCLIPIMAGEMASK, ctm, nil, nil, 0);
-	node->rect = fz_transformrect(ctm, fz_unitrect);
-	node->item.image = fz_keeppixmap(image);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0);
+	node->rect = fz_transform_rect(ctm, fz_unit_rect);
+	node->item.image = fz_keep_pixmap(image);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listbeginmask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *color)
+fz_list_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *color)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDBEGINMASK, fz_identity, colorspace, color, 0);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_BEGIN_MASK, fz_identity, colorspace, color, 0);
 	node->rect = rect;
 	node->flag = luminosity;
-	fz_appenddisplaynode(user, node);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listendmask(void *user)
+fz_list_end_mask(void *user)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDENDMASK, fz_identity, nil, nil, 0);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_END_MASK, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listbegingroup(void *user, fz_rect rect, int isolated, int knockout, fz_blendmode blendmode, float alpha)
+fz_list_begin_group(void *user, fz_rect rect, int isolated, int knockout, fz_blendmode blendmode, float alpha)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDBEGINGROUP, fz_identity, nil, nil, alpha);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_BEGIN_GROUP, fz_identity, NULL, NULL, alpha);
 	node->rect = rect;
 	node->item.blendmode = blendmode;
 	node->flag |= isolated ? ISOLATED : 0;
 	node->flag |= knockout ? KNOCKOUT : 0;
-	fz_appenddisplaynode(user, node);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listendgroup(void *user)
+fz_list_end_group(void *user)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDENDGROUP, fz_identity, nil, nil, 0);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_END_GROUP, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listbegintile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_list_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDBEGINTILE, ctm, nil, nil, 0);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0);
 	node->rect = area;
 	node->color[0] = xstep;
 	node->color[1] = ystep;
@@ -305,82 +305,82 @@ fz_listbegintile(void *user, fz_rect area, fz_rect view, float xstep, float yste
 	node->color[3] = view.y0;
 	node->color[4] = view.x1;
 	node->color[5] = view.y1;
-	fz_appenddisplaynode(user, node);
+	fz_append_display_node(user, node);
 }
 
 static void
-fz_listendtile(void *user)
+fz_list_end_tile(void *user)
 {
-	fz_displaynode *node;
-	node = fz_newdisplaynode(FZ_CMDENDTILE, fz_identity, nil, nil, 0);
-	fz_appenddisplaynode(user, node);
+	fz_display_node *node;
+	node = fz_new_display_node(FZ_CMD_END_TILE, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(user, node);
 }
 
 fz_device *
-fz_newlistdevice(fz_displaylist *list)
+fz_new_list_device(fz_display_list *list)
 {
-	fz_device *dev = fz_newdevice(list);
+	fz_device *dev = fz_new_device(list);
 
-	dev->fillpath = fz_listfillpath;
-	dev->strokepath = fz_liststrokepath;
-	dev->clippath = fz_listclippath;
-	dev->clipstrokepath = fz_listclipstrokepath;
+	dev->fill_path = fz_list_fill_path;
+	dev->stroke_path = fz_list_stroke_path;
+	dev->clip_path = fz_list_clip_path;
+	dev->clip_stroke_path = fz_list_clip_stroke_path;
 
-	dev->filltext = fz_listfilltext;
-	dev->stroketext = fz_liststroketext;
-	dev->cliptext = fz_listcliptext;
-	dev->clipstroketext = fz_listclipstroketext;
-	dev->ignoretext = fz_listignoretext;
+	dev->fill_text = fz_list_fill_text;
+	dev->stroke_text = fz_list_stroke_text;
+	dev->clip_text = fz_list_clip_text;
+	dev->clip_stroke_text = fz_list_clip_stroke_text;
+	dev->ignore_text = fz_list_ignore_text;
 
-	dev->fillshade = fz_listfillshade;
-	dev->fillimage = fz_listfillimage;
-	dev->fillimagemask = fz_listfillimagemask;
-	dev->clipimagemask = fz_listclipimagemask;
+	dev->fill_shade = fz_list_fill_shade;
+	dev->fill_image = fz_list_fill_image;
+	dev->fill_image_mask = fz_list_fill_image_mask;
+	dev->clip_image_mask = fz_list_clip_image_mask;
 
-	dev->popclip = fz_listpopclip;
+	dev->pop_clip = fz_list_pop_clip;
 
-	dev->beginmask = fz_listbeginmask;
-	dev->endmask = fz_listendmask;
-	dev->begingroup = fz_listbegingroup;
-	dev->endgroup = fz_listendgroup;
+	dev->begin_mask = fz_list_begin_mask;
+	dev->end_mask = fz_list_end_mask;
+	dev->begin_group = fz_list_begin_group;
+	dev->end_group = fz_list_end_group;
 
-	dev->begintile = fz_listbegintile;
-	dev->endtile = fz_listendtile;
+	dev->begin_tile = fz_list_begin_tile;
+	dev->end_tile = fz_list_end_tile;
 
 	return dev;
 }
 
-fz_displaylist *
-fz_newdisplaylist(void)
+fz_display_list *
+fz_new_display_list(void)
 {
-	fz_displaylist *list = fz_malloc(sizeof(fz_displaylist));
-	list->first = nil;
-	list->last = nil;
+	fz_display_list *list = fz_malloc(sizeof(fz_display_list));
+	list->first = NULL;
+	list->last = NULL;
 	return list;
 }
 
 void
-fz_freedisplaylist(fz_displaylist *list)
+fz_free_display_list(fz_display_list *list)
 {
-	fz_displaynode *node = list->first;
+	fz_display_node *node = list->first;
 	while (node)
 	{
-		fz_displaynode *next = node->next;
-		fz_freedisplaynode(node);
+		fz_display_node *next = node->next;
+		fz_free_display_node(node);
 		node = next;
 	}
 	fz_free(list);
 }
 
 void
-fz_executedisplaylist(fz_displaylist *list, fz_device *dev, fz_matrix topctm, fz_bbox bounds)
+fz_execute_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_bbox bounds)
 {
-	fz_displaynode *node;
+	fz_display_node *node;
 	fz_rect bbox;
 	int clipped = 0;
 	int tiled = 0;
 
-	if (!fz_isinfinitebbox(bounds))
+	if (!fz_is_infinite_bbox(bounds))
 	{
 		/* add some fuzz at the edges, as especially glyph rects
 		 * are sometimes not actually completely bounding the glyph */
@@ -390,40 +390,40 @@ fz_executedisplaylist(fz_displaylist *list, fz_device *dev, fz_matrix topctm, fz
 
 	for (node = list->first; node; node = node->next)
 	{
-		fz_matrix ctm = fz_concat(node->ctm, topctm);
-		fz_rect rect = fz_transformrect(topctm, node->rect);
+		fz_matrix ctm = fz_concat(node->ctm, top_ctm);
+		fz_rect rect = fz_transform_rect(top_ctm, node->rect);
 
 		/* never skip tiles */
 		if (tiled)
 			goto visible;
 
 		/* cull objects to draw using a quick visibility test */
-		if (clipped || fz_isemptybbox(fz_intersectbbox(fz_roundrect(rect), bounds)))
+		if (clipped || fz_is_empty_bbox(fz_intersect_bbox(fz_round_rect(rect), bounds)))
 		{
 			switch (node->cmd)
 			{
-			case FZ_CMDBEGINTILE:
+			case FZ_CMD_BEGIN_TILE:
 				tiled++;
 				goto visible;
-			case FZ_CMDENDTILE:
+			case FZ_CMD_END_TILE:
 				tiled--;
 				goto visible;
-			case FZ_CMDCLIPPATH:
-			case FZ_CMDCLIPSTROKEPATH:
-			case FZ_CMDCLIPTEXT:
-			case FZ_CMDCLIPSTROKETEXT:
-			case FZ_CMDCLIPIMAGEMASK:
-			case FZ_CMDBEGINMASK:
-			case FZ_CMDBEGINGROUP:
+			case FZ_CMD_CLIP_PATH:
+			case FZ_CMD_CLIP_STROKE_PATH:
+			case FZ_CMD_CLIP_TEXT:
+			case FZ_CMD_CLIP_STROKE_TEXT:
+			case FZ_CMD_CLIP_IMAGE_MASK:
+			case FZ_CMD_BEGIN_MASK:
+			case FZ_CMD_BEGIN_GROUP:
 				clipped++;
 				continue;
-			case FZ_CMDPOPCLIP:
-			case FZ_CMDENDGROUP:
+			case FZ_CMD_POP_CLIP:
+			case FZ_CMD_END_GROUP:
 				if (!clipped)
 					goto visible;
 				clipped--;
 				continue;
-			case FZ_CMDENDMASK:
+			case FZ_CMD_END_MASK:
 				if (!clipped)
 					goto visible;
 				continue;
@@ -435,79 +435,79 @@ fz_executedisplaylist(fz_displaylist *list, fz_device *dev, fz_matrix topctm, fz
 visible:
 		switch (node->cmd)
 		{
-		case FZ_CMDFILLPATH:
-			dev->fillpath(dev->user, node->item.path, node->flag, ctm,
+		case FZ_CMD_FILL_PATH:
+			dev->fill_path(dev->user, node->item.path, node->flag, ctm,
 				node->colorspace, node->color, node->alpha);
 			break;
-		case FZ_CMDSTROKEPATH:
-			dev->strokepath(dev->user, node->item.path, node->stroke, ctm,
+		case FZ_CMD_STROKE_PATH:
+			dev->stroke_path(dev->user, node->item.path, node->stroke, ctm,
 				node->colorspace, node->color, node->alpha);
 			break;
-		case FZ_CMDCLIPPATH:
-			dev->clippath(dev->user, node->item.path, node->flag, ctm);
+		case FZ_CMD_CLIP_PATH:
+			dev->clip_path(dev->user, node->item.path, node->flag, ctm);
 			break;
-		case FZ_CMDCLIPSTROKEPATH:
-			dev->clipstrokepath(dev->user, node->item.path, node->stroke, ctm);
+		case FZ_CMD_CLIP_STROKE_PATH:
+			dev->clip_stroke_path(dev->user, node->item.path, node->stroke, ctm);
 			break;
-		case FZ_CMDFILLTEXT:
-			dev->filltext(dev->user, node->item.text, ctm,
+		case FZ_CMD_FILL_TEXT:
+			dev->fill_text(dev->user, node->item.text, ctm,
 				node->colorspace, node->color, node->alpha);
 			break;
-		case FZ_CMDSTROKETEXT:
-			dev->stroketext(dev->user, node->item.text, node->stroke, ctm,
+		case FZ_CMD_STROKE_TEXT:
+			dev->stroke_text(dev->user, node->item.text, node->stroke, ctm,
 				node->colorspace, node->color, node->alpha);
 			break;
-		case FZ_CMDCLIPTEXT:
-			dev->cliptext(dev->user, node->item.text, ctm, node->flag);
+		case FZ_CMD_CLIP_TEXT:
+			dev->clip_text(dev->user, node->item.text, ctm, node->flag);
 			break;
-		case FZ_CMDCLIPSTROKETEXT:
-			dev->clipstroketext(dev->user, node->item.text, node->stroke, ctm);
+		case FZ_CMD_CLIP_STROKE_TEXT:
+			dev->clip_stroke_text(dev->user, node->item.text, node->stroke, ctm);
 			break;
-		case FZ_CMDIGNORETEXT:
-			dev->ignoretext(dev->user, node->item.text, ctm);
+		case FZ_CMD_IGNORE_TEXT:
+			dev->ignore_text(dev->user, node->item.text, ctm);
 			break;
-		case FZ_CMDFILLSHADE:
-			dev->fillshade(dev->user, node->item.shade, ctm, node->alpha);
+		case FZ_CMD_FILL_SHADE:
+			dev->fill_shade(dev->user, node->item.shade, ctm, node->alpha);
 			break;
-		case FZ_CMDFILLIMAGE:
-			dev->fillimage(dev->user, node->item.image, ctm, node->alpha);
+		case FZ_CMD_FILL_IMAGE:
+			dev->fill_image(dev->user, node->item.image, ctm, node->alpha);
 			break;
-		case FZ_CMDFILLIMAGEMASK:
-			dev->fillimagemask(dev->user, node->item.image, ctm,
+		case FZ_CMD_FILL_IMAGE_MASK:
+			dev->fill_image_mask(dev->user, node->item.image, ctm,
 				node->colorspace, node->color, node->alpha);
 			break;
-		case FZ_CMDCLIPIMAGEMASK:
-			dev->clipimagemask(dev->user, node->item.image, ctm);
+		case FZ_CMD_CLIP_IMAGE_MASK:
+			dev->clip_image_mask(dev->user, node->item.image, ctm);
 			break;
-		case FZ_CMDPOPCLIP:
-			dev->popclip(dev->user);
+		case FZ_CMD_POP_CLIP:
+			dev->pop_clip(dev->user);
 			break;
-		case FZ_CMDBEGINMASK:
-			bbox = fz_transformrect(topctm, node->rect);
-			dev->beginmask(dev->user, bbox, node->flag, node->colorspace, node->color);
+		case FZ_CMD_BEGIN_MASK:
+			bbox = fz_transform_rect(top_ctm, node->rect);
+			dev->begin_mask(dev->user, bbox, node->flag, node->colorspace, node->color);
 			break;
-		case FZ_CMDENDMASK:
-			dev->endmask(dev->user);
+		case FZ_CMD_END_MASK:
+			dev->end_mask(dev->user);
 			break;
-		case FZ_CMDBEGINGROUP:
-			bbox = fz_transformrect(topctm, node->rect);
-			dev->begingroup(dev->user, bbox,
+		case FZ_CMD_BEGIN_GROUP:
+			bbox = fz_transform_rect(top_ctm, node->rect);
+			dev->begin_group(dev->user, bbox,
 				node->flag & ISOLATED, node->flag & KNOCKOUT,
 				node->item.blendmode, node->alpha);
 			break;
-		case FZ_CMDENDGROUP:
-			dev->endgroup(dev->user);
+		case FZ_CMD_END_GROUP:
+			dev->end_group(dev->user);
 			break;
-		case FZ_CMDBEGINTILE:
+		case FZ_CMD_BEGIN_TILE:
 			bbox.x0 = node->color[2];
 			bbox.y0 = node->color[3];
 			bbox.x1 = node->color[4];
 			bbox.y1 = node->color[5];
-			dev->begintile(dev->user, node->rect, bbox,
+			dev->begin_tile(dev->user, node->rect, bbox,
 				node->color[0], node->color[1], ctm);
 			break;
-		case FZ_CMDENDTILE:
-			dev->endtile(dev->user);
+		case FZ_CMD_END_TILE:
+			dev->end_tile(dev->user);
 			break;
 		}
 	}
diff --git a/fitz/dev_null.c b/fitz/dev_null.c
index 2d20a966..dcb43292 100644
--- a/fitz/dev_null.c
+++ b/fitz/dev_null.c
@@ -1,29 +1,29 @@
 #include "fitz.h"
 
-static void fz_nullfreeuser(void *user) {}
-static void fz_nullfillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
-static void fz_nullstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
-static void fz_nullclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm) {}
-static void fz_nullclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm) {}
-static void fz_nullfilltext(void *user, fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
-static void fz_nullstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
-static void fz_nullcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate) {}
-static void fz_nullclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm) {}
-static void fz_nullignoretext(void *user, fz_text *text, fz_matrix ctm) {}
-static void fz_nullpopclip(void *user) {}
-static void fz_nullfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) {}
-static void fz_nullfillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) {}
-static void fz_nullfillimagemask(void *user, fz_pixmap *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
-static void fz_nullclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm) {}
-static void fz_nullbeginmask(void *user, fz_rect r, int luminosity, fz_colorspace *colorspace, float *bc) {}
-static void fz_nullendmask(void *user) {}
-static void fz_nullbegingroup(void *user, fz_rect r, int isolated, int knockout, fz_blendmode blendmode, float alpha) {}
-static void fz_nullendgroup(void *user) {}
-static void fz_nullbegintile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm) {}
-static void fz_nullendtile(void *user) {}
+static void fz_null_free_user(void *user) {}
+static void fz_null_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
+static void fz_null_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
+static void fz_null_clip_path(void *user, fz_path *path, int even_odd, fz_matrix ctm) {}
+static void fz_null_clip_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm) {}
+static void fz_null_fill_text(void *user, fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
+static void fz_null_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
+static void fz_null_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate) {}
+static void fz_null_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm) {}
+static void fz_null_ignore_text(void *user, fz_text *text, fz_matrix ctm) {}
+static void fz_null_pop_clip(void *user) {}
+static void fz_null_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) {}
+static void fz_null_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) {}
+static void fz_null_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) {}
+static void fz_null_clip_image_mask(void *user, fz_pixmap *image, fz_matrix ctm) {}
+static void fz_null_begin_mask(void *user, fz_rect r, int luminosity, fz_colorspace *colorspace, float *bc) {}
+static void fz_null_end_mask(void *user) {}
+static void fz_null_begin_group(void *user, fz_rect r, int isolated, int knockout, fz_blendmode blendmode, float alpha) {}
+static void fz_null_end_group(void *user) {}
+static void fz_null_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm) {}
+static void fz_null_end_tile(void *user) {}
 
 fz_device *
-fz_newdevice(void *user)
+fz_new_device(void *user)
 {
 	fz_device *dev = fz_malloc(sizeof(fz_device));
 	memset(dev, 0, sizeof(fz_device));
@@ -31,41 +31,41 @@ fz_newdevice(void *user)
 	dev->hints = 0;
 
 	dev->user = user;
-	dev->freeuser = fz_nullfreeuser;
+	dev->free_user = fz_null_free_user;
 
-	dev->fillpath = fz_nullfillpath;
-	dev->strokepath = fz_nullstrokepath;
-	dev->clippath = fz_nullclippath;
-	dev->clipstrokepath = fz_nullclipstrokepath;
+	dev->fill_path = fz_null_fill_path;
+	dev->stroke_path = fz_null_stroke_path;
+	dev->clip_path = fz_null_clip_path;
+	dev->clip_stroke_path = fz_null_clip_stroke_path;
 
-	dev->filltext = fz_nullfilltext;
-	dev->stroketext = fz_nullstroketext;
-	dev->cliptext = fz_nullcliptext;
-	dev->clipstroketext = fz_nullclipstroketext;
-	dev->ignoretext = fz_nullignoretext;
+	dev->fill_text = fz_null_fill_text;
+	dev->stroke_text = fz_null_stroke_text;
+	dev->clip_text = fz_null_clip_text;
+	dev->clip_stroke_text = fz_null_clip_stroke_text;
+	dev->ignore_text = fz_null_ignore_text;
 
-	dev->fillshade = fz_nullfillshade;
-	dev->fillimage = fz_nullfillimage;
-	dev->fillimagemask = fz_nullfillimagemask;
-	dev->clipimagemask = fz_nullclipimagemask;
+	dev->fill_shade = fz_null_fill_shade;
+	dev->fill_image = fz_null_fill_image;
+	dev->fill_image_mask = fz_null_fill_image_mask;
+	dev->clip_image_mask = fz_null_clip_image_mask;
 
-	dev->popclip = fz_nullpopclip;
+	dev->pop_clip = fz_null_pop_clip;
 
-	dev->beginmask = fz_nullbeginmask;
-	dev->endmask = fz_nullendmask;
-	dev->begingroup = fz_nullbegingroup;
-	dev->endgroup = fz_nullendgroup;
+	dev->begin_mask = fz_null_begin_mask;
+	dev->end_mask = fz_null_end_mask;
+	dev->begin_group = fz_null_begin_group;
+	dev->end_group = fz_null_end_group;
 
-	dev->begintile = fz_nullbegintile;
-	dev->endtile = fz_nullendtile;
+	dev->begin_tile = fz_null_begin_tile;
+	dev->end_tile = fz_null_end_tile;
 
 	return dev;
 }
 
 void
-fz_freedevice(fz_device *dev)
+fz_free_device(fz_device *dev)
 {
-	if (dev->freeuser)
-		dev->freeuser(dev->user);
+	if (dev->free_user)
+		dev->free_user(dev->user);
 	fz_free(dev);
 }
diff --git a/fitz/dev_text.c b/fitz/dev_text.c
index c59a36f7..139c3eed 100644
--- a/fitz/dev_text.c
+++ b/fitz/dev_text.c
@@ -1,55 +1,55 @@
 #include "fitz.h"
 
-#define LINEDIST 0.9f
-#define SPACEDIST 0.2f
+#define LINE_DIST 0.9f
+#define SPACE_DIST 0.2f
 
 #include <ft2build.h>
 #include FT_FREETYPE_H
 #include FT_ADVANCES_H
 
-typedef struct fz_textdevice_s fz_textdevice;
+typedef struct fz_text_device_s fz_text_device;
 
-struct fz_textdevice_s
+struct fz_text_device_s
 {
 	fz_point point;
-	fz_textspan *head;
-	fz_textspan *span;
+	fz_text_span *head;
+	fz_text_span *span;
 };
 
-fz_textspan *
-fz_newtextspan(void)
+fz_text_span *
+fz_new_text_span(void)
 {
-	fz_textspan *span;
-	span = fz_malloc(sizeof(fz_textspan));
-	span->font = nil;
+	fz_text_span *span;
+	span = fz_malloc(sizeof(fz_text_span));
+	span->font = NULL;
 	span->wmode = 0;
 	span->size = 0;
 	span->len = 0;
 	span->cap = 0;
-	span->text = nil;
-	span->next = nil;
+	span->text = NULL;
+	span->next = NULL;
 	span->eol = 0;
 	return span;
 }
 
 void
-fz_freetextspan(fz_textspan *span)
+fz_free_text_span(fz_text_span *span)
 {
 	if (span->font)
-		fz_dropfont(span->font);
+		fz_drop_font(span->font);
 	if (span->next)
-		fz_freetextspan(span->next);
+		fz_free_text_span(span->next);
 	fz_free(span->text);
 	fz_free(span);
 }
 
 static void
-fz_addtextcharimp(fz_textspan *span, int c, fz_bbox bbox)
+fz_add_text_char_imp(fz_text_span *span, int c, fz_bbox bbox)
 {
 	if (span->len + 1 >= span->cap)
 	{
 		span->cap = span->cap > 1 ? (span->cap * 3) / 2 : 80;
-		span->text = fz_realloc(span->text, span->cap, sizeof(fz_textchar));
+		span->text = fz_realloc(span->text, span->cap, sizeof(fz_text_char));
 	}
 	span->text[span->len].c = c;
 	span->text[span->len].bbox = bbox;
@@ -57,7 +57,7 @@ fz_addtextcharimp(fz_textspan *span, int c, fz_bbox bbox)
 }
 
 static fz_bbox
-fz_splitbbox(fz_bbox bbox, int i, int n)
+fz_split_bbox(fz_bbox bbox, int i, int n)
 {
 	float w = (float)(bbox.x1 - bbox.x0) / n;
 	float x0 = bbox.x0;
@@ -67,20 +67,20 @@ fz_splitbbox(fz_bbox bbox, int i, int n)
 }
 
 static void
-fz_addtextchar(fz_textspan **last, fz_font *font, float size, int wmode, int c, fz_bbox bbox)
+fz_add_text_char(fz_text_span **last, fz_font *font, float size, int wmode, int c, fz_bbox bbox)
 {
-	fz_textspan *span = *last;
+	fz_text_span *span = *last;
 
 	if (!span->font)
 	{
-		span->font = fz_keepfont(font);
+		span->font = fz_keep_font(font);
 		span->size = size;
 	}
 
 	if ((span->font != font || span->size != size || span->wmode != wmode) && c != 32)
 	{
-		span = fz_newtextspan();
-		span->font = fz_keepfont(font);
+		span = fz_new_text_span();
+		span->font = fz_keep_font(font);
 		span->size = size;
 		span->wmode = wmode;
 		(*last)->next = span;
@@ -92,55 +92,55 @@ fz_addtextchar(fz_textspan **last, fz_font *font, float size, int wmode, int c,
 	case -1: /* ignore when one unicode character maps to multiple glyphs */
 		break;
 	case 0xFB00: /* ff */
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 0, 2));
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 1, 2));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 0, 2));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 1, 2));
 		break;
 	case 0xFB01: /* fi */
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 0, 2));
-		fz_addtextcharimp(span, 'i', fz_splitbbox(bbox, 1, 2));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 0, 2));
+		fz_add_text_char_imp(span, 'i', fz_split_bbox(bbox, 1, 2));
 		break;
 	case 0xFB02: /* fl */
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 0, 2));
-		fz_addtextcharimp(span, 'l', fz_splitbbox(bbox, 1, 2));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 0, 2));
+		fz_add_text_char_imp(span, 'l', fz_split_bbox(bbox, 1, 2));
 		break;
 	case 0xFB03: /* ffi */
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 0, 3));
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 1, 3));
-		fz_addtextcharimp(span, 'i', fz_splitbbox(bbox, 2, 3));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 0, 3));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 1, 3));
+		fz_add_text_char_imp(span, 'i', fz_split_bbox(bbox, 2, 3));
 		break;
 	case 0xFB04: /* ffl */
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 0, 3));
-		fz_addtextcharimp(span, 'f', fz_splitbbox(bbox, 1, 3));
-		fz_addtextcharimp(span, 'l', fz_splitbbox(bbox, 2, 3));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 0, 3));
+		fz_add_text_char_imp(span, 'f', fz_split_bbox(bbox, 1, 3));
+		fz_add_text_char_imp(span, 'l', fz_split_bbox(bbox, 2, 3));
 		break;
 	case 0xFB05: /* long st */
 	case 0xFB06: /* st */
-		fz_addtextcharimp(span, 's', fz_splitbbox(bbox, 0, 2));
-		fz_addtextcharimp(span, 't', fz_splitbbox(bbox, 1, 2));
+		fz_add_text_char_imp(span, 's', fz_split_bbox(bbox, 0, 2));
+		fz_add_text_char_imp(span, 't', fz_split_bbox(bbox, 1, 2));
 		break;
 	default:
-		fz_addtextcharimp(span, c, bbox);
+		fz_add_text_char_imp(span, c, bbox);
 		break;
 	}
 }
 
 static void
-fz_dividetextchars(fz_textspan **last, int n, fz_bbox bbox)
+fz_divide_text_chars(fz_text_span **last, int n, fz_bbox bbox)
 {
-	fz_textspan *span = *last;
+	fz_text_span *span = *last;
 	int i, x;
 	x = span->len - n;
 	if (x >= 0)
 		for (i = 0; i < n; i++)
-			span->text[x + i].bbox = fz_splitbbox(bbox, i, n);
+			span->text[x + i].bbox = fz_split_bbox(bbox, i, n);
 }
 
 static void
-fz_addtextnewline(fz_textspan **last, fz_font *font, float size, int wmode)
+fz_add_text_newline(fz_text_span **last, fz_font *font, float size, int wmode)
 {
-	fz_textspan *span;
-	span = fz_newtextspan();
-	span->font = fz_keepfont(font);
+	fz_text_span *span;
+	span = fz_new_text_span();
+	span->font = fz_keep_font(font);
 	span->size = size;
 	span->wmode = wmode;
 	(*last)->eol = 1;
@@ -149,7 +149,7 @@ fz_addtextnewline(fz_textspan **last, fz_font *font, float size, int wmode)
 }
 
 void
-fz_debugtextspanxml(fz_textspan *span)
+fz_debug_text_span_xml(fz_text_span *span)
 {
 	char buf[10];
 	int c, n, k, i;
@@ -179,11 +179,11 @@ fz_debugtextspanxml(fz_textspan *span)
 	printf("</span>\n");
 
 	if (span->next)
-		fz_debugtextspanxml(span->next);
+		fz_debug_text_span_xml(span->next);
 }
 
 void
-fz_debugtextspan(fz_textspan *span)
+fz_debug_text_span(fz_text_span *span)
 {
 	char buf[10];
 	int c, n, k, i;
@@ -205,14 +205,14 @@ fz_debugtextspan(fz_textspan *span)
 		putchar('\n');
 
 	if (span->next)
-		fz_debugtextspan(span->next);
+		fz_debug_text_span(span->next);
 }
 
 static void
-fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *pen)
+fz_text_extract_span(fz_text_span **last, fz_text *text, fz_matrix ctm, fz_point *pen)
 {
 	fz_font *font = text->font;
-	FT_Face face = font->ftface;
+	FT_Face face = font->ft_face;
 	fz_matrix tm = text->trm;
 	fz_matrix trm;
 	float size;
@@ -229,16 +229,16 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 	if (text->len == 0)
 		return;
 
-	if (font->ftface)
+	if (font->ft_face)
 	{
-		err = FT_Set_Char_Size(font->ftface, 64, 64, 72, 72);
+		err = FT_Set_Char_Size(font->ft_face, 64, 64, 72, 72);
 		if (err)
-			fz_warn("freetype set character size: %s", ft_errorstring(err));
+			fz_warn("freetype set character size: %s", ft_error_string(err));
 		ascender = (float)face->ascender / face->units_per_EM;
 		descender = (float)face->descender / face->units_per_EM;
 	}
 
-	rect = fz_emptyrect;
+	rect = fz_empty_rect;
 
 	if (text->wmode == 0)
 	{
@@ -254,29 +254,29 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 	tm.e = 0;
 	tm.f = 0;
 	trm = fz_concat(tm, ctm);
-	dir = fz_transformvector(trm, dir);
+	dir = fz_transform_vector(trm, dir);
 	dist = sqrtf(dir.x * dir.x + dir.y * dir.y);
 	ndir.x = dir.x / dist;
 	ndir.y = dir.y / dist;
 
-	size = fz_matrixexpansion(trm);
+	size = fz_matrix_expansion(trm);
 
 	multi = 1;
 
 	for (i = 0; i < text->len; i++)
 	{
-		if (text->els[i].gid < 0)
+		if (text->items[i].gid < 0)
 		{
-			fz_addtextchar(last, font, size, text->wmode, text->els[i].ucs, fz_roundrect(rect));
+			fz_add_text_char(last, font, size, text->wmode, text->items[i].ucs, fz_round_rect(rect));
 			multi ++;
-			fz_dividetextchars(last, multi, fz_roundrect(rect));
+			fz_divide_text_chars(last, multi, fz_round_rect(rect));
 			continue;
 		}
 		multi = 1;
 
 		/* Calculate new pen location and delta */
-		tm.e = text->els[i].x;
-		tm.f = text->els[i].y;
+		tm.e = text->items[i].x;
+		tm.f = text->items[i].y;
 		trm = fz_concat(tm, ctm);
 
 		delta.x = pen->x - trm.e;
@@ -293,11 +293,11 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 			ndelta.y = delta.y / dist;
 			dot = ndelta.x * ndir.x + ndelta.y * ndir.y;
 
-			if (dist > size * LINEDIST)
+			if (dist > size * LINE_DIST)
 			{
-				fz_addtextnewline(last, font, size, text->wmode);
+				fz_add_text_newline(last, font, size, text->wmode);
 			}
-			else if (fabsf(dot) > 0.95f && dist > size * SPACEDIST)
+			else if (fabsf(dot) > 0.95f && dist > size * SPACE_DIST)
 			{
 				if ((*last)->len > 0 && (*last)->text[(*last)->len - 1].c != ' ')
 				{
@@ -306,14 +306,14 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 					spacerect.y0 = 0;
 					spacerect.x1 = 0;
 					spacerect.y1 = 1;
-					spacerect = fz_transformrect(trm, spacerect);
-					fz_addtextchar(last, font, size, text->wmode, ' ', fz_roundrect(spacerect));
+					spacerect = fz_transform_rect(trm, spacerect);
+					fz_add_text_char(last, font, size, text->wmode, ' ', fz_round_rect(spacerect));
 				}
 			}
 		}
 
 		/* Calculate bounding box and new pen position based on font metrics */
-		if (font->ftface)
+		if (font->ft_face)
 		{
 			FT_Fixed ftadv = 0;
 			int mask = FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING | FT_LOAD_IGNORE_TRANSFORM;
@@ -321,7 +321,7 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 			/* TODO: freetype returns broken vertical metrics */
 			/* if (text->wmode) mask |= FT_LOAD_VERTICAL_LAYOUT; */
 
-			FT_Get_Advance(font->ftface, text->els[i].gid, mask, &ftadv);
+			FT_Get_Advance(font->ft_face, text->items[i].gid, mask, &ftadv);
 			adv = ftadv / 65536.0f;
 
 			rect.x0 = 0;
@@ -331,62 +331,62 @@ fz_textextractspan(fz_textspan **last, fz_text *text, fz_matrix ctm, fz_point *p
 		}
 		else
 		{
-			adv = font->t3widths[text->els[i].gid];
+			adv = font->t3widths[text->items[i].gid];
 			rect.x0 = 0;
 			rect.y0 = descender;
 			rect.x1 = adv;
 			rect.y1 = ascender;
 		}
 
-		rect = fz_transformrect(trm, rect);
+		rect = fz_transform_rect(trm, rect);
 		pen->x = trm.e + dir.x * adv;
 		pen->y = trm.f + dir.y * adv;
 
-		fz_addtextchar(last, font, size, text->wmode, text->els[i].ucs, fz_roundrect(rect));
+		fz_add_text_char(last, font, size, text->wmode, text->items[i].ucs, fz_round_rect(rect));
 	}
 }
 
 static void
-fz_textfilltext(void *user, fz_text *text, fz_matrix ctm,
+fz_text_fill_text(void *user, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_textdevice *tdev = user;
-	fz_textextractspan(&tdev->span, text, ctm, &tdev->point);
+	fz_text_device *tdev = user;
+	fz_text_extract_span(&tdev->span, text, ctm, &tdev->point);
 }
 
 static void
-fz_textstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm,
+fz_text_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	fz_textdevice *tdev = user;
-	fz_textextractspan(&tdev->span, text, ctm, &tdev->point);
+	fz_text_device *tdev = user;
+	fz_text_extract_span(&tdev->span, text, ctm, &tdev->point);
 }
 
 static void
-fz_textcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
+fz_text_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 {
-	fz_textdevice *tdev = user;
-	fz_textextractspan(&tdev->span, text, ctm, &tdev->point);
+	fz_text_device *tdev = user;
+	fz_text_extract_span(&tdev->span, text, ctm, &tdev->point);
 }
 
 static void
-fz_textclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm)
+fz_text_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	fz_textdevice *tdev = user;
-	fz_textextractspan(&tdev->span, text, ctm, &tdev->point);
+	fz_text_device *tdev = user;
+	fz_text_extract_span(&tdev->span, text, ctm, &tdev->point);
 }
 
 static void
-fz_textignoretext(void *user, fz_text *text, fz_matrix ctm)
+fz_text_ignore_text(void *user, fz_text *text, fz_matrix ctm)
 {
-	fz_textdevice *tdev = user;
-	fz_textextractspan(&tdev->span, text, ctm, &tdev->point);
+	fz_text_device *tdev = user;
+	fz_text_extract_span(&tdev->span, text, ctm, &tdev->point);
 }
 
 static void
-fz_textfreeuser(void *user)
+fz_text_free_user(void *user)
 {
-	fz_textdevice *tdev = user;
+	fz_text_device *tdev = user;
 
 	tdev->span->eol = 1;
 
@@ -397,22 +397,22 @@ fz_textfreeuser(void *user)
 }
 
 fz_device *
-fz_newtextdevice(fz_textspan *root)
+fz_new_text_device(fz_text_span *root)
 {
 	fz_device *dev;
-	fz_textdevice *tdev = fz_malloc(sizeof(fz_textdevice));
+	fz_text_device *tdev = fz_malloc(sizeof(fz_text_device));
 	tdev->head = root;
 	tdev->span = root;
 	tdev->point.x = -1;
 	tdev->point.y = -1;
 
-	dev = fz_newdevice(tdev);
-	dev->hints = FZ_IGNOREIMAGE | FZ_IGNORESHADE;
-	dev->freeuser = fz_textfreeuser;
-	dev->filltext = fz_textfilltext;
-	dev->stroketext = fz_textstroketext;
-	dev->cliptext = fz_textcliptext;
-	dev->clipstroketext = fz_textclipstroketext;
-	dev->ignoretext = fz_textignoretext;
+	dev = fz_new_device(tdev);
+	dev->hints = FZ_IGNORE_IMAGE | FZ_IGNORE_SHADE;
+	dev->free_user = fz_text_free_user;
+	dev->fill_text = fz_text_fill_text;
+	dev->stroke_text = fz_text_stroke_text;
+	dev->clip_text = fz_text_clip_text;
+	dev->clip_stroke_text = fz_text_clip_stroke_text;
+	dev->ignore_text = fz_text_ignore_text;
 	return dev;
 }
diff --git a/fitz/dev_trace.c b/fitz/dev_trace.c
index f8a94b43..2bc171de 100644
--- a/fitz/dev_trace.c
+++ b/fitz/dev_trace.c
@@ -1,14 +1,14 @@
 #include "fitz.h"
 
 static void
-fz_tracematrix(fz_matrix ctm)
+fz_trace_matrix(fz_matrix ctm)
 {
 	printf("matrix=\"%g %g %g %g %g %g\" ",
 		ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f);
 }
 
 static void
-fz_tracecolor(fz_colorspace *colorspace, float *color, float alpha)
+fz_trace_color(fz_colorspace *colorspace, float *color, float alpha)
 {
 	int i;
 	printf("colorspace=\"%s\" color=\"", colorspace->name);
@@ -20,7 +20,7 @@ fz_tracecolor(fz_colorspace *colorspace, float *color, float alpha)
 }
 
 static void
-fz_tracepath(fz_path *path, int indent)
+fz_trace_path(fz_path *path, int indent)
 {
 	float x, y;
 	int i = 0;
@@ -29,30 +29,30 @@ fz_tracepath(fz_path *path, int indent)
 	{
 		for (n = 0; n < indent; n++)
 			putchar(' ');
-		switch (path->els[i++].k)
+		switch (path->items[i++].k)
 		{
 		case FZ_MOVETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("<moveto x=\"%g\" y=\"%g\" />\n", x, y);
 			break;
 		case FZ_LINETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("<lineto x=\"%g\" y=\"%g\" />\n", x, y);
 			break;
 		case FZ_CURVETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("<curveto x1=\"%g\" y1=\"%g\" ", x, y);
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("x2=\"%g\" y2=\"%g\" ", x, y);
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("x3=\"%g\" y3=\"%g\" />\n", x, y);
 			break;
-		case FZ_CLOSEPATH:
+		case FZ_CLOSE_PATH:
 			printf("<closepath />\n");
 			break;
 		}
@@ -60,245 +60,245 @@ fz_tracepath(fz_path *path, int indent)
 }
 
 static void
-fz_tracefillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm,
+fz_trace_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	printf("<fillpath ");
-	if (evenodd)
+	printf("<fill_path ");
+	if (even_odd)
 		printf("winding=\"eofill\" ");
 	else
 		printf("winding=\"nonzero\" ");
-	fz_tracecolor(colorspace, color, alpha);
-	fz_tracematrix(ctm);
+	fz_trace_color(colorspace, color, alpha);
+	fz_trace_matrix(ctm);
 	printf(">\n");
-	fz_tracepath(path, 0);
-	printf("</fillpath>\n");
+	fz_trace_path(path, 0);
+	printf("</fill_path>\n");
 }
 
 static void
-fz_tracestrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm,
+fz_trace_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	int i;
 
-	printf("<strokepath ");
+	printf("<stroke_path ");
 	printf("linewidth=\"%g\" ", stroke->linewidth);
 	printf("miterlimit=\"%g\" ", stroke->miterlimit);
 	printf("linecap=\"%d\" ", stroke->linecap);
 	printf("linejoin=\"%d\" ", stroke->linejoin);
 
-	if (stroke->dashlen)
+	if (stroke->dash_len)
 	{
-		printf("dashphase=\"%g\" dash=\"", stroke->dashphase);
-		for (i = 0; i < stroke->dashlen; i++)
-			printf("%g ", stroke->dashlist[i]);
+		printf("dash_phase=\"%g\" dash=\"", stroke->dash_phase);
+		for (i = 0; i < stroke->dash_len; i++)
+			printf("%g ", stroke->dash_list[i]);
 		printf("\"");
 	}
 
-	fz_tracecolor(colorspace, color, alpha);
-	fz_tracematrix(ctm);
+	fz_trace_color(colorspace, color, alpha);
+	fz_trace_matrix(ctm);
 	printf(">\n");
 
-	fz_tracepath(path, 0);
+	fz_trace_path(path, 0);
 
-	printf("</strokepath>\n");
+	printf("</stroke_path>\n");
 }
 
 static void
-fz_traceclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm)
+fz_trace_clip_path(void *user, fz_path *path, int even_odd, fz_matrix ctm)
 {
-	printf("<clippath ");
-	if (evenodd)
+	printf("<clip_path ");
+	if (even_odd)
 		printf("winding=\"eofill\" ");
 	else
 		printf("winding=\"nonzero\" ");
-	fz_tracematrix(ctm);
+	fz_trace_matrix(ctm);
 	printf(">\n");
-	fz_tracepath(path, 0);
-	printf("</clippath>\n");
+	fz_trace_path(path, 0);
+	printf("</clip_path>\n");
 }
 
 static void
-fz_traceclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
+fz_trace_clip_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	printf("<clipstrokepath ");
-	fz_tracematrix(ctm);
+	printf("<clip_stroke_path ");
+	fz_trace_matrix(ctm);
 	printf(">\n");
-	fz_tracepath(path, 0);
-	printf("</clipstrokepath>\n");
+	fz_trace_path(path, 0);
+	printf("</clip_stroke_path>\n");
 }
 
 static void
-fz_tracefilltext(void *user, fz_text *text, fz_matrix ctm,
+fz_trace_fill_text(void *user, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	printf("<filltext font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
-	fz_tracecolor(colorspace, color, alpha);
-	fz_tracematrix(fz_concat(ctm, text->trm));
+	printf("<fill_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
+	fz_trace_color(colorspace, color, alpha);
+	fz_trace_matrix(fz_concat(ctm, text->trm));
 	printf(">\n");
-	fz_debugtext(text, 0);
-	printf("</filltext>\n");
+	fz_debug_text(text, 0);
+	printf("</fill_text>\n");
 }
 
 static void
-fz_tracestroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm,
+fz_trace_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
-	printf("<stroketext font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
-	fz_tracecolor(colorspace, color, alpha);
-	fz_tracematrix(fz_concat(ctm, text->trm));
+	printf("<stroke_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
+	fz_trace_color(colorspace, color, alpha);
+	fz_trace_matrix(fz_concat(ctm, text->trm));
 	printf(">\n");
-	fz_debugtext(text, 0);
-	printf("</stroketext>\n");
+	fz_debug_text(text, 0);
+	printf("</stroke_text>\n");
 }
 
 static void
-fz_tracecliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
+fz_trace_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
 {
-	printf("<cliptext font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
+	printf("<clip_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
 	printf("accumulate=\"%d\" ", accumulate);
-	fz_tracematrix(fz_concat(ctm, text->trm));
+	fz_trace_matrix(fz_concat(ctm, text->trm));
 	printf(">\n");
-	fz_debugtext(text, 0);
-	printf("</cliptext>\n");
+	fz_debug_text(text, 0);
+	printf("</clip_text>\n");
 }
 
 static void
-fz_traceclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm)
+fz_trace_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
 {
-	printf("<clipstroketext font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
-	fz_tracematrix(fz_concat(ctm, text->trm));
+	printf("<clip_stroke_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
+	fz_trace_matrix(fz_concat(ctm, text->trm));
 	printf(">\n");
-	fz_debugtext(text, 0);
-	printf("</clipstroketext>\n");
+	fz_debug_text(text, 0);
+	printf("</clip_stroke_text>\n");
 }
 
 static void
-fz_traceignoretext(void *user, fz_text *text, fz_matrix ctm)
+fz_trace_ignore_text(void *user, fz_text *text, fz_matrix ctm)
 {
-	printf("<ignoretext font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
-	fz_tracematrix(fz_concat(ctm, text->trm));
+	printf("<ignore_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
+	fz_trace_matrix(fz_concat(ctm, text->trm));
 	printf(">\n");
-	fz_debugtext(text, 0);
-	printf("</ignoretext>\n");
+	fz_debug_text(text, 0);
+	printf("</ignore_text>\n");
 }
 
 static void
-fz_tracefillimage(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
+fz_trace_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
 {
-	printf("<fillimage alpha=\"%g\" ", alpha);
-	fz_tracematrix(ctm);
+	printf("<fill_image alpha=\"%g\" ", alpha);
+	fz_trace_matrix(ctm);
 	printf("/>\n");
 }
 
 static void
-fz_tracefillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_trace_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
 {
-	printf("<fillshade alpha=\"%g\" ", alpha);
-	fz_tracematrix(ctm);
+	printf("<fill_shade alpha=\"%g\" ", alpha);
+	fz_trace_matrix(ctm);
 	printf("/>\n");
 }
 
 static void
-fz_tracefillimagemask(void *user, fz_pixmap *image, fz_matrix ctm,
+fz_trace_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
 fz_colorspace *colorspace, float *color, float alpha)
 {
-	printf("<fillimagemask ");
-	fz_tracematrix(ctm);
-	fz_tracecolor(colorspace, color, alpha);
+	printf("<fill_image_mask ");
+	fz_trace_matrix(ctm);
+	fz_trace_color(colorspace, color, alpha);
 	printf("/>\n");
 }
 
 static void
-fz_traceclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
+fz_trace_clip_image_mask(void *user, fz_pixmap *image, fz_matrix ctm)
 {
-	printf("<clipimagemask ");
-	fz_tracematrix(ctm);
+	printf("<clip_image_mask ");
+	fz_trace_matrix(ctm);
 	printf("/>\n");
 }
 
 static void
-fz_tracepopclip(void *user)
+fz_trace_pop_clip(void *user)
 {
-	printf("<popclip />\n");
+	printf("<pop_clip />\n");
 }
 
 static void
-fz_tracebeginmask(void *user, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
+fz_trace_begin_mask(void *user, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
 {
 	printf("<mask bbox=\"%g %g %g %g\" s=\"%s\" ",
 		bbox.x0, bbox.y0, bbox.x1, bbox.y1,
 		luminosity ? "luminosity" : "alpha");
-//	fz_tracecolor(colorspace, color, 1);
+//	fz_trace_color(colorspace, color, 1);
 	printf(">\n");
 }
 
 static void
-fz_traceendmask(void *user)
+fz_trace_end_mask(void *user)
 {
 	printf("</mask>\n");
 }
 
 static void
-fz_tracebegingroup(void *user, fz_rect bbox, int isolated, int knockout, fz_blendmode blendmode, float alpha)
+fz_trace_begin_group(void *user, fz_rect bbox, int isolated, int knockout, fz_blendmode blendmode, float alpha)
 {
 	printf("<group bbox=\"%g %g %g %g\" isolated=\"%d\" knockout=\"%d\" blendmode=\"%s\" alpha=\"%g\">\n",
 		bbox.x0, bbox.y0, bbox.x1, bbox.y1,
-		isolated, knockout, fz_blendnames[blendmode], alpha);
+		isolated, knockout, fz_blendmode_names[blendmode], alpha);
 }
 
 static void
-fz_traceendgroup(void *user)
+fz_trace_end_group(void *user)
 {
 	printf("</group>\n");
 }
 
 static void
-fz_tracebegintile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_trace_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
 {
 	printf("<tile ");
 	printf("area=\"%g %g %g %g\" ", area.x0, area.y0, area.x1, area.y1);
 	printf("view=\"%g %g %g %g\" ", view.x0, view.y0, view.x1, view.y1);
 	printf("xstep=\"%g\" ystep=\"%g\" ", xstep, ystep);
-	fz_tracematrix(ctm);
+	fz_trace_matrix(ctm);
 	printf(">\n");
 }
 
 static void
-fz_traceendtile(void *user)
+fz_trace_end_tile(void *user)
 {
 	printf("</tile>\n");
 }
 
-fz_device *fz_newtracedevice(void)
+fz_device *fz_new_trace_device(void)
 {
-	fz_device *dev = fz_newdevice(nil);
+	fz_device *dev = fz_new_device(NULL);
 
-	dev->fillpath = fz_tracefillpath;
-	dev->strokepath = fz_tracestrokepath;
-	dev->clippath = fz_traceclippath;
-	dev->clipstrokepath = fz_traceclipstrokepath;
+	dev->fill_path = fz_trace_fill_path;
+	dev->stroke_path = fz_trace_stroke_path;
+	dev->clip_path = fz_trace_clip_path;
+	dev->clip_stroke_path = fz_trace_clip_stroke_path;
 
-	dev->filltext = fz_tracefilltext;
-	dev->stroketext = fz_tracestroketext;
-	dev->cliptext = fz_tracecliptext;
-	dev->clipstroketext = fz_traceclipstroketext;
-	dev->ignoretext = fz_traceignoretext;
+	dev->fill_text = fz_trace_fill_text;
+	dev->stroke_text = fz_trace_stroke_text;
+	dev->clip_text = fz_trace_clip_text;
+	dev->clip_stroke_text = fz_trace_clip_stroke_text;
+	dev->ignore_text = fz_trace_ignore_text;
 
-	dev->fillshade = fz_tracefillshade;
-	dev->fillimage = fz_tracefillimage;
-	dev->fillimagemask = fz_tracefillimagemask;
-	dev->clipimagemask = fz_traceclipimagemask;
+	dev->fill_shade = fz_trace_fill_shade;
+	dev->fill_image = fz_trace_fill_image;
+	dev->fill_image_mask = fz_trace_fill_image_mask;
+	dev->clip_image_mask = fz_trace_clip_image_mask;
 
-	dev->popclip = fz_tracepopclip;
+	dev->pop_clip = fz_trace_pop_clip;
 
-	dev->beginmask = fz_tracebeginmask;
-	dev->endmask = fz_traceendmask;
-	dev->begingroup = fz_tracebegingroup;
-	dev->endgroup = fz_traceendgroup;
+	dev->begin_mask = fz_trace_begin_mask;
+	dev->end_mask = fz_trace_end_mask;
+	dev->begin_group = fz_trace_begin_group;
+	dev->end_group = fz_trace_end_group;
 
-	dev->begintile = fz_tracebegintile;
-	dev->endtile = fz_traceendtile;
+	dev->begin_tile = fz_trace_begin_tile;
+	dev->end_tile = fz_trace_end_tile;
 
 	return dev;
 }
diff --git a/fitz/filt_basic.c b/fitz/filt_basic.c
index 221d0846..391f06ab 100644
--- a/fitz/filt_basic.c
+++ b/fitz/filt_basic.c
@@ -3,23 +3,23 @@
 /* Pretend we have a filter that just copies data forever */
 
 fz_stream *
-fz_opencopy(fz_stream *chain)
+fz_open_copy(fz_stream *chain)
 {
-	return fz_keepstream(chain);
+	return fz_keep_stream(chain);
 }
 
 /* Null filter copies a specified amount of data */
 
-struct nullfilter
+struct null_filter
 {
 	fz_stream *chain;
 	int remain;
 };
 
 static int
-readnull(fz_stream *stm, unsigned char *buf, int len)
+read_null(fz_stream *stm, unsigned char *buf, int len)
 {
-	struct nullfilter *state = stm->state;
+	struct null_filter *state = stm->state;
 	int amount = MIN(len, state->remain);
 	int n = fz_read(state->chain, buf, amount);
 	if (n < 0)
@@ -29,23 +29,23 @@ readnull(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closenull(fz_stream *stm)
+close_null(fz_stream *stm)
 {
-	struct nullfilter *state = stm->state;
+	struct null_filter *state = stm->state;
 	fz_close(state->chain);
 	fz_free(state);
 }
 
 fz_stream *
-fz_opennull(fz_stream *chain, int len)
+fz_open_null(fz_stream *chain, int len)
 {
-	struct nullfilter *state;
+	struct null_filter *state;
 
-	state = fz_malloc(sizeof(struct nullfilter));
+	state = fz_malloc(sizeof(struct null_filter));
 	state->chain = chain;
 	state->remain = len;
 
-	return fz_newstream(state, readnull, closenull);
+	return fz_new_stream(state, read_null, close_null);
 }
 
 /* ASCII Hex Decode */
@@ -75,7 +75,7 @@ static inline int ishex(int a)
 		(a >= '0' && a <= '9');
 }
 
-static inline int fromhex(int a)
+static inline int from_hex(int a)
 {
 	if (a >= 'A' && a <= 'F')
 		return a - 'A' + 0xA;
@@ -87,7 +87,7 @@ static inline int fromhex(int a)
 }
 
 static int
-readahxd(fz_stream *stm, unsigned char *buf, int len)
+read_ahxd(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_ahxd *state = stm->state;
 	unsigned char *p = buf;
@@ -101,7 +101,7 @@ readahxd(fz_stream *stm, unsigned char *buf, int len)
 		if (state->eod)
 			return p - buf;
 
-		c = fz_readbyte(state->chain);
+		c = fz_read_byte(state->chain);
 		if (c < 0)
 			return p - buf;
 
@@ -109,12 +109,12 @@ readahxd(fz_stream *stm, unsigned char *buf, int len)
 		{
 			if (!odd)
 			{
-				a = fromhex(c);
+				a = from_hex(c);
 				odd = 1;
 			}
 			else
 			{
-				b = fromhex(c);
+				b = from_hex(c);
 				*p++ = (a << 4) | b;
 				odd = 0;
 			}
@@ -135,7 +135,7 @@ readahxd(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closeahxd(fz_stream *stm)
+close_ahxd(fz_stream *stm)
 {
 	fz_ahxd *state = stm->state;
 	fz_close(state->chain);
@@ -143,7 +143,7 @@ closeahxd(fz_stream *stm)
 }
 
 fz_stream *
-fz_openahxd(fz_stream *chain)
+fz_open_ahxd(fz_stream *chain)
 {
 	fz_ahxd *state;
 
@@ -151,7 +151,7 @@ fz_openahxd(fz_stream *chain)
 	state->chain = chain;
 	state->eod = 0;
 
-	return fz_newstream(state, readahxd, closeahxd);
+	return fz_new_stream(state, read_ahxd, close_ahxd);
 }
 
 /* ASCII 85 Decode */
@@ -167,7 +167,7 @@ struct fz_a85d_s
 };
 
 static int
-reada85d(fz_stream *stm, unsigned char *buf, int len)
+read_a85d(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_a85d *state = stm->state;
 	unsigned char *p = buf;
@@ -184,7 +184,7 @@ reada85d(fz_stream *stm, unsigned char *buf, int len)
 		if (state->eod)
 			return p - buf;
 
-		c = fz_readbyte(state->chain);
+		c = fz_read_byte(state->chain);
 		if (c < 0)
 			return p - buf;
 
@@ -223,7 +223,7 @@ reada85d(fz_stream *stm, unsigned char *buf, int len)
 
 		else if (c == '~')
 		{
-			c = fz_readbyte(state->chain);
+			c = fz_read_byte(state->chain);
 			if (c != '>')
 				fz_warn("bad eod marker in a85d");
 
@@ -270,7 +270,7 @@ reada85d(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closea85d(fz_stream *stm)
+close_a85d(fz_stream *stm)
 {
 	fz_a85d *state = stm->state;
 	fz_close(state->chain);
@@ -278,7 +278,7 @@ closea85d(fz_stream *stm)
 }
 
 fz_stream *
-fz_opena85d(fz_stream *chain)
+fz_open_a85d(fz_stream *chain)
 {
 	fz_a85d *state;
 
@@ -288,7 +288,7 @@ fz_opena85d(fz_stream *chain)
 	state->wp = state->bp;
 	state->eod = 0;
 
-	return fz_newstream(state, reada85d, closea85d);
+	return fz_new_stream(state, read_a85d, close_a85d);
 }
 
 /* Run Length Decode */
@@ -302,7 +302,7 @@ struct fz_rld_s
 };
 
 static int
-readrld(fz_stream *stm, unsigned char *buf, int len)
+read_rld(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_rld *state = stm->state;
 	unsigned char *p = buf;
@@ -315,7 +315,7 @@ readrld(fz_stream *stm, unsigned char *buf, int len)
 
 		if (state->n == 0)
 		{
-			state->run = fz_readbyte(state->chain);
+			state->run = fz_read_byte(state->chain);
 			if (state->run < 0)
 				state->run = 128;
 			if (state->run < 128)
@@ -323,7 +323,7 @@ readrld(fz_stream *stm, unsigned char *buf, int len)
 			if (state->run > 128)
 			{
 				state->n = 257 - state->run;
-				state->c = fz_readbyte(state->chain);
+				state->c = fz_read_byte(state->chain);
 				if (state->c < 0)
 					return fz_throw("premature end of data in run length decode");
 			}
@@ -333,7 +333,7 @@ readrld(fz_stream *stm, unsigned char *buf, int len)
 		{
 			while (p < ep && state->n)
 			{
-				int c = fz_readbyte(state->chain);
+				int c = fz_read_byte(state->chain);
 				if (c < 0)
 					return fz_throw("premature end of data in run length decode");
 				*p++ = c;
@@ -355,7 +355,7 @@ readrld(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closerld(fz_stream *stm)
+close_rld(fz_stream *stm)
 {
 	fz_rld *state = stm->state;
 	fz_close(state->chain);
@@ -363,7 +363,7 @@ closerld(fz_stream *stm)
 }
 
 fz_stream *
-fz_openrld(fz_stream *chain)
+fz_open_rld(fz_stream *chain)
 {
 	fz_rld *state;
 
@@ -373,7 +373,7 @@ fz_openrld(fz_stream *chain)
 	state->n = 0;
 	state->c = 0;
 
-	return fz_newstream(state, readrld, closerld);
+	return fz_new_stream(state, read_rld, close_rld);
 }
 
 /* RC4 Filter */
@@ -387,7 +387,7 @@ struct fz_arc4c_s
 };
 
 static int
-readarc4(fz_stream *stm, unsigned char *buf, int len)
+read_arc4(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_arc4c *state = stm->state;
 	int n;
@@ -396,13 +396,13 @@ readarc4(fz_stream *stm, unsigned char *buf, int len)
 	if (n < 0)
 		return fz_rethrow(n, "read error in arc4 filter");
 
-	fz_arc4encrypt(&state->arc4, buf, buf, n);
+	fz_arc4_encrypt(&state->arc4, buf, buf, n);
 
 	return n;
 }
 
 static void
-closearc4(fz_stream *stm)
+close_arc4(fz_stream *stm)
 {
 	fz_arc4c *state = stm->state;
 	fz_close(state->chain);
@@ -410,15 +410,15 @@ closearc4(fz_stream *stm)
 }
 
 fz_stream *
-fz_openarc4(fz_stream *chain, unsigned char *key, unsigned keylen)
+fz_open_arc4(fz_stream *chain, unsigned char *key, unsigned keylen)
 {
 	fz_arc4c *state;
 
 	state = fz_malloc(sizeof(fz_arc4c));
 	state->chain = chain;
-	fz_arc4init(&state->arc4, key, keylen);
+	fz_arc4_init(&state->arc4, key, keylen);
 
-	return fz_newstream(state, readarc4, closearc4);
+	return fz_new_stream(state, read_arc4, close_arc4);
 }
 
 /* AES Filter */
@@ -436,7 +436,7 @@ struct fz_aesd_s
 };
 
 static int
-readaesd(fz_stream *stm, unsigned char *buf, int len)
+read_aesd(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_aesd *state = stm->state;
 	unsigned char *p = buf;
@@ -444,7 +444,7 @@ readaesd(fz_stream *stm, unsigned char *buf, int len)
 
 	while (state->ivcount < 16)
 	{
-		int c = fz_readbyte(state->chain);
+		int c = fz_read_byte(state->chain);
 		if (c < 0)
 			return fz_throw("premature end in aes filter");
 		state->iv[state->ivcount++] = c;
@@ -468,7 +468,7 @@ readaesd(fz_stream *stm, unsigned char *buf, int len)
 		state->wp = state->bp + 16;
 
 		/* strip padding at end of file */
-		if (fz_iseof(state->chain))
+		if (fz_is_eof(state->chain))
 		{
 			int pad = state->bp[15];
 			if (pad < 1 || pad > 16)
@@ -484,7 +484,7 @@ readaesd(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closeaesd(fz_stream *stm)
+close_aesd(fz_stream *stm)
 {
 	fz_aesd *state = stm->state;
 	fz_close(state->chain);
@@ -492,7 +492,7 @@ closeaesd(fz_stream *stm)
 }
 
 fz_stream *
-fz_openaesd(fz_stream *chain, unsigned char *key, unsigned keylen)
+fz_open_aesd(fz_stream *chain, unsigned char *key, unsigned keylen)
 {
 	fz_aesd *state;
 
@@ -503,5 +503,5 @@ fz_openaesd(fz_stream *chain, unsigned char *key, unsigned keylen)
 	state->rp = state->bp;
 	state->wp = state->bp;
 
-	return fz_newstream(state, readaesd, closeaesd);
+	return fz_new_stream(state, read_aesd, close_aesd);
 }
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 05c3db4d..0e24b794 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -8,7 +8,7 @@ typedef struct fz_dctd_s fz_dctd;
 struct fz_dctd_s
 {
 	fz_stream *chain;
-	int colortransform;
+	int color_transform;
 	int init;
 	int stride;
 	unsigned char *scanline;
@@ -44,7 +44,7 @@ static boolean fill_input_buffer(j_decompress_ptr cinfo)
 	fz_stream *chain = state->chain;
 
 	chain->rp = chain->wp;
-	fz_fillbuffer(chain);
+	fz_fill_buffer(chain);
 	src->next_input_byte = chain->rp;
 	src->bytes_in_buffer = chain->wp - chain->rp;
 
@@ -75,7 +75,7 @@ static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
 }
 
 static int
-readdctd(fz_stream *stm, unsigned char *buf, int len)
+read_dctd(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_dctd *state = stm->state;
 	j_decompress_ptr cinfo = &state->cinfo;
@@ -113,28 +113,28 @@ readdctd(fz_stream *stm, unsigned char *buf, int len)
 		cinfo->do_fancy_upsampling = FALSE;
 
 		/* default value if ColorTransform is not set */
-		if (state->colortransform == -1)
+		if (state->color_transform == -1)
 		{
 			if (state->cinfo.num_components == 3)
-				state->colortransform = 1;
+				state->color_transform = 1;
 			else
-				state->colortransform = 0;
+				state->color_transform = 0;
 		}
 
 		if (cinfo->saw_Adobe_marker)
-			state->colortransform = cinfo->Adobe_transform;
+			state->color_transform = cinfo->Adobe_transform;
 
 		/* Guess the input colorspace, and set output colorspace accordingly */
 		switch (cinfo->num_components)
 		{
 		case 3:
-			if (state->colortransform)
+			if (state->color_transform)
 				cinfo->jpeg_color_space = JCS_YCbCr;
 			else
 				cinfo->jpeg_color_space = JCS_RGB;
 			break;
 		case 4:
-			if (state->colortransform)
+			if (state->color_transform)
 				cinfo->jpeg_color_space = JCS_YCCK;
 			else
 				cinfo->jpeg_color_space = JCS_CMYK;
@@ -179,7 +179,7 @@ readdctd(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closedctd(fz_stream *stm)
+close_dctd(fz_stream *stm)
 {
 	fz_dctd *state = stm->state;
 
@@ -202,7 +202,7 @@ skip:
 }
 
 fz_stream *
-fz_opendctd(fz_stream *chain, fz_obj *params)
+fz_open_dctd(fz_stream *chain, fz_obj *params)
 {
 	fz_dctd *state;
 	fz_obj *obj;
@@ -210,12 +210,12 @@ fz_opendctd(fz_stream *chain, fz_obj *params)
 	state = fz_malloc(sizeof(fz_dctd));
 	memset(state, 0, sizeof(fz_dctd));
 	state->chain = chain;
-	state->colortransform = -1; /* unset */
+	state->color_transform = -1; /* unset */
 	state->init = 0;
 
-	obj = fz_dictgets(params, "ColorTransform");
+	obj = fz_dict_gets(params, "ColorTransform");
 	if (obj)
-		state->colortransform = fz_toint(obj);
+		state->color_transform = fz_to_int(obj);
 
-	return fz_newstream(state, readdctd, closedctd);
+	return fz_new_stream(state, read_dctd, close_dctd);
 }
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index 714629e7..97076f89 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -171,7 +171,7 @@ const cfd_node cf_uncompressed_decode[] = {
 /* bit magic */
 
 static inline void
-printbits(FILE *f, int code, int nbits)
+print_bits(FILE *f, int code, int nbits)
 {
 	int n, b;
 	for (n = nbits - 1; n >= 0; n--)
@@ -188,7 +188,7 @@ getbit(const unsigned char *buf, int x)
 }
 
 static inline void
-printline(FILE *f, unsigned char *line, int w)
+print_line(FILE *f, unsigned char *line, int w)
 {
 	int i;
 	for (i = 0; i < w; i++)
@@ -197,7 +197,7 @@ printline(FILE *f, unsigned char *line, int w)
 }
 
 static inline int
-findchanging(const unsigned char *line, int x, int w)
+find_changing(const unsigned char *line, int x, int w)
 {
 	int a, b;
 
@@ -227,15 +227,15 @@ findchanging(const unsigned char *line, int x, int w)
 }
 
 static inline int
-findchangingcolor(const unsigned char *line, int x, int w, int color)
+find_changing_color(const unsigned char *line, int x, int w, int color)
 {
 	if (!line)
 		return w;
 
-	x = findchanging(line, x, w);
+	x = find_changing(line, x, w);
 
 	if (x < w && getbit(line, x) != color)
-		x = findchanging(line, x, w);
+		x = find_changing(line, x, w);
 
 	return x;
 }
@@ -278,11 +278,11 @@ typedef struct fz_faxd_s fz_faxd;
 
 enum
 {
-	SNORMAL,	/* neutral state, waiting for any code */
-	SMAKEUP,	/* got a 1d makeup code, waiting for terminating code */
-	SEOL,		/* at eol, needs output buffer space */
-	SH1, SH2,	/* in H part 1 and 2 (both makeup and terminating codes) */
-	SDONE		/* all done */
+	STATE_NORMAL,	/* neutral state, waiting for any code */
+	STATE_MAKEUP,	/* got a 1d makeup code, waiting for terminating code */
+	STATE_EOL,		/* at eol, needs output buffer space */
+	STATE_H1, STATE_H2,	/* in H part 1 and 2 (both makeup and terminating codes) */
+	STATE_DONE		/* all done */
 };
 
 struct fz_faxd_s
@@ -290,12 +290,12 @@ struct fz_faxd_s
 	fz_stream *chain;
 
 	int k;
-	int endofline;
-	int encodedbytealign;
+	int end_of_line;
+	int encoded_byte_align;
 	int columns;
 	int rows;
-	int endofblock;
-	int blackis1;
+	int end_of_block;
+	int black_is_1;
 
 	int stride;
 	int ridx;
@@ -312,18 +312,18 @@ struct fz_faxd_s
 };
 
 static inline void
-eatbits(fz_faxd *fax, int nbits)
+eat_bits(fz_faxd *fax, int nbits)
 {
 	fax->word <<= nbits;
 	fax->bidx += nbits;
 }
 
 static inline int
-fillbits(fz_faxd *fax)
+fill_bits(fz_faxd *fax)
 {
 	while (fax->bidx >= 8)
 	{
-		int c = fz_readbyte(fax->chain);
+		int c = fz_read_byte(fax->chain);
 		if (c == EOF)
 			return EOF;
 		fax->bidx -= 8;
@@ -348,7 +348,7 @@ getcode(fz_faxd *fax, const cfd_node *table, int initialbits)
 		nbits = initialbits + table[tidx].nbits;
 	}
 
-	eatbits(fax, nbits);
+	eat_bits(fax, nbits);
 
 	return val;
 }
@@ -384,10 +384,10 @@ dec1d(fz_faxd *fax)
 	if (code < 64)
 	{
 		fax->c = !fax->c;
-		fax->stage = SNORMAL;
+		fax->stage = STATE_NORMAL;
 	}
 	else
-		fax->stage = SMAKEUP;
+		fax->stage = STATE_MAKEUP;
 
 	return fz_okay;
 }
@@ -398,7 +398,7 @@ dec2d(fz_faxd *fax)
 {
 	int code, b1, b2;
 
-	if (fax->stage == SH1 || fax->stage == SH2)
+	if (fax->stage == STATE_H1 || fax->stage == STATE_H2)
 	{
 		if (fax->a == -1)
 			fax->a = 0;
@@ -425,10 +425,10 @@ dec2d(fz_faxd *fax)
 		if (code < 64)
 		{
 			fax->c = !fax->c;
-			if (fax->stage == SH1)
-				fax->stage = SH2;
-			else if (fax->stage == SH2)
-				fax->stage = SNORMAL;
+			if (fax->stage == STATE_H1)
+				fax->stage = STATE_H2;
+			else if (fax->stage == STATE_H2)
+				fax->stage = STATE_NORMAL;
 		}
 
 		return fz_okay;
@@ -439,28 +439,28 @@ dec2d(fz_faxd *fax)
 	switch (code)
 	{
 	case H:
-		fax->stage = SH1;
+		fax->stage = STATE_H1;
 		break;
 
 	case P:
-		b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 >= fax->columns)
 			b2 = fax->columns;
 		else
-			b2 = findchanging(fax->ref, b1, fax->columns);
+			b2 = find_changing(fax->ref, b1, fax->columns);
 		if (fax->c) setbits(fax->dst, fax->a, b2);
 		fax->a = b2;
 		break;
 
 	case V0:
-		b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
 		fax->c = !fax->c;
 		break;
 
 	case VR1:
-		b1 = 1 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = 1 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 >= fax->columns) b1 = fax->columns;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -468,7 +468,7 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case VR2:
-		b1 = 2 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = 2 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 >= fax->columns) b1 = fax->columns;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -476,7 +476,7 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case VR3:
-		b1 = 3 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = 3 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 >= fax->columns) b1 = fax->columns;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -484,7 +484,7 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case VL1:
-		b1 = -1 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = -1 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 < 0) b1 = 0;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -492,7 +492,7 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case VL2:
-		b1 = -2 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = -2 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 < 0) b1 = 0;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -500,7 +500,7 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case VL3:
-		b1 = -3 + findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c);
+		b1 = -3 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
 		if (b1 < 0) b1 = 0;
 		if (fax->c) setbits(fax->dst, fax->a, b1);
 		fax->a = b1;
@@ -521,7 +521,7 @@ dec2d(fz_faxd *fax)
 }
 
 static int
-readfaxd(fz_stream *stm, unsigned char *buf, int len)
+read_faxd(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_faxd *fax = stm->state;
 	unsigned char *p = buf;
@@ -529,15 +529,15 @@ readfaxd(fz_stream *stm, unsigned char *buf, int len)
 	unsigned char *tmp;
 	fz_error error;
 
-	if (fax->stage == SDONE)
+	if (fax->stage == STATE_DONE)
 		return 0;
 
-	if (fax->stage == SEOL)
+	if (fax->stage == STATE_EOL)
 		goto eol;
 
 loop:
 
-	if (fillbits(fax))
+	if (fill_bits(fax))
 	{
 		if (fax->bidx > 31)
 		{
@@ -549,13 +549,13 @@ loop:
 
 	if ((fax->word >> (32 - 12)) == 0)
 	{
-		eatbits(fax, 1);
+		eat_bits(fax, 1);
 		goto loop;
 	}
 
 	if ((fax->word >> (32 - 12)) == 1)
 	{
-		eatbits(fax, 12);
+		eat_bits(fax, 12);
 		fax->eolc ++;
 
 		if (fax->k > 0)
@@ -566,7 +566,7 @@ loop:
 				fax->dim = 1;
 			else
 				fax->dim = 2;
-			eatbits(fax, 1);
+			eat_bits(fax, 1);
 		}
 	}
 	else if (fax->k > 0 && fax->a == -1)
@@ -576,7 +576,7 @@ loop:
 			fax->dim = 1;
 		else
 			fax->dim = 2;
-		eatbits(fax, 1);
+		eat_bits(fax, 1);
 	}
 	else if (fax->dim == 1)
 	{
@@ -594,7 +594,7 @@ loop:
 	}
 
 	/* no eol check after makeup codes nor in the middle of an H code */
-	if (fax->stage == SMAKEUP || fax->stage == SH1 || fax->stage == SH2)
+	if (fax->stage == STATE_MAKEUP || fax->stage == STATE_H1 || fax->stage == STATE_H2)
 		goto loop;
 
 	/* check for eol conditions */
@@ -609,9 +609,9 @@ loop:
 	goto loop;
 
 eol:
-	fax->stage = SEOL;
+	fax->stage = STATE_EOL;
 
-	if (fax->blackis1)
+	if (fax->black_is_1)
 	{
 		while (fax->rp < fax->wp && p < ep)
 			*p++ = *fax->rp++;
@@ -625,7 +625,6 @@ eol:
 	if (fax->rp < fax->wp)
 		return p - buf;
 
-
 	tmp = fax->ref;
 	fax->ref = fax->dst;
 	fax->dst = tmp;
@@ -634,12 +633,12 @@ eol:
 	fax->rp = fax->dst;
 	fax->wp = fax->dst + fax->stride;
 
-	fax->stage = SNORMAL;
+	fax->stage = STATE_NORMAL;
 	fax->c = 0;
 	fax->a = -1;
 	fax->ridx ++;
 
-	if (!fax->endofblock && fax->rows)
+	if (!fax->end_of_block && fax->rows)
 	{
 		if (fax->ridx >= fax->rows)
 			goto rtc;
@@ -654,13 +653,13 @@ eol:
 			fax->dim = 2;
 	}
 
-	/* if endofline & encodedbytealign, EOLs are *not* optional */
-	if (fax->encodedbytealign)
+	/* if end_of_line & encoded_byte_align, EOLs are *not* optional */
+	if (fax->encoded_byte_align)
 	{
-		if (fax->endofline)
-			eatbits(fax, (12 - fax->bidx) & 7);
+		if (fax->end_of_line)
+			eat_bits(fax, (12 - fax->bidx) & 7);
 		else
-			eatbits(fax, (8 - fax->bidx) & 7);
+			eat_bits(fax, (8 - fax->bidx) & 7);
 	}
 
 	/* no more space in output, don't decode the next row yet */
@@ -670,12 +669,12 @@ eol:
 	goto loop;
 
 rtc:
-	fax->stage = SDONE;
+	fax->stage = STATE_DONE;
 	return p - buf;
 }
 
 static void
-closefaxd(fz_stream *stm)
+close_faxd(fz_stream *stm)
 {
 	fz_faxd *fax = stm->state;
 	int i;
@@ -683,7 +682,7 @@ closefaxd(fz_stream *stm)
 	/* if we read any extra bytes, try to put them back */
 	i = (32 - fax->bidx) / 8;
 	while (i--)
-		fz_unreadbyte(fax->chain);
+		fz_unread_byte(fax->chain);
 
 	fz_close(fax->chain);
 	fz_free(fax->ref);
@@ -692,7 +691,7 @@ closefaxd(fz_stream *stm)
 }
 
 fz_stream *
-fz_openfaxd(fz_stream *chain, fz_obj *params)
+fz_open_faxd(fz_stream *chain, fz_obj *params)
 {
 	fz_faxd *fax;
 	fz_obj *obj;
@@ -700,44 +699,44 @@ fz_openfaxd(fz_stream *chain, fz_obj *params)
 	fax = fz_malloc(sizeof(fz_faxd));
 	fax->chain = chain;
 
-	fax->ref = nil;
-	fax->dst = nil;
+	fax->ref = NULL;
+	fax->dst = NULL;
 
 	fax->k = 0;
-	fax->endofline = 0;
-	fax->encodedbytealign = 0;
+	fax->end_of_line = 0;
+	fax->encoded_byte_align = 0;
 	fax->columns = 1728;
 	fax->rows = 0;
-	fax->endofblock = 1;
-	fax->blackis1 = 0;
+	fax->end_of_block = 1;
+	fax->black_is_1 = 0;
 
-	obj = fz_dictgets(params, "K");
-	if (obj) fax->k = fz_toint(obj);
+	obj = fz_dict_gets(params, "K");
+	if (obj) fax->k = fz_to_int(obj);
 
-	obj = fz_dictgets(params, "EndOfLine");
-	if (obj) fax->endofline = fz_tobool(obj);
+	obj = fz_dict_gets(params, "EndOfLine");
+	if (obj) fax->end_of_line = fz_to_bool(obj);
 
-	obj = fz_dictgets(params, "EncodedByteAlign");
-	if (obj) fax->encodedbytealign = fz_tobool(obj);
+	obj = fz_dict_gets(params, "EncodedByteAlign");
+	if (obj) fax->encoded_byte_align = fz_to_bool(obj);
 
-	obj = fz_dictgets(params, "Columns");
-	if (obj) fax->columns = fz_toint(obj);
+	obj = fz_dict_gets(params, "Columns");
+	if (obj) fax->columns = fz_to_int(obj);
 
-	obj = fz_dictgets(params, "Rows");
-	if (obj) fax->rows = fz_toint(obj);
+	obj = fz_dict_gets(params, "Rows");
+	if (obj) fax->rows = fz_to_int(obj);
 
-	obj = fz_dictgets(params, "EndOfBlock");
-	if (obj) fax->endofblock = fz_tobool(obj);
+	obj = fz_dict_gets(params, "EndOfBlock");
+	if (obj) fax->end_of_block = fz_to_bool(obj);
 
-	obj = fz_dictgets(params, "BlackIs1");
-	if (obj) fax->blackis1 = fz_tobool(obj);
+	obj = fz_dict_gets(params, "BlackIs1");
+	if (obj) fax->black_is_1 = fz_to_bool(obj);
 
 	fax->stride = ((fax->columns - 1) >> 3) + 1;
 	fax->ridx = 0;
 	fax->bidx = 32;
 	fax->word = 0;
 
-	fax->stage = SNORMAL;
+	fax->stage = STATE_NORMAL;
 	fax->a = -1;
 	fax->c = 0;
 	fax->dim = fax->k < 0 ? 2 : 1;
@@ -751,5 +750,5 @@ fz_openfaxd(fz_stream *chain, fz_obj *params)
 	memset(fax->ref, 0, fax->stride);
 	memset(fax->dst, 0, fax->stride);
 
-	return fz_newstream(fax, readfaxd, closefaxd);
+	return fz_new_stream(fax, read_faxd, close_faxd);
 }
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index 0d14a75c..e7d4c9f7 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -21,7 +21,7 @@ static void zfree(void *opaque, void *ptr)
 }
 
 static int
-readflated(fz_stream *stm, unsigned char *outbuf, int outlen)
+read_flated(fz_stream *stm, unsigned char *outbuf, int outlen)
 {
 	fz_flate *state = stm->state;
 	fz_stream *chain = state->chain;
@@ -34,7 +34,7 @@ readflated(fz_stream *stm, unsigned char *outbuf, int outlen)
 	while (zp->avail_out > 0)
 	{
 		if (chain->rp == chain->wp)
-			fz_fillbuffer(chain);
+			fz_fill_buffer(chain);
 
 		zp->next_in = chain->rp;
 		zp->avail_in = chain->wp - chain->rp;
@@ -67,7 +67,7 @@ readflated(fz_stream *stm, unsigned char *outbuf, int outlen)
 }
 
 static void
-closeflated(fz_stream *stm)
+close_flated(fz_stream *stm)
 {
 	fz_flate *state = stm->state;
 	int code;
@@ -81,7 +81,7 @@ closeflated(fz_stream *stm)
 }
 
 fz_stream *
-fz_openflated(fz_stream *chain)
+fz_open_flated(fz_stream *chain)
 {
 	fz_flate *state;
 	int code;
@@ -91,13 +91,13 @@ fz_openflated(fz_stream *chain)
 
 	state->z.zalloc = zalloc;
 	state->z.zfree = zfree;
-	state->z.opaque = nil;
-	state->z.next_in = nil;
+	state->z.opaque = NULL;
+	state->z.next_in = NULL;
 	state->z.avail_in = 0;
 
 	code = inflateInit(&state->z);
 	if (code != Z_OK)
 		fz_warn("zlib error: inflateInit: %s", state->z.msg);
 
-	return fz_newstream(state, readflated, closeflated);
+	return fz_new_stream(state, read_flated, close_flated);
 }
diff --git a/fitz/filt_jbig2d.c b/fitz/filt_jbig2d.c
index 8804ef29..4dbe542c 100644
--- a/fitz/filt_jbig2d.c
+++ b/fitz/filt_jbig2d.c
@@ -29,7 +29,7 @@ struct fz_jbig2d_s
 };
 
 static void
-closejbig2d(fz_stream *stm)
+close_jbig2d(fz_stream *stm)
 {
 	fz_jbig2d *state = stm->state;
 	if (state->page)
@@ -42,7 +42,7 @@ closejbig2d(fz_stream *stm)
 }
 
 static int
-readjbig2d(fz_stream *stm, unsigned char *buf, int len)
+read_jbig2d(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_jbig2d *state = stm->state;
 	unsigned char tmp[4096];
@@ -81,23 +81,23 @@ readjbig2d(fz_stream *stm, unsigned char *buf, int len)
 }
 
 fz_stream *
-fz_openjbig2d(fz_stream *chain, fz_buffer *globals)
+fz_open_jbig2d(fz_stream *chain, fz_buffer *globals)
 {
 	fz_jbig2d *state;
 
 	state = fz_malloc(sizeof(fz_jbig2d));
 	state->chain = chain;
-	state->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, nil, nil, nil);
-	state->gctx = nil;
-	state->page = nil;
+	state->ctx = jbig2_ctx_new(NULL, JBIG2_OPTIONS_EMBEDDED, NULL, NULL, NULL);
+	state->gctx = NULL;
+	state->page = NULL;
 	state->idx = 0;
 
 	if (globals)
 	{
 		jbig2_data_in(state->ctx, globals->data, globals->len);
 		state->gctx = jbig2_make_global_ctx(state->ctx);
-		state->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, state->gctx, nil, nil);
+		state->ctx = jbig2_ctx_new(NULL, JBIG2_OPTIONS_EMBEDDED, state->gctx, NULL, NULL);
 	}
 
-	return fz_newstream(state, readjbig2d, closejbig2d);
+	return fz_new_stream(state, read_jbig2d, close_jbig2d);
 }
diff --git a/fitz/filt_jpxd.c b/fitz/filt_jpxd.c
index 3ec06ab3..f5a65851 100644
--- a/fitz/filt_jpxd.c
+++ b/fitz/filt_jpxd.c
@@ -19,7 +19,7 @@ static void fz_opj_info_callback(const char *msg, void *client_data)
 }
 
 fz_error
-fz_loadjpximage(fz_pixmap **imgp, unsigned char *data, int size)
+fz_load_jpx_image(fz_pixmap **imgp, unsigned char *data, int size)
 {
 	fz_pixmap *img;
 	opj_event_mgr_t evtmgr;
@@ -81,16 +81,16 @@ fz_loadjpximage(fz_pixmap **imgp, unsigned char *data, int size)
 
 	switch (n)
 	{
-	case 1: colorspace = fz_devicegray; break;
-	case 3: colorspace = fz_devicergb; break;
-	case 4: colorspace = fz_devicecmyk; break;
+	case 1: colorspace = fz_device_gray; break;
+	case 3: colorspace = fz_device_rgb; break;
+	case 4: colorspace = fz_device_cmyk; break;
 	default:
 		/* TODO: SMaskInData */
 		opj_image_destroy(jpx);
 		return fz_throw("unknown jpx colorspace (%d components)", n);
 	}
 
-	img = fz_newpixmap(colorspace, 0, 0, w, h);
+	img = fz_new_pixmap(colorspace, 0, 0, w, h);
 
 	p = img->samples;
 	for (y = 0; y < h; y++)
diff --git a/fitz/filt_lzwd.c b/fitz/filt_lzwd.c
index 23cb7520..942e5837 100644
--- a/fitz/filt_lzwd.c
+++ b/fitz/filt_lzwd.c
@@ -4,13 +4,13 @@
 
 enum
 {
-	MINBITS = 9,
-	MAXBITS = 12,
-	NUMCODES = (1 << MAXBITS),
+	MIN_BITS = 9,
+	MAX_BITS = 12,
+	NUM_CODES = (1 << MAX_BITS),
 	LZW_CLEAR = 256,
 	LZW_EOD = 257,
 	LZW_FIRST = 258,
-	MAXLENGTH = 4097
+	MAX_LENGTH = 4097
 };
 
 typedef struct lzw_code_s lzw_code;
@@ -20,7 +20,7 @@ struct lzw_code_s
 	int prev;			/* prev code (in string) */
 	unsigned short length;		/* string len, including this token */
 	unsigned char value;		/* data value */
-	unsigned char firstchar;	/* first token of string */
+	unsigned char first_char;	/* first token of string */
 };
 
 typedef struct fz_lzwd_s fz_lzwd;
@@ -30,21 +30,21 @@ struct fz_lzwd_s
 	fz_stream *chain;
 	int eod;
 
-	int earlychange;
+	int early_change;
 
-	int codebits;			/* num bits/code */
+	int code_bits;			/* num bits/code */
 	int code;			/* current code */
-	int oldcode;			/* previously recognized code */
-	int nextcode;			/* next free entry */
+	int old_code;			/* previously recognized code */
+	int next_code;			/* next free entry */
 
-	lzw_code table[NUMCODES];
+	lzw_code table[NUM_CODES];
 
-	unsigned char bp[MAXLENGTH];
+	unsigned char bp[MAX_LENGTH];
 	unsigned char *rp, *wp;
 };
 
 static int
-readlzwd(fz_stream *stm, unsigned char *buf, int len)
+read_lzwd(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_lzwd *lzw = stm->state;
 	lzw_code *table = lzw->table;
@@ -53,10 +53,10 @@ readlzwd(fz_stream *stm, unsigned char *buf, int len)
 	unsigned char *s;
 	int codelen;
 
-	int codebits = lzw->codebits;
+	int code_bits = lzw->code_bits;
 	int code = lzw->code;
-	int oldcode = lzw->oldcode;
-	int nextcode = lzw->nextcode;
+	int old_code = lzw->old_code;
+	int next_code = lzw->next_code;
 
 	while (lzw->rp < lzw->wp && p < ep)
 		*p++ = *lzw->rp++;
@@ -66,9 +66,9 @@ readlzwd(fz_stream *stm, unsigned char *buf, int len)
 		if (lzw->eod)
 			return 0;
 
-		code = fz_readbits(lzw->chain, codebits);
+		code = fz_read_bits(lzw->chain, code_bits);
 
-		if (fz_iseofbits(lzw->chain))
+		if (fz_is_eof_bits(lzw->chain))
 		{
 			lzw->eod = 1;
 			break;
@@ -82,40 +82,40 @@ readlzwd(fz_stream *stm, unsigned char *buf, int len)
 
 		if (code == LZW_CLEAR)
 		{
-			codebits = MINBITS;
-			nextcode = LZW_FIRST;
-			oldcode = -1;
+			code_bits = MIN_BITS;
+			next_code = LZW_FIRST;
+			old_code = -1;
 			continue;
 		}
 
-		/* if stream starts without a clear code, oldcode is undefined... */
-		if (oldcode == -1)
+		/* if stream starts without a clear code, old_code is undefined... */
+		if (old_code == -1)
 		{
-			oldcode = code;
+			old_code = code;
 		}
 		else
 		{
 			/* add new entry to the code table */
-			table[nextcode].prev = oldcode;
-			table[nextcode].firstchar = table[oldcode].firstchar;
-			table[nextcode].length = table[oldcode].length + 1;
-			if (code < nextcode)
-				table[nextcode].value = table[code].firstchar;
-			else if (code == nextcode)
-				table[nextcode].value = table[nextcode].firstchar;
+			table[next_code].prev = old_code;
+			table[next_code].first_char = table[old_code].first_char;
+			table[next_code].length = table[old_code].length + 1;
+			if (code < next_code)
+				table[next_code].value = table[code].first_char;
+			else if (code == next_code)
+				table[next_code].value = table[next_code].first_char;
 			else
 				fz_warn("out of range code encountered in lzw decode");
 
-			nextcode ++;
+			next_code ++;
 
-			if (nextcode > (1 << codebits) - lzw->earlychange - 1)
+			if (next_code > (1 << code_bits) - lzw->early_change - 1)
 			{
-				codebits ++;
-				if (codebits > MAXBITS)
-					codebits = MAXBITS;	/* FIXME */
+				code_bits ++;
+				if (code_bits > MAX_BITS)
+					code_bits = MAX_BITS;	/* FIXME */
 			}
 
-			oldcode = code;
+			old_code = code;
 		}
 
 		/* code maps to a string, copy to output (in reverse...) */
@@ -125,7 +125,7 @@ readlzwd(fz_stream *stm, unsigned char *buf, int len)
 			lzw->rp = lzw->bp;
 			lzw->wp = lzw->bp + codelen;
 
-			assert(codelen < MAXLENGTH);
+			assert(codelen < MAX_LENGTH);
 
 			s = lzw->wp;
 			do {
@@ -147,16 +147,16 @@ readlzwd(fz_stream *stm, unsigned char *buf, int len)
 			*p++ = *lzw->rp++;
 	}
 
-	lzw->codebits = codebits;
+	lzw->code_bits = code_bits;
 	lzw->code = code;
-	lzw->oldcode = oldcode;
-	lzw->nextcode = nextcode;
+	lzw->old_code = old_code;
+	lzw->next_code = next_code;
 
 	return p - buf;
 }
 
 static void
-closelzwd(fz_stream *stm)
+close_lzwd(fz_stream *stm)
 {
 	fz_lzwd *lzw = stm->state;
 	fz_close(lzw->chain);
@@ -164,7 +164,7 @@ closelzwd(fz_stream *stm)
 }
 
 fz_stream *
-fz_openlzwd(fz_stream *chain, fz_obj *params)
+fz_open_lzwd(fz_stream *chain, fz_obj *params)
 {
 	fz_lzwd *lzw;
 	fz_obj *obj;
@@ -173,34 +173,34 @@ fz_openlzwd(fz_stream *chain, fz_obj *params)
 	lzw = fz_malloc(sizeof(fz_lzwd));
 	lzw->chain = chain;
 	lzw->eod = 0;
-	lzw->earlychange = 1;
+	lzw->early_change = 1;
 
-	obj = fz_dictgets(params, "EarlyChange");
+	obj = fz_dict_gets(params, "EarlyChange");
 	if (obj)
-		lzw->earlychange = !!fz_toint(obj);
+		lzw->early_change = !!fz_to_int(obj);
 
 	for (i = 0; i < 256; i++)
 	{
 		lzw->table[i].value = i;
-		lzw->table[i].firstchar = i;
+		lzw->table[i].first_char = i;
 		lzw->table[i].length = 1;
 		lzw->table[i].prev = -1;
 	}
 
-	for (i = 256; i < NUMCODES; i++)
+	for (i = 256; i < NUM_CODES; i++)
 	{
 		lzw->table[i].value = 0;
-		lzw->table[i].firstchar = 0;
+		lzw->table[i].first_char = 0;
 		lzw->table[i].length = 0;
 		lzw->table[i].prev = -1;
 	}
 
-	lzw->codebits = MINBITS;
+	lzw->code_bits = MIN_BITS;
 	lzw->code = -1;
-	lzw->nextcode = LZW_FIRST;
-	lzw->oldcode = -1;
+	lzw->next_code = LZW_FIRST;
+	lzw->old_code = -1;
 	lzw->rp = lzw->bp;
 	lzw->wp = lzw->bp;
 
-	return fz_newstream(lzw, readlzwd, closelzwd);
+	return fz_new_stream(lzw, read_lzwd, close_lzwd);
 }
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index ae2d1aaf..1501fc09 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -60,7 +60,7 @@ paeth(int a, int b, int c)
 }
 
 static void
-fz_predicttiff(fz_predict *state, unsigned char *out, unsigned char *in, int len)
+fz_predict_tiff(fz_predict *state, unsigned char *out, unsigned char *in, int len)
 {
 	int left[MAXC];
 	int i, k;
@@ -82,7 +82,7 @@ fz_predicttiff(fz_predict *state, unsigned char *out, unsigned char *in, int len
 }
 
 static void
-fz_predictpng(fz_predict *state, unsigned char *out, unsigned char *in, int len, int predictor)
+fz_predict_png(fz_predict *state, unsigned char *out, unsigned char *in, int len, int predictor)
 {
 	int bpp = state->bpp;
 	int i;
@@ -141,7 +141,7 @@ fz_predictpng(fz_predict *state, unsigned char *out, unsigned char *in, int len,
 }
 
 static int
-readpredict(fz_stream *stm, unsigned char *buf, int len)
+read_predict(fz_stream *stm, unsigned char *buf, int len)
 {
 	fz_predict *state = stm->state;
 	unsigned char *p = buf;
@@ -163,10 +163,10 @@ readpredict(fz_stream *stm, unsigned char *buf, int len)
 		if (state->predictor == 1)
 			memcpy(state->out, state->in, n);
 		else if (state->predictor == 2)
-			fz_predicttiff(state, state->out, state->in, n);
+			fz_predict_tiff(state, state->out, state->in, n);
 		else
 		{
-			fz_predictpng(state, state->out, state->in + 1, n - 1, state->in[0]);
+			fz_predict_png(state, state->out, state->in + 1, n - 1, state->in[0]);
 			memcpy(state->ref, state->out, state->stride);
 		}
 
@@ -181,7 +181,7 @@ readpredict(fz_stream *stm, unsigned char *buf, int len)
 }
 
 static void
-closepredict(fz_stream *stm)
+close_predict(fz_stream *stm)
 {
 	fz_predict *state = stm->state;
 	fz_close(state->chain);
@@ -192,7 +192,7 @@ closepredict(fz_stream *stm)
 }
 
 fz_stream *
-fz_openpredict(fz_stream *chain, fz_obj *params)
+fz_open_predict(fz_stream *chain, fz_obj *params)
 {
 	fz_predict *state;
 	fz_obj *obj;
@@ -205,9 +205,9 @@ fz_openpredict(fz_stream *chain, fz_obj *params)
 	state->colors = 1;
 	state->bpc = 8;
 
-	obj = fz_dictgets(params, "Predictor");
+	obj = fz_dict_gets(params, "Predictor");
 	if (obj)
-		state->predictor = fz_toint(obj);
+		state->predictor = fz_to_int(obj);
 
 	if (state->predictor != 1 && state->predictor != 2 &&
 		state->predictor != 10 && state->predictor != 11 &&
@@ -218,17 +218,17 @@ fz_openpredict(fz_stream *chain, fz_obj *params)
 		state->predictor = 1;
 	}
 
-	obj = fz_dictgets(params, "Columns");
+	obj = fz_dict_gets(params, "Columns");
 	if (obj)
-		state->columns = fz_toint(obj);
+		state->columns = fz_to_int(obj);
 
-	obj = fz_dictgets(params, "Colors");
+	obj = fz_dict_gets(params, "Colors");
 	if (obj)
-		state->colors = fz_toint(obj);
+		state->colors = fz_to_int(obj);
 
-	obj = fz_dictgets(params, "BitsPerComponent");
+	obj = fz_dict_gets(params, "BitsPerComponent");
 	if (obj)
-		state->bpc = fz_toint(obj);
+		state->bpc = fz_to_int(obj);
 
 	state->stride = (state->bpc * state->colors * state->columns + 7) / 8;
 	state->bpp = (state->bpc * state->colors + 7) / 8;
@@ -241,5 +241,5 @@ fz_openpredict(fz_stream *chain, fz_obj *params)
 
 	memset(state->ref, 0, state->stride);
 
-	return fz_newstream(state, readpredict, closepredict);
+	return fz_new_stream(state, read_predict, close_predict);
 }
diff --git a/fitz/fitz.h b/fitz/fitz.h
index b8972871..c765da87 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -18,8 +18,6 @@
 #include <float.h>	/* FLT_EPSILON */
 #include <fcntl.h>	/* O_RDONLY & co */
 
-#define nil ((void*)0)
-
 #define nelem(x) (sizeof(x)/sizeof((x)[0]))
 
 /*
@@ -63,33 +61,33 @@ int gettimeofday(struct timeval *tv, struct timezone *tz);
 
 #if __STDC_VERSION__ == 199901L /* C99 */
 
-#define fz_throw(...) fz_throwimp(__FILE__, __LINE__, __func__, __VA_ARGS__)
-#define fz_rethrow(cause, ...) fz_rethrowimp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
-#define fz_catch(cause, ...) fz_catchimp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
+#define fz_throw(...) fz_throw_imp(__FILE__, __LINE__, __func__, __VA_ARGS__)
+#define fz_rethrow(cause, ...) fz_rethrow_imp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
+#define fz_catch(cause, ...) fz_catch_imp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
 
 #elif _MSC_VER >= 1500 /* MSVC 9 or newer */
 
 #define inline __inline
 #define restrict __restrict
-#define fz_throw(...) fz_throwimp(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
-#define fz_rethrow(cause, ...) fz_rethrowimp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
-#define fz_catch(cause, ...) fz_catchimp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
+#define fz_throw(...) fz_throw_imp(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
+#define fz_rethrow(cause, ...) fz_rethrow_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
+#define fz_catch(cause, ...) fz_catch_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
 
 #elif __GNUC__ >= 3 /* GCC 3 or newer */
 
 #define inline __inline
 #define restrict __restrict
-#define fz_throw(fmt...) fz_throwimp(__FILE__, __LINE__, __FUNCTION__, fmt)
-#define fz_rethrow(cause, fmt...) fz_rethrowimp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
-#define fz_catch(cause, fmt...) fz_catchimp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
+#define fz_throw(fmt...) fz_throw_imp(__FILE__, __LINE__, __FUNCTION__, fmt)
+#define fz_rethrow(cause, fmt...) fz_rethrow_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
+#define fz_catch(cause, fmt...) fz_catch_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
 
 #else /* Unknown or ancient */
 
 #define inline
 #define restrict
-#define fz_throw fz_throwimpx
-#define fz_rethrow fz_rethrowimpx
-#define fz_catch fz_catchimpx
+#define fz_throw fz_throw_impx
+#define fz_rethrow fz_rethrow_impx
+#define fz_catch fz_catch_impx
 
 #endif
 
@@ -113,21 +111,21 @@ int gettimeofday(struct timeval *tv, struct timezone *tz);
 typedef int fz_error;
 
 void fz_warn(char *fmt, ...) __printflike(1, 2);
-void fz_flushwarnings(void);
+void fz_flush_warnings(void);
 
-fz_error fz_throwimp(const char *file, int line, const char *func, char *fmt, ...) __printflike(4, 5);
-fz_error fz_rethrowimp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
-void fz_catchimp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
+fz_error fz_throw_imp(const char *file, int line, const char *func, char *fmt, ...) __printflike(4, 5);
+fz_error fz_rethrow_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
+void fz_catch_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
 
-fz_error fz_throwimpx(char *fmt, ...) __printflike(1, 2);
-fz_error fz_rethrowimpx(fz_error cause, char *fmt, ...) __printflike(2, 3);
-void fz_catchimpx(fz_error cause, char *fmt, ...) __printflike(2, 3);
+fz_error fz_throw_impx(char *fmt, ...) __printflike(1, 2);
+fz_error fz_rethrow_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
+void fz_catch_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
 
 #define fz_okay ((fz_error)0)
 
 /* extract the last error stack trace */
-int fz_geterrorcount(void);
-char *fz_geterrorline(int n);
+int fz_get_error_count(void);
+char *fz_get_error_line(int n);
 
 /*
  * Basic runtime and utility functions
@@ -146,7 +144,7 @@ void fz_free(void *p);
 char *fz_strdup(char *s);
 
 /* runtime (hah!) test for endian-ness */
-int fz_isbigendian(void);
+int fz_is_big_endian(void);
 
 /* safe string functions */
 char *fz_strsep(char **stringp, const char *delim);
@@ -167,20 +165,20 @@ extern char *fz_optarg;
  * Generic hash-table with fixed-length keys.
  */
 
-typedef struct fz_hashtable_s fz_hashtable;
+typedef struct fz_hash_table_s fz_hash_table;
 
-fz_hashtable *fz_newhash(int initialsize, int keylen);
-void fz_debughash(fz_hashtable *table);
-void fz_emptyhash(fz_hashtable *table);
-void fz_freehash(fz_hashtable *table);
+fz_hash_table *fz_new_hash_table(int initialsize, int keylen);
+void fz_debug_hash(fz_hash_table *table);
+void fz_empty_hash(fz_hash_table *table);
+void fz_free_hash(fz_hash_table *table);
 
-void *fz_hashfind(fz_hashtable *table, void *key);
-void fz_hashinsert(fz_hashtable *table, void *key, void *val);
-void fz_hashremove(fz_hashtable *table, void *key);
+void *fz_hash_find(fz_hash_table *table, void *key);
+void fz_hash_insert(fz_hash_table *table, void *key, void *val);
+void fz_hash_remove(fz_hash_table *table, void *key);
 
-int fz_hashlen(fz_hashtable *table);
-void *fz_hashgetkey(fz_hashtable *table, int idx);
-void *fz_hashgetval(fz_hashtable *table, int idx);
+int fz_hash_len(fz_hash_table *table);
+void *fz_hash_get_key(fz_hash_table *table, int idx);
+void *fz_hash_get_val(fz_hash_table *table, int idx);
 
 /*
  * Math and geometry
@@ -203,7 +201,7 @@ static inline int fz_mul255(int a, int b)
 #define FZ_COMBINE(A,B) (((A)*(B))>>8)
 
 /* Combine values A and C (in the same (any) range) and B and D (in the
- * 0..256 range), to give a single value in the same range as A and C were.  */
+ * 0..256 range), to give a single value in the same range as A and C were. */
 #define FZ_COMBINE2(A,B,C,D) (FZ_COMBINE((A), (B)) + FZ_COMBINE((C), (D)))
 
 /* Blend SRC and DST (in the same range) together according to
@@ -215,18 +213,18 @@ typedef struct fz_point_s fz_point;
 typedef struct fz_rect_s fz_rect;
 typedef struct fz_bbox_s fz_bbox;
 
-extern const fz_rect fz_unitrect;
-extern const fz_rect fz_emptyrect;
-extern const fz_rect fz_infiniterect;
+extern const fz_rect fz_unit_rect;
+extern const fz_rect fz_empty_rect;
+extern const fz_rect fz_infinite_rect;
 
-extern const fz_bbox fz_unitbbox;
-extern const fz_bbox fz_emptybbox;
-extern const fz_bbox fz_infinitebbox;
+extern const fz_bbox fz_unit_bbox;
+extern const fz_bbox fz_empty_bbox;
+extern const fz_bbox fz_infinite_bbox;
 
-#define fz_isemptyrect(r) ((r).x0 == (r).x1)
-#define fz_isinfiniterect(r) ((r).x0 > (r).x1)
-#define fz_isemptybbox(b) ((b).x0 == (b).x1)
-#define fz_isinfinitebbox(b) ((b).x0 > (b).x1)
+#define fz_is_empty_rect(r) ((r).x0 == (r).x1)
+#define fz_is_infinite_rect(r) ((r).x0 > (r).x1)
+#define fz_is_empty_bbox(b) ((b).x0 == (b).x1)
+#define fz_is_infinite_bbox(b) ((b).x0 > (b).x1)
 
 struct fz_matrix_s
 {
@@ -256,18 +254,18 @@ fz_matrix fz_concat(fz_matrix one, fz_matrix two);
 fz_matrix fz_scale(float sx, float sy);
 fz_matrix fz_rotate(float theta);
 fz_matrix fz_translate(float tx, float ty);
-fz_matrix fz_invertmatrix(fz_matrix m);
-int fz_isrectilinear(fz_matrix m);
-float fz_matrixexpansion(fz_matrix m);
+fz_matrix fz_invert_matrix(fz_matrix m);
+int fz_is_rectilinear(fz_matrix m);
+float fz_matrix_expansion(fz_matrix m);
 
-fz_bbox fz_roundrect(fz_rect r);
-fz_bbox fz_intersectbbox(fz_bbox a, fz_bbox b);
-fz_bbox fz_unionbbox(fz_bbox a, fz_bbox b);
+fz_bbox fz_round_rect(fz_rect r);
+fz_bbox fz_intersect_bbox(fz_bbox a, fz_bbox b);
+fz_bbox fz_union_bbox(fz_bbox a, fz_bbox b);
 
-fz_point fz_transformpoint(fz_matrix m, fz_point p);
-fz_point fz_transformvector(fz_matrix m, fz_point p);
-fz_rect fz_transformrect(fz_matrix m, fz_rect r);
-fz_bbox fz_transformbbox(fz_matrix m, fz_bbox b);
+fz_point fz_transform_point(fz_matrix m, fz_point p);
+fz_point fz_transform_vector(fz_matrix m, fz_point p);
+fz_rect fz_transform_rect(fz_matrix m, fz_rect r);
+fz_bbox fz_transform_bbox(fz_matrix m, fz_bbox b);
 
 /*
  * Basic crypto functions.
@@ -286,9 +284,9 @@ struct fz_md5_s
 	unsigned char buffer[64];
 };
 
-void fz_md5init(fz_md5 *state);
-void fz_md5update(fz_md5 *state, const unsigned char *input, const unsigned inlen);
-void fz_md5final(fz_md5 *state, unsigned char digest[16]);
+void fz_md5_init(fz_md5 *state);
+void fz_md5_update(fz_md5 *state, const unsigned char *input, const unsigned inlen);
+void fz_md5_final(fz_md5 *state, unsigned char digest[16]);
 
 /* sha-256 digests */
 
@@ -304,9 +302,9 @@ struct fz_sha256_s
 	} buffer;
 };
 
-void fz_sha256init(fz_sha256 *state);
-void fz_sha256update(fz_sha256 *state, const unsigned char *input, unsigned int inlen);
-void fz_sha256final(fz_sha256 *state, unsigned char digest[32]);
+void fz_sha256_init(fz_sha256 *state);
+void fz_sha256_update(fz_sha256 *state, const unsigned char *input, unsigned int inlen);
+void fz_sha256_final(fz_sha256 *state, unsigned char digest[32]);
 
 /* arc4 crypto */
 
@@ -319,8 +317,8 @@ struct fz_arc4_s
 	unsigned char state[256];
 };
 
-void fz_arc4init(fz_arc4 *state, const unsigned char *key, const unsigned len);
-void fz_arc4encrypt(fz_arc4 *state, unsigned char *dest, const unsigned char *src, const unsigned len);
+void fz_arc4_init(fz_arc4 *state, const unsigned char *key, const unsigned len);
+void fz_arc4_encrypt(fz_arc4 *state, unsigned char *dest, const unsigned char *src, const unsigned len);
 
 /* AES block cipher implementation from XYSSL */
 
@@ -406,69 +404,69 @@ struct fz_obj_s
 	} u;
 };
 
-extern fz_obj* (*fz_resolveindirect)(fz_obj*);
+extern fz_obj* (*fz_resolve_indirect)(fz_obj*);
 
-fz_obj *fz_newnull(void);
-fz_obj *fz_newbool(int b);
-fz_obj *fz_newint(int i);
-fz_obj *fz_newreal(float f);
-fz_obj *fz_newname(char *str);
-fz_obj *fz_newstring(char *str, int len);
-fz_obj *fz_newindirect(int num, int gen, void *xref);
+fz_obj *fz_new_null(void);
+fz_obj *fz_new_bool(int b);
+fz_obj *fz_new_int(int i);
+fz_obj *fz_new_real(float f);
+fz_obj *fz_new_name(char *str);
+fz_obj *fz_new_string(char *str, int len);
+fz_obj *fz_new_indirect(int num, int gen, void *xref);
 
-fz_obj *fz_newarray(int initialcap);
-fz_obj *fz_newdict(int initialcap);
-fz_obj *fz_copyarray(fz_obj *array);
-fz_obj *fz_copydict(fz_obj *dict);
+fz_obj *fz_new_array(int initialcap);
+fz_obj *fz_new_dict(int initialcap);
+fz_obj *fz_copy_array(fz_obj *array);
+fz_obj *fz_copy_dict(fz_obj *dict);
 
-fz_obj *fz_keepobj(fz_obj *obj);
-void fz_dropobj(fz_obj *obj);
+fz_obj *fz_keep_obj(fz_obj *obj);
+void fz_drop_obj(fz_obj *obj);
 
 /* type queries */
-int fz_isnull(fz_obj *obj);
-int fz_isbool(fz_obj *obj);
-int fz_isint(fz_obj *obj);
-int fz_isreal(fz_obj *obj);
-int fz_isname(fz_obj *obj);
-int fz_isstring(fz_obj *obj);
-int fz_isarray(fz_obj *obj);
-int fz_isdict(fz_obj *obj);
-int fz_isindirect(fz_obj *obj);
+int fz_is_null(fz_obj *obj);
+int fz_is_bool(fz_obj *obj);
+int fz_is_int(fz_obj *obj);
+int fz_is_real(fz_obj *obj);
+int fz_is_name(fz_obj *obj);
+int fz_is_string(fz_obj *obj);
+int fz_is_array(fz_obj *obj);
+int fz_is_dict(fz_obj *obj);
+int fz_is_indirect(fz_obj *obj);
 
 int fz_objcmp(fz_obj *a, fz_obj *b);
 
 /* silent failure, no error reporting */
-int fz_tobool(fz_obj *obj);
-int fz_toint(fz_obj *obj);
-float fz_toreal(fz_obj *obj);
-char *fz_toname(fz_obj *obj);
-char *fz_tostrbuf(fz_obj *obj);
-int fz_tostrlen(fz_obj *obj);
-int fz_tonum(fz_obj *obj);
-int fz_togen(fz_obj *obj);
-
-int fz_arraylen(fz_obj *array);
-fz_obj *fz_arrayget(fz_obj *array, int i);
-void fz_arrayput(fz_obj *array, int i, fz_obj *obj);
-void fz_arraypush(fz_obj *array, fz_obj *obj);
-void fz_arraydrop(fz_obj *array);
-void fz_arrayinsert(fz_obj *array, fz_obj *obj);
-
-int fz_dictlen(fz_obj *dict);
-fz_obj *fz_dictgetkey(fz_obj *dict, int idx);
-fz_obj *fz_dictgetval(fz_obj *dict, int idx);
-fz_obj *fz_dictget(fz_obj *dict, fz_obj *key);
-fz_obj *fz_dictgets(fz_obj *dict, char *key);
-fz_obj *fz_dictgetsa(fz_obj *dict, char *key, char *abbrev);
-void fz_dictput(fz_obj *dict, fz_obj *key, fz_obj *val);
-void fz_dictputs(fz_obj *dict, char *key, fz_obj *val);
-void fz_dictdel(fz_obj *dict, fz_obj *key);
-void fz_dictdels(fz_obj *dict, char *key);
-void fz_sortdict(fz_obj *dict);
-
-int fz_fprintobj(FILE *fp, fz_obj *obj, int tight);
-void fz_debugobj(fz_obj *obj);
-void fz_debugref(fz_obj *obj);
+int fz_to_bool(fz_obj *obj);
+int fz_to_int(fz_obj *obj);
+float fz_to_real(fz_obj *obj);
+char *fz_to_name(fz_obj *obj);
+char *fz_to_str_buf(fz_obj *obj);
+int fz_to_str_len(fz_obj *obj);
+int fz_to_num(fz_obj *obj);
+int fz_to_gen(fz_obj *obj);
+
+int fz_array_len(fz_obj *array);
+fz_obj *fz_array_get(fz_obj *array, int i);
+void fz_array_put(fz_obj *array, int i, fz_obj *obj);
+void fz_array_push(fz_obj *array, fz_obj *obj);
+void fz_array_drop(fz_obj *array);
+void fz_array_insert(fz_obj *array, fz_obj *obj);
+
+int fz_dict_len(fz_obj *dict);
+fz_obj *fz_dict_get_key(fz_obj *dict, int idx);
+fz_obj *fz_dict_get_val(fz_obj *dict, int idx);
+fz_obj *fz_dict_get(fz_obj *dict, fz_obj *key);
+fz_obj *fz_dict_gets(fz_obj *dict, char *key);
+fz_obj *fz_dict_getsa(fz_obj *dict, char *key, char *abbrev);
+void fz_dict_put(fz_obj *dict, fz_obj *key, fz_obj *val);
+void fz_dict_puts(fz_obj *dict, char *key, fz_obj *val);
+void fz_dict_del(fz_obj *dict, fz_obj *key);
+void fz_dict_dels(fz_obj *dict, char *key);
+void fz_sort_dict(fz_obj *dict);
+
+int fz_fprint_obj(FILE *fp, fz_obj *obj, int tight);
+void fz_debug_obj(fz_obj *obj);
+void fz_debug_ref(fz_obj *obj);
 
 char *fz_objkindstr(fz_obj *obj);
 
@@ -485,12 +483,12 @@ struct fz_buffer_s
 	int cap, len;
 };
 
-fz_buffer *fz_newbuffer(int size);
-fz_buffer *fz_keepbuffer(fz_buffer *buf);
-void fz_dropbuffer(fz_buffer *buf);
+fz_buffer *fz_new_buffer(int size);
+fz_buffer *fz_keep_buffer(fz_buffer *buf);
+void fz_drop_buffer(fz_buffer *buf);
 
-void fz_resizebuffer(fz_buffer *buf, int size);
-void fz_growbuffer(fz_buffer *buf);
+void fz_resize_buffer(fz_buffer *buf, int size);
+void fz_grow_buffer(fz_buffer *buf);
 
 /*
  * Buffered reader.
@@ -515,62 +513,62 @@ struct fz_stream_s
 	unsigned char buf[4096];
 };
 
-fz_stream *fz_openfd(int file);
-fz_stream *fz_openfile(const char *filename);
-fz_stream *fz_openfilew(const wchar_t *filename); /* only on win32 */
-fz_stream *fz_openbuffer(fz_buffer *buf);
-fz_stream *fz_openmemory(unsigned char *data, int len);
+fz_stream *fz_open_fd(int file);
+fz_stream *fz_open_file(const char *filename);
+fz_stream *fz_open_file_w(const wchar_t *filename); /* only on win32 */
+fz_stream *fz_open_buffer(fz_buffer *buf);
+fz_stream *fz_open_memory(unsigned char *data, int len);
 void fz_close(fz_stream *stm);
 
-fz_stream *fz_newstream(void*, int(*)(fz_stream*, unsigned char*, int), void(*)(fz_stream *));
-fz_stream *fz_keepstream(fz_stream *stm);
-void fz_fillbuffer(fz_stream *stm);
+fz_stream *fz_new_stream(void*, int(*)(fz_stream*, unsigned char*, int), void(*)(fz_stream *));
+fz_stream *fz_keep_stream(fz_stream *stm);
+void fz_fill_buffer(fz_stream *stm);
 
 int fz_tell(fz_stream *stm);
 void fz_seek(fz_stream *stm, int offset, int whence);
 
 int fz_read(fz_stream *stm, unsigned char *buf, int len);
-void fz_readline(fz_stream *stm, char *buf, int max);
-fz_error fz_readall(fz_buffer **bufp, fz_stream *stm, int initial);
+void fz_read_line(fz_stream *stm, char *buf, int max);
+fz_error fz_read_all(fz_buffer **bufp, fz_stream *stm, int initial);
 
-static inline int fz_readbyte(fz_stream *stm)
+static inline int fz_read_byte(fz_stream *stm)
 {
 	if (stm->rp == stm->wp)
 	{
-		fz_fillbuffer(stm);
+		fz_fill_buffer(stm);
 		return stm->rp < stm->wp ? *stm->rp++ : EOF;
 	}
 	return *stm->rp++;
 }
 
-static inline int fz_peekbyte(fz_stream *stm)
+static inline int fz_peek_byte(fz_stream *stm)
 {
 	if (stm->rp == stm->wp)
 	{
-		fz_fillbuffer(stm);
+		fz_fill_buffer(stm);
 		return stm->rp < stm->wp ? *stm->rp : EOF;
 	}
 	return *stm->rp;
 }
 
-static inline void fz_unreadbyte(fz_stream *stm)
+static inline void fz_unread_byte(fz_stream *stm)
 {
 	if (stm->rp > stm->bp)
 		stm->rp--;
 }
 
-static inline int fz_iseof(fz_stream *stm)
+static inline int fz_is_eof(fz_stream *stm)
 {
 	if (stm->rp == stm->wp)
 	{
 		if (stm->eof)
 			return 1;
-		return fz_peekbyte(stm) == EOF;
+		return fz_peek_byte(stm) == EOF;
 	}
 	return 0;
 }
 
-static inline unsigned int fz_readbits(fz_stream *stm, int n)
+static inline unsigned int fz_read_bits(fz_stream *stm, int n)
 {
 	unsigned int x;
 
@@ -587,13 +585,13 @@ static inline unsigned int fz_readbits(fz_stream *stm, int n)
 
 		while (n > 8)
 		{
-			x = (x << 8) | fz_readbyte(stm);
+			x = (x << 8) | fz_read_byte(stm);
 			n -= 8;
 		}
 
 		if (n > 0)
 		{
-			stm->bits = fz_readbyte(stm);
+			stm->bits = fz_read_byte(stm);
 			stm->avail = 8 - n;
 			x = (x << n) | (stm->bits >> stm->avail);
 		}
@@ -602,64 +600,64 @@ static inline unsigned int fz_readbits(fz_stream *stm, int n)
 	return x;
 }
 
-static inline void fz_syncbits(fz_stream *stm)
+static inline void fz_sync_bits(fz_stream *stm)
 {
 	stm->avail = 0;
 }
 
-static inline int fz_iseofbits(fz_stream *stm)
+static inline int fz_is_eof_bits(fz_stream *stm)
 {
-	return fz_iseof(stm) && (stm->avail == 0 || stm->bits == EOF);
+	return fz_is_eof(stm) && (stm->avail == 0 || stm->bits == EOF);
 }
 
 /*
  * Data filters.
  */
 
-fz_stream *fz_opencopy(fz_stream *chain);
-fz_stream *fz_opennull(fz_stream *chain, int len);
-fz_stream *fz_openarc4(fz_stream *chain, unsigned char *key, unsigned keylen);
-fz_stream *fz_openaesd(fz_stream *chain, unsigned char *key, unsigned keylen);
-fz_stream *fz_opena85d(fz_stream *chain);
-fz_stream *fz_openahxd(fz_stream *chain);
-fz_stream *fz_openrld(fz_stream *chain);
-fz_stream *fz_opendctd(fz_stream *chain, fz_obj *param);
-fz_stream *fz_openfaxd(fz_stream *chain, fz_obj *param);
-fz_stream *fz_openflated(fz_stream *chain);
-fz_stream *fz_openlzwd(fz_stream *chain, fz_obj *param);
-fz_stream *fz_openpredict(fz_stream *chain, fz_obj *param);
-fz_stream *fz_openjbig2d(fz_stream *chain, fz_buffer *global);
+fz_stream *fz_open_copy(fz_stream *chain);
+fz_stream *fz_open_null(fz_stream *chain, int len);
+fz_stream *fz_open_arc4(fz_stream *chain, unsigned char *key, unsigned keylen);
+fz_stream *fz_open_aesd(fz_stream *chain, unsigned char *key, unsigned keylen);
+fz_stream *fz_open_a85d(fz_stream *chain);
+fz_stream *fz_open_ahxd(fz_stream *chain);
+fz_stream *fz_open_rld(fz_stream *chain);
+fz_stream *fz_open_dctd(fz_stream *chain, fz_obj *param);
+fz_stream *fz_open_faxd(fz_stream *chain, fz_obj *param);
+fz_stream *fz_open_flated(fz_stream *chain);
+fz_stream *fz_open_lzwd(fz_stream *chain, fz_obj *param);
+fz_stream *fz_open_predict(fz_stream *chain, fz_obj *param);
+fz_stream *fz_open_jbig2d(fz_stream *chain, fz_buffer *global);
 
 /*
  * Resources and other graphics related objects.
  */
 
-enum { FZ_MAXCOLORS = 32 };
+enum { FZ_MAX_COLORS = 32 };
 
 typedef enum fz_blendmode_e
 {
 	/* PDF 1.4 -- standard separable */
-	FZ_BNORMAL,
-	FZ_BMULTIPLY,
-	FZ_BSCREEN,
-	FZ_BOVERLAY,
-	FZ_BDARKEN,
-	FZ_BLIGHTEN,
-	FZ_BCOLORDODGE,
-	FZ_BCOLORBURN,
-	FZ_BHARDLIGHT,
-	FZ_BSOFTLIGHT,
-	FZ_BDIFFERENCE,
-	FZ_BEXCLUSION,
+	FZ_BLEND_NORMAL,
+	FZ_BLEND_MULTIPLY,
+	FZ_BLEND_SCREEN,
+	FZ_BLEND_OVERLAY,
+	FZ_BLEND_DARKEN,
+	FZ_BLEND_LIGHTEN,
+	FZ_BLEND_COLOR_DODGE,
+	FZ_BLEND_COLOR_BURN,
+	FZ_BLEND_HARD_LIGHT,
+	FZ_BLEND_SOFT_LIGHT,
+	FZ_BLEND_DIFFERENCE,
+	FZ_BLEND_EXCLUSION,
 
 	/* PDF 1.4 -- standard non-separable */
-	FZ_BHUE,
-	FZ_BSATURATION,
-	FZ_BCOLOR,
-	FZ_BLUMINOSITY,
+	FZ_BLEND_HUE,
+	FZ_BLEND_SATURATION,
+	FZ_BLEND_COLOR,
+	FZ_BLEND_LUMINOSITY,
 } fz_blendmode;
 
-extern const char *fz_blendnames[];
+extern const char *fz_blendmode_names[];
 
 /*
  * Pixmaps have n components per pixel. the last is always alpha.
@@ -679,54 +677,54 @@ struct fz_pixmap_s
 	int xres, yres;
 	fz_colorspace *colorspace;
 	unsigned char *samples;
-	int freesamples;
+	int free_samples;
 };
 
-fz_pixmap *fz_newpixmapwithdata(fz_colorspace *colorspace, int x, int y, int w, int h, unsigned char *samples);
-fz_pixmap *fz_newpixmapwithrect(fz_colorspace *, fz_bbox bbox);
-fz_pixmap *fz_newpixmap(fz_colorspace *, int x, int y, int w, int h);
-fz_pixmap *fz_keeppixmap(fz_pixmap *pix);
-void fz_droppixmap(fz_pixmap *pix);
-void fz_clearpixmap(fz_pixmap *pix);
-void fz_clearpixmapwithcolor(fz_pixmap *pix, int value);
-void fz_premultiplypixmap(fz_pixmap *pix);
-fz_pixmap *fz_alphafromgray(fz_pixmap *gray, int luminosity);
-fz_bbox fz_boundpixmap(fz_pixmap *pix);
+fz_pixmap *fz_new_pixmap_with_data(fz_colorspace *colorspace, int x, int y, int w, int h, unsigned char *samples);
+fz_pixmap *fz_new_pixmap_with_rect(fz_colorspace *, fz_bbox bbox);
+fz_pixmap *fz_new_pixmap(fz_colorspace *, int x, int y, int w, int h);
+fz_pixmap *fz_keep_pixmap(fz_pixmap *pix);
+void fz_drop_pixmap(fz_pixmap *pix);
+void fz_clear_pixmap(fz_pixmap *pix);
+void fz_clear_pixmap_with_color(fz_pixmap *pix, int value);
+void fz_premultiply_pixmap(fz_pixmap *pix);
+fz_pixmap *fz_alpha_from_gray(fz_pixmap *gray, int luminosity);
+fz_bbox fz_bound_pixmap(fz_pixmap *pix);
 
-fz_pixmap *fz_scalepixmap(fz_pixmap *src, float x, float y, float w, float h);
+fz_pixmap *fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h);
 
-fz_error fz_writepnm(fz_pixmap *pixmap, char *filename);
-fz_error fz_writepam(fz_pixmap *pixmap, char *filename, int savealpha);
-fz_error fz_writepng(fz_pixmap *pixmap, char *filename, int savealpha);
+fz_error fz_write_pnm(fz_pixmap *pixmap, char *filename);
+fz_error fz_write_pam(fz_pixmap *pixmap, char *filename, int savealpha);
+fz_error fz_write_png(fz_pixmap *pixmap, char *filename, int savealpha);
 
-fz_error fz_loadjpximage(fz_pixmap **imgp, unsigned char *data, int size);
+fz_error fz_load_jpx_image(fz_pixmap **imgp, unsigned char *data, int size);
 
 /*
  * Colorspace resources.
  */
 
-extern fz_colorspace *fz_devicegray;
-extern fz_colorspace *fz_devicergb;
-extern fz_colorspace *fz_devicebgr;
-extern fz_colorspace *fz_devicecmyk;
+extern fz_colorspace *fz_device_gray;
+extern fz_colorspace *fz_device_rgb;
+extern fz_colorspace *fz_device_bgr;
+extern fz_colorspace *fz_device_cmyk;
 
 struct fz_colorspace_s
 {
 	int refs;
 	char name[16];
 	int n;
-	void (*toxyz)(fz_colorspace *, float *src, float *xyz);
-	void (*fromxyz)(fz_colorspace *, float *xyz, float *dst);
-	void (*freedata)(fz_colorspace *);
+	void (*to_xyz)(fz_colorspace *, float *src, float *xyz);
+	void (*from_xyz)(fz_colorspace *, float *xyz, float *dst);
+	void (*free_data)(fz_colorspace *);
 	void *data;
 };
 
-fz_colorspace *fz_newcolorspace(char *name, int n);
-fz_colorspace *fz_keepcolorspace(fz_colorspace *colorspace);
-void fz_dropcolorspace(fz_colorspace *colorspace);
+fz_colorspace *fz_new_colorspace(char *name, int n);
+fz_colorspace *fz_keep_colorspace(fz_colorspace *colorspace);
+void fz_drop_colorspace(fz_colorspace *colorspace);
 
-void fz_convertcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv);
-void fz_convertpixmap(fz_pixmap *src, fz_pixmap *dst);
+void fz_convert_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv);
+void fz_convert_pixmap(fz_pixmap *src, fz_pixmap *dst);
 
 /*
  * Fonts come in two variants:
@@ -737,21 +735,21 @@ void fz_convertpixmap(fz_pixmap *src, fz_pixmap *dst);
 struct fz_device_s;
 
 typedef struct fz_font_s fz_font;
-char *ft_errorstring(int err);
+char *ft_error_string(int err);
 
 struct fz_font_s
 {
 	int refs;
 	char name[32];
 
-	void *ftface; /* has an FT_Face if used */
-	int ftsubstitute; /* ... substitute metrics */
-	int fthint; /* ... force hinting for DynaLab fonts */
+	void *ft_face; /* has an FT_Face if used */
+	int ft_substitute; /* ... substitute metrics */
+	int ft_hint; /* ... force hinting for DynaLab fonts */
 
 	/* origin of font data */
-	char *ftfile;
-	unsigned char *ftdata;
-	int ftsize;
+	char *ft_file;
+	unsigned char *ft_data;
+	int ft_size;
 
 	fz_matrix t3matrix;
 	fz_obj *t3resources;
@@ -764,81 +762,81 @@ struct fz_font_s
 	fz_rect bbox;
 
 	/* substitute metrics */
-	int widthcount;
-	int *widthtable;
+	int width_count;
+	int *width_table;
 };
 
-fz_font *fz_newtype3font(char *name, fz_matrix matrix);
+fz_font *fz_new_type3_font(char *name, fz_matrix matrix);
 
-fz_error fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index);
-fz_error fz_newfontfromfile(fz_font **fontp, char *path, int index);
+fz_error fz_new_font_from_memory(fz_font **fontp, unsigned char *data, int len, int index);
+fz_error fz_new_font_from_file(fz_font **fontp, char *path, int index);
 
-fz_font *fz_keepfont(fz_font *font);
-void fz_dropfont(fz_font *font);
+fz_font *fz_keep_font(fz_font *font);
+void fz_drop_font(fz_font *font);
 
-void fz_debugfont(fz_font *font);
-void fz_setfontbbox(fz_font *font, float xmin, float ymin, float xmax, float ymax);
+void fz_debug_font(fz_font *font);
+void fz_set_font_bbox(fz_font *font, float xmin, float ymin, float xmax, float ymax);
 
 /*
  * Vector path buffer.
  * It can be stroked and dashed, or be filled.
- * It has a fill rule (nonzero or evenodd).
+ * It has a fill rule (nonzero or even_odd).
  *
  * When rendering, they are flattened, stroked and dashed straight
  * into the Global Edge List.
  */
 
 typedef struct fz_path_s fz_path;
-typedef struct fz_strokestate_s fz_strokestate;
+typedef struct fz_stroke_state_s fz_stroke_state;
 
-typedef union fz_pathel_s fz_pathel;
+typedef union fz_path_item_s fz_path_item;
 
-typedef enum fz_pathelkind_e
+typedef enum fz_path_item_kind_e
 {
 	FZ_MOVETO,
 	FZ_LINETO,
 	FZ_CURVETO,
-	FZ_CLOSEPATH
-} fz_pathelkind;
+	FZ_CLOSE_PATH
+} fz_path_item_kind;
 
-union fz_pathel_s
+union fz_path_item_s
 {
-	fz_pathelkind k;
+	fz_path_item_kind k;
 	float v;
 };
 
 struct fz_path_s
 {
 	int len, cap;
-	fz_pathel *els;
+	fz_path_item *items;
 };
 
-struct fz_strokestate_s
+struct fz_stroke_state_s
 {
 	int linecap;
 	int linejoin;
 	float linewidth;
 	float miterlimit;
-	float dashphase;
-	int dashlen;
-	float dashlist[32];
+	float dash_phase;
+	int dash_len;
+	float dash_list[32];
 };
 
-fz_path *fz_newpath(void);
+fz_path *fz_new_path(void);
 void fz_moveto(fz_path*, float x, float y);
 void fz_lineto(fz_path*, float x, float y);
 void fz_curveto(fz_path*, float, float, float, float, float, float);
 void fz_curvetov(fz_path*, float, float, float, float);
 void fz_curvetoy(fz_path*, float, float, float, float);
 void fz_closepath(fz_path*);
-void fz_freepath(fz_path *path);
+void fz_free_path(fz_path *path);
 
-void fz_transformpath(fz_path *path, fz_matrix transform);
+void fz_transform_path(fz_path *path, fz_matrix transform);
 
-fz_path *fz_clonepath(fz_path *old);
+fz_path *fz_clone_path(fz_path *old);
 
-fz_rect fz_boundpath(fz_path *path, fz_strokestate *stroke, fz_matrix ctm);
-void fz_debugpath(fz_path *, int indent);
+fz_rect fz_bound_path(fz_path *path, fz_stroke_state *stroke, fz_matrix ctm);
+void fz_debug_path(fz_path *, int indent);
 
 /*
  * Text buffer.
@@ -853,9 +851,9 @@ void fz_debugpath(fz_path *, int indent);
  */
 
 typedef struct fz_text_s fz_text;
-typedef struct fz_textel_s fz_textel;
+typedef struct fz_text_item_s fz_text_item;
 
-struct fz_textel_s
+struct fz_text_item_s
 {
 	float x, y;
 	int gid; /* -1 for one gid to many ucs mappings */
@@ -868,15 +866,15 @@ struct fz_text_s
 	fz_matrix trm;
 	int wmode;
 	int len, cap;
-	fz_textel *els;
+	fz_text_item *items;
 };
 
-fz_text *fz_newtext(fz_font *face, fz_matrix trm, int wmode);
-void fz_addtext(fz_text *text, int gid, int ucs, float x, float y);
-void fz_freetext(fz_text *text);
-void fz_debugtext(fz_text*, int indent);
-fz_rect fz_boundtext(fz_text *text, fz_matrix ctm);
-fz_text *fz_clonetext(fz_text *old);
+fz_text *fz_new_text(fz_font *face, fz_matrix trm, int wmode);
+void fz_add_text(fz_text *text, int gid, int ucs, float x, float y);
+void fz_free_text(fz_text *text);
+void fz_debug_text(fz_text*, int indent);
+fz_rect fz_bound_text(fz_text *text, fz_matrix ctm);
+fz_text *fz_clone_text(fz_text *old);
 
 /*
  * The shading code uses gouraud shaded triangle meshes.
@@ -895,44 +893,44 @@ struct fz_shade_s
 {
 	int refs;
 
-	fz_rect bbox;		/* can be fz_infiniterect */
+	fz_rect bbox;		/* can be fz_infinite_rect */
 	fz_colorspace *colorspace;
 
 	fz_matrix matrix;	/* matrix from pattern dict */
-	int usebackground;	/* background color for fills but not 'sh' */
-	float background[FZ_MAXCOLORS];
+	int use_background;	/* background color for fills but not 'sh' */
+	float background[FZ_MAX_COLORS];
 
-	int usefunction;
-	float function[256][FZ_MAXCOLORS + 1];
+	int use_function;
+	float function[256][FZ_MAX_COLORS + 1];
 
 	int type; /* linear, radial, mesh */
 	int extend[2];
 
-	int meshlen;
-	int meshcap;
+	int mesh_len;
+	int mesh_cap;
 	float *mesh; /* [x y 0], [x y r], [x y t] or [x y c1 ... cn] */
 };
 
-fz_shade *fz_keepshade(fz_shade *shade);
-void fz_dropshade(fz_shade *shade);
-void fz_debugshade(fz_shade *shade);
+fz_shade *fz_keep_shade(fz_shade *shade);
+void fz_drop_shade(fz_shade *shade);
+void fz_debug_shade(fz_shade *shade);
 
-fz_rect fz_boundshade(fz_shade *shade, fz_matrix ctm);
-void fz_paintshade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox);
+fz_rect fz_bound_shade(fz_shade *shade, fz_matrix ctm);
+void fz_paint_shade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox);
 
 /*
  * Glyph cache
  */
 
-typedef struct fz_glyphcache_s fz_glyphcache;
+typedef struct fz_glyph_cache_s fz_glyph_cache;
 
-fz_glyphcache *fz_newglyphcache(void);
-fz_pixmap *fz_renderftglyph(fz_font *font, int cid, fz_matrix trm);
-fz_pixmap *fz_rendert3glyph(fz_font *font, int cid, fz_matrix trm);
-fz_pixmap *fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_strokestate *state);
-fz_pixmap *fz_renderglyph(fz_glyphcache*, fz_font*, int, fz_matrix);
-fz_pixmap *fz_renderstrokedglyph(fz_glyphcache*, fz_font*, int, fz_matrix, fz_matrix, fz_strokestate *stroke);
-void fz_freeglyphcache(fz_glyphcache *);
+fz_glyph_cache *fz_new_glyph_cache(void);
+fz_pixmap *fz_render_ft_glyph(fz_font *font, int cid, fz_matrix trm);
+fz_pixmap *fz_render_t3_glyph(fz_font *font, int cid, fz_matrix trm);
+fz_pixmap *fz_render_ft_stroked_glyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *state);
+fz_pixmap *fz_render_glyph(fz_glyph_cache*, fz_font*, int, fz_matrix);
+fz_pixmap *fz_render_stroked_glyph(fz_glyph_cache*, fz_font*, int, fz_matrix, fz_matrix, fz_stroke_state *stroke);
+void fz_free_glyph_cache(fz_glyph_cache *);
 
 /*
  * Scan converter
@@ -945,7 +943,7 @@ typedef struct fz_ael_s fz_ael;
 struct fz_edge_s
 {
 	int x, e, h, y;
-	int adjup, adjdown;
+	int adj_up, adj_down;
 	int xmove;
 	int xdir, ydir; /* -1 or +1 */
 };
@@ -966,23 +964,23 @@ struct fz_ael_s
 	fz_edge **edges;
 };
 
-fz_gel *fz_newgel(void);
-void fz_insertgel(fz_gel *gel, float x0, float y0, float x1, float y1);
-fz_bbox fz_boundgel(fz_gel *gel);
-void fz_resetgel(fz_gel *gel, fz_bbox clip);
-void fz_sortgel(fz_gel *gel);
-void fz_freegel(fz_gel *gel);
-int fz_isrectgel(fz_gel *gel);
+fz_gel *fz_new_gel(void);
+void fz_insert_gel(fz_gel *gel, float x0, float y0, float x1, float y1);
+fz_bbox fz_bound_gel(fz_gel *gel);
+void fz_reset_gel(fz_gel *gel, fz_bbox clip);
+void fz_sort_gel(fz_gel *gel);
+void fz_free_gel(fz_gel *gel);
+int fz_is_rect_gel(fz_gel *gel);
 
-fz_ael *fz_newael(void);
-void fz_freeael(fz_ael *ael);
+fz_ael *fz_new_ael(void);
+void fz_free_ael(fz_ael *ael);
 
-fz_error fz_scanconvert(fz_gel *gel, fz_ael *ael, int eofill,
+fz_error fz_scan_convert(fz_gel *gel, fz_ael *ael, int eofill,
 	fz_bbox clip, fz_pixmap *pix, unsigned char *colorbv);
 
-void fz_fillpath(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness);
-void fz_strokepath(fz_gel *gel, fz_path *path, fz_strokestate *stroke, fz_matrix ctm, float flatness, float linewidth);
-void fz_dashpath(fz_gel *gel, fz_path *path, fz_strokestate *stroke, fz_matrix ctm, float flatness, float linewidth);
+void fz_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness);
+void fz_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth);
+void fz_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth);
 
 /*
  * The device interface.
@@ -990,8 +988,8 @@ void fz_dashpath(fz_gel *gel, fz_path *path, fz_strokestate *stroke, fz_matrix c
 
 enum
 {
-	FZ_IGNOREIMAGE = 1,
-	FZ_IGNORESHADE = 2,
+	FZ_IGNORE_IMAGE = 1,
+	FZ_IGNORE_SHADE = 2,
 };
 
 typedef struct fz_device_s fz_device;
@@ -1001,110 +999,110 @@ struct fz_device_s
 	int hints;
 
 	void *user;
-	void (*freeuser)(void *);
+	void (*free_user)(void *);
 
-	void (*fillpath)(void *, fz_path *, int evenodd, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*strokepath)(void *, fz_path *, fz_strokestate *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*clippath)(void *, fz_path *, int evenodd, fz_matrix);
-	void (*clipstrokepath)(void *, fz_path *, fz_strokestate *, fz_matrix);
+	void (*fill_path)(void *, fz_path *, int even_odd, fz_matrix, fz_colorspace *, float *color, float alpha);
+	void (*stroke_path)(void *, fz_path *, fz_stroke_state *, fz_matrix, fz_colorspace *, float *color, float alpha);
+	void (*clip_path)(void *, fz_path *, int even_odd, fz_matrix);
+	void (*clip_stroke_path)(void *, fz_path *, fz_stroke_state *, fz_matrix);
 
-	void (*filltext)(void *, fz_text *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*stroketext)(void *, fz_text *, fz_strokestate *, fz_matrix, fz_colorspace *, float *color, float alpha);
-	void (*cliptext)(void *, fz_text *, fz_matrix, int accumulate);
-	void (*clipstroketext)(void *, fz_text *, fz_strokestate *, fz_matrix);
-	void (*ignoretext)(void *, fz_text *, fz_matrix);
+	void (*fill_text)(void *, fz_text *, fz_matrix, fz_colorspace *, float *color, float alpha);
+	void (*stroke_text)(void *, fz_text *, fz_stroke_state *, fz_matrix, fz_colorspace *, float *color, float alpha);
+	void (*clip_text)(void *, fz_text *, fz_matrix, int accumulate);
+	void (*clip_stroke_text)(void *, fz_text *, fz_stroke_state *, fz_matrix);
+	void (*ignore_text)(void *, fz_text *, fz_matrix);
 
-	void (*fillshade)(void *, fz_shade *shd, fz_matrix ctm, float alpha);
-	void (*fillimage)(void *, fz_pixmap *img, fz_matrix ctm, float alpha);
-	void (*fillimagemask)(void *, fz_pixmap *img, fz_matrix ctm, fz_colorspace *, float *color, float alpha);
-	void (*clipimagemask)(void *, fz_pixmap *img, fz_matrix ctm);
+	void (*fill_shade)(void *, fz_shade *shd, fz_matrix ctm, float alpha);
+	void (*fill_image)(void *, fz_pixmap *img, fz_matrix ctm, float alpha);
+	void (*fill_image_mask)(void *, fz_pixmap *img, fz_matrix ctm, fz_colorspace *, float *color, float alpha);
+	void (*clip_image_mask)(void *, fz_pixmap *img, fz_matrix ctm);
 
-	void (*popclip)(void *);
+	void (*pop_clip)(void *);
 
-	void (*beginmask)(void *, fz_rect, int luminosity, fz_colorspace *, float *bc);
-	void (*endmask)(void *);
-	void (*begingroup)(void *, fz_rect, int isolated, int knockout, fz_blendmode blendmode, float alpha);
-	void (*endgroup)(void *);
+	void (*begin_mask)(void *, fz_rect, int luminosity, fz_colorspace *, float *bc);
+	void (*end_mask)(void *);
+	void (*begin_group)(void *, fz_rect, int isolated, int knockout, fz_blendmode blendmode, float alpha);
+	void (*end_group)(void *);
 
-	void (*begintile)(void *, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm);
-	void (*endtile)(void *);
+	void (*begin_tile)(void *, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm);
+	void (*end_tile)(void *);
 };
 
-fz_device *fz_newdevice(void *user);
-void fz_freedevice(fz_device *dev);
+fz_device *fz_new_device(void *user);
+void fz_free_device(fz_device *dev);
 
-fz_device *fz_newtracedevice(void);
+fz_device *fz_new_trace_device(void);
 
-fz_device *fz_newbboxdevice(fz_bbox *bboxp);
+fz_device *fz_new_bbox_device(fz_bbox *bboxp);
 
-fz_device *fz_newdrawdevice(fz_glyphcache *cache, fz_pixmap *dest);
+fz_device *fz_new_draw_device(fz_glyph_cache *cache, fz_pixmap *dest);
 
 /*
  * Text extraction device
  */
 
-typedef struct fz_textspan_s fz_textspan;
-typedef struct fz_textchar_s fz_textchar;
+typedef struct fz_text_span_s fz_text_span;
+typedef struct fz_text_char_s fz_text_char;
 
-struct fz_textchar_s
+struct fz_text_char_s
 {
 	int c;
 	fz_bbox bbox;
 };
 
-struct fz_textspan_s
+struct fz_text_span_s
 {
 	fz_font *font;
 	float size;
 	int wmode;
 	int len, cap;
-	fz_textchar *text;
-	fz_textspan *next;
+	fz_text_char *text;
+	fz_text_span *next;
 	int eol;
 };
 
-fz_textspan *fz_newtextspan(void);
-void fz_freetextspan(fz_textspan *line);
-void fz_debugtextspan(fz_textspan *line);
-void fz_debugtextspanxml(fz_textspan *span);
+fz_text_span *fz_new_text_span(void);
+void fz_free_text_span(fz_text_span *line);
+void fz_debug_text_span(fz_text_span *line);
+void fz_debug_text_span_xml(fz_text_span *span);
 
-fz_device *fz_newtextdevice(fz_textspan *text);
+fz_device *fz_new_text_device(fz_text_span *text);
 
 /*
  * Display list device -- record and play back device commands.
  */
 
-typedef struct fz_displaylist_s fz_displaylist;
-typedef struct fz_displaynode_s fz_displaynode;
+typedef struct fz_display_list_s fz_display_list;
+typedef struct fz_display_node_s fz_display_node;
 
-typedef enum fz_displaycommand_e
+typedef enum fz_display_command_e
 {
-	FZ_CMDFILLPATH,
-	FZ_CMDSTROKEPATH,
-	FZ_CMDCLIPPATH,
-	FZ_CMDCLIPSTROKEPATH,
-	FZ_CMDFILLTEXT,
-	FZ_CMDSTROKETEXT,
-	FZ_CMDCLIPTEXT,
-	FZ_CMDCLIPSTROKETEXT,
-	FZ_CMDIGNORETEXT,
-	FZ_CMDFILLSHADE,
-	FZ_CMDFILLIMAGE,
-	FZ_CMDFILLIMAGEMASK,
-	FZ_CMDCLIPIMAGEMASK,
-	FZ_CMDPOPCLIP,
-	FZ_CMDBEGINMASK,
-	FZ_CMDENDMASK,
-	FZ_CMDBEGINGROUP,
-	FZ_CMDENDGROUP,
-	FZ_CMDBEGINTILE,
-	FZ_CMDENDTILE
-} fz_displaycommand;
-
-struct fz_displaynode_s
+	FZ_CMD_FILL_PATH,
+	FZ_CMD_STROKE_PATH,
+	FZ_CMD_CLIP_PATH,
+	FZ_CMD_CLIP_STROKE_PATH,
+	FZ_CMD_FILL_TEXT,
+	FZ_CMD_STROKE_TEXT,
+	FZ_CMD_CLIP_TEXT,
+	FZ_CMD_CLIP_STROKE_TEXT,
+	FZ_CMD_IGNORE_TEXT,
+	FZ_CMD_FILL_SHADE,
+	FZ_CMD_FILL_IMAGE,
+	FZ_CMD_FILL_IMAGE_MASK,
+	FZ_CMD_CLIP_IMAGE_MASK,
+	FZ_CMD_POP_CLIP,
+	FZ_CMD_BEGIN_MASK,
+	FZ_CMD_END_MASK,
+	FZ_CMD_BEGIN_GROUP,
+	FZ_CMD_END_GROUP,
+	FZ_CMD_BEGIN_TILE,
+	FZ_CMD_END_TILE
+} fz_display_command;
+
+struct fz_display_node_s
 {
-	fz_displaycommand cmd;
-	fz_displaynode *next;
+	fz_display_command cmd;
+	fz_display_node *next;
 	fz_rect rect;
 	union {
 		fz_path *path;
@@ -1113,93 +1111,46 @@ struct fz_displaynode_s
 		fz_pixmap *image;
 		fz_blendmode blendmode;
 	} item;
-	fz_strokestate *stroke;
-	int flag; /* evenodd, accumulate, isolated/knockout... */
+	fz_stroke_state *stroke;
+	int flag; /* even_odd, accumulate, isolated/knockout... */
 	fz_matrix ctm;
 	fz_colorspace *colorspace;
 	float alpha;
-	float color[FZ_MAXCOLORS];
+	float color[FZ_MAX_COLORS];
 };
 
-struct fz_displaylist_s
+struct fz_display_list_s
 {
-	fz_displaynode *first;
-	fz_displaynode *last;
+	fz_display_node *first;
+	fz_display_node *last;
 };
 
-fz_displaylist *fz_newdisplaylist(void);
-void fz_freedisplaylist(fz_displaylist *list);
-fz_device *fz_newlistdevice(fz_displaylist *list);
-void fz_executedisplaylist(fz_displaylist *list, fz_device *dev, fz_matrix ctm, fz_bbox area);
+fz_display_list *fz_new_display_list(void);
+void fz_free_display_list(fz_display_list *list);
+fz_device *fz_new_list_device(fz_display_list *list);
+void fz_execute_display_list(fz_display_list *list, fz_device *dev, fz_matrix ctm, fz_bbox area);
 
 /*
- * Function pointers for plotting functions.
- * They can be replaced by cpu-optimized versions.
+ * Plotting functions.
  */
 
-/*
-These are the blending primitives:
-
-span over span			(text and path drawing to clip mask)
-span in alpha over span
-span in span over span
-color in span over span		(text and path drawing)
-
-	fz_paintspan(dp, sp);
-		fz_paintspanalpha(dp, sp, alpha)
-	fz_paintspanmask(dp, sp, mask);
-	fz_paintspancolor(dp, color, mask);
-
-pixmap over pixmap		(shading with function lookup)
-pixmap in alpha over pixmap	(xobject/shading with ca)
-pixmap in pixmap over pixmap	(xobject with softmask / clip)
-
-	fz_paintpixmap()
-		fz_paintpixmapalpha()
-	fz_paintpixmapmask()
-
-affine over span
-affine in alpha over span
-color in affine over span
-
-	fz_paintaffine()
-		fz_paintaffinealpha()
-	fz_paintaffinecolor()
-
-image over pixmap		(image fill)
-image in alpha over pixmap	(image fill with ca)
-color in image over pixmap	(image mask fill)
-
-	fz_paintimage()
-		fz_paintimagealpha()
-	fz_paintimagecolor()
-
-pixmap BLEND pixmap
-pixmap in alpha BLEND pixmap
-
-	fz_blendpixmap()
-		fz_blendpixmapalpha()
-*/
-
 void fz_accelerate(void);
-void fz_acceleratearch(void);
-
-void fz_decodetile(fz_pixmap *pix, float *decode);
-void fz_decodeindexedtile(fz_pixmap *pix, float *decode, int maxval);
-void fz_unpacktile(fz_pixmap *dst, unsigned char * restrict src, int n, int depth, int stride, int scale);
+void fz_accelerate_arch(void);
 
-void fz_paintspan(unsigned char * restrict dp, unsigned char * restrict sp, int n, int w, int alpha);
-void fz_paintspancolor(unsigned char * restrict dp, unsigned char * restrict mp, int n, int w, unsigned char *color);
+void fz_decode_tile(fz_pixmap *pix, float *decode);
+void fz_decode_indexed_tile(fz_pixmap *pix, float *decode, int maxval);
+void fz_unpack_tile(fz_pixmap *dst, unsigned char * restrict src, int n, int depth, int stride, int scale);
 
-void fz_paintaffinecolor(unsigned char *dp, unsigned char *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, unsigned char *color);
+void fz_paint_span(unsigned char * restrict dp, unsigned char * restrict sp, int n, int w, int alpha);
+void fz_paint_span_with_color(unsigned char * restrict dp, unsigned char * restrict mp, int n, int w, unsigned char *color);
 
-void fz_paintimage(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, int alpha);
-void fz_paintimagecolor(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, unsigned char *colorbv);
+void fz_paint_image(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, int alpha);
+void fz_paint_image_with_color(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, unsigned char *colorbv);
 
-void fz_paintpixmap(fz_pixmap *dst, fz_pixmap *src, int alpha);
-void fz_paintpixmapmask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk);
-void fz_paintpixmapbbox(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_bbox bbox);
+void fz_paint_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha);
+void fz_paint_pixmap_with_mask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk);
+void fz_paint_pixmap_with_rect(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_bbox bbox);
 
-void fz_blendpixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_blendmode blendmode);
+void fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_blendmode blendmode);
 
 #endif
diff --git a/fitz/obj_array.c b/fitz/obj_array.c
index 391c1dd8..d6ffb687 100644
--- a/fitz/obj_array.c
+++ b/fitz/obj_array.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 
 fz_obj *
-fz_newarray(int initialcap)
+fz_new_array(int initialcap)
 {
 	fz_obj *obj;
 	int i;
@@ -15,56 +15,56 @@ fz_newarray(int initialcap)
 
 	obj->u.a.items = fz_calloc(obj->u.a.cap, sizeof(fz_obj*));
 	for (i = 0; i < obj->u.a.cap; i++)
-		obj->u.a.items[i] = nil;
+		obj->u.a.items[i] = NULL;
 
 	return obj;
 }
 
 fz_obj *
-fz_copyarray(fz_obj *obj)
+fz_copy_array(fz_obj *obj)
 {
 	fz_obj *new;
 	int i;
 
-	if (fz_isindirect(obj) || !fz_isarray(obj))
+	if (fz_is_indirect(obj) || !fz_is_array(obj))
 		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
 
-	new = fz_newarray(fz_arraylen(obj));
-	for (i = 0; i < fz_arraylen(obj); i++)
-		fz_arraypush(new, fz_arrayget(obj, i));
+	new = fz_new_array(fz_array_len(obj));
+	for (i = 0; i < fz_array_len(obj); i++)
+		fz_array_push(new, fz_array_get(obj, i));
 
 	return new;
 }
 
 int
-fz_arraylen(fz_obj *obj)
+fz_array_len(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (!fz_isarray(obj))
+	obj = fz_resolve_indirect(obj);
+	if (!fz_is_array(obj))
 		return 0;
 	return obj->u.a.len;
 }
 
 fz_obj *
-fz_arrayget(fz_obj *obj, int i)
+fz_array_get(fz_obj *obj, int i)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isarray(obj))
-		return nil;
+	if (!fz_is_array(obj))
+		return NULL;
 
 	if (i < 0 || i >= obj->u.a.len)
-		return nil;
+		return NULL;
 
 	return obj->u.a.items[i];
 }
 
 void
-fz_arrayput(fz_obj *obj, int i, fz_obj *item)
+fz_array_put(fz_obj *obj, int i, fz_obj *item)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isarray(obj))
+	if (!fz_is_array(obj))
 		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
 	else if (i < 0)
 		fz_warn("assert: index %d < 0", i);
@@ -73,17 +73,17 @@ fz_arrayput(fz_obj *obj, int i, fz_obj *item)
 	else
 	{
 		if (obj->u.a.items[i])
-			fz_dropobj(obj->u.a.items[i]);
-		obj->u.a.items[i] = fz_keepobj(item);
+			fz_drop_obj(obj->u.a.items[i]);
+		obj->u.a.items[i] = fz_keep_obj(item);
 	}
 }
 
 void
-fz_arraypush(fz_obj *obj, fz_obj *item)
+fz_array_push(fz_obj *obj, fz_obj *item)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isarray(obj))
+	if (!fz_is_array(obj))
 		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
 	else
 	{
@@ -93,35 +93,35 @@ fz_arraypush(fz_obj *obj, fz_obj *item)
 			obj->u.a.cap = (obj->u.a.cap * 3) / 2;
 			obj->u.a.items = fz_realloc(obj->u.a.items, obj->u.a.cap, sizeof(fz_obj*));
 			for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
-				obj->u.a.items[i] = nil;
+				obj->u.a.items[i] = NULL;
 		}
-		obj->u.a.items[obj->u.a.len] = fz_keepobj(item);
+		obj->u.a.items[obj->u.a.len] = fz_keep_obj(item);
 		obj->u.a.len++;
 	}
 }
 
 void
-fz_arraydrop(fz_obj *obj)
+fz_array_drop(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isarray(obj))
+	if (!fz_is_array(obj))
 		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
 	else
 	{
 		if (obj->u.a.len > 0)
 		{
-			fz_dropobj(obj->u.a.items[--obj->u.a.len]);
+			fz_drop_obj(obj->u.a.items[--obj->u.a.len]);
 		}
 	}
 }
 
 void
-fz_arrayinsert(fz_obj *obj, fz_obj *item)
+fz_array_insert(fz_obj *obj, fz_obj *item)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isarray(obj))
+	if (!fz_is_array(obj))
 		fz_warn("assert: not an array (%s)", fz_objkindstr(obj));
 	else
 	{
@@ -131,16 +131,16 @@ fz_arrayinsert(fz_obj *obj, fz_obj *item)
 			obj->u.a.cap = (obj->u.a.cap * 3) / 2;
 			obj->u.a.items = fz_realloc(obj->u.a.items, obj->u.a.cap, sizeof(fz_obj*));
 			for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
-				obj->u.a.items[i] = nil;
+				obj->u.a.items[i] = NULL;
 		}
 		memmove(obj->u.a.items + 1, obj->u.a.items, obj->u.a.len * sizeof(fz_obj*));
-		obj->u.a.items[0] = fz_keepobj(item);
+		obj->u.a.items[0] = fz_keep_obj(item);
 		obj->u.a.len++;
 	}
 }
 
 void
-fz_freearray(fz_obj *obj)
+fz_free_array(fz_obj *obj)
 {
 	int i;
 
@@ -148,7 +148,7 @@ fz_freearray(fz_obj *obj)
 
 	for (i = 0; i < obj->u.a.len; i++)
 		if (obj->u.a.items[i])
-			fz_dropobj(obj->u.a.items[i]);
+			fz_drop_obj(obj->u.a.items[i]);
 
 	fz_free(obj->u.a.items);
 	fz_free(obj);
diff --git a/fitz/obj_dict.c b/fitz/obj_dict.c
index d1cc22cc..6f3ba9da 100644
--- a/fitz/obj_dict.c
+++ b/fitz/obj_dict.c
@@ -6,20 +6,20 @@ static int keyvalcmp(const void *ap, const void *bp)
 {
 	const fz_keyval *a = ap;
 	const fz_keyval *b = bp;
-	if (fz_isname(a->k) && fz_isname(b->k))
-		return strcmp(fz_toname(a->k), fz_toname(b->k));
+	if (fz_is_name(a->k) && fz_is_name(b->k))
+		return strcmp(fz_to_name(a->k), fz_to_name(b->k));
 	return -1;
 }
 
 static inline int keystrcmp(fz_obj *key, char *s)
 {
-	if (fz_isname(key))
-		return strcmp(fz_toname(key), s);
+	if (fz_is_name(key))
+		return strcmp(fz_to_name(key), s);
 	return -1;
 }
 
 fz_obj *
-fz_newdict(int initialcap)
+fz_new_dict(int initialcap)
 {
 	fz_obj *obj;
 	int i;
@@ -35,68 +35,68 @@ fz_newdict(int initialcap)
 	obj->u.d.items = fz_calloc(obj->u.d.cap, sizeof(fz_keyval));
 	for (i = 0; i < obj->u.d.cap; i++)
 	{
-		obj->u.d.items[i].k = nil;
-		obj->u.d.items[i].v = nil;
+		obj->u.d.items[i].k = NULL;
+		obj->u.d.items[i].v = NULL;
 	}
 
 	return obj;
 }
 
 fz_obj *
-fz_copydict(fz_obj *obj)
+fz_copy_dict(fz_obj *obj)
 {
 	fz_obj *new;
 	int i;
 
-	if (fz_isindirect(obj) || !fz_isdict(obj))
+	if (fz_is_indirect(obj) || !fz_is_dict(obj))
 		fz_throw("assert: not a dict (%s)", fz_objkindstr(obj));
 
-	new = fz_newdict(fz_dictlen(obj));
-	for (i = 0; i < fz_dictlen(obj); i++)
-		fz_dictput(new, fz_dictgetkey(obj, i), fz_dictgetval(obj, i));
+	new = fz_new_dict(fz_dict_len(obj));
+	for (i = 0; i < fz_dict_len(obj); i++)
+		fz_dict_put(new, fz_dict_get_key(obj, i), fz_dict_get_val(obj, i));
 
 	return new;
 }
 
 int
-fz_dictlen(fz_obj *obj)
+fz_dict_len(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (!fz_isdict(obj))
+	obj = fz_resolve_indirect(obj);
+	if (!fz_is_dict(obj))
 		return 0;
 	return obj->u.d.len;
 }
 
 fz_obj *
-fz_dictgetkey(fz_obj *obj, int i)
+fz_dict_get_key(fz_obj *obj, int i)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
-		return nil;
+	if (!fz_is_dict(obj))
+		return NULL;
 
 	if (i < 0 || i >= obj->u.d.len)
-		return nil;
+		return NULL;
 
 	return obj->u.d.items[i].k;
 }
 
 fz_obj *
-fz_dictgetval(fz_obj *obj, int i)
+fz_dict_get_val(fz_obj *obj, int i)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
-		return nil;
+	if (!fz_is_dict(obj))
+		return NULL;
 
 	if (i < 0 || i >= obj->u.d.len)
-		return nil;
+		return NULL;
 
 	return obj->u.d.items[i].v;
 }
 
 static inline int
-fz_dictfinds(fz_obj *obj, char *key)
+fz_dict_finds(fz_obj *obj, char *key)
 {
 	if (obj->u.d.sorted)
 	{
@@ -127,56 +127,56 @@ fz_dictfinds(fz_obj *obj, char *key)
 }
 
 fz_obj *
-fz_dictgets(fz_obj *obj, char *key)
+fz_dict_gets(fz_obj *obj, char *key)
 {
 	int i;
 
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
-		return nil;
+	if (!fz_is_dict(obj))
+		return NULL;
 
-	i = fz_dictfinds(obj, key);
+	i = fz_dict_finds(obj, key);
 	if (i >= 0)
 		return obj->u.d.items[i].v;
 
-	return nil;
+	return NULL;
 }
 
 fz_obj *
-fz_dictget(fz_obj *obj, fz_obj *key)
+fz_dict_get(fz_obj *obj, fz_obj *key)
 {
-	if (fz_isname(key))
-		return fz_dictgets(obj, fz_toname(key));
-	return nil;
+	if (fz_is_name(key))
+		return fz_dict_gets(obj, fz_to_name(key));
+	return NULL;
 }
 
 fz_obj *
-fz_dictgetsa(fz_obj *obj, char *key, char *abbrev)
+fz_dict_getsa(fz_obj *obj, char *key, char *abbrev)
 {
 	fz_obj *v;
-	v = fz_dictgets(obj, key);
+	v = fz_dict_gets(obj, key);
 	if (v)
 		return v;
-	return fz_dictgets(obj, abbrev);
+	return fz_dict_gets(obj, abbrev);
 }
 
 void
-fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
+fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 {
 	char *s;
 	int i;
 
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
+	if (!fz_is_dict(obj))
 	{
 		fz_warn("assert: not a dict (%s)", fz_objkindstr(obj));
 		return;
 	}
 
-	if (fz_isname(key))
-		s = fz_toname(key);
+	if (fz_is_name(key))
+		s = fz_to_name(key);
 	else
 	{
 		fz_warn("assert: key is not a name (%s)", fz_objkindstr(obj));
@@ -189,11 +189,11 @@ fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 		return;
 	}
 
-	i = fz_dictfinds(obj, s);
+	i = fz_dict_finds(obj, s);
 	if (i >= 0)
 	{
-		fz_dropobj(obj->u.d.items[i].v);
-		obj->u.d.items[i].v = fz_keepobj(val);
+		fz_drop_obj(obj->u.d.items[i].v);
+		obj->u.d.items[i].v = fz_keep_obj(val);
 		return;
 	}
 
@@ -203,8 +203,8 @@ fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 		obj->u.d.items = fz_realloc(obj->u.d.items, obj->u.d.cap, sizeof(fz_keyval));
 		for (i = obj->u.d.len; i < obj->u.d.cap; i++)
 		{
-			obj->u.d.items[i].k = nil;
-			obj->u.d.items[i].v = nil;
+			obj->u.d.items[i].k = NULL;
+			obj->u.d.items[i].v = NULL;
 		}
 	}
 
@@ -213,33 +213,33 @@ fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 		if (keystrcmp(obj->u.d.items[obj->u.d.len - 1].k, s) > 0)
 			obj->u.d.sorted = 0;
 
-	obj->u.d.items[obj->u.d.len].k = fz_keepobj(key);
-	obj->u.d.items[obj->u.d.len].v = fz_keepobj(val);
+	obj->u.d.items[obj->u.d.len].k = fz_keep_obj(key);
+	obj->u.d.items[obj->u.d.len].v = fz_keep_obj(val);
 	obj->u.d.len ++;
 }
 
 void
-fz_dictputs(fz_obj *obj, char *key, fz_obj *val)
+fz_dict_puts(fz_obj *obj, char *key, fz_obj *val)
 {
-	fz_obj *keyobj = fz_newname(key);
-	fz_dictput(obj, keyobj, val);
-	fz_dropobj(keyobj);
+	fz_obj *keyobj = fz_new_name(key);
+	fz_dict_put(obj, keyobj, val);
+	fz_drop_obj(keyobj);
 }
 
 void
-fz_dictdels(fz_obj *obj, char *key)
+fz_dict_dels(fz_obj *obj, char *key)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
+	if (!fz_is_dict(obj))
 		fz_warn("assert: not a dict (%s)", fz_objkindstr(obj));
 	else
 	{
-		int i = fz_dictfinds(obj, key);
+		int i = fz_dict_finds(obj, key);
 		if (i >= 0)
 		{
-			fz_dropobj(obj->u.d.items[i].k);
-			fz_dropobj(obj->u.d.items[i].v);
+			fz_drop_obj(obj->u.d.items[i].k);
+			fz_drop_obj(obj->u.d.items[i].v);
 			obj->u.d.sorted = 0;
 			obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1];
 			obj->u.d.len --;
@@ -248,29 +248,29 @@ fz_dictdels(fz_obj *obj, char *key)
 }
 
 void
-fz_dictdel(fz_obj *obj, fz_obj *key)
+fz_dict_del(fz_obj *obj, fz_obj *key)
 {
-	if (fz_isname(key))
-		fz_dictdels(obj, fz_toname(key));
+	if (fz_is_name(key))
+		fz_dict_dels(obj, fz_to_name(key));
 	else
 		fz_warn("assert: key is not a name (%s)", fz_objkindstr(obj));
 }
 
 void
-fz_freedict(fz_obj *obj)
+fz_free_dict(fz_obj *obj)
 {
 	int i;
 
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 
-	if (!fz_isdict(obj))
+	if (!fz_is_dict(obj))
 		return;
 
 	for (i = 0; i < obj->u.d.len; i++) {
 		if (obj->u.d.items[i].k)
-			fz_dropobj(obj->u.d.items[i].k);
+			fz_drop_obj(obj->u.d.items[i].k);
 		if (obj->u.d.items[i].v)
-			fz_dropobj(obj->u.d.items[i].v);
+			fz_drop_obj(obj->u.d.items[i].v);
 	}
 
 	fz_free(obj->u.d.items);
@@ -278,10 +278,10 @@ fz_freedict(fz_obj *obj)
 }
 
 void
-fz_sortdict(fz_obj *obj)
+fz_sort_dict(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (!fz_isdict(obj))
+	obj = fz_resolve_indirect(obj);
+	if (!fz_is_dict(obj))
 		return;
 	if (!obj->u.d.sorted)
 	{
diff --git a/fitz/obj_print.c b/fitz/obj_print.c
index 4233b80f..3433903c 100644
--- a/fitz/obj_print.c
+++ b/fitz/obj_print.c
@@ -12,7 +12,7 @@ struct fmt
 	int last;
 };
 
-static void fmtobj(struct fmt *fmt, fz_obj *obj);
+static void fmt_obj(struct fmt *fmt, fz_obj *obj);
 
 static inline int iswhite(int ch)
 {
@@ -35,11 +35,11 @@ static inline int isdelim(int ch)
 		ch == '%';
 }
 
-static inline void fmtputc(struct fmt *fmt, int c)
+static inline void fmt_putc(struct fmt *fmt, int c)
 {
 	if (fmt->sep && !isdelim(fmt->last) && !isdelim(c)) {
 		fmt->sep = 0;
-		fmtputc(fmt, ' ');
+		fmt_putc(fmt, ' ');
 	}
 	fmt->sep = 0;
 
@@ -56,195 +56,195 @@ static inline void fmtputc(struct fmt *fmt, int c)
 	fmt->last = c;
 }
 
-static inline void fmtindent(struct fmt *fmt)
+static inline void fmt_indent(struct fmt *fmt)
 {
 	int i = fmt->indent;
 	while (i--) {
-		fmtputc(fmt, ' ');
-		fmtputc(fmt, ' ');
+		fmt_putc(fmt, ' ');
+		fmt_putc(fmt, ' ');
 	}
 }
 
-static inline void fmtputs(struct fmt *fmt, char *s)
+static inline void fmt_puts(struct fmt *fmt, char *s)
 {
 	while (*s)
-		fmtputc(fmt, *s++);
+		fmt_putc(fmt, *s++);
 }
 
-static inline void fmtsep(struct fmt *fmt)
+static inline void fmt_sep(struct fmt *fmt)
 {
 	fmt->sep = 1;
 }
 
-static void fmtstr(struct fmt *fmt, fz_obj *obj)
+static void fmt_str(struct fmt *fmt, fz_obj *obj)
 {
 	int i, c;
 
-	fmtputc(fmt, '(');
+	fmt_putc(fmt, '(');
 	for (i = 0; i < obj->u.s.len; i++)
 	{
 		c = (unsigned char) obj->u.s.buf[i];
 		if (c == '\n')
-			fmtputs(fmt, "\\n");
+			fmt_puts(fmt, "\\n");
 		else if (c == '\r')
-			fmtputs(fmt, "\\r");
+			fmt_puts(fmt, "\\r");
 		else if (c == '\t')
-			fmtputs(fmt, "\\t");
+			fmt_puts(fmt, "\\t");
 		else if (c == '\b')
-			fmtputs(fmt, "\\b");
+			fmt_puts(fmt, "\\b");
 		else if (c == '\f')
-			fmtputs(fmt, "\\f");
+			fmt_puts(fmt, "\\f");
 		else if (c == '(')
-			fmtputs(fmt, "\\(");
+			fmt_puts(fmt, "\\(");
 		else if (c == ')')
-			fmtputs(fmt, "\\)");
+			fmt_puts(fmt, "\\)");
 		else if (c < 32 || c > 126) {
 			char buf[16];
-			fmtputc(fmt, '\\');
+			fmt_putc(fmt, '\\');
 			sprintf(buf, "%o", c);
-			fmtputs(fmt, buf);
+			fmt_puts(fmt, buf);
 		}
 		else
-			fmtputc(fmt, c);
+			fmt_putc(fmt, c);
 	}
-	fmtputc(fmt, ')');
+	fmt_putc(fmt, ')');
 }
 
-static void fmthex(struct fmt *fmt, fz_obj *obj)
+static void fmt_hex(struct fmt *fmt, fz_obj *obj)
 {
 	int i, b, c;
 
-	fmtputc(fmt, '<');
+	fmt_putc(fmt, '<');
 	for (i = 0; i < obj->u.s.len; i++) {
 		b = (unsigned char) obj->u.s.buf[i];
 		c = (b >> 4) & 0x0f;
-		fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
+		fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
 		c = (b) & 0x0f;
-		fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
+		fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
 	}
-	fmtputc(fmt, '>');
+	fmt_putc(fmt, '>');
 }
 
-static void fmtname(struct fmt *fmt, fz_obj *obj)
+static void fmt_name(struct fmt *fmt, fz_obj *obj)
 {
-	unsigned char *s = (unsigned char *) fz_toname(obj);
+	unsigned char *s = (unsigned char *) fz_to_name(obj);
 	int i, c;
 
-	fmtputc(fmt, '/');
+	fmt_putc(fmt, '/');
 
 	for (i = 0; s[i]; i++)
 	{
 		if (isdelim(s[i]) || iswhite(s[i]) ||
 			s[i] == '#' || s[i] < 32 || s[i] > 127)
 		{
-			fmtputc(fmt, '#');
+			fmt_putc(fmt, '#');
 			c = (s[i] >> 4) & 0xf;
-			fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
+			fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
 			c = s[i] & 0xf;
-			fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
+			fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA);
 		}
 		else
 		{
-			fmtputc(fmt, s[i]);
+			fmt_putc(fmt, s[i]);
 		}
 	}
 }
 
-static void fmtarray(struct fmt *fmt, fz_obj *obj)
+static void fmt_array(struct fmt *fmt, fz_obj *obj)
 {
 	int i;
 
 	if (fmt->tight) {
-		fmtputc(fmt, '[');
-		for (i = 0; i < fz_arraylen(obj); i++) {
-			fmtobj(fmt, fz_arrayget(obj, i));
-			fmtsep(fmt);
+		fmt_putc(fmt, '[');
+		for (i = 0; i < fz_array_len(obj); i++) {
+			fmt_obj(fmt, fz_array_get(obj, i));
+			fmt_sep(fmt);
 		}
-		fmtputc(fmt, ']');
+		fmt_putc(fmt, ']');
 	}
 	else {
-		fmtputs(fmt, "[ ");
-		for (i = 0; i < fz_arraylen(obj); i++) {
+		fmt_puts(fmt, "[ ");
+		for (i = 0; i < fz_array_len(obj); i++) {
 			if (fmt->col > 60) {
-				fmtputc(fmt, '\n');
-				fmtindent(fmt);
+				fmt_putc(fmt, '\n');
+				fmt_indent(fmt);
 			}
-			fmtobj(fmt, fz_arrayget(obj, i));
-			fmtputc(fmt, ' ');
+			fmt_obj(fmt, fz_array_get(obj, i));
+			fmt_putc(fmt, ' ');
 		}
-		fmtputc(fmt, ']');
-		fmtsep(fmt);
+		fmt_putc(fmt, ']');
+		fmt_sep(fmt);
 	}
 }
 
-static void fmtdict(struct fmt *fmt, fz_obj *obj)
+static void fmt_dict(struct fmt *fmt, fz_obj *obj)
 {
 	int i;
 	fz_obj *key, *val;
 
 	if (fmt->tight) {
-		fmtputs(fmt, "<<");
-		for (i = 0; i < fz_dictlen(obj); i++) {
-			fmtobj(fmt, fz_dictgetkey(obj, i));
-			fmtsep(fmt);
-			fmtobj(fmt, fz_dictgetval(obj, i));
-			fmtsep(fmt);
+		fmt_puts(fmt, "<<");
+		for (i = 0; i < fz_dict_len(obj); i++) {
+			fmt_obj(fmt, fz_dict_get_key(obj, i));
+			fmt_sep(fmt);
+			fmt_obj(fmt, fz_dict_get_val(obj, i));
+			fmt_sep(fmt);
 		}
-		fmtputs(fmt, ">>");
+		fmt_puts(fmt, ">>");
 	}
 	else {
-		fmtputs(fmt, "<<\n");
+		fmt_puts(fmt, "<<\n");
 		fmt->indent ++;
-		for (i = 0; i < fz_dictlen(obj); i++) {
-			key = fz_dictgetkey(obj, i);
-			val = fz_dictgetval(obj, i);
-			fmtindent(fmt);
-			fmtobj(fmt, key);
-			fmtputc(fmt, ' ');
-			if (!fz_isindirect(val) && fz_isarray(val))
+		for (i = 0; i < fz_dict_len(obj); i++) {
+			key = fz_dict_get_key(obj, i);
+			val = fz_dict_get_val(obj, i);
+			fmt_indent(fmt);
+			fmt_obj(fmt, key);
+			fmt_putc(fmt, ' ');
+			if (!fz_is_indirect(val) && fz_is_array(val))
 				fmt->indent ++;
-			fmtobj(fmt, val);
-			fmtputc(fmt, '\n');
-			if (!fz_isindirect(val) && fz_isarray(val))
+			fmt_obj(fmt, val);
+			fmt_putc(fmt, '\n');
+			if (!fz_is_indirect(val) && fz_is_array(val))
 				fmt->indent --;
 		}
 		fmt->indent --;
-		fmtindent(fmt);
-		fmtputs(fmt, ">>");
+		fmt_indent(fmt);
+		fmt_puts(fmt, ">>");
 	}
 }
 
-static void fmtobj(struct fmt *fmt, fz_obj *obj)
+static void fmt_obj(struct fmt *fmt, fz_obj *obj)
 {
 	char buf[256];
 
 	if (!obj)
-		fmtputs(fmt, "<nil>");
-	else if (fz_isindirect(obj))
+		fmt_puts(fmt, "<NULL>");
+	else if (fz_is_indirect(obj))
 	{
-		sprintf(buf, "%d %d R", fz_tonum(obj), fz_togen(obj));
-		fmtputs(fmt, buf);
+		sprintf(buf, "%d %d R", fz_to_num(obj), fz_to_gen(obj));
+		fmt_puts(fmt, buf);
 	}
-	else if (fz_isnull(obj))
-		fmtputs(fmt, "null");
-	else if (fz_isbool(obj))
-		fmtputs(fmt, fz_tobool(obj) ? "true" : "false");
-	else if (fz_isint(obj))
+	else if (fz_is_null(obj))
+		fmt_puts(fmt, "null");
+	else if (fz_is_bool(obj))
+		fmt_puts(fmt, fz_to_bool(obj) ? "true" : "false");
+	else if (fz_is_int(obj))
 	{
-		sprintf(buf, "%d", fz_toint(obj));
-		fmtputs(fmt, buf);
+		sprintf(buf, "%d", fz_to_int(obj));
+		fmt_puts(fmt, buf);
 	}
-	else if (fz_isreal(obj))
+	else if (fz_is_real(obj))
 	{
-		sprintf(buf, "%g", fz_toreal(obj));
+		sprintf(buf, "%g", fz_to_real(obj));
 		if (strchr(buf, 'e')) /* bad news! */
-			sprintf(buf, fabsf(fz_toreal(obj)) > 1 ? "%1.1f" : "%1.8f", fz_toreal(obj));
-		fmtputs(fmt, buf);
+			sprintf(buf, fabsf(fz_to_real(obj)) > 1 ? "%1.1f" : "%1.8f", fz_to_real(obj));
+		fmt_puts(fmt, buf);
 	}
-	else if (fz_isstring(obj))
+	else if (fz_is_string(obj))
 	{
-		char *str = fz_tostrbuf(obj);
-		int len = fz_tostrlen(obj);
+		char *str = fz_to_str_buf(obj);
+		int len = fz_to_str_len(obj);
 		int added = 0;
 		int i, c;
 		for (i = 0; i < len; i++) {
@@ -259,22 +259,22 @@ static void fmtobj(struct fmt *fmt, fz_obj *obj)
 				added += 3;
 		}
 		if (added < obj->u.s.len)
-			fmtstr(fmt, obj);
+			fmt_str(fmt, obj);
 		else
-			fmthex(fmt, obj);
+			fmt_hex(fmt, obj);
 	}
-	else if (fz_isname(obj))
-		fmtname(fmt, obj);
-	else if (fz_isarray(obj))
-		fmtarray(fmt, obj);
-	else if (fz_isdict(obj))
-		fmtdict(fmt, obj);
+	else if (fz_is_name(obj))
+		fmt_name(fmt, obj);
+	else if (fz_is_array(obj))
+		fmt_array(fmt, obj);
+	else if (fz_is_dict(obj))
+		fmt_dict(fmt, obj);
 	else
-		fmtputs(fmt, "<unknown object>");
+		fmt_puts(fmt, "<unknown object>");
 }
 
 static int
-fz_sprintobj(char *s, int n, fz_obj *obj, int tight)
+fz_sprint_obj(char *s, int n, fz_obj *obj, int tight)
 {
 	struct fmt fmt;
 
@@ -287,7 +287,7 @@ fz_sprintobj(char *s, int n, fz_obj *obj, int tight)
 	fmt.buf = s;
 	fmt.cap = n;
 	fmt.len = 0;
-	fmtobj(&fmt, obj);
+	fmt_obj(&fmt, obj);
 
 	if (fmt.buf && fmt.len < fmt.cap)
 		fmt.buf[fmt.len] = '\0';
@@ -296,23 +296,23 @@ fz_sprintobj(char *s, int n, fz_obj *obj, int tight)
 }
 
 int
-fz_fprintobj(FILE *fp, fz_obj *obj, int tight)
+fz_fprint_obj(FILE *fp, fz_obj *obj, int tight)
 {
 	char buf[1024];
 	char *ptr;
 	int n;
 
-	n = fz_sprintobj(nil, 0, obj, tight);
+	n = fz_sprint_obj(NULL, 0, obj, tight);
 	if ((n + 1) < sizeof buf)
 	{
-		fz_sprintobj(buf, sizeof buf, obj, tight);
+		fz_sprint_obj(buf, sizeof buf, obj, tight);
 		fputs(buf, fp);
 		fputc('\n', fp);
 	}
 	else
 	{
 		ptr = fz_malloc(n + 1);
-		fz_sprintobj(ptr, n + 1, obj, tight);
+		fz_sprint_obj(ptr, n + 1, obj, tight);
 		fputs(ptr, fp);
 		fputc('\n', fp);
 		fz_free(ptr);
@@ -321,16 +321,15 @@ fz_fprintobj(FILE *fp, fz_obj *obj, int tight)
 }
 
 void
-fz_debugobj(fz_obj *obj)
+fz_debug_obj(fz_obj *obj)
 {
-	fz_fprintobj(stdout, obj, 0);
+	fz_fprint_obj(stdout, obj, 0);
 }
 
 void
-fz_debugref(fz_obj *ref)
+fz_debug_ref(fz_obj *ref)
 {
 	fz_obj *obj;
-	obj = fz_resolveindirect(ref);
-	fz_debugobj(obj);
+	obj = fz_resolve_indirect(ref);
+	fz_debug_obj(obj);
 }
-
diff --git a/fitz/obj_simple.c b/fitz/obj_simple.c
index b629974e..2dc9d686 100644
--- a/fitz/obj_simple.c
+++ b/fitz/obj_simple.c
@@ -1,17 +1,17 @@
 #include "fitz.h"
 
-extern void fz_freearray(fz_obj *array);
-extern void fz_freedict(fz_obj *dict);
+extern void fz_free_array(fz_obj *array);
+extern void fz_free_dict(fz_obj *dict);
 
 static fz_obj *fz_resolve_indirect_null(fz_obj *ref)
 {
 	return ref;
 }
 
-fz_obj* (*fz_resolveindirect)(fz_obj*) = fz_resolve_indirect_null;
+fz_obj* (*fz_resolve_indirect)(fz_obj*) = fz_resolve_indirect_null;
 
 fz_obj *
-fz_newnull(void)
+fz_new_null(void)
 {
 	fz_obj *o = fz_malloc(sizeof(fz_obj));
 	o->refs = 1;
@@ -20,7 +20,7 @@ fz_newnull(void)
 }
 
 fz_obj *
-fz_newbool(int b)
+fz_new_bool(int b)
 {
 	fz_obj *o = fz_malloc(sizeof(fz_obj));
 	o->refs = 1;
@@ -30,7 +30,7 @@ fz_newbool(int b)
 }
 
 fz_obj *
-fz_newint(int i)
+fz_new_int(int i)
 {
 	fz_obj *o = fz_malloc(sizeof(fz_obj));
 	o->refs = 1;
@@ -40,7 +40,7 @@ fz_newint(int i)
 }
 
 fz_obj *
-fz_newreal(float f)
+fz_new_real(float f)
 {
 	fz_obj *o = fz_malloc(sizeof(fz_obj));
 	o->refs = 1;
@@ -50,7 +50,7 @@ fz_newreal(float f)
 }
 
 fz_obj *
-fz_newstring(char *str, int len)
+fz_new_string(char *str, int len)
 {
 	fz_obj *o = fz_malloc(offsetof(fz_obj, u.s.buf) + len + 1);
 	o->refs = 1;
@@ -62,7 +62,7 @@ fz_newstring(char *str, int len)
 }
 
 fz_obj *
-fz_newname(char *str)
+fz_new_name(char *str)
 {
 	fz_obj *o = fz_malloc(offsetof(fz_obj, u.n) + strlen(str) + 1);
 	o->refs = 1;
@@ -72,7 +72,7 @@ fz_newname(char *str)
 }
 
 fz_obj *
-fz_newindirect(int num, int gen, void *xref)
+fz_new_indirect(int num, int gen, void *xref)
 {
 	fz_obj *o = fz_malloc(sizeof(fz_obj));
 	o->refs = 1;
@@ -84,143 +84,143 @@ fz_newindirect(int num, int gen, void *xref)
 }
 
 fz_obj *
-fz_keepobj(fz_obj *o)
+fz_keep_obj(fz_obj *o)
 {
-	assert(o != nil);
+	assert(o != NULL);
 	o->refs ++;
 	return o;
 }
 
 void
-fz_dropobj(fz_obj *o)
+fz_drop_obj(fz_obj *o)
 {
-	assert(o != nil);
+	assert(o != NULL);
 	if (--o->refs == 0)
 	{
 		if (o->kind == FZ_ARRAY)
-			fz_freearray(o);
+			fz_free_array(o);
 		else if (o->kind == FZ_DICT)
-			fz_freedict(o);
+			fz_free_dict(o);
 		else
 			fz_free(o);
 	}
 }
 
-int fz_isindirect(fz_obj *obj)
+int fz_is_indirect(fz_obj *obj)
 {
 	return obj ? obj->kind == FZ_INDIRECT : 0;
 }
 
-int fz_isnull(fz_obj *obj)
+int fz_is_null(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_NULL : 0;
 }
 
-int fz_isbool(fz_obj *obj)
+int fz_is_bool(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_BOOL : 0;
 }
 
-int fz_isint(fz_obj *obj)
+int fz_is_int(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_INT : 0;
 }
 
-int fz_isreal(fz_obj *obj)
+int fz_is_real(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_REAL : 0;
 }
 
-int fz_isstring(fz_obj *obj)
+int fz_is_string(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_STRING : 0;
 }
 
-int fz_isname(fz_obj *obj)
+int fz_is_name(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_NAME : 0;
 }
 
-int fz_isarray(fz_obj *obj)
+int fz_is_array(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_ARRAY : 0;
 }
 
-int fz_isdict(fz_obj *obj)
+int fz_is_dict(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
+	obj = fz_resolve_indirect(obj);
 	return obj ? obj->kind == FZ_DICT : 0;
 }
 
-int fz_tobool(fz_obj *obj)
+int fz_to_bool(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isbool(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_bool(obj))
 		return obj->u.b;
 	return 0;
 }
 
-int fz_toint(fz_obj *obj)
+int fz_to_int(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isint(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_int(obj))
 		return obj->u.i;
-	if (fz_isreal(obj))
+	if (fz_is_real(obj))
 		return obj->u.f;
 	return 0;
 }
 
-float fz_toreal(fz_obj *obj)
+float fz_to_real(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isreal(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_real(obj))
 		return obj->u.f;
-	if (fz_isint(obj))
+	if (fz_is_int(obj))
 		return obj->u.i;
 	return 0;
 }
 
-char *fz_toname(fz_obj *obj)
+char *fz_to_name(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isname(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_name(obj))
 		return obj->u.n;
 	return "";
 }
 
-char *fz_tostrbuf(fz_obj *obj)
+char *fz_to_str_buf(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isstring(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_string(obj))
 		return obj->u.s.buf;
 	return "";
 }
 
-int fz_tostrlen(fz_obj *obj)
+int fz_to_str_len(fz_obj *obj)
 {
-	obj = fz_resolveindirect(obj);
-	if (fz_isstring(obj))
+	obj = fz_resolve_indirect(obj);
+	if (fz_is_string(obj))
 		return obj->u.s.len;
 	return 0;
 }
 
-int fz_tonum(fz_obj *obj)
+int fz_to_num(fz_obj *obj)
 {
-	if (fz_isindirect(obj))
+	if (fz_is_indirect(obj))
 		return obj->u.r.num;
 	return 0;
 }
 
-int fz_togen(fz_obj *obj)
+int fz_to_gen(fz_obj *obj)
 {
-	if (fz_isindirect(obj))
+	if (fz_is_indirect(obj))
 		return obj->u.r.gen;
 	return 0;
 }
@@ -306,8 +306,8 @@ fz_objcmp(fz_obj *a, fz_obj *b)
 
 char *fz_objkindstr(fz_obj *obj)
 {
-	if (obj == nil)
-		return "<nil>";
+	if (obj == NULL)
+		return "<NULL>";
 	switch (obj->kind)
 	{
 	case FZ_NULL: return "null";
diff --git a/fitz/res_colorspace.c b/fitz/res_colorspace.c
index 09e6c349..a98d568b 100644
--- a/fitz/res_colorspace.c
+++ b/fitz/res_colorspace.c
@@ -3,21 +3,21 @@
 #define SLOWCMYK
 
 fz_colorspace *
-fz_newcolorspace(char *name, int n)
+fz_new_colorspace(char *name, int n)
 {
 	fz_colorspace *cs = fz_malloc(sizeof(fz_colorspace));
 	cs->refs = 1;
 	fz_strlcpy(cs->name, name, sizeof cs->name);
 	cs->n = n;
-	cs->toxyz = nil;
-	cs->fromxyz = nil;
-	cs->freedata = nil;
-	cs->data = nil;
+	cs->to_xyz = NULL;
+	cs->from_xyz = NULL;
+	cs->free_data = NULL;
+	cs->data = NULL;
 	return cs;
 }
 
 fz_colorspace *
-fz_keepcolorspace(fz_colorspace *cs)
+fz_keep_colorspace(fz_colorspace *cs)
 {
 	if (cs->refs < 0)
 		return cs;
@@ -26,28 +26,28 @@ fz_keepcolorspace(fz_colorspace *cs)
 }
 
 void
-fz_dropcolorspace(fz_colorspace *cs)
+fz_drop_colorspace(fz_colorspace *cs)
 {
 	if (cs && cs->refs < 0)
 		return;
 	if (cs && --cs->refs == 0)
 	{
-		if (cs->freedata && cs->data)
-			cs->freedata(cs);
+		if (cs->free_data && cs->data)
+			cs->free_data(cs);
 		fz_free(cs);
 	}
 }
 
 /* Device colorspace definitions */
 
-static void graytoxyz(fz_colorspace *cs, float *gray, float *xyz)
+static void gray_to_xyz(fz_colorspace *cs, float *gray, float *xyz)
 {
 	xyz[0] = gray[0];
 	xyz[1] = gray[0];
 	xyz[2] = gray[0];
 }
 
-static void xyztogray(fz_colorspace *cs, float *xyz, float *gray)
+static void xyz_to_gray(fz_colorspace *cs, float *xyz, float *gray)
 {
 	float r = xyz[0];
 	float g = xyz[1];
@@ -55,35 +55,35 @@ static void xyztogray(fz_colorspace *cs, float *xyz, float *gray)
 	gray[0] = r * 0.3f + g * 0.59f + b * 0.11f;
 }
 
-static void rgbtoxyz(fz_colorspace *cs, float *rgb, float *xyz)
+static void rgb_to_xyz(fz_colorspace *cs, float *rgb, float *xyz)
 {
 	xyz[0] = rgb[0];
 	xyz[1] = rgb[1];
 	xyz[2] = rgb[2];
 }
 
-static void xyztorgb(fz_colorspace *cs, float *xyz, float *rgb)
+static void xyz_to_rgb(fz_colorspace *cs, float *xyz, float *rgb)
 {
 	rgb[0] = xyz[0];
 	rgb[1] = xyz[1];
 	rgb[2] = xyz[2];
 }
 
-static void bgrtoxyz(fz_colorspace *cs, float *bgr, float *xyz)
+static void bgr_to_xyz(fz_colorspace *cs, float *bgr, float *xyz)
 {
 	xyz[0] = bgr[2];
 	xyz[1] = bgr[1];
 	xyz[2] = bgr[0];
 }
 
-static void xyztobgr(fz_colorspace *cs, float *xyz, float *bgr)
+static void xyz_to_bgr(fz_colorspace *cs, float *xyz, float *bgr)
 {
 	bgr[0] = xyz[2];
 	bgr[1] = xyz[1];
 	bgr[2] = xyz[0];
 }
 
-static void cmyktoxyz(fz_colorspace *cs, float *cmyk, float *xyz)
+static void cmyk_to_xyz(fz_colorspace *cs, float *cmyk, float *xyz)
 {
 #ifdef SLOWCMYK /* from poppler */
 	float c = cmyk[0], m = cmyk[1], y = cmyk[2], k = cmyk[3];
@@ -146,7 +146,7 @@ static void cmyktoxyz(fz_colorspace *cs, float *cmyk, float *xyz)
 #endif
 }
 
-static void xyztocmyk(fz_colorspace *cs, float *xyz, float *cmyk)
+static void xyz_to_cmyk(fz_colorspace *cs, float *xyz, float *cmyk)
 {
 	float c, m, y, k;
 	c = 1 - xyz[0];
@@ -159,19 +159,19 @@ static void xyztocmyk(fz_colorspace *cs, float *xyz, float *cmyk)
 	cmyk[3] = k;
 }
 
-static fz_colorspace kdevicegray = { -1, "DeviceGray", 1, graytoxyz, xyztogray };
-static fz_colorspace kdevicergb = { -1, "DeviceRGB", 3, rgbtoxyz, xyztorgb };
-static fz_colorspace kdevicebgr = { -1, "DeviceRGB", 3, bgrtoxyz, xyztobgr };
-static fz_colorspace kdevicecmyk = { -1, "DeviceCMYK", 4, cmyktoxyz, xyztocmyk };
+static fz_colorspace k_device_gray = { -1, "DeviceGray", 1, gray_to_xyz, xyz_to_gray };
+static fz_colorspace k_device_rgb = { -1, "DeviceRGB", 3, rgb_to_xyz, xyz_to_rgb };
+static fz_colorspace k_device_bgr = { -1, "DeviceRGB", 3, bgr_to_xyz, xyz_to_bgr };
+static fz_colorspace k_device_cmyk = { -1, "DeviceCMYK", 4, cmyk_to_xyz, xyz_to_cmyk };
 
-fz_colorspace *fz_devicegray = &kdevicegray;
-fz_colorspace *fz_devicergb = &kdevicergb;
-fz_colorspace *fz_devicebgr = &kdevicebgr;
-fz_colorspace *fz_devicecmyk = &kdevicecmyk;
+fz_colorspace *fz_device_gray = &k_device_gray;
+fz_colorspace *fz_device_rgb = &k_device_rgb;
+fz_colorspace *fz_device_bgr = &k_device_bgr;
+fz_colorspace *fz_device_cmyk = &k_device_cmyk;
 
 /* Fast pixmap color conversions */
 
-static void fastgraytorgb(fz_pixmap *src, fz_pixmap *dst)
+static void fast_gray_to_rgb(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -187,7 +187,7 @@ static void fastgraytorgb(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastgraytocmyk(fz_pixmap *src, fz_pixmap *dst)
+static void fast_gray_to_cmyk(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -204,7 +204,7 @@ static void fastgraytocmyk(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastrgbtogray(fz_pixmap *src, fz_pixmap *dst)
+static void fast_rgb_to_gray(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -218,7 +218,7 @@ static void fastrgbtogray(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastbgrtogray(fz_pixmap *src, fz_pixmap *dst)
+static void fast_bgr_to_gray(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -232,7 +232,7 @@ static void fastbgrtogray(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastrgbtocmyk(fz_pixmap *src, fz_pixmap *dst)
+static void fast_rgb_to_cmyk(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -253,7 +253,7 @@ static void fastrgbtocmyk(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastbgrtocmyk(fz_pixmap *src, fz_pixmap *dst)
+static void fast_bgr_to_cmyk(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -274,7 +274,7 @@ static void fastbgrtocmyk(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastcmyktogray(fz_pixmap *src, fz_pixmap *dst)
+static void fast_cmyk_to_gray(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -291,7 +291,7 @@ static void fastcmyktogray(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastcmyktorgb(fz_pixmap *src, fz_pixmap *dst)
+static void fast_cmyk_to_rgb(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -304,7 +304,7 @@ static void fastcmyktorgb(fz_pixmap *src, fz_pixmap *dst)
 		cmyk[1] = s[1] / 255.0f;
 		cmyk[2] = s[2] / 255.0f;
 		cmyk[3] = s[3] / 255.0f;
-		cmyktoxyz(nil, cmyk, rgb);
+		cmyk_to_xyz(NULL, cmyk, rgb);
 		d[0] = rgb[0] * 255;
 		d[1] = rgb[1] * 255;
 		d[2] = rgb[2] * 255;
@@ -319,7 +319,7 @@ static void fastcmyktorgb(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastcmyktobgr(fz_pixmap *src, fz_pixmap *dst)
+static void fast_cmyk_to_bgr(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -332,7 +332,7 @@ static void fastcmyktobgr(fz_pixmap *src, fz_pixmap *dst)
 		cmyk[1] = s[1] / 255.0f;
 		cmyk[2] = s[2] / 255.0f;
 		cmyk[3] = s[3] / 255.0f;
-		cmyktoxyz(nil, cmyk, rgb);
+		cmyk_to_xyz(NULL, cmyk, rgb);
 		d[0] = rgb[2] * 255;
 		d[1] = rgb[1] * 255;
 		d[2] = rgb[0] * 255;
@@ -347,7 +347,7 @@ static void fastcmyktobgr(fz_pixmap *src, fz_pixmap *dst)
 	}
 }
 
-static void fastrgbtobgr(fz_pixmap *src, fz_pixmap *dst)
+static void fast_rgb_to_bgr(fz_pixmap *src, fz_pixmap *dst)
 {
 	unsigned char *s = src->samples;
 	unsigned char *d = dst->samples;
@@ -364,10 +364,10 @@ static void fastrgbtobgr(fz_pixmap *src, fz_pixmap *dst)
 }
 
 static void
-fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
+fz_std_conv_pixmap(fz_pixmap *src, fz_pixmap *dst)
 {
-	float srcv[FZ_MAXCOLORS];
-	float dstv[FZ_MAXCOLORS];
+	float srcv[FZ_MAX_COLORS];
+	float dstv[FZ_MAX_COLORS];
 	int srcn, dstn;
 	int y, x, k, i;
 
@@ -395,7 +395,7 @@ fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
 				srcv[1] = *s++ - 128;
 				srcv[2] = *s++ - 128;
 
-				fz_convertcolor(ss, srcv, ds, dstv);
+				fz_convert_color(ss, srcv, ds, dstv);
 
 				for (k = 0; k < dstn; k++)
 					*d++ = dstv[k] * 255;
@@ -415,7 +415,7 @@ fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
 				for (k = 0; k < srcn; k++)
 					srcv[k] = *s++ / 255.0f;
 
-				fz_convertcolor(ss, srcv, ds, dstv);
+				fz_convert_color(ss, srcv, ds, dstv);
 
 				for (k = 0; k < dstn; k++)
 					*d++ = dstv[k] * 255;
@@ -428,12 +428,12 @@ fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
 	/* 1-d lookup table for separation and similar colorspaces */
 	else if (srcn == 1)
 	{
-		unsigned char lookup[FZ_MAXCOLORS * 256];
+		unsigned char lookup[FZ_MAX_COLORS * 256];
 
 		for (i = 0; i < 256; i++)
 		{
 			srcv[0] = i / 255.0f;
-			fz_convertcolor(ss, srcv, ds, dstv);
+			fz_convert_color(ss, srcv, ds, dstv);
 			for (k = 0; k < dstn; k++)
 				lookup[i * dstn + k] = dstv[k] * 255;
 		}
@@ -453,16 +453,16 @@ fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
 	/* Memoize colors using a hash table for the general case */
 	else
 	{
-		fz_hashtable *lookup;
+		fz_hash_table *lookup;
 		unsigned char *color;
 
-		lookup = fz_newhash(509, srcn);
+		lookup = fz_new_hash_table(509, srcn);
 
 		for (y = 0; y < src->h; y++)
 		{
 			for (x = 0; x < src->w; x++)
 			{
-				color = fz_hashfind(lookup, s);
+				color = fz_hash_find(lookup, s);
 				if (color)
 				{
 					memcpy(d, color, dstn);
@@ -474,23 +474,23 @@ fz_stdconvpixmap(fz_pixmap *src, fz_pixmap *dst)
 				{
 					for (k = 0; k < srcn; k++)
 						srcv[k] = *s++ / 255.0f;
-					fz_convertcolor(ss, srcv, ds, dstv);
+					fz_convert_color(ss, srcv, ds, dstv);
 					for (k = 0; k < dstn; k++)
 						*d++ = dstv[k] * 255;
 
-					fz_hashinsert(lookup, s - srcn, d - dstn);
+					fz_hash_insert(lookup, s - srcn, d - dstn);
 
 					*d++ = *s++;
 				}
 			}
 		}
 
-		fz_freehash(lookup);
+		fz_free_hash(lookup);
 	}
 }
 
 void
-fz_convertpixmap(fz_pixmap *sp, fz_pixmap *dp)
+fz_convert_pixmap(fz_pixmap *sp, fz_pixmap *dp)
 {
 	fz_colorspace *ss = sp->colorspace;
 	fz_colorspace *ds = dp->colorspace;
@@ -498,57 +498,57 @@ fz_convertpixmap(fz_pixmap *sp, fz_pixmap *dp)
 	assert(ss && ds);
 
 	if (sp->mask)
-		dp->mask = fz_keeppixmap(sp->mask);
+		dp->mask = fz_keep_pixmap(sp->mask);
 	dp->interpolate = sp->interpolate;
 
-	if (ss == fz_devicegray)
+	if (ss == fz_device_gray)
 	{
-		if (ds == fz_devicergb) fastgraytorgb(sp, dp);
-		else if (ds == fz_devicebgr) fastgraytorgb(sp, dp); /* bgr == rgb here */
-		else if (ds == fz_devicecmyk) fastgraytocmyk(sp, dp);
-		else fz_stdconvpixmap(sp, dp);
+		if (ds == fz_device_rgb) fast_gray_to_rgb(sp, dp);
+		else if (ds == fz_device_bgr) fast_gray_to_rgb(sp, dp); /* bgr == rgb here */
+		else if (ds == fz_device_cmyk) fast_gray_to_cmyk(sp, dp);
+		else fz_std_conv_pixmap(sp, dp);
 	}
 
-	else if (ss == fz_devicergb)
+	else if (ss == fz_device_rgb)
 	{
-		if (ds == fz_devicegray) fastrgbtogray(sp, dp);
-		else if (ds == fz_devicebgr) fastrgbtobgr(sp, dp);
-		else if (ds == fz_devicecmyk) fastrgbtocmyk(sp, dp);
-		else fz_stdconvpixmap(sp, dp);
+		if (ds == fz_device_gray) fast_rgb_to_gray(sp, dp);
+		else if (ds == fz_device_bgr) fast_rgb_to_bgr(sp, dp);
+		else if (ds == fz_device_cmyk) fast_rgb_to_cmyk(sp, dp);
+		else fz_std_conv_pixmap(sp, dp);
 	}
 
-	else if (ss == fz_devicebgr)
+	else if (ss == fz_device_bgr)
 	{
-		if (ds == fz_devicegray) fastbgrtogray(sp, dp);
-		else if (ds == fz_devicergb) fastrgbtobgr(sp, dp); /* bgr = rgb here */
-		else if (ds == fz_devicecmyk) fastbgrtocmyk(sp, dp);
-		else fz_stdconvpixmap(sp, dp);
+		if (ds == fz_device_gray) fast_bgr_to_gray(sp, dp);
+		else if (ds == fz_device_rgb) fast_rgb_to_bgr(sp, dp); /* bgr = rgb here */
+		else if (ds == fz_device_cmyk) fast_bgr_to_cmyk(sp, dp);
+		else fz_std_conv_pixmap(sp, dp);
 	}
 
-	else if (ss == fz_devicecmyk)
+	else if (ss == fz_device_cmyk)
 	{
-		if (ds == fz_devicegray) fastcmyktogray(sp, dp);
-		else if (ds == fz_devicebgr) fastcmyktobgr(sp, dp);
-		else if (ds == fz_devicergb) fastcmyktorgb(sp, dp);
-		else fz_stdconvpixmap(sp, dp);
+		if (ds == fz_device_gray) fast_cmyk_to_gray(sp, dp);
+		else if (ds == fz_device_bgr) fast_cmyk_to_bgr(sp, dp);
+		else if (ds == fz_device_rgb) fast_cmyk_to_rgb(sp, dp);
+		else fz_std_conv_pixmap(sp, dp);
 	}
 
-	else fz_stdconvpixmap(sp, dp);
+	else fz_std_conv_pixmap(sp, dp);
 }
 
 /* Convert a single color */
 
 static void
-fz_stdconvcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv)
+fz_std_conv_color(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv)
 {
 	float xyz[3];
 	int i;
 
 	if (srcs != dsts)
 	{
-		assert(srcs->toxyz && dsts->fromxyz);
-		srcs->toxyz(srcs, srcv, xyz);
-		dsts->fromxyz(dsts, xyz, dstv);
+		assert(srcs->to_xyz && dsts->from_xyz);
+		srcs->to_xyz(srcs, srcv, xyz);
+		dsts->from_xyz(dsts, xyz, dstv);
 		for (i = 0; i < dsts->n; i++)
 			dstv[i] = CLAMP(dstv[i], 0, 1);
 	}
@@ -560,17 +560,17 @@ fz_stdconvcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *ds
 }
 
 void
-fz_convertcolor(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
+fz_convert_color(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 {
-	if (ss == fz_devicegray)
+	if (ss == fz_device_gray)
 	{
-		if ((ds == fz_devicergb) || (ds == fz_devicebgr))
+		if ((ds == fz_device_rgb) || (ds == fz_device_bgr))
 		{
 			dv[0] = sv[0];
 			dv[1] = sv[0];
 			dv[2] = sv[0];
 		}
-		else if (ds == fz_devicecmyk)
+		else if (ds == fz_device_cmyk)
 		{
 			dv[0] = 0;
 			dv[1] = 0;
@@ -578,22 +578,22 @@ fz_convertcolor(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = sv[0];
 		}
 		else
-			fz_stdconvcolor(ss, sv, ds, dv);
+			fz_std_conv_color(ss, sv, ds, dv);
 	}
 
-	else if (ss == fz_devicergb)
+	else if (ss == fz_device_rgb)
 	{
-		if (ds == fz_devicegray)
+		if (ds == fz_device_gray)
 		{
 			dv[0] = sv[0] * 0.3f + sv[1] * 0.59f + sv[2] * 0.11f;
 		}
-		else if (ds == fz_devicebgr)
+		else if (ds == fz_device_bgr)
 		{
 			dv[0] = sv[2];
 			dv[1] = sv[1];
 			dv[2] = sv[0];
 		}
-		else if (ds == fz_devicecmyk)
+		else if (ds == fz_device_cmyk)
 		{
 			float c = 1 - sv[0];
 			float m = 1 - sv[1];
@@ -605,22 +605,22 @@ fz_convertcolor(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = k;
 		}
 		else
-			fz_stdconvcolor(ss, sv, ds, dv);
+			fz_std_conv_color(ss, sv, ds, dv);
 	}
 
-	else if (ss == fz_devicebgr)
+	else if (ss == fz_device_bgr)
 	{
-		if (ds == fz_devicegray)
+		if (ds == fz_device_gray)
 		{
 			dv[0] = sv[0] * 0.11f + sv[1] * 0.59f + sv[2] * 0.3f;
 		}
-		else if (ds == fz_devicebgr)
+		else if (ds == fz_device_bgr)
 		{
 			dv[0] = sv[2];
 			dv[1] = sv[1];
 			dv[2] = sv[0];
 		}
-		else if (ds == fz_devicecmyk)
+		else if (ds == fz_device_cmyk)
 		{
 			float c = 1 - sv[2];
 			float m = 1 - sv[1];
@@ -632,33 +632,33 @@ fz_convertcolor(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 			dv[3] = k;
 		}
 		else
-			fz_stdconvcolor(ss, sv, ds, dv);
+			fz_std_conv_color(ss, sv, ds, dv);
 	}
 
-	else if (ss == fz_devicecmyk)
+	else if (ss == fz_device_cmyk)
 	{
-		if (ds == fz_devicegray)
+		if (ds == fz_device_gray)
 		{
 			float c = sv[0] * 0.3f;
 			float m = sv[1] * 0.59f;
 			float y = sv[2] * 0.11f;
 			dv[0] = 1 - MIN(c + m + y + sv[3], 1);
 		}
-		else if (ds == fz_devicergb)
+		else if (ds == fz_device_rgb)
 		{
 #ifdef SLOWCMYK
-			cmyktoxyz(nil, sv, dv);
+			cmyk_to_xyz(NULL, sv, dv);
 #else
 			dv[0] = 1 - MIN(sv[0] + sv[3], 1);
 			dv[1] = 1 - MIN(sv[1] + sv[3], 1);
 			dv[2] = 1 - MIN(sv[2] + sv[3], 1);
 #endif
 		}
-		else if (ds == fz_devicebgr)
+		else if (ds == fz_device_bgr)
 		{
 #ifdef SLOWCMYK
 			float rgb[3];
-			cmyktoxyz(nil, sv, rgb);
+			cmyk_to_xyz(NULL, sv, rgb);
 			dv[0] = rgb[2];
 			dv[1] = rgb[1];
 			dv[2] = rgb[0];
@@ -669,9 +669,9 @@ fz_convertcolor(fz_colorspace *ss, float *sv, fz_colorspace *ds, float *dv)
 #endif
 		}
 		else
-			fz_stdconvcolor(ss, sv, ds, dv);
+			fz_std_conv_color(ss, sv, ds, dv);
 	}
 
 	else
-		fz_stdconvcolor(ss, sv, ds, dv);
+		fz_std_conv_color(ss, sv, ds, dv);
 }
diff --git a/fitz/res_font.c b/fitz/res_font.c
index f076a9e9..f94940a6 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -4,10 +4,10 @@
 #include FT_FREETYPE_H
 #include FT_STROKER_H
 
-static void fz_finalizefreetype(void);
+static void fz_finalize_freetype(void);
 
 static fz_font *
-fz_newfont(void)
+fz_new_font(void)
 {
 	fz_font *font;
 
@@ -15,41 +15,41 @@ fz_newfont(void)
 	font->refs = 1;
 	strcpy(font->name, "<unknown>");
 
-	font->ftface = nil;
-	font->ftsubstitute = 0;
-	font->fthint = 0;
+	font->ft_face = NULL;
+	font->ft_substitute = 0;
+	font->ft_hint = 0;
 
-	font->ftfile = nil;
-	font->ftdata = nil;
-	font->ftsize = 0;
+	font->ft_file = NULL;
+	font->ft_data = NULL;
+	font->ft_size = 0;
 
 	font->t3matrix = fz_identity;
-	font->t3resources = nil;
-	font->t3procs = nil;
-	font->t3widths = nil;
-	font->t3xref = nil;
-	font->t3run = nil;
+	font->t3resources = NULL;
+	font->t3procs = NULL;
+	font->t3widths = NULL;
+	font->t3xref = NULL;
+	font->t3run = NULL;
 
 	font->bbox.x0 = 0;
 	font->bbox.y0 = 0;
 	font->bbox.x1 = 1000;
 	font->bbox.y1 = 1000;
 
-	font->widthcount = 0;
-	font->widthtable = nil;
+	font->width_count = 0;
+	font->width_table = NULL;
 
 	return font;
 }
 
 fz_font *
-fz_keepfont(fz_font *font)
+fz_keep_font(fz_font *font)
 {
 	font->refs ++;
 	return font;
 }
 
 void
-fz_dropfont(fz_font *font)
+fz_drop_font(fz_font *font)
 {
 	int fterr;
 	int i;
@@ -59,36 +59,36 @@ fz_dropfont(fz_font *font)
 		if (font->t3procs)
 		{
 			if (font->t3resources)
-				fz_dropobj(font->t3resources);
+				fz_drop_obj(font->t3resources);
 			for (i = 0; i < 256; i++)
 				if (font->t3procs[i])
-					fz_dropbuffer(font->t3procs[i]);
+					fz_drop_buffer(font->t3procs[i]);
 			fz_free(font->t3procs);
 			fz_free(font->t3widths);
 		}
 
-		if (font->ftface)
+		if (font->ft_face)
 		{
-			fterr = FT_Done_Face((FT_Face)font->ftface);
+			fterr = FT_Done_Face((FT_Face)font->ft_face);
 			if (fterr)
-				fz_warn("freetype finalizing face: %s", ft_errorstring(fterr));
-			fz_finalizefreetype();
+				fz_warn("freetype finalizing face: %s", ft_error_string(fterr));
+			fz_finalize_freetype();
 		}
 
-		if (font->ftfile)
-			fz_free(font->ftfile);
-		if (font->ftdata)
-			fz_free(font->ftdata);
+		if (font->ft_file)
+			fz_free(font->ft_file);
+		if (font->ft_data)
+			fz_free(font->ft_data);
 
-		if (font->widthtable)
-			fz_free(font->widthtable);
+		if (font->width_table)
+			fz_free(font->width_table);
 
 		fz_free(font);
 	}
 }
 
 void
-fz_setfontbbox(fz_font *font, float xmin, float ymin, float xmax, float ymax)
+fz_set_font_bbox(fz_font *font, float xmin, float ymin, float xmax, float ymax)
 {
 	font->bbox.x0 = xmin;
 	font->bbox.y0 = ymin;
@@ -100,7 +100,7 @@ fz_setfontbbox(fz_font *font, float xmin, float ymin, float xmax, float ymax)
  * Freetype hooks
  */
 
-static FT_Library fz_ftlib = nil;
+static FT_Library fz_ftlib = NULL;
 static int fz_ftlib_refs = 0;
 
 #undef __FTERRORS_H__
@@ -119,7 +119,7 @@ static const struct ft_error ft_errors[] =
 #include FT_ERRORS_H
 };
 
-char *ft_errorstring(int err)
+char *ft_error_string(int err)
 {
 	const struct ft_error *e;
 
@@ -131,7 +131,7 @@ char *ft_errorstring(int err)
 }
 
 static fz_error
-fz_initfreetype(void)
+fz_init_freetype(void)
 {
 	int fterr;
 	int maj, min, pat;
@@ -144,14 +144,14 @@ fz_initfreetype(void)
 
 	fterr = FT_Init_FreeType(&fz_ftlib);
 	if (fterr)
-		return fz_throw("cannot init freetype: %s", ft_errorstring(fterr));
+		return fz_throw("cannot init freetype: %s", ft_error_string(fterr));
 
 	FT_Library_Version(fz_ftlib, &maj, &min, &pat);
 	if (maj == 2 && min == 1 && pat < 7)
 	{
 		fterr = FT_Done_FreeType(fz_ftlib);
 		if (fterr)
-			fz_warn("freetype finalizing: %s", ft_errorstring(fterr));
+			fz_warn("freetype finalizing: %s", ft_error_string(fterr));
 		return fz_throw("freetype version too old: %d.%d.%d", maj, min, pat);
 	}
 
@@ -160,7 +160,7 @@ fz_initfreetype(void)
 }
 
 static void
-fz_finalizefreetype(void)
+fz_finalize_freetype(void)
 {
 	int fterr;
 
@@ -168,29 +168,29 @@ fz_finalizefreetype(void)
 	{
 		fterr = FT_Done_FreeType(fz_ftlib);
 		if (fterr)
-			fz_warn("freetype finalizing: %s", ft_errorstring(fterr));
-		fz_ftlib = nil;
+			fz_warn("freetype finalizing: %s", ft_error_string(fterr));
+		fz_ftlib = NULL;
 	}
 }
 
 fz_error
-fz_newfontfromfile(fz_font **fontp, char *path, int index)
+fz_new_font_from_file(fz_font **fontp, char *path, int index)
 {
 	FT_Face face;
 	fz_error error;
 	fz_font *font;
 	int fterr;
 
-	error = fz_initfreetype();
+	error = fz_init_freetype();
 	if (error)
 		return fz_rethrow(error, "cannot init freetype library");
 
 	fterr = FT_New_Face(fz_ftlib, path, index, &face);
 	if (fterr)
-		return fz_throw("freetype: cannot load font: %s", ft_errorstring(fterr));
+		return fz_throw("freetype: cannot load font: %s", ft_error_string(fterr));
 
-	font = fz_newfont();
-	font->ftface = face;
+	font = fz_new_font();
+	font->ft_face = face;
 	font->bbox.x0 = face->bbox.xMin * 1000 / face->units_per_EM;
 	font->bbox.y0 = face->bbox.yMin * 1000 / face->units_per_EM;
 	font->bbox.x1 = face->bbox.xMax * 1000 / face->units_per_EM;
@@ -201,23 +201,23 @@ fz_newfontfromfile(fz_font **fontp, char *path, int index)
 }
 
 fz_error
-fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index)
+fz_new_font_from_memory(fz_font **fontp, unsigned char *data, int len, int index)
 {
 	FT_Face face;
 	fz_error error;
 	fz_font *font;
 	int fterr;
 
-	error = fz_initfreetype();
+	error = fz_init_freetype();
 	if (error)
 		return fz_rethrow(error, "cannot init freetype library");
 
 	fterr = FT_New_Memory_Face(fz_ftlib, data, len, index, &face);
 	if (fterr)
-		return fz_throw("freetype: cannot load font: %s", ft_errorstring(fterr));
+		return fz_throw("freetype: cannot load font: %s", ft_error_string(fterr));
 
-	font = fz_newfont();
-	font->ftface = face;
+	font = fz_new_font();
+	font->ft_face = face;
 	font->bbox.x0 = face->bbox.xMin * 1000 / face->units_per_EM;
 	font->bbox.y0 = face->bbox.yMin * 1000 / face->units_per_EM;
 	font->bbox.x1 = face->bbox.xMax * 1000 / face->units_per_EM;
@@ -228,10 +228,10 @@ fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index)
 }
 
 static fz_matrix
-fz_adjustftglyphwidth(fz_font *font, int gid, fz_matrix trm)
+fz_adjust_ft_glyph_width(fz_font *font, int gid, fz_matrix trm)
 {
 	/* Fudge the font matrix to stretch the glyph if we've substituted the font. */
-	if (font->ftsubstitute && gid < font->widthcount)
+	if (font->ft_substitute && gid < font->width_count)
 	{
 		FT_Error fterr;
 		int subw;
@@ -239,17 +239,17 @@ fz_adjustftglyphwidth(fz_font *font, int gid, fz_matrix trm)
 		float scale;
 
 		/* TODO: use FT_Get_Advance */
-		fterr = FT_Set_Char_Size(font->ftface, 1000, 1000, 72, 72);
+		fterr = FT_Set_Char_Size(font->ft_face, 1000, 1000, 72, 72);
 		if (fterr)
-			fz_warn("freetype setting character size: %s", ft_errorstring(fterr));
+			fz_warn("freetype setting character size: %s", ft_error_string(fterr));
 
-		fterr = FT_Load_Glyph(font->ftface, gid,
+		fterr = FT_Load_Glyph(font->ft_face, gid,
 			FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM);
 		if (fterr)
-			fz_warn("freetype failed to load glyph: %s", ft_errorstring(fterr));
+			fz_warn("freetype failed to load glyph: %s", ft_error_string(fterr));
 
-		realw = ((FT_Face)font->ftface)->glyph->metrics.horiAdvance;
-		subw = font->widthtable[gid];
+		realw = ((FT_Face)font->ft_face)->glyph->metrics.horiAdvance;
+		subw = font->width_table[gid];
 		if (realw)
 			scale = (float) subw / realw;
 		else
@@ -262,16 +262,16 @@ fz_adjustftglyphwidth(fz_font *font, int gid, fz_matrix trm)
 }
 
 fz_pixmap *
-fz_renderftglyph(fz_font *font, int gid, fz_matrix trm)
+fz_render_ft_glyph(fz_font *font, int gid, fz_matrix trm)
 {
-	FT_Face face = font->ftface;
+	FT_Face face = font->ft_face;
 	FT_Matrix m;
 	FT_Vector v;
 	FT_Error fterr;
 	fz_pixmap *glyph;
 	int y;
 
-	trm = fz_adjustftglyphwidth(font, gid, trm);
+	trm = fz_adjust_ft_glyph_width(font, gid, trm);
 
 	/*
 	Freetype mutilates complex glyphs if they are loaded
@@ -290,10 +290,10 @@ fz_renderftglyph(fz_font *font, int gid, fz_matrix trm)
 
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
 	if (fterr)
-		fz_warn("freetype setting character size: %s", ft_errorstring(fterr));
+		fz_warn("freetype setting character size: %s", ft_error_string(fterr));
 	FT_Set_Transform(face, &m, &v);
 
-	if (font->fthint)
+	if (font->ft_hint)
 	{
 		/*
 		Enable hinting, but keep the huge char size so that
@@ -304,7 +304,7 @@ fz_renderftglyph(fz_font *font, int gid, fz_matrix trm)
 		*/
 #ifdef GRIDFIT
 		/* If you really want grid fitting, enable this code. */
-		float scale = fz_matrixexpansion(trm);
+		float scale = fz_matrix_expansion(trm);
 		m.xx = trm.a * 65536 / scale;
 		m.xy = trm.b * 65536 / scale;
 		m.yx = trm.c * 65536 / scale;
@@ -314,31 +314,31 @@ fz_renderftglyph(fz_font *font, int gid, fz_matrix trm)
 
 		fterr = FT_Set_Char_Size(face, 64 * scale, 64 * scale, 72, 72);
 		if (fterr)
-			fz_warn("freetype setting character size: %s", ft_errorstring(fterr));
+			fz_warn("freetype setting character size: %s", ft_error_string(fterr));
 		FT_Set_Transform(face, &m, &v);
 #endif
 		fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP);
 		if (fterr)
-			fz_warn("freetype load glyph (gid %d): %s", gid, ft_errorstring(fterr));
+			fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
 	}
 	else
 	{
 		fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
 		if (fterr)
 		{
-			fz_warn("freetype load glyph (gid %d): %s", gid, ft_errorstring(fterr));
-			return nil;
+			fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr));
+			return NULL;
 		}
 	}
 
 	fterr = FT_Render_Glyph(face->glyph, ft_render_mode_normal);
 	if (fterr)
 	{
-		fz_warn("freetype render glyph (gid %d): %s", gid, ft_errorstring(fterr));
-		return nil;
+		fz_warn("freetype render glyph (gid %d): %s", gid, ft_error_string(fterr));
+		return NULL;
 	}
 
-	glyph = fz_newpixmap(nil,
+	glyph = fz_new_pixmap(NULL,
 		face->glyph->bitmap_left,
 		face->glyph->bitmap_top - face->glyph->bitmap.rows,
 		face->glyph->bitmap.width,
@@ -355,10 +355,10 @@ fz_renderftglyph(fz_font *font, int gid, fz_matrix trm)
 }
 
 fz_pixmap *
-fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_strokestate *state)
+fz_render_ft_stroked_glyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *state)
 {
-	FT_Face face = font->ftface;
-	float expansion = fz_matrixexpansion(ctm);
+	FT_Face face = font->ft_face;
+	float expansion = fz_matrix_expansion(ctm);
 	int linewidth = state->linewidth * expansion * 64 / 2;
 	FT_Matrix m;
 	FT_Vector v;
@@ -369,7 +369,7 @@ fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz
 	fz_pixmap *pix;
 	int y;
 
-	trm = fz_adjustftglyphwidth(font, gid, trm);
+	trm = fz_adjust_ft_glyph_width(font, gid, trm);
 
 	m.xx = trm.a * 64; /* should be 65536 */
 	m.yx = trm.b * 64;
@@ -381,8 +381,8 @@ fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz
 	fterr = FT_Set_Char_Size(face, 65536, 65536, 72, 72); /* should be 64, 64 */
 	if (fterr)
 	{
-		fz_warn("FT_Set_Char_Size: %s", ft_errorstring(fterr));
-		return nil;
+		fz_warn("FT_Set_Char_Size: %s", ft_error_string(fterr));
+		return NULL;
 	}
 
 	FT_Set_Transform(face, &m, &v);
@@ -390,15 +390,15 @@ fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz
 	fterr = FT_Load_Glyph(face, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
 	if (fterr)
 	{
-		fz_warn("FT_Load_Glyph(gid %d): %s", gid, ft_errorstring(fterr));
-		return nil;
+		fz_warn("FT_Load_Glyph(gid %d): %s", gid, ft_error_string(fterr));
+		return NULL;
 	}
 
 	fterr = FT_Stroker_New(fz_ftlib, &stroker);
 	if (fterr)
 	{
-		fz_warn("FT_Stroker_New: %s", ft_errorstring(fterr));
-		return nil;
+		fz_warn("FT_Stroker_New: %s", ft_error_string(fterr));
+		return NULL;
 	}
 
 	FT_Stroker_Set(stroker, linewidth, state->linecap, state->linejoin, state->miterlimit * 65536);
@@ -406,31 +406,31 @@ fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz
 	fterr = FT_Get_Glyph(face->glyph, &glyph);
 	if (fterr)
 	{
-		fz_warn("FT_Get_Glyph: %s", ft_errorstring(fterr));
+		fz_warn("FT_Get_Glyph: %s", ft_error_string(fterr));
 		FT_Stroker_Done(stroker);
-		return nil;
+		return NULL;
 	}
 
 	fterr = FT_Glyph_Stroke(&glyph, stroker, 1);
 	if (fterr)
 	{
-		fz_warn("FT_Glyph_Stroke: %s", ft_errorstring(fterr));
+		fz_warn("FT_Glyph_Stroke: %s", ft_error_string(fterr));
 		FT_Done_Glyph(glyph);
 		FT_Stroker_Done(stroker);
-		return nil;
+		return NULL;
 	}
 
 	fterr = FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1);
 	if (fterr)
 	{
-		fz_warn("FT_Glyph_To_Bitmap: %s", ft_errorstring(fterr));
+		fz_warn("FT_Glyph_To_Bitmap: %s", ft_error_string(fterr));
 		FT_Done_Glyph(glyph);
 		FT_Stroker_Done(stroker);
-		return nil;
+		return NULL;
 	}
 
 	bitmap = (FT_BitmapGlyph)glyph;
-	pix = fz_newpixmap(nil,
+	pix = fz_new_pixmap(NULL,
 		bitmap->left,
 		bitmap->top - bitmap->bitmap.rows,
 		bitmap->bitmap.width,
@@ -454,12 +454,12 @@ fz_renderftstrokedglyph(fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz
  */
 
 fz_font *
-fz_newtype3font(char *name, fz_matrix matrix)
+fz_new_type3_font(char *name, fz_matrix matrix)
 {
 	fz_font *font;
 	int i;
 
-	font = fz_newfont();
+	font = fz_new_font();
 	font->t3procs = fz_calloc(256, sizeof(fz_buffer*));
 	font->t3widths = fz_calloc(256, sizeof(float));
 
@@ -467,7 +467,7 @@ fz_newtype3font(char *name, fz_matrix matrix)
 	font->t3matrix = matrix;
 	for (i = 0; i < 256; i++)
 	{
-		font->t3procs[i] = nil;
+		font->t3procs[i] = NULL;
 		font->t3widths[i] = 0;
 	}
 
@@ -475,57 +475,57 @@ fz_newtype3font(char *name, fz_matrix matrix)
 }
 
 fz_pixmap *
-fz_rendert3glyph(fz_font *font, int gid, fz_matrix trm)
+fz_render_t3_glyph(fz_font *font, int gid, fz_matrix trm)
 {
 	fz_error error;
 	fz_matrix ctm;
 	fz_buffer *contents;
 	fz_bbox bbox;
 	fz_device *dev;
-	fz_glyphcache *cache;
+	fz_glyph_cache *cache;
 	fz_pixmap *glyph;
 	fz_pixmap *result;
 
 	if (gid < 0 || gid > 255)
-		return nil;
+		return NULL;
 
 	contents = font->t3procs[gid];
 	if (!contents)
-		return nil;
+		return NULL;
 
 	ctm = fz_concat(font->t3matrix, trm);
-	dev = fz_newbboxdevice(&bbox);
+	dev = fz_new_bbox_device(&bbox);
 	error = font->t3run(font->t3xref, font->t3resources, contents, dev, ctm);
 	if (error)
 		fz_catch(error, "cannot draw type3 glyph");
-	fz_freedevice(dev);
+	fz_free_device(dev);
 
-	glyph = fz_newpixmap(fz_devicegray, bbox.x0-1, bbox.y0-1, bbox.x1 - bbox.x0 + 1, bbox.y1 - bbox.y0 + 1);
-	fz_clearpixmap(glyph);
+	glyph = fz_new_pixmap(fz_device_gray, bbox.x0-1, bbox.y0-1, bbox.x1 - bbox.x0 + 1, bbox.y1 - bbox.y0 + 1);
+	fz_clear_pixmap(glyph);
 
-	cache = fz_newglyphcache();
-	dev = fz_newdrawdevice(cache, glyph);
+	cache = fz_new_glyph_cache();
+	dev = fz_new_draw_device(cache, glyph);
 	error = font->t3run(font->t3xref, font->t3resources, contents, dev, ctm);
 	if (error)
 		fz_catch(error, "cannot draw type3 glyph");
-	fz_freedevice(dev);
-	fz_freeglyphcache(cache);
+	fz_free_device(dev);
+	fz_free_glyph_cache(cache);
 
-	result = fz_alphafromgray(glyph, 0);
-	fz_droppixmap(glyph);
+	result = fz_alpha_from_gray(glyph, 0);
+	fz_drop_pixmap(glyph);
 
 	return result;
 }
 
 void
-fz_debugfont(fz_font *font)
+fz_debug_font(fz_font *font)
 {
 	printf("font '%s' {\n", font->name);
 
-	if (font->ftface)
+	if (font->ft_face)
 	{
-		printf("\tfreetype face %p\n", font->ftface);
-		if (font->ftsubstitute)
+		printf("\tfreetype face %p\n", font->ft_face);
+		if (font->ft_substitute)
 			printf("\tsubstitute font\n");
 	}
 
diff --git a/fitz/res_path.c b/fitz/res_path.c
index b4ac415a..4959754b 100644
--- a/fitz/res_path.c
+++ b/fitz/res_path.c
@@ -1,56 +1,56 @@
 #include "fitz.h"
 
 fz_path *
-fz_newpath(void)
+fz_new_path(void)
 {
 	fz_path *path;
 
 	path = fz_malloc(sizeof(fz_path));
 	path->len = 0;
 	path->cap = 0;
-	path->els = nil;
+	path->items = NULL;
 
 	return path;
 }
 
 fz_path *
-fz_clonepath(fz_path *old)
+fz_clone_path(fz_path *old)
 {
 	fz_path *path;
 
 	path = fz_malloc(sizeof(fz_path));
 	path->len = old->len;
 	path->cap = old->len;
-	path->els = fz_calloc(path->cap, sizeof(fz_pathel));
-	memcpy(path->els, old->els, sizeof(fz_pathel) * path->len);
+	path->items = fz_calloc(path->cap, sizeof(fz_path_item));
+	memcpy(path->items, old->items, sizeof(fz_path_item) * path->len);
 
 	return path;
 }
 
 void
-fz_freepath(fz_path *path)
+fz_free_path(fz_path *path)
 {
-	fz_free(path->els);
+	fz_free(path->items);
 	fz_free(path);
 }
 
 static void
-growpath(fz_path *path, int n)
+grow_path(fz_path *path, int n)
 {
 	if (path->len + n < path->cap)
 		return;
 	while (path->len + n > path->cap)
 		path->cap = path->cap + 36;
-	path->els = fz_realloc(path->els, path->cap, sizeof(fz_pathel));
+	path->items = fz_realloc(path->items, path->cap, sizeof(fz_path_item));
 }
 
 void
 fz_moveto(fz_path *path, float x, float y)
 {
-	growpath(path, 3);
-	path->els[path->len++].k = FZ_MOVETO;
-	path->els[path->len++].v = x;
-	path->els[path->len++].v = y;
+	grow_path(path, 3);
+	path->items[path->len++].k = FZ_MOVETO;
+	path->items[path->len++].v = x;
+	path->items[path->len++].v = y;
 }
 
 void
@@ -58,10 +58,10 @@ fz_lineto(fz_path *path, float x, float y)
 {
 	if (path->len == 0)
 		fz_moveto(path, 0, 0);
-	growpath(path, 3);
-	path->els[path->len++].k = FZ_LINETO;
-	path->els[path->len++].v = x;
-	path->els[path->len++].v = y;
+	grow_path(path, 3);
+	path->items[path->len++].k = FZ_LINETO;
+	path->items[path->len++].v = x;
+	path->items[path->len++].v = y;
 }
 
 void
@@ -72,21 +72,21 @@ fz_curveto(fz_path *path,
 {
 	if (path->len == 0)
 		fz_moveto(path, 0, 0);
-	growpath(path, 7);
-	path->els[path->len++].k = FZ_CURVETO;
-	path->els[path->len++].v = x1;
-	path->els[path->len++].v = y1;
-	path->els[path->len++].v = x2;
-	path->els[path->len++].v = y2;
-	path->els[path->len++].v = x3;
-	path->els[path->len++].v = y3;
+	grow_path(path, 7);
+	path->items[path->len++].k = FZ_CURVETO;
+	path->items[path->len++].v = x1;
+	path->items[path->len++].v = y1;
+	path->items[path->len++].v = x2;
+	path->items[path->len++].v = y2;
+	path->items[path->len++].v = x3;
+	path->items[path->len++].v = y3;
 }
 
 void
 fz_curvetov(fz_path *path, float x2, float y2, float x3, float y3)
 {
-	float x1 = path->els[path->len-2].v;
-	float y1 = path->els[path->len-1].v;
+	float x1 = path->items[path->len-2].v;
+	float y1 = path->items[path->len-1].v;
 	fz_curveto(path, x1, y1, x2, y2, x3, y3);
 }
 
@@ -101,11 +101,11 @@ fz_closepath(fz_path *path)
 {
 	if (path->len == 0)
 		return;
-	growpath(path, 1);
-	path->els[path->len++].k = FZ_CLOSEPATH;
+	grow_path(path, 1);
+	path->items[path->len++].k = FZ_CLOSE_PATH;
 }
 
-static inline fz_rect boundexpand(fz_rect r, fz_point p)
+static inline fz_rect bound_expand(fz_rect r, fz_point p)
 {
 	if (p.x < r.x0) r.x0 = p.x;
 	if (p.y < r.y0) r.y0 = p.y;
@@ -115,43 +115,43 @@ static inline fz_rect boundexpand(fz_rect r, fz_point p)
 }
 
 fz_rect
-fz_boundpath(fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
+fz_bound_path(fz_path *path, fz_stroke_state *stroke, fz_matrix ctm)
 {
 	fz_point p;
-	fz_rect r = fz_emptyrect;
+	fz_rect r = fz_empty_rect;
 	int i = 0;
 
 	if (path->len)
 	{
-		p.x = path->els[1].v;
-		p.y = path->els[2].v;
-		p = fz_transformpoint(ctm, p);
+		p.x = path->items[1].v;
+		p.y = path->items[2].v;
+		p = fz_transform_point(ctm, p);
 		r.x0 = r.x1 = p.x;
 		r.y0 = r.y1 = p.y;
 	}
 
 	while (i < path->len)
 	{
-		switch (path->els[i++].k)
+		switch (path->items[i++].k)
 		{
 		case FZ_CURVETO:
-			p.x = path->els[i++].v;
-			p.y = path->els[i++].v;
-			r = boundexpand(r, fz_transformpoint(ctm, p));
-			p.x = path->els[i++].v;
-			p.y = path->els[i++].v;
-			r = boundexpand(r, fz_transformpoint(ctm, p));
-			p.x = path->els[i++].v;
-			p.y = path->els[i++].v;
-			r = boundexpand(r, fz_transformpoint(ctm, p));
+			p.x = path->items[i++].v;
+			p.y = path->items[i++].v;
+			r = bound_expand(r, fz_transform_point(ctm, p));
+			p.x = path->items[i++].v;
+			p.y = path->items[i++].v;
+			r = bound_expand(r, fz_transform_point(ctm, p));
+			p.x = path->items[i++].v;
+			p.y = path->items[i++].v;
+			r = bound_expand(r, fz_transform_point(ctm, p));
 			break;
 		case FZ_MOVETO:
 		case FZ_LINETO:
-			p.x = path->els[i++].v;
-			p.y = path->els[i++].v;
-			r = boundexpand(r, fz_transformpoint(ctm, p));
+			p.x = path->items[i++].v;
+			p.y = path->items[i++].v;
+			r = bound_expand(r, fz_transform_point(ctm, p));
 			break;
-		case FZ_CLOSEPATH:
+		case FZ_CLOSE_PATH:
 			break;
 		}
 	}
@@ -171,43 +171,43 @@ fz_boundpath(fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
 }
 
 void
-fz_transformpath(fz_path *path, fz_matrix ctm)
+fz_transform_path(fz_path *path, fz_matrix ctm)
 {
 	fz_point p;
 	int k, i = 0;
 
 	while (i < path->len)
 	{
-		switch (path->els[i++].k)
+		switch (path->items[i++].k)
 		{
 		case FZ_CURVETO:
 			for (k = 0; k < 3; k++)
 			{
-				p.x = path->els[i].v;
-				p.y = path->els[i+1].v;
-				p = fz_transformpoint(ctm, p);
-				path->els[i].v = p.x;
-				path->els[i+1].v = p.y;
+				p.x = path->items[i].v;
+				p.y = path->items[i+1].v;
+				p = fz_transform_point(ctm, p);
+				path->items[i].v = p.x;
+				path->items[i+1].v = p.y;
 				i += 2;
 			}
 			break;
 		case FZ_MOVETO:
 		case FZ_LINETO:
-			p.x = path->els[i].v;
-			p.y = path->els[i+1].v;
-			p = fz_transformpoint(ctm, p);
-			path->els[i].v = p.x;
-			path->els[i+1].v = p.y;
+			p.x = path->items[i].v;
+			p.y = path->items[i+1].v;
+			p = fz_transform_point(ctm, p);
+			path->items[i].v = p.x;
+			path->items[i+1].v = p.y;
 			i += 2;
 			break;
-		case FZ_CLOSEPATH:
+		case FZ_CLOSE_PATH:
 			break;
 		}
 	}
 }
 
 void
-fz_debugpath(fz_path *path, int indent)
+fz_debug_path(fz_path *path, int indent)
 {
 	float x, y;
 	int i = 0;
@@ -216,30 +216,30 @@ fz_debugpath(fz_path *path, int indent)
 	{
 		for (n = 0; n < indent; n++)
 			putchar(' ');
-		switch (path->els[i++].k)
+		switch (path->items[i++].k)
 		{
 		case FZ_MOVETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("%g %g m\n", x, y);
 			break;
 		case FZ_LINETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("%g %g l\n", x, y);
 			break;
 		case FZ_CURVETO:
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("%g %g ", x, y);
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("%g %g ", x, y);
-			x = path->els[i++].v;
-			y = path->els[i++].v;
+			x = path->items[i++].v;
+			y = path->items[i++].v;
 			printf("%g %g c\n", x, y);
 			break;
-		case FZ_CLOSEPATH:
+		case FZ_CLOSE_PATH:
 			printf("h\n");
 			break;
 		}
diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c
index 85138be1..7e689e07 100644
--- a/fitz/res_pixmap.c
+++ b/fitz/res_pixmap.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 
 fz_pixmap *
-fz_newpixmapwithdata(fz_colorspace *colorspace, int x, int y, int w, int h, unsigned char *samples)
+fz_new_pixmap_with_data(fz_colorspace *colorspace, int x, int y, int w, int h, unsigned char *samples)
 {
 	fz_pixmap *pix;
 
@@ -11,75 +11,75 @@ fz_newpixmapwithdata(fz_colorspace *colorspace, int x, int y, int w, int h, unsi
 	pix->y = y;
 	pix->w = w;
 	pix->h = h;
-	pix->mask = nil;
+	pix->mask = NULL;
 	pix->interpolate = 1;
 	pix->xres = 96;
 	pix->yres = 96;
-	pix->colorspace = nil;
+	pix->colorspace = NULL;
 	pix->n = 1;
 
 	if (colorspace)
 	{
-		pix->colorspace = fz_keepcolorspace(colorspace);
+		pix->colorspace = fz_keep_colorspace(colorspace);
 		pix->n = 1 + colorspace->n;
 	}
 
 	if (samples)
 	{
 		pix->samples = samples;
-		pix->freesamples = 0;
+		pix->free_samples = 0;
 	}
 	else
 	{
 		pix->samples = fz_calloc(pix->h, pix->w * pix->n);
-		pix->freesamples = 1;
+		pix->free_samples = 1;
 	}
 
 	return pix;
 }
 
 fz_pixmap *
-fz_newpixmap(fz_colorspace *colorspace, int x, int y, int w, int h)
+fz_new_pixmap(fz_colorspace *colorspace, int x, int y, int w, int h)
 {
-	return fz_newpixmapwithdata(colorspace, x, y, w, h, nil);
+	return fz_new_pixmap_with_data(colorspace, x, y, w, h, NULL);
 }
 
 fz_pixmap *
-fz_newpixmapwithrect(fz_colorspace *colorspace, fz_bbox r)
+fz_new_pixmap_with_rect(fz_colorspace *colorspace, fz_bbox r)
 {
-	return fz_newpixmap(colorspace, r.x0, r.y0, r.x1 - r.x0, r.y1 - r.y0);
+	return fz_new_pixmap(colorspace, r.x0, r.y0, r.x1 - r.x0, r.y1 - r.y0);
 }
 
 fz_pixmap *
-fz_keeppixmap(fz_pixmap *pix)
+fz_keep_pixmap(fz_pixmap *pix)
 {
 	pix->refs++;
 	return pix;
 }
 
 void
-fz_droppixmap(fz_pixmap *pix)
+fz_drop_pixmap(fz_pixmap *pix)
 {
 	if (pix && --pix->refs == 0)
 	{
 		if (pix->mask)
-			fz_droppixmap(pix->mask);
+			fz_drop_pixmap(pix->mask);
 		if (pix->colorspace)
-			fz_dropcolorspace(pix->colorspace);
-		if (pix->freesamples)
+			fz_drop_colorspace(pix->colorspace);
+		if (pix->free_samples)
 			fz_free(pix->samples);
 		fz_free(pix);
 	}
 }
 
 void
-fz_clearpixmap(fz_pixmap *pix)
+fz_clear_pixmap(fz_pixmap *pix)
 {
 	memset(pix->samples, 0, pix->w * pix->h * pix->n);
 }
 
 void
-fz_clearpixmapwithcolor(fz_pixmap *pix, int value)
+fz_clear_pixmap_with_color(fz_pixmap *pix, int value)
 {
 	if (value == 255)
 		memset(pix->samples, 255, pix->w * pix->h * pix->n);
@@ -100,7 +100,7 @@ fz_clearpixmapwithcolor(fz_pixmap *pix, int value)
 }
 
 void
-fz_premultiplypixmap(fz_pixmap *pix)
+fz_premultiply_pixmap(fz_pixmap *pix)
 {
 	unsigned char *s = pix->samples;
 	unsigned char a;
@@ -119,7 +119,7 @@ fz_premultiplypixmap(fz_pixmap *pix)
 }
 
 fz_bbox
-fz_boundpixmap(fz_pixmap *pix)
+fz_bound_pixmap(fz_pixmap *pix)
 {
 	fz_bbox bbox;
 	bbox.x0 = pix->x;
@@ -130,7 +130,7 @@ fz_boundpixmap(fz_pixmap *pix)
 }
 
 fz_pixmap *
-fz_alphafromgray(fz_pixmap *gray, int luminosity)
+fz_alpha_from_gray(fz_pixmap *gray, int luminosity)
 {
 	fz_pixmap *alpha;
 	unsigned char *sp, *dp;
@@ -138,7 +138,7 @@ fz_alphafromgray(fz_pixmap *gray, int luminosity)
 
 	assert(gray->n == 2);
 
-	alpha = fz_newpixmap(nil, gray->x, gray->y, gray->w, gray->h);
+	alpha = fz_new_pixmap(NULL, gray->x, gray->y, gray->w, gray->h);
 	dp = alpha->samples;
 	sp = gray->samples;
 	if (!luminosity)
@@ -159,7 +159,7 @@ fz_alphafromgray(fz_pixmap *gray, int luminosity)
  */
 
 fz_error
-fz_writepnm(fz_pixmap *pixmap, char *filename)
+fz_write_pnm(fz_pixmap *pixmap, char *filename)
 {
 	FILE *fp;
 	unsigned char *p;
@@ -213,7 +213,7 @@ fz_writepnm(fz_pixmap *pixmap, char *filename)
  */
 
 fz_error
-fz_writepam(fz_pixmap *pixmap, char *filename, int savealpha)
+fz_write_pam(fz_pixmap *pixmap, char *filename, int savealpha)
 {
 	unsigned char *sp;
 	int y, w, k;
@@ -289,14 +289,14 @@ static void putchunk(char *tag, unsigned char *data, int size, FILE *fp)
 	put32(size, fp);
 	fwrite(tag, 1, 4, fp);
 	fwrite(data, 1, size, fp);
-	sum = crc32(0, nil, 0);
+	sum = crc32(0, NULL, 0);
 	sum = crc32(sum, (unsigned char*)tag, 4);
 	sum = crc32(sum, data, size);
 	put32(sum, fp);
 }
 
 fz_error
-fz_writepng(fz_pixmap *pixmap, char *filename, int savealpha)
+fz_write_png(fz_pixmap *pixmap, char *filename, int savealpha)
 {
 	static const unsigned char pngsig[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
 	FILE *fp;
diff --git a/fitz/res_shade.c b/fitz/res_shade.c
index e4afa14a..7faff3bf 100644
--- a/fitz/res_shade.c
+++ b/fitz/res_shade.c
@@ -1,26 +1,26 @@
 #include "fitz.h"
 
 fz_shade *
-fz_keepshade(fz_shade *shade)
+fz_keep_shade(fz_shade *shade)
 {
 	shade->refs ++;
 	return shade;
 }
 
 void
-fz_dropshade(fz_shade *shade)
+fz_drop_shade(fz_shade *shade)
 {
 	if (shade && --shade->refs == 0)
 	{
 		if (shade->colorspace)
-			fz_dropcolorspace(shade->colorspace);
+			fz_drop_colorspace(shade->colorspace);
 		fz_free(shade->mesh);
 		fz_free(shade);
 	}
 }
 
 fz_rect
-fz_boundshade(fz_shade *shade, fz_matrix ctm)
+fz_bound_shade(fz_shade *shade, fz_matrix ctm)
 {
 	float *v;
 	fz_rect r;
@@ -28,22 +28,22 @@ fz_boundshade(fz_shade *shade, fz_matrix ctm)
 	int i, ncomp, nvert;
 
 	ctm = fz_concat(shade->matrix, ctm);
-	ncomp = shade->usefunction ? 3 : 2 + shade->colorspace->n;
-	nvert = shade->meshlen / ncomp;
+	ncomp = shade->use_function ? 3 : 2 + shade->colorspace->n;
+	nvert = shade->mesh_len / ncomp;
 	v = shade->mesh;
 
 	if (shade->type == FZ_LINEAR)
-		return fz_infiniterect;
+		return fz_infinite_rect;
 	if (shade->type == FZ_RADIAL)
-		return fz_infiniterect;
+		return fz_infinite_rect;
 
 	if (nvert == 0)
-		return fz_emptyrect;
+		return fz_empty_rect;
 
 	p.x = v[0];
 	p.y = v[1];
 	v += ncomp;
-	p = fz_transformpoint(ctm, p);
+	p = fz_transform_point(ctm, p);
 	r.x0 = r.x1 = p.x;
 	r.y0 = r.y1 = p.y;
 
@@ -51,7 +51,7 @@ fz_boundshade(fz_shade *shade, fz_matrix ctm)
 	{
 		p.x = v[0];
 		p.y = v[1];
-		p = fz_transformpoint(ctm, p);
+		p = fz_transform_point(ctm, p);
 		v += ncomp;
 		if (p.x < r.x0) r.x0 = p.x;
 		if (p.y < r.y0) r.y0 = p.y;
@@ -63,7 +63,7 @@ fz_boundshade(fz_shade *shade, fz_matrix ctm)
 }
 
 void
-fz_debugshade(fz_shade *shade)
+fz_debug_shade(fz_shade *shade)
 {
 	int i, j, n;
 	float *vertex;
@@ -88,7 +88,7 @@ fz_debugshade(fz_shade *shade)
 			shade->matrix.a, shade->matrix.b, shade->matrix.c,
 			shade->matrix.d, shade->matrix.e, shade->matrix.f);
 
-	if (shade->usebackground)
+	if (shade->use_background)
 	{
 		printf("\tbackground [");
 		for (i = 0; i < shade->colorspace->n; i++)
@@ -96,7 +96,7 @@ fz_debugshade(fz_shade *shade)
 		printf("]\n");
 	}
 
-	if (shade->usefunction)
+	if (shade->use_function)
 	{
 		printf("\tfunction\n");
 		n = 3;
@@ -104,12 +104,12 @@ fz_debugshade(fz_shade *shade)
 	else
 		n = 2 + shade->colorspace->n;
 
-	printf("\tvertices: %d\n", shade->meshlen);
+	printf("\tvertices: %d\n", shade->mesh_len);
 
 	vertex = shade->mesh;
 	triangle = 0;
 	i = 0;
-	while (i < shade->meshlen)
+	while (i < shade->mesh_len)
 	{
 		printf("\t%d:(%g, %g): ", triangle, vertex[0], vertex[1]);
 
diff --git a/fitz/res_text.c b/fitz/res_text.c
index 8ba62669..d38637f1 100644
--- a/fitz/res_text.c
+++ b/fitz/res_text.c
@@ -1,48 +1,48 @@
 #include "fitz.h"
 
 fz_text *
-fz_newtext(fz_font *font, fz_matrix trm, int wmode)
+fz_new_text(fz_font *font, fz_matrix trm, int wmode)
 {
 	fz_text *text;
 
 	text = fz_malloc(sizeof(fz_text));
-	text->font = fz_keepfont(font);
+	text->font = fz_keep_font(font);
 	text->trm = trm;
 	text->wmode = wmode;
 	text->len = 0;
 	text->cap = 0;
-	text->els = nil;
+	text->items = NULL;
 
 	return text;
 }
 
 void
-fz_freetext(fz_text *text)
+fz_free_text(fz_text *text)
 {
-	fz_dropfont(text->font);
-	fz_free(text->els);
+	fz_drop_font(text->font);
+	fz_free(text->items);
 	fz_free(text);
 }
 
 fz_text *
-fz_clonetext(fz_text *old)
+fz_clone_text(fz_text *old)
 {
 	fz_text *text;
 
 	text = fz_malloc(sizeof(fz_text));
-	text->font = fz_keepfont(old->font);
+	text->font = fz_keep_font(old->font);
 	text->trm = old->trm;
 	text->wmode = old->wmode;
 	text->len = old->len;
 	text->cap = text->len;
-	text->els = fz_calloc(text->len, sizeof(fz_textel));
-	memcpy(text->els, old->els, text->len * sizeof(fz_textel));
+	text->items = fz_calloc(text->len, sizeof(fz_text_item));
+	memcpy(text->items, old->items, text->len * sizeof(fz_text_item));
 
 	return text;
 }
 
 fz_rect
-fz_boundtext(fz_text *text, fz_matrix ctm)
+fz_bound_text(fz_text *text, fz_matrix ctm)
 {
 	fz_matrix trm;
 	fz_rect bbox;
@@ -50,22 +50,22 @@ fz_boundtext(fz_text *text, fz_matrix ctm)
 	int i;
 
 	if (text->len == 0)
-		return fz_emptyrect;
+		return fz_empty_rect;
 
 	/* find bbox of glyph origins in ctm space */
 
-	bbox.x0 = bbox.x1 = text->els[0].x;
-	bbox.y0 = bbox.y1 = text->els[0].y;
+	bbox.x0 = bbox.x1 = text->items[0].x;
+	bbox.y0 = bbox.y1 = text->items[0].y;
 
 	for (i = 1; i < text->len; i++)
 	{
-		bbox.x0 = MIN(bbox.x0, text->els[i].x);
-		bbox.y0 = MIN(bbox.y0, text->els[i].y);
-		bbox.x1 = MAX(bbox.x1, text->els[i].x);
-		bbox.y1 = MAX(bbox.y1, text->els[i].y);
+		bbox.x0 = MIN(bbox.x0, text->items[i].x);
+		bbox.y0 = MIN(bbox.y0, text->items[i].y);
+		bbox.x1 = MAX(bbox.x1, text->items[i].x);
+		bbox.y1 = MAX(bbox.y1, text->items[i].y);
 	}
 
-	bbox = fz_transformrect(ctm, bbox);
+	bbox = fz_transform_rect(ctm, bbox);
 
 	/* find bbox of font in trm * ctm space */
 
@@ -78,7 +78,7 @@ fz_boundtext(fz_text *text, fz_matrix ctm)
 	fbox.x1 = text->font->bbox.x1 * 0.001f;
 	fbox.y1 = text->font->bbox.y1 * 0.001f;
 
-	fbox = fz_transformrect(trm, fbox);
+	fbox = fz_transform_rect(trm, fbox);
 
 	/* expand glyph origin bbox by font bbox */
 
@@ -91,23 +91,23 @@ fz_boundtext(fz_text *text, fz_matrix ctm)
 }
 
 static void
-fz_growtext(fz_text *text, int n)
+fz_grow_text(fz_text *text, int n)
 {
 	if (text->len + n < text->cap)
 		return;
 	while (text->len + n > text->cap)
 		text->cap = text->cap + 36;
-	text->els = fz_realloc(text->els, text->cap, sizeof(fz_textel));
+	text->items = fz_realloc(text->items, text->cap, sizeof(fz_text_item));
 }
 
 void
-fz_addtext(fz_text *text, int gid, int ucs, float x, float y)
+fz_add_text(fz_text *text, int gid, int ucs, float x, float y)
 {
-	fz_growtext(text, 1);
-	text->els[text->len].ucs = ucs;
-	text->els[text->len].gid = gid;
-	text->els[text->len].x = x;
-	text->els[text->len].y = y;
+	fz_grow_text(text, 1);
+	text->items[text->len].ucs = ucs;
+	text->items[text->len].gid = gid;
+	text->items[text->len].x = x;
+	text->items[text->len].y = y;
 	text->len++;
 }
 
@@ -116,18 +116,18 @@ static int isxmlmeta(int c)
 	return c < 32 || c >= 128 || c == '&' || c == '<' || c == '>' || c == '\'' || c == '"';
 }
 
-void fz_debugtext(fz_text *text, int indent)
+void fz_debug_text(fz_text *text, int indent)
 {
 	int i, n;
 	for (i = 0; i < text->len; i++)
 	{
 		for (n = 0; n < indent; n++)
 			putchar(' ');
-		if (!isxmlmeta(text->els[i].ucs))
+		if (!isxmlmeta(text->items[i].ucs))
 			printf("<g ucs=\"%c\" gid=\"%d\" x=\"%g\" y=\"%g\" />\n",
-				text->els[i].ucs, text->els[i].gid, text->els[i].x, text->els[i].y);
+				text->items[i].ucs, text->items[i].gid, text->items[i].x, text->items[i].y);
 		else
 			printf("<g ucs=\"U+%04X\" gid=\"%d\" x=\"%g\" y=\"%g\" />\n",
-				text->els[i].ucs, text->els[i].gid, text->els[i].x, text->els[i].y);
+				text->items[i].ucs, text->items[i].gid, text->items[i].x, text->items[i].y);
 	}
 }
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index 9b1ee469..4c7410c3 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 
 fz_buffer *
-fz_newbuffer(int size)
+fz_new_buffer(int size)
 {
 	fz_buffer *b;
 
@@ -17,14 +17,14 @@ fz_newbuffer(int size)
 }
 
 fz_buffer *
-fz_keepbuffer(fz_buffer *buf)
+fz_keep_buffer(fz_buffer *buf)
 {
 	buf->refs ++;
 	return buf;
 }
 
 void
-fz_dropbuffer(fz_buffer *buf)
+fz_drop_buffer(fz_buffer *buf)
 {
 	if (--buf->refs == 0)
 	{
@@ -34,7 +34,7 @@ fz_dropbuffer(fz_buffer *buf)
 }
 
 void
-fz_resizebuffer(fz_buffer *buf, int size)
+fz_resize_buffer(fz_buffer *buf, int size)
 {
 	buf->data = fz_realloc(buf->data, size, 1);
 	buf->cap = size;
@@ -43,7 +43,7 @@ fz_resizebuffer(fz_buffer *buf, int size)
 }
 
 void
-fz_growbuffer(fz_buffer *buf)
+fz_grow_buffer(fz_buffer *buf)
 {
-	fz_resizebuffer(buf, (buf->cap * 3) / 2);
+	fz_resize_buffer(buf, (buf->cap * 3) / 2);
 }
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index c7cf8409..74346f73 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 
 fz_stream *
-fz_newstream(void *state,
+fz_new_stream(void *state,
 	int(*read)(fz_stream *stm, unsigned char *buf, int len),
 	void(*close)(fz_stream *stm))
 {
@@ -25,13 +25,13 @@ fz_newstream(void *state,
 	stm->state = state;
 	stm->read = read;
 	stm->close = close;
-	stm->seek = nil;
+	stm->seek = NULL;
 
 	return stm;
 }
 
 fz_stream *
-fz_keepstream(fz_stream *stm)
+fz_keep_stream(fz_stream *stm)
 {
 	stm->refs ++;
 	return stm;
@@ -51,7 +51,7 @@ fz_close(fz_stream *stm)
 
 /* File stream */
 
-static int readfile(fz_stream *stm, unsigned char *buf, int len)
+static int read_file(fz_stream *stm, unsigned char *buf, int len)
 {
 	int n = read(*(int*)stm->state, buf, len);
 	if (n < 0)
@@ -59,7 +59,7 @@ static int readfile(fz_stream *stm, unsigned char *buf, int len)
 	return n;
 }
 
-static void seekfile(fz_stream *stm, int offset, int whence)
+static void seek_file(fz_stream *stm, int offset, int whence)
 {
 	int n = lseek(*(int*)stm->state, offset, whence);
 	if (n < 0)
@@ -69,7 +69,7 @@ static void seekfile(fz_stream *stm, int offset, int whence)
 	stm->wp = stm->bp;
 }
 
-static void closefile(fz_stream *stm)
+static void close_file(fz_stream *stm)
 {
 	int n = close(*(int*)stm->state);
 	if (n < 0)
@@ -78,7 +78,7 @@ static void closefile(fz_stream *stm)
 }
 
 fz_stream *
-fz_openfd(int fd)
+fz_open_fd(int fd)
 {
 	fz_stream *stm;
 	int *state;
@@ -86,40 +86,40 @@ fz_openfd(int fd)
 	state = fz_malloc(sizeof(int));
 	*state = fd;
 
-	stm = fz_newstream(state, readfile, closefile);
-	stm->seek = seekfile;
+	stm = fz_new_stream(state, read_file, close_file);
+	stm->seek = seek_file;
 
 	return stm;
 }
 
 fz_stream *
-fz_openfile(const char *name)
+fz_open_file(const char *name)
 {
 	int fd = open(name, O_BINARY | O_RDONLY, 0);
 	if (fd == -1)
-		return nil;
-	return fz_openfd(fd);
+		return NULL;
+	return fz_open_fd(fd);
 }
 
 #ifdef _WIN32
 fz_stream *
-fz_openfilew(const wchar_t *name)
+fz_open_file_w(const wchar_t *name)
 {
 	int fd = _wopen(name, O_BINARY | O_RDONLY, 0);
 	if (fd == -1)
-		return nil;
-	return fz_openfd(fd);
+		return NULL;
+	return fz_open_fd(fd);
 }
 #endif
 
 /* Memory stream */
 
-static int readbuffer(fz_stream *stm, unsigned char *buf, int len)
+static int read_buffer(fz_stream *stm, unsigned char *buf, int len)
 {
 	return 0;
 }
 
-static void seekbuffer(fz_stream *stm, int offset, int whence)
+static void seek_buffer(fz_stream *stm, int offset, int whence)
 {
 	if (whence == 0)
 		stm->rp = stm->bp + offset;
@@ -131,19 +131,19 @@ static void seekbuffer(fz_stream *stm, int offset, int whence)
 	stm->wp = stm->ep;
 }
 
-static void closebuffer(fz_stream *stm)
+static void close_buffer(fz_stream *stm)
 {
 	if (stm->state)
-		fz_dropbuffer(stm->state);
+		fz_drop_buffer(stm->state);
 }
 
 fz_stream *
-fz_openbuffer(fz_buffer *buf)
+fz_open_buffer(fz_buffer *buf)
 {
 	fz_stream *stm;
 
-	stm = fz_newstream(fz_keepbuffer(buf), readbuffer, closebuffer);
-	stm->seek = seekbuffer;
+	stm = fz_new_stream(fz_keep_buffer(buf), read_buffer, close_buffer);
+	stm->seek = seek_buffer;
 
 	stm->bp = buf->data;
 	stm->rp = buf->data;
@@ -156,12 +156,12 @@ fz_openbuffer(fz_buffer *buf)
 }
 
 fz_stream *
-fz_openmemory(unsigned char *data, int len)
+fz_open_memory(unsigned char *data, int len)
 {
 	fz_stream *stm;
 
-	stm = fz_newstream(nil, readbuffer, closebuffer);
-	stm->seek = seekbuffer;
+	stm = fz_new_stream(NULL, read_buffer, close_buffer);
+	stm->seek = seek_buffer;
 
 	stm->bp = data;
 	stm->rp = data;
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index 10626e5d..4a81b9cd 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -67,7 +67,7 @@ fz_read(fz_stream *stm, unsigned char *buf, int len)
 }
 
 void
-fz_fillbuffer(fz_stream *stm)
+fz_fill_buffer(fz_stream *stm)
 {
 	int n;
 
@@ -95,7 +95,7 @@ fz_fillbuffer(fz_stream *stm)
 }
 
 fz_error
-fz_readall(fz_buffer **bufp, fz_stream *stm, int initial)
+fz_read_all(fz_buffer **bufp, fz_stream *stm, int initial)
 {
 	fz_buffer *buf;
 	int n;
@@ -103,23 +103,23 @@ fz_readall(fz_buffer **bufp, fz_stream *stm, int initial)
 	if (initial < 1024)
 		initial = 1024;
 
-	buf = fz_newbuffer(initial);
+	buf = fz_new_buffer(initial);
 
 	while (1)
 	{
 		if (buf->len == buf->cap)
-			fz_growbuffer(buf);
+			fz_grow_buffer(buf);
 
 		if (buf->len / 200 > initial)
 		{
-			fz_dropbuffer(buf);
+			fz_drop_buffer(buf);
 			return fz_throw("compression bomb detected");
 		}
 
 		n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
 		if (n < 0)
 		{
-			fz_dropbuffer(buf);
+			fz_drop_buffer(buf);
 			return fz_rethrow(n, "read error");
 		}
 		if (n == 0)
@@ -133,19 +133,19 @@ fz_readall(fz_buffer **bufp, fz_stream *stm, int initial)
 }
 
 void
-fz_readline(fz_stream *stm, char *mem, int n)
+fz_read_line(fz_stream *stm, char *mem, int n)
 {
 	char *s = mem;
 	int c = EOF;
 	while (n > 1)
 	{
-		c = fz_readbyte(stm);
+		c = fz_read_byte(stm);
 		if (c == EOF)
 			break;
 		if (c == '\r') {
-			c = fz_peekbyte(stm);
+			c = fz_peek_byte(stm);
 			if (c == '\n')
-				fz_readbyte(stm);
+				fz_read_byte(stm);
 			break;
 		}
 		if (c == '\n')
@@ -184,7 +184,7 @@ fz_seek(fz_stream *stm, int offset, int whence)
 			fz_warn("cannot seek backwards");
 		/* dog slow, but rare enough */
 		while (offset-- > 0)
-			fz_readbyte(stm);
+			fz_read_byte(stm);
 	}
 	else
 		fz_warn("cannot seek");