ttf/ttf2.c

static u8
read_8(struct font_buffer *buf)
{
    u8 result = buf->data[buf->offset]; 
    buf->offset += 1;
    return(result);
}

static s8
read_8s(struct font_buffer *buf)
{
    s8 result = buf->data[buf->offset]; 
    buf->offset += 1;
    return(result);
}

static u16
be16(u8 *buf)
{
    u16 result = buf[0] << 8 | buf[1];
    return(result);
}

static s16
be16s(u8 *buf)
{
    s16 result = buf[0] << 8 | buf[1];
    return(result);
}

static u16
read_be16(struct font_buffer *buf)
{
    u16 result = be16(buf->data + buf->offset);
    buf->offset += 2;
    return(result);
}

static s16
read_be16s(struct font_buffer *buf)
{
    s16 result = be16s(buf->data + buf->offset);
    buf->offset += 2;
    return(result);
}

static u32
be32(u8 *buf)
{
    u32 result = ((u32) buf[0] << 24) | ((u32) buf[1] << 16) | ((u32) buf[2] << 8) | ((u32) buf[3]); 
    return(result);
}

static u32
read_be32(struct font_buffer *buf)
{
    u32 result = be32(buf->data + buf->offset);
    buf->offset += 4;
    return(result);
}

static f32
read_be214(struct font_buffer *buf)
{
    f32 result = read_be16s(buf) / 16384.0f;
    return(result);
}

static struct font_buffer
read_file(char *filename)
{
    FILE *file = fopen(filename, "rb");
    struct font_buffer result = { 0 };
    
    ASSERT(file);
    
    if (file) {
        fseek(file, 0, SEEK_END);
        result.size = ftell(file);
        result.data = malloc(result.size);
        fseek(file, 0, SEEK_SET);
        fread(result.data, result.size, 1, file);
        fclose(file);
    }
    
    return(result);
}

static u32
get_glyph_index_format12(struct ttf_font *font, u16 codepoint)
{
    u32 ngroups = be32(font->file.data + font->dir.cmap_offset + 12);
    
    font->file.offset = font->dir.cmap_offset + 16;
    
    // TODO: binsearch
    for (u32 g = 0; g < ngroups; ++g) {
        u32 start_charcode = read_be32(&font->file);
        u32 end_charcode = read_be32(&font->file);
        u32 start_glyphcode = read_be32(&font->file);
        
        if (start_charcode <= codepoint && codepoint <= end_charcode) {
            u32 glyph_index = start_glyphcode + (codepoint - start_charcode);
            return(glyph_index);
        }
        
        if (start_charcode > codepoint) {
            break;
        }
    }
    
    return(0);
}

static s16
get_glyph_index_format4(struct ttf_font *font, u16 codepoint)
{
    int segcount_x2 = be16(font->file.data + font->dir.cmap_offset + 6);
    
    u16 *end_codes = (u16 *) (font->file.data + font->dir.cmap_offset + 16);
    u16 *start_codes = (u16 *) (font->file.data + font->dir.cmap_offset + 16 + segcount_x2 + 2);
    u16 *id_deltas = (u16 *) (font->file.data + font->dir.cmap_offset + 16 + segcount_x2 * 2 + 2);
    u16 *id_range_offset = (u16 *) (font->file.data + font->dir.cmap_offset + 16 + segcount_x2 * 3 + 2);
    
    int index = -1;
    
    for (int i = 0; i < segcount_x2 / 2; ++i) {
        u16 end_code = be16((u8 *) (end_codes + i));
		if (end_code >= codepoint) {
            index = i;
            break;
        }
	}
	
	if (index == -1) {
        return(0);
    }
    
    u16 start_code = be16((u8 *) (start_codes + index));
	if (start_code <= codepoint) {
        u16 ir_offset = be16((u8 *) (id_range_offset + index));
		if (ir_offset != 0) {
			u16 glyph_index = be16((u8 *) (id_range_offset 
                                           + index + ir_offset / 2 
                                           + (codepoint - start_code)));
            
			if (!glyph_index) {
                return(0);
            }
			
            u16 id_delta = be16((u8 *) (id_deltas + index));
            u16 result = (u16) (glyph_index + id_delta);
            
            return(result);
		}
        
        u16 id_delta = be16((u8 *) (id_deltas + index));
        u16 result = (u16) (codepoint + id_delta);
        
        return(result);
	}
    
	return(0);
}

static u16
get_glyph_index_format6(struct ttf_font *font, u16 codepoint)
{
    u16 first_code = be16(font->file.data + font->dir.cmap_offset + 6);
    u16 entry_count = be16(font->file.data + font->dir.cmap_offset + 8);
    u16 *glyph_index_array = (u16 *) (font->file.data + font->dir.cmap_offset + 10);
    
    if (first_code <= codepoint && codepoint < first_code + entry_count) {
        u16 glyph_index = be16((u8 *) (glyph_index_array + (codepoint - first_code)));
        return(glyph_index);
    }
    
    return(0);
}

static u16
get_glyph_index_format0(struct ttf_font *font, u16 codepoint)
{
    u8 *glyph_index_array = font->file.data + font->dir.cmap_offset + 6;
    
    if (codepoint <= 0xFF) {
        u8 glyph_index = glyph_index_array[codepoint];
        return(glyph_index);
    }
    
    return(0);
}

static u32
get_glyph_index(struct ttf_font *font, u16 codepoint) 
{
    u32 result = 0;
    
    switch (font->cmap_format) {
        case 0: {
            result = get_glyph_index_format0(font, codepoint);
            break;
        }
        
        case 12: {
            result = get_glyph_index_format12(font, codepoint);
            break;
        }
        
        case 6: {
            result = get_glyph_index_format6(font, codepoint);
            break;
        }
        
        case 4: {
            result = get_glyph_index_format4(font, codepoint);
            break;
        }
        
        default: {
            ASSERT(false);
        }
    }
    
    return(result);
}

static u32
get_glyph_offset(struct ttf_font *font, u32 glyph_index)
{
    u32 offset = 0;
    u32 offset_next;
    
    if (font->head.itl_format == 1) {
        font->file.offset = font->dir.loca_offset + glyph_index * 4;
        offset = read_be32(&font->file);
        offset_next = read_be32(&font->file);
    } else {
        font->file.offset = font->dir.loca_offset + glyph_index * 2;
        offset = read_be16(&font->file);
        offset *= 2;
        offset_next = read_be16(&font->file);
        offset_next *= 2;
    }
    
    if (offset == offset_next) {
        return(0);
    }
    
    return(offset);
}

static s16
get_current_coordinate(struct font_buffer *font_file, int flag_combined)
{
    s16 current_coordinate = 0;
    
    switch (flag_combined) {
        case 0: {
            current_coordinate = read_be16(font_file);
            break;
        }
        
        case 1: { 
            current_coordinate = 0; 
            break;
        }
        
        case 2: { 
            current_coordinate = read_8(font_file);
            current_coordinate *= -1;
            break;
        }
        
        case 3: { 
            current_coordinate = read_8(font_file);
            break;
        } 
    }
    
    return(current_coordinate);
}

static inline u32
pop(struct ttf_graphics_state *state)
{
    u32 result = state->stack[state->stack_head - 1];
    --state->stack_head;
    return(result);
}

static inline f32
popf(struct ttf_graphics_state *state)
{
    u32 integer = state->stack[state->stack_head - 1];
    --state->stack_head;
    f32 result;
    memcpy(&result, &integer, sizeof(f32));
    return(result);
}

static inline void
push(struct ttf_graphics_state *state, u32 value)
{
    state->stack[state->stack_head] = value;
    ++state->stack_head;
}

static u32
skip_until(struct font_buffer *font_file, u32 start, u32 size, enum ttf_instruction until)
{
    u32 result = -1; // -1 means not found
    
    u32 base = start;
    u32 offset = start;
    
    while (offset - base < size) {
        enum ttf_instruction inst = font_file->data[offset];
        
        if (inst == until) {
            result = offset;
            break;
        }
        
        ++offset;
        
        // thankfully, ONLY push instructions take data from the instructin stream
        if (inst == NPUSHB) {
            u8 n = font_file->data[offset++];
            offset += n;
        } else if (inst == NPUSHW) {
            u8 n = font_file->data[offset++];
            offset += n * 2;
        } else if (PUSHB <= inst && inst <= PUSHB_TOP) {
            u8 n = inst - PUSHB + 1;
            offset += n;
        } else if (PUSHW <= inst && inst <= PUSHW_TOP) {
            u8 n = inst - PUSHW + 1;
            offset += n * 2;
        }
    }
    
    return(result);
}

static struct v2u32
find_if_pair(struct font_buffer *font_file, u32 start, u32 size)
{
    // Find matching ELSE and EIF for an IF, -1 means not found
    struct v2u32 result = { -1, -1 };
    
    u32 base = start;
    u32 offset = start;
    u32 depth = 1;
    
    while (offset - base < size) {
        enum ttf_instruction inst = font_file->data[offset++];
        
        if (inst == NPUSHB) {
            u8 n = font_file->data[offset++];
            offset += n;
        } else if (inst == NPUSHW) {
            u8 n = font_file->data[offset++];
            offset += n * 2;
        } else if (PUSHB <= inst && inst <= PUSHB_TOP) {
            u8 n = inst - PUSHB + 1;
            offset += n;
        } else if (PUSHW <= inst && inst <= PUSHW_TOP) {
            u8 n = inst - PUSHW + 1;
            offset += n * 2;
        } else if (inst == IF) {
            ++depth;
        } else if (inst == ELSE) {
            if (depth == 1) {
                result.x = offset;
            }
        } else if (inst == EIF) {
            if (depth == 1) {
                result.y = offset;
                break;
            } else {
                --depth;
            }
        }
    }
    
    return(result);
}

static s16
funits_to_pixels(u32 funits)
{
    // TODO
    return(funits);
}

static void
iterate_instructions(struct ttf_font *font, struct font_buffer *font_file, u32 offset, u32 size, struct ttf_graphics_state *state)
{
    const struct v2f X_AXIS = { 1.0f, 0.0f };
    const struct v2f Y_AXIS = { 0.0f, 1.0f };
    
    u32 base_offset = offset;
    u32 n_fdefs = 0;
    
    int function_define = -1;
    int if_true = 0;
    
    while (offset - base_offset < size) {
        enum ttf_instruction inst = font_file->data[offset++];
        
        if (function_define >= 0 && inst != ENDF) {
            continue;
        }
        
        if (offset == 13622) {
            int __sdfsdf = 0;
        }
        
#if 0
        printf("%6d: ", offset);
        printf("%s\n", ttfe_instruction_name(inst));
#endif
        
        switch (inst) {
            case NPUSHB: {
                u8 n = font_file->data[offset++];
                for (int b = 0; b < n; ++b) {
                    u8 b = font_file->data[offset++];
                    push(state, b);
                }
                break;
            }
            
            case NPUSHW: {
                u8 n = font_file->data[offset++];
                for (int b = 0; b < n; ++b) {
                    u16 word = be16(font_file->data + offset);
                    offset += 2;
                    push(state, word);
                }
                break;
            }
            
            case PUSHB ... PUSHB_TOP: {
                u8 overflow = inst - PUSHB;
                int abc = overflow + 1;
                
                for (int i = 0; i < abc; ++i) {
                    u8 b = font_file->data[offset++];
                    push(state, b);
                }
                
                break;
            }
            
            case PUSHW ... PUSHW_TOP: {
                u8 overflow = inst - PUSHW;
                int abc = overflow + 1;
                
                for (int i = 0; i < abc; ++i) {
                    u16 word = be16(font_file->data + offset);
                    offset += 2;
                    push(state, word);
                }
                
                break;
            }
            
            case RS: {
                u32 location = pop(state);
                u32 value = font->storage[location];
                push(state, value);
                break;
            }
            
            case WS: {
                u32 value = pop(state);
                u32 location = pop(state);
                font->storage[location] = value;
                break;
            }
            
            case WCVTP: {
                u32 value = pop(state);
                u32 location = pop(state);
                s16 cvt_value = value;
                assert(location <= font->dir.cvt_size / sizeof(s16));
                font->cvt[location] = cvt_value;
                break;
            }
            
            case WCVTF: {
                u32 value = pop(state);
                u32 location = pop(state);
                s16 cvt_value = funits_to_pixels(value);
                assert(location <= font->dir.cvt_size / sizeof(s16));
                font->cvt[location] = cvt_value;
                break;
            }
            
            case RCVT: {
                u32 location = pop(state);
                assert(location <= font->dir.cvt_size / sizeof(s16));
                s16 integer = font->cvt[location];
                push(state, integer);
                break;
            }
            
            case SVTCA ... SVTCA_TOP: {
                u8 overflow = inst - SVTCA;
                int a = overflow;
                
                if (a == 0) {
                    state->projection_vector = Y_AXIS;
                    state->freedom_vector = Y_AXIS;
                } else if (a == 1) {
                    state->projection_vector = X_AXIS;
                    state->freedom_vector = X_AXIS;
                }
                
                break;
            }
            
            case SPVTCA ... SPVTCA_TOP: {
                u8 overflow = inst - SPVTCA;
                int a = overflow;
                
                if (a == 0) {
                    state->projection_vector = Y_AXIS;
                } else if (a == 1) {
                    state->projection_vector = X_AXIS;
                }
                
                break;
            }
            
            case SFVTCA ... SFVTCA_TOP: {
                u8 overflow = inst - SFVTCA;
                int a = overflow;
                
                if (a == 0) {
                    state->freedom_vector = Y_AXIS;
                } else if (a == 1) {
                    state->freedom_vector = X_AXIS;
                }
                
                break;
            }
            
            case SPVTL ... SPVTL_TOP: {
                u8 overflow = inst - SFVTCA;
                int a = overflow;
                
                u32 p1 = pop(state);
                u32 p2 = pop(state);
                
                
                
                break;
            }
            
            case SFVTL ... SFVTL_TOP: {
                break;
            }
            
            case SFVTPV: {
                break;
            }
            
            case SDPVTL ... SDPVTL_TOP: {
                break;
            }
            
            case SPVFS: {
                u32 y = pop(state);
                u32 x = pop(state);
                // TODO: convert to 2.14 fixed point
                break;
            }
            
            case SFVFS: {
                break;
            }
            
            case GPV: {
                break;
            }
            
            case GFV: {
                break;
            }
            
            case SRP0: {
                break;
            }
            
            case SRP1: {
                break;
            }
            
            case SRP2: {
                break;
            }
            
            case SZP0: {
                break;
            }
            
            case SZP1: {
                break;
            }
            
            case SZP2: {
                break;
            }
            
            case SZPS: {
                break;
            }
            
            case RTHG: {
                break;
            }
            
            case RTG: {
                state->round_state = 1;
                break;
            }
            
            case RTDG: {
                break;
            }
            
            case RDTG: {
                break;
            }
            
            case RUTG: {
                break;
            }
            
            case ROFF: {
                break;
            }
            
            case SROUND: {
                break;
            }
            
            case S45ROUND: {
                break;
            }
            
            case SLOOP: {
                break;
            }
            
            case SMD: {
                break;
            }
            
            case INSTCTRL: {
                break;
            }
            
            case SCANCTRL: {
                // TODO: turn dropout control (state->scan_control) on or off
                u32 n = pop(state);
                break;
            }
            
            case SCANTYPE: {
                // TODO: dropout control mode
                u32 val = pop(state);
                u16 n = (u16) val;
                break;
            }
            
            case SCVTCI: {
                u32 cut_in_64th = pop(state);
                f32 cut_in = cut_in_64th / 64.0f;
                state->control_value_cut_in = cut_in;
                break;
            }
            
            case SSWCI: {
                break;
            }
            
            case SSW: {
                break;
            }
            
            case FLIPON: {
                break;
            }
            
            case FLIPOFF: {
                break;
            }
            
            case SANGW: {
                break;
            }
            
            case SDB: {
                break;
            }
            
            case SDS: {
                break;
            }
            
            case GC_ ... GC_TOP: {
                break;
            }
            
            case SCFS: {
                break;
            }
            
            case MD ... MD_TOP: {
                break;
            }
            
            case MPPEM: {
                /* (funit -> px) scale = pointSize * resolution / ( 72 points per inch * units_per_em ) */
                /* 1em = units_per_em funits */
                /* 1em = scale * units_per_em pixels */
                
                u32 dpi = 96; // TODO: query system
                u32 point_size = 12; // TODO: pass as parameter
                u16 ppem = point_size * dpi / 72;
                
                push(state, ppem);
                
                break;
            }
            
            case MPS: {
                break;
            }
            
            case FLIPPT: {
                break;
            }
            
            case FLIPRGON: {
                break;
            }
            
            case FLIPRGOFF: {
                break;
            }
            
            case SHP ... SHP_TOP: {
                break;
            }
            
            case SHC ... SHC_TOP: {
                u8 overflow = inst - SHC;
                u32 c = pop(state);
                // TODO
                break;
            }
            
            case SHZ ... SHZ_TOP: {
                u8 overflow = inst - SHZ;
                u32 e = pop(state);
                // TODO
                break;
            }
            
            case SHPIX: {
                break;
            }
            
            case MSIRP ... MSIRP_TOP: {
                u8 overflow = inst - MSIRP;
                f32 d = popf(state);
                u32 p = pop(state);
                // TODO
                break;
            }
            
            case MDAP ... MDAP_TOP: {
                break;
            }
            
            case MIAP ... MIAP_TOP: {
                // 0: don’t round the distance and don’t look at the control_value_cut_in
                // 1: round the distance and look at the control_value_cut_in
                int a = inst - MIAP;
                
                assert(state->stack_head  >= 2);
                
                u32 n = pop(state); // CVT entry number
                u32 p = pop(state); // point number
                
                // TODO
                
                break;
            }
            
            case MDRP ... MDRP_TOP: {
                break;
            }
            
            case MIRP ... MIRP_TOP: {
                break;
            }
            
            case ALIGNRP: {
                break;
            }
            
            case ISECT: {
                break;
            }
            
            case ALIGNPTS: {
                break;
            }
            
            case IP: {
                u32 p = pop(state);
                // TODO
                break;
            }
            
            case UTP: {
                u32 p = pop(state);
                // TODO
                break;
            }
            
            case IUP ... IUP_TOP: {
                u8 overflow = inst - IUP;
                break;
            }
            
            case DELTAP1: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 pi = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DELTAP2: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 pi = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DELTAP3: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 pi = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DELTAC1: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 ci = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DELTAC2: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 ci = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DELTAC3: {
                u32 n = pop(state);
                for (u32 i = 0; i < n; ++i) {
                    u32 ci = pop(state);
                    u32 argi = pop(state);
                    // TODO
                }
                break;
            }
            
            case DUP: {
                u32 e = pop(state);
                push(state, e);
                push(state, e);
                break;
            }
            
            case POP: {
                --state->stack_head;
                break;
            }
            
            case CLEAR: {
                state->stack_head = 0;
                break;
            }
            
            case SWAP: {
                assert(state->stack_head >= 2);
                
                u32 last = state->stack[state->stack_head - 1];
                u32 prelast = state->stack[state->stack_head - 2];
                
                state->stack[state->stack_head - 2] = last;
                state->stack[state->stack_head - 1] = prelast;
                
                break;
            }
            
            case DEPTH: {
                break;
            }
            
            case CINDEX: {
                break;
            }
            
            case MINDEX: {
                break;
            }
            
            case ROLL: {
                break;
            }
            
            case IF: {
                struct v2u32 pair = find_if_pair(font_file, offset, size - (offset - base_offset));
                
                if_true = pop(state);
                
                if (!if_true) {
                    assert(pair.x != (u32) -1 || pair.y != (u32) -1);
                    offset = MIN(pair.x, pair.y);
                }
                
                break;
            }
            
            case ELSE: {
                if (if_true) {
                    offset = skip_until(font_file, offset, size - (offset - base_offset), EIF);
                    assert(offset != (u32) -1);
                }
                
                break;
            }
            
            case EIF: {
                break;
            }
            
            case JROT: {
                break;
            }
            
            case JMPR: {
                break;
            }
            
            case JROF: {
                break;
            }
            
            case LT: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 less = (e1 < e2 ? 1 : 0);
                push(state, less);
                break;
            }
            
            case LTEQ: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 leq = (e1 <= e2 ? 1 : 0);
                push(state, leq);
                break;
            }
            
            case GT: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 gt = (e1 > e2 ? 1 : 0);
                push(state, gt);
                break;
            }
            
            case GTEQ: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 geq = (e1 >= e2 ? 1 : 0);
                push(state, geq);
                break;
            }
            
            case EQ: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 equal = (e1 == e2 ? 1 : 0);
                push(state, equal);
                break;
            }
            
            case NEQ: {
                u32 e2 = pop(state);
                u32 e1 = pop(state);
                u32 neq = (e1 != e2 ? 1 : 0);
                push(state, neq);
                break;
            }
            
            case ODD: {
                u32 e1 = pop(state);
                u32 odd = e1 & 1;
                push(state, odd);
                break;
            }
            
            case EVEN: {
                u32 e1 = pop(state);
                u32 even = 1 - (e1 & 1);
                push(state, even);
                break;
            }
            
            case AND: {
                u32 e1 = pop(state);
                u32 e2 = pop(state);
                u32 and = (e1 & e2 ? 1 : 0);
                push(state, and);
                break;
            }
            
            case OR: {
                u32 e1 = pop(state);
                u32 e2 = pop(state);
                u32 or = (e1 | e2 ? 1 : 0);
                push(state, or);
                break;
            }
            
            case NOT: {
                u32 e1 = pop(state);
                u32 not = (e1 ? 0 : 1);
                push(state, not);
                break;
            }
            
            case ADD: {
                f32 n1 = popf(state);
                f32 n2 = popf(state);
                f32 add = n2 + n1;
                push(state, add);
                break;
            }
            
            case SUB: {
                f32 n1 = popf(state);
                f32 n2 = popf(state);
                f32 sub = n2 - n1;
                push(state, sub);
                break;
            }
            
            case DIV: {
                f32 n1 = popf(state);
                f32 n2 = popf(state);
                f32 div = n2 / n1;
                push(state, div);
                break;
            }
            
            case MUL: {
                f32 n1 = popf(state);
                f32 n2 = popf(state);
                f32 mul = n2 * n1;
                push(state, mul);
                break;
            }
            
            case ABS: {
                f32 n1 = popf(state);
                f32 abs = fabsf(n1);
                push(state, abs);
                break;
            }
            
            case NEG: {
                f32 n1 = popf(state);
                f32 neg = -n1;
                push(state, neg);
                break;
            }
            
            case FLOOR: {
                f32 n1 = popf(state);
                f32 floor = floorf(n1);
                push(state, floor);
                break;
            }
            
            case CEILING: {
                f32 n1 = popf(state);
                f32 ceil = ceilf(n1);
                push(state, ceil);
                break;
            }
            
            case MAX: {
                u32 e1 = pop(state);
                u32 e2 = pop(state);
                u32 max = (e1 > e2 ? e1 : e2);
                push(state, max);
                break;
            }
            
            case MIN: {
                u32 e1 = pop(state);
                u32 e2 = pop(state);
                u32 min = (e1 < e2 ? e1 : e2);
                push(state, min);
                break;
            }
            
            case ROUND ... ROUND_TOP: {
                u8 overflow = inst - ROUND;
                u32 n1 = pop(state);
                // TODO: do rounding
                push(state, n1);
                break;
            }
            
            case NROUND ... NROUND_TOP: {
                break;
            }
            
            case FDEF: {
                int f = state->stack[--state->stack_head];
                font->functions[f].from = offset;
                function_define = f;
                break;
            }
            
            case ENDF: {
                font->functions[function_define].to = offset - 1; // NOTE: do not include ENDF in subproc
                function_define = -1;
                break;
            }
            
            case CALL: {
                int f = state->stack[--state->stack_head];
                assert(f <= font->maxp.max_fdefs);
                struct ttf_function proc = font->functions[f];
                iterate_instructions(font, font_file, proc.from, proc.to - proc.from, state);
                break;
            }
            
            case LOOPCALL: {
                break;
            }
            
            case IDEF: {
                break;
            }
            
            case DEBUG: {
                break;
            }
            
            case GETINFO: {
                // TODO?
                int selector = pop(state);
                push(state, 0);
                break;
            }
            
            case GETVARIATION: {
                break;
            }
            
            default: {
                printf("Unknown ttf instruction %x\n", inst);
                __builtin_trap();
            }
        }
    }
}

static void
get_simple_glyph_points(struct font_buffer *font_file, u16 number_of_countours, struct glyph *result)
{
    u16 *end_pts_of_contours = calloc(1, number_of_countours * sizeof(u16));
    for (int c = 0; c < number_of_countours; ++c) {
        end_pts_of_contours[c] = read_be16(font_file);
    }
    
    // NOTE: skip instructions
    u16 instruction_length = read_be16(font_file);
    struct ttf_graphics_state glyph_state = default_graphics_state();
    //iterate_instructions(font, font_file, font_file->offset, instruction_length, &glyph_state);
    font_file->offset += instruction_length;
    
    int last_index = end_pts_of_contours[number_of_countours - 1];
    union glyph_flag *flags = calloc(1, last_index + 1);
    struct glyph_point *points = malloc((last_index + 2) * 2 * sizeof(struct v2));
    
    // NOTE: so that we can insert one point at the start if needed
    // points = points + 1;
    
    for (int i = 0; i < last_index + 1; ++i) {
        flags[i].flag = read_8(font_file);
        if (flags[i].repeat) {
            u8 repeat_count = read_8(font_file);
            while (repeat_count-- > 0) {
                i++;
                flags[i] = flags[i - 1];
            }
        }
    }
    
    s16 prev_coordinate = 0;
    int start = 0;
    int head = 0;
    
    for (int c = 0; c < number_of_countours; ++c) {
        int end = end_pts_of_contours[c];
        struct glyph_point first_point = { 0 };
        
        for (int i = start; i < end + 1; ++i) {
            // NOTE: read x coordinates
            int flag_combined = (flags[i].x_short << 1) | flags[i].x_short_pos;
            s16 current_coordinate = get_current_coordinate(font_file, flag_combined);
            s16 read_x = current_coordinate + prev_coordinate;
            
            int prev = i - 1;
            if (prev >= start) {
                //prev = end;
                
                if (!flags[i].on_curve && !flags[prev].on_curve) {
                    // NOTE: implicit on-curve point
                    points[head].on_curve = true;
                    points[head].x = (read_x + points[head - 1].x) / 2;
                    ++head;
                }
            }
            
            points[head].on_curve = flags[i].on_curve;
            points[head].x = read_x;
            ++head;
            
            if (i == start) {
                // NOTE: first iteration could not have inserted an implicit point
                first_point = points[head - 1];
            }
            
            prev_coordinate = read_x;
        }
        
        if (!flags[start].on_curve && !flags[end].on_curve) {
            points[head].on_curve = true;
            points[head].x = (first_point.x + points[head - 1].x) / 2;
            ++head;
        }
        
        start = end + 1;
    }
    
    
    prev_coordinate = 0;
    start = 0;
    head = 0;
    
    int added_points = 0;
    
    for (int c = 0; c < number_of_countours; ++c) {
        int end = end_pts_of_contours[c];
        struct glyph_point first_point = { 0 };
        
        for (int i = start; i < end + 1; ++i) {
            // NOTE: read y coordinates
            int flag_combined = (flags[i].y_short << 1) | flags[i].y_short_pos;
            s16 current_coordinate = get_current_coordinate(font_file, flag_combined);
            s16 read_y = current_coordinate + prev_coordinate;
            
            int prev = i - 1;
            if (prev >= start) {
                //prev = end;
                
                if (!flags[i].on_curve && !flags[prev].on_curve) {
                    // NOTE: implicit on-curve point
                    points[head].on_curve = true;
                    points[head].y = (read_y + points[head - 1].y) / 2;
                    ++head;
                    ++added_points;
                }
            }
            
            points[head].on_curve = flags[i].on_curve;
            points[head].y = read_y;
            ++head;
            
            prev_coordinate = read_y;
            
            if (i == start) {
                // NOTE: first iteration could not have inserted an implicit point
                first_point = points[head - 1];
            }
        }
        
        if (!flags[start].on_curve && !flags[end].on_curve) {
            points[head].on_curve = true;
            points[head].y = (first_point.y + points[head - 1].y) / 2;
            ++head;
            ++added_points;
        }
        
        start = end + 1;
        end_pts_of_contours[c] += added_points;
    }
    
    
    result->points = points;
    result->ncontours = number_of_countours;
    result->end_pts_of_contours = end_pts_of_contours;
}

static struct glyph
get_glyph_outline(struct ttf_font *font, u32 glyph_index)
{
    u32 glyph_offset = get_glyph_offset(font, glyph_index);
    struct font_buffer *font_file = &font->file;
    
    font_file->offset = font->dir.glyf_offset + glyph_offset;
    
    struct glyph result = { 0 };
    s16 number_of_countours = read_be16(font_file);
    
    result.xmin = read_be16(font_file);
    result.ymin = read_be16(font_file);
    result.xmax = read_be16(font_file);
    result.ymax = read_be16(font_file);
    
    if (number_of_countours > 0) {
        // NOTE: simple glyph
        get_simple_glyph_points(font_file, number_of_countours, &result);
    } else if (number_of_countours < 0) {
        // NOTE: compund glyph
        int head = 0;
        
        result.end_pts_of_contours = malloc(font->maxp.max_component_contours * sizeof(u16));
        result.points = malloc(font->maxp.max_component_points * 2 * sizeof(struct glyph_point));
        
        for (;;) {
            u16 flags = read_be16(font_file);
            u16 component_index = read_be16(font_file);
            
            f32 matrix[6] = {1, 0, 0, 1, 0, 0}; /* NOTE(aolo2): matrix stuff is highjacked from stb */
            
            if (flags & ARG_1_AND_2_ARE_WORDS) {
                matrix[4] = read_be16(font_file);
                matrix[5] = read_be16(font_file);
            } else {
                matrix[4] = read_8s(font_file);
                matrix[5] = read_8s(font_file);
            }
            
            if (flags & WE_HAVE_A_SCALE) {
                f32 scale = read_be214(font_file);
                matrix[0] = scale;
                matrix[1] = 0;
                matrix[2] = 0;
                matrix[3] = scale;
            } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE ) {
                f32 xscale = read_be214(font_file);
                f32 yscale = read_be214(font_file);
                matrix[0] = xscale;
                matrix[1] = 0;
                matrix[2] = 0;
                matrix[3] = yscale;
            } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
                f32 xscale = read_be214(font_file);
                f32 scale01 = read_be214(font_file);
                f32 scale10 = read_be214(font_file);
                f32 yscale = read_be214(font_file);
                matrix[0] = xscale;
                matrix[1] = scale01;
                matrix[2] = scale10;
                matrix[3] = yscale;
            }
            
            f32 m = sqrtf(matrix[0] * matrix[0] + matrix[1] * matrix[1]);
            f32 n = sqrtf(matrix[2] * matrix[2] + matrix[3] * matrix[3]);
            
            u32 saved_offset = font_file->offset;
            struct glyph component = get_glyph_outline(font, component_index);
            font_file->offset = saved_offset;
            
            int startv = 0;
            for (int c = 0; c < component.ncontours; ++c) {
                int endv = component.end_pts_of_contours[c] + 1;
                
                for (int v = startv; v < endv; ++v) {
                    s16 x = component.points[v].x;
                    s16 y = component.points[v].y;
                    
                    result.points[head].x = m * (matrix[0] * x + matrix[2] * y + matrix[4]);
                    result.points[head].y = n * (matrix[1] * x + matrix[3] * y + matrix[5]);
                    result.points[head].on_curve = component.points[v].on_curve;
                    ++head;
                }
                
                startv = endv;
                result.end_pts_of_contours[result.ncontours] = head - 1;
                ++result.ncontours;
            }
            
            if (!(flags & MORE_COMPONENTS)) {
                break;
            }
        }
    } else {
        // NOTE: space
        //advance = 0; // TODO
    }
    
    return(result);
}

static void
get_hmtx(struct ttf_font *font, u32 glyph_index, struct glyph *dest)
{
    struct font_buffer font_file = font->file;
    
    if (font->is_monospace) {
        font_file.offset = font->dir.hmtx_offset;
    } else {
        font_file.offset = font->dir.hmtx_offset + glyph_index * 4;
    }
    
    dest->advance = read_be16(&font_file);
    dest->lsb = read_be16s(&font_file);
}

static int
get_string_width(struct ttf_font *font, int px_size, wchar_t *string, int length)
{
    int result = 0;
    struct glyph g = { 0 };
    f32 scale = (f32) px_size / ((f32) (font->hhea.ascent - font->hhea.descent));
    
    for (int i = 0; i < length; ++i) {
        u16 codepoint = string[i];
        u32 glyph_index = get_glyph_index(font, codepoint);
        get_hmtx(font, glyph_index, &g);
        result += ceil_f32(scale * g.advance); // NOTE(aolo2): ceil each time because that's what the rasterizing code does
    }
    
    return(result);
}

static struct glyph
get_outline(struct ttf_font *font, u16 codepoint)
{
    u32 glyph_index = get_glyph_index(font, codepoint);
    
    struct glyph result = get_glyph_outline(font, glyph_index);
    get_hmtx(font, glyph_index, &result);
    
    int xmin = result.xmin;
    int ymin = result.ymin;
    //int ymin = result.ymin;
    
    for (int p = 0; p < result.end_pts_of_contours[result.ncontours - 1] + 1; ++p) {
        struct glyph_point *gp = result.points + p;
        gp->x -= xmin;
        gp->y -= ymin;
    }
    
    result.baseline = - (int) result.ymin;
    result.xmin = 0;
    result.xmax -= xmin;
    result.ymin = 0;
    result.ymax -= result.ymin;
    
    return(result);
}

static u16
read_offset_table(struct font_buffer *file)
{
    u16 num_tables = be16(file->data + 4);
    return(num_tables);
}

static struct font_directory
read_font_directory(struct font_buffer *file)
{
    struct font_directory result = { 0 };
    u16 table_count = read_offset_table(file);
    
    for (int i = 0; i < table_count; ++i) {
        u32 tag = be32(file->data + 12 + 16 * i + 0);
        u32 offset = be32(file->data + 12 + 16 * i + 8);
        u32 length = be32(file->data + 12 + 16 * i + 12);
        
        switch (tag) {
            case 0x636d6170: {
                /* cmap */
                result.cmap_offset = offset;
                break;
            }
            
            case 0x63767420: {
                /* cvt */
                result.cvt_offset = offset;
                result.cvt_size = length;
                break;
            }
            
            case 0x70726570: {
                /* prep */
                result.prep_offset = offset;
                result.prep_size = length;
                break;
            }
            
            case 0x6670676d: {
                /* fpgm */
                result.fpgm_offset = offset;
                result.fpgm_size = length;
                break;
            }
            
            case 0x6c6f6361: {
                /* loca */
                result.loca_offset = offset;
                break;
            }
            
            case 0x68656164: {
                /* head */
                result.head_offset = offset;
                break;
            }
            
            case 0x676c7966: {
                /* glyf */
                result.glyf_offset = offset;
                break;
            }
            
            case 0x686d7478: {
                /* hmtx */
                result.hmtx_offset = offset;
                break;
            }
            
            case 0x6d617870: {
                /* maxp */
                result.maxp_offset = offset;
                break;
            }
            
            case 0x68686561: {
                /* hhea */
                result.hhea_offset = offset;
                break;
            }
            
            case 0x706f7374: {
                /* post */
                result.post_offset = offset;
            }
        }
    }
    
    return(result);
}

static void
read_head(struct font_directory font_dir, struct ttf_font *font)
{
    font->head.units_per_em = be16(font->file.data + font_dir.head_offset + 18);
    font->head.itl_format = be16(font->file.data + font_dir.head_offset + 50);
}

static void
read_hhea(struct font_directory font_dir, struct ttf_font *font)
{
    font->hhea.ascent = be16s(font->file.data + font_dir.hhea_offset + 4);
    font->hhea.descent = be16s(font->file.data + font_dir.hhea_offset + 6);
    font->hhea.line_gap = be16s(font->file.data + font_dir.hhea_offset + 10);
    font->hhea.max_advance = be16(font->file.data + font_dir.hhea_offset + 14);
}

static void
read_cmap(struct font_directory font_dir, struct ttf_font *font)
{
    font->file.offset = font_dir.cmap_offset + 2;
    
    u16 num_tables = read_be16(&font->file);
    
    for (int st = 0; st < num_tables; ++st) {
        u16 platform_id = read_be16(&font->file);
        u16 platform_specific_id = read_be16(&font->file);
        u32 subtable_offset = read_be32(&font->file);
        
        if ((platform_id == 0 && (platform_specific_id == 3 || platform_specific_id == 4)) ||
            (platform_id == 3 && ((platform_specific_id == 1 || platform_specific_id == 10))))
        {
            font->cmap_format = be16(font->file.data + font_dir.cmap_offset + subtable_offset);
            font->dir.cmap_offset = font_dir.cmap_offset + subtable_offset;
        }
    }
}

static void
read_maxp(struct font_directory font_dir, struct ttf_font *font)
{
    font->maxp.max_component_points = be16(font->file.data + font_dir.maxp_offset + 10);
    font->maxp.max_component_contours = be16(font->file.data + font_dir.maxp_offset + 12);
    font->maxp.max_storage = be16(font->file.data + font_dir.maxp_offset + 18);
    font->maxp.max_fdefs = be16(font->file.data + font_dir.maxp_offset + 20);
}

static void
read_fpgm(struct ttf_font *font, struct font_buffer *font_file, struct font_directory font_dir, struct ttf_graphics_state *state)
{
    iterate_instructions(font, font_file, font_dir.fpgm_offset, font_dir.fpgm_size, state);
}

static void
read_cvt(struct ttf_font *font, struct font_buffer *font_file, struct font_directory font_dir, struct ttf_graphics_state *state)
{
    iterate_instructions(font, font_file, font_dir.prep_offset, font_dir.prep_size, state);
}

static void
read_post(struct font_directory font_dir, struct ttf_font *font)
{
    if (font_dir.post_offset) {
        font->is_monospace = be32(font->file.data + font_dir.post_offset + 12);
    } else {
        printf("Warning: font file doesn't have a 'post' table. Assuming font is proportional\n");
        font->is_monospace = 0;
    }
}

static struct ttf_font
parse_ttf_file(char *filename, char *fontname)
{
    struct ttf_font result = { 0 };
    struct font_buffer font_file = read_file(filename);
    struct font_directory font_dir = read_font_directory(&font_file);
    
    result.file = font_file;
    result.dir = font_dir;
    result.dir.glyf_offset = font_dir.glyf_offset;
    result.dir.loca_offset = font_dir.loca_offset;
    result.dir.hmtx_offset = font_dir.hmtx_offset;
    result.cvt = (s16 *) (font_file.data + font_dir.cvt_offset);
    
    read_head(font_dir, &result);
    read_post(font_dir, &result);
    read_maxp(font_dir, &result);
    read_cmap(font_dir, &result);
    read_hhea(font_dir, &result);
    
    if (result.maxp.max_fdefs) {
        result.functions = malloc(result.maxp.max_fdefs * sizeof(struct ttf_function));
    }
    
    if (result.maxp.max_storage) {
        result.storage = malloc(result.maxp.max_storage * sizeof(struct ttf_function));
    }
    
    //struct ttf_graphics_state fpgm_state = default_graphics_state();
    //struct ttf_graphics_state prep_state = default_graphics_state();
    
    //read_fpgm(&result, &font_file, font_dir, &fpgm_state); // the font program
    //printf("------------- FPGM END -------------\n");
    //read_cvt(&result, &font_file, font_dir, &prep_state);  // the cvt program
    //printf("------------- CVT END -------------\n");
    
    result.name = fontname;
    
    return(result);
}