INSTALL                package:utils                R Documentation

_I_n_s_t_a_l_l _A_d_d-_o_n _P_a_c_k_a_g_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     Utility for installing add-on packages.

_U_s_a_g_e:

     R CMD INSTALL [options] [-l lib] pkgs

_A_r_g_u_m_e_n_t_s:

    pkgs: A space-separated list with the path names of the packages to
          be installed.

     lib: the path name of the R library tree to install to.

 options: a space-separated list of options through which in particular
          the process for building the help files can be controlled. 
          Options should only be given once. Use 'R CMD INSTALL --help'
          for the current list of options. 

_D_e_t_a_i_l_s:

     This will stop at the first error, so if you want all the 'pkgs'
     to be tried, call this via a shell 'for' or 'foreach' loop.

     If used as 'R CMD INSTALL pkgs' without explicitly specifying
     'lib', packages are installed into the library tree rooted at the
     first directory given in the environment variable 'R_LIBS' if this
     is set and non-null, and to the default library tree (which is
     rooted at '$R_HOME/library') otherwise.

     To install into the library tree 'lib', use 'R CMD INSTALL -l lib
     pkgs'.

     Both 'lib' and the elements of 'pkgs' may be absolute or relative
     path names of directories.  'pkgs' may also contain names of
     package/bundle archive files of the form 'pkg_version.tar.gz' as
     obtained from CRAN: these are then extracted in a temporary
     directory.  Finally, binary package/bundle archive files (as
     created by 'R CMD build --binary' can be supplied.

     Some package sources contain a 'configure' script that can be
     passed arguments or variables via the option '--configure-args'
     and '--configure-vars', respectively, if necessary.  The latter is
     useful in particular if libraries or header files needed for the
     package are in non-system directories.  In this case, one can use
     the configure variables 'LIBS' and 'CPPFLAGS' to specify these
     locations (and set these via '--configure-vars'), see section
     "Configuration variables" in "R Installation and Administration"
     for more information.  (If these are used more than once on the
     command line, only the last instance is used.)  One can bypass the
     configure mechanism using the option '--no-configure'.

     If '--no-docs' is given, no help files are built.  Options
     '--no-text', '--no-html', and '--no-latex' suppress creating the
     text, HTML, and LaTeX versions, respectively.  The default is to
     build help files in all three versions.

     If the attempt to install the package fails, leftovers are
     removed. If the package was already installed, the old version is
     restored. This happens either if a command encounters an error or
     if the install is interrupted from the keyboard: after cleaning up
     the script terminates.

     Use 'R CMD INSTALL --help' for more usage information.

_D_e_p_r_e_c_a_t_e_d _o_p_t_i_o_n_s:

     *The following options are deprecated:* use the 'DESCRIPTION'
     fields such as 'LazyLoad', 'LazyData' and 'SaveImage' instead.

     If the option '--save' is used, the installation procedure creates
     a binary image of the package code, which is then loaded when the
     package is attached, rather than evaluating the package source at
     that time.  Having a file 'install.R' in the package directory
     makes this the default behavior for the package (option
     '--no-save' overrides).  You may need  '--save' if your package
     requires other packages to evaluate its own source.  If the file
     'install.R' is non-empty, it should contain R expressions to be
     executed when the package is attached, after loading the saved
     image.  Options to be passed to R when creating the save image can
     be specified via '--save=ARGS'.

     Options '--lazy', '--no-lazy', '--lazy-data' and '--no-lazy-data'
     control where the R objects and the datasets are made available
     for lazy loading.  (These options are overridden by any values set
     in the 'DESCRIPTION' file.)  The default is '--no-lazy
     --no-lazy-data' except that lazy-loading is used for package with
     more than 25kB of R code and no saved image.

_P_a_c_k_a_g_e_s _u_s_i_n_g _t_h_e _m_e_t_h_o_d_s _p_a_c_k_a_g_e:

     Packages that require the methods package, and that use functions
     such as 'setMethod' or 'setClass', should be installed either
     (preferably) using lazy-loading or by creating a binary image.

     *The following mechanism is deprecated:* use the flags such as
     'LazyLoad' and 'SaveImage' instead. The presence of a file named
     'install.R' in the package's main directory causes an image to be
     saved.  Note that the file is not in the 'R' subdirectory: all the
     code in that subdirectory is used to construct the binary image.
     Normally, the file 'install.R' will be empty; if it does contain R
     expressions these will be evaluated when the package is attached,
     e.g. by a call to the function 'library'.  (Specifically, the
     source code evaluated for a package with a saved image consists of
     a suitable definition of '.First.lib' to ensure loading of the
     saved image, followed by the R code in file 'install.R', if any.)

_S_e_e _A_l_s_o:

     'REMOVE' and 'library' for information on using several library
     trees; 'update.packages' for automatic update of packages using
     the internet; the section on "Add-on packages" in "R Installation
     and Administration" and the chapter on "Creating R packages" in
     "Writing R Extensions" (see the 'doc/manual' subdirectory of the R
     source tree).

