Attachment #500936 for bug #629710




        free(checksum);
    }
    if (pdf_doc->doc == NULL) {
        docmemstream = new MemStream( docstream,0,streamsize, Object(objNull) );
        doc = new PDFDoc(docmemstream); /* takes ownership of docmemstream */
        pdf_doc->pc++;
        if (!doc->isOk() || !doc->okToPrint()) {

    Object obj1;
    pdf_begin_array(pdf);
    for (i = 0, l = array->getLength(); i < l; ++i) {
        obj1 = array->getNF(i);
        copyObject(pdf, pdf_doc, &obj1);
        obj1.free();
    }
    pdf_end_array(pdf);
}

    pdf_begin_dict(pdf);
    for (i = 0, l = dict->getLength(); i < l; ++i) {
        copyName(pdf, dict->getKey(i));
        obj1 = dict->getValNF(i);
        copyObject(pdf, pdf_doc, &obj1);
        obj1.free();
    }
    pdf_end_dict(pdf);
}

    PDFDoc *doc = pdf_doc->doc;
    xref = doc->getXRef();
    for (r = pdf_doc->inObjList; r != NULL;) {
        obj1 = xref->fetch(r->ref.num, r->ref.gen);
        if (obj1.isStream())
            pdf_begin_obj(pdf, r->num, OBJSTM_NEVER);
        else
            pdf_begin_obj(pdf, r->num, 2);
        copyObject(pdf, pdf_doc, &obj1);
        obj1.free();
        pdf_end_obj(pdf);
        n = r->next;
        delete r;

    catalog = doc->getCatalog();
    page = catalog->getPage(img_pagenum(idict));
    pageref = catalog->getPageRef(img_pagenum(idict));
    pageobj = doc->getXRef()->fetch(pageref->num, pageref->gen);
    pageDict = pageobj.getDict();
    /* write the Page header */
    pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);

        pdf_dict_add_int(pdf, "PTEX.PageNumber", (int) img_pagenum(idict));
    }
    if ((suppress_optional_info & 8) == 0) {
        obj1 = doc->getDocInfoNF();
        if (obj1.isRef()) {
            /* the info dict must be indirect (PDF Ref p. 61) */
            pdf_dict_add_ref(pdf, "PTEX.InfoDict", addInObj(pdf, pdf_doc, obj1.getRef()));
        }
        obj1.free();
    }
    if (img_is_bbox(idict)) {
        bbox[0] = sp2bp(img_bbox(idict)[0]);

        Now all relevant parts of the Page dictionary are copied. Metadata validity
        check is needed(as a stream it must be indirect).
    */
    obj1 = pageDict->lookupNF("Metadata");
    if (!obj1.isNull() && !obj1.isRef())
        formatted_warning("pdf inclusion","/Metadata must be indirect object");
    obj1.free();
    /* copy selected items in Page dictionary */
    for (i = 0; pagedictkeys[i] != NULL; i++) {
        obj1 = pageDict->lookupNF(pagedictkeys[i]);
        if (!obj1.isNull()) {
            pdf_add_name(pdf, pagedictkeys[i]);
            /* preserves indirection */
            copyObject(pdf, pdf_doc, &obj1);
        }
        obj1.free();
    }
    /*
        If there are no Resources in the Page dict of the embedded page,

        PDF file, climbing up the tree until the Resources are found.
        (This fixes a problem with Scribus 1.3.3.14.)
    */
    obj1 = pageDict->lookupNF("Resources");
    if (obj1.isNull()) {
        op1 = &pagesobj1;
        op2 = &pagesobj2;
        *op1 = pageDict->lookup("Parent");
        while (op1->isDict()) {
            obj1 = op1->dictLookupNF("Resources");
            op1->dictLookupNF("Resources", &obj1);
            if (!obj1.isNull()) {
                pdf_add_name(pdf, "Resources");
                copyObject(pdf, pdf_doc, &obj1);
                break;
            }
            *op2 = op1->dictLookup("Parent");
            optmp = op1;
            op1 = op2;
            op2 = optmp;
            op2->free();
        };
        if (!op1->isDict())
            formatted_warning("pdf inclusion","Page /Resources missing");
        op1->free();
    }
    obj1.free();
    /* Write the Page contents. */
    contents = page->getContents();
    if (contents.isStream()) {
        /*
            Variant A: get stream and recompress under control of \pdfcompresslevel


            Variant B: copy stream without recompressing
        */
        obj1 = contents.streamGetDict()->lookup("F");
        if (!obj1.isNull()) {
            normal_error("pdf inclusion","unsupported external stream");
        }
        obj1 = contents.streamGetDict()->lookup("Length");
        contents.streamGetDict()->lookup("Length", &obj1);
        pdf_add_name(pdf, "Length");
        copyObject(pdf, pdf_doc, &obj1);
        obj1 = contents.streamGetDict()->lookup("Filter");
        contents.streamGetDict()->lookup("Filter", &obj1);
        if (!obj1.isNull()) {
            pdf_add_name(pdf, "Filter");
            copyObject(pdf, pdf_doc, &obj1);
            obj1 = contents.streamGetDict()->lookup("DecodeParms");
            contents.streamGetDict()->lookup("DecodeParms", &obj1);
            if (!obj1.isNull()) {
                pdf_add_name(pdf, "DecodeParms");
                copyObject(pdf, pdf_doc, &obj1);
            }
        }
        obj1.free();
        pdf_end_dict(pdf);
        pdf_begin_stream(pdf);
        copyStreamStream(pdf, contents.getStream()->getUndecodedStream());

        pdf_end_dict(pdf);
        pdf_begin_stream(pdf);
        for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {
            obj1 = contents.arrayGet(i);
            copyStreamStream(pdf, obj1.getStream());
            if (i < (l - 1)) {
                /*
                    Put a space between streams to be on the safe side (streams

    }
    /* write out all indirect objects */
    writeRefs(pdf, pdf_doc);
    contents.free();
    pageobj.free();
    /*
        unrefPdfDocument() must come after contents.free() and pageobj.free()!
        TH: The next line makes repeated pdf inclusion unacceptably slow




        pdfdoc_changed_error(L);                               \
    uout = new_Object_userdata(L);                             \
    uout->d = new Object();                                    \
    *((Object *)uout->d) = ((in *) uin->d)->function();                  \
    uout->atype = ALLOC_LEPDF;                                 \
    uout->pc = uin->pc;                                        \
    uout->pd = uin->pd;                                        \


static int m_Array_incRef(lua_State * L)
{
    int i;
    udstruct *uin;
    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    lua_pushinteger(L, 1);
    lua_pushinteger(L, i);
    return 1;
}


    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    lua_pushinteger(L, 1);
    lua_pushinteger(L, i);
    return 1;
}


    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
        || (uobj->pd != NULL && uobj->pd->pc != uobj->pc))
        pdfdoc_changed_error(L);
    ((Array *) uin->d)->add(std::move(*((Object *) uobj->d)));
    return 0;
}


    if (i > 0 && i <= len) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Array *) uin->d)->get(i - 1);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

    if (i > 0 && i <= len) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Array *) uin->d)->getNF(i - 1);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;


static int m_Dict_incRef(lua_State * L)
{
    int i;
    udstruct *uin;
    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    lua_pushinteger(L, 1);
    lua_pushinteger(L, i);
    return 1;
}

static int m_Dict_decRef(lua_State * L)
{
    int i;
    udstruct *uin;
    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    lua_pushinteger(L, 1);
    lua_pushinteger(L, i);
    return 1;
}


        pdfdoc_changed_error(L);
    s = copyString(luaL_checkstring(L, 2));
    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
    ((Dict *) uin->d)->add(s, std::move(*((Object *) uobj->d)));
    return 0;
}


        pdfdoc_changed_error(L);
    s = luaL_checkstring(L, 2);
    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
    ((Dict *) uin->d)->set(s, std::move(*((Object *) uobj->d)));
    return 0;
}


    s = luaL_checkstring(L, 2);
    uout = new_Object_userdata(L);
    uout->d = new Object();
    *((Object *) uout->d) = ((Dict *) uin->d)->lookup(s);
    uout->atype = ALLOC_LEPDF;
    uout->pc = uin->pc;
    uout->pd = uin->pd;

    s = luaL_checkstring(L, 2);
    uout = new_Object_userdata(L);
    uout->d = new Object();
    *((Object *) uout->d) = ((Dict *) uin->d)->lookupNF(s);
    uout->atype = ALLOC_LEPDF;
    uout->pc = uin->pc;
    uout->pd = uin->pd;

    if (i > 0 && i <= len) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Dict *) uin->d)->getVal(i - 1);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

    if (i > 0 && i <= len) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Dict *) uin->d)->getValNF(i - 1);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

        pdfdoc_changed_error(L);
    luaL_checktype(L, 2, LUA_TBOOLEAN);
    if (lua_toboolean(L, 2) != 0)
        *((Object *) uin->d) = Object(gTrue);
    else
        *((Object *) uin->d) = Object(gFalse);
    return 0;
}


    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    i = luaL_checkint(L, 2);
    *((Object *) uin->d) = Object(i);
    return 0;
}


    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    d = luaL_checknumber(L, 2);
    *((Object *) uin->d) = Object(d);
    return 0;
}


        pdfdoc_changed_error(L);
    s = luaL_checklstring(L, 2, &len);
    gs = new GooString(s, len);
    *((Object *) uin->d) = Object(gs);
    return 0;
}


    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    s = luaL_checkstring(L, 2);
    *((Object *) uin->d) = Object(objName, s);
    return 0;
}


    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    *((Object *) uin->d) = Object(objNull);
    return 0;
}

static int m_Object_initArray(lua_State * L)
{
    udstruct *uin, *uxref;
    Array *a;
    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
    uxref = (udstruct *) luaL_checkudata(L, 2, M_XRef);
    if (uin->pd != NULL && uxref->pd != NULL && uin->pd != uxref->pd)

    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
        || (uxref->pd != NULL && uxref->pd->pc != uxref->pc))
        pdfdoc_changed_error(L);
    a = new Array((XRef *) uxref->d);
    *((Object *) uin->d) = Object(a);
    return 0;
}


static int m_Object_initDict(lua_State * L)
{
    udstruct *uin, *uxref;
    Dict *d;
    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
    uxref = (udstruct *) luaL_checkudata(L, 2, M_XRef);
    if (uin->pd != NULL && uxref->pd != NULL && uin->pd != uxref->pd)

    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
        || (uxref->pd != NULL && uxref->pd->pc != uxref->pc))
        pdfdoc_changed_error(L);
    d = new Dict((XRef *) uxref->d);
    *((Object *) uin->d) = Object(d);
    return 0;
}


    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
        || (ustream->pd != NULL && ustream->pd->pc != ustream->pc))
        pdfdoc_changed_error(L);
    *((Object *) uin->d) = Object((Stream *) ustream->d);
    return 0;
}


        pdfdoc_changed_error(L);
    num = luaL_checkint(L, 2);
    gen = luaL_checkint(L, 3);
    *((Object *) uin->d) = Object(num, gen);
    return 0;
}


    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    s = luaL_checkstring(L, 2);
    *((Object *) uin->d) = Object(objCmd, CHARP_CAST s);
    return 0;
}


    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    *((Object *) uin->d) = Object(objError);
    return 0;
}


    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
    if (uin->pd != NULL && uin->pd->pc != uin->pc)
        pdfdoc_changed_error(L);
    *((Object *) uin->d) = Object(objEOF);
    return 0;
}


        pdfdoc_changed_error(L);
    uout = new_Object_userdata(L);
    uout->d = new Object();
    *((Object *) uout->d) = ((Object *) uin->d)->fetch((XRef *) uxref->d);
    uout->atype = ALLOC_LEPDF;
    uout->pc = uin->pc;
    uout->pd = uin->pd;

        pdfdoc_changed_error(L);
    if (!((Object *) uin->d)->isArray())
        luaL_error(L, "Object is not an Array");
    ((Object *) uin->d)->arrayAdd(std::move(*((Object *) uobj->d)));
    return 0;
}


        if (i > 0 && i <= len) {
            uout = new_Object_userdata(L);
            uout->d = new Object();
            *((Object *) uout->d) = ((Object *) uin->d)->arrayGet(i - 1);
            uout->atype = ALLOC_LEPDF;
            uout->pc = uin->pc;
            uout->pd = uin->pd;

        if (i > 0 && i <= len) {
            uout = new_Object_userdata(L);
            uout->d = new Object();
            *((Object *) uout->d) = ((Object *) uin->d)->arrayGetNF(i - 1);
            uout->atype = ALLOC_LEPDF;
            uout->pc = uin->pc;
            uout->pd = uin->pd;

        pdfdoc_changed_error(L);
    if (!((Object *) uin->d)->isDict())
        luaL_error(L, "Object is not a Dict");
    ((Object *) uin->d)->dictAdd(copyString(s), std::move(*((Object *) uobj->d)));
    return 0;
}


        pdfdoc_changed_error(L);
    if (!((Object *) uin->d)->isDict())
        luaL_error(L, "Object is not a Dict");
    ((Object *) uin->d)->dictSet(s, std::move(*((Object *) uobj->d)));
    return 0;
}


    if (((Object *) uin->d)->isDict()) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Object *) uin->d)->dictLookup(s);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

    if (((Object *) uin->d)->isDict()) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((Object *) uin->d)->dictLookupNF(s);
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

        if (i > 0 && i <= len) {
            uout = new_Object_userdata(L);
            uout->d = new Object();
	    *((Object *) uout->d) = ((Object *) uin->d)->dictGetVal(i - 1);
            uout->atype = ALLOC_LEPDF;
            uout->pc = uin->pc;
            uout->pd = uin->pd;

        if (i > 0 && i <= len) {
            uout = new_Object_userdata(L);
            uout->d = new Object();
            *((Object *) uout->d) = ((Object *) uin->d)->dictGetValNF(i - 1);
            uout->atype = ALLOC_LEPDF;
            uout->pc = uin->pc;
            uout->pd = uin->pd;

m_poppler_get_poppler(Page, Dict, getPieceInfo);
m_poppler_get_poppler(Page, Dict, getSeparationInfo);
m_poppler_get_poppler(Page, Dict, getResourceDict);
m_poppler_get_OBJECT(Page, getAnnotsObject);

m_poppler_get_OBJECT(Page, getContents);


    {"getPieceInfo", m_Page_getPieceInfo},
    {"getSeparationInfo", m_Page_getSeparationInfo},
    {"getResourceDict", m_Page_getResourceDict},
    {"getAnnots", m_Page_getAnnotsObject},
    {"getContents", m_Page_getContents},
    {"__tostring", m_Page__tostring},
    {NULL, NULL}                // sentinel

    if (((PdfDocument *) uin->d)->doc->getXRef()->isOk()) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((PdfDocument *) uin->d)->doc->getDocInfo();
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

    if (((PdfDocument *) uin->d)->doc->getXRef()->isOk()) {
        uout = new_Object_userdata(L);
        uout->d = new Object();
        *((Object *) uout->d) = ((PdfDocument *) uin->d)->doc->getDocInfoNF();
        uout->atype = ALLOC_LEPDF;
        uout->pc = uin->pc;
        uout->pd = uin->pd;

    uout = new_Object_userdata(L);
    uout->d = new Object();
    origin = (Object *) (((Attribute *) uin->d)->getValue());
    *((Object *) uout->d) = origin->copy();
    uout->atype = ALLOC_LEPDF;
    uout->pc = uin->pc;
    uout->pd = uin->pd;

    parent = root->findParentElement(i-1);
    if (parent != NULL) {
       uout = new_StructElement_userdata(L);
       uout->d = (StructElement *) parent;
       uout->atype = ALLOC_LEPDF;
       uout->pc = uin->pc;
       uout->pd = uin->pd;

    gen = luaL_checkint(L, 3);
    uout = new_Object_userdata(L);
    uout->d = new Object();
    *((Object *) uout->d) = ((XRef *) uin->d)->fetch(num, gen);
    uout->atype = ALLOC_LEPDF;
    uout->pc = uin->pc;
    uout->pd = uin->pd;

Lines 634-640 Link Here

(-)source.orig/texk/web2c/luatexdir/lua/lpdfscannerlib.cc (-1 / +1 lines)
634	int i;	634	int i;
635	for (i=0;i<count;i++) {	635	for (i=0;i<count;i++) {
636	Object *val = new Object();	636	Object *val = new Object();
637	arrayref->get(i, val);	637	*val = arrayref->get(i);
638	if (val->isStream()) {	638	if (val->isStream()) {
639	ObjectList *rover = self->_streams;	639	ObjectList *rover = self->_streams;
640	ObjectList item = (ObjectList )priv_xmalloc (sizeof(ObjectList));	640	ObjectList item = (ObjectList )priv_xmalloc (sizeof(ObjectList));




#define MASK_SUPPRESS_PTEX_PAGENUMBER 0x04
#define MASK_SUPPRESS_PTEX_INFODICT   0x08

// PdfObject encapsulates the xpdf Object type,
// and properly frees its resources on destruction.
// Use obj-> to access members of the Object,
// and &obj to get a pointer to the object.
// It is no longer necessary to call Object::free explicitely.

class PdfObject {
  public:
    PdfObject() {               // nothing
    } ~PdfObject() {
        iObject.free();
    }
    Object *operator->() {
        return &iObject;
    }
    Object *operator&() {
        return &iObject;
    }
  private:                     // no copying or assigning
    PdfObject(const PdfObject &);
    void operator=(const PdfObject &);
  public:
    Object iObject;
};

// When copying the Resources of the selected page, all objects are copied
// recusively top-down. Indirect objects however are not fetched during
// copying, but get a new object number from pdfTeX and then will be

    delete pdf_doc;
}

// Replacement for
//      Object *initDict(Dict *dict1){ initObj(objDict); dict = dict1; return this; }

static void initDictFromDict(PdfObject & obj, Dict * dict)
{
    obj->initDict(xref);
    for (int i = 0, l = dict->getLength(); i < l; i++) {
        Object obj1;
        obj->dictAdd(copyString(dict->getKey(i)), dict->getValNF(i, &obj1));
    }
}

// --------------------------------------------------------------------

static int addEncoding(GfxFont * gfont)


static void copyDictEntry(Object * obj, int i)
{
    Object obj1;
    copyName(obj->dictGetKey(i));
    pdf_puts(" ");
    obj1 = obj->dictGetValNF(i);
    copyObject(&obj1);
    pdf_puts("\n");
}

static void copyProcSet(Object * obj)
{
    int i, l;
    Object procset;
    if (!obj->isArray())
        pdftex_fail("PDF inclusion: invalid ProcSet array type <%s>",
                    obj->getTypeName());
    pdf_puts("/ProcSet [ ");
    for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
        procset = obj->arrayGetNF(i);
        if (!procset.isName())
            pdftex_fail("PDF inclusion: invalid ProcSet entry type <%s>",
                        procset.getTypeName());
        copyName(procset.getName());
        pdf_puts(" ");
    }
    pdf_puts("]\n");


static void copyFont(char *tag, Object * fontRef)
{
    Object fontdict, subtype, basefont, fontdescRef, fontdesc, charset,
        fontfile, ffsubtype, stemV;
    GfxFont *gfont;
    fd_entry *fd;

    }
    // Only handle included Type1 (and Type1C) fonts; anything else will be copied.
    // Type1C fonts are replaced by Type1 fonts, if REPLACE_TYPE1C is true.
    fontdict = fontRef->fetch(xref);
    if (fontdict.isDict()) {
        subtype = fontdict.dictLookup("Subtype");
        basefont = fontdict.dictLookup("BaseFont");
        fontdescRef = fontdict.dictLookupNF("FontDescriptor");
        if (fontdescRef.isRef()) {
            fontdesc = fontdescRef.fetch(xref);
            if (fontdesc.isDict()) {
                fontfile = fontdesc.dictLookup("FontFile");
                if (!fontfile.isStream() && REPLACE_TYPE1C) {
                    fontfile = fontdesc.dictLookup("FontFile3");
                    ffsubtype = fontfile.streamGetDict()->lookup("Subtype");
                    if (!(ffsubtype.isName() && !strcmp(ffsubtype.getName(), "Type1C"))) {
                        // not a Type1-C font.
                        fontfile = Object(objNull);
                    }
                }
            }
        }
    }
    if (!fixedinclusioncopyfont && fontdict.isDict()
        && subtype.isName()
        && !strcmp(subtype.getName(), "Type1")
        && basefont.isName()
        && fontdescRef.isRef()
        && fontdesc.isDict()
        && fontfile.isStream()
        && (fontmap = lookup_fontmap(basefont.getName())) != NULL) {
        // round /StemV value, since the PDF input is a float
        // (see Font Descriptors in PDF reference), but we only store an
        // integer, since we don't want to change the struct.
        stemV = fontdesc.dictLookup("StemV");
        fd = epdf_create_fontdescriptor(fontmap, zround(stemV.getNum()));
        charset = fontdesc.dictLookup("CharSet");
        if (!charset.isNull() &&
            charset.isString() && is_subsetable(fontmap))
            epdf_mark_glyphs(fd, charset.getString()->getCString());
        else
            embed_whole_font(fd);
        addFontDesc(fontdescRef.getRef(), fd);
        copyName(tag);
        gfont = GfxFont::makeFont(xref, tag, fontRef->getRef(),
                                  fontdict.getDict());
        pdf_printf(" %d 0 R ", addFont(fontRef->getRef(), fd,
                                       addEncoding(gfont)));
    } else {


static void copyFontResources(Object * obj)
{
    Object fontRef;
    int i, l;
    if (!obj->isDict())
        pdftex_fail("PDF inclusion: invalid font resources dict type <%s>",
                    obj->getTypeName());
    pdf_puts("/Font << ");
    for (i = 0, l = obj->dictGetLength(); i < l; ++i) {
        fontRef = obj->dictGetValNF(i);
        if (fontRef.isRef())
            copyFont(obj->dictGetKey(i), &fontRef);
        else if (fontRef.isDict()) {   // some programs generate pdf with embedded font object
            copyName(obj->dictGetKey(i));
            pdf_puts(" ");
            copyObject(&fontRef);
        }
        else
            pdftex_fail("PDF inclusion: invalid font in reference type <%s>",
                        fontRef.getTypeName());
    }
    pdf_puts(">>\n");
}


static void copyObject(Object * obj)
{
    Object obj1;
    int i, l, c;
    Ref ref;
    char *p;

    } else if (obj->isArray()) {
        pdf_puts("[");
        for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
            obj1 = obj->arrayGetNF(i);
            if (!obj1.isName())
                pdf_puts(" ");
            copyObject(&obj1);
        }

        copyDict(obj);
        pdf_puts(">>");
    } else if (obj->isStream()) {
        obj1 = Object(obj->streamGetDict());
        pdf_puts("<<\n");
        copyDict(&obj1);
        pdf_puts(">>\n");

    InObj *r;
    for (r = inObjList; r != 0; r = r->next) {
        if (!r->written) {
            Object obj1;
            r->written = 1;
            Object obj1 = xref->fetch(r->ref.num, r->ref.gen);
            if (r->type == objFont) {
                assert(!obj1.isStream());
                pdfbeginobj(r->num, 2);         // \pdfobjcompresslevel = 2 is for this

                pdf_puts("\n");
                pdfendobj();
            }
            obj1.free();
        }
    }
}

    Page *page;
    Ref *pageRef;
    Dict *pageDict;
    Object contents, obj1, obj2, pageObj, dictObj;
    Object groupDict;
    bool writeSepGroup = false;
    Object info;
    char *key;

    encodingList = 0;
    page = pdf_doc->doc->getCatalog()->getPage(epdf_selected_page);
    pageRef = pdf_doc->doc->getCatalog()->getPageRef(epdf_selected_page);
    pageObj = xref->fetch(pageRef->num, pageRef->gen);
    pageDict = pageObj.getDict();
    rotate = page->getRotate();
    PDFRectangle *pagebox;
    // write the Page header

        pdf_printf("/%s.PageNumber %i\n", pdfkeyprefix, (int) epdf_selected_page);
    }
    if ((suppress_ptex_info & MASK_SUPPRESS_PTEX_INFODICT) == 0) {
        info = pdf_doc->doc->getDocInfoNF();
        if (info.isRef()) {
            // the info dict must be indirect (PDF Ref p. 61)
            pdf_printf("/%s.InfoDict ", pdfkeyprefix);

    pdf_puts(stripzeros(s));

    // Metadata validity check (as a stream it must be indirect)
    dictObj = pageDict->lookupNF("Metadata");
    if (!dictObj.isNull() && !dictObj.isRef())
        pdftex_warn("PDF inclusion: /Metadata must be indirect object");

    // copy selected items in Page dictionary except Resources & Group
    for (i = 0; pageDictKeys[i] != NULL; i++) {
        dictObj = pageDict->lookupNF(pageDictKeys[i]);
        if (!dictObj.isNull()) {
            pdf_newline();
            pdf_printf("/%s ", pageDictKeys[i]);
            copyObject(&dictObj); // preserves indirection

    } 

    // handle page group
    dictObj = pageDict->lookupNF("Group");
    if (!dictObj.isNull()) {
        if (pdfpagegroupval == 0) { 
            // another pdf with page group was included earlier on the
            // same page; copy the Group entry as is.  See manual for

            copyObject(&dictObj);
        } else {
            // write Group dict as a separate object, since the Page dict also refers to it
            dictObj = pageDict->lookup("Group");
            if (!dictObj.isDict())
                pdftex_fail("PDF inclusion: /Group dict missing");
            writeSepGroup = true;
            groupDict = Object(page->getGroup());
            pdf_printf("/Group %ld 0 R\n", (long)pdfpagegroupval);
        }
    }

        pdftex_warn
            ("PDF inclusion: /Resources missing. 'This practice is not recommended' (PDF Ref)");
    } else {
        obj1 = Object(page->getResourceDict());
        if (!obj1.isDict())
            pdftex_fail("PDF inclusion: invalid resources dict type <%s>",
                        obj1.getTypeName());
        pdf_newline();
        pdf_puts("/Resources <<\n");
        for (i = 0, l = obj1.dictGetLength(); i < l; ++i) {
            obj2 = obj1.dictGetVal(i);
            key = obj1.dictGetKey(i);
            if (strcmp("Font", key) == 0)
                copyFontResources(&obj2);
            else if (strcmp("ProcSet", key) == 0)

    }

    // write the page contents
    contents = page->getContents();
    if (contents.isStream()) {

        // Variant A: get stream and recompress under control
        // of \pdfcompresslevel


        // Variant B: copy stream without recompressing
        //
        obj1 = contents.streamGetDict()->lookup("F");
        if (!obj1.isNull()) {
            pdftex_fail("PDF inclusion: Unsupported external stream");
        }
        obj1 = contents.streamGetDict()->lookup("Length");
        assert(!obj1.isNull());
        pdf_puts("/Length ");
        copyObject(&obj1);
        pdf_puts("\n");
        obj1 = contents.streamGetDict()->lookup("Filter");
        if (!obj1.isNull()) {
            pdf_puts("/Filter ");
            copyObject(&obj1);
            pdf_puts("\n");
            obj1 = contents.streamGetDict()->lookup("DecodeParms");
            if (!obj1.isNull()) {
                pdf_puts("/DecodeParms ");
                copyObject(&obj1);
                pdf_puts("\n");
            }
        }
        pdf_puts(">>\nstream\n");
        copyStream(contents.getStream()->getUndecodedStream());
        pdfendstream();
    } else if (contents.isArray()) {
        pdfbeginstream();
        for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {
            Object contentsobj = contents.arrayGet(i);
            copyStream(contentsobj.getStream());
            contentsobj.free();
            if (i < l - 1)
                pdf_newline();  // add a newline after each stream except the last
        }




            objgen = atoi(argv[3]);
    }
    xref = doc->getXRef();
    catalogDict = xref->getCatalog();
    xref->getCatalog(&catalogDict);
    if (!catalogDict.isDict("Catalog")) {
        fprintf(stderr, "No Catalog found\n");
        exit(1);
    }
    srcStream = Object(objNull);
    if (objnum == 0) {
        srcStream = catalogDict.dictLookup("SourceObject");
        static char const_SourceFile[] = "SourceFile";
        if (!srcStream.isStream(const_SourceFile)) {
            fprintf(stderr, "No SourceObject found\n");
            exit(1);
        }
        srcName = srcStream.getStream()->getDict()->lookup("SourceName");
        srcStream.getStream()->getDict()->lookup("SourceName", &srcName);
        if (!srcName.isString()) {
            fprintf(stderr, "No SourceName found\n");
            exit(1);

        // We cannot free srcName, as objname shares its string.
        // srcName.free();
    } else if (objnum > 0) {
        srcStream = xref->fetch(objnum, objgen);
        if (!srcStream.isStream()) {
            fprintf(stderr, "Not a Stream object\n");
            exit(1);

                int localOffset = 0;
                Guint firstOffset;

                objStr = xref->fetch(e->offset, 0);
                assert(objStr.isStream());
                obj1 = objStr.streamGetDict()->lookup("N");
                nObjects = obj1.getInt();
                obj1 = objStr.streamGetDict()->lookup("First");
                first = obj1.getInt();
                firstOffset = objStr.getStream()->getBaseStream()->getStart() + first;

                // parse the header: object numbers and offsets
                objStr.streamReset();
                str = new EmbedStream(objStr.getStream(), Object(objNull), gTrue, first);
                str = new EmbedStream(objStr.getStream(), &obj1, gTrue, first);
                parser = new Parser(xref, new Lexer(xref, str), gFalse);
                for (n = 0; n < nObjects; ++n) {
                    obj1 = parser->getObj();
                    obj2 = parser->getObj();
                    if (n == e->gen)
                        localOffset = obj2.getInt();
                    obj1.free();
                    obj2.free();
                }
                while (str->getChar() != EOF) ;
                delete parser;
                objStr.free();

                fprintf(outfile, "%.10lu 00000 n\n",
                        (long unsigned)(firstOffset + localOffset));

        s->reset();
        while ((c = s->getChar()) != EOF)
            fputc(c, outfile);
        srcStream.free();
    }
    if (objnum == 0)
        fprintf(stderr, "Source file extracted to %s\n", outname);

    else
        fprintf(stderr, "Cross-reference table extracted to %s\n", outname);
    fclose(outfile);
    catalogDict.free();
    delete doc;
    delete globalParams;
}

Return to bug 629710

Lines 224-230 Link Here

(-)source.orig/texk/web2c/luatexdir/image/pdftoepdf.w (-35 / +19 lines)
224	free(checksum);	224	free(checksum);
225	}	225	}
226	if (pdf_doc->doc == NULL) {	226	if (pdf_doc->doc == NULL) {
227	docmemstream = new MemStream( docstream,0,streamsize, obj.initNull() );	227	docmemstream = new MemStream( docstream,0,streamsize, Object(objNull) );
228	doc = new PDFDoc(docmemstream); /* takes ownership of docmemstream */	228	doc = new PDFDoc(docmemstream); /* takes ownership of docmemstream */
229	pdf_doc->pc++;	229	pdf_doc->pc++;
230	if (!doc->isOk() \|\| !doc->okToPrint()) {	230	if (!doc->isOk() \|\| !doc->okToPrint()) {
Lines 408-416 Link Here
408	Object obj1;	408	Object obj1;
409	pdf_begin_array(pdf);	409	pdf_begin_array(pdf);
410	for (i = 0, l = array->getLength(); i < l; ++i) {	410	for (i = 0, l = array->getLength(); i < l; ++i) {
411	array->getNF(i, &obj1);	411	obj1 = array->getNF(i);
412	copyObject(pdf, pdf_doc, &obj1);	412	copyObject(pdf, pdf_doc, &obj1);
413	obj1.free();
414	}	413	}
415	pdf_end_array(pdf);	414	pdf_end_array(pdf);
416	}	415	}
Lines 422-430 Link Here
422	pdf_begin_dict(pdf);	421	pdf_begin_dict(pdf);
423	for (i = 0, l = dict->getLength(); i < l; ++i) {	422	for (i = 0, l = dict->getLength(); i < l; ++i) {
424	copyName(pdf, dict->getKey(i));	423	copyName(pdf, dict->getKey(i));
425	dict->getValNF(i, &obj1);	424	obj1 = dict->getValNF(i);
426	copyObject(pdf, pdf_doc, &obj1);	425	copyObject(pdf, pdf_doc, &obj1);
427	obj1.free();
428	}	426	}
429	pdf_end_dict(pdf);	427	pdf_end_dict(pdf);
430	}	428	}
Lines 510-522 Link Here
510	PDFDoc *doc = pdf_doc->doc;	508	PDFDoc *doc = pdf_doc->doc;
511	xref = doc->getXRef();	509	xref = doc->getXRef();
512	for (r = pdf_doc->inObjList; r != NULL;) {	510	for (r = pdf_doc->inObjList; r != NULL;) {
513	xref->fetch(r->ref.num, r->ref.gen, &obj1);	511	obj1 = xref->fetch(r->ref.num, r->ref.gen);
514	if (obj1.isStream())	512	if (obj1.isStream())
515	pdf_begin_obj(pdf, r->num, OBJSTM_NEVER);	513	pdf_begin_obj(pdf, r->num, OBJSTM_NEVER);
516	else	514	else
517	pdf_begin_obj(pdf, r->num, 2);	515	pdf_begin_obj(pdf, r->num, 2);
518	copyObject(pdf, pdf_doc, &obj1);	516	copyObject(pdf, pdf_doc, &obj1);
519	obj1.free();
520	pdf_end_obj(pdf);	517	pdf_end_obj(pdf);
521	n = r->next;	518	n = r->next;
522	delete r;	519	delete r;
Lines 740-746 Link Here
740	catalog = doc->getCatalog();	737	catalog = doc->getCatalog();
741	page = catalog->getPage(img_pagenum(idict));	738	page = catalog->getPage(img_pagenum(idict));
742	pageref = catalog->getPageRef(img_pagenum(idict));	739	pageref = catalog->getPageRef(img_pagenum(idict));
743	doc->getXRef()->fetch(pageref->num, pageref->gen, &pageobj);	740	pageobj = doc->getXRef()->fetch(pageref->num, pageref->gen);
744	pageDict = pageobj.getDict();	741	pageDict = pageobj.getDict();
745	/* write the Page header */	742	/* write the Page header */
746	pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);	743	pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);
Lines 757-768 Link Here
757	pdf_dict_add_int(pdf, "PTEX.PageNumber", (int) img_pagenum(idict));	754	pdf_dict_add_int(pdf, "PTEX.PageNumber", (int) img_pagenum(idict));
758	}	755	}
759	if ((suppress_optional_info & 8) == 0) {	756	if ((suppress_optional_info & 8) == 0) {
760	doc->getDocInfoNF(&obj1);	757	obj1 = doc->getDocInfoNF();
761	if (obj1.isRef()) {	758	if (obj1.isRef()) {
762	/* the info dict must be indirect (PDF Ref p. 61) */	759	/* the info dict must be indirect (PDF Ref p. 61) */
763	pdf_dict_add_ref(pdf, "PTEX.InfoDict", addInObj(pdf, pdf_doc, obj1.getRef()));	760	pdf_dict_add_ref(pdf, "PTEX.InfoDict", addInObj(pdf, pdf_doc, obj1.getRef()));
764	}	761	}
765	obj1.free();
766	}	762	}
767	if (img_is_bbox(idict)) {	763	if (img_is_bbox(idict)) {
768	bbox[0] = sp2bp(img_bbox(idict)[0]);	764	bbox[0] = sp2bp(img_bbox(idict)[0]);
Lines 788-806 Link Here
788	Now all relevant parts of the Page dictionary are copied. Metadata validity	784	Now all relevant parts of the Page dictionary are copied. Metadata validity
789	check is needed(as a stream it must be indirect).	785	check is needed(as a stream it must be indirect).
790	*/	786	*/
791	pageDict->lookupNF("Metadata", &obj1);	787	obj1 = pageDict->lookupNF("Metadata");
792	if (!obj1.isNull() && !obj1.isRef())	788	if (!obj1.isNull() && !obj1.isRef())
793	formatted_warning("pdf inclusion","/Metadata must be indirect object");	789	formatted_warning("pdf inclusion","/Metadata must be indirect object");
794	obj1.free();
795	/* copy selected items in Page dictionary */	790	/* copy selected items in Page dictionary */
796	for (i = 0; pagedictkeys[i] != NULL; i++) {	791	for (i = 0; pagedictkeys[i] != NULL; i++) {
797	pageDict->lookupNF(pagedictkeys[i], &obj1);	792	obj1 = pageDict->lookupNF(pagedictkeys[i]);
798	if (!obj1.isNull()) {	793	if (!obj1.isNull()) {
799	pdf_add_name(pdf, pagedictkeys[i]);	794	pdf_add_name(pdf, pagedictkeys[i]);
800	/* preserves indirection */	795	/* preserves indirection */
801	copyObject(pdf, pdf_doc, &obj1);	796	copyObject(pdf, pdf_doc, &obj1);
802	}	797	}
803	obj1.free();
804	}	798	}
805	/*	799	/*
806	If there are no Resources in the Page dict of the embedded page,	800	If there are no Resources in the Page dict of the embedded page,
Lines 808-839 Link Here
808	PDF file, climbing up the tree until the Resources are found.	802	PDF file, climbing up the tree until the Resources are found.
809	(This fixes a problem with Scribus 1.3.3.14.)	803	(This fixes a problem with Scribus 1.3.3.14.)
810	*/	804	*/
811	pageDict->lookupNF("Resources", &obj1);	805	obj1 = pageDict->lookupNF("Resources");
812	if (obj1.isNull()) {	806	if (obj1.isNull()) {
813	op1 = &pagesobj1;	807	op1 = &pagesobj1;
814	op2 = &pagesobj2;	808	op2 = &pagesobj2;
815	pageDict->lookup("Parent", op1);	809	*op1 = pageDict->lookup("Parent");
816	while (op1->isDict()) {	810	while (op1->isDict()) {
817	obj1.free();	811	obj1 = op1->dictLookupNF("Resources");
818	op1->dictLookupNF("Resources", &obj1);
819	if (!obj1.isNull()) {	812	if (!obj1.isNull()) {
820	pdf_add_name(pdf, "Resources");	813	pdf_add_name(pdf, "Resources");
821	copyObject(pdf, pdf_doc, &obj1);	814	copyObject(pdf, pdf_doc, &obj1);
822	break;	815	break;
823	}	816	}
824	op1->dictLookup("Parent", op2);	817	*op2 = op1->dictLookup("Parent");
825	optmp = op1;	818	optmp = op1;
826	op1 = op2;	819	op1 = op2;
827	op2 = optmp;	820	op2 = optmp;
828	op2->free();
829	};	821	};
830	if (!op1->isDict())	822	if (!op1->isDict())
831	formatted_warning("pdf inclusion","Page /Resources missing");	823	formatted_warning("pdf inclusion","Page /Resources missing");
832	op1->free();
833	}	824	}
834	obj1.free();
835	/* Write the Page contents. */	825	/* Write the Page contents. */
836	page->getContents(&contents);	826	contents = page->getContents();
837	if (contents.isStream()) {	827	if (contents.isStream()) {
838	/*	828	/*
839	Variant A: get stream and recompress under control of \pdfcompresslevel	829	Variant A: get stream and recompress under control of \pdfcompresslevel
Lines 844-870 Link Here
844		834
845	Variant B: copy stream without recompressing	835	Variant B: copy stream without recompressing
846	*/	836	*/
847	contents.streamGetDict()->lookup("F", &obj1);	837	obj1 = contents.streamGetDict()->lookup("F");
848	if (!obj1.isNull()) {	838	if (!obj1.isNull()) {
849	normal_error("pdf inclusion","unsupported external stream");	839	normal_error("pdf inclusion","unsupported external stream");
850	}	840	}
851	obj1.free();	841	obj1 = contents.streamGetDict()->lookup("Length");
852	contents.streamGetDict()->lookup("Length", &obj1);
853	pdf_add_name(pdf, "Length");	842	pdf_add_name(pdf, "Length");
854	copyObject(pdf, pdf_doc, &obj1);	843	copyObject(pdf, pdf_doc, &obj1);
855	obj1.free();	844	obj1 = contents.streamGetDict()->lookup("Filter");
856	contents.streamGetDict()->lookup("Filter", &obj1);
857	if (!obj1.isNull()) {	845	if (!obj1.isNull()) {
858	pdf_add_name(pdf, "Filter");	846	pdf_add_name(pdf, "Filter");
859	copyObject(pdf, pdf_doc, &obj1);	847	copyObject(pdf, pdf_doc, &obj1);
860	obj1.free();	848	obj1 = contents.streamGetDict()->lookup("DecodeParms");
861	contents.streamGetDict()->lookup("DecodeParms", &obj1);
862	if (!obj1.isNull()) {	849	if (!obj1.isNull()) {
863	pdf_add_name(pdf, "DecodeParms");	850	pdf_add_name(pdf, "DecodeParms");
864	copyObject(pdf, pdf_doc, &obj1);	851	copyObject(pdf, pdf_doc, &obj1);
865	}	852	}
866	}	853	}
867	obj1.free();
868	pdf_end_dict(pdf);	854	pdf_end_dict(pdf);
869	pdf_begin_stream(pdf);	855	pdf_begin_stream(pdf);
870	copyStreamStream(pdf, contents.getStream()->getUndecodedStream());	856	copyStreamStream(pdf, contents.getStream()->getUndecodedStream());
Lines 875-882 Link Here
875	pdf_end_dict(pdf);	861	pdf_end_dict(pdf);
876	pdf_begin_stream(pdf);	862	pdf_begin_stream(pdf);
877	for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {	863	for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {
878	copyStreamStream(pdf, (contents.arrayGet(i, &obj1))->getStream());	864	obj1 = contents.arrayGet(i);
879	obj1.free();	865	copyStreamStream(pdf, obj1.getStream());
880	if (i < (l - 1)) {	866	if (i < (l - 1)) {
881	/*	867	/*
882	Put a space between streams to be on the safe side (streams	868	Put a space between streams to be on the safe side (streams
Lines 897-904 Link Here
897	}	883	}
898	/* write out all indirect objects */	884	/* write out all indirect objects */
899	writeRefs(pdf, pdf_doc);	885	writeRefs(pdf, pdf_doc);
900	contents.free();
901	pageobj.free();
902	/*	886	/*
903	unrefPdfDocument() must come after contents.free() and pageobj.free()!	887	unrefPdfDocument() must come after contents.free() and pageobj.free()!
904	TH: The next line makes repeated pdf inclusion unacceptably slow	888	TH: The next line makes repeated pdf inclusion unacceptably slow

Lines 86-107 Link Here

(-)source.orig/texk/web2c/pdftexdir/pdftosrc.cc (-21 / +14 lines)
86	objgen = atoi(argv[3]);	86	objgen = atoi(argv[3]);
87	}	87	}
88	xref = doc->getXRef();	88	xref = doc->getXRef();
89	catalogDict.initNull();	89	catalogDict = xref->getCatalog();
90	xref->getCatalog(&catalogDict);
91	if (!catalogDict.isDict("Catalog")) {	90	if (!catalogDict.isDict("Catalog")) {
92	fprintf(stderr, "No Catalog found\n");	91	fprintf(stderr, "No Catalog found\n");
93	exit(1);	92	exit(1);
94	}	93	}
95	srcStream.initNull();	94	srcStream = Object(objNull);
96	if (objnum == 0) {	95	if (objnum == 0) {
97	catalogDict.dictLookup("SourceObject", &srcStream);	96	srcStream = catalogDict.dictLookup("SourceObject");
98	static char const_SourceFile[] = "SourceFile";	97	static char const_SourceFile[] = "SourceFile";
99	if (!srcStream.isStream(const_SourceFile)) {	98	if (!srcStream.isStream(const_SourceFile)) {
100	fprintf(stderr, "No SourceObject found\n");	99	fprintf(stderr, "No SourceObject found\n");
101	exit(1);	100	exit(1);
102	}	101	}
103	srcName.initNull();	102	srcName = srcStream.getStream()->getDict()->lookup("SourceName");
104	srcStream.getStream()->getDict()->lookup("SourceName", &srcName);
105	if (!srcName.isString()) {	103	if (!srcName.isString()) {
106	fprintf(stderr, "No SourceName found\n");	104	fprintf(stderr, "No SourceName found\n");
107	exit(1);	105	exit(1);
Lines 110-116 Link Here
110	// We cannot free srcName, as objname shares its string.	108	// We cannot free srcName, as objname shares its string.
111	// srcName.free();	109	// srcName.free();
112	} else if (objnum > 0) {	110	} else if (objnum > 0) {
113	xref->fetch(objnum, objgen, &srcStream);	111	srcStream = xref->fetch(objnum, objgen);
114	if (!srcStream.isStream()) {	112	if (!srcStream.isStream()) {
115	fprintf(stderr, "Not a Stream object\n");	113	fprintf(stderr, "Not a Stream object\n");
116	exit(1);	114	exit(1);
Lines 159-187 Link Here
159	int localOffset = 0;	157	int localOffset = 0;
160	Guint firstOffset;	158	Guint firstOffset;
161		159
162	assert(xref->fetch(e->offset, 0, &objStr)->isStream());	160	objStr = xref->fetch(e->offset, 0);
163	nObjects = objStr.streamGetDict()->lookup("N", &obj1)->getInt();	161	assert(objStr.isStream());
164	obj1.free();	162	obj1 = objStr.streamGetDict()->lookup("N");
165	first = objStr.streamGetDict()->lookup("First", &obj1)->getInt();	163	nObjects = obj1.getInt();
166	obj1.free();	164	obj1 = objStr.streamGetDict()->lookup("First");
		165	first = obj1.getInt();
167	firstOffset = objStr.getStream()->getBaseStream()->getStart() + first;	166	firstOffset = objStr.getStream()->getBaseStream()->getStart() + first;
168		167
169	// parse the header: object numbers and offsets	168	// parse the header: object numbers and offsets
170	objStr.streamReset();	169	objStr.streamReset();
171	obj1.initNull();	170	str = new EmbedStream(objStr.getStream(), Object(objNull), gTrue, first);
172	str = new EmbedStream(objStr.getStream(), &obj1, gTrue, first);
173	parser = new Parser(xref, new Lexer(xref, str), gFalse);	171	parser = new Parser(xref, new Lexer(xref, str), gFalse);
174	for (n = 0; n < nObjects; ++n) {	172	for (n = 0; n < nObjects; ++n) {
175	parser->getObj(&obj1);	173	obj1 = parser->getObj();
176	parser->getObj(&obj2);	174	obj2 = parser->getObj();
177	if (n == e->gen)	175	if (n == e->gen)
178	localOffset = obj2.getInt();	176	localOffset = obj2.getInt();
179	obj1.free();
180	obj2.free();
181	}	177	}
182	while (str->getChar() != EOF) ;	178	while (str->getChar() != EOF) ;
183	delete parser;	179	delete parser;
184	objStr.free();
185		180
186	fprintf(outfile, "%.10lu 00000 n\n",	181	fprintf(outfile, "%.10lu 00000 n\n",
187	(long unsigned)(firstOffset + localOffset));	182	(long unsigned)(firstOffset + localOffset));
Lines 192-198 Link Here
192	s->reset();	187	s->reset();
193	while ((c = s->getChar()) != EOF)	188	while ((c = s->getChar()) != EOF)
194	fputc(c, outfile);	189	fputc(c, outfile);
195	srcStream.free();
196	}	190	}
197	if (objnum == 0)	191	if (objnum == 0)
198	fprintf(stderr, "Source file extracted to %s\n", outname);	192	fprintf(stderr, "Source file extracted to %s\n", outname);
Lines 201-207 Link Here
201	else	195	else
202	fprintf(stderr, "Cross-reference table extracted to %s\n", outname);	196	fprintf(stderr, "Cross-reference table extracted to %s\n", outname);
203	fclose(outfile);	197	fclose(outfile);
204	catalogDict.free();
205	delete doc;	198	delete doc;
206	delete globalParams;	199	delete globalParams;
207	}	200	}

Lines 84-114 Link Here

(-)source.orig/texk/web2c/pdftexdir/pdftoepdf.cc (-113 / +89 lines)
84	#define MASK_SUPPRESS_PTEX_PAGENUMBER 0x04	84	#define MASK_SUPPRESS_PTEX_PAGENUMBER 0x04
85	#define MASK_SUPPRESS_PTEX_INFODICT 0x08	85	#define MASK_SUPPRESS_PTEX_INFODICT 0x08
86		86
87	// PdfObject encapsulates the xpdf Object type,
88	// and properly frees its resources on destruction.
89	// Use obj-> to access members of the Object,
90	// and &obj to get a pointer to the object.
91	// It is no longer necessary to call Object::free explicitely.
92
93	class PdfObject {
94	public:
95	PdfObject() { // nothing
96	} ~PdfObject() {
97	iObject.free();
98	}
99	Object *operator->() {
100	return &iObject;
101	}
102	Object *operator&() {
103	return &iObject;
104	}
105	private: // no copying or assigning
106	PdfObject(const PdfObject &);
107	void operator=(const PdfObject &);
108	public:
109	Object iObject;
110	};
111
112	// When copying the Resources of the selected page, all objects are copied	87	// When copying the Resources of the selected page, all objects are copied
113	// recusively top-down. Indirect objects however are not fetched during	88	// recusively top-down. Indirect objects however are not fetched during
114	// copying, but get a new object number from pdfTeX and then will be	89	// copying, but get a new object number from pdfTeX and then will be
Lines 212-229 Link Here
212	delete pdf_doc;	187	delete pdf_doc;
213	}	188	}
214		189
215	// Replacement for
216	// Object initDict(Dict dict1){ initObj(objDict); dict = dict1; return this; }
217
218	static void initDictFromDict(PdfObject & obj, Dict * dict)
219	{
220	obj->initDict(xref);
221	for (int i = 0, l = dict->getLength(); i < l; i++) {
222	Object obj1;
223	obj->dictAdd(copyString(dict->getKey(i)), dict->getValNF(i, &obj1));
224	}
225	}
226
227	// --------------------------------------------------------------------	190	// --------------------------------------------------------------------
228		191
229	static int addEncoding(GfxFont * gfont)	192	static int addEncoding(GfxFont * gfont)
Lines 320-329 Link Here
320		283
321	static void copyDictEntry(Object * obj, int i)	284	static void copyDictEntry(Object * obj, int i)
322	{	285	{
323	PdfObject obj1;	286	Object obj1;
324	copyName(obj->dictGetKey(i));	287	copyName(obj->dictGetKey(i));
325	pdf_puts(" ");	288	pdf_puts(" ");
326	obj->dictGetValNF(i, &obj1);	289	obj1 = obj->dictGetValNF(i);
327	copyObject(&obj1);	290	copyObject(&obj1);
328	pdf_puts("\n");	291	pdf_puts("\n");
329	}	292	}
Lines 376-392 Link Here
376	static void copyProcSet(Object * obj)	339	static void copyProcSet(Object * obj)
377	{	340	{
378	int i, l;	341	int i, l;
379	PdfObject procset;	342	Object procset;
380	if (!obj->isArray())	343	if (!obj->isArray())
381	pdftex_fail("PDF inclusion: invalid ProcSet array type <%s>",	344	pdftex_fail("PDF inclusion: invalid ProcSet array type <%s>",
382	obj->getTypeName());	345	obj->getTypeName());
383	pdf_puts("/ProcSet [ ");	346	pdf_puts("/ProcSet [ ");
384	for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {	347	for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
385	obj->arrayGetNF(i, &procset);	348	procset = obj->arrayGetNF(i);
386	if (!procset->isName())	349	if (!procset.isName())
387	pdftex_fail("PDF inclusion: invalid ProcSet entry type <%s>",	350	pdftex_fail("PDF inclusion: invalid ProcSet entry type <%s>",
388	procset->getTypeName());	351	procset.getTypeName());
389	copyName(procset->getName());	352	copyName(procset.getName());
390	pdf_puts(" ");	353	pdf_puts(" ");
391	}	354	}
392	pdf_puts("]\n");	355	pdf_puts("]\n");
Lines 396-402 Link Here
396		359
397	static void copyFont(char tag, Object fontRef)	360	static void copyFont(char tag, Object fontRef)
398	{	361	{
399	PdfObject fontdict, subtype, basefont, fontdescRef, fontdesc, charset,	362	Object fontdict, subtype, basefont, fontdescRef, fontdesc, charset,
400	fontfile, ffsubtype, stemV;	363	fontfile, ffsubtype, stemV;
401	GfxFont *gfont;	364	GfxFont *gfont;
402	fd_entry *fd;	365	fd_entry *fd;
Lines 413-445 Link Here
413	}	376	}
414	// Only handle included Type1 (and Type1C) fonts; anything else will be copied.	377	// Only handle included Type1 (and Type1C) fonts; anything else will be copied.
415	// Type1C fonts are replaced by Type1 fonts, if REPLACE_TYPE1C is true.	378	// Type1C fonts are replaced by Type1 fonts, if REPLACE_TYPE1C is true.
416	if (!fixedinclusioncopyfont && fontRef->fetch(xref, &fontdict)->isDict()	379	fontdict = fontRef->fetch(xref);
417	&& fontdict->dictLookup("Subtype", &subtype)->isName()	380	if (fontdict.isDict()) {
418	&& !strcmp(subtype->getName(), "Type1")	381	subtype = fontdict.dictLookup("Subtype");
419	&& fontdict->dictLookup("BaseFont", &basefont)->isName()	382	basefont = fontdict.dictLookup("BaseFont");
420	&& fontdict->dictLookupNF("FontDescriptor", &fontdescRef)->isRef()	383	fontdescRef = fontdict.dictLookupNF("FontDescriptor");
421	&& fontdescRef->fetch(xref, &fontdesc)->isDict()	384	if (fontdescRef.isRef()) {
422	&& (fontdesc->dictLookup("FontFile", &fontfile)->isStream()	385	fontdesc = fontdescRef.fetch(xref);
423	\|\| (REPLACE_TYPE1C	386	if (fontdesc.isDict()) {
424	&& fontdesc->dictLookup("FontFile3", &fontfile)->isStream()	387	fontfile = fontdesc.dictLookup("FontFile");
425	&& fontfile->streamGetDict()->lookup("Subtype",	388	if (!fontfile.isStream() && REPLACE_TYPE1C) {
426	&ffsubtype)->isName()	389	fontfile = fontdesc.dictLookup("FontFile3");
427	&& !strcmp(ffsubtype->getName(), "Type1C")))	390	ffsubtype = fontfile.streamGetDict()->lookup("Subtype");
428	&& (fontmap = lookup_fontmap(basefont->getName())) != NULL) {	391	if (!(ffsubtype.isName() && !strcmp(ffsubtype.getName(), "Type1C"))) {
		392	// not a Type1-C font.
		393	fontfile = Object(objNull);
		394	}
		395	}
		396	}
		397	}
		398	}
		399	if (!fixedinclusioncopyfont && fontdict.isDict()
		400	&& subtype.isName()
		401	&& !strcmp(subtype.getName(), "Type1")
		402	&& basefont.isName()
		403	&& fontdescRef.isRef()
		404	&& fontdesc.isDict()
		405	&& fontfile.isStream()
		406	&& (fontmap = lookup_fontmap(basefont.getName())) != NULL) {
429	// round /StemV value, since the PDF input is a float	407	// round /StemV value, since the PDF input is a float
430	// (see Font Descriptors in PDF reference), but we only store an	408	// (see Font Descriptors in PDF reference), but we only store an
431	// integer, since we don't want to change the struct.	409	// integer, since we don't want to change the struct.
432	fontdesc->dictLookup("StemV", &stemV);	410	stemV = fontdesc.dictLookup("StemV");
433	fd = epdf_create_fontdescriptor(fontmap, zround(stemV->getNum()));	411	fd = epdf_create_fontdescriptor(fontmap, zround(stemV.getNum()));
434	if (fontdesc->dictLookup("CharSet", &charset) &&	412	charset = fontdesc.dictLookup("CharSet");
435	charset->isString() && is_subsetable(fontmap))	413	if (!charset.isNull() &&
436	epdf_mark_glyphs(fd, charset->getString()->getCString());	414	charset.isString() && is_subsetable(fontmap))
		415	epdf_mark_glyphs(fd, charset.getString()->getCString());
437	else	416	else
438	embed_whole_font(fd);	417	embed_whole_font(fd);
439	addFontDesc(fontdescRef->getRef(), fd);	418	addFontDesc(fontdescRef.getRef(), fd);
440	copyName(tag);	419	copyName(tag);
441	gfont = GfxFont::makeFont(xref, tag, fontRef->getRef(),	420	gfont = GfxFont::makeFont(xref, tag, fontRef->getRef(),
442	fontdict->getDict());	421	fontdict.getDict());
443	pdf_printf(" %d 0 R ", addFont(fontRef->getRef(), fd,	422	pdf_printf(" %d 0 R ", addFont(fontRef->getRef(), fd,
444	addEncoding(gfont)));	423	addEncoding(gfont)));
445	} else {	424	} else {
Lines 451-474 Link Here
451		430
452	static void copyFontResources(Object * obj)	431	static void copyFontResources(Object * obj)
453	{	432	{
454	PdfObject fontRef;	433	Object fontRef;
455	int i, l;	434	int i, l;
456	if (!obj->isDict())	435	if (!obj->isDict())
457	pdftex_fail("PDF inclusion: invalid font resources dict type <%s>",	436	pdftex_fail("PDF inclusion: invalid font resources dict type <%s>",
458	obj->getTypeName());	437	obj->getTypeName());
459	pdf_puts("/Font << ");	438	pdf_puts("/Font << ");
460	for (i = 0, l = obj->dictGetLength(); i < l; ++i) {	439	for (i = 0, l = obj->dictGetLength(); i < l; ++i) {
461	obj->dictGetValNF(i, &fontRef);	440	fontRef = obj->dictGetValNF(i);
462	if (fontRef->isRef())	441	if (fontRef.isRef())
463	copyFont(obj->dictGetKey(i), &fontRef);	442	copyFont(obj->dictGetKey(i), &fontRef);
464	else if (fontRef->isDict()) { // some programs generate pdf with embedded font object	443	else if (fontRef.isDict()) { // some programs generate pdf with embedded font object
465	copyName(obj->dictGetKey(i));	444	copyName(obj->dictGetKey(i));
466	pdf_puts(" ");	445	pdf_puts(" ");
467	copyObject(&fontRef);	446	copyObject(&fontRef);
468	}	447	}
469	else	448	else
470	pdftex_fail("PDF inclusion: invalid font in reference type <%s>",	449	pdftex_fail("PDF inclusion: invalid font in reference type <%s>",
471	fontRef->getTypeName());	450	fontRef.getTypeName());
472	}	451	}
473	pdf_puts(">>\n");	452	pdf_puts(">>\n");
474	}	453	}
Lines 557-563 Link Here
557		536
558	static void copyObject(Object * obj)	537	static void copyObject(Object * obj)
559	{	538	{
560	PdfObject obj1;	539	Object obj1;
561	int i, l, c;	540	int i, l, c;
562	Ref ref;	541	Ref ref;
563	char *p;	542	char *p;
Lines 601-608 Link Here
601	} else if (obj->isArray()) {	580	} else if (obj->isArray()) {
602	pdf_puts("[");	581	pdf_puts("[");
603	for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {	582	for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
604	obj->arrayGetNF(i, &obj1);	583	obj1 = obj->arrayGetNF(i);
605	if (!obj1->isName())	584	if (!obj1.isName())
606	pdf_puts(" ");	585	pdf_puts(" ");
607	copyObject(&obj1);	586	copyObject(&obj1);
608	}	587	}
Lines 612-618 Link Here
612	copyDict(obj);	591	copyDict(obj);
613	pdf_puts(">>");	592	pdf_puts(">>");
614	} else if (obj->isStream()) {	593	} else if (obj->isStream()) {
615	initDictFromDict(obj1, obj->streamGetDict());	594	obj1 = Object(obj->streamGetDict());
616	pdf_puts("<<\n");	595	pdf_puts("<<\n");
617	copyDict(&obj1);	596	copyDict(&obj1);
618	pdf_puts(">>\n");	597	pdf_puts(">>\n");
Lines 638-646 Link Here
638	InObj *r;	617	InObj *r;
639	for (r = inObjList; r != 0; r = r->next) {	618	for (r = inObjList; r != 0; r = r->next) {
640	if (!r->written) {	619	if (!r->written) {
641	Object obj1;
642	r->written = 1;	620	r->written = 1;
643	xref->fetch(r->ref.num, r->ref.gen, &obj1);	621	Object obj1 = xref->fetch(r->ref.num, r->ref.gen);
644	if (r->type == objFont) {	622	if (r->type == objFont) {
645	assert(!obj1.isStream());	623	assert(!obj1.isStream());
646	pdfbeginobj(r->num, 2); // \pdfobjcompresslevel = 2 is for this	624	pdfbeginobj(r->num, 2); // \pdfobjcompresslevel = 2 is for this
Lines 656-662 Link Here
656	pdf_puts("\n");	634	pdf_puts("\n");
657	pdfendobj();	635	pdfendobj();
658	}	636	}
659	obj1.free();
660	}	637	}
661	}	638	}
662	}	639	}
Lines 839-846 Link Here
839	Page *page;	816	Page *page;
840	Ref *pageRef;	817	Ref *pageRef;
841	Dict *pageDict;	818	Dict *pageDict;
842	PdfObject contents, obj1, obj2, pageObj, dictObj;	819	Object contents, obj1, obj2, pageObj, dictObj;
843	PdfObject groupDict;	820	Object groupDict;
844	bool writeSepGroup = false;	821	bool writeSepGroup = false;
845	Object info;	822	Object info;
846	char *key;	823	char *key;
Lines 867-874 Link Here
867	encodingList = 0;	844	encodingList = 0;
868	page = pdf_doc->doc->getCatalog()->getPage(epdf_selected_page);	845	page = pdf_doc->doc->getCatalog()->getPage(epdf_selected_page);
869	pageRef = pdf_doc->doc->getCatalog()->getPageRef(epdf_selected_page);	846	pageRef = pdf_doc->doc->getCatalog()->getPageRef(epdf_selected_page);
870	xref->fetch(pageRef->num, pageRef->gen, &pageObj);	847	pageObj = xref->fetch(pageRef->num, pageRef->gen);
871	pageDict = pageObj->getDict();	848	pageDict = pageObj.getDict();
872	rotate = page->getRotate();	849	rotate = page->getRotate();
873	PDFRectangle *pagebox;	850	PDFRectangle *pagebox;
874	// write the Page header	851	// write the Page header
Lines 886-892 Link Here
886	pdf_printf("/%s.PageNumber %i\n", pdfkeyprefix, (int) epdf_selected_page);	863	pdf_printf("/%s.PageNumber %i\n", pdfkeyprefix, (int) epdf_selected_page);
887	}	864	}
888	if ((suppress_ptex_info & MASK_SUPPRESS_PTEX_INFODICT) == 0) {	865	if ((suppress_ptex_info & MASK_SUPPRESS_PTEX_INFODICT) == 0) {
889	pdf_doc->doc->getDocInfoNF(&info);	866	info = pdf_doc->doc->getDocInfoNF();
890	if (info.isRef()) {	867	if (info.isRef()) {
891	// the info dict must be indirect (PDF Ref p. 61)	868	// the info dict must be indirect (PDF Ref p. 61)
892	pdf_printf("/%s.InfoDict ", pdfkeyprefix);	869	pdf_printf("/%s.InfoDict ", pdfkeyprefix);
Lines 942-955 Link Here
942	pdf_puts(stripzeros(s));	919	pdf_puts(stripzeros(s));
943		920
944	// Metadata validity check (as a stream it must be indirect)	921	// Metadata validity check (as a stream it must be indirect)
945	pageDict->lookupNF("Metadata", &dictObj);	922	dictObj = pageDict->lookupNF("Metadata");
946	if (!dictObj->isNull() && !dictObj->isRef())	923	if (!dictObj.isNull() && !dictObj.isRef())
947	pdftex_warn("PDF inclusion: /Metadata must be indirect object");	924	pdftex_warn("PDF inclusion: /Metadata must be indirect object");
948		925
949	// copy selected items in Page dictionary except Resources & Group	926	// copy selected items in Page dictionary except Resources & Group
950	for (i = 0; pageDictKeys[i] != NULL; i++) {	927	for (i = 0; pageDictKeys[i] != NULL; i++) {
951	pageDict->lookupNF(pageDictKeys[i], &dictObj);	928	dictObj = pageDict->lookupNF(pageDictKeys[i]);
952	if (!dictObj->isNull()) {	929	if (!dictObj.isNull()) {
953	pdf_newline();	930	pdf_newline();
954	pdf_printf("/%s ", pageDictKeys[i]);	931	pdf_printf("/%s ", pageDictKeys[i]);
955	copyObject(&dictObj); // preserves indirection	932	copyObject(&dictObj); // preserves indirection
Lines 957-964 Link Here
957	}	934	}
958		935
959	// handle page group	936	// handle page group
960	pageDict->lookupNF("Group", &dictObj);	937	dictObj = pageDict->lookupNF("Group");
961	if (!dictObj->isNull()) {	938	if (!dictObj.isNull()) {
962	if (pdfpagegroupval == 0) {	939	if (pdfpagegroupval == 0) {
963	// another pdf with page group was included earlier on the	940	// another pdf with page group was included earlier on the
964	// same page; copy the Group entry as is. See manual for	941	// same page; copy the Group entry as is. See manual for
Lines 972-982 Link Here
972	copyObject(&dictObj);	949	copyObject(&dictObj);
973	} else {	950	} else {
974	// write Group dict as a separate object, since the Page dict also refers to it	951	// write Group dict as a separate object, since the Page dict also refers to it
975	pageDict->lookup("Group", &dictObj);	952	dictObj = pageDict->lookup("Group");
976	if (!dictObj->isDict())	953	if (!dictObj.isDict())
977	pdftex_fail("PDF inclusion: /Group dict missing");	954	pdftex_fail("PDF inclusion: /Group dict missing");
978	writeSepGroup = true;	955	writeSepGroup = true;
979	initDictFromDict(groupDict, page->getGroup());	956	groupDict = Object(page->getGroup());
980	pdf_printf("/Group %ld 0 R\n", (long)pdfpagegroupval);	957	pdf_printf("/Group %ld 0 R\n", (long)pdfpagegroupval);
981	}	958	}
982	}	959	}
Lines 989-1003 Link Here
989	pdftex_warn	966	pdftex_warn
990	("PDF inclusion: /Resources missing. 'This practice is not recommended' (PDF Ref)");	967	("PDF inclusion: /Resources missing. 'This practice is not recommended' (PDF Ref)");
991	} else {	968	} else {
992	initDictFromDict(obj1, page->getResourceDict());	969	obj1 = Object(page->getResourceDict());
993	if (!obj1->isDict())	970	if (!obj1.isDict())
994	pdftex_fail("PDF inclusion: invalid resources dict type <%s>",	971	pdftex_fail("PDF inclusion: invalid resources dict type <%s>",
995	obj1->getTypeName());	972	obj1.getTypeName());
996	pdf_newline();	973	pdf_newline();
997	pdf_puts("/Resources <<\n");	974	pdf_puts("/Resources <<\n");
998	for (i = 0, l = obj1->dictGetLength(); i < l; ++i) {	975	for (i = 0, l = obj1.dictGetLength(); i < l; ++i) {
999	obj1->dictGetVal(i, &obj2);	976	obj2 = obj1.dictGetVal(i);
1000	key = obj1->dictGetKey(i);	977	key = obj1.dictGetKey(i);
1001	if (strcmp("Font", key) == 0)	978	if (strcmp("Font", key) == 0)
1002	copyFontResources(&obj2);	979	copyFontResources(&obj2);
1003	else if (strcmp("ProcSet", key) == 0)	980	else if (strcmp("ProcSet", key) == 0)
Lines 1009-1016 Link Here
1009	}	986	}
1010		987
1011	// write the page contents	988	// write the page contents
1012	page->getContents(&contents);	989	contents = page->getContents();
1013	if (contents->isStream()) {	990	if (contents.isStream()) {
1014		991
1015	// Variant A: get stream and recompress under control	992	// Variant A: get stream and recompress under control
1016	// of \pdfcompresslevel	993	// of \pdfcompresslevel
Lines 1021-1056 Link Here
1021		998
1022	// Variant B: copy stream without recompressing	999	// Variant B: copy stream without recompressing
1023	//	1000	//
1024	contents->streamGetDict()->lookup("F", &obj1);	1001	obj1 = contents.streamGetDict()->lookup("F");
1025	if (!obj1->isNull()) {	1002	if (!obj1.isNull()) {
1026	pdftex_fail("PDF inclusion: Unsupported external stream");	1003	pdftex_fail("PDF inclusion: Unsupported external stream");
1027	}	1004	}
1028	contents->streamGetDict()->lookup("Length", &obj1);	1005	obj1 = contents.streamGetDict()->lookup("Length");
1029	assert(!obj1->isNull());	1006	assert(!obj1.isNull());
1030	pdf_puts("/Length ");	1007	pdf_puts("/Length ");
1031	copyObject(&obj1);	1008	copyObject(&obj1);
1032	pdf_puts("\n");	1009	pdf_puts("\n");
1033	contents->streamGetDict()->lookup("Filter", &obj1);	1010	obj1 = contents.streamGetDict()->lookup("Filter");
1034	if (!obj1->isNull()) {	1011	if (!obj1.isNull()) {
1035	pdf_puts("/Filter ");	1012	pdf_puts("/Filter ");
1036	copyObject(&obj1);	1013	copyObject(&obj1);
1037	pdf_puts("\n");	1014	pdf_puts("\n");
1038	contents->streamGetDict()->lookup("DecodeParms", &obj1);	1015	obj1 = contents.streamGetDict()->lookup("DecodeParms");
1039	if (!obj1->isNull()) {	1016	if (!obj1.isNull()) {
1040	pdf_puts("/DecodeParms ");	1017	pdf_puts("/DecodeParms ");
1041	copyObject(&obj1);	1018	copyObject(&obj1);
1042	pdf_puts("\n");	1019	pdf_puts("\n");
1043	}	1020	}
1044	}	1021	}
1045	pdf_puts(">>\nstream\n");	1022	pdf_puts(">>\nstream\n");
1046	copyStream(contents->getStream()->getUndecodedStream());	1023	copyStream(contents.getStream()->getUndecodedStream());
1047	pdfendstream();	1024	pdfendstream();
1048	} else if (contents->isArray()) {	1025	} else if (contents.isArray()) {
1049	pdfbeginstream();	1026	pdfbeginstream();
1050	for (i = 0, l = contents->arrayGetLength(); i < l; ++i) {	1027	for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {
1051	Object contentsobj;	1028	Object contentsobj = contents.arrayGet(i);
1052	copyStream((contents->arrayGet(i, &contentsobj))->getStream());	1029	copyStream(contentsobj.getStream());
1053	contentsobj.free();
1054	if (i < l - 1)	1030	if (i < l - 1)
1055	pdf_newline(); // add a newline after each stream except the last	1031	pdf_newline(); // add a newline after each stream except the last
1056	}	1032	}