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)))