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

Source
/* Copyright (C) 2001-2023 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.
*/


/* 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: 2025-11-16 07:40

Line	Count	Source
1		/* Copyright (C) 2001-2023 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., 39 Mesa Street, Suite 108A, San Francisco,
13		CA 94129, USA, 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	296	{
48	296	stream_puts(s, prefix);
49	296	stream_write(s, pstr->data, pstr->size);
50	296	}
51
52		/* Write a hex string. */
53		static void
54		pput_hex(stream s, const byte pcid, int size)
55	325k	{
56	325k	int i;
57	325k	static const char *const hex_digits = "0123456789abcdef";
58
59	805k	for (i = 0; i < size; ++i) {
60	480k	stream_putc(s, hex_digits[pcid[i] >> 4]);
61	480k	stream_putc(s, hex_digits[pcid[i] & 0xf]);
62	480k	}
63	325k	}
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	5.30k	{
69	5.30k	int i;
70
71	5.30k	pprintd1(s, "%d begincodespacerange\n", count);
72	10.6k	for (i = 0; i < count; ++i, ++pcsr) {
73	5.31k	stream_puts(s, "<");
74	5.31k	pput_hex(s, pcsr->first, pcsr->size);
75	5.31k	stream_puts(s, "><");
76	5.31k	pput_hex(s, pcsr->last, pcsr->size);
77	5.31k	stream_puts(s, ">\n");
78	5.31k	}
79	5.30k	stream_puts(s, "endcodespacerange\n");
80	5.30k	}
81
82		/* Write one CIDSystemInfo dictionary. */
83		static void
84		cmap_put_system_info(stream s, const gs_cid_system_info_t pcidsi)
85	74	{
86	74	if (cid_system_info_is_null(pcidsi)) {
87	3	stream_puts(s, " null ");
88	71	} else {
89	71	stream_puts(s, " 3 dict dup begin\n");
90	71	stream_puts(s, "/Registry ");
91	71	s_write_ps_string(s, pcidsi->Registry.data, pcidsi->Registry.size, 0);
92	71	stream_puts(s, " def\n/Ordering ");
93	71	s_write_ps_string(s, pcidsi->Ordering.data, pcidsi->Ordering.size, 0);
94	71	pprintd1(s, " def\n/Supplement %d def\nend ", pcidsi->Supplement);
95	71	}
96	74	}
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	10.6k	{
106		/* For simplicity, produce one entry for each lookup range. */
107	10.6k	gs_cmap_lookups_enum_t lenum;
108	10.6k	int font_index = (pcmap->num_fonts <= 1 ? 0 : -1);
109	10.6k	int code;
110
111	10.6k	for (gs_cmap_lookups_enum_init(pcmap, which, &lenum);
112	20.0k	(code = gs_cmap_enum_next_lookup(mem, &lenum)) == 0; ) {
113	9.44k	gs_cmap_lookups_enum_t counter;
114	9.44k	int num_entries = 0;
115	9.44k	int gi;
116
117	9.44k	if (font_index_only >= 0 && lenum.entry.font_index != font_index_only)
118	0	continue;
119	9.44k	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	9.44k	counter = lenum;
125	116k	while (gs_cmap_enum_next_entry(&counter) == 0)
126	107k	++num_entries;
127	18.9k	for (gi = 0; gi < num_entries; gi += 100) {
128	9.47k	int i = gi, ni = min(i + 100, num_entries);
129	9.47k	const char *end;
130
131	9.47k	pprintd1(s, "%d ", ni - i);
132	9.47k	if (lenum.entry.key_is_range) {
133	6.25k	if (lenum.entry.value_type == CODE_VALUE_CID \|\| lenum.entry.value_type == CODE_VALUE_NOTDEF) {
134	992	stream_puts(s, pcmo->beginrange);
135	992	end = pcmo->endrange;
136	5.26k	} else { /* must be def, not notdef */
137	5.26k	stream_puts(s, "beginbfrange\n");
138	5.26k	end = "endbfrange\n";
139	5.26k	}
140	6.25k	} else {
141	3.21k	if (lenum.entry.value_type == CODE_VALUE_CID \|\| lenum.entry.value_type == CODE_VALUE_NOTDEF) {
142	3.21k	stream_puts(s, pcmo->beginchar);
143	3.21k	end = pcmo->endchar;
144	3.21k	} else { /* must be def, not notdef */
145	0	stream_puts(s, "beginbfchar\n");
146	0	end = "endbfchar\n";
147	0	}
148	3.21k	}
149	116k	for (; i < ni; ++i) {
150	107k	int j;
151	107k	long value;
152	107k	int value_size;
153
154	107k	DISCARD(gs_cmap_enum_next_entry(&lenum)); /* can't fail */
155	107k	value_size = lenum.entry.value.size;
156	318k	for (j = 0; j <= lenum.entry.key_is_range; ++j) {
157	211k	stream_putc(s, '<');
158	211k	pput_hex(s, lenum.entry.key[j], lenum.entry.key_size);
159	211k	stream_putc(s, '>');
160	211k	}
161	321k	for (j = 0, value = 0; j < value_size; ++j)
162	214k	value = (value << 8) + lenum.entry.value.data[j];
163	107k	switch (lenum.entry.value_type) {
164	4.21k	case CODE_VALUE_CID:
165	4.21k	case CODE_VALUE_NOTDEF:
166	4.21k	pprintld1(s, "%ld", value);
167	4.21k	break;
168	103k	case CODE_VALUE_CHARS:
169	103k	stream_putc(s, '<');
170	103k	pput_hex(s, lenum.entry.value.data, value_size);
171	103k	stream_putc(s, '>');
172	103k	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	107k	}
200	107k	stream_putc(s, '\n');
201	107k	}
202	9.47k	stream_puts(s, end);
203	9.47k	}
204	9.44k	}
205	10.6k	if (lenum.entry.value.data && lenum.entry.value.data != lenum.temp_value) {
206	5.23k	gs_free_object(mem, (void *)lenum.entry.value.data, "working ToUnicode buffer");
207	5.23k	}
208	10.6k	return code;
209	10.6k	}
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	5.30k	{
220	5.30k	const gs_const_string *const cmap_name =
221	5.30k	(alt_cmap_name ? alt_cmap_name : &pcmap->CMapName);
222	5.30k	const gs_cid_system_info_t *const pcidsi = pcmap->CIDSystemInfo;
223
224	5.30k	switch (pcmap->CMapType) {
225	5.30k	case 0: case 1: case 2:
226	5.30k	break;
227	0	default:
228	0	return_error(gs_error_rangecheck);
229	5.30k	}
230
231		/* Write the header. */
232
233	5.30k	if (!pcmap->ToUnicode) {
234	74	stream_puts(s, "%!PS-Adobe-3.0 Resource-CMap\n");
235	74	stream_puts(s, "%%DocumentNeededResources: ProcSet (CIDInit)\n");
236	74	stream_puts(s, "%%IncludeResource: ProcSet (CIDInit)\n");
237	74	pput_string_entry(s, "%%BeginResource: CMap (", cmap_name);
238	74	pput_string_entry(s, ")\n%%Title: (", cmap_name);
239	74	pput_string_entry(s, " ", &pcidsi->Registry);
240	74	pput_string_entry(s, " ", &pcidsi->Ordering);
241	74	pprintd1(s, " %d)\n", pcidsi->Supplement);
242	74	pprintg1(s, "%%%%Version: %g\n", pcmap->CMapVersion);
243	74	}
244	5.30k	stream_puts(s, "/CIDInit /ProcSet findresource begin\n");
245	5.30k	stream_puts(s, "12 dict begin\nbegincmap\n");
246
247		/* Write the fixed entries. */
248
249	5.30k	pprintd1(s, "/CMapType %d def\n", pcmap->CMapType);
250	5.30k	stream_puts(s, "/CMapName/");
251	5.30k	put_name_chars(s, cmap_name->data, cmap_name->size);
252	5.30k	stream_puts(s, " def\n");
253	5.30k	if (!pcmap->ToUnicode) {
254	74	pprintg1(s, "/CMapVersion %g def\n", pcmap->CMapVersion);
255	74	stream_puts(s, "/CIDSystemInfo");
256	74	if (font_index_only >= 0 && font_index_only < pcmap->num_fonts) {
257	74	cmap_put_system_info(s, pcidsi + font_index_only);
258	74	} 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	74	stream_puts(s, " def\n");
271	74	if (uid_is_XUID(&pcmap->uid)) {
272	27	uint i, n = uid_XUID_size(&pcmap->uid);
273	27	const long *values = uid_XUID_values(&pcmap->uid);
274
275	27	stream_puts(s, "/XUID [");
276	128	for (i = 0; i < n; ++i)
277	101	pprintld1(s, " %ld", values[i]);
278	27	stream_puts(s, "] def\n");
279	27	}
280	74	pprintld1(s, "/UIDOffset %ld def\n", pcmap->UIDOffset);
281	74	pprintd1(s, "/WMode %d def\n", pcmap->WMode);
282	74	}
283
284		/* Write the code space ranges. */
285
286	5.30k	{
287	5.30k	gs_cmap_ranges_enum_t renum;
288	5.31k	#define MAX_RANGES 100
289	5.30k	gx_code_space_range_t ranges[MAX_RANGES];
290	5.30k	int code, count = 0;
291
292	5.30k	for (gs_cmap_ranges_enum_init(pcmap, &renum);
293	10.6k	(code = gs_cmap_enum_next_range(&renum)) == 0; ) {
294	5.31k	if (count == MAX_RANGES) {
295	0	cmap_put_ranges(s, ranges, count);
296	0	count = 0;
297	0	}
298	5.31k	ranges[count++] = renum.range;
299	5.31k	}
300	5.30k	if (code < 0)
301	0	return code;
302	5.30k	if (count)
303	5.30k	cmap_put_ranges(s, ranges, count);
304	5.30k	#undef MAX_RANGES
305	5.30k	}
306
307		/* Write the code and notdef data. */
308
309	0	{
310	5.30k	int code;
311
312	5.30k	code = cmap_put_code_map(mem, s, 1, pcmap, &cmap_notdef_operators,
313	5.30k	put_name_chars, font_index_only);
314	5.30k	if (code < 0)
315	0	return code;
316	5.30k	code = cmap_put_code_map(mem, s, 0, pcmap, &cmap_cid_operators,
317	5.30k	put_name_chars, font_index_only);
318	5.30k	if (code < 0)
319	0	return code;
320	5.30k	}
321
322		/* Write the trailer. */
323
324	5.30k	stream_puts(s, "endcmap\n");
325	5.30k	stream_puts(s, "CMapName currentdict /CMap defineresource pop\nend end\n");
326	5.30k	if (!pcmap->ToUnicode) {
327	74	stream_puts(s, "%%EndResource\n");
328	74	stream_puts(s, "%%EOF\n");
329	74	}
330
331	5.30k	return 0;
332	5.30k	}