Changeset 1702

Show
Ignore:
Timestamp:
11/09/09 12:34:33 (13 years ago)
Author:
arnonym
Message:

Change whitespaces.

And don't crash when a configuration-file doesn't have a "device_definitions" section.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libffado/support/mixer-qt4/ffado/configuration.py

    r1640 r1702  
    3030 
    3131class DeviceList: 
    32        def __init__( self, filename="" ): 
    33                self.devices = list() 
    34                if not filename == "": 
    35                        self.updateFromFile( filename ) 
     32    def __init__( self, filename="" ): 
     33        self.devices = list() 
     34        if not filename == "": 
     35            self.updateFromFile( filename ) 
    3636 
    37        def updateFromFile( self, filename, must_exist=False): 
    38                filename = os.path.expanduser(filename) 
    39                log.debug("DeviceList::updateFromFile(%s)" % filename) 
    40                if not os.path.exists( filename ): 
    41                        if must_exist: 
    42                                log.error("cannot open file") 
    43                        return 
    44                f = open( filename, "r" ) 
     37    def updateFromFile( self, filename, must_exist=False): 
     38        filename = os.path.expanduser(filename) 
     39        log.debug("DeviceList::updateFromFile(%s)" % filename) 
     40        if not os.path.exists( filename ): 
     41            if must_exist: 
     42                log.error("cannot open file") 
     43            return 
     44        f = open( filename, "r" ) 
    4545 
    46                 lex = Parser( f ) 
    47                 config = {} 
    48                 while lex.peaktoken() != lex.eof: 
    49                         tmp = lex.parsenamedvalue() 
    50                         if tmp != None: 
    51                                 config[ tmp[0] ] = tmp[1] 
    52                 for dev in config["device_definitions"]: 
    53                         self.addDevice( dev ) 
     46        lex = Parser( f ) 
     47        config = {} 
     48        while lex.peaktoken() != lex.eof: 
     49            tmp = lex.parsenamedvalue() 
     50            if tmp != None: 
     51                config[ tmp[0] ] = tmp[1] 
     52        if config.has_key("device_definitions"): 
     53            for dev in config["device_definitions"]: 
     54                self.addDevice( dev ) 
    5455 
    55        def getDeviceById( self, vendor, model ): 
    56                log.debug("DeviceList::getDeviceById( %s, %s )" % (vendor, model )) 
    57                for dev in self.devices: 
    58                        if int("%s" % dev['vendorid'], 0) == int("%s" % vendor, 0) and \ 
    59                           int("%s" % dev['modelid'], 0) == int("%s" % model, 0): 
    60                                return dev 
    61                tmp = dict() 
    62                self.devices.append( tmp ) 
    63                return tmp 
     56    def getDeviceById( self, vendor, model ): 
     57        log.debug("DeviceList::getDeviceById( %s, %s )" % (vendor, model )) 
     58        for dev in self.devices: 
     59            if int("%s" % dev['vendorid'], 0) == int("%s" % vendor, 0) and \ 
     60               int("%s" % dev['modelid'], 0) == int("%s" % model, 0): 
     61                return dev 
     62        tmp = dict() 
     63        self.devices.append( tmp ) 
     64        return tmp 
    6465 
    65        def addDevice( self, device_dict ): 
    66                log.debug("DeviceList::addDevice()") 
    67                dev = self.getDeviceById( device_dict['vendorid'], device_dict['modelid'] ) 
    68                dev.update( device_dict ) 
     66    def addDevice( self, device_dict ): 
     67        log.debug("DeviceList::addDevice()") 
     68        dev = self.getDeviceById( device_dict['vendorid'], device_dict['modelid'] ) 
     69        dev.update( device_dict ) 
    6970 
    7071class Parser: 
    71        def __init__( self, file ): 
    72                self.lex = shlex.shlex( file ) 
    73                self.eof = self.lex.eof 
     72    def __init__( self, file ): 
     73        self.lex = shlex.shlex( file ) 
     74        self.eof = self.lex.eof 
    7475 
    75        def peaktoken( self ): 
    76                token = self.lex.get_token() 
    77                self.lex.push_token( token ) 
    78                return token 
     76    def peaktoken( self ): 
     77        token = self.lex.get_token() 
     78        self.lex.push_token( token ) 
     79        return token 
    7980 
    80        def parselist( self, level="" ): 
    81                token = self.peaktoken() 
    82                if token != "(": 
    83                        return 
    84                self.lex.get_token() 
    85                log.debug("%sWill parse list" % level) 
    86                ret = [] 
    87                token = self.peaktoken() 
    88                while token != ")": 
    89                        ret.append( self.parsenamedvalue( level+"  " ) ) 
    90                        token = self.peaktoken() 
    91                log.debug("%slist is %s" % (level, str(ret))) 
    92                self.lex.get_token() 
    93                if self.peaktoken() == ",": 
    94                        log.debug("%sFound a delimiter" % level) 
    95                        self.lex.get_token() 
    96                return ret 
     81    def parselist( self, level="" ): 
     82        token = self.peaktoken() 
     83        if token != "(": 
     84            return 
     85        self.lex.get_token() 
     86        log.debug("%sWill parse list" % level) 
     87        ret = [] 
     88        token = self.peaktoken() 
     89        while token != ")": 
     90            ret.append( self.parsenamedvalue( level+"  " ) ) 
     91            token = self.peaktoken() 
     92        log.debug("%slist is %s" % (level, str(ret))) 
     93        self.lex.get_token() 
     94        if self.peaktoken() == ",": 
     95            log.debug("%sFound a delimiter" % level) 
     96            self.lex.get_token() 
     97        return ret 
    9798 
    98        def parsemap( self, level="" ): 
    99                token = self.lex.get_token() 
    100                if token != "{": 
    101                        return 
    102                log.debug("%sWill parse map" % level) 
    103                ret = {} 
    104                token = self.peaktoken() 
    105                while token != "}": 
    106                        #self.push_token( token ) 
    107                        tmp = self.parsenamedvalue( level+"  " ) 
    108                        if tmp != None: 
    109                                ret[ tmp[0] ] = tmp[1] 
    110                        token = self.peaktoken() 
    111                token = self.lex.get_token() 
    112                log.debug("%sMap ended with '%s' and '%s'"% (level,token,self.peaktoken())) 
    113                if self.peaktoken() in (",",";"): 
    114                        log.debug("%sFound a delimiter!" % level) 
    115                        self.lex.get_token() 
    116                return ret 
     99    def parsemap( self, level="" ): 
     100        token = self.lex.get_token() 
     101        if token != "{": 
     102            return 
     103        log.debug("%sWill parse map" % level) 
     104        ret = {} 
     105        token = self.peaktoken() 
     106        while token != "}": 
     107            #self.push_token( token ) 
     108            tmp = self.parsenamedvalue( level+"  " ) 
     109            if tmp != None: 
     110                ret[ tmp[0] ] = tmp[1] 
     111            token = self.peaktoken() 
     112        token = self.lex.get_token() 
     113        log.debug("%sMap ended with '%s' and '%s'"% (level,token,self.peaktoken())) 
     114        if self.peaktoken() in (",",";"): 
     115            log.debug("%sFound a delimiter!" % level) 
     116            self.lex.get_token() 
     117        return ret 
    117118 
    118        def parsevalue( self, level="" ): 
    119                token = self.lex.get_token() 
    120                log.debug("%sparsevalue() called on token '%s'" % (level, token)) 
    121                self.lex.push_token( token ) 
    122                if token == "(": 
    123                        value = self.parselist( level+"  " ) 
    124                elif token == "{": 
    125                        value = self.parsemap( level+"  " ) 
    126                else: 
    127                        value = self.lex.get_token().replace( "\"", "" ) 
    128                token = self.peaktoken() 
    129                if token == ";": 
    130                        log.debug("%sFound a delimiter!" % level) 
    131                        self.lex.get_token() 
    132                return value 
     119    def parsevalue( self, level="" ): 
     120        token = self.lex.get_token() 
     121        log.debug("%sparsevalue() called on token '%s'" % (level, token)) 
     122        self.lex.push_token( token ) 
     123        if token == "(": 
     124            value = self.parselist( level+"  " ) 
     125        elif token == "{": 
     126            value = self.parsemap( level+"  " ) 
     127        else: 
     128            value = self.lex.get_token().replace( "\"", "" ) 
     129        token = self.peaktoken() 
     130        if token == ";": 
     131            log.debug("%sFound a delimiter!" % level) 
     132            self.lex.get_token() 
     133        return value 
    133134 
    134        def parsenamedvalue( self, level="" ): 
    135                token = self.lex.get_token() 
    136                log.debug("%sparsenamedvalue() called on token '%s'" % (level, token)) 
    137                if token == "{": 
    138                        self.lex.push_token( token ) 
    139                        return self.parsemap( level+"  " ) 
    140                if len(token) > 0 and token not in ("{","}","(",")",",",";"): 
    141                        log.debug("%sGot name '%s'" %(level,token)) 
    142                        name = token 
    143                        token = self.lex.get_token() 
    144                        if token in ("=",":"): 
    145                                #print "%sWill parse value" % level 
    146                                value = self.parsevalue( level ) 
    147                                return (name,value) 
    148                log.debug("%sparsenamedvalue() will return None!" % level) 
    149                return 
     135    def parsenamedvalue( self, level="" ): 
     136        token = self.lex.get_token() 
     137        log.debug("%sparsenamedvalue() called on token '%s'" % (level, token)) 
     138        if token == "{": 
     139            self.lex.push_token( token ) 
     140            return self.parsemap( level+"  " ) 
     141        if len(token) > 0 and token not in ("{","}","(",")",",",";"): 
     142            log.debug("%sGot name '%s'" %(level,token)) 
     143            name = token 
     144            token = self.lex.get_token() 
     145            if token in ("=",":"): 
     146                #print "%sWill parse value" % level 
     147                value = self.parsevalue( level ) 
     148                return (name,value) 
     149        log.debug("%sparsenamedvalue() will return None!" % level) 
     150        return 
    150151 
    151152# 
    …… 
    154155if __name__ == "__main__": 
    155156 
    156        import sys 
     157    import sys 
    157158 
    158        file = sys.argv[1] 
     159    file = sys.argv[1] 
    159160 
    160        log.setLevel(logging.DEBUG) 
    161        devs = DeviceList( file ) 
     161    log.setLevel(logging.DEBUG) 
     162    devs = DeviceList( file ) 
    162163 
    163        print devs.devices 
     164    print devs.devices 
    164165 
    165166# vim: et