Cosmetic cleanup.

1 files changed, 54 insertions, 46 deletions

diff --git a/radeonreg.py b/radeonreg.py
index 2e4d474..36fefd4 100755
--- a/radeonreg.py
+++ b/radeonreg.py
@@ -5,7 +5,8 @@ import itertools
 import re
 from xml.etree import ElementTree
 
-class RadeonReg:
+class RadeonReg(object):
+
     def __init__(self, unit, name, count, access, addr, stride, desc):
         self.unit = unit
         self.name = name
@@ -15,26 +16,29 @@ class RadeonReg:
         self.addr = addr
         self.fields = []
         self.stride = stride
-    
-    def __ne__(self, rhs): return not (self == rhs)
-    def __eq__(self, rhs):
-        if (not isinstance(rhs, RadeonReg)): return False
+
+    def __eq__(self, other):
+        if (not isinstance(other, RadeonReg)): return False
         
-        if  self.unit != rhs.unit or \
-            self.name != rhs.name or \
-            self.desc != rhs.desc or \
-            self.count != rhs.count or \
-            self.access != rhs.access or \
-            self.addr != rhs.addr or \
-            self.stride != rhs.stride or \
-            len(self.fields) != len(rhs.fields): return False
+        if  self.unit != other.unit or \
+            self.name != other.name or \
+            self.desc != other.desc or \
+            self.count != other.count or \
+            self.access != other.access or \
+            self.addr != other.addr or \
+            self.stride != other.stride or \
+            len(self.fields) != len(other.fields): return False
         
         for i in xrange(len(self.fields)):
-            if self.fields[i] != rhs.fields[i]: return False
+            if self.fields[i] != other.fields[i]: return False
         
         return True
 
-class RadeonField:
+    def __ne__(self, other):
+        return not self == other
+
+class RadeonField(object):
+
     def __init__(self, name, low, high, desc):
         self.name = name
         self.desc = desc
@@ -42,64 +46,69 @@ class RadeonField:
         self.high = high if high >= low else low
         self.enum = None
     
-    def __ne__(self, rhs): return not (self == rhs)
-    def __eq__(self, rhs):
-        if (not isinstance(rhs, RadeonField)): return False
+    def __eq__(self, other):
+        if (not isinstance(other, RadeonField)): return False
         
-        if  self.name == rhs.name and \
-            self.desc == rhs.desc and \
-            self.low == rhs.low and \
-            self.high == rhs.high and \
-            self.enum == rhs.enum: return True
+        if  self.name == other.name and \
+            self.desc == other.desc and \
+            self.low == other.low and \
+            self.high == other.high and \
+            self.enum == other.enum: return True
         return False
 
-class EnumEntry:
+    def __ne__(self, other):
+        return not self == other
+
+class EnumEntry(object):
+
     def __init__(self, val, name, desc):
         self.val = val
         self.name = name
         self.desc = desc
     
-    def __ne__(self, rhs): return not (self == rhs)
-    def __eq__(self, rhs):
-        if (not isinstance(rhs, EnumEntry)): return False
+    def __eq__(self, other):
+        if (not isinstance(other, EnumEntry)): return False
         
-        if  self.val == rhs.val and \
-            self.name == rhs.name and \
-            self.desc == rhs.desc: return True
+        if  self.val == other.val and \
+            self.name == other.name and \
+            self.desc == other.desc: return True
         return False
 
-class RadeonEnum:
+    def __ne__(self, other):
+        return not self == other
+
+class RadeonEnum(object):
+
     def __init__(self):
         self.entries = []
         self.refs = 0
         
     def add(self, val, name, desc):
         self.entries.append(EnumEntry(val, name, desc))
-        
-    def reference(self): self.refs += 1
-    def dereference(self): self.refs -= 1
 
-    def __ne__(self, rhs): return not (self == rhs)
-    def __eq__(self, rhs):
-        if (not isinstance(rhs, RadeonEnum)): return False
+    def __eq__(self, other):
+        if (not isinstance(other, RadeonEnum)): return False
         
-        if len(self.entries) != len(rhs.entries): return False
+        if len(self.entries) != len(other.entries): return False
 
         for i in xrange(len(self.entries)):
-            if self.entries[i] != rhs.entries[i]: return False
+            if self.entries[i] != other.entries[i]: return False
 
         return True
 
+    def __ne__(self, other):
+        return not self == other
+
 enums = []
 
 def AddEnum(e):
     for i in xrange(len(enums)):
         if e == enums[i]:
-            enums[i].reference()
+            enums[i].refs += 1
             return i
 
     enums.append(e)
-    enums[-1].reference()
+    enums[-1].refs += 1
     return len(enums)-1
 
 enum_regex = re.compile('(\d\d?)( - |: |=)((?:(?!\d\d?(?: - |: |=)).)*)', re.DOTALL)
@@ -144,12 +153,11 @@ def ReadPDFDump(filename):
 
     formatted = ''
     for line in pdflines:
-        out = line
         for regex in subs:
-            out = regex.sub('', out)
+            line = regex.sub('', line)
             
-        if out != '':
-            formatted += out + '\n'
+        if line:
+            formatted += line + '\n'
 
     formatted = stupid_linebreaks.sub('-0x', formatted);
     return formatted + '\n'
@@ -219,7 +227,7 @@ def CompareRegs(regs1, regs2):
         if r1r == r2r:
             regs_both.append(r1r)
             for bf in regs_both[-1].fields:
-                if bf.enum != None: enums[bf.enum].dereference()
+                if bf.enum != None: enums[bf.enum].refs -= 1
 
     regs_a = [reg for reg in regs1 if not RegInArray(reg, regs_both)]
     regs_b = [reg for reg in regs2 if not RegInArray(reg, regs_both)]