def gen_update_flow(self, env, marking_var, place_info):
""" Get an pyast representing the flow update.
"""
return pyast.Assign(
targets=[pyast.E(self.field.access_from(marking_var))],
value=pyast.Num(self._places[place_info.name]))
def new_place_stmt(self, env, marking_var):
""" Produce a new empty place.
@returns: empty place expression
@rtype: C{Expr}
"""
return pyast.E("{} = 0".format(self.field.access_from(marking_var)))
def extract_pids(self, env, marking_var, dict_var):
place_expr = pyast.E(self.field.access_from(marking_var))
vp = VariableProvider()
token_var = vp.new_variable(TypeInfo.get('AnyType'), name='pid')
place_in_dict_marking = self.field.access_from_str(
"{pid_dict}[ {token} ]".format(pid_dict=dict_var.name,
token=token_var.name))
body = [
pyast.stmt(
pyast.E("{marking}.add({token})".format(
marking=place_in_dict_marking, token=token_var.name)))
]
return pyast.For(target=pyast.E(token_var.name),
iter=place_expr,
body=body)
def update_pids_stmt(self, env, marking_var, new_pid_dict_var):
return pyast.Assign(
targets=[self.place_expr(env, marking_var)],
value=pyast.Call(func=pyast.E(stubs['pid_place_type_update_pids']),
args=[
self.place_expr(self, marking_var),
pyast.Name(new_pid_dict_var.name)
]))
def dump_expr(self, env, marking_var, variable):
place_expr = pyast.E(self.field.access_from(marking_var))
l = []
for place in self._places:
l.append(
pyast.stmt(
pyast.Call(
func=pyast.E('{}.append'.format(variable.name)),
args=[
pyast.BinOp(
left=pyast.Str(repr(place) + ' : '),
op=pyast.Add(),
right=pyast.IfExp(test=self.gen_check_flow(
env, marking_var, place, place_expr),
body=pyast.Str('[ dot ],'),
orelse=pyast.Str('[],')))
])))
return l
def enumerate(self, env, marking_var, token_var, compiled_body):
place_expr = pyast.E(self.field.access_from(marking_var))
getnode = pyast.Assign(targets=[pyast.Name(id=token_var.name)],
value=pyast.Name(id='dot'))
ifnode = pyast.If(test=pyast.Compare(left=place_expr,
ops=[pyast.Gt()],
comparators=[pyast.Num(0)]),
body=[getnode, compiled_body])
return [ifnode]
def extract_pids(self, env, marking_var, dict_var):
place_expr = pyast.E(self.field.access_from(marking_var))
vp = VariableProvider()
token_var = vp.new_variable(TypeInfo.get('AnyType'), name='token')
if not self.token_type.has_pids:
return []
if self.token_type.is_Pid:
raise RuntimeError
elif self.token_type.is_TupleType:
print "!!! TUPLE >> ", self.token_type
for index, subtype in enumerate(self.token_type):
body = []
if subtype.is_Pid:
if index == 0:
# head is pid, owned token
place_in_dict_marking = self.field.access_from_str(
"{pid_dict}[ {token}[{index}] ]".format(
pid_dict=dict_var.name,
token=token_var.name,
index=index))
body.append(
pyast.stmt(
pyast.E("{marking}.add({token})".format(
marking=place_in_dict_marking,
token=token_var.name))))
else:
place_in_dict_marking = "{pid_dict}[ {token}[{index}] ]".format(
pid_dict=dict_var.name,
token=token_var.name,
index=index)
body.append(
pyast.E("{marking} = Marking(True)".format(
marking=place_in_dict_marking)))
return pyast.For(target=pyast.E(token_var.name),
iter=place_expr,
body=body)
else:
print "!!! DATA >> ", self.token_type
return []
def copy_stmt(self, env, dst_marking_var, src_marking_var):
""" produce an expression corresponding to a copy of the place.
@param env: compiling environment
@type env: C{Env}
@param marking_var: marking storing the place
@type marking_var: C{VariableInfo}
"""
field = self.field
return pyast.E("{} = {}".format(field.access_from(dst_marking_var),
field.access_from(src_marking_var)))
def dump_expr(self, env, marking_var):
place_expr = pyast.E(self.field.access_from(marking_var))
return pyast.IfExp(test=place_expr,
body=pyast.BinOp(left=pyast.Str('['),
op=pyast.Add(),
right=pyast.BinOp(
left=pyast.Call(
func=pyast.Name('dump'),
args=[place_expr]),
op=pyast.Add(),
right=pyast.Str(']'))),
orelse=pyast.Str('[]'))
def light_copy_stmt(self, env, dst_marking_var, src_marking_var):
return pyast.E("{} = {}".format(
self.field.access_from(dst_marking_var),
self.field.access_from(src_marking_var)))
def token_expr(self, env, value):
return pyast.E(repr(value))
def add_token_stmt(self, env, compiled_token, marking_var, *args):
add_expr = pyast.E("{}.add".format(
self.field.access_from(marking_var)))
return pyast.stmt(pyast.Call(func=add_expr, args=[compiled_token]))
def iterable_expr(self, env, marking_var):
return pyast.E("{}".format(self.field.access_from(marking_var)))
def add_token_stmt(self, env, compiled_token, marking_var, *args):
return pyast.E("{} += 1".format(self.field.access_from(marking_var)))
def add_items_stmt(self, env, multiset, marking_var):
add_items_attr_expr = pyast.E('{}.add_items'.format(
self.field.access_from(marking_var)))
return pyast.stmt(pyast.Call(func=add_items_attr_expr,
args=[multiset]))
def not_empty_expr(self, env, marking_var):
return pyast.E(self.field.access_from(marking_var))
def size_expr(self, env, marking_var):
return pyast.E("len({})".format(self.field.access_from(marking_var)))
def add_token_stmt(self, env, compiled_token, marking_var):
field_expr = pyast.E(self.field.access_from(marking_var))
return pyast.Assign(targets=[field_expr], value=compiled_token)
def new_place_stmt(self, env, dst_marking_var):
return pyast.E("{} = multiset([])".format(
self.field.access_from(dst_marking_var)))
def copy_stmt(self, env, dst_marking_var, src_marking_var):
env.add_import('copy')
return pyast.E("{} = copy.deepcopy({})".format(
self.field.access_from(dst_marking_var),
self.field.access_from(src_marking_var)))
def dump_expr(self, env, marking_var):
return pyast.E("'[' + ','.join(['dot'] * {}) + ']'".format(
self.field.access_from(marking_var)))
def token_expr(self, env, value):
return pyast.E('dot')
def clear_stmt(self, env, marking_var):
return pyast.E("{} = multiset()".format(
self.field.access_from(marking_var)))
def pid_free_hash_expr(self, env, marking_var, ignore):
return pyast.E("{}.pid_pid_free_hash()".format(
self.field.access_from(marking_var)))
def assign_multiset_stmt(self, env, token_var, marking_var):
return pyast.E('{} = {}'.format(token_var.name,
self.field.access_from(marking_var)))
def gen_read_flow(self, env, marking_var):
return pyast.E(self.field.access_from(marking_var))
def add_multiset_stmt(self, env, multiset, marking_var):
update_attr_expr = pyast.E('{}.update'.format(
self.field.access_from(marking_var)))
return pyast.stmt(pyast.Call(func=update_attr_expr, args=[multiset]))
def pid_free_compare_expr(self, env, left_marking_var, right_marking_var,
ignore):
self_place_expr = pyast.E(self.field.access_from(left_marking_var))
other_place_expr = pyast.E(self.field.access_from(right_marking_var))
return pyast.B(self_place_expr).attr('pid_free_pid_compare').call(
[other_place_expr]).ast()
def dump_expr(self, env, marking_var):
return pyast.E("{}.__dump__()".format(
self.field.access_from(marking_var)))
def new_place_stmt(self, env, marking_var):
return pyast.E("{} = 0".format(self.field.access_from(marking_var)))
