def filter_sort_meth_basic( x ) :
z = sorted(x.iteritems(), key=lambda (k,v): (v,k))
if get_debug() :
for i in z :
debug("\t %s %s %s %d %f" %(i[0].m.get_class_name(), i[0].m.get_name(), i[0].m.get_descriptor(), i[0].m.get_length(), i[1]))
return z[:1]
def getResourceWrapper(task, dataObj):
error.debug("Task: %s is checking out resource: %s" %
(task.name, task.forkObj.remoteType))
resource = getResource(dataObj.shared.getVar('TAG'),
dataObj.shared.getVar('ID'),
task.forkObj.remoteType,
"Checked out by %s" % (task.name))
dataObj.local.putVar("resource", resource)
return resource
def diff_ins(self, di) :
self.di = di
off_add = {}
off_rm = {}
for i in self.di.add_ins :
off_add[ i[0] ] = i
for i in self.di.remove_ins :
off_rm[ i[0] ] = i
nb = 0
for i in self.bb1.ins :
ok = False
if nb in off_add :
debug("%d ADD %s %s" % (nb, off_add[ nb ][2].get_name(), off_add[ nb ][2].get_operands()))
self.ins.append( off_add[ nb ][2] )
setattr( off_add[ nb ][2], "diff_tag", DIFF_INS_TAG["ADD"] )
del off_add[ nb ]
if nb in off_rm :
debug("%d RM %s %s" % (nb, off_rm[ nb ][2].get_name(), off_rm[ nb ][2].get_operands()))
self.ins.append( off_rm[ nb ][2] )
setattr( off_rm[ nb ][2], "diff_tag", DIFF_INS_TAG["REMOVE"] )
del off_rm[ nb ]
ok = True
if ok == False :
self.ins.append( i )
debug("%d %s %s" % (nb, i.get_name(), i.get_operands()))
setattr( i, "diff_tag", DIFF_INS_TAG["ORIG"] )
nb += 1
#print nb, off_add, off_rm
nbmax = nb
if off_add != {} :
nbmax = sorted(off_add)[-1]
if off_rm != {} :
nbmax = max(nbmax, sorted(off_rm)[-1])
while nb <= nbmax :
if nb in off_add :
debug("%d ADD %s %s" % (nb, off_add[ nb ][2].get_name(), off_add[ nb ][2].get_operands()))
self.ins.append( off_add[ nb ][2] )
setattr( off_add[ nb ][2], "diff_tag", DIFF_INS_TAG["ADD"] )
del off_add[ nb ]
if nb in off_rm :
debug("%d RM %s %s" % (nb, off_rm[ nb ][2].get_name(), off_rm[ nb ][2].get_operands()))
self.ins.append( off_rm[ nb ][2] )
setattr( off_rm[ nb ][2], "diff_tag", DIFF_INS_TAG["REMOVE"] )
del off_rm[ nb ]
nb += 1
def set_childs(self, abb) :
childs = []
for c in self.bb.childs :
if c[2].name in abb :
debug("SET %s %s " % (c[2], abb[ c[2].name ]))
childs.append( (c[0], c[1], abb[ c[2].name ]) )
else :
debug("SET ORIG %s" % str(c))
childs.append( c )
setattr( self, "childs", childs )
def _init_sort_methods(self) :
# print "DEBUG DIFF METHODS"
for fil in self.filters :
delete_methods = []
for j in self.filters[fil][DIFFMETHODS] :
debug("%s %s %s %d" % (j.m.get_class_name(), j.m.get_name(), j.m.get_descriptor(), j.m.get_length()))
ret = j.sort( self.filters[fil][BASE][FILTER_NAME], self.filters[fil][BASE][FILTER_SORT_METH] )
if ret == False :
delete_methods.append( j )
for j in delete_methods :
self.filters[ fil ][ DELETEMETHODS ].append( j )
pos = self.filters[ fil ][ DIFFMETHODS ].index( j )
self.filters[ fil ][ DIFFMETHODS ].remove( j )
def main():
# Parse the command line options
parser = optparse.OptionParser()
parser.add_option("--debug",
action="store_true",
dest="debug",
default=False,
help="start game in debugging mode")
parser.add_option("--show-fps",
action="store_true",
dest="show_fps",
default=False,
help="start game in debugging mode")
(opts, args) = parser.parse_args()
options.DEBUG = opts.debug
options.SHOW_FRAMERATE = opts.show_fps
# Setup a custom data directory
pyglet.resource.path = ["data"]
pyglet.resource.reindex()
error.debug("Importing scene")
import scene # Imported here, because it depends on the options used
error.debug("Success!")
error.debug("Importing menu")
import menu
error.debug("Success!")
# Add two windows
game_manager.add_window(MainWindow(width=options.window_width, height=options.window_height,
caption=options.__appname__, resizable=True),
"game_draw")
if options.DEBUG: game_manager.add_window(BasicWindow(caption="Debug"), "debug_draw")
# Add one scene
game_manager.push(menu.MainMenu())
# Start sound recordning here. Something is wrong with wonderful,
# leading to strange segfaults. I'm gonna see if this fixes it.
import wonderful
wonderful.init(options.SAMPLE_RATE, options.DFT_SIZE)
# Hand control over to the Game manager
error.debug("Hiya, I'm gonna hand control over to the game manager")
game_manager.run()
wonderful.terminate()
def set_childs(self, abb) :
setattr( self.bb1.ins[-1], "childs", self.bb1.childs )
for i in self.ins :
if i == self.bb2.ins[-1] :
childs = []
for c in self.bb2.childs :
if c[2].name in abb :
debug("SET %s %s" % (c[2], abb[ c[2].name ]))
childs.append( (c[0], c[1], abb[ c[2].name ]) )
else :
debug("SET ORIG %s" % str(c))
childs.append( c )
setattr( i, "childs", childs )
def _init_mark_methods(self) :
# Change the compression to have a better result for a one <-> one comparison
self.sim.set_compress_type( XZ_COMPRESS )
for fil in self.filters :
# mark diff methods
for j in self.filters[fil][DIFFMETHODS] :
debug("%s %s %s" % (j.m.get_class_name(), j.m.get_name(), j.m.get_descriptor()))
# get the first method which match
k = j.get_meth_first_sort( self.filters[fil][BASE][FILTER_NAME] )
# recalculate the similarity to have better percentage with a better algorithm
v1 = j.quick_similarity( self.filters[fil][BASE][FILTER_NAME], k, self.filters[fil][BASE][FILTER_SIM_METH] )
# filter the mark to eliminate totaly diff method
v2 = self.filters[fil][BASE][FILTER_MARK_METH]( v1 )
self.marks[fil].append( v2 )
# mark match methods
for m in self.filters[ fil ][ MATCHMETHODS ] :
v = self.filters[fil][BASE][FILTER_MARK_METH]( 0.0 )
self.marks[fil].append( v )
def _init_similarity(self) :
# Check if some methods in the first file has been modified
for fil in self.filters :
for j in self.filters[fil][METHODS][self.vm1[0]] :
debug("SIM FOR %s %s %s" % (j.m.get_class_name(), j.m.get_name(), j.m.get_descriptor()))
for i1 in self.filters[fil][METHODS] :
if i1 != self.vm1[0] :
# B1 not at 0.0 in BB2
if j.getsha256( self.filters[fil][BASE][FILTER_NAME] ) not in self.filters[fil][HASHSUM][i1] :
for k in self.filters[fil][METHODS][i1] :
# B2 not at 0.0 in BB1
if k.getsha256( self.filters[fil][BASE][FILTER_NAME] ) not in self.filters[fil][HASHSUM][self.vm1[0]] :
j.similarity( self.filters[fil][BASE][FILTER_NAME], k, self.filters[fil][BASE][FILTER_SIM_METH] )
if j not in self.filters[fil][DIFFMETHODS] :
self.filters[fil][DIFFMETHODS].append(j)
# B2 matched perfectly
else :
if k not in self.filters[fil][MATCHMETHODS] :
self.filters[fil][MATCHMETHODS].append( k )
# B1 matched perfectly
else :
if j not in self.filters[fil][MATCHMETHODS] :
self.filters[fil][MATCHMETHODS].append( j )
def getDiff(C, X, Y, i, j, a, r):
if i > 0 and j > 0 and X[i-1] == Y[j-1]:
getDiff(C, X, Y, i-1, j-1, a, r)
debug(" " + "%02X" % ord(X[i-1]))
else:
if j > 0 and (i == 0 or C[i][j-1] >= C[i-1][j]):
getDiff(C, X, Y, i, j-1, a, r)
a.append( (j-1, Y[j-1]) )
debug(" + " + "%02X" % ord(Y[j-1]))
elif i > 0 and (j == 0 or C[i][j-1] < C[i-1][j]):
getDiff(C, X, Y, i-1, j, a, r)
r.append( (i-1, X[i-1]) )
debug(" - " + "%02X" % ord(X[i-1]))
def diff(self, name_attribute, func_sim_bb, func_diff_ins):
z = getattr( self, "sort_" + name_attribute )
if z == [] :
setattr(self, "dbb_" + name_attribute, {})
setattr(self, "nbb_" + name_attribute, {})
return
bb1 = getattr( self, "bb_" + name_attribute )
### Dict for diff basic blocks
### vm1 basic block : vm2 basic blocks -> value (0.0 to 1.0)
diff_bb = {}
### List to get directly all diff basic blocks
direct_diff_bb = []
### Dict for new basic blocks
new_bb = {}
### Reverse Dict with matches diff basic blocks
associated_bb = {}
for b1 in bb1 :
diff_bb[ bb1[ b1 ] ] = {}
debug("%s 0x%x" % (b1, bb1[ b1 ].basic_block.end))
for i in z :
bb2 = getattr( i[0], "bb_" + name_attribute )
b_z = diff_bb[ bb1[ b1 ] ]
bb2hash = getattr( i[0], "bb_sha256_" + name_attribute )
# If b1 is in bb2 :
# we can have one or more identical basic blocks to b1, we must add them
if bb1[ b1 ].get_hash() in bb2hash :
for equal_bb in bb2hash[ bb1[ b1 ].get_hash() ] :
b_z[ equal_bb.basic_block.name ] = 0.0
# If b1 is not in bb2 :
# we must check similarities between all bb2
else :
for b2 in bb2 :
b_z[ b2 ] = func_sim_bb( bb1[ b1 ], bb2[ b2 ], self.sim )
sorted_bb = sorted(b_z.iteritems(), key=lambda (k,v): (v,k))
debug("\t\t%s" % sorted_bb[:2])
for new_diff in sorted_bb :
associated_bb[ new_diff[0] ] = bb1[ b1 ].basic_block
if new_diff[1] == 0.0 :
direct_diff_bb.append( new_diff[0] )
if sorted_bb[0][1] != 0.0 :
diff_bb[ bb1[ b1 ] ] = (bb2[ sorted_bb[0][0] ], sorted_bb[0][1])
direct_diff_bb.append( sorted_bb[0][0] )
else :
del diff_bb[ bb1[ b1 ] ]
for i in z :
bb2 = getattr( i[0], "bb_" + name_attribute )
for b2 in bb2 :
if b2 not in direct_diff_bb :
new_bb[ b2 ] = bb2[ b2 ]
dbb = {}
nbb = {}
# Add all different basic blocks
for d in diff_bb :
dbb[ d.basic_block.name ] = DiffBB( d.basic_block, diff_bb[ d ][0].basic_block, diff_bb[ d ] )
# Add all new basic blocks
for n in new_bb :
nbb[ new_bb[ n ].basic_block ] = NewBB( new_bb[ n ].basic_block )
del associated_bb[ n ]
setattr(self, "dbb_" + name_attribute, dbb)
setattr(self, "nbb_" + name_attribute, nbb)
# Found diff instructions
for d in dbb :
func_diff_ins( dbb[d], self.sim, name_attribute )
# Set new childs for diff basic blocks
# The instructions will be tag with a new flag "childs"
for d in dbb :
dbb[ d ].set_childs( associated_bb )
# Set new childs for new basic blocks
for d in nbb :
nbb[ d ].set_childs( associated_bb )
# Create and tag all (orig/diff/new) basic blocks
self.create_bbs( name_attribute )
def filter_diff_ins_basic( dbb, sim, name_attribute ) :
final_add = []
final_rm = []
hS = {}
rS = {}
X = toString( dbb.bb1, hS, rS )
Y = toString( dbb.bb2, hS, rS )
debug("%s %d" % (repr(X), len(X)))
debug("%s %d" % (repr(Y), len(Y)))
m = len(X)
n = len(Y)
C = LCS( X, Y )
a = []
r = []
getDiff(C, X, Y, m, n, a, r)
debug(a)
debug(r)
debug("DEBUG ADD")
for i in a :
debug(" \t %s %s %s" % (i[0], dbb.bb2.ins[ i[0] ].get_name(), dbb.bb2.ins[ i[0] ].get_operands()))
final_add.append( (i[0], 0, dbb.bb2.ins[ i[0] ]) )
debug("DEBUG REMOVE")
for i in r :
debug(" \t %s %s %s" % (i[0], dbb.bb1.ins[ i[0] ].get_name(), dbb.bb1.ins[ i[0] ].get_operands()))
final_rm.append( (i[0], 0, dbb.bb1.ins[ i[0] ]) )
dbb.diff_ins( DiffINS( final_add, final_rm ) )
def releaseResourceWrapper(task, dataObj, resource):
error.debug("Task: %s is releasing resource: %s" % (task.name, resource))
releaseResource(resource)
return
def cleanupResources():
error.debug("Cleaning resource manager")
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import error
######################
# Standard library #
######################
import sys, os
import optparse
######################
# Required libraries #
######################
error.debug("Attempting to import pyglet")
try:
import pyglet
except ImportError, err:
# put an error on the log
error.critical("This game requires pyglet. If you are using Windows, seeing this message is a BUG. Please file a bug report on http://guitarlegend.googlecode.com. Linux and OS X users should download Pyglet from http://www.pyglet.org.")
error.bail_out(err)
error.debug("Success!")
######################
# Game modules #
######################
error.debug("Importing options")
import options
error.debug("Success!")
error.debug("Importing manager stuffs")
from manager import game_manager, BasicWindow, MainWindow
