void
pdf__end_glyph(PDF *p)
{
pdf_t3font *t3font = p->fonts[p->t3slot].t3font;
pdf_t3glyph *glyph = &t3font->glyphs[t3font->curr_glyph];
int ig = t3font->curr_glyph;
if (t3font->pass != 1 && glyph->charproc_id != PDC_BAD_ID)
{
/* check whether pdf__save() and pdf__restore() calls are balanced */
if (p->curr_ppt->sl > 0)
pdc_error(p->pdc, PDF_E_GSTATE_UNMATCHEDSAVE, 0, 0, 0, 0);
pdf_end_text(p);
pdc_end_pdfstream(p->out); /* glyph description stream */
pdc_end_obj(p->out); /* glyph description */
pdc_put_pdfstreamlength(p->out, p->length_id);
}
PDF_SET_STATE(p, pdf_state_font);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tEnd of Type3 font glyph \"%s\"\n",
t3font->glyphs[ig].name);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[End glyph %d]\n", ig);
}
void
pdc_set_warnmsg(
pdc_core * pdc,
int errnum,
const char *parm1,
const char *parm2,
const char *parm3,
const char *parm4)
{
char errbuf[PDC_ERRBUF_SIZE];
strcpy(errbuf, pdc->pr->errbuf);
if (errnum != -1)
{
const pdc_error_info *ei = get_error_info(pdc, errnum);
make_errmsg(pdc, ei, parm1, parm2, parm3, parm4, pdc_false);
}
pdc_logg_cond(pdc, 1, trc_warning,
"\n[Warning message %d: \"%s\"]\n",
errnum, pdc->pr->errbuf);
strcpy(pdc->pr->errbuf, errbuf);
} /* pdc_set_warnmsg */
void *
pdc_realloc(pdc_core *pdc, void *mem, size_t size, const char *caller)
{
void *ret;
pdc_bool logg1 = pdc_logg_is_enabled(pdc, 1, trc_memory);
if (logg1)
pdc_logg(pdc, "\ttry to realloc %p to %ld bytes\n", mem, size);
if (size == (size_t) 0 || (long) size < 0L)
{
size = (size_t) 1;
pdc_error(pdc, PDC_E_INT_ALLOC0, caller, 0, 0, 0);
}
ret = (mem == (void *) 0) ?
(*pdc->pr->allocproc)(pdc->pr->opaque, size, caller) :
(*pdc->pr->reallocproc)(pdc->pr->opaque, mem, size, caller);
if (ret == (void *) 0)
pdc_error(pdc, PDC_E_MEM_OUT, caller, 0, 0, 0);
pdc_logg_cond(pdc, 1, trc_memory,
"\t%p realloced to\n"
"\t%p new, size=%ld, called from \"%s\"\n",
mem, ret, size, caller);
return ret;
}
void
pdc_free_tmp(pdc_core *pdc, void *mem)
{
pdc_tmpmem_list *tm_list = &pdc->pr->tm_list;
int i, j;
pdc_logg_cond(pdc, 2, trc_memory,
"\tTemporary memory %p to be freed\n", mem);
/* we search the list backwards since chances are good
** that the most recently allocated items are freed first.
*/
for (i = tm_list->size - 1; 0 <= i; --i)
{
if (tm_list->tmpmem[i].mem == mem)
{
if (tm_list->tmpmem[i].destr)
tm_list->tmpmem[i].destr(
tm_list->tmpmem[i].opaque, tm_list->tmpmem[i].mem);
pdc_free(pdc, tm_list->tmpmem[i].mem);
tm_list->tmpmem[i].mem = (void *) 0;
--tm_list->size;
for (j = i; j < tm_list->size; j++)
tm_list->tmpmem[j] = tm_list->tmpmem[j + 1];
return;
}
}
pdc_error(pdc, PDC_E_INT_FREE_TMP, 0, 0, 0, 0);
}
void
pdf_check_textformat(PDF *p, pdc_text_format textformat)
{
if (!p->pdc->ptfrun && p->pdc->unicaplang && textformat != pdc_auto2)
pdc_error(p->pdc, PDF_E_ENC_UNSUPPENCFORMAT, "textformat", 0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_encoding, "\tTextformat: \"%s\"\n",
pdc_get_keyword(textformat, pdf_textformat_keylist));
}
void
pdc_free(pdc_core *pdc, void *mem)
{
pdc_logg_cond(pdc, 1, trc_memory, "\t%p freed\n", mem);
/* just in case the freeproc() isn't that ANSI compatible...
*/
if (mem != NULL)
(*pdc->pr->freeproc)(pdc->pr->opaque, mem);
}
static int
pdf_get_index(PDF *p, const char *key, pdc_bool setpar)
{
int i;
if (key == NULL || !*key)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "key", 0, 0, 0);
for (i = 0; i < PDF_PARAMETER_LIMIT; ++i)
{
if (pdc_stricmp(key, parms[i].name) == 0)
{
if ((setpar || parms[i].check_scope) &&
(p->state_stack[p->state_sp] & parms[i].scope) == 0 &&
(p->state_stack[p->state_sp] & pdf_state_glyphignore) == 0)
{
pdc_error(p->pdc,
setpar ? PDF_E_DOC_SCOPE_SET : PDF_E_DOC_SCOPE_GET,
key, pdf_current_scope(p), 0, 0);
}
if (parms[i].deprecated > 0)
{
pdc_logg_cond(p->pdc, 2, trc_api,
"[Parameter \"%s\" is deprecated since PDFlib %d]\n",
key, parms[i].deprecated);
}
else if (parms[i].deprecated < 0)
{
pdc_logg_cond(p->pdc, 2, trc_api,
"[Parameter \"%s\" is unsupported]\n", key);
}
return i;
}
}
if (i == PDF_PARAMETER_LIMIT)
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
return -1;
}
void
pdf_check_hypertextencoding(PDF *p, pdc_encoding hypertextencoding)
{
if (!p->pdc->ptfrun && p->pdc->unicaplang &&
hypertextencoding != pdc_unicode)
pdc_error(p->pdc, PDF_E_ENC_UNSUPPENCFORMAT, "hypertextencoding",
0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_encoding, "\tHypertextencoding: \"%s\"\n",
pdc_get_user_encoding(p->pdc, hypertextencoding));
}
const void *
pdc_freadall(pdc_file *sfp, size_t *filelen, pdc_bool *ismem)
{
const void *result = NULL;
*filelen = 0;
pdc_logg_cond(sfp->pdc, 1, trc_filesearch,
"\tAttempting to read whole file \"%s\"\n", sfp->filename);
if (sfp->fp)
{
pdc_off_t flen; /* TODO2GB: >2GB on 32-bit platforms? */
result = pdc_read_file(sfp->pdc, sfp->fp, &flen, 1);
if (ismem)
*ismem = pdc_false;
*filelen = (size_t) flen;
}
else
{
result = sfp->data;
if (ismem)
*ismem = pdc_true;
*filelen = (size_t) (sfp->end - sfp->data);
}
pdc_logg_cond(sfp->pdc, 1, trc_filesearch,
"\t%d bytes read from %s file, contents=%p\n",
(int) (*filelen),
(sfp->fp) ? "disk" : "memory",
result);
return result;
}
pdc_bool
pdf_get_metrics_afm(
PDF *p,
pdf_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename,
pdc_bool requested)
{
static const char fn[] = "pdf_get_metrics_afm";
char fullname[PDC_FILENAMELEN];
pdc_file *afmfile;
/* open AFM file */
afmfile = pdc_fsearch_fopen(p->pdc, filename, fullname, "AFM ",
PDC_FILE_TEXT);
if (afmfile == NULL)
return pdc_check_fopen_errmsg(p->pdc, requested);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tLoading AFM metric fontfile \"%s\":\n", fullname);
/* parse AFM file */
if (pdf_parse_afm(p, afmfile, font, fontname, fullname) == pdc_false)
return pdc_false;
/* members not fount */
if (font->ft.m.type == fnt_unknownType)
font->ft.m.type = fnt_Type1;
if (font->ft.name == NULL)
{
font->ft.name = pdc_strdup(p->pdc, fontname);
font->ft.m.name = pdc_strdup(p->pdc, fontname);
}
/* save full filename */
font->metricfilename = pdc_strdup_ext(p->pdc, fullname, 0, fn);
/* process metric data */
font->ft.enc = enc;
if (pdf_process_metrics_data(p, font, fontname) == pdc_false)
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
void
pdc_exit_try(pdc_core *pdc)
{
pdc_logg_cond(pdc, 3, trc_api,
"[EXIT_TRY at level %d]\n", pdc->pr->x_sp);
if (pdc->pr->x_sp == -1)
{
strcpy(pdc->pr->errbuf, "exception stack underflow");
pdc->pr->errnum = PDC_E_INT_XSTACK;
(*pdc->pr->errorhandler)(pdc->pr->opaque, PDF_UnknownError,
pdc->pr->errbuf);
}
else
--pdc->pr->x_sp;
} /* pdc_exit_try */
pdc_bool
fnt_test_type1_font(pdc_core *pdc, const pdc_byte *img)
{
char startsequ[5];
strcpy(startsequ, FNT_PFA_STARTSEQU);
/* ASCII block sign and begin of text at byte 7 */
if (img[0] == 0x80 && img[1] == 0x01 &&
strncmp((const char *)&img[6], startsequ, 4) == 0)
{
pdc_logg_cond(pdc, 1, trc_font,
"\tPostScript Type1 font detected\n");
return pdc_true;
}
return pdc_false;
}
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;
}
void
pdc_set_errmsg(
pdc_core * pdc,
int errnum,
const char *parm1,
const char *parm2,
const char *parm3,
const char *parm4)
{
const pdc_error_info *ei = get_error_info(pdc, errnum);
make_errmsg(pdc, ei, parm1, parm2, parm3, parm4, pdc_false);
pdc->pr->errnum = errnum;
pdc_logg_cond(pdc, 2, trc_warning,
"[Reason for error message %d: \"%s\"]\n",
pdc->pr->errnum, pdc->pr->errbuf);
} /* pdc_set_errmsg */
void
pdc_insert_mem_tmp(
pdc_core * pdc,
void * memory,
void * opaque,
pdc_destructor destr)
{
pdc_tmpmem_list *tm_list = &pdc->pr->tm_list;
if (tm_list->size == tm_list->capacity)
pdc_tmlist_grow(pdc);
pdc_logg_cond(pdc, 2, trc_memory,
"\tTemporary memory %p was created\n", memory);
tm_list->tmpmem[tm_list->size].mem = memory;
tm_list->tmpmem[tm_list->size].destr = destr;
tm_list->tmpmem[tm_list->size].opaque = opaque;
++tm_list->size;
}
/* Finish the pattern definition. */
void
pdf__end_pattern(PDF *p)
{
/* check whether pdf__save() and pdf__restore() calls are balanced */
if (p->curr_ppt->sl > 0)
pdc_error(p->pdc, PDF_E_GSTATE_UNMATCHEDSAVE, 0, 0, 0, 0);
pdf_end_text(p);
pdc_end_pdfstream(p->out);
pdc_end_obj(p->out); /* pattern */
pdc_put_pdfstreamlength(p->out, p->length_id);
pdc_begin_obj(p->out, p->res_id); /* Resource object */
pdc_begin_dict(p->out); /* Resource dict */
pdf_write_page_fonts(p); /* Font resources */
pdf_write_page_colorspaces(p); /* Color space resources */
pdf_write_page_pattern(p); /* Pattern resources */
pdf_write_xobjects(p); /* XObject resources */
pdf_write_page_extgstates(p); /* ExtGState resources */
pdc_end_dict(p->out); /* resource dict */
pdc_end_obj(p->out); /* resource object */
pdf_pg_resume(p, -1);
if (p->flush & pdc_flush_content)
pdc_flush_stream(p->out);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[End pattern %d]\n",
p->pattern_number -1);
}
int
pdc_catch_extern(pdc_core *pdc)
{
pdc_bool result;
pdc_logg_cond(pdc, 3, trc_api,
"[CATCH at level %d]\n", pdc->pr->x_sp);
if (pdc->pr->x_sp == -1)
{
strcpy(pdc->pr->errbuf, "exception stack underflow");
pdc->pr->errnum = PDC_E_INT_XSTACK;
(*pdc->pr->errorhandler)(pdc->pr->opaque, PDF_UnknownError,
pdc->pr->errbuf);
}
else
--pdc->pr->x_sp;
result = pdc->pr->x_thrown;
pdc->pr->x_thrown = pdc_false;
return result;
} /* pdc_catch_extern */
static pdc_bool
pdf_read_pfb_segment(PDF *p, PDF_data_source *src, t1_private_data *t1, int i)
{
static const char *fn = "pdf_read_pfb_segment";
size_t length, len;
length = (size_t) (pdf_t1getc(t1) & 0xff);
length |= (size_t) (pdf_t1getc(t1) & 0xff) << 8;
length |= (size_t) (pdf_t1getc(t1) & 0xff) << 16;
length |= (size_t) (pdf_t1getc(t1) & 0xff) << 24;
pdc_logg_cond(p->pdc, 5, trc_font,
" and length x%04X", length);
if (src->buffer_start)
pdc_free(p->pdc, (void *) src->buffer_start);
src->buffer_start = (pdc_byte *) pdc_malloc(p->pdc, length, fn);
if (t1->fontfile)
{
len = pdc_fread(src->buffer_start, 1, length, t1->fontfile);
}
else
{
len = length;
if (t1->pos + len > t1->end)
len = (unsigned int)(t1->end - t1->pos);
memcpy(src->buffer_start, t1->pos, len);
t1->pos += len;
}
t1->length[i] = len;
src->next_byte = src->buffer_start;
src->bytes_available = len;
return (len != length) ? pdc_false : pdc_true;
}
pdc_id
pdf_write_info(PDF *p, pdc_bool moddate)
{
pdc_bool logg3 = pdc_logg_is_enabled(p->pdc, 3, trc_xmp);
char time_str[PDC_TIME_SBUF_SIZE];
char producer[PDC_GEN_BUFSIZE];
pdf_info *info;
pdc_id info_id;
const char *product = "PDFlib Lite";
const char *security = "";
(void) logg3;
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api,
"[Full product name: \"%s\"]\n", product);
info_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Info object */
pdc_begin_dict(p->out);
/*
* Although it would be syntactically correct, we must not remove
* the space characters after the dictionary keys since this
* would break the PDF properties feature in Windows Explorer.
*/
if (p->userinfo)
{
for (info = p->userinfo; info != NULL; info = info->next)
{
pdf_put_pdfname(p, info->key);
pdc_puts(p->out, " ");
if (strcmp(info->key, "Trapped"))
pdf_put_hypertext(p, info->value);
else
pdf_put_pdfname(p, info->value);
pdc_puts(p->out, "\n");
}
}
pdc_get_timestr(time_str, pdc_false);
/* creation date and time */
pdc_puts(p->out, "/CreationDate ");
pdf_put_hypertext(p, time_str);
pdc_puts(p->out, "\n");
/* modification date and time */
if (moddate)
{
pdc_puts(p->out, "/ModDate ");
pdf_put_hypertext(p, time_str);
pdc_puts(p->out, "\n");
}
/*
* If you change the /Producer entry your license to use
* PDFlib will be void!
*/
if (p->pdc->binding)
pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s/%s)", product,
PDFLIB_VERSIONSTRING, security, p->pdc->binding, PDF_PLATFORM);
else
pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s)", product,
PDFLIB_VERSIONSTRING, security, PDF_PLATFORM);
pdc_puts(p->out, "/Producer ");
pdf_put_hypertext(p, producer);
pdc_puts(p->out, "\n");
pdc_end_dict(p->out);
pdc_end_obj(p->out); /* Info object */
return info_id;
}
/* Start a new pattern definition. */
int
pdf__begin_pattern(
PDF *p,
pdc_scalar width,
pdc_scalar height,
pdc_scalar xstep,
pdc_scalar ystep,
int painttype)
{
int slot = -1;
pdc_check_number_limits(p->pdc, "width", width,
PDC_FLOAT_PREC, PDC_FLOAT_MAX);
pdc_check_number_limits(p->pdc, "height", height,
PDC_FLOAT_PREC, PDC_FLOAT_MAX);
pdc_check_number_zero(p->pdc, "xstep", xstep);
pdc_check_number_zero(p->pdc, "ystep", ystep);
if (painttype != 1 && painttype != 2)
pdc_error(p->pdc, PDC_E_ILLARG_INT,
"painttype", pdc_errprintf(p->pdc, "%d", painttype), 0, 0);
if (p->pattern_number == p->pattern_capacity)
pdf_grow_pattern(p);
pdf_pg_suspend(p);
PDF_SET_STATE(p, pdf_state_pattern);
p->pattern[p->pattern_number].obj_id = pdc_begin_obj(p->out, PDC_NEW_ID);
p->pattern[p->pattern_number].painttype = painttype;
pdc_begin_dict(p->out); /* pattern dict*/
p->res_id = pdc_alloc_id(p->out);
pdc_puts(p->out, "/PatternType 1\n"); /* tiling pattern */
/* colored or uncolored pattern */
pdc_printf(p->out, "/PaintType %d\n", painttype);
pdc_puts(p->out, "/TilingType 1\n"); /* constant spacing */
pdc_printf(p->out, "/BBox[0 0 %f %f]\n", width, height);
pdc_printf(p->out, "/XStep %f\n", xstep);
pdc_printf(p->out, "/YStep %f\n", ystep);
pdc_objref(p->out, "/Resources", p->res_id);
p->length_id = pdc_alloc_id(p->out);
pdc_objref(p->out, "/Length", p->length_id);
if (pdc_get_compresslevel(p->out))
pdc_puts(p->out, "/Filter/FlateDecode\n");
pdc_end_dict(p->out); /* pattern dict*/
pdc_begin_pdfstream(p->out);
slot = p->pattern_number;
p->pattern_number++;
/* top-down y-coordinates */
pdf_set_topdownsystem(p, height);
/* set color differing from PDF default */
pdf_set_default_color(p, pdc_false);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[Begin pattern %d]\n", slot);
return slot;
}
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;
}
static pdc_bool
pdf_parse_pfm(PDF *p, pdc_file *fp, pdf_font *font)
{
static const char fn[] = "pdf_parse_pfm";
fnt_font_metric *ftm = &font->ft.m;
size_t length;
pdc_byte *pfm;
pdc_bool ismem;
int i, dfFirstChar, dfLastChar, default_width;
unsigned long dfExtentTable;
/* read whole file and close it */
pfm = (pdc_byte *) pdc_freadall(fp, &length, &ismem);
pdc_fclose(fp);
/* check whether this is really a valid PostScript PFM file */
if (pfm == NULL ||
(header_dfVersion != 0x100 && header_dfVersion != 0x200) ||
dfDevice > length ||
strncmp((const char *) pfm + dfDevice, PDF_STRING_PostScript, 10) ||
ext_dfDriverInfo > length)
{
if (!ismem)
pdc_free(p->pdc, pfm);
return pdc_false;
}
/* fetch relevant data from the PFM */
ftm->type = fnt_Type1;
font->ft.name = pdc_strdup(p->pdc, (const char *)pfm + ext_dfDriverInfo);
ftm->name = pdc_strdup(p->pdc, font->ft.name);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tPostScript font name: \"%s\"\n", ftm->name);
switch (header_dfPitchAndFamily & 0xF0)
{
case PDF_ROMAN:
ftm->flags |= FNT_SERIF;
break;
case PDF_MODERN:
/* Has to be ignored, contrary to MS's specs */
break;
case PDF_SCRIPT:
ftm->flags |= FNT_SCRIPT;
break;
case PDF_DECORATIVE:
/* the dfCharSet flag lies in this case... */
header_dfCharSet = PFM_SYMBOL_CHARSET;
break;
case PDF_SWISS:
case PDF_DONTCARE:
default:
break;
}
/* temporarily */
font->ft.enc = (pdc_encoding) header_dfCharSet;
dfFirstChar = header_dfFirstChar;
dfLastChar = header_dfLastChar;
dfExtentTable = ext_dfExtentTable;
/*
* Some rare PFMs do not contain any ExtentTable if the fixed pitch flag
* is set. Use the dfMaxWidth entry for all glyphs in this case.
* If the user forced the font to be monospaced we use this value instead.
*/
if ((!(header_dfPitchAndFamily & PDF_FIXED_PITCH) && dfExtentTable == 0) ||
font->opt.monospace)
{
ftm->isFixedPitch = pdc_true;
default_width = font->opt.monospace ? font->opt.monospace :
(int) header_dfMaxWidth;
}
else
{
/* default values -- don't take the width of the default character */
default_width = FNT_DEFAULT_WIDTH;
}
font->ft.numcodes = 256;
ftm->numwidths = font->ft.numcodes;
ftm->widths = (int *) pdc_calloc(p->pdc, ftm->numwidths * sizeof(int), fn);
for (i = 0; i < font->ft.numcodes; i++)
ftm->widths[i] = default_width;
if (!ftm->isFixedPitch)
{
if (ext_dfExtentTable == 0 ||
ext_dfExtentTable + 2 * (header_dfLastChar-header_dfFirstChar) + 1 >
length)
{
if (!ismem)
pdc_free(p->pdc, pfm);
return pdc_false;
}
for (i = dfFirstChar; i <= dfLastChar; i++)
ftm->widths[i] =
(int) PFM_WORD(dfExtentTable + 2 * (i - dfFirstChar));
/*
* Check whether the font is actually opt.monospaced
* (the fixed pitch flag is not necessarily set)
*/
default_width = ftm->widths[dfFirstChar];
for (i = dfFirstChar+1; i <= dfLastChar; i++)
if (default_width != ftm->widths[i])
break;
if (i == dfLastChar + 1)
ftm->isFixedPitch = pdc_true;
}
font->ft.weight = fnt_check_weight(header_dfWeight);
ftm->defwidth = default_width;
ftm->italicAngle = (header_dfItalic ? etmSlant/(10.0) : 0.0);
ftm->capHeight = etmCapHeight;
ftm->xHeight = etmXHeight;
ftm->descender = -etmLowerCaseDescent;
ftm->ascender = (int) header_dfAscent;
ftm->underlinePosition = -etmUnderlineOffset;
ftm->underlineThickness = etmUnderlineWidth;
ftm->urx = header_dfMaxWidth;
if (!ismem)
pdc_free(p->pdc, pfm);
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;
}
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;
}
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;
}
void
pdf__set_parameter(PDF *p, const char *key, const char *value)
{
pdc_pagebox usebox = pdc_pbox_none;
pdc_text_format textformat = pdc_auto;
char optlist[PDC_GEN_BUFSIZE];
pdf_ppt *ppt;
int i, k;
i = pdf_get_index(p, key, pdc_true);
if (value == NULL) value = "";
ppt = p->curr_ppt;
switch (i)
{
case PDF_PARAMETER_PDIUSEBOX:
case PDF_PARAMETER_VIEWAREA:
case PDF_PARAMETER_VIEWCLIP:
case PDF_PARAMETER_PRINTAREA:
case PDF_PARAMETER_PRINTCLIP:
k = pdc_get_keycode_ci(value, pdf_usebox_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
usebox = (pdc_pagebox) k;
pdc_sprintf(p->pdc, pdc_false, optlist, "%s %s", key, value);
break;
case PDF_PARAMETER_TEXTFORMAT:
case PDF_PARAMETER_HYPERTEXTFORMAT:
k = pdc_get_keycode_ci(value, pdf_textformat_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
textformat = (pdc_text_format) k;
break;
}
switch (i)
{
case PDF_PARAMETER_SEARCHPATH:
case PDF_PARAMETER_FONTAFM:
case PDF_PARAMETER_FONTPFM:
case PDF_PARAMETER_FONTOUTLINE:
case PDF_PARAMETER_HOSTFONT:
case PDF_PARAMETER_ENCODING:
case PDF_PARAMETER_ICCPROFILE:
case PDF_PARAMETER_STANDARDOUTPUTINTENT:
{
pdf_add_pdflib_resource(p, key, value);
break;
}
case PDF_PARAMETER_DEBUG:
{
const unsigned char *c;
for (c = (const unsigned char *) value; *c; c++)
p->debug[(int) *c] = 1;
break;
}
case PDF_PARAMETER_NODEBUG:
{
const unsigned char *c;
for (c = (const unsigned char *) value; *c; c++)
p->debug[(int) *c] = 0;
break;
}
case PDF_PARAMETER_BINDING:
if (!p->pdc->binding)
p->pdc->binding = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_OBJORIENT:
p->pdc->objorient = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_HASTOBEPOS:
p->pdc->hastobepos = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PTFRUN:
p->pdc->ptfrun = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_SMOKERUN:
p->pdc->smokerun = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_UNICAPLANG:
p->pdc->unicaplang = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_ERRORPOLICY:
k = pdc_get_keycode_ci(value, pdf_errpol_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
p->errorpolicy = (pdf_errpol) k;
break;
case PDF_PARAMETER_UNDERLINE:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_underline);
break;
case PDF_PARAMETER_OVERLINE:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_overline);
break;
case PDF_PARAMETER_STRIKEOUT:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_strikeout);
break;
case PDF_PARAMETER_KERNING:
pdc_warning(p->pdc, PDF_E_UNSUPP_KERNING, 0, 0, 0, 0);
break;
case PDF_PARAMETER_FAKEBOLD:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_fakebold);
break;
case PDF_PARAMETER_RESOURCEFILE:
pdc_set_resourcefile(p->pdc, value);
break;
case PDF_PARAMETER_RENDERINGINTENT:
k = pdc_get_keycode_ci(value, pdf_renderingintent_pdfkeylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
p->rendintent = (pdf_renderingintent) k;
break;
case PDF_PARAMETER_PRESERVEOLDPANTONENAMES:
p->preserveoldpantonenames = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_SPOTCOLORLOOKUP:
p->spotcolorlookup = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PDISTRICT:
p->pdi_strict = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TOPDOWN:
if (pdf_bool_value(p, key, value))
p->ydirection = -1.0;
else
p->ydirection = 1.0;
break;
case PDF_PARAMETER_USERCOORDINATES:
p->usercoordinates = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_USEHYPERTEXTENCODING:
p->usehyptxtenc = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TEXTFORMAT:
pdf_check_textformat(p, textformat);
p->textformat = textformat;
if (p->curr_ppt)
pdf_set_tstate(p, (double) textformat, to_textformat);
break;
case PDF_PARAMETER_HYPERTEXTFORMAT:
pdf_check_hypertextformat(p, textformat);
p->hypertextformat = textformat;
break;
case PDF_PARAMETER_HYPERTEXTENCODING:
{
p->hypertextencoding =
pdf_get_hypertextencoding(p, value, &p->hypertextcodepage,
pdc_true);
pdf_check_hypertextencoding(p, p->hypertextencoding);
break;
}
case PDF_PARAMETER_CHARREF:
pdc_warning(p->pdc, PDF_E_UNSUPP_CHARREF, 0, 0, 0, 0);
break;
case PDF_PARAMETER_ESCAPESEQUENCE:
pdc_warning(p->pdc, PDF_E_UNSUPP_ESCAPESEQU, 0, 0, 0, 0);
break;
case PDF_PARAMETER_HONORLANG:
pdc_warning(p->pdc, PDF_E_UNSUPP_HONORLANG, 0, 0, 0, 0);
break;
case PDF_PARAMETER_GLYPHCHECK:
pdc_warning(p->pdc, PDF_E_UNSUPP_GLYPHCHECK, 0, 0, 0, 0);
break;
case PDF_PARAMETER_FILLRULE:
k = pdc_get_keycode_ci(value, pdf_fillrule_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
ppt->fillrule = (pdf_fillrule) k;
break;
case PDF_PARAMETER_LOGGING:
pdc_set_logg_options(p->pdc, value);
break;
case PDF_PARAMETER_LOGMSG:
pdc_logg_cond(p->pdc, 1, trc_user, value);
break;
case PDF_PARAMETER_TRACEMSG:
/* do nothing -- client-supplied string will show up
* in the log file
*/
break;
case PDF_PARAMETER_NODEMOSTAMP:
break;
case PDF_PARAMETER_SERIAL:
case PDF_PARAMETER_LICENCE:
case PDF_PARAMETER_LICENSE:
break;
case PDF_PARAMETER_LICENCEFILE:
case PDF_PARAMETER_LICENSEFILE:
break;
case PDF_PARAMETER_AUTOSPACE:
pdc_warning(p->pdc, PDF_E_UNSUPP_TAGGED, 0, 0, 0, 0);
break;
/*****************************************************************************/
/** deprecated historical parameters **/
/*****************************************************************************/
case PDF_PARAMETER_OPENWARNING:
p->debug[(int) 'o'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_FONTWARNING:
p->debug[(int) 'F'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_ICCWARNING:
p->debug[(int) 'I'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_IMAGEWARNING:
p->debug[(int) 'i'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PDIWARNING:
p->debug[(int) 'p'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_HONORICCPROFILE:
p->debug[(int) 'e'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_GLYPHWARNING:
p->debug[(int) 'g'] = (char) pdf_bool_value(p, key, value);
if (p->curr_ppt)
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_glyphwarning);
break;
case PDF_PARAMETER_TRACE:
{
pdc_bool bv = pdf_bool_value(p, key, value);
if (bv)
pdc_set_logg_options(p->pdc, "");
else
pdc_set_logg_options(p->pdc, "disable");
break;
}
case PDF_PARAMETER_TRACEFILE:
pdc_sprintf(p->pdc, pdc_false, optlist, "filename %s", value);
pdc_set_logg_options(p->pdc, optlist);
break;
case PDF_PARAMETER_WARNING:
break;
case PDF_PARAMETER_MASTERPASSWORD:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_USERPASSWORD:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_PERMISSIONS:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_COMPATIBILITY:
pdf_set_compatibility(p, value);
break;
case PDF_PARAMETER_FLUSH:
pdf_set_flush(p, value);
break;
case PDF_PARAMETER_PDFX:
pdc_warning(p->pdc, PDF_E_UNSUPP_PDFX, 0, 0, 0, 0);
break;
case PDF_PARAMETER_HIDETOOLBAR:
case PDF_PARAMETER_HIDEMENUBAR:
case PDF_PARAMETER_HIDEWINDOWUI:
case PDF_PARAMETER_FITWINDOW:
case PDF_PARAMETER_CENTERWINDOW:
case PDF_PARAMETER_DISPLAYDOCTITLE:
if (pdf_bool_value(p, key, value))
pdf_set_viewerpreference(p, key);
break;
case PDF_PARAMETER_NONFULLSCREENPAGEMODE:
if (!pdc_stricmp(value, "useoutlines"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode bookmarks");
else if (!pdc_stricmp(value, "usethumbs"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode thumbnails");
else if (!pdc_stricmp(value, "usenone"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode none");
else
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
break;
case PDF_PARAMETER_DIRECTION:
if (!pdc_stricmp(value, "r2l"))
pdf_set_viewerpreference(p, "direction r2l");
else if (!pdc_stricmp(value, "l2r"))
pdf_set_viewerpreference(p, "direction l2r");
else
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
break;
case PDF_PARAMETER_VIEWAREA:
case PDF_PARAMETER_VIEWCLIP:
case PDF_PARAMETER_PRINTAREA:
case PDF_PARAMETER_PRINTCLIP:
pdf_set_viewerpreference(p, optlist);
break;
case PDF_PARAMETER_OPENACTION:
pdf_set_openaction(p, value);
break;
case PDF_PARAMETER_OPENMODE:
pdf_set_openmode(p, value);
break;
case PDF_PARAMETER_BOOKMARKDEST:
pdf_cleanup_destination(p, p->bookmark_dest);
p->bookmark_dest =
pdf_parse_destination_optlist(p, value, 0, pdf_bookmark);
break;
case PDF_PARAMETER_INHERITGSTATE:
(void) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TRANSITION:
pdf_set_transition(p, value);
break;
case PDF_PARAMETER_BASE:
pdf_set_uri(p, value);
break;
case PDF_PARAMETER_LAUNCHLINK_PARAMETERS:
if (p->launchlink_parameters) {
pdc_free(p->pdc, p->launchlink_parameters);
p->launchlink_parameters = NULL;
}
p->launchlink_parameters = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_LAUNCHLINK_OPERATION:
if (p->launchlink_operation) {
pdc_free(p->pdc, p->launchlink_operation);
p->launchlink_operation = NULL;
}
p->launchlink_operation = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_LAUNCHLINK_DEFAULTDIR:
if (p->launchlink_defaultdir) {
pdc_free(p->pdc, p->launchlink_defaultdir);
p->launchlink_defaultdir = NULL;
}
p->launchlink_defaultdir = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_PDIUSEBOX:
p->pdi_usebox = usebox;
break;
case PDF_PARAMETER_AUTOSUBSETTING:
case PDF_PARAMETER_AUTOCIDFONT:
case PDF_PARAMETER_UNICODEMAP:
pdc_warning(p->pdc, PDF_E_UNSUPP_UNICODE, 0, 0, 0, 0);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
break;
} /* switch */
} /* pdf__set_parameter */
void
pdf__begin_font(
PDF *p,
const char *fontname, int len,
pdc_scalar a, pdc_scalar b, pdc_scalar c, pdc_scalar d,
pdc_scalar e, pdc_scalar f,
const char *optlist)
{
static const char fn[] = "pdf__begin_font";
pdc_resopt *results;
pdf_font tmpfont, *font;
pdf_font_options fo;
pdc_scalar det;
pdc_clientdata cdata;
int colorized = pdc_false;
int metricsonly = pdc_false;
int slot;
if (fontname == NULL)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "fontname", 0, 0, 0);
/* Converting fontname */
fontname = pdf_convert_name(p, fontname, len,
PDC_CONV_WITHBOM | PDC_CONV_TMPALLOC);
if (fontname == NULL || *fontname == '\0')
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "fontname", 0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tBegin of Type3 font \"%s\"\n", fontname);
/* error message prefix */
pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, fontname, 0, 0, 0);
/* look for an already existing font */
for (slot = 0; slot < p->fonts_number; slot++)
{
if (!pdc_strcmp(p->fonts[slot].apiname, fontname))
{
if (p->fonts[slot].t3font->pass == 1)
{
pdc_logg_cond(p->pdc, 1, trc_font,
"\tType3 font [%d] with metric definition found\n", slot);
PDF_CHECK_STATE(p, pdf_state_document);
p->fonts[slot].t3font->pass = 2;
p->t3slot = slot;
pdc_pop_errmsg(p->pdc);
pdf_pg_suspend(p);
PDF_SET_STATE(p, pdf_state_font);
return;
}
pdc_error(p->pdc, PDF_E_T3_FONTEXISTS, 0, 0, 0, 0);
}
}
pdc_check_number(p->pdc, "a", a);
pdc_check_number(p->pdc, "b", b);
pdc_check_number(p->pdc, "c", c);
pdc_check_number(p->pdc, "d", d);
pdc_check_number(p->pdc, "e", e);
pdc_check_number(p->pdc, "f", f);
det = a*d - b*c;
if (det == 0)
pdc_error(p->pdc, PDC_E_ILLARG_MATRIX,
pdc_errprintf(p->pdc, "%f %f %f %f %f %f", a, b, c, d, e, f),
0, 0, 0);
/* parsing optlist */
pdf_set_clientdata(p, &cdata);
results = pdc_parse_optionlist(p->pdc, optlist, pdf_begin_font_options,
&cdata, pdc_true);
pdc_get_optvalues("colorized", results, &colorized, NULL);
pdc_get_optvalues("widthsonly", results, &metricsonly, NULL);
pdc_cleanup_optionlist(p->pdc, results);
/* initialize font struct */
font = &tmpfont;
pdf_init_font_options(p, &fo);
pdf_init_font(p, font, &fo);
/*
* We store the new font in a font slot marked with "invalidenc" encoding.
* When the font is used for the first time we modify the encoding.
* Later uses will make a copy if the encoding is different.
*/
/* API font name */
font->apiname = pdc_strdup(p->pdc, fontname);
font->ft.m.type = fnt_Type3;
font->hasoriginal = pdc_true;
font->ft.matrix.a = a;
font->ft.matrix.b = b;
font->ft.matrix.c = c;
font->ft.matrix.d = d;
font->ft.matrix.e = e;
font->ft.matrix.f = f;
font->t3font = (pdf_t3font*) pdc_malloc(p->pdc, sizeof(pdf_t3font), fn);
pdf_init_t3font(p, font->t3font, T3GLYPHS_CHUNKSIZE);
font->t3font->colorized = colorized;
/* the resource id is needed until the font dict is written */
font->t3font->res_id = pdc_alloc_id(p->out);
/* Now everything is fine, insert Type3 font with invalid encoding */
slot = pdf_insert_font(p, font);
/*
* We must store a pointer to the current font because its glyph
* definitions may use other fonts and we would be unable to find
* "our" current font again. This pointer lives throughout the
* font definition, and will be reset in PDF_end_font() below.
*/
p->t3slot = slot;
if (metricsonly)
{
font->t3font->pass = 1;
pdc_logg_cond(p->pdc, 2, trc_font,
"\t\tonly for metric definition\n");
}
else
{
pdf_pg_suspend(p);
}
pdc_pop_errmsg(p->pdc);
PDF_SET_STATE(p, pdf_state_font);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[Begin font %d]\n", p->t3slot);
}
void
pdf__begin_glyph(
PDF *p,
const char *glyphname,
pdc_scalar wx,
pdc_scalar llx, pdc_scalar lly, pdc_scalar urx, pdc_scalar ury)
{
static const char fn[] = "pdf__begin_glyph";
pdf_font *font;
pdf_t3font *t3font;
pdf_t3glyph *glyph = NULL;
pdc_scalar tbc;
int ig;
if (glyphname == NULL || *glyphname == '\0')
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "glyphname", 0, 0, 0);
font = &p->fonts[p->t3slot];
t3font = font->t3font;
/* error message prefix */
pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, font->apiname, 0, 0, 0);
for (ig = 0; ig < t3font->next_glyph; ig++)
{
glyph = &t3font->glyphs[ig];
if (!pdc_strcmp(glyph->name, glyphname))
{
if (t3font->pass == glyph->pass)
pdc_error(p->pdc, PDF_E_T3_GLYPH, glyphname, 0, 0, 0);
else
break;
}
}
/* new glyph */
if (ig == t3font->next_glyph)
{
if (t3font->pass == 2)
pdc_error(p->pdc, PDF_E_T3_UNKOWNGLYPH, glyphname, 0, 0, 0);
pdc_check_number(p->pdc, "wx", wx);
pdc_check_number(p->pdc, "llx", llx);
pdc_check_number(p->pdc, "lly", lly);
pdc_check_number(p->pdc, "urx", urx);
pdc_check_number(p->pdc, "ury", ury);
if (t3font->colorized == pdc_true &&
(llx != 0 || lly != 0 ||
urx != 0 || ury != 0))
pdc_error(p->pdc, PDF_E_T3_BADBBOX, 0, 0, 0, 0);
if (urx < llx)
{
tbc = llx;
llx = urx;
urx = tbc;
}
if (ury < lly)
{
tbc = lly;
lly = ury;
ury = tbc;
}
if (ig == t3font->capacity)
{
t3font->capacity *= 2;
t3font->glyphs = (pdf_t3glyph *) pdc_realloc(p->pdc, t3font->glyphs,
t3font->capacity * sizeof (pdf_t3glyph), fn);
}
glyph = &t3font->glyphs[ig];
glyph->charproc_id = PDC_BAD_ID;
glyph->name = pdc_strdup(p->pdc, glyphname);
glyph->wx = wx;
glyph->llx = llx;
glyph->lly = lly;
glyph->urx = urx;
glyph->ury = ury;
/* see comment in p_font.c for explanation */
glyph->width = 1000 * wx * font->ft.matrix.a;
/* if the strdup above fails, cleanup won't touch this slot. */
t3font->next_glyph++;
}
glyph->pass = t3font->pass;
t3font->curr_glyph = ig;
pdc_logg_cond(p->pdc, 1, trc_font,
"\tBegin of Type3 font glyph \"%s\"\n", glyphname);
if (t3font->pass != 1)
{
if (t3font->pass == 2)
pdc_logg_cond(p->pdc, 2, trc_font,
"\t\tglyph [%d] was used in text\n", ig);
glyph->charproc_id = pdc_begin_obj(p->out, PDC_NEW_ID);
pdc_begin_dict(p->out);
p->length_id = pdc_alloc_id(p->out);
pdc_objref(p->out, "/Length", p->length_id);
if (pdc_get_compresslevel(p->out))
pdc_puts(p->out, "/Filter/FlateDecode\n");
pdc_end_dict(p->out);
pdc_begin_pdfstream(p->out);
if (t3font->colorized == pdc_true)
pdc_printf(p->out, "%f 0 d0\n", glyph->wx);
else
{
pdc_printf(p->out, "%f 0 %f %f %f %f d1\n",
glyph->wx, glyph->llx, glyph->lly, glyph->urx, glyph->ury);
/* adjust the font's bounding box */
if (glyph->llx < font->ft.bbox.llx)
font->ft.bbox.llx = glyph->llx;
if (glyph->lly < font->ft.bbox.lly)
font->ft.bbox.lly = glyph->lly;
if (glyph->urx > font->ft.bbox.urx)
font->ft.bbox.urx = glyph->urx;
if (glyph->ury > font->ft.bbox.ury)
font->ft.bbox.ury = glyph->ury;
}
/* we must initialize the text, graphics and color state
* otherwise the user get unpredictable appearance of a
* glyph because of optimizing outputting graphics properties.
* Following statements were inserted due to bug #719
*/
pdf_init_tstate(p);
pdf_init_gstate(p);
pdf_init_cstate(p);
PDF_SET_STATE(p, pdf_state_glyph);
}
else
{
PDF_SET_STATE(p, pdf_state_glyphmetrics);
}
pdc_pop_errmsg(p->pdc);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[Begin glyph %d]\n", ig);
}
void
pdf__end_font(PDF *p)
{
int ig;
pdf_font *font;
pdf_t3font *t3font;
PDF_SET_STATE(p, pdf_state_document);
font = &p->fonts[p->t3slot];
t3font = font->t3font;
/* error message prefix */
pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, font->apiname, 0, 0, 0);
if (t3font->pass == 0)
{
pdf_t3glyph glyph0 = t3font->glyphs[0];
/* search for .notdef glyph */
if (pdc_strcmp(glyph0.name, (char *) pdc_get_notdef_glyphname()))
{
for (ig = 0; ig < t3font->next_glyph; ig++)
{
if (!pdc_strcmp(t3font->glyphs[ig].name,
(char *) pdc_get_notdef_glyphname()))
break;
}
if (ig < t3font->next_glyph)
{
pdc_logg_cond(p->pdc, 2, trc_font,
"\tGlyph id %d: \"%s\" will be exchanged "
"with glyph id 0: \"%s\"\n",
ig, t3font->glyphs[ig].name, glyph0.name);
t3font->glyphs[0] = t3font->glyphs[ig];
t3font->glyphs[ig] = glyph0;
}
else
{
pdc_warning(p->pdc, PDF_E_T3_MISSNOTDEF, 0, 0, 0, 0);
}
}
}
if (t3font->pass != 1)
{
t3font->charprocs_id = pdc_alloc_id(p->out);
pdc_begin_obj(p->out, t3font->charprocs_id); /* CharProcs dict */
pdc_begin_dict(p->out);
for (ig = 0; ig < t3font->next_glyph; ig++)
{
pdf_t3glyph *glyph = &t3font->glyphs[ig];
if (glyph->charproc_id != PDC_BAD_ID)
{
pdf_put_pdfname(p, glyph->name);
pdc_objref(p->out, "", glyph->charproc_id);
}
}
pdc_end_dict(p->out);
pdc_end_obj(p->out); /* CharProcs dict */
pdc_begin_obj(p->out, t3font->res_id);
pdc_begin_dict(p->out); /* Resource dict */
pdf_write_page_fonts(p); /* Font resources */
pdf_write_page_colorspaces(p); /* Color space resources */
pdf_write_page_pattern(p); /* Pattern resources */
pdf_write_xobjects(p); /* XObject resources */
pdc_end_dict(p->out); /* Resource dict */
pdc_end_obj(p->out); /* Resource object */
pdf_pg_resume(p, -1);
if (p->flush & pdc_flush_content)
pdc_flush_stream(p->out);
/* see pdf__begin_glyph */
pdf_init_tstate(p);
pdf_init_gstate(p);
pdf_init_cstate(p);
}
pdc_logg_cond(p->pdc, 1, trc_font,
"\tEnd of Type3 font \"%s\"\n", font->apiname);
pdc_pop_errmsg(p->pdc);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[End font %d]\n", p->t3slot);
p->t3slot = -1;
}
