/*
* Write the Encoding array. This is a separate procedure only for
* readability.
*/
static int
write_Encoding(stream *s, gs_font_type1 *pfont, int options,
gs_glyph *subset_glyphs, uint subset_size, gs_glyph notdef)
{
stream_puts(s, "/Encoding ");
switch (pfont->encoding_index) {
case ENCODING_INDEX_STANDARD:
stream_puts(s, "StandardEncoding");
break;
case ENCODING_INDEX_ISOLATIN1:
/* ATM only recognizes StandardEncoding. */
if (options & WRITE_TYPE1_POSTSCRIPT) {
stream_puts(s, "ISOLatin1Encoding");
break;
}
default:{
gs_char i;
stream_puts(s, "256 array\n");
stream_puts(s, "0 1 255 {1 index exch /.notdef put} for\n");
for (i = 0; i < 256; ++i) {
gs_glyph glyph =
(*pfont->procs.encode_char)
((gs_font *)pfont, (gs_char)i, GLYPH_SPACE_NAME);
gs_const_string namestr;
if (subset_glyphs && subset_size) {
/*
* Only write Encoding entries for glyphs in the
* subset. Use binary search to check each glyph,
* since subset_glyphs are sorted.
*/
if (!psf_sorted_glyphs_include(subset_glyphs,
subset_size, glyph))
continue;
}
if (glyph != gs_no_glyph && glyph != notdef &&
pfont->procs.glyph_name((gs_font *)pfont, glyph,
&namestr) >= 0
) {
pprintd1(s, "dup %d /", (int)i);
stream_write(s, namestr.data, namestr.size);
stream_puts(s, " put\n");
}
}
stream_puts(s, "readonly");
}
}
stream_puts(s, " def\n");
return 0;
}
/* 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 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 code map. */
static int
cmap_put_code_map(const 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(&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)
return code;
stream_putc(s, '/');
code = put_name_chars(s, str.data, str.size);
if (code < 0)
return code;
}
break;
default: /* not possible */
return_error(gs_error_unregistered);
}
stream_putc(s, '\n');
}
stream_puts(s, end);
}
}
return code;
}
/* Write a CMap in its standard (source) format. */
int
psf_write_cmap(const 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;
}
static int
param_print_typed(gs_param_list * plist, gs_param_name pkey,
gs_param_typed_value * pvalue)
{
printer_param_list_t *const prlist = (printer_param_list_t *)plist;
stream *s = prlist->strm;
if (!prlist->any) {
if (prlist->params.prefix)
stream_puts(s, prlist->params.prefix);
prlist->any = true;
}
if (prlist->params.item_prefix)
stream_puts(s, prlist->params.item_prefix);
pprints1(s, "/%s", pkey);
switch (pvalue->type) {
case gs_param_type_null:
stream_puts(s, " null");
break;
case gs_param_type_bool:
stream_puts(s, (pvalue->value.b ? " true" : " false"));
break;
case gs_param_type_int:
pprintd1(s, " %d", pvalue->value.i);
break;
case gs_param_type_long:
pprintld1(s, " %l", pvalue->value.l);
break;
case gs_param_type_float:
pprintg1(s, " %g", pvalue->value.f);
break;
case gs_param_type_string:
s_write_ps_string(s, pvalue->value.s.data, pvalue->value.s.size,
prlist->params.print_ok);
break;
case gs_param_type_name:
/****** SHOULD USE #-ESCAPES FOR PDF ******/
stream_putc(s, '/');
stream_write(s, pvalue->value.n.data, pvalue->value.n.size);
break;
case gs_param_type_int_array:
{
uint i;
char sepr = (pvalue->value.ia.size <= 10 ? ' ' : '\n');
stream_putc(s, '[');
for (i = 0; i < pvalue->value.ia.size; ++i) {
pprintd1(s, "%d", pvalue->value.ia.data[i]);
stream_putc(s, sepr);
}
stream_putc(s, ']');
}
break;
case gs_param_type_float_array:
{
uint i;
char sepr = (pvalue->value.fa.size <= 10 ? ' ' : '\n');
stream_putc(s, '[');
for (i = 0; i < pvalue->value.fa.size; ++i) {
pprintg1(s, "%g", pvalue->value.fa.data[i]);
stream_putc(s, sepr);
}
stream_putc(s, ']');
}
break;
/*case gs_param_type_string_array: */
/*case gs_param_type_name_array: */
default:
return_error(gs_error_typecheck);
}
if (prlist->params.item_suffix)
stream_puts(s, prlist->params.item_suffix);
return 0;
}
/*
* Write the Private dictionary. This is a separate procedure only for
* readability. write_CharString is a parameter so that we can encrypt
* Subrs and CharStrings when the font's lenIV == -1 but we are writing
* the font with lenIV = 0.
*/
static int
write_Private(stream *s, gs_font_type1 *pfont,
gs_glyph *subset_glyphs, uint subset_size,
gs_glyph notdef, int lenIV,
int (*write_CharString)(stream *, const void *, uint),
const param_printer_params_t *ppp)
{
const gs_type1_data *const pdata = &pfont->data;
printer_param_list_t rlist;
gs_param_list *const plist = (gs_param_list *)&rlist;
int code = s_init_param_printer(&rlist, ppp, s);
if (code < 0)
return 0;
stream_puts(s, "dup /Private 17 dict dup begin\n");
stream_puts(s, "/-|{string currentfile exch readstring pop}executeonly def\n");
stream_puts(s, "/|-{noaccess def}executeonly def\n");
stream_puts(s, "/|{noaccess put}executeonly def\n");
{
static const gs_param_item_t private_items[] = {
{"BlueFuzz", gs_param_type_int,
offset_of(gs_type1_data, BlueFuzz)},
{"BlueScale", gs_param_type_float,
offset_of(gs_type1_data, BlueScale)},
{"BlueShift", gs_param_type_float,
offset_of(gs_type1_data, BlueShift)},
{"ExpansionFactor", gs_param_type_float,
offset_of(gs_type1_data, ExpansionFactor)},
{"ForceBold", gs_param_type_bool,
offset_of(gs_type1_data, ForceBold)},
{"LanguageGroup", gs_param_type_int,
offset_of(gs_type1_data, LanguageGroup)},
{"RndStemUp", gs_param_type_bool,
offset_of(gs_type1_data, RndStemUp)},
gs_param_item_end
};
gs_type1_data defaults;
defaults.BlueFuzz = 1;
defaults.BlueScale = (float)0.039625;
defaults.BlueShift = 7.0;
defaults.ExpansionFactor = (float)0.06;
defaults.ForceBold = false;
defaults.LanguageGroup = 0;
defaults.RndStemUp = true;
code = gs_param_write_items(plist, pdata, &defaults, private_items);
if (code < 0)
return code;
if (lenIV != 4) {
code = param_write_int(plist, "lenIV", &lenIV);
if (code < 0)
return code;
}
write_float_array(plist, "BlueValues", pdata->BlueValues.values,
pdata->BlueValues.count);
write_float_array(plist, "OtherBlues", pdata->OtherBlues.values,
pdata->OtherBlues.count);
write_float_array(plist, "FamilyBlues", pdata->FamilyBlues.values,
pdata->FamilyBlues.count);
write_float_array(plist, "FamilyOtherBlues", pdata->FamilyOtherBlues.values,
pdata->FamilyOtherBlues.count);
write_float_array(plist, "StdHW", pdata->StdHW.values,
pdata->StdHW.count);
write_float_array(plist, "StdVW", pdata->StdVW.values,
pdata->StdVW.count);
write_float_array(plist, "StemSnapH", pdata->StemSnapH.values,
pdata->StemSnapH.count);
write_float_array(plist, "StemSnapV", pdata->StemSnapV.values,
pdata->StemSnapV.count);
}
write_uid(s, &pfont->UID);
stream_puts(s, "/MinFeature{16 16} def\n");
stream_puts(s, "/password 5839 def\n");
/*
* Write the Subrs. We always write them all, even for subsets.
* (We will fix this someday.)
*/
{
int n, i;
gs_glyph_data_t gdata;
int code;
gdata.memory = pfont->memory;
for (n = 0;
(code = pdata->procs.subr_data(pfont, n, false, &gdata)) !=
gs_error_rangecheck;
) {
++n;
if (code >= 0)
gs_glyph_data_free(&gdata, "write_Private(Subrs)");
}
pprintd1(s, "/Subrs %d array\n", n);
for (i = 0; i < n; ++i)
if ((code = pdata->procs.subr_data(pfont, i, false, &gdata)) >= 0) {
char buf[50];
if (gdata.bits.size) {
sprintf(buf, "dup %d %u -| ", i, gdata.bits.size);
stream_puts(s, buf);
write_CharString(s, gdata.bits.data, gdata.bits.size);
stream_puts(s, " |\n");
}
gs_glyph_data_free(&gdata, "write_Private(Subrs)");
}
stream_puts(s, "|-\n");
}
/* We don't write OtherSubrs -- there had better not be any! */
/* Write the CharStrings. */
{
int num_chars = 0;
gs_glyph glyph;
psf_glyph_enum_t genum;
gs_glyph_data_t gdata;
int code;
gdata.memory = pfont->memory;
psf_enumerate_glyphs_begin(&genum, (gs_font *)pfont, subset_glyphs,
(subset_glyphs ? subset_size : 0),
GLYPH_SPACE_NAME);
for (glyph = gs_no_glyph;
(code = psf_enumerate_glyphs_next(&genum, &glyph)) != 1;
)
if (code == 0 &&
(code = pdata->procs.glyph_data(pfont, glyph, &gdata)) >= 0
) {
++num_chars;
gs_glyph_data_free(&gdata, "write_Private(CharStrings)");
}
pprintd1(s, "2 index /CharStrings %d dict dup begin\n", num_chars);
psf_enumerate_glyphs_reset(&genum);
for (glyph = gs_no_glyph;
(code = psf_enumerate_glyphs_next(&genum, &glyph)) != 1;
)
if (code == 0 &&
(code = pdata->procs.glyph_data(pfont, glyph, &gdata)) >= 0
) {
gs_const_string gstr;
int code;
code = pfont->procs.glyph_name((gs_font *)pfont, glyph, &gstr);
if (code < 0)
return code;
stream_puts(s, "/");
stream_write(s, gstr.data, gstr.size);
pprintd1(s, " %d -| ", gdata.bits.size);
write_CharString(s, gdata.bits.data, gdata.bits.size);
stream_puts(s, " |-\n");
gs_glyph_data_free(&gdata, "write_Private(CharStrings)");
}
}
/* Wrap up. */
stream_puts(s, "end\nend\nreadonly put\nnoaccess put\n");
s_release_param_printer(&rlist);
return 0;
}
const char *
pprintd3(stream * s, const char *format, int v1, int v2, int v3)
{
return pprintd2(s, pprintd1(s, format, v1), v2, v3);
}
