/* Copyright (C) 2018-2025 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.

*/

/* Font operations for the PDF interpreter */

#include "pdf_int.h"

#include "pdf_font_types.h"

#include "pdf_gstate.h"

#include "pdf_file.h"

#include "pdf_dict.h"

#include "pdf_loop_detect.h"

#include "pdf_array.h"

#include "pdf_font.h"

#include "pdf_stack.h"

#include "pdf_misc.h"

#include "pdf_doc.h"

#include "pdf_font0.h"

#include "pdf_font1.h"

#include "pdf_font1C.h"

#include "pdf_font3.h"

#include "pdf_fontTT.h"

#include "pdf_fontmt.h"

#include "pdf_font0.h"

#include "pdf_fmap.h"

#include "gscencs.h"            /* For gs_c_known_encode and gs_c_glyph_name */

#include "gsagl.h"

#include "strmio.h"

#include "stream.h"

#include "gsstate.h"            /* For gs_setPDFfontsize() */

extern single_glyph_list_t SingleGlyphList[];

static int pdfi_gs_setfont(pdf_context *ctx, gs_font *pfont)

{

    int code = 0;

    pdfi_int_gstate *igs = (pdfi_int_gstate *)ctx->pgs->client_data;

    pdf_font *old_font = igs->current_font;

    code = gs_setfont(ctx->pgs, pfont);

    if (code >= 0) {

        igs->current_font = (pdf_font *)pfont->client_data;

        pdfi_countup(igs->current_font);

        pdfi_countdown(old_font);

    }

    return code;

}

static void pdfi_cache_resource_font(pdf_context *ctx, pdf_obj *fontdesc, pdf_obj *ppdffont)

{

    resource_font_cache_t *entry = NULL;

    int i;

    if (ctx->resource_font_cache == NULL) {

        ctx->resource_font_cache = (resource_font_cache_t *)gs_alloc_bytes(ctx->memory, RESOURCE_FONT_CACHE_BLOCK_SIZE * sizeof(pdfi_name_entry_t), "pdfi_cache_resource_font");

        if (ctx->resource_font_cache == NULL)

            return;

        ctx->resource_font_cache_size = RESOURCE_FONT_CACHE_BLOCK_SIZE;

        memset(ctx->resource_font_cache, 0x00, RESOURCE_FONT_CACHE_BLOCK_SIZE * sizeof(pdfi_name_entry_t));

        entry = &ctx->resource_font_cache[0];

    }

    for (i = 0; entry == NULL && i < ctx->resource_font_cache_size; i++) {

        if (ctx->resource_font_cache[i].pdffont == NULL) {

            entry = &ctx->resource_font_cache[i];

        }

        else if (i == ctx->resource_font_cache_size - 1) {

            entry = (resource_font_cache_t *)gs_resize_object(ctx->memory, ctx->resource_font_cache, sizeof(pdfi_name_entry_t) * (ctx->resource_font_cache_size + RESOURCE_FONT_CACHE_BLOCK_SIZE), "pdfi_cache_resource_font");

            if (entry == NULL)

                break;

            memset(entry + ctx->resource_font_cache_size, 0x00, RESOURCE_FONT_CACHE_BLOCK_SIZE * sizeof(pdfi_name_entry_t));

            ctx->resource_font_cache = entry;

            entry = &ctx->resource_font_cache[ctx->resource_font_cache_size];

            ctx->resource_font_cache_size += RESOURCE_FONT_CACHE_BLOCK_SIZE;

        }

    }

    if (entry != NULL) {

        entry->desc_obj_num = fontdesc->object_num;

        entry->pdffont = ppdffont;

        pdfi_countup(ppdffont);

    }

}

void pdfi_purge_cache_resource_font(pdf_context *ctx)

{

    int i;

    for (i = 0; i < ctx->resource_font_cache_size; i++) {

       pdfi_countdown(ctx->resource_font_cache[i].pdffont);

    }

    gs_free_object(ctx->memory, ctx->resource_font_cache, "pdfi_purge_cache_resource_font");

    ctx->resource_font_cache = NULL;

    ctx->resource_font_cache_size = 0;

}

static int pdfi_find_cache_resource_font(pdf_context *ctx, pdf_obj *fontdesc, pdf_obj **ppdffont)

{

    int i, code = gs_error_undefined;

    for (i = 0; i < ctx->resource_font_cache_size; i++) {

        if (ctx->resource_font_cache[i].desc_obj_num == fontdesc->object_num) {

           *ppdffont = ctx->resource_font_cache[i].pdffont;

           pdfi_countup(*ppdffont);

           code = 0;

           break;

        }

    }

    return code;

}

/* These are fonts for which we have to ignore "named" encodings */

typedef struct known_symbolic_font_name_s

{

    const char *name;

    const int namelen;

} known_symbolic_font_name_t;

#define DEFINE_NAME_LEN(s) #s, sizeof(#s) - 1

static const known_symbolic_font_name_t known_symbolic_font_names[] =

{

  {DEFINE_NAME_LEN(Symbol)},

  {DEFINE_NAME_LEN(Wingdings2)},

  {DEFINE_NAME_LEN(Wingdings)},

  {DEFINE_NAME_LEN(ZapfDingbats)},

  {NULL , 0}

};

#undef DEFINE_NAME_LEN

bool pdfi_font_known_symbolic(pdf_obj *basefont)

{

    bool ignore = false;

    int i;

    pdf_name *nm = (pdf_name *)basefont;

    if (basefont != NULL && pdfi_type_of(basefont) == PDF_NAME) {

        for (i = 0; known_symbolic_font_names[i].name != NULL; i++) {

            if (nm->length == known_symbolic_font_names[i].namelen

             && !strncmp((char *)nm->data, known_symbolic_font_names[i].name, nm->length)) {

                ignore = true;

                break;

            }

        }

    }

    return ignore;

}

static int

pdfi_font_match_glyph_widths(pdf_font *pdfont)

{

    int code = 0;

    int i;

    int sindex, lindex;

    gs_font_base *pbfont = pdfont->pfont;

    double fw = 0.0, ww = 0.0;

    if (pdfont->LastChar <  pdfont->FirstChar || pdfont->Widths == NULL)

        return 0; /* Technically invalid - carry on, hope for the best */

    /* For "best" results, restrict to what we *hope* are A-Z,a-z */

    sindex = pdfont->FirstChar < 96 ? 96 : pdfont->FirstChar;

    lindex = pdfont->LastChar > 122 ? 123 : pdfont->LastChar + 1;

    for (i = sindex; i < lindex; i++) {

        gs_glyph_info_t ginfo = {0};

        gs_glyph g;

        g = pbfont->procs.encode_char((gs_font *)pbfont, i, GLYPH_SPACE_NAME);

        /* We're only interested in non-zero Widths entries for glyphs that actually exist in the font */

        if (g != GS_NO_GLYPH && pdfont->Widths[i - pdfont->FirstChar] != 0.0

          && (*pbfont->procs.glyph_info)((gs_font *)pbfont, g, NULL, GLYPH_INFO_WIDTH0, &ginfo) >= 0) {

            fw += hypot(ginfo.width[0].x, ginfo.width[0].y);

            ww += pdfont->Widths[i - pdfont->FirstChar];

        }

    }

    /* Only reduce font width, don't expand */

    if (ww != 0.0 && fw != 0.0 && ww / fw < 1.0) {

        gs_matrix nmat, smat = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0};

        double wscale;

        smat.xx = smat.yy = ww/fw;

        wscale = 1.0 / smat.xx;

        gs_matrix_multiply(&pbfont->FontMatrix, &smat, &nmat);

        memcpy(&pbfont->FontMatrix, &nmat, sizeof(pbfont->FontMatrix));

        for (i = pdfont->FirstChar; i <= pdfont->LastChar; i++) {

            pdfont->Widths[i - pdfont->FirstChar] *= wscale;

        }

        /* Purging a font can be expensive, but in this case, we know

           we have no scaled instances (pdfi doesn't work that way)

           and we know we have no fm pairs, nor glyphs to purge (we

           *just* created the font!).

           So "purging" the font is really just removing it from the

           doubly linked list of font objects in the font directory

         */

        code = gs_purge_font((gs_font *)pbfont);

        if (code >= 0)

            code = gs_definefont(pbfont->dir, (gs_font *)pbfont);

        if (code >= 0)

            code = pdfi_fapi_passfont((pdf_font *)pdfont, 0, NULL, NULL, NULL, 0);

    }

    return code;

}

/* Print a name object to stdout */

static void pdfi_print_font_name(pdf_context *ctx, pdf_name *n)

{

    if (ctx->args.QUIET != true)

        (void)outwrite(ctx->memory, (const char *)n->data, n->length);

}

static void pdfi_print_font_string(pdf_context *ctx, pdf_string *s)

{

    if (ctx->args.QUIET != true)

        (void)outwrite(ctx->memory, (const char *)s->data, s->length);

}

/* Print a null terminated string to stdout */

static void pdfi_print_cstring(pdf_context *ctx, const char *str)

{

    if (ctx->args.QUIET != true)

        (void)outwrite(ctx->memory, str, strlen(str));

}

/* Call with a CIDFont name to try to find the CIDFont on disk

   call if with ffname NULL to load the default fallback CIDFont

   substitue

   Currently only loads substitute - DroidSansFallback

 */

static int

pdfi_open_CIDFont_substitute_file(pdf_context *ctx, pdf_dict *font_dict, pdf_dict *fontdesc, bool fallback, byte ** buf, int64_t * buflen, int *findex)

{

    int code = 0;

    char fontfname[gp_file_name_sizeof];

    stream *s;

    pdf_name *cidname = NULL;

    gs_const_string fname;

    (void)pdfi_dict_get(ctx, font_dict, "BaseFont", (pdf_obj **)&cidname);

    if (fallback == true) {

        pdf_string *mname = NULL;

        pdf_dict *csi = NULL;

        pdf_name *fbname;

        const char *cidfbstr = "CIDFallBack";

        code = pdfi_fontmap_lookup_cidfont(ctx, font_dict, NULL, (pdf_obj **)&mname, findex);

        if (mname == NULL || pdfi_type_of(mname) != PDF_STRING) {

            pdfi_countdown(mname);

            code = pdfi_object_alloc(ctx, PDF_NAME, strlen(cidfbstr), (pdf_obj **)&fbname);

            if (code >= 0) {

                pdfi_countup(fbname);

                memcpy(fbname->data, cidfbstr, strlen(cidfbstr));

                code = pdfi_fontmap_lookup_cidfont(ctx, font_dict, fbname, (pdf_obj **)&mname, findex);

                pdfi_countdown(fbname);

            }

            if (code < 0 || pdfi_type_of(mname) != PDF_STRING) {

                pdfi_countdown(mname);

                mname = NULL;

                code = pdfi_dict_get(ctx, font_dict, "CIDSystemInfo", (pdf_obj **)&csi);

                if (code >= 0 && pdfi_type_of(csi) == PDF_DICT) {

                    pdf_string *csi_reg = NULL, *csi_ord = NULL;

                    if (pdfi_dict_get(ctx, csi, "Registry", (pdf_obj **)&csi_reg) >= 0

                     && pdfi_dict_get(ctx, csi, "Ordering", (pdf_obj **)&csi_ord) >= 0

                     && pdfi_type_of(csi_reg) == PDF_STRING && pdfi_type_of(csi_ord) == PDF_STRING

                     && csi_reg->length + csi_ord->length + 1 < gp_file_name_sizeof - 1) {

                        pdf_name *reg_ord;

                        memcpy(fontfname, csi_reg->data, csi_reg->length);

                        memcpy(fontfname + csi_reg->length, "-", 1);

                        memcpy(fontfname + csi_reg->length + 1, csi_ord->data, csi_ord->length);

                        fontfname[csi_reg->length + csi_ord->length + 1] = '\0';

                        code = pdfi_name_alloc(ctx, (byte *)fontfname, strlen(fontfname), (pdf_obj **) &reg_ord);

                        if (code >= 0) {

                            pdfi_countup(reg_ord);

                            code = pdfi_fontmap_lookup_cidfont(ctx, font_dict, reg_ord, (pdf_obj **)&mname, findex);

                            pdfi_countdown(reg_ord);

                        }

                    }

                    pdfi_countdown(csi_reg);

                    pdfi_countdown(csi_ord);

                }

                pdfi_countdown(csi);

            }

            if (mname == NULL || pdfi_type_of(mname) != PDF_STRING) {

                pdfi_countdown(mname);

                mname = NULL;

                code = pdfi_fontmap_lookup_cidfont(ctx, font_dict, NULL, (pdf_obj **)&mname, findex);

            }

        }

        do {

            if (code < 0 || pdfi_type_of(mname) != PDF_STRING) {

                const char *fsprefix = "CIDFSubst/";

                int fsprefixlen = strlen(fsprefix);

                const char *defcidfallack = "DroidSansFallback.ttf";

                int defcidfallacklen = strlen(defcidfallack);

                pdfi_countdown(mname);

                if (ctx->args.nocidfallback == true) {

                    if (ctx->args.pdfstoponerror == true)

                        code = gs_note_error(gs_error_Fatal);

                    else

                        code = gs_note_error(gs_error_invalidfont);

                }

                else {

                    if (ctx->args.cidfsubstpath.data == NULL) {

                        memcpy(fontfname, fsprefix, fsprefixlen);

                    }

                    else {

                        if (ctx->args.cidfsubstpath.size > gp_file_name_sizeof - 1) {

                            code = gs_note_error(gs_error_rangecheck);

                            if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSubstPath parameter too long")) < 0)

                                goto exit;

                            memcpy(fontfname, fsprefix, fsprefixlen);

                        }

                        else {

                            memcpy(fontfname, ctx->args.cidfsubstpath.data, ctx->args.cidfsubstpath.size);

                            fsprefixlen = ctx->args.cidfsubstpath.size;

                        }

                    }

                    if (ctx->args.cidfsubstfont.data == NULL) {

                        int len = 0;

                        if (gp_getenv("CIDFSUBSTFONT", (char *)0, &len) < 0) {

                            if (len + fsprefixlen + 1 > gp_file_name_sizeof) {

                                code = gs_note_error(gs_error_rangecheck);

                                if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSUBSTFONT environment variable too long")) < 0)

                                    goto exit;

                                if (defcidfallacklen + fsprefixlen > gp_file_name_sizeof - 1) {

                                    pdfi_set_warning(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSubstPath parameter too long");

                                    memcpy(fontfname, defcidfallack, defcidfallacklen);

                                    fsprefixlen = 0;

                                } else

                                    memcpy(fontfname + fsprefixlen, defcidfallack, defcidfallacklen);

                            }

                            else {

                                (void)gp_getenv("CIDFSUBSTFONT", (char *)(fontfname + fsprefixlen), &defcidfallacklen);

                            }

                        }

                        else {

                            if (fsprefixlen + defcidfallacklen > gp_file_name_sizeof - 1) {

                                code = gs_note_error(gs_error_rangecheck);

                                if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSUBSTFONT environment variable too long")) < 0)

                                    goto exit;

                                memcpy(fontfname, defcidfallack, defcidfallacklen);

                                /* cidfsubstfont should either be a font name we find in the search path(s)

                                   or an absolute path.

                                 */

                                fsprefixlen = 0;

                            }

                            else {

                                memcpy(fontfname + fsprefixlen, defcidfallack, defcidfallacklen);

                            }

                        }

                    }

                    else {

                        if (ctx->args.cidfsubstfont.size + fsprefixlen > gp_file_name_sizeof - 1) {

                            code = gs_note_error(gs_error_rangecheck);

                            if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSubstFont parameter too long")) < 0)

                                goto exit;

                            if (fsprefixlen + defcidfallacklen > gp_file_name_sizeof - 1) {

                                pdfi_set_warning(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSubstPath parameter too long");

                                memcpy(fontfname, defcidfallack, defcidfallacklen);

                                fsprefixlen = 0;

                            }

                            else

                                memcpy(fontfname + fsprefixlen, defcidfallack, defcidfallacklen);

                        }

                        else {

                            if (ctx->args.cidfsubstfont.size > gp_file_name_sizeof - 1) {

                                code = gs_note_error(gs_error_rangecheck);

                                if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_BAD_CONFIG, "pdfi_open_CIDFont_substitute_file", "CIDFSubstFont parameter too long")) < 0)

                                    goto exit;

                                memcpy(fontfname, defcidfallack, defcidfallacklen);

                                defcidfallacklen = ctx->args.cidfsubstfont.size;

                                /* cidfsubstfont should either be a font name we find in the search path(s)

                                   or an absolute path.

                                 */

                                fsprefixlen = 0;

                            }

                            else {

                                memcpy(fontfname, ctx->args.cidfsubstfont.data, ctx->args.cidfsubstfont.size);

                                defcidfallacklen = ctx->args.cidfsubstfont.size;

                                /* cidfsubstfont should either be a font name we find in the search path(s)

                                   or an absolute path.

                                 */

                                fsprefixlen = 0;

                            }

                        }

                    }

                    fontfname[fsprefixlen + defcidfallacklen] = '\0';

                    code = pdfi_open_resource_file(ctx, fontfname, strlen(fontfname), &s);

                    if (code < 0) {

                        pdf_name *fn;

                        code = pdfi_object_alloc(ctx, PDF_NAME, strlen(fontfname), (pdf_obj **)&fn);

                        if (code < 0) {

                            code = gs_note_error(gs_error_invalidfont);

                        }

                        else {

                            pdfi_countup(fn);

                            memcpy(fn->data, fontfname, strlen(fontfname));

                            pdfi_countdown(mname);

                            mname = NULL;

                            code = pdfi_fontmap_lookup_cidfont(ctx, font_dict, fn, (pdf_obj **)&mname, findex);

                            pdfi_countdown(fn);

                            if (code < 0)

                                code = gs_note_error(gs_error_invalidfont);

                            else

                                continue;

                        }

                    }

                    else {

                        if (cidname) {

                            pdfi_print_cstring(ctx, "Loading CIDFont ");

                            pdfi_print_font_name(ctx, (pdf_name *)cidname);

                            pdfi_print_cstring(ctx, " substitute from ");

                        }

                        else {

                            pdfi_print_cstring(ctx, "Loading nameless CIDFont from ");

                        }

                        sfilename(s, &fname);

                        if (fname.size < gp_file_name_sizeof) {

                            memcpy(fontfname, fname.data, fname.size);

                            fontfname[fname.size] = '\0';

                        }

                        else {

                            strcpy(fontfname, "unnamed file");

                        }

                        pdfi_print_cstring(ctx, fontfname);

                        pdfi_print_cstring(ctx, "\n");

                        sfseek(s, 0, SEEK_END);

                        *buflen = sftell(s);

                        sfseek(s, 0, SEEK_SET);

                        *buf = gs_alloc_bytes(ctx->memory, *buflen, "pdfi_open_CIDFont_file(buf)");

                        if (*buf != NULL) {

                            sfread(*buf, 1, *buflen, s);

                        }

                        else {

                            code = gs_note_error(gs_error_VMerror);

                        }

                        sfclose(s);

                        break;

                    }

                }

            }

            else {

                if (mname->length + 1 > gp_file_name_sizeof) {

                    pdfi_countdown(mname);

                    return_error(gs_error_invalidfont);

                }

                memcpy(fontfname, mname->data, mname->length);

                fontfname[mname->length] = '\0';

                code = pdfi_open_resource_file(ctx, (const char *)fontfname, mname->length, &s);

                pdfi_countdown(mname);

                if (code < 0) {

                    code = gs_note_error(gs_error_invalidfont);

                }

                else {

                    if (cidname) {

                        pdfi_print_cstring(ctx, "Loading CIDFont ");

                        pdfi_print_font_name(ctx, (pdf_name *)cidname);

                        pdfi_print_cstring(ctx, " (or substitute) from ");

                    }

                    else {

                        pdfi_print_cstring(ctx, "Loading nameless CIDFont from ");

                    }

                    sfilename(s, &fname);

                    if (fname.size < gp_file_name_sizeof) {

                        memcpy(fontfname, fname.data, fname.size);

                        fontfname[fname.size] = '\0';

                    }

                    else {

                        strcpy(fontfname, "unnamed file");

                    }

                    pdfi_print_cstring(ctx, fontfname);

                    pdfi_print_cstring(ctx, "\n");

                    sfseek(s, 0, SEEK_END);

                    *buflen = sftell(s);

                    sfseek(s, 0, SEEK_SET);

                    *buf = gs_alloc_bytes(ctx->memory, *buflen, "pdfi_open_CIDFont_file(buf)");

                    if (*buf != NULL) {

                        sfread(*buf, 1, *buflen, s);

                    }

                    else {

                        code = gs_note_error(gs_error_VMerror);

                    }

                    sfclose(s);

                    break;

                }

            }

        } while (code >= 0);

    }

    else {

        const char *fsprefix = "CIDFont/";

        const int fsprefixlen = strlen(fsprefix);

        if (cidname == NULL || pdfi_type_of(cidname) != PDF_NAME

         || fsprefixlen + cidname->length >= gp_file_name_sizeof) {

            code = gs_note_error(gs_error_invalidfont);

            goto exit;

        }

        memcpy(fontfname, fsprefix, fsprefixlen);

        memcpy(fontfname + fsprefixlen, cidname->data, cidname->length);

        fontfname[fsprefixlen + cidname->length] = '\0';

        code = pdfi_open_resource_file(ctx, fontfname, strlen(fontfname), &s);

        if (code < 0) {

            code = gs_note_error(gs_error_invalidfont);

        }

        else {

            sfseek(s, 0, SEEK_END);

            *buflen = sftell(s);

            sfseek(s, 0, SEEK_SET);

            *buf = gs_alloc_bytes(ctx->memory, *buflen, "pdfi_open_CIDFont_file(buf)");

            if (*buf != NULL) {

                sfread(*buf, 1, *buflen, s);

            }

            else {

                code = gs_note_error(gs_error_invalidfont);

            }

            sfclose(s);

        }

    }

exit:

    if (cidname != NULL)

        pdfi_countdown(cidname);

    return code;

}

enum

{

    pdfi_font_flag_none =        0x00000,

    pdfi_font_flag_fixed =       0x00001,

    pdfi_font_flag_serif =       0x00002,

    pdfi_font_flag_symbolic =    0x00004,

    pdfi_font_flag_script =      0x00008,

    pdfi_font_flag_nonsymbolic = 0x00020,

    pdfi_font_flag_italic =      0x00040,

    pdfi_font_flag_allcap =      0x10000,

    pdfi_font_flag_smallcap =    0x20000,

    pdfi_font_flag_forcebold =   0x40000

};

/* Barefaced theft from mupdf! */

static const char *pdfi_base_font_names[][10] =

{

  { "Courier", "CourierNew", "CourierNewPSMT", "CourierStd", NULL },

  { "Courier-Bold", "CourierNew,Bold", "Courier,Bold", "CourierNewPS-BoldMT", "CourierNew-Bold", NULL },

  { "Courier-Oblique", "CourierNew,Italic", "Courier,Italic", "CourierNewPS-ItalicMT", "CourierNew-Italic", NULL },

  { "Courier-BoldOblique", "CourierNew,BoldItalic", "Courier,BoldItalic", "CourierNewPS-BoldItalicMT", "CourierNew-BoldItalic", NULL },

  { "Helvetica", "ArialMT", "Arial", NULL },

  { "Helvetica-Bold", "Arial-BoldMT", "Arial,Bold", "Arial-Bold", "Helvetica,Bold", NULL },

  { "Helvetica-Oblique", "Arial-ItalicMT", "Arial,Italic", "Arial-Italic", "Helvetica,Italic", "Helvetica-Italic", NULL },

  { "Helvetica-BoldOblique", "Arial-BoldItalicMT", "Arial,BoldItalic", "Arial-BoldItalic", "Helvetica,BoldItalic", "Helvetica-BoldItalic", NULL },

  { "Times-Roman", "TimesNewRomanPSMT", "TimesNewRoman", "TimesNewRomanPS", NULL },

  { "Times-Bold", "TimesNewRomanPS-BoldMT", "TimesNewRoman,Bold", "TimesNewRomanPS-Bold", "TimesNewRoman-Bold", NULL },

  { "Times-Italic", "TimesNewRomanPS-ItalicMT", "TimesNewRoman,Italic", "TimesNewRomanPS-Italic", "TimesNewRoman-Italic", NULL },

  { "Times-BoldItalic", "TimesNewRomanPS-BoldItalicMT", "TimesNewRoman,BoldItalic", "TimesNewRomanPS-BoldItalic", "TimesNewRoman-BoldItalic", NULL },

  { "Symbol", "Symbol,Italic", "Symbol,Bold", "Symbol,BoldItalic", "SymbolMT", "SymbolMT,Italic", "SymbolMT,Bold", "SymbolMT,BoldItalic", NULL },

  { "ZapfDingbats", NULL }

};

static int strncmp_ignore_space(const char *a, const char *b)

{

    while (1)

    {

        while (*a == ' ')

            a++;

        while (*b == ' ')

            b++;

        if (*a != *b)

            return 1;

        if (*a == 0)

            return *a != *b;

        if (*b == 0)

            return *a != *b;

        a++;

        b++;

    }

    return 0; /* Shouldn't happen */

}

static const char *pdfi_clean_font_name(const char *fontname)

{

    int i, k;

    for (i = 0; i < (sizeof(pdfi_base_font_names)/sizeof(pdfi_base_font_names[0])); i++) {

        for (k = 0; pdfi_base_font_names[i][k]; k++) {

            if (!strncmp_ignore_space(pdfi_base_font_names[i][k], (const char *)fontname))

                return pdfi_base_font_names[i][0];

        }

    }

    return NULL;

}

static int pdfi_font_substitute_by_flags(pdf_context *ctx, unsigned int flags, char **name, int *namelen)

{

    bool fixed = ((flags & pdfi_font_flag_fixed) != 0);

    bool serif = ((flags & pdfi_font_flag_serif) != 0);

    bool italic = ((flags & pdfi_font_flag_italic) != 0);

    bool bold = ((flags & pdfi_font_flag_forcebold) != 0);

    int code = 0;

    if (ctx->args.defaultfont_is_name == true && ctx->args.defaultfont.size == 4

        && !memcmp(ctx->args.defaultfont.data, "None", 4)) {

       *name = NULL;

       *namelen = 0;

       code = gs_error_invalidfont;

    }

    else if (ctx->args.defaultfont.data != NULL && ctx->args.defaultfont.size > 0) {

        *name = (char *)ctx->args.defaultfont.data;

        *namelen = ctx->args.defaultfont.size;

    }

    else if (fixed) {

        if (bold) {

            if (italic) {

                *name = (char *)pdfi_base_font_names[3][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[1][0];

                *namelen = strlen(*name);

            }

        }

        else {

            if (italic) {

                *name = (char *)pdfi_base_font_names[2][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[0][0];

                *namelen = strlen(*name);

            }

        }

    }

    else if (serif) {

        if (bold) {

            if (italic) {

                *name = (char *)pdfi_base_font_names[11][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[9][0];

                *namelen = strlen(*name);

            }

        }

        else {

            if (italic) {

                *name = (char *)pdfi_base_font_names[10][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[8][0];

                *namelen = strlen(*name);

            }

        }

    } else {

        if (bold) {

            if (italic) {

                *name = (char *)pdfi_base_font_names[7][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[5][0];

                *namelen = strlen(*name);

            }

        }

        else {

            if (italic) {

                *name = (char *)pdfi_base_font_names[6][0];

                *namelen = strlen(*name);

            }

            else {

                *name = (char *)pdfi_base_font_names[4][0];

                *namelen = strlen(*name);

            }

        }

    }

    return code;

}

enum {

  no_type_font = -1,

  type0_font = 0,

  type1_font = 1,

  cff_font = 2,

  type3_font = 3,

  tt_font = 42

};

static int pdfi_fonttype_picker(byte *buf, int64_t buflen)

{

#define MAKEMAGIC(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))

    if (buflen >= 4) {

        if (MAKEMAGIC(buf[0], buf[1], buf[2], buf[3]) == MAKEMAGIC(0, 1, 0, 0)

            || MAKEMAGIC(buf[0], buf[1], buf[2], buf[3]) == MAKEMAGIC('t', 'r', 'u', 'e')

            || MAKEMAGIC(buf[0], buf[1], buf[2], buf[3]) == MAKEMAGIC('t', 't', 'c', 'f')) {

            return tt_font;

        }

        else if (MAKEMAGIC(buf[0], buf[1], buf[2], buf[3]) == MAKEMAGIC('O', 'T', 'T', 'O')) {

            return cff_font; /* OTTO will end up as CFF */

        }

        else if (MAKEMAGIC(buf[0], buf[1], buf[2], 0) == MAKEMAGIC('%', '!', 'P', 0)) {

            return type1_font; /* pfa */

        }

        else if (MAKEMAGIC(buf[0], buf[1], buf[2], 0) == MAKEMAGIC(1, 0, 4, 0)) {

            return cff_font; /* 1C/CFF */

        }

        else if (MAKEMAGIC(buf[0], buf[1], 0, 0) == MAKEMAGIC(128, 1, 0, 0)) {

            return type1_font; /* pfb */

        }

    }

    return no_type_font;

#undef MAKEMAGIC

}

static int pdfi_copy_font(pdf_context *ctx, pdf_font *spdffont, pdf_dict *font_dict, pdf_font **tpdffont)

{

    int code;

    if (pdfi_type_of(spdffont) != PDF_FONT)

        return_error(gs_error_typecheck);

    switch(spdffont->pdfi_font_type) {

        case e_pdf_font_type1:

          code = pdfi_copy_type1_font(ctx, spdffont, font_dict, tpdffont);

          break;

        case e_pdf_font_cff:

          code = pdfi_copy_cff_font(ctx, spdffont, font_dict, tpdffont);

          break;

        case e_pdf_font_truetype:

          code = pdfi_copy_truetype_font(ctx, spdffont, font_dict, tpdffont);

          break;

        case e_pdf_font_microtype:

          code = pdfi_copy_microtype_font(ctx, spdffont, font_dict, tpdffont);

          break;

        default:

            return_error(gs_error_invalidfont);

    }

    return code;

}

enum {

  font_embedded = 0,

  font_from_file = 1,

  font_substitute = 2

};

static int pdfi_load_font_buffer(pdf_context *ctx, byte *fbuf, int fbuflen, int fftype, pdf_name *Subtype, int findex, pdf_dict *stream_dict, pdf_dict *page_dict, pdf_dict *font_dict, pdf_font **ppdffont, bool cidfont)

{

    int code = gs_error_invalidfont;

    if (fbuf != NULL) {

        /* First, see if we can glean the type from the magic number */

        int sftype = pdfi_fonttype_picker(fbuf, fbuflen);

        if (sftype == no_type_font) {

            if (fftype != no_type_font)

                sftype = fftype;

            else {

                /* If we don't have a Subtype, can't work it out, try Type 1 */

                if (Subtype == NULL || pdfi_name_is(Subtype, "Type1") || pdfi_name_is(Subtype, "MMType1"))

                    sftype = type1_font;

                else if (pdfi_name_is(Subtype, "Type1C"))

                    sftype = cff_font;

                else if (pdfi_name_is(Subtype, "TrueType"))

                    sftype = tt_font;

            }

        }

        /* fbuf ownership passes to the font loader */

        switch (sftype) {

            case type1_font:

                code = pdfi_read_type1_font(ctx, (pdf_dict *)font_dict, stream_dict, page_dict, fbuf, fbuflen, ppdffont);

                fbuf = NULL;

                break;

            case cff_font:

                code = pdfi_read_cff_font(ctx, (pdf_dict *)font_dict, stream_dict, page_dict, fbuf, fbuflen, cidfont, ppdffont);

                fbuf = NULL;

                break;

            case tt_font:

                {

                    if (cidfont)

                        code = pdfi_read_cidtype2_font(ctx, font_dict, stream_dict, page_dict, fbuf, fbuflen, findex, ppdffont);

                    else

                        code = pdfi_read_truetype_font(ctx, font_dict, stream_dict, page_dict, fbuf, fbuflen, findex, ppdffont);

                    fbuf = NULL;

                }

                break;

            default:

                gs_free_object(ctx->memory, fbuf, "pdfi_load_font_buffer(fbuf)");

                code = gs_note_error(gs_error_invalidfont);

        }

    }

    return code;

}

static int pdfi_load_font_file(pdf_context *ctx, int fftype, pdf_name *Subtype, pdf_dict *stream_dict, pdf_dict *page_dict, pdf_dict *font_dict, pdf_dict *fontdesc, bool substitute, pdf_font **ppdffont)

{

    int code;

    char fontfname[gp_file_name_sizeof];

    pdf_obj *basefont = NULL, *mapname = NULL;

    pdf_obj *fontname = NULL;

    stream *s = NULL;

    const char *fn;

    int findex = 0;

    byte *buf;

    int buflen;

    pdf_font *pdffont = NULL;

    pdf_font *substpdffont = NULL;

    bool f_retry = true;

    code = pdfi_dict_knownget_type(ctx, font_dict, "BaseFont", PDF_NAME, &basefont);

    if (substitute == false && (code < 0 || basefont == NULL || ((pdf_name *)basefont)->length == 0)) {

        pdfi_countdown(basefont);

        return_error(gs_error_invalidfont);

    }

    if (substitute == true) {

        char *fbname;

        int fbnamelen;

        int64_t flags = 0;

        if (fontdesc != NULL) {

            (void)pdfi_dict_get_int(ctx, fontdesc, "Flags", &flags);

        }

        code = pdfi_font_substitute_by_flags(ctx, (int)flags, &fbname, &fbnamelen);

        if (code < 0)

            return code;

        code = pdfi_name_alloc(ctx, (byte *)fbname, strlen(fbname), (pdf_obj **) &fontname);

        if (code < 0)

            return code;

        pdfi_countup(fontname);

    }

    else {

        fontname = basefont;

        pdfi_countup(fontname);

    }

    if (((pdf_name *)fontname)->length < gp_file_name_sizeof) {

        memcpy(fontfname, ((pdf_name *)fontname)->data, ((pdf_name *)fontname)->length);

        fontfname[((pdf_name *)fontname)->length] = '\0';

        pdfi_countdown(fontname);

        code = pdfi_name_alloc(ctx, (byte *)fontfname, strlen(fontfname), (pdf_obj **) &fontname);

        if (code < 0)

            return code;

        pdfi_countup(fontname);

    }

    else {

        /* Just to ensure that fontfname is a valid, though empty, string */

        fontfname[0] = '\0';

    }

    do {

        if (f_retry == true && pdfi_font_file_exists(ctx, (const char *)((pdf_name *)fontname)->data, ((pdf_name *)fontname)->length) == true) {

            code = 0;

        }

        else {

            code = pdfi_fontmap_lookup_font(ctx, font_dict, (pdf_name *) fontname, &mapname, &findex);

            if (code < 0) {

                if (((pdf_name *)fontname)->length < gp_file_name_sizeof) {

                    memcpy(fontfname, ((pdf_name *)fontname)->data, ((pdf_name *)fontname)->length);

                    fontfname[((pdf_name *)fontname)->length] = '\0';

                    fn = pdfi_clean_font_name(fontfname);

                    if (fn != NULL) {

                        pdfi_countdown(fontname);

                        code = pdfi_name_alloc(ctx, (byte *)fn, strlen(fn), (pdf_obj **) &fontname);

                        if (code < 0)

                            return code;

                        pdfi_countup(fontname);

                    }

                }

                code = pdfi_fontmap_lookup_font(ctx, font_dict, (pdf_name *) fontname, &mapname, &findex);

                if (code < 0) {

                    mapname = fontname;

                    pdfi_countup(mapname);

                    code = 0;

                }

            }

            if (pdfi_type_of(mapname) == PDF_FONT) {

                pdffont = (pdf_font *)mapname;

                pdfi_countup(pdffont);

                break;

            }

            if (pdfi_type_of(mapname) == PDF_NAME || pdfi_type_of(mapname) == PDF_STRING) {

                pdf_name *mname = (pdf_name *) mapname;

                if (mname->length + 1 < gp_file_name_sizeof) {

                    memcpy(fontfname, mname->data, mname->length);

                    fontfname[mname->length] = '\0';

                }

                else {

                    pdfi_countdown(mapname);

                    pdfi_countdown(fontname);

                    return_error(gs_error_invalidfileaccess);

                }

            }

            else {

                pdfi_countdown(mapname);

                pdfi_countdown(fontname);

                return_error(gs_error_invalidfileaccess);

            }

            if (ctx->pdf_substitute_fonts != NULL) {

                code = pdfi_dict_knownget_type(ctx, ctx->pdf_substitute_fonts, fontfname, PDF_FONT, (pdf_obj **)&pdffont);

                if (code == 1 && pdffont->filename == NULL) {

                    pdfi_countdown(pdffont);

                    pdffont = NULL;

                    code = 0;

                }

            }

            else

                code = 0;

        }

        if (code != 1) {

            code = pdfi_open_font_file(ctx, fontfname, strlen(fontfname), &s);

            if (code < 0 && f_retry && pdfi_type_of(mapname) == PDF_NAME) {

                pdfi_countdown(fontname);

                fontname = mapname;

                mapname = NULL;

                f_retry = false;

                continue;

            }

            if (code >= 0) {

                gs_const_string fname;

                sfilename(s, &fname);

                if (fname.size < gp_file_name_sizeof) {

                    memcpy(fontfname, fname.data, fname.size);

                    fontfname[fname.size] = '\0';

                }

                else {

                    strcpy(fontfname, "unnamed file");

                }

                sfseek(s, 0, SEEK_END);

                buflen = sftell(s);

                sfseek(s, 0, SEEK_SET);

                buf = gs_alloc_bytes(ctx->memory, buflen, "pdfi_open_t1_font_file(buf)");

                if (buf != NULL) {

                    sfread(buf, 1, buflen, s);

                }

                else {

                    code = gs_note_error(gs_error_VMerror);

                }

                sfclose(s);

                /* Buffer owership moves to the font object */

                code = pdfi_load_font_buffer(ctx, buf, buflen, no_type_font, NULL, findex, stream_dict, page_dict, NULL, &pdffont, false);

                if (code >= 0) {

                    pdffont->filename = NULL;