satisfy the tabnanny

3 files changed, 358 insertions, 358 deletions

diff --git a/Tools/scripts/eptags.py b/Tools/scripts/eptags.py
index 0e93447..dca875b 100755
--- a/Tools/scripts/eptags.py
+++ b/Tools/scripts/eptags.py
@@ -24,32 +24,33 @@ matcher = re.compile(expr)
 def treat_file(file, outfp):
     """Append tags found in file named 'file' to the open file 'outfp'"""
     try:
-	fp = open(file, 'r')
+        fp = open(file, 'r')
     except:
-	sys.stderr.write('Cannot open %s\n'%file)
-	return
+        sys.stderr.write('Cannot open %s\n'%file)
+        return
     charno = 0
     lineno = 0
     tags = []
     size = 0
     while 1:
-	line = fp.readline()
-	if not line: break
-	lineno = lineno + 1
-	m = matcher.search(line)
-	if m:
-	    tag = m.group(0) + '\177%d,%d\n'%(lineno,charno)
-	    tags.append(tag)
-	    size = size + len(tag)
-	charno = charno + len(line)
+        line = fp.readline()
+        if not line:
+            break
+        lineno = lineno + 1
+        m = matcher.search(line)
+        if m:
+            tag = m.group(0) + '\177%d,%d\n'%(lineno,charno)
+            tags.append(tag)
+            size = size + len(tag)
+        charno = charno + len(line)
     outfp.write('\f\n%s,%d\n'%(file,size))
     for tag in tags:
-	outfp.write(tag)
+        outfp.write(tag)
 
 def main():
     outfp = open('TAGS', 'w')
     for file in sys.argv[1:]:
-	treat_file(file, outfp)
+        treat_file(file, outfp)
 
 if __name__=="__main__":
     main()
diff --git a/Tools/scripts/parseentities.py b/Tools/scripts/parseentities.py
index b708116..ab4f830 100755
--- a/Tools/scripts/parseentities.py
+++ b/Tools/scripts/parseentities.py
@@ -21,15 +21,15 @@ def parse(text,pos=0,endpos=None):
 
     pos = 0
     if endpos is None:
-	endpos = len(text)
+        endpos = len(text)
     d = {}
     while 1:
-	m = entityRE.search(text,pos,endpos)
-	if not m:
-	    break
-	name,charcode,comment = m.groups()
-	d[name] = charcode,comment
-	pos = m.end()
+        m = entityRE.search(text,pos,endpos)
+        if not m:
+            break
+        name,charcode,comment = m.groups()
+        d[name] = charcode,comment
+        pos = m.end()
     return d
 
 def writefile(f,defs):
@@ -38,27 +38,27 @@ def writefile(f,defs):
     items = defs.items()
     items.sort()
     for name,(charcode,comment) in items:
-	if charcode[:2] == '&#':
-	    code = int(charcode[2:-1])
-	    if code < 256:
-		charcode = "'\%o'" % code
-	    else:
-		charcode = repr(charcode)
-	else:
-	    charcode = repr(charcode)
-	comment = TextTools.collapse(comment)
-	f.write("    '%s':\t%s,  \t# %s\n" % (name,charcode,comment))
+        if charcode[:2] == '&#':
+            code = int(charcode[2:-1])
+            if code < 256:
+                charcode = "'\%o'" % code
+            else:
+                charcode = repr(charcode)
+        else:
+            charcode = repr(charcode)
+        comment = TextTools.collapse(comment)
+        f.write("    '%s':\t%s,  \t# %s\n" % (name,charcode,comment))
     f.write('\n}\n')
 
 if __name__ == '__main__':
     if len(sys.argv) > 1:
-	infile = open(sys.argv[1])
+        infile = open(sys.argv[1])
     else:
-	infile = sys.stdin
+        infile = sys.stdin
     if len(sys.argv) > 2:
-	outfile = open(sys.argv[2],'w')
+        outfile = open(sys.argv[2],'w')
     else:
-	outfile = sys.stdout
+        outfile = sys.stdout
     text = infile.read()
     defs = parse(text)
     writefile(outfile,defs)
diff --git a/Tools/scripts/trace.py b/Tools/scripts/trace.py
index ec0d45f..d8016b0 100644
--- a/Tools/scripts/trace.py
+++ b/Tools/scripts/trace.py
@@ -99,109 +99,108 @@ modules.
 
 class Ignore:
     def __init__(self, modules = None, dirs = None):
-	self._mods = modules or []
-	self._dirs = dirs or []
+        self._mods = modules or []
+        self._dirs = dirs or []
 
-	self._ignore = { '<string>': 1 }
+        self._ignore = { '<string>': 1 }
 
 
     def names(self, filename, modulename):
-	if self._ignore.has_key(modulename):
-	    return self._ignore[modulename]
-
-	# haven't seen this one before, so see if the module name is
-	# on the ignore list.  Need to take some care since ignoring
-	# "cmp" musn't mean ignoring "cmpcache" but ignoring
-	# "Spam" must also mean ignoring "Spam.Eggs".
-	for mod in self._mods:
-	    if mod == modulename:  # Identical names, so ignore
-		self._ignore[modulename] = 1
-		return 1
-	    # check if the module is a proper submodule of something on
-	    # the ignore list
-	    n = len(mod)
-	    # (will not overflow since if the first n characters are the
-	    # same and the name has not already occured, then the size
-	    # of "name" is greater than that of "mod")
-	    if mod == modulename[:n] and modulename[n] == '.':
-		self._ignore[modulename] = 1
-		return 1
-
-	# Now check that __file__ isn't in one of the directories
-	if filename is None:
-	    # must be a built-in, so we must ignore
-	    self._ignore[modulename] = 1
-	    return 1
-
-	# Ignore a file when it contains one of the ignorable paths
-	for d in self._dirs:
-	    # The '+ os.sep' is to ensure that d is a parent directory,
-	    # as compared to cases like:
-	    #  d = "/usr/local"
-	    #  filename = "/usr/local.py"
-	    # or
-	    #  d = "/usr/local.py"
-	    #  filename = "/usr/local.py"
-	    if string.find(filename, d + os.sep) == 0:
-		self._ignore[modulename] = 1
-		return 1
-
-	# Tried the different ways, so we don't ignore this module
-	self._ignore[modulename] = 0
-	return 0
-	
+        if self._ignore.has_key(modulename):
+            return self._ignore[modulename]
+
+        # haven't seen this one before, so see if the module name is
+        # on the ignore list.  Need to take some care since ignoring
+        # "cmp" musn't mean ignoring "cmpcache" but ignoring
+        # "Spam" must also mean ignoring "Spam.Eggs".
+        for mod in self._mods:
+            if mod == modulename:  # Identical names, so ignore
+                self._ignore[modulename] = 1
+                return 1
+            # check if the module is a proper submodule of something on
+            # the ignore list
+            n = len(mod)
+            # (will not overflow since if the first n characters are the
+            # same and the name has not already occured, then the size
+            # of "name" is greater than that of "mod")
+            if mod == modulename[:n] and modulename[n] == '.':
+                self._ignore[modulename] = 1
+                return 1
+
+        # Now check that __file__ isn't in one of the directories
+        if filename is None:
+            # must be a built-in, so we must ignore
+            self._ignore[modulename] = 1
+            return 1
+
+        # Ignore a file when it contains one of the ignorable paths
+        for d in self._dirs:
+            # The '+ os.sep' is to ensure that d is a parent directory,
+            # as compared to cases like:
+            #  d = "/usr/local"
+            #  filename = "/usr/local.py"
+            # or
+            #  d = "/usr/local.py"
+            #  filename = "/usr/local.py"
+            if string.find(filename, d + os.sep) == 0:
+                self._ignore[modulename] = 1
+                return 1
+
+        # Tried the different ways, so we don't ignore this module
+        self._ignore[modulename] = 0
+        return 0
 
 def run(trace, cmd):
     import __main__
     dict = __main__.__dict__
     sys.settrace(trace)
     try:
-	exec cmd in dict, dict
+        exec cmd in dict, dict
     finally:
-	sys.settrace(None)
+        sys.settrace(None)
 
 def runctx(trace, cmd, globals=None, locals=None):
     if globals is None: globals = {}
     if locals is None: locals = {}
     sys.settrace(trace)
     try:
-	exec cmd in dict, dict
+        exec cmd in dict, dict
     finally:
-	sys.settrace(None)
+        sys.settrace(None)
 
 def runfunc(trace, func, *args, **kw):
     result = None
     sys.settrace(trace)
     try:
-	result = apply(func, args, kw)
+        result = apply(func, args, kw)
     finally:
-	sys.settrace(None)
+        sys.settrace(None)
     return result
 
 
 class CoverageResults:
     def __init__(self, counts = {}, modules = {}):
-	self.counts = counts.copy()    # map (filename, lineno) to count
-	self.modules = modules.copy()  # map filenames to modules
+        self.counts = counts.copy()    # map (filename, lineno) to count
+        self.modules = modules.copy()  # map filenames to modules
 
     def update(self, other):
-	"""Merge in the data from another CoverageResults"""
-	counts = self.counts
-	other_counts = other.counts
-	modules = self.modules
-	other_modules = other.modules
-
-	for key in other_counts.keys():
-	    counts[key] = counts.get(key, 0) + other_counts[key]
-
-	for key in other_modules.keys():
-	    if modules.has_key(key):
-		# make sure they point to the same file
-		assert modules[key] == other_modules[key], \
-		       "Strange! filename %s has two different module names" % \
-		       (key, modules[key], other_module[key])
-	    else:
-		modules[key] = other_modules[key]
+        """Merge in the data from another CoverageResults"""
+        counts = self.counts
+        other_counts = other.counts
+        modules = self.modules
+        other_modules = other.modules
+
+        for key in other_counts.keys():
+            counts[key] = counts.get(key, 0) + other_counts[key]
+
+        for key in other_modules.keys():
+            if modules.has_key(key):
+                # make sure they point to the same file
+                assert modules[key] == other_modules[key], \
+                      "Strange! filename %s has two different module names" % \
+                      (key, modules[key], other_module[key])
+            else:
+                modules[key] = other_modules[key]
 
 # Given a code string, return the SET_LINENO information
 def _find_LINENO_from_string(co_code):
@@ -215,21 +214,21 @@ def _find_LINENO_from_string(co_code):
     prev_op = None
     prev_lineno = 0
     while i < n:
-	c = co_code[i]
-	op = ord(c)
-	if op == dis.SET_LINENO:
-	    if prev_op == op:
-		# two SET_LINENO in a row, so the previous didn't
-		# indicate anything.  This occurs with triple
-		# quoted strings (?).  Remove the old one.
-		del linenos[prev_lineno]
-	    prev_lineno = ord(co_code[i+1]) + ord(co_code[i+2])*256
-	    linenos[prev_lineno] = 1
-	if op >= dis.HAVE_ARGUMENT:
-	    i = i + 3
-	else:
-	    i = i + 1
-	prev_op = op
+        c = co_code[i]
+        op = ord(c)
+        if op == dis.SET_LINENO:
+            if prev_op == op:
+                # two SET_LINENO in a row, so the previous didn't
+                # indicate anything.  This occurs with triple
+                # quoted strings (?).  Remove the old one.
+                del linenos[prev_lineno]
+            prev_lineno = ord(co_code[i+1]) + ord(co_code[i+2])*256
+            linenos[prev_lineno] = 1
+        if op >= dis.HAVE_ARGUMENT:
+            i = i + 3
+        else:
+            i = i + 1
+        prev_op = op
     return linenos
 
 def _find_LINENO(code):
@@ -241,9 +240,9 @@ def _find_LINENO(code):
 
     # and check the constants for references to other code objects
     for c in code.co_consts:
-	if type(c) == types.CodeType:
-	    # find another code object, so recurse into it
-	    linenos.update(_find_LINENO(c))
+        if type(c) == types.CodeType:
+            # find another code object, so recurse into it
+            linenos.update(_find_LINENO(c))
     return linenos
 
 def find_executable_linenos(filename):
@@ -289,7 +288,7 @@ def create_results_log(results, dirname = ".", show_missing = 1,
     per_file = {}
     for filename, lineno in results.counts.keys():
         lines_hit = per_file[filename] = per_file.get(filename, {})
-	lines_hit[lineno] = results.counts[(filename, lineno)]
+        lines_hit[lineno] = results.counts[(filename, lineno)]
 
     # try and merge existing counts and modules file from dirname
     try:
@@ -323,70 +322,70 @@ def create_results_log(results, dirname = ".", show_missing = 1,
         else:
             coverpath = os.path.join(dirname, fndir)
 
-	if filename.endswith(".pyc") or filename.endswith(".pyo"):
+        if filename.endswith(".pyc") or filename.endswith(".pyo"):
             filename = filename[:-1]
 
-	# Get the original lines from the .py file
-	try:
-	    lines = open(filename, 'r').readlines()
-	except IOError, err:
-	    sys.stderr.write(
-		"%s: Could not open %s for reading because: %s - skipping\n" % \
-		("trace", `filename`, err.strerror))
-	    continue
+        # Get the original lines from the .py file
+        try:
+            lines = open(filename, 'r').readlines()
+        except IOError, err:
+            sys.stderr.write("%s: Could not open %s for reading " \
+                             "because: %s - skipping\n" % \
+                             ("trace", `filename`, err.strerror))
+            continue
 
-	modulename = os.path.split(results.modules[key])[1]
+        modulename = os.path.split(results.modules[key])[1]
 
-	# build list file name by appending a ".cover" to the module name
-	# and sticking it into the specified directory
-	listfilename = os.path.join(coverpath, modulename + ".cover")
+        # build list file name by appending a ".cover" to the module name
+        # and sticking it into the specified directory
+        listfilename = os.path.join(coverpath, modulename + ".cover")
         #sys.stderr.write("modulename: %(modulename)s\n"
         #                 "filename: %(filename)s\n"
         #                 "coverpath: %(coverpath)s\n"
         #                 "listfilename: %(listfilename)s\n"
         #                 "dirname: %(dirname)s\n"
         #                 % locals())
-	try:
-	    outfile = open(listfilename, 'w')
-	except IOError, err:
-	    sys.stderr.write(
-		'%s: Could not open %s for writing because: %s - skipping\n' %
-		("trace", `listfilename`, err.strerror))
-	    continue
-
-	# If desired, get a list of the line numbers which represent
-	# executable content (returned as a dict for better lookup speed)
-	if show_missing:
-	    executable_linenos = find_executable_linenos(filename)
-	else:
-	    executable_linenos = {}
-
-	lines_hit = per_file[key]
-	for i in range(len(lines)):
-	    line = lines[i]
-
-	    # do the blank/comment match to try to mark more lines
-	    # (help the reader find stuff that hasn't been covered)
-	    if lines_hit.has_key(i+1):
-		# count precedes the lines that we captured
-		outfile.write('%5d: ' % lines_hit[i+1])
-	    elif blank.match(line):
-		# blank lines and comments are preceded by dots
-		outfile.write('    . ')
-	    else:
-		# lines preceded by no marks weren't hit
-		# Highlight them if so indicated, unless the line contains
-		# '#pragma: NO COVER' (it is possible to embed this into
-		# the text as a non-comment; no easy fix)
-		if executable_linenos.has_key(i+1) and \
-		   string.find(lines[i],
+        try:
+            outfile = open(listfilename, 'w')
+        except IOError, err:
+            sys.stderr.write(
+                '%s: Could not open %s for writing because: %s" \
+                "- skipping\n' % ("trace", `listfilename`, err.strerror))
+            continue
+
+        # If desired, get a list of the line numbers which represent
+        # executable content (returned as a dict for better lookup speed)
+        if show_missing:
+            executable_linenos = find_executable_linenos(filename)
+        else:
+            executable_linenos = {}
+
+        lines_hit = per_file[key]
+        for i in range(len(lines)):
+            line = lines[i]
+
+            # do the blank/comment match to try to mark more lines
+            # (help the reader find stuff that hasn't been covered)
+            if lines_hit.has_key(i+1):
+                # count precedes the lines that we captured
+                outfile.write('%5d: ' % lines_hit[i+1])
+            elif blank.match(line):
+                # blank lines and comments are preceded by dots
+                outfile.write('    . ')
+            else:
+                # lines preceded by no marks weren't hit
+                # Highlight them if so indicated, unless the line contains
+                # '#pragma: NO COVER' (it is possible to embed this into
+                # the text as a non-comment; no easy fix)
+                if executable_linenos.has_key(i+1) and \
+                   string.find(lines[i],
                                string.join(['#pragma', 'NO COVER'])) == -1:
-		    outfile.write('>>>>>> ')
-		else:
-		    outfile.write(' '*7)
-	    outfile.write(string.expandtabs(lines[i], 8))
+                    outfile.write('>>>>>> ')
+                else:
+                    outfile.write(' '*7)
+            outfile.write(string.expandtabs(lines[i], 8))
 
-	outfile.close()
+        outfile.close()
 
         if save_counts:
             # try and store counts and module info into dirname
@@ -396,8 +395,8 @@ def create_results_log(results, dirname = ".", show_missing = 1,
                 marshal.dump(results.modules,
                              open(os.path.join(dirname, "modules"), "w"))
             except IOError, err:
-                sys.stderr.write("cannot save counts/modules files because %s" %
-                                 err.strerror)
+                sys.stderr.write("cannot save counts/modules " \
+                                 "files because %s" % err.strerror)
 
 # There is a lot of code shared between these two classes even though
 # it is straightforward to make a super class to share code.  However,
@@ -408,105 +407,105 @@ def create_results_log(results, dirname = ".", show_missing = 1,
 
 class Coverage:
     def __init__(self, ignore = Ignore()):
-	self.ignore = ignore
-	self.ignore_names = ignore._ignore # access ignore's cache (speed hack)
+        self.ignore = ignore
+        self.ignore_names = ignore._ignore # access ignore's cache (speed hack)
 
-	self.counts = {}   # keys are (filename, linenumber)
-	self.modules = {}  # maps filename -> module name
+        self.counts = {}   # keys are (filename, linenumber)
+        self.modules = {}  # maps filename -> module name
 
     def trace(self, frame, why, arg):
-	if why == 'line':
-	    # something is fishy about getting the file name
-	    filename = frame.f_globals.get("__file__", None)
-	    if filename is None:
-		filename = frame.f_code.co_filename
-	    modulename = frame.f_globals["__name__"]
+        if why == 'line':
+            # something is fishy about getting the file name
+            filename = frame.f_globals.get("__file__", None)
+            if filename is None:
+                filename = frame.f_code.co_filename
+            modulename = frame.f_globals["__name__"]
 
-	    # We do this next block to keep from having to make methods
-	    # calls, which also requires resetting the trace
-	    ignore_it = self.ignore_names.get(modulename, -1)
-	    if ignore_it == -1:  # unknown filename
-		sys.settrace(None)
-		ignore_it = self.ignore.names(filename, modulename)
-		sys.settrace(self.trace)
+            # We do this next block to keep from having to make methods
+            # calls, which also requires resetting the trace
+            ignore_it = self.ignore_names.get(modulename, -1)
+            if ignore_it == -1:  # unknown filename
+                sys.settrace(None)
+                ignore_it = self.ignore.names(filename, modulename)
+                sys.settrace(self.trace)
 
-		# record the module name for every file
-		self.modules[filename] = modulename
+                # record the module name for every file
+                self.modules[filename] = modulename
 
-	    if not ignore_it:
-		lineno = frame.f_lineno
+            if not ignore_it:
+                lineno = frame.f_lineno
 
-		# record the file name and line number of every trace
-		key = (filename, lineno)
-		self.counts[key] = self.counts.get(key, 0) + 1
+                # record the file name and line number of every trace
+                key = (filename, lineno)
+                self.counts[key] = self.counts.get(key, 0) + 1
 
-	return self.trace
+        return self.trace
 
     def results(self):
-	return CoverageResults(self.counts, self.modules)
+        return CoverageResults(self.counts, self.modules)
 
 class Trace:
     def __init__(self, ignore = Ignore()):
-	self.ignore = ignore
-	self.ignore_names = ignore._ignore # access ignore's cache (speed hack)
+        self.ignore = ignore
+        self.ignore_names = ignore._ignore # access ignore's cache (speed hack)
 
-	self.files = {'<string>': None}  # stores lines from the .py file, or None
+        self.files = {'<string>': None}  # stores lines from the .py file, or None
 
     def trace(self, frame, why, arg):
-	if why == 'line':
-	    filename = frame.f_code.co_filename
-	    modulename = frame.f_globals["__name__"]
-
-	    # We do this next block to keep from having to make methods
-	    # calls, which also requires resetting the trace
-	    ignore_it = self.ignore_names.get(modulename, -1)
-	    if ignore_it == -1:  # unknown filename
-		sys.settrace(None)
-		ignore_it = self.ignore.names(filename, modulename)
-		sys.settrace(self.trace)
-
-	    if not ignore_it:
-		lineno = frame.f_lineno
-		files = self.files
-
-		if filename != '<string>' and not files.has_key(filename):
+        if why == 'line':
+            filename = frame.f_code.co_filename
+            modulename = frame.f_globals["__name__"]
+
+            # We do this next block to keep from having to make methods
+            # calls, which also requires resetting the trace
+            ignore_it = self.ignore_names.get(modulename, -1)
+            if ignore_it == -1:  # unknown filename
+                sys.settrace(None)
+                ignore_it = self.ignore.names(filename, modulename)
+                sys.settrace(self.trace)
+
+            if not ignore_it:
+                lineno = frame.f_lineno
+                files = self.files
+
+                if filename != '<string>' and not files.has_key(filename):
                     files[filename] = map(string.rstrip,
                                           open(filename).readlines())
 
-		# If you want to see filenames (the original behaviour), try:
-		#   modulename = filename
-		# or, prettier but confusing when several files have the same name
-		#   modulename = os.path.basename(filename)
+                # If you want to see filenames (the original behaviour), try:
+                #   modulename = filename
+                # or, prettier but confusing when several files have the same name
+                #   modulename = os.path.basename(filename)
 
-		if files[filename] != None:
-		    print '%s(%d): %s' % (os.path.basename(filename), lineno,
-					  files[filename][lineno-1])
-		else:
-		    print '%s(%d): ??' % (modulename, lineno)
+                if files[filename] != None:
+                    print '%s(%d): %s' % (os.path.basename(filename), lineno,
+                                          files[filename][lineno-1])
+                else:
+                    print '%s(%d): ??' % (modulename, lineno)
 
-	return self.trace
+        return self.trace
     
 
 def _err_exit(msg):
-	sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
-	sys.exit(1)
+    sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
+    sys.exit(1)
 
 def main(argv = None):
     import getopt
 
     if argv is None:
-	argv = sys.argv
+        argv = sys.argv
     try:
-	opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m",
-					["help", "version", "trace", "count",
-					 "report", "no-report",
-					 "file=", "logdir=", "missing",
-					 "ignore-module=", "ignore-dir="])
+        opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:m",
+                                        ["help", "version", "trace", "count",
+                                         "report", "no-report",
+                                         "file=", "logdir=", "missing",
+                                         "ignore-module=", "ignore-dir="])
 
     except getopt.error, msg:
-	sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
-	sys.stderr.write("Try `%s --help' for more information\n" % sys.argv[0])
-	sys.exit(1)
+        sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
+        sys.stderr.write("Try `%s --help' for more information\n" % sys.argv[0])
+        sys.exit(1)
 
     trace = 0
     count = 0
@@ -519,143 +518,143 @@ def main(argv = None):
     ignore_dirs = []
 
     for opt, val in opts:
-	if opt == "--help":
-	    usage(sys.stdout)
-	    sys.exit(0)
-
-	if opt == "--version":
-	    sys.stdout.write("trace 2.0\n")
-	    sys.exit(0)
-	
-	if opt == "-t" or opt == "--trace":
-	    trace = 1
-	    continue
-	
-	if opt == "-c" or opt == "--count":
-	    count = 1
-	    continue
-
-	if opt == "-r" or opt == "--report":
-	    report = 1
-	    continue
-
-	if opt == "-R" or opt == "--no-report":
-	    no_report = 1
-	    continue
-	
-	if opt == "-f" or opt == "--file":
-	    counts_file = val
-	    continue
-
-	if opt == "-d" or opt == "--logdir":
-	    logdir = val
-	    continue
-
-	if opt == "-m" or opt == "--missing":
-	    missing = 1
-	    continue
-
-	if opt == "--ignore-module":
-	    ignore_modules.append(val)
-	    continue
-
-	if opt == "--ignore-dir":
-	    for s in string.split(val, os.pathsep):
-		s = os.path.expandvars(s)
-		# should I also call expanduser? (after all, could use $HOME)
-
-		s = string.replace(s, "$prefix",
-				   os.path.join(sys.prefix, "lib",
-						"python" + sys.version[:3]))
-		s = string.replace(s, "$exec_prefix",
-				   os.path.join(sys.exec_prefix, "lib",
-						"python" + sys.version[:3]))
-		s = os.path.normpath(s)
-		ignore_dirs.append(s)
-	    continue
-
-	assert 0, "Should never get here"
+        if opt == "--help":
+            usage(sys.stdout)
+            sys.exit(0)
+
+        if opt == "--version":
+            sys.stdout.write("trace 2.0\n")
+            sys.exit(0)
+
+        if opt == "-t" or opt == "--trace":
+            trace = 1
+            continue
+
+        if opt == "-c" or opt == "--count":
+            count = 1
+            continue
+
+        if opt == "-r" or opt == "--report":
+            report = 1
+            continue
+
+        if opt == "-R" or opt == "--no-report":
+            no_report = 1
+            continue
+
+        if opt == "-f" or opt == "--file":
+            counts_file = val
+            continue
+
+        if opt == "-d" or opt == "--logdir":
+            logdir = val
+            continue
+
+        if opt == "-m" or opt == "--missing":
+            missing = 1
+            continue
+
+        if opt == "--ignore-module":
+            ignore_modules.append(val)
+            continue
+
+        if opt == "--ignore-dir":
+            for s in string.split(val, os.pathsep):
+                s = os.path.expandvars(s)
+                # should I also call expanduser? (after all, could use $HOME)
+
+                s = string.replace(s, "$prefix",
+                                   os.path.join(sys.prefix, "lib",
+                                                "python" + sys.version[:3]))
+                s = string.replace(s, "$exec_prefix",
+                                   os.path.join(sys.exec_prefix, "lib",
+                                                "python" + sys.version[:3]))
+                s = os.path.normpath(s)
+                ignore_dirs.append(s)
+            continue
+
+        assert 0, "Should never get here"
 
     if len(prog_argv) == 0:
-	_err_exit("missing name of file to run")
+        _err_exit("missing name of file to run")
 
     if count + trace + report > 1:
-	_err_exit("can only specify one of --trace, --count or --report")
+        _err_exit("can only specify one of --trace, --count or --report")
 
     if count + trace + report == 0:
-	_err_exit("must specify one of --trace, --count or --report")
+        _err_exit("must specify one of --trace, --count or --report")
 
     if report and counts_file is None:
-	_err_exit("--report requires a --file")
+        _err_exit("--report requires a --file")
 
     if report and no_report:
-	_err_exit("cannot specify both --report and --no-report")
+        _err_exit("cannot specify both --report and --no-report")
 
     if logdir is not None:
-	# warn if the directory doesn't exist, but keep on going
-	# (is this the correct behaviour?)
-	if not os.path.isdir(logdir):
-	    sys.stderr.write(
-		"trace: WARNING, --logdir directory %s is not available\n" %
-		       `logdir`)
+        # warn if the directory doesn't exist, but keep on going
+        # (is this the correct behaviour?)
+        if not os.path.isdir(logdir):
+            sys.stderr.write(
+                "trace: WARNING, --logdir directory %s is not available\n" %
+                       `logdir`)
 
     sys.argv = prog_argv
     progname = prog_argv[0]
     if eval(sys.version[:3])>1.3:
-	sys.path[0] = os.path.split(progname)[0] # ???
+        sys.path[0] = os.path.split(progname)[0] # ???
 
     # everything is ready
     ignore = Ignore(ignore_modules, ignore_dirs)
     if trace:
-	t = Trace(ignore)
-	try:
-	    run(t.trace, 'execfile(' + `progname` + ')')
-	except IOError, err:
-	    _err_exit("Cannot run file %s because: %s" % \
-		      (`sys.argv[0]`, err.strerror))
+        t = Trace(ignore)
+        try:
+            run(t.trace, 'execfile(' + `progname` + ')')
+        except IOError, err:
+            _err_exit("Cannot run file %s because: %s" % \
+                      (`sys.argv[0]`, err.strerror))
 
     elif count:
-	t = Coverage(ignore)
-	try:
-	    run(t.trace, 'execfile(' + `progname` + ')')
-	except IOError, err:
-	    _err_exit("Cannot run file %s because: %s" % \
-		      (`sys.argv[0]`, err.strerror))
-	except SystemExit:
-	    pass
-
-	results = t.results()
-	# Add another lookup from the program's file name to its import name
-	# This give the right results, but I'm not sure why ...
-	results.modules[progname] = os.path.splitext(progname)[0]
-
-	if counts_file:
-	    # add in archived data, if available
-	    try:
-		old_counts, old_modules = marshal.load(open(counts_file, 'rb'))
-	    except IOError:
-		pass
-	    else:
-		results.update(CoverageResults(old_counts, old_modules))
-
-	if not no_report:
-	    create_results_log(results, logdir, missing)
-
-	if counts_file:
-	    try:
-		marshal.dump( (results.counts, results.modules),
-			      open(counts_file, 'wb'))
-	    except IOError, err:
-		_err_exit("Cannot save counts file %s because: %s" % \
-			  (`counts_file`, err.strerror))
+        t = Coverage(ignore)
+        try:
+            run(t.trace, 'execfile(' + `progname` + ')')
+        except IOError, err:
+            _err_exit("Cannot run file %s because: %s" % \
+                      (`sys.argv[0]`, err.strerror))
+        except SystemExit:
+            pass
+
+        results = t.results()
+        # Add another lookup from the program's file name to its import name
+        # This give the right results, but I'm not sure why ...
+        results.modules[progname] = os.path.splitext(progname)[0]
+
+        if counts_file:
+            # add in archived data, if available
+            try:
+                old_counts, old_modules = marshal.load(open(counts_file, 'rb'))
+            except IOError:
+                pass
+            else:
+                results.update(CoverageResults(old_counts, old_modules))
+
+        if not no_report:
+            create_results_log(results, logdir, missing)
+
+        if counts_file:
+            try:
+                marshal.dump( (results.counts, results.modules),
+                              open(counts_file, 'wb'))
+            except IOError, err:
+                _err_exit("Cannot save counts file %s because: %s" % \
+                          (`counts_file`, err.strerror))
 
     elif report:
-	old_counts, old_modules = marshal.load(open(counts_file, 'rb'))
-	results = CoverageResults(old_counts, old_modules)
-	create_results_log(results, logdir, missing)
+        old_counts, old_modules = marshal.load(open(counts_file, 'rb'))
+        results = CoverageResults(old_counts, old_modules)
+        create_results_log(results, logdir, missing)
 
     else:
-	assert 0, "Should never get here"
+        assert 0, "Should never get here"
 
 if __name__=='__main__':
     main()