load font manually, for now Type0

experimental/PdfViewer/generate_code.py

 
 
 import sys
 
 import datatypes
 import pdfspec_autogen
 
 knowTypes = {
 '(any)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 '(undefined)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 '(various)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 'array': ['SkPdfArray', 'ArrayFromDictionary', datatypes.PdfArrayNone(), '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.PdfEmptyRect(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'],
-'stream': ['SkPdfStream', 'StreamFromDictionary',  datatypes.PdfEmptyStream(), 'ret->podofo()->HasStream()'],
+'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'],
 }
 
 
 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.fMustBe = []
     self.fComment = ''
 
   def must(self, value):
     self.fHasMust = True
     self.fMustBe = value
     return self
     
   def default(self, value):
     self.fDefault = value
     return self
@@ skipping 153 matching lines @@
     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 knowTypes
   
     # generate enum
     enumsRoot = []
 
     enumToCls = {}
     
@@ skipping 182 matching lines @@
       
 
       fileMapper.write('  static bool map(const SkPdfObject& in, SkPdf' + name + '** out) {\n')
       fileMapper.write('    return map(*in.doc(), *in.podofo(), out);\n')
       fileMapper.write('  }\n') 
       fileMapper.write('\n')
 
       fileMapper.write('  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n')
       fileMapper.write('    if (!is' + name + '(podofoDoc, podofoObj)) return false;\n')
       fileMapper.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:
+          fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
       
-      for sub in cls.fEnumSubclasses:
-        fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
+      if hasStream:
+        fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
+      
 
       fileMapper.write('\n')
       
       fileMapper.write('    *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
       fileMapper.write('    return true;\n')        
       fileMapper.write('  }\n') 
       fileMapper.write('\n')
        
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       
       fileMapper.write('  static bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
       
       if cls.fCheck != '':
         fileMapper.write('    return ' + cls.fCheck + ';\n')
       else:
         cntMust = 0
         for field in cls.fFields:
           prop = field.fProp
           if prop.fHasMust:
             cntMust = cntMust + 1
             fileMapper.write('    ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n')
             fileMapper.write('    if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n')
-            fileMapper.write('    if (' + prop.fCppName + ' != ' + prop.fMustBe.toCpp() + ') return false;\n')
-            fileMapper.write('\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() + ')'
+              fileMapper.write('    if (' + eval + ') return false;\n')
+              fileMapper.write('\n')
       
         fileMapper.write('    return true;\n')
               
       fileMapper.write('  }\n') 
       fileMapper.write('\n')    
     
     fileMapper.write('};\n') 
     fileMapper.write('\n')
     
     fileMapper.write('#endif  // __DEFINED__SkPdfPodofoMapper\n')
@@ skipping 21 matching lines @@
                              
   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('Stream') - attached to a dictionary
   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('const SkPdfObject operator[](int i) const {return SkPdfObject(fPodofoDoc, &fPodofoObj->GetArray()[i]);}')\
-                             .carbonCopyPublic('SkPdfObject operator[](int i) {return SkPdfObject(fPodofoDoc, &fPodofoObj->GetArray()[i]);}')
+                             .carbonCopyPublic('SkPdfObject* operator[](int i) const {return new SkPdfObject(fPodofoDoc, &fPodofoObj->GetArray()[i]);}')\
   
   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('const SkPdfObject get(const char* dictionaryKeyName) const {return SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\
                                 .carbonCopyPublic('SkPdfObject get(const char* dictionaryKeyName) {return 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', 'FontDictionary')
+  manager.addClass('TrueTypeFontDictionary', 'Type1FontDictionary')\
+          .required('NULL')\
+          .field('Subtype')\
+          .name('Subtype')\
+          .type('name')\
+          .comment('')\
+          .must([datatypes.PdfName('TrueType')])\
+          .done().done()\
   
   pdfspec_autogen.buildPdfSpec(manager)  
 
   manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\
           .required('NULL')\
           .field('Subtype')\
           .name('Subtype')\
           .type('name')\
           .comment('')\
-          .must(datatypes.PdfName('MMType1'))\
+          .must([datatypes.PdfName('MMType1')])\
           .done().done()\
 
 
   manager.write()
   
   fileHeaders.write('#endif  // __DEFINED__SkPdfHeaders\n')
   fileHeaders.close()
   
   return 1
 
 if '__main__' == __name__:
   sys.exit(generateCode())