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 compile_InitialPid(self, node):
return cyast.E(self.env.type2str(TypeInfo.get('Pid')) + '(1)')
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):
