Pre-compile the standard CMaps into c-structs instead of parsing them at runtime.

14 files changed, 1331 insertions, 1492 deletions

diff --git a/Jamfile b/Jamfile
index 6fd4a7b9..23a80dcb 100644
--- a/Jamfile
+++ b/Jamfile
@@ -10,12 +10,13 @@ SubDir TOP ;
 
 HDRS = [ FDirName $(TOP) include ] ;
 
-Main hexdump : hexdump.c ;
-Main strdump : strdump.c ;
-
 SubInclude TOP fitz ;
 SubInclude TOP fitzdraw ;
 
+Main hexdump : hexdump.c ;
+Main cmapdump : cmapdump.c ;
+LinkLibraries cmapdump : libfitz ;
+
 SubInclude TOP fonts ;
 SubInclude TOP cmaps ;
 SubInclude TOP mupdf ;
diff --git a/cmapdump.c b/cmapdump.c
new file mode 100644
index 00000000..f6c5cb2e
--- /dev/null
+++ b/cmapdump.c
@@ -0,0 +1,160 @@
+/* cmapdump.c -- parse a CMap file and dump it as a c-struct */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "fitz.h"
+#include "mupdf.h"
+
+#include "mupdf/pdf_lex.c"
+#include "mupdf/pdf_cmap.c"
+#include "mupdf/pdf_cmap_parse.c"
+
+char *
+flagtoname(int flag)
+{
+    switch (flag)
+    {
+	case PDF_CMAP_SINGLE: return "PDF_CMAP_SINGLE,";
+	case PDF_CMAP_RANGE:  return "PDF_CMAP_RANGE, ";
+	case PDF_CMAP_TABLE:  return "PDF_CMAP_TABLE, ";
+	case PDF_CMAP_MULTI:  return "PDF_CMAP_MULTI, ";
+    }
+    return "-1,";
+}
+
+void
+clean(char *p)
+{
+    while (*p)
+    {
+	if ((*p == '/') || (*p == '.') || (*p == '\\') || (*p == '-'))
+	    *p = '_';
+	p ++;
+    }
+}
+
+int
+main(int argc, char **argv)
+{
+    pdf_cmap *cmap;
+    fz_error *error;
+    fz_stream *fi;
+    FILE *fo;
+    char name[256];
+    char *realname;
+    char *p;
+    int i, k;
+
+    if (argc < 3)
+    {
+	fprintf(stderr, "usage: cmapdump output.c lots of cmap files\n");
+	return 1;
+    }
+
+    fo = fopen(argv[1], "wb");
+    if (!fo)
+    {
+	fprintf(stderr, "cmapdump: could not open output file\n");
+	return 1;
+    }
+
+    fprintf(fo, "#include \"fitz.h\"\n");
+    fprintf(fo, "#include \"mupdf.h\"\n");
+    fprintf(fo, "\n");
+
+    for (i = 2; i < argc; i++)
+    {
+	realname = strrchr(argv[i], '/');
+	if (!realname)
+	    realname = strrchr(argv[i], '\\');
+	if (realname)
+	    realname ++;
+	else
+	    realname = argv[i];
+
+	strcpy(name, realname);
+	p = name;
+	while (*p)
+	{
+	    if ((*p == '/') || (*p == '.') || (*p == '\\') || (*p == '-'))
+		*p = '_';
+	    p ++;
+	}
+
+	error = fz_openrfile(&fi, argv[i]);
+	if (error)
+	{
+	    fprintf(stderr, "cmapdump: could not open input file %s\n", argv[i]);
+	    fz_printerror(error);
+	    return 1;
+	}
+
+	error = pdf_parsecmap(&cmap, fi);
+	if (error)
+	{
+	    fprintf(stderr, "cmapdump: could not parse input cmap %s\n", argv[i]);
+	    fz_printerror(error);
+	    return 1;
+	}
+
+	fprintf(fo, "/*\n * %s\n */\n\n", cmap->cmapname);
+
+	fprintf(fo, "static const pdf_range pdf_cmap_%s_ranges[%d] =\n{\n",
+		name, cmap->rlen);
+	for (k = 0; k < cmap->rlen; k++)
+	{
+	    fprintf(fo, "    { 0x%04x, 0x%04x, %s %d },\n",
+		    cmap->ranges[k].low, cmap->ranges[k].high,
+		    flagtoname(cmap->ranges[k].flag),
+		    cmap->ranges[k].offset);
+	}
+	fprintf(fo, "};\n\n");
+
+	if (cmap->tlen == 0)
+	{
+	    fprintf(fo, "static const int pdf_cmap_%s_table[1] = { 0 };\n\n", name);
+	}
+	else
+	{
+	    fprintf(fo, "static const int pdf_cmap_%s_table[%d] =\n{",
+		    name, cmap->tlen);
+	    for (k = 0; k < cmap->tlen; k++)
+	    {
+		if (k % 8 == 0)
+		    fprintf(fo, "\n    ");
+		fprintf(fo, "%d, ", cmap->table[k]);
+	    }
+	    fprintf(fo, "\n};\n\n");
+	}
+
+	fprintf(fo, "pdf_cmap pdf_cmap_%s =\n", name);
+	fprintf(fo, "{\n");
+	fprintf(fo, "    -1, ");
+	fprintf(fo, "\"%s\", ", cmap->cmapname);
+	fprintf(fo, "\"%s\", 0, ", cmap->usecmapname);
+	fprintf(fo, "%d,\n", cmap->wmode);
+
+	fprintf(fo, "    %d, /* codespace table */\n", cmap->ncspace);
+	fprintf(fo, "    {\n");
+	for (k = 0; k < cmap->ncspace; k++)
+	{
+	    fprintf(fo, "\t{ %d, 0x%04x, 0x%04x },\n",
+		    cmap->cspace[k].n, cmap->cspace[k].lo, cmap->cspace[k].hi);
+	}
+	fprintf(fo, "    },\n");
+
+	fprintf(fo, "    %d, %d, (pdf_range*) pdf_cmap_%s_ranges,\n",
+		cmap->rlen, cmap->rlen, name);
+
+	fprintf(fo, "    %d, %d, (int*) pdf_cmap_%s_table,\n",
+		cmap->tlen, cmap->tlen, name);
+
+	fprintf(fo, "};\n\n");
+
+	fz_dropstream(fi);
+    }
+
+    return 0;
+}
+
diff --git a/cmaps/Jamfile b/cmaps/Jamfile
index 9203009e..2d2e435a 100644
--- a/cmaps/Jamfile
+++ b/cmaps/Jamfile
@@ -3,7 +3,7 @@
 #
 
 SubDir TOP cmaps chinese_s ;
-GenFile cmap_chinese_s.c : strdump
+GenFile cmap_chinese_s.c : cmapdump
     Adobe-GB1-4
     Adobe-GB1-UCS2
     GB-EUC-H
@@ -27,7 +27,7 @@ GenFile cmap_chinese_s.c : strdump
 Library libcmaps : cmap_chinese_s.c ;
 
 SubDir TOP cmaps chinese_t ;
-GenFile cmap_chinese_t.c : strdump
+GenFile cmap_chinese_t.c : cmapdump
     Adobe-CNS1-3
     Adobe-CNS1-UCS2
     B5pc-H
@@ -47,7 +47,7 @@ GenFile cmap_chinese_t.c : strdump
 Library libcmaps : cmap_chinese_t.c ;
 
 SubDir TOP cmaps japanese ;
-GenFile cmap_japanese.c : strdump 
+GenFile cmap_japanese.c : cmapdump
     83pv-RKSJ-H
     90ms-RKSJ-H
     90ms-RKSJ-UCS2
@@ -75,7 +75,7 @@ GenFile cmap_japanese.c : strdump
 Library libcmaps : cmap_japanese.c ;
 
 SubDir TOP cmaps korean ;
-GenFile cmap_korean.c : strdump 
+GenFile cmap_korean.c : cmapdump
     Adobe-Korea1-2
     Adobe-Korea1-UCS2
     KSC-EUC-H
diff --git a/include/fitz.h b/include/fitz.h
index 47e7eeb8..f9705740 100644
--- a/include/fitz.h
+++ b/include/fitz.h
@@ -1,6 +1,4 @@
-#ifdef _FITZ_H_
-#error "fitz.h must only be included once"
-#endif
+#ifndef _FITZ_H_
 #define _FITZ_H_
 
 #include "fitz-base.h"
@@ -8,3 +6,4 @@
 #include "fitz-world.h"
 #include "fitz-draw.h"
 
+#endif
diff --git a/include/mupdf.h b/include/mupdf.h
index 86b9a6c9..07acde71 100644
--- a/include/mupdf.h
+++ b/include/mupdf.h
@@ -1,18 +1,8 @@
-#ifdef _MUPDF_H_
-#error "mupdf.h must only be included once"
-#endif
+#ifndef _MUPDF_H_
 #define _MUPDF_H_
 
-#ifndef _FITZ_BASE_H_
-#error "fitz-base.h must be included before mupdf.h"
-#endif
-
-#ifndef _FITZ_STREAM_H_
-#error "fitz-stream.h must be included before mupdf.h"
-#endif
-
-#ifndef _FITZ_WORLD_H_
-#error "fitz-world.h must be included before mupdf.h"
+#ifndef _FITZ_H_
+#error "fitz.h must be included before mupdf.h"
 #endif
 
 void pdf_logxref(char *fmt, ...);
@@ -29,3 +19,4 @@ void pdf_logpage(char *fmt, ...);
 #include "mupdf/annot.h"
 #include "mupdf/page.h"
 
+#endif
diff --git a/include/mupdf/rsrc.h b/include/mupdf/rsrc.h
index 738919b4..f4e7717c 100644
--- a/include/mupdf/rsrc.h
+++ b/include/mupdf/rsrc.h
@@ -147,16 +147,43 @@ fz_error *pdf_loadtile(fz_image *image, fz_pixmap *tile);
  */
 
 typedef struct pdf_cmap_s pdf_cmap;
+typedef struct pdf_range_s pdf_range;
 
-struct pdf_cmapentry_s
+enum { PDF_CMAP_SINGLE, PDF_CMAP_RANGE, PDF_CMAP_TABLE, PDF_CMAP_MULTI };
+
+struct pdf_range_s
 {
-    const char *name;
-    const char *buf;
-    const int *len;
-    pdf_cmap *cmap;
+	int low;
+	int high;
+	int flag;	/* what kind of lookup is this (single, range, table, multi) */
+	int offset;	/* either range-delta or table-index */
 };
 
-extern struct pdf_cmapentry_s pdf_cmaptable[]; /* list of builtin system cmaps */
+struct pdf_cmap_s
+{
+	int refs;
+	char cmapname[32];
+
+	char usecmapname[32];
+	pdf_cmap *usecmap;
+
+	int wmode;
+
+	int ncspace;
+	struct {
+		int n;
+		unsigned lo;
+		unsigned hi;
+	} cspace[40];
+
+	int rlen, rcap;
+	pdf_range *ranges;
+
+	int tlen, tcap;
+	int *table;
+};
+
+extern pdf_cmap *pdf_cmaptable[]; /* list of builtin system cmaps */
 
 fz_error *pdf_newcmap(pdf_cmap **cmapp);
 pdf_cmap *pdf_keepcmap(pdf_cmap *cmap);
@@ -164,12 +191,11 @@ void pdf_dropcmap(pdf_cmap *cmap);
 
 void pdf_debugcmap(pdf_cmap *cmap);
 int pdf_getwmode(pdf_cmap *cmap);
-pdf_cmap *fz_getusecmap(pdf_cmap *cmap);
-void fz_setwmode(pdf_cmap *cmap, int wmode);
-void fz_setusecmap(pdf_cmap *cmap, pdf_cmap *usecmap);
+pdf_cmap *pdf_getusecmap(pdf_cmap *cmap);
+void pdf_setwmode(pdf_cmap *cmap, int wmode);
+void pdf_setusecmap(pdf_cmap *cmap, pdf_cmap *usecmap);
 
 fz_error *pdf_addcodespace(pdf_cmap *cmap, unsigned lo, unsigned hi, int n);
-
 fz_error *pdf_maprangetotable(pdf_cmap *cmap, int low, int *map, int len);
 fz_error *pdf_maprangetorange(pdf_cmap *cmap, int srclo, int srchi, int dstlo);
 fz_error *pdf_maponetomany(pdf_cmap *cmap, int one, int *many, int len);
diff --git a/mupdf/Jamfile b/mupdf/Jamfile
index f11db836..e8f02310 100644
--- a/mupdf/Jamfile
+++ b/mupdf/Jamfile
@@ -20,10 +20,13 @@ Library libmupdf :
 	pdf_outline.c
 
 	# fonts
+	pdf_cmap.c
+	pdf_cmap_parse.c
+	pdf_cmap_load.c
+	pdf_cmap_table.c
+
 	pdf_fontagl.c
 	pdf_fontenc.c
-	pdf_cmapfile.c
-	pdf_cmap.c
 	pdf_unicode.c
 	pdf_font.c
 	pdf_type3.c
diff --git a/mupdf/pdf_cmap.c b/mupdf/pdf_cmap.c
index 6728c333..47402f2e 100644
--- a/mupdf/pdf_cmap.c
+++ b/mupdf/pdf_cmap.c
@@ -18,49 +18,6 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-typedef struct pdf_range_s pdf_range;
-
-enum { MAXCODESPACE = 10 };
-enum { SINGLE, RANGE, TABLE, MULTI };
-
-struct pdf_range_s
-{
-	int low;
-	int high;
-	int flag;	/* what kind of lookup is this */
-	int offset;	/* either range-delta or table-index */
-};
-
-static int
-cmprange(const void *va, const void *vb)
-{
-	return ((const pdf_range*)va)->low - ((const pdf_range*)vb)->low;
-}
-
-struct pdf_cmap_s
-{
-	int refs;
-	char cmapname[32];
-
-	char usecmapname[32];
-	pdf_cmap *usecmap;
-
-	int wmode;
-
-	int ncspace;
-	struct {
-		int n;
-		unsigned lo;
-		unsigned hi;
-	} cspace[MAXCODESPACE];
-
-	int rlen, rcap;
-	pdf_range *ranges;
-
-	int tlen, tcap;
-	int *table;
-};
-
 /*
  * Allocate, destroy and simple parameters.
  */
@@ -68,133 +25,137 @@ struct pdf_cmap_s
 fz_error *
 pdf_newcmap(pdf_cmap **cmapp)
 {
-	pdf_cmap *cmap;
+    pdf_cmap *cmap;
 
-	cmap = *cmapp = fz_malloc(sizeof(pdf_cmap));
-	if (!cmap)
-		return fz_throw("outofmem: cmap struct");
+    cmap = *cmapp = fz_malloc(sizeof(pdf_cmap));
+    if (!cmap)
+	return fz_throw("outofmem: cmap struct");
 
-	cmap->refs = 1;
-	strcpy(cmap->cmapname, "");
+    cmap->refs = 1;
+    strcpy(cmap->cmapname, "");
 
-	strcpy(cmap->usecmapname, "");
-	cmap->usecmap = nil;
+    strcpy(cmap->usecmapname, "");
+    cmap->usecmap = nil;
 
-	cmap->wmode = 0;
+    cmap->wmode = 0;
 
-	cmap->ncspace = 0;
+    cmap->ncspace = 0;
 
-	cmap->rlen = 0;
-	cmap->rcap = 0;
-	cmap->ranges = nil;
+    cmap->rlen = 0;
+    cmap->rcap = 0;
+    cmap->ranges = nil;
 
-	cmap->tlen = 0;
-	cmap->tcap = 0;
-	cmap->table = nil;
+    cmap->tlen = 0;
+    cmap->tcap = 0;
+    cmap->table = nil;
 
-	return fz_okay;
+    return fz_okay;
 }
 
 pdf_cmap *
 pdf_keepcmap(pdf_cmap *cmap)
 {
+    if (cmap->refs >= 0)
 	cmap->refs ++;
-	return cmap;
+    return cmap;
 }
 
 void
 pdf_dropcmap(pdf_cmap *cmap)
 {
+    if (cmap->refs >= 0)
+    {
 	if (--cmap->refs == 0)
 	{
-		if (cmap->usecmap)
-			pdf_dropcmap(cmap->usecmap);
-		fz_free(cmap->ranges);
-		fz_free(cmap->table);
-		fz_free(cmap);
+	    if (cmap->usecmap)
+		pdf_dropcmap(cmap->usecmap);
+	    fz_free(cmap->ranges);
+	    fz_free(cmap->table);
+	    fz_free(cmap);
 	}
+    }
 }
 
 pdf_cmap *
 pdf_getusecmap(pdf_cmap *cmap)
 {
-	return cmap->usecmap;
+    return cmap->usecmap;
 }
 
 void
 pdf_setusecmap(pdf_cmap *cmap, pdf_cmap *usecmap)
 {
-	int i;
+    int i;
 
-	if (cmap->usecmap)
-		pdf_dropcmap(cmap->usecmap);
-	cmap->usecmap = pdf_keepcmap(usecmap);
+    if (cmap->usecmap)
+	pdf_dropcmap(cmap->usecmap);
+    cmap->usecmap = pdf_keepcmap(usecmap);
 
-	if (cmap->ncspace == 0)
-	{
-		cmap->ncspace = usecmap->ncspace;
-		for (i = 0; i < usecmap->ncspace; i++)
-			cmap->cspace[i] = usecmap->cspace[i];
-	}
+    if (cmap->ncspace == 0)
+    {
+	cmap->ncspace = usecmap->ncspace;
+	for (i = 0; i < usecmap->ncspace; i++)
+	    cmap->cspace[i] = usecmap->cspace[i];
+    }
 }
 
 int
 pdf_getwmode(pdf_cmap *cmap)
 {
-	return cmap->wmode;
+    return cmap->wmode;
 }
 
 void
 pdf_setwmode(pdf_cmap *cmap, int wmode)
 {
-	cmap->wmode = wmode;
+    cmap->wmode = wmode;
 }
 
 void
 pdf_debugcmap(pdf_cmap *cmap)
 {
-	int i, k, n;
+    int i, k, n;
 
-	printf("cmap $%p /%s {\n", (void *) cmap, cmap->cmapname);
+    printf("cmap $%p /%s {\n", (void *) cmap, cmap->cmapname);
 
-	if (cmap->usecmapname[0])
-		printf("  usecmap /%s\n", cmap->usecmapname);
-	if (cmap->usecmap)
-		printf("  usecmap $%p\n", (void *) cmap->usecmap);
+    if (cmap->usecmapname[0])
+	printf("  usecmap /%s\n", cmap->usecmapname);
+    if (cmap->usecmap)
+	printf("  usecmap $%p\n", (void *) cmap->usecmap);
 
-	printf("  wmode %d\n", cmap->wmode);
+    printf("  wmode %d\n", cmap->wmode);
 
-	printf("  codespaces {\n");
-	for (i = 0; i < cmap->ncspace; i++)
-	{
-		printf("    <%x> <%x>\n", cmap->cspace[i].lo, cmap->cspace[i].hi);
-	}
-	printf("  }\n");
+    printf("  codespaces {\n");
+    for (i = 0; i < cmap->ncspace; i++)
+    {
+	printf("    <%x> <%x>\n", cmap->cspace[i].lo, cmap->cspace[i].hi);
+    }
+    printf("  }\n");
 
-	printf("  ranges (%d,%d) {\n", cmap->rlen, cmap->tlen);
-	for (i = 0; i < cmap->rlen; i++)
+    printf("  ranges (%d,%d) {\n", cmap->rlen, cmap->tlen);
+    for (i = 0; i < cmap->rlen; i++)
+    {
+	pdf_range *r = &cmap->ranges[i];
+	printf("    <%04x> <%04x> ", r->low, r->high);
+	if (r->flag == PDF_CMAP_TABLE)
 	{
-		pdf_range *r = &cmap->ranges[i];
-		printf("    <%04x> <%04x> ", r->low, r->high);
-		if (r->flag == TABLE)
-		{
-			printf("[ ");
-			for (k = 0; k < r->high - r->low + 1; k++)
-				printf("%d ", cmap->table[r->offset + k]);
-			printf("]\n");
-		}
-		else if (r->flag == MULTI)
-		{
-			printf("< ");
-			n = cmap->table[r->offset];
-			for (k = 0; k < n; k++)
-				printf("%04x ", cmap->table[r->offset + 1 + k]);
-			printf(">\n");
-		}
-		else
-			printf("%d\n", r->offset);
+	    printf("[ ");
+	    for (k = 0; k < r->high - r->low + 1; k++)
+		printf("%d ", cmap->table[r->offset + k]);
+	    printf("]\n");
 	}
-	printf("  }\n}\n");
+	else if (r->flag == PDF_CMAP_MULTI)
+	{
+	    printf("< ");
+	    n = cmap->table[r->offset];
+	    for (k = 0; k < n; k++)
+		printf("%04x ", cmap->table[r->offset + 1 + k]);
+	    printf(">\n");
+	}
+	else
+	    printf("%d\n", r->offset);
+    }
+    printf("  }\n}\n");
 }
 
 /*
@@ -205,16 +166,16 @@ pdf_debugcmap(pdf_cmap *cmap)
 fz_error *
 pdf_addcodespace(pdf_cmap *cmap, unsigned lo, unsigned hi, int n)
 {
-	if (cmap->ncspace + 1 == MAXCODESPACE)
-		return fz_throw("assert: too many code space ranges");
+    if (cmap->ncspace + 1 == nelem(cmap->cspace))
+	return fz_throw("assert: too many code space ranges");
 
-	cmap->cspace[cmap->ncspace].n = n;
-	cmap->cspace[cmap->ncspace].lo = lo;
-	cmap->cspace[cmap->ncspace].hi = hi;
+    cmap->cspace[cmap->ncspace].n = n;
+    cmap->cspace[cmap->ncspace].lo = lo;
+    cmap->cspace[cmap->ncspace].hi = hi;
 
-	cmap->ncspace ++;
+    cmap->ncspace ++;
 
-	return fz_okay;
+    return fz_okay;
 }
 
 /*
@@ -223,19 +184,19 @@ pdf_addcodespace(pdf_cmap *cmap, unsigned lo, unsigned hi, int n)
 static fz_error *
 addtable(pdf_cmap *cmap, int value)
 {
-	if (cmap->tlen + 1 > cmap->tcap)
-	{
-		int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2;
-		int *newtable = fz_realloc(cmap->table, newcap * sizeof(int));
-		if (!newtable)
-			return fz_throw("outofmem: cmap table");
-		cmap->tcap = newcap;
-		cmap->table = newtable;
-	}
+    if (cmap->tlen + 1 > cmap->tcap)
+    {
+	int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2;
+	int *newtable = fz_realloc(cmap->table, newcap * sizeof(int));
+	if (!newtable)
+	    return fz_throw("outofmem: cmap table");
+	cmap->tcap = newcap;
+	cmap->table = newtable;
+    }
 
-	cmap->table[cmap->tlen++] = value;
+    cmap->table[cmap->tlen++] = value;
 
-	return fz_okay;
+    return fz_okay;
 }
 
 /*
@@ -244,24 +205,24 @@ addtable(pdf_cmap *cmap, int value)
 static fz_error *
 addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 {
-	if (cmap->rlen + 1 > cmap->rcap)
-	{
-		pdf_range *newranges;
-		int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2;
-		newranges = fz_realloc(cmap->ranges, newcap * sizeof(pdf_range));
-		if (!newranges)
-			return fz_throw("outofmem: cmap ranges");
-		cmap->rcap = newcap;
-		cmap->ranges = newranges;
-	}
+    if (cmap->rlen + 1 > cmap->rcap)
+    {
+	pdf_range *newranges;
+	int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2;
+	newranges = fz_realloc(cmap->ranges, newcap * sizeof(pdf_range));
+	if (!newranges)
+	    return fz_throw("outofmem: cmap ranges");
+	cmap->rcap = newcap;
+	cmap->ranges = newranges;
+    }
 
-	cmap->ranges[cmap->rlen].low = low;
-	cmap->ranges[cmap->rlen].high = high;
-	cmap->ranges[cmap->rlen].flag = flag;
-	cmap->ranges[cmap->rlen].offset = offset;
-	cmap->rlen ++;
+    cmap->ranges[cmap->rlen].low = low;
+    cmap->ranges[cmap->rlen].high = high;
+    cmap->ranges[cmap->rlen].flag = flag;
+    cmap->ranges[cmap->rlen].offset = offset;
+    cmap->rlen ++;
 
-	return fz_okay;
+    return fz_okay;
 }
 
 /*
@@ -270,26 +231,26 @@ addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 fz_error *
 pdf_maprangetotable(pdf_cmap *cmap, int low, int *table, int len)
 {
-	fz_error *error;
-	int offset;
-	int high;
-	int i;
-
-	high = low + len;
-	offset = cmap->tlen;
+    fz_error *error;
+    int offset;
+    int high;
+    int i;
 
-	for (i = 0; i < len; i++)
-	{
-		error = addtable(cmap, table[i]);
-		if (error)
-			return fz_rethrow(error, "cannot add range-to-table index");
-	}
+    high = low + len;
+    offset = cmap->tlen;
 
-	error = addrange(cmap, low, high, TABLE, offset);
+    for (i = 0; i < len; i++)
+    {
+	error = addtable(cmap, table[i]);
 	if (error)
-		return fz_rethrow(error, "cannot add range-to-table range");
+	    return fz_rethrow(error, "cannot add range-to-table index");
+    }
 
-	return fz_okay;
+    error = addrange(cmap, low, high, PDF_CMAP_TABLE, offset);
+    if (error)
+	return fz_rethrow(error, "cannot add range-to-table range");
+
+    return fz_okay;
 }
 
 /*
@@ -298,11 +259,11 @@ pdf_maprangetotable(pdf_cmap *cmap, int low, int *table, int len)
 fz_error *
 pdf_maprangetorange(pdf_cmap *cmap, int low, int high, int offset)
 {
-	fz_error *error;
-	error = addrange(cmap, low, high, high - low == 0 ? SINGLE : RANGE, offset);
-	if (error)
-		return fz_rethrow(error, "cannot add range-to-range mapping");
-	return fz_okay;
+    fz_error *error;
+    error = addrange(cmap, low, high, high - low == 0 ? PDF_CMAP_SINGLE : PDF_CMAP_RANGE, offset);
+    if (error)
+	return fz_rethrow(error, "cannot add range-to-range mapping");
+    return fz_okay;
 }
 
 /*
@@ -311,36 +272,36 @@ pdf_maprangetorange(pdf_cmap *cmap, int low, int high, int offset)
 fz_error *
 pdf_maponetomany(pdf_cmap *cmap, int low, int *values, int len)
 {
-	fz_error *error;
-	int offset;
-	int i;
-
-	if (len == 1)
-	{
-		error = addrange(cmap, low, low, SINGLE, values[0]);
-		if (error)
-			return fz_rethrow(error, "cannot add one-to-one mapping");
-		return fz_okay;
-	}
-
-	offset = cmap->tlen;
+    fz_error *error;
+    int offset;
+    int i;
 
-	error = addtable(cmap, len);
+    if (len == 1)
+    {
+	error = addrange(cmap, low, low, PDF_CMAP_SINGLE, values[0]);
 	if (error)
-		return fz_rethrow(error, "cannot add one-to-many table length");
+	    return fz_rethrow(error, "cannot add one-to-one mapping");
+	return fz_okay;
+    }
 
-	for (i = 0; i < len; i++)
-	{
-		error = addtable(cmap, values[i]);
-		if (error)
-			return fz_rethrow(error, "cannot add one-to-many table index");
-	}
+    offset = cmap->tlen;
+
+    error = addtable(cmap, len);
+    if (error)
+	return fz_rethrow(error, "cannot add one-to-many table length");
 
-	error = addrange(cmap, low, low, MULTI, offset);
+    for (i = 0; i < len; i++)
+    {
+	error = addtable(cmap, values[i]);
 	if (error)
-		return fz_rethrow(error, "cannot add one-to-many mapping");
+	    return fz_rethrow(error, "cannot add one-to-many table index");
+    }
 
-	return fz_okay;
+    error = addrange(cmap, low, low, PDF_CMAP_MULTI, offset);
+    if (error)
+	return fz_rethrow(error, "cannot add one-to-many mapping");
+
+    return fz_okay;
 }
 
 /*
@@ -348,130 +309,137 @@ pdf_maponetomany(pdf_cmap *cmap, int low, int *values, int len)
  * Merge contiguous input ranges to range-to-range if the output is contiguous.
  * Merge contiguous input ranges to range-to-table if the output is random.
  */
+
+static int cmprange(const void *va, const void *vb)
+{
+    return ((const pdf_range*)va)->low - ((const pdf_range*)vb)->low;
+}
+
 fz_error *
 pdf_sortcmap(pdf_cmap *cmap)
 {
-	fz_error *error;
-	pdf_range *newranges;
-	int *newtable;
-	pdf_range *a;			/* last written range on output */
-	pdf_range *b;			/* current range examined on input */
+    fz_error *error;
+    pdf_range *newranges;
+    int *newtable;
+    pdf_range *a;			/* last written range on output */
+    pdf_range *b;			/* current range examined on input */
+
+    if (cmap->rlen == 0)
+	return fz_okay;
 
-	if (cmap->rlen == 0)
-		return fz_okay;
+    qsort(cmap->ranges, cmap->rlen, sizeof(pdf_range), cmprange);
 
-	qsort(cmap->ranges, cmap->rlen, sizeof(pdf_range), cmprange);
+    a = cmap->ranges;
+    b = cmap->ranges + 1;
 
-	a = cmap->ranges;
-	b = cmap->ranges + 1;
+    while (b < cmap->ranges + cmap->rlen)
+    {
+	/* ignore one-to-many mappings */
+	if (b->flag == PDF_CMAP_MULTI)
+	{
+	    *(++a) = *b;
+	}
 
-	while (b < cmap->ranges + cmap->rlen)
+	/* input contiguous */
+	else if (a->high + 1 == b->low)
 	{
-		/* ignore one-to-many mappings */
-		if (b->flag == MULTI)
+	    /* output contiguous */
+	    if (a->high - a->low + a->offset + 1 == b->offset)
+	    {
+		/* SR -> R and SS -> R and RR -> R and RS -> R */
+		if (a->flag == PDF_CMAP_SINGLE || a->flag == PDF_CMAP_RANGE)
+		{
+		    a->flag = PDF_CMAP_RANGE;
+		    a->high = b->high;
+		}
+
+		/* LS -> L */
+		else if (a->flag == PDF_CMAP_TABLE && b->flag == PDF_CMAP_SINGLE)
 		{
-			*(++a) = *b;
+		    a->high = b->high;
+		    error = addtable(cmap, b->offset);
+		    if (error)
+			return fz_rethrow(error, "cannot convert LS -> L");
 		}
 
-		/* input contiguous */
-		else if (a->high + 1 == b->low)
+		/* LR -> LR */
+		else if (a->flag == PDF_CMAP_TABLE && b->flag == PDF_CMAP_RANGE)
 		{
-			/* output contiguous */
-			if (a->high - a->low + a->offset + 1 == b->offset)
-			{
-				/* SR -> R and SS -> R and RR -> R and RS -> R */
-				if (a->flag == SINGLE || a->flag == RANGE)
-				{
-					a->flag = RANGE;
-					a->high = b->high;
-				}
-
-				/* LS -> L */
-				else if (a->flag == TABLE && b->flag == SINGLE)
-				{
-					a->high = b->high;
-					error = addtable(cmap, b->offset);
-					if (error)
-						return fz_rethrow(error, "cannot convert LS -> L");
-				}
-
-				/* LR -> LR */
-				else if (a->flag == TABLE && b->flag == RANGE)
-				{
-					*(++a) = *b;
-				}
-
-				/* XX -> XX */
-				else
-				{
-					*(++a) = *b;
-				}
-			}
-
-			/* output separated */
-			else
-			{
-				/* SS -> L */
-				if (a->flag == SINGLE && b->flag == SINGLE)
-				{
-					a->flag = TABLE;
-					a->high = b->high;
-
-					error = addtable(cmap, a->offset);
-					if (error)
-						return fz_rethrow(error, "cannot convert SS -> L");
-
-					error = addtable(cmap, b->offset);
-					if (error)
-						return fz_rethrow(error, "cannot convert SS -> L");
-
-					a->offset = cmap->tlen - 2;
-				}
-
-				/* LS -> L */
-				else if (a->flag == TABLE && b->flag == SINGLE)
-				{
-					a->high = b->high;
-					error = addtable(cmap, b->offset);
-					if (error)
-						return fz_rethrow(error, "cannot convert LS -> L");
-				}
-
-				/* XX -> XX */
-				else
-				{
-					*(++a) = *b;
-				}
-			}
+		    *(++a) = *b;
 		}
 
-		/* input separated: XX -> XX */
+		/* XX -> XX */
 		else
 		{
-			*(++a) = *b;
+		    *(++a) = *b;
 		}
+	    }
 
-		b ++;
-	}
+	    /* output separated */
+	    else
+	    {
+		/* SS -> L */
+		if (a->flag == PDF_CMAP_SINGLE && b->flag == PDF_CMAP_SINGLE)
+		{
+		    a->flag = PDF_CMAP_TABLE;
+		    a->high = b->high;
 
-	cmap->rlen = a - cmap->ranges + 1;
+		    error = addtable(cmap, a->offset);
+		    if (error)
+			return fz_rethrow(error, "cannot convert SS -> L");
 
-	newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(pdf_range));
-	if (!newranges)
-		return fz_throw("outofmem: cmap ranges");
-	cmap->rcap = cmap->rlen;
-	cmap->ranges = newranges;
+		    error = addtable(cmap, b->offset);
+		    if (error)
+			return fz_rethrow(error, "cannot convert SS -> L");
 
-	if (cmap->tlen)
+		    a->offset = cmap->tlen - 2;
+		}
+
+		/* LS -> L */
+		else if (a->flag == PDF_CMAP_TABLE && b->flag == PDF_CMAP_SINGLE)
+		{
+		    a->high = b->high;
+		    error = addtable(cmap, b->offset);
+		    if (error)
+			return fz_rethrow(error, "cannot convert LS -> L");
+		}
+
+		/* XX -> XX */
+		else
+		{
+		    *(++a) = *b;
+		}
+	    }
+	}
+
+	/* input separated: XX -> XX */
+	else
 	{
-		newtable = fz_realloc(cmap->table, cmap->tlen * sizeof(int));
-		if (!newtable)
-			return fz_throw("outofmem: cmap table");
-		cmap->tcap = cmap->tlen;
-		cmap->table = newtable;
+	    *(++a) = *b;
 	}
 
-	return fz_okay;
+	b ++;
+    }
+
+    cmap->rlen = a - cmap->ranges + 1;
+
+    newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(pdf_range));
+    if (!newranges)
+	return fz_throw("outofmem: cmap ranges");
+    cmap->rcap = cmap->rlen;
+    if (cmap->refs >= 0)
+	cmap->ranges = newranges;
+
+    if (cmap->tlen)
+    {
+	newtable = fz_realloc(cmap->table, cmap->tlen * sizeof(int));
+	if (!newtable)
+	    return fz_throw("outofmem: cmap table");
+	cmap->tcap = cmap->tlen;
+	cmap->table = newtable;
+    }
+
+    return fz_okay;
 }
 
 /*
@@ -480,32 +448,32 @@ pdf_sortcmap(pdf_cmap *cmap)
 int
 pdf_lookupcmap(pdf_cmap *cmap, int cpt)
 {
-	int l = 0;
-	int r = cmap->rlen - 1;
-	int m;
+    int l = 0;
+    int r = cmap->rlen - 1;
+    int m;
 
-	while (l <= r)
+    while (l <= r)
+    {
+	m = (l + r) >> 1;
+	if (cpt < cmap->ranges[m].low)
+	    r = m - 1;
+	else if (cpt > cmap->ranges[m].high)
+	    l = m + 1;
+	else
 	{
-		m = (l + r) >> 1;
-		if (cpt < cmap->ranges[m].low)
-			r = m - 1;
-		else if (cpt > cmap->ranges[m].high)
-			l = m + 1;
-		else
-		{
-			int i = cpt - cmap->ranges[m].low + cmap->ranges[m].offset;
-			if (cmap->ranges[m].flag == TABLE)
-				return cmap->table[i];
-			if (cmap->ranges[m].flag == MULTI)
-				return -1;
-			return i;
-		}
+	    int i = cpt - cmap->ranges[m].low + cmap->ranges[m].offset;
+	    if (cmap->ranges[m].flag == PDF_CMAP_TABLE)
+		return cmap->table[i];
+	    if (cmap->ranges[m].flag == PDF_CMAP_MULTI)
+		return -1;
+	    return i;
 	}
+    }
 
-	if (cmap->usecmap)
-		return pdf_lookupcmap(cmap->usecmap, cpt);
+    if (cmap->usecmap)
+	return pdf_lookupcmap(cmap->usecmap, cpt);
 
-	return -1;
+    return -1;
 }
 
 /*
@@ -515,7 +483,7 @@ pdf_lookupcmap(pdf_cmap *cmap, int cpt)
 unsigned char *
 pdf_decodecmap(pdf_cmap *cmap, unsigned char *buf, int *cpt)
 {
-    int i, k, n, c;
+    int k, n, c;
 
     c = 0;
     for (n = 0; n < 4; n++)
@@ -538,699 +506,3 @@ pdf_decodecmap(pdf_cmap *cmap, unsigned char *buf, int *cpt)
     return buf + 1;
 }
 
-/*
- * CMap parser
- */
-
-enum
-{
-	TUSECMAP = PDF_NTOKENS,
-	TBEGINCODESPACERANGE,
-	TENDCODESPACERANGE,
-	TBEGINBFCHAR,
-	TENDBFCHAR,
-	TBEGINBFRANGE,
-	TENDBFRANGE,
-	TBEGINCIDCHAR,
-	TENDCIDCHAR,
-	TBEGINCIDRANGE,
-	TENDCIDRANGE
-};
-
-static pdf_token_e tokenfromkeyword(char *key)
-{
-	if (!strcmp(key, "usecmap")) return TUSECMAP;
-	if (!strcmp(key, "begincodespacerange")) return TBEGINCODESPACERANGE;
-	if (!strcmp(key, "endcodespacerange")) return TENDCODESPACERANGE;
-	if (!strcmp(key, "beginbfchar")) return TBEGINBFCHAR;
-	if (!strcmp(key, "endbfchar")) return TENDBFCHAR;
-	if (!strcmp(key, "beginbfrange")) return TBEGINBFRANGE;
-	if (!strcmp(key, "endbfrange")) return TENDBFRANGE;
-	if (!strcmp(key, "begincidchar")) return TBEGINCIDCHAR;
-	if (!strcmp(key, "endcidchar")) return TENDCIDCHAR;
-	if (!strcmp(key, "begincidrange")) return TBEGINCIDRANGE;
-	if (!strcmp(key, "endcidrange")) return TENDCIDRANGE;
-	return PDF_TKEYWORD;
-}
-
-static int codefromstring(char *buf, int len)
-{
-	int a = 0;
-	while (len--)
-		a = (a << 8) | *(unsigned char *)buf++;
-	return a;
-}
-
-static fz_error *lexcmap(pdf_token_e *tok, fz_stream *file, char *buf, int n, int *sl)
-{
-	fz_error *error;
-
-	error = pdf_lex(tok, file, buf, n, sl);
-	if (error)
-		return fz_rethrow(error, "cannot parse cmap token");
-
-	if (*tok == PDF_TKEYWORD)
-		*tok = tokenfromkeyword(buf);
-
-	return fz_okay;
-}
-
-static fz_error *parsecmapname(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-
-	error = lexcmap(&tok, file, buf, sizeof buf, &len);
-	if (error)
-		return fz_rethrow(error, "syntaxerror in cmap");
-
-	if (tok == PDF_TNAME)
-	{
-		strlcpy(cmap->cmapname, buf, sizeof(cmap->cmapname));
-		return fz_okay;
-	}
-
-	return fz_throw("expected name");
-}
-
-static fz_error *parsewmode(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-
-	error = lexcmap(&tok, file, buf, sizeof buf, &len);
-	if (error)
-		return fz_rethrow(error, "syntaxerror in cmap");
-
-	if (tok == PDF_TINT)
-	{
-		pdf_setwmode(cmap, atoi(buf));
-		return fz_okay;
-	}
-
-	return fz_throw("expected integer");
-}
-
-static fz_error *parsecodespacerange(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int lo, hi;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == TENDCODESPACERANGE)
-			return fz_okay;
-
-		else if (tok == PDF_TSTRING)
-		{
-			lo = codefromstring(buf, len);
-			error = lexcmap(&tok, file, buf, sizeof buf, &len);
-			if (error)
-				return fz_rethrow(error, "syntaxerror in cmap");
-			if (tok == PDF_TSTRING)
-			{
-				hi = codefromstring(buf, len);
-				error = pdf_addcodespace(cmap, lo, hi, len);
-				if (error)
-					return fz_rethrow(error, "cannot add code space");
-			}
-			else break;
-		}
-
-		else break;
-	}
-
-	return fz_throw("expected string or endcodespacerange");
-}
-
-static fz_error *parsecidrange(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int lo, hi, dst;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == TENDCIDRANGE)
-			return fz_okay;
-
-		else if (tok != PDF_TSTRING)
-			return fz_throw("expected string or endcidrange");
-
-		lo = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-		if (tok != PDF_TSTRING)
-			return fz_throw("expected string");
-
-		hi = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-		if (tok != PDF_TINT)
-			return fz_throw("expected integer");
-
-		dst = atoi(buf);
-
-		error = pdf_maprangetorange(cmap, lo, hi, dst);
-		if (error)
-			return fz_rethrow(error, "cannot map cidrange");
-	}
-}
-
-static fz_error *parsecidchar(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int src, dst;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == TENDCIDCHAR)
-			return fz_okay;
-
-		else if (tok != PDF_TSTRING)
-			return fz_throw("expected string or endcidchar");
-
-		src = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-		if (tok != PDF_TINT)
-			return fz_throw("expected integer");
-
-		dst = atoi(buf);
-
-		error = pdf_maprangetorange(cmap, src, src, dst);
-		if (error)
-			return fz_rethrow(error, "cannot map cidchar");
-	}
-}
-
-static fz_error *parsebfrangearray(pdf_cmap *cmap, fz_stream *file, int lo, int hi)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int dst[256];
-	int i;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == PDF_TCARRAY)
-			return fz_okay;
-
-		/* Note: does not handle [ /Name /Name ... ] */
-		else if (tok != PDF_TSTRING)
-			return fz_throw("expected string or ]");
-
-		if (len / 2)
-		{
-			for (i = 0; i < len / 2; i++)
-				dst[i] = codefromstring(buf + i * 2, 2);
-
-			error = pdf_maponetomany(cmap, lo, dst, len / 2);
-			if (error)
-				return fz_rethrow(error, "cannot map bfrange array");
-		}
-
-		lo ++;
-	}
-}
-
-static fz_error *parsebfrange(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int lo, hi, dst;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == TENDBFRANGE)
-			return fz_okay;
-
-		else if (tok != PDF_TSTRING)
-			return fz_throw("expected string or endbfrange");
-
-		lo = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-		if (tok != PDF_TSTRING)
-			return fz_throw("expected string");
-
-		hi = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == PDF_TSTRING)
-		{
-			if (len == 2)
-			{
-				dst = codefromstring(buf, len);
-				error = pdf_maprangetorange(cmap, lo, hi, dst);
-				if (error)
-					return fz_rethrow(error, "cannot map bfrange");
-			}
-			else
-			{
-				int dststr[256];
-				int i;
-
-				if (len / 2)
-				{
-					for (i = 0; i < len / 2; i++)
-						dststr[i] = codefromstring(buf + i * 2, 2);
-
-					while (lo <= hi)
-					{
-						dststr[i-1] ++;
-						error = pdf_maponetomany(cmap, lo, dststr, i);
-						if (error)
-							return fz_rethrow(error, "cannot map bfrange");
-						lo ++;
-					}
-				}
-			}
-		}
-
-		else if (tok == PDF_TOARRAY)
-		{
-			error = parsebfrangearray(cmap, file, lo, hi);
-			if (error)
-				return fz_rethrow(error, "cannot map bfrange");
-		}
-
-		else
-		{
-			return fz_throw("expected string or array or endbfrange");
-		}
-	}
-}
-
-static fz_error *parsebfchar(pdf_cmap *cmap, fz_stream *file)
-{
-	fz_error *error;
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-	int dst[256];
-	int src;
-	int i;
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-
-		if (tok == TENDBFCHAR)
-			return fz_okay;
-
-		else if (tok != PDF_TSTRING)
-			return fz_throw("expected string or endbfchar");
-
-		src = codefromstring(buf, len);
-
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
-		/* Note: does not handle /dstName */
-		if (tok != PDF_TSTRING)
-			return fz_throw("expected string");
-
-		if (len / 2)
-		{
-			for (i = 0; i < len / 2; i++)
-				dst[i] = codefromstring(buf + i * 2, 2);
-
-			error = pdf_maponetomany(cmap, src, dst, i);
-			if (error)
-				return fz_rethrow(error, "cannot map bfchar");
-		}
-	}
-}
-
-fz_error *
-pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file)
-{
-	fz_error *error;
-	pdf_cmap *cmap;
-	char key[64];
-	char buf[256];
-	pdf_token_e tok;
-	int len;
-
-	error = pdf_newcmap(&cmap);
-	if (error)
-		return fz_rethrow(error, "cannot create cmap");
-
-	strcpy(key, ".notdef");
-
-	while (1)
-	{
-		error = lexcmap(&tok, file, buf, sizeof buf, &len);
-		if (error)
-		{
-			error = fz_rethrow(error, "syntaxerror in cmap");
-			goto cleanup;
-		}
-
-		if (tok == PDF_TEOF)
-			break;
-
-		else if (tok == PDF_TNAME)
-		{
-			if (!strcmp(buf, "CMapName"))
-			{
-				error = parsecmapname(cmap, file);
-				if (error)
-				{
-					error = fz_rethrow(error, "syntaxerror in cmap after /CMapName");
-					goto cleanup;
-				}
-			}
-			else if (!strcmp(buf, "WMode"))
-			{
-				error = parsewmode(cmap, file);
-				if (error)
-				{
-					error = fz_rethrow(error, "syntaxerror in cmap after /WMode");
-					goto cleanup;
-				}
-			}
-			else
-				strlcpy(key, buf, sizeof key);
-		}
-
-		else if (tok == TUSECMAP)
-		{
-			strlcpy(cmap->usecmapname, key, sizeof(cmap->usecmapname));
-		}
-
-		else if (tok == TBEGINCODESPACERANGE)
-		{
-			error = parsecodespacerange(cmap, file);
-			if (error)
-			{
-				error = fz_rethrow(error, "syntaxerror in cmap codespacerange");
-				goto cleanup;
-			}
-		}
-
-		else if (tok == TBEGINBFCHAR)
-		{
-			error = parsebfchar(cmap, file);
-			if (error)
-			{
-				error = fz_rethrow(error, "syntaxerror in cmap bfchar");
-				goto cleanup;
-			}
-		}
-
-		else if (tok == TBEGINCIDCHAR)
-		{
-			error = parsecidchar(cmap, file);
-			if (error)
-			{
-				error = fz_rethrow(error, "syntaxerror in cmap cidchar");
-				goto cleanup;
-			}
-		}
-
-		else if (tok == TBEGINBFRANGE)
-		{
-			error = parsebfrange(cmap, file);
-			if (error)
-			{
-				error = fz_rethrow(error, "syntaxerror in cmap bfrange");
-				goto cleanup;
-			}
-		}
-
-		else if (tok == TBEGINCIDRANGE)
-		{
-			error = parsecidrange(cmap, file);
-			if (error)
-			{
-				error = fz_rethrow(error, "syntaxerror in cmap cidrange");
-				goto cleanup;
-			}
-		}
-
-		/* ignore everything else */
-	}
-
-	error = pdf_sortcmap(cmap);
-	if (error)
-	{
-		error = fz_rethrow(error, "cannot sort cmap");
-		goto cleanup;
-	}
-
-	*cmapp = cmap;
-	return fz_okay;
-
-cleanup:
-	pdf_dropcmap(cmap);
-	return error; /* already rethrown */
-}
-
-/*
- * Load CMap stream in PDF file
- */
-fz_error *
-pdf_loadembeddedcmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmref)
-{
-	fz_error *error = fz_okay;
-	fz_obj *stmobj = stmref;
-	fz_stream *file;
-	pdf_cmap *cmap = nil;
-	pdf_cmap *usecmap;
-	fz_obj *wmode;
-	fz_obj *obj;
-
-	if ((*cmapp = pdf_finditem(xref->store, PDF_KCMAP, stmref)))
-	{
-		pdf_keepcmap(*cmapp);
-		return fz_okay;
-	}
-
-	pdf_logfont("load embedded cmap (%d %d R) {\n", fz_tonum(stmref), fz_togen(stmref));
-
-	error = pdf_resolve(&stmobj, xref);
-	if (error)
-		return fz_rethrow(error, "cannot resolve cmap object");
-
-	error = pdf_openstream(&file, xref, fz_tonum(stmref), fz_togen(stmref));
-	if (error)
-	{
-		error = fz_rethrow(error, "cannot open cmap stream");
-		goto cleanup;
-	}
-
-	error = pdf_parsecmap(&cmap, file);
-	if (error)
-	{
-		error = fz_rethrow(error, "cannot parse cmap stream");
-		goto cleanup;
-	}
-
-	fz_dropstream(file);
-
-	wmode = fz_dictgets(stmobj, "WMode");
-	if (fz_isint(wmode))
-	{
-		pdf_logfont("wmode %d\n", wmode);
-		pdf_setwmode(cmap, fz_toint(wmode));
-	}
-
-	obj = fz_dictgets(stmobj, "UseCMap");
-	if (fz_isname(obj))
-	{
-		pdf_logfont("usecmap /%s\n", fz_toname(obj));
-		error = pdf_loadsystemcmap(&usecmap, fz_toname(obj));
-		if (error)
-		{
-			error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_toname(obj));
-			goto cleanup;
-		}
-		pdf_setusecmap(cmap, usecmap);
-		pdf_dropcmap(usecmap);
-	}
-	else if (fz_isindirect(obj))
-	{
-		pdf_logfont("usecmap (%d %d R)\n", fz_tonum(obj), fz_togen(obj));
-		error = pdf_loadembeddedcmap(&usecmap, xref, obj);
-		if (error)
-		{
-			error = fz_rethrow(error, "cannot load embedded usecmap");
-			goto cleanup;
-		}
-		pdf_setusecmap(cmap, usecmap);
-		pdf_dropcmap(usecmap);
-	}
-
-	pdf_logfont("}\n");
-
-	error = pdf_storeitem(xref->store, PDF_KCMAP, stmref, cmap);
-	if (error)
-	{
-		error = fz_rethrow(error, "cannot store cmap resource");
-		goto cleanup;
-	}
-
-	fz_dropobj(stmobj);
-
-	*cmapp = cmap;
-	return fz_okay;
-
-cleanup:
-	if (cmap)
-		pdf_dropcmap(cmap);
-	fz_dropobj(stmobj);
-	return error; /* already rethrown */
-}
-
-/*
- * Load predefined CMap from system. We keep these files
- * embedded in the executable, and parse them when needed,
- * and cache the parsed copy for later reuse.
- */
-fz_error *
-pdf_loadsystemcmap(pdf_cmap **cmapp, char *cmapname)
-{
-    fz_error *error;
-    fz_stream *file;
-    pdf_cmap *usecmap;
-    pdf_cmap *cmap;
-    int i;
-
-    for (i = 0; pdf_cmaptable[i].name; i++)
-	if (!strcmp(cmapname, pdf_cmaptable[i].name))
-	    goto found;
-
-    return fz_throw("no builtin cmap file: %s", cmapname);
-
-found:
-    if (pdf_cmaptable[i].cmap)
-    {
-	pdf_logfont("reuse system cmap %s\n", cmapname);
-	pdf_keepcmap(pdf_cmaptable[i].cmap);
-	*cmapp = pdf_cmaptable[i].cmap;
-	return fz_okay;
-    }
-
-    pdf_logfont("load system cmap %s\n", cmapname);
-
-    error = fz_openrmemory(&file, pdf_cmaptable[i].buf, *pdf_cmaptable[i].len);
-    if (error)
-	return fz_rethrow(error, "cannot create stream to read cmap from memory");
-
-    error = pdf_parsecmap(&pdf_cmaptable[i].cmap, file);
-    if (error)
-    {
-	fz_dropstream(file);
-	return fz_rethrow(error, "cannot parse system cmap '%s'", cmapname);
-    }
-
-    fz_dropstream(file);
-
-    /* Keep an extra reference, since we have it cached */
-    pdf_keepcmap(pdf_cmaptable[i].cmap);
-
-    if (pdf_cmaptable[i].cmap->usecmapname[0])
-    {
-	pdf_logfont("usecmap %s\n", pdf_cmaptable[i].cmap->usecmapname);
-	error = pdf_loadsystemcmap(&usecmap, pdf_cmaptable[i].cmap->usecmapname);
-	if (error)
-	    return fz_rethrow(error, "cannot load usecmap '%s'", pdf_cmaptable[i].cmap->usecmapname);
-	pdf_setusecmap(pdf_cmaptable[i].cmap, usecmap);
-	pdf_dropcmap(usecmap);
-    }
-
-    pdf_keepcmap(pdf_cmaptable[i].cmap);
-    *cmapp = pdf_cmaptable[i].cmap;
-    return fz_okay;
-}
-
-/*
- * Create an Identity-* CMap (for both 1 and 2-byte encodings)
- */
-fz_error *
-pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes)
-{
-	fz_error *error;
-	pdf_cmap *cmap;
-
-	error = pdf_newcmap(&cmap);
-	if (error)
-		return fz_rethrow(error, "cannot create cmap");
-
-	sprintf(cmap->cmapname, "Identity-%c", wmode ? 'V' : 'H');
-
-	error = pdf_addcodespace(cmap, 0x0000, 0xffff, bytes);
-	if (error) {
-		pdf_dropcmap(cmap);
-		return fz_rethrow(error, "cannot add code space");
-	}
-
-	error = pdf_maprangetorange(cmap, 0x0000, 0xffff, 0);
-	if (error) {
-		pdf_dropcmap(cmap);
-		return fz_rethrow(error, "cannot map <0000> to <ffff>");
-	}
-
-	error = pdf_sortcmap(cmap);
-	if (error) {
-		pdf_dropcmap(cmap);
-		return fz_rethrow(error, "cannot sort cmap");
-	}
-
-	pdf_setwmode(cmap, wmode);
-
-	*cmapp = cmap;
-	return fz_okay;
-}
-
diff --git a/mupdf/pdf_cmap_load.c b/mupdf/pdf_cmap_load.c
new file mode 100644
index 00000000..f0eb12ef
--- /dev/null
+++ b/mupdf/pdf_cmap_load.c
@@ -0,0 +1,171 @@
+#include "fitz.h"
+#include "mupdf.h"
+
+/*
+ * Load CMap stream in PDF file
+ */
+fz_error *
+pdf_loadembeddedcmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmref)
+{
+    fz_error *error = fz_okay;
+    fz_obj *stmobj = stmref;
+    fz_stream *file;
+    pdf_cmap *cmap = nil;
+    pdf_cmap *usecmap;
+    fz_obj *wmode;
+    fz_obj *obj;
+
+    if ((*cmapp = pdf_finditem(xref->store, PDF_KCMAP, stmref)))
+    {
+	pdf_keepcmap(*cmapp);
+	return fz_okay;
+    }
+
+    pdf_logfont("load embedded cmap (%d %d R) {\n", fz_tonum(stmref), fz_togen(stmref));
+
+    error = pdf_resolve(&stmobj, xref);
+    if (error)
+	return fz_rethrow(error, "cannot resolve cmap object");
+
+    error = pdf_openstream(&file, xref, fz_tonum(stmref), fz_togen(stmref));
+    if (error)
+    {
+	error = fz_rethrow(error, "cannot open cmap stream");
+	goto cleanup;
+    }
+
+    error = pdf_parsecmap(&cmap, file);
+    if (error)
+    {
+	error = fz_rethrow(error, "cannot parse cmap stream");
+	goto cleanup;
+    }
+
+    fz_dropstream(file);
+
+    wmode = fz_dictgets(stmobj, "WMode");
+    if (fz_isint(wmode))
+    {
+	pdf_logfont("wmode %d\n", wmode);
+	pdf_setwmode(cmap, fz_toint(wmode));
+    }
+
+    obj = fz_dictgets(stmobj, "UseCMap");
+    if (fz_isname(obj))
+    {
+	pdf_logfont("usecmap /%s\n", fz_toname(obj));
+	error = pdf_loadsystemcmap(&usecmap, fz_toname(obj));
+	if (error)
+	{
+	    error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_toname(obj));
+	    goto cleanup;
+	}
+	pdf_setusecmap(cmap, usecmap);
+	pdf_dropcmap(usecmap);
+    }
+    else if (fz_isindirect(obj))
+    {
+	pdf_logfont("usecmap (%d %d R)\n", fz_tonum(obj), fz_togen(obj));
+	error = pdf_loadembeddedcmap(&usecmap, xref, obj);
+	if (error)
+	{
+	    error = fz_rethrow(error, "cannot load embedded usecmap");
+	    goto cleanup;
+	}
+	pdf_setusecmap(cmap, usecmap);
+	pdf_dropcmap(usecmap);
+    }
+
+    pdf_logfont("}\n");
+
+    error = pdf_storeitem(xref->store, PDF_KCMAP, stmref, cmap);
+    if (error)
+    {
+	error = fz_rethrow(error, "cannot store cmap resource");
+	goto cleanup;
+    }
+
+    fz_dropobj(stmobj);
+
+    *cmapp = cmap;
+    return fz_okay;
+
+cleanup:
+    if (cmap)
+	pdf_dropcmap(cmap);
+    fz_dropobj(stmobj);
+    return error; /* already rethrown */
+}
+
+/*
+ * Create an Identity-* CMap (for both 1 and 2-byte encodings)
+ */
+fz_error *
+pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes)
+{
+    fz_error *error;
+    pdf_cmap *cmap;
+
+    error = pdf_newcmap(&cmap);
+    if (error)
+	return fz_rethrow(error, "cannot create cmap");
+
+    sprintf(cmap->cmapname, "Identity-%c", wmode ? 'V' : 'H');
+
+    error = pdf_addcodespace(cmap, 0x0000, 0xffff, bytes);
+    if (error) {
+	pdf_dropcmap(cmap);
+	return fz_rethrow(error, "cannot add code space");
+    }
+
+    error = pdf_maprangetorange(cmap, 0x0000, 0xffff, 0);
+    if (error) {
+	pdf_dropcmap(cmap);
+	return fz_rethrow(error, "cannot map <0000> to <ffff>");
+    }
+
+    error = pdf_sortcmap(cmap);
+    if (error) {
+	pdf_dropcmap(cmap);
+	return fz_rethrow(error, "cannot sort cmap");
+    }
+
+    pdf_setwmode(cmap, wmode);
+
+    *cmapp = cmap;
+    return fz_okay;
+}
+
+/*
+ * Load predefined CMap from system.
+ */
+fz_error *
+pdf_loadsystemcmap(pdf_cmap **cmapp, char *cmapname)
+{
+    fz_error *error;
+    pdf_cmap *usecmap;
+    pdf_cmap *cmap;
+    int i;
+
+    pdf_logfont("loading system cmap %s\n", cmapname);
+
+    for (i = 0; pdf_cmaptable[i]; i++)
+    {
+	if (!strcmp(cmapname, pdf_cmaptable[i]->cmapname))
+	{
+	    cmap = pdf_cmaptable[i];
+	    if (cmap->usecmapname[0] && !cmap->usecmap)
+	    {
+		error = pdf_loadsystemcmap(&usecmap, cmap->usecmapname);
+		if (error)
+		    return fz_rethrow(error, "could not load usecmap: %s", cmap->usecmapname);
+		pdf_setusecmap(cmap, usecmap);
+	    }
+	    *cmapp = cmap;
+	    return fz_okay;
+	}
+    }
+
+    return fz_throw("no builtin cmap file: %s", cmapname);
+}
+
diff --git a/mupdf/pdf_cmap_parse.c b/mupdf/pdf_cmap_parse.c
new file mode 100644
index 00000000..b474469c
--- /dev/null
+++ b/mupdf/pdf_cmap_parse.c
@@ -0,0 +1,502 @@
+#include "fitz.h"
+#include "mupdf.h"
+
+/*
+ * CMap parser
+ */
+
+enum
+{
+    TUSECMAP = PDF_NTOKENS,
+    TBEGINCODESPACERANGE,
+    TENDCODESPACERANGE,
+    TBEGINBFCHAR,
+    TENDBFCHAR,
+    TBEGINBFRANGE,
+    TENDBFRANGE,
+    TBEGINCIDCHAR,
+    TENDCIDCHAR,
+    TBEGINCIDRANGE,
+    TENDCIDRANGE
+};
+
+static pdf_token_e pdf_cmaptokenfromkeyword(char *key)
+{
+    if (!strcmp(key, "usecmap")) return TUSECMAP;
+    if (!strcmp(key, "begincodespacerange")) return TBEGINCODESPACERANGE;
+    if (!strcmp(key, "endcodespacerange")) return TENDCODESPACERANGE;
+    if (!strcmp(key, "beginbfchar")) return TBEGINBFCHAR;
+    if (!strcmp(key, "endbfchar")) return TENDBFCHAR;
+    if (!strcmp(key, "beginbfrange")) return TBEGINBFRANGE;
+    if (!strcmp(key, "endbfrange")) return TENDBFRANGE;
+    if (!strcmp(key, "begincidchar")) return TBEGINCIDCHAR;
+    if (!strcmp(key, "endcidchar")) return TENDCIDCHAR;
+    if (!strcmp(key, "begincidrange")) return TBEGINCIDRANGE;
+    if (!strcmp(key, "endcidrange")) return TENDCIDRANGE;
+    return PDF_TKEYWORD;
+}
+
+static int codefromstring(char *buf, int len)
+{
+    int a = 0;
+    while (len--)
+	a = (a << 8) | *(unsigned char *)buf++;
+    return a;
+}
+
+static fz_error *lexcmap(pdf_token_e *tok, fz_stream *file, char *buf, int n, int *sl)
+{
+    fz_error *error;
+
+    error = pdf_lex(tok, file, buf, n, sl);
+    if (error)
+	return fz_rethrow(error, "cannot parse cmap token");
+
+    if (*tok == PDF_TKEYWORD)
+	*tok = pdf_cmaptokenfromkeyword(buf);
+
+    return fz_okay;
+}
+
+static fz_error *parsecmapname(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+
+    error = lexcmap(&tok, file, buf, sizeof buf, &len);
+    if (error)
+	return fz_rethrow(error, "syntaxerror in cmap");
+
+    if (tok == PDF_TNAME)
+    {
+	strlcpy(cmap->cmapname, buf, sizeof(cmap->cmapname));
+	return fz_okay;
+    }
+
+    return fz_throw("expected name");
+}
+
+static fz_error *parsewmode(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+
+    error = lexcmap(&tok, file, buf, sizeof buf, &len);
+    if (error)
+	return fz_rethrow(error, "syntaxerror in cmap");
+
+    if (tok == PDF_TINT)
+    {
+	pdf_setwmode(cmap, atoi(buf));
+	return fz_okay;
+    }
+
+    return fz_throw("expected integer");
+}
+
+static fz_error *parsecodespacerange(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int lo, hi;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == TENDCODESPACERANGE)
+	    return fz_okay;
+
+	else if (tok == PDF_TSTRING)
+	{
+	    lo = codefromstring(buf, len);
+	    error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	    if (error)
+		return fz_rethrow(error, "syntaxerror in cmap");
+	    if (tok == PDF_TSTRING)
+	    {
+		hi = codefromstring(buf, len);
+		error = pdf_addcodespace(cmap, lo, hi, len);
+		if (error)
+		    return fz_rethrow(error, "cannot add code space");
+	    }
+	    else break;
+	}
+
+	else break;
+    }
+
+    return fz_throw("expected string or endcodespacerange");
+}
+
+static fz_error *parsecidrange(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int lo, hi, dst;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == TENDCIDRANGE)
+	    return fz_okay;
+
+	else if (tok != PDF_TSTRING)
+	    return fz_throw("expected string or endcidrange");
+
+	lo = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+	if (tok != PDF_TSTRING)
+	    return fz_throw("expected string");
+
+	hi = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+	if (tok != PDF_TINT)
+	    return fz_throw("expected integer");
+
+	dst = atoi(buf);
+
+	error = pdf_maprangetorange(cmap, lo, hi, dst);
+	if (error)
+	    return fz_rethrow(error, "cannot map cidrange");
+    }
+}
+
+static fz_error *parsecidchar(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int src, dst;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == TENDCIDCHAR)
+	    return fz_okay;
+
+	else if (tok != PDF_TSTRING)
+	    return fz_throw("expected string or endcidchar");
+
+	src = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+	if (tok != PDF_TINT)
+	    return fz_throw("expected integer");
+
+	dst = atoi(buf);
+
+	error = pdf_maprangetorange(cmap, src, src, dst);
+	if (error)
+	    return fz_rethrow(error, "cannot map cidchar");
+    }
+}
+
+static fz_error *parsebfrangearray(pdf_cmap *cmap, fz_stream *file, int lo, int hi)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int dst[256];
+    int i;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == PDF_TCARRAY)
+	    return fz_okay;
+
+	/* Note: does not handle [ /Name /Name ... ] */
+	else if (tok != PDF_TSTRING)
+	    return fz_throw("expected string or ]");
+
+	if (len / 2)
+	{
+	    for (i = 0; i < len / 2; i++)
+		dst[i] = codefromstring(buf + i * 2, 2);
+
+	    error = pdf_maponetomany(cmap, lo, dst, len / 2);
+	    if (error)
+		return fz_rethrow(error, "cannot map bfrange array");
+	}
+
+	lo ++;
+    }
+}
+
+static fz_error *parsebfrange(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int lo, hi, dst;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == TENDBFRANGE)
+	    return fz_okay;
+
+	else if (tok != PDF_TSTRING)
+	    return fz_throw("expected string or endbfrange");
+
+	lo = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+	if (tok != PDF_TSTRING)
+	    return fz_throw("expected string");
+
+	hi = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == PDF_TSTRING)
+	{
+	    if (len == 2)
+	    {
+		dst = codefromstring(buf, len);
+		error = pdf_maprangetorange(cmap, lo, hi, dst);
+		if (error)
+		    return fz_rethrow(error, "cannot map bfrange");
+	    }
+	    else
+	    {
+		int dststr[256];
+		int i;
+
+		if (len / 2)
+		{
+		    for (i = 0; i < len / 2; i++)
+			dststr[i] = codefromstring(buf + i * 2, 2);
+
+		    while (lo <= hi)
+		    {
+			dststr[i-1] ++;
+			error = pdf_maponetomany(cmap, lo, dststr, i);
+			if (error)
+			    return fz_rethrow(error, "cannot map bfrange");
+			lo ++;
+		    }
+		}
+	    }
+	}
+
+	else if (tok == PDF_TOARRAY)
+	{
+	    error = parsebfrangearray(cmap, file, lo, hi);
+	    if (error)
+		return fz_rethrow(error, "cannot map bfrange");
+	}
+
+	else
+	{
+	    return fz_throw("expected string or array or endbfrange");
+	}
+    }
+}
+
+static fz_error *parsebfchar(pdf_cmap *cmap, fz_stream *file)
+{
+    fz_error *error;
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+    int dst[256];
+    int src;
+    int i;
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+
+	if (tok == TENDBFCHAR)
+	    return fz_okay;
+
+	else if (tok != PDF_TSTRING)
+	    return fz_throw("expected string or endbfchar");
+
+	src = codefromstring(buf, len);
+
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	    return fz_rethrow(error, "syntaxerror in cmap");
+	/* Note: does not handle /dstName */
+	if (tok != PDF_TSTRING)
+	    return fz_throw("expected string");
+
+	if (len / 2)
+	{
+	    for (i = 0; i < len / 2; i++)
+		dst[i] = codefromstring(buf + i * 2, 2);
+
+	    error = pdf_maponetomany(cmap, src, dst, i);
+	    if (error)
+		return fz_rethrow(error, "cannot map bfchar");
+	}
+    }
+}
+
+fz_error *
+pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file)
+{
+    fz_error *error;
+    pdf_cmap *cmap;
+    char key[64];
+    char buf[256];
+    pdf_token_e tok;
+    int len;
+
+    error = pdf_newcmap(&cmap);
+    if (error)
+	return fz_rethrow(error, "cannot create cmap");
+
+    strcpy(key, ".notdef");
+
+    while (1)
+    {
+	error = lexcmap(&tok, file, buf, sizeof buf, &len);
+	if (error)
+	{
+	    error = fz_rethrow(error, "syntaxerror in cmap");
+	    goto cleanup;
+	}
+
+	if (tok == PDF_TEOF)
+	    break;
+
+	else if (tok == PDF_TNAME)
+	{
+	    if (!strcmp(buf, "CMapName"))
+	    {
+		error = parsecmapname(cmap, file);
+		if (error)
+		{
+		    error = fz_rethrow(error, "syntaxerror in cmap after /CMapName");
+		    goto cleanup;
+		}
+	    }
+	    else if (!strcmp(buf, "WMode"))
+	    {
+		error = parsewmode(cmap, file);
+		if (error)
+		{
+		    error = fz_rethrow(error, "syntaxerror in cmap after /WMode");
+		    goto cleanup;
+		}
+	    }
+	    else
+		strlcpy(key, buf, sizeof key);
+	}
+
+	else if (tok == TUSECMAP)
+	{
+	    strlcpy(cmap->usecmapname, key, sizeof(cmap->usecmapname));
+	}
+
+	else if (tok == TBEGINCODESPACERANGE)
+	{
+	    error = parsecodespacerange(cmap, file);
+	    if (error)
+	    {
+		error = fz_rethrow(error, "syntaxerror in cmap codespacerange");
+		goto cleanup;
+	    }
+	}
+
+	else if (tok == TBEGINBFCHAR)
+	{
+	    error = parsebfchar(cmap, file);
+	    if (error)
+	    {
+		error = fz_rethrow(error, "syntaxerror in cmap bfchar");
+		goto cleanup;
+	    }
+	}
+
+	else if (tok == TBEGINCIDCHAR)
+	{
+	    error = parsecidchar(cmap, file);
+	    if (error)
+	    {
+		error = fz_rethrow(error, "syntaxerror in cmap cidchar");
+		goto cleanup;
+	    }
+	}
+
+	else if (tok == TBEGINBFRANGE)
+	{
+	    error = parsebfrange(cmap, file);
+	    if (error)
+	    {
+		error = fz_rethrow(error, "syntaxerror in cmap bfrange");
+		goto cleanup;
+	    }
+	}
+
+	else if (tok == TBEGINCIDRANGE)
+	{
+	    error = parsecidrange(cmap, file);
+	    if (error)
+	    {
+		error = fz_rethrow(error, "syntaxerror in cmap cidrange");
+		goto cleanup;
+	    }
+	}
+
+	/* ignore everything else */
+    }
+
+    error = pdf_sortcmap(cmap);
+    if (error)
+    {
+	error = fz_rethrow(error, "cannot sort cmap");
+	goto cleanup;
+    }
+
+    *cmapp = cmap;
+    return fz_okay;
+
+cleanup:
+    pdf_dropcmap(cmap);
+    return error; /* already rethrown */
+}
+
diff --git a/mupdf/pdf_cmap_table.c b/mupdf/pdf_cmap_table.c
new file mode 100644
index 00000000..c5d2ed11
--- /dev/null
+++ b/mupdf/pdf_cmap_table.c
@@ -0,0 +1,157 @@
+/*
+ * :r !grep '^const.*pdf_cmap_' build/macosx-x86-debug/cmap_*.c
+ */
+
+#include "fitz.h"
+#include "mupdf.h"
+
+extern pdf_cmap pdf_cmap_Adobe_GB1_4;
+extern pdf_cmap pdf_cmap_Adobe_GB1_UCS2;
+extern pdf_cmap pdf_cmap_GB_EUC_H;
+extern pdf_cmap pdf_cmap_GB_EUC_V;
+extern pdf_cmap pdf_cmap_GBK_EUC_H;
+extern pdf_cmap pdf_cmap_GBK_EUC_UCS2;
+extern pdf_cmap pdf_cmap_GBK_EUC_V;
+extern pdf_cmap pdf_cmap_GBK2K_H;
+extern pdf_cmap pdf_cmap_GBK2K_V;
+extern pdf_cmap pdf_cmap_GBKp_EUC_H;
+extern pdf_cmap pdf_cmap_GBKp_EUC_V;
+extern pdf_cmap pdf_cmap_GBT_EUC_H;
+extern pdf_cmap pdf_cmap_GBT_EUC_V;
+extern pdf_cmap pdf_cmap_GBpc_EUC_H;
+extern pdf_cmap pdf_cmap_GBpc_EUC_UCS2;
+extern pdf_cmap pdf_cmap_GBpc_EUC_UCS2C;
+extern pdf_cmap pdf_cmap_GBpc_EUC_V;
+extern pdf_cmap pdf_cmap_UniGB_UCS2_H;
+extern pdf_cmap pdf_cmap_UniGB_UCS2_V;
+extern pdf_cmap pdf_cmap_Adobe_CNS1_3;
+extern pdf_cmap pdf_cmap_Adobe_CNS1_UCS2;
+extern pdf_cmap pdf_cmap_B5pc_H;
+extern pdf_cmap pdf_cmap_B5pc_UCS2;
+extern pdf_cmap pdf_cmap_B5pc_UCS2C;
+extern pdf_cmap pdf_cmap_B5pc_V;
+extern pdf_cmap pdf_cmap_CNS_EUC_H;
+extern pdf_cmap pdf_cmap_CNS_EUC_V;
+extern pdf_cmap pdf_cmap_ETen_B5_H;
+extern pdf_cmap pdf_cmap_ETen_B5_UCS2;
+extern pdf_cmap pdf_cmap_ETen_B5_V;
+extern pdf_cmap pdf_cmap_HKscs_B5_H;
+extern pdf_cmap pdf_cmap_HKscs_B5_V;
+extern pdf_cmap pdf_cmap_UniCNS_UCS2_H;
+extern pdf_cmap pdf_cmap_UniCNS_UCS2_V;
+extern pdf_cmap pdf_cmap_83pv_RKSJ_H;
+extern pdf_cmap pdf_cmap_90ms_RKSJ_H;
+extern pdf_cmap pdf_cmap_90ms_RKSJ_UCS2;
+extern pdf_cmap pdf_cmap_90ms_RKSJ_V;
+extern pdf_cmap pdf_cmap_90msp_RKSJ_H;
+extern pdf_cmap pdf_cmap_90msp_RKSJ_V;
+extern pdf_cmap pdf_cmap_90pv_RKSJ_H;
+extern pdf_cmap pdf_cmap_90pv_RKSJ_UCS2;
+extern pdf_cmap pdf_cmap_90pv_RKSJ_UCS2C;
+extern pdf_cmap pdf_cmap_Add_RKSJ_H;
+extern pdf_cmap pdf_cmap_Add_RKSJ_V;
+extern pdf_cmap pdf_cmap_Adobe_Japan1_4;
+extern pdf_cmap pdf_cmap_Adobe_Japan1_UCS2;
+extern pdf_cmap pdf_cmap_EUC_H;
+extern pdf_cmap pdf_cmap_EUC_V;
+extern pdf_cmap pdf_cmap_Ext_RKSJ_H;
+extern pdf_cmap pdf_cmap_Ext_RKSJ_V;
+extern pdf_cmap pdf_cmap_H;
+extern pdf_cmap pdf_cmap_UniJIS_UCS2_H;
+extern pdf_cmap pdf_cmap_UniJIS_UCS2_HW_H;
+extern pdf_cmap pdf_cmap_UniJIS_UCS2_HW_V;
+extern pdf_cmap pdf_cmap_UniJIS_UCS2_V;
+extern pdf_cmap pdf_cmap_V;
+extern pdf_cmap pdf_cmap_Adobe_Korea1_2;
+extern pdf_cmap pdf_cmap_Adobe_Korea1_UCS2;
+extern pdf_cmap pdf_cmap_KSC_EUC_H;
+extern pdf_cmap pdf_cmap_KSC_EUC_V;
+extern pdf_cmap pdf_cmap_KSCms_UHC_H;
+extern pdf_cmap pdf_cmap_KSCms_UHC_HW_H;
+extern pdf_cmap pdf_cmap_KSCms_UHC_HW_V;
+extern pdf_cmap pdf_cmap_KSCms_UHC_UCS2;
+extern pdf_cmap pdf_cmap_KSCms_UHC_V;
+extern pdf_cmap pdf_cmap_KSCpc_EUC_H;
+extern pdf_cmap pdf_cmap_KSCpc_EUC_UCS2;
+extern pdf_cmap pdf_cmap_KSCpc_EUC_UCS2C;
+extern pdf_cmap pdf_cmap_UniKS_UCS2_H;
+extern pdf_cmap pdf_cmap_UniKS_UCS2_V;
+
+pdf_cmap *pdf_cmaptable[] =
+{
+#ifndef NOCJK
+    &pdf_cmap_Adobe_GB1_4,
+    &pdf_cmap_Adobe_GB1_UCS2,
+    &pdf_cmap_GB_EUC_H,
+    &pdf_cmap_GB_EUC_V,
+    &pdf_cmap_GBK_EUC_H,
+    &pdf_cmap_GBK_EUC_UCS2,
+    &pdf_cmap_GBK_EUC_V,
+    &pdf_cmap_GBK2K_H,
+    &pdf_cmap_GBK2K_V,
+    &pdf_cmap_GBKp_EUC_H,
+    &pdf_cmap_GBKp_EUC_V,
+    &pdf_cmap_GBT_EUC_H,
+    &pdf_cmap_GBT_EUC_V,
+    &pdf_cmap_GBpc_EUC_H,
+    &pdf_cmap_GBpc_EUC_UCS2,
+    &pdf_cmap_GBpc_EUC_UCS2C,
+    &pdf_cmap_GBpc_EUC_V,
+    &pdf_cmap_UniGB_UCS2_H,
+    &pdf_cmap_UniGB_UCS2_V,
+    &pdf_cmap_Adobe_CNS1_3,
+    &pdf_cmap_Adobe_CNS1_UCS2,
+    &pdf_cmap_B5pc_H,
+    &pdf_cmap_B5pc_UCS2,
+    &pdf_cmap_B5pc_UCS2C,
+    &pdf_cmap_B5pc_V,
+    &pdf_cmap_CNS_EUC_H,
+    &pdf_cmap_CNS_EUC_V,
+    &pdf_cmap_ETen_B5_H,
+    &pdf_cmap_ETen_B5_UCS2,
+    &pdf_cmap_ETen_B5_V,
+    &pdf_cmap_HKscs_B5_H,
+    &pdf_cmap_HKscs_B5_V,
+    &pdf_cmap_UniCNS_UCS2_H,
+    &pdf_cmap_UniCNS_UCS2_V,
+    &pdf_cmap_83pv_RKSJ_H,
+    &pdf_cmap_90ms_RKSJ_H,
+    &pdf_cmap_90ms_RKSJ_UCS2,
+    &pdf_cmap_90ms_RKSJ_V,
+    &pdf_cmap_90msp_RKSJ_H,
+    &pdf_cmap_90msp_RKSJ_V,
+    &pdf_cmap_90pv_RKSJ_H,
+    &pdf_cmap_90pv_RKSJ_UCS2,
+    &pdf_cmap_90pv_RKSJ_UCS2C,
+    &pdf_cmap_Add_RKSJ_H,
+    &pdf_cmap_Add_RKSJ_V,
+    &pdf_cmap_Adobe_Japan1_4,
+    &pdf_cmap_Adobe_Japan1_UCS2,
+    &pdf_cmap_EUC_H,
+    &pdf_cmap_EUC_V,
+    &pdf_cmap_Ext_RKSJ_H,
+    &pdf_cmap_Ext_RKSJ_V,
+    &pdf_cmap_H,
+    &pdf_cmap_UniJIS_UCS2_H,
+    &pdf_cmap_UniJIS_UCS2_HW_H,
+    &pdf_cmap_UniJIS_UCS2_HW_V,
+    &pdf_cmap_UniJIS_UCS2_V,
+    &pdf_cmap_V,
+    &pdf_cmap_Adobe_Korea1_2,
+    &pdf_cmap_Adobe_Korea1_UCS2,
+    &pdf_cmap_KSC_EUC_H,
+    &pdf_cmap_KSC_EUC_V,
+    &pdf_cmap_KSCms_UHC_H,
+    &pdf_cmap_KSCms_UHC_HW_H,
+    &pdf_cmap_KSCms_UHC_HW_V,
+    &pdf_cmap_KSCms_UHC_UCS2,
+    &pdf_cmap_KSCms_UHC_V,
+    &pdf_cmap_KSCpc_EUC_H,
+    &pdf_cmap_KSCpc_EUC_UCS2,
+    &pdf_cmap_KSCpc_EUC_UCS2C,
+    &pdf_cmap_UniKS_UCS2_H,
+    &pdf_cmap_UniKS_UCS2_V,
+#endif
+    0
+};
+
diff --git a/mupdf/pdf_cmapfile.c b/mupdf/pdf_cmapfile.c
deleted file mode 100644
index 80fe4d9e..00000000
--- a/mupdf/pdf_cmapfile.c
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
- * A mostly grep-generated file.
- */
-
-#include "fitz.h"
-#include "mupdf.h"
-
-extern const char cmaps_chinese_s_Adobe_GB1_4_name[];
-extern const char cmaps_chinese_s_Adobe_GB1_4_buf[];
-extern const int cmaps_chinese_s_Adobe_GB1_4_len;
-extern const char cmaps_chinese_s_Adobe_GB1_UCS2_name[];
-extern const char cmaps_chinese_s_Adobe_GB1_UCS2_buf[];
-extern const int cmaps_chinese_s_Adobe_GB1_UCS2_len;
-extern const char cmaps_chinese_s_GB_EUC_H_name[];
-extern const char cmaps_chinese_s_GB_EUC_H_buf[];
-extern const int cmaps_chinese_s_GB_EUC_H_len;
-extern const char cmaps_chinese_s_GB_EUC_V_name[];
-extern const char cmaps_chinese_s_GB_EUC_V_buf[];
-extern const int cmaps_chinese_s_GB_EUC_V_len;
-extern const char cmaps_chinese_s_GBK_EUC_H_name[];
-extern const char cmaps_chinese_s_GBK_EUC_H_buf[];
-extern const int cmaps_chinese_s_GBK_EUC_H_len;
-extern const char cmaps_chinese_s_GBK_EUC_UCS2_name[];
-extern const char cmaps_chinese_s_GBK_EUC_UCS2_buf[];
-extern const int cmaps_chinese_s_GBK_EUC_UCS2_len;
-extern const char cmaps_chinese_s_GBK_EUC_V_name[];
-extern const char cmaps_chinese_s_GBK_EUC_V_buf[];
-extern const int cmaps_chinese_s_GBK_EUC_V_len;
-extern const char cmaps_chinese_s_GBK2K_H_name[];
-extern const char cmaps_chinese_s_GBK2K_H_buf[];
-extern const int cmaps_chinese_s_GBK2K_H_len;
-extern const char cmaps_chinese_s_GBK2K_V_name[];
-extern const char cmaps_chinese_s_GBK2K_V_buf[];
-extern const int cmaps_chinese_s_GBK2K_V_len;
-extern const char cmaps_chinese_s_GBKp_EUC_H_name[];
-extern const char cmaps_chinese_s_GBKp_EUC_H_buf[];
-extern const int cmaps_chinese_s_GBKp_EUC_H_len;
-extern const char cmaps_chinese_s_GBKp_EUC_V_name[];
-extern const char cmaps_chinese_s_GBKp_EUC_V_buf[];
-extern const int cmaps_chinese_s_GBKp_EUC_V_len;
-extern const char cmaps_chinese_s_GBT_EUC_H_name[];
-extern const char cmaps_chinese_s_GBT_EUC_H_buf[];
-extern const int cmaps_chinese_s_GBT_EUC_H_len;
-extern const char cmaps_chinese_s_GBT_EUC_V_name[];
-extern const char cmaps_chinese_s_GBT_EUC_V_buf[];
-extern const int cmaps_chinese_s_GBT_EUC_V_len;
-extern const char cmaps_chinese_s_GBpc_EUC_H_name[];
-extern const char cmaps_chinese_s_GBpc_EUC_H_buf[];
-extern const int cmaps_chinese_s_GBpc_EUC_H_len;
-extern const char cmaps_chinese_s_GBpc_EUC_UCS2_name[];
-extern const char cmaps_chinese_s_GBpc_EUC_UCS2_buf[];
-extern const int cmaps_chinese_s_GBpc_EUC_UCS2_len;
-extern const char cmaps_chinese_s_GBpc_EUC_UCS2C_name[];
-extern const char cmaps_chinese_s_GBpc_EUC_UCS2C_buf[];
-extern const int cmaps_chinese_s_GBpc_EUC_UCS2C_len;
-extern const char cmaps_chinese_s_GBpc_EUC_V_name[];
-extern const char cmaps_chinese_s_GBpc_EUC_V_buf[];
-extern const int cmaps_chinese_s_GBpc_EUC_V_len;
-extern const char cmaps_chinese_s_UniGB_UCS2_H_name[];
-extern const char cmaps_chinese_s_UniGB_UCS2_H_buf[];
-extern const int cmaps_chinese_s_UniGB_UCS2_H_len;
-extern const char cmaps_chinese_s_UniGB_UCS2_V_name[];
-extern const char cmaps_chinese_s_UniGB_UCS2_V_buf[];
-extern const int cmaps_chinese_s_UniGB_UCS2_V_len;
-extern const char cmaps_chinese_t_Adobe_CNS1_3_name[];
-extern const char cmaps_chinese_t_Adobe_CNS1_3_buf[];
-extern const int cmaps_chinese_t_Adobe_CNS1_3_len;
-extern const char cmaps_chinese_t_Adobe_CNS1_UCS2_name[];
-extern const char cmaps_chinese_t_Adobe_CNS1_UCS2_buf[];
-extern const int cmaps_chinese_t_Adobe_CNS1_UCS2_len;
-extern const char cmaps_chinese_t_B5pc_H_name[];
-extern const char cmaps_chinese_t_B5pc_H_buf[];
-extern const int cmaps_chinese_t_B5pc_H_len;
-extern const char cmaps_chinese_t_B5pc_UCS2_name[];
-extern const char cmaps_chinese_t_B5pc_UCS2_buf[];
-extern const int cmaps_chinese_t_B5pc_UCS2_len;
-extern const char cmaps_chinese_t_B5pc_UCS2C_name[];
-extern const char cmaps_chinese_t_B5pc_UCS2C_buf[];
-extern const int cmaps_chinese_t_B5pc_UCS2C_len;
-extern const char cmaps_chinese_t_B5pc_V_name[];
-extern const char cmaps_chinese_t_B5pc_V_buf[];
-extern const int cmaps_chinese_t_B5pc_V_len;
-extern const char cmaps_chinese_t_CNS_EUC_H_name[];
-extern const char cmaps_chinese_t_CNS_EUC_H_buf[];
-extern const int cmaps_chinese_t_CNS_EUC_H_len;
-extern const char cmaps_chinese_t_CNS_EUC_V_name[];
-extern const char cmaps_chinese_t_CNS_EUC_V_buf[];
-extern const int cmaps_chinese_t_CNS_EUC_V_len;
-extern const char cmaps_chinese_t_ETen_B5_H_name[];
-extern const char cmaps_chinese_t_ETen_B5_H_buf[];
-extern const int cmaps_chinese_t_ETen_B5_H_len;
-extern const char cmaps_chinese_t_ETen_B5_UCS2_name[];
-extern const char cmaps_chinese_t_ETen_B5_UCS2_buf[];
-extern const int cmaps_chinese_t_ETen_B5_UCS2_len;
-extern const char cmaps_chinese_t_ETen_B5_V_name[];
-extern const char cmaps_chinese_t_ETen_B5_V_buf[];
-extern const int cmaps_chinese_t_ETen_B5_V_len;
-extern const char cmaps_chinese_t_HKscs_B5_H_name[];
-extern const char cmaps_chinese_t_HKscs_B5_H_buf[];
-extern const int cmaps_chinese_t_HKscs_B5_H_len;
-extern const char cmaps_chinese_t_HKscs_B5_V_name[];
-extern const char cmaps_chinese_t_HKscs_B5_V_buf[];
-extern const int cmaps_chinese_t_HKscs_B5_V_len;
-extern const char cmaps_chinese_t_UniCNS_UCS2_H_name[];
-extern const char cmaps_chinese_t_UniCNS_UCS2_H_buf[];
-extern const int cmaps_chinese_t_UniCNS_UCS2_H_len;
-extern const char cmaps_chinese_t_UniCNS_UCS2_V_name[];
-extern const char cmaps_chinese_t_UniCNS_UCS2_V_buf[];
-extern const int cmaps_chinese_t_UniCNS_UCS2_V_len;
-extern const char cmaps_japanese_83pv_RKSJ_H_name[];
-extern const char cmaps_japanese_83pv_RKSJ_H_buf[];
-extern const int cmaps_japanese_83pv_RKSJ_H_len;
-extern const char cmaps_japanese_90ms_RKSJ_H_name[];
-extern const char cmaps_japanese_90ms_RKSJ_H_buf[];
-extern const int cmaps_japanese_90ms_RKSJ_H_len;
-extern const char cmaps_japanese_90ms_RKSJ_UCS2_name[];
-extern const char cmaps_japanese_90ms_RKSJ_UCS2_buf[];
-extern const int cmaps_japanese_90ms_RKSJ_UCS2_len;
-extern const char cmaps_japanese_90ms_RKSJ_V_name[];
-extern const char cmaps_japanese_90ms_RKSJ_V_buf[];
-extern const int cmaps_japanese_90ms_RKSJ_V_len;
-extern const char cmaps_japanese_90msp_RKSJ_H_name[];
-extern const char cmaps_japanese_90msp_RKSJ_H_buf[];
-extern const int cmaps_japanese_90msp_RKSJ_H_len;
-extern const char cmaps_japanese_90msp_RKSJ_V_name[];
-extern const char cmaps_japanese_90msp_RKSJ_V_buf[];
-extern const int cmaps_japanese_90msp_RKSJ_V_len;
-extern const char cmaps_japanese_90pv_RKSJ_H_name[];
-extern const char cmaps_japanese_90pv_RKSJ_H_buf[];
-extern const int cmaps_japanese_90pv_RKSJ_H_len;
-extern const char cmaps_japanese_90pv_RKSJ_UCS2_name[];
-extern const char cmaps_japanese_90pv_RKSJ_UCS2_buf[];
-extern const int cmaps_japanese_90pv_RKSJ_UCS2_len;
-extern const char cmaps_japanese_90pv_RKSJ_UCS2C_name[];
-extern const char cmaps_japanese_90pv_RKSJ_UCS2C_buf[];
-extern const int cmaps_japanese_90pv_RKSJ_UCS2C_len;
-extern const char cmaps_japanese_Add_RKSJ_H_name[];
-extern const char cmaps_japanese_Add_RKSJ_H_buf[];
-extern const int cmaps_japanese_Add_RKSJ_H_len;
-extern const char cmaps_japanese_Add_RKSJ_V_name[];
-extern const char cmaps_japanese_Add_RKSJ_V_buf[];
-extern const int cmaps_japanese_Add_RKSJ_V_len;
-extern const char cmaps_japanese_Adobe_Japan1_4_name[];
-extern const char cmaps_japanese_Adobe_Japan1_4_buf[];
-extern const int cmaps_japanese_Adobe_Japan1_4_len;
-extern const char cmaps_japanese_Adobe_Japan1_UCS2_name[];
-extern const char cmaps_japanese_Adobe_Japan1_UCS2_buf[];
-extern const int cmaps_japanese_Adobe_Japan1_UCS2_len;
-extern const char cmaps_japanese_EUC_H_name[];
-extern const char cmaps_japanese_EUC_H_buf[];
-extern const int cmaps_japanese_EUC_H_len;
-extern const char cmaps_japanese_EUC_V_name[];
-extern const char cmaps_japanese_EUC_V_buf[];
-extern const int cmaps_japanese_EUC_V_len;
-extern const char cmaps_japanese_Ext_RKSJ_H_name[];
-extern const char cmaps_japanese_Ext_RKSJ_H_buf[];
-extern const int cmaps_japanese_Ext_RKSJ_H_len;
-extern const char cmaps_japanese_Ext_RKSJ_V_name[];
-extern const char cmaps_japanese_Ext_RKSJ_V_buf[];
-extern const int cmaps_japanese_Ext_RKSJ_V_len;
-extern const char cmaps_japanese_H_name[];
-extern const char cmaps_japanese_H_buf[];
-extern const int cmaps_japanese_H_len;
-extern const char cmaps_japanese_UniJIS_UCS2_H_name[];
-extern const char cmaps_japanese_UniJIS_UCS2_H_buf[];
-extern const int cmaps_japanese_UniJIS_UCS2_H_len;
-extern const char cmaps_japanese_UniJIS_UCS2_HW_H_name[];
-extern const char cmaps_japanese_UniJIS_UCS2_HW_H_buf[];
-extern const int cmaps_japanese_UniJIS_UCS2_HW_H_len;
-extern const char cmaps_japanese_UniJIS_UCS2_HW_V_name[];
-extern const char cmaps_japanese_UniJIS_UCS2_HW_V_buf[];
-extern const int cmaps_japanese_UniJIS_UCS2_HW_V_len;
-extern const char cmaps_japanese_UniJIS_UCS2_V_name[];
-extern const char cmaps_japanese_UniJIS_UCS2_V_buf[];
-extern const int cmaps_japanese_UniJIS_UCS2_V_len;
-extern const char cmaps_japanese_V_name[];
-extern const char cmaps_japanese_V_buf[];
-extern const int cmaps_japanese_V_len;
-extern const char cmaps_korean_Adobe_Korea1_2_name[];
-extern const char cmaps_korean_Adobe_Korea1_2_buf[];
-extern const int cmaps_korean_Adobe_Korea1_2_len;
-extern const char cmaps_korean_Adobe_Korea1_UCS2_name[];
-extern const char cmaps_korean_Adobe_Korea1_UCS2_buf[];
-extern const int cmaps_korean_Adobe_Korea1_UCS2_len;
-extern const char cmaps_korean_KSC_EUC_H_name[];
-extern const char cmaps_korean_KSC_EUC_H_buf[];
-extern const int cmaps_korean_KSC_EUC_H_len;
-extern const char cmaps_korean_KSC_EUC_V_name[];
-extern const char cmaps_korean_KSC_EUC_V_buf[];
-extern const int cmaps_korean_KSC_EUC_V_len;
-extern const char cmaps_korean_KSCms_UHC_H_name[];
-extern const char cmaps_korean_KSCms_UHC_H_buf[];
-extern const int cmaps_korean_KSCms_UHC_H_len;
-extern const char cmaps_korean_KSCms_UHC_HW_H_name[];
-extern const char cmaps_korean_KSCms_UHC_HW_H_buf[];
-extern const int cmaps_korean_KSCms_UHC_HW_H_len;
-extern const char cmaps_korean_KSCms_UHC_HW_V_name[];
-extern const char cmaps_korean_KSCms_UHC_HW_V_buf[];
-extern const int cmaps_korean_KSCms_UHC_HW_V_len;
-extern const char cmaps_korean_KSCms_UHC_UCS2_name[];
-extern const char cmaps_korean_KSCms_UHC_UCS2_buf[];
-extern const int cmaps_korean_KSCms_UHC_UCS2_len;
-extern const char cmaps_korean_KSCms_UHC_V_name[];
-extern const char cmaps_korean_KSCms_UHC_V_buf[];
-extern const int cmaps_korean_KSCms_UHC_V_len;
-extern const char cmaps_korean_KSCpc_EUC_H_name[];
-extern const char cmaps_korean_KSCpc_EUC_H_buf[];
-extern const int cmaps_korean_KSCpc_EUC_H_len;
-extern const char cmaps_korean_KSCpc_EUC_UCS2_name[];
-extern const char cmaps_korean_KSCpc_EUC_UCS2_buf[];
-extern const int cmaps_korean_KSCpc_EUC_UCS2_len;
-extern const char cmaps_korean_KSCpc_EUC_UCS2C_name[];
-extern const char cmaps_korean_KSCpc_EUC_UCS2C_buf[];
-extern const int cmaps_korean_KSCpc_EUC_UCS2C_len;
-extern const char cmaps_korean_UniKS_UCS2_H_name[];
-extern const char cmaps_korean_UniKS_UCS2_H_buf[];
-extern const int cmaps_korean_UniKS_UCS2_H_len;
-extern const char cmaps_korean_UniKS_UCS2_V_name[];
-extern const char cmaps_korean_UniKS_UCS2_V_buf[];
-extern const int cmaps_korean_UniKS_UCS2_V_len;
-
-struct pdf_cmapentry_s pdf_cmaptable[] =
-{
-#ifndef NOCJK
-
-    { cmaps_chinese_s_Adobe_GB1_4_name,
-	cmaps_chinese_s_Adobe_GB1_4_buf,
-	&cmaps_chinese_s_Adobe_GB1_4_len, 0 },
-    { cmaps_chinese_s_Adobe_GB1_UCS2_name,
-	cmaps_chinese_s_Adobe_GB1_UCS2_buf,
-	&cmaps_chinese_s_Adobe_GB1_UCS2_len, 0 },
-    { cmaps_chinese_s_GB_EUC_H_name,
-	cmaps_chinese_s_GB_EUC_H_buf,
-	&cmaps_chinese_s_GB_EUC_H_len, 0 },
-    { cmaps_chinese_s_GB_EUC_V_name,
-	cmaps_chinese_s_GB_EUC_V_buf,
-	&cmaps_chinese_s_GB_EUC_V_len, 0 },
-    { cmaps_chinese_s_GBK_EUC_H_name,
-	cmaps_chinese_s_GBK_EUC_H_buf,
-	&cmaps_chinese_s_GBK_EUC_H_len, 0 },
-    { cmaps_chinese_s_GBK_EUC_UCS2_name,
-	cmaps_chinese_s_GBK_EUC_UCS2_buf,
-	&cmaps_chinese_s_GBK_EUC_UCS2_len, 0 },
-    { cmaps_chinese_s_GBK_EUC_V_name,
-	cmaps_chinese_s_GBK_EUC_V_buf,
-	&cmaps_chinese_s_GBK_EUC_V_len, 0 },
-    { cmaps_chinese_s_GBK2K_H_name,
-	cmaps_chinese_s_GBK2K_H_buf,
-	&cmaps_chinese_s_GBK2K_H_len, 0 },
-    { cmaps_chinese_s_GBK2K_V_name,
-	cmaps_chinese_s_GBK2K_V_buf,
-	&cmaps_chinese_s_GBK2K_V_len, 0 },
-    { cmaps_chinese_s_GBKp_EUC_H_name,
-	cmaps_chinese_s_GBKp_EUC_H_buf,
-	&cmaps_chinese_s_GBKp_EUC_H_len, 0 },
-    { cmaps_chinese_s_GBKp_EUC_V_name,
-	cmaps_chinese_s_GBKp_EUC_V_buf,
-	&cmaps_chinese_s_GBKp_EUC_V_len, 0 },
-    { cmaps_chinese_s_GBT_EUC_H_name,
-	cmaps_chinese_s_GBT_EUC_H_buf,
-	&cmaps_chinese_s_GBT_EUC_H_len, 0 },
-    { cmaps_chinese_s_GBT_EUC_V_name,
-	cmaps_chinese_s_GBT_EUC_V_buf,
-	&cmaps_chinese_s_GBT_EUC_V_len, 0 },
-    { cmaps_chinese_s_GBpc_EUC_H_name,
-	cmaps_chinese_s_GBpc_EUC_H_buf,
-	&cmaps_chinese_s_GBpc_EUC_H_len, 0 },
-    { cmaps_chinese_s_GBpc_EUC_UCS2_name,
-	cmaps_chinese_s_GBpc_EUC_UCS2_buf,
-	&cmaps_chinese_s_GBpc_EUC_UCS2_len, 0 },
-    { cmaps_chinese_s_GBpc_EUC_UCS2C_name,
-	cmaps_chinese_s_GBpc_EUC_UCS2C_buf,
-	&cmaps_chinese_s_GBpc_EUC_UCS2C_len, 0 },
-    { cmaps_chinese_s_GBpc_EUC_V_name,
-	cmaps_chinese_s_GBpc_EUC_V_buf,
-	&cmaps_chinese_s_GBpc_EUC_V_len, 0 },
-    { cmaps_chinese_s_UniGB_UCS2_H_name,
-	cmaps_chinese_s_UniGB_UCS2_H_buf,
-	&cmaps_chinese_s_UniGB_UCS2_H_len, 0 },
-    { cmaps_chinese_s_UniGB_UCS2_V_name,
-	cmaps_chinese_s_UniGB_UCS2_V_buf,
-	&cmaps_chinese_s_UniGB_UCS2_V_len, 0 },
-    { cmaps_chinese_t_Adobe_CNS1_3_name,
-	cmaps_chinese_t_Adobe_CNS1_3_buf,
-	&cmaps_chinese_t_Adobe_CNS1_3_len, 0 },
-    { cmaps_chinese_t_Adobe_CNS1_UCS2_name,
-	cmaps_chinese_t_Adobe_CNS1_UCS2_buf,
-	&cmaps_chinese_t_Adobe_CNS1_UCS2_len, 0 },
-    { cmaps_chinese_t_B5pc_H_name,
-	cmaps_chinese_t_B5pc_H_buf,
-	&cmaps_chinese_t_B5pc_H_len, 0 },
-    { cmaps_chinese_t_B5pc_UCS2_name,
-	cmaps_chinese_t_B5pc_UCS2_buf,
-	&cmaps_chinese_t_B5pc_UCS2_len, 0 },
-    { cmaps_chinese_t_B5pc_UCS2C_name,
-	cmaps_chinese_t_B5pc_UCS2C_buf,
-	&cmaps_chinese_t_B5pc_UCS2C_len, 0 },
-    { cmaps_chinese_t_B5pc_V_name,
-	cmaps_chinese_t_B5pc_V_buf,
-	&cmaps_chinese_t_B5pc_V_len, 0 },
-    { cmaps_chinese_t_CNS_EUC_H_name,
-	cmaps_chinese_t_CNS_EUC_H_buf,
-	&cmaps_chinese_t_CNS_EUC_H_len, 0 },
-    { cmaps_chinese_t_CNS_EUC_V_name,
-	cmaps_chinese_t_CNS_EUC_V_buf,
-	&cmaps_chinese_t_CNS_EUC_V_len, 0 },
-    { cmaps_chinese_t_ETen_B5_H_name,
-	cmaps_chinese_t_ETen_B5_H_buf,
-	&cmaps_chinese_t_ETen_B5_H_len, 0 },
-    { cmaps_chinese_t_ETen_B5_UCS2_name,
-	cmaps_chinese_t_ETen_B5_UCS2_buf,
-	&cmaps_chinese_t_ETen_B5_UCS2_len, 0 },
-    { cmaps_chinese_t_ETen_B5_V_name,
-	cmaps_chinese_t_ETen_B5_V_buf,
-	&cmaps_chinese_t_ETen_B5_V_len, 0 },
-    { cmaps_chinese_t_HKscs_B5_H_name,
-	cmaps_chinese_t_HKscs_B5_H_buf,
-	&cmaps_chinese_t_HKscs_B5_H_len, 0 },
-    { cmaps_chinese_t_HKscs_B5_V_name,
-	cmaps_chinese_t_HKscs_B5_V_buf,
-	&cmaps_chinese_t_HKscs_B5_V_len, 0 },
-    { cmaps_chinese_t_UniCNS_UCS2_H_name,
-	cmaps_chinese_t_UniCNS_UCS2_H_buf,
-	&cmaps_chinese_t_UniCNS_UCS2_H_len, 0 },
-    { cmaps_chinese_t_UniCNS_UCS2_V_name,
-	cmaps_chinese_t_UniCNS_UCS2_V_buf,
-	&cmaps_chinese_t_UniCNS_UCS2_V_len, 0 },
-    { cmaps_japanese_83pv_RKSJ_H_name,
-	cmaps_japanese_83pv_RKSJ_H_buf,
-	&cmaps_japanese_83pv_RKSJ_H_len, 0 },
-    { cmaps_japanese_90ms_RKSJ_H_name,
-	cmaps_japanese_90ms_RKSJ_H_buf,
-	&cmaps_japanese_90ms_RKSJ_H_len, 0 },
-    { cmaps_japanese_90ms_RKSJ_UCS2_name,
-	cmaps_japanese_90ms_RKSJ_UCS2_buf,
-	&cmaps_japanese_90ms_RKSJ_UCS2_len, 0 },
-    { cmaps_japanese_90ms_RKSJ_V_name,
-	cmaps_japanese_90ms_RKSJ_V_buf,
-	&cmaps_japanese_90ms_RKSJ_V_len, 0 },
-    { cmaps_japanese_90msp_RKSJ_H_name,
-	cmaps_japanese_90msp_RKSJ_H_buf,
-	&cmaps_japanese_90msp_RKSJ_H_len, 0 },
-    { cmaps_japanese_90msp_RKSJ_V_name,
-	cmaps_japanese_90msp_RKSJ_V_buf,
-	&cmaps_japanese_90msp_RKSJ_V_len, 0 },
-    { cmaps_japanese_90pv_RKSJ_H_name,
-	cmaps_japanese_90pv_RKSJ_H_buf,
-	&cmaps_japanese_90pv_RKSJ_H_len, 0 },
-    { cmaps_japanese_90pv_RKSJ_UCS2_name,
-	cmaps_japanese_90pv_RKSJ_UCS2_buf,
-	&cmaps_japanese_90pv_RKSJ_UCS2_len, 0 },
-    { cmaps_japanese_90pv_RKSJ_UCS2C_name,
-	cmaps_japanese_90pv_RKSJ_UCS2C_buf,
-	&cmaps_japanese_90pv_RKSJ_UCS2C_len, 0 },
-    { cmaps_japanese_Add_RKSJ_H_name,
-	cmaps_japanese_Add_RKSJ_H_buf,
-	&cmaps_japanese_Add_RKSJ_H_len, 0 },
-    { cmaps_japanese_Add_RKSJ_V_name,
-	cmaps_japanese_Add_RKSJ_V_buf,
-	&cmaps_japanese_Add_RKSJ_V_len, 0 },
-    { cmaps_japanese_Adobe_Japan1_4_name,
-	cmaps_japanese_Adobe_Japan1_4_buf,
-	&cmaps_japanese_Adobe_Japan1_4_len, 0 },
-    { cmaps_japanese_Adobe_Japan1_UCS2_name,
-	cmaps_japanese_Adobe_Japan1_UCS2_buf,
-	&cmaps_japanese_Adobe_Japan1_UCS2_len, 0 },
-    { cmaps_japanese_EUC_H_name,
-	cmaps_japanese_EUC_H_buf,
-	&cmaps_japanese_EUC_H_len, 0 },
-    { cmaps_japanese_EUC_V_name,
-	cmaps_japanese_EUC_V_buf,
-	&cmaps_japanese_EUC_V_len, 0 },
-    { cmaps_japanese_Ext_RKSJ_H_name,
-	cmaps_japanese_Ext_RKSJ_H_buf,
-	&cmaps_japanese_Ext_RKSJ_H_len, 0 },
-    { cmaps_japanese_Ext_RKSJ_V_name,
-	cmaps_japanese_Ext_RKSJ_V_buf,
-	&cmaps_japanese_Ext_RKSJ_V_len, 0 },
-    { cmaps_japanese_H_name,
-	cmaps_japanese_H_buf,
-	&cmaps_japanese_H_len, 0 },
-    { cmaps_japanese_UniJIS_UCS2_H_name,
-	cmaps_japanese_UniJIS_UCS2_H_buf,
-	&cmaps_japanese_UniJIS_UCS2_H_len, 0 },
-    { cmaps_japanese_UniJIS_UCS2_HW_H_name,
-	cmaps_japanese_UniJIS_UCS2_HW_H_buf,
-	&cmaps_japanese_UniJIS_UCS2_HW_H_len, 0 },
-    { cmaps_japanese_UniJIS_UCS2_HW_V_name,
-	cmaps_japanese_UniJIS_UCS2_HW_V_buf,
-	&cmaps_japanese_UniJIS_UCS2_HW_V_len, 0 },
-    { cmaps_japanese_UniJIS_UCS2_V_name,
-	cmaps_japanese_UniJIS_UCS2_V_buf,
-	&cmaps_japanese_UniJIS_UCS2_V_len, 0 },
-    { cmaps_japanese_V_name,
-	cmaps_japanese_V_buf,
-	&cmaps_japanese_V_len, 0 },
-    { cmaps_korean_Adobe_Korea1_2_name,
-	cmaps_korean_Adobe_Korea1_2_buf,
-	&cmaps_korean_Adobe_Korea1_2_len, 0 },
-    { cmaps_korean_Adobe_Korea1_UCS2_name,
-	cmaps_korean_Adobe_Korea1_UCS2_buf,
-	&cmaps_korean_Adobe_Korea1_UCS2_len, 0 },
-    { cmaps_korean_KSC_EUC_H_name,
-	cmaps_korean_KSC_EUC_H_buf,
-	&cmaps_korean_KSC_EUC_H_len, 0 },
-    { cmaps_korean_KSC_EUC_V_name,
-	cmaps_korean_KSC_EUC_V_buf,
-	&cmaps_korean_KSC_EUC_V_len, 0 },
-    { cmaps_korean_KSCms_UHC_H_name,
-	cmaps_korean_KSCms_UHC_H_buf,
-	&cmaps_korean_KSCms_UHC_H_len, 0 },
-    { cmaps_korean_KSCms_UHC_HW_H_name,
-	cmaps_korean_KSCms_UHC_HW_H_buf,
-	&cmaps_korean_KSCms_UHC_HW_H_len, 0 },
-    { cmaps_korean_KSCms_UHC_HW_V_name,
-	cmaps_korean_KSCms_UHC_HW_V_buf,
-	&cmaps_korean_KSCms_UHC_HW_V_len, 0 },
-    { cmaps_korean_KSCms_UHC_UCS2_name,
-	cmaps_korean_KSCms_UHC_UCS2_buf,
-	&cmaps_korean_KSCms_UHC_UCS2_len, 0 },
-    { cmaps_korean_KSCms_UHC_V_name,
-	cmaps_korean_KSCms_UHC_V_buf,
-	&cmaps_korean_KSCms_UHC_V_len, 0 },
-    { cmaps_korean_KSCpc_EUC_H_name,
-	cmaps_korean_KSCpc_EUC_H_buf,
-	&cmaps_korean_KSCpc_EUC_H_len, 0 },
-    { cmaps_korean_KSCpc_EUC_UCS2_name,
-	cmaps_korean_KSCpc_EUC_UCS2_buf,
-	&cmaps_korean_KSCpc_EUC_UCS2_len, 0 },
-    { cmaps_korean_KSCpc_EUC_UCS2C_name,
-	cmaps_korean_KSCpc_EUC_UCS2C_buf,
-	&cmaps_korean_KSCpc_EUC_UCS2C_len, 0 },
-    { cmaps_korean_UniKS_UCS2_H_name,
-	cmaps_korean_UniKS_UCS2_H_buf,
-	&cmaps_korean_UniKS_UCS2_H_len, 0 },
-    { cmaps_korean_UniKS_UCS2_V_name,
-	cmaps_korean_UniKS_UCS2_V_buf,
-	&cmaps_korean_UniKS_UCS2_V_len, 0 },
-
-#endif
-    { 0, 0, 0, 0 }
-};
-
diff --git a/mupdf/pdf_fontfile.c b/mupdf/pdf_fontfile.c
index ebd9125a..3c0ecb37 100644
--- a/mupdf/pdf_fontfile.c
+++ b/mupdf/pdf_fontfile.c
@@ -115,7 +115,7 @@ loadsystemcidfont(pdf_fontdesc *font, int csi, int kind)
 	 */
 	pdf_logfont("loading builtin CJK font\n");
 	error = fz_newfontfrombuffer(&font->font,
-		fonts_droid_DroidSansFallback_ttf,
+		(unsigned char *)fonts_droid_DroidSansFallback_ttf,
 		fonts_droid_DroidSansFallback_ttf_len, 0);
 	if (error)
 	    return fz_rethrow(error, "cannot load builtin CJK font");
diff --git a/mupdf/pdf_lex.c b/mupdf/pdf_lex.c
index aabe3fbb..927f464f 100644
--- a/mupdf/pdf_lex.c
+++ b/mupdf/pdf_lex.c
@@ -233,7 +233,7 @@ lexhexstring(fz_stream *f, char *buf, int n)
 }
 
 static pdf_token_e
-tokenfromkeyword(char *key)
+pdf_tokenfromkeyword(char *key)
 {
 	if (!strcmp(key, "R")) return PDF_TR;
 	if (!strcmp(key, "true")) return PDF_TTRUE;
@@ -367,7 +367,7 @@ pdf_lex(pdf_token_e *tok, fz_stream *f, char *buf, int n, int *sl)
 		{
 			lexname(f, buf, n);
 			*sl = strlen(buf);
-			*tok = tokenfromkeyword(buf);
+			*tok = pdf_tokenfromkeyword(buf);
 			goto cleanupokay;
 		}