blob: 97c91a8209156bee1b33507a162c7f864cf3aa25 [file] [log] [blame]
#!/usr/bin/python
import subprocess
def splitArgs(s):
it = iter(s)
current = ''
inQuote = False
for c in it:
if c == '"':
if inQuote:
inQuote = False
yield current + '"'
else:
inQuote = True
current = '"'
elif inQuote:
if c == '\\':
current += c
current += it.next()
else:
current += c
elif not c.isspace():
yield c
def insertMinimumPadding(a, b, dist):
"""insertMinimumPadding(a,b) -> (a',b')
Return two lists of equal length, where some number of Nones have
been inserted into the shorter list such that sum(map(dist, a',
b')) is minimized.
Assumes dist(X, Y) -> int and non-negative.
"""
# Yay for simplicity over complexity.
def extend(aElt, bElt, solution):
d0,(a0,b0) = solution
return d0 + dist(aElt,bElt), (([aElt]+a0),([bElt]+b0))
def f(a, b):
if len(a) == len(b):
return (sum(map(dist, a, b)), (a, b))
if not a or not b:
if not a:
a += [None] * len(b)
else:
b += [None] * len(a)
return (sum(map(dist, a, b)), (a, b))
if int(dist(a[0], b[0])) == 0:
# Non-negative condition implies maximum is satisfied
# taking this.
return extend(a[0], b[0], f(a[1:], b[1:]))
if len(a) < len(b):
return min(f([None] + a, b),
extend(a[0], b[0], f(a[1:], b[1:])))
else:
return min(f(a, [None] + b),
extend(a[0], b[0], f(a[1:], b[1:])))
return f(a, b)[1]
class ZipperDiff(object):
"""ZipperDiff - Simple (slow) diff only accomodating inserts."""
def __init__(self, a, b):
self.a = a
self.b = b
def dist(self, a, b):
return a != b
def getDiffs(self):
a,b = insertMinimumPadding(self.a, self.b, self.dist)
for aElt,bElt in zip(a,b):
if self.dist(aElt, bElt):
yield aElt,bElt
class DriverZipperDiff(ZipperDiff):
def isTempFile(self, filename):
if filename[0] != '"' or filename[-1] != '"':
return False
return (filename.startswith('/tmp/', 1) or
filename.startswith('/var/', 1))
def dist(self, a, b):
if a and b and self.isTempFile(a) and self.isTempFile(b):
return 0
return super(DriverZipperDiff, self).dist(a,b)
class CompileInfo:
def __init__(self, out, err, res):
self.commands = []
# Standard out isn't used for much.
self.stdout = out
self.stderr = ''
# FIXME: Compare error messages as well.
for ln in err.split('\n'):
if (ln == 'Using built-in specs.' or
ln.startswith('Target: ') or
ln.startswith('Configured with: ') or
ln.startswith('Thread model: ') or
ln.startswith('gcc version') or
ln.startswith('ccc version')):
pass
elif ln.strip().startswith('"'):
self.commands.append(list(splitArgs(ln)))
else:
self.stderr += ln + '\n'
self.stderr = self.stderr.strip()
self.exitCode = res
def captureDriverInfo(cmd, args):
p = subprocess.Popen([cmd,'-###'] + args,
stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out,err = p.communicate()
res = p.wait()
return CompileInfo(out,err,res)
def main():
import os, sys
args = sys.argv[1:]
driverA = os.getenv('DRIVER_A') or 'gcc'
driverB = os.getenv('DRIVER_B') or 'xcc'
infoA = captureDriverInfo(driverA, args)
infoB = captureDriverInfo(driverB, args)
differ = False
# Compare stdout.
if infoA.stdout != infoB.stdout:
print '-- STDOUT DIFFERS -'
print 'A: ',infoA.stdout
print 'B: ',infoB.stdout
differ = True
# Compare stderr.
if infoA.stderr != infoB.stderr:
print '-- STDERR DIFFERS -'
print 'A: ',infoA.stderr
print 'B: ',infoB.stderr
differ = True
# Compare commands.
for i,(a,b) in enumerate(map(None, infoA.commands, infoB.commands)):
if a is None:
print 'A MISSING:',' '.join(b)
differ = True
continue
elif b is None:
print 'B MISSING:',' '.join(a)
differ = True
continue
diff = DriverZipperDiff(a,b)
diffs = list(diff.getDiffs())
if diffs:
print '-- COMMAND %d DIFFERS -' % i
print 'A COMMAND:',' '.join(a)
print 'B COMMAND:',' '.join(b)
print
for i,(aElt,bElt) in enumerate(diffs):
if aElt is None:
print 'A missing: %s' % bElt
elif bElt is None:
print 'B missing: %s' % aElt
else:
print 'mismatch: A: %s' % aElt
print ' B: %s' % bElt
differ = True
# Compare result codes.
if infoA.exitCode != infoB.exitCode:
print '-- EXIT CODES DIFFER -'
print 'A: ',infoA.exitCode
print 'B: ',infoB.exitCode
differ = True
if differ:
sys.exit(1)
if __name__ == '__main__':
main()