#define kUnfilteredStreamBit 1
#define kOwnedStreamBit 2
+/** \class SkPdfNativeObject
+ *
+ * The SkPdfNativeObject class is used to store a pdf object. Classes that inherit it are not
+ * allowed to add fields.
+ *
+ * SkPdfAllocator will allocate them in chunks and will free them in destructor.
+ *
+ * You can allocate one on the stack, as long as you call reset() at the end, and any objects it
+ * points to in an allocator. But if your object is a simple one, like number, then
+ * putting it on stack will be just fine.
+ *
+ */
class SkPdfNativeObject {
public:
enum ObjectType {
void* fData;
DataType fDataType;
- // Keep this the last entries
#ifdef PDF_TRACK_OBJECT_USAGE
+ // Records if the object was used during rendering/proccessing. It can be used to track
+ // what features are only partially implemented, by looking at what objects have not been
+ // accessed.
mutable bool fUsed;
#endif // PDF_TRACK_OBJECT_USAGE
#ifdef PDF_TRACK_STREAM_OFFSETS
public:
+ // TODO(edisonn): replace them with char* start, end - and a mechanism to register streams.
int fStreamId;
int fOffsetStart;
int fOffsetEnd;
public:
#ifdef PDF_TRACK_STREAM_OFFSETS
+ // TODO(edisonn): remove these ones.
int streamId() const { return fStreamId; }
int offsetStart() const { return fOffsetStart; }
int offsetEnd() const { return fOffsetEnd; }
#endif // PDF_TRACK_STREAM_OFFSETS
-
SkPdfNativeObject() : fInRendering(0)
, fObjectType(kInvalid_PdfObjectType)
, fMap(NULL)
#endif // PDF_TRACK_STREAM_OFFSETS
{}
+ // Used to verify if a form is used in rendering, to check for infinite loops.
bool inRendering() const { return fInRendering != 0; }
void startRendering() {fInRendering = 1;}
void doneRendering() {fInRendering = 0;}
+ // Each object can cache one entry associated with it.
+ // for example a SkPdfImage could cache an SkBitmap, of a SkPdfFont, could cache a SkTypeface.
inline bool hasData(DataType type) {
return type == fDataType;
}
+ // returns the cached value
inline void* data(DataType type) {
return type == fDataType ? fData : NULL;
}
+ // Stores something in the cache
inline void setData(void* data, DataType type) {
releaseData();
fDataType = type;
fData = data;
}
+ // destroys the cache
void releaseData();
+ // TODO(edisonn): add an assert that reset was called
// ~SkPdfNativeObject() {
// //reset(); must be called manually! Normally, will be called by allocator destructor.
// }
+ // Resets a pdf object, deleting all resources directly referenced.
+ // It will not reset/delete indirect resources.
+ // (e.g. it deletes only the array holding pointers to objects, but does not del the objects)
void reset() {
SkPdfMarkObjectUnused();
releaseData();
}
+ // returns the object type (Null, Integer, String, Dictionary, ... )
+ // It does not specify what type of dictionary we have.
ObjectType type() {
SkPdfMarkObjectUsed();
return fObjectType;
}
+ // Gives quick access to the buffer's address of a string/keyword/name
const char* c_str() const {
SkPdfMarkObjectUsed();
}
}
+ // Gives quick access to the length of a string/keyword/name
size_t lenstr() const {
SkPdfMarkObjectUsed();
return nyi;
}
+ // Creates a Boolean object. Assumes and asserts that it was never initialized.
static void makeBoolean(bool value, SkPdfNativeObject* obj) {
-
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fObjectType = kBoolean_PdfObjectType;
return obj;
}
+ // Creates an Integer object. Assumes and asserts that it was never initialized.
static void makeInteger(int64_t value, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fIntegerValue = value;
}
+ // Creates a Real object. Assumes and asserts that it was never initialized.
static void makeReal(double value, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fRealValue = value;
}
+ // Creates a Null object. Assumes and asserts that it was never initialized.
static void makeNull(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
return obj;
}
+ // TODO(edisonn): this might not woirk well in Chrome
static SkPdfNativeObject kNull;
+ // Creates a Numeric object from a string. Assumes and asserts that it was never initialized.
static void makeNumeric(const unsigned char* start, const unsigned char* end,
SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
}
}
+ // Creates a Reference object. Assumes and asserts that it was never initialized.
static void makeReference(unsigned int id, unsigned int gen, SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fRef.fGen = gen;
}
+ // Creates a Reference object. Resets the object before use.
static void resetAndMakeReference(unsigned int id, unsigned int gen, SkPdfNativeObject* obj) {
obj->reset();
makeReference(id, gen, obj);
}
-
+ // Creates a String object. Assumes and asserts that it was never initialized.
static void makeString(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kString_PdfObjectType);
}
+ // Creates a String object. Assumes and asserts that it was never initialized.
static void makeString(const unsigned char* start, const unsigned char* end,
SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kString_PdfObjectType);
}
+ // Creates a String object. Assumes and asserts that it was never initialized.
static void makeString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kString_PdfObjectType);
}
-
+ // Creates a HexString object. Assumes and asserts that it was never initialized.
static void makeHexString(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kHexString_PdfObjectType);
}
+ // Creates a HexString object. Assumes and asserts that it was never initialized.
static void makeHexString(const unsigned char* start, const unsigned char* end,
SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kHexString_PdfObjectType);
}
+ // Creates a HexString object. Assumes and asserts that it was never initialized.
static void makeHexString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kHexString_PdfObjectType);
}
-
+ // Creates a Name object. Assumes and asserts that it was never initialized.
static void makeName(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kName_PdfObjectType);
}
+ // Creates a Name object. Assumes and asserts that it was never initialized.
static void makeName(const unsigned char* start, const unsigned char* end,
SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kName_PdfObjectType);
}
+ // Creates a Name object. Assumes and asserts that it was never initialized.
static void makeName(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kName_PdfObjectType);
}
-
+ // Creates a Keyword object. Assumes and asserts that it was never initialized.
static void makeKeyword(const unsigned char* start, SkPdfNativeObject* obj) {
makeStringCore(start, strlen((const char*)start), obj, kKeyword_PdfObjectType);
}
+ // Creates a Keyword object. Assumes and asserts that it was never initialized.
static void makeKeyword(const unsigned char* start, const unsigned char* end,
SkPdfNativeObject* obj) {
makeStringCore(start, end - start, obj, kKeyword_PdfObjectType);
}
+ // Creates a Keyword object. Assumes and asserts that it was never initialized.
static void makeKeyword(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
makeStringCore(start, bytes, obj, kKeyword_PdfObjectType);
}
+ // Creates an empty Array object. Assumes and asserts that it was never initialized.
static void makeEmptyArray(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
obj->fArray = new SkTDArray<SkPdfNativeObject*>();
}
+ // Appends an object into the array. Assumes <this> is an array.
bool appendInArray(SkPdfNativeObject* obj) {
SkASSERT(fObjectType == kArray_PdfObjectType);
if (fObjectType != kArray_PdfObjectType) {
return true;
}
+ // Returns the size of an array.
size_t size() const {
SkPdfMarkObjectUsed();
return fArray->count();
}
+ // Returns one object of an array, by index.
SkPdfNativeObject* objAtAIndex(int i) {
SkPdfMarkObjectUsed();
return (*fArray)[i];
}
- SkPdfNativeObject* removeLastInArray() {
+ // Returns one object of an array, by index.
+ const SkPdfNativeObject* objAtAIndex(int i) const {
SkPdfMarkObjectUsed();
SkASSERT(fObjectType == kArray_PdfObjectType);
- SkPdfNativeObject* ret = NULL;
- fArray->pop(&ret);
-
- return ret;
+ return (*fArray)[i];
}
- const SkPdfNativeObject* objAtAIndex(int i) const {
+ // Returns one object of an array, by index.
+ SkPdfNativeObject* operator[](int i) {
SkPdfMarkObjectUsed();
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
}
- SkPdfNativeObject* operator[](int i) {
+ const SkPdfNativeObject* operator[](int i) const {
SkPdfMarkObjectUsed();
SkASSERT(fObjectType == kArray_PdfObjectType);
return (*fArray)[i];
}
- const SkPdfNativeObject* operator[](int i) const {
+ // Removes the last object in the array.
+ SkPdfNativeObject* removeLastInArray() {
SkPdfMarkObjectUsed();
SkASSERT(fObjectType == kArray_PdfObjectType);
- return (*fArray)[i];
+ SkPdfNativeObject* ret = NULL;
+ fArray->pop(&ret);
+
+ return ret;
}
+ // Creates an empty Dictionary object. Assumes and asserts that it was never initialized.
static void makeEmptyDictionary(SkPdfNativeObject* obj) {
SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
// which will be used in code
// add function SkPdfFastNameKey key(const char* key);
// TODO(edisonn): setting the same key twice, will make the value undefined!
+
+ // this[key] = value;
bool set(const SkPdfNativeObject* key, SkPdfNativeObject* value) {
SkPdfMarkObjectUsed();
return set(key->fStr.fBuffer, key->fStr.fBytes, value);
}
+ // this[key] = value;
bool set(const char* key, SkPdfNativeObject* value) {
SkPdfMarkObjectUsed();
return set((const unsigned char*)key, strlen(key), value);
}
+ // this[key] = value;
bool set(const unsigned char* key, size_t len, SkPdfNativeObject* value) {
SkPdfMarkObjectUsed();
return fMap->set((const char*)key, len, value);
}
+ // Returns an object from a Dictionary, identified by it's name.
SkPdfNativeObject* get(const SkPdfNativeObject* key) {
SkPdfMarkObjectUsed();
return get(key->fStr.fBuffer, key->fStr.fBytes);
}
+ // Returns an object from a Dictionary, identified by it's name.
SkPdfNativeObject* get(const char* key) {
SkPdfMarkObjectUsed();
return get((const unsigned char*)key, strlen(key));
}
+ // Returns an object from a Dictionary, identified by it's name.
SkPdfNativeObject* get(const unsigned char* key, size_t len) {
SkPdfMarkObjectUsed();
return ret;
}
+ // Returns an object from a Dictionary, identified by it's name.
const SkPdfNativeObject* get(const SkPdfNativeObject* key) const {
SkPdfMarkObjectUsed();
return get(key->fStr.fBuffer, key->fStr.fBytes);
}
+ // Returns an object from a Dictionary, identified by it's name.
const SkPdfNativeObject* get(const char* key) const {
SkPdfMarkObjectUsed();
return get((const unsigned char*)key, strlen(key));
}
+ // Returns an object from a Dictionary, identified by it's name.
const SkPdfNativeObject* get(const unsigned char* key, size_t len) const {
SkPdfMarkObjectUsed();
return ret;
}
+ // Returns an object from a Dictionary, identified by it's name.
const SkPdfNativeObject* get(const char* key, const char* abr) const {
SkPdfMarkObjectUsed();
return get(abr);
}
+ // Returns an object from a Dictionary, identified by it's name.
SkPdfNativeObject* get(const char* key, const char* abr) {
SkPdfMarkObjectUsed();
return get(abr);
}
+ // Casts the object to a Dictionary. Asserts if the object is not a Dictionary.
SkPdfDictionary* asDictionary() {
SkPdfMarkObjectUsed();
return (SkPdfDictionary*) this;
}
+ // Casts the object to a Dictionary. Asserts if the object is not a Dictionary.
const SkPdfDictionary* asDictionary() const {
SkPdfMarkObjectUsed();
}
+ // Returns true if the object is a Reference.
bool isReference() const {
SkPdfMarkObjectUsed();
return fObjectType == kReference_PdfObjectType;
}
+ // Returns true if the object is a Boolean.
bool isBoolean() const {
SkPdfMarkObjectUsed();
return fObjectType == kBoolean_PdfObjectType;
}
+ // Returns true if the object is an Integer.
bool isInteger() const {
SkPdfMarkObjectUsed();
return fObjectType == kInteger_PdfObjectType;
}
+
private:
+ // Returns true if the object is a Real number.
bool isReal() const {
SkPdfMarkObjectUsed();
return fObjectType == kReal_PdfObjectType;
}
+
public:
+ // Returns true if the object is a Number (either Integer or Real).
bool isNumber() const {
SkPdfMarkObjectUsed();
return fObjectType == kInteger_PdfObjectType || fObjectType == kReal_PdfObjectType;
}
+ // Returns true if the object is a R keyword (used to identify references, e.g. "10 3 R".
bool isKeywordReference() const {
SkPdfMarkObjectUsed();
return fObjectType == kKeyword_PdfObjectType && fStr.fBytes == 1 && fStr.fBuffer[0] == 'R';
}
+ // Returns true if the object is a Keyword.
bool isKeyword() const {
SkPdfMarkObjectUsed();
return fObjectType == kKeyword_PdfObjectType;
}
+ // Returns true if the object is a given Keyword.
bool isKeyword(const char* keyword) const {
SkPdfMarkObjectUsed();
return true;
}
+ // Returns true if the object is a Name.
bool isName() const {
SkPdfMarkObjectUsed();
return fObjectType == kName_PdfObjectType;
}
+ // Returns true if the object is a given Name.
bool isName(const char* name) const {
SkPdfMarkObjectUsed();
strncmp((const char*)fStr.fBuffer, name, fStr.fBytes) == 0;
}
+ // Returns true if the object is an Array.
bool isArray() const {
SkPdfMarkObjectUsed();
return fObjectType == kArray_PdfObjectType;
}
+ // Returns true if the object is a Date.
+ // TODO(edisonn): NYI
bool isDate() const {
SkPdfMarkObjectUsed();
return fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType;
}
+ // Returns true if the object is a Dictionary.
bool isDictionary() const {
SkPdfMarkObjectUsed();
return fObjectType == kDictionary_PdfObjectType;
}
+ // Returns true if the object is a Date.
+ // TODO(edisonn): NYI
bool isFunction() const {
SkPdfMarkObjectUsed();
return false; // NYI
}
+ // Returns true if the object is a Rectangle.
bool isRectangle() const {
SkPdfMarkObjectUsed();
return fObjectType == kArray_PdfObjectType && fArray->count() == 4;
}
- // TODO(edisonn): has stream .. or is stream ... TBD
+ // TODO(edisonn): Design: decide if we should use hasStream or isStream
+ // Returns true if the object has a stream associated with it.
bool hasStream() const {
SkPdfMarkObjectUsed();
return isDictionary() && fStr.fBuffer != NULL;
}
- // TODO(edisonn): has stream .. or is stream ... TBD
+ // Returns the stream associated with the dictionary. As of now, it casts this to Stream.
const SkPdfStream* getStream() const {
SkPdfMarkObjectUsed();
return hasStream() ? (const SkPdfStream*)this : NULL;
}
+ // Returns the stream associated with the dictionary. As of now, it casts this to Stream.
SkPdfStream* getStream() {
SkPdfMarkObjectUsed();
return hasStream() ? (SkPdfStream*)this : NULL;
}
+ // Returns true if the object is a String or HexString.
bool isAnyString() const {
SkPdfMarkObjectUsed();
return fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType;
}
+ // Returns true if the object is a HexString.
bool isHexString() const {
SkPdfMarkObjectUsed();
return fObjectType == kHexString_PdfObjectType;
}
+ // Returns true if the object is a Matrix.
bool isMatrix() const {
SkPdfMarkObjectUsed();
return fObjectType == kArray_PdfObjectType && fArray->count() == 6;
}
+ // Returns the int value stored in the object. Assert if the object is not an Integer.
inline int64_t intValue() const {
SkPdfMarkObjectUsed();
}
return fIntegerValue;
}
+
private:
+ // Returns the real value stored in the object. Assert if the object is not a Real.
inline double realValue() const {
SkPdfMarkObjectUsed();
}
return fRealValue;
}
+
public:
+ // Returns the numeric value stored in the object. Assert if the object is not a Real
+ // or an Integer.
inline double numberValue() const {
SkPdfMarkObjectUsed();
return fObjectType == kReal_PdfObjectType ? fRealValue : fIntegerValue;
}
+ // Returns the numeric value stored in the object as a scalar. Assert if the object is not
+ // a Realor an Integer.
inline SkScalar scalarValue() const {
SkPdfMarkObjectUsed();
SkIntToScalar(fIntegerValue);
}
+ // Returns the id of the referenced object. Assert if the object is not a Reference.
int referenceId() const {
SkPdfMarkObjectUsed();
return fRef.fId;
}
+ // Returns the generation of the referenced object. Assert if the object is not a Reference.
int referenceGeneration() const {
SkPdfMarkObjectUsed();
return fRef.fGen;
}
+ // Returns the buffer of a Name object. Assert if the object is not a Name.
inline const char* nameValue() const {
SkPdfMarkObjectUsed();
return (const char*)fStr.fBuffer;
}
+ // Returns the buffer of a (Hex)String object. Assert if the object is not a (Hex)String.
inline const char* stringValue() const {
SkPdfMarkObjectUsed();
return (const char*)fStr.fBuffer;
}
+ // Returns the storage of any type that can hold a form of string.
inline NotOwnedString strRef() {
SkPdfMarkObjectUsed();
return SkString((const char*)fStr.fBuffer, fStr.fBytes);
}
+ // Returns an SkString with the value of the (Hex)String object.
inline SkString stringValue2() const {
SkPdfMarkObjectUsed();
return SkString((const char*)fStr.fBuffer, fStr.fBytes);
}
+ // Returns the boolean of the Bool object. Assert if the object is not a Bool.
inline bool boolValue() const {
SkPdfMarkObjectUsed();
return fBooleanValue;
}
+ // Returns the rectangle of the Rectangle object. Assert if the object is not a Rectangle.
SkRect rectangleValue() const {
SkPdfMarkObjectUsed();
SkDoubleToScalar(array[3]));
}
+ // Returns the matrix of the Matrix object. Assert if the object is not a Matrix.
SkMatrix matrixValue() const {
SkPdfMarkObjectUsed();
return SkMatrixFromPdfMatrix(array);
}
+ // Runs all the filters of this stream, except the last one, if it is a DCT.
+ // Returns false on failure.
bool filterStream();
-
+ // Runs all the filters of this stream, except the last one, if it is a DCT, a gives back
+ // the buffer and the length. The object continues to own the buffer.
+ // Returns false on failure.
bool GetFilteredStreamRef(unsigned char const** buffer, size_t* len) {
SkPdfMarkObjectUsed();
return true;
}
+ // Returns true if the stream is already filtered.
bool isStreamFiltered() const {
SkPdfMarkObjectUsed();
return hasStream() && ((fStr.fBytes & 1) == kFilteredStreamBit);
}
+ // Returns true if this object own the buffer, or false if an Allocator own it.
bool isStreamOwned() const {
SkPdfMarkObjectUsed();
return hasStream() && ((fStr.fBytes & 2) == kOwnedStreamBit);
}
+ // Gives back the original buffer and the length. The object continues to own the buffer.
+ // Returns false if the stream is already filtered.
bool GetUnfilteredStreamRef(unsigned char const** buffer, size_t* len) const {
SkPdfMarkObjectUsed();
return true;
}
+ // Add a stream to this Dictionarry. Asserts we do not have yet a stream.
bool addStream(const unsigned char* buffer, size_t len) {
SkPdfMarkObjectUsed();
}
}
+ // Returns the string representation of the object value.
SkString toString(int firstRowLevel = 0, int level = 0) {
SkString str;
appendSpaces(&str, firstRowLevel);
bool applyDCTDecodeFilter();
};
+// These classes are provided for convenience. You still have to make sure an SkPdfInteger
+// is indeed an Integer.
class SkPdfStream : public SkPdfNativeObject {};
class SkPdfArray : public SkPdfNativeObject {};
class SkPdfString : public SkPdfNativeObject {};
#ifndef SkPdfNativeTokenizer_DEFINED
#define SkPdfNativeTokenizer_DEFINED
-#include "SkPdfConfig.h"
+#include <math.h>
+#include <string.h>
+#include "SkPdfConfig.h"
#include "SkTDArray.h"
#include "SkTDict.h"
-#include <math.h>
-#include <string.h>
+
+// All these constants are defined by the PDF 1.4 Spec.
class SkPdfDictionary;
class SkPdfImageDictionary;
+class SkPdfNativeDoc;
+class SkPdfNativeObject;
+
// White Spaces
#define kNUL_PdfWhiteSpace '\x00'
// 4) vector (e.f. T type[256] .. return type[ch] ...
// 5) manually build the expression with least number of operators, e.g. for consecutive
// chars, we can use an binary equal ignoring last bit
-#define isPdfWhiteSpace(ch) (((ch)==kNUL_PdfWhiteSpace)||((ch)==kHT_PdfWhiteSpace)||((ch)==kLF_PdfWhiteSpace)||((ch)==kFF_PdfWhiteSpace)||((ch)==kCR_PdfWhiteSpace)||((ch)==kSP_PdfWhiteSpace))
+#define isPdfWhiteSpace(ch) (((ch)==kNUL_PdfWhiteSpace)|| \
+ ((ch)==kHT_PdfWhiteSpace)|| \
+ ((ch)==kLF_PdfWhiteSpace)|| \
+ ((ch)==kFF_PdfWhiteSpace)|| \
+ ((ch)==kCR_PdfWhiteSpace)|| \
+ ((ch)==kSP_PdfWhiteSpace))
#define isPdfEOL(ch) (((ch)==kLF_PdfWhiteSpace)||((ch)==kCR_PdfWhiteSpace))
const unsigned char* skipPdfWhiteSpaces(const unsigned char* buffer, const unsigned char* end);
const unsigned char* endOfPdfToken(const unsigned char* start, const unsigned char* end);
-// TODO(edisonn): typedef read and integer tyepes? make less readable...
-//typedef double SkPdfReal;
-//typedef int64_t SkPdfInteger;
-
-// an allocator only allocates memory, and it deletes it all when the allocator is destroyed
-// this would allow us not to do any garbage collection while we parse or draw a pdf, and defere it
-// while the user is looking at the image
-
-class SkPdfNativeObject;
-
-class SkPdfAllocator {
#define BUFFER_SIZE 1024
- SkTDArray<SkPdfNativeObject*> fHistory;
- SkTDArray<void*> fHandles;
- SkPdfNativeObject* fCurrent;
- int fCurrentUsed;
-
- SkPdfNativeObject* allocBlock();
- size_t fSizeInBytes;
+/** \class SkPdfAllocator
+ *
+ * An allocator only allocates memory, and it deletes it all when the allocator is destroyed.
+ * This strategy would allow us not to do any garbage collection while we parse and/or render
+ * a pdf.
+ *
+ */
+class SkPdfAllocator {
public:
SkPdfAllocator() {
fSizeInBytes = sizeof(*this);
~SkPdfAllocator();
+ // Allocates an object. It will be reset automatically when ~SkPdfAllocator() is called.
SkPdfNativeObject* allocObject();
- // TODO(edisonn): free this memory in destructor, track the usage?
+ // Allocates a buffer. It will be freed automatically when ~SkPdfAllocator() is called.
void* alloc(size_t bytes) {
void* data = malloc(bytes);
fHandles.push(data);
return data;
}
+ // Returns the number of bytes used in this allocator.
size_t bytesUsed() const {
return fSizeInBytes;
}
-};
-class SkPdfNativeDoc;
-const unsigned char* nextObject(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* token, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
+private:
+ SkTDArray<SkPdfNativeObject*> fHistory;
+ SkTDArray<void*> fHandles;
+ SkPdfNativeObject* fCurrent;
+ int fCurrentUsed;
+
+ SkPdfNativeObject* allocBlock();
+ size_t fSizeInBytes;
+};
+// Type of a parsed token.
enum SkPdfTokenType {
kKeyword_TokenType,
kObject_TokenType,
};
+
+/** \struct PdfToken
+ *
+ * Stores the result of the parsing - a keyword or an object.
+ *
+ */
struct PdfToken {
- const char* fKeyword;
- size_t fKeywordLength;
- SkPdfNativeObject* fObject;
- SkPdfTokenType fType;
+ const char* fKeyword;
+ size_t fKeywordLength;
+ SkPdfNativeObject* fObject;
+ SkPdfTokenType fType;
PdfToken() : fKeyword(NULL), fKeywordLength(0), fObject(NULL) {}
};
+/** \class SkPdfNativeTokenizer
+ *
+ * Responsible to tokenize a stream in small tokens, eityh a keyword or an object.
+ * A renderer can feed on the tokens and render a pdf.
+ *
+ */
class SkPdfNativeTokenizer {
public:
- SkPdfNativeTokenizer(SkPdfNativeObject* objWithStream, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
- SkPdfNativeTokenizer(const unsigned char* buffer, int len, SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
+ SkPdfNativeTokenizer(SkPdfNativeObject* objWithStream,
+ SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
+ SkPdfNativeTokenizer(const unsigned char* buffer, int len,
+ SkPdfAllocator* allocator, SkPdfNativeDoc* doc);
virtual ~SkPdfNativeTokenizer();
+ // Reads one token. Returns false if there are no more tokens.
bool readToken(PdfToken* token);
- bool readTokenCore(PdfToken* token);
+
+ // Put back a token to be read in the nextToken read. Only one token is allowed to be put
+ // back. Must not necesaarely be the last token read.
void PutBack(PdfToken token);
+
+ // Reads the inline image that is present in the stream. At this point we just consumed the ID
+ // token already.
SkPdfImageDictionary* readInlineImage();
private:
+ bool readTokenCore(PdfToken* token);
+
SkPdfNativeDoc* fDoc;
SkPdfAllocator* fAllocator;
PdfToken fPutBack;
};
+const unsigned char* nextObject(const unsigned char* start, const unsigned char* end,
+ SkPdfNativeObject* token,
+ SkPdfAllocator* allocator,
+ SkPdfNativeDoc* doc);
+
#endif // SkPdfNativeTokenizer_DEFINED
projects / platform / upstream / libSkiaSharp.git / commitdiff