refactoring for pdf viewer lib

experimental/PdfViewer/generate_code.py

 
 
 import sys
 
 import datatypes
 from autogen.pdfspec_autogen import *
 
 knowTypes = {
 '(any)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 '(undefined)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
@@ skipping 215 matching lines @@
 #      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()
@@ skipping 20 matching lines @@
     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')
       
@@ skipping 53 matching lines @@
           
           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')
-            fileClass.write('    ' + knowTypes[t][0] + ' ret;\n')
-            fileClass.write('    if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
+            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 != '':
-              fileClass.write('    return ' + prop.fDefault.toCpp() + ';\n');
+              fileClassCpp.write('  return ' + prop.fDefault.toCpp() + ';\n');
             else:
-              fileClass.write('    // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
-              fileClass.write('    return ' + knowTypes[t][2].toCpp() + ';\n');
-            fileClass.write('  }\n') 
-            fileClass.write('\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')
           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')
-              fileClass.write('    ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n')
-              fileClass.write('    if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
-              fileClass.write('    // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
-              fileClass.write('    return ' + knowTypes[t][2].toCpp() + ';\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')
-    fileMapper.write('class PodofoMapper {\n')
-    fileMapper.write('public:\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('  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('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out);\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')
+      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:
-          fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
+          fileMapperCpp.write('  if (map' + enumToCls[sub].fName + '(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
       
       if hasStream:
-        fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
+        fileMapperCpp.write('  if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
       
 
-      fileMapper.write('\n')
+      fileMapperCpp.write('\n')
       
-      fileMapper.write('    *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
-      fileMapper.write('    return true;\n')        
-      fileMapper.write('  }\n') 
-      fileMapper.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('  static bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
+      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 != '':
-        fileMapper.write('    return ' + cls.fCheck + ';\n')
+        fileMapperCpp.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')
+            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() + ')'
-              fileMapper.write('    if (' + eval + ') return false;\n')
-              fileMapper.write('\n')
+              fileMapperCpp.write('  if (' + eval + ') return false;\n')
+              fileMapperCpp.write('\n')
       
-        fileMapper.write('    return true;\n')
+        fileMapperCpp.write('  return true;\n')
               
-      fileMapper.write('  }\n') 
-      fileMapper.write('\n')    
+      fileMapperCpp.write('}\n') 
+      fileMapperCpp.write('\n')    
     
-    fileMapper.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();}')
@@ skipping 48 matching lines @@
           .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())