/* Copyright (C) 2001-2020 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.,  1305 Grant Avenue - Suite 200, Novato,

   CA 94945, U.S.A., +1(415)492-9861, for further information.

*/

/* Text processing for pdfwrite. */

#include "math_.h"

#include "string_.h"

#include <stdlib.h> /* abs() */

#include "gx.h"

#include "gserrors.h"

#include "gscencs.h"

#include "gscedata.h"

#include "gsmatrix.h"

#include "gzstate.h"

#include "gxfcache.h"                /* for orig_fonts list */

#include "gxfont.h"

#include "gxfont0.h"

#include "gxfcid.h"

#include "gxfcopy.h"

#include "gxfcmap.h"

#include "gxpath.h"                /* for getting current point */

#include "gxchar.h"

#include "gxstate.h"

#include "gdevpdfx.h"

#include "gdevpdfg.h"

#include "gdevpdfo.h"

#include "gdevpdtx.h"

#include "gdevpdtd.h"

#include "gdevpdtf.h"

#include "gdevpdts.h"

#include "gdevpdtt.h"

#include "gdevpdti.h"

#include "gxhldevc.h"

#include "gzpath.h"

/* ================ Text enumerator ================ */

/* GC descriptor */

private_st_pdf_text_enum();

/* Define the auxiliary procedures for text processing. */

static int

pdf_text_resync(gs_text_enum_t *pte, const gs_text_enum_t *pfrom)

{

    pdf_text_enum_t *const penum = (pdf_text_enum_t *)pte;

    if ((pte->text.operation ^ pfrom->text.operation) & ~TEXT_FROM_ANY)

        return_error(gs_error_rangecheck);

    if (penum->pte_default) {

        int code = gs_text_resync(penum->pte_default, pfrom);

        if (code < 0)

            return code;

    }

    pte->text = pfrom->text;

    gs_text_enum_copy_dynamic(pte, pfrom, false);

    return 0;

}

static bool

pdf_text_is_width_only(const gs_text_enum_t *pte)

{

    const pdf_text_enum_t *const penum = (const pdf_text_enum_t *)pte;

    if (penum->pte_default)

        return gs_text_is_width_only(penum->pte_default);

    return false;

}

static int

pdf_text_current_width(const gs_text_enum_t *pte, gs_point *pwidth)

{

    const pdf_text_enum_t *const penum = (const pdf_text_enum_t *)pte;

    if (penum->pte_default)

        return gs_text_current_width(penum->pte_default, pwidth);

    return_error(gs_error_rangecheck); /* can't happen */

}

static int

pdf_text_set_cache(gs_text_enum_t *pte, const double *pw,

                   gs_text_cache_control_t control)

{

    pdf_text_enum_t *penum;

    gs_text_enum_t *pgste;

    gx_device_pdf *pdev = (gx_device_pdf *)pte->dev;

    gs_matrix m;

    if (pdev->pte != NULL)

        penum = (pdf_text_enum_t *)pdev->pte;

    else {

        if (gs_object_type(pte->memory, pte) == &st_pdf_text_enum)

            penum = (pdf_text_enum_t *)pte;

        else

            return_error(gs_error_typecheck);

    }

    if (pdev->type3charpath)

        return gs_text_set_cache(penum->pte_default, pw, control);

    switch (control) {

    case TEXT_SET_CHAR_WIDTH:

    case TEXT_SET_CACHE_DEVICE:

        /* See comments in pdf_text_process. We are using a 100x100 matrix

         * NOT the identity, but we want the cache device values to be in

         * font co-ordinate space, so we need to undo that scale here.

         */

        if (pdev->PS_accumulator){

            gs_matrix_scale(&ctm_only(pte->pgs), .01, .01, &m);

            gs_distance_transform(pw[0], pw[1], &m, &pdev->char_width);

        } else {

            pdev->char_width.x = pw[0];

            pdev->char_width.y = pw[1];

        }

        break;

    case TEXT_SET_CACHE_DEVICE2:

        /*

         * pdev->char_width is used with synthesized Type 3 fonts only.

         * Since they are simple fonts, we only need the horisontal

         * width for Widths array. Therefore we don't check

         * gs_rootfont(pgs)->WMode and don't use pw[6:7].

         */

        /* See comments in pdf_text_process. We are using a 100x100 matrix

         * NOT the identity, but we want the cache device values to be in

         * font co-ordinate space, so we need to undo that scale here.

         */

        if (pdev->PS_accumulator){

            gs_matrix_scale(&ctm_only(pte->pgs), .01, .01, &m);

            gs_distance_transform(pw[0], pw[1], &m, &pdev->char_width);

        } else {

            pdev->char_width.x = pw[0];

            pdev->char_width.y = pw[1];

        }

        if (penum->cdevproc_callout) {

            memcpy(penum->cdevproc_result, pw, sizeof(penum->cdevproc_result));

            return 0;

        }

        break;

    default:

        return_error(gs_error_rangecheck);

    }

    if (!pdev->PS_accumulator)

        pgste = (gs_text_enum_t *)penum;

    else

        pgste = penum->pte_default;

    if ((penum->current_font->FontType == ft_user_defined ||

        penum->current_font->FontType == ft_PDF_user_defined ||

        penum->current_font->FontType == ft_PCL_user_defined ||

        penum->current_font->FontType == ft_MicroType ||

        penum->current_font->FontType == ft_GL2_stick_user_defined ||

        penum->current_font->FontType == ft_GL2_531) &&

            penum->outer_CID == GS_NO_GLYPH &&

            !(pgste->text.operation & TEXT_DO_CHARWIDTH)) {

        int code;

        gs_glyph glyph;

        glyph = pte->returned.current_glyph;

        if ((glyph != GS_NO_GLYPH && penum->output_char_code != GS_NO_CHAR) || !pdev->PS_accumulator) {

            gs_show_enum *penum_s;

            gs_fixed_rect clip_box;

            double pw1[10];

            int narg = (control == TEXT_SET_CHAR_WIDTH ? 2 :

                        control == TEXT_SET_CACHE_DEVICE ? 6 : 10), i;

            penum_s = (gs_show_enum *)pgste;

            /* BuildChar could change the scale before calling setcachedevice (Bug 687290).

               We must scale the setcachedevice arguments because we assumed

               identity scale before entering the charproc.

               For now we only handle scaling matrices.

            */

            for (i = 0; i < narg; i += 2) {

                gs_point p;

                gs_point_transform(pw[i], pw[i + 1], &ctm_only(penum_s->pgs), &p);

                pw1[i] = p.x;

                pw1[i + 1] = p.y;

            }

            if (control != TEXT_SET_CHAR_WIDTH) {

                clip_box.p.x = float2fixed(pw1[2]);

                clip_box.p.y = float2fixed(pw1[3]);

                clip_box.q.x = float2fixed(pw1[4]);

                clip_box.q.y = float2fixed(pw1[5]);

            } else {

                /*

                 * We have no character bbox, but we need one to install the clipping

                 * to the graphic state of the PS interpreter. Since some fonts don't

                 * provide a proper FontBBox (Bug 687239 supplies a zero one),

                 * we set an "infinite" clipping here.

                 * We also detected that min_int, max_int don't work here with

                 * comparefiles/Bug687044.ps, therefore we divide them by 2.

                 */

                clip_box.p.x = clip_box.p.y = min_int / 2;

                clip_box.q.x = clip_box.q.y = max_int / 2;

            }

            code = gx_clip_to_rectangle(penum_s->pgs, &clip_box);

            if (code < 0)

                return code;

            /* See comments in pdf_text_process. We are using a 100x100 matrix

             * NOT the identity, but we want the cache device values to be in

             * font co-ordinate space, so we need to undo that scale here. We

             * can't do it above, where we take any scaling from the BuildChar

             * into account, because that would get the clip path wrong, that

             * needs to be in the 100x100 space so that it doesn't clip

             * out marking operations.

             */

            if (pdev->PS_accumulator)

                gs_matrix_scale(&ctm_only(penum_s->pgs), .01, .01, &m);

            else

                m = ctm_only(penum_s->pgs);

            for (i = 0; i < narg; i += 2) {

                gs_point p;

                gs_point_transform(pw[i], pw[i + 1], &m, &p);

                pw1[i] = p.x;

                pw1[i + 1] = p.y;

            }

            if (!pdev->PS_accumulator)

                code = pdf_set_charproc_attrs(pdev, pte->current_font,

                        pw1, narg, control, penum->returned.current_char, false);

            else

                code = pdf_set_charproc_attrs(pdev, pte->current_font,

                        pw1, narg, control, penum->output_char_code, true);

            if (code < 0)

                return code;

            /* Prevent writing the clipping path to charproc.

               See the comment above and bugs 687678, 688327.

               Note that the clipping in the graphic state will be used while

               fallbacks to default implementations of graphic objects.

               Hopely such fallbacks are rare. */

            pdev->clip_path_id = gx_get_clip_path_id(penum_s->pgs);

            return code;

        } else {

            gs_matrix m;

            pdf_resource_t *pres = pdev->accumulating_substream_resource;

            /* pdf_text_process started a charproc stream accumulation,

               but now we re-decided to go with the default implementation.

               Cancel the stream now.

             */

            code = pdf_exit_substream(pdev);

            if (code < 0)

                return code;

            code = pdf_cancel_resource(pdev, pres, resourceCharProc);

            if (code < 0)

                return code;

            pdf_forget_resource(pdev, pres, resourceCharProc);

            /* pdf_text_process had set an identity CTM for the

               charproc stream accumulation, but now we re-decided

               to go with the default implementation.

               Need to restore the correct CTM and add

               changes, which the charproc possibly did. */

            /* See comments in pdf_text_process. We are using a 100x100 matrix

             * NOT the identity,  so we need to undo that scale here.

             */

            gs_matrix_scale(&ctm_only(penum->pgs), .01, .01, (gs_matrix *)&ctm_only(penum->pgs));

            /* We also scaled the page height and width. Because we

             * don't go through the accumulator 'close' in pdf_text_process

             * we must also undo that scale.

             */

            pdev->width /= 100;

            pdev->height /= 100;

            gs_matrix_multiply((gs_matrix *)&pdev->charproc_ctm, (gs_matrix *)&penum->pgs->ctm, &m);

            gs_matrix_fixed_from_matrix(&penum->pgs->ctm, &m);

            penum->charproc_accum = false;

            pdev->accumulating_charproc = false;

        }

    }

    if (pdev->PS_accumulator && penum->pte_default) {

        if (penum->pte_default->text.operation & TEXT_DO_CHARWIDTH /* See process_cmap_text.*/)

            return gs_text_set_cache(penum->pte_default, pw, TEXT_SET_CHAR_WIDTH);

        else

            return gs_text_set_cache(penum->pte_default, pw, control);

    }

    return_error(gs_error_unregistered); /* can't happen */

}

static int

pdf_text_retry(gs_text_enum_t *pte)

{

    pdf_text_enum_t *const penum = (pdf_text_enum_t *)pte;

    if (penum->pte_default)

        return gs_text_retry(penum->pte_default);

    return_error(gs_error_rangecheck); /* can't happen */

}

static void

pdf_text_release(gs_text_enum_t *pte, client_name_t cname)

{

    pdf_text_enum_t *const penum = (pdf_text_enum_t *)pte;

    if (penum->pte_default) {

        gs_text_release(penum->pte_default, cname);

        penum->pte_default = 0;

    }

    pdf_text_release_cgp(penum);

    gx_default_text_release(pte, cname);

}

void

pdf_text_release_cgp(pdf_text_enum_t *penum)

{

    if (penum->cgp) {

        gs_free_object(penum->memory, penum->cgp, "pdf_text_release");

        penum->cgp = 0;

    }

}

/* Begin processing text. */

static text_enum_proc_process(pdf_text_process);

static const gs_text_enum_procs_t pdf_text_procs = {

    pdf_text_resync, pdf_text_process,

    pdf_text_is_width_only, pdf_text_current_width,

    pdf_text_set_cache, pdf_text_retry,

    pdf_text_release

};

/* Ideally we would set the stroke and fill colours in pdf_prepare_text_drawing

 * but this is called from pdf_process_text, not pdf_begin_text. The problem is

 * that if we get a pattern colour we need to exit to the interpreter and run

 * the PaintProc, we do this by retunring e_ReampColor. But the 'process' routines

 * aren't set up to accept this, and just throw an error. Trying to rework the

 * interpreter routines began turning into a gigantic task, so I chose instead

 * to 'set' the colours here, which is called from text_begin, where the code

 * allows us to return_error(gs_error_RemapColor. Attempting to write the colour to the PDF file

 * in this routine as well caused trouble keeping the graphics states synchronised,

 * so this functionality was left in pdf_prepare_text_drawing.

 */

static int

pdf_prepare_text_color(gx_device_pdf *const pdev, gs_gstate *pgs, const gs_text_params_t *text, gs_font *font)

{

    int code=0;

    if (text->operation & TEXT_DO_DRAW) {

        if (!pdev->ForOPDFRead) {

            if (pgs->text_rendering_mode != 3 && pgs->text_rendering_mode != 7) {

                if (font->PaintType == 2) {

                    /* Bit awkward, if the PaintType is 2 then we want to set the

                     * current ie 'fill' colour, but as a stroke colour because we

                     * will later change the text rendering mode to 1 (stroke).

                     */

                    code = gx_set_dev_color(pgs);

                    if (code != 0)

                        return code;

                    code = pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_stroke_color,

                                 &pdev->stroke_used_process_color,

                                 &psdf_set_stroke_color_commands);

                    if (code < 0)

                        return code;

                } else {

                    if ((pgs->text_rendering_mode == 0 || pgs->text_rendering_mode == 2 ||

                        pgs->text_rendering_mode == 4 || pgs->text_rendering_mode == 6) &&

                        !pdev->remap_stroke_color) {

                        code = gx_set_dev_color(pgs);

                        if (code != 0)

                            return code;

                    }

                    if (pgs->text_rendering_mode == 1 || pgs->text_rendering_mode == 2 ||

                        pgs->text_rendering_mode == 5 || pgs->text_rendering_mode == 6) {

                        if (!pdev->remap_fill_color) {

                            if (pdev->remap_stroke_color) {

                                pdev->remap_stroke_color = false;

                            } else {

                                gs_swapcolors_quick(pgs);

                                code = gx_set_dev_color(pgs);

                                if (code == gs_error_Remap_Color)

                                    pdev->remap_stroke_color = true;

                                if (code != 0)

                                    return code;

                            }

                        } else

                            pdev->remap_fill_color = false;

                        gs_swapcolors_quick(pgs);

                        code = gx_set_dev_color(pgs);

                        if (code == gs_error_Remap_Color)

                            pdev->remap_fill_color = true;

                        if (code != 0)

                            return code;

                    }

                }

            }

        }

    }

    return code;

}

static int

pdf_prepare_text_drawing(gx_device_pdf *const pdev, gs_text_enum_t *pte)

{

    gs_gstate * pgs = pte->pgs;

    const gx_clip_path * pcpath = pte->pcpath;

    const gs_text_params_t *text = &pte->text;

    bool new_clip = false; /* Quiet compiler. */

    int code;

    gs_font *font = pte->current_font;

    if (!(text->operation & TEXT_DO_NONE) || pgs->text_rendering_mode == 3) {

        code = pdf_check_soft_mask(pdev, pte->pgs);

        if (code < 0)

            return code;

        new_clip = pdf_must_put_clip_path(pdev, pcpath);

        if (new_clip)

            code = pdf_unclip(pdev);

        else if (pdev->context == PDF_IN_NONE)

            code = pdf_open_page(pdev, PDF_IN_STREAM);

        else

            code = 0;

        if (code < 0)

            return code;

        code = pdf_prepare_fill(pdev, pgs, true);

        if (code < 0)

            return code;

    }

    if (text->operation & TEXT_DO_DRAW) {

        /*

         * Set the clipping path and drawing color.  We set both the fill

         * and stroke color, because we don't know whether the fonts will be

         * filled or stroked, and we can't set a color while we are in text

         * mode.  (This is a consequence of the implementation, not a

         * limitation of PDF.)

         */

        if (new_clip) {

            code = pdf_put_clip_path(pdev, pcpath);

            if (code < 0)

                return code;

        }

        if (!pdev->ForOPDFRead) {

            if (pgs->text_rendering_mode != 3 && pgs->text_rendering_mode != 7) {

                if (font->PaintType == 2) {

                    /* Bit awkward, if the PaintType is 2 then we want to set the

                     * current ie 'fill' colour, but as a stroke colour because we

                     * will later change the text rendering mode to 1 (stroke).

                     */

                    code = gx_set_dev_color(pgs);

                    if (code != 0)

                        return code;

                    code = pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_stroke_color,

                                 &pdev->stroke_used_process_color,

                                 &psdf_set_stroke_color_commands);

                    if (code < 0)

                        return code;

                } else {

                    if (pgs->text_rendering_mode == 0 || pgs->text_rendering_mode == 2 ||

                        pgs->text_rendering_mode == 4 || pgs->text_rendering_mode == 6) {

                        code = gx_set_dev_color(pgs);

                        if (code != 0)

                            return code;

                        code = pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_fill_color,

                                     &pdev->fill_used_process_color,

                                     &psdf_set_fill_color_commands);

                        if (code < 0)

                            return code;

                    }

                    if (pgs->text_rendering_mode == 1 || pgs->text_rendering_mode == 2 ||

                        pgs->text_rendering_mode == 5 || pgs->text_rendering_mode == 6) {

                        gs_swapcolors_quick(pgs);

                        code = gx_set_dev_color(pgs);

                        if (code != 0)

                            return code;

                        code = pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_stroke_color,

                                     &pdev->stroke_used_process_color,

                                     &psdf_set_stroke_color_commands);

                        if (code < 0)

                            return code;

                        gs_swapcolors_quick(pgs);

                    }

                }

            }

        } else {

            code = gx_set_dev_color(pgs);

            if (code != 0)

                return code;

            if ((code =

                 pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_stroke_color,

                                       &pdev->stroke_used_process_color,

                                       &psdf_set_stroke_color_commands)) < 0 ||

                (code =

                 pdf_set_drawing_color(pdev, pgs, pgs->color[0].dev_color, &pdev->saved_fill_color,

                                       &pdev->fill_used_process_color,

                                       &psdf_set_fill_color_commands)) < 0

                )

                return code;

        }

    }

    return 0;

}

int

gdev_pdf_text_begin(gx_device * dev, gs_gstate * pgs,

                    const gs_text_params_t *text, gs_font * font,

                    gx_path * path0, const gx_device_color * pdcolor,

                    const gx_clip_path * pcpath,

                    gs_memory_t * mem, gs_text_enum_t ** ppte)

{

    gx_device_pdf *const pdev = (gx_device_pdf *)dev;

    gx_path *path = path0;

    pdf_text_enum_t *penum;

    int code, user_defined = 0;

    /* should we "flatten" the font to "normal" marking operations */

    if (pdev->FlattenFonts) {

        font->dir->ccache.upper = 0;

        return gx_default_text_begin(dev, pgs, text, font, path, pdcolor,

                                         pcpath, mem, ppte);

    }

    /* Track the dominant text rotation. */

    {

        gs_matrix tmat;

        gs_point p;

        int i;

        gs_matrix_multiply(&font->FontMatrix, &ctm_only(pgs), &tmat);

        gs_distance_transform(1, 0, &tmat, &p);

        if (p.x > fabs(p.y))

            i = 0;

        else if (p.x < -fabs(p.y))

            i = 2;

        else if (p.y > fabs(p.x))

            i = 1;

        else if (p.y < -fabs(p.x))

            i = 3;

        else

            i = 4;

        pdf_current_page(pdev)->text_rotation.counts[i] += text->size;

    }

    pdev->last_charpath_op = 0;

    if ((text->operation & TEXT_DO_ANY_CHARPATH) && !path0->first_subpath) {

        if (pdf_compare_text_state_for_charpath(pdev->text->text_state, pdev, pgs, font, text))

            pdev->last_charpath_op = text->operation & TEXT_DO_ANY_CHARPATH;

    }

    if(font->FontType == ft_user_defined ||

       font->FontType == ft_PDF_user_defined ||

       font->FontType == ft_PCL_user_defined ||

       font->FontType == ft_MicroType ||

       font->FontType == ft_GL2_stick_user_defined ||

       font->FontType == ft_GL2_531)

        user_defined = 1;

    /* We need to know whether any of the glyphs in a string using a composite font

     * use a descendant font which is a type 3 (user-defined) so that we can properly

     * skip the caching below.

     */

    if(font->FontType == ft_composite && ((gs_font_type0 *)font)->data.FMapType != fmap_CMap) {

        int font_code;

        gs_char chr;

        gs_glyph glyph;

        rc_alloc_struct_1(penum, pdf_text_enum_t, &st_pdf_text_enum, mem,

                      return_error(gs_error_VMerror), "gdev_pdf_text_begin");

        penum->rc.free = rc_free_text_enum;

        penum->pte_default = 0;

        penum->charproc_accum = false;

        pdev->accumulating_charproc = false;

        penum->cdevproc_callout = false;

        penum->returned.total_width.x = penum->returned.total_width.y = 0;

        penum->cgp = NULL;

        penum->output_char_code = GS_NO_CHAR;

        code = gs_text_enum_init((gs_text_enum_t *)penum, &pdf_text_procs,

                             dev, pgs, text, font, path, pdcolor, pcpath, mem);

        if (code < 0) {

            gs_free_object(mem, penum, "gdev_pdf_text_begin");

            return code;

        }

        do {

            font_code = penum->orig_font->procs.next_char_glyph

                ((gs_text_enum_t *)penum, &chr, &glyph);

            if (font_code == 1){

                if (penum->fstack.items[penum->fstack.depth].font->FontType == 3) {

                    user_defined = 1;

                    break;

                }

            }

        } while(font_code != 2 && font_code >= 0);

        if (!user_defined) {

            if (penum->fstack.items[penum->fstack.depth].font->FontType == 3)

                user_defined = 1;

        }

        gs_text_release((gs_text_enum_t *)penum, "pdf_text_process");

    }

    if (!user_defined || !(text->operation & TEXT_DO_ANY_CHARPATH)) {

        if (user_defined &&

            (text->operation & TEXT_DO_NONE) && (text->operation & TEXT_RETURN_WIDTH)

            && pgs->text_rendering_mode != 3) {

            /* This is stringwidth, see gx_default_text_begin.

             * We need to prevent writing characters to PS cache,

             * otherwise the font converts to bitmaps.

             * So pass through even with stringwidth.

             */

            code = gx_hld_stringwidth_begin(pgs, &path);

            if (code < 0)

                return code;

        } else if ((!(text->operation & TEXT_DO_DRAW) && pgs->text_rendering_mode != 3)

                    || path == 0 || !path_position_valid(path)

                    || pdev->type3charpath)

            return gx_default_text_begin(dev, pgs, text, font, path, pdcolor,

                                         pcpath, mem, ppte);

        else if (text->operation & TEXT_DO_ANY_CHARPATH)

            return gx_default_text_begin(dev, pgs, text, font, path, pdcolor,

                                         pcpath, mem, ppte);

    }

    if (!pdev->ForOPDFRead) {

    code = pdf_prepare_text_color(pdev, pgs, text, font);

    if (code != 0)

        return code;

    }

    /* Allocate and initialize the enumerator. */

    rc_alloc_struct_1(penum, pdf_text_enum_t, &st_pdf_text_enum, mem,

                      return_error(gs_error_VMerror), "gdev_pdf_text_begin");

    penum->rc.free = rc_free_text_enum;

    penum->pte_default = 0;

    penum->charproc_accum = false;

    pdev->accumulating_charproc = false;

    penum->cdevproc_callout = false;

    penum->returned.total_width.x = penum->returned.total_width.y = 0;

    penum->cgp = NULL;

    penum->output_char_code = GS_NO_CHAR;

    code = gs_text_enum_init((gs_text_enum_t *)penum, &pdf_text_procs,

                             dev, pgs, text, font, path, pdcolor, pcpath, mem);

    if (code < 0) {

        gs_free_object(mem, penum, "gdev_pdf_text_begin");

        return code;

    }

    if (pdev->font3 != 0) {

        /* A text operation happens while accumulating a charproc.

           This is a case when source document uses a Type 3 font,

           which's charproc uses another font.

           Since the text operation is handled by the device,

           the font isn't converting to a raster (i.e. to a bitmap font).

           Disable the grid fitting for the convertion to get a proper outlines,

           because the viewer resolution is not known during the accumulation.

           Note we set identity CTM in pdf_text_set_cache for the accumilation,

           and therefore the font may look too small while the source charproc

           interpretation. The document tpc2.ps of the bug 687087 is an example.

        */

        penum->device_disabled_grid_fitting = true;

    }

    *ppte = (gs_text_enum_t *)penum;

    return 0;

}

/* ================ Font cache element ================ */

/* GC descriptor */

private_st_pdf_font_cache_elem();

/*

 * Compute id for a font cache element.

 */

static ulong

pdf_font_cache_elem_id(gs_font *font)

{

    return font->id;

}

pdf_font_cache_elem_t **

pdf_locate_font_cache_elem(gx_device_pdf *pdev, gs_font *font)

{

    pdf_font_cache_elem_t **e = &pdev->font_cache;

    long id = pdf_font_cache_elem_id(font);

    for (; *e != 0; e = &(*e)->next)

        if ((*e)->font_id == id) {

            return e;

        }

    return 0;

}

static void

pdf_remove_font_cache_elem(gx_device_pdf *pdev, pdf_font_cache_elem_t *e0)

{

    pdf_font_cache_elem_t **e = &pdev->font_cache;

    for (; *e != 0; e = &(*e)->next)

        if (*e == e0) {

            *e = e0->next;

            gs_free_object(pdev->pdf_memory, e0->glyph_usage,

                                "pdf_remove_font_cache_elem");

            gs_free_object(pdev->pdf_memory, e0->real_widths,

                                "pdf_remove_font_cache_elem");

            /* Clean pointers, because gs_free_object below may work idle

               when this function is called by a garbager notification.

               Leaving unclean pointers may cause

               a further heap validation to fail

               since the unfreed structure points to freed areas.

               For instance, e0->next may point to an element,

               which is really freed with a subsequent 'restore'.

               Bug 688837. */

            e0->next = 0;

            e0->glyph_usage = 0;

            e0->real_widths = 0;

            gs_free_object(pdev->pdf_memory, e0,

                                "pdf_remove_font_cache_elem");

            return;

        }

}

static void

font_cache_elem_array_sizes(gx_device_pdf *pdev, gs_font *font,

                            int *num_widths, int *num_chars)

{

    switch (font->FontType) {

    case ft_composite:

        *num_widths = 0; /* Unused for Type 0 */

        *num_chars = 65536; /* No chance to determine, use max. */

        break;

    case ft_encrypted:

    case ft_encrypted2:

    case ft_user_defined:

    case ft_PDF_user_defined:

    case ft_GL2_stick_user_defined:

    case ft_PCL_user_defined:

    case ft_MicroType:

    case ft_GL2_531:

    case ft_disk_based:

    case ft_Chameleon:

    case ft_TrueType:

        *num_widths = *num_chars = 256; /* Assuming access to glyph_usage by character codes */

        break;

    case ft_CID_encrypted:

        *num_widths = *num_chars = ((gs_font_cid0 *)font)->cidata.common.MaxCID + 1;

        break;

    case ft_CID_TrueType:

        *num_widths = *num_chars = ((gs_font_cid2 *)font)->cidata.common.CIDCount;

        break;

    default:

        *num_widths = *num_chars = 65536; /* No chance to determine, use max. */

    }

}

static int

alloc_font_cache_elem_arrays(gx_device_pdf *pdev, pdf_font_cache_elem_t *e,

                             gs_font *font)

{

    int num_widths, num_chars, len;

    font_cache_elem_array_sizes(pdev, font, &num_widths, &num_chars);

    len = (num_chars + 7) / 8;

    e->glyph_usage = gs_alloc_bytes(pdev->pdf_memory,

                        len, "alloc_font_cache_elem_arrays");

    e->real_widths = (num_widths > 0 ? (double *)gs_alloc_bytes(pdev->pdf_memory,

                        num_widths * sizeof(*e->real_widths) *

                            ((font->FontType == ft_user_defined ||

                            font->FontType == ft_PDF_user_defined ||

                            font->FontType == ft_GL2_stick_user_defined ||

                            font->FontType == ft_PCL_user_defined ||

                            font->FontType == ft_MicroType ||

                            font->FontType == ft_GL2_531) ? 2 : 1),

                        "alloc_font_cache_elem_arrays") : NULL);

    if (e->glyph_usage == NULL || (num_widths !=0 && e->real_widths == NULL)) {

        gs_free_object(pdev->pdf_memory, e->glyph_usage,

                            "pdf_attach_font_resource");

        gs_free_object(pdev->pdf_memory, e->real_widths,

                            "alloc_font_cache_elem_arrays");

        return_error(gs_error_VMerror);

    }

    e->num_chars = num_chars;

    e->num_widths = num_widths;

    memset(e->glyph_usage, 0, len);

    if (e->real_widths != NULL)

        memset(e->real_widths, 0, num_widths * sizeof(*e->real_widths));

    return 0;

}

int

pdf_free_font_cache(gx_device_pdf *pdev)

{

    pdf_font_cache_elem_t *e = pdev->font_cache, *next;

    /* fixed! fixme : release elements.

     * We no longer track font_cache elements in the original font, which is where

     * the memory used to be released. So now we must release it ourselves.

     */

    while (e != NULL) {

        next = e->next;

        pdf_remove_font_cache_elem(pdev, e);

        e = next;

    }

    pdev->font_cache = NULL;

    return 0;

}

/*

 * Retrive font resource attached to a font,

 * allocating glyph_usage and real_widths on request.

 */

int

pdf_attached_font_resource(gx_device_pdf *pdev, gs_font *font,

                            pdf_font_resource_t **pdfont, byte **glyph_usage,

                            double **real_widths, int *num_chars, int *num_widths)

{

    pdf_font_cache_elem_t **e = pdf_locate_font_cache_elem(pdev, font);

    if (e != NULL && (((*e)->glyph_usage == NULL && glyph_usage !=NULL) ||

                      ((*e)->real_widths == NULL && real_widths !=NULL))) {

        int code = alloc_font_cache_elem_arrays(pdev, *e, font);

        if (code < 0)

            return code;

    }

    *pdfont = (e == NULL ? NULL : (*e)->pdfont);

    if (glyph_usage != NULL)

        *glyph_usage = (e == NULL ? NULL : (*e)->glyph_usage);

    if (real_widths != NULL)

        *real_widths = (e == NULL ? NULL : (*e)->real_widths);

    if (num_chars != NULL)

        *num_chars = (e == NULL ? 0 : (*e)->num_chars);

    if (num_widths != NULL)

        *num_widths = (e == NULL ? 0 : (*e)->num_widths);

    return 0;

}

/*

 * Attach font resource to a font.

 */

int

pdf_attach_font_resource(gx_device_pdf *pdev, gs_font *font,

                         pdf_font_resource_t *pdfont)

{

    int num_chars, num_widths, len;

    pdf_font_cache_elem_t *e, **pe = pdf_locate_font_cache_elem(pdev, font);

    /* Allow the HPGL2 stick font to be attached to a type 3 font, it *is* a

     * type 3 font, its just identified differently so that we can choose not

     * to capture it elsewhere. Same for PCL bitmap fonts.

     */

    if (pdfont->FontType != font->FontType &&

        (pdfont->FontType != ft_user_defined ||

        (font->FontType != ft_PCL_user_defined &&

        font->FontType != ft_PDF_user_defined &&

        font->FontType != ft_MicroType &&

        font->FontType != ft_GL2_stick_user_defined &&

        font->FontType != ft_GL2_531)))

        return_error(gs_error_unregistered); /* Must not happen. */

    font_cache_elem_array_sizes(pdev, font, &num_widths, &num_chars);

    len = (num_chars + 7) / 8;

    if (pe != NULL) {

        e = *pe;

        if (e->pdfont == pdfont)

            return 0;

        e->pdfont = pdfont;

        /* Reset glyph cache because e->pdfont had changed. */