bgencxxsupport.py

彩信浏览器

                self.report("      %d: leaving %s" % (len(self.namespaces), self.namespaces[-1]))
            del self.namespaces[-1]
            count -= 1
        if not self.in_class_defn:
            self.head = self.head1
            self.type = self.type1
            self.whole = self.whole1
            
    def dovisibility(self, match):
        ## assert self.in_class_defn
        self.visible = match.group("visibility")
        if self.debug:
            self.report("      %d: %s:" % (len(self.namespaces), self.visible))

    def scan(self):
        if not self.scanfile:
            self.error("No input file has been specified")
            return
        inputname = self.scanfile.name
        self.report("scanfile = %r", inputname)
        if not self.specfile:
            self.report("(No interface specifications will be written)")
        else:
            self.report("specfile = %r", self.specfile.name)
            self.specfile.write("# Generated from %r\n\n" % (inputname,))
        if not self.defsfile:
            self.report("(No symbol definitions will be written)")
        else:
            self.report("defsfile = %r", (self.defsfile.name,))
            self.defsfile.write("# Generated from %r\n\n" % (os.path.split(inputname)[1],))
            self.writeinitialdefs()
        self.alreadydone = []
        try:
            while 1:
                try: line = self.getline()
                except EOFError: break
                if self.debug:
                    self.report("LINE: %r" % (line,))

                match = self.comment1.match(line)
                if match:
                    line = match.group('rest')
                    if self.debug:
                        self.report("\tafter comment1: %r" % (line,))

                match = self.comment2.match(line)
                while match:
                    line = match.group('rest1')+match.group('rest2')
                    if self.debug:
                        self.report("\tafter comment2: %r" % (line,))
                    match = self.comment2.match(line)

                if self.defsfile:
                    match = self.sym.match(line)
                    if match:
                        if self.debug:
                            self.report("\tmatches sym.")
                        self.dosymdef(match)
                        continue

                match = self.head.match(line)
                if match:
                    if self.debug:
                        self.report("\tmatches head.")
                    line = self.dofuncspec()
                elif self.in_class_defn:
                    match = self.headconstructor.match(line)
                    if match and match.group('name') == self.namespaces[-1]:
                        if self.debug:
                            self.report("\tmatches constructor head.")
                        # It appears to be a constructor. Temporarily use
                        # different patterns for type and whole, which will
                        # keep dofuncspec() somewhat happy.
                        keep_type = self.type
                        keep_whole = self.whole
                        self.type = self.typeconstructor
                        self.whole = self.wholeconstructor
                        line = self.dofuncspec()
                        self.type = keep_type
                        self.whole = keep_whole
                            
                match = self.namespace.match(line)
                if match:
                    if self.debug:
                        self.report("\tmatches namespace.")
                    self.donamespace(match)

                match = self.klass.match(line)
                if match:
                    if self.debug:
                        self.report("\tmatches class.")
                    self.doclass(match)

                match = self.visibility.match(line)
                if match:
                    self.dovisibility(match)
                    
                beginscopecount = line.count('{')
                endscopecount = line.count('}')
                if beginscopecount > endscopecount:
                    self.dobeginscope(beginscopecount-endscopecount)
                elif beginscopecount < endscopecount:
                    self.doendscope(endscopecount-beginscopecount)
        except EOFError:
            self.error("Uncaught EOF error")
        self.reportusedtypes()

    def getmodifiers(self, match):
        modifiers = []

        if match.group('storage') == 'static':
            modifiers.append('static')
        elif match.group('storage') == 'virtual':
            modifiers.append('virtual')
            
        if match.group('const') == 'const':
            modifiers.append('const')

        return modifiers
        
    def checkduplicate(self, name):
        """By default we do not check for duplicates in C++ code"""
        self.alreadydone.append(name)
        return False

    def destination(self, type, name, arglist, modifiers=[]):
        if self.in_class_defn:
            classname = self.namespaces[-1]
            classname = self.pythonizename(classname)
            # First check that we don't skip this class altogether
            if classname in self.blacklisttypes:
                self.report("*** class %s blacklisted", classname)
                return None, None
            
            #Then, skip non-public methods
            if self.visible != 'public':
                self.report("*** %s method skipped", self.visible)
                return None, None
                
            # Next, treat static methods as functions.
            if "static" in modifiers:
                return "Function", "functions"
            
            # Also treat constructors as functions, but append to the method list
            if name == self.namespaces[-1]:
                return "ConstructorMethod", "methods_%s" % classname
                
            # Finally treat const methods differently
            if "const" in modifiers:
                return "ConstMethod", "methods_%s" % classname
            return "Method", "methods_%s" % classname
        return "Function", "functions"

    def generatemodifiers(self, classname, name, modifiers):
        # If we are using namespaces make sure to fully qualify
        # all functions.
        if classname == 'Function' and self.namespaces:
            callname = '::'.join(self.namespaces + [name])
            self.specfile.write('    callname="%s",\n' % callname)
        # If this is a constructor we call it with "new"
        if self.in_class_defn and classname == 'Method' and \
                self.namespaces and self.namespaces[-1] == name:
            callname = 'new ' + '::'.join(self.namespaces + [name])
            self.specfile.write('    callname="%s",\n' % callname)
        if modifiers:
            self.specfile.write('    modifiers=%s,\n' % repr(modifiers))
            
    def repairarglist(self, functionname, arglist):
        # More trickery for constructors: if we're in a constructor
        # modify the return arg to return a pointer to the class name
        if self.in_class_defn \
                and arglist == [('', self.namespaces[-1], 'ReturnMode')]:
            return [(self.namespaces[-1]+'_ptr', self.namespaces[-1], 'ReturnMode')]
        return Scanner.repairarglist(self, functionname, arglist)
        

class TupleType(Type):

    def __init__(self, type, *memberlist):
        self.typeName = type
        self.memberlist = memberlist
        self.dot = '.'
        
    def getargsPreCheck(self, name):
        for membertype, membername in self.memberlist:
            membertype.getargsPreCheck(name + self.dot + membername)
        
    def getargsFormat(self):
        fmt = '('
        for membertype, membername in self.memberlist:
            fmt += membertype.getargsFormat()
        fmt += ')'
        return fmt
        
    def getargsArgs(self, name):
        alist = []
        for membertype, membername in self.memberlist:
            arg = membertype.getargsArgs(name + self.dot + membername)
            if arg:
                alist.append(arg)
        return ', '.join(alist)
          
    def getargsCheck(self, name):
        for membertype, membername in self.memberlist:
            membertype.getargsCheck(name + self.dot + membername)
        
    def mkvalueFormat(self):
        fmt = '('
        for membertype, membername in self.memberlist:
            fmt += membertype.mkvalueFormat()
        fmt += ')'
        return fmt
        
    def mkvalueArgs(self, name):
        alist = []
        for membertype, membername in self.memberlist:
            alist.append(membertype.mkvalueArgs(name + self.dot + membername))
        return ', '.join(alist)

class ByAddressTupleType(TupleType):
    def passInput(self, name):
        return "&%s" % name
        
class ByReferenceTupleType(TupleType):

    def passOutput(self, name):
        return name
        
class HeapTupleType(TupleType):

    def __init__(self, type, *memberlist):
        self._realtype = type
        TupleType.__init__(self, type + '*', *memberlist)
        self.dot = '->'

    def getargsPreCheck(self, name):
        # XXX This is a hack: we allocate the object on the heap
        # but never free it!
        Output("%s = new %s;", name, self._realtype)

    def passOutput(self, name):
        return name

class CallbackTupleType(TupleType):

    def __init__(self, type, *memberlist):
        TupleType.__init__(self, type + '*', *memberlist)
        self.dot = '->'
        
    def getargsFormat(self):
        raise RuntimeError, \
            "CallbackTupleType('%s') can only be used for callback input parameters" % self.typeName

    def getargsArgs(self, name):
        raise RuntimeError, \
            "CallbackTupleType('%s') can only be used for callback input parameters" % self.typeName

class StdStringType(Type):
    def __init__(self, typeName="std::string", celement="char", fmt="s"):
        Type.__init__(self, typeName, fmt)
        self.typeName = typeName
        self.celement = celement
        
    def getargsPreCheck(self, name):
        name = name.replace('.', '_')
        Output("%s *%s_cstr;", self.celement, name)
        
    def getargsArgs(self, name):
        name = name.replace('.', '_')
        return "&%s_cstr" % name
        
    def getargsCheck(self, name):
        tmpname = name.replace('.', '_')
        Output("%s = %s_cstr;", name, tmpname)
        
    def mkvalueArgs(self, name):
        return "%s.c_str()" % name

class StdPairType(Type):
    def __init__(self, firsttype, secondtype, typeName="std::pair<%s, %s>", castname=None):
        if '%' in typeName:
            typeName = decl % (firsttype.typeName, secondtype.typeName)
        Type.__init__(self, typeName, "")
        self.firsttype = firsttype
        self.secondtype = secondtype
        if not castname:
            castname = typeName
        self.castname = castname
        
    def getargsPreCheck(self, name):
        decls = self.firsttype.getArgDeclarations(name + "_first") + \
                self.firsttype.getAuxDeclarations(name + "_first") + \
                self.secondtype.getArgDeclarations(name + "_second") + \
                self.secondtype.getAuxDeclarations(name + "_second")
        for d in decls:
            Output("%s;", d)
        self.firsttype.getargsPreCheck(name + "_first")
        self.secondtype.getargsPreCheck(name + "_second")
        
    def getargsArgs(self, name):
        return ', '.join([self.firsttype.getargsArgs(name + "_first"),
               self.secondtype.getargsArgs(name + "_second")])
               
    def getargsFormat(self):
        return '(' + self.firsttype.getargsFormat() + \
               self.secondtype.getargsFormat() + ')'
               
    def getargsCheck(self, name):
        self.firsttype.getargsCheck(name + "_first")
        self.secondtype.getargsCheck(name + "_second")
        Output("%s = %s(%s_first, %s_second);", name, self.castname, name, name)
        
    def mkvalueArgs(self, name):
        return ", ".join([self.firsttype.mkvalueArgs(name + ".first"),
               self.secondtype.mkvalueArgs(name + ".second")])
               
    def mkvalueFormat(self):
        return '(' + self.firsttype.mkvalueFormat() + \
               self.secondtype.mkvalueFormat() + ')'