def gen_multiset_comparison(checker_env, marking_var, cython_op, left, right):
if left.isPlaceMarking():
left_multiset = multiset_expr_from_place_name(checker_env, marking_var,
left.place_name)
elif left.isMultisetConstant():
left_multiset = build_multiset(left.elements)
elif left.isMultisetPythonExpression():
left_multiset = cyast.E(left.expr)
else:
raise NotImplementedError
if right.isPlaceMarking():
right_multiset = multiset_expr_from_place_name(checker_env,
marking_var,
right.place_name)
elif right.isMultisetConstant():
right_multiset = build_multiset(right.elements)
elif right.isMultisetPythonExpression():
right_multiset = cyast.E(right.expr)
else:
raise NotImplementedError
return cyast.Compare(left=left_multiset,
ops=[cython_op],
comparators=[right_multiset])
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_CheckType(self, node):
type_info = node.type
if type_info.is_AnyType:
return self.compile(node.body)
test = cyast.Call(func=cyast.Name('isinstance'),
args=[
cyast.E(node.variable.name),
cyast.E(self.env.type2str(type_info))
])
return cyast.Builder.If(test=test, body=self.compile(node.body))
def gen_tuple(self, tuple_info):
elts = []
for info in tuple_info:
if info.is_Value:
elts.append(cyast.E(repr(info.raw)))
elif info.is_Variable:
elts.append(cyast.Name(id=info.name))
elif info.is_Tuple:
elts.append(self.gen_tuple(info))
elif info.is_Expression:
elts.append(cyast.E(info.raw))
else:
raise NotImplementedError, info.component.__class__
return cyast.Builder.Tuple(elts=elts)
def compile_CheckTuple(self, node):
tuple_info = node.tuple_info
expr = "isinstance({tuple_name}, tuple) and len({tuple_name}) == {length}"
test = cyast.E(
expr.format(tuple_name=node.tuple_var.name,
length=repr(len(tuple_info))))
return cyast.Builder.If(test, 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 build_multiset(elements):
def zero():
return 0
l = defaultdict(zero)
for e in elements:
l[eval(e)] += 1
return cyast.E("ctypes_ext.MultiSet({!r})".format(dict(l)))
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_Succs(self, node):
body = []
body.extend(self.compile(node.body))
body.append(cyast.E("return " + node.arg_marking_acc_var.name))
f1 = cyast.Builder.FunctionCpDef(
name=node.function_name,
args=self.main_succ_function_args(node),
body=body,
lang=cyast.CpDef(public=True),
returns=cyast.Name("set"),
decl=[
cyast.CVar(name=node.arg_marking_acc_var.name,
type=self.env.type2str(
node.arg_marking_acc_var.type),
init=self.env.marking_set_type.new_marking_set_expr(
self.env))
])
body = [cyast.E("l = ctypes_ext.neco_list_new()")]
body.append(
cyast.For(
target=cyast.to_ast(cyast.E("e")),
iter=cyast.to_ast(cyast.E("succs(m, ctx)")),
body=[
cyast.to_ast(
cyast.stmt(cyast.E("ctypes_ext.__Pyx_INCREF(e)"))),
cyast.Expr(
cyast.Call(
func=cyast.to_ast(
cyast.E("ctypes_ext.neco_list_push_front")),
args=[cyast.to_ast(cyast.E("l")),
cyast.Name("e")],
keywords=[],
starargs=None,
kwargs=None))
]))
body.append(cyast.E("return l"))
f2 = cyast.Builder.FunctionCDef(
name="neco_succs",
args=(cyast.A(
"m", type=self.env.type2str(node.arg_marking_var.type)).param(
"ctx", type=self.env.type2str(node.arg_ctx_var.type))),
body=body,
returns=cyast.Name("ctypes_ext.neco_list_t*"),
decl=[
cyast.CVar(name="l", type="ctypes_ext.neco_list_t*"),
cyast.CVar(name="e", type="Marking")
])
return [f1]
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_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_SuccP(self, node):
env = self.env
env.push_cvar_env()
stmts = [self.compile(node.body)]
decl = CVarSet()
additionnal_decls = self.env.pop_cvar_env()
for var in additionnal_decls:
decl.add(var)
return cyast.Builder.FunctionDef(name=node.function_name,
args=self.succ_function_args(node),
body=stmts,
lang=cyast.CDef(public=False),
returns=cyast.E("void"),
decl=decl)
def generate_pxd(self, env):
cls = cyast.Builder.PublicClassCDef(name="Marking",
bases=[cyast.E("object")],
spec=cyast.type_name_spec(
o="Marking", t="MarkingType"))
################################################################################
# attributes
################################################################################
if self.chunk_manager.packed_bits() > 0:
(attr_name, attr_type,
count) = self.chunk_manager.packed_attribute()
cls.add_decl(
cyast.CVar(attr_name + '[' + str(count) + ']',
type=env.type2str(attr_type)))
for chunk in self.chunk_manager.normal_chunks:
attr_name = chunk.get_attribute_name()
attr_type = chunk.get_cython_type()
cls.add_decl(
cyast.CVar(name=attr_name, type=env.type2str(attr_type)))
# place = chunk_place_map[attr_name]
cls.add_decl(cyast.Comment("{}".format(chunk.hint)))
cls.add_method(
cyast.FunctionDecl(name='copy',
args=cyast.to_ast(
cyast.A("self",
cyast.Name(env.type2str(
self.type)))),
returns=cyast.Name(env.type2str(self.type)),
lang=cyast.CDef()))
return cyast.to_ast(cls)
def normalize_marking_call(self, env, marking_var):
return cyast.stmt(
cyast.Call(func=cyast.E("{}.normalize_pids".format(
marking_var.name)),
args=[]))
def gen_get_pack(self, env, marking_var, pack):
return cyast.E(marking_var.name).attr(self.id_provider.get(pack))
def compile_InitialPid(self, node):
return cyast.E(self.env.type2str(TypeInfo.get('Pid')) + '(1)')
def add_marking_stmt(self, env, markingset_var, marking_var):
return cyast.Call(func=cyast.Attribute(value=cyast.Name(
markingset_var.name),
attr=self.add_attribute_name),
args=[cyast.E(marking_var.name)])
def compile_NormalizeMarking(self, node):
return cyast.stmt(
cyast.Call(func=cyast.E('normalize_pids'),
args=[cyast.E(node.marking_var.name)]))
def compile_Pickle(self, node):
output = StringIO.StringIO()
cPickle.dump(node.obj, output)
pickle_str = output.getvalue()
return cyast.E("cPickle.load(StringIO.StringIO(" + repr(pickle_str) +
"))")
def compile_PyExpr(self, node):
assert isinstance(node.expr, ExpressionInfo)
return cyast.E(node.expr.raw)
def compile_Name(self, node):
return cyast.E(node.name)
def compile_FunctionCall(self, node):
return cyast.E(node.function_name).call(
[self.compile(arg) for arg in node.arguments])