Пример #1
0
def get_target_parameter(rd_list, ri_list, rolearg):
    roleparam = None
    rd_iter = roledecllist_get_roledecl_children(rd_list).__iter__()
    for ri in roleinstantiationlist_get_children(ri_list):
        rd = rd_iter.next()
        if roleinstantiation_get_arg(ri) == rolearg:
            if roleinstantiation_get_parameter_child(ri):
                roleparam = roleinstantiation_get_parameter(ri)
            else:
                roleparam = roledecl_get_role_name(rd)
                # actually, this else case subsumes the first case
            break
    return roleparam
Пример #2
0
def project(projector, node_):
    context_ = projector.context
    rolearg = projector.role
    scope = get_scope(node_)
    target = get_target_full_name(context_, node_)
    gpd = context_.get_visible_global(target)
    #fullname = globalprotocoldecl.get_full_name(gpd)

    rd_list = globalprotocoldecl_get_roledecllist_child(gpd)
    ri_list = get_roleinstantiationlist_child(node_)
    roleparam = get_target_parameter(rd_list, ri_list, rolearg)

    if roleparam is None:
        return None
    else:
    #{
        roles = []
        rd_iter = roledecllist_get_roledecl_children(rd_list).__iter__()
        for ri in roleinstantiationlist_get_children(ri_list):
            rd = rd_iter.next()
            #roles.append(roleinstantiation_pretty_print(ri))  # FIXME: string hack (localdo)
            #tmp = projector.rolemap[roleinstantiation_get_arg(ri)]
            tmp = roleinstantiation_get_arg(ri)
            roles.append((tmp, roleinstantiation_get_parameter(ri)))

        args = []
        #pd_list = globalprotocoldecl_get_parameterdecllist_child(gpd)
        arglist = get_argumentlist_child(node_)
        ##for arg in argumentlist_get_argument_children(arglist):
        ##    args.append(argument_pretty_print(arg))
        #pd_iter = parameterdecllist_get_paramdecl_children(pd_list).__iter__()
        for arg in argumentlist_get_children(arglist):
            #pd = rd_iter.next()
            tmp = argument_get_arg(arg)
            args.append((tmp, argument_get_parameter(arg)))

        """members = context_.get_members()

        for arg in globaldo.getglobaldoArgsChildren(globel):
            if util.get_node_type(arg) == constants.MESSAGE_SIGNATURE_NODE_TYPE:
                for payload in payloadList.getpayloadChildren(messagesignature.getpayloadListChild(arg)):
                    alias = payload.getpayloadType(payload)
                    payloads[len(payloads)-1][alias] = context_.getpayloadTypes()[alias]

        if not((fqmn, param) in visited.keys()) or not(globalprotocoldecl.get_name(gpd) in visited[(fqmn, param)]):
            target = project(context_.get_source(fqmn), context_, fqmn, gpd, param)  # FIXME: only need to do for target parameter
        imports[len(imports)-1].add(fqmn + '_' + param)"""

        if target in context_.get_members():
            # Full member name of target was specified
            #module_ = util.get_full_module_name_from_full_member_name(target)
            #proto = util.get_simple_member_name_from_full_member_name(target)
            projectionname = get_projected_member_name(target, roleparam)
                # FIXME: factor out local projection name generation with import
                # decl projection
            #projector.add_subprotocol_reference(target, roleparam)
        else:
            # TODO: several cases, could be via simple name of co-module_
            # protocol, or full name via member alias or module_ alias, etc.
            #
            # One option is to project all references to be fully qualified
            # (dropping aliases even?)
            raise RuntimeError("[Projector] globaldo TODO: " + target)

        return projector.nf.localdo(#projector.rolemap[projector.role],
                                    projector.role,
                                    scope,
                                    projectionname,
                                    args,
                                    roles)