def parse_typename(tname, source):
if len(tname) == 0:
raise utils.PtpException("Missing type", source)
try:
return typename.parseString(tname, parseAll=True)
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def parse_edge_expression(string, source):
if len(string.strip()) == 0:
raise utils.PtpException("Missing expression", source)
try:
inscriptions = edge_expr.parseString(string, parseAll=True)
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def load_project(element, target_envs, build_target="build", load_nets=True):
target_env = utils.xml_str(element, "target_env")
if target_env not in target_envs:
raise utils.PtpException("Unknown target environment")
description = element.find("description").text
name = utils.xml_str(element, "name")
root_directory = utils.xml_str(element, "root-directory")
p = Project(name,
root_directory,
target_envs[target_env],
description)
p.build_target = build_target
p.library_rpc = utils.xml_bool(element, "library-rpc", False)
p.library_octave = utils.xml_bool(element, "library-octave", False)
p.tracing = utils.xml_bool(element, "tracing", False)
load_configuration(element.find("configuration"), p)
if not load_nets:
return p
nets = [ (e, load_net(e, p)) for e in element.findall("net") ]
p.nets = [ net for e, net in nets ]
for e, net in nets:
load_net_content(e, p, net)
return p
def write_parameters(builder):
for p in builder.project.get_parameters():
policy = "ca::PARAMETER_" + p.get_policy().upper()
if p.get_policy() == "mandatory":
default = ""
else:
default = ", " + p.default
if p.get_type() == "int":
builder.line("ca::ParameterInt param::{0}({1}, {2}, {3}{4});",
p.name,
const_string(p.name),
const_string(p.description),
policy,
default)
elif p.get_type() == "double":
builder.line("ca::ParameterDouble param::{0}({1}, {2}, {3}{4});",
p.name,
const_string(p.name),
const_string(p.description),
policy,
default)
elif p.get_type() == "std::string":
builder.line("ca::ParameterString param::{0}({1}, {2}, {3}{4});",
p.name,
const_string(p.name),
const_string(p.description),
policy,
default)
else:
utils.PtpException("Invalid type '{0}' for parameter '{1}'".format(
p.get_type(), p.name))
def parse_init_expression(string, source):
if string.strip() == "":
return (None, None)
try:
return init_expression.parseString(string, parseAll=True)[0]
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def split_expressions(string, source):
if string.strip() == "":
return []
try:
return expressions.parseString(string, parseAll=True)
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def run(self):
builder = build.Builder(self.project,
os.path.join("/tmp", self.project.get_name() + ".h"))
build.write_header_file(builder)
builder.write_to_file()
tester = base.tester.Tester()
tester.prepare_writer = self.prepare_writer
tester.args = [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CAILIE_INCLUDE_DIR),
"-I", self.project.root_directory ]
if self.project.get_build_with_octave():
import ptp # To avoid cyclic import
tester.args += [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CAOCTAVE_INCLUDE_DIR) ]
tester.args += ptp.get_config("Octave", "INCFLAGS").split()
if self.project.build_target == "simrun":
tester.args += [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CASIMRUN_INCLUDE_DIR) ]
tester.args += self.project.get_build_option("CFLAGS").split()
tester.run()
if tester.stderr:
raise utils.PtpException(tester.stderr)
for t in self.types.values():
t.add_checks(tester)
for check in self.checks:
tester.add(check)
check = tester.run()
if check is not None:
check.throw_exception()
def load_area(element, project, net):
id = utils.xml_int(element, "id")
init_type, init_value = project.parse_init_expression(
element.get("init-expr"),
get_source(element, "init"))
if init_type is None:
raise utils.PtpException("Expression is empty", get_source(element, "init"))
places = [ net.get_place(utils.xml_int(e, "id"))
for e in element.findall("place") ]
return Area(net, id, init_type, init_value, places)
def check(self):
if self.library_octave:
import ptp # Import here to avoid cyclyc import
if ptp.get_config("Main", "OCTAVE") != "True":
raise utils.PtpException("Cannot build a module for Octave, "
"Kaira is not build with Octave support.\n"
"Run './waf configure' in Kaira root directory")
if self.get_build_with_octave():
import ptp # Import here to avoid cyclyc import
if ptp.get_config("Main", "OCTAVE") != "True":
raise utils.PtpException("Cannot build a project with Octave C++ API, "
"Kaira is not build with Octave support.\n"
"Run './waf configure' in Kaira root directory")
checker = self.target_env.get_checker(self)
for net in self.nets:
net.check(checker)
checker.run()
def parse_expression(expr, source, allow_empty):
if len(expr.strip()) == 0:
if allow_empty:
return None
else:
return "Missing expression"
try:
return full_expression.parseString(expr, parseAll=True)[0]
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def write_parameters_forward(builder):
builder.line("struct param")
builder.block_begin()
for p in builder.project.get_parameters():
if p.get_type() == "int":
builder.line("static ca::ParameterInt {0};", p.get_name())
elif p.get_type() == "double":
builder.line("static ca::ParameterDouble {0};", p.get_name())
elif p.get_type() == "std::string":
builder.line("static ca::ParameterString {0};", p.get_name())
else:
raise utils.PtpException("Invalid type '{0}' for parameter '{1}'".format(
p.get_type(), p.name))
builder.write_class_end()
def load_transition(element, project, net):
id = utils.xml_int(element, "id")
name = element.get("name")
guard = project.parse_expression(element.get("guard"),
get_source(element, "guard"),
allow_empty=True)
transition = Transition(net, id, name, guard)
transition.collective = utils.xml_bool(element, "collective", False)
transition.edges_in = map(
lambda e: load_edge_in(e, project, net, transition),
element.findall("edge-in"))
transition.edges_out = map(
lambda e: load_edge_out(e, project, net, transition),
element.findall("edge-out"))
if element.find("code") is not None:
transition.code = element.find("code").text
transition.trace_fire = element.find("trace") is not None
transition.clock = utils.xml_bool(element, "clock", False)
if transition.collective:
transition.root = project.parse_expression(element.get("root"),
get_source(element, "root"),
allow_empty=True)
if element.find("time-substitution") is not None:
transition.time_substitution = element.find("time-substitution").text
if element.find("clock-substitution") is not None:
transition.clock_substitution = element.find("clock-substitution").text
if element.find("verif-quit_flag") is not None:
transition.calls_quit = True
e = element.find("verif-occurrence")
if e is not None:
transition.occurrence_analysis = True
transition.occurrence_analysis_compare_process = utils.xml_bool(
e, "process")
transition.occurrence_analysis_compare_binding = utils.xml_bool(
e, "binding")
priority = element.get("priority").strip()
if priority == "":
transition.priority = 0
elif utils.is_integer(priority):
transition.priority = int(priority)
else:
raise utils.PtpException("Priority has to be integer or empty",
get_source(element, "priority"))
return transition
raise utils.PtpException(e.msg, source)
def parse_init_expression(string, source):
if string.strip() == "":
return (None, None)
try:
return init_expression.parseString(string, parseAll=True)[0]
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
def parse_edge_expression(string, source):
if len(string.strip()) == 0:
raise utils.PtpException("Missing expression", source)
try:
inscriptions = edge_expr.parseString(string, parseAll=True)
except pp.ParseException, e:
raise utils.PtpException(e.msg, source)
results = []
for configs, expr, target in inscriptions:
config = {}
for name, param in configs:
if name in config:
raise utils.PtpException(
"Configuration option '{0}' used more then once".format(name), source)
else:
config[name] = param
results.append((config, expr, target))
return results
def throw_exception(self):
raise utils.PtpException(self.message, self.source)
