find.calls(definition, name, expressions=T, replace=F)
TRUE,
name is sought only in the context
of a replacement; that is, as a function call immediately to the left of
a <- or <<-. If
replace is
FALSE,
name is
sought as a call only in other contexts.
expressions is
TRUE, a list of expressions from
definition; the
list components are calls to
name, or replacement assignments involving
name
, as
replace is
FALSE or
TRUE. If
expressions is
FALSE,
find.calls
just returns the number of such expressions found.
definition is examined recursively for function calls to
name.
Generally speaking, a call to
f in a function definition would be
treated as such by the evaluator. Replacement expressions are an
exception. The expression
f(x) <- value would conceptually be
evaluated as a call to the function f<-, not
f, but is represented
in a function definition as a call to
f on the left hand side of an
assignment. The flag
replace must be
TRUE if
find.calls should
treat this as a call to
f, in which event it will return the entire
assignment expression.
Except for the case of replacements,
find.calls will return only those
expressions which would be evaluated as function calls. This implies
that certain expressions which deparse (print) as apparent function
calls will not be counted. Examples of these include the
interfaces
.Internal and
.S (but not
.C and
.Fortran, which are true
calls), as well as hardcoded data that may deparse as a
call to
c,
list or
structure.
If many functions are going to be searched in a single top-level
expression, memory usage can be kept down by setting the
keep
option to
NULL and using
immediate=TRUE with the
get function.
See the help files for
options and
get.
find.calls(f, "[") # returns [-subscript extractions in f
find.calls(f, "[", replace=T) # returns [-subscript replacements in f
as.logical(find.calls(f, "g", expr=F)) # returns TRUE if f calls g
# find all functions on working database that call g:
old.keep <- options(keep=NULL)
for(i in objects()) {
obj <- get(i, where=1, immediate=T)
if(mode(obj) == "function" && find.calls(obj, "g", expr=F) != 0)
cat(i, "calls g\\n")
}
options(old.keep)
# find all functions called by f:
functions.called <- function(definition)
setdiff(all.names(definition, unique = T), all.names(definition,
functions = F, unique = T))
functions.called(f)