X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=buildscripts%2Fcoverage.py;h=d44f81fdeeb8a7b0ba7328cf6e35c1b059506b7b;hb=7f65b882cf00bdc468eef1f2517161b56e3a3851;hp=4012b6b92ea0c8120a3f484d2ff0de5d69e781db;hpb=395244658ace2362d1acff5ca1f23d2eadeb2cb4;p=lilypond.git

diff --git a/buildscripts/coverage.py b/buildscripts/coverage.py
index 4012b6b92e..d44f81fdee 100644
--- a/buildscripts/coverage.py
+++ b/buildscripts/coverage.py
@@ -1,4 +1,5 @@
-#!/bin/sh
+#!/usr/bin/python
+
 import os
 import glob
 import re
@@ -38,7 +39,11 @@ def summary (args):
         print '%(cov)5.2f (%(lines)6d): %(file)s' % d
 
 class Chunk:
-    def __init__ (self, range, all_lines, file):
+    def __init__ (self, range, coverage_count, all_lines, file):
+        assert coverage_count >= 0
+        assert type (range) == type (())
+        
+        self.coverage_count = coverage_count
         self.range = range
         self.all_lines = all_lines
         self.file = file
@@ -56,15 +61,39 @@ class Chunk:
         self.range = (min (self.range[0] -1, 0),
                       self.range[0] +1)
     def write (self):
-        print 'uncovered chunk in', self.file
+        print 'chunk in', self.file
         for (c, n, l) in self.lines ():
-            sys.stdout.write ('%8s:%8d:%s' % (c,n,l))
+            cov = '%d' % c
+            if c == 0:
+                cov = '#######'
+            elif c < 0:
+                cov = ''
+            sys.stdout.write ('%8s:%8d:%s' % (cov, n, l))
             
+    def uncovered_score (self):
+        return self.length ()
+    
+class SchemeChunk (Chunk):
+    def uncovered_score (self):
+        text = self.text ()
+        if (text.startswith  ('(define ')
+            and not text.startswith ('(define (')):
+            return 0
+
+        if text.startswith  ('(use-modules '):
+            return 0
+
+        if (text.startswith  ('(define-public ')
+            and not text.startswith ('(define-public (')):
+            return 0
+
+        return len ([l for (c,n,l) in self.lines() if (c == 0)]) 
+
 def read_gcov (f):
     ls = []
 
     in_lines = [l for l in open (f).readlines ()]
-    (count_len, line_num_len) = tuple (map (len, in_lines[0].split( ':')[:2]))
+    (count_len, line_num_len) = tuple (map (len, in_lines[0].split (':')[:2]))
     
     for l in in_lines:
         c = l[:count_len].strip ()
@@ -73,6 +102,13 @@ def read_gcov (f):
 
         if n == 0:
             continue
+
+        if '#' in c:
+            c = 0
+        elif c == '-':
+            c = -1
+        else:
+            c = int (c)
         
         l = l[line_num_len+1:]
 
@@ -80,21 +116,47 @@ def read_gcov (f):
         
     return ls
 
-def get_chunks (ls, file):
+def get_c_chunks (ls, file):
     chunks = []
     chunk = []
-    for (c,n,l) in ls:
-        if '#' in c:
-            chunk.append ((n,l))
-        elif c.strip () != '-' or l == '}\n':
-            if chunk:
+
+    last_c = -1
+    for (c, n, l) in ls:
+        if not (c == last_c or c < 0 and l != '}\n'):
+            if chunk and last_c >= 0:
                 nums = [n-1 for (n, l) in chunk]
                 chunks.append (Chunk ((min (nums), max (nums)+1),
-                                      ls, file))
+                                      last_c, ls, file))
                 chunk = []
+
+        chunk.append ((n,l))
+        if c >= 0:
+            last_c = c
             
     return chunks
 
+def get_scm_chunks (ls, file):
+    chunks = []
+    chunk = []
+
+    def new_chunk ():
+        if chunk:
+            nums = [n-1 for (n, l) in chunk]
+            chunks.append (SchemeChunk ((min (nums), max (nums)+1),
+                                        max (last_c, 0), ls, file))
+            chunk[:] = []
+        
+    last_c = -1
+    for (cov_count, line_number, line) in ls:
+        if line.startswith ('('):
+            new_chunk ()
+            last_c = -1
+        
+        chunk.append ((line_number, line))
+        if cov_count >= 0:
+            last_c = cov_count
+
+    return chunks
 
 def widen_chunk (ch, ls):
     a -= 1
@@ -103,22 +165,33 @@ def widen_chunk (ch, ls):
     return [(n, l)  for (c, n, l) in ls[a:b]]
     
 
-def extract_uncovered (file):
+def extract_chunks (file):
     try:
         ls = read_gcov (file)
     except IOError, s :
         print s
         return []
         
-    cs = get_chunks (ls, file)
+    cs = []
+    if 'scm' in file:
+        cs = get_scm_chunks (ls, file)
+    else:
+        cs = get_c_chunks (ls, file)
+    return cs
+
+
+def filter_uncovered (chunks):
     def interesting (c):
+        if c.coverage_count > 0:
+            return False
+        
         t = c.text()
         for stat in  ('warning', 'error', 'print', 'scm_gc_mark'):
             if stat in t:
                 return False
         return True
    
-    return [c for c in cs if interesting (c)]
+    return [c for c in chunks if interesting (c)]
     
 
 def main ():
@@ -129,6 +202,11 @@ def main ():
                   default=False,
                   dest="summary")
     
+    p.add_option ("--hotspots",
+                  default=False,
+                  action='store_true',
+                  dest="hotspots")
+    
     p.add_option ("--uncovered",
                   default=False,
                   action='store_true',
@@ -141,15 +219,27 @@ def main ():
     if options.summary:
         summary (['%s.gcov-summary' % s for s in args])
 
-    if options.uncovered:
-        uncovered = []
+    if options.uncovered or options.hotspots:
+        chunks = []
         for a in args:
-            uncovered += extract_uncovered ('%s.gcov' % a)
+            name = a
+            if name.endswith ('scm'):
+                name += '.cov'
+            else:
+                name += '.gcov'
+            
+            chunks += extract_chunks  (name)
+
+        if options.uncovered:
+            chunks = filter_uncovered (chunks)
+            chunks = [(c.uncovered_score (), c) for c in chunks if c.uncovered_score() > 0]
+        elif options.hotspots:
+            chunks = [((c.coverage_count, -c.length()), c) for c in chunks]
+            
             
-        uncovered = [(c.length (), c) for c in uncovered]
-        uncovered.sort ()
-        uncovered.reverse ()
-        for (score, c) in uncovered:
+        chunks.sort ()
+        chunks.reverse ()
+        for (score, c) in chunks:
             c.write ()