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

Source (jump to first uncovered line)
/* 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-06-24 07:01

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