def compile_TokenEnumeration(self, node): marking_type = self.env.marking_type place_type = marking_type.get_place_type_by_name(node.place_name) if hasattr(place_type, 'enumerate'): return place_type.enumerate(self.env, node.marking_var, node.token_var, self.compile(node.body)) arc = node.arc if place_type.provides_by_index_access: index_var = arc.data['index'] size_var = self.env.variable_provider.new_variable() self.env.try_declare_cvar(index_var.name, TypeInfo.get('Int')) self.env.try_declare_cvar(node.token_var.name, node.token_var.type) self.env.try_declare_cvar(size_var.name, TypeInfo.get('Int')) place_size = place_type.get_size_expr(env=self.env, marking_var=node.marking_var) get_token = place_type.get_token_expr(env=self.env, index_expr=index_var, marking_var=node.marking_var, compiled_index=cyast.Name( index_var.name)) return [ cyast.Assign(targets=[cyast.Name(size_var.name)], value=place_size), cyast.Builder.CFor( start=cyast.Num(0), start_op=cyast.LtE(), target=cyast.Name(index_var.name), stop_op=cyast.Lt(), stop=cyast.Name(size_var.name), body=[ cyast.Assign(targets=[cyast.Name(node.token_var.name)], value=get_token), self.compile(node.body) ], orelse=[]) ] else: self.env.try_declare_cvar(node.token_var.name, node.token_var.type) place_type = marking_type.get_place_type_by_name(node.place_name) return cyast.Builder.For(target=cyast.Name(node.token_var.name), iter=place_type.iterable_expr( env=self.env, marking_var=node.marking_var), body=[self.compile(node.body)])
def compile_Init(self, node): env = self.env env.push_cvar_env() new_marking = cyast.Assign( targets=[cyast.Name(node.marking_var.name)], value=self.env.marking_type.new_marking_expr(self.env)) return_stmt = cyast.E("return {}".format(node.marking_var.name)) stmts = [new_marking] stmts.extend(self.compile(node.body)) stmts.append(return_stmt) decl = CVarSet() decl.extend([ cyast.CVar(node.marking_var.name, self.env.type2str(node.marking_var.type)) ]) additionnal_decls = self.env.pop_cvar_env() decl.extend(additionnal_decls) f1 = cyast.Builder.FunctionDef(name=node.function_name, body=stmts, returns=cyast.Name("Marking"), decl=decl) f2 = cyast.Builder.FunctionCDef(name="neco_init", body=stmts, returns=cyast.Name("Marking"), decl=decl) return [f1, f2]
def compile_FlushIn(self, node): destination_place = self.env.marking_type.get_place_type_by_name( node.place_name) return [ cyast.Assign(targets=[cyast.Name(node.token_var.name)], value=destination_place.attribute_expr( self.env, node.marking_var)) ]
def gen_copy(self, env, src_marking, dst_marking, modified_places): """ @param modified_places: @type modified_places: C{} """ nodes = [] nodes.append(cyast.E(dst_marking.name + " = Marking()")) copy_attributes = set() assign_attributes = set() for place_type in self.place_types.itervalues(): if place_type.info in modified_places: copy_attributes.add(place_type.get_attribute_name()) else: assign_attributes.add(place_type.get_attribute_name()) # a place in copy from a pack forces the copy of the whole pack assign_attributes = assign_attributes - copy_attributes copied = set() # copy packed if self.chunk_manager.packed_bits() > 0: attr_name, _, count = self.chunk_manager.packed_attribute() copied.add(attr_name) for i in range(count): target_expr = cyast.E('{object}.{attribute}[{index!s}]'.format( object=dst_marking.name, attribute=attr_name, index=i)) value_expr = cyast.E('{object}.{attribute}[{index!s}]'.format( object=src_marking.name, attribute=attr_name, index=i)) nodes.append( cyast.Assign(targets=[target_expr], value=value_expr)) # copy modified attributes for place_type in self.place_types.itervalues(): attr_name = place_type.get_attribute_name() if attr_name in copied: continue if attr_name in copy_attributes: nodes.append( place_type.copy_stmt(env, dst_marking, src_marking)) nodes.append( cyast.Comment('copy: {} {!s}'.format( place_type.info.name, place_type.info.type))) elif attr_name in assign_attributes: nodes.append( place_type.light_copy_stmt(env, dst_marking, src_marking)) nodes.append( cyast.Comment('assign: {} {!s}'.format( place_type.info.name, place_type.info.type))) copied.add(attr_name) return cyast.to_ast(nodes)
def compile_InitGeneratorPlace(self, node): marking_type = self.env.marking_type generator_place = marking_type.get_place_type_by_name(GENERATOR_PLACE) initial_pid_var = self.env.variable_provider.new_variable( variable_type=TypeInfo.get('Pid')) self.env.try_declare_cvar(initial_pid_var.name, initial_pid_var.type) assign = cyast.Assign(targets=[cyast.E(initial_pid_var.name)], value=self.compile_InitialPid(None)) return [ assign, generator_place.add_pid_stmt(self.env, initial_pid_var, node.marking_var) ]
def compile_Match(self, node): tuple_info = node.tuple_info seq = [] component_names = [ token_info.data['local_variable'].name for token_info in tuple_info ] seq.append( cyast.Assign(targets=[ cyast.Tuple([cyast.E(name) for name in component_names]) ], value=cyast.Name( tuple_info.data['local_variable'].name))) cur = None for component in tuple_info.components: if component.is_Value: # self.try_declare_cvar(component.data['local_variable'].name, component.type) n = cyast.Builder.If( test=cyast.Builder.Compare( left=cyast.E(component.data['local_variable'].name), ops=[cyast.Eq()], comparators=[cyast.E(repr(component.raw)) ]), # TO DO unify value & pickle orelse=[]) if cur == None: cur = n seq.append(n) else: cur.body = [n] cur = n elif component.is_Variable: self.env.try_declare_cvar( component.data['local_variable'].name, component.type) if cur != None: cur.body = [self.compile(node.body)] else: seq.append(self.compile(node.body)) return seq
def compile_MultiTokenEnumeration(self, node): place_type = self.env.marking_type.get_place_type_by_name( node.place_name) base = None current = None if place_type.provides_by_index_access: for sub_arc in node.multiarc.sub_arcs: variable = sub_arc.data['local_variable'] index_var = sub_arc.data['index'] self.env.try_declare_cvar(index_var.name, TypeInfo.get('Int')) self.env.try_declare_cvar(variable.name, place_type.token_type) assign = cyast.Assign(targets=[cyast.Name(variable.name)], value=place_type.get_token_expr( self.env, index_expr=index_var, marking_var=node.marking_var, compiled_index=cyast.Name( index_var.name))) enumeration = cyast.For(target=cyast.Name(index_var.name), iter=cyast.Call( func=cyast.Name('range'), args=[ cyast.Num(0), place_type.get_size_expr( self.env, node.marking_var) ]), body=[assign]) if base == None: current = enumeration base = enumeration else: current.body.append(enumeration) current = enumeration else: # no index access for sub_arc in node.multiarc.sub_arcs: variable = sub_arc.data['local_variable'] index_var = sub_arc.data['index'] init = cyast.Assign(targets=[cyast.Name(index_var.name)], value=cyast.Num(0)) self.env.try_declare_cvar(index_var.name, TypeInfo.get('Int')) self.env.try_declare_cvar(variable.name, place_type.token_type) enumeration = cyast.For(target=cyast.Name(variable.name), iter=place_type.iterable_expr( env=self.env, marking_var=node.marking_var), body=[ cyast.AugAssign(target=cyast.Name( index_var.name), op=cyast.Add(), value=cyast.Num(1)) ]) if base == None: current = [init, enumeration] base = [init, enumeration] else: current[1].body.append([init, enumeration]) current = [init, enumeration] indices = [sub_arc.data['index'] for sub_arc in node.multiarc.sub_arcs] inner_base, inner = self.gen_different(indices) if isinstance(current, list): current[1].body.append(inner_base) else: current.body.append(inner_base) current = inner current.body.extend([self.compile(node.body)]) return base
def compile_Assign(self, node): self.env.try_declare_cvar(node.variable.name, node.variable.type) return cyast.Assign(targets=[cyast.Name(node.variable.name)], value=self.compile(node.expr))