fz_error *
pdf_parseindobj(fz_obj **op, fz_stream *file, char *buf, int cap,
int *ooid, int *ogid, int *ostmofs)
{
fz_error *error = nil;
fz_obj *obj = nil;
int oid = 0, gid = 0, stmofs;
int tok, len;
int a, b;
tok = pdf_lex(file, buf, cap, &len);
if (tok != PDF_TINT)
goto cleanup;
oid = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok != PDF_TINT)
goto cleanup;
gid = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok != PDF_TOBJ)
goto cleanup;
tok = pdf_lex(file, buf, cap, &len);
switch (tok)
{
case PDF_TOARRAY: error = pdf_parsearray(&obj, file, buf, cap); break;
case PDF_TODICT: error = pdf_parsedict(&obj, file, buf, cap); break;
case PDF_TNAME: error = fz_newname(&obj, buf); break;
case PDF_TREAL: error = fz_newreal(&obj, atof(buf)); break;
case PDF_TSTRING: error = fz_newstring(&obj, buf, len); break;
case PDF_TTRUE: error = fz_newbool(&obj, 1); break;
case PDF_TFALSE: error = fz_newbool(&obj, 0); break;
case PDF_TNULL: error = fz_newnull(&obj); break;
case PDF_TINT:
a = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok == PDF_TSTREAM || tok == PDF_TENDOBJ)
{
error = fz_newint(&obj, a);
if (error) goto cleanup;
goto skip;
}
if (tok == PDF_TINT)
{
b = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok == PDF_TR)
{
error = fz_newindirect(&obj, a, b);
break;
}
}
goto cleanup;
default:
goto cleanup;
}
if (error) goto cleanup;
tok = pdf_lex(file, buf, cap, &len);
skip:
if (tok == PDF_TSTREAM)
{
int c = fz_readbyte(file);
if (c == '\r')
{
c = fz_peekbyte(file);
if (c != '\n')
fz_warn("syntaxerror: DOS format line ending after stream keyword (%d %d)\n", oid, gid);
else
c = fz_readbyte(file);
}
stmofs = fz_tell(file);
}
else if (tok == PDF_TENDOBJ)
stmofs = 0;
else
goto cleanup;
if (ooid) *ooid = oid;
if (ogid) *ogid = gid;
if (ostmofs) *ostmofs = stmofs;
*op = obj;
return nil;
cleanup:
if (obj) fz_dropobj(obj);
if (error) return error;
return fz_throw("syntaxerror: corrupt indirect object (%d %d)", oid, gid);
}
fz_error *
pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
{
fz_error *error;
pdf_xobject *form;
fz_obj *obj;
if ((*formp = pdf_finditem(xref->store, PDF_KXOBJECT, ref)))
{
pdf_keepxobject(*formp);
return fz_okay;
}
form = fz_malloc(sizeof(pdf_xobject));
if (!form)
return fz_throw("outofmem: xobject struct");
form->refs = 1;
form->resources = nil;
form->contents = nil;
/* Store item immediately, to avoid infinite recursion if contained
objects refer again to this xobject */
error = pdf_storeitem(xref->store, PDF_KXOBJECT, ref, form);
if (error)
{
pdf_dropxobject(form);
return fz_rethrow(error, "cannot store xobject resource");
}
pdf_logrsrc("load xobject %d %d (%p) {\n", fz_tonum(ref), fz_togen(ref), form);
obj = fz_dictgets(dict, "BBox");
form->bbox = pdf_torect(obj);
pdf_logrsrc("bbox [%g %g %g %g]\n",
form->bbox.x0, form->bbox.y0,
form->bbox.x1, form->bbox.y1);
obj = fz_dictgets(dict, "Matrix");
if (obj)
form->matrix = pdf_tomatrix(obj);
else
form->matrix = fz_identity();
pdf_logrsrc("matrix [%g %g %g %g %g %g]\n",
form->matrix.a, form->matrix.b,
form->matrix.c, form->matrix.d,
form->matrix.e, form->matrix.f);
obj = fz_dictgets(dict, "I");
form->isolated = fz_tobool(obj);
obj = fz_dictgets(dict, "K");
form->knockout = fz_tobool(obj);
pdf_logrsrc("isolated %d\n", form->isolated);
pdf_logrsrc("knockout %d\n", form->knockout);
obj = fz_dictgets(dict, "Resources");
if (obj)
{
error = pdf_resolve(&obj, xref);
if (error)
{
fz_dropobj(obj);
error = fz_rethrow(error, "cannot resolve xobject resources");
goto cleanup;
}
error = pdf_loadresources(&form->resources, xref, obj);
fz_dropobj(obj);
if (error)
{
error = fz_rethrow(error, "cannot load xobject resources");
goto cleanup;
}
}
error = pdf_loadstream(&form->contents, xref, fz_tonum(ref), fz_togen(ref));
if (error)
{
error = fz_rethrow(error, "cannot load xobject content stream");
goto cleanup;
}
pdf_logrsrc("stream %d bytes\n", form->contents->wp - form->contents->rp);
pdf_logrsrc("}\n");
*formp = form;
return fz_okay;
cleanup:
pdf_removeitem(xref->store, PDF_KXOBJECT, ref);
pdf_dropxobject(form);
return error;
}
fz_error *
pdf_parsearray(fz_obj **op, fz_stream *file, char *buf, int cap)
{
fz_error *error = nil;
fz_obj *ary = nil;
fz_obj *obj = nil;
int a = 0, b = 0, n = 0;
int tok, len;
error = fz_newarray(op, 4);
if (error) return error;
ary = *op;
while (1)
{
tok = pdf_lex(file, buf, cap, &len);
if (tok != PDF_TINT && tok != PDF_TR)
{
if (n > 0)
{
error = fz_newint(&obj, a);
if (error) goto cleanup;
error = fz_arraypush(ary, obj);
if (error) goto cleanup;
fz_dropobj(obj);
obj = nil;
}
if (n > 1)
{
error = fz_newint(&obj, b);
if (error) goto cleanup;
error = fz_arraypush(ary, obj);
if (error) goto cleanup;
fz_dropobj(obj);
obj = nil;
}
n = 0;
}
if (tok == PDF_TINT && n == 2)
{
error = fz_newint(&obj, a);
if (error) goto cleanup;
error = fz_arraypush(ary, obj);
if (error) goto cleanup;
fz_dropobj(obj);
obj = nil;
a = b;
n --;
}
switch (tok)
{
case PDF_TCARRAY:
return nil;
case PDF_TINT:
if (n == 0)
a = atoi(buf);
if (n == 1)
b = atoi(buf);
n ++;
break;
case PDF_TR:
if (n != 2)
goto cleanup;
error = fz_newindirect(&obj, a, b);
if (error) goto cleanup;
n = 0;
break;
case PDF_TOARRAY: error = pdf_parsearray(&obj, file, buf, cap); break;
case PDF_TODICT: error = pdf_parsedict(&obj, file, buf, cap); break;
case PDF_TNAME: error = fz_newname(&obj, buf); break;
case PDF_TREAL: error = fz_newreal(&obj, atof(buf)); break;
case PDF_TSTRING: error = fz_newstring(&obj, buf, len); break;
case PDF_TTRUE: error = fz_newbool(&obj, 1); break;
case PDF_TFALSE: error = fz_newbool(&obj, 0); break;
case PDF_TNULL: error = fz_newnull(&obj); break;
default: goto cleanup;
}
if (error) goto cleanup;
if (obj)
{
error = fz_arraypush(ary, obj);
if (error) goto cleanup;
fz_dropobj(obj);
}
obj = nil;
}
cleanup:
if (obj) fz_dropobj(obj);
if (ary) fz_dropobj(ary);
if (error) return error;
return fz_throw("syntaxerror: corrupt array");
}
fz_error *
pdf_parsedict(fz_obj **op, fz_stream *file, char *buf, int cap)
{
fz_error *error = nil;
fz_obj *dict = nil;
fz_obj *key = nil;
fz_obj *val = nil;
int tok, len;
int a, b;
error = fz_newdict(op, 8);
if (error) return error;
dict = *op;
while (1)
{
tok = pdf_lex(file, buf, cap, &len);
skip:
if (tok == PDF_TCDICT)
return nil;
/* for BI .. ID .. EI in content streams */
if (tok == PDF_TKEYWORD && !strcmp(buf, "ID"))
return nil;
if (tok != PDF_TNAME)
goto cleanup;
error = fz_newname(&key, buf);
if (error) goto cleanup;
tok = pdf_lex(file, buf, cap, &len);
switch (tok)
{
case PDF_TOARRAY: error = pdf_parsearray(&val, file, buf, cap); break;
case PDF_TODICT: error = pdf_parsedict(&val, file, buf, cap); break;
case PDF_TNAME: error = fz_newname(&val, buf); break;
case PDF_TREAL: error = fz_newreal(&val, atof(buf)); break;
case PDF_TSTRING: error = fz_newstring(&val, buf, len); break;
case PDF_TTRUE: error = fz_newbool(&val, 1); break;
case PDF_TFALSE: error = fz_newbool(&val, 0); break;
case PDF_TNULL: error = fz_newnull(&val); break;
case PDF_TINT:
a = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok == PDF_TCDICT || tok == PDF_TNAME ||
(tok == PDF_TKEYWORD && !strcmp(buf, "ID")))
{
error = fz_newint(&val, a);
if (error) goto cleanup;
error = fz_dictput(dict, key, val);
if (error) goto cleanup;
fz_dropobj(val);
fz_dropobj(key);
key = val = nil;
goto skip;
}
if (tok == PDF_TINT)
{
b = atoi(buf);
tok = pdf_lex(file, buf, cap, &len);
if (tok == PDF_TR)
{
error = fz_newindirect(&val, a, b);
break;
}
}
goto cleanup;
default:
goto cleanup;
}
if (error) goto cleanup;
error = fz_dictput(dict, key, val);
if (error) goto cleanup;
fz_dropobj(val);
fz_dropobj(key);
key = val = nil;
}
cleanup:
if (key) fz_dropobj(key);
if (val) fz_dropobj(val);
if (dict) fz_dropobj(dict);
if (error) return error;
return fz_throw("syntaxerror: corrupt dictionary");
}
void
pdf_loadpagetreenode(pdf_xref *xref, fz_obj *node, struct info info)
{
fz_obj *dict, *kids, *count;
fz_obj *obj, *tmp;
int i, n;
/* prevent infinite recursion */
if (fz_dictgets(node, ".seen"))
return;
kids = fz_dictgets(node, "Kids");
count = fz_dictgets(node, "Count");
if (fz_isarray(kids) && fz_isint(count))
{
obj = fz_dictgets(node, "Resources");
if (obj)
info.resources = obj;
obj = fz_dictgets(node, "MediaBox");
if (obj)
info.mediabox = obj;
obj = fz_dictgets(node, "CropBox");
if (obj)
info.cropbox = obj;
obj = fz_dictgets(node, "Rotate");
if (obj)
info.rotate = obj;
tmp = fz_newnull();
fz_dictputs(node, ".seen", tmp);
fz_dropobj(tmp);
n = fz_arraylen(kids);
for (i = 0; i < n; i++)
{
obj = fz_arrayget(kids, i);
pdf_loadpagetreenode(xref, obj, info);
}
fz_dictdels(node, ".seen");
}
else
{
dict = fz_resolveindirect(node);
if (info.resources && !fz_dictgets(dict, "Resources"))
fz_dictputs(dict, "Resources", info.resources);
if (info.mediabox && !fz_dictgets(dict, "MediaBox"))
fz_dictputs(dict, "MediaBox", info.mediabox);
if (info.cropbox && !fz_dictgets(dict, "CropBox"))
fz_dictputs(dict, "CropBox", info.cropbox);
if (info.rotate && !fz_dictgets(dict, "Rotate"))
fz_dictputs(dict, "Rotate", info.rotate);
if (xref->pagelen == xref->pagecap)
{
fz_warn("found more pages than expected");
xref->pagecap ++;
xref->pagerefs = fz_realloc(xref->pagerefs, sizeof(fz_obj*) * xref->pagecap);
xref->pageobjs = fz_realloc(xref->pageobjs, sizeof(fz_obj*) * xref->pagecap);
}
xref->pagerefs[xref->pagelen] = fz_keepobj(node);
xref->pageobjs[xref->pagelen] = fz_keepobj(dict);
xref->pagelen ++;
}
}
fz_error *
pdf_loadtype3font(pdf_font **fontp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
{
fz_error *error;
char buf[256];
char *estrings[256];
pdf_font *font;
fz_obj *encoding;
fz_obj *widths;
fz_obj *resources;
fz_obj *charprocs;
fz_obj *obj;
int first, last;
int i, k, n;
fz_rect bbox;
obj = fz_dictgets(dict, "Name");
if (obj)
strlcpy(buf, fz_toname(obj), sizeof buf);
else
sprintf(buf, "Unnamed-T3");
font = pdf_newfont(buf);
if (!font)
return fz_throw("outofmem: font struct");
pdf_logfont("load type3 font %d %d (%p) {\n", fz_tonum(ref), fz_togen(ref), font);
pdf_logfont("name %s\n", buf);
font->super.render = t3render;
font->super.drop = (void(*)(fz_font*)) t3dropfont;
obj = fz_dictgets(dict, "FontMatrix");
font->matrix = pdf_tomatrix(obj);
pdf_logfont("matrix [%g %g %g %g %g %g]\n",
font->matrix.a, font->matrix.b,
font->matrix.c, font->matrix.d,
font->matrix.e, font->matrix.f);
obj = fz_dictgets(dict, "FontBBox");
bbox = pdf_torect(obj);
pdf_logfont("bbox [%g %g %g %g]\n",
bbox.x0, bbox.y0,
bbox.x1, bbox.y1);
bbox = fz_transformaabb(font->matrix, bbox);
bbox.x0 = fz_floor(bbox.x0 * 1000);
bbox.y0 = fz_floor(bbox.y0 * 1000);
bbox.x1 = fz_ceil(bbox.x1 * 1000);
bbox.y1 = fz_ceil(bbox.y1 * 1000);
fz_setfontbbox((fz_font*)font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/*
* Encoding
*/
for (i = 0; i < 256; i++)
estrings[i] = nil;
encoding = fz_dictgets(dict, "Encoding");
if (!encoding) {
error = fz_throw("syntaxerror: Type3 font missing Encoding");
goto cleanup;
}
error = pdf_resolve(&encoding, xref);
if (error)
goto cleanup;
if (fz_isname(obj))
pdf_loadencoding(estrings, fz_toname(encoding));
if (fz_isdict(encoding))
{
fz_obj *base, *diff, *item;
base = fz_dictgets(encoding, "BaseEncoding");
if (fz_isname(base))
pdf_loadencoding(estrings, fz_toname(base));
diff = fz_dictgets(encoding, "Differences");
if (fz_isarray(diff))
{
n = fz_arraylen(diff);
k = 0;
for (i = 0; i < n; i++)
{
item = fz_arrayget(diff, i);
if (fz_isint(item))
k = fz_toint(item);
if (fz_isname(item))
estrings[k++] = fz_toname(item);
if (k < 0) k = 0;
if (k > 255) k = 255;
}
}
}
fz_dropobj(encoding);
error = pdf_newidentitycmap(&font->encoding, 0, 1);
if (error)
goto cleanup;
error = pdf_loadtounicode(font, xref,
estrings, nil, fz_dictgets(dict, "ToUnicode"));
if (error)
goto cleanup;
/*
* Widths
*/
fz_setdefaulthmtx((fz_font*)font, 0);
first = fz_toint(fz_dictgets(dict, "FirstChar"));
last = fz_toint(fz_dictgets(dict, "LastChar"));
widths = fz_dictgets(dict, "Widths");
if (!widths) {
error = fz_throw("syntaxerror: Type3 font missing Widths");
goto cleanup;
}
error = pdf_resolve(&widths, xref);
if (error)
goto cleanup;
for (i = first; i <= last; i++)
{
float w = fz_toreal(fz_arrayget(widths, i - first));
w = font->matrix.a * w * 1000.0;
error = fz_addhmtx((fz_font*)font, i, i, w);
if (error) {
fz_dropobj(widths);
goto cleanup;
}
}
fz_dropobj(widths);
error = fz_endhmtx((fz_font*)font);
if (error)
goto cleanup;
/*
* Resources
*/
resources = nil;
obj = fz_dictgets(dict, "Resources");
if (obj)
{
error = pdf_resolve(&obj, xref);
if (error)
goto cleanup;
error = pdf_loadresources(&resources, xref, obj);
fz_dropobj(obj);
if (error)
goto cleanup;
}
else
pdf_logfont("no resource dict!\n");
/*
* CharProcs
*/
charprocs = fz_dictgets(dict, "CharProcs");
if (!charprocs)
{
error = fz_throw("syntaxerror: Type3 font missing CharProcs");
goto cleanup2;
}
error = pdf_resolve(&charprocs, xref);
if (error)
goto cleanup2;
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
obj = fz_dictgets(charprocs, estrings[i]);
if (obj)
{
pdf_logfont("load charproc %s {\n", estrings[i]);
error = loadcharproc(&font->charprocs[i], xref, resources, obj);
if (error)
goto cleanup2;
error = fz_optimizetree(font->charprocs[i]);
if (error)
goto cleanup2;
pdf_logfont("}\n");
}
}
}
fz_dropobj(charprocs);
if (resources)
fz_dropobj(resources);
pdf_logfont("}\n");
*fontp = font;
return fz_okay;
cleanup2:
if (resources)
fz_dropobj(resources);
cleanup:
fz_dropfont((fz_font*)font);
return fz_rethrow(error, "cannot load type3 font");
}
void
cleanmain(int argc, char **argv)
{
int doencrypt = 0;
int dogarbage = 0;
int doexpand = 0;
pdf_crypt *encrypt = nil;
char *infile;
char *outfile = "out.pdf";
char *userpw = "";
char *ownerpw = "";
unsigned perms = 0xfffff0c0; /* nothing allowed */
int keylen = 40;
char *password = "";
fz_error *error;
int c;
while ((c = getopt(argc, argv, "d:egn:o:p:u:x")) != -1)
{
switch (c)
{
case 'p':
/* see TABLE 3.15 User access permissions */
perms = 0xfffff0c0;
if (strchr(optarg, 'p')) /* print */
perms |= (1 << 2) | (1 << 11);
if (strchr(optarg, 'm')) /* modify */
perms |= (1 << 3) | (1 << 10);
if (strchr(optarg, 'c')) /* copy */
perms |= (1 << 4) | (1 << 9);
if (strchr(optarg, 'a')) /* annotate / forms */
perms |= (1 << 5) | (1 << 8);
break;
case 'd': password = optarg; break;
case 'e': doencrypt ++; break;
case 'g': dogarbage ++; break;
case 'n': keylen = atoi(optarg); break;
case 'o': ownerpw = optarg; break;
case 'u': userpw = optarg; break;
case 'x': doexpand ++; break;
default: cleanusage(); break;
}
}
if (argc - optind < 1)
cleanusage();
infile = argv[optind++];
if (argc - optind > 0)
outfile = argv[optind++];
opensrc(infile, password, 0);
if (doencrypt)
{
fz_obj *id = fz_dictgets(src->trailer, "ID");
if (!id)
{
error = fz_packobj(&id, "[(ABCDEFGHIJKLMNOP)(ABCDEFGHIJKLMNOP)]");
if (error)
die(error);
}
else
fz_keepobj(id);
error = pdf_newencrypt(&encrypt, userpw, ownerpw, perms, keylen, id);
if (error)
die(error);
fz_dropobj(id);
}
if (doexpand)
cleanexpand();
if (dogarbage)
{
preloadobjstms();
pdf_garbagecollect(src);
}
error = pdf_savexref(src, outfile, encrypt);
if (error)
die(error);
if (encrypt)
pdf_dropcrypt(encrypt);
pdf_closexref(src);
}
static void saveimage(fz_obj *obj, int num, int gen)
{
pdf_image *img = nil;
fz_obj *ref;
fz_error error;
fz_pixmap *pix;
char name[1024];
FILE *f;
int bpc;
int w;
int h;
int n;
int x;
int y;
ref = fz_newindirect(num, gen, xref);
xref->store = pdf_newstore();
error = pdf_loadimage(&img, xref, ref);
if (error)
die(error);
n = img->super.n;
w = img->super.w;
h = img->super.h;
bpc = img->bpc;
error = fz_newpixmap(&pix, 0, 0, w, h, n + 1);
if (error)
die(error);
error = img->super.loadtile(&img->super, pix);
if (error)
die(error);
if (bpc == 1 && n == 0)
{
fz_pixmap *temp;
error = fz_newpixmap(&temp, pix->x, pix->y, pix->w, pix->h, pdf_devicergb->n + 1);
if (error)
die(error);
for (y = 0; y < pix->h; y++)
for (x = 0; x < pix->w; x++)
{
int pixel = y * pix->w + x;
temp->samples[pixel * temp->n + 0] = 255;
temp->samples[pixel * temp->n + 1] = pix->samples[pixel];
temp->samples[pixel * temp->n + 2] = pix->samples[pixel];
temp->samples[pixel * temp->n + 3] = pix->samples[pixel];
}
fz_droppixmap(pix);
pix = temp;
}
if (img->super.cs && strcmp(img->super.cs->name, "DeviceRGB"))
{
fz_pixmap *temp;
error = fz_newpixmap(&temp, pix->x, pix->y, pix->w, pix->h, pdf_devicergb->n + 1);
if (error)
die(error);
fz_convertpixmap(img->super.cs, pix, pdf_devicergb, temp);
fz_droppixmap(pix);
pix = temp;
}
sprintf(name, "img-%04d.pnm", num);
f = fopen(name, "wb");
if (f == NULL)
die(fz_throw("Error creating image file"));
fprintf(f, "P6\n%d %d\n%d\n", w, h, 255);
for (y = 0; y < pix->h; y++)
for (x = 0; x < pix->w; x++)
{
fz_sample *sample = &pix->samples[(y * pix->w + x) * (pdf_devicergb->n + 1)];
unsigned char r = sample[1];
unsigned char g = sample[2];
unsigned char b = sample[3];
fprintf(f, "%c%c%c", r, g, b);
}
if (fclose(f) < 0)
die(fz_throw("Error closing image file"));
fz_droppixmap(pix);
pdf_dropstore(xref->store);
xref->store = nil;
fz_dropimage(&img->super);
fz_dropobj(ref);
}
static fz_error
fz_repairobj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp, fz_obj **encrypt, fz_obj **id)
{
fz_error error;
int tok;
int stmlen;
int len;
int n;
*stmofsp = 0;
*stmlenp = -1;
stmlen = 0;
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
return fz_rethrow(error, "cannot parse object");
if (tok == PDF_TODICT)
{
fz_obj *dict, *obj;
/* Send nil xref so we don't try to resolve references */
error = pdf_parsedict(&dict, nil, file, buf, cap);
if (error)
return fz_rethrow(error, "cannot parse object");
obj = fz_dictgets(dict, "Type");
if (fz_isname(obj) && !strcmp(fz_toname(obj), "XRef"))
{
obj = fz_dictgets(dict, "Encrypt");
if (obj)
{
if (*encrypt)
fz_dropobj(*encrypt);
*encrypt = fz_keepobj(obj);
}
obj = fz_dictgets(dict, "ID");
if (obj)
{
if (*id)
fz_dropobj(*id);
*id = fz_keepobj(obj);
}
}
obj = fz_dictgets(dict, "Length");
if (fz_isint(obj))
stmlen = fz_toint(obj);
fz_dropobj(dict);
}
while ( tok != PDF_TSTREAM &&
tok != PDF_TENDOBJ &&
tok != PDF_TERROR &&
tok != PDF_TEOF )
{
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
return fz_rethrow(error, "cannot scan for endobj or stream token");
}
if (tok == PDF_TSTREAM)
{
int c = fz_readbyte(file);
if (c == '\r') {
c = fz_peekbyte(file);
if (c == '\n')
fz_readbyte(file);
}
*stmofsp = fz_tell(file);
if (*stmofsp < 0)
return fz_throw("cannot seek in file");
if (stmlen > 0)
{
fz_seek(file, *stmofsp + stmlen, 0);
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
fz_catch(error, "cannot find endstream token, falling back to scanning");
if (tok == PDF_TENDSTREAM)
goto atobjend;
fz_seek(file, *stmofsp, 0);
}
n = fz_read(file, (unsigned char *) buf, 9);
if (n < 0)
return fz_rethrow(n, "cannot read from file");
while (memcmp(buf, "endstream", 9) != 0)
{
c = fz_readbyte(file);
if (c == EOF)
break;
memmove(buf, buf + 1, 8);
buf[8] = c;
}
*stmlenp = fz_tell(file) - *stmofsp - 9;
atobjend:
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
return fz_rethrow(error, "cannot scan for endobj token");
if (tok != PDF_TENDOBJ)
fz_warn("object missing 'endobj' token");
}
return fz_okay;
}
fz_error
pdf_repairxref(pdf_xref *xref, char *buf, int bufsize)
{
fz_error error;
fz_obj *dict, *obj;
fz_obj *length;
fz_obj *encrypt = nil;
fz_obj *id = nil;
fz_obj *root = nil;
fz_obj *info = nil;
struct entry *list = nil;
int listlen;
int listcap;
int maxnum = 0;
int num = 0;
int gen = 0;
int tmpofs, numofs = 0, genofs = 0;
int stmlen, stmofs = 0;
int tok;
int next;
int i, n;
pdf_logxref("repairxref %p\n", xref);
fz_seek(xref->file, 0, 0);
listlen = 0;
listcap = 1024;
list = fz_calloc(listcap, sizeof(struct entry));
/* look for '%PDF' version marker within first kilobyte of file */
n = fz_read(xref->file, (unsigned char *)buf, MAX(bufsize, 1024));
if (n < 0)
{
error = fz_rethrow(n, "cannot read from file");
goto cleanup;
}
fz_seek(xref->file, 0, 0);
for (i = 0; i < n - 4; i++)
{
if (memcmp(buf + i, "%PDF", 4) == 0)
{
fz_seek(xref->file, i, 0);
break;
}
}
while (1)
{
tmpofs = fz_tell(xref->file);
if (tmpofs < 0)
{
error = fz_throw("cannot tell in file");
goto cleanup;
}
error = pdf_lex(&tok, xref->file, buf, bufsize, &n);
if (error)
{
fz_catch(error, "ignoring the rest of the file");
break;
}
if (tok == PDF_TINT)
{
numofs = genofs;
num = gen;
genofs = tmpofs;
gen = atoi(buf);
}
if (tok == PDF_TOBJ)
{
error = fz_repairobj(xref->file, buf, bufsize, &stmofs, &stmlen, &encrypt, &id);
if (error)
{
error = fz_rethrow(error, "cannot parse object (%d %d R)", num, gen);
goto cleanup;
}
pdf_logxref("found object: (%d %d R)\n", num, gen);
if (listlen + 1 == listcap)
{
listcap = (listcap * 3) / 2;
list = fz_realloc(list, listcap, sizeof(struct entry));
}
list[listlen].num = num;
list[listlen].gen = gen;
list[listlen].ofs = numofs;
list[listlen].stmofs = stmofs;
list[listlen].stmlen = stmlen;
listlen ++;
if (num > maxnum)
maxnum = num;
}
/* trailer dictionary */
if (tok == PDF_TODICT)
{
error = pdf_parsedict(&dict, xref, xref->file, buf, bufsize);
if (error)
{
error = fz_rethrow(error, "cannot parse object");
goto cleanup;
}
obj = fz_dictgets(dict, "Encrypt");
if (obj)
{
if (encrypt)
fz_dropobj(encrypt);
encrypt = fz_keepobj(obj);
}
obj = fz_dictgets(dict, "ID");
if (obj)
{
if (id)
fz_dropobj(id);
id = fz_keepobj(obj);
}
obj = fz_dictgets(dict, "Root");
if (obj)
{
if (root)
fz_dropobj(root);
root = fz_keepobj(obj);
}
obj = fz_dictgets(dict, "Info");
if (obj)
{
if (info)
fz_dropobj(info);
info = fz_keepobj(obj);
}
fz_dropobj(dict);
}
if (tok == PDF_TERROR)
fz_readbyte(xref->file);
if (tok == PDF_TEOF)
break;
}
/* make xref reasonable */
pdf_resizexref(xref, maxnum + 1);
for (i = 0; i < listlen; i++)
{
xref->table[list[i].num].type = 'n';
xref->table[list[i].num].ofs = list[i].ofs;
xref->table[list[i].num].gen = list[i].gen;
xref->table[list[i].num].stmofs = list[i].stmofs;
/* corrected stream length */
if (list[i].stmlen >= 0)
{
pdf_logxref("correct stream length %d %d = %d\n",
list[i].num, list[i].gen, list[i].stmlen);
error = pdf_loadobject(&dict, xref, list[i].num, list[i].gen);
if (error)
{
error = fz_rethrow(error, "cannot load stream object (%d %d R)", list[i].num, list[i].gen);
goto cleanup;
}
length = fz_newint(list[i].stmlen);
fz_dictputs(dict, "Length", length);
fz_dropobj(length);
fz_dropobj(dict);
}
}
xref->table[0].type = 'f';
xref->table[0].ofs = 0;
xref->table[0].gen = 65535;
xref->table[0].stmofs = 0;
xref->table[0].obj = nil;
next = 0;
for (i = xref->len - 1; i >= 0; i--)
{
if (xref->table[i].type == 'f')
{
xref->table[i].ofs = next;
if (xref->table[i].gen < 65535)
xref->table[i].gen ++;
next = i;
}
}
/* create a repaired trailer, Root will be added later */
xref->trailer = fz_newdict(5);
obj = fz_newint(maxnum + 1);
fz_dictputs(xref->trailer, "Size", obj);
fz_dropobj(obj);
if (root)
{
fz_dictputs(xref->trailer, "Root", root);
fz_dropobj(root);
}
if (info)
{
fz_dictputs(xref->trailer, "Info", info);
fz_dropobj(info);
}
if (encrypt)
{
if (fz_isindirect(encrypt))
{
/* create new reference with non-nil xref pointer */
obj = fz_newindirect(fz_tonum(encrypt), fz_togen(encrypt), xref);
fz_dropobj(encrypt);
encrypt = obj;
}
fz_dictputs(xref->trailer, "Encrypt", encrypt);
fz_dropobj(encrypt);
}
if (id)
{
if (fz_isindirect(id))
{
/* create new reference with non-nil xref pointer */
obj = fz_newindirect(fz_tonum(id), fz_togen(id), xref);
fz_dropobj(id);
id = obj;
}
fz_dictputs(xref->trailer, "ID", id);
fz_dropobj(id);
}
fz_free(list);
return fz_okay;
cleanup:
if (encrypt) fz_dropobj(encrypt);
if (id) fz_dropobj(id);
if (root) fz_dropobj(root);
if (info) fz_dropobj(info);
fz_free(list);
return error; /* already rethrown */
}
/* TODO error cleanup */
fz_error *
pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
{
fz_error *error;
pdf_image *img;
pdf_image *mask;
int ismask;
fz_obj *obj;
fz_obj *sub;
int i;
int w, h, bpc;
int n = 0;
int a = 0;
int usecolorkey = 0;
fz_colorspace *cs = nil;
pdf_indexed *indexed = nil;
int stride;
#ifndef PSP
printf("LI\n");
#endif
if ((*imgp = pdf_finditem(xref->store, PDF_KIMAGE, ref)))
{
fz_keepimage((fz_image*)*imgp);
return nil;
}
img = fz_malloc(sizeof(pdf_image));
if (!img)
return fz_outofmem;
img->super.refs = 0;
pdf_logimage("load image %d %d (%p) {\n", fz_tonum(ref), fz_togen(ref), img);
/*
* Dimensions, BPC and ColorSpace
*/
w = fz_toint(fz_dictgets(dict, "Width"));
h = fz_toint(fz_dictgets(dict, "Height"));
bpc = fz_toint(fz_dictgets(dict, "BitsPerComponent"));
pdf_logimage("size %dx%d %d\n", w, h, bpc);
cs = nil;
obj = fz_dictgets(dict, "ColorSpace");
if (obj)
{
cs = pdf_finditem(xref->store, PDF_KCOLORSPACE, obj);
if (cs)
fz_keepcolorspace(cs);
else
{
error = pdf_resolve(&obj, xref);
if (error)
return error;
error = pdf_loadcolorspace(&cs, xref, obj);
if (error)
return error;
fz_dropobj(obj);
}
if (!strcmp(cs->name, "Indexed"))
{
pdf_logimage("indexed\n");
indexed = (pdf_indexed*)cs;
cs = indexed->base;
}
n = cs->n;
a = 0;
pdf_logimage("colorspace %s\n", cs->name);
}
/*
* ImageMask, Mask and SoftMask
*/
mask = nil;
ismask = fz_tobool(fz_dictgets(dict, "ImageMask"));
if (ismask)
{
pdf_logimage("is mask\n");
bpc = 1;
n = 0;
a = 1;
}
obj = fz_dictgets(dict, "SMask");
if (fz_isindirect(obj))
{
pdf_logimage("has soft mask\n");
error = pdf_loadindirect(&sub, xref, obj);
if (error)
return error;
error = pdf_loadimage(&mask, xref, sub, obj);
if (error)
return error;
if (mask->super.cs != pdf_devicegray)
return fz_throw("syntaxerror: SMask must be DeviceGray");
mask->super.cs = 0;
mask->super.n = 0;
mask->super.a = 1;
fz_dropobj(sub);
}
obj = fz_dictgets(dict, "Mask");
if (fz_isindirect(obj))
{
error = pdf_loadindirect(&sub, xref, obj);
if (error)
return error;
if (fz_isarray(sub))
{
usecolorkey = 1;
loadcolorkey(img->colorkey, bpc, indexed != nil, sub);
}
else
{
pdf_logimage("has mask\n");
error = pdf_loadimage(&mask, xref, sub, obj);
if (error)
return error;
}
fz_dropobj(sub);
}
else if (fz_isarray(obj))
{
usecolorkey = 1;
loadcolorkey(img->colorkey, bpc, indexed != nil, obj);
}
/*
* Decode
*/
obj = fz_dictgets(dict, "Decode");
if (fz_isarray(obj))
{
pdf_logimage("decode array\n");
if (indexed)
for (i = 0; i < 2; i++)
img->decode[i] = fz_toreal(fz_arrayget(obj, i));
else
for (i = 0; i < (n + a) * 2; i++)
img->decode[i] = fz_toreal(fz_arrayget(obj, i));
}
else
{
if (indexed)
for (i = 0; i < 2; i++)
img->decode[i] = i & 1 ? (1 << bpc) - 1 : 0;
else
for (i = 0; i < (n + a) * 2; i++)
img->decode[i] = i & 1;
}
/*
* Load samples
*/
if (indexed)
stride = (w * bpc + 7) / 8;
else
stride = (w * (n + a) * bpc + 7) / 8;
// ccm
// do not load images larger than 2MB uncompressed
int early_reject = 0;
if (h * stride <= 2*1024*1024) {
error = pdf_loadstream(&img->samples, xref, fz_tonum(ref), fz_togen(ref));
if (error)
{
/* TODO: colorspace? */
fz_free(img);
return error;
}
if (img->samples->wp - img->samples->bp < stride * h)
{
/* TODO: colorspace? */
fz_dropbuffer(img->samples);
fz_free(img);
return fz_throw("syntaxerror: truncated image data");
}
/* 0 means opaque and 1 means transparent, so we invert to get alpha */
if (ismask)
{
unsigned char *p;
for (p = img->samples->bp; p < img->samples->ep; p++)
*p = ~*p;
}
} else {
#ifndef PSP
printf("LI - %p - early reject\n", img);
#endif
img->samples = nil;
early_reject = 1;
}
/*
* Create image object
*/
img->super.loadtile = pdf_loadtile;
img->super.drop = pdf_dropimage;
img->super.cs = cs;
img->super.w = w;
img->super.h = h;
img->super.n = n;
img->super.a = a;
img->indexed = indexed;
img->stride = stride;
img->bpc = bpc;
img->mask = (fz_image*)mask;
img->usecolorkey = usecolorkey;
if (img->mask)
fz_keepimage(img->mask);
// ccm
#if 1
int bs = 0;
if (img->samples)
bs = (int)(img->samples->wp) - (int)(img->samples->rp);
if (early_reject || (image_buffers_size + bs >= image_buffers_size_max)) {
#ifndef PSP
printf("LI - %p - optimized out\n", img);
#endif
if (img->samples)
fz_dropbuffer(img->samples);
if (img->mask)
fz_dropimage(img->mask);
fz_newbuffer(&img->samples, 8);
img->super.w = 1;
img->super.h = 1;
img->super.n = 3;
img->super.a = 0;
img->super.refs = 0;
unsigned char *p;
for (p = img->samples->bp; p < img->samples->ep; p++)
*p = 0x7f;
img->indexed = 0;
img->stride = (1 * (3 + 0) * 8 + 7) / 8; //(w * (n + a) * bpc + 7) / 8;
img->super.cs = cs;
img->super.loadtile = fakeImageTile;
img->bpc = 8;
img->mask = NULL;
img->usecolorkey = 0;
} else {
image_buffers_size += bs;
}
#endif
pdf_logimage("}\n");
error = pdf_storeitem(xref->store, PDF_KIMAGE, ref, img);
if (error)
{
fz_dropimage((fz_image*)img);
return error;
}
*imgp = img;
return nil;
}
fz_error
pdf_loadobjstm(pdf_xref *xref, int oid, int gen, char *buf, int cap)
{
fz_error error;
fz_stream *stm;
fz_obj *objstm;
int *oidbuf;
int *ofsbuf;
fz_obj *obj;
int first;
int count;
int i, n;
pdf_token_e tok;
pdf_logxref("loadobjstm (%d %d R)\n", oid, gen);
error = pdf_loadobject(&objstm, xref, oid, gen);
if (error)
return fz_rethrow(error, "cannot load object stream object");
count = fz_toint(fz_dictgets(objstm, "N"));
first = fz_toint(fz_dictgets(objstm, "First"));
pdf_logxref(" count %d\n", count);
oidbuf = fz_malloc(count * sizeof(int));
if (!oidbuf)
{
error = fz_rethrow(-1, "out of memory: object id buffer");
goto cleanupobj;
}
ofsbuf = fz_malloc(count * sizeof(int));
if (!ofsbuf)
{
error = fz_rethrow(-1, "out of memory: offset buffer");
goto cleanupoid;
}
error = pdf_openstream(&stm, xref, oid, gen);
if (error)
{
error = fz_rethrow(error, "cannot open object stream");
goto cleanupofs;
}
for (i = 0; i < count; i++)
{
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TINT)
{
error = fz_rethrow(error, "corrupt object stream");
goto cleanupstm;
}
oidbuf[i] = atoi(buf);
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TINT)
{
error = fz_rethrow(error, "corrupt object stream");
goto cleanupstm;
}
ofsbuf[i] = atoi(buf);
}
error = fz_seek(stm, first, 0);
if (error)
{
error = fz_rethrow(error, "cannot seek in object stream");
goto cleanupstm;
}
for (i = 0; i < count; i++)
{
/* FIXME: seek to first + ofsbuf[i] */
error = pdf_parsestmobj(&obj, xref, stm, buf, cap);
if (error)
{
error = fz_rethrow(error, "cannot parse object %d in stream", i);
goto cleanupstm;
}
if (oidbuf[i] < 1 || oidbuf[i] >= xref->len)
{
fz_dropobj(obj);
error = fz_throw("object id (%d 0 R) out of range (0..%d)", oidbuf[i], xref->len - 1);
goto cleanupstm;
}
if (xref->table[oidbuf[i]].obj)
fz_dropobj(xref->table[oidbuf[i]].obj);
xref->table[oidbuf[i]].obj = obj;
}
fz_dropstream(stm);
fz_free(ofsbuf);
fz_free(oidbuf);
fz_dropobj(objstm);
return fz_okay;
cleanupstm:
fz_dropstream(stm);
cleanupofs:
fz_free(ofsbuf);
cleanupoid:
fz_free(oidbuf);
cleanupobj:
fz_dropobj(objstm);
return error; /* already rethrown */
}
static fz_error
readnewxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
{
fz_error error;
fz_stream *stm;
fz_obj *trailer;
fz_obj *index;
fz_obj *obj;
int oid, gen, stmofs;
int size, w0, w1, w2;
int t;
pdf_logxref("load new xref format\n");
error = pdf_parseindobj(&trailer, xref, xref->file, buf, cap, &oid, &gen, &stmofs);
if (error)
return fz_rethrow(error, "cannot parse compressed xref stream object");
if (oid < 0 || oid >= xref->len)
{
if (oid == xref->len && oid < xref->cap)
{
/* allow broken pdf files that have off-by-one errors in the xref */
fz_warn("object id (%d %d R) out of range (0..%d)", oid, gen, xref->len - 1);
xref->len ++;
}
else
{
fz_dropobj(trailer);
return fz_throw("object id (%d %d R) out of range (0..%d)", oid, gen, xref->len - 1);
}
}
xref->table[oid].type = 'n';
xref->table[oid].gen = gen;
xref->table[oid].obj = fz_keepobj(trailer);
xref->table[oid].stmofs = stmofs;
xref->table[oid].ofs = 0;
obj = fz_dictgets(trailer, "Size");
if (!obj)
{
fz_dropobj(trailer);
return fz_throw("xref stream missing Size entry");
}
size = fz_toint(obj);
obj = fz_dictgets(trailer, "W");
if (!obj) {
fz_dropobj(trailer);
return fz_throw("xref stream missing W entry");
}
w0 = fz_toint(fz_arrayget(obj, 0));
w1 = fz_toint(fz_arrayget(obj, 1));
w2 = fz_toint(fz_arrayget(obj, 2));
index = fz_dictgets(trailer, "Index");
error = pdf_openstream(&stm, xref, oid, gen);
if (error)
{
fz_dropobj(trailer);
return fz_rethrow(error, "cannot open compressed xref stream");
}
if (!index)
{
error = readnewxrefsection(xref, stm, 0, size, w0, w1, w2);
if (error)
{
fz_dropstream(stm);
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read xref stream");
}
}
else
{
for (t = 0; t < fz_arraylen(index); t += 2)
{
int i0 = fz_toint(fz_arrayget(index, t + 0));
int i1 = fz_toint(fz_arrayget(index, t + 1));
error = readnewxrefsection(xref, stm, i0, i1, w0, w1, w2);
if (error)
{
fz_dropstream(stm);
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read xref stream section");
}
}
}
fz_dropstream(stm);
*trailerp = trailer;
return fz_okay;
}
fz_error
pdf_parsearray(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap)
{
fz_error error = fz_okay;
fz_obj *ary = nil;
fz_obj *obj = nil;
int a = 0, b = 0, n = 0;
pdf_token_e tok;
int len;
ary = fz_newarray(4);
while (1)
{
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
{
fz_dropobj(ary);
return fz_rethrow(error, "cannot parse array");
}
if (tok != PDF_TINT && tok != PDF_TR)
{
if (n > 0)
{
obj = fz_newint(a);
fz_arraypush(ary, obj);
fz_dropobj(obj);
}
if (n > 1)
{
obj = fz_newint(b);
fz_arraypush(ary, obj);
fz_dropobj(obj);
}
n = 0;
}
if (tok == PDF_TINT && n == 2)
{
obj = fz_newint(a);
fz_arraypush(ary, obj);
fz_dropobj(obj);
a = b;
n --;
}
switch (tok)
{
case PDF_TCARRAY:
*op = ary;
return fz_okay;
case PDF_TINT:
if (n == 0)
a = atoi(buf);
if (n == 1)
b = atoi(buf);
n ++;
break;
case PDF_TR:
if (n != 2)
{
fz_dropobj(ary);
return fz_throw("cannot parse indirect reference in array");
}
obj = fz_newindirect(a, b, xref);
fz_arraypush(ary, obj);
fz_dropobj(obj);
n = 0;
break;
case PDF_TOARRAY:
error = pdf_parsearray(&obj, xref, file, buf, cap);
if (error)
{
fz_dropobj(ary);
return fz_rethrow(error, "cannot parse array");
}
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TODICT:
error = pdf_parsedict(&obj, xref, file, buf, cap);
if (error)
{
fz_dropobj(ary);
return fz_rethrow(error, "cannot parse array");
}
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TNAME:
obj = fz_newname(buf);
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TREAL:
obj = fz_newreal(atof(buf));
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TSTRING:
obj = fz_newstring(buf, len);
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TTRUE:
obj = fz_newbool(1);
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TFALSE:
obj = fz_newbool(0);
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
case PDF_TNULL:
obj = fz_newnull();
fz_arraypush(ary, obj);
fz_dropobj(obj);
break;
default:
fz_dropobj(ary);
return fz_rethrow(error, "cannot parse token in array");
}
}
}
void
editflushcatalog(void)
{
fz_error *error;
int rootnum, rootgen;
int listnum, listgen;
fz_obj *listref;
fz_obj *obj;
int i;
/* Create page tree and add back-links */
error = pdf_allocobject(editxref, &listnum, &listgen);
if (error)
die(error);
error = fz_packobj(&obj, "<</Type/Pages/Count %i/Kids %o>>",
fz_arraylen(editpagelist),
editpagelist);
if (error)
die(error);
pdf_updateobject(editxref, listnum, listgen, obj);
fz_dropobj(obj);
error = fz_newindirect(&listref, listnum, listgen);
if (error)
die(error);
for (i = 0; i < fz_arraylen(editpagelist); i++)
{
int num = fz_tonum(fz_arrayget(editpagelist, i));
int gen = fz_togen(fz_arrayget(editpagelist, i));
error = pdf_loadobject(&obj, editxref, num, gen);
if (error)
die(error);
error = fz_dictputs(obj, "Parent", listref);
if (error)
die(error);
pdf_updateobject(editxref, num, gen, obj);
fz_dropobj(obj);
}
/* Create catalog */
error = pdf_allocobject(editxref, &rootnum, &rootgen);
if (error)
die(error);
error = fz_packobj(&obj, "<</Type/Catalog/Pages %r>>", listnum, listgen);
if (error)
die(error);
pdf_updateobject(editxref, rootnum, rootgen, obj);
fz_dropobj(obj);
/* Create trailer */
error = fz_packobj(&editxref->trailer, "<</Root %r>>", rootnum, rootgen);
if (error)
die(error);
}
fz_error
pdf_parsedict(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap)
{
fz_error error = fz_okay;
fz_obj *dict = nil;
fz_obj *key = nil;
fz_obj *val = nil;
pdf_token_e tok;
int len;
int a, b;
dict = fz_newdict(8);
while (1)
{
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
{
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
skip:
if (tok == PDF_TCDICT)
{
*op = dict;
return fz_okay;
}
/* for BI .. ID .. EI in content streams */
if (tok == PDF_TKEYWORD && !strcmp(buf, "ID"))
{
*op = dict;
return fz_okay;
}
if (tok != PDF_TNAME)
{
fz_dropobj(dict);
return fz_throw("invalid key in dict");;
}
key = fz_newname(buf);
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
{
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
switch (tok)
{
case PDF_TOARRAY:
error = pdf_parsearray(&val, xref, file, buf, cap);
if (error)
{
fz_dropobj(key);
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
break;
case PDF_TODICT:
error = pdf_parsedict(&val, xref, file, buf, cap);
if (error)
{
fz_dropobj(key);
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
break;
case PDF_TNAME: val = fz_newname(buf); break;
case PDF_TREAL: val = fz_newreal(atof(buf)); break;
case PDF_TSTRING: val = fz_newstring(buf, len); break;
case PDF_TTRUE: val = fz_newbool(1); break;
case PDF_TFALSE: val = fz_newbool(0); break;
case PDF_TNULL: val = fz_newnull(); break;
case PDF_TINT:
a = atoi(buf);
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
{
fz_dropobj(key);
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
if (tok == PDF_TCDICT || tok == PDF_TNAME ||
(tok == PDF_TKEYWORD && !strcmp(buf, "ID")))
{
val = fz_newint(a);
fz_dictput(dict, key, val);
fz_dropobj(val);
fz_dropobj(key);
goto skip;
}
if (tok == PDF_TINT)
{
b = atoi(buf);
error = pdf_lex(&tok, file, buf, cap, &len);
if (error)
{
fz_dropobj(key);
fz_dropobj(dict);
return fz_rethrow(error, "cannot parse dict");
}
if (tok == PDF_TR)
{
val = fz_newindirect(a, b, xref);
break;
}
}
fz_dropobj(key);
fz_dropobj(dict);
return fz_throw("invalid indirect reference in dict");
default:
return fz_throw("unknown token in dict");
}
fz_dictput(dict, key, val);
fz_dropobj(val);
fz_dropobj(key);
}
}
fz_error *
pdf_loadlink(pdf_link **linkp, pdf_xref *xref, fz_obj *dict)
{
fz_error *error;
pdf_link *link;
fz_obj *dest;
fz_obj *action;
fz_obj *obj;
fz_rect bbox;
pdf_linkkind kind;
pdf_logpage("load link {\n");
link = nil;
dest = nil;
obj = fz_dictgets(dict, "Rect");
if (obj)
{
bbox = pdf_torect(obj);
pdf_logpage("rect [%g %g %g %g]\n",
bbox.x0, bbox.y0,
bbox.x1, bbox.y1);
}
else
bbox = fz_emptyrect;
obj = fz_dictgets(dict, "Dest");
if (obj)
{
error = pdf_resolve(&obj, xref);
if (error)
return error;
dest = resolvedest(xref, obj);
pdf_logpage("dest %d %d R\n", fz_tonum(dest), fz_togen(dest));
fz_dropobj(obj);
}
kind = PDF_LUNKNOWN;
action = fz_dictgets(dict, "A");
if (action)
{
error = pdf_resolve(&action, xref);
if (error)
return error;
obj = fz_dictgets(action, "S");
if (!strcmp(fz_toname(obj), "GoTo"))
{
kind = PDF_LGOTO;
dest = resolvedest(xref, fz_dictgets(action, "D"));
pdf_logpage("action goto %d %d R\n", fz_tonum(dest), fz_togen(dest));
}
else if (!strcmp(fz_toname(obj), "URI"))
{
kind = PDF_LURI;
dest = fz_dictgets(action, "URI");
pdf_logpage("action uri %s\n", fz_tostrbuf(dest));
}
else
pdf_logpage("action ... ?\n");
fz_dropobj(action);
}
pdf_logpage("}\n");
if (dest)
{
error = pdf_newlink(&link, bbox, dest, kind);
if (error)
return error;
*linkp = link;
}
return nil;
}
