def main():
if len(argv) == 1:
usage()
if argv[1] == 'get':
if len(argv) == 2:
get()
elif argv[2] in ['ubuntu', 'fedora', 'debian', 'arch']:
get(argv[2])
else:
usage()
elif argv[1] == 'add':
try:
libc_file = argv[2]
add_local_libc(libc_file)
except:
usage()
elif argv[1] == 'find':
try:
fun_name = argv[2]
fun_addr = argv[3]
find(fun_name, fun_addr)
except:
usage()
elif argv[1] == 'identify':
try:
libc_file = argv[2]
identify(libc_file)
except:
usage()
elif argv[1] == 'status':
status()
else:
usage()
def compute_subitized_complex(subrange, mmap, nterm):
twos = len(find(mmap, 1))
threes = len(find(mmap, 2))
if twos == 1 and threes == 1:
comp = nterm * 4 - 3
elif twos == 1 and threes > 1:
comp = nterm * 4 - 2
elif twos > 1:
comp = nterm * 4 - 1
else:
comp = nterm * 4
return comp
def eval(self, context: Context, pos, code):
if not context.flags[GotoLine.flag]:
new_pos = find(self.matching_line.re, code, pos, reverse=True)
repeat_pos = new_pos - 1
repeat_line = self.matching_line(get_line(code, repeat_pos))
args = repeat_line.args
index_var = repeat_line.index_var
self.end.init(context, ForLine.end_name, repeat_pos,
exp_eval(args[1], context))
if len(args) == 4:
self.step.init(context, ForLine.step_name, repeat_pos,
exp_eval(args[2], context))
else:
self.step.init(context, ForLine.step_name, repeat_pos, 1)
current = context.get_var(index_var)
next_index = self.update_index(current, self.end.get(context),
self.step.get(context))
if next_index:
context.set_var(
self.matching_line(get_line(code, new_pos - 1)).index_var,
next_index)
else:
return pos + 1
return new_pos
else:
return pos + 1
def parsePrep(word, var, prop, string):
rel = word.doc
varToBeShown = []
statement = ""
replaceDictionary = {}
isProp = None
propVar = None
if word.lemma_ == "of":
for dep in findDependencies(word):
if dep.dep_ == "pobj":
if word.lemma_ == "as":
return {'property': dep}
else:
var2 = gn.generateName()
var3 = gn.generateName()
res = parseNoun(dep, var3, prop)
varToBeShown += res["varToBeShown"]
statement += res["statement"]
replaceDictionary = concatDict(replaceDictionary,
res["replaceDictionary"])
isProp = True
propVar = var3
elif dep.dep_ == "":
pass
else:
raise ValueError
else:
replacements = find(string, True)
if replacements == []:
return parsePrepVerb(word, var)
pobj = findDep(word, "pobj")
var2 = gn.generateName()
var3 = gn.generateName()
res = parseNoun(pobj, var3, prop)
varToBeShown += res["varToBeShown"]
statement += res["statement"]
replaceDictionary = concatDict(replaceDictionary,
res["replaceDictionary"])
isProp = True
propVar = var3
#else:
# raise ValueError
return {
"varToBeShown": varToBeShown,
"statement": statement,
"replaceDictionary": replaceDictionary,
"isProp": isProp,
"propVar": propVar
}
def latesttracks(directory, days):
"""
Finds the latest additions to 'directory' (within the last 'days')
and returns an XSPF playlist.
"""
tags = TagReader()
then = time.time() - (days * 24 * 3600)
date = time.strftime("%D", time.localtime(then))
now = time.strftime("%D")
creator = "LatestXSPF"
title = "New tracks from {date} till {now}".format(date=date, now=now)
find(days=days, dir=directory, exts=[".mp3", ".flac", ".ogg"], hook=tags.read)
print >> sys.stderr, len(tags), 'music files found'
xspf = xspfgenerator.SimpleXSPFGenerator(title, creator)
xspf.addTracks(tags.tags())
return xspf
def eval(self, context: Context, pos, code):
if exp_eval(self.arg, context):
pos += 1
else: # normally else or elseif will just jump to endif. this code prevents this by jumping past it.
jmp_targets = (ElseIfLine, )
re = r'(' + '|'.join(map(lambda x: x.re, jmp_targets)) + r')'
while True:
try:
pos = find(re, code, pos)
if get_line_instance(get_line(code, pos -
1)).get_condition(context):
return pos
else:
continue
except FindError:
break
pos = find(EndifLine.re, code, pos)
return pos
def latesttracks(directory, days):
"""
Finds the latest additions to 'directory' (within the last 'days')
and returns an XSPF playlist.
"""
tags = TagReader()
then = time.time() - (days * 24 * 3600)
date = time.strftime("%D", time.localtime(then))
now = time.strftime("%D")
creator = "LatestXSPF"
title = "New tracks from {date} till {now}".format(date=date, now=now)
find(days=days,
dir=directory,
exts=[".mp3", ".flac", ".ogg"],
hook=tags.read)
print >> sys.stderr, len(tags), 'music files found'
xspf = xspfgenerator.SimpleXSPFGenerator(title, creator)
xspf.addTracks(tags.tags())
return xspf
def compute_cost_comp(nnum, nterm, numberline, mus, c, w, need_probs,
subrange):
F_i_w_numerator = compute_f_i_w_numerator(nnum, nterm, numberline, mus, c,
w)
F_i_w_numerator = np.multiply(F_i_w_numerator, need_probs)
term_num_map = np.zeros((nterm, nnum))
maxind = find(F_i_w_numerator, np.amax(F_i_w_numerator, 0), axis=1)
maxmaxind = find(maxind, max(maxind))
for i in range(maxmaxind[-1] + 1, len(maxind)):
maxind[i] = max(maxind)
for i in range(1, nterm - 1):
inds = find(maxind, i)
for ind in inds:
term_num_map[i, ind] = 1
for diff_ind in find_diff(numberline, find(sum(term_num_map), 1)):
term_num_map[nterm - 1, diff_ind - 1] = 1
mmap = np.argmax(term_num_map, 0)
log_prob_L = np.zeros((1, nnum))
for j in range(nterm):
cat_inds = find(mmap, j)
f = F_i_w_numerator[j, cat_inds]
for ind in range(len(cat_inds)):
log_prob_L[0, cat_inds[ind]] = (f[ind] / sum(f))
log_prob_L = np.log2(log_prob_L)
ccost_perm = np.sum(np.asarray(need_probs) * -log_prob_L[0])
ccost_perm_ns = ccost_perm
comp_perm = compute_subitized_complex(subrange, mmap, nterm)
comp_perm_ns = 3 * len(find_unique(mmap))
return ccost_perm, ccost_perm_ns, comp_perm, comp_perm_ns
def parsePrepVerb(p, var):
statement = ""
varToBeShown = []
replaceDictionary = {}
pobj = findDep(p, "pobj")
if pobj == None:
pobj = findDep(p, "pcomp")
if pobj == None:
return {
"varToBeShown": varToBeShown,
"statement": statement,
"replaceDictionary": replaceDictionary
}
pobjv = gn.generateName()
if pobj.pos_ != "NUM":
res = parseNoun(pobj, pobjv, None)
statement += res['statement']
varToBeShown += res['varToBeShown']
replaceDictionary = concatDict(replaceDictionary,
res['replaceDictionary'])
union = False
for i in inProperties:
prepVar = createName(i, True)
replacements = find(i, True)
if replacements != []:
if union:
statement += " UNION "
statement += "{" + var + " " + prepVar + " " + pobjv + ".}"
replaceDictionary[prepVar] = ("wdt:", replacements)
union = True
return {
"varToBeShown": varToBeShown,
"statement": statement,
"replaceDictionary": replaceDictionary
}
def str2np(string):
str_R = find(string, ']')
i = 5
return str_R
def generateStatements(word, combination, var, prop):
sentence = word.doc.text
sentence = sentence.replace(combination["string"],
combination["replacement"])
rel = nlp(sentence)
w = rel[combination["start"]]
string = combination["string"]
varToBeShown = []
statement = ""
replaceDictionary = {}
isProp = None
for dep in findDependencies(w):
if dep.dep_ == "prep":
if dep.i <= w.i:
i = dep.i
else:
i = dep.i + combination["length"] - 1
res = parsePrep(word.doc[i], var, prop, string)
varToBeShown += res["varToBeShown"]
statement += res["statement"]
replaceDictionary = concatDict(replaceDictionary,
res["replaceDictionary"])
if isProp == None:
if "isProp" in res and "propVar" in res:
isProp = res[
"isProp"] #TODO: Check this for efficiency and properness
propVar = res["propVar"]
elif isProp != res["isProp"]:
raise ValueError
elif dep.dep_ == "det":
res = parseDet(dep, var)
varToBeShown += res["varToBeShown"]
statement += res["statement"]
replaceDictionary = concatDict(replaceDictionary,
res["replaceDictionary"])
elif dep.dep_ == "acl":
pass
elif dep.dep_ == "amod":
if dep.lemma_ != "all" or dep.lemma_ != "current":
res = parseAmodAcomp(dep, var)
varToBeShown += res["varToBeShown"]
statement += res["statement"]
replaceDictionary = concatDict(replaceDictionary,
res["replaceDictionary"])
else:
raise ValueError
if string.lower() in questionWords:
selectVar = createSelectName(combination["start"])
statement += "BIND(" + var + " AS " + selectVar + ").\n"
#replaceDictionary[var] = selectVar
varToBeShown.append(var)
return {
"varToBeShown": varToBeShown,
"statement": statement,
"replaceDictionary": replaceDictionary
}
if prop != None:
isProp = True
propVar = prop
property = None
if isProp == True:
if string in countWords:
statement1 = "SELECT (count(distinct " + propVar + ") as " + var + ") WHERE {" + statement + "}\n"
statement = statement1
else:
union = False
cvar1 = gn.generateName()
cvar2 = gn.generateName()
coalesce = ""
if find(string, True) != []:
rvar = createName(string, True)
replaceDictionary[rvar] = ("wdt:", find(string, True))
statement += "OPTIONAL {" + propVar + " " + rvar + " " + cvar1 + "}"
coalesce += "IF(BOUND(" + cvar1 + ")," + cvar1 + ",1/0)"
union = True
if find(string + " of", True) != []:
if union:
coalesce += ", "
coalesce += "IF(BOUND(" + cvar2 + ")," + cvar2 + ",1/0)"
rvar = createName(string + " of", True)
replaceDictionary[rvar] = ("wdt:", find(string + " of", True))
statement += "OPTIONAL {" + cvar2 + " " + rvar + " " + propVar + "}"
if find(string + " of", True) == [] and find(string, True) == []:
raise ValueError
statement += "BIND(COALESCE(" + coalesce + ") as " + var + ").\n"
property = string
elif find(string, False) != []:
rvar = createName(string, False)
replaceDictionary[rvar] = ("wd:", find(string, False))
statement += "{ \n"
statement += "BIND(" + rvar + " AS " + var + "). \n"
statement += "} UNION { \n"
statement += var + " wdt:P31 " + rvar + ". \n"
statement += "}\n"
else:
rvar = createName(string, True)
uvar = gn.generateName()
replaceDictionary[rvar] = ("wdt:", find(string, True))
statement += uvar + " " + rvar + " " + var
if find(string, True) == []:
raise ValueError
return {
"varToBeShown": varToBeShown,
"statement": statement,
"replaceDictionary": replaceDictionary,
"property": property
}
def compute_P_w_i_match_modemap(cluster, numberline, nterm, term_num_map,
mu_range, c, w, need_probs):
nnum = len(numberline)
mu_placements = list(itertools.combinations(mu_range, nterm))
mu_placements = np.asarray(mu_placements)
minmse = float("inf")
best_P_w_i = None
P_w_i_vec = None
mus_match = None
inds = []
cvec = []
for i in range(mu_placements.shape[0]):
mus = mu_placements[i, :].reshape(-1, 1)
P_w_i = compute_P_w_i(nnum, nterm, numberline, mus, c, w)
maxPs = np.amax(P_w_i, axis=0)
mode_cluster = np.argmax(P_w_i, axis=0)
mode_cluster = [a + 1 for a in mode_cluster]
mindiff = np.sum([abs(x - y) for x, y in zip(mode_cluster, cluster)])
if mindiff < minmse:
minmse = mindiff
mus_match = mus
P_w_i_vec = maxPs
best_P_w_i = P_w_i
for i in range(mu_placements.shape[0]):
mus = mu_placements[i, :].reshape(-1, 1)
P_w_i = compute_P_w_i(nnum, nterm, numberline, mus, c, w)
maxPs = np.amax(P_w_i, axis=0)
mode_cluster = np.argmax(P_w_i, axis=0)
mode_cluster = [a + 1 for a in mode_cluster]
if np.sum([abs(x - y)
for x, y in zip(mode_cluster, cluster)]) == mindiff:
inds.append(i)
F_i_w_numerator = compute_f_i_w_numerator(nnum, nterm, numberline,
mus, c, w)
log_prob_L = np.zeros((1, nnum))
for j in range(nterm):
cat_inds = find(cluster, j + 1)
cat_sum = 0
for ind in cat_inds:
cat_sum += F_i_w_numerator[j, ind]
for ind in cat_inds:
if cat_sum != 0:
log_prob_L[0, ind] = F_i_w_numerator[j, ind] / cat_sum
else:
log_prob_L[0, ind] = 0
log_prob_L = np.log2(log_prob_L)
cvec.append(sum((need_probs * -log_prob_L)[0]))
ind = inds[find(cvec, min(cvec))[0]]
mus_match = mu_placements[i, :]
P_w_i = compute_P_w_i(nnum, nterm, numberline,
np.asarray(mus_match).reshape((-1, 1)), c, w)
maxPs = np.amax(P_w_i)
modeclust = np.argmax(P_w_i)
return mus_match, P_w_i_vec
def extractRings(V, F, centerVIdx, numRings=1):
VIdx = centerVIdx
for ii in range(numRings):
r, c = find(F, VIdx)
VIdx = np.unique(F[r, :])
return VIdx
def eval(self, context: Context, pos, code):
return find(WhileLine.re, code, pos, True) - 1
def eval(self, context: Context, pos, code):
if exp_eval(self.arg, context):
return pos + 1
else:
return find(WendLine.re, code, pos)
def eval(self, context: Context, pos, code):
pos = find(EndifLine.re, code, pos)
return pos
