/* Copyright (C) 2001-2026 Artifex Software, Inc.

   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or

   implied.

   This software is distributed under license and may not be copied,

   modified or distributed except as expressly authorized under the terms

   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* plchar.c */

/* PCL font handling library -- operations on individual characters */

#include "math_.h"

#include "memory_.h"

#include "stdio_.h"             /* for gdebug.h */

#include "gdebug.h"

#include "gserrors.h"

#include "gstypes.h"

#include "gsmemory.h"

#include "gsstruct.h"

#include "gsmatrix.h"

#include "gsstate.h"

#include "gschar.h"

#include "gsimage.h"

#include "gspaint.h"

#include "gspath.h"

#include "gsbittab.h"

#include "gxarith.h"            /* for igcd */

#include "gxfont.h"

#include "gxfont42.h"

#include "plfont.h"

#include "plvalue.h"

#include "gscoord.h"

#include "gsstate.h"

#include "gxdevice.h"

#include "gxdevmem.h"

#include "gxpath.h"

/* We really shouldn't need the following, but currently they are needed */

/* for pgs->path and penum->log2_current_scale in pl_tt_build_char. */

#include "gxfixed.h"

#include "gxchar.h"

#include "gxfcache.h"

#include "gxttf.h"

#include "gzstate.h"

#include "gxfapi.h" /* for gx_fapi_bits_smear_horizontally and gx_fapi_bits_merge */

#include "plchar.h"

/* include the prototype for pixmap_high_level_pattern */

#include "gsptype1.h"

#include "gsgstate.h"

#include "gxgstate.h"

/* Define whether to cache TrueType characters. */

/* This would only be disabled for debugging. */

#define CACHE_TRUETYPE_CHARS

#define IF_COMPOUND_CHAR_LIMIT 8

/* Structure descriptors */

gs_private_st_ptrs1(st_pl_font_glyph, pl_font_glyph_t, "pl_font_glyph_t",

                    pl_font_glyph_enum_ptrs, pl_font_glyph_reloc_ptrs, data);

gs_private_st_element(st_pl_font_glyph_element, pl_font_glyph_t,

                      "pl_font_glyph_t[]",

                      pl_font_glyph_elt_enum_ptrs,

                      pl_font_glyph_elt_reloc_ptrs, st_pl_font_glyph);

int

pl_prepend_xl_dummy_header(gs_memory_t * mem, byte ** ppheader)

{

    return 0;

}

int

pl_swap_header(byte * header, uint gifct)

{

    return 0;

}

/* ---------------- Utilities ---------------- */

/* Look up a glyph in a font.  Return a pointer to the glyph's slot */

/* (data != 0) or where it should be added (data == 0). */

pl_font_glyph_t *

pl_font_lookup_glyph(const pl_font_t * plfont, gs_glyph glyph)

{

    uint size = plfont->glyphs.size;

    uint skip = plfont->glyphs.skip;

    uint index = glyph % size;

    pl_font_glyph_t *pfg;

    pl_font_glyph_t *result = 0;

    while ((pfg = plfont->glyphs.table + index)->data ?

           pfg->glyph != glyph : pfg->glyph != 0) {

        if (!pfg->data)

            result = pfg;

        index = (index >= skip ? index : index + size) - skip;

    }

    return (!pfg->data && result) ? result : pfg;

}

/* ---------------- Bitmap font support ---------------- */

/* Encode a character for a bitmap font.  This is simple, because */

/* bitmap fonts are always bound. */

static gs_glyph

pl_bitmap_encode_char(gs_font * pfont, gs_char chr, gs_glyph_space_t not_used)

{

    return (gs_glyph) chr;

}

/* Get character existence and escapement for a bitmap font. */

/* This is simple for the same reason. */

static int

pl_bitmap_char_width(const pl_font_t * plfont, const void *pgs,

                     gs_char char_code, gs_point * pwidth)

{

    const byte *cdata = pl_font_lookup_glyph(plfont, char_code)->data;

    pwidth->x = pwidth->y = 0;

    if (cdata == 0) {

        return 1;

    }

    if (cdata[0] == 0) {        /* PCL XL characters don't have an escapement. */

        pwidth->x = pwidth->y = 0;

        return 0;

    }

    {

        const byte *params = cdata + 6;

        pwidth->x = (plfont->header[13] ?       /* variable pitch */

                     pl_get_int16(params + 8) * 0.25 :

                     pl_get_int16(params) /*lsb */ +pl_get_int16(params +

                                                                 4) /*width */

                     );

    }

    return 0;

}

static int

pl_bitmap_char_metrics(const pl_font_t * plfont, const void *pgs,

                       gs_char char_code, float metrics[4])

{

    gs_point width;

    const byte *cdata = pl_font_lookup_glyph(plfont, char_code)->data;

    /* never a vertical substitute */

    metrics[0] = metrics[1] = metrics[2] = metrics[3] = 0;

    /* no data - character not found */

    if (cdata == 0)

        return 1;

    /* We are not concerned about PCL XL characters */

    if (cdata[0] == 0)

        return 0;

    metrics[0] = (float)pl_get_int16(cdata + 6);

    pl_bitmap_char_width(plfont, pgs, char_code, &width);

    metrics[2] = width.x;

    return 0;

}

/*

 * For pseudo-bolding, we have to "smear" a bitmap horizontally and

 * vertically by ORing together a rectangle of bits below and to the left of

 * each output bit.  We do this separately for horizontal and vertical

 * smearing.  Eventually, we will replace the current procedure, which takes

 * time proportional to W * H * (N + log2(N)), with one that is only

 * proportional to N (but takes W * N additional buffer space).

 */

/* Allocate the line buffer for bolding.  We need 2 + bold scan lines. */

static byte *

alloc_bold_lines(gs_memory_t * mem, uint width, int bold, client_name_t cname)

{

    return gs_alloc_byte_array(mem, 2 + bold, bitmap_raster(width + bold),

                               cname);

}

/* Image a bitmap character, with or without bolding. */

int

pl_image_bitmap_char(gs_image_enum * ienum, const gs_image_t * pim,

                     const byte * bitmap_data, uint sraster, int bold,

                     byte * bold_lines, gs_gstate * pgs)

{

    uint dest_bytes = (pim->Width + 7) >> 3;

    int code;

    gs_image_enum *penum;

    uint used;

    code = gx_set_dev_color(pgs);

    if (code == gs_error_Remap_Color)

        code = pixmap_high_level_pattern(pgs);

    if (code != 0)

        return code;

    penum = gs_image_enum_alloc(gs_gstate_memory(pgs), "pl_image_bitmap_char");

    if (penum == NULL)

        return_error(gs_error_VMerror);

    code = gs_image_init(penum, pim, pim->ImageMask | pim->CombineWithColor, true, pgs);

    if (code < 0)

        goto free_penum_and_exit;

    if (bold) {                 /* Pass individual smeared lines. */

        uint src_width = pim->Width - bold;

        uint src_height = pim->Height - bold;

        uint dest_raster = bitmap_raster(pim->Width);

        int n1 = bold + 1;

#define merged_line(i) (bold_lines + ((i) % n1 + 1) * dest_raster)

        int y;

        for (y = 0; y < pim->Height; ++y) {

            int y0 = (y < bold ? 0 : y - bold);

            int y1 = min(y + 1, src_height);

            if (y < src_height) {

                gx_fapi_bits_smear_horizontally(merged_line(y),

                                        bitmap_data + y * sraster,

                                        src_width, bold);

                {               /* Now re-establish the invariant -- see below. */

                    int kmask = 1;

                    for (; (y & kmask) == kmask && y - kmask >= y0;

                         kmask = (kmask << 1) + 1)

                        gx_fapi_bits_merge(merged_line(y - kmask),

                                   merged_line(y - (kmask >> 1)), dest_bytes);

                }

            }

            /*

             * As of this point in the loop, we maintain the following

             * invariant to cache partial merges of groups of lines: for

             * each Y, y0 <= Y < y1, let K be the maximum k such that Y

             * mod 2^k = 0 and Y + 2^k < y1; then merged_line(Y) holds

             * the union of horizontally smeared source lines Y through

             * Y + 2^k - 1.  The idea behind this is similar to the idea

             * of quicksort.

             */

            {                   /* Now construct the output line. */

                bool first = true;

                int iy;

                for (iy = y1 - 1; iy >= y0; --iy) {

                    int kmask = 1;

                    while ((iy & kmask) == kmask && iy - kmask >= y0)

                        iy -= kmask, kmask <<= 1;

                    if (first) {

                        memcpy(bold_lines, merged_line(iy), dest_bytes);

                        first = false;

                    } else

                        gx_fapi_bits_merge(bold_lines, merged_line(iy), dest_bytes);

                }

            }

            code = gs_image_next(penum, bold_lines, dest_bytes, &used);

            if (code != 0)

                break;

        }

#undef merged_line

    } else {                    /* Pass the entire image at once. */

        int i;

        for (i = 0; i < pim->Height; i++) {

            code = gs_image_next(penum, bitmap_data, dest_bytes, &used);

            if (code < 0)

                break;

            bitmap_data += sraster;

        }

    }

free_penum_and_exit:

    {

        int code2 = gs_image_cleanup_and_free_enum(penum, pgs);

        if (code == 0)

            code = code2;

    }

    return code;

}

/* Render a character for a bitmap font. */

/* This handles both format 0 (PCL XL) and format 4 (PCL5 bitmap). */

static int

pl_bitmap_build_char(gs_show_enum * penum, gs_gstate * pgs, gs_font * pfont,

                     gs_char chr, gs_glyph glyph)

{

    pl_font_t *plfont = (pl_font_t *) pfont->client_data;

    const byte *cdata = pl_font_lookup_glyph(plfont, glyph)->data;

    bool orient = plfont->orient;

    if (cdata == 0) {

        return gs_setcharwidth(penum, pgs, 0, 0);

    } else {

        const byte *params;

        const byte *bitmap_data;

        int lsb, ascent;

        float delta_x;

        gs_image_t image;

        gs_image_enum *ienum;

        int code;

        uint bold;

        byte *bold_lines = 0;

        if (cdata[0] == 0) {    /* PCL XL format */

            params = cdata + 2;

            bitmap_data = cdata + round_up(10, ARCH_ALIGN_PTR_MOD);

            delta_x = 0;        /* irrelevant */

            lsb = pl_get_int16(params);

            ascent = pl_get_int16(params + 2);

        } else {                /* PCL5 format */

            params = cdata + 6;

            bitmap_data = cdata + 16;

            delta_x = (plfont->header[13] ?     /* variable pitch */

                       pl_get_int16(params + 8) * 0.25 :

                       (short)(pl_get_int16(params) /*lsb */

                               +pl_get_int16(params + 4)) /*width */ );

            lsb = pl_get_int16(params);

            ascent = pl_get_int16(params + 2);

        }

        ienum = gs_image_enum_alloc(pgs->memory, "pl_bitmap_build_char");

        if (ienum == 0)

            return_error(gs_error_VMerror);

        gs_image_t_init_mask(&image, true);

        image.Width = pl_get_uint16(params + 4);

        image.Height = pl_get_uint16(params + 6);

        /* Determine the amount of pseudo-bolding. */

        if (plfont->bold_fraction != 0) {

            if (image.Height < image.Width)

                bold = (uint) (2 * image.Height * plfont->bold_fraction + 0.5);

            else

                bold = (uint) (2 * image.Width * plfont->bold_fraction + 0.5);

            bold_lines = alloc_bold_lines(pgs->memory, image.Width, bold,

                                          "pl_bitmap_build_char(bold_line)");

            if (bold_lines == 0) {

                code = gs_note_error(gs_error_VMerror);

                goto out;

            }

            image.Width += bold;

            image.Height += bold;

            ascent += bold;

        } else

            bold = 0;

        gs_make_identity(&image.ImageMatrix);

        gs_matrix_rotate(&image.ImageMatrix, orient * -90,

                         &image.ImageMatrix);

        image.ImageMatrix.tx -= lsb;

        image.ImageMatrix.ty += ascent;

        image.adjust = true;

        if (bold || orient != 0)

            code = gs_setcharwidth(penum, pgs, delta_x, 0);

        else {

            /* we use cache device for portrait bitmap fonts to

               avoid image setup overhead.  */

            float m[6];

            m[0] = delta_x;

            m[1] = 0;

            m[2] = (float)lsb;

            m[3] = (float)(image.Height - ascent);

            m[4] = image.Width + m[2];

            m[5] = (float)(-ascent);

            code = gs_setcachedevice(penum, pgs, m);

        }

        if (code < 0)

            goto out;

#ifdef DEBUG

        if (gs_debug_c('B')) {

            int i;

            int pixels = round_up(image.Width, 8) * image.Height;

            dmprintf7(pgs->memory,

                      "bitmap font data chr=%ld, width=%d, height=%d, lsb=%d, ascent=%d, top offset=%d left offset=%d\n",

                      chr, image.Width, image.Height, lsb, ascent,

                      pl_get_int16(params + 2), pl_get_int16(params));

            for (i = 0; i < pixels; i++) {

                if (i % round_up(image.Width, 8) == 0)

                    dmprintf(pgs->memory, "\n");

                dmprintf1(pgs->memory, "%d",

                          bitmap_data[i >> 3] & (128 >> (i & 7)) ? 1 : 0);

            }

            dmprintf(pgs->memory, "\n");

        }

#endif

        code = pl_image_bitmap_char(ienum, &image, bitmap_data,

                                    (image.Width - bold + 7) >> 3, bold,

                                    bold_lines, pgs);

      out:gs_free_object(pgs->memory, bold_lines,

                       "pl_bitmap_build_char(bold_lines)");

        gs_free_object(pgs->memory, ienum, "pl_bitmap_build_char");

        return (code < 0 ? code : 0);

    }

}

/* ---------------- TrueType font support ---------------- */

/* Look up a character in the TrueType character-to-TT-glyph map. */

/* Return a pointer to the glyph's slot (chr != gs_no_char) or where */

/* it should be added (chr == gs_no_char). */

pl_tt_char_glyph_t *

pl_tt_lookup_char(const pl_font_t * plfont, gs_glyph glyph)

{

    uint size = plfont->char_glyphs.size;

    uint skip = plfont->char_glyphs.skip;

    uint index = glyph % size;

    pl_tt_char_glyph_t *ptcg;

    pl_tt_char_glyph_t *result = 0;

    while ((ptcg = plfont->char_glyphs.table + index)->chr != gs_no_char ?

           ptcg->chr != glyph : ptcg->glyph) {

        if (ptcg->chr == gs_no_char)

            result = ptcg;

        index = (index >= skip ? index : index + size) - skip;

    }

    return (result ? result : ptcg);

}

/* Get a string from a TrueType font. */

static int

pl_tt_string_proc(gs_font_type42 * pfont, ulong offset, uint length,

                  const byte ** pdata)

{

    pl_font_t *plfont = pfont->client_data;

    *pdata = plfont->header + plfont->offsets.GT +

        (plfont->large_sizes ? 6 : 4) + offset;

    if (((*pdata) + length) > plfont->header + plfont->header_size)

        return_error(gs_error_invalidfont);

    return 0;

}

/* Return the vertical substitute for a glyph, if it has one; */

/* otherwise return GS_NO_GLYPH. */

gs_glyph

pl_font_vertical_glyph(gs_glyph glyph, const pl_font_t * plfont)

{

    long VT = plfont->offsets.VT;

    const byte *vtseg;

    uint i, len;

    if (VT < 0)

        return GS_NO_GLYPH;

    vtseg = plfont->header + VT;

    if (plfont->large_sizes)

        len = pl_get_uint32(vtseg + 2), i = 6;

    else

        len = pl_get_uint16(vtseg + 2), i = 4;

    len += i;

    for (; i < len; i += 4)

        if (glyph == pl_get_uint16(vtseg + i))

            return pl_get_uint16(vtseg + i + 2);

    return GS_NO_GLYPH;

}

/* retrieve lsb and width metrics for Format 1 Class 2 glyphs */

int

pl_tt_f1c2_get_metrics(gs_font_type42 * pfont, uint glyph_index,

                  int wmode, float *sbw)

{

    int code = gs_error_undefined;

    pl_font_t *plfont = pfont->client_data;

    const pl_font_glyph_t *pfg = 0;

    const byte *cdata = 0;

    if (plfont->glyphs.table != 0) {

        /* at least one caller calls before the glyph.table is valid, no chars yet

         * test routes caller to gs_type42_default_get_metrics

         */

        pfg = pl_font_lookup_glyph(plfont, glyph_index);

        cdata = pfg->data;

        if (cdata && (cdata[1] == 1 || cdata[1] == 2)) {

            double factor = 1.0 / pfont->data.unitsPerEm;

            uint width;

            int lsb;

            lsb = pl_get_int16(cdata + 4);

            width = pl_get_int16(cdata + 6);

            /* foo NB what about the top side bearing in class 2 ? */

            if (wmode) {

                /* NB BUG all other fonts work without this sign

                   change it should already be accounted for in the

                   character ctm */

                factor = -factor;       /* lsb and width go down the page */

                sbw[0] = 0, sbw[1] = lsb * factor;

                sbw[2] = 0, sbw[3] = width * factor;

            } else {

                sbw[0] = lsb * factor, sbw[1] = 0;

                sbw[2] = width * factor, sbw[3] = 0;

            }

            code = 0;           /* tt class 1,2 */

        }

    }

    return code;

}

/* get metrics with support for XL tt class 1 and 2

 * pl overrides gstype42_default_get_metrics

 */

static int

pl_tt_get_metrics(gs_font_type42 * pfont, uint glyph_index,

                  gs_type42_metrics_options_t options, float *sbw)

{

    int wmode = gs_type42_metrics_options_wmode(options);

    int code;

    if ((code = pl_tt_f1c2_get_metrics (pfont, glyph_index, wmode, sbw)) != gs_error_undefined) {

        return code;

    }

    /* else call default implementation for tt class 0, incomplete font */

    /* first check for a vertical substitute if writing mode is

       vertical.  We unpleasantly replace the glyph_index parameter

       passed to procedure to be consist with the pl_tt_build_char()

       debacle */

    {

        pl_font_t *plfont = pfont->client_data;

        if (plfont->allow_vertical_substitutes) {

            gs_glyph vertical = pl_font_vertical_glyph(glyph_index, plfont);

            if (vertical != GS_NO_GLYPH)

                glyph_index = vertical;

        }

    }

    /* the graphics library does not do this correctly.  If there

       aren't two sets of metrics WMode should be ignored.  We work

       around that here. */

    if (wmode == 1) {

        const gs_type42_mtx_t *pmtx = &pfont->data.metrics[wmode];

        if (pmtx->length == 0) {

            wmode = 0;

        } else {

            if (gs_debug_c('=')) {

                dmprintf(pfont->memory, "Found vertical metrics\n");

            }

        }

    }

    return gs_type42_default_get_metrics(pfont, glyph_index, wmode, sbw);

}

/* Get the outline data for a glyph in a downloaded TrueType font. */

int

pl_tt_get_outline(gs_font_type42 * pfont, uint index, gs_glyph_data_t * pdata)

{

    pl_font_t *plfont = pfont->client_data;

    const pl_font_glyph_t *pfg = pl_font_lookup_glyph(plfont, index);

    const byte *cdata = pfg->data;

    if (cdata == 0) {

        /* undefined glyph */

        gs_glyph_data_from_null(pdata);

    } else {

        uint desc_size =

            (*cdata == 15 ? cdata[2] /* PCL5 */ : 0 /* PCL XL */ );

        uint data_size = pl_get_uint16(cdata + 2 + desc_size);

        if (data_size > pfg->data_len)

            data_size = pfg->data_len;

        if (data_size <= 4) {

            /* empty outline */

            gs_glyph_data_from_null(pdata);

        } else if (cdata[1] == 0 && (6 + desc_size + data_size - 4) <= pfg->data_len) {

            gs_glyph_data_from_bytes(pdata, cdata, 6 + desc_size, data_size - 4, NULL);

        } else if (cdata[1] == 1 && (10 + data_size - 8) <= pfg->data_len) {

            gs_glyph_data_from_bytes(pdata, cdata, 10, data_size - 8, NULL);

        } else if (cdata[1] == 2 && (12 + data_size - 10) <= pfg->data_len) {

            gs_glyph_data_from_bytes(pdata, cdata, 12, data_size - 10, NULL);

        }

        else {

            /* invalid, treat as empty outline */

            gs_glyph_data_from_null(pdata);

        }

    }

    return 0;

}

#define access(base, length, vptr)\

  (*pfont->data.string_proc)(pfont, (ulong)(base), length, &vptr)

/* Find a table in a TrueType font. */

/* Return the data offset of the table; store the length in *plen. */

/* If the table is missing, return 0. */

ulong

tt_find_table(gs_font_type42 * pfont, const char *tname, uint * plen)

{

    const byte *OffsetTable;

    uint numTables;

    const byte *TableDirectory;

    uint i;

    ulong table_dir_offset = 0;

    int code;

    if (((code = access(0, 12, OffsetTable)) < 0) ||

        ((code = access(table_dir_offset, 12, OffsetTable)) < 0))

        return 0;

    numTables = pl_get_uint16(OffsetTable + 4);

    if (access(table_dir_offset + 12, numTables * 16, TableDirectory) < 0)

        return 0;

    for (i = 0; i < numTables; ++i) {

        const byte *tab = TableDirectory + i * 16;

        if (!memcmp(tab, tname, 4)) {

            if (plen)

                *plen = pl_get_uint32(tab + 12);

            return pl_get_uint32(tab + 8);

        }

    }

    return 0;

}

/*

 * Map a key through a cmap sub-table.  We export this so we can use

 * it someday for mapping between glyph vocabularies.  If the key is

 * not mappable, return gs_error_undefined; if the sub-table type is

 * unknown, return gs_error_invalidfont.

 */

static int

pl_cmap_lookup(const uint key, const byte * table, size_t table_len, uint * pvalue)

{

    const byte *table_lim = table + table_len;

    /* Dispatch according to the table type. */

    switch (pl_get_uint16(table)) {

        case 0:

            {                   /* Apple standard 1-to-1 mapping. */

                if (table + key + 6 < table_lim) {

                    *pvalue = table[key + 6];

                    if_debug2('J', "[J]%u => %u\n", key, *pvalue);

                }

                else

                    return_error(gs_error_undefined);

                break;

            }

        case 4:

            {                   /* Microsoft/Adobe segmented mapping.  What a mess! */

                uint segCount2 = pl_get_uint16(table + 6);

                const byte *endCount = table + 14;

                const byte *startCount = endCount + segCount2 + 2;

                const byte *idDelta = startCount + segCount2;

                const byte *idRangeOffset = idDelta + segCount2;

                /*const byte *glyphIdArray = idRangeOffset + segCount2; */

                uint i2;

                if (idRangeOffset > table_lim)

                    return_error(gs_error_undefined);

                for (i2 = 0; i2 < segCount2 - 3; i2 += 2) {

                    int delta, roff;

                    uint start = pl_get_uint16(startCount + i2);

                    uint glyph;

                    if_debug4('J', "[J]start=%u end=%u delta=%d roff=%d\n",

                              start, pl_get_uint16(endCount + i2),

                              pl_get_int16(idDelta + i2),

                              pl_get_int16(idRangeOffset + i2));

                    if (key < start) {

                        if_debug1('J', "[J]%u out of range\n", key);

                        return_error(gs_error_undefined);

                    }

                    if (endCount + i2 + 2 > table_lim) {

                        break;

                    }

                    if (key > pl_get_uint16(endCount + i2))

                        continue;

                    if (idRangeOffset + i2 + 2 > table_lim) {

                        break;

                    }

                    delta = pl_get_int16(idDelta + i2);

                    roff = pl_get_int16(idRangeOffset + i2);

                    if (roff == 0) {

                        *pvalue = (key + delta) & 0xffff;       /* mod 65536 */

                        if_debug2('J', "[J]%u => %u\n", key, *pvalue);

                        return 0;

                    }

                    if ((2 + idRangeOffset + i2 + roff + ((key - start) << 1)) > table_lim) {

                        break;

                    }

                    glyph = pl_get_uint16(idRangeOffset + i2 + roff + ((key - start) << 1));

                    *pvalue = (glyph == 0 ? 0 : glyph + delta);

                    if_debug2('J', "[J]%u => %u\n", key, *pvalue);

                    return 0;

                }

                /*

                 * The TrueType documentation says that the last range is

                 * always supposed to end with 0xffff, so this shouldn't

                 * happen; however, in some real fonts, it does.

                 */

                if_debug1('J', "[J]%u out of range\n", key);

                return_error(gs_error_undefined);

            }

        case 6:

            {                   /* Single interval lookup. */

                uint firstCode;

                uint entryCount;

                if (table + 10 > table_lim) {

                    return_error(gs_error_undefined);

                }

                firstCode = pl_get_uint16(table + 6);

                entryCount = pl_get_uint16(table + 8);

                if (key < firstCode || key >= firstCode + entryCount) {

                    if_debug1('J', "[J]%u out of range\n", key);

                    return_error(gs_error_undefined);

                }

                if (table + 12 + ((key - firstCode) << 1) > table_lim) {

                    return_error(gs_error_undefined);

                }

                *pvalue =

                    pl_get_uint16(table + 10 + ((key - firstCode) << 1));

                if_debug2('J', "[J]%u => %u\n", key, *pvalue);

                break;

            }

        default:

            return_error(gs_error_invalidfont);

    }

    return 0;

}

/* Encode a character using the TrueType cmap tables. */

/* (We think this is never used for downloaded fonts.) */

static gs_glyph

pl_tt_cmap_encode_char(gs_font_type42 * pfont, ulong cmap_offset,

                       uint cmap_len, gs_char chr)

{

    const byte *cmap;

    const byte *cmap_sub;

    const byte *table;

    size_t table_len;

    uint value;

    int code;

    access(cmap_offset, cmap_len, cmap);

    /* Since the Apple cmap format is of no help in determining */

    /* the encoding, look for a Microsoft table; but if we can't */

    /* find one, take the first one. */

    cmap_sub = cmap + 4;

    {

        uint i;

        uint16_t ncmaps = pl_get_uint16(cmap + 2);

        if (ncmaps * 8 + 2 >= cmap_len)

            return GS_NO_GLYPH;

        for (i = 0; i < ncmaps; ++i) {

            if_debug3m('j', pfont->memory,

                       "[j]cmap %d: platform %u encoding %u\n", i,

                       pl_get_uint16(cmap_sub + i * 8),

                       pl_get_uint16(cmap_sub + i * 8 + 2));

            if (pl_get_uint16(cmap_sub + i * 8) == 3) {

                cmap_sub += i * 8;

                break;

            }

        }

    }

    {

        uint offset = cmap_offset + pl_get_uint32(cmap_sub + 4);

        table_len = cmap_offset + cmap_len - offset;

        access(offset, table_len, table);

    }

    code = pl_cmap_lookup((uint) chr, table, table_len, &value);

    return (code < 0 ? GS_NO_GLYPH : value);

}

/* Encode a character using the map built for downloaded TrueType fonts. */

static gs_glyph

pl_tt_dynamic_encode_char(const gs_font_type42 * pfont, gs_char chr)

{

    pl_font_t *plfont = pfont->client_data;

    const pl_tt_char_glyph_t *ptcg = pl_tt_lookup_char(plfont, chr);

    return (ptcg->chr == gs_no_char ? GS_NO_GLYPH : ptcg->glyph);

}

/* Return the galley character for a character code, if any; */

/* otherwise return gs_no_char. */

/* Note that we return 0xffff for a character that is explicitly */

/* designated as undefined. */

static gs_char

pl_font_galley_character(gs_char chr, const pl_font_t * plfont)

{

    long GC = plfont->offsets.GC;

    const byte *gcseg;

    uint b0, b1;

    uint i, len;

    uint default_char;

    if (GC < 0)

        return gs_no_char;

    gcseg = plfont->header + GC;

    if (plfont->large_sizes)

        len = pl_get_uint32(gcseg + 2), i = 12;

    else

        len = pl_get_uint16(gcseg + 2), i = 10;

    if (len != pl_get_uint16(gcseg + i - 2) * 6 + 6)    /* bad data */

        return gs_no_char;

    default_char = pl_get_uint16(gcseg + i - 4);        /* default character */

    len += i - 6;

    b0 = chr >> 8;

    b1 = chr & 0xff;

    for (; i < len; i += 6)

        if (b0 >= gcseg[i] && b0 <= gcseg[i + 1] &&

            b1 >= gcseg[i + 2] && b1 <= gcseg[i + 3]

            )

            return pl_get_uint16(gcseg + i + 4);

    return default_char;

}

/* Encode a character for a TrueType font. */

/* What we actually return is the TT glyph index.  Note that */

/* we may return either GS_NO_GLYPH or 0 for an undefined character. */

gs_glyph

pl_tt_encode_char(gs_font * pfont_generic, gs_char chr,

                  gs_glyph_space_t not_used)

{

    gs_font_type42 *pfont = (gs_font_type42 *) pfont_generic;

    uint cmap_len;

    ulong cmap_offset = tt_find_table(pfont, "cmap", &cmap_len);

    gs_glyph glyph = (cmap_offset == 0 ?

                      /* This is a downloaded font with no cmap. */

                      pl_tt_dynamic_encode_char(pfont, chr) :

                      pl_tt_cmap_encode_char(pfont, cmap_offset, cmap_len,

                                             chr));

    pl_font_t *plfont = pfont->client_data;

    pl_font_glyph_t *pfg;

    if (plfont->offsets.GC < 0)

        return glyph;           /* no substitute */

    pfg = pl_font_lookup_glyph(plfont, glyph);

    /* If the character is missing, use the galley character instead. */

    if (!pfg->data) {

        gs_char galley_char = pl_font_galley_character(chr, plfont);

        if (galley_char != gs_no_char) {

            return

                (galley_char == 0xffff ? 0 :

                 cmap_offset == 0 ?

                 pl_tt_dynamic_encode_char(pfont, galley_char) :

                 pl_tt_cmap_encode_char(pfont, cmap_offset, cmap_len,

                                        galley_char));

        }

    }

    return glyph;               /* no substitute */

}

/* Get metrics */

static int

pl_tt_char_metrics(const pl_font_t * plfont, const void *pgs,

                   gs_char char_code, float metrics[4])

{

    gs_glyph unused_glyph = GS_NO_GLYPH;

    gs_glyph glyph =

        pl_tt_encode_char(plfont->pfont, char_code, unused_glyph);

    if (glyph == GS_NO_GLYPH) {

        return 1;

    }

    return gs_type42_get_metrics((gs_font_type42 *) plfont->pfont,

                                 glyph, metrics);

}

/* Get character existence and escapement for a TrueType font. */

static int

pl_tt_char_width(const pl_font_t * plfont, const void *pgs, gs_char char_code,

                 gs_point * pwidth)

{

    gs_font *pfont = plfont->pfont;

    gs_char chr = char_code;

    gs_glyph unused_glyph = GS_NO_GLYPH;

    gs_glyph glyph = pl_tt_encode_char(pfont, chr, unused_glyph);

    int code;

    float sbw[4];

    pwidth->x = pwidth->y = 0;

    /* Check for a vertical substitute. */

    if (pfont->WMode & 1) {

        gs_glyph vertical = pl_font_vertical_glyph(glyph, plfont);

        if (vertical != GS_NO_GLYPH)

            glyph = vertical;

    }

    /* undefined character */

    if (glyph == 0xffff || glyph == GS_NO_GLYPH)

        return 1;

    code = gs_type42_get_metrics((gs_font_type42 *) pfont, glyph, sbw);

    if (code < 0)

        return code;

    /* character exists */

    pwidth->x = sbw[2];

    return 0;

}

/* Render a TrueType character. */

static int

pl_tt_build_char(gs_show_enum * penum, gs_gstate * pgs, gs_font * pfont,

                 gs_char chr, gs_glyph orig_glyph)

{

    gs_glyph glyph = orig_glyph;

#define pbfont ((gs_font_base *)pfont)

#define pfont42 ((gs_font_type42 *)pfont)

    int code;

    pl_font_t *plfont = (pl_font_t *) pfont->client_data;

    float bold_fraction =

        gs_show_in_charpath(penum) != cpm_show ? 0.0 : plfont->bold_fraction;

    uint bold_added;

    double scale = 1.0;

    float sbw[4], w2[6];

    int ipx = 0;

    int ipy = 0;

    int iqx, iqy;

    gx_device_memory *pmdev;

    bool ctm_modified = false;

    bool bold_device_created = false;

    gs_matrix save_ctm;

#define isDownloaded(p42) ((p42)->data.proc_data == 0)

#ifdef CACHE_TRUETYPE_CHARS

#  define tt_set_cache(penum, pgs, w2)\

     gs_setcachedevice(penum, pgs, w2)

#else

#  define tt_set_cache(penum, pgs, w2)\

     gs_setcharwidth(penum, pgs, w2[0], w2[1]);

#endif

    /* undefined */

    if (glyph == GS_NO_GLYPH)

        return 0;

    /* Get the metrics and set the cache device. */

    code = gs_type42_get_metrics(pfont42, glyph, sbw);

    if (code < 0)

        return code;

    w2[0] = sbw[2], w2[1] = sbw[3];

    /* Adjust the bounding box for stroking if needed. */

    {

        const gs_rect *pbbox = &pbfont->FontBBox;

        w2[2] = pbbox->p.x, w2[3] = pbbox->p.y;