int fnt_get_charcoll(const char *ordering) { int charcoll; charcoll = (int) pdc_get_keycode(ordering, fnt_charcoll_keylist); if (charcoll == PDC_KEY_NOTFOUND) return cc_unknown; else return charcoll; }
/* * 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; }
int fnt_get_pdf_fonttype_code(const char *typenam) { int type = pdc_get_keycode(typenam, pdf_fonttype_pdfkeylist); return (type != PDC_KEY_NOTFOUND) ? type : fnt_unknownType; }
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 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; }
PDFLIB_API void PDFLIB_CALL PDF_set_parameter(PDF *p, const char *key, const char *value) { static const char fn[] = "PDF_set_parameter"; pdc_usebox usebox = use_none; pdc_text_format textformat = pdc_auto; int i, k; if (key == NULL || !*key) pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "key", 0, 0, 0); i = get_index(key); if (!pdf_enter_api(p, fn, (pdf_state) pdf_state_all, "(p[%p], \"%s\", \"%s\")\n", (void *) p, key, value)) return; if (i == -1) pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0); if ((p->state_stack[p->state_sp] & parms[i].set_scope) == 0) pdc_error(p->pdc, PDF_E_DOC_SCOPE_SET, key, pdf_current_scope(p), 0, 0); if (value == NULL) pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "value", 0, 0, 0); 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(value, pdf_usebox_keylist); if (k == PDC_KEY_NOTFOUND) pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); usebox = (pdc_usebox) k; break; case PDF_PARAMETER_TEXTFORMAT: case PDF_PARAMETER_HYPERTEXTFORMAT: k = pdc_get_keycode(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_resource(p, key, value); break; } case PDF_PARAMETER_FLUSH: if (p->binding != NULL && strcmp(p->binding, "C++")) break; if (!strcmp(value, "none")) p->flush = pdf_flush_none; else if (!strcmp(value, "page")) p->flush = (pdf_flush_state) (p->flush | pdf_flush_page); else if (!strcmp(value, "content")) p->flush = (pdf_flush_state) (p->flush | pdf_flush_content); else if (!strcmp(value, "heavy")) p->flush = (pdf_flush_state) (p->flush | pdf_flush_heavy); else pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); break; case PDF_PARAMETER_DEBUG: { const unsigned char *c; for (c = (const unsigned char *) value; *c; c++) { p->debug[(int) *c] = 1; if (*c == 't') { pdc_set_trace(p->pdc, "PDFlib " PDFLIB_VERSIONSTRING); } } break; } case PDF_PARAMETER_NODEBUG: { const unsigned char *c; for (c = (const unsigned char *) value; *c; c++) { if (*c == 't') pdc_set_trace(p->pdc, NULL); p->debug[(int) *c] = 0; } break; } case PDF_PARAMETER_BINDING: if (!p->binding) p->binding = pdc_strdup(p->pdc, value); break; case PDF_PARAMETER_HASTOBEPOS: p->hastobepos = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_UNDERLINE: p->underline = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_OVERLINE: p->overline = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_STRIKEOUT: p->strikeout = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_KERNING: pdc_warning(p->pdc, PDF_E_UNSUPP_KERNING, 0, 0, 0, 0); break; case PDF_PARAMETER_AUTOSUBSETTING: pdc_warning(p->pdc, PDF_E_UNSUPP_SUBSET, 0, 0, 0, 0); break; case PDF_PARAMETER_AUTOCIDFONT: pdc_warning(p->pdc, PDF_E_UNSUPP_UNICODE, 0, 0, 0, 0); break; case PDF_PARAMETER_UNICODEMAP: pdc_warning(p->pdc, PDF_E_UNSUPP_UNICODE, 0, 0, 0, 0); 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: if (!strcmp(value, "1.3")) p->compatibility = PDC_1_3; else if (!strcmp(value, "1.4")) p->compatibility = PDC_1_4; else if (!strcmp(value, "1.5")) p->compatibility = PDC_1_5; else pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); break; case PDF_PARAMETER_PDFX: pdc_warning(p->pdc, PDF_E_UNSUPP_PDFX, 0, 0, 0, 0); break; case PDF_PARAMETER_RESOURCEFILE: if (p->resourcefilename) { pdc_free(p->pdc, p->resourcefilename); p->resourcefilename = NULL; } p->resourcefilename = pdc_strdup(p->pdc, value); p->resfilepending = pdc_true; break; case PDF_PARAMETER_PREFIX: if (p->prefix) { pdc_free(p->pdc, p->prefix); p->prefix = NULL; } /* because of downward compatibility */ p->prefix = pdc_strdup(p->pdc, &value[value[0] == '/' ? 1 : 0]); break; case PDF_PARAMETER_WARNING: pdc_set_warnings(p->pdc, pdf_bool_value(p, key, value)); break; case PDF_PARAMETER_OPENWARNING: p->debug['o'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_FONTWARNING: p->debug['F'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_ICCWARNING: p->debug['I'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_IMAGEWARNING: p->debug['i'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_PDIWARNING: p->debug['p'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_HONORICCPROFILE: p->debug['e'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_GLYPHWARNING: p->debug['g'] = (char) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_RENDERINGINTENT: k = pdc_get_keycode(value, gs_renderingintents); 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_INHERITGSTATE: p->inheritgs = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_PDISTRICT: p->pdi_strict = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_PDIUSEBOX: p->pdi_usebox = usebox; break; case PDF_PARAMETER_PASSTHROUGH: p->debug['P'] = (char) !pdf_bool_value(p, key, value); break; case PDF_PARAMETER_HIDETOOLBAR: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= HideToolbar; break; case PDF_PARAMETER_HIDEMENUBAR: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= HideMenubar; break; case PDF_PARAMETER_HIDEWINDOWUI: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= HideWindowUI; break; case PDF_PARAMETER_FITWINDOW: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= FitWindow; break; case PDF_PARAMETER_CENTERWINDOW: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= CenterWindow; break; case PDF_PARAMETER_DISPLAYDOCTITLE: if (pdf_bool_value(p, key, value)) p->ViewerPreferences.flags |= DisplayDocTitle; break; case PDF_PARAMETER_NONFULLSCREENPAGEMODE: if (!strcmp(value, "useoutlines")) { p->ViewerPreferences.flags |= NonFullScreenPageModeOutlines; p->ViewerPreferences.flags &= ~NonFullScreenPageModeThumbs; } else if (!strcmp(value, "usethumbs")) { p->ViewerPreferences.flags &= ~NonFullScreenPageModeOutlines; p->ViewerPreferences.flags |= NonFullScreenPageModeThumbs; } else if (!strcmp(value, "usenone")) { p->ViewerPreferences.flags &= ~NonFullScreenPageModeOutlines; p->ViewerPreferences.flags &= ~NonFullScreenPageModeThumbs; } else { pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); } break; case PDF_PARAMETER_DIRECTION: if (!strcmp(value, "r2l")) { p->ViewerPreferences.flags |= DirectionR2L; } else if (!strcmp(value, "l2r")) { p->ViewerPreferences.flags &= ~DirectionR2L; } else { pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); } break; case PDF_PARAMETER_VIEWAREA: p->ViewerPreferences.ViewArea = usebox; break; case PDF_PARAMETER_VIEWCLIP: p->ViewerPreferences.ViewClip = usebox; break; case PDF_PARAMETER_PRINTAREA: p->ViewerPreferences.PrintArea = usebox; break; case PDF_PARAMETER_PRINTCLIP: p->ViewerPreferences.PrintClip = usebox; break; case PDF_PARAMETER_TOPDOWN: if (pdf_bool_value(p, key, value)) p->ydirection = (float) -1.0; else p->ydirection = (float) 1.0; break; case PDF_PARAMETER_USERCOORDINATES: p->usercoordinates = pdf_bool_value(p, key, value); break; case PDF_PARAMETER_OPENACTION: pdf_cleanup_destination(p, &p->open_action); pdf_parse_destination_optlist(p, value, &p->open_action, 1, pdf_openaction); break; case PDF_PARAMETER_OPENMODE: if (!strcmp(value, "none")) { p->open_mode = open_none; } else if (!strcmp(value, "bookmarks")) { p->open_mode = open_bookmarks; } else if (!strcmp(value, "thumbnails")) { p->open_mode = open_thumbnails; } else if (!strcmp(value, "fullscreen")) { p->open_mode = open_fullscreen; } else { pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); } break; case PDF_PARAMETER_BOOKMARKDEST: pdf_cleanup_destination(p, &p->bookmark_dest); pdf_parse_destination_optlist(p, value, &p->bookmark_dest, 0, pdf_bookmark); break; case PDF_PARAMETER_FILLRULE: if (!strcmp(value, "winding")) { p->fillrule = pdf_fill_winding; } else if (!strcmp(value, "evenodd")) { p->fillrule = pdf_fill_evenodd; } else { pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); } break; case PDF_PARAMETER_TEXTFORMAT: p->textformat = textformat; break; case PDF_PARAMETER_HYPERTEXTFORMAT: p->hypertextformat = textformat; break; case PDF_PARAMETER_HYPERTEXTENCODING: { pdc_encoding enc; if (!*value) { enc = pdc_unicode; } else { enc = pdf_find_encoding(p, (const char *) value); if (enc == pdc_invalidenc) enc = pdf_insert_encoding(p, (const char *) value); if (enc < 0 && enc != pdc_unicode) pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0); } p->hypertextencoding = enc; break; } /* deprecated */ case PDF_PARAMETER_NATIVEUNICODE: (void) pdf_bool_value(p, key, value); break; case PDF_PARAMETER_TRANSITION: pdf_set_transition(p, value); break; case PDF_PARAMETER_BASE: if (p->base) { pdc_free(p->pdc, p->base); p->base = NULL; } p->base = pdc_strdup(p->pdc, 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_TRACE: if (pdf_bool_value(p, key, value)) { p->debug['t'] = 1; pdc_set_trace(p->pdc, "PDFlib " PDFLIB_VERSIONSTRING); } else { pdc_set_trace(p->pdc, NULL); p->debug['t'] = 0; } break; case PDF_PARAMETER_TRACEFILE: pdc_set_tracefile(p->pdc, value); break; case PDF_PARAMETER_TRACEMSG: /* do nothing -- client-supplied string will show up in the trace */ break; case PDF_PARAMETER_SERIAL: case PDF_PARAMETER_LICENSE: break; case PDF_PARAMETER_LICENSEFILE: break; default: pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0); break; } /* switch */ } /* PDF_set_parameter */
void pdf_add_resource(PDF *p, const char *category, const char *resource) { static const char fn[] = "pdf_add_resource"; pdf_rescategory rescat; pdf_category *cat, *lastcat = NULL; pdf_res *res, *lastres = NULL; char *name; char *value; char *prefix = NULL; size_t len; int k, absolut; /* We no longer raise an error but silently ignore unknown categories */ k = pdc_get_keycode(category, pdf_rescategories); if (k == PDC_KEY_NOTFOUND) return; rescat = (pdf_rescategory) k; /* Read resource configuration file if it is pending */ if (p->resfilepending) { p->resfilepending = pdc_false; pdf_read_resourcefile(p, p->resourcefilename); } /* Find start of this category's resource list, if the category exists */ for (cat = p->resources; cat != (pdf_category *) NULL; cat = cat->next) { lastcat = cat; if (!strcmp(cat->category, category)) break; } if (cat == NULL) { cat = (pdf_category *) pdc_malloc(p->pdc, sizeof(pdf_category), fn); cat->category = pdc_strdup(p->pdc, category); cat->kids = NULL; cat->next = NULL; if (lastcat) lastcat->next = cat; else p->resources = cat; } /* Determine name and value of resource */ absolut = 0; len = strlen(resource); value = strchr(resource, '='); if (value) { len = (size_t) (value - resource); value++; if (*value == '=') { absolut = 1; value++; } /* file name is assumed */ if (value[0] != '\0' && value[0] == '.' && value[1] == '/') { value += 2; } } /* Copy resource name */ name = (char *) pdc_malloc(p->pdc, len + 1, fn); strncpy(name, resource, len); name[len] = 0; pdc_strtrim(name); /* Find resource name in resource list */ for (res = cat->kids; res != (pdf_res *) NULL; res = res->next) { if (!strcmp(res->name, name)) break; lastres = res; } /* New resource */ if (res) { pdc_free(p->pdc, name); } else { res = (pdf_res *) pdc_calloc(p->pdc, sizeof(pdf_res), fn); if (lastres) lastres->next = res; else cat->kids = res; res->prev = lastres; res->name = name; } /* New value */ if (res->value) pdc_free(p->pdc, res->value); res->value = NULL; if (!value) { value = ""; } else if (!absolut && p->prefix) { /* Directory prefix */ prefix = p->prefix; if (prefix[0] != '\0' && prefix[0] == '.' && prefix[1] == '/') prefix += 2; if (prefix) { len = strlen(prefix) + strlen(value) + 6; res->value = (char *) pdc_malloc(p->pdc, len, fn); pdc_file_fullname(prefix, value, res->value); } } if (!res->value) { res->value = pdc_strdup(p->pdc, value); pdc_str2trim(res->value); } #undef PDF_TEST_RESOURCE #ifdef PDF_TEST_RESOURCE printf("%s.%s: '%s'\n", category, res->name, res->value); #endif switch (rescat) { case pdf_FontOutline: case pdf_FontAFM: case pdf_FontPFM: case pdf_HostFont: case pdf_Encoding: case pdf_ICCProfile: if (!strlen(res->name) || !strlen(res->value)) pdc_error(p->pdc, PDF_E_RES_BADRES, resource, category, 0, 0); break; default: break; } }