Python compat - exception

[michaelplatings]

LGTM

llvm/trunk/test/tools/llvm-readobj/Inputs/relocs.py

for symbol in attributes:
 
       # The first symbol with the given value is authoritative.
       if not (value in self._map):
         # MyEnum[value] == symbol
         self._map[value] = symbol
 
   # Not supported (Enums are immutable).
   def __setattr__(self, name, value):
-    raise NotSupportedException, self.__setattr__
+    raise NotSupportedException(self.__setattr__)
 
   # Not supported (Enums are immutable).
   def __delattr__(self, name):
-    raise NotSupportedException, self.__delattr__
+    raise NotSupportedException(self.__delattr__)
 
   # Gets the enum symbol for the specified value.
   def __getitem__(self, value):
     symbol = self._map.get(value)
     if symbol is None:
-      raise KeyError, value
+      raise KeyError(value)
     return symbol
 
   # Gets the enum symbol for the specified value or none.
   def lookup(self, value):
     symbol = self._map.get(value)
     return symbol
 
   # Not supported (Enums are immutable).
   def __setitem__(self, value, symbol):
-    raise NotSupportedException, self.__setitem__
+    raise NotSupportedException(self.__setitem__)
 
   # Not supported (Enums are immutable).
   def __delitem__(self, value):
-    raise NotSupportedException, self.__delitem__
+    raise NotSupportedException(self.__delitem__)
 
   def entries(self):
     # sort by (value, name)
     def makeKey(item):
       return (item[1], item[0])
     e = []
     for pair in sorted(self._nameMap.iteritems(), key=makeKey):
       e.append(pair)
def tell(self):
     return self.file.tell()
 
   def seek(self, pos):
     self.file.seek(pos)
 
   def read(self, N):
     data = self.file.read(N)
     if len(data) != N:
-      raise ValueError, "Out of data!"
+      raise ValueError("Out of data!")
     return data
 
   def int8(self):
     return ord(self.read(1))
 
   def uint8(self):
     return ord(self.read(1))
 
def patchElf(path, relocs):
   assert magic == '\x7FELF'
 
   fileclass = f.uint8()
   if fileclass == 1:
     f.is64Bit = False
   elif fileclass == 2:
     f.is64Bit = True
   else:
-    raise ValueError, "Unknown file class %x" % fileclass
+    raise ValueError("Unknown file class %x" % fileclass)
 
   byteordering = f.uint8()
   if byteordering == 1:
       f.isLSB = True
   elif byteordering == 2:
       f.isLSB = False
   else:
-      raise ValueError, "Unknown byte ordering %x" % byteordering
+      raise ValueError("Unknown byte ordering %x" % byteordering)
 
   f.seek(18)
   e_machine = f.uint16()
   if e_machine == 0x0008 and f.is64Bit: # EM_MIPS && 64 bit
       f.isN64 = True
 
   e_version = f.uint32()
   e_entry = f.word()
if magic == '\xFE\xED\xFA\xCE':
     f.isLSB, f.is64Bit = False, False
   elif magic == '\xCE\xFA\xED\xFE':
     f.isLSB, f.is64Bit = True, False
   elif magic == '\xFE\xED\xFA\xCF':
     f.isLSB, f.is64Bit = False, True
   elif magic == '\xCF\xFA\xED\xFE':
     f.isLSB, f.is64Bit = True, True
   else:
-    raise ValueError,"Not a Mach-O object file: %r (bad magic)" % path
+    raise ValueError("Not a Mach-O object file: %r (bad magic)" % path)
 
   cputype = f.uint32()
   cpusubtype = f.uint32()
   filetype = f.uint32()
   numLoadCommands = f.uint32()
   loadCommandsSize = f.uint32()
   flag = f.uint32()
   if f.is64Bit:
     reserved = f.uint32()
 
   start = f.tell()
 
   for i in range(numLoadCommands):
     patchMachoLoadCommand(f, relocs)
 
   if f.tell() - start != loadCommandsSize:
-    raise ValueError,"%s: warning: invalid load commands size: %r" % (
-      sys.argv[0], loadCommandsSize)
+    raise ValueError("%s: warning: invalid load commands size: %r" % (
+      sys.argv[0], loadCommandsSize))
 
 def patchMachoLoadCommand(f, relocs):
   start = f.tell()
   cmd = f.uint32()
   cmdSize = f.uint32()
 
   if cmd == 1:
     patchMachoSegmentLoadCommand(f, relocs)
   elif cmd == 25:
     patchMachoSegmentLoadCommand(f, relocs)
   else:
     f.read(cmdSize - 8)
 
   if f.tell() - start != cmdSize:
-    raise ValueError,"%s: warning: invalid load command size: %r" % (
-      sys.argv[0], cmdSize)
+    raise ValueError("%s: warning: invalid load command size: %r" % (
+      sys.argv[0], cmdSize))
 
 def patchMachoSegmentLoadCommand(f, relocs):
   segment_name = f.read(16)
   vm_addr = f.word()
   vm_size = f.word()
   file_offset = f.word()
   file_size = f.word()
   maxprot = f.uint32()