/* 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.

*/

/* pcsfont.c */

/* PCL5 soft font creation commands */

#include "memory_.h"

#include "stdio_.h"             /* needed for pl_load_tt_font */

#include "math_.h"

#include "gdebug.h"

#include "pcommand.h"

#include "pcfont.h"

#include "pcursor.h"

#include "pcpage.h"

#include "pcstate.h"

#include "pcfsel.h"

#include "pcparse.h"

#include "pjparse.h"

#include "pldict.h"

#include "plvalue.h"

#include "plmain.h"             /* for high_level_device...

                                   hopefully this will go away soon */

#include "plfapi.h"

#include "gsbitops.h"

#include "gsccode.h"

#include "gsmatrix.h"

#include "gsutil.h"

#include "gxfont.h"

#include "gxfont42.h"

#define IGNORE_BAD_HEADER_FORMAT_SPECIFIER

/* Emulate bug in HP printer where component metrics are ignored. */

#define DISABLE_USE_MY_METRICS

/* Define the downloaded character data formats. */

typedef enum

{

    pccd_bitmap = 4,

    pccd_intellifont = 10,

    pccd_truetype = 15

} pcl_character_format;

/* ------ Internal procedures ------ */

/* Delete a soft font.  If it is the currently selected font, or the */

/* current primary or secondary font, cause a new one to be chosen. */

static int

pcl_delete_soft_font(pcl_state_t * pcs, const byte * key, uint ksize,

                     void *value)

{

    if (value == NULL) {

        if (!pl_dict_find_no_stack(&pcs->soft_fonts, key, ksize, &value))

            return 0;             /* not a defined font */

    }

    {

        pl_font_t *plfontp = (pl_font_t *) value;

        if (pcs->font_selection[0].font == plfontp)

            pcs->font_selection[0].font = 0;

        if (pcs->font_selection[1].font == plfontp)

            pcs->font_selection[1].font = 0;

        /* if this is permanent font we need to tell PJL we are

           removing it */

        if (plfontp->storage & pcds_permanent)

            if (pjl_proc_register_permanent_soft_font_deletion(pcs->pjls,

                                                               plfontp->

                                                               params.

                                                               pjl_font_number)

                > 0) {

                int code = pcl_set_current_font_environment(pcs);

                if (code < 0)

                    return code;

            }

        pcs->font = pcs->font_selection[pcs->font_selected].font;

        pl_dict_undef_purge_synonyms(&pcs->soft_fonts, key, ksize);

    }

    return 0;

}

/* ------ Commands ------ */

static int                      /* ESC * c <id> D */

pcl_assign_font_id(pcl_args_t * pargs, pcl_state_t * pcs)

{

    uint id = uint_arg(pargs);

    id_set_value(pcs->font_id, id);

    /* set state to use id's not strings */

    pcs->font_id_type = numeric_id;

    return 0;

}

/* Supports copy or assignment of resident fonts.  Copying a soft font

   involves a deep copy and a new font.  Copying a resident font

   creates a link to the original (source) font */

static int

pcl_make_resident_font_copy(pcl_state_t * pcs)

{

    pl_dict_enum_t dictp;

    gs_const_string key;

    void *value;

    bool found = false;

    /* first check for a duplicate key, if found remove it */

    if (pl_dict_lookup

        (&pcs->built_in_fonts, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE, &value,

         false, (pl_dict_t **) 0))

        if (pl_dict_undef

            (&pcs->built_in_fonts, CURRENT_FONT_ID,

             CURRENT_FONT_ID_SIZE) == false)

            /* shouldn't fail */

            return -1;

    /* now search for the value */

    pl_dict_enum_begin(&pcs->built_in_fonts, &dictp);

    while (pl_dict_enum_next(&dictp, &key, &value))

        if ((void *)(pcs->font) == value) {

            found = true;

            break;

        }

    if (found == false)

        return -1;

    return pl_dict_put_synonym(&pcs->built_in_fonts, key.data,

                        key.size, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE);

}

static int                      /* ESC * c <fc_enum> F */

pcl_font_control(pcl_args_t * pargs, pcl_state_t * pcs)

{

    int code = 0;

    gs_const_string key;

    void *value;

    pl_dict_enum_t denum;

    switch (uint_arg(pargs)) {

        case 0:

            /* Delete all soft fonts. */

            pcs->font = pcs->font_selection[pcs->font_selected].font;

            pl_dict_enum_stack_begin(&pcs->soft_fonts, &denum, false);

            while (pl_dict_enum_next(&denum, &key, &value)) {

                code = pcl_delete_soft_font(pcs, key.data, key.size, value);

                if (code < 0)

                    return code;

                /* when deleting fonts we must restart the enumeration

                   each time because the last deleted font may have had

                   deleted synonyms which are not properly registered in

                   the enumeration structure.  NB A similar change should

                   be made for deleting all temporary fonts. */

                pl_dict_enum_stack_begin(&pcs->soft_fonts, &denum, false);

            }

            pl_dict_release(&pcs->soft_fonts);

            break;

        case 1:

            /* Delete all temporary soft fonts. */

            pl_dict_enum_stack_begin(&pcs->soft_fonts, &denum, false);

            while (pl_dict_enum_next(&denum, &key, &value))

                if (((pl_font_t *) value)->storage == pcds_temporary) {

                    code = pcl_delete_soft_font(pcs, key.data, key.size, value);

                    if (code < 0)

                        return code;

                    /* Since deleting the softfont also deletes any "synonyms" in

                       the dictionary, it means the dictionary contents can change

                       under our feet.

                       The simplest solution is to start the enumeration with

                       a clean slate. This isn't used often enough for the

                       efficiency to be a worry.

                     */

                    pl_dict_enum_stack_begin(&pcs->soft_fonts, &denum, false);

                }

            break;

        case 2:

            /* Delete soft font <font_id>. */

            code = pcl_delete_soft_font(pcs, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE,

                                 NULL);

            /* decache the currently selected font in case we deleted it. */

            pcl_decache_font(pcs, -1, true);

            break;

        case 3:

            /* Delete character <font_id, character_code>. */

            if (pl_dict_find_no_stack

                (&pcs->soft_fonts, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE,

                 &value))

                pl_font_remove_glyph((pl_font_t *) value,

                                     pcs->character_code);

            return 0;

            break;

        case 4:

            /* Make soft font <font_id> temporary. */

            if (pl_dict_find_no_stack

                (&pcs->soft_fonts, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE,

                 &value))

                ((pl_font_t *) value)->storage = pcds_temporary;

            break;

        case 5:

            /* Make soft font <font_id> permanent. */

            if (pl_dict_find_no_stack

                (&pcs->soft_fonts, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE,

                 &value)) {

                ((pl_font_t *) value)->storage = pcds_permanent;

                ((pl_font_t *) value)->params.pjl_font_number =

                    pjl_proc_register_permanent_soft_font_addition(pcs->pjls);

            }

            break;

        case 6:

            {

                if (pcs->font == 0) {

                    code = pcl_recompute_font(pcs, false);

                    if (code < 0)

                        return code;

                }

                if (pcs->font->storage == pcds_internal) {

                    return pcl_make_resident_font_copy(pcs);

                } else {

                    pl_font_t *plfont = pl_clone_font(pcs->font,

                                                      pcs->memory,

                                                      "pcl_font_control()");

                    if (plfont == 0) {

                        dmprintf(pcs->memory, "pcsfont.c clone font FIXME\n");

                        return 0;

                    }

                    code = gs_definefont(pcs->font_dir, plfont->pfont);

                    if (code < 0)

                        return code;

                    if (plfont->scaling_technology == plfst_TrueType)

                        code = pl_fapi_passfont(plfont, 0, NULL, NULL, NULL, 0);

                    if (code < 0)

                        return code;

                    code = pcl_delete_soft_font(pcs, CURRENT_FONT_ID,

                                         CURRENT_FONT_ID_SIZE, NULL);

                    if (code < 0)

                        return code;

                    plfont->storage = pcds_temporary;

                    plfont->data_are_permanent = false;

                    code = pl_dict_put(&pcs->soft_fonts, CURRENT_FONT_ID,

                                CURRENT_FONT_ID_SIZE, plfont);

                }

            }

            break;

        default:

            return 0;

    }

    return code;

}

#ifdef DEBUG

static void

dump_dl_font_header(const gs_memory_t * mem, const pcl_font_header_t *pfh)

{

    const char *header_format;

    int i;

    dmprintf1(mem, "FontDescriptorSize:%d\n", pl_get_uint16(pfh->FontDescriptorSize));

    switch (pfh->HeaderFormat) {

    case pcfh_bitmap:

        header_format = "bitmap";

        break;

    case pcfh_resolution_bitmap:

        header_format = "resolution bitmap";

        break;

    case pcfh_intellifont_bound:

        header_format = "bound intellifont";

        break;

    case pcfh_intellifont_unbound:

        header_format = "unbound intellifont";

        break;

    case pcfh_truetype:

        header_format = "truetype";

        break;

    case pcfh_truetype_large:

        header_format = "truetype large";

        break;

    default:

        header_format = "unknown";

    }

    dmprintf1(mem, "Header Format:%s\n", header_format);

    dmprintf1(mem, "Font Type:%d\n", (pl_font_type_t) pfh->FontType);

    dmprintf1(mem, "Style:%d\n", (pfh->StyleMSB << 8) + pfh->StyleLSB);

    dmprintf1(mem, "BaseLinePostion:%d\n", pl_get_uint16(pfh->BaselinePosition));

    dmprintf1(mem, "Reserved (should be 0):%d\n", pfh->Reserved);

    dmprintf1(mem, "CellWidth:%d\n", pl_get_uint16(pfh->CellWidth));

    dmprintf1(mem, "CellHeight:%d\n", pl_get_uint16(pfh->CellHeight));

    dmprintf1(mem, "Orientation:%d\n", pfh->Orientation);

    dmprintf1(mem, "Spacing:%d\n", pfh->Spacing);

    dmprintf1(mem, "SymbolSet:%d\n", pl_get_uint16(pfh->SymbolSet));

    dmprintf1(mem, "Pitch:%d\n", pl_get_uint16(pfh->Pitch));

    dmprintf1(mem, "Height:%d\n", pl_get_uint16(pfh->Height));

    dmprintf1(mem, "xHeight:%d\n", pl_get_uint16(pfh->xHeight));

    dmprintf1(mem, "WidthType:%d\n", pfh->WidthType);

    dmprintf1(mem, "StrokeWeight:%d\n", pfh->StrokeWeight);

    dmprintf1(mem, "TypeFace:%d\n", (pfh->TypefaceMSB << 8) + pfh->TypefaceLSB);

    dmprintf1(mem, "SerifStyle:%d\n", pfh->SerifStyle);

    dmprintf1(mem, "Quality:%d\n", pfh->Quality);

    dmprintf1(mem, "Placement:%d\n", pfh->Placement);

    dmprintf1(mem, "UnderlinePosition:%d\n", pfh->UnderlinePosition);

    dmprintf1(mem, "UnderlineThickness:%d\n", pfh->UnderlineThickness);

    dmprintf1(mem, "TextHeight:%d\n", pl_get_uint16(pfh->TextHeight));

    dmprintf1(mem, "TextWidth:%d\n", pl_get_uint16(pfh->TextWidth));

    dmprintf1(mem, "FirstCode:%d\n", pl_get_uint16(pfh->FirstCode));

    dmprintf1(mem, "LastCode:%d\n", pl_get_uint16(pfh->LastCode));

    dmprintf1(mem, "PitchExtended:%d\n", pfh->PitchExtended);

    dmprintf1(mem, "HeightExtended:%d\n", pfh->HeightExtended);

    dmprintf1(mem, "CapHeight:%d\n", pl_get_uint16(pfh->CapHeight));

    dmprintf4(mem, "FontNumber:%d %d %d %d\n", pfh->FontNumber[0],

              pfh->FontNumber[1], pfh->FontNumber[2], pfh->FontNumber[3]);

    dmprintf(mem, "FontName:");

    for (i = 0; i < sizeof(pfh->FontName); i++) {

        unsigned char c = pfh->FontName[i];

        if (c < 32 || c == 127)

            dmprintf1(mem, "<%02x>", c);

        else

            dmprintf1(mem, "%c", c);

    }

    dmprintf(mem, "\n");

    if (pfh->HeaderFormat == pcfh_resolution_bitmap) {

#define pfhx ((const pcl_resolution_bitmap_header_t *)pfh)

        dmprintf1(mem, "XResolution:%d\n", pl_get_uint16(pfhx->XResolution));

        dmprintf1(mem, "YResolution:%d\n", pl_get_uint16(pfhx->YResolution));

#undef pfhx

    }

    return;

}

#endif

static int                      /* ESC ) s <count> W */

pcl_font_header(pcl_args_t * pargs, pcl_state_t * pcs)

{

    uint count = uint_arg(pargs);

    const byte *data = arg_data(pargs);

    pcl_font_header_t *pfh = (pcl_font_header_t *) data;

    uint desc_size;

    pl_font_scaling_technology_t fst;

    gs_memory_t *mem = pcs->memory;

    pl_font_t *plfont;

    byte *header;

    int code;

    bool has_checksum;

#ifdef DEBUG

    if (gs_debug_c('i')) {

        pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs));

    }

#endif

    if (count < 64 && pfh->HeaderFormat != pcfh_bitmap)

        return e_Range;         /* pcfh_bitmap defaults short headers to 0 except underline position = 5; */

#ifdef DEBUG

    if (gs_debug_c('=')) {

        dump_dl_font_header(pcs->memory, pfh);

    }

#endif

    desc_size =

        (pfh->FontDescriptorSize[0] << 8) + pfh->FontDescriptorSize[1];

    /* Dispatch on the header format. */

    switch (pfh->HeaderFormat) {

        case pcfh_bitmap:

        case pcfh_resolution_bitmap:

            fst = plfst_bitmap;

            has_checksum = false;

            break;

        case pcfh_intellifont_bound:

        case pcfh_intellifont_unbound:

            fst = plfst_Intellifont;

            /* intellifonts do have a checksum but we have seen

               several fonts in tests that don't follow the

               documentation.  It is possible intellifonts use a

               different offset than truetype to begin the summation.

               We have not investigated. */

            has_checksum = false;

            break;

        case pcfh_truetype:

        case pcfh_truetype_large:

            fst = plfst_TrueType;

            has_checksum = true;

            break;

        default:

#ifdef IGNORE_BAD_HEADER_FORMAT_SPECIFIER

            return 0;

#else

            return_error(gs_error_invalidfont);

#endif

    }

    /* Fonts should include a final byte that makes the sum of the

       bytes in the font 0 (mod 256).  The hp documentation says

       byte 64 and up should contribute to the checksum.  All

       known examples indicate byte 64 (index 63 of the array

       below) is not included. */

    if (has_checksum) {

        ulong sum = 0;

        int i;

        for (i = count - 1; i >= 64; i--) {

            sum += data[i];

            sum %= 256;

        }

        if (sum != 0) {

            dmprintf1(pcs->memory, "corrupt font sum=%ld\n", sum);

            return_error(gs_error_invalidfont);

        }

    }

    /* Delete any previous font with this ID. */

    code = pcl_delete_soft_font(pcs, CURRENT_FONT_ID, CURRENT_FONT_ID_SIZE, NULL);

    if (code < 0)

        return code;

    /* Create the generic font information. */

    plfont = pl_alloc_font(mem, "pcl_font_header(pl_font_t)");

#ifdef DEBUG

    {

        int i;

        for (i = 0; i < sizeof(pfh->FontName); i++)

            plfont->FontName[i] = pfh->FontName[i];

    }

#endif

    header = gs_alloc_bytes(mem, count, "pcl_font_header(header)");

    if (plfont == NULL || header == NULL) {

        gs_free_object(mem, header, "pcl_font_header(header)");

        gs_free_object(mem, plfont, "pcl_font_header(pl_font_t)");

        return_error(e_Memory);

    }

    memcpy(header, data, count);

    plfont->storage = pcds_temporary;

    plfont->data_are_permanent = false;

    if (fst == plfst_Intellifont) {

        if (pfh->HeaderFormat != pcfh_intellifont_bound) {

            /* copy in the compliment while we are here. */

            memcpy(plfont->character_complement, &data[78], 8);

        }

    }

    plfont->header = header;

    plfont->header_size = count;

    plfont->is_xl_format = false;

    plfont->scaling_technology = fst;

    plfont->font_type = (pl_font_type_t) pfh->FontType;

    plfont->font_file = (char *)0;

    code = pl_font_alloc_glyph_table(plfont, 256, mem,

                                     "pcl_font_header(char table)");

    if (code < 0)

        goto fail;

    /* Create the actual font. */

    switch (fst) {

        case plfst_bitmap:

            {

                gs_font_base *pfont;

              bitmap:pfont = gs_alloc_struct(mem, gs_font_base, &st_gs_font_base,

                                        "pcl_font_header(bitmap font)");

                if (pfont == NULL) {

                    code = e_Memory;

                    goto fail;

                }

                code =

                    pl_fill_in_font((gs_font *) pfont, plfont, pcs->font_dir,

                                    mem, "nameless_font");

                if (code < 0)

                    goto fail;

                pl_fill_in_bitmap_font(pfont, gs_next_ids(mem, 1));

                /* Extract parameters from the font header. */

                if (pfh->HeaderFormat == pcfh_resolution_bitmap) {

#define pfhx ((const pcl_resolution_bitmap_header_t *)pfh)

                    plfont->resolution.x = pl_get_uint16(pfhx->XResolution);

                    plfont->resolution.y = pl_get_uint16(pfhx->YResolution);

#undef pfhx

                }

                /* note that we jump to the bitmap label for type 16 - so

                   called truetype large which can also be bitmap but its

                   resolution field is filled in when scanning the

                   segments (see pl_font_scan_segments() the resolution

                   does not show up in the font header. */

                else if (pfh->HeaderFormat == pcfh_bitmap)

                    plfont->resolution.x = plfont->resolution.y = 300;

                {

                    ulong pitch_1024th_dots =

                        ((ulong) pl_get_uint16(pfh->Pitch) << 8) +

                        pfh->PitchExtended;

                    double pitch_cp = (double)

                        (pitch_1024th_dots / 1024.0     /* dots */

                         / plfont->resolution.x /* => inches */

                         * 7200.0);

                    pl_fp_set_pitch_cp(&plfont->params, pitch_cp);

                }

                {

                    uint height_quarter_dots = pl_get_uint16(pfh->Height);

                    plfont->params.height_4ths =

                        (uint) (floor((double)height_quarter_dots * 72.0 /

                                      (double)(plfont->resolution.x) + 0.5));

                }

                break;

            }

        case plfst_TrueType:

            {

                gs_font_type42 *pfont;

                {

                    static const pl_font_offset_errors_t errors = {

                        gs_error_invalidfont, 0

                    };

                    code =

                        pl_font_scan_segments(mem, plfont, 70, desc_size,

                                              (ulong) count - 2,

                                              pfh->HeaderFormat ==

                                              pcfh_truetype_large, &errors);

                    if (code < 0)

                        goto fail;

                    /* truetype large format 16 can be truetype or bitmap -

                       absurd */

                    if ((pfh->HeaderFormat == pcfh_truetype_large) &&

                        (plfont->scaling_technology == plfst_bitmap))

                        goto bitmap;

                }

                pfont =

                    gs_alloc_struct(mem, gs_font_type42, &st_gs_font_type42,

                                    "pcl_font_header(truetype font)");

                if (pfont == NULL) {

                    code = e_Memory;

                    goto fail;

                }

                code =

                    pl_fill_in_font((gs_font *) pfont, plfont, pcs->font_dir,

                                    mem, "nameless_font");

                if (code < 0)

                    goto fail;

                {

                    uint num_chars = pl_get_uint16(pfh->LastCode);

                    if (num_chars < 20)

                        num_chars = 20;

                    else if (num_chars > 300)

                        num_chars = 300;

                    code = pl_tt_alloc_char_glyphs(plfont, num_chars, mem,

                                                   "pcl_font_header(char_glyphs)");

                    if (code < 0)

                        goto fail;

                }

                code = pl_fill_in_tt_font(pfont, NULL, gs_next_ids(mem, 1));

                if (code < 0)

                    goto fail;

                {

                    uint pitch_cp =

                        (uint) (pl_get_uint16(pfh->Pitch) * 1000.0 /

                                pfont->data.unitsPerEm);

                    pl_fp_set_pitch_cp(&plfont->params, pitch_cp);

                }

            }

            break;

        case plfst_Intellifont:

            {

                gs_font_base *pfont =

                    gs_alloc_struct(mem, gs_font_base, &st_gs_font_base,

                                    "pcl_font_header(bitmap font)");

                if (pfont == NULL) {

                    code = e_Memory;

                    goto fail;

                }

                code =

                    pl_fill_in_font((gs_font *) pfont, plfont, pcs->font_dir,

                                    mem, "nameless_font");

                if (code < 0)

                    goto fail;

                pl_fill_in_intelli_font(pfont, gs_next_ids(mem, 1));

                {

                    uint pitch_cp =

                        (uint) (pl_get_uint16(pfh->Pitch) * 1000.0 / 8782.0);

                    pl_fp_set_pitch_cp(&plfont->params, pitch_cp);

                }

                break;

            }

        default:

            code = gs_error_invalidfont; /* can't happen */

            goto fail;

    }

    /* Extract common parameters from the font header. */

    plfont->params.symbol_set = pl_get_uint16(pfh->SymbolSet);

    if (pfh->Spacing > 1) {

        code = e_Range;

        goto fail;

    }

    plfont->params.proportional_spacing = pfh->Spacing;

    plfont->params.style = (pfh->StyleMSB << 8) + pfh->StyleLSB;

    plfont->params.stroke_weight =      /* signed byte */

        (int)(pfh->StrokeWeight ^ 0x80) - 0x80;

    plfont->params.typeface_family =

        (pfh->TypefaceMSB << 8) + pfh->TypefaceLSB;

    plfont->params.pjl_font_number = pcs->pjl_dlfont_number++;

    code = pl_dict_put(&pcs->soft_fonts, CURRENT_FONT_ID,

                CURRENT_FONT_ID_SIZE, plfont);

    if (code < 0) {

        /* on error, pl_dict_put consumes plfont */

        return code;

    }

    plfont->pfont->procs.define_font = gs_no_define_font;

    if ((code = gs_definefont(pcs->font_dir, plfont->pfont)) != 0) {

        goto fail;

    }

    if (plfont->scaling_technology == plfst_TrueType)

        code = pl_fapi_passfont(plfont, 0, NULL, NULL, NULL, 0);

    return code;

fail:

    if (code < 0)

        pl_free_font(mem, plfont, "pcl_font_header(pl_font_t)");

    return (code);

}

static int                      /* ESC * c <char_code> E */

pcl_character_code(pcl_args_t * pargs, pcl_state_t * pcs)

{

    pcs->character_code = uint_arg(pargs);

    return 0;

}

static int                      /* ESC ( s <count> W */

pcl_character_data(pcl_args_t * pargs, pcl_state_t * pcs)

{

    uint count = uint_arg(pargs);

    uint font_data_size = count;

    const byte *data = arg_data(pargs);

    void *value;

    pl_font_t *plfont;

    pcl_font_header_format_t format;

    byte *char_data = 0;

    int code;

#ifdef DEBUG

    if (gs_debug_c('i')) {

        pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs));

    }

#endif

    if (!pl_dict_find_no_stack(&pcs->soft_fonts, CURRENT_FONT_ID,

                               CURRENT_FONT_ID_SIZE, &value))

        return 0;               /* font not found */

    plfont = ((pl_font_t *) value);

    if (count < 4 || data[2] > count - 2)

        goto fail_range;

    if (data[1]) {              /* continuation */

        /* Check that we are continuing data - we know this is the

           case if the previous download character command byte count

           is smaller than the data indicated calculating the space

           for the glyph */

        if ((pcs->soft_font_char_data == 0))

            goto fail_range;

        /* NB we only enable this for uncompressed bitmap

           characters for now, since we don't have real world

           examples for the other font file formats.  */

        if (data[0] != pccd_bitmap && data[3] != 1) {

            dmprintf(pcs->memory,

                     "continuation not implemented for this font type\n");

            return e_Unimplemented;

        }

        /* check for buffer overrun */

        if (pcs->soft_font_count + count - 2 > gs_object_size(pcs->memory, pcs->soft_font_char_data))

            goto fail_range;

        /* append the new data to the new object */

        memcpy(pcs->soft_font_char_data + pcs->soft_font_count, data + 2,

               count - 2);

        /* update the continuation count */

        pcs->soft_font_count += (count - 2);

        return 0;

    } else {

        pcs->soft_font_count = 0;

        pcs->soft_font_char_data = 0;

    }

    format = (pcl_font_header_format_t)

        ((const pcl_font_header_t *)plfont->header)->HeaderFormat;

    switch (data[0]) {

        case pccd_bitmap:

            {

                uint width, height;

                if (data[2] != 14 ||

                    (format != pcfh_bitmap &&

                     format != pcfh_resolution_bitmap &&

                     format != pcfh_truetype_large)

                    )

                    goto fail_range;

                width = pl_get_uint16(data + 10);

                if (width < 1 || width > 16384)

                    goto fail_range;

                height = pl_get_uint16(data + 12);

                if (height < 1 || height > 16384)

                    goto fail_range;

                /* more error checking of offsets, delta, width and height. */

                {

                    int toff, loff;

                    int deltax;

                    loff = pl_get_int16(data + 6);

                    if ((-16384 > loff) || (loff > 16384))

                        goto fail_range;

                    toff = pl_get_int16(data + 8);

                    if ((-16384 > toff) || (toff > 16384))

                        goto fail_range;

                    deltax = pl_get_int16(data + 14);

                    if ((-32768 > deltax) || (deltax > 32767))

                        goto fail_range;

                    /* also reject if width * height larger than 1MByte */

                    if ((width * height / 8) > 1024 * 1024)

                        goto fail_range;

                }

                switch (data[3]) {

                    case 1:    /* uncompressed bitmap */

                        font_data_size = 16 + (((width + 7) >> 3) * height);

                        break;

                    case 2:    /* compressed bitmap */

                        {

                            uint y = 0;

                            const byte *src = data + 16;

                            const byte *end = data + count;

                            uint width_bytes = (width + 7) >> 3;

                            byte *row;

                            font_data_size = 16 + width_bytes * height;

                            char_data =

                                gs_alloc_bytes(pcs->memory,

                                               font_data_size,

                                               "pcl_character_data(compressed bitmap)");

                            if (char_data == 0)

                                return_error(e_Memory);

                            memcpy(char_data, data, 16);

                            memset(char_data + 16, 0, (size_t)width_bytes * height);

                            row = char_data + 16;

                            while (src < end && y < height) {   /* Read the next compressed row. */

                                uint x;

                                int color = 0;

                                uint reps = *src++;

                                for (x = 0; src < end && x < width; color ^= 1) {       /* Read the next run. */

                                    uint rlen = *src++;

                                    if (rlen > width - x)

                                        goto fail_range; /* row overrun */

                                    if (color) {        /* Set the run to black. */

                                        char *data = (char *)row;

                                        while (rlen--) {

                                            data[x >> 3] |= (128 >> (x & 7));

                                            x++;

                                        }

                                    } else

                                        x += rlen;

                                }

                                row += width_bytes;

                                ++y;

                                /* Replicate the row if needed. */

                                for (; reps > 0 && y < height;

                                     --reps, ++y, row += width_bytes)

                                    memcpy(row, row - width_bytes,

                                           width_bytes);

                            }

                        }

                        break;

                    default:

                        goto fail_range;

                }

            }

            break;

        case pccd_intellifont:

            if (data[2] != 2 ||

                (format != pcfh_intellifont_bound &&

                 format != pcfh_intellifont_unbound)

                )

                goto fail_range;

            switch (data[3]) {

                case 3:        /* non-compound character */

                    /* See TRM Table 11-41 (p. 11-60) for the following. */

                    if (count < 14)

                        goto fail_range;

                    {

                        uint data_size = pl_get_uint16(data + 4);

                        /* The contour data excludes 4 initial bytes of header */

                        /* and 2 final bytes of padding/checksum. */

                        if (data_size != count - 6)

                            goto fail_range;

                    }

                    break;

                case 4:        /* compound character */

                    /* See TRM Figure 11-42 and 11-43 (p. 11-61) */

                    /* for the following. */

                    if (count < 8)

                        goto fail_range;

                    {

                        uint num_components = data[6];

                        if (count != 8 + num_components * 6 + 2)

                            goto fail_range;

                    }

                    break;

                default:

                    goto fail_range;

            }

            break;

        case pccd_truetype:

            if (format != pcfh_truetype && format != pcfh_truetype_large)

                goto fail_range;

            break;

        default:

            goto fail_range;

    }

    /* Register the character. */

    /**** FREE PREVIOUS DEFINITION ****/

    /* Compressed bitmaps have already allocated and filled in */

    /* the character data structure. */

    if (char_data == 0) {

        char_data = gs_alloc_bytes(pcs->memory, font_data_size,

                                   "pcl_character_data");

        if (char_data == 0)

            return_error(e_Memory);

        memset(char_data, 0, font_data_size);

        /* if count > font_data_size extra data is ignored */

        memcpy(char_data, data, min(count, font_data_size));

        /* NB we only handle continuation for uncompressed bitmap characters */

        if (data[0] == pccd_bitmap && data[3] == 1 && font_data_size > count    /* expecting continuation */

            ) {

            pcs->soft_font_char_data = char_data;

            pcs->soft_font_count = count;

        } else {

            pcs->soft_font_char_data = 0;

            pcs->soft_font_count = 0;

        }

    }

    /* get and set the orientation field */

    {

        pcl_font_header_t *header = (pcl_font_header_t *) plfont->header;

        plfont->orient = header->Orientation;

    }

    code = pl_font_add_glyph(plfont, pcs->character_code, char_data, font_data_size);

    if (code < 0) {

        gs_free_object(pcs->memory, char_data, "pcl_character_data");

        return code;

    }

#ifdef DISABLE_USE_MY_METRICS

    if (data[0] == pccd_truetype)

        code = pl_font_disable_composite_metrics(plfont, pcs->character_code);

#endif /* DISABLE_USE_MY_METRICS */

    return code;

#undef plfont

    fail_range:

    gs_free_object(pcs->memory, char_data, "pcl_character_data");

    return e_Range;

}

/* template for casting data to command */

typedef struct alphanumeric_data_s

{

    byte operation;

    byte string_id[512];

} alphanumeric_data_t;

typedef enum resource_type_enum

{

    macro_resource,

    font_resource

} resource_type_t;

/*

 * Search the PJL file system for a macro or font resource and

 * associate it's name with the current font or macro id

 */

static int

pcl_find_resource(pcl_state_t * pcs,

                  const byte sid[],

                  int sid_size, resource_type_t resource_type)

{

    void *value = NULL;

    char alphaname[512 + 1];

    long int size;

    int c;

    int code = 0;

    /* a null terminated string is needed for the PJL resource call */

    for (c = 0; c < sid_size && c < 512; c++)

        alphaname[c] = sid[c];

    alphaname[c] = '\0';

    size = pjl_proc_get_named_resource_size(pcs->pjls, alphaname);

    /* resource not found */

    if (size <= 0)

        return 0;

    /* for a macro we need enough room for the macro header plus the

       macro itself, fonts are handled differently, see below */

    value = gs_alloc_bytes(pcs->memory,

                           size +

                           (resource_type == macro_resource ?

                            sizeof(pcl_macro_t) : 0),

                           "resource");

    if (value == NULL)

        return_error(gs_error_Fatal);

    if (pjl_proc_get_named_resource(pcs->pjls, alphaname,

                                        (byte *) value +

                                        (resource_type == macro_resource ?

                                         sizeof(pcl_macro_t) : 0), size) < 0) {

        gs_free_object(pcs->memory, value, "resource");

        return_error(gs_error_Fatal);

    }

    /* if this is a font we have to recursively invoke the PCL

       interpreter to process the data and create the downloaded

       font. */

    if (resource_type == font_resource) {