getting the arguments of a parent function in R, with names

Question

I'm trying to write a function that captures the arguments of the function it is called from. For example,

get_args <- function () as.list( sys.call(sys.parent()) )[-1]

caller <- function (x, y, z) {
    get_args()
}
caller(1,2,3)

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

sys.call() unfortunately does not add match parameter names with argument values, and I'd like to write a similar version of get_args that returns output similar to

caller2 <- function (x, y, z) {
    as.list( match.call() )[-1]
}
caller2(1,2,3)

$x
[1] 1

$y
[1] 2

$z
[1] 3

replacing "get_args()" with "match.call()" directly is not the solution I'm looking for, since in reality get_args will do some other things before returning its parent functions arguments.

I've tried to use match.call() with sys.parent() in several ways, but I can't get the function to return the arguments of caller; it just returns the arguments of get_args().

Is there any way to make get_args() return output identical to that of caller2 for the above test case? I know that naming the arguments manually is possible using formals(), but is this guaranteed to be equivelant?

If any clarification is needed, leave a comment below. Thanks.

EDIT 1:

the aim of get_args() is to act as a user-friendly way of getting the arguments with which a function was called. Typing as.list( match.call() )[-1] gets old, but because match.call grabs the nearest function call it just gets the arguments of get_args() at the moment.

get_args() will also get default arguments from the parent function, but this easy to implement.

SOLUTION:

thanks Hong Ooi, the key to using match.call seems to be providing both the call and the definition of the function you want to find out about. A slightly modified, anonymous-friendly version of get_args is below for posterity

get_args <- function () {
as.list( match.call(
    def = sys.function( -1 ),
    call = sys.call(-1)) )[-1]

}

This version finds the function further up the call stack, grabs its definition and call, and matches parameters to its arguments.

Answer 1

get_args <- function()
{
    cl <- sys.call(-1)
    f <- get(as.character(cl[[1]]), mode="function", sys.frame(-2))
    cl <- match.call(definition=f, call=cl)
    as.list(cl)[-1]
}

The key here is to set the definition argument to match.call to be get_arg's calling function. This should (hopefully!) work for the general case where get_args can be called from anywhere.