/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-10 07:27

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