#include "libparsepcf.h"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


static char *file = NULL;
static size_t len = 0;

static size_t table_n;
static size_t table_i;
static struct libparsepcf_table *tables;

static struct libparsepcf_font font;


static void
load_file(void)
{
	size_t size = 0;
	ssize_t r;

	if (isatty(STDIN_FILENO)) {
		fprintf(stderr, "An uncompressed PCF file is required as standard input\n");
		exit(1);
	}

	for (;;) {
		if (size == len) {
			file = realloc(file, size += 8096);
			if (!file) {
				perror("realloc");
				exit(1);
			}
		}
		r = read(STDIN_FILENO, &file[len], size - len);
		if (r <= 0) {
			if (!r)
				break;
			perror("read");
			exit(1);
		}
		len += (size_t)r;
	}
}


static void
print_properties(void)
{
	size_t prop_i;
	struct libparsepcf_properties props;
	struct libparsepcf_property_subtable *proptab;

	if (libparsepcf_get_properties(file, len, &tables[table_i], &props)) {
		perror("libparsepcf_get_properties");
		exit(1);
	}
	printf("    PROPERTIES:\n");
	printf("\tnprops: %zu\n", props.property_count);
	printf("\tstrlen: %zu\n", props.strings_size);
	if (!props.property_count)
		return;
	proptab = calloc(props.property_count, sizeof(*proptab));
	if (!proptab) {
		perror("calloc");
		exit(1);
	}
	if (libparsepcf_get_property_subtable(file, len, &tables[table_i], &props,
	                                      proptab, 0, props.property_count)) {
		perror("libparsepcf_get_property_subtable");
		exit(1);
	}
	for (prop_i = 0; prop_i < props.property_count; prop_i++) {
		printf("\t    #%zu\n", prop_i);
		printf("\t\tname: %s\n", proptab[prop_i].name);
		if (proptab[prop_i].is_string_property)
			printf("\t\tvalue: \"%s\"\n", proptab[prop_i].value.string_value);
		else
			printf("\t\tvalue: %i\n", proptab[prop_i].value.signed_value);
	}
	free(proptab);
}


static void
print_metrics(const char *header)
{
	struct libparsepcf_metrics *metrics;
	size_t mtx_i, mtx_n;

	if (libparsepcf_get_metrics_count(file, len, &tables[table_i], &mtx_n)) {
		perror("libparsepcf_get_metrics_count");
		exit(1);
	}
	metrics = calloc(mtx_n, sizeof(*metrics));
	if (!metrics) {
		perror("calloc");
		exit(1);
	}
	if (libparsepcf_get_metrics(file, len, &tables[table_i], metrics, 0, mtx_n)) {
		perror("libparsepcf_get_metrics");
		exit(1);
	}
	printf("    %s:\n", header);
	printf("\tcount: %zu\n", mtx_n);
	for (mtx_i = 0; mtx_i < mtx_n; mtx_i++) {
		printf("\t#%zu: lsb=%i, rsb=%i, width=%i, ascent=%i, descent=%i, attributes=%x\n",
		       mtx_i, metrics[mtx_i].left_side_bearing, metrics[mtx_i].right_side_bearing,
		       metrics[mtx_i].character_width, metrics[mtx_i].character_ascent,
		       metrics[mtx_i].character_descent, metrics[mtx_i].character_attributes);
	}
	free(metrics);
}


static void
print_glyph_names(void)
{
	size_t name_i;
	struct libparsepcf_glyph_names names;
	const char **nametab;

	if (libparsepcf_get_glyph_names(file, len, &tables[table_i], &names)) {
		perror("libparsepcf_get_glyph_names");
		exit(1);
	}
	printf("    GLYPH NAMES:\n");
	printf("\tnglyph: %zu\n", names.glyph_count);
	printf("\tstrlen: %zu\n", names.strings_size);
	if (!names.glyph_count)
		return;
	nametab = calloc(names.glyph_count, sizeof(*nametab));
	if (!nametab) {
		perror("calloc");
		exit(1);
	}
	if (libparsepcf_get_glyph_name_subtable(file, len, &tables[table_i], &names,
	                                        nametab, 0, names.glyph_count)) {
		perror("libparsepcf_get_glyph_name_subtable");
		exit(1);
	}
	for (name_i = 0; name_i < names.glyph_count; name_i++)
		printf("\t    #%zu: %s\n", name_i, nametab[name_i]);
	free(nametab);
}


static void
print_bitmaps(void)
{
	size_t bitmap_i;
	struct libparsepcf_bitmaps bitmaps;
	size_t *bitmaptab;

	if (libparsepcf_get_bitmaps(file, len, &tables[table_i], &bitmaps)) {
		perror("libparsepcf_get_bitmaps");
		exit(1);
	}
	printf("    BITMAPS:\n");
	printf("\tnglyph: %zu\n", bitmaps.glyph_count);
	printf("\tsize: %zu\n", bitmaps.bitmap_size);
	printf("\tpacking: %zu\n", bitmaps.bit_packing);
	printf("\tpadding: %zu\n", bitmaps.row_padding);
	printf("\tlsbyte: %i\n", bitmaps.lsbyte);
	printf("\tlsbit: %i\n", bitmaps.lsbit);
	if (!bitmaps.glyph_count)
		return;
	bitmaptab = calloc(bitmaps.glyph_count, sizeof(*bitmaptab));
	if (!bitmaptab) {
		perror("calloc");
		exit(1);
	}
	if (libparsepcf_get_bitmap_offsets(file, len, &tables[table_i], &bitmaps,
	                                   bitmaptab, 0, bitmaps.glyph_count)) {
		perror("libparsepcf_get_bitmap_offsets");
		exit(1);
	}
	for (bitmap_i = 0; bitmap_i < bitmaps.glyph_count; bitmap_i++) {
		printf("\t    #%zu: %zu -> %p (maxsize=%zu)\n",
		       bitmap_i, bitmaptab[bitmap_i],
		       (const void *)&bitmaps.bitmap_data[bitmaptab[bitmap_i]],
		       bitmaps.bitmap_size - bitmaptab[bitmap_i]);
	}
	free(bitmaptab);
}


static void
print_bdf_encodings(void)
{
	struct libparsepcf_encoding encoding;
	size_t *indices;
	size_t index_i;

	if (libparsepcf_get_encoding(file, len, &tables[table_i], &encoding)) {
		perror("libparsepcf_get_encoding:");
		exit(1);
	}
	printf("    BDF ENCODINGS:\n");
	printf("\trange2: [%u, %u]\n", encoding.min_byte2, encoding.max_byte2);
	printf("\trange1: [%u, %u]\n", encoding.min_byte1, encoding.max_byte1);
	printf("\tdefault: %u\n", encoding.default_char);
	printf("\tnglyph: %zu\n", encoding.glyph_count);
	if (!encoding.glyph_count)
		return;
	indices = calloc(encoding.glyph_count, sizeof(*indices));
	if (libparsepcf_get_glyph_indices(file, len, &tables[table_i], &encoding,
	                                  indices, 0, encoding.glyph_count)) {
		perror("libparsepcf_get_glyph_indices");
		exit(1);
	}
	for (index_i = 0; index_i < encoding.glyph_count; index_i++) {
		if (indices[index_i] == LIBPARSEPCF_NOT_ENCODED)
			printf("\t#%#zx: not encoded\n", index_i);
		else
			printf("\t#%#zx: %zu\n", index_i, indices[index_i]);
	}
	free(indices);
}


static void
print_accelerators(const char *header)
{
	struct libparsepcf_accelerators accel;

	if (libparsepcf_get_accelerators(file, len, &tables[table_i], &accel)) {
		perror("libparsepcf_get_accelerators:");
		exit(1);
	}
	printf("    %s:\n", header);
	printf("\tno overlap: %i\n", accel.no_overlap);
	printf("\tconstant metrics: %i\n", accel.constant_metrics);
	printf("\tterminal font: %i\n", accel.terminal_font);
	printf("\tconstant width: %i\n", accel.constant_width);
	printf("\tink inside: %i\n", accel.ink_inside);
	printf("\tink metrics: %i\n", accel.ink_metrics);
	printf("\tdraw rtl: %i\n", accel.draw_rtl);
	printf("\thave ink bounds: %i\n", accel.have_ink_bounds);
	printf("\tfont ascent: %i\n", accel.font_ascent);
	printf("\tfont descent: %i\n", accel.font_descent);
	printf("\tmax overlap: %i\n", accel.max_overlap);
	printf("\tmin bounds: lsb=%i, rsb=%i, width=%i, ascent=%i, descent=%i, attributes=%x\n",
	       accel.min_bounds.left_side_bearing, accel.min_bounds.right_side_bearing,
	       accel.min_bounds.character_width, accel.min_bounds.character_ascent,
	       accel.min_bounds.character_descent, accel.min_bounds.character_attributes);
	printf("\tmax bounds: lsb=%i, rsb=%i, width=%i, ascent=%i, descent=%i, attributes=%x\n",
	       accel.max_bounds.left_side_bearing, accel.max_bounds.right_side_bearing,
	       accel.max_bounds.character_width, accel.max_bounds.character_ascent,
	       accel.max_bounds.character_descent, accel.max_bounds.character_attributes);
	if (accel.have_ink_bounds) {
		printf("\tmin ink bounds: lsb=%i, rsb=%i, width=%i, ascent=%i, descent=%i, attributes=%x\n",
		       accel.min_ink_bounds.left_side_bearing, accel.min_ink_bounds.right_side_bearing,
		       accel.min_ink_bounds.character_width, accel.min_ink_bounds.character_ascent,
		       accel.min_ink_bounds.character_descent, accel.min_ink_bounds.character_attributes);
		printf("\tmax ink bounds: lsb=%i, rsb=%i, width=%i, ascent=%i, descent=%i, attributes=%x\n",
		       accel.max_ink_bounds.left_side_bearing, accel.max_ink_bounds.right_side_bearing,
		       accel.max_ink_bounds.character_width, accel.max_ink_bounds.character_ascent,
		       accel.max_ink_bounds.character_descent, accel.max_ink_bounds.character_attributes);
	}
}


static void
print_swidths(void)
{
	size_t sw_i, sw_n;
	int32_t *swidths;

	if (libparsepcf_get_swidth_count(file, len, &tables[table_i], &sw_n)) {
		perror("libparsepcf_get_swidth_count");
		exit(1);
	}
	printf("    SWIDTHS:\n");
	printf("\tnglyph: %zu\n", sw_n);
	if (!sw_n)
		return;
	swidths = calloc(sw_n, sizeof(*swidths));
	if (libparsepcf_get_swidths(file, len, &tables[table_i], swidths, 0, sw_n)) {
		perror("libparsepcf_get_swidths");
		exit(1);
	}
	for (sw_i = 0; sw_i < sw_n; sw_i++)
		printf("\t#%zu: %i milli-ems\n", sw_i, swidths[sw_i]);
}


static void
print_font(void)
{
	if (libparsepcf_get_table_count(file, len, &table_n)) {
		perror("libparsepcf_get_table_count");
		exit(1);
	}
	fprintf(stderr, "size: %zu\n", len);
	fprintf(stderr, "ntables: %zu\n", table_n);

	tables = calloc(table_n, sizeof(*tables));
	if (!tables) {
		perror("calloc");
		exit(1);
	}
	if (libparsepcf_get_tables(file, len, tables, 0, table_n)) {
		perror("libparsepcf_get_tables");
		exit(1);
	}

	for (table_i = 0; table_i < table_n; table_i++) {
		printf("table #%zu: type=%#x, format=%#x, offset=%u, size=%u, (end=%u)\n",
		       table_i, tables[table_i].type, tables[table_i].format,
		       tables[table_i].offset, tables[table_i].size,
		       tables[table_i].offset + tables[table_i].size);

		switch (tables[table_i].type) {
#if 1
		case LIBPARSEPCF_PROPERTIES: /* X font atoms */
			print_properties();
			break;
#endif
#if 0
		case LIBPARSEPCF_METRICS: /* bitmap size */
			print_metrics("METRICS");
			break;
#endif
#if 0
		case LIBPARSEPCF_INK_METRICS: /* minimium bounding box metrics */
			print_metrics("INK METRICS");
			break;
#endif
#if 0
		case LIBPARSEPCF_GLYPH_NAMES: /* PostScript names */
			print_glyph_names();
			break;
#endif
#if 0
		case LIBPARSEPCF_BITMAPS:
			print_bitmaps();
			break;
#endif
#if 0
		case LIBPARSEPCF_BDF_ENCODINGS:
			print_bdf_encodings();
			break;
#endif
#if 1
		case LIBPARSEPCF_ACCELERATORS:
			print_accelerators("ACCELERATORS");
			break;
#endif
#if 1
		case LIBPARSEPCF_BDF_ACCELERATORS: /* prefered over LIBPARSEPCF_ACCELERATORS */
			print_accelerators("BDF ACCELERATORS");
			break;
#endif
#if 0
		case LIBPARSEPCF_SWIDTHS:
			print_swidths();
			break;
#endif
		default:
			(void) print_properties;
			(void) print_metrics;
			(void) print_glyph_names;
			(void) print_bitmaps;
			(void) print_bdf_encodings;
			(void) print_accelerators;
			(void) print_swidths;
			break;
		}
	}

	free(tables);
}


static void
print_glyph_info(size_t glyph, const struct libparsepcf_metrics *mtx)
{
	struct libparsepcf_metrics inkmtx;
	const char *name;
	int32_t s32;

	if (font.name_table) {
		if (libparsepcf_get_glyph_name_subtable(file, len, font.name_table, &font.names, &name, glyph, 1)) {
			perror("libparsepcf_get_glyph_name_subtable");
			exit(1);
		}
		printf("glyph name: %s\n", name);
	}
	if (font.swidth_table) {
		if (libparsepcf_get_swidths(file, len, font.swidth_table, &s32, glyph, 1)) {
			perror("libparsepcf_get_swidths");
			exit(1);
		}
		printf("scalable width: %i milli-ems\n", s32);
	}
	printf("metrics:\n");
	printf("    left side bearing:    %i\n", mtx->left_side_bearing);
	printf("    right side bearing:   %i\n", mtx->right_side_bearing);
	printf("    character width:      %i\n", mtx->character_width);
	printf("    character ascent:     %i\n", mtx->character_ascent);
	printf("    character descent:    %i\n", mtx->character_descent);
	printf("    character attributes: %u\n", mtx->character_attributes);	
	if (font.inkmtx_table) {
		if (libparsepcf_get_metrics(file, len, font.inkmtx_table, &inkmtx, glyph, 1)) {
			perror("libparsepcf_get_metrics");
			exit(1);
		}
		printf("ink metrics:\n");
		printf("    left side bearing:    %i\n", inkmtx.left_side_bearing);
		printf("    right side bearing:   %i\n", inkmtx.right_side_bearing);
		printf("    character width:      %i\n", inkmtx.character_width);
		printf("    character ascent:     %i\n", inkmtx.character_ascent);
		printf("    character descent:    %i\n", inkmtx.character_descent);
		printf("    character attributes: %u\n", inkmtx.character_attributes);
	}
	if (font.accel_table) {
		printf("font ascent: %i\n", font.accels.font_ascent);
		printf("font descent: %i\n", font.accels.font_descent);
	}
}


static void
print_glyph(size_t glyph)
{
	struct libparsepcf_metrics mtx;
	size_t width, height, bitmap_size, bitmap_offset;
	size_t row_size, padding, y, x, bit, byte, packing;
	int32_t font_ascent, font_descent;
	size_t extra_left, extra_right, print_width;
	const uint8_t *bitmap;
	const char *pixel;

	if (glyph >= font.glyph_count) {
		fprintf(stderr, "specified glyph does not exist\n");
		exit(1);
	}
	if (libparsepcf_get_metrics(file, len, font.mtx_table, &mtx, glyph, 1)) {
		perror("libparsepcf_get_metrics");
		exit(1);
	}
	padding = font.bitmaps.row_padding - 1;
	packing = font.bitmaps.bit_packing - 1;
	width = (size_t)((int32_t)mtx.right_side_bearing - (int32_t)mtx.left_side_bearing);
	height = (size_t)((int32_t)mtx.character_ascent + (int32_t)mtx.character_descent);
	row_size = width / 8 + !!(width & 7);
	row_size = row_size + ((font.bitmaps.row_padding - (row_size & padding)) & padding);
	if (font.accel_table) {
		font_ascent = font.accels.font_ascent;
		font_descent = font.accels.font_descent;
	} else {
		font_ascent = mtx.character_ascent;
		font_descent = mtx.character_descent;
	}

	print_glyph_info(glyph, &mtx);

	if (libparsepcf_get_bitmap_offsets(file, len, font.bitmap_table, &font.bitmaps, &bitmap_offset, glyph, 1)) {
		perror("libparsepcf_get_bitmap_offsets");
		exit(1);
	}
	bitmap_size = font.bitmaps.bitmap_size - bitmap_offset;
	bitmap = &font.bitmaps.bitmap_data[bitmap_offset];
	if (height && row_size > bitmap_size / height) {
		perror("bitmap is smaller than expected");
		exit(1);
	}
	printf("\n");

	extra_left = mtx.left_side_bearing > 0 ? (size_t)mtx.left_side_bearing : 0;
	extra_right = mtx.character_width > mtx.right_side_bearing ? (size_t)(mtx.character_width - mtx.right_side_bearing) : 0;
	print_width = extra_left + width + extra_right;

	/* If the font's ascent is greater than the character's, print the excees in black */
	if (font_ascent > mtx.character_ascent) {
		for (y = 0; y < (size_t)(font_ascent - mtx.character_ascent); y++) {
			for (x = 0; x < print_width; x++)
				printf("\033[1;30m[]");
			printf("\033[0m\n");
		}
	}

	for (y = 0; y < height; y++, bitmap += row_size) {
		/* Draw baseline */
		if ((int64_t)y + 1 == (int64_t)mtx.character_ascent)
			printf("\033[4m");

		/* If glyph is offset for caret, print offset in black */
		for (x = 0; x < extra_left; x++)
			printf("\033[1;30m[]");

		/* Draw glyph */
		for (x = 0; x < width; x++) {
			bit = font.bitmaps.lsbit ? 7 - x % 8 : x % 8;
			byte = x / 8;
			if (!font.bitmaps.lsbyte)
				byte = ((byte & ~packing) | (packing - (byte & packing)));

			/* Use <> to mark dots outside of the glyph box */
			if (mtx.left_side_bearing < 0 &&
			    x < (size_t)-mtx.left_side_bearing) {
				pixel = "<>";
			} else if (mtx.right_side_bearing > mtx.character_width &&
			           x >= (size_t)(mtx.character_width + mtx.left_side_bearing)) {
				pixel = "<>";
			} else if (mtx.character_ascent > font_ascent &&
			           y < (size_t)(mtx.character_ascent - font_ascent)) {
				pixel = "<>";
			} else if (mtx.character_descent > font_descent &&
				   y >= (size_t)(mtx.character_ascent + font_descent)) {
				pixel = "<>";
			} else {
				pixel = "[]";
			}

			printf("\033[%sm%s", ((bitmap[byte] >> bit) & 1) ? "1;37" : "2;37", pixel);
		}

		/* If horizontal advance is larger than character width, print extent in black */
		for (x = 0; x < extra_right; x++)
			printf("\033[1;30m[]");

		printf("\033[0m\n");
	}

	/* If the font's descent is greater than the character's, print the excees in black */
	if (font_descent > mtx.character_descent) {
		for (y = 0; y < (size_t)(font_descent - mtx.character_descent); y++) {
			for (x = 0; x < print_width; x++)
				printf("\033[1;30m[]");
			printf("\033[0m\n");
		}
	}
}


static void
draw_glyph(size_t glyph, int32_t *xp, char ***linesp, int32_t *leftp, int32_t *rightp, int32_t *ascentp, int32_t *descentp)
{
	struct libparsepcf_metrics mtx;
	const uint8_t *bitmap;
	int32_t left, right;
	size_t height, width, old_height, old_width, y, x, ypos, xpos;
	size_t padding, packing, row_size, bit, byte, bitmap_offset, bitmap_size;

	if (libparsepcf_get_metrics(file, len, font.mtx_table, &mtx, glyph, 1)) {
		perror("libparsepcf_get_metrics");
		exit(1);
	}

	xpos = (size_t)*xp;
	left = *xp + mtx.left_side_bearing;
	right = *xp + mtx.right_side_bearing;
	*xp += mtx.character_width;
	height = (size_t)(*ascentp + *descentp);
	width = (size_t)(*leftp + *rightp);

	if (-left > *leftp) {
		*leftp = -left;
		old_width = width;
		width = (size_t)(*leftp + *rightp);
		for (y = 0; y < height; y++) {
			(*linesp)[y] = realloc((*linesp)[y], width);
			if (!(*linesp)[y]) {
				perror("realloc");
				exit(1);
			}
			memmove(&(*linesp)[y][width - old_width], (*linesp)[y], old_width);
			memset((*linesp)[y], 0, width - old_width);
		}
	}
	xpos += (size_t)*leftp;

	if (right > *rightp) {
		*rightp = right;
		old_width = width;
		width = (size_t)(*leftp + *rightp);
		for (y = 0; y < height; y++) {
			(*linesp)[y] = realloc((*linesp)[y], width);
			if (!(*linesp)[y]) {
				perror("realloc");
				exit(1);
			}
			memset(&(*linesp)[y][old_width], 0, width - old_width);
		}
	}

	if (mtx.character_ascent > *ascentp) {
		*ascentp = mtx.character_ascent;
		old_height = height;
		height = (size_t)(*ascentp + *descentp);
		*linesp = realloc(*linesp, height * sizeof(**linesp));
		memmove(&(*linesp)[height - old_height], *linesp, old_height * sizeof(**linesp));
		for (y = 0; y < height - old_height; y++) {
			(*linesp)[y] = NULL;
			if (width) {
				(*linesp)[y] = calloc(width, 1);
				if (!(*linesp)[y]) {
					perror("calloc");
					exit(1);
				}
			}
		}
	}

	if (mtx.character_descent > *descentp) {
		*descentp = mtx.character_descent;
		old_height = height;
		height = (size_t)(*ascentp + *descentp);
		*linesp = realloc(*linesp, height * sizeof(**linesp));
		for (y = old_height; y < height; y++) {
			(*linesp)[y] = NULL;
			if (width) {
				(*linesp)[y] = calloc(width, 1);
				if (!(*linesp)[y]) {
					perror("calloc");
					exit(1);
				}
			}
		}
	}

	padding = font.bitmaps.row_padding - 1;
	packing = font.bitmaps.bit_packing - 1;
	width = (size_t)((int32_t)mtx.right_side_bearing - (int32_t)mtx.left_side_bearing);
	height = (size_t)((int32_t)mtx.character_ascent + (int32_t)mtx.character_descent);
	row_size = width / 8 + !!(width & 7);
	row_size = row_size + ((font.bitmaps.row_padding - (row_size & padding)) & padding);

	if (libparsepcf_get_bitmap_offsets(file, len, font.bitmap_table, &font.bitmaps, &bitmap_offset, glyph, 1)) {
		perror("libparsepcf_get_bitmap_offsets");
		exit(1);
	}
	bitmap_size = font.bitmaps.bitmap_size - bitmap_offset;
	bitmap = &font.bitmaps.bitmap_data[bitmap_offset];
	if (height && row_size > bitmap_size / height) {
		perror("bitmap is smaller than expected");
		exit(1);
	}

	ypos = (size_t)(*ascentp - mtx.character_ascent);
	for (y = 0; y < height; y++, bitmap += row_size) {
		for (x = 0; x < width; x++) {
			bit = font.bitmaps.lsbit ? 7 - x % 8 : x % 8;
			byte = x / 8;
			if (!font.bitmaps.lsbyte)
				byte = ((byte & ~packing) | (packing - (byte & packing)));
			if ((bitmap[byte] >> bit) & 1)
				(*linesp)[y + ypos][x + xpos] |= 1;
		}
	}
}


static void
print_line(const char *str)
{
	const uint8_t *s = (const void *)str;
	int32_t xpos = 0, left = 0, right = 0, ascent = 0, descent = 0;
	char **lines = NULL;
	uint32_t codepoint = 0, hi, lo;
	size_t glyph, n = 0, y, x, width, height;

	while (*s) {
		/* Very sloppy UTF-8 decoding */
		if (n) {
			if ((*s & 0xC0) != 0x80) {
				n = 0;
				glyph = (size_t)font.encoding.default_char;
				goto have_glyph;
			} else {
				n -= 1;
				codepoint <<= 6;
				codepoint |= *s++ & 0x3F;
			}
		} else if ((*s & 0xC0) == 0x80) {
			glyph = (size_t)font.encoding.default_char;
			s++;
			goto have_glyph;
		} else if (*s & 0x80) {
			codepoint = (uint32_t)*s++;
			n = 0;
			while (codepoint & 0x80) {
				codepoint <<= 1;
				n += 1;
			}
			codepoint &= 0xFF;
			codepoint >>= n--;
			continue;
		} else {
			codepoint = (uint32_t)*s++;
		}

		/* Map codepoint to glyph index */
		if (font.encoding.min_byte1 || font.encoding.max_byte1) {
			if (codepoint > UINT32_C(0xFFFF) ||
			    codepoint < (uint32_t)font.encoding.min_byte2 ||
			    codepoint > (uint32_t)font.encoding.max_byte2) {
				glyph = (size_t)font.encoding.default_char;
				goto have_glyph;
			}
			glyph = codepoint - (uint32_t)font.encoding.min_byte2;
		} else {
			hi = (codepoint >> 8) & UINT32_C(0xFF);
			lo = (codepoint >> 0) & UINT32_C(0xFF);
			if (codepoint > UINT32_C(0xFF) ||
			    hi < (uint32_t)font.encoding.min_byte1 ||
			    hi > (uint32_t)font.encoding.max_byte1 ||
			    lo < (uint32_t)font.encoding.min_byte2 ||
			    lo > (uint32_t)font.encoding.max_byte2) {
				glyph = (size_t)font.encoding.default_char;
				goto have_glyph;
			}
			hi -= (size_t)font.encoding.min_byte1;
			lo -= (size_t)font.encoding.min_byte2;
			glyph = hi * (size_t)(font.encoding.max_byte2 - font.encoding.min_byte2 + 1) + lo;
		}
		/* For the purpose of the demo we are assuming ASCII/UCS-2 */
		if (libparsepcf_get_glyph_indices(file, len, font.enc_table, &font.encoding, &glyph, glyph, 1)) {
			perror("libparsepcf_get_glyph_indices");
			exit(1);
		}

	have_glyph:
		if (glyph == LIBPARSEPCF_NOT_ENCODED)
			glyph = (size_t)font.encoding.default_char;

		draw_glyph(glyph, &xpos, &lines, &left, &right, &ascent, &descent);
	}

	width = (size_t)(left + right);
	height = (size_t)(ascent + descent);
	for (y = 0; y < height; y++) {
		if ((int64_t)y + 1 == (int64_t)ascent)
			printf("\033[4m");
		for (x = 0; x < width; x++)
			printf("\033[%sm[]", lines[y][x] ? "1;37" : "1;30");
		printf("\033[0m\n");
		free(lines[y]);
	}
	free(lines);
}


int
main(int argc, char *argv[])
{
	size_t glyph;
	if (argc) {
		argc--;
		argv++;
	}
	load_file();
	if (!argc) {
		print_font();
	} else {
		if (libparsepcf_preparse_font(file, len, &font)) {
			perror("libparsepcf_preparse_font");
			exit(1);
		}
		if (argc == 2 && !strcmp(argv[0], "-g")) {
			glyph = (size_t)strtoul(argv[1], NULL, 0);
			print_glyph(glyph);
		} else if (argc == 2 && !strcmp(argv[0], "-x")) {
			glyph = (size_t)strtoul(argv[1], NULL, 16);
			print_glyph(glyph);
		} else {
			printf("This demo assumes the font uses ASCII or UCS-2 encoding\n");
			for (; argc--; argv++) {
				print_line(*argv);
				printf("\n");
			}
		}
		libparsepcf_destroy_preparsed_font(&font);
	}
	free(file);
	return 0;
}