diff options
| -rwxr-xr-x | Tools/scripts/eptags.py | 29 | ||||
| -rwxr-xr-x | Tools/scripts/parseentities.py | 42 | ||||
| -rw-r--r-- | Tools/scripts/trace.py | 645 |
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() |