pd_internal.h

Go to the documentation of this file.

//
// pd_internal.h
//
// Copyright (c) 2012 - 2015 Karl-Johan Alm (http://github.com/kallewoof)
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

#ifndef INCLUDED_pd_internal_h
#define INCLUDED_pd_internal_h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "PDDefines.h"
#include "PDOperator.h"

#ifndef true
#define true 1
#endif
#ifndef false
#define false 0
#endif


extern PDObjectRef PDObjectCreate(PDInteger obid, PDInteger genid);


#ifdef DEBUG_PDTYPES
#define PDTYPE_PTR_LEN  4
#else
#define PDTYPE_PTR_LEN  3
#endif

union PDType {
    struct {
#ifdef DEBUG_PDTYPES
        char *pdc;                  // Pajdeg signature
#endif
        PDInstanceType it;          // Instance type, if any.
        PDInteger retainCount;      // Retain count. If the retain count of an object hits zero, the object is disposed of.
        PDDeallocator dealloc;      // Deallocation method.
    };
    void *align[PDTYPE_PTR_LEN];    // Force-align. 
};

#define PDAlloc(s,d,z) PDAllocTyped(PDInstanceTypeUnset,s,d,z)

#ifdef DEBUG_PD_RELEASES
#define PDAllocTyped(it,s,d,z) _PDAllocTypedDebug(__FILE__,__LINE__,it,s,d,z)
extern void *_PDFocusObject;
extern void *_PDAllocTypedDebug(const char *file, int lineNumber, PDInstanceType it, PDSize size, void *dealloc, PDBool zeroed);
#else

extern void *PDAllocTyped(PDInstanceType it, PDSize size, void *dealloc, PDBool zeroed);
#endif

extern void PDFlush(void);

extern void PDFlushUntil(void *ob);

extern char *PDC;

#ifdef DEBUG_PDTYPES
#   define PDTYPE_ASSERT(ob) PDAssert(((PDTypeRef)ob - 1)->pdc == PDC)
#else
#   define PDTYPE_ASSERT(ob) 
#endif

#ifdef PD_SUPPORT_CRYPTO

typedef struct PDCryptoInstance *PDCryptoInstanceRef;

extern PDCryptoInstanceRef PDCryptoInstanceCreate(pd_crypto crypto, PDInteger obid, PDInteger gennum);

typedef void (*PDInstanceCryptoExchange)(void *inst, PDCryptoInstanceRef ci, PDBool encrypted);

extern PDInstanceCryptoExchange PDInstanceCryptoExchanges[];

#endif

struct PDObject {
    PDInteger           obid;           
    PDInteger           genid;          
    PDObjectClass       obclass;        
    PDObjectType        type;           
    pd_stack            def;            
    void               *inst;           
    PDBool              hasStream;      
    PDInteger           streamLen;      
    PDInteger           extractedLen;   
    char               *streamBuf;      
    PDBool              skipStream;     
    PDBool              skipObject;     
    PDBool              deleteObject;   
    char               *ovrStream;      
    PDInteger           ovrStreamLen;   
    PDBool              ovrStreamAlloc; 
    char               *ovrDef;         
    PDInteger           ovrDefLen;      
    PDBool              encryptedDoc;   
    char               *refString;      
    PDSynchronizer      synchronizer;   
    const void         *syncInfo;       
#ifdef PD_SUPPORT_CRYPTO
    pd_crypto           crypto;         
    PDCryptoInstanceRef cryptoInstance; 
#endif
};

//
// object stream
//

typedef struct PDObjectStreamElement *PDObjectStreamElementRef;

struct PDObjectStreamElement {
    PDInteger obid;                     
    PDInteger offset;                   
    PDInteger length;                   
    PDObjectType type;                  
    void *def;                          
};

struct PDObjectStream {
    PDObjectRef ob;                     
    PDInteger n;                        
    PDInteger first;                    
    PDStreamFilterRef filter;           
    PDObjectStreamElementRef elements;  
    PDSplayTreeRef constructs;              
};

extern PDObjectStreamRef PDObjectStreamCreateWithObject(PDObjectRef object);

extern PDBool PDObjectStreamParseRawObjectStream(PDObjectStreamRef obstm, char *rawBuf);

extern void PDObjectStreamParseExtractedObjectStream(PDObjectStreamRef obstm, char *buf);

extern void PDObjectStreamCommit(PDObjectStreamRef obstm);

struct PDContentStream {
    PDSplayTreeRef opertree;            
    PDArrayRef args;                    
    pd_stack opers;                     
    pd_stack deallocators;              
    pd_stack resetters;                 
    const char *lastOperator;           
};

struct PDPage {
    PDObjectRef  ob;           
    PDParserRef  parser;       
    PDInteger    contentCount; 
    PDArrayRef   contentRefs;  
    PDObjectRef *contentObs;   
    PDFontDictionaryRef fontDict; 
};


struct PDEnv {
    PDStateRef    state;            
    pd_stack      buildStack;       
    pd_stack      varStack;         
    //PDInteger     entryOffset;     
};

extern void PDEnvDestroy(PDEnvRef env);


struct pd_btree {
    PDInteger key;                  
    void *value;                    
    //PDInteger balance;              
    PDSplayTreeRef branch[2];           
};


struct PDOperator {
    PDOperatorType   type;          

    union {
        PDStateRef   pushedState;   
        char        *key;           
        PDID         identifier;    
    };
    
    PDOperatorRef    next;          
};


typedef struct PDXTable *PDXTableRef;

typedef enum {
    PDParserStateBase,              
    PDParserStateObjectDefinition,  
    PDParserStateObjectAppendix,    
    PDParserStateObjectPostStream,  
} PDParserState;

struct PDParser {
    PDTwinStreamRef stream;         
    PDScannerRef scanner;           
    PDParserState state;            
    
    // xref related
    pd_stack xstack;                
    PDXTableRef mxt;                
    PDXTableRef cxt;                
    PDBool done;                    
    PDSize xrefnewiter;             
    
    // object related
    pd_stack appends;               
    pd_stack inserts;               
    PDSplayTreeRef aiTree;              
    PDObjectRef construct;          
    PDSize streamLen;               
    PDSize obid;                    
    PDSize genid;                   
    PDSize oboffset;                
    
    // document-wide stuff
    PDReferenceRef rootRef;         
    PDReferenceRef infoRef;         
    PDReferenceRef encryptRef;      
    PDObjectRef trailer;            
    PDObjectRef root;               
    PDObjectRef info;               
    PDObjectRef encrypt;            
    PDCatalogRef catalog;           
    pd_crypto crypto;               
    
    // miscellaneous
    PDBool success;                 
    PDSplayTreeRef skipT;           
    PDFontDictionaryRef mfd;        
};

typedef struct PDPageReference PDPageReference;
struct PDPageReference {
    PDBool collection;              
    union {
        struct {
            PDInteger count;        
            PDPageReference *kids;           
        };
        struct {
            PDInteger obid;         
            PDInteger genid;        
        };
    };
};

struct PDCatalog {
    PDParserRef parser;             
    PDObjectRef object;             
    PDRect      mediaBox;           
    PDPageReference pages;          
    PDInteger   count;              
    PDInteger   capacity;           
    PDInteger  *kids;               
};


typedef struct PDScannerSymbol *PDScannerSymbolRef;

typedef enum {
    PDScannerSymbolTypeDefault    = PDOperatorSymbolGlobRegular,    
    PDScannerSymbolTypeWhitespace = PDOperatorSymbolGlobWhitespace, 
    PDScannerSymbolTypeDelimiter  = PDOperatorSymbolGlobDelimiter,  
    PDScannerSymbolTypeNumeric    = PDOperatorSymbolExtNumeric,     
    PDScannerSymbolTypeEOB        = PDOperatorSymbolExtEOB,         
    PDScannerSymbolTypeFake       = PDOperatorSymbolExtFake,        
} PDScannerSymbolType;

struct PDScannerSymbol {
    char         *sstart;       
    short         shash;        
    PDInteger     slen;         
    PDScannerSymbolType stype;  
};

struct PDScanner {
    PDEnvRef   env;             
    PDScannerBufFunc bufFunc;   
    void *bufFuncInfo;          
    pd_stack contextStack;      
    
    pd_stack envStack;          
    pd_stack resultStack;       
    pd_stack symbolStack;       
    pd_stack garbageStack;      
    
    PDStreamFilterRef filter;   
    
    char         *buf;          
    PDInteger     bresoffset;   
    PDInteger     bsize;        
    PDInteger     boffset;      
    PDInteger     bmark;        
    PDScannerSymbolRef sym;     
    PDScannerPopFunc popFunc;   
    PDBool        fixedBuf;     
    PDBool        failed;       
    PDBool        outgrown;     
    PDBool        strict;       
};


#define PD_STACK_STRING   0      
#define PD_STACK_ID       1      
#define PD_STACK_STACK    2      
#define PD_STACK_PDOB     3      
#define PD_STACK_FREEABLE 4      


struct pd_stack {
    pd_stack   prev;            
    char       type;            
    void      *info;            
};


// "Get string object for key" signature for arrays/dictionaries. (Arrays pass integers as keys.)
// */
//typedef const char *(*_list_getter)(void *ref, const void *key);
//
// "Get raw object for key" signature for arrays/dictionaries. (Arrays pass integers as keys.)
// */
//typedef const pd_stack (*_list_getter_raw)(void *ref, const void *key);
//
// "Remove object for key" signature for arrays/dictionaries. (Arrays pass integers as keys.)
// */
//typedef void (*_list_remover)(void *ref, const void *key);
//
// "Set object for key to value" signature for arrays/dictionaries.
// */
//typedef PDInteger (*_list_setter)(void *ref, const void *key, const char *value);
//
// "Make room at index" signature for arrays.
// */
//typedef void (*_list_push_index)(void *ref, PDInteger index);
//
// The internal array structure.
// */
//struct pd_array {
//    PDInteger        count;     ///< Number of elements
//    PDInteger        capacity;  ///< Capacity of array
//    char           **values;    ///< Content
//    pd_stack        *vstacks;   ///< Values in pd_stack form
//    _list_getter     g;         ///< Getter
//    _list_getter_raw rg;        ///< Raw getter
//    _list_setter     s;         ///< Setter
//    _list_remover    r;         ///< Remover
//    _list_push_index pi;        ///< Push-indexer
//    void            *info;      ///< Info object (used for encrypted arrays)
//};
//
// The internal dictionary structure.
// */
//struct pd_dict {
//    PDInteger        count;     ///< Number of entries
//    PDInteger        capacity;  ///< Capacity of dictionary
//    char           **keys;      ///< Keys
//    char           **values;    ///< Values
//    pd_stack        *vstacks;   ///< Values in pd_stack form
//    _list_getter     g;         ///< Getter
//    _list_getter_raw rg;        ///< Raw getter
//    _list_setter     s;         ///< Setter
//    _list_remover    r;         ///< Remover
//    void            *info;      ///< Info object (used for encrypted arrays)
//};

struct PDArray {
    PDInteger        count;     
    PDInteger        capacity;  
    void           **values;    
    pd_stack        *vstacks;   
#ifdef PD_SUPPORT_CRYPTO
    PDCryptoInstanceRef ci;     
#endif
};

typedef struct PDDictionaryNode *PDDictionaryNodeRef;
struct PDDictionaryNode {
    char            *key;       
    void            *data;      
#ifdef PD_SUPPORT_CRYPTO
    void            *decrypted; 
#endif
    PDSize           hash;      
};

//#define PDHM_PROF

struct PDDictionary {
    PDInteger        count;     
#ifdef PDHM_PROF
    PDInteger        maxCount;  
#endif
    PDInteger        bucketc;   
    PDInteger        bucketm;   
    PDArrayRef      *buckets;   
    PDArrayRef       populated; 
#ifdef PD_SUPPORT_CRYPTO
    PDCryptoInstanceRef ci;     
#endif
};

struct PDDictionaryStack {
    pd_stack dicts;             
};

struct PDFontDictionary {
    PDParserRef     parser;     
    PDDictionaryRef fonts;      
    PDDictionaryRef encodings;  
};

struct PDFont {
    PDParserRef     parser;     
    PDFontDictionaryRef fontDict;
    PDObjectRef     obj;        
    PDCMapRef       toUnicode;  
    PDStringEncoding enc;       
    unsigned char  *encMap;     
};

typedef struct PDCMapRange PDCMapRange;                 
typedef struct PDCMapRangeMapping PDCMapRangeMapping;   
typedef struct PDCMapCharMapping PDCMapCharMapping;     

struct PDCMap {
    PDDictionaryRef systemInfo; 
    PDStringRef     name;       
    PDNumberRef     type;       
    PDSize          csrCap;     
    PDSize          bfrCap;     
    PDSize          bfcCap;     
    PDSize          csrCount;   
    PDSize          bfrCount;   
    PDSize          bfcCount;   
    PDSize          bfcLength;  
    PDCMapRange    *csrs;       
    PDCMapRangeMapping *bfrs;   
    PDCMapCharMapping  *bfcs;   
};

#ifdef PD_SUPPORT_CRYPTO

struct PDCryptoInstance {
    pd_crypto crypto;           
    PDInteger obid;             
    PDInteger genid;            
};

struct pd_crypto {
    // common values
    PDStringRef identifier;     
    PDStringRef filter;         
    PDStringRef subfilter;      
    PDInteger version;          
    PDInteger length;           
    
    // standard security handler 
    PDInteger revision;         
    PDStringRef owner;          
    PDStringRef user;           
    int32_t privs;              
    PDBool encryptMetadata;     
    PDStringRef enckey;         
    
    // standard crypt filter
    PDInteger cfLength;         
    pd_crypto_method cfMethod;  
    pd_auth_event cfAuthEvent;  
};

#else

struct pd_crypto {
    
};

#endif


struct PDState {
    PDBool         iterates;    
    char          *name;        
    char         **symbol;      
    PDInteger      symbols;     
    
    PDInteger     *symindex;    
    short          symindices;  
    
    PDOperatorRef *symbolOp;    
    PDOperatorRef  numberOp;    
    PDOperatorRef  delimiterOp; 
    PDOperatorRef  fallbackOp;  
};


struct PDStaticHash {
    PDInteger entries;          
    PDInteger mask;             
    PDInteger shift;            
    PDBool    leaveKeys;        
    PDBool    leaveValues;      
    void    **keys;             
    void    **values;           
    void    **table;            
};


struct PDTask {
    PDBool          isActive;       
    PDBool          isFilter;       
    PDPropertyType  propertyType;   
    PDInteger       value;          
    PDTaskFunc      func;           
    PDTaskRef       child;          
    PDDeallocator   deallocator;    
    void           *info;           
};


struct PDTwinStream {
    PDTwinStreamMethod method;      
    PDScannerRef scanner;           
    
    FILE    *fi;                    
    FILE    *fo;                    
    fpos_t   offsi;                 
    fpos_t   offso;                 
    
    char    *heap;                  
    PDSize   size;                  
    PDSize   holds;                 
    PDSize   cursor;                
    
    char    *sidebuf;               
    
    PDBool   outgrown;              
};

struct PDPipe {
    PDBool          opened;             
    PDBool          dynamicFiltering;   
    PDBool          typedTasks;         
    char           *pi;                 
    char           *po;                 
    FILE           *fi;                 
    FILE           *fo;                 
    PDInteger       filterCount;        
    PDTwinStreamRef stream;             
    PDParserRef     parser;             
    PDSplayTreeRef      filter;             
    pd_stack
    typeTasks[_PDFTypeCount];           
    PDSplayTreeRef      attachments;        
};

extern void PDPipeCloseFileStream(FILE *stream);
extern FILE *PDPipeOpenInputStream(const char *path);
extern FILE *PDPipeOpenOutputStream(const char *path);


struct PDReference {
    PDInteger obid;         
    PDInteger genid;        
};


struct PDNumber {
    PDObjectType type;      
    union {
        PDInteger i;
        PDReal r;
        PDBool b;
        PDSize s;
        void  *p;
    };
};


struct PDString {
    PDStringType type;      
    PDFontRef font;         
    PDStringEncoding enc;   
    PDSize length;          
    PDBool wrapped;         
    char *data;             
    PDStringRef alt;        
#ifdef PD_SUPPORT_CRYPTO
    PDCryptoInstanceRef ci; 
    PDBool encrypted;       
#endif
};

extern void PDStringAttachCryptoInstance(PDStringRef string, PDCryptoInstanceRef ci, PDBool encrypted);
extern void PDArrayAttachCryptoInstance(PDArrayRef array, PDCryptoInstanceRef ci, PDBool encrypted);
extern void PDDictionaryAttachCryptoInstance(PDDictionaryRef dictionary, PDCryptoInstanceRef ci, PDBool encrypted);
extern void PDDictionaryAttachCryptoInstance(PDDictionaryRef hm, PDCryptoInstanceRef ci, PDBool encrypted);


typedef struct PDStringConv *PDStringConvRef;

struct PDStringConv {
    char *allocBuf;         
    PDInteger offs;         
    PDInteger left;         
};


#define PDDEF const void*[]

#define PDDef(defs...) (PDDEF){(void*)defs, NULL}


#ifndef PDError
#   if defined(DEBUG) || defined(PD_WARNINGS)
#       define PD_WARNINGS
extern void _PDBreak();
#       define PDError(args...) do {\
            fprintf(stderr, "[pajdeg::error] %s:%d - ", __FILE__,__LINE__); \
            fprintf(stderr, args); \
            fprintf(stderr, "\n"); \
            _PDBreak();\
        } while (0)
#   else
#       define PDError(args...) 
#   endif
#endif

#ifndef PDWarn
#   if defined(DEBUG) || defined(PD_WARNINGS)
#       define PD_WARNINGS
#       define PDWarn(args...) do { \
            fprintf(stderr, "[pajdeg::warning] %s:%d - ", __FILE__,__LINE__); \
            fprintf(stderr, args); \
            fprintf(stderr, "\n"); \
        } while (0)
#   else
#       define PDWarn(args...) 
#   endif
#endif

#ifndef PDNotice
#   if defined(PD_NOTICES)
#       define PDNotice(args...) do { \
            fprintf(stderr, "[pajdeg::notice]  %s:%d - ", __FILE__,__LINE__); \
            fprintf(stderr, args); \
            fprintf(stderr, "\n"); \
        } while (0)
#   else
#       define PDNotice(args...) 
#   endif
#endif

#ifndef PDAssert
#   if defined(DEBUG) || defined(PD_ASSERTS)
#       include <assert.h>
#       if defined(PD_WARNINGS)
#           define PDAssert(args...) \
                if (!(args)) { \
                    PDWarn("assertion failure : %s", #args); \
                    assert(args); \
                }
#       else
#           define PDAssert(args...) assert(args)
#       endif
#   else
#       define PDAssert(args...) 
#   endif
#endif

#define PDRequire(state, retval, msg...) \
        if (!(state)) { \
            PDWarn("requirement failure : " msg); \
            PDAssert(state); \
            return retval; \
        }

#define as(type, expr...) ((type)(expr))

extern void PDTwinStreamAsserts(PDTwinStreamRef ts);

#define PDInstancePrinterRequire(b, r) \
    if (*cap - offs < b) { \
        *cap += r; \
        *buf = realloc(*buf, *cap); \
    }

#define PDInstancePrinterInit(itype, b, r) \
    itype i = (itype) inst;\
    PDInstancePrinterRequire(b, r)

#define fmatox(x, ato) \
static inline x fast_mutative_##ato(char *str, PDInteger len) \
{ \
    char t = str[len]; \
    str[len] = 0; \
    x l = ato(str); \
    str[len] = t; \
    return l; \
}

fmatox(long long, atoll)
fmatox(long, atol)

#endif