pdfviewer: debug code for drawText (show magenta background for text, to show text even when we fai…

experimental/PdfViewer/generate_code.py

 
 
 import os
 import sys
 
 import datatypes
 from pdfspec_autogen import *
 
 # TODO(edisonn): date and some other types are in fact strings, with a custom format!!!
 # TODO(edisonn): refer to page 99 (PDF data types)
 knowTypes = {
-'(any)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(any)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
 # TODO(edisonn): return constant for undefined
-'(undefined)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
-'(various)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(undefined)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
+'(various)': ['SkPdfNativeObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'],
 'array': ['SkPdfArray*', '(SkPdfArray*)ret', datatypes.CppNull(), 'ret->isArray()'],
 'boolean': ['bool', 'ret->boolValue()', datatypes.PdfBoolean('false'), 'ret->isBoolean()'],
 #date is a string, with special formating, add here the 
 'date': ['SkPdfDate', 'ret->dateValue()', datatypes.PdfDateNever(), 'ret->isDate()'],
 'dictionary': ['SkPdfDictionary*', '(SkPdfDictionary*)ret', datatypes.CppNull(), 'ret->isDictionary()', 'use a mapper'],
 'function': ['SkPdfFunction', 'ret->functionValue()', datatypes.PdfFunctionNone(), 'ret->isFunction()'],
 'integer': ['int64_t', 'ret->intValue()', datatypes.PdfInteger(0), 'ret->isInteger()'],
 'file_specification': ['SkPdfFileSpec', 'ret->fileSpecValue()', datatypes.FileSpecNone(), 'false'],
 'name': ['std::string', 'ret->nameValue2()', datatypes.PdfString('""'), 'ret->isName()'],
 #should assert, references should never be allowed here, should be resolved way earlier
@@ skipping 221 matching lines @@
     global fileHeadersNativeCpp 
     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'
+      cls.fEnum = 'k' + name + '_SkPdfNativeObjectType'
+      cls.fEnumEnd = 'k' + name + '__End_SkPdfNativeObjectType'
 
       fileHeadersNative.write('#include "SkPdf' + cls.fName + '_autogen.h"\n')
       fileHeadersNativeCpp.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(os.path.join(sys.argv[1], 'native', 'autogen', 'SkPdfEnums_autogen.h'), 'w')
     fileEnums.write('#ifndef __DEFINED__SkPdfEnums\n')
     fileEnums.write('#define __DEFINED__SkPdfEnums\n')
     fileEnums.write('\n')
     
-    fileEnums.write('enum SkPdfObjectType {\n')
-    fileEnums.write('  kNone_SkPdfObjectType = 0,\n')
+    fileEnums.write('enum SkPdfNativeObjectType {\n')
+    fileEnums.write('  kNone_SkPdfNativeObjectType = 0,\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')
 
@@ skipping 13 matching lines @@
 
       nativeFileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n')
       nativeFileClassCpp.write('\n')
 
       
       if cls.fBase == '':
         nativeFileClass.write('#include "stddef.h"\n')
         nativeFileClass.write('#include <string>\n')
         nativeFileClass.write('#include "SkPdfEnums_autogen.h"\n')
         nativeFileClass.write('#include "SkPdfNYI.h"\n')
-        nativeFileClass.write('#include "SkPdfObject.h"\n')
-        nativeFileClass.write('class SkNativeParsedPDF;\n')
+        nativeFileClass.write('#include "SkPdfNativeObject.h"\n')
+        nativeFileClass.write('class SkPdfNativeDoc;\n')
 
       if cls.fBase != '':
         nativeFileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n')
 
-      nativeFileClassCpp.write('#include "SkNativeParsedPDF.h"\n')
+      nativeFileClassCpp.write('#include "SkPdfNativeDoc.h"\n')
 
 
       nativeFileClass.write('\n')
       
       if cls.fComment != '':
         nativeFileClass.write('// ' + cls.fComment + '\n')
       
       if cls.fBase == '':
-        nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdfObject {\n')
+        nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdfNativeObject {\n')
       else:
         nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdf' + cls.fBase + ' {\n')
       
       self.writeAsFoo(nativeFileClass, cls, enumToCls)
       
       nativeFileClass.write('public:\n')
 
       for cc in cls.fCCPublicNative:
         nativeFileClass.write('  ' + cc + '\n')
       
@@ skipping 24 matching lines @@
             nativeFileClass.write('**/\n')
           
           if prop.fCppName[0] == '[':
             nativeFileClass.write('/*\n')  # comment code of the atributes that can have any name
             nativeFileClassCpp.write('/*\n')  # comment code of the atributes that can have any name
           
 
           if len(prop.fTypes.split()) == 1:
             t = prop.fTypes.strip()
 
-            nativeFileClass.write('  ' + knowTypes[t][0] + ' ' + prop.fCppName + '(SkNativeParsedPDF* doc);\n')
-            nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '(SkNativeParsedPDF* doc) {\n')
-            nativeFileClassCpp.write('  SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+            nativeFileClass.write('  ' + knowTypes[t][0] + ' ' + prop.fCppName + '(SkPdfNativeDoc* doc);\n')
+            nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '(SkPdfNativeDoc* doc) {\n')
+            nativeFileClassCpp.write('  SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
             nativeFileClassCpp.write('  if (doc) {ret = doc->resolveReference(ret);}\n')
             nativeFileClassCpp.write('  if ((ret != NULL && ' + knowTypes[t][3] + ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTypes[t][1] + ';\n')
             
             if field.fRequired:
               nativeFileClassCpp.write('  // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
               nativeFileClassCpp.write('  return ' + knowTypes[t][2].toCpp() + ';\n');
             elif prop.fDefault != '':
               nativeFileClassCpp.write('  return ' + prop.fDefault.toCpp() + ';\n');
             else:
               nativeFileClassCpp.write('  // TODO(edisonn): warn about missing default value for optional fields\n')
               nativeFileClassCpp.write('  return ' + knowTypes[t][2].toCpp() + ';\n');
             
             nativeFileClassCpp.write('}\n') 
             nativeFileClassCpp.write('\n')
           else:
             for type in prop.fTypes.split():
               t = type.strip()
               
-              nativeFileClass.write('  bool is' + prop.fCppName + 'A' + t.title() + '(SkNativeParsedPDF* doc);\n')
+              nativeFileClass.write('  bool is' + prop.fCppName + 'A' + t.title() + '(SkPdfNativeDoc* doc);\n')
 
-              nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.fCppName + 'A' + t.title() + '(SkNativeParsedPDF* doc) {\n')
-              nativeFileClassCpp.write('  SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+              nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.fCppName + 'A' + t.title() + '(SkPdfNativeDoc* doc) {\n')
+              nativeFileClassCpp.write('  SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
               nativeFileClassCpp.write('  if (doc) {ret = doc->resolveReference(ret);}\n')
               nativeFileClassCpp.write('  return ret != NULL && ' + knowTypes[t][3] + ';\n')
               nativeFileClassCpp.write('}\n')
               nativeFileClassCpp.write('\n')
 
-              nativeFileClass.write('  ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '(SkNativeParsedPDF* doc);\n')
-              nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '(SkNativeParsedPDF* doc) {\n')
+              nativeFileClass.write('  ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '(SkPdfNativeDoc* doc);\n')
+              nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '(SkPdfNativeDoc* doc) {\n')
 
-              nativeFileClassCpp.write('  SkPdfObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
+              nativeFileClassCpp.write('  SkPdfNativeObject* ret = get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
               nativeFileClassCpp.write('  if (doc) {ret = doc->resolveReference(ret);}\n')
               nativeFileClassCpp.write('  if ((ret != NULL && ' + knowTypes[t][3] + ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTypes[t][1] + ';\n')
 
 
               if field.fRequired:
                 nativeFileClassCpp.write('  // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
                 nativeFileClassCpp.write('  return ' + knowTypes[t][2].toCpp() + ';\n');
               elif prop.fDefault != '':
                 nativeFileClassCpp.write('  return ' + prop.fDefault.toCpp() + ';\n');
               else:
@@ skipping 29 matching lines @@
     # generate parser  
     # TODO(edisonn): fast recognition based on must attributes.
     fileMapperNative = open(os.path.join(sys.argv[1], 'native', 'autogen', 'SkPdfMapper_autogen.h'), 'w')
     fileMapperNativeCpp = open(os.path.join(sys.argv[1], 'native', 'autogen', 'SkPdfMapper_autogen.cpp'), 'w')
 
     fileMapperNative.write('#ifndef __DEFINED__SkPdfMapper\n')
     fileMapperNative.write('#define __DEFINED__SkPdfMapper\n')
     fileMapperNative.write('\n')
 
     fileMapperNative.write('#include "SkPdfHeaders_autogen.h"\n')
-    fileMapperNative.write('#include "SkNativeParsedPDF.h"\n')
-    fileMapperNative.write('#include "SkPdfObject.h"\n')
+    fileMapperNative.write('#include "SkPdfNativeDoc.h"\n')
+    fileMapperNative.write('#include "SkPdfNativeObject.h"\n')
 
 
     fileMapperNativeCpp.write('#include "SkPdfMapper_autogen.h"\n')
     fileMapperNativeCpp.write('#include "SkPdfUtils.h"\n')
-    fileMapperNativeCpp.write('#include "SkPdfObject.h"\n')
+    fileMapperNativeCpp.write('#include "SkPdfNativeObject.h"\n')
     fileMapperNativeCpp.write('\n')
     
     fileMapperNative.write('class SkPdfMapper {\n')
 
-    fileMapperNative.write('  SkNativeParsedPDF* fParsedDoc;\n')
+    fileMapperNative.write('  SkPdfNativeDoc* fParsedDoc;\n')
     
     fileMapperNative.write('public:\n')
     
-    fileMapperNative.write('  SkPdfMapper(SkNativeParsedPDF* doc) : fParsedDoc(doc) {}\n')
+    fileMapperNative.write('  SkPdfMapper(SkPdfNativeDoc* doc) : fParsedDoc(doc) {}\n')
     fileMapperNative.write('\n')
     
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       
-      fileMapperNative.write('  SkPdfObjectType map' + name + '(const SkPdfObject* in) const;\n')
+      fileMapperNative.write('  SkPdfNativeObjectType map' + name + '(const SkPdfNativeObject* in) const;\n')
 
-      fileMapperNativeCpp.write('SkPdfObjectType SkPdfMapper::map' + name + '(const SkPdfObject* in) const {\n')
-      fileMapperNativeCpp.write('  if (in == NULL || !is' + name + '(in)) return kNone_SkPdfObjectType;\n')
+      fileMapperNativeCpp.write('SkPdfNativeObjectType SkPdfMapper::map' + name + '(const SkPdfNativeObject* in) const {\n')
+      fileMapperNativeCpp.write('  if (in == NULL || !is' + name + '(in)) return kNone_SkPdfNativeObjectType;\n')
       fileMapperNativeCpp.write('\n')
       if len(cls.fEnumSubclasses) > 0:
-        fileMapperNativeCpp.write('  SkPdfObjectType ret;\n')
+        fileMapperNativeCpp.write('  SkPdfNativeObjectType ret;\n')
 
       # stream must be last one
       hasStream = False
       for sub in cls.fEnumSubclasses:
-        fileMapperNativeCpp.write('  if (kNone_SkPdfObjectType != (ret = map' + enumToCls[sub].fName + '(in))) return ret;\n')
+        fileMapperNativeCpp.write('  if (kNone_SkPdfNativeObjectType != (ret = map' + enumToCls[sub].fName + '(in))) return ret;\n')
       
       fileMapperNativeCpp.write('\n')
       
-      fileMapperNativeCpp.write('  return k' + name + '_SkPdfObjectType;\n')        
+      fileMapperNativeCpp.write('  return k' + name + '_SkPdfNativeObjectType;\n')        
       fileMapperNativeCpp.write('}\n') 
       fileMapperNativeCpp.write('\n')
        
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       
-      fileMapperNative.write('  bool is' + name + '(const SkPdfObject* nativeObj) const ;\n')
-      fileMapperNativeCpp.write('bool SkPdfMapper::is' + name + '(const SkPdfObject* nativeObj) const {\n')
+      fileMapperNative.write('  bool is' + name + '(const SkPdfNativeObject* nativeObj) const ;\n')
+      fileMapperNativeCpp.write('bool SkPdfMapper::is' + name + '(const SkPdfNativeObject* nativeObj) const {\n')
       
       if cls.fCheck != '':
         fileMapperNativeCpp.write('  return ' + cls.fCheck + ';\n')
       else:
         cntMust = 0
         emitedRet = False
         for field in cls.fFields:
           prop = field.fProp
           if prop.fHasMust:
             if emitedRet == False:
-              fileMapperNativeCpp.write('  const SkPdfObject* ret = NULL;\n')
+              fileMapperNativeCpp.write('  const SkPdfNativeObject* ret = NULL;\n')
               emitedRet = True
             cntMust = cntMust + 1
             fileMapperNativeCpp.write('  if (!nativeObj->isDictionary()) return false;\n')
             fileMapperNativeCpp.write('  ret = nativeObj->get(\"' + prop.fName + '\", \"' + prop.fAbr + '\");\n')
             fileMapperNativeCpp.write('  if (ret == NULL || !' + knowTypes[prop.fTypes.strip()][3] + ') 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 = '(' + knowTypes[prop.fTypes.strip()][1]  + ' != ' + cnd.toCpp() + ')'
                 else:
                   eval = eval + ' && ' + '(' + knowTypes[prop.fTypes.strip()][1]  + ' != ' + cnd.toCpp() + ')'
               fileMapperNativeCpp.write('  if (' + eval + ') return false;\n')
               fileMapperNativeCpp.write('\n')
       
         fileMapperNativeCpp.write('  return true;\n')
               
       fileMapperNativeCpp.write('}\n') 
       fileMapperNativeCpp.write('\n')    
     
       # TODO(edisonn): dict should be a SkPdfDictionary ?
-      fileMapperNative.write('  bool SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, SkPdf' + name + '** data) const ;\n')
-      fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, SkPdf' + name + '** data) const {\n')
-      fileMapperNativeCpp.write('  const SkPdfObject* value = dict->get(key);\n')
+      fileMapperNative.write('  bool SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, SkPdf' + name + '** data) const ;\n')
+      fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, SkPdf' + name + '** data) const {\n')
+      fileMapperNativeCpp.write('  const SkPdfNativeObject* value = dict->get(key);\n')
       fileMapperNativeCpp.write('  if (value == NULL) { return false; }\n')
       fileMapperNativeCpp.write('  if (data == NULL) { return true; }\n')
-      fileMapperNativeCpp.write('  if (kNone_SkPdfObjectType == map' + name + '(value)) return false;\n')
+      fileMapperNativeCpp.write('  if (kNone_SkPdfNativeObjectType == map' + name + '(value)) return false;\n')
       fileMapperNativeCpp.write('  *data = (SkPdf' + name + '*)value;\n')
       fileMapperNativeCpp.write('  return true;\n');
       fileMapperNativeCpp.write('}\n')
       fileMapperNativeCpp.write('\n')
 
-      fileMapperNative.write('  bool SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const ;\n')
-      fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const {\n')
+      fileMapperNative.write('  bool SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const ;\n')
+      fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictionary(const SkPdfNativeObject* dict, const char* key, const char* abr, SkPdf' + name + '** data) const {\n')
       fileMapperNativeCpp.write('  if (SkPdf' + name + 'FromDictionary(dict, key, data)) return true;\n')
       fileMapperNativeCpp.write('  if (abr == NULL || *abr == \'\\0\') return false;\n')
       fileMapperNativeCpp.write('  return SkPdf' + name + 'FromDictionary(dict, abr, data);\n')
       fileMapperNativeCpp.write('}\n')
       fileMapperNativeCpp.write('\n')
           
     fileMapperNative.write('};\n') 
     fileMapperNative.write('\n')
     
     fileMapperNative.write('#endif  // __DEFINED__SkPdfMapper\n')
@@ skipping 55 matching lines @@
   
   fileHeadersNative.write('#endif  // __DEFINED__SkPdfHeaders\n')
 
   fileHeadersNative.close()
   fileHeadersNativeCpp.close()
 
 if '__main__' == __name__:
   #print sys.argv
   sys.exit(generateCode())