/* uuterm, Copyright (C) 2006 Rich Felker; licensed under GNU GPL v2 only */

/* note: the following implementation of ucf is NOT SECURE. malicious or
 * damaged files can cause it to crash or possibly enter into an infinite
 * loop, or cause other parts of the process core to be read as a font,
 * possibly leading to information leaks. however there is no possibility
 * of privilege elevation as ucf never writes to memory.
 *
 * users needing a robust implementation would be advised to simply run a
 * sanity check across the whole font file before accepting it, rather than
 * incurring large bounds-checking penalties at each glyph lookup.
 */

#include <stddef.h>
#include <string.h>
#include "ucf.h"

#define U24(p) ( ((p)[0]<<16) | ((p)[1]<<8) | (p)[2] )
#define U32(p) ( ((p)[0]<<24) | U24((p)+1) )

int ucf_init(struct ucf *f, const unsigned char *map, size_t len)
{
	size_t n;
	if (memcmp(map, "ucf\300\000\001\000\000", 8))
		return -1;
	f->w = map[8];
	f->h = map[9];
	f->s = (f->w+7)>>3;
	f->S = f->s * f->h;
	f->ranges = map + U32(map+20) + 4;
	f->gmap = map + U32(map+24);
	f->glyphs = map + U32(map+28);
	f->nglyphs = (len - (f->glyphs - map)) / f->S;
	f->ctab = f->ranges + 8*(f->nranges = U32(f->ranges - 4));
	return 0;
}

#define GMAP_WIDTH         1

#define GMAP_FINAL1        0
#define GMAP_FINAL2        1
#define GMAP_GLYPH1        2
#define GMAP_GLYPH2        3

#define RULE_RANGE         4
#define RULE_ATTACHED_TO   5
#define RULE_WITH_ATTACHED 6
#define RULE_FOLLOWS       7
#define RULE_PRECEDES      8

#define CTAB_MASK          0x3fffffff
#define CTAB_INDIRECT      0x80000000
#define CTAB_WIDTH         30

int ucf_lookup(struct ucf *f, int idx, const unsigned *cc,
	const unsigned *pc, const unsigned *nc, int width)
{
	unsigned ch = cc[idx];
	unsigned a, l, x, i;
	const unsigned *c;
	const unsigned char *p;

	for (p=f->ranges, a=0; ch>=(a+=U32(p)); p+=8) {
		if (ch-a < (l=U32(p+4))) {
			x = U32(f->ctab+4*(a-1));
			if (x>>30 != width-1)
				return -1;
			return (x & 0x3fffffff) + (ch-a)*width;
		}
		ch -= l;
	}
	x = U32(f->ctab+4*ch);
	if (!((x+1) & CTAB_INDIRECT)) {
		if (x>>CTAB_WIDTH != width-1) return -1;
		return x & CTAB_MASK;
	}
	x &= 0x7fffffff;
	i = idx;
	c = cc;
	for (p=f->gmap+x; ; p+=4) {
		if (*p <= GMAP_GLYPH2) {
			if ((*p & GMAP_WIDTH) == width-1) break;
			else if (*p <= GMAP_FINAL2) return -1;
			i = idx; c = cc;
			continue;
		}
		x = *p;
		a = U24(p+1);
		if (p[4] == RULE_RANGE) {
			p += 4;
			l = U24(p+1);
		} else l = 1;
		switch (x) {
		case RULE_ATTACHED_TO:
			if (i > idx) i = idx;
			if (i && c[--i]-a < l) continue;
			break;
		case RULE_WITH_ATTACHED:
			if (i < idx) i = idx;
			if (c[++i]-a < l) continue;
			break;
		case RULE_FOLLOWS:
			if ((c=pc)[i=0]-a < l) continue;
			break;
		case RULE_PRECEDES:
			if ((c=nc)[i=0]-a < l) continue;
			break;
		}
		/* Skip until the next mapping */
		for (; *p > GMAP_GLYPH2; p+=4);
		i = idx; c = cc;
	}
	return U24(p+1);
}

#if 0
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i, j;
	struct ucf f;
	static char tmp[1000000];
	ucf_init(&f, tmp, fread(tmp, 1, sizeof tmp, stdin));
	for (i=1; i<argc; i++) {
		unsigned x[5] = { strtol(argv[i], NULL, 16), 0 };
		int g;
		if (i+1<argc) x[1] = strtol(argv[i+1], NULL, 16);
		printf("char %.4x maps to glyph %d\n", x[1], g=ucf_lookup(&f, 1, x, x+4, x+4, 1));
		if (g >= 0) for (j=0; j<16; j++)
			printf("%.2X", f.glyphs[16*g+j]);
		printf("\n");
	}
	return 0;
}
#endif