import sys import datatypes from autogen.pdfspec_autogen import * knowTypes = { '(any)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'], '(undefined)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'], '(various)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'], 'array': ['SkPdfArray*', 'ArrayFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'], 'boolean': ['bool', 'BoolFromDictionary', datatypes.PdfBoolean('false'), 'ret->podofo()->GetDataType() == ePdfDataType_Bool'], 'date': ['SkPdfDate', 'DateFromDictionary', datatypes.PdfDateNever(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'], 'dictionary': ['SkPdfDictionary*', 'DictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary'], 'function': ['SkPdfFunction', 'FunctionFromDictionary', datatypes.PdfFunctionNone(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'], 'integer': ['long', 'LongFromDictionary', datatypes.PdfInteger(0), 'ret->podofo()->GetDataType() == ePdfDataType_Number'], 'file_specification': ['SkPdfFileSpec', 'FileSpecFromDictionary', datatypes.FileSpecNone(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'], 'name': ['std::string', 'NameFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_Name'], 'tree': ['SkPdfTree*', 'TreeFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'], 'number': ['double', 'DoubleFromDictionary', datatypes.PdfNumber(0), 'ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number'], 'rectangle': ['SkRect*', 'SkRectFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array && ret->podofo()->GetArray().GetLength() == 4'], 'stream': ['SkPdfStream*', 'StreamFromDictionary', datatypes.CppNull(), 'ret->podofo()->HasStream()'], 'string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'], 'text': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'], 'text string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'], 'matrix': ['SkMatrix*', 'SkMatrixFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array && ret->podofo()->GetArray().GetLength() == 4'], } class PdfField: def __init__(self, parent, name, abr): self.fParent = parent self.fName = name self.fAbr = abr self.fDefault = '' self.fTypes = '' self.fCppName = '' self.fEnumValues = [] self.fHasMust = False self.fMustBe = [] self.fComment = '' def must(self, value): self.fHasMust = True self.fMustBe = value return self def default(self, value): self.fDefault = value return self def multiple(self, enumValues): self.fEnumValues = enumValues return self def name(self, name): self.fCppName = name return self def type(self, types): # TODO (edisonn): if simple type, use it, otherwise set it to Dictionary, and set a mask for valid types, like array or name types = types.strip() types = types.replace(' or ', ' ') types = types.replace(' or,', ' ') types = types.replace(',or ', ' ') types = types.replace(',or,', ' ') types = types.replace(',', ' ') types = types.replace('text', ' ') # TODO(edisonn): what is the difference between 'text string' and 'string'? types = types.replace('file specification', 'file_specification') self.fTypes = types return self def comment(self, comment): self.fComment = comment return self def done(self): return self.fParent class PdfClassField: def __init__(self, parent, required, version='', inheritable=False): #self.fProp = '' self.fParent = parent self.fRequired = required self.fVersion = version self.fInheritable = inheritable def field(self, name, abr=''): self.fProp = PdfField(self, name, abr) return self.fProp def done(self): return self.fParent class PdfClass: def __init__(self, name, base, comment): self.fFields = [] self.fIncludes = [] self.fCCPublic = [] self.fCCPrivate = [] self.fName = name self.fBase = base self.fComment = comment self.fEnumSubclasses = [] self.fEnum = '!UNDEFINED' self.fEnumEnd = '!UNDEFINED' self.fCheck = '' def check(self, ifCheck): self.fCheck = ifCheck return self def required(self, badDefault): field = PdfClassField(self, True) field.fBadDefault = badDefault self.fFields.append(field) return field def optional(self): field = PdfClassField(self, False) self.fFields.append(field) return field #([Required] [;] [inheritable] [;] [version]; [comments]) # version: PDF [d].[d] # ; separate props #inheritable #version #required, if #optional, if def include(self, path): self.fIncludes.append(path) return self def carbonCopyPublic(self, cc): self.fCCPublic.append(cc) return self def carbonCopyPrivate(self, cc): self.fCCPrivate.append(cc) return self def done(self): return class PdfClassManager: def __init__(self): self.fClasses = {} self.fClassesNamesInOrder = [] def addClass(self, name, base='Object', comment=''): if name == 'Object': cls = PdfClass(name, '', comment) else: cls = PdfClass(name, base, comment) self.fClasses[name] = cls self.fClassesNamesInOrder.append(name) return cls def writeEnum(self, fileEnums, enum, enumToCls): fileEnums.write(' ' + enum + ',\n') cls = enumToCls[enum] cls.fEnumSubclasses.sort() cnt = 0 for sub in cls.fEnumSubclasses: self.writeEnum(fileEnums, cls.fEnumSubclasses[cnt], enumToCls) cnt = cnt + 1 if cnt != 0: fileEnums.write(' ' + cls.fEnumEnd + ',\n') def writeAsNull(self, fileClass, cls, enumToCls): fileClass.write(' virtual SkPdf' + cls.fName +'* as' + cls.fName + '() {return NULL;}\n') fileClass.write(' virtual const SkPdf' + cls.fName +'* as' + cls.fName + '() const {return NULL;}\n') fileClass.write('\n') cnt = 0 for sub in cls.fEnumSubclasses: self.writeAsNull(fileClass, enumToCls[cls.fEnumSubclasses[cnt]], enumToCls) cnt = cnt + 1 def writeAsFoo(self, fileClass, cls, enumToCls): # TODO(edisonn): add a container, with sections, public, private, default, ... # the end code will be grouped # me fileClass.write('public:\n') fileClass.write(' virtual SkPdf' + cls.fName +'* as' + cls.fName + '() {return this;}\n') fileClass.write(' virtual const SkPdf' + cls.fName +'* as' + cls.fName + '() const {return this;}\n') fileClass.write('\n') if cls.fName == 'Object': cnt = 0 for sub in cls.fEnumSubclasses: self.writeAsNull(fileClass, enumToCls[cls.fEnumSubclasses[cnt]], enumToCls) cnt = cnt + 1 if cls.fName != 'Object': fileClass.write('private:\n') base = self.fClasses[cls.fBase] cnt = 0 for sub in base.fEnumSubclasses: if enumToCls[base.fEnumSubclasses[cnt]].fName != cls.fName: self.writeAsNull(fileClass, enumToCls[base.fEnumSubclasses[cnt]], enumToCls) cnt = cnt + 1 def determineAllMustBe(self, cls, field, enumToCls): mustBe = [] for sub in cls.fEnumSubclasses: mustBe = mustBe + self.determineAllMustBe(enumToCls[sub], field, enumToCls) for subField in cls.fFields: if subField.fProp.fName == field.fProp.fName: mustBe = mustBe + subField.fProp.fMustBe # while cls.fBase != '': # cls = self.fClasses[cls.fBase] # # TODO(edisonn): bad perf # for subField in cls.fFields: # if subField.fProp.fName == field.fProp.fName: # mustBe = mustBe + subField.fProp.fMustBe return mustBe def write(self): global fileHeaders global fileHeadersCpp global knowTypes # generate enum enumsRoot = [] enumToCls = {} for name in self.fClasses: cls = self.fClasses[name] cls.fEnum = 'k' + name + '_SkPdfObjectType' cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType' fileHeaders.write('#include "SkPdf' + cls.fName + '_autogen.h"\n') fileHeadersCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\n') if cls.fBase != '': self.fClasses[cls.fBase].fEnumSubclasses.append(cls.fEnum) if cls.fBase == '': enumsRoot.append(cls.fEnum) enumToCls[cls.fEnum] = cls enumsRoot.sort() # TODO(edisonn): move each .h in it's own file # write imports # write enums fileEnums = open('SkPdfEnums_autogen.h', 'w') fileEnums.write('#ifndef __DEFINED__SkPdfEnums\n') fileEnums.write('#define __DEFINED__SkPdfEnums\n') fileEnums.write('\n') fileEnums.write('enum SkPdfObjectType {\n') for enum in enumsRoot: self.writeEnum(fileEnums, enum, enumToCls) fileEnums.write('};\n') fileEnums.write('\n') # write forward class declaration for name in self.fClassesNamesInOrder: fileEnums.write('class SkPdf' + name + ';\n') fileEnums.write('\n') fileEnums.write('#endif // __DEFINED__SkPdfEnums\n') fileEnums.close() for name in self.fClassesNamesInOrder: cls = self.fClasses[name] enum = cls.fEnum fileClass = open('SkPdf' + cls.fName + '_autogen.h', 'w') fileClassCpp = open('SkPdf' + cls.fName + '_autogen.cpp', 'w') fileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n') fileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n') fileClass.write('\n') fileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n') fileClass.write('#include "SkPdfUtils.h"\n') fileClass.write('#include "SkPdfEnums_autogen.h"\n') fileClass.write('#include "SkPdfArray_autogen.h"\n') if cls.fBase != '': fileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n') fileClass.write('\n') if cls.fComment != '': fileClass.write('// ' + cls.fComment + '\n') if cls.fBase == '': fileClass.write('class SkPdf' + cls.fName + ' {\n') else: fileClass.write('class SkPdf' + cls.fName + ' : public SkPdf' + cls.fBase + ' {\n') fileClass.write('public:\n') fileClass.write(' virtual SkPdfObjectType getType() const { return ' + cls.fEnum + ';}\n') if len(cls.fEnumSubclasses) == 0: fileClass.write(' virtual SkPdfObjectType getTypeEnd() const { return (SkPdfObjectType)(' + cls.fEnum + ' + 1);}\n') else: fileClass.write(' virtual SkPdfObjectType getTypeEnd() const { return ' + cls.fEnumEnd + ';}\n') self.writeAsFoo(fileClass, cls, enumToCls) fileClass.write('public:\n') for cc in cls.fCCPublic: fileClass.write(' ' + cc + '\n') fileClass.write('private:\n') for cc in cls.fCCPrivate: fileClass.write(' ' + cc + '\n') if cls.fBase == '': fileClass.write('protected:\n') fileClass.write(' const PdfMemDocument* fPodofoDoc;\n') fileClass.write(' const PdfObject* fPodofoObj;\n') fileClass.write('\n') fileClass.write('public:\n') fileClass.write(' SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc = NULL, const PdfObject* podofoObj = NULL) : fPodofoDoc(podofoDoc), fPodofoObj(podofoObj) {}\n') fileClass.write(' SkPdf' + cls.fName + '(const SkPdf' + cls.fName + '& from) : fPodofoDoc(from.fPodofoDoc), fPodofoObj(from.fPodofoObj) {}\n') fileClass.write('\n') fileClass.write(' const PdfMemDocument* doc() const { return fPodofoDoc;}\n') fileClass.write(' const PdfObject* podofo() const { return fPodofoObj;}\n') else: fileClass.write('public:\n') fileClass.write(' SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc = NULL, const PdfObject* podofoObj = NULL) : SkPdf' + cls.fBase + '(podofoDoc, podofoObj) {}\n') fileClass.write('\n') fileClass.write(' SkPdf' + cls.fName + '(const SkPdf' + cls.fName + '& from) : SkPdf' + cls.fBase + '(from.fPodofoDoc, from.fPodofoObj) {}\n') fileClass.write('\n') #check required fieds, also, there should be an internal_valid() manually wrote for complex # situations # right now valid return true fileClass.write(' virtual bool valid() const {return true;}\n') fileClass.write('\n') fileClass.write(' SkPdf' + cls.fName + '& operator=(const SkPdf' + cls.fName + '& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}\n') fileClass.write('\n') for field in cls.fFields: prop = field.fProp if prop.fCppName != '': lines = prop.fComment.split('\n') if prop.fComment != '' and len(lines) > 0: fileClass.write('/** ' + lines[0] + '\n') for line in lines[1:]: fileClass.write(' * ' + line + '\n') fileClass.write('**/\n') if prop.fCppName[0] == '[': fileClass.write('/*\n') # comment code of the atributes that can have any name fileClassCpp.write('/*\n') # comment code of the atributes that can have any name # TODO(edisonn): has_foo(); fileClass.write(' bool has_' + prop.fCppName + '() const {\n') fileClass.write(' return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", NULL));\n') fileClass.write(' }\n') fileClass.write('\n') if len(prop.fTypes.split()) == 1: t = prop.fTypes.strip() fileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName + '() const;\n') fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '() const {\n') fileClassCpp.write(' ' + knowTypes[t][0] + ' ret;\n') fileClassCpp.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n') if field.fRequired == False and prop.fDefault != '': fileClassCpp.write(' return ' + prop.fDefault.toCpp() + ';\n'); else: fileClassCpp.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n') fileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + ';\n'); fileClassCpp.write('}\n') fileClassCpp.write('\n') else: for type in prop.fTypes.split(): t = type.strip() fileClass.write(' bool is' + prop.fCppName + 'A' + t.title() + '() const {\n') fileClass.write(' SkPdfObject* ret = NULL;\n') fileClass.write(' if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return false;\n') fileClass.write(' return ' + knowTypes[t][3] + ';\n') fileClass.write(' }\n') fileClass.write('\n') fileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '() const;\n') fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '() const {\n') fileClassCpp.write(' ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n') fileClassCpp.write(' if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n') fileClassCpp.write(' // TODO(edisonn): warn about missing required field, assert for known good pdfs\n') fileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + ';\n') fileClassCpp.write('}\n') fileClassCpp.write('\n') if prop.fCppName[0] == '[': fileClass.write('*/\n') # comment code of the atributes that can have any name fileClassCpp.write('*/\n') # comment code of the atributes that can have any name fileClass.write('};\n') fileClass.write('\n') fileClass.write('#endif // __DEFINED__SkPdf' + cls.fName + '\n') fileClass.close() fileClassCpp.close() # generate constructor when knowing the type # later, p2, generate constructor when not knowing the type - very similar with parsing? # generate parser # TODO(edisonn): fast recognition based on must attributes. fileMapper = open('SkPdfPodofoMapper_autogen.h', 'w') fileMapperCpp = open('SkPdfPodofoMapper_autogen.cpp', 'w') fileMapper.write('#ifndef __DEFINED__SkPdfPodofoMapper\n') fileMapper.write('#define __DEFINED__SkPdfPodofoMapper\n') fileMapper.write('\n') fileMapper.write('#include "SkPdfHeaders_autogen.h"\n') fileMapperCpp.write('#include "SkPdfPodofoMapper_autogen.h"\n') # fileMapper.write('class PodofoMapper {\n') # fileMapper.write('public:\n') for name in self.fClassesNamesInOrder: cls = self.fClasses[name] fileMapper.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out);\n') fileMapperCpp.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out) {\n') fileMapperCpp.write(' return map' + name + '(*in.doc(), *in.podofo(), out);\n') fileMapperCpp.write('}\n') fileMapperCpp.write('\n') fileMapper.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out);\n') fileMapperCpp.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n') fileMapperCpp.write(' if (!is' + name + '(podofoDoc, podofoObj)) return false;\n') fileMapperCpp.write('\n') # stream must be last one hasStream = False for sub in cls.fEnumSubclasses: if cls.fName == 'Object' and enumToCls[sub].fName == 'Stream': hasStream = True else: fileMapperCpp.write(' if (map' + enumToCls[sub].fName + '(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n') if hasStream: fileMapperCpp.write(' if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n') fileMapperCpp.write('\n') fileMapperCpp.write(' *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n') fileMapperCpp.write(' return true;\n') fileMapperCpp.write('}\n') fileMapperCpp.write('\n') for name in self.fClassesNamesInOrder: cls = self.fClasses[name] fileMapper.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);\n') fileMapperCpp.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n') if cls.fCheck != '': fileMapperCpp.write(' return ' + cls.fCheck + ';\n') else: cntMust = 0 for field in cls.fFields: prop = field.fProp if prop.fHasMust: cntMust = cntMust + 1 fileMapperCpp.write(' ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n') fileMapperCpp.write(' if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n') eval = ''; # TODO(edisonn): this could get out of hand, and could have poor performance if continued on this path # but if we would write our parser, then best thing would be to create a map of (key, value) -> to bits # and at each (key, value) we do an and with the bits existent, then we check what bits are left, which would tell the posible types of this dictionary # and for non unique posinilities (if any) based on context, or the requester of dictionry we can determine fast the dictionary type mustBe = self.determineAllMustBe(cls, field, enumToCls) if len(mustBe) > 0: for cnd in mustBe: if eval == '': eval = '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')' else: eval = eval + ' && ' + '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')' fileMapperCpp.write(' if (' + eval + ') return false;\n') fileMapperCpp.write('\n') fileMapperCpp.write(' return true;\n') fileMapperCpp.write('}\n') fileMapperCpp.write('\n') fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data);\n') fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data) {\n') fileMapperCpp.write(' const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);\n') fileMapperCpp.write(' if (value == NULL) { return false; }\n') fileMapperCpp.write(' if (data == NULL) { return true; }\n') fileMapperCpp.write(' return map' + name + '(*pdfDoc, *value, (SkPdf' + name + '**)data);\n') fileMapperCpp.write('}\n') fileMapperCpp.write('\n') fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data);\n') fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data) {\n') fileMapperCpp.write(' if (' + name + 'FromDictionary(pdfDoc, dict, key, data)) return true;\n') fileMapperCpp.write(' if (abr == NULL || *abr == \'\\0\') return false;\n') fileMapperCpp.write(' return ' + name + 'FromDictionary(pdfDoc, dict, abr, data);\n') fileMapperCpp.write('}\n') fileMapperCpp.write('\n') #fileMapper.write('};\n') fileMapper.write('\n') fileMapper.write('#endif // __DEFINED__SkPdfPodofoMapper\n') fileMapper.close() return def generateCode(): global fileHeaders global fileHeadersCpp global knowTypes fileHeaders = open('SkPdfHeaders_autogen.h', 'w') fileHeadersCpp = open('SkPdfHeaders_autogen.cpp', 'w') fileHeaders.write('#ifndef __DEFINED__SkPdfHeaders\n') fileHeaders.write('#define __DEFINED__SkPdfHeaders\n') fileHeaders.write('\n') fileHeaders.write('#include "SkPdfEnums_autogen.h"\n') fileHeadersCpp.write('#include "SkPdfHeaders_autogen.h"\n') manager = PdfClassManager() manager.addClass('Object') manager.addClass('Null').check('podofoObj.GetDataType() == ePdfDataType_Null') manager.addClass('Boolean').check('podofoObj.GetDataType() == ePdfDataType_Bool')\ .carbonCopyPublic('bool value() const {return fPodofoObj->GetBool();}') manager.addClass('Integer').check('podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real')\ .carbonCopyPublic('long value() const {return fPodofoObj->GetNumber();}') manager.addClass('Number', 'Integer').check('podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real')\ .carbonCopyPublic('double value() const {return fPodofoObj->GetReal();}') manager.addClass('Name').check('podofoObj.GetDataType() == ePdfDataType_Name')\ .carbonCopyPublic('const std::string& value() const {return fPodofoObj->GetName().GetName();}') manager.addClass('Reference').check('podofoObj.GetDataType() == ePdfDataType_Reference') manager.addClass('Array').check('podofoObj.GetDataType() == ePdfDataType_Array')\ .carbonCopyPublic('const int size() const {return fPodofoObj->GetArray().GetSize();}')\ .carbonCopyPublic('SkPdfObject* operator[](int i) const { SkPdfObject* ret = NULL; skpdfmap(*fPodofoDoc, fPodofoObj->GetArray()[i], &ret); return ret; }')\ manager.addClass('String').check('podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString')\ .carbonCopyPublic('const std::string& value() const {return fPodofoObj->GetString().GetStringUtf8();}') manager.addClass('HexString', 'String').check('podofoObj.GetDataType() == ePdfDataType_HexString')\ .carbonCopyPublic('const std::string& value() const {return fPodofoObj->GetString().GetStringUtf8();}') manager.addClass('Dictionary').check('podofoObj.GetDataType() == ePdfDataType_Dictionary')\ .carbonCopyPublic('SkPdfObject* get(const char* dictionaryKeyName) const {return new SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\ .carbonCopyPublic('SkPdfObject* get(const char* dictionaryKeyName) {return new SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\ manager.addClass('Stream') # attached to a dictionary in podofo # these classes are not explicitely backed by a table in the pdf spec manager.addClass('XObjectDictionary', 'Dictionary') manager.addClass('FontDictionary', 'Dictionary') manager.addClass('TrueTypeFontDictionary', 'Type1FontDictionary')\ .required('NULL')\ .field('Subtype')\ .name('Subtype')\ .type('name')\ .comment('')\ .must([datatypes.PdfName('TrueType')])\ .done().done()\ addDictionaryTypesTo(knowTypes) buildPdfSpec(manager) manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\ .required('NULL')\ .field('Subtype')\ .name('Subtype')\ .type('name')\ .comment('')\ .must([datatypes.PdfName('MMType1')])\ .done().done()\ manager.write() fileHeaders.write('#endif // __DEFINED__SkPdfHeaders\n') fileHeaders.close() fileHeadersCpp.close() return 1 if '__main__' == __name__: sys.exit(generateCode())