Skip to Content

compile {compiler}

Byte Code Compiler
R 3.0.2


These functions provide an interface to a byte code compiler for R.


cmpfun(f, options = NULL)
compile(e, env = .GlobalEnv, options = NULL)
cmpfile(infile, outfile, ascii = FALSE, env = .GlobalEnv,
        verbose = FALSE, options = NULL)
loadcmp(file, envir = .GlobalEnv, chdir = FALSE)
getCompilerOption(name, options)


a closure.
list of named compiler options
the top level environment for the compiling.
pathnames; outfile defaults to infile with a .Rc extension in place of any existing extension.
logical; should the compiled file be saved in ascii format?
logical; should the compiler show what is being compiled
environment to evaluate loaded expressions in.
logical; change directory before evaluation?
byte code expression or compiled closure
expression to compile
integer; the JIT level to use
logical; enable compiling packages if TRUE
character string; name of option to return
named compiler options to set


The function cmpfun compiles the body of a closure and returns a new closure with the same formals and the body replaced by the compiled body expression.

compile compiles an expression into a byte code object; the object can then be evaluated with eval.

cmpfile parses the expression in infile, compiles them, and writes the compiled expressions to outfile. If outfile is not provided, it is formed from infile by replacing or appending a .Rc suffix.

loadcmp is used to load compiled files. It is similar to sys.source, except that its default loading environment is the global environment rather than the base environment.

disassemble produces a printed representation of the code that may be useful to give a hint of what is going on.

enableJIT enables or disables just-in-time (JIT) compilation. JIT is disabled if the argument is 0. If enable is 1 then closures are compiled before their first use. If enable is 2, then in addition closures are also compiled before they are duplicated (useful for some packages, like lattice, that store closures in lists). If enable is 3 then in addition all loops are compiled before they are executed. JIT can also be enabled by starting R with the environment variable R_ENABLE_JIT set to one of these values.

compilePKGS enables or disables compiling packages when they are installed. This requires that the package use lazy loading as compilation occurs as functions are written to the lazy loading data base. This can also be enabled by starting R with the environment variable R_COMPILE_PKGS set to a positive integer value.

Currently the compiler warns about a variety of things. It does this by using cat to print messages. Eventually this should use the condition handling mechanism.

The options argument can be used to control compiler operation. There are currently three options: optimize, suppressAll, and suppressUndefined. optimize specifies the optimization level, which can be an integer form 0 to 3. suppressAll should be a scalar logical; if TRUE no messages will be shown. suppressUndefined can be TRUE to suppress all messages about undefined variables, or it can be a character vector of the names of variables for which messages should not be shown.

getCompilerOption returns the value of the specified option. The default value is returned unless a value is supplied in the options argument; the options argument is primarily for internal use. setCompilerOption sets the default option values. It returns a named list of the previous values.

Calling the compiler a byte code compiler is actually a bit of a misnomer: the external representation of code objects currently uses int operands, and when compiled with gcc the internal representation is actually threaded code rather than byte code.


# a simple example
f <- function(x) x+1
fc <- cmpfun(f)
# old R version of lapply
la1 <- function(X, FUN, ...) {
    FUN <-
    if (!is.list(X))
    X <- as.list(X)
    rval <- vector("list", length(X))
    for(i in seq(along = X))
    rval[i] <- list(FUN(X[[i]], ...))
    names(rval) <- names(X)          # keep `names' !
# a small variation
la2 <- function(X, FUN, ...) {
    FUN <-
    if (!is.list(X))
    X <- as.list(X)
    rval <- vector("list", length(X))
    for(i in seq(along = X)) {
        v <- FUN(X[[i]], ...)
        if (is.null(v)) rval[i] <- list(v)
        else rval[[i]] <- v
    names(rval) <- names(X)          # keep `names' !
# Compiled versions
la1c <- cmpfun(la1)
la2c <- cmpfun(la2)
# some timings
x <- 1:10
y <- 1:100
system.time(for (i in 1:10000) lapply(x, is.null))
system.time(for (i in 1:10000) la1(x, is.null))
system.time(for (i in 1:10000) la1c(x, is.null))
system.time(for (i in 1:10000) la2(x, is.null))
system.time(for (i in 1:10000) la2c(x, is.null))
system.time(for (i in 1:1000) lapply(y, is.null))
system.time(for (i in 1:1000) la1(y, is.null))
system.time(for (i in 1:1000) la1c(y, is.null))
system.time(for (i in 1:1000) la2(y, is.null))
system.time(for (i in 1:1000) la2c(y, is.null))


Luke Tierney

Documentation reproduced from R 3.0.2. License: GPL-2.


Calimo's picture

For those who are (like me) wondering where they can find this package: it's included in the list of R's recommended packages, so all you have to do is library(compiler). No need to search on CRAN or elsewhere!