def get_c_coverage():
 cov = {}
 dir_file={}
 dirs=c_code_dirs.split(",")
 gcov_cmd=os.environ.get("COV", "gcov")
 for d in dirs:
  files=os.listdir(d)
  for f in files:
   if f.split(".")[-1]=="gcda":
    os.system("%s %s -o %s" % (gcov_cmd, f.split(".")[0], d))
    cov[d+"/"+".".join(f.split(".")[0:-1])+".c"]=d
    try:
     source=open(".".join(f.split(".")[0:-1])+".c.gcov", "r")
    except IOError:
     print "Can't open file: ", ".".join(f.split(".")[0:-1])+".c.gcov"
     continue
    exe_lines=[]
    for line in source:
     line=line.rstrip("\n")
     if line.count(":") < 2:
      continue
     (count, lineno, code)=line.split(":", 2)
     if count.strip()=="-" or count.strip()=="#####":
      continue
     else:
      exe_lines.append(int(lineno))
    cov[d+"/"+".".join(f.split(".")[0:-1])+".c"]=set(exe_lines)   
 return cov

def write_coverage(filename, append=True):
    """
    Write the current coverage info out to the given filename.  If
    'append' is false, destroy any previously recorded coverage info.
    """
    if _t is None:
        return

    data = internals.CoverageData(_t)

    d = data.gather_files()

    # sum existing coverage?
    if append:
        old = {}
        fp = None
        try:
            fp = open(filename, 'rb')
        except IOError:
            pass

        if fp:
            old = load(fp)
            fp.close()
            d = combine_coverage(d, old)

    # ok, save.
    if c_code_dirs:
     c_coverage=get_c_coverage()
     if c_coverage:
      d=combine_coverage(c_coverage, d)
    outfp = open(filename, 'wb')
    try:
        dump(d, outfp)
    finally:
        outfp.close()

def build_python_coverage_info(coverage, exclude_patterns, files_list):
    keys = coverage.keys()
    
    line_info = {}
    lines=set([])
    for pyfile in filter_files(keys, exclude_patterns, files_list):
        try:
            fp = open(pyfile, 'rU')
            if pyfile.split(".")[-1]=="py":
                lines = figleaf.get_lines(fp)
            else:
         lines = figleaf.get_c_lines(pyfile)  
        except KeyboardInterrupt:
            raise
        except IOError:
            logger.error('CANNOT OPEN: %s' % (pyfile,))
            continue
        except Exception, e:
            logger.error('ERROR: file %s, exception %s' % (pyfile, str(e)))
            continue

        # retrieve the coverage and merge into a realpath-based filename.
        covered = coverage.get(pyfile, set())
        realpath = os.path.realpath(pyfile)

        # be careful not to overwrite existing coverage for different
        # filenames that may have been canonicalized.
        (old_l, old_c) = line_info.get(realpath, (set(), set()))
        lines.update(old_l)
        covered.update(old_c)

        line_info[realpath] = (lines, covered)

    return line_info

def get_c_lines(fp):
 """
 Return the set of interesting lines in the C source code read
 from this file.
 """
 lines=[]
 fp=os.path.basename(fp)
 try:
  fp=open("./"+fp+".gcov", 'r')
 except IOError:
  print "Can't open: ", "./"+fp+".gcov"
  
 for line in fp:
  line=line.rstrip("\n")
  if line.count(":") < 2:
   continue
  (count, lineno, code)=line.split(":", 2)
  if count.strip()=="-":
   continue
  else:
   lines.append(int(lineno))
 return set(lines)