/* * 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); }