/* Build a type 32 (bitmap) font. */
static int
zbuildfont32(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
build_proc_refs build;
gs_font_base *pfont;
check_type(*op, t_dictionary);
code = build_proc_name_refs(imemory, &build, NULL, "%Type32BuildGlyph");
if (code < 0)
return code;
code = build_gs_simple_font(i_ctx_p, op, &pfont, ft_CID_bitmap,
&st_gs_font_base, &build,
bf_Encoding_optional);
if (code < 0)
return code;
/* Always transform cached bitmaps. */
pfont->BitmapWidths = true;
pfont->ExactSize = fbit_transform_bitmaps;
pfont->InBetweenSize = fbit_transform_bitmaps;
pfont->TransformedChar = fbit_transform_bitmaps;
/* The encode_char procedure of a Type 32 font */
/* should never be called. */
pfont->procs.encode_char = zfont_no_encode_char;
return define_gs_font((gs_font *) pfont);
}
/* Build a type 2 (compact Adobe encrypted) font. */
static int
zbuildfont2(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
charstring_font_refs_t refs;
build_proc_refs build;
int code = build_proc_name_refs(imemory, &build,
"%Type2BuildChar", "%Type2BuildGlyph");
gs_type1_data data1;
if (code < 0)
return code;
code = charstring_font_get_refs(op, &refs);
if (code < 0)
return code;
code = type2_font_params(op, &refs, &data1);
if (code < 0)
return code;
return build_charstring_font(i_ctx_p, op, &build, ft_encrypted2, &refs,
&data1, bf_notdef_required);
}
/* <string|name> <font_dict> .buildfont9 <string|name> <font> */
static int
zbuildfont9(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
build_proc_refs build;
int code = build_proc_name_refs(imemory, &build, NULL, "%Type9BuildGlyph");
gs_font_cid_data common;
ref GlyphDirectory, GlyphData, DataSource;
ref *prfda, cfnstr;
ref *pCIDFontName, CIDFontName;
gs_font_type1 **FDArray;
uint FDArray_size;
int FDBytes;
uint CIDMapOffset;
gs_font_base *pfont;
gs_font_cid0 *pfcid;
uint i;
/*
* If the CIDFont's data have been loaded into VM, GlyphData will be
* a string or an array of strings; if they are loaded incrementally
* from a file, GlyphData will be an integer, and DataSource will be
* a (reusable) stream.
*/
if (code < 0 ||
(code = cid_font_data_param(op, &common, &GlyphDirectory)) < 0 ||
(code = dict_find_string(op, "FDArray", &prfda)) < 0 ||
(code = dict_find_string(op, "CIDFontName", &pCIDFontName)) <= 0 ||
(code = dict_int_param(op, "FDBytes", 0, MAX_FDBytes, -1, &FDBytes)) < 0
)
return code;
/*
* Since build_gs_simple_font may resize the dictionary and cause
* pointers to become invalid, save CIDFontName
*/
CIDFontName = *pCIDFontName;
if (r_has_type(&GlyphDirectory, t_null)) {
/* Standard CIDFont, require GlyphData and CIDMapOffset. */
ref *pGlyphData;
if ((code = dict_find_string(op, "GlyphData", &pGlyphData)) < 0 ||
(code = dict_uint_param(op, "CIDMapOffset", 0, max_uint - 1,
max_uint, &CIDMapOffset)) < 0)
return code;
GlyphData = *pGlyphData;
if (r_has_type(&GlyphData, t_integer)) {
ref *pds;
stream *ignore_s;
if ((code = dict_find_string(op, "DataSource", &pds)) < 0)
return code;
check_read_file(i_ctx_p, ignore_s, pds);
DataSource = *pds;
} else {
if (!r_has_type(&GlyphData, t_string) && !r_is_array(&GlyphData))
return_error(e_typecheck);
make_null(&DataSource);
}
} else {
make_null(&GlyphData);
make_null(&DataSource);
CIDMapOffset = 0;
}
if (!r_is_array(prfda))
return_error(e_invalidfont);
FDArray_size = r_size(prfda);
if (FDArray_size == 0)
return_error(e_invalidfont);
FDArray = ialloc_struct_array(FDArray_size, gs_font_type1 *,
&st_gs_font_type1_ptr_element,
"buildfont9(FDarray)");
if (FDArray == 0)
return_error(e_VMerror);
memset(FDArray, 0, sizeof(gs_font_type1 *) * FDArray_size);
for (i = 0; i < FDArray_size; ++i) {
ref rfd;
array_get(imemory, prfda, (long)i, &rfd);
code = fd_array_element(i_ctx_p, &FDArray[i], &rfd);
if (code < 0)
goto fail;
}
code = build_gs_outline_font(i_ctx_p, op, &pfont, ft_CID_encrypted,
&st_gs_font_cid0, &build,
bf_Encoding_optional | bf_UniqueID_ignored,
build_gs_simple_font);
if (code < 0)
goto fail;
if (code == 1) {
/* The font already has a FID, don't need to build it again.
Release FDArray and return normally.
fixme: FDArray fonts are thrown for garbager.
We're not safe to build them after
build_gs_simple_font(..., &pfont, ...),
because a failure in building them would throw
an underbuilt font with unclear consequences.
*/
ifree_object(FDArray, "buildfont9(FDarray)");
return 0;
}
pfont->procs.enumerate_glyph = gs_font_cid0_enumerate_glyph;
pfont->procs.glyph_outline = z9_glyph_outline;
pfont->procs.glyph_info = z9_glyph_info;
pfcid = (gs_font_cid0 *)pfont;
pfcid->cidata.common = common;
pfcid->cidata.CIDMapOffset = CIDMapOffset;
pfcid->cidata.FDArray = FDArray;
pfcid->cidata.FDArray_size = FDArray_size;
pfcid->cidata.FDBytes = FDBytes;
pfcid->cidata.glyph_data = z9_glyph_data;
pfcid->cidata.proc_data = 0; /* for GC */
if (pfcid->font_name.size == 0) {
get_font_name(imemory, &cfnstr, &CIDFontName);
copy_font_name(&pfcid->font_name, &cfnstr);
}
ref_assign(&pfont_data(pfont)->u.cid0.GlyphDirectory, &GlyphDirectory);
ref_assign(&pfont_data(pfont)->u.cid0.GlyphData, &GlyphData);
ref_assign(&pfont_data(pfont)->u.cid0.DataSource, &DataSource);
code = define_gs_font(i_ctx_p, (gs_font *)pfont);
if (code >= 0)
code = gs_notify_register(&pfont->notify_list, notify_remove_font_type9, pfont);
if (code >= 0) {
for (i = 0; i < FDArray_size; ++i) {
FDArray[i]->dir = pfont->dir;
FDArray[i]->data.parent = pfont;
}
return code;
}
fail:
ifree_object(FDArray, "buildfont9(FDarray)");
return code;
}
/* Get one element of a FDArray. */
static int
fd_array_element(i_ctx_t *i_ctx_p, gs_font_type1 **ppfont, ref *prfd)
{
charstring_font_refs_t refs;
gs_type1_data data1;
build_proc_refs build;
gs_font_base *pbfont;
gs_font_type1 *pfont;
/*
* Standard CIDFontType 0 fonts have Type 1 fonts in the FDArray, but
* CFF CIDFontType 0 fonts have Type 2 fonts there.
*/
int fonttype = 1; /* default */
int code = charstring_font_get_refs(prfd, &refs);
if (code < 0 ||
(code = dict_int_param(prfd, "FontType", 1, 2, 1, &fonttype)) < 0
)
return code;
/*
* We don't handle the alternate Subr representation (SubrCount,
* SDBytes, SubrMapOffset) here: currently that is handled in
* PostScript code (lib/gs_cidfn.ps).
*/
switch (fonttype) {
case 1:
data1.interpret = gs_type1_interpret;
data1.subroutineNumberBias = 0;
data1.lenIV = DEFAULT_LENIV_1;
code = charstring_font_params(imemory, prfd, &refs, &data1);
if (code < 0)
return code;
code = build_proc_name_refs(imemory, &build,
"%Type1BuildChar", "%Type1BuildGlyph");
break;
case 2:
code = type2_font_params(prfd, &refs, &data1);
if (code < 0)
return code;
code = charstring_font_params(imemory, prfd, &refs, &data1);
if (code < 0)
return code;
code = build_proc_name_refs(imemory, &build,
"%Type2BuildChar", "%Type2BuildGlyph");
break;
default: /* can't happen */
return_error(e_Fatal);
}
if (code < 0)
return code;
code = build_gs_FDArray_font(i_ctx_p, prfd, &pbfont, fonttype,
&st_gs_font_type1, &build);
if (code < 0)
return code;
pfont = (gs_font_type1 *)pbfont;
pbfont->FAPI = NULL;
pbfont->FAPI_font_data = NULL;
charstring_font_init(pfont, &refs, &data1);
pfont->data.procs.glyph_data = z9_FDArray_glyph_data;
pfont->data.procs.seac_data = z9_FDArray_seac_data;
*ppfont = pfont;
return 0;
}
