def __init__(self, config): coretypes.MarkingType.__init__(self, TypeInfo.register_type("Marking"), TypeInfo.register_type("MarkingSet"), config) # id provider for class attributes self.id_provider = utils.NameProvider( ) # used to produce attribute names self._process_place_types = {} #self.packing_enabled = config.bit_packing self.config = config self.chunk_manager = ChunkManager(self.id_provider.new(base="_packed")) self.add_method_generator(priv.mrkmethods.InitGenerator()) self.add_method_generator(priv.mrkmethods.DeallocGenerator()) self.add_method_generator(priv.mrkmethods.CopyGenerator()) self.add_method_generator(priv.mrkmethods.DumpExprGenerator()) self.add_method_generator(priv.mrkmethods.RichcmpGenerator()) self.add_method_generator(priv.mrkmethods.HashGenerator()) self._C_function_generators = [] self.add_C_function_generator(priv.mrkfunctions.DumpGenerator()) self.add_C_function_generator(priv.mrkfunctions.CopyGenerator()) self.add_C_function_generator(priv.mrkfunctions.CompareGenerator()) self.add_C_function_generator(priv.mrkfunctions.HashGenerator()) if config.normalize_pids: self.add_C_function_generator( priv.mrkpidfunctions.UpdatePidsGenerator()) self.add_C_function_generator( priv.mrkpidfunctions.NormalizePidsGenerator())
def __init__(self, config): coretypes.MarkingType.__init__(self, TypeInfo.register_type('Marking'), TypeInfo.register_type('set'), config) self.id_provider = utils.NameProvider() self._process_place_types = {} self.fields = set() self.create_field('_hash', TypeInfo.get('Int')) self.add_method_generator(priv.mrkmethods.InitGenerator()) self.add_method_generator(priv.mrkmethods.CopyGenerator()) self.add_method_generator(priv.mrkmethods.ReprGenerator()) self.add_method_generator(priv.mrkmethods.DumpGenerator()) self.add_method_generator(priv.mrkmethods.LineDumpGenerator()) if self.config.normalize_pids: self.add_method_generator(priv.mrkpidmethods.EqGenerator()) self.add_method_generator(priv.mrkpidmethods.HashGenerator()) self.add_method_generator(priv.mrkpidmethods.UpdatePidsGenerator()) self.add_method_generator(priv.mrkpidmethods.BuildPidTreeGenerator()) self.add_method_generator(priv.mrkpidmethods.PidFreeCmpGenerator()) self.add_method_generator(priv.mrkpidmethods.PidFreeHashGenerator()) else: self.add_method_generator(priv.mrkmethods.EqGenerator()) self.add_method_generator(priv.mrkmethods.HashGenerator())
def __init__(self, config): coretypes.MarkingType.__init__(self, TypeInfo.register_type('Marking'), TypeInfo.register_type('set'), config) self.id_provider = utils.NameProvider() self._process_place_types = {} self.fields = set() self.create_field('_hash', TypeInfo.get('Int')) self.add_method_generator(priv.mrkmethods.InitGenerator()) self.add_method_generator(priv.mrkmethods.CopyGenerator()) self.add_method_generator(priv.mrkmethods.ReprGenerator()) self.add_method_generator(priv.mrkmethods.DumpGenerator()) self.add_method_generator(priv.mrkmethods.LineDumpGenerator()) if self.config.normalize_pids: self.add_method_generator(priv.mrkpidmethods.EqGenerator()) self.add_method_generator(priv.mrkpidmethods.HashGenerator()) self.add_method_generator(priv.mrkpidmethods.UpdatePidsGenerator()) self.add_method_generator( priv.mrkpidmethods.BuildPidTreeGenerator()) self.add_method_generator(priv.mrkpidmethods.PidFreeCmpGenerator()) self.add_method_generator( priv.mrkpidmethods.PidFreeHashGenerator()) else: self.add_method_generator(priv.mrkmethods.EqGenerator()) self.add_method_generator(priv.mrkmethods.HashGenerator())
def __init__(self, place_info, marking_type): coretypes.OneSafePlaceType.__init__(self, place_info=place_info, marking_type=marking_type, type_info=TypeInfo.get('AnyType'), token_type=TypeInfo.get('AnyType')) self.field = marking_type.create_field(self, place_info.type)
def generate(self, env): marking_type = env.marking_type vp = VariableProvider() self_var = vp.new_variable(marking_type.type, name='self') tree_var = vp.new_variable(TypeInfo.get('AnyType'), name='tree') token_var = vp.new_variable(TypeInfo.get('AnyType'), name='token') pid_dict_var = vp.new_variable(TypeInfo.get('Dict'), name='pid_dict') tmp_pid_var = vp.new_variable(TypeInfo.get('Pid'), name='tpid') tmp_marking_var = vp.new_variable(TypeInfo.get('Marking'), name='tmkr') function = pyast.FunctionDef(name='buildPidTree', args=pyast.A(self_var.name).ast()) body = [] body.append( pyast.E("{} = defaultdict(Marking)".format(pid_dict_var.name))) body.append(pyast.E("{} = PidTree(0)".format(tree_var.name))) # build the tree for name, place_type in marking_type.place_types.iteritems(): if not place_type.allow_pids: continue if name == GENERATOR_PLACE: enum_body = [ pyast.If(test=pyast.E('not {}.has_key({}[0])'.format( pid_dict_var.name, token_var.name)), body=[ pyast.E("{}[ {}[0] ] = Marking(True)".format( pid_dict_var.name, token_var.name)) ]), pyast. E("{}[ Pid.from_list({}[0].data + [{}[1] + 1]) ] = 'next_pid'" .format(pid_dict_var.name, token_var.name, token_var.name)) ] body.append( place_type.enumerate(env, self_var, token_var, enum_body)) else: body.append( place_type.extract_pids(env, self_var, pid_dict_var)) # body.append(pyast.E("print {}".format(pid_dict_var.name))) body.append( pyast.For(target=pyast.E('{}, {}'.format(tmp_pid_var.name, tmp_marking_var.name)), iter=pyast.E( ('{}.iteritems()'.format(pid_dict_var.name))), body=[ pyast.stmt( pyast.E('{}.add_marking({}, {})'.format( tree_var.name, tmp_pid_var.name, tmp_marking_var.name))) ])) body.append(pyast.E("return {}".format(tree_var.name))) function.body = body return function
def gen_main_check_function(checker_env, id_prop_map): function_name = "neco_check" builder = cyast.Builder() variable_provider = VariableProvider() checker_env.push_cvar_env() checker_env.push_variable_provider(variable_provider) marking_var = variable_provider.new_variable( variable_type=checker_env.marking_type.type) atom_var = variable_provider.new_variable( variable_type=TypeInfo.get('Int')) builder.begin_FunctionCDef( name=function_name, args=(cyast.A(marking_var.name, type=checker_env.type2str(marking_var.type)).param( atom_var.name, type=checker_env.type2str(TypeInfo.get('Int')))), returns=cyast.Name("int"), decl=[], public=True, api=True) for (i, (ident, _)) in enumerate(id_prop_map.iteritems()): if i == 0: builder.begin_If( test=cyast.Compare(left=cyast.Name(atom_var.name), ops=[cyast.Eq()], comparators=[cyast.Num(ident)])) else: builder.begin_Elif( test=cyast.Compare(left=cyast.Name(atom_var.name), ops=[cyast.Eq()], comparators=[cyast.Num(ident)])) builder.emit_Return( checker_env.get_check_function("check_{}".format(ident)).call( [cyast.Name(marking_var.name)])) for _ in id_prop_map: builder.end_If() builder.emit( cyast.Print(dest=cyast.E('sys.stderr'), values=[ cyast.Str(s='!W! invalid proposition identifier'), cyast.Name(atom_var.name) ], nl=True)) builder.emit_Return(cyast.Num(n=0)) builder.end_FunctionDef() tree = cyast.to_ast(builder) checker_env.register_check_function(function_name, FunctionWrapper(function_name, tree)) return tree
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 generate(self, env): marking_type = env.marking_type vp = VariableProvider() self_var = vp.new_variable(marking_type.type, name='self') tree_var = vp.new_variable(TypeInfo.get('AnyType'), name='tree') pid_dict_var = vp.new_variable(TypeInfo.get('Dict'), name='pid_dict') function = cyast.Builder.FunctionCDef(name='normalize_pids', args=cyast.A(self_var.name, type=env.type2str(self_var.type)), returns=cyast.E('void')) body = [] body.append(cyast.Assign(targets=[cyast.Name(id=tree_var.name)], value=cyast.Call(func=cyast.Name(stubs['create_pid_tree']), args=[]))) # build the tree for name, place_type in marking_type.place_types.iteritems(): if not place_type.allows_pids: continue if name == GENERATOR_PLACE: body.append(cyast.stmt(cyast.Call(func=cyast.Name(stubs['generator_place_update_pid_tree']), args=[ place_type.place_expr(env, self_var), cyast.Name(id=tree_var.name) ] ))) else: body.append( add_pids_to_tree(env, place_type, self_var, tree_var)) # normalize tree and get dict body.append(cyast.Assign(targets=[cyast.Name(id=pid_dict_var.name)], value=cyast.Call(func=cyast.Name(stubs['normalize_pid_tree']), args=[cyast.Name(tree_var.name)]))) # update tokens with new pids for name, place_type in marking_type.place_types.iteritems(): if not place_type.allows_pids: continue if name == GENERATOR_PLACE: body.append( cyast.Assign(targets=[ place_type.place_expr(env, self_var) ], value=cyast.Call(func=cyast.Name(stubs['generator_place_update_pids']), args=[place_type.place_expr(env, self_var), cyast.Name(pid_dict_var.name)]) ) ) else: body.append( place_type.update_pids_stmt(env, self_var, pid_dict_var) ) if not body: body = [cyast.Pass()] function.body = body function.body = [cyast.Pass()] return function
def __init__(self, place_info, marking_type): """ @param p)lace_info: @type_info place_info: C{} @param marking_type: @type_info marking_type: C{} """ coretypes.BTPlaceType.__init__(self, place_info=place_info, marking_type=marking_type, type_info=TypeInfo.get('Int'), token_type=TypeInfo.get('Int')) self.field = marking_type.create_field(self, TypeInfo.get('Int'))
def generate(self, env): marking_type = env.marking_type builder = cyast.Builder() left_marking_name = 'self' right_marking_name = 'other' op_name = 'op' builder.begin_FunctionDef( name='__richcmp__', args=(cyast.A('self', type=env.type2str(marking_type.type)).param( right_marking_name, type=env.type2str(marking_type.type)).param( op_name, type=env.type2str(TypeInfo.get('Int'))))) builder.emit_Return( cyast.Compare(left=cyast.Call( func=cyast.Name('neco_marking_compare'), args=[ cyast.Name(left_marking_name), cyast.Name(right_marking_name) ]), ops=[cyast.Eq()], comparators=[cyast.Num(0)])) builder.end_FunctionDef() return cyast.to_ast(builder)
def multiset_expr_from_place_name(checker_env, marking_var, place_name): place_type = checker_env.marking_type.get_place_type_by_name(place_name) multiset = place_type.multiset_expr(checker_env, marking_var) if place_type.type != TypeInfo.get('MultiSet'): print >> sys.stderr, "[W] using multiset fallback for {}, this may result in slow execution times".format( place_name) return multiset
def __init__(self, place_info, marking_type): """ Build a new place. @param place_info: @type_info place_info: C{} @param marking_type: @type_info marking_type: C{} """ self._counter = 0 self._places = {} coretypes.PlaceType.__init__(self, place_info=place_info, marking_type=marking_type, type_info=TypeInfo.get('Int'), token_type=TypeInfo.get('Int')) self.field = marking_type.create_field(self, TypeInfo.get('Int'))
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 __init__(self, place_info, marking_type): coretypes.ObjectPlaceType.__init__(self, place_info=place_info, marking_type=marking_type, type_info=TypeInfo.get('MultiSet'), token_type=place_info.type) self.field = marking_type.create_field(self, place_info.type)
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 generate(self, env): marking_type = env.marking_type vp = VariableProvider() self_var = vp.new_variable(marking_type.type, name='self') tree_var = vp.new_variable(TypeInfo.get('AnyType'), name='tree') token_var = vp.new_variable(TypeInfo.get('AnyType'), name='token') pid_dict_var = vp.new_variable(TypeInfo.get('Dict'), name='pid_dict') tmp_pid_var = vp.new_variable(TypeInfo.get('Pid'), name='tpid') tmp_marking_var = vp.new_variable(TypeInfo.get('Marking'), name='tmkr') function = pyast.FunctionDef(name = 'buildPidTree', args = pyast.A(self_var.name).ast()) body = [] body.append( pyast.E("{} = defaultdict(Marking)".format(pid_dict_var.name)) ) body.append( pyast.E("{} = PidTree(0)".format(tree_var.name)) ) # build the tree for name, place_type in marking_type.place_types.iteritems(): if not place_type.allow_pids: continue if name == GENERATOR_PLACE: enum_body = [ pyast.If(test=pyast.E('not {}.has_key({}[0])'.format(pid_dict_var.name, token_var.name)), body=[pyast.E("{}[ {}[0] ] = Marking(True)".format(pid_dict_var.name, token_var.name))]), pyast.E("{}[ Pid.from_list({}[0].data + [{}[1] + 1]) ] = 'next_pid'".format(pid_dict_var.name, token_var.name, token_var.name)) ] body.append( place_type.enumerate( env, self_var, token_var, enum_body ) ) else: body.append( place_type.extract_pids(env, self_var, pid_dict_var) ) # body.append(pyast.E("print {}".format(pid_dict_var.name))) body.append(pyast.For(target=pyast.E('{}, {}'.format(tmp_pid_var.name, tmp_marking_var.name)), iter=pyast.E(('{}.iteritems()'.format(pid_dict_var.name))), body=[pyast.stmt(pyast.E('{}.add_marking({}, {})'.format(tree_var.name, tmp_pid_var.name, tmp_marking_var.name)))])) body.append(pyast.E("return {}".format(tree_var.name))) function.body = body return function
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 __init__(self, reserved_packed_name): ''' Constructor ''' self.packed_name = reserved_packed_name self.named_chunks = {} self.packed_chunks = [] # simple list holding packed memory chunks self.normal_chunks = [] # simple list holding memory chunks self.packed_type = TypeInfo.get('UnsignedChar') self.packed_field_size = bits_sizeof(self.packed_type) self.ordered_chunks = [] self.packed_field_count = 0
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 gen_main_check_function(checker_env, id_prop_map): function_name = "neco_check" builder = cyast.Builder() variable_provider = VariableProvider() checker_env.push_cvar_env() checker_env.push_variable_provider(variable_provider) marking_var = variable_provider.new_variable(variable_type = checker_env.marking_type.type) atom_var = variable_provider.new_variable(variable_type = TypeInfo.get('Int')) builder.begin_FunctionCDef(name = function_name, args = (cyast.A(marking_var.name, type = checker_env.type2str(marking_var.type)) .param(atom_var.name, type = checker_env.type2str(TypeInfo.get('Int')))), returns = cyast.Name("int"), decl = [], public = True, api = True) for (i, (ident, _)) in enumerate(id_prop_map.iteritems()): if i == 0: builder.begin_If(test = cyast.Compare(left = cyast.Name(atom_var.name), ops = [ cyast.Eq() ], comparators = [ cyast.Num(ident) ])) else: builder.begin_Elif(test = cyast.Compare(left = cyast.Name(atom_var.name), ops = [ cyast.Eq() ], comparators = [ cyast.Num(ident) ])) builder.emit_Return(checker_env.get_check_function("check_{}".format(ident)).call([cyast.Name(marking_var.name)])) for _ in id_prop_map: builder.end_If() builder.emit(cyast.Print(dest = cyast.E('sys.stderr'), values = [cyast.Str(s = '!W! invalid proposition identifier'), cyast.Name(atom_var.name)], nl = True)) builder.emit_Return(cyast.Num(n = 0)) builder.end_FunctionDef() tree = cyast.to_ast(builder) checker_env.register_check_function(function_name, FunctionWrapper(function_name, tree)) return tree
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 __init__(self, config, net_info, word_set, marking_type, marking_set_type): core.CompilingEnvironment.__init__(self, config, net_info) self._word_set = word_set self._marking_type = marking_type self._marking_set_type = marking_set_type self._pyx_declarations = [] self._ending_pyx_declarations = [] self._pxd_declarations = [] self._c_declarations = [] self._cvar_decl = [] self._variable_providers = [] self._registered_cython_types = dict() # register types self.register_cython_type(TypeInfo.get('Bool'), 'short') self.register_cython_type(TypeInfo.get('Char'), 'char') self.register_cython_type(TypeInfo.get('Int'), 'int') self.register_cython_type(TypeInfo.get('Short'), 'short') self.register_cython_type(TypeInfo.get('IntPlace'), from_neco_lib('TGenericPlaceType[int]*')) self.register_cython_type(TypeInfo.get('MultiSet'), 'ctypes_ext.MultiSet') self.register_cython_type(TypeInfo.get('UnsignedChar'), 'unsigned char') self.register_cython_type(TypeInfo.get('UnsignedInt'), 'unsigned int') self.register_cython_type(TypeInfo.get('set'), 'set') self.register_cython_type(TypeInfo.get('dict'), 'dict') self.register_cython_type(TypeInfo.get('NecoCtx'), 'NecoCtx') if marking_type.config.normalize_pids: self.register_cython_type(TypeInfo.get('Pid'), from_neco_lib('Pid')) else: self.register_cython_type(TypeInfo.get('Pid'), 'object') self.register_cython_type(TypeInfo.get('PidPlace'), from_neco_lib('TGenericPlaceType[' + from_neco_lib('Pid') + ']*')) self.register_cython_type(TypeInfo.get('GeneratorPlace'), from_neco_lib('TGeneratorPlaceType[' + from_neco_lib('Pid') + ', int]*'))
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_InitialPid(self, node): return cyast.E(self.env.type2str(TypeInfo.get('Pid')) + '(1)')
def __str__(self): return str( self.expr ) + " is of type " + self.type + " but type " + self.expected + " was expected." def from_neco_lib(f): return "ctypes_ext.%s" % f ################################################################################ # new types TypeInfo.register_type("MultiSet") TypeInfo.register_type("IntPlace") TypeInfo.register_type("Char") TypeInfo.register_type("Short") TypeInfo.register_type("UnsignedInt") TypeInfo.register_type("UnsignedChar") TypeInfo.register_type("PidPlace") TypeInfo.register_type("GeneratorPlace") ################################################################################ class CVars(object): def __init__(self, env, initial=None): self.env = env
self.expr = expr self.type = got self.expected = expected def __str__(self): return str(self.expr) + " is of type " + self.type + " but type " + self.expected + " was expected." def from_neco_lib(f): return "ctypes_ext.%s" % f ################################################################################ # new types TypeInfo.register_type("MultiSet") TypeInfo.register_type("IntPlace") TypeInfo.register_type("Char") TypeInfo.register_type("Short") TypeInfo.register_type("UnsignedInt") TypeInfo.register_type("UnsignedChar") TypeInfo.register_type("PidPlace") TypeInfo.register_type("GeneratorPlace") ################################################################################ class CVars(object): def __init__(self, env, initial = None): self.env = env
def __init__(self, config, net_info, word_set, marking_type, marking_set_type): core.CompilingEnvironment.__init__(self, config, net_info) self._word_set = word_set self._marking_type = marking_type self._marking_set_type = marking_set_type self._pyx_declarations = [] self._ending_pyx_declarations = [] self._pxd_declarations = [] self._c_declarations = [] self._cvar_decl = [] self._variable_providers = [] self._registered_cython_types = dict() # register types self.register_cython_type(TypeInfo.get('Bool'), 'short') self.register_cython_type(TypeInfo.get('Char'), 'char') self.register_cython_type(TypeInfo.get('Int'), 'int') self.register_cython_type(TypeInfo.get('Short'), 'short') self.register_cython_type(TypeInfo.get('IntPlace'), from_neco_lib('TGenericPlaceType[int]*')) self.register_cython_type(TypeInfo.get('MultiSet'), 'ctypes_ext.MultiSet') self.register_cython_type(TypeInfo.get('UnsignedChar'), 'unsigned char') self.register_cython_type(TypeInfo.get('UnsignedInt'), 'unsigned int') self.register_cython_type(TypeInfo.get('set'), 'set') self.register_cython_type(TypeInfo.get('dict'), 'dict') self.register_cython_type(TypeInfo.get('NecoCtx'), 'NecoCtx') if marking_type.config.normalize_pids: self.register_cython_type(TypeInfo.get('Pid'), from_neco_lib('Pid')) else: self.register_cython_type(TypeInfo.get('Pid'), 'object') self.register_cython_type( TypeInfo.get('PidPlace'), from_neco_lib('TGenericPlaceType[' + from_neco_lib('Pid') + ']*')) self.register_cython_type( TypeInfo.get('GeneratorPlace'), from_neco_lib('TGeneratorPlaceType[' + from_neco_lib('Pid') + ', int]*'))
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 generate(self, env): marking_type = env.marking_type vp = VariableProvider() self_var = vp.new_variable(marking_type.type, name='self') tree_var = vp.new_variable(TypeInfo.get('AnyType'), name='tree') pid_dict_var = vp.new_variable(TypeInfo.get('Dict'), name='pid_dict') function = cyast.Builder.FunctionCDef(name='normalize_pids', args=cyast.A(self_var.name, type=env.type2str( self_var.type)), returns=cyast.E('void')) body = [] body.append( cyast.Assign(targets=[cyast.Name(id=tree_var.name)], value=cyast.Call(func=cyast.Name( stubs['create_pid_tree']), args=[]))) # build the tree for name, place_type in marking_type.place_types.iteritems(): if not place_type.allows_pids: continue if name == GENERATOR_PLACE: body.append( cyast.stmt( cyast.Call(func=cyast.Name( stubs['generator_place_update_pid_tree']), args=[ place_type.place_expr(env, self_var), cyast.Name(id=tree_var.name) ]))) else: body.append( add_pids_to_tree(env, place_type, self_var, tree_var)) # normalize tree and get dict body.append( cyast.Assign(targets=[cyast.Name(id=pid_dict_var.name)], value=cyast.Call(func=cyast.Name( stubs['normalize_pid_tree']), args=[cyast.Name(tree_var.name)]))) # update tokens with new pids for name, place_type in marking_type.place_types.iteritems(): if not place_type.allows_pids: continue if name == GENERATOR_PLACE: body.append( cyast.Assign( targets=[place_type.place_expr(env, self_var)], value=cyast.Call(func=cyast.Name( stubs['generator_place_update_pids']), args=[ place_type.place_expr( env, self_var), cyast.Name(pid_dict_var.name) ]))) else: body.append( place_type.update_pids_stmt(env, self_var, pid_dict_var)) if not body: body = [cyast.Pass()] function.body = body function.body = [cyast.Pass()] return function
def generate(self, env): marking_type = env.marking_type vp = VariableProvider() builder = cyast.Builder() left_marking_var = vp.new_variable(marking_type.type, "self") right_marking_var = vp.new_variable(marking_type.type, "other") builder.begin_FunctionCDef(name = "neco_marking_compare", args = (cyast.A("self", type = env.type2str(marking_type.type)) .param(right_marking_var.name, type = env.type2str(marking_type.type))), returns = cyast.E("int"), public = True, api = True, decl = [ cyast.Builder.CVar(name = 'tmp', type = env.type2str(TypeInfo.get('Int'))) ]) compared = set() tests = [] if marking_type.chunk_manager.packed_bits() > 0: attr, _, count = marking_type.chunk_manager.packed_attribute() compared.add(attr) for index in range(0, count): left = cyast.E("{object}.{attribute}[{index}]".format(object = left_marking_var.name, attribute = attr, index = index)) right = cyast.E("{object}.{attribute}[{index}]".format(object = right_marking_var.name, attribute = attr, index = index)) tests.append(cyast.BinOp(left = left, op = cyast.Sub(), right = right)) for place_type in marking_type.place_types.itervalues(): if place_type.get_attribute_name() in compared: continue tests.append(place_type.compare_expr(env, left_marking_var = left_marking_var, right_marking_var = right_marking_var) ) tests.reverse() _gen_C_compare_aux(builder, tests) builder.end_FunctionDef() return cyast.to_ast(builder)
def produce_and_compile_pyx(checker_env, id_prop_map): config = checker_env.config marking_type = checker_env.marking_type checker_env.register_cython_type(marking_type.type, 'net.Marking') TypeInfo.register_type('Marking') # functions = [] for identifier, prop in id_prop_map.iteritems(): gen_check_function(checker_env, identifier, prop) # updates env gen_main_check_function(checker_env, id_prop_map) # updates env # checker_module = cyast.Module(body = functions) base_dir = "build/" try: os.mkdir(base_dir) except OSError: pass f = open(base_dir + "checker.pyx", "w") f.write("cimport net\n") f.write("import net\n") f.write("cimport neco.ctypes.ctypes_ext as ctypes_ext\n") f.write("import sys, StringIO\n") f.write("import cPickle as pickle\n") f.write("from snakes.nets import *\n") for imp in config.checker_imports: f.write("from {} import *\n".format(imp)) for function_ast in checker_env.is_fireable_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.get_all_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.get_any_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.functions(): cyast.Unparser(function_ast, f) f.close() search_paths = config.search_paths ctypes_source = search_file("ctypes.cpp", search_paths) macros = [] if config.normalize_pids: macros.append(( 'USE_PIDS', '1', )) # # remove -Wstrict-prototypes since we compile using g++ # (opt, ) = get_config_vars('OPT') os.environ['OPT'] = " ".join(flag for flag in opt.split() if flag != '-Wstrict-prototypes') # # compile checker # setup(name=base_dir + "checker.pyx", cmdclass={'build_ext': build_ext}, ext_modules=[ Extension("checker", [base_dir + "checker.pyx", ctypes_source], include_dirs=search_paths + [base_dir], extra_compile_args=[], extra_link_args=[], define_macros=macros, library_dirs=search_paths + [base_dir], language='c++') ], script_args=["build_ext", "--inplace"], options={'build': { 'build_base': 'build' }})
def multiset_expr_from_place_name(checker_env, marking_var, place_name): place_type = checker_env.marking_type.get_place_type_by_name(place_name) multiset = place_type.multiset_expr(checker_env, marking_var) if place_type.type != TypeInfo.get('MultiSet'): print >> sys.stderr, "[W] using multiset fallback for {}, this may result in slow execution times".format(place_name) return multiset
def token_type(self): """ Get python type of the stored token """ return TypeInfo.get('Int')
if type_info.is_BlackToken: return "BlackToken" elif type_info.is_Bool: return "bool" elif type_info.is_Int: return "int" elif type_info.is_String: return "str" else: return str(type_info) elif type_info.is_TupleType: return "tuple" else: return "object" TypeInfo.register_type("Multiset") class Field(object): def __init__(self, name, field_type): self.name = name self.type = field_type def access_from(self, marking_var): return "{}.{}".format(marking_var.name, self.name) def access_from_str(self, marking_str): return "{}.{}".format(marking_str, self.name) class StaticMarkingType(coretypes.MarkingType): """ Python marking type implementation, places as class attributes. """
def produce_and_compile_pyx(checker_env, id_prop_map): config = checker_env.config marking_type = checker_env.marking_type checker_env.register_cython_type(marking_type.type, 'net.Marking') TypeInfo.register_type('Marking') # functions = [] for identifier, prop in id_prop_map.iteritems(): gen_check_function(checker_env, identifier, prop) # updates env gen_main_check_function(checker_env, id_prop_map) # updates env # checker_module = cyast.Module(body = functions) base_dir = "build/" try: os.mkdir(base_dir) except OSError: pass f = open(base_dir + "checker.pyx", "w") f.write("cimport net\n") f.write("import net\n") f.write("cimport neco.ctypes.ctypes_ext as ctypes_ext\n") f.write("import sys, StringIO\n") f.write("import cPickle as pickle\n") f.write("from snakes.nets import *\n") for imp in config.checker_imports: f.write("from {} import *\n".format(imp)) for function_ast in checker_env.is_fireable_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.get_all_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.get_any_functions(): cyast.Unparser(function_ast, f) for function_ast in checker_env.functions(): cyast.Unparser(function_ast, f) f.close() search_paths = config.search_paths ctypes_source = search_file("ctypes.cpp", search_paths) macros = [] if config.normalize_pids: macros.append(('USE_PIDS', '1',)) # # remove -Wstrict-prototypes since we compile using g++ # (opt,) = get_config_vars('OPT') os.environ['OPT'] = " ".join( flag for flag in opt.split() if flag != '-Wstrict-prototypes' ) # # compile checker # setup(name = base_dir + "checker.pyx", cmdclass = {'build_ext': build_ext}, ext_modules = [Extension("checker", [base_dir + "checker.pyx", ctypes_source], include_dirs = search_paths + [base_dir], extra_compile_args = [], extra_link_args = [], define_macros = macros, library_dirs = search_paths + [base_dir], language = 'c++')], script_args = ["build_ext", "--inplace"], options = { 'build': { 'build_base': 'build' } })
return "BlackToken" elif type_info.is_Bool: return "bool" elif type_info.is_Int: return "int" elif type_info.is_String: return "str" else: return str(type_info) elif type_info.is_TupleType: return "tuple" else: return "object" TypeInfo.register_type("Multiset") class Field(object): def __init__(self, name, field_type): self.name = name self.type = field_type def access_from(self, marking_var): return "{}.{}".format(marking_var.name, self.name) def access_from_str(self, marking_str): return "{}.{}".format(marking_str, self.name) class StaticMarkingType(coretypes.MarkingType):