experimental/PdfViewer/generate_code.py

import sys

import datatypes
import pdfspec_autogen




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 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 = 'Dictionary'
    self.fCppType = 'SkPdfDictionary*'
    self.fCppReader = 'DictionaryFromDictionary'
    self.fDefault = datatypes.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
    type = type.replace('or', ' ')
    type = type.replace(',', ' ')
    type = type.replace('text', ' ') # TODO(edisonn): what is the difference between 'text string' and 'string'?
    
    type = type.strip()
    types = type.split()
    
    if len(types) == 1:
      if type == 'integer':
        self.integer(self.fCppName)
        self.default(datatypes.PdfInteger(0))
        return self
        
      if type == 'number':
        self.number(self.fCppName)
        self.default(datatypes.PdfNumber(0))
        return self

      if type == 'string':
        self.string(self.fCppName)
        self.default(datatypes.PdfString('""'))
        return self

      if type == 'name':
        self.name(self.fCppName)
        self.default(datatypes.PdfName('""'))
        return self
    
      if type == 'dictionary':
        self.dictionary(self.fCppName)
        self.default(datatypes.CppNull())
        return self

    self.fType = 'object'
    self.fDictionaryType = 'Object'
    self.fCppType = 'SkPdfObject*'
    self.fCppReader = 'ObjectFromDictionary'
    self.fDefault = datatypes.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'
    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 longName(self, name):
    #return name
    # TODO(edisonn): we need the long name to nenerate and sort enums, but we can generate them recursively
    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.fCppName[0] == '[':
            print('/*')  # comment code of the atributes that can have any name
            
          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.fCppName[0] == '[':
            print('*/')  # comment code of the atributes that can have any name
         

      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) {')
      
      if cls.fCheck != '':
        print('    return ' + cls.fCheck + ';')
      else:
        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 len(cls.fEnumSubclasses) > 0:
          print('    return true;')
        else:
          print('    return false;')
              
      print('  }') 
      print    
    
    print('};') 
    print
    
    return

def generateCode():
  manager = PdfClassManager()
  
  manager.addClass('Object')
  
  manager.addClass('Null').check('podofoObj.GetDataType() == ePdfDataType_Null')
  manager.addClass('Boolean').check('podofoObj.GetDataType() == ePdfDataType_Bool')
  manager.addClass('Integer').check('podofoObj.GetDataType() == ePdfDataType_Number')
  manager.addClass('Number').check('podofoObj.GetDataType() == ePdfDataType_Real')
  manager.addClass('Name').check('podofoObj.GetDataType() == ePdfDataType_Name')
  #manager.addClass('Stream') - attached to a dictionary
  manager.addClass('Reference').check('podofoObj.GetDataType() == ePdfDataType_Reference')
  manager.addClass('Array').check('podofoObj.GetDataType() == ePdfDataType_Array')
  manager.addClass('String').check('podofoObj.GetDataType() == ePdfDataType_String')
  manager.addClass('HexString').check('podofoObj.GetDataType() == ePdfDataType_HexString')
  
  manager.addClass('Dictionary').check('podofoObj.GetDataType() == ePdfDataType_Dictionary')
  
  # 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')
  
  pdfspec_autogen.buildPdfSpec(manager)  

  manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\
          .required('NULL')\
          .field('Subtype')\
          .name('Subtype')\
          .type('name')\
          .comment('')\
          .must(datatypes.PdfName('MMType1'))\
          .done().done()\


  manager.write()
  
  return 1

if '__main__' == __name__:
  sys.exit(generateCode())