Python2/3 compat - exceptions

[joerg]

LGTM

cfe/trunk/tools/scan-view/share/ScanView.py

def run(self):
         try:
             if self.server.options.debug:
                 print >>sys.stderr, "%s: SERVER: submitting bug."%(sys.argv[0],)
             self.status = self.reporter.fileReport(self.report, self.parameters)
             self.success = True
             time.sleep(3)
             if self.server.options.debug:
                 print >>sys.stderr, "%s: SERVER: submission complete."%(sys.argv[0],)
-        except Reporter.ReportFailure,e:
+        except Reporter.ReportFailure as e:
             self.status = e.value
-        except Exception,e:
+        except Exception as e:
             s = StringIO.StringIO()
             import traceback
             print >>s,'<b>Unhandled Exception</b><br><pre>'
             traceback.print_exc(e,file=s)
             print >>s,'</pre>'
             self.status = s.getvalue()
 
 class ScanViewServer(BaseHTTPServer.HTTPServer):
def halt(self):
             print >>sys.stderr, "%s: SERVER: halting." % (sys.argv[0],)
 
     def serve_forever(self):
         while not self.halted:
             if self.options.debug > 1:
                 print >>sys.stderr, "%s: SERVER: waiting..." % (sys.argv[0],)
             try:
                 self.handle_request()
-            except OSError,e:
+            except OSError as e:
                 print 'OSError',e.errno
 
     def finish_request(self, request, client_address):
         if self.options.autoReload:
             import ScanView
             self.RequestHandlerClass = reload(ScanView).ScanViewRequestHandler
         BaseHTTPServer.HTTPServer.finish_request(self, request, client_address)
 

 
 class ScanViewRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
     server_version = "ScanViewServer/" + __version__
     dynamic_mtime = time.time()
 
     def do_HEAD(self):
         try:
             SimpleHTTPServer.SimpleHTTPRequestHandler.do_HEAD(self)
-        except Exception,e:
+        except Exception as e:
             self.handle_exception(e)
             
     def do_GET(self):
         try:
             SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
-        except Exception,e:
+        except Exception as e:
             self.handle_exception(e)
             
     def do_POST(self):
         """Serve a POST request."""
         try:
             length = self.headers.getheader('content-length') or "0"
             try:
                 length = int(length)
             except:
                 length = 0
             content = self.rfile.read(length)
             fields = parse_query(content)
             f = self.send_head(fields)
             if f:
                 self.copyfile(f, self.wfile)
                 f.close()
-        except Exception,e:
+        except Exception as e:
             self.handle_exception(e)            
 
     def log_message(self, format, *args):
         if self.server.options.debug:
             sys.stderr.write("%s: SERVER: %s - - [%s] %s\n" %
                              (sys.argv[0],
                               self.address_string(),
                               self.log_date_time_string(),
</html>"""%locals()
 
     def get_report_context(self, report):
         class Context:
             pass
         if report is None or report == 'None':
             data = self.load_crashes()
             # Don't allow empty reports.
             if not data:
-                raise ValueError, 'No crashes detected!'
+                raise ValueError('No crashes detected!')
             c = Context()
             c.title = 'clang static analyzer failures'
 
             stderrSummary = ""
             for item in data:
                 if 'stderr' in item:
                     path = posixpath.join(self.server.root, item['stderr'])
                     if os.path.exists(path):
""" % ('\n'.join([item.get('src','<unknown>') for item in data]),
             # Just in case something failed, ignore files which don't
             # exist.
             c.files = [f for f in c.files
                        if os.path.exists(f) and os.path.isfile(f)]
         else:
             # Check that this is a valid report.            
             path = posixpath.join(self.server.root, 'report-%s.html' % report)
             if not posixpath.exists(path):
-                raise ValueError, 'Invalid report ID'
+                raise ValueError('Invalid report ID')
             keys = self.load_report(report)
             c = Context()
             c.title = keys.get('DESC','clang error (unrecognized')
             c.description = """\
 Bug reported by the clang static analyzer.
 
 Description: %s
 File: %s
def send_report(self, report, configOverrides=None):
                 section in configOverrides and
                 field in configOverrides[section]):
                 return configOverrides[section][field]
             return self.server.config.get(section, field)
 
         # report is None is used for crashes
         try:
             c = self.get_report_context(report)
-        except ValueError, e:
+        except ValueError as e:
             return self.send_error(400, e.message)
 
         title = c.title
         description= c.description
         reportingFor = c.navMarkup
         if c.reportSource is None:
             extraIFrame = ""
         else:

cfe/trunk/utils/ABITest/ABITestGen.py

def getTestValues(self, t):
             if not values:
                 yield '{ }'
             for i in range(t.numElements):
                 for v in values:
                     elements = [random.choice(values) for i in range(t.numElements)]
                     elements[i] = v
                     yield '{ %s }'%(', '.join(elements))
         else:
-            raise NotImplementedError,'Cannot make tests values of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot make tests values of type: "%s"'%(t,))
 
     def printSizeOfType(self, prefix, name, t, output=None, indent=2):
         print >>output, '%*sprintf("%s: sizeof(%s) = %%ld\\n", (long)sizeof(%s));'%(indent, '', prefix, name, name) 
     def printAlignOfType(self, prefix, name, t, output=None, indent=2):
         print >>output, '%*sprintf("%s: __alignof__(%s) = %%ld\\n", (long)__alignof__(%s));'%(indent, '', prefix, name, name) 
     def printOffsetsOfType(self, prefix, name, t, output=None, indent=2):
         if isinstance(t, RecordType):
             for i,f in enumerate(t.fields):
def printValueOfType(self, prefix, name, t, output=None, indent=2):
             for i in range(t.numElements):
                 # Access in this fashion as a hackish way to portably
                 # access vectors.
                 if t.isVector:
                     self.printValueOfType(prefix, '((%s*) &%s)[%d]'%(t.elementType,name,i), t.elementType, output=output,indent=indent)
                 else:
                     self.printValueOfType(prefix, '%s[%d]'%(name,i), t.elementType, output=output,indent=indent)                    
         else:
-            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot print value of type: "%s"'%(t,))
 
     def checkTypeValues(self, nameLHS, nameRHS, t, output=None, indent=2):
         prefix = 'foo'
         if output is None:
             output = self.output
         if isinstance(t, BuiltinType):
             print >>output, '%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS)
         elif isinstance(t, EnumType):
def checkTypeValues(self, nameLHS, nameRHS, t, output=None, indent=2):
                 if t.isVector:
                     self.checkTypeValues('((%s*) &%s)[%d]'%(t.elementType,nameLHS,i), 
                                          '((%s*) &%s)[%d]'%(t.elementType,nameRHS,i), 
                                          t.elementType, output=output,indent=indent)
                 else:
                     self.checkTypeValues('%s[%d]'%(nameLHS,i), '%s[%d]'%(nameRHS,i), 
                                          t.elementType, output=output,indent=indent)                    
         else:
-            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot print value of type: "%s"'%(t,))
 
 import sys
 
 def main():
     from optparse import OptionParser, OptionGroup
     parser = OptionParser("%prog [options] {indices}")
     parser.add_option("", "--mode", dest="mode",
                       help="autogeneration mode (random or linear) [default %default]",
P = TypePrinter(output,
                     outputTests=outputTests,
                     outputDriver=outputDriver,
                     headerName=opts.outputHeader,                    
                     info=info)
 
     def write(N):
         try:
             FT = ftg.get(N)
-        except RuntimeError,e:
+        except RuntimeError as e:
             if e.args[0]=='maximum recursion depth exceeded':
                 print >>sys.stderr,'WARNING: Skipped %d, recursion limit exceeded (bad arguments?)'%(N,)
                 return
             raise
         if opts.testLayout:
             P.writeLayoutTest(N, FT)
         else:
             P.writeFunction(N, FT)

cfe/trunk/utils/ABITest/Enumeration.py

def __new__(type):
         return type._singleton
     def __repr__(self): return '<aleph0>'
     def __str__(self): return 'inf'
     
     def __cmp__(self, b):
         return 1
 
     def __sub__(self, b):
-        raise ValueError,"Cannot subtract aleph0"
+        raise ValueError("Cannot subtract aleph0")
     __rsub__ = __sub__
 
     def __add__(self, b): 
         return self
     __radd__ = __add__
 
     def __mul__(self, b): 
         if b == 0: return b            
def getNthPair(N):
     return (line - index, index)
 
 def getNthPairBounded(N,W=aleph0,H=aleph0,useDivmod=False):
     """getNthPairBounded(N, W, H) -> (x, y)
     
     Return the N-th pair such that 0 <= x < W and 0 <= y < H."""
 
     if W <= 0 or H <= 0:
-        raise ValueError,"Invalid bounds"
+        raise ValueError("Invalid bounds")
     elif N >= W*H:
-        raise ValueError,"Invalid input (out of bounds)"
+        raise ValueError("Invalid input (out of bounds)")
 
     # Simple case...
     if W is aleph0 and H is aleph0:
         return getNthPair(N)
 
     # Otherwise simplify by assuming W < H
     if H < W:
         x,y = getNthPairBounded(N,H,W,useDivmod=useDivmod)
def getNthTuple(N, maxSize=aleph0, maxElement=aleph0, useDivmod=False, useLeftToRight=False):
     y < maxElement."""
 
     # All zero sized tuples are isomorphic, don't ya know.
     if N == 0:
         return ()
     N -= 1
     if maxElement is not aleph0:
         if maxSize is aleph0:
-            raise NotImplementedError,'Max element size without max size unhandled'
+            raise NotImplementedError('Max element size without max size unhandled')
         bounds = [maxElement**i for i in range(1, maxSize+1)]
         S,M = getNthPairVariableBounds(N, bounds)
     else:
         S,M = getNthPairBounded(N, maxSize, useDivmod=useDivmod)
     return getNthNTuple(M, S+1, maxElement, useLeftToRight=useLeftToRight)
 def getNthTupleChecked(N, maxSize=aleph0, maxElement=aleph0, 
                        useDivmod=False, useLeftToRight=False, GNT=getNthTuple):
     # FIXME: maxsize is inclusive
     t = GNT(N,maxSize,maxElement,useDivmod,useLeftToRight)
     assert len(t) <= maxSize
     for i in t:
         assert i < maxElement
     return t
 
 def getNthPairVariableBounds(N, bounds):
     """getNthPairVariableBounds(N, bounds) -> (x, y)
 
     Given a finite list of bounds (which may be finite or aleph0),
     return the N-th pair such that 0 <= x < len(bounds) and 0 <= y <
     bounds[x]."""
 
     if not bounds:
-        raise ValueError,"Invalid bounds"
+        raise ValueError("Invalid bounds")
     if not (0 <= N < sum(bounds)):
-        raise ValueError,"Invalid input (out of bounds)"
+        raise ValueError("Invalid input (out of bounds)")
 
     level = 0
     active = range(len(bounds))
     active.sort(key=lambda i: bounds[i])
     prevLevel = 0
     for i,index in enumerate(active):
         level = bounds[index]
         W = len(active) - i
         if level is aleph0:
             H = aleph0
         else:
             H = level - prevLevel
         levelSize = W*H
         if N<levelSize: # Found the level
             idelta,delta = getNthPairBounded(N, W, H)
             return active[i+idelta],prevLevel+delta
         else:
             N -= levelSize
             prevLevel = level
     else:
-        raise RuntimError,"Unexpected loop completion"
+        raise RuntimError("Unexpected loop completion")
 
 def getNthPairVariableBoundsChecked(N, bounds, GNVP=getNthPairVariableBounds):
     x,y = GNVP(N,bounds)
     assert 0 <= x < len(bounds) and 0 <= y < bounds[x]
     return (x,y)
 
 ###
 

cfe/trunk/utils/ABITest/TypeGen.py

def addGenerator(self, g):
             prev = self._cardinality
             self._cardinality = None
             for g in self.generators:
                 g.setCardinality()
             self.setCardinality()
             if (self._cardinality is aleph0) or prev==self._cardinality:
                 break
         else:
-            raise RuntimeError,"Infinite loop in setting cardinality"
+            raise RuntimeError("Infinite loop in setting cardinality")
 
     def generateType(self, N):
         index,M = getNthPairVariableBounds(N, self.bounds)
         return self.generators[index].get(M)
 
 def test():
     fbtg = FixedTypeGenerator([BuiltinType('char', 4),
                                BuiltinType('char', 4, 0),
#    fields0.addGenerator( RecordTypeGenerator(fields1, False, 4) )
     atg.addGenerator( btg )
     atg.addGenerator( RecordTypeGenerator(fields0, False, 4) )
     atg.addGenerator( etg )
     print 'Cardinality:',atg.cardinality
     for i in range(100):
         if i == atg.cardinality:
             try:
                 atg.get(i)
-                raise RuntimeError,"Cardinality was wrong"
+                raise RuntimeError("Cardinality was wrong")
             except AssertionError:
                 break
         print '%4d: %s'%(i, atg.get(i))
 
 if __name__ == '__main__':
     test()

cfe/trunk/utils/analyzer/SATestBuild.py

for FullFileName in glob.glob(Dir + "/*"):
         Command = CmdPrefix + OutputOption + ("'%s'" % FileName)
         LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+b")
         try:
             if Verbose == 1:
                 Local.stdout.write("  Executing: %s\n" % (Command,))
             check_call(Command, cwd=Dir, stderr=LogFile,
                        stdout=LogFile,
                        shell=True)
-        except CalledProcessError, e:
+        except CalledProcessError as e:
             Local.stderr.write("Error: Analyzes of %s failed. "
                                "See %s for details."
                                "Error code %d.\n" % (
                                    FullFileName, LogFile.name, e.returncode))
             Failed = True
         finally:
             LogFile.close()
 

cfe/trunk/utils/token-delta.py

class DeltaAlgorithm(object):
 
     def run(self, changes, force=False):
         # Make sure the initial test passes, if not then (a) either
         # the user doesn't expect monotonicity, and we may end up
         # doing O(N^2) tests, or (b) the test is wrong. Avoid the
         # O(N^2) case unless user requests it.
         if not force:
             if not self.getTestResult(changes):
-                raise ValueError,'Initial test passed to delta fails.'
+                raise ValueError('Initial test passed to delta fails.')
 
         # Check empty set first to quickly find poor test functions.
         if self.getTestResult(set()):
             return set()
         else:
             return self.delta(changes, self.split(changes))
 
     def split(self, S):