| import sys |
| |
| class PdfName: |
| def __init__(self, name, abr=''): |
| self.fName = name |
| self.fAbr = abr |
| |
| def toCpp(self): |
| return '\"' + self.fName + '\"' |
| |
| class PdfString: |
| def __init__(self, value): |
| self.fValue = value |
| |
| def toCpp(self): |
| return '\"' + self.fValue + '\"' |
| |
| class PdfInteger: |
| def __init__(self, value): |
| self.fValue = value |
| |
| def toCpp(self): |
| return str(self.fValue) |
| |
| class PdfReal: |
| def __init__(self, value): |
| self.fValue = value |
| |
| def toCpp(self): |
| return str(self.fValue) |
| |
| class PdfString: |
| def __init__(self, value): |
| self.fValue = value |
| |
| def toCpp(self): |
| return self.fValue |
| |
| class PdfBoolean: |
| def __init__(self, value): |
| self.fValue = value |
| |
| def toCpp(self): |
| return self.fValue |
| |
| class CppNull: |
| def toCpp(self): |
| return 'NULL' |
| |
| |
| class PdfField: |
| def __init__(self, parent, name, abr): |
| self.fParent = parent |
| self.fName = name |
| self.fAbr = abr |
| |
| self.fDefault = '' |
| self.fType = '' |
| self.fCppName = '' |
| self.fCppType = '' |
| self.fCppReader = '' |
| self.fValidOptions = [] |
| self.fHasMust = False |
| self.fMustBe = '' |
| |
| def must(self, value): |
| self.fHasMust = True |
| self.fMustBe = value |
| return self |
| |
| def default(self, value): |
| self.fDefault = value |
| return self |
| |
| def number(self, name): |
| self.fType = 'number' |
| self.fCppName = name |
| self.fCppType = 'double' |
| self.fCppReader = 'DoubleFromDictionary' |
| return self |
| |
| def integer(self, name): |
| self.fType = 'integer' |
| self.fCppName = name |
| self.fCppType = 'long' |
| self.fCppReader = 'LongFromDictionary' |
| return self |
| |
| def real(self, name): |
| self.fType = 'real' |
| self.fCppName = name |
| self.fCppType = 'double' |
| self.fCppReader = 'DoubleFromDictionary' |
| return self |
| |
| def name(self, name): |
| self.fType = 'name' |
| self.fCppName = name |
| self.fCppType = 'std::string' |
| self.fCppReader = 'NameFromDictionary' |
| return self |
| |
| def string(self, name): |
| self.fType = 'string' |
| self.fCppName = name |
| self.fCppType = 'std::string' |
| self.fCppReader = 'StringFromDictionary' |
| return self |
| |
| def multiple(self, validOptions): |
| self.fValidOptions = validOptions |
| return self |
| |
| def dictionary(self, name): |
| self.fType = 'dictionary' |
| self.fCppName = name |
| self.fDictionaryType = 'Resources' # TODO(edisonn): Dictionary? |
| self.fCppReader = 'DictionaryFromDictionary' |
| self.fDefault = CppNull() |
| return self |
| |
| def type(self, type): |
| # TODO (edisonn): if simple type, use it, otherwise set it to Dictionary, and set a mask for valid types, like array or name |
| self.fType = 'dictionary' |
| self.fDictionaryType = 'Dictionary' |
| self.fCppReader = 'DictionaryFromDictionary' |
| self.fDefault = CppNull() |
| return self |
| |
| def comment(self, comment): |
| return self |
| |
| def done(self): |
| return self.fParent |
| |
| |
| class PdfClassField: |
| def __init__(self, parent, required, version='', inheritable=False, comment=''): |
| #self.fProp = '' |
| self.fParent = parent |
| self.fRequired = required |
| self.fVersion = version |
| self.fInheritable = inheritable |
| self.fComment = comment |
| |
| 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' |
| |
| 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 longName(self, name): |
| ret = '' |
| while name != '': |
| cls = self.fClasses[name] |
| ret = name + ret |
| name = cls.fBase |
| |
| return ret |
| |
| |
| def writeEnum(self, enum, enumToCls): |
| print(' ' + enum + ',') |
| cls = enumToCls[enum] |
| cls.fEnumSubclasses.sort() |
| |
| cnt = 0 |
| for sub in cls.fEnumSubclasses: |
| self.writeEnum(cls.fEnumSubclasses[cnt], enumToCls) |
| cnt = cnt + 1 |
| |
| if cnt != 0: |
| print(' ' + cls.fEnumEnd + ',') |
| |
| |
| def writeAsNull(self, cls, enumToCls): |
| print(' virtual SkPdf' + cls.fName +'* as' + cls.fName + '() {return NULL;}') |
| print(' virtual const SkPdf' + cls.fName +'* as' + cls.fName + '() const {return NULL;}') |
| print |
| |
| cnt = 0 |
| for sub in cls.fEnumSubclasses: |
| self.writeAsNull(enumToCls[cls.fEnumSubclasses[cnt]], enumToCls) |
| cnt = cnt + 1 |
| |
| |
| def writeAsFoo(self, cls, enumToCls): |
| # TODO(edisonn): add a container, with sections, public, private, default, ... |
| # the end code will be grouped |
| |
| # me |
| print('public:') |
| print(' virtual SkPdf' + cls.fName +'* as' + cls.fName + '() {return this;}') |
| print(' virtual const SkPdf' + cls.fName +'* as' + cls.fName + '() const {return this;}') |
| print |
| |
| if cls.fName == 'Object': |
| cnt = 0 |
| for sub in cls.fEnumSubclasses: |
| self.writeAsNull(enumToCls[cls.fEnumSubclasses[cnt]], enumToCls) |
| cnt = cnt + 1 |
| |
| if cls.fName != 'Object': |
| print('private:') |
| base = self.fClasses[cls.fBase] |
| cnt = 0 |
| for sub in base.fEnumSubclasses: |
| if enumToCls[base.fEnumSubclasses[cnt]].fName != cls.fName: |
| self.writeAsNull(enumToCls[base.fEnumSubclasses[cnt]], enumToCls) |
| cnt = cnt + 1 |
| |
| |
| |
| def write(self): |
| # generate enum |
| enumsRoot = [] |
| |
| enumToCls = {} |
| |
| for name in self.fClasses: |
| cls = self.fClasses[name] |
| enum = self.longName(name) |
| cls.fEnum = 'k' + enum + '_SkPdfObjectType' |
| cls.fEnumEnd = 'k' + enum + '__End_SkPdfObjectType' |
| |
| 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 |
| print('enum SkPdfObjectType {') |
| for enum in enumsRoot: |
| self.writeEnum(enum, enumToCls) |
| print('};') |
| print |
| |
| # write forward class declaration |
| for name in self.fClassesNamesInOrder: |
| print('class SkPdf' + name + ';') |
| print |
| |
| for name in self.fClassesNamesInOrder: |
| cls = self.fClasses[name] |
| enum = cls.fEnum |
| |
| if cls.fBase == '': |
| print('class SkPdf' + cls.fName + ' {') |
| else: |
| print('class SkPdf' + cls.fName + ' : public SkPdf' + cls.fBase + ' {') |
| |
| print('public:') |
| print(' virtual SkPdfObjectType getType() const { return ' + cls.fEnum + ';}') |
| if len(cls.fEnumSubclasses) == 0: |
| print(' virtual SkPdfObjectType getTypeEnd() const { return (SkPdfObjectType)(' + cls.fEnum + ' + 1);}') |
| else: |
| print(' virtual SkPdfObjectType getTypeEnd() const { return ' + cls.fEnumEnd + ';}') |
| |
| |
| self.writeAsFoo(cls, enumToCls) |
| |
| print('public:') |
| for cc in cls.fCCPublic: |
| print(' ' + cc) |
| |
| print('private:') |
| for cc in cls.fCCPrivate: |
| print(' ' + cc) |
| |
| if cls.fBase == '': |
| print('protected:') |
| print(' const PdfMemDocument* fPodofoDoc;') |
| print(' const PdfObject* fPodofoObj;') |
| print |
| print('public:') |
| print(' SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc, const PdfObject* podofoObj) : fPodofoDoc(podofoDoc), fPodofoObj(podofoObj) {}') |
| print(' const PdfObject* podofo() const { return fPodofoObj;}') |
| else: |
| print('public:') |
| print(' SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc, const PdfObject* podofoObj) : SkPdf' + cls.fBase + '(podofoDoc, podofoObj) {}') |
| print |
| |
| #check required fieds, also, there should be an internal_valid() manually wrote for complex |
| # situations |
| # right now valid return true |
| print(' virtual bool valid() const {return true;}') |
| print |
| |
| for field in cls.fFields: |
| prop = field.fProp |
| if prop.fCppName != '': |
| if prop.fType != 'dictionary': |
| print(' ' + prop.fCppType + ' ' + prop.fCppName + '() const {') |
| print(' ' + prop.fCppType + ' ret;') |
| print(' if (' + prop.fCppReader + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;') |
| if field.fRequired == False: |
| print(' return ' + prop.fDefault.toCpp() + ';'); |
| if field.fRequired == True: |
| print(' // TODO(edisonn): warn about missing required field, assert for known good pdfs') |
| print(' return ' + field.fBadDefault + ';'); |
| print(' }') |
| print |
| |
| if prop.fType == 'dictionary': |
| print(' SkPdf' + prop.fDictionaryType + '* ' + prop.fCppName + '() const {') |
| print(' SkPdfObject* dict = NULL;') |
| print(' if (' + prop.fCppReader + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &dict) && dict != NULL) {') |
| print(' SkPdf' + prop.fDictionaryType + '* ret = new SkPdf' + prop.fDictionaryType + '(fPodofoDoc, dict->podofo());') |
| print(' delete dict; dict = NULL;') |
| print(' return ret;') |
| print(' }') |
| if field.fRequired == False: |
| print(' return ' + prop.fDefault.toCpp() + ';'); |
| if field.fRequired == True: |
| print(' // TODO(edisonn): warn about missing required field, assert for known good pdfs') |
| print(' return ' + field.fBadDefault + ';'); |
| print(' }') |
| print |
| |
| |
| |
| print('};') |
| print |
| print |
| |
| |
| |
| # 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. |
| print('class PodofoMapper {') |
| print('public:') |
| for name in self.fClassesNamesInOrder: |
| cls = self.fClasses[name] |
| |
| print(' static bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {') |
| print(' if (!isA' + name + '(podofoDoc, podofoObj)) return false;') |
| print |
| |
| for sub in cls.fEnumSubclasses: |
| print(' if (map' + enumToCls[sub].fName + '(podofoDoc, podofoObj, out)) return true;') |
| |
| print |
| |
| print(' *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);') |
| print(' return true;') |
| print(' }') |
| print |
| |
| for name in self.fClassesNamesInOrder: |
| cls = self.fClasses[name] |
| |
| print(' static bool isA' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {') |
| |
| cntMust = 0 |
| for field in cls.fFields: |
| prop = field.fProp |
| if prop.fHasMust: |
| cntMust = cntMust + 1 |
| print(' ' + prop.fCppType + ' ' + prop.fCppName + ';') |
| print(' if (!' + prop.fCppReader + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;') |
| print(' if (' + prop.fCppName + ' != ' + prop.fMustBe.toCpp() + ') return false;') |
| print |
| |
| # hack, we only care about dictionaries now, so ret tru only if there is a match |
| if cntMust != 0 or name == 'Object' or name == 'Dictionary': |
| print(' return true;') |
| else: |
| print(' return false;') |
| |
| print(' }') |
| print |
| |
| print('};') |
| print |
| |
| return |
| |
| def generateCode(): |
| all = PdfClassManager() |
| |
| all.addClass('Object') |
| all.addClass('Null') |
| all.addClass('Boolean') |
| all.addClass('Integer') |
| all.addClass('Real') |
| all.addClass('Name') |
| all.addClass('Stream') |
| all.addClass('Reference') |
| all.addClass('Array') |
| all.addClass('Dictionary').optional().field('Resources', '').dictionary("r") #.inherited_from_page_tree() |
| |
| all.addClass('Resources', 'Dictionary') |
| |
| all.addClass('XObject', 'Dictionary').required('""').field('Type').must(PdfName('XObject')).name('t') |
| |
| all.addClass('Image', 'XObject').required('""').field('Type').must(PdfName('XObject')).name('t').done()\ |
| .done()\ |
| .required('""').field('Subtype').must(PdfName('Image')).name('s').done()\ |
| .done()\ |
| .required('-1').field('Width', 'W').integer('w').done()\ |
| .done()\ |
| .required('-1').field('Height', 'H').integer('h').done()\ |
| .done()\ |
| .required('""').field('ColorSpace').name('cs').multiple([PdfName('/DeviceRGB', '/RGB'), PdfName('/DeviceGray', '/Gray')]).done()\ |
| .done()\ |
| .optional().field('BitsPerComponent', 'BPC').integer('bpc').multiple([PdfInteger(1), PdfInteger(2), PdfInteger(4), PdfInteger(8)])\ |
| .default(PdfInteger(1)).done()\ |
| .done()\ |
| .carbonCopyPrivate('SkBitmap bitmap;') |
| |
| all.addClass('Form', 'XObject').required('""').field('Type').must(PdfName('XObject')).name('t').done()\ |
| .done()\ |
| .required('""').field('Subtype').must(PdfName('Form')).name('s').done()\ |
| .done()\ |
| .carbonCopyPublic('void test() {}') |
| |
| |
| |
| all.addClass('SpecificToATrapNetworkAppearanceStream', 'Dictionary', 'Additional entries specific to a trap network appearance stream')\ |
| .required('NULL')\ |
| .field('PCM')\ |
| .name('PCM')\ |
| .type('name')\ |
| .comment('(Required) The name of the process color model that was assumed when this trap network was created; equivalent to the PostScript page device parameter ProcessColorModel (see Section 6.2.5 of the PostScript Language Reference, Third Edition). Valid values are DeviceGray, DeviceRGB, DeviceCMYK, DeviceCMY, DeviceRGBK, and DeviceN.')\ |
| .done().done()\ |
| .optional()\ |
| .field('SeparationColorNames')\ |
| .name('SeparationColorNames')\ |
| .type('array')\ |
| .comment('(Optional) An array of names identifying the colorants that were assumed when this network was created; equivalent to the Post- Script page device parameter of the same name (see Section 6.2.5 of the PostScript Language Reference, Third Edition). Colorants im- plied by the process color model PCM are available automatically and need not be explicitly declared. If this entry is absent, the colorants implied by PCM are assumed.')\ |
| .done().done()\ |
| .optional()\ |
| .field('TrapRegions')\ |
| .name('TrapRegions')\ |
| .type('array')\ |
| .comment('(Optional) An array of indirect references to TrapRegion objects defining the page\'s trapping zones and the associated trapping parameters, as described in Adobe Technical Note #5620, Portable Job Ticket Format. These references are to objects comprising portions of a PJTF job ticket that is embedded in the PDF file. When the trapping zones and parameters are defined by an external job ticket (or by some other means, such as with JDF), this entry is absent.')\ |
| .done().done()\ |
| .optional()\ |
| .field('TrapStyles')\ |
| .name('TrapStyles')\ |
| .type('text string')\ |
| .comment('(Optional) A human-readable text string that applications can use to describe this trap network to the user (for example, to allow switching between trap networks).')\ |
| .done().done()\ |
| .done() |
| |
| all.addClass('OpiVersionDictionary', 'Dictionary', 'Entry in an OPI version dictionary')\ |
| .required('NULL')\ |
| .field('version_number')\ |
| .name('version_number')\ |
| .type('dictionary')\ |
| .comment('(Required; PDF 1.2) An OPI dictionary specifying the attributes of this proxy (see Tables 9.50 and 9.51). The key for this entry must be the name 1.3 or 2.0, identifying the version of OPI to which the proxy corresponds.')\ |
| .done().done()\ |
| .done() |
| |
| |
| |
| all.write() |
| |
| return 1 |
| |
| if '__main__' == __name__: |
| sys.exit(generateCode()) |
| |
| |