systemcall : DOLLER ID
13801
def p_systemcall_noargs(self, p):
        ''
        p[0] = SystemCall(p[2], (), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1256272
private synchronized String getCallerIdName10()
    {
        if (!callerIdCreated)
        {
            rawCallerId = request.get("callerid");
            callerIdCreated = true;
        }

        return AstUtil.parseCallerId(rawCallerId)[0];
    }
1140362
function(jid_or_user_id) {
        var jid;
        if (typeof jid_or_user_id === 'string') {
            jid = jid_or_user_id;
        } else if (typeof jid_or_user_id === 'number') {
            jid = jid_or_user_id + '-' + config.creds.appId + '@' + config.endpoints.chat;
        } else {
            throw new Error('The method "jidOrUserId" may take jid or id');
        }
        return jid;
    }
473208
@Override
  public final void setItsId(final IdUserRoleJetty pId) {
    this.itsId = pId;
    if (this.itsId == null) {
      this.itsUser = null;
      this.itsRole = null;
    } else {
      this.itsUser = this.itsId.getItsUser();
      this.itsRole = this.itsId.getItsRole();
    }
  }
835002
private Object invokeImpl(Object thiz, String name, Object... args)
            throws ScriptException, NoSuchMethodException {
        if (name == null) {
            throw new NullPointerException("method name is null");
        }

        try {
            if (thiz != null) {
                return InvokerHelper.invokeMethod(thiz, name, args);
            } else {
                return callGlobal(name, args);
            }
        } catch (MissingMethodException mme) {
            throw new NoSuchMethodException(mme.getMessage());
        } catch (Exception e) {
            throw new ScriptException(e);
        }
    }
554323
function (t, timerName) {
            if (this.enabled) {
                var id = _.uniqueId('jt');
                this._startDate[id] = t || (+new Date());
                if (console.profile && timerName) {
                    this._timerConsoleName[id] = timerName;
                    console.profile(timerName);
                }
                return id;
            }
        }
4284
def _get_caller_supplement(caller, data):
    
    if caller == "mutect":
        icaller = tz.get_in(["config", "algorithm", "indelcaller"], data)
        if icaller:
            caller = "%s/%s" % (caller, icaller)
    return caller
1166026
function getCaller(req) {
        var ipAddress = req.headers['x-forwarded-for'] || req.info.remoteAddress || '';
        var user = req.user;

        if (user) {

            // if user admin and there is an onBehalfOf value then use onBehalfOf
            if (user.role === 'admin' && req.query.onBehalfOfId) {
                return {
                    _id:    req.query.onBehalfOfId,
                    name:   req.query.onBehalfOfName,
                    role:   req.query.onBehalfOfRole,
                    type:   req.query.onBehalfOfType,
                    ipAddress: ipAddress
                };
            }

            // else return user data as caller info
            return {
                _id:    user._id,
                name:   user.username,
                role:   user.role,
                type:   'user',
                user:   user,
                ipAddress: ipAddress
            };

        }
        else if (req.deviceId) {
            return {
                _id:    req.deviceId,
                name:   req.deviceId,
                role:   'device',
                type:   'device',
                ipAddress: ipAddress
            };
        }
        // if no other auth, but GET then defer to fakeblock ACL level security
        //else if (req.method === 'get' || req.method === 'options') {
        else {
            return {
                _id:    'unknown',
                name:   'unknown',
                role:   'visitor',
                type:   'visitor',
                ipAddress: ipAddress
            };
        }
    }
310784
@SuppressWarnings("unused") // called in SoyFileParser.jj
  public static final String calculateFullCalleeName(
      Identifier ident, SoyFileHeaderInfo header, ErrorReporter errorReporter) {

    String name = ident.identifier();
    switch (ident.type()) {
      case DOT_IDENT:
        // Case 1: Source callee name is partial.
        return header.getNamespace() + name;
      case DOTTED_IDENT:
        // Case 2: Source callee name is a proper dotted ident, which might start with an alias.
        return header.resolveAlias(name);
      case SINGLE_IDENT:
        // Case 3: Source callee name is a single ident (not dotted).
        if (header.hasAlias(name)) {
          // Case 3a: This callee collides with a namespace alias, which likely means the alias
          // incorrectly references a template.
          errorReporter.report(ident.location(), CALL_COLLIDES_WITH_NAMESPACE_ALIAS, name);
        } else {
          // Case 3b: The callee name needs a namespace.
          errorReporter.report(ident.location(), MISSING_CALLEE_NAMESPACE, name);
        }
        return name;
    }
    throw new AssertionError(ident.type());
  }
28845
private Object internal_call(String method, String actual_objectId, int flags, boolean checkMethodName, Object... parameters) throws PickleException, PyroException, IOException {
		if(actual_objectId==null) actual_objectId=this.objectid;
		synchronized (this) {
			connect();
			sequenceNr=(sequenceNr+1)&0xffff;		// stay within an unsigned short 0-65535
		}
		if(pyroAttrs.contains(method)) {
			throw new PyroException("cannot call an attribute");
		}
		if(pyroOneway.contains(method)) {
			flags |= Message.FLAGS_ONEWAY;
		}
		if(checkMethodName && Config.METADATA && !pyroMethods.contains(method)) {
			throw new PyroException(String.format("remote object '%s' has no exposed attribute or method '%s'", actual_objectId, method));
		}
		if (parameters == null)
			parameters = new Object[] {};
		PyroSerializer ser = PyroSerializer.getFor(Config.SERIALIZER);
		byte[] pickle = ser.serializeCall(actual_objectId, method, parameters, Collections.emptyMap());
		Message msg = new Message(Message.MSG_INVOKE, pickle, ser.getSerializerId(), flags, sequenceNr, annotations(), pyroHmacKey);
		Message resultmsg;
		synchronized (this.sock) {
			IOUtil.send(sock_out, msg.to_bytes());
			if(Config.MSG_TRACE_DIR!=null) {
				Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data);
			}
			pickle = null;

			if ((flags & Message.FLAGS_ONEWAY) != 0)
				return null;

			resultmsg = Message.recv(sock_in, new int[]{Message.MSG_RESULT}, pyroHmacKey);
		}
		if (resultmsg.seq != sequenceNr) {
			throw new PyroException("result msg out of sync");
		}
		responseAnnotations(resultmsg.annotations, resultmsg.type);
		if ((resultmsg.flags & Message.FLAGS_COMPRESSED) != 0) {
			_decompressMessageData(resultmsg);
		}
		if ((resultmsg.flags & Message.FLAGS_ITEMSTREAMRESULT) != 0) {
			byte[] streamId = resultmsg.annotations.get("STRM");
			if(streamId==null)
				throw new PyroException("result of call is an iterator, but the server is not configured to allow streaming");
			return new PyroProxy.StreamResultIterable(new String(streamId), this);
		}
		if ((resultmsg.flags & Message.FLAGS_EXCEPTION) != 0) {
			Throwable rx = (Throwable) ser.deserializeData(resultmsg.data);
			if (rx instanceof PyroException) {
				throw (PyroException) rx;
			} else {
				PyroException px;

				// if the source was a PythonException, copy its message and python exception type
				if(rx instanceof PythonException) {
					PythonException rxp = (PythonException)rx;
					px = new PyroException(rxp.getMessage(), rxp);
					px.pythonExceptionType = rxp.pythonExceptionType;
				} else {
					px = new PyroException(null, rx);
				}

				try {
					Field remotetbField = rx.getClass().getDeclaredField("_pyroTraceback");
					String remotetb = (String) remotetbField.get(rx);
					px._pyroTraceback = remotetb;
				} catch (Exception e) {
					// exception didn't provide a pyro remote traceback
				}
				throw px;
			}
		}
		return ser.deserializeData(resultmsg.data);
	}
446326
private static Node checkUserIdentifier(final FormItemList formItemList,
			final CreateFollowResponse createFollowResponse) {
		final String userId = formItemList
				.getField(ProtocolConstants.Parameters.Create.Follow.USER_IDENTIFIER);
		if (userId != null) {
			final Node user = NeoUtils.getUserByIdentifier(userId);
			if (user != null) {
				return user;
			}

			createFollowResponse.userIdentifierInvalid(userId);
		} else {
			createFollowResponse.userIdentifierMissing();
		}

		return null;
	}
1360609
def getCall(self, n): #pylint: disable=invalid-name
        
        call_list = super(SinonSpy, self)._get_wrapper().call_list
        if n >= 0 and n < len(call_list):
            call = call_list[n]
            call.proxy = weakref.proxy(self)
            return call
        else:
            return None
94251
def get_id(self):
        '''
        
        '''
        if self._dxid is not None:
            return self._dxid
        else:
            return 'app-' + self._name + '/' + self._alias
1257745
def user_call(self, frame, argument_list):
        """"""
        if self.stop_here(frame):
            pdb.Pdb.user_call(self, frame, argument_list)
1014168
def call_name_is(siter, name):
    """"""
    return (
        isinstance(siter, ast.Call)
        and hasattr(siter.func, 'attr')
        and siter.func.attr == name
    )
1361406
def call(self, name, *a):
        """"""
        return callJavaFunc(self._sc, getattr(self._java_model, name), *a)
946046
def usable_id(cls, id, datacenter=None):
        
        try:
            qry_id = int(id)
        except Exception:
            # if id is a string, prefer a system disk then a label
            qry_id = cls.from_sysdisk(id) or cls.from_label(id, datacenter)

        if not qry_id:
            msg = 'unknown identifier %s' % id
            cls.error(msg)

        return qry_id