/src/ghostpdl/devices/vector/gdevpsfm.c

Source (jump to first uncovered line)
/* Copyright (C) 2001-2021 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.
*/


/* Write a CMap */
#include "gx.h"
#include "gserrors.h"
#include "gxfcmap.h"
#include "stream.h"
#include "spprint.h"
#include "spsdf.h"
#include "gdevpsf.h"

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

typedef struct cmap_operators_s {
    const char *beginchar;
    const char *endchar;
    const char *beginrange;
    const char *endrange;
} cmap_operators_t;
static const cmap_operators_t
  cmap_cid_operators = {
    "begincidchar\n", "endcidchar\n",
    "begincidrange\n", "endcidrange\n"
  },
  cmap_notdef_operators = {
    "beginnotdefchar\n", "endnotdefchar\n",
    "beginnotdefrange\n", "endnotdefrange\n"
  };

/* Write a gs_string with a prefix. */
static void
pput_string_entry(stream *s, const char *prefix, const gs_const_string *pstr)
{
    stream_puts(s, prefix);
    stream_write(s, pstr->data, pstr->size);
}

/* Write a hex string. */
static void
pput_hex(stream *s, const byte *pcid, int size)
{
    int i;
    static const char *const hex_digits = "0123456789abcdef";

    for (i = 0; i < size; ++i) {
        stream_putc(s, hex_digits[pcid[i] >> 4]);
        stream_putc(s, hex_digits[pcid[i] & 0xf]);
    }
}

/* Write a list of code space ranges. */
static void
cmap_put_ranges(stream *s, const gx_code_space_range_t *pcsr, int count)
{
    int i;

    pprintd1(s, "%d begincodespacerange\n", count);
    for (i = 0; i < count; ++i, ++pcsr) {
        stream_puts(s, "<");
        pput_hex(s, pcsr->first, pcsr->size);
        stream_puts(s, "><");
        pput_hex(s, pcsr->last, pcsr->size);
        stream_puts(s, ">\n");
    }
    stream_puts(s, "endcodespacerange\n");
}

/* Write one CIDSystemInfo dictionary. */
static void
cmap_put_system_info(stream *s, const gs_cid_system_info_t *pcidsi)
{
    if (cid_system_info_is_null(pcidsi)) {
        stream_puts(s, " null ");
    } else {
        stream_puts(s, " 3 dict dup begin\n");
        stream_puts(s, "/Registry ");
        s_write_ps_string(s, pcidsi->Registry.data, pcidsi->Registry.size, 0);
        stream_puts(s, " def\n/Ordering ");
        s_write_ps_string(s, pcidsi->Ordering.data, pcidsi->Ordering.size, 0);
        pprintd1(s, " def\n/Supplement %d def\nend ", pcidsi->Supplement);
    }
}

/* Write one code map. */
static int
cmap_put_code_map(gs_memory_t *mem,
                  stream *s, int which, const gs_cmap_t *pcmap,
                  const cmap_operators_t *pcmo,
                  psf_put_name_chars_proc_t put_name_chars,
                  int font_index_only)
{
    /* For simplicity, produce one entry for each lookup range. */
    gs_cmap_lookups_enum_t lenum;
    int font_index = (pcmap->num_fonts <= 1 ? 0 : -1);
    int code;

    for (gs_cmap_lookups_enum_init(pcmap, which, &lenum);
         (code = gs_cmap_enum_next_lookup(mem, &lenum)) == 0; ) {
        gs_cmap_lookups_enum_t counter;
        int num_entries = 0;
        int gi;

        if (font_index_only >= 0 && lenum.entry.font_index != font_index_only)
            continue;
        if (font_index_only < 0 && lenum.entry.font_index != font_index) {
            pprintd1(s, "%d usefont\n", lenum.entry.font_index);
            font_index = lenum.entry.font_index;
        }
        /* Count the number of entries in this lookup range. */
        counter = lenum;
        while (gs_cmap_enum_next_entry(&counter) == 0)
            ++num_entries;
        for (gi = 0; gi < num_entries; gi += 100) {
            int i = gi, ni = min(i + 100, num_entries);
            const char *end;

            pprintd1(s, "%d ", ni - i);
            if (lenum.entry.key_is_range) {
                if (lenum.entry.value_type == CODE_VALUE_CID || lenum.entry.value_type == CODE_VALUE_NOTDEF) {
                    stream_puts(s, pcmo->beginrange);
                    end = pcmo->endrange;
                } else { /* must be def, not notdef */
                    stream_puts(s, "beginbfrange\n");
                    end = "endbfrange\n";
                }
            } else {
                if (lenum.entry.value_type == CODE_VALUE_CID || lenum.entry.value_type == CODE_VALUE_NOTDEF) {
                    stream_puts(s, pcmo->beginchar);
                    end = pcmo->endchar;
                } else { /* must be def, not notdef */
                    stream_puts(s, "beginbfchar\n");
                    end = "endbfchar\n";
                }
            }
            for (; i < ni; ++i) {
                int j;
                long value;
                int value_size;

                DISCARD(gs_cmap_enum_next_entry(&lenum)); /* can't fail */
                value_size = lenum.entry.value.size;
                for (j = 0; j <= lenum.entry.key_is_range; ++j) {
                    stream_putc(s, '<');
                    pput_hex(s, lenum.entry.key[j], lenum.entry.key_size);
                    stream_putc(s, '>');
                }
                for (j = 0, value = 0; j < value_size; ++j)
                    value = (value << 8) + lenum.entry.value.data[j];
                switch (lenum.entry.value_type) {
                case CODE_VALUE_CID:
                case CODE_VALUE_NOTDEF:
                    pprintld1(s, "%ld", value);
                    break;
                case CODE_VALUE_CHARS:
                    stream_putc(s, '<');
                    pput_hex(s, lenum.entry.value.data, value_size);
                    stream_putc(s, '>');
                    break;
                case CODE_VALUE_GLYPH: {
                    gs_const_string str;
                    int code = pcmap->glyph_name(mem, (gs_glyph)value, &str,
                                                 pcmap->glyph_name_data);

                    if (code < 0) {
                        if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
                            gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
                        }
                        return code;
                    }
                    stream_putc(s, '/');
                    code = put_name_chars(s, str.data, str.size);
                    if (code < 0) {
                        if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
                            gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
                        }
                        return code;
                    }
                }
                    break;
                default:  /* not possible */
                    if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
                        gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
                    }
                    return_error(gs_error_unregistered);
                }
                stream_putc(s, '\n');
            }
            stream_puts(s, end);
        }
    }
    if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
        gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
    }
    return code;
}

/* ---------------- Main program ---------------- */

/* Write a CMap in its standard (source) format. */
int
psf_write_cmap(gs_memory_t *mem,
               stream *s, const gs_cmap_t *pcmap,
               psf_put_name_chars_proc_t put_name_chars,
               const gs_const_string *alt_cmap_name, int font_index_only)
{
    const gs_const_string *const cmap_name =
        (alt_cmap_name ? alt_cmap_name : &pcmap->CMapName);
    const gs_cid_system_info_t *const pcidsi = pcmap->CIDSystemInfo;

    switch (pcmap->CMapType) {
    case 0: case 1: case 2:
        break;
    default:
        return_error(gs_error_rangecheck);
    }

    /* Write the header. */

    if (!pcmap->ToUnicode) {
        stream_puts(s, "%!PS-Adobe-3.0 Resource-CMap\n");
        stream_puts(s, "%%DocumentNeededResources: ProcSet (CIDInit)\n");
        stream_puts(s, "%%IncludeResource: ProcSet (CIDInit)\n");
        pput_string_entry(s, "%%BeginResource: CMap (", cmap_name);
        pput_string_entry(s, ")\n%%Title: (", cmap_name);
        pput_string_entry(s, " ", &pcidsi->Registry);
        pput_string_entry(s, " ", &pcidsi->Ordering);
        pprintd1(s, " %d)\n", pcidsi->Supplement);
        pprintg1(s, "%%%%Version: %g\n", pcmap->CMapVersion);
    }
    stream_puts(s, "/CIDInit /ProcSet findresource begin\n");
    stream_puts(s, "12 dict begin\nbegincmap\n");

    /* Write the fixed entries. */

    pprintd1(s, "/CMapType %d def\n", pcmap->CMapType);
    stream_puts(s, "/CMapName/");
    put_name_chars(s, cmap_name->data, cmap_name->size);
    stream_puts(s, " def\n");
    if (!pcmap->ToUnicode) {
        pprintg1(s, "/CMapVersion %g def\n", pcmap->CMapVersion);
        stream_puts(s, "/CIDSystemInfo");
        if (font_index_only >= 0 && font_index_only < pcmap->num_fonts) {
            cmap_put_system_info(s, pcidsi + font_index_only);
        } else if (pcmap->num_fonts == 1) {
            cmap_put_system_info(s, pcidsi);
        } else {
            int i;

            pprintd1(s, " %d array\n", pcmap->num_fonts);
            for (i = 0; i < pcmap->num_fonts; ++i) {
                pprintd1(s, "dup %d", i);
                cmap_put_system_info(s, pcidsi + i);
                stream_puts(s, "put\n");
            }
        }
        stream_puts(s, " def\n");
        if (uid_is_XUID(&pcmap->uid)) {
            uint i, n = uid_XUID_size(&pcmap->uid);
            const long *values = uid_XUID_values(&pcmap->uid);

            stream_puts(s, "/XUID [");
            for (i = 0; i < n; ++i)
                pprintld1(s, " %ld", values[i]);
            stream_puts(s, "] def\n");
        }
        pprintld1(s, "/UIDOffset %ld def\n", pcmap->UIDOffset);
        pprintd1(s, "/WMode %d def\n", pcmap->WMode);
    }

    /* Write the code space ranges. */

    {
        gs_cmap_ranges_enum_t renum;
#define MAX_RANGES 100
        gx_code_space_range_t ranges[MAX_RANGES];
        int code, count = 0;

        for (gs_cmap_ranges_enum_init(pcmap, &renum);
             (code = gs_cmap_enum_next_range(&renum)) == 0; ) {
            if (count == MAX_RANGES) {
                cmap_put_ranges(s, ranges, count);
                count = 0;
            }
            ranges[count++] = renum.range;
        }
        if (code < 0)
            return code;
        if (count)
            cmap_put_ranges(s, ranges, count);
#undef MAX_RANGES
    }

    /* Write the code and notdef data. */

    {
        int code;

        code = cmap_put_code_map(mem, s, 1, pcmap, &cmap_notdef_operators,
                                 put_name_chars, font_index_only);
        if (code < 0)
            return code;
        code = cmap_put_code_map(mem, s, 0, pcmap, &cmap_cid_operators,
                                 put_name_chars, font_index_only);
        if (code < 0)
            return code;
    }

    /* Write the trailer. */

    stream_puts(s, "endcmap\n");
    stream_puts(s, "CMapName currentdict /CMap defineresource pop\nend end\n");
    if (!pcmap->ToUnicode) {
        stream_puts(s, "%%EndResource\n");
        stream_puts(s, "%%EOF\n");
    }

    return 0;
}

Coverage Report

Created: 2022-10-31 07:00

Line	Count	Source (jump to first uncovered line)
1		/* Copyright (C) 2001-2021 Artifex Software, Inc.
2		All Rights Reserved.
3
4		This software is provided AS-IS with no warranty, either express or
5		implied.
6
7		This software is distributed under license and may not be copied,
8		modified or distributed except as expressly authorized under the terms
9		of the license contained in the file LICENSE in this distribution.
10
11		Refer to licensing information at http://www.artifex.com or contact
12		Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato,
13		CA 94945, U.S.A., +1(415)492-9861, for further information.
14		*/
15
16
17		/* Write a CMap */
18		#include "gx.h"
19		#include "gserrors.h"
20		#include "gxfcmap.h"
21		#include "stream.h"
22		#include "spprint.h"
23		#include "spsdf.h"
24		#include "gdevpsf.h"
25
26		/* ---------------- Utilities ---------------- */
27
28		typedef struct cmap_operators_s {
29		const char *beginchar;
30		const char *endchar;
31		const char *beginrange;
32		const char *endrange;
33		} cmap_operators_t;
34		static const cmap_operators_t
35		cmap_cid_operators = {
36		"begincidchar\n", "endcidchar\n",
37		"begincidrange\n", "endcidrange\n"
38		},
39		cmap_notdef_operators = {
40		"beginnotdefchar\n", "endnotdefchar\n",
41		"beginnotdefrange\n", "endnotdefrange\n"
42		};
43
44		/* Write a gs_string with a prefix. */
45		static void
46		pput_string_entry(stream s, const char prefix, const gs_const_string *pstr)
47	28	{
48	28	stream_puts(s, prefix);
49	28	stream_write(s, pstr->data, pstr->size);
50	28	}
51
52		/* Write a hex string. */
53		static void
54		pput_hex(stream s, const byte pcid, int size)
55	25.0k	{
56	25.0k	int i;
57	25.0k	static const char *const hex_digits = "0123456789abcdef";
58
59	62.1k	for (i = 0; i < size; ++i) {
60	37.1k	stream_putc(s, hex_digits[pcid[i] >> 4]);
61	37.1k	stream_putc(s, hex_digits[pcid[i] & 0xf]);
62	37.1k	}
63	25.0k	}
64
65		/* Write a list of code space ranges. */
66		static void
67		cmap_put_ranges(stream s, const gx_code_space_range_t pcsr, int count)
68	451	{
69	451	int i;
70
71	451	pprintd1(s, "%d begincodespacerange\n", count);
72	906	for (i = 0; i < count; ++i, ++pcsr) {
73	455	stream_puts(s, "<");
74	455	pput_hex(s, pcsr->first, pcsr->size);
75	455	stream_puts(s, "><");
76	455	pput_hex(s, pcsr->last, pcsr->size);
77	455	stream_puts(s, ">\n");
78	455	}
79	451	stream_puts(s, "endcodespacerange\n");
80	451	}
81
82		/* Write one CIDSystemInfo dictionary. */
83		static void
84		cmap_put_system_info(stream s, const gs_cid_system_info_t pcidsi)
85	7	{
86	7	if (cid_system_info_is_null(pcidsi)) {
87	2	stream_puts(s, " null ");
88	5	} else {
89	5	stream_puts(s, " 3 dict dup begin\n");
90	5	stream_puts(s, "/Registry ");
91	5	s_write_ps_string(s, pcidsi->Registry.data, pcidsi->Registry.size, 0);
92	5	stream_puts(s, " def\n/Ordering ");
93	5	s_write_ps_string(s, pcidsi->Ordering.data, pcidsi->Ordering.size, 0);
94	5	pprintd1(s, " def\n/Supplement %d def\nend ", pcidsi->Supplement);
95	5	}
96	7	}
97
98		/* Write one code map. */
99		static int
100		cmap_put_code_map(gs_memory_t *mem,
101		stream s, int which, const gs_cmap_t pcmap,
102		const cmap_operators_t *pcmo,
103		psf_put_name_chars_proc_t put_name_chars,
104		int font_index_only)
105	902	{
106		/* For simplicity, produce one entry for each lookup range. */
107	902	gs_cmap_lookups_enum_t lenum;
108	902	int font_index = (pcmap->num_fonts <= 1 ? 0 : -1);
109	902	int code;
110
111	902	for (gs_cmap_lookups_enum_init(pcmap, which, &lenum);
112	1.44k	(code = gs_cmap_enum_next_lookup(mem, &lenum)) == 0; ) {
113	538	gs_cmap_lookups_enum_t counter;
114	538	int num_entries = 0;
115	538	int gi;
116
117	538	if (font_index_only >= 0 && lenum.entry.font_index != font_index_only)
118	0	continue;
119	538	if (font_index_only < 0 && lenum.entry.font_index != font_index) {
120	0	pprintd1(s, "%d usefont\n", lenum.entry.font_index);
121	0	font_index = lenum.entry.font_index;
122	0	}
123		/* Count the number of entries in this lookup range. */
124	538	counter = lenum;
125	8.62k	while (gs_cmap_enum_next_entry(&counter) == 0)
126	8.08k	++num_entries;
127	1.07k	for (gi = 0; gi < num_entries; gi += 100) {
128	538	int i = gi, ni = min(i + 100, num_entries);
129	538	const char *end;
130
131	538	pprintd1(s, "%d ", ni - i);
132	538	if (lenum.entry.key_is_range) {
133	482	if (lenum.entry.value_type == CODE_VALUE_CID \|\| lenum.entry.value_type == CODE_VALUE_NOTDEF) {
134	38	stream_puts(s, pcmo->beginrange);
135	38	end = pcmo->endrange;
136	444	} else { /* must be def, not notdef */
137	444	stream_puts(s, "beginbfrange\n");
138	444	end = "endbfrange\n";
139	444	}
140	482	} else {
141	56	if (lenum.entry.value_type == CODE_VALUE_CID \|\| lenum.entry.value_type == CODE_VALUE_NOTDEF) {
142	56	stream_puts(s, pcmo->beginchar);
143	56	end = pcmo->endchar;
144	56	} else { /* must be def, not notdef */
145	0	stream_puts(s, "beginbfchar\n");
146	0	end = "endbfchar\n";
147	0	}
148	56	}
149	8.62k	for (; i < ni; ++i) {
150	8.08k	int j;
151	8.08k	long value;
152	8.08k	int value_size;
153
154	8.08k	DISCARD(gs_cmap_enum_next_entry(&lenum)); /* can't fail */
155	8.08k	value_size = lenum.entry.value.size;
156	24.2k	for (j = 0; j <= lenum.entry.key_is_range; ++j) {
157	16.1k	stream_putc(s, '<');
158	16.1k	pput_hex(s, lenum.entry.key[j], lenum.entry.key_size);
159	16.1k	stream_putc(s, '>');
160	16.1k	}
161	24.3k	for (j = 0, value = 0; j < value_size; ++j)
162	16.2k	value = (value << 8) + lenum.entry.value.data[j];
163	8.08k	switch (lenum.entry.value_type) {
164	94	case CODE_VALUE_CID:
165	94	case CODE_VALUE_NOTDEF:
166	94	pprintld1(s, "%ld", value);
167	94	break;
168	7.99k	case CODE_VALUE_CHARS:
169	7.99k	stream_putc(s, '<');
170	7.99k	pput_hex(s, lenum.entry.value.data, value_size);
171	7.99k	stream_putc(s, '>');
172	7.99k	break;
173	0	case CODE_VALUE_GLYPH: {
174	0	gs_const_string str;
175	0	int code = pcmap->glyph_name(mem, (gs_glyph)value, &str,
176	0	pcmap->glyph_name_data);
177
178	0	if (code < 0) {
179	0	if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
180	0	gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
181	0	}
182	0	return code;
183	0	}
184	0	stream_putc(s, '/');
185	0	code = put_name_chars(s, str.data, str.size);
186	0	if (code < 0) {
187	0	if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
188	0	gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
189	0	}
190	0	return code;
191	0	}
192	0	}
193	0	break;
194	0	default: /* not possible */
195	0	if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
196	0	gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
197	0	}
198	0	return_error(gs_error_unregistered);
199	8.08k	}
200	8.08k	stream_putc(s, '\n');
201	8.08k	}
202	538	stream_puts(s, end);
203	538	}
204	538	}
205	902	if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
206	444	gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
207	444	}
208	902	return code;
209	902	}
210
211		/* ---------------- Main program ---------------- */
212
213		/* Write a CMap in its standard (source) format. */
214		int
215		psf_write_cmap(gs_memory_t *mem,
216		stream s, const gs_cmap_t pcmap,
217		psf_put_name_chars_proc_t put_name_chars,
218		const gs_const_string *alt_cmap_name, int font_index_only)
219	451	{
220	451	const gs_const_string *const cmap_name =
221	451	(alt_cmap_name ? alt_cmap_name : &pcmap->CMapName);
222	451	const gs_cid_system_info_t *const pcidsi = pcmap->CIDSystemInfo;
223
224	451	switch (pcmap->CMapType) {
225	451	case 0: case 1: case 2:
226	451	break;
227	0	default:
228	0	return_error(gs_error_rangecheck);
229	451	}
230
231		/* Write the header. */
232
233	451	if (!pcmap->ToUnicode) {
234	7	stream_puts(s, "%!PS-Adobe-3.0 Resource-CMap\n");
235	7	stream_puts(s, "%%DocumentNeededResources: ProcSet (CIDInit)\n");
236	7	stream_puts(s, "%%IncludeResource: ProcSet (CIDInit)\n");
237	7	pput_string_entry(s, "%%BeginResource: CMap (", cmap_name);
238	7	pput_string_entry(s, ")\n%%Title: (", cmap_name);
239	7	pput_string_entry(s, " ", &pcidsi->Registry);
240	7	pput_string_entry(s, " ", &pcidsi->Ordering);
241	7	pprintd1(s, " %d)\n", pcidsi->Supplement);
242	7	pprintg1(s, "%%%%Version: %g\n", pcmap->CMapVersion);
243	7	}
244	451	stream_puts(s, "/CIDInit /ProcSet findresource begin\n");
245	451	stream_puts(s, "12 dict begin\nbegincmap\n");
246
247		/* Write the fixed entries. */
248
249	451	pprintd1(s, "/CMapType %d def\n", pcmap->CMapType);
250	451	stream_puts(s, "/CMapName/");
251	451	put_name_chars(s, cmap_name->data, cmap_name->size);
252	451	stream_puts(s, " def\n");
253	451	if (!pcmap->ToUnicode) {
254	7	pprintg1(s, "/CMapVersion %g def\n", pcmap->CMapVersion);
255	7	stream_puts(s, "/CIDSystemInfo");
256	7	if (font_index_only >= 0 && font_index_only < pcmap->num_fonts) {
257	7	cmap_put_system_info(s, pcidsi + font_index_only);
258	7	} else if (pcmap->num_fonts == 1) {
259	0	cmap_put_system_info(s, pcidsi);
260	0	} else {
261	0	int i;
262
263	0	pprintd1(s, " %d array\n", pcmap->num_fonts);
264	0	for (i = 0; i < pcmap->num_fonts; ++i) {
265	0	pprintd1(s, "dup %d", i);
266	0	cmap_put_system_info(s, pcidsi + i);
267	0	stream_puts(s, "put\n");
268	0	}
269	0	}
270	7	stream_puts(s, " def\n");
271	7	if (uid_is_XUID(&pcmap->uid)) {
272	4	uint i, n = uid_XUID_size(&pcmap->uid);
273	4	const long *values = uid_XUID_values(&pcmap->uid);
274
275	4	stream_puts(s, "/XUID [");
276	18	for (i = 0; i < n; ++i)
277	14	pprintld1(s, " %ld", values[i]);
278	4	stream_puts(s, "] def\n");
279	4	}
280	7	pprintld1(s, "/UIDOffset %ld def\n", pcmap->UIDOffset);
281	7	pprintd1(s, "/WMode %d def\n", pcmap->WMode);
282	7	}
283
284		/* Write the code space ranges. */
285
286	451	{
287	451	gs_cmap_ranges_enum_t renum;
288	455	#define MAX_RANGES 100
289	451	gx_code_space_range_t ranges[MAX_RANGES];
290	451	int code, count = 0;
291
292	451	for (gs_cmap_ranges_enum_init(pcmap, &renum);
293	906	(code = gs_cmap_enum_next_range(&renum)) == 0; ) {
294	455	if (count == MAX_RANGES) {
295	0	cmap_put_ranges(s, ranges, count);
296	0	count = 0;
297	0	}
298	455	ranges[count++] = renum.range;
299	455	}
300	451	if (code < 0)
301	0	return code;
302	451	if (count)
303	451	cmap_put_ranges(s, ranges, count);
304	451	#undef MAX_RANGES
305	451	}
306
307		/* Write the code and notdef data. */
308
309	0	{
310	451	int code;
311
312	451	code = cmap_put_code_map(mem, s, 1, pcmap, &cmap_notdef_operators,
313	451	put_name_chars, font_index_only);
314	451	if (code < 0)
315	0	return code;
316	451	code = cmap_put_code_map(mem, s, 0, pcmap, &cmap_cid_operators,
317	451	put_name_chars, font_index_only);
318	451	if (code < 0)
319	0	return code;
320	451	}
321
322		/* Write the trailer. */
323
324	451	stream_puts(s, "endcmap\n");
325	451	stream_puts(s, "CMapName currentdict /CMap defineresource pop\nend end\n");
326	451	if (!pcmap->ToUnicode) {
327	7	stream_puts(s, "%%EndResource\n");
328	7	stream_puts(s, "%%EOF\n");
329	7	}
330
331	451	return 0;
332	451	}