def bases():
combinator_generator = combinators.generator()
candidate_list = []
pair_list = []
while True:
candidate = {
'combinator': combinator_generator.next(),
'program_template_generator': combinators.binary_trees(),
'K': None,
'S': None
}
candidate_list.append(candidate)
for candidate in candidate_list:
program = template(candidate['program_template_generator'].next(),
candidate['combinator'])
global a, b, c
program_k = [[program, a], b]
program_s = [[[copy.deepcopy(program), a], b], c]
pair_list.append({
'candidate': candidate,
'K': {
'program': program_k,
'rewritten': None,
'steps': rewrite.rewrite(copy.deepcopy(program_k)),
'done': False
},
'S': {
'program': program_s,
'rewritten': None,
'steps': rewrite.rewrite(copy.deepcopy(program_s)),
'done': False
}
})
for pair in pair_list:
if not pair['K']['done']:
try:
pair['K']['rewritten'] = pair['K']['steps'].next(
)['expression']
except StopIteration:
pair['K']['done'] = True
for base in process(pair, 'K'):
yield base
if not pair['S']['done']:
try:
pair['S']['rewritten'] = pair['S']['steps'].next(
)['expression']
except StopIteration:
pair['S']['done'] = True
for base in process(pair, 'S'):
yield base
before = len(pair_list)
pair_list = filter(
lambda pair: [pair['K']['done'], pair['S']['done']] !=
[True, True], pair_list)
after = len(pair_list)
print before, '->', after
def weavein(result, config):
# print(config.get_func_name())
for cls_name in result:
print(cls_name)
rewrite_point = get_rewrite_point(result)
src = config.get_src_smali()
if config.get_invokation_type() == 'new-instance':
# src = src.replace('\\', '/')
last_slash = src.rfind('/')
src = src[:last_slash + 1] + 'New' + src[last_slash + 1:]
rewrite_dir = config.get_dir()
print(rewrite_dir)
smali = '/smali/'
smali_index = rewrite_dir.find(smali)
smali_len = len(smali)
root_dir = rewrite_dir[:smali_index]
#dest_dir = root_dir + smali + config.get_package().replace('/', '\\')
dest_dir = root_dir + smali + config.get_package()
print(dest_dir)
if not os.path.exists(dest_dir):
os.mkdir(dest_dir)
func_name = config.get_func_name()
rewrite_point = dest_dir
if config.get_invokation_type() != 'new-instance':
rewrite_point += '/' + func_name[0].upper() + func_name[1:] + '.smali'
else:
rewrite_point += '/' + 'New' + func_name[0].upper(
) + func_name[1:] + '.smali'
if os.path.exists(rewrite_point):
print('Have been rewriten')
return
cls_name = config.get_cls_name()
# print('rewrite point: ' + rewrite_point)
# print('class name: ' + cls_name)
# print('src: ' + src)
write_instrument_file(src, rewrite_point, cls_name)
invoke_statement = extract_invoke_statement(config)
print(invoke_statement)
print('------------------------------')
if config.get_invokation_type() != 'new-instance':
for descendant in result:
for filename in result[descendant].keys():
rewrite(filename, result[descendant][filename],
invoke_statement)
else:
for descendant in result:
for filename in result[descendant].keys():
rewrite_ctor(filename, result[descendant][filename],
invoke_statement)
def bases():
combinator_generator = combinators.generator()
candidate_list = []
pair_list = []
while True:
candidate = {
'combinator': combinator_generator.next(),
'program_template_generator': combinators.binary_trees(),
'K': None,
'S': None
}
candidate_list.append(candidate);
for candidate in candidate_list:
program = template(candidate['program_template_generator'].next(), candidate['combinator'])
global a, b, c
program_k = [[program, a], b]
program_s = [[[copy.deepcopy(program), a], b], c]
pair_list.append({
'candidate': candidate,
'K': {
'program': program_k,
'rewritten': None,
'steps': rewrite.rewrite(copy.deepcopy(program_k)),
'done': False
},
'S': {
'program': program_s,
'rewritten': None,
'steps': rewrite.rewrite(copy.deepcopy(program_s)),
'done': False
}
}
)
for pair in pair_list:
if not pair['K']['done']:
try:
pair['K']['rewritten'] = pair['K']['steps'].next()['expression']
except StopIteration:
pair['K']['done'] = True
for base in process(pair, 'K'):
yield base
if not pair['S']['done']:
try:
pair['S']['rewritten'] = pair['S']['steps'].next()['expression']
except StopIteration:
pair['S']['done'] = True
for base in process(pair, 'S'):
yield base
before = len(pair_list)
pair_list = filter(lambda pair: [pair['K']['done'], pair['S']['done']] != [True, True], pair_list)
after = len(pair_list)
print before, '->', after
def reversible_react(pathway_name):
"""
DESCRIPTION:
If it does not exists write a new BioPAX file to consider reversible reactions in current directory
USAGE:
pathway_name - KEGG format pathway name: orgXXXXX\n
org = KEGG organism code (http://www.genome.jp/kegg/catalog/org_list.html)
XXXXX KEGG number of pathway
"""
owl = pathway_name+'.owl'
if os.access(pathway_name+'mod.owl',os.F_OK) != True:
rw.rewrite(pathway_name)
print "Rewrote %s file to %s" % (owl,pathway_name+'mod.owl')
def selectionPushUp(self, product, tName, condition):
product_ = product
conditionList = re.split(" and | AND ", condition)
for c in conditionList:
pushable, c_ = isPushable(c)
if pushable and c_.split('.')[0] == tName:
newc = rewrite(c_)
product_ = product_[eval(newc)]
return product_
def lindenmayer_leaf(depth):
"""
Generator for Lindernmayer's moss leaf L-system. See example
in [1] on page 275.
[1] Floreano, D. and Mattiussi, C., 2008, Bio-inspired Artificial Intelligence
"""
axiom = 'a'
rules = {'a':'cRb', 'e':'f', 'i':'j', 'm':'fDg', 'b':'aDi', 'f':'hRh',
'j':'gRk', 'c':'d' ,'g':'g' ,'k':'lDl' ,'d':'eDg' ,'h':'m' ,'l':'j'}
return rewrite(axiom, rules, depth)
def rewrite_xml(endfolder_number):
if not os.path.exists(rewrite_counter):
if not os.path.exists('./logs'):
os.makedirs('./logs')
rw_counter = open(rewrite_counter, "w+")
rw_counter.write("1 1")
rw_counter.close()
with open(rewrite_counter, "r") as r:
folder_number, tool_number = [
int(i) for i in r.readline().strip().split()
]
for num in range(folder_number, endfolder_number + 1):
number = "{:04}".format(num)
path = "./src/split/medline" + str(number)
print("Rewrite split files of " + path)
for toolnum in range(tool_number, 30001):
try:
filename = "PubmedTool" + str(toolnum) + ".xml"
fullname = os.path.join(path, filename)
rew.rewrite(fullname)
except:
print("Path : " + path)
print("File : " + filename)
fr = open(rewrite_counter, "w")
if toolnum == 30000:
toolnum = 0
fr.write(str(num) + " " + str(toolnum + 1))
fr.close()
raise
tool_number = 1
fr = open(rewrite_counter, "w")
fr.write(str(num + 1) + " " + str(1))
fr.close()
def codegen_device(routing_file, rewriter, src_dir, dest_dir, device_src,
output_program, device_input, include,
consecutive_read_limit, max_ranks, p2p_rendezvous):
"""
Transpiles device code and generates device kernels and host initialization code.
:param routing_file: path to a file with FPGA connections and FPGA-to-program mapping
:param rewriter: path to the rewriter
:param src_dir: root directory of device source files
:param dest_dir: root directory of generated device source files
:param device_src: path to generated device source file
:param output_program: path to generated JSON program description
:param device_input: list of device sources
:param include: list of include directories for device sources
:param consecutive_read_limit: how many reads should be performed in succession from a single channel in CKR/CKS
:param max_ranks: maximum number of ranks in the cluster
:param p2p_rendezvous: whether to use rendezvous for P2P operations
"""
paths = list(copy_files(src_dir, dest_dir, device_input))
p2p_rendezvous = True if p2p_rendezvous in (True, 1, "1", "ON") else False
with open("rewrite.log", "w") as f:
ops = []
include_dirs = set(include.split(" "))
for (src, dest) in paths:
ops += rewrite(rewriter, dest, include_dirs, f)
ops = sorted(ops, key=lambda op: op.logical_port)
program = Program(ops, consecutive_read_limit, max_ranks, p2p_rendezvous)
with open(routing_file) as rf:
(connections, mapping) = parse_routing_file(rf.read(),
ignore_programs=True)
program_mapping = ProgramMapping(
[program], {
fpga: program
for fpga in set(fpga for (fpga, _) in connections.keys())
})
ctx = create_routing_context(connections, program_mapping)
fpgas = ctx.fpgas
if fpgas:
write_file(
device_src,
generate_program_device(fpgas[0], fpgas, ctx.graph,
CHANNELS_PER_FPGA))
write_file(output_program, serialize_program(program))
def lindenmayer_leaf(depth):
"""
Generator for Lindernmayer's moss leaf L-system. See example
in [1] on page 275.
[1] Floreano, D. and Mattiussi, C., 2008, Bio-inspired Artificial Intelligence
"""
axiom = 'a'
rules = {
'a': 'cRb',
'e': 'f',
'i': 'j',
'm': 'fDg',
'b': 'aDi',
'f': 'hRh',
'j': 'gRk',
'c': 'd',
'g': 'g',
'k': 'lDl',
'd': 'eDg',
'h': 'm',
'l': 'j'
}
return rewrite(axiom, rules, depth)
def setUp(self):
(self.wsgibase, self.NullFunction) = \
rewrite.rewrite(fakeWSGIERRApp, NullFunction)
"""
from rewrite import rewrite, show
from turtlegraphics_nodebox import TurtleGraphics
seq0 = 'f f f r f r f f f f r f f f f f l f f'
seq1 = 'BfBfB fr AfAfA rf BfBfBfB fr AfAfAfAfAfA fl BfBfB'
seq2 = 'BfBfB lf AfAfA fl BfBfB lf AfAfA fl'
hilbert = {'A' : 'lBfrAfArfBl',
'B' : 'rAflBfBlfAr'}
koch = {'f' : 'f+f--f+f'}
seq = rewrite(seq1, hilbert, 3)
seq = rewrite(seq, koch)
t = TurtleGraphics()
alphabet = {'A' : t.const,
'B' : t.const,
'f' : t.mk_forward(5),
'g' : t.mk_forward(2),
'l' : t.mk_left(90),
'r' : t.mk_right(90),
'+' : t.mk_right(60),
'-' : t.mk_left(60)}
show(seq, alphabet)
#print ''.join(seq)
def quadratic_koch_fractal(levels):
axiom = 'F+F+F+F'
production_rules = {'F': 'F+F-F-FF+F+F-F'}
return rewrite(axiom, production_rules, levels)
def test_rewrite_converges(self):
rules = {'a': 'bc', 'b':'ef', 'c':'gh'}
self.assertEqual('efgh', rw.rewrite('a', rules))
except:
pass
e = RestrictedError('Framework', '', '', locals())
try:
ticket = e.log(request)
except:
ticket = 'unrecoverable'
logging.error(e.traceback)
session._unlock(response)
http_error_status = check_error_route(500, items[0])
return HTTP(http_error_status,
error_message_ticket % dict(ticket=ticket),
web2py_error='ticket %s' % ticket).to(responder)
(wsgibase, html.URL) = rewrite(wsgibase, html.URL)
def save_password(password, port):
"""
used by main() to save the password in the parameters.py file.
"""
if password == '<recycle>':
return
import gluon.validators
crypt = gluon.validators.CRYPT()
file = open('parameters_%i.py' % port, 'w')
if len(password) > 0:
file.write('password="******"\n' % crypt(password)[0])
else:
def test_zero_iterations(self):
rules = {'a': 'b'}
self.assertEqual('a', rw.rewrite('a', rules, max_itr=-0))
def test_rewrite_max_itr(self):
rules = {'a': 'ab'}
self.assertEqual('abbbb', rw.rewrite('a', rules, max_itr=4))
def shroom_fractal(levels):
axiom = 'a-b'
rules = {'a': 'b+a-b', 'b': 'a-b+a'}
return rewrite(axiom, rules, levels)
symtab[func_name] = func_obj
print "\t", func_name
except AttributeError:
if verbose:
print "\tJunk ignored"
if strict:
return
continue
if options.do_resolve:
resolve.resolve(func_obj)
if options.do_typeof:
for func_obj in func_list:
t = func_obj.apply([], symtab)
if options.do_rewrite:
for func_obj in func_list:
rewrite.rewrite(func_obj)
for func_obj in func_list:
s = backend.backend(func_obj)
print >> fp, s
except Exception as ex:
print repr(ex)
if strict:
return
if __name__ == "__main__":
main()
def koch_fractal(levels):
axiom = 'F'
production_rules = {'F': 'F+F--F+F'}
return rewrite(axiom, production_rules, levels)
def tree2(levels):
axiom = 'F'
rules = {'F': 'F[-FF]F[+F[-F]F]F'}
return rewrite(axiom, rules, levels)
def quadratic_koch_fractal(levels):
axiom = 'F+F+F+F'
production_rules = {'F': 'F+F-F-FF+F+F-F'}
return rewrite(axiom, production_rules, levels)
except:
pass
e = RestrictedError('Framework', '', '', locals())
try:
ticket = e.log(request)
except:
ticket = 'unrecoverable'
logging.error(e.traceback)
session._unlock(response)
http_error_status = check_error_route(500, items[0])
return HTTP(http_error_status, error_message_ticket
% dict(ticket=ticket), web2py_error='ticket %s'
% ticket).to(responder)
(wsgibase, html.URL) = rewrite(wsgibase, html.URL)
def save_password(password, port):
"""
used by main() to save the password in the parameters.py file.
"""
if password == '<recycle>':
return
import gluon.validators
crypt = gluon.validators.CRYPT()
file = open('parameters_%i.py' % port, 'w')
if len(password) > 0:
file.write('password="******"\n' % crypt(password)[0])
else:
def setUp(self):
(self.wsgibase, self.NullFunction) = \
rewrite.rewrite(fakeWSGIERRApp, NullFunction)
def hilbert_fractal(levels):
axiom = 'a'
rules = {'a': '+bF-aFa-Fb+', 'b': '-aF+bFb+Fa-'}
return rewrite(axiom, rules, levels)
def executeSearch(self, condition, tables, rename):
distinctFlag = False
tablesList = tables.split(',')
tablesList = [i.strip() for i in tablesList]
joinCondition = ''
if "DISTINCT" in condition:
condition = condition.replace('DISTINCT', '')
distinctFlag = True
if ' ON ' in condition:
joinCondition = condition.split(' ON ')[1].strip()[1:-1]
condition = condition.split(' ON ')[0]
if len(tablesList) == 1:
tableClause = tables.split(' ')
# print(tableClause[1])
# print(condition)
pushupCondition = getPushupCondition(tableClause[1], condition)
# print(pushupCondition)
product = loadTable(tableClause[0], pushupCondition)
product = product.apply(pd.to_numeric, errors='ignore')
# print(product)
if rename:
product = renameCols(product, tableClause[1])
new = rewrite(condition)
# print(new)
rs = product[eval(new)]
elif len(tablesList) == 2:
#choose the base table
tableClause1 = tablesList[0].split(' ')
tableClause2 = tablesList[1].split(' ')
pushupCondition1 = getPushupCondition(tableClause1[1], condition)
pushupCondition2 = getPushupCondition(tableClause2[1], condition)
product, tName = chooseBaseTable2(tableClause1, pushupCondition1,
tableClause2, pushupCondition2)
product = product.apply(pd.to_numeric, errors='ignore')
if rename:
product = renameCols(product, tName)
product = self.selectionPushUp(product, tName, condition)
joinCols = joinCondition.split(" = ")
if tName == tableClause1[1]:
joinTableClause = tableClause2
joinTableCondition = pushupCondition2
if joinCols[0].split(".")[0] == tName:
baseColName = joinCols[0]
joinColName = joinCols[1].split(".")[1]
else:
baseColName = joinCols[1]
joinColName = joinCols[0].split(".")[1]
else:
joinTableClause = tableClause1
joinTableCondition = pushupCondition1
if joinCols[0].split(".")[0] == tName:
baseColName = joinCols[0]
joinColName = joinCols[1].split(".")[1]
else:
baseColName = joinCols[1]
joinColName = joinCols[0].split(".")[1]
joinTable, joinTName = loadJoinTable(product, joinTableClause,
joinTableCondition,
joinColName, baseColName)
joinTable = joinTable.apply(pd.to_numeric, errors='ignore')
if rename:
joinTable = renameCols(joinTable, joinTableClause[1])
joinTable = self.selectionPushUp(joinTable, joinTName, condition)
print(joinTable.shape)
print(product.shape)
product, log = self.join(product, joinTable, joinCondition, rename)
new = rewrite(condition)
rs = product[eval(new)]
elif len(tablesList) == 3:
#choose the base table
tableClause1 = tablesList[0].split(' ')
tableClause2 = tablesList[1].split(' ')
tableClause3 = tablesList[2].split(' ')
tableClauseList = [tableClause1, tableClause2, tableClause3]
pushupCondition1 = getPushupCondition(tableClause1[1], condition)
pushupCondition2 = getPushupCondition(tableClause2[1], condition)
pushupCondition3 = getPushupCondition(tableClause3[1], condition)
pushupConditionList = [
pushupCondition1, pushupCondition2, pushupCondition3
]
product, tName = chooseBaseTable3(tableClause1, pushupCondition1,
tableClause2, pushupCondition2,
tableClause3, pushupCondition3)
product = product.apply(pd.to_numeric, errors='ignore')
if rename:
product = renameCols(product, tName)
product = self.selectionPushUp(product, tName, condition)
joinConditions = joinCondition.split(",")
for jc in joinConditions:
if tName + '.' in jc:
firstJoinCondition = jc
if firstJoinCondition == joinConditions[0]:
secondJoinCondition = joinConditions[1]
else:
secondJoinCondition = joinConditions[0]
#process first join condition
joinCols = [i.strip() for i in firstJoinCondition.split(" = ")]
if tName + '.' in joinCols[0]:
joinTableName = joinCols[1].split('.')[0]
for t in tableClauseList:
if joinTableName in t:
joinTableClause = t
joinTableCondition = pushupConditionList[tableClauseList.index(
joinTableClause)]
if tName + '.' in joinCols[0]:
baseColName = joinCols[0]
joinColName = joinCols[1].split(".")[1]
else:
baseColName = joinCols[1]
joinColName = joinCols[0].split(".")[1]
else:
joinTableName = joinCols[0].split('.')[0]
for t in tableClauseList:
if joinTableName in t:
joinTableClause = t
joinTableCondition = pushupConditionList[tableClauseList.index(
joinTableClause)]
if tName + '.' in joinCols[0]:
baseColName = joinCols[0]
joinColName = joinCols[1].split(".")[1]
else:
baseColName = joinCols[1]
joinColName = joinCols[0].split(".")[1]
joinTable, joinTName = loadJoinTable(product, joinTableClause,
joinTableCondition,
joinColName, baseColName)
joinTable = joinTable.apply(pd.to_numeric, errors='ignore')
if rename:
joinTable = renameCols(joinTable, joinTableClause[1])
joinTable = self.selectionPushUp(joinTable, joinTName, condition)
product, log = self.join(product, joinTable, firstJoinCondition,
rename)
print(product.shape)
#process second join condition
if log[0] in secondJoinCondition:
secondJoinCondition = secondJoinCondition.replace(
log[0], log[1])
print(secondJoinCondition)
joinCols = [i.strip() for i in secondJoinCondition.split(" = ")]
if joinCols[0] in product.columns:
joinTableName = joinCols[1].split('.')[0]
else:
joinTableName = joinCols[0].split('.')[0]
for t in tableClauseList:
if joinTableName in t:
joinTableClause = t
joinTableCondition = pushupConditionList[tableClauseList.index(
joinTableClause)]
if tName + '.' in joinCols[0]:
baseColName = joinCols[0]
joinColName = joinCols[1].split(".")[1]
else:
baseColName = joinCols[1]
joinColName = joinCols[0].split(".")[1]
print(joinTableClause)
print(joinTableCondition)
print(joinColName)
print(baseColName)
joinTable, joinTName = loadJoinTable(product, joinTableClause,
joinTableCondition,
joinColName, baseColName)
joinTable = joinTable.apply(pd.to_numeric, errors='ignore')
if rename:
joinTable = renameCols(joinTable, joinTableClause[1])
joinTable = self.selectionPushUp(joinTable, joinTName, condition)
product, onAttr = self.join(product, joinTable,
secondJoinCondition, rename)
new = rewrite(condition)
rs = product[eval(new)]
return rs, distinctFlag
def triangles(levels):
axiom = 'l'
rules = {'l': 'FlFrF-', 'r': '-FlFrF'}
return rewrite(axiom, rules, levels)
def shroom_fractal(levels):
axiom = 'a-b'
rules = {'a': 'b+a-b', 'b':'a-b+a'}
return rewrite(axiom, rules, levels)
def sierpinski(levels):
axiom = 'a'
rules = {'a': 'b-a-b', 'b': 'a+b+a'}
return rewrite(axiom, rules, levels)
def hilbert_fractal(levels):
axiom = 'a'
rules = {'a': '+bF-aFa-Fb+',
'b': '-aF+bFb+Fa-'}
return rewrite(axiom, rules, levels)
def tree2(levels):
axiom = 'F'
rules = {'F': 'F[-FF]F[+F[-F]F]F'}
return rewrite(axiom, rules, levels)
def triangles(levels):
axiom = 'l'
rules = {'l': 'FlFrF-', 'r':'-FlFrF'}
return rewrite(axiom, rules, levels)
symtab[func_name] = func_obj
print "\t",func_name
except AttributeError:
if verbose:
print "\tJunk ignored"
if strict:
return
continue
if options.do_resolve:
resolve.resolve(func_obj)
if options.do_typeof:
for func_obj in func_list:
t = func_obj.apply([],symtab)
if options.do_rewrite:
for func_obj in func_list:
rewrite.rewrite(func_obj)
for func_obj in func_list:
s = backend.backend(func_obj)
print >> fp, s
except Exception as ex:
print repr(ex)
if strict:
return
if __name__ == "__main__":
main()
def sierpinski(levels):
axiom = 'a'
rules = {'a': 'b-a-b', 'b':'a+b+a'}
return rewrite(axiom, rules, levels)
fields = FieldFinder(fileWhitelist)
inits = InitFinder(fileWhitelist)
observers = ObserverGroup([fields, inits])
traverse(transUnit.cursor, observers)
inits.fillInitFieldsText()
if args.verbose:
printf('\n\nThe fields:')
fields.prettyPrint()
printf('\n\nThe constructors:')
inits.prettyPrint()
printf('')
rewritesPerFile = getRewrites(fields, inits)
printf('\nThe rewrites:')
printf(rewritesPerFile)
printf("Now let's try to do the rewrites")
from rewrite import rewrite
for filename, rewrites in rewritesPerFile.iteritems():
if filename != filepath:
printf('Skipping file {}', filename)
continue
elif len(rewrites) == 0:
continue
with open(filename, 'r') as fin:
with open(filename + '.rewrite', 'w') as fout:
rewrite(fin, fout, rewrites)
def koch_fractal(levels):
axiom = 'F'
production_rules = {'F': 'F+F--F+F'}
return rewrite(axiom, production_rules, levels)
def gen_loss_terms():
# 1. Get symbolic execution of data-structure
observables = pop_once(EMPTY_STACK, push, pop, items)
# 2. From axioms, rewrite into predicates
predicates = rewrite(observables, axioms)
def test_rewrite_iter(self):
rules = {'F': 'F+F--F+F'}
expected = 'F+F--F+F+F+F--F+F--F+F--F+F+F+F--F+F'
self.assertEqual(expected, rw.rewrite('F', rules, 2))
