int
pdc_get_keymask_ci(pdc_core *pdc, const char *option,
const char *keywordlist, const pdc_keyconn *keyconn)
{
char **keys = NULL;
int nkeys, i, j, k = 0;
nkeys = pdc_split_stringlist(pdc, keywordlist, NULL, 0, &keys);
for (j = 0; j < nkeys; j++)
{
for (i = 0; keyconn[i].word != NULL; i++)
if (!pdc_stricmp(keys[j], keyconn[i].word))
break;
if (keyconn[i].word == NULL)
{
const char *stemp = pdc_errprintf(pdc, "%.*s",
PDC_ERR_MAXSTRLEN, keys[j]);
pdc_cleanup_stringlist(pdc, keys);
pdc_set_errmsg(pdc, PDC_E_OPT_ILLKEYWORD, option, stemp, 0, 0);
return PDC_KEY_NOTFOUND;
}
k |= keyconn[i].code;
}
pdc_cleanup_stringlist(pdc, keys);
return k;
}
/* Creates a file depending on PDC_FILE_ASCII and pdc->asciifile.
*/
size_t
pdc_write_file(
pdc_core *pdc,
const char *filename,
const char *qualifier,
const char *content,
size_t len,
int flags)
{
size_t wlen = 0;
pdc_file *sfp;
sfp = pdc_fopen(pdc, filename, qualifier, NULL, 0, flags);
if (sfp != NULL)
{
wlen = pdc_fwrite_ascii(pdc, content, len, sfp->fp);
pdc_fclose(sfp);
if (wlen != len)
{
pdc_set_errmsg(pdc, PDC_E_IO_WRITE, filename, 0, 0, 0);
}
}
return wlen;
}
void
pdc_set_fopen_errmsg(pdc_core *pdc, int errnum, const char *qualifier,
const char *filename)
{
const char *stemp1 = NULL;
const char *stemp2 = NULL;
int errno1 = errno;
#if defined(EMACOSERR) && defined(MAC)
errno1 = (int) __MacOSErrNo;
#endif
errnum = pdc_get_fopen_errnum(pdc, errnum);
if (errnum == PDC_E_IO_RDOPEN)
errnum = PDC_E_IO_RDOPEN_CODE;
else if (errnum == PDC_E_IO_WROPEN)
errnum = PDC_E_IO_WROPEN_CODE;
if (errnum == PDC_E_IO_RDOPEN_CODE || errnum == PDC_E_IO_WROPEN_CODE)
{
stemp1 = pdc_errprintf(pdc, "%d", errno1);
#ifdef PDC_HAS_STRERROR
stemp2 = strerror(errno1);
if (stemp2 != NULL)
{
if (errnum == PDC_E_IO_RDOPEN_CODE)
errnum = PDC_E_IO_RDOPEN_CODETEXT;
else if (errnum == PDC_E_IO_WROPEN_CODE)
errnum = PDC_E_IO_WROPEN_CODETEXT;
}
#endif
}
pdc_set_errmsg(pdc, errnum, qualifier, filename, stemp1, stemp2);
}
/*
* flags: PDC_INT_HEXADEC, PDC_INT_CASESENS
*/
int
pdc_get_keycode_num(pdc_core *pdc, const char *option, const char *i_keyword,
int flags, const pdc_keyconn *keyconn, int *o_num)
{
static const char *fn = "pdc_get_keycode_num";
char *keyword;
int i, len, keycode;
keyword = pdc_strdup_ext(pdc, i_keyword, 0, fn);
len = (int) strlen(keyword);
*o_num = -1;
/* parse number */
for (i = 0; i < len; i++)
{
if (pdc_isdigit(keyword[i]))
{
if (pdc_str2integer(&keyword[i], flags, o_num))
{
keyword[i] = 0;
}
else
{
pdc_set_errmsg(pdc, PDC_E_OPT_ILLINTEGER, option, &keyword[i],
0, 0);
}
break;
}
}
if (flags & PDC_INT_CASESENS)
keycode = pdc_get_keycode(keyword, keyconn);
else
keycode = pdc_get_keycode_ci(keyword, keyconn);
if (keycode == PDC_KEY_NOTFOUND)
pdc_set_errmsg(pdc, PDC_E_OPT_ILLKEYWORD, option, keyword, 0, 0);
pdc_free(pdc, keyword);
return keycode;
}
pdc_bool
pdf_get_metrics_pfm(
PDF *p,
pdf_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename,
pdc_bool requested)
{
static const char fn[] = "pdf_get_metrics_pfm";
char fullname[PDC_FILENAMELEN];
pdc_file *pfmfile;
(void) fontname;
/* open PFM file */
pfmfile = pdc_fsearch_fopen(p->pdc, filename, fullname, "PFM ",
PDC_FILE_BINARY);
if (pfmfile == NULL)
return pdc_check_fopen_errmsg(p->pdc, requested);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tLoading PFM metric fontfile \"%s\":\n", fullname);
/* Read PFM metrics */
if (!pdf_parse_pfm(p, pfmfile, font))
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_CORRUPT, "PFM", fullname, 0, 0);
return pdc_false;
}
/* save full filename */
font->metricfilename = pdc_strdup_ext(p->pdc, fullname, 0, fn);
/* Check encoding */
if (!pdf_check_pfm_encoding(p, font, enc))
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
pdc_bool
pdf_get_metrics_pfm(
PDF *p,
pdc_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename)
{
pdc_file *pfmfile;
/* open PFM file */
pfmfile = pdf_fopen(p, filename, "PFM ", PDC_FILE_BINARY);
if (pfmfile == NULL)
{
if (font->verbose_open)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
/* Read PFM metrics */
if (!pdf_parse_pfm(p, pfmfile, font))
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_CORRUPT, "PFM", filename, 0, 0);
if (font->verbose == pdc_true)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
/* Check encoding */
if (!pdf_check_pfm_encoding(p, font, fontname, enc))
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
void
pdc_set_fwrite_errmsg(pdc_core *pdc, const char *filename)
{
const char *stemp1 = NULL;
const char *stemp2 = NULL;
int errno1 = errno;
int errnum = PDC_E_IO_WRITE;
#if defined(EMACOSERR)
#if defined(MAC) && defined(PDF_ALLOW_MAC_DEPR_FUNCS)
errno1 = (int) __MacOSErrNo;
#endif
#endif
stemp1 = pdc_errprintf(pdc, "%d", errno1);
#ifdef PDC_HAS_STRERROR
stemp2 = strerror(errno1);
if (stemp2 != NULL)
errnum = PDC_E_IO_WRITE_CODETEXT;
#endif
pdc_set_errmsg(pdc, errnum, filename, stemp1, stemp2, 0);
}
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_resopt *
pdc_parse_optionlist(pdc_core *pdc, const char *optlist,
const pdc_defopt *defopt,
const pdc_clientdata *clientdata, pdc_bool verbose)
{
static const char *fn = "pdc_parse_optionlist";
pdc_bool logg5 = pdc_logg_is_enabled(pdc, 5, trc_optlist);
const char *stemp1 = NULL, *stemp2 = NULL, *stemp3 = NULL, *s1, *s2;
char **items = NULL, *keyword = NULL;
char **values = NULL, *value = NULL, **strings = NULL;
int i, j, k, nd, is, iss, it, iv, icoord;
int numdef, nitems = 0, nvalues, ncoords = 0, errcode = 0;
void *resval;
double dz, maxval;
int retval, iz;
pdc_sint32 lz = 0;
pdc_uint32 ulz = 0;
size_t len;
const pdc_defopt *dopt = NULL;
pdc_resopt *resopt = NULL;
pdc_bool ignore = pdc_false;
pdc_bool boolval = pdc_false;
pdc_bool tocheck = pdc_false;
pdc_bool issorted = pdc_true;
pdc_bool ishandle = pdc_true;
pdc_bool isutf8 = pdc_false;
pdc_logg_cond(pdc, 1, trc_optlist, "\n\tOption list: \"%T\"\n",
optlist ? optlist : "", 0);
/* split option list */
if (optlist != NULL)
{
nitems = pdc_split_stringlist(pdc, optlist, PDC_OPT_LISTSEPS,
PDC_SPLIT_ISOPTLIST, &items);
isutf8 = pdc_is_utf8_bytecode(optlist);
}
if (nitems < 0)
{
keyword = (char *) optlist;
errcode = PDC_E_OPT_NOTBAL;
goto PDC_OPT_SYNTAXERROR;
}
/* initialize result list */
for (numdef = 0; defopt[numdef].name != NULL; numdef++)
{
/* */ ;
}
/* allocate temporary memory for option parser result struct */
resopt = (pdc_resopt *) pdc_calloc_tmp(pdc, numdef * sizeof(pdc_resopt),
fn, pdc, pdc_cleanup_optionlist_tmp);
for (i = 0; i < numdef; i++)
{
resopt[i].numdef = numdef;
resopt[i].defopt = &defopt[i];
if (defopt[i].flags & PDC_OPT_IGNOREIF1 ||
defopt[i].flags & PDC_OPT_IGNOREIF2 ||
defopt[i].flags & PDC_OPT_REQUIRIF1 ||
defopt[i].flags & PDC_OPT_REQUIRIF2 ||
defopt[i].flags & PDC_OPT_REQUIRED)
tocheck = pdc_true;
if (i && issorted)
issorted = (strcmp(defopt[i-1].name, defopt[i].name) <= 0) ?
pdc_true : pdc_false;
}
/* loop over all option list elements */
for (is = 0; is < nitems; is++)
{
pdc_bool isequal = pdc_false;
/* search keyword */
boolval = pdc_undef;
keyword = items[is];
for (it = 0; it < numdef; it++)
{
s1 = keyword;
s2 = defopt[it].name;
/* if (!pdc_stricmp(keyword, defopt[it].name))
* isequal = pdc_true;
*/
for (; *s1; ++s1, ++s2)
{
if (pdc_tolower(*s1) != pdc_tolower(*s2))
break;
}
if (pdc_tolower(*s1) == pdc_tolower(*s2))
isequal = pdc_true;
/* special handling for booleans */
if (defopt[it].type == pdc_booleanlist)
{
if (isequal ||
(keyword[1] != 0 &&
!pdc_stricmp(&keyword[2], defopt[it].name)))
{
iss = is + 1;
if (iss == nitems ||
(pdc_stricmp(items[iss], "true") &&
pdc_stricmp(items[iss], "false")))
{
i = pdc_strincmp(defopt[it].name, "no", 2) ? 0 : 2;
if (!pdc_strincmp(&keyword[i], "no", 2))
{
boolval = pdc_false;
break;
}
else if (isequal)
{
boolval = pdc_true;
break;
}
}
}
}
if (isequal)
break;
}
if (logg5)
pdc_logg(pdc, "\t\t\toption \"%s\" specified: ", keyword);
if (it == numdef)
{
errcode = PDC_E_OPT_UNKNOWNKEY;
goto PDC_OPT_SYNTAXERROR;
}
/* initialize */
dopt = &defopt[it];
ignore = pdc_false;
nvalues = 1;
values = NULL;
ishandle = pdc_true;
/* compatibility */
if (clientdata && clientdata->compatibility)
{
int compatibility = clientdata->compatibility;
for (iv = PDC_1_3; iv <= PDC_X_X_LAST; iv++)
{
if (logg5 && (dopt->flags & (1L<<iv)))
pdc_logg(pdc, "(compatibility >= %s) ",
pdc_get_pdfversion(pdc, iv));
if ((dopt->flags & (1L<<iv)) && compatibility < iv)
{
if (logg5)
pdc_logg(pdc, "\n");
stemp2 = pdc_get_pdfversion(pdc, compatibility);
errcode = PDC_E_OPT_VERSION;
goto PDC_OPT_SYNTAXERROR;
}
}
}
/* not supported */
if (dopt->flags & PDC_OPT_UNSUPP)
{
if (logg5)
pdc_logg(pdc, "(unsupported)\n");
keyword = (char *) dopt->name;
errcode = PDC_E_OPT_UNSUPP;
goto PDC_OPT_SYNTAXERROR;
}
/* parse values */
if (boolval == pdc_undef)
{
is++;
if (is == nitems)
{
errcode = PDC_E_OPT_NOVALUES;
goto PDC_OPT_SYNTAXERROR;
}
if (!ignore)
{
if (dopt->type == pdc_stringlist &&
pdc_is_utf8_bytecode(items[is]))
resopt[it].flags |= PDC_OPT_ISUTF8;
if (dopt->type != pdc_stringlist || dopt->maxnum > 1)
nvalues = pdc_split_stringlist(pdc, items[is],
(dopt->flags & PDC_OPT_SUBOPTLIST) ?
PDC_OPT_LISTSEPS : NULL,
PDC_SPLIT_ISOPTLIST, &values);
if (dopt->flags & PDC_OPT_DUPORIGVAL)
resopt[it].origval = pdc_strdup(pdc, items[is]);
}
}
/* ignore */
if (ignore) continue;
/* number of values check */
if (nvalues < dopt->minnum)
{
stemp2 = pdc_errprintf(pdc, "%d", dopt->minnum);
errcode = PDC_E_OPT_TOOFEWVALUES;
goto PDC_OPT_SYNTAXERROR;
}
else if (nvalues > dopt->maxnum)
{
stemp2 = pdc_errprintf(pdc, "%d", dopt->maxnum);
errcode = PDC_E_OPT_TOOMANYVALUES;
goto PDC_OPT_SYNTAXERROR;
}
/* number of values must be even */
if (dopt->flags & PDC_OPT_EVENNUM && (nvalues % 2))
{
errcode = PDC_E_OPT_ODDNUM;
goto PDC_OPT_SYNTAXERROR;
}
/* number of values must be odd */
if (dopt->flags & PDC_OPT_ODDNUM && !(nvalues % 2))
{
errcode = PDC_E_OPT_EVENNUM;
goto PDC_OPT_SYNTAXERROR;
}
/* deprecated option since PDFlib 7 */
if (dopt->flags & PDC_OPT_PDFLIB_7)
{
pdc_logg_cond(pdc, 2, trc_api,
"[Option \"%s\" is deprecated since PDFlib 7]\n",
keyword);
}
/* option already exists */
if (resopt[it].num)
{
pdc_delete_optvalue(pdc, &resopt[it]);
}
/* no values */
if (!nvalues ) continue;
/* maximal value */
switch (dopt->type)
{
case pdc_3ddatahandle:
maxval = clientdata->max3ddata;
break;
case pdc_3dviewhandle:
maxval = clientdata->max3dview;
break;
case pdc_actionhandle:
maxval = clientdata->maxaction;
break;
case pdc_bookmarkhandle:
maxval = clientdata->maxbookmark;
break;
case pdc_colorhandle:
maxval = clientdata->maxcolor;
break;
case pdc_documenthandle:
maxval = clientdata->maxdocument;
break;
case pdc_fonthandle:
maxval = clientdata->maxfont;
break;
case pdc_gstatehandle:
maxval = clientdata->maxgstate;
break;
case pdc_iccprofilehandle:
maxval = clientdata->maxiccprofile;
break;
case pdc_imagehandle:
maxval = clientdata->maximage;
break;
case pdc_layerhandle:
maxval = clientdata->maxlayer;
break;
case pdc_pagehandle:
maxval = clientdata->maxpage;
break;
case pdc_patternhandle:
maxval = clientdata->maxpattern;
break;
case pdc_shadinghandle:
maxval = clientdata->maxshading;
break;
case pdc_tablehandle:
maxval = clientdata->maxtable;
break;
case pdc_templatehandle:
maxval = clientdata->maxtemplate;
break;
case pdc_textflowhandle:
maxval = clientdata->maxtextflow;
break;
case pdc_stringhandle:
maxval = clientdata->maxstring;
break;
case pdc_polylinelist:
ncoords = 0;
default:
maxval = dopt->maxval;
ishandle = pdc_false;
break;
}
/* allocate value array */
resopt[it].val = pdc_calloc(pdc,
(size_t) (nvalues * pdc_typesizes[dopt->type]), fn);
resopt[it].num = nvalues;
resopt[it].currind = it;
if (dopt->flags & PDC_OPT_PERCENT)
memset(resopt[it].pcbits, 0, PDC_PCBITS_SIZE);
if (logg5)
pdc_logg(pdc, "{");
/* analyze type */
resval = resopt[it].val;
for (iv = 0; iv < nvalues; iv++)
{
errcode = 0;
if (dopt->maxnum > 1 && nvalues)
value = values[iv];
else
value = items[is];
if (logg5)
pdc_logg(pdc, "%s{%T}", iv ? " " : "", value, 0);
switch (dopt->type)
{
/* boolean list */
case pdc_booleanlist:
if (boolval == pdc_true || !pdc_stricmp(value, "true"))
{
*(pdc_bool *) resval = pdc_true;
}
else if (boolval == pdc_false || !pdc_stricmp(value, "false"))
{
*(pdc_bool *) resval = pdc_false;
}
else
{
errcode = PDC_E_OPT_ILLBOOLEAN;
}
break;
/* string list */
case pdc_stringlist:
if (dopt->flags & PDC_OPT_NOSPACES)
{
if (pdc_split_stringlist(pdc, value, NULL, 0, &strings) > 1)
errcode = PDC_E_OPT_ILLSPACES;
pdc_cleanup_stringlist(pdc, strings);
}
if (!errcode)
{
len = strlen(value);
dz = (double) len;
if (dz < dopt->minval)
{
stemp3 = pdc_errprintf(pdc, "%d", (int) dopt->minval);
errcode = PDC_E_OPT_TOOSHORTSTR;
}
else if (dz > maxval)
{
stemp3 = pdc_errprintf(pdc, "%d", (int) maxval);
errcode = PDC_E_OPT_TOOLONGSTR;
}
if (dopt->flags & PDC_OPT_CONVUTF8)
{
int flags = PDC_CONV_EBCDIC | PDC_CONV_WITHBOM;
if (isutf8 || (resopt[it].flags & PDC_OPT_ISUTF8))
flags |= PDC_CONV_ISUTF8;
*((char **) resval) =
pdc_convert_name(pdc, value, 0, flags);
}
else
{
*((char **) resval) = pdc_strdup(pdc, value);
}
}
break;
/* keyword list */
case pdc_keywordlist:
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(value, dopt->keylist);
else
iz = pdc_get_keycode_ci(value, dopt->keylist);
if (iz == PDC_KEY_NOTFOUND)
{
errcode = PDC_E_OPT_ILLKEYWORD;
}
else
{
*(int *) resval = iz;
}
break;
/* character list */
case pdc_unicharlist:
iz = pdc_string2unicode(pdc, value, dopt->flags, dopt->keylist,
pdc_false);
if (iz < 0)
{
errcode = PDC_E_OPT_ILLCHAR;
break;
}
dz = iz;
if (dz < dopt->minval)
{
stemp3 = pdc_errprintf(pdc, "%g", dopt->minval);
errcode = PDC_E_OPT_TOOSMALLVAL;
}
else if (dz > maxval)
{
stemp3 = pdc_errprintf(pdc, "%g", maxval);
errcode = PDC_E_OPT_TOOBIGVAL;
}
*(int *) resval = iz;
break;
/* string list */
case pdc_polylinelist:
{
int np = pdc_split_stringlist(pdc, value, NULL, 0,
&strings);
pdc_polyline *pl = (pdc_polyline *) resval;
pl->np = np / 2;
pl->p = NULL;
/* number of coordinates must be even */
if (np % 2)
{
errcode = PDC_E_OPT_ODDNUM;
np = 0;
}
/* polyline must be a box */
else if ((dopt->flags & PDC_OPT_ISBOX) && np != 4)
{
errcode = PDC_E_OPT_ILLBOX;
np = 0;
}
/* polyline will be closed */
else if ((dopt->flags & PDC_OPT_CLOSEPOLY) && np <= 4)
{
errcode = PDC_E_OPT_ILLPOLYLINE;
np = 0;
}
/* polyline not empty */
if (np)
{
if (dopt->flags & PDC_OPT_CLOSEPOLY)
pl->np += 1;
pl->p = (pdc_vector *) pdc_malloc(pdc,
pl->np * sizeof(pdc_vector), fn);
iz = PDC_KEY_NOTFOUND;
j = 0;
icoord = ncoords;
for (i = 0; i < np; i++)
{
char *sk = strings[i];
if (dopt->keylist)
{
/* optional keyword list */
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(sk, dopt->keylist);
else
iz = pdc_get_keycode_ci(sk, dopt->keylist);
}
if (iz == PDC_KEY_NOTFOUND)
{
/* percentage */
if (dopt->flags & PDC_OPT_PERCENT)
{
k = (int) strlen(sk) - 1;
if (sk[k] == '%')
{
sk[k] = 0;
if (ncoords < PDC_MAX_PERCENTS)
{
pdc_setbit(resopt[it].pcbits,
ncoords);
}
else
{
errcode = PDC_E_OPT_TOOMANYPERCVALS;
}
}
}
retval = pdc_str2double(sk, &dz);
if (!retval)
{
errcode = PDC_E_OPT_ILLNUMBER;
}
else if (pdc_getbit(resopt[it].pcbits, ncoords))
{
if (dopt->flags & PDC_OPT_PERCRANGE)
{
if (dz < 0)
errcode = PDC_E_OPT_TOOSMALLPERCVAL;
if (dz > 100)
errcode = PDC_E_OPT_TOOBIGPERCVAL;
}
dz /= 100.0;
}
}
else
{
dz = (double) iz;
}
if (!(i % 2))
{
pl->p[j].x = dz;
}
else
{
pl->p[j].y = dz;
j++;
}
ncoords++;
}
if (dopt->flags & PDC_OPT_CLOSEPOLY)
{
pl->p[pl->np - 1] = pl->p[0];
if (pdc_getbit(resopt[it].pcbits, icoord))
pdc_setbit(resopt[it].pcbits, ncoords);
ncoords++;
if (pdc_getbit(resopt[it].pcbits, icoord + 1))
pdc_setbit(resopt[it].pcbits, ncoords);
ncoords++;
}
}
pdc_cleanup_stringlist(pdc, strings);
}
break;
/* number list */
case pdc_3ddatahandle:
case pdc_3dviewhandle:
case pdc_actionhandle:
case pdc_bookmarkhandle:
case pdc_colorhandle:
case pdc_documenthandle:
case pdc_fonthandle:
case pdc_gstatehandle:
case pdc_iccprofilehandle:
case pdc_imagehandle:
case pdc_layerhandle:
case pdc_pagehandle:
case pdc_patternhandle:
case pdc_shadinghandle:
case pdc_tablehandle:
case pdc_templatehandle:
case pdc_textflowhandle:
case pdc_integerlist:
case pdc_floatlist:
case pdc_doublelist:
case pdc_scalarlist:
if (dopt->keylist &&
(!(dopt->flags & PDC_OPT_KEYLIST1) || !iv))
{
/* optional keyword and/or allowed integer list */
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(value, dopt->keylist);
else
iz = pdc_get_keycode_ci(value, dopt->keylist);
if (iz == PDC_KEY_NOTFOUND)
{
if (dopt->flags & PDC_OPT_INTLIST)
{
errcode = PDC_E_OPT_ILLINTEGER;
break;
}
}
else
{
switch (dopt->type)
{
default:
case pdc_integerlist:
*(int *) resval = iz;
break;
case pdc_floatlist:
*(float *) resval = (float) iz;
break;
case pdc_doublelist:
*(double *) resval = (double) iz;
break;
case pdc_scalarlist:
*(pdc_scalar *) resval = (pdc_scalar) iz;
break;
}
break;
}
}
/* percentage */
if (dopt->flags & PDC_OPT_PERCENT)
{
i = (int) strlen(value) - 1;
if (value[i] == '%')
{
value[i] = 0;
if (iv < PDC_MAX_PERCENTS)
{
pdc_setbit(resopt[it].pcbits, iv);
}
else
{
errcode = PDC_E_OPT_TOOMANYPERCVALS;
}
}
}
case pdc_stringhandle:
if (dopt->type == pdc_floatlist ||
dopt->type == pdc_doublelist ||
dopt->type == pdc_scalarlist)
{
retval = pdc_str2double(value, &dz);
}
else
{
if (dopt->minval >= 0)
{
retval = pdc_str2integer(value, PDC_INT_UNSIGNED, &ulz);
dz = ulz;
}
else
{
retval = pdc_str2integer(value, 0, &lz);
dz = lz;
}
if (retval && ishandle && pdc->hastobepos &&
dopt->type != pdc_bookmarkhandle &&
dopt->type != pdc_stringhandle)
{
dz -= 1;
lz = (pdc_sint32) dz;
ulz = (pdc_uint32) dz;
}
}
if (!retval)
{
errcode = PDC_E_OPT_ILLNUMBER;
}
else
{
if (pdc_getbit(resopt[it].pcbits, iv))
{
if (dopt->flags & PDC_OPT_PERCRANGE)
{
if (dz < 0)
errcode = PDC_E_OPT_TOOSMALLPERCVAL;
if (dz > 100)
errcode = PDC_E_OPT_TOOBIGPERCVAL;
}
dz /= 100.0;
}
if (errcode == 0)
{
if (dz < dopt->minval)
{
if (ishandle)
{
stemp3 = pdc_get_keyword(dopt->type,
pdc_handletypes);
errcode = PDC_E_OPT_ILLHANDLE;
}
else
{
stemp3 = pdc_errprintf(pdc, "%g", dopt->minval);
errcode = PDC_E_OPT_TOOSMALLVAL;
}
}
else if (dz > maxval)
{
if (ishandle)
{
stemp3 = pdc_get_keyword(dopt->type,
pdc_handletypes);
errcode = PDC_E_OPT_ILLHANDLE;
}
else
{
stemp3 = pdc_errprintf(pdc, "%g", maxval);
errcode = PDC_E_OPT_TOOBIGVAL;
}
}
else if (dopt->flags & PDC_OPT_NOZERO &&
fabs(dz) < PDC_FLOAT_PREC)
{
errcode = PDC_E_OPT_ZEROVAL;
}
else if (dopt->type == pdc_scalarlist)
{
*(pdc_scalar *) resval = dz;
}
else if (dopt->type == pdc_doublelist)
{
*(double *) resval = dz;
}
else if (dopt->type == pdc_floatlist)
{
*(float *) resval = (float) dz;
}
else
{
if (dopt->minval >= 0)
*(pdc_uint32 *) resval = ulz;
else
*(pdc_sint32 *) resval = lz;
}
}
}
break;
}
if (errcode)
{
stemp2 = pdc_errprintf(pdc, "%.*s", PDC_ERR_MAXSTRLEN, value);
goto PDC_OPT_SYNTAXERROR;
}
/* increment value pointer */
resval = (void *) ((char *)(resval) + pdc_typesizes[dopt->type]);
}
pdc_cleanup_stringlist(pdc, values);
values = NULL;
if (logg5)
pdc_logg(pdc, "}\n");
/* build OR bit pattern */
if (dopt->flags & PDC_OPT_BUILDOR && nvalues > 1)
{
int *bcode = (int *) resopt[it].val;
for (iv = 1; iv < nvalues; iv++)
{
bcode[0] |= bcode[iv];
}
resopt[it].num = 1;
}
}
pdc_cleanup_stringlist(pdc, items);
items = NULL;
/* required and to be ignored options */
for (is = 0; tocheck && is < numdef; is++)
{
/* to be ignored option */
if (resopt[is].num)
{
nd = 0;
if (defopt[is].flags & PDC_OPT_IGNOREIF1) nd = 1;
if (defopt[is].flags & PDC_OPT_IGNOREIF2) nd = 2;
for (it = is - 1; it >= is - nd && it >= 0; it--)
{
if (resopt[it].num)
{
pdc_delete_optvalue(pdc, &resopt[is]);
if (verbose)
pdc_warning(pdc, PDC_E_OPT_IGNORE, defopt[is].name,
defopt[it].name, 0, 0);
}
}
}
/* required option */
if (!resopt[is].num &&
((defopt[is].flags & PDC_OPT_REQUIRED) ||
(defopt[is].flags & PDC_OPT_REQUIRIF1 && resopt[is-1].num) ||
(defopt[is].flags & PDC_OPT_REQUIRIF2 &&
(resopt[is-1].num || resopt[is-2].num))))
{
keyword = (char *) defopt[is].name;
errcode = PDC_E_OPT_NOTFOUND;
goto PDC_OPT_SYNTAXERROR;
}
}
/* is no sorted */
if (!issorted)
{
qsort((void *)resopt, (size_t) numdef, sizeof(pdc_resopt),
pdc_optname_compare);
}
/* global UTF-8 check after sort */
if (isutf8)
resopt[0].isutf8 = pdc_true;
/* index of last got option */
resopt[0].lastind = -1;
/* protocol */
if (pdc_logg_is_enabled(pdc, 1, trc_optlist))
{
for (is = 0; is < numdef; is++)
{
if (resopt[is].num)
pdc_logg(pdc, "\tOption \"%s\": %d value%s found\n",
resopt[is].defopt->name, resopt[is].num,
resopt[is].num == 1 ? "" : "s");
else if (logg5)
pdc_logg(pdc, "\t\t\toption \"%s\" not specified\n",
resopt[is].defopt->name);
for (iv = 0; iv < resopt[is].num; iv++)
{
switch (resopt[is].defopt->type)
{
case pdc_booleanlist:
case pdc_keywordlist:
case pdc_integerlist:
case pdc_3ddatahandle:
case pdc_3dviewhandle:
case pdc_actionhandle:
case pdc_bookmarkhandle:
case pdc_colorhandle:
case pdc_documenthandle:
case pdc_fonthandle:
case pdc_gstatehandle:
case pdc_iccprofilehandle:
case pdc_imagehandle:
case pdc_layerhandle:
case pdc_pagehandle:
case pdc_patternhandle:
case pdc_shadinghandle:
case pdc_tablehandle:
case pdc_templatehandle:
case pdc_textflowhandle:
case pdc_stringhandle:
pdc_logg(pdc, "\tValue %d: %d\n",
iv + 1, *((int *) resopt[is].val + iv));
break;
case pdc_stringlist:
pdc_logg(pdc, "\tValue %d: \"%T\"\n",
iv + 1, *((char **) resopt[is].val + iv), 0);
break;
case pdc_floatlist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((float *) resopt[is].val + iv));
break;
case pdc_doublelist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((double *) resopt[is].val + iv));
break;
case pdc_scalarlist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((pdc_scalar *) resopt[is].val + iv));
break;
case pdc_unicharlist:
pdc_logg(pdc, "\tValue %d: %d\n",
iv + 1, *((int *) resopt[is].val + iv));
break;
case pdc_polylinelist:
pdc_logg(pdc, "\t\t#%d: ", iv + 1);
{
pdc_polyline *pl = (pdc_polyline *) resopt[is].val + iv;
for (j = 0; j < pl->np; j++)
pdc_logg(pdc, "%f,%f ", pl->p[j].x, pl->p[j].y);
pdc_logg(pdc, "\n");
}
break;
}
}
}
}
return resopt;
PDC_OPT_SYNTAXERROR:
stemp1 = pdc_errprintf(pdc, "%.*s", PDC_ERR_MAXSTRLEN, keyword);
pdc_cleanup_stringlist(pdc, items);
pdc_cleanup_stringlist(pdc, values);
pdc_set_errmsg(pdc, errcode, stemp1, stemp2, stemp3, 0);
if (verbose)
pdc_error(pdc, -1, 0, 0, 0, 0);
return NULL;
}
/* returns font handle,
** or -1 if no font found,
** or -2 in case of an error.
*/
int
pdf_handle_cidfont(PDF *p, const char *fontname, const char *encoding)
{
pdc_font *font = &p->fonts[p->fonts_number];
int slot, cmap, metric;
/*
* Look whether font is already in the cache.
* If font with same name and encoding is found,
* return its descriptor.
*/
for (slot = 0; slot < p->fonts_number; slot++) {
if (p->fonts[slot].encoding == pdc_cid &&
p->fonts[slot].style == font->style &&
!strcmp(p->fonts[slot].name, fontname) &&
!strcmp(p->fonts[slot].cmapname, encoding))
return slot;
}
/* Check the requested CMap */
for (cmap = 0; cmap < NUMBER_OF_CMAPS; cmap++)
if (!strcmp(cmaps[cmap].name, encoding))
break;
/* Unknown CMap */
if (cmap == NUMBER_OF_CMAPS)
return -1;
/* Check whether this CMap is supported in the desired PDF version */
if (cmaps[cmap].compatibility > p->compatibility)
{
pdc_set_errmsg(p->pdc, PDF_E_DOC_PDFVERSION,
encoding, pdc_errprintf(p->pdc, "%d.%d",
p->compatibility/10, p->compatibility % 10), 0, 0);
if (font->verbose)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return -2;
}
/* Check whether the font name is among the known CID fonts */
for (metric = 0; metric < SIZEOF_CID_METRICS; metric++) {
if (!strcmp(pdf_cid_metrics[metric].name, fontname))
break;
}
/* Unknown font */
if (metric == SIZEOF_CID_METRICS)
{
pdc_set_errmsg(p->pdc, PDF_E_CJK_NOSTANDARD, fontname, 0, 0, 0);
if (font->verbose)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return -2;
}
/* Selected CMap and font don't match */
if (cmaps[cmap].charcoll != cc_identity &&
cmaps[cmap].charcoll != pdf_cid_metrics[metric].charcoll)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, fontname, encoding, 0, 0);
if (font->verbose)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return -2;
}
/* For Unicode capable language wrappers only UCS2 CMaps allowed */
if (cmaps[cmap].codesize == 0 && p->textformat == pdc_auto2)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_NEEDUCS2, encoding, fontname, 0, 0);
if (font->verbose)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return -2;
}
p->fonts_number++;
/* Code size of CMap */
font->codeSize = 0;
font->numOfCodes = 0;
/* Fill up the font struct */
pdc_fill_font_metric(p->pdc, font, &pdf_cid_metrics[metric]);
/* Now everything is fine; fill the remaining entries */
font->encoding = pdc_cid;
font->cmapname = pdc_strdup(p->pdc, encoding);
font->ttname = pdc_strdup(p->pdc, fontname);
font->apiname = pdc_strdup(p->pdc, fontname);
font->obj_id = pdc_alloc_id(p->out);
font->embedding = pdc_false;
font->kerning = pdc_false;
font->subsetting = pdc_false;
font->autocidfont = pdc_false;
font->unicodemap = pdc_false;
font->autosubsetting = pdc_false;
/* return valid font descriptor */
return slot;
}
pdc_file *
pdf_fopen(PDF *p, const char *filename, const char *qualifier, int flags)
{
const pdc_byte *data = NULL;
size_t size = 0;
pdf_virtfile *vfile;
vfile = pdf_find_pvf(p, filename, NULL);
if (vfile)
{
size = vfile->size;
data = (const pdc_byte *) vfile->data;
return pdc_fopen(p->pdc, filename, qualifier, data, size, flags);
}
else
{
pdf_category *cat;
/* Bad filename */
if (!*filename || !strcmp(filename, ".") || !strcmp(filename, ".."))
{
pdc_set_errmsg(p->pdc, PDC_E_IO_ILLFILENAME, filename, 0, 0, 0);
return NULL;
}
/* Read resource configuration file if it is pending */
if (p->resfilepending)
{
p->resfilepending = pdc_false;
pdf_read_resourcefile(p, p->resourcefilename);
}
#ifdef PDF_TEST_RESOURCE
printf("Search for file '%s'\n", filename);
#endif
/* Searching resource category */
for (cat = p->resources; cat != (pdf_category *) NULL; cat = cat->next)
if (!strcmp(cat->category, "SearchPath")) break;
if (!cat)
{
/* No resource category */
return pdc_fopen(p->pdc, filename, qualifier, NULL, 0, flags);
}
else
{
pdf_res *res = cat->kids;
pdf_res *lastres = cat->kids;
char *pathname = NULL;
char fullname[PDC_FILENAMELEN];
FILE *fp = NULL;
int errnum = PDC_E_IO_RDOPEN_NF;
/* Find last SearchPath entry */
while (res != (pdf_res *) NULL)
{
lastres = res;
res = res->next;
}
/* First local search and then search with concatenated
* filename with search paths one after another backwards
*/
while (1)
{
/* Test opening */
pdc_file_fullname(pathname, filename, fullname);
#ifdef PDF_TEST_RESOURCE
printf(" pathname '%s' -> fullname: '%s'\n", pathname, fullname);
#endif
fp = fopen(fullname, READBMODE);
if (fp)
{
/* File found */
fclose(fp);
return
pdc_fopen(p->pdc, fullname, qualifier, NULL, 0, flags);
}
errnum = pdc_get_fopen_errnum(p->pdc, PDC_E_IO_RDOPEN);
if (errno != 0 && errnum != PDC_E_IO_RDOPEN_NF) break;
if (lastres == (pdf_res *) NULL)
break;
pathname = lastres->name;
lastres = lastres->prev;
}
pdc_set_errmsg(p->pdc, errnum, qualifier, filename, 0, 0);
return NULL;
}
}
}
pdc_bool
pdf_t1open_fontfile(PDF *p, pdf_font *font, const char *filename,
PDF_data_source *t1src, pdc_bool requested)
{
static const char *fn = "pdf_t1open_fontfile";
t1_private_data *t1 = NULL;
pdc_file *fp = NULL;
const char *stemp = NULL;
pdc_byte magic[PFA_TESTBYTE];
char fullname[PDC_FILENAMELEN];
int fflags = PDC_FILE_BINARY;
pdc_bool ispfb = pdc_true;
if (filename)
{
pdc_bool retval = pdc_true;
pdc_bool fnamegiven = (strcmp(filename, FNT_MISSING_FILENAME) == 0) ?
pdc_false : pdc_true;
(void) retval;
if (fnamegiven)
{
fp = pdc_fsearch_fopen(p->pdc, filename, fullname,
"PostScript Type1 ", fflags);
if (fp == NULL)
{
if (t1src)
PDC_RETHROW(p->pdc);
return pdc_check_fopen_errmsg(p->pdc, requested);
}
pdc_logg_cond(p->pdc, 1, trc_font,
"\tLoading PostScript Type1 fontfile \"%s\":\n", fullname);
}
}
if (fp)
{
pdc_fread(magic, 1, PFA_TESTBYTE, fp);
stemp = filename;
}
else if (font->ft.img)
{
strncpy((char *) magic, (const char *)font->ft.img, PFA_TESTBYTE);
stemp = font->ft.name;
}
/* try to identify PFA files */
if (magic[0] != PFB_MARKER)
{
char startsequ[PFA_TESTBYTE + 1];
strcpy(startsequ, FNT_PFA_STARTSEQU);
if (strncmp((const char *) magic, startsequ, PFA_TESTBYTE))
{
if (fp)
pdc_fclose(fp);
pdc_set_errmsg(p->pdc, PDF_E_T1_NOFONT, stemp, 0, 0, 0);
if (t1src)
PDC_RETHROW(p->pdc);
return pdc_false;
}
ispfb = pdc_false;
}
pdc_logg_cond(p->pdc, 1, trc_font,
"\tPostScript Type1 font of format \"%s\" detected\n",
ispfb ? "PFB" : "PFA");
if (t1src)
{
t1src->private_data = (unsigned char *)
pdc_malloc(p->pdc, sizeof(t1_private_data), fn);
t1 = (t1_private_data *) t1src->private_data;
if (filename)
{
pdc_fclose(fp);
if (ispfb)
{
t1->fontfile =
pdc_fsearch_fopen(p->pdc, fullname, NULL, "PFB ", fflags);
}
else
{
t1->fontfile =
pdc_fsearch_fopen(p->pdc, fullname, NULL, "PFA ",
PDC_FILE_TEXT);
}
if (t1->fontfile == NULL)
PDC_RETHROW(p->pdc);
}
else if (font->ft.img)
{
/* only for virtual PFB files */
t1->fontfile = NULL;
t1->img = font->ft.img;
t1->pos = font->ft.img;
t1->end = font->ft.img + font->ft.filelen;
}
t1src->init = t1data_init;
t1src->fill = ispfb ? PFB_data_fill : PFA_data_fill;
t1src->terminate = t1data_terminate;
}
else if (fp != NULL)
{
if (pdc_file_isvirtual(fp) == pdc_true)
{
if (ispfb)
font->ft.img =
(pdc_byte *) pdc_freadall(fp, &font->ft.filelen, NULL);
font->ft.imgname = pdc_strdup(p->pdc, fullname);
pdc_lock_pvf(p->pdc, font->ft.imgname);
}
font->ft.filename = pdc_strdup(p->pdc, fullname);
pdc_fclose(fp);
}
return pdc_true;
}
/*
* Returns the Unicode value for a given string Unicode expression:
*
* - Byte 1...255 -> U0001...U00FF
* - U+XXXXX
* - 0xXXXXX
* - HTML character reference without frame syntax &...;
*
* If no conversion is possible -1 will be returned.
*/
int
pdc_string2unicode(pdc_core *pdc, const char *text, int i_flags,
const pdc_keyconn *keyconn, pdc_bool verbose)
{
int iz = PDC_KEY_NOTFOUND, usv = -1;
pdc_bool seterr = pdc_false;
int flags = PDC_INT_UNSIGNED;
int i = 0;
(void) verbose;
/* single byte as Unicode value */
if (strlen(text) == 1)
{
char c = text[0];
usv = (pdc_byte) c;
}
else
{
/* keyword */
if (keyconn)
{
if (i_flags & PDC_INT_CASESENS)
iz = pdc_get_keycode(text, keyconn);
else
iz = pdc_get_keycode_ci(text, keyconn);
}
if (iz != PDC_KEY_NOTFOUND)
{
usv = iz;
}
else
{
/* Unicode value */
if (!pdc_strincmp(text, "U+", 2))
{
flags |= PDC_INT_HEXADEC;
i = 2;
}
if (!pdc_str2integer(&text[i], flags, &iz))
{
seterr = pdc_true;
}
else if (iz >= PDC_NUM_UNIVAL ||
(iz >= PDC_UNICODE_MINHIGHSUR &&
iz <= PDC_UNICODE_MAXLOWSUR))
{
seterr = pdc_true;
}
else
{
usv = iz;
}
}
}
if (seterr)
{
pdc_set_errmsg(pdc, PDC_E_CONV_ILLUTF32, &text[i], 0, 0, 0);
if (verbose)
pdc_error(pdc, -1, 0, 0, 0, 0);
}
return usv;
}
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;
}
pdc_file *
pdc_fopen(pdc_core *pdc, const char *filename, const char *qualifier,
const pdc_byte *data, size_t size, int flags)
{
static const char fn[] = "pdc_fopen";
pdc_file *sfp;
/* reset error number */
pdc_set_errmsg(pdc, 0, 0, 0, 0, 0);
sfp = (pdc_file *) pdc_calloc(pdc, sizeof(pdc_file), fn);
/* initialize */
sfp->pdc = pdc;
sfp->filename = pdc_strdup_ext(pdc, filename, 0, fn);
if (flags & PDC_FILE_WRITEMODE || flags & PDC_FILE_APPENDMODE)
sfp->wrmode = pdc_true;
if (data != NULL || size > 0)
{
/* virtual file */
if (sfp->wrmode)
{
sfp->data = (pdc_byte *) pdc_calloc(pdc, size, fn);
if (data != NULL)
{
/* append mode */
memcpy(sfp->data, data, size);
sfp->pos = sfp->data + size;
}
else
{
sfp->pos = sfp->data;
}
sfp->end = sfp->pos;
sfp->limit = sfp->data + size;
}
else
{
sfp->data = (pdc_byte *) data;
sfp->pos = sfp->data;
sfp->end = sfp->data + size;
}
}
else
{
const char *mode;
/* disk file */
if (flags & PDC_FILE_BINARY)
mode = READBMODE;
else
mode = READTMODE;
if (flags & PDC_FILE_APPENDMODE)
mode = APPENDMODE;
else if (flags & PDC_FILE_WRITEMODE)
mode = WRITEMODE;
sfp->fp = pdc_fopen_logg(pdc, filename, mode);
if (sfp->fp == NULL)
{
pdc_fclose(sfp);
if (qualifier == NULL)
qualifier = "";
pdc_set_fopen_errmsg(pdc, PDC_E_IO_RDOPEN, qualifier, filename);
return NULL;
}
}
return sfp;
}
pdc_bool
pdf_check_pfm_encoding(PDF *p, pdc_font *font, const char *fontname,
pdc_encoding enc)
{
const char *encname;
pdc_encoding enc_old = enc;
int islatin1 = 0;
/* Font encoding */
switch (font->encoding)
{
case PFM_ANSI_CHARSET:
font->encoding = pdc_winansi;
font->isstdlatin = pdc_true;
break;
case PFM_SYMBOL_CHARSET:
font->encoding = pdc_builtin;
font->isstdlatin = pdc_false;
break;
default:
pdc_set_errmsg(p->pdc, PDF_E_T1_BADCHARSET,
pdc_errprintf(p->pdc, "%d", font->encoding), fontname, 0, 0);
if (font->verbose == pdc_true)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
/* iso8859-1 */
if (enc > 0)
{
islatin1 = !strcmp(pdf_get_encoding_name(p, enc), "iso8859-1");
if (font->encoding == pdc_winansi)
font->encoding = enc;
}
/* Unicode encoding */
if (enc == pdc_unicode)
{
enc = pdf_find_encoding(p, "iso8859-1");
font->encoding = enc;
islatin1 = 1;
}
/* Unallowed encoding */
encname = pdc_errprintf(p->pdc, "%s", pdf_get_encoding_name(p, enc_old));
if (enc < pdc_builtin)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, fontname, encname, 0, 0);
if (font->verbose == pdc_true)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
if (font->verbose == pdc_true)
{
if (enc != pdc_winansi && !islatin1 &&
font->encoding != pdc_builtin)
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, pdc_winansi), encname, fontname, 0);
}
if (enc != pdc_builtin && font->encoding == pdc_builtin)
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, pdc_builtin), encname, fontname, 0);
}
}
return pdc_true;
}
/*
** Returns CMap slot and for standard CJK fonts: fontandle.
**
** pdc_invalidenc: predefined CMap not found
** pdc_cid or pdc_unicode: predefined CMap found
**
** *o_slot:
** >= 0: standard font found
** < 0: |error code|
*/
pdc_bool
pdf_handle_cidfont(PDF *p, const char *fontname, const char *encoding,
pdc_encoding enc, pdf_font *font, int *o_slot,
pdc_encoding *newenc)
{
const char *encapiname = encoding;
fnt_cmap_info cmapinfo;
const fnt_font_metric *fontmetric;
pdc_bool isidentity = pdc_false;
pdc_bool isstdfont = pdc_false;
pdc_bool iscjkcp = pdc_false;
int charcoll, slot;
(void) enc;
(void) iscjkcp;
(void) encapiname;
*o_slot = -1;
*newenc = pdc_invalidenc;
/*
* Look whether font is already in the cache.
* If font with same name and encoding is found,
* returns its slot number.
*/
for (slot = 0; slot < p->fonts_number; slot++)
{
if (p->fonts[slot].ft.enc == pdc_cid &&
p->fonts[slot].opt.fontstyle == font->opt.fontstyle &&
p->fonts[slot].opt.embedding == font->opt.embedding &&
!strcmp(p->fonts[slot].apiname, fontname) &&
!strcmp(p->fonts[slot].ft.cmapname, encoding))
{
*o_slot = slot;
*newenc = pdc_cid;
return pdc_true;
}
}
/* Check the requested CMap */
charcoll = fnt_get_predefined_cmap_info(encoding, &cmapinfo);
if (charcoll == (int) cc_none)
return pdc_true;
pdc_logg_cond(p->pdc, 1, trc_font,
"\tPredefined CMap \"%s\" found\n", encoding);
/* Check whether this CMap is supported in the desired PDF version */
if (cmapinfo.compatibility > p->compatibility)
{
pdc_set_errmsg(p->pdc, PDF_E_DOC_PDFVERSION,
encoding, pdc_get_pdfversion(p->pdc, p->compatibility), 0, 0);
return pdc_false;
}
/* For Unicode capable language wrappers only UCS2/UTF16 CMaps allowed */
if (cmapinfo.codesize == 0 && p->pdc->unicaplang)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_NEEDUCS2, 0, 0, 0, 0);
return pdc_false;
}
/* Check whether the font name is among the known Acrobat CJK fonts */
charcoll = fnt_get_preinstalled_cidfont(fontname, &fontmetric);
isidentity = cmapinfo.charcoll == (int) cc_identity;
if (isidentity)
cmapinfo.charcoll = abs(charcoll);
/* known Acrobat CID font */
if (charcoll != (int) cc_none)
{
pdc_logg_cond(p->pdc, 1, trc_font,
"\tStandard CJK font \"%s\" found\n", fontname);
/* Selected CMap and known standard font don't match */
if ((cmapinfo.charcoll != abs(charcoll) ||
(charcoll == (int) cc_japanese && cmapinfo.codesize == -2)))
{
pdc_set_errmsg(p->pdc, PDF_E_CJK_UNSUPP_CHARCOLL,
0, 0, 0, 0);
return pdc_false;
}
isstdfont = pdc_true;
/* Embedding not possible */
if (font->opt.embedding)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_EMBEDCMAP, 0, 0, 0, 0);
return pdc_false;
}
}
#ifdef WIN32
else if (iscjkcp && !p->pdc->ptfrun)
{
return pdc_true;
}
#endif
/* embedding check */
if (!pdf_check_font_embedding(p, font, fontname))
return pdc_false;
/* supplement number, number of codes = (maximal) number of CIDs */
font->supplement = fnt_get_supplement(&cmapinfo, p->compatibility);
if (isidentity)
font->supplement = -1;
font->ft.numcodes = fnt_get_maxcid(cmapinfo.charcoll, font->supplement) + 1;
{
font->passthrough = pdc_true;
font->codesize = 0;
}
/* CMap and default settings */
font->ft.vertical = cmapinfo.vertical;
font->ft.cmapname = pdc_strdup(p->pdc, encoding);
if (font->outcmapname == NULL)
font->outcmapname = pdc_strdup(p->pdc, encoding);
font->ft.enc = pdc_cid;
font->iscidfont = pdc_true;
/* Fill up the font struct */
fnt_fill_font_metric(p->pdc, &font->ft, pdc_false, fontmetric);
/* CID widths not available */
font->widthsmissing = pdc_true;
pdc_logg_cond(p->pdc, 1, trc_font,
"\n\t%s CJK font: \"%s\"\n\tPredefined CMap: \"%s\"\n"
"\tOrdering: \"%s\"\n\tSupplement: %d\n",
font->ft.isstdfont ? "Adobe Standard" : "Custom", fontname, encoding,
fnt_get_ordering_cid(font->ft.m.charcoll), font->supplement);
*newenc = pdc_cid;
return pdc_true;
}
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;
}
static pdc_bool
pdf_parse_afm(
PDF *p,
pdc_file *fp,
pdf_font *font,
const char *fontname,
const char *filename)
{
static const char fn[] = "pdf_parse_afm";
fnt_font_metric *ftm = &font->ft.m;
const char *afmtype = NULL;
char **wordlist = NULL, *keyword, *arg1;
char line[AFM_LINEBUF];
int i, cmp, lo, hi, nwords, nglyphs = 0, nline = 0;
int tablen = ((sizeof keyStrings) / (sizeof (char *)));
pdc_sint32 iz;
double dz;
pdc_scalar charwidth = -1;
pdf_afmkey keynumber;
fnt_glyphwidth *glw;
pdc_bool toskip = pdc_false;
pdc_bool is_zadbfont = !strcmp(fontname, "ZapfDingbats");
/* all new glyph names of AGL 2.0 are missing */
font->missingglyphs = 0xFFFFFFFF;
/* read loop. because of Mac files we use pdc_fgetline */
while (pdc_fgetline(line, AFM_LINEBUF, fp) != NULL)
{
/* split line */
nline++;
nwords = pdc_split_stringlist(p->pdc, line, AFM_SEPARATORS, 0,
&wordlist);
if (!nwords) continue;
keyword = wordlist[0];
/* find keynumber */
lo = 0;
hi = tablen;
keynumber = NOPE;
while (lo < hi)
{
i = (lo + hi) / 2;
cmp = strcmp(keyword, keyStrings[i]);
if (cmp == 0)
{
keynumber = (pdf_afmkey) i;
break;
}
if (cmp < 0)
hi = i;
else
lo = i + 1;
}
/* unkown key */
if (keynumber == NOPE)
{
pdc_warning(p->pdc, PDF_E_T1_AFMBADKEY, keyword, filename, 0,0);
goto PDF_PARSECONTD;
}
if (keynumber == ENDDIRECTION)
toskip = pdc_false;
if (nwords == 1 || toskip == pdc_true)
goto PDF_PARSECONTD;
/* key switch */
arg1 = wordlist[1];
switch (keynumber)
{
case STARTDIRECTION:
if (pdc_str2integer(arg1, 0, &iz) != pdc_true)
goto PDF_SYNTAXERROR;
if (iz)
toskip = pdc_true;
break;
case STARTCOMPFONTMETRICS:
afmtype = "ACFM";
goto PDF_SYNTAXERROR;
case STARTMASTERFONTMETRICS:
afmtype = "AMFM";
goto PDF_SYNTAXERROR;
case ISCIDFONT:
afmtype = "CID font";
if (!strcmp(arg1, "true"))
goto PDF_SYNTAXERROR;
break;
case FONTNAME:
font->ft.name = pdc_strdup(p->pdc, arg1);
ftm->name = pdc_strdup(p->pdc, arg1);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tPostScript font name: \"%s\"\n", ftm->name);
break;
/* Recognize Multiple Master fonts by last part of name */
case FAMILYNAME:
if (!strcmp(wordlist[nwords-1], "MM"))
ftm->type = fnt_MMType1;
else
ftm->type = fnt_Type1;
break;
/* Default: FontSpecific */
case ENCODINGSCHEME:
if (!pdc_stricmp(arg1, "StandardEncoding") ||
!pdc_stricmp(arg1, "AdobeStandardEncoding"))
font->ft.issymbfont = pdc_false;
break;
case STDHW:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->StdHW = (int) dz;
break;
case STDVW:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->StdVW = (int) dz;
break;
case WEIGHT:
font->ft.weight = fnt_check_weight(fnt_weightname2weight(arg1));
break;
case ISFIXEDPITCH:
if (!pdc_stricmp(arg1, "false"))
ftm->isFixedPitch = pdc_false;
else
ftm->isFixedPitch = pdc_true;
break;
/* New AFM 4.1 keyword "CharWidth" implies fixed pitch */
case CHARWIDTH:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
charwidth = dz;
ftm->isFixedPitch = pdc_true;
break;
case ITALICANGLE:
{
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->italicAngle = dz;
}
break;
case UNDERLINEPOSITION:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->underlinePosition = (int) dz;
break;
case UNDERLINETHICKNESS:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->underlineThickness = (int) dz;
break;
case FONTBBOX:
{
if (nwords != 5)
goto PDF_SYNTAXERROR;
for (i = 1; i < nwords; i++)
{
if (pdc_str2double(wordlist[i], &dz) != pdc_true)
goto PDF_SYNTAXERROR;
if (i == 1)
ftm->llx = dz;
else if (i == 2)
ftm->lly = dz;
else if (i == 3)
ftm->urx = dz;
else if (i == 4)
ftm->ury = dz;
}
}
break;
case CAPHEIGHT:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->capHeight = (int) dz;
break;
case XHEIGHT:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->xHeight = (int) dz;
break;
case DESCENDER:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->descender = (int) dz;
break;
case ASCENDER:
if (pdc_str2double(arg1, &dz) != pdc_true)
goto PDF_SYNTAXERROR;
ftm->ascender = (int) dz;
break;
/* Character widths */
case STARTCHARMETRICS:
if (pdc_str2integer(arg1, PDC_INT_UNSIGNED, (pdc_sint32 *) &nglyphs)
!= pdc_true || nglyphs <= 0)
goto PDF_SYNTAXERROR;
ftm->glw = (fnt_glyphwidth *) pdc_calloc(p->pdc,
(size_t) nglyphs * sizeof(fnt_glyphwidth), fn);
break;
/* Character code */
case CODE:
case CODEHEX:
if (!nglyphs || !ftm->glw)
goto PDF_SYNTAXERROR;
if (font->ft.numglyphs >= nglyphs)
{
nglyphs++;
ftm->glw = (fnt_glyphwidth *) pdc_realloc(p->pdc, ftm->glw,
(size_t) nglyphs * sizeof(fnt_glyphwidth), fn);
}
glw = &ftm->glw[font->ft.numglyphs];
if (keynumber == CODE)
{
if (pdc_str2integer(arg1, 0, &iz) != pdc_true)
goto PDF_SYNTAXERROR;
}
else
{
if (pdc_str2integer(arg1, PDC_INT_HEXADEC, &iz) != pdc_true)
goto PDF_SYNTAXERROR;
}
glw->code = (pdc_short) iz;
glw->unicode = 0;
glw->width = (pdc_ushort)
(font->opt.monospace ? font->opt.monospace : charwidth);
font->ft.numglyphs++;
/* Character width and name */
for (i = 2; i < nwords; i++)
{
if (!strcmp(wordlist[i], "WX") ||
!strcmp(wordlist[i], "W0X") ||
!strcmp(wordlist[i], "W"))
{
i++;
if (i == nwords)
goto PDF_SYNTAXERROR;
if (pdc_str2double(wordlist[i], &dz) != pdc_true)
goto PDF_SYNTAXERROR;
glw->width = (pdc_ushort)
(font->opt.monospace ? font->opt.monospace : dz);
}
if (!strcmp(wordlist[i], "N"))
{
i++;
if (i == nwords)
goto PDF_SYNTAXERROR;
/* Unicode value by means of AGL,
* internal and private table
*/
glw->unicode = is_zadbfont ?
(pdc_ushort) pdc_zadb2unicode(wordlist[i]):
pdc_insert_glyphname(p->pdc, wordlist[i]);
pdc_delete_missingglyph_bit(glw->unicode,
&font->missingglyphs);
}
}
break;
default:
break;
}
PDF_PARSECONTD:
pdc_cleanup_stringlist(p->pdc, wordlist);
wordlist = NULL;
if (keynumber == ENDFONTMETRICS)
break;
}
/* necessary font struct members */
if (font->ft.name == NULL || ftm->glw == NULL)
goto PDF_SYNTAXERROR;
pdc_fclose(fp);
ftm->numglwidths = font->ft.numglyphs;
return pdc_true;
PDF_SYNTAXERROR:
pdc_fclose(fp);
pdc_cleanup_stringlist(p->pdc, wordlist);
if (afmtype)
pdc_set_errmsg(p->pdc, PDF_E_T1_UNSUPP_FORMAT, afmtype, 0, 0, 0);
else
pdc_set_errmsg(p->pdc, PDC_E_IO_ILLSYNTAX, "AFM ", filename,
pdc_errprintf(p->pdc, "%d", nline), 0);
return pdc_false;
}
