Changeset 1577 for pykota/trunk

Show
Ignore:
Timestamp:
06/29/04 01:11:26 (20 years ago)
Author:
jalet
Message:

Code de-factorization in PCLXL parser

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • pykota/trunk/pykota/pdlanalyzer.py

    r1576 r1577  
    2222# 
    2323# $Log$ 
     24# Revision 1.21  2004/06/28 23:11:26  jalet 
     25# Code de-factorization in PCLXL parser 
     26# 
    2427# Revision 1.20  2004/06/28 22:38:41  jalet 
    2528# Increased speed by a factor of 2 in PCLXL parser 
     
    264267        # raise PDLAnalyzerError, "PCLXL (aka PCL6) is not supported yet." 
    265268        self.infile = infile 
    266         self.islittleendian = None 
     269        self.endianness = None 
    267270        found = 0 
    268271        while not found : 
     
    333336        return 0 
    334337         
    335     def handleArray(self, itemsize) :         
    336         """Handles arrays.""" 
     338    def array_8(self) :     
     339        """Handles byte arrays.""" 
    337340        pos = self.pos 
    338341        datatype = self.minfile[pos] 
     
    346349        sarraysize = self.minfile[pos:posl] 
    347350        self.pos = posl 
    348         if self.islittleendian : 
    349             fmt = "<" 
    350         else :     
    351             fmt = ">" 
    352351        if length == 1 :     
    353             fmt += "B" 
     352            return struct.unpack(self.endianness + "B", sarraysize)[0] 
    354353        elif length == 2 :     
    355             fmt += "H" 
     354            return struct.unpack(self.endianness + "H", sarraysize)[0] 
    356355        elif length == 4 :     
    357             fmt += "I" 
     356            return struct.unpack(self.endianness + "I", sarraysize)[0] 
    358357        else :     
    359358            raise PDLAnalyzerError, "Error on array size at %s" % self.pos 
    360         arraysize = struct.unpack(fmt, sarraysize)[0] 
    361         return arraysize * itemsize 
    362          
    363     def array_8(self) :     
    364         """Handles byte arrays.""" 
    365         return self.handleArray(1) 
    366359         
    367360    def array_16(self) :     
    368361        """Handles byte arrays.""" 
    369         return self.handleArray(2) 
     362        pos = self.pos 
     363        datatype = self.minfile[pos] 
     364        pos += 1 
     365        length = self.tags[ord(datatype)] 
     366        if callable(length) : 
     367            self.pos = pos 
     368            length = length() 
     369            pos = self.pos 
     370        posl = pos + length 
     371        sarraysize = self.minfile[pos:posl] 
     372        self.pos = posl 
     373        if length == 1 :     
     374            return 2 * struct.unpack(self.endianness + "B", sarraysize)[0] 
     375        elif length == 2 :     
     376            return 2 * struct.unpack(self.endianness + "H", sarraysize)[0] 
     377        elif length == 4 :     
     378            return 2 * struct.unpack(self.endianness + "I", sarraysize)[0] 
     379        else :     
     380            raise PDLAnalyzerError, "Error on array size at %s" % self.pos 
    370381         
    371382    def array_32(self) :     
    372383        """Handles byte arrays.""" 
    373         return self.handleArray(4) 
     384        pos = self.pos 
     385        datatype = self.minfile[pos] 
     386        pos += 1 
     387        length = self.tags[ord(datatype)] 
     388        if callable(length) : 
     389            self.pos = pos 
     390            length = length() 
     391            pos = self.pos 
     392        posl = pos + length 
     393        sarraysize = self.minfile[pos:posl] 
     394        self.pos = posl 
     395        if length == 1 :     
     396            return 4 * struct.unpack(self.endianness + "B", sarraysize)[0] 
     397        elif length == 2 :     
     398            return 4 * struct.unpack(self.endianness + "H", sarraysize)[0] 
     399        elif length == 4 :     
     400            return 4 * struct.unpack(self.endianness + "I", sarraysize)[0] 
     401        else :     
     402            raise PDLAnalyzerError, "Error on array size at %s" % self.pos 
    374403         
    375404    def embeddedDataSmall(self) : 
     
    382411    def embeddedData(self) : 
    383412        """Handle normal amounts of data.""" 
    384         if self.islittleendian : 
    385             fmt = "<I" 
    386         else :     
    387             fmt = ">I" 
     413        fmt = self.endianness + "I" 
    388414        pos = self.pos 
    389415        pos4 = pos + 4 
     
    394420    def littleEndian(self) :         
    395421        """Toggles to little endianness.""" 
    396         self.islittleendian = 1 # little endian 
     422        self.endianness = "<" # little endian 
    397423        return 0 
    398424         
    399425    def bigEndian(self) :     
    400426        """Toggles to big endianness.""" 
    401         self.islittleendian = 0 # big endian 
     427        self.endianness = ">" # big endian 
    402428        return 0 
    403429     
     
    586612     
    587613if __name__ == "__main__" :     
    588     main()         
     614    main()