is returned to the caller.
960550
public synchronized Object put(Object key, Object value) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINER)) {
            //PM16861 Modified trace statement by removing toString of session object to avoid deadlock
            StringBuffer sb = new StringBuffer("key=").append(key);
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[PUT], sb.toString());
        }

        if (maxSize == 0)
            return null;

        CacheEntryWrapper currEntry;
        CacheEntryWrapper oldestEntry = null;

        // See if entry exists
        currEntry = (CacheEntryWrapper) super.get(key);

        if (currEntry == null) { // need new entry
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[PUT], "Doesn't exist in HashMap");
            }

            currentSize++;
            if (_iStoreCallback != null) {
                _iStoreCallback.sessionLiveCountInc(value);
            }

            if (currentSize > maxSize) {
                // too many entries, remove the oldest
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[PUT], "Too Many Entries.. Remove the oldest entry: " + lru.key);
                }
                oldestEntry = (CacheEntryWrapper) removeGuts(lru.key);
                if (_iStoreCallback != null) {
                    _iStoreCallback.sessionCacheDiscard(oldestEntry.value);
                }
            }

            currEntry = new CacheEntryWrapper();
            currEntry.key = key;
            currEntry.value = value;

            currEntry.next = mru;
            if (mru != null)
                mru.prev = currEntry;
            else
                lru = currEntry;
            mru = currEntry;

            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[PUT], "Adding new entry to the map");
            }

        }

        else { // found entry

            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[PUT], "Key already in use .. Reuse the entry");
            }

            updateCacheList(key);
            currEntry.value = value;
        }

        Object replacedEntry = super.put(key, currEntry);

        if (oldestEntry != null) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                //PM16861
                LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[PUT], "Returning object associated with this key: " + oldestEntry.key);
            }
            return oldestEntry.value;
        }
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[PUT], null);
        }
        return null;
    }
591017
public static function caller ( )
	{
		$backtrace = V(debug_backtrace());

		foreach ($backtrace as $line) {
			$line = A($line);

			if ($line->class === 'Bacon\Log') continue;

			return A([
				'class'  => $line->class,
				'file'   => $line->file,
				'method' => $line->function,
				'object' => $line->object
			]);
		}

		/*
		if (isset($backtrace[2]['class'])) {
			return $backtrace[2]['class'];
		} elseif (isset($backtrace[2]['file'])) {
			return $backtrace[2]['file'];
		} else {
			return $backtrace[0]['file'];
		}
		 */
	}
230199
def call(self, *args, **kwargs):
        
        args, kwargs = self.__process__(*args, **kwargs)
        return check_call(args, **kwargs)
727743
def call_or_yield(object)
      caller_method = caller_locations(1,1)[0].label
      if object.respond_to?(caller_method)
        object.public_send(caller_method)
      else
        yield
      end
    end
656543
private Entry<K, V> returnEntry(final Entry<K, V> e) {
    touchEntry(e.getKey());
    return e;
  }
733015
def _get_caller(self, callers: List[str], function: str) -> str:
        
        is_next = False
        for c in callers:
            if is_next is True:
                return c
            if function == c:
                is_next = True
663695
def caller(self, fun, **kwargs):
        '''
        
        '''
        self.client_cache['caller'].cmd(fun, *kwargs['arg'], **kwargs['kwarg'])
891776
def Call(self, Id=0):
        
        o = Call(self, Id)
        o.Status # Test if such a call exists.
        return o
409307
public function getReturned()
    {
        $ret = $this->_returnData;

        // noone needs the responseFingerprintOrder and responseFingerprint in the shop.
        if (array_key_exists('responseFingerprintOrder', $ret)) {
            unset( $ret['responseFingerprintOrder'] );
        }

        if (array_key_exists('responseFingerprint', $ret)) {
            unset( $ret['responseFingerprint'] );
        }

        return $ret;
    }
797554
private function _processReturn() {
		// If not an empty return (no value before the semicolon)
		if (!$this->tokenizer->checkNextValidToken(T_SEMICOLON)) {
			// Remember that the current function does return something (for PHPDoc)
			$this->_functionReturns = true;
		}

		// Search for unused code after the return
		$this->_checkUnusedCode('RETURN');
	}
909156
def and_after_calling_original
      self.and_wrap_original do |m, *args, &block|
        result = m.call(*args, &block)
        yield result
        result
      end
    end
966662
def call_eval(self, value, caller, return_value=True, **kwargs):
        
        value = self.name_to_system_object(value)
        if return_value and isinstance(value, AbstractStatusObject):
            return value.status
        if hasattr(value, 'call'):
            return self.call_eval(value.call(caller, **kwargs), caller, return_value, **kwargs)
        else:
            return value
496561
function getReturnContext(state) {
    let context = state.tryContext;

    while (context) {
        if (context.hasFinalizer && context.position !== "finally") {
            return context;
        }
        context = context.upper;
    }

    return state;
}
403897
def _handleCallAnswered(self, regexMatch, callId=None):
        
        if regexMatch:
            groups = regexMatch.groups()
            if len(groups) > 1:
                callId = int(groups[0])
                self.activeCalls[callId].answered = True
            else:
                # Call ID not available for this notificition - check for the first outgoing call that has not been answered
                for call in dictValuesIter(self.activeCalls):
                    if call.answered == False and type(call) == Call:
                        call.answered = True
                        return
        else:
            # Use supplied values
            self.activeCalls[callId].answered = True
1126132
def call(self, input_data=None, *args, **kwargs):
        
        self.build_request(input_data)
        self.caller = RequestCall(self.request)
        self.exception = None

        try:
            self.caller.call()
            self.response = self.caller.response
            self.decrypt_result()
            return self.decrypted

        except Exception as e:
            self.exception = e
            logger.info("Exception throw %s", e)
        pass
1245412
def callRemote(self, *a, **kw):
        
        if not self.running:
            return defer.fail(ServiceStopped())
        return self.clientFactory.callRemote(*a, **kw)
315665
def _call(self, method, url, params):
        """"""
        request_params = {}
        if method == 'GET':
            request_params['params'] = params
        elif method == 'POST':
            request_params['data'] = params
        response = requests.request(method, url, **request_params)
        return response