def _project_all(context_):
for _, module_ in context_.get_modules().items():
clone = context_.set_current_module(module_get_full_name(module_))
clone = build_visibility(clone, module_)
for (proto, gpd) in clone.get_visible_globals().items():
full_global_name = globalprotocoldecl_get_full_name(gpd)
rdl = globalprotocoldecl_get_roledecllist_child(gpd)
#rolemap = roledecllist_get_rolemap(rdl)
#for role_ in globalprotocoldecl_get_role_names(gpd):
for rd in roledecllist_get_roledecl_children(rdl):
dname = roledecl_get_declaration_name(rd)
role_ = roledecl_get_role_name(rd)
full_local_name = globaldo_get_projected_member_name(
full_global_name, role_)
#full_global_name, rolemap[role_])
if context_.has_projection(full_local_name):
break
projector = Projector()
lpd = projector.project_globalprotocoldecl(clone, gpd, dname)#, rolemap)
#full_name = lpd.get_full_name(clone)
context_ = context_.add_projection(full_local_name, lpd)
#print "Projected", full_global_name, "for", role_ + ":\n", \
# lpd.pretty_print()
return context_
def _output_projections_to_modules(context_, target_globalname, localrole, dir):
members = context_.get_members()
if target_globalname not in members.keys():
util.report_error("[Projection] Unknown protocol: " + \
target_globalname) #+ ", " + str(members))
gpd = context_.get_member(target_globalname)
if util.get_node_type(gpd) != constants.GLOBAL_PROTOCOL_DECL_NODE_TYPE:
util.report_error("[Projection] Not a global protocol declaration: " +
target_globalname)
if localrole not in globalprotocoldecl_get_role_names(gpd):
util.report_error("[Projection] Projection role not declared: " + localrole)
target_localname = globaldo_get_projected_member_name(target_globalname,
localrole)
todo = [target_localname]
lpd = context_.get_projection(target_localname)
subprotos = SubprotocolCollector(context_).collect_subprotocols(lpd, True)
todo.extend(subprotos)
# Includes target_globalname (even if not used recursively)
# Write each subprotocol to a separately projected module
for subproto in todo:
globalmodulename = \
util.get_global_module_name_from_projected_member_name(subproto)
# FIXME: not working if member/role names contain underscores; but
# good to run subprotocol collection on local protocol. best way may
# be to record a mapping between projected names and the global/role
# names they come from
globalmodule = context_.get_module(globalmodulename)
projector = Projector()
lm = projector.project_module(context_, globalmodule, subproto, todo)
# subproto is the full local name
lm = lm.addlocalprotocoldecl(context_.get_projection(subproto))
fmn = lm.get_full_name()
filepath = None
if dir is None:
# FIXME: factor out with e.g. globaldo and importmodule projection
filename = util.get_simple_module_name_from_full_module_name(fmn) \
+ '.' + constants.SCRIBBLE_FILE_EXTENSION
sp = context_.get_source(globalmodulename)
filepath = util.parse_directory_from_filepath(sp) + '/' + filename
# FIXME: double slashes being introduced somewhere
else:
filepath = dir + '/' + \
util.convert_full_module_name_to_filepath(fmn)
_write_module(lm, filepath)
"""print '[DEBUG] Projection of ' + target_globalname + ' for ' + \
class WellformednessChecker(ContextVisitor):
rc = RoleCollector(
) # Here because inconvenient to import in the ast modules
projector = Projector()
def __init__(self, context_):
super(WellformednessChecker, self).__init__(context_)
# Recursive traversal, although some nodes are visited "early" (before going
# into the children) e.g. sequencing
def check_wellformedness(self, node_):
return self.visit(node_)
"""def create_reachability_checker(self, role_):
context_ = self.get_context().parent # MODULE
#context_ = context_.push_globalprotocoldecl(gpd) # FIXME (local)
#context_ = context_.push_globalprotocoldef(globalprotocoldecl_get_child(gpd))
# HACK: mangling visible global names in place -- better to remove
# globals and add to locals?
for g in context_._visible_globals.keys():
projectionname = globaldo_get_projected_member_name(g, role_)
context_ = context_.rename_visible_global(g, projectionname)
return ReachabilityChecker(context_)"""
def clone(self):
clone = self.get_context().clone()
return WellformednessChecker(clone)
def _enter_module(self, node_):
module_check_wellformedness_enter(self, node_)
def _context_visit_module(self, node_):
return module_check_wellformedness_visit(self, node_)
def _leave_module(self, node_):
module_check_wellformedness_leave(self, node_)
def _enter_moduledecl(self, node_):
moduledecl_check_wellformedness_enter(self, node_)
def _context_visit_moduledecl(self, node_):
return moduledecl_check_wellformedness_visit(self, node_)
def _leave_moduledecl(self, node_):
moduledecl_check_wellformedness_leave(self, node_)
def _enter_importmodule(self, node_):
importmodule_check_wellformedness_enter(self, node_)
def _context_visit_importmodule(self, node_):
return importmodule_check_wellformedness_visit(self, node_)
def _leave_importmodule(self, node_):
importmodule_check_wellformedness_leave(self, node_)
def _enter_payloadtypedecl(self, node_):
payloadtypedecl_check_wellformedness_enter(self, node_)
def _context_visit_payloadtypedecl(self, node_):
return payloadtypedecl_check_wellformedness_visit(self, node_)
def _leave_payloadtypedecl(self, node_):
payloadtypedecl_check_wellformedness_leave(self, node_)
def _enter_roledecllist(self, node_):
roledecllist_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_roledecllist(node_)
def _context_visit_roledecllist(self, node_):
return roledecllist_check_wellformedness_visit(self, node_)
def _leave_roledecllist(self, node_):
super(WellformednessChecker, self)._leave_roledecllist(node_)
roledecllist_check_wellformedness_leave(self, node_)
def _enter_parameterdecllist(self, node_):
parameterdecllist_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_parameterdecllist(node_)
def _context_visit_parameterdecllist(self, node_):
return parameterdecllist_check_wellformedness_visit(self, node_)
def _leave_parameterdecllist(self, node_):
super(WellformednessChecker, self)._leave_parameterdecllist(node_)
parameterdecllist_check_wellformedness_leave(self, node_)
# Contract is that the checker should first see the original context, and then
# we push the new scope
#
# Need to check well-formedness first before updating the context state
#
# Other ContextVisitor subclasses (run on a later pass after WF checker, and
# only need to see the result of context building) may do the other way around
#
# A better approach may be to record the contexts on the nodes for later passes
# (Context building vs. visiting)
#
# choice, recursion, etc. will follow this pattern
def _enter_globalprotocoldecl(self, node_):
globalprotocoldecl_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalprotocoldecl(node_)
def _context_visit_globalprotocoldecl(self, node_):
return globalprotocoldecl_check_wellformedness_visit(self, node_)
def _leave_globalprotocoldecl(self, node_):
super(WellformednessChecker, self)._leave_globalprotocoldecl(node_)
globalprotocoldecl_check_wellformedness_leave(self, node_)
def _enter_globalprotocoldef(self, node_):
globalprotocoldef_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalprotocoldef(node_)
def _context_visit_globalprotocoldef(self, node_):
return globalprotocoldef_check_wellformedness_visit(self, node_)
def _leave_globalprotocoldef(self, node_):
super(WellformednessChecker, self)._leave_globalprotocoldef(node_)
globalprotocoldef_check_wellformedness_leave(self, node_)
def _enter_globalprotocolblock(self, node_):
globalprotocolblock_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalprotocolblock(node_)
def _context_visit_globalprotocolblock(self, node_):
return globalprotocolblock_check_wellformedness_visit(self, node_)
def _leave_globalprotocolblock(self, node_):
super(WellformednessChecker, self)._leave_globalprotocolblock(node_)
globalprotocolblock_check_wellformedness_leave(self, node_)
def _enter_globalinteractionsequence(self, node_):
globalinteractionsequence_check_wellformedness_enter(self, node_)
super(WellformednessChecker,
self)._enter_globalinteractionsequence(node_)
def _context_visit_globalinteractionsequence(self, node_):
return globalinteractionsequence_check_wellformedness_visit(
self, node_)
def _leave_globalinteractionsequence(self, node_):
super(WellformednessChecker,
self)._leave_globalinteractionsequence(node_)
globalinteractionsequence_check_wellformedness_leave(self, node_)
def _enter_globalmessagetransfer(self, node_):
globalmessagetransfer_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalmessagetransfer(node_)
def _context_visit_globalmessagetransfer(self, node_):
return globalmessagetransfer_check_wellformedness_visit(self, node_)
def _leave_globalmessagetransfer(self, node_):
super(WellformednessChecker, self)._leave_globalmessagetransfer(node_)
globalmessagetransfer_check_wellformedness_leave(self, node_)
def _enter_globalchoice(self, node_):
globalchoice_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalchoice(node_)
def _context_visit_globalchoice(self, node_):
return globalchoice_check_wellformedness_visit(self, node_)
def _leave_globalchoice(self, node_):
super(WellformednessChecker, self)._leave_globalchoice(node_)
globalchoice_check_wellformedness_leave(self, node_)
def _enter_globalrecursion(self, node_):
globalrecursion_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalrecursion(node_)
def _context_visit_globalrecursion(self, node_):
return globalrecursion_check_wellformedness_visit(self, node_)
def _leave_globalrecursion(self, node_):
super(WellformednessChecker, self)._leave_globalrecursion(node_)
globalrecursion_check_wellformedness_leave(self, node_)
def _enter_globalcontinue(self, node_):
globalcontinue_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalcontinue(node_)
def _context_visit_globalcontinue(self, node_):
return globalcontinue_check_wellformedness_visit(self, node_)
def _leave_globalcontinue(self, node_):
super(WellformednessChecker, self)._leave_globalcontinue(node_)
globalcontinue_check_wellformedness_leave(self, node_)
def _enter_globalparallel(self, node_):
globalparallel_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalparallel(node_)
def _context_visit_globalparallel(self, node_):
return globalparallel_check_wellformedness_visit(self, node_)
def _leave_globalparallel(self, node_):
super(WellformednessChecker, self)._leave_globalparallel(node_)
globalparallel_check_wellformedness_leave(self, node_)
def _enter_globalinterruptible(self, node_):
globalinterruptible_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globalinterruptible(node_)
def _context_visit_globalinterruptible(self, node_):
return globalinterruptible_check_wellformedness_visit(self, node_)
def _leave_globalinterruptible(self, node_):
super(WellformednessChecker, self)._leave_globalinterruptible(node_)
globalinterruptible_check_wellformedness_leave(self, node_)
def _enter_globaldo(self, node_):
globaldo_check_wellformedness_enter(self, node_)
super(WellformednessChecker, self)._enter_globaldo(node_)
def _context_visit_globaldo(self, node_):
return globaldo_check_wellformedness_visit(self, node_)
def _leave_globaldo(self, node_):
super(WellformednessChecker, self)._leave_globaldo(node_)
globaldo_check_wellformedness_leave(self, node_)
