Return an isolated entry of the receiver.

        Args:
            rval: Raw object to be used for the returned entry.
438271
def orphan_entry(self, rval: RawObject) -> "ArrayEntry":
        
        val = self.entry_from_raw(rval)
        return ArrayEntry(0, EmptyList(), EmptyList(), val, None, self,
                          val.timestamp)
1258786
private RValue[] packReturns(CallStack frame, Decl.Callable decl) {
		if (decl instanceof Decl.Property) {
			return new RValue[] { RValue.True };
		} else {
			Tuple<Decl.Variable> returns = decl.getReturns();
			RValue[] values = new RValue[returns.size()];
			for (int i = 0; i != values.length; ++i) {
				values[i] = frame.getLocal(returns.get(i).getName());
			}
			return values;
		}
	}
967357
def get_receiver(self, receiver=None, plugin=None):
        
        if plugin is not None:
            if receiver is None:
                receiver_list = {}
                for key in self.receivers.keys():
                    if self.receivers[key].plugin == plugin:
                        receiver_list[key] = self.receivers[key]
                return receiver_list
            else:
                if receiver in self.receivers.keys():
                    if self.receivers[receiver].plugin == plugin:
                        return self.receivers[receiver]
                    else:
                        return None
                else:
                    return None
        else:
            if receiver is None:
                return self.receivers
            else:
                if receiver in self.receivers.keys():
                    return self.receivers[receiver]
                else:
                    return None
98806
def get_receiver(self, receiver=None):
        
        return self.__app.signals.get_receiver(receiver, self._plugin)
195198
function(ctx)
{
   // sort keys
   var rval = {};
   var keys = Object.keys(ctx).sort();
   for(var k in keys)
   {
      var key = keys[k];
      rval[key] = ctx[key];
   }
   return rval;
}
519293
def receiver(url, **kwargs):
    
    res = url_to_resources(url)
    fnc = res["receiver"]
    return fnc(res.get("url"), **kwargs)
597241
def primitive(self):
        
        raw_container = raw.to_raw(self._navigable)

        # Collapsing the anonymous table onto the top-level container is present
        if '' in raw_container:
            raw_container.update(raw_container[''])
            del raw_container['']

        return raw_container
786581
def _Constructor(cls, ptr=_internal_guard):
    
    if ptr == _internal_guard:
        raise VLCException("(INTERNAL) ctypes class. You should get references for this class through methods of the LibVLC API.")
    if ptr is None or ptr == 0:
        return None
    return _Cobject(cls, ctypes.c_void_p(ptr))
121015
private ClassSymbol getReceiver(ExpressionTree tree, Symbol sym) {
    if (sym.isStatic() || sym instanceof ClassSymbol) {
      return sym.enclClass();
    }
    switch (tree.getKind()) {
      case MEMBER_SELECT:
      case METHOD_INVOCATION:
        Type receiver = ASTHelpers.getType(ASTHelpers.getReceiver(tree));
        if (receiver == null) {
          return null;
        }
        return receiver.tsym.enclClass();
      case IDENTIFIER:
        // Simple names are implicitly qualified by an enclosing instance, so if we get here
        // we're inside the compilation unit that declares the receiver, and the diff doesn't
        // contain accurate information.
        return null;
      default:
        return null;
    }
  }
279523
def __live_receivers(signal):
    
    with __lock:
        __purge()
        receivers = [funcref() for funcref in __receivers[signal]]

    return receivers
1276022
def from_raw(self, rval: RawObject, jptr: JSONPointer = "") -> ObjectValue:
        """"""
        if not isinstance(rval, dict):
            raise RawTypeError(jptr, "object")
        res = ObjectValue()
        for qn in rval:
            if qn.startswith("@"):
                if qn != "@":
                    tgt = qn[1:]
                    if tgt not in rval:
                        raise MissingAnnotationTarget(jptr, tgt)
                    jptr += '/' + tgt
                res[qn] = self._process_metadata(rval[qn], jptr)
            else:
                cn = self._iname2qname(qn)
                ch = self.get_data_child(*cn)
                npath = jptr + "/" + qn
                if ch is None:
                    raise RawMemberError(npath)
                res[ch.iname()] = ch.from_raw(rval[qn], npath)
        return res
131929
def p_funcdecl(p):
    
    if p[1] is None:
        p[0] = None
        return

    p[0] = p[1]
    p[0].local_symbol_table = SYMBOL_TABLE.table[SYMBOL_TABLE.current_scope]
    p[0].locals_size = SYMBOL_TABLE.leave_scope()
    FUNCTION_LEVEL.pop()
    p[0].entry.body = p[2]

    entry = p[0].entry
    entry.forwarded = False
696086
def returner(ret):
    '''
    
    '''
    signaled = dispatch.Signal(providing_args=['ret']).send(sender='returner', ret=ret)

    for signal in signaled:
        log.debug(
            'Django returner function \'returner\' signaled %s '
            'which responded with %s', signal[0], signal[1]
        )
1186988
def orphan_instance(self, rval: RawValue) -> "ObjectMember":
        
        val = self.from_raw(rval)
        return ObjectMember(self.iname(), {}, val, None, self, datetime.now())
1306217
def _get_initial_returning(self):
        

        hooker = None
        if self.is_syscall:
            hooker = self.project.simos.syscall_from_addr(self.addr)
        elif self.is_simprocedure:
            hooker = self.project.hooked_by(self.addr)
        if hooker and hasattr(hooker, 'NO_RET'):
            return not hooker.NO_RET

        # Cannot determine
        return None
369570
def _return_handler(self, ret_value, func, arguments):
        

        logger.debug('%s%s -> %r',
                     func.__name__, _args_to_str(arguments), ret_value,
                     extra=self._logging_extra)

        try:
            ret_value = StatusCode(ret_value)
        except ValueError:
            pass

        self._last_status = ret_value

        # The first argument of almost all registered visa functions is a session.
        # We store the error code per session
        session = None
        if func.__name__ not in ('viFindNext', ):
            try:
                session = arguments[0]
            except KeyError:
                raise Exception('Function %r does not seem to be a valid '
                                'visa function (len args %d)' % (func, len(arguments)))

            # Functions that use the first parameter to get a session value.
            if func.__name__ in ('viOpenDefaultRM', ):
                # noinspection PyProtectedMember
                session = session._obj.value

            if isinstance(session, integer_types):
                self._last_status_in_session[session] = ret_value
            else:
                # Functions that might or might have a session in the first argument.
                if func.__name__ not in ('viClose', 'viGetAttribute', 'viSetAttribute', 'viStatusDesc'):
                    raise Exception('Function %r does not seem to be a valid '
                                    'visa function (type args[0] %r)' % (func, type(session)))

        if ret_value < 0:
            raise errors.VisaIOError(ret_value)

        if ret_value in self.issue_warning_on:
            if session and ret_value not in self._ignore_warning_in_session[session]:
                warnings.warn(errors.VisaIOWarning(ret_value), stacklevel=2)

        return ret_value
57490
def get_by_slot(self, parent_object, slot):
        
        placeholder = self.parent(parent_object).get(slot=slot)
        placeholder.parent = parent_object  # fill the reverse cache
        return placeholder