/* * Conversion to PDFDoc/EBCDIC or UTF-16/[EBCDIC-]UTF-8 */ char * pdf_convert_hypertext(PDF *p, const char *text, int len, pdc_text_format hypertextformat, pdc_encoding hypertextencoding, int codepage, int *outlen, pdc_bool oututf8, pdc_bool verbose) { pdc_encodingvector *inev = NULL, *outev = NULL; pdc_byte *intext = (pdc_byte *) text, *outtext = NULL; pdc_text_format textformat = pdc_utf16be; int convflags = PDC_CONV_WITHBOM | PDC_CONV_TRYBYTES; *outlen = 0; if (text == NULL) return NULL; if (len == 0) len = (int) strlen(text); /* incoming encoding */ if (hypertextencoding >= 0) { inev = pdc_get_encoding_vector(p->pdc, hypertextencoding); } /* PDFDocEncoding */ outev = pdc_get_encoding_vector(p->pdc, pdc_pdfdoc); /* conversion to UTF-16-BE or PDFDocEncoding / EBCDIC */ pdf_set_convertflags(p, &convflags); if (pdc_logg_is_enabled(p->pdc, 3, trc_text)) convflags |= PDC_CONV_LOGGING; pdc_convert_string(p->pdc, hypertextformat, codepage, inev, intext, len, &textformat, outev, &outtext, outlen, convflags, verbose); /* conversion to UTF-8 if Unicode */ if (oututf8 && textformat == pdc_utf16be) { pdc_text_format outtextformat = PDC_UTF8; pdc_byte *newtext = NULL; convflags = PDC_CONV_WITHBOM; if (pdc_logg_is_enabled(p->pdc, 3, trc_text)) convflags |= PDC_CONV_LOGGING; pdc_convert_string(p->pdc, textformat, 0, NULL, outtext, *outlen, &outtextformat, NULL, &newtext, outlen, convflags, verbose); pdc_free(p->pdc, outtext); outtext = newtext; } return (char *) outtext; }
char * pdf_convert_pdfstring(PDF *p, const char *text, int inlen, int convflags, int *outlen) { pdc_byte *newtext = NULL; if (pdc_is_utf8_bytecode(text)) { pdc_text_format textformat = PDC_UTF8; pdc_text_format outtextformat = pdc_utf16be; pdc_encodingvector *outev = pdc_get_encoding_vector(p->pdc, pdc_pdfdoc); pdf_set_convertflags(p, &convflags); pdc_convert_string(p->pdc, textformat, 0, NULL, (pdc_byte *) text, inlen, &outtextformat, outev, &newtext, outlen, convflags, pdc_true); } else { newtext = (pdc_byte *) text; *outlen = inlen; } return (char *) newtext; }
void fnt_cleanup_font(pdc_core *pdc, fnt_font *font) { int i = 0; (void) i; fnt_cleanup_font_metric(pdc, &font->m); if (font->name != NULL) { pdc_free(pdc, font->name); font->name = NULL; } if (font->utf8name != NULL) { pdc_free(pdc, font->utf8name); font->utf8name = NULL; } if (font->filename != NULL) { pdc_free(pdc, font->filename); font->filename = NULL; } /* delete font specific encoding vector */ if (font->enc >= pdc_firstvarenc) { pdc_encodingvector *ev = pdc_get_encoding_vector(pdc, font->enc); if (ev != NULL && ev->flags & PDC_ENC_FONT) pdc_remove_encoding_vector(pdc, (int) font->enc); } if (font->gid2code != NULL) { pdc_free(pdc, font->gid2code); font->gid2code = NULL; } if (font->code2gid != NULL) { pdc_free(pdc, font->code2gid); font->code2gid = NULL; } if (font->cmapname != NULL) { pdc_free(pdc, font->cmapname); font->cmapname = NULL; } fnt_cleanup_fontimg(pdc, font); }
pdc_bool pdf_get_metrics_tt(PDF *p, pdf_font *font, const char *fontname, pdc_encoding enc, const char *filename) { pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_font); pdc_bool logg2 = pdc_logg_is_enabled(p->pdc, 2, trc_font); int filesize = 0; double kbfilesize = 0; int foundglyphs, flags = 0; tt_file *ttf; pdc_bool retval; pdc_encoding enc_req; pdc_encodingvector *ev = NULL; pdc_bool isotf; int errcode = 0; (void) logg2; /* * Initialisation */ ttf = fnt_new_tt(p->pdc, &font->ft); ttf->filename = filename; ttf->fontname = fontname; ttf->verbose = font->verbose; ttf->incore = pdc_true; ttf->monospace = font->opt.monospace; filesize = font->ft.filelen; kbfilesize = filesize / 1024.0; /* * Read font file */ retval = fnt_read_tt(ttf); if (retval == pdc_false) goto PDF_TRUETYPE_ERROR2; /* * Font type */ if (ttf->tab_CFF_) { isotf = pdc_true; font->ft.m.type = fnt_Type1C; font->cff_offset = (long) ttf->tab_CFF_->offset; font->cff_length = ttf->tab_CFF_->length; } else { isotf = pdc_false; font->ft.m.type = fnt_TrueType; TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_glyf) != -1); TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_loca) != -1); } /* Number of Glyphs */ if (ttf->numGlyphs <= 1) { errcode = FNT_E_TT_NOGLYFDESC; goto PDF_TRUETYPE_ERROR1; } /* * Encoding */ if (isotf) { /* OpenType font with CFF table */ if (ttf->charcoll != cc_none) { /* CID font */ if (font->ft.m.charcoll != cc_none) { if (!ttf->regisadobe) { errcode = PDF_E_CJK_UNSUPP_REGISTRY; goto PDF_TRUETYPE_ERROR1; } if (font->ft.m.charcoll != ttf->charcoll) { errcode = PDF_E_CJK_UNSUPP_CHARCOLL; goto PDF_TRUETYPE_ERROR1; } if (font->outcmapname != NULL) enc = pdc_cid; if (logg1) pdc_logg(p->pdc, "\tCID font ordering: \"%s\"\n", fnt_get_ordering_cid(ttf->charcoll)); } else if (enc == pdc_unicode || enc == pdc_glyphid) { font->ft.m.charcoll = ttf->charcoll; font->supplement = ttf->supplement; } else { errcode = PDF_E_FONT_ONLY_CMAP; goto PDF_TRUETYPE_ERROR1; } } else if (font->ft.m.charcoll != cc_none) { /* SID font */ errcode = PDF_E_FONT_UNSUPP_CMAP; goto PDF_TRUETYPE_ERROR1; } } else { if (font->ft.m.charcoll != cc_none) { int i; pdc_bool iscjk = pdc_false; for (i = 0; i < PDC_NUMCHARCOLL; i++) { if (ttf->tab_OS_2->charcolls[i]) iscjk = pdc_true; if (ttf->tab_OS_2->charcolls[i] == font->ft.m.charcoll) break; } if (i == PDC_NUMCHARCOLL) { if (iscjk) { /* CJK font */ errcode = PDF_E_CJK_UNSUPP_CHARCOLL; goto PDF_TRUETYPE_ERROR1; } else { /* no CJK font */ errcode = PDF_E_FONT_UNSUPP_CMAP; goto PDF_TRUETYPE_ERROR1; } } else { if (font->outcmapname != NULL) { ttf->charcoll = font->ft.m.charcoll; enc = pdc_cid; } } } } /* encoding vector */ enc_req = fnt_get_tt_encoding_key(ttf, enc); if (enc_req == pdc_invalidenc) { errcode = FNT_E_TT_BADCMAP; goto PDF_TRUETYPE_ERROR1; } else if (enc_req != enc) { if (strcmp(font->encapiname, "auto")) { pdc_warning(p->pdc, PDF_E_FONT_FORCEENC, pdf_get_encoding_name(p, enc_req, NULL), 0, 0, 0); } enc = enc_req; } if (enc >= 0) ev = pdc_get_encoding_vector(p->pdc, enc); font->ft.enc = enc; font->ft.issymbfont = ttf->issymbol; font->hasnomac = !ttf->tab_cmap || !ttf->tab_cmap->mac; /* builtin encoding */ if (enc == pdc_builtin) { if (font->ft.issymbfont == pdc_false) { errcode = PDF_E_FONT_BADENC; goto PDF_TRUETYPE_ERROR1; } else { /* encoding vector for builtin */ ev = pdf_create_font_encoding(p, enc, font, fontname, pdc_true); font->symenc = font->ft.enc; } } { /* optimizing PDF output */ if (enc == pdc_ebcdic || enc == pdc_ebcdic_37 || enc == pdc_ebcdic_winansi) font->towinansi = pdc_winansi; } /* /FontName in FontDescriptor */ font->ft.m.name = pdc_strdup(p->pdc, ttf->tab_name->englishname4); /* /BaseFont name */ font->ft.name = pdc_strdup(p->pdc, ttf->tab_name->englishname6); #define PDF_RESTRICTED_TT_EMBEDDING 0x02 /* check embedding flags */ if ((font->opt.embedding) && ttf->tab_OS_2 && ttf->tab_OS_2->fsType == PDF_RESTRICTED_TT_EMBEDDING) { errcode = FNT_E_TT_EMBED; goto PDF_TRUETYPE_ERROR1; } if (logg1) { pdc_logg(p->pdc, "\tFull font name: \"%s\"\n" "\tPostScript font name: \"%s\"\n" "\tFont embedding: %s\n" "\tVertical font: %s\n", font->ft.name, font->ft.m.name, PDC_BOOLSTR(font->opt.embedding), PDC_BOOLSTR(font->ft.vertical)); if (ttf->tab_name->producer != NULL) pdc_logg(p->pdc, "\tFont producer: \"%s\"\n", ttf->tab_name->producer); pdc_logg(p->pdc, "\tNumber of Glyphs: %d\n", ttf->numGlyphs); } /* Save font values */ fnt_set_tt_fontvalues(ttf); /* Flags for creating font arrays */ flags = TT_FONT_code2gid | TT_FONT_m_widths; /* Create font mapping and width arrays */ foundglyphs = fnt_set_tt_fontarrays(ttf, flags); /***********************************/ if (font->symenc != pdc_invalidenc) font->ft.enc = pdc_builtin; /***********************************/ if (!foundglyphs) { errcode = PDF_E_FONT_BADENC; goto PDF_TRUETYPE_ERROR1; } fnt_delete_tt(ttf); if (!pdf_make_fontflag(p, font)) return pdc_false; return pdc_true; PDF_TRUETYPE_ERROR1: pdc_set_errmsg(p->pdc, errcode, 0, 0, 0, 0); PDF_TRUETYPE_ERROR2: fnt_delete_tt(ttf); return pdc_false; }
pdc_bool pdf_check_pfm_encoding(PDF *p, pdf_font *font, pdc_encoding enc) { const char *encname = pdc_errprintf(p->pdc, "%.*s", PDC_ERR_MAXSTRLEN, pdf_get_encoding_name(p, enc, font)); const char *intencname = NULL; pdc_encoding intenc = pdc_invalidenc; pdc_bool issymbfont = pdc_undef; pdc_logg_cond(p->pdc, 2, trc_font, "\tFont internal charset (dfCharSet): %d\n", font->ft.enc); /* Font encoding */ intencname = pdc_get_keyword(font->ft.enc, pdf_charset_keylist); if (intencname == NULL) { pdc_set_errmsg(p->pdc, PDF_E_T1_BADCHARSET, pdc_errprintf(p->pdc, "%d", font->ft.enc), 0, 0, 0); return pdc_false; } if (strlen(intencname)) { int codepage = 0; pdc_logg_cond(p->pdc, 2, trc_font, "\tFont internal encoding \"%s\" found\n", intencname); intenc = pdc_find_encoding(p->pdc, intencname); if (intenc == pdc_invalidenc) intenc = pdc_insert_encoding(p->pdc, intencname, &codepage, pdc_true); font->ft.issymbfont = pdc_false; } else { pdc_logg_cond(p->pdc, 2, trc_font, "\tSymbol font\n"); font->ft.issymbfont = pdc_true; intenc = pdc_builtin; /* auto */ if (!strcmp(font->encapiname, "auto")) { issymbfont = pdc_true; enc = pdc_builtin; } } /* builtin */ if (enc == pdc_builtin) issymbfont = pdc_true; /* unicode */ if (enc == pdc_unicode) { font->unibyte = pdc_true; issymbfont = pdc_false; enc = intenc; } /* encoding is subset of 8-bit encoding */ if (enc >= pdc_winansi && intenc >= pdc_winansi) { if (pdc_is_encoding_subset(p->pdc, pdc_get_encoding_vector(p->pdc, enc), pdc_get_encoding_vector(p->pdc, intenc))) { if (enc != pdc_winansi && intenc == pdc_winansi && strcmp(encname, "iso8859-1")) { font->towinansi = intenc; } else { enc = intenc; } issymbfont = pdc_false; } } /* illegal encoding */ if (issymbfont == pdc_undef || font->ft.issymbfont == pdc_undef) { pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, 0, 0, 0, 0); return pdc_false; } font->ft.enc = enc; if (issymbfont && !font->ft.issymbfont) { pdc_warning(p->pdc, PDF_E_FONT_FORCEENC, pdf_get_encoding_name(p, intenc, NULL), 0, 0, 0); font->ft.enc = intenc; } if (!issymbfont && font->ft.issymbfont) { pdc_warning(p->pdc, PDF_E_FONT_FORCEENC, pdf_get_encoding_name(p, pdc_builtin, NULL), 0, 0, 0); font->ft.enc = pdc_builtin; font->towinansi = pdc_invalidenc; } if (font->towinansi != pdc_invalidenc) pdf_transform_fontwidths(p, font, pdc_get_encoding_vector(p->pdc, font->ft.enc), pdc_get_encoding_vector(p->pdc, font->towinansi)); return pdc_true; }
pdc_bool pdf_handle_t3font(PDF *p, const char *fontname, pdc_encoding enc, pdf_font *font, int *slot) { static const char fn[] = "pdf_handle_t3font"; const char *encname; char *fname; size_t namlen; pdf_font *deffont = &p->fonts[*slot]; pdc_encodingvector *ev = pdc_get_encoding_vector(p->pdc, enc); fnt_font_metric *ftm = &font->ft.m; size_t nalloc; int code, gid; pdc_bool newinst = pdc_false; /* font name incl. encoding name */ encname = pdc_get_user_encoding(p->pdc, enc); namlen = strlen(fontname) + strlen(encname) + 2; fname = (char *) pdc_malloc(p->pdc, namlen, fn); pdc_sprintf(p->pdc, pdc_false, fname, "%s.%s", fontname, encname); /* we have to copy the available font. * otherwise the original font will be changed */ newinst = deffont->ft.enc != pdc_invalidenc; pdc_logg_cond(p->pdc, 1, trc_font, "\n\tType3 font \"%s\" with %d glyphs found\n", fontname, deffont->t3font->next_glyph); if (newinst) { pdc_logg_cond(p->pdc, 1, trc_font, "\tInstance with specified encoding will be created\n"); } /* copy data from available font (see pdf__begin_font()) */ font->ft.m.type = fnt_Type3; font->ft.matrix = deffont->ft.matrix; font->ft.bbox = deffont->ft.bbox; font->t3font = deffont->t3font; font->ft.numglyphs = deffont->t3font->next_glyph; nalloc = (size_t) font->ft.numglyphs; ftm->name = fname; font->ft.name = pdc_strdup(p->pdc, fname); font->ft.enc = enc; font->ft.issymbfont = pdc_false; font->opt.embedding = pdc_true; if (enc >= pdc_winansi) { font->codesize = 1; font->ft.numcodes = 256; font->lastcode = -1; ftm->widths = (int *) pdc_calloc(p->pdc, (size_t) font->ft.numcodes * sizeof(int), fn); ftm->numwidths = font->ft.numcodes; } font->ft.code2gid = (pdc_ushort *) pdc_calloc(p->pdc, (size_t) font->ft.numcodes * sizeof(pdc_ushort), fn); font->ft.gid2code = (pdc_ushort *) pdc_calloc(p->pdc, nalloc * sizeof (pdc_ushort), fn); /* fill up font arrays */ for (gid = 0; gid < font->ft.numglyphs; gid++) { const char *str = NULL, *glyphname = font->t3font->glyphs[gid].name; if (enc >= pdc_winansi) { /* search for code */ for (code = 0; code < font->ft.numcodes; code++) { if (ev->chars[code] != NULL) str = ev->chars[code]; else if (ev->codes[code]) str = pdc_unicode2glyphname(p->pdc, ev->codes[code]); if (str != NULL && !pdc_strcmp(glyphname, str)) break; } /* code found */ if (code < font->ft.numcodes) { font->ft.code2gid[code] = gid; font->ft.gid2code[gid] = code; if (!gid) font->gid0code = code; if (font->opt.monospace) ftm->widths[code] = font->opt.monospace; else ftm->widths[code] = (int) (font->t3font->glyphs[gid].width + 0.5); } } } pdf_type3_protocol(p, font, ev); /* font flags */ if (!pdf_make_fontflag(p, font)) return pdc_false; if (newinst) { *slot = -1; } else { if (deffont->apiname != NULL) pdc_free(p->pdc, deffont->apiname); *deffont = *font; deffont->hasoriginal = pdc_true; } return pdc_true; }
pdc_bool pdf_process_metrics_data( PDF *p, pdf_font *font, const char *fontname) { static const char fn[] = "pdf_process_metrics_data"; fnt_font_metric *ftm = &font->ft.m; int width = 0; pdc_ushort uv; pdc_encoding enc = font->ft.enc; pdc_encodingvector *ev = NULL; int /* nalloc, */ foundglyphs = 0, i, j = 0, k; (void) j; /* Unallowed encoding */ if (enc == pdc_cid || enc < pdc_builtin) { pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, 0, 0, 0, 0); return pdc_false; } /* Determine the default character width (width of space character) */ if (font->opt.monospace) { ftm->defwidth = font->opt.monospace; } else { width = fnt_get_glyphwidth((int) PDF_DEFAULT_CHAR, &font->ft); if (width != FNT_MISSING_WIDTH) ftm->defwidth = width; else ftm->defwidth = FNT_DEFAULT_WIDTH; } /* builtin font */ if (font->ft.issymbfont == pdc_true && enc != pdc_builtin && !strcmp(font->encapiname, "auto")) { enc = pdc_builtin; font->ft.enc = enc; } /* optimizing PDF output */ if (enc == pdc_ebcdic || enc == pdc_ebcdic_37 || enc == pdc_ebcdic_winansi) font->towinansi = pdc_winansi; /* glyph name list for incore fonts */ /* nalloc = font->ft.numglyphs + AFM_GLYPH_SUPPL; */ /* * Generate character width according to the chosen encoding */ { font->ft.numcodes = 256; font->ft.code2gid = (pdc_ushort *) pdc_calloc(p->pdc, font->ft.numcodes * sizeof (pdc_ushort), fn); ftm->numwidths = font->ft.numcodes; ftm->widths = (int *)pdc_calloc(p->pdc, font->ft.numcodes * sizeof(int), fn); /* Given 8-bit encoding */ if (enc >= 0) { ev = pdc_get_encoding_vector(p->pdc, enc); for (k = 0; k < font->ft.numcodes; k++) { uv = ev->codes[k]; ftm->widths[k] = ftm->defwidth; if (uv) { uv = pdc_get_alter_glyphname(uv, font->missingglyphs, NULL); if (uv) { for (i = 0; i < ftm->numglwidths; i++) { if (ftm->glw[i].unicode == uv) { j = i + 1; ftm->widths[k] = ftm->glw[i].width; font->ft.code2gid[k] = (pdc_ushort) j; foundglyphs++; } } } } } if (ftm->ciw != NULL) { pdc_free(p->pdc, ftm->ciw); ftm->ciw = NULL; } pdc_logg_cond(p->pdc, 2, trc_font, "\t\t%d glyphs could be mapped to Unicode\n", foundglyphs); /* No characters found */ if (!foundglyphs) { if (font->ft.issymbfont == pdc_false) { pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, 0, 0, 0, 0); return pdc_false; } else { /* We enforce builtin encoding */ pdc_warning(p->pdc, PDF_E_FONT_FORCEENC, pdf_get_encoding_name(p, pdc_builtin, font), 0, 0, 0); enc = pdc_builtin; font->ft.enc = enc; font->towinansi = pdc_invalidenc; } } else if (foundglyphs < PDF_MIN_GLYPHS) { pdc_warning(p->pdc, PDF_E_FONT_INAPPROPENC, pdc_errprintf(p->pdc, "%d", foundglyphs), 0, 0, 0); } } /* built-in encoding */ if (enc == pdc_builtin) { if (ftm->glw == NULL) { pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, 0, 0, 0, 0); return pdc_false; } /* encoding for builtin */ ev = pdf_create_font_encoding(p, enc, font, fontname, pdc_true); font->symenc = font->ft.enc; /***************************/ font->ft.enc = pdc_builtin; /***************************/ for (i = 0; i < font->ft.numcodes; i++) { ftm->widths[i] = ftm->defwidth; } for (i = 0; i < font->ft.numglyphs; i++) { pdc_short code = ftm->glw[i].code; if (code >= 0 && code < font->ft.numcodes) { j = i + 1; ftm->widths[code] = ftm->glw[i].width; font->ft.code2gid[code] = (pdc_ushort) j; if (ev != NULL) { ev->codes[code] = ftm->glw[i].unicode; } } } } } if (ftm->glw != NULL) { pdc_free(p->pdc, ftm->glw); ftm->glw = NULL; } return pdc_true; }
char * pdf_get_opt_filename(PDF *p, const char *keyword, pdc_resopt *resopts, pdc_encoding enc, int codepage) { pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_optlist); pdc_bool logg3 = pdc_logg_is_enabled(p->pdc, 3, trc_text); pdc_byte *filename = NULL; char **strlist; if (pdc_get_optvalues(keyword, resopts, NULL, &strlist)) { pdc_encodingvector *inev = NULL, *outev = NULL; pdc_text_format intextformat = pdc_bytes; pdc_text_format outtextformat = pdc_utf16; /* sic! */ int convflags = PDC_CONV_NOBOM | PDC_CONV_TRYBYTES | PDC_CONV_NEWALLOC; pdc_bool isutf8; int ic, outlen; /* whole option list or string list is in UTF-8 */ isutf8 = pdc_is_lastopt_utf8(resopts); if (!isutf8) { if (enc < 0 && enc != pdc_unicode && enc != pdc_cid) enc = pdf_get_hypertextencoding(p, "auto", &codepage, pdc_true); if (enc >= 0) inev = pdc_get_encoding_vector(p->pdc, enc); } else { intextformat = PDC_UTF8; } if (logg1) { if (isutf8) { pdc_logg(p->pdc, "\tOption \"%s\" is "PDC_UTF8_STRG" encoded\n", keyword); } else { pdc_logg(p->pdc, "\tOption \"%s\" is %s encoded\n", keyword, pdc_get_user_encoding(p->pdc, enc)); } } outev = pdc_get_encoding_vector(p->pdc, pdc_winansi); if (logg3) convflags |= PDC_CONV_LOGGING; pdf_set_convertflags(p, &convflags); pdc_convert_string(p->pdc, intextformat, codepage, inev, (pdc_byte *) strlist[0], (int) strlen(strlist[0]), &outtextformat, outev, &filename, &outlen, convflags, pdc_true); if (outtextformat == pdc_utf16) { pdc_ushort uv, *unifilename = (pdc_ushort *) filename; int code; if (p->compatibility < PDC_1_7) pdc_error(p->pdc, PDC_E_IO_UNSUPP_PDFUNINAME, 0, 0, 0, 0); /* we must replace non-WinAnsi characters by period * and omit the BOM to get a WinAnsi string. */ outlen /= 2; for (ic = 0; ic < outlen; ic++) { uv = unifilename[ic]; code = pdc_get_encoding_bytecode(p->pdc, outev, uv); if (code <= 0) uv = PDC_UNICODE_PERIOD; filename[ic] = (char) uv; } filename[ic] = 0; } if (logg3) pdc_logg_hexdump(p->pdc, "output filename", "\t\t", (char *) filename, strlen((char *) filename)); } return (char *) filename; }
int pdf_get_opt_textlist(PDF *p, const char *keyword, pdc_resopt *resopts, pdc_encoding enc, int codepage, pdc_bool ishypertext, const char *fieldname, char **text, char ***textlist) { pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_optlist); int ns; char **strlist; ns = pdc_get_optvalues(keyword, resopts, NULL, &strlist); if (ns) { pdc_byte *string = NULL; pdc_encodingvector *inev = NULL, *outev = NULL; pdc_text_format intextformat = pdc_bytes; pdc_text_format outtextformat = pdc_utf16be; pdc_text_format textformat; int convflags = PDC_CONV_WITHBOM; pdc_bool isutf8; int i, outlen; /* whole option list or string list is in UTF-8 */ isutf8 = pdc_is_lastopt_utf8(resopts); /* Encoding */ if (ishypertext) { /* Initialize */ if (!isutf8) { if (enc < 0 && enc != pdc_unicode && enc != pdc_cid) enc = pdf_get_hypertextencoding(p, "auto", &codepage, pdc_true); if (enc >= 0) inev = pdc_get_encoding_vector(p->pdc, enc); } outev = pdc_get_encoding_vector(p->pdc, pdc_pdfdoc); /* conversion to PDFDocEncoding if possible */ convflags |= PDC_CONV_TRYBYTES; } else { if (enc == pdc_invalidenc) { if (fieldname) { pdc_cleanup_optionlist(p->pdc, resopts); pdc_error(p->pdc, PDF_E_FF_FONTMISSING, fieldname, 0, 0, 0); } return 0; } else if (enc >= 0 && !isutf8) { /* bug #2069: always conversion to UTF-16BE */ inev = pdc_get_encoding_vector(p->pdc, enc); } } if (logg1) { if (isutf8) { pdc_logg(p->pdc, "\tOption \"%s\" is "PDC_UTF8_STRG" encoded\n", keyword); } else { pdc_logg(p->pdc, "\tOption \"%s\" is %s encoded\n", keyword, pdc_get_user_encoding(p->pdc, enc)); } } for (i = 0; i < ns; i++) { string = (pdc_byte *) strlist[i]; { if (ishypertext || isutf8 || inev != NULL) { intextformat = isutf8 ? PDC_UTF8 : pdc_bytes; if (pdc_logg_is_enabled(p->pdc, 3, trc_text)) convflags |= PDC_CONV_LOGGING; pdf_set_convertflags(p, &convflags); textformat = outtextformat; pdc_convert_string(p->pdc, intextformat, codepage, inev, string, (int) strlen((char *) string), &textformat, outev, &string, &outlen, convflags, pdc_true); pdc_free(p->pdc, strlist[i]); strlist[i] = (char *) string; } } } if (text) *text = strlist[0]; else *textlist = strlist; if (fieldname) { strlist = (char **) pdc_save_lastopt(resopts, PDC_OPT_SAVEALL); pdf_insert_stringlist(p, strlist, ns); } } return ns; }