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_)